@done-coding/cli-template 0.1.0 → 0.2.1

package/es/handler.mjs

@@ -1,135 +1,153 @@
 #!/usr/bin/env node
 import { OutputModeEnum as p } from "./utils/types.mjs";
 import f from "node:path";
-import c from "node:fs";
+import n from "node:fs";
 import o from "chalk";
-import E from "lodash.template";
-import x from "prompts";
-const $ = ({
+import b from "lodash.template";
+import k from "prompts";
+const d = ({
   filePath: r,
-  dataInit: t,
-  json: u,
-  filePathKey: l,
-  dataInitKey: g
+  dataInit: l,
+  json: i,
+  filePathKey: s,
+  dataInitKey: g,
+  dealMarkdown: u = !1
 }) => {
   if (r) {
-    if (u && !r.endsWith(".json"))
+    if (i && !r.endsWith(".json"))
       return console.log(
-        o.red(`${l}必须是json文件，请检查文件后缀名`)
+        o.red(`${s}必须是json文件，请检查文件后缀名`)
       ), process.exit(1);
-    const s = c.readFileSync(f.resolve(r), "utf-8");
-    return u ? JSON.parse(s) : s;
+    const t = n.readFileSync(f.resolve(r), "utf-8");
+    let c = t;
+    return u && r.endsWith(".md") && (c = t.replace(
+      /^\s*```[a-zA-Z0-9]+\s*[\r\n]+([\s\S]+?)```\s*$/,
+      "$1"
+    )), i ? JSON.parse(c) : c;
   } else
-    return t ? (console.log(o.green(`${l} 为空，将使用${t}作为数据`)), u ? JSON.parse(t) : t) : (console.log(o.red(`${l}与${g}不能同时为空`)), process.exit(1));
-}, d = (r, t) => {
-  if (!t)
+    return l ? (console.log(
+      o.green(`${s} 为空，将使用${g}作为数据`)
+    ), i ? JSON.parse(l) : l) : (console.log(o.red(`${s}与${g}不能同时为空`)), process.exit(1));
+}, y = (r, l) => {
+  if (!l)
     return console.log(o.red(`${r}模式下output不能为空`)), process.exit(1);
-}, y = (r, t) => {
-  if (t && r === t)
+}, v = (r, l) => {
+  if (l && r === l)
     return console.log(o.red("output与input不能相同")), process.exit(1);
-}, N = (r, t) => {
-  if (!t)
+}, x = (r, l) => {
+  if (!l)
     return console.log(o.red(`${r}模式下input不能为空`)), process.exit(1);
 }, O = async (r) => {
   const {
-    envData: t,
-    envJson: u,
-    input: l,
-    inputTemplate: g,
-    output: s,
-    mode: n,
-    rollback: a
+    envData: l,
+    env: i,
+    input: s,
+    inputData: g,
+    output: u,
+    mode: t = p.OVERWRITE,
+    rollback: c = !1,
+    dealMarkdown: m = !1
   } = r;
-  if (a)
-    switch (n) {
+  if (c)
+    switch (t) {
       case p.REPLACE:
       case p.RETURN: {
-        console.log(o.red(`${n}模式不支持回滚`));
+        console.log(o.red(`${t}模式不支持回滚`));
         return;
       }
     }
   console.log(
     o.blue(`开始处理模板
-mode: ${n}`)
+mode: ${t}
+rollback: ${c}
+`)
   );
-  const v = $({
-    filePath: u,
-    dataInit: t,
+  const S = d({
+    filePath: i,
+    dataInit: l,
     json: !0,
-    filePathKey: "envJson",
-    dataInitKey: "envData"
-  }), w = $({
-    filePath: l,
+    filePathKey: "env",
+    dataInitKey: "envData",
+    dealMarkdown: m
+  }), w = d({
+    filePath: s,
     dataInit: g,
     json: !1,
     filePathKey: "input",
-    dataInitKey: "inputTemplate"
-  }), i = E(w)(v);
-  switch (n) {
+    dataInitKey: "inputData",
+    dealMarkdown: m
+  }), a = b(w)(S);
+  switch (t) {
     case p.OVERWRITE: {
-      d(n, s), y(s, l);
-      const e = f.resolve(s);
-      if (a) {
-        if (c.existsSync(e))
-          if ((await x({
+      y(t, u), v(u, s);
+      const e = f.resolve(u);
+      if (n.mkdirSync(f.dirname(e), { recursive: !0 }), n.existsSync(e)) {
+        if (c)
+          if ((await k({
             type: "confirm",
             name: "remove",
-            message: `${n}模式下回滚将删除${e}，是否继续？`
+            message: `${t}模式下回滚将删除${e}，是否继续？`
           })).remove) {
-            c.rmSync(e, { force: !0 }), console.log(o.green(`${n}模式下${e}已删除`));
+            n.rmSync(e, { force: !0 }), console.log(o.green(`${t}模式下${e}已删除`));
             return;
           } else {
-            console.log(
-              o.yellow(`${n}模式下${e}不存在，无需回滚`)
-            );
+            console.log(o.yellow(`${t}模式下${e}回滚取消`));
             return;
           }
-        return;
+        console.log(o.blue(`output:${e} 已存在，将覆盖`));
+      } else {
+        if (c) {
+          console.log(
+            o.yellow(`${t}模式下${e}不存在，无需回滚`)
+          );
+          return;
+        }
+        console.log(o.blue(`output:${e} 不存在，将创建`));
       }
-      c.writeFileSync(e, i, "utf-8"), console.log(o.green(`模板处理完成，输出到 ${e}`));
+      n.writeFileSync(e, a, "utf-8"), console.log(o.green(`模板处理完成，输出到 ${e}`));
       break;
     }
     case p.APPEND: {
-      d(n, s), y(s, l);
-      const e = f.resolve(s);
-      if (c.existsSync(e)) {
-        const m = c.readFileSync(e, "utf-8");
-        if (a) {
-          c.writeFileSync(
+      y(t, u), v(u, s);
+      const e = f.resolve(u);
+      if (n.mkdirSync(f.dirname(e), { recursive: !0 }), n.existsSync(e)) {
+        const $ = n.readFileSync(e, "utf-8");
+        if (c) {
+          n.writeFileSync(
             e,
-            m.replace(i, ""),
+            $.replace(a, ""),
             "utf-8"
-          ), console.log(o.green(`${n}模式下${e}回滚完成`));
+          ), console.log(o.green(`${t}模式下${e}回滚完成`));
           return;
         }
-        const S = m + i;
-        c.writeFileSync(e, S, "utf-8"), console.log(o.green(`模板处理完成，追加到 ${e}`));
+        const E = $ + a;
+        n.writeFileSync(e, E, "utf-8"), console.log(o.green(`模板处理完成，追加到 ${e}`));
       } else {
-        if (a) {
+        if (c) {
           console.log(
-            o.yellow(`${n}模式下${e}不存在，无需回滚`)
+            o.yellow(`${t}模式下${e}不存在，无需回滚`)
           );
           return;
         }
-        console.log(o.blue(`output:${e} 不存在，将创建`)), c.writeFileSync(e, i, "utf-8"), console.log(o.green(`模板处理完成，输出到 ${e}`));
+        console.log(o.blue(`output:${e} 不存在，将创建`)), n.writeFileSync(e, a, "utf-8"), console.log(o.green(`模板处理完成，输出到 ${e}`));
       }
       break;
     }
     case p.REPLACE: {
-      if (s && console.log(o.yellow(`output ${s} 将被忽略`)), N(n, l), u && u === l)
-        return console.log(o.red("envJson与input不能相同")), process.exit(1);
-      const e = f.resolve(l);
-      c.writeFileSync(e, i, "utf-8"), console.log(o.green(`模板处理完成，输出到 ${e}`));
+      if (u && console.log(o.yellow(`output ${u} 将被忽略`)), x(t, s), i && i === s)
+        return console.log(o.red("env 与 input 不能相同")), process.exit(1);
+      const e = f.resolve(s);
+      n.mkdirSync(f.dirname(e), { recursive: !0 }), n.writeFileSync(e, a, "utf-8"), console.log(o.green(`模板处理完成，输出到 ${e}`));
       break;
     }
     case p.RETURN:
       return console.log(
         o.green("模板处理完成，返回结果(函数调用才会拿到返回值)")
-      ), i;
+      ), a;
     default:
-      return console.log(o.red(`mode ${n} 不支持`)), process.exit(1);
+      return console.log(o.red(`mode ${t} 不支持`)), process.exit(1);
   }
-  return i;
+  return a;
 };
 export {
   O as handler

package/es/index.mjs

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

package/es/injectInfo.json.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 const e = {
   name: "@done-coding/cli-template",
-  version: "0.1.0",
+  version: "0.2.1",
   description: "预编译命令行工具"
 };
 export {

package/es/main.mjs

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 import l from "yargs";
 import { hideBin as p } from "yargs/helpers";
-import { OutputModeEnum as s } from "./utils/types.mjs";
-import { handler as i } from "./handler.mjs";
+import { OutputModeEnum as t } from "./utils/types.mjs";
+import { handler as a } from "./handler.mjs";
 import o from "chalk";
-import n from "./injectInfo.json.mjs";
-const m = () => ({
-  envJson: {
-    alias: "j",
+import i from "./injectInfo.json.mjs";
+const d = () => ({
+  env: {
+    alias: "e",
     describe: "环境数据文件JSON文件相对路径(优先级高于envData)",
     type: "string"
   },
   envData: {
-    alias: "e",
+    alias: "E",
     describe: "环境变量数据(JSON字符串)",
     type: "string"
   },
@@ -21,9 +21,9 @@ const m = () => ({
     describe: "模板文件相对路径(优先级高于inputTemplate)",
     type: "string"
   },
-  inputTemplate: {
-    alias: "t",
-    describe: "模板文件内容",
+  inputData: {
+    alias: "I",
+    describe: "模板数据",
     type: "string"
   },
   mode: {
@@ -31,40 +31,45 @@ const m = () => ({
     describe: "输出模式",
     type: "string",
     choices: [
-      s.OVERWRITE,
-      s.APPEND,
-      s.REPLACE,
-      s.RETURN
+      t.OVERWRITE,
+      t.APPEND,
+      t.REPLACE,
+      t.RETURN
     ],
-    default: s.OVERWRITE
+    default: t.OVERWRITE
   },
   output: {
     alias: "o",
     describe: "输出文件路径",
-    type: "string",
-    demandOption: !0
+    type: "string"
   },
   rollback: {
     alias: "r",
     describe: "是否回滚",
     type: "boolean",
     default: !1
+  },
+  dealMarkdown: {
+    alias: "d",
+    describe: "(检测是markdown)是否处理(单个)代码块包裹",
+    type: "boolean",
+    default: !1
   }
-}), a = "template", d = (e, t) => {
-  console.log(e ? o.red(e) : o.red(t.message)), process.exit(1);
-}, g = n.description, u = `Usage: $0 ${a} [options]`, f = "Usage: $0 [options]", r = (e, t) => {
-  const c = m();
-  return e.strict().usage(t).help("help").version(n.version).alias("v", "version").alias("h", "help").options(c).fail(d).argv;
+}), n = "template", m = (e, s) => {
+  console.log(e ? o.red(e) : o.red(s.message)), process.exit(1);
+}, g = i.description, u = `Usage: $0 ${n} [options]`, f = "Usage: $0 [options]", r = (e, s) => {
+  const c = d();
+  return e.strict().usage(s).help("help").version(i.version).alias("v", "version").alias("h", "help").options(c).fail(m).argv;
 }, b = (e) => r(e, u), C = {
-  command: a,
+  command: n,
   describe: g,
   builder: b,
-  handler: i
-}, N = async () => {
-  const e = l(p(process.argv)), t = await r(e, f);
-  return i(t);
+  handler: a
+}, D = async () => {
+  const e = l(p(process.argv)), s = await r(e, f);
+  return a(s);
 };
 export {
   C as command,
-  N as createCli
+  D as createCli
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@done-coding/cli-template",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "预编译命令行工具",
   "private": false,
   "module": "es/index.mjs",
@@ -34,13 +34,14 @@
     "directory": "packages/template"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   },
   "author": "JustSoSu",
   "license": "MIT",
   "sideEffects": false,
   "devDependencies": {
-    "@done-coding/cli-inject": "^0.2.0",
+    "@done-coding/cli-inject": "^0.2.2",
     "@types/lodash.get": "^4.4.9",
     "@types/lodash.set": "^4.3.9",
     "@types/lodash.template": "^4.5.3",
@@ -63,5 +64,5 @@
     "prompts": "^2.4.2",
     "yargs": "^17.7.2"
   },
-  "gitHead": "caa230835cb90705a00646511ae437a13439b267"
+  "gitHead": "e2dc7c4b0fa74aa83dc6173416aaffe0a0a445ad"
 }

package/types/index.d.ts

@@ -1,2 +1,3 @@
 export { handler } from "./handler";
 export { command } from "./main";
+export * from './utils/types';

package/types/injectInfo.json.d.ts

@@ -1,6 +1,6 @@
 declare const _default: {
   "name": "@done-coding/cli-template",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "预编译命令行工具"
 };
 

package/types/utils/types.d.ts

@@ -10,18 +10,20 @@ export declare enum OutputModeEnum {
     RETURN = "return"
 }
 export interface Options {
-    /** 环境数据文件JSON文件相对路径(优先级高于envData) */
-    envJson: string;
+    /** 环境数据(json)文件(优先级高于 envData ) */
+    env?: string;
     /** 环境变量数据(JSON字符串) */
-    envData: string;
-    /** 模板文件相对路径(优先级高于inputTemplate) */
-    input: string;
-    /** 模板文件内容  */
-    inputTemplate: string;
+    envData?: string;
+    /** 模板文件相对路径(优先级高于 inputData ) */
+    input?: string;
+    /** 模板数据 */
+    inputData?: string;
     /** 输出文件相对路径 */
     output: string;
-    /** 输出模式 */
+    /** 输出模式 @default OutputModeEnum.OVERWRITE */
     mode: OutputModeEnum;
-    /** 是否回滚 */
-    rollback: boolean;
+    /** 是否回滚 @default false */
+    rollback?: boolean;
+    /** (检测是markdown)是否处理(单个)代码块包裹 */
+    dealMarkdown?: boolean;
 }