done-coding-template 0.7.11 → 0.8.0-alpha.0

package/es/cli.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { d as m } from "./main-3510f696.js";
-import "@done-coding/cli-utils";
+import { e as m } from "./main-bd31ea48.js";
 import "node:path";
 import "node:fs";
+import "@done-coding/cli-utils";
 import "lodash.template";
 import "lodash.assign";
 m();

package/es/index.mjs

@@ -1,28 +1,28 @@
 #!/usr/bin/env node
-import { M as r } from "./main-3510f696.js";
-import { O as E, S as h, T as b, b as T, c as A, a as H, h as O, i as S } from "./main-3510f696.js";
+import { M as r } from "./main-bd31ea48.js";
+import { d as f, O as T, S as _, T as h, b as A, a as O, c as b, h as L } from "./main-bd31ea48.js";
 import t from "node:path";
-import { existsSync as n } from "node:fs";
+import { existsSync as m } from "node:fs";
 import "@done-coding/cli-utils";
 import "lodash.template";
 import "lodash.assign";
-const u = ({
-  rootDir: e,
-  configPath: o = r
+const E = ({
+  rootDir: a,
+  configPath: e = r
 }) => {
-  const a = t.resolve(e, o);
-  if (n(a))
-    return a;
+  const o = t.resolve(a, e);
+  if (m(o))
+    return o;
 };
 export {
+  f as MODULE_CONFIG_RELATIVE_PATH,
   r as MODULE_DEFAULT_CONFIG_RELATIVE_PATH,
-  E as OutputModeEnum,
-  h as SubcommandEnum,
-  b as TemplateBindKeyEnum,
-  T as batchCompileHandler,
-  A as compileHandler,
-  H as crateAsSubcommand,
-  u as getConfigPath,
-  O as handler,
-  S as initHandler
+  T as OutputModeEnum,
+  _ as SubcommandEnum,
+  h as TemplateBindKeyEnum,
+  A as batchCompileHandler,
+  O as compileHandler,
+  b as crateAsSubcommand,
+  E as getConfigPath,
+  L as handler
 };

package/es/main-bd31ea48.js

@@ -0,0 +1,482 @@
+#!/usr/bin/env node
+import y from "node:path";
+import p from "node:fs";
+import { log as a, xPrompts as A, getConfigFileCommonOptions as P, getUseDefaultConfig as V, initHandlerCommon as W, readConfigFile as G, createSubcommand as S, getRootScriptName as J, createMainCommand as K } from "@done-coding/cli-utils";
+import L from "lodash.template";
+import q from "lodash.assign";
+const N = {
+  name: "@done-coding/cli-template",
+  version: "0.8.0-alpha.0",
+  description: "预编译命令行工具",
+  bin: {
+    "dc-template": "es/cli.mjs"
+  },
+  cliConfig: {
+    namespaceDir: ".done-coding",
+    moduleName: "template"
+  }
+}, {
+  cliConfig: { namespaceDir: z, moduleName: Z }
+} = N, Q = `./${z}/${Z}`, _ = `${Q}.json`, w = (t, n) => {
+  if (!n)
+    return a.error(`${t}模式下output不能为空`), process.exit(1);
+}, k = (t, n) => {
+  if (n && t === n)
+    return a.error("output与input不能相同"), process.exit(1);
+}, X = (t, n) => {
+  if (!n)
+    return a.error(`${t}模式下input不能为空`), process.exit(1);
+}, F = ({
+  rootDir: t,
+  filePath: n,
+  dataInit: s,
+  limitJson: u,
+  filePathKey: c,
+  dataInitKey: r,
+  dealMarkdown: i = !1
+}) => {
+  if (n) {
+    if (u && !n.endsWith(".json"))
+      return a.error(`${c}必须是json文件，请检查文件后缀名`), process.exit(1);
+    const o = p.readFileSync(
+      y.resolve(t, n),
+      "utf-8"
+    );
+    let $ = o;
+    return i && n.endsWith(".md") && ($ = o.replace(
+      /^\s*```[a-zA-Z0-9]+\s*[\r\n]+([\s\S]+?)```\s*$/,
+      "$1"
+    )), u ? JSON.parse($) : $;
+  } else
+    return s ? (a.info(`${c} 为空，将使用${r}作为数据`), u ? JSON.parse(s) : s) : (a.error(`${c}与${r}不能同时为空`), process.exit(1));
+};
+var R = /* @__PURE__ */ ((t) => (t.INIT = "init", t.COMPILE = "compile", t.BATCH = "batch", t))(R || {}), ee = /* @__PURE__ */ ((t) => (t.REPOSITORY_URL = "REPOSITORY_URL", t))(ee || {}), d = /* @__PURE__ */ ((t) => (t.OVERWRITE = "overwrite", t.APPEND = "append", t.REPLACE = "replace", t.RETURN = "return", t))(d || {});
+const x = async (t, { rootDir: n, rollback: s }) => {
+  const {
+    env: u,
+    input: c,
+    inputData: r,
+    output: i,
+    mode: o,
+    rollbackDelNullFile: $,
+    rollbackDelAskAsYes: C,
+    dealMarkdown: D,
+    envData: E
+  } = t;
+  if (s)
+    switch (o) {
+      case d.REPLACE:
+      case d.RETURN: {
+        a.error(`${o}模式不支持回滚`);
+        return;
+      }
+    }
+  a.stage(`开始处理模板
+mode: ${o}
+rollback: ${s}
+`);
+  const h = F({
+    rootDir: n,
+    filePath: c,
+    dataInit: r,
+    limitJson: !1,
+    filePathKey: "input",
+    dataInitKey: "inputData",
+    dealMarkdown: D
+  }), g = L(h), v = typeof E == "function" ? E() : E, l = g(v);
+  switch (o) {
+    case d.OVERWRITE: {
+      w(o, i), k(i, c);
+      const e = y.resolve(n, i);
+      if (p.mkdirSync(y.dirname(e), { recursive: !0 }), p.existsSync(e)) {
+        if (s)
+          if (C || (await A({
+            type: "confirm",
+            name: "remove",
+            message: `${o}模式下回滚将删除${e}，是否继续？`
+          })).remove) {
+            p.rmSync(e, { force: !0 }), a.success(`${o}模式下${e}已删除`);
+            return;
+          } else {
+            a.warn(`${o}模式下${e}回滚取消`);
+            return;
+          }
+        a.info(`output:${e} 已存在，将覆盖`);
+      } else {
+        if (s) {
+          a.warn(`${o}模式下${e}不存在，无需回滚`);
+          return;
+        }
+        a.stage(`output:${e} 不存在，将创建`);
+      }
+      p.writeFileSync(e, l, "utf-8"), a.success(`模板处理完成，输出到 ${e}`);
+      break;
+    }
+    case d.APPEND: {
+      w(o, i), k(i, c);
+      const e = y.resolve(n, i);
+      if (p.mkdirSync(y.dirname(e), { recursive: !0 }), p.existsSync(e)) {
+        const m = p.readFileSync(e, "utf-8");
+        if (s) {
+          const b = m.replace(l, "");
+          b || !$ ? p.writeFileSync(e, b, "utf-8") : (a.stage(`${o}模式下 文件为空 删除`), p.unlinkSync(e)), a.success(`${o}模式下${e}回滚完成`);
+          return;
+        }
+        const f = m + l;
+        p.writeFileSync(e, f, "utf-8"), a.success(`模板处理完成，追加到 ${e}`);
+      } else {
+        if (s) {
+          a.warn(`${o}模式下${e}不存在，无需回滚`);
+          return;
+        }
+        a.stage(`output:${e} 不存在，将创建`), p.writeFileSync(e, l, "utf-8"), a.success(`模板处理完成，输出到 ${e}`);
+      }
+      break;
+    }
+    case d.REPLACE: {
+      if (i && a.warn(`output ${i} 将被忽略`), X(o, c), u && u === c)
+        return a.error("env 与 input 不能相同"), process.exit(1);
+      const e = y.resolve(n, c);
+      let m = e;
+      const f = L(e)(v);
+      f !== e && (a.success(`检测输入文件名也需要替换
+            ${e} => ${f}`), p.rmSync(e), m = f), p.mkdirSync(y.dirname(m), { recursive: !0 }), p.writeFileSync(m, l, "utf-8"), a.success(`模板处理完成，输出到 ${m}`);
+      break;
+    }
+    case d.RETURN:
+      return a.success("模板处理完成，返回结果(函数调用才会拿到返回值)"), l;
+    default:
+      return a.error(`mode ${o} 不支持`), process.exit(1);
+  }
+  return l;
+}, te = {
+  globalEnvData: {},
+  collectEnvDataForm: [
+    {
+      key: "name",
+      label: "项目名"
+    },
+    {
+      key: "chineseName",
+      label: "项目中文名"
+    },
+    {
+      key: "description",
+      label: "描述",
+      initial: "这是一个描述"
+    },
+    {
+      key: "repositoryUrl",
+      label: "仓库地址",
+      initial: "",
+      bindKey: "REPOSITORY_URL"
+    }
+  ],
+  list: [
+    {
+      input: "./package.json",
+      output: "./package.json",
+      mode: "replace"
+    },
+    {
+      input: "./README.md",
+      output: "./README.md",
+      mode: "replace"
+    }
+  ]
+}, ne = () => P({
+  configPathDefault: _
+}), ae = async (t) => {
+  let n = {};
+  if (t)
+    n = te;
+  else {
+    const { globalEnvCount: s, collectEnvCount: u, compileFileCount: c } = await A([
+      {
+        name: "globalEnvCount",
+        type: "number",
+        message: "全局固定变量数量",
+        initial: 1,
+        format: (r) => Number(r) || 0,
+        validate: (r) => r >= 0
+      },
+      {
+        name: "collectEnvCount",
+        type: "number",
+        message: "采集变量数量",
+        initial: 1,
+        format: (r) => Number(r) || 0,
+        validate: (r) => r >= 0
+      },
+      {
+        name: "compileFileCount",
+        type: "number",
+        message: "预编译文件数量",
+        initial: 1,
+        format: (r) => Number(r) || 0,
+        validate: (r) => r >= 0
+      }
+    ]);
+    s && (n.globalEnvData = Array.from({
+      length: s
+    }).reduce((r, i, o) => (r[`GLOBAL_${o}`] = "", r), {})), u && (n.collectEnvDataForm = Array.from({
+      length: u
+    }).map((r, i) => ({
+      key: `COLLECT_KEY_${i}`,
+      label: `COLLECT_LABEL_${i}`,
+      initial: void 0
+    }))), c && (n.list = Array.from({
+      length: c
+    }).map((r, i) => ({
+      input: `(相对于命令运行目录)需要编译的模板文件路径${i}`,
+      output: `(相对于命令运行目录)编译后输出的文件路径${i}`,
+      mode: d.REPLACE
+    })));
+  }
+  return n;
+}, U = async (t) => {
+  const n = await V(), s = await ae(n);
+  await W(s, t, {
+    edit: !0,
+    onFileGenerated(u) {
+      n || a.success(`配置文件已生成：${u}
+        请具体需要替换
+        globalEnvData中的 GLOBAL_\${index}及其对应值
+        collectEnvDataForm各项中 COLLECT_KEY_\${index} COLLECT_LABEL_\${index}
+        list各项中的 input值 output值
+    `);
+    }
+  });
+}, oe = {
+  command: R.INIT,
+  describe: "初始化配置文件",
+  options: ne(),
+  handler: U
+}, I = () => ({
+  ...P({
+    configPathDefault: _
+  }),
+  rollbackDelAskAsYes: {
+    describe: "回滚删除询问默认yes(即不再额外询问，直接认为同意)",
+    type: "boolean",
+    default: !1
+  },
+  rollbackDelNullFile: {
+    describe: "回滚时是否删除空文件",
+    type: "boolean",
+    default: !1
+  },
+  dealMarkdown: {
+    alias: "d",
+    describe: "(检测是markdown)是否处理(单个)代码块包裹",
+    type: "boolean",
+    default: !1
+  },
+  rollback: {
+    alias: "r",
+    describe: "是否回滚",
+    type: "boolean",
+    default: !1
+  }
+}), O = async ({
+  extraEnvData: t = {},
+  ...n
+}, s) => {
+  var v;
+  const u = I(), {
+    rootDir: c = u.rootDir.default,
+    configPath: r = (v = u.configPath) == null ? void 0 : v.default,
+    rollback: i
+  } = n;
+  let o;
+  if (s ? o = s : o = await G({
+    rootDir: c,
+    configPath: r
+  }), !o)
+    return a.error("读取配置文件失败"), process.exit(1);
+  const {
+    list: $ = [],
+    globalEnvData: C = {},
+    collectEnvDataForm: D = []
+  } = o, E = {};
+  for (const l of D) {
+    let e, m, f;
+    typeof l == "string" ? (e = l, m = l, f = void 0) : (e = l.key, m = l.label, f = l.initial), E[e] = (await A({
+      type: "text",
+      name: e,
+      message: `请输入${m}`,
+      initial: f,
+      format: (b) => b.trim(),
+      validate: (b) => b.length > 0 || `${m}不能为空`
+    }))[e];
+  }
+  const h = $.map((l) => {
+    const { envData: e, env: m, input: f, output: b, ...H } = l;
+    return m && a.warn(`批量处理中 env:${m} 将被忽略, 只读envData`), {
+      ...H,
+      env: m,
+      input: f,
+      output: b,
+      envData: q(
+        {},
+        t,
+        C,
+        E,
+        e
+      ),
+      rollback: i
+    };
+  }), g = [];
+  for (const l of h) {
+    const e = await x(l, {
+      rootDir: c,
+      rollback: i
+    });
+    g.push(e);
+  }
+  return g;
+}, re = {
+  command: R.BATCH,
+  describe: "批量编译模板",
+  options: I(),
+  handler: O
+}, M = () => ({
+  env: {
+    alias: "e",
+    describe: "环境数据文件JSON文件相对路径(优先级高于envData)",
+    type: "string"
+  },
+  envData: {
+    alias: "E",
+    describe: "环境变量数据(JSON字符串)",
+    type: "string"
+  },
+  input: {
+    alias: "i",
+    describe: "模板文件相对路径(优先级高于inputTemplate)",
+    type: "string"
+  },
+  inputData: {
+    alias: "I",
+    describe: "模板数据",
+    type: "string"
+  },
+  output: {
+    alias: "o",
+    describe: "输出文件路径",
+    type: "string"
+  },
+  mode: {
+    alias: "m",
+    describe: "输出模式",
+    type: "string",
+    choices: [
+      d.OVERWRITE,
+      d.APPEND,
+      d.REPLACE,
+      d.RETURN
+    ],
+    default: d.OVERWRITE
+  },
+  batch: {
+    alias: "b",
+    describe: "是否批量处理",
+    type: "boolean",
+    default: !1
+  },
+  ...I()
+}), Y = async (t) => {
+  const n = M(), {
+    envData: s,
+    env: u,
+    input: c,
+    inputData: r,
+    output: i,
+    mode: o = n.mode.default,
+    batch: $,
+    ...C
+  } = t, {
+    rootDir: D = n.rootDir.default,
+    rollbackDelNullFile: E,
+    rollbackDelAskAsYes: h,
+    dealMarkdown: g,
+    rollback: v
+  } = C;
+  if ($)
+    return a.stage("开始批量处理"), O(C);
+  a.stage("开始单个处理");
+  const l = F({
+    rootDir: D,
+    filePath: u,
+    dataInit: s,
+    limitJson: !0,
+    filePathKey: "env",
+    dataInitKey: "envData",
+    dealMarkdown: g
+  });
+  return x(
+    {
+      input: c,
+      inputData: r,
+      output: i,
+      mode: o,
+      rollbackDelNullFile: E,
+      rollbackDelAskAsYes: h,
+      dealMarkdown: g,
+      envData: l
+    },
+    {
+      rootDir: D,
+      rollback: v
+    }
+  );
+}, se = {
+  command: "$0",
+  describe: "编译模板",
+  options: M(),
+  handler: Y
+}, fe = async (t, n) => {
+  switch (t) {
+    case R.INIT:
+      return U(n);
+    case R.COMPILE:
+      return Y(n);
+    case R.BATCH:
+      return O(n);
+    default:
+      throw new Error(`不支持的命令 ${t}`);
+  }
+}, { version: ie, description: le } = N, j = {
+  describe: le,
+  version: ie,
+  subcommands: [
+    oe,
+    se,
+    re
+  ].map(S),
+  demandCommandCount: 1,
+  rootScriptName: J({ packageJson: N })
+}, {
+  cliConfig: { moduleName: T }
+} = N, B = (t = !1) => {
+  const n = t ? T : void 0, s = `$0${t ? ` ${T}` : ""} <command> [options]`;
+  return { command: n, usage: s };
+}, $e = async () => K({
+  ...j,
+  ...B()
+}), Ee = () => S({
+  ...j,
+  ...B(!0)
+});
+export {
+  _ as M,
+  d as O,
+  R as S,
+  ee as T,
+  Y as a,
+  O as b,
+  Ee as c,
+  Q as d,
+  $e as e,
+  fe as h
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "done-coding-template",
-  "version": "0.7.11",
+  "version": "0.8.0-alpha.0",
   "description": "预编译命令行工具",
   "private": false,
   "module": "es/index.mjs",
@@ -30,7 +30,7 @@
   "license": "MIT",
   "sideEffects": false,
   "devDependencies": {
-    "@done-coding/cli-inject": "^0.5.11",
+    "@done-coding/cli-inject": "^0.5.13-alpha.0",
     "@types/lodash.assign": "^4.2.9",
     "@types/lodash.template": "^4.5.3",
     "@types/node": "^18.0.0",
@@ -44,10 +44,10 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@done-coding/cli-utils": "^0.7.2",
+    "@done-coding/cli-utils": "^0.7.4-alpha.0",
     "lodash.assign": "^4.2.0",
     "lodash.template": "^4.5.0"
   },
-  "gitHead": "ad322da7f5d0897ee91a399aff9a14b111d62825",
+  "gitHead": "a1acffae69586b12aec17d0ad76d6f75ad1d0ca0",
   "scripts": {}
 }

package/types/index.d.ts

@@ -4,16 +4,10 @@ import type { InitConfigFileOptions } from '@done-coding/cli-utils';
 import type { ReadConfigFileOptions } from '@done-coding/cli-utils';
 
 /** 批量编译模板 */
-export declare const batchCompileHandler: ({ rootDir, configPath, itemDefaultRollback, extraEnvData, }: {
-    /** 项目更目录 */
-    rootDir: string;
-    /** 配置文件路径 */
-    configPath?: string | undefined;
-    /** item默认回滚? */
-    itemDefaultRollback?: boolean | undefined;
-    /** 额外环境变量 */
+export declare const batchCompileHandler: ({ extraEnvData, ...args }: CliHandlerArgv<CompileBatchOptions & {
+    /** 额外的环境变量 */
     extraEnvData?: object | undefined;
-}, paramsConfig?: CompileTemplateConfig) => Promise<(string | undefined)[]>;
+}>, paramsConfig?: CompileTemplateConfig) => Promise<(string | undefined)[]>;
 
 /** 采集环境变量配置 */
 export declare interface CollectFormItem {
@@ -27,38 +21,45 @@ export declare interface CollectFormItem {
     bindKey?: TemplateBindKeyEnum;
 }
 
+/** 批量模板编译配置项 */
+export declare interface CompileBatchOptions extends CompilePublicConfig {
+}
+
 /** 编译模板 */
 export declare const compileHandler: (argv: CliHandlerArgv<CompileOptions>) => Promise<string | (string | undefined)[] | undefined>;
 
-export declare interface CompileOptions {
+/** 编译模板配置项 */
+export declare interface CompileOptions extends CompilePublicConfig, CompileTemplateConfigListItemRaw {
+    /**
+     * 是否批量处理
+     * --
+     * 为true 走批量编译，此时configPath为批量编译配置文件路径 且必须
+     */
+    batch?: boolean;
+}
+
+/** 编译公共选项 */
+export declare interface CompilePublicConfig {
     /** 项目根目录 */
     rootDir: string;
-    /** 配置文件路径 */
+    /**
+     * 配置文件路径
+     * ---
+     * 不传拿默认值
+     */
     configPath?: string;
-    /** 环境数据(json)文件(优先级高于 envData ) */
-    env?: string;
-    /** 环境变量数据(JSON字符串) */
-    envData?: string;
-    /** 模板文件相对路径(优先级高于 inputData ) */
-    input?: string;
-    /** 模板数据 */
-    inputData?: string;
-    /** 输出文件相对路径 */
-    output?: string;
-    /** 输出模式 @default OutputModeEnum.OVERWRITE */
-    mode: OutputModeEnum;
-    /** 是否回滚 @default false */
-    rollback?: boolean;
     /**
      * 回滚删除空文件
      * ---
      * 只限 OutputModeEnum.APPEND 模式下生效
      */
     rollbackDelNullFile?: boolean;
+    /** 回滚删除询问默认yes(即不再额外询问，直接认为同意) */
+    rollbackDelAskAsYes?: boolean;
     /** (检测是markdown)是否处理(单个)代码块包裹 */
     dealMarkdown?: boolean;
-    /** 是否批量处理 */
-    batch?: boolean;
+    /** 是否回滚 */
+    rollback?: boolean;
 }
 
 /** 编译模板配置 */
@@ -68,31 +69,46 @@ export declare interface CompileTemplateConfig {
     /** 采集环境变量表单配置 */
     collectEnvDataForm?: (CollectFormItem | string)[];
     /** 配置列表 */
-    list?: Omit<CompileOptions, keyof ReadConfigFileOptions>[];
+    list?: CompileTemplateConfigListItemRaw[];
 }
 
 /**
  * 编译模板配置选项
  */
-export declare type CompileTemplateConfigListItem = Omit<CompileOptions, "envData" | keyof ReadConfigFileOptions> & {
+export declare type CompileTemplateConfigListItem = Omit<CompileTemplateConfigListItemRaw & Omit<CompilePublicConfig, keyof ReadConfigFileOptions>, "envData" | "rollback"> & {
     /** 已经解析为对象的envData */
     envData: Record<string, any>;
 };
 
+/** 编译模板配置项(原始的) */
+export declare interface CompileTemplateConfigListItemRaw {
+    /** 环境数据(json)文件(优先级高于 envData ) */
+    env?: string;
+    /** 环境变量数据(JSON字符串) */
+    envData?: string;
+    /** 模板文件相对路径(优先级高于 inputData ) */
+    input?: string;
+    /** 模板数据(JSON字符串) */
+    inputData?: string;
+    /** 输出文件相对路径 */
+    output?: string;
+    /** 输出模式 @default OutputModeEnum.OVERWRITE */
+    mode: OutputModeEnum;
+}
+
 /** 作为子命令创建 */
 export declare const crateAsSubcommand: () => CommandModule<{}, {}>;
 
 /** 获取配置文件路径 */
 export declare const getConfigPath: ({ rootDir, configPath, }: ReadConfigFileOptions) => string | undefined;
 
-/** 命令处理函数 */
-export declare const handler: (command: SubcommandEnum, argv: CliHandlerArgv<InitOptions | CompileOptions>) => Promise<string | void | (string | undefined)[]>;
-
-/** 初始化模板 */
-export declare const initHandler: (argv: CliHandlerArgv<InitOptions>) => Promise<void>;
+export declare const handler: (command: SubcommandEnum, argv: CliHandlerArgv<any>) => Promise<string | void | (string | undefined)[]>;
 
 export declare type InitOptions = InitConfigFileOptions;
 
+/** 模块配置相对路径 */
+export declare const MODULE_CONFIG_RELATIVE_PATH: string;
+
 /** 模块默认配置文件相对路径 */
 export declare const MODULE_DEFAULT_CONFIG_RELATIVE_PATH: string;
 
@@ -113,7 +129,9 @@ export declare enum SubcommandEnum {
     /** 初始化模板 */
     INIT = "init",
     /** 编译模板 */
-    COMPILE = "compile"
+    COMPILE = "compile",
+    /** 批量编译模板 */
+    BATCH = "batch"
 }
 
 /** 绑定的关键变量枚举 */

package/es/main-3510f696.js

@@ -1,489 +0,0 @@
-#!/usr/bin/env node
-import { getConfigFileCommonOptions as N, getUseDefaultConfig as V, initHandlerCommon as W, log as a, xPrompts as R, readConfigFile as G, _curry as T, createSubcommand as A, createMainCommand as Y } from "@done-coding/cli-utils";
-import k from "node:path";
-import f from "node:fs";
-import O from "lodash.template";
-import B from "lodash.assign";
-var I = /* @__PURE__ */ ((e) => (e.INIT = "init", e.COMPILE = "compile", e))(I || {}), J = /* @__PURE__ */ ((e) => (e.REPOSITORY_URL = "REPOSITORY_URL", e))(J || {}), b = /* @__PURE__ */ ((e) => (e.OVERWRITE = "overwrite", e.APPEND = "append", e.REPLACE = "replace", e.RETURN = "return", e))(b || {});
-const _ = {
-  name: "@done-coding/cli-template",
-  version: "0.7.11",
-  description: "预编译命令行工具",
-  cliConfig: {
-    namespaceDir: ".done-coding",
-    moduleName: "template"
-  }
-}, {
-  cliConfig: { namespaceDir: K, moduleName: q }
-} = _, z = `./${K}/${q}`, h = `${z}.json`, v = {
-  rollback: !1,
-  dealMarkdown: !1,
-  mode: b.OVERWRITE,
-  batch: !1,
-  rollbackDelNullFile: !1
-}, S = (e) => {
-  const {
-    rollback: t,
-    dealMarkdown: l,
-    mode: c,
-    batch: s,
-    rootDir: o,
-    configPath: i,
-    rollbackDelNullFile: r,
-    ...u
-  } = e, { rootDir: g, configPath: D } = N({
-    configPathDefault: h
-  });
-  return {
-    rollback: t ?? v.rollback,
-    rollbackDelNullFile: r ?? v.rollbackDelNullFile,
-    dealMarkdown: l ?? v.dealMarkdown,
-    mode: c ?? v.mode,
-    batch: s ?? v.batch,
-    rootDir: o ?? g.default,
-    configPath: i ?? D.default,
-    ...u
-  };
-}, Z = () => ({
-  env: {
-    alias: "e",
-    describe: "环境数据文件JSON文件相对路径(优先级高于envData)",
-    type: "string"
-  },
-  envData: {
-    alias: "E",
-    describe: "环境变量数据(JSON字符串)",
-    type: "string"
-  },
-  input: {
-    alias: "i",
-    describe: "模板文件相对路径(优先级高于inputTemplate)",
-    type: "string"
-  },
-  inputData: {
-    alias: "I",
-    describe: "模板数据",
-    type: "string"
-  },
-  mode: {
-    alias: "m",
-    describe: "输出模式",
-    type: "string",
-    choices: [
-      b.OVERWRITE,
-      b.APPEND,
-      b.REPLACE,
-      b.RETURN
-    ],
-    default: v.mode
-  },
-  output: {
-    alias: "o",
-    describe: "输出文件路径",
-    type: "string"
-  },
-  rollback: {
-    alias: "r",
-    describe: "是否回滚",
-    type: "boolean",
-    default: v.rollback
-  },
-  dealMarkdown: {
-    alias: "d",
-    describe: "(检测是markdown)是否处理(单个)代码块包裹",
-    type: "boolean",
-    default: v.dealMarkdown
-  },
-  batch: {
-    alias: "b",
-    describe: "是否批量处理",
-    type: "boolean",
-    default: v.batch
-  },
-  ...N({
-    configPathDefault: h
-  })
-}), Q = {
-  globalEnvData: {},
-  collectEnvDataForm: [
-    {
-      key: "name",
-      label: "项目名"
-    },
-    {
-      key: "chineseName",
-      label: "项目中文名"
-    },
-    {
-      key: "description",
-      label: "描述",
-      initial: "这是一个描述"
-    },
-    {
-      key: "repositoryUrl",
-      label: "仓库地址",
-      initial: "",
-      bindKey: "REPOSITORY_URL"
-    }
-  ],
-  list: [
-    {
-      input: "./package.json",
-      output: "./package.json",
-      mode: "replace"
-    },
-    {
-      input: "./README.md",
-      output: "./README.md",
-      mode: "replace"
-    }
-  ]
-}, X = () => N({
-  configPathDefault: h
-}), ee = async (e) => {
-  let t = {};
-  if (e)
-    t = Q;
-  else {
-    const { globalEnvCount: l, collectEnvCount: c, compileFileCount: s } = await R([
-      {
-        name: "globalEnvCount",
-        type: "number",
-        message: "全局固定变量数量",
-        initial: 1,
-        format: (o) => Number(o) || 0,
-        validate: (o) => o >= 0
-      },
-      {
-        name: "collectEnvCount",
-        type: "number",
-        message: "采集变量数量",
-        initial: 1,
-        format: (o) => Number(o) || 0,
-        validate: (o) => o >= 0
-      },
-      {
-        name: "compileFileCount",
-        type: "number",
-        message: "预编译文件数量",
-        initial: 1,
-        format: (o) => Number(o) || 0,
-        validate: (o) => o >= 0
-      }
-    ]);
-    l && (t.globalEnvData = Array.from({
-      length: l
-    }).reduce((o, i, r) => (o[`GLOBAL_${r}`] = "", o), {})), c && (t.collectEnvDataForm = Array.from({
-      length: c
-    }).map((o, i) => ({
-      key: `COLLECT_KEY_${i}`,
-      label: `COLLECT_LABEL_${i}`,
-      initial: void 0
-    }))), s && (t.list = Array.from({
-      length: s
-    }).map((o, i) => ({
-      input: `(相对于命令运行目录)需要编译的模板文件路径${i}`,
-      output: `(相对于命令运行目录)编译后输出的文件路径${i}`,
-      mode: b.REPLACE
-    })));
-  }
-  return t;
-}, te = async (e) => {
-  const t = await V(), l = await ee(t);
-  await W(l, e, {
-    edit: !0,
-    onFileGenerated(c) {
-      t || a.success(`配置文件已生成：${c}
-        请具体需要替换
-        globalEnvData中的 GLOBAL_\${index}及其对应值
-        collectEnvDataForm各项中 COLLECT_KEY_\${index} COLLECT_LABEL_\${index}
-        list各项中的 input值 output值
-    `);
-    }
-  });
-}, x = ({
-  rootDir: e,
-  filePath: t,
-  dataInit: l,
-  limitJson: c,
-  filePathKey: s,
-  dataInitKey: o,
-  dealMarkdown: i = !1
-}) => {
-  if (t) {
-    if (c && !t.endsWith(".json"))
-      return a.error(`${s}必须是json文件，请检查文件后缀名`), process.exit(1);
-    const r = f.readFileSync(
-      k.resolve(e, t),
-      "utf-8"
-    );
-    let u = r;
-    return i && t.endsWith(".md") && (u = r.replace(
-      /^\s*```[a-zA-Z0-9]+\s*[\r\n]+([\s\S]+?)```\s*$/,
-      "$1"
-    )), c ? JSON.parse(u) : u;
-  } else
-    return l ? (a.info(`${s} 为空，将使用${o}作为数据`), c ? JSON.parse(l) : l) : (a.error(`${s}与${o}不能同时为空`), process.exit(1));
-}, P = (e, t) => {
-  if (!t)
-    return a.error(`${e}模式下output不能为空`), process.exit(1);
-}, w = (e, t) => {
-  if (t && e === t)
-    return a.error("output与input不能相同"), process.exit(1);
-}, ne = (e, t) => {
-  if (!t)
-    return a.error(`${e}模式下input不能为空`), process.exit(1);
-}, M = async (e, {
-  rootDir: t,
-  rollbackDelFileAgree: l = !1
-}) => {
-  const {
-    env: c,
-    input: s,
-    inputData: o,
-    output: i,
-    mode: r,
-    rollback: u,
-    rollbackDelNullFile: g,
-    dealMarkdown: D,
-    envData: E
-  } = e;
-  if (u)
-    switch (r) {
-      case b.REPLACE:
-      case b.RETURN: {
-        a.error(`${r}模式不支持回滚`);
-        return;
-      }
-    }
-  a.stage(`开始处理模板
-mode: ${r}
-rollback: ${u}
-`);
-  const m = x({
-    rootDir: t,
-    filePath: s,
-    dataInit: o,
-    limitJson: !1,
-    filePathKey: "input",
-    dataInitKey: "inputData",
-    dealMarkdown: D
-  }), d = O(m), C = typeof E == "function" ? E() : E, p = d(C);
-  switch (r) {
-    case b.OVERWRITE: {
-      P(r, i), w(i, s);
-      const n = k.resolve(t, i);
-      if (f.mkdirSync(k.dirname(n), { recursive: !0 }), f.existsSync(n)) {
-        if (u)
-          if (l || (await R({
-            type: "confirm",
-            name: "remove",
-            message: `${r}模式下回滚将删除${n}，是否继续？`
-          })).remove) {
-            f.rmSync(n, { force: !0 }), a.success(`${r}模式下${n}已删除`);
-            return;
-          } else {
-            a.warn(`${r}模式下${n}回滚取消`);
-            return;
-          }
-        a.info(`output:${n} 已存在，将覆盖`);
-      } else {
-        if (u) {
-          a.warn(`${r}模式下${n}不存在，无需回滚`);
-          return;
-        }
-        a.stage(`output:${n} 不存在，将创建`);
-      }
-      f.writeFileSync(n, p, "utf-8"), a.success(`模板处理完成，输出到 ${n}`);
-      break;
-    }
-    case b.APPEND: {
-      P(r, i), w(i, s);
-      const n = k.resolve(t, i);
-      if (f.mkdirSync(k.dirname(n), { recursive: !0 }), f.existsSync(n)) {
-        const $ = f.readFileSync(n, "utf-8");
-        if (u) {
-          const L = $.replace(p, "");
-          L || !g ? f.writeFileSync(n, L, "utf-8") : (a.stage(`${r}模式下 文件为空 删除`), f.unlinkSync(n)), a.success(`${r}模式下${n}回滚完成`);
-          return;
-        }
-        const y = $ + p;
-        f.writeFileSync(n, y, "utf-8"), a.success(`模板处理完成，追加到 ${n}`);
-      } else {
-        if (u) {
-          a.warn(`${r}模式下${n}不存在，无需回滚`);
-          return;
-        }
-        a.stage(`output:${n} 不存在，将创建`), f.writeFileSync(n, p, "utf-8"), a.success(`模板处理完成，输出到 ${n}`);
-      }
-      break;
-    }
-    case b.REPLACE: {
-      if (i && a.warn(`output ${i} 将被忽略`), ne(r, s), c && c === s)
-        return a.error("env 与 input 不能相同"), process.exit(1);
-      const n = k.resolve(t, s);
-      let $ = n;
-      const y = O(n)(C);
-      y !== n && (a.success(`检测输入文件名也需要替换
-            ${n} => ${y}`), f.rmSync(n), $ = y), f.mkdirSync(k.dirname($), { recursive: !0 }), f.writeFileSync($, p, "utf-8"), a.success(`模板处理完成，输出到 ${$}`);
-      break;
-    }
-    case b.RETURN:
-      return a.success("模板处理完成，返回结果(函数调用才会拿到返回值)"), p;
-    default:
-      return a.error(`mode ${r} 不支持`), process.exit(1);
-  }
-  return p;
-}, ae = async ({
-  rootDir: e,
-  configPath: t = h,
-  itemDefaultRollback: l = !1,
-  extraEnvData: c = {}
-}, s) => {
-  let o;
-  if (s ? o = s : o = await G({
-    rootDir: e,
-    configPath: t
-  }), !o)
-    return a.error("读取配置文件失败"), process.exit(1);
-  const {
-    list: i = [],
-    globalEnvData: r = {},
-    collectEnvDataForm: u = []
-  } = o, g = {};
-  for (const m of u) {
-    let d, C, p;
-    typeof m == "string" ? (d = m, C = m, p = void 0) : (d = m.key, C = m.label, p = m.initial), g[d] = (await R({
-      type: "text",
-      name: d,
-      message: `请输入${C}`,
-      initial: p,
-      format: (n) => n.trim(),
-      validate: (n) => n.length > 0 || `${C}不能为空`
-    }))[d];
-  }
-  const D = i.map((m) => {
-    const { rollback: d = l } = m, {
-      envData: C,
-      env: p,
-      input: n,
-      output: $,
-      ...y
-    } = S(m);
-    return p && a.warn(`批量处理中 env:${p} 将被忽略, 只读envData`), {
-      ...y,
-      env: p,
-      input: n,
-      output: $,
-      envData: B(
-        {},
-        c,
-        r,
-        g,
-        C
-      ),
-      rollback: d
-    };
-  }), E = [];
-  for (const m of D) {
-    const d = await M(m, {
-      rollbackDelFileAgree: !0,
-      rootDir: e
-    });
-    E.push(d);
-  }
-  return E;
-}, oe = async (e) => {
-  const {
-    envData: t,
-    env: l,
-    input: c,
-    inputData: s,
-    output: o,
-    mode: i,
-    rollback: r,
-    rollbackDelNullFile: u,
-    dealMarkdown: g,
-    batch: D,
-    rootDir: E,
-    configPath: m
-  } = S(e);
-  if (D)
-    return a.stage("开始批量处理"), ae({
-      // 回滚默认值 基于全局
-      itemDefaultRollback: r,
-      rootDir: E,
-      configPath: m
-    });
-  a.stage("开始单个处理");
-  const d = x({
-    rootDir: E,
-    filePath: l,
-    dataInit: t,
-    limitJson: !0,
-    filePathKey: "env",
-    dataInitKey: "envData",
-    dealMarkdown: g
-  });
-  return M(
-    {
-      input: c,
-      inputData: s,
-      output: o,
-      mode: i,
-      rollback: r,
-      rollbackDelNullFile: u,
-      dealMarkdown: g,
-      envData: d
-    },
-    {
-      rootDir: E
-    }
-  );
-}, U = async (e, t) => e === I.INIT ? te(t) : e === I.COMPILE ? oe(t) : (a.error(`无效的命令: ${e}`), process.exit(1)), {
-  version: re,
-  description: ie,
-  cliConfig: { moduleName: F }
-} = _, se = {
-  command: I.INIT,
-  describe: "初始化模板配置文件",
-  options: X(),
-  handler: T(U)(
-    I.INIT
-  )
-}, le = {
-  command: I.COMPILE,
-  describe: "编译模板",
-  options: Z(),
-  handler: T(U)(
-    I.COMPILE
-  )
-}, j = {
-  describe: ie,
-  version: re,
-  subcommands: [se, le].map(
-    A
-  ),
-  demandCommandCount: 1
-}, H = (e = !1) => {
-  const t = e ? F : void 0, l = `$0${e ? ` ${F}` : ""} <command> [options]`;
-  return { command: t, usage: l };
-}, de = async () => Y({
-  ...j,
-  ...H()
-}), be = () => A({
-  ...j,
-  ...H(!0)
-});
-export {
-  h as M,
-  b as O,
-  I as S,
-  J as T,
-  be as a,
-  ae as b,
-  oe as c,
-  de as d,
-  U as h,
-  te as i
-};