ut2 1.1.3 → 1.2.1

package/types/intersection.d.ts

@@ -1,14 +1,17 @@
 /**
- * 创建唯一值的数组，该数组包含 2 个数组参数都包含的元素（交集）。使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
+ * 创建唯一值的数组，该数组包含 2 个数组参数都包含的元素（交集）。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
  *
  * `iteratee` 调用时会传入 1 个参数 `value` 。
  *
+ * 默认使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。如果 `strictCheck=true` 将使用 [`SameValue`](https://tc39.es/ecma262/#sec-samevalue) 做等值比较。
+ *
  * @static
  * @alias module:Array.intersection
  * @since 1.0.0
  * @param {Array} array 要检查的数组。
  * @param {Array} other 另一个要检查的数组。
  * @param {Function | string} [iteratee] 迭代函数，调用每个元素。
+ * @param {boolean} [strictCheck=false] 严格比较，区分 `+0` `-0`。
  * @returns {Array} 包含所有传入数组交集元素的新数组。
  * @example
  *
@@ -21,6 +24,10 @@
  * // 迭代函数可以直接写入属性。
  * intersection([{x: 1}, {x: 1}, {x: 2}, {x: 2}], [{x: 1}], 'x'); // [{x: 1}]
  *
+ * intersection([-0, 0], [0]); // [-0]
+ *
+ * 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): T[];
+declare function intersection<T, F extends (value: T) => any, K extends keyof T>(array: T[], other: T[], iteratee?: F | K, strictCheck?: boolean): T[];
 export default intersection;

package/types/isArrayLikeObject.d.ts

@@ -8,13 +8,13 @@
  * @returns {boolean} 如果值为类数组对象，返回 `true` ，否则返回 `false` 。
  * @example
  *
- * isArrayLike([1, 2, 3]); // true
+ * isArrayLikeObject([1, 2, 3]); // true
  *
- * isArrayLike(document.body.children); // true
+ * isArrayLikeObject(document.body.children); // true
  *
- * isArrayLike('abc'); // false
+ * isArrayLikeObject('abc'); // false
  *
- * isArrayLike(()=>{}); // false
+ * isArrayLikeObject(()=>{}); // false
  *
  */
 declare function isArrayLikeObject(value: any): boolean;

package/types/isBuffer.d.ts

@@ -11,7 +11,7 @@
  * @returns {boolean} 如果值为 `buffer` ，返回 `true` ，否则返回 `false` 。
  * @example
  *
- * isBuffer(new Blob(['a'])); // true
+ * isBuffer(new Buffer(2)); // true
  *
  * isBuffer({}); // false
  *

package/types/isDataView.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 检查值是否为 `DataView` 对象。
+ *
+ * @static
+ * @alias module:Type.isDataView
+ * @since 1.2.0
+ * @param {*} value 要检查的值。
+ * @returns {boolean} 如果值为 `DataView` 对象，返回 `true` ，否则返回 `false` 。
+ * @example
+ *
+ * isDataView(new DataView(new ArrayBuffer(8))); // true
+ *
+ */
+declare function isDataView(value: any): boolean;
+export default isDataView;

package/types/isPlainObject.d.ts

@@ -14,11 +14,11 @@
  *
  * isPlainObject(new Foo); // false
  *
- * isObject([1,2,3]); // false
+ * isPlainObject([1,2,3]); // false
  *
- * isObject({ a: 1, b: 2 }); // true
+ * isPlainObject({ a: 1, b: 2 }); // true
  *
- * isObject(Object.create(null)); // true
+ * isPlainObject(Object.create(null)); // true
  *
  */
 declare function isPlainObject(value: any): boolean;

package/types/isTypedArray.d.ts

@@ -9,9 +9,9 @@
  * @returns {boolean} 如果值为类型化数组，返回 `true` ，否则返回 `false` 。
  * @example
  *
- * ut2.isTypedArray(new Uint8Array); // true
+ * isTypedArray(new Uint8Array); // true
  *
- * ut2.isTypedArray([]); // false
+ * isTypedArray([]); // false
  *
  */
 declare function isTypedArray(value: any): boolean;

package/types/kebabCase.d.ts

@@ -6,7 +6,7 @@
  * @since 1.0.0
  * @see {@link https://en.wikipedia.org/wiki/Letter_case#Special_case_styles | kebab case}
  * @param {string} string 要转换的字符串。
- * @param {RegExp|string} [pattern] 拆分词组的匹配模式。
+ * @param {RegExp | string} [pattern] 拆分词组的匹配模式。
  * @returns {string} 转换后的字符串。
  * @example
  *

package/types/keyBy.d.ts

@@ -7,7 +7,7 @@
  * @alias module:Collection.keyBy
  * @since 1.0.0
  * @param {Array} collection 一个用来迭代的集合。
- * @param {Function|string} [iteratee] 迭代函数，用来转换键。
+ * @param {Function | string} [iteratee] 迭代函数，用来转换键。
  * @returns {Object} 组成聚合对象。
  * @example
  *

package/types/lowerCase.d.ts

@@ -5,7 +5,7 @@
  * @alias module:String.lowerCase
  * @since 1.0.0
  * @param {string} string 要转换的字符串。
- * @param {RegExp|string} [pattern] 拆分词组的匹配模式。
+ * @param {RegExp | string} [pattern] 拆分词组的匹配模式。
  * @returns {string} 小写字符串。
  * @example
  *

package/types/merge.d.ts

@@ -7,8 +7,8 @@ type Customizer = (objValue: any, srcValue: any, key: string | symbol, object: a
  * @static
  * @alias module:Object.merge
  * @since 1.0.0
- * @param {Object|Array} object 目标对象。
- * @param {Object|Array} source 来源对象。
+ * @param {Object | Array} object 目标对象。
+ * @param {Object | Array} source 来源对象。
  * @param {Function} [customizer] 自定义赋值函数。
  * @returns {Object} 目标对象。
  * @example

package/types/omit.d.ts

@@ -5,7 +5,7 @@
  * @alias module:Object.omit
  * @since 1.0.0
  * @param {Object} object 来源对象。
- * @param {string|string[]} [fields] 要被忽略的属性。
+ * @param {string | string[]} [fields] 要被忽略的属性。
  * @returns {Object} 新对象。
  * @example
  *

package/types/once.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 创建一个只能调用 `func` 一次的函数。重复调用将返回第一次调用 `func` 的结果。
+ *
+ * @static
+ * @alias module:Function.once
+ * @since 1.2.0
+ * @requires module:Function.before
+ * @param {Function} func 限制执行的函数。
+ * @returns {Function} 新的限定函数。
+ * @example
+ *
+ * let count = 0;
+ *
+ * const increment = _.once(()=>{
+ *   return ++count;
+ * });
+ *
+ * increment(); // 1
+ * increment(); // 1
+ * increment(); // 1
+ *
+ */
+declare function once<T extends (...args: any[]) => any>(func: T): T;
+export default once;

package/types/orderBy.d.ts

@@ -11,8 +11,8 @@ import { Order } from './internals/compare';
  * @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] 迭代函数的排序顺序。
+ * @param {Function | string | Array} [iteratees] 排序的迭代函数。
+ * @param {'asc' | 'desc' | Array} [orders] 迭代函数的排序顺序。
  * @returns {Array} 排序后的新数组。
  * @example
  *

package/types/partition.d.ts

@@ -7,7 +7,7 @@
  * @alias module:Collection.partition
  * @since 1.0.0
  * @param {Array} collection 一个用来迭代的集合。
- * @param {Function|string} [predicate=identity] 每次迭代调用的断言函数。
+ * @param {Function | string} [predicate=identity] 每次迭代调用的断言函数。
  * @returns {Array} 分组后的数组。
  * @example
  *

package/types/pick.d.ts

@@ -7,7 +7,7 @@
  * @alias module:Object.pick
  * @since 1.0.0
  * @param {Object} object 来源对象。
- * @param {string|string[]} [fields] 选中的属性。
+ * @param {string | string[]} [fields] 选中的属性。
  * @returns {Object} 新对象。
  * @example
  *

package/types/snakeCase.d.ts

@@ -6,7 +6,7 @@
  * @since 1.0.0
  * @see {@link https://en.wikipedia.org/wiki/Snake_case | snake case}
  * @param {string} string 要转换的字符串。
- * @param {RegExp|string} [pattern] 拆分词组的匹配模式。
+ * @param {RegExp | string} [pattern] 拆分词组的匹配模式。
  * @returns {string} 转换后的字符串。
  * @example
  *

package/types/toFinite.d.ts

@@ -8,21 +8,21 @@
  * @returns {number} 转换后的数字。
  * @example
  *
- * toSafeInteger(3.2); // 3.2
+ * toFinite(3.2); // 3.2
  *
- * toSafeInteger('3.2'); // 3.2
+ * toFinite('3.2'); // 3.2
  *
- * toSafeInteger(-0); // -0
+ * toFinite(-0); // -0
  *
- * toSafeInteger('-0'); // -0
+ * toFinite('-0'); // -0
  *
- * toSafeInteger('0'); // 0
+ * toFinite('0'); // 0
  *
- * toSafeInteger(NaN); // 0
+ * toFinite(NaN); // 0
  *
- * toSafeInteger(Infinity); // 1.7976931348623157e+308
+ * toFinite(Infinity); // 1.7976931348623157e+308
  *
- * toSafeInteger(-Infinity); // -1.7976931348623157e+308
+ * toFinite(-Infinity); // -1.7976931348623157e+308
  *
  */
 declare function toFinite(value: any): number;

package/types/union.d.ts

@@ -1,14 +1,17 @@
 /**
- * 创建一个按顺序排列的唯一值的数组（并集）。使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。与 [`uniq`](#.uniq) 相似。
+ * 创建一个按顺序排列的唯一值的数组（并集）。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。与 [`uniq`](#.uniq) 相似。
  *
  * `iteratee` 调用时会传入 1 个参数 `value` 。
  *
+ * 默认使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。如果 `strictCheck=true` 将使用 [`SameValue`](https://tc39.es/ecma262/#sec-samevalue) 做等值比较。
+ *
  * @static
  * @alias module:Array.union
  * @since 1.0.0
  * @param {Array} array 要检查的数组。
  * @param {Array} [other=[]] 另一个要检查的数组。
  * @param {Function | string} [iteratee] 迭代函数，调用每个元素。
+ * @param {boolean} [strictCheck=false] 严格比较，区分 `+0` `-0`。
  * @returns {Array} 新的联合数组。
  * @example
  *
@@ -16,11 +19,15 @@
  *
  * union([2.1], [1.2, 2.3], Math.floor); // [2.1, 1.2]
  *
- * intersection([{x: 1}, {x: 1}, {x: 2}, {x: 2}], [{x: 1}], item=>item.x); // [{x: 1}, {x: 2}]
+ * union([{x: 1}, {x: 1}, {x: 2}, {x: 2}], [{x: 1}], item=>item.x); // [{x: 1}, {x: 2}]
  *
  * // 迭代函数可以直接写入属性。
- * intersection([{x: 1}, {x: 1}, {x: 2}, {x: 2}], [{x: 1}], 'x'); // [{x: 1}, {x: 2}]
+ * union([{x: 1}, {x: 1}, {x: 2}, {x: 2}], [{x: 1}], 'x'); // [{x: 1}, {x: 2}]
+ *
+ * union([-0, 0], [-0]); // [-0]
+ *
+ * union([-0, 0], [-0], undefined, true); // [-0, 0]
  *
  */
-declare function union<T, F extends (value: T) => any, K extends keyof T>(array: T[], other?: T[], iteratee?: F | K): T[];
+declare function union<T, F extends (value: T) => any, K extends keyof T>(array: T[], other?: T[], iteratee?: F | K, strickCheck?: boolean): T[];
 export default union;

package/types/uniq.d.ts

@@ -1,13 +1,16 @@
 /**
- * 创建一个去重后的数组副本。使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。只有第一次出现的元素才会被保留。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
+ * 创建一个去重后的数组副本。只有第一次出现的元素才会被保留。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
  *
  * `iteratee` 调用时会传入 1 个参数 `value` 。
  *
+ * 默认使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。如果 `strictCheck=true` 将使用 [`SameValue`](https://tc39.es/ecma262/#sec-samevalue) 做等值比较。
+ *
  * @static
  * @alias module:Array.uniq
  * @since 1.0.0
- * @param {Array}  array 要检查的数组。
+ * @param {Array} array 要检查的数组。
  * @param {Function | string} [iteratee] 迭代函数，调用每个元素。
+ * @param {boolean} [strictCheck=false] 严格比较，区分 `+0` `-0`。
  * @returns {Array} 去重后的新数组。
  * @example
  *
@@ -20,6 +23,10 @@
  * // 迭代函数可以直接写入属性。
  * uniq([{x: 1}, {x: 2}, {x: 1}], 'x'); // [{x: 1}, {x: 2}]
  *
+ * uniq([-0, 0]); // [-0]
+ *
+ * uniq([-0, 0], undefined, true); // [-0, 0]
+ *
  */
-declare function uniq<T, F extends (value: T) => any, K extends keyof T>(array: T[], iteratee?: F | K): T[];
+declare function uniq<T, F extends (value: T) => any, K extends keyof T>(array: T[], iteratee?: F | K, strickCheck?: boolean): T[];
 export default uniq;

package/types/upperCase.d.ts

@@ -5,7 +5,7 @@
  * @alias module:String.upperCase
  * @since 1.0.0
  * @param {string} string 要转换的字符串。
- * @param {RegExp|string} [pattern] 拆分词组的匹配模式。
+ * @param {RegExp | string} [pattern] 拆分词组的匹配模式。
  * @returns {string} 大写字符串。
  * @example
  *

package/types/words.d.ts

@@ -6,7 +6,7 @@
  * @since 1.0.0
  * @see {@link https://zh.wikipedia.org/wiki/ASCII | ASCII}
  * @param {string} string 要拆分的字符串。
- * @param {RegExp|string} [pattern=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g] 匹配模式。
+ * @param {RegExp | string} [pattern=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g] 匹配模式。
  * @returns {string[]} 拆分后的数组。
  * @example
  *

package/types/xor.d.ts

@@ -1,26 +1,33 @@
 /**
- * 创建一个唯一值的数组（并集-交集），该数组包含 2 个数组参数中不相同的元素。使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
+ * 创建一个唯一值的数组（并集-交集），该数组包含 2 个数组参数中不相同的元素。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
  *
  * `iteratee` 调用时会传入 1 个参数 `value` 。
  *
+ * 默认使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。如果 `strictCheck=true` 将使用 [`SameValue`](https://tc39.es/ecma262/#sec-samevalue) 做等值比较。
+ *
  * @static
  * @alias module:Array.xor
  * @since 1.0.0
  * @param {Array} array 要检查的数组。
  * @param {Array} [other=[]] 另一个要检查的数组。
  * @param {Function | string} [iteratee] 迭代函数，调用每个元素。
+ * @param {boolean} [strictCheck=false] 严格比较，区分 `+0` `-0`。
  * @returns {Array} 过滤值后的新数组。
  * @example
  *
- * intersection([2, 1, 1], [4, 2]); // [1, 4]
+ * xor([2, 1, 1], [4, 2]); // [1, 4]
  *
- * intersection([2.1, 1.2], [4.3, 2.4], Math.floor); // [1.2, 4.3]
+ * xor([2.1, 1.2], [4.3, 2.4], Math.floor); // [1.2, 4.3]
  *
- * intersection([{x: 1}, {x: 1}, {x: 2}, {x: 2}], [{x: 1}], item=>item.x); // [{x: 2}]
+ * xor([{x: 1}, {x: 1}, {x: 2}, {x: 2}], [{x: 1}], item=>item.x); // [{x: 2}]
  *
  * // 迭代函数可以直接写入属性。
- * intersection([{x: 1}, {x: 1}, {x: 2}, {x: 2}], [{x: 1}], 'x'); // [{x: 2}]
+ * xor([{x: 1}, {x: 1}, {x: 2}, {x: 2}], [{x: 1}], 'x'); // [{x: 2}]
+ *
+ * xor([-0, 0],[0]); // []
+ *
+ * xor([-0, 0],[0], undefined, true); // [-0]
  *
  */
-declare function xor<T, F extends (value: T) => any, K extends keyof T>(array: T[], other?: T[], iteratee?: F | K): T[];
+declare function xor<T, F extends (value: T) => any, K extends keyof T>(array: T[], other?: T[], iteratee?: F | K, strickCheck?: boolean): T[];
 export default xor;