chai 5.1.0 → 5.1.1

package/README.md

@@ -98,9 +98,9 @@ import { expect, use } from 'chai';  // Creates local variables `expect` and `us
 ### Usage with Mocha
 
 ```bash
-mocha spec.js -r chai/register-assert  # Using Assert style
-mocha spec.js -r chai/register-expect  # Using Expect style
-mocha spec.js -r chai/register-should  # Using Should style
+mocha spec.js --require chai/register-assert.js  # Using Assert style
+mocha spec.js --require chai/register-expect.js  # Using Expect style
+mocha spec.js --require chai/register-should.js  # Using Should style
 ```
 
 [Read more about these styles in our docs](http://chaijs.com/guide/styles/).

package/chai.js

@@ -38,6 +38,7 @@ __export(utils_exports, {
   inspect: () => inspect2,
   isNaN: () => isNaN2,
   isProxyEnabled: () => isProxyEnabled,
+  isRegExp: () => isRegExp2,
   objDisplay: () => objDisplay,
   overwriteChainableMethod: () => overwriteChainableMethod,
   overwriteMethod: () => overwriteMethod,
@@ -57,14 +58,22 @@ __export(check_error_exports, {
   getConstructorName: () => getConstructorName,
   getMessage: () => getMessage
 });
+function isErrorInstance(obj) {
+  return obj instanceof Error || Object.prototype.toString.call(obj) === "[object Error]";
+}
+__name(isErrorInstance, "isErrorInstance");
+function isRegExp(obj) {
+  return Object.prototype.toString.call(obj) === "[object RegExp]";
+}
+__name(isRegExp, "isRegExp");
 function compatibleInstance(thrown, errorLike) {
-  return errorLike instanceof Error && thrown === errorLike;
+  return isErrorInstance(errorLike) && thrown === errorLike;
 }
 __name(compatibleInstance, "compatibleInstance");
 function compatibleConstructor(thrown, errorLike) {
-  if (errorLike instanceof Error) {
+  if (isErrorInstance(errorLike)) {
     return thrown.constructor === errorLike.constructor || thrown instanceof errorLike.constructor;
-  } else if (errorLike.prototype instanceof Error || errorLike === Error) {
+  } else if ((typeof errorLike === "object" || typeof errorLike === "function") && errorLike.prototype) {
     return thrown.constructor === errorLike || thrown instanceof errorLike;
   }
   return false;
@@ -72,7 +81,7 @@ function compatibleConstructor(thrown, errorLike) {
 __name(compatibleConstructor, "compatibleConstructor");
 function compatibleMessage(thrown, errMatcher) {
   const comparisonString = typeof thrown === "string" ? thrown : thrown.message;
-  if (errMatcher instanceof RegExp) {
+  if (isRegExp(errMatcher)) {
     return errMatcher.test(comparisonString);
   } else if (typeof errMatcher === "string") {
     return comparisonString.indexOf(errMatcher) !== -1;
@@ -82,7 +91,7 @@ function compatibleMessage(thrown, errMatcher) {
 __name(compatibleMessage, "compatibleMessage");
 function getConstructorName(errorLike) {
   let constructorName = errorLike;
-  if (errorLike instanceof Error) {
+  if (isErrorInstance(errorLike)) {
     constructorName = errorLike.constructor.name;
   } else if (typeof errorLike === "function") {
     constructorName = errorLike.name;
@@ -805,8 +814,8 @@ var config = {
    *
    *     chai.config.includeStack = true;  // enable stack on error
    *
-   * @param {Boolean}
-   * @api public
+   * @param {boolean}
+   * @public
    */
   includeStack: false,
   /**
@@ -818,8 +827,8 @@ var config = {
    * will be true when the assertion has requested a diff
    * be shown.
    *
-   * @param {Boolean}
-   * @api public
+   * @param {boolean}
+   * @public
    */
   showDiff: true,
   /**
@@ -838,8 +847,8 @@ var config = {
    *
    *     chai.config.truncateThreshold = 0;  // disable truncating
    *
-   * @param {Number}
-   * @api public
+   * @param {number}
+   * @public
    */
   truncateThreshold: 40,
   /**
@@ -856,8 +865,8 @@ var config = {
    * This feature is automatically disabled regardless of this config value
    * in environments that don't support proxies.
    *
-   * @param {Boolean}
-   * @api public
+   * @param {boolean}
+   * @public
    */
   useProxy: true,
   /**
@@ -875,7 +884,7 @@ var config = {
    *     chai.config.proxyExcludedKeys = ['then', 'inspect'];
    *
    * @param {Array}
-   * @api public
+   * @public
    */
   proxyExcludedKeys: ["then", "catch", "inspect", "toJSON"],
   /**
@@ -887,18 +896,18 @@ var config = {
    *
    *     // use a custom comparator
    *     chai.config.deepEqual = (expected, actual) => {
-   *        return chai.util.eql(expected, actual, {
-   *           comparator: (expected, actual) => {
-   *              // for non number comparison, use the default behavior
-   *              if(typeof expected !== 'number') return null;
-   *              // allow a difference of 10 between compared numbers
-   *              return typeof actual === 'number' && Math.abs(actual - expected) < 10
-   *           }
-   *        })
+   *         return chai.util.eql(expected, actual, {
+   *             comparator: (expected, actual) => {
+   *                 // for non number comparison, use the default behavior
+   *                 if(typeof expected !== 'number') return null;
+   *                 // allow a difference of 10 between compared numbers
+   *                 return typeof actual === 'number' && Math.abs(actual - expected) < 10
+   *             }
+   *         })
    *     };
    *
    * @param {Function}
-   * @api public
+   * @public
    */
   deepEqual: null
 };
@@ -1809,6 +1818,10 @@ function getName(fn) {
   return fn.name;
 }
 __name(getName, "getName");
+function isRegExp2(obj) {
+  return Object.prototype.toString.call(obj) === "[object RegExp]";
+}
+__name(isRegExp2, "isRegExp");
 
 // lib/chai/core/assertions.js
 var { flag: flag2 } = utils_exports;
@@ -2659,14 +2672,16 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
     flag2(this, "message", msg);
   var obj = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), negate = flag2(this, "negate") || false;
   new Assertion(obj, flagMsg, ssfi, true).is.a("function");
-  if (errorLike instanceof RegExp || typeof errorLike === "string") {
+  if (isRegExp2(errorLike) || typeof errorLike === "string") {
     errMsgMatcher = errorLike;
     errorLike = null;
   }
-  var caughtErr;
+  let caughtErr;
+  let errorWasThrown = false;
   try {
     obj();
   } catch (err) {
+    errorWasThrown = true;
     caughtErr = err;
   }
   var everyArgIsUndefined = errorLike === void 0 && errMsgMatcher === void 0;
@@ -2680,12 +2695,23 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
     } else if (errorLike) {
       errorLikeString = check_error_exports.getConstructorName(errorLike);
     }
+    let actual = caughtErr;
+    if (caughtErr instanceof Error) {
+      actual = caughtErr.toString();
+    } else if (typeof caughtErr === "string") {
+      actual = caughtErr;
+    } else if (caughtErr && (typeof caughtErr === "object" || typeof caughtErr === "function")) {
+      try {
+        actual = check_error_exports.getConstructorName(caughtErr);
+      } catch (_err) {
+      }
+    }
     this.assert(
-      caughtErr,
+      errorWasThrown,
       "expected #{this} to throw " + errorLikeString,
       "expected #{this} to not throw an error but #{act} was thrown",
       errorLike && errorLike.toString(),
-      caughtErr instanceof Error ? caughtErr.toString() : typeof caughtErr === "string" ? caughtErr : caughtErr && check_error_exports.getConstructorName(caughtErr)
+      actual
     );
   }
   if (errorLike && caughtErr) {
@@ -2722,7 +2748,7 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
   }
   if (caughtErr && errMsgMatcher !== void 0 && errMsgMatcher !== null) {
     var placeholder = "including";
-    if (errMsgMatcher instanceof RegExp) {
+    if (isRegExp2(errMsgMatcher)) {
       placeholder = "matching";
     }
     var isCompatibleMessage = check_error_exports.compatibleMessage(caughtErr, errMsgMatcher);
@@ -3126,8 +3152,8 @@ function loadShould() {
       operator
     }, should2.fail);
   };
-  should2.equal = function(val1, val2, msg) {
-    new Assertion(val1, msg).to.equal(val2);
+  should2.equal = function(actual, expected, message) {
+    new Assertion(actual, message).to.equal(expected);
   };
   should2.Throw = function(fn, errt, errs, msg) {
     new Assertion(fn, msg).to.Throw(errt, errs);
@@ -3136,8 +3162,8 @@ function loadShould() {
     new Assertion(val, msg).to.exist;
   };
   should2.not = {};
-  should2.not.equal = function(val1, val2, msg) {
-    new Assertion(val1, msg).to.not.equal(val2);
+  should2.not.equal = function(actual, expected, msg) {
+    new Assertion(actual, msg).to.not.equal(expected);
   };
   should2.not.Throw = function(fn, errt, errs, msg) {
     new Assertion(fn, msg).to.not.Throw(errt, errs);
@@ -3248,8 +3274,8 @@ assert.isNotNull = function(val, msg) {
 assert.isNaN = function(val, msg) {
   new Assertion(val, msg, assert.isNaN, true).to.be.NaN;
 };
-assert.isNotNaN = function(val, msg) {
-  new Assertion(val, msg, assert.isNotNaN, true).not.to.be.NaN;
+assert.isNotNaN = function(value, message) {
+  new Assertion(value, message, assert.isNotNaN, true).not.to.be.NaN;
 };
 assert.exists = function(val, msg) {
   new Assertion(val, msg, assert.exists, true).to.exist;
@@ -3263,11 +3289,11 @@ assert.isUndefined = function(val, msg) {
 assert.isDefined = function(val, msg) {
   new Assertion(val, msg, assert.isDefined, true).to.not.equal(void 0);
 };
-assert.isCallable = function(val, msg) {
-  new Assertion(val, msg, assert.isCallable, true).is.callable;
+assert.isCallable = function(value, message) {
+  new Assertion(value, message, assert.isCallable, true).is.callable;
 };
-assert.isNotCallable = function(val, msg) {
-  new Assertion(val, msg, assert.isNotCallable, true).is.not.callable;
+assert.isNotCallable = function(value, message) {
+  new Assertion(value, message, assert.isNotCallable, true).is.not.callable;
 };
 assert.isObject = function(val, msg) {
   new Assertion(val, msg, assert.isObject, true).to.be.a("object");
@@ -3305,8 +3331,8 @@ assert.isNotBoolean = function(val, msg) {
 assert.typeOf = function(val, type3, msg) {
   new Assertion(val, msg, assert.typeOf, true).to.be.a(type3);
 };
-assert.notTypeOf = function(val, type3, msg) {
-  new Assertion(val, msg, assert.notTypeOf, true).to.not.be.a(type3);
+assert.notTypeOf = function(value, type3, message) {
+  new Assertion(value, message, assert.notTypeOf, true).to.not.be.a(type3);
 };
 assert.instanceOf = function(val, type3, msg) {
   new Assertion(val, msg, assert.instanceOf, true).to.be.instanceOf(type3);
@@ -3451,12 +3477,12 @@ assert.throws = function(fn, errorLike, errMsgMatcher, msg) {
   var assertErr = new Assertion(fn, msg, assert.throws, true).to.throw(errorLike, errMsgMatcher);
   return flag(assertErr, "object");
 };
-assert.doesNotThrow = function(fn, errorLike, errMsgMatcher, msg) {
+assert.doesNotThrow = function(fn, errorLike, errMsgMatcher, message) {
   if ("string" === typeof errorLike || errorLike instanceof RegExp) {
     errMsgMatcher = errorLike;
     errorLike = null;
   }
-  new Assertion(fn, msg, assert.doesNotThrow, true).to.not.throw(errorLike, errMsgMatcher);
+  new Assertion(fn, message, assert.doesNotThrow, true).to.not.throw(errorLike, errMsgMatcher);
 };
 assert.operator = function(val, operator, val2, msg) {
   var ok;

package/eslint.config.js

@@ -0,0 +1,12 @@
+import jsdoc from "eslint-plugin-jsdoc";
+
+export default [
+  jsdoc.configs["flat/recommended"],
+  {
+    rules: {
+      "jsdoc/require-param-description": "off",
+      "jsdoc/require-returns-description": "off",
+      "jsdoc/tag-lines": ["error", "any", { startLines: 1 }],
+    },
+  },
+];

package/lib/chai/assertion.js

@@ -18,37 +18,37 @@ import * as util from './utils/index.js';
  * be assigned during instantiation by passing arguments to this constructor:
  *
  * - `object`: This flag contains the target of the assertion. For example, in
- *   the assertion `expect(numKittens).to.equal(7);`, the `object` flag will
- *   contain `numKittens` so that the `equal` assertion can reference it when
- *   needed.
+ * the assertion `expect(numKittens).to.equal(7);`, the `object` flag will
+ * contain `numKittens` so that the `equal` assertion can reference it when
+ * needed.
  *
  * - `message`: This flag contains an optional custom error message to be
- *   prepended to the error message that's generated by the assertion when it
- *   fails.
+ * prepended to the error message that's generated by the assertion when it
+ * fails.
  *
  * - `ssfi`: This flag stands for "start stack function indicator". It
- *   contains a function reference that serves as the starting point for
- *   removing frames from the stack trace of the error that's created by the
- *   assertion when it fails. The goal is to provide a cleaner stack trace to
- *   end users by removing Chai's internal functions. Note that it only works
- *   in environments that support `Error.captureStackTrace`, and only when
- *   `Chai.config.includeStack` hasn't been set to `false`.
+ * contains a function reference that serves as the starting point for
+ * removing frames from the stack trace of the error that's created by the
+ * assertion when it fails. The goal is to provide a cleaner stack trace to
+ * end users by removing Chai's internal functions. Note that it only works
+ * in environments that support `Error.captureStackTrace`, and only when
+ * `Chai.config.includeStack` hasn't been set to `false`.
  *
  * - `lockSsfi`: This flag controls whether or not the given `ssfi` flag
- *   should retain its current value, even as assertions are chained off of
- *   this object. This is usually set to `true` when creating a new assertion
- *   from within another assertion. It's also temporarily set to `true` before
- *   an overwritten assertion gets called by the overwriting assertion.
+ * should retain its current value, even as assertions are chained off of
+ * this object. This is usually set to `true` when creating a new assertion
+ * from within another assertion. It's also temporarily set to `true` before
+ * an overwritten assertion gets called by the overwriting assertion.
  *
  * - `eql`: This flag contains the deepEqual function to be used by the assertion.
  *
- * @param {Mixed} obj target of the assertion
- * @param {String} msg (optional) custom error message
+ * @param {unknown} obj target of the assertion
+ * @param {string} msg (optional) custom error message
  * @param {Function} ssfi (optional) starting point for removing stack frames
- * @param {Boolean} lockSsfi (optional) whether or not the ssfi flag is locked
- * @api private
+ * @param {boolean} lockSsfi (optional) whether or not the ssfi flag is locked
+ * @returns {unknown}
+ * @private
  */
-
 export function Assertion (obj, msg, ssfi, lockSsfi) {
   util.flag(this, 'ssfi', ssfi || Assertion);
   util.flag(this, 'lockSsfi', lockSsfi);
@@ -111,13 +111,13 @@ Assertion.overwriteChainableMethod = function (name, fn, chainingBehavior) {
  * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.
  *
  * @name assert
- * @param {Philosophical} expression to be tested
- * @param {String|Function} message or function that returns message to display if expression fails
- * @param {String|Function} negatedMessage or function that returns negatedMessage to display if negated expression fails
- * @param {Mixed} expected value (remember to check for negation)
- * @param {Mixed} actual (optional) will default to `this.obj`
- * @param {Boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails
- * @api private
+ * @param {unknown} expression to be tested
+ * @param {string | Function} message or function that returns message to display if expression fails
+ * @param {string | Function} negatedMessage or function that returns negatedMessage to display if negated expression fails
+ * @param {unknown} expected value (remember to check for negation)
+ * @param {unknown} actual (optional) will default to `this.obj`
+ * @param {boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails
+ * @private
  */
 
 Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) {
@@ -152,7 +152,7 @@ Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual,
  *
  * Quick reference to stored `actual` value for plugin developers.
  *
- * @api private
+ * @private
  */
 Object.defineProperty(Assertion.prototype, '_obj',
   { get: function () {

package/lib/chai/config.js

@@ -9,10 +9,9 @@ export const config = {
    *
    *     chai.config.includeStack = true;  // enable stack on error
    *
-   * @param {Boolean}
-   * @api public
+   * @param {boolean}
+   * @public
    */
-
   includeStack: false,
 
   /**
@@ -24,10 +23,9 @@ export const config = {
    * will be true when the assertion has requested a diff
    * be shown.
    *
-   * @param {Boolean}
-   * @api public
+   * @param {boolean}
+   * @public
    */
-
   showDiff: true,
 
   /**
@@ -46,10 +44,9 @@ export const config = {
    *
    *     chai.config.truncateThreshold = 0;  // disable truncating
    *
-   * @param {Number}
-   * @api public
+   * @param {number}
+   * @public
    */
-
   truncateThreshold: 40,
 
   /**
@@ -66,10 +63,9 @@ export const config = {
    * This feature is automatically disabled regardless of this config value
    * in environments that don't support proxies.
    *
-   * @param {Boolean}
-   * @api public
+   * @param {boolean}
+   * @public
    */
-
   useProxy: true,
 
   /**
@@ -87,9 +83,8 @@ export const config = {
    *     chai.config.proxyExcludedKeys = ['then', 'inspect'];
    *
    * @param {Array}
-   * @api public
+   * @public
    */
-
   proxyExcludedKeys: ['then', 'catch', 'inspect', 'toJSON'],
 
   /**
@@ -101,20 +96,19 @@ export const config = {
    *
    *     // use a custom comparator
    *     chai.config.deepEqual = (expected, actual) => {
-   *        return chai.util.eql(expected, actual, {
-   *           comparator: (expected, actual) => {
-   *              // for non number comparison, use the default behavior
-   *              if(typeof expected !== 'number') return null;
-   *              // allow a difference of 10 between compared numbers
-   *              return typeof actual === 'number' && Math.abs(actual - expected) < 10
-   *           }
-   *        })
+   *         return chai.util.eql(expected, actual, {
+   *             comparator: (expected, actual) => {
+   *                 // for non number comparison, use the default behavior
+   *                 if(typeof expected !== 'number') return null;
+   *                 // allow a difference of 10 between compared numbers
+   *                 return typeof actual === 'number' && Math.abs(actual - expected) < 10
+   *             }
+   *         })
    *     };
    *
    * @param {Function}
-   * @api public
+   * @public
    */
-
   deepEqual: null
 
 };