@paragrav/rhf-utils 0.0.50 → 0.0.51

package/dist/esm/devtool/LazyDevTool.mjs

@@ -1,16 +1,12 @@
-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 "react/jsx-runtime";
+import t from "react";
+import "react-hook-form";
+t.lazy(
   () => import("@hookform/devtools").then((o) => ({
     default: o.DevTool
   }))
-), s = ({ 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 }) });
-}, u = s;
+);
+const e = (o) => null, p = e;
 export {
-  u as default
+  p as default
 };

package/dist/esm/env-conditions/production.mjs

@@ -0,0 +1,4 @@
+const e = !1;
+export {
+  e as isDevelopment
+};

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

@@ -1,18 +1,17 @@
 import "react";
-import n from "../useFormErrorsToConsole.mjs";
-import t from "./useOrphanFormErrorsMemo.mjs";
-const a = (r, s, e) => {
-  const o = t(r);
-  n("Orphan errors detected!", o, {
-    disabled: !e,
-    isDev: s,
+import e from "../useFormErrorsToConsole.mjs";
+import n from "./useOrphanFormErrorsMemo.mjs";
+const t = (r, s) => {
+  const o = n(r);
+  e("Orphan errors detected!", o, {
+    disabled: !s,
     isError: !0,
     data: {
       location: window.location,
       orphans: o
     }
   });
-}, d = a;
+}, i = t;
 export {
-  d as default
+  i as default
 };

package/dist/esm/errors/outputErrors.mjs

@@ -1,8 +1,7 @@
-import t from "./consoleErrors.mjs";
-const c = (u, E, r) => {
-  if (t(u, E, r), r != null && r.isDev && r.isError)
-    throw new Error(u);
-}, f = c;
+import s from "./consoleErrors.mjs";
+const u = (o, r, t) => {
+  s(o, r, t);
+}, c = u;
 export {
-  f as default
+  c as default
 };

package/dist/esm/form/Form.mjs

@@ -1,71 +1,63 @@
-import { jsxs as O, jsx as t } from "react/jsx-runtime";
+import { jsxs as C, jsx as t } from "react/jsx-runtime";
 import "react";
-import { useFormContext as v } from "react-hook-form";
-import T from "../devtool/LazyDevTool.mjs";
-import V from "../errors/root/FormRootErrorsFromContext.mjs";
-import j from "../submit/error/handleFormSubmitError.mjs";
-import w from "../submit/useResetFormOnSubmitError.mjs";
-import E from "../submit/useSubmitFormOnChange.mjs";
-import P from "../utils/useImperativeForwardedRef.mjs";
-import S from "./FormBase.mjs";
-function H({
-  isDev: u,
-  formId: h,
-  formRef: F,
+import { useFormContext as O } from "react-hook-form";
+import v from "../devtool/LazyDevTool.mjs";
+import T from "../errors/root/FormRootErrorsFromContext.mjs";
+import V from "../submit/error/handleFormSubmitError.mjs";
+import j from "../submit/useResetFormOnSubmitError.mjs";
+import w from "../submit/useSubmitFormOnChange.mjs";
+import E from "../utils/useImperativeForwardedRef.mjs";
+import P from "./FormBase.mjs";
+function G({
+  formId: u,
+  formRef: h,
   Fields: f,
   //
   onSubmit: d,
   onSubmitError: l,
-  onSubmitInvalid: x,
+  onSubmitInvalid: F,
   //
   options: r,
   //
-  children: g,
-  ...R
+  children: x,
+  ...g
 }) {
-  const m = v(), c = P(F);
-  E(c, !(r != null && r.submitOnChange)), w(!(r != null && r.resetValuesOnSubmitError));
-  const b = async (e) => {
+  const m = O(), c = E(h);
+  w(c, !(r != null && r.submitOnChange)), j(!(r != null && r.resetValuesOnSubmitError));
+  const R = async (e) => {
     r != null && r.stopSubmitPropagation && e.stopPropagation();
     try {
-      await m.handleSubmit(y, x)(e);
+      await m.handleSubmit(b, F)(e);
     } catch (a) {
-      C(a, e);
+      y(a, e);
     }
-  }, y = (e, a) => d == null ? void 0 : d(
+  }, b = (e, a) => d == null ? void 0 : d(
     e,
     m,
     a
-  ), C = (e, a) => {
-    j(e, m), l == null || l(e, m, a);
+  ), y = (e, a) => {
+    V(e, m), l == null || l(e, m, a);
   };
-  return /* @__PURE__ */ O(
-    S,
+  return /* @__PURE__ */ C(
+    P,
     {
-      id: h,
-      onSubmit: b,
+      id: u,
+      onSubmit: R,
       noValidate: !0,
       style: {
         position: "relative"
       },
-      ...R,
+      ...g,
       ref: c,
       children: [
-        (r == null ? void 0 : r.devTool) !== "disabled" && /* @__PURE__ */ t(
-          T,
-          {
-            isDev: u,
-            placement: "top-right",
-            ...r == null ? void 0 : r.devTool
-          }
-        ),
+        (r == null ? void 0 : r.devTool) !== "disabled" && /* @__PURE__ */ t(v, { placement: "top-right", ...r == null ? void 0 : r.devTool }),
         f && /* @__PURE__ */ t(f, { ctx: m }),
-        g,
-        !(r != null && r.hideRootErrors) && /* @__PURE__ */ t(V, {})
+        x,
+        !(r != null && r.hideRootErrors) && /* @__PURE__ */ t(T, {})
       ]
     }
   );
 }
 export {
-  H as default
+  G as default
 };

package/dist/esm/form/context/FormProvider.mjs

@@ -1,27 +1,25 @@
 import { jsx as r } from "react/jsx-runtime";
-import { FormProvider as n } from "react-hook-form";
-import p from "./utils/FormUtilsContextProvider.mjs";
-function F({
-  isDev: o,
-  formId: m,
-  formRef: i,
-  rhf: t,
-  form: e,
-  utils: d,
-  children: f
+import { FormProvider as f } from "react-hook-form";
+import n from "./utils/FormUtilsContextProvider.mjs";
+function v({
+  formId: o,
+  formRef: m,
+  rhf: i,
+  form: t,
+  utils: e,
+  children: d
 }) {
-  return /* @__PURE__ */ r(n, { ...t, children: /* @__PURE__ */ r(
-    p,
+  return /* @__PURE__ */ r(f, { ...i, children: /* @__PURE__ */ r(
+    n,
     {
-      isDev: o,
-      formId: m,
-      formRef: i,
-      formProps: e,
-      ...d,
-      children: f
+      formId: o,
+      formRef: m,
+      formProps: t,
+      ...e,
+      children: d
     }
   ) });
 }
 export {
-  F as default
+  v as default
 };

package/dist/esm/form/context/utils/FormUtilsContextProvider.mjs

@@ -1,20 +1,20 @@
-import { jsx as i } from "react/jsx-runtime";
+import { jsx as e } from "react/jsx-runtime";
+import { isDevelopment as i } from "../../../env-conditions/production.mjs";
 import p from "../../../errors/orphan/useOrphanFormErrorsToConsole.mjs";
-import F from "../../../errors/useFormErrorConsoleDebug.mjs";
-import u from "../../../errors/useFormRequestSubmit.mjs";
-import a from "../../../submit/useFormOnSubmitSuccessfulAndReset.mjs";
-import s from "../../../submit/useResetFormOnSubmitSuccessful.mjs";
+import s from "../../../errors/useFormErrorConsoleDebug.mjs";
+import F from "../../../errors/useFormRequestSubmit.mjs";
+import u from "../../../submit/useFormOnSubmitSuccessfulAndReset.mjs";
+import a from "../../../submit/useResetFormOnSubmitSuccessful.mjs";
 import { _FormUtilsContextProvider as l } from "./useFormUtilsContext.mjs";
 function O({
-  isDev: m,
   formRef: o,
   onSubmitSuccessfulAndReset: r,
-  children: t
+  children: m
 }) {
-  const e = u(o);
-  return F(m), p(o, m, !0), s({ enabled: !!r }), a(() => {
+  const t = F(o);
+  return s(i), p(o, !0), a({ enabled: !!r }), u(() => {
     r == null || r();
-  }), /* @__PURE__ */ i(l, { value: { formRef: o, requestSubmit: e }, children: t });
+  }), /* @__PURE__ */ e(l, { value: { formRef: o, requestSubmit: t }, children: m });
 }
 export {
   O as default

package/dist/esm/form/useForm.mjs

@@ -1,31 +1,29 @@
-import { jsx as i } from "react/jsx-runtime";
-import u from "react";
-import { useForm as F } from "react-hook-form";
-import c from "../utils/useImperativeForwardedRef.mjs";
-import f from "./Form.mjs";
-const p = ({
-  isDev: e,
-  rhf: m,
+import { jsx as n } from "react/jsx-runtime";
+import i from "react";
+import { useForm as u } from "react-hook-form";
+import F from "../utils/useImperativeForwardedRef.mjs";
+import c from "./Form.mjs";
+const f = ({
+  rhf: e,
   form: o
 }) => {
-  const r = u.useId(), s = F(m), t = c();
+  const r = i.useId(), m = u(e), t = F();
   return {
     id: r,
     ref: t,
-    context: s,
-    Form: ({ children: n }) => /* @__PURE__ */ i(
-      f,
+    context: m,
+    Form: ({ children: s }) => /* @__PURE__ */ n(
+      c,
       {
-        isDev: e,
         formId: r,
         formRef: t,
         onSubmit: o == null ? void 0 : o.onSubmit,
         ...o,
-        children: n
+        children: s
       }
     )
   };
-}, S = p;
+}, b = f;
 export {
-  S as default
+  b as default
 };

package/dist/esm/form/useFormWithProviders.mjs

@@ -1,30 +1,28 @@
-import { jsx as s } from "react/jsx-runtime";
+import { jsx as i } from "react/jsx-runtime";
 import "react";
-import f from "./context/FormProvider.mjs";
-import d from "./useForm.mjs";
-const n = ({
-  isDev: o,
-  rhf: e,
-  form: t,
-  utils: m
+import s from "./context/FormProvider.mjs";
+import f from "./useForm.mjs";
+const d = ({
+  rhf: t,
+  form: o,
+  utils: e
 }) => {
-  const r = d({ isDev: o, rhf: e, form: t });
+  const r = f({ rhf: t, form: o });
   return {
     ...r,
-    Provider: ({ children: i }) => /* @__PURE__ */ s(
-      f,
+    Provider: ({ children: m }) => /* @__PURE__ */ i(
+      s,
       {
-        isDev: o,
         formRef: r.ref,
         rhf: r.context,
         formId: r.id,
-        form: t,
-        utils: m,
-        children: i
+        form: o,
+        utils: e,
+        children: m
       }
     )
   };
-}, F = n;
+}, P = d;
 export {
-  F as default
+  P as default
 };

package/dist/types/src/devtool/LazyDevTool.d.ts

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

package/dist/types/src/env-conditions/development.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Determined whether env is dev via `imports`.
+ *
+ * Technique borrowed from react-error-boundary {@link https://github.com/bvaughn/react-error-boundary/blob/master/package.json}.
+ * Assign `boolean` type to avoid `@typescript-eslint/no-unnecessary-condition`.
+ */
+export declare const isDevelopment: boolean;

package/dist/types/src/env-conditions/production.d.ts

@@ -0,0 +1 @@
+export declare const isDevelopment: boolean;

package/dist/types/src/errors/consoleErrors.d.ts

@@ -0,0 +1,13 @@
+import { FieldErrors, FieldValues } from 'react-hook-form';
+
+/**
+ * Output form values and errors to console.
+ */
+declare const consoleErrors: (message: string, form: {
+    values: FieldValues;
+    errors: FieldErrors;
+}, options?: {
+    other?: Record<string, unknown>;
+    isError?: boolean;
+}) => void;
+export default consoleErrors;

package/dist/types/src/errors/context/index.d.ts

@@ -0,0 +1,10 @@
+import { FlatFieldErrors } from '../flat/types';
+
+export type FormErrorsFlatContext = {
+    all: FlatFieldErrors;
+    roots: FlatFieldErrors;
+    orphans: FlatFieldErrors;
+};
+declare const useFormErrorsFlatContextMaybe: () => FormErrorsFlatContext | undefined, useFormErrorsFlatContext: () => FormErrorsFlatContext, _FormErrorsFlatContextProvider: import('react').Provider<FormErrorsFlatContext | undefined>;
+export default useFormErrorsFlatContext;
+export { _FormErrorsFlatContextProvider, useFormErrorsFlatContextMaybe };

package/dist/types/src/errors/context/provider.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+type Props = React.PropsWithChildren<{
+    formRef: React.RefObject<HTMLFormElement>;
+    outputErrors?: boolean;
+}>;
+/**
+ * Provides a flattened version of the form errors.
+ * Allows flattening and filtering to happen once per errors change.
+ */
+declare const FormErrorsFlatContextProvider: React.FC<Props>;
+export default FormErrorsFlatContextProvider;

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

@@ -0,0 +1,25 @@
+import { FlatFieldErrors } from './types';
+import { FieldErrors } from 'react-hook-form';
+
+/**
+ * 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;
+/**
+ * Regular expression to maybe match the end of a leaf node path.
+ *
+ * i.e., `name.type`, `address.street.message`
+ *
+ * iow: dot [?: non-capturing]("type" | "message")[\b word boundary][$ end of string]
+ */
+export declare const regexMaybeFieldErrorLeafNode: RegExp;

package/dist/types/src/errors/flat/types.d.ts

@@ -0,0 +1,13 @@
+import { FieldError } from 'react-hook-form';
+
+/**
+ * Flattened field errors object.
+ *
+ * @example
+ * ```ts
+ * {
+ *   'address.street': FieldError
+ * }
+ * ```
+ */
+export type FlatFieldErrors = Record<string, FieldError>;

package/dist/types/src/errors/flat/useFormFlatFieldErrorsMemo.d.ts

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

package/dist/types/src/errors/flat/useRefdFieldErrorsMemo.d.ts

@@ -0,0 +1,9 @@
+import { FlatFieldErrors } from './types';
+import { FieldErrors } from 'react-hook-form';
+
+/**
+ * Use errors with refs.
+ */
+declare const useRefdFieldErrorsMemo: () => FlatFieldErrors;
+export default useRefdFieldErrorsMemo;
+export declare const getFlatFieldFormErrors: (errors: FieldErrors) => FlatFieldErrors;

package/dist/types/src/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/types/src/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/types/src/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/types/src/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/non-root error is being displayed to user.
+ */
+declare const FormNonFieldErrorMarker: React.FC<Props>;
+export default FormNonFieldErrorMarker;

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

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

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

@@ -0,0 +1,2 @@
+export declare const getFormNonFieldErrorMarkerQuerySelector: (path: string) => string;
+export declare const hasNonFieldErrorMarkerInDOM: (path: string, parentElement: Pick<HTMLElement, 'querySelector'>) => boolean;

package/dist/types/src/errors/nonfield/FormNonFieldErrorMarkerHtmlAttribute.d.ts

@@ -0,0 +1,5 @@
+/**
+ * HTML data attribute for {@link FormNonFieldErrorMarker}.
+ */
+declare const FormNonFieldErrorMarkerHtmlAttribute = "data-paragrav-rhf-utils-nonfield-error-marker-path";
+export default FormNonFieldErrorMarkerHtmlAttribute;

package/dist/types/src/errors/nonfield/isNonFieldError.d.ts

@@ -0,0 +1,19 @@
+import { FieldError } from 'react-hook-form';
+
+/**
+ * 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}.
+ *
+ * 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`.
+ */
+declare const isNonFieldError: (error: FieldError) => boolean;
+export default isNonFieldError;

package/dist/types/src/errors/orphan/getOrphansFromFieldErrors.d.ts

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

package/dist/types/src/errors/orphan/getOrphansFromFlatFieldErrors.d.ts

@@ -0,0 +1,4 @@
+import { FlatFieldErrors } from '../flat/types';
+
+declare const getOrphansFromFlatFieldErrors: (errors: FlatFieldErrors, parentElement: Pick<HTMLElement, 'querySelector'>) => FlatFieldErrors;
+export default getOrphansFromFlatFieldErrors;

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

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

package/dist/types/src/errors/orphan/useOrphanFormErrorsToConsole.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+
+/**
+ * Logs out orphan errors to console.error.
+ *
+ * In development, it will also throw an error to bring attention to dev.
+ */
+declare const useOrphanFormErrorsToConsole: (formRef: React.RefObject<HTMLFormElement>, enabled?: boolean) => void;
+export default useOrphanFormErrorsToConsole;

package/dist/types/src/errors/outputErrors.d.ts

@@ -0,0 +1,13 @@
+import { FieldErrors, FieldValues } from 'react-hook-form';
+
+/**
+ * Output form values and errors to console and throw in dev.
+ */
+declare const outputErrors: (message: string, form: {
+    values: FieldValues;
+    errors: FieldErrors;
+}, options?: {
+    other?: Record<string, unknown>;
+    isError?: boolean;
+}) => void;
+export default outputErrors;

package/dist/types/src/errors/root/FormRootErrors.d.ts

@@ -0,0 +1,7 @@
+import { FlatFieldErrors } from '../flat/types';
+
+type Props = React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement> & {
+    errors: FlatFieldErrors;
+};
+declare const FormRootErrors: React.FC<Props>;
+export default FormRootErrors;

package/dist/types/src/errors/root/FormRootErrorsFromContext.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const FormRootErrorsFromContext: React.FC;
+export default FormRootErrorsFromContext;

package/dist/types/src/errors/root/consts.d.ts

@@ -0,0 +1 @@
+export declare const FormErrorPathRoot = "root";

package/dist/types/src/errors/root/getRootsFromFieldErrors.d.ts

@@ -0,0 +1,5 @@
+import { FlatFieldErrors } from '../flat/types';
+import { FieldErrors } from 'react-hook-form';
+
+declare const getRootsFromFieldErrors: (errors: FieldErrors) => FlatFieldErrors;
+export default getRootsFromFieldErrors;