@colyseus/schema 3.0.0-alpha.9 → 3.0.1

package/lib/encoder/ChangeTree.js

@@ -1,95 +1,80 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChangeTree = exports.Root = void 0;
+exports.ChangeTree = void 0;
+exports.setOperationAtIndex = setOperationAtIndex;
+exports.deleteOperationAtIndex = deleteOperationAtIndex;
 const spec_1 = require("../encoding/spec");
 const symbols_1 = require("../types/symbols");
 const Metadata_1 = require("../Metadata");
-class Root {
-    constructor() {
-        this.nextUniqueId = 0;
-        this.refCount = new WeakMap();
-        // all changes
-        this.allChanges = new Map();
-        this.allFilteredChanges = new Map();
-        // pending changes to be encoded
-        this.changes = new Map();
-        this.filteredChanges = new Map();
+function setOperationAtIndex(changeSet, index) {
+    const operationsIndex = changeSet.indexes[index];
+    if (operationsIndex === undefined) {
+        changeSet.indexes[index] = changeSet.operations.push(index) - 1;
     }
-    getNextUniqueId() {
-        return this.nextUniqueId++;
+    else {
+        changeSet.operations[operationsIndex] = index;
     }
-    add(changeTree) {
-        const refCount = this.refCount.get(changeTree) || 0;
-        this.refCount.set(changeTree, refCount + 1);
-    }
-    remove(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));
+}
+function deleteOperationAtIndex(changeSet, index) {
+    const operationsIndex = changeSet.indexes[index];
+    if (operationsIndex !== undefined) {
+        changeSet.operations[operationsIndex] = undefined;
     }
-    clear() {
-        this.changes.clear();
+    delete changeSet.indexes[index];
+}
+function enqueueChangeTree(root, changeTree, changeSet, queueRootIndex = changeTree[changeSet].queueRootIndex) {
+    if (root && root[changeSet][queueRootIndex] !== changeTree) {
+        changeTree[changeSet].queueRootIndex = root[changeSet].push(changeTree) - 1;
     }
 }
-exports.Root = Root;
 class ChangeTree {
-    static { _a = symbols_1.$isNew; }
-    ;
     constructor(ref) {
-        this.indexes = {}; // TODO: remove this, only used by MapSchema/SetSchema/CollectionSchema (`encodeKeyValueOperation`)
-        this.currentOperationIndex = 0;
-        this.allChanges = new Map();
-        this.allFilteredChanges = new Map();
-        this.changes = new Map();
-        this.filteredChanges = new Map();
-        this[_a] = true;
+        /**
+         * Whether this structure is parent of a filtered structure.
+         */
+        this.isFiltered = false;
+        this.indexedOperations = {};
+        //
+        // TODO:
+        //   try storing the index + operation per item.
+        //   example: 1024 & 1025 => ADD, 1026 => DELETE
+        //
+        // => https://chatgpt.com/share/67107d0c-bc20-8004-8583-83b17dd7c196
+        //
+        this.changes = { indexes: {}, operations: [] };
+        this.allChanges = { indexes: {}, operations: [] };
+        /**
+         * Is this a new instance? Used on ArraySchema to determine OPERATION.MOVE_AND_ADD operation.
+         */
+        this.isNew = true;
         this.ref = ref;
+        //
+        // Does this structure have "filters" declared?
+        //
+        const metadata = ref.constructor[Symbol.metadata];
+        if (metadata?.[symbols_1.$viewFieldIndexes]) {
+            this.allFilteredChanges = { indexes: {}, operations: [] };
+            this.filteredChanges = { indexes: {}, operations: [] };
+        }
     }
     setRoot(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);
-        // unique refId for the ChangeTree.
-        this.ensureRefId();
-        if (!this.isFiltered) {
-            this.root.changes.set(this, this.changes);
+        // Recursively set root on child structures
+        const metadata = this.ref.constructor[Symbol.metadata];
+        if (metadata) {
+            metadata[symbols_1.$refTypeFieldIndexes]?.forEach((index) => {
+                const field = metadata[index];
+                const value = this.ref[field.name];
+                value?.[symbols_1.$changes].setRoot(root);
+            });
         }
-        if (this.isFiltered || this.isPartiallyFiltered) {
-            this.root.allFilteredChanges.set(this, this.allFilteredChanges);
-            this.root.filteredChanges.set(this, this.filteredChanges);
-            // } else {
-            //     this.root.allChanges.set(this, this.allChanges);
+        else if (this.ref[symbols_1.$childType] && typeof (this.ref[symbols_1.$childType]) !== "string") {
+            // MapSchema / ArraySchema, etc.
+            this.ref.forEach((value, key) => {
+                value[symbols_1.$changes].setRoot(root);
+            });
         }
-        if (!this.isFiltered) {
-            this.root.allChanges.set(this, this.allChanges);
-        }
-        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(parent, root, parentIndex) {
         this.parent = parent;
@@ -98,83 +83,86 @@ class ChangeTree {
         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;
+        if (root !== this.root) {
+            this.root = root;
+            this.checkIsFiltered(parent, parentIndex);
         }
-        this.root = root;
-        this.checkIsFiltered(parent, parentIndex);
-        if (!this.isFiltered) {
-            this.root.changes.set(this, this.changes);
+        else {
+            root.add(this);
         }
-        if (this.isFiltered || this.isPartiallyFiltered) {
-            this.root.filteredChanges.set(this, this.filteredChanges);
-            this.root.allFilteredChanges.set(this, this.filteredChanges);
+        // assign same parent on child structures
+        const metadata = this.ref.constructor[Symbol.metadata];
+        if (metadata) {
+            metadata[symbols_1.$refTypeFieldIndexes]?.forEach((index) => {
+                const field = metadata[index];
+                const value = this.ref[field.name];
+                value?.[symbols_1.$changes].setParent(this.ref, root, index);
+            });
         }
-        else {
-            this.root.allChanges.set(this, this.allChanges);
+        else if (this.ref[symbols_1.$childType] && typeof (this.ref[symbols_1.$childType]) !== "string") {
+            // MapSchema / ArraySchema, etc.
+            this.ref.forEach((value, key) => {
+                value[symbols_1.$changes].setParent(this.ref, root, this.indexes[key] ?? key);
+            });
         }
-        this.ensureRefId();
-        this.forEachChild((changeTree, atIndex) => {
-            changeTree.setParent(this.ref, root, atIndex);
-        });
     }
     forEachChild(callback) {
         //
         // assign same parent on child structures
         //
-        if (Metadata_1.Metadata.isValidInstance(this.ref)) {
-            const 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[symbols_1.$changes]) {
-                    callback(value[symbols_1.$changes], metadata[field].index);
+        const metadata = this.ref.constructor[Symbol.metadata];
+        if (metadata) {
+            metadata[symbols_1.$refTypeFieldIndexes]?.forEach((index) => {
+                const field = metadata[index];
+                const value = this.ref[field.name];
+                if (value) {
+                    callback(value[symbols_1.$changes], index);
                 }
-            }
+            });
         }
-        else if (typeof (this.ref) === "object") {
+        else if (this.ref[symbols_1.$childType] && typeof (this.ref[symbols_1.$childType]) !== "string") {
             // MapSchema / ArraySchema, etc.
             this.ref.forEach((value, key) => {
-                if (Metadata_1.Metadata.isValidInstance(value)) {
-                    callback(value[symbols_1.$changes], this.ref[symbols_1.$changes].indexes[key]);
-                }
+                callback(value[symbols_1.$changes], this.indexes[key] ?? key);
             });
         }
     }
     operation(op) {
-        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, operation = spec_1.OPERATION.ADD) {
-        const metadata = this.ref['constructor'][Symbol.metadata];
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
+        const metadata = this.ref.constructor[Symbol.metadata];
+        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 === spec_1.OPERATION.DELETE) {
             const op = (!previousOperation)
                 ? operation
                 : (previousOperation === spec_1.OPERATION.DELETE)
                     ? spec_1.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, spec_1.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, spec_1.OPERATION.ADD);
-            this.root?.changes.set(this, this.changes);
+            setOperationAtIndex(this.allChanges, index);
+            enqueueChangeTree(this.root, this, 'changes');
         }
     }
     shiftChangeIndexes(shiftIndex) {
@@ -186,12 +174,15 @@ class ChangeTree {
         const changeSet = (this.isFiltered)
             ? 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, startIndex = 0) {
         //
@@ -199,7 +190,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);
         }
@@ -207,33 +198,42 @@ class ChangeTree {
             this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allChanges);
         }
     }
-    _shiftAllChangeIndexes(shiftIndex, startIndex = 0, allChangeSet) {
-        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);
+    _shiftAllChangeIndexes(shiftIndex, startIndex = 0, 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, operation, allChangesIndex = index) {
-        const metadata = this.ref['constructor'][Symbol.metadata];
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
-        if (isFiltered) {
-            this.allFilteredChanges.set(allChangesIndex, spec_1.OPERATION.ADD);
-            this.filteredChanges.set(index, operation);
-            this.root?.filteredChanges.set(this, this.filteredChanges);
+        this.indexedOperations[index] = operation;
+        if (this.filteredChanges !== undefined) {
+            setOperationAtIndex(this.allFilteredChanges, allChangesIndex);
+            setOperationAtIndex(this.filteredChanges, index);
+            enqueueChangeTree(this.root, this, 'filteredChanges');
         }
         else {
-            this.allChanges.set(allChangesIndex, spec_1.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) {
         if (Metadata_1.Metadata.isValidInstance(this.ref)) {
-            const metadata = this.ref['constructor'][Symbol.metadata];
-            return metadata[metadata[index]].type;
+            const metadata = this.ref.constructor[Symbol.metadata];
+            return metadata[index].type;
         }
         else {
             //
@@ -246,8 +246,7 @@ class ChangeTree {
         }
     }
     getChange(index) {
-        // TODO: optimize this. avoid checking against multiple instances
-        return this.changes.get(index) ?? this.filteredChanges.get(index);
+        return this.indexedOperations[index];
     }
     //
     // used during `.encode()`
@@ -268,16 +267,14 @@ class ChangeTree {
             }
             return;
         }
-        const metadata = this.ref['constructor'][Symbol.metadata];
-        const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
-        const changeSet = (isFiltered)
+        const changeSet = (this.filteredChanges !== undefined)
             ? this.filteredChanges
             : this.changes;
+        this.indexedOperations[index] = operation ?? spec_1.OPERATION.DELETE;
+        setOperationAtIndex(changeSet, index);
         const previousValue = this.getValue(index);
-        changeSet.set(index, operation ?? spec_1.OPERATION.DELETE);
         // remove `root` reference
         if (previousValue && previousValue[symbols_1.$changes]) {
-            previousValue[symbols_1.$changes].root = undefined;
             //
             // FIXME: this.root is "undefined"
             //
@@ -286,27 +283,31 @@ 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[symbols_1.$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[symbols_1.$onEncodeEnd]?.();
         // Not a new instance anymore
-        delete this[symbols_1.$isNew];
+        this.isNew = false;
     }
     discard(discardAll = false) {
         //
@@ -315,13 +316,22 @@ class ChangeTree {
         //      REPLACE in case same key is used on next patches.
         //
         this.ref[symbols_1.$onEncodeEnd]?.();
-        this.changes.clear();
-        this.filteredChanges.clear();
-        // reset operation index
-        this.currentOperationIndex = 0;
+        this.indexedOperations = {};
+        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, _) => this.root?.remove(changeTree));
         }
@@ -330,12 +340,13 @@ class ChangeTree {
      * 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[symbols_1.$changes]) {
                 value[symbols_1.$changes].discardAll();
             }
-        });
+        }
         this.discard();
     }
     ensureRefId() {
@@ -346,36 +357,79 @@ class ChangeTree {
         this.refId = this.root.getNextUniqueId();
     }
     get changed() {
-        return this.changes.size > 0;
+        return (Object.entries(this.indexedOperations).length > 0);
     }
     checkIsFiltered(parent, parentIndex) {
-        // 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.
-        // Detect if parent has "filters" declared
-        while (parent && !this.isFiltered) {
-            const metadata = parent['constructor'][Symbol.metadata];
-            const fieldName = metadata?.[parentIndex];
-            const isParentOwned = metadata?.[fieldName]?.tag !== undefined;
-            this.isFiltered = isParentOwned || parent[symbols_1.$changes].isFiltered; // metadata?.[-2]
-            parent = parent[symbols_1.$changes].parent;
-        }
-        ;
+        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
+        // (if refType is typeof string, the parentFiltered[key] below will always be invalid)
+        //
+        const refType = Metadata_1.Metadata.isValidInstance(this.ref)
+            ? this.ref.constructor
+            : this.ref[symbols_1.$childType];
+        if (!Metadata_1.Metadata.isValidInstance(parent)) {
+            const parentChangeTree = parent[symbols_1.$changes];
+            parent = parentChangeTree.parent;
+            parentIndex = parentChangeTree.parentIndex;
+        }
+        const parentConstructor = parent.constructor;
+        let key = `${this.root.types.getTypeId(refType)}`;
+        if (parentConstructor) {
+            key += `-${this.root.types.schemas.get(parentConstructor)}`;
+        }
+        key += `-${parentIndex}`;
+        this.isFiltered = parent[symbols_1.$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;
+            }
         }
     }
 }