@colyseus/schema 3.0.24 → 3.0.25

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;
     }
 }
@@ -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();
             }
         }
     }
@@ -3662,19 +3665,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 +3745,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 +3787,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 +3840,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 +3863,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 +3947,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 +3955,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 +3978,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);