@zenithbuild/compiler 1.0.15 → 1.3.0

package/dist/core/lifecycle/zen-unmount.js

@@ -1,76 +0,0 @@
-/**
- * Zenith OnUnmount - Pre-Unmount Lifecycle Hook
- *
- * Registers a cleanup callback to run before a component is disposed.
- * Useful for cleaning up subscriptions, timers, event listeners, etc.
- *
- * Features:
- * - Runs before component is removed from DOM
- * - Can register multiple callbacks
- * - Callbacks run in registration order
- *
- * @example
- * ```ts
- * zenOnUnmount(() => {
- *   console.log('Cleaning up...')
- *   subscription.unsubscribe()
- *   clearInterval(timerId)
- * })
- * ```
- *
- * Note: This hook registers callbacks that will be executed by the
- * component lifecycle system when the component is disposed.
- */
-/**
- * Queue of registered unmount callbacks
- */
-const unmountCallbacks = new Set();
-/**
- * Register a callback to run before component unmount
- *
- * @param callback - Function to run before unmount
- * @returns Dispose function to cancel the unmount callback
- */
-export function zenOnUnmount(callback) {
-    unmountCallbacks.add(callback);
-    // Return dispose function
-    return () => {
-        unmountCallbacks.delete(callback);
-    };
-}
-/**
- * Execute all unmount callbacks
- * Called by the component lifecycle system before disposal
- *
- * @internal
- */
-export function executeUnmountCallbacks() {
-    // Execute in registration order
-    for (const callback of unmountCallbacks) {
-        try {
-            callback();
-        }
-        catch (error) {
-            console.error('[Zenith] Error in onUnmount callback:', error);
-        }
-    }
-    // Clear all callbacks after execution
-    unmountCallbacks.clear();
-}
-/**
- * Get count of registered unmount callbacks
- * Useful for testing
- *
- * @internal
- */
-export function getUnmountCallbackCount() {
-    return unmountCallbacks.size;
-}
-/**
- * Reset unmount state - for testing purposes
- *
- * @internal
- */
-export function resetUnmountState() {
-    unmountCallbacks.clear();
-}

package/dist/core/plugins/bridge.d.ts

@@ -1,116 +0,0 @@
-/**
- * Zenith CLI Bridge
- *
- * The ONLY interface between CLI and plugins.
- *
- * ═══════════════════════════════════════════════════════════════════════════════
- * CLI BRIDGE RULES (CANONICAL)
- * ═══════════════════════════════════════════════════════════════════════════════
- *
- * 1. No runtime emitters - plugins return data, CLI serializes blindly
- * 2. No plugin typing - all data is unknown
- * 3. No semantic helpers - CLI is blind to what data means
- *
- * The CLI dispatches hooks and collects returns. It never inspects payloads.
- * ═══════════════════════════════════════════════════════════════════════════════
- */
-/**
- * CLI Bridge API - passed to plugins during CLI registration
- *
- * Plugins use this to register namespaced hooks.
- * CLI lifecycle hooks: 'cli:*'
- * Plugin hooks: '<namespace>:*'
- */
-export interface CLIBridgeAPI {
-    /**
-     * Register a hook handler
-     *
-     * @param hook - Namespaced hook name (e.g., 'cli:runtime:collect', 'content:dev:watch')
-     * @param handler - Handler function that receives context and optionally returns data
-     */
-    on(hook: string, handler: (ctx: HookContext) => unknown | void | Promise<unknown | void>): void;
-}
-/**
- * Context passed to hook handlers
- *
- * CLI provides this but never uses getPluginData itself.
- * Only plugins call getPluginData with their own namespace.
- */
-export interface HookContext {
-    /** Absolute path to project root */
-    projectRoot: string;
-    /**
-     * Opaque data accessor
-     *
-     * CLI passes this function but NEVER calls it.
-     * Only plugins use it to access their own namespaced data.
-     */
-    getPluginData: (namespace: string) => unknown;
-    /** Additional context data (e.g., filename for file-change hooks) */
-    [key: string]: unknown;
-}
-/**
- * Runtime payload returned by plugins
- *
- * CLI collects these and serializes without inspection.
- * The envelope structure is: { [namespace]: payload }
- */
-export interface RuntimePayload {
-    /** Plugin namespace (e.g., 'content', 'router') */
-    namespace: string;
-    /** Opaque payload - CLI never inspects this */
-    payload: unknown;
-}
-type HookHandler = (ctx: HookContext) => unknown | void | Promise<unknown | void>;
-/**
- * Register a hook handler
- *
- * @internal Called by CLIBridgeAPI.on()
- */
-export declare function registerHook(hook: string, handler: HookHandler): void;
-/**
- * Clear all registered hooks
- *
- * @internal Used for testing and cleanup
- */
-export declare function clearHooks(): void;
-/**
- * Run all handlers for a hook (fire-and-forget)
- *
- * CLI calls this for lifecycle events.
- * No return values are collected.
- *
- * @param hook - Hook name to dispatch
- * @param ctx - Hook context
- */
-export declare function runPluginHooks(hook: string, ctx: HookContext): Promise<void>;
-/**
- * Collect return values from all handlers for a hook
- *
- * CLI calls this for 'cli:runtime:collect' to gather plugin payloads.
- * Only RuntimePayload-shaped returns are collected.
- *
- * @param hook - Hook name to dispatch
- * @param ctx - Hook context
- * @returns Array of runtime payloads from plugins
- */
-export declare function collectHookReturns(hook: string, ctx: HookContext): Promise<RuntimePayload[]>;
-/**
- * Build runtime envelope from collected payloads
- *
- * CLI calls this to serialize plugin data for injection.
- * CLI never inspects the envelope contents.
- *
- * @param payloads - Array of runtime payloads from collectHookReturns
- * @returns Envelope object: { [namespace]: payload }
- */
-export declare function buildRuntimeEnvelope(payloads: RuntimePayload[]): Record<string, unknown>;
-/**
- * Create a CLI Bridge API for plugin registration
- *
- * CLI calls this once and passes to each plugin's registerCLI method.
- *
- * @returns CLIBridgeAPI instance
- */
-export declare function createBridgeAPI(): CLIBridgeAPI;
-export {};

package/dist/core/plugins/bridge.js

@@ -1,121 +0,0 @@
-/**
- * Zenith CLI Bridge
- *
- * The ONLY interface between CLI and plugins.
- *
- * ═══════════════════════════════════════════════════════════════════════════════
- * CLI BRIDGE RULES (CANONICAL)
- * ═══════════════════════════════════════════════════════════════════════════════
- *
- * 1. No runtime emitters - plugins return data, CLI serializes blindly
- * 2. No plugin typing - all data is unknown
- * 3. No semantic helpers - CLI is blind to what data means
- *
- * The CLI dispatches hooks and collects returns. It never inspects payloads.
- * ═══════════════════════════════════════════════════════════════════════════════
- */
-const hookRegistry = new Map();
-/**
- * Register a hook handler
- *
- * @internal Called by CLIBridgeAPI.on()
- */
-export function registerHook(hook, handler) {
-    if (!hookRegistry.has(hook)) {
-        hookRegistry.set(hook, []);
-    }
-    hookRegistry.get(hook).push(handler);
-}
-/**
- * Clear all registered hooks
- *
- * @internal Used for testing and cleanup
- */
-export function clearHooks() {
-    hookRegistry.clear();
-}
-// ============================================
-// Hook Execution (CLI-facing)
-// ============================================
-/**
- * Run all handlers for a hook (fire-and-forget)
- *
- * CLI calls this for lifecycle events.
- * No return values are collected.
- *
- * @param hook - Hook name to dispatch
- * @param ctx - Hook context
- */
-export async function runPluginHooks(hook, ctx) {
-    const handlers = hookRegistry.get(hook) || [];
-    for (const handler of handlers) {
-        try {
-            await handler(ctx);
-        }
-        catch (error) {
-            console.error(`[Zenith] Hook "${hook}" error:`, error);
-        }
-    }
-}
-/**
- * Collect return values from all handlers for a hook
- *
- * CLI calls this for 'cli:runtime:collect' to gather plugin payloads.
- * Only RuntimePayload-shaped returns are collected.
- *
- * @param hook - Hook name to dispatch
- * @param ctx - Hook context
- * @returns Array of runtime payloads from plugins
- */
-export async function collectHookReturns(hook, ctx) {
-    const handlers = hookRegistry.get(hook) || [];
-    const results = [];
-    for (const handler of handlers) {
-        try {
-            const result = await handler(ctx);
-            // Only collect properly shaped payloads
-            if (result &&
-                typeof result === 'object' &&
-                'namespace' in result &&
-                'payload' in result &&
-                typeof result.namespace === 'string') {
-                results.push(result);
-            }
-        }
-        catch (error) {
-            console.error(`[Zenith] Hook "${hook}" collection error:`, error);
-        }
-    }
-    return results;
-}
-/**
- * Build runtime envelope from collected payloads
- *
- * CLI calls this to serialize plugin data for injection.
- * CLI never inspects the envelope contents.
- *
- * @param payloads - Array of runtime payloads from collectHookReturns
- * @returns Envelope object: { [namespace]: payload }
- */
-export function buildRuntimeEnvelope(payloads) {
-    const envelope = {};
-    for (const { namespace, payload } of payloads) {
-        envelope[namespace] = payload;
-    }
-    return envelope;
-}
-// ============================================
-// Bridge API Factory
-// ============================================
-/**
- * Create a CLI Bridge API for plugin registration
- *
- * CLI calls this once and passes to each plugin's registerCLI method.
- *
- * @returns CLIBridgeAPI instance
- */
-export function createBridgeAPI() {
-    return {
-        on: registerHook
-    };
-}

package/dist/core/plugins/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Zenith Plugins
- *
- * Public exports for plugin system
- */
-export { PluginRegistry, createPluginContext } from './registry';

package/dist/core/plugins/index.js

@@ -1,6 +0,0 @@
-/**
- * Zenith Plugins
- *
- * Public exports for plugin system
- */
-export { PluginRegistry, createPluginContext } from './registry';

package/dist/core/plugins/registry.d.ts

@@ -1,67 +0,0 @@
-/**
- * Zenith Plugin Registry
- *
- * Manages plugin registration and initialization
- *
- * ═══════════════════════════════════════════════════════════════════════════════
- * HOOK OWNERSHIP RULE (CANONICAL)
- * ═══════════════════════════════════════════════════════════════════════════════
- *
- * The plugin registry is part of core infrastructure.
- * It MUST remain plugin-agnostic:
- *   - No plugin-specific types
- *   - No plugin-specific logic
- *   - Generic data handling only
- *
- * Plugins own their data structures; core provides the storage mechanism.
- * ═══════════════════════════════════════════════════════════════════════════════
- */
-import type { ZenithPlugin, PluginContext } from '../config/types';
-/**
- * Get all plugin data (for runtime access)
- */
-export declare function getPluginData(): Record<string, unknown[]>;
-/**
- * Get plugin data by namespace
- */
-export declare function getPluginDataByNamespace(namespace: string): unknown[];
-/**
- * Plugin registry for managing Zenith plugins
- */
-export declare class PluginRegistry {
-    private plugins;
-    /**
-     * Register a plugin
-     */
-    register(plugin: ZenithPlugin): void;
-    /**
-     * Get a plugin by name
-     */
-    get(name: string): ZenithPlugin | undefined;
-    /**
-     * Check if a plugin is registered
-     */
-    has(name: string): boolean;
-    /**
-     * Get all registered plugins
-     */
-    all(): ZenithPlugin[];
-    /**
-     * Initialize all plugins with the provided context
-     */
-    initAll(ctx: PluginContext): Promise<void>;
-    /**
-     * Clear all registered plugins
-     */
-    clear(): void;
-}
-/**
- * Create a plugin context for initialization
- *
- * Uses a generic data setter that stores data by namespace.
- * Plugins define their own data structures internally.
- *
- * @param projectRoot - Absolute path to the project root
- * @returns A PluginContext for plugin initialization
- */
-export declare function createPluginContext(projectRoot: string): PluginContext;

package/dist/core/plugins/registry.js

@@ -1,112 +0,0 @@
-/**
- * Zenith Plugin Registry
- *
- * Manages plugin registration and initialization
- *
- * ═══════════════════════════════════════════════════════════════════════════════
- * HOOK OWNERSHIP RULE (CANONICAL)
- * ═══════════════════════════════════════════════════════════════════════════════
- *
- * The plugin registry is part of core infrastructure.
- * It MUST remain plugin-agnostic:
- *   - No plugin-specific types
- *   - No plugin-specific logic
- *   - Generic data handling only
- *
- * Plugins own their data structures; core provides the storage mechanism.
- * ═══════════════════════════════════════════════════════════════════════════════
- */
-/**
- * Global plugin data store
- *
- * Plugins store their data here using namespaced keys.
- * Core does not interpret this data - it just stores and serves it.
- */
-const pluginDataStore = {};
-/**
- * Get all plugin data (for runtime access)
- */
-export function getPluginData() {
-    return { ...pluginDataStore };
-}
-/**
- * Get plugin data by namespace
- */
-export function getPluginDataByNamespace(namespace) {
-    return pluginDataStore[namespace] || [];
-}
-/**
- * Plugin registry for managing Zenith plugins
- */
-export class PluginRegistry {
-    plugins = new Map();
-    /**
-     * Register a plugin
-     */
-    register(plugin) {
-        if (this.plugins.has(plugin.name)) {
-            console.warn(`[Zenith] Plugin "${plugin.name}" is already registered. Overwriting.`);
-        }
-        this.plugins.set(plugin.name, plugin);
-    }
-    /**
-     * Get a plugin by name
-     */
-    get(name) {
-        return this.plugins.get(name);
-    }
-    /**
-     * Check if a plugin is registered
-     */
-    has(name) {
-        return this.plugins.has(name);
-    }
-    /**
-     * Get all registered plugins
-     */
-    all() {
-        return Array.from(this.plugins.values());
-    }
-    /**
-     * Initialize all plugins with the provided context
-     */
-    async initAll(ctx) {
-        for (const plugin of this.plugins.values()) {
-            try {
-                await plugin.setup(ctx);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                console.error(`[Zenith] Failed to initialize plugin "${plugin.name}":`, message);
-            }
-        }
-    }
-    /**
-     * Clear all registered plugins
-     */
-    clear() {
-        this.plugins.clear();
-        // Also clear plugin data
-        for (const key of Object.keys(pluginDataStore)) {
-            delete pluginDataStore[key];
-        }
-    }
-}
-/**
- * Create a plugin context for initialization
- *
- * Uses a generic data setter that stores data by namespace.
- * Plugins define their own data structures internally.
- *
- * @param projectRoot - Absolute path to the project root
- * @returns A PluginContext for plugin initialization
- */
-export function createPluginContext(projectRoot) {
-    return {
-        projectRoot,
-        setPluginData: (namespace, data) => {
-            pluginDataStore[namespace] = data;
-        },
-        options: {}
-    };
-}

package/dist/core/reactivity/index.d.ts

@@ -1,30 +0,0 @@
-/**
- * Zenith Reactivity System
- *
- * This module exports all reactive primitives for the Zenith framework.
- *
- * Exports both explicit `zen*` names (internal) and clean aliases (public DX).
- */
-import { zenSignal as _zenSignal, type Signal } from './zen-signal';
-import { zenState as _zenState } from './zen-state';
-import { zenEffect as _zenEffect, type EffectFn, type DisposeFn } from './zen-effect';
-import { zenMemo as _zenMemo, type Memo } from './zen-memo';
-import { zenRef as _zenRef, type Ref } from './zen-ref';
-import { zenBatch as _zenBatch } from './zen-batch';
-import { zenUntrack as _zenUntrack } from './zen-untrack';
-export declare const zenSignal: typeof _zenSignal;
-export declare const zenState: typeof _zenState;
-export declare const zenEffect: typeof _zenEffect;
-export declare const zenMemo: typeof _zenMemo;
-export declare const zenRef: typeof _zenRef;
-export declare const zenBatch: typeof _zenBatch;
-export declare const zenUntrack: typeof _zenUntrack;
-export type { Signal, Memo, Ref, EffectFn, DisposeFn };
-export { type Subscriber, type TrackingContext, trackDependency, notifySubscribers, getCurrentContext, pushContext, popContext, cleanupContext, runUntracked, startBatch, endBatch, isBatching } from './tracking';
-export declare const signal: typeof _zenSignal;
-export declare const state: typeof _zenState;
-export declare const effect: typeof _zenEffect;
-export declare const memo: typeof _zenMemo;
-export declare const ref: typeof _zenRef;
-export declare const batch: typeof _zenBatch;
-export declare const untrack: typeof _zenUntrack;

package/dist/core/reactivity/index.js

@@ -1,33 +0,0 @@
-/**
- * Zenith Reactivity System
- *
- * This module exports all reactive primitives for the Zenith framework.
- *
- * Exports both explicit `zen*` names (internal) and clean aliases (public DX).
- */
-// Core primitives - explicit names
-import { zenSignal as _zenSignal } from './zen-signal';
-import { zenState as _zenState } from './zen-state';
-import { zenEffect as _zenEffect } from './zen-effect';
-import { zenMemo as _zenMemo } from './zen-memo';
-import { zenRef as _zenRef } from './zen-ref';
-import { zenBatch as _zenBatch } from './zen-batch';
-import { zenUntrack as _zenUntrack } from './zen-untrack';
-// Re-export with explicit names
-export const zenSignal = _zenSignal;
-export const zenState = _zenState;
-export const zenEffect = _zenEffect;
-export const zenMemo = _zenMemo;
-export const zenRef = _zenRef;
-export const zenBatch = _zenBatch;
-export const zenUntrack = _zenUntrack;
-// Internal tracking utilities (for advanced use)
-export { trackDependency, notifySubscribers, getCurrentContext, pushContext, popContext, cleanupContext, runUntracked, startBatch, endBatch, isBatching } from './tracking';
-// Public DX aliases - clean names
-export const signal = _zenSignal;
-export const state = _zenState;
-export const effect = _zenEffect;
-export const memo = _zenMemo;
-export const ref = _zenRef;
-export const batch = _zenBatch;
-export const untrack = _zenUntrack;

package/dist/core/reactivity/tracking.d.ts

@@ -1,74 +0,0 @@
-/**
- * Zenith Reactivity Tracking System
- *
- * This module provides the core dependency tracking mechanism used by
- * signals, effects, and memos. It uses a stack-based approach to track
- * which reactive values are accessed during effect/memo execution.
- *
- * Key concepts:
- * - Subscriber: A function that should be called when a dependency changes
- * - Tracking context: The currently executing effect/memo that should collect dependencies
- * - Dependency: A reactive value that an effect/memo depends on
- */
-/**
- * A subscriber is a function that gets called when a reactive value changes
- */
-export type Subscriber = () => void;
-/**
- * Tracking context - represents an effect or memo that is collecting dependencies
- */
-export interface TrackingContext {
-    /** The function to call when dependencies change */
-    execute: Subscriber;
-    /** Set of dependency subscriber sets this context is registered with */
-    dependencies: Set<Set<Subscriber>>;
-}
-/**
- * Get the current tracking context (if any)
- */
-export declare function getCurrentContext(): TrackingContext | undefined;
-/**
- * Push a new tracking context onto the stack
- */
-export declare function pushContext(context: TrackingContext): void;
-/**
- * Pop the current tracking context from the stack
- */
-export declare function popContext(): TrackingContext | undefined;
-/**
- * Track a dependency - called when a reactive value is read
- *
- * @param subscribers - The subscriber set of the reactive value being read
- */
-export declare function trackDependency(subscribers: Set<Subscriber>): void;
-/**
- * Notify subscribers that a reactive value has changed
- *
- * @param subscribers - The subscriber set to notify
- */
-export declare function notifySubscribers(subscribers: Set<Subscriber>): void;
-/**
- * Clean up a tracking context - remove it from all dependency sets
- *
- * @param context - The context to clean up
- */
-export declare function cleanupContext(context: TrackingContext): void;
-/**
- * Run a function without tracking dependencies
- *
- * @param fn - The function to run
- * @returns The return value of the function
- */
-export declare function runUntracked<T>(fn: () => T): T;
-/**
- * Start a batch - defer effect execution until batch ends
- */
-export declare function startBatch(): void;
-/**
- * End a batch - run all pending effects
- */
-export declare function endBatch(): void;
-/**
- * Check if currently inside a batch
- */
-export declare function isBatching(): boolean;