@teams-max/mwsp 1.0.2 → 2.0.1

package/lib/utils/index.js

@@ -0,0 +1,183 @@
+// src/utils/index.js
+var fs = require("fs");
+var { join } = require("path");
+var inquirer = require("inquirer");
+var yParser = require("./yargs-parser");
+var execa = require("./execa");
+var exec = require("./exec");
+var chalk = require("./chalk");
+var cwd = process.cwd() || process.env.INIT_CWD || process.env.PWD;
+var asgDir = join(cwd, ".asg");
+function logStep(...args) {
+  const name = `${chalk.magenta.bold(args == null ? void 0 : args[0])}`;
+  const desc = (args == null ? void 0 : args[1]) ? `${chalk.greenBright(args.slice(1).join(" "))}` : "";
+  console.log(`${chalk.gray("[MWSP] ")} ${name} ${desc}`);
+}
+function printError(...args) {
+  const name = `${chalk.red.bold(args == null ? void 0 : args[0])}`;
+  const desc = (args == null ? void 0 : args[1]) ? `${chalk.greenBright(args.slice(1).join(" "))}` : "";
+  console.error(`${chalk.gray(" >> Error: [MWSP] ")} ${name} ${desc}`);
+}
+function printErrorAndExit(...args) {
+  printError(args);
+  process.exit(1);
+}
+function pickDependencies(dependencies, isDev) {
+  const pkgs = require(join(cwd, "package.json"));
+  return dependencies.filter((p) => {
+    if (isDev) {
+      return !pkgs.devDependencies[p];
+    } else {
+      return !pkgs.dependencies[p];
+    }
+  });
+}
+function getCfg() {
+  const pkgs = require(join(cwd, "package.json"));
+  const { infra = {}, appKey } = pkgs;
+  if (!(infra == null ? void 0 : infra.url) || !appKey) {
+    printErrorAndExit("Please check the infra and appKey in package.json.");
+  }
+  const args = yParser(process.argv.slice(2));
+  const JENKINS_BUILD = args.jenkinsBuild || args.JENKINSBUILD || args.jenkins_build || args.JENKINS_BUILD;
+  const APP_ENV = args.env || args.ENV || "";
+  const ASG_BRAHCH = args.asg_branch || args.ASG_BRAHCH || "";
+  let RESOURCE_URL = "";
+  let SUB_APP = "";
+  let archStr = "unknown";
+  if (infra.url.includes("teams-pro")) {
+    archStr = "PRO";
+  } else if (infra.url.includes("teams-max")) {
+    archStr = "MAX";
+    RESOURCE_URL = args.versionUrl || args.RESOURCE_URL || "";
+    SUB_APP = args.subApp || args.SUB_APP || "";
+  }
+  return {
+    appKey,
+    infra: {
+      url: infra.url,
+      arch: archStr
+    },
+    ASG_DIR: asgDir,
+    JENKINS_BUILD,
+    ASG_BRAHCH,
+    APP_ENV,
+    RESOURCE_URL,
+    SUB_APP
+  };
+}
+function checkDirectoryExistsSync(dirPath) {
+  try {
+    const stats = fs.statSync(dirPath);
+    return stats.isDirectory();
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return false;
+    } else {
+      printErrorAndExit(err);
+    }
+  }
+}
+async function fetchRemoteRepository() {
+  const cfg = getCfg();
+  const { infra, ASG_DIR: directory, ASG_BRAHCH, JENKINS_BUILD } = cfg;
+  const remoteUrl = infra.url;
+  const doesExist = checkDirectoryExistsSync(directory);
+  if (!doesExist) {
+    logStep("Cloning the repository from GitHub...");
+    execa.sync("git", ["clone", "-b", "feature-asg", remoteUrl, directory]);
+    logStep("Cloning completed.");
+    logStep("Installing dependencies...");
+    if ((infra == null ? void 0 : infra.arch) === "PRO") {
+      const proDevDeps = pickDependencies(["snb-mock-middleware", "lodash-webpack-plugin"], true);
+      !!proDevDeps.length && await exec("yarn", ["add", ...proDevDeps, "-D"]);
+      const proDeps = pickDependencies(["@teams-max/skynet", "history"]);
+      !!proDeps.length && await exec("yarn", ["add", ...proDeps]);
+    } else if ((infra == null ? void 0 : infra.arch) === "MAX") {
+      const maxDevDeps = pickDependencies(["axios"], true);
+      !!maxDevDeps.length && await exec("pnpm", ["add", ...maxDevDeps, "-D"]);
+      const maxDeps = pickDependencies(["@teams-max/skynet", "classnames", "qs", "uuid", "react-draggable", "lodash", "moment", "dayjs"]);
+      !!maxDeps.length && await exec("pnpm", ["add", ...maxDeps]);
+    }
+    logStep("Installation completed.");
+  } else if (JENKINS_BUILD && !ASG_BRAHCH) {
+    logStep("Jenkins build detected. Skipping sync up.");
+    return;
+  } else {
+    if (!JENKINS_BUILD) {
+      const { syncUp } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "syncUp",
+          message: "\u540C\u6B65\u8FDC\u7AEF\u4ED3\u5E93",
+          default: "Y"
+        }
+      ]);
+      if (!syncUp)
+        return;
+    }
+  }
+  if (!doesExist && JENKINS_BUILD && !ASG_BRAHCH) {
+    printErrorAndExit(
+      "Jenkins build detected. The branch parameter is missing!"
+    );
+    return;
+  }
+  logStep("Synchronizing with the remote repository...");
+  process.chdir(directory);
+  try {
+    execa.sync("git", ["fetch", "origin", "--prune"]);
+    if (JENKINS_BUILD && ASG_BRAHCH) {
+      execa.sync("git", ["checkout", ASG_BRAHCH]);
+      logStep(`Anto switched to branch:`, ASG_BRAHCH);
+    } else {
+      const infraBranchsOutput = execa.sync("git", ["branch", "-r"]).stdout;
+      const infraBranchArray = infraBranchsOutput.trim().split("\n");
+      const filteredBranches = infraBranchArray.map((b) => b.trim()).filter(
+        (b) => !(b.startsWith("origin/HEA") || b.startsWith("origin/app-") || b.startsWith("app-"))
+      );
+      const defaultBrancheIdx = filteredBranches.indexOf("origin/feature-asg");
+      if (defaultBrancheIdx !== -1) {
+        filteredBranches.splice(defaultBrancheIdx, 1);
+        filteredBranches.unshift("origin/feature-asg");
+      }
+      if (filteredBranches.length === 0) {
+        printErrorAndExit("No branches available for selection.");
+      }
+      const questions = await inquirer.prompt([
+        {
+          type: "list",
+          name: "branch",
+          message: "Please select the branch first: ",
+          choices: filteredBranches,
+          validate: function(val) {
+            if (!val || !val.length) {
+              return "Please select a branch!";
+            }
+            return true;
+          }
+        }
+      ]);
+      try {
+        execa.sync("git", ["checkout", "-q", questions.branch]);
+        logStep(`Switched to branch:`, questions.branch);
+      } catch (error) {
+        printErrorAndExit(
+          `Failed to switch to branch '${questions.branch}'. Reason: ${error.message}`
+        );
+      }
+    }
+  } catch (error) {
+    printErrorAndExit(
+      `An error occurred while fetching remote branches: ${error.message}`
+    );
+  }
+  process.chdir(cwd);
+}
+module.exports.yParser = yParser;
+module.exports.execa = execa;
+module.exports.chalk = chalk;
+module.exports.logStep = logStep;
+module.exports.printErrorAndExit = printErrorAndExit;
+module.exports.getCfg = getCfg;
+module.exports.fetchRemoteRepository = fetchRemoteRepository;

package/lib/utils/isNextVersion.js

@@ -0,0 +1,4 @@
+// src/utils/isNextVersion.js
+module.exports = function(version) {
+  return version.includes("-rc.") || version.includes("-beta.") || version.includes("-alpha.");
+};

package/{es/internal → lib/utils}/merge-stream/index.d.ts

@@ -9,7 +9,9 @@
 /// <reference types="node"/>
 
 interface MergedStream extends NodeJS.ReadWriteStream {
-  add(source: NodeJS.ReadableStream | ReadonlyArray<NodeJS.ReadableStream>): MergedStream;
+  add(
+    source: NodeJS.ReadableStream | ReadonlyArray<NodeJS.ReadableStream>,
+  ): MergedStream;
   isEmpty(): boolean;
 }
 

package/lib/{internal → utils}/merge-stream/index.js

@@ -1,4 +1,4 @@
-// src/internal/merge-stream/index.js
+// src/utils/merge-stream/index.js
 module.exports = (() => {
   "use strict";
   var e = {

package/lib/utils/merge-stream/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "merge-stream",
+  "license": "MIT",
+  "author": "Stephen Sugden <me@stephensugden.com>",
+  "main": "index.js",
+  "types": "index.d.ts"
+}

package/lib/utils/parseDoc.js

@@ -0,0 +1,30 @@
+// src/utils/parseDoc.js
+module.exports = function(docStr) {
+  docStr = docStr.trim();
+  const hasYamlConfig = docStr.startsWith("---");
+  const docArr = docStr.split("\n");
+  let title = null;
+  let titleIndex = null;
+  let yamlEndIndex = null;
+  let i = hasYamlConfig ? 1 : 0;
+  while (i < docArr.length) {
+    const line = docArr[i];
+    if (line.startsWith("---")) {
+      yamlEndIndex = i;
+    }
+    if (line.startsWith("# ") && titleIndex === null) {
+      title = line.replace("# ", "");
+      titleIndex = i;
+    }
+    i += 1;
+  }
+  if (titleIndex === null && yamlEndIndex !== null) {
+    titleIndex = yamlEndIndex;
+  }
+  return {
+    hasYamlConfig,
+    title,
+    yamlConfig: hasYamlConfig ? docArr.slice(1, yamlEndIndex) : [],
+    body: docArr.slice(titleIndex === null ? titleIndex : titleIndex + 1)
+  };
+};

package/lib/utils/yargs-parser/index.d.ts

@@ -0,0 +1,114 @@
+// Type definitions for yargs-parser 20.2
+// Project: https://github.com/yargs/yargs-parser#readme
+// Definitions by: Miles Johnson <https://github.com/milesj>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
+
+declare namespace yargsParser {
+  interface Arguments {
+    /** Non-option arguments */
+    _: string[];
+    /** The script name or node command */
+    $0: string;
+    /** All remaining options */
+    [argName: string]: any;
+  }
+
+  interface DetailedArguments {
+    /** An object representing the parsed value of `args` */
+    argv: Arguments;
+    /** Populated with an error object if an exception occurred during parsing. */
+    error: Error | null;
+    /** The inferred list of aliases built by combining lists in opts.alias. */
+    aliases: { [alias: string]: string[] };
+    /** Any new aliases added via camel-case expansion. */
+    newAliases: { [alias: string]: boolean };
+    /** The configuration loaded from the yargs stanza in package.json. */
+    configuration: Configuration;
+  }
+
+  interface Configuration {
+    /** Should variables prefixed with --no be treated as negations? Default is `true` */
+    'boolean-negation': boolean;
+    /** Should hyphenated arguments be expanded into camel-case aliases? Default is `true` */
+    'camel-case-expansion': boolean;
+    /** Should arrays be combined when provided by both command line arguments and a configuration file. Default is `false`  */
+    'combine-arrays': boolean;
+    /** Should keys that contain . be treated as objects? Default is `true` */
+    'dot-notation': boolean;
+    /** Should arguments be coerced into an array when duplicated. Default is `true` */
+    'duplicate-arguments-array': boolean;
+    /** Should array arguments be coerced into a single array when duplicated. Default is `true` */
+    'flatten-duplicate-arrays': boolean;
+    /** Should arrays consume more than one positional argument following their flag. Default is `true` */
+    'greedy-arrays': boolean;
+    /** Should nargs consume dash options as well as positional arguments. Default is `false` */
+    'nargs-eats-options': boolean;
+    /** Should parsing stop at the first text argument? This is similar to how e.g. ssh parses its command line. Default is `false` */
+    'halt-at-non-option': boolean;
+    /** The prefix to use for negated boolean variables. Default is `'no-'` */
+    'negation-prefix': string;
+    /** Should keys that look like numbers be treated as such? Default is `true` */
+    'parse-numbers': boolean;
+    /** Should positional keys that look like numbers be treated as such? Default is `true` */
+    'parse-positional-numbers': boolean;
+    /** Should unparsed flags be stored in -- or _. Default is `false` */
+    'populate--': boolean;
+    /** Should a placeholder be added for keys not set via the corresponding CLI argument? Default is `false` */
+    'set-placeholder-key': boolean;
+    /** Should a group of short-options be treated as boolean flags? Default is `true` */
+    'short-option-groups': boolean;
+    /** Should aliases be removed before returning results? Default is `false` */
+    'strip-aliased': boolean;
+    /** Should dashed keys be removed before returning results? This option has no effect if camel-case-expansion is disabled. Default is `false` */
+    'strip-dashed': boolean;
+    /** Should unknown options be treated like regular arguments? An unknown option is one that is not configured in opts. Default is `false` */
+    'unknown-options-as-args': boolean;
+  }
+
+  interface Options {
+    /** An object representing the set of aliases for a key: `{ alias: { foo: ['f']} }`. */
+    alias?: { [key: string]: string | string[] };
+    /**
+     * Indicate that keys should be parsed as an array: `{ array: ['foo', 'bar'] }`.
+     * Indicate that keys should be parsed as an array and coerced to booleans / numbers:
+     * { array: [ { key: 'foo', boolean: true }, {key: 'bar', number: true} ] }`.
+     */
+    array?:
+      | string[]
+      | Array<{ key: string; boolean?: boolean; number?: boolean }>;
+    /** Arguments should be parsed as booleans: `{ boolean: ['x', 'y'] }`. */
+    boolean?: string[];
+    /** Indicate a key that represents a path to a configuration file (this file will be loaded and parsed). */
+    config?: string | string[] | { [key: string]: boolean };
+    /** Provide configuration options to the yargs-parser. */
+    configuration?: Partial<Configuration>;
+    /**
+     * Provide a custom synchronous function that returns a coerced value from the argument provided (or throws an error), e.g.
+     * `{ coerce: { foo: function (arg) { return modifiedArg } } }`.
+     */
+    coerce?: { [key: string]: (arg: any) => any };
+    /** Indicate a key that should be used as a counter, e.g., `-vvv = {v: 3}`. */
+    count?: string[];
+    /** Provide default values for keys: `{ default: { x: 33, y: 'hello world!' } }`. */
+    default?: { [key: string]: any };
+    /** Environment variables (`process.env`) with the prefix provided should be parsed. */
+    envPrefix?: string;
+    /** Specify that a key requires n arguments: `{ narg: {x: 2} }`. */
+    narg?: { [key: string]: number };
+    /** `path.normalize()` will be applied to values set to this key. */
+    normalize?: string[];
+    /** Keys should be treated as strings (even if they resemble a number `-x 33`). */
+    string?: string[];
+    /** Keys should be treated as numbers. */
+    number?: string[];
+  }
+
+  interface Parser {
+    (argv: string | string[], opts?: Options): Arguments;
+    detailed(argv: string | string[], opts?: Options): DetailedArguments;
+  }
+}
+
+declare var yargsParser: yargsParser.Parser;
+export = yargsParser;