@util.js/promises 0.41.4 → 0.41.5

package/README.md

@@ -317,7 +317,7 @@ promises.callPromise(
   notifyPromise,
   "Call back",
   "Hypnotoad",
-  (error, message) => console.log(message)
+  (error, message) => console.log(message),
 );
 ```
 

package/doc/README-examples.js

@@ -172,7 +172,7 @@ function runExample7() {
         return;
       }
       console.log(message);
-    }
+    },
   );
 }
 

package/lib/Promises.js

@@ -176,13 +176,13 @@ class Promises {
     if (returnValue) return returnValue;
     if (typeof promiseFunction !== "function")
       throw new TypeError(
-        `We expected promiseFunction to be function, but it was ${promiseFunction}.`
+        `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}.`
+          `We expected callback to be a function, but it was ${callback}.`,
         );
       const argsWithoutCalback = Array.from(args).slice(0, args.length - 1);
       let promise;
@@ -193,7 +193,7 @@ class Promises {
       }
       if (!promise && !promise.then)
         throw new Error(
-          `We expected promiseFunction to return a Promise but instead got ${promise}.`
+          `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.
@@ -303,7 +303,7 @@ class Promises {
     if (returnValue) return returnValue;
     if (typeof functionWithCallback !== "function")
       throw new TypeError(
-        `We expected functionWithCallback to be a function, but it was ${functionWithCallback}.`
+        `We expected functionWithCallback to be a function, but it was ${functionWithCallback}.`,
       );
     returnValue = function (...args) {
       const thiz = this;

package/package.json

@@ -28,6 +28,5 @@
     "type": "git",
     "url": "https://github.com/creemama/utiljs/tree/master/packages/utiljs-promises"
   },
-  "version": "0.41.4",
-  "gitHead": "2119863a175cf7095ca3a2417e61af32974add15"
+  "version": "0.41.5"
 }

package/test/PromisesTest.js

@@ -12,24 +12,24 @@ describe("Promises", function () {
     }
     it("should resolve a Promise", async function () {
       expect(
-        await promises.applyCallback(null, notify, ["Promise me", "Hypnotoad"])
+        await promises.applyCallback(null, notify, ["Promise me", "Hypnotoad"]),
       ).to.eql("Promise me, Hypnotoad!");
       expect(
-        await promises.callCallback(null, notify, "Promise me", "Hypnotoad")
+        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"])
+        promises.applyCallback(null, null, ["Promise me", "Hypnotoad"]),
       ).to.throw(TypeError);
       expect(() =>
-        promises.callCallback(null, null, "Promise me", "Hypnotoad")
+        promises.callCallback(null, null, "Promise me", "Hypnotoad"),
       ).to.throw(TypeError);
       expect(() =>
-        promises.applyCallback(null, "a", ["Promise me", "Hypnotoad"])
+        promises.applyCallback(null, "a", ["Promise me", "Hypnotoad"]),
       ).to.throw(TypeError);
       expect(() =>
-        promises.callCallback(null, "a", "Promise me", "Hypnotoad")
+        promises.callCallback(null, "a", "Promise me", "Hypnotoad"),
       ).to.throw(TypeError);
     });
     it("should error if args is erroneous", () => {
@@ -97,7 +97,7 @@ describe("Promises", function () {
             }
             expect(message).to.eql("Call back, Hypnotoad!");
             c(callbck);
-          }
+          },
         );
       }
       function c(callbck) {
@@ -121,22 +121,22 @@ describe("Promises", function () {
             } catch (err) {
               callbck(err);
             }
-          }
+          },
         );
       }
     });
     it("should error if promiseFunction is not a function", () => {
       expect(() =>
-        promises.applyPromise(null, null, ["Call back", "Hypnotoad"])
+        promises.applyPromise(null, null, ["Call back", "Hypnotoad"]),
       ).to.throw(TypeError);
       expect(() =>
-        promises.callPromise(null, null, "Call back", "Hypnotoad")
+        promises.callPromise(null, null, "Call back", "Hypnotoad"),
       ).to.throw(TypeError);
       expect(() =>
-        promises.applyPromise(null, "a", ["Call back", "Hypnotoad"])
+        promises.applyPromise(null, "a", ["Call back", "Hypnotoad"]),
       ).to.throw(TypeError);
       expect(() =>
-        promises.callPromise(null, "a", "Call back", "Hypnotoad")
+        promises.callPromise(null, "a", "Call back", "Hypnotoad"),
       ).to.throw(TypeError);
     });
     it("should handle erroneous input", (callback) => {
@@ -219,11 +219,11 @@ describe("Promises", function () {
                 callback(
                   new Error(
                     "We expected #callPromise to not call this callback.",
-                    { cause: error }
-                  )
+                    { cause: error },
+                  ),
                 );
-              }
-            )
+              },
+            ),
           ).to.throw(Error);
           callbck();
         } catch (error) {
@@ -298,20 +298,20 @@ describe("Promises", function () {
         cb();
       }
       expect(() => promises.applyCallback(null, functionWithCallback)).to.throw(
-        TypeError
+        TypeError,
       );
       expect(() =>
-        promises.applyCallback(null, functionWithCallback, null)
+        promises.applyCallback(null, functionWithCallback, null),
       ).to.throw(TypeError);
       // The following line sends functionWithCallback the wrong number of arguments.
       expect(() =>
-        promises.applyCallback(null, functionWithCallback, "a")
+        promises.applyCallback(null, functionWithCallback, "a"),
       ).to.throw(TypeError);
       expect(() => promises.applyCallback(null, null, [() => {}])).to.throw(
-        TypeError
+        TypeError,
       );
       expect(() => promises.applyCallback(null, "a", [() => {}])).to.throw(
-        TypeError
+        TypeError,
       );
       expect(() => promises.applyCallback(null, null, [])).to.throw(TypeError);
       expect(() => promises.applyCallback(null, "a", [])).to.throw(TypeError);