@siberiacancode/reactuse 0.0.112 → 0.0.114

package/dist/types/hooks/useIntersectionObserver/useIntersectionObserver.d.ts

@@ -0,0 +1,45 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The intersection observer options type */
+export interface UseIntersectionObserverOptions extends Omit<IntersectionObserverInit, 'root'> {
+    enabled?: boolean;
+    root?: HookTarget;
+    onChange?: (entry: IntersectionObserverEntry) => void;
+}
+/** The intersection observer return type */
+export interface UseIntersectionObserverReturn {
+    entry?: IntersectionObserverEntry;
+    inView: boolean;
+}
+export interface UseIntersectionObserver {
+    <Target extends Element>(options?: UseIntersectionObserverOptions, target?: never): UseIntersectionObserverReturn & {
+        ref: StateRef<Target>;
+    };
+    (target: HookTarget, options?: UseIntersectionObserverOptions): UseIntersectionObserverReturn;
+}
+/**
+ * @name useIntersectionObserver
+ * @description - Hook that gives you intersection observer state
+ * @category Browser
+ *
+ * @overload
+ * @param {HookTarget} target The target element to detect intersection
+ * @param {boolean} [options.enabled=true] The IntersectionObserver options
+ * @param {((entries: IntersectionObserverEntry[], observer: IntersectionObserver) => void) | undefined} [options.onChange] The callback to execute when intersection is detected
+ * @param {HookTarget} [options.root] The root element to observe
+ * @returns {UseIntersectionObserverReturn} An object containing the state and the supported status
+ *
+ * @example
+ * const { ref, entry, inView } = useIntersectionObserver();
+ *
+ * @overload
+ * @template Target The target element
+ * @param {boolean} [options.enabled=true] The IntersectionObserver options
+ * @param {((entries: IntersectionObserverEntry[], observer: IntersectionObserver) => void) | undefined} [options.onChange] The callback to execute when intersection is detected
+ * @param {HookTarget} [options.root] The root element to observe
+ * @returns {UseIntersectionObserverReturn & { ref: StateRef<Target> }} A React ref to attach to the target element
+ *
+ * @example
+ * const { entry, inView } = useIntersectionObserver(ref);
+ */
+export declare const useIntersectionObserver: UseIntersectionObserver;

package/dist/types/hooks/useInterval/useInterval.d.ts

@@ -0,0 +1,46 @@
+/** The use interval options */
+export interface UseIntervalOptions {
+    /** Start the interval immediately */
+    immediately?: boolean;
+}
+/** The use interval return type */
+export interface UseIntervalReturn {
+    /** Is the interval active */
+    active: boolean;
+    /** Pause the interval */
+    pause: () => void;
+    /** Resume the interval */
+    resume: () => void;
+    /** Toggle the interval */
+    toggle: () => void;
+}
+interface UseInterval {
+    (callback: () => void, interval?: number, options?: UseIntervalOptions): UseIntervalReturn;
+    (callback: () => void, options?: UseIntervalOptions & {
+        interval?: number;
+    }): UseIntervalReturn;
+}
+/**
+ * @name useInterval
+ * @description - Hook that makes and interval and returns controlling functions
+ * @category Time
+ *
+ * @overload
+ * @param {() => void} callback Any callback function
+ * @param {number} [interval=1000] Time in milliseconds
+ * @param {boolean} [options.immediately=true] Start the interval immediately
+ * @returns {UseIntervalReturn}
+ *
+ * @example
+ * const { active, pause, resume, toggle } = useInterval(() => console.log('inside interval'), 2500);
+ *
+ * @overload
+ * @param {() => void} callback Any callback function
+ * @param {number} [options.interval=1000] Time in milliseconds
+ * @param {boolean} [options.immediately=true] Start the interval immediately
+ *
+ * @example
+ * const { active, pause, resume, toggle } = useInterval(() => console.log('inside interval'), { interval: 2500 });
+ */
+export declare const useInterval: UseInterval;
+export {};

package/dist/types/hooks/useIsFirstRender/useIsFirstRender.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @name useIsFirstRender
+ * @description - Hook that returns true if the component is first render
+ * @category Lifecycle
+ *
+ * @returns {boolean} True if the component is first render
+ *
+ * @example
+ * const isFirstRender = useIsFirstRender();
+ */
+export declare const useIsFirstRender: () => boolean;

package/dist/types/hooks/useIsomorphicLayoutEffect/useIsomorphicLayoutEffect.d.ts

@@ -0,0 +1,10 @@
+import { useEffect } from 'react';
+/**
+ * @name useIsomorphicLayoutEffect
+ * @description - Hook conditionally selects either `useLayoutEffect` or `useEffect` based on the environment
+ * @category Lifecycle
+ *
+ * @example
+ * useIsomorphicLayoutEffect(() => console.log('effect'), [])
+ */
+export declare const useIsomorphicLayoutEffect: typeof useEffect;

package/dist/types/hooks/useKeyPress/useKeyPress.d.ts

@@ -0,0 +1,37 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The key or keys to listen for */
+export type UseKeyPressKey = string | string[];
+/** The callback function to be invoked when key is pressed */
+export type UseKeyPressCallback = (pressed: boolean, event: KeyboardEvent) => void;
+export interface UseKeyPress {
+    (target: HookTarget | Window, key: UseKeyPressKey, callback?: UseKeyPressCallback): boolean;
+    <Target extends Element>(key: UseKeyPressKey, callback?: UseKeyPressCallback, target?: never): {
+        pressed: boolean;
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name useKeyPress
+ * @description - Hook that listens for key press events
+ * @category Sensors
+ *
+ * @overload
+ * @param {HookTarget} [target=window] The target to attach the event listeners to
+ * @param {UseKeyPressKey} key The key or keys to listen for
+ * @param {(pressed: boolean, event: KeyboardEvent) => void} [callback] Callback function invoked when key is pressed
+ * @returns {boolean} The pressed state of the key
+ *
+ * @example
+ * const isKeyPressed = useKeyPress('a', window);
+ *
+ * @overload
+ * @template Target The target element type
+ * @param {UseKeyPressKey} key The key or keys to listen for
+ * @param {(pressed: boolean, event: KeyboardEvent) => void} [callback] Callback function invoked when key is pressed
+ * @returns {{ pressed: boolean; ref: StateRef<Target> }} An object containing the pressed state and ref
+ *
+ * @example
+ * const { pressed, ref } = useKeyPress('a');
+ */
+export declare const useKeyPress: UseKeyPress;

package/dist/types/hooks/useKeyPressEvent/useKeyPressEvent.d.ts

@@ -0,0 +1,45 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The key or keys to listen for */
+export type UseKeyPressEventKey = string | string[];
+/** The use key press event options type */
+export interface UseKeyPressEventOptions {
+    /** Whether the event should be captured */
+    capture?: boolean;
+    /** Whether the event listener should only be triggered once */
+    once?: boolean;
+    /** Whether the event listener should be passive */
+    passive?: boolean;
+}
+export interface UseKeyPressEvent {
+    (target: HookTarget | Window, key: UseKeyPressEventKey, listener: (event: KeyboardEvent) => void, options?: UseKeyPressEventOptions): void;
+    <Target extends Element>(key: UseKeyPressEventKey, listener: (event: KeyboardEvent) => void, options?: UseKeyPressEventOptions, target?: never): {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name useKeyPressEvent
+ * @description - Hook that listens for key press events on specified targets
+ * @category Sensors
+ *
+ * @overload
+ * @param {UseKeyPressEventKey} key The key or array of keys to listen for.
+ * @param {HookTarget | Window} target The target to attach the event listener to.
+ * @param {(event: KeyboardEvent) => void} listener The callback function to be executed when the specified key or keys are pressed.
+ * @param {UseKeyPressEventOptions} [options] The options for the event listener.
+ * @returns {void}
+ *
+ * @example
+ * useKeyPressEvent(ref, 'Enter', () => console.log('pressed'));
+ *
+ * @overload
+ * @template Target extends Element
+ * @param {UseKeyPressEventKey} key The key or array of keys to listen for.
+ * @param {(event: KeyboardEvent) => void} listener The callback function to be executed when the specified key or keys are pressed.
+ * @param {UseKeyPressEventOptions} [options] The options for the event listener.
+ * @returns {{ ref: StateRef<Target> }} An object containing the ref
+ *
+ * @example
+ * const ref = useKeyPressEvent('Enter', (event) => console.log('pressed'));
+ */
+export declare const useKeyPressEvent: UseKeyPressEvent;

package/dist/types/hooks/useKeyboard/useKeyboard.d.ts

@@ -0,0 +1,39 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The keyboard event handler type */
+export type KeyboardEventHandler = (event: KeyboardEvent) => void;
+/** The use keyboard options type */
+export interface UseKeyboardOptions {
+    /** The callback function to be invoked on key down */
+    onKeyDown?: KeyboardEventHandler;
+    /** The callback function to be invoked on key up */
+    onKeyUp?: KeyboardEventHandler;
+}
+export interface UseKeyboard {
+    (target: HookTarget | Window, options: UseKeyboardOptions): void;
+    <Target extends Element>(options: UseKeyboardOptions, target?: never): {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name useKeyboard
+ * @description - Hook that helps to listen for keyboard events
+ * @category Sensors
+ *
+ * @overload
+ * @param {HookTarget | Window} target The target to attach the event listeners to
+ * @param {UseKeyboardOptions} [options] The keyboard event options
+ * @returns {void}
+ *
+ * @example
+ * useKeyboard(ref, { onKeyDown: (event) => console.log('key down'), onKeyUp: (event) => console.log('key up') });
+ *
+ * @overload
+ * @template Target The target element type
+ * @param {UseKeyboardOptions} [options] The keyboard event options
+ * @returns {{ ref: StateRef<Target> }} An object containing the ref
+ *
+ * @example
+ * const ref = useKeyboard({ onKeyDown: (event) => console.log('key down'), onKeyUp: (event) => console.log('key up') });
+ */
+export declare const useKeyboard: UseKeyboard;

package/dist/types/hooks/useKeysPressed/useKeysPressed.d.ts

@@ -0,0 +1,44 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The use keys pressed options type */
+export interface UseKeysPressedOptions {
+    /** Enable or disable the event listeners */
+    enabled?: boolean;
+}
+export interface UseKeysPressed {
+    (target: HookTarget | Window, options?: UseKeysPressedOptions): Array<{
+        key: string;
+        code: string;
+    }>;
+    <Target extends Element>(options?: UseKeysPressedOptions): {
+        value: Array<{
+            key: string;
+            code: string;
+        }>;
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * Hook that tracks which keyboard keys are currently pressed
+ *
+ * @name useKeysPressed
+ * @description Tracks all currently pressed keyboard keys and their codes
+ * @category Sensors
+ *
+ * @overload
+ * @param {HookTarget | Window} target DOM element or ref to attach keyboard listeners to
+ * @param {UseKeysPressedOptions} [options.enabled=true] Enable or disable the event listeners
+ * @returns {Array<{ key: string; code: string }>} Array of currently pressed keys with their key and code values
+ *
+ * @example
+ * const pressedKeys = useKeysPressed(ref);
+ *
+ * @overload
+ * @template Target - Type of the target DOM element
+ * @param {UseKeysPressedOptions} [options] - Optional configuration options
+ * @returns {{ keys: Array<{ key: string; code: string }>; ref: StateRef<Target> }} Object containing pressed keys array and ref to attach to a DOM element
+ *
+ * @example
+ * const { value, ref } = useKeysPressed();
+ */
+export declare const useKeysPressed: UseKeysPressed;

package/dist/types/hooks/useLastChanged/useLastChanged.d.ts

@@ -0,0 +1,17 @@
+/** The use last changed options type  */
+export interface UseLastChangedOptions {
+    initialValue?: number;
+}
+/**
+ * @name useLastChanged
+ * @description - Hook for records the timestamp of the last change
+ * @category Time
+ *
+ * @param {any} source  The source of the last change
+ * @param {number | null} [options.initialValue=null] The initial value
+ * @returns {number | null} Return timestamp of the last change
+ *
+ * @example
+ * const lastChanged = useLastChanged(source);
+ */
+export declare const useLastChanged: (source: any, options?: UseLastChangedOptions) => number | null;

package/dist/types/hooks/useLatest/useLatest.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @name useLatest
+ * @description - Hook that returns the stable reference of the value
+ * @category Utilities
+ *
+ * @template Value The type of the value
+ * @param {Value} value The value to get the previous value
+ * @returns {Value} The previous value
+ *
+ * @example
+ * const latestValue = useLatest(value);
+ */
+export declare const useLatest: <Value>(value: Value) => Value;

package/dist/types/hooks/useLess/useLess.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name useLess
+ * @description - Hook that can be so useless
+ * @category Humor
+ *
+ * @warning - This hook is a joke. Please do not use it in production code!
+ *
+ * @template Value The type of the value
+ * @param {Value} [value] The value to be returned
+ * @returns {Value} The value passed to the hook
+ *
+ * @example
+ * const value = useLess(state);
+ */
+export declare const useLess: <Value>(value?: Value) => Value | undefined;

package/dist/types/hooks/useList/useList.d.ts

@@ -0,0 +1,39 @@
+/** The use list return type */
+export interface UseListReturn<Item> {
+    /** The current list of items */
+    value: Item[];
+    /** Clears the list */
+    clear: () => void;
+    /** Inserts an item at the specified index */
+    insertAt: (insertAtIndex: number, item: Item) => void;
+    /** Adds an item to the list */
+    push: (item: Item) => void;
+    /** Removes an item from the list */
+    removeAt: (removeAtIndex: number) => void;
+    /** Sets the list of items */
+    set: (list: Item[]) => void;
+    /** Updates an item at the specified index */
+    updateAt: (updateAtIndex: number, item: Item) => void;
+}
+/**
+ * @name useList
+ * @description - Hook that provides state and helper methods to manage a list of items
+ * @category Utilities
+ *
+ * @template Item The type of the item
+ * @param {Item[] | (() => Item[])} initialList The initial list of items
+ * @returns {UseListReturn} An object containing the current list and functions to interact with the list
+ *
+ * @example
+ * const { value, set, push, removeAt, insertAt, updateAt, clear } = useList();
+ */
+export declare const useList: <Item>(initialList?: Item[]) => {
+    value: Item[];
+    set: import('react').Dispatch<import('react').SetStateAction<Item[]>>;
+    push: (item: Item) => void;
+    removeAt: (removeAtIndex: number) => void;
+    insertAt: (insertAtIndex: number, item: Item) => void;
+    updateAt: (updateAtIndex: number, item: Item) => void;
+    clear: () => void;
+    reset: () => void;
+};

package/dist/types/hooks/useLocalStorage/useLocalStorage.d.ts

@@ -0,0 +1,21 @@
+import { UseStorageInitialValue, UseStorageOptions } from '../useStorage/useStorage';
+/**
+ * @name useLocalStorage
+ * @description - Hook that manages local storage value
+ * @category Browser
+ *
+ * @browserapi localStorage https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage
+ *
+ * @template Value The type of the value
+ * @param {string} key The key of the storage
+ * @param {UseStorageInitialValue<Value>} [initialValue] The initial value of the storage
+ * @param {UseStorageOptions<Value>} [options] The options of the storage
+ *
+ * @example
+ * const { value, set, remove } = useLocalStorage('key', 'value');
+ */
+export declare const useLocalStorage: <Value>(key: string, initialValue?: UseStorageInitialValue<Value>, options?: Omit<UseStorageOptions<Value>, "initialValue" | "storage">) => {
+    value: Value | undefined;
+    set: (value: Value) => void;
+    remove: () => void;
+};

package/dist/types/hooks/useLockCallback/useLockCallback.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @name useLockCallback
+ * @description - Hook that prevents a callback from being executed multiple times simultaneously
+ * @category Utilities
+ *
+ * @param {Function} callback The callback to be locked
+ * @returns {Function} The locked callback
+ *
+ * @example
+ * const lockedCallback = useLockCallback(() => promise());
+ */
+export declare const useLockCallback: <Callback extends (...args: any[]) => any>(callback: Callback) => (...args: Parameters<Callback>) => Promise<any>;

package/dist/types/hooks/useLogger/useLogger.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @name useLogger
+ * @description - Hook for debugging lifecycle
+ * @category Lifecycle
+ *
+ * @param {string} name The name or identifier for the logger
+ * @param {unknown[]} params Additional arguments to be logged
+ *
+ * @example
+ * useLogger('Component', [1, 2, 3]);
+ */
+export declare const useLogger: (name: string, params: unknown[]) => void;

package/dist/types/hooks/useLongPress/useLongPress.d.ts

@@ -0,0 +1,38 @@
+import { MouseEventHandler, RefObject, TouchEventHandler } from 'react';
+export type UseLongPressTarget = (() => Element) | Element | RefObject<Element | null | undefined>;
+export type LongPressReactEvents<Target extends Element = Element> = MouseEventHandler<Target> | TouchEventHandler<Target>;
+export interface UseLongPressOptions {
+    threshold?: number;
+    onCancel?: (event: LongPressReactEvents) => void;
+    onFinish?: (event: LongPressReactEvents) => void;
+    onStart?: (event: LongPressReactEvents) => void;
+}
+export interface UseLongPressBind {
+    /** The callback function to be invoked on mouse down */
+    onMouseDown: MouseEventHandler<Element>;
+    /** The callback function to be invoked on mouse up */
+    onMouseUp: MouseEventHandler<Element>;
+    /** The callback function to be invoked on touch end */
+    onTouchEnd: TouchEventHandler<Element>;
+    /** The callback function to be invoked on touch start */
+    onTouchStart: TouchEventHandler<Element>;
+}
+export type UseLongPressReturn = [UseLongPressBind, boolean];
+/**
+ * @name useLongPress
+ * @description - Hook that defines the logic when long pressing an element
+ * @category Sensors
+ *
+ * @template Target The target element
+ * @param {Target} target The target element to be long pressed
+ * @param {(event: Event) => void} callback The callback function to be invoked on long press
+ * @param {number} [options.threshold=400] The threshold time in milliseconds
+ * @param {(event: Event) => void} [options.onStart] The callback function to be invoked on long press start
+ * @param {(event: Event) => void} [options.onFinish] The callback function to be invoked on long press finish
+ * @param {(event: Event) => void} [options.onCancel] The callback function to be invoked on long press cancel
+ * @returns {UseLongPressReturn<Target>} The ref of the target element
+ *
+ * @example
+ * const [bind, longPressing] = useLongPress(() => console.log('callback'));
+ */
+export declare const useLongPress: (callback: (event: LongPressReactEvents) => void, options?: UseLongPressOptions) => UseLongPressReturn;

package/dist/types/hooks/useMap/useMap.d.ts

@@ -0,0 +1,30 @@
+/** The use map return type */
+export interface UseMapReturn<Key, Value> {
+    /** The size of the map */
+    size: number;
+    /** The current map */
+    value: Map<Key, Value>;
+    /** Function to clear the map */
+    clear: () => void;
+    /** Function to check if a value exists in the map */
+    has: (key: Key) => boolean;
+    /** Function to remove a value from the map */
+    remove: (key: Key) => void;
+    /** Function to toggle a value in the map */
+    reset: () => void;
+    /** Function to add a value to the map */
+    set: (key: Key, value: Value) => void;
+}
+/**
+ * @name useMap
+ * @description - Hook that manages a map structure
+ * @category Utilities
+ *
+ * @template Value The type of the value
+ * @param {Value[]} [values] The initial array of the map
+ * @returns {UseMapReturn<Key, Value>} An object containing the current map and functions to interact with the map
+ *
+ * @example
+ * const { value, set, remove, clear, reset, size, has } = useMap([1, 'one'], [2, 'two']);
+ */
+export declare const useMap: <Key, Value>(values?: [Key, Value][]) => UseMapReturn<Key, Value>;

package/dist/types/hooks/useMeasure/useMeasure.d.ts

@@ -0,0 +1,30 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The use measure return type */
+export type UseMeasureReturn = Pick<DOMRectReadOnly, 'bottom' | 'height' | 'left' | 'right' | 'top' | 'width' | 'x' | 'y'>;
+export interface UseMeasure {
+    (target: HookTarget): UseMeasureReturn;
+    <Target extends Element>(target?: never): UseMeasureReturn & {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name useMeasure
+ * @description - Hook to measure the size and position of an element
+ * @category Browser
+ *
+ * @overload
+ * @param {HookTarget} target The element to measure
+ * @returns {UseMeasureReturn} The element's size and position
+ *
+ * @example
+ * const { x, y, width, height, top, left, bottom, right } = useMeasure(ref);
+ *
+ * @overload
+ * @template Target The element to measure
+ * @returns {UseMeasureReturn & { ref: StateRef<Target> }} The element's size and position
+ *
+ * @example
+ * const { ref, x, y, width, height, top, left, bottom, right } = useMeasure();
+ */
+export declare const useMeasure: UseMeasure;

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

@@ -0,0 +1,14 @@
+/**
+ * @name useMediaQuery
+ * @description - Hook that manages a media query
+ * @category Browser
+ *
+ * @browserapi window.matchMedia https://developer.mozilla.org/en-US/docs/Web/API/Window/matchMedia
+ *
+ * @param {string} query The media query string
+ * @returns {boolean} A boolean indicating if the media query matches
+ *
+ * @example
+ * const matches = useMediaQuery('(max-width: 768px)');
+ */
+export declare const useMediaQuery: (query: string) => boolean;

package/dist/types/hooks/useMemory/useMemory.d.ts

@@ -0,0 +1,29 @@
+declare global {
+    interface Performance {
+        memory: {
+            readonly jsHeapSizeLimit: number;
+            readonly totalJSHeapSize: number;
+            readonly usedJSHeapSize: number;
+        };
+    }
+}
+/** The use memory return type */
+export interface UseMemoryReturn {
+    /** The memory supported status */
+    supported: boolean;
+    /** The current memory usage */
+    value: Performance['memory'];
+}
+/**
+ * @name useMemory
+ * @description - Hook that gives you current memory usage
+ * @category Browser
+ *
+ * @browserapi performance.memory https://developer.mozilla.org/en-US/docs/Web/API/Performance/memory
+ *
+ * @returns {UseMemoryReturn} An object containing the current memory usage
+ *
+ * @example
+ * const { supported, value } = useMemory();
+ */
+export declare const useMemory: () => UseMemoryReturn;

package/dist/types/hooks/useMount/useMount.d.ts

@@ -0,0 +1,12 @@
+import { EffectCallback } from 'react';
+/**
+ * @name useMount
+ * @description - Hook that executes a callback when the component mounts
+ * @category Lifecycle
+ *
+ * @param {EffectCallback} effect The callback to execute
+ *
+ * @example
+ * useMount(() => console.log('This effect runs on the initial render'));
+ */
+export declare const useMount: (effect: EffectCallback) => void;

package/dist/types/hooks/useMouse/useMouse.d.ts

@@ -0,0 +1,45 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The use mouse return type */
+export interface UseMouseReturn {
+    /** The current element */
+    element?: Element;
+    /** The current element position x */
+    elementPositionX: number;
+    /** The current element position y */
+    elementPositionY: number;
+    /** The current element x position */
+    elementX: number;
+    /** The current element y position */
+    elementY: number;
+    /** The current mouse x position */
+    x: number;
+    /** The current mouse y position */
+    y: number;
+}
+export interface UseMouse {
+    (target: HookTarget): UseMouseReturn;
+    <Target extends Element>(target?: never): UseMouseReturn & {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name useMouse
+ * @description - Hook that manages a mouse position
+ * @category Sensors
+ *
+ * @overload
+ * @param {HookTarget} target The target element to manage the mouse position for
+ * @returns {UseMouseReturn} An object with the current mouse position
+ *
+ * @example
+ * const { x, y, elementX, elementY, elementPositionX, elementPositionY } = useMouse(ref);
+ *
+ * @overload
+ * @template Target The target element
+ * @returns {UseMouseReturn & { ref: StateRef<Target> }} An object with the current mouse position and a ref
+ *
+ * @example
+ * const { ref, x, y, elementX, elementY, elementPositionX, elementPositionY } = useMouse();
+ */
+export declare const useMouse: UseMouse;