zarro 1.92.0

package/gulp-tasks/increment-package-json-version.js

@@ -0,0 +1,12 @@
+"use strict";
+const alterPackageJsonVersion = requireModule("alter-package-json-version"), env = requireModule("env"), gulp = requireModule("gulp"), taskName = "increment-package-json-version";
+env.associate([
+    env.DRY_RUN,
+    env.PACKAGE_JSON,
+    env.VERSION_INCREMENT_STRATEGY,
+    env.VERSION_INCREMENT_ZERO,
+    env.INITIAL_RELEASE
+], taskName);
+gulp.task(taskName, async () => {
+    return await alterPackageJsonVersion();
+});

package/gulp-tasks/increment-package-json-version.ts

@@ -0,0 +1,17 @@
+const
+  alterPackageJsonVersion = requireModule<AlterPackageJson>("alter-package-json-version"),
+  env = requireModule<Env>("env"),
+  gulp = requireModule<GulpWithHelp>("gulp"),
+  taskName = "increment-package-json-version";
+
+env.associate([
+  env.DRY_RUN,
+  env.PACKAGE_JSON,
+  env.VERSION_INCREMENT_STRATEGY,
+  env.VERSION_INCREMENT_ZERO,
+  env.INITIAL_RELEASE
+], taskName);
+
+gulp.task(taskName, async () => {
+  return await alterPackageJsonVersion();
+});

package/gulp-tasks/install-tools.js

@@ -0,0 +1,24 @@
+var gulp = requireModule("gulp");
+
+/*
+  Installs tooling into the solution folder, into the `tools` folder, or, if specified
+  by the BUILD_TOOLS_FOLDER environment variable, there instead (in case you already have
+  a `tools` folder which would cause confusion).
+
+  If you don't need this step at all, copy this to your `local-tasks` folder and remove
+  the dependency on "default-tools-installer".
+
+  If you want the default functionality in addition to other functionality, have a look
+  at how `default-tools-installer` works and implement your own custom logic inside the
+  body of this task, copied off to your `local-tasks` folder
+*/
+gulp.task(
+  "install-tools",
+  "Installs the default tools for dotnet development",
+  [ "default-tools-installer" ],
+  () => {
+    // replace this line with custom tooling installation
+    return Promise.resolve();
+  }
+);
+

package/gulp-tasks/modules/add-stream-on-any-handler.js

@@ -0,0 +1,31 @@
+// import to patch streams to have an .onAny handler where you can spy on all
+//  events from the stream
+function patchEventEmitters() {
+  var EventEmitter = require("events");
+  var origemit = EventEmitter.prototype.emit;
+  Object.assign(EventEmitter.prototype, {
+    emit: function() {
+      if (this._onAnyListeners) {
+        this._onAnyListeners.forEach(listener =>
+          listener.apply(this, arguments)
+        );
+      }
+      return origemit.apply(this, arguments);
+    },
+    onAny: function(func) {
+      if (typeof func !== "function") {
+        throw new Error("Invalid type");
+      }
+      if (!this._onAnyListeners) this._onAnyListeners = [];
+      this._onAnyListeners.push(func);
+    },
+    removeOnAny: function(func) {
+      const index = this._onAnyListeners.indexOf(func);
+      if (index === -1) {
+        return;
+      }
+      this._onAnyListeners.splice(index, 1);
+    }
+  });
+}
+patchEventEmitters();

package/gulp-tasks/modules/alter-package-json-version.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+(function () {
+    const gutil = requireModule("gulp-util"), env = requireModule("env"), { stat } = require("fs").promises, readTextFile = requireModule("read-text-file"), writeTextFile = requireModule("write-text-file"), incrementVersion = requireModule("increment-version");
+    async function alterPackageJsonVersion(inputOpts) {
+        if (env.resolveFlag(env.INITIAL_RELEASE)) {
+            return;
+        }
+        return new Promise(async (resolve, reject) => {
+            const opts = fillInFromEnvironment(inputOpts), st = await stat(opts.packageJsonPath);
+            if (!st) {
+                return reject(`Can't find file at '${opts.packageJsonPath}'`);
+            }
+            const json = await readTextFile(opts.packageJsonPath), indent = guessIndent(json), index = JSON.parse(json), currentVersion = index.version || "0.0.0", incremented = incrementVersion(currentVersion, opts.strategy, opts.zero, opts.incrementBy);
+            index.version = incremented;
+            const newJson = JSON.stringify(index, null, indent);
+            if (opts.dryRun) {
+                gutil.log(gutil.colors.green(`dry run: would increment version in '${opts.packageJsonPath}' from '${currentVersion}' to '${incremented}'`));
+            }
+            await writeTextFile(opts.packageJsonPath, newJson);
+            resolve();
+        });
+    }
+    function shouldFillInFromEnvironment(opts) {
+        if (!opts) {
+            return true;
+        }
+        if (opts.loadUnsetFromEnvironment) {
+            return true;
+        }
+        return (Object.keys(opts).length === 0);
+    }
+    function fillInFromEnvironment(opts) {
+        if (!shouldFillInFromEnvironment(opts)) {
+            return opts;
+        }
+        const result = Object.assign({}, opts);
+        if (result.packageJsonPath === undefined) {
+            result.packageJsonPath = env.resolve(env.PACKAGE_JSON);
+        }
+        if (result.dryRun === undefined) {
+            result.dryRun = env.resolveFlag(env.DRY_RUN);
+        }
+        if (result.strategy === undefined) {
+            result.strategy = env.resolve(env.VERSION_INCREMENT_STRATEGY);
+        }
+        if (result.zero === undefined) {
+            result.zero = env.resolveFlag(env.VERSION_INCREMENT_ZERO);
+        }
+        if (result.incrementBy === undefined) {
+            result.incrementBy = env.resolveNumber(env.PACK_INCREMENT_VERSION_BY);
+        }
+        return result;
+    }
+    function guessIndent(text) {
+        const lines = text.split("\n"), firstIndented = lines.find(line => line.match(/^\s+/));
+        if (!firstIndented) {
+            return 2; // guess
+        }
+        const firstMatch = firstIndented.match(/(^\s+)/) || [], leadingWhitespace = firstMatch[0] || "  ", asSpaces = leadingWhitespace.replace(/\t/g, "  ");
+        return asSpaces.length;
+    }
+    module.exports = alterPackageJsonVersion;
+})();

package/gulp-tasks/modules/alter-package-json-version.ts

@@ -0,0 +1,113 @@
+export interface AlterPackageJsonVersionOptions {
+  packageJsonPath?: string;
+  dryRun?: boolean;
+  strategy?: string;
+  zero?: boolean;
+  loadUnsetFromEnvironment?: boolean;
+  incrementBy?: number
+}
+
+interface CompleteOptions extends AlterPackageJsonVersionOptions {
+  packageJsonPath: string;
+  dryRun: boolean;
+  strategy: string;
+  zero: boolean;
+  incrementBy: number
+}
+
+(function() {
+  const
+    gutil = requireModule<GulpUtil>("gulp-util"),
+    env = requireModule<Env>("env"),
+    { stat } = require("fs").promises,
+    readTextFile = requireModule<ReadTextFile>("read-text-file"),
+    writeTextFile = requireModule<WriteTextFile>("write-text-file"),
+    incrementVersion = requireModule<IncrementVersion>("increment-version");
+
+  async function alterPackageJsonVersion(
+    inputOpts?: AlterPackageJsonVersionOptions
+  ) {
+    if (env.resolveFlag(env.INITIAL_RELEASE)) {
+      return;
+    }
+    return new Promise(async (resolve, reject) => {
+      const
+        opts = fillInFromEnvironment(inputOpts),
+        st = await stat(opts.packageJsonPath);
+      if (!st) {
+        return reject(`Can't find file at '${ opts.packageJsonPath }'`);
+      }
+      const
+        json = await readTextFile(opts.packageJsonPath),
+        indent = guessIndent(json),
+        index = JSON.parse(json),
+        currentVersion = index.version || "0.0.0",
+        incremented = incrementVersion(
+          currentVersion,
+          opts.strategy,
+          opts.zero,
+          opts.incrementBy
+        );
+      index.version = incremented;
+      const newJson = JSON.stringify(index, null, indent);
+      if (opts.dryRun) {
+        gutil.log(
+          gutil.colors.green(
+            `dry run: would increment version in '${ opts.packageJsonPath }' from '${ currentVersion }' to '${ incremented }'`
+          )
+        );
+      }
+      await writeTextFile(opts.packageJsonPath, newJson);
+      resolve();
+    });
+  }
+
+  function shouldFillInFromEnvironment(opts?: AlterPackageJsonVersionOptions) {
+    if (!opts) {
+      return true;
+    }
+    if (opts.loadUnsetFromEnvironment) {
+      return true;
+    }
+    return (Object.keys(opts).length === 0);
+  }
+
+  function fillInFromEnvironment(opts?: AlterPackageJsonVersionOptions): CompleteOptions {
+    if (!shouldFillInFromEnvironment(opts)) {
+      return opts as CompleteOptions;
+    }
+    const result = { ...opts } as CompleteOptions;
+    if (result.packageJsonPath === undefined) {
+      result.packageJsonPath = env.resolve(env.PACKAGE_JSON);
+    }
+    if (result.dryRun === undefined) {
+      result.dryRun = env.resolveFlag(env.DRY_RUN)
+    }
+    if (result.strategy === undefined) {
+      result.strategy = env.resolve(env.VERSION_INCREMENT_STRATEGY);
+    }
+    if (result.zero === undefined) {
+      result.zero = env.resolveFlag(env.VERSION_INCREMENT_ZERO);
+    }
+    if (result.incrementBy === undefined) {
+      result.incrementBy = env.resolveNumber(env.PACK_INCREMENT_VERSION_BY);
+    }
+    return result as CompleteOptions;
+  }
+
+  function guessIndent(text: string) {
+    const
+      lines = text.split("\n"),
+      firstIndented = lines.find(line => line.match(/^\s+/));
+    if (!firstIndented) {
+      return 2; // guess
+    }
+    const
+      firstMatch = firstIndented.match(/(^\s+)/) || [],
+      leadingWhitespace = firstMatch[0] || "  ",
+      asSpaces = leadingWhitespace.replace(/\t/g, "  ");
+    return asSpaces.length;
+  }
+
+  module.exports = alterPackageJsonVersion;
+})();

package/gulp-tasks/modules/are-all-dotnet-core.js

@@ -0,0 +1,96 @@
+const
+  gulp = requireModule("gulp"),
+  fs = require("fs"),
+  xml2js = require("xml2js"),
+  throwIfNoFiles = requireModule("throw-if-no-files"),
+  path = require("path"),
+  env = require("./env"),
+  debug = require("debug")(path.basename(__filename.replace(/\.js$/, ""))),
+  es = require("event-stream");
+
+module.exports = async function areAllDotnetCore(
+  gulpSrcSpecs
+)
+{
+  if (process.env.DOTNETCORE !== undefined) {
+    return env.resolveFlag("DOTNET_CORE");
+  }
+  return await new Promise(async (resolve, reject) => {
+    const projFiles = [];
+    gulp
+      .src(gulpSrcSpecs, { allowEmpty: true })
+      .pipe(throwIfNoFiles())
+      .pipe(
+        (() => {
+          return es.through(
+            function write(file) {
+              if (!file) {
+                return;
+              }
+              projFiles.push(file.path);
+            },
+            async function end() {
+              if (projFiles.length === 0) {
+                return resolve(false);
+              }
+              for (const proj of projFiles) {
+                const isCoreOrStandard = await allTargetsAreCoreOrFramework(
+                  proj
+                );
+                if (!isCoreOrStandard) {
+                  resolve(false);
+                }
+              }
+              resolve(true);
+            }
+          );
+        })()
+      );
+  });
+}
+
+async function allTargetsAreCoreOrFramework(csproj) {
+  return new Promise(async (resolve, reject) => {
+    try {
+      debug(`testing for netcore/netstandard: ${csproj}`);
+      const contents = fs.readFileSync(csproj, { encoding: "utf-8" }),
+        parser = new xml2js.Parser();
+      parser.parseString(contents, (err, data) => {
+        if (err) {
+          return reject(err);
+        }
+        if (!data.Project) {
+          resolve(false);
+        }
+        let foundTargetFrameworksNode = false;
+        const allCoreOrStandard = (data.Project.PropertyGroup || []).reduce(
+          (acc, cur) => {
+            const targetFrameworksNode =
+              cur.TargetFramework || cur.TargetFrameworks;
+            if (!targetFrameworksNode) {
+              return acc;
+            }
+            foundTargetFrameworksNode = true;
+            const targetFrameworks = targetFrameworksNode.join("").split(";");
+            debug(`have target framework(s): ${targetFrameworks}`);
+            return (
+              acc &&
+              targetFrameworks.reduce((acc2, cur2) => {
+                return (
+                  acc2 &&
+                  (cur2.indexOf("netstandard") === 0 ||
+                    cur2.indexOf("netcoreapp") === 0)
+                );
+              }, true)
+            );
+          },
+          true
+        ) && foundTargetFrameworksNode;
+        debug(`all targets are core/standard: ${allCoreOrStandard}`);
+        resolve(allCoreOrStandard);
+      });
+    } catch (e) {
+      reject(e);
+    }
+  });
+}

package/gulp-tasks/modules/ask.js

@@ -0,0 +1,31 @@
+"use strict";
+(function () {
+    const readline = require("readline");
+    const defaultOptions = {
+        inputStream: process.stdin,
+        outputStream: process.stdout,
+        done: (s) => true // grab only the first line
+    };
+    async function ask(message, opts) {
+        opts = Object.assign({}, defaultOptions, opts || {});
+        const { done } = opts;
+        const rl = readline.createInterface({
+            input: opts.inputStream,
+            output: opts.outputStream
+        });
+        const lines = [];
+        return new Promise((resolve, reject) => {
+            rl.question(message, (line) => {
+                lines.push(line);
+                const all = lines.join("\n");
+                if (done(all)) {
+                    rl.close();
+                    resolve(all);
+                }
+            });
+        });
+    }
+    module.exports = {
+        ask
+    };
+})();

package/gulp-tasks/modules/ask.ts

@@ -0,0 +1,41 @@
+(function() {
+  const
+    readline = require("readline");
+
+  interface AskOptions {
+    inputStream: NodeJS.ReadStream,
+    outputStream: NodeJS.WriteStream,
+    done: ((data: string) => boolean)
+  }
+
+  const defaultOptions: AskOptions = {
+    inputStream: process.stdin,
+    outputStream: process.stdout,
+    done: (s: string) => true // grab only the first line
+  };
+
+  async function ask(message: string, opts?: AskOptions): Promise<string> {
+    opts = Object.assign({}, defaultOptions, opts || {});
+    const { done } = opts;
+    const rl = readline.createInterface({
+      input: opts.inputStream,
+      output: opts.outputStream
+    });
+
+    const lines: string[] = [];
+    return new Promise((resolve, reject) => {
+      rl.question(message, (line: string) => {
+        lines.push(line);
+        const all = lines.join("\n");
+        if (done(all)) {
+          rl.close();
+          resolve(all);
+        }
+      });
+    });
+  }
+
+  module.exports = {
+    ask
+  }
+})();

package/gulp-tasks/modules/collect-files.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+(function () {
+    // collects the files from a gulp stream
+    const es = require("event-stream");
+    module.exports = function collectFiles(target) {
+        const stream = es.through(function data(file) {
+            target.push(file);
+            stream.emit("data", file);
+        }, function end() {
+            stream.emit("end");
+        });
+        return stream;
+    };
+})();