@paragrav/rhf-utils 0.0.50 → 0.0.51

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * Output form errors to console.debug() for easier debugging for certain condition.
+ * (e.g., in dev/staging environments or certain users)
+ *
+ * `console.debug()` is unlikely to trigger any automated console capture reporting.
+ */
+declare const useFormErrorConsoleDebug: (enabled?: boolean) => void;
+export default useFormErrorConsoleDebug;

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

@@ -0,0 +1,4 @@
+import { FieldErrors } from 'react-hook-form';
+
+declare const useFormErrorsEffect: <TReturn>(callback: (errors: FieldErrors) => TReturn) => void;
+export default useFormErrorsEffect;

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

@@ -0,0 +1,6 @@
+/**
+ * Returns errors only if there are errors.
+ * Allows simple typeguard without `isEmpty` dependency.
+ */
+declare const useFormErrorsIfAny: () => false | import('react-hook-form').FieldErrors<import('react-hook-form').FieldValues>;
+export default useFormErrorsIfAny;

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Get callback to trigger submit manually on form.
+ * @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/src/exports.d.ts

@@ -0,0 +1,37 @@
+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/FormNonFieldErrorMarkerHtmlAttribute';
+export { default as useFormHasOrphanAndNoFieldErrors } from './errors/orphan/useFormHasOrphanAndNoFieldErrors';
+export { default as useOrphanFormErrorsMemo } from './errors/orphan/useOrphanFormErrorsMemo';
+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 Form } from './form/Form';
+export { default as FormWithProviders } from './form/FormWithProviders';
+export { default as useForm } from './form/useForm';
+export { default as useFormWithProviders } from './form/useFormWithProviders';
+export { default as FormProvider } from './form/context/FormProvider';
+export { default as FormUtilsContextProvider } from './form/context/utils/FormUtilsContextProvider';
+export { default as useFormUtilsContext } from './form/context/utils/useFormUtilsContext';
+export { default as FormGroupContextProvider } from './form/context/group/FormGroupContextProvider';
+export { default as useFormGroupChildIsMountedTracker } from './form/context/group/useFormGroupChildIsMountedTracker';
+export { default as useFormGroupChildIsSubmittingTracker } from './form/context/group/useFormGroupChildIsSubmittingTracker';
+export { default as useFormGroupIsAnyBusy } from './form/context/group/useFormGroupIsAnyBusy';
+export { default as useFormGroupIsChildBusy } from './form/context/group/useFormGroupIsChildBusy';
+export { default as useFormGroupIsParentBusy } from './form/context/group/useFormGroupIsParentBusy';
+export { default as useFormGroupParentTracker } from './form/context/group/useFormGroupParentTracker';
+export { default as getSubmitterButtonData } from './form/utils/getSubmitterButtonData';
+export { FormSubmitError } from './submit/error/FormSubmitError';
+export { default as useFormOnSubmitSuccessful } from './submit/useFormOnSubmitSuccessful';
+export { default as useFormOnSubmitSuccessfulAndReset } from './submit/useFormOnSubmitSuccessfulAndReset';
+export { default as useResetFormOnSubmitError } from './submit/useResetFormOnSubmitError';
+export { default as useResetFormAfterSubmitSuccessful } from './submit/useResetFormOnSubmitSuccessful';
+export { default as useSubmitFormOnChange } from './submit/useSubmitFormOnChange';

package/dist/types/src/form/ErrorBoundary.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+
+type Props = React.PropsWithChildren;
+type State = {
+    error: null | Error;
+};
+export declare class ErrorBoundary extends React.Component<Props, State> {
+    state: State;
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    componentDidCatch(error: unknown, errorInfo: React.ErrorInfo): void;
+    render(): string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { FormBaseProps } from './FormBase';
+import { FieldValues, SubmitErrorHandler, UseFormReturn } from 'react-hook-form';
+import { default as React } from 'react';
+import { DevtoolUIProps } from '@hookform/devtools/dist/devToolUI';
+
+export type FormProps<TFieldValues extends FieldValues, TTransformedValues extends FieldValues> = React.PropsWithChildren<Pick<FormBaseProps, 'onChange'> & {
+    formId?: string;
+    formRef?: React.RefObject<HTMLFormElement>;
+    Fields?: React.FC<{
+        ctx: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+    }>;
+    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, context: UseFormReturn<TFieldValues, unknown, TTransformedValues>, event: React.BaseSyntheticEvent<SubmitEvent>) => void;
+    /** Submit handler when form is invalid. */
+    onSubmitInvalid?: SubmitErrorHandler<TFieldValues>;
+    options?: {
+        hideRootErrors?: boolean;
+        /** Request submit via listener on form change. */
+        submitOnChange?: boolean;
+        /** Reset form values if submit throw errors. Use case: optimistic UI toggle form that submits on each change */
+        resetValuesOnSubmitError?: boolean;
+        stopSubmitPropagation?: boolean;
+        devTool?: DevtoolUIProps | 'disabled';
+    };
+    className?: string;
+}>;
+declare function Form<TFieldValues extends FieldValues, TTransformedValues extends FieldValues>({ formId, formRef, Fields, onSubmit, onSubmitError, onSubmitInvalid, options, children, ...props }: FormProps<TFieldValues, TTransformedValues>): import("react/jsx-runtime").JSX.Element;
+export default Form;

package/dist/types/src/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/src/form/FormWithProviders.d.ts

@@ -0,0 +1,13 @@
+import { UseFormProps } from './useForm';
+import { FieldValues } from 'react-hook-form';
+
+export type FormWithProviders<TFieldValues extends FieldValues, TTransformedValues extends FieldValues> = React.PropsWithChildren<UseFormProps<TFieldValues, TTransformedValues>>;
+/**
+ * {@link FormProvider} (and utils) with immediate descendent {@link Form}.
+ * (Syntactic sugar for {@link useForm}. Use this for most applications.)
+ *
+ * Use {@link useForm} 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 FieldValues, TTransformedValues extends FieldValues>({ children, ...props }: FormWithProviders<TFieldValues, TTransformedValues>): import("react/jsx-runtime").JSX.Element;
+export default FormWithProviders;

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

@@ -0,0 +1,15 @@
+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<{
+    formId: string;
+    formRef: React.RefObject<HTMLFormElement>;
+    rhf: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+} & {
+    form?: Omit<FormProps<TFieldValues, TTransformedValues>, 'formRef' | 'formId'>;
+    utils?: FormUtilsContextProviderProps;
+}>;
+declare function FormProvider<TFieldValues extends FieldValues, TTransformedValues extends FieldValues>({ formId, formRef, rhf, form, utils, children, }: Props<TFieldValues, TTransformedValues>): import("react/jsx-runtime").JSX.Element;
+export default FormProvider;

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

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+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 _useFormGroupContextMaybe: () => FormGroupContext | undefined, _useFormGroupContext: () => FormGroupContext, _FormGroupContextProvider: import('react').Provider<FormGroupContext | undefined>;

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+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<{
+    formId: string;
+    formRef: React.RefObject<HTMLFormElement>;
+    formProps?: Omit<FormProps<TFieldValues, TTransformedValues>, 'formRef' | 'formId'>;
+} & FormUtilsContextProviderProps>;
+declare function FormUtilsContextProvider<TFieldValues extends FieldValues, TTransformedValues extends FieldValues>({ formRef, onSubmitSuccessfulAndReset, children, }: Props<TFieldValues, TTransformedValues>): import("react/jsx-runtime").JSX.Element;
+export default FormUtilsContextProvider;

package/dist/types/src/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/src/form/search/FormSearch.d.ts

@@ -0,0 +1,32 @@
+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<FormBaseProps, "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/src/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/src/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/src/form/useForm.d.ts

@@ -0,0 +1,29 @@
+import { FormProps } from './Form';
+import { FieldValues, UseFormProps as RhfUseFormProps } from 'react-hook-form';
+import { default as React } from 'react';
+
+export type UseFormProps<TFieldValues extends FieldValues, TTransformedValues extends FieldValues> = {
+    /** {@link RhfUseFormProps} props for RHF's {@link useRhfForm}. */
+    rhf?: RhfUseFormProps<TFieldValues>;
+    /** {@link FormProps} props for Form. */
+    form?: Omit<FormProps<TFieldValues, TTransformedValues>, 'formId' | 'formRef'>;
+};
+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.
+ */
+declare const useForm: <TFieldValues extends FieldValues, TTransformedValues extends FieldValues>({ rhf, form, }: UseFormProps<TFieldValues, TTransformedValues>) => {
+    readonly id: string;
+    readonly ref: React.RefObject<HTMLFormElement>;
+    readonly context: import('react-hook-form').UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+    readonly Form: React.FC<{
+        children?: React.ReactNode;
+    }>;
+};
+export default useForm;

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

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

package/dist/types/src/form/useFormOrParentIsBusy.d.ts

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

package/dist/types/src/form/useFormWithProviders.d.ts

@@ -0,0 +1,31 @@
+import { UseFormProps } from './useForm';
+import { FormUtilsContextProviderProps } from './context/utils/FormUtilsContextProvider';
+import { FieldValues } from 'react-hook-form';
+import { default as React } from 'react';
+
+export type UseFormWithProvidersProps<TFieldValues extends FieldValues, TTransformedValues extends FieldValues> = UseFormProps<TFieldValues, TTransformedValues> & {
+    /** {@link FormUtilsContextProviderProps} props for `FormUtilsContextProvider`. */
+    utils?: FormUtilsContextProviderProps;
+};
+export type UseFormWithProvidersReturn = ReturnType<typeof useFormWithProviders>;
+/**
+ * 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.
+ */
+declare const useFormWithProviders: <TFieldValues extends FieldValues, TTransformedValues extends FieldValues>({ rhf, form, utils, }: UseFormWithProvidersProps<TFieldValues, TTransformedValues>) => {
+    readonly Provider: React.FC<{
+        children?: React.ReactNode;
+    }>;
+    readonly id: string;
+    readonly ref: React.RefObject<HTMLFormElement>;
+    readonly context: import('react-hook-form').UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+    readonly Form: React.FC<{
+        children?: React.ReactNode;
+    }>;
+};
+export default useFormWithProviders;

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

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+
+/**
+ * Get [name, value] 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/src/isEmptyObject.d.ts

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

package/dist/types/src/main.d.ts

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

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

@@ -0,0 +1,6 @@
+import { FieldPath, FieldValues } from 'react-hook-form';
+
+export declare class FormSubmitError<TFieldValues extends FieldValues = 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/src/submit/error/handleFormSubmitError.d.ts

@@ -0,0 +1,7 @@
+import { FieldValues, UseFormReturn } from 'react-hook-form';
+
+/**
+ * Handle form submit error if {@link FormSubmitError}. Add items to RHF form errors.
+ */
+declare const handleFormSubmitError: <TFieldValues extends FieldValues, TTransformedValues extends FieldValues>(error: unknown, ctx: UseFormReturn<TFieldValues, unknown, TTransformedValues>) => void;
+export default handleFormSubmitError;

package/dist/types/src/submit/useFormOnSubmitSuccessful.d.ts

@@ -0,0 +1,2 @@
+declare const useFormOnSubmitSuccessful: (callback?: () => void) => void;
+export default useFormOnSubmitSuccessful;

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

@@ -0,0 +1,13 @@
+/**
+ * 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 `!isSubmitSuccessful && !isDirty`
+ */
+declare const useFormOnSubmitSuccessfulAndReset: (callback?: () => void) => void;
+export default useFormOnSubmitSuccessfulAndReset;

package/dist/types/src/submit/useResetFormOnSubmitError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Handle resetting after successful submit with no server validation errors.
+ * See `Rules` section: https://react-hook-form.com/api/useform/reset/
+ * Specifically: "- It's recommended to reset inside useEffect after submission."
+ */
+declare const useResetFormOnSubmitError: (disabled?: boolean) => void;
+export default useResetFormOnSubmitError;

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

@@ -0,0 +1,12 @@
+import { KeepStateOptions } from 'react-hook-form';
+
+type Options = {
+    enabled?: boolean;
+} & KeepStateOptions;
+/**
+ * Handle resetting after successful submit with no server validation errors.
+ * See `Rules` section: https://react-hook-form.com/api/useform/reset/
+ * Specifically: "- It's recommended to reset inside useEffect after submission."
+ */
+declare const useResetFormAfterSubmitSuccessful: ({ enabled, ...options }: Options) => void;
+export default useResetFormAfterSubmitSuccessful;

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

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+
+declare const useSubmitFormOnChange: (formRef: React.RefObject<HTMLFormElement>, disabled?: boolean) => void;
+export default useSubmitFormOnChange;

package/dist/types/src/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/dist/types/src/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/src/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/src/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/src/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;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@paragrav/rhf-utils",
   "author": "paragrav.dev",
   "license": "MIT",
-  "version": "0.0.50",
+  "version": "0.0.51",
   "description": "Integration utilities for react-hook-form.",
   "type": "module",
   "sideEffects": false,
@@ -10,6 +10,12 @@
     "dist"
   ],
   "module": "./dist/esm/exports.mjs",
+  "imports": {
+    "#is-development": {
+      "development": "./src/env-conditions/development.ts",
+      "default": "./src/env-conditions/production.ts"
+    }
+  },
   "exports": {
     ".": {
       "default": "./dist/esm/exports.mjs",
@@ -159,12 +165,12 @@
   "scripts": {
     "build": "npm install && npm run validate && vite build",
     "build:dev": "vite build --config vite.config.dev.ts",
-    "dev": "vite",
+    "dev": "vite --config vite.config.dev.ts",
     "lint": "eslint --ignore-path ./.gitignore --ext ts,tsx --report-unused-disable-directives --max-warnings 0 .",
     "preinstall": "npx only-allow npm",
     "prepare": "husky",
     "prepublishOnly": "npm run build",
-    "preview": "vite preview",
+    "preview": "vite preview --config vite.config.dev.ts",
     "test": "vitest",
     "test:ct": "playwright test -c playwright-ct.config.ts",
     "test:ct:ui": "playwright test -c playwright-ct.config.ts --ui",