@adyen/kyc-components 4.0.0-compact.3 → 4.0.0-compact.7

package/dist/useMultiForm--sSlt50X.js

@@ -1,864 +0,0 @@
-;
-{
-  try {
-    let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "5fedbb35-4b08-4314-8e3a-974f796cf92a", e._sentryDebugIdIdentifier = "sentry-dbid-5fedbb35-4b08-4314-8e3a-974f796cf92a");
-  } catch (e) {
-  }
-}
-;
-import { useCallback, useMemo, useReducer, useEffect } from "preact/hooks";
-import { aj as objectsDeepEqual, P as createLogger, W as isEmpty } from "./StoreProvider-jtUYKLRz.js";
-import { V as ValidationResult } from "./useForm-DLxHtZTP.js";
-import { e as isNotEmptyValidator } from "./CountryField-CzRN1OE8.js";
-const omitKeys = (obj, omit) => Object.keys(obj).filter((k) => !omit.includes(k)).reduce((a, c) => {
-  a[c] = obj[c];
-  return a;
-}, {});
-const addKeys = (obj, add, initialValue, defaultData, pendingData) => add.reduce(
-  (a, c) => ({
-    ...a,
-    [c]: a[c] ?? pendingData?.[c] ?? defaultData?.[c] ?? initialValue
-  }),
-  obj
-);
-const hasValueChanged = (newData, prevData) => {
-  if (typeof newData === "object") {
-    return !objectsDeepEqual(newData, prevData);
-  }
-  return newData !== prevData;
-};
-const processField = ({
-  key,
-  value,
-  formName,
-  mode,
-  defaultData,
-  data,
-  fieldContext,
-  formatters,
-  staticValidate
-}) => {
-  const formatterFn = formatters?.[key]?.formatter ? formatters[key]?.formatter : formatters?.[key];
-  const formattedValue = formatterFn && typeof formatterFn === "function" ? formatterFn(value, fieldContext) : value;
-  const fieldHasDefaultValue = !!defaultData?.[key];
-  const fieldHasChanged = defaultData?.[key] !== value;
-  const idObscuredField = fieldContext.state?.obscuredFields?.includes(key);
-  const shouldValidateField = idObscuredField ? fieldHasChanged : fieldHasChanged || fieldHasDefaultValue;
-  const validationResult = shouldValidateField ? staticValidate({ key, value: formattedValue, mode, formName }, data, fieldContext) : new ValidationResult([
-    {
-      isValid: true,
-      hasError: false
-    }
-  ]);
-  const asyncValidationResult = fieldContext.state?.asyncErrors?.[key];
-  if (asyncValidationResult) {
-    validationResult.addError(asyncValidationResult);
-  }
-  return [formattedValue, validationResult];
-};
-function init({
-  requiredFields,
-  staticValidate,
-  defaultData,
-  obscuredFields,
-  optionalFields,
-  trustedFields,
-  fieldProblems,
-  formatters,
-  data,
-  asyncErrors
-}) {
-  const getProcessedState = (fieldKey, formName) => {
-    const [formattedValue, validationResult] = processField({
-      key: fieldKey,
-      value: data?.[formName]?.[fieldKey] ?? defaultData?.[formName]?.[fieldKey] ?? null,
-      // When requiredField changes prefill any defaultData if no data is input
-      mode: "blur",
-      formName,
-      formatters: formatters?.[formName],
-      defaultData: defaultData?.[formName],
-      data,
-      fieldContext: {
-        state: {
-          data: data?.[formName],
-          obscuredFields: obscuredFields?.[formName],
-          optionalFields: optionalFields?.[formName],
-          trustedFields: trustedFields?.[formName],
-          requiredFields: requiredFields?.[formName],
-          asyncErrors: asyncErrors?.[formName]
-        }
-      },
-      staticValidate
-    });
-    return {
-      valid: validationResult.isValid && !fieldProblems?.[formName]?.[fieldKey] || false,
-      errors: null,
-      data: formattedValue,
-      fieldProblems: fieldProblems?.[formName]?.[fieldKey]
-    };
-  };
-  if (!requiredFields) {
-    return {
-      data: defaultData,
-      errors: {},
-      fieldProblems: {},
-      valid: {},
-      requiredFields: {},
-      asyncErrors: {},
-      defaultData
-    };
-  }
-  const formsForOptionalFields = Object.keys(optionalFields ?? {});
-  const formsForRequiredFields = Object.keys(requiredFields);
-  const availableForms = Array.from(
-    /* @__PURE__ */ new Set([...formsForOptionalFields, ...formsForRequiredFields])
-  );
-  return availableForms.reduce(
-    (acc, formName) => {
-      const form = formName;
-      const optionalsFormFields = optionalFields?.[form] ?? [];
-      const requiredFormFields = requiredFields?.[form] ?? [];
-      const formFields = [...optionalsFormFields, ...requiredFormFields];
-      const formState = formFields?.reduce(
-        (acc2, field) => {
-          const {
-            valid,
-            errors,
-            data: data2,
-            fieldProblems: processedFieldProblems
-          } = getProcessedState(field, form);
-          return {
-            ...acc2,
-            data: { ...acc2.data, [field]: data2 },
-            valid: { ...acc2.valid, [field]: valid },
-            errors: { ...acc2.errors, [field]: errors },
-            fieldProblems: {
-              ...acc2.fieldProblems,
-              ...processedFieldProblems ? { [field]: processedFieldProblems } : {}
-            }
-          };
-        },
-        {}
-      );
-      return {
-        requiredFields,
-        data: {
-          ...acc.data,
-          [formName]: formState.data
-        },
-        valid: {
-          ...acc.valid,
-          [formName]: formState.valid
-        },
-        errors: {
-          ...acc.errors,
-          [formName]: formState.errors
-        },
-        fieldProblems: {
-          ...acc.fieldProblems,
-          [formName]: formState.fieldProblems
-        },
-        asyncErrors: {
-          ...acc.asyncErrors
-        },
-        obscuredFields,
-        optionalFields,
-        trustedFields,
-        defaultData
-      };
-    },
-    {
-      requiredFields,
-      data: {},
-      valid: {},
-      errors: {},
-      fieldProblems: {},
-      obscuredFields,
-      optionalFields,
-      trustedFields,
-      asyncErrors: {}
-    }
-  );
-}
-function reducer({
-  staticValidate,
-  obscuredFields,
-  optionalFields,
-  trustedFields,
-  formatters,
-  defaultData
-}) {
-  return (state, {
-    type,
-    key,
-    mode,
-    value,
-    formData,
-    formName,
-    selectedSchema,
-    innerFormFields,
-    requiredFields,
-    optionalFields: newOptionalFields,
-    asyncValidationResults
-  }) => {
-    const clonedState = structuredClone(state);
-    switch (type) {
-      case "setData": {
-        if (!key || !formName) return state;
-        return {
-          ...clonedState,
-          data: {
-            ...clonedState.data,
-            [formName]: {
-              ...clonedState.data?.[formName],
-              [key]: value
-            }
-          }
-        };
-      }
-      case "setFormData": {
-        if (!formName || !formData) return state;
-        const formRequiredFields = clonedState.requiredFields?.[formName] ?? [];
-        const formOptionalFields = clonedState.optionalFields?.[formName] ?? [];
-        const allowedFields = [...formRequiredFields, ...formOptionalFields];
-        const filteredUpdates = Object.keys(formData).filter((key2) => allowedFields.includes(key2)).reduce((obj, key2) => {
-          obj[key2] = formData[key2];
-          return obj;
-        }, {});
-        const updatedData = {
-          // provide the updated data before running validations
-          ...clonedState.data,
-          [formName]: filteredUpdates
-        };
-        const formValidity = allowedFields.reduce(
-          (acc, field) => {
-            const [, validation] = processField({
-              key: field,
-              value: filteredUpdates[field],
-              mode: "blur",
-              formName,
-              defaultData: defaultData?.[formName],
-              data: updatedData,
-              formatters: formatters?.[formName],
-              fieldContext: {
-                state: {
-                  data: clonedState?.data?.[formName],
-                  obscuredFields: obscuredFields?.[formName],
-                  optionalFields: optionalFields?.[formName],
-                  trustedFields: trustedFields?.[formName],
-                  errors: clonedState.errors?.[formName],
-                  valid: clonedState.valid?.[formName],
-                  fieldProblems: clonedState.fieldProblems?.[formName],
-                  asyncErrors: clonedState.asyncErrors?.[formName]
-                }
-              },
-              staticValidate
-            });
-            return {
-              ...acc,
-              [field]: validation.isValid
-            };
-          },
-          {}
-        );
-        return {
-          ...clonedState,
-          data: {
-            ...clonedState.data,
-            [formName]: {
-              // ...with the new, filtered updates.
-              ...filteredUpdates
-            }
-          },
-          valid: {
-            ...clonedState.valid,
-            [formName]: formValidity
-          }
-        };
-      }
-      case "setValid": {
-        if (!key || !formName) return state;
-        return clonedState?.valid?.[formName]?.[key] === value ? state : {
-          ...clonedState,
-          valid: {
-            ...clonedState.valid,
-            [formName]: {
-              ...clonedState.valid?.[formName],
-              [key]: value
-            }
-          }
-        };
-      }
-      case "setErrors": {
-        if (!key || !formName) return state;
-        return {
-          ...clonedState,
-          errors: {
-            ...clonedState.errors,
-            [formName]: {
-              ...clonedState.errors?.[formName],
-              [key]: value
-            }
-          }
-        };
-      }
-      case "setRequiredFields": {
-        const hasDefaultDataChanged = !objectsDeepEqual(defaultData, state.defaultData);
-        if (objectsDeepEqual(requiredFields, clonedState.requiredFields) && objectsDeepEqual(newOptionalFields, clonedState.optionalFields) && !hasDefaultDataChanged) {
-          return state;
-        }
-        const updatedData = hasDefaultDataChanged ? defaultData : clonedState.data;
-        const newState = init({
-          requiredFields,
-          data: updatedData,
-          fieldProblems: clonedState.fieldProblems,
-          obscuredFields,
-          optionalFields: newOptionalFields,
-          trustedFields,
-          staticValidate,
-          defaultData
-        });
-        return newState;
-      }
-      case "setInnerFormRequiredFields": {
-        if (!innerFormFields || !formName) return state;
-        const requiredFields2 = {
-          ...clonedState.requiredFields,
-          [formName]: innerFormFields
-        };
-        const defaultState = init({
-          requiredFields: requiredFields2,
-          defaultData,
-          fieldProblems: clonedState.fieldProblems,
-          obscuredFields,
-          optionalFields,
-          trustedFields,
-          staticValidate,
-          data: defaultData
-        });
-        const removedFields = clonedState.optionalFields?.[formName].length ? [
-          ...(clonedState.requiredFields?.[formName] ?? []).filter(
-            (field) => !innerFormFields.includes(field)
-          ),
-          ...clonedState.optionalFields[formName].filter(
-            (field) => !optionalFields?.[formName]?.includes(field)
-          )
-        ] : clonedState.requiredFields?.[formName]?.filter(
-          (field) => !innerFormFields.includes(field)
-        );
-        const newFields = optionalFields?.[formName].length ? [
-          ...innerFormFields.filter(
-            (field) => !clonedState.requiredFields?.[formName].includes(field)
-          ),
-          ...(optionalFields[formName] ?? []).filter(
-            (field) => !clonedState.optionalFields?.[formName].includes(field)
-          )
-        ] : innerFormFields.filter(
-          (field) => !clonedState.requiredFields?.[formName].includes(field)
-        );
-        const formLocal = {
-          data: omitKeys(clonedState.data?.[formName], newFields),
-          errors: omitKeys(clonedState.errors?.[formName], newFields),
-          valid: omitKeys(clonedState.valid?.[formName], newFields),
-          fieldProblems: omitKeys(clonedState.fieldProblems?.[formName], newFields)
-        };
-        const local = {
-          ...clonedState.local,
-          [formName]: formLocal
-        };
-        const updatedFormData = addKeys(
-          omitKeys(clonedState.data?.[formName], removedFields),
-          newFields,
-          null,
-          defaultState.data?.[formName],
-          clonedState.local?.[formName].data
-        );
-        const updatedData = {
-          ...clonedState.data,
-          [formName]: updatedFormData
-        };
-        const updatedFormValidity = addKeys(
-          omitKeys(clonedState.valid?.[formName], removedFields),
-          newFields,
-          false,
-          defaultState.valid?.[formName],
-          clonedState.local?.[formName].valid
-        );
-        const updatedValidity = {
-          ...clonedState.valid,
-          [formName]: updatedFormValidity
-        };
-        const updatedFormErrors = addKeys(
-          omitKeys(clonedState.errors?.[formName], removedFields),
-          newFields,
-          null,
-          defaultState.errors?.[formName],
-          clonedState.local?.[formName].errors
-        );
-        const updatedErrors = {
-          ...clonedState.errors,
-          [formName]: updatedFormErrors
-        };
-        const updatedFormFieldProblems = addKeys(
-          omitKeys(clonedState.fieldProblems?.[formName], removedFields),
-          newFields,
-          false,
-          defaultState.fieldProblems?.[formName],
-          clonedState.local?.[formName].fieldProblems
-        );
-        const updatedFieldProblems = {
-          ...clonedState.fieldProblems,
-          [formName]: updatedFormFieldProblems
-        };
-        return {
-          requiredFields: requiredFields2,
-          data: updatedData,
-          valid: updatedValidity,
-          errors: updatedErrors,
-          fieldProblems: updatedFieldProblems,
-          asyncErrors: clonedState.asyncErrors,
-          optionalFields,
-          trustedFields,
-          local,
-          defaultData
-        };
-      }
-      case "updateField": {
-        if (!key || !mode || !formName) return state;
-        const updatedData = {
-          // provide the updated data before running validations
-          ...clonedState.data,
-          [formName]: {
-            ...clonedState.data?.[formName],
-            [key]: value
-          }
-        };
-        const updatedAsyncErrors = hasValueChanged(value, clonedState.data?.[formName]?.[key]) ? {
-          ...clonedState.asyncErrors,
-          [formName]: {
-            ...clonedState.asyncErrors?.[formName],
-            [key]: null
-          }
-        } : clonedState.asyncErrors;
-        const [formattedValue, validation] = processField({
-          key,
-          value,
-          mode,
-          formName,
-          defaultData: defaultData?.[formName],
-          data: updatedData,
-          formatters: formatters?.[formName],
-          fieldContext: {
-            state: {
-              data: clonedState?.data?.[formName],
-              obscuredFields: obscuredFields?.[formName],
-              optionalFields: optionalFields?.[formName],
-              trustedFields: trustedFields?.[formName],
-              errors: clonedState.errors?.[formName],
-              valid: clonedState.valid?.[formName],
-              fieldProblems: clonedState.fieldProblems?.[formName],
-              asyncErrors: updatedAsyncErrors?.[formName]
-            }
-          },
-          staticValidate
-        });
-        const oldValue = clonedState?.data?.[formName];
-        const clearFieldProblems = oldValue?.[key] !== formattedValue;
-        const result = {
-          ...clonedState,
-          data: {
-            ...clonedState.data,
-            [formName]: {
-              ...clonedState?.data?.[formName],
-              [key]: formattedValue
-            }
-          },
-          asyncErrors: updatedAsyncErrors,
-          errors: {
-            ...clonedState.errors,
-            [formName]: {
-              ...clonedState?.errors?.[formName],
-              [key]: validation.getError() ?? null
-            }
-          },
-          valid: {
-            ...clonedState.valid,
-            [formName]: {
-              ...clonedState?.valid?.[formName],
-              [key]: (validation.isValid && !clonedState.fieldProblems?.[formName]?.[key]) ?? false
-            }
-          },
-          fieldProblems: {
-            ...clonedState.fieldProblems,
-            [formName]: {
-              ...clonedState?.fieldProblems?.[formName],
-              ...!clearFieldProblems && clonedState.fieldProblems?.[formName]?.[key] ? { [key]: true } : {}
-            }
-          }
-        };
-        return result;
-      }
-      case "validateForm": {
-        if (!formName) {
-          return state;
-        }
-        const formFields = clonedState.requiredFields?.[formName];
-        if (!formFields) {
-          return state;
-        }
-        const formState = (selectedSchema || formFields).reduce(
-          (acc, field) => {
-            const formData2 = clonedState.data?.[formName];
-            const [formattedValue, validation] = processField({
-              key: field,
-              mode: "blur",
-              value: formData2?.[field] ?? null,
-              formName,
-              defaultData: defaultData?.[formName],
-              data: clonedState?.data,
-              formatters: formatters?.[formName],
-              fieldContext: {
-                state: {
-                  data: clonedState?.data?.[formName],
-                  obscuredFields: obscuredFields?.[formName],
-                  optionalFields: optionalFields?.[formName],
-                  trustedFields: trustedFields?.[formName],
-                  errors: clonedState.errors?.[formName],
-                  valid: clonedState.valid?.[formName],
-                  fieldProblems: clonedState.fieldProblems?.[formName],
-                  asyncErrors: clonedState.asyncErrors?.[formName]
-                }
-              },
-              staticValidate
-            });
-            const oldValue = clonedState?.data?.[formName];
-            const clearFieldProblems = oldValue?.[field] !== formattedValue;
-            const fieldAsyncValidationResult = asyncValidationResults?.[field];
-            return {
-              data: formData2,
-              asyncErrors: {
-                ...acc.asyncErrors,
-                [field]: fieldAsyncValidationResult?.getError() ?? null
-              },
-              errors: {
-                ...acc.errors,
-                [field]: validation.getError() ?? fieldAsyncValidationResult?.getError() ?? null
-              },
-              valid: {
-                ...acc.valid,
-                [field]: (validation.isValid && (fieldAsyncValidationResult?.isValid ?? true) && !clonedState.fieldProblems?.[formName]?.[field]) ?? false
-              },
-              fieldProblems: {
-                ...acc.fieldProblems,
-                ...!clearFieldProblems && acc.fieldProblems?.[field] ? { [field]: true } : {}
-              }
-            };
-          },
-          {}
-        );
-        return {
-          ...clonedState,
-          errors: {
-            ...clonedState.errors,
-            [formName]: formState.errors
-          },
-          asyncErrors: {
-            ...clonedState.asyncErrors,
-            [formName]: formState.asyncErrors
-          },
-          valid: {
-            ...clonedState.valid,
-            [formName]: formState.valid
-          },
-          fieldProblems: {
-            ...clonedState.fieldProblems,
-            [formName]: formState.fieldProblems
-          }
-        };
-      }
-      default:
-        throw new Error("Undefined useForm action");
-    }
-  };
-}
-const logger = createLogger();
-const useMultiFormAsyncValidator = (asyncRules) => {
-  const validResult = {
-    isValid: true,
-    hasError: false
-  };
-  const triggerAsyncValidation = useCallback(
-    async (field, formName, data) => {
-      if (!asyncRules) return new ValidationResult([validResult]);
-      const rule = typeof asyncRules === "function" ? asyncRules?.(data)?.[formName]?.[field] : asyncRules?.[formName]?.[field];
-      const value = data?.[formName]?.[field];
-      if (!rule || !value) return new ValidationResult([validResult]);
-      const isValid = await rule.asyncValidate(value).catch(logger.error);
-      if (isValid === false) {
-        return new ValidationResult([
-          {
-            isValid: isValid ?? true,
-            errorMessage: typeof rule.errorMessage === "function" ? rule.errorMessage(value) : rule.errorMessage,
-            hasError: !isValid
-          }
-        ]);
-      }
-      return new ValidationResult([validResult]);
-    },
-    [asyncRules]
-  );
-  const triggerAsyncFormValidation = async (formName, state, selectedSchema) => {
-    const asyncValidationResults = await (selectedSchema ?? state.requiredFields?.[formName])?.reduce(async (accPromise, fieldName) => {
-      const acc = await accPromise;
-      const asyncValidationResult = await triggerAsyncValidation(
-        fieldName,
-        formName,
-        state.data
-      );
-      return {
-        ...acc,
-        [fieldName]: asyncValidationResult
-      };
-    }, Promise.resolve({}));
-    const isValid = Object.values(asyncValidationResults ?? {}).every(
-      (validationResult) => validationResult.isValid
-    );
-    return {
-      ...asyncValidationResults,
-      isValid
-    };
-  };
-  return {
-    triggerAsyncFormValidation
-  };
-};
-const useMultiFormStaticValidator = (rules) => {
-  const getRulesForField = useCallback(
-    (field, form, data) => {
-      const fallbackRule = {
-        validate: () => true,
-        modes: ["blur", "input"]
-      };
-      if (!form) {
-        return [fallbackRule];
-      }
-      const fieldRules = typeof rules === "function" ? rules(data)?.[form]?.[field] ?? [fallbackRule] : rules?.[form]?.[field] ?? [fallbackRule];
-      return Array.isArray(fieldRules) ? fieldRules : [fieldRules];
-    },
-    [rules]
-  );
-  const triggerStaticValidation = useCallback(
-    ({ key, value, mode = "blur", formName }, data, context) => {
-      const fieldRules = getRulesForField(key, formName, data);
-      const isFieldOptional = !!context?.state.optionalFields?.includes(key);
-      const isFieldObscured = !!context?.state.obscuredFields?.includes(key);
-      if (!isFieldOptional) {
-        fieldRules?.unshift(isNotEmptyValidator);
-      }
-      const validationRulesResult = fieldRules.map((rule) => {
-        const shouldValidate = rule.modes.includes(mode) && !isFieldObscured;
-        const isValid = isFieldOptional && isEmpty(value) ? true : rule.validate(value, context);
-        return {
-          isValid,
-          errorMessage: typeof rule.errorMessage === "function" ? rule.errorMessage(value, context) : rule.errorMessage,
-          hasError: shouldValidate && !isValid
-        };
-      });
-      return new ValidationResult(validationRulesResult);
-    },
-    [getRulesForField]
-  );
-  return {
-    triggerStaticValidation
-  };
-};
-function useMultiForm({
-  defaultData,
-  rules,
-  asyncRules,
-  fieldProblems,
-  allFields,
-  requiredFields,
-  obscuredFields,
-  optionalFields,
-  trustedFields,
-  formatters
-}) {
-  const { triggerStaticValidation } = useMultiFormStaticValidator(rules);
-  const { triggerAsyncFormValidation } = useMultiFormAsyncValidator(asyncRules);
-  const getRequiredFields = useMemo(
-    () => typeof requiredFields === "function" ? requiredFields : () => requiredFields,
-    [requiredFields]
-  );
-  const getSchema = useMemo(() => getRequiredFields(defaultData), [defaultData, getRequiredFields]);
-  const getReducer = useCallback(
-    () => reducer({
-      staticValidate: triggerStaticValidation,
-      defaultData,
-      obscuredFields,
-      optionalFields,
-      trustedFields,
-      formatters
-    }),
-    [
-      triggerStaticValidation,
-      obscuredFields,
-      optionalFields,
-      trustedFields,
-      formatters,
-      defaultData
-    ]
-  );
-  const initialData = useMemo(
-    () => ({
-      requiredFields: getSchema,
-      defaultData,
-      fieldProblems,
-      obscuredFields,
-      optionalFields,
-      trustedFields,
-      formatters,
-      staticValidate: triggerStaticValidation,
-      data: defaultData
-    }),
-    [
-      getSchema,
-      defaultData,
-      fieldProblems,
-      obscuredFields,
-      optionalFields,
-      trustedFields,
-      formatters,
-      triggerStaticValidation
-    ]
-  );
-  const [state, dispatch] = useReducer(getReducer(), initialData, init);
-  const isValid = useMemo(() => {
-    const formsForOptionalFields = Object.keys(state.optionalFields ?? {});
-    const formsForRequiredFields = Object.keys(state.requiredFields ?? {});
-    const availableForms = Array.from(
-      /* @__PURE__ */ new Set([...formsForOptionalFields, ...formsForRequiredFields])
-    );
-    return availableForms.reduce((acc, formName) => {
-      const form = formName;
-      const optionalsFormFields = state.optionalFields?.[form] ?? [];
-      const requiredFormFields = state.requiredFields?.[form] ?? [];
-      const formFields = [...optionalsFormFields, ...requiredFormFields];
-      const formValidity = state.valid?.[formName] ?? {};
-      return {
-        ...acc,
-        [formName]: Object.entries(formValidity)?.every(
-          ([field, valid]) => formFields.includes(field) ? valid : true
-        )
-      };
-    }, {});
-  }, [state.requiredFields, state.valid]);
-  const getTargetValue = useCallback(
-    (key, formName, e) => {
-      if (!e?.target) return e;
-      if (e.target.type === "checkbox") {
-        return !state.data?.[formName][key];
-      }
-      return e.target.value;
-    },
-    [state.data]
-  );
-  const setErrors = useCallback(
-    (key, value, formName) => dispatch({ type: "setErrors", key, value, formName }),
-    []
-  );
-  const setValid = useCallback(
-    (key, value, formName) => dispatch({ type: "setValid", key, value, formName }),
-    []
-  );
-  const setData = useCallback(
-    (key, value, formName) => dispatch({ type: "setData", key, value, formName }),
-    []
-  );
-  const setFormData = useCallback(
-    (formName, formData) => dispatch({ type: "setFormData", formName, formData }),
-    []
-  );
-  const handleChangeFor = useCallback(
-    (key, formName, mode = "blur") => (e) => {
-      const value = getTargetValue(key, formName, e);
-      dispatch({
-        type: "updateField",
-        key,
-        value,
-        mode,
-        formName
-      });
-    },
-    [getTargetValue]
-  );
-  const triggerValidation = useCallback(
-    async (formName, selectedSchema) => {
-      const asyncValidationResults = await triggerAsyncFormValidation?.(
-        formName,
-        state,
-        selectedSchema
-      );
-      dispatch({
-        type: "validateForm",
-        formName,
-        selectedSchema,
-        asyncValidationResults
-      });
-      return asyncValidationResults.isValid;
-    },
-    [state, triggerAsyncFormValidation]
-  );
-  const resetToDefaultData = useCallback(() => {
-    if (!getSchema) return;
-    Object.entries(getSchema).forEach(([formName]) => {
-      const form = formName;
-      const formData = defaultData?.[form];
-      getSchema[form].forEach((field) => {
-        if (!formData || typeof formData[field] !== "undefined") {
-          return handleChangeFor(field, form)(formData);
-        }
-        setValid(field, false, form);
-        setErrors(field, null, form);
-        setData(field, formData[field], form);
-      });
-    });
-  }, [defaultData, getSchema, handleChangeFor, setData, setErrors, setValid]);
-  useEffect(() => {
-    const requiredFields2 = getRequiredFields(state?.data);
-    if (!requiredFields2) {
-      return;
-    }
-    dispatch({
-      type: "setRequiredFields",
-      requiredFields: requiredFields2,
-      defaultData,
-      optionalFields
-    });
-  }, [getRequiredFields, defaultData, optionalFields]);
-  return {
-    setData,
-    setFormData,
-    setValid,
-    setErrors,
-    handleChangeFor,
-    triggerValidation,
-    resetToDefaultData,
-    isValid,
-    allFields,
-    requiredFields: state.requiredFields,
-    optionalFields: state.optionalFields,
-    trustedFields: state.trustedFields,
-    obscuredFields: state.obscuredFields,
-    valid: state.valid,
-    errors: state.errors,
-    data: state.data,
-    fieldProblems: state.fieldProblems,
-    defaultData,
-    asyncErrors: state.asyncErrors
-  };
-}
-export {
-  useMultiForm as u
-};