@capillarytech/creatives-library 8.0.359-alpha.0 → 8.0.359-alpha.1

package/utils/tests/rcsPayloadUtils.test.js

@@ -0,0 +1,226 @@
+import { normalizeRcsMessageContentForApi } from '../rcsPayloadUtils';
+
+describe('normalizeRcsMessageContentForApi', () => {
+  it('defaults missing rcsContent to empty object and still normalizes root smsFallBackContent', () => {
+    const item = {
+      smsFallBackContent: { message: 'root-only' },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.rcsContent).toEqual({});
+    expect(item.smsFallBackContent).toEqual({ message: 'root-only' });
+  });
+
+  it('moves nested smsFallBackContent out of rcsContent and merges onto root', () => {
+    const item = {
+      rcsContent: {
+        contentType: 'RICHCARD',
+        smsFallBackContent: {
+          message: 'nested-msg',
+          templateConfigs: { registeredSenderIds: ['H1'] },
+        },
+      },
+      smsFallBackContent: { message: 'root-msg' },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.rcsContent).toEqual({ contentType: 'RICHCARD' });
+    expect(item.smsFallBackContent.message).toBe('root-msg');
+    expect(item.smsFallBackContent.templateConfigs).toEqual({
+      registeredSenderIds: ['H1'],
+    });
+  });
+
+  it('nested message merges when root has no message key', () => {
+    const item = {
+      rcsContent: {
+        smsFallBackContent: { message: 'from-nested' },
+      },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.rcsContent).toEqual({});
+    expect(item.smsFallBackContent).toEqual({ message: 'from-nested' });
+  });
+
+  it('removes smsFallBackContent when nothing to serialize', () => {
+    const item = {
+      rcsContent: { smsFallBackContent: {} },
+      smsFallBackContent: {},
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.rcsContent).toEqual({});
+    expect(item.smsFallBackContent).toBeUndefined();
+  });
+
+  it('does not add templateConfigs when empty', () => {
+    const item = {
+      rcsContent: {},
+      smsFallBackContent: { message: 'x', templateConfigs: {} },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.smsFallBackContent).toEqual({ message: 'x' });
+  });
+
+  it('serializes templateConfigs only when message is absent but templateConfigs has data', () => {
+    const item = {
+      rcsContent: {
+        smsFallBackContent: {
+          templateConfigs: { registeredSenderIds: ['Z'] },
+        },
+      },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.smsFallBackContent).toEqual({
+      templateConfigs: { registeredSenderIds: ['Z'] },
+    });
+  });
+
+  it('includes message in api payload when key exists with empty string', () => {
+    const item = {
+      smsFallBackContent: { message: '', templateConfigs: { id: 't1' } },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.smsFallBackContent).toEqual({
+      message: '',
+      templateConfigs: { id: 't1' },
+    });
+  });
+
+  it('merges when legacy nested is null-coalesced', () => {
+    const item = {
+      rcsContent: {
+        contentType: 'TEXT',
+        smsFallBackContent: null,
+      },
+      smsFallBackContent: { message: 'from-root' },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.rcsContent).toEqual({ contentType: 'TEXT' });
+    expect(item.smsFallBackContent).toEqual({ message: 'from-root' });
+  });
+
+  it('folds rcsSmsFallbackVarMapped into message and omits var map from API shape', () => {
+    const msg = '{{optout}} {{fullname}} test SMS';
+    const varMapped = {
+      '{{optout}}_0': '{{city}}',
+      '{{fullname}}_2': '{{fullname}}',
+    };
+    const item = {
+      rcsContent: { contentType: 'RICHCARD' },
+      smsFallBackContent: {
+        message: msg,
+        rcsSmsFallbackVarMapped: varMapped,
+      },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.smsFallBackContent).toEqual({
+      message: '{{city}} {{fullname}} test SMS',
+    });
+    expect(item.smsFallBackContent.rcsSmsFallbackVarMapped).toBeUndefined();
+  });
+
+  it('merges nested rcsSmsFallbackVarMapped with root message; root message wins on key clash', () => {
+    const nestedVar = { '{{a}}_0': '{{nested}}' };
+    const item = {
+      rcsContent: {
+        contentType: 'RICHCARD',
+        smsFallBackContent: {
+          message: '{{a}} nested-tail',
+          rcsSmsFallbackVarMapped: nestedVar,
+        },
+      },
+      smsFallBackContent: {
+        message: '{{a}} tail',
+        rcsSmsFallbackVarMapped: { '{{a}}_0': '{{root}}' },
+      },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.smsFallBackContent.message).toBe('{{root}} tail');
+    expect(item.smsFallBackContent.rcsSmsFallbackVarMapped).toBeUndefined();
+  });
+
+  it('non-slot var map keys do not change message but var map is still stripped', () => {
+    const varMapped = { 0: { label: 'City', tag: '{{city}}' } };
+    const item = {
+      rcsContent: { contentType: 'RICHCARD' },
+      smsFallBackContent: {
+        message: 'Hello',
+        rcsSmsFallbackVarMapped: varMapped,
+      },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.smsFallBackContent).toEqual({ message: 'Hello' });
+  });
+
+  it('omits rcsSmsFallbackVarMapped when merged value is empty object', () => {
+    const item = {
+      rcsContent: {
+        smsFallBackContent: { rcsSmsFallbackVarMapped: {} },
+      },
+      smsFallBackContent: { message: 'only-msg' },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.smsFallBackContent).toEqual({ message: 'only-msg' });
+    expect(item.smsFallBackContent.rcsSmsFallbackVarMapped).toBeUndefined();
+  });
+
+  it('removes root-level templateConfigs from RCS message content item', () => {
+    const item = {
+      rcsContent: { cardType: 'STANDALONE' },
+      templateConfigs: {
+        templateId: '69b3d33934a7bd0db5bada8e',
+        template: '{{registered_store_name}} Its a test message',
+      },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.templateConfigs).toBeUndefined();
+    expect(item.rcsContent).toEqual({ cardType: 'STANDALONE' });
+  });
+
+  it('removes templateConfigs nested inside rcsContent', () => {
+    const item = {
+      rcsContent: {
+        cardType: 'STANDALONE',
+        templateConfigs: {
+          templateId: '69b3d33934a7bd0db5bada8e',
+          template: '{{registered_store_name}} Its a test message',
+        },
+        cardContent: [{ title: 'Card' }],
+      },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.templateConfigs).toBeUndefined();
+    expect(item.rcsContent.templateConfigs).toBeUndefined();
+    expect(item.rcsContent.cardContent).toEqual([{ title: 'Card' }]);
+  });
+
+  it('strips isSaved from each suggestion in cardContent', () => {
+    const item = {
+      rcsContent: {
+        cardContent: [
+          {
+            title: 'Card 1',
+            suggestions: [
+              { type: 'QUICK_REPLY', text: 'Yes', isSaved: true },
+              { type: 'CTA', text: 'Go', url: 'https://example.com', isSaved: false },
+            ],
+          },
+        ],
+      },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.rcsContent.cardContent[0].suggestions).toEqual([
+      { type: 'QUICK_REPLY', text: 'Yes' },
+      { type: 'CTA', text: 'Go', url: 'https://example.com' },
+    ]);
+  });
+
+  it('handles cardContent with no suggestions gracefully', () => {
+    const item = {
+      rcsContent: {
+        cardContent: [{ title: 'Card 1' }, { title: 'Card 2', suggestions: [] }],
+      },
+    };
+    normalizeRcsMessageContentForApi(item);
+    expect(item.rcsContent.cardContent[0].suggestions).toBeUndefined();
+    expect(item.rcsContent.cardContent[1].suggestions).toEqual([]);
+  });
+});

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;