lib: simplify isDeepStrictEqual options handling

Author: miguelmarcondesf

doc/api/util.md

@@ -1565,16 +1565,15 @@ changes:
 
 * `val1` {any}
 * `val2` {any}
-* `options` {Object}
-  * `skipPrototypeComparison` {boolean} If `true`, prototype and constructor
-    comparison is skipped during deep strict equality check. **Default:** `false`.
+* `skipPrototypeComparison` {boolean} If `true`, prototype and constructor
+  comparison is skipped during deep strict equality check. **Default:** `false`.
 * Returns: {boolean}
 
 Returns `true` if there is deep strict equality between `val1` and `val2`.
 Otherwise, returns `false`.
 
 By default, deep strict equality includes comparison of object prototypes and
-constructors. When `options.skipPrototypeComparison` is `true`, objects with
+constructors. When `skipPrototypeComparison` is `true`, objects with
 different prototypes or constructors can still be considered equal if their
 enumerable properties are deeply strictly equal.
 
@@ -1600,7 +1599,7 @@ const bar = new Bar(1);
 console.log(util.isDeepStrictEqual(foo, bar));
 // false
 
-console.log(util.isDeepStrictEqual(foo, bar, { skipPrototypeComparison: true }));
+console.log(util.isDeepStrictEqual(foo, bar, true));
 // true
 ```
 

lib/assert.js

@@ -313,10 +313,7 @@ Assert.prototype.deepStrictEqual = function deepStrictEqual(actual, expected, me
     throw new ERR_MISSING_ARGS('actual', 'expected');
   }
   if (isDeepEqual === undefined) lazyLoadComparison();
-  if (!isDeepStrictEqual(actual, expected, {
-    __proto__: null,
-    skipPrototypeComparison: this?.[kOptions]?.skipPrototypeComparison,
-  })) {
+  if (!isDeepStrictEqual(actual, expected, this?.[kOptions]?.skipPrototypeComparison)) {
     innerFail({
       actual,
       expected,
@@ -342,10 +339,7 @@ function notDeepStrictEqual(actual, expected, message) {
     throw new ERR_MISSING_ARGS('actual', 'expected');
   }
   if (isDeepEqual === undefined) lazyLoadComparison();
-  if (isDeepStrictEqual(actual, expected, {
-    __proto__: null,
-    skipPrototypeComparison: this?.[kOptions]?.skipPrototypeComparison,
-  })) {
+  if (isDeepStrictEqual(actual, expected, this?.[kOptions]?.skipPrototypeComparison)) {
     innerFail({
       actual,
       expected,

lib/internal/util/comparisons.js

@@ -1028,8 +1028,8 @@ module.exports = {
   isDeepEqual(val1, val2) {
     return detectCycles(val1, val2, kLoose);
   },
-  isDeepStrictEqual(val1, val2, options) {
-    if (options?.skipPrototypeComparison) {
+  isDeepStrictEqual(val1, val2, skipPrototypeComparison) {
+    if (skipPrototypeComparison) {
       return detectCycles(val1, val2, kStrictWithoutPrototypes);
     }
     return detectCycles(val1, val2, kStrict);

lib/util.js

@@ -487,11 +487,11 @@ module.exports = {
   isArray: deprecate(ArrayIsArray,
                      'The `util.isArray` API is deprecated. Please use `Array.isArray()` instead.',
                      'DEP0044'),
-  isDeepStrictEqual(a, b, options) {
+  isDeepStrictEqual(a, b, skipPrototypeComparison) {
     if (internalDeepEqual === undefined) {
       internalDeepEqual = require('internal/util/comparisons').isDeepStrictEqual;
     }
-    return internalDeepEqual(a, b, options);
+    return internalDeepEqual(a, b, skipPrototypeComparison);
   },
   promisify,
   stripVTControlCharacters,

test/parallel/test-util-isDeepStrictEqual.js

@@ -94,9 +94,9 @@ function notUtilIsDeepStrict(a, b) {
   utilIsDeepStrict(a, b);
 }
 
-// Handle `skipPrototypeComparison` option for isDeepStrictEqual
+// Handle `skipPrototypeComparison` for isDeepStrictEqual
 {
-  test('util.isDeepStrictEqual with skipPrototypeComparison option', () => {
+  test('util.isDeepStrictEqual with skipPrototypeComparison', () => {
     function ClassA(value) { this.value = value; }
 
     function ClassB(value) { this.value = value; }
@@ -105,22 +105,22 @@ function notUtilIsDeepStrict(a, b) {
     const objB = new ClassB(42);
 
     assert.strictEqual(util.isDeepStrictEqual(objA, objB), false);
-    assert.strictEqual(util.isDeepStrictEqual(objA, objB, { skipPrototypeComparison: true }), true);
+    assert.strictEqual(util.isDeepStrictEqual(objA, objB, true), true);
 
     const objC = new ClassB(99);
-    assert.strictEqual(util.isDeepStrictEqual(objA, objC, { skipPrototypeComparison: true }), false);
+    assert.strictEqual(util.isDeepStrictEqual(objA, objC, true), false);
 
     const nestedA = { obj: new ClassA('test'), num: 123 };
     const nestedB = { obj: new ClassB('test'), num: 123 };
 
     assert.strictEqual(util.isDeepStrictEqual(nestedA, nestedB), false);
-    assert.strictEqual(util.isDeepStrictEqual(nestedA, nestedB, { skipPrototypeComparison: true }), true);
+    assert.strictEqual(util.isDeepStrictEqual(nestedA, nestedB, true), true);
 
     const uint8Array = new Uint8Array([1, 2, 3]);
     const buffer = Buffer.from([1, 2, 3]);
 
     assert.strictEqual(util.isDeepStrictEqual(uint8Array, buffer), false);
-    assert.strictEqual(util.isDeepStrictEqual(uint8Array, buffer, { skipPrototypeComparison: true }), true);
+    assert.strictEqual(util.isDeepStrictEqual(uint8Array, buffer, true), true);
   });
 
   test('util.isDeepStrictEqual skipPrototypeComparison with complex scenarios', () => {
@@ -135,24 +135,23 @@ function notUtilIsDeepStrict(a, b) {
     const legacyParent = new LegacyParent(1);
 
     assert.strictEqual(util.isDeepStrictEqual(modernParent, legacyParent), false);
-    assert.strictEqual(util.isDeepStrictEqual(modernParent, legacyParent, { skipPrototypeComparison: true }), true);
+    assert.strictEqual(util.isDeepStrictEqual(modernParent, legacyParent, true), true);
 
     const modern = new Child(1, 2);
     const legacy = new LegacyChild(1, 2);
 
     assert.strictEqual(util.isDeepStrictEqual(modern, legacy), false);
-    assert.strictEqual(util.isDeepStrictEqual(modern, legacy, { skipPrototypeComparison: true }), true);
+    assert.strictEqual(util.isDeepStrictEqual(modern, legacy, true), true);
 
     const literal = { name: 'test', values: [1, 2, 3] };
     function Constructor(name, values) { this.name = name; this.values = values; }
     const constructed = new Constructor('test', [1, 2, 3]);
 
     assert.strictEqual(util.isDeepStrictEqual(literal, constructed), false);
-    assert.strictEqual(util.isDeepStrictEqual(literal, constructed, { skipPrototypeComparison: true }), true);
+    assert.strictEqual(util.isDeepStrictEqual(literal, constructed, true), true);
 
-    assert.strictEqual(util.isDeepStrictEqual(literal, constructed, {}), false);
-    assert.strictEqual(util.isDeepStrictEqual(literal, constructed, { skipPrototypeComparison: false }), false);
-    assert.strictEqual(util.isDeepStrictEqual(literal, constructed, { skipPrototypeComparison: null }), false);
-    assert.strictEqual(util.isDeepStrictEqual(literal, constructed, { skipPrototypeComparison: undefined }), false);
+    assert.strictEqual(util.isDeepStrictEqual(literal, constructed, false), false);
+    assert.strictEqual(util.isDeepStrictEqual(literal, constructed, null), false);
+    assert.strictEqual(util.isDeepStrictEqual(literal, constructed, undefined), false);
   });
 }