@done-coding/cli-template 0.6.2-alpha.0 → 0.7.1-alpha.0

package/es/cli.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { c as r } from "./index-694fa5e1.js";
+import { c as m } from "./index-34359db9.js";
 import "node:path";
 import "node:fs";
+import "@done-coding/cli-utils";
+import "node:child_process";
 import "lodash.template";
 import "lodash.assign";
-import "@done-coding/cli-utils";
-import "yargs";
-import "yargs/helpers";
-r();
+import "lodash.curry";
+m();

package/es/index-34359db9.js

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

package/es/index.mjs

@@ -1,16 +1,21 @@
 #!/usr/bin/env node
-import { O as s, b as d, a as h, g as u, h as b } from "./index-694fa5e1.js";
+import { E as s, O as d, S as u, T as l, b as E, a as b, d as c, g as h, h as g, i as H } from "./index-34359db9.js";
 import "node:path";
 import "node:fs";
+import "@done-coding/cli-utils";
+import "node:child_process";
 import "lodash.template";
 import "lodash.assign";
-import "@done-coding/cli-utils";
-import "yargs";
-import "yargs/helpers";
+import "lodash.curry";
 export {
-  s as OutputModeEnum,
-  d as batchHandler,
-  h as command,
-  u as getConfigPath,
-  b as handler
+  s as EditorTypeEnum,
+  d as OutputModeEnum,
+  u as SubcommandEnum,
+  l as TemplateBindKeyEnum,
+  E as batchCompileHandler,
+  b as compileHandler,
+  c as crateAsSubcommand,
+  h as getConfigPath,
+  g as handler,
+  H as initHandler
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@done-coding/cli-template",
-  "version": "0.6.2-alpha.0",
+  "version": "0.7.1-alpha.0",
   "description": "预编译命令行工具",
   "private": false,
   "module": "es/index.mjs",
@@ -41,8 +41,9 @@
   "license": "MIT",
   "sideEffects": false,
   "devDependencies": {
-    "@done-coding/cli-inject": "^0.4.7-alpha.0",
+    "@done-coding/cli-inject": "^0.5.0-alpha.0",
     "@types/lodash.assign": "^4.2.9",
+    "@types/lodash.curry": "^4.1.8",
     "@types/lodash.get": "^4.4.9",
     "@types/lodash.set": "^4.3.9",
     "@types/lodash.template": "^4.5.3",
@@ -57,12 +58,12 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@done-coding/cli-utils": "^0.2.2-alpha.0",
+    "@done-coding/cli-utils": "^0.3.0-alpha.0",
     "lodash.assign": "^4.2.0",
+    "lodash.curry": "^4.1.1",
     "lodash.get": "^4.4.2",
     "lodash.set": "^4.3.2",
-    "lodash.template": "^4.5.0",
-    "yargs": "^17.7.2"
+    "lodash.template": "^4.5.0"
   },
-  "gitHead": "2e59e86ee192e023138e7475f4abbb5e7c42b29e"
+  "gitHead": "25909f1ffe943c46fdb40133e959c3fc684b023a"
 }

package/types/handler.d.ts

@@ -1,12 +1,5 @@
-import type { CompileTemplateConfig } from './utils';
-import { type Options } from './utils';
-import type { ArgumentsCamelCase } from "yargs";
-export declare const batchHandler: ({ rootDir, itemDefaultRollback, extraEnvData, }?: {
-    /** 根目录 */
-    rootDir?: string | undefined;
-    /** item默认回滚? */
-    itemDefaultRollback?: boolean | undefined;
-    /** 额外环境变量 */
-    extraEnvData?: object | undefined;
-}, paramsConfig?: CompileTemplateConfig) => Promise<(string | undefined)[]>;
-export declare const handler: (argv: ArgumentsCamelCase<Options> | Options) => Promise<string | (string | undefined)[] | undefined>;
+import type { CompileOptions, InitOptions } from './utils';
+import { SubcommandEnum } from './utils';
+import type { CliHandlerArgv } from "@done-coding/cli-utils";
+/** 命令处理函数 */
+export declare const handler: (command: SubcommandEnum, argv: CliHandlerArgv<InitOptions | CompileOptions>) => Promise<string | void | (string | undefined)[]>;

package/types/index.d.ts

@@ -1,4 +1,5 @@
-export { handler, batchHandler } from "./handler";
-export { command } from "./main";
+export { handler } from './handler';
+export { initHandler, compileHandler, batchCompileHandler } from './utils';
+export { crateAsSubcommand } from "./main";
 export * from './utils/types';
 export * from './utils/config';

package/types/injectInfo.json.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
-  "version": "0.6.2-alpha.0",
+  "version": "0.7.1-alpha.0",
   "name": "@done-coding/cli-template",
   "description": "预编译命令行工具",
   "cliConfig": {

package/types/json/template-default.json.d.ts

@@ -0,0 +1,38 @@
+declare const _default: {
+  "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"
+    }
+  ]
+};
+
+export default _default;

package/types/main.d.ts

@@ -1,4 +1,9 @@
-import type { CommandModule } from "yargs";
-import type { Options } from './utils';
-export declare const command: CommandModule<Options, Options>;
-export declare const createCli: () => Promise<string | (string | undefined)[] | undefined>;
+/// <reference types="yargs" />
+/** 作为主命令创建 */
+export declare const createCommand: () => Promise<void | {
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+}>;
+/** 作为子命令创建 */
+export declare const crateAsSubcommand: () => import("yargs").CommandModule<{}, {}>;

package/types/utils/compile.d.ts

@@ -0,0 +1,14 @@
+import type { CompileTemplateConfig } from '.';
+import { type CompileOptions } from '.';
+import type { CliHandlerArgv } from "@done-coding/cli-utils";
+/** 批量编译模板 */
+export declare const batchCompileHandler: ({ rootDir, itemDefaultRollback, extraEnvData, }?: {
+    /** 根目录 */
+    rootDir?: string | undefined;
+    /** item默认回滚? */
+    itemDefaultRollback?: boolean | undefined;
+    /** 额外环境变量 */
+    extraEnvData?: object | undefined;
+}, paramsConfig?: CompileTemplateConfig) => Promise<(string | undefined)[]>;
+/** 编译模板 */
+export declare const compileHandler: (argv: CliHandlerArgv<CompileOptions>) => Promise<string | (string | undefined)[] | undefined>;

package/types/utils/const.d.ts

@@ -0,0 +1,2 @@
+/** 配置文件默认相对路径 */
+export declare const CONFIG_RELATIVE_PATH_DEFAULT = "./.done-coding/template.json";

package/types/utils/dealOptions.d.ts

@@ -1,8 +1,8 @@
-import { OutputModeEnum, type Options } from "./types";
+import { OutputModeEnum, type CompileOptions } from "./types";
 /** 默认选项 */
-export declare const defaultOptions: Pick<Options, "rollback" | "dealMarkdown" | "mode" | "batch">;
+export declare const defaultOptions: Pick<CompileOptions, "rollback" | "dealMarkdown" | "mode" | "batch">;
 /** 设置默认选项 */
-export declare const completeDefaultOptions: <T extends Pick<Options, "mode" | "rollback" | "dealMarkdown" | "batch">>(options: T) => {
+export declare const completeDefaultOptions: <T extends Pick<CompileOptions, "mode" | "rollback" | "dealMarkdown" | "batch">>(options: T) => {
     rollback: boolean | undefined;
     dealMarkdown: boolean | undefined;
     mode: OutputModeEnum;

package/types/utils/index.d.ts

@@ -1,3 +1,6 @@
+export * from "./const";
 export * from "./types";
 export * from "./dealOptions";
 export * from "./config";
+export * from "./init";
+export * from "./compile";

package/types/utils/init.d.ts

@@ -0,0 +1,5 @@
+import { type InitOptions } from '.';
+import { type CliHandlerArgv } from "@done-coding/cli-utils";
+export declare const dispatchEditorCheckRes: (cmd: "cursor" | "code", path: string, onError: () => void) => void;
+/** 初始化模板 */
+export declare const initHandler: (argv: CliHandlerArgv<InitOptions>) => Promise<void>;

package/types/utils/types.d.ts

@@ -1,3 +1,30 @@
+/** 子命令枚举 */
+export declare enum SubcommandEnum {
+    /** 初始化模板 */
+    INIT = "init",
+    /** 编译模板 */
+    COMPILE = "compile"
+}
+export interface InitOptions {
+    /** 配置文件绝对路径 */
+    configPath: string;
+    /** 配置文件中编译文件相对目录运行根目录 */
+    rootDir: string;
+}
+/** 编辑器类型枚举 */
+export declare enum EditorTypeEnum {
+    /** vscode */
+    VSCODE = "VsCode",
+    /** cursor */
+    CURSOR = "Cursor",
+    /** 其他编辑器 */
+    OTHER = "\u5176\u4ED6"
+}
+/** 绑定的关键变量枚举 */
+export declare enum TemplateBindKeyEnum {
+    /** 远程仓库地址 */
+    REPOSITORY_URL = "REPOSITORY_URL"
+}
 /** 输出模式 */
 export declare enum OutputModeEnum {
     /** 覆盖模式 */
@@ -9,7 +36,7 @@ export declare enum OutputModeEnum {
     /** 返回模式--函数调用方式可用 */
     RETURN = "return"
 }
-export interface Options {
+export interface CompileOptions {
     /** 环境数据(json)文件(优先级高于 envData ) */
     env?: string;
     /** 环境变量数据(JSON字符串) */
@@ -30,7 +57,7 @@ export interface Options {
     batch?: boolean;
 }
 /** 编译模板配置选项 */
-export type CompileTemplateConfigListItem = Omit<Options, "envData"> & {
+export type CompileTemplateConfigListItem = Omit<CompileOptions, "envData"> & {
     /** 已经解析为对象的envData */
     envData: Record<string, any>;
 };
@@ -42,6 +69,8 @@ export interface CollectFormItem {
     label: string;
     /** 采集环境变量初始值 */
     initial?: string;
+    /** 绑定的关键变量 */
+    bindKey?: TemplateBindKeyEnum;
 }
 /** 编译模板配置 */
 export interface CompileTemplateConfig {
@@ -50,5 +79,5 @@ export interface CompileTemplateConfig {
     /** 采集环境变量表单配置 */
     collectEnvDataForm?: (CollectFormItem | string)[];
     /** 配置列表 */
-    list: CompileTemplateConfigListItem[];
+    list?: CompileOptions[];
 }

package/es/index-694fa5e1.js

@@ -1,340 +0,0 @@
-#!/usr/bin/env node
-import $ from "node:path";
-import l from "node:fs";
-import D from "lodash.template";
-import T from "lodash.assign";
-import { log as n, xPrompts as N } from "@done-coding/cli-utils";
-import A from "yargs";
-import { hideBin as U } from "yargs/helpers";
-var v = /* @__PURE__ */ ((e) => (e.OVERWRITE = "overwrite", e.APPEND = "append", e.REPLACE = "replace", e.RETURN = "return", e))(v || {});
-const g = {
-  rollback: !1,
-  dealMarkdown: !1,
-  mode: v.OVERWRITE,
-  batch: !1
-}, P = (e) => {
-  const { rollback: r, dealMarkdown: i, mode: s, batch: u, ...c } = e;
-  return {
-    rollback: r ?? g.rollback,
-    dealMarkdown: i ?? g.dealMarkdown,
-    mode: s ?? g.mode,
-    batch: u ?? g.batch,
-    ...c
-  };
-}, E = {
-  version: "0.6.2-alpha.0",
-  name: "@done-coding/cli-template",
-  description: "预编译命令行工具",
-  cliConfig: {
-    namespaceDir: ".done-coding",
-    moduleName: "template"
-  }
-}, W = (e) => {
-  const { namespaceDir: r, moduleName: i } = E.cliConfig, s = [r, `${i}.json`];
-  e && s.unshift(e);
-  const u = $.resolve(...s);
-  if (l.existsSync(u))
-    return u;
-}, C = ({
-  filePath: e,
-  dataInit: r,
-  limitJson: i,
-  filePathKey: s,
-  dataInitKey: u,
-  dealMarkdown: c = !1
-}) => {
-  if (e) {
-    if (i && !e.endsWith(".json"))
-      return n.error(`${s}必须是json文件，请检查文件后缀名`), process.exit(1);
-    const a = l.readFileSync($.resolve(e), "utf-8");
-    let p = a;
-    return c && e.endsWith(".md") && (p = a.replace(
-      /^\s*```[a-zA-Z0-9]+\s*[\r\n]+([\s\S]+?)```\s*$/,
-      "$1"
-    )), i ? JSON.parse(p) : p;
-  } else
-    return r ? (n.info(`${s} 为空，将使用${u}作为数据`), i ? JSON.parse(r) : r) : (n.error(`${s}与${u}不能同时为空`), process.exit(1));
-}, R = (e, r) => {
-  if (!r)
-    return n.error(`${e}模式下output不能为空`), process.exit(1);
-}, S = (e, r) => {
-  if (r && e === r)
-    return n.error("output与input不能相同"), process.exit(1);
-}, J = (e, r) => {
-  if (!r)
-    return n.error(`${e}模式下input不能为空`), process.exit(1);
-}, x = async (e, {
-  rollbackDelFileAgree: r = !1
-} = {}) => {
-  const {
-    env: i,
-    input: s,
-    inputData: u,
-    output: c,
-    mode: a,
-    rollback: p,
-    dealMarkdown: y,
-    envData: h
-  } = e;
-  if (p)
-    switch (a) {
-      case v.REPLACE:
-      case v.RETURN: {
-        n.error(`${a}模式不支持回滚`);
-        return;
-      }
-    }
-  n.stage(`开始处理模板
-mode: ${a}
-rollback: ${p}
-`);
-  const w = C({
-    filePath: s,
-    dataInit: u,
-    limitJson: !1,
-    filePathKey: "input",
-    dataInitKey: "inputData",
-    dealMarkdown: y
-  }), o = D(w), d = typeof h == "function" ? h() : h, m = o(d);
-  switch (a) {
-    case v.OVERWRITE: {
-      R(a, c), S(c, s);
-      const t = $.resolve(c);
-      if (l.mkdirSync($.dirname(t), { recursive: !0 }), l.existsSync(t)) {
-        if (p)
-          if (r || (await N({
-            type: "confirm",
-            name: "remove",
-            message: `${a}模式下回滚将删除${t}，是否继续？`
-          })).remove) {
-            l.rmSync(t, { force: !0 }), n.success(`${a}模式下${t}已删除`);
-            return;
-          } else {
-            n.warn(`${a}模式下${t}回滚取消`);
-            return;
-          }
-        n.info(`output:${t} 已存在，将覆盖`);
-      } else {
-        if (p) {
-          n.warn(`${a}模式下${t}不存在，无需回滚`);
-          return;
-        }
-        n.stage(`output:${t} 不存在，将创建`);
-      }
-      l.writeFileSync(t, m, "utf-8"), n.success(`模板处理完成，输出到 ${t}`);
-      break;
-    }
-    case v.APPEND: {
-      R(a, c), S(c, s);
-      const t = $.resolve(c);
-      if (l.mkdirSync($.dirname(t), { recursive: !0 }), l.existsSync(t)) {
-        const f = l.readFileSync(t, "utf-8");
-        if (p) {
-          l.writeFileSync(
-            t,
-            f.replace(m, ""),
-            "utf-8"
-          ), n.success(`${a}模式下${t}回滚完成`);
-          return;
-        }
-        const b = f + m;
-        l.writeFileSync(t, b, "utf-8"), n.success(`模板处理完成，追加到 ${t}`);
-      } else {
-        if (p) {
-          n.warn(`${a}模式下${t}不存在，无需回滚`);
-          return;
-        }
-        n.stage(`output:${t} 不存在，将创建`), l.writeFileSync(t, m, "utf-8"), n.success(`模板处理完成，输出到 ${t}`);
-      }
-      break;
-    }
-    case v.REPLACE: {
-      if (c && n.warn(`output ${c} 将被忽略`), J(a, s), i && i === s)
-        return n.error("env 与 input 不能相同"), process.exit(1);
-      const t = $.resolve(s);
-      let f = t;
-      const b = s.replace(`${process.cwd()}/`, ""), k = D(b)(d);
-      k !== b && (n.success(`检测输入文件名也需要替换
-            ./${b} => ./${k} `), l.rmSync(t), f = $.resolve(`./${k}`)), l.mkdirSync($.dirname(f), { recursive: !0 }), l.writeFileSync(f, m, "utf-8"), n.success(`模板处理完成，输出到 ${f}`);
-      break;
-    }
-    case v.RETURN:
-      return n.success("模板处理完成，返回结果(函数调用才会拿到返回值)"), m;
-    default:
-      return n.error(`mode ${a} 不支持`), process.exit(1);
-  }
-  return m;
-}, M = async ({
-  rootDir: e = process.cwd(),
-  itemDefaultRollback: r = !1,
-  extraEnvData: i = {}
-} = {}, s) => {
-  let u;
-  if (s)
-    u = s;
-  else {
-    const o = W(e);
-    if (!o)
-      return n.error(`配置文件${o}不存在`), process.exit(1);
-    const d = l.readFileSync(o, "utf-8");
-    u = JSON.parse(d);
-  }
-  const {
-    list: c,
-    globalEnvData: a = {},
-    collectEnvDataForm: p = []
-  } = u, y = {};
-  for (const o of p) {
-    let d, m, t;
-    typeof o == "string" ? (d = o, m = o, t = void 0) : (d = o.key, m = o.label, t = o.initial), y[d] = (await N({
-      type: "text",
-      name: d,
-      message: `请输入${m}`,
-      initial: t,
-      format: (f) => f.trim(),
-      validate: (f) => f.length > 0 || `${m}不能为空`
-    }))[d];
-  }
-  const h = c.map((o) => {
-    const { rollback: d = r } = o, {
-      envData: m,
-      env: t,
-      input: f,
-      output: b,
-      ...k
-    } = P(o);
-    return t && n.warn(`批量处理中 env:${t} 将被忽略，只读envData`), {
-      ...k,
-      env: t,
-      input: e && f ? $.resolve(e, f) : f,
-      output: e && b ? $.resolve(e, b) : b,
-      envData: T(
-        {},
-        i,
-        a,
-        y,
-        m
-      ),
-      rollback: d
-    };
-  }), w = [];
-  for (const o of h) {
-    const d = await x(o, {
-      rollbackDelFileAgree: !0
-    });
-    w.push(d);
-  }
-  return w;
-}, I = async (e) => {
-  const {
-    envData: r,
-    env: i,
-    input: s,
-    inputData: u,
-    output: c,
-    mode: a,
-    rollback: p,
-    dealMarkdown: y,
-    batch: h
-  } = P(e);
-  if (h)
-    return n.stage("开始批量处理"), M({
-      // 回滚默认值 基于全局
-      itemDefaultRollback: p
-    });
-  n.stage("开始单个处理");
-  const w = C({
-    filePath: i,
-    dataInit: r,
-    limitJson: !0,
-    filePathKey: "env",
-    dataInitKey: "envData",
-    dealMarkdown: y
-  });
-  return x({
-    input: s,
-    inputData: u,
-    output: c,
-    mode: a,
-    rollback: p,
-    dealMarkdown: y,
-    envData: w
-  });
-}, j = () => ({
-  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: [
-      v.OVERWRITE,
-      v.APPEND,
-      v.REPLACE,
-      v.RETURN
-    ],
-    default: g.mode
-  },
-  output: {
-    alias: "o",
-    describe: "输出文件路径",
-    type: "string"
-  },
-  rollback: {
-    alias: "r",
-    describe: "是否回滚",
-    type: "boolean",
-    default: g.rollback
-  },
-  dealMarkdown: {
-    alias: "d",
-    describe: "(检测是markdown)是否处理(单个)代码块包裹",
-    type: "boolean",
-    default: g.dealMarkdown
-  },
-  batch: {
-    alias: "b",
-    describe: "是否批量处理",
-    type: "boolean",
-    default: g.batch
-  }
-}), F = E.cliConfig.moduleName, L = (e, r) => {
-  e ? n.error(e) : n.error(r.message), process.exit(1);
-}, V = E.description, H = `Usage: $0 ${F} [options]`, _ = "Usage: $0 [options]", O = (e, r) => {
-  const i = j();
-  return e.strict().usage(r).help("help").version(E.version).alias("v", "version").alias("h", "help").options(i).fail(L).argv;
-}, q = (e) => O(e, H), Y = {
-  command: F,
-  describe: V,
-  builder: q,
-  handler: I
-}, ee = async () => {
-  const e = A(U(process.argv)), r = await O(e, _);
-  return I(r);
-};
-export {
-  v as O,
-  Y as a,
-  M as b,
-  ee as c,
-  W as g,
-  I as h
-};