@zenithbuild/compiler 1.0.2

package/dist/parse/trackLoopContext.js

@@ -0,0 +1,62 @@
+/**
+ * Loop Context Tracking
+ *
+ * Phase 7: Utilities for tracking and propagating loop context through the parse tree
+ */
+import { detectMapExpression, referencesLoopVariable } from './detectMapExpressions';
+/**
+ * Check if an expression should have loop context attached
+ * Returns the loop context if the expression references loop variables
+ */
+export function shouldAttachLoopContext(expr, parentLoopContext) {
+    if (!parentLoopContext) {
+        return undefined;
+    }
+    // Check if this expression references any loop variables
+    if (referencesLoopVariable(expr.code, parentLoopContext.variables)) {
+        return parentLoopContext;
+    }
+    return undefined;
+}
+/**
+ * Merge loop contexts for nested loops
+ * Inner loops inherit outer loop variables
+ */
+export function mergeLoopContext(outer, inner) {
+    if (!inner) {
+        return outer;
+    }
+    if (!outer) {
+        return inner;
+    }
+    // Merge variables: outer variables come first, then inner
+    // This allows expressions to reference both outer and inner loop variables
+    return {
+        variables: [...outer.variables, ...inner.variables],
+        mapSource: inner.mapSource || outer.mapSource
+    };
+}
+/**
+ * Detect if an expression is a map expression and extract its loop context
+ */
+export function extractLoopContextFromExpression(expr) {
+    const mapInfo = detectMapExpression(expr);
+    if (!mapInfo.isMap) {
+        return undefined;
+    }
+    // extractLoopVariables expects a MapExpressionInfo, not a string
+    const variables = [];
+    if (mapInfo.itemVariable) {
+        variables.push(mapInfo.itemVariable);
+    }
+    if (mapInfo.indexVariable) {
+        variables.push(mapInfo.indexVariable);
+    }
+    if (variables.length === 0) {
+        return undefined;
+    }
+    return {
+        variables,
+        mapSource: mapInfo.arraySource
+    };
+}

package/dist/parseZenFile.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Zenith File Parser (Native Bridge)
+ *
+ * Delegates parsing of .zen files to the Rust native compiler.
+ */
+import type { ZenIR } from './ir/types';
+/**
+ * Parse a .zen file into IR via Native Bridge
+ */
+export declare function parseZenFile(filePath: string, sourceInput?: string): ZenIR;

package/dist/parseZenFile.js

@@ -0,0 +1,55 @@
+/**
+ * Zenith File Parser (Native Bridge)
+ *
+ * Delegates parsing of .zen files to the Rust native compiler.
+ */
+import { readFileSync } from 'fs';
+import { CompilerError } from './errors/compilerError';
+let native;
+try {
+    try {
+        native = require('../native/compiler-native');
+    }
+    catch {
+        native = require('../native/compiler-native/index.js');
+    }
+}
+catch (e) {
+    // Bridge load handled elsewhere
+}
+/**
+ * Parse a .zen file into IR via Native Bridge
+ */
+export function parseZenFile(filePath, sourceInput) {
+    let source;
+    if (sourceInput) {
+        source = sourceInput;
+    }
+    else {
+        try {
+            source = readFileSync(filePath, 'utf-8');
+        }
+        catch (error) {
+            throw new CompilerError(`Failed to read file: ${error.message}`, filePath, 1, 1);
+        }
+    }
+    if (native && native.parseTemplateNative && native.parseScriptNative && native.extractStylesNative) {
+        try {
+            const template = native.parseTemplateNative(source, filePath);
+            const script = native.parseScriptNative(source);
+            const stylesRaw = native.extractStylesNative(source);
+            const styles = stylesRaw.map((s) => ({ raw: s }));
+            return {
+                filePath,
+                template,
+                script,
+                styles
+            };
+        }
+        catch (error) {
+            console.warn(`[Zenith Native] Parsing failed for ${filePath}: ${error.message}`);
+            throw error;
+        }
+    }
+    throw new Error(`[Zenith Native] Parser bridge unavailable - cannot compile ${filePath}`);
+}

package/dist/runtime/analyzeAndEmit.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Transform IR to Runtime Code
+ *
+ * NATIVE BRIDGE: Delegates ALL compilation to Rust (`native/compiler-native/src/codegen.rs`).
+ */
+import type { ZenIR } from '../ir/types';
+export interface RuntimeCode {
+    expressions: string;
+    render: string;
+    hydration: string;
+    styles: string;
+    script: string;
+    stateInit: string;
+    bundle: string;
+    npmImports: any[];
+}
+/**
+ * Analyze ZenIR and emit runtime JavaScript code via Native Bridge
+ */
+export declare function analyzeAndEmit(ir: ZenIR): Promise<RuntimeCode>;

package/dist/runtime/analyzeAndEmit.js

@@ -0,0 +1,70 @@
+/**
+ * Transform IR to Runtime Code
+ *
+ * NATIVE BRIDGE: Delegates ALL compilation to Rust (`native/compiler-native/src/codegen.rs`).
+ */
+let native;
+try {
+    try {
+        native = require('../../native/compiler-native');
+    }
+    catch {
+        native = require('../../native/compiler-native/index.js');
+    }
+}
+catch (e) {
+    // Bridge load handled elsewhere
+}
+/**
+ * Analyze ZenIR and emit runtime JavaScript code via Native Bridge
+ */
+export async function analyzeAndEmit(ir) {
+    const scriptContent = ir.script?.raw || '';
+    if (!native || !native.generateRuntimeCode) {
+        throw new Error(`[Zenith Native] Runtime codegen bridge unavailable`);
+    }
+    const codegenInput = {
+        filePath: ir.filePath,
+        scriptContent: scriptContent,
+        expressions: ir.template.expressions,
+        styles: ir.styles.map(s => ({ raw: s.raw })),
+        templateBindings: collectTemplateBindings(ir.template.nodes),
+        location: ir.filePath,
+        nodes: ir.template.nodes,
+        pageBindings: ir.pageBindings || [],
+    };
+    try {
+        return native.generateRuntimeCode(JSON.stringify(codegenInput));
+    }
+    catch (e) {
+        throw new Error(`[Zenith Native] Codegen failed: ${e.message}`);
+    }
+}
+/**
+ * Collect template bindings (loop item/index variables) for native codegen
+ */
+function collectTemplateBindings(nodes) {
+    const bindings = [];
+    function walk(nodeList) {
+        for (const node of nodeList) {
+            if (node.type === 'loop-fragment') {
+                bindings.push(node.itemVar);
+                if (node.indexVar)
+                    bindings.push(node.indexVar);
+                walk(node.body);
+            }
+            else if (node.type === 'element') {
+                walk(node.children);
+            }
+            else if (node.type === 'conditional-fragment') {
+                walk(node.consequent);
+                walk(node.alternate);
+            }
+            else if (node.type === 'optional-fragment') {
+                walk(node.fragment);
+            }
+        }
+    }
+    walk(nodes);
+    return bindings;
+}

package/dist/runtime/build.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Zenith App Build Script
+ *
+ * Builds all pages into a single SPA with file-based routing.
+ */
+export {};

package/dist/runtime/build.js

@@ -0,0 +1,13 @@
+/**
+ * Zenith App Build Script
+ *
+ * Builds all pages into a single SPA with file-based routing.
+ */
+import { buildSPA } from "../spa-build";
+import path from "path";
+const appDir = path.resolve(import.meta.dir, "..", "app");
+buildSPA({
+    pagesDir: path.join(appDir, "pages"),
+    outDir: path.join(appDir, "dist"),
+    baseDir: appDir
+});

package/dist/runtime/bundle-generator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Zenith Bundle Generator
+ *
+ * Generates the shared client runtime bundle that gets served as:
+ * - /assets/bundle.js in production
+ * - /runtime.js in development
+ *
+ * This is a cacheable, versioned file that contains:
+ * - Reactivity primitives (zenSignal, zenState, zenEffect, etc.)
+ * - Lifecycle hooks (zenOnMount, zenOnUnmount)
+ * - Hydration functions (zenithHydrate)
+ * - Event binding utilities
+ */
+/**
+ * Generate the complete client runtime bundle
+ * This is served as an external JS file, not inlined
+ */
+export declare function generateBundleJS(pluginData?: Record<string, any>): string;
+/**
+ * Generate a minified version of the bundle
+ * For production builds
+ */
+export declare function generateMinifiedBundleJS(): string;
+/**
+ * Get bundle version for cache busting
+ */
+export declare function getBundleVersion(): string;