@aiszlab/relax 1.2.37 → 1.2.39

package/dist/is/is-refable.js

@@ -0,0 +1,34 @@
+import { isValidElement } from 'react';
+import { isFragment, isMemo } from 'react-is';
+
+/**
+ * @description
+ */
+var isRefable = function isRefable(node) {
+  if (!isValidElement(node)) {
+    return false;
+  }
+  if (isFragment(node)) {
+    return false;
+  }
+  return _RefableElement(node);
+};
+/**
+ * @description
+ * refable element
+ */
+var _RefableElement = function _RefableElement(element) {
+  var _type$prototype, _element$prototype;
+  var type = isMemo(element) ? element.type.type : element.type;
+  // Function component node
+  if (typeof type === 'function' && !((_type$prototype = type.prototype) !== null && _type$prototype !== void 0 && _type$prototype.render)) {
+    return false;
+  }
+  // Class component
+  if (typeof element === 'function' && !((_element$prototype = element.prototype) !== null && _element$prototype !== void 0 && _element$prototype.render)) {
+    return false;
+  }
+  return true;
+};
+
+export { isRefable };

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

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * is state getter
+ */
+var isStateGetter = function isStateGetter(state) {
+  return typeof state === 'function';
+};
+
+export { isStateGetter };

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

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * style element
+ */
+var isStyleElement = function isStyleElement(element) {
+  return element.tagName === 'STYLE';
+};
+
+export { isStyleElement };

package/dist/is/is-thenable/index.js

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * is thenable
+ */
+var isThenable = function isThenable(value) {
+  return value instanceof Promise || !!value.then;
+};
+
+export { isThenable };

package/dist/is/is-thenable/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/is/is-undefined.js

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

package/dist/is/is-void.js

@@ -0,0 +1,12 @@
+import { isUndefined } from './is-undefined.js';
+import { isNull } from './is-null.js';
+
+/**
+ * @description
+ * is null or undefined
+ */
+var isVoid = function isVoid(value) {
+  return isNull(value) || isUndefined(value);
+};
+
+export { isVoid };

package/dist/utils/{chain.d.ts → chain/index.d.ts}

@@ -1,2 +1,2 @@
-import type { Voidable } from '../types';
+import type { Voidable } from '../../types';
 export declare const chain: <T extends Function>(...callbacks: Voidable<T>[]) => T;

package/dist/utils/chain/index.js

@@ -0,0 +1,15 @@
+var chain = function chain() {
+  for (var _len = arguments.length, callbacks = new Array(_len), _key = 0; _key < _len; _key++) {
+    callbacks[_key] = arguments[_key];
+  }
+  return function () {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    callbacks.forEach(function (callback) {
+      callback === null || callback === void 0 || callback.apply(void 0, args);
+    });
+  };
+};
+
+export { chain };

package/dist/utils/chain/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/{clamp.mjs → clamp/index.js}

@@ -6,8 +6,8 @@
  * @param max number
  * @returns number
  */
-const clamp = (value, min, max) => {
-    return Math.min(Math.max(value, min), max);
+var clamp = function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
 };
 
 export { clamp };

package/dist/utils/clamp/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/clone/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/debounce/index.d.ts

@@ -0,0 +1,23 @@
+import { type Callable } from '../../hooks/use-event';
+export interface Debounced<T extends Callable> {
+    /**
+     * @description
+     * value trigger
+     */
+    next: (...args: Parameters<T>) => void;
+    /**
+     * @description
+     * complete current debounce/throttle function
+     */
+    flush: () => void;
+    /**
+     * @description
+     * ignore any value after call cancel
+     */
+    abort: () => void;
+}
+export type Debouncer<T extends Callable, R extends Array<unknown> = Parameters<T>> = {
+    callback: (...args: R) => ReturnType<T>;
+    pipe: (...args: Parameters<T>) => R | Promise<R>;
+};
+export declare const debounce: <T extends Callable, R extends unknown[] = Parameters<T>>(debouncer: T | Debouncer<T, R>, wait: number) => Debounced<T>;

package/dist/utils/debounce/index.js

@@ -0,0 +1,32 @@
+import { debounceTime } from 'rxjs';
+import { isFunction } from '../../is/is-function.js';
+import { Waitable } from '../waitable/index.js';
+
+var debounce = function debounce(debouncer, wait) {
+  var isCallable = 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({
+    callback: callback,
+    pipe: pipe,
+    timer: debounceTime(wait)
+  });
+  return {
+    next: function next() {
+      return waiter.next.apply(waiter, arguments);
+    },
+    flush: function flush() {
+      return waiter.flush();
+    },
+    abort: function abort() {
+      return waiter.abort();
+    }
+  };
+};
+
+export { debounce };

package/dist/utils/debounce/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/{effect.d.ts → effect/index.d.ts}

@@ -1,5 +1,5 @@
 import type { EffectCallback } from 'react';
-import type { ThenableEffectCallback } from '../types';
+import type { ThenableEffectCallback } from '../../types';
 /**
  * @description
  * call thenable effect

package/dist/utils/effect/index.js

@@ -0,0 +1,16 @@
+import { isThenable } from '../../is/is-thenable/index.js';
+
+/**
+ * @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(called)) return void 0;
+  return called;
+};
+
+export { effect };

package/dist/utils/effect/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/exclude/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @description
+ * exclude any value from array
+ *
+ * for performance, avoid using `Array.includes`, replace with `Set`
+ */
+export declare const exclude: (value: Array<unknown>, _excludeBy: Array<unknown>) => unknown[];

package/dist/utils/exclude/index.js

@@ -0,0 +1,14 @@
+/**
+ * @description
+ * exclude any value from array
+ *
+ * for performance, avoid using `Array.includes`, replace with `Set`
+ */
+var exclude = function exclude(value, _excludeBy) {
+  var excludeBy = new Set(_excludeBy);
+  return value.filter(function (item) {
+    return !excludeBy.has(item);
+  });
+};
+
+export { exclude };

package/dist/utils/exclude/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/range.js

@@ -0,0 +1,16 @@
+/**
+ * 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 = to - from + 1;
+  return Array.from({
+    length: length
+  }, function (_, index) {
+    return index + from;
+  });
+};
+
+export { range };

package/dist/utils/set-style.js

@@ -0,0 +1,21 @@
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+
+/**
+ * @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;
+  }, {});
+};
+
+export { setStyle };

package/dist/utils/{throttle.d.ts → throttle/index.d.ts}

@@ -1,5 +1,5 @@
-import { type Debounced, type Debouncer } from './debounce';
-import { type Callable } from '../hooks/use-event';
+import type { Debounced, Debouncer } from '../debounce';
+import { type Callable } from '../../hooks/use-event';
 export type Throttled<T extends Callable> = Debounced<T>;
 export type Throttler<T extends Callable, R extends Array<unknown> = Parameters<T>> = Debouncer<T, R>;
-export declare const throttle: <T extends Callable, R extends unknown[] = Parameters<T>>(throttler: T | Throttler<T, R>, duration: number) => Throttled<T>;
+export declare const throttle: <T extends Callable, R extends unknown[] = Parameters<T>>(throttler: T | Throttler<T, R>, wait: number) => Throttled<T>;

package/dist/utils/throttle/index.js

@@ -0,0 +1,32 @@
+import { Waitable } from '../waitable/index.js';
+import { isFunction } from '../../is/is-function.js';
+import { throttleTime } from 'rxjs';
+
+var throttle = function throttle(throttler, wait) {
+  var isCallable = 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({
+    callback: callback,
+    pipe: pipe,
+    timer: throttleTime(wait)
+  });
+  return {
+    next: function next() {
+      return waiter.next.apply(waiter, arguments);
+    },
+    flush: function flush() {
+      return waiter.flush();
+    },
+    abort: function abort() {
+      return waiter.abort();
+    }
+  };
+};
+
+export { throttle };

package/dist/utils/throttle/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/to-array/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @description
+ * options
+ */
+type Options = {
+    /**
+     * @description
+     * separator
+     * only effect in `value is string`, value would be split by separator
+     */
+    separator?: string;
+};
+/**
+ * @description
+ * convert any type data to a array
+ */
+export declare const toArray: <T extends unknown = unknown>(value: T | T[], { separator }?: Options) => T[];
+export {};

package/dist/utils/to-array/index.js

@@ -0,0 +1,25 @@
+import { typeof as _typeof } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { isVoid } from '../../is/is-void.js';
+
+/**
+ * @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(separator)) {
+        return [value];
+      }
+      return value.split(separator);
+    default:
+      return [value];
+  }
+};
+
+export { toArray };

package/dist/utils/to-array/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/to-function.js

@@ -0,0 +1,13 @@
+import { isFunction } from '../is/is-function.js';
+
+var toFunction = function toFunction(value) {
+  var _isFunction = isFunction(value);
+  if (_isFunction) {
+    return value;
+  }
+  return function () {
+    return value;
+  };
+};
+
+export { toFunction };

package/dist/utils/unique.js

@@ -0,0 +1,16 @@
+/**
+ * @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)));
+};
+
+export { unique, uniqueBy };

package/dist/utils/waitable/index.d.ts

@@ -0,0 +1,36 @@
+import { type MonoTypeOperatorFunction } from 'rxjs';
+interface Props<T extends Array<unknown> = Array<unknown>, R extends Array<unknown> = T> {
+    callback: (...args: T) => unknown;
+    pipe: (...args: R) => T | Promise<T>;
+    timer: MonoTypeOperatorFunction<R>;
+}
+/**
+ * @description
+ * waitable instance
+ * for debounce...
+ */
+export declare class Waitable<T extends Array<unknown>, R extends Array<unknown> = T> {
+    #private;
+    constructor(props: Props<T, R>);
+    /**
+     * @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
+     */
+    flush(): void;
+    /**
+     * @description
+     * abort
+     * cancel all handlers
+     * in relax, we will create a new observable for next debounce/throttle handler
+     */
+    abort(): void;
+    /**
+     * @description
+     * trigger value
+     */
+    next(...args: R): void;
+}
+export {};

package/dist/utils/waitable/index.js

@@ -0,0 +1,90 @@
+import { createClass as _createClass, classPrivateFieldGet2 as _classPrivateFieldGet2, assertClassBrand as _assertClassBrand, classCallCheck as _classCallCheck, classPrivateMethodInitSpec as _classPrivateMethodInitSpec, classPrivateFieldInitSpec as _classPrivateFieldInitSpec, classPrivateFieldSet2 as _classPrivateFieldSet2, toConsumableArray as _toConsumableArray } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { Observable, switchMap, from, of } from 'rxjs';
+import { isThenable } from '../../is/is-thenable/index.js';
+
+/**
+ * @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);
+    _classPrivateFieldSet2(_cook$, this, null);
+    _classPrivateFieldSet2(_waiter$, this, null);
+    _classPrivateFieldSet2(_pipe, this, props.pipe);
+    _classPrivateFieldSet2(_timer, this, props.timer);
+    _classPrivateFieldSet2(_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$1;
+      (_classPrivateFieldGet2$1 = _classPrivateFieldGet2(_waiter$, this)) === null || _classPrivateFieldGet2$1 === void 0 || _classPrivateFieldGet2$1.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 = _classPrivateFieldGet2(_cook$, this)) === null || _classPrivateFieldGet3 === void 0 || _classPrivateFieldGet3.unsubscribe();
+      (_classPrivateFieldGet4 = _classPrivateFieldGet2(_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 = _classPrivateFieldGet2(_waiter$, this)) === null || _classPrivateFieldGet5 === void 0 || _classPrivateFieldGet5.next(args);
+    }
+  }]);
+}();
+function _use() {
+  var _this = this;
+  _classPrivateFieldSet2(_cook$, this, new Observable(function (subscriber) {
+    _classPrivateFieldSet2(_waiter$, _this, subscriber);
+  }).pipe(_classPrivateFieldGet2(_timer, this), switchMap(function (args) {
+    var _classPrivateFieldGet6;
+    var piped = (_classPrivateFieldGet6 = _classPrivateFieldGet2(_pipe, _this)).call.apply(_classPrivateFieldGet6, [_this].concat(_toConsumableArray(args)));
+    return isThenable(piped) ? from(piped) : of(piped);
+  })).subscribe(function (args) {
+    var _classPrivateFieldGet7;
+    (_classPrivateFieldGet7 = _classPrivateFieldGet2(_callback, _this)) === null || _classPrivateFieldGet7 === void 0 || _classPrivateFieldGet7.call.apply(_classPrivateFieldGet7, [_this].concat(_toConsumableArray(args)));
+  }));
+}
+
+export { Waitable };

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@aiszlab/relax",
-  "version": "1.2.37",
+  "version": "1.2.39",
   "description": "react utils collection",
   "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "default": "./dist/index.mjs"
+      "default": "./dist/index.js"
     },
     "./dom": {
       "types": "./dist/dom/index.d.ts",
-      "default": "./dist/dom/index.mjs"
+      "default": "./dist/dom/index.js"
     },
     "./types": "./dist/types/index.d.ts"
   },
@@ -18,7 +18,8 @@
     "dev": "rollup -c -w",
     "build": "rollup -c",
     "clean:build": "rm -rf dist",
-    "pub": "npm run clean:build && npm run build && npm publish"
+    "pub": "npm run clean:build && npm run build && npm publish",
+    "test": "jest"
   },
   "dependencies": {
     "react-is": "^18.2.0",
@@ -28,13 +29,15 @@
     "@babel/core": "^7.24.0",
     "@babel/preset-env": "^7.24.0",
     "@babel/preset-typescript": "^7.24.1",
-    "@rollup/plugin-babel": "^6.0.3",
+    "@rollup/plugin-babel": "^6.0.4",
     "@rollup/plugin-node-resolve": "^15.1.0",
     "@rollup/plugin-typescript": "^11.1.6",
+    "@types/jest": "^29.5.12",
     "@types/react": "^18",
     "@types/react-dom": "^18",
     "@types/react-is": "^18",
-    "rollup": "^4.13.0",
+    "jest": "^29.7.0",
+    "rollup": "^4.17.2",
     "typescript": "5.3.3"
   },
   "peerDependencies": {

package/dist/dom/contains.mjs

@@ -1,20 +0,0 @@
-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;
-    }
-    return false;
-};
-
-export { contains };

package/dist/dom/index.mjs

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