@paragrav/rhf-utils 0.0.18 → 0.0.20

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.js

@@ -1,15 +1,18 @@
 "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 attribute = {
-        [FormNonFieldErrorMarker_utils_1.FormNonFieldErrorMarkerHtmlAttribute]: path,
+    const dataAttribute = {
+        [FormNonFieldErrorMarker_utils_1.default]: path,
     };
     return ((0, jsx_runtime_1.jsx)("div", { role: "alert", "aria-hidden": "true" // hide from screen readers
-        , style: { display: 'none' }, ...attribute }));
+        , style: { display: 'none' }, ...dataAttribute }));
 };
 exports.default = FormNonFieldErrorMarker;

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

@@ -1,5 +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,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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

@@ -1,9 +1,17 @@
-import type { FieldError, FieldErrors } from 'react-hook-form';
+import type { FieldError } from 'react-hook-form';
 /**
- * @returns A flattened {@link FieldErrors} record. (e.g. `{ "address.street": FieldError }`)
+ * 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 error is not displayed to user with `FormErrorNonFieldMarker`.
  */
-export declare const getNonFieldErrorRecordByFilter: (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 getNonFieldErrorListByFilter: (errors: FieldErrors, where?: ((path: string, flattenedErrors: Record<string, unknown>) => boolean) | undefined) => FieldError[];
+export declare const isNonFieldError: (error: FieldError) => boolean;

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

@@ -1,78 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNonFieldErrorListByFilter = exports.getNonFieldErrorRecordByFilter = void 0;
-const flat_1 = require("flat");
-const react_hook_form_1 = require("react-hook-form");
+exports.isNonFieldError = void 0;
 /**
- * @returns A flattened {@link FieldErrors} record. (e.g. `{ "address.street": FieldError }`)
- */
-const getNonFieldErrorRecordByFilter = (errors, where) => {
-    const keys = getNonFieldErrorPathsByFilter(errors, where);
-    const record = keys.reduce((acc, path) => {
-        acc[path] = (0, react_hook_form_1.get)(errors, path);
-        return acc;
-    }, {});
-    return record;
-};
-exports.getNonFieldErrorRecordByFilter = getNonFieldErrorRecordByFilter;
-/**
- * @returns An array of field errors. (Not a record.)
- */
-const getNonFieldErrorListByFilter = (errors, where) => {
-    const keys = getNonFieldErrorPathsByFilter(errors, where);
-    const fieldErrors = keys.map((key) => {
-        return (0, react_hook_form_1.get)(errors, key);
-    });
-    return fieldErrors;
-};
-exports.getNonFieldErrorListByFilter = getNonFieldErrorListByFilter;
-/**
- * Retrieve non-field error paths from {@link FieldErrors} object.
- *
- * Non-field errors are those without an association to an input via {@link FieldError.ref}.
- *
- * These fall into one of three categories:
- * - Root errors, which are displayed to user at bottom/top of form.
- * - Non-field errors (e.g., array min/max validation), which are typically displayed manually to user near relevant fields.
- *   - Orphan error occurs when a non-field error has not been displayed to user.
- *     - This is typically caused by one of the following cases:
- *       - 1. The input is missing.
- *       - 3. The schema is incorrect.
- *       - 2. The non-field error is not displayed to user with `FormErrorNonFieldMarker`.
+ * Determine if {@link FieldError} is a non-field error (i.e., has `ref`).
  *
- * 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.
+ * A non-field error has no association to an input via {@link FieldError.ref}.
  *
- * @param where Filter callback.
- * @param map Transformer callback.
- * @returns Tuple of field errors and keys.
+ * 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 error is not displayed to user with `FormErrorNonFieldMarker`.
  */
-const getNonFieldErrorPathsByFilter = (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$/;
+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/orphan/useOrphanFormErrors.d.ts

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

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

@@ -0,0 +1,18 @@
+"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 useFormErrorsOnChange_1 = __importDefault(require("../useFormErrorsOnChange"));
+const utils_2 = require("./utils");
+const useOrphanFormErrors = (formRef) => (0, useFormErrorsOnChange_1.default)((errors) => {
+    // if no errors, return early
+    if ((0, utils_1.isEmptyObject)(errors))
+        return {};
+    // this should never happen
+    if (!formRef.current)
+        throw new Error();
+    return (0, utils_2.getOrphanFlatFieldErrors)(errors, formRef.current);
+});
+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/orphan/utils.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 });
+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 getOrphanFlatFieldErrors = (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.getOrphanFlatFieldErrors = getOrphanFlatFieldErrors;

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

@@ -0,0 +1,6 @@
+/**
+ * Root field errors from form.
+ * These are typically displayed at the bottom of the form.
+ */
+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.getRootFieldErrorList);
-exports.default = useFormRootFieldErrors;
+const useRootFormFieldErrors = () => (0, useFormErrorsOnChange_1.default)(utils_1.getRootFlatFieldErrors);
+exports.default = useRootFormFieldErrors;

package/dist/cjs/errors/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

@@ -1,7 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRootFieldErrorList = exports.isFormErrorPathRoot = void 0;
-const utils_1 = require("../nonfield/utils");
+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`)
@@ -9,5 +12,13 @@ const ROOT = 'root';
  */
 const isFormErrorPathRoot = (path) => path === ROOT || path.startsWith(ROOT + '.');
 exports.isFormErrorPathRoot = isFormErrorPathRoot;
-const getRootFieldErrorList = (errors) => (0, utils_1.getNonFieldErrorListByFilter)(errors, exports.isFormErrorPathRoot);
-exports.getRootFieldErrorList = getRootFieldErrorList;
+/**
+ *
+ */
+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/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 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)
+ *
+ * `console.debug()` is unlikely to trigger any automated console capture reporting.
+ */
+const useFormErrorConsoleDebug = (condition) => {
+    const errors = (0, useFormErrorsIfAny_1.default)();
+    if (!condition)
+        return;
+    if (!errors)
+        return;
+    // eslint-disable-next-line no-console
+    console.debug('useFormErrorConsoleDebug', errors);
+};
+exports.default = useFormErrorConsoleDebug;

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/useFormErrorsIfAny.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 useFormErrorsIfAny = () => {
+    const { errors } = (0, react_hook_form_1.useFormState)();
+    return (0, utils_1.isEmptyObject)(errors) ? false : errors;
+};
+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,8 +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,19 +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.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/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 l } from "react-hook-form";
+import d from "./flattenFieldErrors.mjs";
+const f = (e) => {
+  const s = d(e), c = Object.keys(s);
+  return Object.fromEntries(
+    c.reduce(
+      (t, o) => {
+        const r = o.replace(a, "");
+        if (r === o)
+          return t;
+        const n = l(e, r, void 0);
+        return n && t.push([r, n]), t;
+      },
+      []
+      // entries
+    )
+  );
+}, u = f, a = /\.type$/;
+export {
+  u as default
+};