ut2 1.6.0 → 1.7.1

package/lib/groupBy.js

@@ -1,22 +1,22 @@
 'use strict';
 
+var forEach = require('./forEach.js');
+var identity = require('./identity.js');
 var createIteratee = require('./internals/createIteratee.js');
-var isArray = require('./isArray.js');
 
 function groupBy(collection, iteratee) {
+    if (iteratee === void 0) { iteratee = identity; }
     var result = {};
-    if (isArray(collection)) {
-        var internalIteratee_1 = createIteratee(iteratee);
-        collection.forEach(function (item) {
-            var key = internalIteratee_1(item);
-            if (key in result) {
-                result[key].push(item);
-            }
-            else {
-                result[key] = [item];
-            }
-        });
-    }
+    var internalIteratee = createIteratee(iteratee);
+    forEach(collection, function (item) {
+        var key = internalIteratee(item);
+        if (key in result) {
+            result[key].push(item);
+        }
+        else {
+            result[key] = [item];
+        }
+    });
     return result;
 }
 

package/lib/index.js

@@ -13,10 +13,19 @@ var unzip = require('./unzip.js');
 var xor = require('./xor.js');
 var zip = require('./zip.js');
 var countBy = require('./countBy.js');
+var every = require('./every.js');
+var find = require('./find.js');
+var filter = require('./filter.js');
+var forEach = require('./forEach.js');
+var forEachRight = require('./forEachRight.js');
 var groupBy = require('./groupBy.js');
 var keyBy = require('./keyBy.js');
 var orderBy = require('./orderBy.js');
+var map = require('./map.js');
 var partition = require('./partition.js');
+var reduce = require('./reduce.js');
+var reduceRight = require('./reduceRight.js');
+var some = require('./some.js');
 var after = require('./after.js');
 var before = require('./before.js');
 var debounce = require('./debounce.js');
@@ -73,6 +82,7 @@ var random = require('./random.js');
 var randomInt = require('./randomInt.js');
 var allKeys = require('./allKeys.js');
 var allKeysIn = require('./allKeysIn.js');
+var keys = require('./keys.js');
 var keysIn = require('./keysIn.js');
 var merge = require('./merge.js');
 var omit = require('./omit.js');
@@ -132,10 +142,19 @@ exports.unzip = unzip;
 exports.xor = xor;
 exports.zip = zip;
 exports.countBy = countBy;
+exports.every = every;
+exports.find = find;
+exports.filter = filter;
+exports.forEach = forEach;
+exports.forEachRight = forEachRight;
 exports.groupBy = groupBy;
 exports.keyBy = keyBy;
 exports.orderBy = orderBy;
+exports.map = map;
 exports.partition = partition;
+exports.reduce = reduce;
+exports.reduceRight = reduceRight;
+exports.some = some;
 exports.after = after;
 exports.before = before;
 exports.debounce = debounce;
@@ -192,6 +211,7 @@ exports.random = random;
 exports.randomInt = randomInt;
 exports.allKeys = allKeys;
 exports.allKeysIn = allKeysIn;
+exports.keys = keys;
 exports.keysIn = keysIn;
 exports.merge = merge;
 exports.omit = omit;

package/lib/internals/createExtremum.js

@@ -2,7 +2,6 @@
 
 var isArray = require('../isArray.js');
 var isSymbol = require('../isSymbol.js');
-var isUndefined = require('../isUndefined.js');
 var createIteratee = require('./createIteratee.js');
 
 function createExtremum(array, comparator, iteratee) {
@@ -10,23 +9,14 @@ function createExtremum(array, comparator, iteratee) {
         return;
     }
     var result, computed;
-    if (isUndefined(iteratee)) {
-        array.forEach(function (value) {
-            if (value != null && (result === undefined ? value === value && !isSymbol(value) : comparator(value, result))) {
-                result = value;
-            }
-        });
-    }
-    else {
-        var internalIteratee_1 = createIteratee(iteratee);
-        array.forEach(function (value) {
-            var current = internalIteratee_1(value);
-            if (current != null && (computed === undefined ? current === current && !isSymbol(current) : comparator(current, computed))) {
-                computed = current;
-                result = value;
-            }
-        });
-    }
+    var internalIteratee = createIteratee(iteratee);
+    array.forEach(function (value) {
+        var current = internalIteratee(value);
+        if (current != null && (computed === undefined ? current === current && !isSymbol(current) : comparator(current, computed))) {
+            computed = current;
+            result = value;
+        }
+    });
     return result;
 }
 

package/lib/internals/createForEach.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var identity = require('../identity.js');
+var isArrayLike = require('../isArrayLike.js');
+var keys = require('../keys.js');
+
+function createForEach(dir) {
+    function forEach(collection, iteratee) {
+        if (iteratee === void 0) { iteratee = identity; }
+        var _keys = !isArrayLike(collection) && keys(collection);
+        var len = (_keys || collection).length;
+        var i = dir > 0 ? 0 : len - 1;
+        while (i >= 0 && i < len) {
+            var currentKey = _keys ? _keys[i] : i;
+            if (iteratee(collection[currentKey], currentKey, collection) === false) {
+                break;
+            }
+            i += dir;
+        }
+        return collection;
+    }
+    return forEach;
+}
+
+module.exports = createForEach;

package/lib/internals/createReduce.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var identity = require('../identity.js');
+var isArrayLike = require('../isArrayLike.js');
+var keys = require('../keys.js');
+
+function createReduce(dir) {
+    function reducer(collection, iteratee, memo, initial) {
+        var _keys = !isArrayLike(collection) && keys(collection);
+        var len = (_keys || collection).length;
+        var i = dir > 0 ? 0 : len - 1;
+        if (!initial && len > 0) {
+            memo = collection[_keys ? _keys[i] : i];
+            i += dir;
+        }
+        while (i >= 0 && i < len) {
+            var currentKey = _keys ? _keys[i] : i;
+            memo = iteratee(memo, collection[currentKey], currentKey, collection);
+            i += dir;
+        }
+        return memo;
+    }
+    function reduce(collection, iteratee, initialValue) {
+        if (iteratee === void 0) { iteratee = identity; }
+        var initial = arguments.length >= 3;
+        return reducer(collection, iteratee, initialValue, initial);
+    }
+    return reduce;
+}
+
+module.exports = createReduce;

package/lib/internals/helpers.js

@@ -3,7 +3,7 @@
 var getTag = require('./getTag.js');
 var native = require('./native.js');
 
-exports.VERSION = "1.6.0";
+exports.VERSION = "1.7.1";
 exports.supportedArgumentsType = getTag((function () { return arguments; })()) === native.argumentsTag;
 exports.FUNC_ERROR_TEXT = 'Expected a function';
 function toSource(func) {

package/lib/intersection.js

@@ -1,10 +1,12 @@
 'use strict';
 
 var eq = require('./eq.js');
+var identity = require('./identity.js');
 var createIteratee = require('./internals/createIteratee.js');
 var isArray = require('./isArray.js');
 
 function intersection(array, other, iteratee, strictCheck) {
+    if (iteratee === void 0) { iteratee = identity; }
     if (strictCheck === void 0) { strictCheck = false; }
     if (!isArray(array) || !isArray(other)) {
         return [];

package/lib/isEmpty.js

@@ -1,7 +1,7 @@
 'use strict';
 
 var getTag = require('./internals/getTag.js');
-var keys = require('./internals/keys.js');
+var specialKeys = require('./internals/specialKeys.js');
 var native = require('./internals/native.js');
 var isArrayLike = require('./isArrayLike.js');
 var isNil = require('./isNil.js');
@@ -16,7 +16,7 @@ function isEmpty(value) {
         return !value.size;
     }
     if (isObjectLike(value)) {
-        return !keys(value).length;
+        return !specialKeys(value).length;
     }
     if (isArrayLike(value)) {
         return !value.length;

package/lib/keyBy.js

@@ -1,17 +1,17 @@
 'use strict';
 
+var forEach = require('./forEach.js');
+var identity = require('./identity.js');
 var createIteratee = require('./internals/createIteratee.js');
-var isArray = require('./isArray.js');
 
 function keyBy(collection, iteratee) {
+    if (iteratee === void 0) { iteratee = identity; }
     var result = {};
-    if (isArray(collection)) {
-        var internalIteratee_1 = createIteratee(iteratee);
-        collection.forEach(function (item) {
-            var key = internalIteratee_1(item);
-            result[key] = item;
-        });
-    }
+    var internalIteratee = createIteratee(iteratee);
+    forEach(collection, function (item) {
+        var key = internalIteratee(item);
+        result[key] = item;
+    });
     return result;
 }
 

package/lib/keys.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var native = require('./internals/native.js');
+var isObject = require('./isObject.js');
+
+function keys(object) {
+    if (!isObject(object)) {
+        return [];
+    }
+    return native.objectKeys(object);
+}
+
+module.exports = keys;

package/lib/map.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var forEach = require('./forEach.js');
+var identity = require('./identity.js');
+
+function map(collection, iteratee) {
+    if (iteratee === void 0) { iteratee = identity; }
+    var result = [];
+    forEach(collection, function (item, index, arr) {
+        result.push(iteratee(item, index, arr));
+    });
+    return result;
+}
+
+module.exports = map;

package/lib/merge.js

@@ -1,18 +1,18 @@
 'use strict';
 
-var allKeysIn = require('./allKeysIn.js');
+var keysIn = require('./keysIn.js');
 var isArray = require('./isArray.js');
 var isObject = require('./isObject.js');
 var isObjectLike = require('./isObjectLike.js');
 var isPlainObject = require('./isPlainObject.js');
 
-function baseMerge(object, source, customizer, stack) {
+function baseMerge(object, source, getKeys, customizer, stack) {
     if (stack === void 0) { stack = new WeakMap(); }
     var obj = Object(object);
     if (!isObject(source) || obj === source) {
         return obj;
     }
-    var keys = allKeysIn(source);
+    var keys = getKeys(source);
     var hasCustomizer = typeof customizer === 'function';
     keys.forEach(function (key) {
         var srcValue = source[key];
@@ -38,7 +38,7 @@ function baseMerge(object, source, customizer, stack) {
                     }
                 }
                 if (newObjValue) {
-                    obj[key] = baseMerge(newObjValue, srcValue, customizer, stack);
+                    obj[key] = baseMerge(newObjValue, srcValue, getKeys, customizer, stack);
                 }
                 else if (srcValue !== undefined || !(key in obj)) {
                     obj[key] = srcValue;
@@ -48,8 +48,9 @@ function baseMerge(object, source, customizer, stack) {
     });
     return obj;
 }
-function merge(object, source, customizer) {
-    return baseMerge(object, source, customizer);
+function merge(object, source, customizer, getKeys) {
+    if (getKeys === void 0) { getKeys = keysIn; }
+    return baseMerge(object, source, getKeys, customizer);
 }
 
 module.exports = merge;

package/lib/orderBy.js

@@ -4,21 +4,21 @@ var identity = require('./identity.js');
 var createIteratee = require('./internals/createIteratee.js');
 var compare = require('./internals/compare.js');
 var isArray = require('./isArray.js');
+var forEach = require('./forEach.js');
 
 function orderBy(collection, iteratees, orders) {
     var result = [];
     iteratees = (isArray(iteratees) ? iteratees : iteratees !== undefined ? [iteratees] : [identity]);
     orders = (isArray(orders) ? orders : orders !== undefined ? [orders] : []);
-    if (isArray(collection)) {
-        collection.forEach(function (item, index) {
-            var criteria = iteratees.map(function (iteratee) { return createIteratee(iteratee)(item); });
-            result.push({
-                criteria: criteria,
-                index: index,
-                value: item
-            });
+    var index = -1;
+    forEach(collection, function (item) {
+        var criteria = iteratees.map(function (iteratee) { return createIteratee(iteratee)(item); });
+        result.push({
+            criteria: criteria,
+            index: ++index,
+            value: item
         });
-    }
+    });
     return result.sort(function (a, b) { return compare.compareMultiple(a, b, orders); }).map(function (item) { return item.value; });
 }
 

package/lib/partition.js

@@ -1,16 +1,16 @@
 'use strict';
 
+var forEach = require('./forEach.js');
+var identity = require('./identity.js');
 var createIteratee = require('./internals/createIteratee.js');
-var isArray = require('./isArray.js');
 
 function partition(collection, predicate) {
+    if (predicate === void 0) { predicate = identity; }
     var result = [[], []];
-    if (isArray(collection)) {
-        var internalIteratee_1 = createIteratee(predicate);
-        collection.forEach(function (item) {
-            result[internalIteratee_1(item) ? 0 : 1].push(item);
-        });
-    }
+    var internalIteratee = createIteratee(predicate);
+    forEach(collection, function (item) {
+        result[internalIteratee(item) ? 0 : 1].push(item);
+    });
     return result;
 }
 

package/lib/reduce.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var createReduce = require('./internals/createReduce.js');
+
+var reduce = createReduce(1);
+var reduce$1 = reduce;
+
+module.exports = reduce$1;

package/lib/reduceRight.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var createReduce = require('./internals/createReduce.js');
+
+var reduceRight = createReduce(-1);
+var reduceRight$1 = reduceRight;
+
+module.exports = reduceRight$1;

package/lib/some.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var forEach = require('./forEach.js');
+var identity = require('./identity.js');
+
+function some(collection, predicate) {
+    if (predicate === void 0) { predicate = identity; }
+    var result = false;
+    forEach(collection, function (item, index, arr) {
+        if (predicate(item, index, arr)) {
+            result = true;
+            return false;
+        }
+    });
+    return result;
+}
+
+module.exports = some;

package/lib/uniq.js

@@ -3,25 +3,17 @@
 var eq = require('./eq.js');
 var createIteratee = require('./internals/createIteratee.js');
 var isArray = require('./isArray.js');
-var isUndefined = require('./isUndefined.js');
 
 function uniq(array, iteratee, strickCheck) {
     if (strickCheck === void 0) { strickCheck = false; }
     if (!isArray(array)) {
         return [];
     }
-    if (isUndefined(iteratee)) {
-        return array.filter(function (value, index, arr) {
-            return arr.findIndex(function (item) { return eq(item, value, strickCheck); }) === index;
-        });
-    }
-    else {
-        var internalIteratee_1 = createIteratee(iteratee);
-        return array.filter(function (value, index, arr) {
-            var current = internalIteratee_1(value);
-            return arr.findIndex(function (item) { return eq(internalIteratee_1(item), current, strickCheck); }) === index;
-        });
-    }
+    var internalIteratee = createIteratee(iteratee);
+    return array.filter(function (value, index, arr) {
+        var current = internalIteratee(value);
+        return arr.findIndex(function (item) { return eq(internalIteratee(item), current, strickCheck); }) === index;
+    });
 }
 
 module.exports = uniq;

package/lib/xor.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var difference = require('./difference.js');
+var identity = require('./identity.js');
 var createIteratee = require('./internals/createIteratee.js');
 var intersection = require('./intersection.js');
 var isArray = require('./isArray.js');
@@ -9,6 +10,7 @@ var uniq = require('./uniq.js');
 
 function xor(array, other, iteratee, strickCheck) {
     if (other === void 0) { other = []; }
+    if (iteratee === void 0) { iteratee = identity; }
     if (strickCheck === void 0) { strickCheck = false; }
     if (!isArray(array) && !isArray(other)) {
         return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ut2",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "author": "caijf",
   "license": "MIT",
   "main": "lib/index.js",

package/types/allKeys.d.ts

@@ -7,7 +7,7 @@
  * @alias module:Object.allKeys
  * @since 1.1.0
  * @param {Object} object 要查询的对象。
- * @returns {Array<string|symbol>} 对象自身的可枚举属性名(包含 `Symbol` 属性)数组。
+ * @returns {Array<string|symbol>} 对象自身的可枚举属性(包含 `Symbol` 属性)。
  * @example
  *
  * function Foo(){

package/types/allKeysIn.d.ts

@@ -7,7 +7,7 @@
  * @alias module:Object.allKeysIn
  * @since 1.1.0
  * @param {Object} object 要查询的对象。
- * @returns {Array<string|symbol>} 对象自身及继承的可枚举属性名(包含 `Symbol` 属性)数组。
+ * @returns {Array<string|symbol>} 对象自身及继承的可枚举属性(包含 `Symbol` 属性)。
  * @example
  *
  * function Foo(){

package/types/conformsTo.d.ts

@@ -1,3 +1,4 @@
+import { WithNullable } from './internals/types';
 declare function conformsTo<T extends object, K extends keyof T>(object: T, source: Record<K, (value: T[K]) => any>): boolean;
-declare function conformsTo<T extends object | null | undefined>(object: T, source: Record<string | symbol, (value: any) => any>): boolean;
+declare function conformsTo<T extends WithNullable<object>>(object: T, source: Record<string | symbol, (value: any) => any>): boolean;
 export default conformsTo;

package/types/countBy.d.ts

@@ -1,25 +1,4 @@
-/**
- * 创建一个组成对象， `key` 是经过 `iteratee` 执行处理 `collection` 中每个元素后返回的结果，每个 `key` 对应的值是 `iteratee` 返回该 `key` 的次数。
- *
- * `iteratee` 调用时会传入 1 个参数 `value` 。
- *
- * @static
- * @alias module:Collection.countBy
- * @since 1.0.0
- * @param {Array} collection 一个用来迭代的集合。
- * @param {Function | string} [iteratee] 迭代函数，用来转换键。
- * @returns {Object} 组成集合对象。
- * @example
- *
- * countBy([6, 4, 6]); // {'6': 2, '4': 1}
- *
- * countBy([6.1, 4.2, 6.3], Math.floor); // {'6': 2, '4': 1}
- *
- * countBy([{n: 6.1}, {n: 4.2}, {n: 6.3}], item=>Math.floor(item.n)); // {'6': 2, '4': 1}
- *
- * // 迭代函数可以直接写入属性。
- * countBy(['one', 'two', 'three'], 'length'); // {'3': 2, '5': 1}
- *
- */
-declare function countBy<T, F extends (value: T) => any, K extends keyof T>(collection: T[], iteratee?: F | K): Record<string | number | symbol, number>;
+import { CollectionList, CollectionObject, IterateeParam } from './internals/types';
+declare function countBy<T>(collection: CollectionList<T>, iteratee?: IterateeParam<T>): Record<string, number>;
+declare function countBy<T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: IterateeParam<V>): Record<string, number>;
 export default countBy;

package/types/difference.d.ts

@@ -1,3 +1,4 @@
+import { IterateeParam } from './internals/types';
 /**
  * 创建一个 `array` 排除 `values` 值的新数组。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
  *
@@ -10,7 +11,7 @@
  * @since 1.0.0
  * @param {Array} array 要检查的数组。
  * @param {Array} values 排除的值。
- * @param {Function | string} [iteratee] 迭代函数，调用每个元素。
+ * @param {Function | string} [iteratee=identity] 迭代函数，调用每个元素。
  * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`，默认 `false` 。
  * @returns {Array} 过滤值后的新数组。
  * @example
@@ -29,5 +30,5 @@
  * difference([-0, 0], [0], undefined, true); // [-0]
  *
  */
-declare function difference<T, F extends (value: T) => any, K extends keyof T>(array: T[], values: any[], iteratee?: F | K, strictCheck?: boolean): T[];
+declare function difference<T>(array: T[], values: any[], iteratee?: IterateeParam<T>, strictCheck?: boolean): T[];
 export default difference;

package/types/every.d.ts

@@ -0,0 +1,6 @@
+import { ArrayIterator, ArrayLikeIterator, ObjectIterator, StringIterator, WithNullable } from './internals/types';
+declare function every<T>(collection: WithNullable<T[]>, predicate?: ArrayIterator<T, any>): boolean;
+declare function every(collection: WithNullable<string>, predicate?: StringIterator<any>): boolean;
+declare function every<T>(collection: WithNullable<ArrayLike<T>>, predicate?: ArrayLikeIterator<T, any>): boolean;
+declare function every<T extends object>(collection: WithNullable<T>, predicate?: ObjectIterator<T, any>): boolean;
+export default every;

package/types/filter.d.ts

@@ -0,0 +1,6 @@
+import { ArrayIterator, ArrayLikeIterator, ObjectIterator, StringIterator, WithNullable } from './internals/types';
+declare function filter<T>(collection: WithNullable<T[]>, predicate?: ArrayIterator<T, any>): T[];
+declare function filter(collection: WithNullable<string>, predicate?: StringIterator<any>): string[];
+declare function filter<T>(collection: WithNullable<ArrayLike<T>>, predicate?: ArrayLikeIterator<T, any>): T[];
+declare function filter<T extends object>(collection: WithNullable<T>, predicate?: ObjectIterator<T, any>): Array<T[keyof T]>;
+export default filter;

package/types/find.d.ts

@@ -0,0 +1,6 @@
+import { ArrayIterator, ArrayLikeIterator, ObjectIterator, StringIterator, WithNullable } from './internals/types';
+declare function find<T>(collection: WithNullable<T[]>, predicate?: ArrayIterator<T, any>): T | undefined;
+declare function find(collection: WithNullable<string>, predicate?: StringIterator<any>): string | undefined;
+declare function find<T>(collection: WithNullable<ArrayLike<T>>, predicate?: ArrayLikeIterator<T, any>): T | undefined;
+declare function find<T extends object>(collection: WithNullable<T>, predicate?: ObjectIterator<T, any>): T[keyof T] | undefined;
+export default find;

package/types/forEach.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 迭代集合元素，为每个元素调用 `iteratee` 。
+ *
+ * `iteratee` 函数可以通过显式返回 `false` 来提前退出迭代。
+ *
+ * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ *
+ * @function
+ * @alias module:Collection.forEach
+ * @since 1.7.0
+ * @param {ArrayLike<any> | Object} collection 要迭代的集合。
+ * @param {Function} [iteratee=identity] 每次迭代调用的函数。
+ * @returns {ArrayLike<any> | Object} 迭代集合本身。
+ * @example
+ *
+ * forEach([1,2,3], function(item){
+ *   console.log(item);
+ * });
+ * // 1
+ * // 2
+ * // 3
+ *
+ * forEach({a: 1, b: 2}, function(value, key){
+ *   console.log(value, key);
+ * });
+ * // 1 'a'
+ * // 2 'b'
+ *
+ */
+declare const forEach: {
+    <T>(collection: import("./internals/types").WithNullable<T[]>, iteratee?: import("./internals/types").ArrayIterator<T, any> | undefined): T[];
+    (collection: import("./internals/types").WithNullable<string>, iteratee?: import("./internals/types").StringIterator<any> | undefined): string;
+    <T_1>(collection: import("./internals/types").WithNullable<ArrayLike<T_1>>, iteratee?: import("./internals/types").ArrayLikeIterator<T_1, any> | undefined): ArrayLike<T_1>;
+    <T_2 extends object>(collection: import("./internals/types").WithNullable<T_2>, iteratee?: import("./internals/types").ObjectIterator<T_2, any> | undefined): T_2;
+};
+export default forEach;