@paragrav/rhf-utils 0.0.28 → 0.0.30

package/dist/esm/errors/consoleErrors.mjs

@@ -0,0 +1,9 @@
+const l = (e, c, r) => {
+  console[r != null && r.isError ? "error" : "debug"](e, {
+    form: c,
+    other: r == null ? void 0 : r.other
+  });
+};
+export {
+  l as default
+};

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

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

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

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

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

@@ -1,5 +1,5 @@
 import { jsx as t } from "react/jsx-runtime";
-import e from "./FormNonFieldErrorMarker.utils.mjs";
+import e from "./FormNonFieldErrorMarkerHtmlAttribute.mjs";
 const a = ({ path: r }) => {
   const o = {
     [e]: r

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

@@ -1,6 +1,6 @@
-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));
+import o from "./FormNonFieldErrorMarkerHtmlAttribute.mjs";
+const t = (r) => `[role="alert"][${o}="${r}"]`, n = (r, e) => !!e.querySelector(t(r));
 export {
-  a as default,
   t as getFormNonFieldErrorMarkerQuerySelector,
-  l as hasNonFieldErrorMarkerInDOM
+  n as hasNonFieldErrorMarkerInDOM
 };

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

@@ -0,0 +1,4 @@
+const r = "data-paragrav-rhf-utils-nonfield-error-marker-path", t = r;
+export {
+  t as default
+};

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

@@ -0,0 +1,18 @@
+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,
+    isError: !0,
+    data: {
+      location: window.location,
+      orphans: o
+    }
+  });
+}, d = a;
+export {
+  d as default
+};

package/dist/esm/errors/outputErrors.mjs

@@ -0,0 +1,8 @@
+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;
+export {
+  f as default
+};

package/dist/esm/errors/useFormErrorConsoleDebug.mjs

@@ -1,8 +1,10 @@
-import e from "./useFormErrorsIfAny.mjs";
-const s = (o) => {
-  const r = e();
-  o && r && console.debug("useFormErrorConsoleDebug", r);
-}, n = s;
+import { useFormContext as s } from "react-hook-form";
+import t from "./outputErrors.mjs";
+import u from "./useFormErrorsIfAny.mjs";
+const m = (o) => {
+  const { getValues: e } = s(), r = u();
+  o && r && t("useFormErrorConsoleDebug", { values: e(), errors: r });
+}, i = m;
 export {
-  n as default
+  i as default
 };

package/dist/esm/errors/useFormErrorsToConsole.mjs

@@ -0,0 +1,21 @@
+import a from "react";
+import { useFormContext as c, useFormState as l } from "react-hook-form";
+import E from "../isEmptyObject.mjs";
+import d from "./outputErrors.mjs";
+const v = (e, m, r) => {
+  const { getValues: f } = c(), { errors: u } = l();
+  a.useEffect(() => {
+    if (!(r != null && r.disabled) && !E(m) && (d(e, { values: f(), errors: u }, r), console[r != null && r.isError ? "error" : "debug"](e, {
+      form: {
+        values: f(),
+        // form values
+        errors: u
+      },
+      other: r == null ? void 0 : r.data
+    }), r != null && r.isError))
+      throw new Error(e);
+  }, [u]);
+};
+export {
+  v as default
+};

package/dist/esm/errors/useFormRequestSubmit.mjs

@@ -1,8 +1,10 @@
 const r = (t) => (e) => {
   if (!t.current)
     throw new Error();
-  t.current.requestSubmit(e);
-}, u = r;
+  u(t.current, e);
+}, s = r, u = (t, e) => {
+  t.requestSubmit(e);
+};
 export {
-  u as default
+  s as default
 };

package/dist/esm/form/context/parent/FormParentContextProvider.mjs

@@ -0,0 +1,10 @@
+import { jsx as e } from "react/jsx-runtime";
+import s from "react";
+import { _FormParentContextProvider as n } from "./index.mjs";
+const a = ({ children: t }) => {
+  const [r, o] = s.useState(!1);
+  return /* @__PURE__ */ e(n, { value: { isBusy: r, setIsBusy: o }, children: t });
+}, P = a;
+export {
+  P as default
+};

package/dist/esm/form/context/parent/index.mjs

@@ -0,0 +1,6 @@
+import t from "../../../utils/createContext.mjs";
+const [o, , r] = t();
+export {
+  r as _FormParentContextProvider,
+  o as _useFormParentContext
+};

package/dist/esm/form/context/parent/useAsFormParentState.mjs

@@ -0,0 +1,14 @@
+import o from "react";
+import r from "../../useFormIsBusy.mjs";
+import { _useFormParentContext as s } from "./index.mjs";
+const n = () => {
+  const e = r(), t = s();
+  if (!t)
+    throw new Error("Parent context is not provided.");
+  o.useEffect(() => {
+    t.setIsBusy(e);
+  }, [t, e]);
+}, c = n;
+export {
+  c as default
+};

package/dist/esm/form/context/parent/useFormParentIsBusy.mjs

@@ -0,0 +1,8 @@
+import { _useFormParentContext as t } from "./index.mjs";
+const e = () => {
+  var s;
+  return (s = t()) == null ? void 0 : s.isBusy;
+}, r = e;
+export {
+  r as default
+};

package/dist/esm/form/useFormIsBusy.mjs

@@ -0,0 +1,9 @@
+import { useFormState as r } from "react-hook-form";
+import e from "./context/parent/useFormParentIsBusy.mjs";
+const m = () => {
+  const { isSubmitting: t, isLoading: o } = r(), s = e();
+  return !!(t || o || s);
+};
+export {
+  m as default
+};

package/dist/esm/main.mjs

@@ -4,37 +4,43 @@ 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 n } from "./errors/nonfield/FormNonFieldErrorMarkerHtmlAttribute.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";
+import { default as c } from "./errors/orphan/useOrphanFormErrorsMemo.mjs";
+import { default as b } from "./errors/orphan/useOrphanFormErrorsToConsole.mjs";
+import { default as P } from "./errors/root/useRootFormFieldErrorsMemo.mjs";
+import { default as O } from "./errors/useFormErrorConsoleDebug.mjs";
+import { default as y } from "./errors/useFormErrorsEffect.mjs";
+import { default as g } from "./errors/useFormErrorsIfAny.mjs";
+import { default as N } from "./errors/useFormErrorsMemo.mjs";
+import { default as B } from "./errors/useFormRequestSubmit.mjs";
+import { default as H } from "./form/context/parent/FormParentContextProvider.mjs";
+import { default as T } from "./form/context/parent/useAsFormParentState.mjs";
+import { default as z } from "./form/context/parent/useFormParentIsBusy.mjs";
+import { default as j } from "./submit/useFormOnSubmitSuccessful.mjs";
+import { default as G } from "./submit/useFormOnSubmitSuccessfulAndReset.mjs";
+import { default as K } from "./submit/useResetFormOnSubmitSuccessful.mjs";
 export {
   u as FormErrorMessage,
   d as FormErrorMessageByPath,
   f as FormErrorsFlatContextProvider,
   p as FormNonFieldErrorMarker,
-  E as FormNonFieldErrorMarkerHtmlAttribute,
+  n as FormNonFieldErrorMarkerHtmlAttribute,
+  H as FormParentContextProvider,
   e as LazyDevTool,
-  C as useFormErrorConsoleDebug,
-  g as useFormErrorsEffect,
+  T as useAsFormParentState,
+  O as useFormErrorConsoleDebug,
+  y as useFormErrorsEffect,
   s as useFormErrorsFlatContext,
-  N as useFormErrorsIfAny,
-  v as useFormErrorsMemo,
+  g as useFormErrorsIfAny,
+  N 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
+  j as useFormOnSubmitSuccessful,
+  G as useFormOnSubmitSuccessfulAndReset,
+  z as useFormParentIsBusy,
+  B as useFormRequestSubmit,
+  c as useOrphanFormErrorsMemo,
+  b as useOrphanFormErrorsToConsole,
+  K as useResetFormAfterSubmitSuccessful,
+  P as useRootFormFieldErrorsMemo
 };

package/dist/esm/submit/useResetFormOnSubmitSuccessful.mjs

@@ -1,11 +1,14 @@
-import { useFormContext as r } from "react-hook-form";
-import t from "./useFormOnSubmitSuccessful.mjs";
-const s = (e) => {
-  const { reset: u } = r();
-  t(() => {
-    e != null && e.enabled && u(void 0, e);
+import { useFormContext as u } from "react-hook-form";
+import o from "./useFormOnSubmitSuccessful.mjs";
+const r = ({
+  enabled: e,
+  ...t
+}) => {
+  const { reset: s } = u();
+  o(() => {
+    e && s(void 0, t);
   });
-}, f = s;
+}, f = r;
 export {
   f as default
 };

package/dist/esm/utils/createContext.mjs

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

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

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

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

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

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

@@ -1,6 +1,8 @@
 /// <reference types="react" />
 type Props = React.PropsWithChildren<{
     formRef: React.MutableRefObject<HTMLFormElement>;
+    isDev?: boolean;
+    outputErrors?: boolean;
 }>;
 /**
  * Provides a flattened version of the form errors.

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

@@ -1,7 +1,2 @@
-/**
- * HTML data attribute for {@link FormNonFieldErrorMarker}.
- */
-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'>) => boolean;

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

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

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

@@ -0,0 +1,14 @@
+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>;
+    isDev?: boolean;
+    isError?: boolean;
+}) => void;
+export default outputErrors;

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

@@ -4,5 +4,5 @@
  *
  * `console.debug()` is unlikely to trigger any automated console capture reporting.
  */
-declare const useFormErrorConsoleDebug: (condition: boolean) => void;
+declare const useFormErrorConsoleDebug: (enabled?: boolean) => void;
 export default useFormErrorConsoleDebug;

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

@@ -0,0 +1,14 @@
+import { FlatFieldErrors } from './flat/types';
+
+/**
+ * Logs out orphan errors to console.error.
+ *
+ * When `isDev`, it will also throw an error to bring attention to dev.
+ */
+declare const useFormErrorsToConsole: (message: string, flatErrors: FlatFieldErrors, options?: {
+    disabled?: boolean;
+    isDev?: boolean;
+    isError?: boolean;
+    data?: Record<string, unknown>;
+}) => void;
+export default useFormErrorsToConsole;

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

@@ -1,9 +1,21 @@
+import { FormBaseProps } from './FormBase';
+import { LazyDevToolProps } from '../devtool/LazyDevTool';
+import { FieldValues, SubmitErrorHandler, UseFormReturn } from 'react-hook-form';
 import { default as React } from 'react';
 
-export type FormProps = React.PropsWithoutRef<JSX.IntrinsicElements['form']> & {
-    antiCsrfToken?: string;
+export type FormProps<TFieldValues extends FieldValues, TTransformedValues extends FieldValues> = Omit<FormBaseProps, 'onSubmit'> & {
+    isDev: boolean;
+    formRef: React.RefObject<HTMLFormElement>;
+    onSubmit: (values: TTransformedValues, context: UseFormReturn<TFieldValues, unknown, TTransformedValues>, event: React.BaseSyntheticEvent<SubmitEvent>) => unknown | Promise<unknown>;
+    /** Submit error handler. (Only for errors not of instance `FormError`, which are handled internally.) */
+    onSubmitError?: (error: unknown, values: TTransformedValues, context: UseFormReturn<TFieldValues, unknown, TTransformedValues>, event: React.BaseSyntheticEvent<SubmitEvent>) => void;
+    /** Submit handler when form is invalid. */
+    onSubmitInvalid?: SubmitErrorHandler<TFieldValues>;
+    options?: {
+        disableEmptyRootError?: boolean;
+        devTool?: LazyDevToolProps | 'disabled';
+    };
+    className?: string;
 };
-declare const Form: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "ref"> & {
-    antiCsrfToken?: string | undefined;
-} & React.RefAttributes<HTMLFormElement>>;
+declare function Form<TFieldValues extends FieldValues, TTransformedValues extends FieldValues>({ isDev, formRef, onSubmit, onSubmitError, onSubmitInvalid, options, children, ...props }: FormProps<TFieldValues, TTransformedValues>): import("react/jsx-runtime").JSX.Element;
 export default Form;

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

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

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

@@ -0,0 +1,6 @@
+import { FieldPath, FieldValues } from 'react-hook-form';
+
+export declare class FormError<TFieldValues extends FieldValues> extends Error {
+    errors: Partial<Record<FieldPath<TFieldValues> | `root.${string}`, string>>;
+    constructor(errors: Partial<Record<FieldPath<TFieldValues> | `root.${string}`, string>>, message?: string);
+}

package/dist/types/form/context/FormProvider.d.ts

@@ -0,0 +1,13 @@
+import { FormUtilsContextProviderProps } from './utils/FormUtilsContextProvider';
+import { FormProps } from '../Form';
+import { FieldValues, UseFormReturn } from 'react-hook-form';
+
+type Props<TFieldValues extends FieldValues, // input values
+TTransformedValues extends FieldValues> = React.PropsWithChildren<{
+    ctx: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+} & {
+    form: FormProps<TFieldValues, TTransformedValues>;
+    utils?: FormUtilsContextProviderProps;
+}>;
+declare function FormProvider<TFieldValues extends FieldValues, TTransformedValues extends FieldValues>({ ctx, form, utils, children }: Props<TFieldValues, TTransformedValues>): import("react/jsx-runtime").JSX.Element;
+export default FormProvider;

package/dist/types/form/context/parent/FormParentContextProvider.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+
+type Props = React.PropsWithChildren;
+declare const FormParentContextProvider: React.FC<Props>;
+export default FormParentContextProvider;

package/dist/types/form/context/parent/index.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export type FormParentContext = {
+    isBusy: boolean;
+    setIsBusy: (isBusy: boolean) => void;
+};
+export declare const _useFormParentContext: () => FormParentContext | undefined, _FormParentContextProvider: import('react').Provider<FormParentContext | undefined>;

package/dist/types/form/context/parent/useAsFormParentState.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Connect specific form state as parent context.
+ *
+ * Requires usage of provider.
+ */
+declare const useAsFormParentState: () => void;
+export default useAsFormParentState;

package/dist/types/form/context/parent/useFormParentIsBusy.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get parent form state, if exists.
+ *
+ * Context provider not required. (`undefined` value in this case.)
+ */
+declare const useFormParentIsBusy: () => boolean | undefined;
+export default useFormParentIsBusy;

package/dist/types/form/context/utils/FormUtilsContextProvider.d.ts

@@ -0,0 +1,12 @@
+import { FormProps } from '../../Form';
+import { FieldValues } from 'react-hook-form';
+
+export type FormUtilsContextProviderProps = {
+    /** Callback after successful submit, and form reset. */
+    onSubmitSuccessfulAndReset?: () => void;
+};
+type Props<TFieldValues extends FieldValues, TTransformedValues extends FieldValues> = React.PropsWithChildren<{
+    formProps: FormProps<TFieldValues, TTransformedValues>;
+} & FormUtilsContextProviderProps>;
+declare function FormUtilsContextProvider<TFieldValues extends FieldValues, TTransformedValues extends FieldValues>({ formProps, onSubmitSuccessfulAndReset, children, }: Props<TFieldValues, TTransformedValues>): import("react/jsx-runtime").JSX.Element;
+export default FormUtilsContextProvider;

package/dist/types/form/context/utils/useFormUtilsContext.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+export type FormUtilsContext = {
+    formRef: React.RefObject<HTMLFormElement>;
+    /** Callback to trigger submit manually -- e.g., on change. */
+    requestSubmit: HTMLFormElement['requestSubmit'];
+};
+declare const useFormUtilsContext: () => FormUtilsContext, _FormUtilsContextProvider: import('react').Provider<FormUtilsContext | undefined>;
+export default useFormUtilsContext;
+export { _FormUtilsContextProvider };

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

@@ -1,8 +1,8 @@
-import { FormProps } from '../Form';
+import { FormBaseProps } from '../FormBase';
 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"> & {
+declare const _default: <TSchema extends z.ZodTypeAny, TSchemaOutput extends z.output<TSchema> = z.output<TSchema>>(props: Omit<FormBaseProps, "children" | "onSubmit"> & {
     /**
      * Search params schema.
      *

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

@@ -0,0 +1,28 @@
+import { FormProps } from './Form';
+import { FormUtilsContextProviderProps } from './context/utils/FormUtilsContextProvider';
+import { FieldValues, UseFormProps as RhfUseFormProps } from 'react-hook-form';
+import { default as React } from 'react';
+
+export type UseFormProps<TFieldValues extends FieldValues, TTransformedValues extends FieldValues> = {
+    rhf: RhfUseFormProps<TFieldValues>;
+    props: FormProps<TFieldValues, TTransformedValues>;
+    utils?: FormUtilsContextProviderProps;
+};
+export type UseFormReturn = ReturnType<typeof useForm>;
+/**
+ * Base Rhf Form hook. Use `Form` in `index.ts` for most cases.
+ * Use this if you need to separate form components.
+ * e.g., a form for table row due to `form` being considered invalid HTML around `tr` tags.
+ * With this hook, you can wrap the `tr` tag with `form.Provider` and use `form.Form` inside
+ * one of the cells. Other components can be outside form while referring to form by its id via `form` attribute.
+ * see https://caniuse.com/?search=form%20attribute
+ * @returns Form provider and form.
+ */
+export declare const useForm: <TFieldValues extends FieldValues, TTransformedValues extends FieldValues>({ rhf, props, utils, }: UseFormProps<TFieldValues, TTransformedValues>) => {
+    Provider: React.FC<{
+        children?: React.ReactNode;
+    }>;
+    Form: React.FC<{
+        children?: React.ReactNode;
+    }>;
+};

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

@@ -0,0 +1,2 @@
+declare const useFormIsBusy: () => boolean;
+export default useFormIsBusy;

package/dist/types/main.d.ts

@@ -4,16 +4,19 @@ export { default as FormErrorsFlatContextProvider } from './errors/context/provi
 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 FormNonFieldErrorMarkerHtmlAttribute } from './errors/nonfield/FormNonFieldErrorMarkerHtmlAttribute';
 export { default as useFormHasOrphanAndNoFieldErrors } from './errors/orphan/useFormHasOrphanAndNoFieldErrors';
 export { default as useOrphanFormErrorsMemo } from './errors/orphan/useOrphanFormErrorsMemo';
-export { default as useOrphanFormErrorsToConsoleError } from './errors/orphan/useOrphanFormErrorsToConsoleError';
+export { default as useOrphanFormErrorsToConsole } from './errors/orphan/useOrphanFormErrorsToConsole';
 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 useFormErrorsMemo } from './errors/useFormErrorsMemo';
 export { default as useFormRequestSubmit } from './errors/useFormRequestSubmit';
+export { default as FormParentContextProvider } from './form/context/parent/FormParentContextProvider';
+export { default as useAsFormParentState } from './form/context/parent/useAsFormParentState';
+export { default as useFormParentIsBusy } from './form/context/parent/useFormParentIsBusy';
 export { default as useFormOnSubmitSuccessful } from './submit/useFormOnSubmitSuccessful';
 export { default as useFormOnSubmitSuccessfulAndReset } from './submit/useFormOnSubmitSuccessfulAndReset';
 export { default as useResetFormAfterSubmitSuccessful } from './submit/useResetFormOnSubmitSuccessful';

package/dist/types/submit/useResetFormOnSubmitSuccessful.d.ts

@@ -8,5 +8,5 @@ type Options = {
  * See `Rules` section: https://react-hook-form.com/api/useform/reset/
  * Specifically: "- It's recommended to reset inside useEffect after submission."
  */
-declare const useResetFormAfterSubmitSuccessful: (options?: Options) => void;
+declare const useResetFormAfterSubmitSuccessful: ({ enabled, ...options }: Options) => void;
 export default useResetFormAfterSubmitSuccessful;

package/dist/types/utils/createContext.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 createContext<T = unknown>(): readonly [() => T | undefined, () => T & ({} | null), React.Provider<T | undefined>];
+export default createContext;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@paragrav/rhf-utils",
   "author": "paragrav.dev",
   "license": "MIT",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "Integration utilities for react-hook-form.",
   "type": "module",
   "sideEffects": false,
@@ -71,6 +71,18 @@
       "default": "./dist/esm/errors/root/useRootFormFieldErrors.mjs",
       "types": "./dist/types/errors/root/useRootFormFieldErrors.d.ts"
     },
+    "./form/context/parent/FormParentContextProvider": {
+      "default": "./dist/esm/form/context/parent/FormParentContextProvider.mjs",
+      "types": "./dist/types/form/context/parent/FormParentContextProvider.d.ts"
+    },
+    "./form/context/parent/useAsFormParentState": {
+      "default": "./dist/esm/form/context/parent/useAsFormParentState.mjs",
+      "types": "./dist/types/form/context/parent/useAsFormParentState.d.ts"
+    },
+    "./form/context/parent/useFormParentIsBusy": {
+      "default": "./dist/esm/form/context/parent/useFormParentIsBusy.mjs",
+      "types": "./dist/types/form/context/parent/useFormParentIsBusy.d.ts"
+    },
     "./submit/useFormOnSubmitSuccessful": {
       "default": "./dist/esm/submit/useFormOnSubmitSuccessful.mjs",
       "types": "./dist/types/submit/useFormOnSubmitSuccessful.d.ts"
@@ -147,9 +159,13 @@
   },
   "homepage": "https://github.com/paragrav/rhf-utils",
   "keywords": [
-    "react-hook-form",
-    "zod",
+    "integration",
     "form",
-    "react"
+    "forms",
+    "react",
+    "react-hook-form",
+    "utilities",
+    "utils",
+    "zod"
   ]
 }

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

@@ -1,24 +0,0 @@
-import n from "react";
-import { useFormContext as m, useFormState as a } from "react-hook-form";
-import c from "../../isEmptyObject.mjs";
-import p from "./useOrphanFormErrorsMemo.mjs";
-const u = (o, e) => {
-  const { getValues: s } = m(), { errors: t } = a(), 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 {
-  h as default
-};

package/dist/esm/utils/createRequiredContext.mjs

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