@tachui/core 0.7.0-alpha1 → 0.7.1-alpha

package/src/reactive/enhanced-signal.ts

@@ -1,227 +0,0 @@
-/**
- * Enhanced Signal Implementation v2.0
- *
- * Integrates with the unified scheduler and provides custom equality functions
- * to fix signal update detection bugs and eliminate race conditions.
- */
-
-import { getCurrentComputation } from './context'
-import { defaultEquals, deepEquals, shallowEquals, type EqualityFunction } from './equality'
-import type { Computation } from './types'
-import { ComputationState } from './types'
-import { type ReactiveNode, ReactiveScheduler, UpdatePriority } from './unified-scheduler'
-
-let signalIdCounter = 0
-
-export interface SignalOptions<T> {
-  equals?: EqualityFunction<T>
-  priority?: UpdatePriority
-  debugName?: string
-}
-
-/**
- * Enhanced signal implementation with unified scheduler integration
- */
-export class EnhancedSignalImpl<T> implements ReactiveNode {
-  readonly id = ++signalIdCounter
-  readonly type = 'signal' as const
-  readonly priority: UpdatePriority
-  readonly observers = new Set<Computation>()
-
-  private _value: T
-  private scheduler = ReactiveScheduler.getInstance()
-  private equalsFn: EqualityFunction<T>
-  private debugName?: string
-  private options: SignalOptions<T>
-
-  constructor(initialValue: T, options: SignalOptions<T> = {}) {
-    this._value = initialValue
-    this.options = options
-    this.priority = options.priority ?? UpdatePriority.Normal
-    this.equalsFn = options.equals ?? defaultEquals
-    this.debugName = options.debugName
-  }
-
-  /**
-   * Get the current value and track dependency
-   */
-  getValue(): T {
-    const computation = getCurrentComputation()
-    if (computation && computation.state !== ComputationState.Disposed) {
-      // Establish bidirectional relationship
-      this.observers.add(computation)
-      computation.sources.add(this)
-    }
-    return this._value
-  }
-
-  /**
-   * Get the current value without tracking dependency
-   */
-  peek(): T {
-    return this._value
-  }
-
-  /**
-   * Set a new value using custom equality function
-   */
-  setValue(newValue: T | ((prev: T) => T)): T {
-    const value =
-      typeof newValue === 'function' ? (newValue as (prev: T) => T)(this._value) : newValue
-
-    // Use custom equality function instead of simple !== check
-    if (!this.equalsFn(value, this._value)) {
-      const oldValue = this._value
-      this._value = value
-
-      if (process.env.NODE_ENV === 'development' && this.debugName) {
-        console.debug(`[Signal:${this.debugName}] ${oldValue} -> ${value}`)
-      }
-
-      // Schedule update through unified scheduler
-      this.scheduler.schedule(this)
-    }
-
-    return value
-  }
-
-  /**
-   * Notify all observers (called by scheduler)
-   */
-  notify(): void {
-    // Mark all observers as dirty and schedule them
-    for (const observer of this.observers) {
-      if (observer.state !== ComputationState.Disposed) {
-        observer.state = ComputationState.Dirty
-
-        // Schedule observer if it's also a ReactiveNode
-        if ('type' in observer && 'priority' in observer) {
-          this.scheduler.schedule(observer as any)
-        }
-      }
-    }
-  }
-
-  /**
-   * Remove an observer (cleanup)
-   */
-  removeObserver(computation: Computation): void {
-    this.observers.delete(computation)
-  }
-
-  /**
-   * Complete cleanup for memory management
-   */
-  cleanup(): void {
-    // Complete bidirectional cleanup to prevent memory leaks
-    for (const observer of this.observers) {
-      observer.sources.delete(this)
-    }
-    this.observers.clear()
-  }
-
-  /**
-   * Get debug information about this signal
-   */
-  [Symbol.for('tachui.debug')](): object {
-    return {
-      id: this.id,
-      type: this.type,
-      value: this._value,
-      observerCount: this.observers.size,
-      priority: UpdatePriority[this.priority],
-      debugName: this.debugName,
-      equalsFn: this.equalsFn.name || 'anonymous',
-    }
-  }
-
-  toString(): string {
-    return `Signal(${this.options.debugName || this.id}): ${this._value}`
-  }
-}
-
-/**
- * Signal setter function type
- */
-export type SignalSetter<T> = (value: T | ((prev: T) => T)) => T
-
-/**
- * Create a new enhanced reactive signal with custom equality
- */
-export function createEnhancedSignal<T>(
-  initialValue: T,
-  options?: SignalOptions<T>
-): [() => T, SignalSetter<T>] {
-  const signal = new EnhancedSignalImpl(initialValue, options)
-
-  const getter = signal.getValue.bind(signal) as (() => T) & { peek: () => T }
-  getter.peek = signal.peek.bind(signal)
-
-  const setter: SignalSetter<T> = signal.setValue.bind(signal)
-
-  // Add debug information for compatibility
-  Object.defineProperty(getter, Symbol.for('tachui.signal'), {
-    value: signal,
-    enumerable: false,
-  })
-
-  return [getter, setter]
-}
-
-/**
- * Create a signal with deep equality comparison
- */
-export function createDeepSignal<T>(
-  initialValue: T,
-  options?: Omit<SignalOptions<T>, 'equals'>
-): [() => T, SignalSetter<T>] {
-  return createEnhancedSignal(initialValue, {
-    ...options,
-    equals: deepEquals,
-  })
-}
-
-/**
- * Create a signal with shallow equality comparison
- */
-export function createShallowSignal<T>(
-  initialValue: T,
-  options?: Omit<SignalOptions<T>, 'equals'>
-): [() => T, SignalSetter<T>] {
-  return createEnhancedSignal(initialValue, {
-    ...options,
-    equals: shallowEquals,
-  })
-}
-
-/**
- * Get the underlying signal implementation for debugging
- */
-export function getEnhancedSignalImpl<T>(
-  signal: (() => T) & { peek: () => T }
-): EnhancedSignalImpl<T> | null {
-  return (signal as any)[Symbol.for('tachui.signal')] || null
-}
-
-/**
- * Type guard to check if a value is an enhanced signal
- */
-export function isEnhancedSignal<T = any>(value: any): value is (() => T) & { peek: () => T } {
-  return typeof value === 'function' && Symbol.for('tachui.signal') in value
-}
-
-/**
- * Flush all pending signal updates synchronously
- */
-export function flushSignalUpdates(): void {
-  const scheduler = ReactiveScheduler.getInstance()
-  scheduler.flushSync()
-}
-
-/**
- * Get performance metrics for all signals
- */
-export function getSignalPerformanceMetrics() {
-  const scheduler = ReactiveScheduler.getInstance()
-  return scheduler.getPerformanceMetrics()
-}

package/src/reactive/equality.ts

@@ -1,188 +0,0 @@
-/**
- * Equality Functions for Reactive System
- *
- * Provides various equality comparison functions for signal updates
- * including deep, shallow, and custom equality checking.
- */
-
-export type EqualityFunction<T> = (a: T, b: T) => boolean
-
-/**
- * Default reference equality (===)
- */
-export const defaultEquals = <T>(a: T, b: T): boolean => a === b
-
-/**
- * Deep equality comparison for objects and arrays
- * Recursively compares all properties and array elements
- */
-export const deepEquals = <T>(a: T, b: T): boolean => {
-  if (a === b) return true
-  if (a == null || b == null) return false
-  if (typeof a !== typeof b) return false
-
-  if (typeof a === 'object') {
-    if (Array.isArray(a) !== Array.isArray(b)) return false
-
-    if (Array.isArray(a)) {
-      const arrayA = a as unknown as any[]
-      const arrayB = b as unknown as any[]
-      if (arrayA.length !== arrayB.length) return false
-      return arrayA.every((item, index) => deepEquals(item, arrayB[index]))
-    }
-
-    const objA = a as Record<string, any>
-    const objB = b as Record<string, any>
-
-    const keysA = Object.keys(objA)
-    const keysB = Object.keys(objB)
-    if (keysA.length !== keysB.length) return false
-
-    return keysA.every((key) => deepEquals(objA[key], objB[key]))
-  }
-
-  return false
-}
-
-/**
- * Shallow equality comparison for objects
- * Compares only the top-level properties with reference equality
- */
-export const shallowEquals = <T>(a: T, b: T): boolean => {
-  if (a === b) return true
-  if (typeof a !== 'object' || typeof b !== 'object') return false
-  if (a == null || b == null) return false
-
-  const objA = a as Record<string, any>
-  const objB = b as Record<string, any>
-
-  const keysA = Object.keys(objA)
-  const keysB = Object.keys(objB)
-  if (keysA.length !== keysB.length) return false
-
-  return keysA.every((key) => objA[key] === objB[key])
-}
-
-/**
- * Structural equality for specific data types
- */
-export const structuralEquals = <T>(a: T, b: T): boolean => {
-  if (a === b) return true
-
-  // Handle Date objects
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() === b.getTime()
-  }
-
-  // Handle RegExp objects
-  if (a instanceof RegExp && b instanceof RegExp) {
-    return a.toString() === b.toString()
-  }
-
-  // Handle Set objects
-  if (a instanceof Set && b instanceof Set) {
-    if (a.size !== b.size) return false
-    for (const item of a) {
-      if (!b.has(item)) return false
-    }
-    return true
-  }
-
-  // Handle Map objects
-  if (a instanceof Map && b instanceof Map) {
-    if (a.size !== b.size) return false
-    for (const [key, value] of a) {
-      if (!b.has(key) || b.get(key) !== value) return false
-    }
-    return true
-  }
-
-  // Fall back to deep equals for other objects
-  return deepEquals(a, b)
-}
-
-/**
- * JSON-based equality (serializes and compares)
- * Useful for complex nested structures but slower
- */
-export const jsonEquals = <T>(a: T, b: T): boolean => {
-  if (a === b) return true
-
-  try {
-    return JSON.stringify(a) === JSON.stringify(b)
-  } catch {
-    // If serialization fails, fall back to reference equality
-    return a === b
-  }
-}
-
-/**
- * Create a custom equality function based on a selector
- */
-export const createSelectorEquals = <T, K>(
-  selector: (value: T) => K,
-  equalsFn: EqualityFunction<K> = defaultEquals
-): EqualityFunction<T> => {
-  return (a: T, b: T): boolean => {
-    return equalsFn(selector(a), selector(b))
-  }
-}
-
-/**
- * Create an array equality function with custom element comparison
- */
-export const createArrayEquals = <T>(
-  elementEquals: EqualityFunction<T> = defaultEquals
-): EqualityFunction<T[]> => {
-  return (a: T[], b: T[]): boolean => {
-    if (a === b) return true
-    if (a.length !== b.length) return false
-
-    return a.every((item, index) => elementEquals(item, b[index]))
-  }
-}
-
-/**
- * Create an object equality function with custom property comparison
- */
-export const createObjectEquals = <T extends Record<string, any>>(
-  propertyEquals: EqualityFunction<any> = defaultEquals
-): EqualityFunction<T> => {
-  return (a: T, b: T): boolean => {
-    if (a === b) return true
-    if (a == null || b == null) return false
-
-    const keysA = Object.keys(a)
-    const keysB = Object.keys(b)
-    if (keysA.length !== keysB.length) return false
-
-    return keysA.every((key) => propertyEquals(a[key], b[key]))
-  }
-}
-
-/**
- * Combine multiple equality functions with AND logic
- */
-export const combineEquals = <T>(
-  ...equalsFunctions: EqualityFunction<T>[]
-): EqualityFunction<T> => {
-  return (a: T, b: T): boolean => {
-    return equalsFunctions.every((equals) => equals(a, b))
-  }
-}
-
-/**
- * Utility to wrap an equality function with debugging
- */
-export const debugEquals = <T>(
-  equalsFn: EqualityFunction<T>,
-  debugName?: string
-): EqualityFunction<T> => {
-  return (a: T, b: T): boolean => {
-    const result = equalsFn(a, b)
-    if (process.env.NODE_ENV === 'development') {
-      console.log(`[${debugName || 'equals'}]`, { a, b, equal: result })
-    }
-    return result
-  }
-}

package/src/reactive/globals.d.ts

@@ -1,5 +0,0 @@
-/**
- * Global type declarations for reactive system
- */
-
-declare const __DEV__: boolean

package/src/reactive/index.ts

@@ -1,150 +0,0 @@
-/**
- * TachUI Reactive System v2.0
- *
- * Enhanced reactive system with unified scheduler, proper error handling,
- * custom equality functions, and complete memory management.
- */
-
-// Cleanup utilities
-export {
-  type CleanupFunction,
-  createCleanupGroup,
-  createEventListener,
-  createInterval,
-  createResource,
-  createTimeout,
-  dispose,
-  onCleanup,
-} from './cleanup'
-export {
-  type Computed,
-  type ComputedOptions,
-  createComputed,
-  createMemo,
-  isComputed,
-} from './computed'
-// Context and ownership
-export {
-  batch,
-  createRoot,
-  getOwner,
-  getReactiveContext,
-  runWithOwner,
-  untrack,
-} from './context'
-export {
-  createEffect,
-  createOnceEffect,
-  createRenderEffect,
-  createSyncEffect,
-  type Effect,
-  type EffectFunction,
-} from './effect'
-export {
-  createEffectBatch,
-  createEnhancedEffect,
-  createHighPriorityEffect,
-  createLowPriorityEffect,
-  createResilientEffect,
-  createWatchEffect,
-  type EffectOptions as EnhancedEffectOptions,
-  flushEffectUpdates,
-  getEffectPerformanceMetrics,
-} from './enhanced-effect'
-export {
-  createDeepSignal,
-  createEnhancedSignal,
-  createShallowSignal,
-  flushSignalUpdates,
-  getEnhancedSignalImpl,
-  getSignalPerformanceMetrics,
-  isEnhancedSignal,
-  type SignalOptions,
-} from './enhanced-signal'
-
-// Equality functions
-export {
-  combineEquals,
-  createArrayEquals,
-  createObjectEquals,
-  createSelectorEquals,
-  debugEquals,
-  deepEquals,
-  defaultEquals,
-  type EqualityFunction,
-  jsonEquals,
-  shallowEquals,
-  structuralEquals,
-} from './equality'
-// Migration utilities
-export {
-  analyzeReactivePerformance,
-  analyzeSignalUsage,
-  createLegacySignal,
-  createMigrationReport,
-  enableReactiveDebugging,
-  getMigrationStats,
-  migrateBatch,
-  migrateReactiveCode,
-  migrateToEnhancedSignal,
-  resetMigrationStats,
-  setMigrationWarnings,
-} from './migration'
-// Ownership utilities
-export {
-  createDetachedRoot,
-  getOwnerChain,
-  getRootOwner,
-  isReactiveContext,
-  runOutsideReactiveContext,
-} from './ownership'
-// Scheduler utilities
-export {
-  enableScheduling,
-  getScheduler,
-  type Scheduler,
-  scheduleIdle,
-  scheduleUpdate,
-  scheduleWithPriority,
-  setScheduler,
-  TaskPriority,
-} from './scheduler'
-// Enhanced reactive primitives
-export {
-  createSignal,
-  flushSync,
-  getSignalImpl,
-  isSignal,
-  type Signal,
-  type SignalSetter,
-} from './signal'
-
-// Theme management
-export {
-  detectSystemTheme,
-  getCurrentTheme,
-  getThemeSignal,
-  setTheme,
-  type Theme,
-} from './theme'
-// Core types
-export type {
-  Accessor,
-  AccessorValue,
-  Computation,
-  ComputationState,
-  EffectOptions,
-  Owner,
-  Setter,
-} from './types'
-// Enhanced scheduler system
-export {
-  ReactiveError,
-  type ReactiveNode,
-  type ReactivePerformanceMetrics,
-  ReactiveScheduler,
-  UpdatePriority,
-} from './unified-scheduler'
-
-// Note: Convenience aliases can be added in user code:
-// import { createEnhancedSignal as signal } from '@tachui/core'