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

package/dist/useMultiForm-Dm2IEMH9.js

@@ -0,0 +1,873 @@
+;
+{
+  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] = "428c7f33-2b0e-4e4a-837b-ad57deb42c60", e._sentryDebugIdIdentifier = "sentry-dbid-428c7f33-2b0e-4e4a-837b-ad57deb42c60");
+  } catch (e) {
+  }
+}
+;
+import { useCallback, useMemo, useReducer, useEffect } from "preact/hooks";
+import { a6 as objectsDeepEqual, a3 as createLogger, ai as isEmpty } from "./StoreProvider-99-ewU62.js";
+import { V as ValidationResult } from "./utils-PkTZS9uf.js";
+import { a as isNotEmptyValidator } from "./commonValidators-DTt6he7v.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]
+              },
+              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,
+            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") {
+          handleChangeFor(field, form)(formData);
+          return;
+        }
+        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, state.data, 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
+};