ut2 1.7.0 → 1.7.2

package/types/internals/createForEach.d.ts

@@ -1,4 +1,10 @@
 import { ArrayIterator, ArrayLikeIterator, ObjectIterator, StringIterator, WithNullable } from './types';
+export interface ForEach {
+    <T>(collection: WithNullable<T[]>, iteratee?: ArrayIterator<T, any>): T[];
+    (collection: WithNullable<string>, iteratee?: StringIterator<any>): string;
+    <T>(collection: WithNullable<ArrayLike<T>>, iteratee?: ArrayLikeIterator<T, any>): ArrayLike<T>;
+    <T extends object>(collection: WithNullable<T>, iteratee?: ObjectIterator<T, any>): T;
+}
 /**
  * 创建迭代集合方法
  *
@@ -6,10 +12,5 @@ import { ArrayIterator, ArrayLikeIterator, ObjectIterator, StringIterator, WithN
  * @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;
-};
+declare function createForEach(dir: 1 | -1): ForEach;
 export default createForEach;

package/types/internals/createReduce.d.ts

@@ -1,4 +1,14 @@
 import { ReduceArrayIterator, ReduceArrayLikeIterator, ReduceObjectIterator, ReduceStringIterator, WithNullable } from './types';
+export interface Reduce {
+    <T, R>(collection: WithNullable<T[]>, iteratee: ReduceArrayIterator<T, R>, initialValue: R): R;
+    <R>(collection: WithNullable<string>, iteratee: ReduceStringIterator<R>, initialValue: R): R;
+    <T, R>(collection: WithNullable<ArrayLike<T>>, iteratee: ReduceArrayLikeIterator<T, R>, initialValue: R): R;
+    <T extends object, R>(collection: WithNullable<T>, iteratee: ReduceObjectIterator<T, R>, initialValue: R): R;
+    <T>(collection: WithNullable<T[]>, iteratee?: ReduceArrayIterator<T, T>): T | undefined;
+    (collection: WithNullable<string>, iteratee?: ReduceStringIterator<string>): string | undefined;
+    <T>(collection: WithNullable<ArrayLike<T>>, iteratee?: ReduceArrayLikeIterator<T, T>): T | undefined;
+    <T extends object>(collection: WithNullable<T>, iteratee?: ReduceObjectIterator<T, T[keyof T]>): T[keyof T] | undefined;
+}
 /**
  * 创建 reducer 函数
  *
@@ -6,14 +16,5 @@ import { ReduceArrayIterator, ReduceArrayLikeIterator, ReduceObjectIterator, Red
  * @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;
-};
+declare function createReduce(dir: 1 | -1): Reduce;
 export default createReduce;

package/types/internals/types.d.ts

@@ -0,0 +1,29 @@
+export type FunctionAny = (...args: any[]) => any;
+/**
+ * 工具辅助类型
+ */
+export type Many<T> = T | T[];
+export type WithNullable<T> = T | null | undefined;
+/**
+ * 迭代参数
+ */
+export type IterateeParam<T> = ((value: T, ...args: any[]) => any) | keyof T;
+/**
+ * 迭代方法
+ */
+export type StringIterator<R> = (char: string, index: number, string: string) => R;
+export type ArrayIterator<T, R> = (item: T, index: number, list: T[]) => R;
+export type ArrayLikeIterator<T, R> = (item: T, index: number, list: ArrayLike<T>) => R;
+export type ObjectIterator<T, R> = (value: T[keyof T], key: string, object: T) => R;
+export type ReduceStringIterator<R> = (accumulator: R, currentValue: string, currentIndex: number, string: string) => R;
+export type ReduceArrayIterator<T, R> = (accumulator: R, currentValue: T, currentIndex: number, list: T[]) => R;
+export type ReduceArrayLikeIterator<T, R> = (accumulator: R, currentValue: T, currentIndex: number, list: ArrayLike<T>) => R;
+export type ReduceObjectIterator<T, R> = (accumulator: R, currentValue: T[keyof T], currentKey: string, object: T) => R;
+/**
+ * 集合类数组
+ */
+export type CollectionList<T> = WithNullable<ArrayLike<T>>;
+/**
+ * 集合对象
+ */
+export type CollectionObject<T extends object> = WithNullable<T>;

package/types/isFunction.d.ts

@@ -1,3 +1,4 @@
+import { FunctionAny } from './internals/types';
 /**
  * 检查值是否为 `Function` 对象 。
  *
@@ -15,5 +16,5 @@
  * isFunction(/x/); // false
  *
  */
-declare function isFunction(value: any): value is (...args: any[]) => any;
+declare function isFunction(value: any): value is FunctionAny;
 export default isFunction;

package/types/keyBy.d.ts

@@ -1,4 +1,30 @@
 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>;
+interface KeyBy {
+    <T>(collection: CollectionList<T>, iteratee?: IterateeParam<T>): Record<string, T>;
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: IterateeParam<V>): Record<string, V>;
+}
+/**
+ * 创建一个组成聚合对象， `key` 是经过 `iteratee` 执行处理 `collection` 中每个元素后返回的结果。每个 `key` 对应的值是生成 `key` 的最后一个元素。
+ *
+ * `iteratee` 调用时会传入 1 个参数 `value` 。
+ *
+ * @function
+ * @alias module:Collection.keyBy
+ * @since 1.0.0
+ * @param {ArrayLike<any> | Object} collection 一个用来迭代的集合。
+ * @param {Function | string} [iteratee=identity] 迭代函数，用来转换键。
+ * @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 const keyBy: KeyBy;
 export default keyBy;

package/types/map.d.ts

@@ -1,6 +1,30 @@
 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]>;
+interface Map {
+    <T>(collection: WithNullable<T[]>, iteratee?: ArrayIterator<T, any>): T[];
+    (collection: WithNullable<string>, iteratee?: StringIterator<any>): string[];
+    <T>(collection: WithNullable<ArrayLike<T>>, iteratee?: ArrayLikeIterator<T, any>): T[];
+    <T extends object>(collection: WithNullable<T>, iteratee?: ObjectIterator<T, any>): Array<T[keyof T]>;
+}
+/**
+ * 创建一个新数组，这个数组的值由迭代集合每个元素调用 `iteratee` 函数的返回值组成。
+ *
+ * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ *
+ * @static
+ * @alias module:Collection.map
+ * @since 1.7.0
+ * @param {ArrayLike<any> | Object} collection 要迭代的集合。
+ * @param {function} [iteratee=identity] 每次迭代调用的函数。
+ * @returns {Array} 一个新数组。
+ * @example
+ *
+ * const arr = [1, 2, 3];
+ * map(arr, item => item * 3); // [3, 6, 9]
+ *
+ * const obj = { one: 1, two: 2, three: 3 };
+ * map(obj, item => item * 3); // [3, 6, 9]
+ *
+ * map([[1, 2], [3, 4]], item=>item[0]); // [1, 3]
+ */
+declare const map: Map;
 export default map;

package/types/merge.d.ts

@@ -5,7 +5,7 @@ type Customizer = (objValue: any, srcValue: any, key: string | symbol, object: a
  *
  * 如果目标值存在，被解析为 `undefined` 的 `source` 来源对象属性将被跳过。数组和普通对象会递归合并，其他对象和值会被直接分配覆盖。
  *
- * 如果你需要合并 `Symbol` 属性，可以传入 {@link https://caijf.github.io/ut2/module-Object.html#.allKeysIn | allKeysIn} 方法。
+ * 如果你需要合并 `Symbol` 属性，第四个参数传入 {@link https://caijf.github.io/ut2/module-Object.html#.allKeysIn | allKeysIn} 方法， `merge(object, source, undefined, allKeysIn)` 。
  *
  * @static
  * @alias module:Object.merge
@@ -27,6 +27,8 @@ type Customizer = (objValue: any, srcValue: any, key: string | symbol, object: a
  *
  * merge(object, other); // { a: [{b: 2, c: 3}, {d: 4, e: 5}] }
  *
+ * // 自定义，数组不合并
+ * merge(object, other, (objValue, srcValue) => Array.isArray(srcValue) ? srcValue : undefined); // { a: [{c: 3},{e: 5}] }
  */
 declare function merge<TObject, TSource>(object: TObject, source: TSource, customizer?: Customizer, getKeys?: GetKeysMethod): TObject & TSource;
 export default merge;

package/types/negate.d.ts

@@ -1,3 +1,4 @@
+import { FunctionAny } from './internals/types';
 /**
  * 创建一个断言函数结果取反的函数。
  *
@@ -19,5 +20,5 @@
  * nums.filter(ne); // [1, 3, 5]
  *
  */
-declare function negate<T extends (...args: any[]) => any>(this: any, predicate: T): (...args: Parameters<T>) => boolean;
+declare function negate<T extends FunctionAny>(this: any, predicate: T): (...args: Parameters<T>) => boolean;
 export default negate;

package/types/once.d.ts

@@ -1,3 +1,4 @@
+import { FunctionAny } from './internals/types';
 /**
  * 创建一个只能调用 `func` 一次的函数。重复调用将返回第一次调用 `func` 的结果。
  *
@@ -20,5 +21,5 @@
  * increment(); // 1
  *
  */
-declare function once<T extends (...args: any[]) => any>(func: T): T;
+declare function once<T extends FunctionAny>(func: T): T;
 export default once;

package/types/orderBy.d.ts

@@ -1,5 +1,46 @@
 import { Order } from './internals/compare';
 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[];
+interface OrderBy {
+    <T>(collection: CollectionList<T>, iteratee?: Many<IterateeParam<T>>, orders?: Many<Order>): T[];
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: Many<IterateeParam<V>>, orders?: Many<Order>): V[];
+}
+/**
+ * 创建一个元素数组，以迭代函数处理的结果排序。如果没有指定排序，默认为升序排序。
+ *
+ * `asc` 升序， `desc` 降序，默认执行稳定排序，也就是说相同元素会保持原始排序。
+ *
+ * `iteratee` 调用时会传入 1 个参数 `value` 。
+ *
+ * @function
+ * @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 {ArrayLike<any> | Object} 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 const orderBy: OrderBy;
 export default orderBy;

package/types/partial.d.ts

@@ -1,12 +1,64 @@
-declare function partial<TS extends any[], R>(func: (...ts: TS) => R): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, R>(func: (t1: T1, ...ts: TS) => R, arg1: T1): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, R>(func: (t1: T1, t2: T2, ...ts: TS) => R, t1: T1, t2: T2): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R, t1: T1, t2: T2, t3: T3): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, T4, T5, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, T4, T5, T6, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, T4, T5, T6, T7, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, T4, T5, T6, T7, T8, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, T4, T5, T6, T7, T8, T9, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10): (...ts: TS) => R;
+interface PartialPlaceholder {
+    __ut2_partial__: number;
+}
+type Placeholder = PartialPlaceholder;
+type Function0<R> = () => R;
+type Function1<T1, R> = (t1: T1) => R;
+type Function2<T1, T2, R> = (t1: T1, t2: T2) => R;
+type Function3<T1, T2, T3, R> = (t1: T1, t2: T2, t3: T3) => R;
+type Function4<T1, T2, T3, T4, R> = (t1: T1, t2: T2, t3: T3, t4: T4) => R;
+interface Partial {
+    <T1, T2, R>(func: Function2<T1, T2, R>, plc1: Placeholder, arg2: T2): Function1<T1, R>;
+    <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1, arg2: T2): Function0<R>;
+    <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: Placeholder, arg2: T2): Function2<T1, T3, R>;
+    <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: Placeholder, plc2: Placeholder, arg3: T3): Function2<T1, T2, R>;
+    <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, plc2: Placeholder, arg3: T3): Function1<T2, R>;
+    <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: Placeholder, arg2: T2, arg3: T3): Function1<T1, R>;
+    <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): Function0<R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: Placeholder, arg2: T2): Function3<T1, T3, T4, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: Placeholder, plc2: Placeholder, arg3: T3): Function3<T1, T2, T4, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: Placeholder, arg3: T3): Function2<T2, T4, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: Placeholder, arg2: T2, arg3: T3): Function2<T1, T4, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3): Function1<T4, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: Placeholder, plc2: Placeholder, plc3: Placeholder, arg4: T4): Function3<T1, T2, T3, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: Placeholder, plc3: Placeholder, arg4: T4): Function2<T2, T3, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: Placeholder, arg2: T2, plc3: Placeholder, arg4: T4): Function2<T1, T3, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: Placeholder, arg4: T4): Function1<T3, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: Placeholder, plc2: Placeholder, arg3: T3, arg4: T4): Function2<T1, T2, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: Placeholder, arg3: T3, arg4: T4): Function1<T2, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: Placeholder, arg2: T2, arg3: T3, arg4: T4): Function1<T1, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): Function0<R>;
+    <TS extends any[], R>(func: (...ts: TS) => R): (...ts: TS) => R;
+    <TS extends any[], T1, R>(func: (t1: T1, ...ts: TS) => R, arg1: T1): (...ts: TS) => R;
+    <TS extends any[], T1, T2, R>(func: (t1: T1, t2: T2, ...ts: TS) => R, t1: T1, t2: T2): (...ts: TS) => R;
+    <TS extends any[], T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R, t1: T1, t2: T2, t3: T3): (...ts: TS) => R;
+    <TS extends any[], T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4): (...ts: TS) => R;
+    placeholder: Placeholder;
+    _: Placeholder;
+}
+/**
+ * 创建一个函数。该函数调用 `func` ，并传入预设的 `args` 参数。
+ *
+ *  `partial._` 或 `partial.placeholder` 可用作部分参数的占位符。
+ *
+ * @function
+ * @alias module:Function.partial
+ * @since 1.0.0
+ * @param {Function} func 需要预设的函数。
+ * @param {...*} [args] 预设的参数。
+ * @returns {Function} 预设参数的函数。
+ * @example
+ *
+ * function greet(greeting, name){
+ *   return greeting + ' ' + name;
+ * }
+ *
+ * const sayHelloTo = partial(greet, 'hello');
+ * sayHelloTo('jeff'); // 'hello jeff'
+ *
+ * const greetJeff = partial(greet, partial._, 'jeff');
+ * greetJeff('hi'); // 'hi jeff'
+ *
+ */
+declare const partial: Partial;
 export default partial;

package/types/partition.d.ts

@@ -1,4 +1,40 @@
 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[]];
+interface Partition {
+    <T>(collection: CollectionList<T>, iteratee?: IterateeParam<T>): [T[], T[]];
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: IterateeParam<V>): [V[], V[]];
+}
+/**
+ * 创建一个分成两组的元素数组，第一组包含 `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 {ArrayLike<any> | Object} 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 const partition: Partition;
 export default partition;

package/types/range.d.ts

@@ -1,4 +1,29 @@
-declare function range(start: number, end: number, step: number): number[];
-declare function range(start: number, end: number): number[];
-declare function range(end: number): number[];
+interface Range {
+    (start: number, end: number, step: number): number[];
+    (start: number, end: number): number[];
+    (end: number): number[];
+}
+/**
+ * 创建一个升序或降序的数字数组。
+ *
+ * 如果省略 `start` 默认为 0 。
+ *
+ * @function
+ * @alias module:Util.range
+ * @since 1.6.0
+ * @param {number} [start=0] 开始值。
+ * @param {number} end 结束值。
+ * @param {number} [step] 要增加或减少的值。如果值为 `0` ，将视为无效参数。如果 `start` 在 `end` 之前，默认为 1 ，否则默认为 -1。
+ * @return {number[]} 从开始值（包含）到结束值（不包含）逐步递增或递减的数字数组。
+ * @example
+ *
+ * range(4); // [0, 1, 2, 3]
+ * range(-4); // [0, -1, -2, -3]
+ * range(1, 5); // [1, 2, 3, 4]
+ * range(0, 20, 5); // [0, 5, 10, 15]
+ * range(0, -4, -1); // [1, 2, 3]
+ * range(1, 4, 0); // [1, 2, 3]
+ * range(0); // []
+ */
+declare const range: Range;
 export default range;

package/types/reduce.d.ts

@@ -25,14 +25,5 @@
  * // 6
  *
  */
-declare const reduce: {
-    <T, R>(collection: import("./internals/types").WithNullable<T[]>, iteratee: import("./internals/types").ReduceArrayIterator<T, R>, initialValue: R): R;
-    <R_1>(collection: import("./internals/types").WithNullable<string>, iteratee: import("./internals/types").ReduceStringIterator<R_1>, initialValue: R_1): R_1;
-    <T_1, R_2>(collection: import("./internals/types").WithNullable<ArrayLike<T_1>>, iteratee: import("./internals/types").ReduceArrayLikeIterator<T_1, R_2>, initialValue: R_2): R_2;
-    <T_2 extends object, R_3>(collection: import("./internals/types").WithNullable<T_2>, iteratee: import("./internals/types").ReduceObjectIterator<T_2, R_3>, initialValue: R_3): R_3;
-    <T_3>(collection: import("./internals/types").WithNullable<T_3[]>, iteratee?: import("./internals/types").ReduceArrayIterator<T_3, T_3> | undefined): T_3 | undefined;
-    (collection: import("./internals/types").WithNullable<string>, iteratee?: import("./internals/types").ReduceStringIterator<string> | undefined): string | undefined;
-    <T_4>(collection: import("./internals/types").WithNullable<ArrayLike<T_4>>, iteratee?: import("./internals/types").ReduceArrayLikeIterator<T_4, T_4> | undefined): T_4 | undefined;
-    <T_5 extends object>(collection: import("./internals/types").WithNullable<T_5>, iteratee?: import("./internals/types").ReduceObjectIterator<T_5, T_5[keyof T_5]> | undefined): T_5[keyof T_5] | undefined;
-};
+declare const reduce: import("./internals/createReduce").Reduce;
 export default reduce;

package/types/reduceRight.d.ts

@@ -25,14 +25,5 @@
  * // 6
  *
  */
-declare const reduceRight: {
-    <T, R>(collection: import("./internals/types").WithNullable<T[]>, iteratee: import("./internals/types").ReduceArrayIterator<T, R>, initialValue: R): R;
-    <R_1>(collection: import("./internals/types").WithNullable<string>, iteratee: import("./internals/types").ReduceStringIterator<R_1>, initialValue: R_1): R_1;
-    <T_1, R_2>(collection: import("./internals/types").WithNullable<ArrayLike<T_1>>, iteratee: import("./internals/types").ReduceArrayLikeIterator<T_1, R_2>, initialValue: R_2): R_2;
-    <T_2 extends object, R_3>(collection: import("./internals/types").WithNullable<T_2>, iteratee: import("./internals/types").ReduceObjectIterator<T_2, R_3>, initialValue: R_3): R_3;
-    <T_3>(collection: import("./internals/types").WithNullable<T_3[]>, iteratee?: import("./internals/types").ReduceArrayIterator<T_3, T_3> | undefined): T_3 | undefined;
-    (collection: import("./internals/types").WithNullable<string>, iteratee?: import("./internals/types").ReduceStringIterator<string> | undefined): string | undefined;
-    <T_4>(collection: import("./internals/types").WithNullable<ArrayLike<T_4>>, iteratee?: import("./internals/types").ReduceArrayLikeIterator<T_4, T_4> | undefined): T_4 | undefined;
-    <T_5 extends object>(collection: import("./internals/types").WithNullable<T_5>, iteratee?: import("./internals/types").ReduceObjectIterator<T_5, T_5[keyof T_5]> | undefined): T_5[keyof T_5] | undefined;
-};
+declare const reduceRight: import("./internals/createReduce").Reduce;
 export default reduceRight;

package/types/some.d.ts

@@ -1,6 +1,28 @@
 import { ArrayIterator, ArrayLikeIterator, ObjectIterator, StringIterator, WithNullable } from './internals/types';
-declare function some<T>(collection: WithNullable<T[]>, predicate?: ArrayIterator<T, any>): boolean;
-declare function some(collection: WithNullable<string>, predicate?: StringIterator<any>): boolean;
-declare function some<T>(collection: WithNullable<ArrayLike<T>>, predicate?: ArrayLikeIterator<T, any>): boolean;
-declare function some<T extends object>(collection: WithNullable<T>, predicate?: ObjectIterator<T, any>): boolean;
+interface Some {
+    <T>(collection: WithNullable<T[]>, predicate?: ArrayIterator<T, any>): boolean;
+    (collection: WithNullable<string>, predicate?: StringIterator<any>): boolean;
+    <T>(collection: WithNullable<ArrayLike<T>>, predicate?: ArrayLikeIterator<T, any>): boolean;
+    <T extends object>(collection: WithNullable<T>, predicate?: ObjectIterator<T, any>): boolean;
+}
+/**
+ * 迭代集合中的元素执行 `predicate` 函数，如果任一元素通过 `predicate` 返回真值，则停止迭代并返回 `true` ，否则返回 `false` 。
+ *
+ * `predicate` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ *
+ * @function
+ * @alias module:Collection.some
+ * @since 1.7.0
+ * @param {ArrayLike<any> | Object} collection 要迭代的集合。
+ * @param {function} [predicate=identity] 每次迭代调用的函数。
+ * @returns {boolean} 如果任一元素通过 `predicate` 测试，则返回 `true` ，否则返回 `false` 。
+ * @example
+ *
+ * const arr = [1, 2, 3, 4, 5, 6];
+ * some(arr, item => item % 2 === 0); // false
+ *
+ * const obj = { one: 1, two: 2, three: 3 };
+ * some(obj, item => item > 1); // true
+ */
+declare const some: Some;
 export default some;

package/types/throttle.d.ts

@@ -1,3 +1,4 @@
+import { FunctionAny } from './internals/types';
 /**
  * 创建一个节流函数，该函数在 `wait` 毫秒数内最多执行一次 `func` 方法。
  *
@@ -33,7 +34,7 @@
  * window.addEvenetListener('popstate', throttled.cancel);
  *
  */
-declare function throttle<T extends (...args: any[]) => any>(func: T, wait?: number, immediate?: boolean): {
+declare function throttle<T extends FunctionAny>(func: T, wait?: number, immediate?: boolean): {
     (this: any, ...args: Parameters<T>): ReturnType<T>;
     cancel: () => void;
     flush: () => ReturnType<T>;

package/types/times.d.ts

@@ -1,3 +1,26 @@
-declare function times<T>(n: number, iteratee: (index: number) => T): T[];
-declare function times(n: number): number[];
+interface Times {
+    <T>(n: number, iteratee: (index: number) => T): T[];
+    (n: number): number[];
+}
+/**
+ * 调用 `iteratee` `n` 次，每次调用返回的结果存入到数组中。
+ *
+ * `iteratee` 调用传入 1 个参数 `index` 。
+ *
+ * @function
+ * @alias module:Util.times
+ * @since 1.0.0
+ * @param {number} n 调用 `iteratee` 的次数。
+ * @param {Function} [iteratee=identity] 每次迭代调用的函数。
+ * @returns {Array} 调用结果的数组。
+ * @example
+ *
+ * times(3); // [0, 1, 2]
+ *
+ * times(3, String); // ['0', '1', '2']
+ *
+ * times(4, () => 0); // [0, 0, 0, 0]
+ *
+ */
+declare const times: Times;
 export default times;