@colyseus/schema 3.0.26 → 3.0.27

package/src/encoder/Encoder.ts

@@ -10,7 +10,7 @@ import { Root } from "./Root";
 
 import type { StateView } from "./StateView";
 import type { Metadata } from "../Metadata";
-import type { ChangeTree } from "./ChangeTree";
+import type { ChangeSetName, ChangeTree } from "./ChangeTree";
 
 export class Encoder<T extends Schema = any> {
     static BUFFER_SIZE = (typeof(Buffer) !== "undefined") && Buffer.poolSize || 8 * 1024; // 8KB
@@ -48,7 +48,7 @@ export class Encoder<T extends Schema = any> {
         it: Iterator = { offset: 0 },
         view?: StateView,
         buffer = this.sharedBuffer,
-        changeSetName: "changes" | "allChanges" | "filteredChanges" | "allFilteredChanges" = "changes",
+        changeSetName: ChangeSetName = "changes",
         isEncodeAll = changeSetName === "allChanges",
         initialOffset = it.offset // cache current offset in case we need to resize the buffer
     ): Buffer {
@@ -70,11 +70,11 @@ export class Encoder<T extends Schema = any> {
                 }
             }
 
-            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; }
 
             const ctor = ref.constructor;
@@ -90,7 +90,7 @@ export class Encoder<T extends Schema = any> {
             }
 
             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.)

package/src/index.ts

@@ -50,7 +50,7 @@ export { getRawChangesCallback } from "./decoder/strategy/RawChanges";
 
 export { Encoder } from "./encoder/Encoder";
 export { encodeSchemaOperation, encodeArray, encodeKeyValueOperation } from "./encoder/EncodeOperation";
-export { ChangeTree, Ref } from "./encoder/ChangeTree";
+export { ChangeTree, Ref, type ChangeSetName, type ChangeSet} from "./encoder/ChangeTree";
 export { StateView } from "./encoder/StateView";
 
 export { Decoder } from "./decoder/Decoder";

package/src/types/custom/ArraySchema.ts

@@ -1,6 +1,6 @@
 import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $onDecodeEnd } from "../symbols";
 import type { Schema } from "../../Schema";
-import { ChangeTree, setOperationAtIndex } from "../../encoder/ChangeTree";
+import { ChangeTree, debugChangeSet, deleteOperationAtIndex, enqueueChangeTree, setOperationAtIndex } from "../../encoder/ChangeTree";
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
 import { Collection } from "../HelperTypes";
@@ -229,9 +229,6 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
 
         this[$changes].delete(index, undefined, this.items.length - 1);
 
-        // this.tmpItems[index] = undefined;
-        // this.tmpItems.pop();
-
         this.deletedIndexes[index] = true;
 
         return this.items.pop();
@@ -412,38 +409,63 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
      */
     splice(
         start: number,
-        deleteCount: number = this.items.length - start,
+        deleteCount?: number,
         ...insertItems: V[]
     ): V[] {
         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: number[] = [];
         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, OPERATION.DELETE);
+                this.deletedIndexes[index] = true;
+            }
+
+        } else {
+            // not enough items to delete
+            deleteCount = 0;
         }
 
-        // force insert operations
-        for (let i = 0; i < insertCount; i++) {
-            const addIndex = indexes[start] + i;
-            changeTree.indexedOperation(addIndex, OPERATION.ADD);
+        // 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])
+                        ? OPERATION.DELETE_AND_ADD
+                        : OPERATION.ADD
+                );
 
-            // set value's parent/root
-            insertItems[i][$changes]?.setParent(this, changeTree.root, addIndex);
+                // set value's parent/root
+                insertItems[i][$changes]?.setParent(this, changeTree.root, addIndex);
+            }
         }
 
         //
@@ -452,6 +474,17 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         //
         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);
@@ -767,10 +800,6 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
             : this.deletedIndexes[index]
                 ? this.items[index]
                 : this.tmpItems[index] || this.items[index];
-
-        // return (isEncodeAll)
-        //     ? this.items[index]
-        //     : this.tmpItems[index] ?? this.items[index];
     }
 
     protected [$deleteByIndex](index: number) {