reshaped 3.10.0-canary.5 → 3.10.0-canary.7

package/dist/core/Actionable/Actionable.js

@@ -1,73 +0,0 @@
-"use client";
-import { jsx as _jsx } from "react/jsx-runtime";
-import { classNames } from "@reshaped/utilities";
-import { forwardRef } from "react";
-import * as keys from "../../constants/keys.js";
-const Actionable = forwardRef((props, ref) => {
-    const { children, render, href, onClick, type, disabled, as, stopPropagation, className, attributes, } = props;
-    const rootAttributes = { ...attributes };
-    const hasClickHandler = onClick || attributes?.onClick;
-    const hasFocusHandler = attributes?.onFocus || attributes?.onBlur;
-    const isLink = Boolean(href || attributes?.href);
-    // Including attributes ref for the cases when event listeners are added through it
-    // To make sure it doesn't render a span
-    const isButton = Boolean(hasClickHandler || hasFocusHandler || type || attributes?.ref);
-    const renderedAsButton = !isLink && isButton && (!as || as === "button");
-    // Using any here to let TS save on type resolving, otherwise TS throws an error due to the type complexity
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let TagName;
-    if (isLink) {
-        TagName = "a";
-        rootAttributes.href = disabled ? undefined : href || attributes?.href;
-    }
-    else if (renderedAsButton) {
-        TagName = "button";
-        rootAttributes.type = type || attributes?.type || "button";
-        rootAttributes.disabled = disabled || attributes?.disabled;
-    }
-    else if (isButton) {
-        const isFocusable = as === "label";
-        const simulateButton = !isFocusable || hasClickHandler || hasFocusHandler;
-        TagName = as || "span";
-        rootAttributes.role = simulateButton ? "button" : undefined;
-        rootAttributes.tabIndex = simulateButton ? 0 : undefined;
-    }
-    else {
-        TagName = as || "span";
-    }
-    const handlePress = (event) => {
-        if (disabled)
-            return;
-        if (stopPropagation)
-            event.stopPropagation();
-        onClick?.(event);
-        attributes?.onClick?.(event);
-    };
-    const handleKeyDown = (event) => {
-        const isSpace = event.key === keys.SPACE;
-        const isEnter = event.key === keys.ENTER;
-        if (!isSpace && !isEnter)
-            return;
-        if (rootAttributes.role !== "button")
-            return;
-        if (stopPropagation)
-            event.stopPropagation();
-        event.preventDefault();
-        handlePress(event);
-    };
-    const tagAttributes = {
-        ref: ref,
-        // rootAttributes can receive ref from Flyout
-        ...rootAttributes,
-        className: classNames(className),
-        onClick: handlePress,
-        onKeyDown: handleKeyDown,
-        "aria-disabled": disabled ? true : undefined,
-        children: children,
-    };
-    if (render)
-        return render(tagAttributes);
-    return _jsx(TagName, { ...tagAttributes });
-});
-Actionable.displayName = "Actionable";
-export default Actionable;

package/dist/core/Actionable/Actionable.types.d.ts

@@ -1,34 +0,0 @@
-import type React from "react";
-import type * as G from "../../types/global";
-export type AttributesRef = React.RefObject<HTMLButtonElement | null>;
-type Attributes = G.Attributes<"button"> & Omit<React.JSX.IntrinsicElements["a"], keyof G.Attributes<"button">> & {
-    ref?: AttributesRef;
-};
-export type RenderAttributes = G.Attributes<"a"> & {
-    ref: React.RefObject<HTMLAnchorElement | null>;
-    children: React.ReactNode;
-};
-export type Props = {
-    /** Node for inserting the content */
-    children?: React.ReactNode;
-    /** Render a custom root element, useful for integrating with routers */
-    render?: (attributes: RenderAttributes) => React.ReactNode;
-    /** Callback when clicked, renders it as a button tag if href is not provided */
-    onClick?: (e: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>) => void;
-    /** URL, renders it as an anchor tag */
-    href?: string;
-    /** Type attribute, renders it as a button tag */
-    type?: React.ButtonHTMLAttributes<HTMLButtonElement>["type"];
-    /** Disable from user interaction */
-    disabled?: boolean;
-    /** Prevent the event from bubbling up to the parent */
-    stopPropagation?: boolean;
-    /** Render as a different element */
-    as?: keyof React.JSX.IntrinsicElements;
-    /** Additional classname for the root element */
-    className?: G.ClassName;
-    /** Additional attributes for the root element */
-    attributes?: Attributes;
-};
-export type Ref = HTMLButtonElement | HTMLAnchorElement;
-export {};

package/dist/core/Actionable/Actionable.types.js

@@ -1 +0,0 @@
-export {};

package/dist/core/Actionable/index.d.ts

@@ -1,2 +0,0 @@
-export { default } from "./Actionable";
-export type { Props as ActionableProps, Ref as ActionableRef } from "./Actionable.types";

package/dist/core/Actionable/index.js

@@ -1 +0,0 @@
-export { default } from "./Actionable.js";

package/dist/hooks/_private/useSingletonEnvironment.d.ts

@@ -1,9 +0,0 @@
-import React from "react";
-import type * as G from "../../types/global";
-type Context = {
-    rtl: [boolean, (state: boolean) => void];
-    defaultViewport: G.Viewport;
-};
-export declare const SingletonEnvironmentContext: React.Context<Context>;
-export declare const useSingletonEnvironment: (defaultRTL?: boolean) => [boolean, React.Dispatch<React.SetStateAction<boolean>>];
-export {};

package/dist/hooks/_private/useSingletonEnvironment.js

@@ -1,33 +0,0 @@
-import React from "react";
-import useIsomorphicLayoutEffect from "../useIsomorphicLayoutEffect.js";
-export const SingletonEnvironmentContext = React.createContext({
-    rtl: [false, () => { }],
-    defaultViewport: "s",
-});
-export const useSingletonEnvironment = (defaultRTL) => {
-    const state = React.useState(defaultRTL || false);
-    const [isRTL, setRTL] = state;
-    /**
-     * Handle changing dir attribute directly
-     */
-    useIsomorphicLayoutEffect(() => {
-        const observer = new MutationObserver((mutations) => {
-            mutations.forEach((mutation) => {
-                if (mutation.attributeName !== "dir")
-                    return;
-                const nextRTL = mutation.target.dir === "rtl";
-                if (isRTL !== nextRTL)
-                    setRTL(nextRTL);
-            });
-        });
-        observer.observe(document.documentElement, { attributes: true });
-        return () => observer.disconnect();
-    }, [isRTL]);
-    /**
-     * Handle setRTL usage
-     */
-    useIsomorphicLayoutEffect(() => {
-        document.documentElement.setAttribute("dir", isRTL ? "rtl" : "ltr");
-    }, [isRTL]);
-    return state;
-};

package/dist/hooks/_private/useSingletonHotkeys.d.ts

@@ -1,35 +0,0 @@
-import React from "react";
-/**
- * Types
- */
-type Callback = (e?: KeyboardEvent) => void;
-type PressedMap = Map<string, KeyboardEvent>;
-export type Hotkeys = Record<string, Callback | null>;
-type HotkeyOptions = {
-    preventDefault?: boolean;
-};
-type Context = {
-    isPressed: (key: string) => boolean;
-    addHotkeys: (hotkeys: Hotkeys, ref: React.RefObject<HTMLElement | null>, options?: HotkeyOptions) => (() => void) | undefined;
-};
-type HotkeyData = {
-    callback: Callback;
-    ref: React.RefObject<HTMLElement | null>;
-    options: HotkeyOptions;
-};
-export declare class HotkeyStore {
-    hotkeyMap: Record<string, Set<HotkeyData>>;
-    getSize: () => number;
-    bindHotkeys: (hotkeys: Hotkeys, ref: React.RefObject<HTMLElement | null>, options: HotkeyOptions) => void;
-    unbindHotkeys: (hotkeys: Hotkeys) => void;
-    handleKeyDown: (pressedMap: PressedMap, e: KeyboardEvent) => void;
-}
-/**
- * Components / Hooks
- */
-export declare const HotkeyContext: React.Context<Context>;
-export declare const SingletonHotkeysProvider: React.FC<{
-    children: React.ReactNode;
-}>;
-declare const useSingletonHotkeys: () => Context;
-export default useSingletonHotkeys;

package/dist/hooks/_private/useSingletonHotkeys.js

@@ -1,191 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import React from "react";
-/**
- * Utilities
- */
-const COMBINATION_DELIMETER = "+";
-const pressedMap = new Map();
-let modifiedKeys = [];
-const formatHotkey = (hotkey) => {
-    if (hotkey === " ")
-        return hotkey;
-    return hotkey.replace(/\s/g, "").toLowerCase();
-};
-// Normalize passed key combinations to turn them into a consistent ids
-const getHotkeyId = (hotkey) => {
-    return formatHotkey(hotkey).split(COMBINATION_DELIMETER).sort().join(COMBINATION_DELIMETER);
-};
-const getEventKey = (e) => {
-    if (!e.key)
-        return;
-    // Having alt pressed modifies e.key value, so relying on e.code for it
-    if (e.altKey && /^[Key|Digit|Numpad]/.test(e.code)) {
-        return e.code.toLowerCase().replace(/key|digit|numpad/, "");
-    }
-    return e.key.toLowerCase();
-};
-// Removing the unknown gets highlighted an invalid syntax
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
-const walkHotkeys = (hotkeys, cb) => {
-    Object.keys(hotkeys).forEach((key) => {
-        key.split(",").forEach((hotkey) => {
-            const data = hotkeys[key];
-            if (!data)
-                return;
-            cb(getHotkeyId(hotkey), data);
-        });
-    });
-};
-export class HotkeyStore {
-    hotkeyMap = {};
-    getSize = () => Object.keys(this.hotkeyMap).length;
-    bindHotkeys = (hotkeys, ref, options) => {
-        walkHotkeys(hotkeys, (id, hotkeyData) => {
-            if (!hotkeyData)
-                return;
-            if (!this.hotkeyMap[id]) {
-                this.hotkeyMap[id] = new Set();
-            }
-            this.hotkeyMap[id].add({ callback: hotkeyData, ref, options });
-        });
-    };
-    unbindHotkeys = (hotkeys) => {
-        walkHotkeys(hotkeys, (id, hotkeyCallback) => {
-            if (!hotkeyCallback)
-                return;
-            this.hotkeyMap[id]?.forEach((data) => {
-                if (data.callback === hotkeyCallback) {
-                    this.hotkeyMap[id].delete(data);
-                }
-            });
-            if (!this.hotkeyMap[id]?.size) {
-                delete this.hotkeyMap[id];
-            }
-        });
-    };
-    handleKeyDown = (pressedMap, e) => {
-        if (!pressedMap.size)
-            return;
-        const pressedKeys = [...pressedMap.keys()];
-        const pressedId = getHotkeyId(pressedKeys.join(COMBINATION_DELIMETER));
-        const pressedFormattedKeys = pressedId.split(COMBINATION_DELIMETER);
-        const hotkeyData = this.hotkeyMap[pressedId];
-        /**
-         * Support for `mod` that represents both Mac and Win keyboards
-         * We create the hotkeyId again to sort the mod key correctly
-         */
-        const controlToModPressedId = getHotkeyId(pressedId.replace("control", "mod"));
-        const metaToModPressedId = getHotkeyId(pressedId.replace("meta", "mod"));
-        const hotkeyControlModData = pressedFormattedKeys.includes("control") && this.hotkeyMap[controlToModPressedId];
-        const hotkeyMetaModData = pressedFormattedKeys.includes("meta") && this.hotkeyMap[metaToModPressedId];
-        [hotkeyData, hotkeyControlModData, hotkeyMetaModData].forEach((hotkeyData) => {
-            if (!hotkeyData)
-                return;
-            if (hotkeyData?.size) {
-                hotkeyData.forEach((data) => {
-                    const eventTarget = e.composedPath()[0];
-                    if (data.ref.current &&
-                        !(eventTarget === data.ref.current || data.ref.current.contains(eventTarget))) {
-                        return;
-                    }
-                    const resolvedEvent = pressedMap.get(pressedId);
-                    if (data.options.preventDefault) {
-                        resolvedEvent?.preventDefault();
-                        e.preventDefault();
-                    }
-                    data.callback(e);
-                });
-            }
-        });
-    };
-}
-const globalHotkeyStore = new HotkeyStore();
-/**
- * Components / Hooks
- */
-export const HotkeyContext = React.createContext({});
-export const SingletonHotkeysProvider = (props) => {
-    const { children } = props;
-    // eslint-disable-next-line
-    const [_, setTriggerCount] = React.useState(0);
-    // Only handle key presses when there is at least one hook listening for hotkeys
-    const [hooksCount, setHooksCount] = React.useState(0);
-    const addPressedKey = React.useCallback((e) => {
-        if (e.repeat || hooksCount === 0)
-            return;
-        const eventKey = getEventKey(e);
-        if (!eventKey)
-            return;
-        pressedMap.set(eventKey, e);
-        setTriggerCount(pressedMap.size);
-        // Key up won't trigger for other keys while Meta is pressed so we need to cache them
-        // and remove on Meta keyup
-        if (e.metaKey)
-            modifiedKeys.push(...pressedMap.keys());
-        if (pressedMap.has("Meta"))
-            modifiedKeys.push(eventKey);
-    }, [hooksCount]);
-    const removePressedKey = React.useCallback((e) => {
-        if (hooksCount === 0)
-            return;
-        const eventKey = getEventKey(e);
-        if (!eventKey)
-            return;
-        pressedMap.delete(eventKey);
-        if (eventKey === "meta" || eventKey === "control") {
-            pressedMap.delete("mod");
-        }
-        if (eventKey === "meta") {
-            modifiedKeys.forEach((key) => {
-                if (!pressedMap.has(key))
-                    return;
-                pressedMap.delete(key);
-            });
-            modifiedKeys = [];
-        }
-        setTriggerCount(pressedMap.size);
-    }, [hooksCount]);
-    const isPressed = (hotkey) => {
-        const keys = formatHotkey(hotkey).split(COMBINATION_DELIMETER);
-        if (keys.some((key) => !pressedMap.has(key)))
-            return false;
-        return true;
-    };
-    const handleWindowKeyDown = React.useCallback((e) => {
-        // Browsers trigger keyboard event without passing e.key when you click on autocomplete
-        if (!e.key)
-            return;
-        addPressedKey(e);
-        globalHotkeyStore.handleKeyDown(pressedMap, e);
-    }, [addPressedKey]);
-    const handleWindowKeyUp = React.useCallback((e) => {
-        if (!e.key)
-            return;
-        removePressedKey(e);
-    }, [removePressedKey]);
-    const handleWindowBlur = React.useCallback(() => {
-        pressedMap.clear();
-        modifiedKeys = [];
-    }, []);
-    const addHotkeys = React.useCallback((hotkeys, ref, options = {}) => {
-        setHooksCount((prev) => prev + 1);
-        globalHotkeyStore.bindHotkeys(hotkeys, ref, options);
-        return () => {
-            setHooksCount((prev) => prev - 1);
-            globalHotkeyStore.unbindHotkeys(hotkeys);
-        };
-    }, []);
-    React.useEffect(() => {
-        window.addEventListener("keydown", handleWindowKeyDown);
-        window.addEventListener("keyup", handleWindowKeyUp);
-        window.addEventListener("blur", handleWindowBlur);
-        return () => {
-            window.removeEventListener("keydown", handleWindowKeyDown);
-            window.removeEventListener("keyup", handleWindowKeyUp);
-            window.removeEventListener("blur", handleWindowBlur);
-        };
-    }, [handleWindowKeyDown, handleWindowKeyUp, handleWindowBlur]);
-    return (_jsx(HotkeyContext.Provider, { value: { addHotkeys, isPressed }, children: children }));
-};
-const useSingletonHotkeys = () => React.useContext(HotkeyContext);
-export default useSingletonHotkeys;

package/dist/hooks/_private/useSingletonKeyboardMode.d.ts

@@ -1,13 +0,0 @@
-import React from "react";
-type ContextProps = {
-    disabledRef: React.RefObject<boolean> | null;
-    disable: () => void;
-    enable: () => void;
-    activate: () => void;
-    deactivate: () => void;
-};
-export declare const SingletonKeyboardModeContext: React.Context<ContextProps>;
-export declare const SingletonKeyboardModeProvider: React.FC<{
-    children: React.ReactNode;
-}>;
-export {};

package/dist/hooks/_private/useSingletonKeyboardMode.js

@@ -1,58 +0,0 @@
-"use client";
-import { jsx as _jsx } from "react/jsx-runtime";
-import { activateKeyboardMode, deactivateKeyboardMode } from "@reshaped/utilities/internal";
-import React from "react";
-import * as keys from "../../constants/keys.js";
-export const SingletonKeyboardModeContext = React.createContext({
-    disabledRef: null,
-    disable: () => { },
-    enable: () => { },
-    activate: () => { },
-    deactivate: () => { },
-});
-export const SingletonKeyboardModeProvider = (props) => {
-    const disabledRef = React.useRef(false);
-    const disable = React.useCallback(() => {
-        disabledRef.current = true;
-    }, []);
-    const enable = React.useCallback(() => {
-        disabledRef.current = false;
-    }, []);
-    const activate = React.useCallback(() => {
-        if (disabledRef.current)
-            return;
-        activateKeyboardMode();
-    }, []);
-    const deactivate = React.useCallback(() => {
-        if (disabledRef.current)
-            return;
-        deactivateKeyboardMode();
-    }, []);
-    const handleKeyDown = React.useCallback((e) => {
-        if (e.metaKey || e.altKey || e.ctrlKey)
-            return;
-        // Prevent focus ring from appearing when using mouse but closing with esc
-        if (e.key === keys.ESC)
-            return;
-        activate();
-    }, [activate]);
-    const handleClick = React.useCallback(() => {
-        deactivate();
-    }, [deactivate]);
-    React.useEffect(() => {
-        window.addEventListener("keydown", handleKeyDown);
-        window.addEventListener("mousedown", handleClick);
-        return () => {
-            window.removeEventListener("keydown", handleKeyDown);
-            window.removeEventListener("mousedown", handleClick);
-        };
-    }, [handleClick, handleKeyDown]);
-    const value = React.useMemo(() => ({
-        disabledRef,
-        disable,
-        enable,
-        activate,
-        deactivate,
-    }), [disable, enable, activate, deactivate]);
-    return (_jsx(SingletonKeyboardModeContext.Provider, { value: value, children: props.children }));
-};

package/dist/hooks/useHandlerRef.d.ts

@@ -1,8 +0,0 @@
-import React from "react";
-/**
- * Hook for wrapping event handlers passed as props with a ref
- * This way we can keep the instance of the ref the same and pass this ref to the effects dependency array
- * While also making sure that function implementation stays up-to-date
- */
-declare const useHandlerRef: <T>(cb: T) => React.RefObject<T>;
-export default useHandlerRef;

package/dist/hooks/useHandlerRef.js

@@ -1,16 +0,0 @@
-import React from "react";
-import useIsomorphicLayoutEffect from "./useIsomorphicLayoutEffect.js";
-/**
- * Hook for wrapping event handlers passed as props with a ref
- * This way we can keep the instance of the ref the same and pass this ref to the effects dependency array
- * While also making sure that function implementation stays up-to-date
- */
-const useHandlerRef = (cb) => {
-    const ref = React.useRef(cb);
-    // Update the callback on every render, keeping the ref instance the same
-    useIsomorphicLayoutEffect(() => {
-        ref.current = cb;
-    }, [cb]);
-    return ref;
-};
-export default useHandlerRef;

package/dist/hooks/useHotkeys.d.ts

@@ -1,11 +0,0 @@
-import React from "react";
-import { type Hotkeys } from "./_private/useSingletonHotkeys";
-declare const useHotkeys: <Element extends HTMLElement>(hotkeys: Hotkeys, deps?: unknown[], options?: {
-    ref?: React.RefObject<Element | null>;
-    disabled?: boolean;
-    preventDefault?: boolean;
-}) => {
-    ref: React.RefObject<Element | null>;
-    checkHotkeyState: (key: string) => boolean;
-};
-export default useHotkeys;

package/dist/hooks/useHotkeys.js

@@ -1,27 +0,0 @@
-"use client";
-import React from "react";
-import useSingletonHotkey from "./_private/useSingletonHotkeys.js";
-const useHotkeys = (hotkeys, deps = [], options) => {
-    const { addHotkeys, isPressed } = useSingletonHotkey();
-    const generatedRef = React.useRef(null);
-    const elementRef = options?.ref || generatedRef;
-    React.useEffect(() => {
-        if (options?.disabled)
-            return;
-        const remove = addHotkeys(hotkeys, elementRef, {
-            preventDefault: options?.preventDefault,
-        });
-        return () => remove?.();
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [
-        addHotkeys,
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        Object.keys(hotkeys).join(","),
-        options?.disabled,
-        options?.preventDefault,
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        ...deps,
-    ]);
-    return { ref: elementRef, checkHotkeyState: isPressed };
-};
-export default useHotkeys;

package/dist/hooks/useIsomorphicLayoutEffect.d.ts

@@ -1,3 +0,0 @@
-import React from "react";
-declare const useIsomorphicLayoutEffect: typeof React.useEffect;
-export default useIsomorphicLayoutEffect;

package/dist/hooks/useIsomorphicLayoutEffect.js

@@ -1,4 +0,0 @@
-"use client";
-import React from "react";
-const useIsomorphicLayoutEffect = typeof window !== "undefined" ? React.useLayoutEffect : React.useEffect;
-export default useIsomorphicLayoutEffect;

package/dist/hooks/useKeyboardArrowNavigation.d.ts

@@ -1,9 +0,0 @@
-import React from "react";
-type Props = {
-    ref: React.RefObject<HTMLElement | null>;
-    disabled?: boolean;
-    orientation?: "vertical" | "horizontal";
-    circular?: boolean;
-};
-declare const useKeyboardArrowNavigation: (props: Props) => void;
-export default useKeyboardArrowNavigation;

package/dist/hooks/useKeyboardArrowNavigation.js

@@ -1,62 +0,0 @@
-import { focusFirstElement, focusLastElement, focusNextElement, focusPreviousElement, getFocusableElements, } from "@reshaped/utilities/internal";
-import React, { useEffect } from "react";
-import useHotkeys from "./useHotkeys.js";
-const useKeyboardArrowNavigation = (props) => {
-    const { ref, disabled, orientation, circular } = props;
-    const backHotkeys = [];
-    const forwardHotkeys = [];
-    if (!orientation || orientation === "vertical") {
-        backHotkeys.push("ArrowUp");
-        forwardHotkeys.push("ArrowDown");
-    }
-    if (!orientation || orientation === "horizontal") {
-        backHotkeys.push("ArrowLeft");
-        forwardHotkeys.push("ArrowRight");
-    }
-    const updateTabIndex = React.useCallback((options) => {
-        const { el, focusableElements } = options;
-        const initialEl = focusableElements.find((el) => el.getAttribute("tabindex") !== "-1");
-        const activeEl = el ?? initialEl ?? focusableElements[0];
-        focusableElements.forEach((el) => el.setAttribute("tabindex", "-1"));
-        activeEl?.setAttribute("tabindex", "0");
-    }, []);
-    useEffect(() => {
-        if (!ref.current)
-            return;
-        if (disabled)
-            return;
-        const focusableElements = getFocusableElements(ref.current);
-        updateTabIndex({ focusableElements });
-    }, [ref, updateTabIndex, disabled]);
-    useHotkeys({
-        [backHotkeys.join(", ")]: () => {
-            if (!ref.current)
-                return;
-            const data = focusPreviousElement(ref.current, { circular });
-            updateTabIndex(data);
-        },
-        [forwardHotkeys.join(", ")]: () => {
-            if (!ref.current)
-                return;
-            const data = focusNextElement(ref.current, { circular });
-            updateTabIndex(data);
-        },
-        Home: () => {
-            if (!ref.current)
-                return;
-            const data = focusFirstElement(ref.current);
-            updateTabIndex(data);
-        },
-        End: () => {
-            if (!ref.current)
-                return;
-            const data = focusLastElement(ref.current);
-            updateTabIndex(data);
-        },
-    }, [updateTabIndex, circular], {
-        ref,
-        preventDefault: true,
-        disabled,
-    });
-};
-export default useKeyboardArrowNavigation;

package/dist/hooks/useKeyboardMode.d.ts

@@ -1,7 +0,0 @@
-declare const useKeyboardMode: () => {
-    enable: () => void;
-    disable: () => void;
-    activate: () => void;
-    deactivate: () => void;
-};
-export default useKeyboardMode;

package/dist/hooks/useKeyboardMode.js

@@ -1,13 +0,0 @@
-"use client";
-import React from "react";
-import { SingletonKeyboardModeContext } from "./_private/useSingletonKeyboardMode.js";
-const useKeyboardMode = () => {
-    const singletonKeyboardMode = React.useContext(SingletonKeyboardModeContext);
-    return React.useMemo(() => ({
-        enable: singletonKeyboardMode.enable,
-        disable: singletonKeyboardMode.disable,
-        activate: singletonKeyboardMode.activate,
-        deactivate: singletonKeyboardMode.deactivate,
-    }), [singletonKeyboardMode]);
-};
-export default useKeyboardMode;

package/dist/hooks/useOnClickOutside.d.ts

@@ -1,5 +0,0 @@
-import React from "react";
-declare const useOnClickOutside: (refs: React.RefObject<HTMLElement | null>[], handler: (event: Event) => void, options?: {
-    disabled?: boolean;
-}) => void;
-export default useOnClickOutside;