@capillarytech/creatives-library 9.0.15-alpha.3 → 9.0.16-beta.0

package/v2Containers/Rcs/rcsLibraryHydrationUtils.js

@@ -1,227 +0,0 @@
-import isEmpty from 'lodash/isEmpty';
-import get from 'lodash/get';
-import { RCS_SMS_FALLBACK_VAR_MAPPED_PROP } from '../../v2Components/CommonTestAndPreview/constants';
-import {
-  RCS_NUMERIC_VAR_NAME_REGEX,
-  RCS_CARD_VAR_MAPPED_SEMANTIC_KEY_REGEX,
-  REGEX_SPECIAL_CHARS_ESCAPE_PATTERN,
-  RCS_MUSTACHE_WRAPPED_REGEX,
-} from './constants';
-
-/** RCS card `cardVarMapped` / `rcsCardVarMapped` only (SMS fallback slot keys stay on `smsFallBackContent`). */
-export function pickRcsCardVarMappedEntries(record) {
-  if (record == null || typeof record !== 'object' || Array.isArray(record)) return {};
-  return Object.fromEntries(
-    Object.entries(record).filter(([k]) => {
-      const key = String(k);
-      return (
-        RCS_NUMERIC_VAR_NAME_REGEX.test(key)
-        || RCS_CARD_VAR_MAPPED_SEMANTIC_KEY_REGEX.test(key)
-      );
-    }),
-  );
-}
-
-/**
- * Nested `versions…smsFallBackContent` and root `smsFallBackContent` (CreativesContainer mirror)
- * can diverge. Merge explicitly (avoid `get(..., {}) || root` — `{}` is truthy and blocks fallback).
- *
- * When both exist, **nested wins on overlap**: the canonical RCS path is what `createPayload` / submit
- * update; the root mirror can lag behind campaign parent state and would otherwise keep old
- * `message` / `rcsSmsFallbackVarMapped` in hydration and approval payloads.
- */
-export function mergeRcsSmsFallBackContentFromDetails(details) {
-  if (!details || typeof details !== 'object') return {};
-  const nestedSmsFallback = details?.versions?.base?.content?.RCS?.smsFallBackContent;
-  const rootSmsFallback = details?.smsFallBackContent;
-  const nestedRecord =
-    nestedSmsFallback != null && typeof nestedSmsFallback === 'object' ? nestedSmsFallback : {};
-  const rootRecord =
-    rootSmsFallback != null && typeof rootSmsFallback === 'object' ? rootSmsFallback : {};
-  return { ...rootRecord, ...nestedRecord };
-}
-
-/**
- * Merge SMS fallback slot maps from API/templateData (`apiShape`) and editor state (`localShape`).
- * Spreading `{ ...api, ...local }` lets `rcsSmsFallbackVarMapped: {}` on local wipe a populated API map,
- * which keeps Done disabled in DLT campaigns until fixed.
- */
-export function mergeRcsSmsFallbackVarMapLayers(apiShape = {}, localShape = {}) {
-  const readMap = (o) => {
-    if (!o || typeof o !== 'object') return {};
-    const camel = o.rcsSmsFallbackVarMapped;
-    const kebab = o['rcs-sms-fallback-var-mapped'];
-    const src =
-      camel && typeof camel === 'object'
-        ? camel
-        : kebab && typeof kebab === 'object'
-          ? kebab
-          : {};
-    return { ...src };
-  };
-  return { ...readMap(apiShape), ...readMap(localShape) };
-}
-
-/**
- * First non-empty trimmed string for SMS fallback body used in DLT slot checks / payload `templateContent`.
- * Prefer **raw** template fields before resolved `message` so `{#…#}` / `{{…}}` tokens are not lost
- * when `message` is consumer-resolved text (campaigns).
- */
-/**
- * Whether an SMS fallback object carries template body, name, or var-map data (same rule as Rcs `createPayload`).
- */
-export function hasMeaningfulSmsFallbackShape(smsFallback) {
-  return !!(
-    smsFallback
-    && (
-      String(
-        smsFallback.content
-        || smsFallback.templateContent
-        || smsFallback.message
-        || smsFallback.smsContent
-        || smsFallback.smsTemplateContent
-        || '',
-      ).trim() !== ''
-      || String(smsFallback.templateName || smsFallback.smsTemplateName || '').trim() !== ''
-      || (smsFallback.rcsSmsFallbackVarMapped && Object.keys(smsFallback.rcsSmsFallbackVarMapped).length > 0)
-      || (smsFallback[RCS_SMS_FALLBACK_VAR_MAPPED_PROP]
-        && Object.keys(smsFallback[RCS_SMS_FALLBACK_VAR_MAPPED_PROP]).length > 0)
-    )
-  );
-}
-
-/**
- * Library `templateData`: merged root + nested `smsFallBackContent` (nested wins), matching `createPayload`.
- */
-export function getLibrarySmsFallbackApiBaselineFromTemplateData(templateData) {
-  const smsFromTemplateRoot = get(
-    templateData,
-    'versions.base.content.RCS.smsFallBackContent',
-  );
-  return {
-    ...(templateData?.smsFallBackContent && typeof templateData.smsFallBackContent === 'object'
-      ? templateData.smsFallBackContent
-      : {}),
-    ...(smsFromTemplateRoot && typeof smsFromTemplateRoot === 'object'
-      ? smsFromTemplateRoot
-      : {}),
-  };
-}
-
-export { extractRegisteredSenderIdsFromSmsFallbackRecord } from '../../utils/commonUtils';
-
-export function pickFirstSmsFallbackTemplateString(sms = {}) {
-  if (!sms || typeof sms !== 'object') return '';
-  const keys = [
-    'templateContent',
-    'smsTemplateContent',
-    'content',
-    'smsContent',
-    'message',
-  ];
-  for (let i = 0; i < keys.length; i += 1) {
-    const fieldValue = sms[keys[i]];
-    if (fieldValue == null) continue;
-    const trimmedValue = String(fieldValue).trim();
-    if (trimmedValue) return trimmedValue;
-  }
-  return '';
-}
-
-/**
- * Campaign reopen: payloads often keep tag/label values on numeric keys (`"1"`, `"2"`, …) while
- * semantic keys (`user_name`, …) stay `""`. Copy non-empty slot values onto empty semantic keys so
- * VarSegment editors prepopulate after Done → Edit without changing global resolve behavior.
- */
-export function syncCardVarMappedSemanticsFromSlots(
-  cardVarMappedInput,
-  templateTitle,
-  templateDesc,
-  rcsVarRegex,
-) {
-  const cardVarMappedSynced =
-    cardVarMappedInput != null && typeof cardVarMappedInput === 'object'
-      ? { ...cardVarMappedInput }
-      : {};
-  const getVarNameFromToken = (token = '') => token.replace(/^\{\{|\}\}$/g, '').trim();
-  const templateVarTokens = [
-    ...(templateTitle?.match(rcsVarRegex) ?? []),
-    ...(templateDesc?.match(rcsVarRegex) ?? []),
-  ];
-  templateVarTokens.forEach((token, slotIndexZeroBased) => {
-    const semanticVarName = getVarNameFromToken(token);
-    if (!semanticVarName) return;
-    const numericSlotKey = String(slotIndexZeroBased + 1);
-    const semanticValueTrimmed = String(cardVarMappedSynced[semanticVarName] ?? '').trim();
-    const numericSlotValueTrimmed = String(cardVarMappedSynced[numericSlotKey] ?? '').trim();
-    if (!semanticValueTrimmed && numericSlotValueTrimmed) {
-      cardVarMappedSynced[semanticVarName] = cardVarMappedSynced[numericSlotKey];
-    }
-  });
-  return cardVarMappedSynced;
-}
-
-/**
- * Maps resolved campaign values back to `{{semanticKey}}` using `cardVarMapped` keys.
- * Used when hydrating library/journey RCS edit from payloads without existing `{{…}}` tokens.
- */
-export function getUnmappedDesc(str, mapping) {
-  if (!str) return '';
-  if (!mapping || Object.keys(mapping).length === 0) return str;
-  let result = str;
-  const replacements = [];
-  Object.entries(mapping).forEach(([key, value]) => {
-    const raw = (value ?? '').toString();
-    if (!raw || raw?.trim?.() === '') return;
-    const braced = RCS_MUSTACHE_WRAPPED_REGEX.test(raw) ? raw : `{{${raw}}}`;
-    replacements.push({ key, needle: raw });
-    if (braced !== raw) replacements.push({ key, needle: braced });
-  });
-  const seen = new Set();
-  const uniq = replacements
-    .filter(({ key, needle }) => {
-      const id = `${key}::${needle}`;
-      if (seen.has(id)) return false;
-      seen.add(id);
-      return true;
-    })
-    .sort((a, b) => (b.needle.length - a.needle.length));
-
-  uniq.forEach(({ key, needle }) => {
-    if (!needle) return;
-    const escaped = needle.replace(REGEX_SPECIAL_CHARS_ESCAPE_PATTERN, '\\$&');
-    const regex = new RegExp(escaped, 'g');
-    result = result.replace(regex, `{{${key}}}`);
-  });
-  return result;
-}
-
-export function hasRcsVarTokens(str, rcsVarRegex) {
-  return (str?.match(rcsVarRegex) ?? []).length > 0;
-}
-
-/**
- * Library / journey: only run `getUnmappedDesc` when the loaded copy has no `{{…}}` tokens
- * (e.g. fully resolved campaign text). If the API already has numeric or named slots, keep as-is.
- */
-export function normalizeLibraryLoadedTitleDesc({
-  loadedTitle,
-  loadedDesc,
-  isFullMode,
-  cardVarMappedAfterHydration,
-  rcsVarRegex,
-}) {
-  const normalizedTitle =
-    !isFullMode
-    && !isEmpty(cardVarMappedAfterHydration)
-    && !hasRcsVarTokens(loadedTitle, rcsVarRegex)
-      ? getUnmappedDesc(loadedTitle, cardVarMappedAfterHydration)
-      : loadedTitle;
-  const normalizedDesc =
-    !isFullMode
-    && !isEmpty(cardVarMappedAfterHydration)
-    && !hasRcsVarTokens(loadedDesc, rcsVarRegex)
-      ? getUnmappedDesc(loadedDesc, cardVarMappedAfterHydration)
-      : loadedDesc;
-  return { normalizedTitle, normalizedDesc };
-}

package/v2Containers/Rcs/tests/rcsLibraryHydrationUtils.test.js

@@ -1,318 +0,0 @@
-import {
-  getUnmappedDesc,
-  hasRcsVarTokens,
-  normalizeLibraryLoadedTitleDesc,
-  mergeRcsSmsFallBackContentFromDetails,
-  mergeRcsSmsFallbackVarMapLayers,
-  pickFirstSmsFallbackTemplateString,
-  syncCardVarMappedSemanticsFromSlots,
-  hasMeaningfulSmsFallbackShape,
-  getLibrarySmsFallbackApiBaselineFromTemplateData,
-  extractRegisteredSenderIdsFromSmsFallbackRecord,
-  pickRcsCardVarMappedEntries,
-} from '../rcsLibraryHydrationUtils';
-import { rcsVarRegex } from '../constants';
-
-describe('rcsLibraryHydrationUtils', () => {
-  describe('mergeRcsSmsFallBackContentFromDetails', () => {
-    it('returns empty object for missing details', () => {
-      expect(mergeRcsSmsFallBackContentFromDetails(null)).toEqual({});
-      expect(mergeRcsSmsFallBackContentFromDetails(undefined)).toEqual({});
-    });
-
-    it('merges nested RCS smsFallBackContent with root mirror; nested wins on overlap', () => {
-      const details = {
-        versions: {
-          base: {
-            content: {
-              RCS: {
-                smsFallBackContent: {
-                  smsTemplateName: 'OldName',
-                  message: 'from nested',
-                  smsContent: 'nested body',
-                },
-              },
-            },
-          },
-        },
-        smsFallBackContent: {
-          message: 'from root',
-        },
-      };
-      const out = mergeRcsSmsFallBackContentFromDetails(details);
-      expect(out.message).toBe('from nested');
-      expect(out.smsContent).toBe('nested body');
-      expect(out.smsTemplateName).toBe('OldName');
-    });
-
-    it('uses root when nested path is absent', () => {
-      const details = {
-        smsFallBackContent: { message: 'only root' },
-      };
-      expect(mergeRcsSmsFallBackContentFromDetails(details)).toEqual({ message: 'only root' });
-    });
-  });
-
-  describe('mergeRcsSmsFallbackVarMapLayers', () => {
-    it('merges API map with local so empty local object does not wipe API slots', () => {
-      const api = { rcsSmsFallbackVarMapped: { '{#a#}_0': 'x' } };
-      const local = { rcsSmsFallbackVarMapped: {} };
-      expect(mergeRcsSmsFallbackVarMapLayers(api, local)).toEqual({ '{#a#}_0': 'x' });
-    });
-
-    it('local slot values win on same key', () => {
-      const api = { rcsSmsFallbackVarMapped: { '{#a#}_0': 'old' } };
-      const local = { rcsSmsFallbackVarMapped: { '{#a#}_0': 'new' } };
-      expect(mergeRcsSmsFallbackVarMapLayers(api, local)).toEqual({ '{#a#}_0': 'new' });
-    });
-
-    it('reads kebab-case var map from a layer when camel is absent', () => {
-      const api = { 'rcs-sms-fallback-var-mapped': { '{#b#}_1': 'y' } };
-      expect(mergeRcsSmsFallbackVarMapLayers(api, {})).toEqual({ '{#b#}_1': 'y' });
-    });
-  });
-
-  describe('hasMeaningfulSmsFallbackShape', () => {
-    it('is false for empty / missing', () => {
-      expect(hasMeaningfulSmsFallbackShape(null)).toBe(false);
-      expect(hasMeaningfulSmsFallbackShape({})).toBe(false);
-    });
-
-    it('is true when template body or name or var map exists', () => {
-      expect(hasMeaningfulSmsFallbackShape({ message: 'hi' })).toBe(true);
-      expect(hasMeaningfulSmsFallbackShape({ smsTemplateName: 'T' })).toBe(true);
-      expect(hasMeaningfulSmsFallbackShape({ rcsSmsFallbackVarMapped: { '{#a#}_0': 'x' } })).toBe(true);
-    });
-  });
-
-  describe('getLibrarySmsFallbackApiBaselineFromTemplateData', () => {
-    it('merges root and nested; nested wins on overlap', () => {
-      const templateData = {
-        smsFallBackContent: { message: 'root' },
-        versions: {
-          base: {
-            content: {
-              RCS: {
-                smsFallBackContent: { message: 'nested', smsTemplateName: 'N' },
-              },
-            },
-          },
-        },
-      };
-      const out = getLibrarySmsFallbackApiBaselineFromTemplateData(templateData);
-      expect(out.message).toBe('nested');
-      expect(out.smsTemplateName).toBe('N');
-    });
-  });
-
-  describe('extractRegisteredSenderIdsFromSmsFallbackRecord', () => {
-    it('returns null for missing / empty', () => {
-      expect(extractRegisteredSenderIdsFromSmsFallbackRecord(null)).toBe(null);
-      expect(extractRegisteredSenderIdsFromSmsFallbackRecord({})).toBe(null);
-      expect(
-        extractRegisteredSenderIdsFromSmsFallbackRecord({ registeredSenderIds: [] }),
-      ).toBe(null);
-    });
-
-    it('prefers top-level registeredSenderIds', () => {
-      expect(
-        extractRegisteredSenderIdsFromSmsFallbackRecord({
-          registeredSenderIds: ['A'],
-          templateConfigs: { registeredSenderIds: ['B'] },
-        }),
-      ).toEqual(['A']);
-    });
-
-    it('reads templateConfigs.registeredSenderIds when top-level absent', () => {
-      expect(
-        extractRegisteredSenderIdsFromSmsFallbackRecord({
-          templateConfigs: { registeredSenderIds: ['DLT1', 'DLT2'] },
-        }),
-      ).toEqual(['DLT1', 'DLT2']);
-    });
-
-    it('falls back to templateConfigs.header array', () => {
-      expect(
-        extractRegisteredSenderIdsFromSmsFallbackRecord({
-          templateConfigs: { header: ['H1'] },
-        }),
-      ).toEqual(['H1']);
-    });
-  });
-
-  describe('pickFirstSmsFallbackTemplateString', () => {
-    it('prefers smsTemplateContent over resolved message so DLT tokens stay in the string', () => {
-      const sms = {
-        message: 'Hello user',
-        smsTemplateContent: 'Hello {#name#}',
-      };
-      expect(pickFirstSmsFallbackTemplateString(sms)).toBe('Hello {#name#}');
-    });
-
-    it('skips whitespace-only templateContent and uses next field', () => {
-      expect(
-        pickFirstSmsFallbackTemplateString({
-          templateContent: '   ',
-          message: 'x',
-        }),
-      ).toBe('x');
-    });
-  });
-
-  describe('getUnmappedDesc', () => {
-    it('returns empty string for falsy str', () => {
-      expect(getUnmappedDesc('', { a: '1' })).toBe('');
-      expect(getUnmappedDesc(null, { a: '1' })).toBe('');
-    });
-
-    it('returns str when mapping is empty or missing', () => {
-      expect(getUnmappedDesc('hello', null)).toBe('hello');
-      expect(getUnmappedDesc('hello', {})).toBe('hello');
-    });
-
-    it('replaces literal values with {{key}} placeholders', () => {
-      expect(getUnmappedDesc('Hi Alice', { user_name: 'Alice' })).toBe('Hi {{user_name}}');
-    });
-
-    it('skips mapping entries with empty or whitespace-only values', () => {
-      expect(getUnmappedDesc('x', { a: '', b: '   ' })).toBe('x');
-    });
-
-    it('treats already-braced raw values without duplicating braced needle', () => {
-      expect(getUnmappedDesc('v {{user_id}}', { user_id: '{{user_id}}' })).toContain('{{user_id}}');
-    });
-
-    it('adds braced needle when resolved value is not already in {{…}} form', () => {
-      const out = getUnmappedDesc('Hello Bob', { nick: 'Bob' });
-      expect(out).toBe('Hello {{nick}}');
-    });
-
-    it('ignores undefined mapping values', () => {
-      expect(getUnmappedDesc('x', { a: undefined })).toBe('x');
-    });
-
-    it('matches longer needles first to avoid partial replaces', () => {
-      const out = getUnmappedDesc('ab', { x: 'a', y: 'ab' });
-      expect(out).toBe('{{y}}');
-    });
-
-    it('escapes regex metacharacters in resolved values', () => {
-      expect(getUnmappedDesc('price 9.99', { p: '9.99' })).toBe('price {{p}}');
-    });
-  });
-
-  describe('hasRcsVarTokens', () => {
-    it('is false for empty or non-matching strings', () => {
-      expect(hasRcsVarTokens('', rcsVarRegex)).toBe(false);
-      expect(hasRcsVarTokens('plain', rcsVarRegex)).toBe(false);
-    });
-
-    it('is true when string contains {{word}} tokens', () => {
-      expect(hasRcsVarTokens('{{1}} hi', rcsVarRegex)).toBe(true);
-      expect(hasRcsVarTokens('{{user_id}}', rcsVarRegex)).toBe(true);
-      expect(hasRcsVarTokens('{{dynamic_expiry_date_after_3_days.FORMAT_1}}', rcsVarRegex)).toBe(true);
-    });
-  });
-
-  describe('normalizeLibraryLoadedTitleDesc', () => {
-    const cardVarMappedAfterHydration = { user_id: '123' };
-
-    it('returns originals in full mode', () => {
-      const out = normalizeLibraryLoadedTitleDesc({
-        loadedTitle: 'Hello 123',
-        loadedDesc: 'Desc',
-        isFullMode: true,
-        cardVarMappedAfterHydration,
-        rcsVarRegex,
-      });
-      expect(out).toEqual({ normalizedTitle: 'Hello 123', normalizedDesc: 'Desc' });
-    });
-
-    it('unmaps when library mode, map present, and no mustache tokens', () => {
-      const out = normalizeLibraryLoadedTitleDesc({
-        loadedTitle: 'Hello 123',
-        loadedDesc: 'World 123',
-        isFullMode: false,
-        cardVarMappedAfterHydration,
-        rcsVarRegex,
-      });
-      expect(out.normalizedTitle).toBe('Hello {{user_id}}');
-      expect(out.normalizedDesc).toBe('World {{user_id}}');
-    });
-
-    it('keeps {{numeric}} slots when tokens already exist', () => {
-      const out = normalizeLibraryLoadedTitleDesc({
-        loadedTitle: 'Hi {{1}}',
-        loadedDesc: 'Body 123',
-        isFullMode: false,
-        cardVarMappedAfterHydration,
-        rcsVarRegex,
-      });
-      expect(out.normalizedTitle).toBe('Hi {{1}}');
-      expect(out.normalizedDesc).toBe('Body {{user_id}}');
-    });
-
-    it('does not unmap when cardVarMappedAfterHydration is empty', () => {
-      const out = normalizeLibraryLoadedTitleDesc({
-        loadedTitle: 'Hello',
-        loadedDesc: 'D',
-        isFullMode: false,
-        cardVarMappedAfterHydration: {},
-        rcsVarRegex,
-      });
-      expect(out).toEqual({ normalizedTitle: 'Hello', normalizedDesc: 'D' });
-    });
-  });
-
-  describe('syncCardVarMappedSemanticsFromSlots', () => {
-    it('copies numeric slot values onto empty semantic keys (campaign round-trip)', () => {
-      const out = syncCardVarMappedSemanticsFromSlots(
-        { 1: '[FirstName]', user_name: '', 2: 'x', other: '' },
-        'Hi {{user_name}}',
-        'More {{other}}',
-        rcsVarRegex,
-      );
-      expect(out.user_name).toBe('[FirstName]');
-      expect(out.other).toBe('x');
-    });
-
-    it('does not overwrite non-empty semantic keys', () => {
-      const out = syncCardVarMappedSemanticsFromSlots(
-        { 1: 'from-slot', user_name: 'kept' },
-        'Hello {{user_name}}',
-        '',
-        rcsVarRegex,
-      );
-      expect(out.user_name).toBe('kept');
-    });
-  });
-
-  describe('pickRcsCardVarMappedEntries', () => {
-    it('returns {} for null, undefined, and array inputs', () => {
-      expect(pickRcsCardVarMappedEntries(null)).toEqual({});
-      expect(pickRcsCardVarMappedEntries(undefined)).toEqual({});
-      expect(pickRcsCardVarMappedEntries(['{#v#}_0', 'x'])).toEqual({});
-    });
-
-    it('keeps numeric slot keys', () => {
-      expect(pickRcsCardVarMappedEntries({ 1: 'a', 2: 'b' })).toEqual({ 1: 'a', 2: 'b' });
-    });
-
-    it('keeps semantic word keys', () => {
-      expect(pickRcsCardVarMappedEntries({ user_name: 'Alice', gt: '{{tag}}' })).toEqual({
-        user_name: 'Alice',
-        gt: '{{tag}}',
-      });
-    });
-
-    it('strips SMS fallback slot keys like {#var#}_0', () => {
-      const input = { 1: 'x', user_name: 'y', '{#promo#}_0': 'z', '{{name}}_1': 'w' };
-      const out = pickRcsCardVarMappedEntries(input);
-      expect(out).toEqual({ 1: 'x', user_name: 'y' });
-    });
-
-    it('returns {} for an empty object', () => {
-      expect(pickRcsCardVarMappedEntries({})).toEqual({});
-    });
-  });
-});

package/v2Containers/Sms/smsFormDataHelpers.js

@@ -1,67 +0,0 @@
-/**
- * Shared SMS FormBuilder formData helpers for Sms/Create (and any embedded host).
- */
-
-/**
- * @param {object} formData FormBuilder state (same shape as Sms/Create `this.state.formData`)
- * @param {number} currentTab 1-based tab index
- * @returns {string} Raw message body or ''
- */
-export function getSmsMessageFromFormData(formData, currentTab) {
-  if (formData == null || typeof formData !== 'object') {
-    return '';
-  }
-  const tab = currentTab != null && currentTab > 0 ? currentTab : 1;
-  const currentTabData = formData[tab - 1];
-  if (currentTabData && typeof currentTabData === 'object') {
-    const versionedKey = tab > 1 ? `sms-editor${tab}` : 'sms-editor';
-    if (Object.prototype.hasOwnProperty.call(currentTabData, versionedKey)) {
-      const versionedContent = currentTabData[versionedKey];
-      // Key exists — commit to this version's value rather than falling through to base.
-      // Treat null/undefined as empty so a cleared version correctly reports as empty.
-      return (versionedContent != null && versionedContent !== '') ? String(versionedContent) : '';
-    }
-    if (currentTabData['sms-editor'] != null) {
-      return String(currentTabData['sms-editor']);
-    }
-    const activeTab = currentTabData.activeTab || 'base';
-    if (currentTabData[activeTab]?.['sms-editor'] != null) {
-      return String(currentTabData[activeTab]['sms-editor']);
-    }
-    if (currentTabData.base?.['sms-editor'] != null) {
-      return String(currentTabData.base['sms-editor']);
-    }
-  }
-  const rootBase = formData.base;
-  if (rootBase && typeof rootBase === 'object' && rootBase['sms-editor'] != null) {
-    return String(rootBase['sms-editor']);
-  }
-  return '';
-}
-
-/**
- * @param {number} [tabCount] Total number of versions/tabs. When >1 all versions are checked.
- * @returns {{ isTemplateNameEmpty: boolean, isMessageEmpty: boolean }}
- */
-export function getSmsEmbeddedFooterValidity(formData, tabCount) {
-  const rawName = formData?.['template-name'];
-  const name = rawName != null && rawName !== '' ? String(rawName).trim() : '';
-
-  // Check ALL versions: if any version's message is empty, Done should be disabled.
-  // With a single version this is equivalent to the previous single-tab check.
-  const count = tabCount != null && tabCount > 1 ? tabCount : 1;
-  let isMessageEmpty = false;
-  for (let i = 1; i <= count; i++) {
-    const content = getSmsMessageFromFormData(formData, i);
-    const msg = content != null && content !== '' ? String(content).trim() : '';
-    if (!msg) {
-      isMessageEmpty = true;
-      break;
-    }
-  }
-
-  return {
-    isTemplateNameEmpty: !name,
-    isMessageEmpty,
-  };
-}