ut2 1.14.0 → 1.16.0

package/README.md

@@ -64,7 +64,6 @@ const debounced = debounce(() => {
   - [chunk](https://caijf.github.io/ut2/module-Array.html#.chunk) - 拆分成多个 `size` 长度的区块。
   - [compact](https://caijf.github.io/ut2/module-Array.html#.compact) - 剔除假值元素。
   - [difference](https://caijf.github.io/ut2/module-Array.html#.difference) - 排除部分值。
-  - [formPairs](https://caijf.github.io/ut2/module-Array.html#.fromPairs) - 将键值对转为对象。
   - [intersection](https://caijf.github.io/ut2/module-Array.html#.intersection) - 交集去重。
   - [move](https://caijf.github.io/ut2/module-Array.html#.move) - 数组元素移动。
   - [nth](https://caijf.github.io/ut2/module-Array.html#.nth) - 获取第 `n` 个元素。
@@ -155,14 +154,20 @@ const debounced = debounce(() => {
   - [allKeys](https://caijf.github.io/ut2/module-Object.html#.allKeys) - 对象自身的可枚举属性（包含 `Symbol` 属性）。
   - [allKeysIn](https://caijf.github.io/ut2/module-Object.html#.allKeysIn) - 对象自身及继承的可枚举属性（包含 `Symbol` 属性）。
   - [findKey](https://caijf.github.io/ut2/module-Object.html#.findKey) - 查找对象的键。
+  - [fromPathPairs](https://caijf.github.io/ut2/module-Object.html#.fromPathPairs) - 将属性路径/值对的数组转为对象。
+  - [get](https://caijf.github.io/ut2/module-Object.html#.get) - 获取对象路径的值。
   - [invert](https://caijf.github.io/ut2/module-Object.html#.invert) - 对象自身的可枚举属性（包含 `Symbol` 属性）和值反转。
   - [keys](https://caijf.github.io/ut2/module-Object.html#.keys) - 对象自身的可枚举属性（不包含 `Symbol` 属性）。
   - [keysIn](https://caijf.github.io/ut2/module-Object.html#.keysIn) - 对象自身及继承的可枚举属性（不包含 `Symbol` 属性）。
   - [merge](https://caijf.github.io/ut2/module-Object.html#.merge) - 递归对象自身的可枚举属性（包含 `Symbol` 属性）或数组进行合并。
+  - [mergeObject](https://caijf.github.io/ut2/module-Object.html#.merge) - 递归对象自身的可枚举属性（包含 `Symbol` 属性）进行合并，支持多个目标对象参数。
   - [omit](https://caijf.github.io/ut2/module-Object.html#.omit) - 排除部分属性。
   - [omitBy](https://caijf.github.io/ut2/module-Object.html#.omitBy) - 根据方法，排除部分属性。
+  - [pathPairs](https://caijf.github.io/ut2/module-Object.html#.pathPairs) - 将对象转为属性路径/值对的数组。
   - [pick](https://caijf.github.io/ut2/module-Object.html#.pick) - 选择部分属性。
   - [pickBy](https://caijf.github.io/ut2/module-Object.html#.pickBy) - 根据方法，选择部分属性。
+  - [set](https://caijf.github.io/ut2/module-Object.html#.set) - 设置对象属性路径值。
+  - [unset](https://caijf.github.io/ut2/module-Object.html#.unset) - 删除对象路径的属性。
 - [String](https://caijf.github.io/ut2/module-String.html) 字符串
   - [camelCase](https://caijf.github.io/ut2/module-String.html#.camelCase) - 驼峰小写。
   - [capitalize](https://caijf.github.io/ut2/module-String.html#.capitalize) - 首字母大写，其余小写。
@@ -200,6 +205,7 @@ const debounced = debounce(() => {
   - [toInteger](https://caijf.github.io/ut2/module-Util.html#.toInteger) - 转为整数。
   - [toLength](https://caijf.github.io/ut2/module-Util.html#.toLength) - 转为数组长度整数。
   - [toNumber](https://caijf.github.io/ut2/module-Util.html#.toNumber) - 转为数字。
+  - [toPath](https://caijf.github.io/ut2/module-Util.html#.toPath) - 转为属性路径数组。
   - [toSafeInteger](https://caijf.github.io/ut2/module-Util.html#.toSafeInteger) - 转为安全整数。
   - [toString](https://caijf.github.io/ut2/module-Util.html#.toString) - 转为字符串。
   - [tryit](https://caijf.github.io/ut2/module-Util.html#.tryit) - 包装函数为错误优先函数。

package/dist/ut2.js

@@ -606,7 +606,7 @@
         return value == null || value !== value ? defaultValue : value;
     };
 
-    var VERSION = "1.14.0";
+    var VERSION = "1.16.0";
     var isBrowser = typeof window !== stringUndefined && isObjectLike(window) && typeof document !== stringUndefined && isObjectLike(document) && window.document === document;
     var supportedArgumentsType = getTag((function () { return arguments; })()) === argumentsTag;
     var FUNC_ERROR_TEXT = 'Expected a function';
@@ -1562,6 +1562,99 @@
         return key;
     };
 
+    function isIndex(value) {
+        var type = typeof value;
+        if (type === 'string' && value) {
+            value = toNumber(value);
+        }
+        return isLength(value);
+    }
+
+    var reEscapeChar = /\\(\\)?/g;
+    var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+    function stringToPath(value) {
+        var result = [];
+        if (value.charCodeAt(0) === 46) {
+            result.push('');
+        }
+        value.replace(rePropName, function (match, number, quote, subString) {
+            result.push(quote ? subString.replace(reEscapeChar, '$1') : number || match);
+            return match;
+        });
+        return result;
+    }
+
+    function toKey(value) {
+        return isSymbol(value) ? value : toString(value);
+    }
+    function toPath(value, object) {
+        if (isArray(value)) {
+            return value.map(toKey);
+        }
+        if (isSymbol(value) || (typeof value === 'string' && isObject(object) && value in object)) {
+            return [value];
+        }
+        return stringToPath(toString(value));
+    }
+
+    function set(object, path, value, customizer) {
+        if (!isObject(object)) {
+            return object;
+        }
+        var paths = toPath(path, object);
+        var length = paths.length;
+        var lastIndex = length - 1;
+        var index = -1;
+        var nested = object;
+        while (++index < length) {
+            var key = paths[index];
+            if (index === lastIndex) {
+                nested[key] = value;
+            }
+            else {
+                var objValue = nested[key];
+                var newValue = customizer ? customizer(objValue, key, nested) : nativeUndefined;
+                if (!isObject(newValue)) {
+                    newValue = isObject(objValue) ? objValue : isIndex(paths[index + 1]) ? [] : {};
+                }
+                nested[key] = newValue;
+                nested = nested[key];
+            }
+        }
+        return object;
+    }
+
+    function fromPathPairs(value, customizer) {
+        var valueIsArray = isArray(value);
+        var firstPairPath = valueIsArray && isArray(value[0]) && isArray(value[0][0]) ? value[0][0] : [];
+        var firstNode = customizer ? customizer(nativeUndefined, firstPairPath[0], nativeUndefined) : nativeUndefined;
+        var result = isObject(firstNode) ? firstNode : isIndex(firstPairPath[0]) ? [] : {};
+        var length = valueIsArray ? value.length : 0;
+        var index = -1;
+        while (++index < length) {
+            var pathPair = value[index];
+            if (isArray(pathPair)) {
+                var _a = __read(pathPair, 2), paths = _a[0], val = _a[1];
+                set(result, paths, val, customizer);
+            }
+        }
+        return result;
+    }
+
+    function baseGet(object, key) {
+        var paths = toPath(key, object);
+        var length = paths.length;
+        var index = 0;
+        while (!isNil(object) && index < length) {
+            object = object[paths[index++]];
+        }
+        return index && index === length ? object : nativeUndefined;
+    }
+    function get(object, key, defaultValue) {
+        var result = isNil(object) ? nativeUndefined : baseGet(object, key);
+        return isUndefined(result) ? defaultValue : result;
+    }
+
     function invert(object, predicate) {
         if (predicate === void 0) { predicate = stubTrue; }
         var _keys = allKeys(object);
@@ -1639,7 +1732,20 @@
         if (getKeys === void 0) { getKeys = allKeys; }
         return baseMerge(object, source, getKeys, customizer);
     }
-    merge.NOT_MERGE_ARRAYS = function (objValue, srcValue) { return (isArray(srcValue) ? srcValue : undefined); };
+    merge.NOT_MERGE_ARRAYS = function (objValue, srcValue) { return (isArray(srcValue) ? srcValue : nativeUndefined); };
+
+    var mergeObject = function (object, source) {
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        if (args.length > 0) {
+            var _a = __read(args), arg1 = _a[0], restArgs = _a.slice(1);
+            var obj = merge(object, source, merge.NOT_MERGE_ARRAYS);
+            return mergeObject.apply(void 0, __spreadArray([obj, arg1], __read(restArgs), false));
+        }
+        return merge(object, source, merge.NOT_MERGE_ARRAYS);
+    };
 
     function castArray(value) {
         if (!arguments.length) {
@@ -1693,6 +1799,35 @@
         return result;
     }
 
+    function basePathPairs(object, parentPath) {
+        if (parentPath === void 0) { parentPath = []; }
+        var result = [];
+        if (isObjectLike(object)) {
+            forEach(object, function (v, k) {
+                var currentPath = parentPath.concat([k]);
+                if (isObjectLike(v)) {
+                    result.push.apply(result, __spreadArray([], __read(basePathPairs(v, currentPath)), false));
+                }
+                else {
+                    result.push([currentPath, v]);
+                }
+            });
+        }
+        return result;
+    }
+    function pathPairs(object) {
+        return basePathPairs(object);
+    }
+
+    function unset(object, path) {
+        if (isNil(object)) {
+            return true;
+        }
+        var paths = toPath(path, object);
+        var parent = paths.length < 2 ? object : get(object, paths.slice(0, -1));
+        return isNil(parent) ? true : delete parent[nth(paths, -1)];
+    }
+
     var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
     function words(string, pattern) {
         if (pattern === void 0) { pattern = reAsciiWord; }
@@ -1834,7 +1969,7 @@
             if (shouldGuard && !shouldGuard(err)) {
                 throw err;
             }
-            return undefined;
+            return nativeUndefined;
         };
         try {
             var result = fn();
@@ -2029,6 +2164,8 @@
     exports.forEach = forEach;
     exports.forEachRight = forEachRight;
     exports.fromPairs = fromPairs;
+    exports.fromPathPairs = fromPathPairs;
+    exports.get = get;
     exports.groupBy = groupBy;
     exports.gt = gt;
     exports.gte = gte;
@@ -2090,6 +2227,7 @@
     exports.map = map;
     exports.max = max;
     exports.merge = merge;
+    exports.mergeObject = mergeObject;
     exports.min = min;
     exports.move = move;
     exports.negate = negate;
@@ -2103,6 +2241,7 @@
     exports.partial = partial;
     exports.partition = partition;
     exports.pascalCase = pascalCase;
+    exports.pathPairs = pathPairs;
     exports.pick = pick;
     exports.pickBy = pickBy;
     exports.random = random;
@@ -2113,6 +2252,7 @@
     exports.retry = retry;
     exports.root = root;
     exports.round = round;
+    exports.set = set;
     exports.shuffle = shuffle;
     exports.sleep = sleep;
     exports.snakeCase = snakeCase;
@@ -2123,6 +2263,7 @@
     exports.toInteger = toInteger;
     exports.toLength = toLength;
     exports.toNumber = toNumber;
+    exports.toPath = toPath;
     exports.toSafeInteger = toSafeInteger;
     exports.toString = toString;
     exports.tryit = tryit;
@@ -2130,6 +2271,7 @@
     exports.union = union;
     exports.uniq = uniq;
     exports.uniqueId = uniqueId;
+    exports.unset = unset;
     exports.unzip = unzip;
     exports.upperCase = upperCase;
     exports.upperFirst = upperFirst;