@colyseus/schema 3.0.0-alpha.8 → 3.0.0

package/src/encoder/ChangeTree.ts

@@ -1,16 +1,18 @@
 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";
 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";
+import { TypeContext } from "../types/TypeContext";
+import { ReferenceTracker } from "../decoder/ReferenceTracker";
 
 declare global {
     interface Object {
@@ -27,50 +29,47 @@ export type Ref = Schema
     | CollectionSchema
     | SetSchema;
 
-export class Root {
-    protected nextUniqueId: number = 0;
-    refCount = new WeakMap<ChangeTree, number>();
+export type ChangeSetName = "changes"
+    | "allChanges"
+    | "filteredChanges"
+    | "allFilteredChanges";
 
-    // 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>>();
+export interface IndexedOperations {
+    [index: number]: OPERATION;
+}
 
-    getNextUniqueId() {
-        return this.nextUniqueId++;
-    }
+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`
+}
 
-    add (changeTree: ChangeTree) {
-        const refCount = this.refCount.get(changeTree) || 0;
-        this.refCount.set(changeTree, refCount + 1);
+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;
     }
+}
 
-    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));
+export function deleteOperationAtIndex(changeSet: ChangeSet, index: number) {
+    const operationsIndex = changeSet.indexes[index];
+    if (operationsIndex !== undefined) {
+        changeSet.operations[operationsIndex] = undefined;
     }
+    delete changeSet.indexes[index];
+}
 
-    clear() {
-        this.changes.clear();
+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;
     }
 }
 
@@ -79,69 +78,68 @@ export class ChangeTree<T extends Ref=any> {
     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`)
-    currentOperationIndex: number = 0;
+    /**
+     * Whether this structure is parent of a filtered structure.
+     */
+    isFiltered: boolean = false;
+
+    indexedOperations: IndexedOperations = {};
 
-    allChanges = new Map<number, OPERATION>();
-    allFilteredChanges = new 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;
 
-    changes = new Map<number, OPERATION>();
-    filteredChanges = new Map<number, OPERATION>();;
+    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;
-    }
 
-    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".
+        // Does this structure have "filters" declared?
         //
-        this.checkIsFiltered(this.parent, this.parentIndex);
-
-        // unique refId for the ChangeTree.
-        this.ensureRefId();
-
-        if (!this.isFiltered) {
-            this.root.changes.set(this, this.changes);
+        const metadata = ref.constructor[Symbol.metadata];
+        if (metadata?.[$viewFieldIndexes]) {
+            this.allFilteredChanges = { indexes: {}, operations: [] };
+            this.filteredChanges = { indexes: {}, operations: [] };
         }
+    }
 
-        if (this.isFiltered || this.isPartiallyFiltered) {
-            this.root.allFilteredChanges.set(this, this.allFilteredChanges);
-            this.root.filteredChanges.set(this, this.filteredChanges);
+    setRoot(root: Root) {
+        this.root = root;
+        this.checkIsFiltered(this.parent, this.parentIndex);
 
-        // } else {
-        //     this.root.allChanges.set(this, this.allChanges);
-        }
+        // 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 value = this.ref[field.name];
+                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(
@@ -155,97 +153,97 @@ export class ChangeTree<T extends Ref=any> {
         // avoid setting parents with empty `root`
         if (!root) { return; }
 
-        root.add(this);
-
         // skip if parent is already set
-        if (root === this.root) {
-            this.forEachChild((changeTree, atIndex) => {
-                changeTree.setParent(this.ref, root, atIndex);
-            });
-            return;
-        }
-
-        this.root = root;
-        this.checkIsFiltered(parent, parentIndex);
+        if (root !== this.root) {
+            this.root = root;
+            this.checkIsFiltered(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);
         } else {
-            this.root.allChanges.set(this, this.allChanges);
+            root.add(this);
         }
 
-        this.ensureRefId();
+        // 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);
+            });
+
+        } 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[$refTypeFieldIndexes]?.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);
             });
         }
     }
 
     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) {
-        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;
 
-        const previousOperation = changeSet.get(index);
+        const previousOperation = this.indexedOperations[index];
         if (!previousOperation || previousOperation === OPERATION.DELETE) {
             const op = (!previousOperation)
                 ? operation
                 : (previousOperation === OPERATION.DELETE)
                     ? OPERATION.DELETE_AND_ADD
                     : operation
-            changeSet.set(index, op);
+            //
+            // TODO: are DELETE operations being encoded as ADD here ??
+            //
+            this.indexedOperations[index] = op;
         }
 
-        //
-        // TODO: are DELETE operations being encoded as ADD here ??
-        //
+        setOperationAtIndex(changeSet, index);
 
         if (isFiltered) {
-            this.allFilteredChanges.set(index, OPERATION.ADD);
-            this.root?.filteredChanges.set(this, this.filteredChanges);
+            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');
         }
     }
 
@@ -259,13 +257,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) {
@@ -274,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);
 
@@ -283,36 +284,46 @@ 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);
+    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) {
-        const metadata = this.ref['constructor'][Symbol.metadata] as Metadata;
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
+    indexedOperation(index: number, operation: OPERATION, allChangesIndex: number = index) {
+        this.indexedOperations[index] = operation;
 
-        if (isFiltered) {
-            this.allFilteredChanges.set(allChangesIndex, OPERATION.ADD);
-            this.filteredChanges.set(index, operation);
-            this.root?.filteredChanges.set(this, this.filteredChanges);
+        if (this.filteredChanges !== undefined) {
+            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');
         }
     }
 
     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 {
             //
@@ -326,8 +337,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];
     }
 
     //
@@ -350,20 +360,17 @@ 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 !== undefined)
             ? 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]) {
-            previousValue[$changes].root = undefined;
-
             //
             // FIXME: this.root is "undefined"
             //
@@ -372,30 +379,36 @@ 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]);
         }
 
         //
-        // FIXME: this is looking a bit ugly (and repeated from `.change()`)
+        // FIXME: this is looking a ugly and repeated
         //
-        if (isFiltered) {
-            this.root?.filteredChanges.set(this, this.filteredChanges);
-            this.allFilteredChanges.delete(allChangesIndex);
+        if (this.filteredChanges !== undefined) {
+            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) {
@@ -406,15 +419,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, _) =>
@@ -426,13 +450,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();
     }
@@ -447,43 +472,91 @@ export class ChangeTree<T extends Ref=any> {
     }
 
     get changed() {
-        return this.changes.size > 0;
+        return (Object.entries(this.indexedOperations).length > 0);
     }
 
     protected checkIsFiltered(parent: Ref, parentIndex: number) {
-        // Detect if current structure has "filters" declared
-        this.isPartiallyFiltered = this.ref['constructor']?.[Symbol.metadata]?.[-2];
+        const isNewChangeTree = this.root.add(this);
 
-        // TODO: support "partially filtered", where the instance is visible, but only a field is not.
+        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);
 
-        // Detect if parent has "filters" declared
-        while (parent && !this.isFiltered) {
-            const metadata: Metadata = parent['constructor'][Symbol.metadata];
+            if (this.filteredChanges !== undefined) {
+                enqueueChangeTree(this.root, this, 'filteredChanges');
+                if (isNewChangeTree) {
+                    this.root.allFilteredChanges.push(this);
+                }
+            }
+        }
 
-            const fieldName = metadata?.[parentIndex];
-            const isParentOwned = metadata?.[fieldName]?.tag !== undefined;
+        if (!this.isFiltered) {
+            enqueueChangeTree(this.root, this, 'changes');
+            if (isNewChangeTree) {
+                this.root.allChanges.push(this);
+            }
+        }
+    }
 
-            this.isFiltered = isParentOwned || parent[$changes].isFiltered; // metadata?.[-2]
+    protected _checkFilteredByParent(parent: Ref, parentIndex: number) {
+        // skip if parent is not set
+        if (!parent) { return; }
 
-            parent = parent[$changes].parent;
-        };
+        //
+        // ArraySchema | MapSchema - get the child type
+        // (if refType is typeof string, the parentFiltered[key] below will always be invalid)
+        //
+        const refType = Metadata.isValidInstance(this.ref)
+            ? this.ref.constructor
+            :  this.ref[$childType];
+
+        if (!Metadata.isValidInstance(parent)) {
+            const parentChangeTree = parent[$changes];
+            parent = parentChangeTree.parent;
+            parentIndex = parentChangeTree.parentIndex;
+        }
+
+        const parentConstructor = parent.constructor as typeof Schema;
+
+        let key = `${this.root.types.getTypeId(refType as typeof Schema)}`;
+        if (parentConstructor) {
+            key += `-${this.root.types.schemas.get(parentConstructor)}`;
+        }
+        key += `-${parentIndex}`;
+
+        this.isFiltered = parent[$changes].isFiltered // in case parent is already filtered
+            || 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.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;
+        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;
+            }
         }
     }