chai 4.3.10 → 5.1.2

package/lib/chai/utils/addProperty.js

@@ -4,10 +4,10 @@
  * MIT Licensed
  */
 
-var chai = require('../../chai');
-var flag = require('./flag');
-var isProxyEnabled = require('./isProxyEnabled');
-var transferFlags = require('./transferFlags');
+import {Assertion} from '../assertion.js';
+import {flag} from './flag.js';
+import {isProxyEnabled} from './isProxyEnabled.js';
+import {transferFlags} from './transferFlags.js';
 
 /**
  * ### .addProperty(ctx, name, getter)
@@ -15,8 +15,8 @@ var transferFlags = require('./transferFlags');
  * 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,15 +27,14 @@ var transferFlags = require('./transferFlags');
  *
  *     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
  */
-
-module.exports = function addProperty(ctx, name, getter) {
+export function addProperty(ctx, name, getter) {
   getter = getter === undefined ? function () {} : getter;
 
   Object.defineProperty(ctx, name,
@@ -63,10 +62,10 @@ module.exports = function addProperty(ctx, name, getter) {
         if (result !== undefined)
           return result;
 
-        var newAssertion = new chai.Assertion();
+        var newAssertion = new Assertion();
         transferFlags(this, newAssertion);
         return newAssertion;
       }
     , configurable: true
   });
-};
+}

package/lib/chai/utils/compareByInspect.js

@@ -4,11 +4,7 @@
  * MIT Licensed
  */
 
-/*!
- * Module dependencies
- */
-
-var inspect = require('./inspect');
+import {inspect} from './inspect.js';
 
 /**
  * ### .compareByInspect(mixed, mixed)
@@ -18,14 +14,13 @@ var inspect = require('./inspect');
  * 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
  */
-
-module.exports = function compareByInspect(a, b) {
+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,18 +15,13 @@
  *
  *     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
  */
-
-var AssertionError = require('assertion-error');
-var flag = require('./flag');
-var type = require('type-detect');
-
-module.exports = function expectTypes(obj, types) {
+export function expectTypes(obj, types) {
   var flagMsg = flag(obj, 'message');
   var ssfi = flag(obj, 'ssfi');
 
@@ -48,4 +47,4 @@ module.exports = function expectTypes(obj, types) {
       ssfi
     );
   }
-};
+}

package/lib/chai/utils/flag.js

@@ -15,19 +15,19 @@
  *     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
  */
-
-module.exports = function flag(obj, key, value) {
+export function flag(obj, key, value) {
   var flags = obj.__flags || (obj.__flags = Object.create(null));
   if (arguments.length === 3) {
     flags[key] = value;
   } else {
     return flags[key];
   }
-};
+}

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
  */
-
-module.exports = function getActual(obj, args) {
+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,13 +4,9 @@
  * MIT Licensed
  */
 
-/*!
- * Module dependencies
- */
-
-var flag = require('./flag')
-  , getActual = require('./getActual')
-  , objDisplay = require('./objDisplay');
+import {flag} from './flag.js';
+import {getActual} from './getActual.js';
+import {objDisplay} from './objDisplay.js';
 
 /**
  * ### .getMessage(object, message, negateMessage)
@@ -24,14 +20,14 @@ var flag = require('./flag')
  * - `#{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
  */
-
-module.exports = function getMessage(obj, args) {
+export function getMessage(obj, args) {
   var negate = flag(obj, 'negate')
     , val = flag(obj, 'object')
     , expected = args[3]
@@ -47,4 +43,4 @@ module.exports = function getMessage(obj, args) {
     .replace(/#\{exp\}/g, function () { return objDisplay(expected); });
 
   return flagMsg ? flagMsg + ': ' + msg : msg;
-};
+}

package/lib/chai/utils/getOperator.js

@@ -1,10 +1,13 @@
-var type = require('type-detect');
-
-var flag = require('./flag');
+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'];
+  var objectTypes = ['Array', 'Object', 'Function'];
 
   return objectTypes.indexOf(objectType) !== -1;
 }
@@ -18,14 +21,14 @@ 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
  */
-
-module.exports = function getOperator(obj, args) {
+export function getOperator(obj, args) {
   var operator = flag(obj, 'operator');
   var negate = flag(obj, 'negate');
   var expected = args[3];
@@ -52,4 +55,4 @@ module.exports = function getOperator(obj, args) {
   }
 
   return isObject ? 'deepStrictEqual' : 'strictEqual';
-};
+}

package/lib/chai/utils/getOwnEnumerableProperties.js

@@ -4,11 +4,7 @@
  * MIT Licensed
  */
 
-/*!
- * Module dependencies
- */
-
-var getOwnEnumerablePropertySymbols = require('./getOwnEnumerablePropertySymbols');
+import {getOwnEnumerablePropertySymbols} from './getOwnEnumerablePropertySymbols.js';
 
 /**
  * ### .getOwnEnumerableProperties(object)
@@ -17,13 +13,12 @@ var getOwnEnumerablePropertySymbols = require('./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
  */
-
-module.exports = function getOwnEnumerableProperties(obj) {
+export function getOwnEnumerableProperties(obj) {
   return Object.keys(obj).concat(getOwnEnumerablePropertySymbols(obj));
-};
+}

package/lib/chai/utils/getOwnEnumerablePropertySymbols.js

@@ -11,17 +11,16 @@
  * 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
  */
-
-module.exports = function getOwnEnumerablePropertySymbols(obj) {
+export function getOwnEnumerablePropertySymbols(obj) {
   if (typeof Object.getOwnPropertySymbols !== 'function') return [];
 
   return Object.getOwnPropertySymbols(obj).filter(function (sym) {
     return Object.getOwnPropertyDescriptor(obj, sym).enumerable;
   });
-};
+}

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
  */
-
-module.exports = function getProperties(object) {
+export function getProperties(object) {
   var result = Object.getOwnPropertyNames(object);
 
+  /**
+   * @param {unknown} property
+   */
   function addProperty(property) {
     if (result.indexOf(property) === -1) {
       result.push(property);
@@ -33,4 +35,4 @@ module.exports = function getProperties(object) {
   }
 
   return result;
-};
+}

package/lib/chai/utils/index.js

@@ -4,175 +4,109 @@
  * MIT Licensed
  */
 
-/*!
- * Dependencies that are used for multiple exports are required here only once
- */
-
-var pathval = require('pathval');
-
-/*!
- * test utility
- */
-
-exports.test = require('./test');
-
-/*!
- * type utility
- */
-
-exports.type = require('type-detect');
-
-/*!
- * expectTypes utility
- */
-exports.expectTypes = require('./expectTypes');
-
-/*!
- * message utility
- */
-
-exports.getMessage = require('./getMessage');
-
-/*!
- * actual utility
- */
+// Dependencies that are used for multiple exports are required here only once
+import * as checkError from 'check-error';
 
-exports.getActual = require('./getActual');
+// test utility
+export {test} from './test.js';
 
-/*!
- * Inspect util
- */
+// type utility
+import {type} from './type-detect.js';
+export {type};
 
-exports.inspect = require('./inspect');
+// expectTypes utility
+export {expectTypes} from './expectTypes.js';
 
-/*!
- * Object Display util
- */
+// message utility
+export {getMessage} from './getMessage.js';
 
-exports.objDisplay = require('./objDisplay');
+// actual utility
+export {getActual} from './getActual.js';
 
-/*!
- * Flag utility
- */
+// Inspect util
+export {inspect} from './inspect.js';
 
-exports.flag = require('./flag');
+// Object Display util
+export {objDisplay} from './objDisplay.js';
 
-/*!
- * Flag transferring utility
- */
+// Flag utility
+export {flag} from './flag.js';
 
-exports.transferFlags = require('./transferFlags');
+// Flag transferring utility
+export {transferFlags} from './transferFlags.js';
 
-/*!
- * Deep equal utility
- */
+// Deep equal utility
+export {default as eql} from 'deep-eql';
 
-exports.eql = require('deep-eql');
+// Deep path info
+export {getPathInfo, hasProperty} from 'pathval';
 
-/*!
- * Deep path info
- */
-
-exports.getPathInfo = pathval.getPathInfo;
-
-/*!
- * Check if a property exists
- */
-
-exports.hasProperty = pathval.hasProperty;
-
-/*!
+/**
  * Function name
+ *
+ * @param {Function} fn
+ * @returns {string}
  */
+export function getName(fn) {
+  return fn.name
+}
 
-exports.getName = require('get-func-name');
+// add Property
+export {addProperty} from './addProperty.js';
 
-/*!
- * add Property
- */
+// add Method
+export {addMethod} from './addMethod.js';
 
-exports.addProperty = require('./addProperty');
+// overwrite Property
+export {overwriteProperty} from './overwriteProperty.js';
 
-/*!
- * add Method
- */
+// overwrite Method
+export {overwriteMethod} from './overwriteMethod.js';
 
-exports.addMethod = require('./addMethod');
+// Add a chainable method
+export {addChainableMethod} from './addChainableMethod.js';
 
-/*!
- * overwrite Property
- */
+// Overwrite chainable method
+export {overwriteChainableMethod} from './overwriteChainableMethod.js';
 
-exports.overwriteProperty = require('./overwriteProperty');
+// Compare by inspect method
+export {compareByInspect} from './compareByInspect.js';
 
-/*!
- * overwrite Method
- */
+// Get own enumerable property symbols method
+export {getOwnEnumerablePropertySymbols} from './getOwnEnumerablePropertySymbols.js';
 
-exports.overwriteMethod = require('./overwriteMethod');
+// Get own enumerable properties method
+export {getOwnEnumerableProperties} from './getOwnEnumerableProperties.js';
 
-/*!
- * Add a chainable method
- */
+// Checks error against a given set of criteria
+export {checkError};
 
-exports.addChainableMethod = require('./addChainableMethod');
+// Proxify util
+export {proxify} from './proxify.js';
 
-/*!
- * Overwrite chainable method
- */
+// addLengthGuard util
+export {addLengthGuard} from './addLengthGuard.js';
 
-exports.overwriteChainableMethod = require('./overwriteChainableMethod');
+// isProxyEnabled helper
+export {isProxyEnabled} from './isProxyEnabled.js';
 
-/*!
- * Compare by inspect method
- */
-
-exports.compareByInspect = require('./compareByInspect');
-
-/*!
- * Get own enumerable property symbols method
- */
+// isNaN method
+export {isNaN} from './isNaN.js';
 
-exports.getOwnEnumerablePropertySymbols = require('./getOwnEnumerablePropertySymbols');
+// getOperator method
+export {getOperator} from './getOperator.js';
 
-/*!
- * Get own enumerable properties method
- */
-
-exports.getOwnEnumerableProperties = require('./getOwnEnumerableProperties');
-
-/*!
- * Checks error against a given set of criteria
- */
-
-exports.checkError = require('check-error');
-
-/*!
- * Proxify util
- */
-
-exports.proxify = require('./proxify');
-
-/*!
- * addLengthGuard util
- */
-
-exports.addLengthGuard = require('./addLengthGuard');
-
-/*!
- * isProxyEnabled helper
- */
-
-exports.isProxyEnabled = require('./isProxyEnabled');
-
-/*!
- * isNaN method
- */
-
-exports.isNaN = require('./isNaN');
-
-/*!
- * getOperator method
+/**
+ * Determines if an object is a `RegExp`
+ * This is used since `instanceof` will not work in virtual contexts
+ *
+ * @param {*} obj Object to test
+ * @returns {boolean}
  */
+export function isRegExp(obj) {
+  return Object.prototype.toString.call(obj) === '[object RegExp]';
+}
 
-exports.getOperator = require('./getOperator');
+export function isNumeric(obj) {
+  return ['Number', 'BigInt'].includes(type(obj))
+}

package/lib/chai/utils/inspect.js

@@ -1,11 +1,8 @@
 // This is (almost) directly from Node.js utils
 // https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/util.js
 
-var getName = require('get-func-name');
-var loupe = require('loupe');
-var config = require('../config');
-
-module.exports = inspect;
+import {inspect as _inspect} from 'loupe';
+import {config} from '../config.js';
 
 /**
  * ### .inspect(obj, [showHidden], [depth], [colors])
@@ -13,21 +10,22 @@ module.exports = inspect;
  * Echoes the value of a value. Tries to print the value out
  * in the best way possible given the different types.
  *
- * @param {Object} obj The object to print out.
- * @param {Boolean} showHidden Flag that shows hidden (not enumerable)
+ * @param {object} obj The object to print out.
+ * @param {boolean} showHidden Flag that shows hidden (not enumerable)
  *    properties of objects. Default is false.
- * @param {Number} depth Depth in which to descend in object. Default is 2.
- * @param {Boolean} colors Flag to turn on ANSI escape codes to color the
+ * @param {number} depth Depth in which to descend in object. Default is 2.
+ * @param {boolean} colors Flag to turn on ANSI escape codes to color the
  *    output. Default is false (no coloring).
+ * @returns {string}
  * @namespace Utils
  * @name inspect
  */
-function inspect(obj, showHidden, depth, colors) {
+export function inspect(obj, showHidden, depth, colors) {
   var options = {
     colors: colors,
     depth: (typeof depth === 'undefined' ? 2 : depth),
     showHidden: showHidden,
     truncate: config.truncateThreshold ? config.truncateThreshold : Infinity,
   };
-  return loupe.inspect(obj, options);
+  return _inspect(obj, options);
 }