@zenithbuild/compiler 1.0.2

package/dist/parse/parseTemplate.js

@@ -0,0 +1,487 @@
+/**
+ * Template Parser
+ *
+ * Parses HTML template and extracts expressions
+ * Phase 1: Only extracts, does not execute
+ */
+import { parseFragment } from 'parse5';
+import { CompilerError, InvariantError } from '../errors/compilerError';
+import { shouldAttachLoopContext, mergeLoopContext, extractLoopContextFromExpression } from './trackLoopContext';
+import { INVARIANT } from '../validate/invariants';
+import { lowerFragments } from '../transform/fragmentLowering';
+// Generate stable IDs for expressions
+let expressionIdCounter = 0;
+function generateExpressionId() {
+    return `expr_${expressionIdCounter++}`;
+}
+/**
+ * Strip script and style blocks from HTML before parsing
+ */
+function stripBlocks(html) {
+    // Remove script blocks
+    let stripped = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '');
+    // Remove style blocks
+    stripped = stripped.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
+    return stripped;
+}
+/**
+ * Find the end of a balanced brace expression, handling strings and template literals
+ * Returns the index after the closing brace, or -1 if unbalanced
+ */
+function findBalancedBraceEnd(html, startIndex) {
+    let braceCount = 1;
+    let i = startIndex + 1;
+    let inString = false;
+    let stringChar = '';
+    let inTemplate = false;
+    while (i < html.length && braceCount > 0) {
+        const char = html[i];
+        const prevChar = i > 0 ? html[i - 1] : '';
+        // Handle escape sequences
+        if (prevChar === '\\') {
+            i++;
+            continue;
+        }
+        // Handle string literals (not inside template)
+        if (!inString && !inTemplate && (char === '"' || char === "'")) {
+            inString = true;
+            stringChar = char;
+            i++;
+            continue;
+        }
+        if (inString && char === stringChar) {
+            inString = false;
+            stringChar = '';
+            i++;
+            continue;
+        }
+        // Handle template literals
+        if (!inString && !inTemplate && char === '`') {
+            inTemplate = true;
+            i++;
+            continue;
+        }
+        if (inTemplate && char === '`') {
+            inTemplate = false;
+            i++;
+            continue;
+        }
+        // Handle ${} inside template literals - need to track nested braces
+        if (inTemplate && char === '$' && html[i + 1] === '{') {
+            // Skip the ${ and count as opening brace
+            i += 2;
+            let templateBraceCount = 1;
+            while (i < html.length && templateBraceCount > 0) {
+                if (html[i] === '{')
+                    templateBraceCount++;
+                else if (html[i] === '}')
+                    templateBraceCount--;
+                i++;
+            }
+            continue;
+        }
+        // Count braces only when not in strings or templates
+        if (!inString && !inTemplate) {
+            if (char === '{')
+                braceCount++;
+            else if (char === '}')
+                braceCount--;
+        }
+        i++;
+    }
+    return braceCount === 0 ? i : -1;
+}
+/**
+ * Normalize expressions before parsing
+ * Replaces both attr={expr} and {textExpr} with placeholders so parse5 can parse the HTML correctly
+ * without being confused by tags or braces inside expressions.
+ *
+ * Uses balanced brace parsing to correctly handle:
+ * - String literals with braces inside
+ * - Template literals with ${} interpolations
+ * - Arrow functions with object returns
+ * - Multi-line JSX expressions
+ */
+function normalizeAllExpressions(html) {
+    const exprMap = new Map();
+    let exprCounter = 0;
+    let result = '';
+    let lastPos = 0;
+    for (let i = 0; i < html.length; i++) {
+        // Look for { and check if it's an expression
+        // We handle both text expressions and attribute expressions: attr={...}
+        if (html[i] === '{') {
+            const j = findBalancedBraceEnd(html, i);
+            if (j !== -1 && j > i + 1) {
+                const expr = html.substring(i + 1, j - 1).trim();
+                // Skip empty expressions
+                if (expr.length === 0) {
+                    i++;
+                    continue;
+                }
+                const placeholder = `__ZEN_EXPR_${exprCounter++}`;
+                exprMap.set(placeholder, expr);
+                result += html.substring(lastPos, i);
+                result += placeholder;
+                lastPos = j;
+                i = j - 1;
+            }
+        }
+    }
+    result += html.substring(lastPos);
+    return { normalized: result, expressions: exprMap };
+}
+/**
+ * Calculate source location from parse5 node
+ */
+function getLocation(node, originalHtml) {
+    // parse5 provides sourceCodeLocation if available
+    if (node.sourceCodeLocation) {
+        return {
+            line: node.sourceCodeLocation.startLine || 1,
+            column: node.sourceCodeLocation.startCol || 1
+        };
+    }
+    // Fallback if location info not available
+    return { line: 1, column: 1 };
+}
+/**
+ * Extract expressions from text content
+ * Returns array of { expression, location } and the text with expressions replaced
+ * Phase 7: Supports loop context for expressions inside map iterations
+ */
+function extractExpressionsFromText(text, baseLocation, expressions, normalizedExprs, loopContext) {
+    const nodes = [];
+    let processedText = '';
+    let currentIndex = 0;
+    // Match __ZEN_EXPR_N placeholders
+    const expressionRegex = /__ZEN_EXPR_\d+/g;
+    let match;
+    while ((match = expressionRegex.exec(text)) !== null) {
+        const beforeExpr = text.substring(currentIndex, match.index);
+        if (beforeExpr) {
+            nodes.push({
+                type: 'text',
+                value: beforeExpr,
+                location: {
+                    line: baseLocation.line,
+                    column: baseLocation.column + currentIndex
+                }
+            });
+            processedText += beforeExpr;
+        }
+        // Resolve placeholder to original expression code
+        const placeholder = match[0];
+        const exprCode = (normalizedExprs.get(placeholder) || '').trim();
+        const exprId = generateExpressionId();
+        const exprLocation = {
+            line: baseLocation.line,
+            column: baseLocation.column + match.index
+        };
+        const exprIR = {
+            id: exprId,
+            code: exprCode,
+            location: exprLocation
+        };
+        expressions.push(exprIR);
+        // Phase 7: Loop context detection and attachment
+        const mapLoopContext = extractLoopContextFromExpression(exprIR);
+        const activeLoopContext = mergeLoopContext(loopContext, mapLoopContext);
+        const attachedLoopContext = shouldAttachLoopContext(exprIR, activeLoopContext);
+        nodes.push({
+            type: 'expression',
+            expression: exprId,
+            location: exprLocation,
+            loopContext: attachedLoopContext
+        });
+        processedText += `{${exprCode}}`;
+        currentIndex = match.index + match[0].length;
+    }
+    // Add remaining text
+    const remaining = text.substring(currentIndex);
+    if (remaining) {
+        nodes.push({
+            type: 'text',
+            value: remaining,
+            location: {
+                line: baseLocation.line,
+                column: baseLocation.column + currentIndex
+            }
+        });
+        processedText += remaining;
+    }
+    // If no expressions found, return single text node
+    if (nodes.length === 0) {
+        nodes.push({
+            type: 'text',
+            value: text,
+            location: baseLocation
+        });
+        processedText = text;
+    }
+    return { processedText, nodes };
+}
+/**
+ * Parse attribute value - may contain expressions
+ * Phase 7: Supports loop context for expressions inside map iterations
+ */
+function parseAttributeValue(value, baseLocation, expressions, normalizedExprs, loopContext // Phase 7: Loop context from parent map expressions
+) {
+    // Check if this is a normalized expression placeholder
+    if (value.startsWith('__ZEN_EXPR_')) {
+        const exprCode = normalizedExprs.get(value);
+        if (!exprCode) {
+            throw new Error(`Normalized expression placeholder not found: ${value}`);
+        }
+        const exprId = generateExpressionId();
+        expressions.push({
+            id: exprId,
+            code: exprCode,
+            location: baseLocation
+        });
+        return {
+            id: exprId,
+            code: exprCode,
+            location: baseLocation
+        };
+    }
+    // Check if attribute value is an expression { ... } (shouldn't happen after normalization)
+    const exprMatch = value.match(/^\{([^}]+)\}$/);
+    if (exprMatch && exprMatch[1]) {
+        const exprCode = exprMatch[1].trim();
+        const exprId = generateExpressionId();
+        expressions.push({
+            id: exprId,
+            code: exprCode,
+            location: baseLocation
+        });
+        return {
+            id: exprId,
+            code: exprCode,
+            location: baseLocation
+        };
+    }
+    // Regular string value
+    return value;
+}
+/**
+ * Convert parse5 node to TemplateNode
+ * Phase 7: Supports loop context propagation for map expressions
+ */
+function parseNode(node, originalHtml, expressions, normalizedExprs, parentLoopContext // Phase 7: Loop context from parent map expressions
+) {
+    if (node.nodeName === '#text') {
+        const text = node.value || '';
+        const location = getLocation(node, originalHtml);
+        // Extract expressions from text
+        // Phase 7: Pass loop context to detect map expressions and attach context
+        const { nodes } = extractExpressionsFromText(node.value, location, expressions, normalizedExprs, parentLoopContext);
+        // If single text node with no expressions, return it
+        if (nodes.length === 1 && nodes[0] && nodes[0].type === 'text') {
+            return nodes[0];
+        }
+        // Otherwise, we need to handle multiple nodes
+        // For Phase 1, we'll flatten to text for now (will be handled in future phases)
+        // This is a limitation we accept for Phase 1
+        const firstNode = nodes[0];
+        if (firstNode) {
+            return firstNode;
+        }
+        return {
+            type: 'text',
+            value: text,
+            location
+        };
+    }
+    if (node.nodeName === '#comment') {
+        // Skip comments for Phase 1
+        return null;
+    }
+    if (node.nodeName && node.nodeName !== '#text' && node.nodeName !== '#comment') {
+        const location = getLocation(node, originalHtml);
+        const tag = node.tagName?.toLowerCase() || node.nodeName;
+        // Extract original tag name from source HTML to preserve casing (parse5 lowercases everything)
+        let originalTag = node.tagName || node.nodeName;
+        if (node.sourceCodeLocation && node.sourceCodeLocation.startOffset !== undefined) {
+            const startOffset = node.sourceCodeLocation.startOffset;
+            // Find the tag name in original HTML (after '<')
+            const tagMatch = originalHtml.slice(startOffset).match(/^<([a-zA-Z][a-zA-Z0-9._-]*)/);
+            if (tagMatch && tagMatch[1]) {
+                originalTag = tagMatch[1];
+            }
+        }
+        // INV005: <template> tags are forbidden — use compound components instead
+        if (tag === 'template') {
+            throw new InvariantError(INVARIANT.TEMPLATE_TAG, `<template> tags are forbidden in Zenith. Use compound components (e.g., Card.Header) for named slots.`, 'Named slots use compound component pattern (Card.Header), not <template> tags.', 'unknown', // filePath passed to parseTemplate
+            location.line, location.column);
+        }
+        // Parse attributes
+        const attributes = [];
+        if (node.attrs) {
+            for (const attr of node.attrs) {
+                const attrLocation = node.sourceCodeLocation?.attrs?.[attr.name]
+                    ? {
+                        line: node.sourceCodeLocation.attrs[attr.name].startLine || location.line,
+                        column: node.sourceCodeLocation.attrs[attr.name].startCol || location.column
+                    }
+                    : location;
+                // INV006: slot="" attributes are forbidden — use compound components instead
+                if (attr.name === 'slot') {
+                    throw new InvariantError(INVARIANT.SLOT_ATTRIBUTE, `slot="${attr.value || ''}" attribute is forbidden. Use compound components (e.g., Card.Header) for named slots.`, 'Named slots use compound component pattern (Card.Header), not slot="" attributes.', 'unknown', attrLocation.line, attrLocation.column);
+                }
+                // Handle :attr="expr" syntax (colon-prefixed reactive attributes)
+                let attrName = attr.name;
+                let attrValue = attr.value || '';
+                let isReactive = false;
+                if (attrName.startsWith(':')) {
+                    // This is a reactive attribute like :class="expr"
+                    attrName = attrName.slice(1); // Remove the colon
+                    isReactive = true;
+                    // The value is already a string expression (not in braces)
+                    // Treat it as an expression
+                    const exprId = generateExpressionId();
+                    const exprCode = attrValue.trim();
+                    const exprIR = {
+                        id: exprId,
+                        code: exprCode,
+                        location: attrLocation
+                    };
+                    expressions.push(exprIR);
+                    // Phase 7: Attach loop context if expression references loop variables
+                    const attachedLoopContext = shouldAttachLoopContext(exprIR, parentLoopContext);
+                    attributes.push({
+                        name: attrName, // Store without colon (e.g., "class" not ":class")
+                        value: exprIR,
+                        location: attrLocation,
+                        loopContext: attachedLoopContext
+                    });
+                }
+                else {
+                    // Regular attribute or attr={expr} syntax
+                    const attrValueResult = parseAttributeValue(attrValue, attrLocation, expressions, normalizedExprs, parentLoopContext);
+                    // Transform event attributes: onclick -> data-zen-click, onchange -> data-zen-change, etc.
+                    let finalAttrName = attrName;
+                    if (attrName.startsWith('on') && attrName.length > 2) {
+                        const eventType = attrName.slice(2); // Remove "on" prefix
+                        finalAttrName = `data-zen-${eventType}`;
+                    }
+                    if (typeof attrValueResult === 'string') {
+                        // Static attribute value
+                        attributes.push({
+                            name: finalAttrName,
+                            value: attrValueResult,
+                            location: attrLocation
+                        });
+                    }
+                    else {
+                        // Expression attribute value
+                        const exprIR = attrValueResult;
+                        // Phase 7: Attach loop context if expression references loop variables
+                        const attachedLoopContext = shouldAttachLoopContext(exprIR, parentLoopContext);
+                        attributes.push({
+                            name: finalAttrName,
+                            value: exprIR,
+                            location: attrLocation,
+                            loopContext: attachedLoopContext
+                        });
+                    }
+                }
+            }
+        }
+        // Parse children
+        const children = [];
+        if (node.childNodes) {
+            for (const child of node.childNodes) {
+                if (child.nodeName === '#text') {
+                    // Handle text nodes that may contain expressions
+                    const text = child.value || '';
+                    const location = getLocation(child, originalHtml);
+                    const { nodes: textNodes } = extractExpressionsFromText(text, location, expressions, normalizedExprs, parentLoopContext);
+                    // Add all nodes from text (can be multiple: text + expression + text)
+                    for (const textNode of textNodes) {
+                        children.push(textNode);
+                    }
+                }
+                else {
+                    const childNode = parseNode(child, originalHtml, expressions, normalizedExprs, parentLoopContext);
+                    if (childNode) {
+                        children.push(childNode);
+                    }
+                }
+            }
+        }
+        // Phase 7: Check if any child expression is a map expression and extract its loop context
+        // This allows nested loops to work correctly
+        let elementLoopContext = parentLoopContext;
+        // Check children for map expressions (they create new loop contexts)
+        for (const child of children) {
+            if (child.type === 'expression' && child.loopContext) {
+                // If we find a map expression child, merge its context
+                elementLoopContext = mergeLoopContext(elementLoopContext, child.loopContext);
+            }
+        }
+        // Check if this is a custom component (starts with uppercase)
+        const isComponent = originalTag.length > 0 && originalTag[0] === originalTag[0].toUpperCase();
+        if (isComponent) {
+            // This is a component node
+            return {
+                type: 'component',
+                name: originalTag,
+                attributes,
+                children,
+                location,
+                loopContext: elementLoopContext
+            };
+        }
+        else {
+            // This is a regular HTML element
+            return {
+                type: 'element',
+                tag,
+                attributes,
+                children,
+                location,
+                loopContext: elementLoopContext
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Parse template from HTML string
+ */
+export function parseTemplate(html, filePath) {
+    // Strip script and style blocks
+    let templateHtml = stripBlocks(html);
+    // Normalize all expressions so parse5 can parse them safely
+    const { normalized, expressions: normalizedExprs } = normalizeAllExpressions(templateHtml);
+    templateHtml = normalized;
+    try {
+        // Parse HTML using parseFragment
+        const fragment = parseFragment(templateHtml, {
+            sourceCodeLocationInfo: true
+        });
+        const expressions = [];
+        const nodes = [];
+        // Parse fragment children
+        if (fragment.childNodes) {
+            for (const node of fragment.childNodes) {
+                const parsed = parseNode(node, templateHtml, expressions, normalizedExprs, undefined);
+                if (parsed) {
+                    nodes.push(parsed);
+                }
+            }
+        }
+        // Phase 8: Lower JSX expressions to structural fragments
+        // This transforms expressions like {cond ? <A /> : <B />} into ConditionalFragmentNode
+        const loweredNodes = lowerFragments(nodes, filePath, expressions);
+        return {
+            raw: templateHtml,
+            nodes: loweredNodes,
+            expressions
+        };
+    }
+    catch (error) {
+        throw new CompilerError(`Template parsing failed: ${error.message}`, filePath, 1, 1);
+    }
+}

package/dist/parse/parseZenFile.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Zenith File Parser
+ *
+ * Main entry point for parsing .zen files
+ * Phase 1: Parse & Extract only
+ */
+import type { ZenIR } from '../ir/types';
+/**
+ * Parse a .zen file into IR
+ */
+export declare function parseZenFile(filePath: string): ZenIR;

package/dist/parse/parseZenFile.js

@@ -0,0 +1,50 @@
+/**
+ * Zenith File Parser
+ *
+ * Main entry point for parsing .zen files
+ * Phase 1: Parse & Extract only
+ */
+import { readFileSync } from 'fs';
+import { parseTemplate } from './parseTemplate';
+import { parseScript } from './parseScript';
+import { CompilerError } from '../errors/compilerError';
+/**
+ * Extract style blocks from HTML
+ */
+function parseStyles(html) {
+    const styles = [];
+    const styleRegex = /<style[^>]*>([\s\S]*?)<\/style>/gi;
+    let match;
+    while ((match = styleRegex.exec(html)) !== null) {
+        if (match[1]) {
+            styles.push({
+                raw: match[1].trim()
+            });
+        }
+    }
+    return styles;
+}
+/**
+ * Parse a .zen file into IR
+ */
+export function parseZenFile(filePath) {
+    let source;
+    try {
+        source = readFileSync(filePath, 'utf-8');
+    }
+    catch (error) {
+        throw new CompilerError(`Failed to read file: ${error.message}`, filePath, 1, 1);
+    }
+    // Parse template
+    const template = parseTemplate(source, filePath);
+    // Parse script
+    const script = parseScript(source);
+    // Parse styles
+    const styles = parseStyles(source);
+    return {
+        filePath,
+        template,
+        script,
+        styles
+    };
+}

package/dist/parse/scriptAnalysis.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Script Analysis Utilities
+ *
+ * Extracts state and prop declarations from <script> blocks
+ */
+export interface StateInfo {
+    name: string;
+    value: string;
+}
+/**
+ * Extract state declarations: state name = value
+ */
+export declare function extractStateDeclarations(script: string): Map<string, string>;
+/**
+ * Extract prop declarations: export let props: Props;
+ */
+export declare function extractProps(script: string): string[];
+/**
+ * Transform script by removing state and prop declarations
+ */
+export declare function transformStateDeclarations(script: string): string;
+/**
+ * Inject props into a setup script as top-level variables
+ */
+export declare function injectPropsIntoSetup(script: string, props: Record<string, any>): string;

package/dist/parse/scriptAnalysis.js

@@ -0,0 +1,60 @@
+/**
+ * Script Analysis Utilities
+ *
+ * Extracts state and prop declarations from <script> blocks
+ */
+/**
+ * Extract state declarations: state name = value
+ */
+export function extractStateDeclarations(script) {
+    const states = new Map();
+    const statePattern = /state\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*([^;]+?)(?:\s*;|\s*$)/gm;
+    let match;
+    while ((match = statePattern.exec(script)) !== null) {
+        if (match[1] && match[2]) {
+            states.set(match[1], match[2].trim());
+        }
+    }
+    return states;
+}
+/**
+ * Extract prop declarations: export let props: Props;
+ */
+export function extractProps(script) {
+    const props = [];
+    const propPattern = /export\s+let\s+props(?:\s*:\s*([^;]+))?[ \t]*;?/g;
+    let match;
+    while ((match = propPattern.exec(script)) !== null) {
+        if (!props.includes('props')) {
+            props.push('props');
+        }
+    }
+    return props;
+}
+/**
+ * Transform script by removing state and prop declarations
+ */
+export function transformStateDeclarations(script) {
+    let transformed = script;
+    // Remove state declarations (state count = 0)
+    transformed = transformed.replace(/state\s+([a-zA-Z_$][a-zA-Z0-9_$]*)[ \t]*=[ \t]*([^;]+?)(?:[ \t]*;|\s*$)/gm, '');
+    // Remove export let props (legacy)
+    transformed = transformed.replace(/export\s+let\s+props(?:\s*:\s*([^;]+))?\s*;?[ \t]*/g, '');
+    // Remove type/interface Props (carefully handling comments)
+    // We search for the start of the word 'type' or 'interface' and match until the closing brace
+    transformed = transformed.replace(/(?:type|interface)\s+Props\s*=?\s*\{[^}]*(?:\{[^}]*\}[^}]*)*\}[ \t]*;?/gs, '');
+    // Remove zenith/runtime imports
+    transformed = transformed.replace(/import\s+{[^}]+}\s+from\s+['"]zenith\/runtime['"]\s*;?[ \t]*/g, '');
+    // Transform zenith:content imports to global lookups
+    transformed = transformed.replace(/import\s*{\s*([^}]+)\s*}\s*from\s*['"]zenith:content['"]\s*;?/g, (_, imports) => `const { ${imports.trim()} } = window.__zenith;`);
+    return transformed.trim();
+}
+/**
+ * Inject props into a setup script as top-level variables
+ */
+export function injectPropsIntoSetup(script, props) {
+    const propDeclarations = Object.entries(props)
+        .map(([key, value]) => `const ${key} = ${typeof value === 'string' ? `'${value}'` : JSON.stringify(value)};`)
+        .join('\n');
+    return `${propDeclarations}\n\n${script}`;
+}

package/dist/parse/trackLoopContext.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Loop Context Tracking
+ *
+ * Phase 7: Utilities for tracking and propagating loop context through the parse tree
+ */
+import type { LoopContext, ExpressionIR } from '../ir/types';
+/**
+ * Check if an expression should have loop context attached
+ * Returns the loop context if the expression references loop variables
+ */
+export declare function shouldAttachLoopContext(expr: ExpressionIR, parentLoopContext?: LoopContext): LoopContext | undefined;
+/**
+ * Merge loop contexts for nested loops
+ * Inner loops inherit outer loop variables
+ */
+export declare function mergeLoopContext(outer?: LoopContext, inner?: LoopContext): LoopContext | undefined;
+/**
+ * Detect if an expression is a map expression and extract its loop context
+ */
+export declare function extractLoopContextFromExpression(expr: ExpressionIR): LoopContext | undefined;