@colyseus/schema 3.0.0-alpha.3 → 3.0.0-alpha.31

package/src/encoder/ChangeTree.ts

@@ -7,10 +7,10 @@ import type { ArraySchema } from "../types/custom/ArraySchema";
 import type { CollectionSchema } from "../types/custom/CollectionSchema";
 import type { SetSchema } from "../types/custom/SetSchema";
 
+import { Root } from "./Root";
 import { Metadata } from "../Metadata";
 import type { EncodeOperation } from "./EncodeOperation";
 import type { DecodeOperation } from "../decoder/DecodeOperation";
-import type { StateView } from "./StateView";
 
 declare global {
     interface Object {
@@ -27,121 +27,85 @@ export type Ref = Schema
     | CollectionSchema
     | SetSchema;
 
-export class Root {
-    protected nextUniqueId: number = 0;
-    refCount = new WeakMap<ChangeTree, number>();
-
-    // all changes
-    allChanges = new Map<ChangeTree, Map<number, OPERATION>>();
-    allFilteredChanges = new Map<ChangeTree, Map<number, OPERATION>>();
-
-    // pending changes to be encoded
-    changes = new Map<ChangeTree, Map<number, OPERATION>>();
-    filteredChanges = new Map<ChangeTree, Map<number, OPERATION>>();
-
-    getNextUniqueId() {
-        return this.nextUniqueId++;
-    }
-
-    add (changeTree: ChangeTree) {
-        const refCount = this.refCount.get(changeTree) || 0;
-        this.refCount.set(changeTree, refCount + 1);
-    }
-
-    remove(changeTree: ChangeTree) {
-        const refCount = this.refCount.get(changeTree);
-        if (refCount <= 1) {
-            this.allChanges.delete(changeTree);
-            this.changes.delete(changeTree);
-
-            if (changeTree.isFiltered || changeTree.isPartiallyFiltered) {
-                this.allFilteredChanges.delete(changeTree);
-                this.filteredChanges.delete(changeTree);
-            }
-
-            this.refCount.delete(changeTree);
-
-        } else {
-            this.refCount.set(changeTree, refCount - 1);
-        }
-
-        changeTree.forEachChild((child, _) =>
-            this.remove(child));
-    }
-
-    clear() {
-        this.changes.clear();
-    }
-}
-
 export class ChangeTree<T extends Ref=any> {
     ref: T;
     refId: number;
 
     root?: Root;
-
-    isFiltered?: boolean;
-    isPartiallyFiltered?: boolean;
-
     parent?: Ref;
     parentIndex?: number;
 
-    indexes: {[index: string]: any} = {}; // TODO: remove this, only used by MapSchema/SetSchema/CollectionSchema (`encodeKeyValueOperation`)
+    isFiltered: boolean = false;
+    isPartiallyFiltered: boolean = false;
+
     currentOperationIndex: number = 0;
 
+    changes = new Map<number, OPERATION>();
     allChanges = new Map<number, OPERATION>();
-    allFilteredChanges = new Map<number, OPERATION>();
 
-    changes = new Map<number, OPERATION>();
-    filteredChanges = new Map<number, OPERATION>();;
+    allFilteredChanges: Map<number, OPERATION>;
+    filteredChanges: Map<number, OPERATION>;
+
+    indexes: {[index: string]: any}; // TODO: remove this, only used by MapSchema/SetSchema/CollectionSchema (`encodeKeyValueOperation`)
 
     [$isNew] = true;
 
     constructor(ref: T) {
         this.ref = ref;
+
+        //
+        // Does this structure have "filters" declared?
+        //
+        if (ref.constructor[Symbol.metadata]?.[-2]) {
+            this.allFilteredChanges = new Map<number, OPERATION>();
+            this.filteredChanges = new Map<number, OPERATION>();
+        }
     }
 
     setRoot(root: Root) {
         this.root = root;
         this.root.add(this);
 
-        //
-        // At Schema initialization, the "root" structure might not be available
-        // yet, as it only does once the "Encoder" has been set up.
-        //
-        // So the "parent" may be already set without a "root".
-        //
-        this.checkIsFiltered(this.parent, this.parentIndex);
+        const metadata: Metadata = this.ref.constructor[Symbol.metadata];
 
-        // unique refId for the ChangeTree.
-        this.ensureRefId();
+        if (this.root.types.hasFilters) {
+            //
+            // At Schema initialization, the "root" structure might not be available
+            // yet, as it only does once the "Encoder" has been set up.
+            //
+            // So the "parent" may be already set without a "root".
+            //
+            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);
+            }
+        }
 
         if (!this.isFiltered) {
             this.root.changes.set(this, this.changes);
+            this.root.allChanges.set(this, this.allChanges);
         }
 
-        if (this.isFiltered || this.isPartiallyFiltered) {
-            this.root.allFilteredChanges.set(this, this.allFilteredChanges);
-            this.root.filteredChanges.set(this, this.filteredChanges);
+        this.ensureRefId();
 
-        // } else {
-        //     this.root.allChanges.set(this, this.allChanges);
-        }
+        if (metadata) {
+            metadata[-4]?.forEach((index) => {
+                const field = metadata[index as any as number];
+                const value = this.ref[field.name];
+                if (value) {
+                    value[$changes].setRoot(root);
+                }
+            });
 
-        if (!this.isFiltered) {
-            this.root.allChanges.set(this, this.allChanges);
+        } else if (this.ref[$childType] && typeof(this.ref[$childType]) !== "string") {
+            // MapSchema / ArraySchema, etc.
+            (this.ref as MapSchema).forEach((value, key) => {
+                value[$changes].setRoot(root);
+            });
         }
 
-        this.forEachChild((changeTree, _) => {
-            changeTree.setRoot(root);
-        });
-
-        // this.allChanges.forEach((_, index) => {
-        //     const childRef = this.ref[$getByIndex](index);
-        //     if (childRef && childRef[$changes]) {
-        //         childRef[$changes].setRoot(root);
-        //     }
-        // });
     }
 
     setParent(
@@ -157,57 +121,71 @@ export class ChangeTree<T extends Ref=any> {
 
         root.add(this);
 
+        const metadata: Metadata = this.ref.constructor[Symbol.metadata];
+
         // skip if parent is already set
-        if (root === this.root) {
-            this.forEachChild((changeTree, atIndex) => {
-                changeTree.setParent(this.ref, root, atIndex);
-            });
-            return;
-        }
+        if (root !== this.root) {
+            this.root = root;
 
-        this.root = root;
-        this.checkIsFiltered(parent, parentIndex);
+            if (root.types.hasFilters) {
+                this.checkIsFiltered(metadata, parent, parentIndex);
 
-        if (!this.isFiltered) {
-            this.root.changes.set(this, this.changes);
-        }
+                if (this.isFiltered || this.isPartiallyFiltered) {
+                    this.root.filteredChanges.set(this, this.filteredChanges);
+                    this.root.allFilteredChanges.set(this, this.filteredChanges);
+                }
+            }
 
-        if (this.isFiltered || this.isPartiallyFiltered) {
-            this.root.filteredChanges.set(this, this.filteredChanges);
-            this.root.allFilteredChanges.set(this, this.filteredChanges);
-        } else {
-            this.root.allChanges.set(this, this.allChanges);
+            if (!this.isFiltered) {
+                this.root.changes.set(this, this.changes);
+                this.root.allChanges.set(this, this.allChanges);
+            }
+
+            this.ensureRefId();
         }
 
-        this.ensureRefId();
+        // assign same parent on child structures
+        if (metadata) {
+            metadata[-4]?.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);
+                // }
+
+            });
+
+        } else if (this.ref[$childType] && typeof(this.ref[$childType]) !== "string") {
+            // MapSchema / ArraySchema, etc.
+            (this.ref as MapSchema).forEach((value, key) => {
+                value[$changes].setParent(this.ref, root, this.indexes[key] ?? key);
+            });
+        }
 
-        this.forEachChild((changeTree, atIndex) => {
-            changeTree.setParent(this.ref, root, atIndex);
-        });
     }
 
     forEachChild(callback: (change: ChangeTree, atIndex: number) => void) {
         //
         // assign same parent on child structures
         //
-        if (Metadata.isValidInstance(this.ref)) {
-            const metadata: Metadata = this.ref['constructor'][Symbol.metadata];
-
-            // FIXME: need to iterate over parent metadata instead.
-            for (const field in metadata) {
-                const value = this.ref[field];
-
-                if (value && value[$changes]) {
-                    callback(value[$changes], metadata[field].index);
+        const metadata: Metadata = this.ref.constructor[Symbol.metadata];
+        if (metadata) {
+            metadata[-4]?.forEach((index) => {
+                const field = metadata[index as any as number];
+                const value = this.ref[field.name];
+                if (value) {
+                    callback(value[$changes], index);
                 }
-            }
+            });
 
-        } else if (typeof (this.ref) === "object") {
+        } else if (this.ref[$childType] && typeof(this.ref[$childType]) !== "string") {
             // MapSchema / ArraySchema, etc.
             (this.ref as MapSchema).forEach((value, key) => {
-                if (Metadata.isValidInstance(value)) {
-                    callback(value[$changes], this.ref[$changes].indexes[key]);
-                }
+                callback(value[$changes], this.indexes[key] ?? key);
             });
         }
     }
@@ -218,9 +196,9 @@ export class ChangeTree<T extends Ref=any> {
     }
 
     change(index: number, operation: OPERATION = OPERATION.ADD) {
-        const metadata = this.ref['constructor'][Symbol.metadata] as Metadata;
+        const metadata = this.ref.constructor[Symbol.metadata] as Metadata;
 
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
+        const isFiltered = this.isFiltered || (metadata?.[index]?.tag !== undefined);
         const changeSet = (isFiltered)
             ? this.filteredChanges
             : this.changes;
@@ -232,16 +210,16 @@ export class ChangeTree<T extends Ref=any> {
                 : (previousOperation === OPERATION.DELETE)
                     ? OPERATION.DELETE_AND_ADD
                     : operation
+            //
+            // TODO: are DELETE operations being encoded as ADD here ??
+            //
             changeSet.set(index, op);
         }
 
-        //
-        // TODO: are DELETE operations being encoded as ADD here ??
-        //
-
         if (isFiltered) {
             this.allFilteredChanges.set(index, OPERATION.ADD);
             this.root?.filteredChanges.set(this, this.filteredChanges);
+            this.root?.allFilteredChanges.set(this, this.allFilteredChanges);
 
         } else {
             this.allChanges.set(index, OPERATION.ADD);
@@ -285,7 +263,6 @@ 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]) => {
-            // console.log('shiftAllChangeIndexes', index >= startIndex, { index, op, shiftIndex, startIndex })
             if (index >= startIndex) {
                 allChangeSet.delete(index);
                 allChangeSet.set(index + shiftIndex, op);
@@ -294,10 +271,7 @@ export class ChangeTree<T extends Ref=any> {
     }
 
     indexedOperation(index: number, operation: OPERATION, allChangesIndex = index) {
-        const metadata = this.ref['constructor'][Symbol.metadata] as Metadata;
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
-
-        if (isFiltered) {
+        if (this.filteredChanges !== undefined) {
             this.allFilteredChanges.set(allChangesIndex, OPERATION.ADD);
             this.filteredChanges.set(index, operation);
             this.root?.filteredChanges.set(this, this.filteredChanges);
@@ -311,8 +285,8 @@ 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[metadata[index]].type;
+            const metadata = this.ref.constructor[Symbol.metadata] as Metadata;
+            return metadata[index].type;
 
         } else {
             //
@@ -327,7 +301,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.changes.get(index) ?? this.filteredChanges?.get(index);
     }
 
     //
@@ -350,9 +324,7 @@ export class ChangeTree<T extends Ref=any> {
             return;
         }
 
-        const metadata = this.ref['constructor'][Symbol.metadata] as Metadata;
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
-        const changeSet = (isFiltered)
+        const changeSet = (this.filteredChanges)
             ? this.filteredChanges
             : this.changes;
 
@@ -380,7 +352,7 @@ export class ChangeTree<T extends Ref=any> {
         //
         // FIXME: this is looking a bit ugly (and repeated from `.change()`)
         //
-        if (isFiltered) {
+        if (this.filteredChanges) {
             this.root?.filteredChanges.set(this, this.filteredChanges);
             this.allFilteredChanges.delete(allChangesIndex);
 
@@ -392,6 +364,8 @@ export class ChangeTree<T extends Ref=any> {
 
     endEncode() {
         this.changes.clear();
+
+        // ArraySchema and MapSchema have a custom "encode end" method
         this.ref[$onEncodeEnd]?.();
 
         // Not a new instance anymore
@@ -407,14 +381,14 @@ export class ChangeTree<T extends Ref=any> {
         this.ref[$onEncodeEnd]?.();
 
         this.changes.clear();
-        this.filteredChanges.clear();
+        this.filteredChanges?.clear();
 
         // reset operation index
         this.currentOperationIndex = 0;
 
         if (discardAll) {
             this.allChanges.clear();
-            this.allFilteredChanges.clear();
+            this.allFilteredChanges?.clear();
 
             // remove children references
             this.forEachChild((changeTree, _) =>
@@ -450,40 +424,47 @@ export class ChangeTree<T extends Ref=any> {
         return this.changes.size > 0;
     }
 
-    protected checkIsFiltered(parent: Ref, parentIndex: number) {
+    protected checkIsFiltered(metadata: Metadata, parent: Ref, parentIndex: number) {
         // Detect if current structure has "filters" declared
-        this.isPartiallyFiltered = this.ref['constructor']?.[Symbol.metadata]?.[-2];
-
-        // TODO: support "partially filtered", where the instance is visible, but only a field is not.
+        this.isPartiallyFiltered = metadata?.[-2] !== undefined;
 
-        // Detect if parent has "filters" declared
-        while (parent && !this.isFiltered) {
-            const metadata: Metadata = parent['constructor'][Symbol.metadata];
-
-            const fieldName = metadata?.[parentIndex];
-            const isParentOwned = metadata?.[fieldName]?.tag !== undefined;
+        if (this.isPartiallyFiltered) {
+            this.filteredChanges = this.filteredChanges || new Map<number, OPERATION>();
+            this.allFilteredChanges = this.allFilteredChanges || new Map<number, OPERATION>();
+        }
 
-            this.isFiltered = isParentOwned || parent[$changes].isFiltered; // metadata?.[-2]
+        if (parent) {
+            if (!Metadata.isValidInstance(parent)) {
+                const parentChangeTree = parent[$changes];
+                parent = parentChangeTree.parent;
+                parentIndex = parentChangeTree.parentIndex;
+            }
 
-            parent = parent[$changes].parent;
-        };
+            const parentMetadata = parent?.constructor?.[Symbol.metadata];
+            this.isFiltered = (parent && parentMetadata?.[-2]?.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.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 = 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;
+                }
+            }
         }
     }