utopia-scripts/lib/main.js

scripts makes you free

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __objRest = (source, exclude) => {
  var target = {};
  for (var prop in source)
    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
      target[prop] = source[prop];
  if (source != null && __getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(source)) {
      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
        target[prop] = source[prop];
    }
  return target;
};
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
var __async = (__this, __arguments, generator) => {
  return new Promise((resolve6, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve6(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};

// package.json
var require_package = __commonJS({
  "package.json"(exports, module2) {
    module2.exports = {
      name: "utopia-scripts",
      version: "0.1.0",
      description: "scripts makes you free",
      engines: {
        node: ">=8.3.0"
      },
      bin: {
        "utopia-scripts": "./bin/index.js"
      },
      files: [
        "bin",
        "lib"
      ],
      scripts: {
        build: "node build.js",
        lint: "eslint --ext .js,.ts src",
        test: 'echo "pass test"',
        publish: "bash publish.sh"
      },
      keywords: [
        "utopia",
        "scripts",
        "cli"
      ],
      author: "ConradZhangcong",
      license: "MIT",
      dependencies: {
        chalk: "^4.1.2",
        commander: "^9.3.0",
        "download-git-repo": "^3.0.2",
        inquirer: "^8.2.4",
        ora: "5.4.1",
        "utopia-utils": "^0.0.4"
      },
      devDependencies: {
        "@types/inquirer": "^8.2.1",
        "@types/node": "^17.0.40",
        "@typescript-eslint/eslint-plugin": "^4.33.0",
        "@typescript-eslint/parser": "^4.33.0",
        esbuild: "^0.14.42",
        eslint: "^7.32.0",
        "eslint-config-prettier": "^8.5.0",
        "eslint-define-config": "^1.5.0",
        "eslint-plugin-import": "^2.26.0",
        "eslint-plugin-node": "^11.1.0",
        "eslint-plugin-prettier": "^3.4.1",
        prettier: "2.2.1",
        typescript: "^4.7.3"
      },
      repository: {
        type: "git",
        url: "https://github.com/ConradZhangcong/utopia-scripts.git"
      }
    };
  }
});

// src/main.ts
var import_commander = require("commander");
var import_chalk4 = require("../node_modules/chalk/source/index.js");

// src/create/index.ts
var import_process = require("process");
var import_fs4 = require("fs");
var import_path3 = require("path");
var import_ora = __toESM(require("../node_modules/ora/index.js"));
var import_util3 = require("util");
var import_chalk2 = require("../node_modules/chalk/source/index.js");

// src/__utils/downloadGitRepo.ts
var import_util = require("util");
var import_download_git_repo = __toESM(require("../node_modules/download-git-repo/index.js"));
var downloadRepo = (0, import_util.promisify)(import_download_git_repo.default);
var downloadGitRepo_default = downloadRepo;

// src/__utils/isExists.ts
var import_fs = require("fs");
var isExists = (path, options = {}) => {
  const exists = (0, import_fs.existsSync)(path);
  if (!exists)
    return false;
  const stats = (0, import_fs.statSync)(path);
  const isFile = stats.isFile();
  const type = options.type || "file";
  if (type === "file") {
    return isFile;
  } else if (type === "directory") {
    return !isFile;
  } else {
    console.warn(`isExists options.type: ${type} is not validate, will be seen as 'file'`);
    return isFile;
  }
};
var isDirectoryExists = (path) => isExists(path, { type: "directory" });
var isExists_default = isExists;

// src/create/getActualProjectName.ts
var import_fs2 = require("fs");
var import_path = require("path");

// src/create/inquirers.ts
var import_inquirer = require("../node_modules/inquirer/lib/inquirer.js");
var import_chalk = require("../node_modules/chalk/source/index.js");
var inputNewPrjName = () => (0, import_inquirer.prompt)({
  type: "input",
  name: "prjName",
  message: "Target directory exists, please input new project name: "
});
var confirmOverwrite = (projectName) => (0, import_inquirer.prompt)({
  type: "confirm",
  name: "isOverwrite",
  message: `Sure to overwrite: ${(0, import_chalk.red)(projectName)} ?`
});
var operateWhilePrjNameConflict = () => (0, import_inquirer.prompt)({
  type: "list",
  name: "conflictAction",
  message: "Target directory exists, Please choose an action",
  choices: [
    { name: "Create a new floder", value: "newFolder" },
    { name: "Overwrite", value: "overwrite" },
    { name: "Quit", value: "quit" }
  ]
});
var chooseTemplate = () => (0, import_inquirer.prompt)({
  type: "list",
  name: "template",
  message: "Please choose a template",
  choices: ["basic", "react"]
});

// src/create/getActualProjectName.ts
var checkExist = (projectName) => {
  const cwd = process.cwd();
  const targetDir = (0, import_path.resolve)(cwd, projectName);
  return (0, import_fs2.existsSync)(targetDir);
};
var getNewPrjName = () => __async(void 0, null, function* () {
  const loop = () => __async(void 0, null, function* () {
    const answer = yield inputNewPrjName();
    return answer.prjName;
  });
  let prjName = yield loop();
  while (checkExist(prjName)) {
    prjName = yield loop();
  }
  return prjName;
});
var conflict = (projectName) => __async(void 0, null, function* () {
  const { conflictAction } = yield operateWhilePrjNameConflict();
  if (conflictAction === "overwrite") {
    const { isOverwrite } = yield confirmOverwrite(projectName);
    if (isOverwrite) {
      return { projectName, overwrite: true };
    } else {
      return yield conflict(projectName);
    }
  } else if (conflictAction === "newFolder") {
    const newPrjName = yield getNewPrjName();
    return { projectName: newPrjName, overwrite: false };
  } else {
    return {
      quit: true
    };
  }
});
var getActualProjectName = (projectName, options) => __async(void 0, null, function* () {
  if (!checkExist(projectName))
    return { projectName, overwrite: false };
  if (Reflect.has(options, "force")) {
    let forceOverwrite = false;
    if (options.force) {
      const ans = yield confirmOverwrite(projectName);
      forceOverwrite = ans.isOverwrite;
    }
    if (forceOverwrite)
      return { projectName, overwrite: true };
    const newPrjName = yield getNewPrjName();
    return { projectName: newPrjName, overwrite: true };
  }
  const confilctRes = conflict(projectName);
  return confilctRes;
});
var getActualProjectName_default = getActualProjectName;

// src/create/updateProject.ts
var import_fs3 = __toESM(require("fs"));
var import_path2 = require("path");
var import_child_process = require("child_process");
var import_util2 = require("util");

// src/create/const.ts
var TemplateRepos = {
  basic: "github:ConradZhangcong/utopia-template-basic",
  react: "github:ConradZhangcong/utopia-template-react"
};
var GIT_USER_NAME_CMD = "git config user.name";
var GIT_USER_EMAIL_CMD = "git config user.email";
var GIT_REPOSITORY_INIT = "git init";
var GIT_REPOSITORY_FIRST_COMMIT = `git add . && git commit -m "init"`;

// src/create/updateProject.ts
var exec = (0, import_util2.promisify)(import_child_process.exec);
var readFile = (0, import_util2.promisify)(import_fs3.default.readFile);
var writeFile = (0, import_util2.promisify)(import_fs3.default.writeFile);
var getGitUserInfo = () => __async(void 0, null, function* () {
  try {
    const result = {};
    const nameRes = yield exec(GIT_USER_NAME_CMD);
    if (nameRes) {
      Object.assign(result, { name: nameRes.stdout.replace(`
`, "") });
    }
    const emailRes = yield exec(GIT_USER_EMAIL_CMD);
    if (nameRes) {
      Object.assign(result, { email: emailRes.stdout.replace(`
`, "") });
    }
    return result;
  } catch (error) {
    console.error("utopia-scripts: \u83B7\u53D6git\u4FE1\u606F\u5931\u8D25");
    console.error(error);
  }
});
var updatePackageJson = (_0) => __async(void 0, [_0], function* ({
  path,
  prjName
}) {
  const pkgPath = (0, import_path2.resolve)(path, "package.json");
  if (!isExists_default(pkgPath))
    return;
  const pkgInfo = yield readFile(pkgPath, "utf8");
  const pkgData = JSON.parse(pkgInfo);
  Object.assign(pkgData, { name: prjName });
  const userInfo = yield getGitUserInfo();
  if (userInfo) {
    const { name: name2, email } = userInfo;
    if (name2 && email) {
      Object.assign(pkgData, { author: `${name2} ${email}` });
    }
  }
  yield writeFile(pkgPath, JSON.stringify(pkgData, null, 2));
});
var initGitRepo = (_0) => __async(void 0, [_0], function* ({ path }) {
  yield exec(GIT_REPOSITORY_INIT, { cwd: path });
});
var firstCommit = (_0) => __async(void 0, [_0], function* ({ path }) {
  yield exec(GIT_REPOSITORY_FIRST_COMMIT, { cwd: path });
});
var updateProject = (options) => __async(void 0, null, function* () {
  yield Promise.all([
    updatePackageJson(options),
    initGitRepo(options)
  ]);
  yield firstCommit(options);
});
var updateProject_default = updateProject;

// src/create/index.ts
var remove = (0, import_util3.promisify)(import_fs4.rm);
var create = (projectName, options) => __async(void 0, null, function* () {
  try {
    const actualPrjNameRes = yield getActualProjectName_default(projectName, options);
    const { quit, projectName: actualPrjName, overwrite } = actualPrjNameRes;
    if (quit) {
      console.log("quit");
      console.log((0, import_chalk2.blue)("utopia-scripts: create done!"));
      (0, import_process.exit)(0);
    }
    const cwd = process.cwd();
    const actualPath = (0, import_path3.resolve)(cwd, actualPrjName);
    const { template } = yield chooseTemplate();
    const spinner = (0, import_ora.default)("downloading template, please wait");
    spinner.start();
    try {
      if (overwrite) {
        yield remove(actualPath, { force: true, recursive: true });
      }
      yield downloadGitRepo_default(TemplateRepos[template], actualPath);
      yield updateProject_default({ path: actualPath, prjName: actualPrjName });
      spinner.succeed();
      console.log("done");
    } catch (err) {
      spinner.fail("request fail, refetching");
      console.log("err: ", err);
    }
  } catch (error) {
    console.error((0, import_chalk2.red)("utopia-scripts create error:"));
    console.error(error);
    (0, import_process.exit)(1);
  }
});
var create_default = create;

// src/generate-changelog/index.ts
var import_process2 = require("process");
var import_chalk3 = require("../node_modules/chalk/source/index.js");

// src/generate-changelog/check.ts
var import_child_process2 = require("child_process");
var import_util4 = require("util");
var exec2 = (0, import_util4.promisify)(import_child_process2.exec);
var checkGit = () => exec2("git --version").catch(() => {
  throw new Error("command not found: git");
});
var checkGitRepo = (path) => exec2("git rev-parse --is-inside-work-tree", { cwd: path }).then((data) => {
  if (data.stdout.includes("true")) {
    return true;
  }
  return false;
}).catch((err) => {
  throw err;
});

// src/generate-changelog/process.ts
var import_path4 = require("path");
var getLocaleTime = (date) => {
  const now = date || new Date();
  return now.toLocaleDateString() + " " + now.toLocaleTimeString();
};
var isArray = (directory) => /^\[.*\]$/.test(directory);
var getDirectoryList = (directory) => {
  const baseUrl = process.cwd();
  if (!directory) {
    return [baseUrl];
  }
  if (isArray(directory)) {
    const directoryList = JSON.parse(directory);
    return directoryList.map((dir) => (0, import_path4.resolve)(baseUrl, dir));
  }
  return [];
};
var processOptions = (options) => {
  const _a = options, { since, until, directory } = _a, restOptions = __objRest(_a, ["since", "until", "directory"]);
  const nowDate = new Date();
  const untilTime = until || getLocaleTime(nowDate);
  const sinceTime = since || nowDate.toLocaleDateString() + " 00:00:00";
  const directoryList = getDirectoryList(directory);
  return __spreadValues({
    directory,
    directoryList,
    since: sinceTime,
    until: untilTime,
    now: nowDate
  }, restOptions);
};

// src/generate-changelog/generateLog.ts
var import_child_process3 = require("child_process");
var import_fs5 = require("fs");
var import_path5 = require("path");
var import_util5 = require("util");

// src/generate-changelog/const.ts
var SPLIT_STR = "--utopia-scripts-split--";

// src/generate-changelog/generateLog.ts
var exec3 = (0, import_util5.promisify)(import_child_process3.exec);
var writeFile2 = (0, import_util5.promisify)(import_fs5.writeFile);
var matchRegExp = /commitId: (.*), author: (.*), date: (.*), message: (.*)/;
var getLogCommand = ({ since, until }) => {
  return `git log --date=iso --since="${since}" --until="${until}" --pretty=format:"commitId: %h, author: %aN, date: %ad, message: %s${SPLIT_STR}"`;
};
var formatLog = (log) => {
  const result = log.match(matchRegExp);
  if (!result)
    return null;
  const [, commitId, author, date, message] = result;
  return { commitId, author, date, message };
};
var matchMessage = (message, reg) => {
  var _a;
  return reg ? (_a = message.match(new RegExp(reg))) == null ? void 0 : _a[1] : message;
};
var generateFileStr = (dirList, options) => {
  const { message: reg, since, until } = options;
  const originData = JSON.stringify(dirList, null, 2);
  const completeList = [];
  let result = `# CHANGELOG\r
\r
`;
  result += `startTime: ${since}\r
endTime: ${until}\r
\r
`;
  for (const dirItem of dirList) {
    const { dirPath, logList } = dirItem;
    let str = `## ${dirPath}\r
\r
`;
    const messageList = [];
    logList == null ? void 0 : logList.forEach((item) => {
      const message = matchMessage(item.message, reg);
      if (message) {
        messageList.push(message);
      }
    });
    const messageListSet = new Set(messageList);
    for (const item of messageListSet) {
      str += `${item}\r
`;
    }
    if (str) {
      dirItem.messageStr = `${str}\r
`;
    }
    completeList.push(...messageList);
  }
  const completeListSet = new Set(completeList);
  let completeMessage = "";
  for (const item of completeListSet) {
    completeMessage += item;
    completeMessage += "\r\n";
  }
  result += `${completeMessage}\r
`;
  for (const dirItem of dirList) {
    result += dirItem.messageStr;
  }
  result += `### origin data\r
\r
\`\`\`json\r
${originData}\r
\`\`\`\r
`;
  return result;
};
var generateLog = (execDirList, options) => __async(void 0, null, function* () {
  const LOG_COMMAND = getLogCommand(options);
  const gitLogExecList = [];
  const gitLogList = [];
  for (const dir of execDirList) {
    gitLogExecList.push(exec3(LOG_COMMAND, { cwd: dir }));
    gitLogList.push({ dirPath: dir });
  }
  const originList = yield Promise.all(gitLogExecList);
  for (const index in originList) {
    const gitlogItem = originList[index];
    if (!gitlogItem.stdout) {
      continue;
    }
    const logList = gitlogItem.stdout.split(SPLIT_STR).map((item) => formatLog(item)).filter((item) => !!item);
    gitLogList[index].logList = logList;
  }
  const fileData = generateFileStr(gitLogList, options);
  const { now } = options;
  const fileName = `CHANGELOG-${now.getTime()}.md`;
  yield writeFile2(fileName, fileData);
  return (0, import_path5.resolve)(process.cwd(), fileName);
});
var generateLog_default = generateLog;

// src/generate-changelog/index.ts
var generateChangelog = (options) => __async(void 0, null, function* () {
  try {
    yield checkGit();
    const handledOptions = processOptions(options);
    const notExistsDirList = [];
    const notGitRepoDirList = [];
    const execDirList = [];
    for (const directory of handledOptions.directoryList) {
      if (!isDirectoryExists(directory)) {
        notExistsDirList.push(directory);
        continue;
      }
      if (!(yield checkGitRepo(directory))) {
        notGitRepoDirList.push(directory);
        continue;
      }
      execDirList.push(directory);
    }
    if (execDirList.length > 0) {
      const logFilePath = yield generateLog_default(execDirList, handledOptions);
      console.log((0, import_chalk3.blue)(`changelog has been generated, open ${logFilePath}!`));
    }
    if (notExistsDirList.length > 0) {
      const notExistsDirStr = notExistsDirList.join("\r\n");
      const errorMsg = `directory are not exist:\r
${notExistsDirStr}\r
`;
      console.log((0, import_chalk3.red)(errorMsg));
    }
    if (notGitRepoDirList.length > 0) {
      const notGitRepoDirStr = notGitRepoDirList.join("\r\n");
      const errorMsg = `not a git repository:\r
${notGitRepoDirStr}\r
`;
      console.log((0, import_chalk3.red)(errorMsg));
    }
    console.log((0, import_chalk3.blue)("utopia-scripts: generate changelog done!"));
    (0, import_process2.exit)(0);
  } catch (error) {
    console.error((0, import_chalk3.red)("utopia-scripts generate-changelog error:"));
    console.error(error);
    (0, import_process2.exit)(1);
  }
});
var generate_changelog_default = generateChangelog;

// src/main.ts
var packageInfo = require_package();
var { name, version } = packageInfo;
import_commander.program.name(name).version(version, "-v, -V, --version", `display version for ${name}`).usage(`<command> [option]`);
import_commander.program.command("create <project-name>").description("create a new project with utopia-template").option("-f, --force", "overwrite target directory if it exists").action((...args) => create_default(...args));
import_commander.program.command("generate-changelog").description("generate changelog by commit message").option("-c, --config <config-file>", "if exists, other configs will be ignored").option("-d, --directory <directory-list>", "accpet string | Array<string>, search subdirectories of current directory").option("-s, --since <start-time>", "start time").option("-u, --until <end-time>", "end time").option("-m, --message <message-regexp>", "match regexp for actual message").action((...args) => generate_changelog_default(...args));
import_commander.program.on("--help", function() {
  console.log(`\r
Run ${(0, import_chalk4.cyan)(`${name} <command> --help`)} for detailed usage of given command.\r
`);
});
import_commander.program.parse(process.argv);