ut2 1.20.1 → 1.21.0

package/es/equalArrayLike.js

@@ -1,19 +1,5 @@
-import eq from './eq.js';
-import isArrayLike from './isArrayLike.js';
+import shallowEqual from './shallowEqual.js';
 
-function equalArrayLike(arg1, arg2, strictCheck) {
-    if (strictCheck === void 0) { strictCheck = true; }
-    if (eq(arg1, arg2, strictCheck))
-        return true;
-    if (!isArrayLike(arg1) || !isArrayLike(arg2))
-        return false;
-    if (arg1.length !== arg2.length)
-        return false;
-    for (var i = 0; i < arg1.length; i++) {
-        if (!eq(arg1[i], arg2[i], strictCheck))
-            return false;
-    }
-    return true;
-}
+var equalArrayLike = shallowEqual;
 
 export { equalArrayLike as default };

package/es/index.js

@@ -136,6 +136,7 @@ export { default as nthArg } from './nthArg.js';
 export { default as range } from './range.js';
 export { default as retry } from './retry.js';
 export { default as sleep } from './sleep.js';
+export { default as shallowEqual } from './shallowEqual.js';
 export { default as times } from './times.js';
 export { default as toFinite } from './toFinite.js';
 export { default as toInteger } from './toInteger.js';

package/es/internals/helpers.js

@@ -2,7 +2,7 @@ import isObjectLike from '../isObjectLike.js';
 import getTag from './getTag.js';
 import { argumentsTag, functionProtoToString, stringUndefined } from './native.js';
 
-var VERSION = "1.20.1";
+var VERSION = "1.21.0";
 var isBrowser = typeof window !== stringUndefined && isObjectLike(window) && typeof document !== stringUndefined && isObjectLike(document) && window.document === document;
 var supportedArgumentsType = getTag((function () { return arguments; })()) === argumentsTag;
 var FUNC_ERROR_TEXT = 'Expected a function';

package/es/memoize.js

@@ -1,10 +1,10 @@
-import equalArrayLike from './equalArrayLike.js';
+import shallowEqual from './shallowEqual.js';
 import { mathCeil } from './internals/native.js';
 
 function memoize(func, options) {
     var opts = options || {};
     var max = mathCeil(opts.max || 0);
-    var isEqual = typeof opts.isEqual === 'function' ? opts.isEqual : equalArrayLike;
+    var isEqual = typeof opts.isEqual === 'function' ? opts.isEqual : shallowEqual;
     var cache = [];
     function memoized() {
         var _this = this;

package/es/shallowEqual.js

@@ -0,0 +1,26 @@
+import eq from './eq.js';
+import { objectProtoHasOwnProperty } from './internals/native.js';
+
+function shallowEqual(objA, objB, strictCheck) {
+    if (strictCheck === void 0) { strictCheck = true; }
+    if (eq(objA, objB, strictCheck)) {
+        return true;
+    }
+    if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+        return false;
+    }
+    var keysA = Object.keys(objA);
+    var keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    for (var i = 0; i < keysA.length; i++) {
+        var key = keysA[i];
+        if (!objectProtoHasOwnProperty.call(objB, key) || !eq(objA[key], objB[key], strictCheck)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export { shallowEqual as default };

package/lib/equalArrayLike.js

@@ -1,21 +1,7 @@
 'use strict';
 
-var eq = require('./eq.js');
-var isArrayLike = require('./isArrayLike.js');
+var shallowEqual = require('./shallowEqual.js');
 
-function equalArrayLike(arg1, arg2, strictCheck) {
-    if (strictCheck === void 0) { strictCheck = true; }
-    if (eq(arg1, arg2, strictCheck))
-        return true;
-    if (!isArrayLike(arg1) || !isArrayLike(arg2))
-        return false;
-    if (arg1.length !== arg2.length)
-        return false;
-    for (var i = 0; i < arg1.length; i++) {
-        if (!eq(arg1[i], arg2[i], strictCheck))
-            return false;
-    }
-    return true;
-}
+var equalArrayLike = shallowEqual;
 
 module.exports = equalArrayLike;

package/lib/index.js

@@ -138,6 +138,7 @@ var nthArg = require('./nthArg.js');
 var range = require('./range.js');
 var retry = require('./retry.js');
 var sleep = require('./sleep.js');
+var shallowEqual = require('./shallowEqual.js');
 var times = require('./times.js');
 var toFinite = require('./toFinite.js');
 var toInteger = require('./toInteger.js');
@@ -292,6 +293,7 @@ exports.nthArg = nthArg;
 exports.range = range;
 exports.retry = retry;
 exports.sleep = sleep;
+exports.shallowEqual = shallowEqual;
 exports.times = times;
 exports.toFinite = toFinite;
 exports.toInteger = toInteger;

package/lib/internals/helpers.js

@@ -4,7 +4,7 @@ var isObjectLike = require('../isObjectLike.js');
 var getTag = require('./getTag.js');
 var native = require('./native.js');
 
-var VERSION = "1.20.1";
+var VERSION = "1.21.0";
 var isBrowser = typeof window !== native.stringUndefined && isObjectLike(window) && typeof document !== native.stringUndefined && isObjectLike(document) && window.document === document;
 var supportedArgumentsType = getTag((function () { return arguments; })()) === native.argumentsTag;
 var FUNC_ERROR_TEXT = 'Expected a function';

package/lib/memoize.js

@@ -1,12 +1,12 @@
 'use strict';
 
-var equalArrayLike = require('./equalArrayLike.js');
+var shallowEqual = require('./shallowEqual.js');
 var native = require('./internals/native.js');
 
 function memoize(func, options) {
     var opts = options || {};
     var max = native.mathCeil(opts.max || 0);
-    var isEqual = typeof opts.isEqual === 'function' ? opts.isEqual : equalArrayLike;
+    var isEqual = typeof opts.isEqual === 'function' ? opts.isEqual : shallowEqual;
     var cache = [];
     function memoized() {
         var _this = this;

package/lib/shallowEqual.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var eq = require('./eq.js');
+var native = require('./internals/native.js');
+
+function shallowEqual(objA, objB, strictCheck) {
+    if (strictCheck === void 0) { strictCheck = true; }
+    if (eq(objA, objB, strictCheck)) {
+        return true;
+    }
+    if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+        return false;
+    }
+    var keysA = Object.keys(objA);
+    var keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    for (var i = 0; i < keysA.length; i++) {
+        var key = keysA[i];
+        if (!native.objectProtoHasOwnProperty.call(objB, key) || !eq(objA[key], objB[key], strictCheck)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+module.exports = shallowEqual;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ut2",
-  "version": "1.20.1",
+  "version": "1.21.0",
   "author": "caijf",
   "license": "MIT",
   "main": "lib/index.js",

package/types/equalArrayLike.d.ts

@@ -1,37 +1,11 @@
+import shallowEqual from './shallowEqual';
 /**
  * 比较两个类数组的值是否相等。常用于参数对象比较。
  *
- * 1. 如果两个值相等，返回 `true`。
- * 2. 如果两个类数组 `length` 相等，且遍历每个值都相等，则返回 `true`。
- * 3. 否则返回 `false`。
- *
+ * @deprecated 即将废弃，请使用 `shallowEqual` 替代。
+ * @private
  * @alias module:Util.equalArrayLike
  * @since 1.18.0
- * @param {Array} arg1 类数组1。
- * @param {Array} arg2 类数组2。
- * @param {boolean} [strictCheck=true] 严格比较，如果为 `true` 表示区分 `0` 和 `-0`。默认 `true`。
- * @returns 是否相等。
- * @example
- * equalArrayLike([1, 2], [1, 2]); // true
- * equalArrayLike([1, 2], [1, 3]); // false
- * equalArrayLike([1, 2], [1, 2, 3]); // false
- *
- * // 松散比较
- * equalArrayLike(['a', 'b'], 'ab'); // true
- * equalArrayLike(['a', 'b'], { 0: 'a', 1: 'b', length: 2 }); // true
- *
- * // 两个相等值返回 true
- * equalArrayLike(NaN, NaN); // true
- * equalArrayLike(null, null); // true
- * equalArrayLike(undefined, undefined); // true
- * const obj1 = {};
- * const obj2 = obj1;
- * equalArrayLike(obj1, obj2); // true
- *
- * // 0 和 -0 严格比较返回 false
- * equalArrayLike([0, -0], [-0, 0]); // false
- * // 非严格比较返回 true
- * equalArrayLike([0, -0], [-0, 0], false); // true
  */
-declare function equalArrayLike(arg1: ArrayLike<any>, arg2: ArrayLike<any>, strictCheck?: boolean): boolean;
+declare const equalArrayLike: typeof shallowEqual;
 export default equalArrayLike;

package/types/index.d.ts

@@ -190,6 +190,7 @@ export { default as nthArg } from './nthArg';
 export { default as range } from './range';
 export { default as retry } from './retry';
 export { default as sleep } from './sleep';
+export { default as shallowEqual } from './shallowEqual';
 export { default as times } from './times';
 export { default as toFinite } from './toFinite';
 export { default as toInteger } from './toInteger';

package/types/memoize.d.ts

@@ -10,7 +10,7 @@ type EqualFn<TFunc extends (...args: any[]) => any> = (newArgs: Parameters<TFunc
  * @since 1.17.0
  * @param {Function} func 要缓存结果的函数。
  * @param {Object} [options] 配置项。
- * @param {Function} [options.isEqual] 自定义比较参数方法。默认函数 `equalArrayLike`。
+ * @param {Function} [options.isEqual] 自定义比较参数方法。默认函数 `shallowEqual`。
  * @param {number} [options.max] 最大缓存数量，`0`表示不限制。默认`0`。
  * @returns 缓存 `func` 结果的函数。
  * @example

package/types/shallowEqual.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 浅比较两个值是否相等。常用于参数对象比较。
+ *
+ * 1. 如果两个值相等，返回 `true`。
+ * 2. 如果两个对象属性数量相等，且遍历每个属性值都相等，则返回 `true`。
+ * 3. 否则返回 `false`。
+ *
+ * @alias module:Util.shallowEqual
+ * @since 1.21.0
+ * @param {Array} objA 要比较的值。。
+ * @param {Array} objB 另一个要比较的值。
+ * @param {boolean} [strictCheck=true] 严格比较，如果为 `true` 表示区分 `0` 和 `-0`。默认 `true`。
+ * @returns 浅比较两个值是否相等。
+ * @example
+ * shallowEqual({ a: 1, b: 2 }, { a: 1, b: 2 }); // true
+ * shallowEqual({ a: 1, b: 2 }, { a: 1, b: 3 }); // false
+ *
+ * shallowEqual([1, 2], [1, 2]); // true
+ * shallowEqual([1, 2], [1, 3]); // false
+ * shallowEqual([1, 2], [1, 2, 3]); // false
+ *
+ * // 两个相等值返回 true
+ * shallowEqual(1, 1); // true
+ * shallowEqual('foo', 'foo'); // true
+ * shallowEqual(NaN, NaN); // true
+ * shallowEqual(null, null); // true
+ * shallowEqual(undefined, undefined); // true
+ * const obj1 = {};
+ * const obj2 = obj1;
+ * shallowEqual(obj1, obj2); // true
+ *
+ * // 默认严格比较，区分 0 和 -0
+ * shallowEqual([0, -0], [-0, 0]); // false
+ *
+ * // 非严格比较，不区分 0 和 -0
+ * shallowEqual([0, -0], [-0, 0], false); // true
+ */
+declare function shallowEqual(objA: any, objB: any, strictCheck?: boolean): boolean;
+export default shallowEqual;