@colyseus/schema 3.0.24 → 3.0.26

package/build/cjs/index.js

@@ -960,6 +960,9 @@ const Metadata = {
     }
 };
 
+function createChangeSet() {
+    return { indexes: {}, operations: [] };
+}
 function setOperationAtIndex(changeSet, index) {
     const operationsIndex = changeSet.indexes[index];
     if (operationsIndex === undefined) {
@@ -977,7 +980,11 @@ function deleteOperationAtIndex(changeSet, index) {
     delete changeSet.indexes[index];
 }
 function enqueueChangeTree(root, changeTree, changeSet, queueRootIndex = changeTree[changeSet].queueRootIndex) {
-    if (root && root[changeSet][queueRootIndex] !== changeTree) {
+    if (!root) {
+        // skip
+        return;
+    }
+    else if (root[changeSet][queueRootIndex] !== changeTree) {
         changeTree[changeSet].queueRootIndex = root[changeSet].push(changeTree) - 1;
     }
 }
@@ -1132,7 +1139,7 @@ class ChangeTree {
         const newIndexes = {};
         for (const index in this.indexedOperations) {
             newIndexedOperations[Number(index) + shiftIndex] = this.indexedOperations[index];
-            newIndexes[Number(index) + shiftIndex] = changeSet[index];
+            newIndexes[Number(index) + shiftIndex] = changeSet.indexes[index];
         }
         this.indexedOperations = newIndexedOperations;
         changeSet.indexes = newIndexes;
@@ -1226,6 +1233,7 @@ class ChangeTree {
             : this.changes;
         this.indexedOperations[index] = operation ?? exports.OPERATION.DELETE;
         setOperationAtIndex(changeSet, index);
+        deleteOperationAtIndex(this.allChanges, allChangesIndex);
         const previousValue = this.getValue(index);
         // remove `root` reference
         if (previousValue && previousValue[$changes]) {
@@ -1241,7 +1249,6 @@ class ChangeTree {
             //
             this.root?.remove(previousValue[$changes]);
         }
-        deleteOperationAtIndex(this.allChanges, allChangesIndex);
         //
         // FIXME: this is looking a ugly and repeated
         //
@@ -1254,11 +1261,12 @@ class ChangeTree {
         }
         return previousValue;
     }
-    endEncode() {
+    endEncode(changeSetName) {
         this.indexedOperations = {};
-        // // clear changes
-        // this.changes.indexes = {};
-        // this.changes.operations.length = 0;
+        // clear changeset
+        this[changeSetName].indexes = {};
+        this[changeSetName].operations.length = 0;
+        this[changeSetName].queueRootIndex = undefined;
         // ArraySchema and MapSchema have a custom "encode end" method
         this.ref[$onEncodeEnd]?.();
         // Not a new instance anymore
@@ -1365,24 +1373,19 @@ class ChangeTree {
             || this.root.types.parentFiltered[key]
             || parentConstructor?.[Symbol.metadata]?.[$viewFieldIndexes]?.includes(parentIndex);
         //
-        // TODO: refactor this!
-        //
-        //      swapping `changes` and `filteredChanges` is required here
-        //      because "isFiltered" may not be imedialely available on `change()`
-        //      (this happens when instance is detached from root or parent)
+        // "isFiltered" may not be imedialely available during `change()` due to the instance not being attached to the root yet.
+        // when it's available, we need to enqueue the "changes" changeset into the "filteredChanges" changeset.
         //
         if (this.isFiltered) {
-            this.filteredChanges = { indexes: {}, operations: [] };
-            this.allFilteredChanges = { indexes: {}, operations: [] };
+            if (!this.filteredChanges) {
+                this.filteredChanges = createChangeSet();
+                this.allFilteredChanges = createChangeSet();
+            }
             if (this.changes.operations.length > 0) {
-                // swap changes reference
-                const changes = this.changes;
-                this.changes = this.filteredChanges;
-                this.filteredChanges = changes;
-                // swap "all changes" reference
-                const allFilteredChanges = this.allFilteredChanges;
-                this.allFilteredChanges = this.allChanges;
-                this.allChanges = allFilteredChanges;
+                this.changes.operations.forEach((index) => setOperationAtIndex(this.filteredChanges, index));
+                this.allChanges.operations.forEach((index) => setOperationAtIndex(this.allFilteredChanges, index));
+                this.changes = createChangeSet();
+                this.allChanges = createChangeSet();
             }
         }
     }
@@ -2098,10 +2101,11 @@ class ArraySchema {
             return undefined;
         }
         // const index = Number(Object.keys(changeTree.indexes)[0]);
-        const index = this.tmpItems.findIndex((item, i) => item === this.items[0]);
         const changeTree = this[$changes];
-        changeTree.delete(index);
-        changeTree.shiftAllChangeIndexes(-1, index);
+        const index = this.tmpItems.findIndex(item => item === this.items[0]);
+        const allChangesIndex = this.items.findIndex(item => item === this.items[0]);
+        changeTree.delete(index, exports.OPERATION.DELETE, allChangesIndex);
+        changeTree.shiftAllChangeIndexes(-1, allChangesIndex);
         // this.deletedIndexes[index] = true;
         return this.items.shift();
     }
@@ -3662,19 +3666,6 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-function spliceOne(arr, index) {
-    // manually splice an array
-    if (index === -1 || index >= arr.length) {
-        return false;
-    }
-    const len = arr.length - 1;
-    for (let i = index; i < len; i++) {
-        arr[i] = arr[i + 1];
-    }
-    arr.length = len;
-    return true;
-}
-
 class Root {
     constructor(types) {
         this.types = types;
@@ -3755,11 +3746,16 @@ class Root {
     }
     removeChangeFromChangeSet(changeSetName, changeTree) {
         const changeSet = this[changeSetName];
-        if (spliceOne(changeSet, changeSet.indexOf(changeTree))) {
+        const changeSetIndex = changeSet.indexOf(changeTree);
+        if (changeSetIndex !== -1) {
             changeTree[changeSetName].queueRootIndex = -1;
-            // changeSet[index] = undefined;
+            changeSet[changeSetIndex] = undefined;
             return true;
         }
+        // if (spliceOne(changeSet, changeSet.indexOf(changeTree))) {
+        //     changeTree[changeSetName].queueRootIndex = -1;
+        //     return true;
+        // }
     }
     clear() {
         this.changes.length = 0;
@@ -3792,10 +3788,12 @@ class Encoder {
     ) {
         const hasView = (view !== undefined);
         const rootChangeTree = this.state[$changes];
-        const shouldDiscardChanges = !isEncodeAll && !hasView;
         const changeTrees = this.root[changeSetName];
         for (let i = 0, numChangeTrees = changeTrees.length; i < numChangeTrees; i++) {
             const changeTree = changeTrees[i];
+            if (!changeTree) {
+                continue;
+            }
             if (hasView) {
                 if (!view.visible.has(changeTree)) {
                     view.invisible.add(changeTree);
@@ -3843,10 +3841,6 @@ class Encoder {
                 }
                 encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView, metadata);
             }
-            // if (shouldDiscardChanges) {
-            //     changeTree.discard();
-            //     changeTree.isNew = false; // Not a new instance anymore
-            // }
         }
         if (it.offset > buffer.byteLength) {
             // we can assume that n + 1 poolSize will suffice given that we are likely done with encoding at this point
@@ -3870,19 +3864,6 @@ class Encoder {
             return this.encode({ offset: initialOffset }, view, buffer, changeSetName, isEncodeAll);
         }
         else {
-            //
-            // only clear changes after making sure buffer resize is not required.
-            //
-            if (shouldDiscardChanges) {
-                //
-                // TODO: avoid iterating over change trees twice.
-                //
-                for (let i = 0, numChangeTrees = changeTrees.length; i < numChangeTrees; i++) {
-                    const changeTree = changeTrees[i];
-                    changeTree.discard();
-                    changeTree.isNew = false; // Not a new instance anymore
-                }
-            }
             return buffer.subarray(0, it.offset);
         }
     }
@@ -3967,7 +3948,7 @@ class Encoder {
         let length = this.root.changes.length;
         if (length > 0) {
             while (length--) {
-                this.root.changes[length]?.endEncode();
+                this.root.changes[length]?.endEncode('changes');
             }
             this.root.changes.length = 0;
         }
@@ -3975,7 +3956,7 @@ class Encoder {
         length = this.root.filteredChanges.length;
         if (length > 0) {
             while (length--) {
-                this.root.filteredChanges[length]?.endEncode();
+                this.root.filteredChanges[length]?.endEncode('filteredChanges');
             }
             this.root.filteredChanges.length = 0;
         }
@@ -3998,6 +3979,19 @@ class Encoder {
     }
 }
 
+function spliceOne(arr, index) {
+    // manually splice an array
+    if (index === -1 || index >= arr.length) {
+        return false;
+    }
+    const len = arr.length - 1;
+    for (let i = index; i < len; i++) {
+        arr[i] = arr[i + 1];
+    }
+    arr.length = len;
+    return true;
+}
+
 class DecodingWarning extends Error {
     constructor(message) {
         super(message);