@aiszlab/relax 1.3.11 → 1.3.13

package/dist/dom/clipboard.d.ts

@@ -1 +1,2 @@
 declare const clipboard: (value: string) => Promise<void>;
+export { clipboard };

package/dist/dom/contains.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var contains = function contains(root, node) {
+  if (!root) {
+    return false;
+  }
+  // Use native if support
+  if (root.contains) {
+    return root.contains(node !== null && node !== void 0 ? node : null);
+  }
+  // `document.contains` not support with IE11
+  var _node = node;
+  while (_node) {
+    if (_node === root) {
+      return true;
+    }
+    _node = _node.parentNode;
+  }
+  return false;
+};
+
+exports.contains = contains;

package/dist/dom/index.cjs

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

package/dist/dom/index.mjs

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

package/dist/dom/scroll-to.cjs

@@ -0,0 +1,74 @@
+'use strict';
+
+var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
+var _createClass = require('@babel/runtime/helpers/createClass');
+var _classPrivateFieldInitSpec = require('@babel/runtime/helpers/classPrivateFieldInitSpec');
+var _classPrivateFieldGet = require('@babel/runtime/helpers/classPrivateFieldGet2');
+
+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 _classPrivateFieldGet(_scrolled, this);
+    }
+  }, {
+    key: "currentAt",
+    value: function currentAt(orientation) {
+      return orientation === "vertical" ? "scrollTop" : "scrollLeft";
+    }
+  }]);
+}();
+/**
+ * @description
+ * scroll to for wrapper element
+ */
+// singleton mode
+var _scroller = {
+  _: null
+};
+var _scrollTo = function scrollTo(target, to) {
+  var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+      duration: 0,
+      orientation: "vertical"
+    },
+    _ref$duration = _ref.duration,
+    duration = _ref$duration === void 0 ? 0 : _ref$duration,
+    _ref$orientation = _ref.orientation,
+    orientation = _ref$orientation === void 0 ? "vertical" : _ref$orientation;
+  var scroller = new Scroller();
+  var scrolled = scroller.scrolled.get(target);
+  var currentAtProperty = scroller.currentAt(orientation);
+  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,
+      orientation: orientation
+    });
+  }));
+};
+
+exports.scrollTo = _scrollTo;

package/dist/hooks/use-boolean.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var react = require('react');
+
+/**
+ * @author murukal
+ *
+ * @description
+ * boolean state, in relax, we already create some api to easy use
+ */
+var useBoolean = function useBoolean(initialState) {
+  var _useState = react.useState(initialState !== null && initialState !== void 0 ? initialState : false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isOn = _useState2[0],
+    setIsOn = _useState2[1];
+  var turnOn = react.useCallback(function () {
+    return setIsOn(true);
+  }, []);
+  var turnOff = react.useCallback(function () {
+    return setIsOn(false);
+  }, []);
+  var toggle = react.useCallback(function () {
+    return setIsOn(function (_isOn) {
+      return !_isOn;
+    });
+  }, []);
+  return [isOn, {
+    turnOn: turnOn,
+    turnOff: turnOff,
+    toggle: toggle,
+    setBoolean: setIsOn
+  }];
+};
+
+exports.useBoolean = useBoolean;

package/dist/hooks/use-click-away.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var react = require('react');
+var useEvent = require('./use-event.cjs');
+var toArray = require('../utils/to-array.cjs');
+var contains = require('../dom/contains.cjs');
+
+/**
+ * @description
+ * click away
+ */
+var useClickAway = function useClickAway(onClickAway, target) {
+  var clickAway = useEvent.useEvent(function (event) {
+    var targets = toArray.toArray(target);
+    var isContained = targets.some(function (_target) {
+      return _target && contains.contains(_target.current, event.target);
+    });
+    if (isContained) return;
+    onClickAway(event);
+  });
+  react.useEffect(function () {
+    document.addEventListener("click", clickAway);
+    return function () {
+      document.removeEventListener("click", clickAway);
+    };
+  }, []);
+};
+
+exports.useClickAway = useClickAway;

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

@@ -1,7 +1,7 @@
 import { useEffect } from 'react';
-import { useEvent } from './use-event.js';
-import { toArray } from '../utils/to-array.js';
-import { contains } from '../dom/contains.js';
+import { useEvent } from './use-event.mjs';
+import { toArray } from '../utils/to-array.mjs';
+import { contains } from '../dom/contains.mjs';
 
 /**
  * @description

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

@@ -0,0 +1,39 @@
+'use strict';
+
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var react = require('react');
+var isUndefined = require('../is/is-undefined.cjs');
+var useUpdateEffect = require('./use-update-effect.cjs');
+var isFunction = require('../is/is-function.cjs');
+
+function useControlledState(controlledState) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    defaultState = _ref.defaultState;
+  // initialize state
+  var _useState = react.useState(function () {
+      // default use controlled state
+      if (!isUndefined.isUndefined(controlledState)) {
+        return controlledState;
+      }
+      // not controlled use default state
+      if (isFunction.isFunction(defaultState)) {
+        return defaultState();
+      }
+      return defaultState !== null && defaultState !== void 0 ? defaultState : controlledState;
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    _state = _useState2[0],
+    _setState = _useState2[1];
+  // sync value back to `undefined` when it from control to un-control
+  useUpdateEffect.useUpdateEffect(function () {
+    if (!isUndefined.isUndefined(controlledState)) {
+      return;
+    }
+    _setState(defaultState !== null && defaultState !== void 0 ? defaultState : controlledState);
+  }, [controlledState]);
+  // use controlled
+  var state = isUndefined.isUndefined(controlledState) ? _state : controlledState;
+  return [state, _setState];
+}
+
+exports.useControlledState = useControlledState;

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

@@ -1,8 +1,8 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import { useState } from 'react';
-import { isUndefined } from '../is/is-undefined.js';
-import { useUpdateEffect } from './use-update-effect.js';
-import { isFunction } from '../is/is-function.js';
+import { isUndefined } from '../is/is-undefined.mjs';
+import { useUpdateEffect } from './use-update-effect.mjs';
+import { isFunction } from '../is/is-function.mjs';
 
 function useControlledState(controlledState) {
   var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},

package/dist/hooks/use-counter.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var react = require('react');
+var clamp = require('../utils/clamp.cjs');
+var useDefault = require('./use-default.cjs');
+
+/**
+ * @author murukal
+ *
+ * @description
+ * a number counter with some useful apis
+ */
+var useCounter = function useCounter() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref$max = _ref.max,
+    max = _ref$max === void 0 ? Infinity : _ref$max,
+    _ref$min = _ref.min,
+    min = _ref$min === void 0 ? -Infinity : _ref$min;
+  // memorized first time prop value
+  var defaultState = useDefault.useDefault(initialState);
+  var _useState = react.useState(defaultState),
+    _useState2 = _slicedToArray(_useState, 2),
+    _count = _useState2[0],
+    _setCount = _useState2[1];
+  var add = react.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 = react.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 = react.useCallback(function () {
+    _setCount(min);
+  }, [min]);
+  var last = react.useCallback(function () {
+    _setCount(max);
+  }, [max]);
+  var reset = react.useCallback(function () {
+    _setCount(defaultState);
+  }, []);
+  var count = react.useMemo(function () {
+    return clamp.clamp(_count, min, max);
+  }, [_count, min, max]);
+  return [count, {
+    add: add,
+    subtract: subtract,
+    first: first,
+    last: last,
+    reset: reset,
+    setCount: _setCount
+  }];
+};
+
+exports.useCounter = useCounter;

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

@@ -1,7 +1,7 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import { useState, useCallback, useMemo } from 'react';
-import { clamp } from '../utils/clamp.js';
-import { useDefault } from './use-default.js';
+import { clamp } from '../utils/clamp.mjs';
+import { useDefault } from './use-default.mjs';
 
 /**
  * @author murukal

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

@@ -0,0 +1,83 @@
+'use strict';
+
+var react = require('react');
+var debounce = require('../utils/debounce.cjs');
+var useEvent = require('./use-event.cjs');
+var isFunction = require('../is/is-function.cjs');
+var useDefault = require('./use-default.cjs');
+
+var useDebouncer = function useDebouncer(debouncer) {
+  var _debouncer = react.useMemo(function () {
+    return isFunction.isFunction(debouncer) ? {
+      callback: debouncer,
+      pipe: null
+    } : debouncer;
+  }, [debouncer]);
+  return {
+    callback: useEvent.useEvent(function () {
+      return _debouncer.callback.apply(_debouncer, arguments);
+    }),
+    pipe: useEvent.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
+ *
+ * @description
+ * debounce callback
+ *
+ * @param callback
+ * @param wait number
+ * @description
+ * The delay time (in milliseconds) until the debounce function is called.
+ * default 1000
+ *
+ * @example
+ * 1000
+ */
+var useDebounceCallback = function useDebounceCallback(debouncer) {
+  var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
+  var debounced = react.useRef(null);
+  var _useDebouncer = useDebouncer(debouncer),
+    callback = _useDebouncer.callback,
+    pipe = _useDebouncer.pipe;
+  react.useEffect(function () {
+    var _debounced = debounce.debounce({
+      callback: callback,
+      pipe: pipe
+    }, wait);
+    debounced.current = _debounced;
+    // dispose
+    return function () {
+      _debounced.abort();
+      debounced.current = null;
+    };
+  }, [wait]);
+  return useDefault.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();
+      }
+    };
+  });
+};
+
+exports.useDebounceCallback = useDebounceCallback;

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

@@ -1,8 +1,8 @@
 import { useRef, useEffect, useMemo } from 'react';
-import { debounce } from '../utils/debounce.js';
-import { useEvent } from './use-event.js';
-import { isFunction } from '../is/is-function.js';
-import { useDefault } from './use-default.js';
+import { debounce } from '../utils/debounce.mjs';
+import { useEvent } from './use-event.mjs';
+import { isFunction } from '../is/is-function.mjs';
+import { useDefault } from './use-default.mjs';
 
 var useDebouncer = function useDebouncer(debouncer) {
   var _debouncer = useMemo(function () {

package/dist/hooks/use-default.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var react = require('react');
+var toFunction = require('../utils/to-function.cjs');
+
+/**
+ * @author murukal
+ *
+ * @description
+ * state always be same after first render
+ */
+var useDefault = function useDefault(initialState) {
+  return react.useMemo(toFunction.toFunction(initialState), []);
+};
+
+exports.useDefault = useDefault;

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

@@ -1,5 +1,5 @@
 import { useMemo } from 'react';
-import { toFunction } from '../utils/to-function.js';
+import { toFunction } from '../utils/to-function.mjs';
 
 /**
  * @author murukal

package/dist/hooks/use-device-pixel-ratio.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var react = require('react');
+var isDomUsable = require('../is/is-dom-usable.cjs');
+
+/**
+ * @description
+ * devicePixelRatio
+ * in different device, ratio
+ */
+var useDevicePixelRatio = function useDevicePixelRatio() {
+  var _useState = react.useState(function () {
+      if (!isDomUsable.isDomUsable()) return 1;
+      return window.devicePixelRatio;
+    }),
+    _useState2 = _slicedToArray(_useState, 1),
+    devicePixelRatio = _useState2[0];
+  return devicePixelRatio;
+};
+
+exports.useDevicePixelRatio = useDevicePixelRatio;

package/dist/hooks/{use-device-pixel-ratio.js → use-device-pixel-ratio.mjs}

@@ -1,6 +1,6 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import { useState } from 'react';
-import { isDomUsable } from '../is/is-dom-usable.js';
+import { isDomUsable } from '../is/is-dom-usable.mjs';
 
 /**
  * @description

package/dist/hooks/use-event.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var react = require('react');
+
+var useEvent = function useEvent(callback) {
+  var ref = react.useRef(callback);
+  react.useEffect(function () {
+    ref.current = callback;
+  });
+  // @ts-ignore
+  return react.useCallback(function () {
+    return ref.current.apply(ref, arguments);
+  }, []);
+};
+
+exports.useEvent = useEvent;

package/dist/hooks/use-focus.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var react = require('react');
+var useBoolean = require('./use-boolean.cjs');
+var chain = require('../utils/chain.cjs');
+
+var useFocus = function useFocus(props) {
+  var _useBoolean = useBoolean.useBoolean(false),
+    _useBoolean2 = _slicedToArray(_useBoolean, 2),
+    isFocused = _useBoolean2[0],
+    _useBoolean2$ = _useBoolean2[1],
+    turnOn = _useBoolean2$.turnOn,
+    turnOff = _useBoolean2$.turnOff;
+  var onFocus = react.useCallback(function (e) {
+    chain.chain(props === null || props === void 0 ? void 0 : props.onFocus, turnOn, function () {
+      var _props$onFocusChange;
+      return props === null || props === void 0 || (_props$onFocusChange = props.onFocusChange) === null || _props$onFocusChange === void 0 ? void 0 : _props$onFocusChange.call(props, true);
+    })(e);
+  }, [props === null || props === void 0 ? void 0 : props.onFocus, props === null || props === void 0 ? void 0 : props.onFocusChange]);
+  var onBlur = react.useCallback(function (e) {
+    chain.chain(props === null || props === void 0 ? void 0 : props.onBlur, turnOff, function () {
+      var _props$onFocusChange2;
+      return props === null || props === void 0 || (_props$onFocusChange2 = props.onFocusChange) === null || _props$onFocusChange2 === void 0 ? void 0 : _props$onFocusChange2.call(props, false);
+    })(e);
+  }, [props === null || props === void 0 ? void 0 : props.onBlur, props === null || props === void 0 ? void 0 : props.onFocusChange]);
+  return [isFocused, {
+    onFocus: onFocus,
+    onBlur: onBlur
+  }];
+};
+
+exports.useFocus = useFocus;

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

@@ -1,7 +1,7 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import { useCallback } from 'react';
-import { useBoolean } from './use-boolean.js';
-import { chain } from '../utils/chain.js';
+import { useBoolean } from './use-boolean.mjs';
+import { chain } from '../utils/chain.mjs';
 
 var useFocus = function useFocus(props) {
   var _useBoolean = useBoolean(false),

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

@@ -0,0 +1,23 @@
+'use strict';
+
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var react = require('react');
+
+/**
+ * @description
+ * force update
+ */
+var useForceUpdate = function useForceUpdate() {
+  var _useState = react.useState(1),
+    _useState2 = _slicedToArray(_useState, 2),
+    times = _useState2[0],
+    setTimes = _useState2[1];
+  var forceUpdate = react.useCallback(function () {
+    setTimes(function (prev) {
+      return prev + 1;
+    });
+  }, []);
+  return [times, forceUpdate];
+};
+
+exports.useForceUpdate = useForceUpdate;

package/dist/hooks/use-hover.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var useBoolean = require('./use-boolean.cjs');
+var chain = require('../utils/chain.cjs');
+var useEvent = require('./use-event.cjs');
+
+var useHover = function useHover(props) {
+  var _useBoolean = useBoolean.useBoolean(false),
+    _useBoolean2 = _slicedToArray(_useBoolean, 2),
+    isHovered = _useBoolean2[0],
+    _useBoolean2$ = _useBoolean2[1],
+    turnOn = _useBoolean2$.turnOn,
+    turnOff = _useBoolean2$.turnOff;
+  var onPointerEnter = useEvent.useEvent(function (event) {
+    chain.chain(props === null || props === void 0 ? void 0 : props.onEnter, turnOn)(event);
+  });
+  var onPointerLeave = useEvent.useEvent(function (event) {
+    chain.chain(props === null || props === void 0 ? void 0 : props.onLeave, turnOff)(event);
+  });
+  return [isHovered, {
+    onPointerEnter: onPointerEnter,
+    onPointerLeave: onPointerLeave
+  }];
+};
+
+exports.useHover = useHover;

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

@@ -1,7 +1,7 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import { useBoolean } from './use-boolean.js';
-import { chain } from '../utils/chain.js';
-import { useEvent } from './use-event.js';
+import { useBoolean } from './use-boolean.mjs';
+import { chain } from '../utils/chain.mjs';
+import { useEvent } from './use-event.mjs';
 
 var useHover = function useHover(props) {
   var _useBoolean = useBoolean(false),

package/dist/hooks/use-identity.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var react = require('react');
+
+/**
+ * @description
+ * extends from react `useId`
+ */
+var useIdentity = function useIdentity() {
+  var signal = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+  var id = react.useId();
+  var count = react.useRef(0);
+  var unique = react.useCallback(function () {
+    if (!signal) {
+      return "".concat(id).concat(count.current++);
+    }
+    return "".concat(id).concat(signal, ":").concat(count.current++);
+  }, []);
+  return [id, unique];
+};
+
+exports.useIdentity = useIdentity;