@aiszlab/relax 1.2.24 → 1.2.26

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

@@ -1,14 +1,19 @@
-/// <reference types="react" />
+import { type Dispatch, type SetStateAction } from 'react';
+import type { State } from "../types";
+type UsedBoolean = [
+    boolean,
+    {
+        turnOn: () => void;
+        turnOff: () => void;
+        toggle: () => void;
+        setBoolean: Dispatch<SetStateAction<boolean>>;
+    }
+];
 /**
  * @author murukal
  *
  * @description
- * boolean state
+ * boolean state, in relax, we already create some api to easy use
  */
-export declare const useBoolean: (initialValue?: boolean) => {
-    isOn: boolean;
-    turnOn: () => void;
-    turnOff: () => void;
-    toggle: () => void;
-    setIsOn: import("react").Dispatch<import("react").SetStateAction<boolean>>;
-};
+export declare const useBoolean: (initialState?: State<boolean>) => UsedBoolean;
+export {};

package/dist/hooks/use-boolean.mjs

@@ -4,20 +4,19 @@ import { useState, useCallback } from 'react';
  * @author murukal
  *
  * @description
- * boolean state
+ * boolean state, in relax, we already create some api to easy use
  */
-const useBoolean = (initialValue) => {
-    const [isOn, setIsOn] = useState(initialValue || false);
+const useBoolean = (initialState) => {
+    const [isOn, setIsOn] = useState(initialState !== null && initialState !== void 0 ? initialState : false);
     const turnOn = useCallback(() => setIsOn(true), []);
     const turnOff = useCallback(() => setIsOn(false), []);
     const toggle = useCallback(() => setIsOn((_isOn) => !_isOn), []);
-    return {
-        isOn,
-        turnOn,
-        turnOff,
-        toggle,
-        setIsOn
-    };
+    return [isOn, {
+            turnOn,
+            turnOff,
+            toggle,
+            setBoolean: setIsOn
+        }];
 };
 
 export { useBoolean };

package/dist/hooks/use-controlled-state.d.ts

@@ -1,5 +1,5 @@
 import { type Dispatch, type SetStateAction } from 'react';
-import { type State } from '../is/is-state-getter';
+import type { State } from "../types";
 interface Dependencies<T> {
     defaultState?: State<T>;
 }

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

@@ -1,34 +1,38 @@
-/// <reference types="react" />
-interface Props {
+import { type Dispatch, type SetStateAction } from 'react';
+import type { State } from '../types';
+type Props = {
     /**
      * @description
      * initial value
      */
-    initialValue?: number;
+    initialState?: State<number>;
     /**
      * @description
-     * max
+     * max: count will not be greater than max
      */
     max?: number;
     /**
      * @description
-     * min
+     * min: count will not be smaller than min
      */
     min?: number;
-}
+};
+type UsedCounter = [
+    number,
+    {
+        add: (step?: number) => void;
+        subtract: (step?: number) => void;
+        first: () => void;
+        last: () => void;
+        reset: () => void;
+        setCount: Dispatch<SetStateAction<number>>;
+    }
+];
 /**
  * @author murukal
  *
  * @description
  * a number counter with some useful apis
  */
-export declare const useCounter: ({ max, min, ...props }?: Props) => {
-    count: number;
-    next: (step?: number) => void;
-    prev: (step?: number) => void;
-    first: () => void;
-    last: () => void;
-    reset: () => void;
-    setCount: import("react").Dispatch<import("react").SetStateAction<number>>;
-};
+export declare const useCounter: (initialState?: State<number>, { max, min }?: Props) => UsedCounter;
 export {};

package/dist/hooks/use-counter.mjs

@@ -1,6 +1,12 @@
-import { __rest } from '../node_modules/tslib/tslib.es6.mjs';
-import { useMemo, useState, useCallback } from 'react';
+import { useState, useCallback, useMemo } from 'react';
 import { clamp } from '../utils/clamp.mjs';
+import '../utils/debounce.mjs';
+import 'rxjs';
+import { useDefault } from './use-default.mjs';
+import './use-scroll-locker.mjs';
+import '../dom/scroll-to.mjs';
+import './use-toggleable.mjs';
+import 'react-is';
 
 /**
  * @author murukal
@@ -8,34 +14,26 @@ import { clamp } from '../utils/clamp.mjs';
  * @description
  * a number counter with some useful apis
  */
-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));
+const useCounter = (initialState, { max = Infinity, min = 0 } = { max: Infinity, min: 0 }) => {
+    const defaultState = useDefault(initialState !== null && initialState !== void 0 ? initialState : 0);
+    const [_count, _setCount] = useState(defaultState);
+    const add = useCallback((step = 1) => {
+        _setCount((prev) => Math.min(max, prev + step));
     }, [max]);
-    const prev = useCallback((step = 1) => {
-        setCount((prev) => Math.max(min, prev - step));
+    const subtract = useCallback((step = 1) => {
+        _setCount((prev) => Math.max(min, prev - step));
     }, [min]);
     const first = useCallback(() => {
-        setCount(min);
+        _setCount(min);
     }, [min]);
     const last = useCallback(() => {
-        setCount(max);
+        _setCount(max);
     }, [max]);
     const reset = useCallback(() => {
-        setCount(initialValue);
-    }, [initialValue]);
-    return {
-        count,
-        next,
-        prev,
-        first,
-        last,
-        reset,
-        setCount
-    };
+        _setCount(defaultState);
+    }, []);
+    const count = useMemo(() => clamp(_count, min, max), [min, max]);
+    return [count, { add, subtract, first, last, reset, setCount: _setCount }];
 };
 
 export { useCounter };

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

@@ -1,4 +1,4 @@
-import { type State } from '../is/is-state-getter';
+import type { State } from '../types';
 /**
  * @author murukal
  *

package/dist/hooks/use-default.mjs

@@ -1,5 +1,5 @@
 import { useMemo } from 'react';
-import { isStateGetter } from '../is/is-state-getter.mjs';
+import { toFunction } from '../utils/to-function.mjs';
 
 /**
  * @author murukal
@@ -8,14 +8,7 @@ import { isStateGetter } from '../is/is-state-getter.mjs';
  * state always be same after first render
  */
 const useDefault = (initialState) => {
-    return useMemo(() => {
-        if (isStateGetter(initialState)) {
-            return initialState();
-        }
-        else {
-            return initialState;
-        }
-    }, []);
+    return useMemo(toFunction(initialState), []);
 };
 
 export { useDefault };

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

@@ -0,0 +1,9 @@
+type UsedFocus = [
+    boolean,
+    {
+        onFocus: () => void;
+        onBlur: () => void;
+    }
+];
+export declare const useFoucs: () => UsedFocus;
+export {};

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

@@ -0,0 +1,9 @@
+type UsedHover = [
+    boolean,
+    {
+        onPointerEnter: () => void;
+        onPointerLeave: () => void;
+    }
+];
+export declare const useHover: () => UsedHover;
+export {};

package/dist/hooks/use-hover.mjs

@@ -0,0 +1,15 @@
+import { useCallback } from 'react';
+import { useBoolean } from './use-boolean.mjs';
+
+const useHover = () => {
+    const [isHovered, { turnOn, turnOff }] = useBoolean(false);
+    const onPointerEnter = useCallback(() => {
+        turnOn();
+    }, []);
+    const onPointerLeave = useCallback(() => {
+        turnOff();
+    }, []);
+    return [isHovered, { onPointerEnter, onPointerLeave }];
+};
+
+export { useHover };

package/dist/hooks/use-image-loader.d.ts

@@ -1,5 +1,5 @@
 type Status = 'none' | 'loading' | 'error' | 'loaded';
-interface Dependencies {
+interface Props {
     src: string;
 }
 /**
@@ -8,5 +8,5 @@ interface Dependencies {
  * @description
  * image loader
  */
-export declare const useImageLoader: ({ src }: Dependencies) => Status;
+export declare const useImageLoader: ({ src }: Props) => Status;
 export {};

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

@@ -1,4 +1,4 @@
-import { State } from '../is/is-state-getter';
+import type { State } from '../types';
 /**
  * @description
  * use reactive

package/dist/hooks/use-scroll-locker.mjs

@@ -3,25 +3,22 @@ import { useId, useLayoutEffect } from 'react';
 import { isOverflow } from '../is/is-overflow.mjs';
 import { isStyleElement } from '../is/is-style-element.mjs';
 
-var _ScrollLocker_scrollLocker, _ScrollLocker_barSize;
+var _a, _ScrollLocker_scrollLocker, _ScrollLocker_barSize;
 const isComputable = (value) => /^(.*)px$/.test(value);
 class ScrollLocker {
     constructor() {
-        var _a;
-        // singleton mode
-        _ScrollLocker_scrollLocker.set(this, null
-        // bar size
-        );
+        var _b;
+        var _c;
         // bar size
         _ScrollLocker_barSize.set(this, null);
-        return (__classPrivateFieldSet(this, _ScrollLocker_scrollLocker, (_a = __classPrivateFieldGet(this, _ScrollLocker_scrollLocker, "f")) !== null && _a !== void 0 ? _a : this, "f"));
+        return (__classPrivateFieldSet(_c = _a, _a, (_b = __classPrivateFieldGet(_c, _a, "f", _ScrollLocker_scrollLocker)) !== null && _b !== void 0 ? _b : this, "f", _ScrollLocker_scrollLocker));
     }
     get barSize() {
-        var _a;
+        var _b;
         if (__classPrivateFieldGet(this, _ScrollLocker_barSize, "f"))
             return __classPrivateFieldGet(this, _ScrollLocker_barSize, "f");
         const { width, height } = getComputedStyle(document.body, '::-webkit-scrollbar');
-        return (__classPrivateFieldSet(this, _ScrollLocker_barSize, (_a = __classPrivateFieldGet(this, _ScrollLocker_barSize, "f")) !== null && _a !== void 0 ? _a : {
+        return (__classPrivateFieldSet(this, _ScrollLocker_barSize, (_b = __classPrivateFieldGet(this, _ScrollLocker_barSize, "f")) !== null && _b !== void 0 ? _b : {
             width: isComputable(width) ? width : '0',
             height: isComputable(height) ? height : '0'
         }, "f"));
@@ -64,7 +61,9 @@ class ScrollLocker {
         this.container.removeChild(locked);
     }
 }
-_ScrollLocker_scrollLocker = new WeakMap(), _ScrollLocker_barSize = new WeakMap();
+_a = ScrollLocker, _ScrollLocker_barSize = new WeakMap();
+// singleton mode
+_ScrollLocker_scrollLocker = { value: null };
 const useScrollLocker = (isLock) => {
     const id = useId();
     useLayoutEffect(() => {

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

@@ -7,5 +7,5 @@ interface Options {
  * @description
  * timeout effect
  */
-export declare const useTimeout: (handler: UnderlyingSinkCloseCallback, { duration }: Options) => void;
+export declare const useTimeout: (handler: Function, { duration }: Options) => void;
 export {};

package/dist/hooks/use-timeout.mjs

@@ -1,4 +1,4 @@
-import { useRef, useEffect } from 'react';
+import { useEffect } from 'react';
 
 /**
  * @author murukal
@@ -7,13 +7,12 @@ import { useRef, useEffect } from 'react';
  * timeout effect
  */
 const useTimeout = (handler, { duration }) => {
-    const timer = useRef(null);
     useEffect(() => {
-        timer.current = setTimeout(handler, duration);
+        const timer = setTimeout(handler, duration);
         return () => {
-            if (!timer.current)
+            if (!timer)
                 return;
-            clearTimeout(timer.current);
+            clearTimeout(timer);
         };
     }, [duration]);
 };

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,6 @@ 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';
+export { toArray } from './utils/to-array';
+export { toFunction } from './utils/to-function';

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,6 @@ 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';
+export { toArray } from './utils/to-array.mjs';
+export { toFunction } from './utils/to-function.mjs';

package/dist/is/is-state-getter.d.ts

@@ -1,14 +1,6 @@
-type StateGetter<T> = () => T;
-/**
- * @description
- * state setter
- *
- * used by initial state, default state, controlled state
- */
-export type State<T> = T | StateGetter<T>;
+import type { State, StateGetter } from "../types";
 /**
  * @description
  * is state getter
  */
 export declare const isStateGetter: <T>(state: State<T>) => state is StateGetter<T>;
-export {};

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,5 @@ 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';
+export type { State, StateGetter } from './state';

package/dist/types/state.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @description
+ * in react, define some initial state always use a value getter
+ */
+export type StateGetter<T> = () => T;
+/**
+ * @description
+ * value or state setter
+ */
+export type State<T> = T | StateGetter<T>;

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/dist/utils/to-array.mjs

@@ -0,0 +1,12 @@
+/**
+ * @description
+ * convert any type data to a array
+ */
+const toArray = (value) => {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return [value];
+};
+
+export { toArray };

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

@@ -0,0 +1 @@
+export declare const toFunction: <T extends Function>(value: unknown) => T;

package/dist/utils/to-function.mjs

@@ -0,0 +1,11 @@
+import { isFunction } from '../is/is-function.mjs';
+
+const toFunction = (value) => {
+    const _isFunction = isFunction(value);
+    if (_isFunction) {
+        return value;
+    }
+    return (() => value);
+};
+
+export { toFunction };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiszlab/relax",
-  "version": "1.2.24",
+  "version": "1.2.26",
   "description": "react utils collection",
   "type": "module",
   "exports": {
@@ -26,7 +26,7 @@
   },
   "devDependencies": {
     "@babel/core": "^7.22.5",
-    "@babel/preset-env": "^7.22.5",
+    "@babel/preset-env": "^7.24.0",
     "@babel/preset-typescript": "^7.22.5",
     "@rollup/plugin-babel": "^6.0.3",
     "@rollup/plugin-node-resolve": "^15.1.0",