@colyseus/schema 3.0.10 → 3.0.12

package/build/esm/index.mjs

@@ -857,14 +857,13 @@ const Metadata = {
         fieldIndex++;
         for (const field in fields) {
             const type = fields[field];
-            const normalizedType = getNormalizedType(type);
             // FIXME: this code is duplicated from @type() annotation
             const complexTypeKlass = (Array.isArray(type))
                 ? getType("array")
                 : (typeof (Object.keys(type)[0]) === "string") && getType(Object.keys(type)[0]);
             const childType = (complexTypeKlass)
                 ? Object.values(type)[0]
-                : normalizedType;
+                : getNormalizedType(type);
             Metadata.addField(metadata, fieldIndex, field, type, getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass));
             fieldIndex++;
         }
@@ -1236,6 +1235,7 @@ class ChangeTree {
             //
             this.root?.remove(previousValue[$changes]);
         }
+        deleteOperationAtIndex(this.allChanges, allChangesIndex);
         //
         // FIXME: this is looking a ugly and repeated
         //
@@ -1244,7 +1244,6 @@ class ChangeTree {
             enqueueChangeTree(this.root, this, 'filteredChanges');
         }
         else {
-            deleteOperationAtIndex(this.allChanges, allChangesIndex);
             enqueueChangeTree(this.root, this, 'changes');
         }
     }
@@ -1531,19 +1530,6 @@ function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges
         //
         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;
     }
@@ -1891,7 +1877,8 @@ class ArraySchema {
                     else {
                         if (setValue[$changes]) {
                             assertInstanceType(setValue, obj[$childType], obj, key);
-                            if (obj.items[key] !== undefined) {
+                            const previousValue = obj.items[key];
+                            if (previousValue !== undefined) {
                                 if (setValue[$changes].isNew) {
                                     this[$changes].indexedOperation(Number(key), OPERATION.MOVE_AND_ADD);
                                 }
@@ -1903,10 +1890,13 @@ class ArraySchema {
                                         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);
@@ -2544,33 +2534,34 @@ class MapSchema {
         // See: https://github.com/colyseus/colyseus/issues/561#issuecomment-1646733468
         key = key.toString();
         const changeTree = this[$changes];
-        // get "index" for this value.
-        const isReplace = typeof (changeTree.indexes[key]) !== "undefined";
-        const index = (isReplace)
-            ? changeTree.indexes[key]
-            : changeTree.indexes[$numFields] ?? 0;
-        let operation = (isReplace)
-            ? OPERATION.REPLACE
-            : OPERATION.ADD;
         const isRef = (value[$changes]) !== undefined;
-        //
-        // (encoding)
-        // set a unique id to relate directly with this key/value.
-        //
-        if (!isReplace) {
+        let index;
+        let operation;
+        // IS REPLACE?
+        if (typeof (changeTree.indexes[key]) !== "undefined") {
+            index = changeTree.indexes[key];
+            operation = OPERATION.REPLACE;
+            const previousValue = this.$items.get(key);
+            if (previousValue === 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.
+                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;
             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);
         changeTree.change(index, operation);
         //
@@ -2942,13 +2933,14 @@ function getPropertyDescriptor(fieldCached, fieldIndex, type, complexTypeKlass)
                 const changeTree = this[$changes];
                 //
                 // Replacing existing "ref", remove it from root.
-                // TODO: if there are other references to this instance, we should not remove it from root.
                 //
                 if (previousValue !== undefined && previousValue[$changes]) {
                     changeTree.root?.remove(previousValue[$changes]);
+                    this.constructor[$track](changeTree, fieldIndex, OPERATION.DELETE_AND_ADD);
+                }
+                else {
+                    this.constructor[$track](changeTree, fieldIndex, OPERATION.ADD);
                 }
-                // flag the change for encoding.
-                this.constructor[$track](changeTree, fieldIndex, OPERATION.ADD);
                 //
                 // call setParent() recursively for this and its child
                 // structures.
@@ -3745,16 +3737,33 @@ 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));
         return refCount;
     }
     removeChangeFromChangeSet(changeSetName, 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;
         }
     }
     clear() {
@@ -3790,12 +3799,6 @@ class Encoder {
         const changeTrees = this.root[changeSetName];
         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);
@@ -3805,13 +3808,24 @@ class Encoder {
                     view.invisible.delete(changeTree); // remove from invisible list
                 }
             }
+            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) {
                 buffer[it.offset++] = SWITCH_TO_STRUCTURE & 255;
                 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)
                     ? Math.abs(fieldIndex) // "pure" operation without fieldIndex (e.g. CLEAR, REVERSE, etc.)
@@ -3908,14 +3922,16 @@ class Encoder {
     encodeView(view, sharedOffset, it, bytes = this.sharedBuffer) {
         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;
             }
@@ -3925,7 +3941,6 @@ class Encoder {
             const metadata = ctor[Symbol.metadata];
             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];
@@ -3939,7 +3954,7 @@ class Encoder {
         // (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);
         return Buffer.concat([
@@ -3947,20 +3962,6 @@ class Encoder {
             bytes.subarray(viewOffset, it.offset)
         ]);
     }
-    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;
@@ -4692,7 +4693,8 @@ 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)
          */
-        this.changes = {};
+        // TODO: use map here!? may fix encode ordering issue
+        this.changes = new Map();
     }
     // TODO: allow to set multiple tags at once
     add(obj, tag = DEFAULT_VIEW_TAG, checkIncludeParent = true) {
@@ -4708,16 +4710,16 @@ 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
         if (tag !== DEFAULT_VIEW_TAG) {
@@ -4773,24 +4775,29 @@ class StateView {
         });
         return this;
     }
-    addParent(changeTree, parentIndex, tag) {
+    addParentOf(childChangeTree, tag) {
+        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.parent?.[$changes];
         if (parentChangeTree && (parentChangeTree.filteredChanges !== undefined)) {
-            this.addParent(parentChangeTree, changeTree.parentIndex, tag);
+            this.addParentOf(changeTree, tag);
         }
+        if (
         // parent is already available, no need to add it!
-        if (!this.invisible.has(changeTree)) {
+        !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) {
                 this.tags = new WeakMap();
@@ -4816,20 +4823,20 @@ class StateView {
         this.items.delete(changeTree);
         const ref = changeTree.ref;
         const 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) {
             // parent is collection (Map/Array)
             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;