@povio/ui 3.4.0-rc.19 → 3.4.0-rc.20

package/dist/useFormAutosave-BXqu0xAQ.js

@@ -0,0 +1,296 @@
+import { a as isEqual, o as ObjectUtils } from "./uiConfig.context-SBtRegKv.js";
+import { t as ZodArray } from "./schemas-BkfyFvBp.js";
+import { t as StringUtils } from "./string.utils-BPgv6QwA.js";
+import { t as ZodUtils } from "./zod.utils-Nz_Tbo_v.js";
+import { n as getDefaultInputComponentType } from "./dynamicInputs-D8j0ko24.js";
+import { t as InputItem } from "./InputItem-DYNprOmw.js";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { c } from "react/compiler-runtime";
+import { jsx } from "react/jsx-runtime";
+import { useForm, useStore } from "@tanstack/react-form";
+//#region src/components/inputs/Inputs/Form.tsx
+const createFieldComponent = (field, schemaKeyType, form) => {
+	return function FieldComponent({ inputType, label, placeholder, ...inputProps }) {
+		const inputDef = {
+			name: field,
+			type: inputType ?? getDefaultInputComponentType(schemaKeyType),
+			label,
+			placeholder,
+			props: {
+				...ZodUtils.unwrapZodType(schemaKeyType) instanceof ZodArray ? { selectionMode: "multiple" } : {},
+				...inputProps
+			}
+		};
+		return /* @__PURE__ */ jsx(InputItem, {
+			form,
+			inputDef
+		});
+	};
+};
+function Form({ form, schema, onSubmit, onError, className, children }) {
+	const components = useMemo(() => {
+		const fieldComponents = {};
+		const fields = Object.keys(schema.shape);
+		for (const field of fields) {
+			const componentName = StringUtils.capitalize(String(field));
+			const schemaKeyType = schema.shape[field];
+			fieldComponents[componentName] = createFieldComponent(field, schemaKeyType, form);
+		}
+		return fieldComponents;
+	}, [schema.shape, form]);
+	return /* @__PURE__ */ jsx("form", {
+		onSubmit: form.handleSubmit(onSubmit, onError),
+		className,
+		children: children(components)
+	});
+}
+//#endregion
+//#region src/hooks/useAutosave.ts
+function diffLeftOnly(left, right) {
+	if (!ObjectUtils.isObject(left) || ObjectUtils.isDate(left) || ObjectUtils.isRegExp(left)) return isEqual(left, right) ? void 0 : left;
+	if (Array.isArray(left)) return isEqual(left, right) ? void 0 : left;
+	const result = Object.entries(left).reduce((acc, [key, value]) => {
+		const diff = diffLeftOnly(value, right?.[key]);
+		if (diff !== void 0 && (!ObjectUtils.isObject(diff) || !ObjectUtils.isEmpty(diff))) acc[key] = diff;
+		return acc;
+	}, {});
+	return ObjectUtils.isEmpty(result) ? void 0 : result;
+}
+const snapshot = (value) => structuredClone(value);
+function pickChangedValues(source, changes) {
+	if (!ObjectUtils.isObject(changes) || Array.isArray(changes)) return source;
+	return Object.entries(changes).reduce((result, [key, value]) => {
+		result[key] = pickChangedValues(source?.[key], value);
+		return result;
+	}, {});
+}
+function useAutosave({ form, delay = 500, enabled = true, trigger = "change", onSave, onSaveSuccess }) {
+	const timeoutRef = useRef(void 0);
+	const savedSnapshotRef = useRef(snapshot(form.state.values));
+	const saveQueueRef = useRef(Promise.resolve());
+	const latestSaveRef = useRef({
+		onSave,
+		onSaveSuccess
+	});
+	latestSaveRef.current = {
+		onSave,
+		onSaveSuccess
+	};
+	useEffect(() => {
+		const clearPending = () => {
+			if (timeoutRef.current) {
+				clearTimeout(timeoutRef.current);
+				timeoutRef.current = void 0;
+			}
+		};
+		const queueSave = () => {
+			if (!enabled) return;
+			clearPending();
+			timeoutRef.current = setTimeout(() => {
+				saveQueueRef.current = saveQueueRef.current.then(async () => {
+					const valuesAtSaveTime = snapshot(form.state.values);
+					const changedValues = diffLeftOnly(valuesAtSaveTime, savedSnapshotRef.current);
+					if (!changedValues) return;
+					let transformedValues;
+					try {
+						transformedValues = form.parseValues(valuesAtSaveTime);
+					} catch {
+						return;
+					}
+					const payload = pickChangedValues(transformedValues, changedValues);
+					if (ObjectUtils.isEmpty(payload)) return;
+					try {
+						await latestSaveRef.current.onSave(payload);
+						savedSnapshotRef.current = valuesAtSaveTime;
+						for (const name of Object.keys(payload)) form.setFieldMeta(name, (meta) => ({
+							...meta,
+							isDirty: false
+						}));
+						latestSaveRef.current.onSaveSuccess?.();
+					} catch {}
+				});
+			}, delay);
+		};
+		const unsubscribeStore = trigger === "change" ? form.store.subscribe(() => {
+			if (!isEqual(form.state.values, savedSnapshotRef.current)) queueSave();
+		}) : void 0;
+		const unsubscribeBlur = trigger === "blur" ? form.subscribeBlur(queueSave) : void 0;
+		return () => {
+			clearPending();
+			unsubscribeStore?.unsubscribe();
+			unsubscribeBlur?.();
+		};
+	}, [
+		delay,
+		enabled,
+		form,
+		trigger
+	]);
+}
+//#endregion
+//#region src/hooks/useForm.ts
+function useForm$1({ defaultValues, disabled = false, mode = "onSubmit", onSubmitAsync, zodSchema } = {}) {
+	const submitHandlerRef = useRef(() => void 0);
+	const submitErrorHandlerRef = useRef(void 0);
+	const blurListenersRef = useRef(/* @__PURE__ */ new Set());
+	const fieldValidators = useMemo(() => {
+		return /* @__PURE__ */ new Map();
+	}, [mode, zodSchema]);
+	const formValidator = useMemo(() => {
+		if (!zodSchema) return;
+		return ({ value }) => {
+			const result = zodSchema.safeParse(value);
+			if (result.success) return;
+			return { fields: Object.fromEntries(result.error.issues.map((issue) => [pathToString(issue.path), issue.message])) };
+		};
+	}, [zodSchema]);
+	const form = useForm({
+		defaultValues: (typeof defaultValues === "function" ? {} : defaultValues) ?? {},
+		validators: formValidator || onSubmitAsync ? {
+			onSubmit: formValidator,
+			onSubmitAsync
+		} : void 0,
+		onSubmit: async ({ value: value_0 }) => {
+			const transformed = zodSchema ? zodSchema.parse(value_0) : value_0;
+			await submitHandlerRef.current(transformed);
+		},
+		onSubmitInvalid: ({ value: value_1, formApi }) => {
+			submitErrorHandlerRef.current?.(formApi.state.errors, value_1);
+		}
+	});
+	const originalHandleSubmit = useMemo(() => form.handleSubmit.bind(form), [form]);
+	const uiForm = form;
+	Object.defineProperties(uiForm, { disabled: {
+		configurable: true,
+		get: () => disabled
+	} });
+	uiForm.getFieldValidators = (name) => {
+		const cached = fieldValidators.get(name);
+		if (cached || fieldValidators.has(name)) return cached;
+		const schema = zodSchema ? getSchemaAtPath(zodSchema, name) : void 0;
+		if (!schema || mode === "onSubmit") {
+			fieldValidators.set(name, void 0);
+			return;
+		}
+		const validate = ({ value: value_2 }) => {
+			const result_0 = schema.safeParse(value_2);
+			return result_0.success ? void 0 : result_0.error.issues[0]?.message;
+		};
+		const validators = mode === "onChange" || mode === "all" ? { onChange: validate } : { onBlur: validate };
+		fieldValidators.set(name, validators);
+		return validators;
+	};
+	uiForm.notifyBlur = (name_0) => {
+		for (const listener of blurListenersRef.current) listener(name_0);
+	};
+	uiForm.parseValues = (values) => zodSchema ? zodSchema.parse(values) : values;
+	uiForm.subscribeBlur = (listener_0) => {
+		blurListenersRef.current.add(listener_0);
+		return () => blurListenersRef.current.delete(listener_0);
+	};
+	uiForm.handleSubmit = (onValid, onInvalid) => async (event) => {
+		event?.preventDefault?.();
+		event?.stopPropagation?.();
+		submitHandlerRef.current = onValid;
+		submitErrorHandlerRef.current = onInvalid;
+		await originalHandleSubmit();
+	};
+	useEffect(() => {
+		if (typeof defaultValues === "function") defaultValues().then((values_0) => form.reset(values_0));
+	}, [defaultValues, form]);
+	return uiForm;
+}
+const useFormValue = (form, selector) => {
+	const $ = c(2);
+	let t0;
+	if ($[0] !== selector) {
+		t0 = (state) => selector(state.values);
+		$[0] = selector;
+		$[1] = t0;
+	} else t0 = $[1];
+	return useStore(form.store, t0);
+};
+const useFormState = (form, selector) => {
+	return useStore(form.store, selector);
+};
+const getSchemaAtPath = (rootSchema, path) => {
+	let schema = rootSchema;
+	for (const segment of parsePath(path)) {
+		while (schema?.unwrap && !schema.shape && !schema.element && !schema.items) schema = schema.unwrap();
+		schema = typeof segment === "number" ? schema?.element ?? schema?.items?.[segment] : schema?.shape?.[segment];
+		if (!schema) return;
+	}
+	return schema;
+};
+const parsePath = (path) => path.replaceAll("[", ".").replaceAll("]", "").split(".").filter(Boolean).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+const pathToString = (path) => path.reduce((result, segment) => typeof segment === "number" ? `${result}[${segment}]` : result ? `${result}.${String(segment)}` : String(segment), "");
+//#endregion
+//#region src/hooks/useFormAutosave.ts
+const getResetTimeoutErrorMessage = (resetTimeout) => `Form Reset Timeout (${resetTimeout}ms) - Action Required
+Problem: Form values weren't reset after submission.
+
+Likely causes:
+• Missing variables in reset dependency array
+• Reset dependencies not updating after form save
+• Async operations blocking timely reset
+
+Solutions:
+1. Ensure reset dependencies include all relevant state variables
+2. Confirm your submission handler updates state properly (check query invalidation)
+3. For slower operations, consider increasing the timeout threshold`;
+function useFormAutosave({ autosaveDelay, enableAutosave, autosaveOn = "change", normalizeAutosaveData, onAutosave, getResetValues, resetDeps, resetTimeout = 5e3, ...props }) {
+	const form = useForm$1({
+		...props,
+		defaultValues: getResetValues()
+	});
+	const shouldResetFormValuesRef = useRef(false);
+	const resetFormValuesTimeoutRef = useRef(void 0);
+	useEffect(() => {
+		const resetValues = getResetValues();
+		if (resetValues === void 0) return;
+		const resetFormValues = async () => {
+			const keepCurrentValues = shouldResetFormValuesRef.current;
+			shouldResetFormValuesRef.current = false;
+			let values;
+			if (ObjectUtils.isFunction(resetValues)) values = await resetValues();
+			else values = resetValues;
+			form.reset(keepCurrentValues ? {
+				...values,
+				...form.state.values
+			} : values);
+		};
+		resetFormValues();
+	}, [...resetDeps]);
+	const prepareForSaveReset = () => {
+		shouldResetFormValuesRef.current = true;
+		if (resetFormValuesTimeoutRef.current) clearTimeout(resetFormValuesTimeoutRef.current);
+		resetFormValuesTimeoutRef.current = setTimeout(() => {
+			if (shouldResetFormValuesRef.current) throw new Error(getResetTimeoutErrorMessage(resetTimeout));
+		}, resetTimeout);
+	};
+	useAutosave({
+		form,
+		delay: autosaveDelay,
+		enabled: enableAutosave,
+		trigger: autosaveOn,
+		onSave: useCallback(async (data) => {
+			const normalizedData = normalizeAutosaveData ? normalizeAutosaveData(data) : data;
+			if (!normalizedData || ObjectUtils.isEmpty(normalizedData)) return;
+			prepareForSaveReset();
+			try {
+				return await onAutosave(normalizedData);
+			} catch (error) {
+				shouldResetFormValuesRef.current = false;
+				if (resetFormValuesTimeoutRef.current) clearTimeout(resetFormValuesTimeoutRef.current);
+				throw error;
+			}
+		}, [
+			normalizeAutosaveData,
+			onAutosave,
+			resetTimeout
+		])
+	});
+	return form;
+}
+//#endregion
+export { useAutosave as a, useFormValue as i, useForm$1 as n, Form as o, useFormState as r, useFormAutosave as t };

package/dist/useFormReset-BhJH8XnS.js

@@ -0,0 +1,18 @@
+import { N as $8ae05eaa5c114e9c$export$7f54fc3180508a52 } from "./useHover-DwfnacVy.js";
+import { useEffect } from "react";
+//#region ../../node_modules/.bun/@react-aria+utils@3.33.0+67f6792bdf102c28/node_modules/@react-aria/utils/dist/useFormReset.mjs
+function $99facab73266f662$export$5add1d006293d136(ref, initialValue, onReset) {
+	let handleReset = $8ae05eaa5c114e9c$export$7f54fc3180508a52(() => {
+		if (onReset) onReset(initialValue);
+	});
+	useEffect(() => {
+		var _ref_current;
+		let form = ref === null || ref === void 0 ? void 0 : (_ref_current = ref.current) === null || _ref_current === void 0 ? void 0 : _ref_current.form;
+		form === null || form === void 0 || form.addEventListener("reset", handleReset);
+		return () => {
+			form === null || form === void 0 || form.removeEventListener("reset", handleReset);
+		};
+	}, [ref]);
+}
+//#endregion
+export { $99facab73266f662$export$5add1d006293d136 as t };

package/dist/useFormValidation-DLZqyNVp.js

@@ -0,0 +1,115 @@
+import { N as $8ae05eaa5c114e9c$export$7f54fc3180508a52, R as $3ef42575df84b30b$export$9d1611c77c2fe928, X as $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c, q as $bdb11010cef70236$export$b4cc09c592e8fdb8, u as $507fabe10e71c6fb$export$8397ddfc504fdb9a } from "./useHover-DwfnacVy.js";
+import { t as $d191a55c9702f145$export$8467354a121f1b9f } from "./useLabel-BFvzYK5u.js";
+import { useEffect, useRef } from "react";
+//#region ../../node_modules/.bun/@react-aria+label@3.7.24+67f6792bdf102c28/node_modules/@react-aria/label/dist/useField.mjs
+function $2baaea4c71418dea$export$294aa081a6c6f55d(props) {
+	let { description, errorMessage, isInvalid, validationState } = props;
+	let { labelProps, fieldProps } = $d191a55c9702f145$export$8467354a121f1b9f(props);
+	let descriptionId = $bdb11010cef70236$export$b4cc09c592e8fdb8([
+		Boolean(description),
+		Boolean(errorMessage),
+		isInvalid,
+		validationState
+	]);
+	let errorMessageId = $bdb11010cef70236$export$b4cc09c592e8fdb8([
+		Boolean(description),
+		Boolean(errorMessage),
+		isInvalid,
+		validationState
+	]);
+	fieldProps = $3ef42575df84b30b$export$9d1611c77c2fe928(fieldProps, { "aria-describedby": [
+		descriptionId,
+		errorMessageId,
+		props["aria-describedby"]
+	].filter(Boolean).join(" ") || void 0 });
+	return {
+		labelProps,
+		fieldProps,
+		descriptionProps: { id: descriptionId },
+		errorMessageProps: { id: errorMessageId }
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/@react-aria+form@3.1.4+67f6792bdf102c28/node_modules/@react-aria/form/dist/useFormValidation.mjs
+function $e93e671b31057976$export$b8473d3665f3a75a(props, state, ref) {
+	let { validationBehavior, focus } = props;
+	$f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(() => {
+		if (validationBehavior === "native" && (ref === null || ref === void 0 ? void 0 : ref.current) && !ref.current.disabled) {
+			let errorMessage = state.realtimeValidation.isInvalid ? state.realtimeValidation.validationErrors.join(" ") || "Invalid value." : "";
+			ref.current.setCustomValidity(errorMessage);
+			if (!ref.current.hasAttribute("title")) ref.current.title = "";
+			if (!state.realtimeValidation.isInvalid) state.updateValidation($e93e671b31057976$var$getNativeValidity(ref.current));
+		}
+	});
+	let isIgnoredReset = useRef(false);
+	let onReset = $8ae05eaa5c114e9c$export$7f54fc3180508a52(() => {
+		if (!isIgnoredReset.current) state.resetValidation();
+	});
+	let onInvalid = $8ae05eaa5c114e9c$export$7f54fc3180508a52((e) => {
+		var _ref_current;
+		if (!state.displayValidation.isInvalid) state.commitValidation();
+		let form = ref === null || ref === void 0 ? void 0 : (_ref_current = ref.current) === null || _ref_current === void 0 ? void 0 : _ref_current.form;
+		if (!e.defaultPrevented && ref && form && $e93e671b31057976$var$getFirstInvalidInput(form) === ref.current) {
+			var _ref_current1;
+			if (focus) focus();
+			else (_ref_current1 = ref.current) === null || _ref_current1 === void 0 || _ref_current1.focus();
+			$507fabe10e71c6fb$export$8397ddfc504fdb9a("keyboard");
+		}
+		e.preventDefault();
+	});
+	let onChange = $8ae05eaa5c114e9c$export$7f54fc3180508a52(() => {
+		state.commitValidation();
+	});
+	useEffect(() => {
+		let input = ref === null || ref === void 0 ? void 0 : ref.current;
+		if (!input) return;
+		let form = input.form;
+		let reset = form === null || form === void 0 ? void 0 : form.reset;
+		if (form) form.reset = () => {
+			isIgnoredReset.current = !window.event || window.event.type === "message" && window.event.target instanceof MessagePort;
+			reset === null || reset === void 0 || reset.call(form);
+			isIgnoredReset.current = false;
+		};
+		input.addEventListener("invalid", onInvalid);
+		input.addEventListener("change", onChange);
+		form === null || form === void 0 || form.addEventListener("reset", onReset);
+		return () => {
+			input.removeEventListener("invalid", onInvalid);
+			input.removeEventListener("change", onChange);
+			form === null || form === void 0 || form.removeEventListener("reset", onReset);
+			if (form) form.reset = reset;
+		};
+	}, [ref, validationBehavior]);
+}
+function $e93e671b31057976$var$getValidity(input) {
+	let validity = input.validity;
+	return {
+		badInput: validity.badInput,
+		customError: validity.customError,
+		patternMismatch: validity.patternMismatch,
+		rangeOverflow: validity.rangeOverflow,
+		rangeUnderflow: validity.rangeUnderflow,
+		stepMismatch: validity.stepMismatch,
+		tooLong: validity.tooLong,
+		tooShort: validity.tooShort,
+		typeMismatch: validity.typeMismatch,
+		valueMissing: validity.valueMissing,
+		valid: validity.valid
+	};
+}
+function $e93e671b31057976$var$getNativeValidity(input) {
+	return {
+		isInvalid: !input.validity.valid,
+		validationDetails: $e93e671b31057976$var$getValidity(input),
+		validationErrors: input.validationMessage ? [input.validationMessage] : []
+	};
+}
+function $e93e671b31057976$var$getFirstInvalidInput(form) {
+	for (let i = 0; i < form.elements.length; i++) {
+		let element = form.elements[i];
+		if (!element.validity.valid) return element;
+	}
+	return null;
+}
+//#endregion
+export { $2baaea4c71418dea$export$294aa081a6c6f55d as n, $e93e671b31057976$export$b8473d3665f3a75a as t };

package/dist/useFormValidationState-Bpry7Uk5.js

@@ -0,0 +1,142 @@
+import { createContext, useContext, useEffect, useMemo, useRef, useState } from "react";
+//#region ../../node_modules/.bun/@react-stately+form@3.2.3+83d5fd7b249dbeef/node_modules/@react-stately/form/dist/useFormValidationState.mjs
+const $e5be200c675c3b3a$export$aca958c65c314e6c = {
+	badInput: false,
+	customError: false,
+	patternMismatch: false,
+	rangeOverflow: false,
+	rangeUnderflow: false,
+	stepMismatch: false,
+	tooLong: false,
+	tooShort: false,
+	typeMismatch: false,
+	valueMissing: false,
+	valid: true
+};
+const $e5be200c675c3b3a$var$CUSTOM_VALIDITY_STATE = {
+	...$e5be200c675c3b3a$export$aca958c65c314e6c,
+	customError: true,
+	valid: false
+};
+const $e5be200c675c3b3a$export$dad6ae84456c676a = {
+	isInvalid: false,
+	validationDetails: $e5be200c675c3b3a$export$aca958c65c314e6c,
+	validationErrors: []
+};
+const $e5be200c675c3b3a$export$571b5131b7e65c11 = createContext({});
+const $e5be200c675c3b3a$export$a763b9476acd3eb = "__formValidationState" + Date.now();
+function $e5be200c675c3b3a$export$fc1a364ae1f3ff10(props) {
+	if (props[$e5be200c675c3b3a$export$a763b9476acd3eb]) {
+		let { realtimeValidation, displayValidation, updateValidation, resetValidation, commitValidation } = props[$e5be200c675c3b3a$export$a763b9476acd3eb];
+		return {
+			realtimeValidation,
+			displayValidation,
+			updateValidation,
+			resetValidation,
+			commitValidation
+		};
+	}
+	return $e5be200c675c3b3a$var$useFormValidationStateImpl(props);
+}
+function $e5be200c675c3b3a$var$useFormValidationStateImpl(props) {
+	let { isInvalid, validationState, name, value, builtinValidation, validate, validationBehavior = "aria" } = props;
+	if (validationState) isInvalid || (isInvalid = validationState === "invalid");
+	let controlledError = isInvalid !== void 0 ? {
+		isInvalid,
+		validationErrors: [],
+		validationDetails: $e5be200c675c3b3a$var$CUSTOM_VALIDITY_STATE
+	} : null;
+	let clientError = useMemo(() => {
+		if (!validate || value == null) return null;
+		return $e5be200c675c3b3a$var$getValidationResult($e5be200c675c3b3a$var$runValidate(validate, value));
+	}, [validate, value]);
+	if (builtinValidation === null || builtinValidation === void 0 ? void 0 : builtinValidation.validationDetails.valid) builtinValidation = void 0;
+	let serverErrors = useContext($e5be200c675c3b3a$export$571b5131b7e65c11);
+	let serverErrorMessages = useMemo(() => {
+		if (name) return Array.isArray(name) ? name.flatMap((name) => $e5be200c675c3b3a$var$asArray(serverErrors[name])) : $e5be200c675c3b3a$var$asArray(serverErrors[name]);
+		return [];
+	}, [serverErrors, name]);
+	let [lastServerErrors, setLastServerErrors] = useState(serverErrors);
+	let [isServerErrorCleared, setServerErrorCleared] = useState(false);
+	if (serverErrors !== lastServerErrors) {
+		setLastServerErrors(serverErrors);
+		setServerErrorCleared(false);
+	}
+	let serverError = useMemo(() => $e5be200c675c3b3a$var$getValidationResult(isServerErrorCleared ? [] : serverErrorMessages), [isServerErrorCleared, serverErrorMessages]);
+	let nextValidation = useRef($e5be200c675c3b3a$export$dad6ae84456c676a);
+	let [currentValidity, setCurrentValidity] = useState($e5be200c675c3b3a$export$dad6ae84456c676a);
+	let lastError = useRef($e5be200c675c3b3a$export$dad6ae84456c676a);
+	let commitValidation = () => {
+		if (!commitQueued) return;
+		setCommitQueued(false);
+		let error = clientError || builtinValidation || nextValidation.current;
+		if (!$e5be200c675c3b3a$var$isEqualValidation(error, lastError.current)) {
+			lastError.current = error;
+			setCurrentValidity(error);
+		}
+	};
+	let [commitQueued, setCommitQueued] = useState(false);
+	useEffect(commitValidation);
+	return {
+		realtimeValidation: controlledError || serverError || clientError || builtinValidation || $e5be200c675c3b3a$export$dad6ae84456c676a,
+		displayValidation: validationBehavior === "native" ? controlledError || serverError || currentValidity : controlledError || serverError || clientError || builtinValidation || currentValidity,
+		updateValidation(value) {
+			if (validationBehavior === "aria" && !$e5be200c675c3b3a$var$isEqualValidation(currentValidity, value)) setCurrentValidity(value);
+			else nextValidation.current = value;
+		},
+		resetValidation() {
+			let error = $e5be200c675c3b3a$export$dad6ae84456c676a;
+			if (!$e5be200c675c3b3a$var$isEqualValidation(error, lastError.current)) {
+				lastError.current = error;
+				setCurrentValidity(error);
+			}
+			if (validationBehavior === "native") setCommitQueued(false);
+			setServerErrorCleared(true);
+		},
+		commitValidation() {
+			if (validationBehavior === "native") setCommitQueued(true);
+			setServerErrorCleared(true);
+		}
+	};
+}
+function $e5be200c675c3b3a$var$asArray(v) {
+	if (!v) return [];
+	return Array.isArray(v) ? v : [v];
+}
+function $e5be200c675c3b3a$var$runValidate(validate, value) {
+	if (typeof validate === "function") {
+		let e = validate(value);
+		if (e && typeof e !== "boolean") return $e5be200c675c3b3a$var$asArray(e);
+	}
+	return [];
+}
+function $e5be200c675c3b3a$var$getValidationResult(errors) {
+	return errors.length ? {
+		isInvalid: true,
+		validationErrors: errors,
+		validationDetails: $e5be200c675c3b3a$var$CUSTOM_VALIDITY_STATE
+	} : null;
+}
+function $e5be200c675c3b3a$var$isEqualValidation(a, b) {
+	if (a === b) return true;
+	return !!a && !!b && a.isInvalid === b.isInvalid && a.validationErrors.length === b.validationErrors.length && a.validationErrors.every((a, i) => a === b.validationErrors[i]) && Object.entries(a.validationDetails).every(([k, v]) => b.validationDetails[k] === v);
+}
+function $e5be200c675c3b3a$export$75ee7c75d68f5b0e(...results) {
+	let errors = /* @__PURE__ */ new Set();
+	let isInvalid = false;
+	let validationDetails = { ...$e5be200c675c3b3a$export$aca958c65c314e6c };
+	for (let v of results) {
+		var _validationDetails, _key;
+		for (let e of v.validationErrors) errors.add(e);
+		isInvalid || (isInvalid = v.isInvalid);
+		for (let key in validationDetails) (_validationDetails = validationDetails)[_key = key] || (_validationDetails[_key] = v.validationDetails[key]);
+	}
+	validationDetails.valid = !isInvalid;
+	return {
+		isInvalid,
+		validationErrors: [...errors],
+		validationDetails
+	};
+}
+//#endregion
+export { $e5be200c675c3b3a$export$fc1a364ae1f3ff10 as i, $e5be200c675c3b3a$export$a763b9476acd3eb as n, $e5be200c675c3b3a$export$dad6ae84456c676a as r, $e5be200c675c3b3a$export$75ee7c75d68f5b0e as t };