@siberiacancode/reactuse 0.0.112 → 0.0.114

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

@@ -0,0 +1,13 @@
+/**
+ * @name usePreferredLanguages
+ * @description Hook that returns a browser preferred languages from navigator
+ * @category Browser
+ *
+ * @browserapi navigator.languages https://developer.mozilla.org/en-US/docs/Web/API/Navigator/languages
+ *
+ * @returns {readonly string[]} An array of strings representing the user's preferred languages
+ *
+ * @example
+ * const languages = usePreferredLanguages();
+ */
+export declare const usePreferredLanguages: () => readonly string[];

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

@@ -0,0 +1,13 @@
+/** The use preferred reduced motion return type */
+export type UsePreferredReducedMotionReturn = 'no-preference' | 'reduce';
+/**
+ * @name usePreferredReducedMotion
+ * @description - Hook that returns the reduced motion preference
+ * @category Browser
+ *
+ * @returns {UsePreferredReducedMotionReturn} The reduced motion preference
+ *
+ * @example
+ * const reduced = usePreferredReducedMotion();
+ */
+export declare const usePreferredReducedMotion: () => UsePreferredReducedMotionReturn;

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

@@ -0,0 +1,17 @@
+export interface UsePreviousOptions<Value> {
+    equality: (a: Value, b: Value) => boolean;
+}
+/**
+ * @name usePrevious
+ * @description - Hook that returns the previous value
+ * @category Utilities
+ *
+ * @template Value The type of the value
+ * @param {Value} value The value to get the previous value
+ * @param {(a: Value, b: Value) => boolean} [options.equality] The custom equality function to determine if the value has changed
+ * @returns {Value} The previous value
+ *
+ * @example
+ * const prevValue = usePrevious(value);
+ */
+export declare const usePrevious: <Value>(value: Value, options?: UsePreviousOptions<Value>) => Value | undefined;

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

@@ -0,0 +1,50 @@
+import { DependencyList } from 'react';
+export interface UseQueryOptions<QueryData, Data> {
+    enabled?: boolean;
+    initialData?: (() => Data) | Data;
+    keys?: DependencyList;
+    placeholderData?: (() => Data) | Data;
+    refetchInterval?: number;
+    retry?: boolean | number;
+    retryDelay?: ((retry: number, error: Error) => number) | number;
+    onError?: (error: Error) => void;
+    onSuccess?: (data: Data) => void;
+    select?: (data: QueryData) => Data;
+}
+interface UseQueryCallbackParams {
+    keys: DependencyList;
+    signal: AbortSignal;
+}
+export interface UseQueryReturn<Data> {
+    abort: AbortController['abort'];
+    data?: Data;
+    error?: Error;
+    isError: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isRefetching: boolean;
+    isSuccess: boolean;
+    refetch: () => void;
+}
+/**
+ * @name useQuery
+ * @description - Hook that defines the logic when query data
+ * @category Utilities
+ *
+ * @template Data The type of the data
+ * @param {() => Promise<Data>} callback The callback function to be invoked
+ * @param {DependencyList} [options.keys] The dependencies for the hook
+ * @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
+ * @param {UseQueryOptionsSelect<Data>} [options.select] The select function to be invoked
+ * @param {Data | (() => Data)} [options.initialData] The initial data for the hook
+ * @param {Data | (() => Data)} [options.placeholderData] The placeholder data for the hook
+ * @param {number} [options.refetchInterval] The refetch interval
+ * @param {boolean | number} [options.retry] The retry count of requests
+ * @returns {UseQueryReturn<Data>} An object with the state of the query
+ *
+ * @example
+ * const { data, isFetching, isLoading, isError, isSuccess, error, refetch, isRefetching, abort, aborted } = useQuery(() => fetch('url'));
+ */
+export declare const useQuery: <QueryData, Data = QueryData>(callback: (params: UseQueryCallbackParams) => Promise<QueryData>, options?: UseQueryOptions<QueryData, Data>) => UseQueryReturn<Data>;
+export {};

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

@@ -0,0 +1,30 @@
+/** The use queue return type */
+export interface UseQueueReturn<Value> {
+    /** Get the first element of the queue */
+    first: Value;
+    /** Get the last element of the queue */
+    last: Value;
+    /** The current queue */
+    queue: Value[];
+    /** Get the size of the queue */
+    size: number;
+    /** Add an element to the queue */
+    add: (element: Value) => void;
+    /** Clear the queue */
+    clear: () => void;
+    /** Remove an element from the queue */
+    remove: () => Value;
+}
+/**
+ * @name useQueue
+ * @description - Hook that manages a queue
+ * @category Utilities
+ *
+ * @template Value The type of the value
+ * @param {Value[]} [initialValue=[]] The initial value of the queue
+ * @returns {UseQueueReturn} An object containing the current queue and functions to interact with the queue
+ *
+ * @example
+ * const { queue, add, remove, clear, first, last, size } = useQueue([1, 2, 3]);
+ */
+export declare const useQueue: <Value>(initialValue?: Value[]) => UseQueueReturn<Value>;

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;
+};