@colyseus/schema 3.0.19 → 3.0.21

package/build/cjs/index.js

@@ -600,6 +600,7 @@ class TypeContext {
      * Keeps track of which classes extends which. (parent -> children)
      */
     static { this.inheritedTypes = new Map(); }
+    static { this.cachedContexts = new Map(); }
     static register(target) {
         const parent = Object.getPrototypeOf(target);
         if (parent !== Schema) {
@@ -611,17 +612,20 @@ class TypeContext {
             inherits.add(target);
         }
     }
+    static cache(rootClass) {
+        let context = TypeContext.cachedContexts.get(rootClass);
+        if (!context) {
+            context = new TypeContext(rootClass);
+            TypeContext.cachedContexts.set(rootClass, context);
+        }
+        return context;
+    }
     constructor(rootClass) {
         this.types = {};
         this.schemas = new Map();
         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);
         }
     }
@@ -3313,7 +3317,7 @@ class CollectionSchema {
     static [(_a$1 = $encoder, _b$1 = $decoder, $filter)](ref, index, view) {
         return (!view ||
             typeof (ref[$childType]) === "string" ||
-            view.items.has(ref[$getByIndex](index)[$changes]));
+            view.items.has((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes]));
     }
     static is(type) {
         return type['collection'] !== undefined;
@@ -3321,6 +3325,7 @@ class CollectionSchema {
     constructor(initialValues) {
         this.$items = new Map();
         this.$indexes = new Map();
+        this.deletedItems = {};
         this.$refId = 0;
         this[$changes] = new ChangeTree(this);
         this[$changes].indexes = {};
@@ -3370,7 +3375,7 @@ class CollectionSchema {
         if (index === undefined) {
             return false;
         }
-        this[$changes].delete(index);
+        this.deletedItems[index] = this[$changes].delete(index);
         this.$indexes.delete(index);
         return this.$items.delete(index);
     }
@@ -3415,6 +3420,9 @@ class CollectionSchema {
         this.$items.delete(key);
         this.$indexes.delete(index);
     }
+    [$onEncodeEnd]() {
+        this.deletedItems = {};
+    }
     toArray() {
         return Array.from(this.$items.values());
     }
@@ -3469,7 +3477,7 @@ class SetSchema {
     static [(_a = $encoder, _b = $decoder, $filter)](ref, index, view) {
         return (!view ||
             typeof (ref[$childType]) === "string" ||
-            view.items.has(ref[$getByIndex](index)[$changes]));
+            view.items.has((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes]));
     }
     static is(type) {
         return type['set'] !== undefined;
@@ -3477,6 +3485,7 @@ class SetSchema {
     constructor(initialValues) {
         this.$items = new Map();
         this.$indexes = new Map();
+        this.deletedItems = {};
         this.$refId = 0;
         this[$changes] = new ChangeTree(this);
         this[$changes].indexes = {};
@@ -3526,7 +3535,7 @@ class SetSchema {
         if (index === undefined) {
             return false;
         }
-        this[$changes].delete(index);
+        this.deletedItems[index] = this[$changes].delete(index);
         this.$indexes.delete(index);
         return this.$items.delete(index);
     }
@@ -3583,6 +3592,9 @@ class SetSchema {
         this.$items.delete(key);
         this.$indexes.delete(index);
     }
+    [$onEncodeEnd]() {
+        this.deletedItems = {};
+    }
     toArray() {
         return Array.from(this.$items.values());
     }
@@ -3759,10 +3771,12 @@ class Encoder {
     constructor(state) {
         this.sharedBuffer = Buffer.allocUnsafe(Encoder.BUFFER_SIZE);
         //
-        // TODO: cache and restore "Context" based on root schema
-        // (to avoid creating a new context for every new room)
+        // Use .cache() here to avoid re-creating a new context for every new room instance.
+        //
+        // We may need to make this optional in case of dynamically created
+        // schemas - which would lead to memory leaks
         //
-        this.context = new TypeContext(state.constructor);
+        this.context = TypeContext.cache(state.constructor);
         this.root = new Root(this.context);
         this.setState(state);
         // console.log(">>>>>>>>>>>>>>>> Encoder types");
@@ -3787,7 +3801,7 @@ class Encoder {
                     view.invisible.add(changeTree);
                     continue; // skip this change tree
                 }
-                else if (view.invisible.has(changeTree)) {
+                else {
                     view.invisible.delete(changeTree); // remove from invisible list
                 }
             }
@@ -4267,50 +4281,28 @@ class Reflection extends Schema {
         if (rootType > 0) {
             reflection.rootType = rootType;
         }
-        const buildType = (currentType, metadata) => {
-            for (const fieldIndex in metadata) {
-                const index = Number(fieldIndex);
-                const fieldName = metadata[index].name;
-                // skip fields from parent classes
-                if (!Object.prototype.hasOwnProperty.call(metadata, fieldName)) {
-                    continue;
-                }
-                const field = new ReflectionField();
-                field.name = fieldName;
-                let fieldType;
-                const type = metadata[index].type;
-                if (typeof (type) === "string") {
-                    fieldType = type;
+        const includedTypeIds = new Set();
+        const pendingReflectionTypes = {};
+        // add type to reflection in a way that respects inheritance
+        // (parent types should be added before their children)
+        const addType = (type) => {
+            if (type.extendsId === undefined || includedTypeIds.has(type.extendsId)) {
+                includedTypeIds.add(type.id);
+                reflection.types.push(type);
+                const deps = pendingReflectionTypes[type.id];
+                if (deps !== undefined) {
+                    delete pendingReflectionTypes[type.id];
+                    deps.forEach((childType) => addType(childType));
                 }
-                else {
-                    let childTypeSchema;
-                    //
-                    // TODO: refactor below.
-                    //
-                    if (Schema.is(type)) {
-                        fieldType = "ref";
-                        childTypeSchema = type;
-                    }
-                    else {
-                        fieldType = Object.keys(type)[0];
-                        if (typeof (type[fieldType]) === "string") {
-                            fieldType += ":" + type[fieldType]; // array:string
-                        }
-                        else {
-                            childTypeSchema = type[fieldType];
-                        }
-                    }
-                    field.referencedType = (childTypeSchema)
-                        ? context.getTypeId(childTypeSchema)
-                        : -1;
+            }
+            else {
+                if (pendingReflectionTypes[type.extendsId] === undefined) {
+                    pendingReflectionTypes[type.extendsId] = [];
                 }
-                field.type = fieldType;
-                currentType.fields.push(field);
+                pendingReflectionTypes[type.extendsId].push(type);
             }
-            reflection.types.push(currentType);
         };
-        for (let typeid in context.types) {
-            const klass = context.types[typeid];
+        context.schemas.forEach((typeid, klass) => {
             const type = new ReflectionType();
             type.id = Number(typeid);
             // support inheritance
@@ -4318,7 +4310,57 @@ class Reflection extends Schema {
             if (inheritFrom !== Schema) {
                 type.extendsId = context.schemas.get(inheritFrom);
             }
-            buildType(type, klass[Symbol.metadata]);
+            const metadata = klass[Symbol.metadata];
+            //
+            // FIXME: this is a workaround for inherited types without additional fields
+            // if metadata is the same reference as the parent class - it means the class has no own metadata
+            //
+            if (metadata !== inheritFrom[Symbol.metadata]) {
+                for (const fieldIndex in metadata) {
+                    const index = Number(fieldIndex);
+                    const fieldName = metadata[index].name;
+                    // skip fields from parent classes
+                    if (!Object.prototype.hasOwnProperty.call(metadata, fieldName)) {
+                        continue;
+                    }
+                    const reflectionField = new ReflectionField();
+                    reflectionField.name = fieldName;
+                    let fieldType;
+                    const field = metadata[index];
+                    if (typeof (field.type) === "string") {
+                        fieldType = field.type;
+                    }
+                    else {
+                        let childTypeSchema;
+                        //
+                        // TODO: refactor below.
+                        //
+                        if (Schema.is(field.type)) {
+                            fieldType = "ref";
+                            childTypeSchema = field.type;
+                        }
+                        else {
+                            fieldType = Object.keys(field.type)[0];
+                            if (typeof (field.type[fieldType]) === "string") {
+                                fieldType += ":" + field.type[fieldType]; // array:string
+                            }
+                            else {
+                                childTypeSchema = field.type[fieldType];
+                            }
+                        }
+                        reflectionField.referencedType = (childTypeSchema)
+                            ? context.getTypeId(childTypeSchema)
+                            : -1;
+                    }
+                    reflectionField.type = fieldType;
+                    type.fields.push(reflectionField);
+                }
+            }
+            addType(type);
+        });
+        // in case there are types that were not added due to inheritance
+        for (const typeid in pendingReflectionTypes) {
+            pendingReflectionTypes[typeid].forEach((type) => reflection.types.push(type));
         }
         const buf = reflectionEncoder.encodeAll(it);
         return Buffer.from(buf, 0, it.offset);
@@ -4743,10 +4785,11 @@ class StateView {
                 } // skip "undefined" indexes
                 const op = changeTree.indexedOperations[index] ?? exports.OPERATION.ADD;
                 const tagAtIndex = metadata?.[index].tag;
-                if ((isInvisible || // if "invisible", include all
-                    tagAtIndex === undefined || // "all change" with no tag
-                    tagAtIndex === tag // tagged property
-                ) &&
+                if (!changeTree.isNew && // new structures will be added as part of .encode() call, no need to force it to .encodeView()
+                    (isInvisible || // if "invisible", include all
+                        tagAtIndex === undefined || // "all change" with no tag
+                        tagAtIndex === tag // tagged property
+                    ) &&
                     op !== exports.OPERATION.DELETE) {
                     changes[index] = op;
                 }
@@ -4775,10 +4818,8 @@ class StateView {
             if (parentChangeTree && (parentChangeTree.filteredChanges !== undefined)) {
                 this.addParentOf(changeTree, tag);
             }
-            // parent is already available, no need to add it!
-            if (!this.invisible.has(changeTree)) {
-                return;
-            }
+            // // parent is already available, no need to add it!
+            // if (!this.invisible.has(changeTree)) { return; }
         }
         // add parent's tag properties
         if (changeTree.getChange(parentIndex) !== exports.OPERATION.DELETE) {