@capillarytech/creatives-library 9.0.61-alpha.3 → 9.0.62

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

@@ -0,0 +1,274 @@
+/**
+ * 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);
+  });
+});

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

@@ -0,0 +1,251 @@
+/**
+ * MOBILEPUSH validation — line-faithful port of Classic's validateForm MPUSH block
+ * (Classic.js:935-1218) over the legacy formData; emitted errorData is byte-identical.
+ * Every oddity below is a deliberate Classic quirk pinned by the characterization
+ * suite — see FormBuilder-V3-MPUSH-Technical-Design.md §6.1 before "fixing" any.
+ */
+
+import { validateTagsCore } from '../../../../../utils/tagValidations';
+import { hasPersonalizationTags } from '../../../../../utils/commonUtils';
+import { isUrl } from '../../../../../v2Containers/Line/Container/Wrapper/utils';
+import { DEFAULT as DEFAULT_MODULE, ANDROID, IOS } from '../../../../../constants/unified';
+import { TEMPLATE_NAME_FIELD } from '../../constants';
+import { ERROR_VALUE, TABS, CTA_RULES } from './config';
+
+const TAB_KEY_REGEX = /^\d+$/;
+const isTabKey = (key) => TAB_KEY_REGEX.test(`${key}`);
+
+// Tab metadata keys skipped when seeding a tab's error map (Classic.js:1627-1656).
+const ERROR_SEED_SKIP_KEYS = ['tabKey', 'base', 'selectedLanguages'];
+
+/** Truthy-value projection of a tab, excluding the given metadata keys. */
+const pickTruthy = (tab, excluded) => {
+  const out = {};
+  Object.keys(tab || {}).forEach((key) => {
+    if (tab[key] && !excluded.includes(key)) out[key] = tab[key];
+  });
+  return out;
+};
+
+const isEmptyObject = (obj) => !obj || Object.keys(obj).length === 0;
+
+// Classic.js:752-758 — key absent => valid; present but empty/invalid URL => invalid.
+export const isValidExternalLink = (tab, key) => {
+  if (key in (tab || {})) {
+    const url = tab[key];
+    return Boolean(url && url !== '' && isUrl(url));
+  }
+  return true;
+};
+
+// Classic's this.validateTags(content, tags, false /* isEmail */, isFullMode):
+// MPUSH consumes only .valid and .isBraceError from the core result.
+const runTagValidation = (content, { tags, currentModule, isFullMode }) => {
+  const result = validateTagsCore({
+    contentForBraceCheck: content,
+    contentForUnsubscribeScan: content,
+    tags,
+    currentModule,
+    isFullMode,
+    initialMissingTags: [], // not email — no unsubscribe enforcement
+    includeIsContentEmpty: true,
+  });
+  return result && typeof result === 'object'
+    ? result
+    : { valid: false, isBraceError: false };
+};
+
+// Classic seeds EVERY tab's error map from tab 0's keys (initializeEditErrorData).
+const seedTabErrors = (tab0) => {
+  const seeded = {};
+  Object.keys(tab0 || {}).forEach((key) => {
+    if (!ERROR_SEED_SKIP_KEYS.includes(key)) seeded[key] = false;
+  });
+  return seeded;
+};
+
+/**
+ * @param {object} formData  legacy formData ({ 'template-name', 0: {...}, 1: {...}, base })
+ * @param {object} options   { tags, isFullMode, isEmbedded, currentModule,
+ *                             restrictPersonalization, isSave, currentTab (1-based) }
+ * @returns {{ isValid, errorData, platform: { androidValid, iosValid, isOnlyAndroid,
+ *             isOnlyIos }, singlePlatformPrompt: 'android'|'ios'|null }}
+ */
+export default function validateMobilePush(formData = {}, options = {}) {
+  const {
+    tags = [],
+    isFullMode,
+    isEmbedded = false,
+    currentModule = DEFAULT_MODULE,
+    restrictPersonalization = false,
+    isSave = false,
+    currentTab = 1,
+  } = options;
+
+  let isValid = true;
+  let androidValid = true;
+  let iosValid = true;
+  let isOnlyAndroid = false;
+  let isOnlyIos = false;
+  const errorData = {};
+  let singlePlatformPrompt = null;
+
+  // Classic.js:941 — no Android tab => the WHOLE block (template-name included)
+  // is skipped and validity stays true. Quirk, preserved.
+  if (formData && formData[TABS.ANDROID]) {
+    if (isEmptyObject(pickTruthy(formData[TABS.ANDROID], ['tabKey', 'base']))) isOnlyIos = true;
+    if (isEmptyObject(pickTruthy(formData[TABS.IOS], ['tabKey', 'base']))) isOnlyAndroid = true;
+
+    Object.keys(formData).forEach((index) => {
+      const tab = formData[index];
+      let isCurrentTabValid = true;
+      // Embedded mode skips the tab that is not open (Classic.js:961-965).
+      const skipValidation = isEmbedded
+        && ((isOnlyAndroid && parseInt(index, 10) === 1) || (isOnlyIos && parseInt(index, 10) === 0))
+        && isOnlyAndroid !== isOnlyIos;
+
+      if (isTabKey(index) && tab && !skipValidation) {
+        const tabIdx = parseInt(index, 10);
+        const suffix = TABS.suffixFor(tabIdx);
+        errorData[tabIdx] = errorData[tabIdx] || seedTabErrors(formData[TABS.ANDROID]);
+        const tabErrors = errorData[tabIdx];
+
+        // --- message-editor{suffix} (Classic.js:971-998) ---
+        let message = tab[`message-editor${suffix}`];
+        if (message) {
+          message = message.trim();
+          if (message === '') {
+            tabErrors[`message-editor${suffix}`] = true;
+            isValid = false;
+            isCurrentTabValid = false;
+          } else if (restrictPersonalization && hasPersonalizationTags(message)) {
+            tabErrors[`message-editor${suffix}`] = true;
+            isValid = false;
+            isCurrentTabValid = false;
+          } else {
+            tabErrors[`message-editor${suffix}`] = false;
+            const tagValidation = runTagValidation(message, { tags, currentModule, isFullMode });
+            if (tagValidation.valid) {
+              tabErrors[`message-editor${suffix}`] = false;
+            } else {
+              const { isBraceError } = tagValidation;
+              tabErrors[`message-editor${suffix}`] = isBraceError ? ERROR_VALUE.BRACKET : true;
+              tabErrors['bracket-error'] = isBraceError && ERROR_VALUE.BRACKET;
+              isValid = false; // NOTE: isCurrentTabValid deliberately NOT cleared (Classic parity)
+            }
+          }
+        } else {
+          tabErrors[`message-editor${suffix}`] = true;
+          isValid = false; // NOTE: isCurrentTabValid deliberately NOT cleared (Classic parity)
+        }
+
+        // --- message-title{suffix} (Classic.js:1002-1030) ---
+        let title = tab[`message-title${suffix}`];
+        if (title) {
+          title = title.trim();
+          if (title === '') {
+            tabErrors[`message-title${suffix}`] = true;
+            isValid = false;
+            isCurrentTabValid = false;
+          } else if (restrictPersonalization && hasPersonalizationTags(title)) {
+            tabErrors[`message-title${suffix}`] = true;
+            isValid = false;
+            isCurrentTabValid = false;
+          } else {
+            tabErrors[`message-title${suffix}`] = false;
+            const tagValidation = runTagValidation(title, { tags, currentModule, isFullMode });
+            if (tagValidation.valid) {
+              tabErrors[`message-title${suffix}`] = false;
+            } else {
+              const { isBraceError } = tagValidation;
+              tabErrors[`message-title${suffix}`] = isBraceError ? ERROR_VALUE.BRACKET : true;
+              tabErrors['bracket-error'] = isBraceError && ERROR_VALUE.BRACKET;
+              isValid = false; // isCurrentTabValid NOT cleared (Classic parity)
+            }
+          }
+        } else {
+          // Unlike the editor, a missing title DOES clear the tab flag (Classic.js:1026-1029).
+          tabErrors[`message-title${suffix}`] = true;
+          isValid = false;
+          isCurrentTabValid = false;
+        }
+
+        // --- fixed CTA/deeplink rules (Classic.js:1037-1135), unsuffixed by design ---
+        CTA_RULES.forEach(({ fieldId, kind }) => {
+          const failed = kind === 'url'
+            ? !isValidExternalLink(tab, fieldId)
+            : tab[fieldId] === '';
+          if (failed) {
+            tabErrors[fieldId] = true;
+            isValid = false;
+            isCurrentTabValid = false;
+          } else {
+            tabErrors[fieldId] = false;
+          }
+        });
+
+        // --- image: required only when the key exists (imageSchema) (Classic.js:1137-1143) ---
+        if (typeof tab.image !== 'undefined' && tab.image === '') {
+          tabErrors.image = true;
+          isValid = false;
+          isCurrentTabValid = false;
+        } else {
+          tabErrors.image = false;
+        }
+
+        // --- dynamic deeplink custom-value keys (Classic.js:1144-1155) ---
+        Object.keys(tab).forEach((key) => {
+          if (key.indexOf('custom-value') > -1) {
+            if (tab[key] === '') {
+              tabErrors[key] = true;
+              isValid = false;
+              isCurrentTabValid = false;
+            } else {
+              tabErrors[key] = false;
+            }
+          }
+        });
+      }
+
+      // index is a string key ('0'/'1'/metadata) — Number() keeps Classic's `==` semantics.
+      if (Number(index) === TABS.ANDROID) androidValid = isCurrentTabValid;
+      else if (Number(index) === TABS.IOS) iosValid = isCurrentTabValid;
+    });
+
+    // --- template-name: root, skipped in embedded mode; failure also suppresses
+    // the single-platform modal by clearing both platform flags (Classic.js:1163-1170) ---
+    if (!isEmbedded && (!formData[TEMPLATE_NAME_FIELD] || formData[TEMPLATE_NAME_FIELD] === '')) {
+      errorData[TEMPLATE_NAME_FIELD] = true;
+      isValid = false;
+      androidValid = false;
+      iosValid = false;
+    } else {
+      errorData[TEMPLATE_NAME_FIELD] = false;
+    }
+
+    // --- single-platform save prompt (Classic.js:1171-1204) ---
+    if (isSave && (androidValid || iosValid)) {
+      const androidData = pickTruthy(formData[TABS.ANDROID], ['tabKey', 'base']);
+      if (isEmptyObject(androidData) && Number(currentTab) === 2) {
+        singlePlatformPrompt = IOS;
+      } else {
+        // Classic's inner rebuild excludes only tabKey — NOT base (line 1191). Preserved.
+        const iosData = pickTruthy(formData[TABS.IOS], ['tabKey']);
+        if (isEmptyObject(iosData) && Number(currentTab) === 1) {
+          singlePlatformPrompt = ANDROID;
+        }
+      }
+    }
+    // Classic.js:1209-1215 — the three roll-up branches are `isValid = isValid && true`
+    // no-ops; the accumulated isValid stands. isLiquidValid = isValid for MPUSH.
+  }
+
+  return {
+    isValid,
+    errorData,
+    platform: {
+      androidValid, iosValid, isOnlyAndroid, isOnlyIos,
+    },
+    singlePlatformPrompt,
+  };
+}

package/v2Components/FormBuilder/Functional/channels/registry.js

@@ -4,9 +4,11 @@
  * is a new folder + one line here.
  */
 import smsAdapter from './sms';
+import mpushAdapter from './mobilepush';
 
 const adapters = {
   SMS: smsAdapter,
+  MOBILEPUSH: mpushAdapter,
 };
 
 export const getChannelAdapter = (channel) => {

package/v2Components/FormBuilder/Functional/constants.js

@@ -9,7 +9,13 @@ export const SECTION_TYPE = {
   COL_LABEL: 'col-label',
 };
 
-// Leaf field types the SMS schema uses (registry keys + memoization decisions).
+// Container types in the layout schema (schema.containers[]). MOBILEPUSH uses a
+// single 'tabs' container carrying the Android/iOS panes.
+export const CONTAINER_TYPE = {
+  TABS: 'tabs',
+};
+
+// Leaf field types the migrated channels use (registry keys + memoization decisions).
 export const FIELD_TYPE = {
   INPUT: 'input',
   TEXTAREA: 'textarea',
@@ -18,6 +24,12 @@ export const FIELD_TYPE = {
   TAG_LIST: 'tag-list',
   SMS_PREVIEW: 'sms-preview',
   DIV: 'div',
+  // MOBILEPUSH (Phase 2)
+  RADIO_GROUP: 'radioGroup',
+  SELECT: 'select',
+  UPLOAD: 'upload',
+  ICON: 'icon',
+  MOBILE_PUSH_PREVIEW: 'mobile-push-preview',
 };
 
 // Editor-error descriptor kinds (getEditorErrorDescriptor): the brace error is shown
@@ -27,16 +39,42 @@ export const EDITOR_ERROR_KIND = {
   MISSING: 'missing',
 };
 
-// Field types whose render depends only on their own value/error (+ the
-// checkValidation/channel primitives). These go through the memoized FieldSlot;
-// derived/control fields (sms-preview, sms-count, tag-list, button) render directly.
-export const MEMOIZED_TYPES = new Set([FIELD_TYPE.INPUT, FIELD_TYPE.TEXTAREA, FIELD_TYPE.CHECKBOX]);
+// Types rendered through the memoized FieldSlot (depend only on own value/error).
+// radioGroup/select stay direct: they resolve value/options from the full legacy formData.
+export const MEMOIZED_TYPES = new Set([
+  FIELD_TYPE.INPUT,
+  FIELD_TYPE.TEXTAREA,
+  FIELD_TYPE.CHECKBOX,
+]);
+
+// Fallback active tab for single-tab channels (SMS). Tabbed channels keep the live
+// value in reducer state (meta.activeTabIndex).
+// Image types the MPUSH upload accepts (Classic.js:2746 wrong-file check).
+export const ALLOWED_IMAGE_EXTENSIONS = /(\.bmp|\.jpeg|\.png|\.gif|\.avif|\.jpg)$/i;
 
-// Phase 1 renders a single active tab (index 0); multi-tab / version machinery
-// arrives with later channels.
 export const ACTIVE_TAB_INDEX = 0;
 
-export const HIGH_FREQ_FIELDS = ['template-name', 'template-subject'];
+// Injected events called with Classic's performFormDataUpdate signature
+// (true, updatedLegacyFormData, field); everything else takes (data, field.id).
+export const DATA_COMMIT_EVENTS = new Set([
+  'addPrimaryCta',
+  'addSecondaryCta',
+  'addSecondaryCtaIos',
+  'onChange',
+  'onSelect',
+]);
+
+// Only these types reach Classic's commit path — a div's injected 'onChange'
+// must keep the tail signature, hence the type guard.
+export const DATA_COMMIT_FIELD_TYPES = new Set([
+  FIELD_TYPE.CHECKBOX,
+  FIELD_TYPE.RADIO_GROUP,
+  FIELD_TYPE.SELECT,
+]);
+
+export const TEMPLATE_NAME_FIELD = 'template-name';
+
+export const HIGH_FREQ_FIELDS = [TEMPLATE_NAME_FIELD, 'template-subject'];
 
 export const ASCII = 'ASCII';
 export const UNICODE = 'Unicode';