@capillarytech/creatives-library 9.0.56-betaa.0 → 9.0.56

package/v2Components/FormBuilder/Functional/FormBuilderShell.js

@@ -1,8 +1,7 @@
 /**
- * FormBuilderShell — the functional FormBuilder (Phase 1: SMS; Phase 2: MOBILEPUSH).
- * Owns form state in a useReducer, bridges to the legacy formData contract via the
- * codec, and validates/submits through the channel adapter. Stage A keeps the
- * channel containers unchanged.
+ * FormBuilderShell — the functional FormBuilder (Phase 1: SMS). Owns form state in a
+ * useReducer, bridges to the legacy formData contract via the codec, and validates
+ * through the channel adapter. Stage A keeps the channel containers unchanged.
  */
 
 import React, {
@@ -11,19 +10,14 @@ import React, {
 import PropTypes from 'prop-types';
 import debounce from 'lodash/debounce';
 import isEqual from 'lodash/isEqual';
-import cloneDeep from 'lodash/cloneDeep';
 import CapSpin from '@capillarytech/cap-ui-library/CapSpin';
-import CapModal from '@capillarytech/cap-ui-library/CapModal';
-import CapButton from '@capillarytech/cap-ui-library/CapButton';
 import formReducer, {
   createInitialState,
   hydrate,
   fieldChanged,
-  setActiveTab,
-  reconcileSchema,
 } from './core/store/formReducer';
 import { toLegacy, fromLegacy } from './core/store/toLegacyFormData';
-import initializeFormState, { reconcileFormState } from './core/schema/initializeFormState';
+import initializeFormState from './core/schema/initializeFormState';
 import { getChannelAdapter } from './channels/registry';
 import { createSmsRegistry } from './renderers/smsRenderers';
 import { validateLiquidTemplateContent } from '../../../utils/commonUtils';
@@ -32,9 +26,7 @@ import { SMS } from '../../../v2Containers/CreativesContainer/constants';
 import { DEFAULT as DEFAULT_MODULE, EMBEDDED } from '../../../constants/unified';
 import formMessages from '../messages';
 import SchemaForm from './layout/SchemaForm';
-import {
-  ACTIVE_TAB_INDEX, DATA_COMMIT_EVENTS, DATA_COMMIT_FIELD_TYPES, EDITOR_ERROR_KIND, HIGH_FREQ_FIELDS,
-} from './constants';
+import { ACTIVE_TAB_INDEX, EDITOR_ERROR_KIND, HIGH_FREQ_FIELDS } from './constants';
 
 const isNonEmpty = (obj) => obj && Object.keys(obj).length > 0;
 
@@ -42,6 +34,9 @@ const buildInitialState = (schema, parentFormData, channel) => (isNonEmpty(paren
   ? fromLegacy(parentFormData, { channel })
   : initializeFormState(schema || {}));
 
+// Phase 1: only SMS has renderers. Later channels return their own registry.
+const registryFor = () => createSmsRegistry();
+
 const FormBuilderShell = (props) => {
   const {
     schema,
@@ -63,19 +58,11 @@ const FormBuilderShell = (props) => {
     waitEventContextTags,
     restrictPersonalization,
     refs,
-    currentTab: currentTabProp,
-    showModal,
-    modal,
   } = props;
 
   const channel = (channelProp || schema?.channel || SMS).toUpperCase();
   const adapter = getChannelAdapter(channel);
-  // Channels ship their own registry via the adapter; SMS predates the hook and
-  // stays on its original factory.
-  const registry = useMemo(
-    () => (adapter?.createRegistry ? adapter.createRegistry() : createSmsRegistry()),
-    [channel],
-  );
+  const registry = useMemo(() => registryFor(), [channel]);
 
   const [state, dispatch] = useReducer(formReducer, channel, createInitialState);
   const [errorData, setErrorData] = useState({});
@@ -84,10 +71,6 @@ const FormBuilderShell = (props) => {
   // is still computed + emitted via onFormValidityChange on mount; only the inline
   // display is gated. Can also be driven by the container's checkValidation prop.
   const [internalCheckValidation, setInternalCheckValidation] = useState(false);
-  // Container-driven confirmation modal (MOBILEPUSH single-platform save). The
-  // container owns the content (setModalContent -> showModal/modal props); the
-  // shell owns visibility after a click, mirroring Classic's local showModal state.
-  const [modalVisible, setModalVisible] = useState(false);
 
   // refs to latest values for use inside stable/debounced callbacks
   const stateRef = useRef(state);
@@ -97,25 +80,6 @@ const FormBuilderShell = (props) => {
   const lastEmittedRef = useRef(null);
   const didInitRef = useRef(false);
   const prevStartValidationRef = useRef(startValidation);
-  const prevSchemaRef = useRef(null);
-  // Deep snapshot of the last parent formData we processed. The MOBILEPUSH
-  // containers mutate their formData IN PLACE (copy-content, tag insertion), so a
-  // reference-keyed effect would miss genuine pushes — we deep-compare on every
-  // render instead, exactly like Classic's componentWillReceiveProps.
-  const lastSeenParentRef = useRef(null);
-  // Platform validity flags from the last save-validation (MOBILEPUSH android/ios
-  // modal contract): Classic keeps these in state only after a validate pass.
-  const platformRef = useRef(null);
-  // Content snapshot of the tags prop for the tags-change re-validation
-  // (Classic.js:569-578) — containers rebuild the array each render, so identity
-  // is useless. Seeded by the init effect (init already validates with those tags).
-  const lastTagsRef = useRef(null);
-  const lastNextStateRef = useRef(null);
-  // GOLDEN parity (pinned by mpush.characterization): Classic emits
-  // this.state.tabCount in onChange, which starts at 1 and is mirrored from the
-  // tabCount PROP only when hydrating from a parent formData push (edit sync) —
-  // so the MPUSH create flow emits tabCount 1 even though the containers pass 2.
-  const emittedTabCountRef = useRef(1);
 
   // Stable handler identities for the memoized FieldSlot: these wrappers delegate to
   // the latest handler bodies (via a ref), so React.memo can bail out on sibling changes.
@@ -127,20 +91,11 @@ const FormBuilderShell = (props) => {
   const isEmbedded = location?.query?.type === EMBEDDED;
   const currentModule = tagModule || location?.query?.module || DEFAULT_MODULE;
 
-  const activeTabIndex = state?.meta?.activeTabIndex ?? ACTIVE_TAB_INDEX;
-  const currentTab = activeTabIndex + 1; // legacy 1-based (MOBILEPUSH: 1=Android, 2=iOS)
-  const tabCount = state?.tabs?.length || 1;
-  const hasTabs = Boolean(adapter?.config?.features?.tabs);
-
-  const runValidate = (legacy, extra = {}) => adapter.validate(legacy, {
+  const runValidate = (legacy) => adapter.validate(legacy, {
     tags: propsRef.current.tags,
     isFullMode,
     isEmbedded,
     currentModule,
-    restrictPersonalization: propsRef.current.restrictPersonalization,
-    currentTab: (stateRef.current?.meta?.activeTabIndex ?? ACTIVE_TAB_INDEX) + 1,
-    schema: propsRef.current.schema,
-    ...extra,
   });
 
   // Footer state (mirrors Classic's `liquidErrorMessage`). Holds the last
@@ -148,66 +103,45 @@ const FormBuilderShell = (props) => {
   // clobber each other before forwarding to the container's showLiquidErrorInFooter.
   const footerRef = useRef({ STANDARD_ERROR_MSG: [], LIQUID_ERROR_MSG: [] });
   const liquidEnabled = Boolean(adapter.config?.features?.liquid);
-  // Classic passes null as the footer's tab argument for SMS and the live 1-based
-  // currentTab for every other channel (Classic.js:1352, 1487).
-  const footerTabArg = () => (adapter.config?.footerTabArg === 'currentTab'
-    ? (stateRef.current?.meta?.activeTabIndex ?? ACTIVE_TAB_INDEX) + 1
-    : null);
 
   const pushFooter = (next) => {
     footerRef.current = { ...footerRef.current, ...next };
     if (propsRef.current.showLiquidErrorInFooter) {
-      propsRef.current.showLiquidErrorInFooter(footerRef.current, footerTabArg());
+      propsRef.current.showLiquidErrorInFooter(
+        footerRef.current,
+        channel === SMS ? null : propsRef.current.currentTab,
+      );
     }
   };
 
-  // Footer-eligible body message for `legacy`, or [] when none. Full mode shows
-  // errors inline instead, so the footer is suppressed there; library mode keeps
-  // the old flow (message goes to the footer). The extended ctx (errorData,
-  // currentTab, schema, checkValidation) feeds the MPUSH footer echo — the SMS
-  // descriptor derives everything from `legacy` and ignores the extras.
-  const standardFooterMsg = (legacy, result) => {
+  // Footer-eligible body message (brace/missing-tag) for `legacy`, or [] when none.
+  // Full mode shows the brace error inline instead, so the footer is suppressed there;
+  // library mode keeps the old flow (message goes to the footer).
+  const standardFooterMsg = (legacy) => {
     if (isFullMode || !adapter.getEditorErrorDescriptor || !intl) return [];
     const descriptor = adapter.getEditorErrorDescriptor(legacy, {
       tags: propsRef.current.tags,
       isFullMode,
       currentModule,
-      errorData: result?.errorData,
-      currentTab: (stateRef.current?.meta?.activeTabIndex ?? ACTIVE_TAB_INDEX) + 1,
-      schema: propsRef.current.schema,
-      checkValidation: internalCheckValidation
-        || Boolean(propsRef.current.checkValidation)
-        || Boolean(propsRef.current.startValidation),
-      restrictPersonalization: propsRef.current.restrictPersonalization,
     });
-    if (!descriptor) return [];
-    if (descriptor.text) return [descriptor.text];
-    return [intl.formatMessage(descriptor.message, descriptor.values)];
+    return descriptor ? [intl.formatMessage(descriptor.message, descriptor.values)] : [];
   };
 
   const emitValidity = (result, legacy) => {
     setErrorData(result.errorData);
-    if (result.platform) platformRef.current = result.platform;
     if (propsRef.current.onFormValidityChange) {
       propsRef.current.onFormValidityChange(result.isValid, result.errorData);
     }
     // Footer: clear standard errors when the form is valid; otherwise surface the
-    // body-error message (empty/generic gated per channel). Liquid errors are preserved.
+    // brace/missing-tag message (empty/generic => none). Liquid errors are preserved.
     if (liquidEnabled) {
-      pushFooter({ STANDARD_ERROR_MSG: result.isValid ? [] : standardFooterMsg(legacy, result) });
+      pushFooter({ STANDARD_ERROR_MSG: result.isValid ? [] : standardFooterMsg(legacy) });
     }
   };
 
   const emitChange = (legacy, field) => {
     lastEmittedRef.current = legacy;
-    if (propsRef.current.onChange) {
-      propsRef.current.onChange(
-        legacy,
-        emittedTabCountRef.current,
-        (stateRef.current?.meta?.activeTabIndex ?? ACTIVE_TAB_INDEX) + 1,
-        field,
-      );
-    }
+    if (propsRef.current.onChange) propsRef.current.onChange(legacy, 1, 1, field);
   };
 
   const debouncedEmit = useMemo(
@@ -217,130 +151,30 @@ const FormBuilderShell = (props) => {
   useEffect(() => () => debouncedEmit.cancel(), [debouncedEmit]);
 
   // ---- initialize once the (possibly async) schema is ready, then validate+emit ----
-  const schemaReady = Boolean(schema?.standalone || schema?.containers?.length);
+  const schemaReady = Boolean(schema?.standalone);
   useEffect(() => {
     if (schemaReady && !didInitRef.current) {
       didInitRef.current = true;
-      prevSchemaRef.current = schema;
       const init = buildInitialState(schema, propsRef.current.formData, channel);
-      if (isNonEmpty(propsRef.current.formData)) {
-        lastSeenParentRef.current = cloneDeep(propsRef.current.formData);
-        // Classic mirrors the tabCount prop only alongside a parent formData sync.
-        emittedTabCountRef.current = propsRef.current.tabCount || init.tabs?.length || 1;
-      }
       dispatch(hydrate(init));
-      lastTagsRef.current = cloneDeep(propsRef.current.tags || null);
       const legacy = toLegacy(init);
       emitValidity(runValidate(legacy), legacy);
     }
   }, [schemaReady]);
 
-  // Classic's validateForm tail always emits onFormValidityChange (Classic.js:1361)
-  // and runs on every schema change (542-559), deep-unequal parent push (516-537)
-  // and tags change (569-578) — display stays gated. The MPUSH containers gate
-  // their save flows on that maintained validity (Create/index.js:101), so these
-  // background emissions are load-bearing. SMS keeps its shipped behavior.
-  const validateOnExternalChange = Boolean(adapter.config?.features?.validateOnExternalChange);
-
-  // Background emissions must read the POST-dispatch state (a stateRef snapshot can
-  // be stale mid container-setState-cascade): hydration-family effects only ARM this
-  // flag; the [state]-keyed effect below emits once the new state has rendered.
-  const pendingBackgroundValidateRef = useRef(false);
-
-  // ---- reconcile on a genuine schema change (CTA splices, text<->image swap) ----
-  // Runs inside the reducer (reconcileSchema) — see the action's note on stale snapshots.
-  useEffect(() => {
-    if (!didInitRef.current || !schema || prevSchemaRef.current === schema) return;
-    prevSchemaRef.current = schema;
-    dispatch(reconcileSchema(schema, reconcileFormState));
-    // Classic re-validates on EVERY schema change (Classic.js:542-559).
-    const validationActive = propsRef.current.startValidation || internalCheckValidation || Boolean(propsRef.current.checkValidation);
-    if (validationActive || validateOnExternalChange) {
-      pendingBackgroundValidateRef.current = true;
-    }
-  }, [schema]);
-
-  // ---- re-hydrate on a GENUINE external parent push (edit load / discard / copy) ----
-  // No dependency array on purpose: the parent may mutate the same formData object
-  // in place (MOBILEPUSH copy-content, tag insertion), which a [parentFormData]-keyed
-  // effect would never see. The deep-compare guard keeps this a no-op on quiet renders.
+  // ---- re-hydrate on a GENUINE external parent push (edit load / discard) ----
   useEffect(() => {
     if (!didInitRef.current || !isNonEmpty(parentFormData)) return;
-    if (isEqual(parentFormData, lastSeenParentRef.current)) return; // nothing new from the parent
-    lastSeenParentRef.current = cloneDeep(parentFormData);
     const current = toLegacy(stateRef.current);
     const isEcho = isEqual(parentFormData, lastEmittedRef.current) || isEqual(parentFormData, current);
-    if (!isEcho) {
-      dispatch(hydrate(fromLegacy(parentFormData, { channel })));
-      // Classic mirrors the tabCount prop only alongside a parent formData sync.
-      emittedTabCountRef.current = propsRef.current.tabCount || emittedTabCountRef.current;
-      // Classic validates on every deep-unequal parent push (Classic.js:516-537) —
-      // this is what turns the container's isFormValid true before Create/Done.
-      if (validateOnExternalChange) {
-        pendingBackgroundValidateRef.current = true;
-      }
-    }
-  });
-
-  // ---- background validity emission from the SETTLED state (see flag above) ----
-  useEffect(() => {
-    if (!didInitRef.current || !pendingBackgroundValidateRef.current) return;
-    pendingBackgroundValidateRef.current = false;
-    const legacy = toLegacy(state);
-    emitValidity(runValidate(legacy), legacy);
-  }, [state]);
-
-  // ---- re-validate when the tag catalog changes (Classic.js:569-578) ----
-  // The containers rebuild the tags array every render (Create/index.js:1928), so
-  // compare by content, not identity. Emits validity only; display stays gated.
-  useEffect(() => {
-    if (!didInitRef.current || !validateOnExternalChange) return;
-    const nextTags = propsRef.current.tags;
-    if (!Array.isArray(nextTags) || !nextTags.length) return;
-    if (isEqual(nextTags, lastTagsRef.current)) return;
-    lastTagsRef.current = cloneDeep(nextTags);
-    const legacy = toLegacy(stateRef.current);
-    emitValidity(runValidate(legacy), legacy);
-  });
-
-  // ---- container-driven tab position (MOBILEPUSH: Create forces iOS when Android unsupported) ----
-  useEffect(() => {
-    if (!hasTabs || typeof currentTabProp !== 'number') return;
-    dispatch(setActiveTab(currentTabProp - 1));
-  }, [currentTabProp, hasTabs]);
-
-  // ---- container-driven modal visibility (mirrors Classic's props->state modal sync) ----
-  useEffect(() => {
-    setModalVisible(Boolean(showModal));
-  }, [showModal, modal]);
+    if (!isEcho) dispatch(hydrate(fromLegacy(parentFormData, { channel })));
+  }, [parentFormData]);
 
   // Submit a form that passed sync validation (mirrors Classic onSubmitWrapper).
-  // Channels with their own pipeline (MOBILEPUSH: validateMobilePushContent) run it
-  // through adapter.runSubmitPipeline; otherwise the default liquid flow applies:
-  // full mode submits directly; outside it, liquid-supported channels run liquid-tag
+  // Full mode submits directly; outside it, liquid-supported channels run liquid-tag
   // validation first — a clean result submits, an error goes to the footer and blocks.
-  const submitValidForm = (legacy, validErrorData, { singleTab = null } = {}) => {
+  const submitValidForm = (legacy, validErrorData) => {
     const currentProps = propsRef.current;
-
-    if (typeof adapter.runSubmitPipeline === 'function') {
-      adapter.runSubmitPipeline(legacy, {
-        isFullMode,
-        singleTab,
-        currentTab: (stateRef.current?.meta?.activeTabIndex ?? ACTIVE_TAB_INDEX) + 1,
-        baseLanguage: currentProps.baseLanguage,
-        getLiquidTags: currentProps.actions?.getLiquidTags,
-        formatMessage: currentProps.intl?.formatMessage,
-        messages: formMessages,
-      }, {
-        onSubmit: (payload) => currentProps.onSubmit && currentProps.onSubmit(payload),
-        pushFooter,
-        stopValidation: () => currentProps.stopValidation && currentProps.stopValidation(),
-        onFormValidityChange: (isValid, nextErrorData) => currentProps.onFormValidityChange
-          && currentProps.onFormValidityChange(isValid, nextErrorData !== undefined ? nextErrorData : validErrorData),
-      });
-      return;
-    }
-
     const runLiquid = liquidEnabled && !isFullMode;
     const getLiquidTags = currentProps.actions?.getLiquidTags;
     if (!runLiquid || typeof getLiquidTags !== 'function') {
@@ -367,28 +201,18 @@ const FormBuilderShell = (props) => {
     });
   };
 
-  // ---- startValidation rising edge -> validate, then save / prompt / stop ----
+  // ---- startValidation rising edge -> validate, then save or stop ----
   useEffect(() => {
     if (startValidation && !prevStartValidationRef.current) {
       setInternalCheckValidation(true); // reveal field error messages from now on
       debouncedEmit.flush();
       const legacy = toLegacy(stateRef.current);
-      const result = runValidate(legacy, { isSave: true });
-      if (result.platform) platformRef.current = result.platform;
-      if (result.singlePlatformPrompt) {
-        // Classic parity (Classic.js:1180-1204): the single-platform confirmation
-        // takes over — errorData is stored, the container builds the modal, and
-        // NOTHING else runs: no validity emission, no footer push, no
-        // stopValidation, no submit. The modal is the only continuation.
-        setErrorData(result.errorData);
-        if (propsRef.current.setModalContent) propsRef.current.setModalContent(result.singlePlatformPrompt);
-      } else {
-        emitValidity(result, legacy);
-        if (result.isValid) {
-          submitValidForm(legacy, result.errorData);
-        } else if (propsRef.current.stopValidation) {
-          propsRef.current.stopValidation();
-        }
+      const result = runValidate(legacy);
+      emitValidity(result, legacy);
+      if (result.isValid) {
+        submitValidForm(legacy, result.errorData);
+      } else if (propsRef.current.stopValidation) {
+        propsRef.current.stopValidation();
       }
     }
     prevStartValidationRef.current = startValidation;
@@ -400,20 +224,18 @@ const FormBuilderShell = (props) => {
   const resolvedFieldErrors = useMemo(() => {
     if (!isFullMode) return {}; // library mode: unchanged old flow (footer only)
     const editorId = adapter.config?.fieldIds?.editor;
-    const editorError = editorId && errorData?.[activeTabIndex]?.[editorId];
+    const editorError = editorId && errorData?.[ACTIVE_TAB_INDEX]?.[editorId];
     if (!editorError || !adapter.getEditorErrorDescriptor || !intl) return {};
     const descriptor = adapter.getEditorErrorDescriptor(toLegacy(stateRef.current), { tags, isFullMode, currentModule });
     if (descriptor?.kind !== EDITOR_ERROR_KIND.BRACE) return {};
     return { [editorId]: intl.formatMessage(descriptor.message, descriptor.values) };
-  }, [errorData, intl, isFullMode, currentModule, activeTabIndex]);
+  }, [errorData, intl, isFullMode, currentModule]);
 
   // ---- field change ----
   const onFieldChange = (field, value) => {
-    const liveActiveTab = stateRef.current?.meta?.activeTabIndex ?? ACTIVE_TAB_INDEX;
-    const tabIndex = field.standalone ? null : liveActiveTab;
+    const tabIndex = field.standalone ? null : ACTIVE_TAB_INDEX;
     const action = fieldChanged({ fieldId: field.id, value, tabIndex });
     const nextState = formReducer(stateRef.current, action);
-    lastNextStateRef.current = nextState;
     dispatch(action); // immediate UI update on next render
     const legacy = toLegacy(nextState);
 
@@ -423,13 +245,11 @@ const FormBuilderShell = (props) => {
       emitChange(legacy, field);
     }
 
-    // Re-validate on change while errors are shown, so a revealed error clears as
-    // soon as the field becomes valid.
+    // Re-validate on change while errors are being shown, so a revealed error clears
+    // as soon as the field becomes valid. Focus-safe because renderers don't toggle
+    // CapInput's antd suffix (see InputField), so the <input> never remounts.
     const validationActive = propsRef.current.startValidation || internalCheckValidation || Boolean(propsRef.current.checkValidation);
-    // Classic re-validates pre-save typing only under startValidation (Classic.js:334-345);
-    // MPUSH opts out of live validation via features.liveValidation:false, SMS keeps it.
-    const validateLive = liquidEnabled && !isFullMode
-      && adapter.config?.features?.liveValidation !== false;
+    const validateLive = liquidEnabled && !isFullMode;
     if (validationActive || validateLive) {
       emitValidity(runValidate(legacy), legacy);
     }
@@ -446,78 +266,14 @@ const FormBuilderShell = (props) => {
   };
 
   // ---- parent bridge: invoke container-injected handlers (Stage A compat) ----
-  // Signatures mirror Classic exactly:
-  //  - onTagSelect          -> (data, currentTab, field)          [Classic.js:2588-2591]
-  //  - data-commit events   -> (true, updatedLegacyFormData, field) [performFormDataUpdate]
-  //    (checkbox submit-actions, radio onChange, select onSelect — MOBILEPUSH only,
-  //     gated on config.features.bridgeFieldEvents so SMS behavior is untouched)
-  //  - everything else      -> (data, field.id)                   [callChildEvent tail]
   const onEvent = (field, eventName, data) => {
     const injected = field.injectedEvents?.[eventName];
     if (typeof injected !== 'function') return;
-    const parent = propsRef.current.parent;
-    if (eventName === 'discardValues') {
-      // Classic resets its own state on discard (callChildEvent 2617-2625); the
-      // create-flow container then pushes EMPTY formData, which rehydrate ignores —
-      // so the local re-init must happen here.
-      injected.call(parent, data, field.id);
-      const fresh = initializeFormState(propsRef.current.schema || {});
-      lastEmittedRef.current = null;
-      lastSeenParentRef.current = null;
-      dispatch(hydrate(fresh));
-      setErrorData({});
-      setInternalCheckValidation(false);
-      const legacy = toLegacy(fresh);
-      emitValidity(runValidate(legacy), legacy);
-      return;
-    }
     if (eventName === 'onTagSelect') {
-      injected.call(parent, data, (stateRef.current?.meta?.activeTabIndex ?? ACTIVE_TAB_INDEX) + 1, field);
-    } else if (
-      DATA_COMMIT_EVENTS.has(eventName)
-      && DATA_COMMIT_FIELD_TYPES.has(field.type)
-      && adapter.config?.features?.bridgeFieldEvents
-    ) {
-      injected.call(parent, true, toLegacy(lastNextStateRef.current || stateRef.current), field);
+      injected.call(propsRef.current.parent, data, 1, field); // Classic signature
     } else {
-      injected.call(parent, data, field.id); // saveFormData / onClick / onUpload / div onInput / …
-    }
-  };
-
-  // ---- tab switch (from TabsContainer): state dispatch + container bridge ----
-  // Replaces Classic's DOM scan (Classic.js:2526-2551) with the same observable
-  // contract: the container's injected onTabChange receives the 1-based index.
-  const onTabSwitch = (container, key) => {
-    const tabs = stateRef.current?.tabs || [];
-    let index = tabs.findIndex((tab) => `${tab?.tabKey}` === `${key}`);
-    if (index === -1) {
-      const numeric = Number(key);
-      index = Number.isNaN(numeric) ? 0 : numeric;
+      injected.call(propsRef.current.parent, data, field.id); // saveFormData / onClick
     }
-    dispatch(setActiveTab(index));
-    const injected = container?.injectedEvents?.onTabChange;
-    if (typeof injected === 'function') injected.call(propsRef.current.parent, index + 1);
-  };
-
-  // ---- confirmation modal (container-owned content, adapter-owned OK semantics) ----
-  const handleModalOk = (ev) => {
-    // antd v6 wraps button text in a <span>; use currentTarget so the button id resolves.
-    const id = (ev?.currentTarget && ev.currentTarget.id) || ev?.target?.id;
-    setModalVisible(false);
-    if (adapter.modals?.handleOk) {
-      adapter.modals.handleOk(id, {
-        platform: platformRef.current,
-        submitSingleTab: (singleTab) => {
-          const legacy = toLegacy(stateRef.current);
-          submitValidForm(legacy, errorData, { singleTab });
-        },
-      });
-    }
-  };
-
-  const handleModalCancel = () => {
-    setModalVisible(false);
-    if (propsRef.current.handleCancelModal) propsRef.current.handleCancelModal();
   };
 
   // Point the stable wrappers at the latest handler bodies (read at call time).
@@ -530,16 +286,11 @@ const FormBuilderShell = (props) => {
     errorData,
     registry,
     checkValidation: internalCheckValidation || Boolean(checkValidation),
-    // Classic's upload case is the only renderer that ALSO honors startValidation
-    // for error display (Classic.js:3663) — exposed separately for it.
-    startValidation: Boolean(startValidation),
-    activeTabIndex,
-    currentTab,
-    tabCount,
+    activeTabIndex: ACTIVE_TAB_INDEX,
+    currentTab: 1,
     onFieldChange: stableOnFieldChange,
     onFieldBlur: stableOnFieldBlur,
     onEvent: stableOnEvent,
-    onTabSwitch,
     resolvedFieldErrors,
     legacyFormData: toLegacy(state),
     channel,
@@ -563,27 +314,9 @@ const FormBuilderShell = (props) => {
   const spinning = Boolean((liquidEnabled && liquidExtractionInProgress) || metaDataStatus === REQUEST);
   const spinTip = intl?.formatMessage ? intl.formatMessage(formMessages.liquidSpinText) : '';
 
-  // Confirmation modal (Classic getModal 'confirm' variant, Classic.js:597-641).
-  // Only channels that declare modal semantics render it (MOBILEPUSH); the footer's
-  // primary button carries the modal id — that id IS the handleOk dispatch key.
-  const confirmModal = adapter.modals && modal && (
-    <CapModal
-      visible={modalVisible}
-      title={modal.title || ''}
-      onCancel={handleModalCancel}
-      footer={[
-        <CapButton key="back" onClick={handleModalCancel}>Cancel</CapButton>,
-        <CapButton key="submit" type="primary" id={modal.id} onClick={handleModalOk}>Yes</CapButton>,
-      ]}
-    >
-      {modal.body || ''}
-    </CapModal>
-  );
-
   return (
     <CapSpin spinning={spinning} tip={spinTip}>
       <SchemaForm schema={schema} renderContext={renderContext} />
-      {confirmModal}
     </CapSpin>
   );
 };
@@ -615,10 +348,6 @@ FormBuilderShell.propTypes = {
   waitEventContextTags: PropTypes.object,
   restrictPersonalization: PropTypes.bool,
   refs: PropTypes.object,
-  // Tabbed channels (MOBILEPUSH): container-pushed tab position + confirmation modal.
-  currentTab: PropTypes.number,
-  showModal: PropTypes.bool,
-  modal: PropTypes.object,
 };
 
 FormBuilderShell.defaultProps = {
@@ -632,9 +361,6 @@ FormBuilderShell.defaultProps = {
   waitEventContextTags: {},
   restrictPersonalization: false,
   refs: undefined,
-  currentTab: undefined,
-  showModal: false,
-  modal: null,
 };
 
 export default FormBuilderShell;

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

@@ -4,11 +4,9 @@
  * 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,13 +9,7 @@ export const SECTION_TYPE = {
   COL_LABEL: 'col-label',
 };
 
-// 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).
+// Leaf field types the SMS schema uses (registry keys + memoization decisions).
 export const FIELD_TYPE = {
   INPUT: 'input',
   TEXTAREA: 'textarea',
@@ -24,12 +18,6 @@ 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
@@ -39,39 +27,16 @@ export const EDITOR_ERROR_KIND = {
   MISSING: 'missing',
 };
 
-// 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,
-]);
+// 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]);
 
-// Fallback active tab for single-tab channels (SMS). Tabbed channels keep the live
-// value in reducer state (meta.activeTabIndex).
+// Phase 1 renders a single active tab (index 0); multi-tab / version machinery
+// arrives with later channels.
 export const ACTIVE_TAB_INDEX = 0;
 
-// 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 HIGH_FREQ_FIELDS = ['template-name', 'template-subject'];
 
 export const ASCII = 'ASCII';
 export const UNICODE = 'Unicode';