@aiszlab/relax 1.3.15 → 1.3.17

package/dist/dom/contains.cjs

@@ -1,12 +1,13 @@
 'use strict';
 
-var contains = function contains(root, node) {
+var contains = function contains(root) {
+  var node = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
   if (!root) {
     return false;
   }
   // Use native if support
-  if (root.contains) {
-    return root.contains(node !== null && node !== void 0 ? node : null);
+  if (!!root.contains) {
+    return root.contains(node);
   }
   // `document.contains` not support with IE11
   var _node = node;

package/dist/dom/contains.d.ts

@@ -13,4 +13,4 @@ export type Containable = {
      */
     contains?: (node: Nullable<Node>) => boolean;
 };
-export declare const contains: (root: Voidable<Containable>, node: Voidable<Node>) => boolean;
+export declare const contains: (root: Voidable<Containable>, node?: Voidable<Node>) => boolean;

package/dist/dom/contains.mjs

@@ -1,10 +1,11 @@
-var contains = function contains(root, node) {
+var contains = function contains(root) {
+  var node = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
   if (!root) {
     return false;
   }
   // Use native if support
-  if (root.contains) {
-    return root.contains(node !== null && node !== void 0 ? node : null);
+  if (!!root.contains) {
+    return root.contains(node);
   }
   // `document.contains` not support with IE11
   var _node = node;

package/dist/hooks/use-click-away.d.ts

@@ -1,5 +1,5 @@
 import { type MutableRefObject } from "react";
-import { type Containable } from "@aiszlab/relax/dom";
+import { type Containable } from "../dom";
 import type { Nullable, Arrayable } from "@aiszlab/relax/types";
 /**
  * @description

package/dist/hooks/use-refs.cjs

@@ -7,10 +7,10 @@ var useRefs = function useRefs() {
   for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
     refs[_key] = arguments[_key];
   }
-  return useEvent.useEvent(function (_reference) {
+  return useEvent.useEvent(function (reference) {
     refs.forEach(function (ref) {
       if (!ref) return;
-      mountRef.mountRef(ref, _reference);
+      mountRef.mountRef(ref, reference);
     });
   });
 };

package/dist/hooks/use-refs.d.ts

@@ -1,3 +1,3 @@
 import type { Nullable, Voidable } from "@aiszlab/relax/types";
-import { type Refable } from "@aiszlab/relax/react";
-export declare const useRefs: <T>(...refs: Voidable<Refable<Nullable<T>>>[]) => (_reference: T) => void;
+import { type Refable } from "../react/mount-ref";
+export declare const useRefs: <T>(...refs: Voidable<Refable<Nullable<T>>>[]) => (reference: T) => void;

package/dist/hooks/use-refs.mjs

@@ -5,10 +5,10 @@ var useRefs = function useRefs() {
   for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
     refs[_key] = arguments[_key];
   }
-  return useEvent(function (_reference) {
+  return useEvent(function (reference) {
     refs.forEach(function (ref) {
       if (!ref) return;
-      mountRef(ref, _reference);
+      mountRef(ref, reference);
     });
   });
 };

package/dist/hooks/use-scrollable.d.ts

@@ -1,5 +1,5 @@
 import { type Key } from "react";
-import { type Orientation } from "@aiszlab/relax/dom";
+import { type Orientation } from "../dom";
 interface UseScrollableProps {
     orientation?: Orientation;
 }

package/dist/index.cjs

@@ -50,6 +50,7 @@ var isHtmlInputElement = require('./is/is-html-input-element.cjs');
 var isObject = require('./is/is-object.cjs');
 var effect = require('./utils/effect.cjs');
 var unique = require('./utils/unique.cjs');
+var uniqueBy = require('./utils/unique-by.cjs');
 var range = require('./utils/range.cjs');
 var clamp = require('./utils/clamp.cjs');
 var chain = require('./utils/chain.cjs');
@@ -67,6 +68,7 @@ var replace = require('./utils/replace.cjs');
 var clsx = require('./utils/clsx.cjs');
 var first = require('./utils/first.cjs');
 var last = require('./utils/last.cjs');
+var merge = require('./utils/merge.cjs');
 
 
 
@@ -120,7 +122,7 @@ exports.isHTMLInputElement = isHtmlInputElement.isHTMLInputElement;
 exports.isObject = isObject.isObject;
 exports.effect = effect.effect;
 exports.unique = unique.unique;
-exports.uniqueBy = unique.uniqueBy;
+exports.uniqueBy = uniqueBy.uniqueBy;
 exports.range = range.range;
 exports.clamp = clamp.clamp;
 exports.chain = chain.chain;
@@ -138,3 +140,4 @@ exports.replace = replace.replace;
 exports.clsx = clsx.clsx;
 exports.first = first.first;
 exports.last = last.last;
+exports.merge = merge.merge;

package/dist/index.d.ts

@@ -59,7 +59,8 @@ export { isObject } from "./is/is-object";
  * utils
  */
 export { effect } from "./utils/effect";
-export { unique, uniqueBy } from "./utils/unique";
+export { unique } from "./utils/unique";
+export { uniqueBy } from "./utils/unique-by";
 export { range } from "./utils/range";
 export { clamp } from "./utils/clamp";
 export { chain } from "./utils/chain";
@@ -77,3 +78,4 @@ export { replace } from "./utils/replace";
 export { clsx } from "./utils/clsx";
 export { first } from "./utils/first";
 export { last } from "./utils/last";
+export { merge } from "./utils/merge";

package/dist/index.mjs

@@ -47,7 +47,8 @@ export { isHTMLElement } from './is/is-html-element.mjs';
 export { isHTMLInputElement } from './is/is-html-input-element.mjs';
 export { isObject } from './is/is-object.mjs';
 export { effect } from './utils/effect.mjs';
-export { unique, uniqueBy } from './utils/unique.mjs';
+export { unique } from './utils/unique.mjs';
+export { uniqueBy } from './utils/unique-by.mjs';
 export { range } from './utils/range.mjs';
 export { clamp } from './utils/clamp.mjs';
 export { chain } from './utils/chain.mjs';
@@ -65,3 +66,4 @@ export { replace } from './utils/replace.mjs';
 export { clsx } from './utils/clsx.mjs';
 export { first } from './utils/first.mjs';
 export { last } from './utils/last.mjs';
+export { merge } from './utils/merge.mjs';

package/dist/is/is-empty.cjs

@@ -21,7 +21,7 @@ var isEmpty = function isEmpty(value) {
   if (isObject.isObject(value)) {
     return Object.keys(value).length === 0;
   }
-  return !!value;
+  return !value;
 };
 
 exports.isEmpty = isEmpty;

package/dist/is/is-empty.mjs

@@ -19,7 +19,7 @@ var isEmpty = function isEmpty(value) {
   if (isObject(value)) {
     return Object.keys(value).length === 0;
   }
-  return !!value;
+  return !value;
 };
 
 export { isEmpty };

package/dist/is/is-primitive.cjs

@@ -2,7 +2,8 @@
 
 /**
  * @description
- * string/number/... is primitive type
+ * primitive type
+ * string | number | symbol | boolean | null | undefined
  */
 var isPrimitive = function isPrimitive(value) {
   return value !== Object(value);

package/dist/is/is-primitive.d.ts

@@ -1,5 +1,7 @@
+export type Primitive = string | number | symbol | boolean | null | undefined;
 /**
  * @description
- * string/number/... is primitive type
+ * primitive type
+ * string | number | symbol | boolean | null | undefined
  */
-export declare const isPrimitive: (value: unknown) => boolean;
+export declare const isPrimitive: <T extends Primitive>(value: unknown) => value is T;

package/dist/is/is-primitive.mjs

@@ -1,6 +1,7 @@
 /**
  * @description
- * string/number/... is primitive type
+ * primitive type
+ * string | number | symbol | boolean | null | undefined
  */
 var isPrimitive = function isPrimitive(value) {
   return value !== Object(value);

package/dist/path/index.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var leaf = require('./leaf.cjs');
+
+
+
+exports.leaf = leaf.leaf;

package/dist/path/index.d.ts

@@ -0,0 +1 @@
+export { leaf } from "./leaf";

package/dist/path/index.mjs

@@ -0,0 +1 @@
+export { leaf } from './leaf.mjs';

package/dist/path/leaf.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+/**
+ * @description
+ * leaf
+ */
+var leaf = function leaf(path) {
+  var start = 0;
+  for (var index = path.length - 1; index >= 0; index--) {
+    if (path.charCodeAt(index) === 47) {
+      start = index + 1;
+      break;
+    }
+  }
+  return path.slice(start);
+};
+
+exports.leaf = leaf;

package/dist/path/leaf.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * leaf
+ */
+export declare const leaf: (path: string) => string;

package/dist/path/leaf.mjs

@@ -0,0 +1,16 @@
+/**
+ * @description
+ * leaf
+ */
+var leaf = function leaf(path) {
+  var start = 0;
+  for (var index = path.length - 1; index >= 0; index--) {
+    if (path.charCodeAt(index) === 47) {
+      start = index + 1;
+      break;
+    }
+  }
+  return path.slice(start);
+};
+
+export { leaf };

package/dist/react/mount-ref.cjs

@@ -2,18 +2,18 @@
 
 var isFunction = require('../is/is-function.cjs');
 
-var mountRef = function mountRef(ref, trigger) {
-  if (isFunction.isFunction(ref)) {
-    ref(trigger);
+var mountRef = function mountRef(refable, reference) {
+  if (isFunction.isFunction(refable)) {
+    refable(reference);
     return;
   }
   // in deprecated react, class component can use string ref
   // but there are many problems, in relax, we just make it not work
   // issue for react: https://github.com/facebook/react/pull/8333#issuecomment-271648615
-  if (typeof ref === "string") {
+  if (typeof refable === "string") {
     return;
   }
-  ref.current = trigger;
+  refable.current = reference;
 };
 
 exports.mountRef = mountRef;

package/dist/react/mount-ref.d.ts

@@ -1,3 +1,3 @@
 import type { MutableRefObject, RefCallback } from "react";
 export type Refable<T> = RefCallback<T> | MutableRefObject<T> | string;
-export declare const mountRef: <T>(ref: Refable<T>, trigger: T) => void;
+export declare const mountRef: <T>(refable: Refable<T>, reference: T) => void;

package/dist/react/mount-ref.mjs

@@ -1,17 +1,17 @@
 import { isFunction } from '../is/is-function.mjs';
 
-var mountRef = function mountRef(ref, trigger) {
-  if (isFunction(ref)) {
-    ref(trigger);
+var mountRef = function mountRef(refable, reference) {
+  if (isFunction(refable)) {
+    refable(reference);
     return;
   }
   // in deprecated react, class component can use string ref
   // but there are many problems, in relax, we just make it not work
   // issue for react: https://github.com/facebook/react/pull/8333#issuecomment-271648615
-  if (typeof ref === "string") {
+  if (typeof refable === "string") {
     return;
   }
-  ref.current = trigger;
+  refable.current = reference;
 };
 
 export { mountRef };

package/dist/types/first.d.ts

@@ -1 +1 @@
-export type First<T, R = undefined> = T extends [infer D, ...Array<unknown>] ? D : R;
+export type First<T, R = undefined> = T extends string ? string : T extends [infer D, ...Array<unknown>] ? D : R;

package/dist/utils/clone.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
 var isArray = require('../is/is-array.cjs');
 var isPrimitive = require('../is/is-primitive.cjs');
 
@@ -8,12 +9,38 @@ var isPrimitive = require('../is/is-primitive.cjs');
  * in develop, there are many cases to clone a string/number/object/array
  * this util is planning to resolve it
  */
-var clone = function clone(value) {
+var _clone = function clone(value) {
   if (isPrimitive.isPrimitive(value)) return value;
-  if (value instanceof Map) return new Map(value);
-  if (value instanceof Set) return new Set(value);
-  if (isArray.isArray(value)) return Array.from(value);
-  return Object(value);
+  if (value instanceof Map) {
+    // @ts-ignore
+    return new Map(Array.from(value.entries()).map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        _key = _ref2[0],
+        _value = _ref2[1];
+      return [_key, _clone(_value)];
+    }));
+  }
+  if (value instanceof Set) {
+    // @ts-ignore
+    return new Set(Array.from(value.values()).map(function (_value) {
+      return _clone(_value);
+    }));
+  }
+  if (isArray.isArray(value)) {
+    // @ts-ignore
+    return value.map(function (_value) {
+      return _clone(_value);
+    });
+  }
+  // @ts-ignore
+  return Object.entries(value).reduce(function (cloned, _ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+      _key = _ref4[0],
+      _value = _ref4[1];
+    // @ts-ignore
+    cloned[_key] = _clone(_value);
+    return cloned;
+  }, {});
 };
 
-exports.clone = clone;
+exports.clone = _clone;

package/dist/utils/clone.d.ts

@@ -3,4 +3,4 @@
  * in develop, there are many cases to clone a string/number/object/array
  * this util is planning to resolve it
  */
-export declare const clone: (value: unknown) => any;
+export declare const clone: <T>(value: T) => T;

package/dist/utils/clone.mjs

@@ -1,3 +1,4 @@
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import { isArray } from '../is/is-array.mjs';
 import { isPrimitive } from '../is/is-primitive.mjs';
 
@@ -6,12 +7,38 @@ import { isPrimitive } from '../is/is-primitive.mjs';
  * in develop, there are many cases to clone a string/number/object/array
  * this util is planning to resolve it
  */
-var clone = function clone(value) {
+var _clone = function clone(value) {
   if (isPrimitive(value)) return value;
-  if (value instanceof Map) return new Map(value);
-  if (value instanceof Set) return new Set(value);
-  if (isArray(value)) return Array.from(value);
-  return Object(value);
+  if (value instanceof Map) {
+    // @ts-ignore
+    return new Map(Array.from(value.entries()).map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        _key = _ref2[0],
+        _value = _ref2[1];
+      return [_key, _clone(_value)];
+    }));
+  }
+  if (value instanceof Set) {
+    // @ts-ignore
+    return new Set(Array.from(value.values()).map(function (_value) {
+      return _clone(_value);
+    }));
+  }
+  if (isArray(value)) {
+    // @ts-ignore
+    return value.map(function (_value) {
+      return _clone(_value);
+    });
+  }
+  // @ts-ignore
+  return Object.entries(value).reduce(function (cloned, _ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+      _key = _ref4[0],
+      _value = _ref4[1];
+    // @ts-ignore
+    cloned[_key] = _clone(_value);
+    return cloned;
+  }, {});
 };
 
-export { clone };
+export { _clone as clone };

package/dist/utils/debounce.cjs

@@ -5,17 +5,12 @@ 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 _isFunction = isFunction.isFunction(debouncer);
+  var callback = _isFunction ? debouncer : debouncer.callback;
+  // @ts-ignore
   var waiter = new waitable.Waitable({
     callback: callback,
-    pipe: pipe,
+    pipe: _isFunction ? void 0 : debouncer.pipe,
     timer: rxjs.debounceTime(wait)
   });
   return {

package/dist/utils/debounce.d.ts

@@ -16,8 +16,8 @@ export interface Debounced<T extends Callable> {
      */
     abort: () => void;
 }
-export type Debouncer<T extends Callable, R extends Array<unknown> = Parameters<T>> = {
-    callback: (...args: R) => ReturnType<T>;
+export type Debouncer<T extends Callable, R = unknown> = {
+    callback: (args: R) => ReturnType<T>;
     pipe: (...args: Parameters<T>) => R | Promise<R>;
 };
-export declare const debounce: <T extends Callable, R extends Array<unknown> = Parameters<T>>(debouncer: Debouncer<T, R> | T, wait: number) => Debounced<T>;
+export declare const debounce: <T extends Callable, R = unknown>(debouncer: Debouncer<T, R> | T, wait: number) => Debounced<T>;

package/dist/utils/debounce.mjs

@@ -3,17 +3,12 @@ import { isFunction } from '../is/is-function.mjs';
 import { Waitable } from './waitable.mjs';
 
 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 _isFunction = isFunction(debouncer);
+  var callback = _isFunction ? debouncer : debouncer.callback;
+  // @ts-ignore
   var waiter = new Waitable({
     callback: callback,
-    pipe: pipe,
+    pipe: _isFunction ? void 0 : debouncer.pipe,
     timer: debounceTime(wait)
   });
   return {

package/dist/utils/first.cjs

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

package/dist/utils/first.d.ts

@@ -1,4 +1,4 @@
-import { type First } from "../types";
+import { type First } from "@aiszlab/relax/types";
 /**
  * @description
  * first element of array

package/dist/utils/first.mjs

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

package/dist/utils/last.cjs

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

package/dist/utils/last.d.ts

@@ -1,4 +1,4 @@
-import { type Last } from "../types";
+import { type Last } from "@aiszlab/relax/types";
 /**
  * @description
  * last element of array

package/dist/utils/last.mjs

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

package/dist/utils/merge.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var isArray = require('../is/is-array.cjs');
+var isFunction = require('../is/is-function.cjs');
+var isPrimitive = require('../is/is-primitive.cjs');
+var clone = require('./clone.cjs');
+var unique = require('./unique.cjs');
+
+var _merge2 = function _merge(previous, next) {
+  if (isPrimitive.isPrimitive(previous) || isPrimitive.isPrimitive(next) || isFunction.isFunction(previous) || isFunction.isFunction(next) || previous === next) {
+    return clone.clone(next);
+  }
+  var _previous = new Map(Object.entries(previous));
+  var _next = new Map(Object.entries(next));
+  var _uniqueKeys = unique.unique(_previous.keys(), _next.keys());
+  var merged = _uniqueKeys.reduce(function (_merged, _key) {
+    var _previousValue = _previous.get(_key);
+    var _nextValue = _next.get(_key);
+    if (!_next.has(_key)) {
+      _merged[_key] = clone.clone(_previousValue);
+      return _merged;
+    }
+    // deep merge child value
+    _merged[_key] = _merge2(_previousValue, _nextValue);
+    return _merged;
+  }, {});
+  // convert value type same as previous
+  // if `previous` is object, use merged object directly
+  if (!isArray.isArray(previous)) return merged;
+  // else `previous` is array, check next value type
+  // but length will be merged when next value is array
+  return Array.from(_objectSpread(_objectSpread({}, merged), {}, {
+    length: isArray.isArray(next) ? Object.keys(merged).length : previous.length
+  }));
+};
+/**
+ * @description
+ * deep merge api
+ * use unique values to avoid duplicate
+ */
+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);
+};
+
+exports.merge = merge;

package/dist/utils/merge.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @description
+ * deep merge api
+ * use unique values to avoid duplicate
+ */
+declare const merge: <T>(values_0: T, ...values: unknown[]) => T;
+export { merge };

package/dist/utils/merge.mjs

@@ -0,0 +1,51 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import { isArray } from '../is/is-array.mjs';
+import { isFunction } from '../is/is-function.mjs';
+import { isPrimitive } from '../is/is-primitive.mjs';
+import { clone as _clone } from './clone.mjs';
+import { unique } from './unique.mjs';
+
+var _merge2 = function _merge(previous, next) {
+  if (isPrimitive(previous) || isPrimitive(next) || isFunction(previous) || isFunction(next) || previous === next) {
+    return _clone(next);
+  }
+  var _previous = new Map(Object.entries(previous));
+  var _next = new Map(Object.entries(next));
+  var _uniqueKeys = unique(_previous.keys(), _next.keys());
+  var merged = _uniqueKeys.reduce(function (_merged, _key) {
+    var _previousValue = _previous.get(_key);
+    var _nextValue = _next.get(_key);
+    if (!_next.has(_key)) {
+      _merged[_key] = _clone(_previousValue);
+      return _merged;
+    }
+    // deep merge child value
+    _merged[_key] = _merge2(_previousValue, _nextValue);
+    return _merged;
+  }, {});
+  // convert value type same as previous
+  // if `previous` is object, use merged object directly
+  if (!isArray(previous)) return merged;
+  // else `previous` is array, check next value type
+  // but length will be merged when next value is array
+  return Array.from(_objectSpread(_objectSpread({}, merged), {}, {
+    length: isArray(next) ? Object.keys(merged).length : previous.length
+  }));
+};
+/**
+ * @description
+ * deep merge api
+ * use unique values to avoid duplicate
+ */
+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);
+};
+
+export { merge };

package/dist/utils/throttle.cjs

@@ -5,17 +5,12 @@ 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 _isFunction = isFunction.isFunction(throttler);
+  var callback = _isFunction ? throttler : throttler.callback;
+  // @ts-ignore
   var waiter = new waitable.Waitable({
     callback: callback,
-    pipe: pipe,
+    pipe: _isFunction ? void 0 : throttler.pipe,
     timer: rxjs.throttleTime(wait)
   });
   return {

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 extends Array<unknown> = Parameters<T>> = Debouncer<T, R>;
-export declare const throttle: <T extends Callable, R extends Array<unknown> = Parameters<T>>(throttler: Throttler<T, R> | T, wait: number) => Throttled<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>;

package/dist/utils/throttle.mjs

@@ -3,17 +3,12 @@ import { isFunction } from '../is/is-function.mjs';
 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 _isFunction = isFunction(throttler);
+  var callback = _isFunction ? throttler : throttler.callback;
+  // @ts-ignore
   var waiter = new Waitable({
     callback: callback,
-    pipe: pipe,
+    pipe: _isFunction ? void 0 : throttler.pipe,
     timer: throttleTime(wait)
   });
   return {

package/dist/utils/unique-by.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var unique = require('./unique.cjs');
+
+/**
+ * @description
+ * unique by
+ */
+var uniqueBy = function uniqueBy(value, pipe) {
+  if (!pipe) {
+    return unique.unique(value);
+  }
+  return Array.from(Array.from(value).reduce(function (prev, _value) {
+    var _key = pipe(_value);
+    if (!prev.has(_key)) {
+      prev.set(pipe(_value), _value);
+    }
+    return prev;
+  }, new Map()).values());
+};
+
+exports.uniqueBy = uniqueBy;

package/dist/utils/unique-by.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description
+ * unique by
+ */
+export declare const uniqueBy: <T, P>(value: Iterable<T>, pipe?: (item: T) => P) => any[];

package/dist/utils/unique-by.mjs

@@ -0,0 +1,20 @@
+import { unique } from './unique.mjs';
+
+/**
+ * @description
+ * unique by
+ */
+var uniqueBy = function uniqueBy(value, pipe) {
+  if (!pipe) {
+    return unique(value);
+  }
+  return Array.from(Array.from(value).reduce(function (prev, _value) {
+    var _key = pipe(_value);
+    if (!prev.has(_key)) {
+      prev.set(pipe(_value), _value);
+    }
+    return prev;
+  }, new Map()).values());
+};
+
+export { uniqueBy };

package/dist/utils/unique.cjs

@@ -4,16 +4,13 @@
  * @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)));
+var unique = function unique() {
+  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
+    values[_key] = arguments[_key];
+  }
+  return Array.from(values.reduce(function (unionize, _value) {
+    return unionize.union(new Set(_value));
+  }, new Set()));
 };
 
 exports.unique = unique;
-exports.uniqueBy = uniqueBy;

package/dist/utils/unique.d.ts

@@ -2,9 +2,4 @@
  * @description
  * unique
  */
-export declare const unique: <T = unknown>(value: Iterable<T>) => T[];
-/**
- * @description
- * unique by
- */
-export declare const uniqueBy: <T, P>(value: Iterable<T>, callback: (item: T) => P) => P[];
+export declare const unique: <T = unknown>(...values: Array<Iterable<T>>) => T[];

package/dist/utils/unique.mjs

@@ -2,15 +2,13 @@
  * @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)));
+var unique = function unique() {
+  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
+    values[_key] = arguments[_key];
+  }
+  return Array.from(values.reduce(function (unionize, _value) {
+    return unionize.union(new Set(_value));
+  }, new Set()));
 };
 
-export { unique, uniqueBy };
+export { unique };

package/dist/utils/waitable.cjs

@@ -33,8 +33,8 @@ var Waitable = /*#__PURE__*/function () {
     _classPrivateFieldInitSpec(this, _callback, void 0);
     _classPrivateFieldSet(_cook$, this, null);
     _classPrivateFieldSet(_waiter$, this, null);
-    _classPrivateFieldSet(_pipe, this, props.pipe);
     _classPrivateFieldSet(_timer, this, props.timer);
+    _classPrivateFieldSet(_pipe, this, props.pipe);
     _classPrivateFieldSet(_callback, this, props.callback);
     _assertClassBrand(_Waitable_brand, this, _use).call(this);
   }
@@ -88,11 +88,20 @@ function _use() {
     _classPrivateFieldSet(_waiter$, _this, subscriber);
   }).pipe(_classPrivateFieldGet(_timer, this), rxjs.switchMap(function (args) {
     var _classPrivateFieldGet6;
+    if (!_classPrivateFieldGet(_pipe, _this)) {
+      return rxjs.of(args);
+    }
     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)));
+    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,21 @@
 import { type MonoTypeOperatorFunction } from "rxjs";
-interface Props<T extends Array<unknown> = Array<unknown>, R extends Array<unknown> = T> {
+interface PropsWithoutPipe<T extends Array<unknown> = Array<unknown>> {
     callback: (...args: T) => unknown;
-    pipe: (...args: R) => T | Promise<T>;
-    timer: MonoTypeOperatorFunction<R>;
+    pipe: undefined;
+    timer: MonoTypeOperatorFunction<T>;
 }
+interface PropsWithPipe<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>;
 /**
  * @description
  * waitable instance
  * for debounce...
  */
-export declare class Waitable<T extends Array<unknown>, R extends Array<unknown> = T> {
+export declare class Waitable<T extends Array<unknown>, R = unknown> {
     #private;
     constructor(props: Props<T, R>);
     /**
@@ -31,6 +37,6 @@ export declare class Waitable<T extends Array<unknown>, R extends Array<unknown>
      * @description
      * trigger value
      */
-    next(...args: R): void;
+    next(...args: T): void;
 }
 export {};

package/dist/utils/waitable.mjs

@@ -6,7 +6,7 @@ import _classPrivateFieldInitSpec from '@babel/runtime/helpers/classPrivateField
 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 { Observable, switchMap, of, from } from 'rxjs';
 import { isThenable } from '../is/is-thenable.mjs';
 
 /**
@@ -31,8 +31,8 @@ var Waitable = /*#__PURE__*/function () {
     _classPrivateFieldInitSpec(this, _callback, void 0);
     _classPrivateFieldSet(_cook$, this, null);
     _classPrivateFieldSet(_waiter$, this, null);
-    _classPrivateFieldSet(_pipe, this, props.pipe);
     _classPrivateFieldSet(_timer, this, props.timer);
+    _classPrivateFieldSet(_pipe, this, props.pipe);
     _classPrivateFieldSet(_callback, this, props.callback);
     _assertClassBrand(_Waitable_brand, this, _use).call(this);
   }
@@ -86,11 +86,20 @@ function _use() {
     _classPrivateFieldSet(_waiter$, _this, subscriber);
   }).pipe(_classPrivateFieldGet(_timer, this), switchMap(function (args) {
     var _classPrivateFieldGet6;
+    if (!_classPrivateFieldGet(_pipe, _this)) {
+      return of(args);
+    }
     var piped = (_classPrivateFieldGet6 = _classPrivateFieldGet(_pipe, _this)).call.apply(_classPrivateFieldGet6, [_this].concat(_toConsumableArray(args)));
     return isThenable(piped) ? from(piped) : of(piped);
   })).subscribe(function (args) {
-    var _classPrivateFieldGet7;
-    (_classPrivateFieldGet7 = _classPrivateFieldGet(_callback, _this)) === null || _classPrivateFieldGet7 === void 0 || _classPrivateFieldGet7.call.apply(_classPrivateFieldGet7, [_this].concat(_toConsumableArray(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.3.15",
+  "version": "1.3.17",
   "description": "react utils collection",
   "exports": {
     ".": {
@@ -24,6 +24,13 @@
       "import": "./dist/react/index.mjs",
       "default": "./dist/react/index.mjs"
     },
+    "./path": {
+      "types": "./dist/path/index.d.ts",
+      "node": "./dist/path/index.cjs",
+      "require": "./dist/path/index.cjs",
+      "import": "./dist/path/index.mjs",
+      "default": "./dist/path/index.mjs"
+    },
     "./types": "./dist/types/index.d.ts"
   },
   "scripts": {
@@ -32,6 +39,7 @@
     "clean:build": "rm -rf dist",
     "prepublishOnly": "npm run clean:build && npm run build",
     "test": "jest",
+    "test:coverage": "jest --coverage",
     "publish:npm": "npm publish"
   },
   "dependencies": {
@@ -50,6 +58,7 @@
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@rollup/plugin-typescript": "^11.1.6",
     "@testing-library/react": "^16.0.1",
+    "@types/babel__core": "^7.20.5",
     "@types/react": "^18.3.6",
     "@types/react-dom": "^18.3.0",
     "@types/react-is": "^18.3.0",