tempest-react-sdk 0.47.0 → 0.49.0

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

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

@@ -1 +1 @@
-{"version":3,"file":"use-online.cjs","names":[],"sources":["../../src/hooks/use-online.ts"],"sourcesContent":["import { useEffect, useRef, useState } from \"react\";\n\n/**\n * Options for {@link useOnline}. Omit them for the cheap `navigator.onLine`\n * behaviour; pass `pingUrl` to add a real-reachability probe on top.\n */\nexport interface UseOnlineOptions {\n    /**\n     * URL to probe for real connectivity. `navigator.onLine` reports `true`\n     * behind a captive portal or when the machine has a link but no internet;\n     * a periodic `HEAD` to this URL catches those cases. When set, the result\n     * is `navigator.onLine && lastProbeSucceeded`.\n     */\n    pingUrl?: string;\n    /** How often to probe, in ms. Default `30000`. */\n    intervalMs?: number;\n    /** Abort a probe after this many ms and treat it as offline. Default `5000`. */\n    timeoutMs?: number;\n}\n\n/**\n * Track connectivity and re-render on changes.\n *\n * With no options it mirrors `navigator.onLine` (assuming online during SSR and\n * before the first event). Pass `pingUrl` to additionally probe real\n * reachability — the browser's `onLine` flag lies behind captive portals and\n * dead links, so the probe downgrades the result to `false` when the network is\n * unusable even though `navigator.onLine` is `true`.\n *\n * @param options - Optional reachability-probe configuration.\n * @returns `true` when the device is online (and reachable, when probing).\n *\n * @example\n * const online = useOnline(); // navigator.onLine only\n * const reallyOnline = useOnline({ pingUrl: \"/health\", intervalMs: 15_000 });\n */\nexport function useOnline(options: UseOnlineOptions = {}): boolean {\n    const { pingUrl, intervalMs = 30_000, timeoutMs = 5_000 } = options;\n\n    const [navOnline, setNavOnline] = useState<boolean>(() =>\n        typeof navigator === \"undefined\" ? true : navigator.onLine,\n    );\n    const [reachable, setReachable] = useState<boolean>(true);\n\n    const optionsRef = useRef({ pingUrl, timeoutMs });\n    useEffect(() => {\n        optionsRef.current = { pingUrl, timeoutMs };\n    }, [pingUrl, timeoutMs]);\n\n    useEffect(() => {\n        if (typeof window === \"undefined\") return;\n        const handleOnline = (): void => setNavOnline(true);\n        const handleOffline = (): void => setNavOnline(false);\n        window.addEventListener(\"online\", handleOnline);\n        window.addEventListener(\"offline\", handleOffline);\n        return () => {\n            window.removeEventListener(\"online\", handleOnline);\n            window.removeEventListener(\"offline\", handleOffline);\n        };\n    }, []);\n\n    useEffect(() => {\n        if (!pingUrl || typeof window === \"undefined\") return;\n\n        let cancelled = false;\n        const probe = async (): Promise<void> => {\n            if (typeof navigator !== \"undefined\" && !navigator.onLine) {\n                if (!cancelled) setReachable(false);\n                return;\n            }\n            const controller = new AbortController();\n            const timer = window.setTimeout(() => controller.abort(), optionsRef.current.timeoutMs);\n            try {\n                await fetch(optionsRef.current.pingUrl!, {\n                    method: \"HEAD\",\n                    cache: \"no-store\",\n                    signal: controller.signal,\n                });\n                if (!cancelled) setReachable(true);\n            } catch {\n                if (!cancelled) setReachable(false);\n            } finally {\n                window.clearTimeout(timer);\n            }\n        };\n\n        void probe();\n        const id = window.setInterval(() => void probe(), intervalMs);\n        const onWake = (): void => void probe();\n        window.addEventListener(\"online\", onWake);\n        document.addEventListener(\"visibilitychange\", onWake);\n        return () => {\n            cancelled = true;\n            window.clearInterval(id);\n            window.removeEventListener(\"online\", onWake);\n            document.removeEventListener(\"visibilitychange\", onWake);\n        };\n    }, [pingUrl, intervalMs]);\n\n    return pingUrl ? navOnline && reachable : navOnline;\n}\n"],"mappings":"uBAoCA,SAAgB,EAAU,EAA4B,CAAC,EAAY,CAC/D,GAAM,CAAE,UAAS,aAAa,IAAQ,YAAY,KAAU,EAEtD,CAAC,EAAW,IAAA,EAAgB,EAAA,SAAA,KAC9B,OAAO,UAAc,KAAqB,UAAU,MACxD,EACM,CAAC,EAAW,IAAA,EAAgB,EAAA,SAAA,CAAkB,EAAI,EAElD,GAAA,EAAa,EAAA,OAAA,CAAO,CAAE,UAAS,WAAU,CAAC,EAuDhD,OAtDA,EAAA,EAAA,UAAA,KAAgB,CACZ,EAAW,QAAU,CAAE,UAAS,WAAU,CAC9C,EAAG,CAAC,EAAS,CAAS,CAAC,GAEvB,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,OAAO,OAAW,IAAa,OACnC,IAAM,MAA2B,EAAa,EAAI,EAC5C,MAA4B,EAAa,EAAK,EAGpD,OAFA,OAAO,iBAAiB,SAAU,CAAY,EAC9C,OAAO,iBAAiB,UAAW,CAAa,MACnC,CACT,OAAO,oBAAoB,SAAU,CAAY,EACjD,OAAO,oBAAoB,UAAW,CAAa,CACvD,CACJ,EAAG,CAAC,CAAC,GAEL,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,CAAC,GAAW,OAAO,OAAW,IAAa,OAE/C,IAAI,EAAY,GACV,EAAQ,SAA2B,CACrC,GAAI,OAAO,UAAc,KAAe,CAAC,UAAU,OAAQ,CAClD,GAAW,EAAa,EAAK,EAClC,MACJ,CACA,IAAM,EAAa,IAAI,gBACjB,EAAQ,OAAO,eAAiB,EAAW,MAAM,EAAG,EAAW,QAAQ,SAAS,EACtF,GAAI,CACA,MAAM,MAAM,EAAW,QAAQ,QAAU,CACrC,OAAQ,OACR,MAAO,WACP,OAAQ,EAAW,MACvB,CAAC,EACI,GAAW,EAAa,EAAI,CACrC,MAAQ,CACC,GAAW,EAAa,EAAK,CACtC,QAAU,CACN,OAAO,aAAa,CAAK,CAC7B,CACJ,EAEA,EAAW,EACX,IAAM,EAAK,OAAO,gBAAkB,KAAK,EAAM,EAAG,CAAU,EACtD,MAAqB,KAAK,EAAM,EAGtC,OAFA,OAAO,iBAAiB,SAAU,CAAM,EACxC,SAAS,iBAAiB,mBAAoB,CAAM,MACvC,CACT,EAAY,GACZ,OAAO,cAAc,CAAE,EACvB,OAAO,oBAAoB,SAAU,CAAM,EAC3C,SAAS,oBAAoB,mBAAoB,CAAM,CAC3D,CACJ,EAAG,CAAC,EAAS,CAAU,CAAC,EAEjB,EAAU,GAAa,EAAY,CAC9C"}
+{"version":3,"file":"use-online.cjs","names":[],"sources":["../../src/hooks/use-online.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\n\n/**\n * Options for {@link useOnline}. Omit them for the cheap `navigator.onLine`\n * behaviour; pass `pingUrl` to add a real-reachability probe on top.\n */\nexport interface UseOnlineOptions {\n    /**\n     * URL to probe for real connectivity. `navigator.onLine` reports `true`\n     * behind a captive portal or when the machine has a link but no internet;\n     * a periodic `HEAD` to this URL catches those cases. When set, the result\n     * is `navigator.onLine && lastProbeSucceeded`.\n     */\n    pingUrl?: string;\n    /** How often to probe, in ms. Default `30000`. */\n    intervalMs?: number;\n    /** Abort a probe after this many ms and treat it as offline. Default `5000`. */\n    timeoutMs?: number;\n}\n\n/**\n * Track connectivity and re-render on changes.\n *\n * With no options it mirrors `navigator.onLine` (assuming online during SSR and\n * before the first event). Pass `pingUrl` to additionally probe real\n * reachability — the browser's `onLine` flag lies behind captive portals and\n * dead links, so the probe downgrades the result to `false` when the network is\n * unusable even though `navigator.onLine` is `true`.\n *\n * @param options - Optional reachability-probe configuration.\n * @returns `true` when the device is online (and reachable, when probing).\n *\n * @example\n * const online = useOnline(); // navigator.onLine only\n * const reallyOnline = useOnline({ pingUrl: \"/health\", intervalMs: 15_000 });\n */\nexport function useOnline(options: UseOnlineOptions = {}): boolean {\n    const { pingUrl, intervalMs = 30_000, timeoutMs = 5_000 } = options;\n\n    const [navOnline, setNavOnline] = useState<boolean>(() =>\n        typeof navigator === \"undefined\" ? true : navigator.onLine,\n    );\n    const [reachable, setReachable] = useState<boolean>(true);\n\n    const optionsRef = useLatestRef({ pingUrl, timeoutMs });\n\n    useEffect(() => {\n        if (typeof window === \"undefined\") return;\n        const handleOnline = (): void => setNavOnline(true);\n        const handleOffline = (): void => setNavOnline(false);\n        window.addEventListener(\"online\", handleOnline);\n        window.addEventListener(\"offline\", handleOffline);\n        return () => {\n            window.removeEventListener(\"online\", handleOnline);\n            window.removeEventListener(\"offline\", handleOffline);\n        };\n    }, []);\n\n    useEffect(() => {\n        if (!pingUrl || typeof window === \"undefined\") return;\n\n        let cancelled = false;\n        const probe = async (): Promise<void> => {\n            if (typeof navigator !== \"undefined\" && !navigator.onLine) {\n                if (!cancelled) setReachable(false);\n                return;\n            }\n            const controller = new AbortController();\n            const timer = window.setTimeout(() => controller.abort(), optionsRef.current.timeoutMs);\n            try {\n                await fetch(optionsRef.current.pingUrl!, {\n                    method: \"HEAD\",\n                    cache: \"no-store\",\n                    signal: controller.signal,\n                });\n                if (!cancelled) setReachable(true);\n            } catch {\n                if (!cancelled) setReachable(false);\n            } finally {\n                window.clearTimeout(timer);\n            }\n        };\n\n        void probe();\n        const id = window.setInterval(() => void probe(), intervalMs);\n        const onWake = (): void => void probe();\n        window.addEventListener(\"online\", onWake);\n        document.addEventListener(\"visibilitychange\", onWake);\n        return () => {\n            cancelled = true;\n            window.clearInterval(id);\n            window.removeEventListener(\"online\", onWake);\n            document.removeEventListener(\"visibilitychange\", onWake);\n        };\n    }, [pingUrl, intervalMs, optionsRef]);\n\n    return pingUrl ? navOnline && reachable : navOnline;\n}\n"],"mappings":"+DAqCA,SAAgB,EAAU,EAA4B,CAAC,EAAY,CAC/D,GAAM,CAAE,UAAS,aAAa,IAAQ,YAAY,KAAU,EAEtD,CAAC,EAAW,IAAA,EAAgB,EAAA,SAAA,KAC9B,OAAO,UAAc,KAAqB,UAAU,MACxD,EACM,CAAC,EAAW,IAAA,EAAgB,EAAA,SAAA,CAAkB,EAAI,EAElD,EAAa,EAAA,aAAa,CAAE,UAAS,WAAU,CAAC,EAoDtD,OAlDA,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,OAAO,OAAW,IAAa,OACnC,IAAM,MAA2B,EAAa,EAAI,EAC5C,MAA4B,EAAa,EAAK,EAGpD,OAFA,OAAO,iBAAiB,SAAU,CAAY,EAC9C,OAAO,iBAAiB,UAAW,CAAa,MACnC,CACT,OAAO,oBAAoB,SAAU,CAAY,EACjD,OAAO,oBAAoB,UAAW,CAAa,CACvD,CACJ,EAAG,CAAC,CAAC,GAEL,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,CAAC,GAAW,OAAO,OAAW,IAAa,OAE/C,IAAI,EAAY,GACV,EAAQ,SAA2B,CACrC,GAAI,OAAO,UAAc,KAAe,CAAC,UAAU,OAAQ,CAClD,GAAW,EAAa,EAAK,EAClC,MACJ,CACA,IAAM,EAAa,IAAI,gBACjB,EAAQ,OAAO,eAAiB,EAAW,MAAM,EAAG,EAAW,QAAQ,SAAS,EACtF,GAAI,CACA,MAAM,MAAM,EAAW,QAAQ,QAAU,CACrC,OAAQ,OACR,MAAO,WACP,OAAQ,EAAW,MACvB,CAAC,EACI,GAAW,EAAa,EAAI,CACrC,MAAQ,CACC,GAAW,EAAa,EAAK,CACtC,QAAU,CACN,OAAO,aAAa,CAAK,CAC7B,CACJ,EAEA,EAAW,EACX,IAAM,EAAK,OAAO,gBAAkB,KAAK,EAAM,EAAG,CAAU,EACtD,MAAqB,KAAK,EAAM,EAGtC,OAFA,OAAO,iBAAiB,SAAU,CAAM,EACxC,SAAS,iBAAiB,mBAAoB,CAAM,MACvC,CACT,EAAY,GACZ,OAAO,cAAc,CAAE,EACvB,OAAO,oBAAoB,SAAU,CAAM,EAC3C,SAAS,oBAAoB,mBAAoB,CAAM,CAC3D,CACJ,EAAG,CAAC,EAAS,EAAY,CAAU,CAAC,EAE7B,EAAU,GAAa,EAAY,CAC9C"}

package/dist/hooks/use-online.js

@@ -1,22 +1,18 @@
-import { useEffect as e, useRef as t, useState as n } from "react";
+import { useLatestRef as e } from "./use-latest-ref.js";
+import { useEffect as t, useState as n } from "react";
 //#region src/hooks/use-online.ts
 function r(r = {}) {
-	let { pingUrl: i, intervalMs: a = 3e4, timeoutMs: o = 5e3 } = r, [s, c] = n(() => typeof navigator > "u" || navigator.onLine), [l, u] = n(!0), d = t({
+	let { pingUrl: i, intervalMs: a = 3e4, timeoutMs: o = 5e3 } = r, [s, c] = n(() => typeof navigator > "u" || navigator.onLine), [l, u] = n(!0), d = e({
 		pingUrl: i,
 		timeoutMs: o
 	});
-	return e(() => {
-		d.current = {
-			pingUrl: i,
-			timeoutMs: o
-		};
-	}, [i, o]), e(() => {
+	return t(() => {
 		if (typeof window > "u") return;
 		let e = () => c(!0), t = () => c(!1);
 		return window.addEventListener("online", e), window.addEventListener("offline", t), () => {
 			window.removeEventListener("online", e), window.removeEventListener("offline", t);
 		};
-	}, []), e(() => {
+	}, []), t(() => {
 		if (!i || typeof window > "u") return;
 		let e = !1, t = async () => {
 			if (typeof navigator < "u" && !navigator.onLine) {
@@ -41,7 +37,11 @@ function r(r = {}) {
 		return window.addEventListener("online", r), document.addEventListener("visibilitychange", r), () => {
 			e = !0, window.clearInterval(n), window.removeEventListener("online", r), document.removeEventListener("visibilitychange", r);
 		};
-	}, [i, a]), i ? s && l : s;
+	}, [
+		i,
+		a,
+		d
+	]), i ? s && l : s;
 }
 //#endregion
 export { r as useOnline };

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

@@ -1 +1 @@
-{"version":3,"file":"use-online.js","names":[],"sources":["../../src/hooks/use-online.ts"],"sourcesContent":["import { useEffect, useRef, useState } from \"react\";\n\n/**\n * Options for {@link useOnline}. Omit them for the cheap `navigator.onLine`\n * behaviour; pass `pingUrl` to add a real-reachability probe on top.\n */\nexport interface UseOnlineOptions {\n    /**\n     * URL to probe for real connectivity. `navigator.onLine` reports `true`\n     * behind a captive portal or when the machine has a link but no internet;\n     * a periodic `HEAD` to this URL catches those cases. When set, the result\n     * is `navigator.onLine && lastProbeSucceeded`.\n     */\n    pingUrl?: string;\n    /** How often to probe, in ms. Default `30000`. */\n    intervalMs?: number;\n    /** Abort a probe after this many ms and treat it as offline. Default `5000`. */\n    timeoutMs?: number;\n}\n\n/**\n * Track connectivity and re-render on changes.\n *\n * With no options it mirrors `navigator.onLine` (assuming online during SSR and\n * before the first event). Pass `pingUrl` to additionally probe real\n * reachability — the browser's `onLine` flag lies behind captive portals and\n * dead links, so the probe downgrades the result to `false` when the network is\n * unusable even though `navigator.onLine` is `true`.\n *\n * @param options - Optional reachability-probe configuration.\n * @returns `true` when the device is online (and reachable, when probing).\n *\n * @example\n * const online = useOnline(); // navigator.onLine only\n * const reallyOnline = useOnline({ pingUrl: \"/health\", intervalMs: 15_000 });\n */\nexport function useOnline(options: UseOnlineOptions = {}): boolean {\n    const { pingUrl, intervalMs = 30_000, timeoutMs = 5_000 } = options;\n\n    const [navOnline, setNavOnline] = useState<boolean>(() =>\n        typeof navigator === \"undefined\" ? true : navigator.onLine,\n    );\n    const [reachable, setReachable] = useState<boolean>(true);\n\n    const optionsRef = useRef({ pingUrl, timeoutMs });\n    useEffect(() => {\n        optionsRef.current = { pingUrl, timeoutMs };\n    }, [pingUrl, timeoutMs]);\n\n    useEffect(() => {\n        if (typeof window === \"undefined\") return;\n        const handleOnline = (): void => setNavOnline(true);\n        const handleOffline = (): void => setNavOnline(false);\n        window.addEventListener(\"online\", handleOnline);\n        window.addEventListener(\"offline\", handleOffline);\n        return () => {\n            window.removeEventListener(\"online\", handleOnline);\n            window.removeEventListener(\"offline\", handleOffline);\n        };\n    }, []);\n\n    useEffect(() => {\n        if (!pingUrl || typeof window === \"undefined\") return;\n\n        let cancelled = false;\n        const probe = async (): Promise<void> => {\n            if (typeof navigator !== \"undefined\" && !navigator.onLine) {\n                if (!cancelled) setReachable(false);\n                return;\n            }\n            const controller = new AbortController();\n            const timer = window.setTimeout(() => controller.abort(), optionsRef.current.timeoutMs);\n            try {\n                await fetch(optionsRef.current.pingUrl!, {\n                    method: \"HEAD\",\n                    cache: \"no-store\",\n                    signal: controller.signal,\n                });\n                if (!cancelled) setReachable(true);\n            } catch {\n                if (!cancelled) setReachable(false);\n            } finally {\n                window.clearTimeout(timer);\n            }\n        };\n\n        void probe();\n        const id = window.setInterval(() => void probe(), intervalMs);\n        const onWake = (): void => void probe();\n        window.addEventListener(\"online\", onWake);\n        document.addEventListener(\"visibilitychange\", onWake);\n        return () => {\n            cancelled = true;\n            window.clearInterval(id);\n            window.removeEventListener(\"online\", onWake);\n            document.removeEventListener(\"visibilitychange\", onWake);\n        };\n    }, [pingUrl, intervalMs]);\n\n    return pingUrl ? navOnline && reachable : navOnline;\n}\n"],"mappings":";;AAoCA,SAAgB,EAAU,IAA4B,CAAC,GAAY;CAC/D,IAAM,EAAE,YAAS,gBAAa,KAAQ,eAAY,QAAU,GAEtD,CAAC,GAAW,KAAgB,QAC9B,OAAO,YAAc,OAAqB,UAAU,MACxD,GACM,CAAC,GAAW,KAAgB,EAAkB,EAAI,GAElD,IAAa,EAAO;EAAE;EAAS;CAAU,CAAC;CAuDhD,OAtDA,QAAgB;EACZ,EAAW,UAAU;GAAE;GAAS;EAAU;CAC9C,GAAG,CAAC,GAAS,CAAS,CAAC,GAEvB,QAAgB;EACZ,IAAI,OAAO,SAAW,KAAa;EACnC,IAAM,UAA2B,EAAa,EAAI,GAC5C,UAA4B,EAAa,EAAK;EAGpD,OAFA,OAAO,iBAAiB,UAAU,CAAY,GAC9C,OAAO,iBAAiB,WAAW,CAAa,SACnC;GAET,AADA,OAAO,oBAAoB,UAAU,CAAY,GACjD,OAAO,oBAAoB,WAAW,CAAa;EACvD;CACJ,GAAG,CAAC,CAAC,GAEL,QAAgB;EACZ,IAAI,CAAC,KAAW,OAAO,SAAW,KAAa;EAE/C,IAAI,IAAY,IACV,IAAQ,YAA2B;GACrC,IAAI,OAAO,YAAc,OAAe,CAAC,UAAU,QAAQ;IACvD,AAAK,KAAW,EAAa,EAAK;IAClC;GACJ;GACA,IAAM,IAAa,IAAI,gBAAgB,GACjC,IAAQ,OAAO,iBAAiB,EAAW,MAAM,GAAG,EAAW,QAAQ,SAAS;GACtF,IAAI;IAMA,AALA,MAAM,MAAM,EAAW,QAAQ,SAAU;KACrC,QAAQ;KACR,OAAO;KACP,QAAQ,EAAW;IACvB,CAAC,GACI,KAAW,EAAa,EAAI;GACrC,QAAQ;IACJ,AAAK,KAAW,EAAa,EAAK;GACtC,UAAU;IACN,OAAO,aAAa,CAAK;GAC7B;EACJ;EAEA,EAAW;EACX,IAAM,IAAK,OAAO,kBAAkB,KAAK,EAAM,GAAG,CAAU,GACtD,UAAqB,KAAK,EAAM;EAGtC,OAFA,OAAO,iBAAiB,UAAU,CAAM,GACxC,SAAS,iBAAiB,oBAAoB,CAAM,SACvC;GAIT,AAHA,IAAY,IACZ,OAAO,cAAc,CAAE,GACvB,OAAO,oBAAoB,UAAU,CAAM,GAC3C,SAAS,oBAAoB,oBAAoB,CAAM;EAC3D;CACJ,GAAG,CAAC,GAAS,CAAU,CAAC,GAEjB,IAAU,KAAa,IAAY;AAC9C"}
+{"version":3,"file":"use-online.js","names":[],"sources":["../../src/hooks/use-online.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\n\n/**\n * Options for {@link useOnline}. Omit them for the cheap `navigator.onLine`\n * behaviour; pass `pingUrl` to add a real-reachability probe on top.\n */\nexport interface UseOnlineOptions {\n    /**\n     * URL to probe for real connectivity. `navigator.onLine` reports `true`\n     * behind a captive portal or when the machine has a link but no internet;\n     * a periodic `HEAD` to this URL catches those cases. When set, the result\n     * is `navigator.onLine && lastProbeSucceeded`.\n     */\n    pingUrl?: string;\n    /** How often to probe, in ms. Default `30000`. */\n    intervalMs?: number;\n    /** Abort a probe after this many ms and treat it as offline. Default `5000`. */\n    timeoutMs?: number;\n}\n\n/**\n * Track connectivity and re-render on changes.\n *\n * With no options it mirrors `navigator.onLine` (assuming online during SSR and\n * before the first event). Pass `pingUrl` to additionally probe real\n * reachability — the browser's `onLine` flag lies behind captive portals and\n * dead links, so the probe downgrades the result to `false` when the network is\n * unusable even though `navigator.onLine` is `true`.\n *\n * @param options - Optional reachability-probe configuration.\n * @returns `true` when the device is online (and reachable, when probing).\n *\n * @example\n * const online = useOnline(); // navigator.onLine only\n * const reallyOnline = useOnline({ pingUrl: \"/health\", intervalMs: 15_000 });\n */\nexport function useOnline(options: UseOnlineOptions = {}): boolean {\n    const { pingUrl, intervalMs = 30_000, timeoutMs = 5_000 } = options;\n\n    const [navOnline, setNavOnline] = useState<boolean>(() =>\n        typeof navigator === \"undefined\" ? true : navigator.onLine,\n    );\n    const [reachable, setReachable] = useState<boolean>(true);\n\n    const optionsRef = useLatestRef({ pingUrl, timeoutMs });\n\n    useEffect(() => {\n        if (typeof window === \"undefined\") return;\n        const handleOnline = (): void => setNavOnline(true);\n        const handleOffline = (): void => setNavOnline(false);\n        window.addEventListener(\"online\", handleOnline);\n        window.addEventListener(\"offline\", handleOffline);\n        return () => {\n            window.removeEventListener(\"online\", handleOnline);\n            window.removeEventListener(\"offline\", handleOffline);\n        };\n    }, []);\n\n    useEffect(() => {\n        if (!pingUrl || typeof window === \"undefined\") return;\n\n        let cancelled = false;\n        const probe = async (): Promise<void> => {\n            if (typeof navigator !== \"undefined\" && !navigator.onLine) {\n                if (!cancelled) setReachable(false);\n                return;\n            }\n            const controller = new AbortController();\n            const timer = window.setTimeout(() => controller.abort(), optionsRef.current.timeoutMs);\n            try {\n                await fetch(optionsRef.current.pingUrl!, {\n                    method: \"HEAD\",\n                    cache: \"no-store\",\n                    signal: controller.signal,\n                });\n                if (!cancelled) setReachable(true);\n            } catch {\n                if (!cancelled) setReachable(false);\n            } finally {\n                window.clearTimeout(timer);\n            }\n        };\n\n        void probe();\n        const id = window.setInterval(() => void probe(), intervalMs);\n        const onWake = (): void => void probe();\n        window.addEventListener(\"online\", onWake);\n        document.addEventListener(\"visibilitychange\", onWake);\n        return () => {\n            cancelled = true;\n            window.clearInterval(id);\n            window.removeEventListener(\"online\", onWake);\n            document.removeEventListener(\"visibilitychange\", onWake);\n        };\n    }, [pingUrl, intervalMs, optionsRef]);\n\n    return pingUrl ? navOnline && reachable : navOnline;\n}\n"],"mappings":";;;AAqCA,SAAgB,EAAU,IAA4B,CAAC,GAAY;CAC/D,IAAM,EAAE,YAAS,gBAAa,KAAQ,eAAY,QAAU,GAEtD,CAAC,GAAW,KAAgB,QAC9B,OAAO,YAAc,OAAqB,UAAU,MACxD,GACM,CAAC,GAAW,KAAgB,EAAkB,EAAI,GAElD,IAAa,EAAa;EAAE;EAAS;CAAU,CAAC;CAoDtD,OAlDA,QAAgB;EACZ,IAAI,OAAO,SAAW,KAAa;EACnC,IAAM,UAA2B,EAAa,EAAI,GAC5C,UAA4B,EAAa,EAAK;EAGpD,OAFA,OAAO,iBAAiB,UAAU,CAAY,GAC9C,OAAO,iBAAiB,WAAW,CAAa,SACnC;GAET,AADA,OAAO,oBAAoB,UAAU,CAAY,GACjD,OAAO,oBAAoB,WAAW,CAAa;EACvD;CACJ,GAAG,CAAC,CAAC,GAEL,QAAgB;EACZ,IAAI,CAAC,KAAW,OAAO,SAAW,KAAa;EAE/C,IAAI,IAAY,IACV,IAAQ,YAA2B;GACrC,IAAI,OAAO,YAAc,OAAe,CAAC,UAAU,QAAQ;IACvD,AAAK,KAAW,EAAa,EAAK;IAClC;GACJ;GACA,IAAM,IAAa,IAAI,gBAAgB,GACjC,IAAQ,OAAO,iBAAiB,EAAW,MAAM,GAAG,EAAW,QAAQ,SAAS;GACtF,IAAI;IAMA,AALA,MAAM,MAAM,EAAW,QAAQ,SAAU;KACrC,QAAQ;KACR,OAAO;KACP,QAAQ,EAAW;IACvB,CAAC,GACI,KAAW,EAAa,EAAI;GACrC,QAAQ;IACJ,AAAK,KAAW,EAAa,EAAK;GACtC,UAAU;IACN,OAAO,aAAa,CAAK;GAC7B;EACJ;EAEA,EAAW;EACX,IAAM,IAAK,OAAO,kBAAkB,KAAK,EAAM,GAAG,CAAU,GACtD,UAAqB,KAAK,EAAM;EAGtC,OAFA,OAAO,iBAAiB,UAAU,CAAM,GACxC,SAAS,iBAAiB,oBAAoB,CAAM,SACvC;GAIT,AAHA,IAAY,IACZ,OAAO,cAAc,CAAE,GACvB,OAAO,oBAAoB,UAAU,CAAM,GAC3C,SAAS,oBAAoB,oBAAoB,CAAM;EAC3D;CACJ,GAAG;EAAC;EAAS;EAAY;CAAU,CAAC,GAE7B,IAAU,KAAa,IAAY;AAC9C"}

package/dist/hooks/use-service-worker-update.cjs

@@ -1,2 +1,2 @@
-const e=require("../sw/register-service-worker.cjs");let t=require("react");function n(n){let[r,i]=(0,t.useState)(!1),[a,o]=(0,t.useState)(null),s=(0,t.useRef)(null),c=(0,t.useRef)(n);return(0,t.useEffect)(()=>{c.current=n},[n]),(0,t.useEffect)(()=>{let t=!1;return e.registerServiceWorker({...c.current,onUpdate:(e,t)=>{s.current=e,o(t),i(!0)},onReady:e=>{t||(o(e),e.waiting&&navigator.serviceWorker.controller&&(s.current=e.waiting,i(!0)),c.current.onReady?.(e))}}).then(e=>{!t&&e&&o(e)}),()=>{t=!0}},[n.url]),{updateAvailable:r,applyUpdate:(0,t.useCallback)(()=>{let t=s.current;if(!t||typeof navigator>`u`)return;let n=!1;navigator.serviceWorker.addEventListener(`controllerchange`,()=>{n||(n=!0,window.location.reload())}),e.skipWaiting(t)},[]),registration:a}}exports.useServiceWorkerUpdate=n;
+const e=require("./use-latest-ref.cjs"),t=require("../sw/register-service-worker.cjs");let n=require("react");function r(r){let[i,a]=(0,n.useState)(!1),[o,s]=(0,n.useState)(null),c=(0,n.useRef)(null),l=e.useLatestRef(r);return(0,n.useEffect)(()=>{let e=!1;return t.registerServiceWorker({...l.current,onUpdate:(e,t)=>{c.current=e,s(t),a(!0)},onReady:t=>{e||(s(t),t.waiting&&navigator.serviceWorker.controller&&(c.current=t.waiting,a(!0)),l.current.onReady?.(t))}}).then(t=>{!e&&t&&s(t)}),()=>{e=!0}},[r.url,l]),{updateAvailable:i,applyUpdate:(0,n.useCallback)(()=>{let e=c.current;if(!e||typeof navigator>`u`)return;let n=!1;navigator.serviceWorker.addEventListener(`controllerchange`,()=>{n||(n=!0,window.location.reload())}),t.skipWaiting(e)},[]),registration:o}}exports.useServiceWorkerUpdate=r;
 //# sourceMappingURL=use-service-worker-update.cjs.map