@siberiacancode/reactuse 0.0.111 → 0.0.113

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

@@ -0,0 +1,37 @@
+export interface UseRafParams {
+    /** The delta between each frame in milliseconds */
+    delta: number;
+    /** The timestamp of the current frame in milliseconds */
+    timestamp: DOMHighResTimeStamp;
+}
+export type UseRafCallback = (params: UseRafParams) => void;
+export interface UseRafOptions {
+    /** The delay between each frame in milliseconds */
+    delay?: number;
+    /** Whether the callback should be enabled */
+    enabled?: boolean;
+}
+export interface UseRafReturn {
+    /** Whether the callback is active */
+    active: boolean;
+    /** Function to pause the callback */
+    pause: () => void;
+    /** Function to resume the callback */
+    resume: () => void;
+}
+/**
+ * @name useRaf
+ * @description - Hook that defines the logic for raf callback
+ * @category Utilities
+ *
+ * @browserapi requestAnimationFrame https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame
+ *
+ * @param {UseRafCallback} callback The callback to execute
+ * @param {number} [options.delay] The delay between each frame in milliseconds
+ * @param {boolean} [options.enabled=true] Whether the callback should be enabled
+ * @returns {UseRafCallbackReturn} An object of raf callback functions
+ *
+ * @example
+ * useRaf(() => console.log('callback'));
+ */
+export declare const useRaf: (callback: UseRafCallback, options?: UseRafOptions) => UseRafReturn;

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

@@ -0,0 +1,14 @@
+export type UseRafValueReturn<Value> = [Value, (value: Value) => void];
+/**
+ * @name useRafValue
+ * @description - Hook that returns the value and a function to set the value
+ * @category Utilities
+ *
+ * @template Value The type of the value
+ * @param {Value} initialValue The initial value
+ * @returns {UseRafValueReturn<Value>} An array containing the value and a function to set the value
+ *
+ * @example
+ * const [value, setValue] = useRafValue(initialValue);
+ */
+export declare const useRafValue: <Value>(initialValue: (() => Value) | Value) => readonly [Value, (value: Value) => void];

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

@@ -0,0 +1,18 @@
+export interface StateRef<Value> {
+    (node: Value): void;
+    current: Value;
+    state?: Value;
+}
+/**
+ * @name useRefState
+ * @description - Hook that returns the state reference of the value
+ * @category Utilities
+ *
+ * @template Value The type of the value
+ * @param {Value} [initialValue] The initial value
+ * @returns {StateRef<Value>} The current value
+ *
+ * @example
+ * const internalRefState = useRefState();
+ */
+export declare const useRefState: <Value>(initialValue?: Value) => StateRef<Value>;

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

@@ -0,0 +1,11 @@
+/**
+ * @name useRenderCount
+ * @description - Hook returns count component render times
+ * @category Lifecycle
+ *
+ * @returns {number} A number which determines how many times component renders
+ *
+ * @example
+ * const renderCount = useRenderCount();
+ */
+export declare const useRenderCount: () => number;

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

@@ -0,0 +1,19 @@
+export interface UseRenderInfoReturn {
+    component: string;
+    renders: number;
+    sinceLast: number;
+    timestamp: number | null;
+}
+/**
+ * @name useRenderInfo
+ * @description - Hook for getting information about component rerender
+ * @category Lifecycle
+ *
+ * @param {string} [name='Unknown'] Component name
+ * @param {boolean} [log=true] Toggle logging
+ * @returns {UseRenderInfoReturn} An object containing rerender information
+ *
+ * @example
+ * const rerenderInfo = useRenderInfo('Component');
+ */
+export declare const useRenderInfo: (name?: string, log?: boolean) => UseRenderInfoReturn;

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

@@ -0,0 +1,14 @@
+/** The use rerender return type */
+type UseRerenderReturn = () => void;
+/**
+ * @name useRerender
+ * @description - Hook that defines the logic to force rerender a component
+ * @category Lifecycle
+ *
+ * @returns {UseRerenderReturn} The rerender function
+ *
+ * @example
+ * const rerender = useRerender();
+ */
+export declare const useRerender: () => UseRerenderReturn;
+export {};

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

@@ -0,0 +1,49 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The resize observer options type */
+export interface UseResizeObserverOptions extends ResizeObserverOptions {
+    /** The enabled state */
+    enabled?: boolean;
+    /** The resize observer callback */
+    onChange?: (entries: ResizeObserverEntry[], observer: ResizeObserver) => void;
+}
+/** The resize observer return type */
+export interface UseResizeObserverReturn {
+    /** The resize observer entries */
+    entries: ResizeObserverEntry[];
+}
+export interface UseResizeObserver {
+    (target: HookTarget, options?: UseResizeObserverOptions): UseResizeObserverReturn;
+    <Target extends Element>(options?: UseResizeObserverOptions, target?: never): UseResizeObserverReturn & {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ *  @name useResizeObserver
+ *  @description - Hook that gives you resize observer state
+ *  @category Browser
+ *
+ *  @browserapi ResizeObserver https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
+ *
+ *  @overload
+ *  @template Target The target element
+ *  @param {boolean} [options.enabled=true] The IntersectionObserver options
+ *  @param {boolean} [options.box] The IntersectionObserver options
+ *  @param {(entries: ResizeObserverEntry[], observer: ResizeObserver) => void} [options.onChange] The callback to execute when resize is detected
+ *  @returns {UseResizeObserverReturn & { ref: StateRef<Target> }} An object containing the resize observer state
+ *
+ *  @example
+ *  const { ref, entries } = useResizeObserver();
+ *
+ *  @overload
+ *  @template Target The target element
+ *  @param {HookTarget} target The target element to observe
+ *  @param {boolean} [options.enabled=true] The IntersectionObserver options
+ *  @param {boolean} [options.box] The IntersectionObserver options
+ *  @param {(entries: ResizeObserverEntry[], observer: ResizeObserver) => void} [options.onChange] The callback to execute when resize is detected
+ *  @returns {UseResizeObserverReturn} An object containing the resize observer state
+ *
+ *  @example
+ *  const { entries } = useResizeObserver(ref);
+ */
+export declare const useResizeObserver: UseResizeObserver;

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

@@ -0,0 +1,35 @@
+declare global {
+    interface ScreenOrientation {
+        lock: (orientation: OrientationLockType) => Promise<void>;
+    }
+}
+export interface UseScreenOrientationValue {
+    /** The current angle */
+    angle: number;
+    /** The current orientation type */
+    orientationType: OrientationType;
+}
+export type OrientationLockType = 'any' | 'landscape-primary' | 'landscape-secondary' | 'landscape' | 'natural' | 'portrait-primary' | 'portrait-secondary' | 'portrait';
+export interface useScreenOrientationReturn {
+    /** Whether the screen orientation is supported */
+    supported: boolean;
+    /** The current screen orientation value */
+    value: UseScreenOrientationValue;
+    /** Lock the screen orientation */
+    lock: (orientation: OrientationLockType) => void;
+    /** Unlock the screen orientation */
+    unlock: () => void;
+}
+/**
+ * @name useScreenOrientation
+ * @description - Hook that provides the current screen orientation
+ * @category Sensors
+ *
+ * @browserapi screen.orientation https://developer.mozilla.org/en-US/docs/Web/API/Screen/orientation
+ *
+ * @returns {useScreenOrientationReturn} The current screen orientation
+ *
+ * @example
+ * const { supported, value, lock, unlock } = useScreenOrientation();
+ */
+export declare const useScreenOrientation: () => useScreenOrientationReturn;

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

@@ -0,0 +1,24 @@
+import { ComponentProps } from 'react';
+/** The use script status */
+export type UseScriptStatus = 'error' | 'loading' | 'ready' | 'unknown';
+export declare const SCRIPT_STATUS_ATTRIBUTE_NAME = "script-status";
+/** The use script options extends from attributes script tag */
+export interface UseScriptOptions extends ComponentProps<'script'> {
+    /** Whether to remove the script on unmount */
+    removeOnUnmount?: boolean;
+}
+/**
+ * @name useScript
+ * @description - Hook that manages a script with onLoad, onError, and removeOnUnmount functionalities
+ * @category Browser
+ *
+ * @param {string} src The source of the script
+ * @param {UseScriptOptions} [options] The options of the script extends from attributes script tag
+ * @param {boolean} [options.removeOnUnmount=true] Whether to remove the script on unmount
+ * @param {boolean} [options.async=true] Whether to load the script asynchronously
+ * @returns {UseScriptStatus} The status of the script
+ *
+ * @example
+ * const status = useScript('https://example.com/script.js');
+ */
+export declare const useScript: (src: string, options?: UseScriptOptions) => UseScriptStatus;

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

@@ -0,0 +1,99 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+export interface UseScrollOptions {
+    /** The on scroll callback */
+    onScroll?: (params: UseScrollCallbackParams, event: Event) => void;
+    /** The on end scroll callback */
+    onStop?: (event: Event) => void;
+    /** Offset arrived states by x pixels. */
+    offset?: {
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    };
+}
+export interface UseScrollCallbackParams {
+    /** The element x position */
+    x: number;
+    /** The element y position */
+    y: number;
+    /** State of scroll arrived */
+    arrived: {
+        left: boolean;
+        right: boolean;
+        top: boolean;
+        bottom: boolean;
+    };
+    /** State of scroll direction */
+    directions: {
+        left: boolean;
+        right: boolean;
+        top: boolean;
+        bottom: boolean;
+    };
+}
+export interface UseScroll {
+    (target: HookTarget, callback?: (params: UseScrollCallbackParams, event: Event) => void): boolean;
+    (target: HookTarget, options?: UseScrollOptions): boolean;
+    <Target extends Element>(callback?: (params: UseScrollCallbackParams, event: Event) => void, target?: never): {
+        ref: StateRef<Target>;
+        scrolling: boolean;
+    };
+    <Target extends Element>(options?: UseScrollOptions, target?: never): {
+        ref: StateRef<Target>;
+        scrolling: boolean;
+    };
+}
+/**
+ * @name useScroll
+ * @description - Hook that allows you to control scroll a element
+ * @category Sensors
+ *
+ * @overload
+ * @template Target The target element
+ * @param {ScrollBehavior} [options.behavior=auto] The behavior of scrolling
+ * @param {number} [options.offset.left=0] The left offset for arrived states
+ * @param {number} [options.offset.right=0]  The right offset for arrived states
+ * @param {number} [options.offset.top=0] The top offset for arrived states
+ * @param {number} [options.offset.bottom=0] The bottom offset for arrived states
+ * @param {(params: UseScrollCallbackParams, event: Event) => void} [options.onScroll] The callback function to be invoked on scroll
+ * @param {(event: Event) => void} [options.onStop] The callback function to be invoked on scroll end
+ * @returns {boolean} The state of scrolling
+ *
+ * @example
+ * const scrolling = useScroll(ref, options);
+ *
+ * @overload
+ * @template Target The target element
+ * @param {(params: UseScrollCallbackParams, event: Event) => void} [callback] The callback function to be invoked on scroll
+ * @returns {boolean} The state of scrolling
+ *
+ * @example
+ * const scrolling = useScroll(ref, () => console.log('callback'));
+ *
+ * @overload
+ * @template Target The target element
+ * @param {Target} target The target element to scroll
+ * @param {ScrollBehavior} [options.behavior=auto] The behavior of scrolling
+ * @param {number} [options.offset.left=0] The left offset for arrived states
+ * @param {number} [options.offset.right=0]  The right offset for arrived states
+ * @param {number} [options.offset.top=0] The top offset for arrived states
+ * @param {number} [options.offset.bottom=0] The bottom offset for arrived states
+ * @param {(params: UseScrollCallbackParams, event: Event) => void} [options.onScroll] The callback function to be invoked on scroll
+ * @param {(event: Event) => void} [options.onStop] The callback function to be invoked on scroll end
+ * @returns {[StateRef<Target>, boolean]} The state of scrolling
+ *
+ * @example
+ * const { ref, scrolling } = useScroll(options);
+ *
+ * @overload
+ * @template Target The target element
+ * @param {Target} target The target element to scroll
+ * @param {(params: UseScrollCallbackParams, event: Event) => void} [callback] The callback function to be invoked on scroll
+ * @returns {[StateRef<Target>, boolean]} The state of scrolling
+ *
+ * @example
+ * const { ref, scrolling } = useScroll(() => console.log('callback'));
+ */
+export declare const useScroll: UseScroll;

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

@@ -0,0 +1,48 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The scroll into view options type */
+export interface UseScrollIntoViewOptions extends ScrollIntoViewOptions {
+    /** Whether to enable the scroll into view */
+    enabled?: boolean;
+}
+/** The scroll into view return type */
+export interface UseScrollIntoViewReturn {
+    /** Function to scroll element into view */
+    trigger: (params?: {
+        behavior?: ScrollBehavior;
+        block?: ScrollLogicalPosition;
+        inline?: ScrollLogicalPosition;
+    }) => void;
+}
+export interface UseScrollIntoView {
+    <Target extends Element>(options?: UseScrollIntoViewOptions, target?: never): UseScrollIntoViewReturn & {
+        ref: StateRef<Target>;
+    };
+    (target: HookTarget, options?: UseScrollIntoViewOptions): UseScrollIntoViewReturn;
+}
+/**
+ * @name useScrollIntoView
+ * @description - Hook that provides functionality to scroll an element into view
+ * @category Sensors
+ *
+ * @overload
+ * @param {HookTarget} target The target element to scroll into view
+ * @param {ScrollBehavior} [options.behavior='smooth'] The scrolling behavior
+ * @param {ScrollLogicalPosition} [options.block='start'] The vertical alignment
+ * @param {ScrollLogicalPosition} [options.inline='nearest'] The horizontal alignment
+ * @returns {UseScrollIntoViewReturn} Object containing scroll function
+ *
+ * @example
+ * const { trigger } = useScrollIntoView(ref);
+ *
+ * @overload
+ * @template Target The target element
+ * @param {ScrollBehavior} [options.behavior='smooth'] The scrolling behavior
+ * @param {ScrollLogicalPosition} [options.block='start'] The vertical alignment
+ * @param {ScrollLogicalPosition} [options.inline='nearest'] The horizontal alignment
+ * @returns {UseScrollIntoViewReturn & { ref: StateRef<Target> }} Object containing scroll function and ref
+ *
+ * @example
+ * const { ref, trigger } = useScrollIntoView<HTMLDivElement>();
+ */
+export declare const useScrollIntoView: UseScrollIntoView;

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

@@ -0,0 +1,50 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The use scroll to options type */
+export interface UseScrollToOptions {
+    /** The scrolling behavior */
+    behavior?: ScrollBehavior;
+    /** Whether to enable the scroll to */
+    enabled?: boolean;
+    /** The horizontal position to scroll to */
+    x: number;
+    /** The vertical position to scroll to */
+    y: number;
+}
+/** The use scroll to return type */
+export interface UseScrollToReturn {
+    /** The state of scrolling */
+    trigger: (params?: {
+        x: number;
+        y: number;
+        behavior?: ScrollBehavior;
+    }) => void;
+}
+export interface UseScrollTo {
+    <Target extends Element>(options?: UseScrollToOptions, target?: never): UseScrollToReturn & {
+        ref: StateRef<Target>;
+    };
+    (target: HookTarget, options?: UseScrollToOptions): UseScrollToReturn;
+}
+/**
+ * @name useScrollTo
+ * @description - Hook for scrolling to a specific element
+ * @category Sensors
+ *
+ * @overload
+ * @param {HookTarget} target The target element for scrolling to
+ * @param {UseScrollToOptions} [options] The scroll options
+ * @returns {UseScrollToReturn} The scroll trigger function
+ *
+ * @example
+ * const trigger = useScrollTo(ref, options);
+ *
+ * @overload
+ * @template Target The target element
+ * @param {UseScrollToOptions} [options] The scroll options
+ * @returns {UseScrollToReturn & { ref: StateRef<Target> }} The scroll trigger function and ref
+ *
+ * @example
+ * const { ref, trigger } = useScrollTo(options);
+ */
+export declare const useScrollTo: UseScrollTo;

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

@@ -0,0 +1,21 @@
+import { UseStorageInitialValue, UseStorageOptions } from '../useStorage/useStorage';
+/**
+ * @name useSessionStorage
+ * @description - Hook that manages session storage value
+ * @category Browser
+ *
+ * @browserapi sessionStorage https://developer.mozilla.org/en-US/docs/Web/API/Window/sessionStorage
+ *
+ * @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 } = useSessionStorage('key', 'value');
+ */
+export declare const useSessionStorage: <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/useSet/useSet.d.ts

@@ -0,0 +1,41 @@
+/** The use set return type */
+interface UseSetReturn<Value> {
+    /** The size of the set */
+    size: number;
+    /** The current set */
+    value: Set<Value>;
+    /** Function to add a value to the set */
+    add: (value: Value) => void;
+    /** Function to clear the set */
+    clear: () => void;
+    /** Function to get the symmetric difference of two sets */
+    difference: (other: Set<Value>) => void;
+    /** Function to check if a value exists in the set */
+    has: (value: Value) => boolean;
+    /** Function to get the difference of two sets */
+    intersection: (other: Set<Value>) => void;
+    /** Function to remove a value from the set */
+    remove: (value: Value) => void;
+    /** Function to toggle a value in the set */
+    reset: () => void;
+    /** Function to get the symmetric difference of two sets */
+    symmetricDifference: (other: Set<Value>) => void;
+    /** Function to toggle a value in the set */
+    toggle: (value: Value) => void;
+    /** Function to get the union of two sets */
+    union: (other: Set<Value>) => void;
+}
+/**
+ * @name useSet
+ * @description - Hook that manages a set structure
+ * @category Utilities
+ *
+ * @template Value The type of the value
+ * @param {Value[]} [values] The initial array of the set
+ * @returns {UseSetReturn<Value>} An object containing the current set and functions to interact with the set
+ *
+ * @example
+ * const { value, add, remove, clear, reset, toggle, union, intersection, difference, symmetricDifference, size, has } = useSet([1, 2, 3]);
+ */
+export declare const useSet: <Value>(values?: Value[]) => UseSetReturn<Value>;
+export {};

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

@@ -0,0 +1,33 @@
+/** The use share options type */
+export interface UseShareParams {
+    /** Array of files to be shared */
+    files?: File[];
+    /** Text content to be shared */
+    text?: string;
+    /** Title of the content being shared */
+    title?: string;
+    /** URL link to be shared */
+    url?: string;
+}
+/** The use share return type */
+export interface UseShareReturn {
+    /** Whether the Web Share API is supported in the current environment */
+    supported: boolean;
+    /** Function to trigger the native share dialog */
+    share: (shareParams: ShareData) => Promise<void>;
+}
+/**
+ * @name useShare
+ * @description - Hook that utilizes the share api
+ * @category Browser
+ *
+ * @param {UseShareParams} [params] The use share options
+ * @returns {UseShareReturn}
+ *
+ * @example
+ * const { share, supported } = useShare();
+ */
+export declare const useShare: (params?: UseShareParams) => {
+    share: (shareParams: ShareData) => Promise<void>;
+    supported: boolean;
+};

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

@@ -0,0 +1,33 @@
+/** The use state history hook return type */
+interface UseStateHistoryReturn<Value> {
+    /** All history values */
+    history: Value[];
+    /** Current index in history */
+    index: number;
+    /** Current value */
+    value: Value;
+    /** Go back specified number of steps in history (default: 1) */
+    back: (steps?: number) => void;
+    /** Go forward specified number of steps in history (default: 1) */
+    forward: (steps?: number) => void;
+    /** Reset history to initial state */
+    reset: () => void;
+    /** Set a new value */
+    set: (value: Value) => void;
+    /** Undo the last change */
+    undo: () => void;
+}
+/**
+ * @name useStateHistory
+ * @description - Hook that manages state with history functionality
+ * @category Utilities
+ *
+ * @param {Value} initialValue - The initial value to start the history with
+ * @param {number} [maxSize=10] - Maximum number of history entries to keep
+ * @returns {UseStateHistoryReturn<Value>} Object containing current value, history array and control methods
+ *
+ * @example
+ * const { value, history, index, set, back, forward, reset, undo } = useStateHistory(0);
+ */
+export declare const useStateHistory: <Value>(initialValue: Value, maxSize?: number) => UseStateHistoryReturn<Value>;
+export {};

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

@@ -0,0 +1,48 @@
+/** The use step params type */
+interface UseStepParams {
+    /** Initial value for step */
+    initial: number;
+    /** Maximum value for step */
+    max: number;
+}
+/** The use step return type */
+interface UseStepReturn {
+    /** Counts of steps */
+    counts: number;
+    /** Current value of step */
+    currentStep: number;
+    /** Boolean value if current step is first */
+    isFirst: boolean;
+    /** Boolean value if current step is last */
+    isLast: boolean;
+    /** Go to back step */
+    back: () => void;
+    /** Go to next step */
+    next: () => void;
+    /** Reset current step to initial value */
+    reset: () => void;
+    /** Go to custom step */
+    set: (value: number | 'first' | 'last') => void;
+}
+/**
+ * @name useStep
+ * @description - Hook that create stepper
+ * @category Utilities
+ *
+ * @overload
+ * @param {number} max Maximum number of steps
+ * @returns {UseStepReturn} An object contains variables and functions to change the step
+ *
+ * @example
+ * const stepper = useStep(5);
+ *
+ * @overload
+ * @param {number} params.max Maximum number of steps
+ * @param {number} params.initial Initial value for step
+ * @returns {UseStepReturn} An object contains variables and functions to change the step
+ *
+ * @example
+ * const stepper = useStep({ initial: 2, max: 5 });
+ */
+export declare const useStep: (params: number | UseStepParams) => UseStepReturn;
+export {};

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

@@ -0,0 +1,42 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The use sticky return type */
+export interface UseStickyReturn {
+    stuck: boolean;
+}
+/** The use sticky axis type */
+export type UseStickyAxis = 'horizontal' | 'vertical';
+/** The use sticky options type */
+export interface UseStickyOptions {
+    axis?: UseStickyAxis;
+    root?: HookTarget;
+}
+export interface UseSticky {
+    (target: HookTarget, options?: UseStickyOptions): boolean;
+    <Target extends Element>(options?: UseStickyOptions, target?: never): {
+        ref: StateRef<Target>;
+    } & UseStickyReturn;
+}
+/**
+ * @name UseSticky
+ * @description - Hook that allows you to detect that your sticky component is stuck
+ * @category Browser
+ *
+ * @overload
+ * @param {HookTarget} target The target sticky element
+ * @param {UseStickyAxis} [options.axis='vertical'] The axis of motion of the sticky component
+ * @param {UseStickyRoot} [options.root=document] The element that contains your sticky component
+ * @returns {UseStickyReturn} The state of the sticky
+ *
+ * @example
+ * const stuck  = useSticky(ref);
+ *
+ * @overload
+ * @param {UseStickyAxis} [options.axis='vertical'] The axis of motion of the sticky component
+ * @param {UseStickyRoot} [options.root=document] The element that contains your sticky component
+ * @returns {{ stickyRef: StateRef<Target> } & UseStickyReturn} The state of the sticky
+ *
+ * @example
+ * const { stuck, ref } = useSticky();
+ */
+export declare const useSticky: UseSticky;