fix: interpolation should ignore strings outside variables with same

names

Author: vanska

.changeset/cold-experts-work.md

@@ -0,0 +1,5 @@
+---
+"typed-string-interpolation": patch
+---
+
+Fixes issue #8 where variable keys were also replaced outside variables

src/__tests__/stringInterpolation.test.ts

@@ -1,35 +1,35 @@
-import { stringInterpolation } from "../index"
+import { stringInterpolation } from "../index";
 
 describe("stringInterpolation()", () => {
   test("Empty", () => {
     expect(() => {
       stringInterpolation("", {
         world: "world",
-      })
-    }).toThrow("Empty string")
-  })
+      });
+    }).toThrow("Empty string");
+  });
   test("Incorrect variable count", () => {
     expect(() => {
       stringInterpolation("Hello {{world}}", {
         world: "world with varialbe",
         extraVariable: "this is unnecessary",
-      })
-    }).toThrow("Variable count mismatch")
-  })
+      });
+    }).toThrow("Variable count mismatch");
+  });
   test("Variable not found", () => {
     expect(() =>
       stringInterpolation("Hello {{world}}", {
         wrongVariable: "world",
       })
-    ).toThrow("Variable 'world' not found")
-  })
+    ).toThrow("Variable 'world' not found");
+  });
   test("Interpolate single variable", () => {
     expect(
       stringInterpolation("Hello {{world}}", {
         world: "world with variable",
       })
-    ).toBe("Hello world with variable")
-  })
+    ).toBe("Hello world with variable");
+  });
   test("Interpolate single variable and return raw result with passed in option", () => {
     expect(
       stringInterpolation(
@@ -39,16 +39,16 @@ describe("stringInterpolation()", () => {
         },
         { raw: true }
       )
-    ).toStrictEqual(["Hello ", "world with variable"])
-  })
+    ).toStrictEqual(["Hello ", "world with variable"]);
+  });
   test("Interpolate two variables", () => {
     expect(
       stringInterpolation("Hello {{world}} and {{anotherVariable}}", {
         world: "world with variable",
         anotherVariable: "another variable",
       })
-    ).toBe("Hello world with variable and another variable")
-  })
+    ).toBe("Hello world with variable and another variable");
+  });
   test("Interpolation variable contains a function", () => {
     expect(
       stringInterpolation("Hello {{world}} and {{anotherVariable}}", {
@@ -60,6 +60,11 @@ describe("stringInterpolation()", () => {
       "world with variable",
       " and ",
       expect.any(Function),
-    ])
-  })
-})
+    ]);
+  });
+  test("Interpolation string contains a variable name which should remain the same", () => {
+    expect(stringInterpolation("foo{{foo}}", { foo: "bar" })).toStrictEqual(
+      "foobar" // todo: fix - returns "barbar"
+    );
+  });
+});

src/index.ts

@@ -76,15 +76,33 @@ export function stringInterpolation<
     }
   }
 
-  // Create raw interpolation result
-  const rawInterpolation = string
-    .split(pattern)
-    // Trim empty string from array end (Could propably be done with regex as well)
-    .filter(Boolean)
-    // Match parsed variables with passed in variables
-    .map((splitItem) => {
-      return variables[splitItem] ? variables[splitItem] : splitItem
-    })
+  // Create raw interpolation result using match positions to avoid
+  // replacing plain text that happens to equal a variable name
+  const rawInterpolation: (string | VariableValue)[] = []
+  let lastIndex = 0
+
+  for (const regExpMatchArray of stringVariables as RegExpExecArray[]) {
+    const matchIndex = regExpMatchArray.index ?? 0
+    const fullMatch = regExpMatchArray[0]
+    const variableKeyInString = regExpMatchArray[1]
+
+    // Push literal substring before the match
+    if (matchIndex > lastIndex) {
+      rawInterpolation.push(string.slice(lastIndex, matchIndex))
+    }
+
+    // Push the variable value for the matched key
+    rawInterpolation.push(
+      variables[variableKeyInString as unknown as PropertyKey]
+    )
+
+    lastIndex = matchIndex + fullMatch.length
+  }
+
+  // Push any trailing literal substring after the last match
+  if (lastIndex < string.length) {
+    rawInterpolation.push(string.slice(lastIndex))
+  }
 
   // Checks if raw interpolation can be joined or not.
   // i.e. avoid printing [object Object | Array | Function | ...] within returned string.