@batijs/cli 0.0.2 → 0.0.5

package/dist/index.js

@@ -1,24 +1,584 @@
+// ../../node_modules/.pnpm/citty@0.1.1/node_modules/citty/dist/index.mjs
+import * as tty from "tty";
+function toArray(val) {
+  if (Array.isArray(val)) {
+    return val;
+  }
+  return val !== void 0 ? [val] : [];
+}
+function formatLineColumns(lines, linePrefix = "") {
+  const maxLengh = [];
+  for (const line of lines) {
+    for (const [i, element] of line.entries()) {
+      maxLengh[i] = Math.max(maxLengh[i] || 0, element.length);
+    }
+  }
+  return lines.map(
+    (l) => l.map(
+      (c, i) => linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLengh[i])
+    ).join("  ")
+  ).join("\n");
+}
+function resolveValue(input) {
+  return typeof input === "function" ? input() : input;
+}
+var CLIError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "CLIError";
+  }
+};
+var NUMBER_CHAR_RE = /\d/;
+var STR_SPLITTERS = ["-", "_", "/", "."];
+function isUppercase(char = "") {
+  if (NUMBER_CHAR_RE.test(char)) {
+    return void 0;
+  }
+  return char.toUpperCase() === char;
+}
+function splitByCase(string_, separators) {
+  const splitters = separators ?? STR_SPLITTERS;
+  const parts = [];
+  if (!string_ || typeof string_ !== "string") {
+    return parts;
+  }
+  let buff = "";
+  let previousUpper;
+  let previousSplitter;
+  for (const char of string_) {
+    const isSplitter = splitters.includes(char);
+    if (isSplitter === true) {
+      parts.push(buff);
+      buff = "";
+      previousUpper = void 0;
+      continue;
+    }
+    const isUpper = isUppercase(char);
+    if (previousSplitter === false) {
+      if (previousUpper === false && isUpper === true) {
+        parts.push(buff);
+        buff = char;
+        previousUpper = isUpper;
+        continue;
+      }
+      if (previousUpper === true && isUpper === false && buff.length > 1) {
+        const lastChar = buff[buff.length - 1];
+        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+        buff = lastChar + char;
+        previousUpper = isUpper;
+        continue;
+      }
+    }
+    buff += char;
+    previousUpper = isUpper;
+    previousSplitter = isSplitter;
+  }
+  parts.push(buff);
+  return parts;
+}
+function upperFirst(string_) {
+  return !string_ ? "" : string_[0].toUpperCase() + string_.slice(1);
+}
+function lowerFirst(string_) {
+  return !string_ ? "" : string_[0].toLowerCase() + string_.slice(1);
+}
+function pascalCase(string_) {
+  return !string_ ? "" : (Array.isArray(string_) ? string_ : splitByCase(string_)).map((p) => upperFirst(p)).join("");
+}
+function camelCase(string_) {
+  return lowerFirst(pascalCase(string_));
+}
+function kebabCase(string_, joiner) {
+  return !string_ ? "" : (Array.isArray(string_) ? string_ : splitByCase(string_)).map((p) => p.toLowerCase()).join(joiner ?? "-");
+}
+function toArr(any) {
+  return any == void 0 ? [] : Array.isArray(any) ? any : [any];
+}
+function toVal(out, key, val, opts) {
+  let x;
+  const old = out[key];
+  const nxt = ~opts.string.indexOf(key) ? val == void 0 || val === true ? "" : String(val) : typeof val === "boolean" ? val : ~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
+  out[key] = old == void 0 ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+}
+function parseRawArgs(args = [], opts = {}) {
+  let k;
+  let arr;
+  let arg;
+  let name;
+  let val;
+  const out = { _: [] };
+  let i = 0;
+  let j = 0;
+  let idx = 0;
+  const len = args.length;
+  const alibi = opts.alias !== void 0;
+  const strict = opts.unknown !== void 0;
+  const defaults = opts.default !== void 0;
+  opts.alias = opts.alias || {};
+  opts.string = toArr(opts.string);
+  opts.boolean = toArr(opts.boolean);
+  if (alibi) {
+    for (k in opts.alias) {
+      arr = opts.alias[k] = toArr(opts.alias[k]);
+      for (i = 0; i < arr.length; i++) {
+        (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+      }
+    }
+  }
+  for (i = opts.boolean.length; i-- > 0; ) {
+    arr = opts.alias[opts.boolean[i]] || [];
+    for (j = arr.length; j-- > 0; ) {
+      opts.boolean.push(arr[j]);
+    }
+  }
+  for (i = opts.string.length; i-- > 0; ) {
+    arr = opts.alias[opts.string[i]] || [];
+    for (j = arr.length; j-- > 0; ) {
+      opts.string.push(arr[j]);
+    }
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      name = typeof opts.default[k];
+      arr = opts.alias[k] = opts.alias[k] || [];
+      if (opts[name] !== void 0) {
+        opts[name].push(k);
+        for (i = 0; i < arr.length; i++) {
+          opts[name].push(arr[i]);
+        }
+      }
+    }
+  }
+  const keys = strict ? Object.keys(opts.alias) : [];
+  for (i = 0; i < len; i++) {
+    arg = args[i];
+    if (arg === "--") {
+      out._ = out._.concat(args.slice(++i));
+      break;
+    }
+    for (j = 0; j < arg.length; j++) {
+      if (arg.charCodeAt(j) !== 45) {
+        break;
+      }
+    }
+    if (j === 0) {
+      out._.push(arg);
+    } else if (arg.substring(j, j + 3) === "no-") {
+      name = arg.slice(Math.max(0, j + 3));
+      if (strict && !~keys.indexOf(name)) {
+        return opts.unknown(arg);
+      }
+      out[name] = false;
+    } else {
+      for (idx = j + 1; idx < arg.length; idx++) {
+        if (arg.charCodeAt(idx) === 61) {
+          break;
+        }
+      }
+      name = arg.substring(j, idx);
+      val = arg.slice(Math.max(0, ++idx)) || i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i];
+      arr = j === 2 ? [name] : name;
+      for (idx = 0; idx < arr.length; idx++) {
+        name = arr[idx];
+        if (strict && !~keys.indexOf(name)) {
+          return opts.unknown("-".repeat(j) + name);
+        }
+        toVal(out, name, idx + 1 < arr.length || val, opts);
+      }
+    }
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      if (out[k] === void 0) {
+        out[k] = opts.default[k];
+      }
+    }
+  }
+  if (alibi) {
+    for (k in out) {
+      arr = opts.alias[k] || [];
+      while (arr.length > 0) {
+        out[arr.shift()] = out[k];
+      }
+    }
+  }
+  return out;
+}
+function parseArgs(rawArgs, argsDef) {
+  const parseOptions = {
+    boolean: [],
+    string: [],
+    mixed: [],
+    alias: {},
+    default: {}
+  };
+  const args = resolveArgs(argsDef);
+  for (const arg of args) {
+    if (arg.type === "positional") {
+      continue;
+    }
+    if (arg.type === "string") {
+      parseOptions.string.push(arg.name);
+    } else if (arg.type === "boolean") {
+      parseOptions.boolean.push(arg.name);
+    }
+    if (arg.default !== void 0) {
+      parseOptions.default[arg.name] = arg.default;
+    }
+    if (arg.alias) {
+      parseOptions.alias[arg.name] = arg.alias;
+    }
+  }
+  const parsed = parseRawArgs(rawArgs, parseOptions);
+  const [...positionalArguments] = parsed._;
+  const parsedArgsProxy = new Proxy(parsed, {
+    get(target, prop) {
+      return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
+    }
+  });
+  for (const [, arg] of args.entries()) {
+    if (arg.type === "positional") {
+      const nextPositionalArgument = positionalArguments.shift();
+      if (nextPositionalArgument !== void 0) {
+        parsedArgsProxy[arg.name] = nextPositionalArgument;
+      } else if (arg.default !== void 0) {
+        parsedArgsProxy[arg.name] = arg.default;
+      } else {
+        throw new CLIError(
+          `Missing required positional argument: ${arg.name.toUpperCase()}`,
+          "EARG"
+        );
+      }
+    } else if (arg.required && parsedArgsProxy[arg.name] === void 0) {
+      throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
+    }
+  }
+  return parsedArgsProxy;
+}
+function resolveArgs(argsDef) {
+  const args = [];
+  for (const [name, argDef] of Object.entries(argsDef || {})) {
+    args.push({
+      ...argDef,
+      name,
+      alias: toArray(argDef.alias)
+    });
+  }
+  return args;
+}
+function defineCommand(def) {
+  return def;
+}
+async function runCommand(cmd, opts) {
+  const cmdArgs = await resolveValue(cmd.args || {});
+  const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
+  const context = {
+    rawArgs: opts.rawArgs,
+    args: parsedArgs,
+    cmd
+  };
+  if (typeof cmd.setup === "function") {
+    await cmd.setup(context);
+  }
+  const subCommands = await resolveValue(cmd.subCommands);
+  if (subCommands && Object.keys(subCommands).length > 0) {
+    const subCommandArgIndex = opts.rawArgs.findIndex(
+      (arg) => !arg.startsWith("-")
+    );
+    const subCommandName = opts.rawArgs[subCommandArgIndex];
+    if (!subCommandName && !cmd.run) {
+      throw new CLIError(
+        `Missing sub command. Use --help to see available sub commands.`,
+        "ESUBCOMMAND"
+      );
+    }
+    if (!subCommands[subCommandName]) {
+      throw new CLIError(
+        `Unknown sub command: ${subCommandName}`,
+        "ESUBCOMMAND"
+      );
+    }
+    const subCommand = await resolveValue(subCommands[subCommandName]);
+    if (subCommand) {
+      await runCommand(subCommand, {
+        rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1)
+      });
+    }
+  }
+  if (typeof cmd.run === "function") {
+    await cmd.run(context);
+  }
+}
+async function resolveSubCommand(cmd, rawArgs, parent) {
+  const subCommands = await resolveValue(cmd.subCommands);
+  if (subCommands && Object.keys(subCommands).length > 0) {
+    const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith("-"));
+    const subCommandName = rawArgs[subCommandArgIndex];
+    const subCommand = await resolveValue(subCommands[subCommandName]);
+    if (subCommand) {
+      return resolveSubCommand(
+        subCommand,
+        rawArgs.slice(subCommandArgIndex + 1),
+        cmd
+      );
+    }
+  }
+  return [cmd, parent];
+}
+async function showUsage(cmd, parent) {
+  try {
+    console.log(await renderUsage(cmd, parent) + "\n");
+  } catch (error) {
+    console.error(error);
+  }
+}
+async function renderUsage(cmd, parent) {
+  const cmdMeta = await resolveValue(cmd.meta || {});
+  const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
+  const parentMeta = await resolveValue(parent?.meta || {});
+  const commandName = `${parentMeta.name ? `${parentMeta.name} ` : ""}` + (cmdMeta.name || process.argv[1]);
+  const argLines = [];
+  const posLines = [];
+  const commandsLines = [];
+  const usageLine = [];
+  for (const arg of cmdArgs) {
+    if (arg.type === "positional") {
+      const name = arg.name.toUpperCase();
+      const isRequired = arg.required !== false && arg.default === void 0;
+      const usageHint = arg.default ? `="${arg.default}"` : "";
+      posLines.push([name + usageHint, arg.description || ""]);
+      usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
+    } else {
+      const isRequired = arg.required === true && arg.default === void 0;
+      const argStr = (arg.type === "boolean" && arg.default === true ? [
+        ...(arg.alias || []).map((a) => `--no-${a}`),
+        `--no-${arg.name}`
+      ].join(", ") : [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(
+        ", "
+      )) + (arg.type === "string" && (arg.valueHint || arg.default) ? `=${arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`}` : "");
+      argLines.push([
+        argStr + (isRequired ? " (required)" : ""),
+        arg.description || ""
+      ]);
+      if (isRequired) {
+        usageLine.push(argStr);
+      }
+    }
+  }
+  if (cmd.subCommands) {
+    const commandNames = [];
+    for (const [name, sub] of Object.entries(cmd.subCommands)) {
+      commandsLines.push([name, sub.meta?.description || ""]);
+      commandNames.push(name);
+    }
+    usageLine.push(commandNames.join("|"));
+  }
+  const usageLines = [];
+  const version = cmdMeta.version || parentMeta.version;
+  usageLines.push(
+    commandName + (version ? ` v${version}` : ""),
+    cmdMeta.description,
+    ""
+  );
+  const hasOptions = argLines.length > 0 || posLines.length > 0;
+  usageLines.push(
+    `USAGE: ${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(
+      " "
+    )}`,
+    ""
+  );
+  if (posLines.length > 0) {
+    usageLines.push("ARGUMENTS:", "");
+    usageLines.push(formatLineColumns(posLines, "  "));
+    usageLines.push("");
+  }
+  if (argLines.length > 0) {
+    usageLines.push("OPTIONS:", "");
+    usageLines.push(formatLineColumns(argLines, "  "));
+    usageLines.push("");
+  }
+  if (commandsLines.length > 0) {
+    usageLines.push("COMMANDS:", "");
+    usageLines.push(formatLineColumns(commandsLines, "  "));
+    usageLines.push(
+      "",
+      `Use \`${commandName} <command> --help\` for more information about a command.`
+    );
+  }
+  return usageLines.filter((l) => typeof l === "string").join("\n");
+}
+var {
+  env = {},
+  argv = [],
+  platform = ""
+} = typeof process === "undefined" ? {} : process;
+var isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+var isForced = "FORCE_COLOR" in env || argv.includes("--color");
+var isWindows = platform === "win32";
+var isDumbTerminal = env.TERM === "dumb";
+var isCompatibleTerminal = tty && tty.isatty && tty.isatty(1) && env.TERM && !isDumbTerminal;
+var isCI = "CI" in env && ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+var isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI);
+var replaceClose = (index, string, close, replace, head = string.substring(0, index) + replace, tail = string.substring(index + close.length), next = tail.indexOf(close)) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+var clearBleed = (index, string, open, close, replace) => index < 0 ? open + string + close : open + replaceClose(index, string, close, replace) + close;
+var filterEmpty = (open, close, replace = open, at = open.length + 1) => (string) => string || !(string === "" || string === void 0) ? clearBleed(
+  ("" + string).indexOf(close, at),
+  string,
+  open,
+  close,
+  replace
+) : "";
+var init = (open, close, replace) => filterEmpty(`\x1B[${open}m`, `\x1B[${close}m`, replace);
+var colors = {
+  reset: init(0, 0),
+  bold: init(1, 22, "\x1B[22m\x1B[1m"),
+  dim: init(2, 22, "\x1B[22m\x1B[2m"),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49),
+  blackBright: init(90, 39),
+  redBright: init(91, 39),
+  greenBright: init(92, 39),
+  yellowBright: init(93, 39),
+  blueBright: init(94, 39),
+  magentaBright: init(95, 39),
+  cyanBright: init(96, 39),
+  whiteBright: init(97, 39),
+  bgBlackBright: init(100, 49),
+  bgRedBright: init(101, 49),
+  bgGreenBright: init(102, 49),
+  bgYellowBright: init(103, 49),
+  bgBlueBright: init(104, 49),
+  bgMagentaBright: init(105, 49),
+  bgCyanBright: init(106, 49),
+  bgWhiteBright: init(107, 49)
+};
+var createColors = ({ useColor = isColorSupported } = {}) => useColor ? colors : Object.keys(colors).reduce(
+  (colors2, key) => ({ ...colors2, [key]: String }),
+  {}
+);
+var {
+  reset,
+  bold,
+  dim,
+  italic,
+  underline,
+  inverse,
+  hidden,
+  strikethrough,
+  black,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  gray,
+  bgBlack,
+  bgRed,
+  bgGreen,
+  bgYellow,
+  bgBlue,
+  bgMagenta,
+  bgCyan,
+  bgWhite,
+  blackBright,
+  redBright,
+  greenBright,
+  yellowBright,
+  blueBright,
+  magentaBright,
+  cyanBright,
+  whiteBright,
+  bgBlackBright,
+  bgRedBright,
+  bgGreenBright,
+  bgYellowBright,
+  bgBlueBright,
+  bgMagentaBright,
+  bgCyanBright,
+  bgWhiteBright
+} = createColors();
+async function runMain(cmd, opts = {}) {
+  const rawArgs = opts.rawArgs || process.argv.slice(2);
+  try {
+    if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+      await showUsage(...await resolveSubCommand(cmd, rawArgs));
+      process.exit(0);
+    } else {
+      await runCommand(cmd, { rawArgs });
+    }
+  } catch (error) {
+    const isCLIError = error instanceof CLIError;
+    if (!isCLIError) {
+      console.error(error, "\n");
+    }
+    console.error(
+      `
+${bgRed(` ${error.code || error.name} `)} ${error.message}
+`
+    );
+    if (isCLIError) {
+      await showUsage(...await resolveSubCommand(cmd, rawArgs));
+    }
+    process.exit(1);
+  }
+}
+
 // index.ts
-import { defineCommand, runMain } from "citty";
 import exec from "@batijs/build";
 
 // package.json
 var package_default = {
   name: "@batijs/cli",
-  version: "0.0.2",
+  version: "0.0.5",
   description: "",
   type: "module",
   scripts: {
+    prerelease: "rm -rf ./dist",
     prepublishOnly: "pnpm run build",
-    build: "tsup"
+    build: "rm -rf dist && tsup"
   },
   keywords: [],
   author: "",
   license: "MIT",
   devDependencies: {
-    "@types/node": "^16.0.0",
-    tsup: "^6.7.0",
-    typescript: "^5.0.3"
+    "@batijs/tsup": "workspace:*",
+    "@types/node": "^16.18.24",
+    citty: "^0.1.1",
+    colorette: "^2.0.20",
+    esbuild: "^0.17.18",
+    execa: "^7.1.1",
+    typescript: "^5.0.4"
+  },
+  dependencies: {
+    "@batijs/build": "workspace:*",
+    "@batijs/core": "workspace:*",
+    "@typescript-eslint/eslint-plugin": "^5.59.2",
+    "@typescript-eslint/parser": "^5.59.2",
+    eslint: "^8.39.0",
+    "eslint-plugin-unused-imports": "^2.0.0"
   },
   bin: "./dist/index.js",
   exports: {
@@ -31,36 +591,90 @@ var package_default = {
       ]
     }
   },
-  dependencies: {
-    "@batijs/build": "workspace:*",
-    citty: "^0.1.1"
-  },
   files: [
     "dist/"
   ]
 };
 
 // index.ts
-var main = defineCommand({
-  meta: {
-    name: package_default.name,
-    version: package_default.version,
-    description: package_default.description
-  },
-  args: {
-    dist: {
-      type: "positional",
-      description: "Dist folder",
-      required: true
+import { flags as coreFlags } from "@batijs/core";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { readFile } from "fs/promises";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function boilerplatesDir() {
+  if (existsSync(join(__dirname, "boilerplates", "boilerplates.json"))) {
+    return join(__dirname, "boilerplates");
+  } else if (existsSync(join(__dirname, "dist", "boilerplates", "boilerplates.json"))) {
+    return join(__dirname, "dist", "boilerplates");
+  }
+  throw new Error("Missing boilerplates.json file. Run `pnpm run build`");
+}
+async function parseBoilerplates(dir) {
+  return JSON.parse(await readFile(join(dir, "boilerplates.json"), "utf-8"));
+}
+function toArg(flag) {
+  if (!flag)
+    return {};
+  return {
+    [flag]: {
+      type: "boolean",
+      required: false
     }
-  },
-  run({ args }) {
-    exec(
+  };
+}
+async function run() {
+  const dir = boilerplatesDir();
+  const boilerplates = await parseBoilerplates(dir);
+  const main = defineCommand({
+    meta: {
+      name: package_default.name,
+      version: package_default.version,
+      description: package_default.description
+    },
+    args: Object.assign(
       {
-        dist: args.dist
+        dist: {
+          type: "positional",
+          description: "Dist folder",
+          required: true
+        }
       },
-      {}
-    );
-  }
+      ...Array.from(coreFlags.keys()).map(toArg)
+    ),
+    async run({ args }) {
+      const sources = [];
+      const features = [];
+      const flags = Object.entries(args).filter(([, val]) => val === true).map(([key]) => key);
+      for (const bl of boilerplates.filter((b) => !b.config.flag)) {
+        sources.push(join(dir, bl.folder));
+      }
+      for (const bl of boilerplates.filter((b) => Boolean(b.config.flag))) {
+        if (flags.includes(bl.config.flag)) {
+          sources.push(join(dir, bl.folder));
+        }
+      }
+      for (const flag of flags) {
+        features.push(coreFlags.get(flag));
+      }
+      await exec(
+        {
+          source: sources,
+          dist: args.dist
+        },
+        {
+          VIKE_MODULES: features
+        }
+      );
+    }
+  });
+  await runMain(main);
+}
+run().then(() => {
+  process.exit(0);
+}).catch((e) => {
+  console.error(e);
+  process.exit(1);
 });
-runMain(main);