@colyseus/schema 3.0.51 → 3.0.52

package/build/cjs/index.js

@@ -963,27 +963,13 @@ const Metadata = {
     }
 };
 
-function createChangeSet() {
-    return { indexes: {}, operations: [] };
+function createChangeSet(queueRootNode) {
+    return { indexes: {}, operations: [], queueRootNode };
 }
 // Linked list helper functions
 function createChangeTreeList() {
     return { next: undefined, tail: undefined, length: 0 };
 }
-function addToChangeTreeList(list, changeTree) {
-    const node = { changeTree, next: undefined, prev: undefined };
-    if (!list.next) {
-        list.next = node;
-        list.tail = node;
-    }
-    else {
-        node.prev = list.tail;
-        list.tail.next = node;
-        list.tail = node;
-    }
-    list.length++;
-    return node;
-}
 function setOperationAtIndex(changeSet, index) {
     const operationsIndex = changeSet.indexes[index];
     if (operationsIndex === undefined) {
@@ -1008,17 +994,6 @@ function deleteOperationAtIndex(changeSet, index) {
     changeSet.operations[operationsIndex] = undefined;
     delete changeSet.indexes[index];
 }
-function enqueueChangeTree(root, changeTree, changeSet, queueRootNode = changeTree[changeSet].queueRootNode) {
-    // skip
-    if (!root) {
-        return;
-    }
-    if (queueRootNode) ;
-    else {
-        // Add to linked list if not already present
-        changeTree[changeSet].queueRootNode = addToChangeTreeList(root[changeSet], changeTree);
-    }
-}
 class ChangeTree {
     constructor(ref) {
         /**
@@ -1124,11 +1099,11 @@ class ChangeTree {
         // this is checked during .encode() time.
         if (this.filteredChanges !== undefined) {
             this.filteredChanges.operations.push(-op);
-            enqueueChangeTree(this.root, this, 'filteredChanges');
+            this.root?.enqueueChangeTree(this, 'filteredChanges');
         }
         else {
             this.changes.operations.push(-op);
-            enqueueChangeTree(this.root, this, 'changes');
+            this.root?.enqueueChangeTree(this, 'changes');
         }
     }
     change(index, operation = exports.OPERATION.ADD) {
@@ -1152,13 +1127,13 @@ class ChangeTree {
         if (isFiltered) {
             setOperationAtIndex(this.allFilteredChanges, index);
             if (this.root) {
-                enqueueChangeTree(this.root, this, 'filteredChanges');
-                enqueueChangeTree(this.root, this, 'allFilteredChanges');
+                this.root.enqueueChangeTree(this, 'filteredChanges');
+                this.root.enqueueChangeTree(this, 'allFilteredChanges');
             }
         }
         else {
             setOperationAtIndex(this.allChanges, index);
-            enqueueChangeTree(this.root, this, 'changes');
+            this.root?.enqueueChangeTree(this, 'changes');
         }
     }
     shiftChangeIndexes(shiftIndex) {
@@ -1213,12 +1188,12 @@ class ChangeTree {
         if (this.filteredChanges !== undefined) {
             setOperationAtIndex(this.allFilteredChanges, allChangesIndex);
             setOperationAtIndex(this.filteredChanges, index);
-            enqueueChangeTree(this.root, this, 'filteredChanges');
+            this.root?.enqueueChangeTree(this, 'filteredChanges');
         }
         else {
             setOperationAtIndex(this.allChanges, allChangesIndex);
             setOperationAtIndex(this.changes, index);
-            enqueueChangeTree(this.root, this, 'changes');
+            this.root?.enqueueChangeTree(this, 'changes');
         }
     }
     getType(index) {
@@ -1281,10 +1256,10 @@ class ChangeTree {
         //
         if (this.filteredChanges !== undefined) {
             deleteOperationAtIndex(this.allFilteredChanges, allChangesIndex);
-            enqueueChangeTree(this.root, this, 'filteredChanges');
+            this.root?.enqueueChangeTree(this, 'filteredChanges');
         }
         else {
-            enqueueChangeTree(this.root, this, 'changes');
+            this.root?.enqueueChangeTree(this, 'changes');
         }
         return previousValue;
     }
@@ -1310,9 +1285,10 @@ class ChangeTree {
             this.filteredChanges = createChangeSet();
         }
         if (discardAll) {
-            this.allChanges = createChangeSet();
+            // preserve queueRootNode references
+            this.allChanges = createChangeSet(this.allChanges.queueRootNode);
             if (this.allFilteredChanges !== undefined) {
-                this.allFilteredChanges = createChangeSet();
+                this.allFilteredChanges = createChangeSet(this.allFilteredChanges.queueRootNode);
             }
         }
     }
@@ -1343,16 +1319,16 @@ class ChangeTree {
             //
             this._checkFilteredByParent(parent, parentIndex);
             if (this.filteredChanges !== undefined) {
-                enqueueChangeTree(this.root, this, 'filteredChanges');
+                this.root?.enqueueChangeTree(this, 'filteredChanges');
                 if (isNewChangeTree) {
-                    enqueueChangeTree(this.root, this, 'allFilteredChanges');
+                    this.root?.enqueueChangeTree(this, 'allFilteredChanges');
                 }
             }
         }
         if (!this.isFiltered) {
-            enqueueChangeTree(this.root, this, 'changes');
+            this.root?.enqueueChangeTree(this, 'changes');
             if (isNewChangeTree) {
-                enqueueChangeTree(this.root, this, 'allChanges');
+                this.root?.enqueueChangeTree(this, 'allChanges');
             }
         }
     }
@@ -2304,10 +2280,10 @@ class ArraySchema {
         // FIXME: this code block is duplicated on ChangeTree
         //
         if (changeTree.filteredChanges !== undefined) {
-            enqueueChangeTree(changeTree.root, changeTree, 'filteredChanges');
+            changeTree.root?.enqueueChangeTree(changeTree, 'filteredChanges');
         }
         else {
-            enqueueChangeTree(changeTree.root, changeTree, 'changes');
+            changeTree.root?.enqueueChangeTree(changeTree, 'changes');
         }
         return this.items.splice(start, deleteCount, ...insertItems);
     }
@@ -2722,6 +2698,9 @@ class MapSchema {
                     previousValue[$changes].root?.remove(previousValue[$changes]);
                 }
             }
+            if (this.deletedItems[index]) {
+                delete this.deletedItems[index];
+            }
         }
         else {
             index = changeTree.indexes[$numFields] ?? 0;
@@ -3940,11 +3919,12 @@ class Root {
             }
         }
         this.refCount[changeTree.refId] = (previousRefCount || 0) + 1;
-        // console.log("ADD", { refId: changeTree.refId, refCount: this.refCount[changeTree.refId] });
+        // console.log("ADD", { refId: changeTree.refId, ref: changeTree.ref.constructor.name, refCount: this.refCount[changeTree.refId], isNewChangeTree });
         return isNewChangeTree;
     }
     remove(changeTree) {
         const refCount = (this.refCount[changeTree.refId]) - 1;
+        // console.log("REMOVE", { refId: changeTree.refId, ref: changeTree.ref.constructor.name, refCount, needRemove: refCount <= 0 });
         if (refCount <= 0) {
             //
             // Only remove "root" reference if it's the last reference
@@ -4027,6 +4007,28 @@ class Root {
         }
         changeSet.tail = node;
     }
+    enqueueChangeTree(changeTree, changeSet, queueRootNode = changeTree[changeSet].queueRootNode) {
+        // skip
+        if (queueRootNode) {
+            return;
+        }
+        // Add to linked list if not already present
+        changeTree[changeSet].queueRootNode = this.addToChangeTreeList(this[changeSet], changeTree);
+    }
+    addToChangeTreeList(list, changeTree) {
+        const node = { changeTree, next: undefined, prev: undefined };
+        if (!list.next) {
+            list.next = node;
+            list.tail = node;
+        }
+        else {
+            node.prev = list.tail;
+            list.tail.next = node;
+            list.tail = node;
+        }
+        list.length++;
+        return node;
+    }
     removeChangeFromChangeSet(changeSetName, changeTree) {
         const changeSet = this[changeSetName];
         const node = changeTree[changeSetName].queueRootNode;