@zenithbuild/core 1.2.2 → 1.2.3

package/compiler/css/index.ts

@@ -1,317 +0,0 @@
-/**
- * Zenith CSS Compiler Module
- * 
- * Compiler-owned CSS processing that integrates Tailwind CSS v4 JIT
- * at compile time. This module ensures:
- * 
- * 1. All CSS is processed at build time (no runtime generation)
- * 2. Tailwind sees all .zen templates for class scanning
- * 3. HMR support for instant CSS updates in dev mode
- * 4. Deterministic, cacheable output for production
- * 
- * Per Zenith CSS Directive: The compiler owns styles.
- */
-
-import { spawn, spawnSync } from 'child_process'
-import path from 'path'
-import fs from 'fs'
-
-// ============================================
-// Types
-// ============================================
-
-export interface CSSCompileOptions {
-    /** Input CSS file path (e.g., src/styles/globals.css) */
-    input: string
-    /** Output CSS file path, or ':memory:' for in-memory result */
-    output: string
-    /** Enable minification for production */
-    minify?: boolean
-    /** Watch mode for HMR */
-    watch?: boolean
-}
-
-export interface CSSCompileResult {
-    /** Compiled CSS content */
-    css: string
-    /** Compilation time in milliseconds */
-    duration: number
-    /** Whether compilation succeeded */
-    success: boolean
-    /** Error message if failed */
-    error?: string
-}
-
-// ============================================
-// CSS Compilation
-// ============================================
-
-/**
- * Compile CSS using Tailwind CSS v4 CLI
- * 
- * This function synchronously compiles CSS for use in:
- * - Dev server startup
- * - SSG build
- * - On-demand recompilation
- * 
- * @param options Compilation options
- * @returns Compiled CSS result
- */
-export function compileCss(options: CSSCompileOptions): CSSCompileResult {
-    const startTime = performance.now()
-    const { input, output, minify = false } = options
-
-    // Validate input exists
-    if (!fs.existsSync(input)) {
-        return {
-            css: '',
-            duration: 0,
-            success: false,
-            error: `CSS input file not found: ${input}`
-        }
-    }
-
-    try {
-        // Build Tailwind CLI arguments
-        const args = [
-            '@tailwindcss/cli',
-            '-i', input
-        ]
-
-        // For in-memory compilation, use stdout
-        const useStdout = output === ':memory:'
-        if (!useStdout) {
-            args.push('-o', output)
-        }
-
-        if (minify) {
-            args.push('--minify')
-        }
-
-        // Execute Tailwind CLI synchronously
-        const result = spawnSync('bunx', args, {
-            cwd: path.dirname(input),
-            encoding: 'utf-8',
-            stdio: useStdout ? ['pipe', 'pipe', 'pipe'] : ['pipe', 'inherit', 'pipe'],
-            env: { ...process.env }
-        })
-
-        const duration = Math.round(performance.now() - startTime)
-
-        if (result.status !== 0) {
-            const errorMsg = result.stderr?.toString() || 'Unknown compilation error'
-            return {
-                css: '',
-                duration,
-                success: false,
-                error: `Tailwind compilation failed: ${errorMsg}`
-            }
-        }
-
-        // Get CSS content
-        let css = ''
-        if (useStdout) {
-            css = result.stdout?.toString() || ''
-        } else if (fs.existsSync(output)) {
-            css = fs.readFileSync(output, 'utf-8')
-        }
-
-        return {
-            css,
-            duration,
-            success: true
-        }
-
-    } catch (error: any) {
-        return {
-            css: '',
-            duration: Math.round(performance.now() - startTime),
-            success: false,
-            error: error.message
-        }
-    }
-}
-
-/**
- * Compile CSS asynchronously (non-blocking)
- * 
- * Used for HMR updates where we don't want to block the main thread.
- */
-export async function compileCssAsync(options: CSSCompileOptions): Promise<CSSCompileResult> {
-    return new Promise((resolve) => {
-        const startTime = performance.now()
-        const { input, output, minify = false } = options
-
-        if (!fs.existsSync(input)) {
-            resolve({
-                css: '',
-                duration: 0,
-                success: false,
-                error: `CSS input file not found: ${input}`
-            })
-            return
-        }
-
-        const args = ['@tailwindcss/cli', '-i', input]
-        const useStdout = output === ':memory:'
-
-        if (!useStdout) {
-            args.push('-o', output)
-        }
-
-        if (minify) {
-            args.push('--minify')
-        }
-
-        const child = spawn('bunx', args, {
-            cwd: path.dirname(input),
-            stdio: useStdout ? ['pipe', 'pipe', 'pipe'] : ['pipe', 'inherit', 'pipe'],
-            env: { ...process.env }
-        })
-
-        let stdout = ''
-        let stderr = ''
-
-        if (useStdout && child.stdout) {
-            child.stdout.on('data', (data) => { stdout += data.toString() })
-        }
-
-        if (child.stderr) {
-            child.stderr.on('data', (data) => { stderr += data.toString() })
-        }
-
-        child.on('close', (code) => {
-            const duration = Math.round(performance.now() - startTime)
-
-            if (code !== 0) {
-                resolve({
-                    css: '',
-                    duration,
-                    success: false,
-                    error: `Tailwind compilation failed: ${stderr}`
-                })
-                return
-            }
-
-            let css = ''
-            if (useStdout) {
-                css = stdout
-            } else if (fs.existsSync(output)) {
-                css = fs.readFileSync(output, 'utf-8')
-            }
-
-            resolve({
-                css,
-                duration,
-                success: true
-            })
-        })
-
-        child.on('error', (err) => {
-            resolve({
-                css: '',
-                duration: Math.round(performance.now() - startTime),
-                success: false,
-                error: err.message
-            })
-        })
-    })
-}
-
-// ============================================
-// CSS Watcher for HMR
-// ============================================
-
-export interface CSSWatchOptions extends CSSCompileOptions {
-    /** Callback when CSS changes */
-    onChange: (result: CSSCompileResult) => void
-    /** Debounce delay in ms */
-    debounce?: number
-}
-
-/**
- * Watch CSS and source files for changes, recompile on change
- * 
- * This is used by the dev server for HMR support.
- * It watches both the CSS entry point AND all .zen files
- * that Tailwind scans for class names.
- */
-export function watchCss(options: CSSWatchOptions): () => void {
-    const { input, output, minify, onChange, debounce = 100 } = options
-
-    let timeout: NodeJS.Timeout | null = null
-    let isCompiling = false
-
-    const recompile = async () => {
-        if (isCompiling) return
-        isCompiling = true
-
-        const result = await compileCssAsync({ input, output, minify })
-        onChange(result)
-
-        isCompiling = false
-    }
-
-    const debouncedRecompile = () => {
-        if (timeout) clearTimeout(timeout)
-        timeout = setTimeout(recompile, debounce)
-    }
-
-    // Watch the styles directory
-    const stylesDir = path.dirname(input)
-    const stylesWatcher = fs.watch(stylesDir, { recursive: true }, (event, filename) => {
-        if (filename?.endsWith('.css')) {
-            debouncedRecompile()
-        }
-    })
-
-    // Watch source files that Tailwind scans (for class changes)
-    // This assumes standard Zenith structure: src/pages, src/components, src/layouts
-    const srcDir = path.resolve(stylesDir, '..')
-    let srcWatcher: fs.FSWatcher | null = null
-
-    if (fs.existsSync(srcDir)) {
-        srcWatcher = fs.watch(srcDir, { recursive: true }, (event, filename) => {
-            if (filename?.endsWith('.zen') || filename?.endsWith('.tsx') || filename?.endsWith('.jsx')) {
-                debouncedRecompile()
-            }
-        })
-    }
-
-    // Return cleanup function
-    return () => {
-        if (timeout) clearTimeout(timeout)
-        stylesWatcher.close()
-        srcWatcher?.close()
-    }
-}
-
-// ============================================
-// Path Utilities
-// ============================================
-
-/**
- * Resolve the canonical globals.css path for a Zenith project
- */
-export function resolveGlobalsCss(projectRoot: string): string | null {
-    // Check for globals.css (canonical)
-    const globalsPath = path.join(projectRoot, 'src', 'styles', 'globals.css')
-    if (fs.existsSync(globalsPath)) return globalsPath
-
-    // Check for global.css (legacy)
-    const globalPath = path.join(projectRoot, 'src', 'styles', 'global.css')
-    if (fs.existsSync(globalPath)) return globalPath
-
-    return null
-}
-
-/**
- * Get the output path for compiled CSS
- */
-export function getCompiledCssPath(projectRoot: string, mode: 'dev' | 'build'): string {
-    if (mode === 'build') {
-        return path.join(projectRoot, 'dist', 'assets', 'styles.css')
-    }
-    // In dev mode, we use in-memory compilation
-    return ':memory:'
-}

package/compiler/discovery/componentDiscovery.ts

@@ -1,242 +0,0 @@
-/**
- * Component Discovery
- * 
- * Discovers and catalogs components in a Zenith project.
- * Components are auto-imported based on filename:
- * 
- * Auto-Import Rules:
- *   - Component name = filename (without .zen extension)
- *   - Subdirectories are for organization, not namespacing
- *   - Name collisions produce compile-time errors with clear messages
- * 
- * Examples:
- *   components/Header.zen → <Header />
- *   components/sections/HeroSection.zen → <HeroSection />
- *   components/ui/buttons/Primary.zen → <Primary />
- * 
- * If you have name collisions (same filename in different directories),
- * you must rename one of the components.
- * 
- * Requirements:
- *   - Auto-import resolution is deterministic and compile-time only
- *   - Name collisions produce compile-time errors with clear messages
- *   - No runtime component registration or global singleton registries
- */
-
-import * as fs from 'fs'
-import * as path from 'path'
-import { parseZenFile } from '../parse/parseZenFile'
-import { CompilerError } from '../errors/compilerError'
-import type { TemplateNode, ExpressionIR } from '../ir/types'
-
-export interface SlotDefinition {
-    name: string | null  // null = default slot, string = named slot
-    location: {
-        line: number
-        column: number
-    }
-}
-
-export interface ComponentMetadata {
-    name: string          // Component name (e.g., "Card", "HeroSection")
-    path: string          // Absolute path to .zen file
-    relativePath: string  // Relative path from components directory
-    template: string      // Raw template HTML
-    nodes: TemplateNode[] // Parsed template nodes
-    expressions: ExpressionIR[] // Expressions referenced by nodes
-    slots: SlotDefinition[]
-    props: string[]       // Declared props
-    styles: string[]      // Raw CSS from <style> blocks
-    script: string | null         // Raw script content for bundling
-    scriptAttributes: Record<string, string> | null  // Script attributes (setup, lang)
-    hasScript: boolean
-    hasStyles: boolean
-}
-
-/**
- * Discover all components in a directory with auto-import naming
- * 
- * Components are named by their filename (without .zen extension).
- * Subdirectories are for organization only and do not affect the component name.
- * 
- * @param baseDir - Base directory to search (e.g., src/components)
- * @returns Map of component name to metadata
- * @throws CompilerError on name collisions
- */
-export function discoverComponents(baseDir: string): Map<string, ComponentMetadata> {
-    const components = new Map<string, ComponentMetadata>()
-    const collisions = new Map<string, string[]>() // name → [relative paths]
-
-    // Check if components directory exists
-    if (!fs.existsSync(baseDir)) {
-        return components
-    }
-
-    // Recursively find all .zen files
-    const zenFiles = findZenFiles(baseDir)
-
-    for (const filePath of zenFiles) {
-        try {
-            const metadata = parseComponentFile(filePath, baseDir)
-            if (metadata) {
-                // Check for collision
-                if (components.has(metadata.name)) {
-                    const existing = components.get(metadata.name)!
-                    if (!collisions.has(metadata.name)) {
-                        collisions.set(metadata.name, [existing.relativePath])
-                    }
-                    collisions.get(metadata.name)!.push(metadata.relativePath)
-                } else {
-                    components.set(metadata.name, metadata)
-                }
-            }
-        } catch (error: any) {
-            console.warn(`[Zenith] Failed to parse component ${filePath}: ${error.message}`)
-        }
-    }
-
-    // Report all collisions as a single error
-    if (collisions.size > 0) {
-        const collisionMessages = Array.from(collisions.entries())
-            .map(([name, paths]) => {
-                const pathList = paths.map(p => `  - ${p}`).join('\n')
-                return `Component name "${name}" is used by multiple files:\n${pathList}`
-            })
-            .join('\n\n')
-        
-        throw new CompilerError(
-            `Component name collision detected!\n\n${collisionMessages}\n\n` +
-            `Each component must have a unique filename.\n` +
-            `To fix: Rename one of the conflicting components to have a unique name.`,
-            baseDir,
-            0,
-            0
-        )
-    }
-
-    return components
-}
-
-/**
- * Recursively find all .zen files in a directory
- */
-function findZenFiles(dir: string): string[] {
-    const files: string[] = []
-
-    if (!fs.existsSync(dir)) {
-        return files
-    }
-
-    const entries = fs.readdirSync(dir, { withFileTypes: true })
-
-    for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name)
-
-        if (entry.isDirectory()) {
-            files.push(...findZenFiles(fullPath))
-        } else if (entry.isFile() && entry.name.endsWith('.zen')) {
-            files.push(fullPath)
-        }
-    }
-
-    return files
-}
-
-/**
- * Parse a component file and extract metadata
- * 
- * Component name is derived from the filename (without .zen extension).
- * 
- * @param filePath - Absolute path to the component file
- * @param baseDir - Base directory for component discovery (used for relative path)
- */
-function parseComponentFile(filePath: string, baseDir: string): ComponentMetadata | null {
-    const ir = parseZenFile(filePath)
-
-    // Component name is just the filename (without .zen extension)
-    const componentName = path.basename(filePath, '.zen')
-    
-    // Relative path for error messages and debugging
-    const relativePath = path.relative(baseDir, filePath)
-
-    // Extract slots from template
-    const slots = extractSlots(ir.template.nodes)
-
-    // Extract props from script attributes
-    const props = ir.script?.attributes['props']?.split(',').map(p => p.trim()) || []
-
-    // Extract raw CSS from styles
-    const styles = ir.styles.map(s => s.raw)
-
-    return {
-        name: componentName,
-        path: filePath,
-        relativePath,
-        template: ir.template.raw,
-        nodes: ir.template.nodes,
-        expressions: ir.template.expressions,  // Store expressions for later merging
-        slots,
-        props,
-        styles,
-        script: ir.script?.raw || null,                    // Store raw script content
-        scriptAttributes: ir.script?.attributes || null,   // Store script attributes
-        hasScript: ir.script !== null,
-        hasStyles: ir.styles.length > 0
-    }
-}
-
-/**
- * Extract slot definitions from template nodes
- */
-function extractSlots(nodes: TemplateNode[]): SlotDefinition[] {
-    const slots: SlotDefinition[] = []
-
-    function traverse(node: TemplateNode) {
-        if (node.type === 'element') {
-            // Check if this is a <slot> tag
-            if (node.tag === 'slot') {
-                // Extract slot name from attributes
-                const nameAttr = node.attributes.find(attr => attr.name === 'name')
-                const slotName = typeof nameAttr?.value === 'string' ? nameAttr.value : null
-
-                slots.push({
-                    name: slotName,
-                    location: node.location
-                })
-            }
-
-            // Traverse children
-            for (const child of node.children) {
-                traverse(child)
-            }
-        } else if (node.type === 'component') {
-            // Also traverse component children
-            for (const child of node.children) {
-                traverse(child)
-            }
-        }
-    }
-
-    for (const node of nodes) {
-        traverse(node)
-    }
-
-    return slots
-}
-
-/**
- * Check if a tag name represents a component (starts with uppercase)
- */
-export function isComponentTag(tagName: string): boolean {
-    return tagName.length > 0 && tagName[0] !== undefined && tagName[0] === tagName[0].toUpperCase()
-}
-
-/**
- * Get component metadata by name
- */
-export function getComponent(
-    components: Map<string, ComponentMetadata>,
-    name: string
-): ComponentMetadata | undefined {
-    return components.get(name)
-}

package/compiler/discovery/layouts.ts

@@ -1,70 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { parseTemplate } from '../parse/parseTemplate'
-import { parseScript } from '../parse/parseScript'
-import { extractProps, extractStateDeclarations } from '../parse/scriptAnalysis'
-
-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 function discoverLayouts(layoutsDir: string): Map<string, LayoutMetadata> {
-    const layouts = new Map<string, LayoutMetadata>()
-
-    if (!fs.existsSync(layoutsDir)) return layouts
-
-    const files = fs.readdirSync(layoutsDir)
-    for (const file of files) {
-        if (file.endsWith('.zen')) {
-            const filePath = path.join(layoutsDir, file)
-            const name = path.basename(file, '.zen')
-            const source = fs.readFileSync(filePath, 'utf-8')
-
-            const script = parseScript(source)
-            const props = script ? extractProps(script.raw) : []
-            const states = script ? extractStateDeclarations(script.raw) : new Map()
-
-            // Extract styles
-            const styles: string[] = []
-            const styleRegex = /<style[^>]*>([\s\S]*?)<\/style>/gi
-            let match
-            while ((match = styleRegex.exec(source)) !== null) {
-                if (match[1]) styles.push(match[1].trim())
-            }
-
-            // Extract HTML (everything except inline scripts/style)
-            // Preserve external script tags (<script src="...">) but remove inline <script setup> blocks
-            // Use a function-based replace to check for src attribute
-            let html = source.replace(/<script([^>]*)>([\s\S]*?)<\/script>/gi, (match, attrs, content) => {
-                // Keep script tags with src attribute (external scripts)
-                if (attrs.includes('src=')) {
-                    return match;
-                }
-                // Remove inline scripts (those without src)
-                return '';
-            })
-            html = html.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '').trim()
-
-            layouts.set(name, {
-                name,
-                filePath,
-                props,
-                states,
-                html,
-                scripts: script ? [script.raw] : [],
-                styles
-            })
-        }
-    }
-
-    return layouts
-}

package/compiler/errors/compilerError.ts

@@ -1,56 +0,0 @@
-/**
- * Compiler Error Handling
- * 
- * Compiler errors with source location information
- */
-
-export class CompilerError extends Error {
-  file: string
-  line: number
-  column: number
-
-  constructor(message: string, file: string, line: number, column: number) {
-    super(`${file}:${line}:${column} ${message}`)
-    this.name = 'CompilerError'
-    this.file = file
-    this.line = line
-    this.column = column
-  }
-
-  override toString(): string {
-    return `${this.file}:${this.line}:${this.column} ${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: string
-  guarantee: string
-
-  constructor(
-    invariantId: string,
-    message: string,
-    guarantee: string,
-    file: string,
-    line: number,
-    column: number
-  ) {
-    super(`[${invariantId}] ${message}\n\n  Zenith Guarantee: ${guarantee}`, file, line, column)
-    this.name = 'InvariantError'
-    this.invariantId = invariantId
-    this.guarantee = guarantee
-  }
-
-  override toString(): string {
-    return `${this.file}:${this.line}:${this.column} [${this.invariantId}] ${this.message}`
-  }
-}
-