@tanstack/form-core 0.13.0 → 0.13.3

package/dist/mjs/index.mjs

@@ -1,926 +0,0 @@
-import { Store } from "@tanstack/store";
-function functionalUpdate(updater, input) {
-  return typeof updater === "function" ? updater(input) : updater;
-}
-function getBy(obj, path) {
-  const pathObj = makePathArray(path);
-  return pathObj.reduce((current, pathPart) => {
-    if (typeof current !== "undefined") {
-      return current[pathPart];
-    }
-    return void 0;
-  }, obj);
-}
-function setBy(obj, _path, updater) {
-  const path = makePathArray(_path);
-  function doSet(parent) {
-    if (!path.length) {
-      return functionalUpdate(updater, parent);
-    }
-    const key = path.shift();
-    if (typeof key === "string") {
-      if (typeof parent === "object") {
-        return {
-          ...parent,
-          [key]: doSet(parent[key])
-        };
-      }
-      return {
-        [key]: doSet()
-      };
-    }
-    if (Array.isArray(parent) && key !== void 0) {
-      const prefix = parent.slice(0, key);
-      return [
-        ...prefix.length ? prefix : new Array(key),
-        doSet(parent[key]),
-        ...parent.slice(key + 1)
-      ];
-    }
-    return [...new Array(key), doSet()];
-  }
-  return doSet(obj);
-}
-function deleteBy(obj, _path) {
-  const path = makePathArray(_path);
-  function doDelete(parent) {
-    if (path.length === 1) {
-      const finalPath = path[0];
-      const { [finalPath]: remove, ...rest } = parent;
-      return rest;
-    }
-    const key = path.shift();
-    if (typeof key === "string") {
-      if (typeof parent === "object") {
-        return {
-          ...parent,
-          [key]: doDelete(parent[key])
-        };
-      }
-    }
-    if (typeof key === "number") {
-      if (Array.isArray(parent)) {
-        const prefix = parent.slice(0, key);
-        return [
-          ...prefix.length ? prefix : new Array(key),
-          doDelete(parent[key]),
-          ...parent.slice(key + 1)
-        ];
-      }
-    }
-    throw new Error("It seems we have created an infinite loop in deleteBy. ");
-  }
-  return doDelete(obj);
-}
-const reFindNumbers0 = /^(\d*)$/gm;
-const reFindNumbers1 = /\.(\d*)\./gm;
-const reFindNumbers2 = /^(\d*)\./gm;
-const reFindNumbers3 = /\.(\d*$)/gm;
-const reFindMultiplePeriods = /\.{2,}/gm;
-const intPrefix = "__int__";
-const intReplace = `${intPrefix}$1`;
-function makePathArray(str) {
-  if (typeof str !== "string") {
-    throw new Error("Path must be a string.");
-  }
-  return str.replace("[", ".").replace("]", "").replace(reFindNumbers0, intReplace).replace(reFindNumbers1, `.${intReplace}.`).replace(reFindNumbers2, `${intReplace}.`).replace(reFindNumbers3, `.${intReplace}`).replace(reFindMultiplePeriods, ".").split(".").map((d) => {
-    if (d.indexOf(intPrefix) === 0) {
-      return parseInt(d.substring(intPrefix.length), 10);
-    }
-    return d;
-  });
-}
-function isNonEmptyArray(obj) {
-  return !(Array.isArray(obj) && obj.length === 0);
-}
-function getAsyncValidatorArray(cause, options) {
-  const { asyncDebounceMs } = options;
-  const {
-    onChangeAsync,
-    onBlurAsync,
-    onSubmitAsync,
-    onBlurAsyncDebounceMs,
-    onChangeAsyncDebounceMs,
-    onSubmitAsyncDebounceMs
-  } = options.validators || {};
-  const defaultDebounceMs = asyncDebounceMs ?? 0;
-  const changeValidator = {
-    cause: "change",
-    validate: onChangeAsync,
-    debounceMs: onChangeAsyncDebounceMs ?? defaultDebounceMs
-  };
-  const blurValidator = {
-    cause: "blur",
-    validate: onBlurAsync,
-    debounceMs: onBlurAsyncDebounceMs ?? defaultDebounceMs
-  };
-  const submitValidator = {
-    cause: "submit",
-    validate: onSubmitAsync,
-    debounceMs: onSubmitAsyncDebounceMs ?? defaultDebounceMs
-  };
-  switch (cause) {
-    case "submit":
-      return [changeValidator, blurValidator, submitValidator];
-    case "server":
-      return [];
-    case "blur":
-      return [blurValidator];
-    case "change":
-    default:
-      return [changeValidator];
-  }
-}
-function getSyncValidatorArray(cause, options) {
-  const { onChange, onBlur, onSubmit } = options.validators || {};
-  const changeValidator = { cause: "change", validate: onChange };
-  const blurValidator = { cause: "blur", validate: onBlur };
-  const submitValidator = { cause: "submit", validate: onSubmit };
-  const serverValidator = {
-    cause: "server",
-    validate: () => void 0
-  };
-  switch (cause) {
-    case "submit":
-      return [
-        changeValidator,
-        blurValidator,
-        submitValidator,
-        serverValidator
-      ];
-    case "server":
-      return [serverValidator];
-    case "blur":
-      return [blurValidator, serverValidator];
-    case "change":
-    default:
-      return [changeValidator, serverValidator];
-  }
-}
-function getDefaultFormState(defaultState) {
-  return {
-    values: defaultState.values ?? {},
-    errors: defaultState.errors ?? [],
-    errorMap: defaultState.errorMap ?? {},
-    fieldMeta: defaultState.fieldMeta ?? {},
-    canSubmit: defaultState.canSubmit ?? true,
-    isFieldsValid: defaultState.isFieldsValid ?? false,
-    isFieldsValidating: defaultState.isFieldsValidating ?? false,
-    isFormValid: defaultState.isFormValid ?? false,
-    isFormValidating: defaultState.isFormValidating ?? false,
-    isSubmitted: defaultState.isSubmitted ?? false,
-    isSubmitting: defaultState.isSubmitting ?? false,
-    isTouched: defaultState.isTouched ?? false,
-    isValid: defaultState.isValid ?? false,
-    isValidating: defaultState.isValidating ?? false,
-    submissionAttempts: defaultState.submissionAttempts ?? 0,
-    validationMetaMap: defaultState.validationMetaMap ?? {
-      onChange: void 0,
-      onBlur: void 0,
-      onSubmit: void 0,
-      onMount: void 0,
-      onServer: void 0
-    }
-  };
-}
-class FormApi {
-  constructor(opts) {
-    var _a;
-    this.options = {};
-    this.fieldInfo = {};
-    this.prevTransformArray = [];
-    this.mount = () => {
-      const { onMount } = this.options.validators || {};
-      if (!onMount)
-        return;
-      const error = this.runValidator({
-        validate: onMount,
-        value: {
-          value: this.state.values,
-          formApi: this
-        },
-        type: "validate"
-      });
-      if (error) {
-        this.store.setState((prev) => ({
-          ...prev,
-          errorMap: { ...prev.errorMap, onMount: error }
-        }));
-      }
-    };
-    this.update = (options) => {
-      if (!options)
-        return;
-      const oldOptions = this.options;
-      this.options = options;
-      this.store.batch(() => {
-        const shouldUpdateValues = options.defaultValues && options.defaultValues !== oldOptions.defaultValues && !this.state.isTouched;
-        const shouldUpdateState = options.defaultState !== oldOptions.defaultState && !this.state.isTouched;
-        this.store.setState(
-          () => getDefaultFormState(
-            Object.assign(
-              {},
-              this.state,
-              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-              shouldUpdateState ? options.defaultState : {},
-              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-              shouldUpdateValues ? {
-                values: options.defaultValues
-              } : {}
-            )
-          )
-        );
-      });
-    };
-    this.reset = () => this.store.setState(
-      () => {
-        var _a2;
-        return getDefaultFormState({
-          ...this.options.defaultState,
-          values: this.options.defaultValues ?? ((_a2 = this.options.defaultState) == null ? void 0 : _a2.values)
-        });
-      }
-    );
-    this.validateAllFields = async (cause) => {
-      const fieldValidationPromises = [];
-      this.store.batch(() => {
-        void Object.values(this.fieldInfo).forEach((field) => {
-          Object.values(field.instances).forEach((instance) => {
-            fieldValidationPromises.push(
-              Promise.resolve().then(() => instance.validate(cause))
-            );
-            if (!instance.state.meta.isTouched) {
-              instance.setMeta((prev) => ({ ...prev, isTouched: true }));
-            }
-          });
-        });
-      });
-      const fieldErrorMapMap = await Promise.all(fieldValidationPromises);
-      return fieldErrorMapMap.flat();
-    };
-    this.validateSync = (cause) => {
-      const validates = getSyncValidatorArray(cause, this.options);
-      let hasErrored = false;
-      this.store.batch(() => {
-        for (const validateObj of validates) {
-          if (!validateObj.validate)
-            continue;
-          const error = normalizeError$1(
-            this.runValidator({
-              validate: validateObj.validate,
-              value: {
-                value: this.state.values,
-                formApi: this
-              },
-              type: "validate"
-            })
-          );
-          const errorMapKey = getErrorMapKey$1(validateObj.cause);
-          if (this.state.errorMap[errorMapKey] !== error) {
-            this.store.setState((prev) => ({
-              ...prev,
-              errorMap: {
-                ...prev.errorMap,
-                [errorMapKey]: error
-              }
-            }));
-          }
-          if (error) {
-            hasErrored = true;
-          }
-        }
-      });
-      const submitErrKey = getErrorMapKey$1("submit");
-      if (this.state.errorMap[submitErrKey] && cause !== "submit" && !hasErrored) {
-        this.store.setState((prev) => ({
-          ...prev,
-          errorMap: {
-            ...prev.errorMap,
-            [submitErrKey]: void 0
-          }
-        }));
-      }
-      return { hasErrored };
-    };
-    this.validateAsync = async (cause) => {
-      const validates = getAsyncValidatorArray(cause, this.options);
-      if (!this.state.isFormValidating) {
-        this.store.setState((prev) => ({ ...prev, isFormValidating: true }));
-      }
-      const promises = [];
-      for (const validateObj of validates) {
-        if (!validateObj.validate)
-          continue;
-        const key = getErrorMapKey$1(validateObj.cause);
-        const fieldValidatorMeta = this.state.validationMetaMap[key];
-        fieldValidatorMeta == null ? void 0 : fieldValidatorMeta.lastAbortController.abort();
-        const controller = new AbortController();
-        this.state.validationMetaMap[key] = {
-          lastAbortController: controller
-        };
-        promises.push(
-          new Promise(async (resolve) => {
-            let rawError;
-            try {
-              rawError = await new Promise((rawResolve, rawReject) => {
-                setTimeout(async () => {
-                  if (controller.signal.aborted)
-                    return rawResolve(void 0);
-                  try {
-                    rawResolve(
-                      await this.runValidator({
-                        validate: validateObj.validate,
-                        value: {
-                          value: this.state.values,
-                          formApi: this,
-                          signal: controller.signal
-                        },
-                        type: "validateAsync"
-                      })
-                    );
-                  } catch (e) {
-                    rawReject(e);
-                  }
-                }, validateObj.debounceMs);
-              });
-            } catch (e) {
-              rawError = e;
-            }
-            const error = normalizeError$1(rawError);
-            this.store.setState((prev) => ({
-              ...prev,
-              errorMap: {
-                ...prev.errorMap,
-                [getErrorMapKey$1(cause)]: error
-              }
-            }));
-            resolve(error);
-          })
-        );
-      }
-      let results = [];
-      if (promises.length) {
-        results = await Promise.all(promises);
-      }
-      this.store.setState((prev) => ({
-        ...prev,
-        isFormValidating: false
-      }));
-      return results.filter(Boolean);
-    };
-    this.validate = (cause) => {
-      const { hasErrored } = this.validateSync(cause);
-      if (hasErrored && !this.options.asyncAlways) {
-        return this.state.errors;
-      }
-      return this.validateAsync(cause);
-    };
-    this.handleSubmit = async () => {
-      var _a2, _b, _c, _d, _e, _f;
-      this.store.setState((old) => ({
-        ...old,
-        // Submission attempts mark the form as not submitted
-        isSubmitted: false,
-        // Count submission attempts
-        submissionAttempts: old.submissionAttempts + 1
-      }));
-      if (!this.state.canSubmit)
-        return;
-      this.store.setState((d) => ({ ...d, isSubmitting: true }));
-      const done = () => {
-        this.store.setState((prev) => ({ ...prev, isSubmitting: false }));
-      };
-      await this.validateAllFields("submit");
-      if (!this.state.isFieldsValid) {
-        done();
-        (_b = (_a2 = this.options).onSubmitInvalid) == null ? void 0 : _b.call(_a2, {
-          value: this.state.values,
-          formApi: this
-        });
-        return;
-      }
-      await this.validate("submit");
-      if (!this.state.isValid) {
-        done();
-        (_d = (_c = this.options).onSubmitInvalid) == null ? void 0 : _d.call(_c, {
-          value: this.state.values,
-          formApi: this
-        });
-        return;
-      }
-      try {
-        await ((_f = (_e = this.options).onSubmit) == null ? void 0 : _f.call(_e, { value: this.state.values, formApi: this }));
-        this.store.batch(() => {
-          this.store.setState((prev) => ({ ...prev, isSubmitted: true }));
-          done();
-        });
-      } catch (err) {
-        done();
-        throw err;
-      }
-    };
-    this.getFieldValue = (field) => getBy(this.state.values, field);
-    this.getFieldMeta = (field) => {
-      return this.state.fieldMeta[field];
-    };
-    this.getFieldInfo = (field) => {
-      var _a2;
-      return (_a2 = this.fieldInfo)[field] || (_a2[field] = {
-        instances: {},
-        validationMetaMap: {
-          onChange: void 0,
-          onBlur: void 0,
-          onSubmit: void 0,
-          onMount: void 0,
-          onServer: void 0
-        }
-      });
-    };
-    this.setFieldMeta = (field, updater) => {
-      this.store.setState((prev) => {
-        return {
-          ...prev,
-          fieldMeta: {
-            ...prev.fieldMeta,
-            [field]: functionalUpdate(updater, prev.fieldMeta[field])
-          }
-        };
-      });
-    };
-    this.setFieldValue = (field, updater, opts2) => {
-      const touch = opts2 == null ? void 0 : opts2.touch;
-      this.store.batch(() => {
-        if (touch) {
-          this.setFieldMeta(field, (prev) => ({
-            ...prev,
-            isTouched: true
-          }));
-        }
-        this.store.setState((prev) => {
-          return {
-            ...prev,
-            values: setBy(prev.values, field, updater)
-          };
-        });
-      });
-    };
-    this.deleteField = (field) => {
-      this.store.setState((prev) => {
-        const newState = { ...prev };
-        newState.values = deleteBy(newState.values, field);
-        delete newState.fieldMeta[field];
-        return newState;
-      });
-    };
-    this.pushFieldValue = (field, value, opts2) => {
-      return this.setFieldValue(
-        field,
-        (prev) => [...Array.isArray(prev) ? prev : [], value],
-        opts2
-      );
-    };
-    this.insertFieldValue = (field, index, value, opts2) => {
-      this.setFieldValue(
-        field,
-        (prev) => {
-          return prev.map(
-            (d, i) => i === index ? value : d
-          );
-        },
-        opts2
-      );
-    };
-    this.removeFieldValue = (field, index, opts2) => {
-      this.setFieldValue(
-        field,
-        (prev) => {
-          return prev.filter(
-            (_d, i) => i !== index
-          );
-        },
-        opts2
-      );
-    };
-    this.swapFieldValues = (field, index1, index2) => {
-      this.setFieldValue(field, (prev) => {
-        const prev1 = prev[index1];
-        const prev2 = prev[index2];
-        return setBy(setBy(prev, `${index1}`, prev2), `${index2}`, prev1);
-      });
-    };
-    this.store = new Store(
-      getDefaultFormState({
-        ...opts == null ? void 0 : opts.defaultState,
-        values: (opts == null ? void 0 : opts.defaultValues) ?? ((_a = opts == null ? void 0 : opts.defaultState) == null ? void 0 : _a.values),
-        isFormValid: true
-      }),
-      {
-        onUpdate: () => {
-          var _a2, _b;
-          let { state } = this.store;
-          const fieldMetaValues = Object.values(state.fieldMeta);
-          const isFieldsValidating = fieldMetaValues.some(
-            (field) => field == null ? void 0 : field.isValidating
-          );
-          const isFieldsValid = !fieldMetaValues.some(
-            (field) => (field == null ? void 0 : field.errorMap) && isNonEmptyArray(Object.values(field.errorMap).filter(Boolean))
-          );
-          const isTouched = fieldMetaValues.some((field) => field == null ? void 0 : field.isTouched);
-          const isValidating = isFieldsValidating || state.isFormValidating;
-          state.errors = Object.values(state.errorMap).filter(
-            (val) => val !== void 0
-          );
-          const isFormValid = state.errors.length === 0;
-          const isValid = isFieldsValid && isFormValid;
-          const canSubmit = state.submissionAttempts === 0 && !isTouched || !isValidating && !state.isSubmitting && isValid;
-          state = {
-            ...state,
-            isFieldsValidating,
-            isFieldsValid,
-            isFormValid,
-            isValid,
-            canSubmit,
-            isTouched
-          };
-          this.state = state;
-          this.store.state = this.state;
-          const transformArray = ((_a2 = this.options.transform) == null ? void 0 : _a2.deps) ?? [];
-          const shouldTransform = transformArray.length !== this.prevTransformArray.length || transformArray.some((val, i) => val !== this.prevTransformArray[i]);
-          if (shouldTransform) {
-            (_b = this.options.transform) == null ? void 0 : _b.fn(this);
-            this.store.state = this.state;
-            this.prevTransformArray = transformArray;
-          }
-        }
-      }
-    );
-    this.state = this.store.state;
-    this.update(opts || {});
-  }
-  runValidator(props) {
-    const adapter = this.options.validatorAdapter;
-    if (adapter && typeof props.validate !== "function") {
-      return adapter()[props.type](props.value, props.validate);
-    }
-    return props.validate(props.value);
-  }
-}
-function normalizeError$1(rawError) {
-  if (rawError) {
-    if (typeof rawError !== "string") {
-      return "Invalid Form Values";
-    }
-    return rawError;
-  }
-  return void 0;
-}
-function getErrorMapKey$1(cause) {
-  switch (cause) {
-    case "submit":
-      return "onSubmit";
-    case "blur":
-      return "onBlur";
-    case "mount":
-      return "onMount";
-    case "server":
-      return "onServer";
-    case "change":
-    default:
-      return "onChange";
-  }
-}
-let uid = 0;
-class FieldApi {
-  constructor(opts) {
-    this.options = {};
-    this.mount = () => {
-      const info = this.getInfo();
-      info.instances[this.uid] = this;
-      const unsubscribe = this.form.store.subscribe(() => {
-        this.store.batch(() => {
-          const nextValue = this.getValue();
-          const nextMeta = this.getMeta();
-          if (nextValue !== this.state.value) {
-            this.store.setState((prev) => ({ ...prev, value: nextValue }));
-          }
-          if (nextMeta !== this.state.meta) {
-            this.store.setState((prev) => ({ ...prev, meta: nextMeta }));
-          }
-        });
-      });
-      this.update(this.options);
-      const { onMount } = this.options.validators || {};
-      if (onMount) {
-        const error = this.runValidator({
-          validate: onMount,
-          value: {
-            value: this.state.value,
-            fieldApi: this
-          },
-          type: "validate"
-        });
-        if (error) {
-          this.setMeta((prev) => ({
-            ...prev,
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            errorMap: { ...prev == null ? void 0 : prev.errorMap, onMount: error }
-          }));
-        }
-      }
-      return () => {
-        const preserveValue = this.options.preserveValue;
-        unsubscribe();
-        if (!preserveValue) {
-          delete info.instances[this.uid];
-          this.form.deleteField(this.name);
-        }
-        if (!Object.keys(info.instances).length && !preserveValue) {
-          delete this.form.fieldInfo[this.name];
-        }
-      };
-    };
-    this.update = (opts2) => {
-      var _a;
-      if (this.state.value === void 0) {
-        const formDefault = (_a = opts2.form.options.defaultValues) == null ? void 0 : _a[opts2.name];
-        if (opts2.defaultValue !== void 0) {
-          this.setValue(opts2.defaultValue);
-        } else if (formDefault !== void 0) {
-          this.setValue(formDefault);
-        }
-      }
-      if (this._getMeta() === void 0) {
-        this.setMeta(this.state.meta);
-      }
-      this.options = opts2;
-    };
-    this.getValue = () => {
-      return this.form.getFieldValue(this.name);
-    };
-    this.setValue = (updater, options) => {
-      this.form.setFieldValue(this.name, updater, options);
-      this.validate("change", this.state.value);
-    };
-    this._getMeta = () => this.form.getFieldMeta(this.name);
-    this.getMeta = () => this._getMeta() ?? {
-      isValidating: false,
-      isTouched: false,
-      touchedErrors: [],
-      errors: [],
-      errorMap: {},
-      ...this.options.defaultMeta
-    };
-    this.setMeta = (updater) => this.form.setFieldMeta(this.name, updater);
-    this.getInfo = () => this.form.getFieldInfo(this.name);
-    this.pushValue = (value) => this.form.pushFieldValue(this.name, value);
-    this.insertValue = (index, value) => this.form.insertFieldValue(this.name, index, value);
-    this.removeValue = (index) => this.form.removeFieldValue(this.name, index);
-    this.swapValues = (aIndex, bIndex) => this.form.swapFieldValues(this.name, aIndex, bIndex);
-    this.getSubField = (name) => new FieldApi({
-      name: `${this.name}.${name}`,
-      form: this.form
-    });
-    this.validateSync = (value = this.state.value, cause) => {
-      const validates = getSyncValidatorArray(cause, this.options);
-      let hasErrored = false;
-      this.form.store.batch(() => {
-        for (const validateObj of validates) {
-          if (!validateObj.validate)
-            continue;
-          const error = normalizeError(
-            this.runValidator({
-              validate: validateObj.validate,
-              value: { value, fieldApi: this },
-              type: "validate"
-            })
-          );
-          const errorMapKey = getErrorMapKey(validateObj.cause);
-          if (this.state.meta.errorMap[errorMapKey] !== error) {
-            this.setMeta((prev) => ({
-              ...prev,
-              errorMap: {
-                ...prev.errorMap,
-                [getErrorMapKey(validateObj.cause)]: error
-              }
-            }));
-          }
-          if (error) {
-            hasErrored = true;
-          }
-        }
-      });
-      const submitErrKey = getErrorMapKey("submit");
-      if (this.state.meta.errorMap[submitErrKey] && cause !== "submit" && !hasErrored) {
-        this.setMeta((prev) => ({
-          ...prev,
-          errorMap: {
-            ...prev.errorMap,
-            [submitErrKey]: void 0
-          }
-        }));
-      }
-      return { hasErrored };
-    };
-    this.validateAsync = async (value = this.state.value, cause) => {
-      const validates = getAsyncValidatorArray(cause, this.options);
-      if (!this.state.meta.isValidating) {
-        this.setMeta((prev) => ({ ...prev, isValidating: true }));
-      }
-      const promises = [];
-      for (const validateObj of validates) {
-        if (!validateObj.validate)
-          continue;
-        const key = getErrorMapKey(validateObj.cause);
-        const fieldValidatorMeta = this.getInfo().validationMetaMap[key];
-        fieldValidatorMeta == null ? void 0 : fieldValidatorMeta.lastAbortController.abort();
-        const controller = new AbortController();
-        this.getInfo().validationMetaMap[key] = {
-          lastAbortController: controller
-        };
-        promises.push(
-          new Promise(async (resolve) => {
-            let rawError;
-            try {
-              rawError = await new Promise((rawResolve, rawReject) => {
-                setTimeout(async () => {
-                  if (controller.signal.aborted)
-                    return rawResolve(void 0);
-                  try {
-                    rawResolve(
-                      await this.runValidator({
-                        validate: validateObj.validate,
-                        value: {
-                          value,
-                          fieldApi: this,
-                          signal: controller.signal
-                        },
-                        type: "validateAsync"
-                      })
-                    );
-                  } catch (e) {
-                    rawReject(e);
-                  }
-                }, validateObj.debounceMs);
-              });
-            } catch (e) {
-              rawError = e;
-            }
-            const error = normalizeError(rawError);
-            this.setMeta((prev) => {
-              return {
-                ...prev,
-                errorMap: {
-                  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                  ...prev == null ? void 0 : prev.errorMap,
-                  [getErrorMapKey(cause)]: error
-                }
-              };
-            });
-            resolve(error);
-          })
-        );
-      }
-      let results = [];
-      if (promises.length) {
-        results = await Promise.all(promises);
-      }
-      this.setMeta((prev) => ({ ...prev, isValidating: false }));
-      return results.filter(Boolean);
-    };
-    this.validate = (cause, value) => {
-      if (!this.state.meta.isTouched)
-        return [];
-      try {
-        this.form.validate(cause);
-      } catch (_) {
-      }
-      const { hasErrored } = this.validateSync(value, cause);
-      if (hasErrored && !this.options.asyncAlways) {
-        return this.state.meta.errors;
-      }
-      return this.validateAsync(value, cause);
-    };
-    this.handleChange = (updater) => {
-      this.setValue(updater, { touch: true });
-    };
-    this.handleBlur = () => {
-      const prevTouched = this.state.meta.isTouched;
-      if (!prevTouched) {
-        this.setMeta((prev) => ({ ...prev, isTouched: true }));
-        this.validate("change");
-      }
-      this.validate("blur");
-    };
-    this.form = opts.form;
-    this.uid = uid++;
-    this.name = opts.name;
-    if (opts.defaultValue !== void 0) {
-      this.form.setFieldValue(this.name, opts.defaultValue);
-    }
-    this.store = new Store(
-      {
-        value: this.getValue(),
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        meta: this._getMeta() ?? {
-          isValidating: false,
-          isTouched: false,
-          touchedErrors: [],
-          errors: [],
-          errorMap: {},
-          ...opts.defaultMeta
-        }
-      },
-      {
-        onUpdate: () => {
-          const state = this.store.state;
-          state.meta.errors = Object.values(state.meta.errorMap).filter(
-            (val) => val !== void 0
-          );
-          state.meta.touchedErrors = state.meta.isTouched ? state.meta.errors : [];
-          this.prevState = state;
-          this.state = state;
-        }
-      }
-    );
-    this.state = this.store.state;
-    this.prevState = this.state;
-    this.options = opts;
-  }
-  runValidator(props) {
-    const adapters = [
-      this.form.options.validatorAdapter,
-      this.options.validatorAdapter
-    ];
-    for (const adapter of adapters) {
-      if (adapter && typeof props.validate !== "function") {
-        return adapter()[props.type](props.value, props.validate);
-      }
-    }
-    return props.validate(props.value);
-  }
-}
-function normalizeError(rawError) {
-  if (rawError) {
-    if (typeof rawError !== "string") {
-      return "Invalid Form Values";
-    }
-    return rawError;
-  }
-  return void 0;
-}
-function getErrorMapKey(cause) {
-  switch (cause) {
-    case "submit":
-      return "onSubmit";
-    case "blur":
-      return "onBlur";
-    case "mount":
-      return "onMount";
-    case "server":
-      return "onServer";
-    case "change":
-    default:
-      return "onChange";
-  }
-}
-function mutateMergeDeep(target, source) {
-  const targetKeys = Object.keys(target);
-  const sourceKeys = Object.keys(source);
-  const keySet = /* @__PURE__ */ new Set([...targetKeys, ...sourceKeys]);
-  for (const key of keySet) {
-    const targetKey = key;
-    const sourceKey = key;
-    if (Array.isArray(target[targetKey]) && Array.isArray(source[sourceKey])) {
-      target[targetKey] = [
-        ...target[targetKey],
-        ...source[sourceKey]
-      ];
-    } else if (typeof target[targetKey] === "object" && typeof source[sourceKey] === "object") {
-      mutateMergeDeep(target[targetKey], source[sourceKey]);
-    } else {
-      if (!(sourceKey in source) && source[sourceKey] === void 0) {
-        continue;
-      }
-      target[targetKey] = source[sourceKey];
-    }
-  }
-  return target;
-}
-function mergeForm(baseForm, state) {
-  mutateMergeDeep(baseForm.state, state);
-  return baseForm;
-}
-export {
-  FieldApi,
-  FormApi,
-  deleteBy,
-  functionalUpdate,
-  getAsyncValidatorArray,
-  getBy,
-  getSyncValidatorArray,
-  isNonEmptyArray,
-  mergeForm,
-  mutateMergeDeep,
-  setBy
-};
-//# sourceMappingURL=index.mjs.map