@paragrav/rhf-utils 0.0.112 → 0.0.114

package/README.md

@@ -34,12 +34,11 @@ export const rhfUtilsClientConfig: RhfUtilsClientConfig = {
   FormComponent: Form.Root,
 
   // transform backend error
-  // use `getOnSubmitTrpcClientErrorHandler` HOF for TRPC backends
-  onSubmitError: (
+  onUnknownSubmitError: (
     error, // unknown
   ) => {
     // if other error, re-throw to handle in ErrorBoundary
-    if (!(error instanceof ServerError)) throw error;
+    if (!(error instanceof MyServerError)) throw error;
 
     // return to be merged into RHF context errors
     return transformServerErrorToFormSubmitErrors(error);
@@ -49,11 +48,12 @@ export const rhfUtilsClientConfig: RhfUtilsClientConfig = {
     top: (
       // UseRhfUtilsFormChildrenProps
       {
-        formId, //     unique id string
-        formRef, //    ref
-        context, //    rhf UseFormReturn
-        options, //    RhfUtilsFormOptions
-        Controller, // strongly-typed controller
+        formId, //          unique id string
+        formRef, //         ref
+        context, //         rhf UseFormReturn
+        options, //         RhfUtilsFormOptions
+        Controller, //      strongly-typed controller
+        FormSubmitError, // strongly-typed error class
       },
     ) => {
       // navigation blocker (using custom option)
@@ -74,7 +74,7 @@ export const rhfUtilsClientConfig: RhfUtilsClientConfig = {
     output: {
       // callback to determine when to output form context errors to console ("debug" or "error")
       console: ({ isDevelopment, hasOrphans }) =>
-        (hasOrphans && { type: 'error' }) || // report orphan errors early
+        (hasOrphans && { type: 'error' }) || // report all orphan errors
         (isDevelopment && { type: 'debug' }), // facilitate debugging on dev
 
       // callback to determine when to throw an error based on context
@@ -105,14 +105,18 @@ Currently, only `zod` is supported.
     email: '',
   }}
   // submit handler
-  onSubmit={async (data) => {
+  onSubmit={async (
+    data, //    schema output
+    context, // UseRhfUtilsFormOnSubmitContext (form id, form ref, context (rhf), utils options, strongly-typed FormSubmitError class)
+    event, //   SubmitEvent
+  ) => {
     await authLoginService(data);
     onSuccess();
   }}
   // handle error declaratively (i.e., no throw/catch)
   onSubmitError={({
     error, //   unknown
-    context, // rhf UseFormReturn
+    context, // UseRhfUtilsFormOnSubmitErrorContext (form id, form ref, context (rhf), utils options)
     event, //   SubmitEvent
   }) => {
     onError(error);
@@ -120,11 +124,12 @@ Currently, only `zod` is supported.
   // fields
   Children={({
     // UseRhfUtilsFormChildrenProps
-    formId, //     unique id string
-    formRef, //    ref
-    context, //    rhf UseFormReturn
-    options, //    RhfUtilsFormOptions
-    Controller, // strongly-typed controller
+    formId, //          unique id string
+    formRef, //         ref
+    context, //         rhf UseFormReturn
+    options, //         RhfUtilsFormOptions
+    Controller, //      strongly-typed controller
+    FormSubmitError, // strongly-typed error class
   }) => (
     <>
       <Controller
@@ -153,6 +158,28 @@ const Children: RhfUtilsUseFormChildrenZodFC<typeof schema> = ({ ... }) => { };
 function Children({...}: RhfUtilsUseFormChildrenZodProps<typeof schema>) { }
 ```
 
+## `FormSubmitError`
+
+This is a derived `Error` class you can use to throw a structured error in your submit handler. It is strongly-typed, so it only allows field names in schema and `root`/`root.{string}` keys.
+
+It uses `FormSubmitErrors` shape, which is a flat (dot notation) equivalent of RHF's `FieldErrors`.
+
+Example:
+
+```tsx
+<RhfUtilsZodForm
+  onSubmit={({ FormSubmitError }) => {
+    if (isProblem())
+      throw new FormSubmitError({
+        root: { message: 'There was a problem with the form.' },
+        'street.address': { message: 'Street address invalid.' },
+      });
+  }}
+/>
+```
+
+Any non-`FormSubmitError`s thrown from submit handler can be transformed by `RhfUtilsClientConfig`'s `onUnknownSubmitError` callback. This takes an `unknown` error and can return a `FormSubmitErrors` object, which is merged in RHF's context errors. (Most common use case will be transforming backend errors to frontend shape. You can use `getOnSubmitTrpcClientErrorHandler` HOF for TRPC backends.)
+
 ## `RhfUtilsFormOptions`
 
 These options can be set globally and/or per form.
@@ -184,6 +211,10 @@ type RhfUtilsFormOptions = {
 };
 ```
 
+If you need access to options deeper in component structure, use `useRhfUtilsContext` to receive `RhfUtilsContext` object, which includes `formId`, `formRef`, and `options` settings.
+
+Use `useRhfUtilsContextRequestSubmit` to get `requestSubmit` fn for current form ref in context. This is useful when you need to trigger form submission programatically.
+
 ## Extend `RhfUtilsFormOptions`
 
 Extend `RhfUtilsFormOptions` with custom options, which get passed to `Children` component in `options` prop.

package/dist/esm/client/zod/context/RhfUtilsZodForm.mjs

@@ -0,0 +1,12 @@
+import { jsx as i } from "react/jsx-runtime";
+import e from "./useRhfUtilsClientForZodContext.mjs";
+function m({
+  schema: o,
+  ...t
+}) {
+  const { FormWithProviders: r } = e();
+  return /* @__PURE__ */ i(r, { schema: o, ...t });
+}
+export {
+  m as default
+};

package/dist/esm/client/zod/context/useRhfUtilsClientForZodContext.mjs

@@ -0,0 +1,6 @@
+import t from "../../../utils/createContext.mjs";
+const [, e, r] = t();
+export {
+  r as _RhfUtilsClientForZodContextProvider,
+  e as default
+};

package/dist/esm/{src/devtool → devtool}/LazyDevTool.mjs

@@ -5,12 +5,12 @@ const a = e.lazy(
   () => import("@hookform/devtools").then((o) => ({
     default: o.DevTool
   }))
-), s = ({ isDevelopment: o, props: l }) => {
+), u = ({ isDevelopment: o, props: r }) => {
   if (!o)
     return null;
-  const { control: r } = n();
-  return /* @__PURE__ */ t(e.Suspense, { fallback: null, children: /* @__PURE__ */ t(a, { control: r, ...l }) });
-}, u = s;
+  const { control: l } = n();
+  return /* @__PURE__ */ t(e.Suspense, { fallback: null, children: /* @__PURE__ */ t(a, { control: l, ...r }) });
+};
 export {
   u as default
 };

package/dist/esm/errors/flat/FlatFieldErrorsList.mjs

@@ -0,0 +1,17 @@
+import { jsx as t } from "react/jsx-runtime";
+import l from "../../utils/isEmptyObject.mjs";
+const o = ({ errors: e }) => {
+  if (e && !l(e))
+    return /* @__PURE__ */ t("ul", { children: Object.values(e).map((i, r) => /* @__PURE__ */ t(
+      "li",
+      {
+        role: "alert",
+        "aria-live": "polite",
+        children: i.message
+      },
+      r
+    )) });
+};
+export {
+  o as default
+};

package/dist/esm/errors/flat/getFlatFieldErrors.mjs

@@ -0,0 +1,25 @@
+import { get as c } from "react-hook-form";
+import n from "./flattenFieldErrors.mjs";
+const u = (t) => {
+  const s = n(t), a = Object.keys(s);
+  return Object.fromEntries(
+    a.reduce(
+      (e, o) => {
+        const r = o.replace(
+          d,
+          ""
+        );
+        if (r === o)
+          return e;
+        const f = c(t, r, void 0);
+        return f && e.push([r, f]), e;
+      },
+      []
+      // entries
+    )
+  );
+}, d = /\.(?:type|message)\b$/;
+export {
+  u as default,
+  d as regexMaybeFieldErrorLeafNodeSuffix
+};

package/dist/esm/errors/message/FormErrorMessage.mjs

@@ -0,0 +1,14 @@
+import { jsx as o } from "react/jsx-runtime";
+import "react";
+const i = ({ message: r, className: e }) => /* @__PURE__ */ o(
+  "p",
+  {
+    role: "alert",
+    "aria-live": "polite",
+    className: e,
+    children: r
+  }
+);
+export {
+  i as default
+};

package/dist/esm/errors/nonfield/FormNonFieldErrorMarkerHtmlAttribute.mjs

@@ -0,0 +1,4 @@
+const r = "data-paragrav-rhf-utils-nonfield-error-marker-path";
+export {
+  r as default
+};

package/dist/esm/errors/trpc/getOnSubmitTrpcClientErrorHandler.mjs

@@ -0,0 +1,6 @@
+import { TRPCClientError as o } from "@trpc/client";
+import { trpcClientErrorToFormSubmitErrorsSchemaTransformer as n } from "./trpcClientErrorToFormSubmitErrorsSchemaTransformer.mjs";
+const m = (t) => (r) => r instanceof o ? n.parse(r) : t(r);
+export {
+  m as getOnSubmitTrpcClientErrorHandler
+};

package/dist/esm/errors/trpc/trpcClientErrorToFormSubmitErrorsSchemaTransformer.mjs

@@ -0,0 +1,34 @@
+import { TRPCClientError as o } from "@trpc/client";
+import { z as e } from "zod";
+import { trpcClientErrorMessageSchema as a } from "./trpcClientErrorMessageSchema.mjs";
+const i = e.custom(
+  (r) => r instanceof o
+  // check instance type
+).transform((r) => r.message).transform((r) => {
+  try {
+    return JSON.parse(r);
+  } catch {
+    return [
+      {
+        validation: "root",
+        code: "server",
+        message: r,
+        path: ["root"]
+      }
+    ];
+  }
+}).pipe(e.array(a)).transform(
+  (r) => r.map(
+    (t) => [
+      t.path.join("."),
+      // flatten path (e.g., "street.name")
+      {
+        type: t.code,
+        message: t.message
+      }
+    ]
+  )
+).transform((r) => Object.fromEntries(r));
+export {
+  i as trpcClientErrorToFormSubmitErrorsSchemaTransformer
+};

package/dist/esm/exports.mjs

@@ -0,0 +1,48 @@
+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/message/FormErrorMessageByPath.mjs";
+import { default as x } from "./errors/nonfield/FormNonFieldErrorMarker.mjs";
+import { default as F } from "./errors/root/RootErrorsListFromFlatFieldErrorsContext.mjs";
+import { getOnSubmitTrpcClientErrorHandler as C } from "./errors/trpc/getOnSubmitTrpcClientErrorHandler.mjs";
+import { trpcClientErrorToFormSubmitErrorsSchemaTransformer as E } from "./errors/trpc/trpcClientErrorToFormSubmitErrorsSchemaTransformer.mjs";
+import { default as R } from "./form/context/utils/useRhfUtilsContext.mjs";
+import { default as b } from "./form/context/utils/useRhfUtilsContextRequestSubmit.mjs";
+import { default as T } from "./form/context/group/FormGroupContextProvider.mjs";
+import { default as B } from "./form/context/group/useFormGroupChildIsMountedTracker.mjs";
+import { default as P } from "./form/context/group/useFormGroupChildIsSubmittingTracker.mjs";
+import { default as U } from "./form/context/group/useFormGroupChildTracker.mjs";
+import { default as M } from "./form/context/group/useFormGroupIsAnyBusy.mjs";
+import { default as q } from "./form/context/group/useFormGroupIsChildBusy.mjs";
+import { default as O } from "./form/context/group/useFormGroupIsParentBusy.mjs";
+import { default as D } from "./form/context/group/useFormGroupParentTracker.mjs";
+import { default as L } from "./form/context/group/useFormOrParentIsBusy.mjs";
+import { default as j } from "./form/utils/getSubmitterButtonData.mjs";
+import { default as z } from "./form/utils/useFormRequestSubmit.mjs";
+import { FormSubmitError as K } from "./submit/error/FormSubmitError.mjs";
+export {
+  d as FormErrorMessageByPath,
+  T as FormGroupContextProvider,
+  x as FormNonFieldErrorMarker,
+  K as FormSubmitError,
+  e as RhfUtilsClientForZodContextProvider,
+  s as RhfUtilsZodForm,
+  F as RootErrorsListFromFlatFieldErrorsContext,
+  C as getOnSubmitTrpcClientErrorHandler,
+  j as getSubmitterButtonData,
+  E as trpcClientErrorToFormSubmitErrorsSchemaTransformer,
+  m as useFlatFieldErrorsContext,
+  B as useFormGroupChildIsMountedTracker,
+  P as useFormGroupChildIsSubmittingTracker,
+  U as useFormGroupChildTracker,
+  M as useFormGroupIsAnyBusy,
+  q as useFormGroupIsChildBusy,
+  O as useFormGroupIsParentBusy,
+  D as useFormGroupParentTracker,
+  L as useFormOrParentIsBusy,
+  z as useFormRequestSubmit,
+  R as useRhfUtilsContext,
+  b as useRhfUtilsContextRequestSubmit,
+  u as useRhfUtilsZodForm
+};

package/dist/esm/form/Form.mjs

@@ -0,0 +1,102 @@
+import { jsxs as T, jsx as l } from "react/jsx-runtime";
+import "react";
+import { useFormContext as _ } from "react-hook-form";
+import D from "../client/config/useRhfUtilsClientConfigContext.mjs";
+import N from "../devtool/LazyDevTool.mjs";
+import { FormSubmitError as C } from "../submit/error/FormSubmitError.mjs";
+import P from "../submit/error/setCtxErrorsByFormSubmitErrors.mjs";
+import S from "./_Controller.mjs";
+import w from "./_FormBase.mjs";
+function A({
+  formId: s,
+  formRef: p,
+  //
+  onSubmit: c,
+  onSubmitError: d,
+  onSubmitInvalid: v,
+  Children: x,
+  //
+  form: m,
+  utils: o,
+  //
+  children: b
+}) {
+  const n = _(), t = D(), F = async (e) => {
+    o != null && o.stopSubmitPropagation && e.stopPropagation();
+    try {
+      await n.handleSubmit(j, v)(e);
+    } catch (r) {
+      B(r, e);
+    }
+  }, j = (e, r) => c == null ? void 0 : c(
+    e,
+    {
+      formId: s,
+      formRef: p,
+      context: n,
+      utils: o,
+      FormSubmitError: C
+    },
+    r
+  ), B = (e, r) => {
+    var y;
+    const a = e instanceof C ? (
+      // consumer can manually throw FormSubmitError (e.g., manual validation)
+      e.errors
+    ) : (
+      // if error is not FormSubmitError, consumer can provide global handler
+      (y = t == null ? void 0 : t.onUnknownSubmitError) == null ? void 0 : y.call(t, e)
+    );
+    a && P(n, a), d == null || d(
+      e,
+      {
+        formId: s,
+        formRef: p,
+        context: n,
+        utils: o
+      },
+      r
+    );
+  }, h = {
+    formId: s,
+    formRef: p,
+    context: n,
+    utils: o,
+    Controller: S,
+    FormSubmitError: C
+  }, i = (e) => {
+    var a;
+    const r = (a = t == null ? void 0 : t.Children) == null ? void 0 : a[e];
+    return r && /* @__PURE__ */ l(r, { ...h });
+  };
+  return /* @__PURE__ */ T(
+    w,
+    {
+      noValidate: !0,
+      style: {
+        position: "relative"
+      },
+      config: t,
+      formRef: p,
+      ...m,
+      className: [o == null ? void 0 : o.classNames, m == null ? void 0 : m.className].filter(Boolean).join(" "),
+      onSubmit: F,
+      children: [
+        i("top"),
+        (o == null ? void 0 : o.devTool) && /* @__PURE__ */ l(
+          N,
+          {
+            isDevelopment: t == null ? void 0 : t.isDevelopment,
+            props: typeof o.devTool == "object" ? o.devTool : void 0
+          }
+        ),
+        x && /* @__PURE__ */ l(x, { ...h }),
+        b,
+        i("bottom")
+      ]
+    }
+  );
+}
+export {
+  A as default
+};

package/dist/esm/{src/form → form}/RhfUtilsFormProviders.mjs

@@ -1,7 +1,7 @@
 import { jsx as r } from "react/jsx-runtime";
 import { FormProvider as d } from "react-hook-form";
 import n from "../errors/flat/context/FlatFieldErrorsContextProvider.mjs";
-import l from "./context/utils/FormUtilsContextProvider.mjs";
+import l from "./context/utils/RhfUtilsContextProvider.mjs";
 function v({
   formId: t,
   formRef: o,

package/dist/esm/form/context/utils/RhfUtilsContextProvider.mjs

@@ -0,0 +1,27 @@
+import { jsx as f } from "react/jsx-runtime";
+import t from "../../../errors/flat/useFlatFieldErrorsOutput.mjs";
+import l from "../../../submit/useFormOnSubmitSuccessfulAndReset.mjs";
+import F from "../../../submit/useResetFormOnSubmitError.mjs";
+import O from "../../../submit/useResetFormOnSubmitSuccessful.mjs";
+import b from "../../../submit/useSubmitFormOnChange.mjs";
+import { _RhfUtilsContextProvider as d } from "./useRhfUtilsContext.mjs";
+function P({
+  formId: u,
+  formRef: e,
+  onSubmitSuccessfulAndReset: m,
+  options: r,
+  children: a
+}) {
+  return t(), b(e, {
+    disabled: !(r != null && r.submitOnChange)
+  }), F({
+    disabled: !(r != null && r.resetValuesOnSubmitError)
+  }), O(
+    (r == null ? void 0 : r.resetFormAfterSubmitSuccessful) || !!m
+  ), l(() => {
+    m == null || m();
+  }), /* @__PURE__ */ f(d, { value: { formId: u, formRef: e, options: r }, children: a });
+}
+export {
+  P as default
+};

package/dist/esm/form/context/utils/useRhfUtilsContext.mjs

@@ -0,0 +1,6 @@
+import t from "../../../utils/createContext.mjs";
+const [, e, n] = t(), o = e, f = o;
+export {
+  n as _RhfUtilsContextProvider,
+  f as default
+};

package/dist/esm/form/context/utils/useRhfUtilsContextRequestSubmit.mjs

@@ -0,0 +1,9 @@
+import e from "../../utils/useFormRequestSubmit.mjs";
+import s from "./useRhfUtilsContext.mjs";
+const o = () => {
+  const t = s();
+  return e(t.formRef);
+}, m = o;
+export {
+  m as default
+};

package/dist/esm/{src/form → form}/useRhfUtilsForm.mjs

@@ -1,43 +1,43 @@
-import m from "react";
+import s from "react";
 import { useForm as d } from "react-hook-form";
 import { FormSubmitError as F } from "../submit/error/FormSubmitError.mjs";
-const R = ({
+const v = ({
   onSubmit: e,
   onSubmitError: f,
-  onSubmitInvalid: n,
-  defaultValues: p,
+  onSubmitInvalid: p,
+  defaultValues: n,
   Children: c,
   rhf: i,
   form: u,
-  utils: s
+  utils: t
 }) => {
-  const o = m.useId(), t = d({
+  const r = s.useId(), m = d({
     ...i,
-    defaultValues: p
-  }), r = m.useRef(null);
+    defaultValues: n
+  }), o = s.useRef(null);
   return {
-    id: o,
-    ref: r,
-    context: t,
+    id: r,
+    ref: o,
+    context: m,
     providerProps: {
-      formId: o,
-      formRef: r,
-      rhfForm: t,
-      utils: s
+      formId: r,
+      formRef: o,
+      rhfForm: m,
+      utils: t
     },
     formProps: {
       Children: c,
       onSubmit: e,
       onSubmitError: f,
-      onSubmitInvalid: n,
-      formId: o,
-      formRef: r,
+      onSubmitInvalid: p,
+      formId: r,
+      formRef: o,
       form: u,
-      utils: s
+      utils: t
     },
     FormSubmitError: F
   };
-}, x = R;
+};
 export {
-  x as default
+  v as default
 };

package/dist/esm/submit/useFormOnSubmitSuccessful.mjs

@@ -0,0 +1,11 @@
+import s from "react";
+import { useFormState as u } from "react-hook-form";
+const r = (t) => {
+  const { isSubmitSuccessful: e } = u();
+  s.useEffect(() => {
+    t && e && t();
+  }, [t, e]);
+};
+export {
+  r as default
+};

package/dist/esm/{src/submit → submit}/useSubmitFormOnChange.mjs

@@ -1,5 +1,5 @@
 import m from "react";
-import a from "../errors/useFormRequestSubmit.mjs";
+import a from "../form/utils/useFormRequestSubmit.mjs";
 const o = (t, e) => {
   const u = a(t);
   m.useEffect(() => {

package/dist/esm/utils/isEmptyObject.mjs

@@ -0,0 +1,4 @@
+const e = (t) => Object.keys(t).length === 0;
+export {
+  e as default
+};

package/dist/types/client/config/RhfUtilsClientConfig.d.ts

@@ -39,18 +39,16 @@ export type RhfUtilsClientConfig = {
      */
     FormComponent?: React.FC<React.PropsWithChildren<React.HTMLAttributes<HTMLFormElement>>>;
     /**
-     * Global submit error handler.
-     *
-     * Called when/if submit handler throws an error other than {@link FormSubmitError}.
+     * Global submit error handler when/if submit handler throws an error other than {@link FormSubmitError}.
      *
      * Example use case:
      * - transform API errors to {@link FormSubmitErrors}.
      *
      * @returns
-     * - {@link FormSubmitErrors}: merge into context errors.
-     * - `undefined`: do nothing.
+     * - if {@link FormSubmitErrors}: merge into context errors.
+     * - if `undefined`: do nothing.
      */
-    onSubmitError?: (error: unknown) => FormSubmitErrors | undefined;
+    onUnknownSubmitError?: (error: unknown) => FormSubmitErrors | undefined;
     /**
      * Components injected by slot across all forms.
      * (Per-form injection can be done via `Children` prop.)

package/dist/types/client/zod/RhfUtilsUseFormChildrenZodProps.d.ts

@@ -1,4 +1,5 @@
 import { UseRhfUtilsFormChildrenProps } from '../../form/UseRhfUtilsFormChildrenProps';
+import { zodTypeInput, zodTypeOutput } from './consts';
 import { ZodTypeFieldValues } from './ZodTypeFieldValues';
 
-export type RhfUtilsUseFormChildrenZodProps<TSchema extends ZodTypeFieldValues> = UseRhfUtilsFormChildrenProps<TSchema['_input'], TSchema['_output']>;
+export type RhfUtilsUseFormChildrenZodProps<TSchema extends ZodTypeFieldValues> = UseRhfUtilsFormChildrenProps<TSchema[typeof zodTypeInput], TSchema[typeof zodTypeOutput]>;

package/dist/types/client/zod/consts.d.ts

@@ -0,0 +1,4 @@
+/** Schema key that returns input type. */
+export declare const zodTypeInput = "_input";
+/** Schema keys that returns output type. */
+export declare const zodTypeOutput = "_output";

package/dist/types/client/zod/context/RhfUtilsZodForm.d.ts

@@ -0,0 +1,9 @@
+import { UseRhfUtilsFormProps } from '../../../form/UseRhfUtilsFormProps';
+import { zodTypeInput, zodTypeOutput } from '../consts';
+import { ZodTypeFieldValues } from '../ZodTypeFieldValues';
+
+type Props<TSchema extends ZodTypeFieldValues> = {
+    schema: TSchema;
+} & Omit<UseRhfUtilsFormProps<TSchema[typeof zodTypeInput], TSchema[typeof zodTypeOutput]>, 'config'>;
+declare function RhfUtilsZodForm<TSchema extends ZodTypeFieldValues>({ schema, ...props }: Props<TSchema>): import("react/jsx-runtime").JSX.Element;
+export default RhfUtilsZodForm;

package/dist/types/client/zod/context/useRhfUtilsZodForm.d.ts

@@ -1,7 +1,8 @@
 import { UseRhfUtilsFormProps } from '../../../form/UseRhfUtilsFormProps';
+import { zodTypeInput, zodTypeOutput } from '../consts';
 import { ZodTypeFieldValues } from '../ZodTypeFieldValues';
 
-declare const useRhfUtilsZodForm: <TSchema extends ZodTypeFieldValues>(schema: TSchema, form: Omit<UseRhfUtilsFormProps<TSchema['_input'], TSchema['_output']>, 'config'>) => import('../../../form/UseRhfUtilsFormReturn').UseRhfUtilsFormReturn<TSchema["_input"], TSchema["_output"]> & {
+declare const useRhfUtilsZodForm: <TSchema extends ZodTypeFieldValues>(schema: TSchema, form: Omit<UseRhfUtilsFormProps<TSchema[typeof zodTypeInput], TSchema[typeof zodTypeOutput]>, 'config'>) => import('../../../form/UseRhfUtilsFormReturn').UseRhfUtilsFormReturn<TSchema["_input"], TSchema["_output"]> & {
     FormWithProviders: import('react').FC<{
         children?: import('react').ReactNode;
     }>;

package/dist/types/errors/flat/getFlatFieldErrors.d.ts

@@ -6,7 +6,8 @@ import { FlatFieldErrors } from './types';
  * This makes it easy to work with potentially deeply-nested {@link FieldErrors}.
  *
  * @param errors {@link FieldErrors} object.
- * @returns FlatFieldErrors object.
+ *
+ * @returns `FlatFieldErrors` object.
  *
  * @example
  * ```
@@ -28,4 +29,4 @@ export default getFlatFieldErrors;
  *
  * iow: dot [?: non-capturing]("type" | "message")[\b word boundary][$ end of string]
  */
-export declare const regexMaybeFieldErrorLeafNode: RegExp;
+export declare const regexMaybeFieldErrorLeafNodeSuffix: RegExp;

package/dist/types/errors/orphan/useOrphanFormErrorsMemo.d.ts

@@ -1,4 +1,9 @@
 import { default as React } from 'react';
 
+/**
+ * Get {@link FlatFieldErrors} of only orphans.
+ * @param formRef Parent DOM element to look for non-field error markers.
+ * @returns Memoized {@link FlatFieldErrors} of only orphans.
+ */
 declare const useOrphanFormErrorsMemo: (formRef: React.RefObject<HTMLFormElement>) => import('../flat/types').FlatFieldErrors;
 export default useOrphanFormErrorsMemo;