chai 5.1.1 → 5.2.0

package/lib/chai/interface/expect.js

@@ -42,14 +42,18 @@ export {expect};
  */
 expect.fail = function (actual, expected, message, operator) {
   if (arguments.length < 2) {
-      message = actual;
-      actual = undefined;
+    message = actual;
+    actual = undefined;
   }
 
   message = message || 'expect.fail()';
-  throw new AssertionError(message, {
-      actual: actual
-    , expected: expected
-    , operator: operator
-  }, chai.expect.fail);
+  throw new AssertionError(
+    message,
+    {
+      actual: actual,
+      expected: expected,
+      operator: operator
+    },
+    chai.expect.fail
+  );
 };

package/lib/chai/interface/should.js

@@ -10,17 +10,19 @@ import {AssertionError} from 'assertion-error';
 /**
  * @returns {void}
  */
-function loadShould () {
+function loadShould() {
   // explicitly define this method as function as to have it's name to include as `ssfi`
   /**
    * @returns {Assertion}
    */
   function shouldGetter() {
-    if (this instanceof String
-        || this instanceof Number
-        || this instanceof Boolean
-        || typeof Symbol === 'function' && this instanceof Symbol
-        || typeof BigInt === 'function' && this instanceof BigInt) {
+    if (
+      this instanceof String ||
+      this instanceof Number ||
+      this instanceof Boolean ||
+      (typeof Symbol === 'function' && this instanceof Symbol) ||
+      (typeof BigInt === 'function' && this instanceof BigInt)
+    ) {
       return new Assertion(this.valueOf(), null, shouldGetter);
     }
     return new Assertion(this, null, shouldGetter);
@@ -44,9 +46,9 @@ function loadShould () {
   }
   // modify Object.prototype to have `should`
   Object.defineProperty(Object.prototype, 'should', {
-    set: shouldSetter
-    , get: shouldGetter
-    , configurable: true
+    set: shouldSetter,
+    get: shouldGetter,
+    configurable: true
   });
 
   var should = {};
@@ -74,16 +76,20 @@ function loadShould () {
    */
   should.fail = function (actual, expected, message, operator) {
     if (arguments.length < 2) {
-        message = actual;
-        actual = undefined;
+      message = actual;
+      actual = undefined;
     }
 
     message = message || 'should.fail()';
-    throw new AssertionError(message, {
-        actual: actual
-      , expected: expected
-      , operator: operator
-    }, should.fail);
+    throw new AssertionError(
+      message,
+      {
+        actual: actual,
+        expected: expected,
+        operator: operator
+      },
+      should.fail
+    );
   };
 
   /**
@@ -147,10 +153,10 @@ function loadShould () {
    */
   should.exist = function (val, msg) {
     new Assertion(val, msg).to.exist;
-  }
+  };
 
   // negation
-  should.not = {}
+  should.not = {};
 
   /**
    * ### .not.equal(actual, expected, [message])
@@ -209,13 +215,13 @@ function loadShould () {
    */
   should.not.exist = function (val, msg) {
     new Assertion(val, msg).to.not.exist;
-  }
+  };
 
   should['throw'] = should['Throw'];
   should.not['throw'] = should.not['Throw'];
 
   return should;
-};
+}
 
 export const should = loadShould;
 export const Should = loadShould;

package/lib/chai/utils/addChainableMethod.js

@@ -19,23 +19,22 @@ var canSetPrototype = typeof Object.setPrototypeOf === 'function';
 
 // Without `Object.setPrototypeOf` support, this module will need to add properties to a function.
 // However, some of functions' own props are not configurable and should be skipped.
-var testFn = function() {};
-var excludeNames = Object.getOwnPropertyNames(testFn).filter(function(name) {
+var testFn = function () {};
+var excludeNames = Object.getOwnPropertyNames(testFn).filter(function (name) {
   var propDesc = Object.getOwnPropertyDescriptor(testFn, name);
 
   // Note: PhantomJS 1.x includes `callee` as one of `testFn`'s own properties,
   // but then returns `undefined` as the property descriptor for `callee`. As a
   // workaround, we perform an otherwise unnecessary type-check for `propDesc`,
   // and then filter it out if it's not an object as it should be.
-  if (typeof propDesc !== 'object')
-    return true;
+  if (typeof propDesc !== 'object') return true;
 
   return !propDesc.configurable;
 });
 
 // Cache `Function` properties
-var call  = Function.prototype.call,
-    apply = Function.prototype.apply;
+var call = Function.prototype.call,
+  apply = Function.prototype.apply;
 
 /**
  * ### .addChainableMethod(ctx, name, method, chainingBehavior)
@@ -67,12 +66,12 @@ var call  = Function.prototype.call,
  */
 export function addChainableMethod(ctx, name, method, chainingBehavior) {
   if (typeof chainingBehavior !== 'function') {
-    chainingBehavior = function () { };
+    chainingBehavior = function () {};
   }
 
   var chainableBehavior = {
-      method: method
-    , chainingBehavior: chainingBehavior
+    method: method,
+    chainingBehavior: chainingBehavior
   };
 
   // save the methods so we can overwrite them later, if we need to.
@@ -81,67 +80,67 @@ export function addChainableMethod(ctx, name, method, chainingBehavior) {
   }
   ctx.__methods[name] = chainableBehavior;
 
-  Object.defineProperty(ctx, name,
-    { get: function chainableMethodGetter() {
-        chainableBehavior.chainingBehavior.call(this);
-
-        var chainableMethodWrapper = function () {
-          // Setting the `ssfi` flag to `chainableMethodWrapper` causes this
-          // function to be the starting point for removing implementation
-          // frames from the stack trace of a failed assertion.
-          //
-          // However, we only want to use this function as the starting point if
-          // the `lockSsfi` flag isn't set.
-          //
-          // If the `lockSsfi` flag is set, then this assertion is being
-          // invoked from inside of another assertion. In this case, the `ssfi`
-          // flag has already been set by the outer assertion.
-          //
-          // Note that overwriting a chainable method merely replaces the saved
-          // methods in `ctx.__methods` instead of completely replacing the
-          // overwritten assertion. Therefore, an overwriting assertion won't
-          // set the `ssfi` or `lockSsfi` flags.
-          if (!flag(this, 'lockSsfi')) {
-            flag(this, 'ssfi', chainableMethodWrapper);
-          }
-
-          var result = chainableBehavior.method.apply(this, arguments);
-          if (result !== undefined) {
-            return result;
-          }
-
-          var newAssertion = new Assertion();
-          transferFlags(this, newAssertion);
-          return newAssertion;
-        };
-
-        addLengthGuard(chainableMethodWrapper, name, true);
-
-        // Use `Object.setPrototypeOf` if available
-        if (canSetPrototype) {
-          // Inherit all properties from the object by replacing the `Function` prototype
-          var prototype = Object.create(this);
-          // Restore the `call` and `apply` methods from `Function`
-          prototype.call = call;
-          prototype.apply = apply;
-          Object.setPrototypeOf(chainableMethodWrapper, prototype);
+  Object.defineProperty(ctx, name, {
+    get: function chainableMethodGetter() {
+      chainableBehavior.chainingBehavior.call(this);
+
+      var chainableMethodWrapper = function () {
+        // Setting the `ssfi` flag to `chainableMethodWrapper` causes this
+        // function to be the starting point for removing implementation
+        // frames from the stack trace of a failed assertion.
+        //
+        // However, we only want to use this function as the starting point if
+        // the `lockSsfi` flag isn't set.
+        //
+        // If the `lockSsfi` flag is set, then this assertion is being
+        // invoked from inside of another assertion. In this case, the `ssfi`
+        // flag has already been set by the outer assertion.
+        //
+        // Note that overwriting a chainable method merely replaces the saved
+        // methods in `ctx.__methods` instead of completely replacing the
+        // overwritten assertion. Therefore, an overwriting assertion won't
+        // set the `ssfi` or `lockSsfi` flags.
+        if (!flag(this, 'lockSsfi')) {
+          flag(this, 'ssfi', chainableMethodWrapper);
         }
-        // Otherwise, redefine all properties (slow!)
-        else {
-          var asserterNames = Object.getOwnPropertyNames(ctx);
-          asserterNames.forEach(function (asserterName) {
-            if (excludeNames.indexOf(asserterName) !== -1) {
-              return;
-            }
-
-            var pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
-            Object.defineProperty(chainableMethodWrapper, asserterName, pd);
-          });
+
+        var result = chainableBehavior.method.apply(this, arguments);
+        if (result !== undefined) {
+          return result;
         }
 
-        transferFlags(this, chainableMethodWrapper);
-        return proxify(chainableMethodWrapper);
+        var newAssertion = new Assertion();
+        transferFlags(this, newAssertion);
+        return newAssertion;
+      };
+
+      addLengthGuard(chainableMethodWrapper, name, true);
+
+      // Use `Object.setPrototypeOf` if available
+      if (canSetPrototype) {
+        // Inherit all properties from the object by replacing the `Function` prototype
+        var prototype = Object.create(this);
+        // Restore the `call` and `apply` methods from `Function`
+        prototype.call = call;
+        prototype.apply = apply;
+        Object.setPrototypeOf(chainableMethodWrapper, prototype);
       }
-    , configurable: true
+      // Otherwise, redefine all properties (slow!)
+      else {
+        var asserterNames = Object.getOwnPropertyNames(ctx);
+        asserterNames.forEach(function (asserterName) {
+          if (excludeNames.indexOf(asserterName) !== -1) {
+            return;
+          }
+
+          var pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
+          Object.defineProperty(chainableMethodWrapper, asserterName, pd);
+        });
+      }
+
+      transferFlags(this, chainableMethodWrapper);
+      return proxify(chainableMethodWrapper);
+    },
+    configurable: true
   });
 }

package/lib/chai/utils/addLengthGuard.js

@@ -46,13 +46,26 @@ export function addLengthGuard(fn, assertionName, isChainable) {
   Object.defineProperty(fn, 'length', {
     get: function () {
       if (isChainable) {
-        throw Error('Invalid Chai property: ' + assertionName + '.length. Due' +
-          ' to a compatibility issue, "length" cannot directly follow "' +
-          assertionName + '". Use "' + assertionName + '.lengthOf" instead.');
+        throw Error(
+          'Invalid Chai property: ' +
+            assertionName +
+            '.length. Due' +
+            ' to a compatibility issue, "length" cannot directly follow "' +
+            assertionName +
+            '". Use "' +
+            assertionName +
+            '.lengthOf" instead.'
+        );
       }
 
-      throw Error('Invalid Chai property: ' + assertionName + '.length. See' +
-        ' docs for proper usage of "' + assertionName + '".');
+      throw Error(
+        'Invalid Chai property: ' +
+          assertionName +
+          '.length. See' +
+          ' docs for proper usage of "' +
+          assertionName +
+          '".'
+      );
     }
   });
 

package/lib/chai/utils/addMethod.js

@@ -54,8 +54,7 @@ export function addMethod(ctx, name, method) {
     }
 
     var result = method.apply(this, arguments);
-    if (result !== undefined)
-      return result;
+    if (result !== undefined) return result;
 
     var newAssertion = new Assertion();
     transferFlags(this, newAssertion);

package/lib/chai/utils/addProperty.js

@@ -37,35 +37,34 @@ import {transferFlags} from './transferFlags.js';
 export function addProperty(ctx, name, getter) {
   getter = getter === undefined ? function () {} : getter;
 
-  Object.defineProperty(ctx, name,
-    { get: function propertyGetter() {
-        // Setting the `ssfi` flag to `propertyGetter` causes this function to
-        // be the starting point for removing implementation frames from the
-        // stack trace of a failed assertion.
-        //
-        // However, we only want to use this function as the starting point if
-        // the `lockSsfi` flag isn't set and proxy protection is disabled.
-        //
-        // If the `lockSsfi` flag is set, then either this assertion has been
-        // overwritten by another assertion, or this assertion is being invoked
-        // from inside of another assertion. In the first case, the `ssfi` flag
-        // has already been set by the overwriting assertion. In the second
-        // case, the `ssfi` flag has already been set by the outer assertion.
-        //
-        // If proxy protection is enabled, then the `ssfi` flag has already been
-        // set by the proxy getter.
-        if (!isProxyEnabled() && !flag(this, 'lockSsfi')) {
-          flag(this, 'ssfi', propertyGetter);
-        }
+  Object.defineProperty(ctx, name, {
+    get: function propertyGetter() {
+      // Setting the `ssfi` flag to `propertyGetter` causes this function to
+      // be the starting point for removing implementation frames from the
+      // stack trace of a failed assertion.
+      //
+      // However, we only want to use this function as the starting point if
+      // the `lockSsfi` flag isn't set and proxy protection is disabled.
+      //
+      // If the `lockSsfi` flag is set, then either this assertion has been
+      // overwritten by another assertion, or this assertion is being invoked
+      // from inside of another assertion. In the first case, the `ssfi` flag
+      // has already been set by the overwriting assertion. In the second
+      // case, the `ssfi` flag has already been set by the outer assertion.
+      //
+      // If proxy protection is enabled, then the `ssfi` flag has already been
+      // set by the proxy getter.
+      if (!isProxyEnabled() && !flag(this, 'lockSsfi')) {
+        flag(this, 'ssfi', propertyGetter);
+      }
 
-        var result = getter.call(this);
-        if (result !== undefined)
-          return result;
+      var result = getter.call(this);
+      if (result !== undefined) return result;
 
-        var newAssertion = new Assertion();
-        transferFlags(this, newAssertion);
-        return newAssertion;
-      }
-    , configurable: true
+      var newAssertion = new Assertion();
+      transferFlags(this, newAssertion);
+      return newAssertion;
+    },
+    configurable: true
   });
 }

package/lib/chai/utils/expectTypes.js

@@ -28,19 +28,27 @@ export function expectTypes(obj, types) {
   flagMsg = flagMsg ? flagMsg + ': ' : '';
 
   obj = flag(obj, 'object');
-  types = types.map(function (t) { return t.toLowerCase(); });
+  types = types.map(function (t) {
+    return t.toLowerCase();
+  });
   types.sort();
 
   // Transforms ['lorem', 'ipsum'] into 'a lorem, or an ipsum'
-  var str = types.map(function (t, index) {
-    var art = ~[ 'a', 'e', 'i', 'o', 'u' ].indexOf(t.charAt(0)) ? 'an' : 'a';
-    var or = types.length > 1 && index === types.length - 1 ? 'or ' : '';
-    return or + art + ' ' + t;
-  }).join(', ');
+  var str = types
+    .map(function (t, index) {
+      var art = ~['a', 'e', 'i', 'o', 'u'].indexOf(t.charAt(0)) ? 'an' : 'a';
+      var or = types.length > 1 && index === types.length - 1 ? 'or ' : '';
+      return or + art + ' ' + t;
+    })
+    .join(', ');
 
   var objType = type(obj).toLowerCase();
 
-  if (!types.some(function (expected) { return objType === expected; })) {
+  if (
+    !types.some(function (expected) {
+      return objType === expected;
+    })
+  ) {
     throw new AssertionError(
       flagMsg + 'object tested must be ' + str + ', but ' + objType + ' given',
       undefined,

package/lib/chai/utils/getMessage.js

@@ -28,19 +28,25 @@ import {objDisplay} from './objDisplay.js';
  * @public
  */
 export function getMessage(obj, args) {
-  var negate = flag(obj, 'negate')
-    , val = flag(obj, 'object')
-    , expected = args[3]
-    , actual = getActual(obj, args)
-    , msg = negate ? args[2] : args[1]
-    , flagMsg = flag(obj, 'message');
+  var negate = flag(obj, 'negate'),
+    val = flag(obj, 'object'),
+    expected = args[3],
+    actual = getActual(obj, args),
+    msg = negate ? args[2] : args[1],
+    flagMsg = flag(obj, 'message');
 
-  if(typeof msg === "function") msg = msg();
+  if (typeof msg === 'function') msg = msg();
   msg = msg || '';
   msg = msg
-    .replace(/#\{this\}/g, function () { return objDisplay(val); })
-    .replace(/#\{act\}/g, function () { return objDisplay(actual); })
-    .replace(/#\{exp\}/g, function () { return objDisplay(expected); });
+    .replace(/#\{this\}/g, function () {
+      return objDisplay(val);
+    })
+    .replace(/#\{act\}/g, function () {
+      return objDisplay(actual);
+    })
+    .replace(/#\{exp\}/g, function () {
+      return objDisplay(expected);
+    });
 
   return flagMsg ? flagMsg + ': ' + msg : msg;
 }

package/lib/chai/utils/index.js

@@ -11,7 +11,8 @@ import * as checkError from 'check-error';
 export {test} from './test.js';
 
 // type utility
-export {type} from './type-detect.js';
+import {type} from './type-detect.js';
+export {type};
 
 // expectTypes utility
 export {expectTypes} from './expectTypes.js';
@@ -47,7 +48,7 @@ export {getPathInfo, hasProperty} from 'pathval';
  * @returns {string}
  */
 export function getName(fn) {
-  return fn.name
+  return fn.name;
 }
 
 // add Property
@@ -105,3 +106,13 @@ export {getOperator} from './getOperator.js';
 export function isRegExp(obj) {
   return Object.prototype.toString.call(obj) === '[object RegExp]';
 }
+
+/**
+ * Determines if an object is numeric or not
+ *
+ * @param {unknown} obj Object to test
+ * @returns {boolean}
+ */
+export function isNumeric(obj) {
+  return ['Number', 'BigInt'].includes(type(obj));
+}

package/lib/chai/utils/inspect.js

@@ -23,9 +23,9 @@ import {config} from '../config.js';
 export function inspect(obj, showHidden, depth, colors) {
   var options = {
     colors: colors,
-    depth: (typeof depth === 'undefined' ? 2 : depth),
+    depth: typeof depth === 'undefined' ? 2 : depth,
     showHidden: showHidden,
-    truncate: config.truncateThreshold ? config.truncateThreshold : Infinity,
+    truncate: config.truncateThreshold ? config.truncateThreshold : Infinity
   };
   return _inspect(obj, options);
 }

package/lib/chai/utils/isNaN.js

@@ -4,23 +4,4 @@
  * MIT Licensed
  */
 
-/**
- * ### .isNaN(value)
- *
- * Checks if the given value is NaN or not.
- *
- *     utils.isNaN(NaN); // true
- *
- * @param {unknown} value The value which has to be checked if it is NaN
- * @returns {boolean}
- * @name isNaN
- * @private
- */
-function _isNaN(value) {
-  // Refer http://www.ecma-international.org/ecma-262/6.0/#sec-isnan-number
-  // section's NOTE.
-  return value !== value;
-}
-
-// If ECMAScript 6's Number.isNaN is present, prefer that.
-export const isNaN = Number.isNaN || _isNaN;
+export const isNaN = Number.isNaN;

package/lib/chai/utils/isProxyEnabled.js

@@ -18,7 +18,9 @@ import {config} from '../config.js';
  * @returns {boolean}
  */
 export function isProxyEnabled() {
-  return config.useProxy &&
+  return (
+    config.useProxy &&
     typeof Proxy !== 'undefined' &&
-    typeof Reflect !== 'undefined';
+    typeof Reflect !== 'undefined'
+  );
 }

package/lib/chai/utils/objDisplay.js

@@ -21,8 +21,8 @@ import {config} from '../config.js';
  * @public
  */
 export function objDisplay(obj) {
-  var str = inspect(obj)
-    , type = Object.prototype.toString.call(obj);
+  var str = inspect(obj),
+    type = Object.prototype.toString.call(obj);
 
   if (config.truncateThreshold && str.length >= config.truncateThreshold) {
     if (type === '[object Function]') {
@@ -32,10 +32,11 @@ export function objDisplay(obj) {
     } else if (type === '[object Array]') {
       return '[ Array(' + obj.length + ') ]';
     } else if (type === '[object Object]') {
-      var keys = Object.keys(obj)
-        , kstr = keys.length > 2
-          ? keys.splice(0, 2).join(', ') + ', ...'
-          : keys.join(', ');
+      var keys = Object.keys(obj),
+        kstr =
+          keys.length > 2
+            ? keys.splice(0, 2).join(', ') + ', ...'
+            : keys.join(', ');
       return '{ Object (' + kstr + ') }';
     } else {
       return str;

package/lib/chai/utils/overwriteChainableMethod.js

@@ -43,16 +43,17 @@ export function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
   var chainableBehavior = ctx.__methods[name];
 
   var _chainingBehavior = chainableBehavior.chainingBehavior;
-  chainableBehavior.chainingBehavior = function overwritingChainableMethodGetter() {
-    var result = chainingBehavior(_chainingBehavior).call(this);
-    if (result !== undefined) {
-      return result;
-    }
+  chainableBehavior.chainingBehavior =
+    function overwritingChainableMethodGetter() {
+      var result = chainingBehavior(_chainingBehavior).call(this);
+      if (result !== undefined) {
+        return result;
+      }
 
-    var newAssertion = new Assertion();
-    transferFlags(this, newAssertion);
-    return newAssertion;
-  };
+      var newAssertion = new Assertion();
+      transferFlags(this, newAssertion);
+      return newAssertion;
+    };
 
   var _method = chainableBehavior.method;
   chainableBehavior.method = function overwritingChainableMethodWrapper() {

package/lib/chai/utils/overwriteMethod.js

@@ -44,13 +44,12 @@ import {transferFlags} from './transferFlags.js';
  * @public
  */
 export function overwriteMethod(ctx, name, method) {
-  var _method = ctx[name]
-    , _super = function () {
+  var _method = ctx[name],
+    _super = function () {
       throw new Error(name + ' is not a function');
     };
 
-  if (_method && 'function' === typeof _method)
-    _super = _method;
+  if (_method && 'function' === typeof _method) _super = _method;
 
   var overwritingMethodWrapper = function () {
     // Setting the `ssfi` flag to `overwritingMethodWrapper` causes this
@@ -84,7 +83,7 @@ export function overwriteMethod(ctx, name, method) {
     var newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
-  }
+  };
 
   addLengthGuard(overwritingMethodWrapper, name, false);
   ctx[name] = proxify(overwritingMethodWrapper, name);