Upgrade to breaking ESLint 10 and new shared config

eslint.config.js

@@ -0,0 +1,45 @@
+"use strict";
+
+const sinonConfig = require("@sinonjs/eslint-config");
+
+module.exports = [
+  {
+    ignores: [
+      "eslint.config.js",
+      "coverage/**",
+      "dist/**",
+      "docs/**",
+      "site/**",
+    ],
+  },
+  ...sinonConfig,
+  {
+    rules: {
+      "jsdoc/require-returns": "off",
+    },
+  },
+  {
+    files: ["lib/**/*.test.js"],
+    rules: {
+      "mocha/consistent-spacing-between-blocks": "off",
+      "no-unused-vars": [
+        "error",
+        { vars: "all", args: "after-used", caughtErrors: "none" },
+      ],
+    },
+  },
+  {
+    files: ["lib/assertions/json.js", "lib/assertions/match-json.js"],
+    rules: {
+      "no-unused-vars": "off",
+    },
+  },
+  {
+    languageOptions: {
+      globals: {
+        ArrayBuffer: false,
+        Uint8Array: false,
+      },
+    },
+  },
+];

lib/actual-and-expected-message-values.js

@@ -1,5 +1,10 @@
 "use strict";
 
+/**
+ * @param {unknown} actual
+ * @param {unknown} expected
+ * @param {unknown} message
+ */
 function actualAndExpectedMessageValues(actual, expected, message) {
   return {
     actual: actual,

lib/actual-and-type-of-message-values.js

@@ -1,5 +1,9 @@
 "use strict";
 
+/**
+ * @param {unknown} actual
+ * @param {unknown} message
+ */
 function actualAndTypeOfMessageValues(actual, message) {
   return {
     actual: actual,

lib/actual-for-match.js

@@ -2,6 +2,10 @@
 
 var toString = require("@sinonjs/commons").prototypes.object.toString;
 
+/**
+ * @param {unknown} actual
+ * @param {unknown} match
+ */
 function actualForMatch(actual, match) {
   if (
     toString(actual) === "[object Object]" &&

lib/actual-message-values.js

@@ -1,5 +1,9 @@
 "use strict";
 
+/**
+ * @param {unknown} actual
+ * @param {unknown} message
+ */
 function actualMessageValues(actual, message) {
   return {
     actual: actual,

lib/assert-arg-num.js

@@ -2,6 +2,12 @@
 
 // Internal helper. Used throughout to fail assertions if they receive
 // too few arguments. The name is provided for a helpful error message.
+/**
+ * @param {(message: string) => void} fail
+ * @param {string} name
+ * @param {{length: number}} args
+ * @param {number} num
+ */
 function assertArgNum(fail, name, args, num) {
   if (args.length >= num) {
     return true;

lib/assertions/has-arity.js

@@ -2,6 +2,9 @@
 
 var actualAndExpectedMessageValues = require("../actual-and-expected-message-values");
 
+/**
+ * @param {{add: (name: string, options: unknown) => void}} referee
+ */
 function addHasArity(referee) {
   referee.add("hasArity", {
     assert: function assert(actual, expected) {

lib/assertions/is-array-like.js

@@ -4,6 +4,9 @@ var isArguments = require("lodash.isarguments");
 var actualMessageValues = require("../actual-message-values");
 
 module.exports = function (referee) {
+  /**
+   * @param {unknown} object
+   */
   function isArrayLike(object) {
     return (
       Array.isArray(object) ||

lib/assertions/keys.js

@@ -1,6 +1,10 @@
 "use strict";
 
 module.exports = function (referee) {
+  /**
+   * @param {Record<string, unknown>} object
+   * @param {string[]} keys
+   */
   function exactKeys(object, keys) {
     var keyMap = {};
     var keyCnt = 0;

lib/assertions/rejects.js

@@ -7,6 +7,9 @@ var assertMessage = "${actual} is not equal to ${expected}";
 var refuteMessage = "${actual} is equal to ${expected}";
 
 module.exports = function (referee) {
+  /**
+   *
+   */
   function thenCallback() {
     this.reject("${0} did not reject, it resolved instead");
   }

lib/assertions/resolves.js

@@ -7,6 +7,9 @@ var assertMessage = "${actual} is not equal to ${expected}";
 var refuteMessage = "${actual} is equal to ${expected}";
 
 module.exports = function (referee) {
+  /**
+   *
+   */
   function catchCallback() {
     this.reject("${0} did not resolve, it rejected instead");
   }

lib/capture-exception.js

@@ -1,5 +1,8 @@
 "use strict";
 
+/**
+ * @param {() => unknown} callback
+ */
 function captureException(callback) {
   try {
     callback();

lib/create-add.js

@@ -5,6 +5,17 @@ var defineAssertion = require("./define-assertion");
 // taken from https://stackoverflow.com/questions/2008279/validate-a-javascript-function-name/2008444#2008444
 var validFunctionName = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
 
+/**
+ * @param {string} name
+ * @param {{
+ *   assert: (...args: unknown[]) => unknown,
+ *   refute?: (...args: unknown[]) => unknown,
+ *   assertMessage?: string | ((...args: unknown[]) => unknown),
+ *   refuteMessage?: string | ((...args: unknown[]) => unknown),
+ *   values?: unknown,
+ *   expectation?: string
+ * }} options
+ */
 function verifyArguments(name, options) {
   if (typeof name !== "string" || !validFunctionName.test(name)) {
     throw new TypeError(
@@ -64,7 +75,21 @@ function isValidMessageOption(message) {
   return false;
 }
 
+/**
+ * @param {object} referee
+ */
 function createAdd(referee) {
+  /**
+   * @param {string} name
+   * @param {{
+   *   assert: (...args: unknown[]) => unknown,
+   *   refute?: (...args: unknown[]) => unknown,
+   *   assertMessage?: string | ((...args: unknown[]) => unknown),
+   *   refuteMessage?: string | ((...args: unknown[]) => unknown),
+   *   values?: unknown,
+   *   expectation?: string
+   * }} options
+   */
   function add(name, options) {
     verifyArguments(name, options);
 

lib/create-assert.js

@@ -2,7 +2,14 @@
 
 var assertArgNum = require("./assert-arg-num");
 
+/**
+ * @param {{emit: (eventName: string, ...args: unknown[]) => void, fail: (message: string) => never}} referee
+ */
 function createAssert(referee) {
+  /**
+   * @param {unknown} actual
+   * @param {string} message
+   */
   function assert(actual, message) {
     assertArgNum(referee.fail, "assert", arguments, 1);
 

lib/create-async-assertion.js

@@ -2,10 +2,21 @@
 
 var samsam = require("@sinonjs/samsam");
 
+/**
+ * @param {(actual: unknown, expected: unknown) => void} thenFunc
+ * @param {(actual: unknown, expected: unknown) => void} catchFunc
+ */
 function createAsyncAssertion(thenFunc, catchFunc) {
+  /**
+   * @param {Promise<unknown>} promise
+   */
   function asyncAssertion(promise) {
     var self = this;
     this.expected = arguments.length === 1 ? samsam.match.any : arguments[1];
+    /**
+     * @param {(actual: unknown, expected: unknown) => void} callback
+     * @param {{reject: (message: unknown) => void, resolve: (value: unknown) => void}} context
+     */
     function applyCallback(callback, context) {
       return function (actual) {
         self.actual = actual;

lib/create-expect.js

@@ -2,7 +2,13 @@
 
 var expectImpl = require("./expect");
 
+/**
+ * @param {object} referee
+ */
 function createExpect(referee) {
+  /**
+   *
+   */
   function expect() {
     expectImpl.init(referee);
     return expectImpl.apply(referee, arguments);

lib/create-fail.js

@@ -1,6 +1,13 @@
 "use strict";
 
+/**
+ * @param {{emit: (eventName: string, error: unknown) => void, throwOnFailure?: boolean}} referee
+ */
 function createFail(referee) {
+  /**
+   * @param {string} message
+   * @param {Record<string, unknown>} [errorProperties]
+   */
   function fail(message, errorProperties) {
     var exception = new Error(message);
     exception.name = "AssertionError";

lib/create-pass.js

@@ -1,8 +1,14 @@
 "use strict";
 
+/**
+ * @param {{emit: (...args: unknown[]) => void}} referee
+ */
 function createPass(referee) {
-  function pass(message) {
-    referee.emit.apply(referee, message);
+  /**
+   * @param {unknown[]} args
+   */
+  function pass(args) {
+    referee.emit.apply(referee, args);
   }
 
   return pass;

lib/create-refute.js

@@ -2,7 +2,14 @@
 
 var assertArgNum = require("./assert-arg-num");
 
+/**
+ * @param {{emit: (eventName: string, ...args: unknown[]) => void, fail: (message: string) => never}} referee
+ */
 function createRefute(referee) {
+  /**
+   * @param {unknown} actual
+   * @param {string} message
+   */
   function refute(actual, message) {
     assertArgNum(referee.fail, "refute", arguments, 1);
 

lib/create-verifier.js

@@ -1,16 +1,28 @@
 "use strict";
 
+/**
+ * @param {{on: (eventName: string, listener: () => void) => void, off: (eventName: string, listener: () => void) => void}} referee
+ */
 function createVerifier(referee) {
+  /**
+   *
+   */
   function verifier() {
     var count = 0;
 
+    /**
+     * @returns {void}
+     */
     function incrementCount() {
       count += 1;
     }
 
     referee.on("pass", incrementCount);
     referee.on("failure", incrementCount);
 
+    /**
+     * @param {number} expected
+     */
     function verify(expected) {
       referee.off("pass", incrementCount);
       referee.off("failure", incrementCount);

lib/custom-assertions.test.js

@@ -58,7 +58,6 @@ describe("custom assertions", function () {
 
     try {
       referee.assert.custom(2, 3);
-      // eslint-disable-next-line no-empty
     } catch (e) {
       actualMessage = e.message;
     }

lib/define-assertion/format.js

@@ -2,12 +2,24 @@
 
 var inspect = require("util").inspect;
 
+/**
+ * @param {unknown} object
+ */
 function format(object) {
   if (object instanceof Error) {
     return object.name;
   }
 
-  return inspect(object);
+  var formatted = inspect(object);
+
+  if (object instanceof ArrayBuffer || object instanceof DataView) {
+    return formatted
+      .replace(/\[byteLength\]:/g, "byteLength:")
+      .replace(/\[byteOffset\]:/g, "byteOffset:")
+      .replace(/\[buffer\]:/g, "buffer:");
+  }
+
+  return formatted;
 }
 
 module.exports = format;