@paragrav/rhf-utils 0.0.23 → 0.0.26

package/dist/_virtual/_commonjsHelpers.mjs

@@ -0,0 +1,8 @@
+var o = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function l(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+export {
+  o as commonjsGlobal,
+  l as getDefaultExportFromCjs
+};

package/dist/_virtual/index.mjs

@@ -0,0 +1,4 @@
+var r = {};
+export {
+  r as __exports
+};

package/dist/devtool/LazyDevTool.d.ts

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

package/dist/devtool/LazyDevTool.mjs

@@ -0,0 +1,16 @@
+import { jsx as t } from "react/jsx-runtime";
+import e from "react";
+import { useFormContext as n } from "react-hook-form";
+const a = e.lazy(
+  () => import("../node_modules/@hookform/devtools/dist/index.esm.mjs").then((o) => ({
+    default: o.DevTool
+  }))
+), f = ({ isDev: o, ...l }) => {
+  if (!o)
+    return null;
+  const { control: r } = n();
+  return /* @__PURE__ */ t(e.Suspense, { fallback: null, children: /* @__PURE__ */ t(a, { control: r, ...l }) });
+}, m = f;
+export {
+  m as default
+};

package/dist/errors/getFlatFieldErrors.mjs

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

package/dist/errors/isFieldError.d.ts

@@ -0,0 +1,7 @@
+import { FieldError } from 'react-hook-form';
+
+/**
+ * Determine if {@link FieldError} is a field error (i.e., has `ref`).
+ */
+declare const isFieldError: (error: FieldError) => boolean;
+export default isFieldError;

package/dist/errors/isFieldError.mjs

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

package/dist/errors/message/FormErrorMessage.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+
+type Props = {
+    message: string;
+    className?: string;
+};
+declare const FormErrorMessage: React.FC<Props>;
+export default FormErrorMessage;

package/dist/errors/message/FormErrorMessage.mjs

@@ -0,0 +1,14 @@
+import { jsx as e } from "react/jsx-runtime";
+import "react";
+const s = ({ message: r, className: o }) => /* @__PURE__ */ e(
+  "p",
+  {
+    role: "alert",
+    "aria-live": "polite",
+    className: o,
+    children: r
+  }
+), i = s;
+export {
+  i as default
+};

package/dist/errors/message/FormErrorMessageByPath.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+type Props = {
+    name: string;
+    Component?: React.FC<{
+        message: string;
+    }>;
+};
+declare const FormErrorMessageByPath: React.FC<Props>;
+export default FormErrorMessageByPath;

package/dist/errors/message/FormErrorMessageByPath.mjs

@@ -0,0 +1,17 @@
+import { jsxs as n, Fragment as a, jsx as e } from "react/jsx-runtime";
+import { useFormState as g, get as i } from "react-hook-form";
+import p from "../nonfield/FormNonFieldErrorMarker.mjs";
+import F from "./FormErrorMessage.mjs";
+const c = ({ name: o, ...s }) => {
+  const { errors: t } = g(), r = i(t, o, void 0);
+  if (!(r != null && r.message))
+    return null;
+  const m = s.Component ?? F;
+  return /* @__PURE__ */ n(a, { children: [
+    /* @__PURE__ */ e(p, { path: o }),
+    /* @__PURE__ */ e(m, { message: r.message })
+  ] });
+}, h = c;
+export {
+  h as default
+};

package/dist/errors/nonfield/{utils.d.ts → isNonFieldError.d.ts}

@@ -1,7 +1,7 @@
 import { FieldError } from 'react-hook-form';
 
 /**
- * Determine if {@link FieldError} is a non-field error (i.e., has `ref`).
+ * Determine if {@link FieldError} is a non-field error (i.e., has no `ref`).
  *
  * A non-field error has no association to an input via {@link FieldError.ref}.
  *
@@ -15,4 +15,5 @@ import { FieldError } from 'react-hook-form';
  *      - The schema is incorrect.
  *      - The error is not displayed to user with `FormErrorNonFieldMarker`.
  */
-export declare const isNonFieldError: (error: FieldError) => boolean;
+declare const isNonFieldError: (error: FieldError) => boolean;
+export default isNonFieldError;

package/dist/errors/nonfield/isNonFieldError.mjs

@@ -0,0 +1,5 @@
+import o from "../isFieldError.mjs";
+const e = (r) => !o(r);
+export {
+  e as default
+};

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

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

package/dist/errors/orphan/{utils.mjs → getOrphanFlatFieldErrors.mjs}

@@ -1,20 +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 s from "../getFlatFieldErrors.mjs";
+import { hasNonFieldErrorMarkerInDOM as l } from "../nonfield/FormNonFieldErrorMarker.utils.mjs";
+import m from "../nonfield/isNonFieldError.mjs";
 import { isFormErrorPathRoot as n } from "../root/utils.mjs";
 const d = (o, t) => {
-  const e = m(o);
+  const e = s(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)
+        m(i) && // does not have marker
+        !l(r, t)
       )
     )
   );
 };
 export {
-  d as getOrphanFlatFieldErrors
+  d as default
 };

package/dist/errors/orphan/useFormHasOrphanAndNoFieldErrors.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Determined if there are orphan errors and no field errors.
+ * (May be useful when reporting or displaying a specific message to user.)
+ * RHF doesn't seem to have any other mechanism to indicate a failed submit but to `setErrors()`.
+ * Therefore, we have no way of distinguishing between "placeholder" root error and actual error.
+ * (e.g., "Please fix form errors above." vs "Start date must be less than end date.")
+ */
+declare const useFormHasOrphanAndNoFieldErrors: (formRef: React.RefObject<HTMLFormElement>) => boolean;
+export default useFormHasOrphanAndNoFieldErrors;

package/dist/errors/orphan/useFormHasOrphanAndNoFieldErrors.mjs

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

package/dist/errors/orphan/useOrphanFormErrors.mjs

@@ -1,7 +1,7 @@
 import "react";
-import { isEmptyObject as t } from "../../utils.mjs";
+import t from "../../isEmptyObject.mjs";
 import e from "../useFormErrorsOnChange.mjs";
-import { getOrphanFlatFieldErrors as n } from "./utils.mjs";
+import n from "./getOrphanFlatFieldErrors.mjs";
 const m = (r) => e((o) => {
   if (t(o))
     return {};

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

@@ -1,8 +1,9 @@
 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.
+ * Logs out orphan errors to console.error.
+ *
+ * When `isDev`, it will also throw an error to bring attention to dev.
  */
-declare const useOrphanFormErrorsToConsoleError: (formRef: React.RefObject<HTMLFormElement>) => void;
+declare const useOrphanFormErrorsToConsoleError: (formRef: React.RefObject<HTMLFormElement>, isDev?: boolean) => void;
 export default useOrphanFormErrorsToConsoleError;

package/dist/errors/orphan/useOrphanFormErrorsToConsoleError.mjs

@@ -1,16 +1,24 @@
-import t from "react";
-import { useFormContext as n, useFormState as a } from "react-hook-form";
-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("useOrphanFormErrorsToConsoleError", {
-      location: window.location,
-      values: o(),
-      orphans: r
-    });
-  }, [s, o, r]);
-}, E = c;
+import n from "react";
+import { useFormContext as a, useFormState as m } from "react-hook-form";
+import c from "../../isEmptyObject.mjs";
+import p from "./useOrphanFormErrors.mjs";
+const u = (o, e) => {
+  const { getValues: s } = a(), { errors: t } = m(), r = p(o);
+  n.useEffect(() => {
+    if (!c(r) && (console.error(
+      "useOrphanFormErrorsToConsoleError",
+      // include debugging details
+      {
+        location: window.location,
+        values: s(),
+        // form values
+        errors: t,
+        orphans: r
+      }
+    ), e))
+      throw new Error("Orphan errors detected");
+  }, [r]);
+}, h = u;
 export {
-  E as default
+  h as default
 };

package/dist/errors/useFormErrorsEffect.mjs

@@ -5,7 +5,7 @@ const s = (r) => {
   t.useEffect(() => {
     r(o);
   }, [r, o]);
-}, c = s;
+}, u = s;
 export {
-  c as default
+  u as default
 };

package/dist/errors/useFormErrorsIfAny.mjs

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

package/dist/errors/useFormErrorsOnChange.mjs

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

package/dist/errors/useFormFieldErrors.d.ts

@@ -0,0 +1,6 @@
+import { FlatFieldErrors } from './getFlatFieldErrors';
+import { FieldErrors } from 'react-hook-form';
+
+declare const useFormFieldErrors: () => FlatFieldErrors;
+export default useFormFieldErrors;
+export declare const getFlatFieldFormErrors: (errors: FieldErrors) => FlatFieldErrors;

package/dist/errors/useFormFieldErrors.mjs

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

package/dist/isEmptyObject.d.ts

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

package/dist/isEmptyObject.mjs

@@ -0,0 +1,4 @@
+const e = (t) => Object.keys(t).length === 0, s = e;
+export {
+  s as default
+};

package/dist/main.d.ts

@@ -1,6 +1,9 @@
+export { default as LazyDevTool } from './devtool/LazyDevTool';
+export { default as FormErrorMessage } from './errors/message/FormErrorMessage';
+export { default as FormErrorMessageByPath } from './errors/message/FormErrorMessageByPath';
 export { default as FormNonFieldErrorMarker } from './errors/nonfield/FormNonFieldErrorMarker';
 export { default as FormNonFieldErrorMarkerHtmlAttribute } from './errors/nonfield/FormNonFieldErrorMarker.utils';
-export { default as useFormErrorsHasOnlyOrphans } from './errors/orphan/useFormErrorsHasOnlyOrphans';
+export { default as useFormHasOrphanAndNoFieldErrors } from './errors/orphan/useFormHasOrphanAndNoFieldErrors';
 export { default as useOrphanFormErrors } from './errors/orphan/useOrphanFormErrors';
 export { default as useOrphanFormErrorsToConsoleError } from './errors/orphan/useOrphanFormErrorsToConsoleError';
 export { default as useRootFormFieldErrors } from './errors/root/useRootFormFieldErrors';

package/dist/main.mjs

@@ -1,30 +1,36 @@
-import { default as e } from "./errors/nonfield/FormNonFieldErrorMarker.mjs";
-import { default as t } from "./errors/nonfield/FormNonFieldErrorMarker.utils.mjs";
-import { default as a } from "./errors/orphan/useFormErrorsHasOnlyOrphans.mjs";
-import { default as m } 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 x } from "./errors/useFormErrorConsoleDebug.mjs";
-import { default as i } from "./errors/useFormErrorsEffect.mjs";
-import { default as O } from "./errors/useFormErrorsIfAny.mjs";
-import { default as b } from "./errors/useFormErrorsOnChange.mjs";
-import { default as A } from "./errors/useFormRequestSubmit.mjs";
-import { default as C } from "./submit/useFormOnSubmitSuccessful.mjs";
-import { default as k } from "./submit/useFormOnSubmitSuccessfulAndReset.mjs";
-import { default as H } from "./submit/useResetFormOnSubmitSuccessful.mjs";
+import { default as e } from "./devtool/LazyDevTool.mjs";
+import { default as t } from "./errors/message/FormErrorMessage.mjs";
+import { default as u } from "./errors/message/FormErrorMessageByPath.mjs";
+import { default as m } from "./errors/nonfield/FormNonFieldErrorMarker.mjs";
+import { default as d } from "./errors/nonfield/FormNonFieldErrorMarker.utils.mjs";
+import { default as F } from "./errors/orphan/useFormHasOrphanAndNoFieldErrors.mjs";
+import { default as n } from "./errors/orphan/useOrphanFormErrors.mjs";
+import { default as i } from "./errors/orphan/useOrphanFormErrorsToConsoleError.mjs";
+import { default as S } from "./errors/root/useRootFormFieldErrors.mjs";
+import { default as O } from "./errors/useFormErrorConsoleDebug.mjs";
+import { default as A } from "./errors/useFormErrorsEffect.mjs";
+import { default as M } from "./errors/useFormErrorsIfAny.mjs";
+import { default as y } from "./errors/useFormErrorsOnChange.mjs";
+import { default as N } from "./errors/useFormRequestSubmit.mjs";
+import { default as D } from "./submit/useFormOnSubmitSuccessful.mjs";
+import { default as T } from "./submit/useFormOnSubmitSuccessfulAndReset.mjs";
+import { default as v } from "./submit/useResetFormOnSubmitSuccessful.mjs";
 export {
-  e as FormNonFieldErrorMarker,
-  t as FormNonFieldErrorMarkerHtmlAttribute,
-  x as useFormErrorConsoleDebug,
-  i as useFormErrorsEffect,
-  a as useFormErrorsHasOnlyOrphans,
-  O as useFormErrorsIfAny,
-  b as useFormErrorsOnChange,
-  C as useFormOnSubmitSuccessful,
-  k as useFormOnSubmitSuccessfulAndReset,
-  A as useFormRequestSubmit,
-  m as useOrphanFormErrors,
-  d as useOrphanFormErrorsToConsoleError,
-  H as useResetFormAfterSubmitSuccessful,
-  F as useRootFormFieldErrors
+  t as FormErrorMessage,
+  u as FormErrorMessageByPath,
+  m as FormNonFieldErrorMarker,
+  d as FormNonFieldErrorMarkerHtmlAttribute,
+  e as LazyDevTool,
+  O as useFormErrorConsoleDebug,
+  A as useFormErrorsEffect,
+  M as useFormErrorsIfAny,
+  y as useFormErrorsOnChange,
+  F as useFormHasOrphanAndNoFieldErrors,
+  D as useFormOnSubmitSuccessful,
+  T as useFormOnSubmitSuccessfulAndReset,
+  N as useFormRequestSubmit,
+  n as useOrphanFormErrors,
+  i as useOrphanFormErrorsToConsoleError,
+  v as useResetFormAfterSubmitSuccessful,
+  S as useRootFormFieldErrors
 };

package/dist/node_modules/@babel/runtime/helpers/esm/extends.mjs

@@ -0,0 +1,13 @@
+function e() {
+  return e = Object.assign ? Object.assign.bind() : function(a) {
+    for (var n = 1; n < arguments.length; n++) {
+      var t = arguments[n];
+      for (var r in t)
+        Object.prototype.hasOwnProperty.call(t, r) && (a[r] = t[r]);
+    }
+    return a;
+  }, e.apply(this, arguments);
+}
+export {
+  e as default
+};