@capillarytech/creatives-library 9.0.59 → 9.0.60

package/v2Components/FormBuilder/Functional/channels/mobilepush/index.js

@@ -1,28 +0,0 @@
-/**
- * MOBILEPUSH channel adapter — the isolation unit for MPUSH. Bundles config + the
- * pure validate + the identity payload builder + the platform-specific submit
- * pipeline + the single-platform modal semantics + the channel's renderer
- * registry. The shell looks this up via channels/registry by `schema.channel`;
- * it imports nothing from other channels.
- */
-import { MOBILE_PUSH } from '../../../../../v2Containers/CreativesContainer/constants';
-import config from './config';
-import validate from './validate';
-import buildSubmitPayload from './buildSubmitPayload';
-import runSubmitPipeline from './runSubmitPipeline';
-import modals from './modals';
-import getEditorErrorDescriptor from './getEditorErrorDescriptor';
-import { createMpushRegistry } from '../../renderers/mpushRenderers';
-
-const mpushAdapter = {
-  channel: MOBILE_PUSH,
-  config,
-  validate,
-  buildSubmitPayload,
-  runSubmitPipeline,
-  modals,
-  getEditorErrorDescriptor,
-  createRegistry: createMpushRegistry,
-};
-
-export default mpushAdapter;

package/v2Components/FormBuilder/Functional/channels/mobilepush/modals.js

@@ -1,21 +0,0 @@
-/**
- * Single-platform save confirmation (Classic handleOk, Classic.js:2674-2709).
- * The OK button's id ('android'|'ios') is the dispatch key: confirming saves that
- * platform alone, but only if its validity flag is true — a falsy flag silently
- * closes the modal (Classic parity). Modal CONTENT stays container-owned.
- */
-
-import { ANDROID, IOS } from '../../../../../constants/unified';
-
-const mpushModals = {
-  handleOk: (id, { platform, submitSingleTab } = {}) => {
-    if (!platform || typeof submitSingleTab !== 'function') return;
-    if (id === ANDROID && platform.androidValid) {
-      submitSingleTab(ANDROID);
-    } else if (id === IOS && platform.iosValid) {
-      submitSingleTab(IOS);
-    }
-  },
-};
-
-export default mpushModals;

package/v2Components/FormBuilder/Functional/channels/mobilepush/runSubmitPipeline.js

@@ -1,45 +0,0 @@
-/**
- * MOBILEPUSH submit pipeline (Classic.js:1397-1405, 1473-1522). Full mode submits
- * the raw legacy formData (no liquid, no getChannelData); library mode runs
- * validateMobilePushContent over [androidTab, iosTab]. Classic quirks preserved:
- * the util's nested per-platform error objects go to the footer AS-IS, its initial
- * empty "clear" call still triggers stopValidation + onFormValidityChange(false),
- * its onSuccess contentToSubmit is IGNORED (the full formData is submitted), and
- * singleTab from the single-platform modal skips the other platform (1519).
- */
-
-import { validateMobilePushContent } from '../../../../../utils/commonUtils';
-
-export default function runSubmitPipeline(legacyFormData, ctx = {}, callbacks = {}) {
-  const {
-    isFullMode, singleTab, currentTab, getLiquidTags, formatMessage, messages,
-  } = ctx;
-  const {
-    onSubmit, pushFooter, stopValidation, onFormValidityChange,
-  } = callbacks;
-
-  const runLiquid = !isFullMode && typeof getLiquidTags === 'function';
-  if (!runLiquid) {
-    if (onSubmit) onSubmit(legacyFormData);
-    return;
-  }
-
-  validateMobilePushContent(legacyFormData, {
-    currentTab,
-    onError: ({ standardErrors, liquidErrors }) => {
-      if (pushFooter) pushFooter({ STANDARD_ERROR_MSG: standardErrors, LIQUID_ERROR_MSG: liquidErrors });
-      if (stopValidation) stopValidation();
-      // Block save: tell the parent the form is invalid (Classic passes the last
-      // sync errorData — the shell's callback supplies it).
-      if (onFormValidityChange) onFormValidityChange(false);
-    },
-    onSuccess: () => {
-      if (pushFooter) pushFooter({ STANDARD_ERROR_MSG: [], LIQUID_ERROR_MSG: [] });
-      if (onSubmit) onSubmit(legacyFormData);
-    },
-    getLiquidTags,
-    formatMessage,
-    messages,
-    singleTab: singleTab ? `${singleTab}`.toUpperCase() : undefined,
-  });
-}

package/v2Components/FormBuilder/Functional/channels/mobilepush/tests/getEditorErrorDescriptor.test.js

@@ -1,162 +0,0 @@
-/**
- * MPUSH getEditorErrorDescriptor — the library-mode footer echo of the active
- * tab's editor error (mirror of Classic's render-phase push, Classic.js:2885-2895).
- */
-import getEditorErrorDescriptor from '../getEditorErrorDescriptor';
-import { ERROR_VALUE } from '../config';
-import { EDITOR_ERROR_KIND } from '../../../constants';
-import formMessages from '../../../../messages';
-
-const EDITOR_ERROR_TEXT = 'Template message has unsupported/missing tags!';
-
-const schemaWithEditor = (fieldId = 'message-editor', paneIndex = 0) => {
-  const panes = [{ sections: [] }, { sections: [] }];
-  panes[paneIndex] = {
-    sections: [{
-      type: 'multicols',
-      inputFields: [{ cols: [{ id: fieldId, type: 'textarea', errorMessage: EDITOR_ERROR_TEXT }] }],
-    }],
-  };
-  return { containers: [{ id: 'pane', type: 'tabs', panes }] };
-};
-
-// Same editor field, but reached through parent -> col-label sections (the other
-// findPaneField walk branches).
-const colLabelSchema = (fieldId = 'message-editor') => ({
-  containers: [{
-    id: 'pane',
-    type: 'tabs',
-    panes: [{
-      sections: [{
-        type: 'parent',
-        childSections: [{
-          type: 'col-label',
-          inputFields: [{ id: fieldId, type: 'textarea', errorMessage: EDITOR_ERROR_TEXT }],
-        }],
-      }],
-    }, { sections: [] }],
-  }],
-});
-
-const legacyWith = (content, tabIndex = 0, fieldId = 'message-editor') => ({
-  [tabIndex]: { [fieldId]: content, tabKey: `k${tabIndex}` },
-});
-
-const baseCtx = (overrides = {}) => ({
-  isFullMode: false,
-  currentTab: 1,
-  schema: schemaWithEditor(),
-  checkValidation: true,
-  restrictPersonalization: false,
-  ...overrides,
-});
-
-describe('channels/mobilepush/getEditorErrorDescriptor', () => {
-  it('returns null in full mode (MPUSH errors show inline there, never as an inline-brace override)', () => {
-    const ctx = baseCtx({ isFullMode: true, errorData: { 0: { 'message-editor': true } } });
-    expect(getEditorErrorDescriptor(legacyWith('abc'), ctx)).toBeNull();
-  });
-
-  it('returns null when the active tab has no editor error', () => {
-    const ctx = baseCtx({ errorData: { 0: { 'message-editor': false } } });
-    expect(getEditorErrorDescriptor(legacyWith('abc'), ctx)).toBeNull();
-  });
-
-  it('echoes the schema errorMessage for a generic editor error', () => {
-    const ctx = baseCtx({ errorData: { 0: { 'message-editor': true } } });
-    expect(getEditorErrorDescriptor(legacyWith('{{unknown}}'), ctx)).toEqual({
-      text: EDITOR_ERROR_TEXT,
-      kind: EDITOR_ERROR_KIND.MISSING,
-    });
-  });
-
-  it('finds the editor field through parent -> col-label pane sections too', () => {
-    const ctx = baseCtx({ schema: colLabelSchema(), errorData: { 0: { 'message-editor': true } } });
-    expect(getEditorErrorDescriptor(legacyWith('{{unknown}}'), ctx)).toEqual({
-      text: EDITOR_ERROR_TEXT,
-      kind: EDITOR_ERROR_KIND.MISSING,
-    });
-  });
-
-  it('defaults: no arguments => null; missing currentTab resolves to tab 0', () => {
-    expect(getEditorErrorDescriptor()).toBeNull();
-    const ctx = baseCtx({ errorData: { 0: { 'message-editor': true } } });
-    delete ctx.currentTab;
-    expect(getEditorErrorDescriptor(legacyWith('abc'), ctx)).toEqual({
-      text: EDITOR_ERROR_TEXT,
-      kind: EDITOR_ERROR_KIND.MISSING,
-    });
-  });
-
-  it('an inactive tabs container hides the field => no echo (null)', () => {
-    const schema = schemaWithEditor();
-    schema.containers[0].isActive = false;
-    const ctx = baseCtx({ schema, errorData: { 0: { 'message-editor': true } } });
-    expect(getEditorErrorDescriptor(legacyWith('abc'), ctx)).toBeNull();
-  });
-
-  it('also locates the editor field among a multicols row\'s actionFields', () => {
-    const schema = schemaWithEditor();
-    const section = schema.containers[0].panes[0].sections[0];
-    section.actionFields = section.inputFields;
-    section.inputFields = [];
-    const ctx = baseCtx({ schema, errorData: { 0: { 'message-editor': true } } });
-    expect(getEditorErrorDescriptor(legacyWith('abc'), ctx)).toEqual({
-      text: EDITOR_ERROR_TEXT,
-      kind: EDITOR_ERROR_KIND.MISSING,
-    });
-  });
-
-  it('marks a brace error with the BRACE kind', () => {
-    const ctx = baseCtx({ errorData: { 0: { 'message-editor': ERROR_VALUE.BRACKET } } });
-    expect(getEditorErrorDescriptor(legacyWith('abc {{full_name'), ctx)).toEqual({
-      text: EDITOR_ERROR_TEXT,
-      kind: EDITOR_ERROR_KIND.BRACE,
-    });
-  });
-
-  it('gates EVERY error on checkValidation — no footer echo before a save attempt (Classic parity: errorData is only computed under startValidation, Classic.js:334-345)', () => {
-    const generic = { 0: { 'message-editor': true } };
-    expect(getEditorErrorDescriptor(legacyWith('{{unknown}}'), baseCtx({ errorData: generic, checkValidation: false }))).toBeNull();
-    const brace = { 0: { 'message-editor': ERROR_VALUE.BRACKET } };
-    expect(getEditorErrorDescriptor(legacyWith('abc {{full_name'), baseCtx({ errorData: brace, checkValidation: false }))).toBeNull();
-  });
-
-  it('gates the EMPTY-content error on checkValidation (hidden until Save, like the inline message)', () => {
-    const errorData = { 0: { 'message-editor': true } };
-    expect(getEditorErrorDescriptor(legacyWith(''), baseCtx({ errorData, checkValidation: false }))).toBeNull();
-    expect(getEditorErrorDescriptor(legacyWith('   '), baseCtx({ errorData, checkValidation: false }))).toBeNull();
-    expect(getEditorErrorDescriptor(legacyWith(''), baseCtx({ errorData, checkValidation: true }))).toEqual({
-      text: EDITOR_ERROR_TEXT,
-      kind: EDITOR_ERROR_KIND.MISSING,
-    });
-  });
-
-  it('returns the personalization intl descriptor when restricted tokens are present', () => {
-    const ctx = baseCtx({
-      restrictPersonalization: true,
-      errorData: { 0: { 'message-editor': true } },
-    });
-    expect(getEditorErrorDescriptor(legacyWith('hi [eventAttr]'), ctx)).toEqual({
-      message: formMessages.personalizationTagsErrorMessage,
-      kind: EDITOR_ERROR_KIND.MISSING,
-    });
-  });
-
-  it('resolves the iOS tab through the suffixed field id (currentTab=2 => message-editor2)', () => {
-    const ctx = baseCtx({
-      currentTab: 2,
-      schema: schemaWithEditor('message-editor2', 1),
-      errorData: { 1: { 'message-editor2': true } },
-    });
-    expect(getEditorErrorDescriptor(legacyWith('{{x}}', 1, 'message-editor2'), ctx)).toEqual({
-      text: EDITOR_ERROR_TEXT,
-      kind: EDITOR_ERROR_KIND.MISSING,
-    });
-  });
-
-  it('returns null when the schema pane has no errorMessage to echo', () => {
-    const ctx = baseCtx({ schema: { containers: [] }, errorData: { 0: { 'message-editor': true } } });
-    expect(getEditorErrorDescriptor(legacyWith('abc'), ctx)).toBeNull();
-  });
-});

package/v2Components/FormBuilder/Functional/channels/mobilepush/tests/modals.test.js

@@ -1,37 +0,0 @@
-/**
- * MPUSH modal semantics — Classic's single-platform handleOk (Classic.js:2674-2709):
- * the OK id dispatches a single-platform save only when that platform's last
- * validation flag is true; anything else silently closes the modal.
- */
-import mpushModals from '../modals';
-
-describe('channels/mobilepush/modals.handleOk', () => {
-  const run = (id, platform) => {
-    const submitSingleTab = jest.fn();
-    mpushModals.handleOk(id, { platform, submitSingleTab });
-    return submitSingleTab;
-  };
-
-  it('android OK + androidValid => saves android alone', () => {
-    expect(run('android', { androidValid: true, iosValid: false }))
-      .toHaveBeenCalledWith('android');
-  });
-
-  it('ios OK + iosValid => saves ios alone', () => {
-    expect(run('ios', { androidValid: false, iosValid: true }))
-      .toHaveBeenCalledWith('ios');
-  });
-
-  it('a falsy platform flag silently closes (no submit) — Classic parity', () => {
-    expect(run('android', { androidValid: false, iosValid: true })).not.toHaveBeenCalled();
-    expect(run('ios', { androidValid: true, iosValid: false })).not.toHaveBeenCalled();
-  });
-
-  it('unknown id / missing platform / missing callback are all no-ops', () => {
-    expect(run('template-back-confirm-modal', { androidValid: true, iosValid: true }))
-      .not.toHaveBeenCalled();
-    expect(run('android', null)).not.toHaveBeenCalled();
-    expect(() => mpushModals.handleOk('android', { platform: { androidValid: true } })).not.toThrow();
-    expect(() => mpushModals.handleOk('android')).not.toThrow();
-  });
-});

package/v2Components/FormBuilder/Functional/channels/mobilepush/tests/runSubmitPipeline.test.js

@@ -1,70 +0,0 @@
-/**
- * MPUSH submit pipeline — Classic's onSubmitWrapper short-circuit +
- * validateFormBuilderMPush contract (Classic.js:1397-1405, 1473-1522).
- */
-import runSubmitPipeline from '../runSubmitPipeline';
-import { validateMobilePushContent } from '../../../../../../utils/commonUtils';
-
-jest.mock('../../../../../../utils/commonUtils', () => ({
-  validateMobilePushContent: jest.fn(),
-}));
-
-const legacy = { 'template-name': 'p', 0: { 'message-editor': 'a' }, 1: {} };
-
-const buildCallbacks = () => ({
-  onSubmit: jest.fn(),
-  pushFooter: jest.fn(),
-  stopValidation: jest.fn(),
-  onFormValidityChange: jest.fn(),
-});
-
-describe('channels/mobilepush/runSubmitPipeline', () => {
-  beforeEach(() => jest.clearAllMocks());
-
-  it('full mode submits the raw legacy formData directly — no liquid validation', () => {
-    const callbacks = buildCallbacks();
-    runSubmitPipeline(legacy, { isFullMode: true, getLiquidTags: jest.fn() }, callbacks);
-    expect(callbacks.onSubmit).toHaveBeenCalledWith(legacy);
-    expect(validateMobilePushContent).not.toHaveBeenCalled();
-  });
-
-  it('library mode without getLiquidTags also submits directly', () => {
-    const callbacks = buildCallbacks();
-    runSubmitPipeline(legacy, { isFullMode: false }, callbacks);
-    expect(callbacks.onSubmit).toHaveBeenCalledWith(legacy);
-    expect(validateMobilePushContent).not.toHaveBeenCalled();
-  });
-
-  it('library mode runs the liquid pipeline; singleTab is upper-cased; success submits the FULL formData', () => {
-    const callbacks = buildCallbacks();
-    runSubmitPipeline(legacy, {
-      isFullMode: false, getLiquidTags: jest.fn(), singleTab: 'android', currentTab: 1,
-    }, callbacks);
-    const options = validateMobilePushContent.mock.calls[0][1];
-    expect(options.singleTab).toBe('ANDROID');
-    options.onSuccess('{"ignored":"single-tab json"}', 'android');
-    expect(callbacks.onSubmit).toHaveBeenCalledWith(legacy); // contentToSubmit IGNORED
-    expect(callbacks.pushFooter).toHaveBeenCalledWith({ STANDARD_ERROR_MSG: [], LIQUID_ERROR_MSG: [] });
-  });
-
-  it('error callback forwards the nested per-platform objects AS-IS, stops validation, and blocks the save', () => {
-    const callbacks = buildCallbacks();
-    runSubmitPipeline(legacy, { isFullMode: false, getLiquidTags: jest.fn() }, callbacks);
-    const options = validateMobilePushContent.mock.calls[0][1];
-    const standardErrors = { ANDROID: ['bad tag'], IOS: [], generic: [] };
-    options.onError({ standardErrors, liquidErrors: [] });
-    expect(callbacks.pushFooter).toHaveBeenCalledWith({ STANDARD_ERROR_MSG: standardErrors, LIQUID_ERROR_MSG: [] });
-    expect(callbacks.stopValidation).toHaveBeenCalled();
-    expect(callbacks.onFormValidityChange).toHaveBeenCalledWith(false);
-    expect(callbacks.onSubmit).not.toHaveBeenCalled();
-    expect(options.singleTab).toBeUndefined(); // no modal => both platforms validate
-  });
-
-  it('tolerates missing callbacks (every callback is optional)', () => {
-    runSubmitPipeline(legacy, { isFullMode: false, getLiquidTags: jest.fn() }, {});
-    const options = validateMobilePushContent.mock.calls[0][1];
-    expect(() => options.onError({ standardErrors: [], liquidErrors: [] })).not.toThrow();
-    expect(() => options.onSuccess('x')).not.toThrow();
-    expect(() => runSubmitPipeline(legacy, { isFullMode: true }, {})).not.toThrow();
-  });
-});

package/v2Components/FormBuilder/Functional/channels/mobilepush/tests/validate.test.js

@@ -1,274 +0,0 @@
-/**
- * MOBILEPUSH validate — unit tests for the line-faithful port of Classic's
- * validateForm MPUSH block (Classic.js:935-1218), including the quirks the
- * design doc pins (FormBuilder-V3-MPUSH-Technical-Design.md §6.1/§6.2).
- */
-import validateMobilePush, { isValidExternalLink } from '../validate';
-import { ERROR_VALUE } from '../config';
-
-const baseOptions = { tags: [], isFullMode: true, isEmbedded: false };
-
-const bothPlatforms = (overrides = {}) => ({
-  'template-name': 'my push',
-  "0": {
-    'message-title': 'hello', 'message-editor': 'world', "base": true, "tabKey": 'k0',
-  },
-  "1": { 'message-title2': 'bonjour', 'message-editor2': 'monde', "tabKey": 'k1' },
-  ...overrides,
-});
-
-describe('channels/mobilepush/validate', () => {
-  it('valid when both platforms carry title + message and template-name is set', () => {
-    const result = validateMobilePush(bothPlatforms(), baseOptions);
-    expect(result.isValid).toBe(true);
-    expect(result.errorData[0]['message-editor']).toBe(false);
-    expect(result.errorData[1]['message-editor2']).toBe(false);
-    expect(result.errorData['template-name']).toBe(false);
-    expect(result.platform).toEqual({
-      androidValid: true, iosValid: true, isOnlyAndroid: false, isOnlyIos: false,
-    });
-    expect(result.singlePlatformPrompt).toBeNull();
-  });
-
-  it('QUIRK: absent tab 0 skips ALL validation (template-name included) and stays valid', () => {
-    const result = validateMobilePush({ 'template-name': '' }, baseOptions);
-    expect(result.isValid).toBe(true);
-    expect(result.errorData).toEqual({});
-    expect(result.singlePlatformPrompt).toBeNull();
-  });
-
-  it('missing message => error true; missing title clears the tab flag, missing message does NOT (asymmetry)', () => {
-    // Android has a title but no message: isValid false, but androidValid STAYS true.
-    const onlyTitle = validateMobilePush(bothPlatforms({
-      0: { 'message-title': 'hello', "base": true, "tabKey": 'k0' },
-    }), baseOptions);
-    expect(onlyTitle.isValid).toBe(false);
-    expect(onlyTitle.errorData[0]['message-editor']).toBe(true);
-    expect(onlyTitle.platform.androidValid).toBe(true); // Classic parity: not cleared
-
-    // Android has a message but no title: androidValid IS cleared.
-    const onlyMessage = validateMobilePush(bothPlatforms({
-      0: { 'message-editor': 'world', "base": true, "tabKey": 'k0' },
-    }), baseOptions);
-    expect(onlyMessage.isValid).toBe(false);
-    expect(onlyMessage.errorData[0]['message-title']).toBe(true);
-    expect(onlyMessage.platform.androidValid).toBe(false);
-  });
-
-  it('brace mismatch writes the STRING error value + bracket-error, and does NOT clear the tab flag', () => {
-    const result = validateMobilePush(bothPlatforms({
-      0: {
-        'message-title': 'hello', 'message-editor': 'abc {{full_name', "base": true, "tabKey": 'k0',
-      },
-    }), baseOptions);
-    expect(result.isValid).toBe(false);
-    expect(result.errorData[0]['message-editor']).toBe(ERROR_VALUE.BRACKET);
-    expect(result.errorData[0]['bracket-error']).toBe(ERROR_VALUE.BRACKET);
-    // The single-platform modal stays reachable on tag errors (Classic parity).
-    expect(result.platform.androidValid).toBe(true);
-  });
-
-  it('template-name: required in full mode (and suppresses the platform flags); skipped when embedded', () => {
-    const full = validateMobilePush(bothPlatforms({ 'template-name': '' }), baseOptions);
-    expect(full.isValid).toBe(false);
-    expect(full.errorData['template-name']).toBe(true);
-    expect(full.platform.androidValid).toBe(false);
-    expect(full.platform.iosValid).toBe(false);
-    expect(full.singlePlatformPrompt).toBeNull(); // both flags false => no prompt
-
-    const embedded = validateMobilePush(
-      bothPlatforms({ 'template-name': '' }),
-      { ...baseOptions, isEmbedded: true },
-    );
-    expect(embedded.errorData['template-name']).toBe(false);
-    expect(embedded.isValid).toBe(true);
-  });
-
-  it('single-platform prompt: iOS empty + saving from the Android tab => "android"', () => {
-    const result = validateMobilePush(bothPlatforms({
-      1: { tabKey: 'k1' },
-    }), {
-      ...baseOptions, isSave: true, currentTab: 1,
-    });
-    expect(result.singlePlatformPrompt).toBe('android');
-    expect(result.platform.isOnlyAndroid).toBe(true);
-  });
-
-  it('single-platform prompt: Android empty + saving from the iOS tab => "ios"', () => {
-    const result = validateMobilePush(bothPlatforms({
-      0: { base: true, tabKey: 'k0' },
-    }), {
-      ...baseOptions, isSave: true, currentTab: 2,
-    });
-    expect(result.singlePlatformPrompt).toBe('ios');
-    expect(result.platform.isOnlyIos).toBe(true);
-  });
-
-  it('no prompt when the empty platform does not match the current tab (Classic co-condition)', () => {
-    // iOS empty but the user is ON the iOS tab (currentTab 2): no prompt.
-    const result = validateMobilePush(bothPlatforms({
-      1: { tabKey: 'k1' },
-    }), {
-      ...baseOptions, isSave: true, currentTab: 2,
-    });
-    expect(result.singlePlatformPrompt).toBeNull();
-  });
-
-  it('no prompt without isSave', () => {
-    const result = validateMobilePush(bothPlatforms({ 1: { tabKey: 'k1' } }), {
-      ...baseOptions, isSave: false, currentTab: 1,
-    });
-    expect(result.singlePlatformPrompt).toBeNull();
-  });
-
-  it('embedded mode skips validating the tab that is not open (empty other platform)', () => {
-    const result = validateMobilePush(bothPlatforms({
-      "1": { tabKey: 'k1' }, 'template-name': '',
-    }), {
-      ...baseOptions, isEmbedded: true,
-    });
-    // The empty iOS tab (isOnlyAndroid) is skipped entirely: no message-editor2 error.
-    expect(result.errorData[1]).toBeUndefined();
-    expect(result.isValid).toBe(true);
-  });
-
-  it('CTA rules: empty-string select fails, ABSENT key passes; labels required when present-empty', () => {
-    const failing = validateMobilePush(bothPlatforms({
-      0: {
-        'message-title': 'a',
-        'message-editor': 'b',
-        'cta-deeplink-select': '',
-        'secondary-cta-0-label': '',
-        "base": true,
-        "tabKey": 'k0',
-      },
-    }), baseOptions);
-    expect(failing.isValid).toBe(false);
-    expect(failing.errorData[0]['cta-deeplink-select']).toBe(true);
-    expect(failing.errorData[0]['secondary-cta-0-label']).toBe(true);
-    expect(failing.platform.androidValid).toBe(false);
-
-    const absent = validateMobilePush(bothPlatforms(), baseOptions);
-    expect(absent.errorData[0]['cta-deeplink-select']).toBe(false); // absent key => rule passes
-  });
-
-  it('external-link rules use isValidExternalLink semantics (scheme required)', () => {
-    const badUrl = validateMobilePush(bothPlatforms({
-      0: {
-        'message-title': 'a', 'message-editor': 'b', 'cta-deeplink-text': 'www.no-scheme.com', "base": true, "tabKey": 'k0',
-      },
-    }), baseOptions);
-    expect(badUrl.errorData[0]['cta-deeplink-text']).toBe(true);
-    expect(badUrl.isValid).toBe(false);
-
-    const goodUrl = validateMobilePush(bothPlatforms({
-      0: {
-        'message-title': 'a', 'message-editor': 'b', 'cta-deeplink-text': 'https://capillarytech.com/x', "base": true, "tabKey": 'k0',
-      },
-    }), baseOptions);
-    expect(goodUrl.errorData[0]['cta-deeplink-text']).toBe(false);
-    expect(goodUrl.isValid).toBe(true);
-  });
-
-  it('image: required only when the key exists (imageSchema); custom-value-* keys required when present', () => {
-    const result = validateMobilePush(bothPlatforms({
-      0: {
-        'message-title': 'a',
-        'message-editor': 'b',
-        "image": '',
-        'custom-value-userId-cta-deeplink-select': '',
-        "base": true,
-        "tabKey": 'k0',
-      },
-    }), baseOptions);
-    expect(result.errorData[0].image).toBe(true);
-    expect(result.errorData[0]['custom-value-userId-cta-deeplink-select']).toBe(true);
-    expect(result.isValid).toBe(false);
-
-    const textSchema = validateMobilePush(bothPlatforms(), baseOptions);
-    expect(textSchema.errorData[0].image).toBe(false); // always written, false when absent
-  });
-
-  it('personalization tokens are rejected when restrictPersonalization is on', () => {
-    const result = validateMobilePush(bothPlatforms({
-      0: {
-        'message-title': 'hi [eventAttr]', 'message-editor': 'b', "base": true, "tabKey": 'k0',
-      },
-    }), { ...baseOptions, restrictPersonalization: true });
-    expect(result.errorData[0]['message-title']).toBe(true);
-    expect(result.platform.androidValid).toBe(false);
-    expect(result.isValid).toBe(false);
-  });
-
-  it('personalization tokens in the EDITOR are also rejected (clears the tab flag)', () => {
-    const result = validateMobilePush(bothPlatforms({
-      0: {
-        'message-title': 'hi', 'message-editor': 'go [eventAttr]', "base": true, "tabKey": 'k0',
-      },
-    }), { ...baseOptions, restrictPersonalization: true });
-    expect(result.errorData[0]['message-editor']).toBe(true);
-    expect(result.platform.androidValid).toBe(false);
-  });
-
-  it('whitespace-only editor/title trim to empty and fail (both clear the tab flag)', () => {
-    const result = validateMobilePush(bothPlatforms({
-      0: {
-        'message-title': '   ', 'message-editor': '  ', "base": true, "tabKey": 'k0',
-      },
-    }), baseOptions);
-    expect(result.errorData[0]['message-editor']).toBe(true);
-    expect(result.errorData[0]['message-title']).toBe(true);
-    expect(result.platform.androidValid).toBe(false);
-    expect(result.isValid).toBe(false);
-  });
-
-  it('defaults: no arguments at all => valid (the tab-0 gate short-circuits everything)', () => {
-    const result = validateMobilePush();
-    expect(result.isValid).toBe(true);
-    expect(result.errorData).toEqual({});
-  });
-
-  it('seedTabErrors skips tabKey/base/selectedLanguages from the tab-0 key seed', () => {
-    const result = validateMobilePush(bothPlatforms({
-      0: {
-        'message-title': 'hello', 'message-editor': 'world', 'selectedLanguages': ['en'], "base": true, "tabKey": 'k0',
-      },
-    }), baseOptions);
-    expect(result.errorData[1].tabKey).toBeUndefined();
-    expect(result.errorData[1].selectedLanguages).toBeUndefined();
-    expect(result.errorData[1].base).toBeUndefined();
-  });
-
-  it('embedded with BOTH platforms empty skips nothing (isOnlyAndroid === isOnlyIos)', () => {
-    const result = validateMobilePush({
-      'template-name': 'p',
-      '0': { base: true, tabKey: 'k0' },
-      '1': { tabKey: 'k1' },
-    }, { ...baseOptions, isEmbedded: true });
-    // both tabs validated: both flagged for the missing editor/title
-    expect(result.errorData[0]['message-editor']).toBe(true);
-    expect(result.errorData[1]['message-editor2']).toBe(true);
-  });
-
-  it('brace mismatch in the TITLE writes the string error value and keeps the tab flag (Classic asymmetry)', () => {
-    const result = validateMobilePush(bothPlatforms({
-      0: {
-        'message-title': 'hi {{name', 'message-editor': 'body', "base": true, "tabKey": 'k0',
-      },
-    }), baseOptions);
-    expect(result.errorData[0]['message-title']).toBe(ERROR_VALUE.BRACKET);
-    expect(result.errorData[0]['bracket-error']).toBe(ERROR_VALUE.BRACKET);
-    expect(result.platform.androidValid).toBe(true); // NOT cleared, like the editor
-    expect(result.isValid).toBe(false);
-  });
-});
-
-describe('isValidExternalLink', () => {
-  const tab = { present: 'https://a.co/x', empty: '', invalid: 'not a url' };
-  it('absent key => valid; present-but-empty or invalid => invalid; valid url => valid', () => {
-    expect(isValidExternalLink(tab, 'missing-key')).toBe(true);
-    expect(isValidExternalLink(tab, 'empty')).toBe(false);
-    expect(isValidExternalLink(tab, 'invalid')).toBe(false);
-    expect(isValidExternalLink(tab, 'present')).toBe(true);
-  });
-});