@capillarytech/creatives-library 9.0.15-alpha.1 → 9.0.16

package/utils/rcsPayloadUtils.js

@@ -1,92 +0,0 @@
-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

@@ -1,201 +0,0 @@
-/**
- * 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 !== ''
-  );
-};
-
-/**
- * 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 addUniqueVar = (name) => {
-    const trimmedName = (name || '').trim();
-    if (trimmedName && !variables.includes(trimmedName)) variables.push(trimmedName);
-  };
-  const mustacheRe = ensureGlobalRegexForExecLoop(
-    captureRegex || MUSTACHE_VAR_NAME_CAPTURE_REGEX,
-  );
-  let match;
-  while ((match = mustacheRe.exec(templateStr)) !== null) {
-    addUniqueVar(match?.[1]);
-  }
-  if (!captureRegex) {
-    const dltRe = ensureGlobalRegexForExecLoop(DLT_VAR_BODY_CAPTURE_REGEX);
-    let dltMatch;
-    while ((dltMatch = dltRe.exec(templateStr)) !== null) {
-      addUniqueVar(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/rcsPayloadUtils.test.js

@@ -1,226 +0,0 @@
-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([]);
-  });
-});