@mbler/mcx-core 0.0.5 → 0.0.6-alpha.r20260412.2

package/dist/index.d.ts

@@ -3,8 +3,6 @@ import * as t from '@babel/types';
 import { Expression, CallExpression, SpreadElement, ArgumentPlaceholder, ImportDeclaration, ExportNamedDeclaration, ExportAllDeclaration, ExportDefaultDeclaration } from '@babel/types';
 import { CompileOpt } from '@mbler/mcx-types';
 import * as Parser from '@babel/parser';
-import * as ts from 'typescript';
-import { VirtualCode, CodeMapping, LanguagePlugin } from '@volar/language-core';
 
 interface callList {
     source: Expression;
@@ -218,7 +216,9 @@ declare const _default: {
     prop: typeof PropParser;
 };
 
-declare function mcxPlugn(opt: CompileOpt, output: transformCtx["output"]): Plugin;
+declare function mcxPlugn(opt: CompileOpt & {
+    mcxLanguagePlugin?: any;
+}, output: transformCtx["output"]): Plugin;
 
 declare class McxUtlis {
     /**
@@ -280,20 +280,20 @@ declare class CompileJS {
 declare function compileJSFn(code: string): JsCompileData;
 declare function compileMCXFn(mcxCode: string): MCXCompileData;
 
-type index$2_CompileError = CompileError;
-declare const index$2_CompileError: typeof CompileError;
-type index$2_CompileJS = CompileJS;
-declare const index$2_CompileJS: typeof CompileJS;
-type index$2_Context = Context;
-type index$2_JsCompileData = JsCompileData;
-declare const index$2_JsCompileData: typeof JsCompileData;
-type index$2_MCXCompileData = MCXCompileData;
-declare const index$2_MCXCompileData: typeof MCXCompileData;
-declare const index$2_compileJSFn: typeof compileJSFn;
-declare const index$2_compileMCXFn: typeof compileMCXFn;
-declare namespace index$2 {
-  export { index$2_CompileError as CompileError, index$2_CompileJS as CompileJS, index$2_JsCompileData as JsCompileData, index$2_MCXCompileData as MCXCompileData, Utils as MCXNodeUtils, index$2_compileJSFn as compileJSFn, index$2_compileMCXFn as compileMCXFn };
-  export type { index$2_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;
+type index$1_JsCompileData = JsCompileData;
+declare const index$1_JsCompileData: typeof JsCompileData;
+type index$1_MCXCompileData = MCXCompileData;
+declare const index$1_MCXCompileData: typeof MCXCompileData;
+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_JsCompileData as JsCompileData, index$1_MCXCompileData as MCXCompileData, Utils as MCXNodeUtils, index$1_compileJSFn as compileJSFn, index$1_compileMCXFn as compileMCXFn };
+  export type { index$1_Context as Context };
 }
 
 declare enum execESMMethod {
@@ -5040,77 +5040,30 @@ declare class ItemComponent {
 
 declare function compileComponent(compiledCode: MCXCompileData, ctx: transformCtx): Promise<void>;
 
-type index$1_BlockComponent = BlockComponent;
-declare const index$1_BlockComponent: typeof BlockComponent;
-type index$1_EntityComponent = EntityComponent;
-declare const index$1_EntityComponent: typeof EntityComponent;
-type index$1_ItemComponent = ItemComponent;
-declare const index$1_ItemComponent: typeof ItemComponent;
-type index$1_RunScript = RunScript;
-declare const index$1_RunScript: typeof RunScript;
-declare const index$1_compileComponent: typeof compileComponent;
-type index$1_execESMMethod = execESMMethod;
-declare const index$1_execESMMethod: typeof execESMMethod;
-declare const index$1_transformESMToCJS: typeof transformESMToCJS;
-declare namespace index$1 {
+type index_BlockComponent = BlockComponent;
+declare const index_BlockComponent: typeof BlockComponent;
+type index_EntityComponent = EntityComponent;
+declare const index_EntityComponent: typeof EntityComponent;
+type index_ItemComponent = ItemComponent;
+declare const index_ItemComponent: typeof ItemComponent;
+type index_RunScript = RunScript;
+declare const index_RunScript: typeof RunScript;
+declare const index_compileComponent: typeof compileComponent;
+type index_execESMMethod = execESMMethod;
+declare const index_execESMMethod: typeof execESMMethod;
+declare const index_transformESMToCJS: typeof transformESMToCJS;
+declare namespace index {
   export {
-    index$1_BlockComponent as BlockComponent,
-    index$1_EntityComponent as EntityComponent,
-    index$1_ItemComponent as ItemComponent,
-    index$1_RunScript as RunScript,
-    index$1_compileComponent as compileComponent,
-    index$1_execESMMethod as execESMMethod,
-    index$1_transformESMToCJS as transformESMToCJS,
+    index_BlockComponent as BlockComponent,
+    index_EntityComponent as EntityComponent,
+    index_ItemComponent as ItemComponent,
+    index_RunScript as RunScript,
+    index_compileComponent as compileComponent,
+    index_execESMMethod as execESMMethod,
+    index_transformESMToCJS as transformESMToCJS,
   };
 }
 
 declare function transform(code: MCXCompileData, cache: Map<string, MCXCompileData>, id: string, context: TransformPluginContext, opt: CompileOpt, output: transformCtx["output"]): Promise<string>;
 
-interface ServiceScript {
-    code: VirtualCode;
-    scriptKind: ts.ScriptKind;
-    preventLeadingOffset: boolean;
-    extension: string;
-}
-interface TypeScriptLanguagePlugin {
-    getServiceScript(virtualCode: VirtualCode): ServiceScript | undefined;
-    extraFileExtensions: {
-        extension: string;
-        isMixedContent: boolean;
-        scriptKind: ts.ScriptKind;
-    }[];
-}
-interface MCXLanguagePlugin extends LanguagePlugin<string> {
-    typescript: TypeScriptLanguagePlugin;
-}
-declare class MCXVirtualCode implements VirtualCode {
-    id: string;
-    languageId: string;
-    mappings: CodeMapping[];
-    embeddedCodes: VirtualCode[];
-    snapshot: ts.IScriptSnapshot;
-    constructor(snapshot: ts.IScriptSnapshot);
-    private extractScriptContent;
-    private calculateScriptOffset;
-}
-/**
- * 创建 MCX 语言插件
- * @param tsModule TypeScript
- * @returns MCXLanguagePlugin
- */
-declare function createMCXLanguagePlugin(tsModule: typeof ts): MCXLanguagePlugin;
-declare function createMCXVirtualCode(snapshot: ts.IScriptSnapshot): VirtualCode;
-
-type index_MCXVirtualCode = MCXVirtualCode;
-declare const index_MCXVirtualCode: typeof MCXVirtualCode;
-declare const index_createMCXLanguagePlugin: typeof createMCXLanguagePlugin;
-declare const index_createMCXVirtualCode: typeof createMCXVirtualCode;
-declare namespace index {
-  export {
-    index_MCXVirtualCode as MCXVirtualCode,
-    index_createMCXLanguagePlugin as createMCXLanguagePlugin,
-    index_createMCXVirtualCode as createMCXVirtualCode,
-  };
-}
-
-export { _default as AST, BlockComponent, types as ComponentType, EntityComponent, ItemComponent, types$1 as PUBTYPE, index as TSC, index$1 as compile_component, index$2 as compiler, mcxPlugn as plugin, transform, McxUtlis as utils };
+export { _default as AST, BlockComponent, types as ComponentType, EntityComponent, ItemComponent, types$1 as PUBTYPE, index as compile_component, index$1 as compiler, mcxPlugn as plugin, transform, McxUtlis as utils };

package/dist/index.js

@@ -4,7 +4,7 @@ var path = require('node:path');
 var t = require('@babel/types');
 var fs = require('node:fs/promises');
 var Parser$1 = require('@babel/parser');
-var ts = require('typescript');
+var ts$1 = require('typescript');
 var generator = require('@babel/generator');
 var Module = require('node:module');
 var vm = require('node:vm');
@@ -32,6 +32,7 @@ var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 var t__namespace = /*#__PURE__*/_interopNamespaceDefault(t);
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 var Parser__namespace = /*#__PURE__*/_interopNamespaceDefault(Parser$1);
+var ts__namespace = /*#__PURE__*/_interopNamespaceDefault(ts$1);
 var generator__namespace = /*#__PURE__*/_interopNamespaceDefault(generator);
 var Module__namespace = /*#__PURE__*/_interopNamespaceDefault(Module);
 var vm__namespace = /*#__PURE__*/_interopNamespaceDefault(vm);
@@ -572,7 +573,7 @@ function PropParser(code) {
     return Array.from(lexer.tokenize());
 }
 
-var index$3 = {
+var index$2 = {
     tag: McxAst,
     prop: PropParser
 };
@@ -1211,10 +1212,10 @@ class CompileMCX {
                 const scriptNode = node.content.length == 0 ? "" : this.commonTagNodeContent(node);
                 let code = scriptNode;
                 if (node.arr.lang == "ts") {
-                    code = ts.transpileModule(scriptNode, {
+                    code = ts$1.transpileModule(scriptNode, {
                         compilerOptions: {
-                            target: ts.ScriptTarget.ES2024,
-                            module: ts.ModuleKind.ESNext,
+                            target: ts$1.ScriptTarget.ES2024,
+                            module: ts$1.ModuleKind.ESNext,
                         },
                     }).outputText;
                 }
@@ -1356,7 +1357,7 @@ function compileMCXFn(mcxCode) {
     return compiler.getCompileData();
 }
 
-var index$2 = /*#__PURE__*/Object.freeze({
+var index$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     CompileError: CompileError,
     CompileJS: CompileJS,
@@ -10688,7 +10689,7 @@ async function compileComponent(compiledCode, ctx) {
     }
 }
 
-var index$1 = /*#__PURE__*/Object.freeze({
+var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
     BlockComponent: BlockComponent,
     EntityComponent: EntityComponent,
@@ -10783,6 +10784,160 @@ async function transform(code, cache, id, context, opt, output) {
     return await _transform(transformContext);
 }
 
+let ts;
+class TsHook {
+    static tsCompilerOptions;
+    static compilerHost = null;
+    static program = null;
+    static fileCache = new Map();
+    static mcxLanguagePlugin = null;
+    static buildStart(context, opt) {
+        this.fileCache.clear();
+        if (!opt.ts) {
+            ts = ts__namespace;
+        }
+        else {
+            ts = opt.ts;
+        }
+        if (opt.mcxLanguagePlugin) {
+            this.mcxLanguagePlugin = opt.mcxLanguagePlugin;
+            context.debug(`[tsHook] MCX language plugin loaded for .mcx file support`);
+        }
+        const tsconfigPath = opt.tsconfigPath;
+        if (tsconfigPath) {
+            try {
+                const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+                if (!configFile.error) {
+                    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(tsconfigPath));
+                    this.tsCompilerOptions = { ...this.tsCompilerOptions, ...parsedConfig.options };
+                }
+            }
+            catch (error) {
+                context.warn(`Error reading tsconfig.json: ${error}`);
+            }
+        }
+        if (!this.tsCompilerOptions) {
+            throw new Error("[ts]: can't find tsconfig");
+        }
+        this.compilerHost = ts.createCompilerHost(this.tsCompilerOptions);
+        const originalHost = this.compilerHost;
+        this.compilerHost.getSourceFile = (fileName, languageVersion) => {
+            const cachedContent = this.fileCache.get(fileName);
+            if (cachedContent) {
+                return ts.createSourceFile(fileName, cachedContent, languageVersion);
+            }
+            return originalHost.getSourceFile(fileName, languageVersion);
+        };
+        this.compilerHost.fileExists = (fileName) => {
+            return this.fileCache.has(fileName) || originalHost.fileExists(fileName);
+        };
+        this.compilerHost.readFile = (fileName) => {
+            const cachedContent = this.fileCache.get(fileName);
+            if (cachedContent)
+                return cachedContent;
+            return originalHost.readFile(fileName);
+        };
+        this.program = ts.createProgram([], this.tsCompilerOptions, this.compilerHost);
+        this.reportGlobalDiagnostics(context);
+    }
+    static reportGlobalDiagnostics(context) {
+        if (!this.program || !ts)
+            return;
+        const diagnostics = ts.getPreEmitDiagnostics(this.program);
+        diagnostics.forEach(diagnostic => {
+            if (diagnostic.file) {
+                const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+                const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+                if (diagnostic.category === ts.DiagnosticCategory.Error) {
+                    context.error(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+                }
+                else {
+                    context.warn(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+                }
+            }
+            else {
+                const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+                context.warn(`TypeScript: ${message}`);
+            }
+        });
+    }
+    static async transformTs(context, code, id, opt) {
+        const ext = id.slice(id.lastIndexOf('.'));
+        const isTypeScript = ['.ts', '.tsx', '.cts', '.mts'].includes(ext);
+        const isJsx = ['.tsx', '.jsx'].includes(ext);
+        if (!ts || !this.tsCompilerOptions)
+            throw new Error("[ts]: can't find ts module");
+        if (!isTypeScript && !isJsx) {
+            return code;
+        }
+        try {
+            // 缓存当前文件内容
+            this.fileCache.set(id, code);
+            if (!this.program || !this.compilerHost) {
+                // 如果没有预先创建的 compiler，创建临时的一个
+                return this.fallbackTransform(context, code, id);
+            }
+            // 复用现有的程序，添加新文件
+            const fileNames = [...new Set([...this.program.getSourceFiles().map(f => f.fileName), id])];
+            this.program = ts.createProgram(fileNames, this.tsCompilerOptions, this.compilerHost);
+            // 只检查当前文件的错误（避免重复报告全局错误）
+            const sourceFile = this.program.getSourceFile(id);
+            if (!sourceFile) {
+                return this.fallbackTransform(context, code, id);
+            }
+            const diagnostics = [
+                ...this.program.getSemanticDiagnostics(sourceFile),
+                ...this.program.getSyntacticDiagnostics(sourceFile),
+                ...this.program.getDeclarationDiagnostics(sourceFile)
+            ];
+            this.reportFileDiagnostics(context, diagnostics, id);
+            return code;
+        }
+        catch (error) {
+            context.error(`TypeScript transformation failed for ${id}: ${error}`);
+        }
+    }
+    static fallbackTransform(context, code, id) {
+        if (!this.tsCompilerOptions)
+            throw new Error("[ts]: can't find tsconfig");
+        try {
+            ts.createSourceFile(id, code, this.tsCompilerOptions.target || ts.ScriptTarget.ESNext);
+        }
+        catch (error) {
+            context.error(`Failed to parse TypeScript file ${id}: ${error}`);
+        }
+        return code;
+    }
+    static reportFileDiagnostics(context, diagnostics, fileName) {
+        if (diagnostics.length === 0)
+            return;
+        const errors = diagnostics.filter(d => d.category === ts.DiagnosticCategory.Error);
+        const warnings = diagnostics.filter(d => d.category === ts.DiagnosticCategory.Warning);
+        errors.forEach(diagnostic => {
+            if (diagnostic.file) {
+                const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+                const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+                context.error(`${fileName} (${line + 1},${character + 1}): ${message}`);
+            }
+        });
+        warnings.forEach(diagnostic => {
+            if (diagnostic.file) {
+                const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+                const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+                context.warn(`${fileName} (${line + 1},${character + 1}): ${message}`);
+            }
+        });
+        if (errors.length > 0) {
+            throw new Error(`TypeScript compilation failed with ${errors.length} error(s) in ${fileName}`);
+        }
+    }
+    static buildEnd(context) {
+        this.compilerHost = null;
+        this.program = null;
+        this.fileCache.clear();
+    }
+}
+
 function mcxPlugn(opt, output) {
     let cache = new Map();
     return {
@@ -10815,6 +10970,7 @@ function mcxPlugn(opt, output) {
         transform: async function (code, id) {
             const magic = new MagicString(code);
             const ext = path.extname(id).slice(1);
+            const tsRegex = /^.+?\.(ts|cts|mts|tsx|jsx)^/;
             if (ext == "mcx") {
                 let compileData;
                 try {
@@ -10832,21 +10988,31 @@ function mcxPlugn(opt, output) {
                         });
                     }
                     this.error(String(err));
+                    return;
                 }
                 compileData.setFilePath(id);
                 const compiledCode = await transform(compileData, cache, id, this, opt, output);
                 return {
                     code: compiledCode,
-                    map: magic.generateMap({ hires: true, source: id }),
+                    map: opt.sourcemap ? magic.generateMap({ hires: true, source: id }) : void 0,
+                };
+            }
+            else if (tsRegex.test(id)) {
+                const compiledCode = await TsHook.transformTs(this, code, id, opt);
+                return {
+                    code: compiledCode,
+                    map: opt.sourcemap ? magic.generateMap({ hires: true, source: id }) : void 0
                 };
             }
             return null;
         },
         buildEnd() {
             cache.clear();
+            TsHook.buildEnd(this);
         },
         buildStart() {
             cache = new Map();
+            TsHook.buildStart(this, opt);
         }
     };
 }
@@ -10855,147 +11021,14 @@ var types = /*#__PURE__*/Object.freeze({
     __proto__: null
 });
 
-class MCXVirtualCode {
-    id = 'root';
-    languageId = 'mcx';
-    mappings;
-    embeddedCodes = [];
-    snapshot;
-    constructor(snapshot) {
-        this.snapshot = snapshot;
-        const content = snapshot.getText(0, snapshot.getLength());
-        this.mappings = [{
-                sourceOffsets: [0],
-                generatedOffsets: [0],
-                lengths: [snapshot.getLength()],
-                data: {
-                    verification: false,
-                    completion: false,
-                    semantic: false,
-                    navigation: false,
-                    structure: false,
-                    format: false,
-                }
-            }];
-        const embeddedCode = this.extractScriptContent(content);
-        if (embeddedCode) {
-            this.embeddedCodes.push(embeddedCode);
-        }
-    }
-    extractScriptContent(content) {
-        try {
-            const compiled = compileMCXFn(content);
-            const scriptContent = compiled.strLoc.script;
-            if (!scriptContent || scriptContent.trim() === '') {
-                return null;
-            }
-            const scriptNode = compiled.raw.find(node => node.name === 'script');
-            if (!scriptNode) {
-                return null;
-            }
-            const isTypeScript = scriptNode.arr?.lang === 'ts';
-            const sourceOffset = this.calculateScriptOffset(content, scriptNode);
-            const scriptSnapshot = {
-                getText: (start, end) => scriptContent.slice(start, end),
-                getLength: () => scriptContent.length,
-                getChangeRange: () => undefined,
-            };
-            return {
-                id: 'script',
-                languageId: isTypeScript ? 'typescript' : 'javascript',
-                snapshot: scriptSnapshot,
-                mappings: [{
-                        sourceOffsets: [sourceOffset],
-                        generatedOffsets: [0],
-                        lengths: [scriptContent.length],
-                        data: {
-                            verification: true,
-                            completion: true,
-                            semantic: true,
-                            navigation: true,
-                            structure: true,
-                            format: true,
-                        }
-                    }],
-                embeddedCodes: [],
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    calculateScriptOffset(content, scriptNode) {
-        const startTagData = scriptNode.start.data;
-        const startTagIndex = content.indexOf(startTagData);
-        if (startTagIndex === -1) {
-            return 0;
-        }
-        return startTagIndex + startTagData.length;
-    }
-}
-/**
- * 创建 MCX 语言插件
- * @param tsModule TypeScript
- * @returns MCXLanguagePlugin
- */
-function createMCXLanguagePlugin(tsModule) {
-    return {
-        getLanguageId(scriptId) {
-            if (scriptId.endsWith('.mcx')) {
-                return 'mcx';
-            }
-            return undefined;
-        },
-        createVirtualCode(_scriptId, languageId, snapshot) {
-            if (languageId === 'mcx') {
-                return new MCXVirtualCode(snapshot);
-            }
-            return undefined;
-        },
-        typescript: {
-            extraFileExtensions: [
-                {
-                    extension: 'mcx',
-                    isMixedContent: true,
-                    scriptKind: tsModule.ScriptKind.JS,
-                },
-            ],
-            getServiceScript(virtualCode) {
-                const scriptCode = virtualCode.embeddedCodes?.find(code => code.languageId === 'typescript' || code.languageId === 'javascript');
-                if (!scriptCode) {
-                    return undefined;
-                }
-                const isTypeScript = scriptCode.languageId === 'typescript';
-                return {
-                    code: scriptCode,
-                    scriptKind: isTypeScript ? tsModule.ScriptKind.TS : tsModule.ScriptKind.JS,
-                    preventLeadingOffset: false,
-                    extension: isTypeScript ? '.ts' : '.js',
-                };
-            },
-        },
-    };
-}
-function createMCXVirtualCode(snapshot) {
-    return new MCXVirtualCode(snapshot);
-}
-
-var index = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    MCXVirtualCode: MCXVirtualCode,
-    createMCXLanguagePlugin: createMCXLanguagePlugin,
-    createMCXVirtualCode: createMCXVirtualCode
-});
-
-exports.AST = index$3;
+exports.AST = index$2;
 exports.BlockComponent = BlockComponent;
 exports.ComponentType = types$1;
 exports.EntityComponent = EntityComponent;
 exports.ItemComponent = ItemComponent;
 exports.PUBTYPE = types;
-exports.TSC = index;
-exports.compile_component = index$1;
-exports.compiler = index$2;
+exports.compile_component = index;
+exports.compiler = index$1;
 exports.plugin = mcxPlugn;
 exports.transform = transform;
 exports.utils = McxUtlis;