@paragrav/rhf-utils 0.0.26 → 0.0.28

package/dist/{devtool → esm/devtool}/LazyDevTool.mjs

@@ -2,15 +2,15 @@ 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) => ({
+  () => import("@hookform/devtools").then((o) => ({
     default: o.DevTool
   }))
-), f = ({ isDev: o, ...l }) => {
+), 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 }) });
-}, m = f;
+}, u = s;
 export {
-  m as default
+  u as default
 };

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/{errors → 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/{errors → 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

@@ -0,0 +1,10 @@
+import r from "../../isEmptyObject.mjs";
+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 = 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/{errors → esm/errors}/orphan/useOrphanFormErrorsToConsoleError.mjs

@@ -1,9 +1,9 @@
 import n from "react";
-import { useFormContext as a, useFormState as m } from "react-hook-form";
+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 } = a(), { errors: t } = m(), r = p(o);
+  const { getValues: s } = m(), { errors: t } = a(), r = p(o);
   n.useEffect(() => {
     if (!c(r) && (console.error(
       "useOrphanFormErrorsToConsoleError",

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/{errors → esm/errors}/useFormErrorsEffect.mjs

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

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

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

package/dist/esm/main.mjs

@@ -0,0 +1,40 @@
+import { default as e } from "./devtool/LazyDevTool.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 {
+  u as FormErrorMessage,
+  d as FormErrorMessageByPath,
+  f as FormErrorsFlatContextProvider,
+  p as FormNonFieldErrorMarker,
+  E as FormNonFieldErrorMarkerHtmlAttribute,
+  e as LazyDevTool,
+  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/submit/useFormOnSubmitSuccessful.mjs

@@ -0,0 +1,11 @@
+import u from "react";
+import { useFormState as e } from "react-hook-form";
+const o = (s) => {
+  const { isSubmitSuccessful: t } = e();
+  u.useEffect(() => {
+    s && t && s();
+  }, [s, t]);
+}, r = o;
+export {
+  r as default
+};

package/dist/esm/submit/useFormOnSubmitSuccessfulAndReset.mjs

@@ -0,0 +1,14 @@
+import r from "react";
+import { useFormState as c } from "react-hook-form";
+import f from "./useFormOnSubmitSuccessful.mjs";
+const m = (s) => {
+  const { isSubmitSuccessful: t, isDirty: u } = c(), e = r.useRef(!1);
+  f(() => {
+    e.current = !0;
+  }), r.useEffect(() => {
+    s && e.current && !t && !u && (s(), e.current = !1);
+  }, [t, u]);
+}, S = m;
+export {
+  S as default
+};

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/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/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/{errors → 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/{errors → 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/{main.d.ts → 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;