nexa-compiler 0.7.1 → 0.7.2

package/dist/codegen/template.js

@@ -40,7 +40,13 @@ function genIf(node) {
 }
 function genFor(node) {
     const childrenCode = node.children.length === 1 ? genNode(node.children[0]) : `h("div", null, [\n        ${node.children.map(genNode).join(',\n        ')}\n      ])`;
-    return `${node.list}.map((${node.item}, ${node.index}) => ${childrenCode})`;
+    return genForIterate(node.list, node.item, node.index, childrenCode);
+}
+function genForIterate(list, item, index, body) {
+    if (/^\d+$/.test(list)) {
+        return `Array.from({length: ${list}}, (_, ${item}) =>\n        ${body}\n      )`;
+    }
+    return `(${list}).map((${item}, ${index}) =>\n        ${body}\n      )`;
 }
 function genElement(node) {
     const { tag, props, children } = node;
@@ -48,7 +54,7 @@ function genElement(node) {
     const elementCode = buildElementCode(tag, props, childStr, node.scopeId);
     if (node.vFor) {
         const { item, index, list } = node.vFor;
-        return `${list}.map((${item}, ${index}) =>\n        ${elementCode}\n      )`;
+        return genForIterate(list, item, index, elementCode);
     }
     // Note: v-if is handled by transformChildren and genIf
     return elementCode;

package/dist/parse/errors.d.ts

@@ -0,0 +1,48 @@
+export interface SourceLocation {
+    line: number;
+    column: number;
+    offset: number;
+}
+export interface CompilerError {
+    code: string;
+    message: string;
+    location: SourceLocation;
+    endLocation?: SourceLocation;
+    suggestion?: string;
+    helpUrl?: string;
+}
+declare const ERROR_CODES: {
+    readonly E001: "UNCLOSED_TAG";
+    readonly E002: "UNEXPECTED_CLOSING_TAG";
+    readonly E003: "INVALID_TAG_NAME";
+    readonly E004: "MALFORMED_ATTRIBUTE";
+    readonly E005: "MISSING_ATTRIBUTE_VALUE";
+    readonly E006: "INVALID_EXPRESSION";
+    readonly E007: "UNCLOSED_MUSTACHE";
+    readonly E008: "V_FOR_REQUIRED";
+    readonly E009: "V_IF_REQUIRED";
+    readonly E010: "SELF_CLOSING_NON_VOID";
+    readonly E011: "DUPLICATE_ATTRIBUTE";
+    readonly E012: "INVALID_DIRECTIVE";
+    readonly E013: "UNCLOSED_COMMENT";
+    readonly E014: "NESTED_SFC_TAG";
+    readonly E015: "MISSING_CLOSING_BRACKET";
+};
+type ErrorCode = keyof typeof ERROR_CODES;
+export declare class NexaCompilerError extends Error {
+    readonly code: string;
+    readonly location: SourceLocation;
+    readonly endLocation?: SourceLocation;
+    readonly suggestion?: string;
+    readonly helpUrl?: string;
+    constructor(error: CompilerError);
+    toString(): string;
+    toMarkdown(): string;
+}
+export declare function createError(code: ErrorCode, message: string, location: SourceLocation, options?: {
+    endLocation?: SourceLocation;
+    suggestion?: string;
+    helpUrl?: string;
+}): NexaCompilerError;
+export declare function getErrorHelp(code: string): string | undefined;
+export { ERROR_CODES };

package/dist/parse/errors.js

@@ -0,0 +1,85 @@
+const ERROR_CODES = {
+    E001: 'UNCLOSED_TAG',
+    E002: 'UNEXPECTED_CLOSING_TAG',
+    E003: 'INVALID_TAG_NAME',
+    E004: 'MALFORMED_ATTRIBUTE',
+    E005: 'MISSING_ATTRIBUTE_VALUE',
+    E006: 'INVALID_EXPRESSION',
+    E007: 'UNCLOSED_MUSTACHE',
+    E008: 'V_FOR_REQUIRED',
+    E009: 'V_IF_REQUIRED',
+    E010: 'SELF_CLOSING_NON_VOID',
+    E011: 'DUPLICATE_ATTRIBUTE',
+    E012: 'INVALID_DIRECTIVE',
+    E013: 'UNCLOSED_COMMENT',
+    E014: 'NESTED_SFC_TAG',
+    E015: 'MISSING_CLOSING_BRACKET',
+};
+export class NexaCompilerError extends Error {
+    code;
+    location;
+    endLocation;
+    suggestion;
+    helpUrl;
+    constructor(error) {
+        super(error.message);
+        this.name = 'NexaCompilerError';
+        this.code = error.code;
+        this.location = error.location;
+        this.endLocation = error.endLocation;
+        this.suggestion = error.suggestion;
+        this.helpUrl = error.helpUrl;
+    }
+    toString() {
+        const location = formatLocation(this.location);
+        let result = `\n${this.code}: ${this.message}\n`;
+        result += `  at ${location}\n`;
+        if (this.suggestion) {
+            result += `\n  Suggestion: ${this.suggestion}\n`;
+        }
+        return result;
+    }
+    toMarkdown() {
+        const location = formatLocation(this.location);
+        let result = `### ${this.code}: ${this.message}\n\n`;
+        result += `**Location:** ${location}\n`;
+        if (this.suggestion) {
+            result += `\n**Suggestion:** ${this.suggestion}\n`;
+        }
+        if (this.helpUrl) {
+            result += `\n**Learn more:** ${this.helpUrl}\n`;
+        }
+        return result;
+    }
+}
+function formatLocation(loc) {
+    return `${loc.line}:${loc.column}`;
+}
+function getLineCol(text, offset) {
+    const lines = text.slice(0, offset).split('\n');
+    return {
+        line: lines.length,
+        column: (lines[lines.length - 1]?.length || 0) + 1,
+        offset,
+    };
+}
+export function createError(code, message, location, options) {
+    return new NexaCompilerError({
+        code: ERROR_CODES[code],
+        message,
+        location,
+        ...options,
+    });
+}
+export function getErrorHelp(code) {
+    const helpUrls = {
+        E001: 'https://nexajs.dev/docs/compiler/errors#e001',
+        E002: 'https://nexajs.dev/docs/compiler/errors#e002',
+        E007: 'https://nexajs.dev/docs/compiler/errors#e007',
+        E008: 'https://nexajs.dev/docs/compiler/errors#e008',
+        E009: 'https://nexajs.dev/docs/compiler/errors#e009',
+        E010: 'https://nexajs.dev/docs/compiler/errors#e010',
+    };
+    return helpUrls[code];
+}
+export { ERROR_CODES };

package/dist/parse/template.js

@@ -1,40 +1,79 @@
+import { createError, getErrorHelp } from './errors.js';
 const tagRegex = /<(\/?)(\w[\w-]*)((?:\s+[^'">\s/]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^>\s/]+))?)*)\s*(\/?)>/g;
-const attrRegex = /([#@:]?[\w.-]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|(\{[^}]+\})))?/g;
+const attrRegex = /([#@:]?[\w.:-]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|(\{[^}]+\})))?/g;
 const mustacheRegex = /\{\{(.*?)\}\}/g;
+const voidElements = new Set([
+    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+    'link', 'meta', 'param', 'source', 'track', 'wbr',
+]);
 export function parseTemplate(template) {
     template = template.replace(/<!--[\s\S]*?-->/g, '');
     const root = { type: 'root', children: [] };
-    const stack = [root.children];
+    const stack = [];
     let lastIndex = 0;
     let match;
     tagRegex.lastIndex = 0;
     while ((match = tagRegex.exec(template)) !== null) {
         const [, isClose, tag, attrsStr, selfClose] = match;
         const matchStart = match.index;
-        // Process text between tags
         if (matchStart > lastIndex) {
             const text = template.slice(lastIndex, matchStart);
             const nodes = parseText(text);
             for (const node of nodes) {
-                stack[stack.length - 1].push(node);
+                const parentStack = stack.length > 0 ? stack[stack.length - 1] : null;
+                if (parentStack && 'children' in parentStack.node) {
+                    parentStack.node.children.push(node);
+                }
+                else {
+                    root.children.push(node);
+                }
             }
         }
         if (isClose) {
-            // Closing tag
-            if (stack.length > 1) {
-                stack.pop();
+            if (stack.length === 0) {
+                const location = getLineCol(template, matchStart);
+                const topTag = stack.length > 0 ? stack[stack.length - 1].tag : null;
+                const suggestion = topTag
+                    ? `Did you mean to close </${topTag}> instead?`
+                    : `This closing tag has no matching opening tag.`;
+                throw createError('E002', `Unexpected closing tag </${tag}>`, location, {
+                    suggestion,
+                    helpUrl: getErrorHelp('E002'),
+                });
+            }
+            const parent = stack[stack.length - 1];
+            if (parent.tag !== tag) {
+                const location = getLineCol(template, matchStart);
+                throw createError('E002', `Unexpected closing tag </${tag}>. Expected </${parent.tag}>`, location, {
+                    suggestion: `Did you mean </${parent.tag}>?`,
+                    helpUrl: getErrorHelp('E002'),
+                });
+            }
+            stack.pop();
+            lastIndex = tagRegex.lastIndex;
+            continue;
+        }
+        const attrs = parseAttrs(attrsStr.trim(), template, matchStart);
+        const isVoid = isVoidElement(tag);
+        const isSelfClosing = selfClose === '/' || isVoid;
+        if (isSelfClosing) {
+            const parentStack = stack.length > 0 ? stack[stack.length - 1] : null;
+            const node = { type: 'element', tag, attrs, children: [], isSelfClosing: true };
+            if (parentStack && 'children' in parentStack.node) {
+                parentStack.node.children.push(node);
+            }
+            else {
+                root.children.push(node);
             }
             lastIndex = tagRegex.lastIndex;
             continue;
         }
-        const attrs = parseAttrs(attrsStr.trim());
-        const isSelfClosing = selfClose === '/' || isVoidElement(tag);
         const node = {
             type: 'element',
             tag,
             attrs,
             children: [],
-            isSelfClosing: isSelfClosing,
+            isSelfClosing: false,
         };
         const isSlot = tag === 'slot';
         if (isSlot) {
@@ -42,41 +81,66 @@ export function parseTemplate(template) {
                 type: 'slot',
                 name: attrs.find(a => a.name === 'name')?.value || 'default',
                 attrs,
-                children: []
+                children: [],
             };
-            stack[stack.length - 1].push(slotNode);
-            if (!isSelfClosing) {
-                stack.push(slotNode.children);
+            const parentStack = stack.length > 0 ? stack[stack.length - 1] : null;
+            if (parentStack && 'children' in parentStack.node) {
+                parentStack.node.children.push(slotNode);
+            }
+            else {
+                root.children.push(slotNode);
             }
+            stack.push({ tag, node: slotNode, start: matchStart });
         }
         else {
-            stack[stack.length - 1].push(node);
-            if (!isSelfClosing) {
-                stack.push(node.children);
+            const parentStack = stack.length > 0 ? stack[stack.length - 1] : null;
+            if (parentStack && 'children' in parentStack.node) {
+                parentStack.node.children.push(node);
             }
+            else {
+                root.children.push(node);
+            }
+            stack.push({ tag, node, start: matchStart });
         }
         lastIndex = tagRegex.lastIndex;
     }
-    // Process remaining text
+    if (stack.length > 0) {
+        const unclosed = stack[stack.length - 1];
+        const location = getLineCol(template, unclosed.start);
+        throw createError('E001', `Unclosed tag <${unclosed.tag}>`, location, {
+            suggestion: `Add closing </${unclosed.tag}> tag after the content.`,
+            helpUrl: getErrorHelp('E001'),
+        });
+    }
     if (lastIndex < template.length) {
         const text = template.slice(lastIndex);
         const nodes = parseText(text);
         for (const node of nodes) {
-            stack[stack.length - 1].push(node);
+            root.children.push(node);
         }
     }
     return root;
 }
-function parseAttrs(attrsStr) {
+function parseAttrs(attrsStr, template, tagStart) {
     if (!attrsStr)
         return [];
     const attrs = [];
     attrRegex.lastIndex = 0;
+    const seenAttrs = new Map();
     let match;
     while ((match = attrRegex.exec(attrsStr)) !== null) {
         let rawName = match[1];
         let quotedValue = match[2] ?? match[3] ?? match[4];
         const isDynamic = rawName.startsWith(':') || rawName.startsWith('@');
+        if (seenAttrs.has(rawName)) {
+            const attrIndex = tagStart + 4 + attrsStr.indexOf(rawName);
+            const location = getLineCol(template, attrIndex);
+            throw createError('E011', `Duplicate attribute "${rawName}"`, location, {
+                suggestion: `Remove one of the duplicate attributes.`,
+                helpUrl: getErrorHelp('E011'),
+            });
+        }
+        seenAttrs.set(rawName, match.index);
         let name;
         if (rawName.startsWith(':')) {
             name = rawName.slice(1);
@@ -102,6 +166,17 @@ function parseAttrs(attrsStr) {
     }
     return attrs;
 }
+function isVoidElement(tag) {
+    return voidElements.has(tag);
+}
+function getLineCol(text, offset) {
+    const lines = text.slice(0, offset).split('\n');
+    return {
+        line: lines.length,
+        column: (lines[lines.length - 1]?.length || 0) + 1,
+        offset,
+    };
+}
 function decodeEntities(text) {
     return text.replace(/&[a-zA-Z#]+;/g, match => {
         const entities = {
@@ -120,6 +195,10 @@ function parseText(text) {
         if (match.index > lastIdx) {
             nodes.push({ type: 'text', content: decodeEntities(text.slice(lastIdx, match.index)) });
         }
+        if (!match[1].trim()) {
+            lastIdx = mustacheRegex.lastIndex;
+            continue;
+        }
         nodes.push({ type: 'expression', content: match[1].trim() });
         lastIdx = mustacheRegex.lastIndex;
     }
@@ -128,10 +207,3 @@ function parseText(text) {
     }
     return nodes;
 }
-const voidElements = new Set([
-    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
-    'link', 'meta', 'param', 'source', 'track', 'wbr',
-]);
-function isVoidElement(tag) {
-    return voidElements.has(tag);
-}

package/dist/transform/template.js

@@ -7,6 +7,13 @@ function transformNode(node, scopeId) {
         case 'comment':
             return { type: 'comment' };
         case 'element': {
+            if (node.tag === 'slot') {
+                const dynamicAttrs = node.attrs.filter(a => a.dynamic && a.name !== 'name');
+                const slotProps = dynamicAttrs.length > 0
+                    ? dynamicAttrs.map(a => `${a.name}: ${a.value}`).join(', ')
+                    : undefined;
+                return { type: 'slot', name: node.attrs.find(a => a.name === 'name')?.value || 'default', slotProps, children: node.children?.map(c => transformNode(c)) };
+            }
             const vForAttr = node.attrs.find(a => a.name === 'v-for');
             const vIfAttr = node.attrs.find(a => a.name === 'v-if');
             const filteredAttrs = node.attrs.filter(a => a.name !== 'v-if' && a.name !== 'v-for');
@@ -118,10 +125,16 @@ function genProps(attrs, tag) {
             continue;
         if (attr.name === 'class')
             continue;
+        if (tag === 'slot' && attr.name === 'name')
+            continue;
         let propName = attr.name;
         if (propName.startsWith('v-')) {
             propName = propName.split('-').map((s, i) => i === 0 ? s : s.charAt(0).toUpperCase() + s.slice(1)).join('');
         }
+        const isComponentTag = /^[A-Z]/.test(tag) || tag.includes('-');
+        if (isComponentTag && propName.includes('-')) {
+            propName = propName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+        }
         if (propName === 'vShow' && typeof attr.value === 'string') {
             parts.push(`${propName}: ${attr.value}`);
         }
@@ -164,7 +177,8 @@ function genProps(attrs, tag) {
                     handler = `($event) => { $event.stopPropagation(); (${handler})($event) }`;
                 }
             }
-            parts.push(`${realName}: ${handler}`);
+            const safeKey = /[^a-zA-Z0-9_$]/.test(realName) ? JSON.stringify(realName) : realName;
+            parts.push(`${safeKey}: ${handler}`);
         }
         else if (attr.dynamic) {
             const key = /[^a-zA-Z0-9_$]/.test(propName) ? JSON.stringify(propName) : propName;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexa-compiler",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",