@fictjs/runtime 0.0.13 → 0.0.14

package/src/props.ts

@@ -122,38 +122,46 @@ export function mergeProps<T extends Record<string, unknown>>(
     return unwrapProps(value as T)
   }
 
+  const hasProp = (prop: string | symbol) => {
+    for (const src of validSources) {
+      const raw = resolveSource(src)
+      if (raw && prop in raw) {
+        return true
+      }
+    }
+    return false
+  }
+
+  const readProp = (prop: string | symbol) => {
+    // Only return undefined if no source has this Symbol property
+    // Search sources in reverse order (last wins)
+    for (let i = validSources.length - 1; i >= 0; i--) {
+      const src = validSources[i]!
+      const raw = resolveSource(src)
+      if (!raw || !(prop in raw)) continue
+
+      const value = (raw as Record<string | symbol, unknown>)[prop]
+      // Preserve prop getters - let child component's createPropsProxy unwrap lazily
+      // Note: For Symbol properties, we still wrap in getter if source is dynamic
+      if (typeof src === 'function' && !isPropGetter(value)) {
+        return __fictProp(() => {
+          const latest = resolveSource(src)
+          if (!latest || !(prop in latest)) return undefined
+          return (latest as Record<string | symbol, unknown>)[prop]
+        })
+      }
+      return value
+    }
+    return undefined
+  }
+
   return new Proxy({} as Record<string, unknown>, {
     get(_, prop) {
-      // Only return undefined if no source has this Symbol property
-      // Search sources in reverse order (last wins)
-      for (let i = validSources.length - 1; i >= 0; i--) {
-        const src = validSources[i]!
-        const raw = resolveSource(src)
-        if (!raw || !(prop in raw)) continue
-
-        const value = (raw as Record<string | symbol, unknown>)[prop]
-        // Preserve prop getters - let child component's createPropsProxy unwrap lazily
-        // Note: For Symbol properties, we still wrap in getter if source is dynamic
-        if (typeof src === 'function' && !isPropGetter(value)) {
-          return __fictProp(() => {
-            const latest = resolveSource(src)
-            if (!latest || !(prop in latest)) return undefined
-            return (latest as Record<string | symbol, unknown>)[prop]
-          })
-        }
-        return value
-      }
-      return undefined
+      return readProp(prop)
     },
 
     has(_, prop) {
-      for (const src of validSources) {
-        const raw = resolveSource(src)
-        if (raw && prop in raw) {
-          return true
-        }
-      }
-      return false
+      return hasProp(prop)
     },
 
     ownKeys() {
@@ -170,21 +178,12 @@ export function mergeProps<T extends Record<string, unknown>>(
     },
 
     getOwnPropertyDescriptor(_, prop) {
-      for (let i = validSources.length - 1; i >= 0; i--) {
-        const raw = resolveSource(validSources[i]!)
-        if (raw && prop in raw) {
-          return {
-            enumerable: true,
-            configurable: true,
-            get: () => {
-              const value = (raw as Record<string | symbol, unknown>)[prop]
-              // Preserve prop getters - let child component's createPropsProxy unwrap lazily
-              return value
-            },
-          }
-        }
+      if (!hasProp(prop)) return undefined
+      return {
+        enumerable: true,
+        configurable: true,
+        get: () => readProp(prop),
       }
-      return undefined
     },
   })
 }
@@ -192,19 +191,22 @@ export function mergeProps<T extends Record<string, unknown>>(
 export type PropGetter<T> = (() => T) & { __fictProp: true }
 /**
  * Memoize a prop getter to cache expensive computations.
- * Use when prop expressions involve heavy calculations.
+ * Use when prop expressions involve heavy calculations or you need lazy, reactive props.
  *
  * @example
  * ```tsx
- * // Without useProp - recomputes on every access
+ * // Without prop - recomputes on every access
  * <Child data={expensiveComputation(list, filter)} />
  *
- * // With useProp - cached until dependencies change, auto-unwrapped by props proxy
- * const memoizedData = useProp(() => expensiveComputation(list, filter))
+ * // With prop - cached until dependencies change, auto-unwrapped by props proxy
+ * const memoizedData = prop(() => expensiveComputation(list, filter))
  * <Child data={memoizedData} />
  * ```
  */
-export function useProp<T>(getter: () => T): PropGetter<T> {
+export function prop<T>(getter: () => T): PropGetter<T> {
+  if (isPropGetter(getter)) {
+    return getter as PropGetter<T>
+  }
   // Wrap in prop so component props proxy auto-unwraps when passed down.
   return __fictProp(createMemo(getter)) as PropGetter<T>
 }

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()),
   }
 }