@wcstack/state 1.19.0 → 1.19.1

package/dist/index.esm.js

@@ -1,10 +1,12 @@
-let _inSsrCache = null;
 function inSsr() {
-    if (_inSsrCache !== null)
-        return _inSsrCache;
-    const html = document.querySelector('html');
-    _inSsrCache = html ? html.hasAttribute('data-wcs-server') : false;
-    return _inSsrCache;
+    // キャッシュしない: SSR モードはプロセスの属性ではなく「現在の document」の
+    // 属性。@wcstack/server はグローバル document を差し替えてサーバーレンダリング
+    // した後、同一プロセスでクライアント側ハイドレーションが走る（SSR→hydrate の
+    // e2e が該当）。サーバーフェーズの判定をキャッシュするとクライアントフェーズが
+    // SSR モード扱いになり、hydrateBindings の代わりに buildBindings が選ばれて
+    // connectedCallbackPromise が永久に未解決になる。
+    const html = document.documentElement;
+    return html ? html.hasAttribute('data-wcs-server') : false;
 }
 const _config = {
     bindAttributeName: 'data-wcs',
@@ -63,7 +65,7 @@ function setConfig(partialConfig) {
     }
 }
 
-var version$1 = "1.19.0";
+var version$1 = "1.19.1";
 var pkg = {
 	version: version$1};
 
@@ -2788,6 +2790,20 @@ function isSameList(oldList, newList) {
     }
     return true;
 }
+/**
+ * Aligns each list index's .index with its position in the new list.
+ * A diff only becomes the rendered state once the updater applies it: an
+ * earlier diff in the same batch (two replacements in one microtask) may have
+ * moved shared indexes toward a list that never got applied, and a cache hit
+ * skips recomputation entirely — so every createListDiff return re-aligns.
+ */
+function syncListIndexes(newIndexes) {
+    for (let i = 0; i < newIndexes.length; i++) {
+        if (newIndexes[i].index !== i) {
+            newIndexes[i].index = i;
+        }
+    }
+}
 /**
  * Creates or updates list indexes by comparing old and new lists.
  * Optimizes by reusing existing list indexes when values match.
@@ -2798,6 +2814,11 @@ function isSameList(oldList, newList) {
  * @returns Array of list indexes for the new list
  */
 function createListDiff(parentListIndex, rawOldList, rawNewList) {
+    const diff = computeListDiff(parentListIndex, rawOldList, rawNewList);
+    syncListIndexes(diff.newIndexes);
+    return diff;
+}
+function computeListDiff(parentListIndex, rawOldList, rawNewList) {
     // Normalize inputs to arrays (handles null/undefined)
     const oldList = (Array.isArray(rawOldList) && rawOldList.length > 0) ? rawOldList : EMPTY_LIST;
     const newList = (Array.isArray(rawNewList) && rawNewList.length > 0) ? rawNewList : EMPTY_LIST;
@@ -2846,6 +2867,10 @@ function createListDiff(parentListIndex, rawOldList, rawNewList) {
                 addIndexSet: EMPTY_SET$1,
             };
         }
+        if (newIndexes !== null) {
+            return calcDiffIndexes(oldIndexes, newIndexes);
+        }
+        newIndexes = [];
         // Use index-based map for efficiency
         // Supports duplicate values by storing array of indexes
         const indexByValue = new Map();
@@ -2858,10 +2883,6 @@ function createListDiff(parentListIndex, rawOldList, rawNewList) {
             }
             indexes.push(i);
         }
-        if (newIndexes !== null) {
-            return calcDiffIndexes(oldList, newList, oldIndexes, newIndexes, indexByValue);
-        }
-        newIndexes = [];
         // Build new indexes array by matching values with old list
         const changeIndexSet = new Set();
         const addIndexSet = new Set();
@@ -2878,9 +2899,11 @@ function createListDiff(parentListIndex, rawOldList, rawNewList) {
             else {
                 // Reuse existing element
                 const existingListIndex = oldIndexes[oldIndex];
-                // Update index if position changed
-                if (existingListIndex.index !== i) {
-                    existingListIndex.index = i;
+                // Judge position change against the old list's order (oldIndexes array
+                // order), not the mutable .index — an earlier diff in the same batch
+                // may have already moved .index toward a list that was never applied.
+                // The .index itself is re-aligned by syncListIndexes on return.
+                if (oldIndex !== i) {
                     changeIndexSet.add(existingListIndex);
                 }
                 newIndexes.push(existingListIndex);
@@ -2902,22 +2925,35 @@ function createListDiff(parentListIndex, rawOldList, rawNewList) {
         }
     }
 }
-function calcDiffIndexes(oldList, newList, oldIndexes, newIndexes, indexByValue) {
+/**
+ * Diff between two lists whose listIndex ledgers both already exist.
+ * Rows are joined by listIndex identity — the same key applyChangeToFor and
+ * walkDependency consume the result sets with. A value-based join could mark
+ * oldIndexes-side objects that are absent from newIndexes (ledgers built along
+ * unconnected diff chains hold different objects for the same value); such
+ * orphan markers never match the consumers' has() lookups and only pollute
+ * the dirty set. Rows without shared identity are represented as add+delete.
+ */
+function calcDiffIndexes(oldIndexes, newIndexes) {
     const newIndexSet = new Set(newIndexes);
     const oldIndexSet = new Set(oldIndexes);
     const changeIndexSet = new Set();
     const addIndexSet = newIndexSet.difference(oldIndexSet);
     const deleteIndexSet = oldIndexSet.difference(newIndexSet);
-    for (let i = 0; i < newList.length; i++) {
-        const newValue = newList[i];
-        const existingIndexes = indexByValue.get(newValue);
-        const oldIndex = existingIndexes && existingIndexes.length > 0 ? existingIndexes.shift() : undefined;
-        if (typeof oldIndex !== "undefined") {
-            const existingListIndex = oldIndexes[oldIndex];
-            if (existingListIndex.index !== i) {
-                // 位置が違うことだけを記録 
-                changeIndexSet.add(existingListIndex);
-            }
+    // Old positions come from the oldIndexes array order (.index may have been
+    // mutated by an unapplied diff in the same batch).
+    const oldPosByIndex = new Map();
+    for (let i = 0; i < oldIndexes.length; i++) {
+        oldPosByIndex.set(oldIndexes[i], i);
+    }
+    for (let i = 0; i < newIndexes.length; i++) {
+        const index = newIndexes[i];
+        if (addIndexSet.has(index)) {
+            continue;
+        }
+        if (oldPosByIndex.get(index) !== i) {
+            // 位置が違うことだけを記録
+            changeIndexSet.add(index);
         }
     }
     return {
@@ -5666,8 +5702,14 @@ class LoopContextStack {
             }
         }
         else {
-            if (loopContext.pathInfo.wildcardCount !== 1) {
-                raiseError(`Cannot push loop context for a list with wildcard positions when there is no active loop context.`);
+            // With no active loop context the address must be self-contained: the
+            // listIndex chain supplies one index per wildcard. Top-level lists
+            // (wildcardCount 1) always satisfy this. A nested list re-rendered
+            // directly (e.g. replaced via $resolve from outside the loop) also
+            // satisfies it — the for binding's listIndex carries the full ancestor
+            // chain.
+            if (loopContext.listIndex.length !== loopContext.pathInfo.wildcardCount) {
+                raiseError(`Cannot push loop context when there is no active loop context: the list index chain (length ${loopContext.listIndex.length}) does not cover the wildcard path (wildcard count ${loopContext.pathInfo.wildcardCount}).`);
             }
         }
         this._loopContextStack[this._length] = loopContext;