@util.js/promises 0.41.0 → 0.41.2

package/dist/Promises.js

@@ -1,31 +1,22 @@
 "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);
   }
-
   (0, _createClass2["default"])(Promises, [{
     key: "all",
     value:
@@ -62,6 +53,7 @@ var Promises = /*#__PURE__*/function () {
       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.
      *
@@ -111,13 +103,13 @@ var Promises = /*#__PURE__*/function () {
      * @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.
      *
@@ -166,13 +158,13 @@ var Promises = /*#__PURE__*/function () {
      * @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.
      *
@@ -195,36 +187,31 @@ var Promises = /*#__PURE__*/function () {
      * @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.
+        })["catch"](callback);
+        // It is possible for the callback to throw an error.
         // This should be caught by
         // process.on('unhandledRejection', error => { ... });
       };
@@ -232,6 +219,7 @@ var Promises = /*#__PURE__*/function () {
       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.
      *
@@ -262,16 +250,15 @@ var Promises = /*#__PURE__*/function () {
      * @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.
      *
@@ -306,16 +293,15 @@ var Promises = /*#__PURE__*/function () {
      * @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.
      *
@@ -338,33 +324,27 @@ var Promises = /*#__PURE__*/function () {
      * @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]);
+              if (values.length === 0) return resolve();
+              if (values.length === 1) return resolve(values[0]);
               resolve(values);
             }]));
           } catch (err) {
@@ -372,10 +352,10 @@ var Promises = /*#__PURE__*/function () {
           }
         });
       };
-
       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.
      *
@@ -403,13 +383,13 @@ var Promises = /*#__PURE__*/function () {
      * @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.
      *
@@ -421,12 +401,13 @@ var Promises = /*#__PURE__*/function () {
      * @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.
      *
@@ -440,7 +421,6 @@ var Promises = /*#__PURE__*/function () {
      * @instance
      * @function
      */
-
   }, {
     key: "resolve",
     value: function resolve() {
@@ -449,18 +429,14 @@ var Promises = /*#__PURE__*/function () {
   }]);
   return Promises;
 }();
-
 module.exports = Promises;
 var dependencies = {};
-
 function callbackifyCache() {
-  return dependencies["callbackifyCache"] || (dependencies["callbackifyCache"] = new _weakMap["default"]());
+  return dependencies.callbackifyCache || (dependencies.callbackifyCache = new _weakMap["default"]());
 }
-
 function promisifyCache() {
-  return dependencies["promisifyCache"] || (dependencies["promisifyCache"] = new _weakMap["default"]());
+  return dependencies.promisifyCache || (dependencies.promisifyCache = new _weakMap["default"]());
 }
-
 function hasCallback(args) {
   return args.length > 0 && typeof args[args.length - 1] === "function";
 }

package/doc/README-examples.js

@@ -77,7 +77,13 @@ function runExample2() {
     if (!callback) return promises.applyCallback(null, notify, arguments);
     callback(null, `${message}, ${who}!`);
   }
-  notify("Call back", "Hypnotoad", (error, message) => console.log(message));
+  notify("Call back", "Hypnotoad", (error, message) => {
+    if (error) {
+      console.error(error);
+      return;
+    }
+    console.log(message);
+  });
   notify("Promise me", "Hypnotoad").then(console.log);
 }
 
@@ -92,7 +98,13 @@ function runExample3() {
   function notify(message, who, callback) {
     return promises.applyPromise(null, notifyPromise, arguments);
   }
-  notify("Call back", "Hypnotoad", (error, message) => console.log(message));
+  notify("Call back", "Hypnotoad", (error, message) => {
+    if (error) {
+      console.error(error);
+      return;
+    }
+    console.log(message);
+  });
   notify("Promise me", "Hypnotoad").then(console.log);
 }
 
@@ -103,7 +115,13 @@ function runExample4() {
     if (callback) return promises.applyPromise(null, notify, arguments);
     return promises.resolve(`${message}, ${who}!`);
   }
-  notify("Call back", "Hypnotoad", (error, message) => console.log(message));
+  notify("Call back", "Hypnotoad", (error, message) => {
+    if (error) {
+      console.error(error);
+      return;
+    }
+    console.log(message);
+  });
   notify("Promise me", "Hypnotoad").then(console.log);
 }
 
@@ -115,7 +133,13 @@ function runExample5() {
   // #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));
+  notify("Call back", "Hypnotoad", (error, message) => {
+    if (error) {
+      console.error(error);
+      return;
+    }
+    console.log(message);
+  });
 }
 
 function runExample6() {
@@ -142,7 +166,13 @@ function runExample7() {
     notifyPromise,
     "Call back",
     "Hypnotoad",
-    (error, message) => console.log(message)
+    (error, message) => {
+      if (error) {
+        console.error(error);
+        return;
+      }
+      console.log(message);
+    }
   );
 }
 

package/index.js

@@ -1,4 +1,5 @@
 "use strict";
 
+// eslint-disable-next-line no-var
 var Promises = require("./dist/Promises");
 module.exports = new Promises();

package/lib/Promises.js

@@ -311,8 +311,8 @@ class Promises {
         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]);
+            if (values.length === 0) return resolve();
+            if (values.length === 1) return resolve(values[0]);
             resolve(values);
           });
         } catch (err) {
@@ -368,6 +368,7 @@ class Promises {
    * @function
    */
   reject() {
+    // eslint-disable-next-line prefer-promise-reject-errors
     return Promise.reject(...arguments);
   }
 
@@ -395,14 +396,13 @@ const dependencies = {};
 
 function callbackifyCache() {
   return (
-    dependencies["callbackifyCache"] ||
-    (dependencies["callbackifyCache"] = new WeakMap())
+    dependencies.callbackifyCache ||
+    (dependencies.callbackifyCache = new WeakMap())
   );
 }
 function promisifyCache() {
   return (
-    dependencies["promisifyCache"] ||
-    (dependencies["promisifyCache"] = new WeakMap())
+    dependencies.promisifyCache || (dependencies.promisifyCache = new WeakMap())
   );
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "Chris Topher <c@creemama.com>",
   "dependencies": {
-    "@babel/runtime-corejs3": "7.14.0"
+    "@babel/runtime-corejs3": "7.20.1"
   },
   "dependencies-comments": [
     "@babel/runtime-corejs3 is required by files in the dist directory to ",
@@ -28,6 +28,6 @@
     "type": "git",
     "url": "https://github.com/creemama/utiljs/tree/master/packages/utiljs-promises"
   },
-  "version": "0.41.0",
-  "gitHead": "1ae0fda34e06ffbc546c5ba0025b0b59a0c7727d"
+  "version": "0.41.2",
+  "gitHead": "174b81ec0ead0221b9bb6617bc254b025bd20a5a"
 }

package/test/PromisesTest.js

@@ -1,13 +1,13 @@
 "use strict";
 
-const { expect } = require("chai"),
-  promises = require("..");
+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;
+      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 () {
@@ -64,8 +64,8 @@ describe("Promises", function () {
 
   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;
+      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) => {
@@ -75,6 +75,10 @@ describe("Promises", function () {
           "Call back",
           "Hypnotoad",
           (error, message) => {
+            if (error) {
+              callbck(error);
+              return;
+            }
             expect(message).to.eql("Call back, Hypnotoad!");
             b(callbck);
           },
@@ -87,6 +91,10 @@ describe("Promises", function () {
           "Call back",
           "Hypnotoad",
           (error, message) => {
+            if (error) {
+              callbck(error);
+              return;
+            }
             expect(message).to.eql("Call back, Hypnotoad!");
             c(callbck);
           }
@@ -103,6 +111,10 @@ describe("Promises", function () {
           "Call back",
           "Hypnotoad",
           (error, value) => {
+            if (error) {
+              callbck(error);
+              return;
+            }
             try {
               expect(value).to.eql("Call back, Hypnotoad!");
               callbck();
@@ -206,7 +218,8 @@ describe("Promises", function () {
               (error, value) => {
                 callback(
                   new Error(
-                    "We expected #callPromise to not call this callback."
+                    "We expected #callPromise to not call this callback.",
+                    { cause: error }
                   )
                 );
               }
@@ -354,7 +367,7 @@ describe("Promises", function () {
       }
       const a = promises.callbackify(promiseFunction);
       const b = promises.callbackify(promiseFunction);
-      expect(a == b).to.be.ok;
+      expect(a === b).to.be.ok;
     });
     it("should throw an error if promiseFunction is not a function", () => {
       expect(() => promises.callbackify()).to.throw(TypeError);
@@ -393,7 +406,7 @@ describe("Promises", function () {
       }
       const a = promises.promisify(functionWithCallback);
       const b = promises.promisify(functionWithCallback);
-      expect(a == b).to.be.ok;
+      expect(a === b).to.be.ok;
     });
     it("should reject if functionWithCallback is not a function", () => {
       expect(() => promises.promisify()).to.throw(TypeError);