@axeth/create-cli 2.1.5 → 3.0.0

package/.turbo/turbo-build.log

@@ -1,2 +1,14 @@
-[?9001h[?1004h[?25l$tsc
-]0;C:\WINDOWS\system32\cmd.exe[?25h[?9001l[?1004l
+[?9001h[?1004h[?25l$tsup ./src/index.ts
+]0;C:\WINDOWS\system32\cmd.exe[?25hCLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: C:\Users\KisuX3\Documents\Workspace\Axeth\packages\cli\tsup.config.ts
+CLI Target: es2020
+CLI Cleaning output folder
+ESM Build start
+ESM dist\index.js 11.13 KB
+ESM ⚡️ Build success in 25ms
+DTS Build start
+DTS ⚡️ Build success in 1080ms
+DTS dist\index.d.ts 19.00 B
+[?9001l[?1004l

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @axeth/create-cli
+
+## 3.0.0
+
+### Major Changes
+
+- db08190: Change tsc to tsup

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env bun

package/dist/index.js

@@ -0,0 +1,326 @@
+#!/usr/bin/env bun
+
+// src/class/AxethCLI.ts
+import * as prompt from "@clack/prompts";
+import color from "colors";
+
+// src/class/TemplateGenerators.ts
+import path from "path";
+import fs from "fs-extra";
+import { exec } from "child_process";
+var TemplateGenerators = class {
+  constructor() {
+    this.fileList = /* @__PURE__ */ new Map();
+    this.dependencies = [
+      "@axeth/api",
+      "@axeth/core",
+      "@minecraft/server",
+      "@minecraft/server-ui"
+    ];
+  }
+  registerFile(path3, content) {
+    this.fileList.set(path3, content);
+  }
+  getFiles() {
+    return this.fileList;
+  }
+  async generate(config, spinner2) {
+    spinner2.start("Preparing template pack files...");
+    const templateData = await fs.readJson(path.join(__dirname, "../data/templates.json"));
+    for (const [filePath, fileContent] of Object.entries(templateData)) {
+      let populatedContent = fileContent;
+      for (const [key, value] of Object.entries(config)) {
+        const placeholder = `{{${key}}}`;
+        let replacementValue;
+        let isNonStringValue = false;
+        if (Array.isArray(value)) {
+          replacementValue = JSON.stringify(value);
+          isNonStringValue = true;
+        } else if (typeof value === "object" && value !== null) {
+          replacementValue = JSON.stringify(value);
+          isNonStringValue = true;
+        } else if (typeof value === "number") {
+          replacementValue = value.toString();
+          isNonStringValue = true;
+        } else {
+          replacementValue = String(value);
+        }
+        if (isNonStringValue) {
+          populatedContent = populatedContent.split(`"${placeholder}"`).join(replacementValue);
+        } else {
+          populatedContent = populatedContent.split(placeholder).join(replacementValue);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+      this.registerFile(filePath, populatedContent);
+    }
+    spinner2.stop("Prepared template pack files.");
+    spinner2.start("Creating template pack files...");
+    for (const filePath of this.fileList.keys()) {
+      const fullPath = path.join(process.cwd(), config["project_name"], filePath);
+      const shortPath = filePath.split("/").slice(-5).join("/");
+      spinner2.message(`Creating file: ${shortPath}`);
+      await Bun.file(fullPath).write(this.fileList.get(filePath) || "");
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    spinner2.stop("Template pack files generated.");
+    spinner2.start("Installing dependencies...");
+    await this.installDependencies(config["project_name"], this.dependencies);
+    spinner2.stop("Dependencies installed.");
+  }
+  async runCommand(command, cwd) {
+    return new Promise((resolve, reject) => {
+      const options = {};
+      if (cwd) {
+        options.cwd = cwd;
+      }
+      exec(command, options, (error, stdout, stderr) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  async installDependencies(projectName, dependencies) {
+    const projectPath = path.join(process.cwd(), projectName || "");
+    const installCommand = `bun add ${dependencies ? dependencies.join(" ") : this.dependencies.join(" ")}`;
+    return await this.runCommand(installCommand, projectPath);
+  }
+};
+
+// src/class/AxethCLI.ts
+import path2 from "path";
+import { exec as exec2 } from "child_process";
+var AxethCLI = class {
+  constructor() {
+    this.promptGroups = {};
+    this.promptDefaults = {};
+    this.axethAPI = `@axeth/api`;
+    this.axethCore = `@axeth/core`;
+    console.clear();
+    this.template = new TemplateGenerators();
+    this.init();
+  }
+  async version() {
+    const url = new URL("../../package.json", import.meta.url);
+    const pkgData = await Bun.file(url).json();
+    return pkgData.version;
+  }
+  async init() {
+    const version = await this.version();
+    const addonInfo = await this.addonInfoPrompt(version, () => {
+      process.exit(0);
+    });
+    const config = await this.configPrompt();
+    const minecraftServerVersion = await this.getMinecraftServerVersion();
+    const minecraftServerUIVersion = await this.getMinecraftServerUIVersion();
+    const spinner2 = prompt.spinner({ indicator: "dots" });
+    await this.generateTemplate(
+      addonInfo,
+      config,
+      minecraftServerVersion,
+      minecraftServerUIVersion,
+      spinner2
+    );
+    const projectDir = path2.join(
+      process.cwd(),
+      addonInfo.addonName.replace(/\s+/g, "-").toLowerCase()
+    );
+    spinner2.start("Linting generated add-on...");
+    await this.runCommand("bun run lint", projectDir).catch((err) => {
+      spinner2.stop("Linting failed.");
+      console.error(color.red(err));
+      process.exit(1);
+    });
+    spinner2.stop("Add-on linted successfully.");
+    const openVSCode = await prompt.confirm({
+      message: "Open on VSCode?",
+      initialValue: false
+    });
+    if (openVSCode === true) {
+      spinner2.start("Opening VSCode...");
+      await this.runCommand(`code "${projectDir}"`);
+      spinner2.stop("VSCode opened.");
+    }
+    prompt.outro(
+      color.green(`
+  Successfully created add-on: ${addonInfo.addonName}
+`)
+    );
+  }
+  async generateTemplate(addonInfo, config, minecraftServerVersion, minecraftServerUIVersion, spinner2) {
+    await this.template.generate(
+      {
+        project_name: addonInfo.addonName.replace(/\s+/g, "-").toLowerCase(),
+        axethApiVersion: config.axethApiVersion,
+        pack_name: addonInfo.addonName,
+        pack_description: addonInfo.description,
+        author_name: addonInfo.authors.split(",").map((name) => name.trim()),
+        version: addonInfo.version.split(".").map((num) => parseInt(num, 10)),
+        seed: Math.floor(Math.random() * 1e6),
+        axethApiName: this.axethAPI,
+        axethCoreName: this.axethCore,
+        axethCoreVersion: config.axethCoreVersion,
+        minecraftServerUIVersion,
+        minecraftServerVersion
+      },
+      spinner2
+    );
+  }
+  async addonInfoPrompt(version, onCancel) {
+    return await new Promise((resolve) => {
+      this.registerIntro(
+        "\n    _            _   \n   /_\\  __ _____| |_ \n  / _ \\ \\ \\ / -_)  _|\n /_/ \\_\\/\\_\\_\\___|\\__|\n                     ",
+        "Axeth CLI",
+        version
+      );
+      this.registerPrompt("addonInfo", "addonName", "Add-on Name", "text", {
+        placeholder: "My-Addon"
+      });
+      this.registerPrompt("addonInfo", "description", "Description", "text", {
+        placeholder: "This addon create for Minecraft Bedrock (Axeth)"
+      });
+      this.registerPrompt("addonInfo", "version", "Version", "text", {
+        placeholder: "1.0.0"
+      });
+      this.registerPrompt("addonInfo", "authors", "Authors", "text", {
+        placeholder: "YourName,Axeth"
+      });
+      this.runPrompts("addonInfo", onCancel).then((responses) => {
+        resolve(responses);
+      });
+    });
+  }
+  async configPrompt() {
+    return new Promise(async (resolve) => {
+      const spinner2 = prompt.spinner({ indicator: "dots" });
+      spinner2.start("Fetching latest Axeth API version...");
+      const versions = await this.getAxethApiVersion();
+      spinner2.stop(`Fetched @axeth/api ${versions.length} versions.`);
+      this.registerPrompt(
+        "config",
+        "axethApiVersion",
+        "Select Axeth API version",
+        "select",
+        {
+          options: versions.slice(0, 10).map((ver) => ({ label: ver, value: ver })),
+          initial: versions[0]
+        }
+      );
+      const axethCoreVersion = await this.getAxethCoreVersion();
+      await this.runPrompts("config", () => {
+        process.exit(0);
+      }).then((response) => {
+        resolve({
+          axethApiVersion: response.axethApiVersion,
+          axethCoreVersion
+        });
+      });
+    });
+  }
+  async getMinecraftServerVersion() {
+    const moduleData = await fetch(
+      `https://registry.npmjs.org/@minecraft/server`
+    ).then((res) => res.json());
+    const distTag = moduleData["dist-tags"];
+    return distTag.latest;
+  }
+  async getMinecraftServerUIVersion() {
+    const moduleData = await fetch(
+      `https://registry.npmjs.org/@minecraft/server-ui`
+    ).then((res) => res.json());
+    const distTag = moduleData["dist-tags"];
+    return distTag.latest;
+  }
+  registerPrompt(groupId, key, message, type = "text", options = {}) {
+    if (!this.promptGroups[groupId]) this.promptGroups[groupId] = {};
+    this.promptDefaults[groupId] = this.promptDefaults[groupId] || {};
+    switch (type) {
+      case "text":
+        this.promptGroups[groupId][key] = () => prompt.text({ message, ...options });
+        this.promptDefaults[groupId][key] = options.placeholder || void 0;
+        break;
+      case "password":
+        this.promptGroups[groupId][key] = () => prompt.password({ message, ...options });
+        this.promptDefaults[groupId][key] = options.placeholder || void 0;
+        break;
+      case "confirm":
+        this.promptGroups[groupId][key] = () => prompt.confirm({ message, ...options });
+        this.promptDefaults[groupId][key] = options.initial || void 0;
+        break;
+      case "select":
+        this.promptGroups[groupId][key] = () => prompt.select({ message, ...options });
+        this.promptDefaults[groupId][key] = options.initial || void 0;
+        break;
+      case "multiselect":
+        this.promptGroups[groupId][key] = () => prompt.multiselect({ message, ...options });
+        this.promptDefaults[groupId][key] = options.initial || void 0;
+        break;
+      default:
+        throw new Error(`Unknown prompt type: ${type}`);
+    }
+  }
+  async getAxethCoreVersion() {
+    const moduleData = await fetch(
+      `https://registry.npmjs.org/${this.axethCore}`
+    ).then((res) => res.json());
+    const versions = Object.keys(moduleData.versions);
+    return versions.reverse()[0];
+  }
+  async getAxethApiVersion() {
+    const moduleData = await fetch(
+      `https://registry.npmjs.org/${this.axethAPI}`
+    ).then((res) => res.json());
+    const versions = Object.keys(moduleData.versions);
+    return versions.reverse();
+  }
+  async runPrompts(groupId, onCancel) {
+    if (!this.promptGroups[groupId] || Object.keys(this.promptGroups[groupId]).length === 0) {
+      throw new Error(`No prompts to run for group: ${groupId}`);
+    }
+    const responses = {};
+    for (const key of Object.keys(this.promptGroups[groupId])) {
+      const response = await this.promptGroups[groupId][key]();
+      if (String(response).includes("clack:cancel")) {
+        prompt.cancel("Operation cancelled.");
+        if (onCancel) onCancel();
+        return {};
+      }
+      if (response === void 0) {
+        if (this.promptDefaults[groupId] && this.promptDefaults[groupId][key] !== void 0) {
+          responses[key] = this.promptDefaults[groupId][key];
+        } else {
+          responses[key] = void 0;
+        }
+      } else {
+        responses[key] = response;
+      }
+    }
+    return responses;
+  }
+  registerIntro(logo, title, version) {
+    prompt.intro(color.cyan(logo) + `
+   ${title} - v${version}
+`);
+  }
+  async runCommand(command, cwd) {
+    return new Promise((resolve, reject) => {
+      const options = {};
+      if (cwd) {
+        options.cwd = cwd;
+      }
+      exec2(command, options, (error, stdout, stderr) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+};
+
+// src/index.ts
+new AxethCLI();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@axeth/create-cli",
-  "version": "2.1.5",
-  "module": "index.ts",
+  "version": "3.0.0",
+  "module": "dist/index.js",
   "type": "module",
   "bin": {
     "axeth-cli": "index.ts"
@@ -9,8 +9,14 @@
   "publishConfig": {
     "access": "public"
   },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "scripts": {
-    "build": "tsc",
+    "build": "tsup ./src/index.ts",
     "prepublishOnly": "bun run build"
   },
   "keywords": [