@teams-max/mwsp 1.0.2 → 2.0.0

package/lib/utils/chalk/package.json

@@ -0,0 +1 @@
+{"name":"chalk","main":"index.js","license":"MIT","types":"index.d.ts"}

package/lib/utils/changelog.js

@@ -0,0 +1,21 @@
+// src/utils/changelog.js
+var { htmlEscape } = require("escape-goat");
+var git = require("./git");
+exports.getChangelog = async () => {
+  const repoUrl = "https://v.src.corp.qihoo.net/it_informatization/pro-teams";
+  const latest = await git.latestTagOrFirstCommit();
+  const log = await git.commitLogFromRevision(latest);
+  if (!log) {
+    throw new Error(`get changelog failed, no new commits was found.`);
+  }
+  const commits = log.split("\n").map((commit) => {
+    const splitIndex = commit.lastIndexOf(" ");
+    return {
+      message: commit.slice(0, splitIndex),
+      id: commit.slice(splitIndex + 1)
+    };
+  });
+  return (nextTag) => commits.map((commit) => `- ${htmlEscape(commit.message)}  ${commit.id}`).join("\n") + `
+
+${repoUrl}/compare/${latest}...${nextTag}`;
+};

package/lib/{internal → utils}/cross-spawn/index.js

@@ -1,4 +1,4 @@
-// src/internal/cross-spawn/index.js
+// src/utils/cross-spawn/index.js
 module.exports = (() => {
   var t = {
     746: (t2, e2, n) => {

package/lib/{internal → utils}/datetimeFormat.js

@@ -1,27 +1,4 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/internal/datetimeFormat.ts
-var datetimeFormat_exports = {};
-__export(datetimeFormat_exports, {
-  default: () => datetimeFormat_default
-});
-module.exports = __toCommonJS(datetimeFormat_exports);
+// src/utils/datetimeFormat.js
 function isValidDate(value) {
   const date = new Date(value);
   return date instanceof Date && !isNaN(date.valueOf());
@@ -92,15 +69,19 @@ function datetimeFormat(value, format, isCoerce) {
     6: "\u516D"
   };
   if (/(E+)/.test(format)) {
-    format = format.replace(RegExp.$1, (RegExp.$1.length > 1 ? RegExp.$1.length > 2 ? "\u661F\u671F" : "\u5468" : "") + week[date.getDay() + ""]);
+    format = format.replace(
+      RegExp.$1,
+      (RegExp.$1.length > 1 ? RegExp.$1.length > 2 ? "\u661F\u671F" : "\u5468" : "") + week[date.getDay() + ""]
+    );
   }
   for (const k in o) {
     if (new RegExp("(" + k + ")").test(format)) {
-      format = format.replace(RegExp.$1, RegExp.$1.length === 1 ? o[k] : ("00" + o[k]).substr(("" + o[k]).length));
+      format = format.replace(
+        RegExp.$1,
+        RegExp.$1.length === 1 ? o[k] : ("00" + o[k]).substr(("" + o[k]).length)
+      );
     }
   }
   return format;
 }
-var datetimeFormat_default = datetimeFormat;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
+module.exports = datetimeFormat;

package/lib/utils/defineConfig.js

@@ -0,0 +1,19 @@
+// src/utils/defineConfig.js
+var path = require("path");
+var { logStep, printErrorAndExit } = require("./index");
+function defineConfig(config) {
+  if (!process.env.ASG_DIR) {
+    logStep("The Asgard directory does not exist, using default config...");
+    return config;
+  }
+  let iConfigFromPlugins = null;
+  try {
+    iConfigFromPlugins = require(path.join(process.env.ASG_DIR, "base", "pluginConfig.js"));
+  } catch (error) {
+    printErrorAndExit("The Asgard directory does not exist.", `Reason: ${error.message}`);
+    return;
+  }
+  logStep("The Asgard directory exists, using config from plugins...");
+  return iConfigFromPlugins(config);
+}
+module.exports = defineConfig;

package/lib/utils/exec.js

@@ -0,0 +1,23 @@
+// src/utils/exec.js
+var { spawn } = require("child_process");
+module.exports = function exec(command, args, opts) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      shell: true,
+      stdio: "inherit",
+      env: process.env,
+      ...opts
+    });
+    child.once("error", (err) => {
+      console.log(err);
+      reject(err);
+    });
+    child.once("close", (code) => {
+      if (code === 1) {
+        process.exit(1);
+      } else {
+        resolve();
+      }
+    });
+  });
+};

package/lib/{internal → utils}/execa/index.js

@@ -1,4 +1,4 @@
-// src/internal/execa/index.js
+// src/utils/execa/index.js
 module.exports = (() => {
   var e = {
     205: (e2, t2, r) => {

package/lib/utils/getPackages.js

@@ -0,0 +1,6 @@
+// src/utils/getPackages.js
+var { readdirSync } = require("fs");
+var { join } = require("path");
+module.exports = function getPackages() {
+  return readdirSync(join(__dirname, "../../packages")).filter((pkg) => pkg.charAt(0) !== ".");
+};

package/lib/utils/git.js

@@ -0,0 +1,23 @@
+// src/utils/git.js
+var { execa, chalk, yParser } = require("./index");
+exports.latestTag = async () => {
+  const { stdout } = await execa("git", ["describe", "--abbrev=0", "--tags"]);
+  return stdout;
+};
+var firstCommit = async () => {
+  const { stdout } = await execa("git", ["rev-list", "--max-parents=0", "HEAD"]);
+  return stdout;
+};
+exports.latestTagOrFirstCommit = async () => {
+  let latest;
+  try {
+    latest = await exports.latestTag();
+  } catch (_) {
+    latest = await firstCommit();
+  }
+  return latest;
+};
+exports.commitLogFromRevision = async (revision) => {
+  const { stdout } = await execa("git", ["log", "--format=%s %h", `${revision}..HEAD`]);
+  return stdout;
+};

package/lib/utils/index.js

@@ -0,0 +1,159 @@
+// 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 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") {
+      await exec("yarn", ["add", "snb-mock-middleware", "lodash-webpack-plugin", "-D"]);
+      await exec("yarn", ["add", "@teams-max/skynet", "history"]);
+    } else if ((infra == null ? void 0 : infra.arch) === "MAX") {
+      await exec("pnpm", ["add", "axios", "-D"]);
+      await exec("pnpm", ["add", "@teams-max/skynet", "classnames", "qs", "uuid", "react-draggable"]);
+    }
+    logStep("Installation completed.");
+  } else if (JENKINS_BUILD && !ASG_BRAHCH) {
+    logStep("Jenkins build detected. Skipping sync up.");
+    return;
+  } else {
+    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", ["pull", "origin", "master"]);
+    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/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/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,112 @@
+// 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;