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

package/build/esm/index.mjs

@@ -615,6 +615,11 @@ class TypeContext {
         this.hasFilters = false;
         this.parentFiltered = {};
         if (rootClass) {
+            //
+            // TODO:
+            //      cache "discoverTypes" results for each rootClass
+            //      to avoid re-discovering types for each new context/room
+            //
             this.discoverTypes(rootClass);
         }
     }
@@ -642,13 +647,17 @@ class TypeContext {
     getTypeId(klass) {
         return this.schemas.get(klass);
     }
-    discoverTypes(klass, parentIndex, parentFieldViewTag) {
+    discoverTypes(klass, parentType, parentIndex, parentHasViewTag) {
+        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
         let parent = klass;
@@ -663,13 +672,10 @@ class TypeContext {
         if (metadata[$viewFieldIndexes]) {
             this.hasFilters = true;
         }
-        if (parentFieldViewTag !== undefined) {
-            this.parentFiltered[`${this.schemas.get(klass)}-${parentIndex}`] = true;
-        }
         for (const fieldIndex in metadata) {
             const index = fieldIndex;
             const fieldType = metadata[index].type;
-            const viewTag = metadata[index].tag;
+            const fieldHasViewTag = (metadata[index].tag !== undefined);
             if (typeof (fieldType) === "string") {
                 continue;
             }
@@ -679,10 +685,10 @@ class TypeContext {
                 if (type === "string") {
                     continue;
                 }
-                this.discoverTypes(type, index, viewTag);
+                this.discoverTypes(type, klass, index, parentHasViewTag || fieldHasViewTag);
             }
             else if (typeof (fieldType) === "function") {
-                this.discoverTypes(fieldType, viewTag);
+                this.discoverTypes(fieldType, klass, index, parentHasViewTag || fieldHasViewTag);
             }
             else {
                 const type = Object.values(fieldType)[0];
@@ -690,10 +696,44 @@ class TypeContext {
                 if (typeof (type) === "string") {
                     continue;
                 }
-                this.discoverTypes(type, index, viewTag);
+                this.discoverTypes(type, klass, index, parentHasViewTag || fieldHasViewTag);
             }
         }
     }
+    /**
+     * Keep track of which classes have filters applied.
+     * Format: `${typeid}-${parentTypeid}-${parentIndex}`
+     */
+    registerFilteredByParent(schema, parentType, parentIndex) {
+        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 = 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 = 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}`;
+    }
 }
 
 function getNormalizedType(type) {
@@ -938,8 +978,10 @@ function enqueueChangeTree(root, changeTree, changeSet, queueRootIndex = changeT
 }
 class ChangeTree {
     constructor(ref) {
+        /**
+         * Whether this structure is parent of a filtered structure.
+         */
         this.isFiltered = false;
-        this.isPartiallyFiltered = false;
         this.indexedOperations = {};
         //
         // TODO:
@@ -958,37 +1000,17 @@ class ChangeTree {
         //
         // 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: [] };
         }
     }
     setRoot(root) {
         this.root = root;
-        const isNewChangeTree = this.root.add(this);
-        const 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 = this.ref.constructor[Symbol.metadata];
         if (metadata) {
             metadata[$refTypeFieldIndexes]?.forEach((index) => {
                 const field = metadata[index];
@@ -1010,39 +1032,21 @@ class ChangeTree {
         if (!root) {
             return;
         }
-        const 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 = this.ref.constructor[Symbol.metadata];
         if (metadata) {
             metadata[$refTypeFieldIndexes]?.forEach((index) => {
                 const field = metadata[index];
                 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") {
@@ -1135,7 +1139,7 @@ class ChangeTree {
         //
         // - ArraySchema#splice()
         //
-        if (this.isFiltered || this.isPartiallyFiltered) {
+        if (this.filteredChanges !== undefined) {
             this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allFilteredChanges);
             this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allChanges);
         }
@@ -1164,7 +1168,7 @@ class ChangeTree {
     }
     indexedOperation(index, operation, allChangesIndex = 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');
@@ -1212,7 +1216,7 @@ class ChangeTree {
             }
             return;
         }
-        const changeSet = (this.filteredChanges)
+        const changeSet = (this.filteredChanges !== undefined)
             ? this.filteredChanges
             : this.changes;
         this.indexedOperations[index] = operation ?? OPERATION.DELETE;
@@ -1228,14 +1232,14 @@ class ChangeTree {
             // - 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]);
         }
         //
         // FIXME: this is looking a ugly and repeated
         //
-        if (this.filteredChanges) {
+        if (this.filteredChanges !== undefined) {
             deleteOperationAtIndex(this.allFilteredChanges, allChangesIndex);
             enqueueChangeTree(this.root, this, 'filteredChanges');
         }
@@ -1304,29 +1308,59 @@ class ChangeTree {
     get changed() {
         return (Object.entries(this.indexedOperations).length > 0);
     }
-    checkIsFiltered(metadata, parent, parentIndex) {
-        // Detect if current structure has "filters" declared
-        this.isPartiallyFiltered = metadata?.[$viewFieldIndexes] !== undefined;
-        if (this.isPartiallyFiltered) {
-            this.filteredChanges = this.filteredChanges || { indexes: {}, operations: [] };
-            this.allFilteredChanges = this.allFilteredChanges || { indexes: {}, operations: [] };
+    checkIsFiltered(parent, parentIndex) {
+        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.filteredChanges !== undefined) {
+                enqueueChangeTree(this.root, this, 'filteredChanges');
+                if (isNewChangeTree) {
+                    this.root.allFilteredChanges.push(this);
+                }
+            }
         }
+        if (!this.isFiltered) {
+            enqueueChangeTree(this.root, this, 'changes');
+            if (isNewChangeTree) {
+                this.root.allChanges.push(this);
+            }
+        }
+    }
+    _checkFilteredByParent(parent, parentIndex) {
         // 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];
             parent = parentChangeTree.parent;
             parentIndex = parentChangeTree.parentIndex;
         }
-        const parentMetadata = parent.constructor?.[Symbol.metadata];
-        this.isFiltered = parentMetadata?.[$viewFieldIndexes]?.includes(parentIndex);
+        const parentConstructor = parent.constructor;
+        let key = `${this.root.types.getTypeId(ref.constructor)}`;
+        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: [] };
@@ -1340,10 +1374,6 @@ class ChangeTree {
                 const allFilteredChanges = this.allFilteredChanges;
                 this.allFilteredChanges = this.allChanges;
                 this.allChanges = allFilteredChanges;
-                // console.log("SWAP =>", {
-                //     "this.allFilteredChanges": this.allFilteredChanges,
-                //     "this.allChanges": this.allChanges
-                // })
             }
         }
     }
@@ -3231,7 +3261,7 @@ class Schema {
         const rootChangeTree = ref[$changes];
         const root = rootChangeTree.root;
         const changeTrees = new Map();
-        let totalInstances = 0;
+        const instanceRefIds = [];
         let totalOperations = 0;
         for (const [refId, changes] of Object.entries(root[changeSetName])) {
             const changeTree = root.changeTrees[refId];
@@ -3252,14 +3282,14 @@ class Schema {
                 }
             }
             if (includeChangeTree) {
-                totalInstances += 1;
+                instanceRefIds.push(changeTree.refId);
                 totalOperations += Object.keys(changes).length;
                 changeTrees.set(changeTree, parentChangeTrees.reverse());
             }
         }
         output += "---\n";
         output += `root refId: ${rootChangeTree.refId}\n`;
-        output += `Total instances: ${totalInstances}\n`;
+        output += `Total instances: ${instanceRefIds.length} (refIds: ${instanceRefIds.join(", ")})\n`;
         output += `Total changes: ${totalOperations}\n`;
         output += "---\n";
         // based on root.changes, display a tree of changes that has the "ref" instance as parent
@@ -3700,7 +3730,7 @@ class Root {
             delete this.changeTrees[changeTree.refId];
             this.removeChangeFromChangeSet("allChanges", changeTree);
             this.removeChangeFromChangeSet("changes", changeTree);
-            if (changeTree.isFiltered || changeTree.isPartiallyFiltered) {
+            if (changeTree.filteredChanges) {
                 this.removeChangeFromChangeSet("allFilteredChanges", changeTree);
                 this.removeChangeFromChangeSet("filteredChanges", changeTree);
             }
@@ -4046,6 +4076,7 @@ class ReferenceTracker {
     clearRefs() {
         this.refs.clear();
         this.deletedRefs.clear();
+        this.callbacks = {};
         this.refCounts = {};
     }
     // for decoding
@@ -4710,7 +4741,7 @@ class StateView {
         }
         else {
             const isInvisible = this.invisible.has(changeTree);
-            const changeSet = (changeTree.isFiltered || changeTree.isPartiallyFiltered)
+            const changeSet = (changeTree.filteredChanges !== undefined)
                 ? changeTree.allFilteredChanges
                 : changeTree.allChanges;
             for (let i = 0, len = changeSet.operations.length; i < len; i++) {
@@ -4718,7 +4749,7 @@ class StateView {
                 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 ((isInvisible || // if "invisible", include all
                     tagAtIndex === undefined || // "all change" with no tag
@@ -4732,7 +4763,9 @@ 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);
@@ -4744,7 +4777,7 @@ class StateView {
         this.items.add(changeTree);
         // add parent's parent
         const parentChangeTree = changeTree.parent?.[$changes];
-        if (parentChangeTree && (parentChangeTree.isFiltered || parentChangeTree.isPartiallyFiltered)) {
+        if (parentChangeTree && (parentChangeTree.filteredChanges !== undefined)) {
             this.addParent(parentChangeTree, changeTree.parentIndex, tag);
         }
         // parent is already available, no need to add it!