@zenithbuild/core 0.6.2 → 0.6.4

package/core/index.ts

@@ -1,135 +0,0 @@
-/**
- * Zenith Core Runtime
- * 
- * This is the foundational layer of the Zenith framework, providing:
- * - Reactive primitives (signals, state, effects, memos)
- * - Lifecycle hooks (onMount, onUnmount)
- * 
- * Design principles:
- * - Auto-tracked reactivity (no dependency arrays)
- * - No VDOM or render loops
- * - Runtime-agnostic (works in browser, SSR, tests)
- * - Hybrid naming: internal `zen*` + public clean names
- * 
- * @example
- * ```ts
- * // Using clean names (recommended for application code)
- * import { signal, effect, onMount } from 'zenith/core'
- * 
- * const count = signal(0)
- * 
- * effect(() => {
- *   console.log('Count:', count())
- * })
- * 
- * onMount(() => {
- *   console.log('Mounted!')
- * })
- * ```
- * 
- * @example
- * ```ts
- * // Using explicit zen* names (for library/internal code)
- * import { zenSignal, zenEffect, zenOnMount } from 'zenith/core'
- * 
- * const count = zenSignal(0)
- * zenEffect(() => console.log(count()))
- * zenOnMount(() => console.log('Ready'))
- * ```
- * 
- * @example
- * ```ts
- * // For navigation, import from router
- * import { navigate, isActive } from 'zenith/router'
- * 
- * navigate('/about')
- * if (isActive('/blog')) {
- *   // Handle active state
- * }
- * ```
- */
-
-// ============================================
-// Reactivity Primitives
-// ============================================
-
-// Explicit zen* exports (internal naming)
-export {
-  zenSignal,
-  zenState,
-  zenEffect,
-  zenMemo,
-  zenRef,
-  zenBatch,
-  zenUntrack
-} from './reactivity'
-
-// Types
-export type {
-  Signal,
-  Memo,
-  Ref,
-  EffectFn,
-  DisposeFn,
-  Subscriber,
-  TrackingContext
-} from './reactivity'
-
-// Clean name exports (public DX)
-export {
-  signal,
-  state,
-  effect,
-  memo,
-  ref,
-  batch,
-  untrack
-} from './reactivity'
-
-// Internal tracking utilities (advanced use)
-export {
-  trackDependency,
-  notifySubscribers,
-  getCurrentContext,
-  pushContext,
-  popContext,
-  cleanupContext,
-  runUntracked,
-  startBatch,
-  endBatch,
-  isBatching
-} from './reactivity'
-
-// ============================================
-// Lifecycle Hooks
-// ============================================
-
-// Explicit zen* exports (internal naming)
-export {
-  zenOnMount,
-  zenOnUnmount
-} from './lifecycle'
-
-// Clean name exports (public DX)
-export {
-  onMount,
-  onUnmount
-} from './lifecycle'
-
-// Types
-export type {
-  MountCallback,
-  UnmountCallback
-} from './lifecycle'
-
-// Internal lifecycle utilities (for component system)
-export {
-  triggerMount,
-  triggerUnmount,
-  executeUnmountCallbacks,
-  getIsMounted,
-  getUnmountCallbackCount,
-  resetMountState,
-  resetUnmountState
-} from './lifecycle'
-

package/core/lifecycle/index.ts

@@ -1,49 +0,0 @@
-/**
- * Zenith Lifecycle Hooks
- * 
- * This module exports lifecycle hooks for component mount/unmount events.
- * These are effect wrappers that integrate with the component lifecycle system.
- * 
- * Exports both explicit `zen*` names (internal) and clean aliases (public DX).
- */
-
-// Import lifecycle hooks
-import {
-  zenOnMount as _zenOnMount,
-  triggerMount,
-  triggerUnmount,
-  getIsMounted,
-  resetMountState,
-  type MountCallback
-} from './zen-mount'
-
-import {
-  zenOnUnmount as _zenOnUnmount,
-  executeUnmountCallbacks,
-  getUnmountCallbackCount,
-  resetUnmountState,
-  type UnmountCallback
-} from './zen-unmount'
-
-// Re-export with explicit names
-export const zenOnMount = _zenOnMount
-export const zenOnUnmount = _zenOnUnmount
-
-// Re-export utilities
-export {
-  triggerMount,
-  triggerUnmount,
-  getIsMounted,
-  resetMountState,
-  executeUnmountCallbacks,
-  getUnmountCallbackCount,
-  resetUnmountState
-}
-
-// Re-export types
-export type { MountCallback, UnmountCallback }
-
-// Public DX aliases - clean names
-export const onMount = _zenOnMount
-export const onUnmount = _zenOnUnmount
-

package/core/lifecycle/zen-mount.ts

@@ -1,182 +0,0 @@
-/**
- * Zenith OnMount - Post-Mount Lifecycle Hook
- * 
- * Registers a callback to run after a component's DOM is inserted.
- * This is an effect wrapper that defers execution until the mount phase.
- * 
- * Features:
- * - Runs after DOM is available
- * - Only runs once per mount
- * - Supports cleanup function return
- * - Works with component lifecycle system
- * 
- * @example
- * ```ts
- * zenOnMount(() => {
- *   console.log('Component mounted!')
- *   const el = document.querySelector('.my-element')
- *   
- *   // Optional cleanup - runs on unmount
- *   return () => {
- *     console.log('Component will unmount')
- *   }
- * })
- * ```
- * 
- * Note: This hook registers callbacks that will be executed by the
- * component lifecycle system. If no mount scheduler is active,
- * callbacks are queued for later execution.
- */
-
-/**
- * Mount callback type - can optionally return a cleanup function
- */
-export type MountCallback = () => void | (() => void)
-
-/**
- * Mount hook state
- */
-interface MountHookState {
-  callback: MountCallback
-  cleanup: (() => void) | null
-  mounted: boolean
-}
-
-/**
- * Queue of pending mount callbacks
- * These are registered but not yet executed because mount hasn't occurred
- */
-const pendingMountCallbacks: MountHookState[] = []
-
-/**
- * Currently active mount hooks (for cleanup on unmount)
- */
-const activeMountHooks: Set<MountHookState> = new Set()
-
-/**
- * Flag indicating whether we're in a mounted state
- * This is controlled by the component lifecycle system
- */
-let isMounted = false
-
-/**
- * Register a callback to run after component mount
- * 
- * @param callback - Function to run after mount (can return cleanup function)
- * @returns Dispose function to cancel the mount callback
- */
-export function zenOnMount(callback: MountCallback): () => void {
-  const state: MountHookState = {
-    callback,
-    cleanup: null,
-    mounted: false
-  }
-  
-  if (isMounted) {
-    // Already mounted - run immediately
-    executeMountCallback(state)
-  } else {
-    // Queue for later execution
-    pendingMountCallbacks.push(state)
-  }
-  
-  activeMountHooks.add(state)
-  
-  // Return dispose function
-  return () => {
-    // Remove from pending if not yet executed
-    const pendingIndex = pendingMountCallbacks.indexOf(state)
-    if (pendingIndex !== -1) {
-      pendingMountCallbacks.splice(pendingIndex, 1)
-    }
-    
-    // Run cleanup if already mounted
-    if (state.mounted && state.cleanup) {
-      state.cleanup()
-      state.cleanup = null
-    }
-    
-    activeMountHooks.delete(state)
-  }
-}
-
-/**
- * Execute a mount callback
- */
-function executeMountCallback(state: MountHookState): void {
-  if (state.mounted) return
-  
-  state.mounted = true
-  
-  try {
-    const result = state.callback()
-    
-    if (typeof result === 'function') {
-      state.cleanup = result
-    }
-  } catch (error) {
-    console.error('[Zenith] Error in onMount callback:', error)
-  }
-}
-
-/**
- * Trigger mount phase - called by component lifecycle system
- * Executes all pending mount callbacks
- * 
- * @internal
- */
-export function triggerMount(): void {
-  isMounted = true
-  
-  // Execute all pending callbacks
-  const callbacks = [...pendingMountCallbacks]
-  pendingMountCallbacks.length = 0
-  
-  for (const state of callbacks) {
-    executeMountCallback(state)
-  }
-}
-
-/**
- * Trigger unmount phase - called by component lifecycle system
- * Runs cleanup functions for all active mount hooks
- * 
- * @internal
- */
-export function triggerUnmount(): void {
-  isMounted = false
-  
-  // Run all cleanup functions
-  for (const state of activeMountHooks) {
-    if (state.cleanup) {
-      try {
-        state.cleanup()
-      } catch (error) {
-        console.error('[Zenith] Error in onMount cleanup:', error)
-      }
-      state.cleanup = null
-    }
-    state.mounted = false
-  }
-}
-
-/**
- * Check if currently in mounted state
- * 
- * @internal
- */
-export function getIsMounted(): boolean {
-  return isMounted
-}
-
-/**
- * Reset mount state - for testing purposes
- * 
- * @internal
- */
-export function resetMountState(): void {
-  isMounted = false
-  pendingMountCallbacks.length = 0
-  activeMountHooks.clear()
-}
-

package/core/lifecycle/zen-unmount.ts

@@ -1,88 +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.
- */
-
-/**
- * Unmount callback type
- */
-export type UnmountCallback = () => void
-
-/**
- * Queue of registered unmount callbacks
- */
-const unmountCallbacks: Set<UnmountCallback> = 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: UnmountCallback): () => void {
-  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(): void {
-  // 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(): number {
-  return unmountCallbacks.size
-}
-
-/**
- * Reset unmount state - for testing purposes
- * 
- * @internal
- */
-export function resetUnmountState(): void {
-  unmountCallbacks.clear()
-}
-

package/core/plugins/index.ts

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

package/core/plugins/registry.ts

@@ -1,81 +0,0 @@
-/**
- * Zenith Plugin Registry
- * 
- * Manages plugin registration and initialization
- */
-
-import type { ZenithPlugin, PluginContext, ContentItem } from '../config/types';
-
-/**
- * Plugin registry for managing Zenith plugins
- */
-export class PluginRegistry {
-    private plugins = new Map<string, ZenithPlugin>();
-
-    /**
-     * Register a plugin
-     */
-    register(plugin: ZenithPlugin): void {
-        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: string): ZenithPlugin | undefined {
-        return this.plugins.get(name);
-    }
-
-    /**
-     * Check if a plugin is registered
-     */
-    has(name: string): boolean {
-        return this.plugins.has(name);
-    }
-
-    /**
-     * Get all registered plugins
-     */
-    all(): ZenithPlugin[] {
-        return Array.from(this.plugins.values());
-    }
-
-    /**
-     * Initialize all plugins with the provided context
-     */
-    async initAll(ctx: PluginContext): Promise<void> {
-        for (const plugin of this.plugins.values()) {
-            try {
-                await plugin.setup(ctx);
-                console.log(`[Zenith] Plugin "${plugin.name}" initialized`);
-            } catch (error: unknown) {
-                const message = error instanceof Error ? error.message : String(error);
-                console.error(`[Zenith] Failed to initialize plugin "${plugin.name}":`, message);
-            }
-        }
-    }
-
-    /**
-     * Clear all registered plugins
-     */
-    clear(): void {
-        this.plugins.clear();
-    }
-}
-
-/**
- * Create a plugin context for initialization
- */
-export function createPluginContext(
-    projectRoot: string,
-    contentSetter: (data: Record<string, ContentItem[]>) => void
-): PluginContext {
-    return {
-        projectRoot,
-        setContentData: contentSetter,
-        options: {}
-    };
-}

package/core/reactivity/index.ts

@@ -1,54 +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, 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'
-
-// 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
-
-// Re-export types
-export type { Signal, Memo, Ref, EffectFn, DisposeFn }
-
-// Internal tracking utilities (for advanced use)
-export {
-  type Subscriber,
-  type TrackingContext,
-  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
-