@aiszlab/relax 1.2.11-beta.1 → 1.2.11-beta.2

package/dist/dom/index.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var scrollTo = require('./scroll-to.cjs');
+
+
+
+exports.scrollTo = scrollTo.scrollTo;

package/dist/dom/index.mjs

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

package/dist/dom/scroll-to.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+var tslib_es6 = require('../node_modules/tslib/tslib.es6.cjs');
+
+var _Scroller_scrolled, _Scroller_scroller;
+class Scroller {
+    constructor() {
+        var _a;
+        _Scroller_scrolled.set(this, new Map()
+        // singleton mode
+        );
+        // singleton mode
+        _Scroller_scroller.set(this, null);
+        return (tslib_es6.__classPrivateFieldSet(this, _Scroller_scroller, (_a = tslib_es6.__classPrivateFieldGet(this, _Scroller_scroller, "f")) !== null && _a !== void 0 ? _a : this, "f"));
+    }
+    get scrolled() {
+        return tslib_es6.__classPrivateFieldGet(this, _Scroller_scrolled, "f");
+    }
+    currentAt(direction) {
+        return direction === 'vertical' ? 'scrollTop' : 'scrollLeft';
+    }
+}
+_Scroller_scrolled = new WeakMap(), _Scroller_scroller = new WeakMap();
+/**
+ * @description
+ * scroll to for wrapper element
+ */
+const scrollTo = (target, to, { duration = 0, direction = 'vertical' } = {
+    duration: 0,
+    direction: 'vertical'
+}) => {
+    const scroller = new Scroller();
+    const scrolled = scroller.scrolled.get(target);
+    const currentAtProperty = scroller.currentAt(direction);
+    if (scrolled) {
+        cancelAnimationFrame(scrolled);
+        scroller.scrolled.delete(target);
+    }
+    // if duration <= 0, jump immediately
+    if (duration <= 0) {
+        scroller.scrolled.set(target, requestAnimationFrame(() => {
+            target[currentAtProperty] = to;
+        }));
+        return;
+    }
+    // animate
+    const currentAt = target[currentAtProperty];
+    const difference = to - currentAt;
+    const step = (difference / duration) * 10;
+    scroller.scrolled.set(target, requestAnimationFrame(() => {
+        target[currentAtProperty] = currentAt + step;
+        // over end, stop any animation
+        if (target[currentAtProperty] === to)
+            return;
+        scrollTo(target, to, {
+            duration: duration - 10,
+            direction
+        });
+    }));
+};
+
+exports.scrollTo = scrollTo;

package/dist/dom/{scroll-to.js → scroll-to.mjs}

@@ -1,4 +1,4 @@
-import { __classPrivateFieldSet, __classPrivateFieldGet } from '../node_modules/tslib/tslib.es6.js';
+import { __classPrivateFieldSet, __classPrivateFieldGet } from '../node_modules/tslib/tslib.es6.mjs';
 
 var _Scroller_scrolled, _Scroller_scroller;
 class Scroller {

package/dist/hooks/use-boolean.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var react = require('react');
+
+/**
+ * @author murukal
+ *
+ * @description
+ * boolean state
+ */
+const useBoolean = (initialValue) => {
+    const [isOn, setIsOn] = react.useState(initialValue || false);
+    const turnOn = react.useCallback(() => setIsOn(true), []);
+    const turnOff = react.useCallback(() => setIsOn(false), []);
+    const toggle = react.useCallback(() => setIsOn((_isOn) => !_isOn), []);
+    return {
+        isOn,
+        turnOn,
+        turnOff,
+        toggle,
+        setIsOn
+    };
+};
+
+exports.useBoolean = useBoolean;

package/dist/hooks/use-controlled-state.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+var react = require('react');
+var isStateGetter = require('../is/is-state-getter.cjs');
+var isUndefined = require('../is/is-undefined.cjs');
+
+/**
+ * @author murukal
+ *
+ * @description
+ * controlled state
+ */
+const useControlledState = (controlledState, { defaultState } = {}) => {
+    /// initialize state
+    const [state, setState] = react.useState(() => {
+        // state function, run it for value
+        if (isStateGetter.isStateGetter(controlledState))
+            return controlledState();
+        // not controlled use default prop
+        if (isUndefined.isUndefined(controlledState)) {
+            if (isUndefined.isUndefined(defaultState))
+                return controlledState;
+            if (isStateGetter.isStateGetter(defaultState))
+                return defaultState();
+            return defaultState;
+        }
+        // default use controlled state
+        return controlledState;
+    });
+    react.useEffect(() => {
+        // when state is not controlled
+        if (isUndefined.isUndefined(controlledState))
+            return;
+        // if input state is function, mean it is not controlled
+        if (isStateGetter.isStateGetter(controlledState))
+            return;
+        // if state is equal with value
+        if (controlledState === state)
+            return;
+        // update inner state
+        setState(controlledState);
+    }, [controlledState]);
+    return [state, setState];
+};
+
+exports.useControlledState = useControlledState;

package/dist/hooks/{use-controlled-state.js → use-controlled-state.mjs}

@@ -1,6 +1,6 @@
 import { useState, useEffect } from 'react';
-import { isStateGetter } from '../is/is-state-getter.js';
-import { isUndefined } from '../is/is-undefined.js';
+import { isStateGetter } from '../is/is-state-getter.mjs';
+import { isUndefined } from '../is/is-undefined.mjs';
 
 /**
  * @author murukal

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

@@ -0,0 +1,68 @@
+'use strict';
+
+var react = require('react');
+var rxjs = require('rxjs');
+
+/**
+ * @author murukal
+ *
+ * @description
+ * debounce callback
+ */
+const useDebounceCallback = (callable, options) => {
+    var _a;
+    // delay
+    const delay = (_a = options.delay) !== null && _a !== void 0 ? _a : 1000;
+    // runner
+    const runner = react.useRef();
+    // listener
+    const listener = react.useRef();
+    /// initialze listener function for debouce
+    const initialize = react.useCallback(() => {
+        listener.current = new rxjs.Observable((subscriber) => {
+            runner.current = subscriber;
+        })
+            .pipe(rxjs.debounceTime(options.delay))
+            .subscribe({
+            next: (value) => {
+                callable(value);
+            },
+            complete: () => {
+                initialize();
+            }
+        });
+    }, [callable, delay]);
+    /// initialize debounce function
+    /// when delay / callable changed, need reinitialize
+    react.useEffect(() => {
+        initialize();
+        // dispose
+        return () => {
+            var _a;
+            (_a = listener.current) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        };
+    }, [initialize]);
+    /// next function has been debounced for hooks user
+    const next = react.useCallback((value) => {
+        var _a;
+        (_a = runner.current) === null || _a === void 0 ? void 0 : _a.next(value);
+    }, []);
+    /// flush the debounce
+    const complete = react.useCallback(() => {
+        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 = react.useCallback(() => {
+        var _a;
+        (_a = listener.current) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+    }, []);
+    return {
+        next,
+        complete,
+        cancel
+    };
+};
+
+exports.useDebounceCallback = useDebounceCallback;

package/dist/hooks/use-force-update.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var react = require('react');
+
+/**
+ * @description
+ * force update
+ */
+const useForceUpdate = () => {
+    const [times, setTimes] = react.useState(1);
+    const forceUpdate = react.useCallback(() => {
+        setTimes((prev) => prev + 1);
+    }, []);
+    return {
+        times,
+        forceUpdate
+    };
+};
+
+exports.useForceUpdate = useForceUpdate;

package/dist/hooks/use-image-loader.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var react = require('react');
+var rxjs = require('rxjs');
+
+/**
+ * @author murukal
+ *
+ * @description
+ * image loader
+ */
+const useImageLoader = ({ src }) => {
+    const loader = react.useRef();
+    const [status, setStatus] = react.useState('none');
+    react.useEffect(() => {
+        if (!src) {
+            return setStatus('none');
+        }
+        // create observable to listen img status
+        new rxjs.Observable((subscriber) => {
+            loader.current = subscriber;
+            subscriber.next();
+        }).subscribe({
+            next: () => setStatus('loading'),
+            complete: () => setStatus('loaded'),
+            error: () => setStatus('error')
+        });
+        const image = new Image();
+        image.addEventListener('load', () => {
+            var _a;
+            (_a = loader.current) === null || _a === void 0 ? void 0 : _a.complete();
+        });
+        image.addEventListener('error', () => {
+            var _a;
+            (_a = loader.current) === null || _a === void 0 ? void 0 : _a.error(null);
+        });
+        image.src = src;
+    }, [src]);
+    return status;
+};
+
+exports.useImageLoader = useImageLoader;

package/dist/hooks/use-mount.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var react = require('react');
+
+/**
+ * @author murukal
+ *
+ * @description
+ * when components will mount
+ */
+const useMount = (callable) => {
+    react.useLayoutEffect(() => {
+        const called = callable();
+        // if result is void
+        if (!called) {
+            return void 0;
+        }
+        // if result is promise like, return void
+        if (called.then) {
+            return void 0;
+        }
+        return called;
+    }, []);
+};
+
+exports.useMount = useMount;

package/dist/hooks/use-mounted.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var react = require('react');
+
+/**
+ * @author murukal
+ *
+ * @description
+ * when components mounted
+ */
+const useMounted = (callable) => {
+    react.useEffect(() => {
+        const called = callable();
+        // if result is void
+        if (!called) {
+            return void 0;
+        }
+        // if result is promise like, return void
+        if (called.then) {
+            return void 0;
+        }
+        return called;
+    }, []);
+};
+
+exports.useMounted = useMounted;

package/dist/hooks/use-once-state.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var react = require('react');
+
+/**
+ * @author murukal
+ *
+ * @description
+ * state always be same after first render
+ */
+const useOnceState = (initialState) => {
+    return react.useState(initialState)[0];
+};
+
+exports.useOnceState = useOnceState;

package/dist/hooks/use-refs.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var react = require('react');
+var isFunction = require('../is/is-function.cjs');
+
+const mount = (ref, trigger) => {
+    if (isFunction.isFunction(ref)) {
+        ref(trigger);
+        return;
+    }
+    ref.current = trigger;
+};
+const useRefs = (...refs) => {
+    return react.useMemo(() => {
+        return (trigger) => {
+            refs.forEach((ref) => {
+                mount(ref, trigger);
+            });
+        };
+    }, refs);
+};
+
+exports.useRefs = useRefs;

package/dist/hooks/{use-refs.js → use-refs.mjs}

@@ -1,5 +1,5 @@
 import { useMemo } from 'react';
-import { isFunction } from '../is/is-function.js';
+import { isFunction } from '../is/is-function.mjs';
 
 const mount = (ref, trigger) => {
     if (isFunction(ref)) {

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

@@ -0,0 +1,86 @@
+'use strict';
+
+var tslib_es6 = require('../node_modules/tslib/tslib.es6.cjs');
+var react = require('react');
+var isOverflow = require('../is/is-overflow.cjs');
+var isStyleElement = require('../is/is-style-element.cjs');
+
+var _ScrollLocker_scrollLocker, _ScrollLocker_barSize;
+const isComputable = (value) => /^(.*)px$/.test(value);
+class ScrollLocker {
+    constructor() {
+        var _a;
+        // singleton mode
+        _ScrollLocker_scrollLocker.set(this, null
+        // bar size
+        );
+        // bar size
+        _ScrollLocker_barSize.set(this, null);
+        return (tslib_es6.__classPrivateFieldSet(this, _ScrollLocker_scrollLocker, (_a = tslib_es6.__classPrivateFieldGet(this, _ScrollLocker_scrollLocker, "f")) !== null && _a !== void 0 ? _a : this, "f"));
+    }
+    get barSize() {
+        var _a;
+        if (tslib_es6.__classPrivateFieldGet(this, _ScrollLocker_barSize, "f"))
+            return tslib_es6.__classPrivateFieldGet(this, _ScrollLocker_barSize, "f");
+        const { width, height } = getComputedStyle(document.body, '::-webkit-scrollbar');
+        return (tslib_es6.__classPrivateFieldSet(this, _ScrollLocker_barSize, (_a = tslib_es6.__classPrivateFieldGet(this, _ScrollLocker_barSize, "f")) !== null && _a !== void 0 ? _a : {
+            width: isComputable(width) ? width : '0',
+            height: isComputable(height) ? height : '0'
+        }, "f"));
+    }
+    get isOverflow() {
+        return isOverflow.isOverflow();
+    }
+    get locker() {
+        return `html body {
+  overflow-y: hidden;
+  ${this.isOverflow ? `width: calc(100% - ${this.barSize.width});` : ''}
+}`;
+    }
+    get container() {
+        return document.head || document.body;
+    }
+    getLocked(id) {
+        return Array.from(this.container.children).filter((element) => isStyleElement.isStyleElement(element)).find((element) => element.id === id);
+    }
+    lock(id) {
+        if (!this.container)
+            return;
+        const locked = this.getLocked(id);
+        if (locked) {
+            if (locked.innerHTML !== this.locker) {
+                locked.innerHTML = this.locker;
+            }
+            return locked;
+        }
+        const locker = document.createElement('style');
+        locker.id = id;
+        locker.innerHTML = this.locker;
+        this.container.appendChild(locker);
+        return locker;
+    }
+    unlock(id) {
+        const locked = this.getLocked(id);
+        if (!locked)
+            return;
+        this.container.removeChild(locked);
+    }
+}
+_ScrollLocker_scrollLocker = new WeakMap(), _ScrollLocker_barSize = new WeakMap();
+const useScrollLocker = (isLock) => {
+    const id = react.useId();
+    react.useLayoutEffect(() => {
+        const scrollLocker = new ScrollLocker();
+        if (!!isLock) {
+            scrollLocker.lock(id);
+        }
+        else {
+            scrollLocker.unlock(id);
+        }
+        return () => {
+            scrollLocker.unlock(id);
+        };
+    }, [!!isLock, id]);
+};
+
+exports.useScrollLocker = useScrollLocker;

package/dist/hooks/{use-scroll-locker.js → use-scroll-locker.mjs}

@@ -1,7 +1,7 @@
-import { __classPrivateFieldSet, __classPrivateFieldGet } from '../node_modules/tslib/tslib.es6.js';
+import { __classPrivateFieldSet, __classPrivateFieldGet } from '../node_modules/tslib/tslib.es6.mjs';
 import { useId, useLayoutEffect } from 'react';
-import { isOverflow } from '../is/is-overflow.js';
-import { isStyleElement } from '../is/is-style-element.js';
+import { isOverflow } from '../is/is-overflow.mjs';
+import { isStyleElement } from '../is/is-style-element.mjs';
 
 var _ScrollLocker_scrollLocker, _ScrollLocker_barSize;
 const isComputable = (value) => /^(.*)px$/.test(value);

package/dist/hooks/use-scrollable.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var react = require('react');
+var scrollTo = require('../dom/scroll-to.cjs');
+
+/**
+ * @description
+ * scrollable hook
+ */
+const useScrollable = ({ direction = 'vertical' } = {}) => {
+    const targetRef = react.useRef(null);
+    const triggerRefs = react.useRef(new Map());
+    const scrollTo$1 = react.useCallback((to, duration = 0) => {
+        const target = targetRef.current;
+        if (!target)
+            return;
+        // use animated scroll
+        scrollTo.scrollTo(target, to, {
+            duration,
+            direction
+        });
+    }, [direction]);
+    const to = react.useCallback((key) => {
+        const trigger = triggerRefs.current.get(key);
+        if (!trigger)
+            return 0;
+        // different direction, use different property
+        return direction === 'vertical' ? trigger.offsetTop : trigger.offsetLeft;
+    }, [direction]);
+    /// set trigger
+    const setTrigger = react.useCallback((key, trigger) => {
+        triggerRefs.current.set(key, trigger);
+    }, []);
+    return {
+        targetRef,
+        triggerRefs,
+        scrollTo: scrollTo$1,
+        to,
+        setTrigger
+    };
+};
+
+exports.useScrollable = useScrollable;

package/dist/hooks/{use-scrollable.js → use-scrollable.mjs}

@@ -1,5 +1,5 @@
 import { useRef, useCallback } from 'react';
-import { scrollTo } from '../dom/scroll-to.js';
+import { scrollTo } from '../dom/scroll-to.mjs';
 
 /**
  * @description

package/dist/hooks/use-timeout.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var react = require('react');
+
+/**
+ * @author murukal
+ *
+ * @description
+ * timeout effect
+ */
+const useTimeout = (handler, { duration }) => {
+    const timer = react.useRef(null);
+    react.useEffect(() => {
+        timer.current = setTimeout(handler, duration);
+        return () => {
+            if (!timer.current)
+                return;
+            clearTimeout(timer.current);
+        };
+    }, [duration]);
+};
+
+exports.useTimeout = useTimeout;

package/dist/hooks/use-toggleable.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+var react = require('react');
+
+/**
+ * @description
+ * toggle able
+ */
+const useToggleable = ({ keys, isAllDefaultToggled } = {}) => {
+    const [toggledKeys, setToggledKeys] = react.useState(() => {
+        if (isAllDefaultToggled) {
+            return new Map(keys === null || keys === void 0 ? void 0 : keys.map((key) => [key, true]));
+        }
+        return new Map();
+    });
+    /// toggle by flag
+    const toggleBy = react.useCallback((key, isToggled) => {
+        setToggledKeys((prev) => {
+            if (isToggled) {
+                return new Map(prev).set(key, true);
+            }
+            const _toggledKeys = new Map(prev);
+            _toggledKeys.delete(key);
+            return _toggledKeys;
+        });
+    }, []);
+    /// if all key is toggled
+    const isAllToggled = react.useMemo(() => {
+        return toggledKeys.size === (keys === null || keys === void 0 ? void 0 : keys.length);
+    }, [toggledKeys, keys]);
+    /// is toggled
+    const isToggled = react.useCallback((key) => {
+        return toggledKeys.has(key);
+    }, [toggledKeys]);
+    /// toggle
+    const toggle = react.useCallback((key) => {
+        toggleBy(key, !isToggled(key));
+    }, [toggleBy, isToggled]);
+    /// toggle all
+    const toggleAll = react.useCallback(() => {
+        if (isAllToggled) {
+            setToggledKeys(new Map());
+        }
+        else {
+            setToggledKeys(new Map(keys === null || keys === void 0 ? void 0 : keys.map((key) => [key, true])));
+        }
+    }, [isAllToggled, keys]);
+    return {
+        toggleBy,
+        toggle,
+        toggleAll,
+        isToggled,
+        toggledKeys,
+        isAllToggled
+    };
+};
+
+exports.useToggleable = useToggleable;

package/dist/index.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+var useBoolean = require('./hooks/use-boolean.cjs');
+var useDebounceCallback = require('./hooks/use-debounce-callback.cjs');
+var useImageLoader = require('./hooks/use-image-loader.cjs');
+var useMount = require('./hooks/use-mount.cjs');
+var useMounted = require('./hooks/use-mounted.cjs');
+var useTimeout = require('./hooks/use-timeout.cjs');
+var useControlledState = require('./hooks/use-controlled-state.cjs');
+var useOnceState = require('./hooks/use-once-state.cjs');
+var useScrollLocker = require('./hooks/use-scroll-locker.cjs');
+var useForceUpdate = require('./hooks/use-force-update.cjs');
+var useScrollable = require('./hooks/use-scrollable.cjs');
+var useRefs = require('./hooks/use-refs.cjs');
+var useToggleable = require('./hooks/use-toggleable.cjs');
+var isRefable = require('./is/is-refable.cjs');
+var isUndefined = require('./is/is-undefined.cjs');
+var isStateGetter = require('./is/is-state-getter.cjs');
+var isNull = require('./is/is-null.cjs');
+var isVoid = require('./is/is-void.cjs');
+var isArray = require('./is/is-array.cjs');
+var isComplex = require('./is/is-complex.cjs');
+var isEmpty = require('./is/is-empty.cjs');
+var isDomUsable = require('./is/is-dom-usable.cjs');
+var isMobile = require('./is/is-mobile.cjs');
+var isOverflow = require('./is/is-overflow.cjs');
+var isStyleElement = require('./is/is-style-element.cjs');
+var isFunction = require('./is/is-function.cjs');
+
+
+
+exports.useBoolean = useBoolean.useBoolean;
+exports.useDebounceCallback = useDebounceCallback.useDebounceCallback;
+exports.useImageLoader = useImageLoader.useImageLoader;
+exports.useMount = useMount.useMount;
+exports.useMounted = useMounted.useMounted;
+exports.useTimeout = useTimeout.useTimeout;
+exports.useControlledState = useControlledState.useControlledState;
+exports.useOnceState = useOnceState.useOnceState;
+exports.useScrollLocker = useScrollLocker.useScrollLocker;
+exports.useForceUpdate = useForceUpdate.useForceUpdate;
+exports.useScrollable = useScrollable.useScrollable;
+exports.useRefs = useRefs.useRefs;
+exports.useToggleable = useToggleable.useToggleable;
+exports.isRefable = isRefable.isRefable;
+exports.isUndefined = isUndefined.isUndefined;
+exports.isStateGetter = isStateGetter.isStateGetter;
+exports.isNull = isNull.isNull;
+exports.isVoid = isVoid.isVoid;
+exports.isArray = isArray.isArray;
+exports.isComplex = isComplex.isComplex;
+exports.isEmpty = isEmpty.isEmpty;
+exports.isDomUsable = isDomUsable.isDomUsable;
+exports.isMobile = isMobile.isMobile;
+exports.isOverflow = isOverflow.isOverflow;
+exports.isStyleElement = isStyleElement.isStyleElement;
+exports.isFunction = isFunction.isFunction;

package/dist/index.mjs

@@ -0,0 +1,26 @@
+export { useBoolean } from './hooks/use-boolean.mjs';
+export { useDebounceCallback } from './hooks/use-debounce-callback.mjs';
+export { useImageLoader } from './hooks/use-image-loader.mjs';
+export { useMount } from './hooks/use-mount.mjs';
+export { useMounted } from './hooks/use-mounted.mjs';
+export { useTimeout } from './hooks/use-timeout.mjs';
+export { useControlledState } from './hooks/use-controlled-state.mjs';
+export { useOnceState } from './hooks/use-once-state.mjs';
+export { useScrollLocker } from './hooks/use-scroll-locker.mjs';
+export { useForceUpdate } from './hooks/use-force-update.mjs';
+export { useScrollable } from './hooks/use-scrollable.mjs';
+export { useRefs } from './hooks/use-refs.mjs';
+export { useToggleable } from './hooks/use-toggleable.mjs';
+export { isRefable } from './is/is-refable.mjs';
+export { isUndefined } from './is/is-undefined.mjs';
+export { isStateGetter } from './is/is-state-getter.mjs';
+export { isNull } from './is/is-null.mjs';
+export { isVoid } from './is/is-void.mjs';
+export { isArray } from './is/is-array.mjs';
+export { isComplex } from './is/is-complex.mjs';
+export { isEmpty } from './is/is-empty.mjs';
+export { isDomUsable } from './is/is-dom-usable.mjs';
+export { isMobile } from './is/is-mobile.mjs';
+export { isOverflow } from './is/is-overflow.mjs';
+export { isStyleElement } from './is/is-style-element.mjs';
+export { isFunction } from './is/is-function.mjs';

package/dist/is/is-array.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * @description
+ * is array
+ */
+const isArray = (value) => {
+    return Array.isArray(value);
+};
+
+exports.isArray = isArray;

package/dist/is/is-complex.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * @description
+ * complex
+ */
+const isComplex = (value) => {
+    return typeof value === 'object' || typeof value === 'function';
+};
+
+exports.isComplex = isComplex;

package/dist/is/is-dom-usable.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * @description
+ * if there is dom
+ */
+const isDomUsable = () => {
+    return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+};
+
+exports.isDomUsable = isDomUsable;

package/dist/is/is-empty.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var isVoid = require('./is-void.cjs');
+var isArray = require('./is-array.cjs');
+
+/**
+ * @author murukal
+ *
+ * @description
+ * is empty
+ */
+const isEmpty = (value) => {
+    // null or undefined
+    if (isVoid.isVoid(value))
+        return true;
+    // object
+    if (typeof value === 'object') {
+        return Object.keys(value).length === 0;
+    }
+    // array
+    if (isArray.isArray(value)) {
+        return value.length === 0;
+    }
+    return !!value;
+};
+
+exports.isEmpty = isEmpty;

package/dist/is/{is-empty.js → is-empty.mjs}

@@ -1,5 +1,5 @@
-import { isVoid } from './is-void.js';
-import { isArray } from './is-array.js';
+import { isVoid } from './is-void.mjs';
+import { isArray } from './is-array.mjs';
 
 /**
  * @author murukal

package/dist/is/is-function.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * @description
+ * if is function
+ */
+const isFunction = (value) => {
+    return typeof value === 'function';
+};
+
+exports.isFunction = isFunction;

package/dist/is/is-mobile.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+/**
+ * @description
+ * is mobile
+ */
+const isMobile = () => {
+    if (typeof navigator === 'undefined' || typeof window === 'undefined') {
+        return false;
+    }
+    const agent = navigator.userAgent ||
+        navigator.vendor ||
+        window.opera;
+    return (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(agent) ||
+        /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw-(n|u)|c55\/|capi|ccwa|cdm-|cell|chtm|cldc|cmd-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc-s|devi|dica|dmob|do(c|p)o|ds(12|-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(-|_)|g1 u|g560|gene|gf-5|g-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd-(m|p|t)|hei-|hi(pt|ta)|hp( i|ip)|hs-c|ht(c(-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i-(20|go|ma)|i230|iac( |-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|-[a-w])|libw|lynx|m1-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|-([1-8]|c))|phil|pire|pl(ay|uc)|pn-2|po(ck|rt|se)|prox|psio|pt-g|qa-a|qc(07|12|21|32|60|-[2-7]|i-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h-|oo|p-)|sdk\/|se(c(-|0|1)|47|mc|nd|ri)|sgh-|shar|sie(-|m)|sk-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h-|v-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl-|tdg-|tel(i|m)|tim-|t-mo|to(pl|sh)|ts(70|m-|m3|m5)|tx-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas-|your|zeto|zte-/i.test(agent === null || agent === void 0 ? void 0 : agent.substring(0, 4)));
+};
+
+exports.isMobile = isMobile;

package/dist/is/is-null.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * @description
+ * is null
+ */
+const isNull = (value) => {
+    return value === null;
+};
+
+exports.isNull = isNull;

package/dist/is/is-overflow.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+/**
+ * @description
+ * if is overflow
+ */
+function isOverflow() {
+    return (document.body.scrollHeight > (window.innerHeight || document.documentElement.clientHeight) &&
+        window.innerWidth > document.body.offsetWidth);
+}
+
+exports.isOverflow = isOverflow;

package/dist/is/is-refable.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var react = require('react');
+var reactIs = require('react-is');
+
+/**
+ * @description
+ */
+const isRefable = (node) => {
+    if (!react.isValidElement(node)) {
+        return false;
+    }
+    if (reactIs.isFragment(node)) {
+        return false;
+    }
+    return _RefableElement(node);
+};
+/**
+ * @description
+ * refable element
+ */
+const _RefableElement = (element) => {
+    var _a, _b;
+    const type = reactIs.isMemo(element) ? element.type.type : element.type;
+    // Function component node
+    if (typeof type === 'function' && !((_a = type.prototype) === null || _a === void 0 ? void 0 : _a.render)) {
+        return false;
+    }
+    // Class component
+    if (typeof element === 'function' && !((_b = element.prototype) === null || _b === void 0 ? void 0 : _b.render)) {
+        return false;
+    }
+    return true;
+};
+
+exports.isRefable = isRefable;

package/dist/is/is-state-getter.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * @description
+ * is state getter
+ */
+const isStateGetter = (state) => {
+    return typeof state === 'function';
+};
+
+exports.isStateGetter = isStateGetter;

package/dist/is/is-style-element.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * @description
+ * style element
+ */
+const isStyleElement = (element) => {
+    return element.tagName === 'STYLE';
+};
+
+exports.isStyleElement = isStyleElement;

package/dist/is/is-undefined.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * @description
+ * is undefined
+ */
+const isUndefined = (value) => {
+    return value === void 0;
+};
+
+exports.isUndefined = isUndefined;

package/dist/is/is-void.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var isUndefined = require('./is-undefined.cjs');
+var isNull = require('./is-null.cjs');
+
+/**
+ * @description
+ * is null or undefined
+ */
+const isVoid = (value) => {
+    return isNull.isNull(value) || isUndefined.isUndefined(value);
+};
+
+exports.isVoid = isVoid;

package/dist/is/{is-void.js → is-void.mjs}

@@ -1,5 +1,5 @@
-import { isUndefined } from './is-undefined.js';
-import { isNull } from './is-null.js';
+import { isUndefined } from './is-undefined.mjs';
+import { isNull } from './is-null.mjs';
 
 /**
  * @description

package/dist/node_modules/tslib/tslib.es6.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+}
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+exports.__classPrivateFieldGet = __classPrivateFieldGet;
+exports.__classPrivateFieldSet = __classPrivateFieldSet;

package/package.json

@@ -1,20 +1,18 @@
 {
   "name": "@aiszlab/relax",
-  "version": "1.2.11-beta.1",
+  "version": "1.2.11-beta.2",
   "description": "react utils collection",
   "type": "module",
   "exports": {
-    ".": "./dist/index.js",
-    "./dom": "./dist/dom/index.js"
-  },
-  "typesVersions": {
-    "*": {
-      ".": [
-        "./dist/index.d.ts"
-      ],
-      "dom": [
-        "./dist/dom/index.d.ts"
-      ]
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./dom": {
+      "types": "./dist/dom/index.d.ts",
+      "import": "./dist/dom/index.mjs",
+      "require": "./dist/dom/index.cjs"
     }
   },
   "scripts": {

package/dist/dom/index.js

@@ -1 +0,0 @@
-export { scrollTo } from './scroll-to.js';

package/dist/index.js

@@ -1,26 +0,0 @@
-export { useBoolean } from './hooks/use-boolean.js';
-export { useDebounceCallback } from './hooks/use-debounce-callback.js';
-export { useImageLoader } from './hooks/use-image-loader.js';
-export { useMount } from './hooks/use-mount.js';
-export { useMounted } from './hooks/use-mounted.js';
-export { useTimeout } from './hooks/use-timeout.js';
-export { useControlledState } from './hooks/use-controlled-state.js';
-export { useOnceState } from './hooks/use-once-state.js';
-export { useScrollLocker } from './hooks/use-scroll-locker.js';
-export { useForceUpdate } from './hooks/use-force-update.js';
-export { useScrollable } from './hooks/use-scrollable.js';
-export { useRefs } from './hooks/use-refs.js';
-export { useToggleable } from './hooks/use-toggleable.js';
-export { isRefable } from './is/is-refable.js';
-export { isUndefined } from './is/is-undefined.js';
-export { isStateGetter } from './is/is-state-getter.js';
-export { isNull } from './is/is-null.js';
-export { isVoid } from './is/is-void.js';
-export { isArray } from './is/is-array.js';
-export { isComplex } from './is/is-complex.js';
-export { isEmpty } from './is/is-empty.js';
-export { isDomUsable } from './is/is-dom-usable.js';
-export { isMobile } from './is/is-mobile.js';
-export { isOverflow } from './is/is-overflow.js';
-export { isStyleElement } from './is/is-style-element.js';
-export { isFunction } from './is/is-function.js';