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

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 v = 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 (v != null && v !== '') ? String(v) : '';
-    }
-    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,
-  };
-}

package/v2Containers/Sms/tests/smsFormDataHelpers.test.js

@@ -1,253 +0,0 @@
-import {
-  getSmsMessageFromFormData,
-  getSmsEmbeddedFooterValidity,
-} from '../smsFormDataHelpers';
-
-// ---------------------------------------------------------------------------
-// getSmsMessageFromFormData
-// ---------------------------------------------------------------------------
-
-describe('getSmsMessageFromFormData', () => {
-  describe('null / invalid formData guard', () => {
-    it('returns empty string when formData is null', () => {
-      expect(getSmsMessageFromFormData(null, 1)).toBe('');
-    });
-
-    it('returns empty string when formData is undefined', () => {
-      expect(getSmsMessageFromFormData(undefined, 1)).toBe('');
-    });
-
-    it('returns empty string when formData is a string (not an object)', () => {
-      expect(getSmsMessageFromFormData('bad', 1)).toBe('');
-    });
-
-    it('returns empty string when formData is a number', () => {
-      expect(getSmsMessageFromFormData(42, 1)).toBe('');
-    });
-  });
-
-  describe('currentTab normalisation', () => {
-    it('defaults to tab 1 when currentTab is null', () => {
-      const formData = { 0: { 'sms-editor': 'hello' } };
-      expect(getSmsMessageFromFormData(formData, null)).toBe('hello');
-    });
-
-    it('defaults to tab 1 when currentTab is undefined', () => {
-      const formData = { 0: { 'sms-editor': 'hello' } };
-      expect(getSmsMessageFromFormData(formData, undefined)).toBe('hello');
-    });
-
-    it('defaults to tab 1 when currentTab is 0', () => {
-      const formData = { 0: { 'sms-editor': 'hello' } };
-      expect(getSmsMessageFromFormData(formData, 0)).toBe('hello');
-    });
-
-    it('defaults to tab 1 when currentTab is negative', () => {
-      const formData = { 0: { 'sms-editor': 'hello' } };
-      expect(getSmsMessageFromFormData(formData, -5)).toBe('hello');
-    });
-  });
-
-  describe('versioned key lookup', () => {
-    it('uses "sms-editor" key for tab 1', () => {
-      const formData = { 0: { 'sms-editor': 'tab1 msg' } };
-      expect(getSmsMessageFromFormData(formData, 1)).toBe('tab1 msg');
-    });
-
-    it('uses "sms-editor2" versioned key for tab 2', () => {
-      const formData = { 1: { 'sms-editor2': 'tab2 msg', 'sms-editor': 'fallback' } };
-      expect(getSmsMessageFromFormData(formData, 2)).toBe('tab2 msg');
-    });
-
-    it('uses "sms-editor3" versioned key for tab 3', () => {
-      const formData = { 2: { 'sms-editor3': 'tab3 msg' } };
-      expect(getSmsMessageFromFormData(formData, 3)).toBe('tab3 msg');
-    });
-
-    it('returns empty string when versioned key exists but is null (cleared version)', () => {
-      const formData = { 1: { 'sms-editor2': null } };
-      expect(getSmsMessageFromFormData(formData, 2)).toBe('');
-    });
-
-    it('returns empty string when versioned key exists but is empty string', () => {
-      const formData = { 1: { 'sms-editor2': '' } };
-      expect(getSmsMessageFromFormData(formData, 2)).toBe('');
-    });
-
-    it('coerces a numeric value in versioned key to string', () => {
-      const formData = { 1: { 'sms-editor2': 12345 } };
-      expect(getSmsMessageFromFormData(formData, 2)).toBe('12345');
-    });
-  });
-
-  describe('"sms-editor" flat key fallback (versioned key absent)', () => {
-    it('falls back to "sms-editor" when versioned key is absent for tab 2', () => {
-      const formData = { 1: { 'sms-editor': 'flat fallback' } };
-      expect(getSmsMessageFromFormData(formData, 2)).toBe('flat fallback');
-    });
-  });
-
-  describe('activeTab nested fallback', () => {
-    it('falls back to activeTab["sms-editor"] when neither versioned key nor flat "sms-editor" is present', () => {
-      // The versioned key must be absent entirely for the activeTab fallback to be reached.
-      // (If 'sms-editor' exists but is null, the function commits to '' without falling through.)
-      const formData = {
-        0: {
-          activeTab: 'variant1',
-          variant1: { 'sms-editor': 'variant msg' },
-        },
-      };
-      expect(getSmsMessageFromFormData(formData, 1)).toBe('variant msg');
-    });
-
-    it('falls back to base["sms-editor"] when activeTab entry lacks "sms-editor" and flat key is absent', () => {
-      const formData = {
-        0: {
-          activeTab: 'variant1',
-          variant1: {},
-          base: { 'sms-editor': 'base msg' },
-        },
-      };
-      expect(getSmsMessageFromFormData(formData, 1)).toBe('base msg');
-    });
-
-    it('defaults activeTab to "base" when activeTab prop is not set and flat key is absent', () => {
-      const formData = {
-        0: {
-          base: { 'sms-editor': 'default base msg' },
-        },
-      };
-      expect(getSmsMessageFromFormData(formData, 1)).toBe('default base msg');
-    });
-  });
-
-  describe('root formData.base fallback', () => {
-    it('falls back to formData.base["sms-editor"] when tab slot is missing', () => {
-      const formData = {
-        base: { 'sms-editor': 'root base msg' },
-      };
-      expect(getSmsMessageFromFormData(formData, 1)).toBe('root base msg');
-    });
-
-    it('returns empty string when even root base has no "sms-editor"', () => {
-      const formData = { base: {} };
-      expect(getSmsMessageFromFormData(formData, 1)).toBe('');
-    });
-
-    it('returns empty string when formData has no relevant keys at all', () => {
-      expect(getSmsMessageFromFormData({}, 1)).toBe('');
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// getSmsEmbeddedFooterValidity
-// ---------------------------------------------------------------------------
-
-describe('getSmsEmbeddedFooterValidity', () => {
-  describe('isTemplateNameEmpty', () => {
-    it('is true when template-name is absent', () => {
-      const formData = { 0: { 'sms-editor': 'msg' } };
-      const { isTemplateNameEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
-      expect(isTemplateNameEmpty).toBe(true);
-    });
-
-    it('is true when template-name is empty string', () => {
-      const formData = { 'template-name': '', 0: { 'sms-editor': 'msg' } };
-      const { isTemplateNameEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
-      expect(isTemplateNameEmpty).toBe(true);
-    });
-
-    it('is true when template-name is whitespace only', () => {
-      const formData = { 'template-name': '   ', 0: { 'sms-editor': 'msg' } };
-      const { isTemplateNameEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
-      expect(isTemplateNameEmpty).toBe(true);
-    });
-
-    it('is false when template-name is a non-empty string', () => {
-      const formData = { 'template-name': 'My Template', 0: { 'sms-editor': 'msg' } };
-      const { isTemplateNameEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
-      expect(isTemplateNameEmpty).toBe(false);
-    });
-  });
-
-  describe('isMessageEmpty — single tab', () => {
-    it('is true when message is empty string', () => {
-      const formData = { 'template-name': 'T', 0: { 'sms-editor': '' } };
-      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
-      expect(isMessageEmpty).toBe(true);
-    });
-
-    it('is true when message is whitespace only', () => {
-      const formData = { 'template-name': 'T', 0: { 'sms-editor': '   ' } };
-      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
-      expect(isMessageEmpty).toBe(true);
-    });
-
-    it('is true when no sms-editor key at all', () => {
-      const formData = { 'template-name': 'T', 0: {} };
-      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
-      expect(isMessageEmpty).toBe(true);
-    });
-
-    it('is false when message is non-empty', () => {
-      const formData = { 'template-name': 'T', 0: { 'sms-editor': 'Hello world' } };
-      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
-      expect(isMessageEmpty).toBe(false);
-    });
-  });
-
-  describe('isMessageEmpty — multiple tabs', () => {
-    it('is false when all tabs have non-empty messages', () => {
-      const formData = {
-        'template-name': 'T',
-        0: { 'sms-editor': 'Tab 1 message' },
-        1: { 'sms-editor2': 'Tab 2 message' },
-        2: { 'sms-editor3': 'Tab 3 message' },
-      };
-      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData, 3);
-      expect(isMessageEmpty).toBe(false);
-    });
-
-    it('is true when the second tab has an empty message', () => {
-      const formData = {
-        'template-name': 'T',
-        0: { 'sms-editor': 'Tab 1 message' },
-        1: { 'sms-editor2': '' },
-      };
-      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData, 2);
-      expect(isMessageEmpty).toBe(true);
-    });
-
-    it('is true when the third tab has no message', () => {
-      const formData = {
-        'template-name': 'T',
-        0: { 'sms-editor': 'msg1' },
-        1: { 'sms-editor2': 'msg2' },
-        2: {},
-      };
-      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData, 3);
-      expect(isMessageEmpty).toBe(true);
-    });
-
-    it('treats tabCount=1 as single-tab check even when not explicitly provided', () => {
-      const formData = { 'template-name': 'T', 0: { 'sms-editor': 'msg' } };
-      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData);
-      expect(isMessageEmpty).toBe(false);
-    });
-  });
-
-  describe('both fields together', () => {
-    it('returns both empty when template name absent and message empty', () => {
-      const formData = { 0: { 'sms-editor': '' } };
-      const result = getSmsEmbeddedFooterValidity(formData, 1);
-      expect(result).toEqual({ isTemplateNameEmpty: true, isMessageEmpty: true });
-    });
-
-    it('returns both non-empty when template name and message are present', () => {
-      const formData = { 'template-name': 'My Template', 0: { 'sms-editor': 'Hello!' } };
-      const result = getSmsEmbeddedFooterValidity(formData, 1);
-      expect(result).toEqual({ isTemplateNameEmpty: false, isMessageEmpty: false });
-    });
-  });
-});