chai 4.3.10 → 5.1.2

package/lib/chai/interface/expect.js

@@ -4,44 +4,52 @@
  * MIT Licensed
  */
 
-module.exports = function (chai, util) {
-  chai.expect = function (val, message) {
-    return new chai.Assertion(val, message);
-  };
+import * as chai from '../../../index.js';
+import {Assertion} from '../assertion.js';
+import {AssertionError} from 'assertion-error';
 
-  /**
-   * ### .fail([message])
-   * ### .fail(actual, expected, [message], [operator])
-   *
-   * Throw a failure.
-   *
-   *     expect.fail();
-   *     expect.fail("custom error message");
-   *     expect.fail(1, 2);
-   *     expect.fail(1, 2, "custom error message");
-   *     expect.fail(1, 2, "custom error message", ">");
-   *     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} val
+ * @param {string} message
+ * @returns {Assertion}
+ */
+function expect(val, message) {
+  return new Assertion(val, message);
+}
+
+export {expect};
 
-  chai.expect.fail = function (actual, expected, message, operator) {
-    if (arguments.length < 2) {
-        message = actual;
-        actual = undefined;
-    }
+/**
+ * ### .fail([message])
+ * ### .fail(actual, expected, [message], [operator])
+ *
+ * Throw a failure.
+ *
+ *     expect.fail();
+ *     expect.fail("custom error message");
+ *     expect.fail(1, 2);
+ *     expect.fail(1, 2, "custom error message");
+ *     expect.fail(1, 2, "custom error message", ">");
+ *     expect.fail(1, 2, undefined, ">");
+ *
+ * @name fail
+ * @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;
+      actual = undefined;
+  }
 
-    message = message || 'expect.fail()';
-    throw new chai.AssertionError(message, {
-        actual: actual
-      , expected: expected
-      , operator: operator
-    }, chai.expect.fail);
-  };
+  message = message || 'expect.fail()';
+  throw new AssertionError(message, {
+      actual: actual
+    , expected: expected
+    , operator: operator
+  }, chai.expect.fail);
 };

package/lib/chai/interface/should.js

@@ -4,216 +4,218 @@
  * MIT Licensed
  */
 
-module.exports = function (chai, util) {
-  var Assertion = chai.Assertion;
+import {Assertion} from '../assertion.js';
+import {AssertionError} from 'assertion-error';
 
-  function loadShould () {
-    // explicitly define this method as function as to have it's name to include as `ssfi`
-    function shouldGetter() {
-      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);
-    }
-    function shouldSetter(value) {
-      // See https://github.com/chaijs/chai/issues/86: this makes
-      // `whatever.should = someValue` actually set `someValue`, which is
-      // especially useful for `global.should = require('chai').should()`.
-      //
-      // Note that we have to use [[DefineProperty]] instead of [[Put]]
-      // since otherwise we would trigger this very setter!
-      Object.defineProperty(this, 'should', {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
+/**
+ * @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
+        || this instanceof Boolean
+        || typeof Symbol === 'function' && this instanceof Symbol
+        || typeof BigInt === 'function' && this instanceof BigInt) {
+      return new Assertion(this.valueOf(), null, shouldGetter);
     }
-    // modify Object.prototype to have `should`
-    Object.defineProperty(Object.prototype, 'should', {
-      set: shouldSetter
-      , get: shouldGetter
-      , configurable: true
+    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
+    // especially useful for `global.should = require('chai').should()`.
+    //
+    // Note that we have to use [[DefineProperty]] instead of [[Put]]
+    // since otherwise we would trigger this very setter!
+    Object.defineProperty(this, 'should', {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
     });
-
-    var should = {};
-
-    /**
-     * ### .fail([message])
-     * ### .fail(actual, expected, [message], [operator])
-     *
-     * Throw a failure.
-     *
-     *     should.fail();
-     *     should.fail("custom error message");
-     *     should.fail(1, 2);
-     *     should.fail(1, 2, "custom error message");
-     *     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
-     * @namespace BDD
-     * @api public
-     */
-
-    should.fail = function (actual, expected, message, operator) {
-      if (arguments.length < 2) {
-          message = actual;
-          actual = undefined;
-      }
-
-      message = message || 'should.fail()';
-      throw new chai.AssertionError(message, {
-          actual: actual
-        , expected: expected
-        , operator: operator
-      }, should.fail);
-    };
-
-    /**
-     * ### .equal(actual, expected, [message])
-     *
-     * Asserts non-strict equality (`==`) of `actual` and `expected`.
-     *
-     *     should.equal(3, '3', '== coerces values to strings');
-     *
-     * @name equal
-     * @param {Mixed} actual
-     * @param {Mixed} expected
-     * @param {String} message
-     * @namespace Should
-     * @api public
-     */
-
-    should.equal = function (val1, val2, msg) {
-      new Assertion(val1, msg).to.equal(val2);
-    };
-
-    /**
-     * ### .throw(function, [constructor/string/regexp], [string/regexp], [message])
-     *
-     * Asserts that `function` will throw an error that is an instance of
-     * `constructor`, or alternately that it will throw an error with message
-     * matching `regexp`.
-     *
-     *     should.throw(fn, 'function throws a reference error');
-     *     should.throw(fn, /function throws a reference error/);
-     *     should.throw(fn, ReferenceError);
-     *     should.throw(fn, ReferenceError, 'function throws a reference error');
-     *     should.throw(fn, ReferenceError, /function throws a reference error/);
-     *
-     * @name throw
-     * @alias Throw
-     * @param {Function} function
-     * @param {ErrorConstructor} constructor
-     * @param {RegExp} regexp
-     * @param {String} message
-     * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
-     * @namespace Should
-     * @api public
-     */
-
-    should.Throw = function (fn, errt, errs, msg) {
-      new Assertion(fn, msg).to.Throw(errt, errs);
-    };
-
-    /**
-     * ### .exist
-     *
-     * Asserts that the target is neither `null` nor `undefined`.
-     *
-     *     var foo = 'hi';
-     *
-     *     should.exist(foo, 'foo exists');
-     *
-     * @name exist
-     * @namespace Should
-     * @api public
-     */
-
-    should.exist = function (val, msg) {
-      new Assertion(val, msg).to.exist;
+  }
+  // modify Object.prototype to have `should`
+  Object.defineProperty(Object.prototype, 'should', {
+    set: shouldSetter
+    , get: shouldGetter
+    , configurable: true
+  });
+
+  var should = {};
+
+  /**
+   * ### .fail([message])
+   * ### .fail(actual, expected, [message], [operator])
+   *
+   * Throw a failure.
+   *
+   *     should.fail();
+   *     should.fail("custom error message");
+   *     should.fail(1, 2);
+   *     should.fail(1, 2, "custom error message");
+   *     should.fail(1, 2, "custom error message", ">");
+   *     should.fail(1, 2, undefined, ">");
+   *
+   * @name fail
+   * @param {unknown} actual
+   * @param {unknown} expected
+   * @param {string} message
+   * @param {string} operator
+   * @namespace BDD
+   * @public
+   */
+  should.fail = function (actual, expected, message, operator) {
+    if (arguments.length < 2) {
+        message = actual;
+        actual = undefined;
     }
 
-    // negation
-    should.not = {}
-
-    /**
-     * ### .not.equal(actual, expected, [message])
-     *
-     * Asserts non-strict inequality (`!=`) of `actual` and `expected`.
-     *
-     *     should.not.equal(3, 4, 'these numbers are not equal');
-     *
-     * @name not.equal
-     * @param {Mixed} actual
-     * @param {Mixed} expected
-     * @param {String} message
-     * @namespace Should
-     * @api public
-     */
-
-    should.not.equal = function (val1, val2, msg) {
-      new Assertion(val1, msg).to.not.equal(val2);
-    };
-
-    /**
-     * ### .throw(function, [constructor/regexp], [message])
-     *
-     * Asserts that `function` will _not_ throw an error that is an instance of
-     * `constructor`, or alternately that it will not throw an error with message
-     * matching `regexp`.
-     *
-     *     should.not.throw(fn, Error, 'function does not throw');
-     *
-     * @name not.throw
-     * @alias not.Throw
-     * @param {Function} function
-     * @param {ErrorConstructor} constructor
-     * @param {RegExp} regexp
-     * @param {String} message
-     * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
-     * @namespace Should
-     * @api public
-     */
-
-    should.not.Throw = function (fn, errt, errs, msg) {
-      new Assertion(fn, msg).to.not.Throw(errt, errs);
-    };
+    message = message || 'should.fail()';
+    throw new AssertionError(message, {
+        actual: actual
+      , expected: expected
+      , operator: operator
+    }, should.fail);
+  };
 
-    /**
-     * ### .not.exist
-     *
-     * 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
-     */
+  /**
+   * ### .equal(actual, expected, [message])
+   *
+   * Asserts non-strict equality (`==`) of `actual` and `expected`.
+   *
+   *     should.equal(3, '3', '== coerces values to strings');
+   *
+   * @name equal
+   * @param {unknown} actual
+   * @param {unknown} expected
+   * @param {string} message
+   * @namespace Should
+   * @public
+   */
+  should.equal = function (actual, expected, message) {
+    new Assertion(actual, message).to.equal(expected);
+  };
 
-    should.not.exist = function (val, msg) {
-      new Assertion(val, msg).to.not.exist;
-    }
+  /**
+   * ### .throw(function, [constructor/string/regexp], [string/regexp], [message])
+   *
+   * Asserts that `function` will throw an error that is an instance of
+   * `constructor`, or alternately that it will throw an error with message
+   * matching `regexp`.
+   *
+   *     should.throw(fn, 'function throws a reference error');
+   *     should.throw(fn, /function throws a reference error/);
+   *     should.throw(fn, ReferenceError);
+   *     should.throw(fn, ReferenceError, 'function throws a reference error');
+   *     should.throw(fn, ReferenceError, /function throws a reference error/);
+   *
+   * @name throw
+   * @alias Throw
+   * @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
+   * @public
+   */
+  should.Throw = function (fn, errt, errs, msg) {
+    new Assertion(fn, msg).to.Throw(errt, errs);
+  };
 
-    should['throw'] = should['Throw'];
-    should.not['throw'] = should.not['Throw'];
+  /**
+   * ### .exist
+   *
+   * 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
+   * @public
+   */
+  should.exist = function (val, msg) {
+    new Assertion(val, msg).to.exist;
+  }
+
+  // negation
+  should.not = {}
+
+  /**
+   * ### .not.equal(actual, expected, [message])
+   *
+   * Asserts non-strict inequality (`!=`) of `actual` and `expected`.
+   *
+   *     should.not.equal(3, 4, 'these numbers are not equal');
+   *
+   * @name not.equal
+   * @param {unknown} actual
+   * @param {unknown} expected
+   * @param {string} msg
+   * @namespace Should
+   * @public
+   */
+  should.not.equal = function (actual, expected, msg) {
+    new Assertion(actual, msg).to.not.equal(expected);
+  };
 
-    return should;
+  /**
+   * ### .throw(function, [constructor/regexp], [message])
+   *
+   * Asserts that `function` will _not_ throw an error that is an instance of
+   * `constructor`, or alternately that it will not throw an error with message
+   * matching `regexp`.
+   *
+   *     should.not.throw(fn, Error, 'function does not throw');
+   *
+   * @name not.throw
+   * @alias not.Throw
+   * @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
+   * @public
+   */
+  should.not.Throw = function (fn, errt, errs, msg) {
+    new Assertion(fn, msg).to.not.Throw(errt, errs);
   };
 
-  chai.should = loadShould;
-  chai.Should = loadShould;
+  /**
+   * ### .not.exist
+   *
+   * Asserts that the target is neither `null` nor `undefined`.
+   *
+   *     var bar = null;
+   *     should.not.exist(bar, 'bar does not exist');
+   *
+   * @namespace Should
+   * @name not.exist
+   * @param {unknown} val
+   * @param {string} msg
+   * @public
+   */
+  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

@@ -4,17 +4,13 @@
  * MIT Licensed
  */
 
-/*!
- * Module dependencies
- */
-
-var addLengthGuard = require('./addLengthGuard');
-var chai = require('../../chai');
-var flag = require('./flag');
-var proxify = require('./proxify');
-var transferFlags = require('./transferFlags');
+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,16 +57,15 @@ 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
  */
-
-module.exports = function addChainableMethod(ctx, name, method, chainingBehavior) {
+export function addChainableMethod(ctx, name, method, chainingBehavior) {
   if (typeof chainingBehavior !== 'function') {
     chainingBehavior = function () { };
   }
@@ -115,7 +110,7 @@ module.exports = function addChainableMethod(ctx, name, method, chainingBehavior
             return result;
           }
 
-          var newAssertion = new chai.Assertion();
+          var newAssertion = new Assertion();
           transferFlags(this, newAssertion);
           return newAssertion;
         };
@@ -149,4 +144,4 @@ module.exports = function addChainableMethod(ctx, name, method, chainingBehavior
       }
     , configurable: true
   });
-};
+}

package/lib/chai/utils/addLengthGuard.js

@@ -1,4 +1,4 @@
-var fnLengthDesc = Object.getOwnPropertyDescriptor(function () {}, 'length');
+const fnLengthDesc = Object.getOwnPropertyDescriptor(function () {}, 'length');
 
 /*!
  * Chai - addLengthGuard utility
@@ -34,13 +34,13 @@ var 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
  */
-
-module.exports = function addLengthGuard (fn, assertionName, isChainable) {
+export function addLengthGuard(fn, assertionName, isChainable) {
   if (!fnLengthDesc.configurable) return fn;
 
   Object.defineProperty(fn, 'length', {
@@ -57,4 +57,4 @@ module.exports = function addLengthGuard (fn, assertionName, isChainable) {
   });
 
   return fn;
-};
+}

package/lib/chai/utils/addMethod.js

@@ -4,11 +4,11 @@
  * MIT Licensed
  */
 
-var addLengthGuard = require('./addLengthGuard');
-var chai = require('../../chai');
-var flag = require('./flag');
-var proxify = require('./proxify');
-var transferFlags = require('./transferFlags');
+import {addLengthGuard} from './addLengthGuard.js';
+import {flag} from './flag.js';
+import {proxify} from './proxify.js';
+import {transferFlags} from './transferFlags.js';
+import {Assertion} from '../assertion.js';
 
 /**
  * ### .addMethod(ctx, name, method)
@@ -16,8 +16,8 @@ var transferFlags = require('./transferFlags');
  * 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,15 +28,14 @@ var transferFlags = require('./transferFlags');
  *
  *     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
  */
-
-module.exports = function addMethod(ctx, name, method) {
+export function addMethod(ctx, name, method) {
   var methodWrapper = function () {
     // Setting the `ssfi` flag to `methodWrapper` causes this function to be the
     // starting point for removing implementation frames from the stack trace of
@@ -58,11 +57,11 @@ module.exports = function addMethod(ctx, name, method) {
     if (result !== undefined)
       return result;
 
-    var newAssertion = new chai.Assertion();
+    var newAssertion = new Assertion();
     transferFlags(this, newAssertion);
     return newAssertion;
   };
 
   addLengthGuard(methodWrapper, name, false);
   ctx[name] = proxify(methodWrapper, name);
-};
+}