@adyen/kyc-components 3.91.0 → 3.92.0

package/dist/{useForm-_Kjd_HFb.js → Select-D1rFT3T8.js}

@@ -2,171 +2,20 @@
 {
   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] = "296ff351-b18e-42c7-bdf2-9192e5cf307b", e._sentryDebugIdIdentifier = "sentry-dbid-296ff351-b18e-42c7-bdf2-9192e5cf307b");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "441e8e06-191b-48d9-992c-fbf7084e39cb", e._sentryDebugIdIdentifier = "sentry-dbid-441e8e06-191b-48d9-992c-fbf7084e39cb");
   } catch (e) {
   }
 }
 ;
 import { jsxs, jsx, Fragment } from "preact/jsx-runtime";
 import cx from "classnames";
-import { useEffect, useState, useRef, useMemo, useCallback, useReducer } from "preact/hooks";
-import { u as useTranslation, a3 as useAnalyticsContext, a4 as Icon, z as translateStringOrObject, L as Loader, a5 as noop, G as Typography, P as createLogger, W as isEmpty, a1 as entriesOf, aV as doArraysMatch } from "./StoreProvider-CyzNf7KK.js";
-import { b as useId } from "./useToastContext-Cbw29cqc.js";
+import { useState, useRef, useMemo, useCallback, useEffect } from "preact/hooks";
 import { computed, signal, useSignal, useSignalEffect } from "@preact/signals";
-import { K as KEYBOARD_KEYS } from "./Modal-B4wxf7HK.js";
-import { C as Checkbox, a as debouncedInputEvent } from "./debouncedInputEvent-CFFx_oML.js";
-const ARIA_ERROR_SUFFIX = "-ariaError";
-const MaybeFieldset = ({
-  children,
-  className,
-  name,
-  disabled,
-  el,
-  dataTestId
-}) => el === "fieldset" ? /* @__PURE__ */ jsx("fieldset", { name, disabled, className, "data-testid": dataTestId, children }) : /* @__PURE__ */ jsx("div", { className, "data-testid": dataTestId, children });
-const Field = ({
-  className,
-  classNameModifiers = [],
-  children,
-  disabled,
-  optional,
-  errorMessage,
-  formatGuidance,
-  helper,
-  helperPosition = "above",
-  isValid,
-  label,
-  name,
-  showErrorIconBottom = false,
-  showErrorIcon = true,
-  el = "div",
-  dataTestId,
-  onBlur,
-  onFieldBlur,
-  onFocus
-}) => {
-  const uniqueId = useId("field");
-  const { t } = useTranslation("common");
-  const userEvents = useAnalyticsContext();
-  const Label = el === "fieldset" ? "legend" : "label";
-  useEffect(() => {
-    if (!errorMessage) return;
-    const returnValue = typeof errorMessage === "string" && errorMessage || typeof errorMessage === "object" && errorMessage.key || "invalid";
-    userEvents.addFieldEvent("Encountered error", {
-      actionType: "input",
-      field: name,
-      returnType: "validation",
-      returnValue
-    });
-  }, [name, errorMessage, userEvents]);
-  const elementIds = {
-    label: `${uniqueId}-label`,
-    helper: `${uniqueId}-helper`,
-    error: `${uniqueId}${ARIA_ERROR_SUFFIX}`,
-    guidanceText: `${uniqueId}-guidanceText`
-  };
-  const inputDescribedBy = `${errorMessage ? elementIds.error : ""} ${helper ? elementIds.helper : ""} ${formatGuidance ? elementIds.guidanceText : ""}`.trim();
-  return /* @__PURE__ */ jsxs(
-    MaybeFieldset,
-    {
-      className: cx(
-        "adyen-kyc-field",
-        className,
-        classNameModifiers.map((m) => `adyen-kyc-field--${m}`),
-        {
-          "adyen-kyc-field--error": !!errorMessage,
-          "adyen-kyc-field--valid": isValid,
-          "adyen-kyc-field--disabled": disabled
-        }
-      ),
-      name,
-      disabled,
-      el,
-      dataTestId,
-      children: [
-        label && /* @__PURE__ */ jsxs(
-          Label,
-          {
-            id: elementIds.label,
-            htmlFor: el === "fieldset" ? void 0 : uniqueId,
-            className: cx("adyen-kyc-label__text", {
-              "adyen-kyc-label__text--error": !!errorMessage
-            }),
-            children: [
-              label,
-              optional && /* @__PURE__ */ jsxs("span", { className: "adyen-kyc-optional-label", children: [
-                " ",
-                t(($) => $["optional"])
-              ] })
-            ]
-          }
-        ),
-        helper && helperPosition === "above" && /* @__PURE__ */ jsx("span", { id: elementIds.helper, className: "adyen-kyc-helper-text adyen-kyc-helper-text__above", children: helper }),
-        /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-input-wrapper", children: [
-          children({
-            id: uniqueId,
-            "aria-labelledby": elementIds.label,
-            "aria-describedby": inputDescribedBy,
-            isInvalid: !!errorMessage,
-            isValid: !!isValid,
-            onBlurHandler: (e) => {
-              if (typeof onBlur === "function") onBlur(e);
-              if (typeof onFieldBlur === "function") onFieldBlur(e);
-            },
-            onFocusHandler: (e) => {
-              if (typeof onFocus === "function") onFocus(e);
-            }
-          }),
-          helper && helperPosition === "below" && /* @__PURE__ */ jsx(
-            "span",
-            {
-              id: elementIds.helper,
-              className: "adyen-kyc-helper-text adyen-kyc-helper-text__below",
-              children: helper
-            }
-          ),
-          isValid && /* @__PURE__ */ jsx("span", { className: "adyen-kyc-input__inline-validation adyen-kyc-input__inline-validation--valid", children: /* @__PURE__ */ jsx(Icon, { name: "check" }) }),
-          !!errorMessage && !showErrorIconBottom && showErrorIcon && /* @__PURE__ */ jsx("span", { className: "adyen-kyc-input__inline-validation adyen-kyc-input__inline-validation--invalid", children: /* @__PURE__ */ jsx(Icon, { name: "field-error" }) })
-        ] }),
-        /* @__PURE__ */ jsxs("div", { "aria-live": "polite", "aria-atomic": true, className: "adyen-kyc-error-text", children: [
-          /* @__PURE__ */ jsx("span", { className: "adyen-kyc-u-screen-reader-only", children: `${label}:` }),
-          !!errorMessage && typeof errorMessage !== "boolean" && /* @__PURE__ */ jsxs("span", { id: elementIds.error, children: [
-            translateStringOrObject(t, errorMessage),
-            showErrorIconBottom && /* @__PURE__ */ jsx("span", { className: "adyen-kyc-input__inline-validation adyen-kyc-input__inline-validation--invalid-bottom", children: /* @__PURE__ */ jsx(Icon, { name: "field-error" }) })
-          ] })
-        ] }),
-        !errorMessage && formatGuidance && /* @__PURE__ */ jsx("span", { id: elementIds.guidanceText, "aria-live": "polite", className: "adyen-kyc-guidance-text", children: formatGuidance })
-      ]
-    }
-  );
-};
-const loaderWrapperLoader = "adyen-kyc-loader-wrapper-loader";
-const loaderWrapperLoaderActive = "adyen-kyc-loader-wrapper-loader-active";
-const styles$1 = {
-  loaderWrapperLoader,
-  loaderWrapperLoaderActive
-};
-const LoaderWrapper = ({
-  children,
-  status,
-  formOpacityWhenLoading = 0,
-  loaderSize = "medium",
-  showSpinner = true,
-  className
-}) => {
-  const opacitySyle = status === "loading" ? {
-    opacity: formOpacityWhenLoading
-  } : { opacity: 1 };
-  const showLoader = status === "loading" && showSpinner;
-  const loaderWrapperClass = cx(styles$1.loaderWrapperLoader, {
-    [styles$1.loaderWrapperLoaderActive]: showLoader
-  });
-  const overlayClass = cx(styles$1.loaderWrapper, className);
-  return /* @__PURE__ */ jsxs("div", { className: overlayClass, style: { position: "relative" }, children: [
-    showLoader && /* @__PURE__ */ jsx("div", { className: loaderWrapperClass, children: /* @__PURE__ */ jsx(Loader, { size: loaderSize }) }),
-    /* @__PURE__ */ jsx("div", { className: styles$1.loaderWrapperForm, style: opacitySyle, children })
-  ] });
-};
+import { K as KEYBOARD_KEYS } from "./Modal-pyBUluei.js";
+import { V as useAnalyticsContext, L as Loader, Y as noop, G as Typography, H as createLogger, u as useTranslation } from "./StoreProvider-D9IR5HNN.js";
+import { d as debouncedInputEvent } from "./debouncedInputEvent-Cv2S512Y.js";
+import { a as useId } from "./useId-BZ0PA7jP.js";
+import { C as Checkbox } from "./Checkbox-D8rB6_HN.js";
 const createSelectFocus = ({
   activeItems,
   filteredItems: items
@@ -526,7 +375,7 @@ const SelectListItem = ({
     ] })
   }
 );
-const logger$1 = createLogger();
+const logger = createLogger();
 const DEFAULT_ITEM_HEIGHT = 36;
 function SelectList({
   selectListId,
@@ -613,7 +462,7 @@ function SelectList({
         if (itemEl) {
           itemEl.focus();
         } else {
-          logger$1.warn("[SelectList] still cannot see the option", item.name);
+          logger.warn("[SelectList] still cannot see the option", item.name);
         }
       }, 20);
     },
@@ -1005,621 +854,7 @@ const Select = ({
     }
   );
 };
-class ValidationResult {
-  validationResults;
-  constructor(results) {
-    this.validationResults = results;
-  }
-  /** Checks if all validation rules have passed */
-  get isValid() {
-    return this.validationResults.reduce((acc, result) => acc && result.isValid, true);
-  }
-  /** Checks if any validation rule returned an error */
-  hasError() {
-    return Boolean(this.getError());
-  }
-  /** Returns the first validation result that returned an error */
-  getError() {
-    return this.validationResults.find((result) => result.hasError);
-  }
-  /** Used to add async validation results to the static validation result*/
-  addError(result) {
-    this.validationResults.push(result);
-    return this.validationResults;
-  }
-}
-const logger = createLogger();
-const useAsyncValidator = (asyncRules) => {
-  const [asyncValidationResults, setAsyncValidationResults] = useState({});
-  const clearAsyncValidationResults = useCallback(
-    (field) => setAsyncValidationResults((existingResults) => ({
-      ...existingResults,
-      [field]: void 0
-    })),
-    []
-  );
-  const triggerAsyncValidation = useCallback(
-    (field, formState, mode) => {
-      const rule = asyncRules?.[field];
-      if (!rule || !rule.modes.includes(mode)) {
-        clearAsyncValidationResults(field);
-        return;
-      }
-      const value = formState.data[field];
-      return rule.asyncValidate(formState.data[field], { state: formState }).then((isValid) => {
-        setAsyncValidationResults((existingResults) => ({
-          ...existingResults,
-          [field]: new ValidationResult([
-            {
-              isValid,
-              errorMessage: typeof rule.errorMessage === "function" ? rule.errorMessage(value, { state: formState }) : rule.errorMessage,
-              hasError: !isValid
-            }
-          ])
-        }));
-      }).catch(logger.error);
-    },
-    [asyncRules, clearAsyncValidationResults]
-  );
-  return {
-    asyncValidationResults,
-    triggerAsyncValidation,
-    clearAsyncValidationResults
-  };
-};
-const useStaticValidator = (rules) => {
-  const getRulesForField = useCallback(
-    (field) => {
-      const fallbackRule = {
-        validate: () => true,
-        modes: ["blur", "input"]
-      };
-      const fieldRules = rules?.[field] ?? [fallbackRule];
-      return Array.isArray(fieldRules) ? fieldRules : [fieldRules];
-    },
-    [rules]
-  );
-  const triggerStaticValidation = useCallback(
-    ({ key, value, mode = "blur" }, context) => {
-      const fieldRules = getRulesForField(key);
-      const isFieldOptional = !!context?.state.optionalFields?.includes(key);
-      const isFieldObscured = !!context?.state.obscuredFields?.includes(key);
-      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
-  };
-};
-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
-);
-function getDataByFields(formData, fieldKeys) {
-  return entriesOf(formData).reduce((acc, [key, val]) => {
-    if (fieldKeys.includes(key)) {
-      return { ...acc, [key]: val };
-    }
-    return acc;
-  }, {});
-}
-const processField = ({
-  key,
-  value = null,
-  mode,
-  defaultData,
-  fieldContext,
-  formatters,
-  staticValidate,
-  asyncValidate
-}) => {
-  const formatterFn = formatters?.[key]?.formatter ? formatters[key]?.formatter : formatters?.[key];
-  const formattedValue = formatterFn && typeof formatterFn === "function" ? formatterFn(value, fieldContext) : value;
-  const shouldValidateField = !(defaultData?.[key] === value && !!defaultData?.[key]);
-  if (shouldValidateField && value) {
-    asyncValidate(key, fieldContext.state, mode);
-  }
-  const validationResult = shouldValidateField ? staticValidate({ key, value: formattedValue, mode }, fieldContext) : new ValidationResult([
-    {
-      isValid: true,
-      hasError: false
-    }
-  ]);
-  return [formattedValue, validationResult];
-};
-function init({
-  schema,
-  defaultData,
-  fieldProblems,
-  obscuredFields,
-  optionalFields,
-  trustedFields,
-  formatters,
-  staticValidate,
-  asyncValidate
-}) {
-  const getProcessedState = (fieldKey) => {
-    const [formattedValue, validationResult] = processField({
-      key: fieldKey,
-      value: defaultData?.[fieldKey],
-      mode: "blur",
-      formatters,
-      defaultData,
-      fieldContext: {
-        state: {
-          data: defaultData,
-          obscuredFields,
-          optionalFields,
-          trustedFields
-        }
-      },
-      staticValidate,
-      asyncValidate
-    });
-    if (typeof defaultData?.[fieldKey] === "undefined") {
-      return {
-        valid: validationResult.isValid && !fieldProblems?.[fieldKey] || false,
-        errors: null,
-        data: null,
-        fieldProblems: fieldProblems?.[fieldKey] ?? false
-      };
-    }
-    return {
-      valid: validationResult.isValid && !fieldProblems?.[fieldKey] || false,
-      errors: validationResult.getError() ?? null,
-      data: formattedValue,
-      fieldProblems: fieldProblems?.[fieldKey] ?? false
-    };
-  };
-  const formFields = optionalFields ? [...schema, ...optionalFields] : schema;
-  const formData = formFields.reduce(
-    (acc, field) => {
-      const {
-        valid,
-        errors,
-        data,
-        fieldProblems: processedFieldProblems
-      } = getProcessedState(field);
-      return {
-        ...acc,
-        data: { ...acc.data, [field]: data },
-        valid: { ...acc.valid, [field]: valid },
-        errors: { ...acc.errors, [field]: errors },
-        fieldProblems: { ...acc.fieldProblems, [field]: processedFieldProblems }
-      };
-    },
-    {
-      schema,
-      data: {},
-      valid: {},
-      errors: {},
-      fieldProblems: {},
-      obscuredFields,
-      optionalFields,
-      trustedFields
-    }
-  );
-  return formData;
-}
-function reducer({
-  staticValidate,
-  asyncValidate,
-  obscuredFields,
-  optionalFields,
-  trustedFields,
-  formatters
-}) {
-  return (state, {
-    type,
-    key,
-    mode,
-    value,
-    schema,
-    selectedSchema,
-    formValue,
-    fieldProblems,
-    defaultData
-  }) => {
-    const validationSchema = selectedSchema || state.schema;
-    switch (type) {
-      case "setData": {
-        if (!key) return state;
-        return { ...state, data: { ...state.data, [key]: value } };
-      }
-      case "setValid": {
-        if (!key) return state;
-        return { ...state, valid: { ...state.valid, [key]: value } };
-      }
-      case "setErrors": {
-        if (!key) return state;
-        return { ...state, errors: { ...state.errors, [key]: value } };
-      }
-      case "setFieldProblems": {
-        return state?.schema?.reduce(
-          (acc, field) => ({
-            ...acc,
-            fieldProblems: {
-              ...state.fieldProblems,
-              [field]: fieldProblems?.[field] ?? false
-            },
-            valid: { ...state.valid, [field]: state.valid?.[field] && !fieldProblems?.[field] }
-          }),
-          state
-        );
-      }
-      case "setSchema": {
-        if (!schema) return state;
-        const defaultState = init({
-          schema,
-          // requiredFields
-          defaultData,
-          fieldProblems,
-          obscuredFields,
-          optionalFields,
-          trustedFields,
-          staticValidate,
-          asyncValidate
-        });
-        const removedFields = state.optionalFields?.length ? [
-          ...state.schema.filter((field) => !schema.includes(field)),
-          ...state.optionalFields.filter((field) => !optionalFields?.includes(field))
-        ] : state.schema.filter((field) => !schema.includes(field));
-        const newFields = optionalFields?.length ? [
-          ...schema.filter((field) => !state.schema?.includes(field)),
-          ...optionalFields.filter((field) => !state.optionalFields?.includes(field))
-        ] : schema.filter((field) => !state.schema?.includes(field));
-        const local = {
-          data: omitKeys(state.data, newFields),
-          errors: omitKeys(state.errors, newFields),
-          valid: omitKeys(state.valid, newFields),
-          fieldProblems: omitKeys(state.fieldProblems, newFields)
-        };
-        const updatedData = addKeys(
-          omitKeys(state.data, removedFields),
-          newFields,
-          null,
-          defaultState.data,
-          state.local?.data
-        );
-        const updatedValid = addKeys(
-          omitKeys(state.valid, removedFields),
-          newFields,
-          false,
-          defaultState.valid,
-          state.local?.valid
-        );
-        const updatedErrors = addKeys(
-          omitKeys(state.errors, removedFields),
-          newFields,
-          null,
-          defaultState.errors,
-          state.local?.errors
-        );
-        const updatedFieldProblems = addKeys(
-          omitKeys(state.fieldProblems, removedFields),
-          newFields,
-          false,
-          defaultState.fieldProblems,
-          state.local?.fieldProblems
-        );
-        return {
-          ...state,
-          schema,
-          data: updatedData,
-          valid: updatedValid,
-          errors: updatedErrors,
-          fieldProblems: updatedFieldProblems,
-          obscuredFields,
-          optionalFields,
-          trustedFields,
-          local
-        };
-      }
-      case "updateField": {
-        if (!key || !mode) return state;
-        const [formattedValue, validation] = processField({
-          key,
-          value,
-          mode,
-          defaultData,
-          formatters,
-          fieldContext: { state },
-          staticValidate,
-          asyncValidate
-        });
-        const oldValue = state.data[key];
-        const clearFieldProblems = oldValue !== formattedValue;
-        return {
-          ...state,
-          data: { ...state.data, [key]: formattedValue },
-          errors: {
-            ...state.errors,
-            [key]: validation.getError() ?? null
-          },
-          valid: {
-            ...state.valid,
-            [key]: validation.isValid && !state.fieldProblems?.[key] || false
-          },
-          fieldProblems: {
-            ...state.fieldProblems,
-            [key]: clearFieldProblems ? false : state.fieldProblems?.[key] ?? false
-          }
-        };
-      }
-      case "mergeForm": {
-        const mergedState = {
-          ...state,
-          data: { ...state.data, ...formValue?.data },
-          errors: { ...state.errors, ...formValue?.errors },
-          valid: { ...state.valid, ...formValue?.valid },
-          fieldProblems: { ...state.fieldProblems, ...formValue?.fieldProblems }
-        };
-        if (mergedState.valid) {
-          mergedState.isValid = Object.values(mergedState.valid).every((isValid) => isValid);
-        }
-        return mergedState;
-      }
-      case "validateForm": {
-        const formValidation = validationSchema?.reduce(
-          (acc, cur) => {
-            const [formattedValue, validation] = processField({
-              key: cur,
-              value: state.data[cur],
-              mode: "blur",
-              defaultData,
-              formatters,
-              fieldContext: { state },
-              staticValidate,
-              asyncValidate
-            });
-            const oldValue = state.data[cur];
-            const clearFieldProblems = oldValue !== formattedValue;
-            return {
-              valid: {
-                ...acc.valid,
-                [cur]: validation.isValid && !state.fieldProblems?.[cur] || false
-              },
-              errors: {
-                ...acc.errors,
-                [cur]: validation.getError() ?? null
-              },
-              fieldProblems: {
-                ...acc.fieldProblems,
-                [cur]: clearFieldProblems ? false : state.fieldProblems?.[cur] ?? false
-              }
-            };
-          },
-          { valid: state.valid, errors: state.errors, fieldProblems: state.fieldProblems }
-        );
-        return {
-          ...state,
-          valid: formValidation?.valid,
-          errors: formValidation?.errors,
-          fieldProblems: formValidation?.fieldProblems
-        };
-      }
-      default:
-        throw new Error("Undefined useForm action");
-    }
-  };
-}
-const mergeStaticAndAsyncErrorsState = (staticValidationErrors, asyncValidationErrors, schema, setValid, optionalFields) => {
-  const fields = optionalFields ? [...schema, ...optionalFields] : schema;
-  if (!fields.length) return staticValidationErrors;
-  const errors = fields.reduce(
-    (acc, field) => {
-      if (asyncValidationErrors[field]?.getError()) setValid(field, false);
-      return {
-        ...acc,
-        [field]: staticValidationErrors[field] ?? asyncValidationErrors[field]?.getError() ?? null
-      };
-    },
-    {}
-  );
-  return errors;
-};
-function useForm({
-  schema,
-  defaultData,
-  rules,
-  asyncRules,
-  fieldProblems,
-  obscuredFields,
-  optionalFields,
-  trustedFields,
-  formatters,
-  shouldValidate = false
-}) {
-  const { triggerStaticValidation } = useStaticValidator(rules);
-  const { triggerAsyncValidation, asyncValidationResults } = useAsyncValidator(asyncRules);
-  const getRequiredFields = useMemo(
-    () => typeof schema === "function" ? schema : () => schema,
-    [schema]
-  );
-  const getSchema = useMemo(
-    () => defaultData ? getRequiredFields(defaultData) : [],
-    [defaultData, getRequiredFields]
-  );
-  const getReducer = useCallback(
-    () => reducer({
-      staticValidate: triggerStaticValidation,
-      asyncValidate: triggerAsyncValidation,
-      obscuredFields,
-      optionalFields,
-      trustedFields,
-      formatters
-    }),
-    [
-      triggerStaticValidation,
-      triggerAsyncValidation,
-      obscuredFields,
-      optionalFields,
-      trustedFields,
-      formatters
-    ]
-  );
-  const initialData = useMemo(
-    () => ({
-      schema: getSchema,
-      defaultData,
-      fieldProblems,
-      obscuredFields,
-      optionalFields,
-      trustedFields,
-      formatters,
-      staticValidate: triggerStaticValidation,
-      asyncValidate: triggerAsyncValidation
-    }),
-    [
-      getSchema,
-      defaultData,
-      fieldProblems,
-      obscuredFields,
-      optionalFields,
-      trustedFields,
-      formatters,
-      triggerStaticValidation,
-      triggerAsyncValidation
-    ]
-  );
-  const [state, dispatch] = useReducer(getReducer(), initialData, init);
-  const isValid = useMemo(
-    () => state.schema?.every((key) => state.valid[key]),
-    [state.schema, state.valid]
-  );
-  const getTargetValue = useCallback(
-    (key, e) => {
-      if (!e?.target) return e;
-      if (e.target.type === "checkbox") {
-        return !state.data[key];
-      }
-      return e.target.value;
-    },
-    [state.data]
-  );
-  const setErrors = useCallback(
-    (key, value) => dispatch({ type: "setErrors", key, value }),
-    []
-  );
-  const setValid = useCallback(
-    (key, value) => dispatch({ type: "setValid", key, value }),
-    []
-  );
-  const setData = useCallback(
-    (key, value) => dispatch({ type: "setData", key, value }),
-    []
-  );
-  const setSchema = useCallback(
-    (newSchema) => dispatch({ type: "setSchema", schema: newSchema, defaultData }),
-    [defaultData]
-  );
-  const setFieldProblems = useCallback(
-    (newFieldProblems) => dispatch({ type: "setFieldProblems", fieldProblems: newFieldProblems }),
-    []
-  );
-  const mergeForm = useCallback(
-    (formValue) => dispatch({ type: "mergeForm", formValue }),
-    []
-  );
-  const handleChangeFor = useCallback(
-    (key, mode = "blur") => (e) => {
-      const value = getTargetValue(key, e);
-      dispatch({
-        type: "updateField",
-        key,
-        value,
-        mode,
-        defaultData
-      });
-    },
-    [defaultData, getTargetValue]
-  );
-  const triggerValidation = useCallback(
-    (selectedSchema) => {
-      dispatch({
-        type: "validateForm",
-        selectedSchema,
-        defaultData
-      });
-    },
-    [defaultData]
-  );
-  const resetToDefaultData = useCallback(() => {
-    getSchema.forEach((field) => {
-      if (!defaultData || typeof defaultData[field] !== "undefined") {
-        return handleChangeFor(field)(defaultData?.[field]);
-      }
-      setValid(field, false);
-      setErrors(field, null);
-      setData(field, defaultData[field]);
-    });
-  }, [defaultData, getSchema, handleChangeFor, setData, setErrors, setValid]);
-  useEffect(() => {
-    const newSchema = getRequiredFields(state.data);
-    if (!doArraysMatch(state.schema, newSchema)) {
-      setSchema(newSchema);
-    }
-  }, [state.schema, state.data, setSchema, getRequiredFields]);
-  useEffect(() => {
-    if (shouldValidate) {
-      triggerValidation();
-    }
-  }, [shouldValidate, state.schema]);
-  useEffect(() => {
-    if (fieldProblems) {
-      setFieldProblems(fieldProblems);
-    }
-  }, [JSON.stringify(fieldProblems), setFieldProblems]);
-  const formErrors = useMemo(
-    () => mergeStaticAndAsyncErrorsState(
-      state.errors,
-      asyncValidationResults,
-      state.schema,
-      setValid,
-      state.optionalFields
-    ),
-    [asyncValidationResults, state.errors, state.optionalFields, state.schema]
-  );
-  return {
-    mergeForm,
-    setData,
-    setValid,
-    setErrors,
-    setFieldProblems,
-    handleChangeFor,
-    triggerValidation,
-    resetToDefaultData,
-    isValid,
-    schema: state.schema,
-    valid: state.valid,
-    errors: formErrors,
-    data: state.data,
-    fieldProblems: state.fieldProblems
-  };
-}
 export {
-  Field as F,
-  LoaderWrapper as L,
   Select as S,
-  ValidationResult as V,
-  SelectListItem as a,
-  getDataByFields as g,
-  useForm as u
+  SelectListItem as a
 };