@colyseus/schema 3.0.25 → 3.0.27

package/src/encoder/ChangeTree.ts

@@ -1,3 +1,5 @@
+import * as util from "util";
+
 import { OPERATION } from "../encoding/spec";
 import { Schema } from "../Schema";
 import { $changes, $childType, $decoder, $onEncodeEnd, $encoder, $getByIndex, $refTypeFieldIndexes, $viewFieldIndexes } from "../types/symbols";
@@ -39,7 +41,7 @@ export interface IndexedOperations {
 export interface ChangeSet {
     // field index -> operation index
     indexes: { [index: number]: number };
-    operations: OPERATION[]
+    operations: number[];
     queueRootIndex?: number; // index of ChangeTree structure in `root.changes` or `root.filteredChanges`
 }
 
@@ -56,14 +58,43 @@ export function setOperationAtIndex(changeSet: ChangeSet, index: number) {
     }
 }
 
-export function deleteOperationAtIndex(changeSet: ChangeSet, index: number) {
-    const operationsIndex = changeSet.indexes[index];
-    if (operationsIndex !== undefined) {
-        changeSet.operations[operationsIndex] = undefined;
+export function deleteOperationAtIndex(changeSet: ChangeSet, index: number | string) {
+    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];
 }
 
+export function debugChangeSet(label: string, changeSet: ChangeSet) {
+    let indexes: string[] = [];
+    let operations: string[] = [];
+
+    for (const index in changeSet.indexes) {
+        indexes.push(`\t${util.inspect(index, { colors: true })} => [${util.inspect(changeSet.indexes[index], { colors: true })}]`);
+    }
+
+    for (let i = 0; i < changeSet.operations.length; i++) {
+        const index = changeSet.operations[i];
+        if (index !== undefined) {
+            operations.push(`\t[${util.inspect(i, { colors: true })}] => ${util.inspect(index, { colors: true })}`);
+        }
+    }
+
+    console.log(`${label} =>\nindexes (${Object.keys(changeSet.indexes).length}) {`);
+    console.log(indexes.join("\n"), "\n}");
+    console.log(`operations (${changeSet.operations.filter(op => op !== undefined).length}) {`);
+    console.log(operations.join("\n"), "\n}");
+}
+
 export function enqueueChangeTree(
     root: Root,
     changeTree: ChangeTree,
@@ -267,7 +298,7 @@ export class ChangeTree<T extends Ref=any> {
         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;
@@ -292,15 +323,24 @@ export class ChangeTree<T extends Ref=any> {
 
     private _shiftAllChangeIndexes(shiftIndex: number, startIndex: number = 0, changeSet: 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++) {
@@ -372,6 +412,7 @@ export class ChangeTree<T extends Ref=any> {
 
         this.indexedOperations[index] = operation ?? OPERATION.DELETE;
         setOperationAtIndex(changeSet, index);
+        deleteOperationAtIndex(this.allChanges, allChangesIndex);
 
         const previousValue = this.getValue(index);
 
@@ -390,8 +431,6 @@ export class ChangeTree<T extends Ref=any> {
             this.root?.remove(previousValue[$changes]);
         }
 
-        deleteOperationAtIndex(this.allChanges, allChangesIndex);
-
         //
         // FIXME: this is looking a ugly and repeated
         //

package/src/encoder/EncodeOperation.ts

@@ -217,6 +217,8 @@ export const encodeArray: EncodeOperation = function (
     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,

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();
@@ -360,11 +357,13 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         if (this.items.length === 0) { 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, OPERATION.DELETE, allChangesIndex);
+        changeTree.shiftAllChangeIndexes(-1, allChangesIndex);
 
         // this.deletedIndexes[index] = true;
 
@@ -410,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.");
+            }
 
-            // set value's parent/root
-            insertItems[i][$changes]?.setParent(this, changeTree.root, addIndex);
+            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);
+            }
         }
 
         //
@@ -450,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);
@@ -765,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) {