zarro 1.141.5 → 1.141.8

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

@@ -0,0 +1,125 @@
+"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");
+    class HttpClient {
+        constructor(infoLogFunction, debugLogFunction) {
+            this.aborted = false;
+            this._downloadSize = -1;
+            this._statusSuffix = "";
+            this._written = 0;
+            this._lastPerc = -1;
+            this._info = infoLogFunction || console.log;
+            this._debug = debugLogFunction || debug;
+            this.assumeDownloadedIfExistsAndSizeMatches = true;
+        }
+        async exists(url) {
+            return new Promise(resolve => {
+                request.get(url, (err) => {
+                    return resolve(!err);
+                });
+            });
+        }
+        async download(url, target) {
+            if (this._alreadyDownloaded(target)) {
+                return target;
+            }
+            const partFile = `${target}.part`;
+            ensureFolderExists(path.dirname(partFile));
+            return new Promise((resolve, reject) => {
+                this._request = request.get(url, { timeout: 30000 })
+                    .on("response", (response) => {
+                    this._debug(`got response: ${JSON.stringify(response)}`);
+                    this._downloadSize = parseInt(response.headers["content-length"] || "0");
+                    this._statusSuffix = "% of " + this._humanSize(this._downloadSize);
+                })
+                    .on("error", (e) => {
+                    this._debug(`got error: ${e}`);
+                    reject(e);
+                })
+                    .on("data", (data) => {
+                    this._debug(`got ${data.length} bytes`);
+                    this._updateStatus(data);
+                })
+                    .on("end", () => {
+                    this._clear();
+                    this._rename(resolve, reject, partFile, target);
+                }).pipe(fs.createWriteStream(partFile));
+            });
+        }
+        abort() {
+            if (this._request) {
+                this.aborted = true;
+                this._request.abort();
+                this._clear();
+            }
+        }
+        _updateStatus(data) {
+            if (process.env.SUPPRESS_DOWNLOAD_PROGRESS || process.env.BUILD_NUMBER /* automatically disable at Jenkins CI */) {
+                return;
+            }
+            this._written += data.length;
+            const perc = Math.round((100 * this._written) / this._downloadSize);
+            if (perc != this._lastPerc) {
+                this._writeStatus(perc + this._statusSuffix);
+                this._lastPerc = perc;
+            }
+        }
+        _writeStatus(msg) {
+            this._clearStatus();
+            process.stdout.write(msg);
+        }
+        _rename(resolve, reject, src, dst, attempts = 0) {
+            try {
+                this._debug("attempt rename of temp file");
+                fs.renameSync(src, dst);
+                this._clearStatus();
+                this._info(`-> ${dst} download complete!`);
+                resolve(dst);
+            }
+            catch (e) {
+                this._debug("rename error:", e);
+                if (attempts > 99) {
+                    reject(new ZarroError(["Unable to rename \"", src, "\" to \"", dst, "\": ", e].join("")));
+                }
+                else {
+                    setTimeout(() => {
+                        this._rename(resolve, reject, src, dst, attempts++);
+                    }, 100);
+                }
+            }
+        }
+        _clearStatus() {
+            process.stdout.write("\r               \r");
+        }
+        _humanSize(size) {
+            const suffixes = ["b", "kb", "mb", "tb", "pb"];
+            for (let i = 0; i < suffixes.length - 1; i++) {
+                if (size < 1024) {
+                    return size.toFixed(2) + suffixes[i];
+                }
+                size /= 1024;
+            }
+            return size.toFixed(2) + suffixes[suffixes.length - 1];
+        }
+        _clear() {
+            this._request = undefined;
+            this._downloadSize = -1;
+            this._lastPerc = -1;
+        }
+        _alreadyDownloaded(target) {
+            if (!this.assumeDownloadedIfExistsAndSizeMatches) {
+                return false;
+            }
+            if (!fs.existsSync(target)) {
+                return false;
+            }
+            const lstat = fs.lstatSync(target);
+            return lstat.size === this._downloadSize;
+        }
+        static create(infoLogFunction, debugLogFunction) {
+            return new HttpClient(infoLogFunction, debugLogFunction);
+        }
+    }
+    module.exports = HttpClient;
+})();

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

@@ -1,113 +1,4 @@
-const
-  fs = require('fs'),
-  path = require("path"),
-  ensureFolderExists = require("./ensure-folder-exists").sync,
-  request = require('request'),
-  debug = require('debug')('http-downloader');
-
-function HttpDownloader(infoLogFunction, debugLogFunction) {
-  this._info = infoLogFunction || console.log;
-  this._debug = debugLogFunction || debug;
-  this.assumeDownloadedIfExistsAndSizeMatches = true;
-}
-
-HttpDownloader.prototype = {
-  download: function (url, target) {
-    const partFile = `${target}.part`;
-    ensureFolderExists(path.dirname(partFile));
-    return new Promise((resolve, reject) => {
-      this._request = request.get(url, { timeout: 30000 })
-        .on("response", (response) => {
-          this._debug(`got response: ${JSON.stringify(response)}`);
-          this._downloadSize = parseInt(response.headers["content-length"]);
-          this._statusSuffix = '% of ' + this._humanSize(this._downloadSize);
-        })
-        .on("error", (e) => {
-          this._debug(`got error: ${e}`);
-          reject(e);
-        })
-        .on("data", (data) => {
-          this._debug(`got ${data.length} bytes`);
-          this._updateStatus(data);
-        })
-        .on("end", () => {
-          this._clear();
-          this._rename(resolve, reject, partFile, target);
-        }).pipe(fs.createWriteStream(partFile));
-    });
-  },
-  abort: function () {
-    if (this._request) {
-      self._errored = true;
-      this._request.abort();
-      this._clear();
-    }
-  },
-  _updateStatus: function (data) {
-    if (process.env.SUPPRESS_DOWNLOAD_PROGRESS || process.env.BUILD_NUMBER /* automatically disable at Jenkins CI */) {
-      return;
-    }
-    this._written = this._written || 0;
-    this._written += data.length;
-    var perc = Math.round((100 * this._written) / this._downloadSize);
-    if (perc != this._lastPerc) {
-      this._writeStatus(perc + this._statusSuffix);
-      this._lastPerc = perc;
-    }
-  },
-  _writeStatus: function (msg) {
-    this._clearStatus();
-    process.stdout.write(msg);
-  },
-  _rename: function (resolve, reject, src, dst, attempts) {
-    try {
-      this._debug('attempt rename of temp file');
-      fs.renameSync(src, dst)
-      this._clearStatus();
-      this._info(`-> ${dst} download complete!`);
-      resolve(dst)
-    } catch (e) {
-      this._debug('rename error:', e);
-      if (attempts > 99) {
-        reject(['Unable to rename "', src, '" to "', ds, '": ', e].join(''));
-      } else {
-        setTimeout(()=> {
-          this._rename(resolve, reject, src, dst, attempts++);
-        }, 100);
-      }
-    }
-  },
-  _clearStatus: function () {
-    process.stdout.write('\r               \r');
-  },
-  _humanSize: function (size) {
-    var suffixes = ['b', 'kb', 'mb', 'tb', 'pb'];
-    for (var i = 0; i < suffixes.length - 1; i++) {
-      if (size < 1024) {
-        return size.toFixed(2) + suffixes[i];
-      }
-      size /= 1024;
-    }
-    return size.toFixed(2) + suffixes[suffixes.length - 1];
-  },
-  _clear: function () {
-    var self = this;
-    ['_request', '_response', '_downloadSize', '_lastPerc',
-      '_resolveFunction', '_rejectFunction', '_lastData', '_statusSuffix'
-    ].forEach(function (prop) {
-      self[prop] = undefined;
-    });
-  },
-  _alreadyDownloaded: function () {
-    if (!this.assumeDownloadedIfExistsAndSizeMatches) {
-      return false;
-    }
-    if (!fs.existsSync(this._target)) {
-      return false;
-    }
-    var lstat = fs.lstatSync(this._target);
-    return lstat.size === this._downloadSize;
-  }
-}
-
-module.exports = HttpDownloader;
+(function() {
+  console.warn("http-downloader is deprecated; this is now a shim to http-client");
+  module.exports = requireModule("http-downloader");
+})();

package/gulp-tasks/modules/open.js

@@ -0,0 +1,39 @@
+"use strict";
+(function () {
+    // originally, I wanted to use the opn package, now renamed to
+    // open, but the author has kindly made it impossible to require
+    // from within zarro (I get an error about it being an ESM module);
+    // since my requirements are simple, I'll just roll my own.
+    const os = require("os"), { ZarroError } = requireModule("zarro-error"), spawn = requireModule("spawn");
+    async function open(url) {
+        const opener = findOpenerForPlatform();
+        await spawn(opener, [url]);
+    }
+    function findOpenerForPlatform() {
+        switch (os.platform()) {
+            case "darwin":
+                return "open";
+            case "netbsd":
+            case "freebsd":
+            case "linux":
+            case "openbsd":
+                return "xdg-open";
+            case "win32":
+                return "start";
+            case "cygwin":
+                // if we believe: https://stackoverflow.com/a/577698/1697008
+                return "cygstart";
+            case "aix":
+            case "android":
+            case "sunos":
+            default:
+                throw platformNotSupported();
+        }
+    }
+    function platformNotSupported() {
+        return new ZarroError(`Platform not supported for opening urls. Please open an issue at https://github.com/fluffynuts/zarro.`);
+    }
+    module.exports = {
+        open
+    };
+})();

package/gulp-tasks/modules/sleep.js

@@ -1,5 +1,8 @@
-module.exports = function(ms) {
-  return new Promise(resolve => {
-    setTimeout(resolve, ms);
-  });
-};
+"use strict";
+(function () {
+    module.exports = function (ms) {
+        return new Promise(resolve => {
+            setTimeout(resolve, ms);
+        });
+    };
+})();

package/gulp-tasks/start-dev-smtp-server.js

@@ -46,13 +46,20 @@
         if (!env.resolveFlag(env.DEV_SMTP_OPEN_INTERFACE)) {
             return;
         }
-        const url = generateInterfaceUrlFor(ip, port), open = require("open");
+        const url = generateInterfaceUrlFor(ip, port), { open } = requireModule("open");
+        await waitForUrlToBecomeAvailable(url);
         logInfo(`
     Opening the dev smtp interface in your browser (${url})
-    To disable this behavor, set env variable ${env.DEV_SMTP_OPEN_INTERFACE}=0
+    To disable this behavior, set env variable ${env.DEV_SMTP_OPEN_INTERFACE}=0
 `.trim());
         await open(url);
     }
+    async function waitForUrlToBecomeAvailable(url) {
+        const sleep = requireModule("sleep"), HttpClient = requireModule("http-client"), httpClient = HttpClient.create();
+        do {
+            await sleep(500);
+        } while (!(await httpClient.exists(url)));
+    }
     const ipMap = {
         "[::]": "localhost",
         "127.0.0.1": "localhost"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zarro",
-  "version": "1.141.5",
+  "version": "1.141.8",
   "description": "Some glue to make gulp easier, perhaps even zero- or close-to-zero-conf",
   "bin": {
     "zarro": "./index.js"
@@ -54,7 +54,6 @@
     "gulp-msbuild": "^0.10.0",
     "mkdirp": "^1.0.4",
     "npm-run-all": "^4.1.5",
-    "open": "^9.1.0",
     "plugin-error": "^1.0.1",
     "readline": "^1.3.0",
     "request": "^2.88.2",
@@ -90,6 +89,7 @@
     "@types/gulp": "^4.0.8",
     "@types/jest": "^26.0.20",
     "@types/node": "^13.13.40",
+    "@types/request": "^2.48.8",
     "@types/rimraf": "^3.0.0",
     "@types/through2": "^2.0.38",
     "@types/xml2js": "^0.4.8",

package/types.d.ts

@@ -45,6 +45,18 @@ declare global {
     ): Transform;
   }
 
+  interface HttpClient {
+    download(url: string, target: string): Promise<string>;
+    exists(url: string): Promise<boolean>;
+  }
+
+  interface HttpClientModule {
+    create(
+      infoLogFunction?: (s: string) => void,
+      debugLogFunction?: (s: string) => void
+    ): HttpClient;
+  }
+
   interface GulpWithHelp {
     task(name: string, callback: GulpCallback): void;
     task(name: string, help: string, callback: GulpCallback): void;
@@ -217,6 +229,9 @@ declare global {
   }
 
   type GetToolsFolder = (overrideEnv?: Env) => string;
+  interface Open {
+    open(url: string): Promise<void>;
+  }
 
   interface Env {
     resolve(...names: (StringEnvVar | VersionIncrementStrategy)[]): string;