@tachui/core 0.7.0-alpha1

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

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

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

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

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

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