@pyreon/reactivity 0.24.4 → 0.24.6

package/src/createSelector.ts

@@ -1,109 +0,0 @@
-import { effect } from './effect'
-import { trackSubscriber } from './tracking'
-
-/**
- * Notify a subscriber bucket without snapshot allocation.
- * Caps iteration at the original size to avoid infinite loops from
- * re-inserted entries (same pattern as notifySubscribers in tracking.ts).
- */
-function notifyBucket(bucket: Set<() => void>): void {
-  if (bucket.size === 0) return
-  if (bucket.size === 1) {
-    ;(bucket.values().next().value as () => void)()
-    return
-  }
-  const originalSize = bucket.size
-  let i = 0
-  for (const fn of bucket) {
-    if (i >= originalSize) break
-    fn()
-    i++
-  }
-}
-
-/** Selector predicate with a `dispose()` method to release internal state. */
-export interface Selector<T> {
-  (value: T): boolean
-  /**
-   * Stop the source-tracking effect AND clear the per-value subscriber/host
-   * Maps. After dispose, calls to the selector return the last-known result
-   * but no longer track. Required for selectors over dynamic value spaces
-   * (UUIDs, ephemeral IDs) created outside an `EffectScope` — without it,
-   * each unique queried value adds a permanent entry to the internal Maps,
-   * leaking memory for the lifetime of the program. Idempotent.
-   */
-  dispose(): void
-}
-
-/**
- * Create an equality selector — returns a reactive predicate that is true
- * only for the currently selected value.
- *
- * Unlike a plain `() => source() === value`, this only triggers the TWO
- * affected subscribers (deselected + newly selected) instead of ALL
- * subscribers, making selection O(1) regardless of list size.
- *
- * @example
- * const isSelected = createSelector(selectedId)
- * // In each row:
- * class: () => (isSelected(row.id) ? "selected" : "")
- *
- * @example
- * // Dynamic value spaces — call dispose() to release the per-value cache:
- * const isCurrentTab = createSelector(() => currentTabId())
- * onUnmount(() => isCurrentTab.dispose())
- */
-export function createSelector<T>(source: () => T): Selector<T> {
-  const subs = new Map<T, Set<() => void>>()
-  let current: T
-  let initialized = false
-  let disposed = false
-
-  const sourceEffect = effect(() => {
-    const next = source()
-    if (!initialized) {
-      initialized = true
-      current = next
-      return
-    }
-    if (Object.is(next, current)) return
-    const old = current
-    current = next
-    // Only notify the two affected buckets — O(1) regardless of list size.
-    // Iteration-capped loop avoids [...bucket] snapshot allocation.
-    const oldBucket = subs.get(old)
-    const newBucket = subs.get(next)
-    if (oldBucket) notifyBucket(oldBucket)
-    if (newBucket) notifyBucket(newBucket)
-  })
-
-  // Reusable hosts per value — avoids allocating a closure per trackSubscriber call
-  const hosts = new Map<T, { _s: Set<() => void> | null }>()
-
-  const selector = ((value: T): boolean => {
-    if (!disposed) {
-      let host = hosts.get(value)
-      if (!host) {
-        let bucket = subs.get(value)
-        if (!bucket) {
-          bucket = new Set()
-          subs.set(value, bucket)
-        }
-        host = { _s: bucket }
-        hosts.set(value, host)
-      }
-      trackSubscriber(host)
-    }
-    return Object.is(current, value)
-  }) as Selector<T>
-
-  selector.dispose = (): void => {
-    if (disposed) return
-    disposed = true
-    sourceEffect.dispose()
-    subs.clear()
-    hosts.clear()
-  }
-
-  return selector
-}

package/src/debug.ts

@@ -1,134 +0,0 @@
-/**
- * @pyreon/reactivity debug utilities.
- *
- * Development-only tools for tracing signal updates, inspecting reactive
- * graphs, and understanding why DOM nodes re-render.
- *
- * All utilities are tree-shakeable — they compile away in production builds
- * when unused.
- */
-
-import type { Signal, SignalDebugInfo } from './signal'
-
-// ─── Signal update tracing ───────────────────────────────────────────────────
-
-interface SignalUpdateEvent {
-  /** The signal that changed */
-  signal: Signal<unknown>
-  /** Signal name (from options or label) */
-  name: string | undefined
-  /** Previous value */
-  prev: unknown
-  /** New value */
-  next: unknown
-  /** Stack trace at the point of the .set() / .update() call */
-  stack: string
-  /** Timestamp */
-  timestamp: number
-}
-
-type SignalUpdateListener = (event: SignalUpdateEvent) => void
-
-let _traceListeners: SignalUpdateListener[] | null = null
-
-/**
- * Register a listener that fires on every signal write.
- * Returns a dispose function.
- *
- * @example
- * const dispose = onSignalUpdate(e => {
- *   console.log(`${e.name ?? 'anonymous'}: ${e.prev} → ${e.next}`)
- * })
- */
-export function onSignalUpdate(listener: SignalUpdateListener): () => void {
-  if (!_traceListeners) _traceListeners = []
-  _traceListeners.push(listener)
-  return () => {
-    if (!_traceListeners) return
-    _traceListeners = _traceListeners.filter((l) => l !== listener)
-    if (_traceListeners.length === 0) _traceListeners = null
-  }
-}
-
-/** @internal — called from signal.set() when tracing is active */
-export function _notifyTraceListeners(sig: Signal<unknown>, prev: unknown, next: unknown): void {
-  if (!_traceListeners) return
-  const event: SignalUpdateEvent = {
-    signal: sig,
-    name: sig.label,
-    prev,
-    next,
-    stack: new Error().stack ?? '',
-    timestamp: performance.now(),
-  }
-  for (const l of _traceListeners) l(event)
-}
-
-/** Check if any trace listeners are active (fast path for signal.set) */
-export function isTracing(): boolean {
-  return _traceListeners !== null
-}
-
-// ─── why() — trace which signal caused a re-run ──────────────────────────────
-
-let _whyActive = false
-let _whyLog: { name: string | undefined; prev: unknown; next: unknown }[] = []
-
-/**
- * Trace the next signal update. Logs which signals fire and what changed.
- * Call before triggering a state change to see what updates and why.
- *
- * @example
- * why()
- * count.set(5)
- * // Console: [pyreon:why] "count": 3 → 5 (2 subscribers)
- */
-export function why(): void {
-  if (_whyActive) return
-  _whyActive = true
-  _whyLog = []
-
-  const dispose = onSignalUpdate((e) => {
-    const _subCount = (e.signal as unknown as { _s: Set<unknown> | null })._s?.size ?? 0
-    const _name = e.name ? `"${e.name}"` : '(anonymous signal)'
-
-    console.log(
-      `[pyreon:why] ${_name}: ${JSON.stringify(e.prev)} → ${JSON.stringify(e.next)} (${_subCount} subscriber${_subCount === 1 ? '' : 's'})`,
-    )
-    _whyLog.push({ name: e.name, prev: e.prev, next: e.next })
-  })
-
-  // Auto-dispose after the current microtask (captures the synchronous batch)
-  queueMicrotask(() => {
-    dispose()
-    if (_whyLog.length === 0) {
-      console.log('[pyreon:why] No signal updates detected')
-    }
-    _whyActive = false
-    _whyLog = []
-  })
-}
-
-// ─── inspectSignal — rich console output ─────────────────────────────────────
-
-/**
- * Print a signal's current state to the console in a readable format.
- *
- * @example
- * const count = signal(42, { name: "count" })
- * inspectSignal(count)
- * // Console:
- * // 🔍 Signal "count"
- * //   value: 42
- * //   subscribers: 3
- */
-export function inspectSignal<T>(sig: Signal<T>): SignalDebugInfo<T> {
-  const info = sig.debug()
-
-  console.group(`🔍 Signal ${info.name ? `"${info.name}"` : '(anonymous)'}`)
-  console.log('value:', info.value)
-  console.log('subscribers:', info.subscriberCount)
-  console.groupEnd()
-
-  return info
-}