@capillarytech/creatives-library 9.0.14-beta.0 → 9.0.14

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

@@ -1,87 +0,0 @@
-/**
- * Unit tests for the pure SMS validator (mirrors the Classic SMS validateForm
- * block). Operates on the legacy formData shape; returns legacy errorData.
- */
-
-import validateSms, { ERROR } from '../validate';
-import * as tagValidations from '../../../../../../utils/tagValidations';
-
-const fd = ({ name = 'My SMS', content = 'hello world', unicode = false } = {}) => ({
-  'template-name': name,
-  0: { 'sms-editor': content, 'unicode-validity': unicode, base: true, tabKey: 'k0' },
-});
-
-const baseCtx = { tags: [], isFullMode: true, isEmbedded: false, currentModule: 'default' };
-
-describe('validateSms', () => {
-  it('valid: ascii content + name', () => {
-    const { isValid, errorData } = validateSms(fd(), baseCtx);
-    expect(isValid).toBe(true);
-    expect(errorData['template-name']).toBe(false);
-    expect(errorData[0]['sms-editor']).toBe(false);
-    expect(errorData[0]['unicode-validity']).toBe(false);
-  });
-
-  it('tolerates default args (no formData / no options)', () => {
-    // empty form, default options -> empty content + required name both flagged
-    const { isValid, errorData } = validateSms();
-    expect(isValid).toBe(false);
-    expect(errorData[0]['sms-editor']).toBe(ERROR.GENERIC);
-    expect(errorData['template-name']).toBe(true);
-  });
-
-  it('invalid: empty content flags sms-editor with a generic error', () => {
-    const { isValid, errorData } = validateSms(fd({ content: '' }), baseCtx);
-    expect(isValid).toBe(false);
-    expect(errorData[0]['sms-editor']).toBe(ERROR.GENERIC);
-  });
-
-  it('invalid: empty template-name (non-embedded) flags template-name at root', () => {
-    const { isValid, errorData } = validateSms(fd({ name: '' }), baseCtx);
-    expect(isValid).toBe(false);
-    expect(errorData['template-name']).toBe(true);
-  });
-
-  it('invalid: unicode content with the checkbox OFF', () => {
-    const { isValid, errorData } = validateSms(fd({ content: 'नमस्ते', unicode: false }), baseCtx);
-    expect(isValid).toBe(false);
-    expect(errorData[0]['unicode-validity']).toBe(true);
-  });
-
-  it('valid: unicode content with the checkbox ON', () => {
-    const { isValid, errorData } = validateSms(fd({ content: 'नमस्ते', unicode: true }), baseCtx);
-    expect(isValid).toBe(true);
-    expect(errorData[0]['unicode-validity']).toBe(false);
-  });
-
-  it('embedded: template-name is not required', () => {
-    const { isValid, errorData } = validateSms(fd({ name: '' }), { ...baseCtx, isEmbedded: true });
-    expect(errorData['template-name']).toBe(false);
-    expect(isValid).toBe(true);
-  });
-
-  it('invalid: unbalanced braces flag a bracket error on sms-editor', () => {
-    const { isValid, errorData } = validateSms(fd({ content: 'hi {{name}' }), baseCtx);
-    expect(isValid).toBe(false);
-    expect(errorData[0]['sms-editor']).toBe(ERROR.BRACKET);
-    expect(errorData[0]['bracket-error']).toBe(ERROR.BRACKET);
-  });
-
-  it('maps a missing-tag core result -> MISSING_TAG editor error', () => {
-    // SMS passes initialMissingTags:[] so the core never reports missing tags in
-    // practice; stub it to verify validateSms maps a missing-tag result correctly.
-    jest.spyOn(tagValidations, 'validateTagsCore').mockReturnValue({ valid: false, missingTags: ['unsubscribe'], isBraceError: false });
-    const { isValid, errorData } = validateSms(fd({ content: 'hi' }), { ...baseCtx, isFullMode: false });
-    expect(isValid).toBe(false);
-    expect(errorData[0]['sms-editor']).toBe(ERROR.MISSING_TAG);
-    tagValidations.validateTagsCore.mockRestore();
-  });
-
-  it('falls back to a generic error when the core returns a non-object', () => {
-    jest.spyOn(tagValidations, 'validateTagsCore').mockReturnValue(undefined);
-    const { isValid, errorData } = validateSms(fd({ content: 'hi' }), baseCtx);
-    expect(isValid).toBe(false);
-    expect(errorData[0]['sms-editor']).toBe(ERROR.GENERIC);
-    tagValidations.validateTagsCore.mockRestore();
-  });
-});

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

@@ -1,89 +0,0 @@
-/**
- * SMS validation — pure mirror of the class component's SMS validateForm block,
- * operating on the legacy formData so the emitted errorData is byte-identical:
- * tags/braces, empty content, unicode-without-checkbox, and required template-name.
- */
-
-import { checkUnicode } from '../../../../../utils/smsCharCountV2';
-import { validateTagsCore } from '../../../../../utils/tagValidations';
-import { DEFAULT as DEFAULT_MODULE } from '../../../../../constants/unified';
-import { fieldIds, SMS_TAB } from './config';
-
-const { name: NAME_FIELD, editor: EDITOR_FIELD, unicode: UNICODE_FIELD } = fieldIds;
-
-// Same error constants the class uses (Classic.js errorMessageForTags).
-export const ERROR = {
-  MISSING_TAG: 'missingTagsError',
-  GENERIC: 'genericValidationError',
-  BRACKET: 'tagBracketCountMismatchError',
-};
-
-/**
- * @param {object} formData  legacy formData ({ 'template-name', 0: {...}, base })
- * @param {object} options   { tags, isFullMode, isEmbedded, currentModule }
- * @returns {{ isValid: boolean, errorData: object }}
- */
-export default function validateSms(formData = {}, options = {}) {
-  const {
-    tags = [],
-    isFullMode,
-    isEmbedded = false,
-    currentModule = DEFAULT_MODULE,
-  } = options;
-
-  let isValid = true;
-  const tabErrors = {};
-  const errorData = { [SMS_TAB]: tabErrors };
-  const tab = formData[SMS_TAB] || {};
-  const content = tab[EDITOR_FIELD];
-  const unicodeAllowed = tab[UNICODE_FIELD];
-  const hasUnicodeChars = content ? checkUnicode(content) : false;
-
-  // --- tags / braces ---
-  let tagValidation = { valid: false, missingTags: [], isBraceError: false };
-  if (content) {
-    const result = validateTagsCore({
-      contentForBraceCheck: content,
-      contentForUnsubscribeScan: content,
-      tags,
-      currentModule,
-      isFullMode,
-      initialMissingTags: [], // SMS is not email — no unsubscribe enforcement
-      includeIsContentEmpty: true,
-    });
-    if (result && typeof result === 'object') tagValidation = result;
-  }
-
-  if (tagValidation.valid) {
-    tabErrors[EDITOR_FIELD] = false;
-  } else {
-    const { missingTags, isBraceError } = tagValidation;
-    let editorError = ERROR.GENERIC;
-    if (missingTags?.length) editorError = ERROR.MISSING_TAG;
-    else if (isBraceError) editorError = ERROR.BRACKET;
-    tabErrors[EDITOR_FIELD] = editorError;
-    tabErrors['bracket-error'] = isBraceError && ERROR.BRACKET;
-    isValid = false;
-  }
-
-  // --- unicode / empty (can overwrite the editor error, matching the class) ---
-  if (content && hasUnicodeChars && !unicodeAllowed) {
-    tabErrors[UNICODE_FIELD] = true;
-    isValid = false;
-  } else if (!content) {
-    tabErrors[EDITOR_FIELD] = ERROR.GENERIC;
-    isValid = false;
-  } else {
-    tabErrors[UNICODE_FIELD] = false;
-  }
-
-  // --- template-name (required unless embedded) ---
-  if (!isEmbedded && !formData[NAME_FIELD]) {
-    errorData[NAME_FIELD] = true;
-    isValid = false;
-  } else {
-    errorData[NAME_FIELD] = false;
-  }
-
-  return { isValid, errorData };
-}

package/v2Components/FormBuilder/Functional/constants.js

@@ -1,42 +0,0 @@
-/**
- * Engine-level constants for the functional FormBuilder (channel-agnostic).
- */
-
-// Structural section types in the layout schema.
-export const SECTION_TYPE = {
-  PARENT: 'parent',
-  MULTICOLS: 'multicols',
-  COL_LABEL: 'col-label',
-};
-
-// Leaf field types the SMS schema uses (registry keys + memoization decisions).
-export const FIELD_TYPE = {
-  INPUT: 'input',
-  TEXTAREA: 'textarea',
-  CHECKBOX: 'checkbox',
-  BUTTON: 'button',
-  TAG_LIST: 'tag-list',
-  SMS_PREVIEW: 'sms-preview',
-  DIV: 'div',
-};
-
-// Editor-error descriptor kinds (getEditorErrorDescriptor): the brace error is shown
-// inline + footer, missing-tag is footer-only.
-export const EDITOR_ERROR_KIND = {
-  BRACE: 'brace',
-  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]);
-
-// 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'];
-
-export const ASCII = 'ASCII';
-export const UNICODE = 'Unicode';

package/v2Components/FormBuilder/Functional/core/schema/fieldRegistry.js

@@ -1,38 +0,0 @@
-/**
- * fieldRegistry — maps a schema field `type` to the React component that renders
- * it. This replaces the monolith's ~800-line render switch: adding a field type
- * means registering a renderer; a channel-specific variant is registered as an
- * override on top of the base registry, scoped to that channel's form.
- *
- * A factory (not a module-level singleton) so each FormBuilder instance / test
- * gets an isolated registry — channels never mutate a shared global.
- */
-
-export function createFieldRegistry(initial = {}) {
-  const map = new Map(Object.entries(initial));
-
-  const register = (type, component) => {
-    map.set(type, component);
-    return api; // chainable
-  };
-
-  const registerAll = (componentsByType = {}) => {
-    Object.entries(componentsByType).forEach(([type, component]) => map.set(type, component));
-    return api;
-  };
-
-  /** Resolve a renderer for a type, or null if none is registered. */
-  const resolve = (type) => (map.has(type) ? map.get(type) : null);
-
-  const has = (type) => map.has(type);
-
-  /** A child registry that inherits this one and can shadow entries (channel overrides). */
-  const extend = (overrides = {}) => createFieldRegistry({ ...Object.fromEntries(map), ...overrides });
-
-  const api = {
-    register, registerAll, resolve, has, extend,
-  };
-  return api;
-}
-
-export default createFieldRegistry;

package/v2Components/FormBuilder/Functional/core/schema/initializeFormState.js

@@ -1,85 +0,0 @@
-/**
- * initializeFormState — pure walk of a layout schema that seeds default field
- * values into the normalized state (the V3 equivalent of the class component's
- * initializeStandAloneSections / initializeMultiColSection family).
- *
- * Scope (Phase 1): SMS — a single-tab, standalone-only schema. Fields marked
- * `standalone: true` seed into `root`; all other data fields seed into tab 0.
- * `onlyDisplay` fields (buttons, preview, counter, tag-list) are NOT seeded —
- * they are non-data UI controls. Defaults match the class component: checkbox
- * => false; otherwise the schema's `value` if defined, else ''.
- *
- * NOTE: tab/version/language seeding is intentionally out of scope here — those
- * arrive with MobilePush (tabs) and Email (versions/languages). Parity of the
- * seeded shape against the monolith is asserted in PR3 against real fixtures.
- */
-
-import {
-  createInitialState,
-  emptyLiquidErrors,
-} from '../store/formReducer';
-import { SECTION_TYPE, FIELD_TYPE } from '../../constants';
-
-const defaultValueFor = (field) => {
-  if (field.type === FIELD_TYPE.CHECKBOX) return false;
-  return field.value !== undefined ? field.value : '';
-};
-
-const isDataField = (field) => Boolean(field?.id) && !field.onlyDisplay;
-
-/** Walk a section subtree (parent / multicols / col-label) and call visit() on every leaf field. */
-const visitSectionFields = (section, visit) => {
-  if (!section) return;
-  switch (section.type) {
-    case SECTION_TYPE.PARENT:
-      (section.childSections || []).forEach((child) => visitSectionFields(child, visit));
-      break;
-    case SECTION_TYPE.MULTICOLS:
-      (section.inputFields || []).forEach((row) => (row?.cols || []).forEach(visit));
-      (section.actionFields || []).forEach((row) => (row?.cols || []).forEach(visit));
-      break;
-    case SECTION_TYPE.COL_LABEL:
-      (section.inputFields || []).forEach(visit);
-      (section.actionFields || []).forEach(visit);
-      break;
-    default:
-      break;
-  }
-};
-
-let autoId = 0;
-const defaultGenerateId = () => {
-  autoId += 1;
-  return `fb-${autoId}`;
-};
-
-/**
- * @param {object} schema  the layout `definition` (with `.channel`, `.standalone`, …)
- * @param {object} [opts]
- * @param {() => string} [opts.generateId]  tab-key generator (injectable for tests)
- * @returns normalized state with defaults seeded
- */
-export default function initializeFormState(schema = {}, opts = {}) {
-  const generateId = opts.generateId || defaultGenerateId;
-  const channel = schema.channel || null;
-
-  const state = createInitialState(channel);
-  // SMS uses exactly one tab (index 0), marked base.
-  const tab0 = { fields: {}, base: true, tabKey: generateId() };
-  state.tabs = [tab0];
-  state.errors = { root: {}, tabs: [{}] };
-  state.validity = { isFormValid: false, liquidErrorMessage: emptyLiquidErrors() };
-
-  // Seed each leaf field's default in a single walk: standalone fields go to `root`,
-  // the rest to tab 0. onlyDisplay (non-data) fields are skipped.
-  const seedField = (field) => {
-    if (!isDataField(field)) return;
-    const target = field.standalone ? state.root : tab0.fields;
-    if (target[field.id] === undefined) target[field.id] = defaultValueFor(field);
-  };
-
-  const sections = schema.standalone?.sections;
-  if (sections) sections.forEach((section) => visitSectionFields(section, seedField));
-
-  return state;
-}

package/v2Components/FormBuilder/Functional/core/store/formReducer.js

@@ -1,81 +0,0 @@
-/**
- * formReducer — the single source of truth for FormBuilder form state (V3).
-*/
-
-export const ActionTypes = {
-  HYDRATE: 'fb/HYDRATE',
-  FIELD_CHANGED: 'fb/FIELD_CHANGED',
-  VALIDATION_RESULT: 'fb/VALIDATION_RESULT',
-};
-
-export const emptyLiquidErrors = () => ({ STANDARD_ERROR_MSG: [], LIQUID_ERROR_MSG: [] });
-
-/** Build a clean initial normalized state for a channel (no fields seeded). */
-export const createInitialState = (channel = null) => ({
-  meta: { channel, baseTabIndex: 0 },
-  root: {},
-  tabs: [],
-  errors: { root: {}, tabs: [] },
-  validity: { isFormValid: false, liquidErrorMessage: emptyLiquidErrors() },
-});
-
-// ---- action creators ---------------------------------------------------------
-
-/** Replace the whole normalized state (used to load an initialized/hydrated tree). */
-export const hydrate = (state) => ({ type: ActionTypes.HYDRATE, state });
-
-/**
- * Set one field's value. `tabIndex == null` targets a root (standalone) field;
- * otherwise it targets tabs[tabIndex].fields.
- */
-export const fieldChanged = ({ fieldId, value, tabIndex = null }) => ({
-  type: ActionTypes?.FIELD_CHANGED,
-  fieldId,
-  value,
-  tabIndex,
-});
-
-/** Merge a validation outcome (errors + validity) into state. */
-export const validationResult = ({ errors, isFormValid, liquidErrorMessage }) => ({
-  type: ActionTypes.VALIDATION_RESULT,
-  errors,
-  isFormValid,
-  liquidErrorMessage,
-});
-
-// ---- reducer -----------------------------------------------------------------
-
-export default function formReducer(state, action) {
-  switch (action?.type) {
-    case ActionTypes.HYDRATE:
-      return action?.state || state;
-
-    case ActionTypes.FIELD_CHANGED: {
-      const { fieldId, value, tabIndex } = action;
-      if (tabIndex == null) {
-        if (state?.root[fieldId] === value) return state; // no-op keeps identity
-        return { ...state, root: { ...state.root, [fieldId]: value } };
-      }
-      const tab = state?.tabs[tabIndex];
-      if (!tab) return state;
-      if (tab?.fields?.[fieldId] === value) return state; // no-op keeps identity
-      return {
-        ...state,
-        tabs: state?.tabs?.map((tabData, index) => index === tabIndex ? { ...tabData, fields: { ...tabData?.fields, [fieldId]: value } } : tabData),
-      };
-    }
-
-    case ActionTypes.VALIDATION_RESULT:
-      return {
-        ...state,
-        errors: action?.errors || state?.errors,
-        validity: {
-          isFormValid: Boolean(action?.isFormValid),
-          liquidErrorMessage: action?.liquidErrorMessage || state?.validity?.liquidErrorMessage,
-        },
-      };
-
-    default:
-      return state;
-  }
-}

package/v2Components/FormBuilder/Functional/core/store/selectors.js

@@ -1,30 +0,0 @@
-/**
- * selectors — pure read helpers over the normalized form state.
- *
- * Field components read their value/error through these so they receive
- * PRIMITIVE props (string/boolean) — that is what lets React.memo field
- * boundaries bail out cheaply (see the State Management Decision in the design
- * doc). Never return freshly-constructed objects from a hot-path selector.
- */
-
-/** Value of a field. `tabIndex == null` => a root (standalone) field. */
-export const selectFieldValue = (state, { fieldId, tabIndex = null }) => {
-  const { root = {}, tabs = [] } = state || {};
-  if (tabIndex == null) return root?.[fieldId];
-  return tabs?.[tabIndex]?.fields?.[fieldId];
-};
-
-/** Validation error for a field (string message or boolean), mirrors selectFieldValue. */
-export const selectFieldError = (state, { fieldId, tabIndex = null }) => {
-  const { root = {}, tabs = [] } = state?.errors || {};
-  if (tabIndex == null) return root?.[fieldId];
-  return tabs?.[tabIndex]?.[fieldId];
-};
-
-export const selectIsFormValid = (state) => state.validity.isFormValid;
-
-export const selectLiquidErrorMessage = (state) => state.validity.liquidErrorMessage;
-
-export const selectBaseTabIndex = (state) => state.meta.baseTabIndex;
-
-export const selectChannel = (state) => state.meta.channel;

package/v2Components/FormBuilder/Functional/core/store/toLegacyFormData.js

@@ -1,91 +0,0 @@
-/**
- * toLegacyFormData — codec between the normalized V3 state and the legacy
- * `formData` dialect that the channel containers + `getChannelData` consume.
- *
- * This is the compatibility contract that keeps the migration invisible to the
- * containers and the backend: the functional engine works in the normalized
- * shape, but emits `onChange(legacyFormData, ...)` and builds the save payload
- * from the exact same shape the class component produced.
- *
- * LEGACY DIALECT (SMS example):
- *   {
- *     'template-name': 'My SMS',                                   // root (standalone) fields
- *     0: { 'sms-editor': 'hi', 'unicode-validity': false,         // tab fields
- *          base: true, tabKey: '...' },                           // tab metadata
- *     base: <SAME REFERENCE as formData[0]>,                       // alias of the base tab
- *   }
- *
- * INVARIANT (unit-tested): toLegacy(fromLegacy(x)) deep-equals x.
- *   - root fields  <-> top-level non-numeric keys (excluding `base`)
- *   - tabs[i]      <-> numeric key i; base/tabKey/name are metadata, the rest are fields
- *   - `base`       <-> the SAME object reference as the base tab (never a copy)
- */
-
-const isTabKey = (key) => /^\d+$/.test(key);
-
-/** Parse a legacy `formData` object into normalized state. */
-export const fromLegacy = (legacy = {}, { channel = null } = {}) => {
-  const root = {};
-  const tabsByIndex = {};
-
-  Object.keys(legacy).forEach((key) => {
-    if (key === 'base') return; // alias — reconstructed by toLegacy, never stored
-    if (isTabKey(key)) {
-      const tabObj = legacy[key] || {};
-      const {
-        base, tabKey, name, ...fields
-      } = tabObj;
-      tabsByIndex[Number(key)] = {
-        fields: { ...fields },
-        base: Boolean(base),
-        tabKey,
-        name,
-      };
-    } else {
-      root[key] = legacy[key];
-    }
-  });
-
-  // Safe to compact: legacy tab indices are always dense 0..n-1 (class seeds formData[0];
-  // deleteVersion re-indexes without holes). Revisit only if a channel emits sparse keys.
-  const orderedIndices = Object.keys(tabsByIndex)
-    .map(Number)
-    .sort((a, b) => a - b);
-  const tabs = orderedIndices.map((index) => tabsByIndex[index]);
-
-  const foundBase = tabs.findIndex((tab) => tab?.base);
-  const baseTabIndex = foundBase === -1 ? 0 : foundBase;
-
-  return {
-    meta: { channel, baseTabIndex },
-    root,
-    tabs,
-    errors: { root: {}, tabs: tabs?.map(() => ({})) },
-    validity: { isFormValid: false, liquidErrorMessage: { STANDARD_ERROR_MSG: [], LIQUID_ERROR_MSG: [] } },
-  };
-};
-
-/** Serialize normalized state back into the legacy `formData` dialect. */
-export const toLegacy = (state) => {
-  const out = {};
-
-  // root (standalone) fields land at the top level
-  Object.assign(out, state.root);
-
-  // each tab becomes a numeric-keyed object carrying its fields + metadata
-  state.tabs.forEach((tab, index) => {
-    const tabObj = { ...tab.fields };
-    if (tab?.base) tabObj.base = true; // legacy omits `base` on non-base tabs
-    if (tab?.tabKey !== undefined) tabObj.tabKey = tab.tabKey;
-    if (tab?.name !== undefined) tabObj.name = tab.name;
-    out[index] = tabObj;
-  });
-
-  // `base` is an ALIAS (same reference) of the base tab, matching the class component
-  const baseIdx = state.meta.baseTabIndex;
-  if (out[baseIdx] !== undefined) {
-    out.base = out[baseIdx];
-  }
-
-  return out;
-};

package/v2Components/FormBuilder/Functional/index.js

@@ -1,26 +0,0 @@
-/**
- * FunctionalFormBuilder — Redux-connected entry for the functional FormBuilder.
- * Injects intl and sources the liquid action + spinner state the same way the class
- * component does, so the channel containers stay unchanged (Stage A).
- */
-
-import { connect } from 'react-redux';
-import { bindActionCreators } from 'redux';
-import { injectIntl } from 'react-intl';
-import { createStructuredSelector } from 'reselect';
-import FormBuilderShell from './FormBuilderShell';
-import { selectLiquidStateDetails, selectMetaDataStatus } from '../../../v2Containers/Cap/selectors';
-import * as actions from '../../../v2Containers/Cap/actions';
-
-const mapStateToProps = createStructuredSelector({
-  liquidExtractionInProgress: selectLiquidStateDetails(),
-  metaDataStatus: selectMetaDataStatus(),
-});
-
-function mapDispatchToProps(dispatch) {
-  return {
-    actions: bindActionCreators(actions, dispatch),
-  };
-}
-
-export default connect(mapStateToProps, mapDispatchToProps)(injectIntl(FormBuilderShell));

package/v2Components/FormBuilder/Functional/layout/FieldSlot.js

@@ -1,59 +0,0 @@
-/**
- * FieldSlot — React.memo boundary for self-contained data fields (input/textarea/
- * checkbox). Receives only primitive per-field props + stable handler refs, so a
- * keystroke in one field re-renders only its slot. Derived/control fields render directly.
- */
-import React from 'react';
-import PropTypes from 'prop-types';
-
-const FieldSlot = React.memo(({
-  Renderer,
-  field,
-  value,
-  error,
-  resolvedError,
-  checkValidation,
-  channel,
-  onFieldChange,
-  onFieldBlur,
-  onEvent,
-}) => {
-  const renderContext = { checkValidation, channel };
-  return (
-    <Renderer
-      field={field}
-      value={value}
-      error={error}
-      resolvedError={resolvedError}
-      onChange={(newValue) => onFieldChange(field, newValue)}
-      onBlur={() => onFieldBlur?.(field)}
-      onEvent={(eventName, data) => onEvent?.(field, eventName, data)}
-      renderContext={renderContext}
-    />
-  );
-});
-
-FieldSlot.propTypes = {
-  Renderer: PropTypes.elementType.isRequired,
-  field: PropTypes.object.isRequired,
-  value: PropTypes.any,
-  error: PropTypes.any,
-  resolvedError: PropTypes.string,
-  checkValidation: PropTypes.bool,
-  channel: PropTypes.string,
-  onFieldChange: PropTypes.func.isRequired,
-  onFieldBlur: PropTypes.func,
-  onEvent: PropTypes.func,
-};
-
-FieldSlot.defaultProps = {
-  value: undefined,
-  error: undefined,
-  resolvedError: undefined,
-  checkValidation: false,
-  channel: '',
-  onFieldBlur: undefined,
-  onEvent: undefined,
-};
-
-export default FieldSlot;

package/v2Components/FormBuilder/Functional/layout/SchemaForm.js

@@ -1,31 +0,0 @@
-/**
- * SchemaForm — top of the schema-driven render. Walks the standalone sections
- * (SMS shape). Container/tabs handling is added when MobilePush/Email migrate.
- */
-
-import React from 'react';
-import PropTypes from 'prop-types';
-import Section from './Section';
-
-const SchemaForm = ({ schema, renderContext }) => {
-  if (!schema?.standalone) return null;
-  return (
-    <>
-      {schema.standalone?.sections?.map((section, index) => (
-        // The schema is a frozen, never-reordered layout descriptor, so the index is a stable key here.
-        <Section key={index} section={section} renderContext={renderContext} />
-      ))}
-    </>
-  );
-};
-
-SchemaForm.propTypes = {
-  schema: PropTypes.object,
-  renderContext: PropTypes.object.isRequired,
-};
-
-SchemaForm.defaultProps = {
-  schema: null,
-};
-
-export default SchemaForm;