@paragrav/rhf-utils 0.0.18 → 0.0.20

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

@@ -1,6 +1,6 @@
 import { jsx as t } from "react/jsx-runtime";
-import { FormNonFieldErrorMarkerHtmlAttribute as e } from "./FormNonFieldErrorMarker.utils.mjs";
-const i = ({ path: r }) => {
+import e from "./FormNonFieldErrorMarker.utils.mjs";
+const a = ({ path: r }) => {
   const o = {
     [e]: r
   };
@@ -13,7 +13,7 @@ const i = ({ path: r }) => {
       ...o
     }
   );
-}, l = i;
+}, d = a;
 export {
-  l as default
+  d as default
 };

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

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

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

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

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/orphan/utils.mjs

@@ -0,0 +1,20 @@
+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 {
+  d as getOrphanFlatFieldErrors
+};

package/dist/esm/errors/root/{useFormRootFieldErrors.mjs → useRootFormFieldErrors.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

@@ -1,6 +1,11 @@
-import { getNonFieldErrorListByFilter as t } from "../nonfield/utils.mjs";
-const r = "root", i = (o) => o === r || o.startsWith(r + "."), e = (o) => t(o, i);
+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 {
-  e as getRootFieldErrorList,
+  n as getRootFlatFieldErrors,
   i as isFormErrorPathRoot
 };

package/dist/esm/errors/useFormErrorConsoleDebug.mjs

@@ -0,0 +1,8 @@
+import e from "./useFormErrorsIfAny.mjs";
+const s = (o) => {
+  const r = e();
+  o && r && console.debug("useFormErrorConsoleDebug", r);
+}, n = s;
+export {
+  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,18 +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/useFormErrorsEffect.mjs";
-import { default as x } from "./errors/useFormErrorsOnChange.mjs";
-import { default as i } 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,
-  m as useFormErrorOrphansToConsoleError,
-  p as useFormErrorsEffect,
-  x as useFormErrorsOnChange,
-  u as useFormOrphanErrors,
-  i 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/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.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/types/errors/nonfield/utils.d.ts

@@ -1,10 +1,18 @@
-import { FieldError, FieldErrors } from 'react-hook-form';
+import { 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/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/orphan/useOrphanFormErrors.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+
+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/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('../getFlatFieldErrors').FlatFieldErrors;
+export default useRootFormFieldErrors;

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

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

package/package.json

@@ -2,9 +2,10 @@
   "name": "@paragrav/rhf-utils",
   "author": "paragrav.dev",
   "license": "MIT",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "Integration utilities for react-hook-form.",
   "type": "module",
+  "sideEffects": false,
   "files": [
     "dist"
   ],
@@ -12,17 +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"
+    },
+    "./errors/useFormErrorConsoleDebug": {
+      "import": "./dist/esm/errors/useFormErrorConsoleDebug.mjs",
+      "require": "./dist/cjs/errors/useFormErrorConsoleDebug.cjs",
+      "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",
@@ -37,10 +87,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 +107,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/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/useFormOrphanErrors.d.ts

@@ -1,3 +0,0 @@
-import React from 'react';
-declare const useFormOrphanErrors: (formRef: React.RefObject<HTMLFormElement>) => Record<string, import("react-hook-form").FieldError>;
-export default useFormOrphanErrors;

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

@@ -1,17 +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 useFormErrorsOnChange_1 = __importDefault(require("../useFormErrorsOnChange"));
-const utils_1 = require("./utils");
-const useFormOrphanErrors = (formRef) => (0, useFormErrorsOnChange_1.default)((errors) => {
-    if (JSON.stringify(errors) === '{}')
-        return {};
-    if (!formRef.current) {
-        console.error(errors);
-        throw new Error('This should not happen.');
-    }
-    return (0, utils_1.getOrphanFieldErrorsWithMarkerCheck)(errors, formRef.current);
-});
-exports.default = useFormOrphanErrors;

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

@@ -1,15 +0,0 @@
-import type { FieldErrors } from 'react-hook-form';
-/**
- * Get flat record of orphan errors -- i.e., non-field, non-root and not displayed to user using {@link FormNonFieldErrorMarker}.
- * @param fieldErrors
- * @param formElement Ref to form element for scoped `querySelector`.
- * @returns
- */
-export declare const getOrphanFieldErrorsWithMarkerCheck: (fieldErrors: FieldErrors, formElement: HTMLFormElement) => Record<string, import("react-hook-form").FieldError>;
-/**
- * Get non-field errors that are not root errors.
- *
- * NOTE: This is an intermediary function used by {@link getOrphanFieldErrorsWithMarkerCheck}.
- * It is exported for sake of testing.
- */
-export declare const getNonFieldNonRootErrors: (errors: FieldErrors) => Record<string, import("react-hook-form").FieldError>;

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

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNonFieldNonRootErrors = exports.getOrphanFieldErrorsWithMarkerCheck = void 0;
-const FormNonFieldErrorMarker_utils_1 = require("../nonfield/FormNonFieldErrorMarker.utils");
-const utils_1 = require("../nonfield/utils");
-const utils_2 = require("../root/utils");
-/**
- * Get flat record of orphan errors -- i.e., non-field, non-root and not displayed to user using {@link FormNonFieldErrorMarker}.
- * @param fieldErrors
- * @param formElement Ref to form element for scoped `querySelector`.
- * @returns
- */
-const getOrphanFieldErrorsWithMarkerCheck = (fieldErrors, formElement) => {
-    const nonFieldNonRootErrors = (0, exports.getNonFieldNonRootErrors)(fieldErrors);
-    return (0, utils_1.getNonFieldErrorRecordByFilter)(nonFieldNonRootErrors, (path) => 
-    // if doesn't have alert, then it's an orphan
-    !formElement.querySelector((0, FormNonFieldErrorMarker_utils_1.getFormNonFieldErrorMarkerQuerySelector)(path)));
-};
-exports.getOrphanFieldErrorsWithMarkerCheck = getOrphanFieldErrorsWithMarkerCheck;
-/**
- * Get non-field errors that are not root errors.
- *
- * NOTE: This is an intermediary function used by {@link getOrphanFieldErrorsWithMarkerCheck}.
- * It is exported for sake of testing.
- */
-const getNonFieldNonRootErrors = (errors) => (0, utils_1.getNonFieldErrorRecordByFilter)(errors, (path) => !(0, utils_2.isFormErrorPathRoot)(path));
-exports.getNonFieldNonRootErrors = getNonFieldNonRootErrors;

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

@@ -1,6 +0,0 @@
-/**
- * Root field errors from form.
- * These are typically displayed at the bottom of the form.
- */
-declare const useFormRootFieldErrors: () => import("react-hook-form").FieldError[];
-export default useFormRootFieldErrors;

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

@@ -1,9 +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 useFormErrorsOnChange_1 = __importDefault(require("../useFormErrorsOnChange"));
-const utils_1 = require("./utils");
-const useFormRootFieldErrors = () => (0, useFormErrorsOnChange_1.default)(utils_1.getRootFieldErrorList);
-exports.default = useFormRootFieldErrors;