@tachui/core 0.7.0-alpha1

package/src/plugins/simplified-error-handler.ts

@@ -0,0 +1,372 @@
+/**
+ * Simplified Plugin Error Handler - Week 3 Performance Enhancement
+ * 
+ * Enhanced error handling with performance optimizations:
+ * - Error rate limiting and circuit breaker patterns
+ * - Error aggregation and batch reporting
+ * - Performance metrics for error handling
+ * - Memory-efficient error tracking
+ */
+
+import type { TachUIPlugin } from './simplified-types'
+import { PluginError } from './simplified-types'
+
+interface ErrorMetrics {
+  count: number
+  lastOccurrence: number
+  firstOccurrence: number
+  errorTypes: Map<string, number>
+  resolved: boolean
+}
+
+interface CircuitBreakerState {
+  isOpen: boolean
+  failureCount: number
+  lastFailureTime: number
+  resetTimeout?: number
+}
+
+export class OptimizedPluginErrorHandler {
+  private errorMetrics = new Map<string, ErrorMetrics>()
+  private circuitBreakers = new Map<string, CircuitBreakerState>()
+  private errorQueue: Array<{ type: string; data: any; timestamp: number }> = []
+  private batchTimer?: number
+  
+  // Configuration
+  private maxFailuresBeforeCircuitBreak = 3
+  private circuitBreakerResetTime = 30000 // 30 seconds
+  private errorBatchSize = 10
+  private errorBatchTimeout = 1000 // 1 second
+  private maxErrorHistory = 100
+
+  handleInstallError(plugin: TachUIPlugin, error: Error): void {
+    const errorKey = `install:${plugin.name}`
+    
+    // Update error metrics
+    this.recordError(errorKey, error)
+    
+    // Check circuit breaker
+    if (this.isCircuitOpen(errorKey)) {
+      if (process.env.NODE_ENV === 'development') {
+        console.warn(`🚫 Circuit breaker open for plugin ${plugin.name}, skipping detailed error handling`)
+      }
+      return
+    }
+
+    if (process.env.NODE_ENV === 'development') {
+      console.error(`❌ Failed to install plugin ${plugin.name}:`, error)
+    }
+    
+    // Simple fallback strategies with performance considerations
+    if (error instanceof PluginError) {
+      this.recordErrorType(errorKey, `plugin-error-${error.code}`)
+      if (process.env.NODE_ENV === 'development') {
+        console.warn(`Plugin ${plugin.name} installation failed with code: ${error.code}`)
+      }
+    }
+    
+    if (error.message.includes('dependencies')) {
+      this.recordErrorType(errorKey, 'dependency-error')
+      if (process.env.NODE_ENV === 'development') {
+        console.warn(`Plugin ${plugin.name} has unmet dependencies`)
+      }
+    }
+    
+    // Queue error for batch emission
+    this.queueError('plugin-install-failed', { plugin: { name: plugin.name, version: plugin.version }, error: error.message })
+  }
+
+  handleRuntimeError(pluginName: string, error: Error): void {
+    const errorKey = `runtime:${pluginName}`
+    
+    // Update error metrics
+    this.recordError(errorKey, error)
+    
+    // Check circuit breaker
+    if (this.isCircuitOpen(errorKey)) {
+      return
+    }
+
+    if (process.env.NODE_ENV === 'development') {
+      console.error(`❌ Runtime error in plugin ${pluginName}:`, error)
+    }
+    
+    // Simple recovery - log error and continue
+    if (error instanceof PluginError && error.code === 'CRITICAL') {
+      this.recordErrorType(errorKey, 'critical-error')
+      if (process.env.NODE_ENV === 'development') {
+        console.warn(`Plugin ${pluginName} encountered a critical error`)
+      }
+      this.queueError('plugin-critical-error', { pluginName, error: error.message })
+    } else {
+      this.recordErrorType(errorKey, 'runtime-error')
+      this.queueError('plugin-runtime-error', { pluginName, error: error.message })
+    }
+  }
+
+  handleUninstallError(pluginName: string, error: Error): void {
+    const errorKey = `uninstall:${pluginName}`
+    
+    // Update error metrics
+    this.recordError(errorKey, error)
+
+    if (process.env.NODE_ENV === 'development') {
+      console.error(`❌ Failed to uninstall plugin ${pluginName}:`, error)
+      console.warn(`Plugin ${pluginName} may not have cleaned up properly`)
+    }
+    
+    this.queueError('plugin-uninstall-error', { pluginName, error: error.message })
+  }
+
+  private recordError(errorKey: string, _error: Error): void {
+    const now = performance.now()
+    
+    if (!this.errorMetrics.has(errorKey)) {
+      this.errorMetrics.set(errorKey, {
+        count: 0,
+        lastOccurrence: now,
+        firstOccurrence: now,
+        errorTypes: new Map(),
+        resolved: false
+      })
+    }
+    
+    const metrics = this.errorMetrics.get(errorKey)!
+    metrics.count++
+    metrics.lastOccurrence = now
+    metrics.resolved = false
+    
+    // Update circuit breaker
+    this.updateCircuitBreaker(errorKey)
+  }
+
+  private recordErrorType(errorKey: string, errorType: string): void {
+    const metrics = this.errorMetrics.get(errorKey)
+    if (metrics) {
+      const currentCount = metrics.errorTypes.get(errorType) || 0
+      metrics.errorTypes.set(errorType, currentCount + 1)
+    }
+  }
+
+  private updateCircuitBreaker(errorKey: string): void {
+    if (!this.circuitBreakers.has(errorKey)) {
+      this.circuitBreakers.set(errorKey, {
+        isOpen: false,
+        failureCount: 0,
+        lastFailureTime: 0
+      })
+    }
+    
+    const breaker = this.circuitBreakers.get(errorKey)!
+    breaker.failureCount++
+    breaker.lastFailureTime = performance.now()
+    
+    // Open circuit if too many failures
+    if (breaker.failureCount >= this.maxFailuresBeforeCircuitBreak && !breaker.isOpen) {
+      breaker.isOpen = true
+      
+      if (process.env.NODE_ENV === 'development') {
+        console.warn(`🚫 Circuit breaker opened for ${errorKey} after ${breaker.failureCount} failures`)
+      }
+      
+      // Schedule circuit reset
+      breaker.resetTimeout = window.setTimeout(() => {
+        this.resetCircuitBreaker(errorKey)
+      }, this.circuitBreakerResetTime)
+    }
+  }
+
+  private isCircuitOpen(errorKey: string): boolean {
+    const breaker = this.circuitBreakers.get(errorKey)
+    return breaker ? breaker.isOpen : false
+  }
+
+  private resetCircuitBreaker(errorKey: string): void {
+    const breaker = this.circuitBreakers.get(errorKey)
+    if (breaker) {
+      breaker.isOpen = false
+      breaker.failureCount = 0
+      
+      if (breaker.resetTimeout) {
+        clearTimeout(breaker.resetTimeout)
+        breaker.resetTimeout = undefined
+      }
+      
+      if (process.env.NODE_ENV === 'development') {
+        console.log(`🔄 Circuit breaker reset for ${errorKey}`)
+      }
+    }
+  }
+
+  private queueError(type: string, data: any): void {
+    // Add to queue with memory management
+    this.errorQueue.push({
+      type,
+      data,
+      timestamp: performance.now()
+    })
+    
+    // Limit queue size
+    if (this.errorQueue.length > this.maxErrorHistory) {
+      this.errorQueue = this.errorQueue.slice(-this.maxErrorHistory)
+    }
+    
+    // Batch process errors
+    if (this.errorQueue.length >= this.errorBatchSize) {
+      this.flushErrorQueue()
+    } else if (!this.batchTimer) {
+      this.batchTimer = window.setTimeout(() => {
+        this.flushErrorQueue()
+      }, this.errorBatchTimeout)
+    }
+  }
+
+  private flushErrorQueue(): void {
+    if (this.errorQueue.length === 0) return
+    
+    // Process batched errors
+    const errors = [...this.errorQueue]
+    this.errorQueue = []
+    
+    if (this.batchTimer) {
+      clearTimeout(this.batchTimer)
+      this.batchTimer = undefined
+    }
+    
+    // Emit batched errors
+    for (const error of errors) {
+      this.emitError(error.type, error.data)
+    }
+    
+    if (process.env.NODE_ENV === 'development' && errors.length > 1) {
+      console.log(`📦 Processed ${errors.length} batched errors`)
+    }
+  }
+
+  private emitError(type: string, data: any): void {
+    // Simple event emission for application error handling
+    if (typeof window !== 'undefined') {
+      window.dispatchEvent(new CustomEvent(`tachui:${type}`, { detail: data }))
+    } else if (typeof process !== 'undefined' && process.emit) {
+      process.emit(`tachui:${type}` as any, data)
+    }
+  }
+
+  // Performance monitoring methods
+  
+  getErrorMetrics(errorKey?: string): ErrorMetrics | Map<string, ErrorMetrics> {
+    if (errorKey) {
+      return this.errorMetrics.get(errorKey) || {
+        count: 0,
+        lastOccurrence: 0,
+        firstOccurrence: 0,
+        errorTypes: new Map(),
+        resolved: true
+      }
+    }
+    return new Map(this.errorMetrics)
+  }
+
+  getCircuitBreakerStatus(errorKey?: string): CircuitBreakerState | Map<string, CircuitBreakerState> {
+    if (errorKey) {
+      return this.circuitBreakers.get(errorKey) || {
+        isOpen: false,
+        failureCount: 0,
+        lastFailureTime: 0
+      }
+    }
+    return new Map(this.circuitBreakers)
+  }
+
+  getPerformanceStats() {
+    const allErrors = Array.from(this.errorMetrics.entries())
+    const totalErrors = allErrors.reduce((sum, [, metrics]) => sum + metrics.count, 0)
+    const activeCircuits = Array.from(this.circuitBreakers.values()).filter(cb => cb.isOpen).length
+    
+    const errorsByType = new Map<string, number>()
+    for (const [, metrics] of allErrors) {
+      for (const [type, count] of metrics.errorTypes) {
+        errorsByType.set(type, (errorsByType.get(type) || 0) + count)
+      }
+    }
+    
+    return {
+      totalErrors,
+      uniqueErrorKeys: this.errorMetrics.size,
+      activeCircuitBreakers: activeCircuits,
+      queuedErrors: this.errorQueue.length,
+      errorsByType: Object.fromEntries(errorsByType),
+      memoryUsage: {
+        errorMetrics: this.errorMetrics.size,
+        circuitBreakers: this.circuitBreakers.size,
+        queuedErrors: this.errorQueue.length,
+        estimatedMemoryKB: (this.errorMetrics.size * 2) + (this.circuitBreakers.size * 1) + (this.errorQueue.length * 0.5)
+      }
+    }
+  }
+
+  markErrorResolved(errorKey: string): void {
+    const metrics = this.errorMetrics.get(errorKey)
+    if (metrics) {
+      metrics.resolved = true
+      
+      // Reset circuit breaker if error is resolved
+      this.resetCircuitBreaker(errorKey)
+    }
+  }
+
+  clearErrorHistory(errorKey?: string): void {
+    if (errorKey) {
+      this.errorMetrics.delete(errorKey)
+      this.circuitBreakers.delete(errorKey)
+    } else {
+      this.errorMetrics.clear()
+      this.circuitBreakers.clear()
+      this.errorQueue = []
+      
+      if (this.batchTimer) {
+        clearTimeout(this.batchTimer)
+        this.batchTimer = undefined
+      }
+    }
+  }
+}
+
+// Global error handler instance
+export const globalPluginErrorHandler = new OptimizedPluginErrorHandler()
+
+// Maintain backward compatibility alias
+export const SimplifiedPluginErrorHandler = OptimizedPluginErrorHandler
+
+/**
+ * Simple error recovery utilities
+ */
+export const ErrorRecoveryUtils = {
+  /**
+   * Safely execute plugin operation with error handling
+   */
+  async safeExecute<T>(
+    pluginName: string,
+    operation: string,
+    fn: () => Promise<T> | T
+  ): Promise<T | undefined> {
+    try {
+      return await fn()
+    } catch (error) {
+      console.error(`❌ [${pluginName}] ${operation} failed:`, error)
+      globalPluginErrorHandler.handleRuntimeError(pluginName, error as Error)
+      return undefined
+    }
+  },
+
+  /**
+   * Create an error boundary for plugin operations
+   */
+  createErrorBoundary(pluginName: string) {
+    return {
+      async exec<T>(fn: () => Promise<T> | T): Promise<T | undefined> {
+        return ErrorRecoveryUtils.safeExecute(pluginName, 'operation', fn)
+      }
+    }
+  }
+}

package/src/plugins/simplified-index.ts

@@ -0,0 +1,61 @@
+/**
+ * Simplified Plugin System - Phase 1 Implementation
+ * 
+ * Main exports for the streamlined plugin system.
+ * Removes over-engineered security, performance monitoring, and complex preloading.
+ */
+
+// Core simplified plugin system
+export { SimplifiedPluginManager } from './simplified-plugin-manager'
+export { SimplifiedComponentRegistry } from './simplified-component-registry'
+export { 
+  SimplifiedTachUIInstance,
+  globalTachUIInstance,
+  installPlugin,
+  registerComponent,
+  registerService
+} from './simplified-tachui-instance'
+
+// Simplified types
+export type {
+  TachUIPlugin,
+  TachUIInstance,
+  ComponentRegistrationOptions,
+  ServiceRegistration
+} from './simplified-types'
+export { PluginError } from './simplified-types'
+
+// Component registration types
+export type { ComponentRegistration } from './simplified-component-registry'
+
+// Essential utilities
+export {
+  validateSemver,
+  compareSemver,
+  validatePluginName,
+  normalizePluginName,
+  PluginDevUtils
+} from './simplified-utils'
+
+// Optimized lazy loading (Week 3 performance enhancement)
+export { 
+  OptimizedLazyPluginLoader,
+  createLazyPlugin,
+  // Backward compatibility alias
+  OptimizedLazyPluginLoader as SimplifiedLazyPluginLoader
+} from './simplified-lazy-loader'
+
+// Optimized error handling (Week 3 performance enhancement)
+export {
+  OptimizedPluginErrorHandler,
+  SimplifiedPluginErrorHandler,
+  globalPluginErrorHandler,
+  ErrorRecoveryUtils
+} from './simplified-error-handler'
+
+// Legacy adapter for backward compatibility
+export { 
+  createLegacyPluginAdapter,
+  isLegacyPlugin,
+  adaptPlugin
+} from './legacy-adapter'

package/src/plugins/simplified-lazy-loader.ts

@@ -0,0 +1,242 @@
+/**
+ * Optimized Lazy Plugin Loader - Week 3 Performance Enhancement
+ * 
+ * Enhanced dynamic plugin loading with performance optimizations:
+ * - Load caching and deduplication
+ * - Performance metrics tracking
+ * - Retry logic with exponential backoff
+ * - Memory-efficient loading
+ */
+
+import type { TachUIPlugin } from './simplified-types'
+import { PluginError } from './simplified-types'
+
+interface LoadMetrics {
+  startTime: number
+  endTime?: number
+  duration?: number
+  attempts: number
+  success: boolean
+  cacheHit: boolean
+}
+
+/**
+ * Performance-optimized lazy plugin loader
+ */
+export class OptimizedLazyPluginLoader {
+  private loadPromises = new Map<string, Promise<TachUIPlugin>>()
+  private loadedPlugins = new Map<string, TachUIPlugin>()
+  private loadMetrics = new Map<string, LoadMetrics>()
+  private maxRetries = 3
+  private baseRetryDelay = 100 // ms
+
+  async loadPlugin(pluginName: string): Promise<TachUIPlugin> {
+    // Check cache first for already loaded plugins
+    if (this.loadedPlugins.has(pluginName)) {
+      this.recordCacheHit(pluginName)
+      return this.loadedPlugins.get(pluginName)!
+    }
+
+    // Check if loading is in progress
+    if (this.loadPromises.has(pluginName)) {
+      return this.loadPromises.get(pluginName)!
+    }
+
+    // Start new load with metrics tracking
+    const loadPromise = this.doLoadPluginWithRetry(pluginName)
+    this.loadPromises.set(pluginName, loadPromise)
+
+    try {
+      const plugin = await loadPromise
+      // Cache the loaded plugin for future requests
+      this.loadedPlugins.set(pluginName, plugin)
+      return plugin
+    } catch (error) {
+      // Remove failed promise from cache
+      this.loadPromises.delete(pluginName)
+      throw error
+    }
+  }
+
+  private async doLoadPluginWithRetry(pluginName: string, attempt: number = 1): Promise<TachUIPlugin> {
+    const metrics: LoadMetrics = {
+      startTime: performance.now(),
+      attempts: attempt,
+      success: false,
+      cacheHit: false
+    }
+    this.loadMetrics.set(pluginName, metrics)
+
+    try {
+      const plugin = await this.doLoadPlugin(pluginName)
+      
+      // Record successful load metrics
+      metrics.endTime = performance.now()
+      metrics.duration = metrics.endTime - metrics.startTime
+      metrics.success = true
+      
+      if (process.env.NODE_ENV === 'development') {
+        console.log(`🚀 Plugin "${pluginName}" loaded in ${metrics.duration.toFixed(2)}ms (attempt ${attempt})`)
+      }
+
+      return plugin
+    } catch (error) {
+      // Record failed attempt
+      metrics.endTime = performance.now()
+      metrics.duration = metrics.endTime - metrics.startTime
+
+      if (attempt < this.maxRetries) {
+        // Exponential backoff retry
+        const delay = this.baseRetryDelay * Math.pow(2, attempt - 1)
+        
+        if (process.env.NODE_ENV === 'development') {
+          console.warn(`⚠️ Plugin "${pluginName}" load failed (attempt ${attempt}), retrying in ${delay}ms...`)
+        }
+        
+        await this.delay(delay)
+        return this.doLoadPluginWithRetry(pluginName, attempt + 1)
+      }
+
+      // All retries exhausted
+      if (process.env.NODE_ENV === 'development') {
+        console.error(`❌ Plugin "${pluginName}" failed to load after ${attempt} attempts`)
+      }
+      
+      throw new PluginError(`Failed to load plugin "${pluginName}" after ${attempt} attempts: ${error}`)
+    }
+  }
+
+  private async doLoadPlugin(pluginName: string): Promise<TachUIPlugin> {
+    try {
+      // Optimized dynamic import - let bundler handle code splitting
+      const module = await import(/* webpackChunkName: "plugin-[request]" */ pluginName)
+      const plugin = module.default || module
+      
+      if (!plugin || typeof plugin !== 'object') {
+        throw new PluginError(`Plugin "${pluginName}" must export a plugin object`)
+      }
+      
+      if (!plugin.name || !plugin.version || typeof plugin.install !== 'function') {
+        throw new PluginError(`Plugin "${pluginName}" must have name, version, and install method`)
+      }
+      
+      return plugin as TachUIPlugin
+    } catch (error) {
+      throw new PluginError(`Dynamic import failed for "${pluginName}": ${error}`)
+    }
+  }
+
+  private recordCacheHit(pluginName: string): void {
+    if (this.loadMetrics.has(pluginName)) {
+      const metrics = this.loadMetrics.get(pluginName)!
+      metrics.cacheHit = true
+    }
+
+    if (process.env.NODE_ENV === 'development') {
+      console.log(`💾 Plugin "${pluginName}" served from cache`)
+    }
+  }
+
+  private delay(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms))
+  }
+
+  // Performance monitoring methods
+  
+  isLoading(pluginName: string): boolean {
+    return this.loadPromises.has(pluginName) && !this.loadedPlugins.has(pluginName)
+  }
+
+  isLoaded(pluginName: string): boolean {
+    return this.loadedPlugins.has(pluginName)
+  }
+
+  getLoadMetrics(pluginName: string): LoadMetrics | undefined {
+    return this.loadMetrics.get(pluginName)
+  }
+
+  getAllMetrics(): Array<{ plugin: string; metrics: LoadMetrics }> {
+    return Array.from(this.loadMetrics.entries()).map(([plugin, metrics]) => ({
+      plugin,
+      metrics
+    }))
+  }
+
+  getPerformanceStats() {
+    const allMetrics = this.getAllMetrics()
+    const successful = allMetrics.filter(m => m.metrics.success)
+    const failed = allMetrics.filter(m => !m.metrics.success)
+    
+    const totalLoadTime = successful.reduce((sum, m) => sum + (m.metrics.duration || 0), 0)
+    const avgLoadTime = successful.length > 0 ? totalLoadTime / successful.length : 0
+    
+    return {
+      totalPlugins: allMetrics.length,
+      successful: successful.length,
+      failed: failed.length,
+      cached: this.loadedPlugins.size,
+      averageLoadTime: avgLoadTime,
+      totalLoadTime,
+      cacheHitRate: successful.length > 0 ? 
+        successful.filter(m => m.metrics.cacheHit).length / successful.length : 0
+    }
+  }
+
+  clearCache(pluginName?: string): void {
+    if (pluginName) {
+      this.loadPromises.delete(pluginName)
+      this.loadedPlugins.delete(pluginName)
+      this.loadMetrics.delete(pluginName)
+    } else {
+      this.loadPromises.clear()
+      this.loadedPlugins.clear()
+      this.loadMetrics.clear()
+    }
+  }
+
+  // Memory management
+  
+  unloadPlugin(pluginName: string): void {
+    this.loadPromises.delete(pluginName)
+    this.loadedPlugins.delete(pluginName)
+    
+    if (process.env.NODE_ENV === 'development') {
+      console.log(`🗑️ Plugin "${pluginName}" unloaded from memory`)
+    }
+  }
+
+  getMemoryUsage() {
+    return {
+      loadedPlugins: this.loadedPlugins.size,
+      pendingLoads: this.loadPromises.size,
+      metricsEntries: this.loadMetrics.size,
+      estimatedMemoryKB: (this.loadedPlugins.size * 5) + (this.loadMetrics.size * 1) // rough estimate
+    }
+  }
+}
+
+/**
+ * Create a lazy plugin loader from a dynamic import function
+ */
+export function createLazyPlugin(
+  importFn: () => Promise<{ default: TachUIPlugin } | TachUIPlugin>
+): () => Promise<TachUIPlugin> {
+  return async () => {
+    try {
+      const module = await importFn()
+      const plugin = 'default' in module ? module.default : module
+      
+      if (!plugin || typeof plugin !== 'object') {
+        throw new PluginError('Plugin module must export a plugin object')
+      }
+      
+      if (!plugin.name || !plugin.version || typeof plugin.install !== 'function') {
+        throw new PluginError('Plugin must have name, version, and install method')
+      }
+      
+      return plugin as TachUIPlugin
+    } catch (error) {
+      throw new PluginError(`Failed to load plugin: ${error}`)
+    }
+  }
+}