@lazycatcloud/lzc-cli 1.1.8 → 1.1.9

package/lib/app/lpk_create.js

@@ -2,18 +2,17 @@ import logger from "loglevel";
 import inquirer from "inquirer";
 import {
   contextDirname,
-  createTemplateFile,
   loadFromYaml,
   envTemplateFile,
   ensureDir,
   dumpToYaml,
+  isFileExist,
 } from "../utils.js";
 import path from "node:path";
-import Generator, { TemplateConfig } from "../generator.js";
-import fs from "fs";
+import { TemplateConfig } from "./lpk_create_generator.js";
+import fs from "node:fs";
 import yaml from "js-yaml";
 let fsPromises = fs.promises;
-import { parse2CorrectName } from "../utils.js";
 
 export class LpkManifest {
   constructor(defaultAppID) {
@@ -22,23 +21,30 @@ export class LpkManifest {
     this.defaultAppID = defaultAppID;
   }
 
-  async init(manifestFilePath) {
-    if (manifestFilePath) {
-      this.manifest = loadFromYaml(manifestFilePath);
-    } else {
-      let templatePath = path.join(
+  async init(manifestFilePath, askInfo = false) {
+    if (!manifestFilePath) {
+      manifestFilePath = path.join(
         this.pwd,
         "../../template/_lpk/manifest.yml.in"
       );
+    }
+
+    if (askInfo) {
       let answer = await this.askLpkInfo();
-      this.manifest = yaml.load(await envTemplateFile(templatePath, answer));
+      this.manifest = yaml.load(
+        await envTemplateFile(manifestFilePath, answer)
+      );
+    } else {
+      this.manifest = loadFromYaml(manifestFilePath);
     }
   }
 
   async create(outputDir) {
-    let outputFilePath = path.join(outputDir, "manifest.yml");
-    logger.info(`创建文件 ${outputFilePath}`);
+    let outputFilePath = path.join(outputDir, "lzc-manifest.yml");
+    logger.debug(`创建文件 ${outputFilePath}`);
+
     ensureDir(outputFilePath);
+
     return fsPromises
       .access(outputFilePath, fs.constants.F_OK | fs.constants.W_OK)
       .then(
@@ -48,7 +54,7 @@ export class LpkManifest {
               name: "override",
               type: "input",
               default: "n",
-              message: "manifest.yml已经存在，是否覆盖(y/n): ",
+              message: "lzc-manifest.yml已经存在，是否覆盖(y/n): ",
             },
           ];
           const answers = await inquirer.prompt(questions);
@@ -123,18 +129,29 @@ export class LpkManifest {
 }
 
 export class TemplateInit {
-  constructor(context) {
-    this.context = context;
-    this.type = context.type;
+  constructor(cwd, name, type) {
+    this.cwd = cwd;
+    this.name = name;
+    this.type = type;
+    this.lpkManifest = new LpkManifest(name);
   }
 
-  async create() {
+  async init() {
     if (!this.type) {
       this.type = await chooseTemplate();
     }
-    let lpkManifest = new LpkManifest(path.basename(this.context.cwd));
-    await lpkManifest.init();
-    await lpkManifest.create(this.context.cwd);
+
+    // 优先使用模板项目自定义的模板文件
+    const typeTemplatePath = path.join(
+      contextDirname(import.meta.url),
+      `../../template/_lpk/${this.type}.manifest.yml.in`
+    );
+    const templatePath = isFileExist(typeTemplatePath) ? typeTemplatePath : "";
+    await this.lpkManifest.init(templatePath, true);
+  }
+
+  async create() {
+    await this.lpkManifest.create(path.resolve(this.cwd, this.name));
   }
 }
 
@@ -145,41 +162,44 @@ export async function chooseTemplate() {
         name: "type",
         message: "选择项目构建模板",
         type: "list",
-        choices: ["vue", "golang", "ionic_vue3"],
+        choices: ["lite", "vue3", "vue2", "golang", "ionic_vue3"],
       },
     ])
   )["type"];
 }
 
 // 创建一个应用
-// - 先选择模板信息（vue, golang, vue3)
+// - 先选择模板信息（golang, vue3)
 // - 根据 lpk manifest 模板中所需要的字段填充manifest
-// - 将 .lazycat 生成（包含 manifest, 项目文件）
 // - 调用模板的hook
 class LpkCreate {
-  constructor({ name }) {
+  constructor(name, cwd = process.cwd()) {
     this.name = name;
+    this.cwd = cwd ?? process.cwd();
+  }
+
+  async init() {
+    ensureDir(path.resolve(this.cwd, this.name, "file"));
+    return this;
   }
 
   async exec() {
     const type = await chooseTemplate();
-    const template = new TemplateInit({
-      cwd: path.join(process.cwd(), this.name),
-      type: type,
-    });
-    if (TemplateConfig[type]) {
-      await template.create();
-      logger.info(`初始化项目 ${this.name}`);
-      await Generator().generate(type, this.name);
-      logger.info("设置懒猫云应用");
-      await TemplateConfig[type].after(this.name);
-    }
+    const template = new TemplateInit(this.cwd, this.name, type);
+    await template.init();
+
+    console.log(`初始化项目 ${this.name}`);
+    await TemplateConfig[type].build(path.resolve(this.cwd, this.name));
+
+    console.log("初始化懒猫云应用");
+    await TemplateConfig[type].after(this.name, this.cwd);
+
+    await template.create();
   }
 }
 
-export default async (context) => {
-  context.name = parse2CorrectName(context.name);
-  await fsPromises.access(process.cwd() + "/" + context.name).then(
+export default async (name, cwd = process.cwd()) => {
+  await fsPromises.access(path.resolve(cwd, name)).then(
     async () => {
       const questions = [
         {
@@ -191,11 +211,13 @@ export default async (context) => {
       ];
       const answers = await inquirer.prompt(questions);
       if (answers.override.toLowerCase() === "y") {
-        return new LpkCreate(context).exec();
+        const lpk = await new LpkCreate(name, cwd).init();
+        return await lpk.exec();
       }
     },
-    () => {
-      return new LpkCreate(context).exec();
+    async () => {
+      const lpk = await new LpkCreate(name, cwd).init();
+      return await lpk.exec();
     }
   );
 };

package/lib/app/lpk_create_generator.js

@@ -0,0 +1,202 @@
+import glob from "fast-glob";
+import path from "path";
+import fs from "fs";
+import { isBinaryFileSync } from "isbinaryfile";
+import { contextDirname, isFileExist } from "../utils.js";
+import chalk from "chalk";
+import { spawnSync } from "node:child_process";
+import logger from "loglevel";
+
+const __dirname = contextDirname(import.meta.url);
+
+async function loadFiles(dirPath, prefix = "") {
+  const templateRoot = path.join(__dirname, "../../template/");
+  const templateDir = path.join(templateRoot, dirPath);
+
+  const _files = await glob(["**/*"], { cwd: templateDir });
+  let content;
+  let files = {};
+  for (let p of _files) {
+    const sourcePath = path.join(templateDir, p);
+
+    const statInfo = fs.statSync(sourcePath);
+    const mode = statInfo.mode;
+    if (isBinaryFileSync(sourcePath)) {
+      content = fs.readFileSync(sourcePath);
+    } else {
+      content = fs.readFileSync(sourcePath, "utf8");
+    }
+    // change _ prefix file into dot file
+    if (p.startsWith("_")) {
+      p = p.replace("_", ".");
+    }
+
+    files[path.join(prefix, p)] = {
+      content,
+      mode,
+    };
+  }
+  return files;
+}
+
+function writeFileTree(target, files) {
+  Object.keys(files).forEach((p) => {
+    const filePath = path.join(target, p);
+    if (!fs.existsSync(path.dirname(filePath))) {
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    }
+    logger.debug(`创建文件 ${filePath}`);
+    fs.writeFileSync(filePath, files[p].content, { mode: files[p].mode });
+  });
+}
+
+async function generate(type, to, opts = {}) {
+  const files = await loadFiles(type, opts.prefix);
+  writeFileTree(to, files);
+}
+
+function appendREADME(dir) {
+  const readme = path.resolve(dir, "README.md");
+  const readmeTemplate = path.resolve(
+    __dirname,
+    "../../template/_lpk/README.md"
+  );
+  if (!isFileExist(readme)) {
+    fs.copyFileSync(readmeTemplate, readme);
+  } else {
+    const contentStream = fs.readFileSync(readmeTemplate, {
+      encoding: "utf-8",
+    });
+    fs.writeFileSync(readme, contentStream, { flag: "a" });
+  }
+}
+
+function vueTemplate(type) {
+  const v = type == "vue3" ? "vue@3" : "vue@2";
+  return {
+    build: async (to, option) => {
+      spawnSync("npm", ["init", v, path.basename(to)], { stdio: "inherit" });
+    },
+    after: async function (name, cwd) {
+      spawnSync("npm", ["install"], {
+        cwd: path.resolve(cwd, name),
+        stdio: "inherit",
+      });
+
+      const lzcBuildTemplatePath = path.resolve(
+        __dirname,
+        `../../template/_lpk/vue.lzc-build.yml.in`
+      );
+      logger.debug("复制", lzcBuildTemplatePath);
+      fs.copyFileSync(
+        lzcBuildTemplatePath,
+        path.resolve(name, "lzc-build.yml")
+      );
+
+      const iconPngPath = path.resolve(
+        __dirname,
+        "../../template/_lpk/lazycat.png"
+      );
+      fs.copyFileSync(iconPngPath, path.resolve(name, "lazycat.png"));
+
+      // 更改默认的端口
+      const packageJson = path.resolve(name, "package.json");
+      const pkgInfo = JSON.parse(fs.readFileSync(packageJson));
+      pkgInfo["scripts"]["dev"] = `vite --port 3000 --host`;
+      fs.writeFileSync(packageJson, JSON.stringify(pkgInfo, null, "  "));
+
+      appendREADME(path.resolve(cwd, name));
+
+      console.log(
+        chalk.green(
+          `
+🚀 构建 lpk 包
+  ${chalk.yellow(`lzc-cli project build -o ${name}.lpk`)}
+⚙️ 将应用安装至设备中:
+  ${chalk.yellow(`lzc-cli app install ${name}.lpk`)}
+   `.trim()
+        )
+      );
+    },
+  };
+}
+
+export const TemplateConfig = {
+  vue3: vueTemplate("vue3"),
+  vue2: vueTemplate("vue2"),
+  lite: {
+    build: async (to, option) => {
+      await generate("lite", to, option);
+    },
+    after: async function (name, cwd) {
+      appendREADME(path.resolve(cwd, name));
+
+      console.log(
+        chalk.green(
+          `
+✨ 懒猫云应用 ${name} 已创建:
+  ${chalk.yellow(`cd ${name}`)}
+🚀 构建 lpk 包
+  ${chalk.yellow(`lzc-cli project build -o ${name}.lpk`)}
+⚙️ 将应用安装至设备中:
+  ${chalk.yellow(`lzc-cli app install ${name}.lpk`)}
+   `.trim()
+        )
+      );
+    },
+  },
+  ionic_vue3: {
+    build: async (to, option) => {
+      await generate("ionic_vue3", to, option);
+    },
+    after: async function (name, cwd) {
+      appendREADME(path.resolve(cwd, name));
+
+      console.log(chalk.green("开始安装依赖"));
+      spawnSync("npm", ["install"], {
+        cwd: path.join(cwd, name),
+        stdio: "inherit",
+      });
+
+      console.log(
+        chalk.green(
+          `
+✨ 懒猫云应用 ${name} 已创建:
+  ${chalk.yellow(`cd ${name}`)}
+  ${chalk.yellow(`npm run dev`)}
+🚀 构建 lpk 包
+  ${chalk.yellow(`lzc-cli project build -o ${name}.lpk`)}
+⚙️ 将应用安装至设备中:
+  ${chalk.yellow(`lzc-cli app install ${name}.lpk`)}
+📄 生成android代码:
+  ${chalk.yellow(`npm run build_android`)}
+📄 生成ios代码:
+  ${chalk.yellow(`npm run build_ios`)}
+   `.trim()
+        )
+      );
+    },
+  },
+  golang: {
+    build: async (to, option) => {
+      await generate("golang", to, option);
+    },
+    after: function (name, cwd) {
+      appendREADME(path.resolve(cwd, name));
+
+      console.log(
+        chalk.green(
+          `
+✨ 懒猫云应用 ${name} 已创建:
+  ${chalk.yellow(`cd ${name}`)}
+  ${chalk.yellow(`go run .`)}
+🚀 构建 lpk 包
+  ${chalk.yellow(`lzc-cli project build -o ${name}.lpk`)}
+⚙️ 将应用安装至设备中:
+  ${chalk.yellow(`lzc-cli app install ${name}.lpk`)}
+`.trim()
+        )
+      );
+    },
+  },
+};