@tachui/core 0.7.0-alpha1 → 0.7.1-alpha

package/src/reactive/unified-scheduler.ts

@@ -1,357 +0,0 @@
-/**
- * Unified Reactive Scheduler v2.0
- *
- * Eliminates duplicate update queues and provides enterprise-grade
- * reactive system with proper error handling and memory management.
- *
- * Replaces the existing duplicated queue systems in signal.ts and computed.ts
- */
-
-export enum UpdatePriority {
-  Immediate = 0, // Synchronous updates (rare)
-  High = 1, // User interaction responses
-  Normal = 2, // Regular updates
-  Low = 3, // Background updates
-  Idle = 4, // Idle time updates
-}
-
-export interface ReactiveNode {
-  readonly id: number
-  readonly type: 'signal' | 'computed' | 'effect'
-  readonly priority: UpdatePriority
-  notify(): void
-  cleanup(): void
-}
-
-export class ReactiveError extends Error {
-  constructor(
-    message: string,
-    public readonly cause: any,
-    public readonly node: ReactiveNode
-  ) {
-    super(message)
-    this.name = 'ReactiveError'
-  }
-}
-
-export interface ReactivePerformanceMetrics {
-  totalNodes: number
-  updateCycles: number
-  averageUpdateTime: number
-  memoryUsage: number
-  errorCount: number
-}
-
-/**
- * Unified reactive scheduler that replaces all duplicate queue systems
- */
-export class ReactiveScheduler {
-  private static instance: ReactiveScheduler | null = null
-  private updateQueues = new Map<UpdatePriority, Set<ReactiveNode>>()
-  private isFlushPending = false
-  private isDestroyed = false
-
-  // Error handling
-  private errorHandlers = new Set<(error: ReactiveError) => void>()
-  private readonly maxRetries = 3
-
-  // Performance tracking
-  private totalUpdateCycles = 0
-  private totalUpdateTime = 0
-  private errorCount = 0
-  private nodeRegistry = new WeakSet<ReactiveNode>()
-
-  private constructor() {
-    // Initialize priority queues
-    for (const priority of Object.values(UpdatePriority)) {
-      if (typeof priority === 'number') {
-        this.updateQueues.set(priority, new Set())
-      }
-    }
-  }
-
-  static getInstance(): ReactiveScheduler {
-    if (!ReactiveScheduler.instance) {
-      ReactiveScheduler.instance = new ReactiveScheduler()
-    }
-    return ReactiveScheduler.instance
-  }
-
-  /**
-   * Schedule reactive node for update
-   */
-  schedule(node: ReactiveNode): void {
-    if (this.isDestroyed) return
-
-    this.nodeRegistry.add(node)
-    const queue = this.getQueue(node.priority)
-    queue.add(node)
-
-    if (!this.isFlushPending) {
-      this.isFlushPending = true
-      this.scheduleFlush(node.priority)
-    }
-  }
-
-  /**
-   * Process all queued updates by priority
-   */
-  private async flush(): Promise<void> {
-    if (this.isDestroyed) return
-
-    this.isFlushPending = false
-    const startTime = performance.now()
-
-    try {
-      // Process queues in priority order
-      for (const priority of [
-        UpdatePriority.Immediate,
-        UpdatePriority.High,
-        UpdatePriority.Normal,
-        UpdatePriority.Low,
-        UpdatePriority.Idle,
-      ]) {
-        const queue = this.updateQueues.get(priority)
-        if (!queue || queue.size === 0) continue
-
-        const nodesToUpdate = Array.from(queue)
-        queue.clear()
-
-        // Process nodes with error handling
-        for (const node of nodesToUpdate) {
-          try {
-            await this.updateNodeWithRetry(node)
-          } catch (error) {
-            this.handleReactiveError(
-              new ReactiveError(`Failed to update ${node.type} node ${node.id}`, error, node)
-            )
-          }
-        }
-
-        // Allow higher priority updates to interrupt
-        if (this.hasHigherPriorityWork(priority)) {
-          return this.flush()
-        }
-      }
-
-      this.totalUpdateCycles++
-    } finally {
-      const endTime = performance.now()
-      this.totalUpdateTime += endTime - startTime
-    }
-  }
-
-  /**
-   * Update node with retry logic
-   */
-  private async updateNodeWithRetry(node: ReactiveNode, attempt = 1): Promise<void> {
-    try {
-      node.notify()
-    } catch (error) {
-      if (attempt < this.maxRetries) {
-        console.warn(`Reactive update failed, retrying (${attempt}/${this.maxRetries})`)
-        // Exponential backoff
-        await new Promise((resolve) => setTimeout(resolve, attempt * 10))
-        return this.updateNodeWithRetry(node, attempt + 1)
-      } else {
-        throw error
-      }
-    }
-  }
-
-  /**
-   * Schedule flush based on priority
-   */
-  private scheduleFlush(priority: UpdatePriority): void {
-    switch (priority) {
-      case UpdatePriority.Immediate:
-        // Synchronous update (use sparingly)
-        void this.flush()
-        break
-      case UpdatePriority.High:
-        // Next microtask for user interactions
-        queueMicrotask(() => this.flush())
-        break
-      case UpdatePriority.Normal:
-        // RequestAnimationFrame for normal updates
-        if (typeof requestAnimationFrame !== 'undefined') {
-          requestAnimationFrame(() => this.flush())
-        } else {
-          queueMicrotask(() => this.flush())
-        }
-        break
-      case UpdatePriority.Low:
-      case UpdatePriority.Idle:
-        // Idle callback for low priority updates
-        if (typeof requestIdleCallback !== 'undefined') {
-          requestIdleCallback(() => this.flush(), { timeout: 1000 })
-        } else {
-          setTimeout(() => this.flush(), 50)
-        }
-        break
-    }
-  }
-
-  /**
-   * Check if there's higher priority work waiting
-   */
-  private hasHigherPriorityWork(currentPriority: UpdatePriority): boolean {
-    for (let priority = UpdatePriority.Immediate; priority < currentPriority; priority++) {
-      const queue = this.updateQueues.get(priority)
-      if (queue && queue.size > 0) {
-        return true
-      }
-    }
-    return false
-  }
-
-  /**
-   * Get queue for priority level
-   */
-  private getQueue(priority: UpdatePriority): Set<ReactiveNode> {
-    const queue = this.updateQueues.get(priority)
-    if (!queue) {
-      throw new Error(`Invalid priority level: ${priority}`)
-    }
-    return queue
-  }
-
-  /**
-   * Register error handler
-   */
-  onError(handler: (error: ReactiveError) => void): () => void {
-    this.errorHandlers.add(handler)
-    return () => this.errorHandlers.delete(handler)
-  }
-
-  /**
-   * Handle reactive errors with recovery
-   */
-  private handleReactiveError(error: ReactiveError): void {
-    this.errorCount++
-
-    // Notify error handlers
-    let handled = false
-    for (const handler of this.errorHandlers) {
-      try {
-        handler(error)
-        handled = true
-      } catch (handlerError) {
-        console.error('Error handler threw error:', handlerError)
-      }
-    }
-
-    // If no handlers or all handlers failed, log and continue
-    if (!handled) {
-      console.error('Unhandled reactive error:', error)
-      // In development, we might want to throw to surface errors
-      if (process.env.NODE_ENV === 'development') {
-        throw error
-      }
-    }
-  }
-
-  /**
-   * Get performance metrics
-   */
-  getPerformanceMetrics(): ReactivePerformanceMetrics {
-    let totalNodes = 0
-    for (const queue of this.updateQueues.values()) {
-      totalNodes += queue.size
-    }
-
-    return {
-      totalNodes,
-      updateCycles: this.totalUpdateCycles,
-      averageUpdateTime:
-        this.totalUpdateCycles > 0 ? this.totalUpdateTime / this.totalUpdateCycles : 0,
-      memoryUsage: this.estimateMemoryUsage(),
-      errorCount: this.errorCount,
-    }
-  }
-
-  /**
-   * Estimate memory usage (rough approximation)
-   */
-  private estimateMemoryUsage(): number {
-    let usage = 0
-    for (const queue of this.updateQueues.values()) {
-      usage += queue.size * 50 // Rough estimate per node
-    }
-    usage += this.errorHandlers.size * 100 // Rough estimate per handler
-    return usage
-  }
-
-  /**
-   * Check if node is scheduled
-   */
-  hasNode(node: ReactiveNode): boolean {
-    for (const queue of this.updateQueues.values()) {
-      if (queue.has(node)) {
-        return true
-      }
-    }
-    return false
-  }
-
-  /**
-   * Flush all pending updates synchronously
-   */
-  flushSync(): void {
-    if (this.isFlushPending) {
-      this.isFlushPending = false
-      void this.flush()
-    }
-  }
-
-  /**
-   * Clear all pending updates
-   */
-  clearPending(): void {
-    for (const queue of this.updateQueues.values()) {
-      queue.clear()
-    }
-    this.isFlushPending = false
-  }
-
-  /**
-   * Cleanup all reactive nodes and destroy scheduler
-   */
-  destroy(): void {
-    this.isDestroyed = true
-
-    // Cleanup all queued nodes
-    for (const queue of this.updateQueues.values()) {
-      for (const node of queue) {
-        try {
-          node.cleanup()
-        } catch (error) {
-          console.error('Error cleaning up reactive node:', error)
-        }
-      }
-      queue.clear()
-    }
-
-    this.updateQueues.clear()
-    this.errorHandlers.clear()
-    ReactiveScheduler.instance = null
-  }
-
-  /**
-   * Get debug information
-   */
-  getDebugInfo(): object {
-    const queueInfo: Record<string, number> = {}
-    for (const [priority, queue] of this.updateQueues) {
-      queueInfo[UpdatePriority[priority]] = queue.size
-    }
-
-    return {
-      isFlushPending: this.isFlushPending,
-      isDestroyed: this.isDestroyed,
-      queueSizes: queueInfo,
-      errorHandlerCount: this.errorHandlers.size,
-      performance: this.getPerformanceMetrics(),
-    }
-  }
-}

package/src/runtime/component-context.ts

@@ -1,343 +0,0 @@
-/**
- * Component Context System
- *
- * Provides proper context injection for component state management,
- * environment objects, and dependency injection. This fixes the broken
- * @State, @Binding, and @EnvironmentObject implementations.
- */
-
-import { getCurrentOwner } from '../reactive/context'
-import type { ComponentContext, ComponentInstance, ComponentProps } from './types'
-
-/**
- * Symbol for component context storage in reactive owner
- */
-export const ComponentContextSymbol = Symbol('TachUI.ComponentContext')
-
-/**
- * Symbol for environment object storage
- */
-export const EnvironmentSymbol = Symbol('TachUI.Environment')
-
-/**
- * Current component context (set during component render)
- */
-let currentComponentContext: ComponentContext | null = null
-
-
-/**
- * Component context implementation
- */
-class ComponentContextImpl implements ComponentContext {
-  readonly id: string
-  readonly parent?: ComponentContext
-  readonly providers = new Map<symbol, any>()
-  readonly consumers = new Set<symbol>()
-  readonly cleanup = new Set<() => void>()
-
-  // State management
-  private stateStore = new Map<string, any>()
-  private bindingStore = new Map<string, any>()
-
-  // Performance tracking
-  private createdAt = Date.now()
-  private updateCount = 0
-
-  constructor(id: string, parent?: ComponentContext) {
-    this.id = id
-    this.parent = parent
-  }
-
-  /**
-   * Store state value for a property
-   */
-  setState<T = any>(propertyName: string, value: T): void {
-    this.stateStore.set(propertyName, value)
-    this.updateCount++
-  }
-
-  /**
-   * Get state value for a property
-   */
-  getState<T = any>(propertyName: string): T | undefined {
-    return this.stateStore.get(propertyName)
-  }
-
-  /**
-   * Check if state exists for a property
-   */
-  hasState(propertyName: string): boolean {
-    return this.stateStore.has(propertyName)
-  }
-
-  /**
-   * Store binding for a property
-   */
-  setBinding(propertyName: string, binding: any): void {
-    this.bindingStore.set(propertyName, binding)
-  }
-
-  /**
-   * Get binding for a property
-   */
-  getBinding(propertyName: string): any {
-    return this.bindingStore.get(propertyName)
-  }
-
-  /**
-   * Provide a value for dependency injection
-   */
-  provide<T>(symbol: symbol, value: T): void {
-    this.providers.set(symbol, value)
-  }
-
-  /**
-   * Consume a value from dependency injection hierarchy
-   */
-  consume<T>(symbol: symbol): T | undefined {
-    this.consumers.add(symbol)
-
-    // Check local providers first
-    if (this.providers.has(symbol)) {
-      return this.providers.get(symbol)
-    }
-
-    // Walk up parent chain
-    let context = this.parent
-    while (context) {
-      if (context.providers.has(symbol)) {
-        return context.providers.get(symbol)
-      }
-      context = context.parent
-    }
-
-    return undefined
-  }
-
-  /**
-   * Register cleanup function
-   */
-  onCleanup(fn: () => void): void {
-    this.cleanup.add(fn)
-  }
-
-  /**
-   * Dispose of context and run cleanup
-   */
-  dispose(): void {
-    // Run cleanup functions
-    for (const cleanup of this.cleanup) {
-      try {
-        cleanup()
-      } catch (error) {
-        console.error(`Error in component context cleanup (${this.id}):`, error)
-      }
-    }
-    this.cleanup.clear()
-
-    // Clear stores
-    this.stateStore.clear()
-    this.bindingStore.clear()
-    this.providers.clear()
-    this.consumers.clear()
-  }
-
-  /**
-   * Get performance metrics
-   */
-  getMetrics() {
-    return {
-      id: this.id,
-      createdAt: this.createdAt,
-      updateCount: this.updateCount,
-      stateCount: this.stateStore.size,
-      bindingCount: this.bindingStore.size,
-      providerCount: this.providers.size,
-      consumerCount: this.consumers.size,
-    }
-  }
-}
-
-/**
- * Create a new component context
- */
-export function createComponentContext(
-  componentId: string,
-  parent?: ComponentContext
-): ComponentContext {
-  return new ComponentContextImpl(componentId, parent)
-}
-
-/**
- * Get the current component context
- */
-export function getCurrentComponentContext(): ComponentContext {
-  // ALWAYS check global context first for immediate availability
-  // This is more reliable when reactive context gets lost
-  if (currentComponentContext) {
-    return currentComponentContext
-  }
-  
-  // Then check reactive owner chain as fallback
-  let owner = getCurrentOwner()
-  
-  while (owner) {
-    if (owner.context.has(ComponentContextSymbol)) {
-      const context = owner.context.get(ComponentContextSymbol) as ComponentContext
-      return context
-    }
-    owner = owner.parent
-  }
-
-  throw new Error(
-    '@State can only be used within a component context. ' +
-      'Make sure you are using @State inside a TachUI component render function.'
-  )
-}
-
-/**
- * Set the current component context (used during rendering)
- */
-export function setCurrentComponentContext(context: ComponentContext | null): void {
-  currentComponentContext = context
-}
-
-/**
- * Run a function with a specific component context
- */
-export function runWithComponentContext<T>(context: ComponentContext, fn: () => T): T {
-  const prevContext = currentComponentContext
-  currentComponentContext = context
-
-  // CRITICAL: Always set in reactive owner if available
-  // This is the primary mechanism for context storage
-  const owner = getCurrentOwner()
-  if (owner) {
-    owner.context.set(ComponentContextSymbol, context)
-  }
-
-  try {
-    const result = fn()
-    return result
-  } finally {
-    // IMPORTANT: Only restore context if we're still the active context
-    // Don't clear it if there was an error or if it was changed by something else
-    if (currentComponentContext === context) {
-      currentComponentContext = prevContext
-    }
-
-    // Clean up reactive owner context
-    if (owner) {
-      if (prevContext) {
-        owner.context.set(ComponentContextSymbol, prevContext)
-      } else {
-        owner.context.delete(ComponentContextSymbol)
-      }
-    }
-  }
-}
-
-/**
- * Enhanced component wrapper that provides context injection
- */
-export function withComponentContext<P extends ComponentProps>(
-  component: (props: P) => ComponentInstance<P>,
-  contextId?: string
-) {
-  return (props: P): ComponentInstance<P> => {
-    const componentId = contextId || `component-${Math.random().toString(36).substr(2, 9)}`
-
-    // Get parent context if available
-    const parentContext = currentComponentContext || undefined
-
-    // Create component context
-    const context = createComponentContext(componentId, parentContext)
-
-    // Create the component instance with context
-    return runWithComponentContext(context, () => {
-      const instance = component(props)
-
-      // Inject context into instance
-      instance.context = context
-
-      // Set up cleanup
-      if (!instance.cleanup) {
-        instance.cleanup = []
-      }
-      instance.cleanup.push(() => context.dispose())
-
-      return instance
-    })
-  }
-}
-
-/**
- * Environment object key type
- */
-export interface EnvironmentKey<T> {
-  readonly symbol: symbol
-  readonly defaultValue?: T
-  readonly name: string
-}
-
-/**
- * Create an environment key
- */
-export function createEnvironmentKey<T>(name: string, defaultValue?: T): EnvironmentKey<T> {
-  return {
-    symbol: Symbol(`Environment.${name}`),
-    defaultValue,
-    name,
-  }
-}
-
-/**
- * Provide environment value
- */
-export function provideEnvironmentValue<T>(key: EnvironmentKey<T>, value: T): void {
-  const context = getCurrentComponentContext()
-  context.provide(key.symbol, value)
-}
-
-/**
- * Consume environment value
- */
-export function consumeEnvironmentValue<T>(key: EnvironmentKey<T>): T {
-  const context = getCurrentComponentContext()
-  const value = context.consume<T>(key.symbol)
-
-  if (value !== undefined) {
-    return value
-  }
-
-  if (key.defaultValue !== undefined) {
-    return key.defaultValue
-  }
-
-  throw new Error(
-    `Environment value for '${key.name}' not found. ` +
-      `Make sure to provide this value higher in the component hierarchy.`
-  )
-}
-
-/**
- * Debug utilities
- */
-export const ComponentContextDebug = {
-  getCurrentContext: () => currentComponentContext,
-
-  getContextHierarchy: () => {
-    const hierarchy: ComponentContext[] = []
-    let context: ComponentContext | undefined = currentComponentContext || undefined
-    while (context) {
-      hierarchy.push(context)
-      context = context.parent
-    }
-    return hierarchy
-  },
-
-  getContextMetrics: (context?: ComponentContext) => {
-    const ctx = context || currentComponentContext
-    return ctx ? (ctx as ComponentContextImpl).getMetrics() : null
-  },
-}