@colyseus/schema 3.0.0-alpha.33 → 3.0.0-alpha.35

package/src/encoder/ChangeTree.ts

@@ -1,6 +1,6 @@
 import { OPERATION } from "../encoding/spec";
 import { Schema } from "../Schema";
-import { $changes, $childType, $decoder, $onEncodeEnd, $encoder, $getByIndex, $isNew } from "../types/symbols";
+import { $changes, $childType, $decoder, $onEncodeEnd, $encoder, $getByIndex, $refTypeFieldIndexes, $viewFieldIndexes } from "../types/symbols";
 
 import type { MapSchema } from "../types/custom/MapSchema";
 import type { ArraySchema } from "../types/custom/ArraySchema";
@@ -27,6 +27,50 @@ export type Ref = Schema
     | CollectionSchema
     | SetSchema;
 
+export type ChangeSetName = "changes"
+    | "allChanges"
+    | "filteredChanges"
+    | "allFilteredChanges";
+
+export interface IndexedOperations {
+    [index: number]: OPERATION;
+}
+
+export interface ChangeSet {
+    // field index -> operation index
+    indexes: { [index: number]: number };
+    operations: OPERATION[]
+    queueRootIndex?: number; // index of ChangeTree structure in `root.changes` or `root.filteredChanges`
+}
+
+export function setOperationAtIndex(changeSet: ChangeSet, index: number) {
+    const operationsIndex = changeSet.indexes[index];
+    if (operationsIndex === undefined) {
+        changeSet.indexes[index] = changeSet.operations.push(index) - 1;
+    } else {
+        changeSet.operations[operationsIndex] = index;
+    }
+}
+
+export function deleteOperationAtIndex(changeSet: ChangeSet, index: number) {
+    const operationsIndex = changeSet.indexes[index];
+    if (operationsIndex !== undefined) {
+        changeSet.operations[operationsIndex] = undefined;
+    }
+    delete changeSet.indexes[index];
+}
+
+function enqueueChangeTree(
+    root: Root,
+    changeTree: ChangeTree,
+    changeSet: 'changes' | 'filteredChanges' | 'allFilteredChanges',
+    queueRootIndex = changeTree[changeSet].queueRootIndex
+) {
+    if (root && root[changeSet][queueRootIndex] !== changeTree) {
+        changeTree[changeSet].queueRootIndex = root[changeSet].push(changeTree) - 1;
+    }
+}
+
 export class ChangeTree<T extends Ref=any> {
     ref: T;
     refId: number;
@@ -38,17 +82,26 @@ export class ChangeTree<T extends Ref=any> {
     isFiltered: boolean = false;
     isPartiallyFiltered: boolean = false;
 
-    currentOperationIndex: number = 0;
+    indexedOperations: IndexedOperations = {};
 
-    changes = new Map<number, OPERATION>();
-    allChanges = new Map<number, OPERATION>();
-
-    allFilteredChanges: Map<number, OPERATION>;
-    filteredChanges: Map<number, OPERATION>;
+    //
+    // TODO:
+    //   try storing the index + operation per item.
+    //   example: 1024 & 1025 => ADD, 1026 => DELETE
+    //
+    // => https://chatgpt.com/share/67107d0c-bc20-8004-8583-83b17dd7c196
+    //
+    changes: ChangeSet = { indexes: {}, operations: [] };
+    allChanges: ChangeSet = { indexes: {}, operations: [] };
+    filteredChanges: ChangeSet;
+    allFilteredChanges: ChangeSet;
 
     indexes: {[index: string]: any}; // TODO: remove this, only used by MapSchema/SetSchema/CollectionSchema (`encodeKeyValueOperation`)
 
-    [$isNew] = true;
+    /**
+     * Is this a new instance? Used on ArraySchema to determine OPERATION.MOVE_AND_ADD operation.
+     */
+    isNew = true;
 
     constructor(ref: T) {
         this.ref = ref;
@@ -56,15 +109,15 @@ export class ChangeTree<T extends Ref=any> {
         //
         // Does this structure have "filters" declared?
         //
-        if (ref.constructor[Symbol.metadata]?.[-2]) {
-            this.allFilteredChanges = new Map<number, OPERATION>();
-            this.filteredChanges = new Map<number, OPERATION>();
+        if (ref.constructor[Symbol.metadata]?.[$viewFieldIndexes]) {
+            this.allFilteredChanges = { indexes: {}, operations: [] };
+            this.filteredChanges = { indexes: {}, operations: [] };
         }
     }
 
     setRoot(root: Root) {
         this.root = root;
-        this.root.add(this);
+        const isNewChangeTree = this.root.add(this);
 
         const metadata: Metadata = this.ref.constructor[Symbol.metadata];
 
@@ -78,25 +131,26 @@ export class ChangeTree<T extends Ref=any> {
             this.checkIsFiltered(metadata, this.parent, this.parentIndex);
 
             if (this.isFiltered || this.isPartiallyFiltered) {
-                this.root.allFilteredChanges.set(this, this.allFilteredChanges);
-                this.root.filteredChanges.set(this, this.filteredChanges);
+                enqueueChangeTree(root, this, 'filteredChanges');
+                if (isNewChangeTree) {
+                    this.root.allFilteredChanges.push(this);
+                }
             }
         }
 
         if (!this.isFiltered) {
-            this.root.changes.set(this, this.changes);
-            this.root.allChanges.set(this, this.allChanges);
+            enqueueChangeTree(root, this, 'changes');
+            if (isNewChangeTree) {
+                this.root.allChanges.push(this);
+            }
         }
 
-        this.ensureRefId();
-
+        // Recursively set root on child structures
         if (metadata) {
-            metadata[-4]?.forEach((index) => {
+            metadata[$refTypeFieldIndexes]?.forEach((index) => {
                 const field = metadata[index as any as number];
                 const value = this.ref[field.name];
-                if (value) {
-                    value[$changes].setRoot(root);
-                }
+                value?.[$changes].setRoot(root);
             });
 
         } else if (this.ref[$childType] && typeof(this.ref[$childType]) !== "string") {
@@ -119,40 +173,42 @@ export class ChangeTree<T extends Ref=any> {
         // avoid setting parents with empty `root`
         if (!root) { return; }
 
-        root.add(this);
-
         const metadata: Metadata = this.ref.constructor[Symbol.metadata];
 
         // skip if parent is already set
         if (root !== this.root) {
             this.root = root;
+            const isNewChangeTree = root.add(this);
 
             if (root.types.hasFilters) {
                 this.checkIsFiltered(metadata, parent, parentIndex);
 
                 if (this.isFiltered || this.isPartiallyFiltered) {
-                    this.root.filteredChanges.set(this, this.filteredChanges);
-                    this.root.allFilteredChanges.set(this, this.filteredChanges);
+                    enqueueChangeTree(root, this, 'filteredChanges');
+                    if (isNewChangeTree) {
+                        this.root.allFilteredChanges.push(this);
+                    }
                 }
             }
 
             if (!this.isFiltered) {
-                this.root.changes.set(this, this.changes);
-                this.root.allChanges.set(this, this.allChanges);
+                enqueueChangeTree(root, this, 'changes');
+                if (isNewChangeTree) {
+                    this.root.allChanges.push(this);
+                }
             }
 
-            this.ensureRefId();
+        } else {
+            root.add(this);
         }
 
         // assign same parent on child structures
         if (metadata) {
-            metadata[-4]?.forEach((index) => {
+            metadata[$refTypeFieldIndexes]?.forEach((index) => {
                 const field = metadata[index as any as number];
                 const value = this.ref[field.name];
                 value?.[$changes].setParent(this.ref, root, index);
 
-                // console.log(this.ref.constructor.name, field.name, value);
-
                 // try { throw new Error(); } catch (e) {
                 //     console.log(e.stack);
                 // }
@@ -174,7 +230,7 @@ export class ChangeTree<T extends Ref=any> {
         //
         const metadata: Metadata = this.ref.constructor[Symbol.metadata];
         if (metadata) {
-            metadata[-4]?.forEach((index) => {
+            metadata[$refTypeFieldIndexes]?.forEach((index) => {
                 const field = metadata[index as any as number];
                 const value = this.ref[field.name];
                 if (value) {
@@ -191,8 +247,11 @@ export class ChangeTree<T extends Ref=any> {
     }
 
     operation(op: OPERATION) {
-        this.changes.set(--this.currentOperationIndex, op);
-        this.root?.changes.set(this, this.changes);
+        // operations without index use negative values to represent them
+        // this is checked during .encode() time.
+        this.changes.operations.push(-op);
+
+        enqueueChangeTree(this.root, this, 'changes');
     }
 
     change(index: number, operation: OPERATION = OPERATION.ADD) {
@@ -203,7 +262,7 @@ export class ChangeTree<T extends Ref=any> {
             ? this.filteredChanges
             : this.changes;
 
-        const previousOperation = changeSet.get(index);
+        const previousOperation = this.indexedOperations[index];
         if (!previousOperation || previousOperation === OPERATION.DELETE) {
             const op = (!previousOperation)
                 ? operation
@@ -213,17 +272,22 @@ export class ChangeTree<T extends Ref=any> {
             //
             // TODO: are DELETE operations being encoded as ADD here ??
             //
-            changeSet.set(index, op);
+            this.indexedOperations[index] = op;
         }
 
+        setOperationAtIndex(changeSet, index);
+
         if (isFiltered) {
-            this.allFilteredChanges.set(index, OPERATION.ADD);
-            this.root?.filteredChanges.set(this, this.filteredChanges);
-            this.root?.allFilteredChanges.set(this, this.allFilteredChanges);
+            setOperationAtIndex(this.allFilteredChanges, index);
+
+            if (this.root) {
+                enqueueChangeTree(this.root, this, 'filteredChanges');
+                enqueueChangeTree(this.root, this, 'allFilteredChanges');
+            }
 
         } else {
-            this.allChanges.set(index, OPERATION.ADD);
-            this.root?.changes.set(this, this.changes);
+            setOperationAtIndex(this.allChanges, index);
+            enqueueChangeTree(this.root, this, 'changes');
         }
     }
 
@@ -237,13 +301,16 @@ export class ChangeTree<T extends Ref=any> {
             ? this.filteredChanges
             : this.changes;
 
-        const changeSetEntries = Array.from(changeSet.entries());
-        changeSet.clear();
-
-        // Re-insert each entry with the shifted index
-        for (const [index, op] of changeSetEntries) {
-            changeSet.set(index + shiftIndex, op);
+        const newIndexedOperations = {};
+        const newIndexes = {};
+        for (const index in this.indexedOperations) {
+            newIndexedOperations[Number(index) + shiftIndex] = this.indexedOperations[index];
+            newIndexes[Number(index) + shiftIndex] = changeSet[index];
         }
+        this.indexedOperations = newIndexedOperations;
+        changeSet.indexes = newIndexes;
+
+        changeSet.operations = changeSet.operations.map((index) => index + shiftIndex);
     }
 
     shiftAllChangeIndexes(shiftIndex: number, startIndex: number = 0) {
@@ -261,25 +328,39 @@ export class ChangeTree<T extends Ref=any> {
         }
     }
 
-    private _shiftAllChangeIndexes(shiftIndex: number, startIndex: number = 0, allChangeSet: Map<number, OPERATION>) {
-        Array.from(allChangeSet.entries()).forEach(([index, op]) => {
-            if (index >= startIndex) {
-                allChangeSet.delete(index);
-                allChangeSet.set(index + shiftIndex, op);
+    private _shiftAllChangeIndexes(shiftIndex: number, startIndex: number = 0, changeSet: ChangeSet) {
+        const newIndexes = {};
+
+        for (const key in changeSet.indexes) {
+            const index = changeSet.indexes[key];
+            if (index > startIndex) {
+                newIndexes[Number(key) + shiftIndex] = index;
+            } else {
+                newIndexes[key] = index;
             }
-        });
+        }
+        changeSet.indexes = newIndexes;
+
+        for (let i = 0; i < changeSet.operations.length; i++) {
+            const index = changeSet.operations[i];
+            if (index > startIndex) {
+                changeSet.operations[i] = index + shiftIndex;
+            }
+        }
     }
 
-    indexedOperation(index: number, operation: OPERATION, allChangesIndex = index) {
-        if (this.filteredChanges !== undefined) {
-            this.allFilteredChanges.set(allChangesIndex, OPERATION.ADD);
-            this.filteredChanges.set(index, operation);
-            this.root?.filteredChanges.set(this, this.filteredChanges);
+    indexedOperation(index: number, operation: OPERATION, allChangesIndex: number = index) {
+        this.indexedOperations[index] = operation;
+
+        if (this.filteredChanges) {
+            setOperationAtIndex(this.allFilteredChanges, allChangesIndex);
+            setOperationAtIndex(this.filteredChanges, index);
+            enqueueChangeTree(this.root, this, 'filteredChanges');
 
         } else {
-            this.allChanges.set(allChangesIndex, OPERATION.ADD);
-            this.changes.set(index, operation);
-            this.root?.changes.set(this, this.changes);
+            setOperationAtIndex(this.allChanges, allChangesIndex);
+            setOperationAtIndex(this.changes, index);
+            enqueueChangeTree(this.root, this, 'changes');
         }
     }
 
@@ -300,8 +381,7 @@ export class ChangeTree<T extends Ref=any> {
     }
 
     getChange(index: number) {
-        // TODO: optimize this. avoid checking against multiple instances
-        return this.changes.get(index) ?? this.filteredChanges?.get(index);
+        return this.indexedOperations[index];
     }
 
     //
@@ -328,9 +408,10 @@ export class ChangeTree<T extends Ref=any> {
             ? this.filteredChanges
             : this.changes;
 
-        const previousValue = this.getValue(index);
+        this.indexedOperations[index] = operation ?? OPERATION.DELETE;
+        setOperationAtIndex(changeSet, index);
 
-        changeSet.set(index, operation ?? OPERATION.DELETE);
+        const previousValue = this.getValue(index);
 
         // remove `root` reference
         if (previousValue && previousValue[$changes]) {
@@ -348,26 +429,30 @@ export class ChangeTree<T extends Ref=any> {
         }
 
         //
-        // FIXME: this is looking a bit ugly (and repeated from `.change()`)
+        // FIXME: this is looking a ugly and repeated
         //
         if (this.filteredChanges) {
-            this.root?.filteredChanges.set(this, this.filteredChanges);
-            this.allFilteredChanges.delete(allChangesIndex);
+            deleteOperationAtIndex(this.allFilteredChanges, allChangesIndex);
+            enqueueChangeTree(this.root, this, 'filteredChanges');
 
         } else {
-            this.root?.changes.set(this, this.changes);
-            this.allChanges.delete(allChangesIndex);
+            deleteOperationAtIndex(this.allChanges, allChangesIndex);
+            enqueueChangeTree(this.root, this, 'changes');
         }
     }
 
     endEncode() {
-        this.changes.clear();
+        this.indexedOperations = {};
+
+        // // clear changes
+        // this.changes.indexes = {};
+        // this.changes.operations.length = 0;
 
         // ArraySchema and MapSchema have a custom "encode end" method
         this.ref[$onEncodeEnd]?.();
 
         // Not a new instance anymore
-        delete this[$isNew];
+        this.isNew = false;
     }
 
     discard(discardAll: boolean = false) {
@@ -378,15 +463,26 @@ export class ChangeTree<T extends Ref=any> {
         //
         this.ref[$onEncodeEnd]?.();
 
-        this.changes.clear();
-        this.filteredChanges?.clear();
+        this.indexedOperations = {};
 
-        // reset operation index
-        this.currentOperationIndex = 0;
+        this.changes.indexes = {};
+        this.changes.operations.length = 0;
+        this.changes.queueRootIndex = undefined;
+
+        if (this.filteredChanges !== undefined) {
+            this.filteredChanges.indexes = {};
+            this.filteredChanges.operations.length = 0;
+            this.filteredChanges.queueRootIndex = undefined;
+        }
 
         if (discardAll) {
-            this.allChanges.clear();
-            this.allFilteredChanges?.clear();
+            this.allChanges.indexes = {};
+            this.allChanges.operations.length = 0;
+
+            if (this.allFilteredChanges !== undefined) {
+                this.allFilteredChanges.indexes = {};
+                this.allFilteredChanges.operations.length = 0;
+            }
 
             // remove children references
             this.forEachChild((changeTree, _) =>
@@ -398,13 +494,14 @@ export class ChangeTree<T extends Ref=any> {
      * Recursively discard all changes from this, and child structures.
      */
     discardAll() {
-        this.changes.forEach((_, fieldIndex) => {
-            const value = this.getValue(fieldIndex);
+        const keys = Object.keys(this.indexedOperations);
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const value = this.getValue(Number(keys[i]));
 
             if (value && value[$changes]) {
                 value[$changes].discardAll();
             }
-        });
+        }
 
         this.discard();
     }
@@ -419,49 +516,57 @@ export class ChangeTree<T extends Ref=any> {
     }
 
     get changed() {
-        return this.changes.size > 0;
+        return (Object.entries(this.indexedOperations).length > 0);
     }
 
     protected checkIsFiltered(metadata: Metadata, parent: Ref, parentIndex: number) {
         // Detect if current structure has "filters" declared
-        this.isPartiallyFiltered = metadata?.[-2] !== undefined;
+        this.isPartiallyFiltered = metadata?.[$viewFieldIndexes] !== undefined;
 
         if (this.isPartiallyFiltered) {
-            this.filteredChanges = this.filteredChanges || new Map<number, OPERATION>();
-            this.allFilteredChanges = this.allFilteredChanges || new Map<number, OPERATION>();
+            this.filteredChanges = this.filteredChanges || { indexes: {}, operations: [] };
+            this.allFilteredChanges = this.allFilteredChanges || { indexes: {}, operations: [] };
         }
 
-        if (parent) {
-            if (!Metadata.isValidInstance(parent)) {
-                const parentChangeTree = parent[$changes];
-                parent = parentChangeTree.parent;
-                parentIndex = parentChangeTree.parentIndex;
-            }
+        // skip if parent is not set
+        if (!parent) {
+            return;
+        }
+
+        if (!Metadata.isValidInstance(parent)) {
+            const parentChangeTree = parent[$changes];
+            parent = parentChangeTree.parent;
+            parentIndex = parentChangeTree.parentIndex;
+        }
 
-            const parentMetadata = parent?.constructor?.[Symbol.metadata];
-            this.isFiltered = (parent && parentMetadata?.[-2]?.includes(parentIndex));
+        const parentMetadata = parent.constructor?.[Symbol.metadata];
+        this.isFiltered = parentMetadata?.[$viewFieldIndexes]?.includes(parentIndex);
 
-            //
-            // TODO: refactor this!
-            //
-            //      swapping `changes` and `filteredChanges` is required here
-            //      because "isFiltered" may not be imedialely available on `change()`
-            //
-            if (this.isFiltered) {
-                this.filteredChanges = new Map<number, OPERATION>();
-                this.allFilteredChanges = new Map<number, OPERATION>();
-
-                if (this.changes.size > 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;
-                }
+        //
+        // TODO: refactor this!
+        //
+        //      swapping `changes` and `filteredChanges` is required here
+        //      because "isFiltered" may not be imedialely available on `change()`
+        //
+        if (this.isFiltered) {
+            this.filteredChanges = { indexes: {}, operations: [] };
+            this.allFilteredChanges = { indexes: {}, operations: [] };
+
+            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;
+
+                // console.log("SWAP =>", {
+                //     "this.allFilteredChanges": this.allFilteredChanges,
+                //     "this.allChanges": this.allChanges
+                // })
             }
         }
     }

package/src/encoder/EncodeOperation.ts

@@ -23,6 +23,7 @@ export type EncodeOperation<T extends Ref = any> = (
     it: Iterator,
     isEncodeAll: boolean,
     hasView: boolean,
+    metadata?: Metadata,
 ) => void;
 
 export function encodeValue(
@@ -68,6 +69,9 @@ export const encodeSchemaOperation: EncodeOperation = function (
     index: number,
     operation: OPERATION,
     it: Iterator,
+    _: any,
+    __: any,
+    metadata: Metadata,
 ) {
     // "compress" field index + operation
     bytes[it.offset++] = (index | operation) & 255;
@@ -78,7 +82,7 @@ export const encodeSchemaOperation: EncodeOperation = function (
     }
 
     const ref = changeTree.ref;
-    const metadata: Metadata = ref.constructor[Symbol.metadata];
+    // const metadata: Metadata = ref.constructor[Symbol.metadata];
     const field = metadata[index];
 
     // TODO: inline this function call small performance gain