@fictjs/runtime 0.0.12 → 0.0.14

package/src/signal.ts

@@ -2,6 +2,11 @@ import { beginFlushGuard, beforeEffectRunGuard, endFlushGuard } from './cycle-gu
 import { getDevtoolsHook } from './devtools'
 import { registerRootCleanup } from './lifecycle'
 
+const isDev =
+  typeof __DEV__ !== 'undefined'
+    ? __DEV__
+    : typeof process === 'undefined' || process.env?.NODE_ENV !== 'production'
+
 // ============================================================================
 // Type Definitions
 // ============================================================================
@@ -1177,21 +1182,28 @@ export function endBatch(): void {
  */
 export function batch<T>(fn: () => T): T {
   ++batchDepth
-  let _error: unknown
-  let hasError = false
+  let result!: T
+  let error: unknown
   try {
-    return fn()
+    result = fn()
   } catch (e) {
-    _error = e
-    hasError = true
-    throw e
+    error = e
   } finally {
     --batchDepth
-    // Only flush if no error occurred to avoid interfering with error propagation
-    if (!hasError && batchDepth === 0) {
-      flush()
+    if (batchDepth === 0) {
+      try {
+        flush()
+      } catch (flushErr) {
+        if (error === undefined) {
+          error = flushErr
+        }
+      }
     }
   }
+  if (error !== undefined) {
+    throw error
+  }
+  return result
 }
 /**
  * Get the current active subscriber
@@ -1335,43 +1347,51 @@ export default {
 }
 export const $state = signal as <T>(value: T) => T
 
-let devtoolsSignalId = 0
-let devtoolsEffectId = 0
-
 interface DevtoolsIdentifiable {
   __id?: number
 }
 
-function registerSignalDevtools(value: unknown, node: SignalNode): number | undefined {
-  const hook = getDevtoolsHook()
-  if (!hook) return undefined
-  const id = ++devtoolsSignalId
-  hook.registerSignal(id, value)
-  ;(node as SignalNode & DevtoolsIdentifiable).__id = id
-  return id
-}
+let registerSignalDevtools: (value: unknown, node: SignalNode) => number | undefined = () =>
+  undefined
+let updateSignalDevtools: (node: SignalNode, value: unknown) => void = () => {}
+let registerEffectDevtools: (node: EffectNode) => number | undefined = () => undefined
+let effectRunDevtools: (node: EffectNode) => void = () => {}
+
+if (isDev) {
+  let devtoolsSignalId = 0
+  let devtoolsEffectId = 0
+
+  registerSignalDevtools = (value, node) => {
+    const hook = getDevtoolsHook()
+    if (!hook) return undefined
+    const id = ++devtoolsSignalId
+    hook.registerSignal(id, value)
+    ;(node as SignalNode & DevtoolsIdentifiable).__id = id
+    return id
+  }
 
-function updateSignalDevtools(node: SignalNode, value: unknown): void {
-  const hook = getDevtoolsHook()
-  if (!hook) return
-  const id = (node as SignalNode & DevtoolsIdentifiable).__id
-  if (id) hook.updateSignal(id, value)
-}
+  updateSignalDevtools = (node, value) => {
+    const hook = getDevtoolsHook()
+    if (!hook) return
+    const id = (node as SignalNode & DevtoolsIdentifiable).__id
+    if (id) hook.updateSignal(id, value)
+  }
 
-function registerEffectDevtools(node: EffectNode): number | undefined {
-  const hook = getDevtoolsHook()
-  if (!hook) return undefined
-  const id = ++devtoolsEffectId
-  hook.registerEffect(id)
-  ;(node as EffectNode & DevtoolsIdentifiable).__id = id
-  return id
-}
+  registerEffectDevtools = node => {
+    const hook = getDevtoolsHook()
+    if (!hook) return undefined
+    const id = ++devtoolsEffectId
+    hook.registerEffect(id)
+    ;(node as EffectNode & DevtoolsIdentifiable).__id = id
+    return id
+  }
 
-function effectRunDevtools(node: EffectNode): void {
-  const hook = getDevtoolsHook()
-  if (!hook) return
-  const id = (node as EffectNode & DevtoolsIdentifiable).__id
-  if (id) hook.effectRun(id)
+  effectRunDevtools = node => {
+    const hook = getDevtoolsHook()
+    if (!hook) return
+    const id = (node as EffectNode & DevtoolsIdentifiable).__id
+    if (id) hook.effectRun(id)
+  }
 }
 
 // ============================================================================

package/src/store.ts

@@ -152,7 +152,13 @@ function getLastValue(target: any, prop: string | symbol) {
  */
 function reconcile(target: any, value: any) {
   if (target === value) return
-  if (value === null || typeof value !== 'object') return // Should replace?
+  if (value === null || typeof value !== 'object') {
+    throw new Error(
+      `[Fict] Cannot replace store with primitive value: ${String(
+        value,
+      )}. setStore should return an object/array to merge.`,
+    )
+  }
 
   const realTarget = unwrap(target)
   const realValue = unwrap(value)
@@ -166,6 +172,11 @@ function reconcile(target: any, value: any) {
       target[key] = realValue[key] // Triggers proxy trap
     }
   }
+
+  // Fix array length if needed
+  if (Array.isArray(target) && target.length !== realValue.length) {
+    target.length = realValue.length
+  }
 }
 
 // ============================================================================
@@ -180,6 +191,29 @@ function reconcile(target: any, value: any) {
 export function createDiffingSignal<T extends object>(initialValue: T) {
   let currentValue = unwrap(initialValue)
   const signals = new Map<string | symbol, SignalAccessor<any>>()
+  let iterateSignal: SignalAccessor<number> | undefined
+
+  const getPropSignal = (prop: string | symbol) => {
+    let s = signals.get(prop)
+    if (!s) {
+      s = signal((currentValue as any)[prop])
+      signals.set(prop, s)
+    }
+    return s
+  }
+
+  const trackIterate = () => {
+    if (!iterateSignal) {
+      iterateSignal = signal(Reflect.ownKeys(currentValue).length)
+    }
+    iterateSignal()
+  }
+
+  const updateIterate = (value: T) => {
+    if (iterateSignal) {
+      iterateSignal(Reflect.ownKeys(value).length)
+    }
+  }
 
   // The stable proxy we return
   const proxy = new Proxy({} as T, {
@@ -188,17 +222,21 @@ export function createDiffingSignal<T extends object>(initialValue: T) {
       if (prop === TARGET) return currentValue
 
       // Subscribe to property
-      let s = signals.get(prop)
-      if (!s) {
-        // Initialize signal with current property value
-        s = signal((currentValue as any)[prop])
-        signals.set(prop, s)
-      }
+      const s = getPropSignal(prop)
       return s()
     },
     ownKeys() {
+      trackIterate()
       return Reflect.ownKeys(currentValue)
     },
+    has(target, prop) {
+      getPropSignal(prop)()
+      return Reflect.has(currentValue, prop)
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      getPropSignal(prop)()
+      return Reflect.getOwnPropertyDescriptor(currentValue, prop)
+    },
   })
 
   const read = () => proxy
@@ -215,6 +253,7 @@ export function createDiffingSignal<T extends object>(initialValue: T) {
         const newVal = (next as any)[prop]
         s(newVal)
       }
+      updateIterate(next)
       return
     }
 
@@ -228,6 +267,7 @@ export function createDiffingSignal<T extends object>(initialValue: T) {
         s(newVal)
       }
     }
+    updateIterate(next)
 
     // Note: If new properties appeared that weren't tracked, we don't care
     // because no one is listening.

package/src/versioned-signal.ts

@@ -1,4 +1,4 @@
-import { createSignal } from './signal'
+import { createSignal, untrack } from './signal'
 
 export interface VersionedSignalOptions<T> {
   equals?: (prev: T, next: T) => boolean
@@ -52,7 +52,7 @@ export function createVersionedSignal<T>(
     force: () => {
       bumpVersion()
     },
-    peekVersion: () => version(),
-    peekValue: () => value(),
+    peekVersion: () => untrack(() => version()),
+    peekValue: () => untrack(() => value()),
   }
 }