ut2 1.7.2 → 1.8.1

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,7 +1,7 @@
-import { WithNullable } from './internals/types';
+import { PropertyName, WithNullable } from './internals/types';
 interface ConformsTo {
-    <T extends object, K extends keyof T>(object: T, source: Record<K, (value: T[K]) => any>): boolean;
-    <T extends WithNullable<object>>(object: T, source: Record<string | symbol, (value: any) => any>): boolean;
+    <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` 。

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/delay.d.ts

@@ -20,5 +20,5 @@ import { FunctionAny } from './internals/types';
  * // 'hello world'
  *
  */
-declare function delay<T extends FunctionAny>(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/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/compare.d.ts

@@ -1,10 +1,10 @@
 export declare function compareAsc(value: any, other: any): 0 | 1 | -1;
 export declare function compareDesc(value: any, other: any): 0 | 1 | -1;
-export type OrderData<T> = {
+export type CompareOrderData<T> = {
     criteria: any[];
     index: number;
     value: T;
 };
-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;
+export type CompareOrderBase = 'asc' | 'desc';
+export type CompareOrder = CompareOrderBase | ((a: any, b: any) => number);
+export declare function compareMultiple<T>(object: CompareOrderData<T>, other: CompareOrderData<T>, orders: CompareOrder[]): number;

package/types/internals/helpers.d.ts

@@ -9,3 +9,4 @@ export declare const supportedArgumentsType: boolean;
 export declare const FUNC_ERROR_TEXT = "Expected a function";
 export declare function toSource(func: any): string;
 export declare const stubFlase: () => boolean;
+export declare const stubTrue: () => boolean;

package/types/internals/native.d.ts

@@ -1,3 +1,6 @@
+export declare const nativeUndefined: undefined;
+export declare const stringUndefined = "undefined";
+export declare const stringObject = "object";
 export declare const objectProto: Object;
 export declare const objectProtoToString: () => string;
 export declare const objectProtoHasOwnProperty: (v: PropertyKey) => boolean;
@@ -49,6 +52,7 @@ export declare const MIN_SAFE_INTEGER: number;
  * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/length | length}
  */
 export declare const MAX_ARRAY_LENGTH = 4294967295;
+export declare const bigIntTag = "[object BigInt]";
 export declare const numberTag = "[object Number]";
 export declare const booleanTag = "[object Boolean]";
 export declare const stringTag = "[object String]";

package/types/internals/types.d.ts

@@ -4,6 +4,8 @@ export type FunctionAny = (...args: any[]) => any;
  */
 export type Many<T> = T | T[];
 export type WithNullable<T> = T | null | undefined;
+export type PropertyName = string | number | symbol;
+export type ObjectPredicate<T extends object, K extends keyof T = keyof T> = (value: T[K], key: K) => boolean;
 /**
  * 迭代参数
  */

package/types/invert.d.ts

@@ -0,0 +1,19 @@
+import { ObjectPredicate, PropertyName, WithNullable } from './internals/types';
+/**
+ * 创建一个对象，该对象由 `object` 自身可枚举属性（不包含 `Symbol` 属性）和值反转组成。
+ *
+ * @static
+ * @alias module:Object.invert
+ * @since 1.8.0
+ * @param {Object} object 来源对象。
+ * @param {Function} [predicate] 调用每一个属性的函数，返回 `truthy` 表示要反转，否则不反转。
+ * @returns {Object} 新对象。
+ * @example
+ *
+ * invert({ a: 1, b: 2 }); // { 1: 'a', 2: 'b' }
+ *
+ * invert({ a: undefined, b: null }); // { undefined: 'a', null: 'b' }
+ *
+ */
+declare function invert<T extends object>(object: WithNullable<T>, predicate?: ObjectPredicate<T>): Record<PropertyName, any>;
+export default invert;

package/types/isBigInt.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 检查值是否为 bigint 类型或对象。
+ *
+ * @static
+ * @alias module:Language.isBigInt
+ * @since 1.8.0
+ * @param {*} value 要检查的值。
+ * @returns {boolean} 如果值为 bigint 类型或对象，返回 `true` 否则返回 `false` 。
+ * @example
+ *
+ * isBigInt(0n); // true
+ *
+ * isBigInt(1n); // true
+ *
+ * isBigInt(BigInt(1)); // true
+ *
+ * isBigInt(Object(1n)); // true
+ *
+ * isBigInt(1); // false
+ */
+declare function isBigInt(value: any): value is bigint;
+export default isBigInt;

package/types/keys.d.ts

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

package/types/keysIn.d.ts

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

package/types/omit.d.ts

@@ -1,3 +1,8 @@
+import { PropertyName, WithNullable } from './internals/types';
+interface OmitFunction {
+    <T extends object, K extends keyof T>(object: WithNullable<T>, fields?: K | K[]): Omit<T, K>;
+    <T extends object, K extends PropertyName>(object: WithNullable<T>, fields?: K | K[]): Omit<T, K>;
+}
 /**
  * 创建一个对象，该对象由忽略属性之外的 `object` 自身和继承的可枚举属性组成。与 [`pick`](#.pick) 相反。
  *
@@ -21,5 +26,5 @@
  * omit(obj, ['name', 'age']); // {}
  *
  */
-declare function omit<T extends object, K extends keyof T>(object: T, fields?: K | K[]): Omit<T, K>;
+declare const omit: OmitFunction;
 export default omit;

package/types/omitBy.d.ts

@@ -1,3 +1,4 @@
+import { ObjectPredicate, WithNullable } from './internals/types';
 /**
  * 创建一个对象，该对象忽略 `predicate` （断言函数）判断不是真值的属性后，`object` 自身和继承的可枚举属性组成。与 [`pickBy`](#.pickBy) 相反。
  *
@@ -7,7 +8,7 @@
  * @alias module:Object.omitBy
  * @since 1.0.0
  * @param {Object} object 来源对象。
- * @param {Function} [predicate] 调用每一个属性的函数。
+ * @param {Function} [predicate] 调用每一个属性的函数，返回 `truthy` 表示要忽略该属性，否则不忽略。
  * @returns {Object} 新对象。
  * @example
  *
@@ -20,5 +21,5 @@
  * omitBy(obj, (value) => value); // {}
  *
  */
-declare function omitBy<T extends object>(object: T, predicate?: (value: any, key: any) => any): Partial<T>;
+declare function omitBy<T extends object>(object: WithNullable<T>, predicate?: ObjectPredicate<T>): Partial<T>;
 export default omitBy;

package/types/orderBy.d.ts

@@ -1,8 +1,8 @@
-import { Order } from './internals/compare';
+import { CompareOrder } from './internals/compare';
 import { CollectionList, CollectionObject, IterateeParam, Many } from './internals/types';
 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[];
+    <T>(collection: CollectionList<T>, iteratee?: Many<IterateeParam<T>>, orders?: Many<CompareOrder>): T[];
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: Many<IterateeParam<V>>, orders?: Many<CompareOrder>): V[];
 }
 /**
  * 创建一个元素数组，以迭代函数处理的结果排序。如果没有指定排序，默认为升序排序。

package/types/partial.d.ts

@@ -1,7 +1,7 @@
-interface PartialPlaceholder {
-    __ut2_partial__: number;
-}
-type Placeholder = PartialPlaceholder;
+declare const PLACEHOLDER: {
+    __ut2_partial_ph__: null;
+};
+type Placeholder = typeof PLACEHOLDER;
 type Function0<R> = () => R;
 type Function1<T1, R> = (t1: T1) => R;
 type Function2<T1, T2, R> = (t1: T1, t2: T2) => R;
@@ -39,7 +39,7 @@ interface Partial {
 /**
  * 创建一个函数。该函数调用 `func` ，并传入预设的 `args` 参数。
  *
- *  `partial._` 或 `partial.placeholder` 可用作部分参数的占位符。
+ *  `partial._` 或 `partial.placeholder` 可用作参数的占位符。
  *
  * @function
  * @alias module:Function.partial

package/types/pascalCase.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 转换字符串为帕斯卡写法。又名为大驼峰写法。
+ *
+ * @static
+ * @alias module:String.pascalCase
+ * @since 1.8.0
+ * @see {@link https://en.wikipedia.org/wiki/Camel_case | Camel_case}
+ * @param {string} string 要转换的字符串。
+ * @param {RegExp | string} [pattern] 拆分词组的匹配模式。
+ * @returns {string} 帕斯卡写法的字符串。
+ * @example
+ *
+ * pascalCase('foo bar'); // 'FooBar'
+ *
+ * pascalCase('foo-bar'); // 'FooBar'
+ *
+ * pascalCase('Foo Bar'); // 'FooBar'
+ *
+ * pascalCase('FOO BAR'); // 'FooBar'
+ *
+ * pascalCase('--FOO-BAR--'); // 'FooBar'
+ *
+ * pascalCase('__FOO_BAR__'); // 'FooBar'
+ *
+ */
+declare function pascalCase(string: string, pattern?: RegExp | string): string;
+export default pascalCase;

package/types/pick.d.ts

@@ -1,3 +1,8 @@
+import { PropertyName, WithNullable } from './internals/types';
+interface PickFunction {
+    <T extends object, K extends keyof T>(object: WithNullable<T>, fields?: K | K[]): Pick<T, K>;
+    <T extends object, K extends PropertyName>(object: WithNullable<T>, fields?: K | K[]): Record<PropertyName, any>;
+}
 /**
  * 创建一个从 `object` 选中的属性的对象。
  *
@@ -21,5 +26,5 @@
  * // 选取多个属性
  * pick(obj, ['name', 'age']); // { name: "jeff", age: 18 }
  */
-declare function pick<T extends object, K extends keyof T>(object: T, fields?: K | K[]): Pick<T, K>;
+declare const pick: PickFunction;
 export default pick;

package/types/pickBy.d.ts

@@ -1,3 +1,4 @@
+import { ObjectPredicate, WithNullable } from './internals/types';
 /**
  * 创建一个对象，该对象的属性从 `object` 中经 `predicate` （断言函数）判断为真值的属性。
  *
@@ -7,7 +8,7 @@
  * @alias module:Object.pickBy
  * @since 1.0.0
  * @param {Object} obj 来源对象。
- * @param {Function} [predicate] 调用每一个属性的函数。
+ * @param {Function} [predicate] 调用每一个属性的函数，返回 `truthy` 表示要提取该属性，否则不提取。
  * @returns {Object} 新对象。
  * @example
  *
@@ -20,5 +21,5 @@
  * pickBy(obj, (value) => value); // { name: "jeff", age: 18 }
  *
  */
-declare function pickBy<T extends object>(object: T, predicate?: (value: any, key: any) => any): Partial<T>;
+declare function pickBy<T extends object>(object: WithNullable<T>, predicate?: ObjectPredicate<T>): Partial<T>;
 export default pickBy;