@esportsplus/reactivity 0.36.4 → 0.36.5

package/build/system.js

@@ -679,7 +679,12 @@ const read = (node) => {
             }
             let height = node.height;
             if (height >= observer.height) {
+                let queued = observer.state & STATE_IN_HEAP;
+                if (queued)
+                    deleteFromHeap(observer);
                 observer.height = height + 1;
+                if (queued)
+                    insertIntoHeap(observer);
             }
             if (height >= heap_i || node.state & STATE_NOTIFY_MASK) {
                 pull(node);

package/package.json

@@ -36,7 +36,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.36.4",
+  "version": "0.36.5",
   "scripts": {
     "agent:bench": "vitest bench --run",
     "agent:test": "tsc --noEmit && vitest run",

package/src/system.ts

@@ -1006,7 +1006,11 @@ const read = <T>(node: Signal<T> | Computed<T>): T => {
             let height = (node as Computed<T>).height;
 
             if (height >= observer.height) {
+                let queued = observer.state & STATE_IN_HEAP;
+
+                if (queued) deleteFromHeap(observer);
                 observer.height = height + 1;
+                if (queued) insertIntoHeap(observer);
             }
 
             if (height >= heap_i || (node as Computed<T>).state & STATE_NOTIFY_MASK) {

package/test/flush.test.ts

@@ -1,8 +1,56 @@
 import { describe, expect, it } from 'vitest';
-import { batch, computed, effect, flush, read, signal, write } from '~/system';
+import { batch, computed, effect, flush, read, root, signal, write } from '~/system';
 
 
 describe('flush()', () => {
+    it('settles a requeued effect that discovers a deeper computed dependency', () => {
+        let runs = 0,
+            values: number[] = [],
+            trigger = signal(false),
+            source = signal(1);
+
+        let dispose = root((dispose) => {
+            let deep = computed(() => read(source));
+
+            for (let i = 0; i < 4; i++) {
+                let previous = deep;
+                deep = computed(() => read(previous) + 1);
+            }
+
+            effect(() => {
+                runs++;
+
+                if (read(trigger)) {
+                    write(trigger, false);
+                    values.push(read(deep));
+                }
+            });
+
+            return dispose;
+        });
+
+        try {
+            write(trigger, true);
+            flush();
+
+            expect(runs).toBe(3);
+            expect(values).toEqual([5]);
+
+            write(trigger, true);
+            flush();
+
+            expect(runs).toBe(5);
+            expect(values).toEqual([5, 5]);
+        }
+        finally {
+            dispose();
+        }
+
+        write(trigger, true);
+        flush();
+        expect(runs).toBe(5);
+    });
+
     it('runs the dependent effect synchronously before returning', () => {
         let runs = 0,
             s = signal(0);