mocha 11.7.4 → 11.7.6

package/lib/plugin-loader.js

@@ -13,14 +13,14 @@
  * @module plugin
  */
 
-'use strict';
+"use strict";
 
-const debug = require('debug')('mocha:plugin-loader');
+const debug = require("debug")("mocha:plugin-loader");
 const {
   createInvalidPluginDefinitionError,
-  createInvalidPluginImplementationError
-} = require('./errors');
-const {castArray} = require('./utils');
+  createInvalidPluginImplementationError,
+} = require("./errors");
+const { castArray } = require("./utils");
 
 /**
  * @typedef {import('./types.d.ts').PluginLoaderOptions} PluginLoaderOptions
@@ -35,24 +35,24 @@ const MochaPlugins = [
    * @type {PluginDefinition}
    */
   {
-    exportName: 'mochaHooks',
-    optionName: 'rootHooks',
+    exportName: "mochaHooks",
+    optionName: "rootHooks",
     validate(value) {
       if (
         Array.isArray(value) ||
-        (typeof value !== 'function' && typeof value !== 'object')
+        (typeof value !== "function" && typeof value !== "object")
       ) {
         throw createInvalidPluginImplementationError(
-          `mochaHooks must be an object or a function returning (or fulfilling with) an object`
+          `mochaHooks must be an object or a function returning (or fulfilling with) an object`,
         );
       }
     },
     async finalize(rootHooks) {
       if (rootHooks.length) {
         const rootHookObjects = await Promise.all(
-          rootHooks.map(async hook =>
-            typeof hook === 'function' ? hook() : hook
-          )
+          rootHooks.map(async (hook) =>
+            typeof hook === "function" ? hook() : hook,
+          ),
         );
 
         return rootHookObjects.reduce(
@@ -62,68 +62,68 @@ const MochaPlugins = [
               beforeEach: [],
               afterAll: [],
               afterEach: [],
-              ...hook
+              ...hook,
             };
             return {
               beforeAll: [...acc.beforeAll, ...castArray(hook.beforeAll)],
               beforeEach: [...acc.beforeEach, ...castArray(hook.beforeEach)],
               afterAll: [...acc.afterAll, ...castArray(hook.afterAll)],
-              afterEach: [...acc.afterEach, ...castArray(hook.afterEach)]
+              afterEach: [...acc.afterEach, ...castArray(hook.afterEach)],
             };
           },
-          {beforeAll: [], beforeEach: [], afterAll: [], afterEach: []}
+          { beforeAll: [], beforeEach: [], afterAll: [], afterEach: [] },
         );
       }
-    }
+    },
   },
   /**
    * Global setup fixture plugin definition
    * @type {PluginDefinition}
    */
   {
-    exportName: 'mochaGlobalSetup',
-    optionName: 'globalSetup',
+    exportName: "mochaGlobalSetup",
+    optionName: "globalSetup",
     validate(value) {
       let isValid = true;
       if (Array.isArray(value)) {
-        if (value.some(item => typeof item !== 'function')) {
+        if (value.some((item) => typeof item !== "function")) {
           isValid = false;
         }
-      } else if (typeof value !== 'function') {
+      } else if (typeof value !== "function") {
         isValid = false;
       }
       if (!isValid) {
         throw createInvalidPluginImplementationError(
           `mochaGlobalSetup must be a function or an array of functions`,
-          {pluginDef: this, pluginImpl: value}
+          { pluginDef: this, pluginImpl: value },
         );
       }
-    }
+    },
   },
   /**
    * Global teardown fixture plugin definition
    * @type {PluginDefinition}
    */
   {
-    exportName: 'mochaGlobalTeardown',
-    optionName: 'globalTeardown',
+    exportName: "mochaGlobalTeardown",
+    optionName: "globalTeardown",
     validate(value) {
       let isValid = true;
       if (Array.isArray(value)) {
-        if (value.some(item => typeof item !== 'function')) {
+        if (value.some((item) => typeof item !== "function")) {
           isValid = false;
         }
-      } else if (typeof value !== 'function') {
+      } else if (typeof value !== "function") {
         isValid = false;
       }
       if (!isValid) {
         throw createInvalidPluginImplementationError(
           `mochaGlobalTeardown must be a function or an array of functions`,
-          {pluginDef: this, pluginImpl: value}
+          { pluginDef: this, pluginImpl: value },
         );
       }
-    }
-  }
+    },
+  },
 ];
 
 /**
@@ -138,7 +138,7 @@ class PluginLoader {
    * Initializes plugin names, plugin map, etc.
    * @param {PluginLoaderOptions} [opts] - Options
    */
-  constructor({pluginDefs = MochaPlugins, ignore = []} = {}) {
+  constructor({ pluginDefs = MochaPlugins, ignore = [] } = {}) {
     /**
      * Map of registered plugin defs
      * @type {Map<string,PluginDefinition>}
@@ -169,14 +169,14 @@ class PluginLoader {
      */
     this.ignoredExportNames = new Set(castArray(ignore));
 
-    castArray(pluginDefs).forEach(pluginDef => {
+    castArray(pluginDefs).forEach((pluginDef) => {
       this.register(pluginDef);
     });
 
     debug(
-      'registered %d plugin defs (%d ignored)',
+      "registered %d plugin defs (%d ignored)",
       this.registered.size,
-      this.ignoredExportNames.size
+      this.ignoredExportNames.size,
     );
   }
 
@@ -185,23 +185,23 @@ class PluginLoader {
    * @param {PluginDefinition} pluginDef - Plugin definition
    */
   register(pluginDef) {
-    if (!pluginDef || typeof pluginDef !== 'object') {
+    if (!pluginDef || typeof pluginDef !== "object") {
       throw createInvalidPluginDefinitionError(
-        'pluginDef is non-object or falsy',
-        pluginDef
+        "pluginDef is non-object or falsy",
+        pluginDef,
       );
     }
     if (!pluginDef.exportName) {
       throw createInvalidPluginDefinitionError(
         `exportName is expected to be a non-empty string`,
-        pluginDef
+        pluginDef,
       );
     }
-    let {exportName} = pluginDef;
+    let { exportName } = pluginDef;
     if (this.ignoredExportNames.has(exportName)) {
       debug(
         'refusing to register ignored plugin with export name "%s"',
-        exportName
+        exportName,
       );
       return;
     }
@@ -210,7 +210,7 @@ class PluginLoader {
     if (this.knownExportNames.has(exportName)) {
       throw createInvalidPluginDefinitionError(
         `Plugin definition conflict: ${exportName}; exportName must be unique`,
-        pluginDef
+        pluginDef,
       );
     }
     this.loaded.set(exportName, []);
@@ -229,24 +229,24 @@ class PluginLoader {
   load(requiredModule) {
     // we should explicitly NOT fail if other stuff is exported.
     // we only care about the plugins we know about.
-    if (requiredModule && typeof requiredModule === 'object') {
+    if (requiredModule && typeof requiredModule === "object") {
       return Array.from(this.knownExportNames).reduce(
         (pluginImplFound, pluginName) => {
           const pluginImpl = requiredModule[pluginName];
           if (pluginImpl) {
             const plugin = this.registered.get(pluginName);
-            if (typeof plugin.validate === 'function') {
+            if (typeof plugin.validate === "function") {
               plugin.validate(pluginImpl);
             }
             this.loaded.set(pluginName, [
               ...this.loaded.get(pluginName),
-              ...castArray(pluginImpl)
+              ...castArray(pluginImpl),
             ]);
             return true;
           }
           return pluginImplFound;
         },
-        false
+        false,
       );
     }
     return false;
@@ -265,13 +265,13 @@ class PluginLoader {
       if (pluginImpls.length) {
         const plugin = this.registered.get(exportName);
         finalizedPlugins[plugin.optionName] =
-          typeof plugin.finalize === 'function'
+          typeof plugin.finalize === "function"
             ? await plugin.finalize(pluginImpls)
             : pluginImpls;
       }
     }
 
-    debug('finalized plugins: %O', finalizedPlugins);
+    debug("finalized plugins: %O", finalizedPlugins);
     return finalizedPlugins;
   }
 
@@ -279,8 +279,8 @@ class PluginLoader {
    * Constructs a {@link PluginLoader}
    * @param {PluginLoaderOptions} [opts] - Plugin loader options
    */
-  static create({pluginDefs = MochaPlugins, ignore = []} = {}) {
-    return new PluginLoader({pluginDefs, ignore});
+  static create({ pluginDefs = MochaPlugins, ignore = [] } = {}) {
+    return new PluginLoader({ pluginDefs, ignore });
   }
 }
 

package/lib/reporters/base.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 
 /**
  * @typedef {import('../runner.js')} Runner
@@ -13,19 +13,19 @@
  * Module dependencies.
  */
 
-var diff = require('diff');
-var milliseconds = require('ms');
-var utils = require('../utils');
-var supportsColor = require('supports-color');
-var symbols = require('log-symbols');
-var constants = require('../runner').constants;
+var diff = require("diff");
+var milliseconds = require("ms");
+var utils = require("../utils");
+var supportsColor = require("supports-color");
+var symbols = require("log-symbols");
+var constants = require("../runner").constants;
 var EVENT_TEST_PASS = constants.EVENT_TEST_PASS;
 var EVENT_TEST_FAIL = constants.EVENT_TEST_FAIL;
 
 const isBrowser = utils.isBrowser();
 
 function getBrowserWindowSize() {
-  if ('innerHeight' in global) {
+  if ("innerHeight" in global) {
     return [global.innerHeight, global.innerWidth];
   }
   // In a Web Worker, the DOM Window is not available.
@@ -75,25 +75,25 @@ exports.maxDiffSize = 8192;
 exports.colors = {
   pass: 90,
   fail: 31,
-  'bright pass': 92,
-  'bright fail': 91,
-  'bright yellow': 93,
+  "bright pass": 92,
+  "bright fail": 91,
+  "bright yellow": 93,
   pending: 36,
   suite: 0,
-  'error title': 0,
-  'error message': 31,
-  'error stack': 90,
+  "error title": 0,
+  "error message": 31,
+  "error stack": 90,
   checkmark: 32,
   fast: 90,
   medium: 33,
   slow: 31,
   green: 32,
   light: 90,
-  'diff gutter': 90,
-  'diff added': 32,
-  'diff removed': 31,
-  'diff added inline': '30;42',
-  'diff removed inline': '30;41'
+  "diff gutter": 90,
+  "diff added": 32,
+  "diff removed": 31,
+  "diff added inline": "30;42",
+  "diff removed inline": "30;41",
 };
 
 /**
@@ -103,9 +103,9 @@ exports.colors = {
 exports.symbols = {
   ok: symbols.success,
   err: symbols.error,
-  dot: '.',
-  comma: ',',
-  bang: '!'
+  dot: ".",
+  comma: ",",
+  bang: "!",
 };
 
 /**
@@ -123,7 +123,7 @@ var color = (exports.color = function (type, str) {
   if (!exports.useColors) {
     return String(str);
   }
-  return '\u001b[' + exports.colors[type] + 'm' + str + '\u001b[0m';
+  return "\u001b[" + exports.colors[type] + "m" + str + "\u001b[0m";
 });
 
 /**
@@ -131,7 +131,7 @@ var color = (exports.color = function (type, str) {
  */
 
 exports.window = {
-  width: 75
+  width: 75,
 };
 
 if (isatty) {
@@ -148,19 +148,19 @@ if (isatty) {
 
 exports.cursor = {
   hide: function () {
-    isatty && process.stdout.write('\u001b[?25l');
+    isatty && process.stdout.write("\u001b[?25l");
   },
 
   show: function () {
-    isatty && process.stdout.write('\u001b[?25h');
+    isatty && process.stdout.write("\u001b[?25h");
   },
 
   deleteLine: function () {
-    isatty && process.stdout.write('\u001b[2K');
+    isatty && process.stdout.write("\u001b[2K");
   },
 
   beginningOfLine: function () {
-    isatty && process.stdout.write('\u001b[0G');
+    isatty && process.stdout.write("\u001b[0G");
   },
 
   CR: function () {
@@ -168,9 +168,9 @@ exports.cursor = {
       exports.cursor.deleteLine();
       exports.cursor.beginningOfLine();
     } else {
-      process.stdout.write('\r');
+      process.stdout.write("\r");
     }
-  }
+  },
 };
 
 var showDiff = (exports.showDiff = function (err) {
@@ -219,11 +219,11 @@ var generateDiff = (exports.generateDiff = function (actual, expected) {
     return result;
   } catch (err) {
     var msg =
-      '\n      ' +
-      color('diff added', '+ expected') +
-      ' ' +
-      color('diff removed', '- actual:  failed to generate Mocha diff') +
-      '\n';
+      "\n      " +
+      color("diff added", "+ expected") +
+      " " +
+      color("diff removed", "- actual:  failed to generate Mocha diff") +
+      "\n";
     return msg;
   }
 });
@@ -238,17 +238,17 @@ var generateDiff = (exports.generateDiff = function (actual, expected) {
  */
 var getFullErrorStack = function (err, seen) {
   if (seen && seen.has(err)) {
-    return { message: '', msg: '<circular>', stack: '' };
+    return { message: "", msg: "<circular>", stack: "" };
   }
 
   var message;
 
-  if (typeof err.inspect === 'function') {
-    message = err.inspect() + '';
-  } else if (err.message && typeof err.message.toString === 'function') {
-    message = err.message + '';
+  if (typeof err.inspect === "function") {
+    message = err.inspect() + "";
+  } else if (err.message && typeof err.message.toString === "function") {
+    message = err.message + "";
   } else {
-    message = '';
+    message = "";
   }
 
   var msg;
@@ -266,15 +266,18 @@ var getFullErrorStack = function (err, seen) {
     if (err.cause) {
       seen = seen || new Set();
       seen.add(err);
-      const causeStack = getFullErrorStack(err.cause, seen)
-      stack += '\n   Caused by: ' + causeStack.msg + (causeStack.stack ? '\n' + causeStack.stack : '');
+      const causeStack = getFullErrorStack(err.cause, seen);
+      stack +=
+        "\n   Caused by: " +
+        causeStack.msg +
+        (causeStack.stack ? "\n" + causeStack.stack : "");
     }
   }
 
   return {
     message,
     msg,
-    stack
+    stack,
   };
 };
 
@@ -293,9 +296,9 @@ exports.list = function (failures) {
   failures.forEach(function (test, i) {
     // format
     var fmt =
-      color('error title', '  %s) %s:\n') +
-      color('error message', '     %s') +
-      color('error stack', '\n%s\n');
+      color("error title", "  %s) %s:\n") +
+      color("error message", "     %s") +
+      color("error stack", "\n%s\n");
 
     // msg
     var err;
@@ -313,30 +316,30 @@ exports.list = function (failures) {
 
     // uncaught
     if (err.uncaught) {
-      msg = 'Uncaught ' + msg;
+      msg = "Uncaught " + msg;
     }
     // explicitly show diff
     if (!exports.hideDiff && showDiff(err)) {
       stringifyDiffObjs(err);
       fmt =
-        color('error title', '  %s) %s:\n%s') + color('error stack', '\n%s\n');
+        color("error title", "  %s) %s:\n%s") + color("error stack", "\n%s\n");
       var match = message.match(/^([^:]+): expected/);
-      msg = '\n      ' + color('error message', match ? match[1] : msg);
+      msg = "\n      " + color("error message", match ? match[1] : msg);
 
       msg += generateDiff(err.actual, err.expected);
     }
 
     // indent stack trace
-    stack = stack.replace(/^/gm, '  ');
+    stack = stack.replace(/^/gm, "  ");
 
     // indented test title
-    var testTitle = '';
+    var testTitle = "";
     test.titlePath().forEach(function (str, index) {
       if (index !== 0) {
-        testTitle += '\n     ';
+        testTitle += "\n     ";
       }
       for (var i = 0; i < index; i++) {
-        testTitle += '  ';
+        testTitle += "  ";
       }
       testTitle += str;
     });
@@ -361,7 +364,7 @@ function Base(runner, options) {
   var failures = (this.failures = []);
 
   if (!runner) {
-    throw new TypeError('Missing runner argument');
+    throw new TypeError("Missing runner argument");
   }
   this.options = options || {};
   this.runner = runner;
@@ -375,11 +378,11 @@ function Base(runner, options) {
 
   runner.on(EVENT_TEST_PASS, function (test) {
     if (test.duration > test.slow()) {
-      test.speed = 'slow';
+      test.speed = "slow";
     } else if (test.duration > test.slow() / 2) {
-      test.speed = 'medium';
+      test.speed = "medium";
     } else {
-      test.speed = 'fast';
+      test.speed = "fast";
     }
   });
 
@@ -411,22 +414,22 @@ Base.prototype.epilogue = function () {
 
   // passes
   fmt =
-    color('bright pass', ' ') +
-    color('green', ' %d passing') +
-    color('light', ' (%s)');
+    color("bright pass", " ") +
+    color("green", " %d passing") +
+    color("light", " (%s)");
 
   Base.consoleLog(fmt, stats.passes || 0, milliseconds(stats.duration));
 
   // pending
   if (stats.pending) {
-    fmt = color('pending', ' ') + color('pending', ' %d pending');
+    fmt = color("pending", " ") + color("pending", " %d pending");
 
     Base.consoleLog(fmt, stats.pending);
   }
 
   // failures
   if (stats.failures) {
-    fmt = color('fail', '  %d failing');
+    fmt = color("fail", "  %d failing");
 
     Base.consoleLog(fmt, stats.failures);
 
@@ -447,7 +450,7 @@ Base.prototype.epilogue = function () {
  */
 function pad(str, len) {
   str = String(str);
-  return Array(len - str.length + 1).join(' ') + str;
+  return Array(len - str.length + 1).join(" ") + str;
 }
 
 /**
@@ -462,28 +465,28 @@ function inlineDiff(actual, expected) {
   var msg = errorDiff(actual, expected);
 
   // linenos
-  var lines = msg.split('\n');
+  var lines = msg.split("\n");
   if (lines.length > 4) {
     var width = String(lines.length).length;
     msg = lines
       .map(function (str, i) {
-        return pad(++i, width) + ' |' + ' ' + str;
+        return pad(++i, width) + " |" + " " + str;
       })
-      .join('\n');
+      .join("\n");
   }
 
   // legend
   msg =
-    '\n' +
-    color('diff removed inline', 'actual') +
-    ' ' +
-    color('diff added inline', 'expected') +
-    '\n\n' +
+    "\n" +
+    color("diff removed inline", "actual") +
+    " " +
+    color("diff added inline", "expected") +
+    "\n\n" +
     msg +
-    '\n';
+    "\n";
 
   // indent
-  msg = msg.replace(/^/gm, '      ');
+  msg = msg.replace(/^/gm, "      ");
   return msg;
 }
 
@@ -496,16 +499,16 @@ function inlineDiff(actual, expected) {
  * @return {string} The diff.
  */
 function unifiedDiff(actual, expected) {
-  var indent = '      ';
+  var indent = "      ";
   function cleanUp(line) {
-    if (line[0] === '+') {
-      return indent + colorLines('diff added', line);
+    if (line[0] === "+") {
+      return indent + colorLines("diff added", line);
     }
-    if (line[0] === '-') {
-      return indent + colorLines('diff removed', line);
+    if (line[0] === "-") {
+      return indent + colorLines("diff removed", line);
     }
     if (line.match(/@@/)) {
-      return '--';
+      return "--";
     }
     if (line.match(/\\ No newline/)) {
       return null;
@@ -513,17 +516,17 @@ function unifiedDiff(actual, expected) {
     return indent + line;
   }
   function notBlank(line) {
-    return typeof line !== 'undefined' && line !== null;
+    return typeof line !== "undefined" && line !== null;
   }
-  var msg = diff.createPatch('string', actual, expected);
-  var lines = msg.split('\n').splice(5);
+  var msg = diff.createPatch("string", actual, expected);
+  var lines = msg.split("\n").splice(5);
   return (
-    '\n      ' +
-    colorLines('diff added', '+ expected') +
-    ' ' +
-    colorLines('diff removed', '- actual') +
-    '\n\n' +
-    lines.map(cleanUp).filter(notBlank).join('\n')
+    "\n      " +
+    colorLines("diff added", "+ expected") +
+    " " +
+    colorLines("diff removed", "- actual") +
+    "\n\n" +
+    lines.map(cleanUp).filter(notBlank).join("\n")
   );
 }
 
@@ -540,14 +543,14 @@ function errorDiff(actual, expected) {
     .diffWordsWithSpace(actual, expected)
     .map(function (str) {
       if (str.added) {
-        return colorLines('diff added inline', str.value);
+        return colorLines("diff added inline", str.value);
       }
       if (str.removed) {
-        return colorLines('diff removed inline', str.value);
+        return colorLines("diff removed inline", str.value);
       }
       return str.value;
     })
-    .join('');
+    .join("");
 }
 
 /**
@@ -560,11 +563,11 @@ function errorDiff(actual, expected) {
  */
 function colorLines(name, str) {
   return str
-    .split('\n')
+    .split("\n")
     .map(function (str) {
       return color(name, str);
     })
-    .join('\n');
+    .join("\n");
 }
 
 /**