@paragrav/rhf-utils 0.0.140 → 0.0.141

package/dist/types/errors/trpc/trpcClientErrorToFormSubmitFieldErrorsSchemaTransformer.d.ts

@@ -0,0 +1,28 @@
+import { TRPCClientErrorLike } from '@trpc/client';
+import { AnyRouter } from '@trpc/server';
+import { z } from 'zod';
+import { FormSubmitFieldErrors } from '../../submit/error/FormSubmitFieldErrors';
+
+/**
+ * Schema that transforms {@link TRPCClientError} to RHF {@link FormSubmitFieldErrors}.
+ */
+declare const trpcClientErrorToFormSubmitFieldErrorsSchemaTransformer: z.ZodEffects<z.ZodEffects<z.ZodPipeline<z.ZodEffects<z.ZodEffects<z.ZodType<TRPCClientErrorLike<AnyRouter>, z.ZodTypeDef, TRPCClientErrorLike<AnyRouter>>, string, TRPCClientErrorLike<AnyRouter>>, unknown, TRPCClientErrorLike<AnyRouter>>, z.ZodArray<z.ZodObject<{
+    validation: z.ZodString;
+    code: z.ZodString;
+    message: z.ZodString;
+    path: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    code: string;
+    path: string[];
+    validation: string;
+}, {
+    message: string;
+    code: string;
+    path: string[];
+    validation: string;
+}>, "many">>, (readonly [string, {
+    type: string;
+    message: string;
+}])[], TRPCClientErrorLike<AnyRouter>>, FormSubmitFieldErrors, TRPCClientErrorLike<AnyRouter>>;
+export default trpcClientErrorToFormSubmitFieldErrorsSchemaTransformer;

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

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { SafeFieldValues } from './SafeFieldValues';
+import { UseRhfUtilsFormProps } from './UseRhfUtilsFormProps';
+
+export type FormChildrenSlots = 'top' | 'bottom';
+export type FormProps<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = {
+    formId: string;
+    formRef: React.RefObject<HTMLFormElement>;
+} & Pick<UseRhfUtilsFormProps<TFieldValues, TTransformedValues>, 'onSubmit' | 'onSubmitError' | 'onSubmitInvalid' | 'Children' | 'form' | 'utils'>;
+declare function _Form<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues>({ formId, formRef, onSubmit, onSubmitError, onSubmitInvalid, Children, form, utils, }: FormProps<TFieldValues, TTransformedValues>): import("react/jsx-runtime").JSX.Element;
+export default _Form;

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

@@ -0,0 +1,13 @@
+import { SafeFieldValues } from './SafeFieldValues';
+import { UseRhfUtilsFormProps } from './UseRhfUtilsFormProps';
+
+export type FormWithProvidersProps<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = React.PropsWithChildren<UseRhfUtilsFormProps<TFieldValues, TTransformedValues>>;
+/**
+ * Form providers (with utils) with immediate descendent {@link Form}.
+ * (Syntactic sugar for {@link useRhfUtilsForm}. Use this for most applications.)
+ *
+ * Use {@link useRhfUtilsForm} if you need to specific nesting hierarchy.
+ * (e.g., wrapping `<tr>` with provider and nesting `<form>` within `<td>` to appease HTML rules.)
+ */
+declare function FormWithProviders<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues>(props: FormWithProvidersProps<TFieldValues, TTransformedValues>): import("react/jsx-runtime").JSX.Element;
+export default FormWithProviders;

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

@@ -0,0 +1,29 @@
+import { DevtoolUIProps } from '@hookform/devtools/dist/devToolUI';
+import { UseResetFormOnSubmittedOptions } from '../submit/useResetFormOnSubmitted';
+import { Register } from '../register';
+
+/**
+ * Options for enabling utils functionality provided by this library.
+ *
+ * Can be extended using {@link Register.RhfUtilsFormOptions}.
+ */
+export type RhfUtilsFormOptions = {
+    /** Stop propagation of submit event. */
+    stopSubmitPropagation?: boolean;
+    /**
+     * Request submit via listener on form change.
+     * - `true` to submit on any change.
+     * - number to debounce in milliseconds.
+     */
+    submitOnChange?: boolean | number;
+    /** Reset form values and state (e.g., `isDirty`) after submit -- on success and/or error. */
+    resetOnSubmitted?: UseResetFormOnSubmittedOptions;
+    /**
+     * Control dev tool options.
+     * (Lazy-loaded when truthy value supplied.
+     * For zero bundle size in prod, be sure to check for dev environment.)
+     */
+    devTool?: boolean | Pick<DevtoolUIProps, 'placement' | 'styles'>;
+} & (Register extends {
+    RhfUtilsFormOptions: infer _RhfUtilsFormOptions;
+} ? _RhfUtilsFormOptions : {});

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

@@ -0,0 +1,12 @@
+import { UseFormReturn } from 'react-hook-form';
+import { RhfUtilsFormOptions } from './RhfUtilsFormOptions';
+import { SafeFieldValues } from './SafeFieldValues';
+
+export type RhfUtilsFormProvidersProps<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = React.PropsWithChildren<{
+    formId: string;
+    formRef: React.RefObject<HTMLFormElement>;
+    rhfForm: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+    utils?: RhfUtilsFormOptions;
+}>;
+declare function RhfUtilsFormProviders<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues>({ formId, formRef, rhfForm, utils, children, }: RhfUtilsFormProvidersProps<TFieldValues, TTransformedValues>): import("react/jsx-runtime").JSX.Element;
+export default RhfUtilsFormProviders;

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

@@ -0,0 +1,4 @@
+/**
+ * Equivalent to RHF's `FieldValues` except for `unknown` (instead of `any`) value.
+ */
+export type SafeFieldValues = Record<string, unknown>;

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

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+import { UseFormReturn } from 'react-hook-form';
+import { FormSubmitError } from '../submit/error/FormSubmitError';
+import { default as _Controller } from './_Controller';
+import { RhfUtilsFormOptions } from './RhfUtilsFormOptions';
+import { SafeFieldValues } from './SafeFieldValues';
+
+/**
+ * Component props for `Children`.
+ *
+ * Consider keeping shape in line with `UseRhfUtilsFormOnSubmitProps` and `UseRhfUtilsFormReturn`.
+ */
+export type UseRhfUtilsFormChildrenProps<TFieldValues extends SafeFieldValues = SafeFieldValues, TTransformedValues extends SafeFieldValues = SafeFieldValues> = {
+    formId: string;
+    formRef: React.RefObject<HTMLFormElement>;
+    context: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+    utils?: RhfUtilsFormOptions;
+    Controller: typeof _Controller<TFieldValues>;
+    FormSubmitError: typeof FormSubmitError<TFieldValues>;
+};

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

@@ -0,0 +1,27 @@
+import { default as React } from 'react';
+import { UseFormReturn } from 'react-hook-form';
+import { FormSubmitError } from '../submit/error/FormSubmitError';
+import { RhfUtilsFormOptions } from './RhfUtilsFormOptions';
+import { SafeFieldValues } from './SafeFieldValues';
+
+/**
+ * Props for onSubmit other than `data` and `event`.
+ *
+ * Consider keeping shape in line with `UseRhfUtilsFormChildrenProps` and `UseRhfUtilsFormReturn`.
+ */
+export type UseRhfUtilsFormOnSubmitContext<TFieldValues extends SafeFieldValues = SafeFieldValues, TTransformedValues extends SafeFieldValues = SafeFieldValues> = {
+    formId: string;
+    formRef: React.RefObject<HTMLFormElement>;
+    context: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+    utils?: RhfUtilsFormOptions;
+    FormSubmitError: typeof FormSubmitError<TFieldValues>;
+};
+/**
+ * Props for onSubmitError other than `error` and `event`.
+ */
+export type UseRhfUtilsFormOnSubmitErrorContext<TFieldValues extends SafeFieldValues = SafeFieldValues, TTransformedValues extends SafeFieldValues = SafeFieldValues> = {
+    formId: string;
+    formRef: React.RefObject<HTMLFormElement>;
+    context: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+    utils?: RhfUtilsFormOptions;
+};

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

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { SubmitErrorHandler, UseFormProps } from 'react-hook-form';
+import { MaybePromise } from '../utils/types';
+import { RhfUtilsFormOptions } from './RhfUtilsFormOptions';
+import { SafeFieldValues } from './SafeFieldValues';
+import { UseRhfUtilsFormChildrenProps } from './UseRhfUtilsFormChildrenProps';
+import { UseRhfUtilsFormOnSubmitContext, UseRhfUtilsFormOnSubmitErrorContext } from './UseRhfUtilsFormOnSubmitContext';
+
+export type UseRhfUtilsFormProps<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = {
+    defaultValues?: UseFormProps<TFieldValues>['defaultValues'];
+    onSubmit?: (values: TTransformedValues, context: UseRhfUtilsFormOnSubmitContext<TFieldValues, TTransformedValues>, event: React.BaseSyntheticEvent<SubmitEvent>) => MaybePromise<unknown>;
+    /** Submit error handler. (Only for errors not of instance `FormError`, which are handled internally.) */
+    onSubmitError?: (error: unknown, context: UseRhfUtilsFormOnSubmitErrorContext<TFieldValues, TTransformedValues>, event: React.BaseSyntheticEvent<SubmitEvent>) => void;
+    /** Submit handler when form is invalid. */
+    onSubmitInvalid?: SubmitErrorHandler<TFieldValues>;
+    Children: React.FC<UseRhfUtilsFormChildrenProps<TFieldValues, TTransformedValues>>;
+    /** {@link RhfUseFormProps} props for RHF's {@link useForm}. */
+    rhf?: Omit<UseFormProps<TFieldValues>, 'defaultValues'>;
+    /** {@link RhfUtilsFormOptions} to enabled utils functionality. */
+    utils?: RhfUtilsFormOptions;
+    /** {@link FormProps} props for Form. */
+    form?: Omit<React.PropsWithoutRef<JSX.IntrinsicElements['form']>, 'onSubmit'>;
+};

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

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+import { UseFormReturn } from 'react-hook-form';
+import { FormSubmitError } from '../submit/error/FormSubmitError';
+import { FormProps } from './Form';
+import { RhfUtilsFormProvidersProps } from './RhfUtilsFormProviders';
+import { SafeFieldValues } from './SafeFieldValues';
+
+/**
+ * Return type for `useRhfUtilsForm`.
+ *
+ * Consider keeping shape in line with `UseRhfUtilsFormChildrenProps` and `UseRhfUtilsFormOnSubmitProps`.
+ */
+export type UseRhfUtilsFormReturn<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = {
+    id: string;
+    ref: React.RefObject<HTMLFormElement>;
+    context: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+    providerProps: RhfUtilsFormProvidersProps<TFieldValues, TTransformedValues>;
+    formProps: FormProps<TFieldValues, TTransformedValues>;
+    FormSubmitError: typeof FormSubmitError<TFieldValues>;
+};

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

@@ -0,0 +1,6 @@
+import { ControllerProps, FieldPath } from 'react-hook-form';
+import { SafeFieldValues } from './SafeFieldValues';
+
+export type _ControllerProps<TFieldValues extends SafeFieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<ControllerProps<TFieldValues, TName>, 'control'>;
+declare function _Controller<TFieldValues extends SafeFieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: _ControllerProps<TFieldValues, TName>): import("react/jsx-runtime").JSX.Element;
+export default _Controller;

package/dist/types/form/context/group/FormGroupContextProvider.d.ts

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

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

@@ -0,0 +1,14 @@
+export type FormGroupContext = {
+    /** Dependent forms. */
+    children: {
+        busyIds: string[];
+        busyCount: number;
+        setBusyId: (id: string, isBusy: boolean) => void;
+    };
+    /** Main form. */
+    parent: {
+        isBusy: boolean;
+        setIsBusy: (isBusy: boolean) => void;
+    };
+};
+export declare const _FormGroupContextProvider: import('react').Provider<FormGroupContext | undefined>, _useFormGroupContext: () => FormGroupContext, _useFormGroupContextMaybe: () => FormGroupContext | undefined;

package/dist/types/form/context/group/useFormGroupChildIsMountedTracker.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Mark "child" form as "busy" when mounted.
+ */
+declare const useFormGroupChildIsMountedTracker: () => boolean;
+export default useFormGroupChildIsMountedTracker;

package/dist/types/form/context/group/useFormGroupChildIsSubmittingTracker.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Mark "child" form as "busy" when submitting.
+ */
+declare const useFormGroupChildIsSubmittingTracker: () => boolean;
+export default useFormGroupChildIsSubmittingTracker;

package/dist/types/form/context/group/useFormGroupChildTracker.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Mark "child" form as "busy" via arbitrary boolean.
+ * Automatically marks as "not busy" on dismount.
+ */
+declare const useFormGroupChildTracker: (track: boolean) => void;
+export default useFormGroupChildTracker;

package/dist/types/form/context/group/useFormGroupIsAnyBusy.d.ts

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

package/dist/types/form/context/group/useFormGroupIsChildBusy.d.ts

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

package/dist/types/form/context/group/useFormGroupIsParentBusy.d.ts

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

package/dist/types/form/context/group/useFormGroupParentTracker.d.ts

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

package/dist/types/form/context/group/useFormOrParentIsBusy.d.ts

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

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

@@ -0,0 +1,9 @@
+import { RhfUtilsFormOptions } from '../../RhfUtilsFormOptions';
+
+type Props = React.PropsWithChildren<{
+    formId: string;
+    formRef: React.RefObject<HTMLFormElement>;
+    options?: RhfUtilsFormOptions;
+}>;
+declare const RhfUtilsContextProvider: React.FC<Props>;
+export default RhfUtilsContextProvider;

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

@@ -0,0 +1,14 @@
+import { RhfUtilsFormOptions } from '../../RhfUtilsFormOptions';
+
+export type RhfUtilsContext = {
+    formId: string;
+    formRef: React.RefObject<HTMLFormElement>;
+    options: RhfUtilsFormOptions | undefined;
+};
+declare const _RhfUtilsContextProvider: import('react').Provider<RhfUtilsContext | undefined>;
+/**
+ * Use utils from the current form context.
+ */
+declare const useRhfUtilsContext: () => RhfUtilsContext;
+export default useRhfUtilsContext;
+export { _RhfUtilsContextProvider };

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

@@ -0,0 +1,5 @@
+/**
+ * Get `requestSubmit` function from the form ref'd in current context.
+ */
+declare const useRhfUtilsContextRequestSubmit: () => (submitter?: HTMLElement | null) => void;
+export default useRhfUtilsContextRequestSubmit;

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

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

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

@@ -0,0 +1,16 @@
+import { SafeFieldValues } from './SafeFieldValues';
+import { UseRhfUtilsFormProps } from './UseRhfUtilsFormProps';
+import { UseRhfUtilsFormReturn } from './UseRhfUtilsFormReturn';
+
+/**
+ * Core 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.
+ */
+declare const useRhfUtilsForm: <TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues>({ defaultValues, onSubmit, onSubmitError, onSubmitInvalid, Children, rhf, form, utils, }: UseRhfUtilsFormProps<TFieldValues, TTransformedValues>) => UseRhfUtilsFormReturn<TFieldValues, TTransformedValues>;
+export default useRhfUtilsForm;
+export type UseRhfUtilsForm<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = typeof useRhfUtilsForm<TFieldValues, TTransformedValues>;

package/dist/types/form/utils/getSubmitterButtonData.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+
+/**
+ * Get [name, value] tuple of button/input that submitted form.
+ * Useful when determining user intent
+ */
+declare const getSubmitterButtonData: (event: React.BaseSyntheticEvent) => [name: string, value: string] | undefined;
+export default getSubmitterButtonData;

package/dist/types/form/utils/useFormRequestSubmit.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+
+/**
+ * Get callback to trigger submit manually on form.
+ *
+ * Note: `submitter` is optional, but is required to be a submit button.
+ *
+ * @link https://developer.mozilla.org/docs/Web/API/HTMLFormElement/requestSubmit
+ */
+declare const useFormRequestSubmit: (ref: React.RefObject<HTMLFormElement>) => HTMLFormElement["requestSubmit"];
+export default useFormRequestSubmit;

package/dist/types/form/utils/useShouldFormBlockNavigation.d.ts

@@ -0,0 +1,26 @@
+import { FieldValues, FormState } from 'react-hook-form';
+
+export type UseShouldFormBlockNavigationOptions = {
+    disabled?: boolean;
+    /**
+     * Block navigation while submitting.
+     * (In other words, will always block when `isDirty`.)
+     *
+     * NOTE: Be sure to use with `UseResetFormOnSubmittedOptions` configuration
+     * to mark form state as not `isDirty` after successful submit.
+     *
+     * This options is recommended because it prohibits possible
+     * user-triggered navigation during prolonged request.
+     */
+    blockWhenSubmitting?: boolean;
+};
+/**
+ * Returns `boolean` value when the form should block navigation.
+ *
+ * By default, return `true` when the form is submitting or is not dirty.
+ *
+ * Evaluates to `true` when `enabled` and `isDirty` except when `isSubmitting` and `isValid`,
+ * because we don't want to block navigation when the form is submitting and valid.
+ */
+declare const useShouldFormBlockNavigation: ({ isDirty, isSubmitting }: FormState<FieldValues>, options?: UseShouldFormBlockNavigationOptions) => boolean;
+export default useShouldFormBlockNavigation;

package/dist/types/main.d.ts

@@ -1,15 +1 @@
-export type { Register } from '../register';
-export type { RhfUtilsClientConfig } from '../client/config/RhfUtilsClientConfig';
-export { default as RhfUtilsClientForZodContextProvider } from '../client/zod/context/RhfUtilsClientForZodContextProvider';
-export { default as RhfUtilsZodForm } from '../client/zod/context/RhfUtilsZodForm';
-export { default as useRhfUtilsZodForm } from '../client/zod/context/useRhfUtilsZodForm';
-export type { RhfUtilsUseFormChildrenZodFC } from '../client/zod/RhfUtilsUseFormChildrenZodFC';
-export type { RhfUtilsUseFormChildrenZodProps } from '../client/zod/RhfUtilsUseFormChildrenZodProps';
-export { default as useFlatFieldErrorsContext } from '../errors/flat/context/useFlatFieldErrorsContext';
-export { default as useFlatFieldErrorsContextHasOnlyOrphans } from '../errors/flat/context/useFlatFieldErrorsContextHasOnlyOrphans';
-export { default as RhfUtilsNonFieldErrorMarker } from '../errors/nonfield/RhfUtilsNonFieldErrorMarker';
-export type { RhfUtilsFormOptions } from '../form/RhfUtilsFormOptions';
-export type { SafeFieldValues } from '../form/SafeFieldValues';
-export type { UseRhfUtilsFormChildrenProps } from '../form/UseRhfUtilsFormChildrenProps';
-export { default as useRhfUtilsContext } from '../form/context/utils/useRhfUtilsContext';
-export { FormSubmitError } from '../submit/error/FormSubmitError';
+export {};

package/dist/types/register.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Use this to extend internal types.
+ *
+ * For example, `RhfUtilsFormOptions`.
+ */
+export interface Register {
+}

package/dist/types/submit/error/FormSubmitError.d.ts

@@ -0,0 +1,7 @@
+import { SafeFieldValues } from '../../form/SafeFieldValues';
+import { FormSubmitFieldErrors } from './FormSubmitFieldErrors';
+
+export declare class FormSubmitError<TFieldValues extends SafeFieldValues = SafeFieldValues> extends Error {
+    errors: FormSubmitFieldErrors<TFieldValues>;
+    constructor(errors: FormSubmitFieldErrors<TFieldValues>, message?: string);
+}

package/dist/types/submit/error/FormSubmitFieldErrors.d.ts

@@ -0,0 +1,15 @@
+import { FieldPath } from 'react-hook-form';
+import { SafeFieldValues } from '../../form/SafeFieldValues';
+
+/**
+ * Field errors structure based on RHF's `FieldErrors`.
+ *
+ * - Uses {@link SafeFieldValues} instead of more permissive `FieldValues`.
+ * - `root.<string>` keys allowed.
+ *   - `root` is reserved for special use cases.
+ * - simplified `ErrorOption` value.
+ */
+export type FormSubmitFieldErrors<TFieldValues extends SafeFieldValues = SafeFieldValues> = Record<FieldPath<TFieldValues> | `root.${string}`, {
+    type?: string;
+    message: string;
+}>;

package/dist/types/submit/error/setCtxErrorsByFormSubmitFieldErrors.d.ts

@@ -0,0 +1,10 @@
+import { UseFormReturn } from 'react-hook-form';
+import { SafeFieldValues } from '../../form/SafeFieldValues';
+import { FormSubmitFieldErrors } from './FormSubmitFieldErrors';
+
+/**
+ * Handle thrown {@link FormSubmitError}.
+ * Add key/values as name/message to RHF context errors.
+ */
+declare const setCtxErrorsByFormSubmitFieldErrors: <TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues>(ctx: UseFormReturn<TFieldValues, unknown, TTransformedValues>, errors: FormSubmitFieldErrors) => void;
+export default setCtxErrorsByFormSubmitFieldErrors;

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

@@ -0,0 +1,15 @@
+import { MaybePromise } from '../utils/types';
+
+/**
+ * Calls a callback after a successful submit and after a form reset.
+ *
+ * Use this when your forms use a isDirty prompter for user action that would lose unsaved data.
+ * You must reset form before you can navigate away from page.
+ *
+ * Using RHF and following its rules, we are not able to get the state `isSubmitSuccessful=true` and `isDirty=false`.
+ * So, this has to keep track of previous state.
+ *
+ * SubmitSuccessfulAndReset = was `isSubmitSuccessful` and now `!isDirty`
+ */
+declare const useFormOnSubmitSuccessfulAndReset: (callback?: (...data: unknown[]) => MaybePromise<unknown>) => void;
+export default useFormOnSubmitSuccessfulAndReset;

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

@@ -0,0 +1,6 @@
+import { MaybePromise } from '../utils/types';
+
+declare const useFormOnSubmitted: (callback?: (success: boolean) => MaybePromise<unknown>, options?: {
+    successful?: boolean;
+}) => void;
+export default useFormOnSubmitted;

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

@@ -0,0 +1,36 @@
+/**
+ * Configuration options for {@link useResetFormOnSubmitted}.
+ */
+export type UseResetFormOnSubmittedOptions = undefined | {
+    /**
+     * Reset values on successful submit.
+     * - `defaults`: reset current values to defaults
+     * - `current`: reset defaults to current values
+     */
+    success?: {
+        values: 'defaults' | 'current';
+    };
+    /**
+     * Reset values to defaults on submit error.
+     */
+    error?: {
+        values: 'defaults';
+    };
+};
+/**
+ * Control resetting of values and (some) state (e.g., `isDirty`) after form submitted.
+ *
+ * `isDirty` and other state is reset, but submit-related state is preserved, as well as errors.
+ *
+ * Use cases:
+ * - on success:
+ *   - `defaults`: reset current values to defaults (e.g., clear form)
+ *   - `current`: reset defaults to current values (e.g., keep values)
+ * - on error:
+ *   - reset current values to default values (e.g., submitOnChange reset)
+ *
+ * See `Rules` section: https://react-hook-form.com/api/useform/reset/
+ * Specifically: "- It's recommended to reset inside useEffect after submission."
+ */
+declare const useResetFormOnSubmitted: (options: UseResetFormOnSubmittedOptions) => void;
+export default useResetFormOnSubmitted;

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

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+
+declare const useSubmitFormOnChange: (formRef: React.RefObject<HTMLFormElement>, options?: {
+    /** Disable behavior. (Default behavior is enabled for sake of simplicity of general usage.) */
+    disabled?: boolean;
+    /** Milliseconds to debounce form submission. (Default is none.) */
+    debounce?: number;
+}) => void;
+export default useSubmitFormOnChange;

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

@@ -0,0 +1,7 @@
+/**
+ * Component for simply passing through children.
+ *
+ * (Useful for conditional wrapping of children.)
+ */
+declare const PassthroughChildren: React.FC<React.PropsWithChildren>;
+export default PassthroughChildren;

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

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+
+/**
+ * Create a strictly-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 Provider: React.Provider<T | undefined>;
+    readonly useMaybe: () => T | undefined;
+    readonly useRequired: () => T & ({} | null);
+};
+export default createContext;

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/isEmptyObject.d.ts

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

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

@@ -0,0 +1,6 @@
+/**
+ * Awaitable `setTimeout`.
+ * @param timeout milliseconds
+ * @returns `Promise<void>`
+ */
+export declare const timeoutAsync: (timeout: number) => Promise<void>;

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

@@ -0,0 +1 @@
+export type MaybePromise<T> = T | Promise<T>;

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

@@ -0,0 +1,14 @@
+/**
+ * React hook to debounce onChange event callback.
+ *
+ * Returns debounced state setter (uses ref internally).
+ *
+ * When debounce delay has elapsed after setting value,
+ * onChange callback is called with latest value.
+ *
+ * @returns `[setValueDebounced]`
+ */
+export declare const useDebouncedOnChangeValue: <TValue>({ onChange, delay, }: {
+    onChange: (value: TValue) => void;
+    delay: number;
+}) => readonly [(value: TValue) => void];

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>) => React.RefObject<TRef>;
+export default useImperativeForwardedRef;

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

@@ -0,0 +1,2 @@
+declare const useRefIfValueWasTrue: (value: boolean) => readonly [boolean, () => void];
+export default useRefIfValueWasTrue;

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

@@ -0,0 +1,5 @@
+/**
+ * React cannot handle async errors in event handlers or useEffects.
+ */
+declare const useThrowAsyncError: () => (error: unknown) => void;
+export default useThrowAsyncError;

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

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+
+declare const useToggle: (defaultValue?: boolean) => [boolean, React.DispatchWithoutAction];
+export default useToggle;