@colyseus/schema 3.0.10 → 3.0.12

package/src/encoder/Root.ts

@@ -1,7 +1,7 @@
 import { OPERATION } from "../encoding/spec";
 import { TypeContext } from "../types/TypeContext";
 import { spliceOne } from "../types/utils";
-import { ChangeTree, setOperationAtIndex } from "./ChangeTree";
+import { ChangeTree, enqueueChangeTree, setOperationAtIndex } from "./ChangeTree";
 
 export class Root {
     protected nextUniqueId: number = 0;
@@ -71,6 +71,23 @@ export class Root {
 
         } else {
             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.
+            //
+            // 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.
+            //
+            if (changeTree.filteredChanges !== undefined) {
+                this.removeChangeFromChangeSet("filteredChanges", changeTree);
+                enqueueChangeTree(this, changeTree, "filteredChanges");
+            } else {
+                this.removeChangeFromChangeSet("changes", changeTree);
+                enqueueChangeTree(this, changeTree, "changes");
+            }
         }
 
         changeTree.forEachChild((child, _) => this.remove(child));
@@ -80,10 +97,10 @@ export class Root {
 
     removeChangeFromChangeSet(changeSetName: "allChanges" | "changes" | "filteredChanges" | "allFilteredChanges", changeTree: ChangeTree) {
         const changeSet = this[changeSetName];
-        const index = changeSet.indexOf(changeTree);
-        if (index !== -1) {
-            spliceOne(changeSet, index);
+        if (spliceOne(changeSet, changeSet.indexOf(changeTree))) {
+            changeTree[changeSetName].queueRootIndex = -1;
             // changeSet[index] = undefined;
+            return true;
         }
     }
 

package/src/encoder/StateView.ts

@@ -25,7 +25,8 @@ export class StateView {
      * Manual "ADD" operations for changes per ChangeTree, specific to this view.
      * (This is used to force encoding a property, even if it was not changed)
      */
-    changes: { [refId: number]: IndexedOperations } = {};
+    // TODO: use map here!? may fix encode ordering issue
+    changes = new Map<number, IndexedOperations>();
 
     // TODO: allow to set multiple tags at once
     add(obj: Ref, tag: number = DEFAULT_VIEW_TAG, checkIncludeParent: boolean = true) {
@@ -43,17 +44,17 @@ export class StateView {
         // - if it was invisible to this view
         // - if it were previously filtered out
         if (checkIncludeParent && changeTree.parent) {
-            this.addParent(changeTree.parent[$changes], changeTree.parentIndex, tag);
+            this.addParentOf(changeTree, tag);
         }
 
         //
         // TODO: when adding an item of a MapSchema, the changes may not
         // be set (only the parent's changes are set)
         //
-        let changes = this.changes[changeTree.refId];
+        let changes = this.changes.get(changeTree.refId);
         if (changes === undefined) {
             changes = {};
-            this.changes[changeTree.refId] = changes;
+            this.changes.set(changeTree.refId, changes);
         }
 
         // set tag
@@ -118,28 +119,34 @@ export class StateView {
         return this;
     }
 
-    protected addParent(changeTree: ChangeTree, parentIndex: number, tag: number) {
+    protected addParentOf(childChangeTree: ChangeTree, tag: number) {
+        const changeTree = childChangeTree.parent[$changes];
+        const parentIndex = childChangeTree.parentIndex;
+
         // view must have all "changeTree" parent tree
         this.items.add(changeTree);
 
         // add parent's parent
         const parentChangeTree: ChangeTree = changeTree.parent?.[$changes];
         if (parentChangeTree && (parentChangeTree.filteredChanges !== undefined)) {
-            this.addParent(parentChangeTree, changeTree.parentIndex, tag);
+            this.addParentOf(changeTree, tag);
         }
 
-        // parent is already available, no need to add it!
-        if (!this.invisible.has(changeTree)) {
+        if (
+            // parent is already available, no need to add it!
+            !this.invisible.has(changeTree) &&
+            // item is being replaced, no need to add parent
+            changeTree.indexedOperations[parentIndex] !== OPERATION.DELETE_AND_ADD
+        ) {
             return;
         }
 
         // add parent's tag properties
         if (changeTree.getChange(parentIndex) !== OPERATION.DELETE) {
-
-            let changes = this.changes[changeTree.refId];
+            let changes = this.changes.get(changeTree.refId);
             if (changes === undefined) {
                 changes = {};
-                this.changes[changeTree.refId] = changes;
+                this.changes.set(changeTree.refId, changes);
             }
 
             if (!this.tags) {
@@ -171,10 +178,10 @@ export class StateView {
         const ref = changeTree.ref;
         const metadata: Metadata = ref.constructor[Symbol.metadata];
 
-        let changes = this.changes[changeTree.refId];
+        let changes = this.changes.get(changeTree.refId);
         if (changes === undefined) {
             changes = {};
-            this.changes[changeTree.refId] = changes;
+            this.changes.set(changeTree.refId, changes);
         }
 
         if (tag === DEFAULT_VIEW_TAG) {
@@ -182,10 +189,10 @@ export class StateView {
             const parent = changeTree.parent;
             if (!Metadata.isValidInstance(parent)) {
                 const parentChangeTree = parent[$changes];
-                let changes = this.changes[parentChangeTree.refId];
+                let changes = this.changes.get(parentChangeTree.refId);
                 if (changes === undefined) {
                     changes = {};
-                    this.changes[parentChangeTree.refId] = changes;
+                    this.changes.set(parentChangeTree.refId, changes);
                 }
                 // DELETE / DELETE BY REF ID
                 changes[changeTree.parentIndex] = OPERATION.DELETE;

package/src/types/custom/ArraySchema.ts

@@ -92,7 +92,8 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
                         if (setValue[$changes]) {
                             assertInstanceType(setValue, obj[$childType] as typeof Schema, obj, key);
 
-                            if (obj.items[key as unknown as number] !== undefined) {
+                            const previousValue = obj.items[key as unknown as number];
+                            if (previousValue !== undefined) {
                                 if (setValue[$changes].isNew) {
                                     this[$changes].indexedOperation(Number(key), OPERATION.MOVE_AND_ADD);
 
@@ -103,10 +104,16 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
                                         this[$changes].indexedOperation(Number(key), OPERATION.MOVE);
                                     }
                                 }
+
+                                // remove root reference from previous value
+                                previousValue[$changes].root?.remove(previousValue[$changes]);
+
                             } else if (setValue[$changes].isNew) {
                                 this[$changes].indexedOperation(Number(key), OPERATION.ADD);
                             }
 
+                            setValue[$changes].setParent(this, obj[$changes].root, key);
+
                         } else {
                             obj.$changeAt(Number(key), setValue);
                         }

package/src/types/custom/MapSchema.ts

@@ -86,41 +86,38 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
         key = key.toString() as K;
 
         const changeTree = this[$changes];
+        const isRef = (value[$changes]) !== undefined;
 
-        // get "index" for this value.
-        const isReplace = typeof(changeTree.indexes[key]) !== "undefined";
+        let index: number;
+        let operation: OPERATION;
 
-        const index = (isReplace)
-            ? changeTree.indexes[key]
-            : changeTree.indexes[$numFields] ?? 0;
+        // IS REPLACE?
+        if (typeof(changeTree.indexes[key]) !== "undefined") {
+            index = changeTree.indexes[key];
+            operation = OPERATION.REPLACE;
 
-        let operation: OPERATION = (isReplace)
-            ? OPERATION.REPLACE
-            : OPERATION.ADD;
+            const previousValue = this.$items.get(key);
+            if (previousValue === value) {
+                // if value is the same, avoid re-encoding it.
+                return;
 
-        const isRef = (value[$changes]) !== undefined;
+            } else if (isRef) {
+                // if is schema, force ADD operation if value differ from previous one.
+                operation = OPERATION.DELETE_AND_ADD;
+
+                // remove reference from previous value
+                if (previousValue !== undefined) {
+                    previousValue[$changes].root?.remove(previousValue[$changes]);
+                }
+            }
+
+        } else {
+            index = changeTree.indexes[$numFields] ?? 0;
+            operation = OPERATION.ADD;
 
-        //
-        // (encoding)
-        // set a unique id to relate directly with this key/value.
-        //
-        if (!isReplace) {
             this.$indexes.set(index, key);
             changeTree.indexes[key] = index;
             changeTree.indexes[$numFields] = index + 1;
-
-        } else if (
-            !isRef &&
-            this.$items.get(key) === value
-        ) {
-            // if value is the same, avoid re-encoding it.
-            return;
-
-        } else if (
-            isRef && // if is schema, force ADD operation if value differ from previous one.
-            this.$items.get(key) !== value
-        ) {
-            operation = OPERATION.ADD;
         }
 
         this.$items.set(key, value);