react-hook-toolkit 4.0.0 → 5.0.0

package/dist/chunk1516/chunk2021.js

@@ -0,0 +1,406 @@
+import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
+/**
+ * Returns a function that scrolls the window (or a given element) to the top.
+ * Also returns a boolean indicating whether the user has scrolled down enough
+ * that a "back to top" button should be shown (default threshold: 300px).
+ */
+export function useScrollToTop(threshold = 300, options = {}) {
+    const { behavior = 'smooth', element } = options;
+    const [isVisible, setIsVisible] = useState(false);
+    useEffect(() => {
+        var _a;
+        const target = (_a = element === null || element === void 0 ? void 0 : element.current) !== null && _a !== void 0 ? _a : window;
+        const getY = () => (element === null || element === void 0 ? void 0 : element.current) ? element.current.scrollTop : window.scrollY;
+        const handler = () => setIsVisible(getY() > threshold);
+        target.addEventListener('scroll', handler, { passive: true });
+        return () => target.removeEventListener('scroll', handler);
+    }, [threshold, element]);
+    const scrollToTop = useCallback(() => {
+        var _a, _b, _c;
+        const target = (_a = element === null || element === void 0 ? void 0 : element.current) !== null && _a !== void 0 ? _a : window;
+        (_c = (_b = target).scrollTo) === null || _c === void 0 ? void 0 : _c.call(_b, { top: 0, behavior });
+        if (element === null || element === void 0 ? void 0 : element.current)
+            element.current.scrollTo({ top: 0, behavior });
+    }, [behavior, element]);
+    return [isVisible, scrollToTop];
+}
+/**
+ * Returns a ref and a function that scrolls the ref'd element into the viewport.
+ */
+export function useScrollIntoView(defaultOptions = { behavior: 'smooth', block: 'center' }) {
+    const ref = useRef(null);
+    const scrollIntoView = useCallback((options) => {
+        var _a;
+        (_a = ref.current) === null || _a === void 0 ? void 0 : _a.scrollIntoView(Object.assign(Object.assign({}, defaultOptions), options));
+    }, [defaultOptions]);
+    return { ref, scrollIntoView };
+}
+// ─── useFocusTrap ─────────────────────────────────────────────────────────────
+const FOCUSABLE = [
+    'a[href]', 'area[href]', 'input:not([disabled])', 'select:not([disabled])',
+    'textarea:not([disabled])', 'button:not([disabled])', 'iframe', 'object',
+    'embed', '[tabindex]:not([tabindex="-1"])', '[contenteditable]',
+].join(',');
+/**
+ * Traps keyboard focus within a container element. Tab/Shift+Tab cycle only
+ * through focusable elements inside the container while the trap is active.
+ * Essential for accessible modals, drawers, and dialogs.
+ */
+export function useFocusTrap(initiallyActive = false) {
+    const ref = useRef(null);
+    const [isActive, setIsActive] = useState(initiallyActive);
+    const previousFocusRef = useRef(null);
+    useEffect(() => {
+        var _a;
+        if (!isActive || !ref.current)
+            return;
+        previousFocusRef.current = document.activeElement;
+        const getFocusable = () => Array.from(ref.current.querySelectorAll(FOCUSABLE));
+        const focusable = getFocusable();
+        (_a = focusable[0]) === null || _a === void 0 ? void 0 : _a.focus();
+        const handler = (e) => {
+            if (e.key !== 'Tab')
+                return;
+            const elements = getFocusable();
+            const first = elements[0];
+            const last = elements[elements.length - 1];
+            if (e.shiftKey) {
+                if (document.activeElement === first) {
+                    e.preventDefault();
+                    last === null || last === void 0 ? void 0 : last.focus();
+                }
+            }
+            else {
+                if (document.activeElement === last) {
+                    e.preventDefault();
+                    first === null || first === void 0 ? void 0 : first.focus();
+                }
+            }
+        };
+        document.addEventListener('keydown', handler);
+        return () => {
+            var _a;
+            document.removeEventListener('keydown', handler);
+            (_a = previousFocusRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+        };
+    }, [isActive]);
+    const activate = useCallback(() => setIsActive(true), []);
+    const deactivate = useCallback(() => setIsActive(false), []);
+    return { ref, activate, deactivate, isActive };
+}
+/**
+ * Windowed (virtual) list rendering. Only renders items visible in the
+ * scroll container plus an overscan buffer. Dramatically reduces DOM nodes for
+ * large lists. Requires a fixed itemHeight.
+ */
+export function useVirtualList(items, options) {
+    const { itemHeight, overscan = 3 } = options;
+    const containerRef = useRef(null);
+    const [scrollTop, setScrollTop] = useState(0);
+    const [containerHeight, setContainerHeight] = useState(0);
+    useEffect(() => {
+        const el = containerRef.current;
+        if (!el)
+            return;
+        setContainerHeight(el.clientHeight);
+        const onScroll = () => setScrollTop(el.scrollTop);
+        const observer = new ResizeObserver(() => setContainerHeight(el.clientHeight));
+        el.addEventListener('scroll', onScroll, { passive: true });
+        observer.observe(el);
+        return () => { el.removeEventListener('scroll', onScroll); observer.disconnect(); };
+    }, []);
+    const virtualItems = useMemo(() => {
+        const start = Math.max(0, Math.floor(scrollTop / itemHeight) - overscan);
+        const end = Math.min(items.length - 1, Math.ceil((scrollTop + containerHeight) / itemHeight) + overscan);
+        const result = [];
+        for (let i = start; i <= end; i++) {
+            result.push({ item: items[i], index: i, offsetTop: i * itemHeight });
+        }
+        return result;
+    }, [items, scrollTop, containerHeight, itemHeight, overscan]);
+    return { containerRef, virtualItems, totalHeight: items.length * itemHeight };
+}
+const BREAKPOINTS = {
+    xs: 0, sm: 640, md: 768, lg: 1024, xl: 1280, '2xl': 1536,
+};
+/**
+ * Returns the current named breakpoint based on window width.
+ * Uses Tailwind-compatible breakpoints by default.
+ */
+export function useBreakpoint() {
+    const getBreakpoint = () => {
+        var _a;
+        const w = typeof window !== 'undefined' ? window.innerWidth : 0;
+        const keys = Object.keys(BREAKPOINTS).reverse();
+        return (_a = keys.find(k => w >= BREAKPOINTS[k])) !== null && _a !== void 0 ? _a : 'xs';
+    };
+    const [breakpoint, setBreakpoint] = useState(getBreakpoint);
+    useEffect(() => {
+        const update = () => setBreakpoint(getBreakpoint());
+        window.addEventListener('resize', update, { passive: true });
+        return () => window.removeEventListener('resize', update);
+    }, []);
+    return breakpoint;
+}
+const THEME_KEY = 'rht:theme';
+/**
+ * Manages a light/dark/system theme with persistence to localStorage.
+ * Applies a `data-theme` attribute to `<html>` and resolves the system preference.
+ */
+export function useTheme() {
+    const [theme, setThemeState] = useState(() => { var _a; return (_a = (typeof localStorage !== 'undefined' ? localStorage.getItem(THEME_KEY) : null)) !== null && _a !== void 0 ? _a : 'system'; });
+    const getResolved = (t) => {
+        if (t !== 'system')
+            return t;
+        return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+    };
+    const [resolvedTheme, setResolvedTheme] = useState(() => getResolved(theme));
+    useEffect(() => {
+        const resolved = getResolved(theme);
+        setResolvedTheme(resolved);
+        document.documentElement.setAttribute('data-theme', resolved);
+        document.documentElement.classList.toggle('dark', resolved === 'dark');
+        localStorage.setItem(THEME_KEY, theme);
+    }, [theme]);
+    useEffect(() => {
+        if (theme !== 'system')
+            return;
+        const mq = window.matchMedia('(prefers-color-scheme: dark)');
+        const update = () => setResolvedTheme(mq.matches ? 'dark' : 'light');
+        mq.addEventListener('change', update);
+        return () => mq.removeEventListener('change', update);
+    }, [theme]);
+    const setTheme = useCallback((t) => setThemeState(t), []);
+    const toggleTheme = useCallback(() => setThemeState(prev => prev === 'dark' ? 'light' : 'dark'), []);
+    return { theme, resolvedTheme, setTheme, toggleTheme };
+}
+/**
+ * Material-style ripple effect. Spread the returned props onto a button/div.
+ * Render each ripple as an absolutely-positioned circular element using the
+ * provided x/y/size values.
+ */
+export function useRipple(duration = 600) {
+    const [ripples, setRipples] = useState([]);
+    const idRef = useRef(0);
+    const onMouseDown = useCallback((e) => {
+        const el = e.currentTarget;
+        const rect = el.getBoundingClientRect();
+        const size = Math.max(rect.width, rect.height) * 2;
+        const x = e.clientX - rect.left - size / 2;
+        const y = e.clientY - rect.top - size / 2;
+        const id = ++idRef.current;
+        setRipples(prev => [...prev, { id, x, y, size }]);
+        setTimeout(() => setRipples(prev => prev.filter(r => r.id !== id)), duration);
+    }, [duration]);
+    return { ripples, onMouseDown };
+}
+let toastId = 0;
+/**
+ * Manages a list of toast notifications with automatic dismissal after a duration.
+ */
+export function useToast() {
+    const [toasts, setToasts] = useState([]);
+    const dismiss = useCallback((id) => setToasts(prev => prev.filter(t => t.id !== id)), []);
+    const show = useCallback((message, type = 'info', duration = 4000) => {
+        const id = ++toastId;
+        setToasts(prev => [...prev, { id, message, type, duration }]);
+        if (duration > 0)
+            setTimeout(() => dismiss(id), duration);
+    }, [dismiss]);
+    const clear = useCallback(() => setToasts([]), []);
+    return { toasts, show, dismiss, clear };
+}
+/**
+ * Manages modal open/close state. Automatically restores body scroll on close.
+ */
+export function useModal(initialOpen = false) {
+    const [isOpen, setIsOpen] = useState(initialOpen);
+    useEffect(() => {
+        if (isOpen) {
+            const prev = document.body.style.overflow;
+            document.body.style.overflow = 'hidden';
+            return () => { document.body.style.overflow = prev; };
+        }
+    }, [isOpen]);
+    const open = useCallback(() => setIsOpen(true), []);
+    const close = useCallback(() => setIsOpen(false), []);
+    const toggle = useCallback(() => setIsOpen(v => !v), []);
+    return { isOpen, open, close, toggle };
+}
+/**
+ * Captures right-click position to display a custom context menu at the cursor.
+ * Closes on outside click or Escape.
+ */
+export function useContextMenu() {
+    const [state, setState] = useState({ isVisible: false, x: 0, y: 0 });
+    const close = useCallback(() => setState(s => (Object.assign(Object.assign({}, s), { isVisible: false }))), []);
+    useEffect(() => {
+        if (!state.isVisible)
+            return;
+        const onKey = (e) => { if (e.key === 'Escape')
+            close(); };
+        document.addEventListener('click', close);
+        document.addEventListener('keydown', onKey);
+        return () => { document.removeEventListener('click', close); document.removeEventListener('keydown', onKey); };
+    }, [state.isVisible, close]);
+    const targetProps = {
+        onContextMenu: useCallback((e) => {
+            e.preventDefault();
+            setState({ isVisible: true, x: e.clientX, y: e.clientY });
+        }, []),
+    };
+    return { state, targetProps, close };
+}
+/**
+ * Controlled input hook. Spread `bind` onto any input/textarea/select element.
+ * Returns value, reset, and direct setter.
+ */
+export function useInput(initialValue) {
+    const [value, setValue] = useState(initialValue);
+    const onChange = useCallback((e) => {
+        const el = e.target;
+        const next = (el.type === 'checkbox' ? el.checked : el.value);
+        setValue(next);
+    }, []);
+    const reset = useCallback(() => setValue(initialValue), [initialValue]);
+    const set = useCallback((v) => setValue(v), []);
+    return { value, onChange, reset, set, bind: { value, onChange } };
+}
+/**
+ * Standalone field validation hook. Pass an array of validator functions;
+ * returns the first error message or null.
+ */
+export function useValidation(validators) {
+    const [error, setError] = useState(null);
+    const validate = useCallback((value) => {
+        for (const fn of validators) {
+            const msg = fn(value);
+            if (msg) {
+                setError(msg);
+                return false;
+            }
+        }
+        setError(null);
+        return true;
+    }, [validators]);
+    const reset = useCallback(() => setError(null), []);
+    return { error, validate, reset };
+}
+/**
+ * Controlled checkbox state with a toggle function and spread-ready bind props.
+ */
+export function useCheckbox(initialChecked = false) {
+    const [checked, setChecked] = useState(initialChecked);
+    const toggle = useCallback(() => setChecked(v => !v), []);
+    return { checked, toggle, setChecked, bind: { checked, onChange: toggle } };
+}
+/**
+ * Filters an array of items using a search query and a key extractor function.
+ * Returns the query state and the filtered results.
+ */
+export function useSearch(items, getSearchableText, debounceMs = 0) {
+    const [query, setQueryState] = useState('');
+    const [debouncedQuery, setDebouncedQuery] = useState('');
+    const timerRef = useRef();
+    const setQuery = useCallback((q) => {
+        setQueryState(q);
+        clearTimeout(timerRef.current);
+        if (debounceMs > 0) {
+            timerRef.current = setTimeout(() => setDebouncedQuery(q), debounceMs);
+        }
+        else {
+            setDebouncedQuery(q);
+        }
+    }, [debounceMs]);
+    useEffect(() => () => clearTimeout(timerRef.current), []);
+    const activeQuery = debounceMs > 0 ? debouncedQuery : query;
+    const results = useMemo(() => {
+        if (!activeQuery.trim())
+            return items;
+        const lower = activeQuery.toLowerCase();
+        return items.filter(item => getSearchableText(item).toLowerCase().includes(lower));
+    }, [items, activeQuery, getSearchableText]);
+    const clear = useCallback(() => { setQueryState(''); setDebouncedQuery(''); }, []);
+    return { query, setQuery, results, clear };
+}
+/**
+ * Filters an array with a predicate function. Returns the filtered list,
+ * a setter for the predicate, and a clear function.
+ */
+export function useFilter(items) {
+    const [filter, setFilterFn] = useState(null);
+    const filtered = useMemo(() => filter ? items.filter(filter) : items, [items, filter]);
+    const setFilter = useCallback((fn) => {
+        setFilterFn(() => fn);
+    }, []);
+    const clearFilter = useCallback(() => setFilterFn(null), []);
+    return { filtered, setFilter, clearFilter, isFiltered: filter !== null };
+}
+/**
+ * Sorts an array by a key, toggling direction on repeated calls with the same key.
+ */
+export function useSort(items) {
+    const [sortKey, setSortKey] = useState(null);
+    const [direction, setDirection] = useState('asc');
+    const setSort = useCallback((key) => {
+        setDirection(prev => sortKey === key && prev === 'asc' ? 'desc' : 'asc');
+        setSortKey(key);
+    }, [sortKey]);
+    const clearSort = useCallback(() => { setSortKey(null); setDirection('asc'); }, []);
+    const sorted = useMemo(() => {
+        if (!sortKey)
+            return items;
+        return [...items].sort((a, b) => {
+            const av = a[sortKey];
+            const bv = b[sortKey];
+            const cmp = av < bv ? -1 : av > bv ? 1 : 0;
+            return direction === 'asc' ? cmp : -cmp;
+        });
+    }, [items, sortKey, direction]);
+    return { sorted, sortKey, direction, setSort, clearSort };
+}
+/**
+ * Autocomplete suggestions list with keyboard navigation (Up/Down/Enter/Escape).
+ */
+export function useAutocomplete(getSuggestions, onSelect, getLabel) {
+    const [query, setQuery] = useState('');
+    const [selectedIndex, setSelectedIndex] = useState(-1);
+    const [isOpen, setIsOpen] = useState(false);
+    const suggestions = useMemo(() => query.trim() ? getSuggestions(query) : [], [query, getSuggestions]);
+    useEffect(() => {
+        setIsOpen(suggestions.length > 0);
+        setSelectedIndex(-1);
+    }, [suggestions.length]);
+    const select = useCallback((item) => {
+        setQuery(getLabel ? getLabel(item) : String(item));
+        setIsOpen(false);
+        onSelect === null || onSelect === void 0 ? void 0 : onSelect(item);
+    }, [onSelect, getLabel]);
+    const clear = useCallback(() => { setQuery(''); setIsOpen(false); }, []);
+    const inputProps = {
+        value: query,
+        onChange: useCallback((e) => {
+            setQuery(e.target.value);
+        }, []),
+        onKeyDown: useCallback((e) => {
+            if (!isOpen)
+                return;
+            if (e.key === 'ArrowDown') {
+                e.preventDefault();
+                setSelectedIndex(i => Math.min(i + 1, suggestions.length - 1));
+            }
+            else if (e.key === 'ArrowUp') {
+                e.preventDefault();
+                setSelectedIndex(i => Math.max(i - 1, -1));
+            }
+            else if (e.key === 'Enter' && selectedIndex >= 0) {
+                e.preventDefault();
+                select(suggestions[selectedIndex]);
+            }
+            else if (e.key === 'Escape') {
+                setIsOpen(false);
+            }
+        }, [isOpen, selectedIndex, suggestions, select]),
+    };
+    return { query, suggestions, selectedIndex, isOpen, inputProps, select, clear };
+}

package/dist/chunk1516/chunk2122.d.ts

@@ -0,0 +1,77 @@
+type QueryParamValue = string | null;
+interface UseQueryParamsReturn {
+    params: URLSearchParams;
+    get: (key: string) => QueryParamValue;
+    set: (key: string, value: string) => void;
+    delete: (key: string) => void;
+    clear: () => void;
+    toString: () => string;
+}
+/**
+ * Reads and writes URL search parameters reactively.
+ * Updates the browser URL (without navigation) when params change.
+ */
+export declare function useQueryParams(): UseQueryParamsReturn;
+/**
+ * Extracts named dynamic route parameters from the current URL path given a
+ * pattern like "/users/:id/posts/:postId".
+ * Returns null for each key when the pattern does not match the current path.
+ */
+export declare function useParams<T extends Record<string, string>>(pattern: string): Partial<T>;
+type NotificationPermission = 'default' | 'denied' | 'granted';
+interface UseNotificationReturn {
+    permission: NotificationPermission;
+    isSupported: boolean;
+    requestPermission: () => Promise<void>;
+    show: (title: string, options?: NotificationOptions) => Notification | null;
+}
+/**
+ * Web Notifications API wrapper. Requests permission and shows notifications.
+ */
+export declare function useNotification(): UseNotificationReturn;
+interface UseVibrationReturn {
+    isSupported: boolean;
+    vibrate: (pattern: number | number[]) => void;
+    stop: () => void;
+}
+/**
+ * Wraps the Vibration API. Triggers device vibration on supported mobile devices.
+ * Pattern can be a single duration (ms) or an alternating [vibrate, pause] array.
+ */
+export declare function useVibration(): UseVibrationReturn;
+interface UseWakeLockReturn {
+    isSupported: boolean;
+    isActive: boolean;
+    request: () => Promise<void>;
+    release: () => Promise<void>;
+    error: Error | null;
+}
+/**
+ * Screen Wake Lock API — prevents the device screen from sleeping while active.
+ * Automatically re-acquires the lock when the page becomes visible again.
+ */
+export declare function useWakeLock(): UseWakeLockReturn;
+interface UseShareSheetReturn {
+    isSupported: boolean;
+    share: (data: ShareData) => Promise<void>;
+    error: Error | null;
+}
+/**
+ * Web Share API wrapper. Triggers the native OS share sheet.
+ * Falls back gracefully when the API is not available.
+ */
+export declare function useShareSheet(): UseShareSheetReturn;
+type EventHandler = (...args: any[]) => void;
+interface UseEventEmitterReturn {
+    on: (event: string, handler: EventHandler) => void;
+    off: (event: string, handler: EventHandler) => void;
+    emit: (event: string, ...args: any[]) => void;
+    once: (event: string, handler: EventHandler) => void;
+    clear: (event?: string) => void;
+}
+/**
+ * In-component pub/sub event emitter. Useful for decoupled sibling communication
+ * without lifting state or using a global store.
+ */
+export declare function useEventEmitter(): UseEventEmitterReturn;
+export {};

package/dist/chunk1516/chunk2122.js

@@ -0,0 +1,193 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+/**
+ * Reads and writes URL search parameters reactively.
+ * Updates the browser URL (without navigation) when params change.
+ */
+export function useQueryParams() {
+    const [params, setParams] = useState(() => new URLSearchParams(window.location.search));
+    useEffect(() => {
+        const onPop = () => setParams(new URLSearchParams(window.location.search));
+        window.addEventListener('popstate', onPop);
+        return () => window.removeEventListener('popstate', onPop);
+    }, []);
+    const update = useCallback((next) => {
+        const url = `${window.location.pathname}?${next.toString()}${window.location.hash}`;
+        window.history.pushState({}, '', url);
+        setParams(next);
+    }, []);
+    const set = useCallback((key, value) => {
+        const next = new URLSearchParams(params.toString());
+        next.set(key, value);
+        update(next);
+    }, [params, update]);
+    const del = useCallback((key) => {
+        const next = new URLSearchParams(params.toString());
+        next.delete(key);
+        update(next);
+    }, [params, update]);
+    const clear = useCallback(() => update(new URLSearchParams()), [update]);
+    return {
+        params,
+        get: (key) => params.get(key),
+        set,
+        delete: del,
+        clear,
+        toString: () => params.toString(),
+    };
+}
+// ─── useParams ────────────────────────────────────────────────────────────────
+/**
+ * Extracts named dynamic route parameters from the current URL path given a
+ * pattern like "/users/:id/posts/:postId".
+ * Returns null for each key when the pattern does not match the current path.
+ */
+export function useParams(pattern) {
+    const extract = (path) => {
+        const keys = [];
+        const regexStr = pattern
+            .replace(/:([^/]+)/g, (_, key) => { keys.push(key); return '([^/]+)'; })
+            .replace(/\//g, '\\/');
+        const match = path.match(new RegExp(`^${regexStr}$`));
+        if (!match)
+            return {};
+        return keys.reduce((acc, key, i) => (Object.assign(Object.assign({}, acc), { [key]: match[i + 1] })), {});
+    };
+    const [params, setParams] = useState(() => extract(window.location.pathname));
+    useEffect(() => {
+        const update = () => setParams(extract(window.location.pathname));
+        window.addEventListener('popstate', update);
+        return () => window.removeEventListener('popstate', update);
+    }, [pattern]);
+    return params;
+}
+/**
+ * Web Notifications API wrapper. Requests permission and shows notifications.
+ */
+export function useNotification() {
+    const isSupported = typeof window !== 'undefined' && 'Notification' in window;
+    const [permission, setPermission] = useState(isSupported ? Notification.permission : 'denied');
+    const requestPermission = useCallback(async () => {
+        if (!isSupported)
+            return;
+        const result = await Notification.requestPermission();
+        setPermission(result);
+    }, [isSupported]);
+    const show = useCallback((title, options) => {
+        if (!isSupported || permission !== 'granted')
+            return null;
+        return new Notification(title, options);
+    }, [isSupported, permission]);
+    return { permission, isSupported, requestPermission, show };
+}
+/**
+ * Wraps the Vibration API. Triggers device vibration on supported mobile devices.
+ * Pattern can be a single duration (ms) or an alternating [vibrate, pause] array.
+ */
+export function useVibration() {
+    const isSupported = typeof navigator !== 'undefined' && 'vibrate' in navigator;
+    const vibrate = useCallback((pattern) => {
+        if (isSupported)
+            navigator.vibrate(pattern);
+    }, [isSupported]);
+    const stop = useCallback(() => {
+        if (isSupported)
+            navigator.vibrate(0);
+    }, [isSupported]);
+    return { isSupported, vibrate, stop };
+}
+/**
+ * Screen Wake Lock API — prevents the device screen from sleeping while active.
+ * Automatically re-acquires the lock when the page becomes visible again.
+ */
+export function useWakeLock() {
+    const isSupported = typeof navigator !== 'undefined' && 'wakeLock' in navigator;
+    const [isActive, setIsActive] = useState(false);
+    const [error, setError] = useState(null);
+    const lockRef = useRef(null);
+    const request = useCallback(async () => {
+        var _a;
+        if (!isSupported)
+            return;
+        try {
+            lockRef.current = await navigator.wakeLock.request('screen');
+            setIsActive(true);
+            setError(null);
+            (_a = lockRef.current) === null || _a === void 0 ? void 0 : _a.addEventListener('release', () => setIsActive(false));
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('WakeLock failed'));
+        }
+    }, [isSupported]);
+    const release = useCallback(async () => {
+        var _a;
+        await ((_a = lockRef.current) === null || _a === void 0 ? void 0 : _a.release());
+        lockRef.current = null;
+        setIsActive(false);
+    }, []);
+    // Re-acquire after page regains visibility
+    useEffect(() => {
+        if (!isSupported)
+            return;
+        const onVisible = () => { if (document.visibilityState === 'visible' && isActive)
+            request(); };
+        document.addEventListener('visibilitychange', onVisible);
+        return () => document.removeEventListener('visibilitychange', onVisible);
+    }, [isSupported, isActive, request]);
+    useEffect(() => () => { var _a; (_a = lockRef.current) === null || _a === void 0 ? void 0 : _a.release().catch(() => { }); }, []);
+    return { isSupported, isActive, request, release, error };
+}
+/**
+ * Web Share API wrapper. Triggers the native OS share sheet.
+ * Falls back gracefully when the API is not available.
+ */
+export function useShareSheet() {
+    const isSupported = typeof navigator !== 'undefined' && 'share' in navigator;
+    const [error, setError] = useState(null);
+    const share = useCallback(async (data) => {
+        if (!isSupported) {
+            setError(new Error('Web Share API not supported'));
+            return;
+        }
+        try {
+            setError(null);
+            await navigator.share(data);
+        }
+        catch (err) {
+            if (err.name !== 'AbortError') {
+                setError(err instanceof Error ? err : new Error('Share failed'));
+            }
+        }
+    }, [isSupported]);
+    return { isSupported, share, error };
+}
+/**
+ * In-component pub/sub event emitter. Useful for decoupled sibling communication
+ * without lifting state or using a global store.
+ */
+export function useEventEmitter() {
+    const listenersRef = useRef(new Map());
+    const on = useCallback((event, handler) => {
+        if (!listenersRef.current.has(event))
+            listenersRef.current.set(event, new Set());
+        listenersRef.current.get(event).add(handler);
+    }, []);
+    const off = useCallback((event, handler) => {
+        var _a;
+        (_a = listenersRef.current.get(event)) === null || _a === void 0 ? void 0 : _a.delete(handler);
+    }, []);
+    const emit = useCallback((event, ...args) => {
+        var _a;
+        (_a = listenersRef.current.get(event)) === null || _a === void 0 ? void 0 : _a.forEach(fn => fn(...args));
+    }, []);
+    const once = useCallback((event, handler) => {
+        const wrapper = (...args) => { handler(...args); off(event, wrapper); };
+        on(event, wrapper);
+    }, [on, off]);
+    const clear = useCallback((event) => {
+        if (event)
+            listenersRef.current.delete(event);
+        else
+            listenersRef.current.clear();
+    }, []);
+    return { on, off, emit, once, clear };
+}