@tachui/core 0.7.0-alpha1

package/src/reactive/enhanced-signal.ts

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

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

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

package/src/reactive/index.ts

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