@aiszlab/relax 1.2.57 → 1.2.59

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.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.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.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,6 +1,6 @@
 {
   "name": "@aiszlab/relax",
-  "version": "1.2.57",
+  "version": "1.2.59",
   "description": "react utils collection",
   "type": "module",
   "exports": {
@@ -18,7 +18,7 @@
     "dev": "rollup -c -w",
     "build": "rollup -c",
     "clean:build": "rm -rf dist",
-    "pub": "npm run clean:build && npm run build && npm publish",
+    "prepublishOnly": "npm run clean:build && npm run build",
     "test": "jest"
   },
   "dependencies": {