@mbler/mcx-core 0.0.3-alpha.r20260312 → 0.0.3-beta

package/dist/types/ast/index.d.ts

@@ -0,0 +1,7 @@
+import AST_tag from "./tag.js";
+import AST_prop from "./prop.js";
+declare const _default: {
+    tag: typeof AST_tag;
+    prop: typeof AST_prop;
+};
+export default _default;

package/dist/types/ast/prop.d.ts

@@ -0,0 +1,8 @@
+import type { PropNode, PropValue } from "../types.js";
+export declare class Lexer {
+    private code;
+    constructor(code: string);
+    tokenize(): IterableIterator<PropNode>;
+    HandlerValue(value: string): PropValue;
+}
+export default function PropParser(code: string): PropNode[];

package/dist/types/ast/tag.d.ts

@@ -0,0 +1,26 @@
+import type { BaseToken, TagToken, TagEndToken, ContentToken, Token, ParsedTagNode, AttributeMap, ParsedTagContentNode, TokenType } from "./../types.js";
+export default class McxAst {
+    private text;
+    constructor(text: string);
+    private getAST;
+    get data(): ParsedTagNode[];
+    parseAST(): ParsedTagNode[];
+    /**
+     * 生成代码字符串（递归处理 content 数组）
+     * @param node 要生成代码的AST节点
+     * @returns 生成的代码字符串
+     */
+    static generateCode(node: ParsedTagNode): string;
+}
+export declare class MCXUtils {
+    static isTagNode(node: unknown): node is ParsedTagNode;
+    static isTagContentNode(node: unknown): node is ParsedTagContentNode;
+    static isAttributeMap(obj: unknown): obj is AttributeMap;
+    static isToken(obj: unknown): obj is Token;
+    static isTagToken(obj: unknown): obj is TagToken;
+    static isTagEndToken(obj: unknown): obj is TagEndToken;
+    static isContentToken(obj: unknown): obj is ContentToken;
+    static isBaseToken(obj: unknown): obj is BaseToken;
+    static isTokenType(value: unknown): value is TokenType;
+    static isParseNode(node: unknown): node is ParsedTagNode[];
+}

package/dist/types/compile-mcx/compile.d.ts

@@ -0,0 +1,5 @@
+import type { CompileOpt } from "./types.js";
+/**
+ * @description - this is a function factory to generate mcxProject
+ */
+export default function CompileMcxProject(BuildOpt: CompileOpt): Promise<void>;

package/dist/types/compile-mcx/compiler/compileData.d.ts

@@ -0,0 +1,20 @@
+import * as t from "@babel/types";
+import { BuildCache, MCXstructureLoc } from "../types";
+import { ParsedTagNode } from "../../types";
+export declare class JsCompileData {
+    node: t.Program;
+    BuildCache: BuildCache;
+    File: string;
+    isFile: boolean;
+    constructor(node: t.Program, BuildCache?: BuildCache);
+    setFilePath(dir: string): void;
+}
+export declare class MCXCompileData {
+    raw: ParsedTagNode[];
+    JSIR: JsCompileData;
+    strLoc: MCXstructureLoc;
+    File: string;
+    isFile: boolean;
+    constructor(raw: ParsedTagNode[], JSIR: JsCompileData, strLoc: MCXstructureLoc);
+    setFilePath(dir: string): void;
+}

package/dist/types/compile-mcx/compiler/index.d.ts

@@ -0,0 +1,33 @@
+import * as t from "@babel/types";
+import * as CompileData from "./compileData";
+export declare class CompileError extends Error {
+    loc: {
+        line: number;
+        column: number;
+    };
+    constructor(message: string, loc: {
+        line: number;
+        column: number;
+    });
+}
+export type Context = Record<string, t.Expression | {
+    status: "wait";
+}>;
+export declare class CompileJS {
+    node: t.Program;
+    constructor(node: t.Program);
+    TopContext: Context;
+    private indexTemp;
+    private push;
+    private takeInnerMost;
+    private writeImportKeys;
+    private extractIdentifierNames;
+    private writeBuildCache;
+    private CompileData;
+    getCompileData(): CompileData.JsCompileData;
+    private conditionalInTempImport;
+    private tre;
+    run(): void;
+}
+export declare function compileJSFn(code: string): CompileData.JsCompileData;
+export declare function compileMCXFn(mcxCode: string): CompileData.MCXCompileData;

package/dist/types/compile-mcx/compiler/main.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from "rollup";
+import { CompileOpt } from "../types";
+export declare function mcxPlugn(opt: CompileOpt): Plugin;
+export default function CompileProject(opt: CompileOpt): Promise<void>;

package/dist/types/compile-mcx/compiler/utils.d.ts

@@ -0,0 +1,11 @@
+import * as Parser from "@babel/parser";
+import { ImportList } from "../types";
+import * as t from "@babel/types";
+export default class Utils {
+    static FileAST(fileDir: string, parserOpt: Parser.ParserOptions): Promise<t.Program>;
+    static FileContent(fileDir: string): Promise<string>;
+    private static nodeStringValue;
+    private static CheckImportNode;
+    static CacheToImportNode(ir: ImportList): t.ImportDeclaration;
+    static ImportToCache(node: t.ImportDeclaration): ImportList;
+}

package/dist/types/compile-mcx/index.d.ts

@@ -0,0 +1,3 @@
+import type { CompileOpt } from "./types.js";
+export default function CompileMcxDir(BuildOpt: CompileOpt): Promise<void>;
+export { mcxPlugn as plugin } from "./compiler/main";

package/dist/types/compile-mcx/types.d.ts

@@ -0,0 +1,52 @@
+import type { ImportDeclaration, ExportAllDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, Expression, SpreadElement, ArgumentPlaceholder, CallExpression } from "@babel/types";
+import { CompileOpt } from "@mbler/mcx-types";
+import { ParsedTagNode } from "../types";
+interface callList {
+    source: Expression;
+    set: (callEXp: CallExpression) => boolean;
+    arguments: Array<SpreadElement | Expression | ArgumentPlaceholder>;
+    remove: () => void;
+}
+interface ImportListImport {
+    isAll: boolean;
+    import?: string | undefined;
+    as: string;
+}
+interface ImportList {
+    source: string;
+    imported: ImportListImport[];
+    raw?: ImportDeclaration;
+}
+interface BuildCache {
+    call: callList[];
+    import: ImportList[];
+    export: Array<ExportNamedDeclaration | ExportAllDeclaration | ExportDefaultDeclaration>;
+}
+export declare const _MCXstructureLocComponentTypes: {
+    readonly items: "item";
+    readonly blocks: "block";
+    readonly entities: "entity";
+};
+type MCXstructureLocComponentType = typeof _MCXstructureLocComponentTypes[keyof typeof _MCXstructureLocComponentTypes];
+interface MCXstructureLoc {
+    script: string;
+    Event: {
+        on: "after" | "before";
+        subscribe: Record<string, string>;
+        loc: {
+            line: number;
+            column: number;
+        };
+        isLoad: boolean;
+    };
+    Component: Record<string, {
+        type: MCXstructureLocComponentType;
+        useExpore: string;
+        loc: {
+            line: number;
+            column: number;
+        };
+    }>;
+    UI: ParsedTagNode | null;
+}
+export type { BuildCache, ImportList, ImportListImport, callList, CompileOpt, MCXstructureLoc, MCXstructureLocComponentType };

package/dist/types/compile-mcx/utils.node.d.ts

@@ -0,0 +1,14 @@
+import type { MemberExpression, Expression } from '@babel/types';
+import { Context } from './compiler';
+export default class NodeUtils {
+    static stringArrayToMemberExpression(stringArray: string[]): MemberExpression;
+    static memberExpressionToStringArray(memberExpression: MemberExpression, maxLength: number): string[];
+    /**
+     * 计算表达式的值
+     * @param expression Babel AST 表达式节点
+     * @param currentContext 当前上下文变量
+     * @param topContext 顶层上下文变量
+     * @returns 计算结果 (string | number | symbol | object)
+     */
+    static evaluateExpression(expression: Expression, currentContext?: Context, topContext?: Context): string | number | symbol | object;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+import AST from "./ast/index.js";
+import compiler, { plugin } from "./compile-mcx/index.js";
+import utils from "./utils.js";
+import * as Compiler from "./compile-mcx/compiler";
+import * as PUBTYPE from "./types.js";
+import * as compile_component from "./mcx-component/index.js";
+import { transform } from "./transforms";
+export { PUBTYPE, compiler as compile, AST, Compiler, utils, transform, compile_component, plugin };

package/dist/types/mcx-component/index.d.ts

@@ -0,0 +1,2 @@
+import { MCXCompileData } from "../compile-mcx/compiler/compileData";
+export declare function compileComponent(compiledCode: MCXCompileData, project: string): Promise<void>;

package/dist/types/mcx-component/lib.d.ts

@@ -0,0 +1,29 @@
+import * as t from "./types";
+export declare class ItemComponent {
+    #private;
+    constructor(opt: t.ItemComponentOpt);
+    toJSON(): t.ItemJSON;
+    /**
+     * set name
+     * @throws {Error}&
+     * @param {string} newValue
+     * @returns {void}
+     */
+    setName(newValue: string): void;
+    setIcon(newValue: string): void;
+    /**
+     * get name
+     * @returns {string} name
+     */
+    getName(): string;
+    /**
+     * set identifier
+     * @param {string} newValue
+     */
+    setId(newValue: string): void;
+    getId(): void;
+}
+declare const _default: {
+    Item: typeof ItemComponent;
+};
+export default _default;

package/dist/types/mcx-component/types.d.ts

@@ -0,0 +1,44 @@
+interface ItemComponentOpt {
+    id: string;
+    name: string;
+    format: string;
+    components: {
+        offHand: boolean;
+        damage: number;
+        DestroyInCreate: boolean;
+        icon: string;
+    };
+}
+type JSONValue<T> = T | {
+    value: T;
+};
+type ItemGroupEnum = "minecraft:itemGroup.name.planks" | "minecraft:itemGroup.name.walls" | "minecraft:itemGroup.name.fence" | "minecraft:itemGroup.name.fenceGate" | "minecraft:itemGroup.name.glass" | "minecraft:itemGroup.name.trapdoor" | "minecraft:itemGroup.name.door" | "minecraft:itemGroup.name.stairs" | "minecraft:itemGroup.name.glassPane" | "minecraft:itemGroup.name.slab" | "minecraft:itemGroup.name.stoneBrick" | "minecraft:itemGroup.name.sandstone" | "minecraft:itemGroup.name.copper" | "minecraft:itemGroup.name.wool" | "minecraft:itemGroup.name.woolCarpet" | "minecraft:itemGroup.name.concretePowder" | "minecraft:itemGroup.name.concrete" | "minecraft:itemGroup.name.stainedClay" | "minecraft:itemGroup.name.glazedTerracotta" | "minecraft:itemGroup.name.ore" | "minecraft:itemGroup.name.stone" | "minecraft:itemGroup.name.log" | "minecraft:itemGroup.name.wood" | "minecraft:itemGroup.name.leaves" | "minecraft:itemGroup.name.sapling" | "minecraft:itemGroup.name.seed" | "minecraft:itemGroup.name.crop" | "minecraft:itemGroup.name.grass" | "minecraft:itemGroup.name.coral_decorations" | "minecraft:itemGroup.name.flower" | "minecraft:itemGroup.name.dye" | "minecraft:itemGroup.name.rawFood" | "minecraft:itemGroup.name.mushroom" | "minecraft:itemGroup.name.monsterStoneEgg" | "minecraft:itemGroup.name.mobEgg" | "minecraft:itemGroup.name.coral" | "minecraft:itemGroup.name.sculk" | "minecraft:itemGroup.name.helmet" | "minecraft:itemGroup.name.chestplate" | "minecraft:itemGroup.name.leggings" | "minecraft:itemGroup.name.boots" | "minecraft:itemGroup.name.sword" | "minecraft:itemGroup.name.axe" | "minecraft:itemGroup.name.pickaxe" | "minecraft:itemGroup.name.shovel" | "minecraft:itemGroup.name.hoe" | "minecraft:itemGroup.name.arrow" | "minecraft:itemGroup.name.cookedFood" | "minecraft:itemGroup.name.miscFood" | "minecraft:itemGroup.name.goatHorn" | "minecraft:itemGroup.name.bundles" | "minecraft:itemGroup.name.horseArmor" | "minecraft:itemGroup.name.potion" | "minecraft:itemGroup.name.splashPotion" | "minecraft:itemGroup.name.lingeringPotion" | "minecraft:itemGroup.name.ominousBottle" | "minecraft:itemGroup.name.bed" | "minecraft:itemGroup.name.candles" | "minecraft:itemGroup.name.anvil" | "minecraft:itemGroup.name.chest" | "minecraft:itemGroup.name.shulkerBox" | "minecraft:itemGroup.name.record" | "minecraft:itemGroup.name.sign" | "minecraft:itemGroup.name.hanging_sign" | "minecraft:itemGroup.name.skull" | "minecraft:itemGroup.name.boat" | "minecraft:itemGroup.name.chestboat" | "minecraft:itemGroup.name.rail" | "minecraft:itemGroup.name.minecart" | "minecraft:itemGroup.name.buttons" | "minecraft:itemGroup.name.pressurePlate" | "minecraft:itemGroup.name.banner_pattern" | "minecraft:itemGroup.name.potterySherds" | "minecraft:itemGroup.name.smithing_templates";
+interface ItemJSON {
+    format_version: string;
+    "minecraft:item": {
+        description: {
+            identifier: string;
+            category?: string;
+            menu_category?: {
+                category: string;
+                group: ItemGroupEnum;
+            };
+        };
+        components: {
+            "minecraft:display_name"?: JSONValue<string>;
+            "minecraft:allow_off_hand"?: JSONValue<boolean>;
+            "minecraft:can_destroy_in_creative"?: JSONValue<boolean>;
+            "minecraft:compostable"?: {
+                composting_chance: number;
+            };
+            "minecraft:cooldown"?: {
+                category: string;
+                duration: number;
+                type: "use" | "attack";
+            };
+            "minecraft:damage"?: JSONValue<number>;
+            "minecraft:icon"?: JSONValue<string>;
+        };
+    };
+}
+export type { ItemComponentOpt, ItemGroupEnum, ItemJSON };

package/dist/types/mcx-component/utils.d.ts

@@ -0,0 +1,2 @@
+declare const compareVar: (a: string, b: string) => number;
+export default compareVar;

package/dist/types/transforms/config.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    readonly scriptCompileFn: "__main";
+    readonly eventImported: "__mcx__event";
+    readonly eventVarName: "__use_event";
+    readonly eventExtendsName: "McxExtendsBy";
+    readonly paramCtx: "__mcx__ctx";
+};
+export default _default;

package/dist/types/transforms/index.d.ts

@@ -0,0 +1,4 @@
+import { TransformPluginContext } from "rollup";
+import { MCXCompileData } from "../compile-mcx/compiler/compileData";
+import { CompileOpt } from "@mbler/mcx-types";
+export declare function transform(code: MCXCompileData, cache: Map<string, MCXCompileData>, id: string, context: TransformPluginContext, opt: CompileOpt): Promise<string>;

package/dist/types/transforms/main.d.ts

@@ -0,0 +1,2 @@
+import { transformCtx } from "../types";
+export declare function _transform(ctx: transformCtx): Promise<string>;

package/dist/types/transforms/utils.d.ts

@@ -0,0 +1,22 @@
+import * as t from "@babel/types";
+import { JsCompileData } from "../compile-mcx/compiler/compileData";
+import { ParsedTagNode, transformCtx } from "../types";
+declare function extrectVarDefIdList(express: t.LVal | t.VoidPattern): string[];
+declare function extractIdList(expression: t.Declaration): string[];
+declare function generateMain(code: JsCompileData): [t.Statement[], t.ImportDeclaration[]];
+declare function generateEventConfig(eventTag: ParsedTagNode, ctx: transformCtx, impBody: t.ImportDeclaration[]): Promise<t.ObjectExpression>;
+/**
+ * record enable
+ * @returns {(): void} - only call one
+ */
+declare function _enable(): (() => void) & {
+    prototype: {
+        enable: boolean;
+    };
+};
+declare function _enableWithData<T extends any>(): ((data: T) => void) & {
+    prototype: {
+        enable: T | null;
+    };
+};
+export { extractIdList, extrectVarDefIdList, generateEventConfig, _enable, generateMain, _enableWithData };

package/dist/types/transforms/x-comp/index.d.ts

@@ -0,0 +1,3 @@
+export { Comp as UIComp } from "./x-ui";
+export { Comp as EventComp } from "./x-event";
+export { Comp as AppComp } from "./x-app";

package/dist/types/transforms/x-comp/x-app.d.ts

@@ -0,0 +1,2 @@
+import { transformParseCtx } from "../../types";
+export declare function Comp(ctx: transformParseCtx): Promise<void>;

package/dist/types/transforms/x-comp/x-event.d.ts

@@ -0,0 +1,2 @@
+import { transformParseCtx } from "../../types";
+export declare function Comp(ctx: transformParseCtx): Promise<void>;

package/dist/types/transforms/x-comp/x-ui.d.ts

@@ -0,0 +1,2 @@
+import { transformParseCtx } from "../../types";
+export declare function Comp(ctx: transformParseCtx): Promise<void>;

package/dist/types/types.d.ts

@@ -0,0 +1,90 @@
+import { TransformPluginContext } from "rollup";
+import type { MCXCompileData } from "./compile-mcx/compiler/compileData";
+import { CompileOpt } from "@mbler/mcx-types";
+import * as t from "@babel/types";
+interface BaseToken {
+    data: string;
+    type: TokenType;
+    startIndex?: number;
+    endIndex?: number;
+    startLine?: number;
+    loc?: MCXLoc;
+}
+interface TagToken extends BaseToken {
+    type: 'Tag';
+}
+interface TagEndToken extends BaseToken {
+    type: 'TagEnd';
+}
+interface ContentToken extends BaseToken {
+    type: 'Content';
+}
+type Token = TagToken | TagEndToken | ContentToken;
+type AttributeMap = Record<string, string | boolean>;
+interface MCXLoc {
+    start: {
+        line: number;
+        index: number;
+    };
+    end: {
+        line: number;
+        index: number;
+    };
+}
+interface ParsedTagNode {
+    start: TagToken;
+    name: string;
+    arr: AttributeMap;
+    content: (ParsedTagContentNode | ParsedTagNode)[];
+    end: TagEndToken | null;
+    loc: MCXLoc;
+    type: "TagNode";
+}
+interface ParsedTagContentNode {
+    data: string;
+    type: 'TagContent';
+}
+type TokenType = 'Tag' | 'TagEnd' | 'Content';
+type PropValue = number | string | object;
+interface PropNode {
+    key: string;
+    value: PropValue;
+    type: "PropChar" | "PropObject";
+}
+type JsType = "boolean" | "number" | "string" | "object" | "function" | "bigint" | "symbol";
+interface TypeVerifyBody {
+    [key: string]: JsType;
+}
+export interface ParseReadFileOpt {
+    delay: number;
+    maxRetries: number;
+    want: 'string' | 'object';
+}
+export type ReadFileOpt = Partial<ParseReadFileOpt>;
+export type mcxType = "component" | "event" | "app" | "ui";
+export type { Token, ContentToken, TagEndToken, TagToken, BaseToken, AttributeMap, PropValue, TokenType, ParsedTagContentNode, TypeVerifyBody, JsType, PropNode, ParsedTagNode, MCXLoc };
+export interface transformCtx {
+    rollupContext: TransformPluginContext;
+    compiledCode: MCXCompileData;
+    cache: Map<string, MCXCompileData>;
+    currentId: string;
+    scriptTag: ParsedTagNode;
+    currentAST: t.Program;
+    mainFn: {
+        param: t.FunctionParameter[];
+        body: t.Statement[];
+    };
+    impAST: t.ImportDeclaration[];
+    opt: CompileOpt;
+}
+export interface transformParseCtx {
+    prop: t.ObjectProperty[];
+    impBody: t.ImportDeclaration[];
+    mainFn: t.Statement[];
+    ctx: transformCtx;
+    app: ((data: t.ObjectProperty[]) => void) & {
+        prototype: {
+            enable: t.ObjectProperty[] | null;
+        };
+    };
+}

package/dist/types/utils.d.ts

@@ -0,0 +1,19 @@
+import type { ReadFileOpt, TypeVerifyBody } from "./types.js";
+export default class McxUtlis {
+    /**
+     * 检查文件是否存在
+     * @param path 文件路径
+     * @returns 是否存在
+     */
+    static FileExsit(path: string): Promise<boolean>;
+    /**
+     * 读取文件内容，支持返回 string 或 object，带重试机制
+     * @param filePath 文件路径
+     * @param opt 配置选项
+     * @returns 文件内容（string | object），出错时返回 {}
+     */
+    static readFile(filePath: string, opt?: ReadFileOpt): Promise<object | string>;
+    static sleep(time: number): Promise<void>;
+    static TypeVerify(obj: any, types: TypeVerifyBody): boolean;
+    static AbsoluteJoin(baseDir: string, inputPath: string): string;
+}

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@mbler/mcx-core",
-  "version": "0.0.3-alpha.r20260312",
+  "version": "0.0.3-beta",
   "description": "a DSL compiler of mcx",
   "main": "dist/index.js",
   "scripts": {
     "test": "cd __test__ && npm run test",
-    "build": "rollup -c",
-    "publish": "npm run build"
+    "build": "rollup -c"
   },
   "keywords": [
     "compiler",