tempest-react-sdk 0.78.0 → 0.79.0

package/dist/hooks/use-client-filter.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-client-filter.cjs","names":[],"sources":["../../src/hooks/use-client-filter.ts"],"sourcesContent":["import { useMemo } from \"react\";\n\nexport type FilterPredicate<T> = (item: T, search: string) => boolean;\n\n/**\n * Client-side filter helper. Performs a case-insensitive match on the listed\n * keys when no custom predicate is provided.\n *\n * @param items - Source list.\n * @param search - Search string.\n * @param keysOrPredicate - Either a list of keys to match against or a custom predicate.\n * @returns Filtered list (referential identity preserved when search is empty).\n */\nexport function useClientFilter<T extends Record<string, unknown>>(\n    items: T[],\n    search: string,\n    keysOrPredicate: (keyof T)[] | FilterPredicate<T>,\n): T[] {\n    return useMemo(() => {\n        const term = search.trim().toLowerCase();\n        if (!term) return items;\n        if (typeof keysOrPredicate === \"function\") {\n            return items.filter((item) => keysOrPredicate(item, term));\n        }\n        return items.filter((item) =>\n            keysOrPredicate.some((key) => {\n                const value = item[key];\n                return value != null && String(value).toLowerCase().includes(term);\n            }),\n        );\n    }, [items, search, keysOrPredicate]);\n}\n"],"mappings":"uBAaA,SAAgB,EACZ,EACA,EACA,EACG,CACH,OAAA,EAAO,EAAA,QAAA,KAAc,CACjB,IAAM,EAAO,EAAO,KAAK,CAAC,CAAC,YAAY,EAKvC,OAJK,EACD,OAAO,GAAoB,WACpB,EAAM,OAAQ,GAAS,EAAgB,EAAM,CAAI,CAAC,EAEtD,EAAM,OAAQ,GACjB,EAAgB,KAAM,GAAQ,CAC1B,IAAM,EAAQ,EAAK,GACnB,OAAO,GAAS,MAAQ,OAAO,CAAK,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,CAAI,CACrE,CAAC,CACL,EATkB,CAUtB,EAAG,CAAC,EAAO,EAAQ,CAAe,CAAC,CACvC"}
+{"version":3,"file":"use-client-filter.cjs","names":["useMemo","react","useClientFilter","term","search","keysOrPredicate","items","item","value","key"],"sources":["../../src/hooks/use-client-filter.ts"],"sourcesContent":["import { useMemo } from \"react\";\n\nexport type FilterPredicate<T> = (item: T, search: string) => boolean;\n\n/**\n * Client-side filter helper. Performs a case-insensitive match on the listed\n * keys when no custom predicate is provided.\n *\n * @param items - Source list.\n * @param search - Search string.\n * @param keysOrPredicate - Either a list of keys to match against or a custom predicate.\n * @returns Filtered list (referential identity preserved when search is empty).\n */\nexport function useClientFilter<T extends Record<string, unknown>>(\n    items: T[],\n    search: string,\n    keysOrPredicate: (keyof T)[] | FilterPredicate<T>,\n): T[] {\n    return useMemo(() => {\n        const term = search.trim().toLowerCase();\n        if (!term) return items;\n        if (typeof keysOrPredicate === \"function\") {\n            return items.filter((item) => keysOrPredicate(item, term));\n        }\n        return items.filter((item) =>\n            keysOrPredicate.some((key) => {\n                const value = item[key];\n                return value != null && String(value).toLowerCase().includes(term);\n            }),\n        );\n    }, [items, search, keysOrPredicate]);\n}\n"],"mappings":"A,uBAaA,SAAgBE,EACZ,EACA,EACA,EACG,CACH,OAAA,EAAOF,EAAAA,QAAAA,KAAc,CACjB,IAAMG,EAAOC,EAAO,KAAK,CAAC,CAAC,YAAY,EAKvC,OAJKD,EACD,OAAOE,GAAoB,WACpBC,EAAM,OAAQ,GAASD,EAAgBE,EAAMJ,CAAI,CAAC,EAEtDG,EAAM,OAAQ,GACjBD,EAAgB,KAAM,GAAQ,CAC1B,IAAMG,EAAQD,EAAKE,GACnB,OAAOD,GAAS,MAAQ,OAAOA,CAAK,CAAC,CAAC,YAAY,CAAC,CAAC,SAASL,CAAI,CACrE,CAAC,CACL,EATkBG,CAUtB,EAAG,CAACA,EAAOF,EAAQC,CAAe,CAAC,CACvC,C"}

package/dist/hooks/use-client-filter.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-client-filter.js","names":[],"sources":["../../src/hooks/use-client-filter.ts"],"sourcesContent":["import { useMemo } from \"react\";\n\nexport type FilterPredicate<T> = (item: T, search: string) => boolean;\n\n/**\n * Client-side filter helper. Performs a case-insensitive match on the listed\n * keys when no custom predicate is provided.\n *\n * @param items - Source list.\n * @param search - Search string.\n * @param keysOrPredicate - Either a list of keys to match against or a custom predicate.\n * @returns Filtered list (referential identity preserved when search is empty).\n */\nexport function useClientFilter<T extends Record<string, unknown>>(\n    items: T[],\n    search: string,\n    keysOrPredicate: (keyof T)[] | FilterPredicate<T>,\n): T[] {\n    return useMemo(() => {\n        const term = search.trim().toLowerCase();\n        if (!term) return items;\n        if (typeof keysOrPredicate === \"function\") {\n            return items.filter((item) => keysOrPredicate(item, term));\n        }\n        return items.filter((item) =>\n            keysOrPredicate.some((key) => {\n                const value = item[key];\n                return value != null && String(value).toLowerCase().includes(term);\n            }),\n        );\n    }, [items, search, keysOrPredicate]);\n}\n"],"mappings":";;AAaA,SAAgB,EACZ,GACA,GACA,GACG;CACH,OAAO,QAAc;EACjB,IAAM,IAAO,EAAO,KAAK,CAAC,CAAC,YAAY;EAKvC,OAJK,IACD,OAAO,KAAoB,aACpB,EAAM,QAAQ,MAAS,EAAgB,GAAM,CAAI,CAAC,IAEtD,EAAM,QAAQ,MACjB,EAAgB,MAAM,MAAQ;GAC1B,IAAM,IAAQ,EAAK;GACnB,OAAO,KAAS,QAAQ,OAAO,CAAK,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,CAAI;EACrE,CAAC,CACL,IATkB;CAUtB,GAAG;EAAC;EAAO;EAAQ;CAAe,CAAC;AACvC"}
+{"version":3,"file":"use-client-filter.js","names":["useClientFilter","useMemo","term","search","keysOrPredicate","items","item","value","key"],"sources":["../../src/hooks/use-client-filter.ts"],"sourcesContent":["import { useMemo } from \"react\";\n\nexport type FilterPredicate<T> = (item: T, search: string) => boolean;\n\n/**\n * Client-side filter helper. Performs a case-insensitive match on the listed\n * keys when no custom predicate is provided.\n *\n * @param items - Source list.\n * @param search - Search string.\n * @param keysOrPredicate - Either a list of keys to match against or a custom predicate.\n * @returns Filtered list (referential identity preserved when search is empty).\n */\nexport function useClientFilter<T extends Record<string, unknown>>(\n    items: T[],\n    search: string,\n    keysOrPredicate: (keyof T)[] | FilterPredicate<T>,\n): T[] {\n    return useMemo(() => {\n        const term = search.trim().toLowerCase();\n        if (!term) return items;\n        if (typeof keysOrPredicate === \"function\") {\n            return items.filter((item) => keysOrPredicate(item, term));\n        }\n        return items.filter((item) =>\n            keysOrPredicate.some((key) => {\n                const value = item[key];\n                return value != null && String(value).toLowerCase().includes(term);\n            }),\n        );\n    }, [items, search, keysOrPredicate]);\n}\n"],"mappings":";;AAaA,SAAgBA,EACZ,GACA,GACA,GACG;CACH,OAAOC,QAAc;EACjB,IAAMC,IAAOC,EAAO,KAAK,CAAC,CAAC,YAAY;EAKvC,OAJKD,IACD,OAAOE,KAAoB,aACpBC,EAAM,QAAQ,MAASD,EAAgBE,GAAMJ,CAAI,CAAC,IAEtDG,EAAM,QAAQ,MACjBD,EAAgB,MAAM,MAAQ;GAC1B,IAAMG,IAAQD,EAAKE;GACnB,OAAOD,KAAS,QAAQ,OAAOA,CAAK,CAAC,CAAC,YAAY,CAAC,CAAC,SAASL,CAAI;EACrE,CAAC,CACL,IATkBG;CAUtB,GAAG;EAACA;EAAOF;EAAQC;CAAe,CAAC;AACvC"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-clipboard.cjs","names":[],"sources":["../../src/hooks/use-clipboard.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\n\nexport interface UseClipboardOptions {\n    /** Time (ms) before the `copied` flag resets back to false. Default: 1500. */\n    resetAfter?: number;\n}\n\nexport interface UseClipboardResult {\n    /** True briefly after a successful copy. */\n    copied: boolean;\n    /** Copy a string to the clipboard. Returns `true` on success. */\n    copy: (text: string) => Promise<boolean>;\n    /** Manually reset the `copied` flag. */\n    reset: () => void;\n}\n\n/**\n * Wrapper around `navigator.clipboard.writeText` with a transient `copied`\n * flag for UI feedback (\"Copied!\" toast). Falls back gracefully when the\n * Clipboard API is unavailable.\n */\nexport function useClipboard(options: UseClipboardOptions = {}): UseClipboardResult {\n    const { resetAfter = 1500 } = options;\n    const [copied, setCopied] = useState<boolean>(false);\n    const timer = useRef<ReturnType<typeof setTimeout> | null>(null);\n\n    const reset = useCallback((): void => {\n        if (timer.current) {\n            clearTimeout(timer.current);\n            timer.current = null;\n        }\n        setCopied(false);\n    }, []);\n\n    useEffect(() => () => reset(), [reset]);\n\n    const copy = useCallback(\n        async (text: string): Promise<boolean> => {\n            try {\n                if (typeof navigator !== \"undefined\" && navigator.clipboard?.writeText) {\n                    await navigator.clipboard.writeText(text);\n                } else if (typeof document !== \"undefined\") {\n                    const textarea = document.createElement(\"textarea\");\n                    textarea.value = text;\n                    textarea.style.position = \"fixed\";\n                    textarea.style.opacity = \"0\";\n                    document.body.appendChild(textarea);\n                    textarea.select();\n                    document.execCommand(\"copy\");\n                    document.body.removeChild(textarea);\n                } else {\n                    return false;\n                }\n                setCopied(true);\n                if (timer.current) clearTimeout(timer.current);\n                timer.current = setTimeout(() => setCopied(false), resetAfter);\n                return true;\n            } catch {\n                return false;\n            }\n        },\n        [resetAfter],\n    );\n\n    return { copied, copy, reset };\n}\n"],"mappings":"uBAqBA,SAAgB,EAAa,EAA+B,CAAC,EAAuB,CAChF,GAAM,CAAE,aAAa,MAAS,EACxB,CAAC,EAAQ,IAAA,EAAa,EAAA,SAAA,CAAkB,EAAK,EAC7C,GAAA,EAAQ,EAAA,OAAA,CAA6C,IAAI,EAEzD,GAAA,EAAQ,EAAA,YAAA,KAAwB,CAClC,AAEI,EAAM,WADN,aAAa,EAAM,OAAO,EACV,MAEpB,EAAU,EAAK,CACnB,EAAG,CAAC,CAAC,EAgCL,OA9BA,EAAA,EAAA,UAAA,SAAsB,EAAM,EAAG,CAAC,CAAK,CAAC,EA8B/B,CAAE,SAAQ,MAAA,EA5BJ,EAAA,YAAA,CACT,KAAO,IAAmC,CACtC,GAAI,CACA,GAAI,OAAO,UAAc,KAAe,UAAU,WAAW,UACzD,MAAM,UAAU,UAAU,UAAU,CAAI,OACrC,GAAI,OAAO,SAAa,IAAa,CACxC,IAAM,EAAW,SAAS,cAAc,UAAU,EAClD,EAAS,MAAQ,EACjB,EAAS,MAAM,SAAW,QAC1B,EAAS,MAAM,QAAU,IACzB,SAAS,KAAK,YAAY,CAAQ,EAClC,EAAS,OAAO,EAChB,SAAS,YAAY,MAAM,EAC3B,SAAS,KAAK,YAAY,CAAQ,CACtC,MACI,MAAO,GAKX,OAHA,EAAU,EAAI,EACV,EAAM,SAAS,aAAa,EAAM,OAAO,EAC7C,EAAM,QAAU,eAAiB,EAAU,EAAK,EAAG,CAAU,EACtD,EACX,MAAQ,CACJ,MAAO,EACX,CACJ,EACA,CAAC,CAAU,CAGE,EAAM,OAAM,CACjC"}
+{"version":3,"file":"use-clipboard.cjs","names":["useState","useRef","useCallback","react","useClipboard","options","copied","setCopied","timer","reset","text","textarea","resetAfter"],"sources":["../../src/hooks/use-clipboard.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\n\nexport interface UseClipboardOptions {\n    /** Time (ms) before the `copied` flag resets back to false. Default: 1500. */\n    resetAfter?: number;\n}\n\nexport interface UseClipboardResult {\n    /** True briefly after a successful copy. */\n    copied: boolean;\n    /** Copy a string to the clipboard. Returns `true` on success. */\n    copy: (text: string) => Promise<boolean>;\n    /** Manually reset the `copied` flag. */\n    reset: () => void;\n}\n\n/**\n * Wrapper around `navigator.clipboard.writeText` with a transient `copied`\n * flag for UI feedback (\"Copied!\" toast). Falls back gracefully when the\n * Clipboard API is unavailable.\n */\nexport function useClipboard(options: UseClipboardOptions = {}): UseClipboardResult {\n    const { resetAfter = 1500 } = options;\n    const [copied, setCopied] = useState<boolean>(false);\n    const timer = useRef<ReturnType<typeof setTimeout> | null>(null);\n\n    const reset = useCallback((): void => {\n        if (timer.current) {\n            clearTimeout(timer.current);\n            timer.current = null;\n        }\n        setCopied(false);\n    }, []);\n\n    useEffect(() => () => reset(), [reset]);\n\n    const copy = useCallback(\n        async (text: string): Promise<boolean> => {\n            try {\n                if (typeof navigator !== \"undefined\" && navigator.clipboard?.writeText) {\n                    await navigator.clipboard.writeText(text);\n                } else if (typeof document !== \"undefined\") {\n                    const textarea = document.createElement(\"textarea\");\n                    textarea.value = text;\n                    textarea.style.position = \"fixed\";\n                    textarea.style.opacity = \"0\";\n                    document.body.appendChild(textarea);\n                    textarea.select();\n                    document.execCommand(\"copy\");\n                    document.body.removeChild(textarea);\n                } else {\n                    return false;\n                }\n                setCopied(true);\n                if (timer.current) clearTimeout(timer.current);\n                timer.current = setTimeout(() => setCopied(false), resetAfter);\n                return true;\n            } catch {\n                return false;\n            }\n        },\n        [resetAfter],\n    );\n\n    return { copied, copy, reset };\n}\n"],"mappings":"A,uBAqBA,SAAgBI,EAAa,EAA+B,CAAC,EAAuB,CAChF,GAAM,CAAE,aAAa,MAASC,EACxB,CAACC,EAAQC,IAAA,EAAaP,EAAAA,SAAAA,CAAkB,EAAK,EAC7CQ,GAAA,EAAQP,EAAAA,OAAAA,CAA6C,IAAI,EAEzDQ,GAAA,EAAQP,EAAAA,YAAAA,KAAwB,CAClC,AAEIM,EAAM,WADN,aAAaA,EAAM,OAAO,EACV,MAEpBD,EAAU,EAAK,CACnB,EAAG,CAAC,CAAC,EAgCL,OA9BA,EAAAJ,EAAA,UAAA,SAAsBM,EAAM,EAAG,CAACA,CAAK,CAAC,EA8B/B,CAAE,SAAQ,MAAA,EA5BJP,EAAAA,YAAAA,CACT,KAAO,IAAmC,CACtC,GAAI,CACA,GAAI,OAAO,UAAc,KAAe,UAAU,WAAW,UACzD,MAAM,UAAU,UAAU,UAAUQ,CAAI,OACrC,GAAI,OAAO,SAAa,IAAa,CACxC,IAAMC,EAAW,SAAS,cAAc,UAAU,EAClD,EAAS,MAAQD,EACjB,EAAS,MAAM,SAAW,QAC1B,EAAS,MAAM,QAAU,IACzB,SAAS,KAAK,YAAYC,CAAQ,EAClCA,EAAS,OAAO,EAChB,SAAS,YAAY,MAAM,EAC3B,SAAS,KAAK,YAAYA,CAAQ,CACtC,MACI,MAAO,GAKX,OAHAJ,EAAU,EAAI,EACVC,EAAM,SAAS,aAAaA,EAAM,OAAO,EAC7C,EAAM,QAAU,eAAiBD,EAAU,EAAK,EAAGK,CAAU,EACtD,EACX,MAAQ,CACJ,MAAO,EACX,CACJ,EACA,CAACA,CAAU,CAGE,EAAM,OAAM,CACjC,C"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-clipboard.js","names":[],"sources":["../../src/hooks/use-clipboard.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\n\nexport interface UseClipboardOptions {\n    /** Time (ms) before the `copied` flag resets back to false. Default: 1500. */\n    resetAfter?: number;\n}\n\nexport interface UseClipboardResult {\n    /** True briefly after a successful copy. */\n    copied: boolean;\n    /** Copy a string to the clipboard. Returns `true` on success. */\n    copy: (text: string) => Promise<boolean>;\n    /** Manually reset the `copied` flag. */\n    reset: () => void;\n}\n\n/**\n * Wrapper around `navigator.clipboard.writeText` with a transient `copied`\n * flag for UI feedback (\"Copied!\" toast). Falls back gracefully when the\n * Clipboard API is unavailable.\n */\nexport function useClipboard(options: UseClipboardOptions = {}): UseClipboardResult {\n    const { resetAfter = 1500 } = options;\n    const [copied, setCopied] = useState<boolean>(false);\n    const timer = useRef<ReturnType<typeof setTimeout> | null>(null);\n\n    const reset = useCallback((): void => {\n        if (timer.current) {\n            clearTimeout(timer.current);\n            timer.current = null;\n        }\n        setCopied(false);\n    }, []);\n\n    useEffect(() => () => reset(), [reset]);\n\n    const copy = useCallback(\n        async (text: string): Promise<boolean> => {\n            try {\n                if (typeof navigator !== \"undefined\" && navigator.clipboard?.writeText) {\n                    await navigator.clipboard.writeText(text);\n                } else if (typeof document !== \"undefined\") {\n                    const textarea = document.createElement(\"textarea\");\n                    textarea.value = text;\n                    textarea.style.position = \"fixed\";\n                    textarea.style.opacity = \"0\";\n                    document.body.appendChild(textarea);\n                    textarea.select();\n                    document.execCommand(\"copy\");\n                    document.body.removeChild(textarea);\n                } else {\n                    return false;\n                }\n                setCopied(true);\n                if (timer.current) clearTimeout(timer.current);\n                timer.current = setTimeout(() => setCopied(false), resetAfter);\n                return true;\n            } catch {\n                return false;\n            }\n        },\n        [resetAfter],\n    );\n\n    return { copied, copy, reset };\n}\n"],"mappings":";;AAqBA,SAAgB,EAAa,IAA+B,CAAC,GAAuB;CAChF,IAAM,EAAE,gBAAa,SAAS,GACxB,CAAC,GAAQ,KAAa,EAAkB,EAAK,GAC7C,IAAQ,EAA6C,IAAI,GAEzD,IAAQ,QAAwB;EAKlC,AAJA,AAEI,EAAM,aADN,aAAa,EAAM,OAAO,GACV,OAEpB,EAAU,EAAK;CACnB,GAAG,CAAC,CAAC;CAgCL,OA9BA,cAAsB,EAAM,GAAG,CAAC,CAAK,CAAC,GA8B/B;EAAE;EAAQ,MA5BJ,EACT,OAAO,MAAmC;GACtC,IAAI;IACA,IAAI,OAAO,YAAc,OAAe,UAAU,WAAW,WACzD,MAAM,UAAU,UAAU,UAAU,CAAI;SACrC,IAAI,OAAO,WAAa,KAAa;KACxC,IAAM,IAAW,SAAS,cAAc,UAAU;KAOlD,AANA,EAAS,QAAQ,GACjB,EAAS,MAAM,WAAW,SAC1B,EAAS,MAAM,UAAU,KACzB,SAAS,KAAK,YAAY,CAAQ,GAClC,EAAS,OAAO,GAChB,SAAS,YAAY,MAAM,GAC3B,SAAS,KAAK,YAAY,CAAQ;IACtC,OACI,OAAO;IAKX,OAHA,EAAU,EAAI,GACV,EAAM,WAAS,aAAa,EAAM,OAAO,GAC7C,EAAM,UAAU,iBAAiB,EAAU,EAAK,GAAG,CAAU,GACtD;GACX,QAAQ;IACJ,OAAO;GACX;EACJ,GACA,CAAC,CAAU,CAGE;EAAM;CAAM;AACjC"}
+{"version":3,"file":"use-clipboard.js","names":["useClipboard","options","copied","setCopied","useState","timer","useRef","reset","useCallback","useEffect","text","textarea","resetAfter"],"sources":["../../src/hooks/use-clipboard.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\n\nexport interface UseClipboardOptions {\n    /** Time (ms) before the `copied` flag resets back to false. Default: 1500. */\n    resetAfter?: number;\n}\n\nexport interface UseClipboardResult {\n    /** True briefly after a successful copy. */\n    copied: boolean;\n    /** Copy a string to the clipboard. Returns `true` on success. */\n    copy: (text: string) => Promise<boolean>;\n    /** Manually reset the `copied` flag. */\n    reset: () => void;\n}\n\n/**\n * Wrapper around `navigator.clipboard.writeText` with a transient `copied`\n * flag for UI feedback (\"Copied!\" toast). Falls back gracefully when the\n * Clipboard API is unavailable.\n */\nexport function useClipboard(options: UseClipboardOptions = {}): UseClipboardResult {\n    const { resetAfter = 1500 } = options;\n    const [copied, setCopied] = useState<boolean>(false);\n    const timer = useRef<ReturnType<typeof setTimeout> | null>(null);\n\n    const reset = useCallback((): void => {\n        if (timer.current) {\n            clearTimeout(timer.current);\n            timer.current = null;\n        }\n        setCopied(false);\n    }, []);\n\n    useEffect(() => () => reset(), [reset]);\n\n    const copy = useCallback(\n        async (text: string): Promise<boolean> => {\n            try {\n                if (typeof navigator !== \"undefined\" && navigator.clipboard?.writeText) {\n                    await navigator.clipboard.writeText(text);\n                } else if (typeof document !== \"undefined\") {\n                    const textarea = document.createElement(\"textarea\");\n                    textarea.value = text;\n                    textarea.style.position = \"fixed\";\n                    textarea.style.opacity = \"0\";\n                    document.body.appendChild(textarea);\n                    textarea.select();\n                    document.execCommand(\"copy\");\n                    document.body.removeChild(textarea);\n                } else {\n                    return false;\n                }\n                setCopied(true);\n                if (timer.current) clearTimeout(timer.current);\n                timer.current = setTimeout(() => setCopied(false), resetAfter);\n                return true;\n            } catch {\n                return false;\n            }\n        },\n        [resetAfter],\n    );\n\n    return { copied, copy, reset };\n}\n"],"mappings":";;AAqBA,SAAgBA,EAAa,IAA+B,CAAC,GAAuB;CAChF,IAAM,EAAE,gBAAa,SAASC,GACxB,CAACC,GAAQC,KAAaC,EAAkB,EAAK,GAC7CC,IAAQC,EAA6C,IAAI,GAEzDC,IAAQC,QAAwB;EAKlC,AAJA,AAEIH,EAAM,aADN,aAAaA,EAAM,OAAO,GACV,OAEpBF,EAAU,EAAK;CACnB,GAAG,CAAC,CAAC;CAgCL,OA9BAM,cAAsBF,EAAM,GAAG,CAACA,CAAK,CAAC,GA8B/B;EAAE;EAAQ,MA5BJC,EACT,OAAO,MAAmC;GACtC,IAAI;IACA,IAAI,OAAO,YAAc,OAAe,UAAU,WAAW,WACzD,MAAM,UAAU,UAAU,UAAUE,CAAI;SACrC,IAAI,OAAO,WAAa,KAAa;KACxC,IAAMC,IAAW,SAAS,cAAc,UAAU;KAOlD,AANA,EAAS,QAAQD,GACjB,EAAS,MAAM,WAAW,SAC1B,EAAS,MAAM,UAAU,KACzB,SAAS,KAAK,YAAYC,CAAQ,GAClCA,EAAS,OAAO,GAChB,SAAS,YAAY,MAAM,GAC3B,SAAS,KAAK,YAAYA,CAAQ;IACtC,OACI,OAAO;IAKX,OAHAR,EAAU,EAAI,GACVE,EAAM,WAAS,aAAaA,EAAM,OAAO,GAC7C,EAAM,UAAU,iBAAiBF,EAAU,EAAK,GAAGS,CAAU,GACtD;GACX,QAAQ;IACJ,OAAO;GACX;EACJ,GACA,CAACA,CAAU,CAGE;EAAM;CAAM;AACjC"}

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\";\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"}
+{"version":3,"file":"use-countdown.cjs","names":["useCallback","useState","require_use_interval","react","useCountdown","options","compute","durationMs","startedAt","remaining","setRemaining","tickMs"],"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":"A,6DAqCA,SAAgBI,EACZ,EACA,EACA,EAA+B,CAAC,EAC1B,CACN,GAAM,CAAE,SAAS,KAASC,EAEpBC,GAAA,EAAUN,EAAAA,YAAAA,KACN,KAAK,IAAI,EAAGO,GAAc,KAAK,IAAI,EAAIC,EAAU,EACvD,CAACD,EAAYC,CAAS,CAC1B,EAEM,CAACC,EAAWC,IAAA,EAAgBT,EAAAA,SAAAA,CAASK,CAAO,EAQlD,OANA,EAAAH,EAAA,UAAA,KAAgB,CACZO,EAAaJ,EAAQ,CAAC,CAC1B,EAAG,CAACA,CAAO,CAAC,EAEZJ,EAAA,gBAAkBQ,EAAaJ,EAAQ,CAAC,EAAGG,EAAY,EAAIE,EAAS,IAAI,EAEjEF,CACX,C"}

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\";\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"}
+{"version":3,"file":"use-countdown.js","names":["useCountdown","options","compute","useCallback","durationMs","startedAt","remaining","setRemaining","useState","useEffect","useInterval","tickMs"],"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,SAAgBA,EACZ,GACA,GACA,IAA+B,CAAC,GAC1B;CACN,IAAM,EAAE,YAAS,QAASC,GAEpBC,IAAUC,QACN,KAAK,IAAI,GAAGC,KAAc,KAAK,IAAI,IAAIC,EAAU,GACvD,CAACD,GAAYC,CAAS,CAC1B,GAEM,CAACC,GAAWC,KAAgBC,EAASN,CAAO;CAQlD,OANAO,QAAgB;EACZ,EAAaP,EAAQ,CAAC;CAC1B,GAAG,CAACA,CAAO,CAAC,GAEZQ,QAAkBH,EAAaL,EAAQ,CAAC,GAAGI,IAAY,IAAIK,IAAS,IAAI,GAEjEL;AACX"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-counter.cjs","names":[],"sources":["../../src/hooks/use-counter.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface UseCounterOptions {\n    min?: number;\n    max?: number;\n}\n\nexport interface CounterHandlers {\n    increment: () => void;\n    decrement: () => void;\n    set: (value: number) => void;\n    reset: () => void;\n}\n\nconst clamp = (value: number, min: number | undefined, max: number | undefined): number => {\n    let next = value;\n    if (typeof min === \"number\") next = Math.max(min, next);\n    if (typeof max === \"number\") next = Math.min(max, next);\n    return next;\n};\n\n/**\n * Numeric counter clamped to an optional `[min, max]` range.\n *\n * @param initial - initial value (default `0`), clamped to the range.\n * @param options - optional `min` / `max` bounds.\n * @returns Tuple `[count, { increment, decrement, set, reset }]`.\n */\nexport function useCounter(\n    initial = 0,\n    options: UseCounterOptions = {},\n): [number, CounterHandlers] {\n    const { min, max } = options;\n    const [count, setCount] = useState<number>(() => clamp(initial, min, max));\n\n    const increment = useCallback((): void => {\n        setCount((current) => clamp(current + 1, min, max));\n    }, [min, max]);\n\n    const decrement = useCallback((): void => {\n        setCount((current) => clamp(current - 1, min, max));\n    }, [min, max]);\n\n    const set = useCallback(\n        (value: number): void => {\n            setCount(clamp(value, min, max));\n        },\n        [min, max],\n    );\n\n    const reset = useCallback((): void => {\n        setCount(clamp(initial, min, max));\n    }, [initial, min, max]);\n\n    const handlers = useMemo<CounterHandlers>(\n        () => ({ increment, decrement, set, reset }),\n        [increment, decrement, set, reset],\n    );\n\n    return [count, handlers];\n}\n"],"mappings":"uBAcA,IAAM,GAAS,EAAe,EAAyB,IAAoC,CACvF,IAAI,EAAO,EAGX,OAFI,OAAO,GAAQ,WAAU,EAAO,KAAK,IAAI,EAAK,CAAI,GAClD,OAAO,GAAQ,WAAU,EAAO,KAAK,IAAI,EAAK,CAAI,GAC/C,CACX,EASA,SAAgB,EACZ,EAAU,EACV,EAA6B,CAAC,EACL,CACzB,GAAM,CAAE,MAAK,OAAQ,EACf,CAAC,EAAO,IAAA,EAAY,EAAA,SAAA,KAAuB,EAAM,EAAS,EAAK,CAAG,CAAC,EAEnE,GAAA,EAAY,EAAA,YAAA,KAAwB,CACtC,EAAU,GAAY,EAAM,EAAU,EAAG,EAAK,CAAG,CAAC,CACtD,EAAG,CAAC,EAAK,CAAG,CAAC,EAEP,GAAA,EAAY,EAAA,YAAA,KAAwB,CACtC,EAAU,GAAY,EAAM,EAAU,EAAG,EAAK,CAAG,CAAC,CACtD,EAAG,CAAC,EAAK,CAAG,CAAC,EAEP,GAAA,EAAM,EAAA,YAAA,CACP,GAAwB,CACrB,EAAS,EAAM,EAAO,EAAK,CAAG,CAAC,CACnC,EACA,CAAC,EAAK,CAAG,CACb,EAEM,GAAA,EAAQ,EAAA,YAAA,KAAwB,CAClC,EAAS,EAAM,EAAS,EAAK,CAAG,CAAC,CACrC,EAAG,CAAC,EAAS,EAAK,CAAG,CAAC,EAOtB,MAAO,CAAC,GAAA,EALS,EAAA,QAAA,MACN,CAAE,YAAW,YAAW,MAAK,OAAM,GAC1C,CAAC,EAAW,EAAW,EAAK,CAAK,CAGtB,CAAQ,CAC3B"}
+{"version":3,"file":"use-counter.cjs","names":["useState","useCallback","useMemo","react","clamp","next","value","min","max","useCounter","options","count","setCount","initial","increment","current","decrement","set","reset"],"sources":["../../src/hooks/use-counter.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface UseCounterOptions {\n    min?: number;\n    max?: number;\n}\n\nexport interface CounterHandlers {\n    increment: () => void;\n    decrement: () => void;\n    set: (value: number) => void;\n    reset: () => void;\n}\n\nconst clamp = (value: number, min: number | undefined, max: number | undefined): number => {\n    let next = value;\n    if (typeof min === \"number\") next = Math.max(min, next);\n    if (typeof max === \"number\") next = Math.min(max, next);\n    return next;\n};\n\n/**\n * Numeric counter clamped to an optional `[min, max]` range.\n *\n * @param initial - initial value (default `0`), clamped to the range.\n * @param options - optional `min` / `max` bounds.\n * @returns Tuple `[count, { increment, decrement, set, reset }]`.\n */\nexport function useCounter(\n    initial = 0,\n    options: UseCounterOptions = {},\n): [number, CounterHandlers] {\n    const { min, max } = options;\n    const [count, setCount] = useState<number>(() => clamp(initial, min, max));\n\n    const increment = useCallback((): void => {\n        setCount((current) => clamp(current + 1, min, max));\n    }, [min, max]);\n\n    const decrement = useCallback((): void => {\n        setCount((current) => clamp(current - 1, min, max));\n    }, [min, max]);\n\n    const set = useCallback(\n        (value: number): void => {\n            setCount(clamp(value, min, max));\n        },\n        [min, max],\n    );\n\n    const reset = useCallback((): void => {\n        setCount(clamp(initial, min, max));\n    }, [initial, min, max]);\n\n    const handlers = useMemo<CounterHandlers>(\n        () => ({ increment, decrement, set, reset }),\n        [increment, decrement, set, reset],\n    );\n\n    return [count, handlers];\n}\n"],"mappings":"A,uBAcA,IAAMI,GAAS,EAAe,EAAyB,IAAoC,CACvF,IAAIC,EAAOC,EAGX,OAFI,OAAOC,GAAQ,WAAU,EAAO,KAAK,IAAIA,EAAKF,CAAI,GAClD,OAAOG,GAAQ,WAAU,EAAO,KAAK,IAAIA,EAAKH,CAAI,GAC/CA,CACX,EASA,SAAgBI,EACZ,EAAU,EACV,EAA6B,CAAC,EACL,CACzB,GAAM,CAAE,MAAK,OAAQC,EACf,CAACC,EAAOC,IAAA,EAAYZ,EAAAA,SAAAA,KAAuBI,EAAMS,EAASN,EAAKC,CAAG,CAAC,EAEnEM,GAAA,EAAYb,EAAAA,YAAAA,KAAwB,CACtCW,EAAU,GAAYR,EAAMW,EAAU,EAAGR,EAAKC,CAAG,CAAC,CACtD,EAAG,CAACD,EAAKC,CAAG,CAAC,EAEPQ,GAAA,EAAYf,EAAAA,YAAAA,KAAwB,CACtCW,EAAU,GAAYR,EAAMW,EAAU,EAAGR,EAAKC,CAAG,CAAC,CACtD,EAAG,CAACD,EAAKC,CAAG,CAAC,EAEPS,GAAA,EAAMhB,EAAAA,YAAAA,CACP,GAAwB,CACrBW,EAASR,EAAME,EAAOC,EAAKC,CAAG,CAAC,CACnC,EACA,CAACD,EAAKC,CAAG,CACb,EAEMU,GAAA,EAAQjB,EAAAA,YAAAA,KAAwB,CAClCW,EAASR,EAAMS,EAASN,EAAKC,CAAG,CAAC,CACrC,EAAG,CAACK,EAASN,EAAKC,CAAG,CAAC,EAOtB,MAAO,CAACG,GAAA,EALST,EAAAA,QAAAA,MACN,CAAE,YAAW,YAAW,MAAK,OAAM,GAC1C,CAACY,EAAWE,EAAWC,EAAKC,CAAK,CAGtB,CAAQ,CAC3B,C"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-counter.js","names":[],"sources":["../../src/hooks/use-counter.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface UseCounterOptions {\n    min?: number;\n    max?: number;\n}\n\nexport interface CounterHandlers {\n    increment: () => void;\n    decrement: () => void;\n    set: (value: number) => void;\n    reset: () => void;\n}\n\nconst clamp = (value: number, min: number | undefined, max: number | undefined): number => {\n    let next = value;\n    if (typeof min === \"number\") next = Math.max(min, next);\n    if (typeof max === \"number\") next = Math.min(max, next);\n    return next;\n};\n\n/**\n * Numeric counter clamped to an optional `[min, max]` range.\n *\n * @param initial - initial value (default `0`), clamped to the range.\n * @param options - optional `min` / `max` bounds.\n * @returns Tuple `[count, { increment, decrement, set, reset }]`.\n */\nexport function useCounter(\n    initial = 0,\n    options: UseCounterOptions = {},\n): [number, CounterHandlers] {\n    const { min, max } = options;\n    const [count, setCount] = useState<number>(() => clamp(initial, min, max));\n\n    const increment = useCallback((): void => {\n        setCount((current) => clamp(current + 1, min, max));\n    }, [min, max]);\n\n    const decrement = useCallback((): void => {\n        setCount((current) => clamp(current - 1, min, max));\n    }, [min, max]);\n\n    const set = useCallback(\n        (value: number): void => {\n            setCount(clamp(value, min, max));\n        },\n        [min, max],\n    );\n\n    const reset = useCallback((): void => {\n        setCount(clamp(initial, min, max));\n    }, [initial, min, max]);\n\n    const handlers = useMemo<CounterHandlers>(\n        () => ({ increment, decrement, set, reset }),\n        [increment, decrement, set, reset],\n    );\n\n    return [count, handlers];\n}\n"],"mappings":";;AAcA,IAAM,KAAS,GAAe,GAAyB,MAAoC;CACvF,IAAI,IAAO;CAGX,OAFI,OAAO,KAAQ,aAAU,IAAO,KAAK,IAAI,GAAK,CAAI,IAClD,OAAO,KAAQ,aAAU,IAAO,KAAK,IAAI,GAAK,CAAI,IAC/C;AACX;AASA,SAAgB,EACZ,IAAU,GACV,IAA6B,CAAC,GACL;CACzB,IAAM,EAAE,QAAK,WAAQ,GACf,CAAC,GAAO,KAAY,QAAuB,EAAM,GAAS,GAAK,CAAG,CAAC,GAEnE,IAAY,QAAwB;EACtC,GAAU,MAAY,EAAM,IAAU,GAAG,GAAK,CAAG,CAAC;CACtD,GAAG,CAAC,GAAK,CAAG,CAAC,GAEP,IAAY,QAAwB;EACtC,GAAU,MAAY,EAAM,IAAU,GAAG,GAAK,CAAG,CAAC;CACtD,GAAG,CAAC,GAAK,CAAG,CAAC,GAEP,IAAM,GACP,MAAwB;EACrB,EAAS,EAAM,GAAO,GAAK,CAAG,CAAC;CACnC,GACA,CAAC,GAAK,CAAG,CACb,GAEM,IAAQ,QAAwB;EAClC,EAAS,EAAM,GAAS,GAAK,CAAG,CAAC;CACrC,GAAG;EAAC;EAAS;EAAK;CAAG,CAAC;CAOtB,OAAO,CAAC,GALS,SACN;EAAE;EAAW;EAAW;EAAK;CAAM,IAC1C;EAAC;EAAW;EAAW;EAAK;CAAK,CAGtB,CAAQ;AAC3B"}
+{"version":3,"file":"use-counter.js","names":["clamp","next","value","min","max","useCounter","options","count","setCount","useState","initial","increment","useCallback","current","decrement","set","reset","useMemo"],"sources":["../../src/hooks/use-counter.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface UseCounterOptions {\n    min?: number;\n    max?: number;\n}\n\nexport interface CounterHandlers {\n    increment: () => void;\n    decrement: () => void;\n    set: (value: number) => void;\n    reset: () => void;\n}\n\nconst clamp = (value: number, min: number | undefined, max: number | undefined): number => {\n    let next = value;\n    if (typeof min === \"number\") next = Math.max(min, next);\n    if (typeof max === \"number\") next = Math.min(max, next);\n    return next;\n};\n\n/**\n * Numeric counter clamped to an optional `[min, max]` range.\n *\n * @param initial - initial value (default `0`), clamped to the range.\n * @param options - optional `min` / `max` bounds.\n * @returns Tuple `[count, { increment, decrement, set, reset }]`.\n */\nexport function useCounter(\n    initial = 0,\n    options: UseCounterOptions = {},\n): [number, CounterHandlers] {\n    const { min, max } = options;\n    const [count, setCount] = useState<number>(() => clamp(initial, min, max));\n\n    const increment = useCallback((): void => {\n        setCount((current) => clamp(current + 1, min, max));\n    }, [min, max]);\n\n    const decrement = useCallback((): void => {\n        setCount((current) => clamp(current - 1, min, max));\n    }, [min, max]);\n\n    const set = useCallback(\n        (value: number): void => {\n            setCount(clamp(value, min, max));\n        },\n        [min, max],\n    );\n\n    const reset = useCallback((): void => {\n        setCount(clamp(initial, min, max));\n    }, [initial, min, max]);\n\n    const handlers = useMemo<CounterHandlers>(\n        () => ({ increment, decrement, set, reset }),\n        [increment, decrement, set, reset],\n    );\n\n    return [count, handlers];\n}\n"],"mappings":";;AAcA,IAAMA,KAAS,GAAe,GAAyB,MAAoC;CACvF,IAAIC,IAAOC;CAGX,OAFI,OAAOC,KAAQ,aAAU,IAAO,KAAK,IAAIA,GAAKF,CAAI,IAClD,OAAOG,KAAQ,aAAU,IAAO,KAAK,IAAIA,GAAKH,CAAI,IAC/CA;AACX;AASA,SAAgBI,EACZ,IAAU,GACV,IAA6B,CAAC,GACL;CACzB,IAAM,EAAE,QAAK,WAAQC,GACf,CAACC,GAAOC,KAAYC,QAAuBT,EAAMU,GAASP,GAAKC,CAAG,CAAC,GAEnEO,IAAYC,QAAwB;EACtC,GAAU,MAAYZ,EAAMa,IAAU,GAAGV,GAAKC,CAAG,CAAC;CACtD,GAAG,CAACD,GAAKC,CAAG,CAAC,GAEPU,IAAYF,QAAwB;EACtC,GAAU,MAAYZ,EAAMa,IAAU,GAAGV,GAAKC,CAAG,CAAC;CACtD,GAAG,CAACD,GAAKC,CAAG,CAAC,GAEPW,IAAMH,GACP,MAAwB;EACrB,EAASZ,EAAME,GAAOC,GAAKC,CAAG,CAAC;CACnC,GACA,CAACD,GAAKC,CAAG,CACb,GAEMY,IAAQJ,QAAwB;EAClC,EAASZ,EAAMU,GAASP,GAAKC,CAAG,CAAC;CACrC,GAAG;EAACM;EAASP;EAAKC;CAAG,CAAC;CAOtB,OAAO,CAACG,GALSU,SACN;EAAE;EAAW;EAAW;EAAK;CAAM,IAC1C;EAACN;EAAWG;EAAWC;EAAKC;CAAK,CAGtB,CAAQ;AAC3B"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-debounce.cjs","names":[],"sources":["../../src/hooks/use-debounce.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\n/**\n * Debounce a fast-changing value. Returns the latest value once `delay` ms\n * have elapsed without further changes.\n *\n * @param value - The value to debounce.\n * @param delay - Delay in milliseconds (default 300).\n * @returns The debounced value.\n */\nexport function useDebounce<T>(value: T, delay = 300): T {\n    const [debouncedValue, setDebouncedValue] = useState<T>(value);\n\n    useEffect(() => {\n        const timer = setTimeout(() => setDebouncedValue(value), delay);\n        return () => clearTimeout(timer);\n    }, [value, delay]);\n\n    return debouncedValue;\n}\n"],"mappings":"uBAUA,SAAgB,EAAe,EAAU,EAAQ,IAAQ,CACrD,GAAM,CAAC,EAAgB,IAAA,EAAqB,EAAA,SAAA,CAAY,CAAK,EAO7D,OALA,EAAA,EAAA,UAAA,KAAgB,CACZ,IAAM,EAAQ,eAAiB,EAAkB,CAAK,EAAG,CAAK,EAC9D,UAAa,aAAa,CAAK,CACnC,EAAG,CAAC,EAAO,CAAK,CAAC,EAEV,CACX"}
+{"version":3,"file":"use-debounce.cjs","names":["useState","react","useDebounce","debouncedValue","setDebouncedValue","value","timer","delay"],"sources":["../../src/hooks/use-debounce.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\n/**\n * Debounce a fast-changing value. Returns the latest value once `delay` ms\n * have elapsed without further changes.\n *\n * @param value - The value to debounce.\n * @param delay - Delay in milliseconds (default 300).\n * @returns The debounced value.\n */\nexport function useDebounce<T>(value: T, delay = 300): T {\n    const [debouncedValue, setDebouncedValue] = useState<T>(value);\n\n    useEffect(() => {\n        const timer = setTimeout(() => setDebouncedValue(value), delay);\n        return () => clearTimeout(timer);\n    }, [value, delay]);\n\n    return debouncedValue;\n}\n"],"mappings":"A,uBAUA,SAAgBE,EAAe,EAAU,EAAQ,IAAQ,CACrD,GAAM,CAACC,EAAgBC,IAAA,EAAqBJ,EAAAA,SAAAA,CAAYK,CAAK,EAO7D,OALA,EAAAJ,EAAA,UAAA,KAAgB,CACZ,IAAMK,EAAQ,eAAiBF,EAAkBC,CAAK,EAAGE,CAAK,EAC9D,UAAa,aAAaD,CAAK,CACnC,EAAG,CAACD,EAAOE,CAAK,CAAC,EAEVJ,CACX,C"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-debounce.js","names":[],"sources":["../../src/hooks/use-debounce.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\n/**\n * Debounce a fast-changing value. Returns the latest value once `delay` ms\n * have elapsed without further changes.\n *\n * @param value - The value to debounce.\n * @param delay - Delay in milliseconds (default 300).\n * @returns The debounced value.\n */\nexport function useDebounce<T>(value: T, delay = 300): T {\n    const [debouncedValue, setDebouncedValue] = useState<T>(value);\n\n    useEffect(() => {\n        const timer = setTimeout(() => setDebouncedValue(value), delay);\n        return () => clearTimeout(timer);\n    }, [value, delay]);\n\n    return debouncedValue;\n}\n"],"mappings":";;AAUA,SAAgB,EAAe,GAAU,IAAQ,KAAQ;CACrD,IAAM,CAAC,GAAgB,KAAqB,EAAY,CAAK;CAO7D,OALA,QAAgB;EACZ,IAAM,IAAQ,iBAAiB,EAAkB,CAAK,GAAG,CAAK;EAC9D,aAAa,aAAa,CAAK;CACnC,GAAG,CAAC,GAAO,CAAK,CAAC,GAEV;AACX"}
+{"version":3,"file":"use-debounce.js","names":["useDebounce","debouncedValue","setDebouncedValue","useState","value","useEffect","timer","delay"],"sources":["../../src/hooks/use-debounce.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\n/**\n * Debounce a fast-changing value. Returns the latest value once `delay` ms\n * have elapsed without further changes.\n *\n * @param value - The value to debounce.\n * @param delay - Delay in milliseconds (default 300).\n * @returns The debounced value.\n */\nexport function useDebounce<T>(value: T, delay = 300): T {\n    const [debouncedValue, setDebouncedValue] = useState<T>(value);\n\n    useEffect(() => {\n        const timer = setTimeout(() => setDebouncedValue(value), delay);\n        return () => clearTimeout(timer);\n    }, [value, delay]);\n\n    return debouncedValue;\n}\n"],"mappings":";;AAUA,SAAgBA,EAAe,GAAU,IAAQ,KAAQ;CACrD,IAAM,CAACC,GAAgBC,KAAqBC,EAAYC,CAAK;CAO7D,OALAC,QAAgB;EACZ,IAAMC,IAAQ,iBAAiBJ,EAAkBE,CAAK,GAAGG,CAAK;EAC9D,aAAa,aAAaD,CAAK;CACnC,GAAG,CAACF,GAAOG,CAAK,CAAC,GAEVN;AACX"}

package/dist/hooks/use-deep-memo.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-deep-memo.cjs","names":[],"sources":["../../src/hooks/use-deep-memo.ts"],"sourcesContent":["/* eslint-disable react-hooks/refs -- the structural cache is read and written during render by design (see the docstring) */\nimport { useRef } from \"react\";\n\n/**\n * Structural equality over plain objects and arrays, the comparison `useDeepMemo`\n * and `useDraftFilters` share. Internal: not re-exported from the barrel.\n *\n * @param a - First value.\n * @param b - Second value.\n * @returns Whether both values have the same shape and leaves.\n */\nexport function deepEqual(a: unknown, b: unknown): boolean {\n    if (Object.is(a, b)) return true;\n    if (typeof a !== \"object\" || typeof b !== \"object\" || a === null || b === null) return false;\n    if (Array.isArray(a) !== Array.isArray(b)) return false;\n    if (Array.isArray(a) && Array.isArray(b)) {\n        if (a.length !== b.length) return false;\n        return a.every((value, index) => deepEqual(value, b[index]));\n    }\n    const aKeys = Object.keys(a as object);\n    const bKeys = Object.keys(b as object);\n    if (aKeys.length !== bKeys.length) return false;\n    return aKeys.every((key) =>\n        deepEqual((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key]),\n    );\n}\n\n/**\n * Memoize a value with a structural equality check. Use when an object/array\n * created during render is fed to `useEffect` dependencies and you want to\n * avoid spurious effect runs when only the reference changes.\n *\n * The cache is a ref read and written during render. That is flagged by the React\n * Compiler rules and is nonetheless correct here: the write is idempotent — a\n * discarded render either wrote a structurally equal value or nothing at all — so\n * replaying the render cannot change the result.\n */\nexport function useDeepMemo<T>(value: T): T {\n    const ref = useRef<T>(value);\n    if (!deepEqual(ref.current, value)) {\n        ref.current = value;\n    }\n    return ref.current;\n}\n"],"mappings":"uBAWA,SAAgB,EAAU,EAAY,EAAqB,CACvD,GAAI,OAAO,GAAG,EAAG,CAAC,EAAG,MAAO,GAE5B,GADI,OAAO,GAAM,UAAY,OAAO,GAAM,UAAY,IAAM,MAAQ,IAAM,MACtE,MAAM,QAAQ,CAAC,IAAM,MAAM,QAAQ,CAAC,EAAG,MAAO,GAClD,GAAI,MAAM,QAAQ,CAAC,GAAK,MAAM,QAAQ,CAAC,EAEnC,OADI,EAAE,SAAW,EAAE,QACZ,EAAE,OAAO,EAAO,IAAU,EAAU,EAAO,EAAE,EAAM,CAAC,EAE/D,IAAM,EAAQ,OAAO,KAAK,CAAW,EAC/B,EAAQ,OAAO,KAAK,CAAW,EAErC,OADI,EAAM,SAAW,EAAM,QACpB,EAAM,MAAO,GAChB,EAAW,EAA8B,GAAO,EAA8B,EAAI,CACtF,CACJ,CAYA,SAAgB,EAAe,EAAa,CACxC,IAAM,GAAA,EAAM,EAAA,OAAA,CAAU,CAAK,EAI3B,OAHK,EAAU,EAAI,QAAS,CAAK,IAC7B,EAAI,QAAU,GAEX,EAAI,OACf"}
+{"version":3,"file":"use-deep-memo.cjs","names":["useRef","react","deepEqual","a","b","value","index","aKeys","bKeys","key","useDeepMemo","ref"],"sources":["../../src/hooks/use-deep-memo.ts"],"sourcesContent":["/* eslint-disable react-hooks/refs -- the structural cache is read and written during render by design (see the docstring) */\nimport { useRef } from \"react\";\n\n/**\n * Structural equality over plain objects and arrays, the comparison `useDeepMemo`\n * and `useDraftFilters` share. Internal: not re-exported from the barrel.\n *\n * @param a - First value.\n * @param b - Second value.\n * @returns Whether both values have the same shape and leaves.\n */\nexport function deepEqual(a: unknown, b: unknown): boolean {\n    if (Object.is(a, b)) return true;\n    if (typeof a !== \"object\" || typeof b !== \"object\" || a === null || b === null) return false;\n    if (Array.isArray(a) !== Array.isArray(b)) return false;\n    if (Array.isArray(a) && Array.isArray(b)) {\n        if (a.length !== b.length) return false;\n        return a.every((value, index) => deepEqual(value, b[index]));\n    }\n    const aKeys = Object.keys(a as object);\n    const bKeys = Object.keys(b as object);\n    if (aKeys.length !== bKeys.length) return false;\n    return aKeys.every((key) =>\n        deepEqual((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key]),\n    );\n}\n\n/**\n * Memoize a value with a structural equality check. Use when an object/array\n * created during render is fed to `useEffect` dependencies and you want to\n * avoid spurious effect runs when only the reference changes.\n *\n * The cache is a ref read and written during render. That is flagged by the React\n * Compiler rules and is nonetheless correct here: the write is idempotent — a\n * discarded render either wrote a structurally equal value or nothing at all — so\n * replaying the render cannot change the result.\n */\nexport function useDeepMemo<T>(value: T): T {\n    const ref = useRef<T>(value);\n    if (!deepEqual(ref.current, value)) {\n        ref.current = value;\n    }\n    return ref.current;\n}\n"],"mappings":"A,uBAWA,SAAgBE,EAAU,EAAY,EAAqB,CACvD,GAAI,OAAO,GAAGC,EAAGC,CAAC,EAAG,MAAO,GAE5B,GADI,OAAOD,GAAM,UAAY,OAAOC,GAAM,UAAYD,IAAM,MAAQC,IAAM,MACtE,MAAM,QAAQD,CAAC,IAAM,MAAM,QAAQC,CAAC,EAAG,MAAO,GAClD,GAAI,MAAM,QAAQD,CAAC,GAAK,MAAM,QAAQC,CAAC,EAEnC,OADID,EAAE,SAAWC,EAAE,QACZD,EAAE,OAAO,EAAO,IAAUD,EAAUG,EAAOD,EAAEE,EAAM,CAAC,EAE/D,IAAMC,EAAQ,OAAO,KAAKJ,CAAW,EAC/BK,EAAQ,OAAO,KAAKJ,CAAW,EAErC,OADIG,EAAM,SAAWC,EAAM,QACpBD,EAAM,MAAO,GAChBL,EAAWC,EAA8BM,GAAOL,EAA8BK,EAAI,CACtF,CACJ,CAYA,SAAgBC,EAAe,EAAa,CACxC,IAAMC,GAAA,EAAMX,EAAAA,OAAAA,CAAUK,CAAK,EAI3B,OAHKH,EAAUS,EAAI,QAASN,CAAK,IAC7B,EAAI,QAAUA,GAEXM,EAAI,OACf,C"}

package/dist/hooks/use-deep-memo.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-deep-memo.js","names":[],"sources":["../../src/hooks/use-deep-memo.ts"],"sourcesContent":["/* eslint-disable react-hooks/refs -- the structural cache is read and written during render by design (see the docstring) */\nimport { useRef } from \"react\";\n\n/**\n * Structural equality over plain objects and arrays, the comparison `useDeepMemo`\n * and `useDraftFilters` share. Internal: not re-exported from the barrel.\n *\n * @param a - First value.\n * @param b - Second value.\n * @returns Whether both values have the same shape and leaves.\n */\nexport function deepEqual(a: unknown, b: unknown): boolean {\n    if (Object.is(a, b)) return true;\n    if (typeof a !== \"object\" || typeof b !== \"object\" || a === null || b === null) return false;\n    if (Array.isArray(a) !== Array.isArray(b)) return false;\n    if (Array.isArray(a) && Array.isArray(b)) {\n        if (a.length !== b.length) return false;\n        return a.every((value, index) => deepEqual(value, b[index]));\n    }\n    const aKeys = Object.keys(a as object);\n    const bKeys = Object.keys(b as object);\n    if (aKeys.length !== bKeys.length) return false;\n    return aKeys.every((key) =>\n        deepEqual((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key]),\n    );\n}\n\n/**\n * Memoize a value with a structural equality check. Use when an object/array\n * created during render is fed to `useEffect` dependencies and you want to\n * avoid spurious effect runs when only the reference changes.\n *\n * The cache is a ref read and written during render. That is flagged by the React\n * Compiler rules and is nonetheless correct here: the write is idempotent — a\n * discarded render either wrote a structurally equal value or nothing at all — so\n * replaying the render cannot change the result.\n */\nexport function useDeepMemo<T>(value: T): T {\n    const ref = useRef<T>(value);\n    if (!deepEqual(ref.current, value)) {\n        ref.current = value;\n    }\n    return ref.current;\n}\n"],"mappings":";;AAWA,SAAgB,EAAU,GAAY,GAAqB;CACvD,IAAI,OAAO,GAAG,GAAG,CAAC,GAAG,OAAO;CAE5B,IADI,OAAO,KAAM,YAAY,OAAO,KAAM,YAAY,MAAM,QAAQ,MAAM,QACtE,MAAM,QAAQ,CAAC,MAAM,MAAM,QAAQ,CAAC,GAAG,OAAO;CAClD,IAAI,MAAM,QAAQ,CAAC,KAAK,MAAM,QAAQ,CAAC,GAEnC,OADI,EAAE,WAAW,EAAE,UACZ,EAAE,OAAO,GAAO,MAAU,EAAU,GAAO,EAAE,EAAM,CAAC;CAE/D,IAAM,IAAQ,OAAO,KAAK,CAAW,GAC/B,IAAQ,OAAO,KAAK,CAAW;CAErC,OADI,EAAM,WAAW,EAAM,UACpB,EAAM,OAAO,MAChB,EAAW,EAA8B,IAAO,EAA8B,EAAI,CACtF;AACJ;AAYA,SAAgB,EAAe,GAAa;CACxC,IAAM,IAAM,EAAU,CAAK;CAI3B,OAHK,EAAU,EAAI,SAAS,CAAK,MAC7B,EAAI,UAAU,IAEX,EAAI;AACf"}
+{"version":3,"file":"use-deep-memo.js","names":["deepEqual","a","b","value","index","aKeys","bKeys","key","useDeepMemo","ref","useRef"],"sources":["../../src/hooks/use-deep-memo.ts"],"sourcesContent":["/* eslint-disable react-hooks/refs -- the structural cache is read and written during render by design (see the docstring) */\nimport { useRef } from \"react\";\n\n/**\n * Structural equality over plain objects and arrays, the comparison `useDeepMemo`\n * and `useDraftFilters` share. Internal: not re-exported from the barrel.\n *\n * @param a - First value.\n * @param b - Second value.\n * @returns Whether both values have the same shape and leaves.\n */\nexport function deepEqual(a: unknown, b: unknown): boolean {\n    if (Object.is(a, b)) return true;\n    if (typeof a !== \"object\" || typeof b !== \"object\" || a === null || b === null) return false;\n    if (Array.isArray(a) !== Array.isArray(b)) return false;\n    if (Array.isArray(a) && Array.isArray(b)) {\n        if (a.length !== b.length) return false;\n        return a.every((value, index) => deepEqual(value, b[index]));\n    }\n    const aKeys = Object.keys(a as object);\n    const bKeys = Object.keys(b as object);\n    if (aKeys.length !== bKeys.length) return false;\n    return aKeys.every((key) =>\n        deepEqual((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key]),\n    );\n}\n\n/**\n * Memoize a value with a structural equality check. Use when an object/array\n * created during render is fed to `useEffect` dependencies and you want to\n * avoid spurious effect runs when only the reference changes.\n *\n * The cache is a ref read and written during render. That is flagged by the React\n * Compiler rules and is nonetheless correct here: the write is idempotent — a\n * discarded render either wrote a structurally equal value or nothing at all — so\n * replaying the render cannot change the result.\n */\nexport function useDeepMemo<T>(value: T): T {\n    const ref = useRef<T>(value);\n    if (!deepEqual(ref.current, value)) {\n        ref.current = value;\n    }\n    return ref.current;\n}\n"],"mappings":";;AAWA,SAAgBA,EAAU,GAAY,GAAqB;CACvD,IAAI,OAAO,GAAGC,GAAGC,CAAC,GAAG,OAAO;CAE5B,IADI,OAAOD,KAAM,YAAY,OAAOC,KAAM,YAAYD,MAAM,QAAQC,MAAM,QACtE,MAAM,QAAQD,CAAC,MAAM,MAAM,QAAQC,CAAC,GAAG,OAAO;CAClD,IAAI,MAAM,QAAQD,CAAC,KAAK,MAAM,QAAQC,CAAC,GAEnC,OADID,EAAE,WAAWC,EAAE,UACZD,EAAE,OAAO,GAAO,MAAUD,EAAUG,GAAOD,EAAEE,EAAM,CAAC;CAE/D,IAAMC,IAAQ,OAAO,KAAKJ,CAAW,GAC/BK,IAAQ,OAAO,KAAKJ,CAAW;CAErC,OADIG,EAAM,WAAWC,EAAM,UACpBD,EAAM,OAAO,MAChBL,EAAWC,EAA8BM,IAAOL,EAA8BK,EAAI,CACtF;AACJ;AAYA,SAAgBC,EAAe,GAAa;CACxC,IAAMC,IAAMC,EAAUP,CAAK;CAI3B,OAHKH,EAAUS,EAAI,SAASN,CAAK,MAC7B,EAAI,UAAUA,IAEXM,EAAI;AACf"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-disclosure.cjs","names":[],"sources":["../../src/hooks/use-disclosure.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface DisclosureHandlers {\n    open: () => void;\n    close: () => void;\n    toggle: () => void;\n}\n\n/**\n * Manage open/closed boolean state with stable `open`/`close`/`toggle` handlers.\n *\n * Richer than {@link useToggle} for UI elements like modals, drawers and\n * popovers: the handlers are referentially stable across renders.\n *\n * @param initial - initial opened state (default `false`).\n * @returns Tuple `[opened, { open, close, toggle }]`.\n */\nexport function useDisclosure(initial = false): [boolean, DisclosureHandlers] {\n    const [opened, setOpened] = useState<boolean>(initial);\n\n    const open = useCallback((): void => setOpened(true), []);\n    const close = useCallback((): void => setOpened(false), []);\n    const toggle = useCallback((): void => setOpened((current) => !current), []);\n\n    const handlers = useMemo<DisclosureHandlers>(\n        () => ({ open, close, toggle }),\n        [open, close, toggle],\n    );\n\n    return [opened, handlers];\n}\n"],"mappings":"uBAiBA,SAAgB,EAAc,EAAU,GAAsC,CAC1E,GAAM,CAAC,EAAQ,IAAA,EAAa,EAAA,SAAA,CAAkB,CAAO,EAE/C,GAAA,EAAO,EAAA,YAAA,KAAwB,EAAU,EAAI,EAAG,CAAC,CAAC,EAClD,GAAA,EAAQ,EAAA,YAAA,KAAwB,EAAU,EAAK,EAAG,CAAC,CAAC,EACpD,GAAA,EAAS,EAAA,YAAA,KAAwB,EAAW,GAAY,CAAC,CAAO,EAAG,CAAC,CAAC,EAO3E,MAAO,CAAC,GAAA,EALS,EAAA,QAAA,MACN,CAAE,OAAM,QAAO,QAAO,GAC7B,CAAC,EAAM,EAAO,CAAM,CAGR,CAAQ,CAC5B"}
+{"version":3,"file":"use-disclosure.cjs","names":["useState","useCallback","useMemo","react","useDisclosure","opened","setOpened","initial","open","close","toggle","current"],"sources":["../../src/hooks/use-disclosure.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface DisclosureHandlers {\n    open: () => void;\n    close: () => void;\n    toggle: () => void;\n}\n\n/**\n * Manage open/closed boolean state with stable `open`/`close`/`toggle` handlers.\n *\n * Richer than {@link useToggle} for UI elements like modals, drawers and\n * popovers: the handlers are referentially stable across renders.\n *\n * @param initial - initial opened state (default `false`).\n * @returns Tuple `[opened, { open, close, toggle }]`.\n */\nexport function useDisclosure(initial = false): [boolean, DisclosureHandlers] {\n    const [opened, setOpened] = useState<boolean>(initial);\n\n    const open = useCallback((): void => setOpened(true), []);\n    const close = useCallback((): void => setOpened(false), []);\n    const toggle = useCallback((): void => setOpened((current) => !current), []);\n\n    const handlers = useMemo<DisclosureHandlers>(\n        () => ({ open, close, toggle }),\n        [open, close, toggle],\n    );\n\n    return [opened, handlers];\n}\n"],"mappings":"A,uBAiBA,SAAgBI,EAAc,EAAU,GAAsC,CAC1E,GAAM,CAACC,EAAQC,IAAA,EAAaN,EAAAA,SAAAA,CAAkBO,CAAO,EAE/CC,GAAA,EAAOP,EAAAA,YAAAA,KAAwBK,EAAU,EAAI,EAAG,CAAC,CAAC,EAClDG,GAAA,EAAQR,EAAAA,YAAAA,KAAwBK,EAAU,EAAK,EAAG,CAAC,CAAC,EACpDI,GAAA,EAAST,EAAAA,YAAAA,KAAwBK,EAAW,GAAY,CAACK,CAAO,EAAG,CAAC,CAAC,EAO3E,MAAO,CAACN,GAAA,EALSH,EAAAA,QAAAA,MACN,CAAE,OAAM,QAAO,QAAO,GAC7B,CAACM,EAAMC,EAAOC,CAAM,CAGR,CAAQ,CAC5B,C"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-disclosure.js","names":[],"sources":["../../src/hooks/use-disclosure.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface DisclosureHandlers {\n    open: () => void;\n    close: () => void;\n    toggle: () => void;\n}\n\n/**\n * Manage open/closed boolean state with stable `open`/`close`/`toggle` handlers.\n *\n * Richer than {@link useToggle} for UI elements like modals, drawers and\n * popovers: the handlers are referentially stable across renders.\n *\n * @param initial - initial opened state (default `false`).\n * @returns Tuple `[opened, { open, close, toggle }]`.\n */\nexport function useDisclosure(initial = false): [boolean, DisclosureHandlers] {\n    const [opened, setOpened] = useState<boolean>(initial);\n\n    const open = useCallback((): void => setOpened(true), []);\n    const close = useCallback((): void => setOpened(false), []);\n    const toggle = useCallback((): void => setOpened((current) => !current), []);\n\n    const handlers = useMemo<DisclosureHandlers>(\n        () => ({ open, close, toggle }),\n        [open, close, toggle],\n    );\n\n    return [opened, handlers];\n}\n"],"mappings":";;AAiBA,SAAgB,EAAc,IAAU,IAAsC;CAC1E,IAAM,CAAC,GAAQ,KAAa,EAAkB,CAAO,GAE/C,IAAO,QAAwB,EAAU,EAAI,GAAG,CAAC,CAAC,GAClD,IAAQ,QAAwB,EAAU,EAAK,GAAG,CAAC,CAAC,GACpD,IAAS,QAAwB,GAAW,MAAY,CAAC,CAAO,GAAG,CAAC,CAAC;CAO3E,OAAO,CAAC,GALS,SACN;EAAE;EAAM;EAAO;CAAO,IAC7B;EAAC;EAAM;EAAO;CAAM,CAGR,CAAQ;AAC5B"}
+{"version":3,"file":"use-disclosure.js","names":["useDisclosure","opened","setOpened","useState","initial","open","useCallback","close","toggle","current","useMemo"],"sources":["../../src/hooks/use-disclosure.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface DisclosureHandlers {\n    open: () => void;\n    close: () => void;\n    toggle: () => void;\n}\n\n/**\n * Manage open/closed boolean state with stable `open`/`close`/`toggle` handlers.\n *\n * Richer than {@link useToggle} for UI elements like modals, drawers and\n * popovers: the handlers are referentially stable across renders.\n *\n * @param initial - initial opened state (default `false`).\n * @returns Tuple `[opened, { open, close, toggle }]`.\n */\nexport function useDisclosure(initial = false): [boolean, DisclosureHandlers] {\n    const [opened, setOpened] = useState<boolean>(initial);\n\n    const open = useCallback((): void => setOpened(true), []);\n    const close = useCallback((): void => setOpened(false), []);\n    const toggle = useCallback((): void => setOpened((current) => !current), []);\n\n    const handlers = useMemo<DisclosureHandlers>(\n        () => ({ open, close, toggle }),\n        [open, close, toggle],\n    );\n\n    return [opened, handlers];\n}\n"],"mappings":";;AAiBA,SAAgBA,EAAc,IAAU,IAAsC;CAC1E,IAAM,CAACC,GAAQC,KAAaC,EAAkBC,CAAO,GAE/CC,IAAOC,QAAwBJ,EAAU,EAAI,GAAG,CAAC,CAAC,GAClDK,IAAQD,QAAwBJ,EAAU,EAAK,GAAG,CAAC,CAAC,GACpDM,IAASF,QAAwBJ,GAAW,MAAY,CAACO,CAAO,GAAG,CAAC,CAAC;CAO3E,OAAO,CAACR,GALSS,SACN;EAAE;EAAM;EAAO;CAAO,IAC7B;EAACL;EAAME;EAAOC;CAAM,CAGR,CAAQ;AAC5B"}

package/dist/hooks/use-document-title.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-document-title.cjs","names":[],"sources":["../../src/hooks/use-document-title.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\n/**\n * Set `document.title` while the component is mounted, restoring the previous\n * title on unmount. SSR-safe — no-op when `document` is unavailable.\n *\n * @param title - the title to apply.\n */\nexport function useDocumentTitle(title: string): void {\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n        const previous = document.title;\n        document.title = title;\n        return () => {\n            document.title = previous;\n        };\n    }, [title]);\n}\n"],"mappings":"uBAQA,SAAgB,EAAiB,EAAqB,EAClD,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,OAAO,SAAa,IAAa,OACrC,IAAM,EAAW,SAAS,MAE1B,MADA,UAAS,MAAQ,MACJ,CACT,SAAS,MAAQ,CACrB,CACJ,EAAG,CAAC,CAAK,CAAC,CACd"}
+{"version":3,"file":"use-document-title.cjs","names":["react","useDocumentTitle","previous","title"],"sources":["../../src/hooks/use-document-title.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\n/**\n * Set `document.title` while the component is mounted, restoring the previous\n * title on unmount. SSR-safe — no-op when `document` is unavailable.\n *\n * @param title - the title to apply.\n */\nexport function useDocumentTitle(title: string): void {\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n        const previous = document.title;\n        document.title = title;\n        return () => {\n            document.title = previous;\n        };\n    }, [title]);\n}\n"],"mappings":"A,uBAQA,SAAgBC,EAAiB,EAAqB,EAClD,EAAAD,EAAA,UAAA,KAAgB,CACZ,GAAI,OAAO,SAAa,IAAa,OACrC,IAAME,EAAW,SAAS,MAE1B,MADA,UAAS,MAAQC,MACJ,CACT,SAAS,MAAQD,CACrB,CACJ,EAAG,CAACC,CAAK,CAAC,CACd,C"}

package/dist/hooks/use-document-title.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-document-title.js","names":[],"sources":["../../src/hooks/use-document-title.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\n/**\n * Set `document.title` while the component is mounted, restoring the previous\n * title on unmount. SSR-safe — no-op when `document` is unavailable.\n *\n * @param title - the title to apply.\n */\nexport function useDocumentTitle(title: string): void {\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n        const previous = document.title;\n        document.title = title;\n        return () => {\n            document.title = previous;\n        };\n    }, [title]);\n}\n"],"mappings":";;AAQA,SAAgB,EAAiB,GAAqB;CAClD,QAAgB;EACZ,IAAI,OAAO,WAAa,KAAa;EACrC,IAAM,IAAW,SAAS;EAE1B,OADA,SAAS,QAAQ,SACJ;GACT,SAAS,QAAQ;EACrB;CACJ,GAAG,CAAC,CAAK,CAAC;AACd"}
+{"version":3,"file":"use-document-title.js","names":["useDocumentTitle","previous","title"],"sources":["../../src/hooks/use-document-title.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\n/**\n * Set `document.title` while the component is mounted, restoring the previous\n * title on unmount. SSR-safe — no-op when `document` is unavailable.\n *\n * @param title - the title to apply.\n */\nexport function useDocumentTitle(title: string): void {\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n        const previous = document.title;\n        document.title = title;\n        return () => {\n            document.title = previous;\n        };\n    }, [title]);\n}\n"],"mappings":";;AAQA,SAAgBA,EAAiB,GAAqB;CAClD,QAAgB;EACZ,IAAI,OAAO,WAAa,KAAa;EACrC,IAAMC,IAAW,SAAS;EAE1B,OADA,SAAS,QAAQC,SACJ;GACT,SAAS,QAAQD;EACrB;CACJ,GAAG,CAACC,CAAK,CAAC;AACd"}

package/dist/hooks/use-document-visibility.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-document-visibility.cjs","names":[],"sources":["../../src/hooks/use-document-visibility.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\nexport type DocumentVisibility = \"visible\" | \"hidden\";\n\n/** Subscribe to `document.visibilityState`. Returns `\"visible\"` during SSR. */\nexport function useDocumentVisibility(): DocumentVisibility {\n    const [state, setState] = useState<DocumentVisibility>(() =>\n        typeof document === \"undefined\"\n            ? \"visible\"\n            : (document.visibilityState as DocumentVisibility),\n    );\n\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n        const handler = (): void => setState(document.visibilityState as DocumentVisibility);\n        document.addEventListener(\"visibilitychange\", handler);\n        return () => document.removeEventListener(\"visibilitychange\", handler);\n    }, []);\n\n    return state;\n}\n"],"mappings":"uBAKA,SAAgB,GAA4C,CACxD,GAAM,CAAC,EAAO,IAAA,EAAY,EAAA,SAAA,KACtB,OAAO,SAAa,IACd,UACC,SAAS,eACpB,EASA,OAPA,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,OAAO,SAAa,IAAa,OACrC,IAAM,MAAsB,EAAS,SAAS,eAAqC,EAEnF,OADA,SAAS,iBAAiB,mBAAoB,CAAO,MACxC,SAAS,oBAAoB,mBAAoB,CAAO,CACzE,EAAG,CAAC,CAAC,EAEE,CACX"}
+{"version":3,"file":"use-document-visibility.cjs","names":["useState","react","useDocumentVisibility","state","setState","handler"],"sources":["../../src/hooks/use-document-visibility.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\nexport type DocumentVisibility = \"visible\" | \"hidden\";\n\n/** Subscribe to `document.visibilityState`. Returns `\"visible\"` during SSR. */\nexport function useDocumentVisibility(): DocumentVisibility {\n    const [state, setState] = useState<DocumentVisibility>(() =>\n        typeof document === \"undefined\"\n            ? \"visible\"\n            : (document.visibilityState as DocumentVisibility),\n    );\n\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n        const handler = (): void => setState(document.visibilityState as DocumentVisibility);\n        document.addEventListener(\"visibilitychange\", handler);\n        return () => document.removeEventListener(\"visibilitychange\", handler);\n    }, []);\n\n    return state;\n}\n"],"mappings":"A,uBAKA,SAAgBE,GAA4C,CACxD,GAAM,CAACC,EAAOC,IAAA,EAAYJ,EAAAA,SAAAA,KACtB,OAAO,SAAa,IACd,UACC,SAAS,eACpB,EASA,OAPA,EAAAC,EAAA,UAAA,KAAgB,CACZ,GAAI,OAAO,SAAa,IAAa,OACrC,IAAMI,MAAsBD,EAAS,SAAS,eAAqC,EAEnF,OADA,SAAS,iBAAiB,mBAAoBC,CAAO,MACxC,SAAS,oBAAoB,mBAAoBA,CAAO,CACzE,EAAG,CAAC,CAAC,EAEEF,CACX,C"}

package/dist/hooks/use-document-visibility.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-document-visibility.js","names":[],"sources":["../../src/hooks/use-document-visibility.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\nexport type DocumentVisibility = \"visible\" | \"hidden\";\n\n/** Subscribe to `document.visibilityState`. Returns `\"visible\"` during SSR. */\nexport function useDocumentVisibility(): DocumentVisibility {\n    const [state, setState] = useState<DocumentVisibility>(() =>\n        typeof document === \"undefined\"\n            ? \"visible\"\n            : (document.visibilityState as DocumentVisibility),\n    );\n\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n        const handler = (): void => setState(document.visibilityState as DocumentVisibility);\n        document.addEventListener(\"visibilitychange\", handler);\n        return () => document.removeEventListener(\"visibilitychange\", handler);\n    }, []);\n\n    return state;\n}\n"],"mappings":";;AAKA,SAAgB,IAA4C;CACxD,IAAM,CAAC,GAAO,KAAY,QACtB,OAAO,WAAa,MACd,YACC,SAAS,eACpB;CASA,OAPA,QAAgB;EACZ,IAAI,OAAO,WAAa,KAAa;EACrC,IAAM,UAAsB,EAAS,SAAS,eAAqC;EAEnF,OADA,SAAS,iBAAiB,oBAAoB,CAAO,SACxC,SAAS,oBAAoB,oBAAoB,CAAO;CACzE,GAAG,CAAC,CAAC,GAEE;AACX"}
+{"version":3,"file":"use-document-visibility.js","names":["useDocumentVisibility","state","setState","useState","useEffect","handler"],"sources":["../../src/hooks/use-document-visibility.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\nexport type DocumentVisibility = \"visible\" | \"hidden\";\n\n/** Subscribe to `document.visibilityState`. Returns `\"visible\"` during SSR. */\nexport function useDocumentVisibility(): DocumentVisibility {\n    const [state, setState] = useState<DocumentVisibility>(() =>\n        typeof document === \"undefined\"\n            ? \"visible\"\n            : (document.visibilityState as DocumentVisibility),\n    );\n\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n        const handler = (): void => setState(document.visibilityState as DocumentVisibility);\n        document.addEventListener(\"visibilitychange\", handler);\n        return () => document.removeEventListener(\"visibilitychange\", handler);\n    }, []);\n\n    return state;\n}\n"],"mappings":";;AAKA,SAAgBA,IAA4C;CACxD,IAAM,CAACC,GAAOC,KAAYC,QACtB,OAAO,WAAa,MACd,YACC,SAAS,eACpB;CASA,OAPAC,QAAgB;EACZ,IAAI,OAAO,WAAa,KAAa;EACrC,IAAMC,UAAsBH,EAAS,SAAS,eAAqC;EAEnF,OADA,SAAS,iBAAiB,oBAAoBG,CAAO,SACxC,SAAS,oBAAoB,oBAAoBA,CAAO;CACzE,GAAG,CAAC,CAAC,GAEEJ;AACX"}

package/dist/hooks/use-draft-filters.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-draft-filters.cjs","names":[],"sources":["../../src/hooks/use-draft-filters.ts"],"sourcesContent":["import { useCallback, useRef, useState } from \"react\";\n\nimport { deepEqual } from \"./use-deep-memo\";\nimport { useLatestRef } from \"./use-latest-ref\";\n\n/** An edit to the draft: a partial object merged over it, or an updater. */\nexport type DraftFiltersPatch<T> = Partial<T> | ((draft: T) => T);\n\nexport interface UseDraftFiltersOptions<T> {\n    /**\n     * Called with the applied value on every `apply()` and `clear()` — the place to\n     * reset a page number you keep yourself. `usePaginatedQuery` does not need it:\n     * it goes back to page 1 on its own when `applied` changes its `queryKey`.\n     */\n    onApply?: (applied: T) => void;\n    /** Equality behind `isDirty` and the stable `applied`. Default: structural. */\n    isEqual?: (a: T, b: T) => boolean;\n}\n\nexport interface UseDraftFiltersResult<T> {\n    /** What the filter controls edit. Changes on every keystroke. */\n    draft: T;\n    /**\n     * What the query reads. Changes only on `apply()`/`clear()`, and keeps its\n     * reference when the value applied is equal to the current one — safe to put\n     * in a `queryKey`.\n     */\n    applied: T;\n    /** Whether the draft differs from what is applied — enable the apply button on it. */\n    isDirty: boolean;\n    /** Edit the draft, merging a partial object or running an updater. Never applies. */\n    set: (patch: DraftFiltersPatch<T>) => void;\n    /**\n     * Publish the draft. With a patch, merge it into the draft **and** publish the\n     * result in the same call — \"filter by this code\" from a table row.\n     */\n    apply: (patch?: DraftFiltersPatch<T>) => void;\n    /** Reset the draft and the applied value to the initial one, together. */\n    clear: () => void;\n}\n\n/** Both halves, kept in one state so they can never be committed apart. */\ninterface DraftFiltersState<T> {\n    draft: T;\n    applied: T;\n}\n\n/**\n * Resolve a patch against a draft.\n *\n * @param draft - The current draft.\n * @param patch - A partial object to merge, or an updater.\n * @returns The next draft.\n */\nfunction patchDraft<T>(draft: T, patch: DraftFiltersPatch<T>): T {\n    return typeof patch === \"function\" ? patch(draft) : { ...draft, ...patch };\n}\n\n/**\n * Draft vs applied state for a server-side filter: the controls edit a draft\n * freely, and the query only sees it when the user applies (a click, or Enter).\n *\n * A server-side filter cannot react to every keystroke — each character typed in\n * a search box would be a request. Every admin screen then writes the same pair of\n * `useState`s, and gets the same three details wrong:\n *\n * - **Clearing moves both halves.** Resetting only the draft leaves a filtered\n *   list under an empty bar; resetting only the applied value leaves the opposite.\n * - **Applying a value that is not in state yet.** \"Filter by this code\" has to\n *   write the draft and publish it in one gesture; calling `setDraft(x)` and then\n *   publishing `draft` reads the previous value. `apply(patch)` computes the next\n *   draft from a ref that every call keeps current, so it never depends on the\n *   order React flushes state in.\n * - **Resetting the page.** Filtering while on page 7 of a result that now has two\n *   pages shows an empty table. `usePaginatedQuery` handles it by itself when\n *   `applied` is in its `queryKey`; a page kept elsewhere resets in `onApply`.\n *\n * There is no effect in here: applying happens inside the event that asked for it,\n * so one click is one request. `applied` keeps its reference while nothing new is\n * applied, so it can sit in a `queryKey` without a phantom refetch.\n *\n * Like `useState`, the initial value is read on the first render only; `clear()`\n * returns to it.\n *\n * @param initial - The empty filter form: what the screen shows and queries first.\n * @param options - `onApply` and `isEqual`.\n * @returns The draft, the applied value and the gestures between them.\n *\n * @example\n * const filters = useDraftFilters({ code: \"\", level: \"all\" });\n * const logs = usePaginatedQuery({\n *     queryKey: [\"logs\", filters.applied],\n *     queryFn: (params) => api.listLogs({ ...params, ...toQuery(filters.applied) }),\n * });\n * // <Input value={filters.draft.code} onChange={(e) => filters.set({ code: e.target.value })} />\n * // <Button disabled={!filters.isDirty} onClick={() => filters.apply()}>Filtrar</Button>\n */\nexport function useDraftFilters<T extends object>(\n    initial: T,\n    options: UseDraftFiltersOptions<T> = {},\n): UseDraftFiltersResult<T> {\n    const [state, setState] = useState<DraftFiltersState<T>>(() => ({\n        draft: initial,\n        applied: initial,\n    }));\n    const initialRef = useRef<T>(state.applied);\n    const stateRef = useRef<DraftFiltersState<T>>(state);\n    const optionsRef = useLatestRef(options);\n\n    const equal = useCallback(\n        (a: T, b: T): boolean => (optionsRef.current.isEqual ?? deepEqual)(a, b),\n        [optionsRef],\n    );\n\n    const commit = useCallback((next: DraftFiltersState<T>): void => {\n        stateRef.current = next;\n        setState(next);\n    }, []);\n\n    const set = useCallback(\n        (patch: DraftFiltersPatch<T>): void => {\n            const current = stateRef.current;\n            commit({ draft: patchDraft(current.draft, patch), applied: current.applied });\n        },\n        [commit],\n    );\n\n    const publish = useCallback(\n        (next: T): void => {\n            const current = stateRef.current;\n            const applied = equal(next, current.applied) ? current.applied : next;\n            commit({ draft: next, applied });\n            optionsRef.current.onApply?.(applied);\n        },\n        [commit, equal, optionsRef],\n    );\n\n    const apply = useCallback(\n        (patch?: DraftFiltersPatch<T>): void => {\n            const draft = stateRef.current.draft;\n            publish(patch === undefined ? draft : patchDraft(draft, patch));\n        },\n        [publish],\n    );\n\n    const clear = useCallback((): void => publish(initialRef.current), [publish]);\n\n    return {\n        draft: state.draft,\n        applied: state.applied,\n        isDirty: !(options.isEqual ?? deepEqual)(state.draft, state.applied),\n        set,\n        apply,\n        clear,\n    };\n}\n"],"mappings":"gGAsDA,SAAS,EAAc,EAAU,EAAgC,CAC7D,OAAO,OAAO,GAAU,WAAa,EAAM,CAAK,EAAI,CAAE,GAAG,EAAO,GAAG,CAAM,CAC7E,CAyCA,SAAgB,EACZ,EACA,EAAqC,CAAC,EACd,CACxB,GAAM,CAAC,EAAO,IAAA,EAAY,EAAA,SAAA,MAAsC,CAC5D,MAAO,EACP,QAAS,CACb,EAAE,EACI,GAAA,EAAa,EAAA,OAAA,CAAU,EAAM,OAAO,EACpC,GAAA,EAAW,EAAA,OAAA,CAA6B,CAAK,EAC7C,EAAa,EAAA,aAAa,CAAO,EAEjC,GAAA,EAAQ,EAAA,YAAA,EACT,EAAM,KAAmB,EAAW,QAAQ,SAAW,EAAA,UAAA,CAAW,EAAG,CAAC,EACvE,CAAC,CAAU,CACf,EAEM,GAAA,EAAS,EAAA,YAAA,CAAa,GAAqC,CAC7D,EAAS,QAAU,EACnB,EAAS,CAAI,CACjB,EAAG,CAAC,CAAC,EAEC,GAAA,EAAM,EAAA,YAAA,CACP,GAAsC,CACnC,IAAM,EAAU,EAAS,QACzB,EAAO,CAAE,MAAO,EAAW,EAAQ,MAAO,CAAK,EAAG,QAAS,EAAQ,OAAQ,CAAC,CAChF,EACA,CAAC,CAAM,CACX,EAEM,GAAA,EAAU,EAAA,YAAA,CACX,GAAkB,CACf,IAAM,EAAU,EAAS,QACnB,EAAU,EAAM,EAAM,EAAQ,OAAO,EAAI,EAAQ,QAAU,EACjE,EAAO,CAAE,MAAO,EAAM,SAAQ,CAAC,EAC/B,EAAW,QAAQ,UAAU,CAAO,CACxC,EACA,CAAC,EAAQ,EAAO,CAAU,CAC9B,EAEM,GAAA,EAAQ,EAAA,YAAA,CACT,GAAuC,CACpC,IAAM,EAAQ,EAAS,QAAQ,MAC/B,EAAQ,IAAU,IAAA,GAAY,EAAQ,EAAW,EAAO,CAAK,CAAC,CAClE,EACA,CAAC,CAAO,CACZ,EAEM,GAAA,EAAQ,EAAA,YAAA,KAAwB,EAAQ,EAAW,OAAO,EAAG,CAAC,CAAO,CAAC,EAE5E,MAAO,CACH,MAAO,EAAM,MACb,QAAS,EAAM,QACf,QAAS,EAAE,EAAQ,SAAW,EAAA,UAAA,CAAW,EAAM,MAAO,EAAM,OAAO,EACnE,MACA,QACA,OACJ,CACJ"}
+{"version":3,"file":"use-draft-filters.cjs","names":["useState","useRef","useLatestRef","useCallback","deepEqual","require_use_deep_memo","require_use_latest_ref","react","patchDraft","patch","draft","useDraftFilters","state","setState","initial","initialRef","stateRef","optionsRef","options","equal","a","b","commit","next","set","current","publish","applied","apply","clear"],"sources":["../../src/hooks/use-draft-filters.ts"],"sourcesContent":["import { useCallback, useRef, useState } from \"react\";\n\nimport { deepEqual } from \"./use-deep-memo\";\nimport { useLatestRef } from \"./use-latest-ref\";\n\n/** An edit to the draft: a partial object merged over it, or an updater. */\nexport type DraftFiltersPatch<T> = Partial<T> | ((draft: T) => T);\n\nexport interface UseDraftFiltersOptions<T> {\n    /**\n     * Called with the applied value on every `apply()` and `clear()` — the place to\n     * reset a page number you keep yourself. `usePaginatedQuery` does not need it:\n     * it goes back to page 1 on its own when `applied` changes its `queryKey`.\n     */\n    onApply?: (applied: T) => void;\n    /** Equality behind `isDirty` and the stable `applied`. Default: structural. */\n    isEqual?: (a: T, b: T) => boolean;\n}\n\nexport interface UseDraftFiltersResult<T> {\n    /** What the filter controls edit. Changes on every keystroke. */\n    draft: T;\n    /**\n     * What the query reads. Changes only on `apply()`/`clear()`, and keeps its\n     * reference when the value applied is equal to the current one — safe to put\n     * in a `queryKey`.\n     */\n    applied: T;\n    /** Whether the draft differs from what is applied — enable the apply button on it. */\n    isDirty: boolean;\n    /** Edit the draft, merging a partial object or running an updater. Never applies. */\n    set: (patch: DraftFiltersPatch<T>) => void;\n    /**\n     * Publish the draft. With a patch, merge it into the draft **and** publish the\n     * result in the same call — \"filter by this code\" from a table row.\n     */\n    apply: (patch?: DraftFiltersPatch<T>) => void;\n    /** Reset the draft and the applied value to the initial one, together. */\n    clear: () => void;\n}\n\n/** Both halves, kept in one state so they can never be committed apart. */\ninterface DraftFiltersState<T> {\n    draft: T;\n    applied: T;\n}\n\n/**\n * Resolve a patch against a draft.\n *\n * @param draft - The current draft.\n * @param patch - A partial object to merge, or an updater.\n * @returns The next draft.\n */\nfunction patchDraft<T>(draft: T, patch: DraftFiltersPatch<T>): T {\n    return typeof patch === \"function\" ? patch(draft) : { ...draft, ...patch };\n}\n\n/**\n * Draft vs applied state for a server-side filter: the controls edit a draft\n * freely, and the query only sees it when the user applies (a click, or Enter).\n *\n * A server-side filter cannot react to every keystroke — each character typed in\n * a search box would be a request. Every admin screen then writes the same pair of\n * `useState`s, and gets the same three details wrong:\n *\n * - **Clearing moves both halves.** Resetting only the draft leaves a filtered\n *   list under an empty bar; resetting only the applied value leaves the opposite.\n * - **Applying a value that is not in state yet.** \"Filter by this code\" has to\n *   write the draft and publish it in one gesture; calling `setDraft(x)` and then\n *   publishing `draft` reads the previous value. `apply(patch)` computes the next\n *   draft from a ref that every call keeps current, so it never depends on the\n *   order React flushes state in.\n * - **Resetting the page.** Filtering while on page 7 of a result that now has two\n *   pages shows an empty table. `usePaginatedQuery` handles it by itself when\n *   `applied` is in its `queryKey`; a page kept elsewhere resets in `onApply`.\n *\n * There is no effect in here: applying happens inside the event that asked for it,\n * so one click is one request. `applied` keeps its reference while nothing new is\n * applied, so it can sit in a `queryKey` without a phantom refetch.\n *\n * Like `useState`, the initial value is read on the first render only; `clear()`\n * returns to it.\n *\n * @param initial - The empty filter form: what the screen shows and queries first.\n * @param options - `onApply` and `isEqual`.\n * @returns The draft, the applied value and the gestures between them.\n *\n * @example\n * const filters = useDraftFilters({ code: \"\", level: \"all\" });\n * const logs = usePaginatedQuery({\n *     queryKey: [\"logs\", filters.applied],\n *     queryFn: (params) => api.listLogs({ ...params, ...toQuery(filters.applied) }),\n * });\n * // <Input value={filters.draft.code} onChange={(e) => filters.set({ code: e.target.value })} />\n * // <Button disabled={!filters.isDirty} onClick={() => filters.apply()}>Filtrar</Button>\n */\nexport function useDraftFilters<T extends object>(\n    initial: T,\n    options: UseDraftFiltersOptions<T> = {},\n): UseDraftFiltersResult<T> {\n    const [state, setState] = useState<DraftFiltersState<T>>(() => ({\n        draft: initial,\n        applied: initial,\n    }));\n    const initialRef = useRef<T>(state.applied);\n    const stateRef = useRef<DraftFiltersState<T>>(state);\n    const optionsRef = useLatestRef(options);\n\n    const equal = useCallback(\n        (a: T, b: T): boolean => (optionsRef.current.isEqual ?? deepEqual)(a, b),\n        [optionsRef],\n    );\n\n    const commit = useCallback((next: DraftFiltersState<T>): void => {\n        stateRef.current = next;\n        setState(next);\n    }, []);\n\n    const set = useCallback(\n        (patch: DraftFiltersPatch<T>): void => {\n            const current = stateRef.current;\n            commit({ draft: patchDraft(current.draft, patch), applied: current.applied });\n        },\n        [commit],\n    );\n\n    const publish = useCallback(\n        (next: T): void => {\n            const current = stateRef.current;\n            const applied = equal(next, current.applied) ? current.applied : next;\n            commit({ draft: next, applied });\n            optionsRef.current.onApply?.(applied);\n        },\n        [commit, equal, optionsRef],\n    );\n\n    const apply = useCallback(\n        (patch?: DraftFiltersPatch<T>): void => {\n            const draft = stateRef.current.draft;\n            publish(patch === undefined ? draft : patchDraft(draft, patch));\n        },\n        [publish],\n    );\n\n    const clear = useCallback((): void => publish(initialRef.current), [publish]);\n\n    return {\n        draft: state.draft,\n        applied: state.applied,\n        isDirty: !(options.isEqual ?? deepEqual)(state.draft, state.applied),\n        set,\n        apply,\n        clear,\n    };\n}\n"],"mappings":"A,gGAsDA,SAASQ,EAAc,EAAU,EAAgC,CAC7D,OAAO,OAAOC,GAAU,WAAaA,EAAMC,CAAK,EAAI,CAAE,GAAGA,EAAO,GAAGD,CAAM,CAC7E,CAyCA,SAAgBE,EACZ,EACA,EAAqC,CAAC,EACd,CACxB,GAAM,CAACC,EAAOC,IAAA,EAAYb,EAAAA,SAAAA,MAAsC,CAC5D,MAAOc,EACP,QAASA,CACb,EAAE,EACIC,GAAA,EAAad,EAAAA,OAAAA,CAAUW,EAAM,OAAO,EACpCI,GAAA,EAAWf,EAAAA,OAAAA,CAA6BW,CAAK,EAC7CK,EAAaf,EAAAA,aAAagB,CAAO,EAEjCC,GAAA,EAAQhB,EAAAA,YAAAA,EACT,EAAM,KAAmBc,EAAW,QAAQ,SAAWb,EAAAA,UAAAA,CAAWgB,EAAGC,CAAC,EACvE,CAACJ,CAAU,CACf,EAEMK,GAAA,EAASnB,EAAAA,YAAAA,CAAa,GAAqC,CAC7D,EAAS,QAAUoB,EACnBV,EAASU,CAAI,CACjB,EAAG,CAAC,CAAC,EAECC,GAAA,EAAMrB,EAAAA,YAAAA,CACP,GAAsC,CACnC,IAAMsB,EAAUT,EAAS,QACzBM,EAAO,CAAE,MAAOd,EAAWiB,EAAQ,MAAOhB,CAAK,EAAG,QAASgB,EAAQ,OAAQ,CAAC,CAChF,EACA,CAACH,CAAM,CACX,EAEMI,GAAA,EAAUvB,EAAAA,YAAAA,CACX,GAAkB,CACf,IAAMsB,EAAUT,EAAS,QACnBW,EAAUR,EAAMI,EAAME,EAAQ,OAAO,EAAIA,EAAQ,QAAUF,EACjED,EAAO,CAAE,MAAOC,EAAM,SAAQ,CAAC,EAC/BN,EAAW,QAAQ,UAAUU,CAAO,CACxC,EACA,CAACL,EAAQH,EAAOF,CAAU,CAC9B,EAEMW,GAAA,EAAQzB,EAAAA,YAAAA,CACT,GAAuC,CACpC,IAAMO,EAAQM,EAAS,QAAQ,MAC/BU,EAAQjB,IAAU,IAAA,GAAYC,EAAQF,EAAWE,EAAOD,CAAK,CAAC,CAClE,EACA,CAACiB,CAAO,CACZ,EAEMG,GAAA,EAAQ1B,EAAAA,YAAAA,KAAwBuB,EAAQX,EAAW,OAAO,EAAG,CAACW,CAAO,CAAC,EAE5E,MAAO,CACH,MAAOd,EAAM,MACb,QAASA,EAAM,QACf,QAAS,EAAEM,EAAQ,SAAWd,EAAAA,UAAAA,CAAWQ,EAAM,MAAOA,EAAM,OAAO,EACnE,MACA,QACA,OACJ,CACJ,C"}

package/dist/hooks/use-draft-filters.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-draft-filters.js","names":[],"sources":["../../src/hooks/use-draft-filters.ts"],"sourcesContent":["import { useCallback, useRef, useState } from \"react\";\n\nimport { deepEqual } from \"./use-deep-memo\";\nimport { useLatestRef } from \"./use-latest-ref\";\n\n/** An edit to the draft: a partial object merged over it, or an updater. */\nexport type DraftFiltersPatch<T> = Partial<T> | ((draft: T) => T);\n\nexport interface UseDraftFiltersOptions<T> {\n    /**\n     * Called with the applied value on every `apply()` and `clear()` — the place to\n     * reset a page number you keep yourself. `usePaginatedQuery` does not need it:\n     * it goes back to page 1 on its own when `applied` changes its `queryKey`.\n     */\n    onApply?: (applied: T) => void;\n    /** Equality behind `isDirty` and the stable `applied`. Default: structural. */\n    isEqual?: (a: T, b: T) => boolean;\n}\n\nexport interface UseDraftFiltersResult<T> {\n    /** What the filter controls edit. Changes on every keystroke. */\n    draft: T;\n    /**\n     * What the query reads. Changes only on `apply()`/`clear()`, and keeps its\n     * reference when the value applied is equal to the current one — safe to put\n     * in a `queryKey`.\n     */\n    applied: T;\n    /** Whether the draft differs from what is applied — enable the apply button on it. */\n    isDirty: boolean;\n    /** Edit the draft, merging a partial object or running an updater. Never applies. */\n    set: (patch: DraftFiltersPatch<T>) => void;\n    /**\n     * Publish the draft. With a patch, merge it into the draft **and** publish the\n     * result in the same call — \"filter by this code\" from a table row.\n     */\n    apply: (patch?: DraftFiltersPatch<T>) => void;\n    /** Reset the draft and the applied value to the initial one, together. */\n    clear: () => void;\n}\n\n/** Both halves, kept in one state so they can never be committed apart. */\ninterface DraftFiltersState<T> {\n    draft: T;\n    applied: T;\n}\n\n/**\n * Resolve a patch against a draft.\n *\n * @param draft - The current draft.\n * @param patch - A partial object to merge, or an updater.\n * @returns The next draft.\n */\nfunction patchDraft<T>(draft: T, patch: DraftFiltersPatch<T>): T {\n    return typeof patch === \"function\" ? patch(draft) : { ...draft, ...patch };\n}\n\n/**\n * Draft vs applied state for a server-side filter: the controls edit a draft\n * freely, and the query only sees it when the user applies (a click, or Enter).\n *\n * A server-side filter cannot react to every keystroke — each character typed in\n * a search box would be a request. Every admin screen then writes the same pair of\n * `useState`s, and gets the same three details wrong:\n *\n * - **Clearing moves both halves.** Resetting only the draft leaves a filtered\n *   list under an empty bar; resetting only the applied value leaves the opposite.\n * - **Applying a value that is not in state yet.** \"Filter by this code\" has to\n *   write the draft and publish it in one gesture; calling `setDraft(x)` and then\n *   publishing `draft` reads the previous value. `apply(patch)` computes the next\n *   draft from a ref that every call keeps current, so it never depends on the\n *   order React flushes state in.\n * - **Resetting the page.** Filtering while on page 7 of a result that now has two\n *   pages shows an empty table. `usePaginatedQuery` handles it by itself when\n *   `applied` is in its `queryKey`; a page kept elsewhere resets in `onApply`.\n *\n * There is no effect in here: applying happens inside the event that asked for it,\n * so one click is one request. `applied` keeps its reference while nothing new is\n * applied, so it can sit in a `queryKey` without a phantom refetch.\n *\n * Like `useState`, the initial value is read on the first render only; `clear()`\n * returns to it.\n *\n * @param initial - The empty filter form: what the screen shows and queries first.\n * @param options - `onApply` and `isEqual`.\n * @returns The draft, the applied value and the gestures between them.\n *\n * @example\n * const filters = useDraftFilters({ code: \"\", level: \"all\" });\n * const logs = usePaginatedQuery({\n *     queryKey: [\"logs\", filters.applied],\n *     queryFn: (params) => api.listLogs({ ...params, ...toQuery(filters.applied) }),\n * });\n * // <Input value={filters.draft.code} onChange={(e) => filters.set({ code: e.target.value })} />\n * // <Button disabled={!filters.isDirty} onClick={() => filters.apply()}>Filtrar</Button>\n */\nexport function useDraftFilters<T extends object>(\n    initial: T,\n    options: UseDraftFiltersOptions<T> = {},\n): UseDraftFiltersResult<T> {\n    const [state, setState] = useState<DraftFiltersState<T>>(() => ({\n        draft: initial,\n        applied: initial,\n    }));\n    const initialRef = useRef<T>(state.applied);\n    const stateRef = useRef<DraftFiltersState<T>>(state);\n    const optionsRef = useLatestRef(options);\n\n    const equal = useCallback(\n        (a: T, b: T): boolean => (optionsRef.current.isEqual ?? deepEqual)(a, b),\n        [optionsRef],\n    );\n\n    const commit = useCallback((next: DraftFiltersState<T>): void => {\n        stateRef.current = next;\n        setState(next);\n    }, []);\n\n    const set = useCallback(\n        (patch: DraftFiltersPatch<T>): void => {\n            const current = stateRef.current;\n            commit({ draft: patchDraft(current.draft, patch), applied: current.applied });\n        },\n        [commit],\n    );\n\n    const publish = useCallback(\n        (next: T): void => {\n            const current = stateRef.current;\n            const applied = equal(next, current.applied) ? current.applied : next;\n            commit({ draft: next, applied });\n            optionsRef.current.onApply?.(applied);\n        },\n        [commit, equal, optionsRef],\n    );\n\n    const apply = useCallback(\n        (patch?: DraftFiltersPatch<T>): void => {\n            const draft = stateRef.current.draft;\n            publish(patch === undefined ? draft : patchDraft(draft, patch));\n        },\n        [publish],\n    );\n\n    const clear = useCallback((): void => publish(initialRef.current), [publish]);\n\n    return {\n        draft: state.draft,\n        applied: state.applied,\n        isDirty: !(options.isEqual ?? deepEqual)(state.draft, state.applied),\n        set,\n        apply,\n        clear,\n    };\n}\n"],"mappings":";;;;AAsDA,SAAS,EAAc,GAAU,GAAgC;CAC7D,OAAO,OAAO,KAAU,aAAa,EAAM,CAAK,IAAI;EAAE,GAAG;EAAO,GAAG;CAAM;AAC7E;AAyCA,SAAgB,EACZ,GACA,IAAqC,CAAC,GACd;CACxB,IAAM,CAAC,GAAO,KAAY,SAAsC;EAC5D,OAAO;EACP,SAAS;CACb,EAAE,GACI,IAAa,EAAU,EAAM,OAAO,GACpC,IAAW,EAA6B,CAAK,GAC7C,IAAa,EAAa,CAAO,GAEjC,IAAQ,GACT,GAAM,OAAmB,EAAW,QAAQ,WAAW,EAAA,CAAW,GAAG,CAAC,GACvE,CAAC,CAAU,CACf,GAEM,IAAS,GAAa,MAAqC;EAE7D,AADA,EAAS,UAAU,GACnB,EAAS,CAAI;CACjB,GAAG,CAAC,CAAC,GAEC,IAAM,GACP,MAAsC;EACnC,IAAM,IAAU,EAAS;EACzB,EAAO;GAAE,OAAO,EAAW,EAAQ,OAAO,CAAK;GAAG,SAAS,EAAQ;EAAQ,CAAC;CAChF,GACA,CAAC,CAAM,CACX,GAEM,IAAU,GACX,MAAkB;EACf,IAAM,IAAU,EAAS,SACnB,IAAU,EAAM,GAAM,EAAQ,OAAO,IAAI,EAAQ,UAAU;EAEjE,AADA,EAAO;GAAE,OAAO;GAAM;EAAQ,CAAC,GAC/B,EAAW,QAAQ,UAAU,CAAO;CACxC,GACA;EAAC;EAAQ;EAAO;CAAU,CAC9B,GAEM,IAAQ,GACT,MAAuC;EACpC,IAAM,IAAQ,EAAS,QAAQ;EAC/B,EAAQ,MAAU,KAAA,IAAY,IAAQ,EAAW,GAAO,CAAK,CAAC;CAClE,GACA,CAAC,CAAO,CACZ,GAEM,IAAQ,QAAwB,EAAQ,EAAW,OAAO,GAAG,CAAC,CAAO,CAAC;CAE5E,OAAO;EACH,OAAO,EAAM;EACb,SAAS,EAAM;EACf,SAAS,EAAE,EAAQ,WAAW,EAAA,CAAW,EAAM,OAAO,EAAM,OAAO;EACnE;EACA;EACA;CACJ;AACJ"}
+{"version":3,"file":"use-draft-filters.js","names":["patchDraft","patch","draft","useDraftFilters","state","setState","useState","initial","initialRef","useRef","stateRef","optionsRef","useLatestRef","options","equal","useCallback","deepEqual","a","b","commit","next","set","current","publish","applied","apply","clear"],"sources":["../../src/hooks/use-draft-filters.ts"],"sourcesContent":["import { useCallback, useRef, useState } from \"react\";\n\nimport { deepEqual } from \"./use-deep-memo\";\nimport { useLatestRef } from \"./use-latest-ref\";\n\n/** An edit to the draft: a partial object merged over it, or an updater. */\nexport type DraftFiltersPatch<T> = Partial<T> | ((draft: T) => T);\n\nexport interface UseDraftFiltersOptions<T> {\n    /**\n     * Called with the applied value on every `apply()` and `clear()` — the place to\n     * reset a page number you keep yourself. `usePaginatedQuery` does not need it:\n     * it goes back to page 1 on its own when `applied` changes its `queryKey`.\n     */\n    onApply?: (applied: T) => void;\n    /** Equality behind `isDirty` and the stable `applied`. Default: structural. */\n    isEqual?: (a: T, b: T) => boolean;\n}\n\nexport interface UseDraftFiltersResult<T> {\n    /** What the filter controls edit. Changes on every keystroke. */\n    draft: T;\n    /**\n     * What the query reads. Changes only on `apply()`/`clear()`, and keeps its\n     * reference when the value applied is equal to the current one — safe to put\n     * in a `queryKey`.\n     */\n    applied: T;\n    /** Whether the draft differs from what is applied — enable the apply button on it. */\n    isDirty: boolean;\n    /** Edit the draft, merging a partial object or running an updater. Never applies. */\n    set: (patch: DraftFiltersPatch<T>) => void;\n    /**\n     * Publish the draft. With a patch, merge it into the draft **and** publish the\n     * result in the same call — \"filter by this code\" from a table row.\n     */\n    apply: (patch?: DraftFiltersPatch<T>) => void;\n    /** Reset the draft and the applied value to the initial one, together. */\n    clear: () => void;\n}\n\n/** Both halves, kept in one state so they can never be committed apart. */\ninterface DraftFiltersState<T> {\n    draft: T;\n    applied: T;\n}\n\n/**\n * Resolve a patch against a draft.\n *\n * @param draft - The current draft.\n * @param patch - A partial object to merge, or an updater.\n * @returns The next draft.\n */\nfunction patchDraft<T>(draft: T, patch: DraftFiltersPatch<T>): T {\n    return typeof patch === \"function\" ? patch(draft) : { ...draft, ...patch };\n}\n\n/**\n * Draft vs applied state for a server-side filter: the controls edit a draft\n * freely, and the query only sees it when the user applies (a click, or Enter).\n *\n * A server-side filter cannot react to every keystroke — each character typed in\n * a search box would be a request. Every admin screen then writes the same pair of\n * `useState`s, and gets the same three details wrong:\n *\n * - **Clearing moves both halves.** Resetting only the draft leaves a filtered\n *   list under an empty bar; resetting only the applied value leaves the opposite.\n * - **Applying a value that is not in state yet.** \"Filter by this code\" has to\n *   write the draft and publish it in one gesture; calling `setDraft(x)` and then\n *   publishing `draft` reads the previous value. `apply(patch)` computes the next\n *   draft from a ref that every call keeps current, so it never depends on the\n *   order React flushes state in.\n * - **Resetting the page.** Filtering while on page 7 of a result that now has two\n *   pages shows an empty table. `usePaginatedQuery` handles it by itself when\n *   `applied` is in its `queryKey`; a page kept elsewhere resets in `onApply`.\n *\n * There is no effect in here: applying happens inside the event that asked for it,\n * so one click is one request. `applied` keeps its reference while nothing new is\n * applied, so it can sit in a `queryKey` without a phantom refetch.\n *\n * Like `useState`, the initial value is read on the first render only; `clear()`\n * returns to it.\n *\n * @param initial - The empty filter form: what the screen shows and queries first.\n * @param options - `onApply` and `isEqual`.\n * @returns The draft, the applied value and the gestures between them.\n *\n * @example\n * const filters = useDraftFilters({ code: \"\", level: \"all\" });\n * const logs = usePaginatedQuery({\n *     queryKey: [\"logs\", filters.applied],\n *     queryFn: (params) => api.listLogs({ ...params, ...toQuery(filters.applied) }),\n * });\n * // <Input value={filters.draft.code} onChange={(e) => filters.set({ code: e.target.value })} />\n * // <Button disabled={!filters.isDirty} onClick={() => filters.apply()}>Filtrar</Button>\n */\nexport function useDraftFilters<T extends object>(\n    initial: T,\n    options: UseDraftFiltersOptions<T> = {},\n): UseDraftFiltersResult<T> {\n    const [state, setState] = useState<DraftFiltersState<T>>(() => ({\n        draft: initial,\n        applied: initial,\n    }));\n    const initialRef = useRef<T>(state.applied);\n    const stateRef = useRef<DraftFiltersState<T>>(state);\n    const optionsRef = useLatestRef(options);\n\n    const equal = useCallback(\n        (a: T, b: T): boolean => (optionsRef.current.isEqual ?? deepEqual)(a, b),\n        [optionsRef],\n    );\n\n    const commit = useCallback((next: DraftFiltersState<T>): void => {\n        stateRef.current = next;\n        setState(next);\n    }, []);\n\n    const set = useCallback(\n        (patch: DraftFiltersPatch<T>): void => {\n            const current = stateRef.current;\n            commit({ draft: patchDraft(current.draft, patch), applied: current.applied });\n        },\n        [commit],\n    );\n\n    const publish = useCallback(\n        (next: T): void => {\n            const current = stateRef.current;\n            const applied = equal(next, current.applied) ? current.applied : next;\n            commit({ draft: next, applied });\n            optionsRef.current.onApply?.(applied);\n        },\n        [commit, equal, optionsRef],\n    );\n\n    const apply = useCallback(\n        (patch?: DraftFiltersPatch<T>): void => {\n            const draft = stateRef.current.draft;\n            publish(patch === undefined ? draft : patchDraft(draft, patch));\n        },\n        [publish],\n    );\n\n    const clear = useCallback((): void => publish(initialRef.current), [publish]);\n\n    return {\n        draft: state.draft,\n        applied: state.applied,\n        isDirty: !(options.isEqual ?? deepEqual)(state.draft, state.applied),\n        set,\n        apply,\n        clear,\n    };\n}\n"],"mappings":";;;;AAsDA,SAASA,EAAc,GAAU,GAAgC;CAC7D,OAAO,OAAOC,KAAU,aAAaA,EAAMC,CAAK,IAAI;EAAE,GAAGA;EAAO,GAAGD;CAAM;AAC7E;AAyCA,SAAgBE,EACZ,GACA,IAAqC,CAAC,GACd;CACxB,IAAM,CAACC,GAAOC,KAAYC,SAAsC;EAC5D,OAAOC;EACP,SAASA;CACb,EAAE,GACIC,IAAaC,EAAUL,EAAM,OAAO,GACpCM,IAAWD,EAA6BL,CAAK,GAC7CO,IAAaC,EAAaC,CAAO,GAEjCC,IAAQC,GACT,GAAM,OAAmBJ,EAAW,QAAQ,WAAWK,EAAA,CAAWC,GAAGC,CAAC,GACvE,CAACP,CAAU,CACf,GAEMQ,IAASJ,GAAa,MAAqC;EAE7D,AADA,EAAS,UAAUK,GACnBf,EAASe,CAAI;CACjB,GAAG,CAAC,CAAC,GAECC,IAAMN,GACP,MAAsC;EACnC,IAAMO,IAAUZ,EAAS;EACzB,EAAO;GAAE,OAAOV,EAAWsB,EAAQ,OAAOrB,CAAK;GAAG,SAASqB,EAAQ;EAAQ,CAAC;CAChF,GACA,CAACH,CAAM,CACX,GAEMI,IAAUR,GACX,MAAkB;EACf,IAAMO,IAAUZ,EAAS,SACnBc,IAAUV,EAAMM,GAAME,EAAQ,OAAO,IAAIA,EAAQ,UAAUF;EAEjE,AADAD,EAAO;GAAE,OAAOC;GAAM;EAAQ,CAAC,GAC/BT,EAAW,QAAQ,UAAUa,CAAO;CACxC,GACA;EAACL;EAAQL;EAAOH;CAAU,CAC9B,GAEMc,IAAQV,GACT,MAAuC;EACpC,IAAMb,IAAQQ,EAAS,QAAQ;EAC/B,EAAQT,MAAU,KAAA,IAAYC,IAAQF,EAAWE,GAAOD,CAAK,CAAC;CAClE,GACA,CAACsB,CAAO,CACZ,GAEMG,IAAQX,QAAwBQ,EAAQf,EAAW,OAAO,GAAG,CAACe,CAAO,CAAC;CAE5E,OAAO;EACH,OAAOnB,EAAM;EACb,SAASA,EAAM;EACf,SAAS,EAAES,EAAQ,WAAWG,EAAA,CAAWZ,EAAM,OAAOA,EAAM,OAAO;EACnE;EACA;EACA;CACJ;AACJ"}

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 } 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"}
+{"version":3,"file":"use-event-listener.cjs","names":["useLatestRef","require_use_latest_ref","react","useEventListener","handlerRef","handler","resolvedTarget","target","listener","event","eventName","options"],"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":"A,+DAqCA,SAAgBG,EACZ,EACA,EACA,EACA,EACI,CACJ,IAAMC,EAAaJ,EAAAA,aAAaK,CAAO,GAEvC,EAAAH,EAAA,UAAA,KAAgB,CACZ,IAAMI,EACFC,IAAW,IAAA,GACL,OAAO,OAAW,IACd,KACA,OACJ,YAAcA,EACVA,EAA2C,SAAW,KACvDA,EAEb,GAAI,CAACD,GAAgB,iBAAkB,OAEvC,IAAME,EAA2B,GAAUJ,EAAW,QAAQK,CAAK,EAEnE,OADAH,EAAe,iBAAiBI,EAAWF,EAAUG,CAAO,MAC/CL,EAAe,oBAAoBI,EAAWF,EAAUG,CAAO,CAChF,EAAG,CAACD,EAAWH,EAAQI,EAASP,CAAU,CAAC,CAC/C,C"}

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 } 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"}
+{"version":3,"file":"use-event-listener.js","names":["useEventListener","handlerRef","useLatestRef","handler","resolvedTarget","target","listener","event","eventName","options"],"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,SAAgBA,EACZ,GACA,GACA,GACA,GACI;CACJ,IAAMC,IAAaC,EAAaC,CAAO;CAEvC,QAAgB;EACZ,IAAMC,IACFC,MAAW,KAAA,IACL,OAAO,SAAW,MACd,OACA,SACJ,aAAcA,IACVA,EAA2C,WAAW,OACvDA;EAEb,IAAI,CAACD,GAAgB,kBAAkB;EAEvC,IAAME,KAA2B,MAAUL,EAAW,QAAQM,CAAK;EAEnE,OADAH,EAAe,iBAAiBI,GAAWF,GAAUG,CAAO,SAC/CL,EAAe,oBAAoBI,GAAWF,GAAUG,CAAO;CAChF,GAAG;EAACD;EAAWH;EAAQI;EAASR;CAAU,CAAC;AAC/C"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-favicon.cjs","names":[],"sources":["../../src/hooks/use-favicon.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\n/**\n * Swap the document favicon by updating the `<link rel=\"icon\">` href.\n * Creates the link element when it is missing. SSR-safe — no-op when\n * `document` is unavailable.\n *\n * @param href - the favicon URL to apply.\n */\nexport function useFavicon(href: string): void {\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n        let link = document.querySelector<HTMLLinkElement>('link[rel=\"icon\"]');\n        if (!link) {\n            link = document.createElement(\"link\");\n            link.rel = \"icon\";\n            document.head.appendChild(link);\n        }\n        link.href = href;\n    }, [href]);\n}\n"],"mappings":"uBASA,SAAgB,EAAW,EAAoB,EAC3C,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,OAAO,SAAa,IAAa,OACrC,IAAI,EAAO,SAAS,cAA+B,kBAAkB,EAChE,IACD,EAAO,SAAS,cAAc,MAAM,EACpC,EAAK,IAAM,OACX,SAAS,KAAK,YAAY,CAAI,GAElC,EAAK,KAAO,CAChB,EAAG,CAAC,CAAI,CAAC,CACb"}
+{"version":3,"file":"use-favicon.cjs","names":["react","useFavicon","link","href"],"sources":["../../src/hooks/use-favicon.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\n/**\n * Swap the document favicon by updating the `<link rel=\"icon\">` href.\n * Creates the link element when it is missing. SSR-safe — no-op when\n * `document` is unavailable.\n *\n * @param href - the favicon URL to apply.\n */\nexport function useFavicon(href: string): void {\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n        let link = document.querySelector<HTMLLinkElement>('link[rel=\"icon\"]');\n        if (!link) {\n            link = document.createElement(\"link\");\n            link.rel = \"icon\";\n            document.head.appendChild(link);\n        }\n        link.href = href;\n    }, [href]);\n}\n"],"mappings":"A,uBASA,SAAgBC,EAAW,EAAoB,EAC3C,EAAAD,EAAA,UAAA,KAAgB,CACZ,GAAI,OAAO,SAAa,IAAa,OACrC,IAAIE,EAAO,SAAS,cAA+B,kBAAkB,EAChEA,IACD,EAAO,SAAS,cAAc,MAAM,EACpC,EAAK,IAAM,OACX,SAAS,KAAK,YAAYA,CAAI,GAElC,EAAK,KAAOC,CAChB,EAAG,CAACA,CAAI,CAAC,CACb,C"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-favicon.js","names":[],"sources":["../../src/hooks/use-favicon.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\n/**\n * Swap the document favicon by updating the `<link rel=\"icon\">` href.\n * Creates the link element when it is missing. SSR-safe — no-op when\n * `document` is unavailable.\n *\n * @param href - the favicon URL to apply.\n */\nexport function useFavicon(href: string): void {\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n        let link = document.querySelector<HTMLLinkElement>('link[rel=\"icon\"]');\n        if (!link) {\n            link = document.createElement(\"link\");\n            link.rel = \"icon\";\n            document.head.appendChild(link);\n        }\n        link.href = href;\n    }, [href]);\n}\n"],"mappings":";;AASA,SAAgB,EAAW,GAAoB;CAC3C,QAAgB;EACZ,IAAI,OAAO,WAAa,KAAa;EACrC,IAAI,IAAO,SAAS,cAA+B,oBAAkB;EAMrE,AALK,MACD,IAAO,SAAS,cAAc,MAAM,GACpC,EAAK,MAAM,QACX,SAAS,KAAK,YAAY,CAAI,IAElC,EAAK,OAAO;CAChB,GAAG,CAAC,CAAI,CAAC;AACb"}
+{"version":3,"file":"use-favicon.js","names":["useFavicon","link","href"],"sources":["../../src/hooks/use-favicon.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\n/**\n * Swap the document favicon by updating the `<link rel=\"icon\">` href.\n * Creates the link element when it is missing. SSR-safe — no-op when\n * `document` is unavailable.\n *\n * @param href - the favicon URL to apply.\n */\nexport function useFavicon(href: string): void {\n    useEffect(() => {\n        if (typeof document === \"undefined\") return;\n        let link = document.querySelector<HTMLLinkElement>('link[rel=\"icon\"]');\n        if (!link) {\n            link = document.createElement(\"link\");\n            link.rel = \"icon\";\n            document.head.appendChild(link);\n        }\n        link.href = href;\n    }, [href]);\n}\n"],"mappings":";;AASA,SAAgBA,EAAW,GAAoB;CAC3C,QAAgB;EACZ,IAAI,OAAO,WAAa,KAAa;EACrC,IAAIC,IAAO,SAAS,cAA+B,oBAAkB;EAMrE,AALKA,MACD,IAAO,SAAS,cAAc,MAAM,GACpC,EAAK,MAAM,QACX,SAAS,KAAK,YAAYA,CAAI,IAElC,EAAK,OAAOC;CAChB,GAAG,CAACA,CAAI,CAAC;AACb"}

package/dist/hooks/use-focus-trap.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-focus-trap.cjs","names":[],"sources":["../../src/hooks/use-focus-trap.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\nimport { tabRegion, tabSequence } from \"./tab-sequence\";\n\nexport { FOCUSABLE_SELECTOR } from \"./tab-sequence\";\n\n/** One armed trap; the identity is what the stack compares. */\ninterface TrapEntry {\n    container: HTMLElement;\n}\n\nconst stack: TrapEntry[] = [];\n\n/**\n * Trap keyboard focus inside `containerRef` while `active` is true.\n *\n * - **On activation** focus moves to the first tab stop, or to the container\n *   itself when it has none (give it `tabIndex={-1}`). Content that already put\n *   focus inside — an `autoFocus` input — is left where it is.\n * - **`Tab` / `Shift+Tab`** wrap between the first and the last stop, and pull\n *   focus back in when it sits outside.\n * - **On release** focus returns to the element that held it when the trap\n *   armed. That element is read during the render that arms the trap, before\n *   React commits: an `autoFocus` child takes focus in the commit, ahead of any\n *   effect, and reading it there would \"restore\" to the child that is about to\n *   unmount — which dropped focus on `body` in `Command`.\n *\n * **Portalled panels stay reachable.** A `Popover` or `HoverCard` opened from\n * inside the container renders at the end of `body`, outside it. Those panels\n * register themselves (see `usePortalTabOrder`), and the trap treats them as\n * part of the container, spliced right after their trigger. A `Tab` another\n * layer already consumed is not moved again, unless it moved focus out of the\n * container and its panels — the portal bridge leaving the last panel stop for\n * whatever follows the trap in the page.\n *\n * **Traps stack.** Only the most recent active trap handles `Tab`, so a modal\n * opened over another owns the keyboard until it closes, and then hands focus\n * back to the element it was opened from, inside the one below.\n *\n * The listener is on `document` in the bubble phase, after React's own\n * handlers: a menu that closes on `Tab` and returns focus to its trigger has\n * already done so when the trap looks at where focus is.\n *\n * @param containerRef - The element focus is confined to.\n * @param active - Whether the trap is armed.\n * @returns Nothing.\n */\nexport function useFocusTrap(containerRef: RefObject<HTMLElement | null>, active: boolean): void {\n    const [armed, setArmed] = useState(false);\n    const [opener, setOpener] = useState<HTMLElement | null>(null);\n    if (active !== armed) {\n        setArmed(active);\n        if (active && typeof document !== \"undefined\") {\n            setOpener(document.activeElement as HTMLElement | null);\n        }\n    }\n\n    useEffect(() => {\n        if (!active) return;\n        const container = containerRef.current;\n        if (!container) return;\n\n        const entry: TrapEntry = { container };\n        stack.push(entry);\n\n        if (!container.contains(document.activeElement)) {\n            (tabSequence(container)[0] ?? container).focus();\n        }\n\n        const handleKeydown = (event: KeyboardEvent): void => {\n            if (event.key !== \"Tab\" || stack.at(-1) !== entry) return;\n            const sequence = tabSequence(container);\n            const first = sequence[0];\n            const last = sequence.at(-1);\n            const current = document.activeElement as HTMLElement | null;\n            const inside =\n                current !== null && tabRegion(container).some((root) => root.contains(current));\n\n            if (event.defaultPrevented) {\n                if (!inside) ((event.shiftKey ? last : first) ?? container).focus();\n                return;\n            }\n            if (!first || !last) {\n                event.preventDefault();\n                container.focus();\n                return;\n            }\n            const atEnd = event.shiftKey\n                ? current === first || current === container\n                : current === last;\n            if (!inside || atEnd) {\n                event.preventDefault();\n                (event.shiftKey ? last : first).focus();\n            }\n        };\n\n        document.addEventListener(\"keydown\", handleKeydown);\n        return () => {\n            document.removeEventListener(\"keydown\", handleKeydown);\n            stack.splice(stack.indexOf(entry), 1);\n            if (opener?.isConnected) opener.focus();\n        };\n    }, [containerRef, active, opener]);\n}\n"],"mappings":"6DAWA,IAAM,EAAqB,CAAC,EAoC5B,SAAgB,EAAa,EAA6C,EAAuB,CAC7F,GAAM,CAAC,EAAO,IAAA,EAAY,EAAA,SAAA,CAAS,EAAK,EAClC,CAAC,EAAQ,IAAA,EAAa,EAAA,SAAA,CAA6B,IAAI,EACzD,IAAW,IACX,EAAS,CAAM,EACX,GAAU,OAAO,SAAa,KAC9B,EAAU,SAAS,aAAmC,IAI9D,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,CAAC,EAAQ,OACb,IAAM,EAAY,EAAa,QAC/B,GAAI,CAAC,EAAW,OAEhB,IAAM,EAAmB,CAAE,WAAU,EACrC,EAAM,KAAK,CAAK,EAEX,EAAU,SAAS,SAAS,aAAa,IACzC,EAAA,YAAY,CAAS,CAAC,CAAC,IAAM,EAAA,CAAW,MAAM,EAGnD,IAAM,EAAiB,GAA+B,CAClD,GAAI,EAAM,MAAQ,OAAS,EAAM,GAAG,EAAE,IAAM,EAAO,OACnD,IAAM,EAAW,EAAA,YAAY,CAAS,EAChC,EAAQ,EAAS,GACjB,EAAO,EAAS,GAAG,EAAE,EACrB,EAAU,SAAS,cACnB,EACF,IAAY,MAAQ,EAAA,UAAU,CAAS,CAAC,CAAC,KAAM,GAAS,EAAK,SAAS,CAAO,CAAC,EAElF,GAAI,EAAM,iBAAkB,CACnB,KAAU,EAAM,SAAW,EAAO,IAAU,EAAA,CAAW,MAAM,EAClE,MACJ,CACA,GAAI,CAAC,GAAS,CAAC,EAAM,CACjB,EAAM,eAAe,EACrB,EAAU,MAAM,EAChB,MACJ,CACA,IAAM,EAAQ,EAAM,SACd,IAAY,GAAS,IAAY,EACjC,IAAY,GACd,CAAC,GAAU,KACX,EAAM,eAAe,GACpB,EAAM,SAAW,EAAO,EAAA,CAAO,MAAM,EAE9C,EAGA,OADA,SAAS,iBAAiB,UAAW,CAAa,MACrC,CACT,SAAS,oBAAoB,UAAW,CAAa,EACrD,EAAM,OAAO,EAAM,QAAQ,CAAK,EAAG,CAAC,EAChC,GAAQ,aAAa,EAAO,MAAM,CAC1C,CACJ,EAAG,CAAC,EAAc,EAAQ,CAAM,CAAC,CACrC"}
+{"version":3,"file":"use-focus-trap.cjs","names":["useState","tabSequence","tabRegion","require_tab_sequence","react","stack","useFocusTrap","armed","setArmed","opener","setOpener","active","container","containerRef","entry","handleKeydown","event","sequence","first","last","current","inside","root","atEnd"],"sources":["../../src/hooks/use-focus-trap.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\nimport { tabRegion, tabSequence } from \"./tab-sequence\";\n\nexport { FOCUSABLE_SELECTOR } from \"./tab-sequence\";\n\n/** One armed trap; the identity is what the stack compares. */\ninterface TrapEntry {\n    container: HTMLElement;\n}\n\nconst stack: TrapEntry[] = [];\n\n/**\n * Trap keyboard focus inside `containerRef` while `active` is true.\n *\n * - **On activation** focus moves to the first tab stop, or to the container\n *   itself when it has none (give it `tabIndex={-1}`). Content that already put\n *   focus inside — an `autoFocus` input — is left where it is.\n * - **`Tab` / `Shift+Tab`** wrap between the first and the last stop, and pull\n *   focus back in when it sits outside.\n * - **On release** focus returns to the element that held it when the trap\n *   armed. That element is read during the render that arms the trap, before\n *   React commits: an `autoFocus` child takes focus in the commit, ahead of any\n *   effect, and reading it there would \"restore\" to the child that is about to\n *   unmount — which dropped focus on `body` in `Command`.\n *\n * **Portalled panels stay reachable.** A `Popover` or `HoverCard` opened from\n * inside the container renders at the end of `body`, outside it. Those panels\n * register themselves (see `usePortalTabOrder`), and the trap treats them as\n * part of the container, spliced right after their trigger. A `Tab` another\n * layer already consumed is not moved again, unless it moved focus out of the\n * container and its panels — the portal bridge leaving the last panel stop for\n * whatever follows the trap in the page.\n *\n * **Traps stack.** Only the most recent active trap handles `Tab`, so a modal\n * opened over another owns the keyboard until it closes, and then hands focus\n * back to the element it was opened from, inside the one below.\n *\n * The listener is on `document` in the bubble phase, after React's own\n * handlers: a menu that closes on `Tab` and returns focus to its trigger has\n * already done so when the trap looks at where focus is.\n *\n * @param containerRef - The element focus is confined to.\n * @param active - Whether the trap is armed.\n * @returns Nothing.\n */\nexport function useFocusTrap(containerRef: RefObject<HTMLElement | null>, active: boolean): void {\n    const [armed, setArmed] = useState(false);\n    const [opener, setOpener] = useState<HTMLElement | null>(null);\n    if (active !== armed) {\n        setArmed(active);\n        if (active && typeof document !== \"undefined\") {\n            setOpener(document.activeElement as HTMLElement | null);\n        }\n    }\n\n    useEffect(() => {\n        if (!active) return;\n        const container = containerRef.current;\n        if (!container) return;\n\n        const entry: TrapEntry = { container };\n        stack.push(entry);\n\n        if (!container.contains(document.activeElement)) {\n            (tabSequence(container)[0] ?? container).focus();\n        }\n\n        const handleKeydown = (event: KeyboardEvent): void => {\n            if (event.key !== \"Tab\" || stack.at(-1) !== entry) return;\n            const sequence = tabSequence(container);\n            const first = sequence[0];\n            const last = sequence.at(-1);\n            const current = document.activeElement as HTMLElement | null;\n            const inside =\n                current !== null && tabRegion(container).some((root) => root.contains(current));\n\n            if (event.defaultPrevented) {\n                if (!inside) ((event.shiftKey ? last : first) ?? container).focus();\n                return;\n            }\n            if (!first || !last) {\n                event.preventDefault();\n                container.focus();\n                return;\n            }\n            const atEnd = event.shiftKey\n                ? current === first || current === container\n                : current === last;\n            if (!inside || atEnd) {\n                event.preventDefault();\n                (event.shiftKey ? last : first).focus();\n            }\n        };\n\n        document.addEventListener(\"keydown\", handleKeydown);\n        return () => {\n            document.removeEventListener(\"keydown\", handleKeydown);\n            stack.splice(stack.indexOf(entry), 1);\n            if (opener?.isConnected) opener.focus();\n        };\n    }, [containerRef, active, opener]);\n}\n"],"mappings":"A,6DAWA,IAAMK,EAAqB,CAAC,EAoC5B,SAAgBC,EAAa,EAA6C,EAAuB,CAC7F,GAAM,CAACC,EAAOC,IAAA,EAAYR,EAAAA,SAAAA,CAAS,EAAK,EAClC,CAACS,EAAQC,IAAA,EAAaV,EAAAA,SAAAA,CAA6B,IAAI,EACzDW,IAAWJ,IACXC,EAASG,CAAM,EACXA,GAAU,OAAO,SAAa,KAC9BD,EAAU,SAAS,aAAmC,IAI9D,EAAAN,EAAA,UAAA,KAAgB,CACZ,GAAI,CAACO,EAAQ,OACb,IAAMC,EAAYC,EAAa,QAC/B,GAAI,CAACD,EAAW,OAEhB,IAAME,EAAmB,CAAE,WAAU,EACrCT,EAAM,KAAKS,CAAK,EAEXF,EAAU,SAAS,SAAS,aAAa,IACzCX,EAAAA,YAAYW,CAAS,CAAC,CAAC,IAAMA,EAAA,CAAW,MAAM,EAGnD,IAAMG,EAAiB,GAA+B,CAClD,GAAIC,EAAM,MAAQ,OAASX,EAAM,GAAG,EAAE,IAAMS,EAAO,OACnD,IAAMG,EAAWhB,EAAAA,YAAYW,CAAS,EAChCM,EAAQD,EAAS,GACjBE,EAAOF,EAAS,GAAG,EAAE,EACrBG,EAAU,SAAS,cACnBC,EACFD,IAAY,MAAQlB,EAAAA,UAAUU,CAAS,CAAC,CAAC,KAAM,GAASU,EAAK,SAASF,CAAO,CAAC,EAElF,GAAIJ,EAAM,iBAAkB,CACnBK,KAAUL,EAAM,SAAWG,EAAOD,IAAUN,EAAA,CAAW,MAAM,EAClE,MACJ,CACA,GAAI,CAACM,GAAS,CAACC,EAAM,CACjBH,EAAM,eAAe,EACrBJ,EAAU,MAAM,EAChB,MACJ,CACA,IAAMW,EAAQP,EAAM,SACdI,IAAYF,GAASE,IAAYR,EACjCQ,IAAYD,GACd,CAACE,GAAUE,KACXP,EAAM,eAAe,GACpBA,EAAM,SAAWG,EAAOD,EAAA,CAAO,MAAM,EAE9C,EAGA,OADA,SAAS,iBAAiB,UAAWH,CAAa,MACrC,CACT,SAAS,oBAAoB,UAAWA,CAAa,EACrDV,EAAM,OAAOA,EAAM,QAAQS,CAAK,EAAG,CAAC,EAChCL,GAAQ,aAAaA,EAAO,MAAM,CAC1C,CACJ,EAAG,CAACI,EAAcF,EAAQF,CAAM,CAAC,CACrC,C"}

package/dist/hooks/use-focus-trap.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-focus-trap.js","names":[],"sources":["../../src/hooks/use-focus-trap.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\nimport { tabRegion, tabSequence } from \"./tab-sequence\";\n\nexport { FOCUSABLE_SELECTOR } from \"./tab-sequence\";\n\n/** One armed trap; the identity is what the stack compares. */\ninterface TrapEntry {\n    container: HTMLElement;\n}\n\nconst stack: TrapEntry[] = [];\n\n/**\n * Trap keyboard focus inside `containerRef` while `active` is true.\n *\n * - **On activation** focus moves to the first tab stop, or to the container\n *   itself when it has none (give it `tabIndex={-1}`). Content that already put\n *   focus inside — an `autoFocus` input — is left where it is.\n * - **`Tab` / `Shift+Tab`** wrap between the first and the last stop, and pull\n *   focus back in when it sits outside.\n * - **On release** focus returns to the element that held it when the trap\n *   armed. That element is read during the render that arms the trap, before\n *   React commits: an `autoFocus` child takes focus in the commit, ahead of any\n *   effect, and reading it there would \"restore\" to the child that is about to\n *   unmount — which dropped focus on `body` in `Command`.\n *\n * **Portalled panels stay reachable.** A `Popover` or `HoverCard` opened from\n * inside the container renders at the end of `body`, outside it. Those panels\n * register themselves (see `usePortalTabOrder`), and the trap treats them as\n * part of the container, spliced right after their trigger. A `Tab` another\n * layer already consumed is not moved again, unless it moved focus out of the\n * container and its panels — the portal bridge leaving the last panel stop for\n * whatever follows the trap in the page.\n *\n * **Traps stack.** Only the most recent active trap handles `Tab`, so a modal\n * opened over another owns the keyboard until it closes, and then hands focus\n * back to the element it was opened from, inside the one below.\n *\n * The listener is on `document` in the bubble phase, after React's own\n * handlers: a menu that closes on `Tab` and returns focus to its trigger has\n * already done so when the trap looks at where focus is.\n *\n * @param containerRef - The element focus is confined to.\n * @param active - Whether the trap is armed.\n * @returns Nothing.\n */\nexport function useFocusTrap(containerRef: RefObject<HTMLElement | null>, active: boolean): void {\n    const [armed, setArmed] = useState(false);\n    const [opener, setOpener] = useState<HTMLElement | null>(null);\n    if (active !== armed) {\n        setArmed(active);\n        if (active && typeof document !== \"undefined\") {\n            setOpener(document.activeElement as HTMLElement | null);\n        }\n    }\n\n    useEffect(() => {\n        if (!active) return;\n        const container = containerRef.current;\n        if (!container) return;\n\n        const entry: TrapEntry = { container };\n        stack.push(entry);\n\n        if (!container.contains(document.activeElement)) {\n            (tabSequence(container)[0] ?? container).focus();\n        }\n\n        const handleKeydown = (event: KeyboardEvent): void => {\n            if (event.key !== \"Tab\" || stack.at(-1) !== entry) return;\n            const sequence = tabSequence(container);\n            const first = sequence[0];\n            const last = sequence.at(-1);\n            const current = document.activeElement as HTMLElement | null;\n            const inside =\n                current !== null && tabRegion(container).some((root) => root.contains(current));\n\n            if (event.defaultPrevented) {\n                if (!inside) ((event.shiftKey ? last : first) ?? container).focus();\n                return;\n            }\n            if (!first || !last) {\n                event.preventDefault();\n                container.focus();\n                return;\n            }\n            const atEnd = event.shiftKey\n                ? current === first || current === container\n                : current === last;\n            if (!inside || atEnd) {\n                event.preventDefault();\n                (event.shiftKey ? last : first).focus();\n            }\n        };\n\n        document.addEventListener(\"keydown\", handleKeydown);\n        return () => {\n            document.removeEventListener(\"keydown\", handleKeydown);\n            stack.splice(stack.indexOf(entry), 1);\n            if (opener?.isConnected) opener.focus();\n        };\n    }, [containerRef, active, opener]);\n}\n"],"mappings":";;;AAWA,IAAM,IAAqB,CAAC;AAoC5B,SAAgB,EAAa,GAA6C,GAAuB;CAC7F,IAAM,CAAC,GAAO,KAAY,EAAS,EAAK,GAClC,CAAC,GAAQ,KAAa,EAA6B,IAAI;CAQ7D,AAPI,MAAW,MACX,EAAS,CAAM,GACX,KAAU,OAAO,WAAa,OAC9B,EAAU,SAAS,aAAmC,IAI9D,QAAgB;EACZ,IAAI,CAAC,GAAQ;EACb,IAAM,IAAY,EAAa;EAC/B,IAAI,CAAC,GAAW;EAEhB,IAAM,IAAmB,EAAE,aAAU;EAGrC,AAFA,EAAM,KAAK,CAAK,GAEX,EAAU,SAAS,SAAS,aAAa,MACzC,EAAY,CAAS,CAAC,CAAC,MAAM,EAAA,CAAW,MAAM;EAGnD,IAAM,KAAiB,MAA+B;GAClD,IAAI,EAAM,QAAQ,SAAS,EAAM,GAAG,EAAE,MAAM,GAAO;GACnD,IAAM,IAAW,EAAY,CAAS,GAChC,IAAQ,EAAS,IACjB,IAAO,EAAS,GAAG,EAAE,GACrB,IAAU,SAAS,eACnB,IACF,MAAY,QAAQ,EAAU,CAAS,CAAC,CAAC,MAAM,MAAS,EAAK,SAAS,CAAO,CAAC;GAElF,IAAI,EAAM,kBAAkB;IACxB,AAAK,OAAU,EAAM,WAAW,IAAO,MAAU,EAAA,CAAW,MAAM;IAClE;GACJ;GACA,IAAI,CAAC,KAAS,CAAC,GAAM;IAEjB,AADA,EAAM,eAAe,GACrB,EAAU,MAAM;IAChB;GACJ;GACA,IAAM,IAAQ,EAAM,WACd,MAAY,KAAS,MAAY,IACjC,MAAY;GAClB,CAAI,CAAC,KAAU,OACX,EAAM,eAAe,IACpB,EAAM,WAAW,IAAO,EAAA,CAAO,MAAM;EAE9C;EAGA,OADA,SAAS,iBAAiB,WAAW,CAAa,SACrC;GAGT,AAFA,SAAS,oBAAoB,WAAW,CAAa,GACrD,EAAM,OAAO,EAAM,QAAQ,CAAK,GAAG,CAAC,GAChC,GAAQ,eAAa,EAAO,MAAM;EAC1C;CACJ,GAAG;EAAC;EAAc;EAAQ;CAAM,CAAC;AACrC"}
+{"version":3,"file":"use-focus-trap.js","names":["stack","useFocusTrap","armed","setArmed","useState","opener","setOpener","active","useEffect","container","containerRef","entry","tabSequence","handleKeydown","event","sequence","first","last","current","inside","tabRegion","root","atEnd"],"sources":["../../src/hooks/use-focus-trap.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\nimport { tabRegion, tabSequence } from \"./tab-sequence\";\n\nexport { FOCUSABLE_SELECTOR } from \"./tab-sequence\";\n\n/** One armed trap; the identity is what the stack compares. */\ninterface TrapEntry {\n    container: HTMLElement;\n}\n\nconst stack: TrapEntry[] = [];\n\n/**\n * Trap keyboard focus inside `containerRef` while `active` is true.\n *\n * - **On activation** focus moves to the first tab stop, or to the container\n *   itself when it has none (give it `tabIndex={-1}`). Content that already put\n *   focus inside — an `autoFocus` input — is left where it is.\n * - **`Tab` / `Shift+Tab`** wrap between the first and the last stop, and pull\n *   focus back in when it sits outside.\n * - **On release** focus returns to the element that held it when the trap\n *   armed. That element is read during the render that arms the trap, before\n *   React commits: an `autoFocus` child takes focus in the commit, ahead of any\n *   effect, and reading it there would \"restore\" to the child that is about to\n *   unmount — which dropped focus on `body` in `Command`.\n *\n * **Portalled panels stay reachable.** A `Popover` or `HoverCard` opened from\n * inside the container renders at the end of `body`, outside it. Those panels\n * register themselves (see `usePortalTabOrder`), and the trap treats them as\n * part of the container, spliced right after their trigger. A `Tab` another\n * layer already consumed is not moved again, unless it moved focus out of the\n * container and its panels — the portal bridge leaving the last panel stop for\n * whatever follows the trap in the page.\n *\n * **Traps stack.** Only the most recent active trap handles `Tab`, so a modal\n * opened over another owns the keyboard until it closes, and then hands focus\n * back to the element it was opened from, inside the one below.\n *\n * The listener is on `document` in the bubble phase, after React's own\n * handlers: a menu that closes on `Tab` and returns focus to its trigger has\n * already done so when the trap looks at where focus is.\n *\n * @param containerRef - The element focus is confined to.\n * @param active - Whether the trap is armed.\n * @returns Nothing.\n */\nexport function useFocusTrap(containerRef: RefObject<HTMLElement | null>, active: boolean): void {\n    const [armed, setArmed] = useState(false);\n    const [opener, setOpener] = useState<HTMLElement | null>(null);\n    if (active !== armed) {\n        setArmed(active);\n        if (active && typeof document !== \"undefined\") {\n            setOpener(document.activeElement as HTMLElement | null);\n        }\n    }\n\n    useEffect(() => {\n        if (!active) return;\n        const container = containerRef.current;\n        if (!container) return;\n\n        const entry: TrapEntry = { container };\n        stack.push(entry);\n\n        if (!container.contains(document.activeElement)) {\n            (tabSequence(container)[0] ?? container).focus();\n        }\n\n        const handleKeydown = (event: KeyboardEvent): void => {\n            if (event.key !== \"Tab\" || stack.at(-1) !== entry) return;\n            const sequence = tabSequence(container);\n            const first = sequence[0];\n            const last = sequence.at(-1);\n            const current = document.activeElement as HTMLElement | null;\n            const inside =\n                current !== null && tabRegion(container).some((root) => root.contains(current));\n\n            if (event.defaultPrevented) {\n                if (!inside) ((event.shiftKey ? last : first) ?? container).focus();\n                return;\n            }\n            if (!first || !last) {\n                event.preventDefault();\n                container.focus();\n                return;\n            }\n            const atEnd = event.shiftKey\n                ? current === first || current === container\n                : current === last;\n            if (!inside || atEnd) {\n                event.preventDefault();\n                (event.shiftKey ? last : first).focus();\n            }\n        };\n\n        document.addEventListener(\"keydown\", handleKeydown);\n        return () => {\n            document.removeEventListener(\"keydown\", handleKeydown);\n            stack.splice(stack.indexOf(entry), 1);\n            if (opener?.isConnected) opener.focus();\n        };\n    }, [containerRef, active, opener]);\n}\n"],"mappings":";;;AAWA,IAAMA,IAAqB,CAAC;AAoC5B,SAAgBC,EAAa,GAA6C,GAAuB;CAC7F,IAAM,CAACC,GAAOC,KAAYC,EAAS,EAAK,GAClC,CAACC,GAAQC,KAAaF,EAA6B,IAAI;CAQ7D,AAPIG,MAAWL,MACXC,EAASI,CAAM,GACXA,KAAU,OAAO,WAAa,OAC9BD,EAAU,SAAS,aAAmC,IAI9DE,QAAgB;EACZ,IAAI,CAACD,GAAQ;EACb,IAAME,IAAYC,EAAa;EAC/B,IAAI,CAACD,GAAW;EAEhB,IAAME,IAAmB,EAAE,aAAU;EAGrC,AAFAX,EAAM,KAAKW,CAAK,GAEXF,EAAU,SAAS,SAAS,aAAa,MACzCG,EAAYH,CAAS,CAAC,CAAC,MAAMA,EAAA,CAAW,MAAM;EAGnD,IAAMI,KAAiB,MAA+B;GAClD,IAAIC,EAAM,QAAQ,SAASd,EAAM,GAAG,EAAE,MAAMW,GAAO;GACnD,IAAMI,IAAWH,EAAYH,CAAS,GAChCO,IAAQD,EAAS,IACjBE,IAAOF,EAAS,GAAG,EAAE,GACrBG,IAAU,SAAS,eACnBC,IACFD,MAAY,QAAQE,EAAUX,CAAS,CAAC,CAAC,MAAM,MAASY,EAAK,SAASH,CAAO,CAAC;GAElF,IAAIJ,EAAM,kBAAkB;IACxB,AAAKK,OAAUL,EAAM,WAAWG,IAAOD,MAAUP,EAAA,CAAW,MAAM;IAClE;GACJ;GACA,IAAI,CAACO,KAAS,CAACC,GAAM;IAEjB,AADAH,EAAM,eAAe,GACrBL,EAAU,MAAM;IAChB;GACJ;GACA,IAAMa,IAAQR,EAAM,WACdI,MAAYF,KAASE,MAAYT,IACjCS,MAAYD;GAClB,CAAI,CAACE,KAAUG,OACXR,EAAM,eAAe,IACpBA,EAAM,WAAWG,IAAOD,EAAA,CAAO,MAAM;EAE9C;EAGA,OADA,SAAS,iBAAiB,WAAWH,CAAa,SACrC;GAGT,AAFA,SAAS,oBAAoB,WAAWA,CAAa,GACrDb,EAAM,OAAOA,EAAM,QAAQW,CAAK,GAAG,CAAC,GAChCN,GAAQ,eAAaA,EAAO,MAAM;EAC1C;CACJ,GAAG;EAACK;EAAcH;EAAQF;CAAM,CAAC;AACrC"}

package/dist/hooks/use-fullscreen-element.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-fullscreen-element.cjs","names":[],"sources":["../../src/hooks/use-fullscreen-element.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\n/**\n * Vendor-prefixed fullscreen member of `document`, still shipped by WebKit.\n *\n * Declared optional on purpose: the standard property is what every other engine\n * answers to, and Safari is the only reason the second read exists.\n */\ninterface WebkitFullscreenDocument {\n    webkitFullscreenElement?: Element | null;\n}\n\n/**\n * Read the element the browser is presenting fullscreen, standard property first.\n *\n * A plain function rather than a hook, because two very different callers need\n * the answer: `useFullscreenElement` below, which turns it into state, and the\n * action callbacks of `useFullscreen`, which need the value *at call time* and\n * cannot wait for a render to have happened since the last change.\n *\n * @returns The element being presented fullscreen, or `null` — including in any\n * environment without a `document` (a service worker, a build plugin, a Node\n * test), where the SDK must not throw.\n */\nexport function getFullscreenElement(): Element | null {\n    if (typeof document === \"undefined\") return null;\n    const prefixed = document as Document & WebkitFullscreenDocument;\n    return document.fullscreenElement ?? prefixed.webkitFullscreenElement ?? null;\n}\n\n/**\n * Track the element the browser is presenting fullscreen.\n *\n * The SDK's single subscription to `fullscreenchange` (and WebKit's\n * `webkitfullscreenchange`). Two features need exactly this fact and would\n * otherwise each carry their own copy of the prefix dance: `usePortalHost` asks\n * *where do I mount* — the fullscreen element paints its own subtree and nothing\n * else, so a dialog portalled to `document.body` is invisible while fullscreen is\n * on — and `useFullscreen` asks *is my element the one presented*. One\n * subscription, two questions.\n *\n * The event is the source of truth rather than the return of `requestFullscreen`\n * / `exitFullscreen`, because `Esc`, the browser's own exit affordance and F11\n * leave fullscreen without ever passing through those calls.\n *\n * The first value is resolved during render rather than in the effect, so a\n * consumer that mounts while fullscreen is already active is correct in its very\n * first commit instead of correcting itself one frame later.\n *\n * @returns The fullscreen element, or `null` when nothing is presented.\n */\nexport function useFullscreenElement(): Element | null {\n    const [element, setElement] = useState<Element | null>(getFullscreenElement);\n\n    useEffect(() => {\n        const sync = (): void => setElement(getFullscreenElement());\n        sync();\n        document.addEventListener(\"fullscreenchange\", sync);\n        document.addEventListener(\"webkitfullscreenchange\", sync);\n        return () => {\n            document.removeEventListener(\"fullscreenchange\", sync);\n            document.removeEventListener(\"webkitfullscreenchange\", sync);\n        };\n    }, []);\n\n    return element;\n}\n"],"mappings":"uBAwBA,SAAgB,GAAuC,CACnD,GAAI,OAAO,SAAa,IAAa,OAAO,KAC5C,IAAM,EAAW,SACjB,OAAO,SAAS,mBAAqB,EAAS,yBAA2B,IAC7E,CAuBA,SAAgB,GAAuC,CACnD,GAAM,CAAC,EAAS,IAAA,EAAc,EAAA,SAAA,CAAyB,CAAoB,EAa3E,OAXA,EAAA,EAAA,UAAA,KAAgB,CACZ,IAAM,MAAmB,EAAW,EAAqB,CAAC,EAI1D,OAHA,EAAK,EACL,SAAS,iBAAiB,mBAAoB,CAAI,EAClD,SAAS,iBAAiB,yBAA0B,CAAI,MAC3C,CACT,SAAS,oBAAoB,mBAAoB,CAAI,EACrD,SAAS,oBAAoB,yBAA0B,CAAI,CAC/D,CACJ,EAAG,CAAC,CAAC,EAEE,CACX"}
+{"version":3,"file":"use-fullscreen-element.cjs","names":["useState","react","getFullscreenElement","prefixed","useFullscreenElement","element","setElement","sync"],"sources":["../../src/hooks/use-fullscreen-element.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\n/**\n * Vendor-prefixed fullscreen member of `document`, still shipped by WebKit.\n *\n * Declared optional on purpose: the standard property is what every other engine\n * answers to, and Safari is the only reason the second read exists.\n */\ninterface WebkitFullscreenDocument {\n    webkitFullscreenElement?: Element | null;\n}\n\n/**\n * Read the element the browser is presenting fullscreen, standard property first.\n *\n * A plain function rather than a hook, because two very different callers need\n * the answer: `useFullscreenElement` below, which turns it into state, and the\n * action callbacks of `useFullscreen`, which need the value *at call time* and\n * cannot wait for a render to have happened since the last change.\n *\n * @returns The element being presented fullscreen, or `null` — including in any\n * environment without a `document` (a service worker, a build plugin, a Node\n * test), where the SDK must not throw.\n */\nexport function getFullscreenElement(): Element | null {\n    if (typeof document === \"undefined\") return null;\n    const prefixed = document as Document & WebkitFullscreenDocument;\n    return document.fullscreenElement ?? prefixed.webkitFullscreenElement ?? null;\n}\n\n/**\n * Track the element the browser is presenting fullscreen.\n *\n * The SDK's single subscription to `fullscreenchange` (and WebKit's\n * `webkitfullscreenchange`). Two features need exactly this fact and would\n * otherwise each carry their own copy of the prefix dance: `usePortalHost` asks\n * *where do I mount* — the fullscreen element paints its own subtree and nothing\n * else, so a dialog portalled to `document.body` is invisible while fullscreen is\n * on — and `useFullscreen` asks *is my element the one presented*. One\n * subscription, two questions.\n *\n * The event is the source of truth rather than the return of `requestFullscreen`\n * / `exitFullscreen`, because `Esc`, the browser's own exit affordance and F11\n * leave fullscreen without ever passing through those calls.\n *\n * The first value is resolved during render rather than in the effect, so a\n * consumer that mounts while fullscreen is already active is correct in its very\n * first commit instead of correcting itself one frame later.\n *\n * @returns The fullscreen element, or `null` when nothing is presented.\n */\nexport function useFullscreenElement(): Element | null {\n    const [element, setElement] = useState<Element | null>(getFullscreenElement);\n\n    useEffect(() => {\n        const sync = (): void => setElement(getFullscreenElement());\n        sync();\n        document.addEventListener(\"fullscreenchange\", sync);\n        document.addEventListener(\"webkitfullscreenchange\", sync);\n        return () => {\n            document.removeEventListener(\"fullscreenchange\", sync);\n            document.removeEventListener(\"webkitfullscreenchange\", sync);\n        };\n    }, []);\n\n    return element;\n}\n"],"mappings":"A,uBAwBA,SAAgBE,GAAuC,CACnD,GAAI,OAAO,SAAa,IAAa,OAAO,KAC5C,IAAMC,EAAW,SACjB,OAAO,SAAS,mBAAqBA,EAAS,yBAA2B,IAC7E,CAuBA,SAAgBC,GAAuC,CACnD,GAAM,CAACC,EAASC,IAAA,EAAcN,EAAAA,SAAAA,CAAyBE,CAAoB,EAa3E,OAXA,EAAAD,EAAA,UAAA,KAAgB,CACZ,IAAMM,MAAmBD,EAAWJ,EAAqB,CAAC,EAI1D,OAHAK,EAAK,EACL,SAAS,iBAAiB,mBAAoBA,CAAI,EAClD,SAAS,iBAAiB,yBAA0BA,CAAI,MAC3C,CACT,SAAS,oBAAoB,mBAAoBA,CAAI,EACrD,SAAS,oBAAoB,yBAA0BA,CAAI,CAC/D,CACJ,EAAG,CAAC,CAAC,EAEEF,CACX,C"}

package/dist/hooks/use-fullscreen-element.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-fullscreen-element.js","names":[],"sources":["../../src/hooks/use-fullscreen-element.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\n/**\n * Vendor-prefixed fullscreen member of `document`, still shipped by WebKit.\n *\n * Declared optional on purpose: the standard property is what every other engine\n * answers to, and Safari is the only reason the second read exists.\n */\ninterface WebkitFullscreenDocument {\n    webkitFullscreenElement?: Element | null;\n}\n\n/**\n * Read the element the browser is presenting fullscreen, standard property first.\n *\n * A plain function rather than a hook, because two very different callers need\n * the answer: `useFullscreenElement` below, which turns it into state, and the\n * action callbacks of `useFullscreen`, which need the value *at call time* and\n * cannot wait for a render to have happened since the last change.\n *\n * @returns The element being presented fullscreen, or `null` — including in any\n * environment without a `document` (a service worker, a build plugin, a Node\n * test), where the SDK must not throw.\n */\nexport function getFullscreenElement(): Element | null {\n    if (typeof document === \"undefined\") return null;\n    const prefixed = document as Document & WebkitFullscreenDocument;\n    return document.fullscreenElement ?? prefixed.webkitFullscreenElement ?? null;\n}\n\n/**\n * Track the element the browser is presenting fullscreen.\n *\n * The SDK's single subscription to `fullscreenchange` (and WebKit's\n * `webkitfullscreenchange`). Two features need exactly this fact and would\n * otherwise each carry their own copy of the prefix dance: `usePortalHost` asks\n * *where do I mount* — the fullscreen element paints its own subtree and nothing\n * else, so a dialog portalled to `document.body` is invisible while fullscreen is\n * on — and `useFullscreen` asks *is my element the one presented*. One\n * subscription, two questions.\n *\n * The event is the source of truth rather than the return of `requestFullscreen`\n * / `exitFullscreen`, because `Esc`, the browser's own exit affordance and F11\n * leave fullscreen without ever passing through those calls.\n *\n * The first value is resolved during render rather than in the effect, so a\n * consumer that mounts while fullscreen is already active is correct in its very\n * first commit instead of correcting itself one frame later.\n *\n * @returns The fullscreen element, or `null` when nothing is presented.\n */\nexport function useFullscreenElement(): Element | null {\n    const [element, setElement] = useState<Element | null>(getFullscreenElement);\n\n    useEffect(() => {\n        const sync = (): void => setElement(getFullscreenElement());\n        sync();\n        document.addEventListener(\"fullscreenchange\", sync);\n        document.addEventListener(\"webkitfullscreenchange\", sync);\n        return () => {\n            document.removeEventListener(\"fullscreenchange\", sync);\n            document.removeEventListener(\"webkitfullscreenchange\", sync);\n        };\n    }, []);\n\n    return element;\n}\n"],"mappings":";;AAwBA,SAAgB,IAAuC;CACnD,IAAI,OAAO,WAAa,KAAa,OAAO;CAC5C,IAAM,IAAW;CACjB,OAAO,SAAS,qBAAqB,EAAS,2BAA2B;AAC7E;AAuBA,SAAgB,IAAuC;CACnD,IAAM,CAAC,GAAS,KAAc,EAAyB,CAAoB;CAa3E,OAXA,QAAgB;EACZ,IAAM,UAAmB,EAAW,EAAqB,CAAC;EAI1D,OAHA,EAAK,GACL,SAAS,iBAAiB,oBAAoB,CAAI,GAClD,SAAS,iBAAiB,0BAA0B,CAAI,SAC3C;GAET,AADA,SAAS,oBAAoB,oBAAoB,CAAI,GACrD,SAAS,oBAAoB,0BAA0B,CAAI;EAC/D;CACJ,GAAG,CAAC,CAAC,GAEE;AACX"}
+{"version":3,"file":"use-fullscreen-element.js","names":["getFullscreenElement","prefixed","useFullscreenElement","element","setElement","useState","useEffect","sync"],"sources":["../../src/hooks/use-fullscreen-element.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\n/**\n * Vendor-prefixed fullscreen member of `document`, still shipped by WebKit.\n *\n * Declared optional on purpose: the standard property is what every other engine\n * answers to, and Safari is the only reason the second read exists.\n */\ninterface WebkitFullscreenDocument {\n    webkitFullscreenElement?: Element | null;\n}\n\n/**\n * Read the element the browser is presenting fullscreen, standard property first.\n *\n * A plain function rather than a hook, because two very different callers need\n * the answer: `useFullscreenElement` below, which turns it into state, and the\n * action callbacks of `useFullscreen`, which need the value *at call time* and\n * cannot wait for a render to have happened since the last change.\n *\n * @returns The element being presented fullscreen, or `null` — including in any\n * environment without a `document` (a service worker, a build plugin, a Node\n * test), where the SDK must not throw.\n */\nexport function getFullscreenElement(): Element | null {\n    if (typeof document === \"undefined\") return null;\n    const prefixed = document as Document & WebkitFullscreenDocument;\n    return document.fullscreenElement ?? prefixed.webkitFullscreenElement ?? null;\n}\n\n/**\n * Track the element the browser is presenting fullscreen.\n *\n * The SDK's single subscription to `fullscreenchange` (and WebKit's\n * `webkitfullscreenchange`). Two features need exactly this fact and would\n * otherwise each carry their own copy of the prefix dance: `usePortalHost` asks\n * *where do I mount* — the fullscreen element paints its own subtree and nothing\n * else, so a dialog portalled to `document.body` is invisible while fullscreen is\n * on — and `useFullscreen` asks *is my element the one presented*. One\n * subscription, two questions.\n *\n * The event is the source of truth rather than the return of `requestFullscreen`\n * / `exitFullscreen`, because `Esc`, the browser's own exit affordance and F11\n * leave fullscreen without ever passing through those calls.\n *\n * The first value is resolved during render rather than in the effect, so a\n * consumer that mounts while fullscreen is already active is correct in its very\n * first commit instead of correcting itself one frame later.\n *\n * @returns The fullscreen element, or `null` when nothing is presented.\n */\nexport function useFullscreenElement(): Element | null {\n    const [element, setElement] = useState<Element | null>(getFullscreenElement);\n\n    useEffect(() => {\n        const sync = (): void => setElement(getFullscreenElement());\n        sync();\n        document.addEventListener(\"fullscreenchange\", sync);\n        document.addEventListener(\"webkitfullscreenchange\", sync);\n        return () => {\n            document.removeEventListener(\"fullscreenchange\", sync);\n            document.removeEventListener(\"webkitfullscreenchange\", sync);\n        };\n    }, []);\n\n    return element;\n}\n"],"mappings":";;AAwBA,SAAgBA,IAAuC;CACnD,IAAI,OAAO,WAAa,KAAa,OAAO;CAC5C,IAAMC,IAAW;CACjB,OAAO,SAAS,qBAAqBA,EAAS,2BAA2B;AAC7E;AAuBA,SAAgBC,IAAuC;CACnD,IAAM,CAACC,GAASC,KAAcC,EAAyBL,CAAoB;CAa3E,OAXAM,QAAgB;EACZ,IAAMC,UAAmBH,EAAWJ,EAAqB,CAAC;EAI1D,OAHAO,EAAK,GACL,SAAS,iBAAiB,oBAAoBA,CAAI,GAClD,SAAS,iBAAiB,0BAA0BA,CAAI,SAC3C;GAET,AADA,SAAS,oBAAoB,oBAAoBA,CAAI,GACrD,SAAS,oBAAoB,0BAA0BA,CAAI;EAC/D;CACJ,GAAG,CAAC,CAAC,GAEEJ;AACX"}

package/dist/hooks/use-fullscreen.cjs

@@ -1,2 +1,2 @@
-const e=require("./use-fullscreen-element.cjs");let t=require("react");function n(e){return typeof document>`u`?null:e?e.current:document.documentElement}function r(){if(typeof document>`u`)return!1;let e=document.documentElement,t=document;return(typeof e.requestFullscreen==`function`||typeof e.webkitRequestFullscreen==`function`)&&(t.fullscreenEnabled??t.webkitFullscreenEnabled??!0)}function i(i){let a=e.useFullscreenElement(),[o]=(0,t.useState)(r),[s,c]=(0,t.useState)(!1);(0,t.useEffect)(()=>{let e=n(i);c(e!==null&&a===e)},[a,i]);let l=(0,t.useCallback)(async()=>{let e=n(i);if(e===null)throw Error(`useFullscreen: nothing to present. Either this environment has no document, or the ref was never attached to a mounted element.`);let t=e;if(typeof t.requestFullscreen==`function`){await t.requestFullscreen();return}if(typeof t.webkitRequestFullscreen==`function`){await t.webkitRequestFullscreen();return}throw Error(`useFullscreen: this browser exposes no way to enter fullscreen.`)},[i]),u=(0,t.useCallback)(async()=>{if(e.getFullscreenElement()===null)return;let t=document;if(typeof t.exitFullscreen==`function`){await t.exitFullscreen();return}if(typeof t.webkitExitFullscreen==`function`){await t.webkitExitFullscreen();return}throw Error(`useFullscreen: this browser exposes no way to leave fullscreen.`)},[]);return{isFullscreen:s,supported:o,enter:l,exit:u,toggle:(0,t.useCallback)(async()=>{let t=n(i);if(t!==null&&e.getFullscreenElement()===t){await u();return}await l()},[l,u,i])}}exports.isFullscreenSupported=r,exports.useFullscreen=i;
+const e=require("./use-fullscreen-element.cjs");let t=require("react");function n(e){return typeof document>`u`?null:e?e.current:document.documentElement}function r(){if(typeof document>`u`)return!1;let e=document.documentElement,t=document;return(typeof e.requestFullscreen==`function`||typeof e.webkitRequestFullscreen==`function`)&&(t.fullscreenEnabled??t.webkitFullscreenEnabled??!0)}function i(i){let a=e.useFullscreenElement(),[o]=(0,t.useState)(r),[s,c]=(0,t.useState)(!1);(0,t.useEffect)(()=>{let e=n(i);c(e!==null&&a===e)},[a,i]);let l=(0,t.useCallback)(async()=>{let e=n(i);if(e===null)throw Error(`useFullscreen: nothing to present. Either this environment has no document, or the ref was never attached to a mounted element.`);let t=e;if(typeof t.requestFullscreen==`function`)await t.requestFullscreen();else if(typeof t.webkitRequestFullscreen==`function`)await t.webkitRequestFullscreen();else throw Error(`useFullscreen: this browser exposes no way to enter fullscreen.`)},[i]),u=(0,t.useCallback)(async()=>{if(e.getFullscreenElement()===null)return;let t=document;if(typeof t.exitFullscreen==`function`)await t.exitFullscreen();else if(typeof t.webkitExitFullscreen==`function`)await t.webkitExitFullscreen();else throw Error(`useFullscreen: this browser exposes no way to leave fullscreen.`)},[]);return{isFullscreen:s,supported:o,enter:l,exit:u,toggle:(0,t.useCallback)(async()=>{let t=n(i);t!==null&&e.getFullscreenElement()===t?await u():await l()},[l,u,i])}}exports.isFullscreenSupported=r,exports.useFullscreen=i;
 //# sourceMappingURL=use-fullscreen.cjs.map