@colyseus/schema 3.0.0-alpha.35 → 3.0.0-alpha.37

package/build/cjs/index.js

@@ -73,6 +73,102 @@ function getType(identifier) {
     return registeredTypes[identifier];
 }
 
+class TypeContext {
+    /**
+     * For inheritance support
+     * Keeps track of which classes extends which. (parent -> children)
+     */
+    static { this.inheritedTypes = new Map(); }
+    static register(target) {
+        const parent = Object.getPrototypeOf(target);
+        if (parent !== Schema) {
+            let inherits = TypeContext.inheritedTypes.get(parent);
+            if (!inherits) {
+                inherits = new Set();
+                TypeContext.inheritedTypes.set(parent, inherits);
+            }
+            inherits.add(target);
+        }
+    }
+    constructor(rootClass) {
+        this.types = {};
+        this.schemas = new Map();
+        this.hasFilters = false;
+        this.parentFiltered = {};
+        if (rootClass) {
+            this.discoverTypes(rootClass);
+        }
+    }
+    has(schema) {
+        return this.schemas.has(schema);
+    }
+    get(typeid) {
+        return this.types[typeid];
+    }
+    add(schema, typeid = this.schemas.size) {
+        // skip if already registered
+        if (this.schemas.has(schema)) {
+            return false;
+        }
+        this.types[typeid] = schema;
+        //
+        // Workaround to allow using an empty Schema (with no `@type()` fields)
+        //
+        if (schema[Symbol.metadata] === undefined) {
+            Metadata.init(schema);
+        }
+        this.schemas.set(schema, typeid);
+        return true;
+    }
+    getTypeId(klass) {
+        return this.schemas.get(klass);
+    }
+    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, parentIndex, parentFieldViewTag);
+        });
+        const metadata = (klass[Symbol.metadata] ??= {});
+        // if any schema/field has filters, mark "context" as having filters.
+        if (metadata[$viewFieldIndexes]) {
+            this.hasFilters = true;
+        }
+        if (parentFieldViewTag !== undefined) {
+            this.parentFiltered[`${this.schemas.get(klass)}-${parentIndex}`] = true;
+        }
+        for (const fieldIndex in metadata) {
+            const index = fieldIndex;
+            const fieldType = metadata[index].type;
+            const viewTag = metadata[index].tag;
+            if (typeof (fieldType) === "string") {
+                continue;
+            }
+            if (Array.isArray(fieldType)) {
+                const type = fieldType[0];
+                // skip primitive types
+                if (type === "string") {
+                    continue;
+                }
+                this.discoverTypes(type, index, viewTag);
+            }
+            else if (typeof (fieldType) === "function") {
+                this.discoverTypes(fieldType, viewTag);
+            }
+            else {
+                const type = Object.values(fieldType)[0];
+                // skip primitive types
+                if (typeof (type) === "string") {
+                    continue;
+                }
+                this.discoverTypes(type, index, viewTag);
+            }
+        }
+    }
+}
+
 const Metadata = {
     addField(metadata, index, name, type, descriptor) {
         if (index > 64) {
@@ -157,17 +253,42 @@ const Metadata = {
         metadata[$fieldIndexesByViewTag][tag].push(index);
     },
     setFields(target, fields) {
-        const metadata = (target.prototype.constructor[Symbol.metadata] ??= {});
-        let index = 0;
+        // for inheritance support
+        const constructor = target.prototype.constructor;
+        TypeContext.register(constructor);
+        const parentClass = Object.getPrototypeOf(constructor);
+        const parentMetadata = parentClass && parentClass[Symbol.metadata];
+        const metadata = Metadata.initialize(constructor, parentMetadata);
+        // Use Schema's methods if not defined in the class
+        if (!constructor[$track]) {
+            constructor[$track] = Schema[$track];
+        }
+        if (!constructor[$encoder]) {
+            constructor[$encoder] = Schema[$encoder];
+        }
+        if (!constructor[$decoder]) {
+            constructor[$decoder] = Schema[$decoder];
+        }
+        if (!constructor.prototype.toJSON) {
+            constructor.prototype.toJSON = Schema.prototype.toJSON;
+        }
+        //
+        // detect index for this field, considering inheritance
+        //
+        let fieldIndex = metadata[$numFields] // current structure already has fields defined
+            ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
+            ?? -1; // no fields defined
+        fieldIndex++;
         for (const field in fields) {
             const type = fields[field];
             // FIXME: this code is duplicated from @type() annotation
             const complexTypeKlass = (Array.isArray(type))
                 ? getType("array")
                 : (typeof (Object.keys(type)[0]) === "string") && getType(Object.keys(type)[0]);
-            Metadata.addField(metadata, index, field, type, getPropertyDescriptor(`_${field}`, index, type, complexTypeKlass));
-            index++;
+            Metadata.addField(metadata, fieldIndex, field, type, getPropertyDescriptor(`_${field}`, fieldIndex, type, complexTypeKlass));
+            fieldIndex++;
         }
+        return target;
     },
     isDeprecated(metadata, field) {
         return metadata[field].deprecated === true;
@@ -2475,102 +2596,6 @@ class MapSchema {
 }
 registerType("map", { constructor: MapSchema });
 
-class TypeContext {
-    /**
-     * For inheritance support
-     * Keeps track of which classes extends which. (parent -> children)
-     */
-    static { this.inheritedTypes = new Map(); }
-    static register(target) {
-        const parent = Object.getPrototypeOf(target);
-        if (parent !== Schema) {
-            let inherits = TypeContext.inheritedTypes.get(parent);
-            if (!inherits) {
-                inherits = new Set();
-                TypeContext.inheritedTypes.set(parent, inherits);
-            }
-            inherits.add(target);
-        }
-    }
-    constructor(rootClass) {
-        this.types = {};
-        this.schemas = new Map();
-        this.hasFilters = false;
-        this.parentFiltered = {};
-        if (rootClass) {
-            this.discoverTypes(rootClass);
-        }
-    }
-    has(schema) {
-        return this.schemas.has(schema);
-    }
-    get(typeid) {
-        return this.types[typeid];
-    }
-    add(schema, typeid = this.schemas.size) {
-        // skip if already registered
-        if (this.schemas.has(schema)) {
-            return false;
-        }
-        this.types[typeid] = schema;
-        //
-        // Workaround to allow using an empty Schema (with no `@type()` fields)
-        //
-        if (schema[Symbol.metadata] === undefined) {
-            Metadata.init(schema);
-        }
-        this.schemas.set(schema, typeid);
-        return true;
-    }
-    getTypeId(klass) {
-        return this.schemas.get(klass);
-    }
-    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, parentIndex, parentFieldViewTag);
-        });
-        const metadata = (klass[Symbol.metadata] ??= {});
-        // if any schema/field has filters, mark "context" as having filters.
-        if (metadata[$viewFieldIndexes]) {
-            this.hasFilters = true;
-        }
-        if (parentFieldViewTag !== undefined) {
-            this.parentFiltered[`${this.schemas.get(klass)}-${parentIndex}`] = true;
-        }
-        for (const fieldIndex in metadata) {
-            const index = fieldIndex;
-            const fieldType = metadata[index].type;
-            const viewTag = metadata[index].tag;
-            if (typeof (fieldType) === "string") {
-                continue;
-            }
-            if (Array.isArray(fieldType)) {
-                const type = fieldType[0];
-                // skip primitive types
-                if (type === "string") {
-                    continue;
-                }
-                this.discoverTypes(type, index, viewTag);
-            }
-            else if (typeof (fieldType) === "function") {
-                this.discoverTypes(fieldType, viewTag);
-            }
-            else {
-                const type = Object.values(fieldType)[0];
-                // skip primitive types
-                if (typeof (type) === "string") {
-                    continue;
-                }
-                this.discoverTypes(type, index, viewTag);
-            }
-        }
-    }
-}
-
 const DEFAULT_VIEW_TAG = -1;
 /**
  * [See documentation](https://docs.colyseus.io/state/schema/)
@@ -3868,11 +3893,19 @@ class Encoder {
     tryEncodeTypeId(bytes, baseType, targetType, it) {
         const baseTypeId = this.context.getTypeId(baseType);
         const targetTypeId = this.context.getTypeId(targetType);
+        if (targetTypeId === undefined) {
+            console.warn(`@colyseus/schema WARNING: Class "${targetType.name}" is not registered on TypeRegistry - Please either tag the class with @entity or define a @type() field.`);
+            return;
+        }
         if (baseTypeId !== targetTypeId) {
             bytes[it.offset++] = TYPE_ID & 255;
             number$1(bytes, targetTypeId, it);
         }
     }
+    get hasChanges() {
+        return (this.root.changes.length > 0 ||
+            this.root.filteredChanges.length > 0);
+    }
 }
 
 class DecodingWarning extends Error {
@@ -4137,10 +4170,16 @@ class Reflection extends Schema {
         super(...arguments);
         this.types = new ArraySchema();
     }
-    static encode(instance, context, it = { offset: 0 }) {
-        context ??= new TypeContext(instance.constructor);
+    /**
+     * Encodes the TypeContext of an Encoder into a buffer.
+     *
+     * @param context TypeContext instance
+     * @param it
+     * @returns
+     */
+    static encode(context, it = { offset: 0 }) {
         const reflection = new Reflection();
-        const encoder = new Encoder(reflection);
+        const reflectionEncoder = new Encoder(reflection);
         const buildType = (currentType, metadata) => {
             for (const fieldIndex in metadata) {
                 const index = Number(fieldIndex);
@@ -4194,9 +4233,16 @@ class Reflection extends Schema {
             }
             buildType(type, klass[Symbol.metadata]);
         }
-        const buf = encoder.encodeAll(it);
+        const buf = reflectionEncoder.encodeAll(it);
         return Buffer.from(buf, 0, it.offset);
     }
+    /**
+     * Decodes the TypeContext from a buffer into a Decoder instance.
+     *
+     * @param bytes Reflection.encode() output
+     * @param it
+     * @returns Decoder instance
+     */
     static decode(bytes, it) {
         const reflection = new Reflection();
         const reflectionDecoder = new Decoder(reflection);
@@ -4242,8 +4288,8 @@ class Reflection extends Schema {
                 }
             });
         });
-        // @ts-ignore
-        return new (typeContext.get(0))();
+        const state = new (typeContext.get(0))();
+        return new Decoder(state, typeContext);
     }
 }
 __decorate([