tempest-react-sdk 0.77.0 → 0.79.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/hooks/use-fullscreen.cjs

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

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

@@ -1 +1 @@
-{"version":3,"file":"use-fullscreen.cjs","names":[],"sources":["../../src/hooks/use-fullscreen.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\nimport { getFullscreenElement, useFullscreenElement } from \"./use-fullscreen-element\";\n\n/**\n * The fullscreen members of `document` this hook calls, standard and\n * vendor-prefixed, every one of them optional.\n *\n * `lib.dom` declares the standard members as always present, which is a promise\n * the runtime does not keep: an older WebKit ships only the prefixed pair, and a\n * document inside an `<iframe>` without `allowfullscreen` reports\n * `fullscreenEnabled: false`. Reading through an all-optional shape is what makes\n * `typeof x === \"function\"` a check the compiler agrees is worth making.\n */\ninterface FullscreenDocument {\n    fullscreenEnabled?: boolean;\n    exitFullscreen?: () => Promise<void>;\n    webkitFullscreenEnabled?: boolean;\n    webkitExitFullscreen?: () => Promise<void> | void;\n}\n\n/** The fullscreen members of an element, standard and vendor-prefixed. */\ninterface FullscreenTarget {\n    requestFullscreen?: (options?: FullscreenOptions) => Promise<void>;\n    webkitRequestFullscreen?: () => Promise<void> | void;\n}\n\n/**\n * Resolve which element the hook acts on.\n *\n * `ref.current` when a ref was given, `document.documentElement` when it was not\n * — the whole page, which is what \"go fullscreen\" means with no element named.\n *\n * A missing `ref.current` deliberately resolves to `null` rather than falling\n * back to the page: a caller who named an element and whose element is not\n * mounted yet wants an error, not the entire document blown up to fill the\n * screen behind their video.\n *\n * @param ref - The element to present, or `undefined` for the whole page.\n * @returns The element, or `null` when there is nothing to act on.\n */\nfunction resolveTarget(ref?: RefObject<HTMLElement | null>): HTMLElement | null {\n    if (typeof document === \"undefined\") return null;\n    return ref ? ref.current : document.documentElement;\n}\n\n/**\n * Whether this environment can present anything fullscreen at all.\n *\n * Two independent reasons for `false`, and skipping either one ships a button\n * that does nothing when pressed: the API can be missing (older WebKit, and every\n * browser on iOS for non-`<video>` elements), or present and **disabled** — a\n * document inside an `<iframe>` without the `allowfullscreen` attribute exposes\n * `requestFullscreen` and rejects every call to it, which `fullscreenEnabled`\n * reports up front.\n *\n * An engine that exposes the methods and no flag at all is treated as capable:\n * the flag is the newer half of the API, so its absence says nothing.\n *\n * @returns `true` when a fullscreen request stands a chance of being honoured.\n */\nexport function isFullscreenSupported(): boolean {\n    if (typeof document === \"undefined\") return false;\n    const root: FullscreenTarget = document.documentElement;\n    const doc: FullscreenDocument = document;\n    const reachable =\n        typeof root.requestFullscreen === \"function\" ||\n        typeof root.webkitRequestFullscreen === \"function\";\n    return reachable && (doc.fullscreenEnabled ?? doc.webkitFullscreenEnabled ?? true);\n}\n\n/** Value returned by {@link useFullscreen}. */\nexport interface UseFullscreenResult {\n    /** Whether the target element is the one the browser is presenting right now. */\n    isFullscreen: boolean;\n    /** Whether a request stands a chance at all — hide the control when `false`. */\n    supported: boolean;\n    /** Present the target. Must be called from a user gesture. Rejects if refused. */\n    enter: () => Promise<void>;\n    /** Leave fullscreen. Resolves immediately when nothing is presented. */\n    exit: () => Promise<void>;\n    /** Leave if the target is presented, otherwise enter. Same gesture rule as `enter`. */\n    toggle: () => Promise<void>;\n}\n\n/**\n * Drive an immersive mode whose state stays true to the browser.\n *\n * The mistake this exists to remove is storing `isFullscreen` in state and\n * flipping it inside your own `enter()` / `exit()`. Fullscreen ends in ways your\n * code never sees — `Esc`, the browser's own exit affordance, F11 pressed while an\n * API fullscreen is active — and each of those leaves the flag saying \"sair\" over\n * a page that is already windowed. The only honest source is the\n * `fullscreenchange` event, which fires for every one of them, so that is what\n * this hook reads and what the returned `isFullscreen` reflects. The action\n * callbacks never touch it.\n *\n * The subscription is not this hook's own: it lives in `useFullscreenElement`,\n * shared with `usePortalHost`, which needs the same fact to decide where an\n * overlay mounts while fullscreen is on. Two independent listeners for one event\n * would mean two copies of the WebKit prefix dance and two places to fix the next\n * quirk, so the primitive answers \"which element is presented\" once and each\n * consumer asks its own question of the answer.\n *\n * WebKit's prefixed members are handled throughout — `webkitfullscreenchange`,\n * `webkitFullscreenElement`, `webkitRequestFullscreen`, `webkitExitFullscreen` —\n * because Safari on iPad still ships them and nothing else.\n *\n * `isFullscreen` is identity against the target, not containment: a `<video>`\n * inside your element going fullscreen on its own is not your element being\n * presented, and reporting `true` there would put your exit control inside a\n * subtree the browser is not painting.\n *\n * @param ref - The element to present. Omit it to present the whole page\n * (`document.documentElement`).\n * @returns `{ isFullscreen, supported, enter, exit, toggle }`.\n * @throws Nothing during render. `enter()` and `toggle()` reject with the\n * browser's own error when the request is refused — most often a `TypeError`\n * because the call did not come from a user gesture — and with an `Error` when\n * there is no element to present or the environment ships no Fullscreen API.\n *\n * @example\n * const stage = useRef<HTMLDivElement>(null);\n * const { isFullscreen, supported, toggle } = useFullscreen(stage);\n *\n * <div ref={stage}>\n *   <video src=\"/aula.mp4\" controls />\n *   {supported ? (\n *     <button onClick={() => void toggle().catch(() => setRefused(true))}>\n *       {isFullscreen ? \"Sair da tela cheia\" : \"Tela cheia\"}\n *     </button>\n *   ) : null}\n * </div>\n */\nexport function useFullscreen(ref?: RefObject<HTMLElement | null>): UseFullscreenResult {\n    const element = useFullscreenElement();\n    const [supported] = useState(isFullscreenSupported);\n    const [isFullscreen, setIsFullscreen] = useState(false);\n\n    useEffect(() => {\n        const target = resolveTarget(ref);\n        setIsFullscreen(target !== null && element === target);\n    }, [element, ref]);\n\n    const enter = useCallback(async (): Promise<void> => {\n        const target = resolveTarget(ref);\n        if (target === null) {\n            throw new Error(\n                \"useFullscreen: nothing to present. Either this environment has no document, \" +\n                    \"or the ref was never attached to a mounted element.\",\n            );\n        }\n        const candidate: FullscreenTarget = target;\n        if (typeof candidate.requestFullscreen === \"function\") {\n            await candidate.requestFullscreen();\n            return;\n        }\n        if (typeof candidate.webkitRequestFullscreen === \"function\") {\n            await candidate.webkitRequestFullscreen();\n            return;\n        }\n        throw new Error(\"useFullscreen: this browser exposes no way to enter fullscreen.\");\n    }, [ref]);\n\n    const exit = useCallback(async (): Promise<void> => {\n        if (getFullscreenElement() === null) return;\n        const doc: FullscreenDocument = document;\n        if (typeof doc.exitFullscreen === \"function\") {\n            await doc.exitFullscreen();\n            return;\n        }\n        if (typeof doc.webkitExitFullscreen === \"function\") {\n            await doc.webkitExitFullscreen();\n            return;\n        }\n        throw new Error(\"useFullscreen: this browser exposes no way to leave fullscreen.\");\n    }, []);\n\n    const toggle = useCallback(async (): Promise<void> => {\n        const target = resolveTarget(ref);\n        if (target !== null && getFullscreenElement() === target) {\n            await exit();\n            return;\n        }\n        await enter();\n    }, [enter, exit, ref]);\n\n    return { isFullscreen, supported, enter, exit, toggle };\n}\n"],"mappings":"uEAyCA,SAAS,EAAc,EAAyD,CAE5E,OADI,OAAO,SAAa,IAAoB,KACrC,EAAM,EAAI,QAAU,SAAS,eACxC,CAiBA,SAAgB,GAAiC,CAC7C,GAAI,OAAO,SAAa,IAAa,MAAO,GAC5C,IAAM,EAAyB,SAAS,gBAClC,EAA0B,SAIhC,OAFI,OAAO,EAAK,mBAAsB,YAClC,OAAO,EAAK,yBAA4B,cACvB,EAAI,mBAAqB,EAAI,yBAA2B,GACjF,CAiEA,SAAgB,EAAc,EAA0D,CACpF,IAAM,EAAU,EAAA,qBAAqB,EAC/B,CAAC,IAAA,EAAa,EAAA,SAAA,CAAS,CAAqB,EAC5C,CAAC,EAAc,IAAA,EAAmB,EAAA,SAAA,CAAS,EAAK,GAEtD,EAAA,EAAA,UAAA,KAAgB,CACZ,IAAM,EAAS,EAAc,CAAG,EAChC,EAAgB,IAAW,MAAQ,IAAY,CAAM,CACzD,EAAG,CAAC,EAAS,CAAG,CAAC,EAEjB,IAAM,GAAA,EAAQ,EAAA,YAAA,CAAY,SAA2B,CACjD,IAAM,EAAS,EAAc,CAAG,EAChC,GAAI,IAAW,KACX,MAAU,MACN,iIAEJ,EAEJ,IAAM,EAA8B,EACpC,GAAI,OAAO,EAAU,mBAAsB,WAAY,CACnD,MAAM,EAAU,kBAAkB,EAClC,MACJ,CACA,GAAI,OAAO,EAAU,yBAA4B,WAAY,CACzD,MAAM,EAAU,wBAAwB,EACxC,MACJ,CACA,MAAU,MAAM,iEAAiE,CACrF,EAAG,CAAC,CAAG,CAAC,EAEF,GAAA,EAAO,EAAA,YAAA,CAAY,SAA2B,CAChD,GAAI,EAAA,qBAAqB,IAAM,KAAM,OACrC,IAAM,EAA0B,SAChC,GAAI,OAAO,EAAI,gBAAmB,WAAY,CAC1C,MAAM,EAAI,eAAe,EACzB,MACJ,CACA,GAAI,OAAO,EAAI,sBAAyB,WAAY,CAChD,MAAM,EAAI,qBAAqB,EAC/B,MACJ,CACA,MAAU,MAAM,iEAAiE,CACrF,EAAG,CAAC,CAAC,EAWL,MAAO,CAAE,eAAc,YAAW,QAAO,OAAM,QAAA,EAThC,EAAA,YAAA,CAAY,SAA2B,CAClD,IAAM,EAAS,EAAc,CAAG,EAChC,GAAI,IAAW,MAAQ,EAAA,qBAAqB,IAAM,EAAQ,CACtD,MAAM,EAAK,EACX,MACJ,CACA,MAAM,EAAM,CAChB,EAAG,CAAC,EAAO,EAAM,CAAG,CAE2B,CAAO,CAC1D"}
+{"version":3,"file":"use-fullscreen.cjs","names":["useFullscreenElement","useState","useCallback","getFullscreenElement","require_use_fullscreen_element","react","resolveTarget","ref","isFullscreenSupported","root","doc","useFullscreen","element","supported","isFullscreen","setIsFullscreen","target","enter","candidate","exit"],"sources":["../../src/hooks/use-fullscreen.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\nimport { getFullscreenElement, useFullscreenElement } from \"./use-fullscreen-element\";\n\n/**\n * The fullscreen members of `document` this hook calls, standard and\n * vendor-prefixed, every one of them optional.\n *\n * `lib.dom` declares the standard members as always present, which is a promise\n * the runtime does not keep: an older WebKit ships only the prefixed pair, and a\n * document inside an `<iframe>` without `allowfullscreen` reports\n * `fullscreenEnabled: false`. Reading through an all-optional shape is what makes\n * `typeof x === \"function\"` a check the compiler agrees is worth making.\n */\ninterface FullscreenDocument {\n    fullscreenEnabled?: boolean;\n    exitFullscreen?: () => Promise<void>;\n    webkitFullscreenEnabled?: boolean;\n    webkitExitFullscreen?: () => Promise<void> | void;\n}\n\n/** The fullscreen members of an element, standard and vendor-prefixed. */\ninterface FullscreenTarget {\n    requestFullscreen?: (options?: FullscreenOptions) => Promise<void>;\n    webkitRequestFullscreen?: () => Promise<void> | void;\n}\n\n/**\n * Resolve which element the hook acts on.\n *\n * `ref.current` when a ref was given, `document.documentElement` when it was not\n * — the whole page, which is what \"go fullscreen\" means with no element named.\n *\n * A missing `ref.current` deliberately resolves to `null` rather than falling\n * back to the page: a caller who named an element and whose element is not\n * mounted yet wants an error, not the entire document blown up to fill the\n * screen behind their video.\n *\n * @param ref - The element to present, or `undefined` for the whole page.\n * @returns The element, or `null` when there is nothing to act on.\n */\nfunction resolveTarget(ref?: RefObject<HTMLElement | null>): HTMLElement | null {\n    if (typeof document === \"undefined\") return null;\n    return ref ? ref.current : document.documentElement;\n}\n\n/**\n * Whether this environment can present anything fullscreen at all.\n *\n * Two independent reasons for `false`, and skipping either one ships a button\n * that does nothing when pressed: the API can be missing (older WebKit, and every\n * browser on iOS for non-`<video>` elements), or present and **disabled** — a\n * document inside an `<iframe>` without the `allowfullscreen` attribute exposes\n * `requestFullscreen` and rejects every call to it, which `fullscreenEnabled`\n * reports up front.\n *\n * An engine that exposes the methods and no flag at all is treated as capable:\n * the flag is the newer half of the API, so its absence says nothing.\n *\n * @returns `true` when a fullscreen request stands a chance of being honoured.\n */\nexport function isFullscreenSupported(): boolean {\n    if (typeof document === \"undefined\") return false;\n    const root: FullscreenTarget = document.documentElement;\n    const doc: FullscreenDocument = document;\n    const reachable =\n        typeof root.requestFullscreen === \"function\" ||\n        typeof root.webkitRequestFullscreen === \"function\";\n    return reachable && (doc.fullscreenEnabled ?? doc.webkitFullscreenEnabled ?? true);\n}\n\n/** Value returned by {@link useFullscreen}. */\nexport interface UseFullscreenResult {\n    /** Whether the target element is the one the browser is presenting right now. */\n    isFullscreen: boolean;\n    /** Whether a request stands a chance at all — hide the control when `false`. */\n    supported: boolean;\n    /** Present the target. Must be called from a user gesture. Rejects if refused. */\n    enter: () => Promise<void>;\n    /** Leave fullscreen. Resolves immediately when nothing is presented. */\n    exit: () => Promise<void>;\n    /** Leave if the target is presented, otherwise enter. Same gesture rule as `enter`. */\n    toggle: () => Promise<void>;\n}\n\n/**\n * Drive an immersive mode whose state stays true to the browser.\n *\n * The mistake this exists to remove is storing `isFullscreen` in state and\n * flipping it inside your own `enter()` / `exit()`. Fullscreen ends in ways your\n * code never sees — `Esc`, the browser's own exit affordance, F11 pressed while an\n * API fullscreen is active — and each of those leaves the flag saying \"sair\" over\n * a page that is already windowed. The only honest source is the\n * `fullscreenchange` event, which fires for every one of them, so that is what\n * this hook reads and what the returned `isFullscreen` reflects. The action\n * callbacks never touch it.\n *\n * The subscription is not this hook's own: it lives in `useFullscreenElement`,\n * shared with `usePortalHost`, which needs the same fact to decide where an\n * overlay mounts while fullscreen is on. Two independent listeners for one event\n * would mean two copies of the WebKit prefix dance and two places to fix the next\n * quirk, so the primitive answers \"which element is presented\" once and each\n * consumer asks its own question of the answer.\n *\n * WebKit's prefixed members are handled throughout — `webkitfullscreenchange`,\n * `webkitFullscreenElement`, `webkitRequestFullscreen`, `webkitExitFullscreen` —\n * because Safari on iPad still ships them and nothing else.\n *\n * `isFullscreen` is identity against the target, not containment: a `<video>`\n * inside your element going fullscreen on its own is not your element being\n * presented, and reporting `true` there would put your exit control inside a\n * subtree the browser is not painting.\n *\n * @param ref - The element to present. Omit it to present the whole page\n * (`document.documentElement`).\n * @returns `{ isFullscreen, supported, enter, exit, toggle }`.\n * @throws Nothing during render. `enter()` and `toggle()` reject with the\n * browser's own error when the request is refused — most often a `TypeError`\n * because the call did not come from a user gesture — and with an `Error` when\n * there is no element to present or the environment ships no Fullscreen API.\n *\n * @example\n * const stage = useRef<HTMLDivElement>(null);\n * const { isFullscreen, supported, toggle } = useFullscreen(stage);\n *\n * <div ref={stage}>\n *   <video src=\"/aula.mp4\" controls />\n *   {supported ? (\n *     <button onClick={() => void toggle().catch(() => setRefused(true))}>\n *       {isFullscreen ? \"Sair da tela cheia\" : \"Tela cheia\"}\n *     </button>\n *   ) : null}\n * </div>\n */\nexport function useFullscreen(ref?: RefObject<HTMLElement | null>): UseFullscreenResult {\n    const element = useFullscreenElement();\n    const [supported] = useState(isFullscreenSupported);\n    const [isFullscreen, setIsFullscreen] = useState(false);\n\n    useEffect(() => {\n        const target = resolveTarget(ref);\n        setIsFullscreen(target !== null && element === target);\n    }, [element, ref]);\n\n    const enter = useCallback(async (): Promise<void> => {\n        const target = resolveTarget(ref);\n        if (target === null) {\n            throw new Error(\n                \"useFullscreen: nothing to present. Either this environment has no document, \" +\n                    \"or the ref was never attached to a mounted element.\",\n            );\n        }\n        const candidate: FullscreenTarget = target;\n        if (typeof candidate.requestFullscreen === \"function\") {\n            await candidate.requestFullscreen();\n            return;\n        }\n        if (typeof candidate.webkitRequestFullscreen === \"function\") {\n            await candidate.webkitRequestFullscreen();\n            return;\n        }\n        throw new Error(\"useFullscreen: this browser exposes no way to enter fullscreen.\");\n    }, [ref]);\n\n    const exit = useCallback(async (): Promise<void> => {\n        if (getFullscreenElement() === null) return;\n        const doc: FullscreenDocument = document;\n        if (typeof doc.exitFullscreen === \"function\") {\n            await doc.exitFullscreen();\n            return;\n        }\n        if (typeof doc.webkitExitFullscreen === \"function\") {\n            await doc.webkitExitFullscreen();\n            return;\n        }\n        throw new Error(\"useFullscreen: this browser exposes no way to leave fullscreen.\");\n    }, []);\n\n    const toggle = useCallback(async (): Promise<void> => {\n        const target = resolveTarget(ref);\n        if (target !== null && getFullscreenElement() === target) {\n            await exit();\n            return;\n        }\n        await enter();\n    }, [enter, exit, ref]);\n\n    return { isFullscreen, supported, enter, exit, toggle };\n}\n"],"mappings":"A,uEAyCA,SAASM,EAAc,EAAyD,CAE5E,OADI,OAAO,SAAa,IAAoB,KACrCC,EAAMA,EAAI,QAAU,SAAS,eACxC,CAiBA,SAAgBC,GAAiC,CAC7C,GAAI,OAAO,SAAa,IAAa,MAAO,GAC5C,IAAMC,EAAyB,SAAS,gBAClCC,EAA0B,SAIhC,OAFI,OAAOD,EAAK,mBAAsB,YAClC,OAAOA,EAAK,yBAA4B,cACvBC,EAAI,mBAAqBA,EAAI,yBAA2B,GACjF,CAiEA,SAAgBC,EAAc,EAA0D,CACpF,IAAMC,EAAUZ,EAAAA,qBAAqB,EAC/B,CAACa,IAAA,EAAaZ,EAAAA,SAAAA,CAASO,CAAqB,EAC5C,CAACM,EAAcC,IAAA,EAAmBd,EAAAA,SAAAA,CAAS,EAAK,GAEtD,EAAAI,EAAA,UAAA,KAAgB,CACZ,IAAMW,EAASV,EAAcC,CAAG,EAChCQ,EAAgBC,IAAW,MAAQJ,IAAYI,CAAM,CACzD,EAAG,CAACJ,EAASL,CAAG,CAAC,EAEjB,IAAMU,GAAA,EAAQf,EAAAA,YAAAA,CAAY,SAA2B,CACjD,IAAMc,EAASV,EAAcC,CAAG,EAChC,GAAIS,IAAW,KACX,MAAU,MACN,iIAEJ,EAEJ,IAAME,EAA8BF,EACpC,GAAI,OAAOE,EAAU,mBAAsB,WACvC,MAAMA,EAAU,kBAAkB,OAGtC,GAAI,OAAOA,EAAU,yBAA4B,WAC7C,MAAMA,EAAU,wBAAwB,OAG5C,MAAU,MAAM,iEAAiE,CACrF,EAAG,CAACX,CAAG,CAAC,EAEFY,GAAA,EAAOjB,EAAAA,YAAAA,CAAY,SAA2B,CAChD,GAAIC,EAAAA,qBAAqB,IAAM,KAAM,OACrC,IAAMO,EAA0B,SAChC,GAAI,OAAOA,EAAI,gBAAmB,WAC9B,MAAMA,EAAI,eAAe,OAG7B,GAAI,OAAOA,EAAI,sBAAyB,WACpC,MAAMA,EAAI,qBAAqB,OAGnC,MAAU,MAAM,iEAAiE,CACrF,EAAG,CAAC,CAAC,EAWL,MAAO,CAAE,eAAc,YAAW,QAAO,OAAM,QAAA,EAThCR,EAAAA,YAAAA,CAAY,SAA2B,CAClD,IAAMc,EAASV,EAAcC,CAAG,EAC5BS,IAAW,MAAQb,EAAAA,qBAAqB,IAAMa,EAC9C,MAAMG,EAAK,EAGf,MAAMF,EAAM,CAChB,EAAG,CAACA,EAAOE,EAAMZ,CAAG,CAE2B,CAAO,CAC1D,C"}

package/dist/hooks/use-fullscreen.js

@@ -19,27 +19,15 @@ function s(s) {
 		let e = a(s);
 		if (e === null) throw Error("useFullscreen: nothing to present. Either this environment has no document, or the ref was never attached to a mounted element.");
 		let t = e;
-		if (typeof t.requestFullscreen == "function") {
-			await t.requestFullscreen();
-			return;
-		}
-		if (typeof t.webkitRequestFullscreen == "function") {
-			await t.webkitRequestFullscreen();
-			return;
-		}
-		throw Error("useFullscreen: this browser exposes no way to enter fullscreen.");
+		if (typeof t.requestFullscreen == "function") await t.requestFullscreen();
+		else if (typeof t.webkitRequestFullscreen == "function") await t.webkitRequestFullscreen();
+		else throw Error("useFullscreen: this browser exposes no way to enter fullscreen.");
 	}, [s]), p = n(async () => {
 		if (e() === null) return;
 		let t = document;
-		if (typeof t.exitFullscreen == "function") {
-			await t.exitFullscreen();
-			return;
-		}
-		if (typeof t.webkitExitFullscreen == "function") {
-			await t.webkitExitFullscreen();
-			return;
-		}
-		throw Error("useFullscreen: this browser exposes no way to leave fullscreen.");
+		if (typeof t.exitFullscreen == "function") await t.exitFullscreen();
+		else if (typeof t.webkitExitFullscreen == "function") await t.webkitExitFullscreen();
+		else throw Error("useFullscreen: this browser exposes no way to leave fullscreen.");
 	}, []);
 	return {
 		isFullscreen: u,
@@ -48,11 +36,7 @@ function s(s) {
 		exit: p,
 		toggle: n(async () => {
 			let t = a(s);
-			if (t !== null && e() === t) {
-				await p();
-				return;
-			}
-			await f();
+			t !== null && e() === t ? await p() : await f();
 		}, [
 			f,
 			p,

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

@@ -1 +1 @@
-{"version":3,"file":"use-fullscreen.js","names":[],"sources":["../../src/hooks/use-fullscreen.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\nimport { getFullscreenElement, useFullscreenElement } from \"./use-fullscreen-element\";\n\n/**\n * The fullscreen members of `document` this hook calls, standard and\n * vendor-prefixed, every one of them optional.\n *\n * `lib.dom` declares the standard members as always present, which is a promise\n * the runtime does not keep: an older WebKit ships only the prefixed pair, and a\n * document inside an `<iframe>` without `allowfullscreen` reports\n * `fullscreenEnabled: false`. Reading through an all-optional shape is what makes\n * `typeof x === \"function\"` a check the compiler agrees is worth making.\n */\ninterface FullscreenDocument {\n    fullscreenEnabled?: boolean;\n    exitFullscreen?: () => Promise<void>;\n    webkitFullscreenEnabled?: boolean;\n    webkitExitFullscreen?: () => Promise<void> | void;\n}\n\n/** The fullscreen members of an element, standard and vendor-prefixed. */\ninterface FullscreenTarget {\n    requestFullscreen?: (options?: FullscreenOptions) => Promise<void>;\n    webkitRequestFullscreen?: () => Promise<void> | void;\n}\n\n/**\n * Resolve which element the hook acts on.\n *\n * `ref.current` when a ref was given, `document.documentElement` when it was not\n * — the whole page, which is what \"go fullscreen\" means with no element named.\n *\n * A missing `ref.current` deliberately resolves to `null` rather than falling\n * back to the page: a caller who named an element and whose element is not\n * mounted yet wants an error, not the entire document blown up to fill the\n * screen behind their video.\n *\n * @param ref - The element to present, or `undefined` for the whole page.\n * @returns The element, or `null` when there is nothing to act on.\n */\nfunction resolveTarget(ref?: RefObject<HTMLElement | null>): HTMLElement | null {\n    if (typeof document === \"undefined\") return null;\n    return ref ? ref.current : document.documentElement;\n}\n\n/**\n * Whether this environment can present anything fullscreen at all.\n *\n * Two independent reasons for `false`, and skipping either one ships a button\n * that does nothing when pressed: the API can be missing (older WebKit, and every\n * browser on iOS for non-`<video>` elements), or present and **disabled** — a\n * document inside an `<iframe>` without the `allowfullscreen` attribute exposes\n * `requestFullscreen` and rejects every call to it, which `fullscreenEnabled`\n * reports up front.\n *\n * An engine that exposes the methods and no flag at all is treated as capable:\n * the flag is the newer half of the API, so its absence says nothing.\n *\n * @returns `true` when a fullscreen request stands a chance of being honoured.\n */\nexport function isFullscreenSupported(): boolean {\n    if (typeof document === \"undefined\") return false;\n    const root: FullscreenTarget = document.documentElement;\n    const doc: FullscreenDocument = document;\n    const reachable =\n        typeof root.requestFullscreen === \"function\" ||\n        typeof root.webkitRequestFullscreen === \"function\";\n    return reachable && (doc.fullscreenEnabled ?? doc.webkitFullscreenEnabled ?? true);\n}\n\n/** Value returned by {@link useFullscreen}. */\nexport interface UseFullscreenResult {\n    /** Whether the target element is the one the browser is presenting right now. */\n    isFullscreen: boolean;\n    /** Whether a request stands a chance at all — hide the control when `false`. */\n    supported: boolean;\n    /** Present the target. Must be called from a user gesture. Rejects if refused. */\n    enter: () => Promise<void>;\n    /** Leave fullscreen. Resolves immediately when nothing is presented. */\n    exit: () => Promise<void>;\n    /** Leave if the target is presented, otherwise enter. Same gesture rule as `enter`. */\n    toggle: () => Promise<void>;\n}\n\n/**\n * Drive an immersive mode whose state stays true to the browser.\n *\n * The mistake this exists to remove is storing `isFullscreen` in state and\n * flipping it inside your own `enter()` / `exit()`. Fullscreen ends in ways your\n * code never sees — `Esc`, the browser's own exit affordance, F11 pressed while an\n * API fullscreen is active — and each of those leaves the flag saying \"sair\" over\n * a page that is already windowed. The only honest source is the\n * `fullscreenchange` event, which fires for every one of them, so that is what\n * this hook reads and what the returned `isFullscreen` reflects. The action\n * callbacks never touch it.\n *\n * The subscription is not this hook's own: it lives in `useFullscreenElement`,\n * shared with `usePortalHost`, which needs the same fact to decide where an\n * overlay mounts while fullscreen is on. Two independent listeners for one event\n * would mean two copies of the WebKit prefix dance and two places to fix the next\n * quirk, so the primitive answers \"which element is presented\" once and each\n * consumer asks its own question of the answer.\n *\n * WebKit's prefixed members are handled throughout — `webkitfullscreenchange`,\n * `webkitFullscreenElement`, `webkitRequestFullscreen`, `webkitExitFullscreen` —\n * because Safari on iPad still ships them and nothing else.\n *\n * `isFullscreen` is identity against the target, not containment: a `<video>`\n * inside your element going fullscreen on its own is not your element being\n * presented, and reporting `true` there would put your exit control inside a\n * subtree the browser is not painting.\n *\n * @param ref - The element to present. Omit it to present the whole page\n * (`document.documentElement`).\n * @returns `{ isFullscreen, supported, enter, exit, toggle }`.\n * @throws Nothing during render. `enter()` and `toggle()` reject with the\n * browser's own error when the request is refused — most often a `TypeError`\n * because the call did not come from a user gesture — and with an `Error` when\n * there is no element to present or the environment ships no Fullscreen API.\n *\n * @example\n * const stage = useRef<HTMLDivElement>(null);\n * const { isFullscreen, supported, toggle } = useFullscreen(stage);\n *\n * <div ref={stage}>\n *   <video src=\"/aula.mp4\" controls />\n *   {supported ? (\n *     <button onClick={() => void toggle().catch(() => setRefused(true))}>\n *       {isFullscreen ? \"Sair da tela cheia\" : \"Tela cheia\"}\n *     </button>\n *   ) : null}\n * </div>\n */\nexport function useFullscreen(ref?: RefObject<HTMLElement | null>): UseFullscreenResult {\n    const element = useFullscreenElement();\n    const [supported] = useState(isFullscreenSupported);\n    const [isFullscreen, setIsFullscreen] = useState(false);\n\n    useEffect(() => {\n        const target = resolveTarget(ref);\n        setIsFullscreen(target !== null && element === target);\n    }, [element, ref]);\n\n    const enter = useCallback(async (): Promise<void> => {\n        const target = resolveTarget(ref);\n        if (target === null) {\n            throw new Error(\n                \"useFullscreen: nothing to present. Either this environment has no document, \" +\n                    \"or the ref was never attached to a mounted element.\",\n            );\n        }\n        const candidate: FullscreenTarget = target;\n        if (typeof candidate.requestFullscreen === \"function\") {\n            await candidate.requestFullscreen();\n            return;\n        }\n        if (typeof candidate.webkitRequestFullscreen === \"function\") {\n            await candidate.webkitRequestFullscreen();\n            return;\n        }\n        throw new Error(\"useFullscreen: this browser exposes no way to enter fullscreen.\");\n    }, [ref]);\n\n    const exit = useCallback(async (): Promise<void> => {\n        if (getFullscreenElement() === null) return;\n        const doc: FullscreenDocument = document;\n        if (typeof doc.exitFullscreen === \"function\") {\n            await doc.exitFullscreen();\n            return;\n        }\n        if (typeof doc.webkitExitFullscreen === \"function\") {\n            await doc.webkitExitFullscreen();\n            return;\n        }\n        throw new Error(\"useFullscreen: this browser exposes no way to leave fullscreen.\");\n    }, []);\n\n    const toggle = useCallback(async (): Promise<void> => {\n        const target = resolveTarget(ref);\n        if (target !== null && getFullscreenElement() === target) {\n            await exit();\n            return;\n        }\n        await enter();\n    }, [enter, exit, ref]);\n\n    return { isFullscreen, supported, enter, exit, toggle };\n}\n"],"mappings":";;;AAyCA,SAAS,EAAc,GAAyD;CAE5E,OADI,OAAO,WAAa,MAAoB,OACrC,IAAM,EAAI,UAAU,SAAS;AACxC;AAiBA,SAAgB,IAAiC;CAC7C,IAAI,OAAO,WAAa,KAAa,OAAO;CAC5C,IAAM,IAAyB,SAAS,iBAClC,IAA0B;CAIhC,QAFI,OAAO,EAAK,qBAAsB,cAClC,OAAO,EAAK,2BAA4B,gBACvB,EAAI,qBAAqB,EAAI,2BAA2B;AACjF;AAiEA,SAAgB,EAAc,GAA0D;CACpF,IAAM,IAAU,EAAqB,GAC/B,CAAC,KAAa,EAAS,CAAqB,GAC5C,CAAC,GAAc,KAAmB,EAAS,EAAK;CAEtD,QAAgB;EACZ,IAAM,IAAS,EAAc,CAAG;EAChC,EAAgB,MAAW,QAAQ,MAAY,CAAM;CACzD,GAAG,CAAC,GAAS,CAAG,CAAC;CAEjB,IAAM,IAAQ,EAAY,YAA2B;EACjD,IAAM,IAAS,EAAc,CAAG;EAChC,IAAI,MAAW,MACX,MAAU,MACN,iIAEJ;EAEJ,IAAM,IAA8B;EACpC,IAAI,OAAO,EAAU,qBAAsB,YAAY;GACnD,MAAM,EAAU,kBAAkB;GAClC;EACJ;EACA,IAAI,OAAO,EAAU,2BAA4B,YAAY;GACzD,MAAM,EAAU,wBAAwB;GACxC;EACJ;EACA,MAAU,MAAM,iEAAiE;CACrF,GAAG,CAAC,CAAG,CAAC,GAEF,IAAO,EAAY,YAA2B;EAChD,IAAI,EAAqB,MAAM,MAAM;EACrC,IAAM,IAA0B;EAChC,IAAI,OAAO,EAAI,kBAAmB,YAAY;GAC1C,MAAM,EAAI,eAAe;GACzB;EACJ;EACA,IAAI,OAAO,EAAI,wBAAyB,YAAY;GAChD,MAAM,EAAI,qBAAqB;GAC/B;EACJ;EACA,MAAU,MAAM,iEAAiE;CACrF,GAAG,CAAC,CAAC;CAWL,OAAO;EAAE;EAAc;EAAW;EAAO;EAAM,QAThC,EAAY,YAA2B;GAClD,IAAM,IAAS,EAAc,CAAG;GAChC,IAAI,MAAW,QAAQ,EAAqB,MAAM,GAAQ;IACtD,MAAM,EAAK;IACX;GACJ;GACA,MAAM,EAAM;EAChB,GAAG;GAAC;GAAO;GAAM;EAAG,CAE2B;CAAO;AAC1D"}
+{"version":3,"file":"use-fullscreen.js","names":["resolveTarget","ref","isFullscreenSupported","root","doc","useFullscreen","element","useFullscreenElement","supported","useState","isFullscreen","setIsFullscreen","target","enter","useCallback","candidate","exit","getFullscreenElement"],"sources":["../../src/hooks/use-fullscreen.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\nimport { getFullscreenElement, useFullscreenElement } from \"./use-fullscreen-element\";\n\n/**\n * The fullscreen members of `document` this hook calls, standard and\n * vendor-prefixed, every one of them optional.\n *\n * `lib.dom` declares the standard members as always present, which is a promise\n * the runtime does not keep: an older WebKit ships only the prefixed pair, and a\n * document inside an `<iframe>` without `allowfullscreen` reports\n * `fullscreenEnabled: false`. Reading through an all-optional shape is what makes\n * `typeof x === \"function\"` a check the compiler agrees is worth making.\n */\ninterface FullscreenDocument {\n    fullscreenEnabled?: boolean;\n    exitFullscreen?: () => Promise<void>;\n    webkitFullscreenEnabled?: boolean;\n    webkitExitFullscreen?: () => Promise<void> | void;\n}\n\n/** The fullscreen members of an element, standard and vendor-prefixed. */\ninterface FullscreenTarget {\n    requestFullscreen?: (options?: FullscreenOptions) => Promise<void>;\n    webkitRequestFullscreen?: () => Promise<void> | void;\n}\n\n/**\n * Resolve which element the hook acts on.\n *\n * `ref.current` when a ref was given, `document.documentElement` when it was not\n * — the whole page, which is what \"go fullscreen\" means with no element named.\n *\n * A missing `ref.current` deliberately resolves to `null` rather than falling\n * back to the page: a caller who named an element and whose element is not\n * mounted yet wants an error, not the entire document blown up to fill the\n * screen behind their video.\n *\n * @param ref - The element to present, or `undefined` for the whole page.\n * @returns The element, or `null` when there is nothing to act on.\n */\nfunction resolveTarget(ref?: RefObject<HTMLElement | null>): HTMLElement | null {\n    if (typeof document === \"undefined\") return null;\n    return ref ? ref.current : document.documentElement;\n}\n\n/**\n * Whether this environment can present anything fullscreen at all.\n *\n * Two independent reasons for `false`, and skipping either one ships a button\n * that does nothing when pressed: the API can be missing (older WebKit, and every\n * browser on iOS for non-`<video>` elements), or present and **disabled** — a\n * document inside an `<iframe>` without the `allowfullscreen` attribute exposes\n * `requestFullscreen` and rejects every call to it, which `fullscreenEnabled`\n * reports up front.\n *\n * An engine that exposes the methods and no flag at all is treated as capable:\n * the flag is the newer half of the API, so its absence says nothing.\n *\n * @returns `true` when a fullscreen request stands a chance of being honoured.\n */\nexport function isFullscreenSupported(): boolean {\n    if (typeof document === \"undefined\") return false;\n    const root: FullscreenTarget = document.documentElement;\n    const doc: FullscreenDocument = document;\n    const reachable =\n        typeof root.requestFullscreen === \"function\" ||\n        typeof root.webkitRequestFullscreen === \"function\";\n    return reachable && (doc.fullscreenEnabled ?? doc.webkitFullscreenEnabled ?? true);\n}\n\n/** Value returned by {@link useFullscreen}. */\nexport interface UseFullscreenResult {\n    /** Whether the target element is the one the browser is presenting right now. */\n    isFullscreen: boolean;\n    /** Whether a request stands a chance at all — hide the control when `false`. */\n    supported: boolean;\n    /** Present the target. Must be called from a user gesture. Rejects if refused. */\n    enter: () => Promise<void>;\n    /** Leave fullscreen. Resolves immediately when nothing is presented. */\n    exit: () => Promise<void>;\n    /** Leave if the target is presented, otherwise enter. Same gesture rule as `enter`. */\n    toggle: () => Promise<void>;\n}\n\n/**\n * Drive an immersive mode whose state stays true to the browser.\n *\n * The mistake this exists to remove is storing `isFullscreen` in state and\n * flipping it inside your own `enter()` / `exit()`. Fullscreen ends in ways your\n * code never sees — `Esc`, the browser's own exit affordance, F11 pressed while an\n * API fullscreen is active — and each of those leaves the flag saying \"sair\" over\n * a page that is already windowed. The only honest source is the\n * `fullscreenchange` event, which fires for every one of them, so that is what\n * this hook reads and what the returned `isFullscreen` reflects. The action\n * callbacks never touch it.\n *\n * The subscription is not this hook's own: it lives in `useFullscreenElement`,\n * shared with `usePortalHost`, which needs the same fact to decide where an\n * overlay mounts while fullscreen is on. Two independent listeners for one event\n * would mean two copies of the WebKit prefix dance and two places to fix the next\n * quirk, so the primitive answers \"which element is presented\" once and each\n * consumer asks its own question of the answer.\n *\n * WebKit's prefixed members are handled throughout — `webkitfullscreenchange`,\n * `webkitFullscreenElement`, `webkitRequestFullscreen`, `webkitExitFullscreen` —\n * because Safari on iPad still ships them and nothing else.\n *\n * `isFullscreen` is identity against the target, not containment: a `<video>`\n * inside your element going fullscreen on its own is not your element being\n * presented, and reporting `true` there would put your exit control inside a\n * subtree the browser is not painting.\n *\n * @param ref - The element to present. Omit it to present the whole page\n * (`document.documentElement`).\n * @returns `{ isFullscreen, supported, enter, exit, toggle }`.\n * @throws Nothing during render. `enter()` and `toggle()` reject with the\n * browser's own error when the request is refused — most often a `TypeError`\n * because the call did not come from a user gesture — and with an `Error` when\n * there is no element to present or the environment ships no Fullscreen API.\n *\n * @example\n * const stage = useRef<HTMLDivElement>(null);\n * const { isFullscreen, supported, toggle } = useFullscreen(stage);\n *\n * <div ref={stage}>\n *   <video src=\"/aula.mp4\" controls />\n *   {supported ? (\n *     <button onClick={() => void toggle().catch(() => setRefused(true))}>\n *       {isFullscreen ? \"Sair da tela cheia\" : \"Tela cheia\"}\n *     </button>\n *   ) : null}\n * </div>\n */\nexport function useFullscreen(ref?: RefObject<HTMLElement | null>): UseFullscreenResult {\n    const element = useFullscreenElement();\n    const [supported] = useState(isFullscreenSupported);\n    const [isFullscreen, setIsFullscreen] = useState(false);\n\n    useEffect(() => {\n        const target = resolveTarget(ref);\n        setIsFullscreen(target !== null && element === target);\n    }, [element, ref]);\n\n    const enter = useCallback(async (): Promise<void> => {\n        const target = resolveTarget(ref);\n        if (target === null) {\n            throw new Error(\n                \"useFullscreen: nothing to present. Either this environment has no document, \" +\n                    \"or the ref was never attached to a mounted element.\",\n            );\n        }\n        const candidate: FullscreenTarget = target;\n        if (typeof candidate.requestFullscreen === \"function\") {\n            await candidate.requestFullscreen();\n            return;\n        }\n        if (typeof candidate.webkitRequestFullscreen === \"function\") {\n            await candidate.webkitRequestFullscreen();\n            return;\n        }\n        throw new Error(\"useFullscreen: this browser exposes no way to enter fullscreen.\");\n    }, [ref]);\n\n    const exit = useCallback(async (): Promise<void> => {\n        if (getFullscreenElement() === null) return;\n        const doc: FullscreenDocument = document;\n        if (typeof doc.exitFullscreen === \"function\") {\n            await doc.exitFullscreen();\n            return;\n        }\n        if (typeof doc.webkitExitFullscreen === \"function\") {\n            await doc.webkitExitFullscreen();\n            return;\n        }\n        throw new Error(\"useFullscreen: this browser exposes no way to leave fullscreen.\");\n    }, []);\n\n    const toggle = useCallback(async (): Promise<void> => {\n        const target = resolveTarget(ref);\n        if (target !== null && getFullscreenElement() === target) {\n            await exit();\n            return;\n        }\n        await enter();\n    }, [enter, exit, ref]);\n\n    return { isFullscreen, supported, enter, exit, toggle };\n}\n"],"mappings":";;;AAyCA,SAASA,EAAc,GAAyD;CAE5E,OADI,OAAO,WAAa,MAAoB,OACrCC,IAAMA,EAAI,UAAU,SAAS;AACxC;AAiBA,SAAgBC,IAAiC;CAC7C,IAAI,OAAO,WAAa,KAAa,OAAO;CAC5C,IAAMC,IAAyB,SAAS,iBAClCC,IAA0B;CAIhC,QAFI,OAAOD,EAAK,qBAAsB,cAClC,OAAOA,EAAK,2BAA4B,gBACvBC,EAAI,qBAAqBA,EAAI,2BAA2B;AACjF;AAiEA,SAAgBC,EAAc,GAA0D;CACpF,IAAMC,IAAUC,EAAqB,GAC/B,CAACC,KAAaC,EAASP,CAAqB,GAC5C,CAACQ,GAAcC,KAAmBF,EAAS,EAAK;CAEtD,QAAgB;EACZ,IAAMG,IAASZ,EAAcC,CAAG;EAChC,EAAgBW,MAAW,QAAQN,MAAYM,CAAM;CACzD,GAAG,CAACN,GAASL,CAAG,CAAC;CAEjB,IAAMY,IAAQC,EAAY,YAA2B;EACjD,IAAMF,IAASZ,EAAcC,CAAG;EAChC,IAAIW,MAAW,MACX,MAAU,MACN,iIAEJ;EAEJ,IAAMG,IAA8BH;EACpC,IAAI,OAAOG,EAAU,qBAAsB,YACvC,MAAMA,EAAU,kBAAkB;OAGtC,IAAI,OAAOA,EAAU,2BAA4B,YAC7C,MAAMA,EAAU,wBAAwB;OAG5C,MAAU,MAAM,iEAAiE;CACrF,GAAG,CAACd,CAAG,CAAC,GAEFe,IAAOF,EAAY,YAA2B;EAChD,IAAIG,EAAqB,MAAM,MAAM;EACrC,IAAMb,IAA0B;EAChC,IAAI,OAAOA,EAAI,kBAAmB,YAC9B,MAAMA,EAAI,eAAe;OAG7B,IAAI,OAAOA,EAAI,wBAAyB,YACpC,MAAMA,EAAI,qBAAqB;OAGnC,MAAU,MAAM,iEAAiE;CACrF,GAAG,CAAC,CAAC;CAWL,OAAO;EAAE;EAAc;EAAW;EAAO;EAAM,QAThCU,EAAY,YAA2B;GAClD,IAAMF,IAASZ,EAAcC,CAAG;GAChC,AAAIW,MAAW,QAAQK,EAAqB,MAAML,IAC9C,MAAMI,EAAK,IAGf,MAAMH,EAAM;EAChB,GAAG;GAACA;GAAOG;GAAMf;EAAG,CAE2B;CAAO;AAC1D"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-geolocation.cjs","names":[],"sources":["../../src/hooks/use-geolocation.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\nexport interface GeolocationState {\n    loading: boolean;\n    error: GeolocationPositionError | null;\n    coords: GeolocationCoordinates | null;\n    timestamp: number | null;\n}\n\nexport interface UseGeolocationOptions extends PositionOptions {\n    /** Use `watchPosition` instead of one-shot `getCurrentPosition`. Default: false. */\n    watch?: boolean;\n    /** Disable the hook without unmounting. Default: false. */\n    disabled?: boolean;\n}\n\n/**\n * React hook around the Geolocation API.\n *\n * The effect depends on the individual `PositionOptions` fields instead of the\n * rest object, which is a new reference on every render and would restart the\n * watch continuously. `exhaustive-deps` is silenced there because those fields\n * are the whole of what the effect reads from it.\n *\n * @param options - Geolocation options plus `watch` and `disabled` switches.\n * @returns The latest position, error and loading state.\n */\nexport function useGeolocation(options: UseGeolocationOptions = {}): GeolocationState {\n    const { watch = false, disabled = false, ...positionOptions } = options;\n    const [state, setState] = useState<GeolocationState>({\n        loading: !disabled,\n        error: null,\n        coords: null,\n        timestamp: null,\n    });\n\n    useEffect(() => {\n        if (disabled || typeof navigator === \"undefined\" || !navigator.geolocation) {\n            setState((prev) => ({ ...prev, loading: false }));\n            return;\n        }\n\n        const onSuccess = (position: GeolocationPosition): void => {\n            setState({\n                loading: false,\n                error: null,\n                coords: position.coords,\n                timestamp: position.timestamp,\n            });\n        };\n        const onError = (error: GeolocationPositionError): void => {\n            setState((prev) => ({ ...prev, loading: false, error }));\n        };\n\n        if (watch) {\n            const watchId = navigator.geolocation.watchPosition(\n                onSuccess,\n                onError,\n                positionOptions,\n            );\n            return () => navigator.geolocation.clearWatch(watchId);\n        }\n\n        navigator.geolocation.getCurrentPosition(onSuccess, onError, positionOptions);\n        return undefined;\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [\n        disabled,\n        watch,\n        positionOptions.enableHighAccuracy,\n        positionOptions.maximumAge,\n        positionOptions.timeout,\n    ]);\n\n    return state;\n}\n"],"mappings":"uBA2BA,SAAgB,EAAe,EAAiC,CAAC,EAAqB,CAClF,GAAM,CAAE,QAAQ,GAAO,WAAW,GAAO,GAAG,GAAoB,EAC1D,CAAC,EAAO,IAAA,EAAY,EAAA,SAAA,CAA2B,CACjD,QAAS,CAAC,EACV,MAAO,KACP,OAAQ,KACR,UAAW,IACf,CAAC,EAwCD,OAtCA,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,GAAY,OAAO,UAAc,KAAe,CAAC,UAAU,YAAa,CACxE,EAAU,IAAU,CAAE,GAAG,EAAM,QAAS,EAAM,EAAE,EAChD,MACJ,CAEA,IAAM,EAAa,GAAwC,CACvD,EAAS,CACL,QAAS,GACT,MAAO,KACP,OAAQ,EAAS,OACjB,UAAW,EAAS,SACxB,CAAC,CACL,EACM,EAAW,GAA0C,CACvD,EAAU,IAAU,CAAE,GAAG,EAAM,QAAS,GAAO,OAAM,EAAE,CAC3D,EAEA,GAAI,EAAO,CACP,IAAM,EAAU,UAAU,YAAY,cAClC,EACA,EACA,CACJ,EACA,UAAa,UAAU,YAAY,WAAW,CAAO,CACzD,CAEA,UAAU,YAAY,mBAAmB,EAAW,EAAS,CAAe,CAGhF,EAAG,CACC,EACA,EACA,EAAgB,mBAChB,EAAgB,WAChB,EAAgB,OACpB,CAAC,EAEM,CACX"}
+{"version":3,"file":"use-geolocation.cjs","names":["useState","react","useGeolocation","positionOptions","options","state","setState","disabled","prev","onSuccess","position","onError","watch","watchId"],"sources":["../../src/hooks/use-geolocation.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\nexport interface GeolocationState {\n    loading: boolean;\n    error: GeolocationPositionError | null;\n    coords: GeolocationCoordinates | null;\n    timestamp: number | null;\n}\n\nexport interface UseGeolocationOptions extends PositionOptions {\n    /** Use `watchPosition` instead of one-shot `getCurrentPosition`. Default: false. */\n    watch?: boolean;\n    /** Disable the hook without unmounting. Default: false. */\n    disabled?: boolean;\n}\n\n/**\n * React hook around the Geolocation API.\n *\n * The effect depends on the individual `PositionOptions` fields instead of the\n * rest object, which is a new reference on every render and would restart the\n * watch continuously. `exhaustive-deps` is silenced there because those fields\n * are the whole of what the effect reads from it.\n *\n * @param options - Geolocation options plus `watch` and `disabled` switches.\n * @returns The latest position, error and loading state.\n */\nexport function useGeolocation(options: UseGeolocationOptions = {}): GeolocationState {\n    const { watch = false, disabled = false, ...positionOptions } = options;\n    const [state, setState] = useState<GeolocationState>({\n        loading: !disabled,\n        error: null,\n        coords: null,\n        timestamp: null,\n    });\n\n    useEffect(() => {\n        if (disabled || typeof navigator === \"undefined\" || !navigator.geolocation) {\n            setState((prev) => ({ ...prev, loading: false }));\n            return;\n        }\n\n        const onSuccess = (position: GeolocationPosition): void => {\n            setState({\n                loading: false,\n                error: null,\n                coords: position.coords,\n                timestamp: position.timestamp,\n            });\n        };\n        const onError = (error: GeolocationPositionError): void => {\n            setState((prev) => ({ ...prev, loading: false, error }));\n        };\n\n        if (watch) {\n            const watchId = navigator.geolocation.watchPosition(\n                onSuccess,\n                onError,\n                positionOptions,\n            );\n            return () => navigator.geolocation.clearWatch(watchId);\n        }\n\n        navigator.geolocation.getCurrentPosition(onSuccess, onError, positionOptions);\n        return undefined;\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [\n        disabled,\n        watch,\n        positionOptions.enableHighAccuracy,\n        positionOptions.maximumAge,\n        positionOptions.timeout,\n    ]);\n\n    return state;\n}\n"],"mappings":"A,uBA2BA,SAAgBE,EAAe,EAAiC,CAAC,EAAqB,CAClF,GAAM,CAAE,QAAQ,GAAO,WAAW,GAAO,GAAGC,GAAoBC,EAC1D,CAACC,EAAOC,IAAA,EAAYN,EAAAA,SAAAA,CAA2B,CACjD,QAAS,CAACO,EACV,MAAO,KACP,OAAQ,KACR,UAAW,IACf,CAAC,EAwCD,OAtCA,EAAAN,EAAA,UAAA,KAAgB,CACZ,GAAIM,GAAY,OAAO,UAAc,KAAe,CAAC,UAAU,YAAa,CACxED,EAAU,IAAU,CAAE,GAAGE,EAAM,QAAS,EAAM,EAAE,EAChD,MACJ,CAEA,IAAMC,EAAa,GAAwC,CACvDH,EAAS,CACL,QAAS,GACT,MAAO,KACP,OAAQI,EAAS,OACjB,UAAWA,EAAS,SACxB,CAAC,CACL,EACMC,EAAW,GAA0C,CACvDL,EAAU,IAAU,CAAE,GAAGE,EAAM,QAAS,GAAO,OAAM,EAAE,CAC3D,EAEA,GAAII,EAAO,CACP,IAAMC,EAAU,UAAU,YAAY,cAClCJ,EACAE,EACAR,CACJ,EACA,UAAa,UAAU,YAAY,WAAWU,CAAO,CACzD,CAEA,UAAU,YAAY,mBAAmBJ,EAAWE,EAASR,CAAe,CAGhF,EAAG,CACCI,EACAK,EACAT,EAAgB,mBAChBA,EAAgB,WAChBA,EAAgB,OACpB,CAAC,EAEME,CACX,C"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-geolocation.js","names":[],"sources":["../../src/hooks/use-geolocation.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\nexport interface GeolocationState {\n    loading: boolean;\n    error: GeolocationPositionError | null;\n    coords: GeolocationCoordinates | null;\n    timestamp: number | null;\n}\n\nexport interface UseGeolocationOptions extends PositionOptions {\n    /** Use `watchPosition` instead of one-shot `getCurrentPosition`. Default: false. */\n    watch?: boolean;\n    /** Disable the hook without unmounting. Default: false. */\n    disabled?: boolean;\n}\n\n/**\n * React hook around the Geolocation API.\n *\n * The effect depends on the individual `PositionOptions` fields instead of the\n * rest object, which is a new reference on every render and would restart the\n * watch continuously. `exhaustive-deps` is silenced there because those fields\n * are the whole of what the effect reads from it.\n *\n * @param options - Geolocation options plus `watch` and `disabled` switches.\n * @returns The latest position, error and loading state.\n */\nexport function useGeolocation(options: UseGeolocationOptions = {}): GeolocationState {\n    const { watch = false, disabled = false, ...positionOptions } = options;\n    const [state, setState] = useState<GeolocationState>({\n        loading: !disabled,\n        error: null,\n        coords: null,\n        timestamp: null,\n    });\n\n    useEffect(() => {\n        if (disabled || typeof navigator === \"undefined\" || !navigator.geolocation) {\n            setState((prev) => ({ ...prev, loading: false }));\n            return;\n        }\n\n        const onSuccess = (position: GeolocationPosition): void => {\n            setState({\n                loading: false,\n                error: null,\n                coords: position.coords,\n                timestamp: position.timestamp,\n            });\n        };\n        const onError = (error: GeolocationPositionError): void => {\n            setState((prev) => ({ ...prev, loading: false, error }));\n        };\n\n        if (watch) {\n            const watchId = navigator.geolocation.watchPosition(\n                onSuccess,\n                onError,\n                positionOptions,\n            );\n            return () => navigator.geolocation.clearWatch(watchId);\n        }\n\n        navigator.geolocation.getCurrentPosition(onSuccess, onError, positionOptions);\n        return undefined;\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [\n        disabled,\n        watch,\n        positionOptions.enableHighAccuracy,\n        positionOptions.maximumAge,\n        positionOptions.timeout,\n    ]);\n\n    return state;\n}\n"],"mappings":";;AA2BA,SAAgB,EAAe,IAAiC,CAAC,GAAqB;CAClF,IAAM,EAAE,WAAQ,IAAO,cAAW,IAAO,GAAG,MAAoB,GAC1D,CAAC,GAAO,KAAY,EAA2B;EACjD,SAAS,CAAC;EACV,OAAO;EACP,QAAQ;EACR,WAAW;CACf,CAAC;CAwCD,OAtCA,QAAgB;EACZ,IAAI,KAAY,OAAO,YAAc,OAAe,CAAC,UAAU,aAAa;GACxE,GAAU,OAAU;IAAE,GAAG;IAAM,SAAS;GAAM,EAAE;GAChD;EACJ;EAEA,IAAM,KAAa,MAAwC;GACvD,EAAS;IACL,SAAS;IACT,OAAO;IACP,QAAQ,EAAS;IACjB,WAAW,EAAS;GACxB,CAAC;EACL,GACM,KAAW,MAA0C;GACvD,GAAU,OAAU;IAAE,GAAG;IAAM,SAAS;IAAO;GAAM,EAAE;EAC3D;EAEA,IAAI,GAAO;GACP,IAAM,IAAU,UAAU,YAAY,cAClC,GACA,GACA,CACJ;GACA,aAAa,UAAU,YAAY,WAAW,CAAO;EACzD;EAEA,UAAU,YAAY,mBAAmB,GAAW,GAAS,CAAe;CAGhF,GAAG;EACC;EACA;EACA,EAAgB;EAChB,EAAgB;EAChB,EAAgB;CACpB,CAAC,GAEM;AACX"}
+{"version":3,"file":"use-geolocation.js","names":["useGeolocation","positionOptions","options","state","setState","useState","disabled","useEffect","prev","onSuccess","position","onError","watch","watchId"],"sources":["../../src/hooks/use-geolocation.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\n\nexport interface GeolocationState {\n    loading: boolean;\n    error: GeolocationPositionError | null;\n    coords: GeolocationCoordinates | null;\n    timestamp: number | null;\n}\n\nexport interface UseGeolocationOptions extends PositionOptions {\n    /** Use `watchPosition` instead of one-shot `getCurrentPosition`. Default: false. */\n    watch?: boolean;\n    /** Disable the hook without unmounting. Default: false. */\n    disabled?: boolean;\n}\n\n/**\n * React hook around the Geolocation API.\n *\n * The effect depends on the individual `PositionOptions` fields instead of the\n * rest object, which is a new reference on every render and would restart the\n * watch continuously. `exhaustive-deps` is silenced there because those fields\n * are the whole of what the effect reads from it.\n *\n * @param options - Geolocation options plus `watch` and `disabled` switches.\n * @returns The latest position, error and loading state.\n */\nexport function useGeolocation(options: UseGeolocationOptions = {}): GeolocationState {\n    const { watch = false, disabled = false, ...positionOptions } = options;\n    const [state, setState] = useState<GeolocationState>({\n        loading: !disabled,\n        error: null,\n        coords: null,\n        timestamp: null,\n    });\n\n    useEffect(() => {\n        if (disabled || typeof navigator === \"undefined\" || !navigator.geolocation) {\n            setState((prev) => ({ ...prev, loading: false }));\n            return;\n        }\n\n        const onSuccess = (position: GeolocationPosition): void => {\n            setState({\n                loading: false,\n                error: null,\n                coords: position.coords,\n                timestamp: position.timestamp,\n            });\n        };\n        const onError = (error: GeolocationPositionError): void => {\n            setState((prev) => ({ ...prev, loading: false, error }));\n        };\n\n        if (watch) {\n            const watchId = navigator.geolocation.watchPosition(\n                onSuccess,\n                onError,\n                positionOptions,\n            );\n            return () => navigator.geolocation.clearWatch(watchId);\n        }\n\n        navigator.geolocation.getCurrentPosition(onSuccess, onError, positionOptions);\n        return undefined;\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [\n        disabled,\n        watch,\n        positionOptions.enableHighAccuracy,\n        positionOptions.maximumAge,\n        positionOptions.timeout,\n    ]);\n\n    return state;\n}\n"],"mappings":";;AA2BA,SAAgBA,EAAe,IAAiC,CAAC,GAAqB;CAClF,IAAM,EAAE,WAAQ,IAAO,cAAW,IAAO,GAAGC,MAAoBC,GAC1D,CAACC,GAAOC,KAAYC,EAA2B;EACjD,SAAS,CAACC;EACV,OAAO;EACP,QAAQ;EACR,WAAW;CACf,CAAC;CAwCD,OAtCAC,QAAgB;EACZ,IAAID,KAAY,OAAO,YAAc,OAAe,CAAC,UAAU,aAAa;GACxE,GAAU,OAAU;IAAE,GAAGE;IAAM,SAAS;GAAM,EAAE;GAChD;EACJ;EAEA,IAAMC,KAAa,MAAwC;GACvD,EAAS;IACL,SAAS;IACT,OAAO;IACP,QAAQC,EAAS;IACjB,WAAWA,EAAS;GACxB,CAAC;EACL,GACMC,KAAW,MAA0C;GACvD,GAAU,OAAU;IAAE,GAAGH;IAAM,SAAS;IAAO;GAAM,EAAE;EAC3D;EAEA,IAAII,GAAO;GACP,IAAMC,IAAU,UAAU,YAAY,cAClCJ,GACAE,GACAV,CACJ;GACA,aAAa,UAAU,YAAY,WAAWY,CAAO;EACzD;EAEA,UAAU,YAAY,mBAAmBJ,GAAWE,GAASV,CAAe;CAGhF,GAAG;EACCK;EACAM;EACAX,EAAgB;EAChBA,EAAgB;EAChBA,EAAgB;CACpB,CAAC,GAEME;AACX"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-hover.cjs","names":[],"sources":["../../src/hooks/use-hover.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\n\n/**\n * Track whether the pointer is hovering over the referenced element.\n * Returns `false` on touch-only devices (no pointer hover).\n *\n * @example\n * const ref = useRef<HTMLDivElement>(null);\n * const hovered = useHover(ref);\n * return <div ref={ref}>{hovered ? \"✨\" : \"\"}</div>;\n */\nexport function useHover<T extends HTMLElement>(ref: RefObject<T | null>): boolean {\n    const [hovered, setHovered] = useState<boolean>(false);\n\n    useEffect(() => {\n        const node = ref.current;\n        if (!node) return;\n        const onEnter = (): void => setHovered(true);\n        const onLeave = (): void => setHovered(false);\n        node.addEventListener(\"mouseenter\", onEnter);\n        node.addEventListener(\"mouseleave\", onLeave);\n        return () => {\n            node.removeEventListener(\"mouseenter\", onEnter);\n            node.removeEventListener(\"mouseleave\", onLeave);\n        };\n    }, [ref]);\n\n    return hovered;\n}\n"],"mappings":"uBAYA,SAAgB,EAAgC,EAAmC,CAC/E,GAAM,CAAC,EAAS,IAAA,EAAc,EAAA,SAAA,CAAkB,EAAK,EAerD,OAbA,EAAA,EAAA,UAAA,KAAgB,CACZ,IAAM,EAAO,EAAI,QACjB,GAAI,CAAC,EAAM,OACX,IAAM,MAAsB,EAAW,EAAI,EACrC,MAAsB,EAAW,EAAK,EAG5C,OAFA,EAAK,iBAAiB,aAAc,CAAO,EAC3C,EAAK,iBAAiB,aAAc,CAAO,MAC9B,CACT,EAAK,oBAAoB,aAAc,CAAO,EAC9C,EAAK,oBAAoB,aAAc,CAAO,CAClD,CACJ,EAAG,CAAC,CAAG,CAAC,EAED,CACX"}
+{"version":3,"file":"use-hover.cjs","names":["useState","react","useHover","hovered","setHovered","node","ref","onEnter","onLeave"],"sources":["../../src/hooks/use-hover.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\n\n/**\n * Track whether the pointer is hovering over the referenced element.\n * Returns `false` on touch-only devices (no pointer hover).\n *\n * @example\n * const ref = useRef<HTMLDivElement>(null);\n * const hovered = useHover(ref);\n * return <div ref={ref}>{hovered ? \"✨\" : \"\"}</div>;\n */\nexport function useHover<T extends HTMLElement>(ref: RefObject<T | null>): boolean {\n    const [hovered, setHovered] = useState<boolean>(false);\n\n    useEffect(() => {\n        const node = ref.current;\n        if (!node) return;\n        const onEnter = (): void => setHovered(true);\n        const onLeave = (): void => setHovered(false);\n        node.addEventListener(\"mouseenter\", onEnter);\n        node.addEventListener(\"mouseleave\", onLeave);\n        return () => {\n            node.removeEventListener(\"mouseenter\", onEnter);\n            node.removeEventListener(\"mouseleave\", onLeave);\n        };\n    }, [ref]);\n\n    return hovered;\n}\n"],"mappings":"A,uBAYA,SAAgBE,EAAgC,EAAmC,CAC/E,GAAM,CAACC,EAASC,IAAA,EAAcJ,EAAAA,SAAAA,CAAkB,EAAK,EAerD,OAbA,EAAAC,EAAA,UAAA,KAAgB,CACZ,IAAMI,EAAOC,EAAI,QACjB,GAAI,CAACD,EAAM,OACX,IAAME,MAAsBH,EAAW,EAAI,EACrCI,MAAsBJ,EAAW,EAAK,EAG5C,OAFAC,EAAK,iBAAiB,aAAcE,CAAO,EAC3CF,EAAK,iBAAiB,aAAcG,CAAO,MAC9B,CACTH,EAAK,oBAAoB,aAAcE,CAAO,EAC9CF,EAAK,oBAAoB,aAAcG,CAAO,CAClD,CACJ,EAAG,CAACF,CAAG,CAAC,EAEDH,CACX,C"}

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

@@ -1 +1 @@
-{"version":3,"file":"use-hover.js","names":[],"sources":["../../src/hooks/use-hover.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\n\n/**\n * Track whether the pointer is hovering over the referenced element.\n * Returns `false` on touch-only devices (no pointer hover).\n *\n * @example\n * const ref = useRef<HTMLDivElement>(null);\n * const hovered = useHover(ref);\n * return <div ref={ref}>{hovered ? \"✨\" : \"\"}</div>;\n */\nexport function useHover<T extends HTMLElement>(ref: RefObject<T | null>): boolean {\n    const [hovered, setHovered] = useState<boolean>(false);\n\n    useEffect(() => {\n        const node = ref.current;\n        if (!node) return;\n        const onEnter = (): void => setHovered(true);\n        const onLeave = (): void => setHovered(false);\n        node.addEventListener(\"mouseenter\", onEnter);\n        node.addEventListener(\"mouseleave\", onLeave);\n        return () => {\n            node.removeEventListener(\"mouseenter\", onEnter);\n            node.removeEventListener(\"mouseleave\", onLeave);\n        };\n    }, [ref]);\n\n    return hovered;\n}\n"],"mappings":";;AAYA,SAAgB,EAAgC,GAAmC;CAC/E,IAAM,CAAC,GAAS,KAAc,EAAkB,EAAK;CAerD,OAbA,QAAgB;EACZ,IAAM,IAAO,EAAI;EACjB,IAAI,CAAC,GAAM;EACX,IAAM,UAAsB,EAAW,EAAI,GACrC,UAAsB,EAAW,EAAK;EAG5C,OAFA,EAAK,iBAAiB,cAAc,CAAO,GAC3C,EAAK,iBAAiB,cAAc,CAAO,SAC9B;GAET,AADA,EAAK,oBAAoB,cAAc,CAAO,GAC9C,EAAK,oBAAoB,cAAc,CAAO;EAClD;CACJ,GAAG,CAAC,CAAG,CAAC,GAED;AACX"}
+{"version":3,"file":"use-hover.js","names":["useHover","hovered","setHovered","useState","useEffect","node","ref","onEnter","onLeave"],"sources":["../../src/hooks/use-hover.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\n\n/**\n * Track whether the pointer is hovering over the referenced element.\n * Returns `false` on touch-only devices (no pointer hover).\n *\n * @example\n * const ref = useRef<HTMLDivElement>(null);\n * const hovered = useHover(ref);\n * return <div ref={ref}>{hovered ? \"✨\" : \"\"}</div>;\n */\nexport function useHover<T extends HTMLElement>(ref: RefObject<T | null>): boolean {\n    const [hovered, setHovered] = useState<boolean>(false);\n\n    useEffect(() => {\n        const node = ref.current;\n        if (!node) return;\n        const onEnter = (): void => setHovered(true);\n        const onLeave = (): void => setHovered(false);\n        node.addEventListener(\"mouseenter\", onEnter);\n        node.addEventListener(\"mouseleave\", onLeave);\n        return () => {\n            node.removeEventListener(\"mouseenter\", onEnter);\n            node.removeEventListener(\"mouseleave\", onLeave);\n        };\n    }, [ref]);\n\n    return hovered;\n}\n"],"mappings":";;AAYA,SAAgBA,EAAgC,GAAmC;CAC/E,IAAM,CAACC,GAASC,KAAcC,EAAkB,EAAK;CAerD,OAbAC,QAAgB;EACZ,IAAMC,IAAOC,EAAI;EACjB,IAAI,CAACD,GAAM;EACX,IAAME,UAAsBL,EAAW,EAAI,GACrCM,UAAsBN,EAAW,EAAK;EAG5C,OAFAG,EAAK,iBAAiB,cAAcE,CAAO,GAC3CF,EAAK,iBAAiB,cAAcG,CAAO,SAC9B;GAET,AADAH,EAAK,oBAAoB,cAAcE,CAAO,GAC9CF,EAAK,oBAAoB,cAAcG,CAAO;EAClD;CACJ,GAAG,CAACF,CAAG,CAAC,GAEDL;AACX"}