@paragrav/rhf-utils 0.0.137 → 0.0.139

package/README.md

@@ -22,10 +22,9 @@ Integration and utility library for [react-hook-form](https://www.react-hook-for
     - schema-typed Controller component and FormSubmitError class
 - simpler/flatter `FieldErrors` structure (`FlatFieldErrors`)
   - context groups errors into `all`, `fields`, `roots`, and `orphans` (`useFlatFieldErrorsContext`)
-  - `RhfUtilsFieldErrorMessage` for displaying error message
 - safer `FieldValues` type (`SafeFieldValues`)
 - `zod` support, including input/output types for transformations
-- ~3.9kB min+gzip (excluding [peer dependencies](#peer-dependencies))
+- ~3.6kB min+gzip (excluding [peer dependencies](#peer-dependencies))
 
 ## Install
 
@@ -37,13 +36,13 @@ yarn add @paragrav/rhf-utils     # yarn
 
 ## Quick Start
 
-- 🔗 [Config](#config) (`RhfUtilsClientConfig`): define your desired global config (optional)
+- 🔗 [Config](#config) (`RhfUtilsClientConfig`): define your global config (optional)
 - 🔗 [Provider](#provider) (`RhfUtilsClientForZodContextProvider`): add to your global stack
-- 🔗 [Form](#form) (`RhfUtilsZodForm`): use for your forms
+- 🔗 [Form](#form) (`RhfUtilsZodForm`): use as form component
 
 ## Config
 
-Create a config (`RhfUtilsClientConfig`) object with desired global and default options. This is global configuration across all forms, some of which can be overridden at the form level.
+Create a config (`RhfUtilsClientConfig`) object with desired global config and default options. Config applies across all forms, and defaults can be overridden per form.
 
 ```tsx
 export const rhfUtilsClientConfig: RhfUtilsClientConfig = {
@@ -57,7 +56,7 @@ export const rhfUtilsClientConfig: RhfUtilsClientConfig = {
     // RhfUtilsFormOptions (see further below)
     utils: {
       stopSubmitPropagation: true,
-      devTool: import.meta.env.DEV,
+      devTool: import.meta.env.DEV && { placement: 'top-right' },
     },
 
     // default form props
@@ -189,7 +188,7 @@ Currently, only `zod` is supported.
           <label>
             Email
             <input {...field} disabled={isSubmitting} />
-            <RhfUtilsFieldErrorMessage path={field.name} />
+            <ErrorMessage path={field.name} />
           </label>
         )}
       />
@@ -292,7 +291,7 @@ type RhfUtilsFormOptions = {
   };
 
   /** Control dev tool options. (Lazy-loaded when truthy value supplied.) */
-  devTool?: true | Pick<DevtoolUIProps, 'placement' | 'styles'>;
+  devTool?: boolean | Pick<DevtoolUIProps, 'placement' | 'styles'>;
 };
 ```
 
@@ -323,7 +322,7 @@ declare module '@paragrav/rhf-utils' {
 
 `FlatFieldErrors` type is a flattened, simplified version of RHF's `FieldErrors`. Keys represent flattened, dot-notation field paths.
 
-Use `useFlatFieldErrorsContext()` hook, which returns an object with errors grouped by `all`, `fields`, `roots`, `orphans` records, and `hasErrors` and `hasErrors` and `hasOrphans` booleans.
+Use `useFlatFieldErrorsContext()` hook, which returns an object with errors grouped by `all`, `fields`, `roots`, `orphans` records, and boolean values for `hasErrors` and `hasOrphans`.
 
 ### Output
 
@@ -337,7 +336,7 @@ Programatically, an "orphan" is any form state error that meets ALL of the follo
 
 - non-field -- i.e., no RHF-supplied `ref` on `FieldError` object
 - non-root -- i.e., not `root` or `root.${string}` path
-- no corresponding "marker" in DOM (i.e., `FormNonFieldErrorMarker`)
+- no corresponding "marker" in DOM (i.e., `RhfUtilsNonFieldErrorMarker`)
 
 This is because:
 
@@ -345,7 +344,7 @@ This is because:
 - root errors (non-field, without `ref`s) are assumed to always be listed for display
 - all other errors must be marked as displayed to distinguish from being an orphan
 
-_See [FormNonFieldErrorMarker](#formnonfielderrormarker) section below for more information about when and why marker is needed._
+_See [RhfUtilsNonFieldErrorMarker](#rhfutilsnonfielderrormarker) section below for more information about when and why marker is needed._
 
 #### Using orphan errors
 
@@ -358,11 +357,11 @@ Detected orphans can be accessed via any of the following:
   - returns an object with list of errors grouped by `all`, `fields` (with `ref`), `roots`, `orphans` records, and includes computed booleans `hasErrors` and `hasOrphans`
 - boolean value from `useFlatFieldErrorsContextHasOnlyOrphans`
 
-### FormNonFieldErrorMarker
+### RhfUtilsNonFieldErrorMarker
 
 _If you don't need orphan detection, you can skip this section. By default, orphan detection still occurs but doesn't otherwise do anything._
 
-To get accurate orphan detection, you must use `FormNonFieldErrorMarker` when displaying any non-root non-field errors. (Example further below.)
+To get accurate orphan detection, you must use `RhfUtilsNonFieldErrorMarker` when displaying any non-root non-field errors. (Example further below.)
 
 There is little harm in including it consistently for all individual errors displayed. (DOM traversal to find marker only occurs if error is non-field AND non-root, which is not typical.)
 
@@ -372,21 +371,15 @@ A typical example is a field array with a required minimum number of items -- e.
 
 When there are zero items, the error is non-field and non-root. You would probably display this error (manually) near the field array, using something like RHF's [`ErrorMessage`](https://www.react-hook-form.com/api/useformstate/errormessage/) component.
 
-In order to NOT detect this as an orphan, it must be explicitly "marked" as displayed using `FormNonFieldErrorMarker`.
+In order to NOT detect this as an orphan, it must be explicitly "marked" as displayed using `RhfUtilsNonFieldErrorMarker`.
 
-You can incorporate `FormNonFieldErrorMarker` into your own component library, or use this library's `RhfUtilsFieldErrorMessage` to display error message to user, which includes this marker.
+You should incorporate `RhfUtilsNonFieldErrorMarker` into your own component library's error message display component.
 
 ```tsx
-<RhfUtilsFieldErrorMessage path="items" />
+<RhfUtilsNonFieldErrorMarker path="items" />
 ```
 
-Uncommon, but if you are ONLY listing a summary of all errors, without individual displays, you will need to use the marker manually.
-
-```tsx
-<FormNonFieldErrorMarker path="items" />
-```
-
-_If you include the marker for error lists, it will defeat the purpose of the marker. Only use marker for individual errors._
+_If you include the marker in bulk error lists, it will defeat the purpose of the marker. Only use marker for individual errors. Therefore, if you are ONLY listing a summary of all errors, without individual displays, you will need to use the marker manually._
 
 ## Form Groups
 
@@ -424,7 +417,7 @@ This library uses `SafeFieldValues` type which uses `unknown` instead of `any`.
 - [react](https://www.npmjs.com/package/react)
 - [react-dom](https://www.npmjs.com/package/react-dom)
 - [react-hook-form](https://www.npmjs.com/package/react-hook-form)
-- [zod](https://www.npmjs.com/package/zod)
-- [flat](https://www.npmjs.com/package/flat)
 - [@hookform/resolvers](https://www.npmjs.com/package/@hookform/resolvers)
 - [@hookform/devtools](https://www.npmjs.com/package/@hookform/devtools) (optional)
+- [zod](https://www.npmjs.com/package/zod)
+- [flat](https://www.npmjs.com/package/flat) _(805B min+gzip)_

package/dist/esm/{utils/createContext.mjs → createContext-Jzs0Nsql.js}

@@ -12,5 +12,5 @@ function i() {
   };
 }
 export {
-  i as default
+  i as c
 };

package/dist/esm/exports.mjs

@@ -1,46 +1,485 @@
-import { default as e } from "./client/zod/context/RhfUtilsClientForZodContextProvider.mjs";
-import { default as s } from "./client/zod/context/RhfUtilsZodForm.mjs";
-import { default as u } from "./client/zod/context/useRhfUtilsZodForm.mjs";
-import { default as m } from "./errors/flat/context/useFlatFieldErrorsContext.mjs";
-import { default as d } from "./errors/flat/context/useFlatFieldErrorsContextHasOnlyOrphans.mjs";
-import { default as x } from "./errors/message/RhfUtilsFieldErrorMessage.mjs";
-import { default as F } from "./errors/nonfield/FormNonFieldErrorMarker.mjs";
-import { default as C } from "./errors/root/RootErrorsListFromFlatFieldErrorsContext.mjs";
-import { default as R } from "./form/context/utils/useRhfUtilsContext.mjs";
-import { default as E } from "./form/context/utils/useRhfUtilsContextRequestSubmit.mjs";
-import { default as I } from "./form/context/group/FormGroupContextProvider.mjs";
-import { default as b } from "./form/context/group/useFormGroupChildIsMountedTracker.mjs";
-import { default as B } from "./form/context/group/useFormGroupChildIsSubmittingTracker.mjs";
-import { default as S } from "./form/context/group/useFormGroupChildTracker.mjs";
-import { default as T } from "./form/context/group/useFormGroupIsAnyBusy.mjs";
-import { default as M } from "./form/context/group/useFormGroupIsChildBusy.mjs";
-import { default as Z } from "./form/context/group/useFormGroupIsParentBusy.mjs";
-import { default as v } from "./form/context/group/useFormGroupParentTracker.mjs";
-import { default as D } from "./form/context/group/useFormOrParentIsBusy.mjs";
-import { default as L } from "./form/utils/getSubmitterButtonData.mjs";
-import { default as j } from "./form/utils/useFormRequestSubmit.mjs";
-import { FormSubmitError as z } from "./submit/error/FormSubmitError.mjs";
+import { jsx as u, Fragment as $, jsxs as q } from "react/jsx-runtime";
+import a from "react";
+import { c as C } from "./createContext-Jzs0Nsql.js";
+import { zodResolver as B } from "@hookform/resolvers/zod";
+import { useFormContext as E, Controller as I, get as L, useFormState as S, FormProvider as z, useForm as H } from "react-hook-form";
+import { flatten as A } from "flat";
+const {
+  Provider: Q,
+  useMaybe: g
+} = C(), G = a.lazy(
+  () => import("@hookform/devtools").then((r) => ({
+    default: r.DevTool
+  }))
+), J = ({ enabled: r, props: t }) => {
+  if (!r) return null;
+  const { control: e } = E();
+  return /* @__PURE__ */ u(a.Suspense, { fallback: null, children: /* @__PURE__ */ u(G, { control: e, ...t }) });
+};
+class F extends Error {
+  constructor(t, e) {
+    super(e), this.errors = t;
+  }
+}
+const K = (r, t) => {
+  Object.entries(t).forEach(([e, o]) => {
+    r.setError(e, {
+      type: "FormSubmitFieldError",
+      // default
+      ...o
+    });
+  });
+}, X = ({
+  children: r
+}) => /* @__PURE__ */ u($, { children: r });
+function Y(r) {
+  return /* @__PURE__ */ u(I, { ...r });
+}
+function rr({
+  formId: r,
+  formRef: t,
+  //
+  onSubmit: e,
+  onSubmitError: o,
+  onSubmitInvalid: s,
+  Children: n,
+  //
+  form: i,
+  utils: l
+}) {
+  const h = E(), d = g(), c = async (m) => {
+    l != null && l.stopSubmitPropagation && m.stopPropagation();
+    try {
+      await h.handleSubmit(v, s)(m);
+    } catch (f) {
+      R(f, m);
+    }
+  }, v = (m, f) => e == null ? void 0 : e(
+    m,
+    {
+      formId: r,
+      formRef: t,
+      context: h,
+      utils: l,
+      FormSubmitError: F
+    },
+    f
+  ), R = (m, f) => {
+    var O;
+    const P = m instanceof F ? (
+      // consumer can manually throw FormSubmitError (e.g., manual validation)
+      m.errors
+    ) : (
+      // if error is not FormSubmitError, consumer can provide global handler
+      (O = d == null ? void 0 : d.onSubmitErrorUnknown) == null ? void 0 : O.call(d, m)
+    );
+    P && K(h, P), o == null || o(
+      m,
+      {
+        formId: r,
+        formRef: t,
+        context: h,
+        utils: l
+      },
+      f
+    );
+  }, p = {
+    formId: r,
+    formRef: t,
+    context: h,
+    utils: l,
+    Controller: Y,
+    FormSubmitError: F
+  }, Z = p, D = (d == null ? void 0 : d.FormComponent) ?? "form", V = (d == null ? void 0 : d.FormChildrenWrapper) ?? X;
+  return /* @__PURE__ */ u(
+    D,
+    {
+      ...i,
+      ref: t,
+      onSubmit: (m) => void c(m),
+      children: /* @__PURE__ */ q(V, { ...Z, children: [
+        /* @__PURE__ */ u(
+          J,
+          {
+            enabled: !!(l != null && l.devTool),
+            props: typeof (l == null ? void 0 : l.devTool) == "object" ? l.devTool : void 0
+          }
+        ),
+        /* @__PURE__ */ u(n, { ...p })
+      ] })
+    }
+  );
+}
+const b = (r) => (t) => (
+  // re-create object from entries
+  Object.fromEntries(
+    // break down to entries
+    Object.entries(t).filter(r)
+  )
+), k = (r) => !!r.ref, er = ([, r]) => k(r), tr = b(
+  er
+), y = (r) => Object.keys(r).length === 0, _ = "data-rhfutils-nonfield-error-marker-path", or = (r, t) => (
+  // list of selector variants
+  [
+    // equals
+    // e.g., attr="path"
+    ["", ""],
+    [
+      // @see https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors#attrvalue_4
+      "^",
+      // only match nested (avoid match 'field' with 'field1`)
+      "."
+    ]
+  ].map(
+    ([e, o]) => sr(
+      _ + e,
+      r + o
+    )
+  ).join(", ")
+), sr = (r, t) => `[role="alert"][${r}="${t}"]`, nr = (r, t) => !!t.querySelector(
+  or(r)
+), U = "root", W = (r) => r === U || r.startsWith(U + "."), lr = (r, t, e) => (
+  // non-field
+  !k(t) && // non-root
+  !W(r) && // not marked in DOM
+  !nr(r, e)
+), ir = (r) => ([t, e]) => lr(t, e, r), ur = (r, t) => b(
+  ir(t)
+)(r), dr = ([r]) => W(r), ar = b(
+  dr
+), hr = (r) => A(r), mr = (r) => {
+  const t = hr(r), e = Object.keys(t);
+  return Object.fromEntries(
+    e.reduce(
+      (o, s) => {
+        const n = s.replace(
+          cr,
+          ""
+        );
+        if (n === s) return o;
+        const i = L(r, n, void 0);
+        return i && o.push([n, i]), o;
+      },
+      []
+      // entries
+    )
+  );
+}, cr = /\.(?:type|message)\b$/, {
+  Provider: fr,
+  useRequired: Fr
+} = C(), j = Fr, Cr = ({
+  formRef: r,
+  children: t
+}) => {
+  const { errors: e } = S(), o = mr(e), s = r.current ? ur(o, r.current) : {}, n = {
+    all: o,
+    fields: tr(o),
+    roots: ar(o),
+    orphans: s,
+    // computed
+    hasErrors: !y(e),
+    hasOrphans: !y(s)
+  };
+  return /* @__PURE__ */ u(fr, { value: n, children: t });
+}, Er = (r, t, e, o = "debug") => {
+  console[o](r, { values: t, errors: e });
+}, br = (r) => {
+  const t = E(), e = j();
+  a.useEffect(() => {
+    var n, i;
+    if (!e.hasErrors) return;
+    const o = (n = r == null ? void 0 : r.console) == null ? void 0 : n.call(r, e);
+    o && Er(
+      o.message ?? x,
+      t.getValues(),
+      e,
+      o.type
+    );
+    const s = (i = r == null ? void 0 : r.throw) == null ? void 0 : i.call(r, e);
+    if (s)
+      throw new Error(typeof s == "string" ? s : x);
+  }, [e]);
+}, x = "Form errors", vr = (r) => {
+  const t = a.useRef(!1);
+  a.useEffect(() => {
+    r && (t.current = !0);
+  }, [r]);
+  const e = () => {
+    t.current = !1;
+  };
+  return [t.current, e];
+}, Rr = (r, t) => {
+  const { isSubmitSuccessful: e, isSubmitting: o } = S(), [s, n] = vr(o);
+  a.useEffect(() => {
+    r && (o || s && (n(), r(e)));
+  }, [o]);
+}, pr = (r) => {
+  const { getValues: t, reset: e } = E();
+  Rr((o) => {
+    var l;
+    if (!r) return;
+    const s = (l = r[o ? "success" : "error"]) == null ? void 0 : l.values;
+    if (!s) return;
+    const n = s === "current", i = n ? t() : void 0;
+    e(i, {
+      // keep submit stuff for tracking relevant state (e.g., `useFormOnSubmitSuccessful`)
+      keepIsSubmitSuccessful: !0,
+      keepIsSubmitted: !0,
+      keepSubmitCount: !0,
+      /**
+       * This is necessary when setting default values to current values (lest form stop updating).
+       *
+       * Technically, we are keeping values and resetting default values to same values.
+       *
+       * Steps to repro:
+       * - RhfUtilsClientConfig with resetOnSubmitted set to success values to current
+       * - remove `keepValues` prop from reset
+       * - create valid form, submit
+       * - form values should be unchanged
+       * - unexpectedly: can no longer type into input
+       */
+      keepValues: n,
+      // keep errors in the case of unsuccessful submit
+      keepErrors: !0
+    });
+  });
+}, Pr = (r) => a.useCallback(
+  (t) => {
+    if (!r.current) throw new Error();
+    Or(r.current, t);
+  },
+  [r]
+), Or = (r, t) => {
+  r.requestSubmit(t);
+}, yr = ({
+  onChange: r,
+  delay: t
+}) => {
+  const e = a.useRef(), o = () => {
+    e.current && (r(e.current.value), e.current = void 0);
+  }, s = () => {
+    e.current && clearTimeout(e.current.timer);
+  };
+  return a.useEffect(
+    // return timeout clearer
+    () => s,
+    []
+  ), [(i) => {
+    s(), e.current = {
+      // value being tracked
+      value: i,
+      // new timer
+      timer: setTimeout(o, t)
+    };
+  }];
+}, Ur = (r, t) => {
+  const e = !(t != null && t.disabled), o = Pr(r), [s] = yr({
+    // on change value after debounce
+    onChange: () => {
+      o();
+    },
+    delay: (t == null ? void 0 : t.debounce) ?? 0
+  });
+  a.useEffect(() => {
+    if (!e) return;
+    const n = r.current;
+    if (!n) throw new Error();
+    const i = (l) => {
+      s(l);
+    };
+    return n.addEventListener("change", i), () => {
+      n.removeEventListener("change", i);
+    };
+  }, []);
+}, { Provider: xr, useRequired: Sr } = C(), gr = Sr, Hr = gr, kr = ({
+  formId: r,
+  formRef: t,
+  options: e,
+  children: o
+}) => {
+  var n;
+  const s = g();
+  return br((n = s == null ? void 0 : s.fieldErrors) == null ? void 0 : n.output), Ur(t, {
+    // check for false/undefined
+    disabled: ((e == null ? void 0 : e.submitOnChange) ?? !1) === !1,
+    debounce: typeof (e == null ? void 0 : e.submitOnChange) == "number" ? e.submitOnChange : void 0
+  }), pr(e == null ? void 0 : e.resetOnSubmitted), /* @__PURE__ */ u(xr, { value: { formId: r, formRef: t, options: e }, children: o });
+};
+function _r({
+  formId: r,
+  formRef: t,
+  rhfForm: e,
+  utils: o,
+  children: s
+}) {
+  return /* @__PURE__ */ u(z, { ...e, children: /* @__PURE__ */ u(Cr, { formRef: t, children: /* @__PURE__ */ u(
+    kr,
+    {
+      formId: r,
+      formRef: t,
+      options: o,
+      children: s
+    }
+  ) }) });
+}
+const w = ({
+  defaultValues: r,
+  onSubmit: t,
+  onSubmitError: e,
+  onSubmitInvalid: o,
+  Children: s,
+  rhf: n,
+  form: i,
+  utils: l
+}) => {
+  const h = a.useId(), d = H({
+    ...n,
+    defaultValues: r
+  }), c = a.useRef(null);
+  return {
+    id: h,
+    ref: c,
+    context: d,
+    providerProps: {
+      formId: h,
+      formRef: c,
+      rhfForm: d,
+      utils: l
+    },
+    formProps: {
+      Children: s,
+      onSubmit: t,
+      onSubmitError: e,
+      onSubmitInvalid: o,
+      formId: h,
+      formRef: c,
+      form: i,
+      utils: l
+    },
+    FormSubmitError: F
+  };
+};
+function M(r) {
+  const t = w(r);
+  return /* @__PURE__ */ u(_r, { ...t.providerProps, children: /* @__PURE__ */ u(rr, { ...t.formProps }) });
+}
+const Wr = (r, ...t) => (
+  // sequentially merge each set of props into defaults
+  t.reduce(
+    (e, o) => {
+      var s, n, i, l, h, d;
+      return {
+        rhf: {
+          ...e == null ? void 0 : e.rhf,
+          ...o.rhf
+        },
+        utils: {
+          ...e == null ? void 0 : e.utils,
+          ...o.utils,
+          // manual merges
+          // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- false positive
+          ...(((s = e == null ? void 0 : e.utils) == null ? void 0 : s.resetOnSubmitted) || ((n = o.utils) == null ? void 0 : n.resetOnSubmitted)) && {
+            resetOnSubmitted: {
+              ...(i = e == null ? void 0 : e.utils) == null ? void 0 : i.resetOnSubmitted,
+              ...(l = o.utils) == null ? void 0 : l.resetOnSubmitted
+            }
+          }
+        },
+        form: {
+          ...e == null ? void 0 : e.form,
+          ...o.form,
+          // manual merges
+          className: [(h = e == null ? void 0 : e.form) == null ? void 0 : h.className, (d = o.form) == null ? void 0 : d.className].filter(Boolean).join(" ") || void 0
+          // stringify (replace empty string with undefined)
+        }
+      };
+    },
+    // start with defaults
+    r
+  )
+), jr = (r) => (t) => {
+  const e = T(r, t);
+  return {
+    useForm: (o, s) => {
+      const n = e(o, s);
+      return {
+        ...w(n),
+        FormWithProviders: () => /* @__PURE__ */ u(M, { ...n })
+      };
+    },
+    FormWithProviders: wr(r, t)
+  };
+}, T = (r, t) => function(o, s) {
+  return {
+    ...s,
+    ...Wr(
+      t.defaults,
+      s,
+      {
+        rhf: {
+          resolver: r(o)
+        }
+      }
+    )
+  };
+}, wr = (r, t) => {
+  const e = T(r, t);
+  return function({
+    schema: s,
+    children: n,
+    ...i
+  }) {
+    return /* @__PURE__ */ u(
+      M,
+      {
+        ...e(s, i),
+        children: n
+      }
+    );
+  };
+}, Mr = jr(B), {
+  Provider: Tr,
+  useRequired: N
+} = C(), Nr = ({
+  config: r,
+  children: t
+}) => {
+  const [e] = a.useState(r), [o] = a.useState(
+    () => Mr(e ?? {})
+  );
+  return /* @__PURE__ */ u(Q, { value: e, children: /* @__PURE__ */ u(Tr, { value: o, children: t }) });
+}, Ar = Nr;
+function Qr({
+  schema: r,
+  ...t
+}) {
+  const { FormWithProviders: e } = N();
+  return /* @__PURE__ */ u(e, { schema: r, ...t });
+}
+const Zr = (r, t) => N().useForm(r, t), Gr = Zr, Dr = () => {
+  const r = j();
+  return a.useMemo(() => !r.hasErrors || !r.hasOrphans ? !1 : Object.keys(r.orphans).length === Object.keys(r.all).length, [r]);
+}, Jr = Dr, Vr = ({ path: r }) => {
+  const t = {
+    [_]: r
+  };
+  return /* @__PURE__ */ u(
+    "div",
+    {
+      role: "alert",
+      "aria-hidden": "true",
+      style: { display: "none" },
+      ...t
+    }
+  );
+}, Kr = Vr;
 export {
-  I as FormGroupContextProvider,
-  F as FormNonFieldErrorMarker,
-  z as FormSubmitError,
-  e as RhfUtilsClientForZodContextProvider,
-  x as RhfUtilsFieldErrorMessage,
-  s as RhfUtilsZodForm,
-  C as RootErrorsListFromFlatFieldErrorsContext,
-  L as getSubmitterButtonData,
-  m as useFlatFieldErrorsContext,
-  d as useFlatFieldErrorsContextHasOnlyOrphans,
-  b as useFormGroupChildIsMountedTracker,
-  B as useFormGroupChildIsSubmittingTracker,
-  S as useFormGroupChildTracker,
-  T as useFormGroupIsAnyBusy,
-  M as useFormGroupIsChildBusy,
-  Z as useFormGroupIsParentBusy,
-  v as useFormGroupParentTracker,
-  D as useFormOrParentIsBusy,
-  j as useFormRequestSubmit,
-  R as useRhfUtilsContext,
-  E as useRhfUtilsContextRequestSubmit,
-  u as useRhfUtilsZodForm
+  F as FormSubmitError,
+  Ar as RhfUtilsClientForZodContextProvider,
+  Kr as RhfUtilsNonFieldErrorMarker,
+  Qr as RhfUtilsZodForm,
+  j as useFlatFieldErrorsContext,
+  Jr as useFlatFieldErrorsContextHasOnlyOrphans,
+  Hr as useRhfUtilsContext,
+  Gr as useRhfUtilsZodForm
 };