@util.js/promises 0.41.6 → 0.41.7

package/dist/Promises.js

@@ -0,0 +1,440 @@
+"use strict";
+
+/**
+ * JavaScript utility methods for [promises]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise}
+ * @public
+ * @class
+ */
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/promise"));
+var _slice = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/slice"));
+var _from = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/from"));
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+var _weakMap = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/weak-map"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/createClass"));
+var Promises = /*#__PURE__*/function () {
+  function Promises() {
+    (0, _classCallCheck2["default"])(this, Promises);
+  }
+  return (0, _createClass2["default"])(Promises, [{
+    key: "all",
+    value:
+    /**
+     * 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
+     */
+    function all() {
+      if (arguments.length > 1) return _promise["default"].all(arguments);
+      return _promise["default"].all.apply(_promise["default"], 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
+     */
+  }, {
+    key: "applyCallback",
+    value: 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
+     */
+  }, {
+    key: "applyPromise",
+    value: 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
+     */
+  }, {
+    key: "callbackify",
+    value: function callbackify(promiseFunction) {
+      var returnValue = callbackifyCache().get(promiseFunction);
+      if (returnValue) return returnValue;
+      if (typeof promiseFunction !== "function") throw new TypeError("We expected promiseFunction to be function, but it was ".concat(promiseFunction, "."));
+      returnValue = function returnValue() {
+        var _context;
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        var callback = arguments[args.length - 1];
+        if (typeof callback !== "function") throw new TypeError("We expected callback to be a function, but it was ".concat(callback, "."));
+        var argsWithoutCalback = (0, _slice["default"])(_context = (0, _from["default"])(args)).call(_context, 0, args.length - 1);
+        var 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 ".concat(promise, "."));
+        promise.then(function (result) {
+          return 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
+     */
+  }, {
+    key: "callCallback",
+    value: function callCallback(object, functionOnObjectWithCallback) {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+        args[_key2 - 2] = arguments[_key2];
+      }
+      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
+     */
+  }, {
+    key: "callPromise",
+    value: function callPromise(object, promiseFunctionOnObject) {
+      for (var _len3 = arguments.length, args = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
+        args[_key3 - 2] = arguments[_key3];
+      }
+      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
+     */
+  }, {
+    key: "promisify",
+    value: function promisify(functionWithCallback) {
+      var 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 ".concat(functionWithCallback, "."));
+      returnValue = function returnValue() {
+        for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+          args[_key4] = arguments[_key4];
+        }
+        var thiz = this;
+        return new _promise["default"](function (resolve, reject) {
+          try {
+            var _context2;
+            functionWithCallback.call.apply(functionWithCallback, (0, _concat["default"])(_context2 = [thiz]).call(_context2, args, [function (error) {
+              if (error) return reject(error);
+              for (var _len5 = arguments.length, values = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+                values[_key5 - 1] = arguments[_key5];
+              }
+              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
+     */
+  }, {
+    key: "race",
+    value: function race() {
+      if (arguments.length > 1) return _promise["default"].race(arguments);
+      return _promise["default"].race.apply(_promise["default"], 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
+     */
+  }, {
+    key: "reject",
+    value: function reject() {
+      // eslint-disable-next-line prefer-promise-reject-errors
+      return _promise["default"].reject.apply(_promise["default"], 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
+     */
+  }, {
+    key: "resolve",
+    value: function resolve() {
+      return _promise["default"].resolve.apply(_promise["default"], arguments);
+    }
+  }]);
+}();
+module.exports = Promises;
+var dependencies = {};
+function callbackifyCache() {
+  return dependencies.callbackifyCache || (dependencies.callbackifyCache = new _weakMap["default"]());
+}
+function promisifyCache() {
+  return dependencies.promisifyCache || (dependencies.promisifyCache = new _weakMap["default"]());
+}
+function hasCallback(args) {
+  return args.length > 0 && typeof args[args.length - 1] === "function";
+}

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.6"
+  "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"
-}