@mulanjs/mulanjs 1.0.1-dev.20260226191839 → 1.0.1-dev.20260227135307

package/dist/compiler/ast-parser.js

@@ -0,0 +1,221 @@
+"use strict";
+// --- AST Definitions ---
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTag = 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;
+                }
+                let tagContent = template.slice(cursor + 1, end);
+                const isSelfClosing = tagContent.endsWith('/') || ['img', 'br', 'input', 'hr', 'link', 'meta'].includes(tagContent.split(' ')[0].toLowerCase());
+                if (tagContent.endsWith('/')) {
+                    tagContent = tagContent.slice(0, -1).trim();
+                }
+                const { tag, props, directives } = parseTag(tagContent);
+                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;
+        }
+    }
+    return root;
+}
+exports.parse = parse;
+function parseTag(content) {
+    const parts = content.split(' ');
+    const tag = parts[0];
+    const props = {};
+    const directives = {};
+    const attrStr = content.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.js

@@ -19,7 +19,7 @@ async function compileSFC(source, filename, options) {
     }
     // 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

package/dist/compiler/dom-compiler.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileToDOM = void 0;
+const ast_parser_1 = require("./ast-parser");
 function compileToDOM(descriptor, scriptResult, scopedId) {
     console.log(`[MulanJS DOM Compiler v2.0] Compiling template for: ${descriptor.filename || 'anonymous'}`);
     const template = descriptor.template;
@@ -8,8 +9,8 @@ function compileToDOM(descriptor, scriptResult, scopedId) {
         return { code: 'function render() { return document.createDocumentFragment(); }', errors: [] };
     let html = template.content;
     const errors = [];
-    // 1. Parsing Phase (HTML -> AST) - We can reuse the parser logic, but for now we duplicate it to keep it isolated from the old string compiler
-    const ast = parse(html, errors);
+    // 1. Parsing Phase (HTML -> AST) - Unified Parser
+    const ast = (0, ast_parser_1.parse)(html, errors);
     // 2. Transform Phase (Scopes, Bindings)
     transform(ast, scriptResult, scopedId, [], descriptor.filename);
     // 3. Codegen Phase (AST -> JS DOM Instructions)
@@ -177,9 +178,7 @@ function generateDOMInstruction(node, chunks, getUid, uidRef, bindings, localSco
         if (element._propertySideEffects) {
             const effects = element._propertySideEffects;
             for (const effect of effects) {
-                // effect strings look like: `this._b('mu_abc', 'style', ...)` 
-                // We need to translate them to direct assignments, but the original transform already stripped the 'data-mu-id'.
-                // Let's rely on the DOM-specific transform logic we will write below.
+                // ...
             }
         }
         // Handle DOM-specific Bindings
@@ -205,127 +204,7 @@ function generateDOMInstruction(node, chunks, getUid, uidRef, bindings, localSco
     }
     return null;
 }
-// --- Copied Parser and Transformer ---
-// For this standalone compiler test, we duplicate the parser functions.
-// In the final refactor, these will be extracted to a shared `parse.ts` utility.
-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];
-        if (template.startsWith('<!--', cursor)) {
-            const end = template.indexOf('-->', cursor);
-            if (end === -1)
-                break;
-            cursor = end + 3;
-        }
-        else if (char === '<') {
-            if (template[cursor + 1] === '/') {
-                const end = template.indexOf('>', cursor);
-                if (end === -1)
-                    break;
-                stack.pop();
-                cursor = end + 1;
-            }
-            else {
-                const end = template.indexOf('>', cursor);
-                if (end === -1)
-                    break;
-                let tagContent = template.slice(cursor + 1, end);
-                const isSelfClosing = tagContent.endsWith('/') || ['img', 'br', 'input', 'hr'].includes(tagContent.split(' ')[0]);
-                if (tagContent.endsWith('/'))
-                    tagContent = tagContent.slice(0, -1).trim();
-                const { tag, props, directives } = parseTag(tagContent);
-                const element = { type: 'Element', tag, props, children: [], directives };
-                stack[stack.length - 1].children.push(element);
-                if (!isSelfClosing)
-                    stack.push(element);
-                cursor = end + 1;
-            }
-        }
-        else if (char === '{' && template[cursor + 1] === '{') {
-            const end = template.indexOf('}}', cursor);
-            if (end === -1)
-                break;
-            const content = template.slice(cursor + 2, end).trim();
-            stack[stack.length - 1].children.push({ type: 'Interpolation', content });
-            cursor = end + 2;
-        }
-        else {
-            let nextTag = template.indexOf('<', cursor);
-            let nextInterp = template.indexOf('{{', cursor);
-            let end = template.length;
-            if (nextTag !== -1 && nextTag < end)
-                end = nextTag;
-            if (nextInterp !== -1 && nextInterp < end)
-                end = nextInterp;
-            const content = template.slice(cursor, end);
-            if (content.trim() || content === ' ') {
-                stack[stack.length - 1].children.push({ type: 'Text', content });
-            }
-            cursor = end;
-        }
-    }
-    return root;
-}
-function parseTag(content) {
-    const parts = content.split(' ');
-    const tag = parts[0];
-    const props = {};
-    const directives = {};
-    const attrStr = content.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 ');
-            directives.vFor = { item: parts[0].trim(), list: parts.slice(1).join(' in ').trim() };
-        }
-        else if (key)
-            props[key] = value;
-    }
-    return { tag, props, directives };
-}
+// --- Transformer Re-implementation ---
 const JS_KEYWORDS = new Set(['true', 'false', 'null', 'undefined', 'this', 'window', 'if', 'else', 'for', 'while', 'return', 'let', 'const', 'typeof', 'instanceof', 'Math', 'Object', 'Array', 'JSON', 'console']);
 function processBindings(exp, bindings, localScope) {
     const isOptionsAPI = !bindings || bindings.length === 0;