@mbler/mcx-core 0.0.2 → 0.0.3-alpha.r20260311

package/dist/index.d.ts

@@ -1,7 +1,74 @@
-import { CompileOpt } from '@mbler/mcx-types';
+import { TransformPluginContext, Plugin } from 'rollup';
 import * as t from '@babel/types';
 import { Expression, CallExpression, SpreadElement, ArgumentPlaceholder, ImportDeclaration, ExportNamedDeclaration, ExportAllDeclaration, ExportDefaultDeclaration } from '@babel/types';
-import { TransformPluginContext } from 'rollup';
+import { CompileOpt } from '@mbler/mcx-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>;
+}
+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;
+}
+
+declare class JsCompileData {
+    node: t.Program;
+    BuildCache: BuildCache;
+    File: string;
+    isFile: boolean;
+    constructor(node: t.Program, BuildCache?: BuildCache);
+    setFilePath(dir: string): void;
+}
+declare class MCXCompileData {
+    raw: ParsedTagNode[];
+    JSIR: JsCompileData;
+    strLoc: MCXstructureLoc;
+    File: string;
+    isFile: boolean;
+    constructor(raw: ParsedTagNode[], JSIR: JsCompileData, strLoc: MCXstructureLoc);
+    setFilePath(dir: string): void;
+}
 
 interface BaseToken {
     data: string;
@@ -39,6 +106,7 @@ interface ParsedTagNode {
     content: (ParsedTagContentNode | ParsedTagNode)[];
     end: TagEndToken | null;
     loc: MCXLoc;
+    type: "TagNode";
 }
 interface ParsedTagContentNode {
     data: string;
@@ -61,7 +129,33 @@ interface ParseReadFileOpt {
     want: 'string' | 'object';
 }
 type ReadFileOpt = Partial<ParseReadFileOpt>;
-type mcxType = "component" | "event" | "app";
+type mcxType = "component" | "event" | "app" | "ui";
+
+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;
+}
+interface transformParseCtx {
+    prop: t.ObjectProperty[];
+    impBody: t.ImportDeclaration[];
+    mainFn: t.Statement[];
+    ctx: transformCtx;
+    app: ((data: t.ObjectProperty[]) => void) & {
+        prototype: {
+            enable: t.ObjectProperty[] | null;
+        };
+    };
+}
 
 type types_AttributeMap = AttributeMap;
 type types_BaseToken = BaseToken;
@@ -80,12 +174,12 @@ type types_Token = Token;
 type types_TokenType = TokenType;
 type types_TypeVerifyBody = TypeVerifyBody;
 type types_mcxType = mcxType;
+type types_transformCtx = transformCtx;
+type types_transformParseCtx = transformParseCtx;
 declare namespace types {
-  export type { types_AttributeMap as AttributeMap, types_BaseToken as BaseToken, types_ContentToken as ContentToken, types_JsType as JsType, types_MCXLoc as MCXLoc, types_ParseReadFileOpt as ParseReadFileOpt, types_ParsedTagContentNode as ParsedTagContentNode, types_ParsedTagNode as ParsedTagNode, types_PropNode as PropNode, types_PropValue as PropValue, types_ReadFileOpt as ReadFileOpt, types_TagEndToken as TagEndToken, types_TagToken as TagToken, types_Token as Token, types_TokenType as TokenType, types_TypeVerifyBody as TypeVerifyBody, types_mcxType as mcxType };
+  export type { types_AttributeMap as AttributeMap, types_BaseToken as BaseToken, types_ContentToken as ContentToken, types_JsType as JsType, types_MCXLoc as MCXLoc, types_ParseReadFileOpt as ParseReadFileOpt, types_ParsedTagContentNode as ParsedTagContentNode, types_ParsedTagNode as ParsedTagNode, types_PropNode as PropNode, types_PropValue as PropValue, types_ReadFileOpt as ReadFileOpt, types_TagEndToken as TagEndToken, types_TagToken as TagToken, types_Token as Token, types_TokenType as TokenType, types_TypeVerifyBody as TypeVerifyBody, types_mcxType as mcxType, types_transformCtx as transformCtx, types_transformParseCtx as transformParseCtx };
 }
 
-declare function PropParser(code: string): PropNode[];
-
 declare class McxAst {
     private text;
     constructor(text: string);
@@ -100,58 +194,14 @@ declare class McxAst {
     static generateCode(node: ParsedTagNode): string;
 }
 
-declare const _default$1: {
+declare function PropParser(code: string): PropNode[];
+
+declare const _default: {
     tag: typeof McxAst;
     prop: typeof PropParser;
 };
 
-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>;
-}
-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;
-            pos: number;
-        };
-        isLoad: boolean;
-    };
-    Component: Record<string, {
-        type: MCXstructureLocComponentType;
-        useExpore: string;
-        loc: {
-            line: number;
-            pos: number;
-        };
-    }>;
-}
+declare function mcxPlugn(opt: CompileOpt): Plugin;
 
 declare function CompileMcxDir(BuildOpt: CompileOpt): Promise<void>;
 
@@ -174,32 +224,14 @@ declare class McxUtlis {
     static AbsoluteJoin(baseDir: string, inputPath: string): string;
 }
 
-declare class JsCompileData {
-    node: t.Program;
-    BuildCache: BuildCache;
-    File: string;
-    isFile: boolean;
-    constructor(node: t.Program, BuildCache?: BuildCache);
-    setFilePath(dir: string): void;
-}
-declare class MCXCompileData {
-    raw: ParsedTagNode[];
-    JSIR: JsCompileData;
-    strLoc: MCXstructureLoc;
-    File: string;
-    isFile: boolean;
-    constructor(raw: ParsedTagNode[], JSIR: JsCompileData, strLoc: MCXstructureLoc);
-    setFilePath(dir: string): void;
-}
-
 declare class CompileError extends Error {
     loc: {
         line: number;
-        pos: number;
+        column: number;
     };
     constructor(message: string, loc: {
         line: number;
-        pos: number;
+        column: number;
     });
 }
 type Context = Record<string, t.Expression | {
@@ -224,29 +256,27 @@ declare class CompileJS {
 declare function compileJSFn(code: string): JsCompileData;
 declare function compileMCXFn(mcxCode: string): MCXCompileData;
 
-type Compiler_CompileError = CompileError;
-declare const Compiler_CompileError: typeof CompileError;
-type Compiler_CompileJS = CompileJS;
-declare const Compiler_CompileJS: typeof CompileJS;
-type Compiler_Context = Context;
-declare const Compiler_compileJSFn: typeof compileJSFn;
-declare const Compiler_compileMCXFn: typeof compileMCXFn;
-declare namespace Compiler {
-  export { Compiler_CompileError as CompileError, Compiler_CompileJS as CompileJS, Compiler_compileJSFn as compileJSFn, Compiler_compileMCXFn as compileMCXFn };
-  export type { Compiler_Context as Context };
+type index$1_CompileError = CompileError;
+declare const index$1_CompileError: typeof CompileError;
+type index$1_CompileJS = CompileJS;
+declare const index$1_CompileJS: typeof CompileJS;
+type index$1_Context = Context;
+declare const index$1_compileJSFn: typeof compileJSFn;
+declare const index$1_compileMCXFn: typeof compileMCXFn;
+declare namespace index$1 {
+  export { index$1_CompileError as CompileError, index$1_CompileJS as CompileJS, index$1_compileJSFn as compileJSFn, index$1_compileMCXFn as compileMCXFn };
+  export type { index$1_Context as Context };
 }
 
-declare function transform(compileData: MCXCompileData, cache: Map<string, MCXCompileData>, id: string, context: TransformPluginContext, opt: CompileOpt): Promise<string>;
+declare function compileComponent(compiledCode: MCXCompileData, project: string): Promise<void>;
 
-declare const _default: {
-    load: typeof CompileMcxDir;
-    AST: {
-        tag: typeof McxAst;
-        prop: typeof PropParser;
-    };
-    Compiler: typeof Compiler;
-    utils: typeof McxUtlis;
-    transform: typeof transform;
-};
+declare const index_compileComponent: typeof compileComponent;
+declare namespace index {
+  export {
+    index_compileComponent as compileComponent,
+  };
+}
+
+declare function transform(code: MCXCompileData, cache: Map<string, MCXCompileData>, id: string, context: TransformPluginContext, opt: CompileOpt): Promise<string>;
 
-export { _default$1 as AST, Compiler, types as PUBTYPE, CompileMcxDir as compile, _default as default, transform, McxUtlis as utils };
+export { _default as AST, index$1 as Compiler, types as PUBTYPE, CompileMcxDir as compile, index as compile_component, mcxPlugn as plugin, transform, McxUtlis as utils };