ut2 1.7.1 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ut2",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "author": "caijf",
   "license": "MIT",
   "main": "lib/index.js",
@@ -26,7 +26,7 @@
     "commit": "cz",
     "prepublishOnly": "npm test && npm run build",
     "tsc": "tsc --noEmit",
-    "prepare": "husky install"
+    "prepare": "husky"
   },
   "repository": {
     "type": "git",
@@ -54,41 +54,43 @@
   },
   "config": {
     "commitizen": {
-      "path": "./node_modules/cz-conventional-changelog"
+      "path": "@commitlint/cz-commitlint"
     }
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@commitlint/cli": "^17.7.1",
-    "@commitlint/config-conventional": "^17.7.0",
-    "@rollup/plugin-commonjs": "^25.0.4",
-    "@rollup/plugin-node-resolve": "^15.2.1",
-    "@rollup/plugin-replace": "^5.0.2",
-    "@rollup/plugin-terser": "^0.4.3",
-    "@rollup/plugin-typescript": "^11.1.3",
-    "@types/jest": "^29.5.4",
-    "@types/node": "^20.6.2",
-    "@typescript-eslint/eslint-plugin": "^5.62.0",
-    "@typescript-eslint/parser": "^5.62.0",
+    "@commitlint/cli": "^19.2.1",
+    "@commitlint/config-conventional": "^19.1.0",
+    "@commitlint/cz-commitlint": "^19.2.0",
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-replace": "^5.0.5",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.30",
+    "@typescript-eslint/eslint-plugin": "^7.3.1",
+    "@typescript-eslint/parser": "^7.3.1",
     "benchmark": "^2.1.4",
+    "commitizen": "^4.3.0",
     "cross-env": "^7.0.3",
-    "cz-conventional-changelog": "^3.3.0",
     "dayjs": "^1.11.10",
     "docdash": "^2.0.2",
-    "eslint": "^8.48.0",
-    "husky": "^8.0.0",
-    "jest": "^29.6.4",
-    "jest-environment-jsdom": "^29.6.4",
+    "eslint": "^8.57.0",
+    "husky": "^9.0.11",
+    "inquirer": "9",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
     "jsdoc": "^4.0.2",
-    "lint-staged": "^13.3.0",
+    "lint-staged": "^15.2.2",
     "lodash": "^4.17.21",
-    "prettier": "^2.8.8",
-    "rollup": "^3.28.1",
-    "ts-jest": "^29.1.1",
+    "prettier": "^3.2.5",
+    "rollup": "^4.13.0",
+    "ts-jest": "^29.1.2",
     "tslib": "^2.6.2",
-    "typescript": "^5.2.2",
+    "typescript": "^5.4.3",
     "underscore": "^1.13.6"
   },
   "engines": {

package/types/after.d.ts

@@ -1,3 +1,4 @@
+import { FunctionAny } from './internals/types';
 /**
  * 创建一个函数，当它被调用 `n` 或更多次之后触发 `func` 。
  *
@@ -21,5 +22,5 @@
  * // 'done saving!'
  *
  */
-declare function after<T extends (...args: any[]) => any>(n: number, func: T): T;
+declare function after<T extends FunctionAny>(n: number, func: T): T;
 export default after;

package/types/allKeys.d.ts

@@ -20,5 +20,5 @@
  * allKeys(new Foo); // ['a', Symbol(b)]
  *
  */
-declare function allKeys<T extends object>(object: T): (string | symbol)[];
+declare function allKeys(object?: any): (string | symbol)[];
 export default allKeys;

package/types/allKeysIn.d.ts

@@ -20,5 +20,5 @@
  * allKeysIn(new Foo); // ['a', 'c', Symbol(b), Symbol(d)]
  *
  */
-declare function allKeysIn<T extends object>(object: T): (string | symbol)[];
+declare function allKeysIn(object?: any): (string | symbol)[];
 export default allKeysIn;

package/types/before.d.ts

@@ -1,3 +1,4 @@
+import { FunctionAny } from './internals/types';
 /**
  * 创建一个调用 `func` 的函数，调用次数少于 `n` 次。之后再调用这个函数，将返回最后一次调用 `func` 的结果。
  *
@@ -20,5 +21,5 @@
  * increment(); // 2 返回之前的结果
  *
  */
-declare function before<T extends (...args: any[]) => any>(n: number, func: T): T;
+declare function before<T extends FunctionAny>(n: number, func: T): T;
 export default before;

package/types/clamp.d.ts

@@ -1,3 +1,30 @@
-declare function clamp(number: number, upper: number): number;
-declare function clamp(number: number, lower: number, upper: number): number;
+interface Clamp {
+    (number: number, upper: number): number;
+    (number: number, lower: number, upper: number): number;
+}
+/**
+ * 数字限制在 `lower` 和 `upper` 之间的值。
+ *
+ * @function
+ * @alias module:Number.clamp
+ * @since 1.0.0
+ * @param {number} number 被限制的值。
+ * @param {number} [lower] 下限。
+ * @param {number} upper 上限。
+ * @returns {number} 被限制的值。
+ * @example
+ *
+ * clamp(-10, -5, 5); // -5
+ *
+ * clamp(-10, 0, 5); // 0
+ *
+ * clamp(10, -5, 5); // 5
+ *
+ * // 仅限制上限
+ * clamp(10, 5); // 5
+ *
+ * clamp(-10, 5); // -10
+ *
+ */
+declare const clamp: Clamp;
 export default clamp;

package/types/conforms.d.ts

@@ -1,7 +1,12 @@
+import { PropertyName, WithNullable } from './internals/types';
+interface ConformsFunction {
+    <T extends object, K extends keyof T>(source: Record<PropertyName, (value: T[K]) => boolean>): (object: WithNullable<T>) => boolean;
+    (source: object): (object: any) => boolean;
+}
 /**
  * 创建一个函数，调用 `source` 的属性名对应的断言函数与传入对象相对应属性名的值进行断言处理。如果都符合返回 `true`，否则返回 `false` 。
  *
- * @static
+ * @function
  * @alias module:Util.conforms
  * @since 1.0.0
  * @param {Object} source 要断言属性是否符合的对象。
@@ -15,5 +20,5 @@
  *
  * objs.filter(conforms({ b: value => value > 1 })); // [{ a: 2: b: 2 }]
  */
-declare function conforms<T extends object, K extends keyof T, S extends object = Record<string, (value: T[K]) => any>>(source: S): (object: T) => boolean;
+declare const conforms: ConformsFunction;
 export default conforms;

package/types/conformsTo.d.ts

@@ -1,4 +1,25 @@
-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 WithNullable<object>>(object: T, source: Record<string | symbol, (value: any) => any>): boolean;
+import { PropertyName, WithNullable } from './internals/types';
+interface ConformsTo {
+    <T extends object, K extends keyof T>(object: T, source: Record<K, (value: T[K]) => boolean>): boolean;
+    (object: WithNullable<object>, source: Record<PropertyName, (value: any) => boolean>): boolean;
+}
+/**
+ * 通过调用断言 `source` 的属性与 `object` 的相应属性值，检查 `object` 是否符合 `source` 。
+ *
+ * @function
+ * @alias module:Util.conformsTo
+ * @since 1.0.0
+ * @param {Object} object 要检查的对象。
+ * @param {Object} source 要断言属性是否符合的对象。
+ * @returns {boolean} 如果 `object` 符合，返回 `true` ，否则返回 `false` 。
+ * @example
+ *
+ * const object = { a: 1, b: 2 }
+ *
+ * conformsTo(object, { b: value => value > 1 }); // true
+ *
+ * conformsTo(object, { b: value => value > 2 }); // false
+ *
+ */
+declare const conformsTo: ConformsTo;
 export default conformsTo;

package/types/countBy.d.ts

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

package/types/curry.d.ts

@@ -0,0 +1,123 @@
+declare const PLACEHOLDER: {
+    __ut2_curry_ph__: null;
+};
+type Placeholder = typeof PLACEHOLDER;
+interface Curry {
+    <T1, R>(func: (t1: T1) => R, arity?: number): CurriedFunction1<T1, R>;
+    <T1, T2, R>(func: (t1: T1, t2: T2) => R, arity?: number): CurriedFunction2<T1, T2, R>;
+    <T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R, arity?: number): CurriedFunction3<T1, T2, T3, R>;
+    <T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arity?: number): CurriedFunction4<T1, T2, T3, T4, R>;
+    <T1, T2, T3, T4, T5, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R, arity?: number): CurriedFunction5<T1, T2, T3, T4, T5, R>;
+    (func: (...args: any[]) => any, arity?: number): (...args: any[]) => any;
+    placeholder: Placeholder;
+    _: Placeholder;
+}
+interface CurriedFunction1<T1, R> {
+    (t1: T1): R;
+    (t1: Placeholder): CurriedFunction1<T1, R>;
+    (): CurriedFunction1<T1, R>;
+}
+interface CurriedFunction2<T1, T2, R> {
+    (t1: Placeholder, t2: T2): CurriedFunction1<T1, R>;
+    (t1: T1, t2: T2): R;
+    (t1: T1): CurriedFunction1<T2, R>;
+    (t1: Placeholder): CurriedFunction2<T1, T2, R>;
+    (): CurriedFunction2<T1, T2, R>;
+}
+interface CurriedFunction3<T1, T2, T3, R> {
+    (t1: Placeholder, t2: Placeholder, t3: T3): CurriedFunction2<T1, T2, R>;
+    (t1: Placeholder, t2: T2, t3: T3): CurriedFunction1<T1, R>;
+    (t1: T1, t2: Placeholder, t3: T3): CurriedFunction1<T2, R>;
+    (t1: T1, t2: T2, t3: T3): R;
+    (t1: Placeholder, t2: T2): CurriedFunction2<T1, T3, R>;
+    (t1: T1, t2: T2): CurriedFunction1<T3, R>;
+    (t1: T1): CurriedFunction2<T2, T3, R>;
+    (t1: Placeholder): CurriedFunction3<T1, T2, T3, R>;
+    (): CurriedFunction3<T1, T2, T3, R>;
+}
+interface CurriedFunction4<T1, T2, T3, T4, R> {
+    (t1: Placeholder, t2: Placeholder, t3: Placeholder, t4: T4): CurriedFunction3<T1, T2, T3, R>;
+    (t1: Placeholder, t2: Placeholder, t3: T3, t4: T4): CurriedFunction2<T1, T2, R>;
+    (t1: Placeholder, t2: T2, t3: Placeholder, t4: T4): CurriedFunction2<T1, T3, R>;
+    (t1: T1, t2: Placeholder, t3: Placeholder, t4: T4): CurriedFunction2<T2, T3, R>;
+    (t1: T1, t2: T2, t3: Placeholder, t4: T4): CurriedFunction1<T3, R>;
+    (t1: T1, t2: Placeholder, t3: T3, t4: T4): CurriedFunction1<T2, R>;
+    (t1: Placeholder, t2: T2, t3: T3, t4: T4): CurriedFunction1<T1, R>;
+    (t1: T1, t2: T2, t3: T3, t4: T4): R;
+    (t1: Placeholder, t2: Placeholder, t3: T3): CurriedFunction3<T1, T2, T4, R>;
+    (t1: T1, t2: Placeholder, t3: T3): CurriedFunction2<T2, T4, R>;
+    (t1: Placeholder, t2: T2, t3: T3): CurriedFunction2<T1, T4, R>;
+    (t1: T1, t2: T2, t3: T3): CurriedFunction1<T4, R>;
+    (t1: Placeholder, t2: T2): CurriedFunction3<T1, T3, T4, R>;
+    (t1: T1, t2: T2): CurriedFunction2<T3, T4, R>;
+    (t1: T1): CurriedFunction3<T2, T3, T4, R>;
+    (t1: Placeholder): CurriedFunction4<T1, T2, T3, T4, R>;
+    (): CurriedFunction4<T1, T2, T3, T4, R>;
+}
+interface CurriedFunction5<T1, T2, T3, T4, T5, R> {
+    (t1: Placeholder, t2: Placeholder, t3: Placeholder, t4: Placeholder, t5: T5): CurriedFunction4<T1, T2, T3, T4, R>;
+    (t1: Placeholder, t2: Placeholder, t3: Placeholder, t4: T4, t5: T5): CurriedFunction3<T1, T2, T3, R>;
+    (t1: Placeholder, t2: Placeholder, t3: T3, t4: Placeholder, t5: T5): CurriedFunction3<T1, T2, T4, R>;
+    (t1: Placeholder, t2: T2, t3: Placeholder, t4: Placeholder, t5: T5): CurriedFunction3<T1, T3, T4, R>;
+    (t1: T1, t2: Placeholder, t3: Placeholder, t4: Placeholder, t5: T5): CurriedFunction3<T2, T3, T4, R>;
+    (t1: Placeholder, t2: Placeholder, t3: T3, t4: T4, t5: T5): CurriedFunction2<T1, T2, R>;
+    (t1: Placeholder, t2: T2, t3: Placeholder, t4: T4, t5: T5): CurriedFunction2<T1, T3, R>;
+    (t1: Placeholder, t2: T2, t3: T3, t4: Placeholder, t5: T5): CurriedFunction2<T1, T4, R>;
+    (t1: T1, t2: Placeholder, t3: Placeholder, t4: T4, t5: T5): CurriedFunction2<T2, T3, R>;
+    (t1: T1, t2: Placeholder, t3: T3, t4: Placeholder, t5: T5): CurriedFunction2<T2, T4, R>;
+    (t1: T1, t2: T2, t3: Placeholder, t4: Placeholder, t5: T5): CurriedFunction2<T3, T4, R>;
+    (t1: T1, t2: T2, t3: T3, t4: Placeholder, t5: T5): CurriedFunction1<T4, R>;
+    (t1: T1, t2: T2, t3: Placeholder, t4: T4, t5: T5): CurriedFunction1<T3, R>;
+    (t1: T1, t2: Placeholder, t3: T3, t4: T4, t5: T5): CurriedFunction1<T2, R>;
+    (t1: Placeholder, t2: T2, t3: T3, t4: T4, t5: T5): CurriedFunction1<T1, R>;
+    (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R;
+    (t1: Placeholder, t2: Placeholder, t3: Placeholder, t4: T4): CurriedFunction4<T1, T2, T3, T5, R>;
+    (t1: Placeholder, t2: Placeholder, t3: T3, t4: T4): CurriedFunction3<T1, T2, T5, R>;
+    (t1: Placeholder, t2: T2, t3: Placeholder, t4: T4): CurriedFunction3<T1, T3, T5, R>;
+    (t1: T1, t2: Placeholder, t3: Placeholder, t4: T4): CurriedFunction3<T2, T3, T5, R>;
+    (t1: T1, t2: T2, t3: Placeholder, t4: T4): CurriedFunction2<T3, T5, R>;
+    (t1: T1, t2: Placeholder, t3: T3, t4: T4): CurriedFunction2<T2, T5, R>;
+    (t1: Placeholder, t2: T2, t3: T3, t4: T4): CurriedFunction2<T1, T5, R>;
+    (t1: T1, t2: T2, t3: T3, t4: T4): CurriedFunction1<T5, R>;
+    (t1: Placeholder, t2: Placeholder, t3: T3): CurriedFunction4<T1, T2, T4, T5, R>;
+    (t1: T1, t2: Placeholder, t3: T3): CurriedFunction3<T2, T4, T5, R>;
+    (t1: Placeholder, t2: T2, t3: T3): CurriedFunction3<T1, T4, T5, R>;
+    (t1: T1, t2: T2, t3: T3): CurriedFunction2<T4, T5, R>;
+    (t1: Placeholder, t2: T2): CurriedFunction4<T1, T3, T4, T5, R>;
+    (t1: T1, t2: T2): CurriedFunction3<T3, T4, T5, R>;
+    (t1: T1): CurriedFunction4<T2, T3, T4, T5, R>;
+    (t1: Placeholder): CurriedFunction5<T1, T2, T3, T4, T5, R>;
+    (): CurriedFunction5<T1, T2, T3, T4, T5, R>;
+}
+/**
+ * 创建一个函数。该函数接受 `func` 参数，在提供的参数数量达到 `arity` 后调用 `func` 并返回其结果。
+ *
+ *  `curry._` 或 `curry.placeholder` 可用作参数的占位符。
+ *
+ * @function
+ * @alias module:Function.curry
+ * @since 1.8.0
+ * @param {Function} func 需要柯里化的函数。
+ * @param {number} [arity] 指定参数数量，默认值为 `func.length`。
+ * @returns {Function} 新的柯里化函数。
+ * @example
+ *
+ * function abc(a, b, c){
+ *   return [a, b, c];
+ * }
+ *
+ * var curried = curry(abc);
+ *
+ * curried(1)(2)(3); // [1, 2, 3]
+ *
+ * curried(1, 2)(3); // [1, 2, 3]
+ *
+ * curried(1, 2, 3); // [1, 2, 3]
+ *
+ * curried(1)(curry._, 3)(2); // [1, 2, 3]
+ *
+ * curried(curry._, curry._, 3)(curry._, 2)(1); // [1, 2, 3]
+ *
+ */
+declare const curry: Curry;
+export default curry;

package/types/debounce.d.ts

@@ -1,3 +1,4 @@
+import { FunctionAny } from './internals/types';
 /**
  * 创建一个防抖动函数，该函数会从上一次被调用后，延迟 `wait` 毫秒数后调用 `func` 方法。
  *
@@ -33,7 +34,7 @@
  * window.addEventListener('popstate', debounced.cancel);
  *
  */
-declare function debounce<T extends (...args: any[]) => any>(func: T, wait?: number, immediate?: boolean): {
+declare function debounce<T extends FunctionAny>(func: T, wait?: number, immediate?: boolean): {
     (this: any, ...args: Parameters<T>): ReturnType<T>;
     cancel: () => void;
     flush: () => ReturnType<T>;

package/types/defaultTo.d.ts

@@ -1,7 +1,11 @@
+interface DefaultTo {
+    <T>(value: T | null | undefined, defaultValue: T): T;
+    <T, D>(value: T | null | undefined, defaultValue: D): T | D;
+}
 /**
  * 检查值以确定是否应在其位置返回默认值。如果值为 `NaN` `null` 或 `undefined` ，返回 `defaultValue` 。
  *
- * @static
+ * @function
  * @alias module:Util.defaultTo
  * @since 1.0.0
  * @param {*} value 要检查的值。
@@ -16,6 +20,5 @@
  * defaultTo(null, undefined); // undefined
  *
  */
-declare function defaultTo<T>(value: T | null | undefined, defaultValue: T): T;
-declare function defaultTo<T, D>(value: T | null | undefined, defaultValue: D): T | D;
+declare const defaultTo: DefaultTo;
 export default defaultTo;

package/types/delay.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import { FunctionAny } from './internals/types';
 /**
  * 延迟 `wait` 毫秒后调用 `func` 。
  *
@@ -19,5 +20,5 @@
  * // 'hello world'
  *
  */
-declare function delay<T extends (...args: any[]) => any>(func: T, wait: number, ...args: Parameters<T>): NodeJS.Timeout;
+declare function delay<T extends FunctionAny>(this: any, func: T, wait: number, ...args: Parameters<T>): NodeJS.Timeout;
 export default delay;

package/types/every.d.ts

@@ -1,6 +1,30 @@
 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;
+interface Every {
+    <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.every
+ * @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];
+ * every(arr, item => item % 2 === 0); // false
+ * every(arr); // true
+ *
+ * const obj = { one: 1, two: 2, three: 3 };
+ * every(obj, item => item > 1); // false
+ * every(obj, item => item > 0); // true
+ */
+declare const every: Every;
 export default every;

package/types/filter.d.ts

@@ -1,6 +1,28 @@
 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]>;
+interface Filter {
+    <T>(collection: WithNullable<T[]>, predicate?: ArrayIterator<T, any>): T[];
+    (collection: WithNullable<string>, predicate?: StringIterator<any>): string[];
+    <T>(collection: WithNullable<ArrayLike<T>>, predicate?: ArrayLikeIterator<T, any>): T[];
+    <T extends object>(collection: WithNullable<T>, predicate?: ObjectIterator<T, any>): Array<T[keyof T]>;
+}
+/**
+ * 过滤集合元素，为每个元素执行 `predicate` 函数，返回真值的元素将保留在结果数组中（不改变原值）。
+ *
+ * `predicate` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ *
+ * @static
+ * @alias module:Collection.filter
+ * @since 1.7.0
+ * @param {ArrayLike<any> | Object} collection 要迭代的集合。
+ * @param {function} [predicate=identity] 每次迭代调用的函数。
+ * @returns {Array} 返回新的过滤数组。
+ * @example
+ *
+ * const arr = [1, 2, 3, 4, 5, 6];
+ * filter(arr, item => item % 2 === 0); // [2, 4, 6]
+ *
+ * const obj = { one: 1, two: 2, three: 3 };
+ * filter(obj, item => item > 1); // [2, 3]
+ */
+declare const filter: Filter;
 export default filter;

package/types/find.d.ts

@@ -1,6 +1,28 @@
 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;
+interface Find {
+    <T>(collection: WithNullable<T[]>, predicate?: ArrayIterator<T, any>): T | undefined;
+    (collection: WithNullable<string>, predicate?: StringIterator<any>): string | undefined;
+    <T>(collection: WithNullable<ArrayLike<T>>, predicate?: ArrayLikeIterator<T, any>): T | undefined;
+    <T extends object>(collection: WithNullable<T>, predicate?: ObjectIterator<T, any>): T[keyof T] | undefined;
+}
+/**
+ * 迭代集合中的元素执行 `predicate` 函数，返回第一个通过 `predicate` 返回真值的元素（停止迭代），如果都不通过返回 `undefined` 。
+ *
+ * `predicate` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ *
+ * @function
+ * @alias module:Collection.find
+ * @since 1.7.0
+ * @param {ArrayLike<any> | Object} collection 要迭代的集合。
+ * @param {function} [predicate=identity] 每次迭代调用的函数。
+ * @returns {ArrayLike<any> | Object} 返回第一个通过 `predicate` 返回真值的元素，否则返回 `undefined`。
+ * @example
+ *
+ * const arr = [1, 2, 3, 4, 5, 6];
+ * find(arr, item => item % 2 === 0); // 2
+ *
+ * const obj = { one: 1, two: 2, three: 3 };
+ * find(obj, item => item > 1); // 2
+ */
+declare const find: Find;
 export default find;

package/types/forEach.d.ts

@@ -27,10 +27,5 @@
  * // 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;
-};
+declare const forEach: import("./internals/createForEach").ForEach;
 export default forEach;

package/types/forEachRight.d.ts

@@ -27,10 +27,5 @@
  * // 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;
-};
+declare const forEachRight: import("./internals/createForEach").ForEach;
 export default forEachRight;

package/types/fromPairs.d.ts

@@ -1,3 +1,21 @@
-declare function fromPairs<P extends string | number | symbol, V = any>(array: [P, V][]): Record<P, V>;
-declare function fromPairs<P extends string | number | symbol>(array: any[][]): Record<P, any>;
+interface FromPairs {
+    <P extends string | number | symbol, V = any>(array: [P, V][]): Record<P, V>;
+    <P extends string | number | symbol>(array: any[][]): Record<P, any>;
+}
+/**
+ * 将键值对数组转为对象。
+ *
+ * 与 [Object.entries](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/entries) 正好相反。
+ *
+ * @static
+ * @alias module:Array.fromPairs
+ * @since 1.0.0
+ * @param {Array} array 键值对数组。
+ * @returns {Object} 新对象。
+ * @example
+ *
+ * fromPairs([['foo', 'bar'], ['baz', 42]]); // {foo: 'bar', baz: 42}
+ *
+ */
+declare const fromPairs: FromPairs;
 export default fromPairs;

package/types/groupBy.d.ts

@@ -1,4 +1,30 @@
 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[]>;
+interface GroupBy {
+    <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` 中每个元素后返回的结果。分组值的顺序是由他们出现在 `collection` 的顺序确定的。每个键对应的值负责生成 `key` 的元素组成的数组。
+ *
+ * `iteratee` 调用时会传入 1 个参数 `value` 。
+ *
+ * @static
+ * @alias module:Collection.groupBy
+ * @since 1.0.0
+ * @param {ArrayLike<any> | Object} collection 一个用来迭代的集合。
+ * @param {Function | string} [iteratee=identity] 迭代函数，用来转换键。
+ * @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 const groupBy: GroupBy;
 export default groupBy;

package/types/index.d.ts

@@ -44,6 +44,7 @@ export { default as some } from './some';
  */
 export { default as after } from './after';
 export { default as before } from './before';
+export { default as curry } from './curry';
 export { default as debounce } from './debounce';
 export { default as delay } from './delay';
 export { default as negate } from './negate';
@@ -61,6 +62,7 @@ export { default as isArray } from './isArray';
 export { default as isArrayBuffer } from './isArrayBuffer';
 export { default as isArrayLike } from './isArrayLike';
 export { default as isArrayLikeObject } from './isArrayLikeObject';
+export { default as isBigInt } from './isBigInt';
 export { default as isBlob } from './isBlob';
 export { default as isBoolean } from './isBoolean';
 export { default as isBuffer } from './isBuffer';
@@ -122,6 +124,7 @@ export { default as randomInt } from './randomInt';
  */
 export { default as allKeys } from './allKeys';
 export { default as allKeysIn } from './allKeysIn';
+export { default as invert } from './invert';
 export { default as keys } from './keys';
 export { default as keysIn } from './keysIn';
 export { default as merge } from './merge';
@@ -142,6 +145,7 @@ export { default as escapeRegExp } from './escapeRegExp';
 export { default as kebabCase } from './kebabCase';
 export { default as lowerCase } from './lowerCase';
 export { default as lowerFirst } from './lowerFirst';
+export { default as pascalCase } from './pascalCase';
 export { default as snakeCase } from './snakeCase';
 export { default as unescape } from './unescape';
 export { default as upperCase } from './upperCase';

package/types/internals/baseDebounce.d.ts

@@ -1,4 +1,5 @@
-declare function baseDebounce<T extends (...args: any[]) => any>(func: T, wait: number, immediate: boolean, __throttle__?: boolean): {
+import { FunctionAny } from './types';
+declare function baseDebounce<T extends FunctionAny>(func: T, wait: number, immediate: boolean, __throttle__?: boolean): {
     (this: any, ...args: Parameters<T>): ReturnType<T>;
     cancel: () => void;
     flush: () => ReturnType<T>;