@paragrav/rhf-utils 0.0.66 → 0.0.68

package/dist/esm/client/index.mjs

@@ -7,7 +7,6 @@ const p = (t) => (r) => {
     r
   );
   return {
-    config: r,
     useForm: (o, s) => F(
       e(o, s)
     ),
@@ -30,6 +29,7 @@ const p = (t) => (r) => {
   var s, m, i, n, f, a, h;
   return {
     ...o,
+    config: r,
     rhf: {
       ...(s = r.defaultOptions) == null ? void 0 : s.rhf,
       ...o.rhf,

package/dist/esm/client/zod/index.mjs

@@ -1,6 +1,7 @@
-import { zodResolver as t } from "../../node_modules/@hookform/resolvers/zod/dist/zod.mjs";
-import { createRhfUtilsClient as e } from "../index.mjs";
-const i = e(t);
+import { zodResolver as t } from "@hookform/resolvers/zod";
+import "zod";
+import { createRhfUtilsClient as o } from "../index.mjs";
+const l = o(t);
 export {
-  i as createZodRhfUtilsClient
+  l as createZodRhfUtilsClient
 };

package/dist/esm/errors/context/provider.mjs

@@ -1,8 +1,8 @@
 import { jsx as F } from "react/jsx-runtime";
-import i from "../flat/getFlatFieldErrors.mjs";
-import l from "../orphan/getOrphansFromFlatFieldErrors.mjs";
-import a from "../root/getRootsFromFlatFieldErrors.mjs";
-import p from "../useFormErrorsMemo.mjs";
+import a from "../flat/getFlatFieldErrors.mjs";
+import i from "../orphan/getOrphansFromFlatFieldErrors.mjs";
+import l from "../root/getRootsFromFlatFieldErrors.mjs";
+import p from "../useFormErrorsTransformMemo.mjs";
 import { _FormErrorsFlatContextProvider as c } from "./index.mjs";
 const u = ({
   formRef: o,
@@ -11,7 +11,7 @@ const u = ({
   const e = p((s) => {
     if (!o.current)
       return;
-    const r = i(s), m = a(r), n = l(r, o.current);
+    const r = a(s), m = l(r), n = i(r, o.current);
     return { all: r, roots: m, orphans: n };
   });
   return /* @__PURE__ */ F(c, { value: e, children: t });

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

@@ -0,0 +1,10 @@
+const r = (e) => (t) => (
+  // re-create object from entries
+  Object.fromEntries(
+    // break down to entries
+    Object.entries(t).filter(e)
+  )
+);
+export {
+  r as default
+};

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

@@ -0,0 +1,6 @@
+import r from "../useFormErrorsTransformMemo.mjs";
+import o from "./getFlatFieldErrors.mjs";
+const s = () => r(o);
+export {
+  s as default
+};

package/dist/esm/errors/isFieldErrorRefd.mjs

@@ -0,0 +1,4 @@
+const r = (e) => !!e.ref;
+export {
+  r as default
+};

package/dist/esm/errors/nonfield/FormNonFieldErrorMarker.utils.mjs

@@ -1,6 +1,6 @@
 import o from "./FormNonFieldErrorMarkerHtmlAttribute.mjs";
-const t = (r) => `[role="alert"][${o}="${r}"]`, n = (r, e) => !!e.querySelector(t(r));
+const t = (r) => `[role="alert"][${o}="${r}"]`, i = (r, e) => !!e.querySelector(t(r));
 export {
   t as getFormNonFieldErrorMarkerQuerySelector,
-  n as hasNonFieldErrorMarkerInDOM
+  i as isNonFieldErrorMarkerInDOM
 };

package/dist/esm/errors/orphan/getIsOrphanFormErrorWithParentElement.mjs

@@ -0,0 +1,5 @@
+import o from "./isOrphanFormError.mjs";
+const n = (r) => ([t, e]) => o(t, e, r);
+export {
+  n as default
+};

package/dist/esm/errors/orphan/getOrphansFromFieldErrors.mjs

@@ -1,9 +1,6 @@
-import e from "../flat/getFlatFieldErrors.mjs";
-import s from "./getOrphansFromFlatFieldErrors.mjs";
-const a = (r, o) => {
-  const t = e(r);
-  return s(t, o);
-};
+import t from "../flat/getFlatFieldErrors.mjs";
+import e from "./getOrphansFromFlatFieldErrors.mjs";
+const a = (r, o) => e(t(r), o);
 export {
   a as default
 };

package/dist/esm/errors/orphan/getOrphansFromFlatFieldErrors.mjs

@@ -1,9 +1,8 @@
-import s from "./isOrphanFormError.mjs";
-const a = (r, t) => Object.fromEntries(
-  Object.entries(r).filter(
-    ([e, o]) => s(e, o, t)
-  )
-);
+import e from "../flat/filterFlatFieldErrors.mjs";
+import o from "./getIsOrphanFormErrorWithParentElement.mjs";
+const F = (r, t) => e(
+  o(t)
+)(r);
 export {
-  a as default
+  F as default
 };

package/dist/esm/errors/orphan/isOrphanFormError.mjs

@@ -1,12 +1,12 @@
-import m from "../isFieldError.mjs";
-import { hasNonFieldErrorMarkerInDOM as t } from "../nonfield/FormNonFieldErrorMarker.utils.mjs";
-import s from "../root/isFormErrorPathRoot.mjs";
-const n = (r, o, i) => (
+import m from "../isFieldErrorRefd.mjs";
+import { isNonFieldErrorMarkerInDOM as t } from "../nonfield/FormNonFieldErrorMarker.utils.mjs";
+import e from "../root/isFormErrorPathRoot.mjs";
+const d = (r, o, i) => (
   // not root path
-  !s(r) && // non-field
+  !e(r) && // non-field
   !m(o) && // does not have marker
   !t(r, i)
 );
 export {
-  n as default
+  d as default
 };

package/dist/esm/errors/orphan/useFormHasOnlyOrphanFieldErrorsMemo.mjs

@@ -0,0 +1,10 @@
+import s from "../../utils/isEmptyObject.mjs";
+import t from "../flat/useFormFlatFieldErrorsMemo.mjs";
+import m from "./useOrphanFormErrorsMemo.mjs";
+const n = (o) => {
+  const e = t(), r = m(o);
+  return s(r) ? !1 : Object.keys(e).length !== Object.keys(r).length;
+}, i = n;
+export {
+  i as default
+};

package/dist/esm/errors/orphan/useOrphanFormErrorsMemo.mjs

@@ -1,14 +1,14 @@
 import "react";
 import t from "../../utils/isEmptyObject.mjs";
-import e from "../useFormErrorsMemo.mjs";
-import m from "./getOrphansFromFieldErrors.mjs";
-const s = (r) => e((o) => {
+import m from "../useFormErrorsTransformMemo.mjs";
+import e from "./getOrphansFromFieldErrors.mjs";
+const s = (r) => m((o) => {
   if (t(o))
     return {};
   if (!r.current)
     throw new Error();
-  return m(o, r.current);
-}), E = s;
+  return e(o, r.current);
+}), a = s;
 export {
-  E as default
+  a as default
 };

package/dist/esm/errors/root/getRootsFromFieldErrors.mjs

@@ -1,9 +1,6 @@
-import t from "../flat/getFlatFieldErrors.mjs";
-import e from "./getRootsFromFlatFieldErrors.mjs";
-const F = (r) => {
-  const o = t(r);
-  return e(o);
-};
+import o from "../flat/getFlatFieldErrors.mjs";
+import t from "./getRootsFromFlatFieldErrors.mjs";
+const F = (r) => t(o(r));
 export {
   F as default
 };

package/dist/esm/errors/root/getRootsFromFlatFieldErrors.mjs

@@ -1,7 +1,8 @@
-import o from "./isFormErrorPathRoot.mjs";
-const s = (r) => Object.fromEntries(
-  Object.entries(r).filter(([t]) => o(t))
+import r from "../flat/filterFlatFieldErrors.mjs";
+import o from "./isFlatFieldErrorEntryPathRoot.mjs";
+const l = r(
+  o
 );
 export {
-  s as default
+  l as default
 };

package/dist/esm/errors/root/isFlatFieldErrorEntryPathRoot.mjs

@@ -0,0 +1,5 @@
+import r from "./isFormErrorPathRoot.mjs";
+const a = ([o]) => r(o);
+export {
+  a as default
+};

package/dist/esm/errors/root/useRootFormFieldErrorsMemo.mjs

@@ -1,4 +1,4 @@
-import o from "../useFormErrorsMemo.mjs";
+import o from "../useFormErrorsTransformMemo.mjs";
 import r from "./getRootsFromFieldErrors.mjs";
 const e = () => o(r), t = e;
 export {

package/dist/esm/errors/{useFormErrorsMemo.mjs → useFormErrorsTransformMemo.mjs}

@@ -2,7 +2,10 @@ import e from "react";
 import { useFormState as t } from "react-hook-form";
 const u = (r) => {
   const { errors: o } = t();
-  return e.useMemo(() => r(o), [r, o]);
+  return e.useMemo(
+    () => r(o),
+    [r, o]
+  );
 };
 export {
   u as default

package/dist/esm/exports.mjs

@@ -1,22 +1,22 @@
 import { createZodRhfUtilsClient as e } from "./client/zod/index.mjs";
 import { default as s } from "./client/zod/context/index.mjs";
 import { default as u } from "./client/zod/context/provider.mjs";
-import { default as m } from "./devtool/LazyDevTool.mjs";
+import { default as f } from "./devtool/LazyDevTool.mjs";
 import { default as d } from "./errors/context/index.mjs";
 import { default as x } from "./errors/context/provider.mjs";
 import { default as n } from "./errors/message/FormErrorMessage.mjs";
 import { default as E } from "./errors/message/FormErrorMessageByPath.mjs";
 import { default as c } from "./errors/nonfield/FormNonFieldErrorMarker.mjs";
 import { default as S } from "./errors/nonfield/FormNonFieldErrorMarkerHtmlAttribute.mjs";
-import { default as y } from "./errors/orphan/useFormHasOrphanAndNoFieldErrors.mjs";
-import { default as M } from "./errors/orphan/useOrphanFormErrorsMemo.mjs";
+import { default as y } from "./errors/orphan/useFormHasOnlyOrphanFieldErrorsMemo.mjs";
+import { default as O } from "./errors/orphan/useOrphanFormErrorsMemo.mjs";
 import { default as P } from "./errors/orphan/useOrphanFormErrorsToConsole.mjs";
 import { default as I } from "./errors/root/useRootFormFieldErrorsMemo.mjs";
-import { default as k } from "./errors/useFormErrorConsoleDebug.mjs";
+import { default as g } from "./errors/useFormErrorConsoleDebug.mjs";
 import { default as B } from "./errors/useFormErrorsEffect.mjs";
-import { default as v } from "./errors/useFormErrorsIfAny.mjs";
-import { default as D } from "./errors/useFormErrorsMemo.mjs";
-import { default as Z } from "./errors/useFormRequestSubmit.mjs";
+import { default as A } from "./errors/useFormErrorsIfAny.mjs";
+import { default as D } from "./errors/useFormErrorsTransformMemo.mjs";
+import { default as H } from "./errors/useFormRequestSubmit.mjs";
 import { default as q } from "./form/useForm.mjs";
 import { default as L } from "./form/context/utils/FormUtilsContextProvider.mjs";
 import { default as w } from "./form/context/utils/useFormUtilsContext.mjs";
@@ -28,7 +28,7 @@ import { default as rr } from "./form/context/group/useFormGroupIsAnyBusy.mjs";
 import { default as er } from "./form/context/group/useFormGroupIsChildBusy.mjs";
 import { default as sr } from "./form/context/group/useFormGroupIsParentBusy.mjs";
 import { default as ur } from "./form/context/group/useFormGroupParentTracker.mjs";
-import { default as mr } from "./form/context/group/useFormOrParentIsBusy.mjs";
+import { default as fr } from "./form/context/group/useFormOrParentIsBusy.mjs";
 import { default as dr } from "./form/utils/getSubmitterButtonData.mjs";
 import { FormSubmitError as xr } from "./submit/error/FormSubmitError.mjs";
 import { default as nr } from "./submit/useFormOnSubmitSuccessful.mjs";
@@ -45,16 +45,16 @@ export {
   S as FormNonFieldErrorMarkerHtmlAttribute,
   xr as FormSubmitError,
   L as FormUtilsContextProvider,
-  m as LazyDevTool,
+  f as LazyDevTool,
   u as RhfUtilsZodContextProvider,
   e as createZodRhfUtilsClient,
   dr as getSubmitterButtonData,
   q as useForm,
-  k as useFormErrorConsoleDebug,
+  g as useFormErrorConsoleDebug,
   B as useFormErrorsEffect,
   d as useFormErrorsFlatContext,
-  v as useFormErrorsIfAny,
-  D as useFormErrorsMemo,
+  A as useFormErrorsIfAny,
+  D as useFormErrorsTransformMemo,
   V as useFormGroupChildIsMountedTracker,
   X as useFormGroupChildIsSubmittingTracker,
   _ as useFormGroupChildTracker,
@@ -62,13 +62,13 @@ export {
   er as useFormGroupIsChildBusy,
   sr as useFormGroupIsParentBusy,
   ur as useFormGroupParentTracker,
-  y as useFormHasOrphanAndNoFieldErrors,
+  y as useFormHasOnlyOrphanFieldErrorsMemo,
   nr as useFormOnSubmitSuccessful,
   Er as useFormOnSubmitSuccessfulAndReset,
-  mr as useFormOrParentIsBusy,
-  Z as useFormRequestSubmit,
+  fr as useFormOrParentIsBusy,
+  H as useFormRequestSubmit,
   w as useFormUtilsContext,
-  M as useOrphanFormErrorsMemo,
+  O as useOrphanFormErrorsMemo,
   P as useOrphanFormErrorsToConsole,
   Sr as useResetFormAfterSubmitSuccessful,
   cr as useResetFormOnSubmitError,

package/dist/esm/form/_Form.mjs

@@ -1,89 +1,90 @@
-import { jsxs as v, jsx as p } from "react/jsx-runtime";
+import { jsxs as B, jsx as p } from "react/jsx-runtime";
 import "react";
-import { useFormContext as B } from "react-hook-form";
-import N from "../devtool/LazyDevTool.mjs";
-import { FormSubmitError as P } from "../submit/error/FormSubmitError.mjs";
-import T from "../submit/error/setCtxErrorsByFormSubmitError.mjs";
-import V from "../submit/useResetFormOnSubmitError.mjs";
-import _ from "./_FormBase.mjs";
-function A({
-  formId: x,
+import { useFormContext as N } from "react-hook-form";
+import P from "../devtool/LazyDevTool.mjs";
+import { FormSubmitError as T } from "../submit/error/FormSubmitError.mjs";
+import V from "../submit/error/setCtxErrorsByFormSubmitError.mjs";
+import _ from "../submit/useResetFormOnSubmitError.mjs";
+import O from "./_FormBase.mjs";
+function G({
+  formId: c,
   formRef: l,
   form: t,
-  children: y
+  config: n,
+  children: o
 }) {
-  var c, b, S, o, h;
-  const a = B();
-  V({
-    disabled: !((c = t == null ? void 0 : t.options) != null && c.resetValuesOnSubmitError)
+  var b, S, h, E, F;
+  const a = N();
+  _({
+    disabled: !((b = t == null ? void 0 : t.options) != null && b.resetValuesOnSubmitError)
   });
-  const C = async (i) => {
-    var n;
-    (n = t == null ? void 0 : t.options) != null && n.stopSubmitPropagation && i.stopPropagation();
+  const y = async (s) => {
+    var e;
+    (e = t == null ? void 0 : t.options) != null && e.stopSubmitPropagation && s.stopPropagation();
     try {
       await a.handleSubmit(
-        g,
+        j,
         t == null ? void 0 : t.onSubmitInvalid
-      )(i);
-    } catch (s) {
-      j(s, i);
+      )(s);
+    } catch (i) {
+      v(i, s);
     }
-  }, g = (i, n) => {
-    var s;
-    return (s = t == null ? void 0 : t.onSubmit) == null ? void 0 : s.call(
+  }, j = (s, e) => {
+    var i;
+    return (i = t == null ? void 0 : t.onSubmit) == null ? void 0 : i.call(
       t,
-      i,
+      s,
       a,
-      n
+      e
     );
-  }, j = (i, n) => {
-    var e, E, F;
-    const s = i instanceof P ? (
+  }, v = (s, e) => {
+    var x, C;
+    const i = s instanceof T ? (
       // consumer can manually throw FormSubmitError (e.g., manual validation)
-      i
+      s
     ) : (
       // if error is not FormSubmitError, consumer can provide global handler
-      (E = (e = t == null ? void 0 : t.options) == null ? void 0 : e.onSubmitError) == null ? void 0 : E.call(e, i)
+      (x = n == null ? void 0 : n.onSubmitError) == null ? void 0 : x.call(n, s)
     );
-    s && T(a, s), (F = t == null ? void 0 : t.onSubmitError) == null || F.call(
+    i && V(a, i), (C = t == null ? void 0 : t.onSubmitError) == null || C.call(
       t,
-      i,
+      s,
       a,
-      n
+      e
     );
   }, u = {
-    formId: x,
+    formId: c,
     formRef: l,
     ctx: a,
     options: t == null ? void 0 : t.options
-  }, d = (i) => {
-    var s, e;
-    const n = (e = (s = t == null ? void 0 : t.options) == null ? void 0 : s.Children) == null ? void 0 : e[i];
-    return n && /* @__PURE__ */ p(n, { ...u });
+  }, d = (s) => {
+    var i;
+    const e = (i = n == null ? void 0 : n.Children) == null ? void 0 : i[s];
+    return e && /* @__PURE__ */ p(e, { ...u });
   };
-  return /* @__PURE__ */ v(
-    _,
+  return /* @__PURE__ */ B(
+    O,
     {
       noValidate: !0,
       style: {
         position: "relative"
       },
       ...t == null ? void 0 : t.props,
-      className: [(b = t == null ? void 0 : t.options) == null ? void 0 : b.classNames, ((S = t == null ? void 0 : t.props) == null ? void 0 : S.className) ?? ""].join(
+      className: [(S = t == null ? void 0 : t.options) == null ? void 0 : S.classNames, ((h = t == null ? void 0 : t.props) == null ? void 0 : h.className) ?? ""].join(
         " "
       ),
-      onSubmit: C,
+      onSubmit: y,
       formRef: l,
       children: [
         d("top"),
-        ((o = t == null ? void 0 : t.options) == null ? void 0 : o.devTool) !== "disabled" && /* @__PURE__ */ p(N, { placement: "top-right", ...(h = t == null ? void 0 : t.options) == null ? void 0 : h.devTool }),
+        ((E = t == null ? void 0 : t.options) == null ? void 0 : E.devTool) !== "disabled" && /* @__PURE__ */ p(P, { placement: "top-right", ...(F = t == null ? void 0 : t.options) == null ? void 0 : F.devTool }),
         (t == null ? void 0 : t.Fields) && /* @__PURE__ */ p(t.Fields, { ...u }),
-        y,
+        o,
         d("bottom")
       ]
     }
   );
 }
 export {
-  A as default
+  G as default
 };

package/dist/esm/form/useForm.mjs

@@ -1,14 +1,15 @@
 import n from "react";
-import { useForm as u } from "react-hook-form";
-import i from "../submit/useSubmitFormOnChange.mjs";
-const l = ({
-  rhf: m,
+import { useForm as i } from "react-hook-form";
+import c from "../submit/useSubmitFormOnChange.mjs";
+const P = ({
+  config: m,
+  rhf: p,
   form: o,
-  utils: p
+  utils: u
 }) => {
   var t;
-  const s = n.useId(), e = u(m), r = n.useRef(null);
-  return i(r, {
+  const s = n.useId(), e = i(p), r = n.useRef(null);
+  return c(r, {
     disabled: !((t = o == null ? void 0 : o.options) != null && t.submitOnChange)
   }), {
     id: s,
@@ -18,15 +19,16 @@ const l = ({
       formId: s,
       formRef: r,
       rhfForm: e,
-      utils: p
+      utils: u
     },
     formProps: {
       formId: s,
       formRef: r,
+      config: m,
       form: o
     }
   };
 };
 export {
-  l as default
+  P as default
 };

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

@@ -0,0 +1,37 @@
+import { FormSubmitError } from '../submit/error/FormSubmitError';
+import { UseFormOptions } from '../form/useFormOptions';
+import { UseFormFieldsProps } from '../form/useForm';
+import { _FormSlots } from '../form/_Form';
+import { UseFormProps } from 'react-hook-form';
+
+export type ClientConfig = {
+    /**
+     * Default options for all forms. (Are overridden by form-specific options.)
+     */
+    defaultOptions?: {
+        /**
+         * Default RHF `useForm` settings.
+         *
+         * (Exposes only non-local props.)
+         */
+        rhf?: Pick<UseFormProps, 'mode' | 'reValidateMode' | 'resetOptions' | 'context' | 'shouldFocusError' | 'shouldUnregister' | 'shouldUseNativeValidation' | 'progressive' | 'criteriaMode' | 'delayError'>;
+        /**
+         * Default global options settings.
+         *
+         * Extend this type to inject custom options/functionality via `Children` component.
+         */
+        form?: UseFormOptions;
+    };
+    /**
+     * Components injected by slot across all forms.
+     * (Per-form injection can be done via Fields prop.)
+     *
+     * top: e.g., block navigation on dirty form.
+     * bottom: e.g., root errors list.
+     */
+    Children?: Partial<Record<_FormSlots, React.FC<UseFormFieldsProps>>>;
+    /**
+     * Handle non-{@link FormSubmitError} errors. Optionally, return {@link FormSubmitError} to merge into context errors.
+     */
+    onSubmitError?: (error: unknown) => FormSubmitError | undefined;
+};

package/dist/types/{src/client → client}/index.d.ts

@@ -13,7 +13,6 @@ export type ObjectSchema<TInputKey extends string, TOutputKey extends string> =
     [key in TOutputKey]: SafeFieldValues;
 };
 export type CreateRhfUtilsClient<TObjectSchema extends ObjectSchema<TObjectSchemaInputKey, TObjectSchemaOutputKey>, TObjectSchemaInputKey extends string, TObjectSchemaOutputKey extends string> = {
-    config: ClientConfig;
     useForm: <TSchema extends TObjectSchema, TSchemaInput extends SafeFieldValues = TSchema[TObjectSchemaInputKey], TSchemaOutput extends SafeFieldValues = TSchema[TObjectSchemaOutputKey]>(schema: TSchema, props: UseFormProps<TSchemaInput, TSchemaOutput>) => UseFormReturn<TSchemaInput, TSchemaOutput>;
     FormWithProviders: <TSchema extends TObjectSchema, TSchemaInput extends SafeFieldValues = TSchema[TObjectSchemaInputKey], TSchemaOutput extends SafeFieldValues = TSchema[TObjectSchemaOutputKey]>(props: {
         schema: TSchema;

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

@@ -0,0 +1,9 @@
+import { FlatFieldErrorEntry, FlatFieldErrors } from './types';
+
+/**
+ * Filter {@link FlatFieldErrors} by a predicate.
+ *
+ * (Encapsulates to and from Object entries.)
+ */
+declare const makeFlatFieldErrorsFilter: (predicate: (entry: FlatFieldErrorEntry, index: number) => boolean) => (errors: FlatFieldErrors) => FlatFieldErrors;
+export default makeFlatFieldErrorsFilter;

package/dist/types/{src/errors → errors}/flat/types.d.ts

@@ -11,3 +11,7 @@ import { FieldError } from 'react-hook-form';
  * ```
  */
 export type FlatFieldErrors = Record<string, FieldError>;
+/**
+ * Return from `Object.entries` on {@link FlatFieldErrors}.
+ */
+export type FlatFieldErrorEntry = [path: string, error: FieldError];

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

@@ -0,0 +1,7 @@
+import { FlatFieldErrors } from './types';
+
+/**
+ * Use {@link FieldErrors} as {@link FlatFieldErrors}.
+ */
+declare const useFormFlatFieldErrorsMemo: () => FlatFieldErrors;
+export default useFormFlatFieldErrorsMemo;

package/dist/types/{src/errors → errors}/flat/useRefdFieldErrorsMemo.d.ts

@@ -2,7 +2,7 @@ import { FlatFieldErrors } from './types';
 import { FieldErrors } from 'react-hook-form';
 
 /**
- * Use errors with refs.
+ * Use {@link FieldErrors} with `ref`s as {@link FlatFieldErrors}.
  */
 declare const useRefdFieldErrorsMemo: () => FlatFieldErrors;
 export default useRefdFieldErrorsMemo;

package/dist/types/errors/isFieldErrorRefd.d.ts

@@ -0,0 +1,7 @@
+import { FieldError } from 'react-hook-form';
+
+/**
+ * Determine if {@link FieldError} is a `ref`'d field error.
+ */
+declare const isFieldErrorRefd: (error: FieldError) => boolean;
+export default isFieldErrorRefd;

package/dist/types/errors/isFlatFieldErrorEntryRefd.d.ts

@@ -0,0 +1,7 @@
+import { FlatFieldErrorEntry } from './flat/types';
+
+/**
+ * Util wrapper for {@link isFieldErrorRefd} for usage with {@link FlatFieldErrorEntry}.
+ */
+declare const isFlatFieldErrorEntryRefd: ([, error]: FlatFieldErrorEntry) => boolean;
+export default isFlatFieldErrorEntryRefd;

package/dist/types/errors/nonfield/FormNonFieldErrorMarker.utils.d.ts

@@ -0,0 +1,2 @@
+export declare const getFormNonFieldErrorMarkerQuerySelector: (path: string) => string;
+export declare const isNonFieldErrorMarkerInDOM: (path: string, parentElement: Pick<HTMLElement, 'querySelector'>) => boolean;

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

@@ -0,0 +1,7 @@
+import { FlatFieldErrorEntry } from '../flat/types';
+
+/**
+ * Util wrapper for {@link isOrphanFormError} for usage with {@link FlatFieldErrorEntry}.
+ */
+declare const getIsFlatFieldErrorEntryOrphanByParentElement: (parentElement: Pick<HTMLElement, 'querySelector'>) => ([path, error]: FlatFieldErrorEntry) => boolean;
+export default getIsFlatFieldErrorEntryOrphanByParentElement;

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

@@ -0,0 +1,6 @@
+/**
+ * Determined if there are orphan errors and no field errors.
+ * (May be useful when reporting or displaying a specific message to user.)
+ */
+declare const useFormHasOnlyOrphanFieldErrorsMemo: (formRef: React.RefObject<HTMLFormElement>) => boolean;
+export default useFormHasOnlyOrphanFieldErrorsMemo;

package/dist/types/errors/root/getRootsFromFlatFieldErrors.d.ts

@@ -0,0 +1,2 @@
+declare const getRootsFromFlatFieldErrors: (errors: import('../flat/types').FlatFieldErrors) => import('../flat/types').FlatFieldErrors;
+export default getRootsFromFlatFieldErrors;

package/dist/types/errors/root/isFlatFieldErrorEntryPathRoot.d.ts

@@ -0,0 +1,7 @@
+import { FlatFieldErrorEntry } from '../flat/types';
+
+/**
+ * Util wrapper for {@link isFormErrorPathRoot} for usage with {@link FlatFieldErrorEntry}.
+ */
+declare const isFlatFieldErrorEntryPathRoot: ([path]: FlatFieldErrorEntry) => boolean;
+export default isFlatFieldErrorEntryPathRoot;

package/dist/types/{src/errors → errors}/root/isFormErrorPathRoot.d.ts

@@ -1,5 +1,6 @@
 /**
  * Determine if an error path is root. (e.g., `root` or `root.nested`)
+ *
  * @param path Flat path. (e.g., 'root.nested')
  */
 declare const isFormErrorPathRoot: (path: string) => boolean;