@paragrav/rhf-utils 0.0.147 → 0.59.0

package/dist/dts/client/config/RhfUtilsClientConfigType.d.ts

@@ -0,0 +1,63 @@
+import { FlatFieldErrorsOutputConfig } from '../../errors/flat/context/FlatFieldErrorsOutputConfig';
+import { UseRhfUtilsFormGlobalDefaults } from '../../form/defaults/UseRhfUtilsFormGlobalDefaults';
+import { RhfUtilsFormComponentProps } from '../../form/RhfUtilsFormComponentPropsType';
+import { FormSubmitFieldErrors } from '../../submit/error/FormSubmitFieldErrors';
+import { UseRhfUtilsFormOnSubmitContext } from '../../submit/UseRhfUtilsFormOnSubmitContextType';
+import { MaybePromise } from '../../utils/types';
+/**
+ * Client configuration object.
+ *
+ * Options under `defaults` can be overridden at form level.
+ */
+export type RhfUtilsClientConfig = {
+    /**
+     * Default options for all forms. (Are overridden by form-specific options.)
+     */
+    defaults?: UseRhfUtilsFormGlobalDefaults;
+    /**
+     * Supply your own `<form>` component. (By default, a native {@link HTMLFormElement} is used.)
+     *
+     * @description
+     *
+     * Can be used to inject your own hooks, components, etc.
+     *
+     * (NOTE: context params are not schema-typed as not possible at this level.)
+     */
+    FormComponent?: React.FC<React.PropsWithChildren<RhfUtilsFormComponentProps>>;
+    /**
+     * A hook that returns a callback that determines whether form can be cancelled at event-time.
+     *
+     * @description
+     *
+     * Cancellation of forms often doesn't involve navigation, making it more challenging to centrally handle.
+     * Your hook's returned callback should internally prompt user and return response as `boolean`
+     * indicating whether cancellation should be blocked. See `README.md` for example.
+     *
+     * @returns Callback that, given {@link RhfUtilsFormContext} at event-time, returns `boolean` value indicating whether form can be cancelled.
+     *
+     * Callback should return:
+     * `true`: if form can be cancelled (e.g., form not dirty or user confirmed via prompt); {@link UseRhfUtilsFormProps.onCancel} is called.
+     * `false`: form cannot be cancelled (e.g., user denied); {@link UseRhfUtilsFormProps.onCancel} is not called.
+     */
+    useCanFormBeCancelled?: () => (props: UseRhfUtilsFormOnSubmitContext) => MaybePromise<boolean>;
+    /**
+     * Global submit error handler when/if submit handler throws an error other than {@link FormSubmitError}.
+     *
+     * Example use case:
+     * - transform API errors to {@link FormSubmitFieldErrors}.
+     *
+     * @returns
+     * - if {@link FormSubmitFieldErrors}: merge into context errors.
+     * - if `undefined`: do nothing.
+     */
+    onSubmitErrorUnknown?: (error: unknown) => FormSubmitFieldErrors | undefined;
+    /**
+     * Configuration regarding RHF form state errors (`useFormContext().formState.errors`).
+     */
+    fieldErrors?: {
+        /**
+         * Configure how/if errors should be outputted for debugging/reporting (i.e., console and/or throwing).
+         */
+        output?: FlatFieldErrorsOutputConfig;
+    };
+};

package/dist/dts/client/config/context/RhfUtilsClientConfigContext.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+import { RhfUtilsClientConfig } from '../RhfUtilsClientConfigType';
+export declare const RhfUtilsClientConfigContext_Internal: React.Context<RhfUtilsClientConfig | undefined>;

package/dist/dts/client/config/context/RhfUtilsClientConfigProvider.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { RhfUtilsClientConfig } from '../RhfUtilsClientConfigType';
+type Props = React.PropsWithChildren<{
+    config?: RhfUtilsClientConfig;
+}>;
+export declare const RhfUtilsClientConfigProvider: React.FC<Props>;
+export {};

package/dist/dts/client/config/context/useRhfUtilsClientConfig.d.ts

@@ -0,0 +1 @@
+export declare const useRhfUtilsClientConfig: () => import('../RhfUtilsClientConfigType').RhfUtilsClientConfig;

package/dist/{types → dts}/devtool/LazyDevTool.d.ts

@@ -1,11 +1,10 @@
 import { DevtoolUIProps } from '@hookform/devtools/dist/devToolUI';
 import { default as React } from 'react';
 type LazyDevToolProps = {
-    enabled?: boolean;
-    props?: Omit<DevtoolUIProps, 'control'>;
+    config?: boolean | Pick<DevtoolUIProps, 'placement' | 'styles'>;
 };
 /**
  * Lazy-loaded RHF DevTool.
  */
-declare const LazyDevTool: React.FC<LazyDevToolProps>;
-export default LazyDevTool;
+export declare const LazyDevTool: React.FC<LazyDevToolProps>;
+export {};

package/dist/dts/devtool/LazyDevToolViaProviders.d.ts

@@ -0,0 +1 @@
+export declare const LazyDevToolViaProviders: React.FC;

package/dist/{types → dts}/errors/flat/FlatFieldErrorsList.d.ts

@@ -1,6 +1,6 @@
 import { FlatFieldErrors } from './types';
 export type Props = {
     errors: FlatFieldErrors | null | undefined;
+    className?: string;
 };
-declare const FlatFieldErrorsList: React.FC<Props>;
-export default FlatFieldErrorsList;
+export declare const FlatFieldErrorsList: React.FC<Props>;

package/dist/{types → dts}/errors/flat/context/FlatFieldErrorsContextProvider.d.ts

@@ -1,10 +1,10 @@
 import { default as React } from 'react';
 type Props = React.PropsWithChildren<{
-    formRef: React.RefObject<HTMLFormElement>;
+    formRef: React.RefObject<HTMLFormElement | null>;
 }>;
 /**
  * Provides a flattened version of the form errors.
  * Allows flattening and filtering to happen once per errors change.
  */
-declare const FlatFieldErrorsContextProvider: React.FC<Props>;
-export default FlatFieldErrorsContextProvider;
+export declare const FlatFieldErrorsContextProvider: React.FC<Props>;
+export {};

package/dist/{types → dts}/errors/flat/context/useFlatFieldErrorsContext.d.ts

@@ -8,5 +8,4 @@ export type FlatFieldErrorsContext = {
     hasOrphans: boolean;
 };
 declare const _FormErrorsFlatContextProvider: import('react').Provider<FlatFieldErrorsContext | undefined>, useFlatFieldErrorsContext: () => FlatFieldErrorsContext;
-export default useFlatFieldErrorsContext;
-export { _FormErrorsFlatContextProvider };
+export { _FormErrorsFlatContextProvider, useFlatFieldErrorsContext };

package/dist/dts/errors/flat/context/useFlatFieldErrorsContextHasOnlyOrphans.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns `true` if all errors are orphans.
+ *
+ * You may want to treat this case specifically.
+ */
+export declare const useFlatFieldErrorsContextHasOnlyOrphans: () => boolean;

package/dist/{types → dts}/errors/flat/context/useFlatFieldErrorsContextOutput.d.ts

@@ -2,5 +2,4 @@ import { FlatFieldErrorsOutputConfig } from './FlatFieldErrorsOutputConfig';
 /**
  * Outputs (e.g., console, throw) errors based on config.
  */
-declare const useFlatFieldErrorsContextOutput: (config?: FlatFieldErrorsOutputConfig) => void;
-export default useFlatFieldErrorsContextOutput;
+export declare const useFlatFieldErrorsContextOutput: (config?: FlatFieldErrorsOutputConfig) => void;

package/dist/dts/errors/flat/filterFlatFieldErrors.d.ts

@@ -0,0 +1,7 @@
+import { FlatFieldErrorEntry, FlatFieldErrors } from './types';
+/**
+ * Filter {@link FlatFieldErrors} by a predicate.
+ *
+ * (Encapsulates to and from Object entries.)
+ */
+export declare const makeFlatFieldErrorsFilter: (predicate: (entry: FlatFieldErrorEntry, index: number) => boolean) => (errors: FlatFieldErrors) => FlatFieldErrors;

package/dist/{types → dts}/errors/flat/flattenFieldErrors.d.ts

@@ -11,5 +11,4 @@ import { FieldErrors } from 'react-hook-form';
  * }
  * ```
  */
-declare const flattenFieldErrors: (errors: FieldErrors) => Record<string, unknown>;
-export default flattenFieldErrors;
+export declare const flattenFieldErrors: (errors: FieldErrors) => Record<string, unknown>;

package/dist/{types → dts}/errors/flat/getFlatFieldErrors.d.ts

@@ -1,4 +1,4 @@
-import { FieldErrors } from 'react-hook-form';
+import { FieldError, FieldErrors } from 'react-hook-form';
 import { FlatFieldErrors } from './types';
 /**
  * Get {@link FlatFieldErrors} from {@link FieldErrors}.
@@ -28,3 +28,4 @@ export declare const getFlatFieldErrors: (errors: FieldErrors) => FlatFieldError
  * iow: dot [?: non-capturing]("type" | "message")[\b word boundary][$ end of string]
  */
 export declare const regexMaybeFieldErrorLeafNodeSuffix: RegExp;
+export declare const getFlatFieldErrorsSansRef: (errors: FieldErrors) => Record<string, Omit<FieldError, "ref">>;

package/dist/dts/errors/getRefdFromFlatFieldErrors.d.ts

@@ -0,0 +1 @@
+export declare const getRefdFromFlatFieldErrors: (errors: import('./flat/types').FlatFieldErrors) => import('./flat/types').FlatFieldErrors;

package/dist/{types → dts}/errors/isFieldErrorRefd.d.ts

@@ -2,5 +2,4 @@ import { FieldError } from 'react-hook-form';
 /**
  * Determine if {@link FieldError} is a `ref`'d field error.
  */
-declare const isFieldErrorRefd: (error: FieldError) => boolean;
-export default isFieldErrorRefd;
+export declare const isFieldErrorRefd: (error: FieldError) => boolean;

package/dist/dts/errors/isFlatFieldErrorEntryRefd.d.ts

@@ -0,0 +1,5 @@
+import { FlatFieldErrorEntry } from './flat/types';
+/**
+ * Determine if {@link FieldError} is a `ref`'d field error.
+ */
+export declare const isFlatFieldErrorEntryRefd: ([, error,]: FlatFieldErrorEntry) => boolean;

package/dist/{types → dts}/errors/message/FormErrorMessage.d.ts

@@ -3,5 +3,5 @@ type Props = {
     message: string;
     className?: string;
 };
-declare const FormErrorMessage: React.FC<Props>;
-export default FormErrorMessage;
+export declare const FormErrorMessage: React.FC<Props>;
+export {};

package/dist/{types → dts}/errors/message/RhfUtilsFieldErrorMessage.d.ts

@@ -6,5 +6,5 @@ type Props = {
         message: string;
     }>;
 };
-declare const RhfUtilsFieldErrorMessage: React.FC<Props>;
-export default RhfUtilsFieldErrorMessage;
+export declare const RhfUtilsFieldErrorMessage: React.FC<Props>;
+export {};

package/dist/{types → dts}/errors/nonfield/RhfUtilsNonFieldErrorMarker.d.ts

@@ -9,5 +9,5 @@ type Props = {
  * Field array with minimum items.
  * (When there are no items, the error is not associated with a field and is displayed separately.)
  */
-declare const RhfUtilsNonFieldErrorMarker: React.FC<Props>;
-export default RhfUtilsNonFieldErrorMarker;
+export declare const RhfUtilsNonFieldErrorMarker: React.FC<Props>;
+export {};

package/dist/dts/errors/nonfield/RhfUtilsNonFieldErrorMarkerHtmlAttribute.d.ts

@@ -0,0 +1,4 @@
+/**
+ * HTML data attribute for {@link RhfUtilsNonFieldErrorMarker}.
+ */
+export declare const RhfUtilsNonFieldErrorMarkerHtmlAttribute = "data-rhfutils-nonfield-error-marker-path";

package/dist/{types → dts}/errors/nonfield/isNonFieldError.d.ts

@@ -14,5 +14,4 @@ import { FieldError } from 'react-hook-form';
  *      - The schema is incorrect.
  *      - The error is not displayed to user with `FormErrorNonFieldMarker`.
  */
-declare const isNonFieldError: (error: FieldError) => boolean;
-export default isNonFieldError;
+export declare const isNonFieldError: (error: FieldError) => boolean;

package/dist/dts/errors/nonfield/isNonFieldErrorMarkerInDOM.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Determine if a non-field error marker is in the DOM.
+ * Note: this will also look for nested markers to accommodate field arrays
+ */
+export declare const isNonFieldErrorMarkerInDOM: (path: string, parentElement: Pick<HTMLElement, "querySelector">) => boolean;

package/dist/dts/errors/orphan/getIsOrphanFormErrorWithParentElement.d.ts

@@ -0,0 +1,5 @@
+import { FlatFieldErrorEntry } from '../flat/types';
+/**
+ * Util wrapper for {@link isOrphanFormError} for usage with {@link FlatFieldErrorEntry}.
+ */
+export declare const getIsFlatFieldErrorEntryOrphanByParentElement: (parentElement: Pick<HTMLElement, "querySelector">) => ([path, error]: FlatFieldErrorEntry) => boolean;

package/dist/dts/errors/orphan/getOrphansFromFlatFieldErrors.d.ts

@@ -0,0 +1,2 @@
+import { FlatFieldErrors } from '../flat/types';
+export declare const getOrphansFromFlatFieldErrors: (errors: FlatFieldErrors, parentElement: Pick<HTMLElement, "querySelector">) => FlatFieldErrors;

package/dist/dts/errors/orphan/isOrphanFormError.d.ts

@@ -0,0 +1,2 @@
+import { FieldError } from 'react-hook-form';
+export declare const isOrphanFormError: (path: string, error: FieldError, parentElement: Pick<HTMLElement, "querySelector">) => boolean;

package/dist/dts/errors/output/consoleErrors.d.ts

@@ -0,0 +1,5 @@
+import { SafeFieldValues } from '../../form/rhf/SafeFieldValuesType';
+/**
+ * Output form values and errors to console.
+ */
+export declare const consoleErrors: (message: string, values: SafeFieldValues, errors: Record<string, unknown>, type?: "debug" | "error") => void;

package/dist/dts/errors/root/RootErrorsListFromFlatFieldErrorsContext.d.ts

@@ -0,0 +1 @@
+export declare const RootErrorsListFromFlatFieldErrorsContext: React.FC;

package/dist/dts/errors/root/getRootsFromFlatFieldErrors.d.ts

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

package/dist/{types → dts}/errors/root/isFlatFieldErrorEntryPathRoot.d.ts

@@ -2,5 +2,4 @@ import { FlatFieldErrorEntry } from '../flat/types';
 /**
  * Util wrapper for {@link isFormErrorPathRoot} for usage with {@link FlatFieldErrorEntry}.
  */
-declare const isFlatFieldErrorEntryPathRoot: ([path]: FlatFieldErrorEntry) => boolean;
-export default isFlatFieldErrorEntryPathRoot;
+export declare const isFlatFieldErrorEntryPathRoot: ([path]: FlatFieldErrorEntry) => boolean;

package/dist/{types → dts}/errors/root/isFormErrorPathRoot.d.ts

@@ -3,5 +3,4 @@
  *
  * @param path Flat path. (e.g., 'root.nested')
  */
-declare const isFormErrorPathRoot: (path: string) => boolean;
-export default isFormErrorPathRoot;
+export declare const isFormErrorPathRoot: (path: string) => boolean;

package/dist/{types → dts}/errors/trpc/makeOnSubmitTrpcClientErrorHandler.d.ts

@@ -1,4 +1,4 @@
-import { RhfUtilsClientConfig } from '../../client/config/RhfUtilsClientConfig';
+import { RhfUtilsClientConfig } from '../../client/config/RhfUtilsClientConfigType';
 import { FormSubmitFieldErrors } from '../../submit/error/FormSubmitFieldErrors';
 /**
  * HOF that returns submit error handler for {@link RhfUtilsClientConfig.onSubmitErrorUnknown}.
@@ -6,5 +6,4 @@ import { FormSubmitFieldErrors } from '../../submit/error/FormSubmitFieldErrors'
  * @param onError Fallback for handling non-TRPC errors.
  * @returns FormSubmitError
  */
-declare const makeOnSubmitTrpcClientErrorHandler: (onNotTrpcClientError: NonNullable<RhfUtilsClientConfig["onSubmitErrorUnknown"]>) => (error: unknown) => FormSubmitFieldErrors | undefined;
-export default makeOnSubmitTrpcClientErrorHandler;
+export declare const makeOnSubmitTrpcClientErrorHandler: (onNotTrpcClientError: NonNullable<RhfUtilsClientConfig["onSubmitErrorUnknown"]>) => (error: unknown) => FormSubmitFieldErrors | undefined;

package/dist/dts/errors/trpc/trpcClientErrorMessageSchema.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+/**
+ * Schema for {@link TRPCClientError} message.
+ *
+ * (Sent from backend as JSON string.)
+ */
+export declare const trpcClientErrorMessageSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    path: z.ZodArray<z.ZodString, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    code: z.ZodString;
+    message: z.ZodString;
+    path: z.ZodArray<z.ZodString, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    code: z.ZodString;
+    message: z.ZodString;
+    path: z.ZodArray<z.ZodString, "many">;
+}, z.ZodTypeAny, "passthrough">>;

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

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

package/dist/dts/form/RHF_UseFormReturnWithoutProxiesType.d.ts

@@ -0,0 +1,15 @@
+import { UseFormReturn } from 'react-hook-form';
+import { SafeFieldValues } from './rhf/SafeFieldValuesType';
+/**
+ * RHF's {@link UseFormReturn} without proxies -- i.e., `formState`.
+ *
+ * (Proxy values must be invoked or read individually before render.)
+ *
+ * @see https://react-hook-form.com/docs/useform/formstate
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy
+ *
+ * @description
+ *
+ * Hiding them from consumer's callbacks, will force explicit usage before first render.
+ */
+export type RHF_UseFormReturnWithoutProxies<TFieldValues extends SafeFieldValues = SafeFieldValues, TTransformedValues extends SafeFieldValues = TFieldValues> = Omit<UseFormReturn<TFieldValues, unknown, TTransformedValues>, 'formState'>;

package/dist/dts/form/RhfUtilsFormComponentPropsType.d.ts

@@ -0,0 +1,17 @@
+import { UseFormReturn } from 'react-hook-form';
+import { FormSubmitError } from '../submit/error/FormSubmitError';
+import { _Controller } from './_Controller';
+import { RhfUtilsContextProps } from './context/utils/RhfUtilsContextPropsType';
+import { UseRhfUtilsFormInstanceFormProps } from './defaults/form/UseRhfUtilsFormInstanceFormProps';
+import { SafeFieldValues } from './rhf/SafeFieldValuesType';
+/**
+ * RhfUtilsClientConfig's FormComponent props.
+ */
+export type RhfUtilsFormComponentProps<TFieldValues extends SafeFieldValues = SafeFieldValues, TTransformedValues extends SafeFieldValues = TFieldValues> = RhfUtilsContextProps & {
+    rhf: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+    formProps: UseRhfUtilsFormInstanceFormProps & {
+        onSubmit: NonNullable<React.PropsWithoutRef<React.JSX.IntrinsicElements['form']>['onSubmit']>;
+    };
+    Controller: typeof _Controller<TFieldValues>;
+    FormSubmitError: typeof FormSubmitError<TFieldValues>;
+};

package/dist/dts/form/RhfUtilsFormStateWithUtilsType.d.ts

@@ -0,0 +1,7 @@
+import { FormState } from 'react-hook-form';
+import { RhfUtilsContextProps } from './context/utils/RhfUtilsContextPropsType';
+import { SafeFieldValues } from './rhf/SafeFieldValuesType';
+export type RhfUtilsFormStateWithUtilsType<TFieldValues extends SafeFieldValues = SafeFieldValues> = {
+    state: FormState<TFieldValues>;
+    utils: RhfUtilsContextProps;
+};

package/dist/dts/form/UseRhfUtilsFormChildrenPropsType.d.ts

@@ -0,0 +1,25 @@
+import { UseFormReturn } from 'react-hook-form';
+import { FormSubmitError } from '../submit/error/FormSubmitError';
+import { MaybePromise } from '../utils/types';
+import { _Controller } from './_Controller';
+import { RhfUtilsContextProps } from './context/utils/RhfUtilsContextPropsType';
+import { RhfUtilsFormOptions } from './options/RhfUtilsFormOptionsType';
+import { SafeFieldValues } from './rhf/SafeFieldValuesType';
+/**
+ * Component props for `Children`.
+ *
+ * (Consider keeping shape in line with `UseRhfUtilsFormOnSubmitProps` and `UseRhfUtilsFormReturn`.)
+ */
+export type UseRhfUtilsFormChildrenProps<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues, TProps = undefined> = RhfUtilsContextProps & {
+    rhf: UseFormReturn<TFieldValues, unknown, TTransformedValues>;
+    options: RhfUtilsFormOptions;
+    Controller: typeof _Controller<TFieldValues>;
+    FormSubmitError: typeof FormSubmitError<TFieldValues>;
+} & {
+    onCancel?: () => MaybePromise<void>;
+} & // cancel
+(TProps extends undefined ? {
+    props?: undefined;
+} : {
+    props: TProps;
+});

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

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

package/dist/dts/form/context/utils/RhfUtilsContextPropsType.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from 'react';
+import { RhfUtilsContextProviderProps } from './RhfUtilsContextProvider';
+export type RhfUtilsContextProps = RhfUtilsContextProviderProps & {
+    /**
+     * Current form submit state.
+     *
+     * e.g., can be used to determine whether safe to redirect (navigate) without prompter.
+     * Unlike RHF's `isSubmitSuccessful`, is computed/set immediately after `onSubmit` succeeds/fails.
+     */
+    lastSubmitStateRef: RefObject<null | 'submitting' | 'success' | 'error'>;
+};

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

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { RhfUtilsFormOptions } from '../../options/RhfUtilsFormOptionsType';
+export type RhfUtilsContextProviderProps = {
+    formId: string;
+    formRef: React.RefObject<HTMLFormElement | null>;
+    /** Consumer-supplied options and values. */
+    options: RhfUtilsFormOptions;
+};
+export declare const RhfUtilsContextProvider: React.FC<React.PropsWithChildren<RhfUtilsContextProviderProps>>;

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

@@ -0,0 +1,5 @@
+import { RhfUtilsContextProps } from './RhfUtilsContextPropsType';
+declare const _RhfUtilsContextProvider: import('react').Provider<RhfUtilsContextProps | undefined>, useRhfUtilsContext: () => import('./RhfUtilsContextProvider').RhfUtilsContextProviderProps & {
+    lastSubmitStateRef: import('react').RefObject<null | "submitting" | "success" | "error">;
+}, useRhfUtilsMaybeContext: () => RhfUtilsContextProps | undefined;
+export { _RhfUtilsContextProvider, useRhfUtilsContext, useRhfUtilsMaybeContext, };

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

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

package/dist/dts/form/defaults/UseRhfUtilsFormGlobalDefaults.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+import { RhfUtilsFormOptions } from '../options/RhfUtilsFormOptionsType';
+import { RhfUseFormGlobalProps } from '../rhf/UseFormPropsType';
+/**
+ * Globally-relevant subset of defaults.
+ */
+export type UseRhfUtilsFormGlobalDefaults = {
+    /**
+     * Default RHF `useForm` settings.
+     *
+     * (Exposes only non-local props.)
+     */
+    rhf?: RhfUseFormGlobalProps;
+    /**
+     * Global settings and defaults.
+     *
+     * (Extend this type via `Register` type to inject custom options/functionality via `Children` component.)
+     */
+    options?: RhfUtilsFormOptions;
+    /**
+     * Default props for form element.
+     */
+    form?: Pick<React.PropsWithoutRef<React.JSX.IntrinsicElements['form']>, 'className' | 'noValidate' | 'role'>;
+};

package/dist/dts/form/defaults/UseRhfUtilsFormInstanceDefaults.d.ts

@@ -0,0 +1,18 @@
+import { RhfUtilsFormOptions } from '../options/RhfUtilsFormOptionsType';
+import { SafeFieldValues } from '../rhf/SafeFieldValuesType';
+import { RhfUseFormInstanceProps } from '../rhf/UseFormPropsType';
+import { UseRhfUtilsFormInstanceFormProps } from './form/UseRhfUtilsFormInstanceFormProps';
+/**
+ * Instance-specific subset of defaults.
+ */
+export type UseRhfUtilsFormInstanceDefaults<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = {
+    rhf?: RhfUseFormInstanceProps<TFieldValues, TTransformedValues>;
+    options?: RhfUtilsFormOptions;
+    form?: UseRhfUtilsFormInstanceFormProps;
+    /**
+     * Class name for styling.
+     *
+     * (Surfaced for sake of styling libraries. Value is merged along with `form.className`.)
+     */
+    className?: string;
+};

package/dist/dts/form/defaults/UseRhfUtilsFormResolvedDefaultsType.d.ts

@@ -0,0 +1,12 @@
+import { RhfUtilsFormOptions } from '../options/RhfUtilsFormOptionsType';
+import { SafeFieldValues } from '../rhf/SafeFieldValuesType';
+import { RhfUseFormInstanceProps } from '../rhf/UseFormPropsType';
+import { UseRhfUtilsFormInstanceFormProps } from './form/UseRhfUtilsFormInstanceFormProps';
+/**
+ * Global and instance defaults merged and resolved.
+ */
+export type UseRhfUtilsFormResolvedDefaults<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = {
+    rhf: RhfUseFormInstanceProps<TFieldValues, TTransformedValues>;
+    options: RhfUtilsFormOptions;
+    form: UseRhfUtilsFormInstanceFormProps;
+};

package/dist/dts/form/defaults/form/UseRhfUtilsFormInstanceFormProps.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+type DataAttributes = Record<`data-${string}`, string>;
+type FormAttributes = React.PropsWithoutRef<React.JSX.IntrinsicElements['form']> & DataAttributes;
+export type UseRhfUtilsFormInstanceFormProps = Omit<FormAttributes, 'id' | 'onSubmit'>;
+export type RhfUtilsFormInstanceFormSurfacedProps = Pick<FormAttributes, 'className'>;
+export {};

package/dist/dts/form/defaults/form/getRhfUtilsFormResolvedFormProps.d.ts

@@ -0,0 +1,2 @@
+import { RhfUtilsFormInstanceFormSurfacedProps, UseRhfUtilsFormInstanceFormProps } from './UseRhfUtilsFormInstanceFormProps';
+export declare const getRhfUtilsFormResolvedFormProps: (global: UseRhfUtilsFormInstanceFormProps | undefined, instance: UseRhfUtilsFormInstanceFormProps | undefined, surfaced?: RhfUtilsFormInstanceFormSurfacedProps) => UseRhfUtilsFormInstanceFormProps;