@paragrav/rhf-utils 0.0.27 → 0.0.30

package/dist/esm/errors/consoleErrors.mjs

@@ -0,0 +1,9 @@
+const l = (e, c, r) => {
+  console[r != null && r.isError ? "error" : "debug"](e, {
+    form: c,
+    other: r == null ? void 0 : r.other
+  });
+};
+export {
+  l as default
+};

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

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

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

@@ -0,0 +1,19 @@
+import { jsx as l } from "react/jsx-runtime";
+import F from "../flat/getFlatFieldErrors.mjs";
+import a from "../orphan/getOrphanFlatFieldErrors.mjs";
+import i from "../root/getRootFlatFieldErrors.mjs";
+import p from "../useFormErrorsMemo.mjs";
+import { _FormErrorsFlatContextProvider as c } from "./index.mjs";
+const d = ({
+  formRef: o,
+  children: t
+}) => {
+  const e = p((s) => {
+    const r = F(s), m = i(r), n = a(r, o.current);
+    return { all: r, roots: m, orphans: n };
+  });
+  return /* @__PURE__ */ l(c, { value: e, children: t });
+}, C = d;
+export {
+  C as default
+};

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

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

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

@@ -0,0 +1,13 @@
+import t from "../isFieldError.mjs";
+import s from "../useFormErrorsMemo.mjs";
+import i from "./getFlatFieldErrors.mjs";
+const d = () => s(m), m = (r) => {
+  const e = i(r);
+  return Object.fromEntries(
+    Object.entries(e).filter(([, o]) => t(o))
+  );
+};
+export {
+  d as default,
+  m as getFlatFieldFormErrors
+};

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

@@ -1,5 +1,5 @@
 import { jsx as t } from "react/jsx-runtime";
-import e from "./FormNonFieldErrorMarker.utils.mjs";
+import e from "./FormNonFieldErrorMarkerHtmlAttribute.mjs";
 const a = ({ path: r }) => {
   const o = {
     [e]: r

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

@@ -1,6 +1,6 @@
-const e = "data-paragrav-rhf-utils-nonfield-error-marker-path", a = e, t = (r) => `[role="alert"][${e}="${r}"]`, l = (r, o) => o.querySelector(t(r));
+import o from "./FormNonFieldErrorMarkerHtmlAttribute.mjs";
+const t = (r) => `[role="alert"][${o}="${r}"]`, n = (r, e) => !!e.querySelector(t(r));
 export {
-  a as default,
   t as getFormNonFieldErrorMarkerQuerySelector,
-  l as hasNonFieldErrorMarkerInDOM
+  n as hasNonFieldErrorMarkerInDOM
 };

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

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

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

@@ -1,7 +1,7 @@
-import s from "../getFlatFieldErrors.mjs";
+import s from "../flat/getFlatFieldErrors.mjs";
 import { hasNonFieldErrorMarkerInDOM as l } from "../nonfield/FormNonFieldErrorMarker.utils.mjs";
 import m from "../nonfield/isNonFieldError.mjs";
-import { isFormErrorPathRoot as n } from "../root/utils.mjs";
+import n from "../root/isFormErrorPathRoot.mjs";
 const d = (o, t) => {
   const e = s(o);
   return Object.fromEntries(

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

@@ -1,10 +1,10 @@
 import r from "../../isEmptyObject.mjs";
-import t from "../useFormFieldErrors.mjs";
-import n from "./useOrphanFormErrors.mjs";
-const m = (o) => {
-  const s = n(o), e = t();
+import t from "../flat/useRefdFieldErrorsMemo.mjs";
+import m from "./useOrphanFormErrorsMemo.mjs";
+const n = (o) => {
+  const s = m(o), e = t();
   return r(s) ? !1 : !r(e);
-}, d = m;
+}, d = n;
 export {
   d as default
 };

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

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

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

@@ -0,0 +1,18 @@
+import "react";
+import n from "../useFormErrorsToConsole.mjs";
+import t from "./useOrphanFormErrorsMemo.mjs";
+const a = (r, s, e) => {
+  const o = t(r);
+  n("Orphan errors detected!", o, {
+    disabled: !e,
+    isDev: s,
+    isError: !0,
+    data: {
+      location: window.location,
+      orphans: o
+    }
+  });
+}, d = a;
+export {
+  d as default
+};

package/dist/esm/errors/outputErrors.mjs

@@ -0,0 +1,8 @@
+import t from "./consoleErrors.mjs";
+const c = (u, E, r) => {
+  if (t(u, E, r), r != null && r.isDev && r.isError)
+    throw new Error(u);
+}, f = c;
+export {
+  f as default
+};

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

@@ -0,0 +1,4 @@
+const o = "root";
+export {
+  o as FormErrorPathRoot
+};

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

@@ -0,0 +1,11 @@
+import e from "../flat/getFlatFieldErrors.mjs";
+import i from "./isFormErrorPathRoot.mjs";
+const a = (r) => {
+  const t = e(r);
+  return Object.fromEntries(
+    Object.entries(t).filter(([o]) => i(o))
+  );
+};
+export {
+  a as default
+};

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

@@ -0,0 +1,5 @@
+import { FormErrorPathRoot as r } from "./consts.mjs";
+const s = (o) => o === r || o.startsWith(r + ".");
+export {
+  s as default
+};

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

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

package/dist/esm/errors/useFormErrorConsoleDebug.mjs

@@ -1,8 +1,10 @@
-import e from "./useFormErrorsIfAny.mjs";
-const s = (o) => {
-  const r = e();
-  o && r && console.debug("useFormErrorConsoleDebug", r);
-}, n = s;
+import { useFormContext as s } from "react-hook-form";
+import t from "./outputErrors.mjs";
+import u from "./useFormErrorsIfAny.mjs";
+const m = (o) => {
+  const { getValues: e } = s(), r = u();
+  o && r && t("useFormErrorConsoleDebug", { values: e(), errors: r });
+}, i = m;
 export {
-  n as default
+  i as default
 };

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

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

package/dist/esm/errors/useFormErrorsToConsole.mjs

@@ -0,0 +1,21 @@
+import a from "react";
+import { useFormContext as c, useFormState as l } from "react-hook-form";
+import E from "../isEmptyObject.mjs";
+import d from "./outputErrors.mjs";
+const v = (e, m, r) => {
+  const { getValues: f } = c(), { errors: u } = l();
+  a.useEffect(() => {
+    if (!(r != null && r.disabled) && !E(m) && (d(e, { values: f(), errors: u }, r), console[r != null && r.isError ? "error" : "debug"](e, {
+      form: {
+        values: f(),
+        // form values
+        errors: u
+      },
+      other: r == null ? void 0 : r.data
+    }), r != null && r.isError))
+      throw new Error(e);
+  }, [u]);
+};
+export {
+  v as default
+};

package/dist/esm/errors/useFormRequestSubmit.mjs

@@ -1,8 +1,10 @@
 const r = (t) => (e) => {
   if (!t.current)
     throw new Error();
-  t.current.requestSubmit(e);
-}, u = r;
+  u(t.current, e);
+}, s = r, u = (t, e) => {
+  t.requestSubmit(e);
+};
 export {
-  u as default
+  s as default
 };

package/dist/esm/form/context/parent/FormParentContextProvider.mjs

@@ -0,0 +1,10 @@
+import { jsx as e } from "react/jsx-runtime";
+import s from "react";
+import { _FormParentContextProvider as n } from "./index.mjs";
+const a = ({ children: t }) => {
+  const [r, o] = s.useState(!1);
+  return /* @__PURE__ */ e(n, { value: { isBusy: r, setIsBusy: o }, children: t });
+}, P = a;
+export {
+  P as default
+};

package/dist/esm/form/context/parent/index.mjs

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

package/dist/esm/form/context/parent/useAsFormParentState.mjs

@@ -0,0 +1,14 @@
+import o from "react";
+import r from "../../useFormIsBusy.mjs";
+import { _useFormParentContext as s } from "./index.mjs";
+const n = () => {
+  const e = r(), t = s();
+  if (!t)
+    throw new Error("Parent context is not provided.");
+  o.useEffect(() => {
+    t.setIsBusy(e);
+  }, [t, e]);
+}, c = n;
+export {
+  c as default
+};

package/dist/esm/form/context/parent/useFormParentIsBusy.mjs

@@ -0,0 +1,8 @@
+import { _useFormParentContext as t } from "./index.mjs";
+const e = () => {
+  var s;
+  return (s = t()) == null ? void 0 : s.isBusy;
+}, r = e;
+export {
+  r as default
+};

package/dist/esm/form/useFormIsBusy.mjs

@@ -0,0 +1,9 @@
+import { useFormState as r } from "react-hook-form";
+import e from "./context/parent/useFormParentIsBusy.mjs";
+const m = () => {
+  const { isSubmitting: t, isLoading: o } = r(), s = e();
+  return !!(t || o || s);
+};
+export {
+  m as default
+};

package/dist/esm/main.mjs

@@ -1,36 +1,46 @@
 import { default as e } from "./devtool/LazyDevTool.mjs";
-import { default as t } from "./errors/message/FormErrorMessage.mjs";
-import { default as u } from "./errors/message/FormErrorMessageByPath.mjs";
-import { default as m } from "./errors/nonfield/FormNonFieldErrorMarker.mjs";
-import { default as d } from "./errors/nonfield/FormNonFieldErrorMarker.utils.mjs";
-import { default as F } from "./errors/orphan/useFormHasOrphanAndNoFieldErrors.mjs";
-import { default as n } from "./errors/orphan/useOrphanFormErrors.mjs";
-import { default as i } from "./errors/orphan/useOrphanFormErrorsToConsoleError.mjs";
-import { default as S } from "./errors/root/useRootFormFieldErrors.mjs";
+import { default as s } from "./errors/context/index.mjs";
+import { default as f } from "./errors/context/provider.mjs";
+import { default as u } from "./errors/message/FormErrorMessage.mjs";
+import { default as d } from "./errors/message/FormErrorMessageByPath.mjs";
+import { default as p } from "./errors/nonfield/FormNonFieldErrorMarker.mjs";
+import { default as n } from "./errors/nonfield/FormNonFieldErrorMarkerHtmlAttribute.mjs";
+import { default as i } from "./errors/orphan/useFormHasOrphanAndNoFieldErrors.mjs";
+import { default as c } from "./errors/orphan/useOrphanFormErrorsMemo.mjs";
+import { default as b } from "./errors/orphan/useOrphanFormErrorsToConsole.mjs";
+import { default as P } from "./errors/root/useRootFormFieldErrorsMemo.mjs";
 import { default as O } from "./errors/useFormErrorConsoleDebug.mjs";
-import { default as A } from "./errors/useFormErrorsEffect.mjs";
-import { default as M } from "./errors/useFormErrorsIfAny.mjs";
-import { default as y } from "./errors/useFormErrorsOnChange.mjs";
-import { default as N } from "./errors/useFormRequestSubmit.mjs";
-import { default as D } from "./submit/useFormOnSubmitSuccessful.mjs";
-import { default as T } from "./submit/useFormOnSubmitSuccessfulAndReset.mjs";
-import { default as v } from "./submit/useResetFormOnSubmitSuccessful.mjs";
+import { default as y } from "./errors/useFormErrorsEffect.mjs";
+import { default as g } from "./errors/useFormErrorsIfAny.mjs";
+import { default as N } from "./errors/useFormErrorsMemo.mjs";
+import { default as B } from "./errors/useFormRequestSubmit.mjs";
+import { default as H } from "./form/context/parent/FormParentContextProvider.mjs";
+import { default as T } from "./form/context/parent/useAsFormParentState.mjs";
+import { default as z } from "./form/context/parent/useFormParentIsBusy.mjs";
+import { default as j } from "./submit/useFormOnSubmitSuccessful.mjs";
+import { default as G } from "./submit/useFormOnSubmitSuccessfulAndReset.mjs";
+import { default as K } from "./submit/useResetFormOnSubmitSuccessful.mjs";
 export {
-  t as FormErrorMessage,
-  u as FormErrorMessageByPath,
-  m as FormNonFieldErrorMarker,
-  d as FormNonFieldErrorMarkerHtmlAttribute,
+  u as FormErrorMessage,
+  d as FormErrorMessageByPath,
+  f as FormErrorsFlatContextProvider,
+  p as FormNonFieldErrorMarker,
+  n as FormNonFieldErrorMarkerHtmlAttribute,
+  H as FormParentContextProvider,
   e as LazyDevTool,
+  T as useAsFormParentState,
   O as useFormErrorConsoleDebug,
-  A as useFormErrorsEffect,
-  M as useFormErrorsIfAny,
-  y as useFormErrorsOnChange,
-  F as useFormHasOrphanAndNoFieldErrors,
-  D as useFormOnSubmitSuccessful,
-  T as useFormOnSubmitSuccessfulAndReset,
-  N as useFormRequestSubmit,
-  n as useOrphanFormErrors,
-  i as useOrphanFormErrorsToConsoleError,
-  v as useResetFormAfterSubmitSuccessful,
-  S as useRootFormFieldErrors
+  y as useFormErrorsEffect,
+  s as useFormErrorsFlatContext,
+  g as useFormErrorsIfAny,
+  N as useFormErrorsMemo,
+  i as useFormHasOrphanAndNoFieldErrors,
+  j as useFormOnSubmitSuccessful,
+  G as useFormOnSubmitSuccessfulAndReset,
+  z as useFormParentIsBusy,
+  B as useFormRequestSubmit,
+  c as useOrphanFormErrorsMemo,
+  b as useOrphanFormErrorsToConsole,
+  K as useResetFormAfterSubmitSuccessful,
+  P as useRootFormFieldErrorsMemo
 };

package/dist/esm/submit/useResetFormOnSubmitSuccessful.mjs

@@ -1,11 +1,14 @@
-import { useFormContext as r } from "react-hook-form";
-import t from "./useFormOnSubmitSuccessful.mjs";
-const s = (e) => {
-  const { reset: u } = r();
-  t(() => {
-    e != null && e.enabled && u(void 0, e);
+import { useFormContext as u } from "react-hook-form";
+import o from "./useFormOnSubmitSuccessful.mjs";
+const r = ({
+  enabled: e,
+  ...t
+}) => {
+  const { reset: s } = u();
+  o(() => {
+    e && s(void 0, t);
   });
-}, f = s;
+}, f = r;
 export {
   f as default
 };

package/dist/esm/utils/createContext.mjs

@@ -0,0 +1,13 @@
+import r from "react";
+function u() {
+  const t = r.createContext(void 0), e = () => r.useContext(t);
+  return [e, () => {
+    const o = e();
+    if (o === void 0)
+      throw new Error();
+    return o;
+  }, t.Provider];
+}
+export {
+  u as default
+};

package/dist/types/devtool/LazyDevTool.d.ts

@@ -1,11 +1,11 @@
 import { default as React } from 'react';
 import { DevtoolUIProps } from '@hookform/devtools/dist/devToolUI';
 
-type Props = Omit<DevtoolUIProps, 'control'> & {
+export type LazyDevToolProps = Omit<DevtoolUIProps, 'control'> & {
     isDev: boolean;
 };
 /**
  * Lazy-loaded RHF DevTool.
  */
-declare const LazyDevTool: React.FC<Props>;
+declare const LazyDevTool: React.FC<LazyDevToolProps>;
 export default LazyDevTool;

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

@@ -0,0 +1,13 @@
+import { FieldErrors, FieldValues } from 'react-hook-form';
+
+/**
+ * Output form values and errors to console.
+ */
+declare const consoleErrors: (message: string, form: {
+    values: FieldValues;
+    errors: FieldErrors;
+}, options?: {
+    other?: Record<string, unknown>;
+    isError?: boolean;
+}) => void;
+export default consoleErrors;

package/dist/types/errors/context/index.d.ts

@@ -0,0 +1,10 @@
+import { FlatFieldErrors } from '../flat/types';
+
+export type FormErrorsFlatContext = {
+    all: FlatFieldErrors;
+    roots: FlatFieldErrors;
+    orphans: FlatFieldErrors;
+};
+declare const useFormErrorsFlatContextMaybe: () => FormErrorsFlatContext | undefined, useFormErrorsFlatContext: () => FormErrorsFlatContext, _FormErrorsFlatContextProvider: import('react').Provider<FormErrorsFlatContext | undefined>;
+export default useFormErrorsFlatContext;
+export { _FormErrorsFlatContextProvider, useFormErrorsFlatContextMaybe };

package/dist/types/errors/context/provider.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+type Props = React.PropsWithChildren<{
+    formRef: React.MutableRefObject<HTMLFormElement>;
+    isDev?: boolean;
+    outputErrors?: boolean;
+}>;
+/**
+ * Provides a flattened version of the form errors.
+ * Allows flattening and filtering to happen once per errors change.
+ */
+declare const FormErrorsFlatContextProvider: React.FC<Props>;
+export default FormErrorsFlatContextProvider;

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

@@ -0,0 +1,15 @@
+import { FieldErrors } from 'react-hook-form';
+
+/**
+ * Only flattens a {@link FieldErrors} object.
+ * @returns e.g.,
+ * ```
+ * {
+ *   "address.street.type": "too_short",
+ *   "address.street.ref.value": "123",
+ *   "address.street.message": "Required."
+ * }
+ * ```
+ */
+declare const flattenFieldErrors: (errors: FieldErrors) => Record<string, unknown>;
+export default flattenFieldErrors;

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

@@ -0,0 +1,25 @@
+import { FlatFieldErrors } from './types';
+import { FieldErrors } from 'react-hook-form';
+
+/**
+ * Get {@link FlatFieldErrors} from {@link FieldErrors}.
+ * This makes it easy to work with potentially deeply-nested {@link FieldErrors}.
+ *
+ * @param errors {@link FieldErrors} object.
+ * @returns FlatFieldErrors object.
+ *
+ * e.g.,
+ * ```
+ * [ "address.street", { "address.street": { type: "too_short", ref: { value: "123" }, message: "Required." } } ]
+ * ```
+ */
+declare const getFlatFieldErrors: (errors: FieldErrors) => FlatFieldErrors;
+export default getFlatFieldErrors;
+/**
+ * Regular expression to maybe match the end of a leaf node path.
+ *
+ * i.e., `name.type`, `address.street.message`
+ *
+ * iow: dot [?: non-capturing]("type" | "message")[\b word boundary][$ end of string]
+ */
+export declare const regexMaybeFieldErrorLeafNode: RegExp;

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

@@ -0,0 +1,9 @@
+import { FieldError, FieldErrors } from 'react-hook-form';
+
+/**
+ * Get flat field errors filtered by supplied predicate.
+ */
+declare const getFlatFieldErrorsByFilter: (errors: FieldErrors, predicate: (entry: [string, FieldError]) => boolean) => {
+    [k: string]: FieldError;
+};
+export default getFlatFieldErrorsByFilter;

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

@@ -0,0 +1,3 @@
+import { FieldError } from 'react-hook-form';
+
+export type FlatFieldErrors = Record<string, FieldError>;

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

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

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

@@ -0,0 +1,9 @@
+import { FlatFieldErrors } from './types';
+import { FieldErrors } from 'react-hook-form';
+
+/**
+ * Use errors with refs.
+ */
+declare const useRefdFieldErrorsMemo: () => FlatFieldErrors;
+export default useRefdFieldErrorsMemo;
+export declare const getFlatFieldFormErrors: (errors: FieldErrors) => FlatFieldErrors;

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

@@ -1,7 +1,2 @@
-/**
- * HTML data attribute for {@link FormNonFieldErrorMarker}.
- */
-declare const FormNonFieldErrorMarkerHtmlAttribute = "data-paragrav-rhf-utils-nonfield-error-marker-path";
-export default FormNonFieldErrorMarkerHtmlAttribute;
 export declare const getFormNonFieldErrorMarkerQuerySelector: (path: string) => string;
-export declare const hasNonFieldErrorMarkerInDOM: (path: string, parentElement: Pick<HTMLElement, 'querySelector'>) => Element | null;
+export declare const hasNonFieldErrorMarkerInDOM: (path: string, parentElement: Pick<HTMLElement, 'querySelector'>) => boolean;

package/dist/types/errors/nonfield/FormNonFieldErrorMarkerHtmlAttribute.d.ts

@@ -0,0 +1,5 @@
+/**
+ * HTML data attribute for {@link FormNonFieldErrorMarker}.
+ */
+declare const FormNonFieldErrorMarkerHtmlAttribute = "data-paragrav-rhf-utils-nonfield-error-marker-path";
+export default FormNonFieldErrorMarkerHtmlAttribute;

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

@@ -1,4 +1,4 @@
-import { FlatFieldErrors } from '../getFlatFieldErrors';
+import { FlatFieldErrors } from '../flat/types';
 import { FieldErrors } from 'react-hook-form';
 
 declare const getOrphanFlatFieldErrors: (errors: FieldErrors, parentElement: Pick<HTMLElement, 'querySelector'>) => FlatFieldErrors;

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

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+
+declare const useOrphanFormErrorsMemo: (formRef: React.RefObject<HTMLFormElement>) => import('../flat/types').FlatFieldErrors;
+export default useOrphanFormErrorsMemo;

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

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+
+/**
+ * Logs out orphan errors to console.error.
+ *
+ * When `isDev`, it will also throw an error to bring attention to dev.
+ */
+declare const useOrphanFormErrorsToConsole: (formRef: React.RefObject<HTMLFormElement>, isDev?: boolean, enabled?: boolean) => void;
+export default useOrphanFormErrorsToConsole;

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

@@ -0,0 +1,14 @@
+import { FieldErrors, FieldValues } from 'react-hook-form';
+
+/**
+ * Output form values and errors to console and throw in dev.
+ */
+declare const outputErrors: (message: string, form: {
+    values: FieldValues;
+    errors: FieldErrors;
+}, options?: {
+    other?: Record<string, unknown>;
+    isDev?: boolean;
+    isError?: boolean;
+}) => void;
+export default outputErrors;