@util.js/errors 0.41.5 → 0.41.7

package/package.json

@@ -4,6 +4,11 @@
     "@babel/runtime-corejs3": "7.29.7"
   },
   "description": "JavaScript utility methods for errors",
+  "files": [
+    "dist",
+    "index.js",
+    "RethrownError.js"
+  ],
   "keywords": [
     "error",
     "errors",
@@ -25,5 +30,5 @@
     "type": "git",
     "url": "https://github.com/creemama/utiljs/tree/master/packages/utiljs-errors"
   },
-  "version": "0.41.5"
+  "version": "0.41.7"
 }

package/doc/README-examples.js

@@ -1,71 +0,0 @@
-"use strict";
-
-if (process.argv.length < 3) {
-  for (let i = 0; i < 1; i++) runExample(i);
-} else {
-  runExample(parseInt(process.argv[2]));
-}
-
-function runExample(i) {
-  switch (i) {
-    case 0:
-      runExample0();
-      break;
-  }
-}
-
-function runExample0() {
-  const errors = require("..");
-  function rejectAPromise() {
-    return Promise.reject(new TypeError("Fail!"));
-  }
-
-  errors
-    .catch(rejectAPromise())
-    .catch((error) =>
-      console.log("\n\nWith Caller Stack Trace\n" + error.stack),
-    );
-  // With Caller Stack Trace
-  // AsyncError: Fail!
-  //     at promise.catch.error (/root/utiljs/packages/utiljs-errors/lib/Errors.js:28:13)
-  //     at process._tickCallback (internal/process/next_tick.js:68:7)
-  //     at Function.Module.runMain (internal/modules/cjs/loader.js:746:11)
-  //     at startup (internal/bootstrap/node.js:240:19)
-  //     at bootstrapNodeJSCore (internal/bootstrap/node.js:564:3)
-  //     at runExample0 (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:23:11)
-  //     at runExample (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:12:7)
-  //     at Object.<anonymous> (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:4:31)
-  //     at Module._compile (internal/modules/cjs/loader.js:702:30)
-  //     at Object.Module._extensions..js (internal/modules/cjs/loader.js:713:10)
-  //     at Module.load (internal/modules/cjs/loader.js:612:32)
-  //     at tryModuleLoad (internal/modules/cjs/loader.js:551:12)
-  //     at Function.Module._load (internal/modules/cjs/loader.js:543:3)
-  //     at Function.Module.runMain (internal/modules/cjs/loader.js:744:10)
-  // TypeError: Fail!
-  //     at rejectAPromise (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:20:27)
-  //     at runExample0 (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:23:12)
-  //     at runExample (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:12:7)
-  //     at Object.<anonymous> (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:4:31)
-  //     at Module._compile (internal/modules/cjs/loader.js:702:30)
-  //     at Object.Module._extensions..js (internal/modules/cjs/loader.js:713:10)
-  //     at Module.load (internal/modules/cjs/loader.js:612:32)
-  //     at tryModuleLoad (internal/modules/cjs/loader.js:551:12)
-  //     at Function.Module._load (internal/modules/cjs/loader.js:543:3)
-  //     at Function.Module.runMain (internal/modules/cjs/loader.js:744:10)
-
-  rejectAPromise().catch((error) =>
-    console.log("\n\nWithout Caller Stack Trace\n" + error.stack),
-  );
-  // Without Caller Stack Trace
-  // TypeError: Fail!
-  //     at rejectAPromise (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:20:27)
-  //     at runExample0 (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:53:3)
-  //     at runExample (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:12:7)
-  //     at Object.<anonymous> (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:4:31)
-  //     at Module._compile (internal/modules/cjs/loader.js:702:30)
-  //     at Object.Module._extensions..js (internal/modules/cjs/loader.js:713:10)
-  //     at Module.load (internal/modules/cjs/loader.js:612:32)
-  //     at tryModuleLoad (internal/modules/cjs/loader.js:551:12)
-  //     at Function.Module._load (internal/modules/cjs/loader.js:543:3)
-  //     at Function.Module.runMain (internal/modules/cjs/loader.js:744:10)
-}

package/lib/AsyncError.js

@@ -1,38 +0,0 @@
-"use strict";
-
-/*
- * See {@link Errors#AsyncError}.
- */
-module.exports = class AsyncError extends Error {
-  constructor(callerError, asyncError, message) {
-    super(message != null ? message : getErrorProperty(asyncError, "message"));
-    if (!callerError)
-      throw new TypeError(
-        `${this.constructor.name}'s constructor expects a defined callerError, but it was ${callerError}.`,
-      );
-    if (!asyncError)
-      throw new TypeError(
-        `${this.constructor.name}'s constructor expects a defined asyncError, but it was ${asyncError}.`,
-      );
-    this.name = this.constructor.name;
-    this.original = asyncError;
-    this.newStack = this.stack;
-    const callerStack =
-      "    at " + callerError.stack.split("    at ").splice(2).join("    at ");
-    // If asyncError.stack is falsy, then let us just try asyncError;
-    // asyncError may be a string.
-    const asyncErrorStack = getErrorProperty(asyncError, "stack");
-    this.stack = `${this.stack}\n${callerStack}\n${asyncErrorStack}`;
-  }
-};
-
-function getErrorProperty(error, property) {
-  if (error[property]) return error[property];
-  try {
-    return JSON.stringify(error);
-  } catch (e) {
-    // JSON.stringify might throw the following, "TypeError: Converting circular
-    // structure to JSON."
-    return error;
-  }
-}

package/lib/Errors.js

@@ -1,148 +0,0 @@
-"use strict";
-
-/**
- * JavaScript utility methods for [errors]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error}
- *
- * @public
- * @class Errors
- */
-module.exports = class Errors {
-  /**
-   * Wraps the given promise so that errors caught preserve the stack trace of the calling thread.
-   *
-   * The example compares the stack trace of a rejected promise using this method and the stack trace of a rejected promise that does not use this method.
-   *
-   * @example
-   * const errors = require("@util.js/errors");
-   * function rejectAPromise() {
-   *   return Promise.reject(new TypeError("Fail!"));
-   * }
-   *
-   * errors
-   *   .catch(rejectAPromise())
-   *   .catch(error => console.log("\n\nWith Caller Stack Trace\n" + error.stack));
-   * // With Caller Stack Trace
-   * // AsyncError: Fail!
-   * //     at promise.catch.error (/root/utiljs/packages/utiljs-errors/lib/Errors.js:28:13)
-   * //     at process._tickCallback (internal/process/next_tick.js:68:7)
-   * //     at Function.Module.runMain (internal/modules/cjs/loader.js:746:11)
-   * //     at startup (internal/bootstrap/node.js:240:19)
-   * //     at bootstrapNodeJSCore (internal/bootstrap/node.js:564:3)
-   * //     at runExample0 (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:23:11)
-   * //     at runExample (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:12:7)
-   * //     at Object.<anonymous> (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:4:31)
-   * //     at Module._compile (internal/modules/cjs/loader.js:702:30)
-   * //     at Object.Module._extensions..js (internal/modules/cjs/loader.js:713:10)
-   * //     at Module.load (internal/modules/cjs/loader.js:612:32)
-   * //     at tryModuleLoad (internal/modules/cjs/loader.js:551:12)
-   * //     at Function.Module._load (internal/modules/cjs/loader.js:543:3)
-   * //     at Function.Module.runMain (internal/modules/cjs/loader.js:744:10)
-   * // TypeError: Fail!
-   * //     at rejectAPromise (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:20:27)
-   * //     at runExample0 (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:23:12)
-   * //     at runExample (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:12:7)
-   * //     at Object.<anonymous> (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:4:31)
-   * //     at Module._compile (internal/modules/cjs/loader.js:702:30)
-   * //     at Object.Module._extensions..js (internal/modules/cjs/loader.js:713:10)
-   * //     at Module.load (internal/modules/cjs/loader.js:612:32)
-   * //     at tryModuleLoad (internal/modules/cjs/loader.js:551:12)
-   * //     at Function.Module._load (internal/modules/cjs/loader.js:543:3)
-   * //     at Function.Module.runMain (internal/modules/cjs/loader.js:744:10)
-   *
-   * rejectAPromise().catch(error =>
-   *   console.log("\n\nWithout Caller Stack Trace\n" + error.stack)
-   * );
-   * // Without Caller Stack Trace
-   * // TypeError: Fail!
-   * //     at rejectAPromise (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:20:27)
-   * //     at runExample0 (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:53:3)
-   * //     at runExample (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:12:7)
-   * //     at Object.<anonymous> (/root/utiljs/packages/utiljs-errors/doc/README-examples.js:4:31)
-   * //     at Module._compile (internal/modules/cjs/loader.js:702:30)
-   * //     at Object.Module._extensions..js (internal/modules/cjs/loader.js:713:10)
-   * //     at Module.load (internal/modules/cjs/loader.js:612:32)
-   * //     at tryModuleLoad (internal/modules/cjs/loader.js:551:12)
-   * //     at Function.Module._load (internal/modules/cjs/loader.js:543:3)
-   * //     at Function.Module.runMain (internal/modules/cjs/loader.js:744:10)
-   *
-   * @param {Promise} promise The promise to wrap
-   * @param {String} [message] A human-readable description of the error
-   * @return {Promise} A promise that upon rejection wraps the error in an AsyncError and rethrows
-   * @throws {TypeError} If the given promise is not an instance of Promise
-   *
-   * @public
-   * @function Errors#catch
-   */
-  catch(promise, message) {
-    const callerError = new Error();
-    return promise.catch((error) => {
-      throw new this.AsyncError(callerError, error, message);
-    });
-  }
-
-  /**
-   * An error that preserves the stack trace of the thread that calls an asynchronous function.
-   *
-   * Use {@link Errors#catch} to use this class. Use this class directly for instanceof checks.
-   *
-   * @public
-   * @class Errors#AsyncError
-   */
-  get AsyncError() {
-    return require("./AsyncError");
-  }
-
-  get FalsyError() {
-    return require("./FalsyError");
-  }
-
-  get MissingError() {
-    return require("./MissingError");
-  }
-
-  /**
-   * A wrapper of another error used for rethrowing.
-   *
-   * This error preserves information about the original error and its stack trace.
-   *
-   * A [Stack Overflow]{@link https://stackoverflow.com/questions/42754270/re-throwing-exception-in-nodejs-and-not-losing-stack-trace} article inspired this class.
-   *
-   * @example
-   * function throwATypeError() {
-   *   throw new TypeError("Invalid Argument");
-   * }
-   *
-   * function rethrowTheTypeError() {
-   *   try {
-   *     throwATypeError();
-   *   } catch (error) {
-   *     throw new RethrownError(error, "Lorem Ipsum");
-   *   }
-   * }
-   *
-   * try {
-   *   rethrowTheTypeError();
-   * } catch (error) {
-   *   console.log(error.stack);
-   *   // This outputs a stack trace like the following:
-   *   //
-   *   // RethrownError: Lorem Ipsum
-   *   //     at rethrowTheTypeError (/root/utiljs/packages/utiljs-errors/test/ErrorsTest.js:16:15)
-   *   // TypeError: Invalid Argument
-   *   //     at throwATypeError (/root/utiljs/packages/utiljs-errors/test/ErrorsTest.js:10:13)
-   *   //     at rethrowTheTypeError (/root/utiljs/packages/utiljs-errors/test/ErrorsTest.js:14:9)
-   *   //     at Context.it (/root/utiljs/packages/utiljs-errors/test/ErrorsTest.js:20:7)
-   *   //     ...
-   * }
-   *
-   * @param {Error} error The error to rethrow
-   * @param {String} [message] A human-readable description of the error
-   * @throws {TypeError} if the given error is not defined
-   *
-   * @public
-   * @class Errors#RethrownError
-   */
-  get RethrownError() {
-    return require("./RethrownError");
-  }
-};

package/lib/FalsyError.js

@@ -1,27 +0,0 @@
-"use strict";
-
-module.exports = class FalsyError extends TypeError {
-  static check(argumentValue, argumentName, functionName) {
-    if (argumentValue) return;
-    throw new FalsyError(argumentValue, argumentName, functionName);
-  }
-
-  constructor(argumentValue, argumentName, functionName) {
-    super(
-      argumentValue
-        ? "Why are you creating a FalsyError with a truthy `argumentValue`: '" +
-            argumentValue +
-            "'?"
-        : (functionName || "We") +
-            " expected " +
-            (argumentName ? "`" + argumentName + "`" : "an argument") +
-            " to be truthy. " +
-            (argumentName ? "`" + argumentName + "`" : "It") +
-            " is the falsy value " +
-            (argumentValue === "" ? "''" : argumentValue) +
-            ".",
-    );
-    this.name = this.constructor.name;
-    this.argumentName = argumentName;
-  }
-};

package/lib/MissingError.js

@@ -1,27 +0,0 @@
-"use strict";
-
-module.exports = class MissingError extends TypeError {
-  static check(argumentValue, argumentName, functionName) {
-    if (argumentValue != null) return;
-    throw new MissingError(argumentValue, argumentName, functionName);
-  }
-
-  constructor(argumentValue, argumentName, functionName) {
-    super(
-      argumentValue != null
-        ? "Why are you creating a MissingError with a defined `argumentValue`: '" +
-            argumentValue +
-            "'?"
-        : (functionName || "We") +
-            " expected " +
-            (argumentName ? "`" + argumentName + "`" : "an argument") +
-            " to be defined. " +
-            (argumentName ? "`" + argumentName + "`" : "It") +
-            " is '" +
-            argumentValue +
-            "'.",
-    );
-    this.name = this.constructor.name;
-    this.argumentName = argumentName;
-  }
-};

package/lib/RethrownError.js

@@ -1,30 +0,0 @@
-"use strict";
-
-/*
- * See {@link Errors#RethrownError}.
- */
-module.exports = class RethrownError extends Error {
-  constructor(error, message) {
-    super(message != null ? message : getErrorProperty(error, "message"));
-    if (!error)
-      throw new TypeError(
-        `RethrownError's constructor expects a defined error, but it was ${error}.`,
-      );
-    this.name = this.constructor.name;
-    this.original = error;
-    this.newStack = this.stack;
-    const errorStack = getErrorProperty(error, "stack");
-    this.stack = `${this.stack}\n${errorStack}`;
-  }
-};
-
-function getErrorProperty(error, property) {
-  if (error[property]) return error[property];
-  try {
-    return JSON.stringify(error);
-  } catch (e) {
-    // JSON.stringify might throw the following, "TypeError: Converting circular
-    // structure to JSON."
-    return error;
-  }
-}

package/test/ErrorsTest.js

@@ -1,191 +0,0 @@
-"use strict";
-
-const { expect } = require("chai");
-const errors = require("..");
-const { AsyncError, RethrownError } = errors;
-
-describe("Errors#catch(promise)", () => {
-  it("should return a Promise that throws an AsyncError upon rejection", () => {
-    function rejectAPromise() {
-      return Promise.reject(new TypeError("Fail!"));
-    }
-    return errors.catch(rejectAPromise()).catch((error) => {
-      expect(error).to.be.an.instanceof(AsyncError);
-      expect(error.message).to.eql("Fail!");
-      expect(error.original).to.be.an.instanceof(TypeError);
-      expect(error.stack).to.include("AsyncError: Fail!");
-      expect(error.stack).to.include("at rejectAPromise");
-      expect(error.stack).to.include("TypeError: Fail!");
-    });
-  });
-  it("should take the optional message argument", () => {
-    function rejectAPromise() {
-      return Promise.reject(new TypeError("Fail!"));
-    }
-    return errors.catch(rejectAPromise(), "optional message").catch((error) => {
-      expect(error).to.be.an.instanceof(AsyncError);
-      expect(error.message).to.eql("optional message");
-      expect(error.original).to.be.an.instanceof(TypeError);
-      expect(error.stack).to.include("AsyncError: optional message");
-      expect(error.stack).to.include("at rejectAPromise");
-      expect(error.stack).to.include("TypeError: Fail!");
-    });
-  });
-  it("should return a Promise that throws an AsyncError upon rejecting with a string", () => {
-    function rejectAPromise() {
-      // eslint-disable-next-line prefer-promise-reject-errors
-      return Promise.reject("ENTITY_NOT_FOUND");
-    }
-    return errors.catch(rejectAPromise()).catch((error) => {
-      expect(error).to.be.an.instanceof(AsyncError);
-      expect(error.message).to.eql('"ENTITY_NOT_FOUND"');
-      expect(error.original).to.eql("ENTITY_NOT_FOUND");
-      expect(error.stack).to.include("AsyncError");
-      expect(error.stack).to.include("ENTITY_NOT_FOUND");
-    });
-  });
-  it("should return a Promise that throws an AsyncError upon rejecting with an array", () => {
-    function rejectAPromise() {
-      // eslint-disable-next-line prefer-promise-reject-errors
-      return Promise.reject([{ code: "1234" }]);
-    }
-    return errors.catch(rejectAPromise()).catch((error) => {
-      expect(error).to.be.an.instanceof(AsyncError);
-      expect(error.message).to.eql('[{"code":"1234"}]');
-      expect(error.original).to.eql([{ code: "1234" }]);
-      expect(error.stack).to.include("AsyncError");
-      expect(error.stack).to.include('[{"code":"1234"}]');
-    });
-  });
-  it("should return a Promise that throws an AsyncError upon rejecting with a circularly referenced object", () => {
-    const obj = {};
-    obj.circular = obj;
-    return errors.catch(Promise.reject(obj)).catch((error) => {
-      expect(error).to.be.an.instanceof(AsyncError);
-      expect(error.message).to.eql("[object Object]");
-      expect(error.original).to.eql(obj);
-      expect(error.stack).to.include("AsyncError");
-      expect(error.stack).to.include("[object Object]");
-    });
-  });
-  it("should throw a TypeError if the given promise is not defined", () => {
-    expect(() => errors.catch()).to.throw(TypeError);
-  });
-});
-
-describe("new Errors#RethrownError(message, error)", () => {
-  it("should create a rethrown error with an appropriate stack trace", () => {
-    function throwATypeError() {
-      throw new TypeError("Invalid Argument");
-    }
-    function rethrowTheTypeError() {
-      try {
-        throwATypeError();
-      } catch (error) {
-        expect(new RethrownError(error).stack).to.include(
-          "RethrownError: Invalid Argument\n",
-        );
-        expect(new RethrownError(error, "").stack).to.include(
-          "RethrownError\n",
-        );
-        throw new RethrownError(error, "Lorem Ipsum");
-      }
-    }
-    try {
-      rethrowTheTypeError();
-      expect.fail("We expected the runtime to throw a RethrownError.");
-    } catch (error) {
-      if (!(error instanceof RethrownError)) throw error;
-      expect(error.message).to.eql("Lorem Ipsum");
-      expect(error.original).to.be.an.instanceof(TypeError);
-      expect(error.stack).to.include("RethrownError: Lorem Ipsum");
-      expect(error.stack).to.include("at rethrowTheTypeError");
-      expect(error.stack).to.include("TypeError: Invalid Argument");
-      expect(error.stack).to.include("at throwATypeError");
-    }
-  });
-  it("should create a rethrown error from a thrown string", () => {
-    function throwAString() {
-      // eslint-disable-next-line no-throw-literal
-      throw "ENTITY_NOT_FOUND";
-    }
-    function rethrowTheString() {
-      try {
-        throwAString();
-      } catch (error) {
-        expect(new RethrownError(error).stack).to.include(
-          'RethrownError: "ENTITY_NOT_FOUND"\n',
-        );
-        expect(new RethrownError(error).stack.endsWith('"ENTITY_NOT_FOUND"')).to
-          .be.true;
-        expect(new RethrownError(error, "").stack).to.include(
-          "RethrownError\n",
-        );
-        expect(new RethrownError(error, 0).stack).to.include(
-          "RethrownError: 0\n",
-        );
-        expect(new RethrownError(error, "").stack).to.include(
-          "ENTITY_NOT_FOUND",
-        );
-        throw new RethrownError(error, "Lorem Ipsum");
-      }
-    }
-    try {
-      rethrowTheString();
-      expect.fail("We expected the runtime to throw a RethrownError.");
-    } catch (error) {
-      if (!(error instanceof RethrownError)) throw error;
-      expect(error.message).to.eql("Lorem Ipsum");
-      expect(error.original).to.eql("ENTITY_NOT_FOUND");
-      expect(error.stack).to.include("RethrownError");
-      expect(error.stack).to.include("at rethrowTheString");
-      expect(error.stack).to.include("ENTITY_NOT_FOUND");
-    }
-  });
-  it("should create a rethrown error from a thrown array", () => {
-    function throwAnArray() {
-      // eslint-disable-next-line no-throw-literal
-      throw [{ code: "1234" }];
-    }
-    function rethrowTheArray() {
-      try {
-        throwAnArray();
-      } catch (error) {
-        expect(new RethrownError(error).stack).to.include(
-          'RethrownError: [{"code":"1234"}]\n',
-        );
-        expect(new RethrownError(error).stack.endsWith('[{"code":"1234"}]')).to
-          .be.true;
-        expect(new RethrownError(error, "").stack).to.include(
-          "RethrownError\n",
-        );
-        expect(new RethrownError(error, "").stack).to.include(
-          '[{"code":"1234"}]',
-        );
-        throw new RethrownError(error, "Lorem Ipsum");
-      }
-    }
-    try {
-      rethrowTheArray();
-      expect.fail("We expected the runtime to throw a RethrownError.");
-    } catch (error) {
-      if (!(error instanceof RethrownError)) throw error;
-      expect(error.message).to.eql("Lorem Ipsum");
-      expect(error.original).to.eql([{ code: "1234" }]);
-      expect(error.stack).to.include("RethrownError");
-      expect(error.stack).to.include("at rethrowTheArray");
-      expect(error.stack).to.include('[{"code":"1234"}]');
-    }
-  });
-  it("should create a rethrown error from a circularly referenced object", () => {
-    const obj = {};
-    obj.circular = obj;
-    const error = new RethrownError(obj);
-    expect(error.stack).to.include("RethrownError: [object Object]\n");
-    expect(error.stack).to.include("[object Object]");
-  });
-  it("should throw an error when given an invalid error", () => {
-    expect(() => new RethrownError()).to.throw(TypeError);
-    expect(() => new RethrownError(null, "Lorem Ipsum")).to.throw(TypeError);
-  });
-});

package/test/Errors_FalsyError_Test.js

@@ -1,84 +0,0 @@
-"use strict";
-
-const { expect } = require("chai");
-const { FalsyError } = require("..");
-
-describe("FalsyError#constructor", () => {
-  it('should create a new FalsyError instance given a falsy argument value: (null, "argument", "Lawyer#argue").', () => {
-    const actual = new FalsyError(null, "argument", "Lawyer#argue");
-
-    expect(actual).to.be.an.instanceof(TypeError);
-
-    const expectedName = "FalsyError";
-    const actualName = actual.name;
-    expect(actualName).to.equal(expectedName);
-
-    const expectedMessage =
-      "Lawyer#argue expected `argument` to be truthy. `argument` is the falsy value null.";
-    const actualMessage = actual.message;
-    expect(actualMessage).to.equal(expectedMessage);
-
-    const expectedArgumentName = "argument";
-    const actualArgumentName = actual.argumentName;
-    expect(actualArgumentName).to.equal(expectedArgumentName);
-  });
-
-  it('should create a new FalsyError instance given a falsy argument value: (0, "argument").', () => {
-    const actual = new FalsyError(0, "argument");
-
-    expect(actual).to.be.an.instanceof(TypeError);
-
-    const expectedName = "FalsyError";
-    const actualName = actual.name;
-    expect(actualName).to.equal(expectedName);
-
-    const expectedMessage =
-      "We expected `argument` to be truthy. `argument` is the falsy value 0.";
-    const actualMessage = actual.message;
-    expect(actualMessage).to.equal(expectedMessage);
-
-    const expectedArgumentName = "argument";
-    const actualArgumentName = actual.argumentName;
-    expect(actualArgumentName).to.equal(expectedArgumentName);
-  });
-
-  it('should create a new FalsyError instance given a falsy argument value: ("", null, "Lawyer#argue").', () => {
-    const actual = new FalsyError("", null, "Lawyer#argue");
-
-    expect(actual).to.be.an.instanceof(TypeError);
-
-    const expectedName = "FalsyError";
-    const actualName = actual.name;
-    expect(actualName).to.equal(expectedName);
-
-    const expectedMessage =
-      "Lawyer#argue expected an argument to be truthy. It is the falsy value ''.";
-    const actualMessage = actual.message;
-    expect(actualMessage).to.equal(expectedMessage);
-
-    const actualArgumentName = actual.argumentName;
-    expect(actualArgumentName).to.be.null;
-  });
-
-  it('should create a new FalsyError instance even when given a truthy argument value: ("whyTruthy", "badUsage", "Coder#useWrong").', () => {
-    // If a coder constructs this class with a truthy argument, they are using
-    // this constructor wrong. The coder is already throwing an error, so let us
-    // just display a weird message instead of throwing a different error.
-
-    const actual = new FalsyError("whyTruthy", "badUsage", "Coder#useWrong");
-
-    expect(actual).to.be.an.instanceof(TypeError);
-
-    const expectedName = "FalsyError";
-    const actualName = actual.name;
-    expect(actualName).to.equal(expectedName);
-
-    const expectedMessage =
-      "Why are you creating a FalsyError with a truthy `argumentValue`: 'whyTruthy'?";
-    const actualMessage = actual.message;
-    expect(actualMessage).to.equal(expectedMessage);
-
-    const actualArgumentName = actual.argumentName;
-    expect(actualArgumentName).to.equal("badUsage");
-  });
-});

package/test/Errors_FalsyError_check_Test.js

@@ -1,74 +0,0 @@
-"use strict";
-
-const { expect } = require("chai");
-const { FalsyError } = require("..");
-
-describe("FalsyError#check", () => {
-  it('should throw a FalsyError given a falsy argument value: (NaN, "argument", "Lawyer#argue").', () => {
-    try {
-      FalsyError.check(NaN, "argument", "Lawyer#argue");
-      throw new Error("The method did not throw an error.");
-    } catch (e) {
-      expect(e).to.be.an.instanceof(FalsyError);
-      expect(e.message).to.equal(
-        "Lawyer#argue expected `argument` to be truthy. `argument` is the falsy value NaN.",
-      );
-      expect(e.argumentName).to.equal("argument");
-    }
-  });
-
-  it('should throw a FalsyError given a falsy argument value: (false, "argument").', () => {
-    try {
-      FalsyError.check(false, "argument");
-      throw new Error("The method did not throw an error.");
-    } catch (e) {
-      expect(e).to.be.an.instanceof(FalsyError);
-      expect(e.message).to.equal(
-        "We expected `argument` to be truthy. `argument` is the falsy value false.",
-      );
-      expect(e.argumentName).to.equal("argument");
-    }
-  });
-
-  it('should throw a FalsyError given a falsy argument value: (undefined, null, "Lawyer#argue").', () => {
-    try {
-      FalsyError.check(undefined, null, "Lawyer#argue");
-      throw new Error("The method did not throw an error.");
-    } catch (e) {
-      expect(e).to.be.an.instanceof(FalsyError);
-      expect(e.message).to.equal(
-        "Lawyer#argue expected an argument to be truthy. It is the falsy value undefined.",
-      );
-      expect(e.argumentName).to.be.null;
-    }
-  });
-
-  it("should throw a FalsyError given a falsy argument value: (null).", () => {
-    try {
-      FalsyError.check(null);
-      throw new Error("The method did not throw an error.");
-    } catch (e) {
-      expect(e).to.be.an.instanceof(FalsyError);
-      expect(e.message).to.equal(
-        "We expected an argument to be truthy. It is the falsy value null.",
-      );
-      expect(e.argumentName).to.be.undefined;
-    }
-  });
-
-  it('should do nothing given a truthy argument value: ("truthyValue", "truthy", "Fountain#spitTruth").', () => {
-    FalsyError.check("truthyValue", "truthy", "Fountain#spitTruth");
-  });
-
-  it('should do nothing given a truthy argument value: ("truthyValue", "truthy").', () => {
-    FalsyError.check("truthyValue", "truthy");
-  });
-
-  it('should do nothing given a truthy argument value: ("truthyValue", null, "Fountain#spitTruth").', () => {
-    FalsyError.check("truthyValue", null, "Fountain#spitTruth");
-  });
-
-  it('should do nothing given a truthy argument value: ("truthyValue").', () => {
-    FalsyError.check("truthyValue");
-  });
-});

package/test/Errors_MissingError_Test.js

@@ -1,158 +0,0 @@
-"use strict";
-
-const { expect } = require("chai");
-const { MissingError } = require("..");
-
-describe("MissingError#constructor", () => {
-  it('should create a new MissingError instance given a \'null\' argument value: (null, "argument", "Lawyer#argue").', () => {
-    const actual = new MissingError(null, "argument", "Lawyer#argue");
-
-    expect(actual).to.be.an.instanceof(TypeError);
-
-    const expectedName = "MissingError";
-    const actualName = actual.name;
-    expect(actualName).to.equal(expectedName);
-
-    const expectedMessage =
-      "Lawyer#argue expected `argument` to be defined. `argument` is 'null'.";
-    const actualMessage = actual.message;
-    expect(actualMessage).to.equal(expectedMessage);
-
-    const expectedArgumentName = "argument";
-    const actualArgumentName = actual.argumentName;
-    expect(actualArgumentName).to.equal(expectedArgumentName);
-  });
-
-  it("should create a new MissingError instance given a 'null' argument value: (null, \"argument\").", () => {
-    const actual = new MissingError(null, "argument");
-
-    expect(actual).to.be.an.instanceof(TypeError);
-
-    const expectedName = "MissingError";
-    const actualName = actual.name;
-    expect(actualName).to.equal(expectedName);
-
-    const expectedMessage =
-      "We expected `argument` to be defined. `argument` is 'null'.";
-    const actualMessage = actual.message;
-    expect(actualMessage).to.equal(expectedMessage);
-
-    const expectedArgumentName = "argument";
-    const actualArgumentName = actual.argumentName;
-    expect(actualArgumentName).to.equal(expectedArgumentName);
-  });
-
-  it("should create a new MissingError instance given a 'null' argument value: (null, null, \"Lawyer#argue\").", () => {
-    const actual = new MissingError(null, null, "Lawyer#argue");
-
-    expect(actual).to.be.an.instanceof(TypeError);
-
-    const expectedName = "MissingError";
-    const actualName = actual.name;
-    expect(actualName).to.equal(expectedName);
-
-    const expectedMessage =
-      "Lawyer#argue expected an argument to be defined. It is 'null'.";
-    const actualMessage = actual.message;
-    expect(actualMessage).to.equal(expectedMessage);
-
-    const actualArgumentName = actual.argumentName;
-    expect(actualArgumentName).to.be.null;
-  });
-
-  it('should create a new MissingError instance given an \'undefined\' argument value: (undefined, "argument", "Lawyer#argue").', () => {
-    const actual = new MissingError(undefined, "argument", "Lawyer#argue");
-
-    expect(actual).to.be.an.instanceof(TypeError);
-
-    const expectedName = "MissingError";
-    const actualName = actual.name;
-    expect(actualName).to.equal(expectedName);
-
-    const expectedMessage =
-      "Lawyer#argue expected `argument` to be defined. `argument` is 'undefined'.";
-    const actualMessage = actual.message;
-    expect(actualMessage).to.equal(expectedMessage);
-
-    const expectedArgumentName = "argument";
-    const actualArgumentName = actual.argumentName;
-    expect(actualArgumentName).to.equal(expectedArgumentName);
-  });
-
-  it("should create a new MissingError instance given an 'undefined' argument value: (undefined, \"argument\").", () => {
-    const actual = new MissingError(undefined, "argument");
-
-    expect(actual).to.be.an.instanceof(TypeError);
-
-    const expectedName = "MissingError";
-    const actualName = actual.name;
-    expect(actualName).to.equal(expectedName);
-
-    const expectedMessage =
-      "We expected `argument` to be defined. `argument` is 'undefined'.";
-    const actualMessage = actual.message;
-    expect(actualMessage).to.equal(expectedMessage);
-
-    const expectedArgumentName = "argument";
-    const actualArgumentName = actual.argumentName;
-    expect(actualArgumentName).to.equal(expectedArgumentName);
-  });
-
-  it("should create a new MissingError instance given an 'undefined' argument value: (undefined, null, \"Lawyer#argue\").", () => {
-    const actual = new MissingError(undefined, null, "Lawyer#argue");
-
-    expect(actual).to.be.an.instanceof(TypeError);
-
-    const expectedName = "MissingError";
-    const actualName = actual.name;
-    expect(actualName).to.equal(expectedName);
-
-    const expectedMessage =
-      "Lawyer#argue expected an argument to be defined. It is 'undefined'.";
-    const actualMessage = actual.message;
-    expect(actualMessage).to.equal(expectedMessage);
-
-    const actualArgumentName = actual.argumentName;
-    expect(actualArgumentName).to.be.null;
-  });
-
-  it("should create a new MissingError instance given an 'undefined' argument value: no arguments.", () => {
-    const actual = new MissingError();
-
-    expect(actual).to.be.an.instanceof(TypeError);
-
-    const expectedName = "MissingError";
-    const actualName = actual.name;
-    expect(actualName).to.equal(expectedName);
-
-    const expectedMessage =
-      "We expected an argument to be defined. It is 'undefined'.";
-    const actualMessage = actual.message;
-    expect(actualMessage).to.equal(expectedMessage);
-
-    const actualArgumentName = actual.argumentName;
-    expect(actualArgumentName).to.be.undefined;
-  });
-
-  it('should create a new MissingError instance even when given a defined argument value: ("whyDefined", "badUsage", "Coder#useWrong").', () => {
-    // If a coder constructs this class with a defined argument, they are using
-    // this constructor wrong. The coder is already throwing an error, so let us
-    // just display a weird message instead of throwing a different error.
-
-    const actual = new MissingError("whyDefined", "badUsage", "Coder#useWrong");
-
-    expect(actual).to.be.an.instanceof(TypeError);
-
-    const expectedName = "MissingError";
-    const actualName = actual.name;
-    expect(actualName).to.equal(expectedName);
-
-    const expectedMessage =
-      "Why are you creating a MissingError with a defined `argumentValue`: 'whyDefined'?";
-    const actualMessage = actual.message;
-    expect(actualMessage).to.equal(expectedMessage);
-
-    const actualArgumentName = actual.argumentName;
-    expect(actualArgumentName).to.equal("badUsage");
-  });
-});

package/test/Errors_MissingError_check_Test.js

@@ -1,102 +0,0 @@
-"use strict";
-
-const { expect } = require("chai");
-const { MissingError } = require("..");
-
-describe("MissingError#check", () => {
-  it('should throw a MissingError given a \'null\' argument value: (null, "argument", "Lawyer#argue").', () => {
-    try {
-      MissingError.check(null, "argument", "Lawyer#argue");
-      throw new Error("The method did not throw an error.");
-    } catch (e) {
-      expect(e).to.be.an.instanceof(MissingError);
-      expect(e.argumentName).to.equal("argument");
-    }
-  });
-
-  it("should throw a MissingError given a 'null' argument value: (null, \"argument\").", () => {
-    try {
-      MissingError.check(null, "argument");
-      throw new Error("The method did not throw an error.");
-    } catch (e) {
-      expect(e).to.be.an.instanceof(MissingError);
-      expect(e.argumentName).to.equal("argument");
-    }
-  });
-
-  it("should throw a MissingError given a 'null' argument value: (null, null, \"Lawyer#argue\").", () => {
-    try {
-      MissingError.check(null, null, "Lawyer#argue");
-      throw new Error("The method did not throw an error.");
-    } catch (e) {
-      expect(e).to.be.an.instanceof(MissingError);
-      expect(e.argumentName).to.be.null;
-    }
-  });
-
-  it("should throw a MissingError given a 'null' argument value: (null).", () => {
-    try {
-      MissingError.check(null);
-      throw new Error("The method did not throw an error.");
-    } catch (e) {
-      expect(e).to.be.an.instanceof(MissingError);
-      expect(e.argumentName).to.be.undefined;
-    }
-  });
-
-  it('should throw a MissingError given an \'undefined\' argument value: (undefined, "argument", "Lawyer#argue").', () => {
-    try {
-      MissingError.check(undefined, "argument", "Lawyer#argue");
-      throw new Error("The method did not throw an error.");
-    } catch (e) {
-      expect(e).to.be.an.instanceof(MissingError);
-      expect(e.argumentName).to.equal("argument");
-    }
-  });
-
-  it("should throw a MissingError given an 'undefined' argument value: (undefined, \"argument\").", () => {
-    try {
-      MissingError.check(undefined, "argument");
-      throw new Error("The method did not throw an error.");
-    } catch (e) {
-      expect(e).to.be.an.instanceof(MissingError);
-      expect(e.argumentName).to.equal("argument");
-    }
-  });
-
-  it("should throw a MissingError given an 'undefined' argument value: (undefined, null, \"Lawyer#argue\").", () => {
-    try {
-      MissingError.check(undefined, null, "Lawyer#argue");
-      throw new Error("The method did not throw an error.");
-    } catch (e) {
-      expect(e).to.be.an.instanceof(MissingError);
-      expect(e.argumentName).to.be.null;
-    }
-  });
-
-  it("should throw a MissingError given an 'undefined' argument value: no arguments.", () => {
-    try {
-      MissingError.check(undefined);
-      throw new Error("The method did not throw an error.");
-    } catch (e) {
-      expect(e).to.be.an.instanceof(MissingError);
-      expect(e.argumentName).to.be.undefined;
-    }
-  });
-
-  it('should do nothing given a defined argument value: (0, "zero", "Zero#returnZero").', () => {
-    MissingError.check(0, "zero", "Zero#returnZero");
-  });
-
-  it('should do nothing given a defined argument value: (0, "zero").', () => {
-    MissingError.check(0, "zero");
-  });
-
-  it('should do nothing given a defined argument value: (0, null, "Zero#returnZero").', () => {
-    MissingError.check(0, null, "Zero#returnZero");
-  });
-
-  it("should do nothing given a defined argument value: (0).", () => {
-    MissingError.check(0);
-  });
-});