@paragrav/rhf-utils 0.0.19 → 0.0.20

package/dist/cjs/errors/nonfield/FormNonFieldErrorMarker.js

@@ -1,13 +1,16 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const jsx_runtime_1 = require("react/jsx-runtime");
-const FormNonFieldErrorMarker_utils_1 = require("./FormNonFieldErrorMarker.utils");
+const FormNonFieldErrorMarker_utils_1 = __importDefault(require("./FormNonFieldErrorMarker.utils"));
 /**
  * Empty, hidden marker to indicate a non-field error is presented to user.
  */
 const FormNonFieldErrorMarker = ({ path }) => {
     const dataAttribute = {
-        [FormNonFieldErrorMarker_utils_1.FormNonFieldErrorMarkerHtmlAttribute]: path,
+        [FormNonFieldErrorMarker_utils_1.default]: path,
     };
     return ((0, jsx_runtime_1.jsx)("div", { role: "alert", "aria-hidden": "true" // hide from screen readers
         , style: { display: 'none' }, ...dataAttribute }));

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

@@ -1,6 +1,7 @@
 /**
  * HTML data attribute for {@link FormNonFieldErrorMarker}.
  */
-export declare const FormNonFieldErrorMarkerHtmlAttribute = "data-paragrav-rhf-utils-nonfield-error-marker-path";
+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;

package/dist/cjs/errors/nonfield/FormNonFieldErrorMarker.utils.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasNonFieldErrorMarkerInDOM = exports.getFormNonFieldErrorMarkerQuerySelector = exports.FormNonFieldErrorMarkerHtmlAttribute = void 0;
+exports.hasNonFieldErrorMarkerInDOM = exports.getFormNonFieldErrorMarkerQuerySelector = void 0;
 /**
  * HTML data attribute for {@link FormNonFieldErrorMarker}.
  */
-exports.FormNonFieldErrorMarkerHtmlAttribute = 'data-paragrav-rhf-utils-nonfield-error-marker-path';
-const getFormNonFieldErrorMarkerQuerySelector = (path) => `[role="alert"][${exports.FormNonFieldErrorMarkerHtmlAttribute}="${path}"]`;
+const FormNonFieldErrorMarkerHtmlAttribute = 'data-paragrav-rhf-utils-nonfield-error-marker-path';
+exports.default = FormNonFieldErrorMarkerHtmlAttribute;
+// utils
+const getFormNonFieldErrorMarkerQuerySelector = (path) => `[role="alert"][${FormNonFieldErrorMarkerHtmlAttribute}="${path}"]`;
 exports.getFormNonFieldErrorMarkerQuerySelector = getFormNonFieldErrorMarkerQuerySelector;
 const hasNonFieldErrorMarkerInDOM = (path, parentElement) => parentElement.querySelector((0, exports.getFormNonFieldErrorMarkerQuerySelector)(path));
 exports.hasNonFieldErrorMarkerInDOM = hasNonFieldErrorMarkerInDOM;

package/dist/cjs/errors/nonfield/utils.d.ts

@@ -12,6 +12,6 @@ import type { FieldError } from 'react-hook-form';
  *   - Orphan (undisplayed), which are typically caused by one of the following cases:
  *      - The input is missing.
  *      - The schema is incorrect.
- *      - The non-field error is not displayed to user with `FormErrorNonFieldMarker`.
+ *      - The error is not displayed to user with `FormErrorNonFieldMarker`.
  */
 export declare const isNonFieldError: (error: FieldError) => boolean;

package/dist/cjs/errors/nonfield/utils.js

@@ -14,7 +14,7 @@ exports.isNonFieldError = void 0;
  *   - Orphan (undisplayed), which are typically caused by one of the following cases:
  *      - The input is missing.
  *      - The schema is incorrect.
- *      - The non-field error is not displayed to user with `FormErrorNonFieldMarker`.
+ *      - The error is not displayed to user with `FormErrorNonFieldMarker`.
  */
 const isNonFieldError = (error) => !error.ref;
 exports.isNonFieldError = isNonFieldError;

package/dist/cjs/errors/orphan/useFormErrorsHasOnlyOrphans.d.ts

@@ -0,0 +1,2 @@
+declare const useFormErrorsHasOnlyOrphans: (formRef: React.RefObject<HTMLFormElement>) => boolean;
+export default useFormErrorsHasOnlyOrphans;

package/dist/cjs/errors/orphan/useFormErrorsHasOnlyOrphans.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@/utils");
+const useFormFlatFieldErrors_1 = __importDefault(require("../useFormFlatFieldErrors"));
+const useOrphanFormErrors_1 = __importDefault(require("./useOrphanFormErrors"));
+const useFormErrorsHasOnlyOrphans = (formRef) => {
+    // get flat field errors of orphans and all errors
+    const orphans = (0, useOrphanFormErrors_1.default)(formRef);
+    const errors = (0, useFormFlatFieldErrors_1.default)();
+    // if no orphans, or no errors
+    if ([orphans, errors].some(utils_1.isEmptyObject))
+        return false;
+    // equal length
+    return Object.keys(orphans).length === Object.keys(errors).length;
+};
+exports.default = useFormErrorsHasOnlyOrphans;

package/dist/cjs/errors/{orphans/useFormOrphanErrors.d.ts → orphan/useOrphanFormErrors.d.ts}

@@ -1,3 +1,3 @@
 import React from 'react';
-declare const useFormOrphanErrors: (formRef: React.RefObject<HTMLFormElement>) => import("@/errors/getFlatFieldErrors").FlatFieldErrors;
-export default useFormOrphanErrors;
+declare const useOrphanFormErrors: (formRef: React.RefObject<HTMLFormElement>) => import("@/errors/getFlatFieldErrors").FlatFieldErrors;
+export default useOrphanFormErrors;

package/dist/cjs/errors/{orphans/useFormOrphanErrors.js → orphan/useOrphanFormErrors.js}

@@ -6,14 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@/utils");
 const useFormErrorsOnChange_1 = __importDefault(require("../useFormErrorsOnChange"));
 const utils_2 = require("./utils");
-const useFormOrphanErrors = (formRef) => (0, useFormErrorsOnChange_1.default)((errors) => {
+const useOrphanFormErrors = (formRef) => (0, useFormErrorsOnChange_1.default)((errors) => {
     // if no errors, return early
     if ((0, utils_1.isEmptyObject)(errors))
         return {};
-    if (!formRef.current) {
-        console.error(errors);
-        throw new Error('This should not happen.');
-    }
-    return (0, utils_2.getRootFlatFieldErrors)(errors, formRef.current);
+    // this should never happen
+    if (!formRef.current)
+        throw new Error();
+    return (0, utils_2.getOrphanFlatFieldErrors)(errors, formRef.current);
 });
-exports.default = useFormOrphanErrors;
+exports.default = useOrphanFormErrors;

package/dist/cjs/errors/orphan/useOrphanFormErrorsToConsoleError.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+/**
+ * Outputs orphan errors to `console.error` all errors with `ref: undefined` that do not begin with `root(.*)`.
+ * Sentry (or equivalent) should capture.
+ */
+declare const useOrphanFormErrorsToConsoleError: (formRef: React.RefObject<HTMLFormElement>) => void;
+export default useOrphanFormErrorsToConsoleError;

package/dist/cjs/errors/{orphans/useFormErrorOrphansToConsoleError.js → orphan/useOrphanFormErrorsToConsoleError.js}

@@ -5,25 +5,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = __importDefault(require("react"));
 const react_hook_form_1 = require("react-hook-form");
-const useFormOrphanErrors_1 = __importDefault(require("./useFormOrphanErrors"));
+const useOrphanFormErrors_1 = __importDefault(require("./useOrphanFormErrors"));
 /**
- * Orphans are field errors that do not have a ref.
- * (Most commonly `root(.*)`, but these are filtered out. They are handled by `useFormRootFieldErrors`.)
- * Outputs to `console.error` all errors with `ref: undefined` that do not begin with `root(.*)`.
+ * Outputs orphan errors to `console.error` all errors with `ref: undefined` that do not begin with `root(.*)`.
  * Sentry (or equivalent) should capture.
  */
-const useFormErrorOrphansToConsoleError = (formRef) => {
+const useOrphanFormErrorsToConsoleError = (formRef) => {
     const { getValues } = (0, react_hook_form_1.useFormContext)();
     const { errors } = (0, react_hook_form_1.useFormState)();
-    const orphans = (0, useFormOrphanErrors_1.default)(formRef);
+    const orphans = (0, useOrphanFormErrors_1.default)(formRef);
     react_1.default.useEffect(() => {
         if (!Object.keys(orphans).length)
             return;
-        console.error('useFormErrorOrphansToConsoleError', {
+        console.error('useOrphanFormErrorsToConsoleError', {
             location: window.location,
             values: getValues(),
             orphans,
         });
     }, [errors, getValues, orphans]);
 };
-exports.default = useFormErrorOrphansToConsoleError;
+exports.default = useOrphanFormErrorsToConsoleError;

package/dist/cjs/errors/orphan/utils.d.ts

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

package/dist/cjs/errors/{orphans → orphan}/utils.js

@@ -3,12 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRootFlatFieldErrors = void 0;
+exports.getOrphanFlatFieldErrors = void 0;
 const getFlatFieldErrors_1 = __importDefault(require("../getFlatFieldErrors"));
 const FormNonFieldErrorMarker_utils_1 = require("../nonfield/FormNonFieldErrorMarker.utils");
 const utils_1 = require("../nonfield/utils");
 const utils_2 = require("../root/utils");
-const getRootFlatFieldErrors = (errors, parentElement) => {
+const getOrphanFlatFieldErrors = (errors, parentElement) => {
     const flatFieldErrors = (0, getFlatFieldErrors_1.default)(errors);
     return Object.fromEntries(Object.entries(flatFieldErrors).filter(([path, error]) => 
     // not root path
@@ -18,4 +18,4 @@ const getRootFlatFieldErrors = (errors, parentElement) => {
         // does not have marker
         !(0, FormNonFieldErrorMarker_utils_1.hasNonFieldErrorMarkerInDOM)(path, parentElement)));
 };
-exports.getRootFlatFieldErrors = getRootFlatFieldErrors;
+exports.getOrphanFlatFieldErrors = getOrphanFlatFieldErrors;

package/dist/cjs/errors/root/{useFormRootFieldErrors.d.ts → useRootFormFieldErrors.d.ts}

@@ -2,5 +2,5 @@
  * Root field errors from form.
  * These are typically displayed at the bottom of the form.
  */
-declare const useFormRootFieldErrors: () => import("@/errors/getFlatFieldErrors").FlatFieldErrors;
-export default useFormRootFieldErrors;
+declare const useRootFormFieldErrors: () => import("@/errors/getFlatFieldErrors").FlatFieldErrors;
+export default useRootFormFieldErrors;

package/dist/cjs/errors/root/{useFormRootFieldErrors.js → useRootFormFieldErrors.js}

@@ -9,5 +9,5 @@ const utils_1 = require("./utils");
  * Root field errors from form.
  * These are typically displayed at the bottom of the form.
  */
-const useFormRootFieldErrors = () => (0, useFormErrorsOnChange_1.default)(utils_1.getRootFlatFieldErrors);
-exports.default = useFormRootFieldErrors;
+const useRootFormFieldErrors = () => (0, useFormErrorsOnChange_1.default)(utils_1.getRootFlatFieldErrors);
+exports.default = useRootFormFieldErrors;

package/dist/cjs/errors/useFormErrorConsoleDebug.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const useFormContextErrorsIfAny_1 = __importDefault(require("./useFormContextErrorsIfAny"));
+const useFormErrorsIfAny_1 = __importDefault(require("./useFormErrorsIfAny"));
 /**
  * Output form errors to console.debug() for easier debugging for certain condition.
  * (e.g., in dev/staging environments or certain users)
@@ -11,7 +11,7 @@ const useFormContextErrorsIfAny_1 = __importDefault(require("./useFormContextErr
  * `console.debug()` is unlikely to trigger any automated console capture reporting.
  */
 const useFormErrorConsoleDebug = (condition) => {
-    const errors = (0, useFormContextErrorsIfAny_1.default)();
+    const errors = (0, useFormErrorsIfAny_1.default)();
     if (!condition)
         return;
     if (!errors)

package/dist/cjs/errors/useFormErrorsIfAny.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns errors only if there are errors.
+ * Allows simple typeguard without `isEmpty` dependency.
+ */
+declare const useFormErrorsIfAny: () => false | import("react-hook-form").FieldErrors<import("react-hook-form").FieldValues>;
+export default useFormErrorsIfAny;

package/dist/cjs/errors/{useFormContextErrorsIfAny.js → useFormErrorsIfAny.js}

@@ -6,8 +6,8 @@ const utils_1 = require("@/utils");
  * Returns errors only if there are errors.
  * Allows simple typeguard without `isEmpty` dependency.
  */
-const useFormContextErrorsIfAny = () => {
+const useFormErrorsIfAny = () => {
     const { errors } = (0, react_hook_form_1.useFormState)();
     return (0, utils_1.isEmptyObject)(errors) ? false : errors;
 };
-exports.default = useFormContextErrorsIfAny;
+exports.default = useFormErrorsIfAny;

package/dist/cjs/errors/useFormFlatFieldErrors.d.ts

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

package/dist/cjs/errors/useFormFlatFieldErrors.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getFlatFieldErrors_1 = __importDefault(require("./getFlatFieldErrors"));
+const useFormErrorsOnChange_1 = __importDefault(require("./useFormErrorsOnChange"));
+/**
+ * Use {@link FieldErrors} as {@link FlatFieldErrors}.
+ */
+const useFormFlatFieldErrors = () => (0, useFormErrorsOnChange_1.default)(getFlatFieldErrors_1.default);
+exports.default = useFormFlatFieldErrors;

package/dist/cjs/main.d.ts

@@ -1,9 +1,11 @@
 export { default as FormNonFieldErrorMarker } from './errors/nonfield/FormNonFieldErrorMarker';
-export { FormNonFieldErrorMarkerHtmlAttribute } from './errors/nonfield/FormNonFieldErrorMarker.utils';
-export { default as useFormErrorOrphansToConsoleError } from './errors/orphans/useFormErrorOrphansToConsoleError';
-export { default as useFormOrphanErrors } from './errors/orphans/useFormOrphanErrors';
-export { default as useFormRootFieldErrors } from './errors/root/useFormRootFieldErrors';
+export { default as FormNonFieldErrorMarkerHtmlAttribute } from './errors/nonfield/FormNonFieldErrorMarker.utils';
+export { default as useFormErrorsHasOnlyOrphans } from './errors/orphan/useFormErrorsHasOnlyOrphans';
+export { default as useOrphanFormErrors } from './errors/orphan/useOrphanFormErrors';
+export { default as useOrphanFormErrorsToConsoleError } from './errors/orphan/useOrphanFormErrorsToConsoleError';
+export { default as useRootFormFieldErrors } from './errors/root/useRootFormFieldErrors';
 export { default as useFormErrorConsoleDebug } from './errors/useFormErrorConsoleDebug';
 export { default as useFormErrorsEffect } from './errors/useFormErrorsEffect';
+export { default as useFormErrorsIfAny } from './errors/useFormErrorsIfAny';
 export { default as useFormErrorsOnChange } from './errors/useFormErrorsOnChange';
 export { default as useFormRequestSubmit } from './errors/useFormRequestSubmit';

package/dist/cjs/main.js

@@ -3,21 +3,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useFormRequestSubmit = exports.useFormErrorsOnChange = exports.useFormErrorsEffect = exports.useFormErrorConsoleDebug = exports.useFormRootFieldErrors = exports.useFormOrphanErrors = exports.useFormErrorOrphansToConsoleError = exports.FormNonFieldErrorMarkerHtmlAttribute = exports.FormNonFieldErrorMarker = void 0;
+exports.useFormRequestSubmit = exports.useFormErrorsOnChange = exports.useFormErrorsIfAny = exports.useFormErrorsEffect = exports.useFormErrorConsoleDebug = exports.useRootFormFieldErrors = exports.useOrphanFormErrorsToConsoleError = exports.useOrphanFormErrors = exports.useFormErrorsHasOnlyOrphans = exports.FormNonFieldErrorMarkerHtmlAttribute = exports.FormNonFieldErrorMarker = void 0;
 var FormNonFieldErrorMarker_1 = require("./errors/nonfield/FormNonFieldErrorMarker");
 Object.defineProperty(exports, "FormNonFieldErrorMarker", { enumerable: true, get: function () { return __importDefault(FormNonFieldErrorMarker_1).default; } });
 var FormNonFieldErrorMarker_utils_1 = require("./errors/nonfield/FormNonFieldErrorMarker.utils");
-Object.defineProperty(exports, "FormNonFieldErrorMarkerHtmlAttribute", { enumerable: true, get: function () { return FormNonFieldErrorMarker_utils_1.FormNonFieldErrorMarkerHtmlAttribute; } });
-var useFormErrorOrphansToConsoleError_1 = require("./errors/orphans/useFormErrorOrphansToConsoleError");
-Object.defineProperty(exports, "useFormErrorOrphansToConsoleError", { enumerable: true, get: function () { return __importDefault(useFormErrorOrphansToConsoleError_1).default; } });
-var useFormOrphanErrors_1 = require("./errors/orphans/useFormOrphanErrors");
-Object.defineProperty(exports, "useFormOrphanErrors", { enumerable: true, get: function () { return __importDefault(useFormOrphanErrors_1).default; } });
-var useFormRootFieldErrors_1 = require("./errors/root/useFormRootFieldErrors");
-Object.defineProperty(exports, "useFormRootFieldErrors", { enumerable: true, get: function () { return __importDefault(useFormRootFieldErrors_1).default; } });
+Object.defineProperty(exports, "FormNonFieldErrorMarkerHtmlAttribute", { enumerable: true, get: function () { return __importDefault(FormNonFieldErrorMarker_utils_1).default; } });
+var useFormErrorsHasOnlyOrphans_1 = require("./errors/orphan/useFormErrorsHasOnlyOrphans");
+Object.defineProperty(exports, "useFormErrorsHasOnlyOrphans", { enumerable: true, get: function () { return __importDefault(useFormErrorsHasOnlyOrphans_1).default; } });
+var useOrphanFormErrors_1 = require("./errors/orphan/useOrphanFormErrors");
+Object.defineProperty(exports, "useOrphanFormErrors", { enumerable: true, get: function () { return __importDefault(useOrphanFormErrors_1).default; } });
+var useOrphanFormErrorsToConsoleError_1 = require("./errors/orphan/useOrphanFormErrorsToConsoleError");
+Object.defineProperty(exports, "useOrphanFormErrorsToConsoleError", { enumerable: true, get: function () { return __importDefault(useOrphanFormErrorsToConsoleError_1).default; } });
+var useRootFormFieldErrors_1 = require("./errors/root/useRootFormFieldErrors");
+Object.defineProperty(exports, "useRootFormFieldErrors", { enumerable: true, get: function () { return __importDefault(useRootFormFieldErrors_1).default; } });
 var useFormErrorConsoleDebug_1 = require("./errors/useFormErrorConsoleDebug");
 Object.defineProperty(exports, "useFormErrorConsoleDebug", { enumerable: true, get: function () { return __importDefault(useFormErrorConsoleDebug_1).default; } });
 var useFormErrorsEffect_1 = require("./errors/useFormErrorsEffect");
 Object.defineProperty(exports, "useFormErrorsEffect", { enumerable: true, get: function () { return __importDefault(useFormErrorsEffect_1).default; } });
+var useFormErrorsIfAny_1 = require("./errors/useFormErrorsIfAny");
+Object.defineProperty(exports, "useFormErrorsIfAny", { enumerable: true, get: function () { return __importDefault(useFormErrorsIfAny_1).default; } });
 var useFormErrorsOnChange_1 = require("./errors/useFormErrorsOnChange");
 Object.defineProperty(exports, "useFormErrorsOnChange", { enumerable: true, get: function () { return __importDefault(useFormErrorsOnChange_1).default; } });
 var useFormRequestSubmit_1 = require("./errors/useFormRequestSubmit");

package/dist/esm/errors/getFlatFieldErrors.mjs

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

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

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

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

@@ -1,6 +1,6 @@
-const o = "data-paragrav-rhf-utils-nonfield-error-marker-path", t = (r) => `[role="alert"][${o}="${r}"]`, a = (r, e) => e.querySelector(t(r));
+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));
 export {
-  o as FormNonFieldErrorMarkerHtmlAttribute,
+  a as default,
   t as getFormNonFieldErrorMarkerQuerySelector,
-  a as hasNonFieldErrorMarkerInDOM
+  l as hasNonFieldErrorMarkerInDOM
 };

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

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

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

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

package/dist/esm/errors/{orphans/useFormErrorOrphansToConsoleError.mjs → orphan/useOrphanFormErrorsToConsoleError.mjs}

@@ -1,10 +1,10 @@
 import t from "react";
 import { useFormContext as n, useFormState as a } from "react-hook-form";
-import m from "./useFormOrphanErrors.mjs";
+import m from "./useOrphanFormErrors.mjs";
 const c = (e) => {
   const { getValues: o } = n(), { errors: s } = a(), r = m(e);
   t.useEffect(() => {
-    Object.keys(r).length && console.error("useFormErrorOrphansToConsoleError", {
+    Object.keys(r).length && console.error("useOrphanFormErrorsToConsoleError", {
       location: window.location,
       values: o(),
       orphans: r

package/dist/esm/errors/{orphans → orphan}/utils.mjs

@@ -16,5 +16,5 @@ const d = (o, t) => {
   );
 };
 export {
-  d as getRootFlatFieldErrors
+  d as getOrphanFlatFieldErrors
 };

package/dist/esm/errors/useFormErrorConsoleDebug.mjs

@@ -1,8 +1,8 @@
-import e from "./useFormContextErrorsIfAny.mjs";
+import e from "./useFormErrorsIfAny.mjs";
 const s = (o) => {
   const r = e();
   o && r && console.debug("useFormErrorConsoleDebug", r);
-}, u = s;
+}, n = s;
 export {
-  u as default
+  n as default
 };

package/dist/esm/errors/useFormErrorsIfAny.mjs

@@ -0,0 +1,9 @@
+import { useFormState as o } from "react-hook-form";
+import { isEmptyObject as s } from "../utils.mjs";
+const t = () => {
+  const { errors: r } = o();
+  return s(r) ? !1 : r;
+}, f = t;
+export {
+  f as default
+};

package/dist/esm/errors/useFormFlatFieldErrors.mjs

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

package/dist/esm/main.mjs

@@ -1,20 +1,24 @@
 import { default as e } from "./errors/nonfield/FormNonFieldErrorMarker.mjs";
-import { FormNonFieldErrorMarkerHtmlAttribute as s } from "./errors/nonfield/FormNonFieldErrorMarker.utils.mjs";
-import { default as m } from "./errors/orphans/useFormErrorOrphansToConsoleError.mjs";
-import { default as u } from "./errors/orphans/useFormOrphanErrors.mjs";
-import { default as F } from "./errors/root/useFormRootFieldErrors.mjs";
-import { default as p } from "./errors/useFormErrorConsoleDebug.mjs";
-import { default as x } from "./errors/useFormErrorsEffect.mjs";
-import { default as i } from "./errors/useFormErrorsOnChange.mjs";
-import { default as h } from "./errors/useFormRequestSubmit.mjs";
+import { default as t } from "./errors/nonfield/FormNonFieldErrorMarker.utils.mjs";
+import { default as f } from "./errors/orphan/useFormErrorsHasOnlyOrphans.mjs";
+import { default as u } from "./errors/orphan/useOrphanFormErrors.mjs";
+import { default as d } from "./errors/orphan/useOrphanFormErrorsToConsoleError.mjs";
+import { default as F } from "./errors/root/useRootFormFieldErrors.mjs";
+import { default as n } from "./errors/useFormErrorConsoleDebug.mjs";
+import { default as i } from "./errors/useFormErrorsEffect.mjs";
+import { default as h } from "./errors/useFormErrorsIfAny.mjs";
+import { default as C } from "./errors/useFormErrorsOnChange.mjs";
+import { default as k } from "./errors/useFormRequestSubmit.mjs";
 export {
   e as FormNonFieldErrorMarker,
-  s as FormNonFieldErrorMarkerHtmlAttribute,
-  p as useFormErrorConsoleDebug,
-  m as useFormErrorOrphansToConsoleError,
-  x as useFormErrorsEffect,
-  i as useFormErrorsOnChange,
-  u as useFormOrphanErrors,
-  h as useFormRequestSubmit,
-  F as useFormRootFieldErrors
+  t as FormNonFieldErrorMarkerHtmlAttribute,
+  n as useFormErrorConsoleDebug,
+  i as useFormErrorsEffect,
+  f as useFormErrorsHasOnlyOrphans,
+  h as useFormErrorsIfAny,
+  C as useFormErrorsOnChange,
+  k as useFormRequestSubmit,
+  u as useOrphanFormErrors,
+  d as useOrphanFormErrorsToConsoleError,
+  F as useRootFormFieldErrors
 };

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

@@ -1,6 +1,7 @@
 /**
  * HTML data attribute for {@link FormNonFieldErrorMarker}.
  */
-export declare const FormNonFieldErrorMarkerHtmlAttribute = "data-paragrav-rhf-utils-nonfield-error-marker-path";
+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;

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

@@ -13,6 +13,6 @@ import { FieldError } from 'react-hook-form';
  *   - Orphan (undisplayed), which are typically caused by one of the following cases:
  *      - The input is missing.
  *      - The schema is incorrect.
- *      - The non-field error is not displayed to user with `FormErrorNonFieldMarker`.
+ *      - The error is not displayed to user with `FormErrorNonFieldMarker`.
  */
 export declare const isNonFieldError: (error: FieldError) => boolean;

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

@@ -0,0 +1,2 @@
+declare const useFormErrorsHasOnlyOrphans: (formRef: React.RefObject<HTMLFormElement>) => boolean;
+export default useFormErrorsHasOnlyOrphans;

package/dist/types/errors/{orphans/useFormOrphanErrors.d.ts → orphan/useOrphanFormErrors.d.ts}

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

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

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+
+/**
+ * Outputs orphan errors to `console.error` all errors with `ref: undefined` that do not begin with `root(.*)`.
+ * Sentry (or equivalent) should capture.
+ */
+declare const useOrphanFormErrorsToConsoleError: (formRef: React.RefObject<HTMLFormElement>) => void;
+export default useOrphanFormErrorsToConsoleError;

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

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

package/dist/types/errors/root/{useFormRootFieldErrors.d.ts → useRootFormFieldErrors.d.ts}

@@ -2,5 +2,5 @@
  * Root field errors from form.
  * These are typically displayed at the bottom of the form.
  */
-declare const useFormRootFieldErrors: () => import('../getFlatFieldErrors').FlatFieldErrors;
-export default useFormRootFieldErrors;
+declare const useRootFormFieldErrors: () => import('../getFlatFieldErrors').FlatFieldErrors;
+export default useRootFormFieldErrors;

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

@@ -0,0 +1,6 @@
+/**
+ * Returns errors only if there are errors.
+ * Allows simple typeguard without `isEmpty` dependency.
+ */
+declare const useFormErrorsIfAny: () => false | import('react-hook-form').FieldErrors<import("react-hook-form").FieldValues>;
+export default useFormErrorsIfAny;

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

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

package/dist/types/main.d.ts

@@ -1,9 +1,11 @@
 export { default as FormNonFieldErrorMarker } from './errors/nonfield/FormNonFieldErrorMarker';
-export { FormNonFieldErrorMarkerHtmlAttribute } from './errors/nonfield/FormNonFieldErrorMarker.utils';
-export { default as useFormErrorOrphansToConsoleError } from './errors/orphans/useFormErrorOrphansToConsoleError';
-export { default as useFormOrphanErrors } from './errors/orphans/useFormOrphanErrors';
-export { default as useFormRootFieldErrors } from './errors/root/useFormRootFieldErrors';
+export { default as FormNonFieldErrorMarkerHtmlAttribute } from './errors/nonfield/FormNonFieldErrorMarker.utils';
+export { default as useFormErrorsHasOnlyOrphans } from './errors/orphan/useFormErrorsHasOnlyOrphans';
+export { default as useOrphanFormErrors } from './errors/orphan/useOrphanFormErrors';
+export { default as useOrphanFormErrorsToConsoleError } from './errors/orphan/useOrphanFormErrorsToConsoleError';
+export { default as useRootFormFieldErrors } from './errors/root/useRootFormFieldErrors';
 export { default as useFormErrorConsoleDebug } from './errors/useFormErrorConsoleDebug';
 export { default as useFormErrorsEffect } from './errors/useFormErrorsEffect';
+export { default as useFormErrorsIfAny } from './errors/useFormErrorsIfAny';
 export { default as useFormErrorsOnChange } from './errors/useFormErrorsOnChange';
 export { default as useFormRequestSubmit } from './errors/useFormRequestSubmit';

package/package.json

@@ -2,9 +2,10 @@
   "name": "@paragrav/rhf-utils",
   "author": "paragrav.dev",
   "license": "MIT",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "description": "Integration utilities for react-hook-form.",
   "type": "module",
+  "sideEffects": false,
   "files": [
     "dist"
   ],
@@ -12,22 +13,66 @@
   "module": "./dist/esm/main.mjs",
   "exports": {
     ".": {
-      "require": {
-        "types": "./dist/types/main.d.ts",
-        "default": "./dist/cjs/main.js"
-      },
-      "import": {
-        "types": "./dist/types/main.d.ts",
-        "default": "./dist/esm/main.mjs"
-      }
+      "import": "./dist/esm/main.mjs",
+      "require": "./dist/cjs/main.js",
+      "types": "./dist/types/main.d.ts"
     },
-    "./useFormErrorConsoleDebug": {
-      "types": "./dist/types/errors/useFormErrorConsoleDebug.d.ts",
+    "./errors/useFormErrorConsoleDebug": {
+      "import": "./dist/esm/errors/useFormErrorConsoleDebug.mjs",
       "require": "./dist/cjs/errors/useFormErrorConsoleDebug.cjs",
-      "import": "./dist/esm/errors/useFormErrorConsoleDebug.mjs"
+      "types": "./dist/types/errors/useFormErrorConsoleDebug.d.ts"
+    },
+    "./errors/useFormErrorsEffect": {
+      "import": "./dist/esm/errors/useFormErrorsEffect.mjs",
+      "require": "./dist/cjs/errors/useFormErrorsEffect.cjs",
+      "types": "./dist/types/errors/useFormErrorsEffect.d.ts"
+    },
+    "./errors/useFormErrorsIfAny": {
+      "import": "./dist/esm/errors/useFormErrorsIfAny.mjs",
+      "require": "./dist/cjs/errors/useFormErrorsIfAny.cjs",
+      "types": "./dist/types/errors/useFormErrorsIfAny.d.ts"
+    },
+    "./errors/useFormErrorsOnChange": {
+      "import": "./dist/esm/errors/useFormErrorsOnChange.mjs",
+      "require": "./dist/cjs/errors/useFormErrorsOnChange.cjs",
+      "types": "./dist/types/errors/useFormErrorsOnChange.d.ts"
+    },
+    "./errors/useFormRequestSubmit": {
+      "import": "./dist/esm/errors/useFormRequestSubmit.mjs",
+      "require": "./dist/cjs/errors/useFormRequestSubmit.cjs",
+      "types": "./dist/types/errors/useFormRequestSubmit.d.ts"
+    },
+    "./errors/FormNonFieldErrorMarker": {
+      "import": "./dist/esm/errors/nonfield/FormNonFieldErrorMarker.mjs",
+      "require": "./dist/cjs/errors/nonfield/FormNonFieldErrorMarker.cjs",
+      "types": "./dist/types/errors/nonfield/FormNonFieldErrorMarker.d.ts"
+    },
+    "./errors/FormNonFieldErrorMarkerHtmlAttribute": {
+      "import": "./dist/esm/errors/nonfield/FormNonFieldErrorMarker.utils.mjs",
+      "require": "./dist/cjs/errors/nonfield/FormNonFieldErrorMarker.utils.cjs",
+      "types": "./dist/types/errors/nonfield/FormNonFieldErrorMarker.utils.d.ts"
+    },
+    "./errors/useOrphanFormErrorsToConsoleError": {
+      "import": "./dist/esm/errors/orphan/useOrphanFormErrorsToConsoleError.mjs",
+      "require": "./dist/cjs/errors/orphan/useOrphanFormErrorsToConsoleError.cjs",
+      "types": "./dist/types/errors/orphan/useOrphanFormErrorsToConsoleError.d.ts"
+    },
+    "./errors/useFormErrorsHasOnlyOrphans": {
+      "import": "./dist/esm/errors/orphan/useFormErrorsHasOnlyOrphans.mjs",
+      "require": "./dist/cjs/errors/orphan/useFormErrorsHasOnlyOrphans.cjs",
+      "types": "./dist/types/errors/orphan/useFormErrorsHasOnlyOrphans.d.ts"
+    },
+    "./errors/useOrphanFormErrors": {
+      "import": "./dist/esm/errors/orphan/useOrphanFormErrors.mjs",
+      "require": "./dist/cjs/errors/orphan/useOrphanFormErrors.cjs",
+      "types": "./dist/types/errors/orphan/useOrphanFormErrors.d.ts"
+    },
+    "./errors/useRootFormFieldErrors": {
+      "import": "./dist/esm/errors/root/useRootFormFieldErrors.mjs",
+      "require": "./dist/cjs/errors/root/useRootFormFieldErrors.cjs",
+      "types": "./dist/types/errors/root/useRootFormFieldErrors.d.ts"
     }
   },
-  "sideEffects": false,
   "scripts": {
     "build": "npm run validate && npm run build:cjs && npm run build:esm",
     "build:cjs": "tsc -p ./tsconfig.cjs.json",

package/dist/cjs/errors/orphans/useFormErrorOrphansToConsoleError.d.ts

@@ -1,9 +0,0 @@
-import React from 'react';
-/**
- * Orphans are field errors that do not have a ref.
- * (Most commonly `root(.*)`, but these are filtered out. They are handled by `useFormRootFieldErrors`.)
- * Outputs to `console.error` all errors with `ref: undefined` that do not begin with `root(.*)`.
- * Sentry (or equivalent) should capture.
- */
-declare const useFormErrorOrphansToConsoleError: (formRef: React.RefObject<HTMLFormElement>) => void;
-export default useFormErrorOrphansToConsoleError;

package/dist/cjs/errors/orphans/useFormErrorsHasOnlyOrphan.d.ts

@@ -1,2 +0,0 @@
-declare const useFormErrorsHasOnlyOrphan: (formRef: React.RefObject<HTMLFormElement>) => boolean;
-export default useFormErrorsHasOnlyOrphan;

package/dist/cjs/errors/orphans/useFormErrorsHasOnlyOrphan.js

@@ -1,21 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("@/utils");
-const useFormContextErrorsIfAny_1 = __importDefault(require("../useFormContextErrorsIfAny"));
-const useFormOrphanErrors_1 = __importDefault(require("./useFormOrphanErrors"));
-const useFormErrorsHasOnlyOrphan = (formRef) => {
-    const orphans = (0, useFormOrphanErrors_1.default)(formRef);
-    const errors = (0, useFormContextErrorsIfAny_1.default)();
-    // no errors
-    if (!errors)
-        return false;
-    // no orphans
-    if ((0, utils_1.isEmptyObject)(orphans))
-        return false;
-    // equal length
-    return Object.keys(orphans).length === Object.keys(errors).length;
-};
-exports.default = useFormErrorsHasOnlyOrphan;

package/dist/cjs/errors/orphans/utils.d.ts

@@ -1,3 +0,0 @@
-import type { FieldErrors } from 'react-hook-form';
-import type { FlatFieldErrors } from '../getFlatFieldErrors';
-export declare const getRootFlatFieldErrors: (errors: FieldErrors, parentElement: Pick<HTMLElement, 'querySelector'>) => FlatFieldErrors;

package/dist/cjs/errors/useFormContextErrorsIfAny.d.ts

@@ -1,6 +0,0 @@
-/**
- * Returns errors only if there are errors.
- * Allows simple typeguard without `isEmpty` dependency.
- */
-declare const useFormContextErrorsIfAny: () => false | import("react-hook-form").FieldErrors<import("react-hook-form").FieldValues>;
-export default useFormContextErrorsIfAny;

package/dist/esm/errors/orphans/useFormOrphanErrors.mjs

@@ -1,14 +0,0 @@
-import "react";
-import { isEmptyObject as t } from "../../utils.mjs";
-import e from "../useFormErrorsOnChange.mjs";
-import { getRootFlatFieldErrors as n } from "./utils.mjs";
-const s = (o) => e((r) => {
-  if (t(r))
-    return {};
-  if (!o.current)
-    throw console.error(r), new Error("This should not happen.");
-  return n(r, o.current);
-}), a = s;
-export {
-  a as default
-};

package/dist/esm/errors/useFormContextErrorsIfAny.mjs

@@ -1,9 +0,0 @@
-import { useFormState as t } from "react-hook-form";
-import { isEmptyObject as o } from "../utils.mjs";
-const m = () => {
-  const { errors: r } = t();
-  return o(r) ? !1 : r;
-};
-export {
-  m as default
-};

package/dist/types/errors/orphans/useFormErrorOrphansToConsoleError.d.ts

@@ -1,10 +0,0 @@
-import { default as React } from 'react';
-
-/**
- * Orphans are field errors that do not have a ref.
- * (Most commonly `root(.*)`, but these are filtered out. They are handled by `useFormRootFieldErrors`.)
- * Outputs to `console.error` all errors with `ref: undefined` that do not begin with `root(.*)`.
- * Sentry (or equivalent) should capture.
- */
-declare const useFormErrorOrphansToConsoleError: (formRef: React.RefObject<HTMLFormElement>) => void;
-export default useFormErrorOrphansToConsoleError;

package/dist/types/errors/orphans/useFormErrorsHasOnlyOrphan.d.ts

@@ -1,2 +0,0 @@
-declare const useFormErrorsHasOnlyOrphan: (formRef: React.RefObject<HTMLFormElement>) => boolean;
-export default useFormErrorsHasOnlyOrphan;

package/dist/types/errors/orphans/utils.d.ts

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

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

@@ -1,6 +0,0 @@
-/**
- * Returns errors only if there are errors.
- * Allows simple typeguard without `isEmpty` dependency.
- */
-declare const useFormContextErrorsIfAny: () => false | import('react-hook-form').FieldErrors<import("react-hook-form").FieldValues>;
-export default useFormContextErrorsIfAny;