@colyseus/schema 3.0.35 → 3.0.37

package/README.md

@@ -246,9 +246,9 @@ const decoder = new Decoder(state);
 decoder.decode(encodedBytes);
 ```
 
-### Backwards/forwards compability
+### Backwards/forwards compatibility
 
-Backwards/fowards compatibility is possible by declaring new fields at the
+Backwards/forwards compatibility is possible by declaring new fields at the
 end of existing structures, and earlier declarations to not be removed, but
 be marked `@deprecated()` when needed.
 
@@ -307,10 +307,10 @@ Each Colyseus SDK has its own decoder implementation of the `@colyseus/schema` p
 
 ## Why
 
-Initial thoghts/assumptions, for Colyseus:
+Initial thoughts/assumptions, for Colyseus:
 - little to no bottleneck for detecting state changes.
-- have a schema definition on both server and client
-- better experience on staticaly-typed languages (C#, C++)
+- have a schema definition on both the server and the client
+- better experience on statically-typed languages (C#, C++)
 - mutations should be cheap.
 
 Practical Colyseus issues this should solve:

package/build/cjs/index.js

@@ -1032,19 +1032,35 @@ class ChangeTree {
     setRoot(root) {
         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 = this.ref.constructor[Symbol.metadata];
         if (metadata) {
             metadata[$refTypeFieldIndexes]?.forEach((index) => {
                 const field = metadata[index];
-                const value = this.ref[field.name];
-                value?.[$changes].setRoot(root);
+                const 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.forEach((value, key) => {
-                value[$changes].setRoot(root);
+                const changeTree = value[$changes];
+                if (changeTree.root !== root) {
+                    changeTree.setRoot(root);
+                }
+                else {
+                    root.add(changeTree); // increment refCount
+                }
             });
         }
     }
@@ -1068,14 +1084,19 @@ class ChangeTree {
         if (metadata) {
             metadata[$refTypeFieldIndexes]?.forEach((index) => {
                 const field = metadata[index];
-                const value = this.ref[field.name];
-                value?.[$changes].setParent(this.ref, root, index);
+                const 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.forEach((value, key) => {
-                value[$changes].setParent(this.ref, root, this.indexes[key] ?? key);
+                const changeTree = value[$changes];
+                if (changeTree.root !== root) {
+                    changeTree.setParent(this.ref, root, this.indexes[key] ?? key);
+                }
             });
         }
     }
@@ -1307,12 +1328,11 @@ class ChangeTree {
                 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);
@@ -1983,8 +2003,7 @@ class ArraySchema {
     push(...values) {
         let length = this.tmpItems.length;
         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) {
                 // skip null values
@@ -2003,8 +2022,6 @@ class ArraySchema {
             //
             value[$changes]?.setParent(this, changeTree.root, length);
         }
-        //     length++;
-        // });
         return length;
     }
     /**
@@ -2083,21 +2100,9 @@ class ArraySchema {
         }
         // 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);
         changeTree.operation(exports.OPERATION.CLEAR);
@@ -2682,6 +2687,10 @@ class MapSchema {
         // discard previous operations.
         changeTree.discard(true);
         changeTree.indexes = {};
+        // remove children references
+        changeTree.forEachChild((childChangeTree, _) => {
+            changeTree.root?.remove(childChangeTree);
+        });
         // clear previous indexes
         this.$indexes.clear();
         // clear items
@@ -3279,6 +3288,10 @@ class Schema {
         }
         return obj;
     }
+    /**
+     * Used in tests only
+     * @internal
+     */
     discardAllChanges() {
         this[$changes].discardAll();
     }
@@ -3301,8 +3314,11 @@ class Schema {
         const contents = (showContents) ? ` - ${JSON.stringify(ref.toJSON())}` : "";
         const changeTree = ref[$changes];
         const refId = changeTree.refId;
-        let output = "";
-        output += `${getIndent(level)}${ref.constructor.name} (refId: ${refId})${contents}\n`;
+        // log reference count if > 1
+        const refCount = (changeTree.root?.refCount?.[refId] > 1)
+            ? ` [×${changeTree.root.refCount[refId]}]`
+            : '';
+        let output = `${getIndent(level)}${ref.constructor.name} (refId: ${refId})${refCount}${contents}\n`;
         changeTree.forEachChild((childChangeTree) => output += this.debugRefIds(childChangeTree.ref, showContents, level + 1));
         return output;
     }
@@ -3487,6 +3503,10 @@ class CollectionSchema {
         // discard previous operations.
         changeTree.discard(true);
         changeTree.indexes = {};
+        // remove children references
+        changeTree.forEachChild((childChangeTree, _) => {
+            changeTree.root?.remove(childChangeTree);
+        });
         // clear previous indexes
         this.$indexes.clear();
         // clear items
@@ -3819,6 +3839,7 @@ class Root {
                 this.removeChangeFromChangeSet("filteredChanges", changeTree);
             }
             this.refCount[changeTree.refId] = 0;
+            changeTree.forEachChild((child, _) => this.remove(child));
         }
         else {
             this.refCount[changeTree.refId] = refCount;
@@ -3840,7 +3861,6 @@ class Root {
                 enqueueChangeTree(this, changeTree, "changes");
             }
         }
-        changeTree.forEachChild((child, _) => this.remove(child));
         return refCount;
     }
     removeChangeFromChangeSet(changeSetName, changeTree) {
@@ -4214,7 +4234,7 @@ class ReferenceTracker {
     }
     removeCallback(refId, field, callback) {
         const index = this.callbacks?.[refId]?.[field]?.indexOf(callback);
-        if (index !== -1) {
+        if (index !== undefined && index !== -1) {
             spliceOne(this.callbacks[refId][field], index);
         }
     }