@aiszlab/relax 1.2.24 → 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

@@ -7,9 +7,9 @@ import { effect } from '../utils/effect.mjs';
  * @description
  * when components will mount
  */
-const useMount = (callable) => {
+const useMount = (callback) => {
     useLayoutEffect(() => {
-        return effect(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

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

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/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
@@ -46,3 +47,4 @@ 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';
@@ -34,3 +35,4 @@ 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/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

@@ -3,3 +3,4 @@ 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/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/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

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

package/package.json

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