@aiszlab/relax 1.3.10 → 1.3.12

package/dist/utils/{clone.js → clone.mjs}

@@ -1,5 +1,5 @@
-import { isArray } from '../is/is-array.js';
-import { isPrimitive } from '../is/is-primitive.js';
+import { isArray } from '../is/is-array.mjs';
+import { isPrimitive } from '../is/is-primitive.mjs';
 
 /**
  * @description

package/dist/utils/clsx.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var isArray = require('../is/is-array.cjs');
+var isNumber = require('../is/is-number.cjs');
+var isString = require('../is/is-string.cjs');
+var isVoid = require('../is/is-void.cjs');
+
+var _toClassNames = function toClassNames(value) {
+  if (isVoid.isVoid(value)) return [];
+  if (isString.isString(value) || isNumber.isNumber(value)) return [value.toString()];
+  if (isArray.isArray(value)) {
+    return value.reduce(function (classNames, item) {
+      return classNames.concat(_toClassNames(item));
+    }, []);
+  }
+  return Object.entries(value).reduce(function (classNames, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      className = _ref2[0],
+      isValid = _ref2[1];
+    if (isValid) {
+      classNames.push(className);
+    }
+    return classNames;
+  }, []);
+};
+var clsx = function clsx() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  return _toClassNames(args).join(" ");
+};
+
+exports.clsx = clsx;

package/dist/utils/{clsx.js → clsx.mjs}

@@ -1,8 +1,8 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import { isArray } from '../is/is-array.js';
-import { isNumber } from '../is/is-number.js';
-import { isString } from '../is/is-string.js';
-import { isVoid } from '../is/is-void.js';
+import { isArray } from '../is/is-array.mjs';
+import { isNumber } from '../is/is-number.mjs';
+import { isString } from '../is/is-string.mjs';
+import { isVoid } from '../is/is-void.mjs';
 
 var _toClassNames = function toClassNames(value) {
   if (isVoid(value)) return [];

package/dist/utils/debounce.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var rxjs = require('rxjs');
+var isFunction = require('../is/is-function.cjs');
+var waitable = require('./waitable.cjs');
+
+var debounce = function debounce(debouncer, wait) {
+  var isCallable = isFunction.isFunction(debouncer);
+  var callback = isCallable ? debouncer : debouncer.callback;
+  var pipe = isCallable ? function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return args;
+  } : debouncer.pipe;
+  var waiter = new waitable.Waitable({
+    callback: callback,
+    pipe: pipe,
+    timer: rxjs.debounceTime(wait)
+  });
+  return {
+    next: function next() {
+      return waiter.next.apply(waiter, arguments);
+    },
+    flush: function flush() {
+      return waiter.flush();
+    },
+    abort: function abort() {
+      return waiter.abort();
+    }
+  };
+};
+
+exports.debounce = debounce;

package/dist/utils/{debounce.js → debounce.mjs}

@@ -1,6 +1,6 @@
 import { debounceTime } from 'rxjs';
-import { isFunction } from '../is/is-function.js';
-import { Waitable } from './waitable.js';
+import { isFunction } from '../is/is-function.mjs';
+import { Waitable } from './waitable.mjs';
 
 var debounce = function debounce(debouncer, wait) {
   var isCallable = isFunction(debouncer);

package/dist/utils/effect.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var isThenable = require('../is/is-thenable.cjs');
+
+/**
+ * @description
+ * call thenable effect
+ */
+var effect = function effect(callable) {
+  var called = callable();
+  // if result is void
+  if (!called) return void 0;
+  // if result is promise like, return void
+  if (isThenable.isThenable(called)) return void 0;
+  return called;
+};
+
+exports.effect = effect;

package/dist/utils/{effect.js → effect.mjs}

@@ -1,4 +1,4 @@
-import { isThenable } from '../is/is-thenable.js';
+import { isThenable } from '../is/is-thenable.mjs';
 
 /**
  * @description

package/dist/utils/exclude.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+/**
+ * @description
+ * exclude any value from array
+ *
+ * for performance, avoid using `Array.includes`, replace with `Set`
+ *
+ * @example
+ * exclude([1, 2, 3, 4, 5], [2, 4]) // [1, 3, 5]
+ */
+var exclude = function exclude(value, _excludeBy) {
+  var excludeBy = new Set(_excludeBy);
+  // @ts-ignore
+  return value.filter(function (item) {
+    return !excludeBy.has(item);
+  });
+};
+
+exports.exclude = exclude;

package/dist/utils/range.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+/**
+ * Returns an array of numbers, starting at `from` and ending at `to`.
+ * @param from number
+ * @param to number
+ * @returns number[]
+ */
+var range = function range(from, to) {
+  var length = Math.max(to - from + 1, 0);
+  return Array.from({
+    length: length
+  }, function (_, index) {
+    return index + from;
+  });
+};
+
+exports.range = range;

package/dist/utils/replace.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
+var isArray = require('../is/is-array.cjs');
+
+/**
+ * @description
+ * comman replace
+ * usable for `string`, `array`
+ */
+var replace = function replace(value, options) {
+  if (isArray.isArray(value)) {
+    var index = options.index,
+      _replaceValue = options.replaceValue;
+    return [].concat(_toConsumableArray(value.slice(0, index)), [_replaceValue], _toConsumableArray(value.slice(index + 1)));
+  }
+  var replaceValue = options.replaceValue,
+    searchValue = options.searchValue;
+  return value.replace(searchValue, replaceValue);
+};
+
+exports.replace = replace;

package/dist/utils/{replace.js → replace.mjs}

@@ -1,5 +1,5 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import { isArray } from '../is/is-array.js';
+import { isArray } from '../is/is-array.mjs';
 
 /**
  * @description

package/dist/utils/set-style.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+
+/**
+ * @description
+ * set inline style util
+ */
+var setStyle = function setStyle(target, styles) {
+  if (!styles) return {};
+  return Object.entries(styles).reduce(function (prev, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      key = _ref2[0],
+      value = _ref2[1];
+    // @ts-ignore
+    prev[key] = target.style[key];
+    // @ts-ignore
+    target.style[key] = value;
+    return prev;
+  }, {});
+};
+
+exports.setStyle = setStyle;

package/dist/utils/tagged-template-literals.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var _construct = require('@babel/runtime/helpers/construct');
+var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+
+/**
+ * @description
+ * create tagged template literals
+ */
+var taggedTemplateLiterals = function taggedTemplateLiterals(template, variables) {
+  if (!variables) return template;
+  var entries = Object.entries(variables);
+  if (entries.length === 0) return template;
+  var _entries$reduce = entries.reduce(function (prev, _ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+      prev[0].push(key);
+      prev[1].push(value !== null && value !== void 0 ? value : "");
+      return prev;
+    }, [[], []]),
+    _entries$reduce2 = _slicedToArray(_entries$reduce, 2),
+    keys = _entries$reduce2[0],
+    values = _entries$reduce2[1];
+  try {
+    var render = _construct(Function, _toConsumableArray(keys).concat(["return `".concat(template, "`")]));
+    return render.apply(void 0, _toConsumableArray(values));
+  } catch (error) {
+    return template;
+  }
+};
+
+exports.taggedTemplateLiterals = taggedTemplateLiterals;

package/dist/utils/throttle.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var waitable = require('./waitable.cjs');
+var isFunction = require('../is/is-function.cjs');
+var rxjs = require('rxjs');
+
+var throttle = function throttle(throttler, wait) {
+  var isCallable = isFunction.isFunction(throttler);
+  var callback = isCallable ? throttler : throttler.callback;
+  var pipe = isCallable ? function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return args;
+  } : throttler.pipe;
+  var waiter = new waitable.Waitable({
+    callback: callback,
+    pipe: pipe,
+    timer: rxjs.throttleTime(wait)
+  });
+  return {
+    next: function next() {
+      return waiter.next.apply(waiter, arguments);
+    },
+    flush: function flush() {
+      return waiter.flush();
+    },
+    abort: function abort() {
+      return waiter.abort();
+    }
+  };
+};
+
+exports.throttle = throttle;

package/dist/utils/{throttle.js → throttle.mjs}

@@ -1,5 +1,5 @@
-import { Waitable } from './waitable.js';
-import { isFunction } from '../is/is-function.js';
+import { Waitable } from './waitable.mjs';
+import { isFunction } from '../is/is-function.mjs';
 import { throttleTime } from 'rxjs';
 
 var throttle = function throttle(throttler, wait) {

package/dist/utils/to-array.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var _typeof = require('@babel/runtime/helpers/typeof');
+var isVoid = require('../is/is-void.cjs');
+
+/**
+ * @description
+ * convert any type data to a array
+ */
+var toArray = function toArray(value) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    separator = _ref.separator;
+  if (Array.isArray(value)) {
+    return value;
+  }
+  switch (_typeof(value)) {
+    case "string":
+      if (isVoid.isVoid(separator)) {
+        return [value];
+      }
+      return value.split(separator);
+    default:
+      return [value];
+  }
+};
+
+exports.toArray = toArray;

package/dist/utils/{to-array.js → to-array.mjs}

@@ -1,5 +1,5 @@
 import _typeof from '@babel/runtime/helpers/typeof';
-import { isVoid } from '../is/is-void.js';
+import { isVoid } from '../is/is-void.mjs';
 
 /**
  * @description

package/dist/utils/to-form-data.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var isArray = require('../is/is-array.cjs');
+
+/**
+ * @description
+ * convert to formData
+ */
+var toFormData = function toFormData(data) {
+  return Object.entries(data !== null && data !== void 0 ? data : {}).reduce(function (prev, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      key = _ref2[0],
+      value = _ref2[1];
+    // support key-value array data
+    // if value is { list: [ 11, 22 ] }
+    // like prev.append('list[]', 11);
+    if (isArray.isArray(value)) {
+      value.forEach(function (item) {
+        prev.append("".concat(key, "[]"), item);
+      });
+      return prev;
+    }
+    prev.append(key, value);
+    return prev;
+  }, new FormData());
+};
+
+exports.toFormData = toFormData;

package/dist/utils/{to-form-data.js → to-form-data.mjs}

@@ -1,5 +1,5 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import { isArray } from '../is/is-array.js';
+import { isArray } from '../is/is-array.mjs';
 
 /**
  * @description

package/dist/utils/to-function.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var isFunction = require('../is/is-function.cjs');
+
+var toFunction = function toFunction(value) {
+  var _isFunction = isFunction.isFunction(value);
+  if (_isFunction) {
+    return value;
+  }
+  return function () {
+    return value;
+  };
+};
+
+exports.toFunction = toFunction;

package/dist/utils/{to-function.js → to-function.mjs}

@@ -1,4 +1,4 @@
-import { isFunction } from '../is/is-function.js';
+import { isFunction } from '../is/is-function.mjs';
 
 var toFunction = function toFunction(value) {
   var _isFunction = isFunction(value);

package/dist/utils/toggle.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var isSet = require('../is/is-set.cjs');
+
+/**
+ * toggle api
+ * @description
+ * when list has current key, remove it, otherwise add it
+ *
+ * return  a copy of list
+ */
+var toggle = function toggle(value, key) {
+  if (isSet.isSet(value)) {
+    var _copied = new Set(value);
+    if (_copied.has(key)) {
+      _copied["delete"](key);
+    } else {
+      _copied.add(key);
+    }
+    return _copied;
+  }
+  var copied = Array.from(value);
+  var index = copied.indexOf(key);
+  if (index === -1) {
+    copied.push(key);
+  } else {
+    copied.splice(index, 1);
+  }
+  return copied;
+};
+
+exports.toggle = toggle;

package/dist/utils/{toggle.js → toggle.mjs}

@@ -1,4 +1,4 @@
-import { isSet } from '../is/is-set.js';
+import { isSet } from '../is/is-set.mjs';
 
 /**
  * toggle api

package/dist/utils/unique.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+/**
+ * @description
+ * unique
+ */
+var unique = function unique(value) {
+  return Array.from(new Set(value));
+};
+/**
+ * @description
+ * unique by
+ */
+var uniqueBy = function uniqueBy(value, callback) {
+  return Array.from(new Set(Array.from(value).map(callback)));
+};
+
+exports.unique = unique;
+exports.uniqueBy = uniqueBy;

package/dist/utils/waitable.cjs

@@ -0,0 +1,99 @@
+'use strict';
+
+var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
+var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
+var _createClass = require('@babel/runtime/helpers/createClass');
+var _classPrivateMethodInitSpec = require('@babel/runtime/helpers/classPrivateMethodInitSpec');
+var _classPrivateFieldInitSpec = require('@babel/runtime/helpers/classPrivateFieldInitSpec');
+var _classPrivateFieldGet = require('@babel/runtime/helpers/classPrivateFieldGet2');
+var _assertClassBrand = require('@babel/runtime/helpers/assertClassBrand');
+var _classPrivateFieldSet = require('@babel/runtime/helpers/classPrivateFieldSet2');
+var rxjs = require('rxjs');
+var isThenable = require('../is/is-thenable.cjs');
+
+/**
+ * @description
+ * waitable instance
+ * for debounce...
+ */
+var _cook$ = /*#__PURE__*/new WeakMap();
+var _waiter$ = /*#__PURE__*/new WeakMap();
+var _timer = /*#__PURE__*/new WeakMap();
+var _pipe = /*#__PURE__*/new WeakMap();
+var _callback = /*#__PURE__*/new WeakMap();
+var _Waitable_brand = /*#__PURE__*/new WeakSet();
+var Waitable = /*#__PURE__*/function () {
+  function Waitable(props) {
+    _classCallCheck(this, Waitable);
+    _classPrivateMethodInitSpec(this, _Waitable_brand);
+    _classPrivateFieldInitSpec(this, _cook$, void 0);
+    _classPrivateFieldInitSpec(this, _waiter$, void 0);
+    _classPrivateFieldInitSpec(this, _timer, void 0);
+    _classPrivateFieldInitSpec(this, _pipe, void 0);
+    _classPrivateFieldInitSpec(this, _callback, void 0);
+    _classPrivateFieldSet(_cook$, this, null);
+    _classPrivateFieldSet(_waiter$, this, null);
+    _classPrivateFieldSet(_pipe, this, props.pipe);
+    _classPrivateFieldSet(_timer, this, props.timer);
+    _classPrivateFieldSet(_callback, this, props.callback);
+    _assertClassBrand(_Waitable_brand, this, _use).call(this);
+  }
+  return _createClass(Waitable, [{
+    key: "flush",
+    value:
+    /**
+     * @description
+     * flush
+     * complete all handlers
+     * in relax, we will create a new observable for next debounce/throttle handler
+     * so it will make some async problems, pls attention
+     */
+    function flush() {
+      var _classPrivateFieldGet2;
+      (_classPrivateFieldGet2 = _classPrivateFieldGet(_waiter$, this)) === null || _classPrivateFieldGet2 === void 0 || _classPrivateFieldGet2.complete();
+      _assertClassBrand(_Waitable_brand, this, _use).call(this);
+    }
+    /**
+     * @description
+     * abort
+     * cancel all handlers
+     * in relax, we will create a new observable for next debounce/throttle handler
+     */
+  }, {
+    key: "abort",
+    value: function abort() {
+      var _classPrivateFieldGet3, _classPrivateFieldGet4;
+      (_classPrivateFieldGet3 = _classPrivateFieldGet(_cook$, this)) === null || _classPrivateFieldGet3 === void 0 || _classPrivateFieldGet3.unsubscribe();
+      (_classPrivateFieldGet4 = _classPrivateFieldGet(_waiter$, this)) === null || _classPrivateFieldGet4 === void 0 || _classPrivateFieldGet4.error();
+      _assertClassBrand(_Waitable_brand, this, _use).call(this);
+    }
+    /**
+     * @description
+     * trigger value
+     */
+  }, {
+    key: "next",
+    value: function next() {
+      var _classPrivateFieldGet5;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      (_classPrivateFieldGet5 = _classPrivateFieldGet(_waiter$, this)) === null || _classPrivateFieldGet5 === void 0 || _classPrivateFieldGet5.next(args);
+    }
+  }]);
+}();
+function _use() {
+  var _this = this;
+  _classPrivateFieldSet(_cook$, this, new rxjs.Observable(function (subscriber) {
+    _classPrivateFieldSet(_waiter$, _this, subscriber);
+  }).pipe(_classPrivateFieldGet(_timer, this), rxjs.switchMap(function (args) {
+    var _classPrivateFieldGet6;
+    var piped = (_classPrivateFieldGet6 = _classPrivateFieldGet(_pipe, _this)).call.apply(_classPrivateFieldGet6, [_this].concat(_toConsumableArray(args)));
+    return isThenable.isThenable(piped) ? rxjs.from(piped) : rxjs.of(piped);
+  })).subscribe(function (args) {
+    var _classPrivateFieldGet7;
+    (_classPrivateFieldGet7 = _classPrivateFieldGet(_callback, _this)) === null || _classPrivateFieldGet7 === void 0 || _classPrivateFieldGet7.call.apply(_classPrivateFieldGet7, [_this].concat(_toConsumableArray(args)));
+  }));
+}
+
+exports.Waitable = Waitable;

package/dist/utils/{waitable.js → waitable.mjs}

@@ -7,7 +7,7 @@ import _classPrivateFieldGet from '@babel/runtime/helpers/classPrivateFieldGet2'
 import _assertClassBrand from '@babel/runtime/helpers/assertClassBrand';
 import _classPrivateFieldSet from '@babel/runtime/helpers/classPrivateFieldSet2';
 import { Observable, switchMap, from, of } from 'rxjs';
-import { isThenable } from '../is/is-thenable.js';
+import { isThenable } from '../is/is-thenable.mjs';
 
 /**
  * @description

package/package.json

@@ -1,16 +1,21 @@
 {
   "name": "@aiszlab/relax",
-  "version": "1.3.10",
+  "version": "1.3.12",
   "description": "react utils collection",
-  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "node": "./dist/index.cjs",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     },
     "./dom": {
       "types": "./dist/dom/index.d.ts",
-      "default": "./dist/dom/index.js"
+      "node": "./dist/dom/index.cjs",
+      "require": "./dist/dom/index.cjs",
+      "import": "./dist/dom/index.mjs",
+      "default": "./dist/dom/index.mjs"
     },
     "./types": "./dist/types/index.d.ts"
   },

package/dist/dom/index.js

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

package/dist/hooks/use-memorable.js

@@ -1,25 +0,0 @@
-import { useRef, useEffect } from 'react';
-import { useDefault } from './use-default.js';
-
-var useMemorable = function useMemorable(getter, condition, shouldUpdate) {
-  var isMounted = useRef(false);
-  var cacheRef = useRef({
-    value: useDefault(getter),
-    condition: condition
-  });
-  useEffect(function () {
-    // value has got in the first render, skip this render time
-    if (!isMounted.current) {
-      isMounted.current = true;
-      return;
-    }
-    if (!shouldUpdate(cacheRef.current.condition, condition)) return;
-    cacheRef.current = {
-      value: getter(),
-      condition: condition
-    };
-  });
-  return cacheRef.current.value;
-};
-
-export { useMemorable };