@colyseus/schema 3.0.11 → 3.0.12

package/src/decoder/DecodeOperation.ts

@@ -59,20 +59,6 @@ export function decodeValue(
         //
         if (operation !== OPERATION.DELETE_AND_ADD) {
             ref[$deleteByIndex](index);
-
-            // //
-            // // FIXME: is this in the correct place?
-            // //      (This is sounding like a workaround just for ArraySchema, see
-            // //       "should splice and move" test on ArraySchema.test.ts)
-            // //
-            // allChanges.push({
-            //     ref,
-            //     refId: decoder.currentRefId,
-            //     op: OPERATION.DELETE,
-            //     field: index as unknown as string,
-            //     value: undefined,
-            //     previousValue,
-            // });
         }
 
         value = undefined;

package/src/encoder/ChangeTree.ts

@@ -11,8 +11,6 @@ import { Root } from "./Root";
 import { Metadata } from "../Metadata";
 import type { EncodeOperation } from "./EncodeOperation";
 import type { DecodeOperation } from "../decoder/DecodeOperation";
-import { TypeContext } from "../types/TypeContext";
-import { ReferenceTracker } from "../decoder/ReferenceTracker";
 
 declare global {
     interface Object {

package/src/encoder/Encoder.ts

@@ -1,6 +1,6 @@
 import type { Schema } from "../Schema";
 import { TypeContext } from "../types/TypeContext";
-import { $changes, $encoder, $filter, $onEncodeEnd } from "../types/symbols";
+import { $changes, $encoder, $filter } from "../types/symbols";
 
 import { encode } from "../encoding/encode";
 import type { Iterator } from "../encoding/decode";
@@ -58,14 +58,6 @@ export class Encoder<T extends Schema = any> {
         for (let i = 0, numChangeTrees = changeTrees.length; i < numChangeTrees; i++) {
             const changeTree = changeTrees[i];
 
-            const operations = changeTree[changeSetName];
-            const ref = changeTree.ref;
-
-            const ctor = ref.constructor;
-            const encoder = ctor[$encoder];
-            const filter = ctor[$filter];
-            const metadata = ctor[Symbol.metadata];
-
             if (hasView) {
                 if (!view.items.has(changeTree)) {
                     view.invisible.add(changeTree);
@@ -76,6 +68,18 @@ export class Encoder<T extends Schema = any> {
                 }
             }
 
+            const operations = changeTree[changeSetName];
+            const ref = changeTree.ref;
+
+            // TODO: avoid iterating over change tree if no changes were made
+            const numChanges = operations.operations.length;
+            if (numChanges === 0) { continue; }
+
+            const ctor = ref.constructor;
+            const encoder = ctor[$encoder];
+            const filter = ctor[$filter];
+            const metadata = ctor[Symbol.metadata];
+
             // skip root `refId` if it's the first change tree
             // (unless it "hasView", which will need to revisit the root)
             if (hasView || it.offset > initialOffset || changeTree !== rootChangeTree) {
@@ -83,7 +87,7 @@ export class Encoder<T extends Schema = any> {
                 encode.number(buffer, changeTree.refId, it);
             }
 
-            for (let j = 0, numChanges = operations.operations.length; j < numChanges; j++) {
+            for (let j = 0; j < numChanges; j++) {
                 const fieldIndex = operations.operations[j];
 
                 const operation = (fieldIndex < 0)
@@ -199,17 +203,18 @@ export class Encoder<T extends Schema = any> {
         const viewOffset = it.offset;
 
         // encode visibility changes (add/remove for this view)
-        const refIds = Object.keys(view.changes);
-
-        for (let i = 0, numRefIds = refIds.length; i < numRefIds; i++) {
-            const refId = refIds[i];
-            const changes = view.changes[refId];
+        for (const [refId, changes] of view.changes) {
             const changeTree = this.root.changeTrees[refId];
 
-            if (
-                changeTree === undefined ||
-                Object.keys(changes).length === 0 // FIXME: avoid having empty changes if no changes were made
-            ) {
+            if (changeTree === undefined) {
+                // detached instance, remove from view and skip.
+                view.changes.delete(refId);
+                continue;
+            }
+
+            const keys = Object.keys(changes);
+            if (keys.length === 0) {
+                // FIXME: avoid having empty changes if no changes were made
                 // console.log("changes.size === 0, skip", changeTree.ref.constructor.name);
                 continue;
             }
@@ -223,7 +228,6 @@ export class Encoder<T extends Schema = any> {
             bytes[it.offset++] = SWITCH_TO_STRUCTURE & 255;
             encode.number(bytes, changeTree.refId, it);
 
-            const keys = Object.keys(changes);
             for (let i = 0, numChanges = keys.length; i < numChanges; i++) {
                 const key = keys[i];
                 const operation = changes[key];
@@ -239,7 +243,7 @@ export class Encoder<T extends Schema = any> {
         // (to allow re-using StateView's for multiple clients)
         //
         // clear "view" changes after encoding
-        view.changes = {};
+        view.changes.clear();
 
         // try to encode "filtered" changes
         this.encode(it, view, bytes, "filteredChanges", false, viewOffset);
@@ -250,26 +254,6 @@ export class Encoder<T extends Schema = any> {
         ]);
     }
 
-    onEndEncode(changeTrees = this.root.changes) {
-        // changeTrees.forEach(function(changeTree) {
-        //     changeTree.endEncode();
-        // });
-
-
-        // for (const refId in changeTrees) {
-        //     const changeTree = this.root.changeTrees[refId];
-        //     changeTree.endEncode();
-
-        //     // changeTree.changes.clear();
-
-        //     // // ArraySchema and MapSchema have a custom "encode end" method
-        //     // changeTree.ref[$onEncodeEnd]?.();
-
-        //     // // Not a new instance anymore
-        //     // delete changeTree[$isNew];
-        // }
-    }
-
     discardChanges() {
         // discard shared changes
         let length = this.root.changes.length;

package/src/encoder/Root.ts

@@ -100,6 +100,7 @@ export class Root {
         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);