@gsc-basic/components 1.0.1 → 1.0.3

package/dist/es/node_modules/@tanstack/form-core/dist/esm/FormApi.js

@@ -0,0 +1,772 @@
+import { Derived as N } from "../../../store/dist/esm/derived.js";
+import { Store as G } from "../../../store/dist/esm/store.js";
+import { batch as A } from "../../../store/dist/esm/scheduler.js";
+import { throttleFormState as H, evaluate as w, getSyncValidatorArray as J, getAsyncValidatorArray as Q, determineFormLevelErrorSourceAndValue as q, getBy as T, functionalUpdate as X, deleteBy as Y, mergeOpts as B, setBy as _, uuid as Z, isNonEmptyArray as x, isGlobalFormValidationError as W } from "./utils.js";
+import { defaultValidationLogic as z } from "./ValidationLogic.js";
+import { standardSchemaValidators as U, isStandardSchemaValidator as tt } from "./standardSchemaValidator.js";
+import { defaultFieldMeta as $, metaHelper as P } from "./metaHelper.js";
+import { formEventClient as y } from "./EventClient.js";
+function R(f) {
+  return {
+    values: f.values ?? {},
+    errorMap: f.errorMap ?? {},
+    fieldMetaBase: f.fieldMetaBase ?? {},
+    isSubmitted: f.isSubmitted ?? !1,
+    isSubmitting: f.isSubmitting ?? !1,
+    isValidating: f.isValidating ?? !1,
+    submissionAttempts: f.submissionAttempts ?? 0,
+    isSubmitSuccessful: f.isSubmitSuccessful ?? !1,
+    validationMetaMap: f.validationMetaMap ?? {
+      onChange: void 0,
+      onBlur: void 0,
+      onSubmit: void 0,
+      onMount: void 0,
+      onServer: void 0,
+      onDynamic: void 0
+    }
+  };
+}
+class ut {
+  /**
+   * Constructs a new `FormApi` instance with the given form options.
+   */
+  constructor(p) {
+    this.options = {}, this.fieldInfo = {}, this.prevTransformArray = [], this.mount = () => {
+      const t = this.fieldMetaDerived.mount(), s = this.store.mount(), i = this.store.subscribe(() => {
+        H(this);
+      }), e = y.on(
+        "request-form-state",
+        (n) => {
+          n.payload.id === this._formId && y.emit("form-api", {
+            id: this._formId,
+            state: this.store.state,
+            options: this.options
+          });
+        }
+      ), o = y.on(
+        "request-form-reset",
+        (n) => {
+          n.payload.id === this._formId && this.reset();
+        }
+      ), a = y.on(
+        "request-form-force-submit",
+        (n) => {
+          n.payload.id === this._formId && (this._devtoolsSubmissionOverride = !0, this.handleSubmit(), this._devtoolsSubmissionOverride = !1);
+        }
+      ), r = () => {
+        a(), o(), e(), i(), t(), s(), y.emit("form-unmounted", {
+          id: this._formId
+        });
+      };
+      this.options.listeners?.onMount?.({ formApi: this });
+      const { onMount: l } = this.options.validators || {};
+      return y.emit("form-api", {
+        id: this._formId,
+        state: this.store.state,
+        options: this.options
+      }), l && this.validateSync("mount"), r;
+    }, this.update = (t) => {
+      if (!t) return;
+      const s = this.options;
+      this.options = t;
+      const i = !!t.transform?.deps?.some(
+        (a, r) => a !== this.prevTransformArray[r]
+      ), e = t.defaultValues && !w(t.defaultValues, s.defaultValues) && !this.state.isTouched, o = !w(t.defaultState, s.defaultState) && !this.state.isTouched;
+      !e && !o && !i || (A(() => {
+        this.baseStore.setState(
+          () => R(
+            Object.assign(
+              {},
+              this.state,
+              o ? t.defaultState : {},
+              e ? {
+                values: t.defaultValues
+              } : {},
+              i ? { _force_re_eval: !this.state._force_re_eval } : {}
+            )
+          )
+        );
+      }), y.emit("form-api", {
+        id: this._formId,
+        state: this.store.state,
+        options: this.options
+      }));
+    }, this.reset = (t, s) => {
+      const { fieldMeta: i } = this.state, e = this.resetFieldMeta(i);
+      t && !s?.keepDefaultValues && (this.options = {
+        ...this.options,
+        defaultValues: t
+      }), this.baseStore.setState(
+        () => R({
+          ...this.options.defaultState,
+          values: t ?? this.options.defaultValues ?? this.options.defaultState?.values,
+          fieldMetaBase: e
+        })
+      );
+    }, this.validateAllFields = async (t) => {
+      const s = [];
+      return A(() => {
+        Object.values(this.fieldInfo).forEach(
+          (e) => {
+            if (!e.instance) return;
+            const o = e.instance;
+            s.push(
+              // Remember, `validate` is either a sync operation or a promise
+              Promise.resolve().then(
+                () => o.validate(t, { skipFormValidation: !0 })
+              )
+            ), e.instance.state.meta.isTouched || e.instance.setMeta((a) => ({ ...a, isTouched: !0 }));
+          }
+        );
+      }), (await Promise.all(s)).flat();
+    }, this.validateArrayFieldsStartingFrom = async (t, s, i) => {
+      const e = this.getFieldValue(t), o = Array.isArray(e) ? Math.max(e.length - 1, 0) : null, a = [`${t}[${s}]`];
+      for (let d = s + 1; d <= (o ?? 0); d++)
+        a.push(`${t}[${d}]`);
+      const r = Object.keys(this.fieldInfo).filter(
+        (d) => a.some((h) => d.startsWith(h))
+      ), l = [];
+      return A(() => {
+        r.forEach((d) => {
+          l.push(
+            Promise.resolve().then(() => this.validateField(d, i))
+          );
+        });
+      }), (await Promise.all(l)).flat();
+    }, this.validateField = (t, s) => {
+      const i = this.fieldInfo[t]?.instance;
+      if (!i) {
+        const { hasErrored: e } = this.validateSync(s);
+        return e && !this.options.asyncAlways ? this.getFieldMeta(t)?.errors ?? [] : this.validateAsync(s).then(() => this.getFieldMeta(t)?.errors ?? []);
+      }
+      return i.state.meta.isTouched || i.setMeta((e) => ({ ...e, isTouched: !0 })), i.validate(s);
+    }, this.validateSync = (t) => {
+      const s = J(t, {
+        ...this.options,
+        form: this,
+        validationLogic: this.options.validationLogic || z
+      });
+      let i = !1;
+      const e = {};
+      return A(() => {
+        for (const r of s) {
+          if (!r.validate) continue;
+          const l = this.runValidator({
+            validate: r.validate,
+            value: {
+              value: this.state.values,
+              formApi: this,
+              validationSource: "form"
+            },
+            type: "validate"
+          }), { formError: n, fieldErrors: d } = k(l), h = j(r.cause), m = /* @__PURE__ */ new Set([
+            ...Object.keys(this.state.fieldMeta),
+            ...Object.keys(d || {})
+          ]);
+          for (const v of m) {
+            if (this.baseStore.state.fieldMetaBase[v] === void 0 && !d?.[v])
+              continue;
+            const S = this.getFieldMeta(v) ?? $, {
+              errorMap: M,
+              errorSourceMap: c
+            } = S, V = d?.[v], { newErrorValue: F, newSource: b } = q({
+              newFormValidatorError: V,
+              isPreviousErrorFromFormValidator: (
+                // These conditional checks are required, otherwise we get runtime errors.
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                c?.[h] === "form"
+              ),
+              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+              previousErrorValue: M?.[h]
+            });
+            b === "form" && (e[v] = {
+              ...e[v],
+              [h]: V
+            }), M?.[h] !== F && this.setFieldMeta(v, (g = $) => ({
+              ...g,
+              errorMap: {
+                ...g.errorMap,
+                [h]: F
+              },
+              errorSourceMap: {
+                ...g.errorSourceMap,
+                [h]: b
+              }
+            }));
+          }
+          this.state.errorMap?.[h] !== n && this.baseStore.setState((v) => ({
+            ...v,
+            errorMap: {
+              ...v.errorMap,
+              [h]: n
+            }
+          })), (n || d) && (i = !0);
+        }
+        const o = j("submit");
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        this.state.errorMap?.[o] && t !== "submit" && !i && this.baseStore.setState((r) => ({
+          ...r,
+          errorMap: {
+            ...r.errorMap,
+            [o]: void 0
+          }
+        }));
+        const a = j("server");
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        this.state.errorMap?.[a] && t !== "server" && !i && this.baseStore.setState((r) => ({
+          ...r,
+          errorMap: {
+            ...r.errorMap,
+            [a]: void 0
+          }
+        }));
+      }), { hasErrored: i, fieldsErrorMap: e };
+    }, this.validateAsync = async (t) => {
+      const s = Q(t, {
+        ...this.options,
+        form: this,
+        validationLogic: this.options.validationLogic || z
+      });
+      this.state.isFormValidating || this.baseStore.setState((r) => ({ ...r, isFormValidating: !0 }));
+      const i = [];
+      let e;
+      for (const r of s) {
+        if (!r.validate) continue;
+        const l = j(r.cause);
+        this.state.validationMetaMap[l]?.lastAbortController.abort();
+        const d = new AbortController();
+        this.state.validationMetaMap[l] = {
+          lastAbortController: d
+        }, i.push(
+          new Promise(async (h) => {
+            let m;
+            try {
+              m = await new Promise((c, V) => {
+                setTimeout(async () => {
+                  if (d.signal.aborted) return c(void 0);
+                  try {
+                    c(
+                      await this.runValidator({
+                        validate: r.validate,
+                        value: {
+                          value: this.state.values,
+                          formApi: this,
+                          validationSource: "form",
+                          signal: d.signal
+                        },
+                        type: "validateAsync"
+                      })
+                    );
+                  } catch (F) {
+                    V(F);
+                  }
+                }, r.debounceMs);
+              });
+            } catch (c) {
+              m = c;
+            }
+            const { formError: v, fieldErrors: S } = k(m);
+            S && (e = e ? {
+              ...e,
+              ...S
+            } : S);
+            const M = j(r.cause);
+            for (const c of Object.keys(
+              this.state.fieldMeta
+            )) {
+              if (this.baseStore.state.fieldMetaBase[c] === void 0)
+                continue;
+              const V = this.getFieldMeta(c);
+              if (!V) continue;
+              const {
+                errorMap: F,
+                errorSourceMap: b
+              } = V, g = e?.[c], { newErrorValue: I, newSource: L } = q({
+                newFormValidatorError: g,
+                isPreviousErrorFromFormValidator: (
+                  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                  b?.[M] === "form"
+                ),
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                previousErrorValue: F?.[M]
+              });
+              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+              F?.[M] !== I && this.setFieldMeta(c, (O) => ({
+                ...O,
+                errorMap: {
+                  ...O.errorMap,
+                  [M]: I
+                },
+                errorSourceMap: {
+                  ...O.errorSourceMap,
+                  [M]: L
+                }
+              }));
+            }
+            this.baseStore.setState((c) => ({
+              ...c,
+              errorMap: {
+                ...c.errorMap,
+                [M]: v
+              }
+            })), h(
+              e ? { fieldErrors: e, errorMapKey: M } : void 0
+            );
+          })
+        );
+      }
+      let o = [];
+      const a = {};
+      if (i.length) {
+        o = await Promise.all(i);
+        for (const r of o)
+          if (r?.fieldErrors) {
+            const { errorMapKey: l } = r;
+            for (const [n, d] of Object.entries(
+              r.fieldErrors
+            )) {
+              const m = {
+                ...a[n] || {},
+                [l]: d
+              };
+              a[n] = m;
+            }
+          }
+      }
+      return this.baseStore.setState((r) => ({
+        ...r,
+        isFormValidating: !1
+      })), a;
+    }, this.validate = (t) => {
+      const { hasErrored: s, fieldsErrorMap: i } = this.validateSync(t);
+      return s && !this.options.asyncAlways ? i : this.validateAsync(t);
+    }, this._handleSubmit = async (t) => {
+      this.baseStore.setState((e) => ({
+        ...e,
+        // Submission attempts mark the form as not submitted
+        isSubmitted: !1,
+        // Count submission attempts
+        submissionAttempts: e.submissionAttempts + 1,
+        isSubmitSuccessful: !1
+        // Reset isSubmitSuccessful at the start of submission
+      })), A(() => {
+        Object.values(this.fieldInfo).forEach(
+          (e) => {
+            e.instance && (e.instance.state.meta.isTouched || e.instance.setMeta((o) => ({ ...o, isTouched: !0 })));
+          }
+        );
+      });
+      const s = t ?? this.options.onSubmitMeta;
+      if (!this.state.canSubmit && !this._devtoolsSubmissionOverride) {
+        this.options.onSubmitInvalid?.({
+          value: this.state.values,
+          formApi: this,
+          meta: s
+        });
+        return;
+      }
+      this.baseStore.setState((e) => ({ ...e, isSubmitting: !0 }));
+      const i = () => {
+        this.baseStore.setState((e) => ({ ...e, isSubmitting: !1 }));
+      };
+      if (await this.validateAllFields("submit"), !this.state.isFieldsValid) {
+        i(), this.options.onSubmitInvalid?.({
+          value: this.state.values,
+          formApi: this,
+          meta: s
+        }), y.emit("form-submission", {
+          id: this._formId,
+          submissionAttempt: this.state.submissionAttempts,
+          successful: !1,
+          stage: "validateAllFields",
+          errors: Object.values(this.state.fieldMeta).map((e) => e.errors).flat()
+        });
+        return;
+      }
+      if (await this.validate("submit"), !this.state.isValid) {
+        i(), this.options.onSubmitInvalid?.({
+          value: this.state.values,
+          formApi: this,
+          meta: s
+        }), y.emit("form-submission", {
+          id: this._formId,
+          submissionAttempt: this.state.submissionAttempts,
+          successful: !1,
+          stage: "validate",
+          errors: this.state.errors
+        });
+        return;
+      }
+      A(() => {
+        Object.values(this.fieldInfo).forEach(
+          (e) => {
+            e.instance?.options.listeners?.onSubmit?.({
+              value: e.instance.state.value,
+              fieldApi: e.instance
+            });
+          }
+        );
+      }), this.options.listeners?.onSubmit?.({ formApi: this, meta: s });
+      try {
+        await this.options.onSubmit?.({
+          value: this.state.values,
+          formApi: this,
+          meta: s
+        }), A(() => {
+          this.baseStore.setState((e) => ({
+            ...e,
+            isSubmitted: !0,
+            isSubmitSuccessful: !0
+            // Set isSubmitSuccessful to true on successful submission
+          })), y.emit("form-submission", {
+            id: this._formId,
+            submissionAttempt: this.state.submissionAttempts,
+            successful: !0
+          }), i();
+        });
+      } catch (e) {
+        throw this.baseStore.setState((o) => ({
+          ...o,
+          isSubmitSuccessful: !1
+          // Ensure isSubmitSuccessful is false if an error occurs
+        })), y.emit("form-submission", {
+          id: this._formId,
+          submissionAttempt: this.state.submissionAttempts,
+          successful: !1,
+          stage: "inflight",
+          onError: e
+        }), i(), e;
+      }
+    }, this.getFieldValue = (t) => T(this.state.values, t), this.getFieldMeta = (t) => this.state.fieldMeta[t], this.getFieldInfo = (t) => this.fieldInfo[t] ||= {
+      instance: null,
+      validationMetaMap: {
+        onChange: void 0,
+        onBlur: void 0,
+        onSubmit: void 0,
+        onMount: void 0,
+        onServer: void 0,
+        onDynamic: void 0
+      }
+    }, this.setFieldMeta = (t, s) => {
+      this.baseStore.setState((i) => ({
+        ...i,
+        fieldMetaBase: {
+          ...i.fieldMetaBase,
+          [t]: X(
+            s,
+            i.fieldMetaBase[t]
+          )
+        }
+      }));
+    }, this.resetFieldMeta = (t) => Object.keys(t).reduce(
+      (s, i) => {
+        const e = i;
+        return s[e] = $, s;
+      },
+      {}
+    ), this.setFieldValue = (t, s, i) => {
+      const e = i?.dontUpdateMeta ?? !1, o = i?.dontRunListeners ?? !1, a = i?.dontValidate ?? !1;
+      A(() => {
+        e || this.setFieldMeta(t, (r) => ({
+          ...r,
+          isTouched: !0,
+          isDirty: !0,
+          errorMap: {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            ...r?.errorMap,
+            onMount: void 0
+          }
+        })), this.baseStore.setState((r) => ({
+          ...r,
+          values: _(r.values, t, s)
+        }));
+      }), o || this.getFieldInfo(t).instance?.triggerOnChangeListener(), a || this.validateField(t, "change");
+    }, this.deleteField = (t) => {
+      const i = [...Object.keys(this.fieldInfo).filter((e) => {
+        const o = t.toString();
+        return e !== o && e.startsWith(o);
+      }), t];
+      this.baseStore.setState((e) => {
+        const o = { ...e };
+        return i.forEach((a) => {
+          o.values = Y(o.values, a), delete this.fieldInfo[a], delete o.fieldMetaBase[a];
+        }), o;
+      });
+    }, this.pushFieldValue = (t, s, i) => {
+      this.setFieldValue(
+        t,
+        (e) => [...Array.isArray(e) ? e : [], s],
+        i
+      );
+    }, this.insertFieldValue = async (t, s, i, e) => {
+      this.setFieldValue(
+        t,
+        (a) => [
+          ...a.slice(0, s),
+          i,
+          ...a.slice(s)
+        ],
+        B(e, { dontValidate: !0 })
+      );
+      const o = e?.dontValidate ?? !1;
+      o || await this.validateField(t, "change"), P(this).handleArrayInsert(t, s), o || await this.validateArrayFieldsStartingFrom(t, s, "change");
+    }, this.replaceFieldValue = async (t, s, i, e) => {
+      this.setFieldValue(
+        t,
+        (a) => a.map(
+          (r, l) => l === s ? i : r
+        ),
+        B(e, { dontValidate: !0 })
+      ), (e?.dontValidate ?? !1) || (await this.validateField(t, "change"), await this.validateArrayFieldsStartingFrom(t, s, "change"));
+    }, this.removeFieldValue = async (t, s, i) => {
+      const e = this.getFieldValue(t), o = Array.isArray(e) ? Math.max(e.length - 1, 0) : null;
+      if (this.setFieldValue(
+        t,
+        (r) => r.filter(
+          (l, n) => n !== s
+        ),
+        B(i, { dontValidate: !0 })
+      ), P(this).handleArrayRemove(t, s), o !== null) {
+        const r = `${t}[${o}]`;
+        this.deleteField(r);
+      }
+      (i?.dontValidate ?? !1) || (await this.validateField(t, "change"), await this.validateArrayFieldsStartingFrom(t, s, "change"));
+    }, this.swapFieldValues = (t, s, i, e) => {
+      this.setFieldValue(
+        t,
+        (a) => {
+          const r = a[s], l = a[i];
+          return _(_(a, `${s}`, l), `${i}`, r);
+        },
+        B(e, { dontValidate: !0 })
+      ), P(this).handleArraySwap(t, s, i), (e?.dontValidate ?? !1) || (this.validateField(t, "change"), this.validateField(`${t}[${s}]`, "change"), this.validateField(`${t}[${i}]`, "change"));
+    }, this.moveFieldValues = (t, s, i, e) => {
+      this.setFieldValue(
+        t,
+        (a) => {
+          const r = [...a];
+          return r.splice(i, 0, r.splice(s, 1)[0]), r;
+        },
+        B(e, { dontValidate: !0 })
+      ), P(this).handleArrayMove(t, s, i), (e?.dontValidate ?? !1) || (this.validateField(t, "change"), this.validateField(`${t}[${s}]`, "change"), this.validateField(`${t}[${i}]`, "change"));
+    }, this.clearFieldValues = (t, s) => {
+      const i = this.getFieldValue(t), e = Array.isArray(i) ? Math.max(i.length - 1, 0) : null;
+      if (this.setFieldValue(
+        t,
+        [],
+        B(s, { dontValidate: !0 })
+      ), e !== null)
+        for (let a = 0; a <= e; a++) {
+          const r = `${t}[${a}]`;
+          this.deleteField(r);
+        }
+      (s?.dontValidate ?? !1) || this.validateField(t, "change");
+    }, this.resetField = (t) => {
+      this.baseStore.setState((s) => ({
+        ...s,
+        fieldMetaBase: {
+          ...s.fieldMetaBase,
+          [t]: $
+        },
+        values: this.options.defaultValues ? _(s.values, t, T(this.options.defaultValues, t)) : s.values
+      }));
+    }, this.setErrorMap = (t) => {
+      A(() => {
+        Object.entries(t).forEach(([s, i]) => {
+          const e = s;
+          if (W(i)) {
+            const { formError: o, fieldErrors: a } = k(i);
+            for (const r of Object.keys(
+              this.fieldInfo
+            ))
+              this.getFieldMeta(r) && this.setFieldMeta(r, (n) => ({
+                ...n,
+                errorMap: {
+                  ...n.errorMap,
+                  [e]: a?.[r]
+                },
+                errorSourceMap: {
+                  ...n.errorSourceMap,
+                  [e]: "form"
+                }
+              }));
+            this.baseStore.setState((r) => ({
+              ...r,
+              errorMap: {
+                ...r.errorMap,
+                [e]: o
+              }
+            }));
+          } else
+            this.baseStore.setState((o) => ({
+              ...o,
+              errorMap: {
+                ...o.errorMap,
+                [e]: i
+              }
+            }));
+        });
+      });
+    }, this.getAllErrors = () => ({
+      form: {
+        errors: this.state.errors,
+        errorMap: this.state.errorMap
+      },
+      fields: Object.entries(this.state.fieldMeta).reduce(
+        (t, [s, i]) => (Object.keys(i).length && i.errors.length && (t[s] = {
+          errors: i.errors,
+          errorMap: i.errorMap
+        }), t),
+        {}
+      )
+    }), this.parseValuesWithSchema = (t) => U.validate(
+      { value: this.state.values, validationSource: "form" },
+      t
+    ), this.parseValuesWithSchemaAsync = (t) => U.validateAsync(
+      { value: this.state.values, validationSource: "form" },
+      t
+    ), this.timeoutIds = {
+      validations: {},
+      listeners: {},
+      formListeners: {}
+    }, this._formId = p?.formId ?? Z(), this._devtoolsSubmissionOverride = !1, this.baseStore = new G(
+      R({
+        ...p?.defaultState,
+        values: p?.defaultValues ?? p?.defaultState?.values
+      })
+    ), this.fieldMetaDerived = new N({
+      deps: [this.baseStore],
+      fn: ({ prevDepVals: t, currDepVals: s, prevVal: i }) => {
+        const e = i, o = t?.[0], a = s[0];
+        let r = 0;
+        const l = {};
+        for (const n of Object.keys(
+          a.fieldMetaBase
+        )) {
+          const d = a.fieldMetaBase[n], h = o?.fieldMetaBase[n], m = e?.[n], v = T(a.values, n);
+          let S = m?.errors;
+          if (!h || d.errorMap !== h.errorMap) {
+            S = Object.values(d.errorMap ?? {}).filter(
+              (b) => b !== void 0
+            );
+            const F = this.getFieldInfo(n)?.instance;
+            (!F || !F.options.disableErrorFlat) && (S = S.flat(1));
+          }
+          const M = !x(S), c = !d.isDirty, V = w(
+            v,
+            T(this.options.defaultValues, n)
+          ) || w(
+            v,
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            this.getFieldInfo(n)?.instance?.options.defaultValue
+          );
+          if (m && m.isPristine === c && m.isValid === M && m.isDefaultValue === V && m.errors === S && d === h) {
+            l[n] = m, r++;
+            continue;
+          }
+          l[n] = {
+            ...d,
+            errors: S ?? [],
+            isPristine: c,
+            isValid: M,
+            isDefaultValue: V
+          };
+        }
+        return Object.keys(a.fieldMetaBase).length && e && r === Object.keys(a.fieldMetaBase).length ? e : l;
+      }
+    }), this.store = new N({
+      deps: [this.baseStore, this.fieldMetaDerived],
+      fn: ({ prevDepVals: t, currDepVals: s, prevVal: i }) => {
+        const e = i, o = t?.[0], a = s[0], r = s[1], l = Object.values(r).filter(
+          Boolean
+        ), n = l.some(
+          (u) => u.isValidating
+        ), d = l.every((u) => u.isValid), h = l.some((u) => u.isTouched), m = l.some((u) => u.isBlurred), v = l.every(
+          (u) => u.isDefaultValue
+        ), S = (
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          h && a.errorMap?.onMount
+        ), M = l.some((u) => u.isDirty), c = !M, V = !!// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        (a.errorMap?.onMount || // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        l.some((u) => u?.errorMap?.onMount)), F = !!n;
+        let b = e?.errors ?? [];
+        (!o || a.errorMap !== o.errorMap) && (b = Object.values(a.errorMap).reduce((u, E) => E === void 0 ? u : E && W(E) ? (u.push(E.form), u) : (u.push(E), u), []));
+        const g = b.length === 0, I = d && g, L = this.options.canSubmitWhenInvalid ?? !1, O = a.submissionAttempts === 0 && !h && !V || !F && !a.isSubmitting && I || L;
+        let D = a.errorMap;
+        if (S && (b = b.filter(
+          (u) => u !== a.errorMap.onMount
+        ), D = Object.assign(D, { onMount: void 0 })), e && o && e.errorMap === D && e.fieldMeta === this.fieldMetaDerived.state && e.errors === b && e.isFieldsValidating === n && e.isFieldsValid === d && e.isFormValid === g && e.isValid === I && e.canSubmit === O && e.isTouched === h && e.isBlurred === m && e.isPristine === c && e.isDefaultValue === v && e.isDirty === M && w(o, a))
+          return e;
+        let K = {
+          ...a,
+          errorMap: D,
+          fieldMeta: this.fieldMetaDerived.state,
+          errors: b,
+          isFieldsValidating: n,
+          isFieldsValid: d,
+          isFormValid: g,
+          isValid: I,
+          canSubmit: O,
+          isTouched: h,
+          isBlurred: m,
+          isPristine: c,
+          isDefaultValue: v,
+          isDirty: M
+        };
+        const C = this.options.transform?.deps ?? [];
+        if (C.length !== this.prevTransformArray.length || C.some((u, E) => u !== this.prevTransformArray[E])) {
+          const u = Object.assign({}, this, { state: K });
+          this.options.transform?.fn(u), K = u.state, this.prevTransformArray = C;
+        }
+        return K;
+      }
+    }), this.handleSubmit = this.handleSubmit.bind(this), this.update(p || {});
+  }
+  get state() {
+    return this.store.state;
+  }
+  get formId() {
+    return this._formId;
+  }
+  /**
+   * @private
+   */
+  runValidator(p) {
+    return tt(p.validate) ? U[p.type](
+      p.value,
+      p.validate
+    ) : p.validate(p.value);
+  }
+  handleSubmit(p) {
+    return this._handleSubmit(p);
+  }
+}
+function k(f) {
+  if (f) {
+    if (W(f)) {
+      const p = k(f.form).formError, t = f.fields;
+      return { formError: p, fieldErrors: t };
+    }
+    return { formError: f };
+  }
+  return { formError: void 0 };
+}
+function j(f) {
+  switch (f) {
+    case "submit":
+      return "onSubmit";
+    case "blur":
+      return "onBlur";
+    case "mount":
+      return "onMount";
+    case "server":
+      return "onServer";
+    case "dynamic":
+      return "onDynamic";
+    default:
+      return "onChange";
+  }
+}
+export {
+  ut as FormApi
+};