@colyseus/schema 4.0.30 → 4.0.31

package/build/index.js

@@ -1456,6 +1456,33 @@
                 next: this.parentChain
             };
         }
+        /**
+         * Move `parent`'s existing chain entry to `index`, skipping the work
+         * `addParent` does. `parent` must already be a parent of this 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.
+         */
+        setParentIndex(parent, index) {
+            const chain = this.parentChain;
+            if (chain === undefined) {
+                return;
+            }
+            if (chain.next === undefined) {
+                chain.index = 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).
+            for (let entry = chain; entry !== undefined; entry = entry.next) {
+                if (entry.ref[$changes] === parent[$changes]) {
+                    entry.index = index;
+                    return;
+                }
+            }
+        }
         /**
          * Remove a parent from the chain
          * @param parent - The parent to remove
@@ -2092,6 +2119,39 @@
         get length() {
             return this.items.length;
         }
+        /**
+         * 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 an array without `filteredChanges` never has a slot
+         * read back. Everything else stops at that check 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].filteredChanges === undefined) {
+                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);
+            }
+        }
         push(...values) {
             let length = this.tmpItems.length;
             const changeTree = this[$changes];
@@ -2224,6 +2284,7 @@
             this[$changes].operation(exports.OPERATION.REVERSE);
             this.items.reverse();
             this.tmpItems.reverse();
+            this.$reindexChildren(0);
             return this;
         }
         /**
@@ -2267,6 +2328,7 @@
             // wouldn't OPERATION.MOVE make more sense here?
             sortedItems.forEach((_, i) => changeTree.change(i, exports.OPERATION.REPLACE));
             this.tmpItems.sort(compareFn);
+            this.$reindexChildren(0);
             this.isMovingItems = false;
             return this;
         }
@@ -2362,6 +2424,7 @@
                 changeTree.change(index, exports.OPERATION.ADD);
             });
             this.tmpItems.unshift(...items);
+            this.$reindexChildren(0); // from 0: nothing above placed the new items either
             return this.items.unshift(...items);
         }
         /**
@@ -2633,7 +2696,13 @@
             this.tmpItems[index] = undefined; // TODO: do not try to get "tmpItems" at decoding time.
         }
         [$onEncodeEnd]() {
+            const staged = this.tmpItems;
             this.tmpItems = this.items.slice();
+            // Compaction just closed the staged holes — everything above the
+            // lowest one slid down a slot. There is no cheap "were there any"
+            // test to gate this on: `deletedIndexes` is an object here, and a
+            // `for...in` probe measured slower than the prefix scan it skips.
+            this.$reindexChildren(0, staged);
             this.deletedIndexes = {};
         }
         [$onDecodeEnd]() {

package/build/index.mjs

@@ -1450,6 +1450,33 @@ class ChangeTree {
             next: this.parentChain
         };
     }
+    /**
+     * Move `parent`'s existing chain entry to `index`, skipping the work
+     * `addParent` does. `parent` must already be a parent of this 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.
+     */
+    setParentIndex(parent, index) {
+        const chain = this.parentChain;
+        if (chain === undefined) {
+            return;
+        }
+        if (chain.next === undefined) {
+            chain.index = 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).
+        for (let entry = chain; entry !== undefined; entry = entry.next) {
+            if (entry.ref[$changes] === parent[$changes]) {
+                entry.index = index;
+                return;
+            }
+        }
+    }
     /**
      * Remove a parent from the chain
      * @param parent - The parent to remove
@@ -2086,6 +2113,39 @@ class ArraySchema {
     get length() {
         return this.items.length;
     }
+    /**
+     * 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 an array without `filteredChanges` never has a slot
+     * read back. Everything else stops at that check 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].filteredChanges === undefined) {
+            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);
+        }
+    }
     push(...values) {
         let length = this.tmpItems.length;
         const changeTree = this[$changes];
@@ -2218,6 +2278,7 @@ class ArraySchema {
         this[$changes].operation(OPERATION.REVERSE);
         this.items.reverse();
         this.tmpItems.reverse();
+        this.$reindexChildren(0);
         return this;
     }
     /**
@@ -2261,6 +2322,7 @@ class ArraySchema {
         // wouldn't OPERATION.MOVE make more sense here?
         sortedItems.forEach((_, i) => changeTree.change(i, OPERATION.REPLACE));
         this.tmpItems.sort(compareFn);
+        this.$reindexChildren(0);
         this.isMovingItems = false;
         return this;
     }
@@ -2356,6 +2418,7 @@ class ArraySchema {
             changeTree.change(index, OPERATION.ADD);
         });
         this.tmpItems.unshift(...items);
+        this.$reindexChildren(0); // from 0: nothing above placed the new items either
         return this.items.unshift(...items);
     }
     /**
@@ -2627,7 +2690,13 @@ class ArraySchema {
         this.tmpItems[index] = undefined; // TODO: do not try to get "tmpItems" at decoding time.
     }
     [$onEncodeEnd]() {
+        const staged = this.tmpItems;
         this.tmpItems = this.items.slice();
+        // Compaction just closed the staged holes — everything above the
+        // lowest one slid down a slot. There is no cheap "were there any"
+        // test to gate this on: `deletedIndexes` is an object here, and a
+        // `for...in` probe measured slower than the prefix scan it skips.
+        this.$reindexChildren(0, staged);
         this.deletedIndexes = {};
     }
     [$onDecodeEnd]() {