@siberiacancode/reactuse 0.0.112 → 0.0.113

package/dist/esm/utils/helpers/throttle.mjs

@@ -0,0 +1,21 @@
+const s = (l, r) => {
+  let e = !1, t = null;
+  const i = () => {
+    if (!t) {
+      e = !1;
+      return;
+    }
+    l.apply(void 0, t), t = null, setTimeout(i, r);
+  };
+  return function(...n) {
+    if (e) {
+      t = n;
+      return;
+    }
+    l.apply(this, n), e = !0, setTimeout(i, r);
+  };
+};
+export {
+  s as throttle
+};
+//# sourceMappingURL=throttle.mjs.map

package/dist/esm/utils/helpers/throttle.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.mjs","sources":["../../../../src/utils/helpers/throttle.ts"],"sourcesContent":["export const throttle = <Params extends any[]>(\n  callback: (...args: Params) => void,\n  delay: number\n): ((...args: Params) => void) => {\n  let isCalled = false;\n  let lastArgs: Params | null = null;\n\n  const timer = () => {\n    if (!lastArgs) {\n      isCalled = false;\n      return;\n    }\n\n    callback.apply(this, lastArgs);\n    lastArgs = null;\n    setTimeout(timer, delay);\n  };\n\n  return function (this: any, ...args: Params) {\n    if (isCalled) {\n      lastArgs = args;\n      return;\n    }\n\n    callback.apply(this, args);\n    isCalled = true;\n    setTimeout(timer, delay);\n  };\n};\n"],"names":["throttle","callback","delay","isCalled","lastArgs","timer","args"],"mappings":"AAAa,MAAAA,IAAW,CACtBC,GACAC,MACgC;AAChC,MAAIC,IAAW,IACXC,IAA0B;AAE9B,QAAMC,IAAQ,MAAM;AAClB,QAAI,CAACD,GAAU;AACF,MAAAD,IAAA;AACX;AAAA,IAAA;AAGO,IAAAF,EAAA,MAAM,QAAMG,CAAQ,GAClBA,IAAA,MACX,WAAWC,GAAOH,CAAK;AAAA,EACzB;AAEA,SAAO,YAAwBI,GAAc;AAC3C,QAAIH,GAAU;AACD,MAAAC,IAAAE;AACX;AAAA,IAAA;AAGO,IAAAL,EAAA,MAAM,MAAMK,CAAI,GACdH,IAAA,IACX,WAAWE,GAAOH,CAAK;AAAA,EACzB;AACF;"}

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

@@ -0,0 +1,128 @@
+export * from './useActiveElement/useActiveElement';
+export * from './useAsync/useAsync';
+export * from './useBattery/useBattery';
+export * from './useBluetooth/useBluetooth';
+export * from './useBoolean/useBoolean';
+export * from './useBreakpoints/useBreakpoints';
+export * from './useBrowserLanguage/useBrowserLanguage';
+export * from './useClickOutside/useClickOutside';
+export * from './useClipboard/useClipboard';
+export * from './useConst/useConst';
+export * from './useCookie/useCookie';
+export * from './useCookies/useCookies';
+export * from './useCopy/useCopy';
+export * from './useCounter/useCounter';
+export * from './useCssVar/useCssVar';
+export * from './useDebounceCallback/useDebounceCallback';
+export * from './useDebounceValue/useDebounceValue';
+export * from './useDefault/useDefault';
+export * from './useDeviceMotion/useDeviceMotion';
+export * from './useDeviceOrientation/useDeviceOrientation';
+export * from './useDevicePixelRatio/useDevicePixelRatio';
+export * from './useDidUpdate/useDidUpdate';
+export * from './useDisclosure/useDisclosure';
+export * from './useDisplayMedia/useDisplayMedia';
+export * from './useDocumentEvent/useDocumentEvent';
+export * from './useDocumentTitle/useDocumentTitle';
+export * from './useDocumentVisibility/useDocumentVisibility';
+export * from './useElementSize/useElementSize';
+export * from './useEvent/useEvent';
+export * from './useEventListener/useEventListener';
+export * from './useEyeDropper/useEyeDropper';
+export * from './useFavicon/useFavicon';
+export * from './useField/useField';
+export * from './useFileDialog/useFileDialog';
+export * from './useFocus/useFocus';
+export * from './useFps/useFps';
+export * from './useFullscreen/useFullscreen';
+export * from './useGamepad/useGamepad';
+export * from './useGeolocation/useGeolocation';
+export * from './useHash/useHash';
+export * from './useHotkeys/useHotkeys';
+export * from './useHover/useHover';
+export * from './useIdle/useIdle';
+export * from './useImage/useImage';
+export * from './useInfiniteScroll/useInfiniteScroll';
+export * from './useIntersectionObserver/useIntersectionObserver';
+export * from './useInterval/useInterval';
+export * from './useIsFirstRender/useIsFirstRender';
+export * from './useIsomorphicLayoutEffect/useIsomorphicLayoutEffect';
+export * from './useKeyboard/useKeyboard';
+export * from './useKeyPress/useKeyPress';
+export * from './useKeyPressEvent/useKeyPressEvent';
+export * from './useKeysPressed/useKeysPressed';
+export * from './useLastChanged/useLastChanged';
+export * from './useLatest/useLatest';
+export * from './useLess/useLess';
+export * from './useList/useList';
+export * from './useLocalStorage/useLocalStorage';
+export * from './useLockCallback/useLockCallback';
+export * from './useLogger/useLogger';
+export * from './useLongPress/useLongPress';
+export * from './useMap/useMap';
+export * from './useMeasure/useMeasure';
+export * from './useMediaQuery/useMediaQuery';
+export * from './useMemory/useMemory';
+export * from './useMount/useMount';
+export * from './useMouse/useMouse';
+export * from './useMutation/useMutation';
+export * from './useMutationObserver/useMutationObserver';
+export * from './useNetwork/useNetwork';
+export * from './useOffsetPagination/useOffsetPagination';
+export * from './useOnce/useOnce';
+export * from './useOnline/useOnline';
+export * from './useOperatingSystem/useOperatingSystem';
+export * from './useOptimistic/useOptimistic';
+export * from './useOrientation/useOrientation';
+export * from './useOtpCredential/useOtpCredential';
+export * from './usePageLeave/usePageLeave';
+export * from './usePaint/usePaint';
+export * from './useParallax/useParallax';
+export * from './usePerformanceObserver/usePerformanceObserver';
+export * from './usePermission/usePermission';
+export * from './usePointerLock/usePointerLock';
+export * from './usePostMessage/usePostMessage';
+export * from './usePreferredColorScheme/usePreferredColorScheme';
+export * from './usePreferredContrast/usePreferredContrast';
+export * from './usePreferredDark/usePreferredDark';
+export * from './usePreferredLanguages/usePreferredLanguages';
+export * from './usePreferredReducedMotion/usePreferredReducedMotion';
+export * from './usePrevious/usePrevious';
+export * from './useQuery/useQuery';
+export * from './useQueue/useQueue';
+export * from './useRaf/useRaf';
+export * from './useRafValue/useRafValue';
+export * from './useRefState/useRefState';
+export * from './useRenderCount/useRenderCount';
+export * from './useRenderInfo/useRenderInfo';
+export * from './useRerender/useRerender';
+export * from './useResizeObserver/useResizeObserver';
+export * from './useScreenOrientation/useScreenOrientation';
+export * from './useScript/useScript';
+export * from './useScroll/useScroll';
+export * from './useScrollIntoView/useScrollIntoView';
+export * from './useScrollTo/useScrollTo';
+export * from './useSessionStorage/useSessionStorage';
+export * from './useSet/useSet';
+export * from './useShare/useShare';
+export * from './useStateHistory/useStateHistory';
+export * from './useStep/useStep';
+export * from './useSticky/useSticky';
+export * from './useStopwatch/useStopwatch';
+export * from './useStorage/useStorage';
+export * from './useTextDirection/useTextDirection';
+export * from './useTextSelection/useTextSelection';
+export * from './useThrottleCallback/useThrottleCallback';
+export * from './useThrottleValue/useThrottleValue';
+export * from './useTime/useTime';
+export * from './useTimeout/useTimeout';
+export * from './useTimer/useTimer';
+export * from './useToggle/useToggle';
+export * from './useUnmount/useUnmount';
+export * from './useVibrate/useVibrate';
+export * from './useWebSocket/useWebSocket';
+export * from './useWindowEvent/useWindowEvent';
+export * from './useWindowFocus/useWindowFocus';
+export * from './useWindowScroll/useWindowScroll';
+export * from './useWindowSize/useWindowSize';
+export * from './useWizard/useWizard';

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

@@ -0,0 +1,11 @@
+/**
+ * @name useActiveElement
+ * @description - Hook that returns the active element
+ * @category Elements
+ *
+ * @returns {ActiveElement | null} The active element
+ *
+ * @example
+ * const activeElement = useActiveElement();
+ */
+export declare const useActiveElement: <ActiveElement extends HTMLElement>() => ActiveElement | null;

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

@@ -0,0 +1,20 @@
+import { DependencyList } from 'react';
+export interface UseAsyncReturn<Data> {
+    data?: Data;
+    error?: Error;
+    isError: boolean;
+    isLoading: boolean;
+}
+/**
+ * @name useAsync
+ * @description - Hook that provides the state of an async callback
+ * @category Utilities
+ *
+ * @param {() => Promise<Data>} callback - The async callback
+ * @param {DependencyList} deps - The dependencies of the callback
+ * @returns {UseAsyncReturn<Data>} - The state of the async callback
+ *
+ * @example
+ * const { data, isLoading, isError, error } = useAsync(() => fetch('url'), [deps]);
+ */
+export declare const useAsync: <Data>(callback: () => Promise<Data>, deps: DependencyList) => UseAsyncReturn<Data>;

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

@@ -0,0 +1,44 @@
+export interface BatteryManager extends EventTarget {
+    charging: boolean;
+    chargingTime: number;
+    dischargingTime: number;
+    level: number;
+}
+declare global {
+    interface Navigator {
+        readonly getBattery: () => Promise<BatteryManager>;
+    }
+}
+/** The use battery value type */
+export interface UseBatteryValue {
+    /** Is charging battery? */
+    charging: boolean;
+    /** Time until the battery is fully charged */
+    chargingTime: number;
+    /** Time until the battery is completely discharged */
+    dischargingTime: number;
+    /** Battery charge level from 0 to 1 */
+    level: number;
+    /** Is battery information loading? */
+    loading: boolean;
+}
+/** The use battery return type */
+export interface UseBatteryStateReturn {
+    /** Whether the battery api is supported*/
+    supported: boolean;
+    /** The use battery value type  */
+    value: UseBatteryValue;
+}
+/**
+ * @name useBattery
+ * @description - Hook for getting information about battery status
+ * @category Browser
+ *
+ * @browserapi navigator.getBattery https://developer.mozilla.org/en-US/docs/Web/API/Navigator/getBattery
+ *
+ * @returns {UseBatteryStateReturn} Object containing battery information & Battery API support
+ *
+ * @example
+ * const { supported, loading, charging, chargingTime, dischargingTime, level } = useBattery();
+ */
+export declare const useBattery: () => UseBatteryStateReturn;

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

@@ -0,0 +1,38 @@
+/** The use bluetooth return type */
+export interface UseBluetoothReturn {
+    /** Indicates if bluetooth device is currently connected */
+    connected: boolean;
+    /** Describe connected bluetooth device */
+    device?: BluetoothDevice;
+    /** The GATT server for connected bluetooth device */
+    server?: BluetoothRemoteGATTServer;
+    /** Whether the bluetooth is supported*/
+    supported: boolean;
+    /** Function to request bluetooth device from the user */
+    requestDevice: () => Promise<void>;
+}
+/** The use bluetooth options type */
+export interface UseBluetoothOptions {
+    /** The options to request all bluetooth devices */
+    acceptAllDevices?: boolean;
+    /** Array of filters to apply when scanning bluetooth devices */
+    filters?: BluetoothLEScanFilter[];
+    /** Array of optional services that the application can use */
+    optionalServices?: BluetoothServiceUUID[];
+}
+/**
+ * @name useBluetooth
+ * @description - Hook for getting information about bluetooth
+ * @category Browser
+ *
+ * @browserapi navigator.bluetooth https://developer.mozilla.org/en-US/docs/Web/API/Navigator/bluetooth
+ *
+ * @param {boolean} [options.acceptAllDevices=false] The options to request all Bluetooth devices
+ * @param {Array<BluetoothLEScanFilter>} [options.filters] Array of filters to apply when scanning Bluetooth devices
+ * @param {Array<BluetoothServiceUUID>} [options.optionalServices] Array of optional services that the application can use
+ * @returns {UseBluetoothReturn} Object containing battery information & Battery API support
+ *
+ * @example
+ * const { supported, connected, device, requestDevice, server } = useBluetooth(options);
+ */
+export declare const useBluetooth: (options?: UseBluetoothOptions) => UseBluetoothReturn;

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

@@ -0,0 +1,19 @@
+/** The use boolean return type */
+export type UseBooleanReturn = [
+    /** The current boolean state value */
+    value: boolean,
+    /** Function to toggle the boolean state */
+    toggle: (value?: boolean) => void
+];
+/**
+ * @name useBoolean
+ * @description - Hook provides opportunity to manage boolean state
+ * @category Utilities
+ *
+ * @param {boolean} [initialValue=false] The initial boolean value
+ * @returns {UseBooleanReturn} An object containing the boolean state value and utility functions to manipulate the state
+ *
+ * @example
+ * const [on, toggle] = useBoolean()
+ */
+export declare const useBoolean: (initialValue?: boolean) => UseBooleanReturn;

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

@@ -0,0 +1,125 @@
+/** The breakpoints type */
+export type Breakpoints<Breakpoint extends string = string> = Record<Breakpoint, number>;
+/** The use breakpoints strategy */
+export type UseBreakpointsStrategy = 'desktop-first' | 'mobile-first';
+/** The use breakpoints return type */
+export type UseBreakpointsReturn<Breakpoint extends string = string> = {
+    /** The function that checks if the current breakpoint is greater than to the given breakpoint */
+    greater: (breakpoint: Breakpoint) => boolean;
+    /** The function that checks if the current breakpoint is greater than or equal to the given breakpoint */
+    greaterOrEqual: (breakpoint: Breakpoint) => boolean;
+    /** The function that checks if the current breakpoint is smaller than to the given breakpoint */
+    smaller: (breakpoint: Breakpoint) => boolean;
+    /** The function that checks if the current breakpoint is smaller than or equal to the given breakpoint */
+    smallerOrEqual: (breakpoint: Breakpoint) => boolean;
+    /** The function that checks if the current breakpoint is between to the given breakpoints */
+    between: (a: Breakpoint, b: Breakpoint) => boolean;
+    /** The function that checks if the current breakpoint is greater than to the given breakpoint */
+    isGreater: (breakpoint: Breakpoint) => boolean;
+    /** The function that checks if the current breakpoint is greater than or equal to the given breakpoint */
+    isGreaterOrEqual: (breakpoint: Breakpoint) => boolean;
+    /** The function that checks if the current breakpoint is smaller than to the given breakpoint */
+    isSmaller: (breakpoint: Breakpoint) => boolean;
+    /** The function that checks if the current breakpoint is smaller than or equal to the given breakpoint */
+    isSmallerOrEqual: (breakpoint: Breakpoint) => boolean;
+    /** The function that checks if the current breakpoint is between to the given breakpoints */
+    isInBetween: (a: Breakpoint, b: Breakpoint) => boolean;
+    /** The function that returns the current breakpoints */
+    current: () => Breakpoint[];
+    /** The function that returns the current active breakpoint */
+    active: () => Breakpoint;
+} & Record<Breakpoint, boolean>;
+/**
+ * @name useBreakpoints
+ * @description - Hook that manages breakpoints
+ * @category Browser
+ *
+ * @template {string} Breakpoint The name of the breakpoint
+ * @param {Breakpoints<Breakpoint>} breakpoints The breakpoints to use
+ * @param {UseBreakpointsStrategy} [strategy=min-width] The strategy to use for matching
+ * @returns {UseBreakpointsReturn<Breakpoint>} An object containing the current breakpoint
+ *
+ * @example
+ * const { greaterOrEqual, smallerOrEqual, current } = useBreakpoints({ mobile: 0, tablet: 640, laptop: 1024, desktop: 1280 });
+ */
+export declare const useBreakpoints: <Breakpoint extends string>(breakpoints: Breakpoints<Breakpoint>, strategy?: UseBreakpointsStrategy) => UseBreakpointsReturn<Breakpoint>;
+/** Breakpoints from Material UI */
+export declare const BREAKPOINTS_MATERIAL_UI: {
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+};
+/** Breakpoints from Mantine */
+export declare const BREAKPOINTS_MANTINE: {
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+};
+/** Breakpoints from Tailwind */
+export declare const BREAKPOINTS_TAILWIND: {
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+    '2xl': number;
+};
+/**  Breakpoints from Bootstrap V5 */
+export declare const BREAKPOINTS_BOOTSTRAP_V5: {
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+    xxl: number;
+};
+/** Breakpoints from Ant Design */
+export declare const BREAKPOINTS_ANT_DESIGN: {
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+    xxl: number;
+};
+/** Breakpoints from Quasar V2 */
+export declare const BREAKPOINTS_QUASAR_V2: {
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+};
+/** Sematic Breakpoints */
+export declare const BREAKPOINTS_SEMANTIC: {
+    mobileS: number;
+    mobileM: number;
+    mobileL: number;
+    tablet: number;
+    laptop: number;
+    laptopL: number;
+    desktop4K: number;
+};
+/**  Breakpoints from Master CSS  */
+export declare const BREAKPOINTS_MASTER_CSS: {
+    '3xs': number;
+    '2xs': number;
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+    '2xl': number;
+    '3xl': number;
+    '4xl': number;
+};
+/** Breakpoints from PrimeFlex */
+export declare const BREAKPOINTS_PRIME_FLEX: {
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+};

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

@@ -0,0 +1,13 @@
+/**
+ * @name useBrowserLanguage
+ * @description - Hook that returns the current browser language
+ * @category Browser
+ *
+ * @browserapi navigator.language https://developer.mozilla.org/en-US/docs/Web/API/Navigator/language
+ *
+ * @returns {string} The current browser language
+ *
+ * @example
+ * const browserLanguage = useBrowserLanguage();
+ */
+export declare const useBrowserLanguage: () => string;

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

@@ -0,0 +1,28 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+export interface UseClickOutside {
+    (target: HookTarget, callback: (event: Event) => void): void;
+    <Target extends Element>(callback: (event: Event) => void, target?: never): StateRef<Target>;
+}
+/**
+ * @name useClickOutside
+ * @description - Hook to handle click events outside the specified target element(s)
+ * @category Sensors
+ *
+ * @overload
+ * @param {HookTarget} target The target element(s) to detect outside clicks for
+ * @param {(event: Event) => void} callback The callback to execute when a click outside the target is detected
+ * @returns {void}
+ *
+ * @example
+ * useClickOutside(ref, () => console.log('click outside'));
+ *
+ * @overload
+ * @template Target The target element(s)
+ * @param {(event: Event) => void} callback The callback to execute when a click outside the target is detected
+ * @returns {(node: Target) => void} A React ref to attach to the target element
+ *
+ * @example
+ * const ref = useClickOutside<HTMLDivElement>(() => console.log('click outside'));
+ */
+export declare const useClickOutside: UseClickOutside;

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

@@ -0,0 +1,26 @@
+/** The use copy to clipboard return type */
+export interface UseCopyToClipboardReturn {
+    /** The copied value */
+    value: string | null;
+    /** Function to copy to clipboard  */
+    copy: (value: string) => Promise<void>;
+}
+/** The use copy to clipboard params type */
+export interface UseCopyToClipboardParams {
+    /** Whether the copy to clipboard is enabled */
+    enabled: boolean;
+}
+/**
+ * @name useClipboard
+ * @description - Hook that manages a copy to clipboard
+ * @category Browser
+ *
+ * @browserapi navigator.clipboard https://developer.mozilla.org/en-US/docs/Web/API/Navigator/clipboard
+ *
+ * @param {boolean} [params.enabled=false] Whether the copy to clipboard is enabled
+ * @returns {UseCopyToClipboardReturn} An object containing the boolean state value and utility functions to manipulate the state
+ *
+ * @example
+ * const { supported, value, copy } = useClipboard();
+ */
+export declare const useClipboard: (params?: UseCopyToClipboardParams) => UseCopyToClipboardReturn;

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

@@ -0,0 +1,13 @@
+/**
+ * @name useConst
+ * @description - Hook that returns the constant value
+ * @category Utilities
+ *
+ * @template Value The type of the value
+ * @param {(() => Value) | Value} initialValue The initial value of the constant
+ * @returns {Value} The constant value
+ *
+ * @example
+ * const value = useConst('value');
+ */
+export declare const useConst: <Value>(initialValue: (() => Value) | Value) => Value;

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

@@ -0,0 +1,65 @@
+export declare const getCookies: () => {
+    [k: string]: string;
+};
+export interface RemoveCookieParams {
+    domain?: string;
+    expires?: Date;
+    maxAge?: number;
+    path?: string;
+    sameSite?: 'Lax' | 'None' | 'Strict';
+    secure?: boolean;
+}
+export declare const removeCookie: (key: string, options?: RemoveCookieParams) => void;
+export interface SetCookieParams {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    sameSite?: 'Lax' | 'None' | 'Strict';
+    secure?: boolean;
+}
+export declare const setCookie: (key: string, value: string, options?: SetCookieParams) => void;
+export type UseCookieInitialValue<Value> = (() => Value) | Value;
+export interface UseCookieOptions<Value> {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    initialValue?: UseCookieInitialValue<Value>;
+    maxAge?: number;
+    path?: string;
+    sameSite?: 'Lax' | 'None' | 'Strict';
+    secure?: boolean;
+    updateOnChange?: boolean;
+    deserializer?: (value: string) => Value;
+    serializer?: (value: Value) => string;
+}
+export interface UseCookieReturn<Value> {
+    value: Value;
+    remove: (options?: RemoveCookieParams) => void;
+    set: (value: Value, options?: SetCookieParams) => void;
+}
+export declare const COOKIE_EVENT = "reactuse-cookie";
+export declare const dispatchCookieEvent: () => boolean;
+export declare const setCookieItem: (key: string, value: string, options?: SetCookieParams) => void;
+export declare const removeCookieItem: (key: string, options?: RemoveCookieParams) => void;
+export declare const getCookie: (key: string) => string | undefined;
+/**
+ * @name useCookie
+ * @description - Hook that manages cookie value
+ * @category Browser
+ *
+ * @overload
+ * @template Value The type of the cookie value
+ * @param {string} key The key of the cookie
+ * @param {UseCookieInitialValue<Value>} [initialValue] The initial value of the cookie
+ * @returns {UseCookieReturn<Value>} The value and the set function
+ *
+ * @example
+ * const { value, set, remove } = useCookie('key', 'value');
+ */
+export declare const useCookie: <Value>(key: string, params?: UseCookieInitialValue<Value> | UseCookieOptions<Value>) => {
+    value: Value | undefined;
+    set: (value: Value, params?: SetCookieParams) => void;
+    remove: (params?: RemoveCookieParams) => void;
+};

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

@@ -0,0 +1,27 @@
+import { RemoveCookieParams, SetCookieParams } from '../useCookie/useCookie';
+export declare const getParsedCookies: () => {
+    [k: string]: any;
+};
+export declare const clearCookies: () => void;
+/**
+ * @name useCookies
+ * @description - Hook that manages cookie values
+ * @category Browser
+ *
+ * @overload
+ * @template {object} Value The type of the cookie values
+ * @param {string} key The key of the cookie
+ * @returns {UseCookieReturn<Value>} The value and the set function
+ *
+ * @example
+ * const { value, set, remove, getAll, clear } = useCookies();
+ */
+export declare const useCookies: <Value>() => {
+    value: Value;
+    set: (key: string, value: Value, options?: SetCookieParams) => void;
+    remove: (key: string, options?: RemoveCookieParams) => void;
+    getAll: () => {
+        [k: string]: any;
+    };
+    clear: () => void;
+};

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

@@ -0,0 +1,28 @@
+/** The use copy return type */
+export interface UseCopyReturn {
+    /** Whether copy is in progress */
+    copied: boolean;
+    /** The copied value */
+    value: string | null;
+    /** Function to copy text */
+    copy: (value: string) => Promise<void>;
+}
+/** The use copy params type */
+export interface UseCopyParams {
+    /** Reset delay in milliseconds */
+    resetDelay?: number;
+}
+/**
+ * @name useCopy
+ * @description - Hook that manages copying text with status reset
+ * @category Browser
+ *
+ * @browserapi navigator.clipboard https://developer.mozilla.org/en-US/docs/Web/API/Navigator/clipboard
+ *
+ * @param {number} [delay=1000] Delay in ms before resetting copied status
+ * @returns {UseCopyReturn} An object containing the copied value, status and copy function
+ *
+ * @example
+ * const { copied, value, copy } = useCopy();
+ */
+export declare const useCopy: (delay?: number) => UseCopyReturn;