@povio/ui 2.3.0-rc.4 → 2.3.0-rc.40

package/dist/hooks/useBreakpoint.js

@@ -1,4 +1,4 @@
-import { useMemo } from "react";
+import { c } from "react/compiler-runtime";
 import { useMediaQuery } from "react-responsive";
 //#region src/hooks/useBreakpoint.ts
 var breakpoints = null;
@@ -22,9 +22,22 @@ function getBreakpoints() {
 	return breakpoints;
 }
 function useBreakpoint(breakpointKey) {
-	const breakpoints = useMemo(() => getBreakpoints(), []);
+	const $ = c(3);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = getBreakpoints();
+		$[0] = t0;
+	} else t0 = $[0];
+	const breakpoints = t0;
 	if (!breakpoints) throw new Error("Tailwind config is missing theme.screens");
-	return useMediaQuery({ query: `(min-width: ${breakpoints[breakpointKey]})` });
+	const t1 = `(min-width: ${breakpoints[breakpointKey]})`;
+	let t2;
+	if ($[1] !== t1) {
+		t2 = { query: t1 };
+		$[1] = t1;
+		$[2] = t2;
+	} else t2 = $[2];
+	return useMediaQuery(t2);
 }
 //#endregion
 export { useBreakpoint };

package/dist/hooks/useDebounceCallback.js

@@ -1,25 +1,59 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { c } from "react/compiler-runtime";
+import { useEffect, useRef, useState } from "react";
 //#region src/hooks/useDebounceCallback.ts
-function useDebounceCallback(callback, { delay = 500 } = {}) {
+function useDebounceCallback(callback, t0) {
+	const $ = c(10);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const { delay: t2 } = t1;
+	const delay = t2 === void 0 ? 500 : t2;
 	const timeoutRef = useRef(null);
 	const [isDebouncing, setIsDebouncing] = useState(false);
-	const debouncedCallback = useCallback((...args) => {
-		if (timeoutRef.current) clearTimeout(timeoutRef.current);
-		setIsDebouncing(true);
-		timeoutRef.current = setTimeout(() => {
-			setIsDebouncing(false);
-			callback?.(...args);
-		}, delay);
-	}, [callback, delay]);
-	useEffect(() => {
-		return () => {
+	let t3;
+	if ($[2] !== callback || $[3] !== delay) {
+		t3 = (...t4) => {
+			const args = t4;
 			if (timeoutRef.current) clearTimeout(timeoutRef.current);
+			setIsDebouncing(true);
+			timeoutRef.current = setTimeout(() => {
+				setIsDebouncing(false);
+				callback?.(...args);
+			}, delay);
 		};
-	}, []);
-	return {
-		callback: debouncedCallback,
-		isDebouncing
-	};
+		$[2] = callback;
+		$[3] = delay;
+		$[4] = t3;
+	} else t3 = $[4];
+	const debouncedCallback = t3;
+	let t4;
+	let t5;
+	if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+		t4 = () => () => {
+			if (timeoutRef.current) clearTimeout(timeoutRef.current);
+		};
+		t5 = [];
+		$[5] = t4;
+		$[6] = t5;
+	} else {
+		t4 = $[5];
+		t5 = $[6];
+	}
+	useEffect(t4, t5);
+	let t6;
+	if ($[7] !== debouncedCallback || $[8] !== isDebouncing) {
+		t6 = {
+			callback: debouncedCallback,
+			isDebouncing
+		};
+		$[7] = debouncedCallback;
+		$[8] = isDebouncing;
+		$[9] = t6;
+	} else t6 = $[9];
+	return t6;
 }
 //#endregion
 export { useDebounceCallback };

package/dist/hooks/useFilters.js

@@ -1,6 +1,7 @@
 import { UIRouter } from "../config/router.context.js";
 import { RoutingUtils } from "../utils/routing.utils.js";
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { c } from "react/compiler-runtime";
+import { useEffect, useState } from "react";
 import { z } from "zod";
 //#region src/hooks/useFilters.ts
 function getFieldType(schema, fieldKey) {
@@ -50,78 +51,138 @@ var parseFilterFromQuery = (searchParams, schema) => {
 	}
 	return filter;
 };
-var useFilters = (defaultFilterValues, prefix = "", schema) => {
+var useFilters = (defaultFilterValues, t0, schema) => {
+	const $ = c(33);
+	const prefix = t0 === void 0 ? "" : t0;
 	const { searchParams, replace } = UIRouter.useUIRouter();
-	const [filterData, setFilterData] = useState(() => parseFilterFromQuery(searchParams, schema));
-	useEffect(() => {
-		const setUrlToDefaultFilters = () => {
-			const flatFilterQuery = serializeFiltersToQuery(defaultFilterValues, prefix);
+	let t1;
+	if ($[0] !== schema || $[1] !== searchParams) {
+		t1 = () => parseFilterFromQuery(searchParams, schema);
+		$[0] = schema;
+		$[1] = searchParams;
+		$[2] = t1;
+	} else t1 = $[2];
+	const [filterData, setFilterData] = useState(t1);
+	let t2;
+	if ($[3] !== defaultFilterValues || $[4] !== prefix || $[5] !== replace || $[6] !== schema || $[7] !== searchParams) {
+		t2 = () => {
+			const setUrlToDefaultFilters = () => {
+				const flatFilterQuery = serializeFiltersToQuery(defaultFilterValues, prefix);
+				replace(".", {
+					...RoutingUtils.toRouterSearch(searchParams),
+					...flatFilterQuery
+				});
+			};
+			const currentFilters = parseFilterFromQuery(searchParams, schema);
+			const hasFiltersSet = Object.keys(currentFilters).length > 0;
+			if (defaultFilterValues && !hasFiltersSet) setUrlToDefaultFilters();
+		};
+		$[3] = defaultFilterValues;
+		$[4] = prefix;
+		$[5] = replace;
+		$[6] = schema;
+		$[7] = searchParams;
+		$[8] = t2;
+	} else t2 = $[8];
+	let t3;
+	if ($[9] !== defaultFilterValues || $[10] !== prefix || $[11] !== schema) {
+		t3 = [
+			defaultFilterValues,
+			prefix,
+			schema
+		];
+		$[9] = defaultFilterValues;
+		$[10] = prefix;
+		$[11] = schema;
+		$[12] = t3;
+	} else t3 = $[12];
+	useEffect(t2, t3);
+	let t4;
+	let t5;
+	if ($[13] !== schema || $[14] !== searchParams) {
+		t4 = () => {
+			setFilterData(parseFilterFromQuery(searchParams, schema));
+		};
+		t5 = [searchParams, schema];
+		$[13] = schema;
+		$[14] = searchParams;
+		$[15] = t4;
+		$[16] = t5;
+	} else {
+		t4 = $[15];
+		t5 = $[16];
+	}
+	useEffect(t4, t5);
+	let t6;
+	if ($[17] !== defaultFilterValues || $[18] !== filterData || $[19] !== prefix || $[20] !== replace || $[21] !== searchParams) {
+		t6 = (data) => {
+			let newFilters = { ...filterData };
+			const isReset = Object.keys(data).length === 0;
+			if (data === defaultFilterValues) newFilters = { ...defaultFilterValues };
+			else if (isReset) newFilters = {};
+			else Object.entries(data).forEach((t7) => {
+				const [key, value] = t7;
+				if (value === void 0) delete newFilters[key];
+				else newFilters[key] = value;
+			});
+			const prefixPart = prefix ? `${prefix}-` : "";
+			const cleanedQuery = RoutingUtils.toRouterSearch(searchParams);
+			Object.keys(cleanedQuery).forEach((key_0) => {
+				if (key_0.startsWith(`filter[${prefixPart}`)) delete cleanedQuery[key_0];
+			});
+			const flatFilterQuery_0 = serializeFiltersToQuery(newFilters, prefix);
 			replace(".", {
-				...RoutingUtils.toRouterSearch(searchParams),
-				...flatFilterQuery
+				...cleanedQuery,
+				...flatFilterQuery_0
+			});
+			setFilterData(newFilters);
+		};
+		$[17] = defaultFilterValues;
+		$[18] = filterData;
+		$[19] = prefix;
+		$[20] = replace;
+		$[21] = searchParams;
+		$[22] = t6;
+	} else t6 = $[22];
+	const setFilterValue = t6;
+	let t7;
+	if ($[23] !== filterData) {
+		t7 = (keys) => {
+			const result = {};
+			keys.forEach((key_1) => {
+				result[key_1] = filterData[key_1];
 			});
+			return result;
+		};
+		$[23] = filterData;
+		$[24] = t7;
+	} else t7 = $[24];
+	const getFilterValue = t7;
+	let t8;
+	if ($[25] !== defaultFilterValues || $[26] !== setFilterValue) {
+		t8 = () => {
+			setFilterValue(defaultFilterValues ?? {});
 		};
-		const currentFilters = parseFilterFromQuery(searchParams, schema);
-		const hasFiltersSet = Object.keys(currentFilters).length > 0;
-		if (defaultFilterValues && !hasFiltersSet) setUrlToDefaultFilters();
-	}, [
-		defaultFilterValues,
-		prefix,
-		schema
-	]);
-	useEffect(() => {
-		setFilterData(parseFilterFromQuery(searchParams, schema));
-	}, [searchParams, schema]);
-	const setFilterValue = useCallback((data) => {
-		let newFilters = { ...filterData };
-		const isReset = Object.keys(data).length === 0;
-		if (data === defaultFilterValues) newFilters = { ...defaultFilterValues };
-		else if (isReset) newFilters = {};
-		else Object.entries(data).forEach(([key, value]) => {
-			if (value === void 0) delete newFilters[key];
-			else newFilters[key] = value;
-		});
-		const prefixPart = prefix ? `${prefix}-` : "";
-		const cleanedQuery = RoutingUtils.toRouterSearch(searchParams);
-		Object.keys(cleanedQuery).forEach((key) => {
-			if (key.startsWith(`filter[${prefixPart}`)) delete cleanedQuery[key];
-		});
-		const flatFilterQuery = serializeFiltersToQuery(newFilters, prefix);
-		replace(".", {
-			...cleanedQuery,
-			...flatFilterQuery
-		});
-		setFilterData(newFilters);
-	}, [
-		filterData,
-		prefix,
-		replace,
-		defaultFilterValues,
-		searchParams
-	]);
-	const getFilterValue = useCallback((keys) => {
-		const result = {};
-		keys.forEach((key) => {
-			result[key] = filterData[key];
-		});
-		return result;
-	}, [filterData]);
-	const clearAllFilters = useCallback(() => {
-		setFilterValue(defaultFilterValues ?? {});
-	}, [defaultFilterValues, setFilterValue]);
-	return useMemo(() => {
-		return {
+		$[25] = defaultFilterValues;
+		$[26] = setFilterValue;
+		$[27] = t8;
+	} else t8 = $[27];
+	const clearAllFilters = t8;
+	let t9;
+	if ($[28] !== clearAllFilters || $[29] !== filterData || $[30] !== getFilterValue || $[31] !== setFilterValue) {
+		t9 = {
 			filterData,
 			setFilterValue,
 			getFilterValue,
 			clearAllFilters
 		};
-	}, [
-		filterData,
-		setFilterValue,
-		getFilterValue,
-		clearAllFilters
-	]);
+		$[28] = clearAllFilters;
+		$[29] = filterData;
+		$[30] = getFilterValue;
+		$[31] = setFilterValue;
+		$[32] = t9;
+	} else t9 = $[32];
+	return t9;
 };
 //#endregion
 export { useFilters };

package/dist/hooks/useForm.js

@@ -1,14 +1,48 @@
-import { useMemo } from "react";
+import { c } from "react/compiler-runtime";
 import { useForm } from "react-hook-form";
 import { zodResolver } from "@hookform/resolvers/zod";
 //#region src/hooks/useForm.ts
-function useForm$1({ resolver, zodSchema, defaultValues, ...props }) {
-	const formResolver = useMemo(() => resolver ?? (zodSchema ? zodResolver(zodSchema) : void 0), [resolver, zodSchema]);
-	return useForm({
-		...props,
-		resolver: formResolver,
-		defaultValues
-	});
+function useForm$1(t0) {
+	const $ = c(12);
+	let defaultValues;
+	let props;
+	let resolver;
+	let zodSchema;
+	if ($[0] !== t0) {
+		({resolver, zodSchema, defaultValues, ...props} = t0);
+		$[0] = t0;
+		$[1] = defaultValues;
+		$[2] = props;
+		$[3] = resolver;
+		$[4] = zodSchema;
+	} else {
+		defaultValues = $[1];
+		props = $[2];
+		resolver = $[3];
+		zodSchema = $[4];
+	}
+	let t1;
+	if ($[5] !== resolver || $[6] !== zodSchema) {
+		t1 = resolver ?? (zodSchema ? zodResolver(zodSchema) : void 0);
+		$[5] = resolver;
+		$[6] = zodSchema;
+		$[7] = t1;
+	} else t1 = $[7];
+	const formResolver = t1;
+	const t2 = defaultValues;
+	let t3;
+	if ($[8] !== formResolver || $[9] !== props || $[10] !== t2) {
+		t3 = {
+			...props,
+			resolver: formResolver,
+			defaultValues: t2
+		};
+		$[8] = formResolver;
+		$[9] = props;
+		$[10] = t2;
+		$[11] = t3;
+	} else t3 = $[11];
+	return useForm(t3);
 }
 //#endregion
 export { useForm$1 as useForm };

package/dist/hooks/useFormAutosave.js

@@ -1,6 +1,7 @@
 import { ObjectUtils } from "../utils/object.utils.js";
 import { useAutosave } from "./useAutosave.js";
 import { useForm } from "./useForm.js";
+import { c } from "react/compiler-runtime";
 import { useEffect, useRef } from "react";
 //#region src/hooks/useFormAutosave.ts
 var getResetTimeoutErrorMessage = (resetTimeout) => `Form Reset Timeout (${resetTimeout}ms) - Action Required
@@ -15,39 +16,109 @@ 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, onAutosave, getResetValues, resetDeps, resetTimeout = 5e3, ...props }) {
-	const form = useForm({
-		...props,
-		defaultValues: getResetValues()
-	});
+function useFormAutosave(t0) {
+	const $ = c(26);
+	let autosaveDelay;
+	let enableAutosave;
+	let getResetValues;
+	let onAutosave;
+	let props;
+	let resetDeps;
+	let t1;
+	if ($[0] !== t0) {
+		({autosaveDelay, enableAutosave, onAutosave, getResetValues, resetDeps, resetTimeout: t1, ...props} = t0);
+		$[0] = t0;
+		$[1] = autosaveDelay;
+		$[2] = enableAutosave;
+		$[3] = getResetValues;
+		$[4] = onAutosave;
+		$[5] = props;
+		$[6] = resetDeps;
+		$[7] = t1;
+	} else {
+		autosaveDelay = $[1];
+		enableAutosave = $[2];
+		getResetValues = $[3];
+		onAutosave = $[4];
+		props = $[5];
+		resetDeps = $[6];
+		t1 = $[7];
+	}
+	const resetTimeout = t1 === void 0 ? 5e3 : t1;
+	let t2;
+	if ($[8] !== getResetValues) {
+		t2 = getResetValues();
+		$[8] = getResetValues;
+		$[9] = t2;
+	} else t2 = $[9];
+	let t3;
+	if ($[10] !== props || $[11] !== t2) {
+		t3 = {
+			...props,
+			defaultValues: t2
+		};
+		$[10] = props;
+		$[11] = t2;
+		$[12] = t3;
+	} else t3 = $[12];
+	const form = useForm(t3);
 	const shouldResetFormValuesRef = useRef(false);
 	const resetFormValuesTimeoutRef = useRef(void 0);
-	useEffect(() => {
-		const resetValues = getResetValues();
-		if (resetValues === void 0) return;
-		const resetFormValues = async () => {
-			const keepStateOptions = shouldResetFormValuesRef.current ? { keepDirtyValues: true } : void 0;
-			shouldResetFormValuesRef.current = false;
-			let values = resetValues;
-			if (ObjectUtils.isFunction(resetValues)) values = await resetValues();
-			form.reset(values, keepStateOptions);
+	let t4;
+	if ($[13] !== form || $[14] !== getResetValues) {
+		t4 = () => {
+			const resetValues = getResetValues();
+			if (resetValues === void 0) return;
+			const resetFormValues = async () => {
+				const keepStateOptions = shouldResetFormValuesRef.current ? { keepDirtyValues: true } : void 0;
+				shouldResetFormValuesRef.current = false;
+				let values = resetValues;
+				if (ObjectUtils.isFunction(resetValues)) values = await resetValues();
+				form.reset(values, keepStateOptions);
+			};
+			resetFormValues();
+		};
+		$[13] = form;
+		$[14] = getResetValues;
+		$[15] = t4;
+	} else t4 = $[15];
+	let t5;
+	if ($[16] !== resetDeps) {
+		t5 = [...resetDeps];
+		$[16] = resetDeps;
+		$[17] = t5;
+	} else t5 = $[17];
+	useEffect(t4, t5);
+	let t6;
+	if ($[18] !== resetTimeout) {
+		t6 = () => {
+			shouldResetFormValuesRef.current = true;
+			if (resetFormValuesTimeoutRef.current) clearTimeout(resetFormValuesTimeoutRef.current);
+			resetFormValuesTimeoutRef.current = setTimeout(() => {
+				if (shouldResetFormValuesRef.current) throw new Error(getResetTimeoutErrorMessage(resetTimeout));
+			}, resetTimeout);
+		};
+		$[18] = resetTimeout;
+		$[19] = t6;
+	} else t6 = $[19];
+	const onSaveSuccess = t6;
+	let t7;
+	if ($[20] !== autosaveDelay || $[21] !== enableAutosave || $[22] !== form || $[23] !== onAutosave || $[24] !== onSaveSuccess) {
+		t7 = {
+			form,
+			delay: autosaveDelay,
+			enabled: enableAutosave,
+			onSave: onAutosave,
+			onSaveSuccess
 		};
-		resetFormValues();
-	}, [...resetDeps]);
-	const onSaveSuccess = () => {
-		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,
-		onSave: onAutosave,
-		onSaveSuccess
-	});
+		$[20] = autosaveDelay;
+		$[21] = enableAutosave;
+		$[22] = form;
+		$[23] = onAutosave;
+		$[24] = onSaveSuccess;
+		$[25] = t7;
+	} else t7 = $[25];
+	useAutosave(t7);
 	return form;
 }
 //#endregion

package/dist/hooks/useIntersectionObserver.js

@@ -1,44 +1,98 @@
-import { useCallback, useEffect, useMemo, useRef } from "react";
+import { c } from "react/compiler-runtime";
+import { useEffect, useRef } from "react";
 //#region src/hooks/useIntersectionObserver.ts
-var useIntersectionObserver = ({ onIntersection, onIntersectionChange, root, rootMargin, threshold }) => {
+var 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);
-	useEffect(() => {
-		onIntersectionRef.current = onIntersection;
-	}, [onIntersection]);
-	useEffect(() => {
-		onIntersectionChangeRef.current = onIntersectionChange;
-	}, [onIntersectionChange]);
-	useEffect(() => {
-		const observer = new IntersectionObserver((entries) => {
-			if (entries.some((entry) => entry.isIntersecting)) onIntersectionRef.current?.();
-			onIntersectionChangeRef.current?.(entries[0]);
-		}, {
+	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
-		});
-		observerRef.current = observer;
-		if (elementRef.current) observer.observe(elementRef.current);
-		return () => {
-			if (elementRef.current) observer.unobserve(elementRef.current);
-			observer.disconnect();
-			observerRef.current = null;
+		];
+		$[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);
 		};
-	}, [
-		root,
-		rootMargin,
-		threshold
-	]);
-	const ref = useCallback((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);
-	}, []);
-	return useMemo(() => ({ ref }), [ref]);
+		$[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 };