@siberiacancode/reactuse 0.0.111 → 0.0.113

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;

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

@@ -0,0 +1,36 @@
+interface UseMutationOptions<Data> {
+    retry?: ((failureCount: number, error: Error) => boolean) | boolean | number;
+    retryDelay?: ((retry: number, error: Error) => number) | number;
+    onError?: (error: Error) => void;
+    onSuccess?: (data: Data) => void;
+}
+interface UseMutationReturn<Body, Data> {
+    data: Data | null;
+    error: Error | null;
+    isError: boolean;
+    isLoading: boolean;
+    isSuccess: boolean;
+    mutate: (body?: Body, options?: UseMutationOptions<Data>) => void;
+    mutateAsync: (body?: Body, options?: UseMutationOptions<Data>) => Promise<Data>;
+}
+export interface RequestOptions<Data> extends UseMutationOptions<Data> {
+    attempt?: number;
+}
+/**
+ * @name useMutation
+ * @description - Hook that defines the logic when mutate data
+ * @category Utilities
+ *
+ * @template Body The type of the body
+ * @template Data The type of the data
+ * @param {(body: Body) => Promise<Data>} callback The callback function to be invoked
+ * @param {boolean | number} [options.retry] The retry count of requests
+ * @param {(data: Data) => void} [options.onSuccess] The callback function to be invoked on success
+ * @param {(error: Error) => void} [options.onError] The callback function to be invoked on error
+ * @returns {UseMutationReturn<Data>} An object with the state of the mutation
+ *
+ * @example
+ * const { mutate, mutateAsync, isLoading, isError, isSuccess, error, data } = useMutation((name) => Promise.resolve(name));
+ */
+export declare const useMutation: <Body, Data>(callback: (body: Body) => Promise<Data>, options?: UseMutationOptions<Data>) => UseMutationReturn<Body, Data>;
+export {};

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

@@ -0,0 +1,60 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The mutation observer target element type */
+export type UseMutationObserverTarget = HookTarget;
+/** The mutation observer return type */
+export interface UseMutationObserverReturn {
+    /** The mutation observer instance */
+    observer: MutationObserver;
+    /** The mutation observer entries */
+    stop: () => void;
+}
+/** The mutation observer options type */
+export interface UseMutationObserverOptions extends MutationObserverInit {
+    /** The enabled state of the mutation observer */
+    enabled?: boolean;
+}
+export interface UseMutationObserver {
+    (target: HookTarget, callback: MutationCallback, options?: UseMutationObserverOptions): UseMutationObserverReturn;
+    <Target extends Element>(callback: MutationCallback, options?: UseMutationObserverOptions, target?: never): UseMutationObserverReturn & {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name useMutationObserver
+ * @description - Hook that gives you mutation observer state
+ * @category Browser
+ *
+ * @overload
+ * @template Target The target element
+ * @param {MutationCallback} callback The callback to execute when mutation is detected
+ * @param {boolean} [options.enabled=true] The enabled state of the mutation observer
+ * @param {boolean} [options.attributes] Set to true if mutations to target's attributes are to be observed
+ * @param {boolean} [options.characterData] Set to true if mutations to target's data are to be observed
+ * @param {boolean} [options.childList] Set to true if mutations to target's children are to be observed
+ * @param {boolean} [options.subtree]  Set to true if mutations to not just target, but also target's descendants are to be observed
+ * @param {boolean} [options.characterDataOldValue] Set to true if characterData is set to true or omitted and target's data before the mutation needs to be recorded
+ * @param {boolean} [options.attributeOldValue]  Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted
+ * @param {string[]} [options.attributeFilter] Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted
+ * @returns {UseMutationObserverReturn & { ref: StateRef<Target> }} An object containing the mutation observer state
+ *
+ * @example
+ * const { ref, observer, stop } = useMutationObserver(() => console.log('callback'))
+ *
+ * @overload
+ * @param {HookTarget} target The target element to observe
+ * @param {MutationCallback} callback The callback to execute when mutation is detected
+ * @param {boolean} [options.enabled=true] The enabled state of the mutation observer
+ * @param {boolean} [options.attributes] Set to true if mutations to target's attributes are to be observed
+ * @param {boolean} [options.characterData] Set to true if mutations to target's data are to be observed
+ * @param {boolean} [options.childList] Set to true if mutations to target's children are to be observed
+ * @param {boolean} [options.subtree]  Set to true if mutations to not just target, but also target's descendants are to be observed
+ * @param {boolean} [options.characterDataOldValue] Set to true if characterData is set to true or omitted and target's data before the mutation needs to be recorded
+ * @param {boolean} [options.attributeOldValue]  Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted
+ * @param {string[]} [options.attributeFilter] Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted
+ * @returns {UseMutationObserverReturn} An object containing the mutation observer state
+ *
+ * @example
+ * const { observer, stop } = useMutationObserver(ref, () => console.log('callback'))
+ */
+export declare const useMutationObserver: UseMutationObserver;

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

@@ -0,0 +1,51 @@
+export interface Connection extends EventTarget {
+    readonly downlink: number;
+    readonly downlinkMax: number;
+    readonly effectiveType: '2g' | '3g' | '4g' | 'slow-2g';
+    readonly rtt: number;
+    readonly saveData: boolean;
+    onChange: (event: Event) => void;
+    readonly type: 'bluetooth' | 'cellular' | 'ethernet' | 'mixed' | 'none' | 'other' | 'unknown' | 'wifi' | 'wimax';
+}
+declare global {
+    interface Navigator {
+        readonly connection: Connection;
+        readonly mozConnection: Connection;
+        readonly webkitConnection: Connection;
+    }
+}
+/** The type of network connection */
+export type ConnectionType = Connection['type'];
+/** The effective type of connection */
+export type ConnectionEffectiveType = Connection['effectiveType'];
+/** The use network return type */
+export interface UseNetworkReturn {
+    /** The estimated downlink speed in megabits per seconds */
+    downlink?: Connection['downlink'];
+    /** The maximum downlink speed, if available */
+    downlinkMax?: Connection['downlinkMax'];
+    /** The effective type of connection (e.g., '2g', '3g', '4g') */
+    effectiveType?: Connection['effectiveType'];
+    /** Indicates if the device is currently online */
+    online: boolean;
+    /** The estimated round-trip time in milliseconds */
+    rtt?: Connection['rtt'];
+    /** Indicates if the user has enabled data saving mode */
+    saveData?: Connection['saveData'];
+    /** The type of network connection (e.g., 'wifi', 'cellular') */
+    type?: Connection['type'];
+}
+export declare const getConnection: () => Connection;
+/**
+ * @name useNetwork
+ * @description - Hook to track network status
+ * @category Sensors
+ *
+ * @browserapi navigator.connection https://developer.mozilla.org/en-US/docs/Web/API/Navigator/connection
+ *
+ * @returns {UseNetworkReturn} An object containing the network status
+ *
+ * @example
+ * const { online, downlink, downlinkMax, effectiveType, rtt, saveData, type } = useNetwork();
+ */
+export declare const useNetwork: () => UseNetworkReturn;