@tachui/core 0.7.0-alpha1

package/src/plugins/component-loader-registry.ts

@@ -0,0 +1,371 @@
+/**
+ * Component Loader Registry
+ *
+ * Manages lazy-loaded components at the plugin level, allowing components
+ * to be registered as loaders rather than actual implementations.
+ */
+
+import {
+  type LazyComponentLoader,
+  type LazyComponentOptions,
+  type LazyComponentState,
+  lazy,
+  preloadComponent,
+} from '../runtime/lazy-component'
+import type { ComponentInstance } from '../runtime/types'
+
+// Re-export types for convenience
+export type { LazyComponentLoader, LazyComponentOptions, LazyComponentState }
+
+export interface ComponentLoaderDefinition {
+  /** Component loader function */
+  loader: LazyComponentLoader
+  /** Bundle chunk this component belongs to */
+  chunk?: string
+  /** Plugin that owns this component */
+  plugin: string
+  /** Lazy loading options */
+  options?: LazyComponentOptions
+  /** Component metadata */
+  metadata?: {
+    description?: string
+    version?: string
+    dependencies?: string[]
+    size?: number
+  }
+}
+
+export interface ChunkLoadingStrategy {
+  /** Load entire chunk when any component from it is requested */
+  preloadChunk?: boolean
+  /** Parallel load all components in chunk */
+  parallel?: boolean
+  /** Priority for chunk loading */
+  priority?: 'low' | 'normal' | 'high'
+}
+
+/**
+ * Registry for managing lazy-loaded components
+ */
+export class ComponentLoaderRegistry {
+  private loaders = new Map<string, ComponentLoaderDefinition>()
+  private loadedComponents = new Map<string, any>()
+  private loadingPromises = new Map<string, Promise<any>>()
+  private chunks = new Map<string, Set<string>>()
+  private chunkStrategies = new Map<string, ChunkLoadingStrategy>()
+
+  /**
+   * Register a component loader
+   */
+  registerComponentLoader(name: string, definition: ComponentLoaderDefinition): void {
+    this.loaders.set(name, definition)
+
+    // Track chunk membership
+    if (definition.chunk) {
+      if (!this.chunks.has(definition.chunk)) {
+        this.chunks.set(definition.chunk, new Set())
+      }
+      this.chunks.get(definition.chunk)!.add(name)
+    }
+  }
+
+  /**
+   * Register multiple component loaders from a plugin
+   */
+  registerPluginComponents(
+    plugin: string,
+    components: Record<
+      string,
+      {
+        loader: LazyComponentLoader
+        chunk?: string
+        options?: LazyComponentOptions
+        metadata?: ComponentLoaderDefinition['metadata']
+      }
+    >
+  ): void {
+    for (const [name, config] of Object.entries(components)) {
+      this.registerComponentLoader(name, {
+        ...config,
+        plugin,
+      })
+    }
+  }
+
+  /**
+   * Get a lazy component by name
+   */
+  getLazyComponent(name: string): ((props: any) => ComponentInstance) | null {
+    const definition = this.loaders.get(name)
+    if (!definition) {
+      return null
+    }
+
+    return lazy(definition.loader, definition.options)
+  }
+
+  /**
+   * Load a component immediately (not lazy)
+   */
+  async loadComponent(name: string): Promise<any> {
+    // Return cached component if already loaded
+    if (this.loadedComponents.has(name)) {
+      return this.loadedComponents.get(name)
+    }
+
+    // Return existing loading promise if already loading
+    if (this.loadingPromises.has(name)) {
+      return this.loadingPromises.get(name)
+    }
+
+    const definition = this.loaders.get(name)
+    if (!definition) {
+      throw new Error(`Component '${name}' not found in registry`)
+    }
+
+    // Start loading
+    const loadingPromise = this.loadComponentWithChunkStrategy(name, definition)
+    this.loadingPromises.set(name, loadingPromise)
+
+    try {
+      const component = await loadingPromise
+      this.loadedComponents.set(name, component)
+      this.loadingPromises.delete(name)
+      return component
+    } catch (error) {
+      this.loadingPromises.delete(name)
+      throw error
+    }
+  }
+
+  /**
+   * Load component with chunk-aware strategy
+   */
+  private async loadComponentWithChunkStrategy(
+    name: string,
+    definition: ComponentLoaderDefinition
+  ): Promise<any> {
+    const { chunk } = definition
+
+    if (chunk) {
+      const strategy = this.chunkStrategies.get(chunk)
+
+      if (strategy?.preloadChunk) {
+        // Load entire chunk
+        await this.preloadChunk(chunk, strategy.parallel)
+        return this.loadedComponents.get(name)
+      }
+    }
+
+    // Load single component
+    return preloadComponent(definition.loader)
+  }
+
+  /**
+   * Preload an entire chunk
+   */
+  async preloadChunk(chunkName: string, parallel = false): Promise<void> {
+    const componentNames = this.chunks.get(chunkName)
+    if (!componentNames) {
+      throw new Error(`Chunk '${chunkName}' not found`)
+    }
+
+    const componentsToLoad = Array.from(componentNames).filter(
+      (name) => !this.loadedComponents.has(name) && !this.loadingPromises.has(name)
+    )
+
+    if (componentsToLoad.length === 0) {
+      return // All components already loaded/loading
+    }
+
+    if (parallel) {
+      // Load all components in parallel
+      const loadPromises = componentsToLoad.map((name) => {
+        const definition = this.loaders.get(name)!
+        const promise = preloadComponent(definition.loader)
+        this.loadingPromises.set(name, promise)
+        return promise.then((component) => {
+          this.loadedComponents.set(name, component)
+          this.loadingPromises.delete(name)
+          return component
+        })
+      })
+
+      await Promise.all(loadPromises)
+    } else {
+      // Load components sequentially
+      for (const name of componentsToLoad) {
+        await this.loadComponent(name)
+      }
+    }
+  }
+
+  /**
+   * Configure chunk loading strategy
+   */
+  configureChunkStrategy(chunk: string, strategy: ChunkLoadingStrategy): void {
+    this.chunkStrategies.set(chunk, strategy)
+  }
+
+  /**
+   * Get registry statistics
+   */
+  getStatistics() {
+    const totalComponents = this.loaders.size
+    const loadedComponents = this.loadedComponents.size
+    const loadingComponents = this.loadingPromises.size
+    const totalChunks = this.chunks.size
+
+    const pluginStats = new Map<string, number>()
+    const chunkStats = new Map<string, number>()
+
+    for (const [, definition] of this.loaders) {
+      // Plugin stats
+      const current = pluginStats.get(definition.plugin) || 0
+      pluginStats.set(definition.plugin, current + 1)
+
+      // Chunk stats
+      if (definition.chunk) {
+        const currentChunk = chunkStats.get(definition.chunk) || 0
+        chunkStats.set(definition.chunk, currentChunk + 1)
+      }
+    }
+
+    return {
+      totalComponents,
+      loadedComponents,
+      loadingComponents,
+      totalChunks,
+      loadingPercentage: Math.round((loadedComponents / totalComponents) * 100),
+      pluginStats: Object.fromEntries(pluginStats),
+      chunkStats: Object.fromEntries(chunkStats),
+    }
+  }
+
+  /**
+   * Check if component is registered
+   */
+  hasComponent(name: string): boolean {
+    return this.loaders.has(name)
+  }
+
+  /**
+   * Check if component is loaded
+   */
+  isComponentLoaded(name: string): boolean {
+    return this.loadedComponents.has(name)
+  }
+
+  /**
+   * Check if component is currently loading
+   */
+  isComponentLoading(name: string): boolean {
+    return this.loadingPromises.has(name)
+  }
+
+  /**
+   * Get component metadata
+   */
+  getComponentMetadata(name: string): ComponentLoaderDefinition['metadata'] | null {
+    return this.loaders.get(name)?.metadata || null
+  }
+
+  /**
+   * List all registered components
+   */
+  listComponents(): Array<{
+    name: string
+    plugin: string
+    chunk?: string
+    loaded: boolean
+    loading: boolean
+    metadata?: ComponentLoaderDefinition['metadata']
+  }> {
+    return Array.from(this.loaders.entries()).map(([name, definition]) => ({
+      name,
+      plugin: definition.plugin,
+      chunk: definition.chunk,
+      loaded: this.isComponentLoaded(name),
+      loading: this.isComponentLoading(name),
+      metadata: definition.metadata,
+    }))
+  }
+
+  /**
+   * Clear all loaded components (useful for testing)
+   */
+  clearCache(): void {
+    this.loadedComponents.clear()
+    this.loadingPromises.clear()
+  }
+
+  /**
+   * Unregister a component loader
+   */
+  unregisterComponent(name: string): boolean {
+    const definition = this.loaders.get(name)
+    if (!definition) {
+      return false
+    }
+
+    this.loaders.delete(name)
+    this.loadedComponents.delete(name)
+    this.loadingPromises.delete(name)
+
+    // Remove from chunk
+    if (definition.chunk) {
+      const chunkComponents = this.chunks.get(definition.chunk)
+      if (chunkComponents) {
+        chunkComponents.delete(name)
+        if (chunkComponents.size === 0) {
+          this.chunks.delete(definition.chunk)
+          this.chunkStrategies.delete(definition.chunk)
+        }
+      }
+    }
+
+    return true
+  }
+}
+
+// Global component loader registry instance
+export const globalComponentRegistry = new ComponentLoaderRegistry()
+
+/**
+ * Helper function to create lazy components from registry
+ */
+export function createLazyComponentFromRegistry(name: string) {
+  const lazyComponent = globalComponentRegistry.getLazyComponent(name)
+  if (!lazyComponent) {
+    throw new Error(`Component '${name}' not found in registry. Make sure the plugin is installed.`)
+  }
+  return lazyComponent
+}
+
+/**
+ * Helper to register plugin components dynamically
+ * NOTE: This should be called from plugin packages, not core
+ */
+export function createPluginComponentRegistrar(pluginName: string, baseModulePath: string) {
+  return (components: Record<string, {
+    path: string
+    chunk?: string
+    metadata?: ComponentLoaderDefinition['metadata']
+  }>) => {
+    const componentDefinitions: Record<string, any> = {}
+    
+    for (const [name, config] of Object.entries(components)) {
+      componentDefinitions[name] = {
+        loader: () => {
+          const modulePath = `${baseModulePath}/${config.path}`
+          return import(/* @vite-ignore */ modulePath)
+        },
+        chunk: config.chunk,
+        metadata: config.metadata,
+      }
+    }
+    
+    globalComponentRegistry.registerPluginComponents(pluginName, componentDefinitions)
+  }
+}
+

package/src/plugins/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/legacy-adapter.ts

@@ -0,0 +1,84 @@
+/**
+ * Legacy Plugin Adapter - Phase 1 Implementation
+ * 
+ * Provides backward compatibility with existing plugin APIs during migration.
+ * Adapts old plugin interfaces to work with the simplified system.
+ */
+
+import type { TachUIPlugin, TachUIInstance } from './simplified-types'
+import { PluginError } from './simplified-types'
+
+/**
+ * Legacy plugin interface (old format)
+ */
+interface LegacyPlugin {
+  metadata: {
+    name: string
+    version: string
+    description?: string
+    author?: string
+  }
+  initialize(instance: any, options?: any): void | Promise<void>
+  cleanup?(): void | Promise<void>
+  dependencies?: string[]
+}
+
+/**
+ * Legacy plugin adapter
+ */
+export function createLegacyPluginAdapter(legacyPlugin: LegacyPlugin): TachUIPlugin {
+  if (!legacyPlugin.metadata) {
+    throw new PluginError('Legacy plugin must have metadata property')
+  }
+
+  if (!legacyPlugin.metadata.name || !legacyPlugin.metadata.version) {
+    throw new PluginError('Legacy plugin metadata must include name and version')
+  }
+
+  return {
+    name: legacyPlugin.metadata.name,
+    version: legacyPlugin.metadata.version,
+    description: legacyPlugin.metadata.description,
+    
+    async install(instance: TachUIInstance): Promise<void> {
+      if (process.env.NODE_ENV === 'development') {
+        console.warn(`⚠️  Using legacy adapter for plugin "${legacyPlugin.metadata.name}". Consider updating to simplified API.`)
+      }
+      
+      // Adapt old plugin API to new simplified API
+      await legacyPlugin.initialize(instance)
+    },
+    
+    async uninstall(): Promise<void> {
+      if (legacyPlugin.cleanup) {
+        await legacyPlugin.cleanup()
+      }
+    }
+  }
+}
+
+/**
+ * Check if a plugin uses the legacy format
+ */
+export function isLegacyPlugin(plugin: any): plugin is LegacyPlugin {
+  return (
+    plugin && 
+    typeof plugin === 'object' &&
+    plugin.metadata &&
+    typeof plugin.metadata.name === 'string' &&
+    typeof plugin.metadata.version === 'string' &&
+    typeof plugin.initialize === 'function'
+  )
+}
+
+/**
+ * Auto-adapt legacy plugins
+ */
+export function adaptPlugin(plugin: any): TachUIPlugin {
+  if (isLegacyPlugin(plugin)) {
+    return createLegacyPluginAdapter(plugin)
+  }
+  
+  // Assume it's already using the new simplified format
+  return plugin as TachUIPlugin
+}

package/src/plugins/simplified-component-registry.ts

@@ -0,0 +1,130 @@
+/**
+ * Simplified Component Registry - Phase 1 Implementation
+ * 
+ * Streamlined component registration with basic functionality only.
+ * Removes complex lazy loading, chunk management, and metadata tracking.
+ */
+
+import type { Component } from '../runtime/types'
+
+export interface ComponentRegistration {
+  name: string
+  component: Component
+  category?: string
+  tags?: string[]
+  plugin?: string
+}
+
+export class SimplifiedComponentRegistry {
+  private components = new Map<string, ComponentRegistration>()
+
+  register(registration: ComponentRegistration): void {
+    // Simple validation
+    if (!registration.name || typeof registration.name !== 'string') {
+      throw new Error('Component registration must have a valid name')
+    }
+    
+    if (!registration.component || typeof registration.component !== 'function') {
+      throw new Error('Component registration must have a valid component function')
+    }
+
+    // Warn about overwrites but allow them
+    if (this.components.has(registration.name)) {
+      console.warn(`Component ${registration.name} already registered, overwriting`)
+    }
+    
+    this.components.set(registration.name, registration)
+    console.log(`📦 Component "${registration.name}" registered${registration.category ? ` (${registration.category})` : ''}`)
+  }
+
+  get(name: string): ComponentRegistration | undefined {
+    return this.components.get(name)
+  }
+
+  getComponent(name: string): Component | undefined {
+    return this.components.get(name)?.component
+  }
+
+  has(name: string): boolean {
+    return this.components.has(name)
+  }
+
+  list(): ComponentRegistration[] {
+    return Array.from(this.components.values())
+  }
+
+  listByCategory(category: string): ComponentRegistration[] {
+    return this.list().filter(reg => reg.category === category)
+  }
+
+  listByPlugin(plugin: string): ComponentRegistration[] {
+    return this.list().filter(reg => reg.plugin === plugin)
+  }
+
+  unregister(name: string): boolean {
+    const existed = this.components.has(name)
+    this.components.delete(name)
+    
+    if (existed) {
+      console.log(`🗑️ Component "${name}" unregistered`)
+    }
+    
+    return existed
+  }
+
+  unregisterByPlugin(plugin: string): string[] {
+    const unregistered: string[] = []
+    
+    for (const [name, registration] of this.components.entries()) {
+      if (registration.plugin === plugin) {
+        this.components.delete(name)
+        unregistered.push(name)
+      }
+    }
+    
+    if (unregistered.length > 0) {
+      console.log(`🗑️ Unregistered ${unregistered.length} components from plugin "${plugin}": ${unregistered.join(', ')}`)
+    }
+    
+    return unregistered
+  }
+
+  clear(): void {
+    const count = this.components.size
+    this.components.clear()
+    console.log(`🗑️ Cleared ${count} registered components`)
+  }
+
+  getStats() {
+    const stats = {
+      totalComponents: this.components.size,
+      categories: new Map<string, number>(),
+      plugins: new Map<string, number>(),
+      tags: new Map<string, number>()
+    }
+
+    for (const registration of this.components.values()) {
+      // Count by category
+      const category = registration.category || 'uncategorized'
+      stats.categories.set(category, (stats.categories.get(category) || 0) + 1)
+      
+      // Count by plugin
+      const plugin = registration.plugin || 'core'
+      stats.plugins.set(plugin, (stats.plugins.get(plugin) || 0) + 1)
+      
+      // Count by tags
+      if (registration.tags) {
+        for (const tag of registration.tags) {
+          stats.tags.set(tag, (stats.tags.get(tag) || 0) + 1)
+        }
+      }
+    }
+
+    return {
+      totalComponents: stats.totalComponents,
+      categories: Object.fromEntries(stats.categories),
+      plugins: Object.fromEntries(stats.plugins),
+      tags: Object.fromEntries(stats.tags)
+    }
+  }
+}