@colyseus/schema 3.0.36 → 3.0.37

package/src/encoder/ChangeTree.ts

@@ -160,22 +160,36 @@ export class ChangeTree<T extends Ref=any> {
         this.root = root;
         this.checkIsFiltered(this.parent, this.parentIndex);
 
+        //
+        // TODO: refactor and possibly unify .setRoot() and .setParent()
+        //
+
         // Recursively set root on child structures
         const metadata: Metadata = this.ref.constructor[Symbol.metadata];
         if (metadata) {
             metadata[$refTypeFieldIndexes]?.forEach((index) => {
                 const field = metadata[index as any as number];
-                const value = this.ref[field.name];
-                value?.[$changes].setRoot(root);
+                const changeTree: ChangeTree = this.ref[field.name]?.[$changes];
+                if (changeTree) {
+                    if (changeTree.root !== root) {
+                        changeTree.setRoot(root);
+                    } else {
+                        root.add(changeTree); // increment refCount
+                    }
+                }
             });
 
         } else if (this.ref[$childType] && typeof(this.ref[$childType]) !== "string") {
             // MapSchema / ArraySchema, etc.
             (this.ref as MapSchema).forEach((value, key) => {
-                value[$changes].setRoot(root);
+                const changeTree: ChangeTree = value[$changes];
+                if (changeTree.root !== root) {
+                    changeTree.setRoot(root);
+                } else {
+                    root.add(changeTree); // increment refCount
+                }
             });
         }
-
     }
 
     setParent(
@@ -203,14 +217,19 @@ export class ChangeTree<T extends Ref=any> {
         if (metadata) {
             metadata[$refTypeFieldIndexes]?.forEach((index) => {
                 const field = metadata[index as any as number];
-                const value = this.ref[field.name];
-                value?.[$changes].setParent(this.ref, root, index);
+                const changeTree: ChangeTree = this.ref[field.name]?.[$changes];
+                if (changeTree && changeTree.root !== root) {
+                    changeTree.setParent(this.ref, root, index);
+                }
             });
 
         } else if (this.ref[$childType] && typeof(this.ref[$childType]) !== "string") {
             // MapSchema / ArraySchema, etc.
             (this.ref as MapSchema).forEach((value, key) => {
-                value[$changes].setParent(this.ref, root, this.indexes[key] ?? key);
+                const changeTree: ChangeTree = value[$changes];
+                if (changeTree.root !== root) {
+                    changeTree.setParent(this.ref, root, this.indexes[key] ?? key);
+                }
             });
         }
 
@@ -478,15 +497,12 @@ export class ChangeTree<T extends Ref=any> {
                 this.allFilteredChanges.indexes = {};
                 this.allFilteredChanges.operations.length = 0;
             }
-
-            // remove children references
-            this.forEachChild((changeTree, _) =>
-                this.root?.remove(changeTree));
         }
     }
 
     /**
      * Recursively discard all changes from this, and child structures.
+     * (Used in tests only)
      */
     discardAll() {
         const keys = Object.keys(this.indexedOperations);

package/src/encoder/Root.ts

@@ -69,6 +69,8 @@ export class Root {
 
             this.refCount[changeTree.refId] = 0;
 
+            changeTree.forEachChild((child, _) => this.remove(child));
+
         } else {
             this.refCount[changeTree.refId] = refCount;
 
@@ -90,8 +92,6 @@ export class Root {
             }
         }
 
-        changeTree.forEachChild((child, _) => this.remove(child));
-
         return refCount;
     }
 

package/src/types/custom/ArraySchema.ts

@@ -185,9 +185,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
 
         const changeTree = this[$changes];
 
-        // values.forEach((value, i) => {
-
-        for (let i = 0, l = values.length; i < values.length; i++, length++) {
+        for (let i = 0, l = values.length; i < l; i++, length++) {
             const value = values[i];
 
             if (value === undefined || value === null) {
@@ -211,9 +209,6 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
             value[$changes]?.setParent(this, changeTree.root, length);
         }
 
-        //     length++;
-        // });
-
         return length;
     }
 
@@ -310,22 +305,9 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         // discard previous operations.
         const changeTree = this[$changes];
 
-        // discard children
-        changeTree.forEachChild((changeTree, _) => {
-            changeTree.discard(true);
-
-            //
-            // TODO: add tests with instance sharing + .clear()
-            // FIXME: this.root? is required because it is being called at decoding time.
-            //
-            // TODO: do not use [$changes] at decoding time.
-            //
-            const root = changeTree.root;
-            if (root !== undefined) {
-                root.removeChangeFromChangeSet("changes", changeTree);
-                root.removeChangeFromChangeSet("allChanges", changeTree);
-                root.removeChangeFromChangeSet("allFilteredChanges", changeTree);
-            }
+        // remove children references
+        changeTree.forEachChild((childChangeTree, _) => {
+            changeTree.root?.remove(childChangeTree);
         });
 
         changeTree.discard(true);

package/src/types/custom/CollectionSchema.ts

@@ -116,6 +116,11 @@ export class CollectionSchema<V=any> implements Collection<K, V>{
         changeTree.discard(true);
         changeTree.indexes = {};
 
+        // remove children references
+        changeTree.forEachChild((childChangeTree, _) => {
+            changeTree.root?.remove(childChangeTree);
+        });
+
         // clear previous indexes
         this.$indexes.clear();
 

package/src/types/custom/MapSchema.ts

@@ -155,6 +155,11 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
         changeTree.discard(true);
         changeTree.indexes = {};
 
+        // remove children references
+        changeTree.forEachChild((childChangeTree, _) => {
+            changeTree.root?.remove(childChangeTree);
+        });
+
         // clear previous indexes
         this.$indexes.clear();