@aiszlab/relax 1.2.38 → 1.2.39

package/dist/_virtual/_rollupPluginBabelHelpers.js

@@ -0,0 +1,153 @@
+function _assertClassBrand(e, t, n) {
+  if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+  throw new TypeError("Private element is not present on this object");
+}
+function _classPrivateFieldGet2(s, a) {
+  return s.get(_assertClassBrand(s, a));
+}
+function _classPrivateFieldSet2(s, a, r) {
+  return s.set(_assertClassBrand(s, a), r), r;
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r );
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (String )(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  for (var key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      if (excluded.indexOf(key) >= 0) continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _checkPrivateRedeclaration(obj, privateCollection) {
+  if (privateCollection.has(obj)) {
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+}
+function _classPrivateFieldInitSpec(obj, privateMap, value) {
+  _checkPrivateRedeclaration(obj, privateMap);
+  privateMap.set(obj, value);
+}
+function _classPrivateMethodInitSpec(obj, privateSet) {
+  _checkPrivateRedeclaration(obj, privateSet);
+  privateSet.add(obj);
+}
+
+export { _arrayLikeToArray as arrayLikeToArray, _arrayWithHoles as arrayWithHoles, _arrayWithoutHoles as arrayWithoutHoles, _assertClassBrand as assertClassBrand, _checkPrivateRedeclaration as checkPrivateRedeclaration, _classCallCheck as classCallCheck, _classPrivateFieldGet2 as classPrivateFieldGet2, _classPrivateFieldInitSpec as classPrivateFieldInitSpec, _classPrivateFieldSet2 as classPrivateFieldSet2, _classPrivateMethodInitSpec as classPrivateMethodInitSpec, _createClass as createClass, _iterableToArray as iterableToArray, _iterableToArrayLimit as iterableToArrayLimit, _nonIterableRest as nonIterableRest, _nonIterableSpread as nonIterableSpread, _objectWithoutProperties as objectWithoutProperties, _objectWithoutPropertiesLoose as objectWithoutPropertiesLoose, _slicedToArray as slicedToArray, _toConsumableArray as toConsumableArray, _toPrimitive as toPrimitive, _toPropertyKey as toPropertyKey, _typeof as typeof, _unsupportedIterableToArray as unsupportedIterableToArray };

package/dist/dom/contains.js

@@ -1,20 +1,20 @@
-const contains = (root, n) => {
-    if (!root) {
-        return false;
-    }
-    // Use native if support
-    if (root.contains) {
-        return root.contains(n ?? null);
-    }
-    // `document.contains` not support with IE11
-    let node = n;
-    while (node) {
-        if (node === root) {
-            return true;
-        }
-        node = node.parentNode;
-    }
+var contains = function contains(root, n) {
+  if (!root) {
     return false;
+  }
+  // Use native if support
+  if (root.contains) {
+    return root.contains(n !== null && n !== void 0 ? n : null);
+  }
+  // `document.contains` not support with IE11
+  var node = n;
+  while (node) {
+    if (node === root) {
+      return true;
+    }
+    node = node.parentNode;
+  }
+  return false;
 };
 
 export { contains };

package/dist/dom/scroll-to.js

@@ -1,53 +1,69 @@
-class Scroller {
-    #scrolled = new Map();
-    // singleton mode
-    static #scroller = null;
-    constructor() {
-        return (Scroller.#scroller ??= this);
-    }
-    get scrolled() {
-        return this.#scrolled;
+import { createClass as _createClass, classPrivateFieldGet2 as _classPrivateFieldGet2, classCallCheck as _classCallCheck, classPrivateFieldInitSpec as _classPrivateFieldInitSpec } from '../_virtual/_rollupPluginBabelHelpers.js';
+
+var _scrolled = /*#__PURE__*/new WeakMap();
+var Scroller = /*#__PURE__*/function () {
+  function Scroller() {
+    var _scroller$_;
+    _classCallCheck(this, Scroller);
+    _classPrivateFieldInitSpec(this, _scrolled, new Map());
+    return (_scroller$_ = _scroller._) !== null && _scroller$_ !== void 0 ? _scroller$_ : _scroller._ = this;
+  }
+  return _createClass(Scroller, [{
+    key: "scrolled",
+    get: function get() {
+      return _classPrivateFieldGet2(_scrolled, this);
     }
-    currentAt(direction) {
-        return direction === 'vertical' ? 'scrollTop' : 'scrollLeft';
+  }, {
+    key: "currentAt",
+    value: function currentAt(direction) {
+      return direction === 'vertical' ? 'scrollTop' : 'scrollLeft';
     }
-}
+  }]);
+}();
 /**
  * @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
-        });
+// singleton mode
+var _scroller = {
+  _: null
+};
+var scrollTo = function scrollTo(target, to) {
+  var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+      duration: 0,
+      direction: 'vertical'
+    },
+    _ref$duration = _ref.duration,
+    duration = _ref$duration === void 0 ? 0 : _ref$duration,
+    _ref$direction = _ref.direction,
+    direction = _ref$direction === void 0 ? 'vertical' : _ref$direction;
+  var scroller = new Scroller();
+  var scrolled = scroller.scrolled.get(target);
+  var 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(function () {
+      target[currentAtProperty] = to;
     }));
+    return;
+  }
+  // animate
+  var currentAt = target[currentAtProperty];
+  var difference = to - currentAt;
+  var step = difference / duration * 10;
+  scroller.scrolled.set(target, requestAnimationFrame(function () {
+    target[currentAtProperty] = currentAt + step;
+    // over end, stop any animation
+    if (target[currentAtProperty] === to) return;
+    scrollTo(target, to, {
+      duration: duration - 10,
+      direction: direction
+    });
+  }));
 };
 
 export { scrollTo };

package/dist/hooks/use-boolean.js

@@ -1,3 +1,4 @@
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
 import { useState, useCallback } from 'react';
 
 /**
@@ -6,17 +7,28 @@ import { useState, useCallback } from 'react';
  * @description
  * boolean state, in relax, we already create some api to easy use
  */
-const useBoolean = (initialState) => {
-    const [isOn, setIsOn] = useState(initialState ?? false);
-    const turnOn = useCallback(() => setIsOn(true), []);
-    const turnOff = useCallback(() => setIsOn(false), []);
-    const toggle = useCallback(() => setIsOn((_isOn) => !_isOn), []);
-    return [isOn, {
-            turnOn,
-            turnOff,
-            toggle,
-            setBoolean: setIsOn
-        }];
+var useBoolean = function useBoolean(initialState) {
+  var _useState = useState(initialState !== null && initialState !== void 0 ? initialState : false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isOn = _useState2[0],
+    setIsOn = _useState2[1];
+  var turnOn = useCallback(function () {
+    return setIsOn(true);
+  }, []);
+  var turnOff = useCallback(function () {
+    return setIsOn(false);
+  }, []);
+  var toggle = useCallback(function () {
+    return setIsOn(function (_isOn) {
+      return !_isOn;
+    });
+  }, []);
+  return [isOn, {
+    turnOn: turnOn,
+    turnOff: turnOff,
+    toggle: toggle,
+    setBoolean: setIsOn
+  }];
 };
 
 export { useBoolean };

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

@@ -1,3 +1,4 @@
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
 import { useState } from 'react';
 import { isStateGetter } from '../is/is-state-getter.js';
 import { isUndefined } from '../is/is-undefined.js';
@@ -9,29 +10,31 @@ import { useUpdateEffect } from './use-update-effect.js';
  * @description
  * controlled state
  */
-const useControlledState = (controlledState, { defaultState } = {}) => {
-    /// initialize state
-    const [_state, _setState] = useState(() => {
-        // default use controlled state
-        if (!isUndefined(controlledState)) {
-            return controlledState;
-        }
-        // not controlled use default prop
-        if (isUndefined(defaultState))
-            return controlledState;
-        if (isStateGetter(defaultState))
-            return defaultState();
-        return defaultState;
-    });
-    /// sync value back to `undefined` when it from control to un-control
-    useUpdateEffect(() => {
-        if (!isUndefined(controlledState))
-            return;
-        _setState(controlledState ?? defaultState);
-    }, [controlledState]);
-    /// use controlled
-    const state = !isUndefined(controlledState) ? controlledState : _state;
-    return [state, _setState];
+var useControlledState = function useControlledState(controlledState) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    defaultState = _ref.defaultState;
+  /// initialize state
+  var _useState = useState(function () {
+      // default use controlled state
+      if (!isUndefined(controlledState)) {
+        return controlledState;
+      }
+      // not controlled use default prop
+      if (isUndefined(defaultState)) return controlledState;
+      if (isStateGetter(defaultState)) return defaultState();
+      return defaultState;
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    _state = _useState2[0],
+    _setState = _useState2[1];
+  /// sync value back to `undefined` when it from control to un-control
+  useUpdateEffect(function () {
+    if (!isUndefined(controlledState)) return;
+    _setState(controlledState !== null && controlledState !== void 0 ? controlledState : defaultState);
+  }, [controlledState]);
+  /// use controlled
+  var state = !isUndefined(controlledState) ? controlledState : _state;
+  return [state, _setState];
 };
 
 export { useControlledState };

package/dist/hooks/use-counter.js

@@ -1,5 +1,6 @@
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
 import { useState, useCallback, useMemo } from 'react';
-import { clamp } from '../utils/clamp.js';
+import { clamp } from '../utils/clamp/index.js';
 import { useDefault } from './use-default.js';
 
 /**
@@ -8,26 +9,52 @@ import { useDefault } from './use-default.js';
  * @description
  * a number counter with some useful apis
  */
-const useCounter = (initialState, { max = Infinity, min = -Infinity } = { max: Infinity, min: -Infinity }) => {
-    const defaultState = useDefault(initialState ?? 0);
-    const [_count, _setCount] = useState(defaultState);
-    const add = useCallback((step = 1) => {
-        _setCount((prev) => Math.min(max, prev + step));
-    }, [max]);
-    const subtract = useCallback((step = 1) => {
-        _setCount((prev) => Math.max(min, prev - step));
-    }, [min]);
-    const first = useCallback(() => {
-        _setCount(min);
-    }, [min]);
-    const last = useCallback(() => {
-        _setCount(max);
-    }, [max]);
-    const reset = useCallback(() => {
-        _setCount(defaultState);
-    }, []);
-    const count = useMemo(() => clamp(_count, min, max), [_count, min, max]);
-    return [count, { add, subtract, first, last, reset, setCount: _setCount }];
+var useCounter = function useCounter(initialState) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      max: Infinity,
+      min: -Infinity
+    },
+    _ref$max = _ref.max,
+    max = _ref$max === void 0 ? Infinity : _ref$max,
+    _ref$min = _ref.min,
+    min = _ref$min === void 0 ? -Infinity : _ref$min;
+  var defaultState = useDefault(initialState !== null && initialState !== void 0 ? initialState : 0);
+  var _useState = useState(defaultState),
+    _useState2 = _slicedToArray(_useState, 2),
+    _count = _useState2[0],
+    _setCount = _useState2[1];
+  var add = useCallback(function () {
+    var step = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+    _setCount(function (prev) {
+      return Math.min(max, prev + step);
+    });
+  }, [max]);
+  var subtract = useCallback(function () {
+    var step = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+    _setCount(function (prev) {
+      return Math.max(min, prev - step);
+    });
+  }, [min]);
+  var first = useCallback(function () {
+    _setCount(min);
+  }, [min]);
+  var last = useCallback(function () {
+    _setCount(max);
+  }, [max]);
+  var reset = useCallback(function () {
+    _setCount(defaultState);
+  }, []);
+  var count = useMemo(function () {
+    return clamp(_count, min, max);
+  }, [_count, min, max]);
+  return [count, {
+    add: add,
+    subtract: subtract,
+    first: first,
+    last: last,
+    reset: reset,
+    setCount: _setCount
+  }];
 };
 
 export { useCounter };

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

@@ -1,21 +1,28 @@
 import { useRef, useEffect, useMemo } from 'react';
-import { debounce } from '../utils/debounce.js';
+import { debounce } from '../utils/debounce/index.js';
 import { useEvent } from './use-event.js';
 import { isFunction } from '../is/is-function.js';
 import { useDefault } from './use-default.js';
 
-const useDebouncer = (debouncer) => {
-    const _debouncer = useMemo(() => {
-        return isFunction(debouncer) ? { callback: debouncer, pipeable: null } : debouncer;
-    }, [debouncer]);
-    return {
-        callback: useEvent((...args) => {
-            return _debouncer.callback(...args);
-        }),
-        pipeable: useEvent((...args) => {
-            return _debouncer.pipeable?.(...args) ?? args;
-        })
-    };
+var useDebouncer = function useDebouncer(debouncer) {
+  var _debouncer = useMemo(function () {
+    return isFunction(debouncer) ? {
+      callback: debouncer,
+      pipe: null
+    } : debouncer;
+  }, [debouncer]);
+  return {
+    callback: useEvent(function () {
+      return _debouncer.callback.apply(_debouncer, arguments);
+    }),
+    pipe: useEvent(function () {
+      var _debouncer$pipe, _debouncer$pipe2;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return (_debouncer$pipe = (_debouncer$pipe2 = _debouncer.pipe) === null || _debouncer$pipe2 === void 0 ? void 0 : _debouncer$pipe2.call.apply(_debouncer$pipe2, [_debouncer].concat(args))) !== null && _debouncer$pipe !== void 0 ? _debouncer$pipe : args;
+    })
+  };
 };
 /**
  * @author murukal
@@ -32,26 +39,43 @@ const useDebouncer = (debouncer) => {
  * @example
  * 1000
  */
-const useDebounceCallback = (debouncer, wait = 1000) => {
-    const debounced = useRef(null);
-    const { callback, pipeable } = useDebouncer(debouncer);
-    useEffect(() => {
-        const _debounced = debounce({
-            callback,
-            pipeable
-        }, wait);
-        debounced.current = _debounced;
-        // dispose
-        return () => {
-            _debounced.abort();
-            debounced.current = null;
-        };
-    }, [wait]);
-    return useDefault(() => ({
-        next: (...args) => debounced.current?.next(...args),
-        flush: () => debounced.current?.flush(),
-        abort: () => debounced.current?.abort()
-    }));
+var useDebounceCallback = function useDebounceCallback(debouncer) {
+  var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
+  var debounced = useRef(null);
+  var _useDebouncer = useDebouncer(debouncer),
+    callback = _useDebouncer.callback,
+    pipe = _useDebouncer.pipe;
+  useEffect(function () {
+    var _debounced = debounce({
+      callback: callback,
+      pipe: pipe
+    }, wait);
+    debounced.current = _debounced;
+    // dispose
+    return function () {
+      _debounced.abort();
+      debounced.current = null;
+    };
+  }, [wait]);
+  return useDefault(function () {
+    return {
+      next: function next() {
+        var _debounced$current;
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+        return (_debounced$current = debounced.current) === null || _debounced$current === void 0 ? void 0 : _debounced$current.next.apply(_debounced$current, args);
+      },
+      flush: function flush() {
+        var _debounced$current2;
+        return (_debounced$current2 = debounced.current) === null || _debounced$current2 === void 0 ? void 0 : _debounced$current2.flush();
+      },
+      abort: function abort() {
+        var _debounced$current3;
+        return (_debounced$current3 = debounced.current) === null || _debounced$current3 === void 0 ? void 0 : _debounced$current3.abort();
+      }
+    };
+  });
 };
 
 export { useDebounceCallback };

package/dist/hooks/use-default.js

@@ -7,8 +7,8 @@ import { toFunction } from '../utils/to-function.js';
  * @description
  * state always be same after first render
  */
-const useDefault = (initialState) => {
-    return useMemo(toFunction(initialState), []);
+var useDefault = function useDefault(initialState) {
+  return useMemo(toFunction(initialState), []);
 };
 
 export { useDefault };

package/dist/hooks/use-event.js

@@ -1,10 +1,12 @@
 import { useRef, useCallback } from 'react';
 
-const useEvent = (callback) => {
-    const ref = useRef(callback);
-    ref.current = callback;
-    // @ts-ignore
-    return useCallback((...args) => ref.current(...args), []);
+var useEvent = function useEvent(callback) {
+  var ref = useRef(callback);
+  ref.current = callback;
+  // @ts-ignore
+  return useCallback(function () {
+    return ref.current.apply(ref, arguments);
+  }, []);
 };
 
 export { useEvent };