@wcstack/state 1.21.1 → 1.21.3

package/dist/index.esm.js

@@ -3332,6 +3332,38 @@ let nextRecordId = 0;
 let nextGeneration = 0;
 const recordByBinding = new WeakMap();
 const sessionByRoot = new WeakMap();
+// node → その node に関心を持つ session（anchor として binding を覚えている、
+// または定義待ちタスクを抱えている）。BindingOwner は mutation で増減した
+// サブツリーを1回だけ走査し、ここに登録された session だけへ per-node 配送する。
+// 全 session ブロードキャストだと、リスト行の逐次 append などで
+// 「session 数 × 変異ノード数」の O(n²) ファンアウトになるため、その正本台帳。
+// 大多数の node は関心 session が1つなので単一値で持ち、2つ目から Set に昇格する。
+const interestedSessionsByNode = new WeakMap();
+function addInterestedSession(node, session) {
+    const current = interestedSessionsByNode.get(node);
+    if (typeof current === "undefined") {
+        interestedSessionsByNode.set(node, session);
+        return;
+    }
+    if (current === session)
+        return;
+    if (current instanceof Set) {
+        current.add(session);
+        return;
+    }
+    interestedSessionsByNode.set(node, new Set([current, session]));
+}
+function forEachInterestedSession(node, callback) {
+    const current = interestedSessionsByNode.get(node);
+    if (typeof current === "undefined")
+        return;
+    if (current instanceof Set) {
+        for (const session of Array.from(current))
+            callback(session);
+        return;
+    }
+    callback(current);
+}
 function forEachInclusive(root, callback) {
     callback(root);
     for (const child of Array.from(root.childNodes)) {
@@ -3350,8 +3382,6 @@ function observableRootFor(node) {
 }
 class BindingOwner {
     root;
-    sessionRefs = new Set();
-    knownSessions = new WeakSet();
     observer;
     constructor(root) {
         this.root = root;
@@ -3361,12 +3391,6 @@ class BindingOwner {
             : null;
         this.observer?.observe(root, { childList: true, subtree: true });
     }
-    add(session) {
-        if (this.knownSessions.has(session))
-            return;
-        this.knownSessions.add(session);
-        this.sessionRefs.add(new WeakRef(session));
-    }
     handleMutations(mutations) {
         const removed = [];
         const added = [];
@@ -3374,14 +3398,29 @@ class BindingOwner {
             removed.push(...Array.from(mutation.removedNodes));
             added.push(...Array.from(mutation.addedNodes));
         }
-        for (const ref of Array.from(this.sessionRefs)) {
-            const session = ref.deref();
-            if (typeof session === "undefined") {
-                this.sessionRefs.delete(ref);
-                continue;
-            }
-            session.handleMutations(this.root, removed, added);
+        // 走査は owner が1回だけ行い、関心 session が居る node だけを配送・contains
+        // 検査へ進める。contains は O(木の深さ) なので、関心の無い node で呼ばない。
+        const reconnected = [];
+        for (const subtree of removed) {
+            forEachInclusive(subtree, (node) => {
+                forEachInterestedSession(node, (session) => {
+                    if (this.root.contains(node))
+                        return;
+                    session.handleRemovedNode(node);
+                });
+            });
+        }
+        for (const subtree of added) {
+            forEachInclusive(subtree, (node) => {
+                forEachInterestedSession(node, (session) => {
+                    if (!this.root.contains(node))
+                        return;
+                    session.handleAddedNode(node, reconnected);
+                });
+            });
         }
+        if (reconnected.length > 0)
+            applyChangeFromBindings(reconnected);
     }
 }
 const ownerByRoot = new WeakMap();
@@ -3477,6 +3516,7 @@ class BindingSession {
             raiseError(`CustomElementRegistry is unavailable for <${tagName}>.`);
         }
         this.observe(node);
+        addInterestedSession(node, this);
         const task = { node, active: true, cancel: null };
         let tasks = this.deferredByNode.get(node);
         if (typeof tasks === "undefined") {
@@ -3534,27 +3574,17 @@ class BindingSession {
         const root = observableRootFor(node);
         if (root === null)
             return;
-        getBindingOwner(root).add(this);
+        // owner（root ごとの MutationObserver）の存在だけ保証する。session の配送先
+        // 登録は node 単位（interestedSessionsByNode）で行い、owner は session を
+        // 直接は保持しない。
+        getBindingOwner(root);
     }
     handleMutations(root, removed, added) {
         for (const subtree of removed) {
             forEachInclusive(subtree, (node) => {
                 if (root.contains(node))
                     return;
-                const known = this.knownBindingsByNode.get(node);
-                if (typeof known !== "undefined") {
-                    for (const binding of known.values())
-                        this.disposeBinding(binding);
-                }
-                const tasks = this.deferredByNode.get(node);
-                if (typeof tasks !== "undefined") {
-                    for (const task of Array.from(tasks)) {
-                        task.active = false;
-                        task.cancel?.();
-                        tasks.delete(task);
-                        this.deferred.delete(task);
-                    }
-                }
+                this.handleRemovedNode(node);
             });
         }
         const reconnected = [];
@@ -3562,36 +3592,58 @@ class BindingSession {
             forEachInclusive(subtree, (node) => {
                 if (!root.contains(node))
                     return;
-                const known = this.knownBindingsByNode.get(node);
-                if (typeof known === "undefined")
-                    return;
-                for (const binding of known.values()) {
-                    const record = recordByBinding.get(binding);
-                    if (record?.phase === "active") {
-                        this.settleConnectedSnapshot(record);
-                        continue;
-                    }
-                    if (record?.phase !== "disposed")
-                        continue;
-                    const options = this.optionsByBinding.get(binding);
-                    if (typeof options === "undefined")
-                        continue;
-                    try {
-                        this.start(binding, options);
-                        if (options.applyOnReconnect && this.shouldApplyState(binding))
-                            reconnected.push(binding);
-                    }
-                    catch {
-                        // Mutation delivery cannot surface initialization errors to a caller.
-                    }
-                }
+                this.handleAddedNode(node, reconnected);
             });
         }
         if (reconnected.length > 0)
             applyChangeFromBindings(reconnected);
     }
+    handleRemovedNode(node) {
+        const known = this.knownBindingsByNode.get(node);
+        if (typeof known !== "undefined") {
+            for (const binding of known.values())
+                this.disposeBinding(binding);
+        }
+        const tasks = this.deferredByNode.get(node);
+        if (typeof tasks !== "undefined") {
+            for (const task of Array.from(tasks)) {
+                task.active = false;
+                task.cancel?.();
+                tasks.delete(task);
+                this.deferred.delete(task);
+            }
+        }
+    }
+    handleAddedNode(node, reconnected) {
+        const known = this.knownBindingsByNode.get(node);
+        if (typeof known === "undefined")
+            return;
+        for (const binding of known.values()) {
+            const record = recordByBinding.get(binding);
+            if (record?.phase === "active") {
+                this.settleConnectedSnapshot(record);
+                continue;
+            }
+            if (record?.phase !== "disposed")
+                continue;
+            const options = this.optionsByBinding.get(binding);
+            if (typeof options === "undefined")
+                continue;
+            try {
+                this.start(binding, options);
+                if (options.applyOnReconnect && this.shouldApplyState(binding))
+                    reconnected.push(binding);
+            }
+            catch {
+                // Mutation delivery cannot surface initialization errors to a caller.
+            }
+        }
+    }
     remember(binding, options) {
         const anchor = binding.replaceNode;
+        // detached fragment 上でも登録しておく（node 単位の台帳なので root 非依存）。
+        // fragment 一括マウントで後から接続された行にも mutation 配送が届くようにする。
+        addInterestedSession(anchor, this);
         let known = this.knownBindingsByNode.get(anchor);
         if (typeof known === "undefined") {
             known = new Map();
@@ -6058,7 +6110,7 @@ async function buildBindings(root) {
     }
 }
 
-var version = "1.21.1";
+var version = "1.21.3";
 var pkg = {
 	version: version};