@aiszlab/relax 1.4.5 → 1.4.7

package/dist/utils/clone.cjs

@@ -35,7 +35,6 @@ var _clone = function clone(value) {
       return _clone(_value);
     });
   }
-  // @ts-ignore
   return Object.entries(value).reduce(function (cloned, _ref3) {
     var _ref4 = _slicedToArray(_ref3, 2),
       _key = _ref4[0],

package/dist/utils/clone.mjs

@@ -33,7 +33,6 @@ var _clone = function clone(value) {
       return _clone(_value);
     });
   }
-  // @ts-ignore
   return Object.entries(value).reduce(function (cloned, _ref3) {
     var _ref4 = _slicedToArray(_ref3, 2),
       _key = _ref4[0],

package/dist/utils/clsx.cjs

@@ -2,19 +2,20 @@
 
 var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
 var isArray = require('../is/is-array.cjs');
+var isBoolean = require('../is/is-boolean.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) {
+var _toClassNames = function toClassNames(_classNames) {
+  if (isVoid.isVoid(_classNames) || isBoolean.isBoolean(_classNames)) return [];
+  if (isString.isString(_classNames) || isNumber.isNumber(_classNames)) return [_classNames.toString()];
+  if (isArray.isArray(_classNames)) {
+    return _classNames.reduce(function (classNames, item) {
       return classNames.concat(_toClassNames(item));
     }, []);
   }
-  return Object.entries(value).reduce(function (classNames, _ref) {
+  return Object.entries(_classNames).reduce(function (classNames, _ref) {
     var _ref2 = _slicedToArray(_ref, 2),
       className = _ref2[0],
       isValid = _ref2[1];
@@ -25,10 +26,10 @@ var _toClassNames = function toClassNames(value) {
   }, []);
 };
 var clsx = function clsx() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
+  for (var _len = arguments.length, _classNames = new Array(_len), _key = 0; _key < _len; _key++) {
+    _classNames[_key] = arguments[_key];
   }
-  return _toClassNames(args).join(" ");
+  return _toClassNames(_classNames).join(" ");
 };
 
 exports.clsx = clsx;

package/dist/utils/clsx.d.ts

@@ -1,3 +1,3 @@
-type Value = string | number | Record<string, boolean> | Value[] | null | undefined;
-export declare const clsx: (...args: Value[]) => string;
+type ClassNames = string | number | Record<string, boolean> | ClassNames[] | null | undefined | boolean;
+export declare const clsx: (..._classNames: ClassNames[]) => string;
 export {};

package/dist/utils/clsx.mjs

@@ -1,18 +1,19 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import { isArray } from '../is/is-array.mjs';
+import { isBoolean } from '../is/is-boolean.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 [];
-  if (isString(value) || isNumber(value)) return [value.toString()];
-  if (isArray(value)) {
-    return value.reduce(function (classNames, item) {
+var _toClassNames = function toClassNames(_classNames) {
+  if (isVoid(_classNames) || isBoolean(_classNames)) return [];
+  if (isString(_classNames) || isNumber(_classNames)) return [_classNames.toString()];
+  if (isArray(_classNames)) {
+    return _classNames.reduce(function (classNames, item) {
       return classNames.concat(_toClassNames(item));
     }, []);
   }
-  return Object.entries(value).reduce(function (classNames, _ref) {
+  return Object.entries(_classNames).reduce(function (classNames, _ref) {
     var _ref2 = _slicedToArray(_ref, 2),
       className = _ref2[0],
       isValid = _ref2[1];
@@ -23,10 +24,10 @@ var _toClassNames = function toClassNames(value) {
   }, []);
 };
 var clsx = function clsx() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
+  for (var _len = arguments.length, _classNames = new Array(_len), _key = 0; _key < _len; _key++) {
+    _classNames[_key] = arguments[_key];
   }
-  return _toClassNames(args).join(" ");
+  return _toClassNames(_classNames).join(" ");
 };
 
 export { clsx };

package/dist/utils/debounce.cjs

@@ -7,7 +7,6 @@ var waitable = require('./waitable.cjs');
 var debounce = function debounce(debouncer, wait) {
   var _isFunction = isFunction.isFunction(debouncer);
   var callback = _isFunction ? debouncer : debouncer.callback;
-  // @ts-ignore
   var waiter = new waitable.Waitable({
     callback: callback,
     pipe: _isFunction ? void 0 : debouncer.pipe,

package/dist/utils/debounce.d.ts

@@ -1,5 +1,5 @@
-import { type Callable } from "../hooks/use-event";
-export interface Debounced<T extends Callable> {
+import type { AnyFunction } from "@aiszlab/relax/types";
+export interface Debounced<T extends AnyFunction> {
     /**
      * @description
      * value trigger
@@ -16,8 +16,8 @@ export interface Debounced<T extends Callable> {
      */
     abort: () => void;
 }
-export type Debouncer<T extends Callable, R = unknown> = {
+export type Debouncer<T extends AnyFunction, R> = {
     callback: (args: R) => ReturnType<T>;
     pipe: (...args: Parameters<T>) => R | Promise<R>;
 };
-export declare const debounce: <T extends Callable, R = unknown>(debouncer: Debouncer<T, R> | T, wait: number) => Debounced<T>;
+export declare const debounce: <T extends AnyFunction, R>(debouncer: Debouncer<T, R> | T, wait: number) => Debounced<T>;

package/dist/utils/debounce.mjs

@@ -5,7 +5,6 @@ import { Waitable } from './waitable.mjs';
 var debounce = function debounce(debouncer, wait) {
   var _isFunction = isFunction(debouncer);
   var callback = _isFunction ? debouncer : debouncer.callback;
-  // @ts-ignore
   var waiter = new Waitable({
     callback: callback,
     pipe: _isFunction ? void 0 : debouncer.pipe,

package/dist/utils/exclude.cjs

@@ -11,7 +11,6 @@
  */
 var exclude = function exclude(value, _excludeBy) {
   var excludeBy = new Set(_excludeBy);
-  // @ts-ignore
   return value.filter(function (item) {
     return !excludeBy.has(item);
   });

package/dist/utils/exclude.mjs

@@ -9,7 +9,6 @@
  */
 var exclude = function exclude(value, _excludeBy) {
   var excludeBy = new Set(_excludeBy);
-  // @ts-ignore
   return value.filter(function (item) {
     return !excludeBy.has(item);
   });

package/dist/utils/last.cjs

@@ -7,7 +7,6 @@ var toArray = require('./to-array.cjs');
  * last element of array
  */
 var last = function last(value) {
-  // @ts-ignore
   return toArray.toArray(value, {
     separator: ""
   }).at(-1);

package/dist/utils/last.mjs

@@ -5,7 +5,6 @@ import { toArray } from './to-array.mjs';
  * last element of array
  */
 var last = function last(value) {
-  // @ts-ignore
   return toArray(value, {
     separator: ""
   }).at(-1);

package/dist/utils/load.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+var isDomUsable = require('../is/is-dom-usable.cjs');
+
+var loadScript = function loadScript(url) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref$defer = _ref.defer,
+    defer = _ref$defer === void 0 ? false : _ref$defer;
+  var _Promise$withResolver = Promise.withResolvers(),
+    promise = _Promise$withResolver.promise,
+    reject = _Promise$withResolver.reject,
+    resolve = _Promise$withResolver.resolve;
+  var script = document.createElement("script");
+  script.src = url;
+  script.async = true;
+  script.crossOrigin = "anonymous";
+  script.defer = defer;
+  script.addEventListener("load", function () {
+    resolve();
+  });
+  script.addEventListener("error", function () {
+    reject();
+  });
+  document.head.appendChild(script);
+  return promise;
+};
+var loadLink = function loadLink(url) {
+  var _Promise$withResolver2 = Promise.withResolvers(),
+    promise = _Promise$withResolver2.promise,
+    reject = _Promise$withResolver2.reject,
+    resolve = _Promise$withResolver2.resolve;
+  var link = document.createElement("link");
+  link.href = url;
+  link.addEventListener("load", function () {
+    resolve();
+  });
+  link.addEventListener("error", function () {
+    reject();
+  });
+  document.head.appendChild(link);
+  return promise;
+};
+function load(type, url, loading) {
+  if (!isDomUsable.isDomUsable()) return null;
+  switch (type) {
+    case "script":
+      return loadScript(url, loading);
+    case "link":
+      return loadLink(url);
+    default:
+      return Promise.resolve();
+  }
+}
+
+exports.load = load;

package/dist/utils/load.d.ts

@@ -0,0 +1,10 @@
+type ScriptLoading = {
+    defer?: boolean;
+};
+/**
+ * @description
+ * load remote resource
+ */
+declare function load(type: "script", url: string, loading?: ScriptLoading): Promise<void>;
+declare function load(type: "link", url: string): Promise<void>;
+export { load };

package/dist/utils/load.mjs

@@ -0,0 +1,53 @@
+import { isDomUsable } from '../is/is-dom-usable.mjs';
+
+var loadScript = function loadScript(url) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref$defer = _ref.defer,
+    defer = _ref$defer === void 0 ? false : _ref$defer;
+  var _Promise$withResolver = Promise.withResolvers(),
+    promise = _Promise$withResolver.promise,
+    reject = _Promise$withResolver.reject,
+    resolve = _Promise$withResolver.resolve;
+  var script = document.createElement("script");
+  script.src = url;
+  script.async = true;
+  script.crossOrigin = "anonymous";
+  script.defer = defer;
+  script.addEventListener("load", function () {
+    resolve();
+  });
+  script.addEventListener("error", function () {
+    reject();
+  });
+  document.head.appendChild(script);
+  return promise;
+};
+var loadLink = function loadLink(url) {
+  var _Promise$withResolver2 = Promise.withResolvers(),
+    promise = _Promise$withResolver2.promise,
+    reject = _Promise$withResolver2.reject,
+    resolve = _Promise$withResolver2.resolve;
+  var link = document.createElement("link");
+  link.href = url;
+  link.addEventListener("load", function () {
+    resolve();
+  });
+  link.addEventListener("error", function () {
+    reject();
+  });
+  document.head.appendChild(link);
+  return promise;
+};
+function load(type, url, loading) {
+  if (!isDomUsable()) return null;
+  switch (type) {
+    case "script":
+      return loadScript(url, loading);
+    case "link":
+      return loadLink(url);
+    default:
+      return Promise.resolve();
+  }
+}
+
+export { load };

package/dist/utils/merge.cjs

@@ -43,9 +43,7 @@ var merge = function merge() {
   for (var _len = arguments.length, values = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
     values[_key2] = arguments[_key2];
   }
-  // @ts-ignore
   return unique.unique(values).reduce(function (_merged, _value) {
-    // @ts-ignore
     return _merge2(_merged, _value !== null && _value !== void 0 ? _value : {});
   }, null);
 };

package/dist/utils/merge.mjs

@@ -41,9 +41,7 @@ var merge = function merge() {
   for (var _len = arguments.length, values = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
     values[_key2] = arguments[_key2];
   }
-  // @ts-ignore
   return unique(values).reduce(function (_merged, _value) {
-    // @ts-ignore
     return _merge2(_merged, _value !== null && _value !== void 0 ? _value : {});
   }, null);
 };

package/dist/utils/replace.cjs

@@ -1,22 +1,23 @@
 'use strict';
 
 var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
-var isArray = require('../is/is-array.cjs');
+var isString = require('../is/is-string.cjs');
+var toArray = require('./to-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)));
+function replace(value) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
   }
-  var replaceValue = options.replaceValue,
-    searchValue = options.searchValue;
-  return value.replace(searchValue, replaceValue);
-};
+  if (isString.isString(value)) {
+    return value.replace.apply(value, args);
+  }
+  var incoming = args[0],
+    start = args[1],
+    end = args[2];
+  var _incomings = toArray.toArray(incoming);
+  var leading = value.slice(0, start);
+  var trailing = value.slice(end !== null && end !== void 0 ? end : start + _incomings.length);
+  return [].concat(_toConsumableArray(leading), _toConsumableArray(_incomings), _toConsumableArray(trailing));
+}
 
 exports.replace = replace;

package/dist/utils/replace.d.ts

@@ -1,16 +1,17 @@
-type ReplaceArrayOptions<R> = {
-    index: number;
-    replaceValue: R;
-};
-type ReplaceStringOptions = {
-    searchValue: string;
-    replaceValue: string;
-};
-type ReplaceOptions<T> = T extends string ? ReplaceStringOptions : T extends Array<infer R> ? ReplaceArrayOptions<R> : never;
+type StringReplacing = [searchValue: string, incoming: string];
+type ArrayReplacing<T> = [incoming: Array<T> | T, start: number, end?: number];
 /**
  * @description
- * comman replace
- * usable for `string`, `array`
+ * string replace.
+ * it is an easy way to replace string.
+ * wrapper for `String.prototype.replace`.
  */
-export declare const replace: <T extends string | R[], R>(value: T, options: ReplaceOptions<T>) => T;
-export {};
+declare function replace(value: string, ...args: StringReplacing): string;
+/**
+ * @description
+ * replace array.
+ * `value`, `incoming` should be array.
+ * [start, end)
+ */
+declare function replace<T>(value: Array<T>, ...args: ArrayReplacing<T>): Array<T>;
+export { replace };

package/dist/utils/replace.mjs

@@ -1,20 +1,21 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import { isArray } from '../is/is-array.mjs';
+import { isString } from '../is/is-string.mjs';
+import { toArray } from './to-array.mjs';
 
-/**
- * @description
- * comman replace
- * usable for `string`, `array`
- */
-var replace = function replace(value, options) {
-  if (isArray(value)) {
-    var index = options.index,
-      _replaceValue = options.replaceValue;
-    return [].concat(_toConsumableArray(value.slice(0, index)), [_replaceValue], _toConsumableArray(value.slice(index + 1)));
+function replace(value) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
   }
-  var replaceValue = options.replaceValue,
-    searchValue = options.searchValue;
-  return value.replace(searchValue, replaceValue);
-};
+  if (isString(value)) {
+    return value.replace.apply(value, args);
+  }
+  var incoming = args[0],
+    start = args[1],
+    end = args[2];
+  var _incomings = toArray(incoming);
+  var leading = value.slice(0, start);
+  var trailing = value.slice(end !== null && end !== void 0 ? end : start + _incomings.length);
+  return [].concat(_toConsumableArray(leading), _toConsumableArray(_incomings), _toConsumableArray(trailing));
+}
 
 export { replace };

package/dist/utils/set-style.cjs

@@ -6,16 +6,14 @@ var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
  * @description
  * set inline style util
  */
-var setStyle = function setStyle(target, styles) {
+var setStyle = function setStyle(element, 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;
+    prev[key] = element.style[key];
+    element.style[key] = value;
     return prev;
   }, {});
 };

package/dist/utils/set-style.d.ts

@@ -3,4 +3,4 @@ import type { Voidable } from "@aiszlab/relax/types";
  * @description
  * set inline style util
  */
-export declare const setStyle: (target: HTMLElement, styles: Voidable<Partial<CSSStyleDeclaration>>) => Partial<CSSStyleDeclaration>;
+export declare const setStyle: (element: HTMLElement, styles: Voidable<Partial<CSSStyleDeclaration>>) => Partial<CSSStyleDeclaration>;

package/dist/utils/set-style.mjs

@@ -4,16 +4,14 @@ import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
  * @description
  * set inline style util
  */
-var setStyle = function setStyle(target, styles) {
+var setStyle = function setStyle(element, 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;
+    prev[key] = element.style[key];
+    element.style[key] = value;
     return prev;
   }, {});
 };

package/dist/utils/throttle.cjs

@@ -7,7 +7,6 @@ var rxjs = require('rxjs');
 var throttle = function throttle(throttler, wait) {
   var _isFunction = isFunction.isFunction(throttler);
   var callback = _isFunction ? throttler : throttler.callback;
-  // @ts-ignore
   var waiter = new waitable.Waitable({
     callback: callback,
     pipe: _isFunction ? void 0 : throttler.pipe,

package/dist/utils/throttle.d.ts

@@ -1,5 +1,5 @@
 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 = unknown> = Debouncer<T, R>;
-export declare const throttle: <T extends Callable, R = unknown>(throttler: Throttler<T, R> | T, wait: number) => Throttled<T>;
+import type { AnyFunction } from "@aiszlab/relax/types";
+export type Throttled<T extends AnyFunction> = Debounced<T>;
+export type Throttler<T extends AnyFunction, R = unknown> = Debouncer<T, R>;
+export declare const throttle: <T extends AnyFunction, R = unknown>(throttler: Throttler<T, R> | T, wait: number) => Throttled<T>;

package/dist/utils/throttle.mjs

@@ -5,7 +5,6 @@ import { throttleTime } from 'rxjs';
 var throttle = function throttle(throttler, wait) {
   var _isFunction = isFunction(throttler);
   var callback = _isFunction ? throttler : throttler.callback;
-  // @ts-ignore
   var waiter = new Waitable({
     callback: callback,
     pipe: _isFunction ? void 0 : throttler.pipe,

package/dist/utils/to-function.cjs

@@ -3,8 +3,7 @@
 var isFunction = require('../is/is-function.cjs');
 
 var toFunction = function toFunction(value) {
-  var _isFunction = isFunction.isFunction(value);
-  if (_isFunction) {
+  if (isFunction.isFunction(value)) {
     return value;
   }
   return function () {

package/dist/utils/to-function.d.ts

@@ -1 +1,4 @@
-export declare const toFunction: <T extends Function>(value: unknown) => T;
+import type { AnyFunction, State } from "../types";
+type Functioned<T> = T extends State<infer R> ? () => R : T extends AnyFunction ? T : T extends Function ? T : () => T;
+export declare const toFunction: <T = unknown>(value: T) => Functioned<T>;
+export {};

package/dist/utils/to-function.mjs

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

package/dist/utils/waitable.cjs

@@ -23,7 +23,10 @@ var _pipe = /*#__PURE__*/new WeakMap();
 var _callback = /*#__PURE__*/new WeakMap();
 var _Waitable_brand = /*#__PURE__*/new WeakSet();
 var Waitable = /*#__PURE__*/function () {
-  function Waitable(props) {
+  function Waitable(_ref) {
+    var callback = _ref.callback,
+      pipe = _ref.pipe,
+      timer = _ref.timer;
     _classCallCheck(this, Waitable);
     _classPrivateMethodInitSpec(this, _Waitable_brand);
     _classPrivateFieldInitSpec(this, _cook$, void 0);
@@ -33,9 +36,9 @@ var Waitable = /*#__PURE__*/function () {
     _classPrivateFieldInitSpec(this, _callback, void 0);
     _classPrivateFieldSet(_cook$, this, null);
     _classPrivateFieldSet(_waiter$, this, null);
-    _classPrivateFieldSet(_timer, this, props.timer);
-    _classPrivateFieldSet(_pipe, this, props.pipe);
-    _classPrivateFieldSet(_callback, this, props.callback);
+    _classPrivateFieldSet(_timer, this, timer);
+    _classPrivateFieldSet(_pipe, this, pipe);
+    _classPrivateFieldSet(_callback, this, callback);
     _assertClassBrand(_Waitable_brand, this, _use).call(this);
   }
   return _createClass(Waitable, [{
@@ -96,10 +99,8 @@ function _use() {
   })).subscribe(function (args) {
     if (!_classPrivateFieldGet(_pipe, _this)) {
       var _classPrivateFieldGet7;
-      // @ts-ignore
       (_classPrivateFieldGet7 = _classPrivateFieldGet(_callback, _this)).call.apply(_classPrivateFieldGet7, [_this].concat(_toConsumableArray(args)));
     } else {
-      // @ts-ignore
       _classPrivateFieldGet(_callback, _this).call(_this, args);
     }
   }));

package/dist/utils/waitable.d.ts

@@ -1,15 +1,15 @@
 import { type MonoTypeOperatorFunction } from "rxjs";
-interface PropsWithoutPipe<T extends Array<unknown> = Array<unknown>> {
+interface WaitingWithoutPipe<T extends Array<unknown> = Array<unknown>> {
     callback: (...args: T) => unknown;
     pipe: undefined;
     timer: MonoTypeOperatorFunction<T>;
 }
-interface PropsWithPipe<T extends Array<unknown> = Array<unknown>, R = unknown> {
+interface WaitingWithPipe<T extends Array<unknown> = Array<unknown>, R = unknown> {
     callback: (value: R) => unknown;
     pipe: (...args: T) => R | Promise<R>;
     timer: MonoTypeOperatorFunction<T>;
 }
-type Props<T extends Array<unknown> = Array<unknown>, R = unknown> = PropsWithoutPipe<T> | PropsWithPipe<T, R>;
+export type Waiting<T extends Array<unknown> = Array<unknown>, R = unknown> = WaitingWithoutPipe<T> | WaitingWithPipe<T, R>;
 /**
  * @description
  * waitable instance
@@ -17,7 +17,7 @@ type Props<T extends Array<unknown> = Array<unknown>, R = unknown> = PropsWithou
  */
 export declare class Waitable<T extends Array<unknown>, R = unknown> {
     #private;
-    constructor(props: Props<T, R>);
+    constructor({ callback, pipe, timer }: Waiting<T, R>);
     /**
      * @description
      * flush

package/dist/utils/waitable.mjs

@@ -21,7 +21,10 @@ var _pipe = /*#__PURE__*/new WeakMap();
 var _callback = /*#__PURE__*/new WeakMap();
 var _Waitable_brand = /*#__PURE__*/new WeakSet();
 var Waitable = /*#__PURE__*/function () {
-  function Waitable(props) {
+  function Waitable(_ref) {
+    var callback = _ref.callback,
+      pipe = _ref.pipe,
+      timer = _ref.timer;
     _classCallCheck(this, Waitable);
     _classPrivateMethodInitSpec(this, _Waitable_brand);
     _classPrivateFieldInitSpec(this, _cook$, void 0);
@@ -31,9 +34,9 @@ var Waitable = /*#__PURE__*/function () {
     _classPrivateFieldInitSpec(this, _callback, void 0);
     _classPrivateFieldSet(_cook$, this, null);
     _classPrivateFieldSet(_waiter$, this, null);
-    _classPrivateFieldSet(_timer, this, props.timer);
-    _classPrivateFieldSet(_pipe, this, props.pipe);
-    _classPrivateFieldSet(_callback, this, props.callback);
+    _classPrivateFieldSet(_timer, this, timer);
+    _classPrivateFieldSet(_pipe, this, pipe);
+    _classPrivateFieldSet(_callback, this, callback);
     _assertClassBrand(_Waitable_brand, this, _use).call(this);
   }
   return _createClass(Waitable, [{
@@ -94,10 +97,8 @@ function _use() {
   })).subscribe(function (args) {
     if (!_classPrivateFieldGet(_pipe, _this)) {
       var _classPrivateFieldGet7;
-      // @ts-ignore
       (_classPrivateFieldGet7 = _classPrivateFieldGet(_callback, _this)).call.apply(_classPrivateFieldGet7, [_this].concat(_toConsumableArray(args)));
     } else {
-      // @ts-ignore
       _classPrivateFieldGet(_callback, _this).call(_this, args);
     }
   }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiszlab/relax",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "description": "react utils collection",
   "exports": {
     ".": {