@zenithbuild/compiler 1.0.16 → 1.3.0

package/dist/discovery/componentDiscovery.d.ts

@@ -1,42 +0,0 @@
-/**
- * Component Discovery
- *
- * Discovers and catalogs components in a Zenith project
- * Similar to layout discovery but for reusable components
- */
-import type { TemplateNode, ExpressionIR } from '../ir/types';
-export interface SlotDefinition {
-    name: string | null;
-    location: {
-        line: number;
-        column: number;
-    };
-}
-export interface ComponentMetadata {
-    name: string;
-    path: string;
-    template: string;
-    nodes: TemplateNode[];
-    expressions: ExpressionIR[];
-    slots: SlotDefinition[];
-    props: string[];
-    styles: string[];
-    script: string | null;
-    scriptAttributes: Record<string, string> | null;
-    hasScript: boolean;
-    hasStyles: boolean;
-}
-/**
- * Discover all components in a directory
- * @param baseDir - Base directory to search (e.g., src/components)
- * @returns Map of component name to metadata
- */
-export declare function discoverComponents(baseDir: string): Map<string, ComponentMetadata>;
-/**
- * Use native bridge for tag name checks
- */
-export declare function isComponentTag(tagName: string): boolean;
-/**
- * Get component metadata by name
- */
-export declare function getComponent(components: Map<string, ComponentMetadata>, name: string): ComponentMetadata | undefined;

package/dist/discovery/componentDiscovery.js

@@ -1,56 +0,0 @@
-/**
- * Component Discovery
- *
- * Discovers and catalogs components in a Zenith project
- * Similar to layout discovery but for reusable components
- */
-let native;
-try {
-    try {
-        native = require('../../native/compiler-native');
-    }
-    catch {
-        native = require('../../native/compiler-native/index.js');
-    }
-}
-catch (e) {
-    // Bridge load handled elsewhere
-}
-/**
- * Discover all components in a directory
- * @param baseDir - Base directory to search (e.g., src/components)
- * @returns Map of component name to metadata
- */
-export function discoverComponents(baseDir) {
-    if (native && native.discoverComponentsNative) {
-        try {
-            const raw = native.discoverComponentsNative(baseDir);
-            // The native function returns a Map-like object or Record
-            const components = new Map();
-            for (const [name, metadata] of Object.entries(raw)) {
-                components.set(name, metadata);
-            }
-            return components;
-        }
-        catch (error) {
-            console.warn(`[Zenith Native] Discovery failed for ${baseDir}: ${error.message}`);
-        }
-    }
-    // Fallback or empty if native fails (bridge is required for performance)
-    return new Map();
-}
-/**
- * Use native bridge for tag name checks
- */
-export function isComponentTag(tagName) {
-    if (native && native.isComponentTagNative) {
-        return native.isComponentTagNative(tagName);
-    }
-    return tagName.length > 0 && tagName[0] === tagName[0]?.toUpperCase();
-}
-/**
- * Get component metadata by name
- */
-export function getComponent(components, name) {
-    return components.get(name);
-}

package/dist/discovery/layouts.d.ts

@@ -1,13 +0,0 @@
-export interface LayoutMetadata {
-    name: string;
-    filePath: string;
-    props: string[];
-    states: Map<string, string>;
-    html: string;
-    scripts: string[];
-    styles: string[];
-}
-/**
- * Discover layouts in a directory
- */
-export declare function discoverLayouts(layoutsDir: string): Map<string, LayoutMetadata>;

package/dist/discovery/layouts.js

@@ -1,41 +0,0 @@
-let native;
-try {
-    try {
-        native = require('../../native/compiler-native');
-    }
-    catch {
-        native = require('../../native/compiler-native/index.js');
-    }
-}
-catch (e) {
-    // Bridge load handled elsewhere
-}
-/**
- * Discover layouts in a directory
- */
-export function discoverLayouts(layoutsDir) {
-    if (native && native.discoverLayoutsNative) {
-        try {
-            const raw = native.discoverLayoutsNative(layoutsDir);
-            const layouts = new Map();
-            for (const [name, metadata] of Object.entries(raw)) {
-                // Adjust for Rust's camelCase vs Map mapping if needed
-                const meta = metadata;
-                layouts.set(name, {
-                    name: meta.name,
-                    filePath: meta.filePath,
-                    props: meta.props,
-                    states: new Map(Object.entries(meta.states || {})),
-                    html: meta.html,
-                    scripts: meta.scripts,
-                    styles: meta.styles
-                });
-            }
-            return layouts;
-        }
-        catch (error) {
-            console.warn(`[Zenith Native] Layout discovery failed for ${layoutsDir}: ${error.message}`);
-        }
-    }
-    return new Map();
-}

package/dist/errors/compilerError.d.ts

@@ -1,31 +0,0 @@
-/**
- * Compiler Error Handling
- *
- * Compiler errors with source location information
- */
-export declare class CompilerError extends Error {
-    file: string;
-    line: number;
-    column: number;
-    errorType: string;
-    context?: string;
-    hints: string[];
-    code?: string;
-    constructor(message: string, file: string, line: number, column: number, errorType?: string, context?: string, hints?: string[], code?: string);
-    toString(): string;
-}
-/**
- * Invariant Error
- *
- * Thrown when a Zenith compiler invariant is violated.
- * Invariants are non-negotiable rules that guarantee correct behavior.
- *
- * If an invariant fails, the compiler is at fault — not the user.
- * The user receives a clear explanation of what is forbidden and why.
- */
-export declare class InvariantError extends CompilerError {
-    invariantId: string;
-    guarantee: string;
-    constructor(invariantId: string, message: string, guarantee: string, file: string, line: number, column: number, context?: string, hints?: string[]);
-    toString(): string;
-}

package/dist/errors/compilerError.js

@@ -1,51 +0,0 @@
-/**
- * Compiler Error Handling
- *
- * Compiler errors with source location information
- */
-export class CompilerError extends Error {
-    file;
-    line;
-    column;
-    errorType;
-    context;
-    hints;
-    code;
-    constructor(message, file, line, column, errorType = 'COMPILER_ERROR', context, hints = [], code) {
-        super(`${file}:${line}:${column} ${message}`);
-        this.name = 'CompilerError';
-        this.file = file;
-        this.line = line;
-        this.column = column;
-        this.errorType = errorType;
-        this.context = context;
-        this.hints = hints;
-        this.code = code;
-    }
-    toString() {
-        return `${this.file}:${this.line}:${this.column} [${this.errorType}] ${this.message}`;
-    }
-}
-/**
- * Invariant Error
- *
- * Thrown when a Zenith compiler invariant is violated.
- * Invariants are non-negotiable rules that guarantee correct behavior.
- *
- * If an invariant fails, the compiler is at fault — not the user.
- * The user receives a clear explanation of what is forbidden and why.
- */
-export class InvariantError extends CompilerError {
-    invariantId;
-    guarantee;
-    constructor(invariantId, message, guarantee, file, line, column, context, hints = []) {
-        super(`[${invariantId}] ${message}\n\n  Zenith Guarantee: ${guarantee}`, file, line, column, 'COMPILER_INVARIANT_VIOLATION', context, hints, invariantId);
-        this.name = 'InvariantError';
-        this.invariantId = invariantId;
-        this.guarantee = guarantee;
-        this.code = invariantId;
-    }
-    toString() {
-        return `${this.file}:${this.line}:${this.column} [${this.invariantId}] ${this.message}`;
-    }
-}

package/dist/finalize/finalizeOutput.d.ts

@@ -1,32 +0,0 @@
-/**
- * Finalize Output
- *
- * NATIVE BRIDGE: Delegates ALL finalization (Phase 8/9/10) to Rust (`native/compiler-native/src/finalize.rs`).
- */
-import type { CompiledTemplate } from '../output/types';
-import type { ZenIR, BundlePlan } from '../ir/types';
-/**
- * Finalized output ready for browser
- */
-export interface FinalizedOutput {
-    html: string;
-    js: string;
-    npmImports: string;
-    styles: string[];
-    hasErrors: boolean;
-    errors: string[];
-    /** Compiler-emitted bundling plan. If present, bundling MUST occur. If absent, bundling MUST NOT occur. */
-    bundlePlan?: BundlePlan;
-}
-/**
- * Finalize compiler output (Native Bridge)
- *
- * @param ir - Intermediate representation
- * @param compiled - Compiled template
- * @returns Finalized output
- */
-export declare function finalizeOutput(ir: ZenIR, compiled: CompiledTemplate): Promise<FinalizedOutput>;
-/**
- * Generate final output with error handling
- */
-export declare function finalizeOutputOrThrow(ir: ZenIR, compiled: CompiledTemplate): Promise<FinalizedOutput>;

package/dist/finalize/finalizeOutput.js

@@ -1,62 +0,0 @@
-/**
- * Finalize Output
- *
- * NATIVE BRIDGE: Delegates ALL finalization (Phase 8/9/10) to Rust (`native/compiler-native/src/finalize.rs`).
- */
-let native;
-try {
-    try {
-        native = require('../../native/compiler-native');
-    }
-    catch {
-        native = require('../../native/compiler-native/index.js');
-    }
-}
-catch (e) {
-    // Bridge load handled elsewhere
-}
-/**
- * Finalize compiler output (Native Bridge)
- *
- * @param ir - Intermediate representation
- * @param compiled - Compiled template
- * @returns Finalized output
- */
-export async function finalizeOutput(ir, compiled) {
-    if (native && native.finalizeOutputNative) {
-        try {
-            const result = native.finalizeOutputNative(ir, compiled);
-            return {
-                html: result.html,
-                js: result.js,
-                npmImports: result.npmImports,
-                styles: result.styles,
-                hasErrors: result.hasErrors,
-                errors: result.errors,
-                bundlePlan: result.bundlePlan
-            };
-        }
-        catch (error) {
-            return {
-                html: '',
-                js: '',
-                npmImports: '',
-                styles: [],
-                hasErrors: true,
-                errors: [`Native finalization failed: ${error.message}`]
-            };
-        }
-    }
-    throw new Error(`[Zenith Native] Finalize bridge unavailable - cannot finalize ${ir.filePath}`);
-}
-/**
- * Generate final output with error handling
- */
-export async function finalizeOutputOrThrow(ir, compiled) {
-    const output = await finalizeOutput(ir, compiled);
-    if (output.hasErrors) {
-        const errorMessage = output.errors.join('\n\n');
-        throw new Error(`Compilation failed:\n\n${errorMessage}`);
-    }
-    return output;
-}

package/dist/finalize/generateFinalBundle.d.ts

@@ -1,24 +0,0 @@
-/**
- * Generate Final Bundle
- *
- * Phase 8/9/10: Generate final browser-ready bundle
- *
- * Combines:
- * - Compiled HTML
- * - Runtime JS
- * - Expression functions
- * - Event bindings
- * - Style injection
- */
-import type { FinalizedOutput } from './finalizeOutput';
-/**
- * Generate final bundle code
- *
- * This is the complete JavaScript bundle that will execute in the browser.
- * All expressions are pre-compiled - no template parsing at runtime.
- */
-export declare function generateFinalBundle(finalized: FinalizedOutput): string;
-/**
- * Generate HTML with inline script
- */
-export declare function generateHTMLWithScript(html: string, jsBundle: string, styles: string[]): string;

package/dist/finalize/generateFinalBundle.js

@@ -1,68 +0,0 @@
-/**
- * Generate Final Bundle
- *
- * Phase 8/9/10: Generate final browser-ready bundle
- *
- * Combines:
- * - Compiled HTML
- * - Runtime JS
- * - Expression functions
- * - Event bindings
- * - Style injection
- */
-/**
- * Generate final bundle code
- *
- * This is the complete JavaScript bundle that will execute in the browser.
- * All expressions are pre-compiled - no template parsing at runtime.
- */
-export function generateFinalBundle(finalized) {
-    return `// Zenith Compiled Bundle (Phase 8/9/10)
-// Generated at compile time - no .zen parsing in browser
-// All expressions are pre-compiled - deterministic output
-
-${finalized.js}
-
-// Bundle complete - ready for browser execution
-`;
-}
-/**
- * Generate HTML with inline script
- */
-export function generateHTMLWithScript(html, jsBundle, styles) {
-    // Inject styles as <style> tags
-    const styleTags = styles.map(style => `<style>${escapeHTML(style)}</style>`).join('\n');
-    // Inject JS bundle as inline script
-    const scriptTag = `<script>${jsBundle}</script>`;
-    // Find </head> or <body> to inject styles
-    // Find </body> to inject script
-    let result = html;
-    if (styleTags) {
-        if (result.includes('</head>')) {
-            result = result.replace('</head>', `${styleTags}\n</head>`);
-        }
-        else if (result.includes('<body')) {
-            result = result.replace('<body', `${styleTags}\n<body`);
-        }
-    }
-    if (scriptTag) {
-        if (result.includes('</body>')) {
-            result = result.replace('</body>', `${scriptTag}\n</body>`);
-        }
-        else {
-            result += scriptTag;
-        }
-    }
-    return result;
-}
-/**
- * Escape HTML for safe embedding
- */
-function escapeHTML(str) {
-    return str
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&#039;');
-}

package/dist/index.d.ts

@@ -1,38 +0,0 @@
-import type { ZenIR } from './ir/types';
-import type { CompiledTemplate } from './output/types';
-import type { FinalizedOutput } from './finalize/finalizeOutput';
-import { parseZenFile } from './parseZenFile';
-/**
- * Compile a .zen file into IR and CompiledTemplate
- */
-export declare function compileZen(filePath: string): Promise<{
-    ir: ZenIR;
-    compiled: CompiledTemplate;
-    finalized?: FinalizedOutput;
-}>;
-/**
- * Compile Zen source string into IR and CompiledTemplate
- */
-export declare function compileZenSource(source: string, filePath: string, options?: {
-    componentsDir?: string;
-    components?: Map<string, any>;
-}): Promise<{
-    ir: ZenIR;
-    compiled: CompiledTemplate;
-    finalized?: FinalizedOutput;
-}>;
-export { parseZenFile };
-export { discoverComponents } from './discovery/componentDiscovery';
-export { discoverLayouts } from './discovery/layouts';
-export { processLayout } from './transform/layoutProcessor';
-export { bundlePageScript } from './bundler';
-export { buildSSG } from './ssg-build';
-export { buildSPA } from './spa-build';
-export { generateBundleJS } from './runtime/bundle-generator';
-export { generateRouteDefinition } from '@zenithbuild/router/manifest';
-export { compileCss, compileCssAsync, resolveGlobalsCss } from './css';
-export { loadZenithConfig } from './core/config/loader';
-export { PluginRegistry, createPluginContext, getPluginDataByNamespace } from './core/plugins/registry';
-export { createBridgeAPI, runPluginHooks, collectHookReturns, buildRuntimeEnvelope, clearHooks } from './core/plugins/bridge';
-export type { HookContext } from './core/plugins/bridge';
-export type { BundlePlan, ExpressionIR, ZenIR, TemplateNode } from './ir/types';

package/dist/index.js

@@ -1,57 +0,0 @@
-import { readFileSync } from 'fs';
-import { transformTemplate } from './transform/transformTemplate';
-import { finalizeOutputOrThrow } from './finalize/finalizeOutput';
-import { validateIr } from './validate/invariants';
-import { parseZenFile } from './parseZenFile';
-import { discoverComponents } from './discovery/componentDiscovery';
-import { resolveComponentsInIR } from './transform/componentResolver';
-/**
- * Compile a .zen file into IR and CompiledTemplate
- */
-export async function compileZen(filePath) {
-    const source = readFileSync(filePath, 'utf-8');
-    return compileZenSource(source, filePath);
-}
-/**
- * Compile Zen source string into IR and CompiledTemplate
- */
-export async function compileZenSource(source, filePath, options) {
-    // Parse with native bridge
-    let ir = parseZenFile(filePath, source);
-    // Resolve components if explicitly provided OR if components directory is set
-    if (options?.components || options?.componentsDir) {
-        let components = options.components || new Map();
-        // If directory provided, discover and merge
-        if (options.componentsDir) {
-            const discovered = discoverComponents(options.componentsDir);
-            components = new Map([...components, ...discovered]);
-        }
-        // Component resolution may throw InvariantError — let it propagate
-        ir = resolveComponentsInIR(ir, components);
-    }
-    // Validate all compiler invariants after resolution
-    // Throws InvariantError if any invariant is violated
-    validateIr(ir);
-    const compiled = transformTemplate(ir);
-    try {
-        const finalized = await finalizeOutputOrThrow(ir, compiled);
-        return { ir, compiled, finalized };
-    }
-    catch (error) {
-        throw new Error(`Failed to finalize output for ${filePath}:\n${error.message}`);
-    }
-}
-export { parseZenFile };
-// Feature exports
-export { discoverComponents } from './discovery/componentDiscovery';
-export { discoverLayouts } from './discovery/layouts';
-export { processLayout } from './transform/layoutProcessor';
-export { bundlePageScript } from './bundler';
-export { buildSSG } from './ssg-build';
-export { buildSPA } from './spa-build';
-export { generateBundleJS } from './runtime/bundle-generator';
-export { generateRouteDefinition } from '@zenithbuild/router/manifest';
-export { compileCss, compileCssAsync, resolveGlobalsCss } from './css';
-export { loadZenithConfig } from './core/config/loader';
-export { PluginRegistry, createPluginContext, getPluginDataByNamespace } from './core/plugins/registry';
-export { createBridgeAPI, runPluginHooks, collectHookReturns, buildRuntimeEnvelope, clearHooks } from './core/plugins/bridge';