support template literals to exclude specific pattern

README.md

@@ -63,11 +63,15 @@ console.log(interpole(source, ['format'], { clearDirtyParam: true })); // This f
 const source = 'This function can :method this template with :type value';
 
 console.log(
-  interpole(source, {
-    method: 'format',
-  }, {
-    clearDirtyParam: true,
-  }),
+  interpole(
+    source,
+    {
+      method: 'format',
+    },
+    {
+      clearDirtyParam: true,
+    },
+  ),
 ); // This function can format this template with  value
 ```
 
@@ -189,3 +193,30 @@ console.log(
   ),
 ); // Hello Alpha
 ```
+
+# Changelogs
+
+- 1.0.4: support template literals, it will exclude the pattern if has template literals as prefix
+
+```ts
+import interpole from 'string-interpolation-js';
+
+const source = 'Hello {{ user.name }} ${{ user.name }}';
+
+console.log(
+  interpole(
+    source,
+    {
+      user: {
+        name: 'Alpha',
+      },
+    },
+    {
+      exactMatch: true,
+      specElement: '_',
+      pattern: '{{ _ }}',
+      templateLiterals: '$',
+    },
+  ),
+); // Hello Alpha {{ user.name }}
+```

package.json

@@ -1,6 +1,6 @@
 {
   "name": "string-interpolation-js",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Simple module to format string from template",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

src/interface.ts

@@ -17,6 +17,9 @@ export interface IOptionsWithPatternProps extends IOptionsBaseProps {
   // only this example is true {{ name }}
   // if false, those two examples above are true
   exactMatch?: boolean;
+  // will exclude if matches
+  // <templateLiterals><pattern>
+  templateLiterals?: string;
 }
 
 export interface IOptionsWithRegExpPatternProps extends IOptionsBaseProps {

src/utils/replaceKeyword.ts

@@ -11,7 +11,7 @@ function replaceKeyword(
   value: any,
   options: Omit<TOptions, 'clearDirtyParam'> = {},
 ): string {
-  const { pattern, specElement, exactMatch } = options;
+  const { pattern, specElement, exactMatch, templateLiterals } = options;
 
   if (pattern instanceof RegExp) {
     return source.replace(pattern, value);
@@ -25,12 +25,25 @@ function replaceKeyword(
     keyword = ` *${keyword} *`;
   }
 
-  const replacementPattern = escapeRegExp(pattern).replace(
+  // TODO: change to pattern (?<!<templateLitterals>)<pattern> when all browsers support negative lookbehind
+  const escapePattern = escapeRegExp(pattern).replace(
     specElement,
     keyword.toString(),
   );
+  const replacementPattern = `(\\S|)${escapePattern}`;
+  const escapeRegExpPatternWithBegin = new RegExp(`^${escapePattern}$`);
 
-  return source.replace(new RegExp(replacementPattern, 'g'), value);
+  return source.replace(new RegExp(replacementPattern, 'g'), (replacement) => {
+    if (escapeRegExpPatternWithBegin.test(replacement)) {
+      return value;
+    }
+
+    if (replacement[0] === templateLiterals) {
+      return replacement.slice(1);
+    }
+
+    return `${replacement[0]}${value}`;
+  });
 }
 
 export function replaceKeywordForArrayParams(

tests/index.spec.ts

@@ -233,3 +233,30 @@ describe('interpole string with nested object params', () => {
     ).toEqual(result);
   });
 });
+
+describe('interpole string with template literals', () => {
+  const template = 'Hello {{ user.name }}, are you a ${{ user.job.name }}?';
+  const result = 'Hello Alpha, are you a {{ user.job.name }}?';
+
+  test('keep template pattern', () => {
+    expect(
+      interpole(
+        template,
+        {
+          user: {
+            name: 'Alpha',
+            job: {
+              name: 'developer',
+            },
+          },
+        },
+        {
+          exactMatch: true,
+          specElement: '_',
+          pattern: '{{ _ }}',
+          templateLiterals: '$',
+        },
+      ),
+    ).toEqual(result);
+  });
+});

tests/utils/replaceKeyword.spec.ts

@@ -0,0 +1,64 @@
+import { replaceKeywordForObjectParams } from '../../src/utils';
+
+describe('replace keyword for object params', () => {
+  const template = 'Hello :name {{ name }} ${{ name }}';
+
+  test('replace param with : as prefix', () => {
+    expect(
+      replaceKeywordForObjectParams(
+        template,
+        {
+          name: 'test',
+        },
+        {},
+      ),
+    ).toEqual('Hello test {{ name }} ${{ name }}');
+  });
+
+  test('replace param with pattern', () => {
+    expect(
+      replaceKeywordForObjectParams(
+        template,
+        {
+          name: 'test',
+        },
+        {
+          pattern: '{{ _ }}',
+          specElement: '_',
+        },
+      ),
+    ).toEqual('Hello :name test $test');
+  });
+
+  test('replace param with pattern and exclude pattern has template litterals as prefix', () => {
+    expect(
+      replaceKeywordForObjectParams(
+        template,
+        {
+          name: 'test',
+        },
+        {
+          pattern: '{{ _ }}',
+          specElement: '_',
+          templateLiterals: '$',
+        },
+      ),
+    ).toEqual('Hello :name test {{ name }}');
+
+    const otherTemplate = 'Hello :name ${{ name }} $${{ name }}';
+
+    expect(
+      replaceKeywordForObjectParams(
+        otherTemplate,
+        {
+          name: 'test',
+        },
+        {
+          pattern: '${{ _ }}',
+          specElement: '_',
+          templateLiterals: '$',
+        },
+      ),
+    ).toEqual('Hello :name test ${{ name }}');
+  });
+});