@aiszlab/relax 1.2.23 → 1.2.25

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

@@ -1,24 +1,17 @@
-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;
+import { type Debounced } from '../utils/debounce';
 /**
  * @author murukal
  *
  * @description
  * debounce callback
+ *
+ * @param callback
+ * @param wait number
+ * @description
+ * The delay time (in milliseconds) until the debounce function is called.
+ * default 1000
+ *
+ * @example
+ * 1000
  */
-export declare const useDebounceCallback: <T, R>(_callable: Callable<T, R>, options?: Options) => {
-    next: (value: T) => void;
-    complete: () => void;
-    cancel: () => void;
-};
-export {};
+export declare const useDebounceCallback: <T extends Function>(callback: T, wait?: number) => Debounced<T>;

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

@@ -1,5 +1,5 @@
-import { useRef, useCallback, useEffect } from 'react';
-import { Observable, debounceTime } from 'rxjs';
+import { useRef, useEffect, useMemo } from 'react';
+import { debounce } from '../utils/debounce.mjs';
 import { useEvent } from './use-event.mjs';
 
 /**
@@ -7,51 +7,34 @@ import { useEvent } from './use-event.mjs';
  *
  * @description
  * debounce callback
+ *
+ * @param callback
+ * @param wait number
+ * @description
+ * The delay time (in milliseconds) until the debounce function is called.
+ * default 1000
+ *
+ * @example
+ * 1000
  */
-const useDebounceCallback = (_callable, options) => {
-    var _a;
+const useDebounceCallback = (callback, wait = 1000) => {
     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: callable,
-            complete: listen
-        });
-        listener.current = listened;
-        return listened;
-    }, [delay]);
+    const callable = useEvent(callback);
     useEffect(() => {
-        const listened = listen();
+        const debounced = debounce(callable, wait);
+        trigger.current = debounced;
         // dispose
         return () => {
-            listened.unsubscribe();
-            listener.current = null;
+            debounced.cancel();
             trigger.current = null;
         };
-    }, [listen]);
-    const next = useEvent((value) => {
-        var _a;
-        (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.next(value);
-    });
-    const complete = useEvent(() => {
-        var _a;
-        (_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,
-        cancel
-    };
+    }, [wait]);
+    const debounced = useMemo(() => ({
+        next: ((...args) => { var _a; return (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.next(...args); }),
+        complete: () => { var _a; return (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.complete(); },
+        cancel: () => { var _a; return (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.cancel(); }
+    }), []);
+    return debounced;
 };
 
 export { useDebounceCallback };

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

@@ -0,0 +1,5 @@
+export declare const useHover: () => {
+    isHovered: boolean;
+    onPointerEnter: () => void;
+    onPointerLeave: () => void;
+};

package/dist/hooks/use-hover.mjs

@@ -0,0 +1,19 @@
+import { useBoolean } from './use-boolean.mjs';
+import { useEvent } from './use-event.mjs';
+
+const useHover = () => {
+    const { isOn: isHovered, turnOff, turnOn } = useBoolean(false);
+    const onPointerEnter = useEvent(() => {
+        turnOn();
+    });
+    const onPointerLeave = useEvent(() => {
+        turnOff();
+    });
+    return {
+        isHovered,
+        onPointerEnter,
+        onPointerLeave
+    };
+};
+
+export { useHover };

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

@@ -1,8 +1,8 @@
-import { EffectCallback } from 'react';
+import type { ThenableEffectCallback } from '../types';
 /**
  * @author murukal
  *
  * @description
  * when components will mount
  */
-export declare const useMount: (callable: EffectCallback | UnderlyingSinkCloseCallback) => void;
+export declare const useMount: (callback: ThenableEffectCallback) => void;

package/dist/hooks/use-mount.mjs

@@ -1,5 +1,5 @@
 import { useLayoutEffect } from 'react';
-import { callAsEffect } from '../utils/thenable-effect-callback.mjs';
+import { effect } from '../utils/effect.mjs';
 
 /**
  * @author murukal
@@ -7,9 +7,9 @@ import { callAsEffect } from '../utils/thenable-effect-callback.mjs';
  * @description
  * when components will mount
  */
-const useMount = (callable) => {
+const useMount = (callback) => {
     useLayoutEffect(() => {
-        return callAsEffect(callable);
+        return effect(callback);
     }, []);
 };
 

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

@@ -1,8 +1,8 @@
-import { EffectCallback } from 'react';
+import type { ThenableEffectCallback } from '../types';
 /**
  * @author murukal
  *
  * @description
  * when components mounted
  */
-export declare const useMounted: (callable: EffectCallback | UnderlyingSinkCloseCallback) => void;
+export declare const useMounted: (callback: ThenableEffectCallback) => void;

package/dist/hooks/use-mounted.mjs

@@ -1,5 +1,5 @@
 import { useEffect } from 'react';
-import { callAsEffect } from '../utils/thenable-effect-callback.mjs';
+import { effect } from '../utils/effect.mjs';
 
 /**
  * @author murukal
@@ -7,9 +7,9 @@ import { callAsEffect } from '../utils/thenable-effect-callback.mjs';
  * @description
  * when components mounted
  */
-const useMounted = (callable) => {
+const useMounted = (callback) => {
     useEffect(() => {
-        return callAsEffect(callable);
+        return effect(callback);
     }, []);
 };
 

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

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

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

@@ -1,24 +1,17 @@
-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;
+import { type Throttled } from '../utils/throttle';
 /**
  * @author murukal
  *
  * @description
  * throttle callback
+ *
+ * @param callback
+ * @param duration number
+ * @description
+ * The duration time (in milliseconds) until the throttle function is called.
+ * default 1000
+ *
+ * @example
+ * 1000
  */
-export declare const useThrottleCallback: <T, R>(_callable: Callable<T, R>, options?: Options) => {
-    next: (value: T) => void;
-    complete: () => void;
-    cancel: () => void;
-};
-export {};
+export declare const useThrottleCallback: <T extends Function>(callback: T, duration?: number) => Throttled<T>;

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

@@ -1,5 +1,5 @@
-import { useRef, useCallback, useEffect } from 'react';
-import { Observable, throttleTime } from 'rxjs';
+import { useRef, useEffect, useMemo } from 'react';
+import { throttle } from '../utils/throttle.mjs';
 import { useEvent } from './use-event.mjs';
 
 /**
@@ -7,51 +7,34 @@ import { useEvent } from './use-event.mjs';
  *
  * @description
  * throttle callback
+ *
+ * @param callback
+ * @param duration number
+ * @description
+ * The duration time (in milliseconds) until the throttle function is called.
+ * default 1000
+ *
+ * @example
+ * 1000
  */
-const useThrottleCallback = (_callable, options) => {
-    var _a;
+const useThrottleCallback = (callback, duration = 1000) => {
     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: callable,
-            complete: listen
-        });
-        listener.current = listened;
-        return listened;
-    }, [duration]);
+    const callable = useEvent(callback);
     useEffect(() => {
-        const listened = listen();
+        const throttled = throttle(callable, duration);
+        trigger.current = throttled;
         // dispose
         return () => {
-            listened.unsubscribe();
-            listener.current = null;
+            throttled.cancel();
             trigger.current = null;
         };
-    }, [listen]);
-    const next = useEvent((value) => {
-        var _a;
-        (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.next(value);
-    });
-    const complete = useEvent(() => {
-        var _a;
-        (_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,
-        cancel
-    };
+    }, [duration]);
+    const throttled = useMemo(() => ({
+        next: ((...args) => { var _a; return (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.next(...args); }),
+        complete: () => { var _a; return (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.complete(); },
+        cancel: () => { var _a; return (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.cancel(); }
+    }), []);
+    return throttled;
 };
 
 export { useThrottleCallback };

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

@@ -1,4 +1,4 @@
-import { Key } from 'react';
+import { type Key } from 'react';
 /**
  * @description
  * toggleable key

package/dist/hooks/use-update-effect.d.ts

@@ -1,3 +1,3 @@
 import { DependencyList } from 'react';
-import { ThenableEffectCallback } from '../utils/thenable-effect-callback';
+import type { ThenableEffectCallback } from '../types';
 export declare const useUpdateEffect: (callable: ThenableEffectCallback, deps?: DependencyList) => void;

package/dist/hooks/use-update-effect.mjs

@@ -1,13 +1,13 @@
 import { useRef, useEffect } from 'react';
 import { useMounted } from './use-mounted.mjs';
-import { callAsEffect } from '../utils/thenable-effect-callback.mjs';
+import { effect } from '../utils/effect.mjs';
 
 const useUpdateEffect = (callable, deps) => {
     const isMounted = useRef(false);
     useEffect(() => {
         if (!isMounted.current)
             return;
-        return callAsEffect(callable);
+        return effect(callable);
     }, deps);
     useMounted(() => {
         isMounted.current = true;

package/dist/index.d.ts

@@ -19,6 +19,7 @@ export { useToggleable } from './hooks/use-toggleable';
 export { useEvent } from './hooks/use-event';
 export { useUpdateEffect } from './hooks/use-update-effect';
 export { useCounter } from './hooks/use-counter';
+export { useHover } from './hooks/use-hover';
 /**
  * @description
  * is
@@ -41,11 +42,9 @@ export { isThenable } from './is/is-thenable';
  * @description
  * utils
  */
-export { type Nullable } from './utils/null-able';
-export { type Partialable } from './utils/partial-able';
-export { type RequiredIn } from './utils/required-in';
-export { type ThenableEffectCallback, callAsEffect } from './utils/thenable-effect-callback';
+export { effect } from './utils/effect';
 export { unique, uniqueBy } from './utils/unique';
 export { range } from './utils/range';
 export { clamp } from './utils/clamp';
 export { chain } from './utils/chain';
+export { debounce } from './utils/debounce';

package/dist/index.mjs

@@ -15,6 +15,7 @@ export { useToggleable } from './hooks/use-toggleable.mjs';
 export { useEvent } from './hooks/use-event.mjs';
 export { useUpdateEffect } from './hooks/use-update-effect.mjs';
 export { useCounter } from './hooks/use-counter.mjs';
+export { useHover } from './hooks/use-hover.mjs';
 export { isRefable } from './is/is-refable.mjs';
 export { isUndefined } from './is/is-undefined.mjs';
 export { isStateGetter } from './is/is-state-getter.mjs';
@@ -29,8 +30,9 @@ export { isOverflow } from './is/is-overflow.mjs';
 export { isStyleElement } from './is/is-style-element.mjs';
 export { isFunction } from './is/is-function.mjs';
 export { isThenable } from './is/is-thenable.mjs';
-export { callAsEffect } from './utils/thenable-effect-callback.mjs';
+export { effect } from './utils/effect.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';
+export { debounce } from './utils/debounce.mjs';

package/dist/{utils → types}/arguments.d.ts

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

package/dist/types/first.d.ts

@@ -0,0 +1 @@
+export type First<T> = T extends [infer D, ...Array<unknown>] ? D : undefined;

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export type { Arguments } from './arguments';
+export type { Nullable } from './nullable';
+export type { Partialable } from './partialable';
+export type { RequiredIn } from './required-in';
+export type { ThenableEffectCallback } from './thenable-effect-callback';
+export type { First } from './first';

package/dist/{utils → types}/thenable-effect-callback.d.ts

@@ -4,8 +4,3 @@ import type { EffectCallback } from 'react';
  * thenable effect callback
  */
 export type ThenableEffectCallback = () => ReturnType<EffectCallback> | PromiseLike<ReturnType<EffectCallback>>;
-/**
- * @description
- * call thenable effect callback
- */
-export declare const callAsEffect: (callable: ThenableEffectCallback) => ReturnType<EffectCallback>;

package/dist/utils/chain.d.ts

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

package/dist/utils/debounce.d.ts

@@ -0,0 +1,29 @@
+import { Subscriber } from 'rxjs';
+export interface Debounced<T> {
+    /**
+     * @description
+     * value trigger
+     */
+    next: T;
+    /**
+     * @description
+     * complete current debounce function
+     * this function will not be usable
+     */
+    complete: () => void;
+    /**
+     * @description
+     * ignore any value after call cancel
+     * this function will not be usable
+     */
+    cancel: () => void;
+}
+export declare class Trigger<T> {
+    #private;
+    constructor();
+    set use(subscriber: Subscriber<T>);
+    next(value: T): void;
+    error(error?: unknown): void;
+    complete(): void;
+}
+export declare const debounce: <T extends Function>(callback: T, wait: number) => Debounced<T>;

package/dist/utils/debounce.mjs

@@ -0,0 +1,52 @@
+import { __classPrivateFieldSet, __classPrivateFieldGet } from '../node_modules/tslib/tslib.es6.mjs';
+import { Observable, debounceTime } from 'rxjs';
+
+var _Trigger_next, _Trigger_error, _Trigger_complete;
+class Trigger {
+    constructor() {
+        _Trigger_next.set(this, void 0);
+        _Trigger_error.set(this, void 0);
+        _Trigger_complete.set(this, void 0);
+        __classPrivateFieldSet(this, _Trigger_next, null, "f");
+        __classPrivateFieldSet(this, _Trigger_error, null, "f");
+        __classPrivateFieldSet(this, _Trigger_complete, null, "f");
+    }
+    set use(subscriber) {
+        __classPrivateFieldSet(this, _Trigger_next, (value) => subscriber.next(value), "f");
+        __classPrivateFieldSet(this, _Trigger_error, (error) => subscriber.error(error), "f");
+        __classPrivateFieldSet(this, _Trigger_complete, () => subscriber.complete(), "f");
+    }
+    next(value) {
+        var _a;
+        (_a = __classPrivateFieldGet(this, _Trigger_next, "f")) === null || _a === void 0 ? void 0 : _a.call(this, value);
+    }
+    error(error) {
+        var _a;
+        (_a = __classPrivateFieldGet(this, _Trigger_error, "f")) === null || _a === void 0 ? void 0 : _a.call(this, error);
+    }
+    complete() {
+        var _a;
+        (_a = __classPrivateFieldGet(this, _Trigger_complete, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+}
+_Trigger_next = new WeakMap(), _Trigger_error = new WeakMap(), _Trigger_complete = new WeakMap();
+const debounce = (callback, wait) => {
+    const trigger = new Trigger();
+    const listened = new Observable((subscriber) => {
+        trigger.use = subscriber;
+    })
+        .pipe(debounceTime(wait))
+        .subscribe(() => {
+        callback();
+    });
+    return {
+        next: trigger.next.bind(trigger),
+        complete: trigger.complete.bind(trigger),
+        cancel: () => {
+            listened.unsubscribe();
+            trigger.error();
+        }
+    };
+};
+
+export { Trigger, debounce };

package/dist/utils/effect.d.ts

@@ -0,0 +1,7 @@
+import type { EffectCallback } from 'react';
+import type { ThenableEffectCallback } from '../types';
+/**
+ * @description
+ * call thenable effect
+ */
+export declare const effect: (callable: ThenableEffectCallback) => ReturnType<EffectCallback>;

package/dist/utils/{thenable-effect-callback.mjs → effect.mjs}

@@ -2,9 +2,9 @@ import { isThenable } from '../is/is-thenable.mjs';
 
 /**
  * @description
- * call thenable effect callback
+ * call thenable effect
  */
-const callAsEffect = (callable) => {
+const effect = (callable) => {
     const called = callable();
     // if result is void
     if (!called)
@@ -15,4 +15,4 @@ const callAsEffect = (callable) => {
     return called;
 };
 
-export { callAsEffect };
+export { effect };

package/dist/utils/throttle.d.ts

@@ -0,0 +1,3 @@
+import { type Debounced } from './debounce';
+export type Throttled<T> = Debounced<T>;
+export declare const throttle: <T extends Function>(callback: T, wait: number) => Throttled<T>;

package/dist/utils/throttle.mjs

@@ -0,0 +1,23 @@
+import { Observable, throttleTime } from 'rxjs';
+import { Trigger } from './debounce.mjs';
+
+const throttle = (callback, wait) => {
+    const trigger = new Trigger();
+    const listened = new Observable((subscriber) => {
+        trigger.use = subscriber;
+    })
+        .pipe(throttleTime(wait))
+        .subscribe(() => {
+        callback();
+    });
+    return {
+        next: trigger.next.bind(trigger),
+        complete: trigger.complete.bind(trigger),
+        cancel: () => {
+            listened.unsubscribe();
+            trigger.error();
+        }
+    };
+};
+
+export { throttle };

package/dist/utils/to-array.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * convert any type data to a array
+ */
+export declare const toArray: <T extends unknown[]>(value: unknown) => T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiszlab/relax",
-  "version": "1.2.23",
+  "version": "1.2.25",
   "description": "react utils collection",
   "type": "module",
   "exports": {
@@ -11,7 +11,8 @@
     "./dom": {
       "types": "./dist/dom/index.d.ts",
       "default": "./dist/dom/index.mjs"
-    }
+    },
+    "./types": "./dist/types/index.d.ts"
   },
   "scripts": {
     "dev": "rollup -c -w",
@@ -33,7 +34,7 @@
     "@types/react": "^18",
     "@types/react-dom": "^18",
     "@types/react-is": "^18",
-    "rollup": "^3.27.0",
+    "rollup": "^4.12.0",
     "typescript": "^5.1.3"
   },
   "peerDependencies": {