@paragrav/rhf-utils 0.65.0 → 0.67.0

package/dist/tsdown/index.js

@@ -0,0 +1,745 @@
+import { a as _RhfUtilsContextProvider, c as FormRelayContextProvider, i as isEmptyObject, o as useRhfUtilsContext, r as getFlatFieldErrors, t as FormRelaySetter, u as createContext } from "./FormRelaySetter-BKO0Wodf.js";
+import React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Controller, FormProvider, useForm, useFormContext, useFormState, useWatch } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+//#region src/client/config/context/RhfUtilsClientConfigContext.tsx
+const RhfUtilsClientConfigContext_Internal = React.createContext(void 0);
+//#endregion
+//#region src/client/config/context/RhfUtilsClientConfigProvider.tsx
+const RhfUtilsClientConfigProvider = ({ config, children }) => {
+	const [memoConfig] = React.useState(config ?? {});
+	return /* @__PURE__ */ jsx(RhfUtilsClientConfigContext_Internal.Provider, {
+		value: memoConfig,
+		children: /* @__PURE__ */ jsx(FormRelayContextProvider, { children })
+	});
+};
+//#endregion
+//#region src/errors/flat/context/useFlatFieldErrorsContext.ts
+const { Provider: _FormErrorsFlatContextProvider, useRequired: useFlatFieldErrorsContext } = createContext();
+//#endregion
+//#region src/errors/flat/context/useFlatFieldErrorsContextHasOnlyOrphans.ts
+/**
+* Returns `true` if all errors are orphans.
+*
+* You may want to treat this case specifically.
+*/
+const useFlatFieldErrorsContextHasOnlyOrphans = () => {
+	const errors = useFlatFieldErrorsContext();
+	return React.useMemo(() => {
+		if (!errors.hasErrors) return false;
+		if (!errors.hasOrphans) return false;
+		return Object.keys(errors.orphans).length === Object.keys(errors.all).length;
+	}, [errors]);
+};
+//#endregion
+//#region src/errors/nonfield/RhfUtilsNonFieldErrorMarkerHtmlAttribute.ts
+/**
+* HTML data attribute for {@link RhfUtilsNonFieldErrorMarker}.
+*/
+const RhfUtilsNonFieldErrorMarkerHtmlAttribute = "data-rhfutils-nonfield-error-marker-path";
+//#endregion
+//#region src/errors/nonfield/RhfUtilsNonFieldErrorMarker.tsx
+/**
+* Empty, hidden marker to indicate a non-field/non-root error is being displayed to user.
+*
+* Example use case:
+* Field array with minimum items.
+* (When there are no items, the error is not associated with a field and is displayed separately.)
+*/
+const RhfUtilsNonFieldErrorMarker = ({ path }) => {
+	return /* @__PURE__ */ jsx("div", {
+		role: "alert",
+		"aria-hidden": "true",
+		style: { display: "none" },
+		[RhfUtilsNonFieldErrorMarkerHtmlAttribute]: path
+	});
+};
+//#endregion
+//#region src/form/utils/useFormRequestSubmit.ts
+/**
+* Get callback to trigger submit manually on form.
+*
+* Note: `submitter` is optional, but is required to be a submit button.
+*
+* @link https://developer.mozilla.org/docs/Web/API/HTMLFormElement/requestSubmit
+*/
+const useFormRequestSubmit = (ref) => React.useCallback((submitter) => {
+	if (!ref.current) throw new Error();
+	requestSubmitByForm(ref.current, submitter);
+}, [ref]);
+const requestSubmitByForm = (form, submitter) => {
+	form.requestSubmit(submitter);
+};
+//#endregion
+//#region src/submit/error/FormSubmitError.ts
+var FormSubmitError = class extends Error {
+	errors;
+	constructor(errors, message) {
+		super(message);
+		this.errors = errors;
+	}
+};
+//#endregion
+//#region src/submit/last-error/useLastSubmitErrorContext.ts
+const { Provider: _LastSubmitErrorContextProvider, useRequired: _useLastSubmitErrorContext } = createContext();
+//#endregion
+//#region src/submit/last-error/useLastSubmitError.ts
+const useLastSubmitError = () => _useLastSubmitErrorContext().current;
+//#endregion
+//#region src/devtool/LazyDevTool.tsx
+const LazyRhfDevTool = React.lazy(() => import("@hookform/devtools").then((res) => ({ default: res.DevTool })));
+/**
+* Lazy-loaded RHF DevTool.
+*/
+const LazyDevTool = ({ config }) => {
+	const [memoConfig] = React.useState(config);
+	if (!memoConfig) return null;
+	const props = typeof memoConfig === "object" ? memoConfig : void 0;
+	return /* @__PURE__ */ jsx(React.Suspense, { children: /* @__PURE__ */ jsx(LazyRhfDevTool, { ...props }) });
+};
+//#endregion
+//#region src/devtool/LazyDevToolViaProviders.tsx
+const LazyDevToolViaProviders = () => {
+	return /* @__PURE__ */ jsx(LazyDevTool, { config: useRhfUtilsContext().options.devTool });
+};
+//#endregion
+//#region src/form/_Controller.tsx
+const _Controller = (props) => /* @__PURE__ */ jsx(Controller, { ...props });
+//#endregion
+//#region src/client/config/context/useRhfUtilsClientConfig.ts
+const useRhfUtilsClientConfig = () => {
+	const ctx = React.useContext(RhfUtilsClientConfigContext_Internal);
+	if (ctx === void 0) throw new Error();
+	return ctx;
+};
+//#endregion
+//#region src/submit/useRhfUtilsFormOnSubmitContext.ts
+const useRhfUtilsFormOnSubmitContext = () => {
+	return {
+		utils: useRhfUtilsContext(),
+		rhf: useFormContext(),
+		FormSubmitError
+	};
+};
+//#endregion
+//#region src/form/utils/useHandleCancelWithCheckIfCanBe.ts
+const useHandleCancelWithCheckIfCanBe = (onCancel, useCanFormBeCancelled, formOnSubmitContext) => {
+	const canFormBeCancelled = useCanFormBeCancelled?.();
+	return async () => {
+		if (!onCancel) return;
+		if (await Promise.resolve(canFormBeCancelled?.(formOnSubmitContext)) === false) return;
+		return Promise.resolve(onCancel());
+	};
+};
+//#endregion
+//#region src/form/utils/useHandleCancelWithCheckIfCanBeViaProviders.ts
+const useHandleCancelWithCheckIfCanBeViaProviders = (onCancel) => {
+	const { useCanFormBeCancelled } = useRhfUtilsClientConfig();
+	return useHandleCancelWithCheckIfCanBe(onCancel, useCanFormBeCancelled, useRhfUtilsFormOnSubmitContext());
+};
+//#endregion
+//#region src/form/with-handlers-and-children/_ChildrenViaProviders.tsx
+const RhfUtilsFormChildrenViaProviders_Internal = ({ onCancel, Children }) => {
+	const rhf = useFormContext();
+	const utils = useRhfUtilsContext();
+	const onCancelWithCheck = useHandleCancelWithCheckIfCanBeViaProviders(onCancel);
+	return /* @__PURE__ */ jsx(Children, {
+		...utils,
+		rhf,
+		onCancel: onCancelWithCheck,
+		Controller: _Controller,
+		FormSubmitError
+	});
+};
+//#endregion
+//#region src/submit/error/setCtxErrorsByFormSubmitFieldErrors.ts
+/**
+* Handle thrown {@link FormSubmitError}.
+* Add key/values as name/message to RHF context errors.
+*/
+const setCtxErrorsByFormSubmitFieldErrors = (ctx, errors) => {
+	Object.entries(errors).forEach(([name, fieldError]) => {
+		ctx.setError(name, {
+			type: "FormSubmitFieldError",
+			...fieldError
+		});
+	});
+};
+//#endregion
+//#region src/form/defaults/form/getRhfUtilsFormResolvedFormProps.ts
+const getRhfUtilsFormResolvedFormProps = (global, instance, surfaced) => ({
+	...global,
+	...instance,
+	className: [
+		global?.className,
+		instance?.className,
+		surfaced?.className
+	].filter(Boolean).join(" ").trim() || void 0
+});
+//#endregion
+//#region src/form/defaults/form/useRhfUtilsFormResolvedFormProps.ts
+const useRhfUtilsFormResolvedFormProps = (formProps, id, surfaced) => {
+	return {
+		id,
+		...getRhfUtilsFormResolvedFormProps(useRhfUtilsClientConfig().defaults?.form, formProps, surfaced)
+	};
+};
+//#endregion
+//#region src/submit/last-error/useLastSubmitErrorContextWith.ts
+const useLastSubmitErrorContextWith = (handleSubmit) => {
+	const ctx = _useLastSubmitErrorContext();
+	return async function(event) {
+		try {
+			ctx.reset();
+			return await handleSubmit(event);
+		} catch (error) {
+			ctx.set(error, event);
+			throw error;
+		}
+	};
+};
+//#endregion
+//#region src/form/with-handlers-and-children/_useHandleSubmit.ts
+const useRhfUtilsFormHandleSubmit_Internal = ({ onValid, onInvalid, onError, onFinally }) => {
+	const rhfContext = useFormContext();
+	const { options, lastSubmitStateRef } = useRhfUtilsContext();
+	const handleSubmitWithLastSubmitError = useLastSubmitErrorContextWith(rhfContext.handleSubmit(onValid, onInvalid));
+	return (event) => {
+		lastSubmitStateRef.current = "submitting";
+		if (options.stopSubmitPropagation) event.stopPropagation();
+		Promise.resolve(handleSubmitWithLastSubmitError(event)).then(() => {
+			lastSubmitStateRef.current = "success";
+		}).catch((error) => {
+			lastSubmitStateRef.current = "error";
+			onError(error, event);
+		}).finally(() => {
+			onFinally?.();
+		});
+	};
+};
+//#endregion
+//#region src/form/with-handlers-and-children/_FormWithSubmitHandler.tsx
+const RhfUtilsFormWithSubmitHandler_Internal = ({ getApiData, onSubmitInvalid, onBeforeSubmitInvariants, onBeforeSubmit, onSubmit, onSubmitSuccess, onSubmitError, onSubmitFinally, form, className, children }) => {
+	const rhfContext = useFormContext();
+	const utils = useRhfUtilsContext();
+	const config = useRhfUtilsClientConfig();
+	const resolvedFormProps = useRhfUtilsFormResolvedFormProps(form, utils.formId, { className });
+	const handleSubmitValid = async (data, event) => {
+		const datas = {
+			input: rhfContext.getValues(),
+			output: data,
+			api: getApiData?.(data)
+		};
+		const context = {
+			utils,
+			rhf: rhfContext,
+			FormSubmitError
+		};
+		const submitEvent = event;
+		if (onBeforeSubmitInvariants) await handleOnSubmitInvariants(onBeforeSubmitInvariants, datas, context, submitEvent);
+		await Promise.resolve(onBeforeSubmit?.(datas, context, submitEvent));
+		const submitResponse = await Promise.resolve(onSubmit?.(datas, context, submitEvent));
+		utils.lastSubmitStateRef.current = "success";
+		await Promise.resolve(onSubmitSuccess?.(submitResponse, datas, context, submitEvent));
+	};
+	function handleSubmitError(error, event) {
+		const formSubmitErrors = error instanceof FormSubmitError ? error.errors : config.onSubmitErrorUnknown?.(error);
+		if (formSubmitErrors) setCtxErrorsByFormSubmitFieldErrors(rhfContext, formSubmitErrors);
+		onSubmitError?.(error, {
+			utils,
+			errors: formSubmitErrors,
+			rhf: rhfContext
+		}, event);
+	}
+	const handleSubmit = useRhfUtilsFormHandleSubmit_Internal({
+		onValid: handleSubmitValid,
+		onInvalid: onSubmitInvalid,
+		onError: handleSubmitError,
+		onFinally: onSubmitFinally
+	});
+	const Outlet = React.useCallback(() => children, []);
+	/** FormComponent props -- general, non-form-, non-schema-specific. */
+	const formInjectorProps = {
+		...utils,
+		rhf: rhfContext,
+		Controller: _Controller,
+		FormSubmitError,
+		Outlet
+	};
+	return /* @__PURE__ */ jsx(config.FormComponent ?? "form", {
+		...resolvedFormProps,
+		id: utils.formId,
+		ref: utils.formRef,
+		onSubmit: handleSubmit,
+		children: config.FormInjector ? /* @__PURE__ */ jsx(config.FormInjector, { ...formInjectorProps }) : children
+	});
+};
+const handleOnSubmitInvariants = async (onBeforeSubmitInvariants, data, context, event) => {
+	const falseyFieldsAndMessages = (await Promise.resolve(onBeforeSubmitInvariants(data, context, event))).filter(({ validate }) => !validate).map(({ field, message }) => [field, { message }]);
+	if (!falseyFieldsAndMessages.length) return;
+	throw new context.FormSubmitError(Object.fromEntries(falseyFieldsAndMessages));
+};
+//#endregion
+//#region src/form/with-handlers-and-children/RhfUtilsForm.tsx
+const RhfUtilsForm = ({ getApiData, onCancel, onSubmitInvalid, onBeforeSubmitInvariants, onBeforeSubmit, onSubmit, onSubmitSuccess, onSubmitError, onSubmitFinally, Children, form, className }) => /* @__PURE__ */ jsxs(RhfUtilsFormWithSubmitHandler_Internal, {
+	getApiData,
+	onSubmitInvalid,
+	onBeforeSubmitInvariants,
+	onBeforeSubmit,
+	onSubmit,
+	onSubmitSuccess,
+	onSubmitError,
+	onSubmitFinally,
+	form,
+	className,
+	children: [/* @__PURE__ */ jsx(LazyDevToolViaProviders, {}), /* @__PURE__ */ jsx(RhfUtilsFormChildrenViaProviders_Internal, {
+		onCancel,
+		Children
+	})]
+});
+//#endregion
+//#region src/resolvers/zod/form/RhfUtilsZodForm.tsx
+const RhfUtilsZodForm = (props) => /* @__PURE__ */ jsx(RhfUtilsForm, { ...props });
+//#endregion
+//#region src/errors/flat/filterFlatFieldErrors.ts
+/**
+* Filter {@link FlatFieldErrors} by a predicate.
+*
+* (Encapsulates to and from Object entries.)
+*/
+const makeFlatFieldErrorsFilter = (predicate) => (errors) => Object.fromEntries(Object.entries(errors).filter(predicate));
+//#endregion
+//#region src/errors/isFieldErrorRefd.ts
+/**
+* Determine if {@link FieldError} is a `ref`'d field error.
+*/
+const isFieldErrorRefd = (error) => !!error.ref;
+//#endregion
+//#region src/errors/isFlatFieldErrorEntryRefd.ts
+/**
+* Determine if {@link FieldError} is a `ref`'d field error.
+*/
+const isFlatFieldErrorEntryRefd = ([, error]) => isFieldErrorRefd(error);
+//#endregion
+//#region src/errors/getRefdFromFlatFieldErrors.ts
+const getRefdFromFlatFieldErrors = makeFlatFieldErrorsFilter(isFlatFieldErrorEntryRefd);
+//#endregion
+//#region src/errors/nonfield/RhfUtilsNonFieldErrorMarker.utils.ts
+/**
+* Returns query selector for matching non-field error marker.
+* By default includes nested field matching. (See `options.excludeNested`.)
+*
+* @returns One or more selectors in a comma-separated list.
+*/
+const getRhfUtilsNonFieldErrorMarkerQuerySelector = (path, options) => {
+	return [["", ""], ...options?.excludeNested ? [] : [["^", "."]]].map(([attrSuffix, pathSuffix]) => _getQuerySelector(RhfUtilsNonFieldErrorMarkerHtmlAttribute + attrSuffix, path + pathSuffix)).join(", ");
+};
+const _getQuerySelector = (attr, value) => `[role="alert"][${attr}="${value}"]`;
+//#endregion
+//#region src/errors/nonfield/isNonFieldErrorMarkerInDOM.ts
+/**
+* Determine if a non-field error marker is in the DOM.
+* Note: this will also look for nested markers to accommodate field arrays
+*/
+const isNonFieldErrorMarkerInDOM = (path, parentElement) => !!parentElement.querySelector(getRhfUtilsNonFieldErrorMarkerQuerySelector(path));
+//#endregion
+//#region src/errors/root/isFormErrorPathRoot.ts
+/**
+* Determine if an error path is root. (e.g., `root` or `root.nested`)
+*
+* @param path Flat path. (e.g., 'root.nested')
+*/
+const isFormErrorPathRoot = (path) => path === "root" || path.startsWith("root.");
+//#endregion
+//#region src/errors/orphan/isOrphanFormError.ts
+const isOrphanFormError = (path, error, parentElement) => !isFieldErrorRefd(error) && !isFormErrorPathRoot(path) && !isNonFieldErrorMarkerInDOM(path, parentElement);
+//#endregion
+//#region src/errors/orphan/getIsOrphanFormErrorWithParentElement.ts
+/**
+* Util wrapper for {@link isOrphanFormError} for usage with {@link FlatFieldErrorEntry}.
+*/
+const getIsFlatFieldErrorEntryOrphanByParentElement = (parentElement) => ([path, error]) => isOrphanFormError(path, error, parentElement);
+//#endregion
+//#region src/errors/orphan/getOrphansFromFlatFieldErrors.ts
+const getOrphansFromFlatFieldErrors = (errors, parentElement) => makeFlatFieldErrorsFilter(getIsFlatFieldErrorEntryOrphanByParentElement(parentElement))(errors);
+//#endregion
+//#region src/errors/root/isFlatFieldErrorEntryPathRoot.ts
+/**
+* Util wrapper for {@link isFormErrorPathRoot} for usage with {@link FlatFieldErrorEntry}.
+*/
+const isFlatFieldErrorEntryPathRoot = ([path]) => isFormErrorPathRoot(path);
+//#endregion
+//#region src/errors/root/getRootsFromFlatFieldErrors.ts
+const getRootsFromFlatFieldErrors = makeFlatFieldErrorsFilter(isFlatFieldErrorEntryPathRoot);
+//#endregion
+//#region src/errors/flat/context/FlatFieldErrorsContextProvider.tsx
+/**
+* Provides a flattened version of the form errors.
+* Allows flattening and filtering to happen once per errors change.
+*/
+const FlatFieldErrorsContextProvider = ({ formRef, children }) => {
+	const { errors } = useFormState();
+	const all = getFlatFieldErrors(errors);
+	const orphans = formRef.current ? getOrphansFromFlatFieldErrors(all, formRef.current) : {};
+	return /* @__PURE__ */ jsx(_FormErrorsFlatContextProvider, {
+		value: {
+			all,
+			fields: getRefdFromFlatFieldErrors(all),
+			roots: getRootsFromFlatFieldErrors(all),
+			orphans,
+			hasErrors: !isEmptyObject(errors),
+			hasOrphans: !isEmptyObject(orphans)
+		},
+		children
+	});
+};
+//#endregion
+//#region src/submit/last-error/LastSubmitErrorContextProvider.tsx
+const LastSubmitErrorContextProvider = ({ children }) => {
+	const [lastSubmit, setLastSubmit] = React.useState(void 0);
+	return /* @__PURE__ */ jsx(_LastSubmitErrorContextProvider, {
+		value: {
+			current: lastSubmit,
+			reset: () => {
+				setLastSubmit(void 0);
+			},
+			set: (error, event) => {
+				setLastSubmit({
+					error,
+					event
+				});
+			}
+		},
+		children
+	});
+};
+//#endregion
+//#region src/errors/output/consoleErrors.ts
+/**
+* Output form values and errors to console.
+*/
+const consoleErrors = (message, values, errors, type = "debug") => {
+	console[type](message, {
+		values,
+		errors
+	});
+};
+//#endregion
+//#region src/errors/flat/context/useFlatFieldErrorsContextOutput.ts
+/**
+* Outputs (e.g., console, throw) errors based on config.
+*/
+const useFlatFieldErrorsContextOutput = (config) => {
+	const form = useFormContext();
+	const errors = useFlatFieldErrorsContext();
+	React.useEffect(() => {
+		if (!errors.hasErrors) return;
+		const console = config?.console?.(errors);
+		if (console) consoleErrors(console.message ?? defaultMessage, form.getValues(), errors, console.type);
+		const _throw = config?.throw?.(errors);
+		if (_throw) throw new Error(typeof _throw === "string" ? _throw : defaultMessage);
+	}, [errors]);
+};
+const defaultMessage = "Form errors";
+//#endregion
+//#region src/utils/useRefIfValueWasTrue.ts
+const useRefIfValueWasTrue = (value) => {
+	const hasBooleanChanged = React.useRef(false);
+	React.useEffect(() => {
+		if (!value) return;
+		hasBooleanChanged.current = true;
+	}, [value]);
+	const reset = () => {
+		hasBooleanChanged.current = false;
+	};
+	return [hasBooleanChanged, reset];
+};
+//#endregion
+//#region src/submit/useFormOnSubmitted.ts
+const useFormOnSubmitted = (callback, options) => {
+	const { isSubmitSuccessful, isSubmitting } = useFormState();
+	const [wasSubmitting, resetWasSubmitting] = useRefIfValueWasTrue(isSubmitting);
+	React.useEffect(() => {
+		if (!callback) return;
+		if (isSubmitting) return;
+		if (!wasSubmitting.current) return;
+		resetWasSubmitting();
+		if (options?.successful === void 0 || isSubmitSuccessful === options.successful) callback(isSubmitSuccessful);
+	}, [isSubmitting]);
+};
+//#endregion
+//#region src/submit/useResetFormOnSubmitted.ts
+/**
+* Control resetting of values and (some) state (e.g., `isDirty`) after form submitted.
+*
+* `isDirty` and other state is reset, but submit-related state is preserved, as well as errors.
+*
+* Use cases:
+* - on success:
+*   - `defaults`: reset current values to defaults (e.g., clear form)
+*   - `current`: reset defaults to current values (e.g., keep values)
+* - on error:
+*   - reset current values to default values (e.g., submitOnChange reset)
+*
+* See `Rules` section: https://react-hook-form.com/api/useform/reset/
+* Specifically: "- It's recommended to reset inside useEffect after submission."
+*/
+const useResetFormOnSubmitted = (options) => {
+	const { getValues, reset } = useFormContext();
+	useFormOnSubmitted((success) => {
+		if (!options) return;
+		const whichValues = options[success ? "success" : "error"]?.values;
+		if (!whichValues) return;
+		const keepValues = whichValues === "current";
+		reset(keepValues ? getValues() : void 0, {
+			keepIsSubmitSuccessful: true,
+			keepIsSubmitted: true,
+			keepSubmitCount: true,
+			/**
+			* This is necessary when setting default values to current values (lest form stop updating).
+			*
+			* Technically, we are keeping values and resetting default values to same values.
+			*
+			* Steps to repro:
+			* - RhfUtilsClientConfig with resetOnSubmitted set to success values to current
+			* - remove `keepValues` prop from reset
+			* - create valid form, submit
+			* - form values should be unchanged
+			* - unexpectedly: can no longer type into input
+			*/
+			keepValues,
+			keepErrors: true
+		});
+	});
+};
+//#endregion
+//#region src/utils/useIsFirstRender.ts
+/**
+* Use to determine if first render has run.
+*
+* (Supports strict mode.)
+*/
+const useIsFirstRender = () => {
+	const isFirstRender = React.useRef(DEFAULT_STATE);
+	React.useEffect(() => {
+		if (isFirstRender.current) isFirstRender.current = !DEFAULT_STATE;
+		return () => {
+			isFirstRender.current = DEFAULT_STATE;
+		};
+	}, []);
+	return isFirstRender;
+};
+const DEFAULT_STATE = true;
+//#endregion
+//#region src/utils/useDebouncedOnChangeValue.ts
+/**
+* React hook to debounce onChange event callback.
+*
+* Returns debounced state setter (uses ref internally).
+*
+* When debounce delay has elapsed after setting value,
+* onChange callback is called with latest value.
+*
+* @returns `[setValueDebounced]`
+*/
+const useDebouncedOnChangeValue = ({ onChange, delay }) => {
+	/**
+	* State. (Via ref as it should not re-render.)
+	*/
+	const state = React.useRef(null);
+	/** Callback for `setTimeout`. */
+	const _onTimeout = () => {
+		if (!state.current) return;
+		onChange(state.current.value);
+		state.current = null;
+	};
+	const _clearTimeout = () => {
+		if (state.current) clearTimeout(state.current.timer);
+	};
+	React.useEffect(() => _clearTimeout, []);
+	const setValueDebounced = (value) => {
+		_clearTimeout();
+		state.current = {
+			value,
+			timer: setTimeout(_onTimeout, delay)
+		};
+	};
+	return [setValueDebounced];
+};
+//#endregion
+//#region src/submit/useSubmitFormOnEvent.ts
+/**
+* Internal, shared hook to setup debounced callback for OnChange hooks.
+*/
+const useSubmitFormOnEventDebounced = (formRef, options) => {
+	const requestSubmit = useFormRequestSubmit(formRef);
+	const [setOnChangeDebounced] = useDebouncedOnChangeValue({
+		delay: options?.debounce ?? 0,
+		onChange: () => {
+			requestSubmit();
+		}
+	});
+	return setOnChangeDebounced;
+};
+//#endregion
+//#region src/submit/useSubmitFormOnWatch.ts
+/**
+* Watches for changes in form values.
+*
+* Caveats:
+* - uses RHF's useWatch
+* - triggers change immediately as user types, so use sensible debounce time
+* - does not cover uncontrolled inputs
+*/
+const useSubmitFormOnWatch = (formRef, options) => {
+	const setOnChangeDebounced = useSubmitFormOnEventDebounced(formRef, { debounce: options?.debounce });
+	const watch = useWatch();
+	const { isValid, isDirty, isValidating, isSubmitting } = useFormState();
+	/**
+	* In some cases, {@link watch} reference object can change,
+	* even when no input has been made by user.
+	*/
+	const watchJson = React.useMemo(() => JSON.stringify(watch), [watch]);
+	const isFirstRender = useIsFirstRender();
+	React.useEffect(() => {
+		if (isFirstRender.current) return;
+		if (isValidating) return;
+		if (isSubmitting) return;
+		if (!isValid) return;
+		if (!isDirty) return;
+		setOnChangeDebounced(watch);
+	}, [
+		isValid,
+		isDirty,
+		watchJson,
+		isValidating
+	]);
+};
+//#endregion
+//#region src/form/context/utils/RhfUtilsContextProvider.tsx
+const RhfUtilsContextProvider = ({ formId, formRef, options, children }) => {
+	const [memoOptions] = React.useState(options);
+	useFlatFieldErrorsContextOutput(useRhfUtilsClientConfig().fieldErrors?.output);
+	(memoOptions.submitOnWatch ? useSubmitFormOnWatch : void 0)?.(formRef, memoOptions.submitOnWatch);
+	useResetFormOnSubmitted(memoOptions.resetOnSubmitted);
+	return /* @__PURE__ */ jsx(_RhfUtilsContextProvider, {
+		value: {
+			formId,
+			formRef,
+			options,
+			lastSubmitStateRef: React.useRef(null)
+		},
+		children
+	});
+};
+//#endregion
+//#region src/form/options/getRhfUtilsFormResolvedOptions.ts
+const getRhfUtilsFormResolvedOptions = (global, instance) => ({
+	...global,
+	...instance,
+	...(global?.resetOnSubmitted || instance?.resetOnSubmitted) && { resetOnSubmitted: {
+		...global?.resetOnSubmitted,
+		...instance?.resetOnSubmitted
+	} }
+});
+//#endregion
+//#region src/form/options/useRhfUtilsFormResolvedOptions.ts
+const useRhfUtilsFormResolvedOptions = (config, options) => React.useMemo(() => getRhfUtilsFormResolvedOptions(config.defaults?.options, options), [JSON.stringify(options)]);
+//#endregion
+//#region src/form/rhf/getRhfUtilsFormResolvedRhfProps.ts
+const getRhfUtilsFormResolvedRhfProps = (global, instance) => ({
+	...global,
+	...instance
+});
+//#endregion
+//#region src/form/rhf/useRhfFormWithResolvedProps.ts
+const useRhfFormWithResolvedProps = (props, config, defaultValues, resolver) => useForm({
+	...getRhfUtilsFormResolvedRhfProps(config.defaults?.rhf, props),
+	resolver,
+	defaultValues
+});
+//#endregion
+//#region src/form/providers/RhfUtilsFormProviders.tsx
+function RhfUtilsFormProviders({ formId, rhf, resolver, defaultValues, options, relay, children }) {
+	const config = useRhfUtilsClientConfig();
+	const reactId = React.useId();
+	const id = formId || reactId;
+	const formRef = React.useRef(null);
+	const resolvedRhf = useRhfFormWithResolvedProps(rhf, config, defaultValues, resolver);
+	const resolvedOptions = useRhfUtilsFormResolvedOptions(config, options);
+	return /* @__PURE__ */ jsx(FormProvider, {
+		...resolvedRhf,
+		children: /* @__PURE__ */ jsx(FlatFieldErrorsContextProvider, {
+			formRef,
+			children: /* @__PURE__ */ jsxs(RhfUtilsContextProvider, {
+				formId: id,
+				formRef,
+				options: resolvedOptions,
+				children: [/* @__PURE__ */ jsx(FormRelaySetter, { options: relay }), /* @__PURE__ */ jsx(LastSubmitErrorContextProvider, { children })]
+			})
+		})
+	});
+}
+//#endregion
+//#region src/resolvers/zod/getZodResolver.ts
+const getZodResolver = (schema) => zodResolver(schema);
+//#endregion
+//#region src/resolvers/zod/providers/RhfUtilsZodFormProviders.tsx
+const RhfUtilsZodFormProviders = ({ schema, children, ...props }) => /* @__PURE__ */ jsx(RhfUtilsFormProviders, {
+	...props,
+	resolver: getZodResolver(schema),
+	children
+});
+//#endregion
+//#region src/form/with-providers/RhfUtilsFormWithProviders.tsx
+/**
+* Form providers (with utils) with immediate descendent {@link RhfUtilsForm}.
+* (Syntactic sugar for {@link useRhfUtilsForm}. Use this for most applications.)
+*/
+function RhfUtilsFormWithProviders({ getApiData, resolver, rhf, defaultValues, options, relay, onCancel, onSubmitInvalid, onBeforeSubmitInvariants, onBeforeSubmit, onSubmit, onSubmitSuccess, onSubmitError, onSubmitFinally, Children, form, formId, className }) {
+	const providerProps = {
+		formId,
+		resolver,
+		rhf,
+		defaultValues,
+		options,
+		relay
+	};
+	const formProps = {
+		getApiData,
+		onCancel,
+		onSubmitInvalid,
+		onBeforeSubmitInvariants,
+		onBeforeSubmit,
+		onSubmit,
+		onSubmitSuccess,
+		onSubmitError,
+		onSubmitFinally,
+		Children,
+		form,
+		className
+	};
+	return /* @__PURE__ */ jsx(RhfUtilsFormProviders, {
+		...providerProps,
+		children: /* @__PURE__ */ jsx(RhfUtilsForm, { ...formProps })
+	});
+}
+//#endregion
+//#region src/resolvers/zod/with-providers/RhfUtilsZodFormWithProviders.tsx
+const RhfUtilsZodFormWithProviders = ({ schema, ...props }) => /* @__PURE__ */ jsx(RhfUtilsFormWithProviders, {
+	...props,
+	resolver: getZodResolver(schema)
+});
+//#endregion
+//#region src/_exports/index.ts
+/**
+* @license @paragrav/rhf-utils
+*
+* Copyright (c) 2024-present paragrav.dev
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+//#endregion
+export { FormSubmitError, RhfUtilsClientConfigProvider, RhfUtilsNonFieldErrorMarker, RhfUtilsZodForm, RhfUtilsZodFormProviders, RhfUtilsZodFormWithProviders, useFlatFieldErrorsContext, useFlatFieldErrorsContextHasOnlyOrphans, useFormRequestSubmit, useLastSubmitError, useRhfUtilsContext };