chore: process characters with indexOf insead of one-by-one

Author: trivikr

packages/util-endpoints/src/utils/evaluateTemplate.spec.ts

@@ -13,11 +13,14 @@ describe(evaluateTemplate.name, () => {
     jest.clearAllMocks();
   });
 
-  it("should escape tilde while processing expression", () => {
-    const template = "foo `bar` baz";
-    // This test verifies that tilde is unescaped after processing.
-    expect(evaluateTemplate(template, mockOptions)).toBe(template);
-    expect(getAttr).not.toHaveBeenCalled();
+  it("should not escape template with empty parameter", () => {
+    const templateWithEmptyParam = "foo {} bar";
+    expect(evaluateTemplate(templateWithEmptyParam, mockOptions)).toEqual(templateWithEmptyParam);
+  });
+
+  it("should not escape template without braces", () => {
+    const templateWithoutBraces = "foo bar baz";
+    expect(evaluateTemplate(templateWithoutBraces, mockOptions)).toEqual(templateWithoutBraces);
   });
 
   describe("should replace `{parameterName}` with value", () => {
@@ -33,7 +36,7 @@ describe(evaluateTemplate.name, () => {
     });
   });
 
-  it("should not replace string escaped {{value}}", () => {
+  it("should escape values within double braces like {{value}}", () => {
     const value = "bar";
     expect(evaluateTemplate("foo {{value1}} bar {{value2}} baz", { ...mockOptions, endpointParams: { value } })).toBe(
       "foo {value1} bar {value2} baz"
@@ -56,4 +59,15 @@ describe(evaluateTemplate.name, () => {
     expect(getAttr).toHaveBeenNthCalledWith(1, ref1, "key1");
     expect(getAttr).toHaveBeenNthCalledWith(2, ref2, "key2");
   });
+
+  describe("should not change template with incomplete braces", () => {
+    it.each([
+      "incomplete opening bracket '{' in template",
+      "incomplete closing bracket '}' in template",
+      "incomplete opening escape '{{' in template",
+      "incomplete closing escape '}}' in template",
+    ])("%s", (template) => {
+      expect(evaluateTemplate(template, mockOptions)).toEqual(template);
+    });
+  });
 });

packages/util-endpoints/src/utils/evaluateTemplate.ts

@@ -2,43 +2,54 @@ import { getAttr } from "../lib";
 import { EvaluateOptions } from "../types";
 
 export const evaluateTemplate = (template: string, options: EvaluateOptions) => {
-  const evaluatedTemplateArr: Array<String> = [];
+  const evaluatedTemplateArr: string[] = [];
 
   const templateContext = {
     ...options.endpointParams,
     ...options.referenceRecord,
   } as Record<string, string>;
 
-  for (let i = 0; i < template.length; i++) {
-    const char = template[i];
-    const nextChar = template[i + 1];
+  let currentIndex = 0;
+  while (true) {
+    const openingBraceIndex = template.indexOf("{", currentIndex);
 
-    if (char === "{") {
-      if (nextChar === "{") {
-        // Escaped expression, skip next char
-        i++;
-        evaluatedTemplateArr.push(char);
-      } else {
-        const closingBraceIndex = template.indexOf("}", i);
-        const parameterName = template.substring(i + 1, closingBraceIndex);
+    if (openingBraceIndex === -1) {
+      // No more opening braces, add the rest of the template and break
+      evaluatedTemplateArr.push(template.slice(currentIndex));
+      break;
+    } else {
+      evaluatedTemplateArr.push(template.slice(currentIndex, openingBraceIndex));
+      const closingBraceIndex = template.indexOf("}", openingBraceIndex);
 
-        if (parameterName.includes("#")) {
-          const [refName, attrName] = parameterName.split("#");
-          evaluatedTemplateArr.push(getAttr(templateContext[refName], attrName) as string);
-        } else {
-          evaluatedTemplateArr.push(templateContext[parameterName]);
-        }
+      if (closingBraceIndex === -1) {
+        // Invalid template, but pass as it is.
+        evaluatedTemplateArr.push(template.slice(openingBraceIndex));
+        break;
+      }
 
-        i = closingBraceIndex;
+      if (closingBraceIndex === openingBraceIndex + 1) {
+        // Empty parameter, pass as it is.
+        evaluatedTemplateArr.push(template.slice(openingBraceIndex, closingBraceIndex + 1));
+        currentIndex = closingBraceIndex + 1;
+        continue;
       }
-    } else if (char === "}") {
-      if (nextChar === "}") {
-        // Escaped expression, skip next char
-        i++;
+
+      if (template[openingBraceIndex + 1] === "{" && template[closingBraceIndex + 1] === "}") {
+        // Escaped expression. Do not evaluate.
+        evaluatedTemplateArr.push(template.slice(openingBraceIndex + 1, closingBraceIndex));
+        currentIndex = closingBraceIndex + 2;
       }
-      evaluatedTemplateArr.push(char);
-    } else {
-      evaluatedTemplateArr.push(char);
+
+      const parameterName = template.substring(openingBraceIndex + 1, closingBraceIndex);
+
+      if (parameterName.includes("#")) {
+        const [refName, attrName] = parameterName.split("#");
+        evaluatedTemplateArr.push(getAttr(templateContext[refName], attrName) as string);
+      } else {
+        evaluatedTemplateArr.push(templateContext[parameterName]);
+      }
+
+      currentIndex = closingBraceIndex + 1;
     }
   }