@colyseus/schema 3.0.50 → 3.0.52

package/src/encoder/ChangeTree.ts

@@ -57,8 +57,8 @@ export interface ChangeSet {
     queueRootNode?: ChangeTreeNode; // direct reference to ChangeTreeNode in the linked list
 }
 
-function createChangeSet(): ChangeSet {
-    return { indexes: {}, operations: [] };
+function createChangeSet(queueRootNode?: ChangeTreeNode): ChangeSet {
+    return { indexes: {}, operations: [], queueRootNode };
 }
 
 // Linked list helper functions
@@ -66,23 +66,6 @@ export function createChangeTreeList(): ChangeTreeList {
     return { next: undefined, tail: undefined, length: 0 };
 }
 
-export function addToChangeTreeList(list: ChangeTreeList, changeTree: ChangeTree): ChangeTreeNode {
-    const node: ChangeTreeNode = { 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;
-}
-
 export function setOperationAtIndex(changeSet: ChangeSet, index: number) {
     const operationsIndex = changeSet.indexes[index];
     if (operationsIndex === undefined) {
@@ -129,22 +112,6 @@ export function debugChangeSet(label: string, changeSet: ChangeSet) {
     console.log(operations.join("\n"), "\n}");
 }
 
-export function enqueueChangeTree(
-    root: Root,
-    changeTree: ChangeTree,
-    changeSet: 'changes' | 'filteredChanges' | 'allFilteredChanges' | 'allChanges',
-    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);
-    }
-}
-
 export interface ParentChain {
     ref: Ref;
     index: number;
@@ -283,11 +250,11 @@ export class ChangeTree<T extends Ref = any> {
         // 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');
         }
     }
 
@@ -316,13 +283,13 @@ export class ChangeTree<T extends Ref = any> {
             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');
         }
     }
 
@@ -385,12 +352,12 @@ export class ChangeTree<T extends Ref = any> {
         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');
         }
     }
 
@@ -461,10 +428,10 @@ export class ChangeTree<T extends Ref = any> {
         //
         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;
@@ -499,10 +466,11 @@ export class ChangeTree<T extends Ref = any> {
         }
 
         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);
             }
         }
     }
@@ -539,17 +507,19 @@ export class ChangeTree<T extends Ref = any> {
             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');
             }
         }
     }

package/src/encoder/EncodeOperation.ts

@@ -177,7 +177,12 @@ export const encodeArray: EncodeOperation = function (
     let refOrIndex: number;
 
     if (useOperationByRefId) {
-        refOrIndex = ref['tmpItems'][field][$changes].refId;
+        const item = ref['tmpItems'][field];
+
+        // Skip encoding if item is undefined (e.g. when clear() is called)
+        if (!item) { return; }
+
+        refOrIndex = item[$changes].refId;
 
         if (operation === OPERATION.DELETE) {
             operation = OPERATION.DELETE_BY_REFID;

package/src/encoder/Root.ts

@@ -1,6 +1,6 @@
 import { OPERATION } from "../encoding/spec";
 import { TypeContext } from "../types/TypeContext";
-import { ChangeTree, setOperationAtIndex, ChangeTreeList, createChangeTreeList, ChangeSetName, Ref } from "./ChangeTree";
+import { ChangeTree, setOperationAtIndex, ChangeTreeList, createChangeTreeList, ChangeSetName, type ChangeTreeNode } from "./ChangeTree";
 
 export class Root {
     protected nextUniqueId: number = 0;
@@ -47,7 +47,7 @@ export 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;
     }
@@ -55,6 +55,8 @@ export class Root {
     remove(changeTree: 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
@@ -147,7 +149,36 @@ export class Root {
         changeSet.tail = node;
     }
 
-    protected removeChangeFromChangeSet(changeSetName: ChangeSetName, changeTree: ChangeTree) {
+    public enqueueChangeTree(
+        changeTree: ChangeTree,
+        changeSet: 'changes' | 'filteredChanges' | 'allFilteredChanges' | 'allChanges',
+        queueRootNode = changeTree[changeSet].queueRootNode
+    ) {
+        // skip
+        if (queueRootNode) { return; }
+
+        // Add to linked list if not already present
+        changeTree[changeSet].queueRootNode = this.addToChangeTreeList(this[changeSet], changeTree);
+    }
+
+    protected addToChangeTreeList(list: ChangeTreeList, changeTree: ChangeTree): ChangeTreeNode {
+        const node: ChangeTreeNode = { 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;
+    }
+
+    public removeChangeFromChangeSet(changeSetName: ChangeSetName, changeTree: ChangeTree) {
         const changeSet = this[changeSetName];
         const node = changeTree[changeSetName].queueRootNode;
 

package/src/types/custom/ArraySchema.ts

@@ -1,6 +1,6 @@
 import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $onDecodeEnd } from "../symbols";
 import type { Schema } from "../../Schema";
-import { ChangeTree, enqueueChangeTree, setOperationAtIndex } from "../../encoder/ChangeTree";
+import { ChangeTree, setOperationAtIndex } from "../../encoder/ChangeTree";
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
 import { Collection } from "../HelperTypes";
@@ -482,10 +482,10 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         // 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);

package/src/types/custom/MapSchema.ts

@@ -118,6 +118,10 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
                 }
             }
 
+            if (this.deletedItems[index]) {
+                delete this.deletedItems[index];
+            }
+
         } else {
             index = changeTree.indexes[$numFields] ?? 0;
             operation = OPERATION.ADD;