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

package/build/cjs/index.js

@@ -329,7 +329,7 @@ class ChangeTree {
             // MapSchema / ArraySchema, etc.
             this.ref.forEach((value, key) => {
                 if (Metadata.isValidInstance(value)) {
-                    callback(value[$changes], this.ref[$changes].indexes[key]);
+                    callback(value[$changes], this.ref[$changes].indexes[key] ?? key);
                 }
             });
         }
@@ -357,8 +357,9 @@ class ChangeTree {
         // TODO: are DELETE operations being encoded as ADD here ??
         //
         if (isFiltered) {
-            this.allFilteredChanges.set(index, exports.OPERATION.ADD);
             this.root?.filteredChanges.set(this, this.filteredChanges);
+            this.allFilteredChanges.set(index, exports.OPERATION.ADD);
+            this.root?.allFilteredChanges.set(this, this.allFilteredChanges);
         }
         else {
             this.allChanges.set(index, exports.OPERATION.ADD);
@@ -1405,6 +1406,7 @@ const decodeSchemaOperation = function (decoder, bytes, it, ref, allChanges) {
     // skip early if field is not defined
     const field = metadata[index];
     if (field === undefined) {
+        console.warn("@colyseus/schema: field not defined at", { index, ref: ref.constructor.name, metadata });
         return DEFINITION_MISMATCH;
     }
     const { value, previousValue } = decodeValue(decoder, operation, ref, index, metadata[field].type, bytes, it, allChanges);
@@ -2427,13 +2429,13 @@ class TypeContext {
     getTypeId(klass) {
         return this.schemas.get(klass);
     }
-    discoverTypes(klass) {
+    discoverTypes(klass, parentFieldViewTag) {
         if (!this.add(klass)) {
             return;
         }
         // add classes inherited from this base class
         TypeContext.inheritedTypes.get(klass)?.forEach((child) => {
-            this.discoverTypes(child);
+            this.discoverTypes(child, parentFieldViewTag);
         });
         // skip if no fields are defined for this class.
         if (klass[Symbol.metadata] === undefined) {
@@ -2446,7 +2448,15 @@ class TypeContext {
             this.hasFilters = 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;
+            }
             const fieldType = metadata[field].type;
+            const viewTag = metadata[field].tag;
             if (typeof (fieldType) === "string") {
                 continue;
             }
@@ -2455,10 +2465,10 @@ class TypeContext {
                 if (type === "string") {
                     continue;
                 }
-                this.discoverTypes(type);
+                this.discoverTypes(type, viewTag);
             }
             else if (typeof (fieldType) === "function") {
-                this.discoverTypes(fieldType);
+                this.discoverTypes(fieldType, viewTag);
             }
             else {
                 const type = Object.values(fieldType)[0];
@@ -2466,7 +2476,7 @@ class TypeContext {
                 if (typeof (type) === "string") {
                     continue;
                 }
-                this.discoverTypes(type);
+                this.discoverTypes(type, viewTag);
             }
         }
     }
@@ -3025,13 +3035,13 @@ class Schema {
         }
         return output;
     }
-    static debugChangesDeep(ref) {
+    static debugChangesDeep(ref, changeSetName = "changes") {
         let output = "";
         const rootChangeTree = ref[$changes];
         const changeTrees = new Map();
         let totalInstances = 0;
         let totalOperations = 0;
-        for (const [changeTree, changes] of (rootChangeTree.root.changes.entries())) {
+        for (const [changeTree, changes] of (rootChangeTree.root[changeSetName].entries())) {
             let includeChangeTree = false;
             let parentChangeTrees = [];
             let parentChangeTree = changeTree.parent?.[$changes];
@@ -3434,26 +3444,26 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 
 class Encoder {
     static { this.BUFFER_SIZE = 8 * 1024; } // 8KB
-    constructor(root) {
+    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(root.constructor);
-        this.setRoot(root);
+        this.context = new TypeContext(state.constructor);
+        this.setState(state);
         // console.log(">>>>>>>>>>>>>>>> Encoder types");
         // this.context.schemas.forEach((id, schema) => {
         //     console.log("type:", id, schema.name, Object.keys(schema[Symbol.metadata]));
         // });
     }
-    setRoot(state) {
-        this.root = new Root();
+    setState(state) {
         this.state = state;
-        state[$changes].setRoot(this.root);
+        this.state[$changes].setRoot(this.root);
     }
-    encode(it = { offset: 0 }, view, buffer = this.sharedBuffer, changeTrees = this.root.changes, isEncodeAll = this.root.allChanges === changeTrees) {
-        const initialOffset = it.offset; // cache current offset in case we need to resize the buffer
+    encode(it = { offset: 0 }, view, buffer = this.sharedBuffer, changeTrees = this.root.changes, isEncodeAll = this.root.allChanges === changeTrees, initialOffset = it.offset // cache current offset in case we need to resize the buffer
+    ) {
         const hasView = (view !== undefined);
         const rootChangeTree = this.state[$changes];
         const changeTreesIterator = changeTrees.entries();
@@ -3492,7 +3502,6 @@ class Encoder {
                 // TODO: avoid checking if no view tags were defined
                 //
                 if (filter && !filter(ref, fieldIndex, view)) {
-                    // console.log("SKIP FIELD:", { ref: changeTree.ref.constructor.name, fieldIndex, })
                     // console.log("ADD AS INVISIBLE:", fieldIndex, changeTree.ref.constructor.name)
                     // view?.invisible.add(changeTree);
                     continue;
@@ -3570,8 +3579,6 @@ class Encoder {
     }
     encodeView(view, sharedOffset, it, bytes = this.sharedBuffer) {
         const viewOffset = it.offset;
-        // try to encode "filtered" changes
-        this.encode(it, view, bytes, this.root.filteredChanges);
         // encode visibility changes (add/remove for this view)
         const viewChangesIterator = view.changes.entries();
         for (const [changeTree, changes] of viewChangesIterator) {
@@ -3598,6 +3605,8 @@ class Encoder {
         //
         // clear "view" changes after encoding
         view.changes.clear();
+        // try to encode "filtered" changes
+        this.encode(it, view, bytes, this.root.filteredChanges, false, viewOffset);
         return Buffer.concat([
             bytes.subarray(0, sharedOffset),
             bytes.subarray(viewOffset, it.offset)
@@ -3770,14 +3779,14 @@ class ReferenceTracker {
 class Decoder {
     constructor(root, context) {
         this.currentRefId = 0;
-        this.setRoot(root);
+        this.setState(root);
         this.context = context || new TypeContext(root.constructor);
         // console.log(">>>>>>>>>>>>>>>> Decoder types");
         // this.context.schemas.forEach((id, schema) => {
         //     console.log("type:", id, schema.name, Object.keys(schema[Symbol.metadata]));
         // });
     }
-    setRoot(root) {
+    setState(root) {
         this.state = root;
         this.root = new ReferenceTracker();
         this.root.addRef(0, root);
@@ -3906,9 +3915,7 @@ class Reflection extends Schema {
         this.types = new ArraySchema();
     }
     static encode(instance, context, it = { offset: 0 }) {
-        if (!context) {
-            context = new TypeContext(instance.constructor);
-        }
+        context ??= new TypeContext(instance.constructor);
         const reflection = new Reflection();
         const encoder = new Encoder(reflection);
         const buildType = (currentType, metadata) => {
@@ -4032,7 +4039,8 @@ __decorate([
 function getDecoderStateCallbacks(decoder) {
     const $root = decoder.root;
     const callbacks = $root.callbacks;
-    let isTriggeringOnAdd = false;
+    const onAddCalls = new WeakMap();
+    let currentOnAddCallback;
     decoder.triggerChanges = function (allChanges) {
         const uniqueRefIds = new Set();
         for (let i = 0, l = allChanges.length; i < l; i++) {
@@ -4095,7 +4103,6 @@ function getDecoderStateCallbacks(decoder) {
                         }
                     }
                     // Handle DELETE_AND_ADD operations
-                    // FIXME: should we set "isTriggeringOnAdd" here?
                     if ((change.op & exports.OPERATION.ADD) === exports.OPERATION.ADD) {
                         const addCallbacks = $callbacks[exports.OPERATION.ADD];
                         for (let i = addCallbacks?.length - 1; i >= 0; i--) {
@@ -4105,12 +4112,10 @@ function getDecoderStateCallbacks(decoder) {
                 }
                 else if ((change.op & exports.OPERATION.ADD) === exports.OPERATION.ADD && change.previousValue === undefined) {
                     // triger onAdd
-                    isTriggeringOnAdd = true;
                     const addCallbacks = $callbacks[exports.OPERATION.ADD];
                     for (let i = addCallbacks?.length - 1; i >= 0; i--) {
                         addCallbacks[i](change.value, change.dynamicIndex ?? change.field);
                     }
-                    isTriggeringOnAdd = false;
                 }
                 // trigger onChange
                 if (change.value !== change.previousValue) {
@@ -4132,7 +4137,7 @@ function getDecoderStateCallbacks(decoder) {
                 // immediate trigger
                 if (immediate &&
                     context.instance[prop] !== undefined &&
-                    !isTriggeringOnAdd // FIXME: This is a workaround (https://github.com/colyseus/schema/issues/147)
+                    !onAddCalls.has(callback) // Workaround for https://github.com/colyseus/schema/issues/147
                 ) {
                     callback(context.instance[prop], undefined);
                 }
@@ -4158,10 +4163,11 @@ function getDecoderStateCallbacks(decoder) {
                 onChange: function onChange(callback) {
                     return $root.addCallback($root.refIds.get(context.instance), exports.OPERATION.REPLACE, callback);
                 },
+                //
+                // TODO: refactor `bindTo()` implementation.
+                // There is room for improvement.
+                //
                 bindTo: function bindTo(targetObject, properties) {
-                    //
-                    // TODO: refactor this implementation. There is room for improvement here.
-                    //
                     if (!properties) {
                         properties = Object.keys(metadata);
                     }
@@ -4188,7 +4194,8 @@ function getDecoderStateCallbacks(decoder) {
                             }
                         });
                         return getProxy(metadata[prop].type, {
-                            instance,
+                            // make sure refId is available, otherwise need to wait for the instance to be available.
+                            instance: ($root.refIds.get(instance) && instance),
                             parentInstance: context.instance,
                             onInstanceAvailable,
                         });
@@ -4212,7 +4219,12 @@ function getDecoderStateCallbacks(decoder) {
                 if (immediate) {
                     ref.forEach((v, k) => callback(v, k));
                 }
-                return $root.addCallback($root.refIds.get(ref), exports.OPERATION.ADD, callback);
+                return $root.addCallback($root.refIds.get(ref), exports.OPERATION.ADD, (value, key) => {
+                    onAddCalls.set(callback, true);
+                    currentOnAddCallback = callback;
+                    callback(value, key);
+                    onAddCalls.delete(callback);
+                });
             };
             const onRemove = function (ref, callback) {
                 return $root.addCallback($root.refIds.get(ref), exports.OPERATION.DELETE, callback);
@@ -4223,19 +4235,17 @@ function getDecoderStateCallbacks(decoder) {
                     // https://github.com/colyseus/schema/issues/147
                     // If parent instance has "onAdd" registered, avoid triggering immediate callback.
                     //
-                    // FIXME: "isTriggeringOnAdd" is a workaround. We should find a better way to handle this.
-                    //
-                    if (context.onInstanceAvailable) {
+                    if (context.instance) {
+                        return onAdd(context.instance, callback, immediate && !onAddCalls.has(currentOnAddCallback));
+                    }
+                    else if (context.onInstanceAvailable) {
                         // collection instance not received yet
                         let detachCallback = () => { };
                         context.onInstanceAvailable((ref, existing) => {
-                            detachCallback = onAdd(ref, callback, immediate && existing && !isTriggeringOnAdd);
+                            detachCallback = onAdd(ref, callback, immediate && existing && !onAddCalls.has(currentOnAddCallback));
                         });
                         return () => detachCallback();
                     }
-                    else if (context.instance) {
-                        return onAdd(context.instance, callback, immediate && !isTriggeringOnAdd);
-                    }
                 },
                 onRemove: function (callback) {
                     if (context.onInstanceAvailable) {
@@ -4290,26 +4300,21 @@ class StateView {
         this.changes = new Map();
     }
     // TODO: allow to set multiple tags at once
-    add(obj, tag = DEFAULT_VIEW_TAG) {
+    add(obj, tag = DEFAULT_VIEW_TAG, checkIncludeParent = true) {
         if (!obj[$changes]) {
             console.warn("StateView#add(), invalid object:", obj);
             return this;
         }
         // FIXME: ArraySchema/MapSchema does not have metadata
         const metadata = obj.constructor[Symbol.metadata];
-        let changeTree = obj[$changes];
+        const changeTree = obj[$changes];
         this.items.add(changeTree);
-        // 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[metadata[index]].tag !== tag) {
-                return;
-            }
-            this.add(change.ref, tag);
-        });
-        // add parent ChangeTree's, if they are invisible to this view
-        // TODO: REFACTOR addParent()
-        this.addParent(changeTree, tag);
+        // add parent ChangeTree's
+        // - if it was invisible to this view
+        // - if it were previously filtered out
+        if (checkIncludeParent && changeTree.parent) {
+            this.addParent(changeTree.parent[$changes], changeTree.parentIndex, tag);
+        }
         //
         // TODO: when adding an item of a MapSchema, the changes may not
         // be set (only the parent's changes are set)
@@ -4341,73 +4346,63 @@ class StateView {
             });
         }
         else {
-            // console.log("DEFAULT TAG", changeTree.allChanges);
-            // // add default tag properties
-            // metadata?.[-3]?.[DEFAULT_VIEW_TAG]?.forEach((index) => {
-            //     if (changeTree.getChange(index) !== OPERATION.DELETE) {
-            //         changes.set(index, OPERATION.ADD);
-            //     }
-            // });
-            const allChangesSet = (changeTree.isFiltered || changeTree.isPartiallyFiltered)
+            const isInvisible = this.invisible.has(changeTree);
+            const changeSet = (changeTree.isFiltered || changeTree.isPartiallyFiltered)
                 ? changeTree.allFilteredChanges
                 : changeTree.allChanges;
-            const it = allChangesSet.keys();
-            const isInvisible = this.invisible.has(changeTree);
-            for (const index of it) {
-                if ((isInvisible || metadata?.[metadata?.[index]].tag === tag) &&
-                    changeTree.getChange(index) !== exports.OPERATION.DELETE) {
-                    changes.set(index, exports.OPERATION.ADD);
+            changeSet.forEach((op, index) => {
+                const tagAtIndex = metadata?.[metadata?.[index]].tag;
+                if ((isInvisible || // if "invisible", include all
+                    tagAtIndex === undefined || // "all change" with no tag
+                    tagAtIndex === tag // tagged property
+                ) &&
+                    op !== exports.OPERATION.DELETE) {
+                    changes.set(index, op);
                 }
-            }
-        }
-        // TODO: avoid unnecessary iteration here
-        while (changeTree.parent &&
-            (changeTree = changeTree.parent[$changes]) &&
-            (changeTree.isFiltered || changeTree.isPartiallyFiltered)) {
-            this.items.add(changeTree);
+            });
         }
+        // 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[metadata[index]].tag !== tag) {
+                return;
+            }
+            this.add(change.ref, tag, false);
+        });
         return this;
     }
-    addParent(changeTree, tag) {
-        const parentRef = changeTree.parent;
-        if (!parentRef) {
-            return;
+    addParent(changeTree, parentIndex, tag) {
+        // view must have all "changeTree" parent tree
+        this.items.add(changeTree);
+        // add parent's parent
+        const parentChangeTree = changeTree.parent?.[$changes];
+        if (parentChangeTree && (parentChangeTree.isFiltered || parentChangeTree.isPartiallyFiltered)) {
+            this.addParent(parentChangeTree, changeTree.parentIndex, tag);
         }
-        const parentChangeTree = parentRef[$changes];
-        const parentIndex = changeTree.parentIndex;
-        if (!this.invisible.has(parentChangeTree)) {
-            // parent is already available, no need to add it!
+        // parent is already available, no need to add it!
+        if (!this.invisible.has(changeTree)) {
             return;
         }
-        this.addParent(parentChangeTree, tag);
         // add parent's tag properties
-        if (parentChangeTree.getChange(parentIndex) !== exports.OPERATION.DELETE) {
-            let parentChanges = this.changes.get(parentChangeTree);
-            if (parentChanges === undefined) {
-                parentChanges = new Map();
-                this.changes.set(parentChangeTree, parentChanges);
+        if (changeTree.getChange(parentIndex) !== exports.OPERATION.DELETE) {
+            let changes = this.changes.get(changeTree);
+            if (changes === undefined) {
+                changes = new Map();
+                this.changes.set(changeTree, changes);
             }
-            // console.log("add parent change", {
-            //     parentIndex,
-            //     parentChanges,
-            //     parentChange: (
-            //         parentChangeTree.getChange(parentIndex) &&
-            //         OPERATION[parentChangeTree.getChange(parentIndex)]
-            //     ),
-            // })
             if (!this.tags) {
                 this.tags = new WeakMap();
             }
             let tags;
-            if (!this.tags.has(parentChangeTree)) {
+            if (!this.tags.has(changeTree)) {
                 tags = new Set();
-                this.tags.set(parentChangeTree, tags);
+                this.tags.set(changeTree, tags);
             }
             else {
-                tags = this.tags.get(parentChangeTree);
+                tags = this.tags.get(changeTree);
             }
             tags.add(tag);
-            parentChanges.set(parentIndex, exports.OPERATION.ADD);
+            changes.set(parentIndex, exports.OPERATION.ADD);
         }
     }
     remove(obj, tag = DEFAULT_VIEW_TAG) {