@colyseus/schema 3.0.26 → 3.0.28

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,
@@ -91,6 +122,7 @@ export class ChangeTree<T extends Ref=any> {
      * Whether this structure is parent of a filtered structure.
      */
     isFiltered: boolean = false;
+    isVisibilitySharedWithParent?: boolean; // See test case: 'should not be required to manually call view.add() items to child arrays without @view() tag'
 
     indexedOperations: IndexedOperations = {};
 
@@ -292,14 +324,9 @@ 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];
         }
         changeSet.indexes = newIndexes;
 
@@ -524,10 +551,16 @@ export class ChangeTree<T extends Ref=any> {
             ? this.ref.constructor
             :  this.ref[$childType];
 
-        if (!Metadata.isValidInstance(parent)) {
-            const parentChangeTree = parent[$changes];
+        let parentChangeTree: ChangeTree;
+
+        let parentIsCollection = !Metadata.isValidInstance(parent);
+        if (parentIsCollection) {
+            parentChangeTree = parent[$changes];
             parent = parentChangeTree.parent;
             parentIndex = parentChangeTree.parentIndex;
+
+        } else {
+            parentChangeTree = parent[$changes]
         }
 
         const parentConstructor = parent.constructor as typeof Schema;
@@ -538,15 +571,25 @@ export class ChangeTree<T extends Ref=any> {
         }
         key += `-${parentIndex}`;
 
+        const fieldHasViewTag = parentConstructor?.[Symbol.metadata]?.[$viewFieldIndexes]?.includes(parentIndex);
+
         this.isFiltered = parent[$changes].isFiltered // in case parent is already filtered
             || this.root.types.parentFiltered[key]
-            || parentConstructor?.[Symbol.metadata]?.[$viewFieldIndexes]?.includes(parentIndex);
+            || fieldHasViewTag;
 
         //
         // "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.isVisibilitySharedWithParent = (
+                parentChangeTree.isFiltered &&
+                typeof (refType) !== "string" &&
+                !fieldHasViewTag &&
+                parentIsCollection
+            );
+
             if (!this.filteredChanges) {
                 this.filteredChanges = createChangeSet();
                 this.allFilteredChanges = createChangeSet();

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 {
@@ -61,20 +61,19 @@ export class Encoder<T extends Schema = any> {
             if (!changeTree) { continue; }
 
             if (hasView) {
-                if (!view.visible.has(changeTree)) {
+                if (!view.isChangeTreeVisible(changeTree)) {
+                    // console.log("MARK AS INVISIBLE:", { ref: changeTree.ref.constructor.name, refId: changeTree.refId, raw: changeTree.ref.toJSON() });
                     view.invisible.add(changeTree);
                     continue; // skip this change tree
-
-                } else {
-                    view.invisible.delete(changeTree); // remove from invisible list
                 }
+                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; }
 
             const ctor = ref.constructor;
@@ -90,7 +89,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/encoder/StateView.ts

@@ -291,4 +291,28 @@ export class StateView {
         // clear items array
         this.items.length = 0;
     }
+
+    isChangeTreeVisible(changeTree: ChangeTree) {
+        let isVisible = this.visible.has(changeTree);
+
+        //
+        // TODO: avoid checking for parent visibility, most of the time it's not needed
+        // See test case: 'should not be required to manually call view.add() items to child arrays without @view() tag'
+        //
+        if (!isVisible && changeTree.isVisibilitySharedWithParent){
+
+            // console.log("CHECK AGAINST PARENT...", {
+            //     ref: changeTree.ref.constructor.name,
+            //     refId: changeTree.refId,
+            //     parent: changeTree.parent.constructor.name,
+            // });
+
+            if (this.visible.has(changeTree.parent[$changes])) {
+                this.visible.add(changeTree);
+                isVisible = true;
+            }
+        }
+
+        return isVisible;
+    }
 }

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";
@@ -41,8 +41,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         return (
             !view ||
             typeof (ref[$childType]) === "string" ||
-            // view.items.has(ref[$getByIndex](index)[$changes])
-            view.visible.has(ref['tmpItems'][index]?.[$changes])
+            view.isChangeTreeVisible(ref['tmpItems'][index]?.[$changes])
         );
     }
 
@@ -229,9 +228,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 +408,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 +473,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 +799,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) {

package/src/types/custom/CollectionSchema.ts

@@ -33,7 +33,7 @@ export class CollectionSchema<V=any> implements Collection<K, V>{
         return (
             !view ||
             typeof (ref[$childType]) === "string" ||
-            view.visible.has((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes])
+            view.isChangeTreeVisible((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes])
         );
     }
 

package/src/types/custom/MapSchema.ts

@@ -34,7 +34,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
         return (
             !view ||
             typeof (ref[$childType]) === "string" ||
-            view.visible.has((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes])
+            view.isChangeTreeVisible((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes])
         );
     }