@colyseus/schema 5.0.12 → 5.0.13

package/build/index.js

@@ -1918,6 +1918,34 @@
             tree._parentIndex = index;
         }
     }
+    /**
+     * Move `parent`'s existing chain entry to `index`, skipping the attachment
+     * work `addParent` does. `parent` must already be a parent of `tree`.
+     *
+     * Called by collections whose wire slots shift (ArraySchema): StateView
+     * addresses per-view ADD/DELETE by that index, so it has to follow the
+     * element it names.
+     */
+    function setParentIndex(tree, parent, index) {
+        if (tree.extraParents === undefined) {
+            tree._parentIndex = index; // sole parent, so it is `parent`
+            return;
+        }
+        // Shared instance — move only the entry `parent` owns. Matching goes
+        // through `$changes` because ArraySchema arrives proxied (see removeParent
+        // below), and `extraParents` only ever fills by demoting `parentRef`, so
+        // the inline parent is set here.
+        if (tree.parentRef[$changes] === parent[$changes]) {
+            tree._parentIndex = index;
+            return;
+        }
+        for (let entry = tree.extraParents; entry !== undefined; entry = entry.next) {
+            if (entry.ref[$changes] === parent[$changes]) {
+                entry.index = index;
+                return;
+            }
+        }
+    }
     /**
      * Remove a parent from the chain.
      * @returns true if parent was found and removed (Root.remove relies on this).
@@ -3162,6 +3190,8 @@
         get parent() { return this.parentRef; }
         get parentIndex() { return this._parentIndex; }
         addParent(parent, index) { addParent(this, parent, index); }
+        /** Re-point an existing parent's cached index after the parent reindexed. */
+        setParentIndex(parent, index) { setParentIndex(this, parent, index); }
         /** @returns true if parent was found and removed */
         removeParent(parent = this.parent) { return removeParent(this, parent); }
         findParent(predicate) {
@@ -3206,6 +3236,7 @@
         operation() { }
         setParent() { }
         addParent() { }
+        setParentIndex() { }
         removeParent() { return false; }
         getChange() { return 0; }
         discard() { }
@@ -4261,6 +4292,40 @@
             // beyond the live range: appends land after the staged tmpItems tail
             return tmpItems.length + (index - live);
         }
+        /**
+         * Re-point children at their wire slot. `ChangeTree._parentIndex` caches
+         * the slot a child holds in `tmpItems`, and StateView addresses per-view
+         * ADD/DELETE with it — so a reorder that leaves it behind aims those ops
+         * at whichever element inherited the slot (issue #231).
+         *
+         * The filter check is a correctness boundary, not a tunable: StateView is
+         * the only reader and reaches the index only through a filtered array
+         * (`addParentOf` bails on `hasFilteredFields`, `remove` on the child's
+         * `isFiltered`). Everything else stops at the flag read instead of walking
+         * its children every tick.
+         *
+         * Callers name the lowest slot that moved as `from`. Compaction cannot, so
+         * it hands over the pre-compaction layout as `staged` and the unchanged
+         * prefix is skipped instead. Either way tail churn walks nothing.
+         */
+        $reindexChildren(from, staged) {
+            if (!this[$changes].hasFilteredFields) {
+                return;
+            } // nothing will read the cache
+            if (typeof this[$childType] === "string") {
+                return;
+            } // primitives have no child tree
+            const tmpItems = this.tmpItems;
+            const length = tmpItems.length;
+            if (staged !== undefined) {
+                while (from < length && tmpItems[from] === staged[from]) {
+                    from++;
+                }
+            }
+            for (let i = from; i < length; i++) {
+                tmpItems[i]?.[$changes]?.setParentIndex(this, i);
+            }
+        }
         // encoding only. Returns the wire index the change was recorded at
         // (undefined when nothing was recorded).
         $changeAt(index, value) {
@@ -4372,6 +4437,7 @@
             self[$changes].operation(exports.OPERATION.REVERSE);
             self.items.reverse();
             self.tmpItems.reverse();
+            self.$reindexChildren(0);
             return this;
         }
         /**
@@ -4423,6 +4489,7 @@
             // wouldn't OPERATION.MOVE make more sense here?
             sortedItems.forEach((_, i) => changeTree.change(i, exports.OPERATION.REPLACE));
             self.tmpItems.sort(compareFn);
+            self.$reindexChildren(0);
             self.isMovingItems = false;
             return this;
         }
@@ -4504,6 +4571,7 @@
                 deletedIndexes.unshift(...new Array(items.length).fill(false));
             }
             self.tmpItems.unshift(...items);
+            self.$reindexChildren(items.length); // survivors only — the loop above placed the new items
             return self.items.unshift(...items);
         }
         /**
@@ -4772,8 +4840,14 @@
         }
         [$onEncodeEnd]() {
             const self = this[$proxyTarget] ?? this;
+            const staged = self.tmpItems;
             self.tmpItems = self.items.slice();
-            self.deletedIndexes.length = 0;
+            if (self.deletedIndexes.length > 0) {
+                // compaction just closed the staged holes — everything above the
+                // lowest one slid down a slot
+                self.$reindexChildren(0, staged);
+                self.deletedIndexes.length = 0;
+            }
         }
         [$onDecodeEnd]() {
             const self = this[$proxyTarget] ?? this;

package/build/index.mjs

@@ -1912,6 +1912,34 @@ function addParent(tree, parent, index) {
         tree._parentIndex = index;
     }
 }
+/**
+ * Move `parent`'s existing chain entry to `index`, skipping the attachment
+ * work `addParent` does. `parent` must already be a parent of `tree`.
+ *
+ * Called by collections whose wire slots shift (ArraySchema): StateView
+ * addresses per-view ADD/DELETE by that index, so it has to follow the
+ * element it names.
+ */
+function setParentIndex(tree, parent, index) {
+    if (tree.extraParents === undefined) {
+        tree._parentIndex = index; // sole parent, so it is `parent`
+        return;
+    }
+    // Shared instance — move only the entry `parent` owns. Matching goes
+    // through `$changes` because ArraySchema arrives proxied (see removeParent
+    // below), and `extraParents` only ever fills by demoting `parentRef`, so
+    // the inline parent is set here.
+    if (tree.parentRef[$changes] === parent[$changes]) {
+        tree._parentIndex = index;
+        return;
+    }
+    for (let entry = tree.extraParents; entry !== undefined; entry = entry.next) {
+        if (entry.ref[$changes] === parent[$changes]) {
+            entry.index = index;
+            return;
+        }
+    }
+}
 /**
  * Remove a parent from the chain.
  * @returns true if parent was found and removed (Root.remove relies on this).
@@ -3156,6 +3184,8 @@ class ChangeTree {
     get parent() { return this.parentRef; }
     get parentIndex() { return this._parentIndex; }
     addParent(parent, index) { addParent(this, parent, index); }
+    /** Re-point an existing parent's cached index after the parent reindexed. */
+    setParentIndex(parent, index) { setParentIndex(this, parent, index); }
     /** @returns true if parent was found and removed */
     removeParent(parent = this.parent) { return removeParent(this, parent); }
     findParent(predicate) {
@@ -3200,6 +3230,7 @@ class UntrackedChangeTree {
     operation() { }
     setParent() { }
     addParent() { }
+    setParentIndex() { }
     removeParent() { return false; }
     getChange() { return 0; }
     discard() { }
@@ -4255,6 +4286,40 @@ class ArraySchema {
         // beyond the live range: appends land after the staged tmpItems tail
         return tmpItems.length + (index - live);
     }
+    /**
+     * Re-point children at their wire slot. `ChangeTree._parentIndex` caches
+     * the slot a child holds in `tmpItems`, and StateView addresses per-view
+     * ADD/DELETE with it — so a reorder that leaves it behind aims those ops
+     * at whichever element inherited the slot (issue #231).
+     *
+     * The filter check is a correctness boundary, not a tunable: StateView is
+     * the only reader and reaches the index only through a filtered array
+     * (`addParentOf` bails on `hasFilteredFields`, `remove` on the child's
+     * `isFiltered`). Everything else stops at the flag read instead of walking
+     * its children every tick.
+     *
+     * Callers name the lowest slot that moved as `from`. Compaction cannot, so
+     * it hands over the pre-compaction layout as `staged` and the unchanged
+     * prefix is skipped instead. Either way tail churn walks nothing.
+     */
+    $reindexChildren(from, staged) {
+        if (!this[$changes].hasFilteredFields) {
+            return;
+        } // nothing will read the cache
+        if (typeof this[$childType] === "string") {
+            return;
+        } // primitives have no child tree
+        const tmpItems = this.tmpItems;
+        const length = tmpItems.length;
+        if (staged !== undefined) {
+            while (from < length && tmpItems[from] === staged[from]) {
+                from++;
+            }
+        }
+        for (let i = from; i < length; i++) {
+            tmpItems[i]?.[$changes]?.setParentIndex(this, i);
+        }
+    }
     // encoding only. Returns the wire index the change was recorded at
     // (undefined when nothing was recorded).
     $changeAt(index, value) {
@@ -4366,6 +4431,7 @@ class ArraySchema {
         self[$changes].operation(OPERATION.REVERSE);
         self.items.reverse();
         self.tmpItems.reverse();
+        self.$reindexChildren(0);
         return this;
     }
     /**
@@ -4417,6 +4483,7 @@ class ArraySchema {
         // wouldn't OPERATION.MOVE make more sense here?
         sortedItems.forEach((_, i) => changeTree.change(i, OPERATION.REPLACE));
         self.tmpItems.sort(compareFn);
+        self.$reindexChildren(0);
         self.isMovingItems = false;
         return this;
     }
@@ -4498,6 +4565,7 @@ class ArraySchema {
             deletedIndexes.unshift(...new Array(items.length).fill(false));
         }
         self.tmpItems.unshift(...items);
+        self.$reindexChildren(items.length); // survivors only — the loop above placed the new items
         return self.items.unshift(...items);
     }
     /**
@@ -4766,8 +4834,14 @@ class ArraySchema {
     }
     [$onEncodeEnd]() {
         const self = this[$proxyTarget] ?? this;
+        const staged = self.tmpItems;
         self.tmpItems = self.items.slice();
-        self.deletedIndexes.length = 0;
+        if (self.deletedIndexes.length > 0) {
+            // compaction just closed the staged holes — everything above the
+            // lowest one slid down a slot
+            self.$reindexChildren(0, staged);
+            self.deletedIndexes.length = 0;
+        }
     }
     [$onDecodeEnd]() {
         const self = this[$proxyTarget] ?? this;