@siberiacancode/reactuse 0.0.112 → 0.0.113

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

@@ -0,0 +1,46 @@
+import { ComponentProps } from 'react';
+export interface UseFileDialogOptions extends Pick<ComponentProps<'input'>, 'accept' | 'multiple'> {
+    /** The capture value */
+    capture?: string;
+    /** The reset value */
+    reset?: boolean;
+}
+export interface UseFileDialogReturn {
+    /** The selected files */
+    value: FileList | null;
+    /** The open function */
+    open: (openParams?: UseFileDialogOptions) => void;
+    /** The reset function */
+    reset: () => void;
+}
+export interface UseFileDialog {
+    (callback?: (value: FileList | null) => void, options?: UseFileDialogOptions): UseFileDialogReturn;
+    (options?: UseFileDialogOptions, callback?: never): UseFileDialogReturn;
+}
+/**
+ * @name useFileDialog
+ * @description - Hook to handle file input
+ * @category Browser
+ *
+ * @overload
+ * @param {(value: FileList | null) => void} callback The callback to execute when a file is selected
+ * @param {boolean} [options.multiple=true] Whether multiple files can be selected
+ * @param {string} [options.accept='*'] The accepted file types
+ * @param {boolean} [options.reset=false] Whether the input should be reset when the callback is called
+ * @param {string} [options.capture] The capture value
+ * @returns {UseFileDialogReturn} An object containing the selected files
+ *
+ * @example
+ * const { values, open, reset } = useFileDialog((value) => console.log(value));
+ *
+ * @overload
+ * @param {boolean} [options.multiple=true] Whether multiple files can be selected
+ * @param {string} [options.accept='*'] The accepted file types
+ * @param {boolean} [options.reset=false] Whether the input should be reset when the callback is called
+ * @param {string} [options.capture] The capture value
+ * @returns {UseFileDialogReturn} An object containing the selected files
+ *
+ * @example
+ * const { values, open, reset } = useFileDialog({ accept: 'image/*' });
+ */
+export declare const useFileDialog: UseFileDialog;

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

@@ -0,0 +1,52 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The use focus options type */
+export interface UseFocusOptions {
+    /** The initial focus state of the target */
+    initialValue?: boolean;
+    /** The on blur callback */
+    onBlur?: (event: FocusEvent) => void;
+    /** The on focus callback */
+    onFocus?: (event: FocusEvent) => void;
+}
+/** The use focus return type */
+export interface UseFocusReturn {
+    /** The boolean state value of the target */
+    focused: boolean;
+    /** Blur the target */
+    blur: () => void;
+    /** Focus the target */
+    focus: () => void;
+}
+export interface UseFocus {
+    (target: HookTarget, options?: UseFocusOptions): UseFocusReturn;
+    <Target extends Element>(options?: UseFocusOptions, target?: never): UseFocusReturn & {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name useFocus
+ * @description - Hook that allows you to focus on a specific element
+ * @category Browser
+ *
+ * @overload
+ * @param {HookTarget} target The target element to focus
+ * @param {boolean} [options.initialValue=false] The initial focus state of the target
+ * @param {(event: FocusEvent) => void} [options.onFocus] The callback function to be invoked on focus
+ * @param {(event: FocusEvent) => void} [options.onBlur] The callback function to be invoked on blur
+ * @returns {UseFocusReturn} An object with focus state and methods
+ *
+ * @example
+ * const { focus, blur, focused } = useFocus(ref);
+ *
+ * @overload
+ * @template Target The target element
+ * @param {boolean} [options.initialValue=false] The initial focus state of the target
+ * @param {(event: FocusEvent) => void} [options.onFocus] The callback function to be invoked on focus
+ * @param {(event: FocusEvent) => void} [options.onBlur] The callback function to be invoked on blur
+ * @returns {UseFocusReturn & { ref: StateRef<Target> }} An object with focus state, methods and ref
+ *
+ * @example
+ * const { ref, focus, blur, focused } = useFocus();
+ */
+export declare const useFocus: UseFocus;

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

@@ -0,0 +1,13 @@
+/**
+ * @name useFps
+ * @description - Hook that measures frames per second
+ * @category Sensors
+ *
+ * @browserapi requestAnimationFrame https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame
+ *
+ * @returns {number} A number which determines frames per second
+ *
+ * @example
+ * const fps = useFps();
+ */
+export declare const useFps: () => number;

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

@@ -0,0 +1,15 @@
+/**
+ * @name useFul
+ * @description - Hook that can be so useful
+ * @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 = useFul(state);
+ */
+export declare const useFul: <Value>(value?: Value) => Value | undefined;

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

@@ -0,0 +1,54 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The use fullscreen options type */
+export interface UseFullScreenOptions {
+    /** initial value */
+    initialValue?: boolean;
+    /** on enter fullscreen */
+    onEnter?: () => void;
+    /** on exit fullscreen */
+    onExit?: () => void;
+}
+/** The use click outside return type */
+export interface UseFullScreenReturn {
+    /** The fullscreen state */
+    value: boolean;
+    /** The fullscreen enter method */
+    enter: () => void;
+    /** The fullscreen exit method */
+    exit: () => void;
+    /** The fullscreen toggle method */
+    toggle: () => void;
+}
+export interface UseFullScreen {
+    (target: HookTarget, options?: UseFullScreenOptions): UseFullScreenReturn;
+    <Target extends Element>(options?: UseFullScreenOptions, target?: never): UseFullScreenReturn & {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name useFullscreen
+ * @description - Hook to handle fullscreen events
+ * @category Browser
+ *
+ * @overload
+ * @param {HookTarget} target The target element for fullscreen
+ * @param {boolean} [options.initialValue=false] initial value of fullscreen
+ * @param {() => void} [options.onEnter] on enter fullscreen
+ * @param {() => void} [options.onExit] on exit fullscreen
+ * @returns {UseFullScreenReturn} An object with the fullscreen state and methods
+ *
+ * @example
+ * const { enter, exit, toggle, value } = useFullscreen(ref);
+ *
+ * @overload
+ * @template Target The target element for fullscreen
+ * @param {boolean} [options.initialValue=false] initial value of fullscreen
+ * @param {() => void} [options.onEnter] on enter fullscreen
+ * @param {() => void} [options.onExit] on exit fullscreen
+ * @returns {UseFullScreenReturn & { ref: RefObject<Target> }} An object with the fullscreen state and methods
+ *
+ * @example
+ * const { ref, enter, exit, toggle, value } = useFullscreen();
+ */
+export declare const useFullscreen: UseFullScreen;

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

@@ -0,0 +1,67 @@
+declare global {
+    interface Gamepad {
+        hapticActuators?: GamepadHapticActuator[];
+    }
+}
+/** The use gamepad return type  */
+export interface UseGamepadStateReturn {
+    /** The gamepad active status */
+    active: boolean;
+    /** The gamepad state */
+    gamepads: Gamepad[];
+    /** The gamepad supported status */
+    supported: boolean;
+}
+/**
+ * @name useGamepad
+ * @description - Hook for getting information about gamepad
+ * @category Browser
+ *
+ * @browserapi navigator.getGamepads https://developer.mozilla.org/en-US/docs/Web/API/Navigator/getGamepads
+ *
+ * @returns {UseGamepadStateReturn} An object containing the gamepad information
+ *
+ * @example
+ * const { supported, gamepads, active } = useGamepad();
+ */
+export declare const useGamepad: () => {
+    active: boolean;
+    supported: boolean;
+    gamepads: Gamepad[];
+};
+export declare const mapGamepadToXbox360Controller: (gamepad: Gamepad) => {
+    buttons: {
+        a: GamepadButton;
+        b: GamepadButton;
+        x: GamepadButton;
+        y: GamepadButton;
+    };
+    bumper: {
+        left: GamepadButton;
+        right: GamepadButton;
+    };
+    triggers: {
+        left: GamepadButton;
+        right: GamepadButton;
+    };
+    stick: {
+        left: {
+            horizontal: number;
+            vertical: number;
+            button: GamepadButton;
+        };
+        right: {
+            horizontal: number;
+            vertical: number;
+            button: GamepadButton;
+        };
+    };
+    dpad: {
+        up: GamepadButton;
+        down: GamepadButton;
+        left: GamepadButton;
+        right: GamepadButton;
+    };
+    back: GamepadButton;
+    start: GamepadButton;
+};

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

@@ -0,0 +1,41 @@
+/** The use geolocation return type */
+export interface UseGeolocationReturn {
+    /** The accuracy of the last position update */
+    accuracy: number | null;
+    /** The altitude of the last position update */
+    altitude: number | null;
+    /** The altitude accuracy of the last position update */
+    altitudeAccuracy: number | null;
+    /** The error of the last position update */
+    error: GeolocationPositionError | null;
+    /** The heading of the last position update */
+    heading: number | null;
+    /** The latitude of the last position update */
+    latitude: number | null;
+    /** The loading state */
+    loading: boolean;
+    /** The longitude of the last position update */
+    longitude: number | null;
+    /** The speed of the last position update */
+    speed: number | null;
+    /** The timestamp of the last position update */
+    timestamp: number | null;
+}
+/** The use geolocation params type */
+export type UseGeolocationParams = PositionOptions;
+/**
+ * @name useGeolocation
+ * @description - Hook that returns the current geolocation
+ * @category Browser
+ *
+ * @browserapi navigator.geolocation https://developer.mozilla.org/en-US/docs/Web/API/Navigator/geolocation
+ *
+ * @param {boolean} [params.enableHighAccuracy] Enable high accuracy
+ * @param {number} [params.maximumAge] Maximum age
+ * @param {number} [params.timeout] Timeout
+ * @returns {UseGeolocationReturn}
+ *
+ * @example
+ * const { loading, error, timestamp, accuracy, latitude, longitude, altitude, altitudeAccuracy, heading, speed } = useGeolocation();
+ */
+export declare const useGeolocation: (params?: UseGeolocationParams) => UseGeolocationReturn;

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

@@ -0,0 +1,14 @@
+/** The use hash return type */
+type UseHashReturn = [string, (value: string) => void];
+/**
+ * @name useHash
+ * @description - Hook that manages the hash value
+ * @category Browser
+ *
+ * @returns {UseHashReturn} An array containing the hash value and a function to set the hash value
+ *
+ * @example
+ * const [hash, setHash] = useHash();
+ */
+export declare const useHash: () => UseHashReturn;
+export {};

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

@@ -0,0 +1,58 @@
+import { StateRef } from '../useRefState/useRefState';
+/** The use hotkeys params type */
+export interface UseHotkeysOptions {
+    /** Alias map for hotkeys */
+    alias?: Record<string, string>;
+    /** Enable or disable the event listeners */
+    enabled?: boolean;
+}
+export declare const isHotkeyMatch: (hotkey: string, keys: UseHotkeysKey[]) => boolean;
+/** The hotkeys string type */
+export type UseHotkeysHotkeys = string;
+/** The hotkey key information */
+export interface UseHotkeysKey {
+    /** The alias for the key */
+    alias: string;
+    /** The key code */
+    code: string;
+    /** The key value */
+    key: string;
+}
+/** The use hotkeys target type */
+export type UseHotkeysTarget = Element | React.RefObject<Element | null | undefined>;
+export interface UseHotkeys {
+    (target: UseHotkeysTarget, hotkeys: UseHotkeysHotkeys, callback: (event: KeyboardEvent) => void, options?: UseHotkeysOptions): void;
+    <Target extends Element>(hotkeys: UseHotkeysHotkeys, callback: (event: KeyboardEvent) => void, options?: UseHotkeysOptions, target?: never): StateRef<Target>;
+}
+/**
+ * @name useHotkeys
+ * @description - Hook that listens for hotkeys
+ * @category Sensors
+ *
+ * @overload
+ * @param {HookTarget} [target=window] The target element to attach the event listener to
+ * @param {string} hotkeys The hotkey to listen for
+ * @param {(event: KeyboardEvent) => void} callback The callback function to execute when hotkey is pressed
+ * @param {Record<string, string>} [options.alias] Alias map for hotkeys
+ * @param {boolean} [options.enabled=true] Enable or disable the event listeners
+ * @returns {void}
+ *
+ * @example
+ * useHotkeys(ref, 'ctrl+a', () => console.log('hotkey pressed'));
+ * @example
+ * useHotkeys(ref, 'ctrl+a, ctrl+b', () => console.log('hotkey pressed'));
+ *
+ * @overload
+ * @template Target The target element
+ * @param {string} hotkeys The hotkey to listen for
+ * @param {(event: KeyboardEvent) => void} callback The callback function to execute when hotkey is pressed
+ * @param {Record<string, string>} [options.alias] Alias map for hotkeys
+ * @param {boolean} [options.enabled=true] Enable or disable the event listeners
+ * @returns {StateRef<Target>} A reference to the target element
+ *
+ * @example
+ * const ref = useHotkeys('ctrl+a', () => console.log('hotkey pressed'));
+ * @example
+ * const ref = useHotkeys('ctrl+a, ctrl+b', () => console.log('hotkey pressed'));
+ */
+export declare const useHotkeys: UseHotkeys;

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

@@ -0,0 +1,55 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The use hover options type */
+export interface UseHoverOptions {
+    /** The on entry callback */
+    onEntry?: (event: Event) => void;
+    /** The on leave callback */
+    onLeave?: (event: Event) => void;
+}
+export interface UseHover {
+    (target: HookTarget, callback?: (event: Event) => void): boolean;
+    (target: HookTarget, options?: UseHoverOptions): boolean;
+    <Target extends Element>(callback?: (event: Event) => void, target?: never): [StateRef<Target>, boolean];
+    <Target extends Element>(options?: UseHoverOptions, target?: never): [StateRef<Target>, boolean];
+}
+/**
+ * @name useHover
+ * @description - Hook that defines the logic when hovering an element
+ * @category Sensors
+ *
+ * @overload
+ * @param {HookTarget} target The target element to be hovered
+ * @param {(event: Event) => void} [callback] The callback function to be invoked on mouse enter
+ * @returns {boolean} The state of the hover
+ *
+ * @example
+ * const hovering = useHover(ref, () => console.log('callback'));
+ *
+ * @overload
+ * @param {HookTarget} target The target element to be hovered
+ * @param {(event: Event) => void} [options.onEntry] The callback function to be invoked on mouse enter
+ * @param {(event: Event) => void} [options.onLeave] The callback function to be invoked on mouse leave
+ * @returns {boolean} The state of the hover
+ *
+ * @example
+ * const hovering = useHover(ref, options);
+ *
+ * @overload
+ * @template Target The target element
+ * @param {(event: Event) => void} [callback] The callback function to be invoked on mouse enter
+ * @returns {UseHoverReturn<Target>} The state of the hover
+ *
+ * @example
+ * const [ref, hovering] = useHover(() => console.log('callback'));
+ *
+ * @overload
+ * @template Target The target element
+ * @param {(event: Event) => void} [options.onEntry] The callback function to be invoked on mouse enter
+ * @param {(event: Event) => void} [options.onLeave] The callback function to be invoked on mouse leave
+ * @returns {UseHoverReturn<Target>} The state of the hover
+ *
+ * @example
+ * const [ref, hovering] = useHover(options);
+ */
+export declare const useHover: UseHover;

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

@@ -0,0 +1,28 @@
+/** The use idle options type */
+export interface UseIdleOptions {
+    /** The idle events */
+    events?: Array<keyof DocumentEventMap>;
+    /** The idle state */
+    initialValue?: boolean;
+}
+/** The use idle return type */
+export interface UseIdleReturn {
+    /** The idle state */
+    idle: boolean;
+    /** The last active time */
+    lastActive: number;
+}
+/**
+ * @name useIdle
+ * @description - Hook that defines the logic when the user is idle
+ * @category Sensors
+ *
+ * @param {number} [milliseconds=ONE_MINUTE] The idle time in milliseconds
+ * @param {boolean} [options.initialState=false] The options for the hook
+ * @param {Array<keyof WindowEventMap>} [options.events=IDLE_EVENTS]
+ * @returns {UseIdleReturn} An object containing the idle state and the last active time
+ *
+ * @example
+ * const { idle, lastActive } = useIdle();
+ */
+export declare const useIdle: (milliseconds?: number, { initialValue, events }?: UseIdleOptions) => UseIdleReturn;

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

@@ -0,0 +1,44 @@
+import { UseQueryOptions, UseQueryReturn } from '../useQuery/useQuery';
+/** The use image options */
+export interface UseImageOptions {
+    /** The alt of the image */
+    alt?: string;
+    /** The class of the image */
+    class?: string;
+    /** The crossorigin of the image */
+    crossorigin?: string;
+    /** The loading of the image */
+    loading?: HTMLImageElement['loading'];
+    /** The referrer policy of the image */
+    referrerPolicy?: HTMLImageElement['referrerPolicy'];
+    /** The sizes of the image */
+    sizes?: string;
+    /** The srcset of the image */
+    srcset?: string;
+}
+/** The use image return type */
+export type UseImageReturn = UseQueryReturn<HTMLImageElement>;
+/**
+ * @name useImage
+ * @description - Hook that load an image in the browser
+ * @category Browser
+ *
+ * @param {string} src The source of the image
+ * @param {string} [options.srcset] The srcset of the image
+ * @param {string} [options.sizes] The sizes of the image
+ * @param {string} [options.alt] The alt of the image
+ * @param {string} [options.class] The class of the image
+ * @param {HTMLImageElement['loading']} [options.loading] The loading of the image
+ * @param {string} [options.crossorigin] The crossorigin of the image
+ * @param {HTMLImageElement['referrerPolicy']} [options.referrerPolicy] The referrerPolicy of the image
+ * @param {DependencyList} [useQueryOptions.keys] The dependencies for the hook
+ * @param {(data: Data) => void} [useQueryOptions.onSuccess] The callback function to be invoked on success
+ * @param {(error: Error) => void} [useQueryOptions.onError] The callback function to be invoked on error
+ * @param {number} [useQueryOptions.refetchInterval] The refetch interval
+ * @param {boolean | number} [useQueryOptions.retry] The retry count of requests
+ * @returns {UseImageReturn} An object with the state of the image
+ *
+ * @example
+ * const { data, isLoading, isError, isSuccess, error, refetch, isRefetching } = useImage('https://example.com/image.png');
+ */
+export declare const useImage: (src: string, options?: UseImageOptions, useQueryOptions?: Omit<UseQueryOptions<HTMLImageElement, HTMLImageElement>, "initialData" | "placeholderData" | "select">) => UseQueryReturn<HTMLImageElement>;

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

@@ -0,0 +1,42 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The use infinite scroll options type */
+export interface UseInfiniteScrollOptions {
+    /** The direction to trigger the callback */
+    direction?: 'bottom' | 'left' | 'right' | 'top';
+    /** The distance in pixels to trigger the callback */
+    distance?: number;
+}
+export interface UseInfiniteScroll {
+    (target: HookTarget, callback: (event: Event) => void, options?: UseInfiniteScrollOptions): boolean;
+    <Target extends Element>(callback: (event: Event) => void, options?: UseInfiniteScrollOptions, target?: never): {
+        ref: StateRef<Target>;
+        loading: boolean;
+    };
+}
+/**
+ * @name useInfiniteScroll
+ * @description - Hook that defines the logic for infinite scroll
+ * @category Sensors
+ *
+ * @overload
+ * @template Target The target element
+ * @param {(event: Event) => void} callback The callback to execute when a click outside the target is detected
+ * @param {number} [options.distance=10] The distance in pixels to trigger the callback
+ * @param {string} [options.direction='bottom'] The direction to trigger the callback
+ * @returns {{ ref: StateRef<Target>, loading: boolean }} An object containing the ref and loading
+ *
+ * @example
+ * const { ref, loading } = useInfiniteScroll(() => console.log('infinite scroll'));
+ *
+ * @overload
+ * @param {HookTarget} target The target element to detect infinite scroll for
+ * @param {(event: Event) => void} callback The callback to execute when a click outside the target is detected
+ * @param {number} [options.distance=10] The distance in pixels to trigger the callback
+ * @param {string} [options.direction='bottom'] The direction to trigger the callback
+ * @returns {boolean} A loading indicator of the infinite scroll
+ *
+ * @example
+ * const loading = useInfiniteScroll(ref, () => console.log('infinite scroll'));
+ */
+export declare const useInfiniteScroll: UseInfiniteScroll;

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;