tempest-react-sdk 0.78.0 → 0.79.0

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

@@ -1 +1 @@
-{"version":3,"file":"use-pagination.cjs","names":[],"sources":["../../src/hooks/use-pagination.ts"],"sourcesContent":["import { useCallback, useState } from \"react\";\n\nexport interface UsePaginationResult {\n    page: number;\n    size: number;\n    setPage: (page: number) => void;\n    setSize: (size: number) => void;\n    reset: () => void;\n}\n\n/**\n * Manage page/size state for paginated lists. Reset goes back to page 1\n * without touching the page size.\n *\n * @param initialPage - Starting page (default 1).\n * @param initialSize - Starting page size (default 50).\n * @returns Pagination state and setters.\n */\nexport function usePagination(initialPage = 1, initialSize = 50): UsePaginationResult {\n    const [page, setPage] = useState<number>(initialPage);\n    const [size, setSize] = useState<number>(initialSize);\n\n    const reset = useCallback(() => setPage(1), []);\n\n    return { page, size, setPage, setSize, reset };\n}\n"],"mappings":"uBAkBA,SAAgB,EAAc,EAAc,EAAG,EAAc,GAAyB,CAClF,GAAM,CAAC,EAAM,IAAA,EAAW,EAAA,SAAA,CAAiB,CAAW,EAC9C,CAAC,EAAM,IAAA,EAAW,EAAA,SAAA,CAAiB,CAAW,EAIpD,MAAO,CAAE,OAAM,OAAM,UAAS,UAAS,OAAA,EAFzB,EAAA,YAAA,KAAkB,EAAQ,CAAC,EAAG,CAAC,CAEN,CAAM,CACjD"}
+{"version":3,"file":"use-pagination.cjs","names":["useState","useCallback","react","usePagination","page","setPage","initialPage","size","setSize","initialSize"],"sources":["../../src/hooks/use-pagination.ts"],"sourcesContent":["import { useCallback, useState } from \"react\";\n\nexport interface UsePaginationResult {\n    page: number;\n    size: number;\n    setPage: (page: number) => void;\n    setSize: (size: number) => void;\n    reset: () => void;\n}\n\n/**\n * Manage page/size state for paginated lists. Reset goes back to page 1\n * without touching the page size.\n *\n * @param initialPage - Starting page (default 1).\n * @param initialSize - Starting page size (default 50).\n * @returns Pagination state and setters.\n */\nexport function usePagination(initialPage = 1, initialSize = 50): UsePaginationResult {\n    const [page, setPage] = useState<number>(initialPage);\n    const [size, setSize] = useState<number>(initialSize);\n\n    const reset = useCallback(() => setPage(1), []);\n\n    return { page, size, setPage, setSize, reset };\n}\n"],"mappings":"A,uBAkBA,SAAgBG,EAAc,EAAc,EAAG,EAAc,GAAyB,CAClF,GAAM,CAACC,EAAMC,IAAA,EAAWL,EAAAA,SAAAA,CAAiBM,CAAW,EAC9C,CAACC,EAAMC,IAAA,EAAWR,EAAAA,SAAAA,CAAiBS,CAAW,EAIpD,MAAO,CAAE,OAAM,OAAM,UAAS,UAAS,OAAA,EAFzBR,EAAAA,YAAAA,KAAkBI,EAAQ,CAAC,EAAG,CAAC,CAEN,CAAM,CACjD,C"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-pagination.js","names":[],"sources":["../../src/hooks/use-pagination.ts"],"sourcesContent":["import { useCallback, useState } from \"react\";\n\nexport interface UsePaginationResult {\n    page: number;\n    size: number;\n    setPage: (page: number) => void;\n    setSize: (size: number) => void;\n    reset: () => void;\n}\n\n/**\n * Manage page/size state for paginated lists. Reset goes back to page 1\n * without touching the page size.\n *\n * @param initialPage - Starting page (default 1).\n * @param initialSize - Starting page size (default 50).\n * @returns Pagination state and setters.\n */\nexport function usePagination(initialPage = 1, initialSize = 50): UsePaginationResult {\n    const [page, setPage] = useState<number>(initialPage);\n    const [size, setSize] = useState<number>(initialSize);\n\n    const reset = useCallback(() => setPage(1), []);\n\n    return { page, size, setPage, setSize, reset };\n}\n"],"mappings":";;AAkBA,SAAgB,EAAc,IAAc,GAAG,IAAc,IAAyB;CAClF,IAAM,CAAC,GAAM,KAAW,EAAiB,CAAW,GAC9C,CAAC,GAAM,KAAW,EAAiB,CAAW;CAIpD,OAAO;EAAE;EAAM;EAAM;EAAS;EAAS,OAFzB,QAAkB,EAAQ,CAAC,GAAG,CAAC,CAEN;CAAM;AACjD"}
+{"version":3,"file":"use-pagination.js","names":["usePagination","page","setPage","useState","initialPage","size","setSize","initialSize","useCallback"],"sources":["../../src/hooks/use-pagination.ts"],"sourcesContent":["import { useCallback, useState } from \"react\";\n\nexport interface UsePaginationResult {\n    page: number;\n    size: number;\n    setPage: (page: number) => void;\n    setSize: (size: number) => void;\n    reset: () => void;\n}\n\n/**\n * Manage page/size state for paginated lists. Reset goes back to page 1\n * without touching the page size.\n *\n * @param initialPage - Starting page (default 1).\n * @param initialSize - Starting page size (default 50).\n * @returns Pagination state and setters.\n */\nexport function usePagination(initialPage = 1, initialSize = 50): UsePaginationResult {\n    const [page, setPage] = useState<number>(initialPage);\n    const [size, setSize] = useState<number>(initialSize);\n\n    const reset = useCallback(() => setPage(1), []);\n\n    return { page, size, setPage, setSize, reset };\n}\n"],"mappings":";;AAkBA,SAAgBA,EAAc,IAAc,GAAG,IAAc,IAAyB;CAClF,IAAM,CAACC,GAAMC,KAAWC,EAAiBC,CAAW,GAC9C,CAACC,GAAMC,KAAWH,EAAiBI,CAAW;CAIpD,OAAO;EAAE;EAAM;EAAM;EAAS;EAAS,OAFzBC,QAAkBN,EAAQ,CAAC,GAAG,CAAC,CAEN;CAAM;AACjD"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-previous.cjs","names":[],"sources":["../../src/hooks/use-previous.ts"],"sourcesContent":["/* eslint-disable react-hooks/refs -- returning last render's value IS this hook's contract */\nimport { useEffect, useRef } from \"react\";\n\n/**\n * Return the value from the previous render. `undefined` on the first render.\n *\n * @example\n * const previousCount = usePrevious(count);\n * useEffect(() => {\n *     if (previousCount !== undefined && previousCount !== count) {\n *         analytics.track(\"count.changed\", { from: previousCount, to: count });\n *     }\n * }, [count, previousCount]);\n */\nexport function usePrevious<T>(value: T): T | undefined {\n    const ref = useRef<T | undefined>(undefined);\n    useEffect(() => {\n        ref.current = value;\n    }, [value]);\n    return ref.current;\n}\n"],"mappings":"uBAcA,SAAgB,EAAe,EAAyB,CACpD,IAAM,GAAA,EAAM,EAAA,OAAA,CAAsB,IAAA,EAAS,EAI3C,OAHA,EAAA,EAAA,UAAA,KAAgB,CACZ,EAAI,QAAU,CAClB,EAAG,CAAC,CAAK,CAAC,EACH,EAAI,OACf"}
+{"version":3,"file":"use-previous.cjs","names":["useRef","react","usePrevious","ref","value"],"sources":["../../src/hooks/use-previous.ts"],"sourcesContent":["/* eslint-disable react-hooks/refs -- returning last render's value IS this hook's contract */\nimport { useEffect, useRef } from \"react\";\n\n/**\n * Return the value from the previous render. `undefined` on the first render.\n *\n * @example\n * const previousCount = usePrevious(count);\n * useEffect(() => {\n *     if (previousCount !== undefined && previousCount !== count) {\n *         analytics.track(\"count.changed\", { from: previousCount, to: count });\n *     }\n * }, [count, previousCount]);\n */\nexport function usePrevious<T>(value: T): T | undefined {\n    const ref = useRef<T | undefined>(undefined);\n    useEffect(() => {\n        ref.current = value;\n    }, [value]);\n    return ref.current;\n}\n"],"mappings":"A,uBAcA,SAAgBE,EAAe,EAAyB,CACpD,IAAMC,GAAA,EAAMH,EAAAA,OAAAA,CAAsB,IAAA,EAAS,EAI3C,OAHA,EAAAC,EAAA,UAAA,KAAgB,CACZ,EAAI,QAAUG,CAClB,EAAG,CAACA,CAAK,CAAC,EACHD,EAAI,OACf,C"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-previous.js","names":[],"sources":["../../src/hooks/use-previous.ts"],"sourcesContent":["/* eslint-disable react-hooks/refs -- returning last render's value IS this hook's contract */\nimport { useEffect, useRef } from \"react\";\n\n/**\n * Return the value from the previous render. `undefined` on the first render.\n *\n * @example\n * const previousCount = usePrevious(count);\n * useEffect(() => {\n *     if (previousCount !== undefined && previousCount !== count) {\n *         analytics.track(\"count.changed\", { from: previousCount, to: count });\n *     }\n * }, [count, previousCount]);\n */\nexport function usePrevious<T>(value: T): T | undefined {\n    const ref = useRef<T | undefined>(undefined);\n    useEffect(() => {\n        ref.current = value;\n    }, [value]);\n    return ref.current;\n}\n"],"mappings":";;AAcA,SAAgB,EAAe,GAAyB;CACpD,IAAM,IAAM,EAAsB,KAAA,CAAS;CAI3C,OAHA,QAAgB;EACZ,EAAI,UAAU;CAClB,GAAG,CAAC,CAAK,CAAC,GACH,EAAI;AACf"}
+{"version":3,"file":"use-previous.js","names":["usePrevious","ref","useRef","useEffect","value"],"sources":["../../src/hooks/use-previous.ts"],"sourcesContent":["/* eslint-disable react-hooks/refs -- returning last render's value IS this hook's contract */\nimport { useEffect, useRef } from \"react\";\n\n/**\n * Return the value from the previous render. `undefined` on the first render.\n *\n * @example\n * const previousCount = usePrevious(count);\n * useEffect(() => {\n *     if (previousCount !== undefined && previousCount !== count) {\n *         analytics.track(\"count.changed\", { from: previousCount, to: count });\n *     }\n * }, [count, previousCount]);\n */\nexport function usePrevious<T>(value: T): T | undefined {\n    const ref = useRef<T | undefined>(undefined);\n    useEffect(() => {\n        ref.current = value;\n    }, [value]);\n    return ref.current;\n}\n"],"mappings":";;AAcA,SAAgBA,EAAe,GAAyB;CACpD,IAAMC,IAAMC,EAAsB,KAAA,CAAS;CAI3C,OAHAC,QAAgB;EACZ,EAAI,UAAUC;CAClB,GAAG,CAACA,CAAK,CAAC,GACHH,EAAI;AACf"}

package/dist/hooks/use-push-to-talk.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-push-to-talk.cjs","names":[],"sources":["../../src/hooks/use-push-to-talk.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\n\n/** A key offered for push-to-talk, with the label a settings screen shows. */\nexport interface PushToTalkKey {\n    /** `KeyboardEvent.code`, which is layout-independent. */\n    code: string;\n    /** What to show a person. `code` itself is not a label. */\n    label: string;\n}\n\n/**\n * The keys worth offering for push-to-talk.\n *\n * Identified by `code` rather than `key` so a binding survives a layout change:\n * on an ABNT2 keyboard the `key` reported for the backquote position is not what\n * a US layout reports, while `Backquote` is the same physical key everywhere.\n *\n * Left-hand modifiers only. The right-hand ones sit under the hand that is\n * usually on the mouse, and a modifier that is also a shortcut prefix\n * (`ControlLeft` with a browser shortcut) is a deliberate trade the caller makes\n * by choosing it.\n */\nexport const PUSH_TO_TALK_KEYS: readonly PushToTalkKey[] = [\n    { code: \"Space\", label: \"Espaço\" },\n    { code: \"ControlLeft\", label: \"Ctrl esquerdo\" },\n    { code: \"AltLeft\", label: \"Alt esquerdo\" },\n    { code: \"ShiftLeft\", label: \"Shift esquerdo\" },\n    { code: \"Backquote\", label: \"Crase (`)\" },\n];\n\n/** The key a caller gets when it does not choose one. */\nexport const DEFAULT_PUSH_TO_TALK_KEY = \"Space\";\n\n/**\n * The label to show for a `KeyboardEvent.code`.\n *\n * @param code - The bound key's code.\n * @returns Its label, or the code itself for a key this list does not name —\n *     showing `\"F13\"` beats showing nothing.\n */\nexport function pushToTalkKeyLabel(code: string): string {\n    return PUSH_TO_TALK_KEYS.find((key) => key.code === code)?.label ?? code;\n}\n\n/**\n * Whether a keystroke is meant for something the person is typing into.\n *\n * Without this a push-to-talk key bound to Space opens the microphone every time\n * somebody writes a message — and the space never reaches the text field,\n * because the handler preventDefault'd it.\n *\n * @param target - The event's target.\n * @returns `true` when the keystroke belongs to a field, not to the app.\n */\nfunction isTypingTarget(target: EventTarget | null): boolean {\n    if (!(target instanceof HTMLElement)) return false;\n    if (target.isContentEditable) return true;\n    const tag = target.tagName;\n    return tag === \"INPUT\" || tag === \"TEXTAREA\" || tag === \"SELECT\";\n}\n\n/** Options for {@link usePushToTalk}. */\nexport interface UsePushToTalkOptions {\n    /** `KeyboardEvent.code` to hold. Default {@link DEFAULT_PUSH_TO_TALK_KEY}. */\n    code?: string;\n    /** Called once when the key goes down. */\n    onDown: () => void;\n    /** Called when the key comes up, the window blurs, or the hook unmounts. */\n    onUp: () => void;\n    /**\n     * Whether the binding is live. Default `true`.\n     *\n     * Turning it off releases first, so flipping a call from push-to-talk to an\n     * open microphone while the key is held does not leave `onUp` unfired.\n     */\n    enabled?: boolean;\n}\n\n/**\n * Hold a key to transmit; release it to go silent again.\n *\n * Looks like `keydown`/`keyup` and is not, because three things go wrong:\n *\n * 1. **`blur` has to release.** Alt-tabbing away while holding the key means the\n *    browser never sees the `keyup`, and the microphone stays open for as long as\n *    the person is looking at another window — exactly what push-to-talk exists\n *    to prevent.\n * 2. **Auto-repeat has to be ignored.** A held key repeats at the keyboard's rate,\n *    and without the `repeat` check `onDown` fires on every one of them.\n * 3. **A text field has to win.** Space bound to push-to-talk with the focus in an\n *    `<input>` means the space never reaches the message being written.\n *\n * Unmounting releases too, for the same reason `blur` does: the callback that\n * stops transmitting has to run even when the component holding it goes away\n * mid-press.\n *\n * The callbacks are read through a ref that a commit-time effect refreshes, so\n * passing inline arrows neither tears the listeners down on every render nor\n * writes to the ref during one — a render React discards would leave the ref\n * pointing at callbacks that never became the UI.\n *\n * @param options - See {@link UsePushToTalkOptions}.\n *\n * @example\n * usePushToTalk({\n *     code: \"Space\",\n *     onDown: () => setMicEnabled(true),\n *     onUp: () => setMicEnabled(false),\n * });\n */\nexport function usePushToTalk({\n    code = DEFAULT_PUSH_TO_TALK_KEY,\n    onDown,\n    onUp,\n    enabled = true,\n}: UsePushToTalkOptions): void {\n    const callbacks = useRef({ onDown, onUp });\n    useEffect(() => {\n        callbacks.current = { onDown, onUp };\n    });\n\n    useEffect(() => {\n        if (!enabled || typeof window === \"undefined\") return;\n        let held = false;\n\n        const release = (): void => {\n            if (!held) return;\n            held = false;\n            callbacks.current.onUp();\n        };\n\n        const handleKeyDown = (event: KeyboardEvent): void => {\n            if (event.code !== code || event.repeat) return;\n            if (isTypingTarget(event.target)) return;\n            event.preventDefault();\n            if (held) return;\n            held = true;\n            callbacks.current.onDown();\n        };\n\n        /**\n         * Release on the way up, and never mind where the keystroke landed.\n         *\n         * The field guard belongs on the way **down** — it is what stops a\n         * push-to-talk bound to Space from opening the microphone every time\n         * somebody writes a message. On the way up it did the opposite of its\n         * job: `keyup` is delivered to whatever is focused when the key rises,\n         * not to what was focused when it fell, so clicking into an input while\n         * still holding sent the release into the guard and left `held` true.\n         * The microphone stayed open until the window blurred.\n         *\n         * `held` is the guard this needs. If we never opened the microphone\n         * there is nothing to close, and `release()` already returns on that —\n         * so the only thing left to decide is `preventDefault`, which is\n         * honest only for a keystroke we actually acted on.\n         */\n        const handleKeyUp = (event: KeyboardEvent): void => {\n            if (event.code !== code || !held) return;\n            event.preventDefault();\n            release();\n        };\n\n        window.addEventListener(\"keydown\", handleKeyDown);\n        window.addEventListener(\"keyup\", handleKeyUp);\n        window.addEventListener(\"blur\", release);\n\n        return () => {\n            window.removeEventListener(\"keydown\", handleKeyDown);\n            window.removeEventListener(\"keyup\", handleKeyUp);\n            window.removeEventListener(\"blur\", release);\n            release();\n        };\n    }, [code, enabled]);\n}\n"],"mappings":"uBAsBA,IAAa,EAA8C,CACvD,CAAE,KAAM,QAAS,MAAO,QAAS,EACjC,CAAE,KAAM,cAAe,MAAO,eAAgB,EAC9C,CAAE,KAAM,UAAW,MAAO,cAAe,EACzC,CAAE,KAAM,YAAa,MAAO,gBAAiB,EAC7C,CAAE,KAAM,YAAa,MAAO,WAAY,CAC5C,EAGa,EAA2B,QASxC,SAAgB,EAAmB,EAAsB,CACrD,OAAO,EAAkB,KAAM,GAAQ,EAAI,OAAS,CAAI,CAAC,EAAE,OAAS,CACxE,CAYA,SAAS,EAAe,EAAqC,CACzD,GAAI,EAAE,aAAkB,aAAc,MAAO,GAC7C,GAAI,EAAO,kBAAmB,MAAO,GACrC,IAAM,EAAM,EAAO,QACnB,OAAO,IAAQ,SAAW,IAAQ,YAAc,IAAQ,QAC5D,CAmDA,SAAgB,EAAc,CAC1B,OAAO,EACP,SACA,OACA,UAAU,IACiB,CAC3B,IAAM,GAAA,EAAY,EAAA,OAAA,CAAO,CAAE,SAAQ,MAAK,CAAC,GACzC,EAAA,EAAA,UAAA,KAAgB,CACZ,EAAU,QAAU,CAAE,SAAQ,MAAK,CACvC,CAAC,GAED,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,CAAC,GAAW,OAAO,OAAW,IAAa,OAC/C,IAAI,EAAO,GAEL,MAAsB,CACnB,IACL,EAAO,GACP,EAAU,QAAQ,KAAK,EAC3B,EAEM,EAAiB,GAA+B,CAC9C,EAAM,OAAS,GAAQ,EAAM,QAC7B,EAAe,EAAM,MAAM,IAC/B,EAAM,eAAe,EACjB,KACJ,EAAO,GACP,EAAU,QAAQ,OAAO,GAC7B,EAkBM,EAAe,GAA+B,CAC5C,EAAM,OAAS,GAAS,IAC5B,EAAM,eAAe,EACrB,EAAQ,EACZ,EAMA,OAJA,OAAO,iBAAiB,UAAW,CAAa,EAChD,OAAO,iBAAiB,QAAS,CAAW,EAC5C,OAAO,iBAAiB,OAAQ,CAAO,MAE1B,CACT,OAAO,oBAAoB,UAAW,CAAa,EACnD,OAAO,oBAAoB,QAAS,CAAW,EAC/C,OAAO,oBAAoB,OAAQ,CAAO,EAC1C,EAAQ,CACZ,CACJ,EAAG,CAAC,EAAM,CAAO,CAAC,CACtB"}
+{"version":3,"file":"use-push-to-talk.cjs","names":["useRef","react","PUSH_TO_TALK_KEYS","DEFAULT_PUSH_TO_TALK_KEY","pushToTalkKeyLabel","key","code","isTypingTarget","target","tag","usePushToTalk","callbacks","enabled","held","release","handleKeyDown","event","handleKeyUp"],"sources":["../../src/hooks/use-push-to-talk.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\n\n/** A key offered for push-to-talk, with the label a settings screen shows. */\nexport interface PushToTalkKey {\n    /** `KeyboardEvent.code`, which is layout-independent. */\n    code: string;\n    /** What to show a person. `code` itself is not a label. */\n    label: string;\n}\n\n/**\n * The keys worth offering for push-to-talk.\n *\n * Identified by `code` rather than `key` so a binding survives a layout change:\n * on an ABNT2 keyboard the `key` reported for the backquote position is not what\n * a US layout reports, while `Backquote` is the same physical key everywhere.\n *\n * Left-hand modifiers only. The right-hand ones sit under the hand that is\n * usually on the mouse, and a modifier that is also a shortcut prefix\n * (`ControlLeft` with a browser shortcut) is a deliberate trade the caller makes\n * by choosing it.\n */\nexport const PUSH_TO_TALK_KEYS: readonly PushToTalkKey[] = [\n    { code: \"Space\", label: \"Espaço\" },\n    { code: \"ControlLeft\", label: \"Ctrl esquerdo\" },\n    { code: \"AltLeft\", label: \"Alt esquerdo\" },\n    { code: \"ShiftLeft\", label: \"Shift esquerdo\" },\n    { code: \"Backquote\", label: \"Crase (`)\" },\n];\n\n/** The key a caller gets when it does not choose one. */\nexport const DEFAULT_PUSH_TO_TALK_KEY = \"Space\";\n\n/**\n * The label to show for a `KeyboardEvent.code`.\n *\n * @param code - The bound key's code.\n * @returns Its label, or the code itself for a key this list does not name —\n *     showing `\"F13\"` beats showing nothing.\n */\nexport function pushToTalkKeyLabel(code: string): string {\n    return PUSH_TO_TALK_KEYS.find((key) => key.code === code)?.label ?? code;\n}\n\n/**\n * Whether a keystroke is meant for something the person is typing into.\n *\n * Without this a push-to-talk key bound to Space opens the microphone every time\n * somebody writes a message — and the space never reaches the text field,\n * because the handler preventDefault'd it.\n *\n * @param target - The event's target.\n * @returns `true` when the keystroke belongs to a field, not to the app.\n */\nfunction isTypingTarget(target: EventTarget | null): boolean {\n    if (!(target instanceof HTMLElement)) return false;\n    if (target.isContentEditable) return true;\n    const tag = target.tagName;\n    return tag === \"INPUT\" || tag === \"TEXTAREA\" || tag === \"SELECT\";\n}\n\n/** Options for {@link usePushToTalk}. */\nexport interface UsePushToTalkOptions {\n    /** `KeyboardEvent.code` to hold. Default {@link DEFAULT_PUSH_TO_TALK_KEY}. */\n    code?: string;\n    /** Called once when the key goes down. */\n    onDown: () => void;\n    /** Called when the key comes up, the window blurs, or the hook unmounts. */\n    onUp: () => void;\n    /**\n     * Whether the binding is live. Default `true`.\n     *\n     * Turning it off releases first, so flipping a call from push-to-talk to an\n     * open microphone while the key is held does not leave `onUp` unfired.\n     */\n    enabled?: boolean;\n}\n\n/**\n * Hold a key to transmit; release it to go silent again.\n *\n * Looks like `keydown`/`keyup` and is not, because three things go wrong:\n *\n * 1. **`blur` has to release.** Alt-tabbing away while holding the key means the\n *    browser never sees the `keyup`, and the microphone stays open for as long as\n *    the person is looking at another window — exactly what push-to-talk exists\n *    to prevent.\n * 2. **Auto-repeat has to be ignored.** A held key repeats at the keyboard's rate,\n *    and without the `repeat` check `onDown` fires on every one of them.\n * 3. **A text field has to win.** Space bound to push-to-talk with the focus in an\n *    `<input>` means the space never reaches the message being written.\n *\n * Unmounting releases too, for the same reason `blur` does: the callback that\n * stops transmitting has to run even when the component holding it goes away\n * mid-press.\n *\n * The callbacks are read through a ref that a commit-time effect refreshes, so\n * passing inline arrows neither tears the listeners down on every render nor\n * writes to the ref during one — a render React discards would leave the ref\n * pointing at callbacks that never became the UI.\n *\n * @param options - See {@link UsePushToTalkOptions}.\n *\n * @example\n * usePushToTalk({\n *     code: \"Space\",\n *     onDown: () => setMicEnabled(true),\n *     onUp: () => setMicEnabled(false),\n * });\n */\nexport function usePushToTalk({\n    code = DEFAULT_PUSH_TO_TALK_KEY,\n    onDown,\n    onUp,\n    enabled = true,\n}: UsePushToTalkOptions): void {\n    const callbacks = useRef({ onDown, onUp });\n    useEffect(() => {\n        callbacks.current = { onDown, onUp };\n    });\n\n    useEffect(() => {\n        if (!enabled || typeof window === \"undefined\") return;\n        let held = false;\n\n        const release = (): void => {\n            if (!held) return;\n            held = false;\n            callbacks.current.onUp();\n        };\n\n        const handleKeyDown = (event: KeyboardEvent): void => {\n            if (event.code !== code || event.repeat) return;\n            if (isTypingTarget(event.target)) return;\n            event.preventDefault();\n            if (held) return;\n            held = true;\n            callbacks.current.onDown();\n        };\n\n        /**\n         * Release on the way up, and never mind where the keystroke landed.\n         *\n         * The field guard belongs on the way **down** — it is what stops a\n         * push-to-talk bound to Space from opening the microphone every time\n         * somebody writes a message. On the way up it did the opposite of its\n         * job: `keyup` is delivered to whatever is focused when the key rises,\n         * not to what was focused when it fell, so clicking into an input while\n         * still holding sent the release into the guard and left `held` true.\n         * The microphone stayed open until the window blurred.\n         *\n         * `held` is the guard this needs. If we never opened the microphone\n         * there is nothing to close, and `release()` already returns on that —\n         * so the only thing left to decide is `preventDefault`, which is\n         * honest only for a keystroke we actually acted on.\n         */\n        const handleKeyUp = (event: KeyboardEvent): void => {\n            if (event.code !== code || !held) return;\n            event.preventDefault();\n            release();\n        };\n\n        window.addEventListener(\"keydown\", handleKeyDown);\n        window.addEventListener(\"keyup\", handleKeyUp);\n        window.addEventListener(\"blur\", release);\n\n        return () => {\n            window.removeEventListener(\"keydown\", handleKeyDown);\n            window.removeEventListener(\"keyup\", handleKeyUp);\n            window.removeEventListener(\"blur\", release);\n            release();\n        };\n    }, [code, enabled]);\n}\n"],"mappings":"A,uBAsBA,IAAaE,EAA8C,CACvD,CAAE,KAAM,QAAS,MAAO,QAAS,EACjC,CAAE,KAAM,cAAe,MAAO,eAAgB,EAC9C,CAAE,KAAM,UAAW,MAAO,cAAe,EACzC,CAAE,KAAM,YAAa,MAAO,gBAAiB,EAC7C,CAAE,KAAM,YAAa,MAAO,WAAY,CAC5C,EAGaC,EAA2B,QASxC,SAAgBC,EAAmB,EAAsB,CACrD,OAAOF,EAAkB,KAAM,GAAQG,EAAI,OAASC,CAAI,CAAC,EAAE,OAASA,CACxE,CAYA,SAASC,EAAe,EAAqC,CACzD,GAAI,EAAEC,aAAkB,aAAc,MAAO,GAC7C,GAAIA,EAAO,kBAAmB,MAAO,GACrC,IAAMC,EAAMD,EAAO,QACnB,OAAOC,IAAQ,SAAWA,IAAQ,YAAcA,IAAQ,QAC5D,CAmDA,SAAgBC,EAAc,CAC1B,OAAOP,EACP,SACA,OACA,UAAU,IACiB,CAC3B,IAAMQ,GAAA,EAAYX,EAAAA,OAAAA,CAAO,CAAE,SAAQ,MAAK,CAAC,GACzC,EAAAC,EAAA,UAAA,KAAgB,CACZ,EAAU,QAAU,CAAE,SAAQ,MAAK,CACvC,CAAC,GAED,EAAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,CAACW,GAAW,OAAO,OAAW,IAAa,OAC/C,IAAIC,EAAO,GAELC,MAAsB,CACnBD,IACL,EAAO,GACPF,EAAU,QAAQ,KAAK,EAC3B,EAEMI,EAAiB,GAA+B,CAC9CC,EAAM,OAASV,GAAQU,EAAM,QAC7BT,EAAeS,EAAM,MAAM,IAC/BA,EAAM,eAAe,EACjB,KACJ,EAAO,GACPL,EAAU,QAAQ,OAAO,GAC7B,EAkBMM,EAAe,GAA+B,CAC5CD,EAAM,OAASV,GAASO,IAC5BG,EAAM,eAAe,EACrBF,EAAQ,EACZ,EAMA,OAJA,OAAO,iBAAiB,UAAWC,CAAa,EAChD,OAAO,iBAAiB,QAASE,CAAW,EAC5C,OAAO,iBAAiB,OAAQH,CAAO,MAE1B,CACT,OAAO,oBAAoB,UAAWC,CAAa,EACnD,OAAO,oBAAoB,QAASE,CAAW,EAC/C,OAAO,oBAAoB,OAAQH,CAAO,EAC1CA,EAAQ,CACZ,CACJ,EAAG,CAACR,EAAMM,CAAO,CAAC,CACtB,C"}

package/dist/hooks/use-push-to-talk.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-push-to-talk.js","names":[],"sources":["../../src/hooks/use-push-to-talk.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\n\n/** A key offered for push-to-talk, with the label a settings screen shows. */\nexport interface PushToTalkKey {\n    /** `KeyboardEvent.code`, which is layout-independent. */\n    code: string;\n    /** What to show a person. `code` itself is not a label. */\n    label: string;\n}\n\n/**\n * The keys worth offering for push-to-talk.\n *\n * Identified by `code` rather than `key` so a binding survives a layout change:\n * on an ABNT2 keyboard the `key` reported for the backquote position is not what\n * a US layout reports, while `Backquote` is the same physical key everywhere.\n *\n * Left-hand modifiers only. The right-hand ones sit under the hand that is\n * usually on the mouse, and a modifier that is also a shortcut prefix\n * (`ControlLeft` with a browser shortcut) is a deliberate trade the caller makes\n * by choosing it.\n */\nexport const PUSH_TO_TALK_KEYS: readonly PushToTalkKey[] = [\n    { code: \"Space\", label: \"Espaço\" },\n    { code: \"ControlLeft\", label: \"Ctrl esquerdo\" },\n    { code: \"AltLeft\", label: \"Alt esquerdo\" },\n    { code: \"ShiftLeft\", label: \"Shift esquerdo\" },\n    { code: \"Backquote\", label: \"Crase (`)\" },\n];\n\n/** The key a caller gets when it does not choose one. */\nexport const DEFAULT_PUSH_TO_TALK_KEY = \"Space\";\n\n/**\n * The label to show for a `KeyboardEvent.code`.\n *\n * @param code - The bound key's code.\n * @returns Its label, or the code itself for a key this list does not name —\n *     showing `\"F13\"` beats showing nothing.\n */\nexport function pushToTalkKeyLabel(code: string): string {\n    return PUSH_TO_TALK_KEYS.find((key) => key.code === code)?.label ?? code;\n}\n\n/**\n * Whether a keystroke is meant for something the person is typing into.\n *\n * Without this a push-to-talk key bound to Space opens the microphone every time\n * somebody writes a message — and the space never reaches the text field,\n * because the handler preventDefault'd it.\n *\n * @param target - The event's target.\n * @returns `true` when the keystroke belongs to a field, not to the app.\n */\nfunction isTypingTarget(target: EventTarget | null): boolean {\n    if (!(target instanceof HTMLElement)) return false;\n    if (target.isContentEditable) return true;\n    const tag = target.tagName;\n    return tag === \"INPUT\" || tag === \"TEXTAREA\" || tag === \"SELECT\";\n}\n\n/** Options for {@link usePushToTalk}. */\nexport interface UsePushToTalkOptions {\n    /** `KeyboardEvent.code` to hold. Default {@link DEFAULT_PUSH_TO_TALK_KEY}. */\n    code?: string;\n    /** Called once when the key goes down. */\n    onDown: () => void;\n    /** Called when the key comes up, the window blurs, or the hook unmounts. */\n    onUp: () => void;\n    /**\n     * Whether the binding is live. Default `true`.\n     *\n     * Turning it off releases first, so flipping a call from push-to-talk to an\n     * open microphone while the key is held does not leave `onUp` unfired.\n     */\n    enabled?: boolean;\n}\n\n/**\n * Hold a key to transmit; release it to go silent again.\n *\n * Looks like `keydown`/`keyup` and is not, because three things go wrong:\n *\n * 1. **`blur` has to release.** Alt-tabbing away while holding the key means the\n *    browser never sees the `keyup`, and the microphone stays open for as long as\n *    the person is looking at another window — exactly what push-to-talk exists\n *    to prevent.\n * 2. **Auto-repeat has to be ignored.** A held key repeats at the keyboard's rate,\n *    and without the `repeat` check `onDown` fires on every one of them.\n * 3. **A text field has to win.** Space bound to push-to-talk with the focus in an\n *    `<input>` means the space never reaches the message being written.\n *\n * Unmounting releases too, for the same reason `blur` does: the callback that\n * stops transmitting has to run even when the component holding it goes away\n * mid-press.\n *\n * The callbacks are read through a ref that a commit-time effect refreshes, so\n * passing inline arrows neither tears the listeners down on every render nor\n * writes to the ref during one — a render React discards would leave the ref\n * pointing at callbacks that never became the UI.\n *\n * @param options - See {@link UsePushToTalkOptions}.\n *\n * @example\n * usePushToTalk({\n *     code: \"Space\",\n *     onDown: () => setMicEnabled(true),\n *     onUp: () => setMicEnabled(false),\n * });\n */\nexport function usePushToTalk({\n    code = DEFAULT_PUSH_TO_TALK_KEY,\n    onDown,\n    onUp,\n    enabled = true,\n}: UsePushToTalkOptions): void {\n    const callbacks = useRef({ onDown, onUp });\n    useEffect(() => {\n        callbacks.current = { onDown, onUp };\n    });\n\n    useEffect(() => {\n        if (!enabled || typeof window === \"undefined\") return;\n        let held = false;\n\n        const release = (): void => {\n            if (!held) return;\n            held = false;\n            callbacks.current.onUp();\n        };\n\n        const handleKeyDown = (event: KeyboardEvent): void => {\n            if (event.code !== code || event.repeat) return;\n            if (isTypingTarget(event.target)) return;\n            event.preventDefault();\n            if (held) return;\n            held = true;\n            callbacks.current.onDown();\n        };\n\n        /**\n         * Release on the way up, and never mind where the keystroke landed.\n         *\n         * The field guard belongs on the way **down** — it is what stops a\n         * push-to-talk bound to Space from opening the microphone every time\n         * somebody writes a message. On the way up it did the opposite of its\n         * job: `keyup` is delivered to whatever is focused when the key rises,\n         * not to what was focused when it fell, so clicking into an input while\n         * still holding sent the release into the guard and left `held` true.\n         * The microphone stayed open until the window blurred.\n         *\n         * `held` is the guard this needs. If we never opened the microphone\n         * there is nothing to close, and `release()` already returns on that —\n         * so the only thing left to decide is `preventDefault`, which is\n         * honest only for a keystroke we actually acted on.\n         */\n        const handleKeyUp = (event: KeyboardEvent): void => {\n            if (event.code !== code || !held) return;\n            event.preventDefault();\n            release();\n        };\n\n        window.addEventListener(\"keydown\", handleKeyDown);\n        window.addEventListener(\"keyup\", handleKeyUp);\n        window.addEventListener(\"blur\", release);\n\n        return () => {\n            window.removeEventListener(\"keydown\", handleKeyDown);\n            window.removeEventListener(\"keyup\", handleKeyUp);\n            window.removeEventListener(\"blur\", release);\n            release();\n        };\n    }, [code, enabled]);\n}\n"],"mappings":";;AAsBA,IAAa,IAA8C;CACvD;EAAE,MAAM;EAAS,OAAO;CAAS;CACjC;EAAE,MAAM;EAAe,OAAO;CAAgB;CAC9C;EAAE,MAAM;EAAW,OAAO;CAAe;CACzC;EAAE,MAAM;EAAa,OAAO;CAAiB;CAC7C;EAAE,MAAM;EAAa,OAAO;CAAY;AAC5C,GAGa,IAA2B;AASxC,SAAgB,EAAmB,GAAsB;CACrD,OAAO,EAAkB,MAAM,MAAQ,EAAI,SAAS,CAAI,CAAC,EAAE,SAAS;AACxE;AAYA,SAAS,EAAe,GAAqC;CACzD,IAAI,EAAE,aAAkB,cAAc,OAAO;CAC7C,IAAI,EAAO,mBAAmB,OAAO;CACrC,IAAM,IAAM,EAAO;CACnB,OAAO,MAAQ,WAAW,MAAQ,cAAc,MAAQ;AAC5D;AAmDA,SAAgB,EAAc,EAC1B,UAAO,GACP,WACA,SACA,aAAU,MACiB;CAC3B,IAAM,IAAY,EAAO;EAAE;EAAQ;CAAK,CAAC;CAKzC,AAJA,QAAgB;EACZ,EAAU,UAAU;GAAE;GAAQ;EAAK;CACvC,CAAC,GAED,QAAgB;EACZ,IAAI,CAAC,KAAW,OAAO,SAAW,KAAa;EAC/C,IAAI,IAAO,IAEL,UAAsB;GACnB,MACL,IAAO,IACP,EAAU,QAAQ,KAAK;EAC3B,GAEM,KAAiB,MAA+B;GAC9C,EAAM,SAAS,KAAQ,EAAM,UAC7B,EAAe,EAAM,MAAM,MAC/B,EAAM,eAAe,GACjB,OACJ,IAAO,IACP,EAAU,QAAQ,OAAO;EAC7B,GAkBM,KAAe,MAA+B;GAC5C,EAAM,SAAS,KAAS,MAC5B,EAAM,eAAe,GACrB,EAAQ;EACZ;EAMA,OAJA,OAAO,iBAAiB,WAAW,CAAa,GAChD,OAAO,iBAAiB,SAAS,CAAW,GAC5C,OAAO,iBAAiB,QAAQ,CAAO,SAE1B;GAIT,AAHA,OAAO,oBAAoB,WAAW,CAAa,GACnD,OAAO,oBAAoB,SAAS,CAAW,GAC/C,OAAO,oBAAoB,QAAQ,CAAO,GAC1C,EAAQ;EACZ;CACJ,GAAG,CAAC,GAAM,CAAO,CAAC;AACtB"}
+{"version":3,"file":"use-push-to-talk.js","names":["PUSH_TO_TALK_KEYS","DEFAULT_PUSH_TO_TALK_KEY","pushToTalkKeyLabel","key","code","isTypingTarget","target","tag","usePushToTalk","callbacks","useRef","useEffect","enabled","held","release","handleKeyDown","event","handleKeyUp"],"sources":["../../src/hooks/use-push-to-talk.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\n\n/** A key offered for push-to-talk, with the label a settings screen shows. */\nexport interface PushToTalkKey {\n    /** `KeyboardEvent.code`, which is layout-independent. */\n    code: string;\n    /** What to show a person. `code` itself is not a label. */\n    label: string;\n}\n\n/**\n * The keys worth offering for push-to-talk.\n *\n * Identified by `code` rather than `key` so a binding survives a layout change:\n * on an ABNT2 keyboard the `key` reported for the backquote position is not what\n * a US layout reports, while `Backquote` is the same physical key everywhere.\n *\n * Left-hand modifiers only. The right-hand ones sit under the hand that is\n * usually on the mouse, and a modifier that is also a shortcut prefix\n * (`ControlLeft` with a browser shortcut) is a deliberate trade the caller makes\n * by choosing it.\n */\nexport const PUSH_TO_TALK_KEYS: readonly PushToTalkKey[] = [\n    { code: \"Space\", label: \"Espaço\" },\n    { code: \"ControlLeft\", label: \"Ctrl esquerdo\" },\n    { code: \"AltLeft\", label: \"Alt esquerdo\" },\n    { code: \"ShiftLeft\", label: \"Shift esquerdo\" },\n    { code: \"Backquote\", label: \"Crase (`)\" },\n];\n\n/** The key a caller gets when it does not choose one. */\nexport const DEFAULT_PUSH_TO_TALK_KEY = \"Space\";\n\n/**\n * The label to show for a `KeyboardEvent.code`.\n *\n * @param code - The bound key's code.\n * @returns Its label, or the code itself for a key this list does not name —\n *     showing `\"F13\"` beats showing nothing.\n */\nexport function pushToTalkKeyLabel(code: string): string {\n    return PUSH_TO_TALK_KEYS.find((key) => key.code === code)?.label ?? code;\n}\n\n/**\n * Whether a keystroke is meant for something the person is typing into.\n *\n * Without this a push-to-talk key bound to Space opens the microphone every time\n * somebody writes a message — and the space never reaches the text field,\n * because the handler preventDefault'd it.\n *\n * @param target - The event's target.\n * @returns `true` when the keystroke belongs to a field, not to the app.\n */\nfunction isTypingTarget(target: EventTarget | null): boolean {\n    if (!(target instanceof HTMLElement)) return false;\n    if (target.isContentEditable) return true;\n    const tag = target.tagName;\n    return tag === \"INPUT\" || tag === \"TEXTAREA\" || tag === \"SELECT\";\n}\n\n/** Options for {@link usePushToTalk}. */\nexport interface UsePushToTalkOptions {\n    /** `KeyboardEvent.code` to hold. Default {@link DEFAULT_PUSH_TO_TALK_KEY}. */\n    code?: string;\n    /** Called once when the key goes down. */\n    onDown: () => void;\n    /** Called when the key comes up, the window blurs, or the hook unmounts. */\n    onUp: () => void;\n    /**\n     * Whether the binding is live. Default `true`.\n     *\n     * Turning it off releases first, so flipping a call from push-to-talk to an\n     * open microphone while the key is held does not leave `onUp` unfired.\n     */\n    enabled?: boolean;\n}\n\n/**\n * Hold a key to transmit; release it to go silent again.\n *\n * Looks like `keydown`/`keyup` and is not, because three things go wrong:\n *\n * 1. **`blur` has to release.** Alt-tabbing away while holding the key means the\n *    browser never sees the `keyup`, and the microphone stays open for as long as\n *    the person is looking at another window — exactly what push-to-talk exists\n *    to prevent.\n * 2. **Auto-repeat has to be ignored.** A held key repeats at the keyboard's rate,\n *    and without the `repeat` check `onDown` fires on every one of them.\n * 3. **A text field has to win.** Space bound to push-to-talk with the focus in an\n *    `<input>` means the space never reaches the message being written.\n *\n * Unmounting releases too, for the same reason `blur` does: the callback that\n * stops transmitting has to run even when the component holding it goes away\n * mid-press.\n *\n * The callbacks are read through a ref that a commit-time effect refreshes, so\n * passing inline arrows neither tears the listeners down on every render nor\n * writes to the ref during one — a render React discards would leave the ref\n * pointing at callbacks that never became the UI.\n *\n * @param options - See {@link UsePushToTalkOptions}.\n *\n * @example\n * usePushToTalk({\n *     code: \"Space\",\n *     onDown: () => setMicEnabled(true),\n *     onUp: () => setMicEnabled(false),\n * });\n */\nexport function usePushToTalk({\n    code = DEFAULT_PUSH_TO_TALK_KEY,\n    onDown,\n    onUp,\n    enabled = true,\n}: UsePushToTalkOptions): void {\n    const callbacks = useRef({ onDown, onUp });\n    useEffect(() => {\n        callbacks.current = { onDown, onUp };\n    });\n\n    useEffect(() => {\n        if (!enabled || typeof window === \"undefined\") return;\n        let held = false;\n\n        const release = (): void => {\n            if (!held) return;\n            held = false;\n            callbacks.current.onUp();\n        };\n\n        const handleKeyDown = (event: KeyboardEvent): void => {\n            if (event.code !== code || event.repeat) return;\n            if (isTypingTarget(event.target)) return;\n            event.preventDefault();\n            if (held) return;\n            held = true;\n            callbacks.current.onDown();\n        };\n\n        /**\n         * Release on the way up, and never mind where the keystroke landed.\n         *\n         * The field guard belongs on the way **down** — it is what stops a\n         * push-to-talk bound to Space from opening the microphone every time\n         * somebody writes a message. On the way up it did the opposite of its\n         * job: `keyup` is delivered to whatever is focused when the key rises,\n         * not to what was focused when it fell, so clicking into an input while\n         * still holding sent the release into the guard and left `held` true.\n         * The microphone stayed open until the window blurred.\n         *\n         * `held` is the guard this needs. If we never opened the microphone\n         * there is nothing to close, and `release()` already returns on that —\n         * so the only thing left to decide is `preventDefault`, which is\n         * honest only for a keystroke we actually acted on.\n         */\n        const handleKeyUp = (event: KeyboardEvent): void => {\n            if (event.code !== code || !held) return;\n            event.preventDefault();\n            release();\n        };\n\n        window.addEventListener(\"keydown\", handleKeyDown);\n        window.addEventListener(\"keyup\", handleKeyUp);\n        window.addEventListener(\"blur\", release);\n\n        return () => {\n            window.removeEventListener(\"keydown\", handleKeyDown);\n            window.removeEventListener(\"keyup\", handleKeyUp);\n            window.removeEventListener(\"blur\", release);\n            release();\n        };\n    }, [code, enabled]);\n}\n"],"mappings":";;AAsBA,IAAaA,IAA8C;CACvD;EAAE,MAAM;EAAS,OAAO;CAAS;CACjC;EAAE,MAAM;EAAe,OAAO;CAAgB;CAC9C;EAAE,MAAM;EAAW,OAAO;CAAe;CACzC;EAAE,MAAM;EAAa,OAAO;CAAiB;CAC7C;EAAE,MAAM;EAAa,OAAO;CAAY;AAC5C,GAGaC,IAA2B;AASxC,SAAgBC,EAAmB,GAAsB;CACrD,OAAOF,EAAkB,MAAM,MAAQG,EAAI,SAASC,CAAI,CAAC,EAAE,SAASA;AACxE;AAYA,SAASC,EAAe,GAAqC;CACzD,IAAI,EAAEC,aAAkB,cAAc,OAAO;CAC7C,IAAIA,EAAO,mBAAmB,OAAO;CACrC,IAAMC,IAAMD,EAAO;CACnB,OAAOC,MAAQ,WAAWA,MAAQ,cAAcA,MAAQ;AAC5D;AAmDA,SAAgBC,EAAc,EAC1B,UAAOP,GACP,WACA,SACA,aAAU,MACiB;CAC3B,IAAMQ,IAAYC,EAAO;EAAE;EAAQ;CAAK,CAAC;CAKzC,AAJAC,QAAgB;EACZ,EAAU,UAAU;GAAE;GAAQ;EAAK;CACvC,CAAC,GAEDA,QAAgB;EACZ,IAAI,CAACC,KAAW,OAAO,SAAW,KAAa;EAC/C,IAAIC,IAAO,IAELC,UAAsB;GACxB,AAAKD,MACL,IAAO,IACPJ,EAAU,QAAQ,KAAK;EAC3B,GAEMM,KAAiB,MAA+B;GAClD,AAAIC,EAAM,SAASZ,KAAQY,EAAM,UAC7BX,EAAeW,EAAM,MAAM,MAC/BA,EAAM,eAAe,GACjB,OACJ,IAAO,IACPP,EAAU,QAAQ,OAAO;EAC7B,GAkBMQ,KAAe,MAA+B;GAChD,AAAID,EAAM,SAASZ,KAASS,MAC5BG,EAAM,eAAe,GACrBF,EAAQ;EACZ;EAMA,OAJA,OAAO,iBAAiB,WAAWC,CAAa,GAChD,OAAO,iBAAiB,SAASE,CAAW,GAC5C,OAAO,iBAAiB,QAAQH,CAAO,SAE1B;GAIT,AAHA,OAAO,oBAAoB,WAAWC,CAAa,GACnD,OAAO,oBAAoB,SAASE,CAAW,GAC/C,OAAO,oBAAoB,QAAQH,CAAO,GAC1CA,EAAQ;EACZ;CACJ,GAAG,CAACV,GAAMQ,CAAO,CAAC;AACtB"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-queue.cjs","names":[],"sources":["../../src/hooks/use-queue.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface UseQueueOptions<T> {\n    initialValues?: T[];\n    limit?: number;\n}\n\nexport interface UseQueueResult<T> {\n    /** Items currently held within the queue (up to `limit`). */\n    queue: T[];\n    /** Append items; overflow beyond `limit` is held back, not dropped. */\n    add: (...items: T[]) => void;\n    /** Replace the held queue via a mapper over the current held items. */\n    update: (fn: (state: T[]) => T[]) => void;\n    /** Drop all currently held (visible) items, keeping any overflow. */\n    cleanQueue: () => void;\n    /** Number of visible items in the queue. */\n    size: number;\n}\n\n/**\n * FIFO queue with an optional `limit`. When more items are added than `limit`\n * allows, the surplus is kept in an internal overflow buffer and surfaces into\n * `queue` as room frees up (e.g. after `cleanQueue`). Loosely mirrors Mantine's\n * `useQueue` shape.\n *\n * @typeParam T - element type.\n * @param options - `initialValues` and `limit` (default limit `Infinity`).\n * @returns `{ queue, add, update, cleanQueue, size }`.\n */\nexport function useQueue<T>(options: UseQueueOptions<T> = {}): UseQueueResult<T> {\n    const { initialValues = [], limit = Infinity } = options;\n\n    const [state, setState] = useState<{ queue: T[]; overflow: T[] }>(() => ({\n        queue: initialValues.slice(0, limit),\n        overflow: initialValues.slice(limit),\n    }));\n\n    const add = useCallback(\n        (...items: T[]): void => {\n            setState((current) => {\n                const all = [...current.queue, ...current.overflow, ...items];\n                return {\n                    queue: all.slice(0, limit),\n                    overflow: all.slice(limit),\n                };\n            });\n        },\n        [limit],\n    );\n\n    const update = useCallback(\n        (fn: (queueState: T[]) => T[]): void => {\n            setState((current) => {\n                const all = [...fn(current.queue), ...current.overflow];\n                return {\n                    queue: all.slice(0, limit),\n                    overflow: all.slice(limit),\n                };\n            });\n        },\n        [limit],\n    );\n\n    const cleanQueue = useCallback((): void => {\n        setState((current) => ({\n            queue: current.overflow.slice(0, limit),\n            overflow: current.overflow.slice(limit),\n        }));\n    }, [limit]);\n\n    return useMemo<UseQueueResult<T>>(\n        () => ({\n            queue: state.queue,\n            add,\n            update,\n            cleanQueue,\n            size: state.queue.length,\n        }),\n        [state.queue, add, update, cleanQueue],\n    );\n}\n"],"mappings":"uBA8BA,SAAgB,EAAY,EAA8B,CAAC,EAAsB,CAC7E,GAAM,CAAE,gBAAgB,CAAC,EAAG,QAAQ,KAAa,EAE3C,CAAC,EAAO,IAAA,EAAY,EAAA,SAAA,MAA+C,CACrE,MAAO,EAAc,MAAM,EAAG,CAAK,EACnC,SAAU,EAAc,MAAM,CAAK,CACvC,EAAE,EAEI,GAAA,EAAM,EAAA,YAAA,EACP,GAAG,IAAqB,CACrB,EAAU,GAAY,CAClB,IAAM,EAAM,CAAC,GAAG,EAAQ,MAAO,GAAG,EAAQ,SAAU,GAAG,CAAK,EAC5D,MAAO,CACH,MAAO,EAAI,MAAM,EAAG,CAAK,EACzB,SAAU,EAAI,MAAM,CAAK,CAC7B,CACJ,CAAC,CACL,EACA,CAAC,CAAK,CACV,EAEM,GAAA,EAAS,EAAA,YAAA,CACV,GAAuC,CACpC,EAAU,GAAY,CAClB,IAAM,EAAM,CAAC,GAAG,EAAG,EAAQ,KAAK,EAAG,GAAG,EAAQ,QAAQ,EACtD,MAAO,CACH,MAAO,EAAI,MAAM,EAAG,CAAK,EACzB,SAAU,EAAI,MAAM,CAAK,CAC7B,CACJ,CAAC,CACL,EACA,CAAC,CAAK,CACV,EAEM,GAAA,EAAa,EAAA,YAAA,KAAwB,CACvC,EAAU,IAAa,CACnB,MAAO,EAAQ,SAAS,MAAM,EAAG,CAAK,EACtC,SAAU,EAAQ,SAAS,MAAM,CAAK,CAC1C,EAAE,CACN,EAAG,CAAC,CAAK,CAAC,EAEV,OAAA,EAAO,EAAA,QAAA,MACI,CACH,MAAO,EAAM,MACb,MACA,SACA,aACA,KAAM,EAAM,MAAM,MACtB,GACA,CAAC,EAAM,MAAO,EAAK,EAAQ,CAAU,CACzC,CACJ"}
+{"version":3,"file":"use-queue.cjs","names":["useState","useCallback","useMemo","react","useQueue","options","state","setState","initialValues","limit","add","items","all","current","update","fn","cleanQueue"],"sources":["../../src/hooks/use-queue.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface UseQueueOptions<T> {\n    initialValues?: T[];\n    limit?: number;\n}\n\nexport interface UseQueueResult<T> {\n    /** Items currently held within the queue (up to `limit`). */\n    queue: T[];\n    /** Append items; overflow beyond `limit` is held back, not dropped. */\n    add: (...items: T[]) => void;\n    /** Replace the held queue via a mapper over the current held items. */\n    update: (fn: (state: T[]) => T[]) => void;\n    /** Drop all currently held (visible) items, keeping any overflow. */\n    cleanQueue: () => void;\n    /** Number of visible items in the queue. */\n    size: number;\n}\n\n/**\n * FIFO queue with an optional `limit`. When more items are added than `limit`\n * allows, the surplus is kept in an internal overflow buffer and surfaces into\n * `queue` as room frees up (e.g. after `cleanQueue`). Loosely mirrors Mantine's\n * `useQueue` shape.\n *\n * @typeParam T - element type.\n * @param options - `initialValues` and `limit` (default limit `Infinity`).\n * @returns `{ queue, add, update, cleanQueue, size }`.\n */\nexport function useQueue<T>(options: UseQueueOptions<T> = {}): UseQueueResult<T> {\n    const { initialValues = [], limit = Infinity } = options;\n\n    const [state, setState] = useState<{ queue: T[]; overflow: T[] }>(() => ({\n        queue: initialValues.slice(0, limit),\n        overflow: initialValues.slice(limit),\n    }));\n\n    const add = useCallback(\n        (...items: T[]): void => {\n            setState((current) => {\n                const all = [...current.queue, ...current.overflow, ...items];\n                return {\n                    queue: all.slice(0, limit),\n                    overflow: all.slice(limit),\n                };\n            });\n        },\n        [limit],\n    );\n\n    const update = useCallback(\n        (fn: (queueState: T[]) => T[]): void => {\n            setState((current) => {\n                const all = [...fn(current.queue), ...current.overflow];\n                return {\n                    queue: all.slice(0, limit),\n                    overflow: all.slice(limit),\n                };\n            });\n        },\n        [limit],\n    );\n\n    const cleanQueue = useCallback((): void => {\n        setState((current) => ({\n            queue: current.overflow.slice(0, limit),\n            overflow: current.overflow.slice(limit),\n        }));\n    }, [limit]);\n\n    return useMemo<UseQueueResult<T>>(\n        () => ({\n            queue: state.queue,\n            add,\n            update,\n            cleanQueue,\n            size: state.queue.length,\n        }),\n        [state.queue, add, update, cleanQueue],\n    );\n}\n"],"mappings":"A,uBA8BA,SAAgBI,EAAY,EAA8B,CAAC,EAAsB,CAC7E,GAAM,CAAE,gBAAgB,CAAC,EAAG,QAAQ,KAAaC,EAE3C,CAACC,EAAOC,IAAA,EAAYP,EAAAA,SAAAA,MAA+C,CACrE,MAAOQ,EAAc,MAAM,EAAGC,CAAK,EACnC,SAAUD,EAAc,MAAMC,CAAK,CACvC,EAAE,EAEIC,GAAA,EAAMT,EAAAA,YAAAA,EACP,GAAGU,IAAqB,CACrBJ,EAAU,GAAY,CAClB,IAAMK,EAAM,CAAC,GAAGC,EAAQ,MAAO,GAAGA,EAAQ,SAAU,GAAGF,CAAK,EAC5D,MAAO,CACH,MAAOC,EAAI,MAAM,EAAGH,CAAK,EACzB,SAAUG,EAAI,MAAMH,CAAK,CAC7B,CACJ,CAAC,CACL,EACA,CAACA,CAAK,CACV,EAEMK,GAAA,EAASb,EAAAA,YAAAA,CACV,GAAuC,CACpCM,EAAU,GAAY,CAClB,IAAMK,EAAM,CAAC,GAAGG,EAAGF,EAAQ,KAAK,EAAG,GAAGA,EAAQ,QAAQ,EACtD,MAAO,CACH,MAAOD,EAAI,MAAM,EAAGH,CAAK,EACzB,SAAUG,EAAI,MAAMH,CAAK,CAC7B,CACJ,CAAC,CACL,EACA,CAACA,CAAK,CACV,EAEMO,GAAA,EAAaf,EAAAA,YAAAA,KAAwB,CACvCM,EAAU,IAAa,CACnB,MAAOM,EAAQ,SAAS,MAAM,EAAGJ,CAAK,EACtC,SAAUI,EAAQ,SAAS,MAAMJ,CAAK,CAC1C,EAAE,CACN,EAAG,CAACA,CAAK,CAAC,EAEV,OAAA,EAAOP,EAAAA,QAAAA,MACI,CACH,MAAOI,EAAM,MACb,MACA,SACA,aACA,KAAMA,EAAM,MAAM,MACtB,GACA,CAACA,EAAM,MAAOI,EAAKI,EAAQE,CAAU,CACzC,CACJ,C"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-queue.js","names":[],"sources":["../../src/hooks/use-queue.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface UseQueueOptions<T> {\n    initialValues?: T[];\n    limit?: number;\n}\n\nexport interface UseQueueResult<T> {\n    /** Items currently held within the queue (up to `limit`). */\n    queue: T[];\n    /** Append items; overflow beyond `limit` is held back, not dropped. */\n    add: (...items: T[]) => void;\n    /** Replace the held queue via a mapper over the current held items. */\n    update: (fn: (state: T[]) => T[]) => void;\n    /** Drop all currently held (visible) items, keeping any overflow. */\n    cleanQueue: () => void;\n    /** Number of visible items in the queue. */\n    size: number;\n}\n\n/**\n * FIFO queue with an optional `limit`. When more items are added than `limit`\n * allows, the surplus is kept in an internal overflow buffer and surfaces into\n * `queue` as room frees up (e.g. after `cleanQueue`). Loosely mirrors Mantine's\n * `useQueue` shape.\n *\n * @typeParam T - element type.\n * @param options - `initialValues` and `limit` (default limit `Infinity`).\n * @returns `{ queue, add, update, cleanQueue, size }`.\n */\nexport function useQueue<T>(options: UseQueueOptions<T> = {}): UseQueueResult<T> {\n    const { initialValues = [], limit = Infinity } = options;\n\n    const [state, setState] = useState<{ queue: T[]; overflow: T[] }>(() => ({\n        queue: initialValues.slice(0, limit),\n        overflow: initialValues.slice(limit),\n    }));\n\n    const add = useCallback(\n        (...items: T[]): void => {\n            setState((current) => {\n                const all = [...current.queue, ...current.overflow, ...items];\n                return {\n                    queue: all.slice(0, limit),\n                    overflow: all.slice(limit),\n                };\n            });\n        },\n        [limit],\n    );\n\n    const update = useCallback(\n        (fn: (queueState: T[]) => T[]): void => {\n            setState((current) => {\n                const all = [...fn(current.queue), ...current.overflow];\n                return {\n                    queue: all.slice(0, limit),\n                    overflow: all.slice(limit),\n                };\n            });\n        },\n        [limit],\n    );\n\n    const cleanQueue = useCallback((): void => {\n        setState((current) => ({\n            queue: current.overflow.slice(0, limit),\n            overflow: current.overflow.slice(limit),\n        }));\n    }, [limit]);\n\n    return useMemo<UseQueueResult<T>>(\n        () => ({\n            queue: state.queue,\n            add,\n            update,\n            cleanQueue,\n            size: state.queue.length,\n        }),\n        [state.queue, add, update, cleanQueue],\n    );\n}\n"],"mappings":";;AA8BA,SAAgB,EAAY,IAA8B,CAAC,GAAsB;CAC7E,IAAM,EAAE,mBAAgB,CAAC,GAAG,WAAQ,aAAa,GAE3C,CAAC,GAAO,KAAY,SAA+C;EACrE,OAAO,EAAc,MAAM,GAAG,CAAK;EACnC,UAAU,EAAc,MAAM,CAAK;CACvC,EAAE,GAEI,IAAM,GACP,GAAG,MAAqB;EACrB,GAAU,MAAY;GAClB,IAAM,IAAM;IAAC,GAAG,EAAQ;IAAO,GAAG,EAAQ;IAAU,GAAG;GAAK;GAC5D,OAAO;IACH,OAAO,EAAI,MAAM,GAAG,CAAK;IACzB,UAAU,EAAI,MAAM,CAAK;GAC7B;EACJ,CAAC;CACL,GACA,CAAC,CAAK,CACV,GAEM,IAAS,GACV,MAAuC;EACpC,GAAU,MAAY;GAClB,IAAM,IAAM,CAAC,GAAG,EAAG,EAAQ,KAAK,GAAG,GAAG,EAAQ,QAAQ;GACtD,OAAO;IACH,OAAO,EAAI,MAAM,GAAG,CAAK;IACzB,UAAU,EAAI,MAAM,CAAK;GAC7B;EACJ,CAAC;CACL,GACA,CAAC,CAAK,CACV,GAEM,IAAa,QAAwB;EACvC,GAAU,OAAa;GACnB,OAAO,EAAQ,SAAS,MAAM,GAAG,CAAK;GACtC,UAAU,EAAQ,SAAS,MAAM,CAAK;EAC1C,EAAE;CACN,GAAG,CAAC,CAAK,CAAC;CAEV,OAAO,SACI;EACH,OAAO,EAAM;EACb;EACA;EACA;EACA,MAAM,EAAM,MAAM;CACtB,IACA;EAAC,EAAM;EAAO;EAAK;EAAQ;CAAU,CACzC;AACJ"}
+{"version":3,"file":"use-queue.js","names":["useQueue","options","state","setState","useState","initialValues","limit","add","useCallback","items","all","current","update","fn","cleanQueue","useMemo"],"sources":["../../src/hooks/use-queue.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface UseQueueOptions<T> {\n    initialValues?: T[];\n    limit?: number;\n}\n\nexport interface UseQueueResult<T> {\n    /** Items currently held within the queue (up to `limit`). */\n    queue: T[];\n    /** Append items; overflow beyond `limit` is held back, not dropped. */\n    add: (...items: T[]) => void;\n    /** Replace the held queue via a mapper over the current held items. */\n    update: (fn: (state: T[]) => T[]) => void;\n    /** Drop all currently held (visible) items, keeping any overflow. */\n    cleanQueue: () => void;\n    /** Number of visible items in the queue. */\n    size: number;\n}\n\n/**\n * FIFO queue with an optional `limit`. When more items are added than `limit`\n * allows, the surplus is kept in an internal overflow buffer and surfaces into\n * `queue` as room frees up (e.g. after `cleanQueue`). Loosely mirrors Mantine's\n * `useQueue` shape.\n *\n * @typeParam T - element type.\n * @param options - `initialValues` and `limit` (default limit `Infinity`).\n * @returns `{ queue, add, update, cleanQueue, size }`.\n */\nexport function useQueue<T>(options: UseQueueOptions<T> = {}): UseQueueResult<T> {\n    const { initialValues = [], limit = Infinity } = options;\n\n    const [state, setState] = useState<{ queue: T[]; overflow: T[] }>(() => ({\n        queue: initialValues.slice(0, limit),\n        overflow: initialValues.slice(limit),\n    }));\n\n    const add = useCallback(\n        (...items: T[]): void => {\n            setState((current) => {\n                const all = [...current.queue, ...current.overflow, ...items];\n                return {\n                    queue: all.slice(0, limit),\n                    overflow: all.slice(limit),\n                };\n            });\n        },\n        [limit],\n    );\n\n    const update = useCallback(\n        (fn: (queueState: T[]) => T[]): void => {\n            setState((current) => {\n                const all = [...fn(current.queue), ...current.overflow];\n                return {\n                    queue: all.slice(0, limit),\n                    overflow: all.slice(limit),\n                };\n            });\n        },\n        [limit],\n    );\n\n    const cleanQueue = useCallback((): void => {\n        setState((current) => ({\n            queue: current.overflow.slice(0, limit),\n            overflow: current.overflow.slice(limit),\n        }));\n    }, [limit]);\n\n    return useMemo<UseQueueResult<T>>(\n        () => ({\n            queue: state.queue,\n            add,\n            update,\n            cleanQueue,\n            size: state.queue.length,\n        }),\n        [state.queue, add, update, cleanQueue],\n    );\n}\n"],"mappings":";;AA8BA,SAAgBA,EAAY,IAA8B,CAAC,GAAsB;CAC7E,IAAM,EAAE,mBAAgB,CAAC,GAAG,WAAQ,aAAaC,GAE3C,CAACC,GAAOC,KAAYC,SAA+C;EACrE,OAAOC,EAAc,MAAM,GAAGC,CAAK;EACnC,UAAUD,EAAc,MAAMC,CAAK;CACvC,EAAE,GAEIC,IAAMC,GACP,GAAGC,MAAqB;EACrB,GAAU,MAAY;GAClB,IAAMC,IAAM;IAAC,GAAGC,EAAQ;IAAO,GAAGA,EAAQ;IAAU,GAAGF;GAAK;GAC5D,OAAO;IACH,OAAOC,EAAI,MAAM,GAAGJ,CAAK;IACzB,UAAUI,EAAI,MAAMJ,CAAK;GAC7B;EACJ,CAAC;CACL,GACA,CAACA,CAAK,CACV,GAEMM,IAASJ,GACV,MAAuC;EACpC,GAAU,MAAY;GAClB,IAAME,IAAM,CAAC,GAAGG,EAAGF,EAAQ,KAAK,GAAG,GAAGA,EAAQ,QAAQ;GACtD,OAAO;IACH,OAAOD,EAAI,MAAM,GAAGJ,CAAK;IACzB,UAAUI,EAAI,MAAMJ,CAAK;GAC7B;EACJ,CAAC;CACL,GACA,CAACA,CAAK,CACV,GAEMQ,IAAaN,QAAwB;EACvC,GAAU,OAAa;GACnB,OAAOG,EAAQ,SAAS,MAAM,GAAGL,CAAK;GACtC,UAAUK,EAAQ,SAAS,MAAML,CAAK;EAC1C,EAAE;CACN,GAAG,CAACA,CAAK,CAAC;CAEV,OAAOS,SACI;EACH,OAAOb,EAAM;EACb;EACA;EACA;EACA,MAAMA,EAAM,MAAM;CACtB,IACA;EAACA,EAAM;EAAOK;EAAKK;EAAQE;CAAU,CACzC;AACJ"}

package/dist/hooks/use-resize-observer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-resize-observer.cjs","names":[],"sources":["../../src/hooks/use-resize-observer.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\n\nexport interface ElementSize {\n    width: number;\n    height: number;\n}\n\n/**\n * Track size changes of a DOM element via `ResizeObserver`.\n * Returns `null` until the first measurement.\n */\nexport function useResizeObserver(ref: RefObject<Element | null>): ElementSize | null {\n    const [size, setSize] = useState<ElementSize | null>(null);\n\n    useEffect(() => {\n        const target = ref.current;\n        if (!target || typeof ResizeObserver === \"undefined\") return;\n\n        const observer = new ResizeObserver((entries) => {\n            const entry = entries[0];\n            if (!entry) return;\n            const box = entry.contentRect;\n            setSize({ width: box.width, height: box.height });\n        });\n\n        observer.observe(target);\n        return () => observer.disconnect();\n    }, [ref]);\n\n    return size;\n}\n"],"mappings":"uBAYA,SAAgB,EAAkB,EAAoD,CAClF,GAAM,CAAC,EAAM,IAAA,EAAW,EAAA,SAAA,CAA6B,IAAI,EAiBzD,OAfA,EAAA,EAAA,UAAA,KAAgB,CACZ,IAAM,EAAS,EAAI,QACnB,GAAI,CAAC,GAAU,OAAO,eAAmB,IAAa,OAEtD,IAAM,EAAW,IAAI,eAAgB,GAAY,CAC7C,IAAM,EAAQ,EAAQ,GACtB,GAAI,CAAC,EAAO,OACZ,IAAM,EAAM,EAAM,YAClB,EAAQ,CAAE,MAAO,EAAI,MAAO,OAAQ,EAAI,MAAO,CAAC,CACpD,CAAC,EAGD,OADA,EAAS,QAAQ,CAAM,MACV,EAAS,WAAW,CACrC,EAAG,CAAC,CAAG,CAAC,EAED,CACX"}
+{"version":3,"file":"use-resize-observer.cjs","names":["useState","react","useResizeObserver","size","setSize","target","ref","observer","entry","entries","box"],"sources":["../../src/hooks/use-resize-observer.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\n\nexport interface ElementSize {\n    width: number;\n    height: number;\n}\n\n/**\n * Track size changes of a DOM element via `ResizeObserver`.\n * Returns `null` until the first measurement.\n */\nexport function useResizeObserver(ref: RefObject<Element | null>): ElementSize | null {\n    const [size, setSize] = useState<ElementSize | null>(null);\n\n    useEffect(() => {\n        const target = ref.current;\n        if (!target || typeof ResizeObserver === \"undefined\") return;\n\n        const observer = new ResizeObserver((entries) => {\n            const entry = entries[0];\n            if (!entry) return;\n            const box = entry.contentRect;\n            setSize({ width: box.width, height: box.height });\n        });\n\n        observer.observe(target);\n        return () => observer.disconnect();\n    }, [ref]);\n\n    return size;\n}\n"],"mappings":"A,uBAYA,SAAgBE,EAAkB,EAAoD,CAClF,GAAM,CAACC,EAAMC,IAAA,EAAWJ,EAAAA,SAAAA,CAA6B,IAAI,EAiBzD,OAfA,EAAAC,EAAA,UAAA,KAAgB,CACZ,IAAMI,EAASC,EAAI,QACnB,GAAI,CAACD,GAAU,OAAO,eAAmB,IAAa,OAEtD,IAAME,EAAW,IAAI,eAAgB,GAAY,CAC7C,IAAMC,EAAQC,EAAQ,GACtB,GAAI,CAACD,EAAO,OACZ,IAAME,EAAMF,EAAM,YAClBJ,EAAQ,CAAE,MAAOM,EAAI,MAAO,OAAQA,EAAI,MAAO,CAAC,CACpD,CAAC,EAGD,OADAH,EAAS,QAAQF,CAAM,MACVE,EAAS,WAAW,CACrC,EAAG,CAACD,CAAG,CAAC,EAEDH,CACX,C"}

package/dist/hooks/use-resize-observer.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-resize-observer.js","names":[],"sources":["../../src/hooks/use-resize-observer.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\n\nexport interface ElementSize {\n    width: number;\n    height: number;\n}\n\n/**\n * Track size changes of a DOM element via `ResizeObserver`.\n * Returns `null` until the first measurement.\n */\nexport function useResizeObserver(ref: RefObject<Element | null>): ElementSize | null {\n    const [size, setSize] = useState<ElementSize | null>(null);\n\n    useEffect(() => {\n        const target = ref.current;\n        if (!target || typeof ResizeObserver === \"undefined\") return;\n\n        const observer = new ResizeObserver((entries) => {\n            const entry = entries[0];\n            if (!entry) return;\n            const box = entry.contentRect;\n            setSize({ width: box.width, height: box.height });\n        });\n\n        observer.observe(target);\n        return () => observer.disconnect();\n    }, [ref]);\n\n    return size;\n}\n"],"mappings":";;AAYA,SAAgB,EAAkB,GAAoD;CAClF,IAAM,CAAC,GAAM,KAAW,EAA6B,IAAI;CAiBzD,OAfA,QAAgB;EACZ,IAAM,IAAS,EAAI;EACnB,IAAI,CAAC,KAAU,OAAO,iBAAmB,KAAa;EAEtD,IAAM,IAAW,IAAI,gBAAgB,MAAY;GAC7C,IAAM,IAAQ,EAAQ;GACtB,IAAI,CAAC,GAAO;GACZ,IAAM,IAAM,EAAM;GAClB,EAAQ;IAAE,OAAO,EAAI;IAAO,QAAQ,EAAI;GAAO,CAAC;EACpD,CAAC;EAGD,OADA,EAAS,QAAQ,CAAM,SACV,EAAS,WAAW;CACrC,GAAG,CAAC,CAAG,CAAC,GAED;AACX"}
+{"version":3,"file":"use-resize-observer.js","names":["useResizeObserver","size","setSize","useState","useEffect","target","ref","observer","entry","entries","box"],"sources":["../../src/hooks/use-resize-observer.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\n\nexport interface ElementSize {\n    width: number;\n    height: number;\n}\n\n/**\n * Track size changes of a DOM element via `ResizeObserver`.\n * Returns `null` until the first measurement.\n */\nexport function useResizeObserver(ref: RefObject<Element | null>): ElementSize | null {\n    const [size, setSize] = useState<ElementSize | null>(null);\n\n    useEffect(() => {\n        const target = ref.current;\n        if (!target || typeof ResizeObserver === \"undefined\") return;\n\n        const observer = new ResizeObserver((entries) => {\n            const entry = entries[0];\n            if (!entry) return;\n            const box = entry.contentRect;\n            setSize({ width: box.width, height: box.height });\n        });\n\n        observer.observe(target);\n        return () => observer.disconnect();\n    }, [ref]);\n\n    return size;\n}\n"],"mappings":";;AAYA,SAAgBA,EAAkB,GAAoD;CAClF,IAAM,CAACC,GAAMC,KAAWC,EAA6B,IAAI;CAiBzD,OAfAC,QAAgB;EACZ,IAAMC,IAASC,EAAI;EACnB,IAAI,CAACD,KAAU,OAAO,iBAAmB,KAAa;EAEtD,IAAME,IAAW,IAAI,gBAAgB,MAAY;GAC7C,IAAMC,IAAQC,EAAQ;GACtB,IAAI,CAACD,GAAO;GACZ,IAAME,IAAMF,EAAM;GAClB,EAAQ;IAAE,OAAOE,EAAI;IAAO,QAAQA,EAAI;GAAO,CAAC;EACpD,CAAC;EAGD,OADAH,EAAS,QAAQF,CAAM,SACVE,EAAS,WAAW;CACrC,GAAG,CAACD,CAAG,CAAC,GAEDL;AACX"}

package/dist/hooks/use-scroll-lock.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-scroll-lock.cjs","names":[],"sources":["../../src/hooks/use-scroll-lock.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\n/**\n * Lock `<body>` scroll while `active` is true. Restores the previous overflow\n * value on unmount. Safe to nest: stacks the restoration via a counter.\n */\nexport function useScrollLock(active: boolean): void {\n    useEffect(() => {\n        if (!active || typeof document === \"undefined\") return;\n        const body = document.body;\n        const previous = body.style.overflow;\n        body.style.overflow = \"hidden\";\n        return () => {\n            body.style.overflow = previous;\n        };\n    }, [active]);\n}\n"],"mappings":"uBAMA,SAAgB,EAAc,EAAuB,EACjD,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,CAAC,GAAU,OAAO,SAAa,IAAa,OAChD,IAAM,EAAO,SAAS,KAChB,EAAW,EAAK,MAAM,SAE5B,MADA,GAAK,MAAM,SAAW,aACT,CACT,EAAK,MAAM,SAAW,CAC1B,CACJ,EAAG,CAAC,CAAM,CAAC,CACf"}
+{"version":3,"file":"use-scroll-lock.cjs","names":["react","useScrollLock","active","body","previous"],"sources":["../../src/hooks/use-scroll-lock.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\n/**\n * Lock `<body>` scroll while `active` is true. Restores the previous overflow\n * value on unmount. Safe to nest: stacks the restoration via a counter.\n */\nexport function useScrollLock(active: boolean): void {\n    useEffect(() => {\n        if (!active || typeof document === \"undefined\") return;\n        const body = document.body;\n        const previous = body.style.overflow;\n        body.style.overflow = \"hidden\";\n        return () => {\n            body.style.overflow = previous;\n        };\n    }, [active]);\n}\n"],"mappings":"A,uBAMA,SAAgBC,EAAc,EAAuB,EACjD,EAAAD,EAAA,UAAA,KAAgB,CACZ,GAAI,CAACE,GAAU,OAAO,SAAa,IAAa,OAChD,IAAMC,EAAO,SAAS,KAChBC,EAAWD,EAAK,MAAM,SAE5B,MADA,GAAK,MAAM,SAAW,aACT,CACT,EAAK,MAAM,SAAWC,CAC1B,CACJ,EAAG,CAACF,CAAM,CAAC,CACf,C"}

package/dist/hooks/use-scroll-lock.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-scroll-lock.js","names":[],"sources":["../../src/hooks/use-scroll-lock.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\n/**\n * Lock `<body>` scroll while `active` is true. Restores the previous overflow\n * value on unmount. Safe to nest: stacks the restoration via a counter.\n */\nexport function useScrollLock(active: boolean): void {\n    useEffect(() => {\n        if (!active || typeof document === \"undefined\") return;\n        const body = document.body;\n        const previous = body.style.overflow;\n        body.style.overflow = \"hidden\";\n        return () => {\n            body.style.overflow = previous;\n        };\n    }, [active]);\n}\n"],"mappings":";;AAMA,SAAgB,EAAc,GAAuB;CACjD,QAAgB;EACZ,IAAI,CAAC,KAAU,OAAO,WAAa,KAAa;EAChD,IAAM,IAAO,SAAS,MAChB,IAAW,EAAK,MAAM;EAE5B,OADA,EAAK,MAAM,WAAW,gBACT;GACT,EAAK,MAAM,WAAW;EAC1B;CACJ,GAAG,CAAC,CAAM,CAAC;AACf"}
+{"version":3,"file":"use-scroll-lock.js","names":["useScrollLock","active","body","previous"],"sources":["../../src/hooks/use-scroll-lock.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\n/**\n * Lock `<body>` scroll while `active` is true. Restores the previous overflow\n * value on unmount. Safe to nest: stacks the restoration via a counter.\n */\nexport function useScrollLock(active: boolean): void {\n    useEffect(() => {\n        if (!active || typeof document === \"undefined\") return;\n        const body = document.body;\n        const previous = body.style.overflow;\n        body.style.overflow = \"hidden\";\n        return () => {\n            body.style.overflow = previous;\n        };\n    }, [active]);\n}\n"],"mappings":";;AAMA,SAAgBA,EAAc,GAAuB;CACjD,QAAgB;EACZ,IAAI,CAACC,KAAU,OAAO,WAAa,KAAa;EAChD,IAAMC,IAAO,SAAS,MAChBC,IAAWD,EAAK,MAAM;EAE5B,OADA,EAAK,MAAM,WAAW,gBACT;GACT,EAAK,MAAM,WAAWC;EAC1B;CACJ,GAAG,CAACF,CAAM,CAAC;AACf"}

package/dist/hooks/use-scroll-overflow.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-scroll-overflow.cjs","names":[],"sources":["../../src/hooks/use-scroll-overflow.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\n\n/** Which axis to watch for overflow. */\nexport type ScrollOverflowAxis = \"horizontal\" | \"vertical\" | \"both\";\n\n/**\n * Track whether an element's content currently overflows its box.\n *\n * The use this exists for is keyboard access. A scroll container holding no\n * focusable content is unreachable by keyboard: the user can see there is more\n * content past the edge and has no way to get to it, because focus never lands\n * anywhere the arrow keys would scroll. Giving the container `tabIndex={0}`\n * fixes it — but doing that unconditionally puts a tab stop on every such\n * container on the page, including the ones whose content fits and have nothing\n * to scroll. The stop is only wanted while the overflow is real, which is what\n * this reports. (It is also what axe checks as `scrollable-region-focusable`.)\n *\n * Both the container and its content are observed: content can outgrow a box\n * whose own dimensions never change, and a box can shrink around content that\n * never changes. Watching one alone misses half the transitions.\n *\n * A one-pixel difference is ignored — that is layout rounding, not overflow.\n *\n * @param ref - The scroll container.\n * @param axis - Which axis to measure. Defaults to `\"both\"`.\n * @returns `true` while the content is larger than the box on that axis.\n *\n * @example\n * const ref = useRef<HTMLDivElement>(null);\n * const scrollable = useScrollOverflow(ref, \"horizontal\");\n *\n * <div\n *   ref={ref}\n *   tabIndex={scrollable ? 0 : undefined}\n *   role={scrollable ? \"group\" : undefined}\n *   aria-label={scrollable ? \"Tabela rolável\" : undefined}\n * >\n */\nexport function useScrollOverflow(\n    ref: RefObject<HTMLElement | null>,\n    axis: ScrollOverflowAxis = \"both\",\n): boolean {\n    const [overflowing, setOverflowing] = useState(false);\n\n    useEffect(() => {\n        const element = ref.current;\n        if (!element) return;\n\n        const measure = () => {\n            const horizontal = element.scrollWidth - element.clientWidth > 1;\n            const vertical = element.scrollHeight - element.clientHeight > 1;\n            if (axis === \"horizontal\") setOverflowing(horizontal);\n            else if (axis === \"vertical\") setOverflowing(vertical);\n            else setOverflowing(horizontal || vertical);\n        };\n        measure();\n\n        if (typeof ResizeObserver === \"undefined\") return;\n\n        const observer = new ResizeObserver(measure);\n        observer.observe(element);\n        const content = element.firstElementChild;\n        if (content) observer.observe(content);\n        return () => observer.disconnect();\n    }, [ref, axis]);\n\n    return overflowing;\n}\n"],"mappings":"uBAuCA,SAAgB,EACZ,EACA,EAA2B,OACpB,CACP,GAAM,CAAC,EAAa,IAAA,EAAkB,EAAA,SAAA,CAAS,EAAK,EAwBpD,OAtBA,EAAA,EAAA,UAAA,KAAgB,CACZ,IAAM,EAAU,EAAI,QACpB,GAAI,CAAC,EAAS,OAEd,IAAM,MAAgB,CAClB,IAAM,EAAa,EAAQ,YAAc,EAAQ,YAAc,EACzD,EAAW,EAAQ,aAAe,EAAQ,aAAe,EACpC,EAAvB,IAAS,aAA6B,EACjC,IAAS,WAA2B,EACzB,GAAc,CAAQ,CAC9C,EAGA,GAFA,EAAQ,EAEJ,OAAO,eAAmB,IAAa,OAE3C,IAAM,EAAW,IAAI,eAAe,CAAO,EAC3C,EAAS,QAAQ,CAAO,EACxB,IAAM,EAAU,EAAQ,kBAExB,OADI,GAAS,EAAS,QAAQ,CAAO,MACxB,EAAS,WAAW,CACrC,EAAG,CAAC,EAAK,CAAI,CAAC,EAEP,CACX"}
+{"version":3,"file":"use-scroll-overflow.cjs","names":["useState","react","useScrollOverflow","overflowing","setOverflowing","element","ref","measure","horizontal","vertical","axis","observer","content"],"sources":["../../src/hooks/use-scroll-overflow.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\n\n/** Which axis to watch for overflow. */\nexport type ScrollOverflowAxis = \"horizontal\" | \"vertical\" | \"both\";\n\n/**\n * Track whether an element's content currently overflows its box.\n *\n * The use this exists for is keyboard access. A scroll container holding no\n * focusable content is unreachable by keyboard: the user can see there is more\n * content past the edge and has no way to get to it, because focus never lands\n * anywhere the arrow keys would scroll. Giving the container `tabIndex={0}`\n * fixes it — but doing that unconditionally puts a tab stop on every such\n * container on the page, including the ones whose content fits and have nothing\n * to scroll. The stop is only wanted while the overflow is real, which is what\n * this reports. (It is also what axe checks as `scrollable-region-focusable`.)\n *\n * Both the container and its content are observed: content can outgrow a box\n * whose own dimensions never change, and a box can shrink around content that\n * never changes. Watching one alone misses half the transitions.\n *\n * A one-pixel difference is ignored — that is layout rounding, not overflow.\n *\n * @param ref - The scroll container.\n * @param axis - Which axis to measure. Defaults to `\"both\"`.\n * @returns `true` while the content is larger than the box on that axis.\n *\n * @example\n * const ref = useRef<HTMLDivElement>(null);\n * const scrollable = useScrollOverflow(ref, \"horizontal\");\n *\n * <div\n *   ref={ref}\n *   tabIndex={scrollable ? 0 : undefined}\n *   role={scrollable ? \"group\" : undefined}\n *   aria-label={scrollable ? \"Tabela rolável\" : undefined}\n * >\n */\nexport function useScrollOverflow(\n    ref: RefObject<HTMLElement | null>,\n    axis: ScrollOverflowAxis = \"both\",\n): boolean {\n    const [overflowing, setOverflowing] = useState(false);\n\n    useEffect(() => {\n        const element = ref.current;\n        if (!element) return;\n\n        const measure = () => {\n            const horizontal = element.scrollWidth - element.clientWidth > 1;\n            const vertical = element.scrollHeight - element.clientHeight > 1;\n            if (axis === \"horizontal\") setOverflowing(horizontal);\n            else if (axis === \"vertical\") setOverflowing(vertical);\n            else setOverflowing(horizontal || vertical);\n        };\n        measure();\n\n        if (typeof ResizeObserver === \"undefined\") return;\n\n        const observer = new ResizeObserver(measure);\n        observer.observe(element);\n        const content = element.firstElementChild;\n        if (content) observer.observe(content);\n        return () => observer.disconnect();\n    }, [ref, axis]);\n\n    return overflowing;\n}\n"],"mappings":"A,uBAuCA,SAAgBE,EACZ,EACA,EAA2B,OACpB,CACP,GAAM,CAACC,EAAaC,IAAA,EAAkBJ,EAAAA,SAAAA,CAAS,EAAK,EAwBpD,OAtBA,EAAAC,EAAA,UAAA,KAAgB,CACZ,IAAMI,EAAUC,EAAI,QACpB,GAAI,CAACD,EAAS,OAEd,IAAME,MAAgB,CAClB,IAAMC,EAAaH,EAAQ,YAAcA,EAAQ,YAAc,EACzDI,EAAWJ,EAAQ,aAAeA,EAAQ,aAAe,EACpCD,EAAvBM,IAAS,aAA6BF,EACjCE,IAAS,WAA2BD,EACzBD,GAAcC,CAAQ,CAC9C,EAGA,GAFAF,EAAQ,EAEJ,OAAO,eAAmB,IAAa,OAE3C,IAAMI,EAAW,IAAI,eAAeJ,CAAO,EAC3CI,EAAS,QAAQN,CAAO,EACxB,IAAMO,EAAUP,EAAQ,kBAExB,OADIO,GAASD,EAAS,QAAQC,CAAO,MACxBD,EAAS,WAAW,CACrC,EAAG,CAACL,EAAKI,CAAI,CAAC,EAEPP,CACX,C"}

package/dist/hooks/use-scroll-overflow.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-scroll-overflow.js","names":[],"sources":["../../src/hooks/use-scroll-overflow.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\n\n/** Which axis to watch for overflow. */\nexport type ScrollOverflowAxis = \"horizontal\" | \"vertical\" | \"both\";\n\n/**\n * Track whether an element's content currently overflows its box.\n *\n * The use this exists for is keyboard access. A scroll container holding no\n * focusable content is unreachable by keyboard: the user can see there is more\n * content past the edge and has no way to get to it, because focus never lands\n * anywhere the arrow keys would scroll. Giving the container `tabIndex={0}`\n * fixes it — but doing that unconditionally puts a tab stop on every such\n * container on the page, including the ones whose content fits and have nothing\n * to scroll. The stop is only wanted while the overflow is real, which is what\n * this reports. (It is also what axe checks as `scrollable-region-focusable`.)\n *\n * Both the container and its content are observed: content can outgrow a box\n * whose own dimensions never change, and a box can shrink around content that\n * never changes. Watching one alone misses half the transitions.\n *\n * A one-pixel difference is ignored — that is layout rounding, not overflow.\n *\n * @param ref - The scroll container.\n * @param axis - Which axis to measure. Defaults to `\"both\"`.\n * @returns `true` while the content is larger than the box on that axis.\n *\n * @example\n * const ref = useRef<HTMLDivElement>(null);\n * const scrollable = useScrollOverflow(ref, \"horizontal\");\n *\n * <div\n *   ref={ref}\n *   tabIndex={scrollable ? 0 : undefined}\n *   role={scrollable ? \"group\" : undefined}\n *   aria-label={scrollable ? \"Tabela rolável\" : undefined}\n * >\n */\nexport function useScrollOverflow(\n    ref: RefObject<HTMLElement | null>,\n    axis: ScrollOverflowAxis = \"both\",\n): boolean {\n    const [overflowing, setOverflowing] = useState(false);\n\n    useEffect(() => {\n        const element = ref.current;\n        if (!element) return;\n\n        const measure = () => {\n            const horizontal = element.scrollWidth - element.clientWidth > 1;\n            const vertical = element.scrollHeight - element.clientHeight > 1;\n            if (axis === \"horizontal\") setOverflowing(horizontal);\n            else if (axis === \"vertical\") setOverflowing(vertical);\n            else setOverflowing(horizontal || vertical);\n        };\n        measure();\n\n        if (typeof ResizeObserver === \"undefined\") return;\n\n        const observer = new ResizeObserver(measure);\n        observer.observe(element);\n        const content = element.firstElementChild;\n        if (content) observer.observe(content);\n        return () => observer.disconnect();\n    }, [ref, axis]);\n\n    return overflowing;\n}\n"],"mappings":";;AAuCA,SAAgB,EACZ,GACA,IAA2B,QACpB;CACP,IAAM,CAAC,GAAa,KAAkB,EAAS,EAAK;CAwBpD,OAtBA,QAAgB;EACZ,IAAM,IAAU,EAAI;EACpB,IAAI,CAAC,GAAS;EAEd,IAAM,UAAgB;GAClB,IAAM,IAAa,EAAQ,cAAc,EAAQ,cAAc,GACzD,IAAW,EAAQ,eAAe,EAAQ,eAAe;GAC/D,AAA2B,EAAvB,MAAS,eAA6B,IACjC,MAAS,aAA2B,IACzB,KAAc,CAAQ;EAC9C;EAGA,IAFA,EAAQ,GAEJ,OAAO,iBAAmB,KAAa;EAE3C,IAAM,IAAW,IAAI,eAAe,CAAO;EAC3C,EAAS,QAAQ,CAAO;EACxB,IAAM,IAAU,EAAQ;EAExB,OADI,KAAS,EAAS,QAAQ,CAAO,SACxB,EAAS,WAAW;CACrC,GAAG,CAAC,GAAK,CAAI,CAAC,GAEP;AACX"}
+{"version":3,"file":"use-scroll-overflow.js","names":["useScrollOverflow","overflowing","setOverflowing","useState","useEffect","element","ref","measure","horizontal","vertical","axis","observer","content"],"sources":["../../src/hooks/use-scroll-overflow.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\n\n/** Which axis to watch for overflow. */\nexport type ScrollOverflowAxis = \"horizontal\" | \"vertical\" | \"both\";\n\n/**\n * Track whether an element's content currently overflows its box.\n *\n * The use this exists for is keyboard access. A scroll container holding no\n * focusable content is unreachable by keyboard: the user can see there is more\n * content past the edge and has no way to get to it, because focus never lands\n * anywhere the arrow keys would scroll. Giving the container `tabIndex={0}`\n * fixes it — but doing that unconditionally puts a tab stop on every such\n * container on the page, including the ones whose content fits and have nothing\n * to scroll. The stop is only wanted while the overflow is real, which is what\n * this reports. (It is also what axe checks as `scrollable-region-focusable`.)\n *\n * Both the container and its content are observed: content can outgrow a box\n * whose own dimensions never change, and a box can shrink around content that\n * never changes. Watching one alone misses half the transitions.\n *\n * A one-pixel difference is ignored — that is layout rounding, not overflow.\n *\n * @param ref - The scroll container.\n * @param axis - Which axis to measure. Defaults to `\"both\"`.\n * @returns `true` while the content is larger than the box on that axis.\n *\n * @example\n * const ref = useRef<HTMLDivElement>(null);\n * const scrollable = useScrollOverflow(ref, \"horizontal\");\n *\n * <div\n *   ref={ref}\n *   tabIndex={scrollable ? 0 : undefined}\n *   role={scrollable ? \"group\" : undefined}\n *   aria-label={scrollable ? \"Tabela rolável\" : undefined}\n * >\n */\nexport function useScrollOverflow(\n    ref: RefObject<HTMLElement | null>,\n    axis: ScrollOverflowAxis = \"both\",\n): boolean {\n    const [overflowing, setOverflowing] = useState(false);\n\n    useEffect(() => {\n        const element = ref.current;\n        if (!element) return;\n\n        const measure = () => {\n            const horizontal = element.scrollWidth - element.clientWidth > 1;\n            const vertical = element.scrollHeight - element.clientHeight > 1;\n            if (axis === \"horizontal\") setOverflowing(horizontal);\n            else if (axis === \"vertical\") setOverflowing(vertical);\n            else setOverflowing(horizontal || vertical);\n        };\n        measure();\n\n        if (typeof ResizeObserver === \"undefined\") return;\n\n        const observer = new ResizeObserver(measure);\n        observer.observe(element);\n        const content = element.firstElementChild;\n        if (content) observer.observe(content);\n        return () => observer.disconnect();\n    }, [ref, axis]);\n\n    return overflowing;\n}\n"],"mappings":";;AAuCA,SAAgBA,EACZ,GACA,IAA2B,QACpB;CACP,IAAM,CAACC,GAAaC,KAAkBC,EAAS,EAAK;CAwBpD,OAtBAC,QAAgB;EACZ,IAAMC,IAAUC,EAAI;EACpB,IAAI,CAACD,GAAS;EAEd,IAAME,UAAgB;GAClB,IAAMC,IAAaH,EAAQ,cAAcA,EAAQ,cAAc,GACzDI,IAAWJ,EAAQ,eAAeA,EAAQ,eAAe;GAC/D,AAA2BH,EAAvBQ,MAAS,eAA6BF,IACjCE,MAAS,aAA2BD,IACzBD,KAAcC,CAAQ;EAC9C;EAGA,IAFAF,EAAQ,GAEJ,OAAO,iBAAmB,KAAa;EAE3C,IAAMI,IAAW,IAAI,eAAeJ,CAAO;EAC3C,EAAS,QAAQF,CAAO;EACxB,IAAMO,IAAUP,EAAQ;EAExB,OADIO,KAASD,EAAS,QAAQC,CAAO,SACxBD,EAAS,WAAW;CACrC,GAAG,CAACL,GAAKI,CAAI,CAAC,GAEPT;AACX"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-service-worker-update.cjs","names":[],"sources":["../../src/hooks/use-service-worker-update.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\nimport {\n    registerServiceWorker,\n    skipWaiting,\n    type RegisterServiceWorkerOptions,\n} from \"../sw/register-service-worker\";\n\n/**\n * Options for {@link useServiceWorkerUpdate}. Mirrors the registration options\n * minus the callbacks the hook owns internally (`onUpdate`); `onReady` and\n * `onError` still pass through for host-side logging.\n *\n * Leave `autoUpdate` off (the default): this hook exists to hand the reload\n * decision to the user, so a silent auto-reload would defeat the prompt.\n */\nexport type UseServiceWorkerUpdateOptions = Omit<RegisterServiceWorkerOptions, \"onUpdate\">;\n\n/** Reactive service-worker update state plus the apply action. */\nexport interface UseServiceWorkerUpdateResult {\n    /** `true` once a new worker has installed and is waiting to activate. */\n    updateAvailable: boolean;\n    /**\n     * Activate the waiting worker and reload the page once it takes control.\n     * No-op when no update is waiting.\n     */\n    applyUpdate: () => void;\n    /** The active registration, or `null` before it resolves / when unsupported. */\n    registration: ServiceWorkerRegistration | null;\n}\n\n/**\n * Register a service worker and expose a user-driven update flow.\n *\n * Wraps {@link registerServiceWorker}: when a fresh worker finishes installing\n * while the page is still controlled by the old one, `updateAvailable` flips to\n * `true`. Call `applyUpdate` — typically from an \"atualizar\" toast — to tell the\n * waiting worker to activate and reload the page once it takes control.\n *\n * Skips cleanly when the runtime has no service-worker support (`registration`\n * stays `null`, `updateAvailable` stays `false`).\n *\n * @param options - Registration options (`url` required); `autoUpdate` should\n *   stay off so the reload is user-confirmed.\n * @returns The update state and `applyUpdate` action.\n *\n * @example\n * const { updateAvailable, applyUpdate } = useServiceWorkerUpdate({ url: \"/sw.js\" });\n * return (\n *     <UpdatePrompt open={updateAvailable} onUpdate={applyUpdate} />\n * );\n */\nexport function useServiceWorkerUpdate(\n    options: UseServiceWorkerUpdateOptions,\n): UseServiceWorkerUpdateResult {\n    const [updateAvailable, setUpdateAvailable] = useState<boolean>(false);\n    const [registration, setRegistration] = useState<ServiceWorkerRegistration | null>(null);\n    const waitingRef = useRef<ServiceWorker | null>(null);\n\n    const optionsRef = useLatestRef(options);\n\n    useEffect(() => {\n        let cancelled = false;\n        void registerServiceWorker({\n            ...optionsRef.current,\n            onUpdate: (waiting, reg) => {\n                waitingRef.current = waiting;\n                setRegistration(reg);\n                setUpdateAvailable(true);\n            },\n            onReady: (reg) => {\n                if (cancelled) return;\n                setRegistration(reg);\n                if (reg.waiting && navigator.serviceWorker.controller) {\n                    waitingRef.current = reg.waiting;\n                    setUpdateAvailable(true);\n                }\n                optionsRef.current.onReady?.(reg);\n            },\n        }).then((reg) => {\n            if (!cancelled && reg) setRegistration(reg);\n        });\n        return () => {\n            cancelled = true;\n        };\n    }, [options.url, optionsRef]);\n\n    const applyUpdate = useCallback(() => {\n        const waiting = waitingRef.current;\n        if (!waiting || typeof navigator === \"undefined\") return;\n        let reloading = false;\n        navigator.serviceWorker.addEventListener(\"controllerchange\", () => {\n            if (reloading) return;\n            reloading = true;\n            window.location.reload();\n        });\n        skipWaiting(waiting);\n    }, []);\n\n    return { updateAvailable, applyUpdate, registration };\n}\n"],"mappings":"8GAoDA,SAAgB,EACZ,EAC4B,CAC5B,GAAM,CAAC,EAAiB,IAAA,EAAsB,EAAA,SAAA,CAAkB,EAAK,EAC/D,CAAC,EAAc,IAAA,EAAmB,EAAA,SAAA,CAA2C,IAAI,EACjF,GAAA,EAAa,EAAA,OAAA,CAA6B,IAAI,EAE9C,EAAa,EAAA,aAAa,CAAO,EAwCvC,OAtCA,EAAA,EAAA,UAAA,KAAgB,CACZ,IAAI,EAAY,GAoBhB,OAnBA,EAAK,sBAAsB,CACvB,GAAG,EAAW,QACd,UAAW,EAAS,IAAQ,CACxB,EAAW,QAAU,EACrB,EAAgB,CAAG,EACnB,EAAmB,EAAI,CAC3B,EACA,QAAU,GAAQ,CACV,IACJ,EAAgB,CAAG,EACf,EAAI,SAAW,UAAU,cAAc,aACvC,EAAW,QAAU,EAAI,QACzB,EAAmB,EAAI,GAE3B,EAAW,QAAQ,UAAU,CAAG,EACpC,CACJ,CAAC,CAAC,CAAC,KAAM,GAAQ,CACT,CAAC,GAAa,GAAK,EAAgB,CAAG,CAC9C,CAAC,MACY,CACT,EAAY,EAChB,CACJ,EAAG,CAAC,EAAQ,IAAK,CAAU,CAAC,EAcrB,CAAE,kBAAiB,aAAA,EAZN,EAAA,YAAA,KAAkB,CAClC,IAAM,EAAU,EAAW,QAC3B,GAAI,CAAC,GAAW,OAAO,UAAc,IAAa,OAClD,IAAI,EAAY,GAChB,UAAU,cAAc,iBAAiB,uBAA0B,CAC3D,IACJ,EAAY,GACZ,OAAO,SAAS,OAAO,EAC3B,CAAC,EACD,EAAA,YAAY,CAAO,CACvB,EAAG,CAAC,CAEsB,EAAa,cAAa,CACxD"}
+{"version":3,"file":"use-service-worker-update.cjs","names":["useState","useRef","useLatestRef","registerServiceWorker","useCallback","require_use_latest_ref","require_register_service_worker","react","useServiceWorkerUpdate","updateAvailable","setUpdateAvailable","registration","setRegistration","waitingRef","optionsRef","options","cancelled","waiting","reg","reloading"],"sources":["../../src/hooks/use-service-worker-update.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\nimport {\n    registerServiceWorker,\n    skipWaiting,\n    type RegisterServiceWorkerOptions,\n} from \"../sw/register-service-worker\";\n\n/**\n * Options for {@link useServiceWorkerUpdate}. Mirrors the registration options\n * minus the callbacks the hook owns internally (`onUpdate`); `onReady` and\n * `onError` still pass through for host-side logging.\n *\n * Leave `autoUpdate` off (the default): this hook exists to hand the reload\n * decision to the user, so a silent auto-reload would defeat the prompt.\n */\nexport type UseServiceWorkerUpdateOptions = Omit<RegisterServiceWorkerOptions, \"onUpdate\">;\n\n/** Reactive service-worker update state plus the apply action. */\nexport interface UseServiceWorkerUpdateResult {\n    /** `true` once a new worker has installed and is waiting to activate. */\n    updateAvailable: boolean;\n    /**\n     * Activate the waiting worker and reload the page once it takes control.\n     * No-op when no update is waiting.\n     */\n    applyUpdate: () => void;\n    /** The active registration, or `null` before it resolves / when unsupported. */\n    registration: ServiceWorkerRegistration | null;\n}\n\n/**\n * Register a service worker and expose a user-driven update flow.\n *\n * Wraps {@link registerServiceWorker}: when a fresh worker finishes installing\n * while the page is still controlled by the old one, `updateAvailable` flips to\n * `true`. Call `applyUpdate` — typically from an \"atualizar\" toast — to tell the\n * waiting worker to activate and reload the page once it takes control.\n *\n * Skips cleanly when the runtime has no service-worker support (`registration`\n * stays `null`, `updateAvailable` stays `false`).\n *\n * @param options - Registration options (`url` required); `autoUpdate` should\n *   stay off so the reload is user-confirmed.\n * @returns The update state and `applyUpdate` action.\n *\n * @example\n * const { updateAvailable, applyUpdate } = useServiceWorkerUpdate({ url: \"/sw.js\" });\n * return (\n *     <UpdatePrompt open={updateAvailable} onUpdate={applyUpdate} />\n * );\n */\nexport function useServiceWorkerUpdate(\n    options: UseServiceWorkerUpdateOptions,\n): UseServiceWorkerUpdateResult {\n    const [updateAvailable, setUpdateAvailable] = useState<boolean>(false);\n    const [registration, setRegistration] = useState<ServiceWorkerRegistration | null>(null);\n    const waitingRef = useRef<ServiceWorker | null>(null);\n\n    const optionsRef = useLatestRef(options);\n\n    useEffect(() => {\n        let cancelled = false;\n        void registerServiceWorker({\n            ...optionsRef.current,\n            onUpdate: (waiting, reg) => {\n                waitingRef.current = waiting;\n                setRegistration(reg);\n                setUpdateAvailable(true);\n            },\n            onReady: (reg) => {\n                if (cancelled) return;\n                setRegistration(reg);\n                if (reg.waiting && navigator.serviceWorker.controller) {\n                    waitingRef.current = reg.waiting;\n                    setUpdateAvailable(true);\n                }\n                optionsRef.current.onReady?.(reg);\n            },\n        }).then((reg) => {\n            if (!cancelled && reg) setRegistration(reg);\n        });\n        return () => {\n            cancelled = true;\n        };\n    }, [options.url, optionsRef]);\n\n    const applyUpdate = useCallback(() => {\n        const waiting = waitingRef.current;\n        if (!waiting || typeof navigator === \"undefined\") return;\n        let reloading = false;\n        navigator.serviceWorker.addEventListener(\"controllerchange\", () => {\n            if (reloading) return;\n            reloading = true;\n            window.location.reload();\n        });\n        skipWaiting(waiting);\n    }, []);\n\n    return { updateAvailable, applyUpdate, registration };\n}\n"],"mappings":"A,8GAoDA,SAAgBQ,EACZ,EAC4B,CAC5B,GAAM,CAACC,EAAiBC,IAAA,EAAsBV,EAAAA,SAAAA,CAAkB,EAAK,EAC/D,CAACW,EAAcC,IAAA,EAAmBZ,EAAAA,SAAAA,CAA2C,IAAI,EACjFa,GAAA,EAAaZ,EAAAA,OAAAA,CAA6B,IAAI,EAE9Ca,EAAaZ,EAAAA,aAAaa,CAAO,EAwCvC,OAtCA,EAAAR,EAAA,UAAA,KAAgB,CACZ,IAAIS,EAAY,GAoBhB,OAnBAV,EAAKH,sBAAsB,CACvB,GAAGW,EAAW,QACd,UAAW,EAAS,IAAQ,CACxB,EAAW,QAAUG,EACrBL,EAAgBM,CAAG,EACnBR,EAAmB,EAAI,CAC3B,EACA,QAAU,GAAQ,CACVM,IACJJ,EAAgBM,CAAG,EACfA,EAAI,SAAW,UAAU,cAAc,aACvC,EAAW,QAAUA,EAAI,QACzBR,EAAmB,EAAI,GAE3BI,EAAW,QAAQ,UAAUI,CAAG,EACpC,CACJ,CAAC,CAAC,CAAC,KAAM,GAAQ,CACT,CAACF,GAAaE,GAAKN,EAAgBM,CAAG,CAC9C,CAAC,MACY,CACT,EAAY,EAChB,CACJ,EAAG,CAACH,EAAQ,IAAKD,CAAU,CAAC,EAcrB,CAAE,kBAAiB,aAAA,EAZNV,EAAAA,YAAAA,KAAkB,CAClC,IAAMa,EAAUJ,EAAW,QAC3B,GAAI,CAACI,GAAW,OAAO,UAAc,IAAa,OAClD,IAAIE,EAAY,GAChB,UAAU,cAAc,iBAAiB,uBAA0B,CAC3DA,IACJ,EAAY,GACZ,OAAO,SAAS,OAAO,EAC3B,CAAC,EACDb,EAAA,YAAYW,CAAO,CACvB,EAAG,CAAC,CAEsB,EAAa,cAAa,CACxD,C"}

package/dist/hooks/use-service-worker-update.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-service-worker-update.js","names":[],"sources":["../../src/hooks/use-service-worker-update.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\nimport {\n    registerServiceWorker,\n    skipWaiting,\n    type RegisterServiceWorkerOptions,\n} from \"../sw/register-service-worker\";\n\n/**\n * Options for {@link useServiceWorkerUpdate}. Mirrors the registration options\n * minus the callbacks the hook owns internally (`onUpdate`); `onReady` and\n * `onError` still pass through for host-side logging.\n *\n * Leave `autoUpdate` off (the default): this hook exists to hand the reload\n * decision to the user, so a silent auto-reload would defeat the prompt.\n */\nexport type UseServiceWorkerUpdateOptions = Omit<RegisterServiceWorkerOptions, \"onUpdate\">;\n\n/** Reactive service-worker update state plus the apply action. */\nexport interface UseServiceWorkerUpdateResult {\n    /** `true` once a new worker has installed and is waiting to activate. */\n    updateAvailable: boolean;\n    /**\n     * Activate the waiting worker and reload the page once it takes control.\n     * No-op when no update is waiting.\n     */\n    applyUpdate: () => void;\n    /** The active registration, or `null` before it resolves / when unsupported. */\n    registration: ServiceWorkerRegistration | null;\n}\n\n/**\n * Register a service worker and expose a user-driven update flow.\n *\n * Wraps {@link registerServiceWorker}: when a fresh worker finishes installing\n * while the page is still controlled by the old one, `updateAvailable` flips to\n * `true`. Call `applyUpdate` — typically from an \"atualizar\" toast — to tell the\n * waiting worker to activate and reload the page once it takes control.\n *\n * Skips cleanly when the runtime has no service-worker support (`registration`\n * stays `null`, `updateAvailable` stays `false`).\n *\n * @param options - Registration options (`url` required); `autoUpdate` should\n *   stay off so the reload is user-confirmed.\n * @returns The update state and `applyUpdate` action.\n *\n * @example\n * const { updateAvailable, applyUpdate } = useServiceWorkerUpdate({ url: \"/sw.js\" });\n * return (\n *     <UpdatePrompt open={updateAvailable} onUpdate={applyUpdate} />\n * );\n */\nexport function useServiceWorkerUpdate(\n    options: UseServiceWorkerUpdateOptions,\n): UseServiceWorkerUpdateResult {\n    const [updateAvailable, setUpdateAvailable] = useState<boolean>(false);\n    const [registration, setRegistration] = useState<ServiceWorkerRegistration | null>(null);\n    const waitingRef = useRef<ServiceWorker | null>(null);\n\n    const optionsRef = useLatestRef(options);\n\n    useEffect(() => {\n        let cancelled = false;\n        void registerServiceWorker({\n            ...optionsRef.current,\n            onUpdate: (waiting, reg) => {\n                waitingRef.current = waiting;\n                setRegistration(reg);\n                setUpdateAvailable(true);\n            },\n            onReady: (reg) => {\n                if (cancelled) return;\n                setRegistration(reg);\n                if (reg.waiting && navigator.serviceWorker.controller) {\n                    waitingRef.current = reg.waiting;\n                    setUpdateAvailable(true);\n                }\n                optionsRef.current.onReady?.(reg);\n            },\n        }).then((reg) => {\n            if (!cancelled && reg) setRegistration(reg);\n        });\n        return () => {\n            cancelled = true;\n        };\n    }, [options.url, optionsRef]);\n\n    const applyUpdate = useCallback(() => {\n        const waiting = waitingRef.current;\n        if (!waiting || typeof navigator === \"undefined\") return;\n        let reloading = false;\n        navigator.serviceWorker.addEventListener(\"controllerchange\", () => {\n            if (reloading) return;\n            reloading = true;\n            window.location.reload();\n        });\n        skipWaiting(waiting);\n    }, []);\n\n    return { updateAvailable, applyUpdate, registration };\n}\n"],"mappings":";;;;AAoDA,SAAgB,EACZ,GAC4B;CAC5B,IAAM,CAAC,GAAiB,KAAsB,EAAkB,EAAK,GAC/D,CAAC,GAAc,KAAmB,EAA2C,IAAI,GACjF,IAAa,EAA6B,IAAI,GAE9C,IAAa,EAAa,CAAO;CAwCvC,OAtCA,QAAgB;EACZ,IAAI,IAAY;EAoBhB,OAnBA,EAA2B;GACvB,GAAG,EAAW;GACd,WAAW,GAAS,MAAQ;IAGxB,AAFA,EAAW,UAAU,GACrB,EAAgB,CAAG,GACnB,EAAmB,EAAI;GAC3B;GACA,UAAU,MAAQ;IACV,MACJ,EAAgB,CAAG,GACf,EAAI,WAAW,UAAU,cAAc,eACvC,EAAW,UAAU,EAAI,SACzB,EAAmB,EAAI,IAE3B,EAAW,QAAQ,UAAU,CAAG;GACpC;EACJ,CAAC,CAAC,CAAC,MAAM,MAAQ;GACb,AAAI,CAAC,KAAa,KAAK,EAAgB,CAAG;EAC9C,CAAC,SACY;GACT,IAAY;EAChB;CACJ,GAAG,CAAC,EAAQ,KAAK,CAAU,CAAC,GAcrB;EAAE;EAAiB,aAZN,QAAkB;GAClC,IAAM,IAAU,EAAW;GAC3B,IAAI,CAAC,KAAW,OAAO,YAAc,KAAa;GAClD,IAAI,IAAY;GAMhB,AALA,UAAU,cAAc,iBAAiB,0BAA0B;IAC3D,MACJ,IAAY,IACZ,OAAO,SAAS,OAAO;GAC3B,CAAC,GACD,EAAY,CAAO;EACvB,GAAG,CAAC,CAEsB;EAAa;CAAa;AACxD"}
+{"version":3,"file":"use-service-worker-update.js","names":["useServiceWorkerUpdate","updateAvailable","setUpdateAvailable","useState","registration","setRegistration","waitingRef","useRef","optionsRef","useLatestRef","options","useEffect","cancelled","registerServiceWorker","waiting","reg","useCallback","reloading","skipWaiting"],"sources":["../../src/hooks/use-service-worker-update.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\nimport { useLatestRef } from \"./use-latest-ref\";\nimport {\n    registerServiceWorker,\n    skipWaiting,\n    type RegisterServiceWorkerOptions,\n} from \"../sw/register-service-worker\";\n\n/**\n * Options for {@link useServiceWorkerUpdate}. Mirrors the registration options\n * minus the callbacks the hook owns internally (`onUpdate`); `onReady` and\n * `onError` still pass through for host-side logging.\n *\n * Leave `autoUpdate` off (the default): this hook exists to hand the reload\n * decision to the user, so a silent auto-reload would defeat the prompt.\n */\nexport type UseServiceWorkerUpdateOptions = Omit<RegisterServiceWorkerOptions, \"onUpdate\">;\n\n/** Reactive service-worker update state plus the apply action. */\nexport interface UseServiceWorkerUpdateResult {\n    /** `true` once a new worker has installed and is waiting to activate. */\n    updateAvailable: boolean;\n    /**\n     * Activate the waiting worker and reload the page once it takes control.\n     * No-op when no update is waiting.\n     */\n    applyUpdate: () => void;\n    /** The active registration, or `null` before it resolves / when unsupported. */\n    registration: ServiceWorkerRegistration | null;\n}\n\n/**\n * Register a service worker and expose a user-driven update flow.\n *\n * Wraps {@link registerServiceWorker}: when a fresh worker finishes installing\n * while the page is still controlled by the old one, `updateAvailable` flips to\n * `true`. Call `applyUpdate` — typically from an \"atualizar\" toast — to tell the\n * waiting worker to activate and reload the page once it takes control.\n *\n * Skips cleanly when the runtime has no service-worker support (`registration`\n * stays `null`, `updateAvailable` stays `false`).\n *\n * @param options - Registration options (`url` required); `autoUpdate` should\n *   stay off so the reload is user-confirmed.\n * @returns The update state and `applyUpdate` action.\n *\n * @example\n * const { updateAvailable, applyUpdate } = useServiceWorkerUpdate({ url: \"/sw.js\" });\n * return (\n *     <UpdatePrompt open={updateAvailable} onUpdate={applyUpdate} />\n * );\n */\nexport function useServiceWorkerUpdate(\n    options: UseServiceWorkerUpdateOptions,\n): UseServiceWorkerUpdateResult {\n    const [updateAvailable, setUpdateAvailable] = useState<boolean>(false);\n    const [registration, setRegistration] = useState<ServiceWorkerRegistration | null>(null);\n    const waitingRef = useRef<ServiceWorker | null>(null);\n\n    const optionsRef = useLatestRef(options);\n\n    useEffect(() => {\n        let cancelled = false;\n        void registerServiceWorker({\n            ...optionsRef.current,\n            onUpdate: (waiting, reg) => {\n                waitingRef.current = waiting;\n                setRegistration(reg);\n                setUpdateAvailable(true);\n            },\n            onReady: (reg) => {\n                if (cancelled) return;\n                setRegistration(reg);\n                if (reg.waiting && navigator.serviceWorker.controller) {\n                    waitingRef.current = reg.waiting;\n                    setUpdateAvailable(true);\n                }\n                optionsRef.current.onReady?.(reg);\n            },\n        }).then((reg) => {\n            if (!cancelled && reg) setRegistration(reg);\n        });\n        return () => {\n            cancelled = true;\n        };\n    }, [options.url, optionsRef]);\n\n    const applyUpdate = useCallback(() => {\n        const waiting = waitingRef.current;\n        if (!waiting || typeof navigator === \"undefined\") return;\n        let reloading = false;\n        navigator.serviceWorker.addEventListener(\"controllerchange\", () => {\n            if (reloading) return;\n            reloading = true;\n            window.location.reload();\n        });\n        skipWaiting(waiting);\n    }, []);\n\n    return { updateAvailable, applyUpdate, registration };\n}\n"],"mappings":";;;;AAoDA,SAAgBA,EACZ,GAC4B;CAC5B,IAAM,CAACC,GAAiBC,KAAsBC,EAAkB,EAAK,GAC/D,CAACC,GAAcC,KAAmBF,EAA2C,IAAI,GACjFG,IAAaC,EAA6B,IAAI,GAE9CC,IAAaC,EAAaC,CAAO;CAwCvC,OAtCAC,QAAgB;EACZ,IAAIC,IAAY;EAoBhB,OAnBAC,EAA2B;GACvB,GAAGL,EAAW;GACd,WAAW,GAAS,MAAQ;IAGxB,AAFA,EAAW,UAAUM,GACrBT,EAAgBU,CAAG,GACnBb,EAAmB,EAAI;GAC3B;GACA,UAAU,MAAQ;IACd,AAAIU,MACJP,EAAgBU,CAAG,GACfA,EAAI,WAAW,UAAU,cAAc,eACvC,EAAW,UAAUA,EAAI,SACzBb,EAAmB,EAAI,IAE3BM,EAAW,QAAQ,UAAUO,CAAG;GACpC;EACJ,CAAC,CAAC,CAAC,MAAM,MAAQ;GACb,AAAI,CAACH,KAAaG,KAAKV,EAAgBU,CAAG;EAC9C,CAAC,SACY;GACT,IAAY;EAChB;CACJ,GAAG,CAACL,EAAQ,KAAKF,CAAU,CAAC,GAcrB;EAAE;EAAiB,aAZNQ,QAAkB;GAClC,IAAMF,IAAUR,EAAW;GAC3B,IAAI,CAACQ,KAAW,OAAO,YAAc,KAAa;GAClD,IAAIG,IAAY;GAMhB,AALA,UAAU,cAAc,iBAAiB,0BAA0B;IAC/D,AAAIA,MACJ,IAAY,IACZ,OAAO,SAAS,OAAO;GAC3B,CAAC,GACDC,EAAYJ,CAAO;EACvB,GAAG,CAAC,CAEsB;EAAa;CAAa;AACxD"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-set.cjs","names":[],"sources":["../../src/hooks/use-set.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface UseSetResult<T> {\n    set: ReadonlySet<T>;\n    add: (value: T) => void;\n    delete: (value: T) => void;\n    clear: () => void;\n    has: (value: T) => boolean;\n    toggle: (value: T) => void;\n    size: number;\n}\n\n/**\n * Reactive `Set` wrapper. Mutating via `add` / `delete` / `clear` / `toggle`\n * triggers a re-render and yields a fresh `set` reference each time.\n *\n * @typeParam T - element type.\n * @param initial - initial values.\n * @returns `{ set, add, delete, clear, has, toggle, size }`.\n */\nexport function useSet<T>(initial?: Iterable<T>): UseSetResult<T> {\n    const [set, setSet] = useState<Set<T>>(() => new Set(initial));\n\n    const add = useCallback((value: T): void => {\n        setSet((current) => {\n            if (current.has(value)) return current;\n            const next = new Set(current);\n            next.add(value);\n            return next;\n        });\n    }, []);\n\n    const remove = useCallback((value: T): void => {\n        setSet((current) => {\n            if (!current.has(value)) return current;\n            const next = new Set(current);\n            next.delete(value);\n            return next;\n        });\n    }, []);\n\n    const clear = useCallback((): void => {\n        setSet((current) => (current.size === 0 ? current : new Set<T>()));\n    }, []);\n\n    const has = useCallback((value: T): boolean => set.has(value), [set]);\n\n    const toggle = useCallback((value: T): void => {\n        setSet((current) => {\n            const next = new Set(current);\n            if (next.has(value)) next.delete(value);\n            else next.add(value);\n            return next;\n        });\n    }, []);\n\n    return useMemo<UseSetResult<T>>(\n        () => ({\n            set,\n            add,\n            delete: remove,\n            clear,\n            has,\n            toggle,\n            size: set.size,\n        }),\n        [set, add, remove, clear, has, toggle],\n    );\n}\n"],"mappings":"uBAoBA,SAAgB,EAAU,EAAwC,CAC9D,GAAM,CAAC,EAAK,IAAA,EAAU,EAAA,SAAA,KAAuB,IAAI,IAAI,CAAO,CAAC,EAEvD,GAAA,EAAM,EAAA,YAAA,CAAa,GAAmB,CACxC,EAAQ,GAAY,CAChB,GAAI,EAAQ,IAAI,CAAK,EAAG,OAAO,EAC/B,IAAM,EAAO,IAAI,IAAI,CAAO,EAE5B,OADA,EAAK,IAAI,CAAK,EACP,CACX,CAAC,CACL,EAAG,CAAC,CAAC,EAEC,GAAA,EAAS,EAAA,YAAA,CAAa,GAAmB,CAC3C,EAAQ,GAAY,CAChB,GAAI,CAAC,EAAQ,IAAI,CAAK,EAAG,OAAO,EAChC,IAAM,EAAO,IAAI,IAAI,CAAO,EAE5B,OADA,EAAK,OAAO,CAAK,EACV,CACX,CAAC,CACL,EAAG,CAAC,CAAC,EAEC,GAAA,EAAQ,EAAA,YAAA,KAAwB,CAClC,EAAQ,GAAa,EAAQ,OAAS,EAAI,EAAU,IAAI,GAAS,CACrE,EAAG,CAAC,CAAC,EAEC,GAAA,EAAM,EAAA,YAAA,CAAa,GAAsB,EAAI,IAAI,CAAK,EAAG,CAAC,CAAG,CAAC,EAE9D,GAAA,EAAS,EAAA,YAAA,CAAa,GAAmB,CAC3C,EAAQ,GAAY,CAChB,IAAM,EAAO,IAAI,IAAI,CAAO,EAG5B,OAFI,EAAK,IAAI,CAAK,EAAG,EAAK,OAAO,CAAK,EACjC,EAAK,IAAI,CAAK,EACZ,CACX,CAAC,CACL,EAAG,CAAC,CAAC,EAEL,OAAA,EAAO,EAAA,QAAA,MACI,CACH,MACA,MACA,OAAQ,EACR,QACA,MACA,SACA,KAAM,EAAI,IACd,GACA,CAAC,EAAK,EAAK,EAAQ,EAAO,EAAK,CAAM,CACzC,CACJ"}
+{"version":3,"file":"use-set.cjs","names":["useState","useCallback","useMemo","react","useSet","set","setSet","initial","add","current","value","next","remove","clear","has","toggle"],"sources":["../../src/hooks/use-set.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface UseSetResult<T> {\n    set: ReadonlySet<T>;\n    add: (value: T) => void;\n    delete: (value: T) => void;\n    clear: () => void;\n    has: (value: T) => boolean;\n    toggle: (value: T) => void;\n    size: number;\n}\n\n/**\n * Reactive `Set` wrapper. Mutating via `add` / `delete` / `clear` / `toggle`\n * triggers a re-render and yields a fresh `set` reference each time.\n *\n * @typeParam T - element type.\n * @param initial - initial values.\n * @returns `{ set, add, delete, clear, has, toggle, size }`.\n */\nexport function useSet<T>(initial?: Iterable<T>): UseSetResult<T> {\n    const [set, setSet] = useState<Set<T>>(() => new Set(initial));\n\n    const add = useCallback((value: T): void => {\n        setSet((current) => {\n            if (current.has(value)) return current;\n            const next = new Set(current);\n            next.add(value);\n            return next;\n        });\n    }, []);\n\n    const remove = useCallback((value: T): void => {\n        setSet((current) => {\n            if (!current.has(value)) return current;\n            const next = new Set(current);\n            next.delete(value);\n            return next;\n        });\n    }, []);\n\n    const clear = useCallback((): void => {\n        setSet((current) => (current.size === 0 ? current : new Set<T>()));\n    }, []);\n\n    const has = useCallback((value: T): boolean => set.has(value), [set]);\n\n    const toggle = useCallback((value: T): void => {\n        setSet((current) => {\n            const next = new Set(current);\n            if (next.has(value)) next.delete(value);\n            else next.add(value);\n            return next;\n        });\n    }, []);\n\n    return useMemo<UseSetResult<T>>(\n        () => ({\n            set,\n            add,\n            delete: remove,\n            clear,\n            has,\n            toggle,\n            size: set.size,\n        }),\n        [set, add, remove, clear, has, toggle],\n    );\n}\n"],"mappings":"A,uBAoBA,SAAgBI,EAAU,EAAwC,CAC9D,GAAM,CAACC,EAAKC,IAAA,EAAUN,EAAAA,SAAAA,KAAuB,IAAI,IAAIO,CAAO,CAAC,EAEvDC,GAAA,EAAMP,EAAAA,YAAAA,CAAa,GAAmB,CACxCK,EAAQ,GAAY,CAChB,GAAIG,EAAQ,IAAIC,CAAK,EAAG,OAAOD,EAC/B,IAAME,EAAO,IAAI,IAAIF,CAAO,EAE5B,OADAE,EAAK,IAAID,CAAK,EACPC,CACX,CAAC,CACL,EAAG,CAAC,CAAC,EAECC,GAAA,EAASX,EAAAA,YAAAA,CAAa,GAAmB,CAC3CK,EAAQ,GAAY,CAChB,GAAI,CAACG,EAAQ,IAAIC,CAAK,EAAG,OAAOD,EAChC,IAAME,EAAO,IAAI,IAAIF,CAAO,EAE5B,OADAE,EAAK,OAAOD,CAAK,EACVC,CACX,CAAC,CACL,EAAG,CAAC,CAAC,EAECE,GAAA,EAAQZ,EAAAA,YAAAA,KAAwB,CAClCK,EAAQ,GAAaG,EAAQ,OAAS,EAAIA,EAAU,IAAI,GAAS,CACrE,EAAG,CAAC,CAAC,EAECK,GAAA,EAAMb,EAAAA,YAAAA,CAAa,GAAsBI,EAAI,IAAIK,CAAK,EAAG,CAACL,CAAG,CAAC,EAE9DU,GAAA,EAASd,EAAAA,YAAAA,CAAa,GAAmB,CAC3CK,EAAQ,GAAY,CAChB,IAAMK,EAAO,IAAI,IAAIF,CAAO,EAG5B,OAFIE,EAAK,IAAID,CAAK,EAAGC,EAAK,OAAOD,CAAK,EACjCC,EAAK,IAAID,CAAK,EACZC,CACX,CAAC,CACL,EAAG,CAAC,CAAC,EAEL,OAAA,EAAOT,EAAAA,QAAAA,MACI,CACH,MACA,MACA,OAAQU,EACR,QACA,MACA,SACA,KAAMP,EAAI,IACd,GACA,CAACA,EAAKG,EAAKI,EAAQC,EAAOC,EAAKC,CAAM,CACzC,CACJ,C"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-set.js","names":[],"sources":["../../src/hooks/use-set.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface UseSetResult<T> {\n    set: ReadonlySet<T>;\n    add: (value: T) => void;\n    delete: (value: T) => void;\n    clear: () => void;\n    has: (value: T) => boolean;\n    toggle: (value: T) => void;\n    size: number;\n}\n\n/**\n * Reactive `Set` wrapper. Mutating via `add` / `delete` / `clear` / `toggle`\n * triggers a re-render and yields a fresh `set` reference each time.\n *\n * @typeParam T - element type.\n * @param initial - initial values.\n * @returns `{ set, add, delete, clear, has, toggle, size }`.\n */\nexport function useSet<T>(initial?: Iterable<T>): UseSetResult<T> {\n    const [set, setSet] = useState<Set<T>>(() => new Set(initial));\n\n    const add = useCallback((value: T): void => {\n        setSet((current) => {\n            if (current.has(value)) return current;\n            const next = new Set(current);\n            next.add(value);\n            return next;\n        });\n    }, []);\n\n    const remove = useCallback((value: T): void => {\n        setSet((current) => {\n            if (!current.has(value)) return current;\n            const next = new Set(current);\n            next.delete(value);\n            return next;\n        });\n    }, []);\n\n    const clear = useCallback((): void => {\n        setSet((current) => (current.size === 0 ? current : new Set<T>()));\n    }, []);\n\n    const has = useCallback((value: T): boolean => set.has(value), [set]);\n\n    const toggle = useCallback((value: T): void => {\n        setSet((current) => {\n            const next = new Set(current);\n            if (next.has(value)) next.delete(value);\n            else next.add(value);\n            return next;\n        });\n    }, []);\n\n    return useMemo<UseSetResult<T>>(\n        () => ({\n            set,\n            add,\n            delete: remove,\n            clear,\n            has,\n            toggle,\n            size: set.size,\n        }),\n        [set, add, remove, clear, has, toggle],\n    );\n}\n"],"mappings":";;AAoBA,SAAgB,EAAU,GAAwC;CAC9D,IAAM,CAAC,GAAK,KAAU,QAAuB,IAAI,IAAI,CAAO,CAAC,GAEvD,IAAM,GAAa,MAAmB;EACxC,GAAQ,MAAY;GAChB,IAAI,EAAQ,IAAI,CAAK,GAAG,OAAO;GAC/B,IAAM,IAAO,IAAI,IAAI,CAAO;GAE5B,OADA,EAAK,IAAI,CAAK,GACP;EACX,CAAC;CACL,GAAG,CAAC,CAAC,GAEC,IAAS,GAAa,MAAmB;EAC3C,GAAQ,MAAY;GAChB,IAAI,CAAC,EAAQ,IAAI,CAAK,GAAG,OAAO;GAChC,IAAM,IAAO,IAAI,IAAI,CAAO;GAE5B,OADA,EAAK,OAAO,CAAK,GACV;EACX,CAAC;CACL,GAAG,CAAC,CAAC,GAEC,IAAQ,QAAwB;EAClC,GAAQ,MAAa,EAAQ,SAAS,IAAI,oBAAU,IAAI,IAAO,CAAE;CACrE,GAAG,CAAC,CAAC,GAEC,IAAM,GAAa,MAAsB,EAAI,IAAI,CAAK,GAAG,CAAC,CAAG,CAAC,GAE9D,IAAS,GAAa,MAAmB;EAC3C,GAAQ,MAAY;GAChB,IAAM,IAAO,IAAI,IAAI,CAAO;GAG5B,OAFI,EAAK,IAAI,CAAK,IAAG,EAAK,OAAO,CAAK,IACjC,EAAK,IAAI,CAAK,GACZ;EACX,CAAC;CACL,GAAG,CAAC,CAAC;CAEL,OAAO,SACI;EACH;EACA;EACA,QAAQ;EACR;EACA;EACA;EACA,MAAM,EAAI;CACd,IACA;EAAC;EAAK;EAAK;EAAQ;EAAO;EAAK;CAAM,CACzC;AACJ"}
+{"version":3,"file":"use-set.js","names":["useSet","set","setSet","useState","initial","add","useCallback","current","value","next","remove","clear","has","toggle","useMemo"],"sources":["../../src/hooks/use-set.ts"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\n\nexport interface UseSetResult<T> {\n    set: ReadonlySet<T>;\n    add: (value: T) => void;\n    delete: (value: T) => void;\n    clear: () => void;\n    has: (value: T) => boolean;\n    toggle: (value: T) => void;\n    size: number;\n}\n\n/**\n * Reactive `Set` wrapper. Mutating via `add` / `delete` / `clear` / `toggle`\n * triggers a re-render and yields a fresh `set` reference each time.\n *\n * @typeParam T - element type.\n * @param initial - initial values.\n * @returns `{ set, add, delete, clear, has, toggle, size }`.\n */\nexport function useSet<T>(initial?: Iterable<T>): UseSetResult<T> {\n    const [set, setSet] = useState<Set<T>>(() => new Set(initial));\n\n    const add = useCallback((value: T): void => {\n        setSet((current) => {\n            if (current.has(value)) return current;\n            const next = new Set(current);\n            next.add(value);\n            return next;\n        });\n    }, []);\n\n    const remove = useCallback((value: T): void => {\n        setSet((current) => {\n            if (!current.has(value)) return current;\n            const next = new Set(current);\n            next.delete(value);\n            return next;\n        });\n    }, []);\n\n    const clear = useCallback((): void => {\n        setSet((current) => (current.size === 0 ? current : new Set<T>()));\n    }, []);\n\n    const has = useCallback((value: T): boolean => set.has(value), [set]);\n\n    const toggle = useCallback((value: T): void => {\n        setSet((current) => {\n            const next = new Set(current);\n            if (next.has(value)) next.delete(value);\n            else next.add(value);\n            return next;\n        });\n    }, []);\n\n    return useMemo<UseSetResult<T>>(\n        () => ({\n            set,\n            add,\n            delete: remove,\n            clear,\n            has,\n            toggle,\n            size: set.size,\n        }),\n        [set, add, remove, clear, has, toggle],\n    );\n}\n"],"mappings":";;AAoBA,SAAgBA,EAAU,GAAwC;CAC9D,IAAM,CAACC,GAAKC,KAAUC,QAAuB,IAAI,IAAIC,CAAO,CAAC,GAEvDC,IAAMC,GAAa,MAAmB;EACxC,GAAQ,MAAY;GAChB,IAAIC,EAAQ,IAAIC,CAAK,GAAG,OAAOD;GAC/B,IAAME,IAAO,IAAI,IAAIF,CAAO;GAE5B,OADAE,EAAK,IAAID,CAAK,GACPC;EACX,CAAC;CACL,GAAG,CAAC,CAAC,GAECC,IAASJ,GAAa,MAAmB;EAC3C,GAAQ,MAAY;GAChB,IAAI,CAACC,EAAQ,IAAIC,CAAK,GAAG,OAAOD;GAChC,IAAME,IAAO,IAAI,IAAIF,CAAO;GAE5B,OADAE,EAAK,OAAOD,CAAK,GACVC;EACX,CAAC;CACL,GAAG,CAAC,CAAC,GAECE,IAAQL,QAAwB;EAClC,GAAQ,MAAaC,EAAQ,SAAS,IAAIA,oBAAU,IAAI,IAAO,CAAE;CACrE,GAAG,CAAC,CAAC,GAECK,IAAMN,GAAa,MAAsBL,EAAI,IAAIO,CAAK,GAAG,CAACP,CAAG,CAAC,GAE9DY,IAASP,GAAa,MAAmB;EAC3C,GAAQ,MAAY;GAChB,IAAMG,IAAO,IAAI,IAAIF,CAAO;GAG5B,OAFIE,EAAK,IAAID,CAAK,IAAGC,EAAK,OAAOD,CAAK,IACjCC,EAAK,IAAID,CAAK,GACZC;EACX,CAAC;CACL,GAAG,CAAC,CAAC;CAEL,OAAOK,SACI;EACH;EACA;EACA,QAAQJ;EACR;EACA;EACA;EACA,MAAMT,EAAI;CACd,IACA;EAACA;EAAKI;EAAKK;EAAQC;EAAOC;EAAKC;CAAM,CACzC;AACJ"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-sortable.cjs","names":[],"sources":["../../src/hooks/use-sortable.ts"],"sourcesContent":["/**\n * @tempest-limits file-lines, hook-lines — drag-and-drop with a keyboard path that\n * has to produce the same moves as the pointer path: pointer capture, auto-scroll\n * near the edges, the drop-index maths and the live-region announcements all read\n * one drag state. Two hooks would mean two copies of the index arithmetic, and the\n * two paths silently disagreeing is the bug this exists to prevent.\n */\nimport { useCallback, useEffect, useRef, useState } from \"react\";\nimport type { KeyboardEvent as ReactKeyboardEvent, PointerEvent as ReactPointerEvent } from \"react\";\n\n/** Where a dragged item would land if dropped now. */\nexport interface SortableDropTarget {\n    /** Index the item started at, within its own group. */\n    from: number;\n    /** Index it would move to, within the destination group. */\n    to: number;\n    /**\n     * Group the item started in — a Kanban column, for instance. `undefined` for a\n     * plain single-list sortable.\n     */\n    fromGroup?: string;\n    /** Destination group. Equal to `fromGroup` when the move stays in one group. */\n    toGroup?: string;\n}\n\n/** Props to spread on each sortable item. */\nexport interface SortableItemProps {\n    /** Marks the item for hit-testing. */\n    \"data-sortable-index\": number;\n    /** Group the item belongs to, when the sortable spans several lists. */\n    \"data-sortable-group\"?: string;\n    /** `true` while this item is the one being moved. */\n    \"data-sortable-active\"?: boolean;\n    /** Grab handle wiring: starts a pointer drag. */\n    onPointerDown: (event: ReactPointerEvent<HTMLElement>) => void;\n    /** Keyboard reordering — see {@link UseSortableResult}. */\n    onKeyDown: (event: ReactKeyboardEvent<HTMLElement>) => void;\n    /** Puts the item in the tab order so the keyboard path is reachable. */\n    tabIndex: number;\n    role: \"option\";\n    \"aria-roledescription\": string;\n    \"aria-selected\": boolean;\n}\n\nexport interface UseSortableOptions {\n    /**\n     * How many items are in the sortable. Changing it cancels an in-flight drag.\n     *\n     * With groups, pass the **total** across groups: the number only has to change\n     * whenever the indices the drag was based on stop being valid.\n     */\n    itemCount: number;\n    /**\n     * Called once, when a move is committed — on pointer release or on a keyboard\n     * move. Never called mid-drag, so a controlled list re-renders once instead of\n     * on every pointer frame.\n     */\n    onReorder: (target: SortableDropTarget) => void;\n    /** Blocks all interaction. */\n    disabled?: boolean;\n    /**\n     * Description announced for each item, so a screen reader user learns the\n     * keyboard contract. Default is in English — override it to localize.\n     */\n    roleDescription?: string;\n}\n\nexport interface UseSortableResult {\n    /** Index being dragged, or `null` when idle. */\n    activeIndex: number | null;\n    /** Index the item would land on, or `null` when idle. */\n    overIndex: number | null;\n    /** Group the dragged item came from, when using groups. */\n    activeGroup?: string;\n    /** Group the item is currently over, when using groups. */\n    overGroup?: string;\n    /**\n     * Spread on each item. Pass `group` when the sortable spans several lists (a\n     * Kanban column id), so a drop can land in a different group.\n     */\n    getItemProps: (index: number, group?: string) => SortableItemProps;\n    /**\n     * Spread on an **empty** group's drop area, so an item can be moved into a\n     * column that has no cards yet — hit-testing works off item rects, and a group\n     * with no items has none.\n     */\n    getEmptyGroupProps: (group: string) => {\n        \"data-sortable-group\": string;\n        \"data-sortable-empty\": true;\n    };\n    /** Spread on the list container (`role=\"listbox\"` + a label of your own). */\n    getListProps: () => { role: \"listbox\"; \"aria-orientation\": \"vertical\" };\n    /** Abort the current drag without reordering. */\n    cancel: () => void;\n    /**\n     * Callback ref for the element that contains the sortable items — hit-testing\n     * searches inside it.\n     *\n     * Named `setContainer` rather than `ref` because it is a **callback**, not a ref\n     * object: `ref={sortable.setContainer}`. The old name also read as a readable\n     * ref to the React Compiler rules, which flagged every consumer.\n     */\n    setContainer: (node: HTMLElement | null) => void;\n}\n\n/** Reorder helper: move `from` to `to`, returning a new array. */\nexport function moveItem<T>(items: T[], from: number, to: number): T[] {\n    if (from === to || from < 0 || to < 0 || from >= items.length || to >= items.length) {\n        return items;\n    }\n    const next = items.slice();\n    const [moved] = next.splice(from, 1);\n    next.splice(to, 0, moved);\n    return next;\n}\n\n/** A hit-test result: the item (or empty group) under the pointer. */\ninterface HitTarget {\n    index: number;\n    group?: string;\n}\n\n/**\n * Find the sortable slot under a viewport point.\n *\n * Items are tried first; an empty group's drop area is only considered when no item\n * matched, since an empty column is a fallback target rather than a competing one.\n */\nfunction targetAtPoint(container: HTMLElement | null, x: number, y: number): HitTarget | null {\n    if (!container) return null;\n    const inside = (element: HTMLElement): boolean => {\n        const rect = element.getBoundingClientRect();\n        return y >= rect.top && y <= rect.bottom && x >= rect.left && x <= rect.right;\n    };\n\n    for (const item of Array.from(\n        container.querySelectorAll<HTMLElement>(\"[data-sortable-index]\"),\n    )) {\n        if (!inside(item)) continue;\n        const index = Number(item.dataset.sortableIndex);\n        if (Number.isNaN(index)) return null;\n        return { index, group: item.dataset.sortableGroup };\n    }\n\n    for (const empty of Array.from(\n        container.querySelectorAll<HTMLElement>(\"[data-sortable-empty]\"),\n    )) {\n        if (inside(empty)) return { index: 0, group: empty.dataset.sortableGroup };\n    }\n\n    return null;\n}\n\n/**\n * Drag-to-reorder for a list, with a **keyboard path of equal standing**.\n *\n * Pointer events cover mouse, touch and stylus through one code path, and pointer\n * capture keeps the drag alive when the pointer leaves the item. `Space` picks an\n * item up, the arrows move it, `Space`/`Enter` drops it and `Escape` cancels —\n * because a reorder that only works by dragging excludes keyboard users\n * completely, which is where most drag-and-drop implementations fail.\n *\n * The hook owns interaction only: it never mutates your data. `onReorder` fires\n * once per committed move and you apply it, typically with {@link moveItem}. That\n * keeps the list a controlled value and avoids a re-render per pointer frame.\n *\n * Hit-testing reads the live DOM rects of `[data-sortable-index]` children rather\n * than assuming a fixed row height, so it works with rows of different sizes.\n *\n * A change in `itemCount` cancels an in-flight drag: the list no longer has the\n * indices the drag was based on, and committing anyway would move the wrong row.\n *\n * Note for consumers: the indices and groups are exposed as **state** (so rendering\n * from them is reactive) and mirrored into refs only so the window-level `pointerup`\n * listener can read both synchronously. Because the handlers returned by\n * `getItemProps` close over those mirrors, the React Compiler `refs` rule reports\n * the *call site* — a component spreading these props may need a file-level\n * exemption, as `Kanban` documents.\n *\n * @example\n * ```tsx\n * const [items, setItems] = useState([\"Alfa\", \"Bravo\", \"Charlie\"]);\n * const sortable = useSortable({\n *   itemCount: items.length,\n *   onReorder: ({ from, to }) => setItems((current) => moveItem(current, from, to)),\n * });\n *\n * <ul {...sortable.getListProps()} aria-label=\"Prioridade\" ref={sortable.setContainer}>\n *   {items.map((item, index) => (\n *     <li key={item} {...sortable.getItemProps(index)}>\n *       {item}\n *     </li>\n *   ))}\n * </ul>\n * ```\n */\nexport function useSortable(options: UseSortableOptions): UseSortableResult {\n    const { itemCount, onReorder, disabled = false, roleDescription = \"Sortable item\" } = options;\n\n    const [activeIndex, setActiveIndexState] = useState<number | null>(null);\n    const [overIndex, setOverIndexState] = useState<number | null>(null);\n    const containerRef = useRef<HTMLElement | null>(null);\n    const onReorderRef = useRef(onReorder);\n\n    /**\n     * Mirrors of the two indices.\n     *\n     * The window-level `pointerup` listener has to read both values *synchronously*\n     * to know what to commit, and a state setter only exposes one of them. Mirroring\n     * into refs keeps the commit readable instead of nesting setters to smuggle the\n     * other value out.\n     */\n    const activeRef = useRef<number | null>(null);\n    const overRef = useRef<number | null>(null);\n    const [activeGroup, setActiveGroupState] = useState<string | undefined>(undefined);\n    const [overGroup, setOverGroupState] = useState<string | undefined>(undefined);\n    const activeGroupRef = useRef<string | undefined>(undefined);\n    const overGroupRef = useRef<string | undefined>(undefined);\n\n    const setActiveGroup = useCallback((value: string | undefined): void => {\n        activeGroupRef.current = value;\n        setActiveGroupState(value);\n    }, []);\n\n    const setOverGroup = useCallback((value: string | undefined): void => {\n        overGroupRef.current = value;\n        setOverGroupState(value);\n    }, []);\n\n    const setActiveIndex = useCallback((value: number | null): void => {\n        activeRef.current = value;\n        setActiveIndexState(value);\n    }, []);\n\n    const setOverIndex = useCallback((value: number | null): void => {\n        overRef.current = value;\n        setOverIndexState(value);\n    }, []);\n\n    useEffect(() => {\n        onReorderRef.current = onReorder;\n    }, [onReorder]);\n\n    const reset = useCallback((): void => {\n        setActiveGroup(undefined);\n        setOverGroup(undefined);\n        setActiveIndex(null);\n        setOverIndex(null);\n    }, [setActiveGroup, setActiveIndex, setOverGroup, setOverIndex]);\n\n    useEffect(() => {\n        reset();\n    }, [itemCount, reset]);\n\n    /**\n     * Report a committed move and go back to idle.\n     *\n     * The groups are **arguments**, not reads of the mirror refs: `commit` ends up\n     * inside the props returned by `getItemProps`, which render calls, and a ref read\n     * anywhere in that closure chain is a render-time ref access. The pointer\n     * listener reads the mirrors itself — it is an event handler, where reading is\n     * fine — and hands the values over.\n     *\n     * A move that changes group counts even at the same index (the card lands in\n     * another column), so only a same-group, same-index drop is \"nothing happened\".\n     */\n    const commit = useCallback(\n        (from: number, to: number, fromGroup?: string, toGroup?: string): void => {\n            if (from !== to || fromGroup !== toGroup) {\n                onReorderRef.current({ from, to, fromGroup, toGroup });\n            }\n            reset();\n        },\n        [reset],\n    );\n\n    const setContainer = useCallback((node: HTMLElement | null): void => {\n        containerRef.current = node;\n    }, []);\n\n    const handlePointerDown = useCallback(\n        (index: number, group: string | undefined, event: ReactPointerEvent<HTMLElement>): void => {\n            if (disabled) return;\n            event.currentTarget.setPointerCapture?.(event.pointerId);\n            setActiveGroup(group);\n            setOverGroup(group);\n            setActiveIndex(index);\n            setOverIndex(index);\n        },\n        [disabled, setActiveGroup, setActiveIndex, setOverGroup, setOverIndex],\n    );\n\n    useEffect(() => {\n        if (activeIndex === null) return;\n\n        function onPointerMove(event: PointerEvent): void {\n            const target = targetAtPoint(containerRef.current, event.clientX, event.clientY);\n            if (!target) return;\n            setOverGroup(target.group);\n            setOverIndex(target.index);\n        }\n\n        function onPointerUp(): void {\n            const from = activeRef.current;\n            const to = overRef.current;\n            if (from !== null && to !== null) {\n                commit(from, to, activeGroupRef.current, overGroupRef.current);\n            } else {\n                reset();\n            }\n        }\n\n        /**\n         * Cancel the drag on `Escape`.\n         *\n         * Listened in the capture phase and marked consumed: the overlays' shared\n         * `Escape` listener sits on `window` in the bubble phase, so a list sorted\n         * inside a `Modal` would otherwise close the modal mid-drag instead of\n         * just dropping the item back.\n         */\n        function onKeyDown(event: KeyboardEvent): void {\n            if (event.key !== \"Escape\") return;\n            event.preventDefault();\n            reset();\n        }\n\n        window.addEventListener(\"pointermove\", onPointerMove);\n        window.addEventListener(\"pointerup\", onPointerUp);\n        window.addEventListener(\"pointercancel\", reset);\n        window.addEventListener(\"keydown\", onKeyDown, true);\n        return () => {\n            window.removeEventListener(\"pointermove\", onPointerMove);\n            window.removeEventListener(\"pointerup\", onPointerUp);\n            window.removeEventListener(\"pointercancel\", reset);\n            window.removeEventListener(\"keydown\", onKeyDown, true);\n        };\n    }, [activeIndex, commit, reset, setOverGroup, setOverIndex]);\n\n    const handleKeyDown = useCallback(\n        (\n            index: number,\n            group: string | undefined,\n            event: ReactKeyboardEvent<HTMLElement>,\n        ): void => {\n            if (disabled) return;\n            const picked = activeIndex !== null;\n\n            switch (event.key) {\n                case \" \":\n                case \"Enter\":\n                    event.preventDefault();\n                    if (!picked) {\n                        setActiveGroup(group);\n                        setOverGroup(group);\n                        setActiveIndex(index);\n                        setOverIndex(index);\n                    } else if (overIndex !== null) {\n                        commit(activeIndex, overIndex, activeGroup, overGroup);\n                    }\n                    break;\n                case \"ArrowDown\":\n                case \"ArrowRight\": {\n                    if (!picked) return;\n                    event.preventDefault();\n                    if (overRef.current !== null) {\n                        setOverIndex(Math.min(overRef.current + 1, itemCount - 1));\n                    }\n                    break;\n                }\n                case \"ArrowUp\":\n                case \"ArrowLeft\": {\n                    if (!picked) return;\n                    event.preventDefault();\n                    if (overRef.current !== null) {\n                        setOverIndex(Math.max(overRef.current - 1, 0));\n                    }\n                    break;\n                }\n                case \"Escape\":\n                    if (!picked) return;\n                    event.preventDefault();\n                    reset();\n                    break;\n                default:\n                    break;\n            }\n        },\n        [\n            activeGroup,\n            activeIndex,\n            commit,\n            overGroup,\n            disabled,\n            itemCount,\n            overIndex,\n            reset,\n            setActiveGroup,\n            setActiveIndex,\n            setOverGroup,\n            setOverIndex,\n        ],\n    );\n\n    const getItemProps = useCallback(\n        (index: number, group?: string): SortableItemProps => ({\n            \"data-sortable-index\": index,\n            \"data-sortable-group\": group,\n            \"data-sortable-active\": (activeIndex === index && activeGroup === group) || undefined,\n            onPointerDown: (event) => handlePointerDown(index, group, event),\n            onKeyDown: (event) => handleKeyDown(index, group, event),\n            tabIndex: disabled ? -1 : 0,\n            role: \"option\",\n            \"aria-roledescription\": roleDescription,\n            \"aria-selected\": activeIndex === index && activeGroup === group,\n        }),\n        [activeGroup, activeIndex, disabled, handleKeyDown, handlePointerDown, roleDescription],\n    );\n\n    const getEmptyGroupProps = useCallback(\n        (group: string) => ({ \"data-sortable-group\": group, \"data-sortable-empty\": true as const }),\n        [],\n    );\n\n    const getListProps = useCallback(\n        () => ({ role: \"listbox\" as const, \"aria-orientation\": \"vertical\" as const }),\n        [],\n    );\n\n    return {\n        activeIndex,\n        overIndex,\n        activeGroup,\n        overGroup,\n        getItemProps,\n        getEmptyGroupProps,\n        getListProps,\n        cancel: reset,\n        setContainer,\n    };\n}\n"],"mappings":"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"}
+{"version":3,"file":"use-sortable.cjs","names":["useState","useRef","useCallback","react","moveItem","from","to","items","next","moved","targetAtPoint","container","inside","rect","element","y","x","item","index","empty","useSortable","options","activeIndex","setActiveIndexState","overIndex","setOverIndexState","containerRef","onReorderRef","onReorder","activeRef","overRef","activeGroup","setActiveGroupState","overGroup","setOverGroupState","activeGroupRef","overGroupRef","setActiveGroup","value","setOverGroup","setActiveIndex","setOverIndex","reset","itemCount","commit","fromGroup","toGroup","setContainer","node","handlePointerDown","disabled","event","group","onPointerMove","target","onPointerUp","onKeyDown","handleKeyDown","picked","roleDescription"],"sources":["../../src/hooks/use-sortable.ts"],"sourcesContent":["/**\n * @tempest-limits file-lines, hook-lines — drag-and-drop with a keyboard path that\n * has to produce the same moves as the pointer path: pointer capture, auto-scroll\n * near the edges, the drop-index maths and the live-region announcements all read\n * one drag state. Two hooks would mean two copies of the index arithmetic, and the\n * two paths silently disagreeing is the bug this exists to prevent.\n */\nimport { useCallback, useEffect, useRef, useState } from \"react\";\nimport type { KeyboardEvent as ReactKeyboardEvent, PointerEvent as ReactPointerEvent } from \"react\";\n\n/** Where a dragged item would land if dropped now. */\nexport interface SortableDropTarget {\n    /** Index the item started at, within its own group. */\n    from: number;\n    /** Index it would move to, within the destination group. */\n    to: number;\n    /**\n     * Group the item started in — a Kanban column, for instance. `undefined` for a\n     * plain single-list sortable.\n     */\n    fromGroup?: string;\n    /** Destination group. Equal to `fromGroup` when the move stays in one group. */\n    toGroup?: string;\n}\n\n/** Props to spread on each sortable item. */\nexport interface SortableItemProps {\n    /** Marks the item for hit-testing. */\n    \"data-sortable-index\": number;\n    /** Group the item belongs to, when the sortable spans several lists. */\n    \"data-sortable-group\"?: string;\n    /** `true` while this item is the one being moved. */\n    \"data-sortable-active\"?: boolean;\n    /** Grab handle wiring: starts a pointer drag. */\n    onPointerDown: (event: ReactPointerEvent<HTMLElement>) => void;\n    /** Keyboard reordering — see {@link UseSortableResult}. */\n    onKeyDown: (event: ReactKeyboardEvent<HTMLElement>) => void;\n    /** Puts the item in the tab order so the keyboard path is reachable. */\n    tabIndex: number;\n    role: \"option\";\n    \"aria-roledescription\": string;\n    \"aria-selected\": boolean;\n}\n\nexport interface UseSortableOptions {\n    /**\n     * How many items are in the sortable. Changing it cancels an in-flight drag.\n     *\n     * With groups, pass the **total** across groups: the number only has to change\n     * whenever the indices the drag was based on stop being valid.\n     */\n    itemCount: number;\n    /**\n     * Called once, when a move is committed — on pointer release or on a keyboard\n     * move. Never called mid-drag, so a controlled list re-renders once instead of\n     * on every pointer frame.\n     */\n    onReorder: (target: SortableDropTarget) => void;\n    /** Blocks all interaction. */\n    disabled?: boolean;\n    /**\n     * Description announced for each item, so a screen reader user learns the\n     * keyboard contract. Default is in English — override it to localize.\n     */\n    roleDescription?: string;\n}\n\nexport interface UseSortableResult {\n    /** Index being dragged, or `null` when idle. */\n    activeIndex: number | null;\n    /** Index the item would land on, or `null` when idle. */\n    overIndex: number | null;\n    /** Group the dragged item came from, when using groups. */\n    activeGroup?: string;\n    /** Group the item is currently over, when using groups. */\n    overGroup?: string;\n    /**\n     * Spread on each item. Pass `group` when the sortable spans several lists (a\n     * Kanban column id), so a drop can land in a different group.\n     */\n    getItemProps: (index: number, group?: string) => SortableItemProps;\n    /**\n     * Spread on an **empty** group's drop area, so an item can be moved into a\n     * column that has no cards yet — hit-testing works off item rects, and a group\n     * with no items has none.\n     */\n    getEmptyGroupProps: (group: string) => {\n        \"data-sortable-group\": string;\n        \"data-sortable-empty\": true;\n    };\n    /** Spread on the list container (`role=\"listbox\"` + a label of your own). */\n    getListProps: () => { role: \"listbox\"; \"aria-orientation\": \"vertical\" };\n    /** Abort the current drag without reordering. */\n    cancel: () => void;\n    /**\n     * Callback ref for the element that contains the sortable items — hit-testing\n     * searches inside it.\n     *\n     * Named `setContainer` rather than `ref` because it is a **callback**, not a ref\n     * object: `ref={sortable.setContainer}`. The old name also read as a readable\n     * ref to the React Compiler rules, which flagged every consumer.\n     */\n    setContainer: (node: HTMLElement | null) => void;\n}\n\n/** Reorder helper: move `from` to `to`, returning a new array. */\nexport function moveItem<T>(items: T[], from: number, to: number): T[] {\n    if (from === to || from < 0 || to < 0 || from >= items.length || to >= items.length) {\n        return items;\n    }\n    const next = items.slice();\n    const [moved] = next.splice(from, 1);\n    next.splice(to, 0, moved);\n    return next;\n}\n\n/** A hit-test result: the item (or empty group) under the pointer. */\ninterface HitTarget {\n    index: number;\n    group?: string;\n}\n\n/**\n * Find the sortable slot under a viewport point.\n *\n * Items are tried first; an empty group's drop area is only considered when no item\n * matched, since an empty column is a fallback target rather than a competing one.\n */\nfunction targetAtPoint(container: HTMLElement | null, x: number, y: number): HitTarget | null {\n    if (!container) return null;\n    const inside = (element: HTMLElement): boolean => {\n        const rect = element.getBoundingClientRect();\n        return y >= rect.top && y <= rect.bottom && x >= rect.left && x <= rect.right;\n    };\n\n    for (const item of Array.from(\n        container.querySelectorAll<HTMLElement>(\"[data-sortable-index]\"),\n    )) {\n        if (!inside(item)) continue;\n        const index = Number(item.dataset.sortableIndex);\n        if (Number.isNaN(index)) return null;\n        return { index, group: item.dataset.sortableGroup };\n    }\n\n    for (const empty of Array.from(\n        container.querySelectorAll<HTMLElement>(\"[data-sortable-empty]\"),\n    )) {\n        if (inside(empty)) return { index: 0, group: empty.dataset.sortableGroup };\n    }\n\n    return null;\n}\n\n/**\n * Drag-to-reorder for a list, with a **keyboard path of equal standing**.\n *\n * Pointer events cover mouse, touch and stylus through one code path, and pointer\n * capture keeps the drag alive when the pointer leaves the item. `Space` picks an\n * item up, the arrows move it, `Space`/`Enter` drops it and `Escape` cancels —\n * because a reorder that only works by dragging excludes keyboard users\n * completely, which is where most drag-and-drop implementations fail.\n *\n * The hook owns interaction only: it never mutates your data. `onReorder` fires\n * once per committed move and you apply it, typically with {@link moveItem}. That\n * keeps the list a controlled value and avoids a re-render per pointer frame.\n *\n * Hit-testing reads the live DOM rects of `[data-sortable-index]` children rather\n * than assuming a fixed row height, so it works with rows of different sizes.\n *\n * A change in `itemCount` cancels an in-flight drag: the list no longer has the\n * indices the drag was based on, and committing anyway would move the wrong row.\n *\n * Note for consumers: the indices and groups are exposed as **state** (so rendering\n * from them is reactive) and mirrored into refs only so the window-level `pointerup`\n * listener can read both synchronously. Because the handlers returned by\n * `getItemProps` close over those mirrors, the React Compiler `refs` rule reports\n * the *call site* — a component spreading these props may need a file-level\n * exemption, as `Kanban` documents.\n *\n * @example\n * ```tsx\n * const [items, setItems] = useState([\"Alfa\", \"Bravo\", \"Charlie\"]);\n * const sortable = useSortable({\n *   itemCount: items.length,\n *   onReorder: ({ from, to }) => setItems((current) => moveItem(current, from, to)),\n * });\n *\n * <ul {...sortable.getListProps()} aria-label=\"Prioridade\" ref={sortable.setContainer}>\n *   {items.map((item, index) => (\n *     <li key={item} {...sortable.getItemProps(index)}>\n *       {item}\n *     </li>\n *   ))}\n * </ul>\n * ```\n */\nexport function useSortable(options: UseSortableOptions): UseSortableResult {\n    const { itemCount, onReorder, disabled = false, roleDescription = \"Sortable item\" } = options;\n\n    const [activeIndex, setActiveIndexState] = useState<number | null>(null);\n    const [overIndex, setOverIndexState] = useState<number | null>(null);\n    const containerRef = useRef<HTMLElement | null>(null);\n    const onReorderRef = useRef(onReorder);\n\n    /**\n     * Mirrors of the two indices.\n     *\n     * The window-level `pointerup` listener has to read both values *synchronously*\n     * to know what to commit, and a state setter only exposes one of them. Mirroring\n     * into refs keeps the commit readable instead of nesting setters to smuggle the\n     * other value out.\n     */\n    const activeRef = useRef<number | null>(null);\n    const overRef = useRef<number | null>(null);\n    const [activeGroup, setActiveGroupState] = useState<string | undefined>(undefined);\n    const [overGroup, setOverGroupState] = useState<string | undefined>(undefined);\n    const activeGroupRef = useRef<string | undefined>(undefined);\n    const overGroupRef = useRef<string | undefined>(undefined);\n\n    const setActiveGroup = useCallback((value: string | undefined): void => {\n        activeGroupRef.current = value;\n        setActiveGroupState(value);\n    }, []);\n\n    const setOverGroup = useCallback((value: string | undefined): void => {\n        overGroupRef.current = value;\n        setOverGroupState(value);\n    }, []);\n\n    const setActiveIndex = useCallback((value: number | null): void => {\n        activeRef.current = value;\n        setActiveIndexState(value);\n    }, []);\n\n    const setOverIndex = useCallback((value: number | null): void => {\n        overRef.current = value;\n        setOverIndexState(value);\n    }, []);\n\n    useEffect(() => {\n        onReorderRef.current = onReorder;\n    }, [onReorder]);\n\n    const reset = useCallback((): void => {\n        setActiveGroup(undefined);\n        setOverGroup(undefined);\n        setActiveIndex(null);\n        setOverIndex(null);\n    }, [setActiveGroup, setActiveIndex, setOverGroup, setOverIndex]);\n\n    useEffect(() => {\n        reset();\n    }, [itemCount, reset]);\n\n    /**\n     * Report a committed move and go back to idle.\n     *\n     * The groups are **arguments**, not reads of the mirror refs: `commit` ends up\n     * inside the props returned by `getItemProps`, which render calls, and a ref read\n     * anywhere in that closure chain is a render-time ref access. The pointer\n     * listener reads the mirrors itself — it is an event handler, where reading is\n     * fine — and hands the values over.\n     *\n     * A move that changes group counts even at the same index (the card lands in\n     * another column), so only a same-group, same-index drop is \"nothing happened\".\n     */\n    const commit = useCallback(\n        (from: number, to: number, fromGroup?: string, toGroup?: string): void => {\n            if (from !== to || fromGroup !== toGroup) {\n                onReorderRef.current({ from, to, fromGroup, toGroup });\n            }\n            reset();\n        },\n        [reset],\n    );\n\n    const setContainer = useCallback((node: HTMLElement | null): void => {\n        containerRef.current = node;\n    }, []);\n\n    const handlePointerDown = useCallback(\n        (index: number, group: string | undefined, event: ReactPointerEvent<HTMLElement>): void => {\n            if (disabled) return;\n            event.currentTarget.setPointerCapture?.(event.pointerId);\n            setActiveGroup(group);\n            setOverGroup(group);\n            setActiveIndex(index);\n            setOverIndex(index);\n        },\n        [disabled, setActiveGroup, setActiveIndex, setOverGroup, setOverIndex],\n    );\n\n    useEffect(() => {\n        if (activeIndex === null) return;\n\n        function onPointerMove(event: PointerEvent): void {\n            const target = targetAtPoint(containerRef.current, event.clientX, event.clientY);\n            if (!target) return;\n            setOverGroup(target.group);\n            setOverIndex(target.index);\n        }\n\n        function onPointerUp(): void {\n            const from = activeRef.current;\n            const to = overRef.current;\n            if (from !== null && to !== null) {\n                commit(from, to, activeGroupRef.current, overGroupRef.current);\n            } else {\n                reset();\n            }\n        }\n\n        /**\n         * Cancel the drag on `Escape`.\n         *\n         * Listened in the capture phase and marked consumed: the overlays' shared\n         * `Escape` listener sits on `window` in the bubble phase, so a list sorted\n         * inside a `Modal` would otherwise close the modal mid-drag instead of\n         * just dropping the item back.\n         */\n        function onKeyDown(event: KeyboardEvent): void {\n            if (event.key !== \"Escape\") return;\n            event.preventDefault();\n            reset();\n        }\n\n        window.addEventListener(\"pointermove\", onPointerMove);\n        window.addEventListener(\"pointerup\", onPointerUp);\n        window.addEventListener(\"pointercancel\", reset);\n        window.addEventListener(\"keydown\", onKeyDown, true);\n        return () => {\n            window.removeEventListener(\"pointermove\", onPointerMove);\n            window.removeEventListener(\"pointerup\", onPointerUp);\n            window.removeEventListener(\"pointercancel\", reset);\n            window.removeEventListener(\"keydown\", onKeyDown, true);\n        };\n    }, [activeIndex, commit, reset, setOverGroup, setOverIndex]);\n\n    const handleKeyDown = useCallback(\n        (\n            index: number,\n            group: string | undefined,\n            event: ReactKeyboardEvent<HTMLElement>,\n        ): void => {\n            if (disabled) return;\n            const picked = activeIndex !== null;\n\n            switch (event.key) {\n                case \" \":\n                case \"Enter\":\n                    event.preventDefault();\n                    if (!picked) {\n                        setActiveGroup(group);\n                        setOverGroup(group);\n                        setActiveIndex(index);\n                        setOverIndex(index);\n                    } else if (overIndex !== null) {\n                        commit(activeIndex, overIndex, activeGroup, overGroup);\n                    }\n                    break;\n                case \"ArrowDown\":\n                case \"ArrowRight\": {\n                    if (!picked) return;\n                    event.preventDefault();\n                    if (overRef.current !== null) {\n                        setOverIndex(Math.min(overRef.current + 1, itemCount - 1));\n                    }\n                    break;\n                }\n                case \"ArrowUp\":\n                case \"ArrowLeft\": {\n                    if (!picked) return;\n                    event.preventDefault();\n                    if (overRef.current !== null) {\n                        setOverIndex(Math.max(overRef.current - 1, 0));\n                    }\n                    break;\n                }\n                case \"Escape\":\n                    if (!picked) return;\n                    event.preventDefault();\n                    reset();\n                    break;\n                default:\n                    break;\n            }\n        },\n        [\n            activeGroup,\n            activeIndex,\n            commit,\n            overGroup,\n            disabled,\n            itemCount,\n            overIndex,\n            reset,\n            setActiveGroup,\n            setActiveIndex,\n            setOverGroup,\n            setOverIndex,\n        ],\n    );\n\n    const getItemProps = useCallback(\n        (index: number, group?: string): SortableItemProps => ({\n            \"data-sortable-index\": index,\n            \"data-sortable-group\": group,\n            \"data-sortable-active\": (activeIndex === index && activeGroup === group) || undefined,\n            onPointerDown: (event) => handlePointerDown(index, group, event),\n            onKeyDown: (event) => handleKeyDown(index, group, event),\n            tabIndex: disabled ? -1 : 0,\n            role: \"option\",\n            \"aria-roledescription\": roleDescription,\n            \"aria-selected\": activeIndex === index && activeGroup === group,\n        }),\n        [activeGroup, activeIndex, disabled, handleKeyDown, handlePointerDown, roleDescription],\n    );\n\n    const getEmptyGroupProps = useCallback(\n        (group: string) => ({ \"data-sortable-group\": group, \"data-sortable-empty\": true as const }),\n        [],\n    );\n\n    const getListProps = useCallback(\n        () => ({ role: \"listbox\" as const, \"aria-orientation\": \"vertical\" as const }),\n        [],\n    );\n\n    return {\n        activeIndex,\n        overIndex,\n        activeGroup,\n        overGroup,\n        getItemProps,\n        getEmptyGroupProps,\n        getListProps,\n        cancel: reset,\n        setContainer,\n    };\n}\n"],"mappings":"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"}