@capillarytech/creatives-library 8.0.345-alpha.13 → 8.0.345-alpha.15

package/constants/unified.js

@@ -159,6 +159,24 @@ export const TAG_CONTENT_REGEX = /{{([^}]+)}}/g;
 export const ENTRY_TRIGGER_TAG_REGEX = /\bentryTrigger\.\w+(?:\.\w+)?(?:\(\w+\))?/g;
 export const SKIP_TAGS_REGEX_GROUPS = ["dynamic_expiry_date_after_\\d+_days.FORMAT_\\d", "unsubscribe\\(#[a-zA-Z\\d]{6}\\)", "Link_to_[a-zA-Z]", "SURVEY.*.TOKEN", "^[A-Za-z].*\\([a-zA-Z\\d]*\\)", "referral_unique_(code|url).*userid"];
 
+// --- Template variable tokens (`{{var}}`, DLT `{#var#}`) ---
+/** Global: all `{{…}}` placeholders in a string. */
+export const DEFAULT_MUSTACHE_VAR_REGEX = /\{\{[^}]+\}\}/g;
+/** Global: `{{…}}` or DLT `{#…#}` tokens (SMS combined mode). */
+export const COMBINED_SMS_TEMPLATE_VAR_REGEX = /\{\{[^}]+\}\}|\{\#[^#]*\#\}/g;
+/** Full-string check: one mustache token. */
+export const MUSTACHE_VAR_TOKEN_FULL_STRING_REGEX = /^\{\{[^}]+\}\}$/;
+/** Full-string check: one DLT hash token. */
+export const DLT_HASH_VAR_TOKEN_FULL_STRING_REGEX = /^\{\#[^#]*\#\}$/;
+/** Full-string with capture group: inner name for `{{ name }}`-style tokens (whitespace-tolerant). */
+export const MUSTACHE_TOKEN_INNER_NAME_REGEX = /^\{\{\s*([^}]+?)\s*\}\}$/;
+/** Full-string with capture group: inner name/body for `{# name #}` DLT tokens (whitespace-tolerant). */
+export const DLT_HASH_TOKEN_INNER_NAME_REGEX = /^\{#\s*(.*?)\s*#\}$/;
+/** Global with capture group: inner name inside `{{name}}`. */
+export const MUSTACHE_VAR_NAME_CAPTURE_REGEX = /\{\{([^}]+)\}\}/g;
+/** Global with capture group: inner body inside `{#body#}`. */
+export const DLT_VAR_BODY_CAPTURE_REGEX = /\{\#([^#]*)\#\}/g;
+
 export const GET_TRANSLATION_MAPPED = {
   'en': 'en-US',
   'zh-cn': 'zh',
@@ -196,3 +214,14 @@ export const LOGOUT_FAILURE = 'cap/LOGOUT_FAILURE';
 export const JAPANESE_HELP_TEXT = 'ヘルプ :トークンの定義';
 
 export const TAG_TRANSLATION_DOC = 'https://docs.capillarytech.com/docs/tags-translation';
+
+// --- RCS SMS fallback API contract (shared across modules: campaigns, journey, etc.) ---
+
+/** Keys on `messageContent.*.smsFallBackContent` sent to the API: only `message` + `templateConfigs`.
+ *  `rcsSmsFallbackVarMapped` is editor-only — merged into `message` at normalize, not sent on the wire. */
+export const RCS_API_SMS_FALLBACK_KEYS = Object.freeze({
+  MESSAGE: 'message',
+  TEMPLATE_CONFIGS: 'templateConfigs',
+  RCS_SMS_FALLBACK_VAR_MAPPED: 'rcsSmsFallbackVarMapped',
+});
+

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@capillarytech/creatives-library",
   "author": "meharaj",
-  "version": "8.0.345-alpha.13",
+  "version": "8.0.345-alpha.15",
   "description": "Capillary creatives ui",
   "main": "./index.js",
   "module": "./index.es.js",

package/services/api.js

@@ -361,26 +361,6 @@ export const deleteTemplate = ({channel, id}) => {
   //return API.deleteResource(url);
 };
 
-export const archiveTemplate = ({ channel, id }) => {
-  const url = `${API_ENDPOINT}/templates/archive/${id}/${channel}`;
-  return request(url, getAPICallObject('PUT'));
-};
-
-export const unarchiveTemplate = ({ channel, id }) => {
-  const url = `${API_ENDPOINT}/templates/unarchive/${id}/${channel}`;
-  return request(url, getAPICallObject('PUT'));
-};
-
-export const bulkArchiveTemplates = ({ channel, ids }) => {
-  const url = `${API_ENDPOINT}/templates/archive/bulk/${channel}`;
-  return request(url, getAPICallObject('PUT', { ids }));
-};
-
-export const bulkUnarchiveTemplates = ({ channel, ids }) => {
-  const url = `${API_ENDPOINT}/templates/unarchive/bulk/${channel}`;
-  return request(url, getAPICallObject('PUT', { ids }));
-};
-
 export const deleteRcsTemplate = ({ templateName }) => {
   const url = `${API_ENDPOINT}/templates/${templateName}/RCS`;
   return request(url, getAPICallObject('DELETE'))

package/services/tests/api.test.js

@@ -1042,6 +1042,19 @@ describe('getMembersLookup', () => {
     getMembersLookup('email', 'user+test@example.com');
     expect(global.fetch).toHaveBeenCalled();
     const calls = global.fetch.mock.calls;
+    const withEncoding = calls.find(
+      (c) =>
+        c[0] &&
+        String(c[0]).includes('members') &&
+        String(c[0]).includes('identifierType=email') &&
+        String(c[0]).includes('user%2Btest%40example.com')
+    );
+    if (withEncoding) {
+      const [url, options] = withEncoding;
+      expect(url).toContain('identifierType=email');
+      expect(url).toContain('identifierValue=user%2Btest%40example.com');
+      expect(options?.method || 'GET').toBe('GET');
+    }
     const anyMembersCall = calls.find((c) => c[0] && String(c[0]).includes('members'));
     expect(anyMembersCall).toBeDefined();
     expect(anyMembersCall[0]).toContain('identifierType=');
@@ -1086,62 +1099,3 @@ describe('createTestCustomer', () => {
     expect(lastCall[1].body).toBe(JSON.stringify(payload));
   });
 });
-
-import {
-  archiveTemplate,
-  unarchiveTemplate,
-  bulkArchiveTemplates,
-  bulkUnarchiveTemplates,
-} from '../api';
-
-describe('archiveTemplate', () => {
-  beforeEach(() => {
-    global.fetch = jest.fn().mockReturnValue(Promise.resolve({ json: () => Promise.resolve({}) }));
-  });
-
-  it('should call PUT on archive endpoint', () => {
-    archiveTemplate({ channel: 'EMAIL', id: 'id123' });
-    expect(global.fetch).toHaveBeenCalled();
-    const lastCall = global.fetch.mock.calls[global.fetch.mock.calls.length - 1];
-    expect(lastCall[1].method).toBe('PUT');
-  });
-});
-
-describe('unarchiveTemplate', () => {
-  beforeEach(() => {
-    global.fetch = jest.fn().mockReturnValue(Promise.resolve({ json: () => Promise.resolve({}) }));
-  });
-
-  it('should call PUT on unarchive endpoint', () => {
-    unarchiveTemplate({ channel: 'EMAIL', id: 'id123' });
-    expect(global.fetch).toHaveBeenCalled();
-    const lastCall = global.fetch.mock.calls[global.fetch.mock.calls.length - 1];
-    expect(lastCall[1].method).toBe('PUT');
-  });
-});
-
-describe('bulkArchiveTemplates', () => {
-  beforeEach(() => {
-    global.fetch = jest.fn().mockReturnValue(Promise.resolve({ json: () => Promise.resolve({}) }));
-  });
-
-  it('should call PUT on bulk archive endpoint with ids', () => {
-    bulkArchiveTemplates({ channel: 'EMAIL', ids: ['id1', 'id2'] });
-    expect(global.fetch).toHaveBeenCalled();
-    const lastCall = global.fetch.mock.calls[global.fetch.mock.calls.length - 1];
-    expect(lastCall[1].method).toBe('PUT');
-  });
-});
-
-describe('bulkUnarchiveTemplates', () => {
-  beforeEach(() => {
-    global.fetch = jest.fn().mockReturnValue(Promise.resolve({ json: () => Promise.resolve({}) }));
-  });
-
-  it('should call PUT on bulk unarchive endpoint with ids', () => {
-    bulkUnarchiveTemplates({ channel: 'EMAIL', ids: ['id1', 'id2'] });
-    expect(global.fetch).toHaveBeenCalled();
-    const lastCall = global.fetch.mock.calls[global.fetch.mock.calls.length - 1];
-    expect(lastCall[1].method).toBe('PUT');
-  });
-});

package/utils/commonUtils.js

@@ -539,4 +539,22 @@ export const isValidMobile = (mobile) => PHONE_REGEX.test(mobile);
 export const formatPhoneNumber = (phone) => {
   if (!phone) return '';
   return String(phone).replace(/[^\d]/g, '');
-};
+};
+
+/**
+ * TRAI sender IDs on persisted RCS SMS fallback: may live on the merged object, under
+ * `templateConfigs`, or (legacy) `templateConfigs.header`. Same resolution order as
+ * `createPayload` in `Rcs/index.js`.
+ */
+export function extractRegisteredSenderIdsFromSmsFallbackRecord(record) {
+  if (!record || typeof record !== 'object') return null;
+  const tc = record.templateConfigs && typeof record.templateConfigs === 'object'
+    ? record.templateConfigs
+    : {};
+  const candidates = [record.registeredSenderIds, tc.registeredSenderIds, tc.header];
+  for (let i = 0; i < candidates.length; i += 1) {
+    const a = candidates[i];
+    if (Array.isArray(a) && a.length > 0) return a;
+  }
+  return null;
+}

package/utils/rcsPayloadUtils.js

@@ -0,0 +1,92 @@
+import isEmpty from 'lodash/isEmpty';
+import { RCS_API_SMS_FALLBACK_KEYS } from '../constants/unified';
+import {
+  COMBINED_SMS_TEMPLATE_VAR_REGEX,
+  isAnyTemplateVarToken,
+  splitTemplateVarString,
+} from './templateVarUtils';
+
+const {
+  MESSAGE,
+  TEMPLATE_CONFIGS,
+  RCS_SMS_FALLBACK_VAR_MAPPED,
+} = RCS_API_SMS_FALLBACK_KEYS;
+
+function mergeSmsFallbackSlots(templateStr, varMapped) {
+  const map = varMapped != null && typeof varMapped === 'object' ? varMapped : {};
+  if (!Object.keys(map).length) return typeof templateStr === 'string' ? templateStr : '';
+  const str = typeof templateStr === 'string' ? templateStr : '';
+  return splitTemplateVarString(str, COMBINED_SMS_TEMPLATE_VAR_REGEX)
+    .map((seg, i) => {
+      if (!isAnyTemplateVarToken(seg)) return seg;
+      const key = `${seg}_${i}`;
+      if (Object.prototype.hasOwnProperty.call(map, key)) {
+        const v = map[key];
+        return v == null ? '' : String(v);
+      }
+      return seg;
+    })
+    .join('');
+}
+
+/**
+ * Mutates one RCS messageContent entry: strips UI-only fields, promotes smsFallBackContent to a
+ * sibling of rcsContent, and folds rcsSmsFallbackVarMapped into the message string for the API.
+ */
+export const normalizeRcsMessageContentForApi = messageContentItem => {
+  const {
+    rcsContent = {},
+    smsFallBackContent: rootSmsFallbackContent = {},
+  } = messageContentItem;
+  const {
+    smsFallBackContent: legacySmsFallbackNestedUnderCard,
+    ...rcsCardPayloadOnly
+  } = { ...rcsContent };
+  /* Legacy nested first, then root — so current root `smsFallBackContent` wins on key clashes. */
+  const mergedSmsFallbackSources = {
+    ...(legacySmsFallbackNestedUnderCard ?? {}),
+    ...rootSmsFallbackContent,
+  };
+  messageContentItem.rcsContent = rcsCardPayloadOnly;
+
+  delete messageContentItem.templateConfigs;
+  delete rcsCardPayloadOnly.templateConfigs;
+
+  if (Array.isArray(rcsCardPayloadOnly.cardContent)) {
+    rcsCardPayloadOnly.cardContent.forEach(card => {
+      if (Array.isArray(card.suggestions)) {
+        card.suggestions.forEach(suggestion => {
+          delete suggestion.isSaved;
+        });
+      }
+    });
+  }
+
+  const varMappedMerged = mergedSmsFallbackSources[RCS_SMS_FALLBACK_VAR_MAPPED];
+  const hasVarMapped =
+    varMappedMerged != null
+    && typeof varMappedMerged === 'object'
+    && Object.keys(varMappedMerged).length > 0;
+  const hasMessageKey = Object.prototype.hasOwnProperty.call(mergedSmsFallbackSources, MESSAGE);
+  const rawMessage = hasMessageKey ? mergedSmsFallbackSources[MESSAGE] : undefined;
+  const messageForApi =
+    hasMessageKey && hasVarMapped
+      ? mergeSmsFallbackSlots(rawMessage == null ? '' : String(rawMessage), varMappedMerged)
+      : rawMessage;
+
+  const apiSiblingSmsFallback = Object.fromEntries(
+    [
+      hasMessageKey && [MESSAGE, messageForApi],
+      !isEmpty(mergedSmsFallbackSources[TEMPLATE_CONFIGS]) && [
+        TEMPLATE_CONFIGS,
+        mergedSmsFallbackSources[TEMPLATE_CONFIGS],
+      ],
+    ].filter(Boolean),
+  );
+
+  if (Object.keys(apiSiblingSmsFallback).length) {
+    messageContentItem.smsFallBackContent = apiSiblingSmsFallback;
+  } else {
+    delete messageContentItem.smsFallBackContent;
+  }
+};

package/utils/templateVarUtils.js

@@ -0,0 +1,201 @@
+/**
+ * Shared utilities for templates containing {{var}} and DLT `{#var#}` tokens.
+ * Same split process used by WhatsApp/RCS: match vars with regex, then split content at each var.
+ */
+
+import {
+  COMBINED_SMS_TEMPLATE_VAR_REGEX,
+  DEFAULT_MUSTACHE_VAR_REGEX,
+  DLT_HASH_VAR_TOKEN_FULL_STRING_REGEX,
+  DLT_HASH_TOKEN_INNER_NAME_REGEX,
+  DLT_VAR_BODY_CAPTURE_REGEX,
+  MUSTACHE_TOKEN_INNER_NAME_REGEX,
+  MUSTACHE_VAR_NAME_CAPTURE_REGEX,
+  MUSTACHE_VAR_TOKEN_FULL_STRING_REGEX,
+} from '../constants/unified';
+
+export { COMBINED_SMS_TEMPLATE_VAR_REGEX, DEFAULT_MUSTACHE_VAR_REGEX } from '../constants/unified';
+
+const isMustacheVarToken = (s) =>
+  typeof s === 'string' && MUSTACHE_VAR_TOKEN_FULL_STRING_REGEX.test(s);
+
+export const isDltHashVarToken = (s) =>
+  typeof s === 'string' && DLT_HASH_VAR_TOKEN_FULL_STRING_REGEX.test(s);
+
+export const isAnyTemplateVarToken = (s) => isMustacheVarToken(s) || isDltHashVarToken(s);
+
+/**
+ * `RegExp.prototype.exec` only advances `lastIndex` when the `g` and/or `y` flag is set.
+ * A non-global regex in a `while ((m = re.exec(s)) !== null)` loop never advances and can run forever.
+ *
+ * @param {RegExp} regex
+ * @returns {RegExp} Same instance if already global; otherwise a new RegExp with `g` appended to flags.
+ */
+function ensureGlobalRegexForExecLoop(regex) {
+  if (!regex || !(regex instanceof RegExp) || regex.global) {
+    return regex;
+  }
+  return new RegExp(regex.source, `${regex.flags}g`);
+}
+
+/**
+ * Splits `content` into alternating plain-text segments and variable tokens, using the order of
+ * matches in `matchedVariableTokens` (e.g. from `String.prototype.match` with a global regex).
+ *
+ * @param {string[]} matchedVariableTokens - Matched tokens in left-to-right order
+ * @param {string} content - Full template string
+ * @returns {string[]}
+ */
+export const splitContentByOrderedVarTokens = (matchedVariableTokens, content) => {
+  const segmentList = [];
+  const tokenQueue = [...(matchedVariableTokens ?? [])];
+  let remainder = content ?? '';
+  while ((remainder?.length ?? 0) > 0) {
+    const nextVarToken = tokenQueue?.[0];
+    if (nextVarToken == null || nextVarToken === '') {
+      segmentList.push(remainder);
+      break;
+    }
+    const varStartIndex = remainder.indexOf(nextVarToken);
+    if (varStartIndex !== -1) {
+      segmentList.push(remainder.substring(0, varStartIndex));
+      segmentList.push(nextVarToken);
+      const afterVar = varStartIndex + (nextVarToken?.length ?? 0);
+      remainder = remainder.substring(afterVar, remainder?.length ?? 0);
+      tokenQueue.shift();
+    } else {
+      segmentList.push(remainder);
+      break;
+    }
+  }
+  return segmentList;
+};
+
+/**
+ * Splits a template string into an array of text + {{var}} segments using the given regex.
+ *
+ * @param {string} str - Template string
+ * @param {RegExp} [varRegex] - Regex that matches var tokens; defaults to DEFAULT_MUSTACHE_VAR_REGEX
+ * @returns {string[]}
+ */
+export const splitTemplateVarString = (str = '', varRegex = DEFAULT_MUSTACHE_VAR_REGEX) => {
+  if (!str) return [];
+  const matchedVariableTokens = str.match(varRegex) || [];
+  return splitContentByOrderedVarTokens(matchedVariableTokens, str).filter(
+    (segment) => segment === 0 || segment
+  );
+};
+
+/**
+ * Extracts unique variable names from `{{var}}` (and, when using default capture, `{#var#}`) strings.
+ *
+ * @param {string} templateStr
+ * @param {RegExp} [captureRegex] - regex with a single capture group for the var name; if omitted, also scans DLT `{#…#}`.
+ * @returns {string[]}
+ */
+export const extractTemplateVariables = (templateStr = '', captureRegex) => {
+  if (!templateStr) return [];
+  const variables = [];
+  const add = (name) => {
+    const n = (name || '').trim();
+    if (n && !variables.includes(n)) variables.push(n);
+  };
+  const mustacheRe = ensureGlobalRegexForExecLoop(
+    captureRegex || MUSTACHE_VAR_NAME_CAPTURE_REGEX,
+  );
+  let match;
+  while ((match = mustacheRe.exec(templateStr)) !== null) {
+    add(match?.[1]);
+  }
+  if (!captureRegex) {
+    const dltRe = new RegExp(DLT_VAR_BODY_CAPTURE_REGEX.source, DLT_VAR_BODY_CAPTURE_REGEX.flags);
+    let dltMatch;
+    while ((dltMatch = dltRe.exec(templateStr)) !== null) {
+      add(dltMatch?.[1] || 'var');
+    }
+  }
+  return variables;
+};
+
+/**
+ * Looks up the inner name of a `{{name}}` or `{#name#}` token in a flat key→value map.
+ * Handles both exact matches and dot-path suffixes (e.g. `tag.FORMAT_1` → name `FORMAT_1`).
+ * Returns the resolved string value, or `undefined` if not found / blank.
+ */
+function resolveUserVarForToken(segment, userVarMap) {
+  if (!userVarMap || typeof userVarMap !== 'object') return undefined;
+  const mMustache = segment.match(MUSTACHE_TOKEN_INNER_NAME_REGEX);
+  const mDlt = segment.match(DLT_HASH_TOKEN_INNER_NAME_REGEX);
+  const innerName = ((mMustache ? mMustache[1] : (mDlt ? mDlt[1] : '')) ?? '').trim();
+  if (!innerName) return undefined;
+  const direct = userVarMap[innerName];
+  if (direct != null && String(direct).trim() !== '') return String(direct);
+  const hit = Object.keys(userVarMap).find((k) => k === innerName || k.endsWith(`.${innerName}`));
+  if (hit != null && userVarMap[hit] != null && String(userVarMap[hit]).trim() !== '') return String(userVarMap[hit]);
+  return undefined;
+}
+
+/**
+ * SMS / DLT template preview: replace `{{…}}` / `{#…#}` tokens using `varMapData` keys `${token}_${index}`.
+ * Used by SmsTraiEdit (RCS SMS fallback) and UnifiedPreview fallback SMS bubble.
+ * DLT `{#…#}`: empty / unset slot values show the raw token (matches DLT preview UX); mustache `{{…}}` still
+ * resolves to empty when the slot is cleared.
+ *
+ * @param {string} templateStr
+ * @param {Object} varMapData - Slot map (`${token}_${index}` → value)
+ * @param {Object|null} [userVarMap] - Optional Test & Preview custom values; used as fallback when a slot
+ *   is absent or blank. When omitted the function behaves identically to its original two-argument form.
+ */
+export const getFallbackResolvedContent = (templateStr = '', varMapData = {}, userVarMap = null) => {
+  const fallbackVarSlotMap = varMapData ?? {};
+  const templateSegments = splitTemplateVarString(templateStr, COMBINED_SMS_TEMPLATE_VAR_REGEX);
+  return templateSegments
+    .map((segment, segmentIndex) => {
+      const isVariableToken = typeof segment === 'string' && isAnyTemplateVarToken(segment);
+      if (!isVariableToken) return segment;
+      const slotKey = `${segment}_${segmentIndex}`;
+      if (Object.prototype.hasOwnProperty.call(fallbackVarSlotMap, slotKey)) {
+        const slotValue = fallbackVarSlotMap[slotKey];
+        if (isDltHashVarToken(segment)) {
+          if (slotValue == null || String(slotValue).trim() === '') {
+            if (userVarMap) { const uv = resolveUserVarForToken(segment, userVarMap); if (uv !== undefined) return uv; }
+            return segment;
+          }
+          return String(slotValue);
+        }
+        if (slotValue != null && String(slotValue).trim() !== '') return String(slotValue);
+        if (userVarMap) { const uv = resolveUserVarForToken(segment, userVarMap); if (uv !== undefined) return uv; }
+        return '';
+      }
+      if (userVarMap) { const uv = resolveUserVarForToken(segment, userVarMap); if (uv !== undefined) return uv; }
+      if (isDltHashVarToken(segment)) return segment;
+      return '';
+    })
+    .join('');
+};
+
+/**
+ * SMS fallback **card** (library list): show filled slot text; if a slot is empty, unset, or
+ * whitespace-only, show the raw `{{…}}` / `{#…#}` token so “save without labels” still shows
+ * `{#var#}` in the card. {@link getFallbackResolvedContent} keeps DLT placeholders in preview when
+ * slots are empty; mustache cleared slots can still render empty.
+ */
+export const getFallbackResolvedContentForCardDisplay = (templateStr = '', varMapData = {}) => {
+  const fallbackVarSlotMap = varMapData ?? {};
+  const templateSegments = splitTemplateVarString(templateStr, COMBINED_SMS_TEMPLATE_VAR_REGEX);
+  return templateSegments
+    .map((segment, segmentIndex) => {
+      const isVariableToken = typeof segment === 'string' && isAnyTemplateVarToken(segment);
+      if (!isVariableToken) return segment;
+      const slotKey = `${segment}_${segmentIndex}`;
+      if (Object.prototype.hasOwnProperty.call(fallbackVarSlotMap, slotKey)) {
+        const slotValue = fallbackVarSlotMap[slotKey];
+        if (slotValue == null) return segment;
+        const str = String(slotValue);
+        if (str.trim() === '') return segment;
+        return str;
+      }
+      return segment;
+    })
+    .join('');
+};

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#}');
+    });
+  });
+});