@fictjs/runtime 0.5.2 → 0.7.0

package/src/signal.ts

@@ -13,7 +13,7 @@ import type { SuspenseToken } from './types'
 const isDev =
   typeof __DEV__ !== 'undefined'
     ? __DEV__
-    : typeof process === 'undefined' || process.env?.NODE_ENV !== 'production'
+    : typeof process !== 'undefined' && process.env?.NODE_ENV !== 'production'
 
 // ============================================================================
 // Type Definitions
@@ -844,6 +844,9 @@ function updateComputed<T>(c: ComputedNode<T>): boolean {
   } catch (e) {
     activeSub = prevSub
     c.flags &= ~Running
+    // Keep dependency graph consistent even when getter throws.
+    // Without this, stale old deps can remain subscribed.
+    purgeDeps(c)
     throw e
   }
 }
@@ -881,6 +884,9 @@ function runEffect(e: EffectNode): void {
     } catch (err) {
       activeSub = prevSub
       e.flags = Watching
+      // Keep dependency graph consistent even when effect throws.
+      // Without this, stale old deps can remain subscribed.
+      purgeDeps(e)
       throw err
     }
   } else if (flags & Pending && e.deps) {
@@ -920,6 +926,9 @@ function runEffect(e: EffectNode): void {
       } catch (err) {
         activeSub = prevSub
         e.flags = Watching
+        // Keep dependency graph consistent even when effect throws.
+        // Without this, stale old deps can remain subscribed.
+        purgeDeps(e)
         throw err
       }
     } else {
@@ -1050,10 +1059,10 @@ export function signal<T>(initialValue: T, options?: SignalOptions<T>): SignalAc
     subsTail: undefined,
     flags: Mutable,
     __id: undefined as number | undefined,
-    ...(options?.equals !== undefined ? { equals: options.equals } : {}),
-    ...(options?.name !== undefined ? { name: options.name } : {}),
-    ...(options?.devToolsSource !== undefined ? { devToolsSource: options.devToolsSource } : {}),
   }
+  if (options?.equals !== undefined) s.equals = options.equals
+  if (options?.name !== undefined) s.name = options.name
+  if (options?.devToolsSource !== undefined) s.devToolsSource = options.devToolsSource
   if (isDev) registerSignalDevtools(s)
   const accessor = signalOper.bind(s as any) as SignalAccessor<T> & Record<symbol, boolean>
   accessor[SIGNAL_MARKER] = true
@@ -1125,10 +1134,10 @@ export function computed<T>(
     flags: 0,
     getter,
     __id: undefined as number | undefined,
-    ...(options?.equals !== undefined ? { equals: options.equals } : {}),
-    ...(options?.name !== undefined ? { name: options.name } : {}),
-    ...(options?.devToolsSource !== undefined ? { devToolsSource: options.devToolsSource } : {}),
   }
+  if (options?.equals !== undefined) c.equals = options.equals
+  if (options?.name !== undefined) c.name = options.name
+  if (options?.devToolsSource !== undefined) c.devToolsSource = options.devToolsSource
   if (isDev) registerComputedDevtools(c)
   const bound = (computedOper as (this: ComputedNode<T>) => T).bind(
     c as any,
@@ -1163,14 +1172,23 @@ function computedOper<T>(this: ComputedNode<T>): T {
       this.flags = flags & ~Pending
     }
   } else if (!flags) {
+    this.depsTail = undefined
     this.flags = MutableRunning
     const prevSub = setActiveSub(this)
     try {
       this.value = this.getter(undefined)
       if (isDev) updateComputedDevtools(this, this.value)
+    } catch (err) {
+      // Initial evaluation failed: remove partially tracked dependencies
+      // and allow a future read to retry from a clean slate.
+      this.flags = 0
+      purgeDeps(this)
+      throw err
     } finally {
       setActiveSub(prevSub)
-      this.flags &= ~Running
+      if (this.flags & Running) {
+        this.flags &= ~Running
+      }
     }
   }
 
@@ -1206,13 +1224,24 @@ export function effect(fn: () => void): EffectDisposer {
   if (prevSub !== undefined) link(e, prevSub, 0)
   activeSub = e
 
+  let didThrow = false
+  let thrown: unknown
   try {
     if (isDev) effectRunDevtools(e)
     fn()
+  } catch (err) {
+    didThrow = true
+    thrown = err
   } finally {
     activeSub = prevSub
-    e.flags &= ~Running
+    if (didThrow) {
+      // Initial execution failed: fully detach partially collected graph links.
+      disposeNode(e)
+    } else {
+      e.flags &= ~Running
+    }
   }
+  if (didThrow) throw thrown
 
   const disposer = effectOper.bind(e) as EffectDisposer & Record<symbol, boolean>
   disposer[EFFECT_MARKER] = true
@@ -1254,13 +1283,24 @@ export function effectWithCleanup(
   if (prevSub !== undefined) link(e, prevSub, 0)
   activeSub = e
 
+  let didThrow = false
+  let thrown: unknown
   try {
     if (isDev) effectRunDevtools(e)
     fn()
+  } catch (err) {
+    didThrow = true
+    thrown = err
   } finally {
     activeSub = prevSub
-    e.flags &= ~Running
+    if (didThrow) {
+      // Initial execution failed: fully detach partially collected graph links.
+      disposeNode(e)
+    } else {
+      e.flags &= ~Running
+    }
   }
+  if (didThrow) throw thrown
 
   const disposer = effectOper.bind(e) as EffectDisposer & Record<symbol, boolean>
   disposer[EFFECT_MARKER] = true
@@ -1285,11 +1325,21 @@ export function effectScope(fn: () => void): EffectScopeDisposer {
   if (prevSub !== undefined) link(e, prevSub, 0)
   activeSub = e
 
+  let didThrow = false
+  let thrown: unknown
   try {
     fn()
+  } catch (err) {
+    didThrow = true
+    thrown = err
   } finally {
     activeSub = prevSub
+    if (didThrow) {
+      // Scope construction failed: detach nested effects/memos linked to this scope.
+      disposeNode(e)
+    }
   }
+  if (didThrow) throw thrown
 
   const disposer = effectScopeOper.bind(e) as EffectScopeDisposer & Record<symbol, boolean>
   disposer[EFFECT_SCOPE_MARKER] = true

package/src/store.ts

@@ -38,6 +38,24 @@ export function createStore<T extends object>(
 const proxyCache = new WeakMap<object, unknown>()
 // Map of target object -> Map<key, Signal>
 const signalCache = new WeakMap<object, Map<string | symbol, SignalAccessor<unknown>>>()
+// Map of target object -> monotonically increasing iterate version
+const iterateVersionCache = new WeakMap<object, number>()
+
+function getIterateVersion(target: object): number {
+  return iterateVersionCache.get(target) ?? 0
+}
+
+function bumpIterateVersion(target: object): number {
+  const next = getIterateVersion(target) + 1
+  iterateVersionCache.set(target, next)
+  return next
+}
+
+function isArrayIndexKey(prop: string | symbol): prop is string {
+  if (typeof prop !== 'string') return false
+  const index = Number(prop)
+  return Number.isInteger(index) && index >= 0 && String(index) === prop
+}
 
 function wrap<T>(value: T): T {
   if (value === null || typeof value !== 'object') return value
@@ -75,7 +93,9 @@ function wrap<T>(value: T): T {
       if (prop === PROXY || prop === TARGET) return false
 
       const isArrayLength = Array.isArray(target) && prop === 'length'
-      const oldLength = isArrayLength ? target.length : undefined
+      const isArrayIndex = Array.isArray(target) && isArrayIndexKey(prop)
+      const oldLength =
+        (isArrayLength || isArrayIndex) && Array.isArray(target) ? target.length : undefined
       const hadKey = Object.prototype.hasOwnProperty.call(target, prop)
       const oldValue = Reflect.get(target, prop, receiver)
       if (oldValue === value) return true
@@ -86,6 +106,12 @@ function wrap<T>(value: T): T {
         if (!hadKey) {
           trigger(target, ITERATE_KEY)
         }
+        if (isArrayIndex) {
+          const nextLength = target.length
+          if (typeof oldLength === 'number' && nextLength !== oldLength) {
+            trigger(target, 'length')
+          }
+        }
         if (isArrayLength) {
           const nextLength = target.length
           if (typeof oldLength === 'number' && nextLength < oldLength) {
@@ -148,8 +174,7 @@ function track(target: object, prop: string | symbol) {
 
   let s = signals.get(prop)
   if (!s) {
-    const initial =
-      prop === ITERATE_KEY ? (Reflect.ownKeys(target).length as number) : getLastValue(target, prop)
+    const initial = prop === ITERATE_KEY ? getIterateVersion(target) : getLastValue(target, prop)
     s = signal(initial)
     signals.set(prop, s)
   }
@@ -162,7 +187,7 @@ function trigger(target: object, prop: string | symbol) {
     const s = signals.get(prop)
     if (s) {
       if (prop === ITERATE_KEY) {
-        s(Reflect.ownKeys(target).length)
+        s(bumpIterateVersion(target))
       } else {
         s(getLastValue(target, prop)) // notify with new value
       }
@@ -174,10 +199,28 @@ function getLastValue(target: object, prop: string | symbol) {
   return Reflect.get(target, prop)
 }
 
+function isPlainObject(value: object): boolean {
+  const proto = Object.getPrototypeOf(value)
+  return proto === Object.prototype || proto === null
+}
+
+function isReconcilableObject(value: unknown): value is object {
+  if (value === null || typeof value !== 'object') return false
+  const raw = unwrap(value as object)
+  return Array.isArray(raw) || isPlainObject(raw)
+}
+
+function canReconcileNestedValues(current: unknown, next: unknown): current is object {
+  if (!isReconcilableObject(current) || !isReconcilableObject(next)) return false
+  const currentRaw = unwrap(current as object)
+  const nextRaw = unwrap(next as object)
+  return Array.isArray(currentRaw) === Array.isArray(nextRaw)
+}
+
 /**
- * Reconcile a store path with a new value (shallow merge/diff)
+ * Reconcile a store path with a new value (recursive structural diff)
  */
-function reconcile(target: object, value: unknown) {
+function reconcile(target: object, value: unknown, seenPairs?: WeakMap<object, WeakSet<object>>) {
   if (target === value) return
   if (value === null || typeof value !== 'object') {
     throw new Error(
@@ -189,23 +232,43 @@ function reconcile(target: object, value: unknown) {
 
   const realTarget = unwrap(target)
   const realValue = unwrap(value)
+  const seen = seenPairs ?? new WeakMap<object, WeakSet<object>>()
+  let visitedValues = seen.get(realTarget)
+  if (!visitedValues) {
+    visitedValues = new WeakSet<object>()
+    seen.set(realTarget, visitedValues)
+  }
+  if (visitedValues.has(realValue)) return
+  visitedValues.add(realValue)
 
   const keys = new Set([...Object.keys(realTarget), ...Object.keys(realValue)])
   for (const key of keys) {
     const rTarget = realTarget as Record<string, unknown>
     const rValue = realValue as Record<string, unknown>
+    const hasCurrent = Object.prototype.hasOwnProperty.call(rTarget, key)
+    const hasNext = Object.prototype.hasOwnProperty.call(rValue, key)
+    const current = rTarget[key]
+    const next = rValue[key]
 
-    if (rValue[key] === undefined && rTarget[key] !== undefined) {
+    if (!hasNext && hasCurrent) {
       // deleted
       delete (target as Record<string, unknown>)[key] // Triggers proxy trap
-    } else if (rTarget[key] !== rValue[key]) {
-      ;(target as Record<string, unknown>)[key] = rValue[key] // Triggers proxy trap
+    } else if (hasNext && (!hasCurrent || current !== next)) {
+      if (canReconcileNestedValues(current, next)) {
+        reconcile((target as Record<string, unknown>)[key] as object, next, seen)
+      } else {
+        ;(target as Record<string, unknown>)[key] = next // Triggers proxy trap
+      }
     }
   }
 
   // Fix array length if needed
-  if (Array.isArray(target) && Array.isArray(realValue) && target.length !== realValue.length) {
-    target.length = realValue.length
+  if (
+    Array.isArray(realTarget) &&
+    Array.isArray(realValue) &&
+    realTarget.length !== realValue.length
+  ) {
+    ;(target as unknown as unknown[]).length = realValue.length
   }
 }
 
@@ -222,6 +285,16 @@ export function createDiffingSignal<T extends object>(initialValue: T) {
   let currentValue = unwrap(initialValue)
   const signals = new Map<string | symbol, SignalAccessor<unknown>>()
   let iterateSignal: SignalAccessor<number> | undefined
+  let iterateVersion = 0
+  let ownKeysSnapshot = Reflect.ownKeys(currentValue as object)
+
+  const hasSameOwnKeys = (aKeys: (string | symbol)[], bKeys: (string | symbol)[]): boolean => {
+    if (aKeys.length !== bKeys.length) return false
+    for (let i = 0; i < aKeys.length; i++) {
+      if (aKeys[i] !== bKeys[i]) return false
+    }
+    return true
+  }
 
   const getPropSignal = (prop: string | symbol) => {
     let s = signals.get(prop)
@@ -234,14 +307,23 @@ export function createDiffingSignal<T extends object>(initialValue: T) {
 
   const trackIterate = () => {
     if (!iterateSignal) {
-      iterateSignal = signal(Reflect.ownKeys(currentValue).length)
+      iterateSignal = signal(iterateVersion)
     }
     iterateSignal()
   }
 
-  const updateIterate = (value: T) => {
-    if (iterateSignal) {
-      iterateSignal(Reflect.ownKeys(value).length)
+  const bumpIterate = () => {
+    if (!iterateSignal) return
+    iterateVersion += 1
+    iterateSignal(iterateVersion)
+  }
+
+  const updateIterateFromOwnKeys = (next: object): void => {
+    const nextKeys = Reflect.ownKeys(next)
+    const changed = !hasSameOwnKeys(ownKeysSnapshot, nextKeys)
+    ownKeysSnapshot = nextKeys
+    if (changed) {
+      bumpIterate()
     }
   }
 
@@ -265,7 +347,38 @@ export function createDiffingSignal<T extends object>(initialValue: T) {
     },
     getOwnPropertyDescriptor(target, prop) {
       getPropSignal(prop)()
-      return Reflect.getOwnPropertyDescriptor(currentValue, prop)
+      const descriptor = Reflect.getOwnPropertyDescriptor(currentValue, prop)
+      if (!descriptor) return undefined
+
+      // Proxy target is a synthetic empty object. Returning a non-configurable
+      // descriptor from the wrapped value can violate Proxy invariants.
+      if (descriptor.configurable !== false) {
+        return descriptor
+      }
+
+      if ('value' in descriptor) {
+        return {
+          configurable: true,
+          enumerable: descriptor.enumerable ?? true,
+          writable: descriptor.writable ?? true,
+          value: descriptor.value,
+        }
+      }
+
+      const normalized: PropertyDescriptor = {
+        configurable: true,
+        enumerable: descriptor.enumerable ?? true,
+      }
+      if (descriptor.get) normalized.get = descriptor.get
+      if (descriptor.set) normalized.set = descriptor.set
+      return normalized
+    },
+    set(_, prop) {
+      throw new Error(
+        `[Fict] Cannot set "${String(
+          prop,
+        )}" on a diffing signal proxy directly. Update the source value and call its writer instead.`,
+      )
     },
   })
 
@@ -283,7 +396,7 @@ export function createDiffingSignal<T extends object>(initialValue: T) {
         const newVal = Reflect.get(next as object, prop)
         s(newVal)
       }
-      updateIterate(next)
+      updateIterateFromOwnKeys(next as object)
       return
     }
 
@@ -297,7 +410,7 @@ export function createDiffingSignal<T extends object>(initialValue: T) {
         s(newVal)
       }
     }
-    updateIterate(next)
+    updateIterateFromOwnKeys(next as object)
 
     // Note: If new properties appeared that weren't tracked, we don't care
     // because no one is listening.

package/src/transition.ts

@@ -67,21 +67,58 @@ export function startTransition(fn: () => void): void {
  * }
  * ```
  */
-export function useTransition(): [() => boolean, (fn: () => void) => void] {
+export function useTransition(): [() => boolean, (fn: () => void | PromiseLike<unknown>) => void] {
   const pending = signal(false)
+  let pendingCount = 0
 
-  const start = (fn: () => void) => {
-    // Both pending(true) and pending(false) are now low-priority updates,
-    // preventing the race condition where isPending() could be inconsistent
-    // with the actual transition execution state.
-    startTransition(() => {
+  const beginPending = () => {
+    pendingCount += 1
+    if (pendingCount === 1) {
       pending(true)
+    }
+  }
+
+  const endPending = () => {
+    if (pendingCount === 0) return
+    pendingCount -= 1
+    if (pendingCount === 0) {
+      pending(false)
+    }
+  }
+
+  const start = (fn: () => void | PromiseLike<unknown>) => {
+    beginPending()
+    let result: void | PromiseLike<unknown> | undefined
+    let thrown: unknown
+    let didThrow = false
+
+    startTransition(() => {
       try {
-        fn()
-      } finally {
-        pending(false)
+        result = fn()
+      } catch (err) {
+        thrown = err
+        didThrow = true
       }
     })
+
+    if (didThrow) {
+      endPending()
+      throw thrown
+    }
+
+    if (result && typeof (result as PromiseLike<unknown>).then === 'function') {
+      Promise.resolve(result).finally(() => {
+        endPending()
+      })
+      return
+    }
+
+    // Keep pending true for at least one microtask so UI can observe it.
+    if (typeof queueMicrotask === 'function') {
+      queueMicrotask(endPending)
+    } else {
+      Promise.resolve().then(endPending)
+    }
   }
 
   return [() => pending(), start]