@paragrav/rhf-utils 0.0.17 → 0.0.19

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

@@ -0,0 +1,14 @@
+import type { 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/cjs/errors/flattenFieldErrors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const flat_1 = require("flat");
+/**
+ * Only flattens a {@link FieldErrors} object.
+ * @returns e.g.,
+ * ```
+ * {
+ *   "address.street.type": "too_short",
+ *   "address.street.ref.value": "123",
+ *   "address.street.message": "Required."
+ * }
+ * ```
+ */
+const flattenFieldErrors = (errors) => (0, flat_1.flatten)(errors);
+exports.default = flattenFieldErrors;

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

@@ -0,0 +1,16 @@
+import type { FieldError, FieldErrors } from 'react-hook-form';
+export type FlatFieldErrors = Record<string, FieldError>;
+/**
+ * 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;

package/dist/cjs/errors/getFlatFieldErrors.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_hook_form_1 = require("react-hook-form");
+const flattenFieldErrors_1 = __importDefault(require("./flattenFieldErrors"));
+/**
+ * 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." } } ]
+ * ```
+ */
+const getFlatFieldErrors = (errors) => {
+    const flattened = (0, flattenFieldErrors_1.default)(errors);
+    const keys = Object.keys(flattened);
+    return Object.fromEntries(keys.reduce((entries, key) => {
+        // look for leaf node, which would have required `type` prop (e.g., `name.type`, `address.street.type`)
+        // remove `regexEndsWithType` suffix to get flat field path (e.g., `name`, `address.street`)
+        const path = key.replace(regexEndsWithType, '');
+        // if nothing replaced, then it's not a leaf node
+        if (path === key)
+            return entries;
+        // find field error in FieldErrors object
+        // has dual-purpose of confirming that each path is valid
+        const fieldError = (0, react_hook_form_1.get)(errors, path, undefined);
+        if (!fieldError)
+            return entries;
+        entries.push([path, fieldError]);
+        return entries;
+    }, []));
+};
+exports.default = getFlatFieldErrors;
+const regexEndsWithType = /\.type$/;

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+type Props = {
+    /** Flat field name. (e.g., `address.street`) */
+    path: string;
+};
+/**
+ * Empty, hidden marker to indicate a non-field error is presented to user.
+ */
+declare const FormNonFieldErrorMarker: React.FC<Props>;
+export default FormNonFieldErrorMarker;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const FormNonFieldErrorMarker_utils_1 = 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,
+    };
+    return ((0, jsx_runtime_1.jsx)("div", { role: "alert", "aria-hidden": "true" // hide from screen readers
+        , style: { display: 'none' }, ...dataAttribute }));
+};
+exports.default = FormNonFieldErrorMarker;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,15 @@
+"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 experimental_ct_react_1 = require("@playwright/experimental-ct-react");
+const FormNonFieldErrorMarker_1 = __importDefault(require("./FormNonFieldErrorMarker"));
+const FormNonFieldErrorMarker_utils_1 = require("./FormNonFieldErrorMarker.utils");
+const path = 'test';
+const querySelector = (0, FormNonFieldErrorMarker_utils_1.getFormNonFieldErrorMarkerQuerySelector)(path);
+(0, experimental_ct_react_1.test)('FormNonFieldErrorMarker can be located via query', async ({ page, mount, }) => {
+    await mount((0, jsx_runtime_1.jsx)(FormNonFieldErrorMarker_1.default, { path: path }));
+    await (0, experimental_ct_react_1.expect)(page.locator(querySelector)).toBeAttached();
+});

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

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasNonFieldErrorMarkerInDOM = exports.getFormNonFieldErrorMarkerQuerySelector = exports.FormNonFieldErrorMarkerHtmlAttribute = 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}"]`;
+exports.getFormNonFieldErrorMarkerQuerySelector = getFormNonFieldErrorMarkerQuerySelector;
+const hasNonFieldErrorMarkerInDOM = (path, parentElement) => parentElement.querySelector((0, exports.getFormNonFieldErrorMarkerQuerySelector)(path));
+exports.hasNonFieldErrorMarkerInDOM = hasNonFieldErrorMarkerInDOM;

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

@@ -0,0 +1,17 @@
+import type { FieldError } from 'react-hook-form';
+/**
+ * Determine if {@link FieldError} is a non-field error (i.e., has `ref`).
+ *
+ * A non-field error has no association to an input via {@link FieldError.ref}.
+ *
+ * These fall into one of two categories:
+ * - Root, which are typically displayed to user at bottom/top of form.
+ * - Non-root, which fall into two main sub-sets:
+ *   - Non-orphan (displayed -- typically manually)
+ *     - e.g., array min/max validation
+ *   - 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`.
+ */
+export declare const isNonFieldError: (error: FieldError) => boolean;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNonFieldError = void 0;
+/**
+ * Determine if {@link FieldError} is a non-field error (i.e., has `ref`).
+ *
+ * A non-field error has no association to an input via {@link FieldError.ref}.
+ *
+ * These fall into one of two categories:
+ * - Root, which are typically displayed to user at bottom/top of form.
+ * - Non-root, which fall into two main sub-sets:
+ *   - Non-orphan (displayed -- typically manually)
+ *     - e.g., array min/max validation
+ *   - 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`.
+ */
+const isNonFieldError = (error) => !error.ref;
+exports.isNonFieldError = isNonFieldError;

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

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

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

@@ -0,0 +1,21 @@
+"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/useFormOrphanErrors.d.ts

@@ -1,8 +1,3 @@
 import React from 'react';
-/**
- * Root field errors from form.
- * These are typically displayed at the bottom of the form.
- * (Root errors have to processed this way due to (potentially) recursive types.)
- */
-declare const useFormOrphanErrors: (formRef: React.RefObject<HTMLFormElement>) => Record<string, import("react-hook-form").FieldError>;
+declare const useFormOrphanErrors: (formRef: React.RefObject<HTMLFormElement>) => import("@/errors/getFlatFieldErrors").FlatFieldErrors;
 export default useFormOrphanErrors;

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

@@ -3,20 +3,17 @@ 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 useFormErrorsOnChange_1 = __importDefault(require("../useFormErrorsOnChange"));
-const utils_1 = require("./utils");
-/**
- * Root field errors from form.
- * These are typically displayed at the bottom of the form.
- * (Root errors have to processed this way due to (potentially) recursive types.)
- */
+const utils_2 = require("./utils");
 const useFormOrphanErrors = (formRef) => (0, useFormErrorsOnChange_1.default)((errors) => {
-    if (JSON.stringify(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_1.getOrphanFieldErrorsWithMarkerCheck)(errors, formRef.current);
+    return (0, utils_2.getRootFlatFieldErrors)(errors, formRef.current);
 });
 exports.default = useFormOrphanErrors;

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

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

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

@@ -1,20 +1,21 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOrphanFieldErrorsWithMarkerCheck = exports.getOrphanFieldErrors = void 0;
-const utils_1 = require("../roots/utils");
-const utils_2 = require("../utils");
-const FormErrorNonFieldMarker_1 = require("./FormErrorNonFieldMarker");
-const getOrphanFieldErrors = (errors) => (0, utils_2.getFieldErrorsByFilter)(errors, (path, flattenedErrors) => {
-    return (flattenedErrors[path + '.ref'] === undefined && // no ref
-        !(0, utils_1.isFormErrorPathRoot)(path) // ignore root errors, which are always orphans
-    );
-});
-exports.getOrphanFieldErrors = getOrphanFieldErrors;
-const getOrphanFieldErrorsWithMarkerCheck = (errors, formElement) => {
-    const orphanErrors = (0, exports.getOrphanFieldErrors)(errors);
-    return (0, utils_2.getFieldErrorsByFilter)(orphanErrors, 
-    // if doesn't have alert, then it's an orphan
-    (path) => !formElement.querySelector(`[role="alert"][${FormErrorNonFieldMarker_1.FormErrorNonFieldMarkerHtmlAttribute}="${path}"]`));
+exports.getRootFlatFieldErrors = 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 flatFieldErrors = (0, getFlatFieldErrors_1.default)(errors);
+    return Object.fromEntries(Object.entries(flatFieldErrors).filter(([path, error]) => 
+    // not root path
+    !(0, utils_2.isFormErrorPathRoot)(path) &&
+        // non-field
+        (0, utils_1.isNonFieldError)(error) &&
+        // does not have marker
+        !(0, FormNonFieldErrorMarker_utils_1.hasNonFieldErrorMarkerInDOM)(path, parentElement)));
 };
-exports.getOrphanFieldErrorsWithMarkerCheck = getOrphanFieldErrorsWithMarkerCheck;
-//
+exports.getRootFlatFieldErrors = getRootFlatFieldErrors;

package/dist/cjs/errors/root/useFormRootFieldErrors.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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;

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

@@ -5,5 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const useFormErrorsOnChange_1 = __importDefault(require("../useFormErrorsOnChange"));
 const utils_1 = require("./utils");
-const useFormRootFieldErrors = () => (0, useFormErrorsOnChange_1.default)(utils_1.getRootFieldErrorList);
+/**
+ * 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;

package/dist/cjs/errors/{roots → root}/utils.d.ts

@@ -1,7 +1,11 @@
 import type { FieldErrors } from 'react-hook-form';
+import type { FlatFieldErrors } from '../getFlatFieldErrors';
 /**
  * Determine if an error path is root. (e.g., `root` or `root.nested`)
  * @param path Flat path. (e.g., 'root.nested')
  */
 export declare const isFormErrorPathRoot: (path: string) => boolean;
-export declare const getRootFieldErrorList: (errors: FieldErrors) => import("react-hook-form").FieldError[];
+/**
+ *
+ */
+export declare const getRootFlatFieldErrors: (errors: FieldErrors) => FlatFieldErrors;

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

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRootFlatFieldErrors = exports.isFormErrorPathRoot = void 0;
+const getFlatFieldErrors_1 = __importDefault(require("../getFlatFieldErrors"));
+const ROOT = 'root';
+/**
+ * Determine if an error path is root. (e.g., `root` or `root.nested`)
+ * @param path Flat path. (e.g., 'root.nested')
+ */
+const isFormErrorPathRoot = (path) => path === ROOT || path.startsWith(ROOT + '.');
+exports.isFormErrorPathRoot = isFormErrorPathRoot;
+/**
+ *
+ */
+const getRootFlatFieldErrors = (errors) => {
+    const flatFieldErrors = (0, getFlatFieldErrors_1.default)(errors);
+    return Object.fromEntries(Object.entries(flatFieldErrors)
+        // only include entries whose paths are "root"
+        .filter(([path]) => (0, exports.isFormErrorPathRoot)(path)));
+};
+exports.getRootFlatFieldErrors = getRootFlatFieldErrors;

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

@@ -0,0 +1,6 @@
+/**
+ * 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/cjs/errors/useFormContextErrorsIfAny.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_hook_form_1 = require("react-hook-form");
+const utils_1 = require("@/utils");
+/**
+ * Returns errors only if there are errors.
+ * Allows simple typeguard without `isEmpty` dependency.
+ */
+const useFormContextErrorsIfAny = () => {
+    const { errors } = (0, react_hook_form_1.useFormState)();
+    return (0, utils_1.isEmptyObject)(errors) ? false : errors;
+};
+exports.default = useFormContextErrorsIfAny;

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

@@ -0,0 +1,8 @@
+/**
+ * Output form errors to console.debug() for easier debugging for certain condition.
+ * (e.g., in dev/staging environments or certain users)
+ *
+ * `console.debug()` is unlikely to trigger any automated console capture reporting.
+ */
+declare const useFormErrorConsoleDebug: (condition: boolean) => void;
+export default useFormErrorConsoleDebug;

package/dist/cjs/errors/useFormErrorConsoleDebug.js

@@ -0,0 +1,22 @@
+"use strict";
+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"));
+/**
+ * Output form errors to console.debug() for easier debugging for certain condition.
+ * (e.g., in dev/staging environments or certain users)
+ *
+ * `console.debug()` is unlikely to trigger any automated console capture reporting.
+ */
+const useFormErrorConsoleDebug = (condition) => {
+    const errors = (0, useFormContextErrorsIfAny_1.default)();
+    if (!condition)
+        return;
+    if (!errors)
+        return;
+    // eslint-disable-next-line no-console
+    console.debug('useFormErrorConsoleDebug', errors);
+};
+exports.default = useFormErrorConsoleDebug;

package/dist/cjs/main.d.ts

@@ -1,7 +1,9 @@
-export { default as FormErrorNonFieldMarker, FormErrorNonFieldMarkerHtmlAttribute as FormErrorNonFieldMarkerDataHtmlAttribute, } from './errors/orphans/FormErrorNonFieldMarker';
+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/roots/useFormRootFieldErrors';
+export { default as useFormRootFieldErrors } from './errors/root/useFormRootFieldErrors';
+export { default as useFormErrorConsoleDebug } from './errors/useFormErrorConsoleDebug';
 export { default as useFormErrorsEffect } from './errors/useFormErrorsEffect';
 export { default as useFormErrorsOnChange } from './errors/useFormErrorsOnChange';
 export { default as useFormRequestSubmit } from './errors/useFormRequestSubmit';

package/dist/cjs/main.js

@@ -3,16 +3,19 @@ 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.useFormRootFieldErrors = exports.useFormOrphanErrors = exports.useFormErrorOrphansToConsoleError = exports.FormErrorNonFieldMarkerDataHtmlAttribute = exports.FormErrorNonFieldMarker = void 0;
-var FormErrorNonFieldMarker_1 = require("./errors/orphans/FormErrorNonFieldMarker");
-Object.defineProperty(exports, "FormErrorNonFieldMarker", { enumerable: true, get: function () { return __importDefault(FormErrorNonFieldMarker_1).default; } });
-Object.defineProperty(exports, "FormErrorNonFieldMarkerDataHtmlAttribute", { enumerable: true, get: function () { return FormErrorNonFieldMarker_1.FormErrorNonFieldMarkerHtmlAttribute; } });
+exports.useFormRequestSubmit = exports.useFormErrorsOnChange = exports.useFormErrorsEffect = exports.useFormErrorConsoleDebug = exports.useFormRootFieldErrors = exports.useFormOrphanErrors = exports.useFormErrorOrphansToConsoleError = 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/roots/useFormRootFieldErrors");
+var useFormRootFieldErrors_1 = require("./errors/root/useFormRootFieldErrors");
 Object.defineProperty(exports, "useFormRootFieldErrors", { enumerable: true, get: function () { return __importDefault(useFormRootFieldErrors_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 useFormErrorsOnChange_1 = require("./errors/useFormErrorsOnChange");

package/dist/cjs/utils.d.ts

@@ -0,0 +1 @@
+export declare const isEmptyObject: (obj: Record<string, unknown>) => boolean;

package/dist/cjs/utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmptyObject = void 0;
+const isEmptyObject = (obj) => JSON.stringify(obj) === '{}';
+exports.isEmptyObject = isEmptyObject;

package/dist/esm/errors/flattenFieldErrors.mjs

@@ -0,0 +1,5 @@
+import { flatten as r } from "flat";
+const o = (t) => r(t);
+export {
+  o as default
+};

package/dist/esm/errors/getFlatFieldErrors.mjs

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

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

@@ -0,0 +1,19 @@
+import { jsx as t } from "react/jsx-runtime";
+import { FormNonFieldErrorMarkerHtmlAttribute as e } from "./FormNonFieldErrorMarker.utils.mjs";
+const a = ({ path: r }) => {
+  const o = {
+    [e]: r
+  };
+  return /* @__PURE__ */ t(
+    "div",
+    {
+      role: "alert",
+      "aria-hidden": "true",
+      style: { display: "none" },
+      ...o
+    }
+  );
+}, d = a;
+export {
+  d as default
+};

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

@@ -0,0 +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));
+export {
+  o as FormNonFieldErrorMarkerHtmlAttribute,
+  t as getFormNonFieldErrorMarkerQuerySelector,
+  a as hasNonFieldErrorMarkerInDOM
+};

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

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

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

@@ -1,13 +1,14 @@
 import "react";
-import n from "../useFormErrorsOnChange.mjs";
-import { getOrphanFieldErrorsWithMarkerCheck as t } from "./utils.mjs";
-const e = (o) => n((r) => {
-  if (JSON.stringify(r) === "{}")
+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 t(r, o.current);
-}), p = e;
+  return n(r, o.current);
+}), a = s;
 export {
-  p as default
+  a as default
 };

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

@@ -1,18 +1,20 @@
-import { isFormErrorPathRoot as l } from "../roots/utils.mjs";
-import { getFieldErrorsByFilter as t } from "../utils.mjs";
-import { FormErrorNonFieldMarkerHtmlAttribute as m } from "./FormErrorNonFieldMarker.mjs";
-const n = (o) => t(o, (r, e) => e[r + ".ref"] === void 0 && // no ref
-!l(r)), p = (o, r) => {
-  const e = n(o);
-  return t(
-    e,
-    // if doesn't have alert, then it's an orphan
-    (i) => !r.querySelector(
-      `[role="alert"][${m}="${i}"]`
+import m from "../getFlatFieldErrors.mjs";
+import { hasNonFieldErrorMarkerInDOM as s } from "../nonfield/FormNonFieldErrorMarker.utils.mjs";
+import { isNonFieldError as l } from "../nonfield/utils.mjs";
+import { isFormErrorPathRoot as n } from "../root/utils.mjs";
+const d = (o, t) => {
+  const e = m(o);
+  return Object.fromEntries(
+    Object.entries(e).filter(
+      ([r, i]) => (
+        // not root path
+        !n(r) && // non-field
+        l(i) && // does not have marker
+        !s(r, t)
+      )
     )
   );
 };
 export {
-  n as getOrphanFieldErrors,
-  p as getOrphanFieldErrorsWithMarkerCheck
+  d as getRootFlatFieldErrors
 };

package/dist/esm/errors/{roots → root}/useFormRootFieldErrors.mjs

@@ -1,5 +1,5 @@
 import o from "../useFormErrorsOnChange.mjs";
-import { getRootFieldErrorList as r } from "./utils.mjs";
+import { getRootFlatFieldErrors as r } from "./utils.mjs";
 const t = () => o(r), m = t;
 export {
   m as default

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

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

package/dist/esm/errors/useFormContextErrorsIfAny.mjs

@@ -0,0 +1,9 @@
+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/esm/errors/useFormErrorConsoleDebug.mjs

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

package/dist/esm/main.mjs

@@ -1,17 +1,20 @@
-import { default as e, FormErrorNonFieldMarkerHtmlAttribute as t } from "./errors/orphans/FormErrorNonFieldMarker.mjs";
-import { default as s } from "./errors/orphans/useFormErrorOrphansToConsoleError.mjs";
+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 l } from "./errors/roots/useFormRootFieldErrors.mjs";
-import { default as d } from "./errors/useFormErrorsEffect.mjs";
-import { default as p } from "./errors/useFormErrorsOnChange.mjs";
-import { default as i } from "./errors/useFormRequestSubmit.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";
 export {
-  e as FormErrorNonFieldMarker,
-  t as FormErrorNonFieldMarkerDataHtmlAttribute,
-  s as useFormErrorOrphansToConsoleError,
-  d as useFormErrorsEffect,
-  p as useFormErrorsOnChange,
+  e as FormNonFieldErrorMarker,
+  s as FormNonFieldErrorMarkerHtmlAttribute,
+  p as useFormErrorConsoleDebug,
+  m as useFormErrorOrphansToConsoleError,
+  x as useFormErrorsEffect,
+  i as useFormErrorsOnChange,
   u as useFormOrphanErrors,
-  i as useFormRequestSubmit,
-  l as useFormRootFieldErrors
+  h as useFormRequestSubmit,
+  F as useFormRootFieldErrors
 };

package/dist/esm/utils.mjs

@@ -0,0 +1,4 @@
+const i = (t) => JSON.stringify(t) === "{}";
+export {
+  i as isEmptyObject
+};

package/dist/types/errors/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/getFlatFieldErrors.d.ts

@@ -0,0 +1,17 @@
+import { FieldError, FieldErrors } from 'react-hook-form';
+
+export type FlatFieldErrors = Record<string, FieldError>;
+/**
+ * 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;

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+type Props = {
+    /** Flat field name. (e.g., `address.street`) */
+    path: string;
+};
+/**
+ * Empty, hidden marker to indicate a non-field error is presented to user.
+ */
+declare const FormNonFieldErrorMarker: React.FC<Props>;
+export default FormNonFieldErrorMarker;

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

@@ -0,0 +1 @@
+export {};

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

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

@@ -0,0 +1,18 @@
+import { FieldError } from 'react-hook-form';
+
+/**
+ * Determine if {@link FieldError} is a non-field error (i.e., has `ref`).
+ *
+ * A non-field error has no association to an input via {@link FieldError.ref}.
+ *
+ * These fall into one of two categories:
+ * - Root, which are typically displayed to user at bottom/top of form.
+ * - Non-root, which fall into two main sub-sets:
+ *   - Non-orphan (displayed -- typically manually)
+ *     - e.g., array min/max validation
+ *   - 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`.
+ */
+export declare const isNonFieldError: (error: FieldError) => boolean;

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

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

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

@@ -1,9 +1,4 @@
 import { default as React } from 'react';
 
-/**
- * Root field errors from form.
- * These are typically displayed at the bottom of the form.
- * (Root errors have to processed this way due to (potentially) recursive types.)
- */
-declare const useFormOrphanErrors: (formRef: React.RefObject<HTMLFormElement>) => Record<string, import('react-hook-form').FieldError>;
+declare const useFormOrphanErrors: (formRef: React.RefObject<HTMLFormElement>) => import('../getFlatFieldErrors').FlatFieldErrors;
 export default useFormOrphanErrors;

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

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

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

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

package/dist/types/errors/{roots → root}/utils.d.ts

@@ -1,3 +1,4 @@
+import { FlatFieldErrors } from '../getFlatFieldErrors';
 import { FieldErrors } from 'react-hook-form';
 
 /**
@@ -5,4 +6,7 @@ import { FieldErrors } from 'react-hook-form';
  * @param path Flat path. (e.g., 'root.nested')
  */
 export declare const isFormErrorPathRoot: (path: string) => boolean;
-export declare const getRootFieldErrorList: (errors: FieldErrors) => import('react-hook-form').FieldError[];
+/**
+ *
+ */
+export declare const getRootFlatFieldErrors: (errors: FieldErrors) => FlatFieldErrors;

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

@@ -0,0 +1,6 @@
+/**
+ * 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/types/errors/useFormErrorConsoleDebug.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Output form errors to console.debug() for easier debugging for certain condition.
+ * (e.g., in dev/staging environments or certain users)
+ *
+ * `console.debug()` is unlikely to trigger any automated console capture reporting.
+ */
+declare const useFormErrorConsoleDebug: (condition: boolean) => void;
+export default useFormErrorConsoleDebug;

package/dist/types/main.d.ts

@@ -1,7 +1,9 @@
-export { default as FormErrorNonFieldMarker, FormErrorNonFieldMarkerHtmlAttribute as FormErrorNonFieldMarkerDataHtmlAttribute, } from './errors/orphans/FormErrorNonFieldMarker';
+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/roots/useFormRootFieldErrors';
+export { default as useFormRootFieldErrors } from './errors/root/useFormRootFieldErrors';
+export { default as useFormErrorConsoleDebug } from './errors/useFormErrorConsoleDebug';
 export { default as useFormErrorsEffect } from './errors/useFormErrorsEffect';
 export { default as useFormErrorsOnChange } from './errors/useFormErrorsOnChange';
 export { default as useFormRequestSubmit } from './errors/useFormRequestSubmit';

package/dist/types/utils.d.ts

@@ -0,0 +1 @@
+export declare const isEmptyObject: (obj: Record<string, unknown>) => boolean;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@paragrav/rhf-utils",
   "author": "paragrav.dev",
   "license": "MIT",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Integration utilities for react-hook-form.",
   "type": "module",
   "files": [
@@ -20,6 +20,11 @@
         "types": "./dist/types/main.d.ts",
         "default": "./dist/esm/main.mjs"
       }
+    },
+    "./useFormErrorConsoleDebug": {
+      "types": "./dist/types/errors/useFormErrorConsoleDebug.d.ts",
+      "require": "./dist/cjs/errors/useFormErrorConsoleDebug.cjs",
+      "import": "./dist/esm/errors/useFormErrorConsoleDebug.mjs"
     }
   },
   "sideEffects": false,
@@ -37,10 +42,9 @@
     "tsc": "tsc",
     "validate": "npm run tsc & npm run lint & npm run test & npm run test:ct"
   },
-  "dependencies": {
-    "flat": "^6.0.1"
-  },
   "peerDependencies": {
+    "flat": "^6",
+    "react": "^18",
     "react-hook-form": "^7"
   },
   "devDependencies": {
@@ -58,10 +62,10 @@
     "eslint-plugin-react": "^7.34.1",
     "eslint-plugin-react-hooks": "^4.6.0",
     "eslint-plugin-simple-import-sort": "^12.0.0",
+    "happy-dom": "^14.3.9",
     "husky": "^9.0.11",
     "lint-staged": "^15.2.2",
     "prettier": "^3.2.5",
-    "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "rollup": "^4.13.0",
     "typescript": "^5.4.3",

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

@@ -1,14 +0,0 @@
-/// <reference types="react" />
-type Props = {
-    /** Flat field name. (e.g., `address.street`) */
-    path: string;
-};
-/**
- * Empty, hidden marker to indicate a non-field error is presented to user.
- */
-declare const FormErrorNonFieldMarker: React.FC<Props>;
-export default FormErrorNonFieldMarker;
-/**
- * HTML data attribute for {@link FormErrorNonFieldMarker}.
- */
-export declare const FormErrorNonFieldMarkerHtmlAttribute = "data-paragrav-rhf-utils-marker-path";

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

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FormErrorNonFieldMarkerHtmlAttribute = void 0;
-const jsx_runtime_1 = require("react/jsx-runtime");
-/**
- * Empty, hidden marker to indicate a non-field error is presented to user.
- */
-const FormErrorNonFieldMarker = ({ path }) => {
-    const attribute = {
-        [exports.FormErrorNonFieldMarkerHtmlAttribute]: path,
-    };
-    return ((0, jsx_runtime_1.jsx)("div", { role: "alert", "aria-hidden": "true" // hide from screen readers
-        , style: { display: 'none' }, ...attribute }));
-};
-exports.default = FormErrorNonFieldMarker;
-// utils
-/**
- * HTML data attribute for {@link FormErrorNonFieldMarker}.
- */
-exports.FormErrorNonFieldMarkerHtmlAttribute = 'data-paragrav-rhf-utils-marker-path';

package/dist/cjs/errors/roots/useFormRootFieldErrors.d.ts

@@ -1,2 +0,0 @@
-declare const useFormRootFieldErrors: () => import("react-hook-form").FieldError[];
-export default useFormRootFieldErrors;

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

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRootFieldErrorList = exports.isFormErrorPathRoot = void 0;
-const utils_1 = require("../utils");
-const ROOT = 'root';
-/**
- * Determine if an error path is root. (e.g., `root` or `root.nested`)
- * @param path Flat path. (e.g., 'root.nested')
- */
-const isFormErrorPathRoot = (path) => path === ROOT || path.startsWith(ROOT + '.');
-exports.isFormErrorPathRoot = isFormErrorPathRoot;
-const getRootFieldErrorList = (errors) => (0, utils_1.getFieldErrorListByFilter)(errors, exports.isFormErrorPathRoot);
-exports.getRootFieldErrorList = getRootFieldErrorList;

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

@@ -1,9 +0,0 @@
-import type { FieldError, FieldErrors } from 'react-hook-form';
-/**
- * @returns A flattened {@link FieldErrors} record.
- */
-export declare const getFieldErrorsByFilter: (errors: FieldErrors, where?: ((path: string, flattenedErrors: Record<string, unknown>) => boolean) | undefined) => Record<string, FieldError>;
-/**
- * @returns An array of field errors. (Not a record.)
- */
-export declare const getFieldErrorListByFilter: (errors: FieldErrors, where?: ((path: string, flattenedErrors: Record<string, unknown>) => boolean) | undefined) => FieldError[];

package/dist/cjs/errors/utils.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFieldErrorListByFilter = exports.getFieldErrorsByFilter = void 0;
-const flat_1 = require("flat");
-const react_hook_form_1 = require("react-hook-form");
-/**
- * @returns A flattened {@link FieldErrors} record.
- */
-const getFieldErrorsByFilter = (errors, where) => {
-    const keys = getFieldErrorOrphanKeysByFilter(errors, where);
-    const record = keys.reduce((acc, path) => {
-        acc[path] = (0, react_hook_form_1.get)(errors, path);
-        return acc;
-    }, {});
-    return record;
-};
-exports.getFieldErrorsByFilter = getFieldErrorsByFilter;
-/**
- * @returns An array of field errors. (Not a record.)
- */
-const getFieldErrorListByFilter = (errors, where) => {
-    const keys = getFieldErrorOrphanKeysByFilter(errors, where);
-    const fieldErrors = keys.map((key) => {
-        return (0, react_hook_form_1.get)(errors, key);
-    });
-    return fieldErrors;
-};
-exports.getFieldErrorListByFilter = getFieldErrorListByFilter;
-/**
- * RHF uses deeply-nested object for errors, which reflects the structure of the form.
- * And the type is quite complex. All this complicates the process of finding errors.
- * This function automatically looks only for keys that end with `.ref`.
- * (This makes sure we only look at the leaf nodes of the object tree.)
- * This function also automatically removes the `.ref` suffix from the keys.
- *
- * @param where Filter callback.
- * @param map Transformer callback.
- * @returns Tuple of field errors and keys.
- */
-const getFieldErrorOrphanKeysByFilter = (errors, where) => {
-    /**
-     * e.g.:
-     * ```js
-     * { root: { ref: undefined, message: 'Form is invalid.' }, email: { ref: Object, message: 'Invalid.' } }
-     * ```
-     * flattens to:
-     * ```js
-     * { 'root.ref': undefined, 'root.message': 'Form is invalid.', 'email.ref': Object, 'email.message': 'Invalid.' }
-     * ```
-     * returns (if no additional filter/map specified)
-     * ```js
-     * [ 'root', 'email' ]
-     * ```
-     */
-    const flattenedErrors = (0, flat_1.flatten)(errors);
-    const flattenedErrorObjectKeys = Object.keys(flattenedErrors);
-    // look for leaf node, which would have ref prop (e.g., `orphan_field.ref`)
-    const flattenedErrorObjectKeysEndingWithDotRef = flattenedErrorObjectKeys.filter((key) => key.match(regexEndsWithDotRef));
-    // remove `.ref` suffix to get flat field path (e.g., `name`, `address.street`)
-    const paths = flattenedErrorObjectKeysEndingWithDotRef.map((flattenedKey) => flattenedKey.replace(regexEndsWithDotRef, ''));
-    // filter via callback
-    const flattenedKeysFiltered = paths.filter((path) => where ? where(path, flattenedErrors) : true);
-    return flattenedKeysFiltered;
-};
-const regexEndsWithDotRef = /\.ref$/;

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

@@ -1,19 +0,0 @@
-import { jsx as e } from "react/jsx-runtime";
-const o = ({ path: r }) => {
-  const t = {
-    [a]: r
-  };
-  return /* @__PURE__ */ e(
-    "div",
-    {
-      role: "alert",
-      "aria-hidden": "true",
-      style: { display: "none" },
-      ...t
-    }
-  );
-}, n = o, a = "data-paragrav-rhf-utils-marker-path";
-export {
-  a as FormErrorNonFieldMarkerHtmlAttribute,
-  n as default
-};

package/dist/esm/errors/roots/utils.mjs

@@ -1,6 +0,0 @@
-import { getFieldErrorListByFilter as t } from "../utils.mjs";
-const r = "root", i = (o) => o === r || o.startsWith(r + "."), e = (o) => t(o, i);
-export {
-  e as getRootFieldErrorList,
-  i as isFormErrorPathRoot
-};

package/dist/esm/errors/utils.mjs

@@ -1,14 +0,0 @@
-import { flatten as f } from "../node_modules/flat/index.mjs";
-import { get as d } from "react-hook-form";
-const p = (e, t) => i(e, t).reduce((r, s) => (r[s] = d(e, s), r), {}), F = (e, t) => i(e, t).map((r) => d(e, r)), i = (e, t) => {
-  const o = f(e);
-  return Object.keys(o).filter((n) => n.match(l)).map(
-    (n) => n.replace(l, "")
-  ).filter(
-    (n) => t ? t(n, o) : !0
-  );
-}, l = /\.ref$/;
-export {
-  F as getFieldErrorListByFilter,
-  p as getFieldErrorsByFilter
-};

package/dist/esm/node_modules/flat/index.mjs

@@ -1,22 +0,0 @@
-function d(t) {
-  return t && t.constructor && typeof t.constructor.isBuffer == "function" && t.constructor.isBuffer(t);
-}
-function A(t) {
-  return t;
-}
-function B(t, n) {
-  n = n || {};
-  const l = n.delimiter || ".", m = n.maxDepth, o = n.transformKey || A, f = {};
-  function i(s, u, r) {
-    r = r || 1, Object.keys(s).forEach(function(c) {
-      const e = s[c], x = n.safe && Array.isArray(e), a = Object.prototype.toString.call(e), O = d(e), b = a === "[object Object]" || a === "[object Array]", y = u ? u + l + o(c) : o(c);
-      if (!x && !O && b && Object.keys(e).length && (!n.maxDepth || r < m))
-        return i(e, y, r + 1);
-      f[y] = e;
-    });
-  }
-  return i(t), f;
-}
-export {
-  B as flatten
-};

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

@@ -1,14 +0,0 @@
-/// <reference types="react" />
-type Props = {
-    /** Flat field name. (e.g., `address.street`) */
-    path: string;
-};
-/**
- * Empty, hidden marker to indicate a non-field error is presented to user.
- */
-declare const FormErrorNonFieldMarker: React.FC<Props>;
-export default FormErrorNonFieldMarker;
-/**
- * HTML data attribute for {@link FormErrorNonFieldMarker}.
- */
-export declare const FormErrorNonFieldMarkerHtmlAttribute = "data-paragrav-rhf-utils-marker-path";

package/dist/types/errors/roots/useFormRootFieldErrors.d.ts

@@ -1,2 +0,0 @@
-declare const useFormRootFieldErrors: () => import('react-hook-form').FieldError[];
-export default useFormRootFieldErrors;

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

@@ -1,10 +0,0 @@
-import { FieldError, FieldErrors } from 'react-hook-form';
-
-/**
- * @returns A flattened {@link FieldErrors} record.
- */
-export declare const getFieldErrorsByFilter: (errors: FieldErrors, where?: ((path: string, flattenedErrors: Record<string, unknown>) => boolean) | undefined) => Record<string, FieldError>;
-/**
- * @returns An array of field errors. (Not a record.)
- */
-export declare const getFieldErrorListByFilter: (errors: FieldErrors, where?: ((path: string, flattenedErrors: Record<string, unknown>) => boolean) | undefined) => FieldError[];