@tanstack/form-core 0.11.0 → 0.13.0

package/dist/mjs/index.js

@@ -0,0 +1,926 @@
+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