@colyseus/schema 3.0.9 → 3.0.11

package/build/esm/index.mjs

@@ -1236,6 +1236,7 @@ class ChangeTree {
             //
             this.root?.remove(previousValue[$changes]);
         }
+        deleteOperationAtIndex(this.allChanges, allChangesIndex);
         //
         // FIXME: this is looking a ugly and repeated
         //
@@ -1244,7 +1245,6 @@ class ChangeTree {
             enqueueChangeTree(this.root, this, 'filteredChanges');
         }
         else {
-            deleteOperationAtIndex(this.allChanges, allChangesIndex);
             enqueueChangeTree(this.root, this, 'changes');
         }
     }
@@ -1846,7 +1846,6 @@ class ArraySchema {
      * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
      */
     static [(_a$4 = $encoder, _b$4 = $decoder, $filter)](ref, index, view) {
-        // console.log("ArraSchema[$filter] VIEW??", !view)
         return (!view ||
             typeof (ref[$childType]) === "string" ||
             // view.items.has(ref[$getByIndex](index)[$changes])
@@ -2446,6 +2445,7 @@ class ArraySchema {
     }
     [$deleteByIndex](index) {
         this.items[index] = undefined;
+        this.tmpItems[index] = undefined; // TODO: do not try to get "tmpItems" at decoding time.
     }
     [$onEncodeEnd]() {
         this.tmpItems = this.items.slice();
@@ -2453,6 +2453,7 @@ class ArraySchema {
     }
     [$onDecodeEnd]() {
         this.items = this.items.filter((item) => item !== undefined);
+        this.tmpItems = this.items.slice(); // TODO: do no use "tmpItems" at decoding time.
     }
     toArray() {
         return this.items.slice(0);
@@ -3079,7 +3080,6 @@ var _a$2, _b$2;
 class Schema {
     static { this[_a$2] = encodeSchemaOperation; }
     static { this[_b$2] = decodeSchemaOperation; }
-    // public [$changes]: ChangeTree;
     /**
      * Assign the property descriptors required to track changes on this instance.
      * @param instance
@@ -3211,16 +3211,16 @@ class Schema {
     /**
      * Inspect the `refId` of all Schema instances in the tree. Optionally display the contents of the instance.
      *
-     * @param instance Schema instance
+     * @param ref Schema instance
      * @param showContents display JSON contents of the instance
      * @returns
      */
-    static debugRefIds(instance, showContents = false, level = 0) {
-        const ref = instance;
-        const changeTree = ref[$changes];
+    static debugRefIds(ref, showContents = false, level = 0) {
         const contents = (showContents) ? ` - ${JSON.stringify(ref.toJSON())}` : "";
+        const changeTree = ref[$changes];
+        const refId = changeTree.refId;
         let output = "";
-        output += `${getIndent(level)}${ref.constructor.name} (refId: ${ref[$changes].refId})${contents}\n`;
+        output += `${getIndent(level)}${ref.constructor.name} (refId: ${refId})${contents}\n`;
         changeTree.forEachChild((childChangeTree) => output += this.debugRefIds(childChangeTree.ref, showContents, level + 1));
         return output;
     }
@@ -3745,15 +3745,31 @@ 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;
         }
     }
@@ -4035,7 +4051,7 @@ class ReferenceTracker {
         const refCount = this.refCounts[refId];
         if (refCount === undefined) {
             try {
-                throw new DecodingWarning("trying to remove refId that doesn't exist");
+                throw new DecodingWarning("trying to remove refId that doesn't exist: " + refId);
             }
             catch (e) {
                 console.warn(e);