@capillarytech/creatives-library 8.0.330-alpha.0 → 8.0.331-alpha.0

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 === 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

@@ -1,204 +0,0 @@
-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/CommonTestAndPreview/previewApiUtils.js

@@ -1,59 +0,0 @@
-/**
- * Helpers for Liquid `/preview` (updateEmailPreview) responses.
- * The API may nest the payload under `data` or return fields at the top level.
- * SMS responses often use `messageBody` instead of `resolvedBody`.
- */
-
-import { getFallbackResolvedContent } from '../../utils/templateVarUtils';
-import { RCS_SMS_FALLBACK_VAR_MAPPED_PROP } from './constants';
-
-export function normalizePreviewApiPayload(raw) {
-  if (!raw || typeof raw !== 'object') return raw;
-  const next = { ...raw };
-  if (next.resolvedBody == null) {
-    const alt = next.messageBody ?? next.previewMessage ?? next.previewText;
-    if (alt != null) next.resolvedBody = alt;
-  }
-  return next;
-}
-
-/**
- * Returns a normalized preview object suitable for Redux `previewData`, or null on error / empty.
- */
-export function extractPreviewFromLiquidResponse(response) {
-  if (!response || response.error) return null;
-  if (response.errors && Array.isArray(response.errors) && response.errors.length > 0) return null;
-
-  let body;
-  if (response.data !== undefined && response.data !== null && typeof response.data === 'object') {
-    body = normalizePreviewApiPayload(response.data);
-  } else if (typeof response === 'object' && !Array.isArray(response)) {
-    body = normalizePreviewApiPayload(response);
-  } else {
-    return null;
-  }
-
-  if (!body) return null;
-  if (body.resolvedBody === undefined && body.messageBody === undefined) {
-    return null;
-  }
-  return body;
-}
-
-/**
- * RCS SMS fallback: merge template (`templateContent` / `content`) with VarSegment
- * `rcsSmsFallbackVarMapped` before Liquid /preview, tag extraction, or createMessageMeta.
- * Raw template alone is stale when the user edits slot values.
- */
-export function getSmsFallbackTextForTagExtraction(smsFallbackContext) {
-  const rawTemplateBody =
-    smsFallbackContext?.templateContent ?? smsFallbackContext?.content ?? '';
-  if (!rawTemplateBody) return '';
-  const rcsSmsFallbackVarMapped = smsFallbackContext?.[RCS_SMS_FALLBACK_VAR_MAPPED_PROP];
-  const hasRcsSmsFallbackVarMappedEntries =
-    Object.keys(rcsSmsFallbackVarMapped ?? {}).length > 0;
-  if (hasRcsSmsFallbackVarMappedEntries) {
-    return getFallbackResolvedContent(rawTemplateBody, rcsSmsFallbackVarMapped ?? {});
-  }
-  return rawTemplateBody;
-}

package/v2Components/CommonTestAndPreview/tests/previewApiUtils.test.js

@@ -1,67 +0,0 @@
-import {
-  normalizePreviewApiPayload,
-  extractPreviewFromLiquidResponse,
-  getSmsFallbackTextForTagExtraction,
-} from '../previewApiUtils';
-import { RCS_SMS_FALLBACK_VAR_MAPPED_PROP } from '../constants';
-
-describe('previewApiUtils', () => {
-  describe('normalizePreviewApiPayload', () => {
-    it('maps messageBody to resolvedBody when resolvedBody is missing', () => {
-      expect(normalizePreviewApiPayload({ messageBody: 'Hello' }).resolvedBody).toBe('Hello');
-    });
-  });
-
-  describe('extractPreviewFromLiquidResponse', () => {
-    it('accepts nested data shape', () => {
-      const r = { data: { resolvedBody: 'ok' } };
-      expect(extractPreviewFromLiquidResponse(r)).toEqual({ resolvedBody: 'ok' });
-    });
-
-    it('accepts top-level preview (typical SMS)', () => {
-      const r = { messageBody: 'sms text' };
-      expect(extractPreviewFromLiquidResponse(r)).toMatchObject({
-        messageBody: 'sms text',
-        resolvedBody: 'sms text',
-      });
-    });
-
-    it('returns null when errors array is non-empty', () => {
-      expect(extractPreviewFromLiquidResponse({ errors: [{ code: 1 }] })).toBeNull();
-    });
-  });
-
-  describe('getSmsFallbackTextForTagExtraction', () => {
-    it('returns empty string when context is missing or has no template body', () => {
-      expect(getSmsFallbackTextForTagExtraction(null)).toBe('');
-      expect(getSmsFallbackTextForTagExtraction({})).toBe('');
-      expect(getSmsFallbackTextForTagExtraction({ templateContent: '', content: '' })).toBe('');
-    });
-
-    it('returns raw template when rcsSmsFallbackVarMapped is absent or empty', () => {
-      const raw = '{{optout}} {{fullname}} test SMS';
-      expect(getSmsFallbackTextForTagExtraction({ templateContent: raw })).toBe(raw);
-      expect(getSmsFallbackTextForTagExtraction({
-        content: raw,
-        [RCS_SMS_FALLBACK_VAR_MAPPED_PROP]: {},
-      })).toBe(raw);
-    });
-
-    it('prefers templateContent over content when both are set', () => {
-      expect(getSmsFallbackTextForTagExtraction({
-        templateContent: 'A',
-        content: 'B',
-      })).toBe('A');
-    });
-
-    it('applies VarSegment slot map so preview / meta payloads are not stale vs raw template', () => {
-      const rawTemplateWithSlots = '{{optout}} tail';
-      const rcsSmsFallbackVarMappedSlots = { '{{optout}}_0': 'STOP' };
-      const resolvedFallbackText = getSmsFallbackTextForTagExtraction({
-        templateContent: rawTemplateWithSlots,
-        [RCS_SMS_FALLBACK_VAR_MAPPED_PROP]: rcsSmsFallbackVarMappedSlots,
-      });
-      expect(resolvedFallbackText).toBe('STOP tail');
-    });
-  });
-});

package/v2Components/SmsFallback/SmsFallbackLocalSelector.js

@@ -1,87 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import CreativesContainer from '../../v2Containers/CreativesContainer';
-import CapPageSpinner from '../CapPageSpinner';
-import {
-  EMBEDDED_SMS_CREATIVES_LOCATION,
-  SMS_FALLBACK_CHANNEL_KEY,
-  SMS_FALLBACK_CREATIVE_EDITOR,
-  SMS_FALLBACK_ENABLE_NEW_CHANNELS,
-} from './constants';
-
-/**
- * Reuse the exact embedded CreativesContainer SMS flow (same as normal SMS create).
- * Avoid overriding Templates with local config so "Create new" follows built-in createTemplate path.
- */
-export function SmsFallbackLocalSelector({
-  hidden,
-  fetchDetailsLoading,
-  templateList,
-  channelsToHide,
-  smsRegister,
-  onCloseCreatives,
-  onSelectTemplate,
-  filterContent,
-  location,
-  /** Required when user completes embedded SMS create/edit — `CreativesContainer` calls this on save (see `processCentralCommsMetaId`). */
-  getCreativesData,
-}) {
-  const rootClassName = [
-    'sms-fallback-selector',
-    hidden ? 'sms-fallback-selector--visually-hidden' : '',
-  ]
-    .filter(Boolean)
-    .join(' ');
-
-  return (
-    <div className={rootClassName}>
-      {fetchDetailsLoading && (
-        <div className="sms-fallback-selector__loading" aria-busy="true" aria-live="polite">
-          <CapPageSpinner spinning />
-        </div>
-      )}
-      <CreativesContainer
-        creativesMode="create"
-        location={location || EMBEDDED_SMS_CREATIVES_LOCATION}
-        templateData={null}
-        handleCloseCreatives={onCloseCreatives}
-        isFullMode={false}
-        smsRegister={smsRegister}
-        editor={SMS_FALLBACK_CREATIVE_EDITOR}
-        enableNewChannels={SMS_FALLBACK_ENABLE_NEW_CHANNELS}
-        channel={SMS_FALLBACK_CHANNEL_KEY}
-        channelsToHide={channelsToHide}
-        selectedBadges={[]}
-        localTemplatesConfig={{
-          useLocalTemplates: true,
-          localTemplates: templateList.templates,
-          localTemplatesLoading: templateList.loading,
-          localTemplatesFilterContent: filterContent,
-          localTemplatesOnPageChange: templateList.loadMore,
-          localTemplatesUseSkeleton: true,
-        }}
-        onSelectTemplate={onSelectTemplate}
-        getCreativesData={getCreativesData}
-      />
-    </div>
-  );
-}
-
-SmsFallbackLocalSelector.propTypes = {
-  hidden: PropTypes.bool,
-  fetchDetailsLoading: PropTypes.bool,
-  templateList: PropTypes.shape({
-    templates: PropTypes.array,
-    loading: PropTypes.bool,
-    loadMore: PropTypes.func,
-  }).isRequired,
-  channelsToHide: PropTypes.arrayOf(PropTypes.string),
-  smsRegister: PropTypes.any,
-  onCloseCreatives: PropTypes.func.isRequired,
-  onSelectTemplate: PropTypes.func.isRequired,
-  filterContent: PropTypes.node,
-  location: PropTypes.object,
-  getCreativesData: PropTypes.func.isRequired,
-};
-
-export default SmsFallbackLocalSelector;