tempest-react-sdk 0.48.0 → 0.50.0

package/dist/hooks/use-async.js

@@ -1,60 +1,57 @@
-import { useCallback as e, useEffect as t, useRef as n, useState as r } from "react";
+import { useLatestRef as e } from "./use-latest-ref.js";
+import { useCallback as t, useEffect as n, useRef as r, useState as i } from "react";
 //#region src/hooks/use-async.ts
-function i(i, a = [], o = {}) {
-	let { immediate: s = !1 } = o, [c, l] = r({
+function a(a, o = [], s = {}) {
+	let { immediate: c = !1 } = s, [l, u] = i({
 		status: "idle",
 		data: void 0,
 		error: void 0
-	}), u = n(i);
-	t(() => {
-		u.current = i;
-	}, [i]);
-	let d = n(0), f = n(!0);
-	t(() => (f.current = !0, () => {
-		f.current = !1;
+	}), d = e(a), f = r(0), p = r(!0);
+	n(() => (p.current = !0, () => {
+		p.current = !1;
 	}), []);
-	let p = e(async () => {
-		let e = ++d.current;
-		l((e) => ({
+	let m = t(async () => {
+		let e = ++f.current;
+		u((e) => ({
 			...e,
 			status: "pending",
 			error: void 0
 		}));
 		try {
-			let t = await u.current();
-			return f.current && d.current === e && l({
+			let t = await d.current();
+			return p.current && f.current === e && u({
 				status: "success",
 				data: t,
 				error: void 0
 			}), t;
 		} catch (t) {
-			throw f.current && d.current === e && l({
+			throw p.current && f.current === e && u({
 				status: "error",
 				data: void 0,
 				error: t
 			}), t;
 		}
-	}, []), m = e(() => {
-		d.current++, l({
+	}, [d]), h = t(() => {
+		f.current++, u({
 			status: "idle",
 			data: void 0,
 			error: void 0
 		});
 	}, []);
-	return t(() => {
-		s && p().catch(() => {});
-	}, [s, ...a]), {
-		status: c.status,
-		data: c.data,
-		error: c.error,
-		isPending: c.status === "pending",
-		isSuccess: c.status === "success",
-		isError: c.status === "error",
-		run: p,
-		reset: m
+	return n(() => {
+		c && m().catch(() => {});
+	}, [c, ...o]), {
+		status: l.status,
+		data: l.data,
+		error: l.error,
+		isPending: l.status === "pending",
+		isSuccess: l.status === "success",
+		isError: l.status === "error",
+		run: m,
+		reset: h
 	};
 }
 //#endregion
-export { i as useAsync };
+export { a as useAsync };
 
 //# sourceMappingURL=use-async.js.map

package/dist/hooks/use-async.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-async.js","names":[],"sources":["../../src/hooks/use-async.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\n\nexport type AsyncStatus = \"idle\" | \"pending\" | \"success\" | \"error\";\n\nexport interface UseAsyncResult<T> {\n    status: AsyncStatus;\n    data: T | undefined;\n    error: unknown;\n    isPending: boolean;\n    isSuccess: boolean;\n    isError: boolean;\n    /** Trigger the async function. Resolves with the new data or rejects. */\n    run: () => Promise<T>;\n    /** Reset state back to idle. */\n    reset: () => void;\n}\n\n/**\n * Run an async function and track its `idle/pending/success/error` state.\n *\n * - Discards results from stale runs (race-condition safe).\n * - `immediate` (default `false`) triggers the function on mount and when\n *   `deps` change. With `false`, call `run()` manually.\n * - Returns a stable object so callers can destructure or pass around safely.\n *\n * For server data with caching, prefer React Query — `useAsync` is the\n * minimal one-shot primitive without dependencies.\n */\nexport function useAsync<T>(\n    asyncFn: () => Promise<T>,\n    deps: ReadonlyArray<unknown> = [],\n    options: { immediate?: boolean } = {},\n): UseAsyncResult<T> {\n    const { immediate = false } = options;\n    const [state, setState] = useState<{\n        status: AsyncStatus;\n        data: T | undefined;\n        error: unknown;\n    }>({ status: \"idle\", data: undefined, error: undefined });\n\n    const fnRef = useRef(asyncFn);\n    useEffect(() => {\n        fnRef.current = asyncFn;\n    }, [asyncFn]);\n    const callIdRef = useRef<number>(0);\n    const mountedRef = useRef<boolean>(true);\n\n    useEffect(() => {\n        mountedRef.current = true;\n        return () => {\n            mountedRef.current = false;\n        };\n    }, []);\n\n    const run = useCallback(async (): Promise<T> => {\n        const callId = ++callIdRef.current;\n        setState((current) => ({ ...current, status: \"pending\", error: undefined }));\n        try {\n            const data = await fnRef.current();\n            if (mountedRef.current && callIdRef.current === callId) {\n                setState({ status: \"success\", data, error: undefined });\n            }\n            return data;\n        } catch (error) {\n            if (mountedRef.current && callIdRef.current === callId) {\n                setState({ status: \"error\", data: undefined, error });\n            }\n            throw error;\n        }\n    }, []);\n\n    const reset = useCallback((): void => {\n        callIdRef.current++;\n        setState({ status: \"idle\", data: undefined, error: undefined });\n    }, []);\n\n    useEffect(() => {\n        if (!immediate) return;\n        run().catch(() => {\n            /* error already captured in state */\n        });\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [immediate, ...deps]);\n\n    return {\n        status: state.status,\n        data: state.data,\n        error: state.error,\n        isPending: state.status === \"pending\",\n        isSuccess: state.status === \"success\",\n        isError: state.status === \"error\",\n        run,\n        reset,\n    };\n}\n"],"mappings":";;AA4BA,SAAgB,EACZ,GACA,IAA+B,CAAC,GAChC,IAAmC,CAAC,GACnB;CACjB,IAAM,EAAE,eAAY,OAAU,GACxB,CAAC,GAAO,KAAY,EAIvB;EAAE,QAAQ;EAAQ,MAAM,KAAA;EAAW,OAAO,KAAA;CAAU,CAAC,GAElD,IAAQ,EAAO,CAAO;CAC5B,QAAgB;EACZ,EAAM,UAAU;CACpB,GAAG,CAAC,CAAO,CAAC;CACZ,IAAM,IAAY,EAAe,CAAC,GAC5B,IAAa,EAAgB,EAAI;CAEvC,SACI,EAAW,UAAU,UACR;EACT,EAAW,UAAU;CACzB,IACD,CAAC,CAAC;CAEL,IAAM,IAAM,EAAY,YAAwB;EAC5C,IAAM,IAAS,EAAE,EAAU;EAC3B,GAAU,OAAa;GAAE,GAAG;GAAS,QAAQ;GAAW,OAAO,KAAA;EAAU,EAAE;EAC3E,IAAI;GACA,IAAM,IAAO,MAAM,EAAM,QAAQ;GAIjC,OAHI,EAAW,WAAW,EAAU,YAAY,KAC5C,EAAS;IAAE,QAAQ;IAAW;IAAM,OAAO,KAAA;GAAU,CAAC,GAEnD;EACX,SAAS,GAAO;GAIZ,MAHI,EAAW,WAAW,EAAU,YAAY,KAC5C,EAAS;IAAE,QAAQ;IAAS,MAAM,KAAA;IAAW;GAAM,CAAC,GAElD;EACV;CACJ,GAAG,CAAC,CAAC,GAEC,IAAQ,QAAwB;EAElC,AADA,EAAU,WACV,EAAS;GAAE,QAAQ;GAAQ,MAAM,KAAA;GAAW,OAAO,KAAA;EAAU,CAAC;CAClE,GAAG,CAAC,CAAC;CAUL,OARA,QAAgB;EACP,KACL,EAAI,CAAC,CAAC,YAAY,CAElB,CAAC;CAEL,GAAG,CAAC,GAAW,GAAG,CAAI,CAAC,GAEhB;EACH,QAAQ,EAAM;EACd,MAAM,EAAM;EACZ,OAAO,EAAM;EACb,WAAW,EAAM,WAAW;EAC5B,WAAW,EAAM,WAAW;EAC5B,SAAS,EAAM,WAAW;EAC1B;EACA;CACJ;AACJ"}
+{"version":3,"file":"use-async.js","names":[],"sources":["../../src/hooks/use-async.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\n\nexport type AsyncStatus = \"idle\" | \"pending\" | \"success\" | \"error\";\n\nexport interface UseAsyncResult<T> {\n    status: AsyncStatus;\n    data: T | undefined;\n    error: unknown;\n    isPending: boolean;\n    isSuccess: boolean;\n    isError: boolean;\n    /** Trigger the async function. Resolves with the new data or rejects. */\n    run: () => Promise<T>;\n    /** Reset state back to idle. */\n    reset: () => void;\n}\n\n/**\n * Run an async function and track its `idle/pending/success/error` state.\n *\n * - Discards results from stale runs (race-condition safe).\n * - `immediate` (default `false`) triggers the function on mount and when\n *   `deps` change. With `false`, call `run()` manually.\n * - Returns a stable object so callers can destructure or pass around safely.\n *\n * For server data with caching, prefer React Query — `useAsync` is the\n * minimal one-shot primitive without dependencies.\n */\nexport function useAsync<T>(\n    asyncFn: () => Promise<T>,\n    deps: ReadonlyArray<unknown> = [],\n    options: { immediate?: boolean } = {},\n): UseAsyncResult<T> {\n    const { immediate = false } = options;\n    const [state, setState] = useState<{\n        status: AsyncStatus;\n        data: T | undefined;\n        error: unknown;\n    }>({ status: \"idle\", data: undefined, error: undefined });\n\n    const fnRef = useLatestRef(asyncFn);\n    const callIdRef = useRef<number>(0);\n    const mountedRef = useRef<boolean>(true);\n\n    useEffect(() => {\n        mountedRef.current = true;\n        return () => {\n            mountedRef.current = false;\n        };\n    }, []);\n\n    const run = useCallback(async (): Promise<T> => {\n        const callId = ++callIdRef.current;\n        setState((current) => ({ ...current, status: \"pending\", error: undefined }));\n        try {\n            const data = await fnRef.current();\n            if (mountedRef.current && callIdRef.current === callId) {\n                setState({ status: \"success\", data, error: undefined });\n            }\n            return data;\n        } catch (error) {\n            if (mountedRef.current && callIdRef.current === callId) {\n                setState({ status: \"error\", data: undefined, error });\n            }\n            throw error;\n        }\n    }, [fnRef]);\n\n    const reset = useCallback((): void => {\n        callIdRef.current++;\n        setState({ status: \"idle\", data: undefined, error: undefined });\n    }, []);\n\n    useEffect(() => {\n        if (!immediate) return;\n        run().catch(() => {\n            /* error already captured in state */\n        });\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [immediate, ...deps]);\n\n    return {\n        status: state.status,\n        data: state.data,\n        error: state.error,\n        isPending: state.status === \"pending\",\n        isSuccess: state.status === \"success\",\n        isError: state.status === \"error\",\n        run,\n        reset,\n    };\n}\n"],"mappings":";;;AA6BA,SAAgB,EACZ,GACA,IAA+B,CAAC,GAChC,IAAmC,CAAC,GACnB;CACjB,IAAM,EAAE,eAAY,OAAU,GACxB,CAAC,GAAO,KAAY,EAIvB;EAAE,QAAQ;EAAQ,MAAM,KAAA;EAAW,OAAO,KAAA;CAAU,CAAC,GAElD,IAAQ,EAAa,CAAO,GAC5B,IAAY,EAAe,CAAC,GAC5B,IAAa,EAAgB,EAAI;CAEvC,SACI,EAAW,UAAU,UACR;EACT,EAAW,UAAU;CACzB,IACD,CAAC,CAAC;CAEL,IAAM,IAAM,EAAY,YAAwB;EAC5C,IAAM,IAAS,EAAE,EAAU;EAC3B,GAAU,OAAa;GAAE,GAAG;GAAS,QAAQ;GAAW,OAAO,KAAA;EAAU,EAAE;EAC3E,IAAI;GACA,IAAM,IAAO,MAAM,EAAM,QAAQ;GAIjC,OAHI,EAAW,WAAW,EAAU,YAAY,KAC5C,EAAS;IAAE,QAAQ;IAAW;IAAM,OAAO,KAAA;GAAU,CAAC,GAEnD;EACX,SAAS,GAAO;GAIZ,MAHI,EAAW,WAAW,EAAU,YAAY,KAC5C,EAAS;IAAE,QAAQ;IAAS,MAAM,KAAA;IAAW;GAAM,CAAC,GAElD;EACV;CACJ,GAAG,CAAC,CAAK,CAAC,GAEJ,IAAQ,QAAwB;EAElC,AADA,EAAU,WACV,EAAS;GAAE,QAAQ;GAAQ,MAAM,KAAA;GAAW,OAAO,KAAA;EAAU,CAAC;CAClE,GAAG,CAAC,CAAC;CAUL,OARA,QAAgB;EACP,KACL,EAAI,CAAC,CAAC,YAAY,CAElB,CAAC;CAEL,GAAG,CAAC,GAAW,GAAG,CAAI,CAAC,GAEhB;EACH,QAAQ,EAAM;EACd,MAAM,EAAM;EACZ,OAAO,EAAM;EACb,WAAW,EAAM,WAAW;EAC5B,WAAW,EAAM,WAAW;EAC5B,SAAS,EAAM,WAAW;EAC1B;EACA;CACJ;AACJ"}

package/dist/hooks/use-click-outside.cjs

@@ -1,2 +1,2 @@
-let e=require("react");function t(t){let n=(0,e.useRef)(null),r=(0,e.useRef)(t);return(0,e.useEffect)(()=>{r.current=t},[t]),(0,e.useEffect)(()=>{if(typeof document>`u`)return;let e=e=>{let t=e.target;!n.current||t&&n.current.contains(t)||r.current()};return document.addEventListener(`mousedown`,e),document.addEventListener(`touchstart`,e),()=>{document.removeEventListener(`mousedown`,e),document.removeEventListener(`touchstart`,e)}},[]),n}exports.useClickOutside=t;
+const e=require("./use-latest-ref.cjs");let t=require("react");function n(n){let r=(0,t.useRef)(null),i=e.useLatestRef(n);return(0,t.useEffect)(()=>{if(typeof document>`u`)return;let e=e=>{let t=e.target;!r.current||t&&r.current.contains(t)||i.current()};return document.addEventListener(`mousedown`,e),document.addEventListener(`touchstart`,e),()=>{document.removeEventListener(`mousedown`,e),document.removeEventListener(`touchstart`,e)}},[i]),r}exports.useClickOutside=n;
 //# sourceMappingURL=use-click-outside.cjs.map

package/dist/hooks/use-click-outside.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-click-outside.cjs","names":[],"sources":["../../src/hooks/use-click-outside.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport type { RefObject } from \"react\";\n\n/**\n * Call `handler` when a `mousedown` / `touchstart` occurs outside the returned\n * ref's element. SSR-safe — listeners are only attached in the browser.\n *\n * @typeParam T - element type to attach the ref to.\n * @param handler - invoked on an outside interaction.\n * @returns A ref to attach to the element treated as \"inside\".\n */\nexport function useClickOutside<T extends HTMLElement = HTMLElement>(\n    handler: () => void,\n): RefObject<T | null> {\n    const ref = useRef<T>(null);\n    const handlerRef = useRef(handler);\n    useEffect(() => {\n        handlerRef.current = handler;\n    }, [handler]);\n\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n\n        const listener = (event: MouseEvent | TouchEvent): void => {\n            const target = event.target as Node | null;\n            if (!ref.current || (target && ref.current.contains(target))) return;\n            handlerRef.current();\n        };\n\n        document.addEventListener(\"mousedown\", listener);\n        document.addEventListener(\"touchstart\", listener);\n        return () => {\n            document.removeEventListener(\"mousedown\", listener);\n            document.removeEventListener(\"touchstart\", listener);\n        };\n    }, []);\n\n    return ref;\n}\n"],"mappings":"uBAWA,SAAgB,EACZ,EACmB,CACnB,IAAM,GAAA,EAAM,EAAA,OAAA,CAAU,IAAI,EACpB,GAAA,EAAa,EAAA,OAAA,CAAO,CAAO,EAsBjC,OArBA,EAAA,EAAA,UAAA,KAAgB,CACZ,EAAW,QAAU,CACzB,EAAG,CAAC,CAAO,CAAC,GAEZ,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,OAAO,SAAa,IAAa,OAErC,IAAM,EAAY,GAAyC,CACvD,IAAM,EAAS,EAAM,OACjB,CAAC,EAAI,SAAY,GAAU,EAAI,QAAQ,SAAS,CAAM,GAC1D,EAAW,QAAQ,CACvB,EAIA,OAFA,SAAS,iBAAiB,YAAa,CAAQ,EAC/C,SAAS,iBAAiB,aAAc,CAAQ,MACnC,CACT,SAAS,oBAAoB,YAAa,CAAQ,EAClD,SAAS,oBAAoB,aAAc,CAAQ,CACvD,CACJ,EAAG,CAAC,CAAC,EAEE,CACX"}
+{"version":3,"file":"use-click-outside.cjs","names":[],"sources":["../../src/hooks/use-click-outside.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\nimport type { RefObject } from \"react\";\n\n/**\n * Call `handler` when a `mousedown` / `touchstart` occurs outside the returned\n * ref's element. SSR-safe — listeners are only attached in the browser.\n *\n * @typeParam T - element type to attach the ref to.\n * @param handler - invoked on an outside interaction.\n * @returns A ref to attach to the element treated as \"inside\".\n */\nexport function useClickOutside<T extends HTMLElement = HTMLElement>(\n    handler: () => void,\n): RefObject<T | null> {\n    const ref = useRef<T>(null);\n    const handlerRef = useLatestRef(handler);\n\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n\n        const listener = (event: MouseEvent | TouchEvent): void => {\n            const target = event.target as Node | null;\n            if (!ref.current || (target && ref.current.contains(target))) return;\n            handlerRef.current();\n        };\n\n        document.addEventListener(\"mousedown\", listener);\n        document.addEventListener(\"touchstart\", listener);\n        return () => {\n            document.removeEventListener(\"mousedown\", listener);\n            document.removeEventListener(\"touchstart\", listener);\n        };\n    }, [handlerRef]);\n\n    return ref;\n}\n"],"mappings":"+DAYA,SAAgB,EACZ,EACmB,CACnB,IAAM,GAAA,EAAM,EAAA,OAAA,CAAU,IAAI,EACpB,EAAa,EAAA,aAAa,CAAO,EAmBvC,OAjBA,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,OAAO,SAAa,IAAa,OAErC,IAAM,EAAY,GAAyC,CACvD,IAAM,EAAS,EAAM,OACjB,CAAC,EAAI,SAAY,GAAU,EAAI,QAAQ,SAAS,CAAM,GAC1D,EAAW,QAAQ,CACvB,EAIA,OAFA,SAAS,iBAAiB,YAAa,CAAQ,EAC/C,SAAS,iBAAiB,aAAc,CAAQ,MACnC,CACT,SAAS,oBAAoB,YAAa,CAAQ,EAClD,SAAS,oBAAoB,aAAc,CAAQ,CACvD,CACJ,EAAG,CAAC,CAAU,CAAC,EAER,CACX"}

package/dist/hooks/use-click-outside.js

@@ -1,21 +1,20 @@
-import { useEffect as e, useRef as t } from "react";
+import { useLatestRef as e } from "./use-latest-ref.js";
+import { useEffect as t, useRef as n } from "react";
 //#region src/hooks/use-click-outside.ts
-function n(n) {
-	let r = t(null), i = t(n);
-	return e(() => {
-		i.current = n;
-	}, [n]), e(() => {
+function r(r) {
+	let i = n(null), a = e(r);
+	return t(() => {
 		if (typeof document > "u") return;
 		let e = (e) => {
 			let t = e.target;
-			!r.current || t && r.current.contains(t) || i.current();
+			!i.current || t && i.current.contains(t) || a.current();
 		};
 		return document.addEventListener("mousedown", e), document.addEventListener("touchstart", e), () => {
 			document.removeEventListener("mousedown", e), document.removeEventListener("touchstart", e);
 		};
-	}, []), r;
+	}, [a]), i;
 }
 //#endregion
-export { n as useClickOutside };
+export { r as useClickOutside };
 
 //# sourceMappingURL=use-click-outside.js.map

package/dist/hooks/use-click-outside.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-click-outside.js","names":[],"sources":["../../src/hooks/use-click-outside.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport type { RefObject } from \"react\";\n\n/**\n * Call `handler` when a `mousedown` / `touchstart` occurs outside the returned\n * ref's element. SSR-safe — listeners are only attached in the browser.\n *\n * @typeParam T - element type to attach the ref to.\n * @param handler - invoked on an outside interaction.\n * @returns A ref to attach to the element treated as \"inside\".\n */\nexport function useClickOutside<T extends HTMLElement = HTMLElement>(\n    handler: () => void,\n): RefObject<T | null> {\n    const ref = useRef<T>(null);\n    const handlerRef = useRef(handler);\n    useEffect(() => {\n        handlerRef.current = handler;\n    }, [handler]);\n\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n\n        const listener = (event: MouseEvent | TouchEvent): void => {\n            const target = event.target as Node | null;\n            if (!ref.current || (target && ref.current.contains(target))) return;\n            handlerRef.current();\n        };\n\n        document.addEventListener(\"mousedown\", listener);\n        document.addEventListener(\"touchstart\", listener);\n        return () => {\n            document.removeEventListener(\"mousedown\", listener);\n            document.removeEventListener(\"touchstart\", listener);\n        };\n    }, []);\n\n    return ref;\n}\n"],"mappings":";;AAWA,SAAgB,EACZ,GACmB;CACnB,IAAM,IAAM,EAAU,IAAI,GACpB,IAAa,EAAO,CAAO;CAsBjC,OArBA,QAAgB;EACZ,EAAW,UAAU;CACzB,GAAG,CAAC,CAAO,CAAC,GAEZ,QAAgB;EACZ,IAAI,OAAO,WAAa,KAAa;EAErC,IAAM,KAAY,MAAyC;GACvD,IAAM,IAAS,EAAM;GACjB,CAAC,EAAI,WAAY,KAAU,EAAI,QAAQ,SAAS,CAAM,KAC1D,EAAW,QAAQ;EACvB;EAIA,OAFA,SAAS,iBAAiB,aAAa,CAAQ,GAC/C,SAAS,iBAAiB,cAAc,CAAQ,SACnC;GAET,AADA,SAAS,oBAAoB,aAAa,CAAQ,GAClD,SAAS,oBAAoB,cAAc,CAAQ;EACvD;CACJ,GAAG,CAAC,CAAC,GAEE;AACX"}
+{"version":3,"file":"use-click-outside.js","names":[],"sources":["../../src/hooks/use-click-outside.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\nimport type { RefObject } from \"react\";\n\n/**\n * Call `handler` when a `mousedown` / `touchstart` occurs outside the returned\n * ref's element. SSR-safe — listeners are only attached in the browser.\n *\n * @typeParam T - element type to attach the ref to.\n * @param handler - invoked on an outside interaction.\n * @returns A ref to attach to the element treated as \"inside\".\n */\nexport function useClickOutside<T extends HTMLElement = HTMLElement>(\n    handler: () => void,\n): RefObject<T | null> {\n    const ref = useRef<T>(null);\n    const handlerRef = useLatestRef(handler);\n\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n\n        const listener = (event: MouseEvent | TouchEvent): void => {\n            const target = event.target as Node | null;\n            if (!ref.current || (target && ref.current.contains(target))) return;\n            handlerRef.current();\n        };\n\n        document.addEventListener(\"mousedown\", listener);\n        document.addEventListener(\"touchstart\", listener);\n        return () => {\n            document.removeEventListener(\"mousedown\", listener);\n            document.removeEventListener(\"touchstart\", listener);\n        };\n    }, [handlerRef]);\n\n    return ref;\n}\n"],"mappings":";;;AAYA,SAAgB,EACZ,GACmB;CACnB,IAAM,IAAM,EAAU,IAAI,GACpB,IAAa,EAAa,CAAO;CAmBvC,OAjBA,QAAgB;EACZ,IAAI,OAAO,WAAa,KAAa;EAErC,IAAM,KAAY,MAAyC;GACvD,IAAM,IAAS,EAAM;GACjB,CAAC,EAAI,WAAY,KAAU,EAAI,QAAQ,SAAS,CAAM,KAC1D,EAAW,QAAQ;EACvB;EAIA,OAFA,SAAS,iBAAiB,aAAa,CAAQ,GAC/C,SAAS,iBAAiB,cAAc,CAAQ,SACnC;GAET,AADA,SAAS,oBAAoB,aAAa,CAAQ,GAClD,SAAS,oBAAoB,cAAc,CAAQ;EACvD;CACJ,GAAG,CAAC,CAAU,CAAC,GAER;AACX"}

package/dist/hooks/use-countdown.cjs

@@ -1,2 +1,2 @@
-let e=require("react");function t(t,n,r={}){let{tickMs:i=1e3}=r,a=(0,e.useCallback)(()=>Math.max(0,t-(Date.now()-n)),[t,n]),[o,s]=(0,e.useState)(a);return(0,e.useEffect)(()=>{let e=a();if(s(e),e<=0)return;let t=setInterval(()=>{let e=a();s(e),e<=0&&clearInterval(t)},i);return()=>clearInterval(t)},[a,i]),o}exports.useCountdown=t;
+const e=require("./use-interval.cjs");let t=require("react");function n(n,r,i={}){let{tickMs:a=1e3}=i,o=(0,t.useCallback)(()=>Math.max(0,n-(Date.now()-r)),[n,r]),[s,c]=(0,t.useState)(o);return(0,t.useEffect)(()=>{c(o())},[o]),e.useInterval(()=>c(o()),s>0?a:null),s}exports.useCountdown=n;
 //# sourceMappingURL=use-countdown.cjs.map

package/dist/hooks/use-countdown.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-countdown.cjs","names":[],"sources":["../../src/hooks/use-countdown.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from \"react\";\n\n/** Options for {@link useCountdown}. */\nexport interface UseCountdownOptions {\n    /**\n     * How often the remaining time is recomputed, in ms. Default `1000`, which\n     * suits a \"try again in 3s\" label; drop it to ~50 to drive a progress bar.\n     */\n    tickMs?: number;\n}\n\n/**\n * Counts down the time left on a window that started at a known instant.\n *\n * Written around a timestamp rather than a decrementing counter on purpose: the\n * remaining time is recomputed from `Date.now()` on every tick, so a throttled\n * background tab, a slow frame or a `setInterval` that drifts cannot make the\n * countdown disagree with the clock. Remounting recovers the correct value too,\n * which a counter held in state cannot do.\n *\n * The interval stops once it reaches zero instead of ticking forever behind a\n * clamp.\n *\n * @param durationMs - Length of the window.\n * @param startedAt - Epoch ms the window opened (`Date.now()` when it started).\n * @param options - Tick cadence.\n * @returns Milliseconds remaining, never below `0`.\n *\n * @example\n * const remaining = useCountdown(60_000, lastSentAt);\n *\n * <button disabled={remaining > 0}>\n *   {remaining > 0 ? `Reenviar em ${Math.ceil(remaining / 1000)}s` : \"Reenviar código\"}\n * </button>\n */\nexport function useCountdown(\n    durationMs: number,\n    startedAt: number,\n    options: UseCountdownOptions = {},\n): number {\n    const { tickMs = 1000 } = options;\n\n    const compute = useCallback(\n        () => Math.max(0, durationMs - (Date.now() - startedAt)),\n        [durationMs, startedAt],\n    );\n\n    const [remaining, setRemaining] = useState(compute);\n\n    useEffect(() => {\n        const initial = compute();\n        setRemaining(initial);\n        if (initial <= 0) return;\n\n        const id = setInterval(() => {\n            const next = compute();\n            setRemaining(next);\n            if (next <= 0) clearInterval(id);\n        }, tickMs);\n\n        return () => clearInterval(id);\n    }, [compute, tickMs]);\n\n    return remaining;\n}\n"],"mappings":"uBAmCA,SAAgB,EACZ,EACA,EACA,EAA+B,CAAC,EAC1B,CACN,GAAM,CAAE,SAAS,KAAS,EAEpB,GAAA,EAAU,EAAA,YAAA,KACN,KAAK,IAAI,EAAG,GAAc,KAAK,IAAI,EAAI,EAAU,EACvD,CAAC,EAAY,CAAS,CAC1B,EAEM,CAAC,EAAW,IAAA,EAAgB,EAAA,SAAA,CAAS,CAAO,EAgBlD,OAdA,EAAA,EAAA,UAAA,KAAgB,CACZ,IAAM,EAAU,EAAQ,EAExB,GADA,EAAa,CAAO,EAChB,GAAW,EAAG,OAElB,IAAM,EAAK,gBAAkB,CACzB,IAAM,EAAO,EAAQ,EACrB,EAAa,CAAI,EACb,GAAQ,GAAG,cAAc,CAAE,CACnC,EAAG,CAAM,EAET,UAAa,cAAc,CAAE,CACjC,EAAG,CAAC,EAAS,CAAM,CAAC,EAEb,CACX"}
+{"version":3,"file":"use-countdown.cjs","names":[],"sources":["../../src/hooks/use-countdown.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from \"react\";\nimport { useInterval } from \"./use-interval\";\n\n/** Options for {@link useCountdown}. */\nexport interface UseCountdownOptions {\n    /**\n     * How often the remaining time is recomputed, in ms. Default `1000`, which\n     * suits a \"try again in 3s\" label; drop it to ~50 to drive a progress bar.\n     */\n    tickMs?: number;\n}\n\n/**\n * Counts down the time left on a window that started at a known instant.\n *\n * Written around a timestamp rather than a decrementing counter on purpose: the\n * remaining time is recomputed from `Date.now()` on every tick, so a throttled\n * background tab, a slow frame or a `setInterval` that drifts cannot make the\n * countdown disagree with the clock. Remounting recovers the correct value too,\n * which a counter held in state cannot do.\n *\n * The interval stops once it reaches zero instead of ticking forever behind a\n * clamp — `useInterval` pauses on a `null` delay, so reaching zero is what tears\n * the timer down.\n *\n * @param durationMs - Length of the window.\n * @param startedAt - Epoch ms the window opened (`Date.now()` when it started).\n * @param options - Tick cadence.\n * @returns Milliseconds remaining, never below `0`.\n *\n * @example\n * const remaining = useCountdown(60_000, lastSentAt);\n *\n * <button disabled={remaining > 0}>\n *   {remaining > 0 ? `Reenviar em ${Math.ceil(remaining / 1000)}s` : \"Reenviar código\"}\n * </button>\n */\nexport function useCountdown(\n    durationMs: number,\n    startedAt: number,\n    options: UseCountdownOptions = {},\n): number {\n    const { tickMs = 1000 } = options;\n\n    const compute = useCallback(\n        () => Math.max(0, durationMs - (Date.now() - startedAt)),\n        [durationMs, startedAt],\n    );\n\n    const [remaining, setRemaining] = useState(compute);\n\n    useEffect(() => {\n        setRemaining(compute());\n    }, [compute]);\n\n    useInterval(() => setRemaining(compute()), remaining > 0 ? tickMs : null);\n\n    return remaining;\n}\n"],"mappings":"6DAqCA,SAAgB,EACZ,EACA,EACA,EAA+B,CAAC,EAC1B,CACN,GAAM,CAAE,SAAS,KAAS,EAEpB,GAAA,EAAU,EAAA,YAAA,KACN,KAAK,IAAI,EAAG,GAAc,KAAK,IAAI,EAAI,EAAU,EACvD,CAAC,EAAY,CAAS,CAC1B,EAEM,CAAC,EAAW,IAAA,EAAgB,EAAA,SAAA,CAAS,CAAO,EAQlD,OANA,EAAA,EAAA,UAAA,KAAgB,CACZ,EAAa,EAAQ,CAAC,CAC1B,EAAG,CAAC,CAAO,CAAC,EAEZ,EAAA,gBAAkB,EAAa,EAAQ,CAAC,EAAG,EAAY,EAAI,EAAS,IAAI,EAEjE,CACX"}

package/dist/hooks/use-countdown.js

@@ -1,18 +1,13 @@
-import { useCallback as e, useEffect as t, useState as n } from "react";
+import { useInterval as e } from "./use-interval.js";
+import { useCallback as t, useEffect as n, useState as r } from "react";
 //#region src/hooks/use-countdown.ts
-function r(r, i, a = {}) {
-	let { tickMs: o = 1e3 } = a, s = e(() => Math.max(0, r - (Date.now() - i)), [r, i]), [c, l] = n(s);
-	return t(() => {
-		let e = s();
-		if (l(e), e <= 0) return;
-		let t = setInterval(() => {
-			let e = s();
-			l(e), e <= 0 && clearInterval(t);
-		}, o);
-		return () => clearInterval(t);
-	}, [s, o]), c;
+function i(i, a, o = {}) {
+	let { tickMs: s = 1e3 } = o, c = t(() => Math.max(0, i - (Date.now() - a)), [i, a]), [l, u] = r(c);
+	return n(() => {
+		u(c());
+	}, [c]), e(() => u(c()), l > 0 ? s : null), l;
 }
 //#endregion
-export { r as useCountdown };
+export { i as useCountdown };
 
 //# sourceMappingURL=use-countdown.js.map

package/dist/hooks/use-countdown.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-countdown.js","names":[],"sources":["../../src/hooks/use-countdown.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from \"react\";\n\n/** Options for {@link useCountdown}. */\nexport interface UseCountdownOptions {\n    /**\n     * How often the remaining time is recomputed, in ms. Default `1000`, which\n     * suits a \"try again in 3s\" label; drop it to ~50 to drive a progress bar.\n     */\n    tickMs?: number;\n}\n\n/**\n * Counts down the time left on a window that started at a known instant.\n *\n * Written around a timestamp rather than a decrementing counter on purpose: the\n * remaining time is recomputed from `Date.now()` on every tick, so a throttled\n * background tab, a slow frame or a `setInterval` that drifts cannot make the\n * countdown disagree with the clock. Remounting recovers the correct value too,\n * which a counter held in state cannot do.\n *\n * The interval stops once it reaches zero instead of ticking forever behind a\n * clamp.\n *\n * @param durationMs - Length of the window.\n * @param startedAt - Epoch ms the window opened (`Date.now()` when it started).\n * @param options - Tick cadence.\n * @returns Milliseconds remaining, never below `0`.\n *\n * @example\n * const remaining = useCountdown(60_000, lastSentAt);\n *\n * <button disabled={remaining > 0}>\n *   {remaining > 0 ? `Reenviar em ${Math.ceil(remaining / 1000)}s` : \"Reenviar código\"}\n * </button>\n */\nexport function useCountdown(\n    durationMs: number,\n    startedAt: number,\n    options: UseCountdownOptions = {},\n): number {\n    const { tickMs = 1000 } = options;\n\n    const compute = useCallback(\n        () => Math.max(0, durationMs - (Date.now() - startedAt)),\n        [durationMs, startedAt],\n    );\n\n    const [remaining, setRemaining] = useState(compute);\n\n    useEffect(() => {\n        const initial = compute();\n        setRemaining(initial);\n        if (initial <= 0) return;\n\n        const id = setInterval(() => {\n            const next = compute();\n            setRemaining(next);\n            if (next <= 0) clearInterval(id);\n        }, tickMs);\n\n        return () => clearInterval(id);\n    }, [compute, tickMs]);\n\n    return remaining;\n}\n"],"mappings":";;AAmCA,SAAgB,EACZ,GACA,GACA,IAA+B,CAAC,GAC1B;CACN,IAAM,EAAE,YAAS,QAAS,GAEpB,IAAU,QACN,KAAK,IAAI,GAAG,KAAc,KAAK,IAAI,IAAI,EAAU,GACvD,CAAC,GAAY,CAAS,CAC1B,GAEM,CAAC,GAAW,KAAgB,EAAS,CAAO;CAgBlD,OAdA,QAAgB;EACZ,IAAM,IAAU,EAAQ;EAExB,IADA,EAAa,CAAO,GAChB,KAAW,GAAG;EAElB,IAAM,IAAK,kBAAkB;GACzB,IAAM,IAAO,EAAQ;GAErB,AADA,EAAa,CAAI,GACb,KAAQ,KAAG,cAAc,CAAE;EACnC,GAAG,CAAM;EAET,aAAa,cAAc,CAAE;CACjC,GAAG,CAAC,GAAS,CAAM,CAAC,GAEb;AACX"}
+{"version":3,"file":"use-countdown.js","names":[],"sources":["../../src/hooks/use-countdown.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from \"react\";\nimport { useInterval } from \"./use-interval\";\n\n/** Options for {@link useCountdown}. */\nexport interface UseCountdownOptions {\n    /**\n     * How often the remaining time is recomputed, in ms. Default `1000`, which\n     * suits a \"try again in 3s\" label; drop it to ~50 to drive a progress bar.\n     */\n    tickMs?: number;\n}\n\n/**\n * Counts down the time left on a window that started at a known instant.\n *\n * Written around a timestamp rather than a decrementing counter on purpose: the\n * remaining time is recomputed from `Date.now()` on every tick, so a throttled\n * background tab, a slow frame or a `setInterval` that drifts cannot make the\n * countdown disagree with the clock. Remounting recovers the correct value too,\n * which a counter held in state cannot do.\n *\n * The interval stops once it reaches zero instead of ticking forever behind a\n * clamp — `useInterval` pauses on a `null` delay, so reaching zero is what tears\n * the timer down.\n *\n * @param durationMs - Length of the window.\n * @param startedAt - Epoch ms the window opened (`Date.now()` when it started).\n * @param options - Tick cadence.\n * @returns Milliseconds remaining, never below `0`.\n *\n * @example\n * const remaining = useCountdown(60_000, lastSentAt);\n *\n * <button disabled={remaining > 0}>\n *   {remaining > 0 ? `Reenviar em ${Math.ceil(remaining / 1000)}s` : \"Reenviar código\"}\n * </button>\n */\nexport function useCountdown(\n    durationMs: number,\n    startedAt: number,\n    options: UseCountdownOptions = {},\n): number {\n    const { tickMs = 1000 } = options;\n\n    const compute = useCallback(\n        () => Math.max(0, durationMs - (Date.now() - startedAt)),\n        [durationMs, startedAt],\n    );\n\n    const [remaining, setRemaining] = useState(compute);\n\n    useEffect(() => {\n        setRemaining(compute());\n    }, [compute]);\n\n    useInterval(() => setRemaining(compute()), remaining > 0 ? tickMs : null);\n\n    return remaining;\n}\n"],"mappings":";;;AAqCA,SAAgB,EACZ,GACA,GACA,IAA+B,CAAC,GAC1B;CACN,IAAM,EAAE,YAAS,QAAS,GAEpB,IAAU,QACN,KAAK,IAAI,GAAG,KAAc,KAAK,IAAI,IAAI,EAAU,GACvD,CAAC,GAAY,CAAS,CAC1B,GAEM,CAAC,GAAW,KAAgB,EAAS,CAAO;CAQlD,OANA,QAAgB;EACZ,EAAa,EAAQ,CAAC;CAC1B,GAAG,CAAC,CAAO,CAAC,GAEZ,QAAkB,EAAa,EAAQ,CAAC,GAAG,IAAY,IAAI,IAAS,IAAI,GAEjE;AACX"}

package/dist/hooks/use-event-listener.cjs

@@ -1,2 +1,2 @@
-let e=require("react");function t(t,n,r,i){let a=(0,e.useRef)(n);(0,e.useEffect)(()=>{a.current=n},[n]),(0,e.useEffect)(()=>{let e=r===void 0?typeof window>`u`?null:window:`current`in r?r.current??null:r;if(!e?.addEventListener)return;let n=e=>a.current(e);return e.addEventListener(t,n,i),()=>e.removeEventListener(t,n,i)},[t,r,i])}exports.useEventListener=t;
+const e=require("./use-latest-ref.cjs");let t=require("react");function n(n,r,i,a){let o=e.useLatestRef(r);(0,t.useEffect)(()=>{let e=i===void 0?typeof window>`u`?null:window:`current`in i?i.current??null:i;if(!e?.addEventListener)return;let t=e=>o.current(e);return e.addEventListener(n,t,a),()=>e.removeEventListener(n,t,a)},[n,i,a,o])}exports.useEventListener=n;
 //# sourceMappingURL=use-event-listener.cjs.map

package/dist/hooks/use-event-listener.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-event-listener.cjs","names":[],"sources":["../../src/hooks/use-event-listener.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\n\ntype AnyEventTarget = EventTarget | { current: EventTarget | null } | null | undefined;\n\n/**\n * Subscribe to a DOM event with React-friendly semantics.\n *\n * - Handler is stored in a ref so callers can pass inline functions without\n *   resubscribing on every render.\n * - `target` defaults to `window`. Accepts a raw `EventTarget` (window, document,\n *   element) OR a ref pointing at one.\n * - Returns nothing — cleanup is automatic on unmount or when `eventName`/`target` change.\n *\n * @tempest-limits param-count — deliberately the same positional shape as\n * `addEventListener(type, listener, options)`, with the target inserted where React\n * needs it. A hook that mirrors a DOM API is read by everyone who already knows the\n * DOM API; a bespoke options bag would make the familiar call unfamiliar.\n */\nexport function useEventListener<K extends keyof WindowEventMap>(\n    eventName: K,\n    handler: (event: WindowEventMap[K]) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void;\nexport function useEventListener<K extends keyof DocumentEventMap>(\n    eventName: K,\n    handler: (event: DocumentEventMap[K]) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void;\nexport function useEventListener<K extends keyof HTMLElementEventMap>(\n    eventName: K,\n    handler: (event: HTMLElementEventMap[K]) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void;\nexport function useEventListener(\n    eventName: string,\n    handler: (event: Event) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void {\n    const handlerRef = useRef(handler);\n    useEffect(() => {\n        handlerRef.current = handler;\n    }, [handler]);\n\n    useEffect(() => {\n        const resolvedTarget: EventTarget | null =\n            target === undefined\n                ? typeof window === \"undefined\"\n                    ? null\n                    : window\n                : \"current\" in (target as { current: unknown })\n                  ? ((target as { current: EventTarget | null }).current ?? null)\n                  : (target as EventTarget | null);\n\n        if (!resolvedTarget?.addEventListener) return;\n\n        const listener: EventListener = (event) => handlerRef.current(event);\n        resolvedTarget.addEventListener(eventName, listener, options);\n        return () => resolvedTarget.removeEventListener(eventName, listener, options);\n    }, [eventName, target, options]);\n}\n"],"mappings":"uBAoCA,SAAgB,EACZ,EACA,EACA,EACA,EACI,CACJ,IAAM,GAAA,EAAa,EAAA,OAAA,CAAO,CAAO,GACjC,EAAA,EAAA,UAAA,KAAgB,CACZ,EAAW,QAAU,CACzB,EAAG,CAAC,CAAO,CAAC,GAEZ,EAAA,EAAA,UAAA,KAAgB,CACZ,IAAM,EACF,IAAW,IAAA,GACL,OAAO,OAAW,IACd,KACA,OACJ,YAAc,EACV,EAA2C,SAAW,KACvD,EAEb,GAAI,CAAC,GAAgB,iBAAkB,OAEvC,IAAM,EAA2B,GAAU,EAAW,QAAQ,CAAK,EAEnE,OADA,EAAe,iBAAiB,EAAW,EAAU,CAAO,MAC/C,EAAe,oBAAoB,EAAW,EAAU,CAAO,CAChF,EAAG,CAAC,EAAW,EAAQ,CAAO,CAAC,CACnC"}
+{"version":3,"file":"use-event-listener.cjs","names":[],"sources":["../../src/hooks/use-event-listener.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\n\ntype AnyEventTarget = EventTarget | { current: EventTarget | null } | null | undefined;\n\n/**\n * Subscribe to a DOM event with React-friendly semantics.\n *\n * - Handler is stored in a ref so callers can pass inline functions without\n *   resubscribing on every render.\n * - `target` defaults to `window`. Accepts a raw `EventTarget` (window, document,\n *   element) OR a ref pointing at one.\n * - Returns nothing — cleanup is automatic on unmount or when `eventName`/`target` change.\n *\n * @tempest-limits param-count — deliberately the same positional shape as\n * `addEventListener(type, listener, options)`, with the target inserted where React\n * needs it. A hook that mirrors a DOM API is read by everyone who already knows the\n * DOM API; a bespoke options bag would make the familiar call unfamiliar.\n */\nexport function useEventListener<K extends keyof WindowEventMap>(\n    eventName: K,\n    handler: (event: WindowEventMap[K]) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void;\nexport function useEventListener<K extends keyof DocumentEventMap>(\n    eventName: K,\n    handler: (event: DocumentEventMap[K]) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void;\nexport function useEventListener<K extends keyof HTMLElementEventMap>(\n    eventName: K,\n    handler: (event: HTMLElementEventMap[K]) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void;\nexport function useEventListener(\n    eventName: string,\n    handler: (event: Event) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void {\n    const handlerRef = useLatestRef(handler);\n\n    useEffect(() => {\n        const resolvedTarget: EventTarget | null =\n            target === undefined\n                ? typeof window === \"undefined\"\n                    ? null\n                    : window\n                : \"current\" in (target as { current: unknown })\n                  ? ((target as { current: EventTarget | null }).current ?? null)\n                  : (target as EventTarget | null);\n\n        if (!resolvedTarget?.addEventListener) return;\n\n        const listener: EventListener = (event) => handlerRef.current(event);\n        resolvedTarget.addEventListener(eventName, listener, options);\n        return () => resolvedTarget.removeEventListener(eventName, listener, options);\n    }, [eventName, target, options, handlerRef]);\n}\n"],"mappings":"+DAqCA,SAAgB,EACZ,EACA,EACA,EACA,EACI,CACJ,IAAM,EAAa,EAAA,aAAa,CAAO,GAEvC,EAAA,EAAA,UAAA,KAAgB,CACZ,IAAM,EACF,IAAW,IAAA,GACL,OAAO,OAAW,IACd,KACA,OACJ,YAAc,EACV,EAA2C,SAAW,KACvD,EAEb,GAAI,CAAC,GAAgB,iBAAkB,OAEvC,IAAM,EAA2B,GAAU,EAAW,QAAQ,CAAK,EAEnE,OADA,EAAe,iBAAiB,EAAW,EAAU,CAAO,MAC/C,EAAe,oBAAoB,EAAW,EAAU,CAAO,CAChF,EAAG,CAAC,EAAW,EAAQ,EAAS,CAAU,CAAC,CAC/C"}

package/dist/hooks/use-event-listener.js

@@ -1,10 +1,9 @@
-import { useEffect as e, useRef as t } from "react";
+import { useLatestRef as e } from "./use-latest-ref.js";
+import { useEffect as t } from "react";
 //#region src/hooks/use-event-listener.ts
 function n(n, r, i, a) {
-	let o = t(r);
-	e(() => {
-		o.current = r;
-	}, [r]), e(() => {
+	let o = e(r);
+	t(() => {
 		let e = i === void 0 ? typeof window > "u" ? null : window : "current" in i ? i.current ?? null : i;
 		if (!e?.addEventListener) return;
 		let t = (e) => o.current(e);
@@ -12,7 +11,8 @@ function n(n, r, i, a) {
 	}, [
 		n,
 		i,
-		a
+		a,
+		o
 	]);
 }
 //#endregion

package/dist/hooks/use-event-listener.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-event-listener.js","names":[],"sources":["../../src/hooks/use-event-listener.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\n\ntype AnyEventTarget = EventTarget | { current: EventTarget | null } | null | undefined;\n\n/**\n * Subscribe to a DOM event with React-friendly semantics.\n *\n * - Handler is stored in a ref so callers can pass inline functions without\n *   resubscribing on every render.\n * - `target` defaults to `window`. Accepts a raw `EventTarget` (window, document,\n *   element) OR a ref pointing at one.\n * - Returns nothing — cleanup is automatic on unmount or when `eventName`/`target` change.\n *\n * @tempest-limits param-count — deliberately the same positional shape as\n * `addEventListener(type, listener, options)`, with the target inserted where React\n * needs it. A hook that mirrors a DOM API is read by everyone who already knows the\n * DOM API; a bespoke options bag would make the familiar call unfamiliar.\n */\nexport function useEventListener<K extends keyof WindowEventMap>(\n    eventName: K,\n    handler: (event: WindowEventMap[K]) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void;\nexport function useEventListener<K extends keyof DocumentEventMap>(\n    eventName: K,\n    handler: (event: DocumentEventMap[K]) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void;\nexport function useEventListener<K extends keyof HTMLElementEventMap>(\n    eventName: K,\n    handler: (event: HTMLElementEventMap[K]) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void;\nexport function useEventListener(\n    eventName: string,\n    handler: (event: Event) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void {\n    const handlerRef = useRef(handler);\n    useEffect(() => {\n        handlerRef.current = handler;\n    }, [handler]);\n\n    useEffect(() => {\n        const resolvedTarget: EventTarget | null =\n            target === undefined\n                ? typeof window === \"undefined\"\n                    ? null\n                    : window\n                : \"current\" in (target as { current: unknown })\n                  ? ((target as { current: EventTarget | null }).current ?? null)\n                  : (target as EventTarget | null);\n\n        if (!resolvedTarget?.addEventListener) return;\n\n        const listener: EventListener = (event) => handlerRef.current(event);\n        resolvedTarget.addEventListener(eventName, listener, options);\n        return () => resolvedTarget.removeEventListener(eventName, listener, options);\n    }, [eventName, target, options]);\n}\n"],"mappings":";;AAoCA,SAAgB,EACZ,GACA,GACA,GACA,GACI;CACJ,IAAM,IAAa,EAAO,CAAO;CAKjC,AAJA,QAAgB;EACZ,EAAW,UAAU;CACzB,GAAG,CAAC,CAAO,CAAC,GAEZ,QAAgB;EACZ,IAAM,IACF,MAAW,KAAA,IACL,OAAO,SAAW,MACd,OACA,SACJ,aAAc,IACV,EAA2C,WAAW,OACvD;EAEb,IAAI,CAAC,GAAgB,kBAAkB;EAEvC,IAAM,KAA2B,MAAU,EAAW,QAAQ,CAAK;EAEnE,OADA,EAAe,iBAAiB,GAAW,GAAU,CAAO,SAC/C,EAAe,oBAAoB,GAAW,GAAU,CAAO;CAChF,GAAG;EAAC;EAAW;EAAQ;CAAO,CAAC;AACnC"}
+{"version":3,"file":"use-event-listener.js","names":[],"sources":["../../src/hooks/use-event-listener.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\n\ntype AnyEventTarget = EventTarget | { current: EventTarget | null } | null | undefined;\n\n/**\n * Subscribe to a DOM event with React-friendly semantics.\n *\n * - Handler is stored in a ref so callers can pass inline functions without\n *   resubscribing on every render.\n * - `target` defaults to `window`. Accepts a raw `EventTarget` (window, document,\n *   element) OR a ref pointing at one.\n * - Returns nothing — cleanup is automatic on unmount or when `eventName`/`target` change.\n *\n * @tempest-limits param-count — deliberately the same positional shape as\n * `addEventListener(type, listener, options)`, with the target inserted where React\n * needs it. A hook that mirrors a DOM API is read by everyone who already knows the\n * DOM API; a bespoke options bag would make the familiar call unfamiliar.\n */\nexport function useEventListener<K extends keyof WindowEventMap>(\n    eventName: K,\n    handler: (event: WindowEventMap[K]) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void;\nexport function useEventListener<K extends keyof DocumentEventMap>(\n    eventName: K,\n    handler: (event: DocumentEventMap[K]) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void;\nexport function useEventListener<K extends keyof HTMLElementEventMap>(\n    eventName: K,\n    handler: (event: HTMLElementEventMap[K]) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void;\nexport function useEventListener(\n    eventName: string,\n    handler: (event: Event) => void,\n    target?: AnyEventTarget,\n    options?: AddEventListenerOptions | boolean,\n): void {\n    const handlerRef = useLatestRef(handler);\n\n    useEffect(() => {\n        const resolvedTarget: EventTarget | null =\n            target === undefined\n                ? typeof window === \"undefined\"\n                    ? null\n                    : window\n                : \"current\" in (target as { current: unknown })\n                  ? ((target as { current: EventTarget | null }).current ?? null)\n                  : (target as EventTarget | null);\n\n        if (!resolvedTarget?.addEventListener) return;\n\n        const listener: EventListener = (event) => handlerRef.current(event);\n        resolvedTarget.addEventListener(eventName, listener, options);\n        return () => resolvedTarget.removeEventListener(eventName, listener, options);\n    }, [eventName, target, options, handlerRef]);\n}\n"],"mappings":";;;AAqCA,SAAgB,EACZ,GACA,GACA,GACA,GACI;CACJ,IAAM,IAAa,EAAa,CAAO;CAEvC,QAAgB;EACZ,IAAM,IACF,MAAW,KAAA,IACL,OAAO,SAAW,MACd,OACA,SACJ,aAAc,IACV,EAA2C,WAAW,OACvD;EAEb,IAAI,CAAC,GAAgB,kBAAkB;EAEvC,IAAM,KAA2B,MAAU,EAAW,QAAQ,CAAK;EAEnE,OADA,EAAe,iBAAiB,GAAW,GAAU,CAAO,SAC/C,EAAe,oBAAoB,GAAW,GAAU,CAAO;CAChF,GAAG;EAAC;EAAW;EAAQ;EAAS;CAAU,CAAC;AAC/C"}

package/dist/hooks/use-interval.cjs

@@ -1,2 +1,2 @@
-let e=require("react");function t(t,n){let r=(0,e.useRef)(t);(0,e.useEffect)(()=>{r.current=t},[t]),(0,e.useEffect)(()=>{if(n===null)return;let e=setInterval(()=>r.current(),n);return()=>clearInterval(e)},[n])}exports.useInterval=t;
+const e=require("./use-latest-ref.cjs");let t=require("react");function n(n,r){let i=e.useLatestRef(n);(0,t.useEffect)(()=>{if(r===null)return;let e=setInterval(()=>i.current(),r);return()=>clearInterval(e)},[r,i])}exports.useInterval=n;
 //# sourceMappingURL=use-interval.cjs.map

package/dist/hooks/use-interval.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-interval.cjs","names":[],"sources":["../../src/hooks/use-interval.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\n\n/**\n * Reactive `setInterval`. Pass `null` as `delay` to pause. `fn` is stored in\n * a ref so inline callbacks don't reset the interval on every render.\n *\n * @example\n * useInterval(() => poll(), enabled ? 5000 : null);\n */\nexport function useInterval(fn: () => void, delay: number | null): void {\n    const fnRef = useRef(fn);\n    useEffect(() => {\n        fnRef.current = fn;\n    }, [fn]);\n\n    useEffect(() => {\n        if (delay === null) return;\n        const id = setInterval(() => fnRef.current(), delay);\n        return () => clearInterval(id);\n    }, [delay]);\n}\n"],"mappings":"uBASA,SAAgB,EAAY,EAAgB,EAA4B,CACpE,IAAM,GAAA,EAAQ,EAAA,OAAA,CAAO,CAAE,GACvB,EAAA,EAAA,UAAA,KAAgB,CACZ,EAAM,QAAU,CACpB,EAAG,CAAC,CAAE,CAAC,GAEP,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,IAAU,KAAM,OACpB,IAAM,EAAK,gBAAkB,EAAM,QAAQ,EAAG,CAAK,EACnD,UAAa,cAAc,CAAE,CACjC,EAAG,CAAC,CAAK,CAAC,CACd"}
+{"version":3,"file":"use-interval.cjs","names":[],"sources":["../../src/hooks/use-interval.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\n\n/**\n * Reactive `setInterval`. Pass `null` as `delay` to pause. `fn` is stored in\n * a ref so inline callbacks don't reset the interval on every render.\n *\n * @example\n * useInterval(() => poll(), enabled ? 5000 : null);\n */\nexport function useInterval(fn: () => void, delay: number | null): void {\n    const fnRef = useLatestRef(fn);\n\n    useEffect(() => {\n        if (delay === null) return;\n        const id = setInterval(() => fnRef.current(), delay);\n        return () => clearInterval(id);\n    }, [delay, fnRef]);\n}\n"],"mappings":"+DAUA,SAAgB,EAAY,EAAgB,EAA4B,CACpE,IAAM,EAAQ,EAAA,aAAa,CAAE,GAE7B,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,IAAU,KAAM,OACpB,IAAM,EAAK,gBAAkB,EAAM,QAAQ,EAAG,CAAK,EACnD,UAAa,cAAc,CAAE,CACjC,EAAG,CAAC,EAAO,CAAK,CAAC,CACrB"}

package/dist/hooks/use-interval.js

@@ -1,14 +1,13 @@
-import { useEffect as e, useRef as t } from "react";
+import { useLatestRef as e } from "./use-latest-ref.js";
+import { useEffect as t } from "react";
 //#region src/hooks/use-interval.ts
 function n(n, r) {
-	let i = t(n);
-	e(() => {
-		i.current = n;
-	}, [n]), e(() => {
+	let i = e(n);
+	t(() => {
 		if (r === null) return;
 		let e = setInterval(() => i.current(), r);
 		return () => clearInterval(e);
-	}, [r]);
+	}, [r, i]);
 }
 //#endregion
 export { n as useInterval };

package/dist/hooks/use-interval.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-interval.js","names":[],"sources":["../../src/hooks/use-interval.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\n\n/**\n * Reactive `setInterval`. Pass `null` as `delay` to pause. `fn` is stored in\n * a ref so inline callbacks don't reset the interval on every render.\n *\n * @example\n * useInterval(() => poll(), enabled ? 5000 : null);\n */\nexport function useInterval(fn: () => void, delay: number | null): void {\n    const fnRef = useRef(fn);\n    useEffect(() => {\n        fnRef.current = fn;\n    }, [fn]);\n\n    useEffect(() => {\n        if (delay === null) return;\n        const id = setInterval(() => fnRef.current(), delay);\n        return () => clearInterval(id);\n    }, [delay]);\n}\n"],"mappings":";;AASA,SAAgB,EAAY,GAAgB,GAA4B;CACpE,IAAM,IAAQ,EAAO,CAAE;CAKvB,AAJA,QAAgB;EACZ,EAAM,UAAU;CACpB,GAAG,CAAC,CAAE,CAAC,GAEP,QAAgB;EACZ,IAAI,MAAU,MAAM;EACpB,IAAM,IAAK,kBAAkB,EAAM,QAAQ,GAAG,CAAK;EACnD,aAAa,cAAc,CAAE;CACjC,GAAG,CAAC,CAAK,CAAC;AACd"}
+{"version":3,"file":"use-interval.js","names":[],"sources":["../../src/hooks/use-interval.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\n\n/**\n * Reactive `setInterval`. Pass `null` as `delay` to pause. `fn` is stored in\n * a ref so inline callbacks don't reset the interval on every render.\n *\n * @example\n * useInterval(() => poll(), enabled ? 5000 : null);\n */\nexport function useInterval(fn: () => void, delay: number | null): void {\n    const fnRef = useLatestRef(fn);\n\n    useEffect(() => {\n        if (delay === null) return;\n        const id = setInterval(() => fnRef.current(), delay);\n        return () => clearInterval(id);\n    }, [delay, fnRef]);\n}\n"],"mappings":";;;AAUA,SAAgB,EAAY,GAAgB,GAA4B;CACpE,IAAM,IAAQ,EAAa,CAAE;CAE7B,QAAgB;EACZ,IAAI,MAAU,MAAM;EACpB,IAAM,IAAK,kBAAkB,EAAM,QAAQ,GAAG,CAAK;EACnD,aAAa,cAAc,CAAE;CACjC,GAAG,CAAC,GAAO,CAAK,CAAC;AACrB"}

package/dist/hooks/use-latest-ref.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-latest-ref.cjs","names":[],"sources":["../../src/hooks/use-latest-ref.ts"],"sourcesContent":["/* eslint-disable react-hooks/refs -- writing at render time is deliberate; an effect would add a staleness window (see the docstring) */\nimport { useRef, type RefObject } from \"react\";\n\n/**\n * Keeps a ref pointing at the most recent value it was given.\n *\n * The escape hatch for reading fresh state inside something that must not be\n * re-created when that state changes: an interval, a subscription, an event\n * listener registered once on mount. Listing the value in the effect's\n * dependencies would tear the effect down and set it back up on every change;\n * omitting it captures the value from the render that created the closure and\n * never sees another. The ref is neither — a stable object whose `current` is\n * always current.\n *\n * The assignment happens **during render**, for the same reason\n * {@link useStableCallback} does it: moving it into an effect opens a\n * one-commit staleness window, where an effect declared earlier in the same\n * commit reads the previous render's value.\n *\n * Reach for {@link useStableCallback} instead when the value is a function you\n * want to *call* — it hands back a callable with a stable identity, rather than\n * making every call site reach through `.current`.\n *\n * @typeParam T - The tracked value.\n * @param value - The value to track. Written on every render.\n * @returns A stable ref whose `current` holds the latest `value`.\n *\n * @example\n * const optionsRef = useLatestRef(options);\n *\n * useEffect(() => {\n *   const id = setInterval(() => poll(optionsRef.current), 5_000);\n *   return () => clearInterval(id);\n * }, []); // the interval survives every options change, and still reads the latest\n */\nexport function useLatestRef<T>(value: T): RefObject<T> {\n    const ref = useRef(value);\n    ref.current = value;\n    return ref;\n}\n"],"mappings":"uBAmCA,SAAgB,EAAgB,EAAwB,CACpD,IAAM,GAAA,EAAM,EAAA,OAAA,CAAO,CAAK,EAExB,MADA,GAAI,QAAU,EACP,CACX"}
+{"version":3,"file":"use-latest-ref.cjs","names":[],"sources":["../../src/hooks/use-latest-ref.ts"],"sourcesContent":["/* eslint-disable react-hooks/refs -- writing at render time is deliberate; an effect would add a staleness window (see the docstring) */\nimport { useRef, type RefObject } from \"react\";\n\n/**\n * Keeps a ref pointing at the most recent value it was given.\n *\n * The escape hatch for reading fresh state inside something that must not be\n * re-created when that state changes: an interval, a subscription, an event\n * listener registered once on mount. Listing the value in the effect's\n * dependencies would tear the effect down and set it back up on every change;\n * omitting it captures the value from the render that created the closure and\n * never sees another. The ref is neither — a stable object whose `current` is\n * always current.\n *\n * The assignment happens **during render**, for the same reason\n * {@link useStableCallback} does it: moving it into an effect opens a\n * one-commit staleness window, where an effect declared earlier in the same\n * commit reads the previous render's value.\n *\n * Reach for {@link useStableCallback} instead when the value is a function you\n * want to *call* — it hands back a callable with a stable identity, rather than\n * making every call site reach through `.current`.\n *\n * **List the returned ref in your effect's dependencies.** It is a stable object,\n * so the effect never re-runs because of it, but `react-hooks/exhaustive-deps`\n * cannot prove that for a custom hook the way it does for a bare `useRef`.\n * Listing it lets the rule verify the array instead of taking an omission on\n * trust.\n *\n * **Not for holding the previous value.** The write happens during render, so\n * `.current` is already the current value by the time any effect reads it. A hook\n * that wants the value from the *previous* commit — `usePrevious` — needs the\n * effect-based write, and swapping it for this would make it return the present.\n *\n * @typeParam T - The tracked value.\n * @param value - The value to track. Written on every render.\n * @returns A stable ref whose `current` holds the latest `value`.\n *\n * @example\n * const optionsRef = useLatestRef(options);\n *\n * useEffect(() => {\n *   const id = setInterval(() => poll(optionsRef.current), 5_000);\n *   return () => clearInterval(id);\n * }, []); // the interval survives every options change, and still reads the latest\n */\nexport function useLatestRef<T>(value: T): RefObject<T> {\n    const ref = useRef(value);\n    ref.current = value;\n    return ref;\n}\n"],"mappings":"uBA8CA,SAAgB,EAAgB,EAAwB,CACpD,IAAM,GAAA,EAAM,EAAA,OAAA,CAAO,CAAK,EAExB,MADA,GAAI,QAAU,EACP,CACX"}

package/dist/hooks/use-latest-ref.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-latest-ref.js","names":[],"sources":["../../src/hooks/use-latest-ref.ts"],"sourcesContent":["/* eslint-disable react-hooks/refs -- writing at render time is deliberate; an effect would add a staleness window (see the docstring) */\nimport { useRef, type RefObject } from \"react\";\n\n/**\n * Keeps a ref pointing at the most recent value it was given.\n *\n * The escape hatch for reading fresh state inside something that must not be\n * re-created when that state changes: an interval, a subscription, an event\n * listener registered once on mount. Listing the value in the effect's\n * dependencies would tear the effect down and set it back up on every change;\n * omitting it captures the value from the render that created the closure and\n * never sees another. The ref is neither — a stable object whose `current` is\n * always current.\n *\n * The assignment happens **during render**, for the same reason\n * {@link useStableCallback} does it: moving it into an effect opens a\n * one-commit staleness window, where an effect declared earlier in the same\n * commit reads the previous render's value.\n *\n * Reach for {@link useStableCallback} instead when the value is a function you\n * want to *call* — it hands back a callable with a stable identity, rather than\n * making every call site reach through `.current`.\n *\n * @typeParam T - The tracked value.\n * @param value - The value to track. Written on every render.\n * @returns A stable ref whose `current` holds the latest `value`.\n *\n * @example\n * const optionsRef = useLatestRef(options);\n *\n * useEffect(() => {\n *   const id = setInterval(() => poll(optionsRef.current), 5_000);\n *   return () => clearInterval(id);\n * }, []); // the interval survives every options change, and still reads the latest\n */\nexport function useLatestRef<T>(value: T): RefObject<T> {\n    const ref = useRef(value);\n    ref.current = value;\n    return ref;\n}\n"],"mappings":";;AAmCA,SAAgB,EAAgB,GAAwB;CACpD,IAAM,IAAM,EAAO,CAAK;CAExB,OADA,EAAI,UAAU,GACP;AACX"}
+{"version":3,"file":"use-latest-ref.js","names":[],"sources":["../../src/hooks/use-latest-ref.ts"],"sourcesContent":["/* eslint-disable react-hooks/refs -- writing at render time is deliberate; an effect would add a staleness window (see the docstring) */\nimport { useRef, type RefObject } from \"react\";\n\n/**\n * Keeps a ref pointing at the most recent value it was given.\n *\n * The escape hatch for reading fresh state inside something that must not be\n * re-created when that state changes: an interval, a subscription, an event\n * listener registered once on mount. Listing the value in the effect's\n * dependencies would tear the effect down and set it back up on every change;\n * omitting it captures the value from the render that created the closure and\n * never sees another. The ref is neither — a stable object whose `current` is\n * always current.\n *\n * The assignment happens **during render**, for the same reason\n * {@link useStableCallback} does it: moving it into an effect opens a\n * one-commit staleness window, where an effect declared earlier in the same\n * commit reads the previous render's value.\n *\n * Reach for {@link useStableCallback} instead when the value is a function you\n * want to *call* — it hands back a callable with a stable identity, rather than\n * making every call site reach through `.current`.\n *\n * **List the returned ref in your effect's dependencies.** It is a stable object,\n * so the effect never re-runs because of it, but `react-hooks/exhaustive-deps`\n * cannot prove that for a custom hook the way it does for a bare `useRef`.\n * Listing it lets the rule verify the array instead of taking an omission on\n * trust.\n *\n * **Not for holding the previous value.** The write happens during render, so\n * `.current` is already the current value by the time any effect reads it. A hook\n * that wants the value from the *previous* commit — `usePrevious` — needs the\n * effect-based write, and swapping it for this would make it return the present.\n *\n * @typeParam T - The tracked value.\n * @param value - The value to track. Written on every render.\n * @returns A stable ref whose `current` holds the latest `value`.\n *\n * @example\n * const optionsRef = useLatestRef(options);\n *\n * useEffect(() => {\n *   const id = setInterval(() => poll(optionsRef.current), 5_000);\n *   return () => clearInterval(id);\n * }, []); // the interval survives every options change, and still reads the latest\n */\nexport function useLatestRef<T>(value: T): RefObject<T> {\n    const ref = useRef(value);\n    ref.current = value;\n    return ref;\n}\n"],"mappings":";;AA8CA,SAAgB,EAAgB,GAAwB;CACpD,IAAM,IAAM,EAAO,CAAK;CAExB,OADA,EAAI,UAAU,GACP;AACX"}

package/dist/hooks/use-long-press-handlers.cjs

@@ -1,2 +1,2 @@
-let e=require("react");function t(t,n={}){let{delayMs:r=500,disabled:i=!1}=n,a=(0,e.useRef)(null),o=(0,e.useRef)(!1),s=(0,e.useRef)(t);(0,e.useEffect)(()=>{s.current=t},[t]);let c=(0,e.useCallback)(()=>{a.current!==null&&(window.clearTimeout(a.current),a.current=null)},[]),l=(0,e.useCallback)(()=>{i||(o.current=!1,c(),a.current=window.setTimeout(()=>{o.current=!0,s.current()},r))},[i,c,r]);return{onMouseDown:l,onMouseUp:c,onMouseLeave:c,onTouchStart:l,onTouchEnd:c,onTouchMove:c,onContextMenu:(0,e.useCallback)(e=>{i||(e.preventDefault(),o.current=!0,s.current())},[i]),wasLongPress:()=>o.current}}exports.useLongPressHandlers=t;
+const e=require("./use-latest-ref.cjs");let t=require("react");function n(n,r={}){let{delayMs:i=500,disabled:a=!1}=r,o=(0,t.useRef)(null),s=(0,t.useRef)(!1),c=e.useLatestRef(n),l=(0,t.useCallback)(()=>{o.current!==null&&(window.clearTimeout(o.current),o.current=null)},[]),u=(0,t.useCallback)(()=>{a||(s.current=!1,l(),o.current=window.setTimeout(()=>{s.current=!0,c.current()},i))},[a,l,i,c]);return{onMouseDown:u,onMouseUp:l,onMouseLeave:l,onTouchStart:u,onTouchEnd:l,onTouchMove:l,onContextMenu:(0,t.useCallback)(e=>{a||(e.preventDefault(),s.current=!0,c.current())},[a,c]),wasLongPress:()=>s.current}}exports.useLongPressHandlers=n;
 //# sourceMappingURL=use-long-press-handlers.cjs.map

package/dist/hooks/use-long-press-handlers.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-long-press-handlers.cjs","names":[],"sources":["../../src/hooks/use-long-press-handlers.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from \"react\";\nimport type { MouseEvent as ReactMouseEvent, TouchEvent as ReactTouchEvent } from \"react\";\n\n/**\n * DOM event handlers produced by {@link useLongPressHandlers}, ready to spread\n * onto a JSX element (`<div {...handlers}>`).\n */\nexport interface LongPressHandlers {\n    /** Starts the hold timer on mouse press. */\n    onMouseDown: (event: ReactMouseEvent) => void;\n    /** Cancels the pending hold when the mouse is released. */\n    onMouseUp: () => void;\n    /** Cancels the pending hold when the pointer leaves the element. */\n    onMouseLeave: () => void;\n    /** Starts the hold timer on touch start. */\n    onTouchStart: (event: ReactTouchEvent) => void;\n    /** Cancels the pending hold when the touch ends. */\n    onTouchEnd: () => void;\n    /** Cancels the pending hold when the finger moves. */\n    onTouchMove: () => void;\n    /** Fires the long-press immediately (desktop right-click parity). */\n    onContextMenu: (event: ReactMouseEvent) => void;\n}\n\n/** Options accepted by {@link useLongPressHandlers}. */\nexport interface UseLongPressHandlersOptions {\n    /** Hold duration in ms before `onLongPress` fires. Defaults to `500`. */\n    delayMs?: number;\n    /** When `true`, the hook is inert and every handler is a no-op. */\n    disabled?: boolean;\n}\n\n/** Return shape of {@link useLongPressHandlers}. */\nexport type UseLongPressHandlersResult = LongPressHandlers & {\n    /**\n     * Reads whether the most recent interaction fired a long-press. Use it in\n     * the element's `onClick` to suppress the click that follows a long-press.\n     */\n    wasLongPress: () => boolean;\n};\n\n/**\n * Returns DOM event handlers that detect a long press (touch or mouse hold)\n * and invoke `onLongPress` once after `delayMs`.\n *\n * Cancels on touch movement or pointer release. Also wires `contextmenu` to\n * fire `onLongPress` immediately so a right-click on desktop opens selection\n * mode the same way an Android long-press does on mobile.\n *\n * The hook does not `preventDefault` on the underlying click — the consumer\n * decides whether the subsequent click should still fire. Track that with the\n * returned `wasLongPress()` guard to tell \"long-press fired\" apart from a\n * \"regular click\".\n *\n * Unlike {@link useLongPress}, which attaches pointer listeners to a `ref`,\n * this variant returns handler props you spread directly onto an element and\n * exposes a `wasLongPress()` guard.\n *\n * @param onLongPress - Callback invoked once the hold threshold is reached.\n * @param options - Optional `delayMs` and `disabled` flags.\n * @returns The spreadable handlers plus a `wasLongPress()` guard.\n *\n * @example\n * const longPress = useLongPressHandlers(() => enterSelectionMode(), { delayMs: 600 });\n * <button {...longPress} onClick={() => { if (!longPress.wasLongPress()) navigate(); }}>\n *   Item\n * </button>\n */\nexport function useLongPressHandlers(\n    onLongPress: () => void,\n    options: UseLongPressHandlersOptions = {},\n): UseLongPressHandlersResult {\n    const { delayMs = 500, disabled = false } = options;\n    const timerRef = useRef<number | null>(null);\n    const firedRef = useRef<boolean>(false);\n    const callbackRef = useRef<() => void>(onLongPress);\n    useEffect(() => {\n        callbackRef.current = onLongPress;\n    }, [onLongPress]);\n\n    const clear = useCallback((): void => {\n        if (timerRef.current !== null) {\n            window.clearTimeout(timerRef.current);\n            timerRef.current = null;\n        }\n    }, []);\n\n    const start = useCallback((): void => {\n        if (disabled) return;\n        firedRef.current = false;\n        clear();\n        timerRef.current = window.setTimeout(() => {\n            firedRef.current = true;\n            callbackRef.current();\n        }, delayMs);\n    }, [disabled, clear, delayMs]);\n\n    const onContextMenu = useCallback(\n        (event: ReactMouseEvent): void => {\n            if (disabled) return;\n            event.preventDefault();\n            firedRef.current = true;\n            callbackRef.current();\n        },\n        [disabled],\n    );\n\n    return {\n        onMouseDown: start,\n        onMouseUp: clear,\n        onMouseLeave: clear,\n        onTouchStart: start,\n        onTouchEnd: clear,\n        onTouchMove: clear,\n        onContextMenu,\n        wasLongPress: () => firedRef.current,\n    };\n}\n"],"mappings":"uBAoEA,SAAgB,EACZ,EACA,EAAuC,CAAC,EACd,CAC1B,GAAM,CAAE,UAAU,IAAK,WAAW,IAAU,EACtC,GAAA,EAAW,EAAA,OAAA,CAAsB,IAAI,EACrC,GAAA,EAAW,EAAA,OAAA,CAAgB,EAAK,EAChC,GAAA,EAAc,EAAA,OAAA,CAAmB,CAAW,GAClD,EAAA,EAAA,UAAA,KAAgB,CACZ,EAAY,QAAU,CAC1B,EAAG,CAAC,CAAW,CAAC,EAEhB,IAAM,GAAA,EAAQ,EAAA,YAAA,KAAwB,CAC9B,EAAS,UAAY,OACrB,OAAO,aAAa,EAAS,OAAO,EACpC,EAAS,QAAU,KAE3B,EAAG,CAAC,CAAC,EAEC,GAAA,EAAQ,EAAA,YAAA,KAAwB,CAC9B,IACJ,EAAS,QAAU,GACnB,EAAM,EACN,EAAS,QAAU,OAAO,eAAiB,CACvC,EAAS,QAAU,GACnB,EAAY,QAAQ,CACxB,EAAG,CAAO,EACd,EAAG,CAAC,EAAU,EAAO,CAAO,CAAC,EAY7B,MAAO,CACH,YAAa,EACb,UAAW,EACX,aAAc,EACd,aAAc,EACd,WAAY,EACZ,YAAa,EACb,eAAA,EAjBkB,EAAA,YAAA,CACjB,GAAiC,CAC1B,IACJ,EAAM,eAAe,EACrB,EAAS,QAAU,GACnB,EAAY,QAAQ,EACxB,EACA,CAAC,CAAQ,CAUT,EACA,iBAAoB,EAAS,OACjC,CACJ"}
+{"version":3,"file":"use-long-press-handlers.cjs","names":[],"sources":["../../src/hooks/use-long-press-handlers.ts"],"sourcesContent":["import { useCallback, useRef } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\nimport type { MouseEvent as ReactMouseEvent, TouchEvent as ReactTouchEvent } from \"react\";\n\n/**\n * DOM event handlers produced by {@link useLongPressHandlers}, ready to spread\n * onto a JSX element (`<div {...handlers}>`).\n */\nexport interface LongPressHandlers {\n    /** Starts the hold timer on mouse press. */\n    onMouseDown: (event: ReactMouseEvent) => void;\n    /** Cancels the pending hold when the mouse is released. */\n    onMouseUp: () => void;\n    /** Cancels the pending hold when the pointer leaves the element. */\n    onMouseLeave: () => void;\n    /** Starts the hold timer on touch start. */\n    onTouchStart: (event: ReactTouchEvent) => void;\n    /** Cancels the pending hold when the touch ends. */\n    onTouchEnd: () => void;\n    /** Cancels the pending hold when the finger moves. */\n    onTouchMove: () => void;\n    /** Fires the long-press immediately (desktop right-click parity). */\n    onContextMenu: (event: ReactMouseEvent) => void;\n}\n\n/** Options accepted by {@link useLongPressHandlers}. */\nexport interface UseLongPressHandlersOptions {\n    /** Hold duration in ms before `onLongPress` fires. Defaults to `500`. */\n    delayMs?: number;\n    /** When `true`, the hook is inert and every handler is a no-op. */\n    disabled?: boolean;\n}\n\n/** Return shape of {@link useLongPressHandlers}. */\nexport type UseLongPressHandlersResult = LongPressHandlers & {\n    /**\n     * Reads whether the most recent interaction fired a long-press. Use it in\n     * the element's `onClick` to suppress the click that follows a long-press.\n     */\n    wasLongPress: () => boolean;\n};\n\n/**\n * Returns DOM event handlers that detect a long press (touch or mouse hold)\n * and invoke `onLongPress` once after `delayMs`.\n *\n * Cancels on touch movement or pointer release. Also wires `contextmenu` to\n * fire `onLongPress` immediately so a right-click on desktop opens selection\n * mode the same way an Android long-press does on mobile.\n *\n * The hook does not `preventDefault` on the underlying click — the consumer\n * decides whether the subsequent click should still fire. Track that with the\n * returned `wasLongPress()` guard to tell \"long-press fired\" apart from a\n * \"regular click\".\n *\n * Unlike {@link useLongPress}, which attaches pointer listeners to a `ref`,\n * this variant returns handler props you spread directly onto an element and\n * exposes a `wasLongPress()` guard.\n *\n * @param onLongPress - Callback invoked once the hold threshold is reached.\n * @param options - Optional `delayMs` and `disabled` flags.\n * @returns The spreadable handlers plus a `wasLongPress()` guard.\n *\n * @example\n * const longPress = useLongPressHandlers(() => enterSelectionMode(), { delayMs: 600 });\n * <button {...longPress} onClick={() => { if (!longPress.wasLongPress()) navigate(); }}>\n *   Item\n * </button>\n */\nexport function useLongPressHandlers(\n    onLongPress: () => void,\n    options: UseLongPressHandlersOptions = {},\n): UseLongPressHandlersResult {\n    const { delayMs = 500, disabled = false } = options;\n    const timerRef = useRef<number | null>(null);\n    const firedRef = useRef<boolean>(false);\n    const callbackRef = useLatestRef(onLongPress);\n\n    const clear = useCallback((): void => {\n        if (timerRef.current !== null) {\n            window.clearTimeout(timerRef.current);\n            timerRef.current = null;\n        }\n    }, []);\n\n    const start = useCallback((): void => {\n        if (disabled) return;\n        firedRef.current = false;\n        clear();\n        timerRef.current = window.setTimeout(() => {\n            firedRef.current = true;\n            callbackRef.current();\n        }, delayMs);\n    }, [disabled, clear, delayMs, callbackRef]);\n\n    const onContextMenu = useCallback(\n        (event: ReactMouseEvent): void => {\n            if (disabled) return;\n            event.preventDefault();\n            firedRef.current = true;\n            callbackRef.current();\n        },\n        [disabled, callbackRef],\n    );\n\n    return {\n        onMouseDown: start,\n        onMouseUp: clear,\n        onMouseLeave: clear,\n        onTouchStart: start,\n        onTouchEnd: clear,\n        onTouchMove: clear,\n        onContextMenu,\n        wasLongPress: () => firedRef.current,\n    };\n}\n"],"mappings":"+DAqEA,SAAgB,EACZ,EACA,EAAuC,CAAC,EACd,CAC1B,GAAM,CAAE,UAAU,IAAK,WAAW,IAAU,EACtC,GAAA,EAAW,EAAA,OAAA,CAAsB,IAAI,EACrC,GAAA,EAAW,EAAA,OAAA,CAAgB,EAAK,EAChC,EAAc,EAAA,aAAa,CAAW,EAEtC,GAAA,EAAQ,EAAA,YAAA,KAAwB,CAC9B,EAAS,UAAY,OACrB,OAAO,aAAa,EAAS,OAAO,EACpC,EAAS,QAAU,KAE3B,EAAG,CAAC,CAAC,EAEC,GAAA,EAAQ,EAAA,YAAA,KAAwB,CAC9B,IACJ,EAAS,QAAU,GACnB,EAAM,EACN,EAAS,QAAU,OAAO,eAAiB,CACvC,EAAS,QAAU,GACnB,EAAY,QAAQ,CACxB,EAAG,CAAO,EACd,EAAG,CAAC,EAAU,EAAO,EAAS,CAAW,CAAC,EAY1C,MAAO,CACH,YAAa,EACb,UAAW,EACX,aAAc,EACd,aAAc,EACd,WAAY,EACZ,YAAa,EACb,eAAA,EAjBkB,EAAA,YAAA,CACjB,GAAiC,CAC1B,IACJ,EAAM,eAAe,EACrB,EAAS,QAAU,GACnB,EAAY,QAAQ,EACxB,EACA,CAAC,EAAU,CAAW,CAUtB,EACA,iBAAoB,EAAS,OACjC,CACJ"}

package/dist/hooks/use-long-press-handlers.js

@@ -1,20 +1,18 @@
-import { useCallback as e, useEffect as t, useRef as n } from "react";
+import { useLatestRef as e } from "./use-latest-ref.js";
+import { useCallback as t, useRef as n } from "react";
 //#region src/hooks/use-long-press-handlers.ts
 function r(r, i = {}) {
-	let { delayMs: a = 500, disabled: o = !1 } = i, s = n(null), c = n(!1), l = n(r);
-	t(() => {
-		l.current = r;
-	}, [r]);
-	let u = e(() => {
+	let { delayMs: a = 500, disabled: o = !1 } = i, s = n(null), c = n(!1), l = e(r), u = t(() => {
 		s.current !== null && (window.clearTimeout(s.current), s.current = null);
-	}, []), d = e(() => {
+	}, []), d = t(() => {
 		o || (c.current = !1, u(), s.current = window.setTimeout(() => {
 			c.current = !0, l.current();
 		}, a));
 	}, [
 		o,
 		u,
-		a
+		a,
+		l
 	]);
 	return {
 		onMouseDown: d,
@@ -23,9 +21,9 @@ function r(r, i = {}) {
 		onTouchStart: d,
 		onTouchEnd: u,
 		onTouchMove: u,
-		onContextMenu: e((e) => {
+		onContextMenu: t((e) => {
 			o || (e.preventDefault(), c.current = !0, l.current());
-		}, [o]),
+		}, [o, l]),
 		wasLongPress: () => c.current
 	};
 }

package/dist/hooks/use-long-press-handlers.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-long-press-handlers.js","names":[],"sources":["../../src/hooks/use-long-press-handlers.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from \"react\";\nimport type { MouseEvent as ReactMouseEvent, TouchEvent as ReactTouchEvent } from \"react\";\n\n/**\n * DOM event handlers produced by {@link useLongPressHandlers}, ready to spread\n * onto a JSX element (`<div {...handlers}>`).\n */\nexport interface LongPressHandlers {\n    /** Starts the hold timer on mouse press. */\n    onMouseDown: (event: ReactMouseEvent) => void;\n    /** Cancels the pending hold when the mouse is released. */\n    onMouseUp: () => void;\n    /** Cancels the pending hold when the pointer leaves the element. */\n    onMouseLeave: () => void;\n    /** Starts the hold timer on touch start. */\n    onTouchStart: (event: ReactTouchEvent) => void;\n    /** Cancels the pending hold when the touch ends. */\n    onTouchEnd: () => void;\n    /** Cancels the pending hold when the finger moves. */\n    onTouchMove: () => void;\n    /** Fires the long-press immediately (desktop right-click parity). */\n    onContextMenu: (event: ReactMouseEvent) => void;\n}\n\n/** Options accepted by {@link useLongPressHandlers}. */\nexport interface UseLongPressHandlersOptions {\n    /** Hold duration in ms before `onLongPress` fires. Defaults to `500`. */\n    delayMs?: number;\n    /** When `true`, the hook is inert and every handler is a no-op. */\n    disabled?: boolean;\n}\n\n/** Return shape of {@link useLongPressHandlers}. */\nexport type UseLongPressHandlersResult = LongPressHandlers & {\n    /**\n     * Reads whether the most recent interaction fired a long-press. Use it in\n     * the element's `onClick` to suppress the click that follows a long-press.\n     */\n    wasLongPress: () => boolean;\n};\n\n/**\n * Returns DOM event handlers that detect a long press (touch or mouse hold)\n * and invoke `onLongPress` once after `delayMs`.\n *\n * Cancels on touch movement or pointer release. Also wires `contextmenu` to\n * fire `onLongPress` immediately so a right-click on desktop opens selection\n * mode the same way an Android long-press does on mobile.\n *\n * The hook does not `preventDefault` on the underlying click — the consumer\n * decides whether the subsequent click should still fire. Track that with the\n * returned `wasLongPress()` guard to tell \"long-press fired\" apart from a\n * \"regular click\".\n *\n * Unlike {@link useLongPress}, which attaches pointer listeners to a `ref`,\n * this variant returns handler props you spread directly onto an element and\n * exposes a `wasLongPress()` guard.\n *\n * @param onLongPress - Callback invoked once the hold threshold is reached.\n * @param options - Optional `delayMs` and `disabled` flags.\n * @returns The spreadable handlers plus a `wasLongPress()` guard.\n *\n * @example\n * const longPress = useLongPressHandlers(() => enterSelectionMode(), { delayMs: 600 });\n * <button {...longPress} onClick={() => { if (!longPress.wasLongPress()) navigate(); }}>\n *   Item\n * </button>\n */\nexport function useLongPressHandlers(\n    onLongPress: () => void,\n    options: UseLongPressHandlersOptions = {},\n): UseLongPressHandlersResult {\n    const { delayMs = 500, disabled = false } = options;\n    const timerRef = useRef<number | null>(null);\n    const firedRef = useRef<boolean>(false);\n    const callbackRef = useRef<() => void>(onLongPress);\n    useEffect(() => {\n        callbackRef.current = onLongPress;\n    }, [onLongPress]);\n\n    const clear = useCallback((): void => {\n        if (timerRef.current !== null) {\n            window.clearTimeout(timerRef.current);\n            timerRef.current = null;\n        }\n    }, []);\n\n    const start = useCallback((): void => {\n        if (disabled) return;\n        firedRef.current = false;\n        clear();\n        timerRef.current = window.setTimeout(() => {\n            firedRef.current = true;\n            callbackRef.current();\n        }, delayMs);\n    }, [disabled, clear, delayMs]);\n\n    const onContextMenu = useCallback(\n        (event: ReactMouseEvent): void => {\n            if (disabled) return;\n            event.preventDefault();\n            firedRef.current = true;\n            callbackRef.current();\n        },\n        [disabled],\n    );\n\n    return {\n        onMouseDown: start,\n        onMouseUp: clear,\n        onMouseLeave: clear,\n        onTouchStart: start,\n        onTouchEnd: clear,\n        onTouchMove: clear,\n        onContextMenu,\n        wasLongPress: () => firedRef.current,\n    };\n}\n"],"mappings":";;AAoEA,SAAgB,EACZ,GACA,IAAuC,CAAC,GACd;CAC1B,IAAM,EAAE,aAAU,KAAK,cAAW,OAAU,GACtC,IAAW,EAAsB,IAAI,GACrC,IAAW,EAAgB,EAAK,GAChC,IAAc,EAAmB,CAAW;CAClD,QAAgB;EACZ,EAAY,UAAU;CAC1B,GAAG,CAAC,CAAW,CAAC;CAEhB,IAAM,IAAQ,QAAwB;EAClC,AAAI,EAAS,YAAY,SACrB,OAAO,aAAa,EAAS,OAAO,GACpC,EAAS,UAAU;CAE3B,GAAG,CAAC,CAAC,GAEC,IAAQ,QAAwB;EAC9B,MACJ,EAAS,UAAU,IACnB,EAAM,GACN,EAAS,UAAU,OAAO,iBAAiB;GAEvC,AADA,EAAS,UAAU,IACnB,EAAY,QAAQ;EACxB,GAAG,CAAO;CACd,GAAG;EAAC;EAAU;EAAO;CAAO,CAAC;CAY7B,OAAO;EACH,aAAa;EACb,WAAW;EACX,cAAc;EACd,cAAc;EACd,YAAY;EACZ,aAAa;EACb,eAjBkB,GACjB,MAAiC;GAC1B,MACJ,EAAM,eAAe,GACrB,EAAS,UAAU,IACnB,EAAY,QAAQ;EACxB,GACA,CAAC,CAAQ,CAUT;EACA,oBAAoB,EAAS;CACjC;AACJ"}
+{"version":3,"file":"use-long-press-handlers.js","names":[],"sources":["../../src/hooks/use-long-press-handlers.ts"],"sourcesContent":["import { useCallback, useRef } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\nimport type { MouseEvent as ReactMouseEvent, TouchEvent as ReactTouchEvent } from \"react\";\n\n/**\n * DOM event handlers produced by {@link useLongPressHandlers}, ready to spread\n * onto a JSX element (`<div {...handlers}>`).\n */\nexport interface LongPressHandlers {\n    /** Starts the hold timer on mouse press. */\n    onMouseDown: (event: ReactMouseEvent) => void;\n    /** Cancels the pending hold when the mouse is released. */\n    onMouseUp: () => void;\n    /** Cancels the pending hold when the pointer leaves the element. */\n    onMouseLeave: () => void;\n    /** Starts the hold timer on touch start. */\n    onTouchStart: (event: ReactTouchEvent) => void;\n    /** Cancels the pending hold when the touch ends. */\n    onTouchEnd: () => void;\n    /** Cancels the pending hold when the finger moves. */\n    onTouchMove: () => void;\n    /** Fires the long-press immediately (desktop right-click parity). */\n    onContextMenu: (event: ReactMouseEvent) => void;\n}\n\n/** Options accepted by {@link useLongPressHandlers}. */\nexport interface UseLongPressHandlersOptions {\n    /** Hold duration in ms before `onLongPress` fires. Defaults to `500`. */\n    delayMs?: number;\n    /** When `true`, the hook is inert and every handler is a no-op. */\n    disabled?: boolean;\n}\n\n/** Return shape of {@link useLongPressHandlers}. */\nexport type UseLongPressHandlersResult = LongPressHandlers & {\n    /**\n     * Reads whether the most recent interaction fired a long-press. Use it in\n     * the element's `onClick` to suppress the click that follows a long-press.\n     */\n    wasLongPress: () => boolean;\n};\n\n/**\n * Returns DOM event handlers that detect a long press (touch or mouse hold)\n * and invoke `onLongPress` once after `delayMs`.\n *\n * Cancels on touch movement or pointer release. Also wires `contextmenu` to\n * fire `onLongPress` immediately so a right-click on desktop opens selection\n * mode the same way an Android long-press does on mobile.\n *\n * The hook does not `preventDefault` on the underlying click — the consumer\n * decides whether the subsequent click should still fire. Track that with the\n * returned `wasLongPress()` guard to tell \"long-press fired\" apart from a\n * \"regular click\".\n *\n * Unlike {@link useLongPress}, which attaches pointer listeners to a `ref`,\n * this variant returns handler props you spread directly onto an element and\n * exposes a `wasLongPress()` guard.\n *\n * @param onLongPress - Callback invoked once the hold threshold is reached.\n * @param options - Optional `delayMs` and `disabled` flags.\n * @returns The spreadable handlers plus a `wasLongPress()` guard.\n *\n * @example\n * const longPress = useLongPressHandlers(() => enterSelectionMode(), { delayMs: 600 });\n * <button {...longPress} onClick={() => { if (!longPress.wasLongPress()) navigate(); }}>\n *   Item\n * </button>\n */\nexport function useLongPressHandlers(\n    onLongPress: () => void,\n    options: UseLongPressHandlersOptions = {},\n): UseLongPressHandlersResult {\n    const { delayMs = 500, disabled = false } = options;\n    const timerRef = useRef<number | null>(null);\n    const firedRef = useRef<boolean>(false);\n    const callbackRef = useLatestRef(onLongPress);\n\n    const clear = useCallback((): void => {\n        if (timerRef.current !== null) {\n            window.clearTimeout(timerRef.current);\n            timerRef.current = null;\n        }\n    }, []);\n\n    const start = useCallback((): void => {\n        if (disabled) return;\n        firedRef.current = false;\n        clear();\n        timerRef.current = window.setTimeout(() => {\n            firedRef.current = true;\n            callbackRef.current();\n        }, delayMs);\n    }, [disabled, clear, delayMs, callbackRef]);\n\n    const onContextMenu = useCallback(\n        (event: ReactMouseEvent): void => {\n            if (disabled) return;\n            event.preventDefault();\n            firedRef.current = true;\n            callbackRef.current();\n        },\n        [disabled, callbackRef],\n    );\n\n    return {\n        onMouseDown: start,\n        onMouseUp: clear,\n        onMouseLeave: clear,\n        onTouchStart: start,\n        onTouchEnd: clear,\n        onTouchMove: clear,\n        onContextMenu,\n        wasLongPress: () => firedRef.current,\n    };\n}\n"],"mappings":";;;AAqEA,SAAgB,EACZ,GACA,IAAuC,CAAC,GACd;CAC1B,IAAM,EAAE,aAAU,KAAK,cAAW,OAAU,GACtC,IAAW,EAAsB,IAAI,GACrC,IAAW,EAAgB,EAAK,GAChC,IAAc,EAAa,CAAW,GAEtC,IAAQ,QAAwB;EAClC,AAAI,EAAS,YAAY,SACrB,OAAO,aAAa,EAAS,OAAO,GACpC,EAAS,UAAU;CAE3B,GAAG,CAAC,CAAC,GAEC,IAAQ,QAAwB;EAC9B,MACJ,EAAS,UAAU,IACnB,EAAM,GACN,EAAS,UAAU,OAAO,iBAAiB;GAEvC,AADA,EAAS,UAAU,IACnB,EAAY,QAAQ;EACxB,GAAG,CAAO;CACd,GAAG;EAAC;EAAU;EAAO;EAAS;CAAW,CAAC;CAY1C,OAAO;EACH,aAAa;EACb,WAAW;EACX,cAAc;EACd,cAAc;EACd,YAAY;EACZ,aAAa;EACb,eAjBkB,GACjB,MAAiC;GAC1B,MACJ,EAAM,eAAe,GACrB,EAAS,UAAU,IACnB,EAAY,QAAQ;EACxB,GACA,CAAC,GAAU,CAAW,CAUtB;EACA,oBAAoB,EAAS;CACjC;AACJ"}

package/dist/hooks/use-long-press.cjs

@@ -1,2 +1,2 @@
-let e=require("react");function t(t,n,r={}){let{delay:i=500,moveThreshold:a=10}=r,o=(0,e.useRef)(n);(0,e.useEffect)(()=>{o.current=n},[n]),(0,e.useEffect)(()=>{let e=t.current;if(!e)return;let n=null,r=0,s=0,c=()=>{n&&=(clearTimeout(n),null)},l=e=>{r=e.clientX,s=e.clientY,c(),n=setTimeout(()=>{n=null,o.current()},i)},u=e=>{if(n===null)return;let t=e.clientX-r,i=e.clientY-s;Math.hypot(t,i)>a&&c()};return e.addEventListener(`pointerdown`,l),e.addEventListener(`pointermove`,u),e.addEventListener(`pointerup`,c),e.addEventListener(`pointercancel`,c),e.addEventListener(`pointerleave`,c),()=>{c(),e.removeEventListener(`pointerdown`,l),e.removeEventListener(`pointermove`,u),e.removeEventListener(`pointerup`,c),e.removeEventListener(`pointercancel`,c),e.removeEventListener(`pointerleave`,c)}},[t,i,a])}exports.useLongPress=t;
+const e=require("./use-latest-ref.cjs");let t=require("react");function n(n,r,i={}){let{delay:a=500,moveThreshold:o=10}=i,s=e.useLatestRef(r);(0,t.useEffect)(()=>{let e=n.current;if(!e)return;let t=null,r=0,i=0,c=()=>{t&&=(clearTimeout(t),null)},l=e=>{r=e.clientX,i=e.clientY,c(),t=setTimeout(()=>{t=null,s.current()},a)},u=e=>{if(t===null)return;let n=e.clientX-r,a=e.clientY-i;Math.hypot(n,a)>o&&c()};return e.addEventListener(`pointerdown`,l),e.addEventListener(`pointermove`,u),e.addEventListener(`pointerup`,c),e.addEventListener(`pointercancel`,c),e.addEventListener(`pointerleave`,c),()=>{c(),e.removeEventListener(`pointerdown`,l),e.removeEventListener(`pointermove`,u),e.removeEventListener(`pointerup`,c),e.removeEventListener(`pointercancel`,c),e.removeEventListener(`pointerleave`,c)}},[n,a,o,s])}exports.useLongPress=n;
 //# sourceMappingURL=use-long-press.cjs.map

package/dist/hooks/use-long-press.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-long-press.cjs","names":[],"sources":["../../src/hooks/use-long-press.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport type { RefObject } from \"react\";\n\nexport interface UseLongPressOptions {\n    /** Press duration in ms. Default `500`. */\n    delay?: number;\n    /** Pixel threshold — finger/mouse movement beyond this cancels the press. Default `10`. */\n    moveThreshold?: number;\n}\n\n/**\n * Detect long-press / long-tap gestures. Fires `fn` after `delay` ms\n * while the element is held. Cancels on move beyond `moveThreshold` or\n * pointer up before `delay`.\n *\n * @example\n * const ref = useRef<HTMLDivElement>(null);\n * useLongPress(ref, () => openContextMenu(), { delay: 600 });\n */\nexport function useLongPress<T extends HTMLElement>(\n    ref: RefObject<T | null>,\n    fn: () => void,\n    options: UseLongPressOptions = {},\n): void {\n    const { delay = 500, moveThreshold = 10 } = options;\n    const fnRef = useRef(fn);\n    useEffect(() => {\n        fnRef.current = fn;\n    }, [fn]);\n\n    useEffect(() => {\n        const node = ref.current;\n        if (!node) return;\n        let timer: ReturnType<typeof setTimeout> | null = null;\n        let startX = 0;\n        let startY = 0;\n\n        const cancel = (): void => {\n            if (timer) {\n                clearTimeout(timer);\n                timer = null;\n            }\n        };\n\n        const onDown = (event: PointerEvent): void => {\n            startX = event.clientX;\n            startY = event.clientY;\n            cancel();\n            timer = setTimeout(() => {\n                timer = null;\n                fnRef.current();\n            }, delay);\n        };\n\n        const onMove = (event: PointerEvent): void => {\n            if (timer === null) return;\n            const dx = event.clientX - startX;\n            const dy = event.clientY - startY;\n            if (Math.hypot(dx, dy) > moveThreshold) cancel();\n        };\n\n        node.addEventListener(\"pointerdown\", onDown);\n        node.addEventListener(\"pointermove\", onMove);\n        node.addEventListener(\"pointerup\", cancel);\n        node.addEventListener(\"pointercancel\", cancel);\n        node.addEventListener(\"pointerleave\", cancel);\n        return () => {\n            cancel();\n            node.removeEventListener(\"pointerdown\", onDown);\n            node.removeEventListener(\"pointermove\", onMove);\n            node.removeEventListener(\"pointerup\", cancel);\n            node.removeEventListener(\"pointercancel\", cancel);\n            node.removeEventListener(\"pointerleave\", cancel);\n        };\n    }, [ref, delay, moveThreshold]);\n}\n"],"mappings":"uBAmBA,SAAgB,EACZ,EACA,EACA,EAA+B,CAAC,EAC5B,CACJ,GAAM,CAAE,QAAQ,IAAK,gBAAgB,IAAO,EACtC,GAAA,EAAQ,EAAA,OAAA,CAAO,CAAE,GACvB,EAAA,EAAA,UAAA,KAAgB,CACZ,EAAM,QAAU,CACpB,EAAG,CAAC,CAAE,CAAC,GAEP,EAAA,EAAA,UAAA,KAAgB,CACZ,IAAM,EAAO,EAAI,QACjB,GAAI,CAAC,EAAM,OACX,IAAI,EAA8C,KAC9C,EAAS,EACT,EAAS,EAEP,MAAqB,CACvB,AAEI,KADA,aAAa,CAAK,EACV,KAEhB,EAEM,EAAU,GAA8B,CAC1C,EAAS,EAAM,QACf,EAAS,EAAM,QACf,EAAO,EACP,EAAQ,eAAiB,CACrB,EAAQ,KACR,EAAM,QAAQ,CAClB,EAAG,CAAK,CACZ,EAEM,EAAU,GAA8B,CAC1C,GAAI,IAAU,KAAM,OACpB,IAAM,EAAK,EAAM,QAAU,EACrB,EAAK,EAAM,QAAU,EACvB,KAAK,MAAM,EAAI,CAAE,EAAI,GAAe,EAAO,CACnD,EAOA,OALA,EAAK,iBAAiB,cAAe,CAAM,EAC3C,EAAK,iBAAiB,cAAe,CAAM,EAC3C,EAAK,iBAAiB,YAAa,CAAM,EACzC,EAAK,iBAAiB,gBAAiB,CAAM,EAC7C,EAAK,iBAAiB,eAAgB,CAAM,MAC/B,CACT,EAAO,EACP,EAAK,oBAAoB,cAAe,CAAM,EAC9C,EAAK,oBAAoB,cAAe,CAAM,EAC9C,EAAK,oBAAoB,YAAa,CAAM,EAC5C,EAAK,oBAAoB,gBAAiB,CAAM,EAChD,EAAK,oBAAoB,eAAgB,CAAM,CACnD,CACJ,EAAG,CAAC,EAAK,EAAO,CAAa,CAAC,CAClC"}
+{"version":3,"file":"use-long-press.cjs","names":[],"sources":["../../src/hooks/use-long-press.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\nimport type { RefObject } from \"react\";\n\nexport interface UseLongPressOptions {\n    /** Press duration in ms. Default `500`. */\n    delay?: number;\n    /** Pixel threshold — finger/mouse movement beyond this cancels the press. Default `10`. */\n    moveThreshold?: number;\n}\n\n/**\n * Detect long-press / long-tap gestures. Fires `fn` after `delay` ms\n * while the element is held. Cancels on move beyond `moveThreshold` or\n * pointer up before `delay`.\n *\n * @example\n * const ref = useRef<HTMLDivElement>(null);\n * useLongPress(ref, () => openContextMenu(), { delay: 600 });\n */\nexport function useLongPress<T extends HTMLElement>(\n    ref: RefObject<T | null>,\n    fn: () => void,\n    options: UseLongPressOptions = {},\n): void {\n    const { delay = 500, moveThreshold = 10 } = options;\n    const fnRef = useLatestRef(fn);\n\n    useEffect(() => {\n        const node = ref.current;\n        if (!node) return;\n        let timer: ReturnType<typeof setTimeout> | null = null;\n        let startX = 0;\n        let startY = 0;\n\n        const cancel = (): void => {\n            if (timer) {\n                clearTimeout(timer);\n                timer = null;\n            }\n        };\n\n        const onDown = (event: PointerEvent): void => {\n            startX = event.clientX;\n            startY = event.clientY;\n            cancel();\n            timer = setTimeout(() => {\n                timer = null;\n                fnRef.current();\n            }, delay);\n        };\n\n        const onMove = (event: PointerEvent): void => {\n            if (timer === null) return;\n            const dx = event.clientX - startX;\n            const dy = event.clientY - startY;\n            if (Math.hypot(dx, dy) > moveThreshold) cancel();\n        };\n\n        node.addEventListener(\"pointerdown\", onDown);\n        node.addEventListener(\"pointermove\", onMove);\n        node.addEventListener(\"pointerup\", cancel);\n        node.addEventListener(\"pointercancel\", cancel);\n        node.addEventListener(\"pointerleave\", cancel);\n        return () => {\n            cancel();\n            node.removeEventListener(\"pointerdown\", onDown);\n            node.removeEventListener(\"pointermove\", onMove);\n            node.removeEventListener(\"pointerup\", cancel);\n            node.removeEventListener(\"pointercancel\", cancel);\n            node.removeEventListener(\"pointerleave\", cancel);\n        };\n    }, [ref, delay, moveThreshold, fnRef]);\n}\n"],"mappings":"+DAoBA,SAAgB,EACZ,EACA,EACA,EAA+B,CAAC,EAC5B,CACJ,GAAM,CAAE,QAAQ,IAAK,gBAAgB,IAAO,EACtC,EAAQ,EAAA,aAAa,CAAE,GAE7B,EAAA,EAAA,UAAA,KAAgB,CACZ,IAAM,EAAO,EAAI,QACjB,GAAI,CAAC,EAAM,OACX,IAAI,EAA8C,KAC9C,EAAS,EACT,EAAS,EAEP,MAAqB,CACvB,AAEI,KADA,aAAa,CAAK,EACV,KAEhB,EAEM,EAAU,GAA8B,CAC1C,EAAS,EAAM,QACf,EAAS,EAAM,QACf,EAAO,EACP,EAAQ,eAAiB,CACrB,EAAQ,KACR,EAAM,QAAQ,CAClB,EAAG,CAAK,CACZ,EAEM,EAAU,GAA8B,CAC1C,GAAI,IAAU,KAAM,OACpB,IAAM,EAAK,EAAM,QAAU,EACrB,EAAK,EAAM,QAAU,EACvB,KAAK,MAAM,EAAI,CAAE,EAAI,GAAe,EAAO,CACnD,EAOA,OALA,EAAK,iBAAiB,cAAe,CAAM,EAC3C,EAAK,iBAAiB,cAAe,CAAM,EAC3C,EAAK,iBAAiB,YAAa,CAAM,EACzC,EAAK,iBAAiB,gBAAiB,CAAM,EAC7C,EAAK,iBAAiB,eAAgB,CAAM,MAC/B,CACT,EAAO,EACP,EAAK,oBAAoB,cAAe,CAAM,EAC9C,EAAK,oBAAoB,cAAe,CAAM,EAC9C,EAAK,oBAAoB,YAAa,CAAM,EAC5C,EAAK,oBAAoB,gBAAiB,CAAM,EAChD,EAAK,oBAAoB,eAAgB,CAAM,CACnD,CACJ,EAAG,CAAC,EAAK,EAAO,EAAe,CAAK,CAAC,CACzC"}

package/dist/hooks/use-long-press.js

@@ -1,10 +1,9 @@
-import { useEffect as e, useRef as t } from "react";
+import { useLatestRef as e } from "./use-latest-ref.js";
+import { useEffect as t } from "react";
 //#region src/hooks/use-long-press.ts
 function n(n, r, i = {}) {
-	let { delay: a = 500, moveThreshold: o = 10 } = i, s = t(r);
-	e(() => {
-		s.current = r;
-	}, [r]), e(() => {
+	let { delay: a = 500, moveThreshold: o = 10 } = i, s = e(r);
+	t(() => {
 		let e = n.current;
 		if (!e) return;
 		let t = null, r = 0, i = 0, c = () => {
@@ -24,7 +23,8 @@ function n(n, r, i = {}) {
 	}, [
 		n,
 		a,
-		o
+		o,
+		s
 	]);
 }
 //#endregion

package/dist/hooks/use-long-press.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-long-press.js","names":[],"sources":["../../src/hooks/use-long-press.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\nimport type { RefObject } from \"react\";\n\nexport interface UseLongPressOptions {\n    /** Press duration in ms. Default `500`. */\n    delay?: number;\n    /** Pixel threshold — finger/mouse movement beyond this cancels the press. Default `10`. */\n    moveThreshold?: number;\n}\n\n/**\n * Detect long-press / long-tap gestures. Fires `fn` after `delay` ms\n * while the element is held. Cancels on move beyond `moveThreshold` or\n * pointer up before `delay`.\n *\n * @example\n * const ref = useRef<HTMLDivElement>(null);\n * useLongPress(ref, () => openContextMenu(), { delay: 600 });\n */\nexport function useLongPress<T extends HTMLElement>(\n    ref: RefObject<T | null>,\n    fn: () => void,\n    options: UseLongPressOptions = {},\n): void {\n    const { delay = 500, moveThreshold = 10 } = options;\n    const fnRef = useRef(fn);\n    useEffect(() => {\n        fnRef.current = fn;\n    }, [fn]);\n\n    useEffect(() => {\n        const node = ref.current;\n        if (!node) return;\n        let timer: ReturnType<typeof setTimeout> | null = null;\n        let startX = 0;\n        let startY = 0;\n\n        const cancel = (): void => {\n            if (timer) {\n                clearTimeout(timer);\n                timer = null;\n            }\n        };\n\n        const onDown = (event: PointerEvent): void => {\n            startX = event.clientX;\n            startY = event.clientY;\n            cancel();\n            timer = setTimeout(() => {\n                timer = null;\n                fnRef.current();\n            }, delay);\n        };\n\n        const onMove = (event: PointerEvent): void => {\n            if (timer === null) return;\n            const dx = event.clientX - startX;\n            const dy = event.clientY - startY;\n            if (Math.hypot(dx, dy) > moveThreshold) cancel();\n        };\n\n        node.addEventListener(\"pointerdown\", onDown);\n        node.addEventListener(\"pointermove\", onMove);\n        node.addEventListener(\"pointerup\", cancel);\n        node.addEventListener(\"pointercancel\", cancel);\n        node.addEventListener(\"pointerleave\", cancel);\n        return () => {\n            cancel();\n            node.removeEventListener(\"pointerdown\", onDown);\n            node.removeEventListener(\"pointermove\", onMove);\n            node.removeEventListener(\"pointerup\", cancel);\n            node.removeEventListener(\"pointercancel\", cancel);\n            node.removeEventListener(\"pointerleave\", cancel);\n        };\n    }, [ref, delay, moveThreshold]);\n}\n"],"mappings":";;AAmBA,SAAgB,EACZ,GACA,GACA,IAA+B,CAAC,GAC5B;CACJ,IAAM,EAAE,WAAQ,KAAK,mBAAgB,OAAO,GACtC,IAAQ,EAAO,CAAE;CAKvB,AAJA,QAAgB;EACZ,EAAM,UAAU;CACpB,GAAG,CAAC,CAAE,CAAC,GAEP,QAAgB;EACZ,IAAM,IAAO,EAAI;EACjB,IAAI,CAAC,GAAM;EACX,IAAI,IAA8C,MAC9C,IAAS,GACT,IAAS,GAEP,UAAqB;GACvB,AAEI,OADA,aAAa,CAAK,GACV;EAEhB,GAEM,KAAU,MAA8B;GAI1C,AAHA,IAAS,EAAM,SACf,IAAS,EAAM,SACf,EAAO,GACP,IAAQ,iBAAiB;IAErB,AADA,IAAQ,MACR,EAAM,QAAQ;GAClB,GAAG,CAAK;EACZ,GAEM,KAAU,MAA8B;GAC1C,IAAI,MAAU,MAAM;GACpB,IAAM,IAAK,EAAM,UAAU,GACrB,IAAK,EAAM,UAAU;GAC3B,AAAI,KAAK,MAAM,GAAI,CAAE,IAAI,KAAe,EAAO;EACnD;EAOA,OALA,EAAK,iBAAiB,eAAe,CAAM,GAC3C,EAAK,iBAAiB,eAAe,CAAM,GAC3C,EAAK,iBAAiB,aAAa,CAAM,GACzC,EAAK,iBAAiB,iBAAiB,CAAM,GAC7C,EAAK,iBAAiB,gBAAgB,CAAM,SAC/B;GAMT,AALA,EAAO,GACP,EAAK,oBAAoB,eAAe,CAAM,GAC9C,EAAK,oBAAoB,eAAe,CAAM,GAC9C,EAAK,oBAAoB,aAAa,CAAM,GAC5C,EAAK,oBAAoB,iBAAiB,CAAM,GAChD,EAAK,oBAAoB,gBAAgB,CAAM;EACnD;CACJ,GAAG;EAAC;EAAK;EAAO;CAAa,CAAC;AAClC"}
+{"version":3,"file":"use-long-press.js","names":[],"sources":["../../src/hooks/use-long-press.ts"],"sourcesContent":["import { useEffect } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\nimport type { RefObject } from \"react\";\n\nexport interface UseLongPressOptions {\n    /** Press duration in ms. Default `500`. */\n    delay?: number;\n    /** Pixel threshold — finger/mouse movement beyond this cancels the press. Default `10`. */\n    moveThreshold?: number;\n}\n\n/**\n * Detect long-press / long-tap gestures. Fires `fn` after `delay` ms\n * while the element is held. Cancels on move beyond `moveThreshold` or\n * pointer up before `delay`.\n *\n * @example\n * const ref = useRef<HTMLDivElement>(null);\n * useLongPress(ref, () => openContextMenu(), { delay: 600 });\n */\nexport function useLongPress<T extends HTMLElement>(\n    ref: RefObject<T | null>,\n    fn: () => void,\n    options: UseLongPressOptions = {},\n): void {\n    const { delay = 500, moveThreshold = 10 } = options;\n    const fnRef = useLatestRef(fn);\n\n    useEffect(() => {\n        const node = ref.current;\n        if (!node) return;\n        let timer: ReturnType<typeof setTimeout> | null = null;\n        let startX = 0;\n        let startY = 0;\n\n        const cancel = (): void => {\n            if (timer) {\n                clearTimeout(timer);\n                timer = null;\n            }\n        };\n\n        const onDown = (event: PointerEvent): void => {\n            startX = event.clientX;\n            startY = event.clientY;\n            cancel();\n            timer = setTimeout(() => {\n                timer = null;\n                fnRef.current();\n            }, delay);\n        };\n\n        const onMove = (event: PointerEvent): void => {\n            if (timer === null) return;\n            const dx = event.clientX - startX;\n            const dy = event.clientY - startY;\n            if (Math.hypot(dx, dy) > moveThreshold) cancel();\n        };\n\n        node.addEventListener(\"pointerdown\", onDown);\n        node.addEventListener(\"pointermove\", onMove);\n        node.addEventListener(\"pointerup\", cancel);\n        node.addEventListener(\"pointercancel\", cancel);\n        node.addEventListener(\"pointerleave\", cancel);\n        return () => {\n            cancel();\n            node.removeEventListener(\"pointerdown\", onDown);\n            node.removeEventListener(\"pointermove\", onMove);\n            node.removeEventListener(\"pointerup\", cancel);\n            node.removeEventListener(\"pointercancel\", cancel);\n            node.removeEventListener(\"pointerleave\", cancel);\n        };\n    }, [ref, delay, moveThreshold, fnRef]);\n}\n"],"mappings":";;;AAoBA,SAAgB,EACZ,GACA,GACA,IAA+B,CAAC,GAC5B;CACJ,IAAM,EAAE,WAAQ,KAAK,mBAAgB,OAAO,GACtC,IAAQ,EAAa,CAAE;CAE7B,QAAgB;EACZ,IAAM,IAAO,EAAI;EACjB,IAAI,CAAC,GAAM;EACX,IAAI,IAA8C,MAC9C,IAAS,GACT,IAAS,GAEP,UAAqB;GACvB,AAEI,OADA,aAAa,CAAK,GACV;EAEhB,GAEM,KAAU,MAA8B;GAI1C,AAHA,IAAS,EAAM,SACf,IAAS,EAAM,SACf,EAAO,GACP,IAAQ,iBAAiB;IAErB,AADA,IAAQ,MACR,EAAM,QAAQ;GAClB,GAAG,CAAK;EACZ,GAEM,KAAU,MAA8B;GAC1C,IAAI,MAAU,MAAM;GACpB,IAAM,IAAK,EAAM,UAAU,GACrB,IAAK,EAAM,UAAU;GAC3B,AAAI,KAAK,MAAM,GAAI,CAAE,IAAI,KAAe,EAAO;EACnD;EAOA,OALA,EAAK,iBAAiB,eAAe,CAAM,GAC3C,EAAK,iBAAiB,eAAe,CAAM,GAC3C,EAAK,iBAAiB,aAAa,CAAM,GACzC,EAAK,iBAAiB,iBAAiB,CAAM,GAC7C,EAAK,iBAAiB,gBAAgB,CAAM,SAC/B;GAMT,AALA,EAAO,GACP,EAAK,oBAAoB,eAAe,CAAM,GAC9C,EAAK,oBAAoB,eAAe,CAAM,GAC9C,EAAK,oBAAoB,aAAa,CAAM,GAC5C,EAAK,oBAAoB,iBAAiB,CAAM,GAChD,EAAK,oBAAoB,gBAAgB,CAAM;EACnD;CACJ,GAAG;EAAC;EAAK;EAAO;EAAe;CAAK,CAAC;AACzC"}

package/dist/hooks/use-online.cjs

@@ -1,2 +1,2 @@
-let e=require("react");function t(t={}){let{pingUrl:n,intervalMs:r=3e4,timeoutMs:i=5e3}=t,[a,o]=(0,e.useState)(()=>typeof navigator>`u`||navigator.onLine),[s,c]=(0,e.useState)(!0),l=(0,e.useRef)({pingUrl:n,timeoutMs:i});return(0,e.useEffect)(()=>{l.current={pingUrl:n,timeoutMs:i}},[n,i]),(0,e.useEffect)(()=>{if(typeof window>`u`)return;let e=()=>o(!0),t=()=>o(!1);return window.addEventListener(`online`,e),window.addEventListener(`offline`,t),()=>{window.removeEventListener(`online`,e),window.removeEventListener(`offline`,t)}},[]),(0,e.useEffect)(()=>{if(!n||typeof window>`u`)return;let e=!1,t=async()=>{if(typeof navigator<`u`&&!navigator.onLine){e||c(!1);return}let t=new AbortController,n=window.setTimeout(()=>t.abort(),l.current.timeoutMs);try{await fetch(l.current.pingUrl,{method:`HEAD`,cache:`no-store`,signal:t.signal}),e||c(!0)}catch{e||c(!1)}finally{window.clearTimeout(n)}};t();let i=window.setInterval(()=>void t(),r),a=()=>void t();return window.addEventListener(`online`,a),document.addEventListener(`visibilitychange`,a),()=>{e=!0,window.clearInterval(i),window.removeEventListener(`online`,a),document.removeEventListener(`visibilitychange`,a)}},[n,r]),n?a&&s:a}exports.useOnline=t;
+const e=require("./use-latest-ref.cjs");let t=require("react");function n(n={}){let{pingUrl:r,intervalMs:i=3e4,timeoutMs:a=5e3}=n,[o,s]=(0,t.useState)(()=>typeof navigator>`u`||navigator.onLine),[c,l]=(0,t.useState)(!0),u=e.useLatestRef({pingUrl:r,timeoutMs:a});return(0,t.useEffect)(()=>{if(typeof window>`u`)return;let e=()=>s(!0),t=()=>s(!1);return window.addEventListener(`online`,e),window.addEventListener(`offline`,t),()=>{window.removeEventListener(`online`,e),window.removeEventListener(`offline`,t)}},[]),(0,t.useEffect)(()=>{if(!r||typeof window>`u`)return;let e=!1,t=async()=>{if(typeof navigator<`u`&&!navigator.onLine){e||l(!1);return}let t=new AbortController,n=window.setTimeout(()=>t.abort(),u.current.timeoutMs);try{await fetch(u.current.pingUrl,{method:`HEAD`,cache:`no-store`,signal:t.signal}),e||l(!0)}catch{e||l(!1)}finally{window.clearTimeout(n)}};t();let n=window.setInterval(()=>void t(),i),a=()=>void t();return window.addEventListener(`online`,a),document.addEventListener(`visibilitychange`,a),()=>{e=!0,window.clearInterval(n),window.removeEventListener(`online`,a),document.removeEventListener(`visibilitychange`,a)}},[r,i,u]),r?o&&c:o}exports.useOnline=n;
 //# sourceMappingURL=use-online.cjs.map