mbler 0.2.0 → 0.2.2

package/dist/build.esm.js

@@ -0,0 +1,1312 @@
+import * as mcxDef from '@mbler/mcx-core';
+import _chalk from 'chalk';
+import jsonPlugin from '@rollup/plugin-json';
+import resolvePlugin from '@rollup/plugin-node-resolve';
+import minifyPlugin from '@rollup/plugin-terser';
+import { watch as watch$1 } from 'chokidar';
+import * as fs from 'node:fs/promises';
+import fs__default from 'node:fs/promises';
+import * as path from 'node:path';
+import path__default, { isAbsolute } from 'node:path';
+import * as rollup from 'rollup';
+import * as readline from 'readline';
+import os, { tmpdir } from 'node:os';
+import { json } from 'npm-registry-fetch';
+import 'node:child_process';
+import crypto from 'node:crypto';
+import * as fs$1 from 'node:fs';
+import { env } from 'node:process';
+import AdmZip from 'adm-zip';
+import commonjs from '@rollup/plugin-commonjs';
+import { createMCXLanguagePlugin } from '@mbler/mcx-server';
+import typescript from '@rollup/plugin-typescript';
+import { runTsc } from '@volar/typescript/lib/quickstart/runTsc';
+
+// 启用 raw mode 和键盘事件（仅在 TTY 环境中）
+if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    readline.emitKeypressEvents(process.stdin);
+}
+const promises = [];
+const tasks = [];
+process.on("exit", (code) => {
+    process.stdout.write("\x1b[?25h");
+});
+const endTasks = [];
+function onEnd(task) {
+    endTasks.push(task);
+}
+click("c", {
+    ctrl: true,
+}).then(() => {
+    endTasks.forEach((task) => task());
+    process.exit(0);
+});
+/**
+ * 监听键盘输入并触发对应的 Promise 或任务
+ */
+function handler(name, { ctrl, alt, }, raw) {
+    // 查找是否有匹配的 Promise 等待触发
+    const find = promises.find((e) => e.name === name && e.ctrl === ctrl && e.alt === alt);
+    if (find) {
+        find.resolve();
+        promises.splice(promises.indexOf(find), 1);
+    }
+    // 通知所有注册的监听任务
+    tasks.forEach((item) => item(name, ctrl, alt, raw));
+}
+/**
+ * 模拟等待某个按键被按下，返回一个 Promise
+ */
+function click(name, { ctrl = false, alt = false, }) {
+    return new Promise((resolve) => {
+        promises.push({
+            name,
+            ctrl: ctrl || false,
+            alt: alt || false,
+            resolve,
+        });
+    });
+}
+/**
+ * 工具类：提供控制台交互功能，比如高亮菜单渲染、交互式选择等
+ */
+class Input {
+    /**
+     * 渲染一个字符串数组，高亮当前选中的项
+     * @param arr 菜单项数组
+     * @param index 当前选中索引
+     * @returns 格式化后的字符串
+     */
+    static render(arr, index) {
+        return arr
+            .map((item, pindex) => {
+            if (pindex === index)
+                return "\x1b[1m\x1b[32m" + item + "\x1b[0m"; // 亮绿，高亮
+            return "\x1b[1m\x1b[33m" + item + "\x1b[0m"; // 亮黄
+        })
+            .join("     ");
+    }
+    /**
+     * 提供一个交互式菜单选择器
+     * @param tip 提示文本
+     * @param arr 选项数组
+     * @returns 用户选中的选项内容（Promise<string>）
+     */
+    static select(tip, arr) {
+        let index = 0;
+        let win = false;
+        console.log(`\x1b[2K\x1b[47m\x1b[1m\x1b[30m${tip} (按 b 确认，n 键选择下一个)   \x1b[0m\x1b[?25l`);
+        console.log(Input.render(arr, index) + "\n\x1b[1A");
+        const handlerNext = () => {
+            if (win)
+                return;
+            index++;
+            if (index >= arr.length)
+                index = 0;
+            console.log(`\x1b[1A${Input.render(arr, index)}\n\x1b[1A`);
+            click("n", {
+                ctrl: false,
+                alt: false,
+            }).then(handlerNext);
+        };
+        return new Promise((resolve) => {
+            // 监听 n 按键来切换选项
+            click("n", {
+                ctrl: false,
+                alt: false,
+            }).then(handlerNext);
+            // 监听 b 按键来确认选择
+            click("b", {
+                ctrl: false,
+                alt: false,
+            }).then(() => {
+                win = true;
+                process.stdout.write("\x1b[?25h");
+                resolve(arr[index]);
+            });
+        });
+    }
+    /**
+     * 注册一个全局任务，每次按键都会被调用
+     * @param task 回调函数
+     */
+    static use(task) {
+        tasks.push(task);
+    }
+}
+// 监听键盘输入事件
+process.stdin.on("keypress", (str, key) => {
+    const rawKeyName = key?.name || "";
+    const ctrl = Boolean(key?.ctrl);
+    const alt = Boolean(key?.alt);
+    handler(rawKeyName, {
+        ctrl,
+        alt,
+    }, str);
+});
+
+const templateMblerConfig = {
+    name: 'demo',
+    description: 'demo',
+    version: '0.0.0',
+    mcVersion: '1.21.100',
+    script: {
+        main: '',
+    },
+    minify: false,
+    outdir: {
+        behavior: '',
+        resources: '',
+        dist: '',
+    },
+};
+
+const BuildConfig = {
+    ConfigFile: "mbler.config.js",
+    salt: {
+        header: "d61e721d-a2c9-4535-8054-0183bce24767",
+        sapi: "33e2c698-908f-45ab-8a9f-66018f8486ed",
+        module: "cbbacfa4-8b1e-4a9c-9cbd-7a0d2e5f0b3c",
+    },
+    behavior: "behavior",
+    resources: "resources",
+    includes: {
+        public: {
+            "pack_icon.png": "file",
+            "manifest.json": "file",
+        },
+        resources: {
+            "biomes_client.json": "file",
+            "blocks.json": "file",
+            "bug_pack_icon.png": "file",
+            "contents.json": "file",
+            "loading_messages.json": "file",
+            "manifest_publish.json": "file",
+            "signatures.json": "file",
+            "sounds.json": "file",
+            "splashes.json": "file",
+            animation_controllers: "directory",
+            animations: "directory",
+            attachables: "directory",
+            biomes: "directory",
+            cameras: "directory",
+            entity: "directory",
+            fogs: "directory",
+            font: "directory",
+            items: "directory",
+            library: "directory",
+            materials: "directory",
+            models: "directory",
+            particles: "directory",
+            render_controllers: "directory",
+            sounds: "directory",
+            texts: "directory",
+            textures: "directory",
+        },
+        behavior: {
+            aim_assist: "directory",
+            animation_controllers: "directory",
+            animations: "directory",
+            behavior_trees: "directory",
+            biomes: "directory",
+            blocks: "directory",
+            cameras: "directory",
+            dimensions: "directory",
+            entities: "directory",
+            feature_rules: "directory",
+            features: "directory",
+            functions: "directory",
+            item_catalog: "directory",
+            items: "directory",
+            loot_tables: "directory",
+            recipes: "directory",
+            scripts: "skip", // special handling
+            spawn_rules: "directory",
+            structures: "directory",
+            texts: "directory",
+            trading: "directory",
+            worldgen: "directory",
+            "contents.json": "file",
+            "manifest_publish.json": "file",
+            "signatures.json": "file",
+        },
+    },
+};
+
+async function FileExsit(file) {
+    try {
+        const f = await fs.stat(file);
+        if (f)
+            return true;
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+function join(baseDir, inputPath) {
+    return path.isAbsolute(inputPath) ? inputPath : path.join(baseDir, inputPath);
+}
+async function ReadProjectMblerConfig(project) {
+    const fileExport = await import(path.join(project, BuildConfig.ConfigFile));
+    const file = fileExport.default || {};
+    for (const key in file) {
+        if (!(key in templateMblerConfig)) {
+            throw new Error(`[read config]: read config from '${project}' error: Unexpected '${key}'`);
+        }
+    }
+    return file;
+}
+/**
+ * Print a single-line message to stdout with a trailing newline.
+ * Exported here so other modules (for example `build`) do not need
+ * to import from `cli`, avoiding a circular dependency.
+ */
+// IO缓冲队列，避免多线程写入冲突
+let outputQueue = [];
+let isFlushing = false;
+async function flushOutputQueue() {
+    if (isFlushing || outputQueue.length === 0)
+        return;
+    isFlushing = true;
+    try {
+        while (outputQueue.length > 0) {
+            const chunk = outputQueue.shift();
+            if (chunk) {
+                process.stdout.write(chunk);
+            }
+        }
+    }
+    finally {
+        isFlushing = false;
+    }
+}
+process.on("exit", flushOutputQueue);
+function showText(text, needNextLine = true) {
+    outputQueue.push(text + (needNextLine ? '\n' : ""));
+    if (!isFlushing) {
+        Promise.resolve().then(() => flushOutputQueue()).catch(() => {
+            outputQueue = [];
+            isFlushing = false;
+        });
+    }
+}
+function stringToNumberArray(str) {
+    return str
+        .split('.')
+        .map((s) => parseInt(s, 10))
+        .slice(0, 3);
+}
+async function writeJSON(filePath, data) {
+    const content = JSON.stringify(data, null, 2);
+    if (!(await FileExsit(path.dirname(filePath)))) {
+        await fs
+            .mkdir(path.dirname(filePath), { recursive: true })
+            .catch(() => void 0);
+    }
+    return await fs.writeFile(filePath, content, 'utf-8');
+}
+function compareVersion(a, b) {
+    const pa = a.split('.').map((x) => parseInt(x, 10) || 0);
+    const pb = b.split('.').map((x) => parseInt(x, 10) || 0);
+    for (let i = 0; i < 3; i++) {
+        const na = pa[i] || 0;
+        const nb = pb[i] || 0;
+        if (na !== nb)
+            return na - nb;
+    }
+    return 0;
+}
+((function () {
+    let curr;
+    let currstr = '';
+    let tip = '';
+    let show = true;
+    // 在输入时使用输入中间件
+    Input.use(function (raw, ctrl, alt, name) {
+        if (typeof curr !== 'function')
+            return;
+        if (ctrl || alt)
+            return;
+        if (raw) {
+            if (raw === 'return' || raw === 'enter') {
+                curr(currstr);
+                curr = null;
+                currstr = '';
+                console.log('');
+                return;
+            }
+            if (raw === 'backspace') {
+                currstr = currstr.slice(0, -1);
+                refreshInput();
+                return;
+            }
+        }
+        if (name && typeof name === 'string') {
+            currstr += name;
+            refreshInput();
+        }
+    });
+    function refreshInput() {
+        const out = `\x1b[2K\r${tip}${show ? currstr : ''}`;
+        process.stdout.write(out);
+    }
+    /**
+     * 输入文本
+     * @param{string} tip 提示
+     * @param{boolean} show 是否显示输入
+     */
+    return async function (t = '', g = true) {
+        return new Promise((resolve) => {
+            show = g;
+            tip = t;
+            refreshInput();
+            curr = resolve;
+        });
+    };
+}))();
+
+const logFile = path__default.join(os.homedir(), ".cache/mbler/latest.log");
+function _clean(promise) {
+    return () => {
+        Logger.run = Logger.run.filter((item) => {
+            return item !== promise;
+        });
+    };
+}
+function writeLog(logContent) {
+    async function write() {
+        try {
+            const dir = path__default.dirname(logFile);
+            if (!(await FileExsit(dir))) {
+                // ensure the directory exists, root-to-leaf
+                await fs__default.mkdir(dir, { recursive: true }).catch(() => void 0);
+            }
+            // if file does not exist, create it (touch)
+            if (!(await FileExsit(logFile))) {
+                await fs__default.writeFile(logFile, "");
+            }
+        }
+        catch (err) {
+            // if we can't prepare the log file, output to stderr but don't crash
+            console.error("[logger] unable to prepare log file:", err);
+            return;
+        }
+        try {
+            await fs__default.appendFile(logFile, "\n" + logContent);
+        }
+        catch (err) {
+            console.error("[logger] failed to append to log file:", err);
+        }
+    }
+    const asy = write();
+    Logger.run.push(asy.then(_clean(asy)));
+}
+class Logger {
+    // 写入日志池
+    static LogFile = logFile;
+    static run = [];
+    static _b(tag, msg, t) {
+        const date = new Date();
+        const logContent = [
+            `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`,
+            `[${t} ${tag}]`,
+            msg,
+        ].join(" ");
+        writeLog(logContent);
+    }
+    static w(tag, msg) {
+        Logger._b(tag, msg, "WARN");
+    }
+    static e(tag, msg) {
+        Logger._b(tag, msg, "ERROR");
+    }
+    static i(tag, msg) {
+        Logger._b(tag, msg, "INFO");
+    }
+    static d(tag, msg) {
+        Logger._b(tag, msg, "DEBUG");
+    }
+}
+
+// 该模块用于从字符串生成哈希转 uuid
+const fromString = (input, salt = '') => {
+    const combinedInput = salt + input;
+    const hash = crypto
+        .createHash('sha256')
+        .update(combinedInput)
+        .digest('hex');
+    const base = hash
+        .slice(0, 32); // 取前 32 个 hex 字符（16 字节）
+    const ls = '89ab';
+    const r = (t) => ls[(combinedInput.length + t + salt.length) % ls.length];
+    // 构造成标准 UUID v4 格式：xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
+    const uuid = `${base.substring(0, 8)}-${base.substring(8, 12)}-4${base.substring(12, 15)}-8${r(1)}${r(2)}${r(3)}-${base.substring(18, 30)}`;
+    return uuid;
+};
+({
+    uuid: crypto.randomUUID
+});
+
+const config = {
+    tmpdir: path.join(tmpdir(), ".mbler")};
+
+/**
+ * Compare two dotted version strings ("major.minor.patch").
+ * Returns negative if a < b, positive if a > b, zero if equal.
+ */
+const exp = (function () {
+    const cacheFile = path.join(config.tmpdir, "_sapi_version.json");
+    // cacheData is an array of entries keyed by the embedded mc version string
+    let cacheData = null;
+    /**
+     * Pull every published version for a package and reduce it to a mapping
+     * from the embedded Minecraft version (e.g. "1.21.60") to the most
+     * recent formal/beta release we were able to parse.
+     */
+    async function fetchData(pkgName) {
+        const data = (await json(`/${pkgName}`));
+        const pkgVersions = Object.keys(data.versions);
+        const reValue = {};
+        // helper to extract the embedded MC version ("yyyy") from a full
+        // npm package version string. returns null when the expected pattern
+        // cannot be found.
+        const mcVersionFrom = (str) => {
+            const m = str.match(/-(?:rc|beta)(?:\.[^-.]+)*?\.((?:\d+\.){2}\d+)/);
+            return m ? m[1] : null;
+        };
+        for (const v of pkgVersions) {
+            const mcVersion = mcVersionFrom(v);
+            if (!mcVersion)
+                continue;
+            const isStable = /(?:-stable)(?:$|[-.])/.test(v);
+            let entry = reValue[mcVersion];
+            if (!entry) {
+                entry = { formal: "", beta: "", _v: -1 };
+                reValue[mcVersion] = entry;
+            }
+            if (isStable) {
+                // pick the lexically greatest stable version string
+                if (!entry.formal || v > entry.formal) {
+                    entry.formal = v;
+                }
+                entry._v = Infinity;
+            }
+            else {
+                // non-stable release; treat everything else as a beta candidate
+                if (!entry.beta || v > entry.beta) {
+                    entry.beta = v;
+                }
+                if (entry._v !== Infinity)
+                    entry._v = 1;
+            }
+        }
+        return reValue;
+    }
+    async function refresh() {
+        // grab the two packages we care about and merge the keys
+        const serverMap = await fetchData("@minecraft/server");
+        const uiMap = await fetchData("@minecraft/server-ui");
+        const versions = new Set([
+            ...Object.keys(serverMap),
+            ...Object.keys(uiMap),
+        ]);
+        const arr = [];
+        for (const ver of Array.from(versions)) {
+            arr.push({
+                version: ver,
+                server: serverMap[ver]
+                    ? { formal: serverMap[ver].formal, beta: serverMap[ver].beta }
+                    : { formal: "", beta: "" },
+                "server-ui": uiMap[ver]
+                    ? { formal: uiMap[ver].formal, beta: uiMap[ver].beta }
+                    : { formal: "", beta: "" },
+            });
+        }
+        arr.sort((a, b) => compareVersion(a.version, b.version));
+        cacheData = arr;
+        await fs$1.promises
+            .mkdir(config.tmpdir, { recursive: true })
+            .catch(() => void 0);
+        await fs$1.promises.writeFile(cacheFile, JSON.stringify(arr, null, 2), "utf-8");
+    }
+    async function generateVersion(module, mcVersion, isBeta) {
+        if (!cacheData) {
+            try {
+                const txt = await fs$1.promises.readFile(cacheFile, "utf-8");
+                cacheData = JSON.parse(txt);
+            }
+            catch {
+                await refresh();
+            }
+        }
+        if (!cacheData) {
+            throw new Error("unable to load sapi cache data");
+        }
+        // try exact match first
+        let entry = cacheData.find((e) => e.version === mcVersion);
+        if (!entry) {
+            // find closest entry less than or equal to requested version
+            const sorted = cacheData.slice();
+            let candidate = null;
+            for (const e of sorted) {
+                if (compareVersion(e.version, mcVersion) <= 0) {
+                    candidate = e;
+                }
+                else {
+                    break;
+                }
+            }
+            if (!candidate) {
+                candidate = sorted[0];
+            }
+            entry = candidate;
+        }
+        const moduleKey = module === "@minecraft/server" ? "server" : "server-ui";
+        const entryModule = entry[moduleKey];
+        let result = isBeta ? entryModule.beta : entryModule.formal;
+        if (!result) {
+            // fall back to whatever is available
+            result = entryModule.formal || entryModule.beta;
+        }
+        return result || "";
+    }
+    return {
+        refresh,
+        generateVersion,
+    };
+})();
+
+async function generateManifest(config, type) {
+    const manifest = {
+        format_version: 2,
+        header: {
+            name: config.name,
+            description: config.description,
+            uuid: fromString(config.name, BuildConfig.salt.header + type),
+            version: stringToNumberArray(config.version),
+            min_engine_version: stringToNumberArray(typeof config.mcVersion === "string"
+                ? config.mcVersion
+                : (() => {
+                    throw new Error("mcVersion in mblerconfig should be a string");
+                })()),
+        },
+        modules: [
+            {
+                type: type,
+                uuid: fromString(config.name, BuildConfig.salt.module + type),
+                description: `From Mbler(https://github.com/RuanhoR/mbler). welcome to star and contribute!`,
+                version: stringToNumberArray(config.version),
+            },
+        ],
+    };
+    if (type === "data" && config.script) {
+        manifest.modules.push({
+            type: "script",
+            uuid: fromString(config.name, BuildConfig.salt.sapi + type),
+            description: `sapi generate by mbler, weclome to download and star at https://github.com/RuanhoR/mbler`,
+            version: stringToNumberArray(config.version),
+        });
+        manifest.capabilities = ["script_eval"];
+        manifest.dependencies = [
+            {
+                module_name: "@minecraft/server",
+                version: (await exp.generateVersion("@minecraft/server", config.mcVersion, config.script?.UseBeta || false)).split("-")[0], // only major.minor.patch, remove -beta or -rc
+            },
+        ];
+        if (config.script.ui) {
+            manifest.dependencies.push({
+                module_name: "@minecraft/server-ui",
+                version: (await exp.generateVersion("@minecraft/server-ui", config.mcVersion, config.script?.UseBeta || false)).split("-")[0], // only major.minor.patch, remove -beta or -rc
+            });
+        }
+    }
+    return manifest;
+}
+
+function createFullZip(dir) {
+    const zip = new AdmZip();
+    zip.addLocalFolder(dir);
+    return zip;
+}
+async function createZipWithMoreFolder(dir) {
+    const zip = new AdmZip();
+    for (const folder of dir) {
+        await zip.addLocalFolderPromise(folder[0], {
+            zipPath: folder[1]
+        });
+    }
+    return zip;
+}
+async function generateRelease(build) {
+    if (!build.srcDirs)
+        throw new Error("invaild Build");
+    if (env.BUILD_MODULE !== "release")
+        return;
+    let zip;
+    if (build.module == "all") {
+        zip = await createZipWithMoreFolder([
+            [build.srcDirs?.behavior, "behavior"],
+            [build.srcDirs.resources, "resources"]
+        ]);
+    }
+    else if (build.module == "behavior") {
+        zip = createFullZip(build.srcDirs.behavior);
+    }
+    else {
+        zip = createFullZip(build.srcDirs.resources);
+    }
+    await zip.writeZipPromise(build.outdirs?.dist);
+}
+
+// cjs support
+const chalk$1 = _chalk instanceof Function ? _chalk : _chalk.default;
+class Postgress {
+    max;
+    constructor(max) {
+        this.max = max;
+    }
+    update(current) {
+        const percentage = Math.min(current, this.max) / this.max;
+        const barWidth = 30;
+        const filledWidth = Math.round(barWidth * percentage);
+        const emptyWidth = barWidth - filledWidth;
+        const filledBar = chalk$1.green('█'.repeat(filledWidth));
+        const emptyBar = chalk$1.white('█'.repeat(emptyWidth));
+        const progressBar = `${filledBar}${emptyBar}`;
+        const percentText = chalk$1.blue(`${Math.round(percentage * 100)}%`);
+        const progressText = `\n\u001B[1A\r[${progressBar}] ${percentText} (${current}/${this.max})`;
+        showText(progressText, false);
+        if (current == this.max) {
+            showText("", true);
+        }
+    }
+}
+
+/**
+ * 运行 MCX TypeScript 编译器
+ * 为 .mcx 文件提供 TypeScript 类型检查支持
+ */
+function runTSC(tscpath = require.resolve("typescript/lib/tsc")) {
+    runTsc(tscpath, {
+        extraSupportedExtensions: ['.mcx'],
+        extraExtensionsToRemove: ['.mcx'],
+    }, (ts) => {
+        return [createMCXLanguagePlugin(ts)];
+    });
+}
+
+// cjs support
+const chalk = _chalk instanceof Function ? _chalk : _chalk.default;
+class Build {
+    baseBuildDir;
+    resolve;
+    isWatch;
+    currentConfig = null;
+    srcDirs = null;
+    outdirs = null;
+    mcxTs;
+    mcxLanguagePluginCreator = null;
+    constructor(opts, baseBuildDir, resolve, isWatch = false) {
+        this.baseBuildDir = baseBuildDir;
+        this.resolve = resolve;
+        this.isWatch = isWatch;
+        // 初始化 MCX 语言插件创建器，传入 tsHook.ts 使用
+        try {
+            const tsModule = require("typescript");
+            this.mcxLanguagePluginCreator = createMCXLanguagePlugin;
+            this.mcxTs = tsModule;
+            Logger.i("Build", "MCX Volar language plugin creator initialized successfully");
+        }
+        catch (error) {
+            this.mcxTs = require("typescript");
+            Logger.w("Build", `Failed to initialize MCX language plugin: ${error}`);
+        }
+    }
+    /**
+     * Start the watch mode.
+     * This will perform an initial build (if not already done) and then
+     * start filesystem and rollup watchers.
+     * Returns the watcher handles once they are created so that callers
+     * (for example tests) can clean them up later.
+     */
+    async watch() {
+        try {
+            onEnd(() => {
+                if (this.watchers) {
+                    this.watchers.chokidar.close();
+                    this.watchers.rollup.close();
+                }
+            });
+            await this._watch();
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                Logger.e('Watcher', e.stack || e.message);
+            }
+            else {
+                Logger.e('Watcher', e + '');
+            }
+            showText('MBLER__ERR__WATCHER: ' + e + ' Log at ' + Logger.LogFile);
+            this.resolve(1);
+            return null;
+        }
+    }
+    async start() {
+        try {
+            return await this.build();
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                Logger.e('Build', e.stack || e.message);
+            }
+            else {
+                Logger.e('Build', e + '');
+            }
+            showText('MBLER__ERR__BUILD: ' + e.stack + ' Log at ' + Logger.LogFile);
+            this.resolve(1);
+        }
+    }
+    /**
+     * Handles returned from the currently-active watchers.
+     * Set by {@link createWatcher} and exposed via {@link getWatchers}
+     * so that external callers can close them when necessary (e.g. tests).
+     */
+    watchers = null;
+    /**
+     * Returns the watcher handles if watch mode has been started.
+     * Can be safely called even before `watch()` has been invoked.
+     */
+    getWatchers() {
+        return this.watchers;
+    }
+    /**
+     * Close any active watchers.  The build process does not automatically
+     * terminate the watchers unless the process exits; tests or CLI wrappers
+     * can call this method to clean up resources.
+     */
+    closeWatchers() {
+        if (this.watchers) {
+            this.watchers.chokidar.close();
+            this.watchers.rollup.close();
+            this.watchers = null;
+        }
+    }
+    rollupPlugin = null;
+    init = false;
+    /**
+     * Which modules are present in the current project.
+     * - "behavior" when only behavior code exists
+     * - "resources" when only resource files exist
+     * - "all" when both are present
+     * This field is populated during `handlerOtherAddon`.
+     */
+    module = null;
+    /**
+     * Determine whether a path refers to a regular file or a directory.
+     * Follows symbolic links recursively.  Throws if the path exists but
+     * is not one of the expected types.
+     *
+     * @param filePath file system path to inspect
+     * @returns "file" or "directory"
+     */
+    async fileType(filePath) {
+        const stat = await fs.lstat(filePath);
+        if (stat.isFile()) {
+            return 'file';
+        }
+        if (stat.isDirectory()) {
+            return 'directory';
+        }
+        if (stat.isSymbolicLink()) {
+            return await this.fileType(await fs.readlink(filePath));
+        }
+        throw new Error('[build addon]: invaild file type');
+    }
+    /**
+     * Perform a single build of the project located at {@link baseBuildDir}.
+     * The process is roughly:
+     * 1. load and validate the configuration file
+     * 2. prepare source and output directory information
+     * 3. copy addon files (behavior/resources)
+     * 4. generate manifest.json files
+     * 5. run rollup to bundle any script entry point
+     *
+     * If anything goes wrong the promise returned by the public wrapper
+     * (`build()` function exported at the bottom of this file) will be
+     * resolved with a non-zero code and appropriate log entries will be
+     * emitted.
+     */
+    async build() {
+        const progress = new Postgress(100);
+        this.init = true;
+        if (!isAbsolute(this.baseBuildDir)) {
+            throw new Error('[init build]: build dir is not absolute path');
+        }
+        this.currentConfig = await ReadProjectMblerConfig(this.baseBuildDir);
+        this.loadData();
+        if (!this.isWatch)
+            progress.update(10);
+        await this.handlerOtherAddon();
+        await this.handlerManifest();
+        if (!this.isWatch)
+            progress.update(30);
+        const rBuild = (await this.createRollup());
+        if (!this.rollupPlugin || !this.outdirs) {
+            throw new Error(`[build addon]: can't resolve rollup instance`);
+        }
+        if (!this.isWatch)
+            progress.update(50);
+        // write script
+        let output = this.currentConfig.script?.main;
+        if (!output)
+            output = "index.js";
+        if (path__default.extname(output) !== "js")
+            output = output.slice(0, output.length - path__default.extname(output).length) + ".js";
+        if (this.currentConfig.script)
+            await rBuild.write({
+                file: join(path__default.join(this.outdirs.behavior, "scripts"), output),
+                format: 'esm',
+                sourcemap: false,
+            });
+        if (!this.isWatch)
+            progress.update(70);
+        await generateRelease(this);
+        if (!this.isWatch)
+            progress.update(80);
+        if (!this.isWatch)
+            this.resolve(0);
+        if (!this.isWatch)
+            progress.update(100);
+    }
+    /**
+     * Create and return a Rollup build instance configured for the
+     * project's script.  The Rollup configuration mirrors the options
+     * used by the CLI when running manual builds.
+     *
+     * Returns undefined if the project does not define a script section
+     * (in which case nothing needs to be bundled).
+     */
+    async createRollup() {
+        if (!this.currentConfig || !this.srcDirs || !this.outdirs)
+            throw new Error(`[build addon]: can't first can this method`);
+        if (!this.currentConfig.script)
+            return;
+        const main = path__default.join(this.srcDirs.behavior, 'scripts', this.currentConfig.script.main);
+        if (!(await FileExsit(main))) {
+            throw new Error(`[build addon]: main script ${main} is not exist: can't resolve entry`);
+        }
+        const plugin = [
+            jsonPlugin(),
+            resolvePlugin({
+                extensions: ['.ts', '.js', '.json'],
+            }),
+            commonjs()
+        ];
+        const moduleDir = path__default.join(this.baseBuildDir, 'node_modules');
+        if (!(await FileExsit(moduleDir))) {
+            throw new Error(`[build addon]: node_modules is not exist in project root: can't resolve node_modules for rollup: ${moduleDir}`);
+        }
+        if (this.currentConfig.minify) {
+            plugin.push(minifyPlugin({
+                format: {
+                    comments: false,
+                },
+                compress: {
+                    unused: true,
+                },
+            }));
+        }
+        if (this.currentConfig.script.lang == "ts") {
+            const tsconfigPath = path__default.join(this.baseBuildDir, 'tsconfig.json');
+            if (!(await FileExsit(tsconfigPath))) {
+                throw new Error(`[build addon]: ts-lang: tsconfig.json is not exist in project root: can't resolve tsconfig for rollup: ${tsconfigPath}`);
+            }
+            plugin.push(typescript({
+                sourceMap: false,
+                tsconfig: tsconfigPath,
+                exclude: [
+                    this.outdirs.behavior,
+                    this.outdirs.resources
+                ],
+                include: [
+                    this.srcDirs.behavior
+                ]
+            }));
+        }
+        if (this.currentConfig.script?.lang == 'mcx') {
+            try {
+                const tsconfigPath = path__default.join(this.baseBuildDir, 'tsconfig.json');
+                if (!(await FileExsit(tsconfigPath))) {
+                    throw new Error(`[build addon]: ts-lang: tsconfig.json is not exist in project root: can't resolve tsconfig for rollup: ${tsconfigPath}`);
+                }
+                const pluginConfig = {
+                    moduleDir: moduleDir,
+                    tsconfigPath: tsconfigPath,
+                    sourcemap: false,
+                    ts: this.mcxTs,
+                    mcxLanguagePlugin: this.mcxLanguagePluginCreator
+                };
+                if (this.mcxLanguagePluginCreator) {
+                    pluginConfig.mcxLanguagePlugin = this.mcxLanguagePluginCreator;
+                }
+                plugin.push(mcxDef.plugin(pluginConfig, this.outdirs));
+            }
+            catch (err) {
+                throw new Error(`[build addon]: mcx plugin is required but '@mbler/mcx-core' could not be loaded: ${err}`);
+            }
+        }
+        // save plugin array for watcher re-use
+        this.rollupPlugin = plugin;
+        return await rollup.rollup({
+            input: main,
+            external: ['@minecraft/server', '@minecraft/server-ui'],
+            plugins: plugin,
+        });
+    }
+    /**
+     * Internal helper invoked by {@link watch}.
+     * Ensures a build has been run before starting the watchers.
+     */
+    async _watch() {
+        // init build
+        if (!this.init) {
+            await this.build();
+        }
+        this.createWatcher();
+        // watchers field is populated by createWatcher
+    }
+    isParent(parent, dir) {
+        const relative = path__default.relative(parent, dir);
+        return (!!relative && !relative.startsWith('..') && !path__default.isAbsolute(relative));
+    }
+    isChange(oldObj, newObj, checkKeys) {
+        for (const key of checkKeys) {
+            if (typeof oldObj[key] === 'object' &&
+                typeof newObj[key] === 'object' &&
+                oldObj[key] !== null &&
+                newObj[key] !== null) {
+                if (this.isChange(oldObj[key], newObj[key], Object.getOwnPropertyNames(oldObj[key]))) {
+                    return true;
+                }
+            }
+            else if (oldObj[key] !== newObj[key]) {
+                return true;
+            }
+        }
+        return false;
+    }
+    createRollupWatcher() {
+        if (!this.srcDirs ||
+            !this.outdirs ||
+            !this.currentConfig ||
+            !this.rollupPlugin)
+            throw new Error(`[build addon]: can't first can this method`);
+        let output = this.currentConfig.script?.main;
+        if (!output)
+            output = "index.js";
+        if (path__default.extname(output) !== "js")
+            output = output.slice(0, output.length - path__default.extname(output).length) + ".js";
+        const rollupWatcher = rollup.watch({
+            input: path__default.join(this.srcDirs.behavior, 'scripts', this.currentConfig?.script?.main || ''),
+            external: ['@minecraft/server', '@minecraft/server-ui'],
+            plugins: this.rollupPlugin,
+            output: {
+                file: join(path__default.join(this.outdirs.behavior, "scripts"), output),
+                format: 'esm',
+                sourcemap: false,
+            },
+            cache: true,
+            watch: {
+                clearScreen: false,
+                include: path__default.join(this.srcDirs.behavior, 'scripts/**/*'),
+                exclude: [
+                    path__default.join(this.baseBuildDir, 'node_modules/**/*'),
+                    this.outdirs.behavior,
+                    this.outdirs.resources,
+                    this.outdirs.dist,
+                ],
+            },
+        });
+        rollupWatcher.on('change', async (filePath) => {
+            Logger.i('Watcher', `file changed: ${filePath}, start rebuild`);
+        });
+        rollupWatcher.on('event', async (event) => {
+            if (event.code === 'ERROR') {
+                Logger.e('Watcher', `rollup error: ${event.error.stack || event.error}`);
+                showText('MBLER__ERR__ROLLUP: ' +
+                    (event.error.stack || event.error) +
+                    ' Log at ' +
+                    Logger.LogFile);
+            }
+            else if (event.code === 'END') {
+                Logger.i('Watcher', `rebuild success`);
+            }
+        });
+        return rollupWatcher;
+    }
+    async onChange(filePath) {
+        if (!this.srcDirs ||
+            !this.outdirs ||
+            !this.currentConfig ||
+            !this.rollupPlugin ||
+            !this.watchers)
+            throw new Error(`[build addon]: can't first can this method`);
+        const isConfigChange = path__default.relative(path__default.join(this.baseBuildDir, 'mbler.config.json'), filePath) === '';
+        const isBehaviorChange = this.isParent(this.srcDirs.behavior, filePath) && !this.isParent(path__default.join(this.srcDirs.behavior, 'scripts'), filePath);
+        const isResourcesChange = this.isParent(this.srcDirs.resources, filePath);
+        if (isConfigChange) {
+            const oldConfig = this.currentConfig;
+            Logger.i('Watcher', 'detected mbler.config.json change, reload config');
+            this.currentConfig = await ReadProjectMblerConfig(this.baseBuildDir);
+            this.loadData();
+            if (this.isChange(oldConfig, this.currentConfig, [
+                'name',
+                'version',
+                'description',
+                'mcVersion',
+            ])) {
+                await this.handlerManifest();
+            }
+            if (this.isChange(oldConfig, this.currentConfig, ['script', 'outdir'])) {
+                this.watchers.rollup.close();
+                await this.createRollup();
+                this.watchers.rollup = rollup.watch({
+                    input: path__default.join(this.srcDirs.behavior, 'scripts', this.currentConfig?.script?.main || ''),
+                    external: ['@minecraft/server', '@minecraft/server-ui'],
+                    plugins: this.rollupPlugin,
+                    output: {
+                        file: path__default.join(this.outdirs.behavior, 'scripts', this.currentConfig?.script?.main || ''),
+                        format: 'esm',
+                    },
+                });
+            }
+        }
+        // if behavior or resources change, we can just copy the changed file instead of copy all files again.
+        if (isBehaviorChange || isResourcesChange) {
+            const handlerBP = async () => {
+                if (!this.srcDirs || !this.outdirs)
+                    throw new Error(`[build addon]: can't first can this method`);
+                const relativePath = path__default.relative(this.srcDirs.behavior, filePath);
+                await fs.cp(path__default.join(this.srcDirs.behavior, relativePath), path__default.join(this.outdirs.behavior, relativePath), {
+                    recursive: true,
+                    force: true,
+                });
+            };
+            const handlerRP = async () => {
+                if (!this.srcDirs || !this.outdirs)
+                    throw new Error(`[build addon]: can't first can this method`);
+                const relativePath = path__default.relative(this.srcDirs.resources, filePath);
+                await fs.cp(path__default.join(this.srcDirs.resources, relativePath), path__default.join(this.outdirs.resources, relativePath), {
+                    recursive: true,
+                    force: true,
+                });
+            };
+            if (isBehaviorChange) {
+                await handlerBP();
+            }
+            if (isResourcesChange) {
+                await handlerRP();
+            }
+        }
+        showText(`[${chalk.green('mbler')}] ${chalk.bgYellow(`file changed: ${filePath}`)}`);
+    }
+    createWatcher() {
+        if (!this.srcDirs || !this.outdirs || !this.rollupPlugin)
+            throw new Error(`[build addon]: can't first can this method`);
+        const chokidar = watch$1(this.baseBuildDir, {
+            ignored: [
+                this.outdirs.behavior,
+                this.outdirs.resources,
+                this.outdirs.dist,
+                path__default.join(this.baseBuildDir, 'node_modules'),
+            ],
+            ignoreInitial: true,
+            interval: 100,
+        });
+        const onChange = async (filePath) => {
+            await this.onChange(filePath);
+        };
+        chokidar.on('change', onChange);
+        const rollupWatcher = this.createRollupWatcher();
+        this.watchers = {
+            chokidar,
+            rollup: rollupWatcher,
+        };
+    }
+    async handlerManifest() {
+        if (!this.currentConfig || !this.outdirs || !this.srcDirs || !this.module)
+            throw new Error(`[build addon]: can't first can this method`);
+        const otherManifestOption = {
+            behavior: {},
+            resources: {},
+        };
+        const handlerBP = async () => {
+            if (!this.outdirs || !this.currentConfig)
+                throw new Error(`[build addon]: can't first can this method`);
+            const manifest = await generateManifest(this.currentConfig, 'data');
+            await writeJSON(path__default.join(this.outdirs.behavior, 'manifest.json'), {
+                ...manifest,
+                ...otherManifestOption.behavior,
+            });
+        };
+        const handlerRP = async () => {
+            if (!this.outdirs || !this.currentConfig)
+                throw new Error(`[build addon]: can't first can this method`);
+            const manifest = await generateManifest(this.currentConfig, 'resources');
+            await writeJSON(path__default.join(this.outdirs.resources, 'manifest.json'), {
+                ...manifest,
+                ...otherManifestOption.resources,
+            });
+        };
+        if (this.module == 'behavior' || this.module == 'all') {
+            const filePath = path__default.join(this.srcDirs.behavior, 'manifest.json');
+            if (await FileExsit(filePath)) {
+                try {
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    const json = JSON.parse(content);
+                    otherManifestOption.behavior = json;
+                }
+                catch (err) {
+                    Logger.w('Build', 'invalid manifest.json in behavior');
+                }
+            }
+            await handlerBP();
+        }
+        if (this.module == 'resources' || this.module == 'all') {
+            const filePath = path__default.join(this.srcDirs.resources, 'manifest.json');
+            if (await FileExsit(filePath)) {
+                try {
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    const json = JSON.parse(content);
+                    otherManifestOption.resources = json;
+                }
+                catch (err) {
+                    Logger.w('Build', 'invalid manifest.json in resources');
+                }
+            }
+            await handlerRP();
+        }
+    }
+    loadData() {
+        // check run time
+        if (!this.currentConfig || !this.baseBuildDir)
+            throw new Error("[build data]: can't resolve again");
+        // source code dir
+        this.srcDirs = {
+            behavior: path__default.join(this.baseBuildDir, BuildConfig.behavior),
+            resources: path__default.join(this.baseBuildDir, BuildConfig.resources), // res
+        };
+        // output dir
+        this.outdirs = {
+            behavior: this.currentConfig.outdir?.behavior
+                ? join(this.baseBuildDir, this.currentConfig.outdir.behavior)
+                : path__default.join(this.baseBuildDir, 'dist/dep'),
+            resources: this.currentConfig.outdir?.resources
+                ? join(this.baseBuildDir, this.currentConfig.outdir.resources)
+                : path__default.join(this.baseBuildDir, 'dist/res'),
+            dist: this.currentConfig.outdir?.dist
+                ? join(this.baseBuildDir, this.currentConfig.outdir.dist)
+                : path__default.join(this.baseBuildDir, 'dist-pkg'),
+        };
+    }
+    /**
+     * Copy the various files (behavior/resources) into the corresponding
+     * output directories and determine which modules exist in the project
+     * by inspecting the source directories.
+     */
+    async handlerOtherAddon() {
+        if (!this.srcDirs)
+            throw new Error("[build addon]: can't first can this method");
+        const isHasBp = await FileExsit(this.srcDirs.behavior);
+        if (!isHasBp)
+            throw new Error("[build addon]: can't resolve behavior");
+        // init copy resources
+        const handlerBP = async () => {
+            if (!this.srcDirs || !this.outdirs)
+                throw new Error("[build addon]: can't first can this method");
+            for (const f of await fs.readdir(this.srcDirs.behavior)) {
+                const fType = await this.fileType(path__default.join(this.srcDirs.behavior, f));
+                const includeType = BuildConfig.includes.behavior[f] || BuildConfig.includes.public[f];
+                if (includeType == fType) {
+                    await fs.cp(path__default.join(this.srcDirs.behavior, f), path__default.join(this.outdirs.behavior, f), {
+                        recursive: true,
+                        force: true,
+                    });
+                }
+                else if (includeType == 'skip') {
+                    continue;
+                }
+                else {
+                    throw new Error(`[build addon]: invaild file: ${path__default.join(this.srcDirs.behavior, f)}: type: ${fType}`);
+                }
+            }
+        };
+        const handlerRP = async () => {
+            if (!this.srcDirs || !this.outdirs)
+                throw new Error("[build addon]: can't first can this method");
+            for (const f of await fs.readdir(this.srcDirs.resources)) {
+                const fType = await this.fileType(path__default.join(this.srcDirs.resources, f));
+                const includeType = BuildConfig.includes.resources[f] || BuildConfig.includes.public[f];
+                if (includeType == fType) {
+                    await fs.cp(path__default.join(this.srcDirs.resources, f), path__default.join(this.outdirs.resources, f), {
+                        recursive: true,
+                        force: true,
+                    });
+                }
+                else if (includeType == 'skip') {
+                    continue;
+                }
+                else {
+                    throw new Error(`[build addon]: invaild file: ${path__default.join(this.srcDirs.resources, f)}: type: ${fType}`);
+                }
+            }
+        };
+        const tasks = [];
+        if (await FileExsit(this.srcDirs.behavior)) {
+            this.module = 'behavior';
+            tasks.push(handlerBP());
+        }
+        if (await FileExsit(this.srcDirs.resources)) {
+            if (this.module == 'behavior') {
+                this.module = 'all';
+            }
+            else {
+                this.module = 'resources';
+            }
+            tasks.push(handlerRP());
+        }
+        if (!this.module) {
+            throw new Error("[build addon]: couldn't resolve source code(your behaivor or reources code is not found)");
+        }
+        await Promise.all(tasks);
+    }
+}
+function build(cliParam, work) {
+    return new Promise((resolve) => {
+        new Build(cliParam.opts, work, resolve).start();
+    });
+}
+function watch(cliParam, work) {
+    return new Promise((resolve, reject) => {
+        try {
+            const build = new Build(cliParam.opts, work, resolve, true);
+            build.start().then(() => {
+                build.watch();
+                showText(`[${chalk.green('mbler')}] ${chalk.bgYellow('watching for file changes...')}`);
+            });
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                reject(`[watcher]: error ${err.stack || err.message}`);
+            }
+            else {
+                reject(err);
+            }
+        }
+    });
+}
+
+export { Build, runTSC as McxTsc, build, watch };
+//# sourceMappingURL=build.esm.js.map