@povio/ui 3.4.0-rc.4 → 3.4.0-rc.41

package/dist/useFormAutosave-Ckq-Qb34.js

@@ -0,0 +1,198 @@
+import { a as isEqual, o as ObjectUtils } from "./uiConfig.context-BG4jfp9p.js";
+import { n as useForm } from "./form.binding-DLKteDiq.js";
+import { t as StringUtils } from "./string.utils-BPgv6QwA.js";
+import { t as ZodUtils } from "./zod.utils-DrrPDT9v.js";
+import { n as getDefaultInputComponentType } from "./dynamicInputs-0GjoOaz5.js";
+import { t as InputItem } from "./InputItem-DfNvJtim.js";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+import { z } from "zod";
+//#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 z.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/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({
+		...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 n, Form as r, useFormAutosave as t };

package/dist/useFormReset-BmSQIMid.js

@@ -0,0 +1,18 @@
+import { t as $8ae05eaa5c114e9c$export$7f54fc3180508a52 } from "./useEffectEvent-BdzIyMdT.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-DlNyD6aD.js

@@ -0,0 +1,87 @@
+import { _ as $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c } from "./utils-D-KKbY-n.js";
+import { t as $8ae05eaa5c114e9c$export$7f54fc3180508a52 } from "./useEffectEvent-BdzIyMdT.js";
+import { useEffect, useRef } from "react";
+import { setInteractionModality } from "@react-aria/interactions";
+//#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();
+			setInteractionModality("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 { $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 };

package/dist/useGlobalListeners-DuENtiaD.js

@@ -0,0 +1,39 @@
+import { useCallback, useEffect, useRef } from "react";
+//#region ../../node_modules/.bun/@react-aria+utils@3.33.0+67f6792bdf102c28/node_modules/@react-aria/utils/dist/useGlobalListeners.mjs
+function $03deb23ff14920c4$export$4eaf04e54aa8eed6() {
+	let globalListeners = useRef(/* @__PURE__ */ new Map());
+	let addGlobalListener = useCallback((eventTarget, type, listener, options) => {
+		let fn = (options === null || options === void 0 ? void 0 : options.once) ? (...args) => {
+			globalListeners.current.delete(listener);
+			listener(...args);
+		} : listener;
+		globalListeners.current.set(listener, {
+			type,
+			eventTarget,
+			fn,
+			options
+		});
+		eventTarget.addEventListener(type, fn, options);
+	}, []);
+	let removeGlobalListener = useCallback((eventTarget, type, listener, options) => {
+		var _globalListeners_current_get;
+		let fn = ((_globalListeners_current_get = globalListeners.current.get(listener)) === null || _globalListeners_current_get === void 0 ? void 0 : _globalListeners_current_get.fn) || listener;
+		eventTarget.removeEventListener(type, fn, options);
+		globalListeners.current.delete(listener);
+	}, []);
+	let removeAllGlobalListeners = useCallback(() => {
+		globalListeners.current.forEach((value, key) => {
+			removeGlobalListener(value.eventTarget, value.type, key, value.options);
+		});
+	}, [removeGlobalListener]);
+	useEffect(() => {
+		return removeAllGlobalListeners;
+	}, [removeAllGlobalListeners]);
+	return {
+		addGlobalListener,
+		removeGlobalListener,
+		removeAllGlobalListeners
+	};
+}
+//#endregion
+export { $03deb23ff14920c4$export$4eaf04e54aa8eed6 as t };

package/dist/useIntersectionObserver-DYfHnGGU.js

@@ -0,0 +1,98 @@
+import { useEffect, useRef } from "react";
+import { c } from "react/compiler-runtime";
+//#region src/hooks/useIntersectionObserver.ts
+const useIntersectionObserver = (t0) => {
+	const $ = c(13);
+	const { onIntersection, onIntersectionChange, root, rootMargin, threshold } = t0;
+	const elementRef = useRef(null);
+	const observerRef = useRef(null);
+	const onIntersectionRef = useRef(onIntersection);
+	const onIntersectionChangeRef = useRef(onIntersectionChange);
+	let t1;
+	let t2;
+	if ($[0] !== onIntersection) {
+		t1 = () => {
+			onIntersectionRef.current = onIntersection;
+		};
+		t2 = [onIntersection];
+		$[0] = onIntersection;
+		$[1] = t1;
+		$[2] = t2;
+	} else {
+		t1 = $[1];
+		t2 = $[2];
+	}
+	useEffect(t1, t2);
+	let t3;
+	let t4;
+	if ($[3] !== onIntersectionChange) {
+		t3 = () => {
+			onIntersectionChangeRef.current = onIntersectionChange;
+		};
+		t4 = [onIntersectionChange];
+		$[3] = onIntersectionChange;
+		$[4] = t3;
+		$[5] = t4;
+	} else {
+		t3 = $[4];
+		t4 = $[5];
+	}
+	useEffect(t3, t4);
+	let t5;
+	let t6;
+	if ($[6] !== root || $[7] !== rootMargin || $[8] !== threshold) {
+		t5 = () => {
+			const observer = new IntersectionObserver((entries) => {
+				if (entries.some(_temp)) onIntersectionRef.current?.();
+				onIntersectionChangeRef.current?.(entries[0]);
+			}, {
+				root,
+				rootMargin,
+				threshold
+			});
+			observerRef.current = observer;
+			if (elementRef.current) observer.observe(elementRef.current);
+			return () => {
+				if (elementRef.current) observer.unobserve(elementRef.current);
+				observer.disconnect();
+				observerRef.current = null;
+			};
+		};
+		t6 = [
+			root,
+			rootMargin,
+			threshold
+		];
+		$[6] = root;
+		$[7] = rootMargin;
+		$[8] = threshold;
+		$[9] = t5;
+		$[10] = t6;
+	} else {
+		t5 = $[9];
+		t6 = $[10];
+	}
+	useEffect(t5, t6);
+	let t7;
+	if ($[11] === Symbol.for("react.memo_cache_sentinel")) {
+		t7 = (element) => {
+			if (elementRef.current === element) return;
+			if (observerRef.current && elementRef.current) observerRef.current.unobserve(elementRef.current);
+			elementRef.current = element;
+			if (observerRef.current && elementRef.current) observerRef.current.observe(elementRef.current);
+		};
+		$[11] = t7;
+	} else t7 = $[11];
+	const ref = t7;
+	let t8;
+	if ($[12] === Symbol.for("react.memo_cache_sentinel")) {
+		t8 = { ref };
+		$[12] = t8;
+	} else t8 = $[12];
+	return t8;
+};
+function _temp(entry) {
+	return entry.isIntersecting;
+}
+//#endregion
+export { useIntersectionObserver as t };

package/dist/useLabels-Bt2BXuQ6.js

@@ -0,0 +1,16 @@
+import { h as $bdb11010cef70236$export$f680877a34711e37 } from "./utils-D-KKbY-n.js";
+//#region ../../node_modules/.bun/@react-aria+utils@3.33.0+67f6792bdf102c28/node_modules/@react-aria/utils/dist/useLabels.mjs
+function $313b98861ee5dd6c$export$d6875122194c7b44(props, defaultLabel) {
+	let { id, "aria-label": label, "aria-labelledby": labelledBy } = props;
+	id = $bdb11010cef70236$export$f680877a34711e37(id);
+	if (labelledBy && label) labelledBy = [.../* @__PURE__ */ new Set([id, ...labelledBy.trim().split(/\s+/)])].join(" ");
+	else if (labelledBy) labelledBy = labelledBy.trim().split(/\s+/).join(" ");
+	if (!label && !labelledBy && defaultLabel) label = defaultLabel;
+	return {
+		id,
+		"aria-label": label,
+		"aria-labelledby": labelledBy
+	};
+}
+//#endregion
+export { $313b98861ee5dd6c$export$d6875122194c7b44 as t };

package/dist/useLocalStorage-DGsBUCT6.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+//#region src/hooks/useLocalStorage.d.ts
+interface IProps<ZOutput, ZInput> {
+  key: string;
+  schema: z.ZodType<ZOutput, ZInput>;
+}
+declare const useLocalStorage: <ZOutput, ZInput>({ key, schema }: IProps<ZOutput, ZInput>) => {
+  value: ZOutput | null;
+  set: (newValue: ZInput) => void;
+  remove: () => void;
+};
+//#endregion
+export { useLocalStorage as t };

package/dist/useLocalStorage-PlcaJ1tP.js

@@ -0,0 +1,70 @@
+import { useState } from "react";
+import { c } from "react/compiler-runtime";
+//#region src/hooks/useLocalStorage.ts
+const getValue = (key, schema) => {
+	if (!localStorage) return null;
+	const lsValue = localStorage.getItem(key);
+	if (!lsValue) return null;
+	let jsonOrString;
+	try {
+		jsonOrString = JSON.parse(lsValue);
+	} catch {
+		jsonOrString = lsValue;
+	}
+	const parsedValue = schema.safeParse(jsonOrString);
+	if (parsedValue.success) return parsedValue.data;
+	else return null;
+};
+const useLocalStorage = (t0) => {
+	const $ = c(12);
+	const { key, schema } = t0;
+	let t1;
+	if ($[0] !== key || $[1] !== schema) {
+		t1 = () => getValue(key, schema);
+		$[0] = key;
+		$[1] = schema;
+		$[2] = t1;
+	} else t1 = $[2];
+	const [value, setValue] = useState(t1);
+	let t2;
+	if ($[3] !== key || $[4] !== schema) {
+		t2 = (newValue) => {
+			if (!localStorage) return;
+			const parsedValue = schema.safeParse(newValue);
+			if (!parsedValue.success) return;
+			if (typeof parsedValue.data === "string") localStorage.setItem(key, parsedValue.data);
+			else localStorage.setItem(key, JSON.stringify(parsedValue.data));
+			setValue(parsedValue.data);
+		};
+		$[3] = key;
+		$[4] = schema;
+		$[5] = t2;
+	} else t2 = $[5];
+	const set = t2;
+	let t3;
+	if ($[6] !== key) {
+		t3 = () => {
+			if (!localStorage) return;
+			localStorage.removeItem(key);
+			setValue(null);
+		};
+		$[6] = key;
+		$[7] = t3;
+	} else t3 = $[7];
+	const remove = t3;
+	let t4;
+	if ($[8] !== remove || $[9] !== set || $[10] !== value) {
+		t4 = {
+			value,
+			set,
+			remove
+		};
+		$[8] = remove;
+		$[9] = set;
+		$[10] = value;
+		$[11] = t4;
+	} else t4 = $[11];
+	return t4;
+};
+//#endregion
+export { useLocalStorage as t };