@vibe/core 4.0.0-alpha.1 → 4.0.0-alpha.2

package/dist/hooks/useActiveDescendantListFocus/useActiveDescendantListFocusHooks.d.ts

@@ -1,44 +1,44 @@
-import { type MutableRefObject } from "react";
-import type React from "react";
-import { type UseKeyEventArgs } from "../useKeyEvent";
-export declare function useSupportArrowsKeyboardNavigation({ itemsCount, focusedElementRef, visualFocusItemIndex, setVisualFocusItemIndex, isHorizontalList, isItemSelectable, listenerOptions, triggeredByKeyboard }: {
-    itemsCount: number;
-    focusedElementRef: MutableRefObject<HTMLElement>;
-    visualFocusItemIndex: number;
-    setVisualFocusItemIndex: (index: number) => void;
-    isHorizontalList: boolean;
-    isItemSelectable: (index: number) => boolean;
-    triggeredByKeyboard: MutableRefObject<boolean>;
-    listenerOptions: Omit<UseKeyEventArgs, "keys" | "callback">;
-}): void;
-export declare function useSupportPressItemKeyboardNavigation({ visualFocusItemIndex, focusedElementRef, itemsCount, setVisualFocusItemIndex, onItemClick, isItemSelectable, listenerOptions, isIgnoreSpaceAsItemSelection }: {
-    visualFocusItemIndex: number;
-    focusedElementRef: MutableRefObject<HTMLElement>;
-    itemsCount: number;
-    setVisualFocusItemIndex: (index: number) => void;
-    onItemClick: (event: React.MouseEvent | React.KeyboardEvent, index: number) => void;
-    isItemSelectable: (index: number) => boolean;
-    listenerOptions: Omit<UseKeyEventArgs, "keys" | "callback">;
-    isIgnoreSpaceAsItemSelection: boolean;
-}): void;
-export declare function useCleanVisualFocusOnBlur({ focusedElementRef, visualFocusItemIndex, setVisualFocusItemIndex }: {
-    focusedElementRef: MutableRefObject<HTMLElement>;
-    visualFocusItemIndex: number;
-    setVisualFocusItemIndex: (index: number) => void;
-}): void;
-export declare function useSetDefaultItemOnFocusEvent({ focusedElementRef, isItemSelectable, visualFocusItemIndex, setVisualFocusItemIndex, itemsCount, defaultVisualFocusItemIndex }: {
-    focusedElementRef: MutableRefObject<HTMLElement>;
-    isItemSelectable: (index: number) => boolean;
-    visualFocusItemIndex: number;
-    setVisualFocusItemIndex: (index: number) => void;
-    itemsCount: number;
-    defaultVisualFocusItemIndex: number;
-}): {
-    triggeredByKeyboard: MutableRefObject<boolean>;
-};
-export declare function useKeepFocusOnItemWhenListChanged({ visualFocusItemIndex, itemsIds, isItemSelectable, setVisualFocusItemIndex }: {
-    visualFocusItemIndex: number;
-    itemsIds: string[];
-    isItemSelectable: (index: number) => boolean;
-    setVisualFocusItemIndex: (index: number) => void;
-}): void;
+import { type MutableRefObject } from "react";
+import type React from "react";
+import { type UseKeyEventArgs } from "../useKeyEvent";
+export declare function useSupportArrowsKeyboardNavigation({ itemsCount, focusedElementRef, visualFocusItemIndex, setVisualFocusItemIndex, isHorizontalList, isItemSelectable, listenerOptions, triggeredByKeyboard }: {
+    itemsCount: number;
+    focusedElementRef: MutableRefObject<HTMLElement>;
+    visualFocusItemIndex: number;
+    setVisualFocusItemIndex: (index: number) => void;
+    isHorizontalList: boolean;
+    isItemSelectable: (index: number) => boolean;
+    triggeredByKeyboard: MutableRefObject<boolean>;
+    listenerOptions: Omit<UseKeyEventArgs, "keys" | "callback">;
+}): void;
+export declare function useSupportPressItemKeyboardNavigation({ visualFocusItemIndex, focusedElementRef, itemsCount, setVisualFocusItemIndex, onItemClick, isItemSelectable, listenerOptions, isIgnoreSpaceAsItemSelection }: {
+    visualFocusItemIndex: number;
+    focusedElementRef: MutableRefObject<HTMLElement>;
+    itemsCount: number;
+    setVisualFocusItemIndex: (index: number) => void;
+    onItemClick: (event: React.MouseEvent | React.KeyboardEvent, index: number) => void;
+    isItemSelectable: (index: number) => boolean;
+    listenerOptions: Omit<UseKeyEventArgs, "keys" | "callback">;
+    isIgnoreSpaceAsItemSelection: boolean;
+}): void;
+export declare function useCleanVisualFocusOnBlur({ focusedElementRef, visualFocusItemIndex, setVisualFocusItemIndex }: {
+    focusedElementRef: MutableRefObject<HTMLElement>;
+    visualFocusItemIndex: number;
+    setVisualFocusItemIndex: (index: number) => void;
+}): void;
+export declare function useSetDefaultItemOnFocusEvent({ focusedElementRef, isItemSelectable, visualFocusItemIndex, setVisualFocusItemIndex, itemsCount, defaultVisualFocusItemIndex }: {
+    focusedElementRef: MutableRefObject<HTMLElement>;
+    isItemSelectable: (index: number) => boolean;
+    visualFocusItemIndex: number;
+    setVisualFocusItemIndex: (index: number) => void;
+    itemsCount: number;
+    defaultVisualFocusItemIndex: number;
+}): {
+    triggeredByKeyboard: MutableRefObject<boolean>;
+};
+export declare function useKeepFocusOnItemWhenListChanged({ visualFocusItemIndex, itemsIds, isItemSelectable, setVisualFocusItemIndex }: {
+    visualFocusItemIndex: number;
+    itemsIds: string[];
+    isItemSelectable: (index: number) => boolean;
+    setVisualFocusItemIndex: (index: number) => void;
+}): void;

package/dist/hooks/useAfterFirstRender/index.d.ts

@@ -1,2 +1,2 @@
-import { type RefObject } from "react";
-export default function useAfterFirstRender(): RefObject<boolean>;
+import { type RefObject } from "react";
+export default function useAfterFirstRender(): RefObject<boolean>;

package/dist/hooks/useDebounceEvent/index.d.ts

@@ -1,18 +1,18 @@
-import { type ChangeEvent, type Dispatch, type SetStateAction } from "react";
-export type UseDebounceResult = {
-    inputValue: string;
-    onEventChanged: (event: ChangeEvent<Partial<HTMLInputElement> | Partial<HTMLTextAreaElement>>) => void;
-    clearValue: () => void;
-    updateValue: Dispatch<SetStateAction<string>>;
-};
-export default function useDebounceEvent({ delay, onChange, initialStateValue, trim }: {
-    onChange: (value: string) => void;
-    initialStateValue?: string;
-    delay?: number;
-    trim?: boolean;
-}): {
-    inputValue: string;
-    onEventChanged: (event: ChangeEvent<Partial<HTMLInputElement> | Partial<HTMLTextAreaElement>>) => void;
-    clearValue: () => void;
-    updateValue: Dispatch<SetStateAction<string>>;
-};
+import { type ChangeEvent, type Dispatch, type SetStateAction } from "react";
+export type UseDebounceResult = {
+    inputValue: string;
+    onEventChanged: (event: ChangeEvent<Partial<HTMLInputElement> | Partial<HTMLTextAreaElement>>) => void;
+    clearValue: () => void;
+    updateValue: Dispatch<SetStateAction<string>>;
+};
+export default function useDebounceEvent({ delay, onChange, initialStateValue, trim }: {
+    onChange: (value: string) => void;
+    initialStateValue?: string;
+    delay?: number;
+    trim?: boolean;
+}): {
+    inputValue: string;
+    onEventChanged: (event: ChangeEvent<Partial<HTMLInputElement> | Partial<HTMLTextAreaElement>>) => void;
+    clearValue: () => void;
+    updateValue: Dispatch<SetStateAction<string>>;
+};

package/dist/hooks/useElementsOverflowingIndex.d.ts

@@ -1,9 +1,9 @@
-import { type ReactNode, type RefObject } from "react";
-declare function useElementsOverflowingIndex({ ref, children, paddingSize, resizeDebounceTime, ignoreLast }: {
-    ref: RefObject<HTMLElement>;
-    children: ReactNode;
-    paddingSize: number;
-    resizeDebounceTime: number;
-    ignoreLast: boolean;
-}): number;
-export default useElementsOverflowingIndex;
+import { type ReactNode, type RefObject } from "react";
+declare function useElementsOverflowingIndex({ ref, children, paddingSize, resizeDebounceTime, ignoreLast }: {
+    ref: RefObject<HTMLElement>;
+    children: ReactNode;
+    paddingSize: number;
+    resizeDebounceTime: number;
+    ignoreLast: boolean;
+}): number;
+export default useElementsOverflowingIndex;

package/dist/hooks/useEventListener/index.d.ts

@@ -1,8 +1,8 @@
-import { type RefObject } from "react";
-import { type GenericEventCallback } from "../../types/events";
-export default function useEventListener({ eventName, callback, ref, capture }: {
-    eventName: keyof HTMLElementEventMap | string;
-    callback: GenericEventCallback;
-    ref: RefObject<HTMLElement | Document>;
-    capture?: boolean;
-}): void;
+import { type RefObject } from "react";
+import { type GenericEventCallback } from "../../types/events";
+export default function useEventListener({ eventName, callback, ref, capture }: {
+    eventName: keyof HTMLElementEventMap | string;
+    callback: GenericEventCallback;
+    ref: RefObject<HTMLElement | Document>;
+    capture?: boolean;
+}): void;

package/dist/hooks/useFocusWithin.d.ts

@@ -1,14 +1,14 @@
-import { type FocusEvent } from "react";
-type Result = {
-    focusWithinProps?: {
-        onFocus?: (e: FocusEvent) => void;
-        onBlur?: (e: FocusEvent) => void;
-    };
-};
-export declare function useFocusWithin({ onFocusWithin, onFocusWithinChange, isDisabled, onBlurWithin }: {
-    onFocusWithin?: (event: FocusEvent) => void;
-    onBlurWithin?: (event: FocusEvent) => void;
-    onFocusWithinChange?: (isWithinChange: boolean) => void;
-    isDisabled?: boolean;
-}): Result;
-export {};
+import { type FocusEvent } from "react";
+type Result = {
+    focusWithinProps?: {
+        onFocus?: (e: FocusEvent) => void;
+        onBlur?: (e: FocusEvent) => void;
+    };
+};
+export declare function useFocusWithin({ onFocusWithin, onFocusWithinChange, isDisabled, onBlurWithin }: {
+    onFocusWithin?: (event: FocusEvent) => void;
+    onBlurWithin?: (event: FocusEvent) => void;
+    onFocusWithinChange?: (isWithinChange: boolean) => void;
+    isDisabled?: boolean;
+}): Result;
+export {};

package/dist/hooks/useFullKeyboardListeners.d.ts

@@ -1,28 +1,28 @@
-import { type MutableRefObject } from "react";
-import { type KeyboardEventCallback } from "../types/events";
-export declare enum NavDirections {
-    UP = "up",
-    DOWN = "down",
-    LEFT = "left",
-    RIGHT = "right"
-}
-export declare const ARROW_DOWN_KEYS: string[];
-export declare const ARROW_UP_KEYS: string[];
-export declare const ARROW_RIGHT_KEYS: string[];
-export declare const ARROW_LEFT_KEYS: string[];
-export declare const SELECTION_KEYS: string[];
-export declare const ENTER_KEYS: string[];
-export declare const ESCAPE_KEYS: string[];
-export declare const END_KEYS: string[];
-export declare const HOME_KEYS: string[];
-export default function useFullKeyboardListeners({ ref, // the reference for the component that listens to keyboard
-onSelectionKey, onArrowNavigation, onEscape, onHome, onEnd, useDocumentEventListeners, focusOnMount }: {
-    ref: MutableRefObject<HTMLElement>;
-    onSelectionKey: KeyboardEventCallback;
-    onArrowNavigation: (type: NavDirections) => void;
-    onEscape: KeyboardEventCallback;
-    onHome?: KeyboardEventCallback;
-    onEnd?: KeyboardEventCallback;
-    useDocumentEventListeners?: boolean;
-    focusOnMount: boolean;
-}): void;
+import { type MutableRefObject } from "react";
+import { type KeyboardEventCallback } from "../types/events";
+export declare enum NavDirections {
+    UP = "up",
+    DOWN = "down",
+    LEFT = "left",
+    RIGHT = "right"
+}
+export declare const ARROW_DOWN_KEYS: string[];
+export declare const ARROW_UP_KEYS: string[];
+export declare const ARROW_RIGHT_KEYS: string[];
+export declare const ARROW_LEFT_KEYS: string[];
+export declare const SELECTION_KEYS: string[];
+export declare const ENTER_KEYS: string[];
+export declare const ESCAPE_KEYS: string[];
+export declare const END_KEYS: string[];
+export declare const HOME_KEYS: string[];
+export default function useFullKeyboardListeners({ ref, // the reference for the component that listens to keyboard
+onSelectionKey, onArrowNavigation, onEscape, onHome, onEnd, useDocumentEventListeners, focusOnMount }: {
+    ref: MutableRefObject<HTMLElement>;
+    onSelectionKey: KeyboardEventCallback;
+    onArrowNavigation: (type: NavDirections) => void;
+    onEscape: KeyboardEventCallback;
+    onHome?: KeyboardEventCallback;
+    onEnd?: KeyboardEventCallback;
+    useDocumentEventListeners?: boolean;
+    focusOnMount: boolean;
+}): void;

package/dist/hooks/useGridKeyboardNavigation/gridKeyboardNavigationHelper.d.ts

@@ -1,20 +1,20 @@
-import { NavDirections } from "../useFullKeyboardListeners";
-export declare function getActiveIndexFromInboundNavigation({ direction, numberOfItemsInLine, itemsCount }: {
-    direction: NavDirections;
-    numberOfItemsInLine: number;
-    itemsCount: number;
-}): number;
-export declare function calcActiveIndexAfterArrowNavigation({ activeIndex, itemsCount, numberOfItemsInLine, direction, disabledIndexes, circularNavigation }: {
-    activeIndex: number;
-    itemsCount: number;
-    numberOfItemsInLine: number;
-    direction: NavDirections;
-    disabledIndexes?: number[];
-    circularNavigation?: boolean;
-}): {
-    isOutbound: boolean;
-    nextIndex?: undefined;
-} | {
-    isOutbound: boolean;
-    nextIndex: number;
-};
+import { NavDirections } from "../useFullKeyboardListeners";
+export declare function getActiveIndexFromInboundNavigation({ direction, numberOfItemsInLine, itemsCount }: {
+    direction: NavDirections;
+    numberOfItemsInLine: number;
+    itemsCount: number;
+}): number;
+export declare function calcActiveIndexAfterArrowNavigation({ activeIndex, itemsCount, numberOfItemsInLine, direction, disabledIndexes, circularNavigation }: {
+    activeIndex: number;
+    itemsCount: number;
+    numberOfItemsInLine: number;
+    direction: NavDirections;
+    disabledIndexes?: number[];
+    circularNavigation?: boolean;
+}): {
+    isOutbound: boolean;
+    nextIndex?: undefined;
+} | {
+    isOutbound: boolean;
+    nextIndex: number;
+};

package/dist/hooks/useGridKeyboardNavigation/useGridKeyboardNavigation.d.ts

@@ -1,42 +1,42 @@
-import { type MutableRefObject, type ReactElement } from "react";
-/**
- * A hook which is used for accessible keyboard navigation. Useful for components rendering a list of items that can be navigated and selected with a keyboard.
- * @param {Object} options
- * @param {React.MutableRefObject} options.ref - the reference for the component that listens to keyboard
- * @param {number} options.itemsCount - the number of items
- * @param {number} options.numberOfItemsInLine - the number of items on each line of the grid
- * @param {function} options.onItemClicked - the callback for selecting an item. It will be called when an active item is selected, for example with "Enter".
- * @param {function} options.getItemByIndex - a function which gets an index as a param, and returns the item on that index
- * @param {"directional" | "first"} options.entryFocusStrategy - Determines how the first item is focused when entering the grid via keyboard.
- *   - "directional": Tries to focus based on the entry direction (Tab vs Shift+Tab). This is the default.
- *   - "first": Always focuses the first item.
- * @param {boolean=} options.focusOnMount - if true, the referenced element will be focused when mounted
- * @param {number=} options.focusItemIndexOnMount - optional item index to focus when mounted. Only works with "options.focusOnMount".
- * @param {number[]=} options.disabledIndexes - optional array of disabled indices, which will be skipped while navigating.
- * @param {boolean=} options.circularNavigation - if true, the navigation will wrap around the grid
- * @returns {useGridKeyboardNavigationResult}
- *
- * @typedef useGridKeyboardNavigationResult
- * @property {number} activeIndex - the currently active index
- * @property {boolean} isInitialActiveState - if true, the currently active element was due to an initial mounting index option. See "options.focusItemIndexOnMount".
- * @property {(index: number, isKeyboardAction?: boolean) => void} onSelectionAction - the callback which should be used to select an item.
- * It should be called with the selected item's index. Use this callback for onClick handlers, for example.
- * The "isKeyboardAction" can be used to indicate a keyboard selection, which will affect the currently active index.
- */
-export default function useGridKeyboardNavigation({ ref, itemsCount, numberOfItemsInLine, onItemClicked, // the callback to call when an item is selected
-entryFocusStrategy, getItemByIndex, focusOnMount, focusItemIndexOnMount, disabledIndexes, circularNavigation }: {
-    ref: MutableRefObject<HTMLElement>;
-    itemsCount: number;
-    numberOfItemsInLine: number;
-    onItemClicked: (element: HTMLElement | ReactElement | void | string, index: number) => void;
-    entryFocusStrategy?: "directional" | "first";
-    getItemByIndex: (index: number | void) => HTMLElement | ReactElement | void | string;
-    focusOnMount?: boolean;
-    focusItemIndexOnMount?: number;
-    disabledIndexes?: number[];
-    circularNavigation?: boolean;
-}): {
-    activeIndex: number;
-    onSelectionAction: (index: number, isKeyboardAction?: boolean) => void;
-    isInitialActiveState: boolean;
-};
+import { type MutableRefObject, type ReactElement } from "react";
+/**
+ * A hook which is used for accessible keyboard navigation. Useful for components rendering a list of items that can be navigated and selected with a keyboard.
+ * @param {Object} options
+ * @param {React.MutableRefObject} options.ref - the reference for the component that listens to keyboard
+ * @param {number} options.itemsCount - the number of items
+ * @param {number} options.numberOfItemsInLine - the number of items on each line of the grid
+ * @param {function} options.onItemClicked - the callback for selecting an item. It will be called when an active item is selected, for example with "Enter".
+ * @param {function} options.getItemByIndex - a function which gets an index as a param, and returns the item on that index
+ * @param {"directional" | "first"} options.entryFocusStrategy - Determines how the first item is focused when entering the grid via keyboard.
+ *   - "directional": Tries to focus based on the entry direction (Tab vs Shift+Tab). This is the default.
+ *   - "first": Always focuses the first item.
+ * @param {boolean=} options.focusOnMount - if true, the referenced element will be focused when mounted
+ * @param {number=} options.focusItemIndexOnMount - optional item index to focus when mounted. Only works with "options.focusOnMount".
+ * @param {number[]=} options.disabledIndexes - optional array of disabled indices, which will be skipped while navigating.
+ * @param {boolean=} options.circularNavigation - if true, the navigation will wrap around the grid
+ * @returns {useGridKeyboardNavigationResult}
+ *
+ * @typedef useGridKeyboardNavigationResult
+ * @property {number} activeIndex - the currently active index
+ * @property {boolean} isInitialActiveState - if true, the currently active element was due to an initial mounting index option. See "options.focusItemIndexOnMount".
+ * @property {(index: number, isKeyboardAction?: boolean) => void} onSelectionAction - the callback which should be used to select an item.
+ * It should be called with the selected item's index. Use this callback for onClick handlers, for example.
+ * The "isKeyboardAction" can be used to indicate a keyboard selection, which will affect the currently active index.
+ */
+export default function useGridKeyboardNavigation({ ref, itemsCount, numberOfItemsInLine, onItemClicked, // the callback to call when an item is selected
+entryFocusStrategy, getItemByIndex, focusOnMount, focusItemIndexOnMount, disabledIndexes, circularNavigation }: {
+    ref: MutableRefObject<HTMLElement>;
+    itemsCount: number;
+    numberOfItemsInLine: number;
+    onItemClicked: (element: HTMLElement | ReactElement | void | string, index: number) => void;
+    entryFocusStrategy?: "directional" | "first";
+    getItemByIndex: (index: number | void) => HTMLElement | ReactElement | void | string;
+    focusOnMount?: boolean;
+    focusItemIndexOnMount?: number;
+    disabledIndexes?: number[];
+    circularNavigation?: boolean;
+}): {
+    activeIndex: number;
+    onSelectionAction: (index: number, isKeyboardAction?: boolean) => void;
+    isInitialActiveState: boolean;
+};

package/dist/hooks/useHover/useHover.d.ts

@@ -1,2 +1,2 @@
-import { type MutableRefObject } from "react";
-export default function useHover<T extends HTMLElement = HTMLElement>(): [MutableRefObject<T>, boolean];
+import { type MutableRefObject } from "react";
+export default function useHover<T extends HTMLElement = HTMLElement>(): [MutableRefObject<T>, boolean];

package/dist/hooks/useIsMouseEnter.d.ts

@@ -1,4 +1,4 @@
-import { type RefObject } from "react";
-export default function useIsMouseEnter({ ref }: {
-    ref: RefObject<HTMLElement>;
-}): boolean;
+import { type RefObject } from "react";
+export default function useIsMouseEnter({ ref }: {
+    ref: RefObject<HTMLElement>;
+}): boolean;

package/dist/hooks/useIsMouseOver.d.ts

@@ -1,4 +1,4 @@
-import { type RefObject } from "react";
-export default function useIsMouseOver({ ref }: {
-    ref: RefObject<HTMLElement>;
-}): boolean;
+import { type RefObject } from "react";
+export default function useIsMouseOver({ ref }: {
+    ref: RefObject<HTMLElement>;
+}): boolean;

package/dist/hooks/useItemsOverflow/useItemsOverflow.d.ts

@@ -1,15 +1,15 @@
-import { type RefObject } from "react";
-/**
- * Custom hook that calculates how many items can fit in a container without overflowing
- */
-export default function useItemsOverflow({ containerRef, gap, deductedSpaceRef, deductedWidth, itemRefs, minVisibleCount }: {
-    containerRef: RefObject<HTMLElement>;
-    gap: number;
-    deductedSpaceRef?: RefObject<HTMLElement>;
-    deductedWidth?: number;
-    itemRefs: RefObject<HTMLElement>[];
-    minVisibleCount?: number;
-}): {
-    visibleCount: number;
-    hasMeasured: boolean;
-};
+import { type RefObject } from "react";
+/**
+ * Custom hook that calculates how many items can fit in a container without overflowing
+ */
+export default function useItemsOverflow({ containerRef, gap, deductedSpaceRef, deductedWidth, itemRefs, minVisibleCount }: {
+    containerRef: RefObject<HTMLElement>;
+    gap: number;
+    deductedSpaceRef?: RefObject<HTMLElement>;
+    deductedWidth?: number;
+    itemRefs: RefObject<HTMLElement>[];
+    minVisibleCount?: number;
+}): {
+    visibleCount: number;
+    hasMeasured: boolean;
+};

package/dist/hooks/useKeyEvent/index.d.ts

@@ -1,56 +1,56 @@
-import type React from "react";
-import { type RefObject } from "react";
-declare enum Modifier {
-    ALT = "altKey",
-    META = "metaKey",
-    CTRL = "ctrlKey",
-    SHIFT = "shiftKey",
-    CTRL_OR_META = "ctrlOrMetaKey"
-}
-export interface UseKeyEventArgs {
-    /**
-     * The list of keys that should trigger the event.
-     */
-    keys: KeyboardEvent["key"][];
-    /**
-     * Callback fired when a specified key is pressed.
-     */
-    callback: (event: KeyboardEvent | React.KeyboardEvent) => void;
-    /**
-     * Modifier key that must be pressed along with the specified key.
-     */
-    modifier?: Modifier;
-    /**
-     * The keyboard event type to listen for (e.g., "keydown", "keyup").
-     */
-    keyEventName?: string;
-    /**
-     * If true, ensures no modifier keys are pressed when handling the event.
-     */
-    withoutAnyModifier?: boolean;
-    /**
-     * The element reference to listen for key events on.
-     */
-    ref?: RefObject<HTMLElement | Document>;
-    /**
-     * If true, prevents fallback to listening on the document when no ref is provided.
-     */
-    ignoreDocumentFallback?: boolean;
-    /**
-     * If true, uses capture phase instead of bubbling phase for event listening.
-     */
-    capture?: boolean;
-    /**
-     * If true, calls `preventDefault` on the key event.
-     */
-    preventDefault?: boolean;
-    /**
-     * If true, calls `stopPropagation` on the key event.
-     */
-    stopPropagation?: boolean;
-}
-declare function useKeyEvent({ keys, callback, modifier, withoutAnyModifier, ref, ignoreDocumentFallback, capture, preventDefault, stopPropagation, keyEventName }: UseKeyEventArgs): void;
-declare namespace useKeyEvent {
-    var modifiers: typeof Modifier;
-}
-export default useKeyEvent;
+import type React from "react";
+import { type RefObject } from "react";
+declare enum Modifier {
+    ALT = "altKey",
+    META = "metaKey",
+    CTRL = "ctrlKey",
+    SHIFT = "shiftKey",
+    CTRL_OR_META = "ctrlOrMetaKey"
+}
+export interface UseKeyEventArgs {
+    /**
+     * The list of keys that should trigger the event.
+     */
+    keys: KeyboardEvent["key"][];
+    /**
+     * Callback fired when a specified key is pressed.
+     */
+    callback: (event: KeyboardEvent | React.KeyboardEvent) => void;
+    /**
+     * Modifier key that must be pressed along with the specified key.
+     */
+    modifier?: Modifier;
+    /**
+     * The keyboard event type to listen for (e.g., "keydown", "keyup").
+     */
+    keyEventName?: string;
+    /**
+     * If true, ensures no modifier keys are pressed when handling the event.
+     */
+    withoutAnyModifier?: boolean;
+    /**
+     * The element reference to listen for key events on.
+     */
+    ref?: RefObject<HTMLElement | Document>;
+    /**
+     * If true, prevents fallback to listening on the document when no ref is provided.
+     */
+    ignoreDocumentFallback?: boolean;
+    /**
+     * If true, uses capture phase instead of bubbling phase for event listening.
+     */
+    capture?: boolean;
+    /**
+     * If true, calls `preventDefault` on the key event.
+     */
+    preventDefault?: boolean;
+    /**
+     * If true, calls `stopPropagation` on the key event.
+     */
+    stopPropagation?: boolean;
+}
+declare function useKeyEvent({ keys, callback, modifier, withoutAnyModifier, ref, ignoreDocumentFallback, capture, preventDefault, stopPropagation, keyEventName }: UseKeyEventArgs): void;
+declare namespace useKeyEvent {
+    var modifiers: typeof Modifier;
+}
+export default useKeyEvent;

package/dist/hooks/useKeyboard.d.ts

@@ -1,14 +1,14 @@
-import { type KeyboardEventCallback } from "../types/events";
-export declare function useKeyboard({ isDisabled, onKeyDown, onKeyUp }: {
-    isDisabled: boolean;
-    onKeyDown: KeyboardEventCallback;
-    onKeyUp: KeyboardEventCallback;
-}): {
-    keyboardProps: {
-        onKeyDown?: undefined;
-        onKeyUp?: undefined;
-    } | {
-        onKeyDown: (e: UIEvent) => void;
-        onKeyUp: (e: UIEvent) => void;
-    };
-};
+import { type KeyboardEventCallback } from "../types/events";
+export declare function useKeyboard({ isDisabled, onKeyDown, onKeyUp }: {
+    isDisabled: boolean;
+    onKeyDown: KeyboardEventCallback;
+    onKeyUp: KeyboardEventCallback;
+}): {
+    keyboardProps: {
+        onKeyDown?: undefined;
+        onKeyUp?: undefined;
+    } | {
+        onKeyDown: (e: UIEvent) => void;
+        onKeyUp: (e: UIEvent) => void;
+    };
+};

package/dist/hooks/useListenFocusTriggers/index.d.ts

@@ -1,6 +1,6 @@
-import { type RefObject } from "react";
-export default function useListenFocusTriggers({ ref, onFocusByKeyboard, onFocusByMouse }: {
-    ref: RefObject<HTMLElement>;
-    onFocusByKeyboard?: (event: FocusEvent) => void;
-    onFocusByMouse?: (event: FocusEvent) => void;
-}): void;
+import { type RefObject } from "react";
+export default function useListenFocusTriggers({ ref, onFocusByKeyboard, onFocusByMouse }: {
+    ref: RefObject<HTMLElement>;
+    onFocusByKeyboard?: (event: FocusEvent) => void;
+    onFocusByMouse?: (event: FocusEvent) => void;
+}): void;

package/dist/hooks/useMediaQuery/index.d.ts

@@ -1,2 +1,2 @@
-export declare function useMediaQuery(query: string | string[]): boolean[];
-export default useMediaQuery;
+export declare function useMediaQuery(query: string | string[]): boolean[];
+export default useMediaQuery;

package/dist/hooks/useMergeRef.d.ts

@@ -1,7 +1,7 @@
-import { type ForwardedRef, type RefObject } from "react";
-/**
- * Returns a single ref callback that merges multiple ref callbacks - internal replacement for `useMergeRefs` hook
- * @param refs
- */
-declare function useMergeRef<T>(...refs: (RefObject<T> | ForwardedRef<T> | null)[]): RefObject<T>;
-export default useMergeRef;
+import { type ForwardedRef, type RefObject } from "react";
+/**
+ * Returns a single ref callback that merges multiple ref callbacks - internal replacement for `useMergeRefs` hook
+ * @param refs
+ */
+declare function useMergeRef<T>(...refs: (RefObject<T> | ForwardedRef<T> | null)[]): RefObject<T>;
+export default useMergeRef;

package/dist/hooks/usePrevious/index.d.ts

@@ -1 +1 @@
-export default function usePrevious<Type>(value: Type): Type;
+export default function usePrevious<Type>(value: Type): Type;

package/dist/hooks/useRefWithCallback.d.ts

@@ -1,2 +1,2 @@
-import { type MutableRefObject } from "react";
-export default function useRefWithCallback(onMount: (element: HTMLElement) => void, onUnmount?: (element: HTMLElement) => void): [MutableRefObject<HTMLElement>, (node: HTMLElement) => void];
+import { type MutableRefObject } from "react";
+export default function useRefWithCallback(onMount: (element: HTMLElement) => void, onUnmount?: (element: HTMLElement) => void): [MutableRefObject<HTMLElement>, (node: HTMLElement) => void];