@colyseus/schema 3.0.0-alpha.42 → 3.0.0-alpha.44

package/src/encoder/ChangeTree.ts

@@ -11,6 +11,8 @@ import { Root } from "./Root";
 import { Metadata } from "../Metadata";
 import type { EncodeOperation } from "./EncodeOperation";
 import type { DecodeOperation } from "../decoder/DecodeOperation";
+import { TypeContext } from "../types/TypeContext";
+import { ReferenceTracker } from "../decoder/ReferenceTracker";
 
 declare global {
     interface Object {
@@ -79,8 +81,10 @@ export class ChangeTree<T extends Ref=any> {
     parent?: Ref;
     parentIndex?: number;
 
+    /**
+     * Whether this structure is parent of a filtered structure.
+     */
     isFiltered: boolean = false;
-    isPartiallyFiltered: boolean = false;
 
     indexedOperations: IndexedOperations = {};
 
@@ -109,7 +113,8 @@ export class ChangeTree<T extends Ref=any> {
         //
         // Does this structure have "filters" declared?
         //
-        if (ref.constructor[Symbol.metadata]?.[$viewFieldIndexes]) {
+        const metadata = ref.constructor[Symbol.metadata];
+        if (metadata?.[$viewFieldIndexes]) {
             this.allFilteredChanges = { indexes: {}, operations: [] };
             this.filteredChanges = { indexes: {}, operations: [] };
         }
@@ -117,35 +122,10 @@ export class ChangeTree<T extends Ref=any> {
 
     setRoot(root: Root) {
         this.root = root;
-        const isNewChangeTree = this.root.add(this);
-
-        const metadata: Metadata = this.ref.constructor[Symbol.metadata];
-
-        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) {
-                enqueueChangeTree(root, this, 'filteredChanges');
-                if (isNewChangeTree) {
-                    this.root.allFilteredChanges.push(this);
-                }
-            }
-        }
-
-        if (!this.isFiltered) {
-            enqueueChangeTree(root, this, 'changes');
-            if (isNewChangeTree) {
-                this.root.allChanges.push(this);
-            }
-        }
+        this.checkIsFiltered(this.parent, this.parentIndex);
 
         // 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];
@@ -173,46 +153,22 @@ export class ChangeTree<T extends Ref=any> {
         // avoid setting parents with empty `root`
         if (!root) { return; }
 
-        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) {
-                    enqueueChangeTree(root, this, 'filteredChanges');
-                    if (isNewChangeTree) {
-                        this.root.allFilteredChanges.push(this);
-                    }
-                }
-            }
-
-            if (!this.isFiltered) {
-                enqueueChangeTree(root, this, 'changes');
-                if (isNewChangeTree) {
-                    this.root.allChanges.push(this);
-                }
-            }
+            this.checkIsFiltered(parent, parentIndex);
 
         } else {
             root.add(this);
         }
 
         // 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];
                 value?.[$changes].setParent(this.ref, root, index);
-
-                // try { throw new Error(); } catch (e) {
-                //     console.log(e.stack);
-                // }
-
             });
 
         } else if (this.ref[$childType] && typeof(this.ref[$childType]) !== "string") {
@@ -319,7 +275,7 @@ export class ChangeTree<T extends Ref=any> {
         //
         // - ArraySchema#splice()
         //
-        if (this.isFiltered || this.isPartiallyFiltered) {
+        if (this.filteredChanges !== undefined) {
             this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allFilteredChanges);
             this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allChanges);
 
@@ -352,7 +308,7 @@ export class ChangeTree<T extends Ref=any> {
     indexedOperation(index: number, operation: OPERATION, allChangesIndex: number = index) {
         this.indexedOperations[index] = operation;
 
-        if (this.filteredChanges) {
+        if (this.filteredChanges !== undefined) {
             setOperationAtIndex(this.allFilteredChanges, allChangesIndex);
             setOperationAtIndex(this.filteredChanges, index);
             enqueueChangeTree(this.root, this, 'filteredChanges');
@@ -404,7 +360,7 @@ export class ChangeTree<T extends Ref=any> {
             return;
         }
 
-        const changeSet = (this.filteredChanges)
+        const changeSet = (this.filteredChanges !== undefined)
             ? this.filteredChanges
             : this.changes;
 
@@ -423,7 +379,7 @@ export class ChangeTree<T extends Ref=any> {
             // - This is due to using the concrete Schema class at decoding time.
             // - "Reflected" structures do not have this problem.
             //
-            // (the property descriptors should NOT be used at decoding time. only at encoding time.)
+            // (The property descriptors should NOT be used at decoding time. only at encoding time.)
             //
             this.root?.remove(previousValue[$changes]);
         }
@@ -431,7 +387,7 @@ export class ChangeTree<T extends Ref=any> {
         //
         // FIXME: this is looking a ugly and repeated
         //
-        if (this.filteredChanges) {
+        if (this.filteredChanges !== undefined) {
             deleteOperationAtIndex(this.allFilteredChanges, allChangesIndex);
             enqueueChangeTree(this.root, this, 'filteredChanges');
 
@@ -519,19 +475,42 @@ export class ChangeTree<T extends Ref=any> {
         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?.[$viewFieldIndexes] !== undefined;
+    protected checkIsFiltered(parent: Ref, parentIndex: number) {
+        const isNewChangeTree = this.root.add(this);
+
+        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._checkFilteredByParent(parent, parentIndex);
 
-        if (this.isPartiallyFiltered) {
-            this.filteredChanges = this.filteredChanges || { indexes: {}, operations: [] };
-            this.allFilteredChanges = this.allFilteredChanges || { indexes: {}, operations: [] };
+            if (this.filteredChanges !== undefined) {
+                enqueueChangeTree(this.root, this, 'filteredChanges');
+                if (isNewChangeTree) {
+                    this.root.allFilteredChanges.push(this);
+                }
+            }
         }
 
-        // skip if parent is not set
-        if (!parent) {
-            return;
+        if (!this.isFiltered) {
+            enqueueChangeTree(this.root, this, 'changes');
+            if (isNewChangeTree) {
+                this.root.allChanges.push(this);
+            }
         }
+    }
+
+    protected _checkFilteredByParent(parent: Ref, parentIndex: number) {
+        // skip if parent is not set
+        if (!parent) { return; }
+
+        // ArraySchema | MapSchema - get the child type
+        const ref = Metadata.isValidInstance(this.ref)
+            ? this.ref
+            : new this.ref[$childType];
 
         if (!Metadata.isValidInstance(parent)) {
             const parentChangeTree = parent[$changes];
@@ -539,14 +518,23 @@ export class ChangeTree<T extends Ref=any> {
             parentIndex = parentChangeTree.parentIndex;
         }
 
-        const parentMetadata = parent.constructor?.[Symbol.metadata];
-        this.isFiltered = parentMetadata?.[$viewFieldIndexes]?.includes(parentIndex);
+        const parentConstructor = parent.constructor as typeof Schema;
+
+        let key = `${this.root.types.getTypeId(ref.constructor as typeof Schema)}`;
+        if (parentConstructor) { key += `-${this.root.types.schemas.get(parentConstructor)}`; }
+        key += `-${parentIndex}`;
+
+        this.isFiltered = this.root.types.parentFiltered[key];
+
+        // const parentMetadata = parentConstructor?.[Symbol.metadata];
+        // this.isFiltered = parentMetadata?.[$viewFieldIndexes]?.includes(parentIndex) || this.root.types.parentFiltered[key];
 
         //
         // TODO: refactor this!
         //
         //      swapping `changes` and `filteredChanges` is required here
         //      because "isFiltered" may not be imedialely available on `change()`
+        //      (this happens when instance is detached from root or parent)
         //
         if (this.isFiltered) {
             this.filteredChanges = { indexes: {}, operations: [] };
@@ -562,11 +550,6 @@ export class ChangeTree<T extends Ref=any> {
                 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/Root.ts

@@ -62,7 +62,7 @@ export class Root {
             this.removeChangeFromChangeSet("allChanges", changeTree);
             this.removeChangeFromChangeSet("changes", changeTree);
 
-            if (changeTree.isFiltered || changeTree.isPartiallyFiltered) {
+            if (changeTree.filteredChanges) {
                 this.removeChangeFromChangeSet("allFilteredChanges", changeTree);
                 this.removeChangeFromChangeSet("filteredChanges", changeTree);
             }

package/src/encoder/StateView.ts

@@ -79,7 +79,7 @@ export class StateView {
 
         } else {
             const isInvisible = this.invisible.has(changeTree);
-            const changeSet = (changeTree.isFiltered || changeTree.isPartiallyFiltered)
+            const changeSet = (changeTree.filteredChanges !== undefined)
                 ? changeTree.allFilteredChanges
                 : changeTree.allChanges;
 
@@ -87,7 +87,7 @@ export class StateView {
                 const index = changeSet.operations[i];
                 if (index === undefined) { continue; } // skip "undefined" indexes
 
-                const op = changeTree.indexedOperations[index];
+                const op = changeTree.indexedOperations[index] ?? OPERATION.ADD;
                 const tagAtIndex = metadata?.[index].tag;
                 if (
                     (
@@ -105,7 +105,11 @@ export class StateView {
         // Add children of this ChangeTree to this view
         changeTree.forEachChild((change, index) => {
             // Do not ADD children that don't have the same tag
-            if (metadata && metadata[index].tag !== tag) {
+            if (
+                metadata &&
+                metadata[index].tag !== undefined &&
+                metadata[index].tag !== tag
+            ) {
                 return;
             }
             this.add(change.ref, tag, false);
@@ -119,8 +123,8 @@ export class StateView {
         this.items.add(changeTree);
 
         // add parent's parent
-        const parentChangeTree = changeTree.parent?.[$changes];
-        if (parentChangeTree && (parentChangeTree.isFiltered || parentChangeTree.isPartiallyFiltered)) {
+        const parentChangeTree: ChangeTree = changeTree.parent?.[$changes];
+        if (parentChangeTree && (parentChangeTree.filteredChanges !== undefined)) {
             this.addParent(parentChangeTree, changeTree.parentIndex, tag);
         }
 

package/src/types/TypeContext.ts

@@ -29,6 +29,11 @@ export class TypeContext {
 
     constructor(rootClass?: typeof Schema) {
         if (rootClass) {
+            //
+            // TODO:
+            //      cache "discoverTypes" results for each rootClass
+            //      to avoid re-discovering types for each new context/room
+            //
             this.discoverTypes(rootClass);
         }
     }
@@ -41,7 +46,7 @@ export class TypeContext {
         return this.types[typeid];
     }
 
-    add(schema: typeof Schema, typeid: number = this.schemas.size) {
+    add(schema: typeof Schema, typeid = this.schemas.size) {
         // skip if already registered
         if (this.schemas.has(schema)) {
             return false;
@@ -64,14 +69,17 @@ export class TypeContext {
         return this.schemas.get(klass);
     }
 
-    private discoverTypes(klass: typeof Schema, parentIndex?: number, parentFieldViewTag?: number) {
-        if (!this.add(klass)) {
-            return;
+    private discoverTypes(klass: typeof Schema, parentType?: typeof Schema, parentIndex?: number, parentHasViewTag?: boolean) {
+        if (parentHasViewTag) {
+            this.registerFilteredByParent(klass, parentType, parentIndex);
         }
 
+        // skip if already registered
+        if (!this.add(klass)) { return; }
+
         // add classes inherited from this base class
         TypeContext.inheritedTypes.get(klass)?.forEach((child) => {
-            this.discoverTypes(child, parentIndex, parentFieldViewTag);
+            this.discoverTypes(child, klass, parentIndex, parentHasViewTag);
         });
 
         // add parent classes
@@ -91,15 +99,11 @@ export class TypeContext {
             this.hasFilters = true;
         }
 
-        if (parentFieldViewTag !== undefined) {
-            this.parentFiltered[`${this.schemas.get(klass)}-${parentIndex}`] = true;
-        }
-
         for (const fieldIndex in metadata) {
             const index = fieldIndex as any as number;
 
             const fieldType = metadata[index].type;
-            const viewTag = metadata[index].tag;
+            const fieldHasViewTag = (metadata[index].tag !== undefined);
 
             if (typeof (fieldType) === "string") {
                 continue;
@@ -113,10 +117,10 @@ export class TypeContext {
                     continue;
                 }
 
-                this.discoverTypes(type as typeof Schema, index, viewTag);
+                this.discoverTypes(type as typeof Schema, klass, index, parentHasViewTag || fieldHasViewTag);
 
             } else if (typeof (fieldType) === "function") {
-                this.discoverTypes(fieldType as typeof Schema, viewTag);
+                this.discoverTypes(fieldType as typeof Schema, klass, index, parentHasViewTag || fieldHasViewTag);
 
             } else {
                 const type = Object.values(fieldType)[0];
@@ -126,8 +130,46 @@ export class TypeContext {
                     continue;
                 }
 
-                this.discoverTypes(type as typeof Schema, index, viewTag);
+                this.discoverTypes(type as typeof Schema, klass, index, parentHasViewTag || fieldHasViewTag);
             }
         }
     }
+
+    /**
+     * Keep track of which classes have filters applied.
+     * Format: `${typeid}-${parentTypeid}-${parentIndex}`
+     */
+    private registerFilteredByParent(schema: typeof Schema, parentType?: typeof Schema, parentIndex?: number) {
+        const typeid = this.schemas.get(schema) ?? this.schemas.size;
+
+        let key = `${typeid}`;
+        if (parentType) { key += `-${this.schemas.get(parentType)}`; }
+
+        key += `-${parentIndex}`;
+        this.parentFiltered[key] = true;
+    }
+
+    debug() {
+        let parentFiltered = "";
+
+        for (const key in this.parentFiltered) {
+            const keys: number[] = key.split("-").map(Number);
+            const fieldIndex = keys.pop();
+
+            parentFiltered += `\n\t\t`;
+            parentFiltered += `${key}: ${keys.reverse().map((id, i) => {
+                const klass = this.types[id];
+                const metadata: Metadata = klass[Symbol.metadata];
+                let txt = klass.name;
+                if (i === 0) { txt += `[${metadata[fieldIndex].name}]`; }
+                return `${txt}`;
+            }).join(" -> ")}`;
+        }
+
+        return `TypeContext ->\n` +
+            `\tSchema types: ${this.schemas.size}\n` +
+            `\thasFilters: ${this.hasFilters}\n` +
+            `\tparentFiltered:${parentFiltered}`;
+    }
+
 }