@aiszlab/relax 1.3.14 → 1.3.16

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

@@ -1,33 +1,18 @@
 'use strict';
 
-var react = require('react');
-var isFunction = require('../is/is-function.cjs');
+var mountRef = require('../react/mount-ref.cjs');
+var useEvent = require('./use-event.cjs');
 
-var mount = function mount(ref, trigger) {
-  if (isFunction.isFunction(ref)) {
-    ref(trigger);
-    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") {
-    return;
-  }
-  ref.current = trigger;
-};
 var useRefs = function useRefs() {
   for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
     refs[_key] = arguments[_key];
   }
-  return react.useMemo(function () {
-    return function (trigger) {
-      refs.forEach(function (ref) {
-        if (!ref) return;
-        mount(ref, trigger);
-      });
-    };
-  }, refs);
+  return useEvent.useEvent(function (reference) {
+    refs.forEach(function (ref) {
+      if (!ref) return;
+      mountRef.mountRef(ref, reference);
+    });
+  });
 };
 
 exports.useRefs = useRefs;

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

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

package/dist/hooks/use-refs.mjs

@@ -1,31 +1,16 @@
-import { useMemo } from 'react';
-import { isFunction } from '../is/is-function.mjs';
+import { mountRef } from '../react/mount-ref.mjs';
+import { useEvent } from './use-event.mjs';
 
-var mount = function mount(ref, trigger) {
-  if (isFunction(ref)) {
-    ref(trigger);
-    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") {
-    return;
-  }
-  ref.current = trigger;
-};
 var useRefs = function useRefs() {
   for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
     refs[_key] = arguments[_key];
   }
-  return useMemo(function () {
-    return function (trigger) {
-      refs.forEach(function (ref) {
-        if (!ref) return;
-        mount(ref, trigger);
-      });
-    };
-  }, refs);
+  return useEvent(function (reference) {
+    refs.forEach(function (ref) {
+      if (!ref) return;
+      mountRef(ref, reference);
+    });
+  });
 };
 
 export { useRefs };

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

@@ -65,6 +65,9 @@ var toggle = require('./utils/toggle.cjs');
 var taggedTemplateLiterals = require('./utils/tagged-template-literals.cjs');
 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');
 
 
 
@@ -134,3 +137,6 @@ exports.toggle = toggle.toggle;
 exports.taggedTemplateLiterals = taggedTemplateLiterals.taggedTemplateLiterals;
 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

@@ -75,3 +75,6 @@ export { toggle } from "./utils/toggle";
 export { taggedTemplateLiterals } from "./utils/tagged-template-literals";
 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

@@ -63,3 +63,6 @@ export { toggle } from './utils/toggle.mjs';
 export { taggedTemplateLiterals } from './utils/tagged-template-literals.mjs';
 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/react/index.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var mountRef = require('./mount-ref.cjs');
+var isClassComponent = require('./is-class-component.cjs');
+
+
+
+exports.mountRef = mountRef.mountRef;
+exports.isClassComponent = isClassComponent.isClassComponent;

package/dist/react/index.d.ts

@@ -0,0 +1,4 @@
+import { mountRef, type Refable } from "./mount-ref";
+import { isClassComponent } from "./is-class-component";
+export { mountRef, isClassComponent };
+export type { Refable };

package/dist/react/index.mjs

@@ -0,0 +1,2 @@
+export { mountRef } from './mount-ref.mjs';
+export { isClassComponent } from './is-class-component.mjs';

package/dist/react/is-class-component.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var isClassComponent = function isClassComponent() {
+  return false;
+};
+
+exports.isClassComponent = isClassComponent;

package/dist/react/is-class-component.d.ts

@@ -0,0 +1 @@
+export declare const isClassComponent: () => boolean;

package/dist/react/is-class-component.mjs

@@ -0,0 +1,5 @@
+var isClassComponent = function isClassComponent() {
+  return false;
+};
+
+export { isClassComponent };

package/dist/react/mount-ref.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var isFunction = require('../is/is-function.cjs');
+
+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 refable === "string") {
+    return;
+  }
+  refable.current = reference;
+};
+
+exports.mountRef = mountRef;

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

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

package/dist/react/mount-ref.mjs

@@ -0,0 +1,17 @@
+import { isFunction } from '../is/is-function.mjs';
+
+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 refable === "string") {
+    return;
+  }
+  refable.current = reference;
+};
+
+export { mountRef };

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/first.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var toArray = require('./to-array.cjs');
+
+/**
+ * @description
+ * first element of array
+ */
+var first = function first(value) {
+  return toArray.toArray(value).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

@@ -0,0 +1,11 @@
+import { toArray } from './to-array.mjs';
+
+/**
+ * @description
+ * first element of array
+ */
+var first = function first(value) {
+  return toArray(value).at(0);
+};
+
+export { first };

package/dist/utils/last.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var toArray = require('./to-array.cjs');
+
+/**
+ * @description
+ * last element of array
+ */
+var last = function last(value) {
+  return toArray.toArray(value).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

@@ -0,0 +1,11 @@
+import { toArray } from './to-array.mjs';
+
+/**
+ * @description
+ * last element of array
+ */
+var last = function last(value) {
+  return toArray(value).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/unique.cjs

@@ -4,8 +4,13 @@
  * @description
  * unique
  */
-var unique = function unique(value) {
-  return Array.from(new Set(value));
+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()));
 };
 /**
  * @description

package/dist/utils/unique.d.ts

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

package/dist/utils/unique.mjs

@@ -2,8 +2,13 @@
  * @description
  * unique
  */
-var unique = function unique(value) {
-  return Array.from(new Set(value));
+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()));
 };
 /**
  * @description

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiszlab/relax",
-  "version": "1.3.14",
+  "version": "1.3.16",
   "description": "react utils collection",
   "exports": {
     ".": {
@@ -17,6 +17,13 @@
       "import": "./dist/dom/index.mjs",
       "default": "./dist/dom/index.mjs"
     },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "node": "./dist/react/index.cjs",
+      "require": "./dist/react/index.cjs",
+      "import": "./dist/react/index.mjs",
+      "default": "./dist/react/index.mjs"
+    },
     "./types": "./dist/types/index.d.ts"
   },
   "scripts": {
@@ -25,6 +32,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": {
@@ -43,6 +51,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",