@siberiacancode/reactuse 0.0.30 → 0.0.32

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import React from 'react';
+import * as react from 'react';
+import { RefObject, Dispatch, SetStateAction, EffectCallback, DependencyList, useEffect, ComponentProps } from 'react';
 import QRCode from 'qrcode';
 
 /** State for hook use battery */
@@ -58,9 +59,9 @@ declare const useBoolean: (initialValue?: boolean) => UseBooleanReturn;
 declare const useBrowserLanguage: () => string;
 
 /** The use click outside target element type */
-type UseClickOutsideTarget = React.RefObject<Element | null> | (() => Element) | Element;
+type UseClickOutsideTarget = RefObject<Element | null> | (() => Element) | Element;
 /** The use click outside return type */
-type UseClickOutsideReturn<Target extends UseClickOutsideTarget | UseClickOutsideTarget[]> = React.RefObject<Target>;
+type UseClickOutsideReturn<Target extends UseClickOutsideTarget | UseClickOutsideTarget[]> = RefObject<Target>;
 type UseClickOutside = {
     <Target extends UseClickOutsideTarget | UseClickOutsideTarget[]>(target: Target, callback: (event: Event) => void): void;
     <Target extends UseClickOutsideTarget | UseClickOutsideTarget[]>(callback: (event: Event) => void, target?: never): UseClickOutsideReturn<Target>;
@@ -127,7 +128,7 @@ interface UseCounterReturn {
     /** The current count value */
     count: number;
     /** Function to set a specific value to the counter */
-    set: React.Dispatch<React.SetStateAction<number>>;
+    set: Dispatch<SetStateAction<number>>;
     /** Function to reset the counter to its initial value. */
     reset: () => void;
     /** Function to increment the counter */
@@ -163,10 +164,19 @@ type UseCounter = {
  */
 declare const useCounter: UseCounter;
 
-interface UseDebouncedValueOptions {
-    maxWait?: number;
-}
-declare const useDebouncedValue: <Value>(value: Value, delay: number, options?: UseDebouncedValueOptions) => readonly [Value, (value: Value) => void];
+/**
+ * @name useDebouncedValue
+ * @description - Hook that creates a debounced value and returns a stable reference of it
+ *
+ * @template Value The type of the value
+ * @param {Value} value The value to be debounced
+ * @param {number} delay The delay in milliseconds
+ * @returns {Value} The debounced value
+ *
+ * @example
+ * const debouncedValue = useDebouncedValue(value, 500);
+ */
+declare const useDebouncedValue: <Value>(value: Value, delay: number) => Value;
 
 /**
  * @name useDefault
@@ -180,23 +190,23 @@ declare const useDebouncedValue: <Value>(value: Value, delay: number, options?:
  * @example
  * const [value, setValue] = useDefault(initialValue, defaultValue);
  */
-declare const useDefault: <Value>(initialValue: Value | (() => Value), defaultValue: Value) => readonly [Value, React.Dispatch<React.SetStateAction<Value | null | undefined>>];
+declare const useDefault: <Value>(initialValue: Value | (() => Value), defaultValue: Value) => readonly [Value, react.Dispatch<react.SetStateAction<Value | null | undefined>>];
 
 /**
  * @name useDidUpdate
  * @description – Hook that behaves like useEffect, but skips the effect on the initial render
  *
- * @param {React.EffectCallback} effect The effect callback
- * @param {React.DependencyList} [deps] The dependencies list for the effect
+ * @param {EffectCallback} effect The effect callback
+ * @param {DependencyList} [deps] The dependencies list for the effect
  *
  * @example
  * useDidUpdate(() => console.log('Won't be called when mounted'), [deps]);
  */
-declare const useDidUpdate: (effect: React.EffectCallback, deps?: React.DependencyList) => void;
+declare const useDidUpdate: (effect: EffectCallback, deps?: DependencyList) => void;
 
-type UseEventListenerTarget = React.RefObject<Element | null> | (() => Element) | Element | Window | Document;
+type UseEventListenerTarget = RefObject<Element | null> | (() => Element) | Element | Window | Document;
 type UseEventListenerOptions = boolean | AddEventListenerOptions;
-type UseEventListenerReturn<Target extends UseEventListenerTarget> = React.RefObject<Target>;
+type UseEventListenerReturn<Target extends UseEventListenerTarget> = RefObject<Target>;
 type UseEventListener = {
     <Event extends keyof WindowEventMap = keyof WindowEventMap>(target: Window, event: Event | Event[], listener: (this: Window, event: WindowEventMap[Event]) => void, options?: UseEventListenerOptions): void;
     <Event extends keyof DocumentEventMap = keyof DocumentEventMap>(target: Document, event: Event | Event[], listener: (this: Document, event: DocumentEventMap[Event]) => void, options?: UseEventListenerOptions): void;
@@ -290,7 +300,7 @@ interface UseEyeDropperReturn {
 declare const useEyeDropper: (initialValue?: string | undefined) => UseEyeDropperReturn;
 
 /** The use favicon return type */
-type UseFaviconReturn = [string, React.Dispatch<React.SetStateAction<string>>];
+type UseFaviconReturn = [string, Dispatch<SetStateAction<string>>];
 /**
  * @name useFavicon
  * @description - Hook that manages the favicon
@@ -413,7 +423,7 @@ declare const useField: <Value extends string | boolean = string, Type = Value e
 declare const useFps: () => number;
 
 /** The use fullscreen target element type */
-type UseFullScreenTarget = React.RefObject<Element | null> | (() => Element) | Element;
+type UseFullScreenTarget = RefObject<Element | null> | (() => Element) | Element;
 /** The use fullscreen options type */
 interface UseFullScreenOptions {
     /** initial value */
@@ -433,7 +443,7 @@ interface UseFullScreenReturn {
 type UseFullScreen = {
     <Target extends UseFullScreenTarget>(target: Target, options?: UseFullScreenOptions): UseFullScreenReturn;
     <Target extends UseFullScreenTarget>(options?: UseFullScreenOptions, target?: never): UseFullScreenReturn & {
-        ref: React.RefObject<Target>;
+        ref: RefObject<Target>;
     };
 };
 /**
@@ -456,7 +466,7 @@ type UseFullScreen = {
  * @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: React.RefObject<Target> }} An object with the fullscreen state and methods
+ * @returns {UseFullScreenReturn & { ref: RefObject<Target> }} An object with the fullscreen state and methods
  *
  * @example
  * const { ref, enter, exit, toggle, value } = useFullscreen();
@@ -518,8 +528,8 @@ interface UseHoverOptions {
     onEntry?: () => void;
     onLeave?: () => void;
 }
-type UseHoverTarget = React.RefObject<Element | null> | Element;
-type UseHoverReturn<Target extends UseHoverTarget> = [React.RefObject<Target>, boolean];
+type UseHoverTarget = RefObject<Element | null> | Element;
+type UseHoverReturn<Target extends UseHoverTarget> = [RefObject<Target>, boolean];
 type UseHover = {
     <Target extends UseHoverTarget>(target: Target, callback?: () => void): boolean;
     <Target extends UseHoverTarget>(target: Target, options?: UseHoverOptions): boolean;
@@ -596,11 +606,11 @@ interface UseIdleReturn {
  */
 declare const useIdle: (milliseconds?: number, { initialValue, events }?: UseIdleOptions) => UseIdleReturn;
 
-type UseIntersectionObserverTarget = React.RefObject<Element | null> | (() => Element) | Element;
+type UseIntersectionObserverTarget = RefObject<Element | null> | (() => Element) | Element;
 interface UseIntersectionObserverOptions extends Omit<IntersectionObserverInit, 'root'> {
     enabled?: boolean;
     onChange?: (entry: IntersectionObserverEntry) => void;
-    root?: IntersectionObserverInit['root'] | React.RefObject<Element | null>;
+    root?: IntersectionObserverInit['root'] | RefObject<Element | null>;
 }
 interface UseIntersectionObserverReturn {
     inView: boolean;
@@ -609,7 +619,7 @@ interface UseIntersectionObserverReturn {
 type UseIntersectionObserver = {
     <Target extends UseIntersectionObserverTarget>(target: Target, options?: UseIntersectionObserverOptions): UseIntersectionObserverReturn;
     <Target extends UseIntersectionObserverTarget>(options?: UseIntersectionObserverOptions, target?: never): UseIntersectionObserverReturn & {
-        ref: React.RefObject<Target>;
+        ref: RefObject<Target>;
     };
 };
 declare const useIntersectionObserver: UseIntersectionObserver;
@@ -675,7 +685,7 @@ declare const useIsFirstRender: () => boolean;
  * @example
  * useIsomorphicLayoutEffect(() => console.log('effect'), [])
  */
-declare const useIsomorphicLayoutEffect: typeof React.useEffect;
+declare const useIsomorphicLayoutEffect: typeof useEffect;
 
 /** The use key press options type */
 type UseKeyboardParams = {
@@ -831,17 +841,14 @@ declare const useLocalStorage: <Value>(key: string, initialValue?: UseStorageIni
  */
 declare const useLogger: (name: string, params: unknown[]) => void;
 
-type UseLongPressTarget = React.RefObject<Element | null> | (() => Element) | Element;
+type UseLongPressTarget = RefObject<Element | null> | (() => Element) | Element;
 interface UseLongPressOptions {
     threshold?: number;
     onStart?: (event: Event) => void;
     onFinish?: (event: Event) => void;
     onCancel?: (event: Event) => void;
 }
-type UseLongPressReturn<Target extends UseLongPressTarget> = [
-    React.RefObject<Target>,
-    boolean
-];
+type UseLongPressReturn<Target extends UseLongPressTarget> = [RefObject<Target>, boolean];
 type UseLongPress = {
     <Target extends UseLongPressTarget>(target: Target, callback: (event: Event) => void, options?: UseLongPressOptions): boolean;
     <Target extends UseLongPressTarget>(callback: (event: Event) => void, options?: UseLongPressOptions, target?: never): UseLongPressReturn<Target>;
@@ -894,15 +901,15 @@ declare const useMediaQuery: (query: string) => boolean;
  * @name useMount
  * @description - Hook that executes a callback when the component mounts
  *
- * @param {React.EffectCallback} effect The callback to execute
+ * @param {EffectCallback} effect The callback to execute
  *
  * @example
  * useMount(() => console.log('This effect runs on the initial render'));
  */
-declare const useMount: (effect: React.EffectCallback) => void;
+declare const useMount: (effect: EffectCallback) => void;
 
 /** The use mouse target element type */
-type UseMouseTarget = React.RefObject<Element | null> | (() => Element) | Element;
+type UseMouseTarget = RefObject<Element | null> | (() => Element) | Element;
 /** The use mouse return type */
 interface UseMouseReturn {
     /** The current mouse x position */
@@ -921,7 +928,7 @@ interface UseMouseReturn {
 type UseMouse = {
     <Target extends UseMouseTarget>(target: Target): UseMouseReturn;
     <Target extends UseMouseTarget>(target?: never): UseMouseReturn & {
-        ref: React.RefObject<Target>;
+        ref: RefObject<Target>;
     };
 };
 /**
@@ -938,7 +945,7 @@ type UseMouse = {
  *
  * @overload
  * @template Target The target element
- * @returns {UseMouseReturn & { ref: React.RefObject<Target> }} An object with the current mouse position and a ref
+ * @returns {UseMouseReturn & { ref: RefObject<Target> }} An object with the current mouse position and a ref
  *
  * @example
  * const { ref, x, y, elementX, elementY, elementPositionX, elementPositionY } = useMouse();
@@ -1018,6 +1025,7 @@ declare const useNetwork: () => UseNetworkReturn;
  */
 declare const useOnline: () => boolean;
 
+/** The operating system type */
 type OperatingSystem = 'undetermined' | 'macos' | 'ios' | 'windows' | 'android' | 'linux';
 declare const getOperatingSystem: () => OperatingSystem;
 /**
@@ -1073,16 +1081,16 @@ type UsePaintOptions = UsePaintPencil;
 /** The use paint return type */
 interface UsePaintReturn {
     pencil: UsePaintPencil & {
-        set: React.Dispatch<React.SetStateAction<UsePaintPencil>>;
+        set: Dispatch<SetStateAction<UsePaintPencil>>;
     };
     drawing: boolean;
 }
-type UsePaintTarget = React.RefObject<HTMLCanvasElement> | (() => HTMLCanvasElement) | HTMLCanvasElement;
+type UsePaintTarget = RefObject<HTMLCanvasElement> | (() => HTMLCanvasElement) | HTMLCanvasElement;
 declare const getTargetElement: (target: UsePaintTarget) => HTMLCanvasElement | null;
 type UsePaint = {
     <Target extends UsePaintTarget>(target: Target, options?: UsePaintOptions): UsePaintReturn;
     (options?: UsePaintOptions, target?: never): UsePaintReturn & {
-        ref: React.RefObject<HTMLCanvasElement>;
+        ref: RefObject<HTMLCanvasElement>;
     };
 };
 /**
@@ -1100,7 +1108,7 @@ type UsePaint = {
  *
  * @overload
  * @param {UsePaintOptions} [options] The options to be used
- * @returns {UsePaintReturn & { ref: React.RefObject<HTMLCanvasElement> }} An object containing the current pencil options and functions to interact with the paint
+ * @returns {UsePaintReturn & { ref: RefObject<HTMLCanvasElement> }} An object containing the current pencil options and functions to interact with the paint
  *
  * @example
  * const { ref, pencil, drawing } = usePaint();
@@ -1162,7 +1170,7 @@ declare const useQRCode: (text?: string, options?: QRCode.QRCodeToDataURLOptions
 };
 
 interface UseQueryOptions<QueryData, Data> {
-    keys?: React.DependencyList;
+    keys?: DependencyList;
     onSuccess?: (data: Data) => void;
     onError?: (error: Error) => void;
     select?: (data: QueryData) => Data;
@@ -1185,7 +1193,7 @@ interface UseQueryReturn<Data> {
  *
  * @template Data - The type of the data
  * @param {() => Promise<Data>} callback - The callback function to be invoked
- * @param {React.DependencyList} [options.keys] - The dependencies for the hook
+ * @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
@@ -1281,7 +1289,7 @@ declare const useRerender: () => UseRerenderReturns;
 type UseScriptStatus = 'loading' | 'ready' | 'error' | 'unknown';
 declare const SCRIPT_STATUS_ATTRIBUTE_NAME = "script-status";
 /** The use script options extends from attributes script tag */
-interface UseScriptOptions extends React.ComponentProps<'script'> {
+interface UseScriptOptions extends ComponentProps<'script'> {
     /** Whether to remove the script on unmount */
     removeOnUnmount?: boolean;
 }
@@ -1494,7 +1502,7 @@ type UseToggleReturn<Value> = readonly [Value, (value?: Value) => void];
  * @example
  * const [value, toggle] = useToggle(['light', 'dark'] as const);
  */
-declare const useToggle: <Value = boolean>(values?: readonly Value[]) => readonly [Value, (value?: React.SetStateAction<Value>) => void];
+declare const useToggle: <Value = boolean>(values?: readonly Value[]) => readonly [Value, (value?: SetStateAction<Value>) => void];
 
 /**
  * @name useUnmount

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siberiacancode/reactuse",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "description": "Ultimate tool",
   "license": "MIT",
   "author": {

package/dist/cjs/_rollupPluginBabelHelpers-B5ln7UDR.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_rollupPluginBabelHelpers-B5ln7UDR.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/esm/_rollupPluginBabelHelpers-BO0nvURb.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_rollupPluginBabelHelpers-BO0nvURb.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}