Add types

lib/chai/assertion.js

@@ -9,7 +9,7 @@ import {config} from './config.js';
 import {AssertionError} from 'assertion-error';
 import * as util from './utils/index.js';
 
-/*!
+/**
  * Assertion Constructor
  *
  * Creates object for chaining.
@@ -42,10 +42,10 @@ import * as util from './utils/index.js';
  *
  * - `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 {Function} ssfi (optional) starting point for removing stack frames
- * @param {Boolean} lockSsfi (optional) whether or not the ssfi flag is locked
+ * @param {unknown} obj target of the assertion
+ * @param {String} [msg] custom error message
+ * @param {Function} [ssfi] starting point for removing stack frames
+ * @param {Boolean} [lockSsfi] whether or not the ssfi flag is locked
  * @api private
  */
 
@@ -81,26 +81,52 @@ Object.defineProperty(Assertion, 'showDiff', {
   }
 });
 
+/**
+ * @param {string} name
+ * @param {Function} fn
+ */
 Assertion.addProperty = function (name, fn) {
   util.addProperty(this.prototype, name, fn);
 };
 
+/**
+ * @param {string} name
+ * @param {Function} fn
+ */
 Assertion.addMethod = function (name, fn) {
   util.addMethod(this.prototype, name, fn);
 };
 
+/**
+ * @param {string} name
+ * @param {Function} fn
+ * @param {Function} chainingBehavior
+ */
 Assertion.addChainableMethod = function (name, fn, chainingBehavior) {
   util.addChainableMethod(this.prototype, name, fn, chainingBehavior);
 };
 
+/**
+ * @param {string} name
+ * @param {Function} fn
+ */
 Assertion.overwriteProperty = function (name, fn) {
   util.overwriteProperty(this.prototype, name, fn);
 };
 
+/**
+ * @param {string} name
+ * @param {Function} fn
+ */
 Assertion.overwriteMethod = function (name, fn) {
   util.overwriteMethod(this.prototype, name, fn);
 };
 
+/**
+ * @param {string} name
+ * @param {Function} fn
+ * @param {Function} chainingBehavior
+ */
 Assertion.overwriteChainableMethod = function (name, fn, chainingBehavior) {
   util.overwriteChainableMethod(this.prototype, name, fn, chainingBehavior);
 };
@@ -111,12 +137,12 @@ 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
+ * @param {unknown} expr expression to be tested
+ * @param {String|Function} msg message or function that returns message to display if expression fails
+ * @param {String|Function} negateMsg negatedMessage or function that returns negatedMessage to display if negated expression fails
+ * @param {unknown} [expected] value (remember to check for negation)
+ * @param {unknown} [_actual] will default to `this.obj`
+ * @param {Boolean} [showDiff] when set to `true`, assert will display a diff in addition to the message if expression fails
  * @api private
  */
 
@@ -127,12 +153,13 @@ Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual,
   if (true !== config.showDiff) showDiff = false;
 
   if (!ok) {
-    msg = util.getMessage(this, arguments);
+    msg = util.getMessage(this, msg, negateMsg, expected, _actual);
     var actual = util.getActual(this, arguments);
     var assertionErrorObjectProperties = {
         actual: actual
       , expected: expected
       , showDiff: showDiff
+      , operator: undefined
     };
 
     var operator = util.getOperator(this, arguments);