@aiszlab/relax 1.2.20 → 1.2.23

package/dist/dom/contains.d.ts

@@ -0,0 +1 @@
+export declare const contains: (root: Node | null | undefined, n?: Node | null) => boolean;

package/dist/dom/contains.mjs

@@ -0,0 +1,20 @@
+const contains = (root, n) => {
+    if (!root) {
+        return false;
+    }
+    // Use native if support
+    if (root.contains) {
+        return root.contains(n !== null && n !== void 0 ? n : null);
+    }
+    // `document.contains` not support with IE11
+    let node = n;
+    while (node) {
+        if (node === root) {
+            return true;
+        }
+        node = node.parentNode;
+    }
+    return false;
+};
+
+export { contains };

package/dist/dom/index.d.ts

@@ -1,2 +1,3 @@
 import { scrollTo } from './scroll-to';
-export { scrollTo };
+import { contains } from './contains';
+export { scrollTo, contains };

package/dist/dom/index.mjs

@@ -1 +1,2 @@
 export { scrollTo } from './scroll-to.mjs';
+export { contains } from './contains.mjs';

package/dist/hooks/use-counter.mjs

@@ -16,7 +16,7 @@ const useCounter = (_a = { initialValue: 0, max: Infinity, min: 0 }) => {
         setCount((prev) => Math.min(max, prev + step));
     }, [max]);
     const prev = useCallback((step = 1) => {
-        setCount((prev) => Math.max(prev - step));
+        setCount((prev) => Math.max(min, prev - step));
     }, [min]);
     const first = useCallback(() => {
         setCount(min);

package/dist/hooks/use-debounce-callback.d.ts

@@ -1,17 +1,22 @@
 interface Options {
     /**
+     * @description
      * The delay time (in milliseconds) until the debounce function is called.
      * default 1000
+     *
+     * @example
+     * 2000
      */
     readonly delay: number;
 }
+type Callable<T, R> = (value: T) => R;
 /**
  * @author murukal
  *
  * @description
  * debounce callback
  */
-export declare const useDebounceCallback: <T>(callable: Function, { delay }?: Options) => {
+export declare const useDebounceCallback: <T, R>(_callable: Callable<T, R>, options?: Options) => {
     next: (value: T) => void;
     complete: () => void;
     cancel: () => void;

package/dist/hooks/use-debounce-callback.mjs

@@ -1,5 +1,6 @@
 import { useRef, useCallback, useEffect } from 'react';
 import { Observable, debounceTime } from 'rxjs';
+import { useEvent } from './use-event.mjs';
 
 /**
  * @author murukal
@@ -7,54 +8,45 @@ import { Observable, debounceTime } from 'rxjs';
  * @description
  * debounce callback
  */
-const useDebounceCallback = (callable, { delay = 1000 } = {
-    delay: 1000
-}) => {
-    // trigger
-    const trigger = useRef();
-    // listener
-    const listener = useRef();
-    /// initialze listener function for debouce
-    const initialize = useCallback(() => {
-        listener.current = new Observable((subscriber) => {
+const useDebounceCallback = (_callable, options) => {
+    var _a;
+    const trigger = useRef(null);
+    const listener = useRef(null);
+    const delay = (_a = options === null || options === void 0 ? void 0 : options.delay) !== null && _a !== void 0 ? _a : 1000;
+    const callable = useEvent(_callable);
+    const listen = useCallback(() => {
+        const listened = new Observable((subscriber) => {
             trigger.current = subscriber;
         })
             .pipe(debounceTime(delay))
             .subscribe({
-            next: (value) => {
-                callable(value);
-            },
-            complete: () => {
-                initialize();
-            }
+            next: callable,
+            complete: listen
         });
-    }, [callable, delay]);
-    /// initialize debounce function
-    /// when delay / callable changed, need reinitialize
+        listener.current = listened;
+        return listened;
+    }, [delay]);
     useEffect(() => {
-        initialize();
+        const listened = listen();
         // dispose
         return () => {
-            var _a;
-            (_a = listener.current) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+            listened.unsubscribe();
+            listener.current = null;
+            trigger.current = null;
         };
-    }, [initialize]);
-    /// next function has been debounced for hooks user
-    const next = useCallback((value) => {
+    }, [listen]);
+    const next = useEvent((value) => {
         var _a;
         (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.next(value);
-    }, []);
-    /// flush the debounce
-    const complete = useCallback(() => {
+    });
+    const complete = useEvent(() => {
         var _a;
         (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.complete();
-    }, []);
-    /// cancel only valid in debounce time
-    /// if the callback has been called, it can not be canceled
-    const cancel = useCallback(() => {
+    });
+    const cancel = useEvent(() => {
         var _a;
         (_a = listener.current) === null || _a === void 0 ? void 0 : _a.unsubscribe();
-    }, []);
+    });
     return {
         next,
         complete,

package/dist/hooks/use-event.d.ts

@@ -1,3 +1 @@
-type Callback<U extends Array<unknown>, R> = (...args: U) => R;
-export declare const useEvent: <U extends unknown[], R>(callback: Callback<U, R>) => Callback<U, R>;
-export {};
+export declare const useEvent: <T extends Function>(callable: T) => T;

package/dist/hooks/use-event.mjs

@@ -1,9 +1,9 @@
 import { useRef, useCallback } from 'react';
 
-const useEvent = (callback) => {
-    const ref = useRef();
-    ref.current = callback;
-    return useCallback((...args) => ref.current(...args), []);
+const useEvent = (callable) => {
+    const ref = useRef(callable);
+    ref.current = callable;
+    return useCallback(((...args) => ref.current(...args)), []);
 };
 
 export { useEvent };

package/dist/hooks/use-throttle-callback.d.ts

@@ -1,17 +1,22 @@
 interface Options {
     /**
+     * @description
      * The delay time (in milliseconds) until the throttle function is called.
      * default 1000
+     *
+     * @example
+     * 2000
      */
     readonly duration: number;
 }
+type Callable<T, R> = (value: T) => R;
 /**
  * @author murukal
  *
  * @description
  * throttle callback
  */
-export declare const useThrottleCallback: <T>(callable: Function, { duration }?: Options) => {
+export declare const useThrottleCallback: <T, R>(_callable: Callable<T, R>, options?: Options) => {
     next: (value: T) => void;
     complete: () => void;
     cancel: () => void;

package/dist/hooks/use-throttle-callback.mjs

@@ -1,5 +1,6 @@
 import { useRef, useCallback, useEffect } from 'react';
 import { Observable, throttleTime } from 'rxjs';
+import { useEvent } from './use-event.mjs';
 
 /**
  * @author murukal
@@ -7,54 +8,45 @@ import { Observable, throttleTime } from 'rxjs';
  * @description
  * throttle callback
  */
-const useThrottleCallback = (callable, { duration = 1000 } = {
-    duration: 1000
-}) => {
-    // runner
-    const runner = useRef();
-    // listener
-    const listener = useRef();
-    /// initialze listener function for debouce
-    const initialize = useCallback(() => {
-        listener.current = new Observable((subscriber) => {
-            runner.current = subscriber;
+const useThrottleCallback = (_callable, options) => {
+    var _a;
+    const trigger = useRef(null);
+    const listener = useRef(null);
+    const duration = (_a = options === null || options === void 0 ? void 0 : options.duration) !== null && _a !== void 0 ? _a : 1000;
+    const callable = useEvent(_callable);
+    const listen = useCallback(() => {
+        const listened = new Observable((subscriber) => {
+            trigger.current = subscriber;
         })
             .pipe(throttleTime(duration))
             .subscribe({
-            next: (value) => {
-                callable(value);
-            },
-            complete: () => {
-                initialize();
-            }
+            next: callable,
+            complete: listen
         });
-    }, [callable, duration]);
-    /// initialize debounce function
-    /// when delay / callable changed, need reinitialize
+        listener.current = listened;
+        return listened;
+    }, [duration]);
     useEffect(() => {
-        initialize();
+        const listened = listen();
         // dispose
         return () => {
-            var _a;
-            (_a = listener.current) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+            listened.unsubscribe();
+            listener.current = null;
+            trigger.current = null;
         };
-    }, [initialize]);
-    /// next function has been debounced for hooks user
-    const next = useCallback((value) => {
+    }, [listen]);
+    const next = useEvent((value) => {
         var _a;
-        (_a = runner.current) === null || _a === void 0 ? void 0 : _a.next(value);
-    }, []);
-    /// flush the debounce
-    const complete = useCallback(() => {
+        (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.next(value);
+    });
+    const complete = useEvent(() => {
         var _a;
-        (_a = runner.current) === null || _a === void 0 ? void 0 : _a.complete();
-    }, []);
-    /// cancel only valid in debounce time
-    /// if the callback has been called, it can not be canceled
-    const cancel = useCallback(() => {
+        (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.complete();
+    });
+    const cancel = useEvent(() => {
         var _a;
         (_a = listener.current) === null || _a === void 0 ? void 0 : _a.unsubscribe();
-    }, []);
+    });
     return {
         next,
         complete,

package/dist/utils/arguments.d.ts

@@ -0,0 +1 @@
+export type Arguments<T extends Function> = T extends (...args: infer A) => unknown ? A : never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiszlab/relax",
-  "version": "1.2.20",
+  "version": "1.2.23",
   "description": "react utils collection",
   "type": "module",
   "exports": {