@colyseus/schema 5.0.12 → 5.0.13

package/build/encoder/ChangeTree.d.ts

@@ -251,6 +251,8 @@ export declare class ChangeTree<T extends Ref = any> implements ChangeRecorder {
     get parent(): Ref | undefined;
     get parentIndex(): number | undefined;
     addParent(parent: Ref, index: number): void;
+    /** Re-point an existing parent's cached index after the parent reindexed. */
+    setParentIndex(parent: Ref, index: number): void;
     /** @returns true if parent was found and removed */
     removeParent(parent?: Ref): boolean;
     findParent(predicate: (parent: Ref, index: number) => boolean): ParentChain | undefined;
@@ -288,6 +290,7 @@ export declare class UntrackedChangeTree {
     operation(): void;
     setParent(): void;
     addParent(): void;
+    setParentIndex(): void;
     removeParent(): boolean;
     getChange(): number;
     discard(): void;

package/build/encoder/changeTree/parentChain.d.ts

@@ -5,6 +5,15 @@ import type { ChangeTree, ParentChain, Ref } from "../ChangeTree.js";
  * behavior).
  */
 export declare function addParent(tree: ChangeTree, parent: Ref, index: number): void;
+/**
+ * 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.
+ */
+export declare function setParentIndex(tree: ChangeTree, parent: Ref, index: number): void;
 /**
  * Remove a parent from the chain.
  * @returns true if parent was found and removed (Root.remove relies on this).

package/build/index.cjs

@@ -1914,6 +1914,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).
@@ -3158,6 +3186,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) {
@@ -3202,6 +3232,7 @@ class UntrackedChangeTree {
     operation() { }
     setParent() { }
     addParent() { }
+    setParentIndex() { }
     removeParent() { return false; }
     getChange() { return 0; }
     discard() { }
@@ -4257,6 +4288,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) {
@@ -4368,6 +4433,7 @@ class ArraySchema {
         self[$changes].operation(exports.OPERATION.REVERSE);
         self.items.reverse();
         self.tmpItems.reverse();
+        self.$reindexChildren(0);
         return this;
     }
     /**
@@ -4419,6 +4485,7 @@ class ArraySchema {
         // 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;
     }
@@ -4500,6 +4567,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);
     }
     /**
@@ -4768,8 +4836,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;