@zenithbuild/compiler 1.0.15 → 1.3.0

package/dist/core/reactivity/zen-signal.js

@@ -1,84 +0,0 @@
-/**
- * Zenith Signal - Atomic Reactive Value
- *
- * A signal is the most basic reactive primitive. It holds a single value
- * and notifies subscribers when the value changes.
- *
- * Features:
- * - Getter/setter model
- * - Automatic dependency tracking
- * - Fine-grained reactivity (no component re-rendering)
- *
- * @example
- * ```ts
- * const count = zenSignal(0)
- *
- * // Read value
- * console.log(count()) // 0
- *
- * // Write value
- * count(1)
- *
- * // Or use .value
- * count.value = 2
- * console.log(count.value) // 2
- * ```
- */
-import { trackDependency, notifySubscribers } from './tracking';
-/**
- * Create a reactive signal
- *
- * @param initialValue - The initial value of the signal
- * @returns A signal that can be read and written
- */
-export function zenSignal(initialValue) {
-    const state = {
-        value: initialValue,
-        subscribers: new Set()
-    };
-    // The signal function - acts as both getter and setter
-    function signal(newValue) {
-        if (arguments.length === 0) {
-            // Getter - track dependency and return value
-            trackDependency(state.subscribers);
-            return state.value;
-        }
-        else {
-            // Setter - update value and notify
-            const oldValue = state.value;
-            state.value = newValue;
-            if (!Object.is(oldValue, newValue)) {
-                notifySubscribers(state.subscribers);
-            }
-            return state.value;
-        }
-    }
-    // Add .value accessor
-    Object.defineProperty(signal, 'value', {
-        get() {
-            trackDependency(state.subscribers);
-            return state.value;
-        },
-        set(newValue) {
-            const oldValue = state.value;
-            state.value = newValue;
-            if (!Object.is(oldValue, newValue)) {
-                notifySubscribers(state.subscribers);
-            }
-        },
-        enumerable: true,
-        configurable: false
-    });
-    signal.peek = function () {
-        return state.value;
-    };
-    signal.subscribe = function (fn) {
-        const subscriber = () => fn(state.value);
-        state.subscribers.add(subscriber);
-        // Return unsubscribe function
-        return () => {
-            state.subscribers.delete(subscriber);
-        };
-    };
-    return signal;
-}

package/dist/core/reactivity/zen-state.d.ts

@@ -1,35 +0,0 @@
-/**
- * Zenith State - Deep Reactive Object
- *
- * Creates a deeply reactive object using Proxy. Any property access
- * is tracked, and any mutation triggers effects.
- *
- * Features:
- * - Deep reactivity via nested Proxies
- * - Automatic dependency tracking on property access
- * - Triggers effects on property mutation
- *
- * @example
- * ```ts
- * const user = zenState({
- *   name: 'John',
- *   address: {
- *     city: 'NYC'
- *   }
- * })
- *
- * // Access triggers tracking
- * console.log(user.name)
- *
- * // Mutation triggers effects
- * user.name = 'Jane'
- * user.address.city = 'LA'
- * ```
- */
-/**
- * Create a deeply reactive state object
- *
- * @param initialValue - The initial state object
- * @returns A reactive proxy of the object
- */
-export declare function zenState<T extends object>(initialValue: T): T;

package/dist/core/reactivity/zen-state.js

@@ -1,147 +0,0 @@
-/**
- * Zenith State - Deep Reactive Object
- *
- * Creates a deeply reactive object using Proxy. Any property access
- * is tracked, and any mutation triggers effects.
- *
- * Features:
- * - Deep reactivity via nested Proxies
- * - Automatic dependency tracking on property access
- * - Triggers effects on property mutation
- *
- * @example
- * ```ts
- * const user = zenState({
- *   name: 'John',
- *   address: {
- *     city: 'NYC'
- *   }
- * })
- *
- * // Access triggers tracking
- * console.log(user.name)
- *
- * // Mutation triggers effects
- * user.name = 'Jane'
- * user.address.city = 'LA'
- * ```
- */
-import { trackDependency, notifySubscribers } from './tracking';
-/**
- * WeakMap to store proxy targets and their subscriber maps
- * Key: target object
- * Value: Map of property key -> subscriber set
- */
-const proxySubscribers = new WeakMap();
-/**
- * WeakMap to store original objects and their proxies
- * Prevents creating multiple proxies for the same object
- */
-const proxyCache = new WeakMap();
-/**
- * Get or create subscriber set for a property
- */
-function getPropertySubscribers(target, key) {
-    let propertyMap = proxySubscribers.get(target);
-    if (!propertyMap) {
-        propertyMap = new Map();
-        proxySubscribers.set(target, propertyMap);
-    }
-    let subscribers = propertyMap.get(key);
-    if (!subscribers) {
-        subscribers = new Set();
-        propertyMap.set(key, subscribers);
-    }
-    return subscribers;
-}
-/**
- * Check if a value should be wrapped in a proxy
- */
-function shouldProxy(value) {
-    if (value === null || typeof value !== 'object') {
-        return false;
-    }
-    // Don't proxy special objects
-    if (value instanceof Date ||
-        value instanceof RegExp ||
-        value instanceof Map ||
-        value instanceof Set ||
-        value instanceof WeakMap ||
-        value instanceof WeakSet ||
-        value instanceof Promise ||
-        ArrayBuffer.isView(value)) {
-        return false;
-    }
-    return true;
-}
-/**
- * Create a reactive proxy for an object
- */
-function createReactiveProxy(target) {
-    // Check cache first
-    const cached = proxyCache.get(target);
-    if (cached) {
-        return cached;
-    }
-    const proxy = new Proxy(target, {
-        get(target, key, receiver) {
-            // Track dependency
-            const subscribers = getPropertySubscribers(target, key);
-            trackDependency(subscribers);
-            const value = Reflect.get(target, key, receiver);
-            // Recursively proxy nested objects
-            if (shouldProxy(value)) {
-                return createReactiveProxy(value);
-            }
-            return value;
-        },
-        set(target, key, value, receiver) {
-            const oldValue = Reflect.get(target, key, receiver);
-            // Unwrap proxies before storing
-            const rawValue = value;
-            const result = Reflect.set(target, key, rawValue, receiver);
-            // Only notify if value actually changed
-            if (!Object.is(oldValue, rawValue)) {
-                const subscribers = getPropertySubscribers(target, key);
-                notifySubscribers(subscribers);
-            }
-            return result;
-        },
-        deleteProperty(target, key) {
-            const hadKey = Reflect.has(target, key);
-            const result = Reflect.deleteProperty(target, key);
-            if (hadKey && result) {
-                const subscribers = getPropertySubscribers(target, key);
-                notifySubscribers(subscribers);
-            }
-            return result;
-        },
-        has(target, key) {
-            // Track dependency for 'in' operator
-            const subscribers = getPropertySubscribers(target, key);
-            trackDependency(subscribers);
-            return Reflect.has(target, key);
-        },
-        ownKeys(target) {
-            // Track a special 'keys' dependency for iteration
-            const subscribers = getPropertySubscribers(target, Symbol.for('zen:keys'));
-            trackDependency(subscribers);
-            return Reflect.ownKeys(target);
-        }
-    });
-    // Cache the proxy
-    proxyCache.set(target, proxy);
-    return proxy;
-}
-/**
- * Create a deeply reactive state object
- *
- * @param initialValue - The initial state object
- * @returns A reactive proxy of the object
- */
-export function zenState(initialValue) {
-    if (!shouldProxy(initialValue)) {
-        throw new Error('zenState requires a plain object or array');
-    }
-    return createReactiveProxy(initialValue);
-}

package/dist/core/reactivity/zen-untrack.d.ts

@@ -1,38 +0,0 @@
-/**
- * Zenith Untrack - Escape Dependency Tracking
- *
- * Allows reading reactive values without creating a dependency.
- * Useful when you need to read a value inside an effect but don't
- * want the effect to re-run when that value changes.
- *
- * Features:
- * - Disables dependency tracking within the callback
- * - Returns the callback's return value
- * - Can be nested
- *
- * @example
- * ```ts
- * const count = zenSignal(0)
- * const multiplier = zenSignal(2)
- *
- * zenEffect(() => {
- *   // This creates a dependency on 'count'
- *   const c = count()
- *
- *   // This does NOT create a dependency on 'multiplier'
- *   const m = zenUntrack(() => multiplier())
- *
- *   console.log(c * m)
- * })
- *
- * count(5)       // Effect re-runs
- * multiplier(3)  // Effect does NOT re-run
- * ```
- */
-/**
- * Execute a function without tracking dependencies
- *
- * @param fn - The function to execute
- * @returns The return value of the function
- */
-export declare function zenUntrack<T>(fn: () => T): T;

package/dist/core/reactivity/zen-untrack.js

@@ -1,41 +0,0 @@
-/**
- * Zenith Untrack - Escape Dependency Tracking
- *
- * Allows reading reactive values without creating a dependency.
- * Useful when you need to read a value inside an effect but don't
- * want the effect to re-run when that value changes.
- *
- * Features:
- * - Disables dependency tracking within the callback
- * - Returns the callback's return value
- * - Can be nested
- *
- * @example
- * ```ts
- * const count = zenSignal(0)
- * const multiplier = zenSignal(2)
- *
- * zenEffect(() => {
- *   // This creates a dependency on 'count'
- *   const c = count()
- *
- *   // This does NOT create a dependency on 'multiplier'
- *   const m = zenUntrack(() => multiplier())
- *
- *   console.log(c * m)
- * })
- *
- * count(5)       // Effect re-runs
- * multiplier(3)  // Effect does NOT re-run
- * ```
- */
-import { runUntracked } from './tracking';
-/**
- * Execute a function without tracking dependencies
- *
- * @param fn - The function to execute
- * @returns The return value of the function
- */
-export function zenUntrack(fn) {
-    return runUntracked(fn);
-}

package/dist/css/index.d.ts

@@ -1,73 +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.
- */
-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;
-}
-/**
- * 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 declare function compileCss(options: CSSCompileOptions): CSSCompileResult;
-/**
- * Compile CSS asynchronously (non-blocking)
- *
- * Used for HMR updates where we don't want to block the main thread.
- */
-export declare function compileCssAsync(options: CSSCompileOptions): Promise<CSSCompileResult>;
-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 declare function watchCss(options: CSSWatchOptions): () => void;
-/**
- * Resolve the canonical globals.css path for a Zenith project
- */
-export declare function resolveGlobalsCss(projectRoot: string): string | null;
-/**
- * Get the output path for compiled CSS
- */
-export declare function getCompiledCssPath(projectRoot: string, mode: 'dev' | 'build'): string;

package/dist/css/index.js

@@ -1,246 +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';
-// ============================================
-// 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) {
-    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) {
-        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) {
-    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
-            });
-        });
-    });
-}
-/**
- * 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) {
-    const { input, output, minify, onChange, debounce = 100 } = options;
-    let timeout = 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 = 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) {
-    // 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, mode) {
-    if (mode === 'build') {
-        return path.join(projectRoot, 'dist', 'assets', 'styles.css');
-    }
-    // In dev mode, we use in-memory compilation
-    return ':memory:';
-}