@colyseus/schema 3.0.42 → 3.0.44

package/src/encoder/ChangeTree.ts

@@ -36,17 +36,53 @@ export interface IndexedOperations {
     [index: number]: OPERATION;
 }
 
+// Linked list node for change trees
+export interface ChangeTreeNode {
+    changeTree: ChangeTree;
+    next?: ChangeTreeNode;
+    prev?: ChangeTreeNode;
+}
+
+// Linked list for change trees
+export interface ChangeTreeList {
+    next?: ChangeTreeNode;
+    tail?: ChangeTreeNode;
+    length: number;
+}
+
 export interface ChangeSet {
     // field index -> operation index
     indexes: { [index: number]: number };
     operations: number[];
-    queueRootIndex?: number; // index of ChangeTree structure in `root.changes` or `root.filteredChanges`
+    queueRootNode?: ChangeTreeNode; // direct reference to ChangeTreeNode in the linked list
 }
 
 function createChangeSet(): ChangeSet {
     return { indexes: {}, operations: [] };
 }
 
+// Linked list helper functions
+export function createChangeTreeList(): ChangeTreeList {
+    return { next: undefined, tail: undefined, length: 0 };
+}
+
+export function addToChangeTreeList(list: ChangeTreeList, changeTree: ChangeTree): ChangeTreeNode {
+    const node: ChangeTreeNode = { changeTree, next: undefined, prev: undefined };
+
+    if (!list.next) {
+        list.next = node;
+        list.tail = node;
+    } else {
+        node.prev = list.tail;
+        list.tail!.next = node;
+        list.tail = node;
+    }
+
+    list.length++;
+
+    return node;
+}
+
 export function setOperationAtIndex(changeSet: ChangeSet, index: number) {
     const operationsIndex = changeSet.indexes[index];
     if (operationsIndex === undefined) {
@@ -96,25 +132,32 @@ export function debugChangeSet(label: string, changeSet: ChangeSet) {
 export function enqueueChangeTree(
     root: Root,
     changeTree: ChangeTree,
-    changeSet: 'changes' | 'filteredChanges' | 'allFilteredChanges',
-    queueRootIndex = changeTree[changeSet].queueRootIndex
+    changeSet: 'changes' | 'filteredChanges' | 'allFilteredChanges' | 'allChanges',
+    queueRootNode = changeTree[changeSet].queueRootNode
 ) {
-    if (!root) {
-        // skip
-        return;
+    // skip
+    if (!root) { return; }
 
-    } else if (root[changeSet][queueRootIndex] !== changeTree) {
-        changeTree[changeSet].queueRootIndex = root[changeSet].push(changeTree) - 1;
+    if (queueRootNode) {
+    } else {
+        // Add to linked list if not already present
+        changeTree[changeSet].queueRootNode = addToChangeTreeList(root[changeSet], changeTree);
     }
 }
 
-export class ChangeTree<T extends Ref=any> {
+export interface ParentChain {
+    ref: Ref;
+    index: number;
+    next?: ParentChain;
+}
+
+export class ChangeTree<T extends Ref = any> {
     ref: T;
     refId: number;
+    metadata: Metadata;
 
     root?: Root;
-    parent?: Ref;
-    parentIndex?: number;
+    parentChain?: ParentChain; // Linked list for tracking parents
 
     /**
      * Whether this structure is parent of a filtered structure.
@@ -136,7 +179,7 @@ export class ChangeTree<T extends Ref=any> {
     filteredChanges: ChangeSet;
     allFilteredChanges: ChangeSet;
 
-    indexes: {[index: string]: any}; // TODO: remove this, only used by MapSchema/SetSchema/CollectionSchema (`encodeKeyValueOperation`)
+    indexes: { [index: string]: any }; // TODO: remove this, only used by MapSchema/SetSchema/CollectionSchema (`encodeKeyValueOperation`)
 
     /**
      * Is this a new instance? Used on ArraySchema to determine OPERATION.MOVE_AND_ADD operation.
@@ -145,12 +188,12 @@ export class ChangeTree<T extends Ref=any> {
 
     constructor(ref: T) {
         this.ref = ref;
+        this.metadata = ref.constructor[Symbol.metadata];
 
         //
         // Does this structure have "filters" declared?
         //
-        const metadata = ref.constructor[Symbol.metadata];
-        if (metadata?.[$viewFieldIndexes]) {
+        if (this.metadata?.[$viewFieldIndexes]) {
             this.allFilteredChanges = { indexes: {}, operations: [] };
             this.filteredChanges = { indexes: {}, operations: [] };
         }
@@ -158,35 +201,18 @@ export class ChangeTree<T extends Ref=any> {
 
     setRoot(root: Root) {
         this.root = root;
-        this.checkIsFiltered(this.parent, this.parentIndex);
 
-        //
-        // TODO: refactor and possibly unify .setRoot() and .setParent()
-        //
+        const isNewChangeTree = this.root.add(this);
 
-        // Recursively set root on child structures
-        const metadata: Metadata = this.ref.constructor[Symbol.metadata];
-        if (metadata) {
-            metadata[$refTypeFieldIndexes]?.forEach((index) => {
-                const field = metadata[index as any as number];
-                const changeTree: ChangeTree = this.ref[field.name]?.[$changes];
-                if (changeTree) {
-                    if (changeTree.root !== root) {
-                        changeTree.setRoot(root);
-                    } else {
-                        root.add(changeTree); // increment refCount
-                    }
-                }
-            });
+        this.checkIsFiltered(this.parent, this.parentIndex, isNewChangeTree);
 
-        } else if (this.ref[$childType] && typeof(this.ref[$childType]) !== "string") {
-            // MapSchema / ArraySchema, etc.
-            (this.ref as MapSchema).forEach((value, key) => {
-                const changeTree: ChangeTree = value[$changes];
-                if (changeTree.root !== root) {
-                    changeTree.setRoot(root);
+        // Recursively set root on child structures
+        if (isNewChangeTree) {
+            this.forEachChild((child, _) => {
+                if (child.root !== root) {
+                    child.setRoot(root);
                 } else {
-                    root.add(changeTree); // increment refCount
+                    root.add(child); // increment refCount
                 }
             });
         }
@@ -197,63 +223,58 @@ export class ChangeTree<T extends Ref=any> {
         root?: Root,
         parentIndex?: number,
     ) {
-        this.parent = parent;
-        this.parentIndex = parentIndex;
+        this.addParent(parent, parentIndex);
 
         // avoid setting parents with empty `root`
         if (!root) { return; }
 
+        const isNewChangeTree = root.add(this);
+
         // skip if parent is already set
         if (root !== this.root) {
             this.root = root;
-            this.checkIsFiltered(parent, parentIndex);
-
-        } else {
-            root.add(this);
+            this.checkIsFiltered(parent, parentIndex, isNewChangeTree);
         }
 
         // assign same parent on child structures
-        const metadata: Metadata = this.ref.constructor[Symbol.metadata];
-        if (metadata) {
-            metadata[$refTypeFieldIndexes]?.forEach((index) => {
-                const field = metadata[index as any as number];
-                const changeTree: ChangeTree = this.ref[field.name]?.[$changes];
-                if (changeTree && changeTree.root !== root) {
-                    changeTree.setParent(this.ref, root, index);
-                }
-            });
-
-        } else if (this.ref[$childType] && typeof(this.ref[$childType]) !== "string") {
-            // MapSchema / ArraySchema, etc.
-            (this.ref as MapSchema).forEach((value, key) => {
-                const changeTree: ChangeTree = value[$changes];
-                if (changeTree.root !== root) {
-                    changeTree.setParent(this.ref, root, this.indexes[key] ?? key);
+        if (isNewChangeTree) {
+            //
+            // assign same parent on child structures
+            //
+            this.forEachChild((child, index) => {
+                if (child.root === root) {
+                    //
+                    // re-assigning a child of the same root, move it to the end
+                    // of the changes queue so encoding order is preserved
+                    //
+                    root.add(child);
+                    root.moveToEndOfChanges(child);
+                    return;
                 }
+                child.setParent(this.ref, root, index);
             });
         }
-
     }
 
-    forEachChild(callback: (change: ChangeTree, atIndex: number) => void) {
+    forEachChild(callback: (change: ChangeTree, at: any) => void) {
         //
         // assign same parent on child structures
         //
-        const metadata: Metadata = this.ref.constructor[Symbol.metadata];
-        if (metadata) {
-            metadata[$refTypeFieldIndexes]?.forEach((index) => {
-                const field = metadata[index as any as number];
-                const value = this.ref[field.name];
-                if (value) {
-                    callback(value[$changes], index);
-                }
-            });
+        if (this.ref[$childType]) {
+            if (typeof (this.ref[$childType]) !== "string") {
+                // MapSchema / ArraySchema, etc.
+                for (const [key, value] of (this.ref as MapSchema).entries()) {
+                    callback(value[$changes], key);
+                };
+            }
 
-        } else if (this.ref[$childType] && typeof(this.ref[$childType]) !== "string") {
-            // MapSchema / ArraySchema, etc.
-            (this.ref as MapSchema).forEach((value, key) => {
-                callback(value[$changes], this.indexes[key] ?? key);
-            });
+        } else {
+            for (const index of this.metadata?.[$refTypeFieldIndexes] ?? []) {
+                const field = this.metadata[index as any as number];
+                const value = this.ref[field.name];
+                if (!value) { continue; }
+                callback(value[$changes], index);
+            }
         }
     }
 
@@ -271,9 +292,7 @@ export class ChangeTree<T extends Ref=any> {
     }
 
     change(index: number, operation: OPERATION = OPERATION.ADD) {
-        const metadata = this.ref.constructor[Symbol.metadata] as Metadata;
-
-        const isFiltered = this.isFiltered || (metadata?.[index]?.tag !== undefined);
+        const isFiltered = this.isFiltered || (this.metadata?.[index]?.tag !== undefined);
         const changeSet = (isFiltered)
             ? this.filteredChanges
             : this.changes;
@@ -376,19 +395,16 @@ export class ChangeTree<T extends Ref=any> {
     }
 
     getType(index?: number) {
-        if (Metadata.isValidInstance(this.ref)) {
-            const metadata = this.ref.constructor[Symbol.metadata] as Metadata;
-            return metadata[index].type;
-
-        } else {
+        return (
             //
             // Get the child type from parent structure.
             // - ["string"] => "string"
             // - { map: "string" } => "string"
             // - { set: "string" } => "string"
             //
-            return this.ref[$childType];
-        }
+            this.ref[$childType] || // ArraySchema | MapSchema | SetSchema | CollectionSchema
+            this.metadata[index].type // Schema
+        );
     }
 
     getChange(index: number) {
@@ -458,9 +474,7 @@ export class ChangeTree<T extends Ref=any> {
         this.indexedOperations = {};
 
         // clear changeset
-        this[changeSetName].indexes = {};
-        this[changeSetName].operations.length = 0;
-        this[changeSetName].queueRootIndex = undefined;
+        this[changeSetName] = createChangeSet();
 
         // ArraySchema and MapSchema have a custom "encode end" method
         this.ref[$onEncodeEnd]?.();
@@ -478,24 +492,17 @@ export class ChangeTree<T extends Ref=any> {
         this.ref[$onEncodeEnd]?.();
 
         this.indexedOperations = {};
-
-        this.changes.indexes = {};
-        this.changes.operations.length = 0;
-        this.changes.queueRootIndex = undefined;
+        this.changes = createChangeSet();
 
         if (this.filteredChanges !== undefined) {
-            this.filteredChanges.indexes = {};
-            this.filteredChanges.operations.length = 0;
-            this.filteredChanges.queueRootIndex = undefined;
+            this.filteredChanges = createChangeSet();
         }
 
         if (discardAll) {
-            this.allChanges.indexes = {};
-            this.allChanges.operations.length = 0;
+            this.allChanges = createChangeSet();
 
             if (this.allFilteredChanges !== undefined) {
-                this.allFilteredChanges.indexes = {};
-                this.allFilteredChanges.operations.length = 0;
+                this.allFilteredChanges = createChangeSet();
             }
         }
     }
@@ -517,22 +524,11 @@ export class ChangeTree<T extends Ref=any> {
         this.discard();
     }
 
-    ensureRefId() {
-        // skip if refId is already set.
-        if (this.refId !== undefined) {
-            return;
-        }
-
-        this.refId = this.root.getNextUniqueId();
-    }
-
     get changed() {
         return (Object.entries(this.indexedOperations).length > 0);
     }
 
-    protected checkIsFiltered(parent: Ref, parentIndex: number) {
-        const isNewChangeTree = this.root.add(this);
-
+    protected checkIsFiltered(parent: Ref, parentIndex: number, isNewChangeTree: boolean) {
         if (this.root.types.hasFilters) {
             //
             // At Schema initialization, the "root" structure might not be available
@@ -545,7 +541,7 @@ export class ChangeTree<T extends Ref=any> {
             if (this.filteredChanges !== undefined) {
                 enqueueChangeTree(this.root, this, 'filteredChanges');
                 if (isNewChangeTree) {
-                    this.root.allFilteredChanges.push(this);
+                    enqueueChangeTree(this.root, this, 'allFilteredChanges');
                 }
             }
         }
@@ -553,7 +549,7 @@ export class ChangeTree<T extends Ref=any> {
         if (!this.isFiltered) {
             enqueueChangeTree(this.root, this, 'changes');
             if (isNewChangeTree) {
-                this.root.allChanges.push(this);
+                enqueueChangeTree(this.root, this, 'allChanges');
             }
         }
     }
@@ -568,7 +564,7 @@ export class ChangeTree<T extends Ref=any> {
         //
         const refType = Metadata.isValidInstance(this.ref)
             ? this.ref.constructor
-            :  this.ref[$childType];
+            : this.ref[$childType];
 
         let parentChangeTree: ChangeTree;
 
@@ -627,4 +623,95 @@ export class ChangeTree<T extends Ref=any> {
         }
     }
 
+    /**
+     * Get the immediate parent
+     */
+    get parent(): Ref | undefined {
+        return this.parentChain?.ref;
+    }
+
+    /**
+     * Get the immediate parent index
+     */
+    get parentIndex(): number | undefined {
+        return this.parentChain?.index;
+    }
+
+    /**
+     * Add a parent to the chain
+     */
+    addParent(parent: Ref, index: number) {
+        // Check if this parent already exists in the chain
+        if (this.hasParent((p, i) => p[$changes] === parent[$changes] && i === index)) {
+            return;
+        }
+
+        this.parentChain = {
+            ref: parent,
+            index,
+            next: this.parentChain
+        };
+    }
+
+    /**
+     * Remove a parent from the chain
+     * @param parent - The parent to remove
+     * @returns true if parent was removed
+     */
+    removeParent(parent: Ref = this.parent): boolean {
+        let current = this.parentChain;
+        let previous = null;
+        while (current) {
+            //
+            // FIXME: it is required to check against `$changes` here because
+            // ArraySchema is instance of Proxy
+            //
+            if (current.ref[$changes] === parent[$changes]) {
+                if (previous) {
+                    previous.next = current.next;
+                } else {
+                    this.parentChain = current.next;
+                }
+                return true;
+            }
+            previous = current;
+            current = current.next;
+        }
+        return this.parentChain === undefined;
+    }
+
+    /**
+     * Find a specific parent in the chain
+     */
+    findParent(predicate: (parent: Ref, index: number) => boolean): ParentChain | undefined {
+        let current = this.parentChain;
+        while (current) {
+            if (predicate(current.ref, current.index)) {
+                return current;
+            }
+            current = current.next;
+        }
+        return undefined;
+    }
+
+    /**
+     * Check if this ChangeTree has a specific parent
+     */
+    hasParent(predicate: (parent: Ref, index: number) => boolean): boolean {
+        return this.findParent(predicate) !== undefined;
+    }
+
+    /**
+     * Get all parents as an array (for debugging/testing)
+     */
+    getAllParents(): Array<{ ref: Ref, index: number }> {
+        const parents: Array<{ ref: Ref, index: number }> = [];
+        let current = this.parentChain;
+        while (current) {
+            parents.push({ ref: current.ref, index: current.index });
+            current = current.next;
+        }
+        return parents;
+    }
+
 }

package/src/encoder/Encoder.ts

@@ -10,7 +10,8 @@ import { Root } from "./Root";
 
 import type { StateView } from "./StateView";
 import type { Metadata } from "../Metadata";
-import type { ChangeSetName, ChangeTree } from "./ChangeTree";
+import type { ChangeSetName, ChangeTree, ChangeTreeList, ChangeTreeNode } from "./ChangeTree";
+import { createChangeTreeList } from "./ChangeTree";
 
 export class Encoder<T extends Schema = any> {
     static BUFFER_SIZE = (typeof(Buffer) !== "undefined") && Buffer.poolSize || 8 * 1024; // 8KB
@@ -54,11 +55,11 @@ export class Encoder<T extends Schema = any> {
     ): Buffer {
         const hasView = (view !== undefined);
         const rootChangeTree = this.state[$changes];
-        const changeTrees = this.root[changeSetName];
 
-        for (let i = 0, numChangeTrees = changeTrees.length; i < numChangeTrees; i++) {
-            const changeTree = changeTrees[i];
-            if (!changeTree) { continue; }
+        let current: ChangeTreeList | ChangeTreeNode = this.root[changeSetName];
+
+        while (current = current.next) {
+            const changeTree = current.changeTree;
 
             if (hasView) {
                 if (!view.isChangeTreeVisible(changeTree)) {
@@ -166,7 +167,9 @@ export class Encoder<T extends Schema = any> {
             ? this.root[field]
             : field;
 
-        rootChangeSet.forEach((changeTree) => {
+        let current = rootChangeSet.next;
+        while (current) {
+            const changeTree = current.changeTree;
             const changeSet = changeTree[field];
 
             const metadata: Metadata = changeTree.ref.constructor[Symbol.metadata];
@@ -179,7 +182,8 @@ export class Encoder<T extends Schema = any> {
                     op: OPERATION[op],
                 });
             }
-        });
+            current = current.next;
+        }
     }
 
     encodeView(view: StateView, sharedOffset: number, it: Iterator, bytes = this.sharedBuffer) {
@@ -242,22 +246,20 @@ export class Encoder<T extends Schema = any> {
 
     discardChanges() {
         // discard shared changes
-        let length = this.root.changes.length;
-        if (length > 0) {
-            while (length--) {
-                this.root.changes[length]?.endEncode('changes');
-            }
-            this.root.changes.length = 0;
+        let current = this.root.changes.next;
+        while (current) {
+            current.changeTree.endEncode('changes');
+            current = current.next;
         }
+        this.root.changes = createChangeTreeList();
 
         // discard filtered changes
-        length = this.root.filteredChanges.length;
-        if (length > 0) {
-            while (length--) {
-                this.root.filteredChanges[length]?.endEncode('filteredChanges');
-            }
-            this.root.filteredChanges.length = 0;
+        current = this.root.filteredChanges.next;
+        while (current) {
+            current.changeTree.endEncode('filteredChanges');
+            current = current.next;
         }
+        this.root.filteredChanges = createChangeTreeList();
     }
 
     tryEncodeTypeId (bytes: Buffer, baseType: typeof Schema, targetType: typeof Schema, it: Iterator) {