@util.js/promises 0.41.5 → 0.41.7

package/package.json

@@ -8,6 +8,10 @@
     "work in https://npm.runkit.com."
   ],
   "description": "JavaScript utility methods for promises",
+  "files": [
+    "dist",
+    "index.js"
+  ],
   "keywords": [
     "promise",
     "promises",
@@ -28,5 +32,5 @@
     "type": "git",
     "url": "https://github.com/creemama/utiljs/tree/master/packages/utiljs-promises"
   },
-  "version": "0.41.5"
+  "version": "0.41.7"
 }

package/doc/README-examples.js

@@ -1,203 +0,0 @@
-"use strict";
-
-if (process.argv.length < 3) {
-  for (let i = 0; i < 10; i++) runExample(i);
-} else {
-  runExample(parseInt(process.argv[2]));
-}
-
-function runExample(i) {
-  switch (i) {
-    case 0:
-      runExample0();
-      break;
-    case 1:
-      runExample1();
-      break;
-    case 2:
-      runExample2();
-      break;
-    case 3:
-      runExample3();
-      break;
-    case 4:
-      runExample4();
-      break;
-    case 5:
-      runExample5();
-      break;
-    case 6:
-      runExample6();
-      break;
-    case 7:
-      runExample7();
-      break;
-    case 8:
-      runExample8();
-      break;
-    case 9:
-      runExample9();
-      break;
-  }
-}
-
-function runExample0() {
-  const promises = require("..");
-  const promise1 = Promise.resolve(3);
-  const promise2 = 42;
-  const promise3 = new Promise((resolve, reject) => {
-    setTimeout(resolve, 100, "foo");
-  });
-  promises.all(promise1, promise2, promise3).then((values) => {
-    console.log(values);
-  });
-  // expected output: Array [3, 42, "foo"]
-}
-
-function runExample1() {
-  // Wrap a function that only accepts a callback.
-  const promises = require("..");
-  const stream = require("stream");
-  const streams = require("../../utiljs-streams");
-  // stream#finished only takes a callback.
-  // Wrap stream#finished so that it handles both callbacks and Promises.
-  function finished() {
-    return promises.applyCallback(stream, stream.finished, arguments);
-  }
-  const readableToCallback = streams.fromString("Call back, Hypnotoad!");
-  finished(readableToCallback, () => console.log("Finished with a callback"));
-  const readableToPromise = streams.fromString("Promise me, Hypnotoad!");
-  finished(readableToPromise).then(() => console.log("Finished as promised"));
-}
-
-function runExample2() {
-  // Write a function that supports both callbacks and Promises.
-  const promises = require("..");
-  function notify(message, who, callback) {
-    if (!callback) return promises.applyCallback(null, notify, arguments);
-    callback(null, `${message}, ${who}!`);
-  }
-  notify("Call back", "Hypnotoad", (error, message) => {
-    if (error) {
-      console.error(error);
-      return;
-    }
-    console.log(message);
-  });
-  notify("Promise me", "Hypnotoad").then(console.log);
-}
-
-function runExample3() {
-  // Wrap a function that only returns a Promise.
-  const promises = require("..");
-  function notifyPromise(message, who) {
-    return promises.resolve(`${message}, ${who}!`);
-  }
-  // #notifyPromise only returns a Promise.
-  // Wrap #notifyPromise so that it handles both callbacks and Promises.
-  function notify(message, who, callback) {
-    return promises.applyPromise(null, notifyPromise, arguments);
-  }
-  notify("Call back", "Hypnotoad", (error, message) => {
-    if (error) {
-      console.error(error);
-      return;
-    }
-    console.log(message);
-  });
-  notify("Promise me", "Hypnotoad").then(console.log);
-}
-
-function runExample4() {
-  // Write a function that supports both callbacks and Promises.
-  const promises = require("..");
-  function notify(message, who, callback) {
-    if (callback) return promises.applyPromise(null, notify, arguments);
-    return promises.resolve(`${message}, ${who}!`);
-  }
-  notify("Call back", "Hypnotoad", (error, message) => {
-    if (error) {
-      console.error(error);
-      return;
-    }
-    console.log(message);
-  });
-  notify("Promise me", "Hypnotoad").then(console.log);
-}
-
-function runExample5() {
-  const promises = require("..");
-  function notifyPromise(message, who) {
-    return promises.resolve(`${message}, ${who}!`);
-  }
-  // #notifyPromise only returns a Promise.
-  // Wrap #notifyPromise so that it accepts a callback.
-  const notify = promises.callbackify(notifyPromise);
-  notify("Call back", "Hypnotoad", (error, message) => {
-    if (error) {
-      console.error(error);
-      return;
-    }
-    console.log(message);
-  });
-}
-
-function runExample6() {
-  const promises = require("..");
-  function notifyCallback(message, who, callback) {
-    callback(null, `${message}, ${who}!`);
-  }
-  // #notifyCallback only accpets a callback.
-  // Force #notifyCallback to return a Promise.
-  promises
-    .callCallback(null, notifyCallback, "Promise me", "Hypnotoad")
-    .then(console.log);
-}
-
-function runExample7() {
-  const promises = require("..");
-  function notifyPromise(message, who) {
-    return promises.resolve(`${message}, ${who}!`);
-  }
-  // #notifyPromise only returns a Promise.
-  // Force #notifyPromise to accept a callback.
-  promises.callPromise(
-    null,
-    notifyPromise,
-    "Call back",
-    "Hypnotoad",
-    (error, message) => {
-      if (error) {
-        console.error(error);
-        return;
-      }
-      console.log(message);
-    },
-  );
-}
-
-function runExample8() {
-  const promises = require("..");
-  const stream = require("stream");
-  const streams = require("../../utiljs-streams");
-  // stream#finished only takes a callback.
-  // Let us wrap stream#finished so that it returns a Promise.
-  const readable = streams.fromString("Promise me, Hypnotoad!");
-  const finished = promises.promisify(stream.finished);
-  finished(readable).then(() => console.log("Finished as promised"));
-}
-
-function runExample9() {
-  const promises = require("..");
-  const promise1 = new Promise((resolve, reject) => {
-    setTimeout(resolve, 500, "one");
-  });
-  const promise2 = new Promise((resolve, reject) => {
-    setTimeout(resolve, 100, "two");
-  });
-  promises.race(promise1, promise2).then((value) => {
-    console.log(value);
-    // Both resolve, but promise2 is faster
-  });
-  // expected output: "two"
-}

package/lib/Promises.js

@@ -1,411 +0,0 @@
-"use strict";
-
-/**
- * JavaScript utility methods for [promises]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise}
- * @public
- * @class
- */
-class Promises {
-  /**
-   * Returns a single Promise that resolves when all of the promises in the iterable argument have resolved or when the iterable argument contains no promises.
-   *
-   * It rejects with the reason of the first promise that rejects.
-   *
-   * See MDN's documentation about [all]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all}.
-   *
-   * There is one minor difference between Promise#all and this method. Promise#all only takes one argument that must be iterable. This method, Promises#all, behaves the same as Promise#all when given one argument; when given multiple arguments, [arguments]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments} becomes the iterable.
-   *
-   * @example
-   * const promises = require("@util.js/promises");
-   * const promise1 = Promise.resolve(3);
-   * const promise2 = 42;
-   * const promise3 = new Promise((resolve, reject) => {
-   *   setTimeout(resolve, 100, "foo");
-   * });
-   * promises.all(promise1, promise2, promise3).then(values => {
-   *   console.log(values);
-   * });
-   * // expected output: Array [3, 42, "foo"]
-   *
-   * @param {iterable|...*} iterable An iterable object such as an Array or String; if you give move than one argument to this method, [arguments]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments} becomes the iterable
-   * @return {Promise} (A) An already resolved Promise if the iterable passed is empty.
-   * (B) An asynchronously resolved Promise if the iterable passed contains no promises.
-   * (C) A pending Promise in all other cases; this returned promise is then resolved/rejected asynchronously (as soon as the stack is empty) when all the promises in the given iterable have resolved, or if any of the promises reject; returned values will be in order of the Promises passed, regardless of completion order.
-   * @public
-   * @instance
-   * @function
-   */
-  all() {
-    if (arguments.length > 1) return Promise.all(arguments);
-    return Promise.all(...arguments);
-  }
-
-  /**
-   * Calls the given functionOnObjectWithCallback with the given args that either (A) returns a Promise if args does not contain a callback or (B) notifies the callback if args contains a callback.
-   *
-   * Use this function if you are wrapping an existing function that only takes a callback but would like that function to handle both callbacks and Promises.
-   *
-   * It is also useful in writing new functions where you would like to support both callbacks and Promises.
-   *
-   * This function adapts functions that accept a callback. {@link Promises#applyPromise} adapts functions that return a Promise.
-   *
-   * This function is similar to Function#apply. It accepts a single array of arguments.
-   *
-   * Function#call and {@link Promises#callCallback} accept an argument list.
-   *
-   * When trying to remember the difference between #apply and #call, think, "#apply accepts an array. Both array and #apply start with a."
-   *
-   * @example
-   * // Wrap a function that only accepts a callback.
-   * const promises = require("@util.js/promises");
-   * const stream = require("stream");
-   * const streams = require("@util.js/node-streams");
-   * // stream#finished only takes a callback.
-   * // Wrap stream#finished so that it handles both callbacks and Promises.
-   * function finished() {
-   *   return promises.applyCallback(stream, stream.finished, arguments);
-   * }
-   * const readableToCallback = streams.fromString("Call back, Hypnotoad!");
-   * finished(readableToCallback, () => console.log("Finished with a callback"));
-   * const readableToPromise = streams.fromString("Promise me, Hypnotoad!");
-   * finished(readableToPromise).then(() => console.log("Finished as promised"));
-   *
-   * @example
-   * // Write a function that supports both callbacks and Promises.
-   * const promises = require("@util.js/promises");
-   * function notify(message, who, callback) {
-   *   if (!callback) return promises.applyCallback(null, notify, arguments);
-   *   callback(null, `${message}, ${who}!`);
-   * }
-   * notify("Call back", "Hypnotoad", (error, message) => console.log(message));
-   * notify("Promise me", "Hypnotoad").then(console.log);
-   *
-   * @param {Object} object Value to use as this when executing functionOnObjectWithCallback (can be null)
-   * @param {Function} functionOnObjectWithCallback A function that takes a callback as its last argument
-   * @param args An array-like object containing the arguments to pass to functionOnObjectWithCallback; this is usually just [arguments]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments}
-   * @return {undefined|Promise} undefined if the last element of args is a callback or a Promise if args does not contain a callback
-   * @throws {TypeError} If functionOnObjectWithCallback is not a function or if args is null or undefined
-   * @public
-   * @instance
-   * @function
-   */
-  applyCallback(object, functionOnObjectWithCallback, args) {
-    if (hasCallback(args))
-      return functionOnObjectWithCallback.apply(object, args);
-    return this.promisify(functionOnObjectWithCallback).apply(object, args);
-  }
-
-  /**
-   * Calls the given promiseFunctionOnObject with the given args that either (A) returns a Promise if args does not contain a callback or (B) notifies the callback if args contains a callback.
-   *
-   * Use this function if you are wrapping an existing function that only returns a Promise but would like that function to handle both callbacks and Promises.
-   *
-   * It is also useful in writing new functions where you would like to support both callbacks and Promises.
-   *
-   * This function adapts functions that return a Promise. {@link Promises#applyCallback} adapts functions that accept a callback.
-   *
-   * This function is similar to Function#apply. It accepts a single array of arguments.
-   *
-   * Function#call and {@link Promises#callPromise} accept an argument list.
-   *
-   * When trying to remember the difference between #apply and #call, think, "#apply accepts an array. Both array and #apply start with a."
-   *
-   * @example
-   * // Wrap a function that only returns a Promise.
-   * const promises = require("@util.js/promises");
-   * function notifyPromise(message, who) {
-   *   return promises.resolve(`${message}, ${who}!`);
-   * }
-   * // #notifyPromise only returns a Promise.
-   * // Wrap #notifyPromise so that it handles both callbacks and Promises.
-   * function notify(message, who, callback) {
-   *   return promises.applyPromise(null, notifyPromise, arguments);
-   * }
-   * notify("Call back", "Hypnotoad", (error, message) => console.log(message));
-   * notify("Promise me", "Hypnotoad").then(console.log);
-   *
-   * @example
-   * // Write a function that supports both callbacks and Promises.
-   * const promises = require("@util.js/promises");
-   * function notify(message, who, callback) {
-   *   if (callback) return promises.applyPromise(null, notify, arguments);
-   *   return promises.resolve(`${message}, ${who}!`);
-   * }
-   * notify("Call back", "Hypnotoad", (error, message) => console.log(message));
-   * notify("Promise me", "Hypnotoad").then(console.log);
-   *
-   * @param {Object} object Value to use as this when executing promiseFunctionOnObject (can be null)
-   * @param {Function} promiseFunctionOnObject A function that returns a Promise
-   * @param args An array-like object containing the arguments to pass to promiseFunctionOnObject; this is usually just [arguments]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments}
-   * @return {undefined|Promise} undefined if the last element of args is a callback or a Promise if args does not contain a callback
-   * @throws {TypeError} If promiseFunctionOnObject is not a function or if args is null or undefined
-   * @public
-   * @instance
-   * @function
-   */
-  applyPromise(object, promiseFunctionOnObject, args) {
-    if (hasCallback(args))
-      return this.callbackify(promiseFunctionOnObject).apply(object, args);
-    return promiseFunctionOnObject.apply(object, args);
-  }
-
-  /**
-   * Wraps the given promiseFunction such that calling the returned function with a callback notifies the callback with an error if promiseFunction rejects or the return value if promiseFunction resolves.
-   *
-   * Use {@link Promises#callPromise} if you would like to callbackify a method and call it in one line.
-   *
-   * @example
-   * const promises = require("@util.js/promises");
-   * function notifyPromise(message, who) {
-   *   return promises.resolve(`${message}, ${who}!`);
-   * }
-   * // #notifyPromise only returns a Promise.
-   * // Wrap #notifyPromise so that it accepts a callback.
-   * const notify = promises.callbackify(notifyPromise);
-   * notify("Call back", "Hypnotoad", (error, message) => console.log(message));
-   *
-   * @param {Function} promiseFunction A function that returns a Promise
-   * @return {Function} A function that accepts a callback
-   * @throws {TypeError} If promiseFunction is not a function
-   * @public
-   * @instance
-   * @function
-   */
-  callbackify(promiseFunction) {
-    let returnValue = callbackifyCache().get(promiseFunction);
-    if (returnValue) return returnValue;
-    if (typeof promiseFunction !== "function")
-      throw new TypeError(
-        `We expected promiseFunction to be function, but it was ${promiseFunction}.`,
-      );
-    returnValue = function (...args) {
-      const callback = arguments[args.length - 1];
-      if (typeof callback !== "function")
-        throw new TypeError(
-          `We expected callback to be a function, but it was ${callback}.`,
-        );
-      const argsWithoutCalback = Array.from(args).slice(0, args.length - 1);
-      let promise;
-      try {
-        promise = promiseFunction.apply(this, argsWithoutCalback);
-      } catch (error) {
-        return callback(error);
-      }
-      if (!promise && !promise.then)
-        throw new Error(
-          `We expected promiseFunction to return a Promise but instead got ${promise}.`,
-        );
-      promise.then((result) => callback(null, result)).catch(callback);
-      // It is possible for the callback to throw an error.
-      // This should be caught by
-      // process.on('unhandledRejection', error => { ... });
-    };
-    callbackifyCache().set(promiseFunction, returnValue);
-    return returnValue;
-  }
-
-  /**
-   * Calls the given functionOnObjectWithCallback with the given args that either (A) returns a Promise if args does not contain a callback or (B) notifies the callback if args contains a callback.
-   *
-   * This method just calls:
-   * <pre><code>
-   * this.applyCallback(object, functionOnObjectWithCallback, args)
-   * </code></pre>
-   *
-   * See {@link Promises#applyCallback}.
-   *
-   * @example
-   * const promises = require("@util.js/promises");
-   * function notifyCallback(message, who, callback) {
-   *   callback(null, `${message}, ${who}!`);
-   * }
-   * // #notifyCallback only accpets a callback.
-   * // Force #notifyCallback to return a Promise.
-   * promises
-   *   .callCallback(null, notifyCallback, "Promise me", "Hypnotoad")
-   *   .then(console.log);
-   *
-   * @param {Object} object Value to use as this when executing functionOnObjectWithCallback (can be null)
-   * @param {Function} functionOnObjectWithCallback A function that takes a callback as its last argument
-   * @param {...*} [args] The arguments to pass to functionOnObjectWithCallback or its promisified version
-   * @return {undefined|Promise} undefined if the last element of args is a callback or a Promise if args does not contain a callback
-   * @throws {TypeError} If functionOnObjectWithCallback is not a function
-   * @public
-   * @instance
-   * @function
-   */
-  callCallback(object, functionOnObjectWithCallback, ...args) {
-    return this.applyCallback(object, functionOnObjectWithCallback, args);
-  }
-
-  /**
-   * Calls the given promiseFunctionOnObject with the given args that either (A) returns a Promise if args does not contain a callback or (B) notifies the callback if args contains a callback.
-   *
-   * This method just calls:
-   * <pre><code>
-   * this.applyCallback(object, functionOnObjectWithCallback, args)
-   * </code></pre>
-   *
-   * See {@link Promises#applyPromise}.
-   *
-   * @example
-   * const promises = require("@util.js/promises");
-   * function notifyPromise(message, who) {
-   *   return promises.resolve(`${message}, ${who}!`);
-   * }
-   * // #notifyPromise only returns a Promise.
-   * // Force #notifyPromise to accept a callback.
-   * promises.callPromise(
-   *   null,
-   *   notifyPromise,
-   *   "Call back",
-   *   "Hypnotoad",
-   *   (error, message) => console.log(message)
-   * );
-   *
-   * @param {Object} object Value to use as this when executing promiseFunctionOnObject (can be null)
-   * @param {Function} promiseFunctionOnObject A function that returns a Promise
-   * @param {...*} [args] The arguments to pass to promiseFunctionOnObject or its callbackified version
-   * @return {undefined|Promise} undefined if the last element of args is a callback or a Promise if args does not contain a callback
-   * @throws {TypeError} If promiseFunctionOnObject is not a function
-   * @public
-   * @instance
-   * @function
-   */
-  callPromise(object, promiseFunctionOnObject, ...args) {
-    return this.applyPromise(object, promiseFunctionOnObject, args);
-  }
-
-  /**
-   * Wraps the given functionWithCallback such that calling the returned function returns a Promise that resolves if functionWithCallback succeeds and rejects if functionWithCallback errors.
-   *
-   * Use {@link Promises#callCallback} if you would like to promisify a method and call it in one line.
-   *
-   * @example
-   * const promises = require("@util.js/promises");
-   * const stream = require("stream");
-   * const streams = require("@util.js/node-streams");
-   * // stream#finished only takes a callback.
-   * // Let us wrap stream#finished so that it returns a Promise.
-   * const readable = streams.fromString("Promise me, Hypnotoad!");
-   * const finished = promises.promisify(stream.finished);
-   * finished(readable).then(() => console.log("Finished as promised"));
-   *
-   * @param {Function} functionWithCallback A function that takes a callback as its last argument
-   * @return {Function} A function that returns a Promise
-   * @throws {TypeError} If functionWithCallback is not a function
-   * @public
-   * @instance
-   * @function
-   */
-  promisify(functionWithCallback) {
-    let returnValue = promisifyCache().get(functionWithCallback);
-    if (returnValue) return returnValue;
-    if (typeof functionWithCallback !== "function")
-      throw new TypeError(
-        `We expected functionWithCallback to be a function, but it was ${functionWithCallback}.`,
-      );
-    returnValue = function (...args) {
-      const thiz = this;
-      return new Promise((resolve, reject) => {
-        try {
-          functionWithCallback.call(thiz, ...args, function (error, ...values) {
-            if (error) return reject(error);
-            if (values.length === 0) return resolve();
-            if (values.length === 1) return resolve(values[0]);
-            resolve(values);
-          });
-        } catch (err) {
-          reject(err);
-        }
-      });
-    };
-    promisifyCache().set(functionWithCallback, returnValue);
-    return returnValue;
-  }
-
-  /**
-   * Returns a promise that resolves or rejects as soon as one of the promises in the iterable resolves or rejects, with the value or reason from that promise.
-   *
-   * See MDN's documentation about [race]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race}.
-   *
-   * There is one minor difference between Promise#race and this method. Promise#race only takes one argument that must be iterable. This method, Promises#race, behaves the same as Promise#race when given one argument; when given multiple arguments, [arguments]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments} becomes the iterable.
-   *
-   * @example
-   * const promises = require("@util.js/promises");
-   * const promise1 = new Promise((resolve, reject) => {
-   *   setTimeout(resolve, 500, "one");
-   * });
-   * const promise2 = new Promise((resolve, reject) => {
-   *   setTimeout(resolve, 100, "two");
-   * });
-   * promises.race(promise1, promise2).then(value => {
-   *   console.log(value);
-   *   // Both resolve, but promise2 is faster
-   * });
-   * // expected output: "two"
-   *
-   * @param {iterable|...*} iterable An iterable object such as an Array or String; if you give move than one argument to this method, [arguments]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments} becomes the iterable
-   * @return {Promise} A pending Promise that resolves or rejects asynchronically (as soon as the stack is empty) as soon as one of the promises in the given iterable resolves or rejects, adopting that first promise's value as its value
-   * @public
-   * @instance
-   * @function
-   */
-  race() {
-    if (arguments.length > 1) return Promise.race(arguments);
-    return Promise.race(...arguments);
-  }
-
-  /**
-   * Returns a Promise object that is rejected with the given reason.
-   *
-   * See MDN's documentation about [reject]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/reject}.
-   *
-   * @param {*} reason Reason why this Promise rejected
-   * @return {Promise} A Promise that is rejected with the given reason
-   * @public
-   * @instance
-   * @function
-   */
-  reject() {
-    // eslint-disable-next-line prefer-promise-reject-errors
-    return Promise.reject(...arguments);
-  }
-
-  /**
-   * Returns a Promise object that is resolved with the given value.
-   *
-   * If the value is a promise, that promise is returned; if the value is a thenable (i.e. has a "then" method), the returned promise will "follow" that thenable, adopting its eventual state; otherwise the returned promise will be fulfilled with the value.
-   *
-   * See MDN's documentation about [resolve]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/resolve}.
-   *
-   * @param {*} value Argument to be resolved by this Promise that can also be a Promise or a thenable to resolve
-   * @return {Promise} A Promise that is resolved with the given value, or the promise passed as value, if the value was a promise object
-   * @public
-   * @instance
-   * @function
-   */
-  resolve() {
-    return Promise.resolve(...arguments);
-  }
-}
-
-module.exports = Promises;
-
-const dependencies = {};
-
-function callbackifyCache() {
-  return (
-    dependencies.callbackifyCache ||
-    (dependencies.callbackifyCache = new WeakMap())
-  );
-}
-function promisifyCache() {
-  return (
-    dependencies.promisifyCache || (dependencies.promisifyCache = new WeakMap())
-  );
-}
-
-function hasCallback(args) {
-  return args.length > 0 && typeof args[args.length - 1] === "function";
-}

package/test/PromisesTest.js

@@ -1,477 +0,0 @@
-"use strict";
-
-const { expect } = require("chai");
-const promises = require("..");
-
-describe("Promises", function () {
-  describe("#(apply|call)Callback(object, functionOnObjectWithCallback, args)", () => {
-    function notify(message, who, callback) {
-      if (message === "Throw error") throw new Error("Hypnotoad died.");
-      if (message === "Return undefined") return;
-      callback(null, `${message}, ${who}!`);
-    }
-    it("should resolve a Promise", async function () {
-      expect(
-        await promises.applyCallback(null, notify, ["Promise me", "Hypnotoad"]),
-      ).to.eql("Promise me, Hypnotoad!");
-      expect(
-        await promises.callCallback(null, notify, "Promise me", "Hypnotoad"),
-      ).to.eql("Promise me, Hypnotoad!");
-    });
-    it("should error if functionOnObjectWithCallback is not a function", () => {
-      expect(() =>
-        promises.applyCallback(null, null, ["Promise me", "Hypnotoad"]),
-      ).to.throw(TypeError);
-      expect(() =>
-        promises.callCallback(null, null, "Promise me", "Hypnotoad"),
-      ).to.throw(TypeError);
-      expect(() =>
-        promises.applyCallback(null, "a", ["Promise me", "Hypnotoad"]),
-      ).to.throw(TypeError);
-      expect(() =>
-        promises.callCallback(null, "a", "Promise me", "Hypnotoad"),
-      ).to.throw(TypeError);
-    });
-    it("should error if args is erroneous", () => {
-      // This does not cause failures in the unit test, but there is output.
-      promises
-        .callCallback(null, notify, "Return undefined")
-        .then((message) => {
-          throw new Error("Expected expected the function to never return.");
-        })
-        .catch((error) => {
-          throw error;
-        });
-      expect(() => promises.applyCallback(null, notify)).to.throw(TypeError);
-      const a = promises
-        .callCallback(null, notify)
-        .catch((error) => expect(error).to.be.an.instanceof(TypeError));
-      const b = promises
-        .applyCallback(null, notify, ["Hypnotoad"])
-        .catch((error) => expect(error).to.be.an.instanceof(TypeError));
-      const c = promises
-        .callCallback(null, notify, "Hypnotoad")
-        .catch((error) => expect(error).to.be.an.instanceof(TypeError));
-      const d = promises
-        .applyCallback(null, notify, ["Throw error"])
-        .catch((error) => expect(error).to.be.an.instanceof(Error));
-      const e = promises
-        .callCallback(null, notify, "Throw error")
-        .catch((error) => expect(error).to.be.an.instanceof(Error));
-      return promises.all(a, b, c, d, e);
-    });
-  });
-
-  describe("#(apply|call)Promise(object, promiseFunctionOnObject, args)", () => {
-    function notify(message, who) {
-      if (message === "Throw error") throw new Error("Hypnotoad died.");
-      if (message === "Return undefined") return;
-      return promises.resolve(`${message}, ${who}!`);
-    }
-    it("should notify a callback", (callback) => {
-      a(callback);
-      function a(callbck) {
-        promises.applyPromise(null, notify, [
-          "Call back",
-          "Hypnotoad",
-          (error, message) => {
-            if (error) {
-              callbck(error);
-              return;
-            }
-            expect(message).to.eql("Call back, Hypnotoad!");
-            b(callbck);
-          },
-        ]);
-      }
-      function b(callbck) {
-        promises.callPromise(
-          null,
-          notify,
-          "Call back",
-          "Hypnotoad",
-          (error, message) => {
-            if (error) {
-              callbck(error);
-              return;
-            }
-            expect(message).to.eql("Call back, Hypnotoad!");
-            c(callbck);
-          },
-        );
-      }
-      function c(callbck) {
-        function adapt(message, who, callback) {
-          if (callback) return promises.applyPromise(null, notify, arguments);
-          return promises.resolve(`${message}, ${who}!`);
-        }
-        promises.callPromise(
-          null,
-          adapt,
-          "Call back",
-          "Hypnotoad",
-          (error, value) => {
-            if (error) {
-              callbck(error);
-              return;
-            }
-            try {
-              expect(value).to.eql("Call back, Hypnotoad!");
-              callbck();
-            } catch (err) {
-              callbck(err);
-            }
-          },
-        );
-      }
-    });
-    it("should error if promiseFunction is not a function", () => {
-      expect(() =>
-        promises.applyPromise(null, null, ["Call back", "Hypnotoad"]),
-      ).to.throw(TypeError);
-      expect(() =>
-        promises.callPromise(null, null, "Call back", "Hypnotoad"),
-      ).to.throw(TypeError);
-      expect(() =>
-        promises.applyPromise(null, "a", ["Call back", "Hypnotoad"]),
-      ).to.throw(TypeError);
-      expect(() =>
-        promises.callPromise(null, "a", "Call back", "Hypnotoad"),
-      ).to.throw(TypeError);
-    });
-    it("should handle erroneous input", (callback) => {
-      a(callback);
-      function a(callbck) {
-        try {
-          expect(() => promises.applyPromise(null, notify)).to.throw(TypeError);
-          b(callbck);
-        } catch (error) {
-          callbck(error);
-        }
-      }
-      function b(callbck) {
-        promises
-          .callPromise(null, notify)
-          .then((message) => {
-            expect(message).to.eql("undefined, undefined!");
-            c(callbck);
-          })
-          .catch(callbck);
-      }
-      function c(callbck) {
-        promises.applyPromise(null, notify, [
-          "Call back",
-          (error, value) => {
-            try {
-              expect(error).to.be.null;
-              expect(value).to.eql("Call back, undefined!");
-              d(callbck);
-            } catch (err) {
-              callbck(err);
-            }
-          },
-        ]);
-      }
-      function d(callbck) {
-        promises.callPromise(null, notify, "Call back", (error, value) => {
-          try {
-            expect(error).to.be.null;
-            expect(value).to.eql("Call back, undefined!");
-            e(callbck);
-          } catch (err) {
-            callbck(err);
-          }
-        });
-      }
-      function e(callbck) {
-        promises.applyPromise(null, notify, [
-          "Throw error",
-          (error, value) => {
-            try {
-              expect(error).to.be.an.instanceof(Error);
-              expect(value).to.be.undefined;
-              f(callbck);
-            } catch (err) {
-              callbck(err);
-            }
-          },
-        ]);
-      }
-      function f(callbck) {
-        promises.callPromise(null, notify, "Throw error", (error, value) => {
-          try {
-            expect(error).to.be.an.instanceof(Error);
-            expect(value).to.be.undefined;
-            g(callbck);
-          } catch (err) {
-            callbck(err);
-          }
-        });
-      }
-      function g(callbck) {
-        try {
-          expect(() =>
-            promises.callPromise(
-              null,
-              notify,
-              "Return undefined",
-              (error, value) => {
-                callback(
-                  new Error(
-                    "We expected #callPromise to not call this callback.",
-                    { cause: error },
-                  ),
-                );
-              },
-            ),
-          ).to.throw(Error);
-          callbck();
-        } catch (error) {
-          callbck(error);
-        }
-      }
-    });
-  });
-
-  describe("#all(iterable)", () => {
-    it("should properly handle a single, iterable argument", () => {
-      const promise1 = Promise.resolve(3);
-      const promise2 = 42;
-      const promise3 = new Promise((resolve, reject) => {
-        setTimeout(resolve, 100, "foo");
-      });
-      return promises.all([promise1, promise2, promise3]).then((values) => {
-        expect(values).to.eql([3, 42, "foo"]);
-      });
-    });
-    it("should properly handle a single, iterable argument", () => {
-      const promise1 = Promise.resolve(3);
-      const promise2 = 42;
-      const promise3 = new Promise((resolve, reject) => {
-        setTimeout(resolve, 100, "foo");
-      });
-      return promises.all(promise1, promise2, promise3).then((values) => {
-        expect(values).to.eql([3, 42, "foo"]);
-      });
-    });
-    it("should reject when given no arguments", () => {
-      return promises
-        .all()
-        .then(() => expect.fail("We expected promises#all to fail."))
-        .catch((error) => expect(error).to.be.an.instanceof(TypeError));
-    });
-    it("should resolve with [] when given [] as an argument", () => {
-      return promises.all([]).then((values) => {
-        expect(values).to.eql([]);
-      });
-    });
-  });
-
-  describe("#applyCallback(object, functionOnObjectWithCallback, args)", () => {
-    it("should call the callback if args contains a callback", (callback) => {
-      function functionWithCallback(a, b, cb) {
-        expect(a).to.eql("a");
-        expect(b).to.eql("b");
-        cb();
-      }
-      const returnValue = promises.applyCallback(null, functionWithCallback, [
-        "a",
-        "b",
-        callback,
-      ]);
-      try {
-        expect(returnValue).to.be.undefined;
-      } catch (e) {
-        callback(e);
-      }
-    });
-    it("should resolve the returned Promise if args does not contain a callback", () => {
-      function functionWithCallback(a, b, cb) {
-        expect(a).to.eql("a");
-        expect(b).to.eql("b");
-        cb();
-      }
-      return promises.applyCallback(null, functionWithCallback, ["a", "b"]);
-    });
-    it("should throw an Error if functionWithCallback or args is null or undefined", () => {
-      function functionWithCallback(cb) {
-        cb();
-      }
-      expect(() => promises.applyCallback(null, functionWithCallback)).to.throw(
-        TypeError,
-      );
-      expect(() =>
-        promises.applyCallback(null, functionWithCallback, null),
-      ).to.throw(TypeError);
-      // The following line sends functionWithCallback the wrong number of arguments.
-      expect(() =>
-        promises.applyCallback(null, functionWithCallback, "a"),
-      ).to.throw(TypeError);
-      expect(() => promises.applyCallback(null, null, [() => {}])).to.throw(
-        TypeError,
-      );
-      expect(() => promises.applyCallback(null, "a", [() => {}])).to.throw(
-        TypeError,
-      );
-      expect(() => promises.applyCallback(null, null, [])).to.throw(TypeError);
-      expect(() => promises.applyCallback(null, "a", [])).to.throw(TypeError);
-    });
-  });
-
-  describe("#callbackify(promiseFunction)", () => {
-    it("should callbackify Promise functions with no arguments", (callback) => {
-      function promiseFunction() {
-        return Promise.resolve("foobar");
-      }
-      promises.callbackify(promiseFunction)((error, value) => {
-        try {
-          expect(error).to.be.null;
-          expect(value).to.eql("foobar");
-          callback();
-        } catch (err) {
-          callback(err);
-        }
-      });
-    });
-    it("should callbackify Promise functions with one arguments", (callback) => {
-      function promiseFunction(message) {
-        return Promise.resolve(message);
-      }
-      promises.callbackify(promiseFunction)("foobar", (error, value) => {
-        try {
-          expect(error).to.be.null;
-          expect(value).to.eql("foobar");
-          callback();
-        } catch (err) {
-          callback(err);
-        }
-      });
-    });
-    it("should callbackify Promise functions with two arguments", (callback) => {
-      function promiseFunction(a, b) {
-        return Promise.resolve(a + b);
-      }
-      promises.callbackify(promiseFunction)("foo", "bar", (error, value) => {
-        try {
-          expect(error).to.be.null;
-          expect(value).to.eql("foobar");
-          callback();
-        } catch (err) {
-          callback(err);
-        }
-      });
-    });
-    it("should cache callbackified functions", () => {
-      function promiseFunction(a, b) {
-        return Promise.resolve(a + b);
-      }
-      const a = promises.callbackify(promiseFunction);
-      const b = promises.callbackify(promiseFunction);
-      expect(a === b).to.be.ok;
-    });
-    it("should throw an error if promiseFunction is not a function", () => {
-      expect(() => promises.callbackify()).to.throw(TypeError);
-      expect(() => promises.callbackify(null)).to.throw(TypeError);
-      expect(() => promises.callbackify("a")).to.throw(TypeError);
-    });
-  });
-
-  describe("#promisify(functionWithCallback)", () => {
-    it("should promisify callback functions with one argument", () => {
-      function functionWithCallback(callback) {
-        callback();
-      }
-      return promises.promisify(functionWithCallback)();
-    });
-    it("should promisify callback functions with two arguments", () => {
-      function functionWithCallback(a, callback) {
-        expect(a).to.eql("a");
-        callback();
-      }
-      return promises.promisify(functionWithCallback)("a");
-    });
-    it("should promisify callback functions with three arguments", () => {
-      function functionWithCallback(a, b, callback) {
-        expect(a).to.eql("a");
-        expect(b).to.eql("b");
-        callback();
-      }
-      return promises.promisify(functionWithCallback)("a", "b");
-    });
-    it("should cache promisified functions", () => {
-      function functionWithCallback(a, b, callback) {
-        expect(a).to.eql("a");
-        expect(b).to.eql("b");
-        callback();
-      }
-      const a = promises.promisify(functionWithCallback);
-      const b = promises.promisify(functionWithCallback);
-      expect(a === b).to.be.ok;
-    });
-    it("should reject if functionWithCallback is not a function", () => {
-      expect(() => promises.promisify()).to.throw(TypeError);
-      expect(() => promises.promisify(null)).to.throw(TypeError);
-      expect(() => promises.promisify("random")).to.throw(TypeError);
-    });
-  });
-
-  describe("#callCallback", () => {
-    it("should handle functions with only a callback", () => {
-      function functionWithCallback(callback) {
-        callback();
-      }
-      return promises.callCallback(this, functionWithCallback);
-    });
-    it("should handle functions with multiple arguments", () => {
-      function functionWithCallback(x, y, z, callback) {
-        expect(x).to.equal(1);
-        expect(y).to.equal(2);
-        expect(z).to.equal(3);
-        callback(null, x + y + z);
-      }
-      return promises
-        .callCallback(this, functionWithCallback, 1, 2, 3)
-        .then((result) => {
-          expect(result).to.equal(6);
-        });
-    });
-    it("should throw an Error if functionWithCallback or args is null or undefined", () => {
-      function functionWithCallback(cb) {
-        cb();
-      }
-      // The following line sends functionWithCallback the wrong number of arguments.
-      const a = promises
-        .callCallback(null, functionWithCallback, "a")
-        .then(() => expect.fail("We expected call to throw an error."))
-        .catch((error) => expect(error).to.be.an.instanceof(TypeError));
-      expect(() => promises.callCallback(null, null)).to.throw(TypeError);
-      expect(() => promises.callCallback(null, "a")).to.throw(TypeError);
-      return a;
-    });
-  });
-
-  describe("#race(iterable)", () => {
-    it("should handle a single, iterable argument", () => {
-      const promise1 = new Promise((resolve, reject) => {
-        setTimeout(resolve, 500, "one");
-      });
-      const promise2 = new Promise((resolve, reject) => {
-        setTimeout(resolve, 100, "two");
-      });
-      return promises.race([promise1, promise2]).then((value) => {
-        expect(value).to.eql("two");
-      });
-    });
-    it("should handle multiple arguments", () => {
-      const promise1 = new Promise((resolve, reject) => {
-        setTimeout(resolve, 500, "one");
-      });
-      const promise2 = new Promise((resolve, reject) => {
-        setTimeout(resolve, 100, "two");
-      });
-      return promises.race(promise1, promise2).then((value) => {
-        expect(value).to.eql("two");
-      });
-    });
-  });
-});