@done-coding/cli-template 0.3.0 → 0.4.0

package/es/handler.mjs

@@ -1,213 +1,239 @@
 #!/usr/bin/env node
-import { OutputModeEnum as d } from "./utils/types.mjs";
-import { completeDefaultOptions as S } from "./utils/dealOptions.mjs";
+import { OutputModeEnum as b } from "./utils/types.mjs";
+import { completeDefaultOptions as k } from "./utils/dealOptions.mjs";
+import { getConfigPath as N } from "./utils/config.mjs";
 import m from "node:path";
-import s from "node:fs";
-import e from "chalk";
-import x from "lodash.template";
-import N from "lodash.assign";
-import F from "prompts";
-import I from "./injectInfo.json.mjs";
-const b = ({
-  filePath: l,
-  dataInit: n,
-  limitJson: u,
-  filePathKey: c,
-  dataInitKey: f,
-  dealMarkdown: i = !1
+import u from "node:fs";
+import t from "chalk";
+import F from "lodash.template";
+import R from "lodash.assign";
+import E from "prompts";
+const h = ({
+  filePath: n,
+  dataInit: l,
+  limitJson: f,
+  filePathKey: s,
+  dataInitKey: g,
+  dealMarkdown: a = !1
 }) => {
-  if (l) {
-    if (u && !l.endsWith(".json"))
+  if (n) {
+    if (f && !n.endsWith(".json"))
       return console.log(
-        e.red(`${c}必须是json文件，请检查文件后缀名`)
+        t.red(`${s}必须是json文件，请检查文件后缀名`)
       ), process.exit(1);
-    const t = s.readFileSync(m.resolve(l), "utf-8");
-    let r = t;
-    return i && l.endsWith(".md") && (r = t.replace(
+    const o = u.readFileSync(m.resolve(n), "utf-8");
+    let c = o;
+    return a && n.endsWith(".md") && (c = o.replace(
       /^\s*```[a-zA-Z0-9]+\s*[\r\n]+([\s\S]+?)```\s*$/,
       "$1"
-    )), u ? JSON.parse(r) : r;
+    )), f ? JSON.parse(c) : c;
   } else
-    return n ? (console.log(
-      e.green(`${c} 为空，将使用${f}作为数据`)
-    ), u ? JSON.parse(n) : n) : (console.log(e.red(`${c}与${f}不能同时为空`)), process.exit(1));
-}, y = (l, n) => {
-  if (!n)
-    return console.log(e.red(`${l}模式下output不能为空`)), process.exit(1);
-}, D = (l, n) => {
-  if (n && l === n)
-    return console.log(e.red("output与input不能相同")), process.exit(1);
-}, R = (l, n) => {
-  if (!n)
-    return console.log(e.red(`${l}模式下input不能为空`)), process.exit(1);
-}, w = async (l, {
-  rollbackDelFileAgree: n = !1
+    return l ? (console.log(
+      t.green(`${s} 为空，将使用${g}作为数据`)
+    ), f ? JSON.parse(l) : l) : (console.log(t.red(`${s}与${g}不能同时为空`)), process.exit(1));
+}, S = (n, l) => {
+  if (!l)
+    return console.log(t.red(`${n}模式下output不能为空`)), process.exit(1);
+}, D = (n, l) => {
+  if (l && n === l)
+    return console.log(t.red("output与input不能相同")), process.exit(1);
+}, I = (n, l) => {
+  if (!l)
+    return console.log(t.red(`${n}模式下input不能为空`)), process.exit(1);
+}, x = async (n, {
+  rollbackDelFileAgree: l = !1
 } = {}) => {
   const {
-    env: u,
-    input: c,
-    inputData: f,
-    output: i,
-    mode: t,
-    rollback: r,
-    dealMarkdown: a,
-    envData: p
-  } = l;
-  if (r)
-    switch (t) {
-      case d.REPLACE:
-      case d.RETURN: {
-        console.log(e.red(`${t}模式不支持回滚`));
+    env: f,
+    input: s,
+    inputData: g,
+    output: a,
+    mode: o,
+    rollback: c,
+    dealMarkdown: v,
+    envData: d
+  } = n;
+  if (c)
+    switch (o) {
+      case b.REPLACE:
+      case b.RETURN: {
+        console.log(t.red(`${o}模式不支持回滚`));
         return;
       }
     }
   console.log(
-    e.blue(`开始处理模板
-mode: ${t}
-rollback: ${r}
+    t.blue(`开始处理模板
+mode: ${o}
+rollback: ${c}
 `)
   );
-  const $ = b({
-    filePath: c,
-    dataInit: f,
+  const r = h({
+    filePath: s,
+    dataInit: g,
     limitJson: !1,
     filePathKey: "input",
     dataInitKey: "inputData",
-    dealMarkdown: a
-  }), k = x($), E = typeof p == "function" ? p() : p, g = k(E);
-  switch (t) {
-    case d.OVERWRITE: {
-      y(t, i), D(i, c);
-      const o = m.resolve(i);
-      if (s.mkdirSync(m.dirname(o), { recursive: !0 }), s.existsSync(o)) {
-        if (r)
-          if (n || (await F({
+    dealMarkdown: v
+  }), p = F(r), $ = typeof d == "function" ? d() : d, i = p($);
+  switch (o) {
+    case b.OVERWRITE: {
+      S(o, a), D(a, s);
+      const e = m.resolve(a);
+      if (u.mkdirSync(m.dirname(e), { recursive: !0 }), u.existsSync(e)) {
+        if (c)
+          if (l || (await E({
             type: "confirm",
             name: "remove",
-            message: `${t}模式下回滚将删除${o}，是否继续？`
+            message: `${o}模式下回滚将删除${e}，是否继续？`
           })).remove) {
-            s.rmSync(o, { force: !0 }), console.log(e.green(`${t}模式下${o}已删除`));
+            u.rmSync(e, { force: !0 }), console.log(t.green(`${o}模式下${e}已删除`));
             return;
           } else {
-            console.log(e.yellow(`${t}模式下${o}回滚取消`));
+            console.log(t.yellow(`${o}模式下${e}回滚取消`));
             return;
           }
-        console.log(e.blue(`output:${o} 已存在，将覆盖`));
+        console.log(t.blue(`output:${e} 已存在，将覆盖`));
       } else {
-        if (r) {
+        if (c) {
           console.log(
-            e.yellow(`${t}模式下${o}不存在，无需回滚`)
+            t.yellow(`${o}模式下${e}不存在，无需回滚`)
           );
           return;
         }
-        console.log(e.blue(`output:${o} 不存在，将创建`));
+        console.log(t.blue(`output:${e} 不存在，将创建`));
       }
-      s.writeFileSync(o, g, "utf-8"), console.log(e.green(`模板处理完成，输出到 ${o}`));
+      u.writeFileSync(e, i, "utf-8"), console.log(t.green(`模板处理完成，输出到 ${e}`));
       break;
     }
-    case d.APPEND: {
-      y(t, i), D(i, c);
-      const o = m.resolve(i);
-      if (s.mkdirSync(m.dirname(o), { recursive: !0 }), s.existsSync(o)) {
-        const v = s.readFileSync(o, "utf-8");
-        if (r) {
-          s.writeFileSync(
-            o,
-            v.replace(g, ""),
+    case b.APPEND: {
+      S(o, a), D(a, s);
+      const e = m.resolve(a);
+      if (u.mkdirSync(m.dirname(e), { recursive: !0 }), u.existsSync(e)) {
+        const y = u.readFileSync(e, "utf-8");
+        if (c) {
+          u.writeFileSync(
+            e,
+            y.replace(i, ""),
             "utf-8"
-          ), console.log(e.green(`${t}模式下${o}回滚完成`));
+          ), console.log(t.green(`${o}模式下${e}回滚完成`));
           return;
         }
-        const h = v + g;
-        s.writeFileSync(o, h, "utf-8"), console.log(e.green(`模板处理完成，追加到 ${o}`));
+        const w = y + i;
+        u.writeFileSync(e, w, "utf-8"), console.log(t.green(`模板处理完成，追加到 ${e}`));
       } else {
-        if (r) {
+        if (c) {
           console.log(
-            e.yellow(`${t}模式下${o}不存在，无需回滚`)
+            t.yellow(`${o}模式下${e}不存在，无需回滚`)
           );
           return;
         }
-        console.log(e.blue(`output:${o} 不存在，将创建`)), s.writeFileSync(o, g, "utf-8"), console.log(e.green(`模板处理完成，输出到 ${o}`));
+        console.log(t.blue(`output:${e} 不存在，将创建`)), u.writeFileSync(e, i, "utf-8"), console.log(t.green(`模板处理完成，输出到 ${e}`));
       }
       break;
     }
-    case d.REPLACE: {
-      if (i && console.log(e.yellow(`output ${i} 将被忽略`)), R(t, c), u && u === c)
-        return console.log(e.red("env 与 input 不能相同")), process.exit(1);
-      const o = m.resolve(c);
-      s.mkdirSync(m.dirname(o), { recursive: !0 }), s.writeFileSync(o, g, "utf-8"), console.log(e.green(`模板处理完成，输出到 ${o}`));
+    case b.REPLACE: {
+      if (a && console.log(t.yellow(`output ${a} 将被忽略`)), I(o, s), f && f === s)
+        return console.log(t.red("env 与 input 不能相同")), process.exit(1);
+      const e = m.resolve(s);
+      u.mkdirSync(m.dirname(e), { recursive: !0 }), u.writeFileSync(e, i, "utf-8"), console.log(t.green(`模板处理完成，输出到 ${e}`));
       break;
     }
-    case d.RETURN:
+    case b.RETURN:
       return console.log(
-        e.green("模板处理完成，返回结果(函数调用才会拿到返回值)")
-      ), g;
+        t.green("模板处理完成，返回结果(函数调用才会拿到返回值)")
+      ), i;
     default:
-      return console.log(e.red(`mode ${t} 不支持`)), process.exit(1);
+      return console.log(t.red(`mode ${o} 不支持`)), process.exit(1);
   }
-  return g;
+  return i;
 }, C = async ({
+  rootDir: n = process.cwd(),
   itemDefaultRollback: l = !1
-} = {}, n) => {
-  let u;
-  if (n)
-    u = n;
+} = {}, f) => {
+  let s;
+  if (f)
+    s = f;
   else {
-    const { namespaceDir: t, moduleName: r } = I.cliConfig, a = m.resolve(t, `${r}.json`);
-    if (!s.existsSync(a))
-      return console.log(e.red(`配置文件${a}不存在`)), process.exit(1);
-    const p = s.readFileSync(a, "utf-8");
-    u = JSON.parse(p);
+    const r = N(n);
+    if (!r)
+      return console.log(t.red(`配置文件${r}不存在`)), process.exit(1);
+    const p = u.readFileSync(r, "utf-8");
+    s = JSON.parse(p);
   }
-  const { list: c, globalEnvData: f } = u, i = c.map((t) => {
-    const { rollback: r = l } = t, { envData: a, env: p, ...$ } = S(t);
-    return p && console.log(e.yellow(`批量处理中 env:${p} 将被忽略，只读envData`)), {
-      ...$,
-      envData: N({}, f, a),
-      rollback: r
+  const {
+    list: g,
+    globalEnvData: a = {},
+    collectEnvDataForm: o = []
+  } = s, c = {};
+  for (const r of o) {
+    let p, $, i;
+    typeof r == "string" ? (p = r, $ = r, i = void 0) : (p = r.key, $ = r.label, i = r.initial), c[p] = (await E({
+      type: "text",
+      name: p,
+      message: `请输入${$}`,
+      initial: i,
+      format: (e) => (e || "").trim(),
+      validate: (e) => e ? !0 : `${$}不能为空`
+    }))[p];
+  }
+  const v = g.map((r) => {
+    const { rollback: p = l } = r, {
+      envData: $,
+      env: i,
+      input: e,
+      output: y,
+      ...w
+    } = k(r);
+    return i && console.log(t.yellow(`批量处理中 env:${i} 将被忽略，只读envData`)), {
+      ...w,
+      env: i,
+      input: n && e ? m.resolve(n, e) : e,
+      output: n && y ? m.resolve(n, y) : y,
+      envData: R({}, a, c, $),
+      rollback: p
     };
-  });
-  return Promise.all(
-    i.map(
-      (t) => w(t, {
-        rollbackDelFileAgree: !0
-      })
-    )
-  );
-}, U = async (l) => {
+  }), d = [];
+  for (const r of v) {
+    const p = await x(r, {
+      rollbackDelFileAgree: !0
+    });
+    d.push(p);
+  }
+  return d;
+}, U = async (n) => {
   const {
-    envData: n,
-    env: u,
-    input: c,
-    inputData: f,
-    output: i,
-    mode: t,
-    rollback: r,
-    dealMarkdown: a,
-    batch: p
-  } = S(l);
-  if (p)
-    return console.log(e.blue("开始批量处理")), C({
+    envData: l,
+    env: f,
+    input: s,
+    inputData: g,
+    output: a,
+    mode: o,
+    rollback: c,
+    dealMarkdown: v,
+    batch: d
+  } = k(n);
+  if (d)
+    return console.log(t.blue("开始批量处理")), C({
       // 回滚默认值 基于全局
-      itemDefaultRollback: r
+      itemDefaultRollback: c
     });
-  console.log(e.blue("开始单个处理"));
-  const $ = b({
-    filePath: u,
-    dataInit: n,
+  console.log(t.blue("开始单个处理"));
+  const r = h({
+    filePath: f,
+    dataInit: l,
     limitJson: !0,
     filePathKey: "env",
     dataInitKey: "envData",
-    dealMarkdown: a
+    dealMarkdown: v
   });
-  return w({
-    input: c,
-    inputData: f,
-    output: i,
-    mode: t,
-    rollback: r,
-    dealMarkdown: a,
-    envData: $
+  return x({
+    input: s,
+    inputData: g,
+    output: a,
+    mode: o,
+    rollback: c,
+    dealMarkdown: v,
+    envData: r
   });
 };
 export {

package/es/index.mjs

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
-import { handler as e } from "./handler.mjs";
-import { command as n } from "./main.mjs";
+import { batchHandler as e, handler as t } from "./handler.mjs";
+import { command as m } from "./main.mjs";
 import { OutputModeEnum as d } from "./utils/types.mjs";
+import { getConfigPath as p } from "./utils/config.mjs";
 export {
   d as OutputModeEnum,
-  n as command,
-  e as handler
+  e as batchHandler,
+  m as command,
+  p as getConfigPath,
+  t as handler
 };

package/es/injectInfo.json.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 const e = {
-  version: "0.3.0",
+  version: "0.4.0",
   name: "@done-coding/cli-template",
   description: "预编译命令行工具",
   cliConfig: {

package/es/main.mjs

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 import d from "yargs";
 import { hideBin as m } from "yargs/helpers";
-import { OutputModeEnum as a } from "./utils/types.mjs";
-import { defaultOptions as t } from "./utils/dealOptions.mjs";
+import { OutputModeEnum as t } from "./utils/types.mjs";
+import { defaultOptions as a } from "./utils/dealOptions.mjs";
+import i from "./injectInfo.json.mjs";
+import "node:path";
+import "node:fs";
 import { handler as n } from "./handler.mjs";
 import s from "chalk";
-import i from "./injectInfo.json.mjs";
 const p = () => ({
   env: {
     alias: "e",
@@ -32,12 +34,12 @@ const p = () => ({
     describe: "输出模式",
     type: "string",
     choices: [
-      a.OVERWRITE,
-      a.APPEND,
-      a.REPLACE,
-      a.RETURN
+      t.OVERWRITE,
+      t.APPEND,
+      t.REPLACE,
+      t.RETURN
     ],
-    default: t.mode
+    default: a.mode
   },
   output: {
     alias: "o",
@@ -48,35 +50,35 @@ const p = () => ({
     alias: "r",
     describe: "是否回滚",
     type: "boolean",
-    default: t.rollback
+    default: a.rollback
   },
   dealMarkdown: {
     alias: "d",
     describe: "(检测是markdown)是否处理(单个)代码块包裹",
     type: "boolean",
-    default: t.dealMarkdown
+    default: a.dealMarkdown
   },
   batch: {
     alias: "b",
     describe: "是否批量处理",
     type: "boolean",
-    default: t.batch
+    default: a.batch
   }
 }), r = i.cliConfig.moduleName, u = (e, o) => {
   console.log(e ? s.red(e) : s.red(o.message)), process.exit(1);
 }, b = i.description, g = `Usage: $0 ${r} [options]`, f = "Usage: $0 [options]", c = (e, o) => {
   const l = p();
   return e.strict().usage(o).help("help").version(i.version).alias("v", "version").alias("h", "help").options(l).fail(u).argv;
-}, h = (e) => c(e, g), D = {
+}, h = (e) => c(e, g), U = {
   command: r,
   describe: b,
   builder: h,
   handler: n
-}, R = async () => {
+}, w = async () => {
   const e = d(m(process.argv)), o = await c(e, f);
   return n(o);
 };
 export {
-  D as command,
-  R as createCli
+  U as command,
+  w as createCli
 };

package/es/utils/config.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import i from "../injectInfo.json.mjs";
+import r from "node:path";
+import f from "node:fs";
+const p = (o) => {
+  const { namespaceDir: t, moduleName: s } = i.cliConfig, e = [t, `${s}.json`];
+  o && e.unshift(o);
+  const n = r.resolve(...e);
+  if (f.existsSync(n))
+    return n;
+};
+export {
+  p as getConfigPath
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@done-coding/cli-template",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "预编译命令行工具",
   "private": false,
   "module": "es/index.mjs",
@@ -41,12 +41,12 @@
   "license": "MIT",
   "sideEffects": false,
   "devDependencies": {
-    "@done-coding/cli-inject": "^0.3.1",
+    "@done-coding/cli-inject": "^0.4.1",
     "@types/lodash.assign": "^4.2.9",
     "@types/lodash.get": "^4.4.9",
     "@types/lodash.set": "^4.3.9",
     "@types/lodash.template": "^4.5.3",
-    "@types/node": "^20.0.0",
+    "@types/node": "^18.0.0",
     "@types/prompts": "^2.4.6",
     "@types/yargs": "^17.0.28",
     "rimraf": "^6.0.1",
@@ -55,7 +55,7 @@
     "vite-plugin-dts": "^3.6.0"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
   },
   "dependencies": {
     "chalk": "^5.3.0",
@@ -66,5 +66,5 @@
     "prompts": "^2.4.2",
     "yargs": "^17.7.2"
   },
-  "gitHead": "d1dabd6e46a5e38793bba477449dd62aa4d9c4c1"
+  "gitHead": "1778df27cf625b5588b1de38d260cfed75e123f2"
 }

package/types/handler.d.ts

@@ -1,7 +1,9 @@
 import type { CompileTemplateConfig } from './utils';
 import { type Options } from './utils';
 import type { ArgumentsCamelCase } from "yargs";
-export declare const batchHandler: ({ itemDefaultRollback, }?: {
+export declare const batchHandler: ({ rootDir, itemDefaultRollback, }?: {
+    /** 根目录 */
+    rootDir?: string | undefined;
     /** item默认回滚? */
     itemDefaultRollback?: boolean | undefined;
 }, paramsConfig?: CompileTemplateConfig) => Promise<(string | undefined)[]>;

package/types/index.d.ts

@@ -1,3 +1,4 @@
-export { handler } from "./handler";
+export { handler, batchHandler } from "./handler";
 export { command } 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.3.0",
+  "version": "0.4.0",
   "name": "@done-coding/cli-template",
   "description": "预编译命令行工具",
   "cliConfig": {

package/types/utils/config.d.ts

@@ -0,0 +1,2 @@
+/** 获取配置文件路径 */
+export declare const getConfigPath: (rootDir?: string) => string | undefined;

package/types/utils/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./types";
 export * from "./dealOptions";
+export * from "./config";

package/types/utils/types.d.ts

@@ -19,7 +19,7 @@ export interface Options {
     /** 模板数据 */
     inputData?: string;
     /** 输出文件相对路径 */
-    output: string;
+    output?: string;
     /** 输出模式 @default OutputModeEnum.OVERWRITE */
     mode: OutputModeEnum;
     /** 是否回滚 @default false */
@@ -34,10 +34,21 @@ export type CompileTemplateConfigListItem = Omit<Options, "envData"> & {
     /** 已经解析为对象的envData */
     envData: Record<string, any>;
 };
+/** 采集环境变量配置 */
+export interface CollectFormItem {
+    /** 采集环境变量的key */
+    key: string;
+    /** 采集环境变量标签 */
+    label: string;
+    /** 采集环境变量初始值 */
+    initial?: string;
+}
 /** 编译模板配置 */
 export interface CompileTemplateConfig {
     /** 全局环境变量 */
-    globalEnvData: Record<string, any>;
+    globalEnvData?: Record<string, any>;
+    /** 采集环境变量表单配置 */
+    collectEnvDataForm?: (CollectFormItem | string)[];
     /** 配置列表 */
     list: CompileTemplateConfigListItem[];
 }