@boxcustodia/library 1.2.0 → 1.2.1

package/dist/src/components/tooltip/__doc__/Tooltip.stories.d.ts

@@ -0,0 +1,58 @@
+import { Tooltip } from '../..';
+import { Meta, StoryObj } from '@storybook/react';
+
+/**
+ * El componente Tooltip proporciona información adicional al usuario cuando pasa el mouse
+ * o hace focus sobre un elemento.
+ *
+ * ### Características principales
+ * - Aparece al hacer hover o focus sobre el elemento hijo
+ * - Personalizable a través de className
+ * - Posicionamiento automático
+ * - Accesible por teclado
+ *
+ * ### Uso básico
+ * ```tsx
+ * <Tooltip label="Información adicional">
+ *   <Button>Hover me</Button>
+ * </Tooltip>
+ * ```
+ */
+declare const meta: Meta<typeof Tooltip>;
+export default meta;
+type Story = StoryObj<typeof Tooltip>;
+/**
+ * Ejemplo básico del tooltip con un botón como trigger
+ */
+export declare const Default: Story;
+/**
+ * Ejemplo de tooltip personalizado con colores primarios y abierto por defecto
+ * Prop `defaultOpen=true`
+ */
+export declare const Custom: Story;
+export declare const Side: Story;
+/**
+ * Se puede cambiar la distancia del tooltip con la prop `offset`
+ */
+export declare const Offset: Story;
+/**
+ * ThemeProvider permite customizar de manera global las propiedades del componente
+ *
+ * Ejemplo:
+ * ```tsx
+ * <ThemeProvider
+ *   theme={{
+ *     Tooltip: {
+ *       className: "bg-black text-white",
+ *       side: "bottom",
+ *       offset: 20,
+ *     },
+ *   }}
+ * >
+ *   <Tooltip label="Tooltip con tema">
+ *     <Button icon={<ScanEye />}>Hover me</Button>
+ *   </Tooltip>
+ * </ThemeProvider>
+ * ```
+ */
+export declare const Theme: Story;

package/dist/src/components/tooltip/__test__/Tooltip.test.d.ts

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

package/dist/src/components/tooltip/index.d.ts

@@ -0,0 +1 @@
+export * from './Tooltip';

package/dist/src/components/tree/Tree.d.ts

@@ -0,0 +1,13 @@
+import { TreeRoot } from './TreePrimitives';
+import * as React from "react";
+export interface TreeNode {
+    id: string | number;
+    title: string;
+    children: TreeNode[];
+}
+type TreeRootProps = React.ComponentProps<typeof TreeRoot>;
+type Props<T extends TreeNode> = TreeRootProps & {
+    items: T[];
+};
+export declare function Tree<T extends TreeNode>({ items, ...props }: Props<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/tree/TreePrimitives.d.ts

@@ -0,0 +1,11 @@
+import { TreeItemProps as TreeItemPrimitiveProps, TreeProps, Collection, UNSTABLE_TreeItemContent as TreeItemContentPrimitive } from 'react-aria-components';
+import { OverrideProps } from '../../models';
+import * as React from "react";
+declare const TreeRoot: <T extends object>({ className, ...props }: TreeProps<T>) => import("react/jsx-runtime").JSX.Element;
+declare const TreeItem: <T extends object>({ className, ...props }: OverrideProps<TreeItemPrimitiveProps<T>, {
+    id: string | number;
+}>) => import("react/jsx-runtime").JSX.Element;
+declare const TreeItemContent: (props: React.ComponentProps<typeof TreeItemContentPrimitive>) => import("react/jsx-runtime").JSX.Element;
+declare const TreeItemIndicator: () => import("react/jsx-runtime").JSX.Element;
+declare const TreeItemLabel: (props: React.HtmlHTMLAttributes<HTMLSpanElement>) => import("react/jsx-runtime").JSX.Element;
+export { Collection, TreeItem, TreeItemContent, TreeItemIndicator, TreeItemLabel, TreeRoot, };

package/dist/src/components/tree/__doc__/Tree.stories.d.ts

@@ -0,0 +1,116 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { Tree } from '../Tree';
+
+/**
+ * El componente Tree proporciona una vista jerárquica de datos en forma de árbol.
+ * Está construido sobre [@react-aria](https://react-spectrum.adobe.com/react-aria/Tree.html#tree)
+ * y soporta selección, expansión, navegación por teclado y más.
+ *
+ * ## Nodo
+ * Los nodos del árbol deben tener las siguientes propiedades:
+ *
+ * ```tsx
+ * interface TreeNode {
+ *   id: string | number;
+ *   title: string;
+ *   children: TreeNode[];
+ * }
+ * ```
+ */
+declare const meta: Meta<typeof Tree>;
+export default meta;
+type Story = StoryObj<typeof Tree>;
+/**
+ * Ejemplo básico del árbol con selección simple habilitada.
+ * Los usuarios pueden expandir/colapsar nodos y seleccionar un elemento a la vez.
+ */
+export declare const Default: Story;
+/**
+ * Configuración que permite seleccionar un solo elemento a la vez.
+ * Útil cuando necesitas que el usuario elija una única opción del árbol.
+ */
+export declare const SingleSelection: Story;
+/**
+ * Permite seleccionar múltiples elementos simultáneamente.
+ * Los usuarios pueden usar `click` para selección individual
+ * o `shift + click` para selección en rango.
+ */
+export declare const MultipleSelection: Story;
+/**
+ * Ejemplo de árbol con nodos deshabilitados completamente.
+ * Los elementos deshabilitados no pueden ser seleccionados ni expandidos.
+ *
+ * `disabledBehavior="all"` - Deshabilita todas las interacciones
+ *
+ * `disabledKeys` - Array de IDs de elementos a deshabilitar
+ */
+export declare const Disabled: Story;
+/**
+ * Ejemplo donde solo la selección está deshabilitada.
+ * Los elementos pueden expandirse pero no pueden ser seleccionados.
+ *
+ * `disabledBehavior="selection"` - Solo deshabilita la selección
+ *
+ * `disabledKeys` - Array de IDs de elementos a deshabilitar
+ */
+export declare const DisabledSelection: Story;
+/**
+ * Árbol con nodos inicialmente expandidos.
+ * Útil para mostrar cierta estructura desde el inicio.
+ *
+ * `defaultExpandedKeys` - Array de IDs de elementos expandidos por defecto
+ */
+export declare const DefaultExpanded: Story;
+/**
+ * Ejemplo de árbol con expansión controlada.
+ * El estado de expansión es manejado externamente.
+ *
+ * `expandedKeys` - Control explícito de los elementos expandidos
+ */
+export declare const ControlledExpanded: Story;
+/**
+ * Árbol con selección inicial predeterminada.
+ *
+ * `defaultSelectedKeys` - Array de IDs de elementos seleccionados por defecto
+ */
+export declare const DefaultSelected: Story;
+/**
+ * Demostración de los eventos disponibles en el árbol.
+ * Muestra notificaciones toast para:
+ * - Cambios en expansión
+ * - Cambios en selección
+ * - Eventos de scroll
+ */
+export declare const Events: Story;
+/**
+ * ## Estructura con componentes primitivos
+ * ```tsx
+ * import { TreeRoot, TreeItem, Collection } from '@/components/tree'
+ *
+ * const Estructura = () => {
+ *   return (
+ *     <TreeRoot>
+ *       <TreeItem>
+ *         <TreeItemContent>
+ *           <TreeItemIndicator />
+ *           <TreeItemLabel>Item Label</TreeItemLabel>
+ *         </TreeItemContent>
+ *         <Collection>
+ *           Child items
+ *         </Collection>
+ *       </TreeItem>
+ *     </TreeRoot>
+ *   )
+ * }
+ * ```
+ *
+ * Los componentes primitivos del Tree son:
+ *
+ * - `TreeRoot`: Contenedor principal que maneja la selección y expansión
+ * - `TreeItem`: Representa cada elemento del árbol
+ * - `TreeItemContent`: Contenedor del contenido del item
+ * - `TreeItemIndicator`: Indicador de expansión (chevron)
+ * - `TreeItemLabel`: Etiqueta del item
+ * - `Collection`: Contenedor de items hijos que permite manejo con teclado
+ */
+export declare const Primitive: Story;

package/dist/src/components/tree/hooks/useControllableTreeState.d.ts

@@ -0,0 +1,16 @@
+interface UseControllableTreeStateProps {
+    defaultExpandedKeys: string[];
+    defaultSelectedKeys: string[];
+    selectedKeys?: string[];
+    expandedKeys?: string[];
+    multiSelect: boolean;
+    onSelect?: (selectedKeys: string[]) => void;
+    onExpand?: (expandedKeys: string[]) => void;
+}
+export declare function useControllableTreeState({ defaultExpandedKeys, defaultSelectedKeys, selectedKeys: selectedKeysProp, expandedKeys: expandedKeysProp, multiSelect, onSelect, onExpand, }: UseControllableTreeStateProps): {
+    expandedKeys: Set<string>;
+    selectedKeys: Set<string>;
+    handleToggle: (nodeId: string) => void;
+    handleSelect: (nodeId: string) => void;
+};
+export {};

package/dist/src/components/tree/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Tree';
+export * from './TreePrimitives';

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

@@ -0,0 +1,26 @@
+export { useControllableState } from '@radix-ui/react-use-controllable-state';
+export * from './useArray';
+export * from './useAsync';
+export * from './useClickOutside';
+export * from './useClipboard';
+export * from './useDebounceCallback';
+export * from './useDebounceValue';
+export * from './useDisclosure';
+export * from './useDocumentTitle';
+export * from './useEventListener';
+export * from './useHotkey';
+export * from './useHover';
+export * from './useIsVisible';
+export * from './useLocalStorage';
+export * from './useMediaQuery';
+export * from './useMemoizedFn';
+export * from './useMutation';
+export * from './useObject';
+export * from './usePagination';
+export * from './usePortal';
+export * from './usePreventCloseWindow';
+export * from './useRangePagination';
+export * from './useSelection';
+export * from './useStep';
+export * from './useToggle';
+export * from './useFocusTrap';

package/dist/src/hooks/useArray/__doc__/useArray.stories.d.ts

@@ -0,0 +1,23 @@
+import { Meta, StoryObj } from '@storybook/react';
+
+/**
+ * Hook que facilita el manejo de estado de una lista
+ * Se exponen los siguientes métodos:
+ *
+ * | Método | Descripción |
+ * | --- | --- |
+ * | `insertAt(index: number, item: T)` | Inserta un elemento en un índice específico en la lista. |
+ * | `removeAt(index: number)` | Elimina un elemento en un índice específico de la lista. |
+ * | `updateAt(index: number, newItem: T)` | Actualiza un elemento en un índice específico de la lista. |
+ * | `clear()` | Elimina todos los elementos de la lista. |
+ * | `reset()` | Restablece la lista a su valor por defecto o inicial. |
+ * | `push(item: T)` | Agrega un nuevo elemento al final de la lista. |
+ * | `pop()` | Elimina el último elemento de la lista. |
+ * | `set(newList: T[])` | Actualiza la lista con una nueva lista. |
+ * | `update(predicate: ListIterateeCustom<T, boolean>, newItem: T | (item: T) => T)` | Actualiza un elemento de la lista.
+ */
+declare const meta: Meta;
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;
+export declare const DynamicList: Story;

package/dist/src/hooks/useArray/__test__/useArray.test.d.ts

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

package/dist/src/hooks/useArray/index.d.ts

@@ -0,0 +1 @@
+export { default as useArray } from './useArray';

package/dist/src/hooks/useArray/useArray.d.ts

@@ -0,0 +1,14 @@
+import { ListIterateeCustom } from 'lodash';
+
+declare function useArray<T>(defaultProp: T[]): readonly [T[], {
+    readonly insertAt: (index: number, item: T) => void;
+    readonly removeAt: (index: number) => void;
+    readonly updateAt: (index: number, newItem: T) => void;
+    readonly clear: () => void;
+    readonly reset: () => void;
+    readonly push: (item: T) => void;
+    readonly set: (newList: T[]) => void;
+    readonly pop: () => void;
+    readonly update: (predicate: ListIterateeCustom<T, boolean>, newItem: T | ((item: T) => T)) => void;
+}];
+export default useArray;

package/dist/src/hooks/useAsync/__doc__/useAsync.stories.d.ts

@@ -0,0 +1,18 @@
+import { Meta, StoryObj } from '@storybook/react';
+
+declare const meta: Meta;
+export default meta;
+type Story = StoryObj;
+export declare const Basic: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};
+/**
+ * ```tsx
+ * interface UseAsyncOptions<T> {
+ *  onError?: (error: Error) => void;
+ *  onSuccess?: (data: T) => void;
+ *  onFinish?: () => void;
+ * }
+ * ```
+ */
+export declare const Advanced: Story;

package/dist/src/hooks/useAsync/__test__/useAsync.test.d.ts

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

package/dist/src/hooks/useAsync/index.d.ts

@@ -0,0 +1 @@
+export { default as useAsync } from './useAsync';

package/dist/src/hooks/useAsync/useAsync.d.ts

@@ -0,0 +1,19 @@
+import { DependencyList } from 'react';
+
+interface UseAsyncOptions<T> {
+    onError?: (error: Error) => void;
+    onSuccess?: (data: T) => void;
+    onFinish?: () => void;
+}
+interface AsyncState<T> {
+    loading: boolean;
+    error: Error | null;
+    data: T | null;
+    refetch: () => void;
+}
+interface Props<T> extends UseAsyncOptions<T> {
+    fn: () => Promise<T>;
+    dependencies?: DependencyList;
+}
+declare function useAsync<T>({ fn, dependencies, onError, onSuccess, onFinish, }: Props<T>): AsyncState<T>;
+export default useAsync;

package/dist/src/hooks/useClickOutside/__doc__/useClickOutside.stories.d.ts

@@ -0,0 +1,7 @@
+import { Meta } from '@storybook/react';
+
+declare const meta: Meta;
+export default meta;
+export declare const Default: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/src/hooks/useClickOutside/__test__/useClickOutside.test.d.ts

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

package/dist/src/hooks/useClickOutside/index.d.ts

@@ -0,0 +1 @@
+export { default as useClickOutside } from './useClickOutside';

package/dist/src/hooks/useClickOutside/useClickOutside.d.ts

@@ -0,0 +1,2 @@
+declare const useClickOutside: <T extends HTMLElement = HTMLElement>(callback: () => void, watch?: boolean) => import('react').RefObject<T | null>;
+export default useClickOutside;

package/dist/src/hooks/useClipboard/__doc__/useClipboard.stories.d.ts

@@ -0,0 +1,9 @@
+import { Meta, StoryObj } from '@storybook/react';
+
+/**
+ * Permite copiar texto al portapapeles del usuario. Devuelve el texto copiado actualmente y una función para copiar nuevo texto. Incluye manejo de compatibilidad y errores.
+ */
+declare const meta: Meta;
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;

package/dist/src/hooks/useClipboard/__test__/useClipboard.test.d.ts

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

package/dist/src/hooks/useClipboard/index.d.ts

@@ -0,0 +1 @@
+export { default as useClipboard } from './useClipboard';

package/dist/src/hooks/useClipboard/useClipboard.d.ts

@@ -0,0 +1,4 @@
+type CopiedValue = string | null;
+type CopyFunction = (text: string) => Promise<boolean>;
+declare function useCopyToClipboard(): [CopiedValue, CopyFunction];
+export default useCopyToClipboard;

package/dist/src/hooks/useDebounceCallback/__doc__/useDebouncedCallback.stories.d.ts

@@ -0,0 +1,8 @@
+import { Meta, StoryObj } from '@storybook/react';
+
+declare const meta: Meta;
+export default meta;
+export declare const Basic: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};
+export declare const DifferentDelays: StoryObj;

package/dist/src/hooks/useDebounceCallback/index.d.ts

@@ -0,0 +1 @@
+export { default as useDebouncedCallback } from './useDebouncedCallback';

package/dist/src/hooks/useDebounceCallback/useDebouncedCallback.d.ts

@@ -0,0 +1,2 @@
+declare function useDebouncedCallback<T extends (...args: any[]) => any>(callback: T, delay: number): (...args: Parameters<T>) => void;
+export default useDebouncedCallback;

package/dist/src/hooks/useDebounceValue/__doc__/useDebouncedValue.stories.d.ts

@@ -0,0 +1,8 @@
+import { Meta, StoryObj } from '@storybook/react';
+
+declare const meta: Meta;
+export default meta;
+export declare const Basic: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};
+export declare const MultipleDelays: StoryObj;

package/dist/src/hooks/useDebounceValue/index.d.ts

@@ -0,0 +1 @@
+export { default as useDebouncedValue } from './useDebouncedValue';

package/dist/src/hooks/useDebounceValue/useDebouncedValue.d.ts

@@ -0,0 +1,2 @@
+declare function useDebouncedValue<T>(value: T, delay: number): T;
+export default useDebouncedValue;

package/dist/src/hooks/useDisclosure/__doc__/useDisclosure.stories.d.ts

@@ -0,0 +1,10 @@
+import { Meta } from '@storybook/react';
+
+/**
+ * Hook que facilita el manejo de un estado booleano. Provee métodos para abrir, cerrar y toggle el estado
+ */
+declare const meta: Meta;
+export default meta;
+export declare const Default: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/src/hooks/useDisclosure/__test__/useDisclosure.test.d.ts

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

package/dist/src/hooks/useDisclosure/index.d.ts

@@ -0,0 +1 @@
+export { default as useDisclosure } from './useDisclosure';

package/dist/src/hooks/useDisclosure/useDisclosure.d.ts

@@ -0,0 +1,9 @@
+declare function useDisclosure(initialState?: boolean, callbacks?: {
+    onOpen?: () => void;
+    onClose?: () => void;
+}): readonly [boolean, {
+    readonly open: () => void;
+    readonly close: () => void;
+    readonly toggle: () => void;
+}];
+export default useDisclosure;

package/dist/src/hooks/useDocumentTitle/__doc__/useDocumentTitle.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from '@storybook/react';
+
+declare const meta: Meta;
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;

package/dist/src/hooks/useDocumentTitle/index.d.ts

@@ -0,0 +1 @@
+export { default as useDocumentTitle } from './useDocumentTitle';

package/dist/src/hooks/useDocumentTitle/useDocumentTitle.d.ts

@@ -0,0 +1,2 @@
+declare function useDocumentTitle(title: string): void;
+export default useDocumentTitle;

package/dist/src/hooks/useEventListener/__doc__/useEventListener.stories.d.ts

@@ -0,0 +1,18 @@
+import { Meta } from '@storybook/react';
+
+/**
+ * Hook que facilita el manejor de eventos
+ *
+ * Evita tener que hacer el `useEffect` con el cleanup
+ */
+declare const meta: Meta;
+export default meta;
+/**
+ * ```tsx
+ * const ref = useEventListener<HTMLELEMENT>("EVENT_KEY", callback);
+ * return <HTMLELEMENT ref={ref} />;
+ * ```
+ */
+export declare const Default: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/src/hooks/useEventListener/__test__/useEventListener.test.d.ts

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

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

@@ -0,0 +1 @@
+export { default as useEventListener } from './useEventListener';

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

@@ -0,0 +1,2 @@
+declare function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement = any>(type: K, listener: (this: HTMLDivElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): import('react').RefObject<T | null>;
+export default useEventListener;

package/dist/src/hooks/useFocusTrap/__doc__/useFocusTrap.stories.d.ts

@@ -0,0 +1,10 @@
+import { Meta } from '@storybook/react';
+
+/**
+ * Hook que atrapa el focus en un scope
+ */
+declare const meta: Meta;
+export default meta;
+export declare const Default: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/src/hooks/useFocusTrap/index.d.ts

@@ -0,0 +1 @@
+export { default as useFocusTrap } from './useFocusTrap';

package/dist/src/hooks/useFocusTrap/scopeTab.d.ts

@@ -0,0 +1 @@
+export declare function scopeTab(node: HTMLElement, event: KeyboardEvent): void;

package/dist/src/hooks/useFocusTrap/tabbable.d.ts

@@ -0,0 +1,4 @@
+export declare const FOCUS_SELECTOR = "a, input, select, textarea, button, object, [tabindex]";
+export declare function focusable(element: HTMLElement): boolean | "";
+export declare function tabbable(element: HTMLElement): boolean | "";
+export declare function findTabbableDescendants(element: HTMLElement): HTMLElement[];

package/dist/src/hooks/useFocusTrap/useFocusTrap.d.ts

@@ -0,0 +1,2 @@
+declare function useFocusTrap(active?: boolean): (instance: HTMLElement | null) => void;
+export default useFocusTrap;

package/dist/src/hooks/useHotkey/__docs__/useHotkey.stories.d.ts

@@ -0,0 +1,23 @@
+import { Meta, StoryObj } from '@storybook/react';
+
+declare const meta: Meta;
+export default meta;
+type Story = StoryObj<typeof meta>;
+/**
+ * Opciones
+ *
+ * ```tsx
+ * type HotkeyOptions = {
+ * // Es el evento que se va a utilizar; Keydown, Keyup, Keypress
+ * eventName?: HotkeyEventName;
+ * @default "keydown"
+ * // si se debe prevenir los comandos por defecto del navegador
+ * preventDefault?: boolean;
+ * @default true
+ * // si los comandos se deberían ejecutar mientras el usuario está escribiendo en un input o textarea
+ * ignoreInputFields?: boolean;
+ * @default false
+ * };
+ * ```
+ **/
+export declare const Default: Story;

package/dist/src/hooks/useHotkey/__test__/useHotkey.test.d.ts

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

package/dist/src/hooks/useHotkey/__utils__/create-hotkey-listener.d.ts

@@ -0,0 +1 @@
+export declare const createListener: (keys: string | string[], handler: (event: KeyboardEvent) => void, preventDefault: boolean, ignoreInputFields: boolean, watch: boolean) => (event: KeyboardEvent) => void;

package/dist/src/hooks/useHotkey/__utils__/index.d.ts

@@ -0,0 +1,3 @@
+export * from './match-key-modifiers';
+export * from './is-input-field';
+export * from './create-hotkey-listener';

package/dist/src/hooks/useHotkey/__utils__/is-input-field.d.ts

@@ -0,0 +1,2 @@
+export declare const isInputField: (element: HTMLElement) => boolean;
+export declare const shouldIgnoreEvent: (event: KeyboardEvent, ignoreInputFields: boolean) => boolean;

package/dist/src/hooks/useHotkey/__utils__/match-key-modifiers.d.ts

@@ -0,0 +1,8 @@
+export declare const getKeyModifiers: (key: string) => {
+    mainKey: string;
+    isShift: boolean;
+    isCtrl: boolean;
+    isAlt: boolean;
+    isMeta: boolean;
+};
+export declare const matchKeyModifiers: (event: KeyboardEvent, key: string) => boolean;

package/dist/src/hooks/useHotkey/index.d.ts

@@ -0,0 +1 @@
+export { default as useHotkey } from './useHotkey';

package/dist/src/hooks/useHotkey/useHotkey.d.ts

@@ -0,0 +1,10 @@
+export type Keys = string | string[];
+export type HotkeyEventName = "keydown" | "keypress" | "keyup";
+export type HotkeyOptions = {
+    watch?: boolean;
+    eventName?: HotkeyEventName;
+    preventDefault?: boolean;
+    ignoreInputFields?: boolean;
+};
+declare function useHotkey(keys: string | string[], handler: (event: KeyboardEvent) => void, options?: HotkeyOptions): import('react').RefObject<any>;
+export default useHotkey;

package/dist/src/hooks/useHover/__doc__/useHover.stories.d.ts

@@ -0,0 +1,10 @@
+import { Meta } from '@storybook/react';
+
+/**
+ * Hook que facilita el manejo de un estado booleano. Provee métodos para abrir, cerrar y toggle el estado
+ */
+declare const meta: Meta;
+export default meta;
+export declare const Default: {
+    render: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/src/hooks/useHover/__test__/useHover.test.d.ts

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

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

@@ -0,0 +1 @@
+export { default as useHover } from './useHover';

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

@@ -0,0 +1,9 @@
+type UseHoverOptions = {
+    onHoverStart?: (event: MouseEvent) => void;
+    onHoverEnd?: (event: MouseEvent) => void;
+};
+declare function useHover<T extends HTMLElement>(options?: UseHoverOptions): {
+    ref: React.RefObject<T | null>;
+    isHovering: boolean;
+};
+export default useHover;

package/dist/src/hooks/useIsVisible/__doc__/useIsVisible.stories.d.ts

@@ -0,0 +1,10 @@
+import { Meta, StoryObj } from '@storybook/react';
+
+/**
+ * Hook que permite detectar si un elemento es visible para el usuario
+ *
+ * Extiende la API de `IntersectionObserver`
+ */
+declare const meta: Meta;
+export default meta;
+export declare const Default: StoryObj;

package/dist/src/hooks/useIsVisible/index.d.ts

@@ -0,0 +1 @@
+export { default as useIsVisible } from './useIsVisible';