@aiszlab/relax 2.0.4 → 2.0.6-beta.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2023 aiszlab
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2023 aiszlab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,5 @@
-# relax
-favorite and easy hooks for react
-
-## i alaways like writting many hooks for mine project
+# relax
+favorite and easy hooks for react
+
+## i alaways like writting many hooks for mine project
 ## so i need a hooks project to support me

package/dist/class-name/normalize.cjs

@@ -1,6 +1,5 @@
 'use strict';
 
-var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
 var _createForOfIteratorHelper = require('@babel/runtime/helpers/createForOfIteratorHelper');
 var isString = require('../is/is-string.cjs');
 
@@ -11,13 +10,12 @@ function normalize() {
   }
   for (var _i = 0, _classNames2 = classNames; _i < _classNames2.length; _i++) {
     var _classNames = _classNames2[_i];
-    if (!isString.isString(_classNames)) return;
+    if (!isString.isString(_classNames)) continue;
     var _iterator = _createForOfIteratorHelper(_classNames.matchAll(/\S+/g)),
       _step;
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var _step$value = _slicedToArray(_step.value, 1),
-          className = _step$value[0];
+        var className = _step.value[0];
         values.add(className);
       }
     } catch (err) {

package/dist/class-name/normalize.d.ts

@@ -1,2 +1,3 @@
-declare function normalize(...classNames: string[]): string[] | undefined;
+import type { Partialable } from "../types";
+declare function normalize(...classNames: Partialable<string>[]): string[];
 export { normalize };

package/dist/class-name/normalize.mjs

@@ -1,4 +1,3 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _createForOfIteratorHelper from '@babel/runtime/helpers/createForOfIteratorHelper';
 import { isString } from '../is/is-string.mjs';
 
@@ -9,13 +8,12 @@ function normalize() {
   }
   for (var _i = 0, _classNames2 = classNames; _i < _classNames2.length; _i++) {
     var _classNames = _classNames2[_i];
-    if (!isString(_classNames)) return;
+    if (!isString(_classNames)) continue;
     var _iterator = _createForOfIteratorHelper(_classNames.matchAll(/\S+/g)),
       _step;
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var _step$value = _slicedToArray(_step.value, 1),
-          className = _step$value[0];
+        var className = _step.value[0];
         values.add(className);
       }
     } catch (err) {

package/dist/hooks/use-lazy-ref.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var react = require('react');
+
+/**
+ * in react, ref always need a initial value
+ * but can not be a function
+ * so we create a lazy ref to get a value getter
+ */
+function useLazyRef(getter) {
+  var ref = react.useRef(null);
+  return function () {
+    var _ref$current;
+    return (_ref$current = ref.current) !== null && _ref$current !== void 0 ? _ref$current : ref.current = getter();
+  };
+}
+
+exports.useLazyRef = useLazyRef;

package/dist/hooks/use-lazy-ref.d.ts

@@ -0,0 +1,7 @@
+/**
+ * in react, ref always need a initial value
+ * but can not be a function
+ * so we create a lazy ref to get a value getter
+ */
+declare function useLazyRef<T>(getter: () => T): () => T;
+export { useLazyRef };

package/dist/hooks/use-lazy-ref.mjs

@@ -0,0 +1,16 @@
+import { useRef } from 'react';
+
+/**
+ * in react, ref always need a initial value
+ * but can not be a function
+ * so we create a lazy ref to get a value getter
+ */
+function useLazyRef(getter) {
+  var ref = useRef(null);
+  return function () {
+    var _ref$current;
+    return (_ref$current = ref.current) !== null && _ref$current !== void 0 ? _ref$current : ref.current = getter();
+  };
+}
+
+export { useLazyRef };

package/dist/hooks/use-scroll.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var react = require('react');
+var isDomUsable = require('../is/is-dom-usable.cjs');
+var useEvent = require('./use-event.cjs');
+var useMounted = require('./use-mounted.cjs');
+
+/**
+ * `window` `scroll` event
+ */
+function useScroll(callback) {
+  var _callback = useEvent.useEvent(function (event) {
+    callback(event);
+  });
+  var clean = react.useCallback(function () {
+    window.removeEventListener("scroll", _callback);
+  }, [_callback]);
+  useMounted.useMounted(function () {
+    if (!isDomUsable.isDomUsable()) return;
+    window.addEventListener("scroll", _callback);
+    return clean;
+  });
+  return clean;
+}
+
+exports.useScroll = useScroll;

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

@@ -0,0 +1,6 @@
+import type { AnyFunction } from "../types";
+/**
+ * `window` `scroll` event
+ */
+declare function useScroll(callback: AnyFunction<[Event]>): () => void;
+export { useScroll };

package/dist/hooks/use-scroll.mjs

@@ -0,0 +1,24 @@
+import { useCallback } from 'react';
+import { isDomUsable } from '../is/is-dom-usable.mjs';
+import { useEvent } from './use-event.mjs';
+import { useMounted } from './use-mounted.mjs';
+
+/**
+ * `window` `scroll` event
+ */
+function useScroll(callback) {
+  var _callback = useEvent(function (event) {
+    callback(event);
+  });
+  var clean = useCallback(function () {
+    window.removeEventListener("scroll", _callback);
+  }, [_callback]);
+  useMounted(function () {
+    if (!isDomUsable()) return;
+    window.addEventListener("scroll", _callback);
+    return clean;
+  });
+  return clean;
+}
+
+export { useScroll };

package/dist/index.cjs

@@ -40,6 +40,8 @@ var useEventSource = require('./hooks/use-event-source.cjs');
 var useResize = require('./hooks/use-resize.cjs');
 var useDraggable = require('./hooks/use-draggable.cjs');
 var useAsyncEffect = require('./hooks/use-async-effect.cjs');
+var useLazyRef = require('./hooks/use-lazy-ref.cjs');
+var useScroll = require('./hooks/use-scroll.cjs');
 var isRefable = require('./is/is-refable.cjs');
 var isUndefined = require('./is/is-undefined.cjs');
 var isNull = require('./is/is-null.cjs');
@@ -78,6 +80,9 @@ var max = require('./utils/max.cjs');
 var min = require('./utils/min.cjs');
 var load = require('./utils/load.cjs');
 var at = require('./utils/at.cjs');
+var pick = require('./utils/pick.cjs');
+var get = require('./utils/get.cjs');
+var set = require('./utils/set.cjs');
 var replace = require('./utils/replace/replace.cjs');
 var replaceAt = require('./utils/replace/replace-at.cjs');
 
@@ -123,6 +128,8 @@ exports.useEventSource = useEventSource.useEventSource;
 exports.useResize = useResize.useResize;
 exports.useDraggable = useDraggable.useDraggable;
 exports.useAsyncEffect = useAsyncEffect.useAsyncEffect;
+exports.useLazyRef = useLazyRef.useLazyRef;
+exports.useScroll = useScroll.useScroll;
 exports.isRefable = isRefable.isRefable;
 exports.isUndefined = isUndefined.isUndefined;
 exports.isNull = isNull.isNull;
@@ -161,5 +168,8 @@ exports.max = max.max;
 exports.min = min.min;
 exports.load = load.load;
 exports.at = at.at;
+exports.pick = pick.pick;
+exports.get = get.get;
+exports.set = set.set;
 exports.replace = replace.replace;
 exports.replaceAt = replaceAt.replaceAt;

package/dist/index.d.ts

@@ -42,6 +42,8 @@ export { useEventSource } from "./hooks/use-event-source";
 export { useResize } from "./hooks/use-resize";
 export { useDraggable } from "./hooks/use-draggable";
 export { useAsyncEffect } from "./hooks/use-async-effect";
+export { useLazyRef } from "./hooks/use-lazy-ref";
+export { useScroll } from "./hooks/use-scroll";
 /**
  * @description
  * is
@@ -89,3 +91,6 @@ export { max } from "./utils/max";
 export { min } from "./utils/min";
 export { load } from "./utils/load";
 export { at } from "./utils/at";
+export { pick } from "./utils/pick";
+export { get } from "./utils/get";
+export { set } from "./utils/set";

package/dist/index.mjs

@@ -38,6 +38,8 @@ export { useEventSource } from './hooks/use-event-source.mjs';
 export { useResize } from './hooks/use-resize.mjs';
 export { useDraggable } from './hooks/use-draggable.mjs';
 export { useAsyncEffect } from './hooks/use-async-effect.mjs';
+export { useLazyRef } from './hooks/use-lazy-ref.mjs';
+export { useScroll } from './hooks/use-scroll.mjs';
 export { isRefable } from './is/is-refable.mjs';
 export { isUndefined } from './is/is-undefined.mjs';
 export { isNull } from './is/is-null.mjs';
@@ -76,5 +78,8 @@ export { max } from './utils/max.mjs';
 export { min } from './utils/min.mjs';
 export { load } from './utils/load.mjs';
 export { at } from './utils/at.mjs';
+export { pick } from './utils/pick.mjs';
+export { get } from './utils/get.mjs';
+export { set } from './utils/set.mjs';
 export { replace } from './utils/replace/replace.mjs';
 export { replaceAt } from './utils/replace/replace-at.mjs';

package/dist/is/is-deep-key.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+var _typeof = require('@babel/runtime/helpers/typeof');
+
+/**
+ * Checks if a given key is a deep key.
+ *
+ * A deep key is a string that contains a dot (.) or square brackets with a property accessor.
+ *
+ * @param {PropertyKey} key - The key to check.
+ * @returns {boolean} - Returns true if the key is a deep key, otherwise false.
+ *
+ * Examples:
+ *
+ * isDeepKey('a.b') // true
+ * isDeepKey('a[b]') // true
+ * isDeepKey('a') // false
+ * isDeepKey(123) // false
+ * isDeepKey('a.b.c') // true
+ * isDeepKey('a[b][c]') // true
+ */
+function isDeepKey(key) {
+  switch (_typeof(key)) {
+    case "number":
+    case "symbol":
+      {
+        return false;
+      }
+    case "string":
+      {
+        var _deepKeys = new Set([".", "[", "]"]);
+        for (var index = 0; index < key.length; index++) {
+          if (_deepKeys.has(key[index])) {
+            return true;
+          }
+        }
+        return false;
+      }
+    default:
+      {
+        return false;
+      }
+  }
+}
+
+exports.isDeepKey = isDeepKey;

package/dist/is/is-deep-key.mjs

@@ -0,0 +1,44 @@
+import _typeof from '@babel/runtime/helpers/typeof';
+
+/**
+ * Checks if a given key is a deep key.
+ *
+ * A deep key is a string that contains a dot (.) or square brackets with a property accessor.
+ *
+ * @param {PropertyKey} key - The key to check.
+ * @returns {boolean} - Returns true if the key is a deep key, otherwise false.
+ *
+ * Examples:
+ *
+ * isDeepKey('a.b') // true
+ * isDeepKey('a[b]') // true
+ * isDeepKey('a') // false
+ * isDeepKey(123) // false
+ * isDeepKey('a.b.c') // true
+ * isDeepKey('a[b][c]') // true
+ */
+function isDeepKey(key) {
+  switch (_typeof(key)) {
+    case "number":
+    case "symbol":
+      {
+        return false;
+      }
+    case "string":
+      {
+        var _deepKeys = new Set([".", "[", "]"]);
+        for (var index = 0; index < key.length; index++) {
+          if (_deepKeys.has(key[index])) {
+            return true;
+          }
+        }
+        return false;
+      }
+    default:
+      {
+        return false;
+      }
+  }
+}
+
+export { isDeepKey };

package/dist/is/is-iterable.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var isFunction = require('./is-function.cjs');
+
+/**
+ * is iterable
+ */
+function isIterable(value) {
+  return isFunction.isFunction(value === null || value === void 0 ? void 0 : value[Symbol.iterator]);
+}
+
+exports.isIterable = isIterable;

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

@@ -0,0 +1,5 @@
+/**
+ * is iterable
+ */
+declare function isIterable(value: unknown): value is Iterable<unknown>;
+export { isIterable };

package/dist/is/is-iterable.mjs

@@ -0,0 +1,10 @@
+import { isFunction } from './is-function.mjs';
+
+/**
+ * is iterable
+ */
+function isIterable(value) {
+  return isFunction(value === null || value === void 0 ? void 0 : value[Symbol.iterator]);
+}
+
+export { isIterable };

package/dist/is/is-key.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var isArray = require('./is-array.cjs');
+var isBoolean = require('./is-boolean.cjs');
+var isNull = require('./is-null.cjs');
+var isNumber = require('./is-number.cjs');
+var isObject = require('./is-object.cjs');
+var isString = require('./is-string.cjs');
+var isSymbol = require('./is-symbol.cjs');
+
+/**  Matches any deep property path. (e.g. `a.b[0].c`)*/
+var _IS_DEEP_KEY = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+/**  Matches any word character (alphanumeric & underscore).*/
+var _IS_PLAIN_KEY = /^\w*$/;
+/**
+ * Checks if `value` is a property name and not a property path. (It's ok that the `value` is not in the keys of the `object`)
+ * @param {unknown} value The value to check.
+ * @param {unknown} object The object to query.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ *
+ * @example
+ * isKey('a', { a: 1 });
+ * // => true
+ *
+ * isKey('a.b', { a: { b: 2 } });
+ * // => false
+ */
+function isKey(value, object) {
+  if (isArray.isArray(value) || isObject.isObject(value)) {
+    return false;
+  }
+  if (isNumber.isNumber(value) || isBoolean.isBoolean(value) || isNull.isNull(value) || isSymbol.isSymbol(value)) {
+    return true;
+  }
+  return isString.isString(value) && (_IS_PLAIN_KEY.test(value) || !_IS_DEEP_KEY.test(value)) || object != null && Object.hasOwn(object, value);
+}
+
+exports.isKey = isKey;

package/dist/is/is-key.mjs

@@ -0,0 +1,36 @@
+import { isArray } from './is-array.mjs';
+import { isBoolean } from './is-boolean.mjs';
+import { isNull } from './is-null.mjs';
+import { isNumber } from './is-number.mjs';
+import { isObject } from './is-object.mjs';
+import { isString } from './is-string.mjs';
+import { isSymbol } from './is-symbol.mjs';
+
+/**  Matches any deep property path. (e.g. `a.b[0].c`)*/
+var _IS_DEEP_KEY = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+/**  Matches any word character (alphanumeric & underscore).*/
+var _IS_PLAIN_KEY = /^\w*$/;
+/**
+ * Checks if `value` is a property name and not a property path. (It's ok that the `value` is not in the keys of the `object`)
+ * @param {unknown} value The value to check.
+ * @param {unknown} object The object to query.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ *
+ * @example
+ * isKey('a', { a: 1 });
+ * // => true
+ *
+ * isKey('a.b', { a: { b: 2 } });
+ * // => false
+ */
+function isKey(value, object) {
+  if (isArray(value) || isObject(value)) {
+    return false;
+  }
+  if (isNumber(value) || isBoolean(value) || isNull(value) || isSymbol(value)) {
+    return true;
+  }
+  return isString(value) && (_IS_PLAIN_KEY.test(value) || !_IS_DEEP_KEY.test(value)) || object != null && Object.hasOwn(object, value);
+}
+
+export { isKey };

package/dist/is/is-symbol.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var _typeof = require('@babel/runtime/helpers/typeof');
+
+/**
+ * Check whether a value is a symbol.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `symbol`.
+ *
+ * @param {unknown} value The value to check.
+ * @returns {value is symbol} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ * isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return _typeof(value) === "symbol" || value instanceof Symbol;
+}
+
+exports.isSymbol = isSymbol;

package/dist/is/is-symbol.mjs

@@ -0,0 +1,21 @@
+import _typeof from '@babel/runtime/helpers/typeof';
+
+/**
+ * Check whether a value is a symbol.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `symbol`.
+ *
+ * @param {unknown} value The value to check.
+ * @returns {value is symbol} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ * isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return _typeof(value) === "symbol" || value instanceof Symbol;
+}
+
+export { isSymbol };

package/dist/utils/get.cjs

@@ -0,0 +1,81 @@
+'use strict';
+
+var _typeof = require('@babel/runtime/helpers/typeof');
+var isDeepKey = require('../is/is-deep-key.cjs');
+var toKey = require('./to-key.cjs');
+var toPaths = require('./to-paths.cjs');
+
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @param {unknown} object - The object to query.
+ * @param {PropertyKey | readonly PropertyKey[]} path - The path of the property to get.
+ * @param {unknown} [defaultValue] - The value returned if the resolved value is undefined.
+ * @returns {any} - Returns the resolved value.
+ */
+function get(object, path, defaultValue) {
+  if (object == null) {
+    return defaultValue;
+  }
+  switch (_typeof(path)) {
+    case "string":
+      {
+        var result = object[path];
+        if (result === undefined) {
+          if (isDeepKey.isDeepKey(path)) {
+            return get(object, toPaths.toPaths(path), defaultValue);
+          } else {
+            return defaultValue;
+          }
+        }
+        return result;
+      }
+    case "number":
+    case "symbol":
+      {
+        if (typeof path === "number") {
+          path = toKey.toKey(path);
+        }
+        var _result = object[path];
+        if (_result === undefined) {
+          return defaultValue;
+        }
+        return _result;
+      }
+    default:
+      {
+        var _path;
+        if (Array.isArray(path)) {
+          return getWithPath(object, path, defaultValue);
+        }
+        if (Object.is((_path = path) === null || _path === void 0 ? void 0 : _path.valueOf(), -0)) {
+          path = "-0";
+        } else {
+          path = String(path);
+        }
+        var _result2 = object[path];
+        if (_result2 === undefined) {
+          return defaultValue;
+        }
+        return _result2;
+      }
+  }
+}
+function getWithPath(object, path, defaultValue) {
+  if (path.length === 0) {
+    return defaultValue;
+  }
+  var current = object;
+  for (var index = 0; index < path.length; index++) {
+    if (current == null) {
+      return defaultValue;
+    }
+    current = current[path[index]];
+  }
+  if (current === undefined) {
+    return defaultValue;
+  }
+  return current;
+}
+
+exports.get = get;

package/dist/utils/get.mjs

@@ -0,0 +1,79 @@
+import _typeof from '@babel/runtime/helpers/typeof';
+import { isDeepKey } from '../is/is-deep-key.mjs';
+import { toKey } from './to-key.mjs';
+import { toPaths } from './to-paths.mjs';
+
+/**
+ * Retrieves the value at a given path from an object. If the resolved value is undefined, the defaultValue is returned instead.
+ *
+ * @param {unknown} object - The object to query.
+ * @param {PropertyKey | readonly PropertyKey[]} path - The path of the property to get.
+ * @param {unknown} [defaultValue] - The value returned if the resolved value is undefined.
+ * @returns {any} - Returns the resolved value.
+ */
+function get(object, path, defaultValue) {
+  if (object == null) {
+    return defaultValue;
+  }
+  switch (_typeof(path)) {
+    case "string":
+      {
+        var result = object[path];
+        if (result === undefined) {
+          if (isDeepKey(path)) {
+            return get(object, toPaths(path), defaultValue);
+          } else {
+            return defaultValue;
+          }
+        }
+        return result;
+      }
+    case "number":
+    case "symbol":
+      {
+        if (typeof path === "number") {
+          path = toKey(path);
+        }
+        var _result = object[path];
+        if (_result === undefined) {
+          return defaultValue;
+        }
+        return _result;
+      }
+    default:
+      {
+        var _path;
+        if (Array.isArray(path)) {
+          return getWithPath(object, path, defaultValue);
+        }
+        if (Object.is((_path = path) === null || _path === void 0 ? void 0 : _path.valueOf(), -0)) {
+          path = "-0";
+        } else {
+          path = String(path);
+        }
+        var _result2 = object[path];
+        if (_result2 === undefined) {
+          return defaultValue;
+        }
+        return _result2;
+      }
+  }
+}
+function getWithPath(object, path, defaultValue) {
+  if (path.length === 0) {
+    return defaultValue;
+  }
+  var current = object;
+  for (var index = 0; index < path.length; index++) {
+    if (current == null) {
+      return defaultValue;
+    }
+    current = current[path[index]];
+  }
+  if (current === undefined) {
+    return defaultValue;
+  }
+  return current;
+}
+
+export { get };

package/dist/utils/is-index.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var _typeof = require('@babel/runtime/helpers/typeof');
+
+var IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
+function isIndex(value) {
+  var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Number.MAX_SAFE_INTEGER;
+  switch (_typeof(value)) {
+    case "number":
+      {
+        return Number.isInteger(value) && value >= 0 && value < length;
+      }
+    case "symbol":
+      {
+        return false;
+      }
+    case "string":
+      {
+        return IS_UNSIGNED_INTEGER.test(value);
+      }
+    default:
+      {
+        return false;
+      }
+  }
+}
+
+exports.isIndex = isIndex;

package/dist/utils/is-index.mjs

@@ -0,0 +1,26 @@
+import _typeof from '@babel/runtime/helpers/typeof';
+
+var IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
+function isIndex(value) {
+  var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Number.MAX_SAFE_INTEGER;
+  switch (_typeof(value)) {
+    case "number":
+      {
+        return Number.isInteger(value) && value >= 0 && value < length;
+      }
+    case "symbol":
+      {
+        return false;
+      }
+    case "string":
+      {
+        return IS_UNSIGNED_INTEGER.test(value);
+      }
+    default:
+      {
+        return false;
+      }
+  }
+}
+
+export { isIndex };

package/dist/utils/pick.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var get = require('./get.cjs');
+var set = require('./set.cjs');
+
+/**
+ * pick value
+ */
+function pick(value, keys) {
+  return keys.reduce(function (picked, key) {
+    set.set(picked, key, get.get(value, key));
+    return picked;
+  }, {});
+}
+
+exports.pick = pick;

package/dist/utils/pick.d.ts

@@ -0,0 +1,5 @@
+/**
+ * pick value
+ */
+declare function pick<T extends object>(value: T, keys: PropertyKey[]): Partial<T>;
+export { pick };

package/dist/utils/pick.mjs

@@ -0,0 +1,14 @@
+import { get } from './get.mjs';
+import { set } from './set.mjs';
+
+/**
+ * pick value
+ */
+function pick(value, keys) {
+  return keys.reduce(function (picked, key) {
+    set(picked, key, get(value, key));
+    return picked;
+  }, {});
+}
+
+export { pick };

package/dist/utils/set.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var update = require('./update.cjs');
+
+/**
+ * Sets the value at the specified path of the given object. If any part of the path does not exist, it will be created.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to modify.
+ * @param {PropertyKey | PropertyKey[]} path - The path of the property to set.
+ * @param {unknown} value - The value to set.
+ * @returns {T} - The modified object.
+ *
+ * @example
+ * // Set a value in a nested object
+ * const obj = { a: { b: { c: 3 } } };
+ * set(obj, 'a.b.c', 4);
+ * console.log(obj.a.b.c); // 4
+ *
+ * @example
+ * // Set a value in an array
+ * const arr = [1, 2, 3];
+ * set(arr, 1, 4);
+ * console.log(arr[1]); // 4
+ *
+ * @example
+ * // Create non-existent path and set value
+ * const obj = {};
+ * set(obj, 'a.b.c', 4);
+ * console.log(obj); // { a: { b: { c: 4 } } }
+ */
+function set(obj, path, value) {
+  return update.update(obj, path, function () {
+    return value;
+  });
+}
+
+exports.set = set;

package/dist/utils/set.mjs

@@ -0,0 +1,36 @@
+import { update } from './update.mjs';
+
+/**
+ * Sets the value at the specified path of the given object. If any part of the path does not exist, it will be created.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to modify.
+ * @param {PropertyKey | PropertyKey[]} path - The path of the property to set.
+ * @param {unknown} value - The value to set.
+ * @returns {T} - The modified object.
+ *
+ * @example
+ * // Set a value in a nested object
+ * const obj = { a: { b: { c: 3 } } };
+ * set(obj, 'a.b.c', 4);
+ * console.log(obj.a.b.c); // 4
+ *
+ * @example
+ * // Set a value in an array
+ * const arr = [1, 2, 3];
+ * set(arr, 1, 4);
+ * console.log(arr[1]); // 4
+ *
+ * @example
+ * // Create non-existent path and set value
+ * const obj = {};
+ * set(obj, 'a.b.c', 4);
+ * console.log(obj); // { a: { b: { c: 4 } } }
+ */
+function set(obj, path, value) {
+  return update(obj, path, function () {
+    return value;
+  });
+}
+
+export { set };

package/dist/utils/to-array.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
 var isArray = require('../is/is-array.cjs');
+var isIterable = require('../is/is-iterable.cjs');
+var isString = require('../is/is-string.cjs');
 var isVoid = require('../is/is-void.cjs');
 
 /**
@@ -16,6 +18,11 @@ function toArray(value) {
   if (isArray.isArray(value)) {
     return value;
   }
+  // has iterator
+  // `string` to `[string]`
+  if (isIterable.isIterable(value) && !isString.isString(value)) {
+    return Array.from(value);
+  }
   return [value];
 }
 

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

@@ -1,4 +1,4 @@
-type ToArrayReturn<T> = T extends null ? unknown[] : T extends undefined ? unknown : T extends Array<infer E> ? E[] : T[];
+type ToArrayReturn<T> = T extends null ? never[] : T extends undefined ? never[] : T extends string ? T[] : T extends Array<infer R> ? R[] : T extends Iterable<infer I> ? I[] : T[];
 /**
  * @description
  * convert any type data to a array

package/dist/utils/to-array.mjs

@@ -1,4 +1,6 @@
 import { isArray } from '../is/is-array.mjs';
+import { isIterable } from '../is/is-iterable.mjs';
+import { isString } from '../is/is-string.mjs';
 import { isVoid } from '../is/is-void.mjs';
 
 /**
@@ -14,6 +16,11 @@ function toArray(value) {
   if (isArray(value)) {
     return value;
   }
+  // has iterator
+  // `string` to `[string]`
+  if (isIterable(value) && !isString(value)) {
+    return Array.from(value);
+  }
   return [value];
 }
 

package/dist/utils/to-key.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var _typeof = require('@babel/runtime/helpers/typeof');
+
+/**
+ * Converts `value` to a string key if it's not a string or symbol.
+ *
+ * @private
+ * @param {unknown} value The value to inspect.
+ * @returns {string|symbol} Returns the key.
+ */
+function toKey(value) {
+  var _value$valueOf;
+  if (typeof value === "string" || _typeof(value) === "symbol") {
+    return value;
+  }
+  if (Object.is(value === null || value === void 0 || (_value$valueOf = value.valueOf) === null || _value$valueOf === void 0 ? void 0 : _value$valueOf.call(value), -0)) {
+    return "-0";
+  }
+  return String(value);
+}
+
+exports.toKey = toKey;

package/dist/utils/to-key.mjs

@@ -0,0 +1,21 @@
+import _typeof from '@babel/runtime/helpers/typeof';
+
+/**
+ * Converts `value` to a string key if it's not a string or symbol.
+ *
+ * @private
+ * @param {unknown} value The value to inspect.
+ * @returns {string|symbol} Returns the key.
+ */
+function toKey(value) {
+  var _value$valueOf;
+  if (typeof value === "string" || _typeof(value) === "symbol") {
+    return value;
+  }
+  if (Object.is(value === null || value === void 0 || (_value$valueOf = value.valueOf) === null || _value$valueOf === void 0 ? void 0 : _value$valueOf.call(value), -0)) {
+    return "-0";
+  }
+  return String(value);
+}
+
+export { toKey };

package/dist/utils/to-paths.cjs

@@ -0,0 +1,85 @@
+'use strict';
+
+/**
+ * Converts a deep key string into an array of path segments.
+ *
+ * This function takes a string representing a deep key (e.g., 'a.b.c' or 'a[b][c]') and breaks it down into an array of strings, each representing a segment of the path.
+ *
+ * @param {string} deepKey - The deep key string to convert.
+ * @returns {string[]} An array of strings, each representing a segment of the path.
+ *
+ * Examples:
+ *
+ * toPath('a.b.c') // Returns ['a', 'b', 'c']
+ * toPath('a[b][c]') // Returns ['a', 'b', 'c']
+ * toPath('.a.b.c') // Returns ['', 'a', 'b', 'c']
+ * toPath('a["b.c"].d') // Returns ['a', 'b.c', 'd']
+ * toPath('') // Returns []
+ * toPath('.a[b].c.d[e]["f.g"].h') // Returns ['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h']
+ */
+function toPaths(deepKey) {
+  var result = [];
+  var length = deepKey.length;
+  if (length === 0) {
+    return result;
+  }
+  var index = 0;
+  var key = "";
+  var quoteChar = "";
+  var bracket = false;
+  // Leading dot
+  if (deepKey.charCodeAt(0) === 46) {
+    result.push("");
+    index++;
+  }
+  while (index < length) {
+    var _char = deepKey[index];
+    if (quoteChar) {
+      if (_char === "\\" && index + 1 < length) {
+        // Escape character
+        index++;
+        key += deepKey[index];
+      } else if (_char === quoteChar) {
+        // End of quote
+        quoteChar = "";
+      } else {
+        key += _char;
+      }
+    } else if (bracket) {
+      if (_char === '"' || _char === "'") {
+        // Start of quoted string inside brackets
+        quoteChar = _char;
+      } else if (_char === "]") {
+        // End of bracketed segment
+        bracket = false;
+        result.push(key);
+        key = "";
+      } else {
+        key += _char;
+      }
+    } else {
+      if (_char === "[") {
+        // Start of bracketed segment
+        bracket = true;
+        if (key) {
+          result.push(key);
+          key = "";
+        }
+      } else if (_char === ".") {
+        if (key) {
+          result.push(key);
+          key = "";
+        }
+      } else {
+        key += _char;
+      }
+    }
+    index++;
+  }
+  if (key) {
+    result.push(key);
+  }
+  return result;
+}
+
+exports.toPaths = toPaths;

package/dist/utils/to-paths.mjs

@@ -0,0 +1,83 @@
+/**
+ * Converts a deep key string into an array of path segments.
+ *
+ * This function takes a string representing a deep key (e.g., 'a.b.c' or 'a[b][c]') and breaks it down into an array of strings, each representing a segment of the path.
+ *
+ * @param {string} deepKey - The deep key string to convert.
+ * @returns {string[]} An array of strings, each representing a segment of the path.
+ *
+ * Examples:
+ *
+ * toPath('a.b.c') // Returns ['a', 'b', 'c']
+ * toPath('a[b][c]') // Returns ['a', 'b', 'c']
+ * toPath('.a.b.c') // Returns ['', 'a', 'b', 'c']
+ * toPath('a["b.c"].d') // Returns ['a', 'b.c', 'd']
+ * toPath('') // Returns []
+ * toPath('.a[b].c.d[e]["f.g"].h') // Returns ['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h']
+ */
+function toPaths(deepKey) {
+  var result = [];
+  var length = deepKey.length;
+  if (length === 0) {
+    return result;
+  }
+  var index = 0;
+  var key = "";
+  var quoteChar = "";
+  var bracket = false;
+  // Leading dot
+  if (deepKey.charCodeAt(0) === 46) {
+    result.push("");
+    index++;
+  }
+  while (index < length) {
+    var _char = deepKey[index];
+    if (quoteChar) {
+      if (_char === "\\" && index + 1 < length) {
+        // Escape character
+        index++;
+        key += deepKey[index];
+      } else if (_char === quoteChar) {
+        // End of quote
+        quoteChar = "";
+      } else {
+        key += _char;
+      }
+    } else if (bracket) {
+      if (_char === '"' || _char === "'") {
+        // Start of quoted string inside brackets
+        quoteChar = _char;
+      } else if (_char === "]") {
+        // End of bracketed segment
+        bracket = false;
+        result.push(key);
+        key = "";
+      } else {
+        key += _char;
+      }
+    } else {
+      if (_char === "[") {
+        // Start of bracketed segment
+        bracket = true;
+        if (key) {
+          result.push(key);
+          key = "";
+        }
+      } else if (_char === ".") {
+        if (key) {
+          result.push(key);
+          key = "";
+        }
+      } else {
+        key += _char;
+      }
+    }
+    index++;
+  }
+  if (key) {
+    result.push(key);
+  }
+  return result;
+}
+
+export { toPaths };

package/dist/utils/update.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var isKey = require('../is/is-key.cjs');
+var isObject = require('../is/is-object.cjs');
+var isUndefined = require('../is/is-undefined.cjs');
+var isVoid = require('../is/is-void.cjs');
+var isIndex = require('./is-index.cjs');
+var toKey = require('./to-key.cjs');
+var toPaths = require('./to-paths.cjs');
+
+/**
+ * Updates the value at the specified path of the given object using an updater function.
+ * If any part of the path does not exist, it will be created.
+ *
+ * @template T - The type of the object.
+ * @param {T} target - The object to modify.
+ * @param {PropertyKey | PropertyKey[]} path - The path of the property to update.
+ * @param {(value: unknown) => unknown} updater - The function to produce the updated value.
+ * @returns {T} - The modified object.
+ */
+function update(target, path, updater) {
+  if (isVoid.isVoid(target)) {
+    return target;
+  }
+  var _paths = isKey.isKey(path, target) ? [path] : Array.isArray(path) ? path : typeof path === "string" ? toPaths.toPaths(path) : [path];
+  var current = target;
+  for (var i = 0; i < _paths.length && current != null; i++) {
+    var key = toKey.toKey(_paths[i]);
+    var _newValue = void 0;
+    if (i === _paths.length - 1) {
+      // @ts-expect-error get value of key
+      _newValue = updater(current[key]);
+    } else {
+      // @ts-expect-error get value of key
+      var _value = current[key];
+      _newValue = !isUndefined.isUndefined(_value) ? _value : isObject.isObject(_value) ? _value : isIndex.isIndex(_paths[i + 1]) ? [] : {};
+    }
+    Object.assign(current, _defineProperty({}, key, _newValue));
+    // @ts-expect-error get value of key
+    current = current[key];
+  }
+  return target;
+}
+
+exports.update = update;

package/dist/utils/update.mjs

@@ -0,0 +1,44 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { isKey } from '../is/is-key.mjs';
+import { isObject } from '../is/is-object.mjs';
+import { isUndefined } from '../is/is-undefined.mjs';
+import { isVoid } from '../is/is-void.mjs';
+import { isIndex } from './is-index.mjs';
+import { toKey } from './to-key.mjs';
+import { toPaths } from './to-paths.mjs';
+
+/**
+ * Updates the value at the specified path of the given object using an updater function.
+ * If any part of the path does not exist, it will be created.
+ *
+ * @template T - The type of the object.
+ * @param {T} target - The object to modify.
+ * @param {PropertyKey | PropertyKey[]} path - The path of the property to update.
+ * @param {(value: unknown) => unknown} updater - The function to produce the updated value.
+ * @returns {T} - The modified object.
+ */
+function update(target, path, updater) {
+  if (isVoid(target)) {
+    return target;
+  }
+  var _paths = isKey(path, target) ? [path] : Array.isArray(path) ? path : typeof path === "string" ? toPaths(path) : [path];
+  var current = target;
+  for (var i = 0; i < _paths.length && current != null; i++) {
+    var key = toKey(_paths[i]);
+    var _newValue = void 0;
+    if (i === _paths.length - 1) {
+      // @ts-expect-error get value of key
+      _newValue = updater(current[key]);
+    } else {
+      // @ts-expect-error get value of key
+      var _value = current[key];
+      _newValue = !isUndefined(_value) ? _value : isObject(_value) ? _value : isIndex(_paths[i + 1]) ? [] : {};
+    }
+    Object.assign(current, _defineProperty({}, key, _newValue));
+    // @ts-expect-error get value of key
+    current = current[key];
+  }
+  return target;
+}
+
+export { update };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiszlab/relax",
-  "version": "2.0.4",
+  "version": "2.0.6-beta.0",
   "description": "react utils collection",
   "exports": {
     ".": {
@@ -19,31 +19,38 @@
     },
     "./types": "./dist/types/index.d.ts"
   },
+  "scripts": {
+    "dev": "rollup -c -w",
+    "build": "rollup -c",
+    "clean:build": "rm -rf dist",
+    "test": "jest",
+    "test:coverage": "jest --coverage"
+  },
   "dependencies": {
-    "@babel/runtime": "^7.27.0",
+    "@babel/runtime": "^7.27.1",
     "react-is": "^19.1.0",
     "rxjs": "^7.8.2"
   },
   "devDependencies": {
-    "@babel/core": "^7.26.10",
-    "@babel/plugin-transform-runtime": "^7.26.10",
-    "@babel/preset-env": "^7.26.9",
-    "@babel/preset-react": "^7.26.3",
-    "@babel/preset-typescript": "^7.27.0",
+    "@babel/core": "^7.27.1",
+    "@babel/plugin-transform-runtime": "^7.27.1",
+    "@babel/preset-env": "^7.27.2",
+    "@babel/preset-react": "^7.27.1",
+    "@babel/preset-typescript": "^7.27.1",
     "@jest/globals": "^29.7.0",
     "@rollup/plugin-babel": "^6.0.4",
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-typescript": "^12.1.2",
     "@testing-library/react": "^16.3.0",
     "@types/babel__core": "^7.20.5",
-    "@types/react": "^19.1.2",
-    "@types/react-dom": "^19.1.2",
+    "@types/react": "^19.1.3",
+    "@types/react-dom": "^19.1.3",
     "@types/react-is": "^19.0.0",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
-    "rollup": "^4.40.0",
+    "rollup": "^4.40.2",
     "typescript": "5.8.3"
   },
   "peerDependencies": {
@@ -63,12 +70,5 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "homepage": "https://aisz.dev/hooks",
-  "scripts": {
-    "dev": "rollup -c -w",
-    "build": "rollup -c",
-    "clean:build": "rm -rf dist",
-    "test": "jest",
-    "test:coverage": "jest --coverage"
-  }
-}
+  "homepage": "https://aisz.dev/hooks"
+}