@mulanjs/mulanjs 1.0.1-dev.20260227091247 → 1.0.1-dev.20260227172006

package/dist/compiler/ast-parser.d.ts

@@ -0,0 +1,48 @@
+export type NodeType = 'Element' | 'Text' | 'Interpolation';
+export type Node = ElementNode | TextNode | InterpolationNode;
+export interface BaseNode {
+    type: NodeType;
+    isStatic?: boolean;
+}
+export interface ElementNode extends BaseNode {
+    type: 'Element';
+    tag: string;
+    props: Record<string, string>;
+    children: Node[];
+    directives: {
+        vFor?: {
+            item: string;
+            list: string;
+        };
+        vIf?: string;
+    };
+}
+export interface TextNode extends BaseNode {
+    type: 'Text';
+    content: string;
+}
+export interface InterpolationNode extends BaseNode {
+    type: 'Interpolation';
+    content: string;
+}
+/**
+ * Decodes standard HTML entities.
+ */
+export declare function decodeEntities(str: string): string;
+/**
+ * Unified MulanJS Template Parser
+ * Handles HTML tags, {{ }} interpolation, and is robust against raw < symbols in text.
+ */
+export declare function parse(template: string, errors: string[]): ElementNode;
+export declare function markStatic(node: Node): boolean;
+export declare function parseTag(content: string): {
+    tag: string;
+    props: Record<string, string>;
+    directives: {
+        vFor?: {
+            item: string;
+            list: string;
+        };
+        vIf?: string;
+    };
+};

package/dist/compiler/ast-parser.js

@@ -0,0 +1,266 @@
+"use strict";
+// --- AST Definitions ---
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTag = exports.markStatic = exports.parse = exports.decodeEntities = void 0;
+/**
+ * Decodes standard HTML entities.
+ */
+function decodeEntities(str) {
+    return str
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&')
+        .replace(/&quot;/g, '"')
+        .replace(/&#039;/g, "'")
+        .replace(/&nbsp;/g, '\u00A0');
+}
+exports.decodeEntities = decodeEntities;
+/**
+ * Unified MulanJS Template Parser
+ * Handles HTML tags, {{ }} interpolation, and is robust against raw < symbols in text.
+ */
+function parse(template, errors) {
+    const root = {
+        type: 'Element',
+        tag: 'fragment',
+        props: {},
+        children: [],
+        directives: {}
+    };
+    const stack = [root];
+    let cursor = 0;
+    while (cursor < template.length) {
+        const char = template[cursor];
+        // 1. Comments
+        if (template.startsWith('<!--', cursor)) {
+            const end = template.indexOf('-->', cursor);
+            if (end === -1) {
+                errors.push('Unclosed HTML comment.');
+                break;
+            }
+            cursor = end + 3;
+        }
+        // 2. Tags (with lookahead check for robustness)
+        else if (char === '<' && /[\/a-zA-Z!]/.test(template[cursor + 1])) {
+            if (template[cursor + 1] === '/') {
+                // Closing Tag
+                const end = template.indexOf('>', cursor);
+                if (end === -1) {
+                    errors.push('Unclosed closing tag.');
+                    break;
+                }
+                const tagName = template.slice(cursor + 2, end).trim();
+                // Find matching element in stack to pop
+                if (stack.length > 1 && stack[stack.length - 1].tag === tagName) {
+                    stack.pop();
+                }
+                else {
+                    errors.push(`Mismatched closing tag </${tagName}>.`);
+                }
+                cursor = end + 1;
+            }
+            else {
+                // Opening Tag
+                const end = template.indexOf('>', cursor);
+                if (end === -1) {
+                    errors.push('Unclosed opening tag.');
+                    break;
+                }
+                const tagContent = template.slice(cursor + 1, end);
+                const { tag, props, directives } = parseTag(tagContent);
+                const isSelfClosing = tagContent.endsWith('/') || ['img', 'br', 'input', 'hr', 'link', 'meta'].includes(tag.toLowerCase());
+                const element = { type: 'Element', tag, props, children: [], directives };
+                stack[stack.length - 1].children.push(element);
+                if (!isSelfClosing) {
+                    stack.push(element);
+                }
+                cursor = end + 1;
+            }
+        }
+        // 3. Interpolation {{ }}
+        else if (template.startsWith('{{', cursor)) {
+            const end = template.indexOf('}}', cursor);
+            if (end === -1) {
+                errors.push('Unclosed interpolation {{ }}.');
+                break;
+            }
+            const content = template.slice(cursor + 2, end).trim();
+            stack[stack.length - 1].children.push({ type: 'Interpolation', content });
+            cursor = end + 2;
+        }
+        // 4. Native Template Literals ${ } (Protection)
+        else if (template.startsWith('${', cursor)) {
+            // Find end of ${ } while respecting nested braces
+            let innerCursor = cursor + 2;
+            let depth = 1;
+            while (innerCursor < template.length && depth > 0) {
+                if (template[innerCursor] === '{')
+                    depth++;
+                if (template[innerCursor] === '}')
+                    depth--;
+                innerCursor++;
+            }
+            const content = template.slice(cursor, innerCursor);
+            // Treat as text but this block is now "atomic" and won't be split by < checks
+            const lastChild = stack[stack.length - 1].children[stack[stack.length - 1].children.length - 1];
+            if (lastChild && lastChild.type === 'Text') {
+                lastChild.content += content;
+            }
+            else {
+                stack[stack.length - 1].children.push({ type: 'Text', content });
+            }
+            cursor = innerCursor;
+        }
+        // 5. Text Nodes
+        else {
+            let nextTag = template.indexOf('<', cursor);
+            let nextInterp = template.indexOf('{{', cursor);
+            let nextNative = template.indexOf('${', cursor);
+            let end = template.length;
+            // Heuristic for nextTag: it must look like a tag start
+            while (nextTag !== -1) {
+                if (/[\/a-zA-Z!]/.test(template[nextTag + 1])) {
+                    break;
+                }
+                nextTag = template.indexOf('<', nextTag + 1);
+            }
+            if (nextTag !== -1 && nextTag < end)
+                end = nextTag;
+            if (nextInterp !== -1 && nextInterp < end)
+                end = nextInterp;
+            if (nextNative !== -1 && nextNative < end)
+                end = nextNative;
+            const rawContent = template.slice(cursor, end);
+            const content = decodeEntities(rawContent);
+            if (content) {
+                const lastChild = stack[stack.length - 1].children[stack[stack.length - 1].children.length - 1];
+                if (lastChild && lastChild.type === 'Text') {
+                    lastChild.content += content;
+                }
+                else {
+                    stack[stack.length - 1].children.push({ type: 'Text', content });
+                }
+            }
+            cursor = end;
+        }
+    }
+    markStatic(root);
+    return root;
+}
+exports.parse = parse;
+function markStatic(node) {
+    if (node.type === 'Interpolation') {
+        node.isStatic = false;
+        return false;
+    }
+    if (node.type === 'Text') {
+        const text = node;
+        node.isStatic = !text.content.includes('${');
+        return node.isStatic;
+    }
+    if (node.type === 'Element') {
+        const element = node;
+        let isStatic = true;
+        // 1. Directives make it dynamic
+        if (element.directives.vIf || element.directives.vFor) {
+            isStatic = false;
+        }
+        // 2. Dynamic properties or event listeners make it dynamic
+        if (isStatic) {
+            for (const key in element.props) {
+                const val = element.props[key];
+                if (key.startsWith('@') || key.startsWith('v-on:') || key.startsWith('on') || key.startsWith(':') || key.startsWith('.')) {
+                    isStatic = false;
+                    break;
+                }
+                if (val.includes('${')) {
+                    isStatic = false;
+                    break;
+                }
+            }
+        }
+        // 3. Check all children. Every child must be static for the parent to be static.
+        // We still need to call markStatic on ALL children, so don't short-circuit the loop early.
+        for (const child of element.children) {
+            const childStatic = markStatic(child);
+            if (!childStatic) {
+                isStatic = false;
+            }
+        }
+        element.isStatic = isStatic;
+        return isStatic;
+    }
+    return false;
+}
+exports.markStatic = markStatic;
+function parseTag(content) {
+    // 1. Extract tag name (first word, ignoring leading whitespace)
+    const tagMatch = content.trim().match(/^([a-zA-Z0-9:-]+)/);
+    const tag = tagMatch ? tagMatch[1] : '';
+    const props = {};
+    const directives = {};
+    // 2. Remove tag name from content to parse attributes
+    const attrStr = content.trim().slice(tag.length).trim();
+    let i = 0;
+    while (i < attrStr.length) {
+        if (/\s/.test(attrStr[i])) {
+            i++;
+            continue;
+        }
+        const keyStart = i;
+        while (i < attrStr.length && !/\s|=/.test(attrStr[i])) {
+            i++;
+        }
+        const key = attrStr.slice(keyStart, i);
+        let value = 'true';
+        let peek = i;
+        while (peek < attrStr.length && /\s/.test(attrStr[peek]))
+            peek++;
+        if (peek < attrStr.length && attrStr[peek] === '=') {
+            i = peek + 1;
+            while (i < attrStr.length && /\s/.test(attrStr[i]))
+                i++;
+            if (i < attrStr.length && (attrStr[i] === '"' || attrStr[i] === "'")) {
+                const quote = attrStr[i];
+                i++;
+                const valStart = i;
+                while (i < attrStr.length && attrStr[i] !== quote) {
+                    if (attrStr[i] === '\\' && attrStr[i + 1] === quote) {
+                        i += 2;
+                    }
+                    else {
+                        i++;
+                    }
+                }
+                value = attrStr.slice(valStart, i);
+                i++;
+            }
+            else {
+                const valStart = i;
+                while (i < attrStr.length && !/\s/.test(attrStr[i])) {
+                    i++;
+                }
+                value = attrStr.slice(valStart, i);
+            }
+        }
+        if (key === 'v-if' || key === 'mu-if') {
+            directives.vIf = value;
+        }
+        else if (key === 'v-for' || key === 'mu-for') {
+            const parts = value.split(' in ');
+            if (parts.length < 2) {
+                directives.vFor = { item: '_item', list: '[]' };
+            }
+            else {
+                const item = parts[0];
+                const list = parts.slice(1).join(' in ');
+                directives.vFor = { item: item.trim(), list: list.trim() };
+            }
+        }
+        else if (key) {
+            props[key] = value;
+        }
+    }
+    return { tag, props, directives };
+}
+exports.parseTag = parseTag;

package/dist/compiler/compiler.d.ts

@@ -0,0 +1,9 @@
+import { CompilerOptions } from './script-compiler';
+export interface CompileResult {
+    code: string;
+    css: string;
+    errors: string[];
+    map?: string;
+}
+export declare function compileSFC(source: string, filename: string, options?: CompilerOptions): Promise<CompileResult>;
+export declare function compileSFCForSSR(source: string, filename: string, options?: CompilerOptions): Promise<CompileResult>;

package/dist/compiler/compiler.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileSFC = void 0;
+exports.compileSFCForSSR = exports.compileSFC = void 0;
 const sfc_parser_1 = require("./sfc-parser");
 const script_compiler_1 = require("./script-compiler");
 const dom_compiler_1 = require("./dom-compiler");
 const style_compiler_1 = require("./style-compiler");
+const ssr_compiler_1 = require("./ssr-compiler");
 const source_map_1 = require("source-map");
 async function compileSFC(source, filename, options) {
     // 1. Parse
@@ -17,9 +18,12 @@ async function compileSFC(source, filename, options) {
     if (!scriptCode.includes('const __component__ =')) {
         scriptCode = scriptCode.replace(/export\s+default/, 'const __component__ =');
     }
+    if (!scriptCode.includes('const __component__ =')) {
+        scriptCode = scriptCode.replace('exports.default =', 'const __component__ =');
+    }
     // 3. Style
     const styleResult = (0, style_compiler_1.compileStyle)(descriptor, filename, options);
-    // 4. Template (Use the new No-VDOM compiler!)
+    // 4. Template (Use the new unified No-VDOM compiler!)
     const templateResult = (0, dom_compiler_1.compileToDOM)(descriptor, scriptResult, styleResult.scopedId);
     // Calculate offsets for source map merging
     // 1. Script Code
@@ -153,7 +157,7 @@ if (typeof module !== 'undefined' && module.hot) {
 }
 
 // console.log('[MulanJS] Component created:', __component__);
-export default __component__;
+module.exports = __component__;
 
 // Helper to get relative path for sourceURL
 // This ensures the generated file appears in a readable folder structure in DevTools
@@ -167,3 +171,42 @@ export default __component__;
     };
 }
 exports.compileSFC = compileSFC;
+// --- Mulan Server Components (MSC) ---
+async function compileSFCForSSR(source, filename, options) {
+    const descriptor = (0, sfc_parser_1.parseMUJS)(source, filename);
+    const scriptResult = await (0, script_compiler_1.compileScript)(descriptor, options);
+    let scriptCode = scriptResult.code;
+    // Robust replacement for various export styles
+    if (scriptCode.includes('export default')) {
+        scriptCode = scriptCode.replace('export default', 'const __component__ =');
+    }
+    else if (scriptCode.includes('exports.default =')) {
+        scriptCode = scriptCode.replace('exports.default =', 'const __component__ =');
+    }
+    else if (scriptCode.includes('module.exports =')) {
+        scriptCode = scriptCode.replace('module.exports =', 'const __component__ =');
+    }
+    else {
+        // Fallback: search for defineComponent if it's there
+        scriptCode += `\nconst __component__ = typeof exports !== 'undefined' ? (exports.default || module.exports) : {};`;
+    }
+    const templateResult = (0, ssr_compiler_1.compileToSSR)(descriptor, scriptResult, undefined);
+    const finalCode = `${scriptCode}
+
+${templateResult.code}
+
+if (__component__.prototype) {
+    __component__.prototype.renderToString = render;
+} else if (typeof __component__ === 'object') {
+    __component__.renderToString = render;
+}
+
+module.exports = __component__;
+`;
+    return {
+        code: finalCode,
+        css: '', // CSS handling for SSR can be extracted separately
+        errors: [...scriptResult.errors, ...templateResult.errors],
+    };
+}
+exports.compileSFCForSSR = compileSFCForSSR;

package/dist/compiler/dom-compiler.d.ts

@@ -0,0 +1,7 @@
+import { SFCDescriptor } from './sfc-parser';
+import { ScriptCompileResult } from './script-compiler';
+export interface DOMCompileResult {
+    code: string;
+    errors: string[];
+}
+export declare function compileToDOM(descriptor: SFCDescriptor, scriptResult: ScriptCompileResult, scopedId?: string): DOMCompileResult;