ut2 1.5.6 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ut2",
-  "version": "1.5.6",
+  "version": "1.7.0",
   "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;

package/types/forEachRight.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 迭代集合元素（从右往左的顺序），为每个元素调用 `iteratee` 。
+ *
+ * `iteratee` 函数可以通过显式返回 `false` 来提前退出迭代。
+ *
+ * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ *
+ * @function
+ * @alias module:Collection.forEachRight
+ * @since 1.7.0
+ * @param {ArrayLike<any> | Object} collection 要迭代的集合。
+ * @param {Function} [iteratee=identity] 每次迭代调用的函数。
+ * @returns {ArrayLike<any> | Object} 迭代集合本身。
+ * @example
+ *
+ * forEachRight([1,2,3], function(item){
+ *   console.log(item);
+ * });
+ * // 3
+ * // 2
+ * // 1
+ *
+ * forEachRight({a: 1, b: 2}, function(value, key){
+ *   console.log(value, key);
+ * });
+ * // 2 'b'
+ * // 1 'a'
+ *
+ */
+declare const forEachRight: {
+    <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 forEachRight;

package/types/groupBy.d.ts

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

package/types/index.d.ts

@@ -23,10 +23,19 @@ export { default as zip } from './zip';
  * @since 1.0.0
  */
 export { default as countBy } from './countBy';
+export { default as every } from './every';
+export { default as find } from './find';
+export { default as filter } from './filter';
+export { default as forEach } from './forEach';
+export { default as forEachRight } from './forEachRight';
 export { default as groupBy } from './groupBy';
 export { default as keyBy } from './keyBy';
 export { default as orderBy } from './orderBy';
+export { default as map } from './map';
 export { default as partition } from './partition';
+export { default as reduce } from './reduce';
+export { default as reduceRight } from './reduceRight';
+export { default as some } from './some';
 /**
  * 函数
  *
@@ -113,6 +122,7 @@ export { default as randomInt } from './randomInt';
  */
 export { default as allKeys } from './allKeys';
 export { default as allKeysIn } from './allKeysIn';
+export { default as keys } from './keys';
 export { default as keysIn } from './keysIn';
 export { default as merge } from './merge';
 export { default as omit } from './omit';
@@ -156,6 +166,7 @@ export { default as lt } from './lt';
 export { default as lte } from './lte';
 export { default as noop } from './noop';
 export { default as nthArg } from './nthArg';
+export { default as range } from './range';
 export { default as sleep } from './sleep';
 export { default as times } from './times';
 export { default as toFinite } from './toFinite';

package/types/internals/compare.d.ts

@@ -5,5 +5,6 @@ export type OrderData<T> = {
     index: number;
     value: T;
 };
-export type Order = 'asc' | 'desc' | ((a: any, b: any) => number);
+export type OrderBase = 'asc' | 'desc';
+export type Order = OrderBase | ((a: any, b: any) => number);
 export declare function compareMultiple<T>(object: OrderData<T>, other: OrderData<T>, orders: Order[]): number;

package/types/internals/createExtremum.d.ts

@@ -1,2 +1,3 @@
-declare function createExtremum<T, F extends (item: T) => any, K extends keyof T>(array: T[], comparator: (value: any, other: any) => boolean, iteratee?: F | K): T | undefined;
+import { IterateeParam } from './types';
+declare function createExtremum<T>(array: T[], comparator: (value: any, other: any) => boolean, iteratee?: IterateeParam<T>): T | undefined;
 export default createExtremum;

package/types/internals/createForEach.d.ts

@@ -0,0 +1,15 @@
+import { ArrayIterator, ArrayLikeIterator, ObjectIterator, StringIterator, WithNullable } from './types';
+/**
+ * 创建迭代集合方法
+ *
+ * @private
+ * @param dir 迭代方向
+ * @returns 迭代集合方法
+ */
+declare function createForEach(dir: 1 | -1): {
+    <T>(collection: WithNullable<T[]>, iteratee?: ArrayIterator<T, any> | undefined): T[];
+    (collection: WithNullable<string>, iteratee?: StringIterator<any>): string;
+    <T_1>(collection: WithNullable<ArrayLike<T_1>>, iteratee?: ArrayLikeIterator<T_1, any> | undefined): ArrayLike<T_1>;
+    <T_2 extends object>(collection: WithNullable<T_2>, iteratee?: ObjectIterator<T_2, any> | undefined): T_2;
+};
+export default createForEach;

package/types/internals/createIteratee.d.ts

@@ -1,4 +1,4 @@
-import identity from '../identity';
+import { IterateeParam } from './types';
 /**
  * 创建迭代函数。
  *
@@ -6,5 +6,5 @@ import identity from '../identity';
  * @param {Function} iteratee 迭代函数或对象属性。
  * @returns {Function} 如果参数为函数，返回该函数，否则包装一个返回对象属性的函数。
  */
-declare function createIteratee<T, F extends (value: T) => any, K extends keyof T>(iteratee?: F | K): typeof identity | F;
+declare function createIteratee<T>(iteratee?: IterateeParam<T>): (value: T, ...args: any[]) => any;
 export default createIteratee;

package/types/internals/createReduce.d.ts

@@ -0,0 +1,19 @@
+import { ReduceArrayIterator, ReduceArrayLikeIterator, ReduceObjectIterator, ReduceStringIterator, WithNullable } from './types';
+/**
+ * 创建 reducer 函数
+ *
+ * @private
+ * @param dir 迭代方向
+ * @returns reduce 方法
+ */
+declare function createReduce(dir: 1 | -1): {
+    <T, R>(collection: WithNullable<T[]>, iteratee: ReduceArrayIterator<T, R>, initialValue: R): R;
+    <R_1>(collection: WithNullable<string>, iteratee: ReduceStringIterator<R_1>, initialValue: R_1): R_1;
+    <T_1, R_2>(collection: WithNullable<ArrayLike<T_1>>, iteratee: ReduceArrayLikeIterator<T_1, R_2>, initialValue: R_2): R_2;
+    <T_2 extends object, R_3>(collection: WithNullable<T_2>, iteratee: ReduceObjectIterator<T_2, R_3>, initialValue: R_3): R_3;
+    <T_3>(collection: WithNullable<T_3[]>, iteratee?: ReduceArrayIterator<T_3, T_3> | undefined): T_3 | undefined;
+    (collection: WithNullable<string>, iteratee?: ReduceStringIterator<string>): string | undefined;
+    <T_4>(collection: WithNullable<ArrayLike<T_4>>, iteratee?: ReduceArrayLikeIterator<T_4, T_4> | undefined): T_4 | undefined;
+    <T_5 extends object>(collection: WithNullable<T_5>, iteratee?: ReduceObjectIterator<T_5, T_5[keyof T_5]> | undefined): T_5[keyof T_5] | undefined;
+};
+export default createReduce;

package/types/intersection.d.ts

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

package/types/isArrayBuffer.d.ts

@@ -15,5 +15,5 @@
  * isArrayBuffer('2012'); // false
  *
  */
-declare function isArrayBuffer(value: any): boolean;
+declare function isArrayBuffer(value: any): value is ArrayBuffer;
 export default isArrayBuffer;

package/types/isArrayLike.d.ts

@@ -19,5 +19,5 @@
  * isArrayLike(()=>{}); // false
  *
  */
-declare function isArrayLike(value: any): boolean;
+declare function isArrayLike(value: any): value is ArrayLike<any>;
 export default isArrayLike;

package/types/isError.d.ts

@@ -15,5 +15,5 @@
  * isError(Error); // false
  *
  */
-declare function isError(value: any): boolean;
+declare function isError(value: any): value is Error;
 export default isError;

package/types/isWeakMap.d.ts

@@ -13,5 +13,5 @@
  * isWeakMap(new Map); // false
  *
  */
-declare function isWeakMap(value: any): value is WeakMap<any, any>;
+declare function isWeakMap(value: any): value is WeakMap<object, any>;
 export default isWeakMap;

package/types/isWeakSet.d.ts

@@ -13,5 +13,5 @@
  * isWeakSet(new Set); // false
  *
  */
-declare function isWeakSet(value: any): value is WeakSet<any>;
+declare function isWeakSet(value: any): value is WeakSet<object>;
 export default isWeakSet;

package/types/keyBy.d.ts

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

package/types/keys.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 创建一个数组，包含对象自身的可枚举属性（不包含 `Symbol` 属性）。
+ *
+ * 同 `Object.keys` 。
+ *
+ * @static
+ * @alias module:Object.keys
+ * @since 1.7.0
+ * @param {Object} object 要查询的对象。
+ * @returns {string[]} 对象自身的可枚举属性(不包含 `Symbol` 属性)。
+ * @example
+ *
+ * function Foo(){
+ *   this.a = 1;
+ *   this[Symbol.for('b')] = 2;
+ * }
+ * Foo.prototype.c = 3;
+ * Foo.prototype[Symbol.for('d')] = 4;
+ *
+ * keys(new Foo); // ['a']
+ *
+ */
+declare function keys<T extends object>(object: T): string[];
+export default keys;

package/types/keysIn.d.ts

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

package/types/map.d.ts

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

package/types/max.d.ts

@@ -1,3 +1,4 @@
+import { IterateeParam } from './internals/types';
 /**
  * 调用 `array` 中的每一个元素，来生成其值排序的标准，返回最大的值。
  *
@@ -7,7 +8,7 @@
  * @alias module:Math.max
  * @since 1.0.0
  * @param {Array} array 要迭代的数组。
- * @param {Function | string} [iteratee=identity] 调用每个元素的迭代函数。
+ * @param {Function | string} [iteratee] 调用每个元素的迭代函数。
  * @returns {*} 最大的值。
  * @example
  *
@@ -23,5 +24,5 @@
  * max(objects, 'n'); // {n: 2};
  *
  */
-declare function max<T, F extends (item: T) => any, K extends keyof T>(array: T[], iteratee?: F | K): T | undefined;
+declare function max<T>(array: T[], iteratee?: IterateeParam<T>): T | undefined;
 export default max;

package/types/merge.d.ts

@@ -1,15 +1,19 @@
+type GetKeysMethod = <T extends object>(object: T) => (symbol | string)[];
 type Customizer = (objValue: any, srcValue: any, key: string | symbol, object: any, source: any) => any;
 /**
- * 递归合并 `source` 来源对象自身和继承的可枚举属性（包含 `Symbol` 属性）到 `object` 目标对象。
+ * 递归合并 `source` 来源对象自身和继承的可枚举属性（不包含 `Symbol` 属性）到 `object` 目标对象。
  *
  * 如果目标值存在，被解析为 `undefined` 的 `source` 来源对象属性将被跳过。数组和普通对象会递归合并，其他对象和值会被直接分配覆盖。
  *
+ * 如果你需要合并 `Symbol` 属性，可以传入 {@link https://caijf.github.io/ut2/module-Object.html#.allKeysIn | allKeysIn} 方法。
+ *
  * @static
  * @alias module:Object.merge
  * @since 1.0.0
  * @param {Object | Array} object 目标对象。
  * @param {Object | Array} source 来源对象。
  * @param {Function} [customizer] 自定义赋值函数。
+ * @param {Function} [getKeys=keysIn] 自定义获取对象键方法。
  * @returns {Object} 目标对象。
  * @example
  *
@@ -24,5 +28,5 @@ type Customizer = (objValue: any, srcValue: any, key: string | symbol, object: a
  * merge(object, other); // { a: [{b: 2, c: 3}, {d: 4, e: 5}] }
  *
  */
-declare function merge<TObject, TSource>(object: TObject, source: TSource, customizer?: Customizer): TObject & TSource;
+declare function merge<TObject, TSource>(object: TObject, source: TSource, customizer?: Customizer, getKeys?: GetKeysMethod): TObject & TSource;
 export default merge;

package/types/min.d.ts

@@ -1,3 +1,4 @@
+import { IterateeParam } from './internals/types';
 /**
  * 调用 `array` 中的每一个元素，来生成其值排序的标准，返回最小的值。
  *
@@ -7,7 +8,7 @@
  * @alias module:Math.min
  * @since 1.0.0
  * @param {Array} array 要迭代的数组。
- * @param {Function | string} [iteratee=identity] 调用每个元素的迭代函数。
+ * @param {Function | string} [iteratee] 调用每个元素的迭代函数。
  * @returns {*} 最小的值。
  * @example
  *
@@ -22,5 +23,5 @@
  * // 迭代函数可以直接写入属性。
  * min(objects, 'n'); // {n: 1};
  */
-declare function min<T, F extends (item: T) => any, K extends keyof T>(array: T[], iteratee?: F | K): T | undefined;
+declare function min<T>(array: T[], iteratee?: IterateeParam<T>): T | undefined;
 export default min;

package/types/orderBy.d.ts

@@ -1,41 +1,5 @@
 import { Order } from './internals/compare';
-/**
- * 创建一个元素数组，以迭代函数处理的结果排序。如果没有指定排序，默认为升序排序。
- *
- * `asc` 升序， `desc` 降序，默认执行稳定排序，也就是说相同元素会保持原始排序。
- *
- * `iteratee` 调用时会传入 1 个参数 `value` 。
- *
- * @static
- * @alias module:Collection.orderBy
- * @since 1.0.0
- * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/sort | sort}
- * @param {Array} collection 一个用来迭代的集合。
- * @param {Function | string | Array} [iteratees] 排序的迭代函数。
- * @param {'asc' | 'desc' | Array} [orders] 迭代函数的排序顺序。
- * @returns {Array} 排序后的新数组。
- * @example
- *
- * const array = [2, 1, 3, 5, 4];
- *
- * orderBy(array);; // [1, 2, 3, 4, 5]
- *
- * orderBy(array, item=>item, 'desc');; // [5, 4, 3, 2, 1]
- *
- * const objects = [
- *   { a: 'x', b: 3 },
- *   { a: 'y', b: 4 },
- *   { a: 'x', b: 1 },
- *   { a: 'y', b: 2 }
- * ];
- *
- * orderBy(objects, 'b');
- * // [{ a: 'x', b: 1 },{ a: 'y', b: 2 },{ a: 'x', b: 3 },{ a: 'y', b: 4 }]
- *
- * // 迭代函数可以直接写入属性。
- * orderBy(objects, ['a', 'b'], ['asc', 'desc']);
- * // [{ a: 'x', b: 3 },{ a: 'x', b: 1 },{ a: 'y', b: 4 },{ a: 'y', b: 2 }]
- *
- */
-declare function orderBy<T, F extends (value: T) => any, K extends keyof T>(collection: T[], iteratees?: F | K | (F | K)[], orders?: Order | Order[]): T[];
+import { CollectionList, CollectionObject, IterateeParam, Many } from './internals/types';
+declare function orderBy<T>(collection: CollectionList<T>, iteratee?: Many<IterateeParam<T>>, orders?: Many<Order>): T[];
+declare function orderBy<T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: Many<IterateeParam<V>>, orders?: Many<Order>): V[];
 export default orderBy;

package/types/partition.d.ts

@@ -1,35 +1,4 @@
-/**
- * 创建一个分成两组的元素数组，第一组包含 `predicate`（断言函数）返回为 [`truthy`](https://developer.mozilla.org/zh-CN/docs/Glossary/Truthy)（真值）的元素，第二组包含 `predicate`（断言函数）返回为 [`falsy`](https://developer.mozilla.org/zh-CN/docs/Glossary/Falsy)（假值）的元素。
- *
- * `predicate` 调用时会传入 1 个参数 `value`。
- *
- * @static
- * @alias module:Collection.partition
- * @since 1.0.0
- * @param {Array} collection 一个用来迭代的集合。
- * @param {Function | string} [predicate=identity] 每次迭代调用的断言函数。
- * @returns {Array} 分组后的数组。
- * @example
- *
- * const users = [
- *   { user: 'barney', age: 36, active: false },
- *   { user: 'fred', age: 40, active: true },
- *   { user: 'pebbles', age: 1, active: false }
- * ];
- *
- * partition(users, item => item.active);
- * // [
- * //   [{ user: 'fred', age: 40, active: true }],
- * //   [{ user: 'barney', age: 36, active: false }, { user: 'pebbles', age: 1, active: false }]
- * // ]
- *
- * // 迭代函数可以直接写入属性。
- * partition(users, 'active');
- * // [
- * //   [{ user: 'fred', age: 40, active: true }],
- * //   [{ user: 'barney', age: 36, active: false }, { user: 'pebbles', age: 1, active: false }]
- * // ]
- *
- */
-declare function partition<T, F extends (value: T) => any, K extends keyof T>(collection: T[], predicate?: F | K): [T[], T[]];
+import { CollectionList, CollectionObject, IterateeParam } from './internals/types';
+declare function partition<T>(collection: CollectionList<T>, iteratee?: IterateeParam<T>): [T[], T[]];
+declare function partition<T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: IterateeParam<V>): [V[], V[]];
 export default partition;

package/types/range.d.ts

@@ -0,0 +1,4 @@
+declare function range(start: number, end: number, step: number): number[];
+declare function range(start: number, end: number): number[];
+declare function range(end: number): number[];
+export default range;