@colyseus/schema 3.0.11 → 3.0.13

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, $getByIndex } from "../types/symbols";
 
 import { encode } from "../encoding/encode";
 import type { Iterator } from "../encoding/decode";
@@ -10,6 +10,7 @@ import { Root } from "./Root";
 
 import type { StateView } from "./StateView";
 import type { Metadata } from "../Metadata";
+import type { ChangeTree } from "./ChangeTree";
 
 export class Encoder<T extends Schema = any> {
     static BUFFER_SIZE = (typeof(Buffer) !== "undefined") && Buffer.poolSize || 8 * 1024; // 8KB
@@ -58,14 +59,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 +69,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 +88,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 +204,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 (const [refId, changes] of view.changes) {
+            const changeTree: ChangeTree = this.root.changeTrees[refId];
 
-        for (let i = 0, numRefIds = refIds.length; i < numRefIds; i++) {
-            const refId = refIds[i];
-            const changes = view.changes[refId];
-            const changeTree = this.root.changeTrees[refId];
+            if (changeTree === undefined) {
+                // detached instance, remove from view and skip.
+                view.changes.delete(refId);
+                continue;
+            }
 
-            if (
-                changeTree === undefined ||
-                Object.keys(changes).length === 0 // FIXME: avoid having empty changes if no changes were made
-            ) {
+            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,14 +229,15 @@ 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];
+                const index = Number(keys[i]);
+                // workaround when using view.add() on item that has been deleted from state (see test "adding to view item that has been removed from state")
+                const value = changeTree.ref[$getByIndex](index);
+                const operation = (value !== undefined && changes[index]) || OPERATION.DELETE;
 
                 // isEncodeAll = false
                 // hasView = true
-                encoder(this, bytes, changeTree, Number(key), operation, it, false, true, metadata);
+                encoder(this, bytes, changeTree, index, operation, it, false, true, metadata);
             }
         }
 
@@ -239,7 +246,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 +257,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,30 @@ export class StateView {
         return this;
     }
 
-    protected addParent(changeTree: ChangeTree, parentIndex: number, tag: number) {
-        // view must have all "changeTree" parent tree
-        this.items.add(changeTree);
+    protected addParentOf(childChangeTree: ChangeTree, tag: number) {
+        const changeTree = childChangeTree.parent[$changes];
+        const parentIndex = childChangeTree.parentIndex;
 
-        // add parent's parent
-        const parentChangeTree: ChangeTree = changeTree.parent?.[$changes];
-        if (parentChangeTree && (parentChangeTree.filteredChanges !== undefined)) {
-            this.addParent(parentChangeTree, changeTree.parentIndex, tag);
-        }
+        if (!this.items.has(changeTree)) {
+            // view must have all "changeTree" parent tree
+            this.items.add(changeTree);
 
-        // parent is already available, no need to add it!
-        if (!this.invisible.has(changeTree)) {
-            return;
+            // add parent's parent
+            const parentChangeTree: ChangeTree = changeTree.parent?.[$changes];
+            if (parentChangeTree && (parentChangeTree.filteredChanges !== undefined)) {
+                this.addParentOf(changeTree, tag);
+            }
+
+            // parent is already available, no need to add it!
+            if (!this.invisible.has(changeTree)) { 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 +174,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 +185,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;
@@ -222,4 +225,13 @@ export class StateView {
 
         return this;
     }
+
+    has(obj: Ref) {
+        return this.items.has(obj[$changes]);
+    }
+
+    hasTag(ob: Ref, tag: number = DEFAULT_VIEW_TAG) {
+        const tags = this.tags?.get(ob[$changes]);
+        return tags?.has(tag) ?? false;
+    }
 }

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

@@ -14,6 +14,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
 
     protected $items: Map<K, V> = new Map<K, V>();
     protected $indexes: Map<number, K> = new Map<number, K>();
+    protected deletedItems: { [field: string]: V } = {};
 
     protected [$changes]: ChangeTree;
 
@@ -31,9 +32,9 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
      */
     static [$filter] (ref: MapSchema, index: number, view: StateView) {
         return (
-            !view  ||
+            !view ||
             typeof (ref[$childType]) === "string" ||
-            view.items.has(ref[$getByIndex](index)[$changes])
+            view.items.has((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes])
         );
     }
 
@@ -86,41 +87,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);
@@ -145,7 +143,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
     delete(key: K) {
         const index = this[$changes].indexes[key];
 
-        this[$changes].delete(index);
+        this.deletedItems[index] = this[$changes].delete(index);;
 
         return this.$items.delete(key);
     }
@@ -209,19 +207,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
     }
 
     protected [$onEncodeEnd]() {
-        const changeTree = this[$changes];
-        const keys = Object.keys(changeTree.indexedOperations);
-
-        for (let i = 0, len = keys.length; i < len; i++) {
-            const key = keys[i];
-            const fieldIndex = Number(key);
-            const operation = changeTree.indexedOperations[key];
-
-            if (operation === OPERATION.DELETE) {
-                const index = this[$getByIndex](fieldIndex) as string;
-                delete changeTree.indexes[index];
-            }
-        }
+        this.deletedItems = {};
     }
 
     toJSON() {