@tachui/core 0.7.0-alpha1 → 0.7.1-alpha

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

@@ -1,371 +0,0 @@
-/**
- * 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

@@ -1,61 +0,0 @@
-/**
- * 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

@@ -1,84 +0,0 @@
-/**
- * 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

@@ -1,130 +0,0 @@
-/**
- * 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)
-    }
-  }
-}