@aiszlab/relax 1.2.57 → 1.2.58

package/dist/hooks/use-timeout.js

@@ -0,0 +1,68 @@
+import { useRef, useEffect } from 'react';
+import { Observable, timer } from 'rxjs';
+import { useEvent } from './use-event.js';
+import { useMounted } from './use-mounted.js';
+
+/**
+ * @author murukal
+ *
+ * @description
+ * timeout effect
+ */
+var useTimeout = function useTimeout(callback, wait) {
+  var trigger = useRef(null);
+  var timed = useRef(null);
+  var callable = useEvent(callback);
+  useMounted(function () {
+    new Observable(function (_) {
+      trigger.current = _;
+    }).subscribe({
+      complete: function complete() {
+        return callable();
+      }
+    });
+  });
+  // when user what to flush timeout handler
+  // if trigger already registed, just complete trigger
+  // not registed, call `handler` manaully
+  var flush = useEvent(function () {
+    var _timed$current;
+    if (trigger.current) {
+      trigger.current.complete();
+    } else {
+      callback();
+    }
+    (_timed$current = timed.current) === null || _timed$current === void 0 || _timed$current.unsubscribe();
+    timed.current = null;
+    trigger.current = null;
+  });
+  // cancel
+  var cancel = useEvent(function () {
+    var _trigger$current, _timed$current2;
+    (_trigger$current = trigger.current) === null || _trigger$current === void 0 || _trigger$current.error();
+    (_timed$current2 = timed.current) === null || _timed$current2 === void 0 || _timed$current2.unsubscribe();
+    timed.current = null;
+  });
+  // add timer for `wait`
+  useEffect(function () {
+    // if 0, always mean not need to set timeout
+    if (wait <= 0) {
+      return;
+    }
+    var _timed = timer(wait).subscribe(function () {
+      var _trigger$current2;
+      (_trigger$current2 = trigger.current) === null || _trigger$current2 === void 0 || _trigger$current2.complete();
+    });
+    timed.current = _timed;
+    return function () {
+      _timed.unsubscribe();
+      timed.current = null;
+    };
+  }, [wait]);
+  return {
+    flush: flush,
+    cancel: cancel
+  };
+};
+
+export { useTimeout };

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

@@ -0,0 +1,48 @@
+import { type Key } from "react";
+/**
+ * @description
+ * togglable key
+ */
+type TogglableKey = {
+    /**
+     * @description
+     * unique key
+     */
+    key: Key;
+    /**
+     * @description
+     * children
+     */
+    children?: TogglableKey[];
+};
+/**
+ * @description
+ * extra options
+ */
+type Options = {
+    /**
+     * @description
+     * default toggled
+     */
+    isDefaultToggled?: boolean;
+    /**
+     * @description
+     * toggled keys
+     */
+    toggledKeys?: Key[];
+    /**
+     * @description
+     * on toggle callback
+     */
+    onToggle?: (keys: Key[]) => void;
+};
+/**
+ * @description
+ * toggle able
+ */
+export declare const useTogglable: (togglableKeys: TogglableKey[], { onToggle, ...options }?: Options) => {
+    toggledKeys: Set<Key>;
+    isToggled: (key: Key) => boolean;
+    toggle: (key: Key) => void;
+};
+export {};

package/dist/hooks/use-togglable.js

@@ -0,0 +1,177 @@
+import { objectWithoutProperties as _objectWithoutProperties, slicedToArray as _slicedToArray, createClass as _createClass, classPrivateFieldGet2 as _classPrivateFieldGet2, classCallCheck as _classCallCheck, classPrivateFieldInitSpec as _classPrivateFieldInitSpec, classPrivateFieldSet2 as _classPrivateFieldSet2 } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useMemo, useCallback } from 'react';
+import { useControlledState } from './use-controlled-state.js';
+import { useEvent } from './use-event.js';
+
+var _excluded = ["onToggle"];
+var _groupedLeaves = /*#__PURE__*/new WeakMap();
+var Tree = /*#__PURE__*/function () {
+  function Tree() {
+    _classCallCheck(this, Tree);
+    _classPrivateFieldInitSpec(this, _groupedLeaves, void 0);
+    _classPrivateFieldSet2(_groupedLeaves, this, new Map());
+  }
+  return _createClass(Tree, [{
+    key: "groupedLeaves",
+    get: function get() {
+      return _classPrivateFieldGet2(_groupedLeaves, this);
+    }
+  }, {
+    key: "grow",
+    value: function grow(togglableKey) {
+      // create leaf, leaf will auto trigger tree collect callback
+      new Leaf({
+        key: togglableKey.key,
+        parent: null,
+        belongTo: this
+      }).grow(togglableKey.children);
+      return this;
+    }
+  }, {
+    key: "collect",
+    value: function collect(leaf) {
+      _classPrivateFieldGet2(_groupedLeaves, this).has(leaf.key) ? _classPrivateFieldGet2(_groupedLeaves, this).get(leaf.key).add(leaf) : _classPrivateFieldGet2(_groupedLeaves, this).set(leaf.key, new Set([leaf]));
+    }
+  }, {
+    key: "toggle",
+    value: function toggle(key, toggledKeys) {
+      var hasToggled = toggledKeys.has(key);
+      var isToggled = !hasToggled;
+      return this.toggleBy(key, isToggled, toggledKeys);
+    }
+  }, {
+    key: "toggleBy",
+    value: function toggleBy(key, isToggled, toggledKeys) {
+      var _classPrivateFieldGet2$1;
+      return Array.from((_classPrivateFieldGet2$1 = _classPrivateFieldGet2(_groupedLeaves, this).get(key)) !== null && _classPrivateFieldGet2$1 !== void 0 ? _classPrivateFieldGet2$1 : []).reduce(function (prev, leaf) {
+        // deep fall, add or remove child key
+        // deep rise, add or remove parent key
+        return leaf.rise(isToggled, leaf.fall(isToggled, prev));
+      }, new Set(toggledKeys));
+    }
+  }]);
+}();
+var _key = /*#__PURE__*/new WeakMap();
+var _belongTo = /*#__PURE__*/new WeakMap();
+var _parent = /*#__PURE__*/new WeakMap();
+var _children = /*#__PURE__*/new WeakMap();
+var Leaf = /*#__PURE__*/function () {
+  function Leaf(props) {
+    _classCallCheck(this, Leaf);
+    _classPrivateFieldInitSpec(this, _key, void 0);
+    _classPrivateFieldInitSpec(this, _belongTo, void 0);
+    _classPrivateFieldInitSpec(this, _parent, void 0);
+    _classPrivateFieldInitSpec(this, _children, void 0);
+    _classPrivateFieldSet2(_key, this, props.key);
+    _classPrivateFieldSet2(_parent, this, props.parent);
+    _classPrivateFieldSet2(_belongTo, this, props.belongTo);
+    _classPrivateFieldSet2(_children, this, []);
+    // when leaf has grew, let tree collect leaf
+    _classPrivateFieldGet2(_belongTo, this).collect(this);
+  }
+  return _createClass(Leaf, [{
+    key: "key",
+    get: function get() {
+      return _classPrivateFieldGet2(_key, this);
+    }
+  }, {
+    key: "grow",
+    value: function grow() {
+      var _this = this;
+      var children = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      if (children.length === 0) return this;
+      children.forEach(function (node) {
+        var child = new Leaf({
+          key: node.key,
+          parent: _this,
+          belongTo: _classPrivateFieldGet2(_belongTo, _this)
+        }).grow(node.children);
+        _classPrivateFieldGet2(_children, _this).push(child);
+      });
+      return this;
+    }
+  }, {
+    key: "rise",
+    value: function rise(isToggled, toggledKeys) {
+      var rised = new Set(toggledKeys);
+      if (isToggled) {
+        rised.add(_classPrivateFieldGet2(_key, this));
+      } else {
+        rised["delete"](_classPrivateFieldGet2(_key, this));
+      }
+      if (_classPrivateFieldGet2(_parent, this)) {
+        return _classPrivateFieldGet2(_parent, this).rise(isToggled, rised);
+      }
+      return rised;
+    }
+  }, {
+    key: "fall",
+    value: function fall(isToggled, toggledKeys) {
+      return _classPrivateFieldGet2(_children, this).reduce(function (prev, leaf) {
+        // deep loop, remove or add key
+        var fell = leaf.fall(isToggled, prev);
+        // toggle true, add current leaf key
+        // toggle false, remove current leaf key
+        if (isToggled) {
+          fell.add(leaf.key);
+        } else {
+          fell["delete"](leaf.key);
+        }
+        return fell;
+      }, new Set(toggledKeys));
+    }
+  }]);
+}();
+/**
+ * @description
+ * toggle able
+ */
+var useTogglable = function useTogglable(togglableKeys) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    onToggle = _ref.onToggle,
+    options = _objectWithoutProperties(_ref, _excluded);
+  /// re-create tree when togglable keys changed
+  var tree = useMemo(function () {
+    return togglableKeys.reduce(function (_tree, togglable) {
+      return _tree.grow(togglable);
+    }, new Tree());
+  }, [togglableKeys]);
+  /// use controlled state to record toggled keys
+  var _useControlledState = useControlledState(options.toggledKeys, {
+      defaultState: function defaultState() {
+        return options.isDefaultToggled ? Array.from(Array.from(tree.groupedLeaves.values()).reduce(function (prev, leaves) {
+          leaves.forEach(function (leaf) {
+            return prev.add(leaf.key);
+          });
+          return prev;
+        }, new Set())) : [];
+      }
+    }),
+    _useControlledState2 = _slicedToArray(_useControlledState, 2),
+    _toggledKeys = _useControlledState2[0],
+    _setToggledKeys = _useControlledState2[1];
+  /// use set for toggled keys to make it read-only
+  var readableToggledKeys = useMemo(function () {
+    return new Set(_toggledKeys);
+  }, [_toggledKeys]);
+  /// check current key is toggled
+  var isToggled = useCallback(function (key) {
+    return !readableToggledKeys || readableToggledKeys.has(key);
+  }, [readableToggledKeys]);
+  /// toggle one key
+  var toggle = useEvent(function (key) {
+    // get new toggled keys by toggle current key
+    var _toggledKeys = Array.from(tree.toggle(key, readableToggledKeys));
+    // set state
+    _setToggledKeys(_toggledKeys);
+    // trigger on toggle callback
+    onToggle === null || onToggle === void 0 || onToggle(_toggledKeys);
+  });
+  return {
+    toggledKeys: readableToggledKeys,
+    isToggled: isToggled,
+    toggle: toggle
+  };
+};
+
+export { useTogglable };

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

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

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

@@ -0,0 +1,19 @@
+import { useRef, useEffect } from 'react';
+import { useMounted } from './use-mounted.js';
+import { effect } from '../utils/effect.js';
+
+var useUpdateEffect = function useUpdateEffect(callback, deps) {
+  var isMounted = useRef(false);
+  useEffect(function () {
+    if (!isMounted.current) return;
+    return effect(callback);
+  }, deps);
+  useMounted(function () {
+    isMounted.current = true;
+    return function () {
+      isMounted.current = false;
+    };
+  });
+};
+
+export { useUpdateEffect };

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @description
+ * hooks
+ */
+export { useBoolean } from "./hooks/use-boolean";
+export { useDebounceCallback } from "./hooks/use-debounce-callback";
+export { useThrottleCallback } from "./hooks/use-throttle-callback";
+export { useImageLoader } from "./hooks/use-image-loader";
+export { useMount } from "./hooks/use-mount";
+export { useMounted } from "./hooks/use-mounted";
+export { useTimeout } from "./hooks/use-timeout";
+export { useControlledState } from "./hooks/use-controlled-state";
+export { useDefault } from "./hooks/use-default";
+export { useScrollLocker } from "./hooks/use-scroll-locker";
+export { useForceUpdate } from "./hooks/use-force-update";
+export { useScrollable } from "./hooks/use-scrollable";
+export { useRefs } from "./hooks/use-refs";
+export { useTogglable } from "./hooks/use-togglable";
+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";
+export { useFocus } from "./hooks/use-focus";
+export { useMemorable } from "./hooks/use-memorable";
+export { useMutateObserver } from "./hooks/use-mutate-observer";
+export { useRaf } from "./hooks/use-raf";
+export { useDevicePixelRatio } from "./hooks/use-device-pixel-ratio";
+export { useIdentity } from "./hooks/use-identity";
+/**
+ * @description
+ * is
+ */
+export { isRefable } from "./is/is-refable";
+export { isUndefined } from "./is/is-undefined";
+export { isStateGetter } from "./is/is-state-getter";
+export { isNull } from "./is/is-null";
+export { isVoid } from "./is/is-void";
+export { isArray } from "./is/is-array";
+export { isComplex } from "./is/is-complex";
+export { isEmpty } from "./is/is-empty";
+export { isDomUsable } from "./is/is-dom-usable";
+export { isMobile } from "./is/is-mobile";
+export { isOverflow } from "./is/is-overflow";
+export { isStyleElement } from "./is/is-style-element";
+export { isFunction } from "./is/is-function";
+export { isThenable } from "./is/is-thenable";
+/**
+ * @description
+ * utils
+ */
+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";
+export { toArray } from "./utils/to-array";
+export { toFunction } from "./utils/to-function";
+export { exclude } from "./utils/exclude";
+export { toFormData } from "./utils/to-form-data";
+export { setStyle } from "./utils/set-style";
+export { throttle } from "./utils/throttle";
+export { clone } from "./utils/clone";
+export { toggle } from "./utils/toggle";

package/dist/index.js

@@ -0,0 +1,52 @@
+export { useBoolean } from './hooks/use-boolean.js';
+export { useDebounceCallback } from './hooks/use-debounce-callback.js';
+export { useThrottleCallback } from './hooks/use-throttle-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 { useDefault } from './hooks/use-default.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 { useTogglable } from './hooks/use-togglable.js';
+export { useEvent } from './hooks/use-event.js';
+export { useUpdateEffect } from './hooks/use-update-effect.js';
+export { useCounter } from './hooks/use-counter.js';
+export { useHover } from './hooks/use-hover.js';
+export { useFocus } from './hooks/use-focus.js';
+export { useMemorable } from './hooks/use-memorable.js';
+export { useMutateObserver } from './hooks/use-mutate-observer.js';
+export { useRaf } from './hooks/use-raf.js';
+export { useDevicePixelRatio } from './hooks/use-device-pixel-ratio.js';
+export { useIdentity } from './hooks/use-identity.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';
+export { isThenable } from './is/is-thenable.js';
+export { effect } from './utils/effect.js';
+export { unique, uniqueBy } from './utils/unique.js';
+export { range } from './utils/range.js';
+export { clamp } from './utils/clamp.js';
+export { chain } from './utils/chain.js';
+export { debounce } from './utils/debounce.js';
+export { toArray } from './utils/to-array.js';
+export { toFunction } from './utils/to-function.js';
+export { exclude } from './utils/exclude.js';
+export { toFormData } from './utils/to-form-data.js';
+export { setStyle } from './utils/set-style.js';
+export { throttle } from './utils/throttle.js';
+export { clone } from './utils/clone.js';
+export { toggle } from './utils/toggle.js';

package/dist/is/is-array.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * is array
+ */
+export declare const isArray: <T>(value: T | T[] | readonly T[]) => value is T[];

package/dist/is/is-array.js

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * is array
+ */
+var isArray = function isArray(value) {
+  return Array.isArray(value);
+};
+
+export { isArray };

package/dist/is/is-complex.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * complex
+ */
+export declare const isComplex: (value: unknown) => value is Object;

package/dist/is/is-complex.js

@@ -0,0 +1,11 @@
+import { typeof as _typeof } from '../_virtual/_rollupPluginBabelHelpers.js';
+
+/**
+ * @description
+ * complex
+ */
+var isComplex = function isComplex(value) {
+  return _typeof(value) === "object" || typeof value === "function";
+};
+
+export { isComplex };

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

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * if there is dom
+ */
+export declare const isDomUsable: () => boolean;

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

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * if there is dom
+ */
+var isDomUsable = function isDomUsable() {
+  return !!(typeof window !== "undefined" && window.document && window.document.createElement);
+};
+
+export { isDomUsable };

package/dist/is/is-empty.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @author murukal
+ *
+ * @description
+ * is empty
+ */
+export declare const isEmpty: (value?: Object | unknown[] | string | number | boolean | null) => boolean;

package/dist/is/is-empty.js

@@ -0,0 +1,25 @@
+import { typeof as _typeof } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { isVoid } from './is-void.js';
+import { isArray } from './is-array.js';
+
+/**
+ * @author murukal
+ *
+ * @description
+ * is empty
+ */
+var isEmpty = function isEmpty(value) {
+  // null or undefined
+  if (isVoid(value)) return true;
+  // object
+  if (_typeof(value) === "object") {
+    return Object.keys(value).length === 0;
+  }
+  // array
+  if (isArray(value)) {
+    return value.length === 0;
+  }
+  return !!value;
+};
+
+export { isEmpty };

package/dist/is/is-function.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * if is function
+ */
+export declare const isFunction: (value: unknown) => value is Function;

package/dist/is/is-function.js

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * if is function
+ */
+var isFunction = function isFunction(value) {
+  return typeof value === "function";
+};
+
+export { isFunction };

package/dist/is/is-map.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * is set
+ */
+export declare const isMap: (value: unknown) => value is Map<unknown, unknown>;

package/dist/is/is-mobile.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * is mobile
+ */
+export declare const isMobile: () => boolean;

package/dist/is/is-mobile.js

@@ -0,0 +1,13 @@
+/**
+ * @description
+ * is mobile
+ */
+var isMobile = function isMobile() {
+  if (typeof navigator === "undefined" || typeof window === "undefined") {
+    return false;
+  }
+  var 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));
+};
+
+export { isMobile };

package/dist/is/is-null.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * is null
+ */
+export declare const isNull: (value: unknown) => value is null;

package/dist/is/is-null.js

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * is null
+ */
+var isNull = function isNull(value) {
+  return value === null;
+};
+
+export { isNull };

package/dist/is/is-overflow.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * if is overflow
+ */
+export declare function isOverflow(element?: HTMLElement): boolean;

package/dist/is/is-overflow.js

@@ -0,0 +1,14 @@
+/**
+ * @description
+ * if is overflow
+ */
+function isOverflow() {
+  var element = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document.body;
+  if (element === document.body) {
+    return document.body.scrollHeight > (window.innerHeight || document.documentElement.clientHeight) && window.innerWidth > document.body.offsetWidth;
+  }
+  // not body
+  return element.scrollHeight > element.clientHeight;
+}
+
+export { isOverflow };

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

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

package/dist/is/is-primitive.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * string/number/... is primitive type
+ */
+export declare const isPrimitive: (value: unknown) => boolean;

package/dist/is/is-primitive.js

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * string/number/... is primitive type
+ */
+var isPrimitive = function isPrimitive(value) {
+  return value !== Object(value);
+};
+
+export { isPrimitive };

package/dist/is/is-refable.d.ts

@@ -0,0 +1,5 @@
+import { type ReactNode } from "react";
+/**
+ * @description
+ */
+export declare const isRefable: (node: ReactNode) => boolean;