@wix/form-public 0.40.0 → 0.41.0

package/dist/index.js

@@ -15828,6 +15828,9 @@ var import_extends = __toESM(require_extends());
 init_esm();
 
 // ../../node_modules/@wix/bi-logger-forms-platform-uou/dist/esm/v2/index.js
+function formFieldEdit(params) {
+  return { evid: 1002, src: 156, endpoint: "forms-platform-uou", params };
+}
 function formFieldFocus(params) {
   return { evid: 1004, src: 156, endpoint: "forms-platform-uou", params };
 }
@@ -18548,180 +18551,662 @@ var validateBirthdate = (_ref) => {
   return void 0;
 };
 
-// ../../node_modules/fast-equals/dist/esm/index.mjs
-var getOwnPropertyNames = Object.getOwnPropertyNames;
-var getOwnPropertySymbols = Object.getOwnPropertySymbols;
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-function combineComparators(comparatorA, comparatorB) {
-  return function isEqual(a, b, state) {
-    return comparatorA(a, b, state) && comparatorB(a, b, state);
-  };
+// ../form-viewer/dist/esm/services/utils.js
+var RATING_VALUES = [1, 2, 3, 4, 5];
+function isObject3(value) {
+  return typeof value === "object" && !Array.isArray(value) && value !== null;
 }
-function createIsCircular(areItemsEqual) {
-  return function isCircular(a, b, state) {
-    if (!a || !b || typeof a !== "object" || typeof b !== "object") {
-      return areItemsEqual(a, b, state);
-    }
-    var cache = state.cache;
-    var cachedA = cache.get(a);
-    var cachedB = cache.get(b);
-    if (cachedA && cachedB) {
-      return cachedA === b && cachedB === a;
-    }
-    cache.set(a, b);
-    cache.set(b, a);
-    var result2 = areItemsEqual(a, b, state);
-    cache.delete(a);
-    cache.delete(b);
-    return result2;
-  };
+function isString(value) {
+  return typeof value === "string";
 }
-function getStrictProperties(object) {
-  return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
+function isNumber(value) {
+  return typeof value === "number" && !Number.isNaN(value);
 }
-var hasOwn = Object.hasOwn || (function(object, property) {
-  return hasOwnProperty.call(object, property);
-});
-function sameValueZeroEqual(a, b) {
-  return a === b || !a && !b && a !== a && b !== b;
+function isRating(value) {
+  return typeof value === "number" && RATING_VALUES.includes(value);
 }
-var PREACT_VNODE = "__v";
-var PREACT_OWNER = "__o";
-var REACT_OWNER = "_owner";
-var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
-var keys = Object.keys;
-function areArraysEqual(a, b, state) {
-  var index = a.length;
-  if (b.length !== index) {
-    return false;
-  }
-  while (index-- > 0) {
-    if (!state.equals(a[index], b[index], index, index, a, b, state)) {
-      return false;
+
+// ../form-viewer/dist/esm/services/has-multiline-address.js
+var hasMultilineAddress = (form, { excludeEcomAddress } = {
+  excludeEcomAddress: false
+}) => {
+  const fields = [...form?.fields || [], ...form?.deletedFields || []];
+  return fields.some((field) => field.view?.fieldType === "MULTILINE_ADDRESS" || field.view?.fieldType === "BOOKINGS_ADDRESS" || !excludeEcomAddress && field.view?.fieldType === "ECOM_ADDRESS");
+};
+
+// ../form-viewer/dist/esm/services/validation.js
+var removeFalsyValues = (values = {}) => {
+  return Object.keys(values).reduce((withoutFalsy, target) => {
+    const value = values[target];
+    if (value === "" || typeof value === "undefined" || value === null) {
+      return withoutFalsy;
+    }
+    if (Array.isArray(value) && !value.length) {
+      return withoutFalsy;
+    }
+    if (isObject3(value)) {
+      withoutFalsy[target] = removeFalsyValues(value);
+    } else {
+      withoutFalsy[target] = value;
     }
+    return withoutFalsy;
+  }, {});
+};
+var getFormValidator = async (form, addressTemplates, validationMode) => {
+  const [{ FormValidator: FormValidator2 }, { MultilineAddressToolkit: MultilineAddressToolkit2 }] = await Promise.all([
+    Promise.resolve().then(() => (init_esm(), esm_exports)),
+    Promise.resolve().then(() => (init_esm2(), esm_exports2))
+  ]);
+  if (addressTemplates?.length) {
+    const addressForms = addressTemplates.map((template) => template.template);
+    const addressToolkit = new MultilineAddressToolkit2(addressForms);
+    return new FormValidator2([form], validationMode, false, addressToolkit.getFormForValidation, addressToolkit.normalizeEmptyValues, true);
   }
-  return true;
-}
-function areDatesEqual(a, b) {
-  return sameValueZeroEqual(a.getTime(), b.getTime());
-}
-function areErrorsEqual(a, b) {
-  return a.name === b.name && a.message === b.message && a.cause === b.cause && a.stack === b.stack;
-}
-function areFunctionsEqual(a, b) {
-  return a === b;
-}
-function areMapsEqual(a, b, state) {
-  var size = a.size;
-  if (size !== b.size) {
-    return false;
+  return new FormValidator2([form], validationMode, void 0, void 0, void 0, true);
+};
+var validate = async (form, values, addressTemplates, validationMode) => {
+  if (!form.id) {
+    return;
   }
-  if (!size) {
-    return true;
+  const formValidator = await getFormValidator(form, addressTemplates, validationMode);
+  return formValidator.validate(form.id, hasMultilineAddress(form, { excludeEcomAddress: true }) ? values : removeFalsyValues(values));
+};
+var validateFields = async (form, values, addressTemplates, validationMode) => {
+  if (!form.id) {
+    return;
   }
-  var matchedIndices = new Array(size);
-  var aIterable = a.entries();
-  var aResult;
-  var bResult;
-  var index = 0;
-  while (aResult = aIterable.next()) {
-    if (aResult.done) {
-      break;
-    }
-    var bIterable = b.entries();
-    var hasMatch = false;
-    var matchIndex = 0;
-    while (bResult = bIterable.next()) {
-      if (bResult.done) {
-        break;
+  const formValidator = await getFormValidator(form, addressTemplates, validationMode);
+  return formValidator.validateFields(form.id, hasMultilineAddress(form) ? values : removeFalsyValues(values));
+};
+
+// ../form-viewer/dist/esm/services/apply-nested-forms.js
+function applyNestedForms(form, nestedFormsById) {
+  if (!form.nestedForms && !nestedFormsById) {
+    return form;
+  }
+  const nestedFormsByTarget = getNestedFormsByTarget(form);
+  return {
+    ...form,
+    fields: form.fields?.map((field) => {
+      const fieldTarget = field.target;
+      if (!fieldTarget) {
+        return field;
       }
-      if (matchedIndices[matchIndex]) {
-        matchIndex++;
-        continue;
+      const nestedFormId = field.nestedFormId;
+      if (!nestedFormId) {
+        return field;
       }
-      var aEntry = aResult.value;
-      var bEntry = bResult.value;
-      if (state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state) && state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)) {
-        hasMatch = matchedIndices[matchIndex] = true;
-        break;
+      const nestedForm = nestedFormsByTarget?.[fieldTarget] ?? nestedFormsById?.[nestedFormId];
+      if (nestedForm) {
+        return { ...field, view: { ...field.view, form: nestedForm } };
       }
-      matchIndex++;
-    }
-    if (!hasMatch) {
-      return false;
-    }
-    index++;
-  }
-  return true;
-}
-var areNumbersEqual = sameValueZeroEqual;
-function areObjectsEqual(a, b, state) {
-  var properties = keys(a);
-  var index = properties.length;
-  if (keys(b).length !== index) {
-    return false;
-  }
-  while (index-- > 0) {
-    if (!isPropertyEqual(a, b, state, properties[index])) {
-      return false;
-    }
-  }
-  return true;
+      return field;
+    })
+  };
 }
-function areObjectsEqualStrict(a, b, state) {
-  var properties = getStrictProperties(a);
-  var index = properties.length;
-  if (getStrictProperties(b).length !== index) {
-    return false;
-  }
-  var property;
-  var descriptorA;
-  var descriptorB;
-  while (index-- > 0) {
-    property = properties[index];
-    if (!isPropertyEqual(a, b, state, property)) {
-      return false;
+function getNestedFormsByTarget(form) {
+  return form.nestedForms?.reduce((byTarget, { targets, form: nestedForm }) => {
+    if (!nestedForm || !targets) {
+      return byTarget;
     }
-    descriptorA = getOwnPropertyDescriptor(a, property);
-    descriptorB = getOwnPropertyDescriptor(b, property);
-    if ((descriptorA || descriptorB) && (!descriptorA || !descriptorB || descriptorA.configurable !== descriptorB.configurable || descriptorA.enumerable !== descriptorB.enumerable || descriptorA.writable !== descriptorB.writable)) {
-      return false;
+    for (const target of targets) {
+      byTarget[target] = nestedForm;
     }
-  }
-  return true;
-}
-function arePrimitiveWrappersEqual(a, b) {
-  return sameValueZeroEqual(a.valueOf(), b.valueOf());
+    return byTarget;
+  }, {});
 }
-function areRegExpsEqual(a, b) {
-  return a.source === b.source && a.flags === b.flags;
+function getNestedFormArray(formsByTarget) {
+  return Object.keys(formsByTarget).map((target) => {
+    return { targets: [target], form: formsByTarget[target] };
+  });
 }
-function areSetsEqual(a, b, state) {
-  var size = a.size;
-  if (size !== b.size) {
-    return false;
-  }
-  if (!size) {
-    return true;
-  }
-  var matchedIndices = new Array(size);
-  var aIterable = a.values();
-  var aResult;
-  var bResult;
-  while (aResult = aIterable.next()) {
-    if (aResult.done) {
-      break;
+
+// ../form-viewer/dist/esm/services/additional-field-validation.js
+var runAdditionalValidation = ({ form, values, externalData }) => {
+  const additionalErrors = form.fields?.reduce((acc, field) => {
+    const fieldTarget = field.target;
+    if (!fieldTarget) {
+      return acc;
     }
-    var bIterable = b.values();
-    var hasMatch = false;
-    var matchIndex = 0;
-    while (bResult = bIterable.next()) {
-      if (bResult.done) {
-        break;
-      }
-      if (!matchedIndices[matchIndex] && state.equals(aResult.value, bResult.value, aResult.value, bResult.value, a, b, state)) {
-        hasMatch = matchedIndices[matchIndex] = true;
-        break;
+    const fieldType = field?.view?.fieldType;
+    const fieldValue = values[fieldTarget];
+    const validateField = ADDITIONAL_FIELD_VALIDATION[fieldType];
+    const error = validateField?.({
+      value: fieldValue,
+      target: fieldTarget,
+      externalData
+    });
+    if (error) {
+      acc[fieldTarget] = error;
+    }
+    return acc;
+  }, {});
+  return additionalErrors;
+};
+var ADDITIONAL_FIELD_VALIDATION = {
+  [FIELD_TYPES.TEXT_INPUT]: null,
+  [FIELD_TYPES.CHECKBOX_GROUP]: null,
+  [FIELD_TYPES.RADIO_GROUP]: null,
+  [FIELD_TYPES.DONATION]: null,
+  [FIELD_TYPES.DROPDOWN]: null,
+  [FIELD_TYPES.URL_INPUT]: null,
+  [FIELD_TYPES.NUMBER_INPUT]: null,
+  [FIELD_TYPES.QUIZ_NUMBER]: null,
+  [FIELD_TYPES.QUIZ_SHORT_TEXT]: null,
+  [FIELD_TYPES.QUIZ_LONG_TEXT]: null,
+  [FIELD_TYPES.QUIZ_MULTI_CHOICE]: null,
+  [FIELD_TYPES.QUIZ_IMAGE_CHOICE]: null,
+  [FIELD_TYPES.QUIZ_SINGLE_CHOICE]: null,
+  [FIELD_TYPES.QUIZ_FILE_UPLOAD]: null,
+  [FIELD_TYPES.FILE_UPLOAD]: null,
+  [FIELD_TYPES.SIGNATURE]: null,
+  [FIELD_TYPES.CONTACTS_EMAIL]: null,
+  [FIELD_TYPES.CONTACTS_PHONE]: null,
+  [FIELD_TYPES.CHECKBOX]: null,
+  [FIELD_TYPES.DATE_INPUT]: null,
+  [FIELD_TYPES.DATE_TIME_INPUT]: null,
+  [FIELD_TYPES.TIME_INPUT]: null,
+  [FIELD_TYPES.DATE_PICKER]: null,
+  [FIELD_TYPES.CONTACTS_COMPANY]: null,
+  [FIELD_TYPES.CONTACTS_POSITION]: null,
+  [FIELD_TYPES.CONTACTS_TAX_ID]: null,
+  [FIELD_TYPES.CONTACTS_FIRST_NAME]: null,
+  [FIELD_TYPES.CONTACTS_LAST_NAME]: null,
+  [FIELD_TYPES.CONTACTS_ADDRESS]: null,
+  [FIELD_TYPES.CONTACTS_BIRTHDATE]: validateBirthdate,
+  [FIELD_TYPES.TEXT_AREA]: null,
+  [FIELD_TYPES.CONTACTS_SUBSCRIBE]: null,
+  [FIELD_TYPES.NESTED_FORM]: null,
+  [FIELD_TYPES.MULTILINE_ADDRESS]: null,
+  [FIELD_TYPES.MLA_COUNTRY]: null,
+  [FIELD_TYPES.MLA_CITY]: null,
+  [FIELD_TYPES.MLA_ADDRESS_LINE]: null,
+  [FIELD_TYPES.MLA_ADDRESS_LINE_2]: null,
+  [FIELD_TYPES.MLA_POSTAL_CODE]: null,
+  [FIELD_TYPES.MLA_SUBDIVISION]: null,
+  [FIELD_TYPES.MLA_STREET_NAME]: null,
+  [FIELD_TYPES.MLA_STREET_NUMBER]: null,
+  [FIELD_TYPES.MLA_APARTMENT]: null,
+  [FIELD_TYPES.FULL_NAME_FIRST_NAME]: null,
+  [FIELD_TYPES.FULL_NAME_LAST_NAME]: null,
+  [FIELD_TYPES.FULL_NAME]: null,
+  [FIELD_TYPES.DEXT_TEXT_INPUT]: null,
+  [FIELD_TYPES.DEXT_NUMBER_INPUT]: null,
+  [FIELD_TYPES.DEXT_CHECKBOX]: null,
+  [FIELD_TYPES.DEXT_CHECKBOX_GROUP]: null,
+  [FIELD_TYPES.DEXT_TAGS]: null,
+  [FIELD_TYPES.DEXT_RATING_INPUT]: null,
+  [FIELD_TYPES.ECOM_ADDITIONAL_INFO]: null,
+  [FIELD_TYPES.ECOM_ADDRESS]: null,
+  [FIELD_TYPES.ECOM_PHONE]: null,
+  [FIELD_TYPES.ECOM_FULL_NAME]: null,
+  [FIELD_TYPES.ECOM_COMPANY_NAME]: null,
+  [FIELD_TYPES.ECOM_EMAIL]: null,
+  [FIELD_TYPES.ECOM_SUBSCRIPTION]: null,
+  [FIELD_TYPES.DEXT_TEXT_AREA]: null,
+  [FIELD_TYPES.DEXT_DROPDOWN]: null,
+  [FIELD_TYPES.DEXT_RADIO_GROUP]: null,
+  [FIELD_TYPES.DEXT_URL_INPUT]: null,
+  [FIELD_TYPES.DEXT_EMAIL]: null,
+  [FIELD_TYPES.DEXT_PHONE]: null,
+  [FIELD_TYPES.DEXT_DATE_PICKER]: null,
+  [FIELD_TYPES.VAT_ID]: validateVatID,
+  [FIELD_TYPES.PRODUCT_LIST]: null,
+  [FIELD_TYPES.RATING_INPUT]: null,
+  [FIELD_TYPES.TAGS]: null,
+  [FIELD_TYPES.PAYMENT_INPUT]: null,
+  [FIELD_TYPES.FIXED_PAYMENT]: null,
+  [FIELD_TYPES.BOOKINGS_FIRST_NAME]: null,
+  [FIELD_TYPES.BOOKINGS_LAST_NAME]: null,
+  [FIELD_TYPES.BOOKINGS_EMAIL]: null,
+  [FIELD_TYPES.BOOKINGS_PHONE]: null,
+  [FIELD_TYPES.BOOKINGS_ADDRESS]: null,
+  [FIELD_TYPES.APPOINTMENT]: null,
+  [FIELD_TYPES.IDENTITY_PASSWORD]: null,
+  [FIELD_TYPES.SERVICES_DROPDOWN]: null,
+  [FIELD_TYPES.SERVICES_MULTI_CHOICE]: null,
+  [FIELD_TYPES.EVENTS_RSVP]: null,
+  [FIELD_TYPES.EVENTS_REPEATER]: null
+};
+
+// ../form-viewer/dist/esm/services/get-field-errors.js
+var getFieldErrors = async (fieldsToValidate, form, addressTemplates, externalData, validationMode) => {
+  const formValues = fieldsToValidate.reduce((acc, field) => setValue(acc, field.path, field.value), {});
+  const result2 = await validateFields(form, formValues, addressTemplates, validationMode);
+  const _errors = result2?.errors || [];
+  const additionalErrors = runAdditionalValidation({
+    form,
+    values: formValues,
+    externalData
+  });
+  const allErrors = mergeErrors({ errors: _errors, additionalErrors });
+  const fieldErrors = allErrors.filter((error) => findErrorByNormalizedPath(fieldsToValidate, error.errorPath));
+  return fieldErrors;
+};
+var findErrorByNormalizedPath = (fieldsToValidate, errorPath) => {
+  const path = errorPath.split("/").length > 2 ? errorPath.split("/").at(0) : errorPath;
+  return !!fieldsToValidate.find((field) => path === field.path);
+};
+function setValue(object, path, value) {
+  const delimiter = "/";
+  const decomposedPath = path.split(delimiter);
+  const base = decomposedPath[0];
+  if (base === void 0) {
+    return object;
+  }
+  if (!object.hasOwnProperty(base)) {
+    object[base] = {};
+  }
+  value = decomposedPath.length <= 1 ? value : setValue(object[base], decomposedPath.slice(1).join(delimiter), value);
+  return {
+    ...object,
+    [base]: value
+  };
+}
+var mergeErrors = ({ errors, additionalErrors }) => {
+  const errorsToAdd = [];
+  if (additionalErrors) {
+    Object.keys(additionalErrors).forEach((fieldTarget) => {
+      const errorExists = errors.find((error) => error.errorPath === fieldTarget);
+      if (!errorExists) {
+        errorsToAdd.push(additionalErrors[fieldTarget]);
+      }
+    });
+  }
+  return [...errors, ...errorsToAdd];
+};
+
+// ../form-viewer/dist/esm/services/form-overrides.js
+function applyFormOverrides(form, overrides, recursive = true) {
+  const nestedFormsByTarget = getNestedFormsByTarget(form);
+  const fields = (form.fields ?? []).map((field) => {
+    const override = getOverride({
+      id: field.id,
+      target: field.target,
+      overrides
+    });
+    if (!override) {
+      return field;
+    }
+    if (field.target && field.nestedFormId && recursive) {
+      const nestedForm = nestedFormsByTarget?.[field.target];
+      if (nestedForm) {
+        nestedFormsByTarget[field.target] = applyFormOverrides(nestedForm, override, false);
+      }
+      return field;
+    }
+    let validation = field.validation;
+    let options = {};
+    if (Array.isArray(override.countries)) {
+      validation = {
+        ...validation,
+        string: {
+          ...validation?.string,
+          enum: override.countries
+        }
+      };
+      options = override.countries ? {
+        options: override.countries?.map((country) => ({ value: country }))
+      } : {};
+    }
+    if (field.view?.fieldType === "MULTILINE_ADDRESS") {
+      return applyMultilineAddressOverrides({
+        field,
+        override
+      });
+    }
+    return {
+      ...field,
+      ...pick(override, "hidden"),
+      ...pick(override, "readOnly"),
+      view: {
+        ...field.view,
+        ...pick(override, "label"),
+        ...pick(override, "autocomplete"),
+        ...pick(override, "disabled"),
+        ...options
+      },
+      validation: {
+        ...validation,
+        ...pick(override, "required")
+      }
+    };
+  });
+  const nestedForms = nestedFormsByTarget ? getNestedFormArray(nestedFormsByTarget) : void 0;
+  return {
+    ...form,
+    fields,
+    ...nestedForms ? { nestedForms } : {}
+  };
+}
+function pick(override, key) {
+  return override.hasOwnProperty(key) ? { [key]: override[key] } : {};
+}
+var getOverride = ({ target, id, overrides }) => {
+  if (target && target in overrides) {
+    return overrides[target];
+  }
+  if (id && id in overrides) {
+    return overrides[id];
+  }
+  return void 0;
+};
+var applyAddressFieldOverride = (fieldName, override, multilineAddressOptionsFields, multilineAddressFieldSettings) => {
+  const fieldOverride = override[fieldName];
+  if (!fieldOverride) {
+    return {
+      multilineAddressOptionsFields,
+      multilineAddressFieldSettings
+    };
+  }
+  return {
+    multilineAddressOptionsFields: {
+      ...multilineAddressOptionsFields,
+      [fieldName]: {
+        required: fieldOverride.required
+      }
+    },
+    multilineAddressFieldSettings: {
+      ...multilineAddressFieldSettings,
+      [fieldName]: {
+        ...multilineAddressFieldSettings?.[fieldName],
+        show: !fieldOverride.hidden
+      }
+    }
+  };
+};
+var ADDRESS_FIELD_NAMES = [
+  "addressLine",
+  "addressLine2",
+  "streetName",
+  "streetNumber",
+  "city",
+  "postalCode",
+  "subdivision",
+  "country",
+  "apartment"
+];
+var applyMultilineAddressOverrides = ({ field, override }) => {
+  const finalState = ADDRESS_FIELD_NAMES.reduce((state, fieldName) => applyAddressFieldOverride(fieldName, override, state.multilineAddressOptionsFields ?? {}, state.multilineAddressFieldSettings ?? {}), {
+    multilineAddressOptionsFields: field.validation?.predefined?.multilineAddressOptions?.fields,
+    multilineAddressFieldSettings: field.view?.fieldSettings
+  });
+  const autocompleteEnabled = (override.addressLine?.autocomplete || override.streetName?.autocomplete) ?? true;
+  const multilineAddressOptions = {
+    ...field.validation?.predefined?.multilineAddressOptions,
+    fields: {
+      ...field.validation?.predefined?.multilineAddressOptions?.fields,
+      ...finalState.multilineAddressOptionsFields
+    },
+    ...Array.isArray(override.countries) && override.countries.length > 0 ? { allowedCountries: override.countries } : {}
+  };
+  return {
+    ...field,
+    view: {
+      ...field.view,
+      fieldSettings: {
+        ...field.view?.fieldSettings,
+        ...finalState.multilineAddressFieldSettings
+      },
+      autocompleteEnabled
+    },
+    validation: {
+      ...field.validation,
+      predefined: {
+        ...field.validation?.predefined,
+        multilineAddressOptions
+      }
+    }
+  };
+};
+
+// ../form-viewer/dist/esm/hooks/use-validation.js
+var useValidation = ({ form, errorsRef, setErrors, validationMode }) => {
+  const { addressTemplates } = useAddressForms();
+  const externalData = useExternalData();
+  const validateFields2 = useCallback(async (newValues) => {
+    const result2 = await validate(form, newValues, addressTemplates, validationMode);
+    const _errors = result2?.errors || [];
+    const additionalErrors = runAdditionalValidation({
+      form,
+      values: newValues,
+      externalData
+    });
+    const allErrors = mergeErrors({ errors: _errors, additionalErrors });
+    setErrors(allErrors);
+    return allErrors;
+  }, [form, setErrors, addressTemplates, externalData, validationMode]);
+  const handleFieldValidation = useCallback(async (fieldsToValidate) => {
+    const fieldErrors = await getFieldErrors(fieldsToValidate, form, addressTemplates, externalData, validationMode);
+    const otherErrors = (errorsRef.current ?? []).filter((error) => {
+      return !findErrorByNormalizedPath(fieldsToValidate, error.errorPath);
+    });
+    const allErrors = [...otherErrors, ...fieldErrors];
+    setErrors(allErrors);
+    return allErrors;
+  }, [
+    errorsRef,
+    form,
+    setErrors,
+    addressTemplates,
+    externalData,
+    validationMode
+  ]);
+  const validateStep = useCallback(async (stepId, newValues) => {
+    const items = form?.steps?.find((step) => step.id === stepId)?.layout?.large?.items || [];
+    const validationErrors = await Promise.all(items.map(async (item) => {
+      const field = form?.fields?.find((_field) => _field.id === item.fieldId);
+      const fieldValidationResult = field?.target ? await handleFieldValidation([
+        {
+          path: field.target,
+          value: newValues[field.target]
+        }
+      ]) : [];
+      return fieldValidationResult;
+    }));
+    const validationErrorsFlatten = validationErrors.flat();
+    setErrors(validationErrorsFlatten);
+    return !validationErrorsFlatten.length;
+  }, [form, setErrors, handleFieldValidation]);
+  return { validateFields: validateFields2, validateStep, handleFieldValidation };
+};
+var SubmitStatusContext = createContext(void 0);
+var SubmitStatusProvider = ({ children }) => {
+  const [submitSuccessMessage, setSubmitSuccessMessage] = useState();
+  const [submitFailureCode, setSubmitFailureCode] = useState();
+  const [submitFailureMessage, setSubmitFailureMessage] = useState();
+  const value = useMemo(() => ({
+    submitSuccessMessage,
+    submitFailureCode,
+    submitFailureMessage,
+    setSubmitSuccessMessage,
+    setSubmitFailureCode,
+    setSubmitFailureMessage
+  }), [submitSuccessMessage, submitFailureCode, submitFailureMessage]);
+  return React14.createElement(SubmitStatusContext.Provider, { value }, children);
+};
+var useSubmitStatus = () => {
+  const context = useContext(SubmitStatusContext);
+  if (context === void 0) {
+    throw new Error("useSubmitStatus must be used within a SubmitStatusProvider");
+  }
+  return context;
+};
+
+// ../../node_modules/fast-equals/dist/esm/index.mjs
+var getOwnPropertyNames = Object.getOwnPropertyNames;
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function combineComparators(comparatorA, comparatorB) {
+  return function isEqual(a, b, state) {
+    return comparatorA(a, b, state) && comparatorB(a, b, state);
+  };
+}
+function createIsCircular(areItemsEqual) {
+  return function isCircular(a, b, state) {
+    if (!a || !b || typeof a !== "object" || typeof b !== "object") {
+      return areItemsEqual(a, b, state);
+    }
+    var cache = state.cache;
+    var cachedA = cache.get(a);
+    var cachedB = cache.get(b);
+    if (cachedA && cachedB) {
+      return cachedA === b && cachedB === a;
+    }
+    cache.set(a, b);
+    cache.set(b, a);
+    var result2 = areItemsEqual(a, b, state);
+    cache.delete(a);
+    cache.delete(b);
+    return result2;
+  };
+}
+function getStrictProperties(object) {
+  return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
+}
+var hasOwn = Object.hasOwn || (function(object, property) {
+  return hasOwnProperty.call(object, property);
+});
+function sameValueZeroEqual(a, b) {
+  return a === b || !a && !b && a !== a && b !== b;
+}
+var PREACT_VNODE = "__v";
+var PREACT_OWNER = "__o";
+var REACT_OWNER = "_owner";
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+var keys = Object.keys;
+function areArraysEqual(a, b, state) {
+  var index = a.length;
+  if (b.length !== index) {
+    return false;
+  }
+  while (index-- > 0) {
+    if (!state.equals(a[index], b[index], index, index, a, b, state)) {
+      return false;
+    }
+  }
+  return true;
+}
+function areDatesEqual(a, b) {
+  return sameValueZeroEqual(a.getTime(), b.getTime());
+}
+function areErrorsEqual(a, b) {
+  return a.name === b.name && a.message === b.message && a.cause === b.cause && a.stack === b.stack;
+}
+function areFunctionsEqual(a, b) {
+  return a === b;
+}
+function areMapsEqual(a, b, state) {
+  var size = a.size;
+  if (size !== b.size) {
+    return false;
+  }
+  if (!size) {
+    return true;
+  }
+  var matchedIndices = new Array(size);
+  var aIterable = a.entries();
+  var aResult;
+  var bResult;
+  var index = 0;
+  while (aResult = aIterable.next()) {
+    if (aResult.done) {
+      break;
+    }
+    var bIterable = b.entries();
+    var hasMatch = false;
+    var matchIndex = 0;
+    while (bResult = bIterable.next()) {
+      if (bResult.done) {
+        break;
+      }
+      if (matchedIndices[matchIndex]) {
+        matchIndex++;
+        continue;
+      }
+      var aEntry = aResult.value;
+      var bEntry = bResult.value;
+      if (state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state) && state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)) {
+        hasMatch = matchedIndices[matchIndex] = true;
+        break;
+      }
+      matchIndex++;
+    }
+    if (!hasMatch) {
+      return false;
+    }
+    index++;
+  }
+  return true;
+}
+var areNumbersEqual = sameValueZeroEqual;
+function areObjectsEqual(a, b, state) {
+  var properties = keys(a);
+  var index = properties.length;
+  if (keys(b).length !== index) {
+    return false;
+  }
+  while (index-- > 0) {
+    if (!isPropertyEqual(a, b, state, properties[index])) {
+      return false;
+    }
+  }
+  return true;
+}
+function areObjectsEqualStrict(a, b, state) {
+  var properties = getStrictProperties(a);
+  var index = properties.length;
+  if (getStrictProperties(b).length !== index) {
+    return false;
+  }
+  var property;
+  var descriptorA;
+  var descriptorB;
+  while (index-- > 0) {
+    property = properties[index];
+    if (!isPropertyEqual(a, b, state, property)) {
+      return false;
+    }
+    descriptorA = getOwnPropertyDescriptor(a, property);
+    descriptorB = getOwnPropertyDescriptor(b, property);
+    if ((descriptorA || descriptorB) && (!descriptorA || !descriptorB || descriptorA.configurable !== descriptorB.configurable || descriptorA.enumerable !== descriptorB.enumerable || descriptorA.writable !== descriptorB.writable)) {
+      return false;
+    }
+  }
+  return true;
+}
+function arePrimitiveWrappersEqual(a, b) {
+  return sameValueZeroEqual(a.valueOf(), b.valueOf());
+}
+function areRegExpsEqual(a, b) {
+  return a.source === b.source && a.flags === b.flags;
+}
+function areSetsEqual(a, b, state) {
+  var size = a.size;
+  if (size !== b.size) {
+    return false;
+  }
+  if (!size) {
+    return true;
+  }
+  var matchedIndices = new Array(size);
+  var aIterable = a.values();
+  var aResult;
+  var bResult;
+  while (aResult = aIterable.next()) {
+    if (aResult.done) {
+      break;
+    }
+    var bIterable = b.values();
+    var hasMatch = false;
+    var matchIndex = 0;
+    while (bResult = bIterable.next()) {
+      if (bResult.done) {
+        break;
+      }
+      if (!matchedIndices[matchIndex] && state.equals(aResult.value, bResult.value, aResult.value, bResult.value, a, b, state)) {
+        hasMatch = matchedIndices[matchIndex] = true;
+        break;
       }
       matchIndex++;
     }
@@ -19003,979 +19488,570 @@ function asUtcDate(value) {
     return null;
   }
 }
-function getNumberValuesToCompare(...values) {
-  return values.map((value) => {
-    if (typeof value === "string") {
-      return getDateUtcTimestamp(value);
-    }
-    if (typeof value === "number") {
-      return value;
-    }
-    if (isProductSubmission(value)) {
-      return getProductPrice(value);
-    }
-    return null;
-  });
-}
-function getDateUtcTimestamp(givenValue) {
-  const givenDate = asUtcDate(givenValue);
-  return givenDate ? givenDate.getTime() : null;
-}
-function getProductPrice(givenValue) {
-  return givenValue[0].price;
-}
-function isObject3(givenValue) {
-  return typeof givenValue === "object" && !Array.isArray(givenValue) && givenValue !== null;
-}
-var isArrayOfNumbers = (value) => {
-  return value.every((item) => typeof item === "number");
-};
-function isProductSubmission(value) {
-  return Array.isArray(value) && value.every((element) => isObject3(element) && "productId" in element && "price" in element && "quantity" in element);
-}
-function isValueEmpty(givenValue) {
-  return givenValue === void 0 || givenValue === null || givenValue === "";
-}
-function isValidCondition(rule, fields = []) {
-  if (rule === void 0) {
-    return true;
-  }
-  const rulesOrConditions = getRulesOrConditions(rule);
-  if (!rulesOrConditions.length) {
-    return false;
-  }
-  return rulesOrConditions.every((conditionOrRule) => {
-    if (isCondition(conditionOrRule)) {
-      return fields?.some((field) => field.id === conditionOrRule.fact);
-    }
-    return isValidCondition(conditionOrRule, fields);
-  });
-}
-function isFormRuleValid(formRule, formSchema) {
-  if (!formRule || !formRule?.overrides?.length || !formSchema) {
-    return false;
-  }
-  const { fieldsV2, fields, nestedForms, formFields } = formSchema;
-  const fieldsToCheck = (fields ?? []).concat(fieldsV2 ?? []).concat(formFields ?? []);
-  const conditionValid = isValidCondition(formRule.condition, fieldsToCheck);
-  const overrideValid = formRule?.overrides.some((override) => {
-    if (override.entityType === OverrideEntityType.FORM) {
-      return formSchema.id === override.entityId || nestedForms?.some((nestedForm) => nestedForm.form?.id === override.entityId);
-    }
-    const wasFieldFound = (fieldsToCheck?.map((f) => f.id) ?? []).includes(override.entityId);
-    return override.entityId ? wasFieldFound : false;
-  });
-  return conditionValid && overrideValid;
-}
-
-// ../form-conditions/dist/esm/lib/transform-path-to-v2.js
-var supportedPaths = [
-  "hidden",
-  "validation.required",
-  "validation.string.enum",
-  "validation.boolean.enum",
-  "validation.predefined.multilineAddressOptions.fields",
-  "view.options",
-  "view.countryCode"
-];
-var fieldPathMapToPlatfomized = {
-  hidden: ["hidden"],
-  "validation.required": ["inputOptions.required"],
-  "validation.string.enum": ["inputOptions.stringOptions.validation.enum"],
-  "validation.boolean.enum": ["inputOptions.booleanOptions.validation.enum"],
-  "view.options": [
-    "inputOptions.stringOptions.radioGroupOptions.options",
-    "inputOptions.stringOptions.dropdownOptions.options",
-    "inputOptions.arrayOptions.checkboxGroupOptions.options"
-  ],
-  "view.countryCode": []
-};
-
-// ../form-conditions/dist/esm/lib/apply-item-properties-override.js
-var PATH_SEPARATOR = ".";
-function applyItemPropertiesOverride(formSchema, rule) {
-  if (rule.overrides) {
-    const overriddenFormSchema = applyFormOverride(formSchema, mapOverridesByItem(rule.overrides, isFormOverride, isSupportedFormPath));
-    return {
-      ...overriddenFormSchema,
-      fields: applyItemsOverride(overriddenFormSchema.fields ?? [], mapOverridesByItem(rule.overrides, isFieldOverride, isSupportedFieldPath)),
-      ...overriddenFormSchema.fieldsV2 && {
-        fieldsV2: applyItemsOverride(overriddenFormSchema.fieldsV2 ?? [], mapOverridesV2ByItem(rule.overrides, isFieldOverride))
-      },
-      ...overriddenFormSchema.formFields && {
-        formFields: applyItemsOverride(overriddenFormSchema.formFields ?? [], mapOverridesV2ByItem(rule.overrides, isFieldOverride))
-      }
-    };
-  }
-  return formSchema;
-}
-function applyItemsOverride(items, formItemOverrides) {
-  return items.map((formField) => {
-    const fieldOverrides = formItemOverrides[asRequired2(formField.id)] || [];
-    return fieldOverrides.reduce((acc, override) => setToValue(acc, override.path, override.value), formField);
-  });
-}
-function applyFormOverride(formSchema, formItemOverrides) {
-  const formOverrides = Object.values(formItemOverrides).flat();
-  return formOverrides.reduce((acc, override) => setToValue(acc, override.path, override.value), formSchema);
-}
-function mapOverridesByItem(overrideItems, isOverride, isSupportedPath) {
-  return overrideItems.filter(isOverride).reduce((acc, overrideItem) => {
-    const entityId = asRequired2(overrideItem.entityId);
-    const overrides = Object.entries(overrideItem.valueChanges ?? {}).filter(([path]) => isSupportedPath(path)).map(([path, value]) => ({
-      path: path.split(PATH_SEPARATOR),
-      value
-    }));
-    acc[entityId] = [...acc[entityId] || [], ...overrides];
-    return acc;
-  }, {});
-}
-function mapOverridesV2ByItem(overrideItems, isOverride) {
-  return overrideItems.filter(isOverride).reduce((acc, overrideItem) => {
-    const entityId = asRequired2(overrideItem.entityId);
-    const overrides = Object.entries(overrideItem.valueChanges ?? {}).flatMap(([path, value]) => {
-      const resolvedV2Paths = fieldPathMapToPlatfomized[path] || [];
-      return resolvedV2Paths.map((pathV2) => [pathV2, value]);
-    }).map(([path, value]) => ({
-      path: path.split(PATH_SEPARATOR),
-      value
-    }));
-    acc[entityId] = [...acc[entityId] || [], ...overrides];
-    return acc;
-  }, {});
-}
-function setToValue(obj, pathProps, value) {
-  if (value !== void 0 && obj !== void 0) {
-    const [prop, ...rest] = pathProps;
-    if (rest.length) {
-      const valueToSet = setToValue(obj[prop], rest, value);
-      if (valueToSet !== void 0) {
-        return {
-          ...obj,
-          [prop]: valueToSet
-        };
-      }
-      return obj;
-    }
-    return {
-      ...obj,
-      [prop]: value
-    };
-  }
-  return obj;
-}
-function isFieldOverride(override) {
-  return override.entityType === OverrideEntityType.FIELD;
-}
-function isFormOverride(override) {
-  return override.entityType === OverrideEntityType.FORM;
-}
-function isSupportedFieldPath(path) {
-  return supportedPaths.includes(path);
-}
-function isSupportedFormPath(path) {
-  return ["fields", "steps"].includes(path);
-}
-
-// ../form-conditions/dist/esm/lib/evaluate-override-condition.js
-var import_js_rules_engine2 = __toESM(require_dist5());
-
-// ../form-conditions/dist/esm/lib/set-up-operators.js
-var import_js_rules_engine = __toESM(require_dist5());
-
-// ../form-conditions/dist/esm/lib/operators/between.js
-function valueIsBetween(givenValue, expectedValue) {
-  if (isValueEmpty(givenValue)) {
-    return false;
-  }
-  if (!Array.isArray(expectedValue) || expectedValue.length !== 2) {
-    throw new Error("Expected value should be array of two elements");
-  }
-  const values = getNumberValuesToCompare(givenValue, expectedValue[0], expectedValue[1]);
-  if (isArrayOfNumbers(values)) {
-    const [given, firstBound, secondBound] = values;
-    return between(given, Math.min(firstBound, secondBound), Math.max(firstBound, secondBound));
-  }
-  throw new Error(`Between operator: Unsupported values to compare ${givenValue}, ${JSON.stringify(expectedValue)}`);
-}
-
-// ../form-conditions/dist/esm/lib/operators/greater-than.js
-function valueIsGreaterThan(givenValue, expectedValue, orEqual = false) {
-  if (isValueEmpty(givenValue)) {
-    return false;
-  }
-  const values = getNumberValuesToCompare(givenValue, expectedValue);
-  if (isArrayOfNumbers(values)) {
-    const [given, expected] = values;
-    return greaterThan(given, expected, orEqual);
-  }
-  throw new Error(`GreaterThan operator: Unsupported values to compare ${givenValue}, ${expectedValue}`);
-}
-
-// ../form-conditions/dist/esm/lib/operators/less-than.js
-function valueIsLessThan(givenValue, expectedValue, orEqual = false) {
-  if (isValueEmpty(givenValue)) {
-    return false;
-  }
-  const values = getNumberValuesToCompare(givenValue, expectedValue);
-  if (isArrayOfNumbers(values)) {
-    const [given, expected] = values;
-    return lessThan(given, expected, orEqual);
-  }
-  throw new Error(`LessThan operator: Unsupported values to compare ${givenValue}, ${expectedValue}`);
-}
-
-// ../form-conditions/dist/esm/lib/operators/contains.js
-function valueContains(givenValue, expectedValue) {
-  if (isValueEmpty(givenValue)) {
-    return false;
-  }
-  if (isObject3(givenValue)) {
-    return Object.values(givenValue).includes(expectedValue);
-  }
-  if (Array.isArray(givenValue) || typeof givenValue === "string") {
-    return givenValue.indexOf(expectedValue) > -1;
-  }
-  throw new Error(`Contains operator: Unsupported values to compare ${JSON.stringify(givenValue)}, ${JSON.stringify(expectedValue)}`);
-}
-
-// ../form-conditions/dist/esm/lib/operators/array-equals.js
-function arrayEquals(givenValue, expectedValue) {
-  if (isValueEmpty(givenValue)) {
-    return false;
-  }
-  if (!Array.isArray(givenValue) || !Array.isArray(expectedValue)) {
-    throw new Error(`All operator: Unsupported values to compare ${JSON.stringify(givenValue)}, ${JSON.stringify(expectedValue)}`);
-  }
-  if (givenValue.length !== expectedValue.length) {
-    return false;
-  }
-  if (isProductSubmission(givenValue)) {
-    return equals(givenValue.map((product) => product.productId), expectedValue);
-  }
-  return equals(givenValue, expectedValue);
+function getNumberValuesToCompare(...values) {
+  return values.map((value) => {
+    if (typeof value === "string") {
+      return getDateUtcTimestamp(value);
+    }
+    if (typeof value === "number") {
+      return value;
+    }
+    if (isProductSubmission(value)) {
+      return getProductPrice(value);
+    }
+    return null;
+  });
 }
-function equals(givenValue, expectedValue) {
-  return expectedValue.every((v) => givenValue.includes(v));
+function getDateUtcTimestamp(givenValue) {
+  const givenDate = asUtcDate(givenValue);
+  return givenDate ? givenDate.getTime() : null;
 }
-
-// ../form-conditions/dist/esm/lib/operators/any.js
-function valueContainsAny(_givenValue, expectedValue) {
-  if (isValueEmpty(_givenValue)) {
-    return false;
-  }
-  const givenValue = Array.isArray(_givenValue) ? _givenValue : [_givenValue];
-  if (!Array.isArray(givenValue) || !Array.isArray(expectedValue)) {
-    throw new Error(`Any operator: Unsupported values to compare ${JSON.stringify(givenValue)}, ${JSON.stringify(expectedValue)}`);
-  }
-  if (isProductSubmission(givenValue)) {
-    return any(givenValue.map((product) => product.productId), expectedValue);
-  }
-  return any(givenValue, expectedValue);
+function getProductPrice(givenValue) {
+  return givenValue[0].price;
 }
-function any(givenValue, expectedValue) {
-  return givenValue.some((v) => expectedValue.includes(v));
+function isObject4(givenValue) {
+  return typeof givenValue === "object" && !Array.isArray(givenValue) && givenValue !== null;
 }
-
-// ../form-conditions/dist/esm/lib/operators/in.js
-function valueIn(givenValue, expectedValue) {
-  if (isObject3(expectedValue)) {
-    return Object.values(expectedValue).includes(givenValue);
-  }
-  if (Array.isArray(expectedValue) || typeof expectedValue === "string") {
-    return expectedValue.indexOf(givenValue) > -1;
-  }
-  throw new Error(`In operator: Unsupported values to compare ${JSON.stringify(givenValue)}, ${JSON.stringify(expectedValue)}`);
+var isArrayOfNumbers = (value) => {
+  return value.every((item) => typeof item === "number");
+};
+function isProductSubmission(value) {
+  return Array.isArray(value) && value.every((element) => isObject4(element) && "productId" in element && "price" in element && "quantity" in element);
 }
-
-// ../form-conditions/dist/esm/lib/condition-operators.js
-var ConditionOperators;
-(function(ConditionOperators2) {
-  ConditionOperators2["equal"] = "equal";
-  ConditionOperators2["notEqual"] = "notEqual";
-  ConditionOperators2["notEmpty"] = "notEmpty";
-  ConditionOperators2["empty"] = "empty";
-  ConditionOperators2["contains"] = "contains";
-  ConditionOperators2["notContains"] = "notContains";
-  ConditionOperators2["greaterThanOrEqual"] = "greaterThanOrEqual";
-  ConditionOperators2["greaterThan"] = "greaterThan";
-  ConditionOperators2["afterOrEqual"] = "afterOrEqual";
-  ConditionOperators2["after"] = "after";
-  ConditionOperators2["lessThanOrEqual"] = "lessThanOrEqual";
-  ConditionOperators2["lessThan"] = "lessThan";
-  ConditionOperators2["beforeOrEqual"] = "beforeOrEqual";
-  ConditionOperators2["before"] = "before";
-  ConditionOperators2["between"] = "between";
-  ConditionOperators2["any"] = "any";
-  ConditionOperators2["arrayEqual"] = "arrayEqual";
-  ConditionOperators2["arrayNotEqual"] = "arrayNotEqual";
-  ConditionOperators2["checked"] = "checked";
-  ConditionOperators2["notChecked"] = "notChecked";
-  ConditionOperators2["in"] = "in";
-  ConditionOperators2["notIn"] = "notIn";
-  ConditionOperators2["isDateNewerThan"] = "isDateNewerThan";
-  ConditionOperators2["isDateOlderThan"] = "isDateOlderThan";
-  ConditionOperators2["isDateNewerThanOrEqual"] = "isDateNewerThanOrEqual";
-  ConditionOperators2["isDateOlderThanOrEqual"] = "isDateOlderThanOrEqual";
-})(ConditionOperators || (ConditionOperators = {}));
-
-// ../form-conditions/dist/esm/lib/operators/checked.js
-function checked(givenValue) {
-  return Boolean(givenValue);
+function isValueEmpty(givenValue) {
+  return givenValue === void 0 || givenValue === null || givenValue === "";
 }
-
-// ../form-conditions/dist/esm/lib/operators/equal.js
-function valueEqual(givenValue, expectedValue) {
-  if (isProductSubmission(givenValue)) {
-    return getProductPrice(givenValue) === expectedValue;
+function isValidCondition(rule, fields = []) {
+  if (rule === void 0) {
+    return true;
   }
-  return givenValue === expectedValue;
-}
-
-// ../form-conditions/dist/esm/lib/operators/is-date-newer-than.js
-var import_dayjs2 = __toESM(require_dayjs_min());
-var import_isSameOrAfter = __toESM(require_isSameOrAfter());
-function valueIsDateNewerThan(givenValue, expectedValue, { orEqual = false, dateFactory = () => /* @__PURE__ */ new Date() } = {}) {
-  import_dayjs2.default.extend(import_isSameOrAfter.default);
-  if (isValueEmpty(givenValue)) {
+  const rulesOrConditions = getRulesOrConditions(rule);
+  if (!rulesOrConditions.length) {
     return false;
   }
-  if (!Array.isArray(expectedValue) || expectedValue.length !== 2) {
-    throw new Error("Expected value should be array of two elements");
-  }
-  const values = getNumberValuesToCompare(givenValue, expectedValue[0]);
-  const unit = expectedValue[1];
-  switch (unit) {
-    case "day":
-    case "month":
-      if (isArrayOfNumbers(values)) {
-        const [given, units] = values;
-        const date = (0, import_dayjs2.default)(given);
-        const nowUnitsAdded = (0, import_dayjs2.default)(dateFactory()).add(units, unit);
-        if (orEqual) {
-          return date.isSameOrAfter(nowUnitsAdded, "day");
-        }
-        return date.isAfter(nowUnitsAdded, "day");
-      }
-  }
-  throw new Error(`IsDateNewerThan operator: Unsupported values to compare ${givenValue}, ${expectedValue}`);
+  return rulesOrConditions.every((conditionOrRule) => {
+    if (isCondition(conditionOrRule)) {
+      return fields?.some((field) => field.id === conditionOrRule.fact);
+    }
+    return isValidCondition(conditionOrRule, fields);
+  });
 }
-
-// ../form-conditions/dist/esm/lib/operators/is-date-older-than.js
-var import_dayjs3 = __toESM(require_dayjs_min());
-var import_isSameOrBefore = __toESM(require_isSameOrBefore());
-function valueIsDateOlderThan(givenValue, expectedValue, { orEqual = false, dateFactory = () => /* @__PURE__ */ new Date() } = {}) {
-  import_dayjs3.default.extend(import_isSameOrBefore.default);
-  if (isValueEmpty(givenValue)) {
+function isFormRuleValid(formRule, formSchema) {
+  if (!formRule || !formRule?.overrides?.length || !formSchema) {
     return false;
   }
-  if (!Array.isArray(expectedValue) || expectedValue.length !== 2) {
-    throw new Error("Expected value should be array of two elements");
-  }
-  const values = getNumberValuesToCompare(givenValue, expectedValue[0]);
-  const unit = expectedValue[1];
-  switch (unit) {
-    case "day":
-    case "month":
-      if (isArrayOfNumbers(values)) {
-        const [given, units] = values;
-        const date = (0, import_dayjs3.default)(given);
-        const nowUnitsAdded = (0, import_dayjs3.default)(dateFactory()).add(-units, unit);
-        if (orEqual) {
-          return date.isSameOrBefore(nowUnitsAdded, "day");
-        }
-        return date.isBefore(nowUnitsAdded, "day");
-      }
-  }
-  throw new Error(`IsDateOlderThan operator: Unsupported values to compare ${givenValue}, ${expectedValue}`);
-}
-
-// ../form-conditions/dist/esm/lib/set-up-operators.js
-function setUpOperators(defaultEngine2, dateFactory) {
-  const operators = [
-    new import_js_rules_engine.Operator(ConditionOperators.empty, (value) => valueIsMissing(value)),
-    new import_js_rules_engine.Operator(ConditionOperators.notEmpty, (value) => !valueIsMissing(value)),
-    new import_js_rules_engine.Operator(ConditionOperators.between, (givenValue, expectedValue) => valueIsBetween(givenValue, expectedValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.greaterThan, (givenValue, expectedValue) => valueIsGreaterThan(givenValue, expectedValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.after, (givenValue, expectedValue) => valueIsGreaterThan(givenValue, expectedValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.greaterThanOrEqual, (givenValue, expectedValue) => valueIsGreaterThan(givenValue, expectedValue, true)),
-    new import_js_rules_engine.Operator(ConditionOperators.afterOrEqual, (givenValue, expectedValue) => valueIsGreaterThan(givenValue, expectedValue, true)),
-    new import_js_rules_engine.Operator(ConditionOperators.lessThan, (givenValue, expectedValue) => valueIsLessThan(givenValue, expectedValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.before, (givenValue, expectedValue) => valueIsLessThan(givenValue, expectedValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.lessThanOrEqual, (givenValue, expectedValue) => valueIsLessThan(givenValue, expectedValue, true)),
-    new import_js_rules_engine.Operator(ConditionOperators.beforeOrEqual, (givenValue, expectedValue) => valueIsLessThan(givenValue, expectedValue, true)),
-    new import_js_rules_engine.Operator(ConditionOperators.contains, (givenValue, expectedValue) => valueContains(givenValue, expectedValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.equal, (givenValue, expectedValue) => valueEqual(givenValue, expectedValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.notEqual, (givenValue, expectedValue) => !valueEqual(givenValue, expectedValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.notContains, (givenValue, expectedValue) => !valueContains(givenValue, expectedValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.arrayEqual, (givenValue, expectedValue) => arrayEquals(givenValue, expectedValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.arrayNotEqual, (givenValue, expectedValue) => !arrayEquals(givenValue, expectedValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.checked, checked),
-    new import_js_rules_engine.Operator(ConditionOperators.notChecked, (givenValue) => !checked(givenValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.any, (givenValue, expectedValue) => valueContainsAny(givenValue, expectedValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.in, (givenValue, expectedValue) => valueIn(givenValue, expectedValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.notIn, (givenValue, expectedValue) => !valueIn(givenValue, expectedValue)),
-    new import_js_rules_engine.Operator(ConditionOperators.isDateNewerThan, (givenValue, expectedValue) => valueIsDateNewerThan(givenValue, expectedValue, { dateFactory })),
-    new import_js_rules_engine.Operator(ConditionOperators.isDateOlderThan, (givenValue, expectedValue) => valueIsDateOlderThan(givenValue, expectedValue, { dateFactory })),
-    new import_js_rules_engine.Operator(ConditionOperators.isDateNewerThanOrEqual, (givenValue, expectedValue) => valueIsDateNewerThan(givenValue, expectedValue, {
-      orEqual: true,
-      dateFactory
-    })),
-    new import_js_rules_engine.Operator(ConditionOperators.isDateOlderThanOrEqual, (givenValue, expectedValue) => valueIsDateOlderThan(givenValue, expectedValue, {
-      orEqual: true,
-      dateFactory
-    }))
-  ];
-  operators.forEach((operator) => {
-    defaultEngine2.removeOperator(operator.name);
-    defaultEngine2.addOperator(operator);
+  const { fieldsV2, fields, nestedForms, formFields } = formSchema;
+  const fieldsToCheck = (fields ?? []).concat(fieldsV2 ?? []).concat(formFields ?? []);
+  const conditionValid = isValidCondition(formRule.condition, fieldsToCheck);
+  const overrideValid = formRule?.overrides.some((override) => {
+    if (override.entityType === OverrideEntityType.FORM) {
+      return formSchema.id === override.entityId || nestedForms?.some((nestedForm) => nestedForm.form?.id === override.entityId);
+    }
+    const wasFieldFound = (fieldsToCheck?.map((f) => f.id) ?? []).includes(override.entityId);
+    return override.entityId ? wasFieldFound : false;
   });
+  return conditionValid && overrideValid;
 }
 
-// ../form-conditions/dist/esm/lib/evaluate-override-condition.js
-function evaluateOverrideConditionFactory(dateFactory = () => /* @__PURE__ */ new Date()) {
-  setUpOperators(import_js_rules_engine2.defaultEngine, dateFactory);
-  return function evaluateOverrideCondition(override, submission = {}) {
-    if (override.condition) {
-      try {
-        const rule = getRule(override.condition);
-        return rule.evaluate(submission);
-      } catch (e) {
-        console.error(e);
-        return false;
+// ../form-conditions/dist/esm/lib/transform-path-to-v2.js
+var supportedPaths = [
+  "hidden",
+  "validation.required",
+  "validation.string.enum",
+  "validation.boolean.enum",
+  "validation.predefined.multilineAddressOptions.fields",
+  "view.options",
+  "view.countryCode"
+];
+var fieldPathMapToPlatfomized = {
+  hidden: ["hidden"],
+  "validation.required": ["inputOptions.required"],
+  "validation.string.enum": ["inputOptions.stringOptions.validation.enum"],
+  "validation.boolean.enum": ["inputOptions.booleanOptions.validation.enum"],
+  "view.options": [
+    "inputOptions.stringOptions.radioGroupOptions.options",
+    "inputOptions.stringOptions.dropdownOptions.options",
+    "inputOptions.arrayOptions.checkboxGroupOptions.options"
+  ],
+  "view.countryCode": []
+};
+
+// ../form-conditions/dist/esm/lib/apply-item-properties-override.js
+var PATH_SEPARATOR = ".";
+function applyItemPropertiesOverride(formSchema, rule) {
+  if (rule.overrides) {
+    const overriddenFormSchema = applyFormOverride(formSchema, mapOverridesByItem(rule.overrides, isFormOverride, isSupportedFormPath));
+    return {
+      ...overriddenFormSchema,
+      fields: applyItemsOverride(overriddenFormSchema.fields ?? [], mapOverridesByItem(rule.overrides, isFieldOverride, isSupportedFieldPath)),
+      ...overriddenFormSchema.fieldsV2 && {
+        fieldsV2: applyItemsOverride(overriddenFormSchema.fieldsV2 ?? [], mapOverridesV2ByItem(rule.overrides, isFieldOverride))
+      },
+      ...overriddenFormSchema.formFields && {
+        formFields: applyItemsOverride(overriddenFormSchema.formFields ?? [], mapOverridesV2ByItem(rule.overrides, isFieldOverride))
       }
-    }
-    return true;
-  };
-  function getRule(condition) {
-    return new import_js_rules_engine2.Rule(condition);
+    };
   }
+  return formSchema;
 }
-
-// ../form-mapper/dist/esm/lib/submission-mapper.js
-function mapByIds(submission, form) {
-  return mapBy(submission, form, "id");
+function applyItemsOverride(items, formItemOverrides) {
+  return items.map((formField) => {
+    const fieldOverrides = formItemOverrides[asRequired2(formField.id)] || [];
+    return fieldOverrides.reduce((acc, override) => setToValue(acc, override.path, override.value), formField);
+  });
 }
-function mapBy(submission, form, by) {
-  const from = "target" ;
-  const fields = (form?.fields?.length ?? 0) > 0 ? form?.fields ?? [] : (form?.formFields?.length ?? 0) > 0 ? form?.formFields ?? [] : form?.fieldsV2 ?? [];
-  const getIdOrTarget = (field, _by) => {
-    if (_by === "id") {
-      return field[_by];
-    } else if ("inputOptions" in field) {
-      return field.inputOptions?.target;
-    } else {
-      return field.target;
-    }
-  };
-  return fields.reduce((acc, field) => {
-    const source = getIdOrTarget(field, from);
-    const destination = getIdOrTarget(field, by);
-    if (source && destination && source !== destination && acc.hasOwnProperty(source)) {
-      acc[destination] = acc[source];
-      const { [source]: omitted, ...rest } = acc;
-      acc = rest;
-    }
+function applyFormOverride(formSchema, formItemOverrides) {
+  const formOverrides = Object.values(formItemOverrides).flat();
+  return formOverrides.reduce((acc, override) => setToValue(acc, override.path, override.value), formSchema);
+}
+function mapOverridesByItem(overrideItems, isOverride, isSupportedPath) {
+  return overrideItems.filter(isOverride).reduce((acc, overrideItem) => {
+    const entityId = asRequired2(overrideItem.entityId);
+    const overrides = Object.entries(overrideItem.valueChanges ?? {}).filter(([path]) => isSupportedPath(path)).map(([path, value]) => ({
+      path: path.split(PATH_SEPARATOR),
+      value
+    }));
+    acc[entityId] = [...acc[entityId] || [], ...overrides];
     return acc;
-  }, { ...submission });
+  }, {});
 }
-
-// ../form-conditions/dist/esm/lib/apply-overrides.js
-function applyOverrides(formSchema, submission) {
-  const nestedForms = (formSchema?.nestedForms || []).flatMap(({ targets, form }) => (targets || []).map((target) => ({
-    form: applyFormOverrides(asRequired2(form), (submission || {})[target]),
-    targets: [target]
-  })));
-  return { ...applyFormOverrides(formSchema, submission), nestedForms };
+function mapOverridesV2ByItem(overrideItems, isOverride) {
+  return overrideItems.filter(isOverride).reduce((acc, overrideItem) => {
+    const entityId = asRequired2(overrideItem.entityId);
+    const overrides = Object.entries(overrideItem.valueChanges ?? {}).flatMap(([path, value]) => {
+      const resolvedV2Paths = fieldPathMapToPlatfomized[path] || [];
+      return resolvedV2Paths.map((pathV2) => [pathV2, value]);
+    }).map(([path, value]) => ({
+      path: path.split(PATH_SEPARATOR),
+      value
+    }));
+    acc[entityId] = [...acc[entityId] || [], ...overrides];
+    return acc;
+  }, {});
 }
-function applyFormOverrides(formSchema, submission) {
-  const submissionsById = mapByIds(submission, formSchema);
-  const { rules } = formSchema;
-  if (rules) {
-    return rules.filter((rule) => isFormRuleValid(rule, formSchema)).filter((rule) => evaluateOverrideConditionFactory()(rule, submissionsById)).reduce((form, rule) => applyItemPropertiesOverride(form, rule), formSchema);
+function setToValue(obj, pathProps, value) {
+  if (value !== void 0 && obj !== void 0) {
+    const [prop, ...rest] = pathProps;
+    if (rest.length) {
+      const valueToSet = setToValue(obj[prop], rest, value);
+      if (valueToSet !== void 0) {
+        return {
+          ...obj,
+          [prop]: valueToSet
+        };
+      }
+      return obj;
+    }
+    return {
+      ...obj,
+      [prop]: value
+    };
   }
-  return formSchema;
+  return obj;
 }
-
-// ../nested-form-overrides/dist/esm/lib/array-utils.js
-function partition(items, condition) {
-  return items.reduce(([truthy, falsy], element) => {
-    if (condition(element)) {
-      truthy.push(element);
-    } else {
-      falsy.push(element);
-    }
-    return [truthy, falsy];
-  }, [[], []]);
+function isFieldOverride(override) {
+  return override.entityType === OverrideEntityType.FIELD;
 }
-function mapBy2(items, keyFn) {
-  return items.reduce((acc, item) => {
-    acc[keyFn(item)] = item;
-    return acc;
-  }, {});
+function isFormOverride(override) {
+  return override.entityType === OverrideEntityType.FORM;
 }
-
-// ../nested-form-overrides/dist/esm/lib/lang-utils.js
-function isDefined2(value) {
-  return !(value === null || value === void 0);
+function isSupportedFieldPath(path) {
+  return supportedPaths.includes(path);
 }
-
-// ../nested-form-overrides/dist/esm/lib/object-utils.js
-function isEmpty(object) {
-  return Boolean(object) && Boolean(Object.keys(object).length);
+function isSupportedFormPath(path) {
+  return ["fields", "steps"].includes(path);
 }
 
-// ../nested-form-overrides/dist/esm/lib/nested-form-overrides.js
-function applyNestedFormOverrides(parentForm) {
-  const fieldsWithFormOverrides = parentForm.fields.filter((field) => isEmpty(field.nestedFormOverrides?.fieldOverrides));
-  const fieldsWithFormOverridesByTarget = mapBy2(fieldsWithFormOverrides, (field) => field.target);
-  const nestedForms = (parentForm.nestedForms || []).reduce((acc, { targets, form } = {}) => {
-    const [targetsWithOverride, targetsWithoutOverride] = partition(targets, (target) => Boolean(fieldsWithFormOverridesByTarget[target]));
-    const nestedFormsWithOverrides = targetsWithOverride.map((target) => ({
-      targets: [target],
-      form: applyOverrides2(form, fieldsWithFormOverridesByTarget[target].nestedFormOverrides)
-    }));
-    const nestedFormsWithoutOverrides = targetsWithoutOverride.length ? [{ targets: targetsWithoutOverride, form }] : [];
-    return [
-      ...acc,
-      ...nestedFormsWithoutOverrides,
-      ...nestedFormsWithOverrides
-    ];
-  }, []);
-  return { ...parentForm, nestedForms };
+// ../form-conditions/dist/esm/lib/evaluate-override-condition.js
+var import_js_rules_engine2 = __toESM(require_dist5());
+
+// ../form-conditions/dist/esm/lib/set-up-operators.js
+var import_js_rules_engine = __toESM(require_dist5());
+
+// ../form-conditions/dist/esm/lib/operators/between.js
+function valueIsBetween(givenValue, expectedValue) {
+  if (isValueEmpty(givenValue)) {
+    return false;
+  }
+  if (!Array.isArray(expectedValue) || expectedValue.length !== 2) {
+    throw new Error("Expected value should be array of two elements");
+  }
+  const values = getNumberValuesToCompare(givenValue, expectedValue[0], expectedValue[1]);
+  if (isArrayOfNumbers(values)) {
+    const [given, firstBound, secondBound] = values;
+    return between(given, Math.min(firstBound, secondBound), Math.max(firstBound, secondBound));
+  }
+  throw new Error(`Between operator: Unsupported values to compare ${givenValue}, ${JSON.stringify(expectedValue)}`);
 }
-function applyOverrides2(form, overrides) {
-  const fieldOverrides = overrides.fieldOverrides;
-  return {
-    ...form,
-    fields: form.fields.map((field) => {
-      const { hidden: hiddenOverride, required: requiredOverride } = fieldOverrides[field.id] || {};
-      return {
-        ...field,
-        ...isDefined2(hiddenOverride) && { hidden: hiddenOverride },
-        ...isDefined2(requiredOverride) && isDefined2(field.validation) && {
-          validation: {
-            ...field.validation,
-            required: requiredOverride
-          }
-        }
-      };
-    })
-  };
+
+// ../form-conditions/dist/esm/lib/operators/greater-than.js
+function valueIsGreaterThan(givenValue, expectedValue, orEqual = false) {
+  if (isValueEmpty(givenValue)) {
+    return false;
+  }
+  const values = getNumberValuesToCompare(givenValue, expectedValue);
+  if (isArrayOfNumbers(values)) {
+    const [given, expected] = values;
+    return greaterThan(given, expected, orEqual);
+  }
+  throw new Error(`GreaterThan operator: Unsupported values to compare ${givenValue}, ${expectedValue}`);
 }
 
-// ../form-viewer/dist/esm/services/utils.js
-var RATING_VALUES = [1, 2, 3, 4, 5];
-function isObject4(value) {
-  return typeof value === "object" && !Array.isArray(value) && value !== null;
+// ../form-conditions/dist/esm/lib/operators/less-than.js
+function valueIsLessThan(givenValue, expectedValue, orEqual = false) {
+  if (isValueEmpty(givenValue)) {
+    return false;
+  }
+  const values = getNumberValuesToCompare(givenValue, expectedValue);
+  if (isArrayOfNumbers(values)) {
+    const [given, expected] = values;
+    return lessThan(given, expected, orEqual);
+  }
+  throw new Error(`LessThan operator: Unsupported values to compare ${givenValue}, ${expectedValue}`);
 }
-function isString(value) {
-  return typeof value === "string";
+
+// ../form-conditions/dist/esm/lib/operators/contains.js
+function valueContains(givenValue, expectedValue) {
+  if (isValueEmpty(givenValue)) {
+    return false;
+  }
+  if (isObject4(givenValue)) {
+    return Object.values(givenValue).includes(expectedValue);
+  }
+  if (Array.isArray(givenValue) || typeof givenValue === "string") {
+    return givenValue.indexOf(expectedValue) > -1;
+  }
+  throw new Error(`Contains operator: Unsupported values to compare ${JSON.stringify(givenValue)}, ${JSON.stringify(expectedValue)}`);
 }
-function isNumber(value) {
-  return typeof value === "number" && !Number.isNaN(value);
+
+// ../form-conditions/dist/esm/lib/operators/array-equals.js
+function arrayEquals(givenValue, expectedValue) {
+  if (isValueEmpty(givenValue)) {
+    return false;
+  }
+  if (!Array.isArray(givenValue) || !Array.isArray(expectedValue)) {
+    throw new Error(`All operator: Unsupported values to compare ${JSON.stringify(givenValue)}, ${JSON.stringify(expectedValue)}`);
+  }
+  if (givenValue.length !== expectedValue.length) {
+    return false;
+  }
+  if (isProductSubmission(givenValue)) {
+    return equals(givenValue.map((product) => product.productId), expectedValue);
+  }
+  return equals(givenValue, expectedValue);
 }
-function isRating(value) {
-  return typeof value === "number" && RATING_VALUES.includes(value);
+function equals(givenValue, expectedValue) {
+  return expectedValue.every((v) => givenValue.includes(v));
 }
 
-// ../form-viewer/dist/esm/services/has-multiline-address.js
-var hasMultilineAddress = (form, { excludeEcomAddress } = {
-  excludeEcomAddress: false
-}) => {
-  const fields = [...form?.fields || [], ...form?.deletedFields || []];
-  return fields.some((field) => field.view?.fieldType === "MULTILINE_ADDRESS" || field.view?.fieldType === "BOOKINGS_ADDRESS" || !excludeEcomAddress && field.view?.fieldType === "ECOM_ADDRESS");
-};
-
-// ../form-viewer/dist/esm/services/validation.js
-var removeFalsyValues = (values = {}) => {
-  return Object.keys(values).reduce((withoutFalsy, target) => {
-    const value = values[target];
-    if (value === "" || typeof value === "undefined" || value === null) {
-      return withoutFalsy;
-    }
-    if (Array.isArray(value) && !value.length) {
-      return withoutFalsy;
-    }
-    if (isObject4(value)) {
-      withoutFalsy[target] = removeFalsyValues(value);
-    } else {
-      withoutFalsy[target] = value;
-    }
-    return withoutFalsy;
-  }, {});
-};
-var getFormValidator = async (form, addressTemplates, validationMode) => {
-  const [{ FormValidator: FormValidator2 }, { MultilineAddressToolkit: MultilineAddressToolkit2 }] = await Promise.all([
-    Promise.resolve().then(() => (init_esm(), esm_exports)),
-    Promise.resolve().then(() => (init_esm2(), esm_exports2))
-  ]);
-  if (addressTemplates?.length) {
-    const addressForms = addressTemplates.map((template) => template.template);
-    const addressToolkit = new MultilineAddressToolkit2(addressForms);
-    return new FormValidator2([form], validationMode, false, addressToolkit.getFormForValidation, addressToolkit.normalizeEmptyValues, true);
+// ../form-conditions/dist/esm/lib/operators/any.js
+function valueContainsAny(_givenValue, expectedValue) {
+  if (isValueEmpty(_givenValue)) {
+    return false;
   }
-  return new FormValidator2([form], validationMode, void 0, void 0, void 0, true);
-};
-var validate = async (form, values, addressTemplates, validationMode) => {
-  if (!form.id) {
-    return;
+  const givenValue = Array.isArray(_givenValue) ? _givenValue : [_givenValue];
+  if (!Array.isArray(givenValue) || !Array.isArray(expectedValue)) {
+    throw new Error(`Any operator: Unsupported values to compare ${JSON.stringify(givenValue)}, ${JSON.stringify(expectedValue)}`);
   }
-  const formValidator = await getFormValidator(form, addressTemplates, validationMode);
-  return formValidator.validate(form.id, hasMultilineAddress(form, { excludeEcomAddress: true }) ? values : removeFalsyValues(values));
-};
-var validateFields = async (form, values, addressTemplates, validationMode) => {
-  if (!form.id) {
-    return;
+  if (isProductSubmission(givenValue)) {
+    return any(givenValue.map((product) => product.productId), expectedValue);
   }
-  const formValidator = await getFormValidator(form, addressTemplates, validationMode);
-  return formValidator.validateFields(form.id, hasMultilineAddress(form) ? values : removeFalsyValues(values));
-};
+  return any(givenValue, expectedValue);
+}
+function any(givenValue, expectedValue) {
+  return givenValue.some((v) => expectedValue.includes(v));
+}
 
-// ../form-viewer/dist/esm/services/apply-nested-forms.js
-function applyNestedForms(form, nestedFormsById) {
-  if (!form.nestedForms && !nestedFormsById) {
-    return form;
+// ../form-conditions/dist/esm/lib/operators/in.js
+function valueIn(givenValue, expectedValue) {
+  if (isObject4(expectedValue)) {
+    return Object.values(expectedValue).includes(givenValue);
   }
-  const nestedFormsByTarget = getNestedFormsByTarget(form);
-  return {
-    ...form,
-    fields: form.fields?.map((field) => {
-      const fieldTarget = field.target;
-      if (!fieldTarget) {
-        return field;
-      }
-      const nestedFormId = field.nestedFormId;
-      if (!nestedFormId) {
-        return field;
-      }
-      const nestedForm = nestedFormsByTarget?.[fieldTarget] ?? nestedFormsById?.[nestedFormId];
-      if (nestedForm) {
-        return { ...field, view: { ...field.view, form: nestedForm } };
-      }
-      return field;
-    })
-  };
-}
-function getNestedFormsByTarget(form) {
-  return form.nestedForms?.reduce((byTarget, { targets, form: nestedForm }) => {
-    if (!nestedForm || !targets) {
-      return byTarget;
-    }
-    for (const target of targets) {
-      byTarget[target] = nestedForm;
-    }
-    return byTarget;
-  }, {});
+  if (Array.isArray(expectedValue) || typeof expectedValue === "string") {
+    return expectedValue.indexOf(givenValue) > -1;
+  }
+  throw new Error(`In operator: Unsupported values to compare ${JSON.stringify(givenValue)}, ${JSON.stringify(expectedValue)}`);
 }
-function getNestedFormArray(formsByTarget) {
-  return Object.keys(formsByTarget).map((target) => {
-    return { targets: [target], form: formsByTarget[target] };
-  });
+
+// ../form-conditions/dist/esm/lib/condition-operators.js
+var ConditionOperators;
+(function(ConditionOperators2) {
+  ConditionOperators2["equal"] = "equal";
+  ConditionOperators2["notEqual"] = "notEqual";
+  ConditionOperators2["notEmpty"] = "notEmpty";
+  ConditionOperators2["empty"] = "empty";
+  ConditionOperators2["contains"] = "contains";
+  ConditionOperators2["notContains"] = "notContains";
+  ConditionOperators2["greaterThanOrEqual"] = "greaterThanOrEqual";
+  ConditionOperators2["greaterThan"] = "greaterThan";
+  ConditionOperators2["afterOrEqual"] = "afterOrEqual";
+  ConditionOperators2["after"] = "after";
+  ConditionOperators2["lessThanOrEqual"] = "lessThanOrEqual";
+  ConditionOperators2["lessThan"] = "lessThan";
+  ConditionOperators2["beforeOrEqual"] = "beforeOrEqual";
+  ConditionOperators2["before"] = "before";
+  ConditionOperators2["between"] = "between";
+  ConditionOperators2["any"] = "any";
+  ConditionOperators2["arrayEqual"] = "arrayEqual";
+  ConditionOperators2["arrayNotEqual"] = "arrayNotEqual";
+  ConditionOperators2["checked"] = "checked";
+  ConditionOperators2["notChecked"] = "notChecked";
+  ConditionOperators2["in"] = "in";
+  ConditionOperators2["notIn"] = "notIn";
+  ConditionOperators2["isDateNewerThan"] = "isDateNewerThan";
+  ConditionOperators2["isDateOlderThan"] = "isDateOlderThan";
+  ConditionOperators2["isDateNewerThanOrEqual"] = "isDateNewerThanOrEqual";
+  ConditionOperators2["isDateOlderThanOrEqual"] = "isDateOlderThanOrEqual";
+})(ConditionOperators || (ConditionOperators = {}));
+
+// ../form-conditions/dist/esm/lib/operators/checked.js
+function checked(givenValue) {
+  return Boolean(givenValue);
 }
 
-// ../form-viewer/dist/esm/services/additional-field-validation.js
-var runAdditionalValidation = ({ form, values, externalData }) => {
-  const additionalErrors = form.fields?.reduce((acc, field) => {
-    const fieldTarget = field.target;
-    if (!fieldTarget) {
-      return acc;
-    }
-    const fieldType = field?.view?.fieldType;
-    const fieldValue = values[fieldTarget];
-    const validateField = ADDITIONAL_FIELD_VALIDATION[fieldType];
-    const error = validateField?.({
-      value: fieldValue,
-      target: fieldTarget,
-      externalData
-    });
-    if (error) {
-      acc[fieldTarget] = error;
-    }
-    return acc;
-  }, {});
-  return additionalErrors;
-};
-var ADDITIONAL_FIELD_VALIDATION = {
-  [FIELD_TYPES.TEXT_INPUT]: null,
-  [FIELD_TYPES.CHECKBOX_GROUP]: null,
-  [FIELD_TYPES.RADIO_GROUP]: null,
-  [FIELD_TYPES.DONATION]: null,
-  [FIELD_TYPES.DROPDOWN]: null,
-  [FIELD_TYPES.URL_INPUT]: null,
-  [FIELD_TYPES.NUMBER_INPUT]: null,
-  [FIELD_TYPES.QUIZ_NUMBER]: null,
-  [FIELD_TYPES.QUIZ_SHORT_TEXT]: null,
-  [FIELD_TYPES.QUIZ_LONG_TEXT]: null,
-  [FIELD_TYPES.QUIZ_MULTI_CHOICE]: null,
-  [FIELD_TYPES.QUIZ_IMAGE_CHOICE]: null,
-  [FIELD_TYPES.QUIZ_SINGLE_CHOICE]: null,
-  [FIELD_TYPES.QUIZ_FILE_UPLOAD]: null,
-  [FIELD_TYPES.FILE_UPLOAD]: null,
-  [FIELD_TYPES.SIGNATURE]: null,
-  [FIELD_TYPES.CONTACTS_EMAIL]: null,
-  [FIELD_TYPES.CONTACTS_PHONE]: null,
-  [FIELD_TYPES.CHECKBOX]: null,
-  [FIELD_TYPES.DATE_INPUT]: null,
-  [FIELD_TYPES.DATE_TIME_INPUT]: null,
-  [FIELD_TYPES.TIME_INPUT]: null,
-  [FIELD_TYPES.DATE_PICKER]: null,
-  [FIELD_TYPES.CONTACTS_COMPANY]: null,
-  [FIELD_TYPES.CONTACTS_POSITION]: null,
-  [FIELD_TYPES.CONTACTS_TAX_ID]: null,
-  [FIELD_TYPES.CONTACTS_FIRST_NAME]: null,
-  [FIELD_TYPES.CONTACTS_LAST_NAME]: null,
-  [FIELD_TYPES.CONTACTS_ADDRESS]: null,
-  [FIELD_TYPES.CONTACTS_BIRTHDATE]: validateBirthdate,
-  [FIELD_TYPES.TEXT_AREA]: null,
-  [FIELD_TYPES.CONTACTS_SUBSCRIBE]: null,
-  [FIELD_TYPES.NESTED_FORM]: null,
-  [FIELD_TYPES.MULTILINE_ADDRESS]: null,
-  [FIELD_TYPES.MLA_COUNTRY]: null,
-  [FIELD_TYPES.MLA_CITY]: null,
-  [FIELD_TYPES.MLA_ADDRESS_LINE]: null,
-  [FIELD_TYPES.MLA_ADDRESS_LINE_2]: null,
-  [FIELD_TYPES.MLA_POSTAL_CODE]: null,
-  [FIELD_TYPES.MLA_SUBDIVISION]: null,
-  [FIELD_TYPES.MLA_STREET_NAME]: null,
-  [FIELD_TYPES.MLA_STREET_NUMBER]: null,
-  [FIELD_TYPES.MLA_APARTMENT]: null,
-  [FIELD_TYPES.FULL_NAME_FIRST_NAME]: null,
-  [FIELD_TYPES.FULL_NAME_LAST_NAME]: null,
-  [FIELD_TYPES.FULL_NAME]: null,
-  [FIELD_TYPES.DEXT_TEXT_INPUT]: null,
-  [FIELD_TYPES.DEXT_NUMBER_INPUT]: null,
-  [FIELD_TYPES.DEXT_CHECKBOX]: null,
-  [FIELD_TYPES.DEXT_CHECKBOX_GROUP]: null,
-  [FIELD_TYPES.DEXT_TAGS]: null,
-  [FIELD_TYPES.DEXT_RATING_INPUT]: null,
-  [FIELD_TYPES.ECOM_ADDITIONAL_INFO]: null,
-  [FIELD_TYPES.ECOM_ADDRESS]: null,
-  [FIELD_TYPES.ECOM_PHONE]: null,
-  [FIELD_TYPES.ECOM_FULL_NAME]: null,
-  [FIELD_TYPES.ECOM_COMPANY_NAME]: null,
-  [FIELD_TYPES.ECOM_EMAIL]: null,
-  [FIELD_TYPES.ECOM_SUBSCRIPTION]: null,
-  [FIELD_TYPES.DEXT_TEXT_AREA]: null,
-  [FIELD_TYPES.DEXT_DROPDOWN]: null,
-  [FIELD_TYPES.DEXT_RADIO_GROUP]: null,
-  [FIELD_TYPES.DEXT_URL_INPUT]: null,
-  [FIELD_TYPES.DEXT_EMAIL]: null,
-  [FIELD_TYPES.DEXT_PHONE]: null,
-  [FIELD_TYPES.DEXT_DATE_PICKER]: null,
-  [FIELD_TYPES.VAT_ID]: validateVatID,
-  [FIELD_TYPES.PRODUCT_LIST]: null,
-  [FIELD_TYPES.RATING_INPUT]: null,
-  [FIELD_TYPES.TAGS]: null,
-  [FIELD_TYPES.PAYMENT_INPUT]: null,
-  [FIELD_TYPES.FIXED_PAYMENT]: null,
-  [FIELD_TYPES.BOOKINGS_FIRST_NAME]: null,
-  [FIELD_TYPES.BOOKINGS_LAST_NAME]: null,
-  [FIELD_TYPES.BOOKINGS_EMAIL]: null,
-  [FIELD_TYPES.BOOKINGS_PHONE]: null,
-  [FIELD_TYPES.BOOKINGS_ADDRESS]: null,
-  [FIELD_TYPES.APPOINTMENT]: null,
-  [FIELD_TYPES.IDENTITY_PASSWORD]: null,
-  [FIELD_TYPES.SERVICES_DROPDOWN]: null,
-  [FIELD_TYPES.SERVICES_MULTI_CHOICE]: null,
-  [FIELD_TYPES.EVENTS_RSVP]: null,
-  [FIELD_TYPES.EVENTS_REPEATER]: null
-};
+// ../form-conditions/dist/esm/lib/operators/equal.js
+function valueEqual(givenValue, expectedValue) {
+  if (isProductSubmission(givenValue)) {
+    return getProductPrice(givenValue) === expectedValue;
+  }
+  return givenValue === expectedValue;
+}
 
-// ../form-viewer/dist/esm/services/get-field-errors.js
-var getFieldErrors = async (fieldsToValidate, form, addressTemplates, externalData, validationMode) => {
-  const formValues = fieldsToValidate.reduce((acc, field) => setValue(acc, field.path, field.value), {});
-  const result2 = await validateFields(form, formValues, addressTemplates, validationMode);
-  const _errors = result2?.errors || [];
-  const additionalErrors = runAdditionalValidation({
-    form,
-    values: formValues,
-    externalData
-  });
-  const allErrors = mergeErrors({ errors: _errors, additionalErrors });
-  const fieldErrors = allErrors.filter((error) => findErrorByNormalizedPath(fieldsToValidate, error.errorPath));
-  return fieldErrors;
-};
-var findErrorByNormalizedPath = (fieldsToValidate, errorPath) => {
-  const path = errorPath.split("/").length > 2 ? errorPath.split("/").at(0) : errorPath;
-  return !!fieldsToValidate.find((field) => path === field.path);
-};
-function setValue(object, path, value) {
-  const delimiter = "/";
-  const decomposedPath = path.split(delimiter);
-  const base = decomposedPath[0];
-  if (base === void 0) {
-    return object;
+// ../form-conditions/dist/esm/lib/operators/is-date-newer-than.js
+var import_dayjs2 = __toESM(require_dayjs_min());
+var import_isSameOrAfter = __toESM(require_isSameOrAfter());
+function valueIsDateNewerThan(givenValue, expectedValue, { orEqual = false, dateFactory = () => /* @__PURE__ */ new Date() } = {}) {
+  import_dayjs2.default.extend(import_isSameOrAfter.default);
+  if (isValueEmpty(givenValue)) {
+    return false;
   }
-  if (!object.hasOwnProperty(base)) {
-    object[base] = {};
+  if (!Array.isArray(expectedValue) || expectedValue.length !== 2) {
+    throw new Error("Expected value should be array of two elements");
   }
-  value = decomposedPath.length <= 1 ? value : setValue(object[base], decomposedPath.slice(1).join(delimiter), value);
-  return {
-    ...object,
-    [base]: value
-  };
-}
-var mergeErrors = ({ errors, additionalErrors }) => {
-  const errorsToAdd = [];
-  if (additionalErrors) {
-    Object.keys(additionalErrors).forEach((fieldTarget) => {
-      const errorExists = errors.find((error) => error.errorPath === fieldTarget);
-      if (!errorExists) {
-        errorsToAdd.push(additionalErrors[fieldTarget]);
+  const values = getNumberValuesToCompare(givenValue, expectedValue[0]);
+  const unit = expectedValue[1];
+  switch (unit) {
+    case "day":
+    case "month":
+      if (isArrayOfNumbers(values)) {
+        const [given, units] = values;
+        const date = (0, import_dayjs2.default)(given);
+        const nowUnitsAdded = (0, import_dayjs2.default)(dateFactory()).add(units, unit);
+        if (orEqual) {
+          return date.isSameOrAfter(nowUnitsAdded, "day");
+        }
+        return date.isAfter(nowUnitsAdded, "day");
       }
-    });
   }
-  return [...errors, ...errorsToAdd];
-};
+  throw new Error(`IsDateNewerThan operator: Unsupported values to compare ${givenValue}, ${expectedValue}`);
+}
 
-// ../form-viewer/dist/esm/services/form-overrides.js
-function applyFormOverrides2(form, overrides, recursive = true) {
-  const nestedFormsByTarget = getNestedFormsByTarget(form);
-  const fields = (form.fields ?? []).map((field) => {
-    const override = getOverride({
-      id: field.id,
-      target: field.target,
-      overrides
-    });
-    if (!override) {
-      return field;
-    }
-    if (field.target && field.nestedFormId && recursive) {
-      const nestedForm = nestedFormsByTarget?.[field.target];
-      if (nestedForm) {
-        nestedFormsByTarget[field.target] = applyFormOverrides2(nestedForm, override, false);
-      }
-      return field;
-    }
-    let validation = field.validation;
-    let options = {};
-    if (Array.isArray(override.countries)) {
-      validation = {
-        ...validation,
-        string: {
-          ...validation?.string,
-          enum: override.countries
+// ../form-conditions/dist/esm/lib/operators/is-date-older-than.js
+var import_dayjs3 = __toESM(require_dayjs_min());
+var import_isSameOrBefore = __toESM(require_isSameOrBefore());
+function valueIsDateOlderThan(givenValue, expectedValue, { orEqual = false, dateFactory = () => /* @__PURE__ */ new Date() } = {}) {
+  import_dayjs3.default.extend(import_isSameOrBefore.default);
+  if (isValueEmpty(givenValue)) {
+    return false;
+  }
+  if (!Array.isArray(expectedValue) || expectedValue.length !== 2) {
+    throw new Error("Expected value should be array of two elements");
+  }
+  const values = getNumberValuesToCompare(givenValue, expectedValue[0]);
+  const unit = expectedValue[1];
+  switch (unit) {
+    case "day":
+    case "month":
+      if (isArrayOfNumbers(values)) {
+        const [given, units] = values;
+        const date = (0, import_dayjs3.default)(given);
+        const nowUnitsAdded = (0, import_dayjs3.default)(dateFactory()).add(-units, unit);
+        if (orEqual) {
+          return date.isSameOrBefore(nowUnitsAdded, "day");
         }
-      };
-      options = override.countries ? {
-        options: override.countries?.map((country) => ({ value: country }))
-      } : {};
-    }
-    if (field.view?.fieldType === "MULTILINE_ADDRESS") {
-      return applyMultilineAddressOverrides({
-        field,
-        override
-      });
-    }
-    return {
-      ...field,
-      ...pick(override, "hidden"),
-      ...pick(override, "readOnly"),
-      view: {
-        ...field.view,
-        ...pick(override, "label"),
-        ...pick(override, "autocomplete"),
-        ...pick(override, "disabled"),
-        ...options
-      },
-      validation: {
-        ...validation,
-        ...pick(override, "required")
+        return date.isBefore(nowUnitsAdded, "day");
       }
-    };
+  }
+  throw new Error(`IsDateOlderThan operator: Unsupported values to compare ${givenValue}, ${expectedValue}`);
+}
+
+// ../form-conditions/dist/esm/lib/set-up-operators.js
+function setUpOperators(defaultEngine2, dateFactory) {
+  const operators = [
+    new import_js_rules_engine.Operator(ConditionOperators.empty, (value) => valueIsMissing(value)),
+    new import_js_rules_engine.Operator(ConditionOperators.notEmpty, (value) => !valueIsMissing(value)),
+    new import_js_rules_engine.Operator(ConditionOperators.between, (givenValue, expectedValue) => valueIsBetween(givenValue, expectedValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.greaterThan, (givenValue, expectedValue) => valueIsGreaterThan(givenValue, expectedValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.after, (givenValue, expectedValue) => valueIsGreaterThan(givenValue, expectedValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.greaterThanOrEqual, (givenValue, expectedValue) => valueIsGreaterThan(givenValue, expectedValue, true)),
+    new import_js_rules_engine.Operator(ConditionOperators.afterOrEqual, (givenValue, expectedValue) => valueIsGreaterThan(givenValue, expectedValue, true)),
+    new import_js_rules_engine.Operator(ConditionOperators.lessThan, (givenValue, expectedValue) => valueIsLessThan(givenValue, expectedValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.before, (givenValue, expectedValue) => valueIsLessThan(givenValue, expectedValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.lessThanOrEqual, (givenValue, expectedValue) => valueIsLessThan(givenValue, expectedValue, true)),
+    new import_js_rules_engine.Operator(ConditionOperators.beforeOrEqual, (givenValue, expectedValue) => valueIsLessThan(givenValue, expectedValue, true)),
+    new import_js_rules_engine.Operator(ConditionOperators.contains, (givenValue, expectedValue) => valueContains(givenValue, expectedValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.equal, (givenValue, expectedValue) => valueEqual(givenValue, expectedValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.notEqual, (givenValue, expectedValue) => !valueEqual(givenValue, expectedValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.notContains, (givenValue, expectedValue) => !valueContains(givenValue, expectedValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.arrayEqual, (givenValue, expectedValue) => arrayEquals(givenValue, expectedValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.arrayNotEqual, (givenValue, expectedValue) => !arrayEquals(givenValue, expectedValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.checked, checked),
+    new import_js_rules_engine.Operator(ConditionOperators.notChecked, (givenValue) => !checked(givenValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.any, (givenValue, expectedValue) => valueContainsAny(givenValue, expectedValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.in, (givenValue, expectedValue) => valueIn(givenValue, expectedValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.notIn, (givenValue, expectedValue) => !valueIn(givenValue, expectedValue)),
+    new import_js_rules_engine.Operator(ConditionOperators.isDateNewerThan, (givenValue, expectedValue) => valueIsDateNewerThan(givenValue, expectedValue, { dateFactory })),
+    new import_js_rules_engine.Operator(ConditionOperators.isDateOlderThan, (givenValue, expectedValue) => valueIsDateOlderThan(givenValue, expectedValue, { dateFactory })),
+    new import_js_rules_engine.Operator(ConditionOperators.isDateNewerThanOrEqual, (givenValue, expectedValue) => valueIsDateNewerThan(givenValue, expectedValue, {
+      orEqual: true,
+      dateFactory
+    })),
+    new import_js_rules_engine.Operator(ConditionOperators.isDateOlderThanOrEqual, (givenValue, expectedValue) => valueIsDateOlderThan(givenValue, expectedValue, {
+      orEqual: true,
+      dateFactory
+    }))
+  ];
+  operators.forEach((operator) => {
+    defaultEngine2.removeOperator(operator.name);
+    defaultEngine2.addOperator(operator);
   });
-  const nestedForms = nestedFormsByTarget ? getNestedFormArray(nestedFormsByTarget) : void 0;
-  return {
-    ...form,
-    fields,
-    ...nestedForms ? { nestedForms } : {}
+}
+
+// ../form-conditions/dist/esm/lib/evaluate-override-condition.js
+function evaluateOverrideConditionFactory(dateFactory = () => /* @__PURE__ */ new Date()) {
+  setUpOperators(import_js_rules_engine2.defaultEngine, dateFactory);
+  return function evaluateOverrideCondition(override, submission = {}) {
+    if (override.condition) {
+      try {
+        const rule = getRule(override.condition);
+        return rule.evaluate(submission);
+      } catch (e) {
+        console.error(e);
+        return false;
+      }
+    }
+    return true;
   };
+  function getRule(condition) {
+    return new import_js_rules_engine2.Rule(condition);
+  }
 }
-function pick(override, key) {
-  return override.hasOwnProperty(key) ? { [key]: override[key] } : {};
+
+// ../form-mapper/dist/esm/lib/submission-mapper.js
+function mapByIds(submission, form) {
+  return mapBy(submission, form, "id");
 }
-var getOverride = ({ target, id, overrides }) => {
-  if (target && target in overrides) {
-    return overrides[target];
-  }
-  if (id && id in overrides) {
-    return overrides[id];
-  }
-  return void 0;
-};
-var applyAddressFieldOverride = (fieldName, override, multilineAddressOptionsFields, multilineAddressFieldSettings) => {
-  const fieldOverride = override[fieldName];
-  if (!fieldOverride) {
-    return {
-      multilineAddressOptionsFields,
-      multilineAddressFieldSettings
-    };
-  }
-  return {
-    multilineAddressOptionsFields: {
-      ...multilineAddressOptionsFields,
-      [fieldName]: {
-        required: fieldOverride.required
-      }
-    },
-    multilineAddressFieldSettings: {
-      ...multilineAddressFieldSettings,
-      [fieldName]: {
-        ...multilineAddressFieldSettings?.[fieldName],
-        show: !fieldOverride.hidden
-      }
+function mapBy(submission, form, by) {
+  const from = "target" ;
+  const fields = (form?.fields?.length ?? 0) > 0 ? form?.fields ?? [] : (form?.formFields?.length ?? 0) > 0 ? form?.formFields ?? [] : form?.fieldsV2 ?? [];
+  const getIdOrTarget = (field, _by) => {
+    if (_by === "id") {
+      return field[_by];
+    } else if ("inputOptions" in field) {
+      return field.inputOptions?.target;
+    } else {
+      return field.target;
     }
   };
-};
-var ADDRESS_FIELD_NAMES = [
-  "addressLine",
-  "addressLine2",
-  "streetName",
-  "streetNumber",
-  "city",
-  "postalCode",
-  "subdivision",
-  "country",
-  "apartment"
-];
-var applyMultilineAddressOverrides = ({ field, override }) => {
-  const finalState = ADDRESS_FIELD_NAMES.reduce((state, fieldName) => applyAddressFieldOverride(fieldName, override, state.multilineAddressOptionsFields ?? {}, state.multilineAddressFieldSettings ?? {}), {
-    multilineAddressOptionsFields: field.validation?.predefined?.multilineAddressOptions?.fields,
-    multilineAddressFieldSettings: field.view?.fieldSettings
-  });
-  const autocompleteEnabled = (override.addressLine?.autocomplete || override.streetName?.autocomplete) ?? true;
-  const multilineAddressOptions = {
-    ...field.validation?.predefined?.multilineAddressOptions,
-    fields: {
-      ...field.validation?.predefined?.multilineAddressOptions?.fields,
-      ...finalState.multilineAddressOptionsFields
-    },
-    ...Array.isArray(override.countries) && override.countries.length > 0 ? { allowedCountries: override.countries } : {}
-  };
-  return {
-    ...field,
-    view: {
-      ...field.view,
-      fieldSettings: {
-        ...field.view?.fieldSettings,
-        ...finalState.multilineAddressFieldSettings
-      },
-      autocompleteEnabled
-    },
-    validation: {
-      ...field.validation,
-      predefined: {
-        ...field.validation?.predefined,
-        multilineAddressOptions
-      }
+  return fields.reduce((acc, field) => {
+    const source = getIdOrTarget(field, from);
+    const destination = getIdOrTarget(field, by);
+    if (source && destination && source !== destination && acc.hasOwnProperty(source)) {
+      acc[destination] = acc[source];
+      const { [source]: omitted, ...rest } = acc;
+      acc = rest;
+    }
+    return acc;
+  }, { ...submission });
+}
+
+// ../form-conditions/dist/esm/lib/apply-overrides.js
+function applyOverrides(formSchema, submission) {
+  const nestedForms = (formSchema?.nestedForms || []).flatMap(({ targets, form }) => (targets || []).map((target) => ({
+    form: applyFormOverrides2(asRequired2(form), (submission || {})[target]),
+    targets: [target]
+  })));
+  return { ...applyFormOverrides2(formSchema, submission), nestedForms };
+}
+function applyFormOverrides2(formSchema, submission) {
+  const submissionsById = mapByIds(submission, formSchema);
+  const { rules } = formSchema;
+  if (rules) {
+    return rules.filter((rule) => isFormRuleValid(rule, formSchema)).filter((rule) => evaluateOverrideConditionFactory()(rule, submissionsById)).reduce((form, rule) => applyItemPropertiesOverride(form, rule), formSchema);
+  }
+  return formSchema;
+}
+
+// ../nested-form-overrides/dist/esm/lib/array-utils.js
+function partition(items, condition) {
+  return items.reduce(([truthy, falsy], element) => {
+    if (condition(element)) {
+      truthy.push(element);
+    } else {
+      falsy.push(element);
     }
+    return [truthy, falsy];
+  }, [[], []]);
+}
+function mapBy2(items, keyFn) {
+  return items.reduce((acc, item) => {
+    acc[keyFn(item)] = item;
+    return acc;
+  }, {});
+}
+
+// ../nested-form-overrides/dist/esm/lib/lang-utils.js
+function isDefined2(value) {
+  return !(value === null || value === void 0);
+}
+
+// ../nested-form-overrides/dist/esm/lib/object-utils.js
+function isEmpty(object) {
+  return Boolean(object) && Boolean(Object.keys(object).length);
+}
+
+// ../nested-form-overrides/dist/esm/lib/nested-form-overrides.js
+function applyNestedFormOverrides(parentForm) {
+  const fieldsWithFormOverrides = parentForm.fields.filter((field) => isEmpty(field.nestedFormOverrides?.fieldOverrides));
+  const fieldsWithFormOverridesByTarget = mapBy2(fieldsWithFormOverrides, (field) => field.target);
+  const nestedForms = (parentForm.nestedForms || []).reduce((acc, { targets, form } = {}) => {
+    const [targetsWithOverride, targetsWithoutOverride] = partition(targets, (target) => Boolean(fieldsWithFormOverridesByTarget[target]));
+    const nestedFormsWithOverrides = targetsWithOverride.map((target) => ({
+      targets: [target],
+      form: applyOverrides2(form, fieldsWithFormOverridesByTarget[target].nestedFormOverrides)
+    }));
+    const nestedFormsWithoutOverrides = targetsWithoutOverride.length ? [{ targets: targetsWithoutOverride, form }] : [];
+    return [
+      ...acc,
+      ...nestedFormsWithoutOverrides,
+      ...nestedFormsWithOverrides
+    ];
+  }, []);
+  return { ...parentForm, nestedForms };
+}
+function applyOverrides2(form, overrides) {
+  const fieldOverrides = overrides.fieldOverrides;
+  return {
+    ...form,
+    fields: form.fields.map((field) => {
+      const { hidden: hiddenOverride, required: requiredOverride } = fieldOverrides[field.id] || {};
+      return {
+        ...field,
+        ...isDefined2(hiddenOverride) && { hidden: hiddenOverride },
+        ...isDefined2(requiredOverride) && isDefined2(field.validation) && {
+          validation: {
+            ...field.validation,
+            required: requiredOverride
+          }
+        }
+      };
+    })
   };
-};
+}
 
 // ../form-viewer/dist/esm/components/form/all-overrides.js
 function applyAllOverrides(form, values, overrides) {
-  return applyNestedForms(applyFormOverrides2(applyNestedFormOverrides(applyOverrides(form, values)), overrides ?? {}));
+  return applyNestedForms(applyFormOverrides(applyNestedFormOverrides(applyOverrides(form, values)), overrides ?? {}));
 }
 
 // ../form-viewer/dist/esm/components/form/clear-fields.js
@@ -20020,7 +20096,7 @@ function findHiddenTargets(form) {
   }, []);
 }
 
-// ../form-viewer/dist/esm/components/form/form-values.js
+// ../form-viewer/dist/esm/hooks/form-values.js
 var fillEmptyValues = (form, values, recursive = true) => {
   if (!form?.fields) {
     return {};
@@ -20058,7 +20134,7 @@ var getStepIndex = (stepId, steps) => {
   return 0;
 };
 
-// ../form-viewer/dist/esm/components/form/normalize-values.js
+// ../form-viewer/dist/esm/hooks/use-form-values/normalize-values.js
 init_types_impl();
 init_esm2();
 var normalizeValues = (form, values, recursive = true, config) => {
@@ -20224,7 +20300,7 @@ function acceptOnlyValidProducts({ field, fieldValue }) {
     return EMPTY_VALUE;
   }
   const validProducts = fieldValue.filter((productValue) => {
-    const hasAllProps = isObject4(productValue) && productValue.hasOwnProperty("productId") && productValue.hasOwnProperty("price") && productValue.hasOwnProperty("quantity");
+    const hasAllProps = isObject3(productValue) && productValue.hasOwnProperty("productId") && productValue.hasOwnProperty("price") && productValue.hasOwnProperty("quantity");
     if (!hasAllProps) {
       return false;
     }
@@ -20260,7 +20336,7 @@ function normalizeVatIDValue({ fieldValue }) {
   if (isEmptyValue) {
     return fieldValue;
   }
-  if (fieldValue && isObject4(fieldValue) && fieldValue.hasOwnProperty("id")) {
+  if (fieldValue && isObject3(fieldValue) && fieldValue.hasOwnProperty("id")) {
     if (fieldValue.hasOwnProperty("type")) {
       const type = getVatIDType(vatID.id);
       return { id: vatID.id, type };
@@ -20356,7 +20432,7 @@ function normalizeRepeater({ field, fieldValue, config }) {
     fields: nestedFields
   };
   const normalizedValues = fieldValue.map((values) => {
-    if (!isObject4(values)) {
+    if (!isObject3(values)) {
       return {};
     }
     const normalized = normalizeValues(nestedForm, values, false, config);
@@ -20365,7 +20441,7 @@ function normalizeRepeater({ field, fieldValue, config }) {
   return normalizedValues;
 }
 
-// ../form-viewer/dist/esm/components/form/use-form-values.js
+// ../form-viewer/dist/esm/hooks/use-form-values/use-form-values.js
 var useFormValues = (form, values, onChange, config) => {
   const normalizedValues = useMemo(() => normalizeValues(form, fillEmptyValues(form, values), true, config), [form, values, config]);
   useEffect(() => {
@@ -20376,22 +20452,6 @@ var useFormValues = (form, values, onChange, config) => {
   }, [values, normalizedValues, onChange]);
   return normalizedValues;
 };
-var useFormView2 = (form, stepId, breakpoint) => {
-  const { isMobile } = useConfig();
-  const experiments = useExperiments();
-  const useFieldsV2 = experiments.isExperimentEnabled(EXPERIMENTS.USE_FIELDS_V2);
-  return useMemo(() => {
-    return (form?.steps || []).filter((step) => !stepId || stepId === step.id).map((step) => {
-      return createFormView({
-        form,
-        stepId: step.id,
-        isMobile,
-        breakpoint,
-        useFieldsV2
-      });
-    });
-  }, [form, stepId, isMobile, breakpoint, useFieldsV2]);
-};
 var useScrollToFirstError = ({ form, handleStepChange, currentStepId }) => {
   const { setFocusedFieldId } = useFocusedField();
   const scrollToFirstError = useCallback((errors) => {
@@ -20430,10 +20490,10 @@ function submitFormClick(params) {
   return { evid: 1003, src: 156, endpoint: "", params };
 }
 
-// ../form-viewer/dist/esm/components/form/use-submit.js
+// ../form-viewer/dist/esm/hooks/use-submit/use-submit.js
 init_types_impl();
 
-// ../form-viewer/dist/esm/components/submit-status-message/utils.js
+// ../form-viewer/dist/esm/hooks/use-submit/utils.js
 init_types_impl();
 var redirectToExternalUrl = (redirectOptions) => {
   const urlWithoutProtocol = redirectOptions?.redirectUrl?.replace(/^https?:\/\//, "");
@@ -20478,28 +20538,6 @@ var getCheckoutMessage = (text) => {
     }
   };
 };
-var SubmitStatusContext = createContext(void 0);
-var SubmitStatusProvider = ({ children }) => {
-  const [submitSuccessMessage, setSubmitSuccessMessage] = useState();
-  const [submitFailureCode, setSubmitFailureCode] = useState();
-  const [submitFailureMessage, setSubmitFailureMessage] = useState();
-  const value = useMemo(() => ({
-    submitSuccessMessage,
-    submitFailureCode,
-    submitFailureMessage,
-    setSubmitSuccessMessage,
-    setSubmitFailureCode,
-    setSubmitFailureMessage
-  }), [submitSuccessMessage, submitFailureCode, submitFailureMessage]);
-  return React14.createElement(SubmitStatusContext.Provider, { value }, children);
-};
-var useSubmitStatus = () => {
-  const context = useContext(SubmitStatusContext);
-  if (context === void 0) {
-    throw new Error("useSubmitStatus must be used within a SubmitStatusProvider");
-  }
-  return context;
-};
 
 // ../form-viewer/dist/esm/features/monitoring/interactions.js
 var INTERACTIONS = {
@@ -20507,7 +20545,7 @@ var INTERACTIONS = {
   SUBMIT_FORM: "wix.forms.submit-form"
 };
 
-// ../form-viewer/dist/esm/components/form/use-submit.js
+// ../form-viewer/dist/esm/types/bi.js
 var BiFormSubmissionStatus;
 (function(BiFormSubmissionStatus2) {
   BiFormSubmissionStatus2["INIT"] = "INITIATE_SUBMISSION";
@@ -20515,6 +20553,8 @@ var BiFormSubmissionStatus;
   BiFormSubmissionStatus2["FAILURE"] = "FAILURE";
   BiFormSubmissionStatus2["SUCCESS"] = "SUCCESS";
 })(BiFormSubmissionStatus || (BiFormSubmissionStatus = {}));
+
+// ../form-viewer/dist/esm/hooks/use-submit/use-submit.js
 var useSubmit = ({ validateAndScrollToError, submitAction, onSubmit, onSubmitSuccess, onSubmitFailure, resetFormValues, values, submitSettings, handleStepChange, navigateToCheckout, onValidate, handleScrollToFirstError }) => {
   const { setSubmitSuccessMessage, setSubmitFailureCode, setSubmitFailureMessage } = useSubmitStatus();
   const { t } = useTranslation();
@@ -20602,72 +20642,194 @@ var useSubmit = ({ validateAndScrollToError, submitAction, onSubmit, onSubmitSuc
       handleSubmitSuccess(response);
       resetFormValues?.();
     }
-    return response;
-  }, [
-    validateAndScrollToError,
-    values,
-    onSubmit,
-    reportSubmitFormBi,
-    panorama,
+    return response;
+  }, [
+    validateAndScrollToError,
+    values,
+    onSubmit,
+    reportSubmitFormBi,
+    panorama,
+    submitAction,
+    onSubmitFailure,
+    handleCustomErrorMessages,
+    handleSubmitFailure,
+    onSubmitSuccess,
+    fireSubmitSuccess,
+    handleSubmitSuccess,
+    resetFormValues
+  ]);
+  return { submitForm };
+};
+var useFormView2 = (form, stepId, breakpoint) => {
+  const { isMobile } = useConfig();
+  const experiments = useExperiments();
+  const useFieldsV2 = experiments.isExperimentEnabled(EXPERIMENTS.USE_FIELDS_V2);
+  return useMemo(() => {
+    return (form?.steps || []).filter((step) => !stepId || stepId === step.id).map((step) => {
+      return createFormView({
+        form,
+        stepId: step.id,
+        isMobile,
+        breakpoint,
+        useFieldsV2
+      });
+    });
+  }, [form, stepId, isMobile, breakpoint, useFieldsV2]);
+};
+var useReportFieldEdit = (form) => {
+  const lastChangedFields = useRef([]);
+  const bi = useBi();
+  return (changedValues) => {
+    const changedFieldTargets = Object.keys(changedValues);
+    const isEditingDifferentFields = changedFieldTargets.length !== lastChangedFields.current.length || changedFieldTargets.some((target, index) => target !== lastChangedFields.current[index]);
+    if (isEditingDifferentFields) {
+      lastChangedFields.current = changedFieldTargets;
+      changedFieldTargets.forEach((target) => {
+        const changedField = form?.fields?.find((field) => field.target === target);
+        bi.report(formFieldEdit({
+          field_id: changedField?.id,
+          field_label: changedField?.view?.label,
+          field_target: changedField?.target || void 0
+        }));
+      });
+    }
+  };
+};
+
+// ../form-viewer/dist/esm/hooks/use-form.js
+var useForm2 = ({ form: paramForm, values: paramValues, stepId, onStepIdChange, onChange, errors, onValidate, onSubmit, onSubmitSuccess, onSubmitFailure, enableScrollToFirstError = true, forwardedRef, overrides, actions, config, breakpoint, validationMode, fieldMap, inProgress }) => {
+  const formWithOverrides = useMemo(() => applyAllOverrides(paramForm, paramValues, overrides), [paramForm, paramValues, overrides]);
+  const formId = formWithOverrides.id;
+  const { setFocusedFieldId } = useFocusedField();
+  const normalizedValues = useFormValues(formWithOverrides, paramValues, onChange, config);
+  const valuesRef = useRef(normalizedValues);
+  valuesRef.current = normalizedValues;
+  const errorsRef = useRef(errors);
+  errorsRef.current = errors;
+  const reportFieldEdit = useReportFieldEdit(formWithOverrides);
+  const onFieldChange = (target, newValue) => {
+    const oldValues = valuesRef.current;
+    const oldErrors = errorsRef.current;
+    if (!deepEqual(newValue, oldValues[target])) {
+      reportFieldEdit({
+        [target]: newValue
+      });
+      const newValues = {
+        ...oldValues,
+        [target]: newValue
+      };
+      const cleared = clearFieldsWhenHiddenByRule(paramForm, overrides, oldValues, newValues, oldErrors);
+      onChange(cleared.values);
+      onValidate(cleared.errors);
+    }
+  };
+  const _onValidate = (newErrors) => {
+    onValidate(newErrors);
+  };
+  const formViews = useFormView2(formWithOverrides, stepId, breakpoint);
+  const currentView = formViews[0];
+  const { validateFields: validateFields2, validateStep, handleFieldValidation } = useValidation({
+    form: formWithOverrides,
+    errorsRef,
+    setErrors: _onValidate,
+    validationMode
+  });
+  const handleStepChange = useCallback((step) => {
+    const newStepId = formWithOverrides.steps?.[step]?.id;
+    if (newStepId) {
+      const firstFieldInStep = getSortedFields(formWithOverrides, {
+        stepId: newStepId
+      })[0];
+      onStepIdChange?.(newStepId);
+      setFocusedFieldId(firstFieldInStep?.id);
+    }
+  }, [formWithOverrides, onStepIdChange, setFocusedFieldId]);
+  const { scrollToFirstError, handleScrollToFirstError } = useScrollToFirstError({
+    form: formWithOverrides,
+    handleStepChange,
+    currentStepId: stepId
+  });
+  const resetFormValues = useCallback(() => {
+    onChange(fillEmptyValues(formWithOverrides, {}));
+  }, [formWithOverrides, onChange]);
+  const validateAndScrollToError = useCallback(async (values) => {
+    const validationErrors = await validateFields2(values);
+    if (validationErrors && validationErrors.length) {
+      handleScrollToFirstError(validationErrors);
+    }
+    return validationErrors;
+  }, [validateFields2, handleScrollToFirstError]);
+  const submitAction = useCallback(async (values) => {
+    const response = await actions?.submitForm?.(formId, values);
+    return response?.submission;
+  }, [actions, formId]);
+  const { submitForm } = useSubmit({
     submitAction,
-    onSubmitFailure,
-    handleCustomErrorMessages,
-    handleSubmitFailure,
+    onSubmit,
     onSubmitSuccess,
-    fireSubmitSuccess,
-    handleSubmitSuccess,
-    resetFormValues
-  ]);
-  return { submitForm };
-};
-var useValidation = ({ form, errorsRef, setErrors, validationMode }) => {
-  const { addressTemplates } = useAddressForms();
-  const externalData = useExternalData();
-  const validateFields2 = useCallback(async (newValues) => {
-    const result2 = await validate(form, newValues, addressTemplates, validationMode);
-    const _errors = result2?.errors || [];
-    const additionalErrors = runAdditionalValidation({
-      form,
-      values: newValues,
-      externalData
-    });
-    const allErrors = mergeErrors({ errors: _errors, additionalErrors });
-    setErrors(allErrors);
-    return allErrors;
-  }, [form, setErrors, addressTemplates, externalData, validationMode]);
-  const handleFieldValidation = useCallback(async (fieldsToValidate) => {
-    const fieldErrors = await getFieldErrors(fieldsToValidate, form, addressTemplates, externalData, validationMode);
-    const otherErrors = (errorsRef.current ?? []).filter((error) => {
-      return !findErrorByNormalizedPath(fieldsToValidate, error.errorPath);
-    });
-    const allErrors = [...otherErrors, ...fieldErrors];
-    setErrors(allErrors);
-    return allErrors;
-  }, [
-    errorsRef,
-    form,
-    setErrors,
-    addressTemplates,
-    externalData,
-    validationMode
-  ]);
-  const validateStep = useCallback(async (stepId, newValues) => {
-    const items = form?.steps?.find((step) => step.id === stepId)?.layout?.large?.items || [];
-    const validationErrors = await Promise.all(items.map(async (item) => {
-      const field = form?.fields?.find((_field) => _field.id === item.fieldId);
-      const fieldValidationResult = field?.target ? await handleFieldValidation([
-        {
-          path: field.target,
-          value: newValues[field.target]
+    onSubmitFailure,
+    resetFormValues,
+    validateAndScrollToError,
+    values: normalizedValues,
+    submitSettings: formWithOverrides.submitSettings,
+    navigateToCheckout: actions?.navigateToCheckout,
+    handleStepChange,
+    onValidate: _onValidate,
+    handleScrollToFirstError
+  });
+  useImperativeHandle(forwardedRef, () => ({
+    submit: submitForm,
+    validate: async () => {
+      const validationErrors = await validateFields2(normalizedValues);
+      if (validationErrors && validationErrors.length > 0) {
+        if (enableScrollToFirstError) {
+          scrollToFirstError(validationErrors);
         }
-      ]) : [];
-      return fieldValidationResult;
-    }));
-    const validationErrorsFlatten = validationErrors.flat();
-    setErrors(validationErrorsFlatten);
-    return !validationErrorsFlatten.length;
-  }, [form, setErrors, handleFieldValidation]);
-  return { validateFields: validateFields2, validateStep, handleFieldValidation };
+        return false;
+      }
+      return true;
+    },
+    validateStep: (step) => validateStep(step, normalizedValues)
+  }), [
+    submitForm,
+    validateStep,
+    validateFields2,
+    normalizedValues,
+    enableScrollToFirstError,
+    scrollToFirstError
+  ]);
+  const currentStep = getStepIndex(stepId, formWithOverrides.steps);
+  const setNextStep = useCallback(() => handleStepChange(currentStep + 1), [currentStep, handleStepChange]);
+  const setPreviousStep = useCallback(() => handleStepChange(currentStep - 1), [currentStep, handleStepChange]);
+  const fieldActions = useMemo(() => actions ? {
+    actions: { ...actions, submitForm, setNextStep, setPreviousStep },
+    formId,
+    inProgress
+  } : { actions: { submitForm, setNextStep, setPreviousStep } }, [actions, formId, inProgress, submitForm, setNextStep, setPreviousStep]);
+  const formFields = createFormFields({
+    form: currentView,
+    formSchema: formWithOverrides,
+    values: normalizedValues,
+    onFieldChange,
+    errors,
+    FieldLayout: DefaultFieldLayout,
+    fields: fieldMap,
+    validateFields: handleFieldValidation,
+    fieldActions
+  });
+  return {
+    currentView,
+    formViews,
+    normalizedValues,
+    onFieldChange,
+    errors,
+    formFields,
+    handleFieldValidation,
+    formWithOverrides,
+    currentStep,
+    fieldActions,
+    submitForm
+  };
 };
 var dummyBi = {
   log: () => Promise.resolve(),
@@ -20805,127 +20967,6 @@ var FormViewerProvider = ({ i18n, bi, biFormFillSessionId, form, isMobile, isEdi
     )
   );
 };
-var useForm2 = ({ form: paramForm, values: paramValues, stepId, onStepIdChange, onChange, errors, onValidate, enableScrollToFirstError = true, forwardedRef, overrides, actions, config, breakpoint, validationMode, fieldMap }) => {
-  const formWithOverrides = useMemo(() => applyAllOverrides(paramForm, paramValues, overrides), [paramForm, paramValues, overrides]);
-  const formId = formWithOverrides.id;
-  const { setFocusedFieldId } = useFocusedField();
-  const normalizedValues = useFormValues(formWithOverrides, paramValues, onChange, config);
-  const valuesRef = useRef(normalizedValues);
-  valuesRef.current = normalizedValues;
-  const errorsRef = useRef(errors);
-  errorsRef.current = errors;
-  const onFieldChange = (target, newValue) => {
-    const oldValues = valuesRef.current;
-    const oldErrors = errorsRef.current;
-    if (!deepEqual(newValue, oldValues[target])) {
-      const newValues = {
-        ...oldValues,
-        [target]: newValue
-      };
-      const cleared = clearFieldsWhenHiddenByRule(paramForm, overrides, oldValues, newValues, oldErrors);
-      onChange(cleared.values);
-      onValidate(cleared.errors);
-    }
-  };
-  const _onValidate = (newErrors) => {
-    onValidate(newErrors);
-  };
-  const formViews = useFormView2(formWithOverrides, stepId, breakpoint);
-  const currentView = formViews[0];
-  const { validateFields: validateFields2, validateStep, handleFieldValidation } = useValidation({
-    form: formWithOverrides,
-    errorsRef,
-    setErrors: _onValidate,
-    validationMode
-  });
-  const handleStepChange = useCallback((step) => {
-    const newStepId = formWithOverrides.steps?.[step]?.id;
-    if (newStepId) {
-      const firstFieldInStep = getSortedFields(formWithOverrides, {
-        stepId: newStepId
-      })[0];
-      onStepIdChange?.(newStepId);
-      setFocusedFieldId(firstFieldInStep?.id);
-    }
-  }, [formWithOverrides, onStepIdChange, setFocusedFieldId]);
-  const { scrollToFirstError, handleScrollToFirstError } = useScrollToFirstError({
-    form: formWithOverrides,
-    handleStepChange,
-    currentStepId: stepId
-  });
-  const resetFormValues = useCallback(() => {
-    onChange(fillEmptyValues(formWithOverrides, {}));
-  }, [formWithOverrides, onChange]);
-  const validateAndScrollToError = useCallback(async (values) => {
-    const validationErrors = await validateFields2(values);
-    if (validationErrors && validationErrors.length) {
-      handleScrollToFirstError(validationErrors);
-    }
-    return validationErrors;
-  }, [validateFields2, handleScrollToFirstError]);
-  const submitAction = useCallback(async (values) => {
-    const response = await actions?.submitForm?.(formId, values);
-    return response?.submission;
-  }, [actions, formId]);
-  const { submitForm } = useSubmit({
-    submitAction,
-    resetFormValues,
-    validateAndScrollToError,
-    values: normalizedValues,
-    submitSettings: formWithOverrides.submitSettings,
-    navigateToCheckout: actions?.navigateToCheckout,
-    handleStepChange,
-    onValidate: _onValidate,
-    handleScrollToFirstError
-  });
-  useImperativeHandle(forwardedRef, () => ({
-    submit: submitForm,
-    validate: async () => {
-      const validationErrors = await validateFields2(normalizedValues);
-      if (validationErrors && validationErrors.length > 0) {
-        if (enableScrollToFirstError) {
-          scrollToFirstError(validationErrors);
-        }
-        return false;
-      }
-      return true;
-    },
-    validateStep: (step) => validateStep(step, normalizedValues)
-  }), [
-    submitForm,
-    validateStep,
-    validateFields2,
-    normalizedValues,
-    enableScrollToFirstError,
-    scrollToFirstError
-  ]);
-  const currentStep = getStepIndex(stepId, formWithOverrides.steps);
-  const setNextStep = useCallback(() => handleStepChange(currentStep + 1), [currentStep, handleStepChange]);
-  const setPreviousStep = useCallback(() => handleStepChange(currentStep - 1), [currentStep, handleStepChange]);
-  const fieldActions = useMemo(() => actions ? {
-    actions: { ...actions, submitForm, setNextStep, setPreviousStep },
-    formId,
-    inProgress: false
-  } : { actions: { submitForm, setNextStep, setPreviousStep } }, [actions, formId, submitForm, setNextStep, setPreviousStep]);
-  const formFields = createFormFields({
-    form: currentView,
-    formSchema: formWithOverrides,
-    values: normalizedValues,
-    onFieldChange,
-    errors,
-    FieldLayout: DefaultFieldLayout,
-    fields: fieldMap,
-    validateFields: handleFieldValidation,
-    fieldActions
-  });
-  return {
-    currentView,
-    normalizedValues,
-    onFieldChange,
-    errors,
-    formFields
-  };
-};
 function normalizeSchema(obj) {
   if (Array.isArray(obj)) {
     return obj.map(normalizeSchema);