@cplieger/reactive 1.3.0 → 1.3.1

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/reactive",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "license": "Apache-2.0",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/reactive",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -20,7 +20,7 @@
     "@vitest/coverage-v8": "4.1.11",
     "eslint": "10.8.1",
     "fast-check": "4.9.0",
-    "happy-dom": "20.11.2",
+    "happy-dom": "20.11.6",
     "prettier": "3.9.6",
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "typescript-eslint": "8.67.0",

package/src/reconcile-tree.ts

@@ -57,6 +57,15 @@ export function reconcileChildren(parent: Node, newChildren: Node[]): void {
   }
 
   let oldIdx = 0;
+  // Old nodes already placed as the resolved child for an earlier index. The
+  // keyed path cannot hand one back — each key is consumed from its FIFO queue —
+  // but `oldChildren` is a SNAPSHOT taken before the loop, so a node still
+  // occupying its original slot there can be handed back by the positional scan
+  // after it has been placed. That happens when the caller re-renders a parent
+  // with its own current children reordered (drag-and-drop, sort): a match on an
+  // already-placed node either removes it as a tag mismatch or patches over it
+  // as a tag match, and either way a child the caller asked for is lost.
+  const placed = new Set<Node>();
   for (let i = 0; i < newChildren.length; i++) {
     const newChild = newChildren[i];
     if (newChild === undefined) {
@@ -82,7 +91,7 @@ export function reconcileChildren(parent: Node, newChildren: Node[]): void {
       // node would corrupt a node that key-matching also reuses in the same pass.
       while (oldIdx < oldChildren.length) {
         const oc = oldChildren[oldIdx];
-        if (oc !== undefined && !nodeKey(oc)) {
+        if (oc !== undefined && !nodeKey(oc) && !placed.has(oc)) {
           break;
         }
         oldIdx++;
@@ -110,6 +119,7 @@ export function reconcileChildren(parent: Node, newChildren: Node[]): void {
       // keyed node. The insert and patch branches already target index i.
       const ref = parent.childNodes.item(i);
       parent.insertBefore(newChild, ref);
+      placed.add(newChild);
       parent.removeChild(matched);
       continue;
     }

package/src/signal.ts

@@ -373,12 +373,20 @@ function endBatch(): void {
   if (--batchDepth > 0) {
     return;
   }
+  // The drain is re-entrant: a write, a batch() or a flushSync() from an effect
+  // body sees batchDepth back at 0 and starts a nested drain, and the cycle guard
+  // below counts on those nested passes — a two-effect ping-pong recurses one
+  // level per pass rather than looping here. So a nested drain must RESTORE the
+  // count it inherited instead of zeroing it: zeroing let any nested drain,
+  // including a flushSync() that found nothing to flush, wipe the passes the
+  // enclosing drain had accumulated and multiply the effective cap.
+  const enclosingIteration = batchIteration;
   while (batchedEffect !== undefined) {
     let eff: EffectNode | undefined = batchedEffect;
     batchedEffect = undefined;
     batchIteration++;
     if (batchIteration > MAX_BATCH_ITERATIONS) {
-      batchIteration = 0;
+      batchIteration = enclosingIteration;
       // Un-notify the chain we are dropping: notifyTargets skips a NOTIFIED
       // effect, so an effect left NOTIFIED here could never be queued again —
       // bailing would silently deafen every effect in flight, including
@@ -402,7 +410,7 @@ function endBatch(): void {
       eff = next;
     }
   }
-  batchIteration = 0;
+  batchIteration = enclosingIteration;
 }
 
 function runCleanup(eff: EffectNode): void {