@tachui/core 0.7.0-alpha1 → 0.7.1-alpha

package/src/plugins/simplified-plugin-manager.ts

@@ -1,93 +0,0 @@
-/**
- * Simplified Plugin Manager - Phase 1 Implementation
- * 
- * Streamlined plugin management with essential functionality only.
- * Removes over-engineered security, performance monitoring, and complex preloading.
- */
-
-import type { TachUIInstance, TachUIPlugin } from './simplified-types'
-
-export class PluginError extends Error {
-  constructor(message: string, public code?: string) {
-    super(message)
-    this.name = 'PluginError'
-  }
-}
-
-export class SimplifiedPluginManager {
-  private plugins = new Map<string, TachUIPlugin>()
-  private instance: TachUIInstance
-
-  constructor(instance: TachUIInstance) {
-    this.instance = instance
-  }
-
-  async install(plugin: TachUIPlugin): Promise<void> {
-    // Basic validation only
-    this.validatePluginBasics(plugin)
-    
-    // Install plugin
-    await plugin.install(this.instance)
-    
-    // Register in map
-    this.plugins.set(plugin.name, plugin)
-    
-    console.log(`✅ Plugin "${plugin.name}" v${plugin.version} installed successfully`)
-  }
-
-  async uninstall(pluginName: string): Promise<void> {
-    const plugin = this.plugins.get(pluginName)
-    if (!plugin) {
-      throw new PluginError(`Plugin "${pluginName}" is not installed`)
-    }
-
-    // Always remove the plugin from our registry first
-    this.plugins.delete(pluginName)
-    
-    try {
-      if (plugin.uninstall) {
-        await plugin.uninstall()
-      }
-      console.log(`🗑️ Plugin "${pluginName}" uninstalled successfully`)
-    } catch (error) {
-      console.log(`🗑️ Plugin "${pluginName}" uninstalled successfully (cleanup failed)`)
-      // Re-throw the error so the calling code can handle it
-      throw error
-    }
-  }
-
-  isInstalled(pluginName: string): boolean {
-    return this.plugins.has(pluginName)
-  }
-
-  getInstalledPlugins(): string[] {
-    return Array.from(this.plugins.keys())
-  }
-
-  getPlugin(pluginName: string): TachUIPlugin | undefined {
-    return this.plugins.get(pluginName)
-  }
-
-  getAllPlugins(): TachUIPlugin[] {
-    return Array.from(this.plugins.values())
-  }
-
-  private validatePluginBasics(plugin: TachUIPlugin): void {
-    if (!plugin.name || typeof plugin.name !== 'string') {
-      throw new PluginError('Plugin must have a valid name string', 'INVALID_NAME')
-    }
-    
-    if (!plugin.version || typeof plugin.version !== 'string') {
-      throw new PluginError('Plugin must have a valid version string', 'INVALID_VERSION')
-    }
-    
-    if (!plugin.install || typeof plugin.install !== 'function') {
-      throw new PluginError('Plugin must have an install function', 'INVALID_INSTALL')
-    }
-    
-    // Check for duplicate installation
-    if (this.plugins.has(plugin.name)) {
-      console.warn(`Plugin "${plugin.name}" is already installed, overwriting`)
-    }
-  }
-}

package/src/plugins/simplified-tachui-instance.ts

@@ -1,142 +0,0 @@
-/**
- * Simplified TachUI Instance - Phase 1 Implementation
- * 
- * Streamlined framework instance with essential plugin functionality only.
- * Integrates simplified plugin manager and component registry.
- */
-
-import { SimplifiedPluginManager } from './simplified-plugin-manager'
-import { SimplifiedComponentRegistry } from './simplified-component-registry'
-import type { 
-  TachUIInstance, 
-  TachUIPlugin, 
-  ComponentRegistrationOptions
-} from './simplified-types'
-import type { Component } from '../runtime/types'
-
-export class SimplifiedTachUIInstance implements TachUIInstance {
-  public readonly plugins: SimplifiedPluginManager
-  public readonly components: SimplifiedComponentRegistry
-  public readonly services: Map<string, any>
-  private currentInstallingPlugin: string | null = null
-
-  constructor() {
-    this.components = new SimplifiedComponentRegistry()
-    this.services = new Map<string, any>()
-    this.plugins = new SimplifiedPluginManager(this)
-  }
-
-  registerComponent(name: string, component: Component, options?: ComponentRegistrationOptions): void {
-    this.components.register({
-      name,
-      component,
-      category: options?.category,
-      tags: options?.tags,
-      plugin: this.currentInstallingPlugin || undefined
-    })
-  }
-
-  registerService(name: string, service: any): void {
-    if (this.services.has(name) && !this.services.get(name)) {
-      console.warn(`Service "${name}" already registered, overwriting`)
-    }
-    
-    this.services.set(name, service)
-    console.log(`⚙️ Service "${name}" registered`)
-  }
-
-  getService<T = any>(name: string): T | undefined {
-    return this.services.get(name)
-  }
-
-  hasService(name: string): boolean {
-    return this.services.has(name)
-  }
-
-  unregisterService(name: string): boolean {
-    const existed = this.services.has(name)
-    this.services.delete(name)
-    
-    if (existed) {
-      console.log(`🗑️ Service "${name}" unregistered`)
-    }
-    
-    return existed
-  }
-
-  async installPlugin(plugin: TachUIPlugin): Promise<void> {
-    this.currentInstallingPlugin = plugin.name
-    try {
-      await this.plugins.install(plugin)
-    } finally {
-      this.currentInstallingPlugin = null
-    }
-  }
-
-  async uninstallPlugin(pluginName: string): Promise<void> {
-    // Unregister components belonging to this plugin
-    this.components.unregisterByPlugin(pluginName)
-    
-    // Unregister services belonging to this plugin (simple cleanup)
-    // Note: We don't track service ownership in the simplified version,
-    // so we rely on the plugin's uninstall method to clean up its services
-    
-    await this.plugins.uninstall(pluginName)
-  }
-
-  isPluginInstalled(pluginName: string): boolean {
-    return this.plugins.isInstalled(pluginName)
-  }
-
-  getInstalledPlugins(): string[] {
-    return this.plugins.getInstalledPlugins()
-  }
-
-  getStats() {
-    return {
-      plugins: {
-        installed: this.plugins.getInstalledPlugins().length,
-        list: this.plugins.getInstalledPlugins()
-      },
-      components: this.components.getStats(),
-      services: {
-        registered: this.services.size,
-        list: Array.from(this.services.keys())
-      }
-    }
-  }
-
-  async reset(): Promise<void> {
-    // Uninstall all plugins
-    const pluginNames = this.getInstalledPlugins()
-    for (const pluginName of pluginNames) {
-      try {
-        await this.uninstallPlugin(pluginName)
-      } catch (error) {
-        console.error(`Failed to uninstall plugin "${pluginName}":`, error)
-      }
-    }
-    
-    // Clear remaining components and services
-    this.components.clear()
-    this.services.clear()
-    
-    console.log('🔄 TachUI instance reset completed')
-  }
-}
-
-// Create and export a global instance
-export const globalTachUIInstance = new SimplifiedTachUIInstance()
-
-// Convenience functions for global instance
-export function installPlugin(plugin: TachUIPlugin): Promise<void> {
-  return globalTachUIInstance.installPlugin(plugin)
-}
-
-export function registerComponent(name: string, component: Component, options?: ComponentRegistrationOptions): void {
-  return globalTachUIInstance.registerComponent(name, component, options)
-}
-
-export function registerService(name: string, service: any): void {
-  return globalTachUIInstance.registerService(name, service)
-}

package/src/plugins/simplified-types.ts

@@ -1,79 +0,0 @@
-/**
- * Simplified Plugin Types - Phase 1 Implementation
- * 
- * Streamlined type definitions for the simplified plugin system.
- * Removes complex configuration schemas, security features, and performance monitoring.
- */
-
-import type { Component } from '../runtime/types'
-import type { SimplifiedComponentRegistry } from './simplified-component-registry'
-
-/**
- * Simplified plugin interface with essential properties only
- */
-export interface TachUIPlugin {
-  /** Unique plugin name */
-  name: string
-  
-  /** Plugin version (semver recommended) */
-  version: string
-  
-  /** Plugin description (optional) */
-  description?: string
-  
-  /** Plugin installation function */
-  install(instance: TachUIInstance): Promise<void>
-  
-  /** Plugin uninstallation function (optional) */
-  uninstall?(): Promise<void>
-}
-
-/**
- * Simplified TachUI instance interface for plugins
- */
-export interface TachUIInstance {
-  /** Register a component with the framework */
-  registerComponent(name: string, component: Component, options?: ComponentRegistrationOptions): void
-  
-  /** Register a service with the framework */
-  registerService(name: string, service: any): void
-  
-  /** Access to component registry */
-  components: SimplifiedComponentRegistry
-  
-  /** Access to services registry */
-  services: Map<string, any>
-}
-
-/**
- * Component registration options (simplified)
- */
-export interface ComponentRegistrationOptions {
-  /** Component category for organization */
-  category?: string
-  
-  /** Tags for component discovery */
-  tags?: string[]
-  
-  /** Whether to overwrite existing component */
-  overwrite?: boolean
-}
-
-/**
- * Plugin error class for handling plugin-related errors
- */
-export class PluginError extends Error {
-  constructor(message: string, public code?: string) {
-    super(message)
-    this.name = 'PluginError'
-  }
-}
-
-/**
- * Service registration interface
- */
-export interface ServiceRegistration {
-  name: string
-  service: any
-  plugin?: string
-}

package/src/plugins/simplified-utils.ts

@@ -1,118 +0,0 @@
-/**
- * Simplified Plugin Utilities - Phase 1 Implementation
- * 
- * Essential utility functions only, removing complex debounce/throttle/deepClone
- * functionality that adds unnecessary complexity for simple plugin use cases.
- */
-
-/**
- * Validates a semantic version string
- */
-export function validateSemver(version: string): boolean {
-  if (!version || typeof version !== 'string') {
-    return false
-  }
-
-  const semverRegex =
-    /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/
-  return semverRegex.test(version)
-}
-
-/**
- * Compares two semantic version strings
- * @param a First version
- * @param b Second version
- * @returns -1 if a < b, 0 if a === b, 1 if a > b
- */
-export function compareSemver(a: string, b: string): number {
-  if (!validateSemver(a) || !validateSemver(b)) {
-    throw new Error('Invalid semantic version format')
-  }
-
-  const parseVersion = (version: string) => {
-    const [main, prerelease] = version.split('-')
-    const [major, minor, patch] = main.split('.').map(Number)
-    return { major, minor, patch, prerelease }
-  }
-
-  const versionA = parseVersion(a)
-  const versionB = parseVersion(b)
-
-  // Compare major version
-  if (versionA.major !== versionB.major) {
-    return versionA.major < versionB.major ? -1 : 1
-  }
-
-  // Compare minor version
-  if (versionA.minor !== versionB.minor) {
-    return versionA.minor < versionB.minor ? -1 : 1
-  }
-
-  // Compare patch version
-  if (versionA.patch !== versionB.patch) {
-    return versionA.patch < versionB.patch ? -1 : 1
-  }
-
-  // Compare prerelease versions
-  if (versionA.prerelease && versionB.prerelease) {
-    return versionA.prerelease < versionB.prerelease
-      ? -1
-      : versionA.prerelease > versionB.prerelease
-        ? 1
-        : 0
-  }
-
-  // Version with prerelease is less than version without
-  if (versionA.prerelease && !versionB.prerelease) return -1
-  if (!versionA.prerelease && versionB.prerelease) return 1
-
-  return 0
-}
-
-/**
- * Validates plugin name format
- */
-export function validatePluginName(name: string): boolean {
-  if (!name || typeof name !== 'string') {
-    return false
-  }
-
-  // Allow scoped packages (@scope/name) or simple names
-  const nameRegex = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/
-  return nameRegex.test(name)
-}
-
-/**
- * Normalizes a plugin name (removes @scope/ prefix for ID generation)
- */
-export function normalizePluginName(name: string): string {
-  return name.replace(/^@[^/]+\//, '')
-}
-
-/**
- * Simple plugin development utilities for debugging
- */
-export const PluginDevUtils = {
-  /**
-   * Logs plugin debug information in development mode
-   */
-  log(pluginName: string, message: string, data?: any): void {
-    if (process.env.NODE_ENV === 'development') {
-      console.group(`🔌 [${pluginName}]`)
-      console.log(message)
-      if (data) {
-        console.log('Data:', data)
-      }
-      console.groupEnd()
-    }
-  },
-
-  /**
-   * Creates a development-only warning
-   */
-  warn(pluginName: string, message: string): void {
-    if (process.env.NODE_ENV === 'development') {
-      console.warn(`⚠️  [${pluginName}] ${message}`)
-    }
-  },
-}

package/src/reactive/cleanup.ts

@@ -1,241 +0,0 @@
-/**
- * Cleanup and disposal utilities for reactive system
- *
- * Provides memory management, cleanup functions, and disposal
- * utilities to prevent memory leaks in reactive computations.
- */
-
-import { getCurrentOwner } from './context'
-import type { CleanupFunction, Owner } from './types'
-
-/**
- * Add a cleanup function to the current reactive context
- *
- * @param fn Cleanup function to run when the context is disposed
- *
- * @example
- * ```typescript
- * createEffect(() => {
- *   const interval = setInterval(() => {
- *     console.log('tick')
- *   }, 1000)
- *
- *   onCleanup(() => {
- *     clearInterval(interval)
- *   })
- * })
- * ```
- */
-export function onCleanup(fn: CleanupFunction): void {
-  const owner = getCurrentOwner()
-  if (owner && !owner.disposed) {
-    owner.cleanups.push(fn)
-  } else if (__DEV__) {
-    console.warn('onCleanup called outside of reactive context')
-  }
-}
-
-/**
- * Dispose a reactive owner and all its children
- *
- * @param owner The owner to dispose
- */
-export function dispose(owner: Owner): void {
-  if ('dispose' in owner && typeof owner.dispose === 'function') {
-    owner.dispose()
-  }
-}
-
-/**
- * Create a disposable resource with automatic cleanup
- *
- * @param fn Function that creates and returns a resource and its cleanup
- * @returns The created resource
- *
- * @example
- * ```typescript
- * const timer = createResource(() => {
- *   const id = setInterval(() => console.log('tick'), 1000)
- *   return [id, () => clearInterval(id)]
- * })
- * ```
- */
-export function createResource<T>(fn: () => [T, CleanupFunction]): T {
-  const [resource, cleanup] = fn()
-  onCleanup(cleanup)
-  return resource
-}
-
-/**
- * Create a cleanup group that can be disposed manually
- *
- * @returns Cleanup group with dispose function
- *
- * @example
- * ```typescript
- * const group = createCleanupGroup()
- *
- * group.add(() => console.log('cleanup 1'))
- * group.add(() => console.log('cleanup 2'))
- *
- * // Later...
- * group.dispose() // Runs both cleanup functions
- * ```
- */
-export function createCleanupGroup(): {
-  add: (fn: CleanupFunction) => void
-  dispose: () => void
-  disposed: boolean
-} {
-  const cleanups: CleanupFunction[] = []
-  let disposed = false
-
-  return {
-    add(fn: CleanupFunction) {
-      if (disposed) {
-        if (__DEV__) {
-          console.warn('Adding cleanup to disposed group')
-        }
-        return
-      }
-      cleanups.push(fn)
-    },
-
-    dispose() {
-      if (disposed) return
-      disposed = true
-
-      for (const cleanup of cleanups) {
-        try {
-          cleanup()
-        } catch (error) {
-          console.error('Error in cleanup function:', error)
-        }
-      }
-      cleanups.length = 0
-    },
-
-    get disposed() {
-      return disposed
-    },
-  }
-}
-
-/**
- * Create a weak disposal tracker using WeakRef and FinalizationRegistry
- * for automatic cleanup of unreferenced objects
- */
-export function createWeakDisposal<T extends object>(
-  target: T,
-  cleanup: CleanupFunction
-): WeakRef<T> {
-  const weakRef = new WeakRef(target)
-
-  if (typeof FinalizationRegistry !== 'undefined') {
-    const registry = new FinalizationRegistry(cleanup)
-    registry.register(target, cleanup)
-  }
-
-  return weakRef
-}
-
-/**
- * Defer a cleanup function to run after the current reactive cycle
- *
- * @param fn Cleanup function to defer
- */
-export function deferCleanup(fn: CleanupFunction): void {
-  queueMicrotask(() => {
-    try {
-      fn()
-    } catch (error) {
-      console.error('Error in deferred cleanup:', error)
-    }
-  })
-}
-
-/**
- * Create a cleanup function that only runs once
- *
- * @param fn Cleanup function
- * @returns Cleanup function that only runs once
- */
-export function createOnceCleanup(fn: CleanupFunction): CleanupFunction {
-  let hasRun = false
-
-  return () => {
-    if (hasRun) return
-    hasRun = true
-    fn()
-  }
-}
-
-/**
- * Create a timeout with automatic cleanup
- *
- * @param fn Function to run after timeout
- * @param delay Delay in milliseconds
- * @returns Timeout ID
- */
-export function createTimeout(fn: () => void, delay: number): NodeJS.Timeout {
-  const id = setTimeout(fn, delay)
-  onCleanup(() => clearTimeout(id))
-  return id
-}
-
-/**
- * Create an interval with automatic cleanup
- *
- * @param fn Function to run on interval
- * @param delay Delay in milliseconds
- * @returns Interval ID
- */
-export function createInterval(fn: () => void, delay: number): NodeJS.Timeout {
-  const id = setInterval(fn, delay)
-  onCleanup(() => clearInterval(id))
-  return id
-}
-
-/**
- * Create an event listener with automatic cleanup
- *
- * @param target Event target
- * @param event Event name
- * @param handler Event handler
- * @param options Event listener options
- */
-export function createEventListener<K extends keyof WindowEventMap>(
-  target: Window,
-  event: K,
-  handler: (event: WindowEventMap[K]) => void,
-  options?: AddEventListenerOptions
-): void
-export function createEventListener<K extends keyof DocumentEventMap>(
-  target: Document,
-  event: K,
-  handler: (event: DocumentEventMap[K]) => void,
-  options?: AddEventListenerOptions
-): void
-export function createEventListener<K extends keyof HTMLElementEventMap>(
-  target: HTMLElement,
-  event: K,
-  handler: (event: HTMLElementEventMap[K]) => void,
-  options?: AddEventListenerOptions
-): void
-export function createEventListener(
-  target: EventTarget,
-  event: string,
-  handler: (event: Event) => void,
-  options?: AddEventListenerOptions
-): void {
-  target.addEventListener(event, handler, options)
-  onCleanup(() => target.removeEventListener(event, handler, options))
-}
-
-// Development mode flag - simplified approach
-if (typeof (globalThis as any).__DEV__ === 'undefined') {
-  ;(globalThis as any).__DEV__ = process.env.NODE_ENV !== 'production'
-}
-
-// Re-export types
-export type { CleanupFunction }