zarro 1.141.8 → 1.141.9

package/gulp-tasks/modules/download-nuget.js

@@ -1,104 +1,86 @@
-const
-  { ZarroError } = requireModule("zarro-error"),
-  HttpDownloader = require("./http-downloader"),
-  nugetUpdateSelf = require("./nuget-update-self"),
-  logger = require("./log"),
-  path = require("path"),
-  url = 'http://dist.nuget.org/win-x86-commandline/latest/nuget.exe';
-
-function downloadNugetTo(targetFolder) {
-  logger.debug(`Attempting to download nuget.exe to ${targetFolder}`);
-  const
-    downloader = new HttpDownloader(),
-    target = path.join(targetFolder, "nuget.exe");
-  return downloader
-    .download(url, path.join(targetFolder, "nuget.exe"))
-    .then(() => validateCanRunExe(target));
-}
-
-const
-  validators = {},
-  cached = {};
-
-function validateCanRunExe(exePath) {
-  if (validators[exePath]) {
-    return validators[exePath];
-  }
-  const shouldLog = !validators[exePath];
-  if (shouldLog) {
-    logger.debug(`validating exe at: ${exePath}`);
-  }
-  return validators[exePath] = new Promise((resolve, reject) => {
-    let lastMessage = "unknown error",
-      attempts = 0;
-    setTimeout(function testExe() {
-      if (cached[exePath]) {
-        return resolve(exePath);
-      }
-      if (attempts === 10) {
-        return reject(`Unable to run executable at ${exePath}: ${lastMessage}`);
-      }
-      attempts++;
-      if (shouldLog) {
-        logger.debug(`attempt #${attempts} to run ${exePath}`);
-      }
-      const a = attempts;
-      nugetUpdateSelf(exePath).then(() => {
-        if (shouldLog) {
-          const sub = a > 1 ? ` (${a})` : "";
-          logger.info(`nuget.exe appears to be valid!${sub}`);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+(function () {
+    const { ZarroError } = requireModule("zarro-error"), HttpClient = requireModule("http-client"), nugetUpdateSelf = requireModule("nuget-update-self"), logger = requireModule("./log"), path = require("path"), url = "http://dist.nuget.org/win-x86-commandline/latest/nuget.exe";
+    function downloadNugetTo(targetFolder) {
+        logger.debug(`Attempting to download nuget.exe to ${targetFolder}`);
+        const downloader = HttpClient.create(), target = path.join(targetFolder, "nuget.exe");
+        return downloader
+            .download(url, path.join(targetFolder, "nuget.exe"))
+            .then(() => validateCanRunExe(target));
+    }
+    const validators = {}, cached = {};
+    function validateCanRunExe(exePath) {
+        if (!!validators[exePath]) {
+            return validators[exePath];
         }
-        cached[exePath] = true;
-        return resolve(exePath);
-      }).catch(e => {
-        lastMessage = e.message || lastMessage;
+        const shouldLog = !validators[exePath];
         if (shouldLog) {
-          logger.debug(`failed to run executable (${
-            e.message
-          }); ${
-            attempts < 9
-              ? "will try again"
-              : "giving up"
-          }`);
+            logger.debug(`validating exe at: ${exePath}`);
+        }
+        return validators[exePath] = new Promise((resolve, reject) => {
+            let lastMessage = "unknown error", attempts = 0;
+            setTimeout(function testExe() {
+                if (cached[exePath]) {
+                    return resolve(exePath);
+                }
+                if (attempts === 10) {
+                    return reject(`Unable to run executable at ${exePath}: ${lastMessage}`);
+                }
+                attempts++;
+                if (shouldLog) {
+                    logger.debug(`attempt #${attempts} to run ${exePath}`);
+                }
+                const a = attempts;
+                nugetUpdateSelf(exePath).then(() => {
+                    if (shouldLog) {
+                        const sub = a > 1 ? ` (${a})` : "";
+                        logger.info(`nuget.exe appears to be valid!${sub}`);
+                    }
+                    cached[exePath] = true;
+                    return resolve(exePath);
+                }).catch(e => {
+                    lastMessage = e.message || lastMessage;
+                    if (shouldLog) {
+                        logger.debug(`failed to run executable (${e.message}); ${attempts < 9
+                            ? "will try again"
+                            : "giving up"}`);
+                    }
+                    setTimeout(testExe, 1000);
+                });
+            }, 1000);
+        });
+    }
+    function retry(fn, attempt, maxAttempts, wait) {
+        let thisAttempt = attempt !== null && attempt !== void 0 ? attempt : 0;
+        const max = maxAttempts !== null && maxAttempts !== void 0 ? maxAttempts : 10;
+        let waitMs = wait !== null && wait !== void 0 ? wait : 5000;
+        if (waitMs < 1000) {
+            waitMs *= 1000;
         }
-        setTimeout(testExe, 1000);
-      });
-    }, 1000);
-  });
-}
-
-function retry(fn, attempt, maxAttempts, wait) {
-  attempt = attempt || 0;
-  maxAttempts = maxAttempts || 10;
-  wait = wait || 5000;
-  if (wait < 1000) {
-    wait *= 1000;
-  }
-  return fn().catch(e => {
-    if (attempt >= maxAttempts) {
-      throw new ZarroError(`${e} (giving up after ${attempt} attempts)`);
-    } else {
-      return new Promise((resolve, reject) => {
-        setTimeout(() => {
-          console.warn(e);
-          console.log(`trying again in ${wait / 1000}s (${++attempt} / ${maxAttempts})`);
-          retry(fn, attempt, maxAttempts).then(function () {
-            resolve(Array.from(arguments));
-          }).catch(function () {
-            reject(Array.from(arguments));
-          });
-        }, wait);
-      });
+        return fn().catch(e => {
+            if (thisAttempt >= max) {
+                throw new ZarroError(`${e} (giving up after ${attempt} attempts)`);
+            }
+            else {
+                return new Promise((resolve, reject) => {
+                    setTimeout(() => {
+                        console.warn(e);
+                        console.log(`trying again in ${waitMs / 1000}s (${++thisAttempt} / ${max})`);
+                        retry(fn, attempt, maxAttempts, wait).then(function () {
+                            resolve(Array.from(arguments)[0]);
+                        }).catch(function () {
+                            reject(Array.from(arguments));
+                        });
+                    }, wait);
+                });
+            }
+        });
     }
-  });
-}
-
-module.exports = function downloadNuget(targetFolder) {
-  return retry(() =>
-    downloadNugetTo(targetFolder)
-  ).then(downloaded => {
-    console.log(`nuget downloaded to: ${downloaded}`);
-    return downloaded;
-  });
-};
-
+    module.exports = function downloadNuget(targetFolder) {
+        return retry(() => downloadNugetTo(targetFolder)).then(downloaded => {
+            console.log(`nuget downloaded to: ${downloaded}`);
+            return downloaded;
+        });
+    };
+})();

package/gulp-tasks/modules/http-client.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 (function () {
-    const fs = require("fs"), path = require("path"), { ZarroError } = requireModule("zarro-error"), ensureFolderExists = require("./ensure-folder-exists").sync, request = require("request"), debug = require("debug")("http-downloader");
+    const fs = require("fs"), path = require("path"), { ZarroError } = requireModule("zarro-error"), ensureFolderExists = require("./ensure-folder-exists").sync, request = require("request"), debug = require("debug")("http-client");
     class HttpClient {
         constructor(infoLogFunction, debugLogFunction) {
             this.aborted = false;

package/gulp-tasks/modules/log.js

@@ -1,142 +1,148 @@
-const gutil = requireModule("gulp-util"),
-  DEBUG = 1,
-  INFO = 2,
-  NOTICE = 3,
-  WARNING = 4,
-  ERROR = 5,
-  levels = {
-    DEBUG,
-    INFO,
-    NOTICE,
-    WARNING
-  };
-const LogLevels = function () {
-};
-LogLevels.prototype = {
-  get Debug() {
-    return DEBUG;
-  },
-  get Info() {
-    return INFO;
-  },
-  get Notice() {
-    return NOTICE;
-  },
-  get Warning() {
-    return WARNING;
-  },
-  get Error() {
-    return ERROR;
-  }
-};
-const Logger = function () {
-  this.LogLevels = new LogLevels();
-  const logLevel = (process.env.LOG_LEVEL || "").toUpperCase();
-  this.setThreshold(levels[logLevel] || INFO);
-  this._timestamp = true;
-};
-Logger.prototype = {
-  get threshold() {
-    return this._threshold;
-  },
-  setThreshold: function(value) {
-    const intValue = parseInt(value);
-    if (isNaN(intValue) || intValue < 1 || intValue > 5) {
-      throw value +
-        " is not a valid integer value. Try use one of (logger).LogLevels.{Debug|Info|Notice|Warning|Error}";
-    }
-    this._threshold = intValue;
-  },
-  debug: function() {
-    const message = this._resolve(Array.from(arguments));
-    if (this._threshold > DEBUG) return;
-    this._print(message, "grey");
-  },
-  info: function() {
-    const message = this._resolve(Array.from(arguments));
-    if (this._threshold > INFO) return;
-    this._print(message, "yellow");
-  },
-  warning: function() {
-    const message = this._resolve(Array.from(arguments));
-    if (this._threshold > WARNING) return;
-    this._print(message, "magenta");
-  },
-  error: function() {
-    const message = this._resolve(Array.from(arguments));
-    this._print(message, "red", "bold");
-  },
-  fail: function() {
-    const message = this._resolve(Array.from(arguments));
-    this.error(message);
-  },
-  ok: function() {
-    const message = this._resolve(Array.from(arguments));
-    this._print(message, "green");
-  },
-  notice: function() {
-    const message = this._resolve(Array.from(arguments));
-    if (this._threshold > NOTICE) return;
-    this._print(message, "cyan");
-  },
-  suppressTimeStamps: function() {
-    this._timestamp = false;
-  },
-  showTimeStamps: function() {
-    this._timestamp = true;
-  },
-  _resolve: function(args) {
-    return args
-      .map(a => {
-        if (a === undefined) {
-          return "(undefined)";
-        }
-        if (a === null) {
-          return "(null)";
-        }
-        if (Array.isArray(a)) {
-          return a.join(",");
-        }
-        if (typeof a === "object") {
-          return JSON.stringify(a);
-        }
-        return a.toString();
-      })
-      .join(" ");
-  },
-  _print: function() {
-    const message = arguments[0];
-    const styles = [];
-    for (let i = 1; i < arguments.length; i++) {
-      styles.push(arguments[i]); // because arguments is an object, not an array...
-    }
-    const styleFunction = styles.reduce(
-      function (acc, cur) {
-        const fn = gutil.colors[cur];
-        if (fn === undefined) {
-          return acc;
-        }
-        return function (s) {
-          return fn(acc(s));
-        };
-      },
-      function (s) {
-        return s;
-      }
-    );
-    if (this._timestamp) {
-      gutil.log(styleFunction(message));
-    } else {
-      console.log(styleFunction(message));
-    }
-  }
-};
-const logger = new Logger();
-if (logger.threshold === DEBUG) {
-  logger.debug(" -- testing logger outputs -- ");
-  logger.debug("debug message");
-  logger.info("info message");
-  logger.warning("warning message");
-  logger.error("error message");
-}
-module.exports = logger;
+(function () {
+  // TODO: apply some TS faerie dust
+  const gutil = requireModule("gulp-util"),
+    DEBUG = 1,
+    INFO = 2,
+    NOTICE = 3,
+    WARNING = 4,
+    ERROR = 5,
+    levels = {
+      DEBUG,
+      INFO,
+      NOTICE,
+      WARNING
+    };
+  const LogLevels = function () {
+  };
+  LogLevels.prototype = {
+    get Debug() {
+      return DEBUG;
+    },
+    get Info() {
+      return INFO;
+    },
+    get Notice() {
+      return NOTICE;
+    },
+    get Warning() {
+      return WARNING;
+    },
+    get Error() {
+      return ERROR;
+    }
+  };
+  const Logger = function () {
+    this.LogLevels = new LogLevels();
+    const logLevel = (process.env.LOG_LEVEL || "").toUpperCase();
+    this.setThreshold(levels[logLevel] || INFO);
+    this._timestamp = true;
+  };
+  Logger.prototype = {
+    get threshold() {
+      return this._threshold;
+    },
+    setThreshold: function (value) {
+      if (levels[value] !== undefined) {
+        value = levels[value];
+      }
+      const intValue = parseInt(value);
+      if (isNaN(intValue) || intValue < 1 || intValue > 5) {
+        throw value +
+        " is not a valid integer value. Try use one of (logger).LogLevels.{Debug|Info|Notice|Warning|Error}";
+      }
+      this._threshold = intValue;
+    },
+    debug: function () {
+      const message = this._resolve(Array.from(arguments));
+      if (this._threshold >= DEBUG) return;
+      this._print(message, "grey");
+    },
+    info: function () {
+      const message = this._resolve(Array.from(arguments));
+      if (this._threshold >= INFO) return;
+      this._print(message, "yellow");
+    },
+    warning: function () {
+      const message = this._resolve(Array.from(arguments));
+      if (this._threshold >= WARNING) return;
+      this._print(message, "magenta");
+    },
+    error: function () {
+      const message = this._resolve(Array.from(arguments));
+      this._print(message, "red", "bold");
+    },
+    fail: function () {
+      const message = this._resolve(Array.from(arguments));
+      this.error(message);
+    },
+    ok: function () {
+      const message = this._resolve(Array.from(arguments));
+      this._print(message, "green");
+    },
+    notice: function () {
+      const message = this._resolve(Array.from(arguments));
+      if (this._threshold > NOTICE) return;
+      this._print(message, "cyan");
+    },
+    suppressTimeStamps: function () {
+      this._timestamp = false;
+    },
+    showTimeStamps: function () {
+      this._timestamp = true;
+    },
+    _resolve: function (args) {
+      return args
+        .map(a => {
+          if (a === undefined) {
+            return "(undefined)";
+          }
+          if (a === null) {
+            return "(null)";
+          }
+          if (Array.isArray(a)) {
+            return a.join(",");
+          }
+          if (typeof a === "object") {
+            return JSON.stringify(a);
+          }
+          return a.toString();
+        })
+        .join(" ");
+    },
+    _print: function () {
+      const message = arguments[0];
+      const styles = [];
+      for (let i = 1; i < arguments.length; i++) {
+        styles.push(arguments[i]); // because arguments is an object, not an array...
+      }
+      const styleFunction = styles.reduce(
+        function (acc, cur) {
+          const fn = gutil.colors[cur];
+          if (fn === undefined) {
+            return acc;
+          }
+          return function (s) {
+            return fn(acc(s));
+          };
+        },
+        function (s) {
+          return s;
+        }
+      );
+      if (this._timestamp) {
+        gutil.log(styleFunction(message));
+      } else {
+        console.log(styleFunction(message));
+      }
+    }
+  };
+  const logger = new Logger();
+  if (logger.threshold === DEBUG) {
+    logger.debug(" -- testing logger outputs -- ");
+    logger.debug("debug message");
+    logger.info("info message");
+    logger.warning("warning message");
+    logger.error("error message");
+  }
+  module.exports = logger;
+})();

package/gulp-tasks/modules/nuget-update-self.js

@@ -1,9 +1,21 @@
-const
-  exec = requireModule("exec");
-let updating = null;
-module.exports = function (nugetPath) {
-  if (updating) {
-    return updating;
-  }
-  return exec(nugetPath, [ "update", "-self" ]);
-}
+"use strict";
+(function () {
+    const spawn = requireModule("spawn");
+    let updating;
+    module.exports = function (nugetPath) {
+        if (updating) {
+            return updating;
+        }
+        return updating = new Promise(async (resolve, reject) => {
+            try {
+                await spawn(nugetPath, ["update", "-self"]);
+                updating = undefined;
+                resolve();
+            }
+            catch (e) {
+                updating = undefined;
+                reject(e);
+            }
+        });
+    };
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zarro",
-  "version": "1.141.8",
+  "version": "1.141.9",
   "description": "Some glue to make gulp easier, perhaps even zero- or close-to-zero-conf",
   "bin": {
     "zarro": "./index.js"

package/types.d.ts

@@ -19,6 +19,41 @@ interface Logger {
   warn(...args: any[]): Logger;
 }
 
+interface LogLevels {
+  Debug: string;
+  Info: string;
+  Notice: string;
+  Warning: string;
+  Error: string;
+}
+
+declare enum LogThreshold {
+  debug = 1,
+  info = 2,
+  notice = 3,
+  warning = 4,
+  error = 5
+}
+
+interface ZarroLogger {
+  LogLevels: LogLevels;
+  threshold: LogThreshold;
+
+  setThreshold(threshold: number | string): void;
+  debug(...args: any[]): void;
+  info(...args: any[]): void;
+  notice(...args: any[]): void;
+  warning(...args: any[]): void;
+  error(...args: any[]): void;
+
+  fail(...args: any[]): void;
+  ok(...args: any[]): void;
+  notice(...args: any[]): void;
+  suppressTimestamps(): void;
+  showTimestamps(): void;
+
+}
+
 declare global {
   function requireModule<T>(module: string): T;
 
@@ -490,6 +525,8 @@ declare global {
 
   type FailAfter = (ms: number, message?: string) => Failer;
 
+  type NugetUpdateSelf = (nugetPath: string) => Promise<void>;
+
   export interface FileSystemUtils {
     folderExists(at: string): Promise<boolean>;
     fileExists(at: string): Promise<boolean>;