@paragrav/rhf-utils 0.0.27 → 0.0.28

package/dist/esm/errors/context/index.mjs

@@ -0,0 +1,6 @@
+import r from "../../utils/createRequiredContext.mjs";
+const [t, e] = r(), s = t;
+export {
+  e as _FormErrorsFlatContextProvider,
+  s as default
+};

package/dist/esm/errors/context/provider.mjs

@@ -0,0 +1,19 @@
+import { jsx as F } from "react/jsx-runtime";
+import a from "../flat/getFlatFieldErrors.mjs";
+import i from "../orphan/getOrphanFlatFieldErrors.mjs";
+import l from "../root/getRootFlatFieldErrors.mjs";
+import p from "../useFormErrorsMemo.mjs";
+import { _FormErrorsFlatContextProvider as c } from "./index.mjs";
+const d = ({
+  formRef: o,
+  children: t
+}) => {
+  const e = p((s) => {
+    const r = a(s), m = l(r), n = i(r, o.current);
+    return { flattened: r, roots: m, orphans: n };
+  });
+  return /* @__PURE__ */ F(c, { value: e, children: t });
+}, C = d;
+export {
+  C as default
+};

package/dist/esm/errors/flat/getFlatFieldErrors.mjs

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

package/dist/esm/errors/flat/useRefdFieldErrorsMemo.mjs

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

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

@@ -1,4 +1,4 @@
-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));
+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 {
   a as default,
   t as getFormNonFieldErrorMarkerQuerySelector,

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

@@ -1,7 +1,7 @@
-import s from "../getFlatFieldErrors.mjs";
+import s from "../flat/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";
+import n from "../root/isFormErrorPathRoot.mjs";
 const d = (o, t) => {
   const e = s(o);
   return Object.fromEntries(

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

@@ -1,10 +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();
+import t from "../flat/useRefdFieldErrorsMemo.mjs";
+import m from "./useOrphanFormErrorsMemo.mjs";
+const n = (o) => {
+  const s = m(o), e = t();
   return r(s) ? !1 : !r(e);
-}, d = m;
+}, d = n;
 export {
   d as default
 };

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

@@ -0,0 +1,14 @@
+import "react";
+import t from "../../isEmptyObject.mjs";
+import e from "../useFormErrorsMemo.mjs";
+import m from "./getOrphanFlatFieldErrors.mjs";
+const n = (r) => e((o) => {
+  if (t(o))
+    return {};
+  if (!r.current)
+    throw new Error();
+  return m(o, r.current);
+}), a = n;
+export {
+  a as default
+};

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

@@ -1,7 +1,7 @@
 import n from "react";
 import { useFormContext as m, useFormState as a } from "react-hook-form";
 import c from "../../isEmptyObject.mjs";
-import p from "./useOrphanFormErrors.mjs";
+import p from "./useOrphanFormErrorsMemo.mjs";
 const u = (o, e) => {
   const { getValues: s } = m(), { errors: t } = a(), r = p(o);
   n.useEffect(() => {

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

@@ -0,0 +1,4 @@
+const o = "root";
+export {
+  o as FormErrorPathRoot
+};

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

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

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

@@ -0,0 +1,5 @@
+import { FormErrorPathRoot as r } from "./consts.mjs";
+const s = (o) => o === r || o.startsWith(r + ".");
+export {
+  s as default
+};

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

@@ -0,0 +1,6 @@
+import o from "../useFormErrorsMemo.mjs";
+import r from "./getRootFlatFieldErrors.mjs";
+const e = () => o(r), s = e;
+export {
+  s as default
+};

package/dist/esm/errors/{useFormErrorsOnChange.mjs → useFormErrorsMemo.mjs}

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

package/dist/esm/main.mjs

@@ -1,36 +1,40 @@
 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";
+import { default as s } from "./errors/context/index.mjs";
+import { default as f } from "./errors/context/provider.mjs";
+import { default as u } from "./errors/message/FormErrorMessage.mjs";
+import { default as d } from "./errors/message/FormErrorMessageByPath.mjs";
+import { default as p } from "./errors/nonfield/FormNonFieldErrorMarker.mjs";
+import { default as E } from "./errors/nonfield/FormNonFieldErrorMarker.utils.mjs";
+import { default as i } from "./errors/orphan/useFormHasOrphanAndNoFieldErrors.mjs";
+import { default as M } from "./errors/orphan/useOrphanFormErrorsMemo.mjs";
+import { default as b } from "./errors/orphan/useOrphanFormErrorsToConsoleError.mjs";
+import { default as O } from "./errors/root/useRootFormFieldErrorsMemo.mjs";
+import { default as C } from "./errors/useFormErrorConsoleDebug.mjs";
+import { default as g } from "./errors/useFormErrorsEffect.mjs";
+import { default as N } from "./errors/useFormErrorsIfAny.mjs";
+import { default as v } from "./errors/useFormErrorsMemo.mjs";
+import { default as H } from "./errors/useFormRequestSubmit.mjs";
+import { default as T } from "./submit/useFormOnSubmitSuccessful.mjs";
+import { default as z } from "./submit/useFormOnSubmitSuccessfulAndReset.mjs";
+import { default as I } from "./submit/useResetFormOnSubmitSuccessful.mjs";
 export {
-  t as FormErrorMessage,
-  u as FormErrorMessageByPath,
-  m as FormNonFieldErrorMarker,
-  d as FormNonFieldErrorMarkerHtmlAttribute,
+  u as FormErrorMessage,
+  d as FormErrorMessageByPath,
+  f as FormErrorsFlatContextProvider,
+  p as FormNonFieldErrorMarker,
+  E 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
+  C as useFormErrorConsoleDebug,
+  g as useFormErrorsEffect,
+  s as useFormErrorsFlatContext,
+  N as useFormErrorsIfAny,
+  v as useFormErrorsMemo,
+  i as useFormHasOrphanAndNoFieldErrors,
+  T as useFormOnSubmitSuccessful,
+  z as useFormOnSubmitSuccessfulAndReset,
+  H as useFormRequestSubmit,
+  M as useOrphanFormErrorsMemo,
+  b as useOrphanFormErrorsToConsoleError,
+  I as useResetFormAfterSubmitSuccessful,
+  O as useRootFormFieldErrorsMemo
 };

package/dist/esm/utils/createRequiredContext.mjs

@@ -0,0 +1,13 @@
+import o from "react";
+function c() {
+  const t = o.createContext(void 0);
+  return [() => {
+    const e = o.useContext(t);
+    if (e === void 0)
+      throw new Error();
+    return e;
+  }, t.Provider];
+}
+export {
+  c as default
+};

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

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

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+type Props = React.PropsWithChildren<{
+    formRef: React.MutableRefObject<HTMLFormElement>;
+}>;
+/**
+ * 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/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/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/errors/flat/getFlatFieldErrorsByFilter.d.ts

@@ -0,0 +1,9 @@
+import { FieldError, FieldErrors } from 'react-hook-form';
+
+/**
+ * Get flat field errors filtered by supplied predicate.
+ */
+declare const getFlatFieldErrorsByFilter: (errors: FieldErrors, predicate: (entry: [string, FieldError]) => boolean) => {
+    [k: string]: FieldError;
+};
+export default getFlatFieldErrorsByFilter;

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

@@ -0,0 +1,3 @@
+import { FieldError } from 'react-hook-form';
+
+export type FlatFieldErrors = Record<string, FieldError>;

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

@@ -4,4 +4,4 @@
 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;
+export declare const hasNonFieldErrorMarkerInDOM: (path: string, parentElement: Pick<HTMLElement, 'querySelector'>) => boolean;

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Determine if an error path is root. (e.g., `root` or `root.nested`)
+ * @param path Flat path. (e.g., 'root.nested')
+ */
+declare const isFormErrorPathRoot: (path: string) => boolean;
+export default isFormErrorPathRoot;

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

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

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

@@ -0,0 +1,7 @@
+import { FieldErrors } from 'react-hook-form';
+
+/**
+ * Create memoized value from form errors.
+ */
+declare const useFormErrorsMemo: <TReturn>(callback: (errors: FieldErrors) => TReturn) => TReturn;
+export default useFormErrorsMemo;

package/dist/types/form/Form.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+
+export type FormProps = React.PropsWithoutRef<JSX.IntrinsicElements['form']> & {
+    antiCsrfToken?: string;
+};
+declare const Form: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "ref"> & {
+    antiCsrfToken?: string | undefined;
+} & React.RefAttributes<HTMLFormElement>>;
+export default Form;

package/dist/types/form/search/FormSearch.d.ts

@@ -0,0 +1,32 @@
+import { FormProps } from '../Form';
+import { z } from 'zod';
+import { default as React } from 'react';
+
+declare const _default: <TSchema extends z.ZodTypeAny, TSchemaOutput extends z.output<TSchema> = z.output<TSchema>>(props: Omit<FormProps, "children" | "onSubmit"> & {
+    /**
+     * Search params schema.
+     *
+     * Make sure all properties are marked as `optional().catch(undefiend)` to avoid errors from parsing.
+     */
+    schema: TSchema;
+    /** Current search params. */
+    search: NoInfer<TSchemaOutput>;
+    Fields: React.FC<{
+        search: TSchemaOutput;
+        isSubmitting: boolean;
+    }>;
+    /**
+     * Callback to handle form submission.
+     * @param search New search params.
+     * @param data Sanitized form data.
+     * @param event Form submit event.
+     */
+    onSubmit?: ((search: TSchemaOutput, data: TSchemaOutput, event: React.FormEvent<HTMLFormElement>) => unknown) | undefined;
+    /**
+     * Error handler.
+     *
+     * Obviates need for consumer `try/catch`.
+     */
+    onSubmitError?: ((error: unknown, search: TSchemaOutput, data: TSchemaOutput, event: React.FormEvent<HTMLFormElement>) => void) | undefined;
+} & React.RefAttributes<HTMLFormElement>) => React.ReactNode;
+export default _default;

package/dist/types/form/search/FormSearchHiddenInputs.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { Stringifiable } from 'query-string';
+
+/**
+ * Generate hidden inputs from the current search query string.
+ * This allows form to not require JS.
+ */
+declare const FormSearchHiddenInputs: React.FC<{
+    search: Record<string, Stringifiable>;
+    /** Keys to ignore. i.e., they have inputs. */
+    include: string[];
+}>;
+export default FormSearchHiddenInputs;

package/dist/types/form/search/getNewSearchParams.d.ts

@@ -0,0 +1,2 @@
+declare const getNewSearchParams: <TSearchParams extends Record<string, unknown>>(current: TSearchParams | undefined, update: TSearchParams) => TSearchParams;
+export default getNewSearchParams;

package/dist/types/main.d.ts

@@ -1,16 +1,18 @@
 export { default as LazyDevTool } from './devtool/LazyDevTool';
+export { default as useFormErrorsFlatContext } from './errors/context';
+export { default as FormErrorsFlatContextProvider } from './errors/context/provider';
 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 useFormHasOrphanAndNoFieldErrors } from './errors/orphan/useFormHasOrphanAndNoFieldErrors';
-export { default as useOrphanFormErrors } from './errors/orphan/useOrphanFormErrors';
+export { default as useOrphanFormErrorsMemo } from './errors/orphan/useOrphanFormErrorsMemo';
 export { default as useOrphanFormErrorsToConsoleError } from './errors/orphan/useOrphanFormErrorsToConsoleError';
-export { default as useRootFormFieldErrors } from './errors/root/useRootFormFieldErrors';
+export { default as useRootFormFieldErrorsMemo } from './errors/root/useRootFormFieldErrorsMemo';
 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 useFormErrorsMemo } from './errors/useFormErrorsMemo';
 export { default as useFormRequestSubmit } from './errors/useFormRequestSubmit';
 export { default as useFormOnSubmitSuccessful } from './submit/useFormOnSubmitSuccessful';
 export { default as useFormOnSubmitSuccessfulAndReset } from './submit/useFormOnSubmitSuccessfulAndReset';

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

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+
+/**
+ * Create a strongly-typed context that throws error if no provider is found.
+ * @returns A tuple with a function to get the context and the context provider.
+ */
+declare function createRequiredContext<T = unknown>(): readonly [() => T & ({} | null), React.Provider<T | undefined>];
+export default createRequiredContext;

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

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+
+/**
+ * @see https://www.totaltypescript.com/forwardref-with-generic-components
+ */
+declare function fixedForwardRef<T, P = object>(render: (props: P, ref: React.Ref<T>) => React.ReactNode): (props: P & React.RefAttributes<T>) => React.ReactNode;
+export default fixedForwardRef;

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

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+
+/**
+ * Create a ref and point forwarded ref to it.
+ *
+ * Use case: forwarded refs are optional, but sometimes you need the ref.
+ *
+ * @param forwardedRef Forwarded `ref` prop.
+ */
+declare const useImperativeForwardedRef: <TRef>(forwardedRef: React.ForwardedRef<TRef> | undefined) => React.RefObject<TRef>;
+export default useImperativeForwardedRef;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@paragrav/rhf-utils",
   "author": "paragrav.dev",
   "license": "MIT",
-  "version": "0.0.27",
+  "version": "0.0.28",
   "description": "Integration utilities for react-hook-form.",
   "type": "module",
   "sideEffects": false,
@@ -99,6 +99,7 @@
   },
   "peerDependencies": {
     "flat": "^6",
+    "query-string": "^9",
     "react": "^18",
     "react-hook-form": "^7"
   },
@@ -109,6 +110,7 @@
     "@rollup/plugin-typescript": "^11.1.6",
     "@types/node": "^18.19.26",
     "@types/react": "^18.2.69",
+    "@types/react-dom": "^18.2.23",
     "@typescript-eslint/eslint-plugin": "^7.3.1",
     "@typescript-eslint/parser": "^7.3.1",
     "@vitejs/plugin-react": "^4.2.1",

package/dist/esm/errors/getFlatFieldErrors.mjs

@@ -1,22 +0,0 @@
-import { get as f } from "react-hook-form";
-import n from "./flattenFieldErrors.mjs";
-const p = (t) => {
-  const a = n(t), c = Object.keys(a);
-  return Object.fromEntries(
-    c.reduce(
-      (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
-    )
-  );
-}, d = /\.(?:type|message)\b$/;
-export {
-  p as default,
-  d as regexMaybeFieldErrorLeafNode
-};

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

@@ -1,14 +0,0 @@
-import "react";
-import t from "../../isEmptyObject.mjs";
-import e from "../useFormErrorsOnChange.mjs";
-import n from "./getOrphanFlatFieldErrors.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/root/useRootFormFieldErrors.mjs

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

package/dist/esm/errors/useFormFieldErrors.mjs

@@ -1,13 +0,0 @@
-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
-};