@colyseus/schema 3.0.57 → 3.0.60

package/build/esm/index.mjs

@@ -988,7 +988,7 @@ function createChangeSet(queueRootNode) {
 }
 // Linked list helper functions
 function createChangeTreeList() {
-    return { next: undefined, tail: undefined, length: 0 };
+    return { next: undefined, tail: undefined };
 }
 function setOperationAtIndex(changeSet, index) {
     const operationsIndex = changeSet.indexes[index];
@@ -1080,11 +1080,11 @@ class ChangeTree {
             this.forEachChild((child, index) => {
                 if (child.root === root) {
                     //
-                    // re-assigning a child of the same root, move it to the end
-                    // of the changes queue so encoding order is preserved
+                    // re-assigning a child of the same root, move it next to parent
+                    // so encoding order is preserved
                     //
                     root.add(child);
-                    root.moveToEndOfChanges(child);
+                    root.moveNextToParent(child);
                     return;
                 }
                 child.setParent(this.ref, root, index);
@@ -2797,10 +2797,15 @@ class MapSchema {
     }
     [$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 = {};
     }
@@ -4011,8 +4016,8 @@ 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);
                     }
                 }
             });
@@ -4021,34 +4026,52 @@ class Root {
             this.refCount[changeTree.refId] = refCount;
             //
             // 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) {
+    recursivelyMoveNextToParent(changeTree) {
+        this.moveNextToParent(changeTree);
+        changeTree.forEachChild((child, _) => this.recursivelyMoveNextToParent(child));
+    }
+    moveNextToParent(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, changeTree) {
+    moveNextToParentInChangeTreeList(changeSetName, changeTree) {
         const changeSet = this[changeSetName];
         const node = changeTree[changeSetName].queueRootNode;
-        if (!node || node === changeSet.tail)
+        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;
+        // If child is already after parent, no need to move
+        if (childPosition > parentPosition)
             return;
-        // Remove from current position
+        // 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;
         }
@@ -4061,16 +4084,18 @@ class Root {
         else {
             changeSet.tail = node.prev;
         }
-        // Add to end
-        node.prev = changeSet.tail;
-        node.next = undefined;
-        if (changeSet.tail) {
-            changeSet.tail.next = node;
+        // Insert node right after parent
+        node.prev = parentNode;
+        node.next = parentNode.next;
+        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);
     }
     enqueueChangeTree(changeTree, changeSet, queueRootNode = changeTree[changeSet].queueRootNode) {
         // skip
@@ -4081,7 +4106,12 @@ class Root {
         changeTree[changeSet].queueRootNode = this.addToChangeTreeList(this[changeSet], changeTree);
     }
     addToChangeTreeList(list, changeTree) {
-        const node = { changeTree, next: undefined, prev: undefined };
+        const node = {
+            changeTree,
+            next: undefined,
+            prev: undefined,
+            position: list.tail ? list.tail.position + 1 : 0
+        };
         if (!list.next) {
             list.next = node;
             list.tail = node;
@@ -4091,13 +4121,35 @@ class Root {
             list.tail.next = node;
             list.tail = node;
         }
-        list.length++;
         return node;
     }
+    updatePositionsAfterRemoval(list, removedPosition) {
+        // 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++;
+        }
+    }
+    updatePositionsAfterMove(list, node, newPosition) {
+        // 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++;
+        }
+    }
     removeChangeFromChangeSet(changeSetName, 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;
@@ -4111,7 +4163,8 @@ class Root {
             else {
                 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;
             return true;
@@ -4333,8 +4386,8 @@ class Encoder {
         }
     }
     get hasChanges() {
-        return (this.root.changes.length > 0 ||
-            this.root.filteredChanges.length > 0);
+        return (this.root.changes.next !== undefined ||
+            this.root.filteredChanges.next !== undefined);
     }
 }
 
@@ -4517,8 +4570,7 @@ class Decoder {
                 if (!nextRef) {
                     // throw new Error(`"refId" not found: ${nextRefId}`);
                     console.error(`"refId" not found: ${nextRefId}`, { previousRef: ref, previousRefId: this.currentRefId });
-                    console.warn("Please report this to the developers. All refIds =>");
-                    console.warn(Schema.debugRefIdsFromDecoder(this));
+                    console.warn("Please report this issue to the developers.");
                     this.skipCurrentStructure(bytes, it, totalBytes);
                 }
                 else {