@colyseus/schema 3.0.26 → 3.0.27

package/build/cjs/index.js

@@ -1,5 +1,7 @@
 'use strict';
 
+require('util');
+
 const SWITCH_TO_STRUCTURE = 255; // (decoding collides with DELETE_AND_ADD + fieldIndex = 63)
 const TYPE_ID = 213;
 /**
@@ -973,10 +975,18 @@ function setOperationAtIndex(changeSet, index) {
     }
 }
 function deleteOperationAtIndex(changeSet, index) {
-    const operationsIndex = changeSet.indexes[index];
-    if (operationsIndex !== undefined) {
-        changeSet.operations[operationsIndex] = undefined;
+    let operationsIndex = changeSet.indexes[index];
+    if (operationsIndex === undefined) {
+        //
+        // if index is not found, we need to find the last operation
+        // FIXME: this is not very efficient
+        //
+        // > See "should allow consecutive splices (same place)" tests
+        //
+        operationsIndex = Object.values(changeSet.indexes).at(-1);
+        index = Object.entries(changeSet.indexes).find(([_, value]) => value === operationsIndex)?.[0];
     }
+    changeSet.operations[operationsIndex] = undefined;
     delete changeSet.indexes[index];
 }
 function enqueueChangeTree(root, changeTree, changeSet, queueRootIndex = changeTree[changeSet].queueRootIndex) {
@@ -1161,15 +1171,22 @@ class ChangeTree {
     }
     _shiftAllChangeIndexes(shiftIndex, startIndex = 0, changeSet) {
         const newIndexes = {};
+        let newKey = 0;
         for (const key in changeSet.indexes) {
-            const index = changeSet.indexes[key];
-            if (index > startIndex) {
-                newIndexes[Number(key) + shiftIndex] = index;
-            }
-            else {
-                newIndexes[key] = index;
-            }
-        }
+            newIndexes[newKey++] = changeSet.indexes[key];
+        }
+        // const newIndexes = {};
+        // let newKey = 0;
+        // for (const key in changeSet.indexes) {
+        //     const index = changeSet.indexes[key];
+        //     newIndexes[newKey++] = changeSet.indexes[key];
+        //     console.log("...shiftAllChangeIndexes", { index: key, targetIndex: index, startIndex, shiftIndex });
+        //     if (index > startIndex) {
+        //         newIndexes[Number(key) + shiftIndex] = index;
+        //     } else {
+        //         newIndexes[Number(key)] = index;
+        //     }
+        // }
         changeSet.indexes = newIndexes;
         for (let i = 0; i < changeSet.operations.length; i++) {
             const index = changeSet.operations[i];
@@ -1512,6 +1529,7 @@ const encodeArray = function (encoder, bytes, changeTree, field, operation, it,
     }
     const type = changeTree.getType(field);
     const value = changeTree.getValue(field, isEncodeAll);
+    // console.log({ type, field, value });
     // console.log("encodeArray -> ", {
     //     ref: changeTree.ref.constructor.name,
     //     field,
@@ -1990,8 +2008,6 @@ class ArraySchema {
             return undefined;
         }
         this[$changes].delete(index, undefined, this.items.length - 1);
-        // this.tmpItems[index] = undefined;
-        // this.tmpItems.pop();
         this.deletedIndexes[index] = true;
         return this.items.pop();
     }
@@ -2142,31 +2158,50 @@ class ArraySchema {
      * @param deleteCount The number of elements to remove.
      * @param insertItems Elements to insert into the array in place of the deleted elements.
      */
-    splice(start, deleteCount = this.items.length - start, ...insertItems) {
+    splice(start, deleteCount, ...insertItems) {
         const changeTree = this[$changes];
+        const itemsLength = this.items.length;
         const tmpItemsLength = this.tmpItems.length;
         const insertCount = insertItems.length;
         // build up-to-date list of indexes, excluding removed values.
         const indexes = [];
         for (let i = 0; i < tmpItemsLength; i++) {
-            // if (this.tmpItems[i] !== undefined) {
             if (this.deletedIndexes[i] !== true) {
                 indexes.push(i);
             }
         }
-        // delete operations at correct index
-        for (let i = start; i < start + deleteCount; i++) {
-            const index = indexes[i];
-            changeTree.delete(index);
-            // this.tmpItems[index] = undefined;
-            this.deletedIndexes[index] = true;
+        if (itemsLength > start) {
+            // if deleteCount is not provided, delete all items from start to end
+            if (deleteCount === undefined) {
+                deleteCount = itemsLength - start;
+            }
+            //
+            // delete operations at correct index
+            //
+            for (let i = start; i < start + deleteCount; i++) {
+                const index = indexes[i];
+                changeTree.delete(index, exports.OPERATION.DELETE);
+                this.deletedIndexes[index] = true;
+            }
         }
-        // force insert operations
-        for (let i = 0; i < insertCount; i++) {
-            const addIndex = indexes[start] + i;
-            changeTree.indexedOperation(addIndex, exports.OPERATION.ADD);
-            // set value's parent/root
-            insertItems[i][$changes]?.setParent(this, changeTree.root, addIndex);
+        else {
+            // not enough items to delete
+            deleteCount = 0;
+        }
+        // insert operations
+        if (insertCount > 0) {
+            if (insertCount > deleteCount) {
+                console.error("Inserting more elements than deleting during ArraySchema#splice()");
+                throw new Error("ArraySchema#splice(): insertCount must be equal or lower than deleteCount.");
+            }
+            for (let i = 0; i < insertCount; i++) {
+                const addIndex = (indexes[start] ?? itemsLength) + i;
+                changeTree.indexedOperation(addIndex, (this.deletedIndexes[addIndex])
+                    ? exports.OPERATION.DELETE_AND_ADD
+                    : exports.OPERATION.ADD);
+                // set value's parent/root
+                insertItems[i][$changes]?.setParent(this, changeTree.root, addIndex);
+            }
         }
         //
         // delete exceeding indexes from "allChanges"
@@ -2174,6 +2209,16 @@ class ArraySchema {
         //
         if (deleteCount > insertCount) {
             changeTree.shiftAllChangeIndexes(-(deleteCount - insertCount), indexes[start + insertCount]);
+            // debugChangeSet("AFTER SHIFT indexes", changeTree.allChanges);
+        }
+        //
+        // FIXME: this code block is duplicated on ChangeTree
+        //
+        if (changeTree.filteredChanges !== undefined) {
+            enqueueChangeTree(changeTree.root, changeTree, 'filteredChanges');
+        }
+        else {
+            enqueueChangeTree(changeTree.root, changeTree, 'changes');
         }
         return this.items.splice(start, deleteCount, ...insertItems);
     }
@@ -2429,9 +2474,6 @@ class ArraySchema {
             : this.deletedIndexes[index]
                 ? this.items[index]
                 : this.tmpItems[index] || this.items[index];
-        // return (isEncodeAll)
-        //     ? this.items[index]
-        //     : this.tmpItems[index] ?? this.items[index];
     }
     [$deleteByIndex](index) {
         this.items[index] = undefined;
@@ -3803,10 +3845,10 @@ class Encoder {
                     view.invisible.delete(changeTree); // remove from invisible list
                 }
             }
-            const operations = changeTree[changeSetName];
+            const changeSet = changeTree[changeSetName];
             const ref = changeTree.ref;
             // TODO: avoid iterating over change tree if no changes were made
-            const numChanges = operations.operations.length;
+            const numChanges = changeSet.operations.length;
             if (numChanges === 0) {
                 continue;
             }
@@ -3821,7 +3863,7 @@ class Encoder {
                 encode.number(buffer, changeTree.refId, it);
             }
             for (let j = 0; j < numChanges; j++) {
-                const fieldIndex = operations.operations[j];
+                const fieldIndex = changeSet.operations[j];
                 const operation = (fieldIndex < 0)
                     ? Math.abs(fieldIndex) // "pure" operation without fieldIndex (e.g. CLEAR, REVERSE, etc.)
                     : (isEncodeAll)