@fictjs/runtime 0.0.10 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fictjs/runtime",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Fict reactive runtime",
   "publishConfig": {
     "access": "public",

package/src/effect.ts

@@ -5,7 +5,7 @@ import {
   runCleanupList,
   withEffectCleanups,
 } from './lifecycle'
-import { effect } from './signal'
+import { effectWithCleanup } from './signal'
 import type { Cleanup } from './types'
 
 export type Effect = () => void | Cleanup
@@ -14,8 +14,14 @@ export function createEffect(fn: Effect): () => void {
   let cleanups: Cleanup[] = []
   const rootForError = getCurrentRoot()
 
-  const run = () => {
+  // Cleanup runner - called by runEffect BEFORE signal values are committed
+  const doCleanup = () => {
     runCleanupList(cleanups)
+    cleanups = []
+  }
+
+  const run = () => {
+    // Note: cleanups are now run by signal.ts runEffect before this function is called
     const bucket: Cleanup[] = []
     withEffectCleanups(bucket, () => {
       try {
@@ -33,7 +39,7 @@ export function createEffect(fn: Effect): () => void {
     cleanups = bucket
   }
 
-  const disposeEffect = effect(run)
+  const disposeEffect = effectWithCleanup(run, doCleanup)
   const teardown = () => {
     runCleanupList(cleanups)
     disposeEffect()
@@ -50,11 +56,16 @@ export function createRenderEffect(fn: Effect): () => void {
   let cleanup: Cleanup | undefined
   const rootForError = getCurrentRoot()
 
-  const run = () => {
+  // Cleanup runner - called by runEffect BEFORE signal values are committed
+  const doCleanup = () => {
     if (cleanup) {
       cleanup()
       cleanup = undefined
     }
+  }
+
+  const run = () => {
+    // Note: cleanups are now run by signal.ts runEffect before this function is called
     try {
       const maybeCleanup = fn()
       if (typeof maybeCleanup === 'function') {
@@ -69,7 +80,7 @@ export function createRenderEffect(fn: Effect): () => void {
     }
   }
 
-  const disposeEffect = effect(run)
+  const disposeEffect = effectWithCleanup(run, doCleanup)
   const teardown = () => {
     if (cleanup) {
       cleanup()

package/src/signal.ts

@@ -96,6 +96,10 @@ export interface EffectNode extends BaseNode {
   deps: Link | undefined
   /** Last dependency link */
   depsTail: Link | undefined
+  /** Optional cleanup runner to be called before checkDirty */
+  runCleanup?: () => void
+  /** Devtools ID */
+  __id?: number | undefined
 }
 
 /**
@@ -202,6 +206,8 @@ const enqueueMicrotask =
     : (fn: () => void) => {
         Promise.resolve().then(fn)
       }
+// Flag to indicate cleanup is running - signal reads should return currentValue without updating
+let inCleanup = false
 export const ReactiveFlags = {
   None: 0,
   Mutable,
@@ -735,7 +741,16 @@ function updateComputed<T>(c: ComputedNode<T>): boolean {
  */
 function runEffect(e: EffectNode): void {
   const flags = e.flags
-  if (flags & Dirty || (flags & Pending && e.deps && checkDirty(e.deps, e))) {
+  // Run cleanup BEFORE checkDirty so cleanup sees previous signal values
+  if (flags & Dirty) {
+    if (e.runCleanup) {
+      inCleanup = true
+      try {
+        e.runCleanup()
+      } finally {
+        inCleanup = false
+      }
+    }
     ++cycle
     effectRunDevtools(e)
     e.depsTail = undefined
@@ -752,6 +767,36 @@ function runEffect(e: EffectNode): void {
       e.flags = Watching
       throw err
     }
+  } else if (flags & Pending && e.deps) {
+    // Run cleanup before checkDirty which commits signal values
+    if (e.runCleanup) {
+      inCleanup = true
+      try {
+        e.runCleanup()
+      } finally {
+        inCleanup = false
+      }
+    }
+    if (checkDirty(e.deps, e)) {
+      ++cycle
+      effectRunDevtools(e)
+      e.depsTail = undefined
+      e.flags = WatchingRunning
+      const prevSub = activeSub
+      activeSub = e
+      try {
+        e.fn()
+        activeSub = prevSub
+        e.flags = Watching
+        purgeDeps(e)
+      } catch (err) {
+        activeSub = prevSub
+        e.flags = Watching
+        throw err
+      }
+    } else {
+      e.flags = Watching
+    }
   } else {
     e.flags = Watching
   }
@@ -870,7 +915,8 @@ function signalOper<T>(this: SignalNode<T>, value?: T): T | void {
   }
 
   const flags = this.flags
-  if (flags & Dirty) {
+  // During cleanup, don't update signal - return currentValue as-is
+  if (flags & Dirty && !inCleanup) {
     if (updateSignal(this)) {
       const subs = this.subs
       if (subs !== undefined) shallowPropagate(subs)
@@ -976,6 +1022,44 @@ export function effect(fn: () => void): EffectDisposer {
 
   return effectOper.bind(e) as EffectDisposer
 }
+
+/**
+ * Create a reactive effect with a custom cleanup runner
+ * The cleanup runner is called BEFORE signal values are committed, allowing
+ * cleanup functions to access the previous values of signals.
+ * @param fn - The effect function
+ * @param cleanupRunner - Function to run cleanups before signal value commit
+ * @returns An effect disposer function
+ */
+export function effectWithCleanup(fn: () => void, cleanupRunner: () => void): EffectDisposer {
+  const e: EffectNode = {
+    fn,
+    subs: undefined,
+    subsTail: undefined,
+    deps: undefined,
+    depsTail: undefined,
+    flags: WatchingRunning,
+    runCleanup: cleanupRunner,
+    __id: undefined as number | undefined,
+  }
+
+  registerEffectDevtools(e)
+
+  const prevSub = activeSub
+  if (prevSub !== undefined) link(e, prevSub, 0)
+  activeSub = e
+
+  try {
+    effectRunDevtools(e)
+    fn()
+  } finally {
+    activeSub = prevSub
+    e.flags &= ~Running
+  }
+
+  return effectOper.bind(e) as EffectDisposer
+}
+
 function effectOper(this: EffectNode): void {
   disposeNode(this)
 }