@aiszlab/relax 1.2.19 → 1.2.22

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.d.ts

@@ -1,14 +1,34 @@
 /// <reference types="react" />
+interface Props {
+    /**
+     * @description
+     * initial value
+     */
+    initialValue?: number;
+    /**
+     * @description
+     * max
+     */
+    max?: number;
+    /**
+     * @description
+     * min
+     */
+    min?: number;
+}
 /**
  * @author murukal
  *
  * @description
  * a number counter with some useful apis
  */
-export declare const useCounter: () => {
+export declare const useCounter: ({ max, min, ...props }?: Props) => {
     count: number;
-    next: () => void;
-    prev: () => void;
+    next: (step?: number) => void;
+    prev: (step?: number) => void;
     first: () => void;
+    last: () => void;
+    reset: () => void;
     setCount: import("react").Dispatch<import("react").SetStateAction<number>>;
 };
+export {};

package/dist/hooks/use-counter.mjs

@@ -1,4 +1,6 @@
-import { useState, useCallback } from 'react';
+import { __rest } from '../node_modules/tslib/tslib.es6.mjs';
+import { useMemo, useState, useCallback } from 'react';
+import { clamp } from '../utils/clamp.mjs';
 
 /**
  * @author murukal
@@ -6,22 +8,32 @@ import { useState, useCallback } from 'react';
  * @description
  * a number counter with some useful apis
  */
-const useCounter = () => {
-    const [count, setCount] = useState(0);
-    const next = useCallback(() => {
-        setCount((prev) => prev + 1);
-    }, []);
-    const prev = useCallback(() => {
-        setCount((prev) => prev - 1);
-    }, []);
+const useCounter = (_a = { initialValue: 0, max: Infinity, min: 0 }) => {
+    var { max = Infinity, min = 0 } = _a, props = __rest(_a, ["max", "min"]);
+    const initialValue = useMemo(() => { var _a; return clamp((_a = props.initialValue) !== null && _a !== void 0 ? _a : 0, min, max); }, [max, min, props.initialValue]);
+    const [count, setCount] = useState(initialValue);
+    const next = useCallback((step = 1) => {
+        setCount((prev) => Math.min(max, prev + step));
+    }, [max]);
+    const prev = useCallback((step = 1) => {
+        setCount((prev) => Math.max(prev - step));
+    }, [min]);
     const first = useCallback(() => {
-        setCount(0);
-    }, []);
+        setCount(min);
+    }, [min]);
+    const last = useCallback(() => {
+        setCount(max);
+    }, [max]);
+    const reset = useCallback(() => {
+        setCount(initialValue);
+    }, [initialValue]);
     return {
         count,
         next,
         prev,
         first,
+        last,
+        reset,
         setCount
     };
 };

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

@@ -1,17 +1,23 @@
+import { useEvent } from '../hooks/use-event';
 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> = ReturnType<typeof useEvent<[T], R>>;
 /**
  * @author murukal
  *
  * @description
  * debounce callback
  */
-export declare const useDebounceCallback: <T>(callable: Function, { delay }?: Options) => {
+export declare const useDebounceCallback: <T, R>(_callable: (args_0: 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,3 @@
-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>;
+type Callable<U extends Array<unknown>, R> = (...args: U) => R;
+export declare const useEvent: <U extends unknown[], R>(callable: Callable<U, R>) => Callable<U, R>;
 export {};

package/dist/hooks/use-event.mjs

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

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

@@ -1,4 +1,5 @@
 import { type MutableRefObject, type RefCallback } from 'react';
+import type { Nullable } from '../utils/null-able';
 type Refable<T> = RefCallback<T> | MutableRefObject<T>;
-export declare const useRefs: <T>(...refs: Refable<T>[]) => (trigger: T) => void;
+export declare const useRefs: <T>(...refs: Nullable<Refable<Nullable<T>>>[]) => (trigger: T) => void;
 export {};

package/dist/hooks/use-refs.mjs

@@ -12,6 +12,8 @@ const useRefs = (...refs) => {
     return useMemo(() => {
         return (trigger) => {
             refs.forEach((ref) => {
+                if (!ref)
+                    return;
                 mount(ref, trigger);
             });
         };

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

@@ -1,17 +1,23 @@
+import { useEvent } from '../hooks/use-event';
 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> = ReturnType<typeof useEvent<[T], R>>;
 /**
  * @author murukal
  *
  * @description
  * throttle callback
  */
-export declare const useThrottleCallback: <T>(callable: Function, { duration }?: Options) => {
+export declare const useThrottleCallback: <T, R>(_callable: (args_0: 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/index.d.ts

@@ -47,3 +47,5 @@ export { type RequiredIn } from './utils/required-in';
 export { type ThenableEffectCallback, callAsEffect } from './utils/thenable-effect-callback';
 export { unique, uniqueBy } from './utils/unique';
 export { range } from './utils/range';
+export { clamp } from './utils/clamp';
+export { chain } from './utils/chain';

package/dist/index.mjs

@@ -32,3 +32,5 @@ export { isThenable } from './is/is-thenable.mjs';
 export { callAsEffect } from './utils/thenable-effect-callback.mjs';
 export { unique, uniqueBy } from './utils/unique.mjs';
 export { range } from './utils/range.mjs';
+export { clamp } from './utils/clamp.mjs';
+export { chain } from './utils/chain.mjs';

package/dist/is/is-pointer-usable.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * if pointer event is usable
+ */
+export declare const isPointerUsable: () => boolean;

package/dist/utils/chain.d.ts

@@ -0,0 +1,4 @@
+import type { Partialable } from '../utils/partial-able';
+type Callable<R> = (...args: R[]) => void;
+export declare const chain: <S>(...callbacks: Partialable<Callable<S>>[]) => Callable<S>;
+export {};

package/dist/utils/chain.mjs

@@ -0,0 +1,9 @@
+const chain = (...callbacks) => {
+    return (...args) => {
+        callbacks.forEach((callback) => {
+            callback === null || callback === void 0 ? void 0 : callback(...args);
+        });
+    };
+};
+
+export { chain };

package/dist/utils/clamp.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * get mid value
+ * @param value number
+ * @param min number
+ * @param max number
+ * @returns number
+ */
+export declare const clamp: (value: number, min: number, max: number) => number;

package/dist/utils/clamp.mjs

@@ -0,0 +1,13 @@
+/**
+ * @description
+ * get mid value
+ * @param value number
+ * @param min number
+ * @param max number
+ * @returns number
+ */
+const clamp = (value, min, max) => {
+    return Math.min(Math.max(value, min), max);
+};
+
+export { clamp };

package/package.json

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