@capillarytech/creatives-library 8.0.353-alpha.5 → 8.0.353-alpha.6

package/utils/tests/templateVarUtils.test.js

@@ -0,0 +1,204 @@
+import {
+  extractTemplateVariables,
+  splitTemplateVarString,
+  splitContentByOrderedVarTokens,
+  getFallbackResolvedContent,
+  getFallbackResolvedContentForCardDisplay,
+  isDltHashVarToken,
+  isAnyTemplateVarToken,
+} from '../templateVarUtils';
+
+describe('templateVarUtils', () => {
+  describe('splitContentByOrderedVarTokens', () => {
+    it('pushes remainder when next token is not found in string', () => {
+      expect(splitContentByOrderedVarTokens(['{{b}}'], 'hello')).toEqual(['hello']);
+    });
+
+    it('handles empty token queue by pushing remainder', () => {
+      expect(splitContentByOrderedVarTokens([], 'rest')).toEqual(['rest']);
+    });
+
+    it('handles null matchedVariableTokens as empty queue', () => {
+      expect(splitContentByOrderedVarTokens(null, 'abc')).toEqual(['abc']);
+    });
+
+    it('stops and pushes remainder when next token in queue is empty string', () => {
+      expect(splitContentByOrderedVarTokens(['{{a}}', ''], 'x{{a}}y')).toEqual(['x', '{{a}}', 'y']);
+    });
+
+    it('splits multiple ordered tokens across content', () => {
+      expect(splitContentByOrderedVarTokens(['{{a}}', '{{b}}'], 'p{{a}}q{{b}}r')).toEqual([
+        'p',
+        '{{a}}',
+        'q',
+        '{{b}}',
+        'r',
+      ]);
+    });
+
+    it('returns empty segment list when content is null and queue is empty', () => {
+      expect(splitContentByOrderedVarTokens([], null)).toEqual([]);
+    });
+  });
+
+  describe('splitTemplateVarString', () => {
+    it('returns empty array for falsy string', () => {
+      expect(splitTemplateVarString('')).toEqual([]);
+      expect(splitTemplateVarString(null)).toEqual([]);
+    });
+
+    it('splits mustache segments', () => {
+      const parts = splitTemplateVarString('Hi {{name}}!');
+      expect(parts.some((p) => p.includes('name'))).toBe(true);
+    });
+
+    it('omits empty segments after filtering', () => {
+      expect(splitTemplateVarString('a{{x}}b')).toEqual(['a', '{{x}}', 'b']);
+    });
+  });
+
+  describe('getFallbackResolvedContent', () => {
+    it('replaces var segments from varMapData', () => {
+      const out = getFallbackResolvedContent('{{a}}', { '{{a}}_0': 'X' });
+      expect(out).toBe('X');
+    });
+
+    it('keeps DLT token string when slot empty', () => {
+      const out = getFallbackResolvedContent('{#v#}', {});
+      expect(out).toContain('#');
+    });
+
+    it('returns empty string for mustache slot when map has no value', () => {
+      const out = getFallbackResolvedContent('Hi {{missing}}', {});
+      expect(out).toBe('Hi ');
+    });
+
+    it('treats null as empty; explicit empty string is kept (cleared input)', () => {
+      expect(getFallbackResolvedContent('{{a}}', { '{{a}}_0': null })).toBe('');
+      expect(getFallbackResolvedContent('{{a}}', { '{{a}}_0': '' })).toBe('');
+    });
+
+    it('keeps DLT token in preview when slot map has empty string (no tag yet)', () => {
+      expect(getFallbackResolvedContent('{#v#}', { '{#v#}_0': '' })).toBe('{#v#}');
+    });
+
+    it('keeps DLT token in preview when slot map has null', () => {
+      expect(getFallbackResolvedContent('{#v#}', { '{#v#}_0': null })).toBe('{#v#}');
+    });
+
+    it('uses slot replacement when value is non-empty string', () => {
+      expect(getFallbackResolvedContent('A{{b}}C', { '{{b}}_1': 'ok' })).toBe('AokC');
+    });
+  });
+
+  describe('getFallbackResolvedContentForCardDisplay', () => {
+    it('shows raw tokens when map is empty or slots unset', () => {
+      expect(getFallbackResolvedContentForCardDisplay('Hi {{name}}', {})).toBe('Hi {{name}}');
+      expect(getFallbackResolvedContentForCardDisplay('{#var#}', {})).toBe('{#var#}');
+    });
+
+    it('shows raw token when slot key exists but value is empty (no labels)', () => {
+      expect(getFallbackResolvedContentForCardDisplay('{#var#}', { '{#var#}_0': '' })).toBe('{#var#}');
+      expect(getFallbackResolvedContentForCardDisplay('{{a}}', { '{{a}}_0': '' })).toBe('{{a}}');
+    });
+
+    it('replaces when slot has non-empty value', () => {
+      expect(getFallbackResolvedContentForCardDisplay('Hi {{name}}', { '{{name}}_1': 'Pat' })).toBe('Hi Pat');
+    });
+  });
+
+  describe('isDltHashVarToken / isAnyTemplateVarToken', () => {
+    it('detects DLT hash token', () => {
+      expect(isDltHashVarToken('{#x#}')).toBe(true);
+      expect(isDltHashVarToken('plain')).toBe(false);
+    });
+
+    it('isAnyTemplateVarToken combines mustache and DLT', () => {
+      expect(isAnyTemplateVarToken('{{a}}')).toBe(true);
+      expect(isAnyTemplateVarToken('{#x#}')).toBe(true);
+    });
+  });
+
+  describe('extractTemplateVariables', () => {
+    it('returns empty array for empty or missing template', () => {
+      expect(extractTemplateVariables('')).toEqual([]);
+      expect(extractTemplateVariables()).toEqual([]);
+    });
+
+    it('includes DLT {#var#} names when no custom capture regex', () => {
+      const vars = extractTemplateVariables('Hello {#promo#} and {{name}}');
+      expect(vars).toEqual(expect.arrayContaining(['promo', 'name']));
+    });
+
+    it('skips DLT scan when captureRegex is provided', () => {
+      const re = /\{\{([^}]+)\}\}/g;
+      expect(extractTemplateVariables('{#x#} {{y}}', re)).toEqual(['y']);
+    });
+
+    it('dedupes duplicate variable names', () => {
+      expect(extractTemplateVariables('{{a}} {{a}}')).toEqual(['a']);
+    });
+
+    it('uses default name var when DLT body capture is empty', () => {
+      const vars = extractTemplateVariables('{##}');
+      expect(vars).toContain('var');
+    });
+  });
+
+  describe('extractTemplateVariables (regex global)', () => {
+    it('extracts all vars when caller passes a non-global capture regex (avoids infinite exec loop)', () => {
+      const nonGlobal = /\{\{([^}]+)\}\}/;
+      expect(nonGlobal.global).toBe(false);
+      expect(extractTemplateVariables('{{a}} and {{b}}', nonGlobal)).toEqual(['a', 'b']);
+    });
+
+    it('still works when capture regex already has the global flag', () => {
+      const globalRe = /\{\{([^}]+)\}\}/g;
+      expect(extractTemplateVariables('{{x}} {{y}}', globalRe)).toEqual(['x', 'y']);
+    });
+  });
+
+  describe('getFallbackResolvedContent — userVarMap (third param)', () => {
+    it('falls back to userVarMap for mustache slot absent from varMapData', () => {
+      expect(getFallbackResolvedContent('Hi {{name}}', {}, { name: 'Alice' })).toBe('Hi Alice');
+    });
+
+    it('falls back to userVarMap for DLT slot absent from varMapData', () => {
+      expect(getFallbackResolvedContent('{#city#}', {}, { city: 'Mumbai' })).toBe('Mumbai');
+    });
+
+    it('falls back to userVarMap when mustache slot is present but blank', () => {
+      expect(getFallbackResolvedContent('{{x}}', { '{{x}}_0': '' }, { x: 'val' })).toBe('val');
+    });
+
+    it('falls back to userVarMap when DLT slot is present but blank', () => {
+      expect(getFallbackResolvedContent('{#x#}', { '{#x#}_0': '' }, { x: 'val' })).toBe('val');
+    });
+
+    it('slot wins over userVarMap when mustache slot is non-empty', () => {
+      expect(getFallbackResolvedContent('{{x}}', { '{{x}}_0': 'slot-val' }, { x: 'user-val' })).toBe('slot-val');
+    });
+
+    it('slot wins over userVarMap when DLT slot is non-empty', () => {
+      expect(getFallbackResolvedContent('{#x#}', { '{#x#}_0': 'slot' }, { x: 'user' })).toBe('slot');
+    });
+
+    it('resolves dot-path suffix key from userVarMap', () => {
+      expect(
+        getFallbackResolvedContent('{{FORMAT_1}}', {}, { 'expiry.FORMAT_1': 'Dec 2025' }),
+      ).toBe('Dec 2025');
+    });
+
+    it('userVarMap null behaves identically to the two-argument form', () => {
+      expect(getFallbackResolvedContent('{{a}}', { '{{a}}_0': 'x' }, null)).toBe('x');
+    });
+
+    it('blank userVarMap value leaves mustache token as empty string', () => {
+      expect(getFallbackResolvedContent('{{a}}', {}, { a: '' })).toBe('');
+    });
+
+    it('blank userVarMap value leaves DLT token as raw token', () => {
+      expect(getFallbackResolvedContent('{#a#}', {}, { a: '' })).toBe('{#a#}');
+    });
+  });
+});

package/v2Components/CapActionButton/constants.js

@@ -32,6 +32,13 @@ export const CTA_OPTIONS = [
 ];
 
 export const invalidVarRegex = /{{(.*?)}}/g;
+
+/** URL CTA subtype (Figma: URL type dropdown). */
+export const RCS_CTA_URL_TYPE = {
+  STATIC: 'STATIC',
+  DYNAMIC: 'DYNAMIC',
+};
+
 export const BTN_MAX_LENGTH = 25;
 export const PHONE_NUMBER_MAX_LENGTH = 15;
 export const URL_MAX_LENGTH = 2000;