chai 5.0.3 → 5.1.1

package/lib/chai/interface/expect.js

@@ -8,11 +8,17 @@ import * as chai from '../../../index.js';
 import {Assertion} from '../assertion.js';
 import {AssertionError} from 'assertion-error';
 
+/**
+ * @param {unknown} val
+ * @param {string} message
+ * @returns {Assertion}
+ */
 function expect(val, message) {
   return new Assertion(val, message);
 }
 
 export {expect};
+
 /**
  * ### .fail([message])
  * ### .fail(actual, expected, [message], [operator])
@@ -27,14 +33,13 @@ export {expect};
  *     expect.fail(1, 2, undefined, ">");
  *
  * @name fail
- * @param {Mixed} actual
- * @param {Mixed} expected
- * @param {String} message
- * @param {String} operator
- * @namespace BDD
- * @api public
+ * @param {unknown} actual
+ * @param {unknown} expected
+ * @param {string} message
+ * @param {string} operator
+ * @namespace expect
+ * @public
  */
-
 expect.fail = function (actual, expected, message, operator) {
   if (arguments.length < 2) {
       message = actual;

package/lib/chai/interface/should.js

@@ -7,8 +7,14 @@
 import {Assertion} from '../assertion.js';
 import {AssertionError} from 'assertion-error';
 
+/**
+ * @returns {void}
+ */
 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
@@ -19,6 +25,9 @@ function loadShould () {
     }
     return new Assertion(this, null, shouldGetter);
   }
+  /**
+   * @param {unknown} value
+   */
   function shouldSetter(value) {
     // See https://github.com/chaijs/chai/issues/86: this makes
     // `whatever.should = someValue` actually set `someValue`, which is
@@ -55,16 +64,14 @@ function loadShould () {
    *     should.fail(1, 2, "custom error message", ">");
    *     should.fail(1, 2, undefined, ">");
    *
-   *
    * @name fail
-   * @param {Mixed} actual
-   * @param {Mixed} expected
-   * @param {String} message
-   * @param {String} operator
+   * @param {unknown} actual
+   * @param {unknown} expected
+   * @param {string} message
+   * @param {string} operator
    * @namespace BDD
-   * @api public
+   * @public
    */
-
   should.fail = function (actual, expected, message, operator) {
     if (arguments.length < 2) {
         message = actual;
@@ -87,15 +94,14 @@ function loadShould () {
    *     should.equal(3, '3', '== coerces values to strings');
    *
    * @name equal
-   * @param {Mixed} actual
-   * @param {Mixed} expected
-   * @param {String} message
+   * @param {unknown} actual
+   * @param {unknown} expected
+   * @param {string} message
    * @namespace Should
-   * @api public
+   * @public
    */
-
-  should.equal = function (val1, val2, msg) {
-    new Assertion(val1, msg).to.equal(val2);
+  should.equal = function (actual, expected, message) {
+    new Assertion(actual, message).to.equal(expected);
   };
 
   /**
@@ -113,15 +119,14 @@ function loadShould () {
    *
    * @name throw
    * @alias Throw
-   * @param {Function} function
-   * @param {ErrorConstructor} constructor
-   * @param {RegExp} regexp
-   * @param {String} message
+   * @param {Function} fn
+   * @param {Error} errt
+   * @param {RegExp} errs
+   * @param {string} msg
    * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
    * @namespace Should
-   * @api public
+   * @public
    */
-
   should.Throw = function (fn, errt, errs, msg) {
     new Assertion(fn, msg).to.Throw(errt, errs);
   };
@@ -132,14 +137,14 @@ function loadShould () {
    * Asserts that the target is neither `null` nor `undefined`.
    *
    *     var foo = 'hi';
-   *
    *     should.exist(foo, 'foo exists');
    *
+   * @param {unknown} val
+   * @param {string} msg
    * @name exist
    * @namespace Should
-   * @api public
+   * @public
    */
-
   should.exist = function (val, msg) {
     new Assertion(val, msg).to.exist;
   }
@@ -155,15 +160,14 @@ function loadShould () {
    *     should.not.equal(3, 4, 'these numbers are not equal');
    *
    * @name not.equal
-   * @param {Mixed} actual
-   * @param {Mixed} expected
-   * @param {String} message
+   * @param {unknown} actual
+   * @param {unknown} expected
+   * @param {string} msg
    * @namespace Should
-   * @api public
+   * @public
    */
-
-  should.not.equal = function (val1, val2, msg) {
-    new Assertion(val1, msg).to.not.equal(val2);
+  should.not.equal = function (actual, expected, msg) {
+    new Assertion(actual, msg).to.not.equal(expected);
   };
 
   /**
@@ -177,15 +181,14 @@ function loadShould () {
    *
    * @name not.throw
    * @alias not.Throw
-   * @param {Function} function
-   * @param {ErrorConstructor} constructor
-   * @param {RegExp} regexp
-   * @param {String} message
+   * @param {Function} fn
+   * @param {Error} errt
+   * @param {RegExp} errs
+   * @param {string} msg
    * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
    * @namespace Should
-   * @api public
+   * @public
    */
-
   should.not.Throw = function (fn, errt, errs, msg) {
     new Assertion(fn, msg).to.not.Throw(errt, errs);
   };
@@ -196,14 +199,14 @@ function loadShould () {
    * Asserts that the target is neither `null` nor `undefined`.
    *
    *     var bar = null;
-   *
    *     should.not.exist(bar, 'bar does not exist');
    *
-   * @name not.exist
    * @namespace Should
-   * @api public
+   * @name not.exist
+   * @param {unknown} val
+   * @param {string} msg
+   * @public
    */
-
   should.not.exist = function (val, msg) {
     new Assertion(val, msg).to.not.exist;
   }

package/lib/chai/utils/addChainableMethod.js

@@ -4,17 +4,13 @@
  * MIT Licensed
  */
 
-/*!
- * Module dependencies
- */
-
 import {Assertion} from '../assertion.js';
 import {addLengthGuard} from './addLengthGuard.js';
 import {flag} from './flag.js';
 import {proxify} from './proxify.js';
 import {transferFlags} from './transferFlags.js';
 
-/*!
+/**
  * Module variables
  */
 
@@ -47,8 +43,8 @@ var call  = Function.prototype.call,
  * Adds a method to an object, such that the method can also be chained.
  *
  *     utils.addChainableMethod(chai.Assertion.prototype, 'foo', function (str) {
- *       var obj = utils.flag(this, 'object');
- *       new chai.Assertion(obj).to.be.equal(str);
+ *         var obj = utils.flag(this, 'object');
+ *         new chai.Assertion(obj).to.be.equal(str);
  *     });
  *
  * Can also be accessed directly from `chai.Assertion`.
@@ -61,15 +57,14 @@ var call  = Function.prototype.call,
  *     expect(fooStr).to.be.foo('bar');
  *     expect(fooStr).to.be.foo.equal('foo');
  *
- * @param {Object} ctx object to which the method is added
- * @param {String} name of method to add
+ * @param {object} ctx object to which the method is added
+ * @param {string} name of method to add
  * @param {Function} method function to be used for `name`, when called
  * @param {Function} chainingBehavior function to be called every time the property is accessed
  * @namespace Utils
  * @name addChainableMethod
- * @api public
+ * @public
  */
-
 export function addChainableMethod(ctx, name, method, chainingBehavior) {
   if (typeof chainingBehavior !== 'function') {
     chainingBehavior = function () { };

package/lib/chai/utils/addLengthGuard.js

@@ -34,12 +34,12 @@ const fnLengthDesc = Object.getOwnPropertyDescriptor(function () {}, 'length');
  * environments is the priority.
  *
  * @param {Function} fn
- * @param {String} assertionName
- * @param {Boolean} isChainable
+ * @param {string} assertionName
+ * @param {boolean} isChainable
+ * @returns {unknown}
  * @namespace Utils
  * @name addLengthGuard
  */
-
 export function addLengthGuard(fn, assertionName, isChainable) {
   if (!fnLengthDesc.configurable) return fn;
 

package/lib/chai/utils/addMethod.js

@@ -16,8 +16,8 @@ import {Assertion} from '../assertion.js';
  * Adds a method to the prototype of an object.
  *
  *     utils.addMethod(chai.Assertion.prototype, 'foo', function (str) {
- *       var obj = utils.flag(this, 'object');
- *       new chai.Assertion(obj).to.be.equal(str);
+ *         var obj = utils.flag(this, 'object');
+ *         new chai.Assertion(obj).to.be.equal(str);
  *     });
  *
  * Can also be accessed directly from `chai.Assertion`.
@@ -28,14 +28,13 @@ import {Assertion} from '../assertion.js';
  *
  *     expect(fooStr).to.be.foo('bar');
  *
- * @param {Object} ctx object to which the method is added
- * @param {String} name of method to add
+ * @param {object} ctx object to which the method is added
+ * @param {string} name of method to add
  * @param {Function} method function to be used for name
  * @namespace Utils
  * @name addMethod
- * @api public
+ * @public
  */
-
 export function addMethod(ctx, name, method) {
   var methodWrapper = function () {
     // Setting the `ssfi` flag to `methodWrapper` causes this function to be the

package/lib/chai/utils/addProperty.js

@@ -15,8 +15,8 @@ import {transferFlags} from './transferFlags.js';
  * Adds a property to the prototype of an object.
  *
  *     utils.addProperty(chai.Assertion.prototype, 'foo', function () {
- *       var obj = utils.flag(this, 'object');
- *       new chai.Assertion(obj).to.be.instanceof(Foo);
+ *         var obj = utils.flag(this, 'object');
+ *         new chai.Assertion(obj).to.be.instanceof(Foo);
  *     });
  *
  * Can also be accessed directly from `chai.Assertion`.
@@ -27,14 +27,13 @@ import {transferFlags} from './transferFlags.js';
  *
  *     expect(myFoo).to.be.foo;
  *
- * @param {Object} ctx object to which the property is added
- * @param {String} name of property to add
+ * @param {object} ctx object to which the property is added
+ * @param {string} name of property to add
  * @param {Function} getter function to be used for name
  * @namespace Utils
  * @name addProperty
- * @api public
+ * @public
  */
-
 export function addProperty(ctx, name, getter) {
   getter = getter === undefined ? function () {} : getter;
 

package/lib/chai/utils/compareByInspect.js

@@ -4,10 +4,6 @@
  * MIT Licensed
  */
 
-/*!
- * Module dependencies
- */
-
 import {inspect} from './inspect.js';
 
 /**
@@ -18,14 +14,13 @@ import {inspect} from './inspect.js';
  * and objects with irregular/missing toString can still be sorted without a
  * TypeError.
  *
- * @param {Mixed} first element to compare
- * @param {Mixed} second element to compare
- * @returns {Number} -1 if 'a' should come before 'b'; otherwise 1
+ * @param {unknown} a first element to compare
+ * @param {unknown} b second element to compare
+ * @returns {number} -1 if 'a' should come before 'b'; otherwise 1
  * @name compareByInspect
  * @namespace Utils
- * @api public
+ * @public
  */
-
 export function compareByInspect(a, b) {
   return inspect(a) < inspect(b) ? -1 : 1;
 }

package/lib/chai/utils/expectTypes.js

@@ -4,6 +4,10 @@
  * MIT Licensed
  */
 
+import {AssertionError} from 'assertion-error';
+import {flag} from './flag.js';
+import {type} from './type-detect.js';
+
 /**
  * ### .expectTypes(obj, types)
  *
@@ -11,17 +15,12 @@
  *
  *     utils.expectTypes(this, ['array', 'object', 'string']);
  *
- * @param {Mixed} obj constructed Assertion
- * @param {Array} type A list of allowed types for this assertion
+ * @param {unknown} obj constructed Assertion
+ * @param {Array} types A list of allowed types for this assertion
  * @namespace Utils
  * @name expectTypes
- * @api public
+ * @public
  */
-
-import {AssertionError} from 'assertion-error';
-import {flag} from './flag.js';
-import {type} from './type-detect.js';
-
 export function expectTypes(obj, types) {
   var flagMsg = flag(obj, 'message');
   var ssfi = flag(obj, 'ssfi');

package/lib/chai/utils/flag.js

@@ -15,14 +15,14 @@
  *     utils.flag(this, 'foo', 'bar'); // setter
  *     utils.flag(this, 'foo'); // getter, returns `bar`
  *
- * @param {Object} object constructed Assertion
- * @param {String} key
- * @param {Mixed} value (optional)
+ * @param {object} obj object constructed Assertion
+ * @param {string} key
+ * @param {unknown} value (optional)
  * @namespace Utils
  * @name flag
- * @api private
+ * @returns {unknown | undefined}
+ * @private
  */
-
 export function flag(obj, key, value) {
   var flags = obj.__flags || (obj.__flags = Object.create(null));
   if (arguments.length === 3) {

package/lib/chai/utils/getActual.js

@@ -9,12 +9,12 @@
  *
  * Returns the `actual` value for an Assertion.
  *
- * @param {Object} object (constructed Assertion)
- * @param {Arguments} chai.Assertion.prototype.assert arguments
+ * @param {object} obj object (constructed Assertion)
+ * @param {unknown} args chai.Assertion.prototype.assert arguments
+ * @returns {unknown}
  * @namespace Utils
  * @name getActual
  */
-
 export function getActual(obj, args) {
   return args.length > 4 ? args[4] : obj._obj;
 }

package/lib/chai/utils/getEnumerableProperties.js

@@ -10,13 +10,12 @@
  * This allows the retrieval of enumerable property names of an object,
  * inherited or not.
  *
- * @param {Object} object
+ * @param {object} object
  * @returns {Array}
  * @namespace Utils
  * @name getEnumerableProperties
- * @api public
+ * @public
  */
-
 module.exports = function getEnumerableProperties(object) {
   var result = [];
   for (var name in object) {

package/lib/chai/utils/getMessage.js

@@ -4,10 +4,6 @@
  * MIT Licensed
  */
 
-/*!
- * Module dependencies
- */
-
 import {flag} from './flag.js';
 import {getActual} from './getActual.js';
 import {objDisplay} from './objDisplay.js';
@@ -24,13 +20,13 @@ import {objDisplay} from './objDisplay.js';
  * - `#{act}` actual value
  * - `#{exp}` expected value
  *
- * @param {Object} object (constructed Assertion)
- * @param {Arguments} chai.Assertion.prototype.assert arguments
+ * @param {object} obj object (constructed Assertion)
+ * @param {unknown} args chai.Assertion.prototype.assert arguments
+ * @returns {unknown}
  * @namespace Utils
  * @name getMessage
- * @api public
+ * @public
  */
-
 export function getMessage(obj, args) {
   var negate = flag(obj, 'negate')
     , val = flag(obj, 'object')

package/lib/chai/utils/getOperator.js

@@ -1,6 +1,10 @@
 import {flag} from './flag.js';
 import {type} from './type-detect.js';
 
+/**
+ * @param {unknown} obj
+ * @returns {boolean}
+ */
 function isObjectType(obj) {
   var objectType = type(obj);
   var objectTypes = ['Array', 'Object', 'Function'];
@@ -17,13 +21,13 @@ function isObjectType(obj) {
  *
  * Returns the `operator` or `undefined` value for an Assertion.
  *
- * @param {Object} object (constructed Assertion)
- * @param {Arguments} chai.Assertion.prototype.assert arguments
+ * @param {object} obj object (constructed Assertion)
+ * @param {unknown} args chai.Assertion.prototype.assert arguments
+ * @returns {unknown}
  * @namespace Utils
  * @name getOperator
- * @api public
+ * @public
  */
-
 export function getOperator(obj, args) {
   var operator = flag(obj, 'operator');
   var negate = flag(obj, 'negate');

package/lib/chai/utils/getOwnEnumerableProperties.js

@@ -4,10 +4,6 @@
  * MIT Licensed
  */
 
-/*!
- * Module dependencies
- */
-
 import {getOwnEnumerablePropertySymbols} from './getOwnEnumerablePropertySymbols.js';
 
 /**
@@ -17,13 +13,12 @@ import {getOwnEnumerablePropertySymbols} from './getOwnEnumerablePropertySymbols
  * symbols of an object. This function is necessary because Object.keys only
  * returns enumerable property names, not enumerable property symbols.
  *
- * @param {Object} object
+ * @param {object} obj
  * @returns {Array}
  * @namespace Utils
  * @name getOwnEnumerableProperties
- * @api public
+ * @public
  */
-
 export function getOwnEnumerableProperties(obj) {
   return Object.keys(obj).concat(getOwnEnumerablePropertySymbols(obj));
 }

package/lib/chai/utils/getOwnEnumerablePropertySymbols.js

@@ -11,13 +11,12 @@
  * object. This function is necessary because Object.getOwnPropertySymbols
  * returns both enumerable and non-enumerable property symbols.
  *
- * @param {Object} object
+ * @param {object} obj
  * @returns {Array}
  * @namespace Utils
  * @name getOwnEnumerablePropertySymbols
- * @api public
+ * @public
  */
-
 export function getOwnEnumerablePropertySymbols(obj) {
   if (typeof Object.getOwnPropertySymbols !== 'function') return [];
 

package/lib/chai/utils/getProperties.js

@@ -10,16 +10,18 @@
  * This allows the retrieval of property names of an object, enumerable or not,
  * inherited or not.
  *
- * @param {Object} object
+ * @param {object} object
  * @returns {Array}
  * @namespace Utils
  * @name getProperties
- * @api public
+ * @public
  */
-
 export function getProperties(object) {
   var result = Object.getOwnPropertyNames(object);
 
+  /**
+   * @param {unknown} property
+   */
   function addProperty(property) {
     if (result.indexOf(property) === -1) {
       result.push(property);