@paragrav/rhf-utils 0.1.0 → 0.60.0

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

@@ -0,0 +1,293 @@
+import { UseRhfUtilsFormInstanceFormProps } from './UseRhfUtilsFormInstanceFormProps';
+export declare const useRhfUtilsFormResolvedFormProps: (formProps: UseRhfUtilsFormInstanceFormProps | undefined, id: string, surfaced?: {
+    className?: string;
+}) => {
+    acceptCharset?: string | undefined | undefined;
+    action?: string | ((formData: FormData) => void | Promise<void>) | undefined;
+    method?: string | undefined | undefined;
+    name?: string | undefined | undefined;
+    noValidate?: boolean | undefined | undefined;
+    rel?: string | undefined | undefined;
+    target?: string | undefined | undefined;
+    accessKey?: string | undefined | undefined;
+    dir?: string | undefined | undefined;
+    draggable?: (boolean | "true" | "false") | undefined;
+    hidden?: boolean | undefined | undefined;
+    inert?: boolean | undefined | undefined;
+    lang?: string | undefined | undefined;
+    popover?: "" | "auto" | "manual" | "hint" | undefined | undefined;
+    title?: string | undefined | undefined;
+    translate?: "yes" | "no" | undefined | undefined;
+    className?: string | undefined | undefined;
+    part?: string | undefined | undefined;
+    prefix?: string | undefined | undefined;
+    slot?: string | undefined | undefined;
+    role?: import('react').AriaRole | undefined;
+    children?: import('react').ReactNode;
+    style?: import('react').CSSProperties | undefined;
+    contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+    enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | undefined;
+    inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined | undefined;
+    nonce?: string | undefined | undefined;
+    tabIndex?: number | undefined | undefined;
+    onChange?: import('react').FormEventHandler<HTMLFormElement> | undefined;
+    onBlur?: import('react').FocusEventHandler<HTMLFormElement> | undefined;
+    key?: import('react').Key | null | undefined;
+    autoComplete?: string | undefined | undefined;
+    encType?: string | undefined | undefined;
+    defaultChecked?: boolean | undefined | undefined;
+    defaultValue?: string | number | readonly string[] | undefined;
+    suppressContentEditableWarning?: boolean | undefined | undefined;
+    suppressHydrationWarning?: boolean | undefined | undefined;
+    autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {}) | undefined;
+    autoFocus?: boolean | undefined | undefined;
+    contextMenu?: string | undefined | undefined;
+    spellCheck?: (boolean | "true" | "false") | undefined;
+    radioGroup?: string | undefined | undefined;
+    about?: string | undefined | undefined;
+    content?: string | undefined | undefined;
+    datatype?: string | undefined | undefined;
+    inlist?: any;
+    property?: string | undefined | undefined;
+    resource?: string | undefined | undefined;
+    rev?: string | undefined | undefined;
+    typeof?: string | undefined | undefined;
+    vocab?: string | undefined | undefined;
+    autoCorrect?: string | undefined | undefined;
+    autoSave?: string | undefined | undefined;
+    color?: string | undefined | undefined;
+    itemProp?: string | undefined | undefined;
+    itemScope?: boolean | undefined | undefined;
+    itemType?: string | undefined | undefined;
+    itemID?: string | undefined | undefined;
+    itemRef?: string | undefined | undefined;
+    results?: number | undefined | undefined;
+    security?: string | undefined | undefined;
+    unselectable?: "on" | "off" | undefined | undefined;
+    popoverTargetAction?: "toggle" | "show" | "hide" | undefined | undefined;
+    popoverTarget?: string | undefined | undefined;
+    is?: string | undefined | undefined;
+    exportparts?: string | undefined | undefined;
+    "aria-activedescendant"?: string | undefined | undefined;
+    "aria-atomic"?: (boolean | "true" | "false") | undefined;
+    "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined | undefined;
+    "aria-braillelabel"?: string | undefined | undefined;
+    "aria-brailleroledescription"?: string | undefined | undefined;
+    "aria-busy"?: (boolean | "true" | "false") | undefined;
+    "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+    "aria-colcount"?: number | undefined | undefined;
+    "aria-colindex"?: number | undefined | undefined;
+    "aria-colindextext"?: string | undefined | undefined;
+    "aria-colspan"?: number | undefined | undefined;
+    "aria-controls"?: string | undefined | undefined;
+    "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined | undefined;
+    "aria-describedby"?: string | undefined | undefined;
+    "aria-description"?: string | undefined | undefined;
+    "aria-details"?: string | undefined | undefined;
+    "aria-disabled"?: (boolean | "true" | "false") | undefined;
+    "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined | undefined;
+    "aria-errormessage"?: string | undefined | undefined;
+    "aria-expanded"?: (boolean | "true" | "false") | undefined;
+    "aria-flowto"?: string | undefined | undefined;
+    "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+    "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined | undefined;
+    "aria-hidden"?: (boolean | "true" | "false") | undefined;
+    "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined | undefined;
+    "aria-keyshortcuts"?: string | undefined | undefined;
+    "aria-label"?: string | undefined | undefined;
+    "aria-labelledby"?: string | undefined | undefined;
+    "aria-level"?: number | undefined | undefined;
+    "aria-live"?: "off" | "assertive" | "polite" | undefined | undefined;
+    "aria-modal"?: (boolean | "true" | "false") | undefined;
+    "aria-multiline"?: (boolean | "true" | "false") | undefined;
+    "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+    "aria-orientation"?: "horizontal" | "vertical" | undefined | undefined;
+    "aria-owns"?: string | undefined | undefined;
+    "aria-placeholder"?: string | undefined | undefined;
+    "aria-posinset"?: number | undefined | undefined;
+    "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+    "aria-readonly"?: (boolean | "true" | "false") | undefined;
+    "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined | undefined;
+    "aria-required"?: (boolean | "true" | "false") | undefined;
+    "aria-roledescription"?: string | undefined | undefined;
+    "aria-rowcount"?: number | undefined | undefined;
+    "aria-rowindex"?: number | undefined | undefined;
+    "aria-rowindextext"?: string | undefined | undefined;
+    "aria-rowspan"?: number | undefined | undefined;
+    "aria-selected"?: (boolean | "true" | "false") | undefined;
+    "aria-setsize"?: number | undefined | undefined;
+    "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined | undefined;
+    "aria-valuemax"?: number | undefined | undefined;
+    "aria-valuemin"?: number | undefined | undefined;
+    "aria-valuenow"?: number | undefined | undefined;
+    "aria-valuetext"?: string | undefined | undefined;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined | undefined;
+    onCopy?: import('react').ClipboardEventHandler<HTMLFormElement> | undefined;
+    onCopyCapture?: import('react').ClipboardEventHandler<HTMLFormElement> | undefined;
+    onCut?: import('react').ClipboardEventHandler<HTMLFormElement> | undefined;
+    onCutCapture?: import('react').ClipboardEventHandler<HTMLFormElement> | undefined;
+    onPaste?: import('react').ClipboardEventHandler<HTMLFormElement> | undefined;
+    onPasteCapture?: import('react').ClipboardEventHandler<HTMLFormElement> | undefined;
+    onCompositionEnd?: import('react').CompositionEventHandler<HTMLFormElement> | undefined;
+    onCompositionEndCapture?: import('react').CompositionEventHandler<HTMLFormElement> | undefined;
+    onCompositionStart?: import('react').CompositionEventHandler<HTMLFormElement> | undefined;
+    onCompositionStartCapture?: import('react').CompositionEventHandler<HTMLFormElement> | undefined;
+    onCompositionUpdate?: import('react').CompositionEventHandler<HTMLFormElement> | undefined;
+    onCompositionUpdateCapture?: import('react').CompositionEventHandler<HTMLFormElement> | undefined;
+    onFocus?: import('react').FocusEventHandler<HTMLFormElement> | undefined;
+    onFocusCapture?: import('react').FocusEventHandler<HTMLFormElement> | undefined;
+    onBlurCapture?: import('react').FocusEventHandler<HTMLFormElement> | undefined;
+    onChangeCapture?: import('react').FormEventHandler<HTMLFormElement> | undefined;
+    onBeforeInput?: import('react').InputEventHandler<HTMLFormElement> | undefined;
+    onBeforeInputCapture?: import('react').FormEventHandler<HTMLFormElement> | undefined;
+    onInput?: import('react').FormEventHandler<HTMLFormElement> | undefined;
+    onInputCapture?: import('react').FormEventHandler<HTMLFormElement> | undefined;
+    onReset?: import('react').FormEventHandler<HTMLFormElement> | undefined;
+    onResetCapture?: import('react').FormEventHandler<HTMLFormElement> | undefined;
+    onSubmitCapture?: import('react').FormEventHandler<HTMLFormElement> | undefined;
+    onInvalid?: import('react').FormEventHandler<HTMLFormElement> | undefined;
+    onInvalidCapture?: import('react').FormEventHandler<HTMLFormElement> | undefined;
+    onLoad?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onLoadCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onError?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onErrorCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onKeyDown?: import('react').KeyboardEventHandler<HTMLFormElement> | undefined;
+    onKeyDownCapture?: import('react').KeyboardEventHandler<HTMLFormElement> | undefined;
+    onKeyPress?: import('react').KeyboardEventHandler<HTMLFormElement> | undefined;
+    onKeyPressCapture?: import('react').KeyboardEventHandler<HTMLFormElement> | undefined;
+    onKeyUp?: import('react').KeyboardEventHandler<HTMLFormElement> | undefined;
+    onKeyUpCapture?: import('react').KeyboardEventHandler<HTMLFormElement> | undefined;
+    onAbort?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onAbortCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onCanPlay?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onCanPlayCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onCanPlayThrough?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onCanPlayThroughCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onDurationChange?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onDurationChangeCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onEmptied?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onEmptiedCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onEncrypted?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onEncryptedCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onEnded?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onEndedCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onLoadedData?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onLoadedDataCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onLoadedMetadata?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onLoadedMetadataCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onLoadStart?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onLoadStartCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onPause?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onPauseCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onPlay?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onPlayCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onPlaying?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onPlayingCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onProgress?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onProgressCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onRateChange?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onRateChangeCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onSeeked?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onSeekedCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onSeeking?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onSeekingCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onStalled?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onStalledCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onSuspend?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onSuspendCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onTimeUpdate?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onTimeUpdateCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onVolumeChange?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onVolumeChangeCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onWaiting?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onWaitingCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onAuxClick?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onAuxClickCapture?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onClick?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onClickCapture?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onContextMenu?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onContextMenuCapture?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onDoubleClick?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onDoubleClickCapture?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onDrag?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDragCapture?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDragEnd?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDragEndCapture?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDragEnter?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDragEnterCapture?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDragExit?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDragExitCapture?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDragLeave?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDragLeaveCapture?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDragOver?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDragOverCapture?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDragStart?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDragStartCapture?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDrop?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onDropCapture?: import('react').DragEventHandler<HTMLFormElement> | undefined;
+    onMouseDown?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onMouseDownCapture?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onMouseEnter?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onMouseLeave?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onMouseMove?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onMouseMoveCapture?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onMouseOut?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onMouseOutCapture?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onMouseOver?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onMouseOverCapture?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onMouseUp?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onMouseUpCapture?: import('react').MouseEventHandler<HTMLFormElement> | undefined;
+    onSelect?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onSelectCapture?: import('react').ReactEventHandler<HTMLFormElement> | undefined;
+    onTouchCancel?: import('react').TouchEventHandler<HTMLFormElement> | undefined;
+    onTouchCancelCapture?: import('react').TouchEventHandler<HTMLFormElement> | undefined;
+    onTouchEnd?: import('react').TouchEventHandler<HTMLFormElement> | undefined;
+    onTouchEndCapture?: import('react').TouchEventHandler<HTMLFormElement> | undefined;
+    onTouchMove?: import('react').TouchEventHandler<HTMLFormElement> | undefined;
+    onTouchMoveCapture?: import('react').TouchEventHandler<HTMLFormElement> | undefined;
+    onTouchStart?: import('react').TouchEventHandler<HTMLFormElement> | undefined;
+    onTouchStartCapture?: import('react').TouchEventHandler<HTMLFormElement> | undefined;
+    onPointerDown?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onPointerDownCapture?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onPointerMove?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onPointerMoveCapture?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onPointerUp?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onPointerUpCapture?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onPointerCancel?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onPointerCancelCapture?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onPointerEnter?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onPointerLeave?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onPointerOver?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onPointerOverCapture?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onPointerOut?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onPointerOutCapture?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onGotPointerCapture?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onGotPointerCaptureCapture?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onLostPointerCapture?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onLostPointerCaptureCapture?: import('react').PointerEventHandler<HTMLFormElement> | undefined;
+    onScroll?: import('react').UIEventHandler<HTMLFormElement> | undefined;
+    onScrollCapture?: import('react').UIEventHandler<HTMLFormElement> | undefined;
+    onScrollEnd?: import('react').UIEventHandler<HTMLFormElement> | undefined;
+    onScrollEndCapture?: import('react').UIEventHandler<HTMLFormElement> | undefined;
+    onWheel?: import('react').WheelEventHandler<HTMLFormElement> | undefined;
+    onWheelCapture?: import('react').WheelEventHandler<HTMLFormElement> | undefined;
+    onAnimationStart?: import('react').AnimationEventHandler<HTMLFormElement> | undefined;
+    onAnimationStartCapture?: import('react').AnimationEventHandler<HTMLFormElement> | undefined;
+    onAnimationEnd?: import('react').AnimationEventHandler<HTMLFormElement> | undefined;
+    onAnimationEndCapture?: import('react').AnimationEventHandler<HTMLFormElement> | undefined;
+    onAnimationIteration?: import('react').AnimationEventHandler<HTMLFormElement> | undefined;
+    onAnimationIterationCapture?: import('react').AnimationEventHandler<HTMLFormElement> | undefined;
+    onToggle?: import('react').ToggleEventHandler<HTMLFormElement> | undefined;
+    onBeforeToggle?: import('react').ToggleEventHandler<HTMLFormElement> | undefined;
+    onTransitionCancel?: import('react').TransitionEventHandler<HTMLFormElement> | undefined;
+    onTransitionCancelCapture?: import('react').TransitionEventHandler<HTMLFormElement> | undefined;
+    onTransitionEnd?: import('react').TransitionEventHandler<HTMLFormElement> | undefined;
+    onTransitionEndCapture?: import('react').TransitionEventHandler<HTMLFormElement> | undefined;
+    onTransitionRun?: import('react').TransitionEventHandler<HTMLFormElement> | undefined;
+    onTransitionRunCapture?: import('react').TransitionEventHandler<HTMLFormElement> | undefined;
+    onTransitionStart?: import('react').TransitionEventHandler<HTMLFormElement> | undefined;
+    onTransitionStartCapture?: import('react').TransitionEventHandler<HTMLFormElement> | undefined;
+    id: string;
+};

package/dist/{types/form/RhfUtilsFormOptions.d.ts → dts/form/options/RhfUtilsFormOptionsType.d.ts}

@@ -1,20 +1,19 @@
 import { DevtoolUIProps } from '@hookform/devtools/dist/devToolUI';
-import { UseResetFormOnSubmittedOptions } from '../submit/useResetFormOnSubmitted';
-import { Register } from '../register';
+import { UseResetFormOnSubmittedOptions } from '../../submit/useResetFormOnSubmitted';
+import { UseSubmitFormOnWatchOptions } from '../../submit/useSubmitFormOnWatch';
+import { Register } from '../../Register';
 /**
  * Options for enabling utils functionality provided by this library.
  *
- * Can be extended using {@link Register.RhfUtilsFormOptions}.
+ * Can be extended via {@link Register}.
  */
 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.
+     * Request submit when user changes form values.
      */
-    submitOnChange?: boolean | number;
+    submitOnWatch?: UseSubmitFormOnWatchOptions;
     /** Reset form values and state (e.g., `isDirty`) after submit -- on success and/or error. */
     resetOnSubmitted?: UseResetFormOnSubmittedOptions;
     /**

package/dist/dts/form/options/getRhfUtilsFormResolvedOptions.d.ts

@@ -0,0 +1,2 @@
+import { RhfUtilsFormOptions } from './RhfUtilsFormOptionsType';
+export declare const getRhfUtilsFormResolvedOptions: (global: RhfUtilsFormOptions | undefined, instance: RhfUtilsFormOptions | undefined) => RhfUtilsFormOptions;

package/dist/dts/form/options/useRhfUtilsFormResolvedOptions.d.ts

@@ -0,0 +1,8 @@
+import { RhfUtilsClientConfig } from '../../client/config/RhfUtilsClientConfigType';
+import { RhfUtilsFormOptions } from './RhfUtilsFormOptionsType';
+export declare const useRhfUtilsFormResolvedOptions: (config: RhfUtilsClientConfig, options: RhfUtilsFormOptions | undefined) => {
+    stopSubmitPropagation?: boolean;
+    submitOnWatch?: import('../../submit/useSubmitFormOnWatch').UseSubmitFormOnWatchOptions;
+    resetOnSubmitted?: import('../../submit/useResetFormOnSubmitted').UseResetFormOnSubmittedOptions;
+    devTool?: boolean | Pick<import('@hookform/devtools/dist/devToolUI').DevtoolUIProps, "placement" | "styles">;
+};

package/dist/dts/form/providers/RhfUtilsFormProviders.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { SafeFieldValues } from '../rhf/SafeFieldValuesType';
+import { RhfUtilsFormProvidersProps } from './RhfUtilsFormProvidersPropsType';
+type Props<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = React.PropsWithChildren<RhfUtilsFormProvidersProps<TFieldValues, TTransformedValues>>;
+export declare function RhfUtilsFormProviders<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues>({ formId, rhf, resolver, defaultValues, options, children, }: Props<TFieldValues, TTransformedValues>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/dts/form/providers/RhfUtilsFormProvidersPropsType.d.ts

@@ -0,0 +1,15 @@
+import { Resolver, UseFormProps } from 'react-hook-form';
+import { RhfUtilsFormOptions } from '../options/RhfUtilsFormOptionsType';
+import { SafeFieldValues } from '../rhf/SafeFieldValuesType';
+import { RhfUseFormInstanceProps } from '../rhf/UseFormPropsType';
+/**
+ * RhfUtils form providers props.
+ */
+export type RhfUtilsFormProvidersProps<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = {
+    /** Globally-unique form id. (Used in DOM. Auto-generated if not supplied.) */
+    formId?: string;
+    resolver?: Resolver<TFieldValues, unknown, TTransformedValues>;
+    rhf?: RhfUseFormInstanceProps<TFieldValues, TTransformedValues>;
+    defaultValues?: UseFormProps<TFieldValues, unknown, TTransformedValues>['defaultValues'];
+    options?: RhfUtilsFormOptions;
+};

package/dist/dts/form/rhf/UseFormPropsType.d.ts

@@ -0,0 +1,4 @@
+import { UseFormProps } from 'react-hook-form';
+import { SafeFieldValues } from './SafeFieldValuesType';
+export type RhfUseFormGlobalProps = Pick<UseFormProps, 'mode' | 'reValidateMode' | 'resetOptions' | 'context' | 'shouldFocusError' | 'shouldUnregister' | 'shouldUseNativeValidation' | 'progressive' | 'criteriaMode' | 'delayError'>;
+export type RhfUseFormInstanceProps<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues> = Omit<UseFormProps<TFieldValues, unknown, TTransformedValues>, 'defaultValues' | 'resolver'>;

package/dist/dts/form/rhf/getRhfUtilsFormResolvedRhfProps.d.ts

@@ -0,0 +1,4 @@
+import { UseRhfUtilsFormResolvedDefaults } from '../defaults/UseRhfUtilsFormResolvedDefaultsType';
+import { SafeFieldValues } from './SafeFieldValuesType';
+import { RhfUseFormGlobalProps, RhfUseFormInstanceProps } from './UseFormPropsType';
+export declare const getRhfUtilsFormResolvedRhfProps: <TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues>(global: RhfUseFormGlobalProps | undefined, instance: RhfUseFormInstanceProps<TFieldValues, TTransformedValues> | undefined) => UseRhfUtilsFormResolvedDefaults<TFieldValues, TTransformedValues>["rhf"];

package/dist/dts/form/rhf/useRhfFormWithResolvedProps.d.ts

@@ -0,0 +1,5 @@
+import { Resolver, UseFormProps } from 'react-hook-form';
+import { RhfUtilsClientConfig } from '../../client/config/RhfUtilsClientConfigType';
+import { SafeFieldValues } from '../rhf/SafeFieldValuesType';
+import { RhfUseFormInstanceProps } from '../rhf/UseFormPropsType';
+export declare const useRhfFormWithResolvedProps: <TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues>(props: RhfUseFormInstanceProps<TFieldValues, TTransformedValues> | undefined, config: RhfUtilsClientConfig, defaultValues: UseFormProps<TFieldValues, unknown, TTransformedValues>["defaultValues"], resolver?: Resolver<TFieldValues, unknown, TTransformedValues>) => import('react-hook-form').UseFormReturn<TFieldValues, unknown, TTransformedValues>;

package/dist/dts/form/state/relay/FormStateRelayContextProvider.d.ts

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

package/dist/dts/form/state/relay/FormStateRelayedAggregatedType.d.ts

@@ -0,0 +1,10 @@
+import { Merge } from '../../../utils/types';
+import { FormStateRelayed } from './FormStateRelayedType';
+export type FormStateRelayedAggregated = Merge<Omit<FormStateRelayed, 'defaultValues'>, Record<Extract<keyof FormStateRelayed, 'dirtyFields' | 'touchedFields' | 'validatingFields' | 'errors'>, boolean> & {
+    /** Sum of all submit counts. */
+    submitCount: number;
+    /** Any submitted and not successful? */
+    isSubmitUnsuccessful: boolean;
+    /** Consider form flagged when mounted. (Corresponds to {@link FormStateRelayedOptions.flaggedState.isMounted}.) */
+    isMountedFlagged: boolean;
+}>;

package/dist/dts/form/state/relay/FormStateRelayedItemType.d.ts

@@ -0,0 +1,11 @@
+import { SafeFieldValues } from '../../rhf/SafeFieldValuesType';
+import { RhfUtilsFormStateWithUtilsType } from '../../RhfUtilsFormStateWithUtilsType';
+import { FormStateRelayedOptions } from './FormStateRelayedOptionsType';
+import { FormStateRelayed } from './FormStateRelayedType';
+export type FormStateRelayedItem<TFieldValues extends SafeFieldValues = SafeFieldValues> = {
+    state: FormStateRelayed<TFieldValues>;
+    options?: FormStateRelayedOptions;
+};
+export type FormStateRelayedItemWithUtils<TFieldValues extends SafeFieldValues = SafeFieldValues> = RhfUtilsFormStateWithUtilsType<TFieldValues> & {
+    options?: FormStateRelayedOptions;
+};

package/dist/dts/form/state/relay/FormStateRelayedOptionsType.d.ts

@@ -0,0 +1,20 @@
+export type FormStateRelayedOptions = {
+    /**
+     * Arbitrary group name(s) for this form.
+     *
+     * Think of it like class or category names.
+     * (e.g., "parent" or "children")
+     */
+    group?: string | string[];
+    /**
+     * Denote certain state(s) as flagged.
+     */
+    flaggedState?: {
+        /**
+         * Flag when mounted.
+         *
+         * (e.g., forms that are unmounted by default)
+         */
+        isMounted?: true;
+    };
+};

package/dist/dts/form/state/relay/FormStateRelayedType.d.ts

@@ -0,0 +1,3 @@
+import { FormState } from 'react-hook-form';
+import { SafeFieldValues } from '../../rhf/SafeFieldValuesType';
+export type FormStateRelayed<TFieldValues extends SafeFieldValues = SafeFieldValues> = FormState<TFieldValues>;

package/dist/dts/form/state/relay/pull/hooks.d.ts

@@ -0,0 +1,31 @@
+import { SafeFieldValues } from '../../../rhf/SafeFieldValuesType';
+import { RhfUtilsFormStateWithUtilsType } from '../../../RhfUtilsFormStateWithUtilsType';
+import { FormStateRelayedAggregated } from '../FormStateRelayedAggregatedType';
+import { FormStateRelayedItemWithUtils } from '../FormStateRelayedItemType';
+/**
+ * Watch only form -- without worrying about ID.
+ *
+ * @throws If more than one form is being tracked.
+ */
+export declare const useFormStateRelayPullOnlyOrThrow: () => FormStateRelayedItemWithUtils | undefined;
+/**
+ * Watch all forms via {@link FormStateRelayedAggregated}.
+ */
+export declare const useFormStateRelayPullAny: () => FormStateRelayedAggregated;
+/**
+ * Watch single form's state.
+ *
+ * @param formId Watched form identifier.
+ */
+export declare const useFormStateRelayPullById: (formId: string) => FormStateRelayedItemWithUtils | undefined;
+/**
+ * Compute single boolean for group's form state to denote whether it's flagged via default algorithm.
+ * (i.e., is dirty or submitting or submit unsuccessful or mounted flagged)
+ *
+ * @param group Group name to watch.
+ */
+export declare const useFormStateRelayPullGroup: (group: string) => FormStateRelayedAggregated | undefined;
+/**
+ * Use form state with utils either through RHF or relay.
+ */
+export declare const useFormStateWithUtilsViaRhfOrRelay: <TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues>() => RhfUtilsFormStateWithUtilsType<TFieldValues> | undefined;

package/dist/dts/form/state/relay/push/FormStateRelayPusher.d.ts

@@ -0,0 +1,4 @@
+import { FormStateRelayPushOptions } from './useFormStateRelayPusher';
+type Props = FormStateRelayPushOptions;
+export declare const FormStateRelayPusher: React.FC<Props>;
+export {};

package/dist/dts/form/state/relay/push/useFormStateRelayPusher.d.ts

@@ -0,0 +1,3 @@
+import { FormStateRelayedOptions } from '../FormStateRelayedOptionsType';
+export type FormStateRelayPushOptions = FormStateRelayedOptions;
+export declare const useFormStateRelayPusher: (options?: FormStateRelayPushOptions) => void;

package/dist/dts/form/state/relay/useFormStateRelayContext.d.ts

@@ -0,0 +1,20 @@
+import { RhfUtilsContextProps } from '../../context/utils/RhfUtilsContextPropsType';
+import { FormStateRelayedAggregated } from './FormStateRelayedAggregatedType';
+import { FormStateRelayedItemWithUtils } from './FormStateRelayedItemType';
+import { FormStateRelayedOptions } from './FormStateRelayedOptionsType';
+import { FormStateRelayed } from './FormStateRelayedType';
+export type FormStateRelayContext = {
+    add: (state: FormStateRelayed, utils: RhfUtilsContextProps, options?: FormStateRelayedOptions) => void;
+    update: (id: string, state: FormStateRelayed) => void;
+    remove: (id: string) => void;
+    /**
+     * Get form state by ID.
+     *
+     * @throws Error if not found.
+     */
+    get: (id: string) => FormStateRelayedItemWithUtils | undefined;
+    getOnly: () => FormStateRelayedItemWithUtils | undefined;
+    any: FormStateRelayedAggregated;
+    getGroup: (group: string) => FormStateRelayedAggregated | undefined;
+};
+export declare const _FormStateRelayContextProvider: import('react').Provider<FormStateRelayContext | undefined>, useFormStateRelayContext: () => FormStateRelayContext;

package/dist/dts/form/state/relay/utils.d.ts

@@ -0,0 +1,4 @@
+import { FormStateRelayedAggregated } from './FormStateRelayedAggregatedType';
+import { FormStateRelayedItem } from './FormStateRelayedItemType';
+/** Condense list of form states to singular booleans. */
+export declare const getFormContextRelayReducedFormState: (forms: FormStateRelayedItem[]) => FormStateRelayedAggregated;

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

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

package/dist/{types → dts}/form/utils/useFormRequestSubmit.d.ts

@@ -6,5 +6,4 @@ import { default as React } from 'react';
  *
  * @link https://developer.mozilla.org/docs/Web/API/HTMLFormElement/requestSubmit
  */
-declare const useFormRequestSubmit: (ref: React.RefObject<HTMLFormElement>) => HTMLFormElement["requestSubmit"];
-export default useFormRequestSubmit;
+export declare const useFormRequestSubmit: (ref: React.RefObject<HTMLFormElement | null>) => HTMLFormElement["requestSubmit"];

package/dist/dts/form/utils/useHandleCancelWithCheckIfCanBe.d.ts

@@ -0,0 +1,4 @@
+import { RhfUtilsClientConfig } from '../../client/config/RhfUtilsClientConfigType';
+import { UseRhfUtilsFormOnSubmitContext } from '../../submit/UseRhfUtilsFormOnSubmitContextType';
+import { MaybePromise } from '../../utils/types';
+export declare const useHandleCancelWithCheckIfCanBe: (onCancel: undefined | (() => MaybePromise<void>), useCanFormBeCancelled: RhfUtilsClientConfig["useCanFormBeCancelled"], formOnSubmitContext: UseRhfUtilsFormOnSubmitContext) => () => Promise<void>;

package/dist/dts/form/utils/useHandleCancelWithCheckIfCanBeViaProviders.d.ts

@@ -0,0 +1,2 @@
+import { MaybePromise } from '../../utils/types';
+export declare const useHandleCancelWithCheckIfCanBeViaProviders: (onCancel: undefined | (() => MaybePromise<void>)) => () => Promise<void>;

package/dist/{types → dts}/form/utils/useShouldFormBlockNavigation.d.ts

@@ -21,5 +21,4 @@ export type UseShouldFormBlockNavigationOptions = {
  * 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;
+export declare const useShouldFormBlockNavigation: ({ isDirty, isSubmitting }: FormState<FieldValues>, options?: UseShouldFormBlockNavigationOptions) => boolean;

package/dist/dts/form/with-handlers-and-children/RhfUtilsForm.d.ts

@@ -0,0 +1,3 @@
+import { SafeFieldValues } from '../rhf/SafeFieldValuesType';
+import { RhfUtilsFormProps, RhfUtilsFormPropsGetApiValues } from './RhfUtilsFormProps';
+export declare const RhfUtilsForm: <TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues, TGetApiValues extends undefined | RhfUtilsFormPropsGetApiValues<TTransformedValues, SafeFieldValues>, TOnSubmitReturnType, TApiValues extends undefined | SafeFieldValues = TGetApiValues extends RhfUtilsFormPropsGetApiValues<TTransformedValues, infer U> ? U : undefined>({ getApiData, onCancel, onSubmitInvalid, onBeforeSubmitInvariants, onBeforeSubmit, onSubmit, onSubmitSuccess, onSubmitError, onSubmitFinally, Children, form, className, }: RhfUtilsFormProps<TFieldValues, TTransformedValues, TGetApiValues, TOnSubmitReturnType, TApiValues>) => import("react/jsx-runtime").JSX.Element;

package/dist/dts/form/with-handlers-and-children/RhfUtilsFormProps.d.ts

@@ -0,0 +1,46 @@
+import { SubmitErrorHandler } from 'react-hook-form';
+import { MaybePromise } from '../../utils/types';
+import { UseRhfUtilsFormOnSubmitContext, UseRhfUtilsFormOnSubmitErrorContext } from '../../submit/UseRhfUtilsFormOnSubmitContextType';
+import { UseRhfUtilsFormInstanceFormProps } from '../defaults/form/UseRhfUtilsFormInstanceFormProps';
+import { SafeFieldValues } from '../rhf/SafeFieldValuesType';
+import { UseRhfUtilsFormChildrenProps } from '../UseRhfUtilsFormChildrenPropsType';
+export type RhfUtilsFormPropsGetApiValues<TTransformedValues extends SafeFieldValues, TApiValues> = (data: TTransformedValues) => TApiValues;
+export type RhfUtilsFormPropsonBeforeSubmitInvariants<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues, TApiValues extends undefined | SafeFieldValues> = (data: {
+    input: TFieldValues;
+    output: TTransformedValues;
+    api: TApiValues;
+}, context: UseRhfUtilsFormOnSubmitContext<TFieldValues, TTransformedValues, TApiValues>, event: React.BaseSyntheticEvent<SubmitEvent>) => MaybePromise<[keyof TFieldValues | keyof TApiValues, string, unknown][]>;
+export type RhfUtilsFormProps<TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues, TGetApiValues extends undefined | RhfUtilsFormPropsGetApiValues<TTransformedValues, SafeFieldValues>, TOnSubmitReturnType, TApiValues extends undefined | SafeFieldValues = TGetApiValues extends RhfUtilsFormPropsGetApiValues<TTransformedValues, infer U> ? U : undefined> = {
+    getApiData?: TGetApiValues;
+    /** Cancellation handler -- channeled through {@link RhfUtilsClientConfig.useCanFormBeCancelled} before propagating to `Children` component. */
+    onCancel?: () => MaybePromise<void>;
+    /** Submit handler when form is invalid. */
+    onSubmitInvalid?: SubmitErrorHandler<TFieldValues>;
+    /**
+     * List of invariants to run against input/output/api data.
+     * For any and all false-y values, a {@link FormSubmitFieldErrors} will be thrown.
+     */
+    onBeforeSubmitInvariants?: RhfUtilsFormPropsonBeforeSubmitInvariants<TFieldValues, TTransformedValues, TApiValues>;
+    onBeforeSubmit?: (data: {
+        input: TFieldValues;
+        output: TTransformedValues;
+        api: TApiValues;
+    }, context: UseRhfUtilsFormOnSubmitContext<TFieldValues, TTransformedValues, TApiValues>, event: React.BaseSyntheticEvent<SubmitEvent>) => MaybePromise<unknown>;
+    onSubmit?: (data: {
+        input: TFieldValues;
+        output: TTransformedValues;
+        api: TApiValues;
+    }, context: UseRhfUtilsFormOnSubmitContext<TFieldValues, TTransformedValues, TApiValues>, event: React.BaseSyntheticEvent<SubmitEvent>) => MaybePromise<TOnSubmitReturnType>;
+    onSubmitSuccess?: (submitResponse: TOnSubmitReturnType, data: {
+        input: TFieldValues;
+        output: TTransformedValues;
+        api: TApiValues;
+    }, context: UseRhfUtilsFormOnSubmitContext<TFieldValues, TTransformedValues, TApiValues>, 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;
+    onSubmitFinally?: () => MaybePromise<void>;
+    Children: React.FC<UseRhfUtilsFormChildrenProps<TFieldValues, TTransformedValues>>;
+    form?: UseRhfUtilsFormInstanceFormProps;
+    /** Form class attribute. */
+    className?: string;
+};

package/dist/dts/form/with-handlers-and-children/_ChildrenViaProviders.d.ts

@@ -0,0 +1,3 @@
+import { SafeFieldValues } from '../rhf/SafeFieldValuesType';
+import { RhfUtilsFormProps } from './RhfUtilsFormProps';
+export declare const RhfUtilsFormChildrenViaProviders_Internal: <TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues>({ onCancel, Children, }: Pick<RhfUtilsFormProps<TFieldValues, TTransformedValues, undefined, undefined>, "Children" | "onCancel">) => import("react/jsx-runtime").JSX.Element;

package/dist/dts/form/with-handlers-and-children/_FormWithSubmitHandler.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { SafeFieldValues } from '../rhf/SafeFieldValuesType';
+import { RhfUtilsFormProps, RhfUtilsFormPropsGetApiValues } from './RhfUtilsFormProps';
+export declare const RhfUtilsFormWithSubmitHandler_Internal: <TFieldValues extends SafeFieldValues, TTransformedValues extends SafeFieldValues, TGetApiValues extends undefined | RhfUtilsFormPropsGetApiValues<TTransformedValues, SafeFieldValues>, TOnSubmitReturnType, TApiValues extends undefined | SafeFieldValues = TGetApiValues extends RhfUtilsFormPropsGetApiValues<TTransformedValues, infer U> ? U : undefined>({ getApiData, onSubmitInvalid, onBeforeSubmitInvariants, onBeforeSubmit, onSubmit, onSubmitSuccess, onSubmitError, onSubmitFinally, form, className, children, }: React.PropsWithChildren<Pick<RhfUtilsFormProps<TFieldValues, TTransformedValues, TGetApiValues, TOnSubmitReturnType, TApiValues>, "getApiData" | "onSubmitInvalid" | "onBeforeSubmitInvariants" | "onBeforeSubmit" | "onSubmit" | "onSubmitSuccess" | "onSubmitError" | "onSubmitFinally" | "form" | "className">>) => import("react/jsx-runtime").JSX.Element;