@colyseus/schema 3.0.57 → 3.0.60

package/src/encoder/Root.ts

@@ -1,6 +1,7 @@
 import { OPERATION } from "../encoding/spec";
 import { TypeContext } from "../types/TypeContext";
 import { ChangeTree, setOperationAtIndex, ChangeTreeList, createChangeTreeList, ChangeSetName, type ChangeTreeNode } from "./ChangeTree";
+import { $changes } from "../types/symbols";
 
 export class Root {
     protected nextUniqueId: number = 0;
@@ -83,8 +84,8 @@ export class Root {
                         this.remove(child);
 
                     } else if (child.parentChain) {
-                        // re-assigning a child of the same root, move it to the end
-                        this.moveToEndOfChanges(child);
+                        // re-assigning a child of the same root, move it next to parent
+                        this.moveNextToParent(child);
                     }
                 }
             });
@@ -94,36 +95,57 @@ export class Root {
 
             //
             // When losing a reference to an instance, it is best to move the
-            // ChangeTree to the end of the encoding queue.
+            // ChangeTree next to its parent in the encoding queue.
             //
             // This way, at decoding time, the instance that contains the
             // ChangeTree will be available before the ChangeTree itself. If the
             // containing instance is not available, the Decoder will throw
             // "refId not found" error.
             //
-            this.moveToEndOfChanges(changeTree);
-            changeTree.forEachChild((child, _) => this.moveToEndOfChanges(child));
+            this.recursivelyMoveNextToParent(changeTree);
         }
 
         return refCount;
     }
 
-    moveToEndOfChanges(changeTree: ChangeTree) {
+    recursivelyMoveNextToParent(changeTree: ChangeTree) {
+        this.moveNextToParent(changeTree);
+        changeTree.forEachChild((child, _) => this.recursivelyMoveNextToParent(child));
+    }
+
+    moveNextToParent(changeTree: ChangeTree) {
         if (changeTree.filteredChanges) {
-            this.moveToEndOfChangeTreeList("filteredChanges", changeTree);
-            this.moveToEndOfChangeTreeList("allFilteredChanges", changeTree);
+            this.moveNextToParentInChangeTreeList("filteredChanges", changeTree);
+            this.moveNextToParentInChangeTreeList("allFilteredChanges", changeTree);
         } else {
-            this.moveToEndOfChangeTreeList("changes", changeTree);
-            this.moveToEndOfChangeTreeList("allChanges", changeTree);
+            this.moveNextToParentInChangeTreeList("changes", changeTree);
+            this.moveNextToParentInChangeTreeList("allChanges", changeTree);
         }
     }
 
-    moveToEndOfChangeTreeList(changeSetName: ChangeSetName, changeTree: ChangeTree): void {
+    moveNextToParentInChangeTreeList(changeSetName: ChangeSetName, changeTree: ChangeTree): void {
         const changeSet = this[changeSetName];
         const node = changeTree[changeSetName].queueRootNode;
-        if (!node || node === changeSet.tail) return;
+        if (!node) return;
+
+        // Find the parent in the linked list
+        const parent = changeTree.parent;
+        if (!parent || !parent[$changes]) return;
+
+        const parentNode = parent[$changes][changeSetName]?.queueRootNode;
+        if (!parentNode || parentNode === node) return;
+
+        // Use cached positions - no iteration needed!
+        const parentPosition = parentNode.position;
+        const childPosition = node.position;
 
-        // Remove from current position
+        // If child is already after parent, no need to move
+        if (childPosition > parentPosition) return;
+
+        // Child is before parent, so we need to move it after parent
+        // This maintains decoding order (parent before child)
+
+        // Remove node from current position
         if (node.prev) {
             node.prev.next = node.next;
         } else {
@@ -136,17 +158,20 @@ export class Root {
             changeSet.tail = node.prev;
         }
 
-        // Add to end
-        node.prev = changeSet.tail;
-        node.next = undefined;
+        // Insert node right after parent
+        node.prev = parentNode;
+        node.next = parentNode.next;
 
-        if (changeSet.tail) {
-            changeSet.tail.next = node;
+        if (parentNode.next) {
+            parentNode.next.prev = node;
         } else {
-            changeSet.next = node;
+            changeSet.tail = node;
         }
 
-        changeSet.tail = node;
+        parentNode.next = node;
+
+        // Update positions after the move
+        this.updatePositionsAfterMove(changeSet, node, parentPosition + 1);
     }
 
     public enqueueChangeTree(
@@ -162,7 +187,12 @@ export class Root {
     }
 
     protected addToChangeTreeList(list: ChangeTreeList, changeTree: ChangeTree): ChangeTreeNode {
-        const node: ChangeTreeNode = { changeTree, next: undefined, prev: undefined };
+        const node: ChangeTreeNode = {
+            changeTree,
+            next: undefined,
+            prev: undefined,
+            position: list.tail ? list.tail.position + 1 : 0
+        };
 
         if (!list.next) {
             list.next = node;
@@ -173,16 +203,42 @@ export class Root {
             list.tail = node;
         }
 
-        list.length++;
-
         return node;
     }
 
+    protected updatePositionsAfterRemoval(list: ChangeTreeList, removedPosition: number) {
+        // Update positions for all nodes after the removed position
+        let current = list.next;
+        let position = 0;
+
+        while (current) {
+            if (position >= removedPosition) {
+                current.position = position;
+            }
+            current = current.next;
+            position++;
+        }
+    }
+
+    protected updatePositionsAfterMove(list: ChangeTreeList, node: ChangeTreeNode, newPosition: number) {
+        // Recalculate all positions - this is more reliable than trying to be clever
+        let current = list.next;
+        let position = 0;
+
+        while (current) {
+            current.position = position;
+            current = current.next;
+            position++;
+        }
+    }
+
     public removeChangeFromChangeSet(changeSetName: ChangeSetName, changeTree: ChangeTree) {
         const changeSet = this[changeSetName];
         const node = changeTree[changeSetName].queueRootNode;
 
         if (node && node.changeTree === changeTree) {
+            const removedPosition = node.position;
+
             // Remove the node from the linked list
             if (node.prev) {
                 node.prev.next = node.next;
@@ -196,7 +252,8 @@ export class Root {
                 changeSet.tail = node.prev;
             }
 
-            changeSet.length--;
+            // Update positions for nodes that came after the removed node
+            this.updatePositionsAfterRemoval(changeSet, removedPosition);
 
             // Clear ChangeTree reference
             changeTree[changeSetName].queueRootNode = undefined;

package/src/types/custom/MapSchema.ts

@@ -224,10 +224,15 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
     protected [$onEncodeEnd]() {
         const changeTree = this[$changes];
 
-        // cleanup changeTree.indexes of deleted keys
+        // - cleanup changeTree.indexes
+        // - cleanup $indexes
         for (const indexStr in this.deletedItems) {
-            const key = this.$indexes.get(parseInt(indexStr));
+            const index = parseInt(indexStr);
+            const key = this.$indexes.get(index);
+            // TODO: refactor this.
+            // it shouldn't be necessary to keep track of indexes both on changeTree and on $indexes
             delete changeTree.indexes[key];
+            this.$indexes.delete(index);
         }
 
         this.deletedItems = {};