@colyseus/schema 3.0.0-alpha.27 → 3.0.0-alpha.29

package/build/esm/index.mjs

@@ -194,44 +194,6 @@ const Metadata = {
 };
 
 var _a$5;
-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();
-    }
-    getNextUniqueId() {
-        return this.nextUniqueId++;
-    }
-    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));
-    }
-    clear() {
-        this.changes.clear();
-    }
-}
 class ChangeTree {
     static { _a$5 = $isNew; }
     ;
@@ -263,8 +225,6 @@ class ChangeTree {
         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);
         }
         if (!this.isFiltered) {
             this.root.allChanges.set(this, this.allChanges);
@@ -537,15 +497,30 @@ class ChangeTree {
     checkIsFiltered(parent, parentIndex) {
         // Detect if current structure has "filters" declared
         this.isPartiallyFiltered = (this.ref['constructor']?.[Symbol.metadata]?.[-2] !== undefined);
-        // 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[$changes].isFiltered; // metadata?.[-2]
-            parent = parent[$changes].parent;
-        }
+        if (parent && !Metadata.isValidInstance(parent)) {
+            const parentChangeTree = parent[$changes];
+            parent = parentChangeTree.parent;
+            parentIndex = parentChangeTree.parentIndex;
+        }
+        const parentMetadata = parent?.['constructor']?.[Symbol.metadata];
+        this.isFiltered = (parent &&
+            parentMetadata?.[-2]?.includes(parentIndex));
+        // this.isFiltered = this.ref['constructor']?.[Symbol.metadata]?.[-4];
+        // // Detect if parent has "filters" declared
+        // while (parent && !this.isFiltered) {
+        //     const metadata: Metadata = parent['constructor'][Symbol.metadata];
+        //     // this.isFiltered = metadata?.[-4];
+        //     const fieldName = metadata?.[parentIndex];
+        //     const isParentOwned = metadata?.[fieldName]?.tag !== undefined;
+        //     this.isFiltered = isParentOwned || parent[$changes].isFiltered; // metadata?.[-2]
+        //     parent = parent[$changes].parent;
+        // };
+        // console.log("ChangeTree.checkIsFiltered", {
+        //     parent: parent?.constructor.name,
+        //     ref: this.ref.constructor.name,
+        //     isFiltered: this.isFiltered,
+        //     isPartiallyFiltered: this.isPartiallyFiltered,
+        // });
         //
         // TODO: refactor this!
         //
@@ -1686,7 +1661,6 @@ class ArraySchema {
             }
             const changeTree = this[$changes];
             changeTree.indexedOperation(length, OPERATION.ADD, this.items.length);
-            // changeTree.indexes[length] = length;
             this.items.push(value);
             this.tmpItems.push(value);
             //
@@ -2377,7 +2351,6 @@ class MapSchema {
 }
 registerType("map", { constructor: MapSchema });
 
-const DEFAULT_VIEW_TAG = -1;
 class TypeContext {
     /**
      * For inheritance support
@@ -2399,6 +2372,7 @@ class TypeContext {
         this.types = {};
         this.schemas = new Map();
         this.hasFilters = false;
+        this.parentFiltered = {};
         if (rootClass) {
             this.discoverTypes(rootClass);
         }
@@ -2427,32 +2401,32 @@ class TypeContext {
     getTypeId(klass) {
         return this.schemas.get(klass);
     }
-    discoverTypes(klass, parentFieldViewTag) {
+    discoverTypes(klass, parentIndex, parentFieldViewTag) {
         if (!this.add(klass)) {
             return;
         }
         // add classes inherited from this base class
         TypeContext.inheritedTypes.get(klass)?.forEach((child) => {
-            this.discoverTypes(child, parentFieldViewTag);
+            this.discoverTypes(child, parentIndex, parentFieldViewTag);
         });
-        // skip if no fields are defined for this class.
-        if (klass[Symbol.metadata] === undefined) {
-            klass[Symbol.metadata] = {};
-        }
-        // const metadata = Metadata.getFor(klass);
-        const metadata = klass[Symbol.metadata];
+        const metadata = (klass[Symbol.metadata] ??= {});
         // if any schema/field has filters, mark "context" as having filters.
         if (metadata[-2]) {
             this.hasFilters = true;
         }
+        if (parentFieldViewTag !== undefined) {
+            this.parentFiltered[`${this.schemas.get(klass)}-${parentIndex}`] = true;
+        }
         for (const field in metadata) {
-            //
-            // Modify the field's metadata to include the parent field's view tag
-            //
-            if (parentFieldViewTag !== undefined &&
-                metadata[field].tag === undefined) {
-                metadata[field].tag = parentFieldViewTag;
-            }
+            // //
+            // // Modify the field's metadata to include the parent field's view tag
+            // //
+            // if (
+            //     parentFieldViewTag !== undefined &&
+            //     metadata[field].tag === undefined
+            // ) {
+            //     metadata[field].tag = parentFieldViewTag;
+            // }
             const fieldType = metadata[field].type;
             const viewTag = metadata[field].tag;
             if (typeof (fieldType) === "string") {
@@ -2463,7 +2437,7 @@ class TypeContext {
                 if (type === "string") {
                     continue;
                 }
-                this.discoverTypes(type, viewTag);
+                this.discoverTypes(type, metadata[field].index, viewTag);
             }
             else if (typeof (fieldType) === "function") {
                 this.discoverTypes(fieldType, viewTag);
@@ -2474,11 +2448,13 @@ class TypeContext {
                 if (typeof (type) === "string") {
                     continue;
                 }
-                this.discoverTypes(type, viewTag);
+                this.discoverTypes(type, metadata[field].index, viewTag);
             }
         }
     }
 }
+
+const DEFAULT_VIEW_TAG = -1;
 /**
  * [See documentation](https://docs.colyseus.io/state/schema/)
  *
@@ -3440,16 +3416,56 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+class Root {
+    constructor(types) {
+        this.types = types;
+        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();
+    }
+    getNextUniqueId() {
+        return this.nextUniqueId++;
+    }
+    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));
+    }
+    clear() {
+        this.changes.clear();
+    }
+}
+
 class Encoder {
     static { this.BUFFER_SIZE = 8 * 1024; } // 8KB
     constructor(state) {
         this.sharedBuffer = Buffer.allocUnsafeSlow(Encoder.BUFFER_SIZE);
-        this.root = new Root();
         //
         // TODO: cache and restore "Context" based on root schema
         // (to avoid creating a new context for every new room)
         //
         this.context = new TypeContext(state.constructor);
+        this.root = new Root(this.context);
         this.setState(state);
         // console.log(">>>>>>>>>>>>>>>> Encoder types");
         // this.context.schemas.forEach((id, schema) => {
@@ -3486,7 +3502,8 @@ class Encoder {
                 }
             }
             // skip root `refId` if it's the first change tree
-            if (it.offset !== initialOffset || changeTree !== rootChangeTree) {
+            // (unless it "hasView", which will need to revisit the root)
+            if (hasView || changeTree !== rootChangeTree) {
                 buffer[it.offset++] = SWITCH_TO_STRUCTURE & 255;
                 number$1(buffer, changeTree.refId, it);
             }
@@ -3548,35 +3565,43 @@ class Encoder {
         }
     }
     encodeAll(it = { offset: 0 }, buffer = this.sharedBuffer) {
-        // console.log(`encodeAll(), this.root.allChanges (${this.root.allChanges.size})`);
-        // Array.from(this.root.allChanges.entries()).map((item) => {
-        //     console.log("->", { ref: item[0].ref.constructor.name, refId: item[0].refId, changes: item[1].size });
-        // });
+        // console.log(`\nencodeAll(), this.root.allChanges (${this.root.allChanges.size})`);
+        // this.debugChanges("allChanges");
         return this.encode(it, undefined, buffer, this.root.allChanges, true);
     }
     encodeAllView(view, sharedOffset, it, bytes = this.sharedBuffer) {
         const viewOffset = it.offset;
-        // console.log(`encodeAllView(), this.root.allFilteredChanges (${this.root.allFilteredChanges.size})`);
-        // this.debugAllFilteredChanges();
+        // console.log(`\nencodeAllView(), this.root.allFilteredChanges (${this.root.allFilteredChanges.size})`);
+        // this.debugChanges("allFilteredChanges");
         // try to encode "filtered" changes
-        this.encode(it, view, bytes, this.root.allFilteredChanges, true);
+        this.encode(it, view, bytes, this.root.allFilteredChanges, true, viewOffset);
         return Buffer.concat([
             bytes.subarray(0, sharedOffset),
             bytes.subarray(viewOffset, it.offset)
         ]);
     }
-    debugAllFilteredChanges() {
-        Array.from(this.root.allFilteredChanges.entries()).map((item) => {
-            console.log("->", { refId: item[0].refId, changes: item[1].size }, item[0].ref.toJSON());
-            if (Array.isArray(item[0].ref.toJSON())) {
-                item[1].forEach((op, key) => {
-                    console.log("  ->", { key, op: OPERATION[op] });
+    debugChanges(field) {
+        const changeSet = (typeof (field) === "string")
+            ? this.root[field]
+            : field;
+        Array.from(changeSet.entries()).map((item) => {
+            const metadata = item[0].ref.constructor[Symbol.metadata];
+            console.log("->", { ref: item[0].ref.constructor.name, refId: item[0].refId, changes: item[1].size });
+            item[1].forEach((op, index) => {
+                console.log("  ->", {
+                    index,
+                    field: metadata?.[index],
+                    op: OPERATION[op],
                 });
-            }
+            });
         });
     }
     encodeView(view, sharedOffset, it, bytes = this.sharedBuffer) {
         const viewOffset = it.offset;
+        // console.log(`\nencodeView(), view.changes (${view.changes.size})`);
+        // this.debugChanges(view.changes);
+        // console.log(`\nencodeView(), this.root.filteredChanges (${this.root.filteredChanges.size})`);
+        // this.debugChanges("filteredChanges");
         // encode visibility changes (add/remove for this view)
         const viewChangesIterator = view.changes.entries();
         for (const [changeTree, changes] of viewChangesIterator) {
@@ -4131,11 +4156,11 @@ function getDecoderStateCallbacks(decoder) {
         let isCollection = ((context.instance && typeof (context.instance['forEach']) === "function") ||
             (metadataOrType && typeof (metadataOrType[Symbol.metadata]) === "undefined"));
         if (metadata && !isCollection) {
-            const onAdd = function (ref, prop, callback, immediate) {
+            const onAddListen = function (ref, prop, callback, immediate) {
                 // immediate trigger
                 if (immediate &&
                     context.instance[prop] !== undefined &&
-                    !onAddCalls.has(callback) // Workaround for https://github.com/colyseus/schema/issues/147
+                    !onAddCalls.has(currentOnAddCallback) // Workaround for https://github.com/colyseus/schema/issues/147
                 ) {
                     callback(context.instance[prop], undefined);
                 }
@@ -4147,13 +4172,13 @@ function getDecoderStateCallbacks(decoder) {
             return new Proxy({
                 listen: function listen(prop, callback, immediate = true) {
                     if (context.instance) {
-                        return onAdd(context.instance, prop, callback, immediate);
+                        return onAddListen(context.instance, prop, callback, immediate);
                     }
                     else {
                         // collection instance not received yet
                         let detachCallback = () => { };
                         context.onInstanceAvailable((ref, existing) => {
-                            detachCallback = onAdd(ref, prop, callback, immediate && existing);
+                            detachCallback = onAddListen(ref, prop, callback, immediate && existing && !onAddCalls.has(currentOnAddCallback));
                         });
                         return () => detachCallback();
                     }
@@ -4222,6 +4247,7 @@ function getDecoderStateCallbacks(decoder) {
                     currentOnAddCallback = callback;
                     callback(value, key);
                     onAddCalls.delete(callback);
+                    currentOnAddCallback = undefined;
                 });
             };
             const onRemove = function (ref, callback) {