@colyseus/schema 3.0.0-alpha.36 → 3.0.0-alpha.38

package/build/esm/index.mjs

@@ -181,7 +181,11 @@ const Metadata = {
             name,
         });
         // create "descriptors" map
-        metadata[$descriptors] ??= {};
+        Object.defineProperty(metadata, $descriptors, {
+            value: metadata[$descriptors] || {},
+            enumerable: false,
+            configurable: true,
+        });
         if (descriptor) {
             // for encoder
             metadata[$descriptors][name] = descriptor;
@@ -256,7 +260,7 @@ const Metadata = {
         TypeContext.register(constructor);
         const parentClass = Object.getPrototypeOf(constructor);
         const parentMetadata = parentClass && parentClass[Symbol.metadata];
-        const metadata = Metadata.initialize(constructor, parentMetadata);
+        const metadata = Metadata.initialize(constructor);
         // Use Schema's methods if not defined in the class
         if (!constructor[$track]) {
             constructor[$track] = Schema[$track];
@@ -304,24 +308,62 @@ const Metadata = {
             configurable: true,
         });
     },
-    initialize(constructor, parentMetadata) {
+    initialize(constructor) {
+        const parentClass = Object.getPrototypeOf(constructor);
+        const parentMetadata = parentClass[Symbol.metadata];
         let metadata = constructor[Symbol.metadata] ?? Object.create(null);
         // make sure inherited classes have their own metadata object.
-        if (constructor[Symbol.metadata] === parentMetadata) {
+        if (parentClass !== Schema && metadata === parentMetadata) {
             metadata = Object.create(null);
             if (parentMetadata) {
+                //
                 // assign parent metadata to current
-                Object.assign(metadata, parentMetadata);
-                for (let i = 0; i <= parentMetadata[$numFields]; i++) {
-                    const fieldName = parentMetadata[i].name;
-                    Object.defineProperty(metadata, fieldName, {
-                        value: parentMetadata[fieldName],
+                //
+                Object.setPrototypeOf(metadata, parentMetadata);
+                // Object.keys(parentMetadata).forEach((fieldIndex) => {
+                //     const index = Number(fieldIndex);
+                //     const field = parentMetadata[index];
+                //     metadata[index] = field;
+                //     // Object.defineProperty(metadata, field.name, {
+                //     //     value: index,
+                //     //     enumerable: false,
+                //     //     configurable: true,
+                //     // });
+                // });
+                // $numFields
+                Object.defineProperty(metadata, $numFields, {
+                    value: parentMetadata[$numFields],
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                });
+                // $viewFieldIndexes / $fieldIndexesByViewTag
+                if (parentMetadata[$viewFieldIndexes] !== undefined) {
+                    Object.defineProperty(metadata, $viewFieldIndexes, {
+                        value: [...parentMetadata[$viewFieldIndexes]],
                         enumerable: false,
                         configurable: true,
+                        writable: true,
+                    });
+                    Object.defineProperty(metadata, $fieldIndexesByViewTag, {
+                        value: { ...parentMetadata[$fieldIndexesByViewTag] },
+                        enumerable: false,
+                        configurable: true,
+                        writable: true,
                     });
                 }
-                Object.defineProperty(metadata, $numFields, {
-                    value: parentMetadata[$numFields],
+                // $refTypeFieldIndexes
+                if (parentMetadata[$refTypeFieldIndexes] !== undefined) {
+                    Object.defineProperty(metadata, $refTypeFieldIndexes, {
+                        value: [...parentMetadata[$refTypeFieldIndexes]],
+                        enumerable: false,
+                        configurable: true,
+                        writable: true,
+                    });
+                }
+                // $descriptors
+                Object.defineProperty(metadata, $descriptors, {
+                    value: { ...parentMetadata[$descriptors] },
                     enumerable: false,
                     configurable: true,
                     writable: true,
@@ -2768,13 +2810,13 @@ function type(type, options) {
         // for inheritance support
         TypeContext.register(constructor);
         const parentClass = Object.getPrototypeOf(constructor);
-        const parentMetadata = parentClass && parentClass[Symbol.metadata];
-        const metadata = Metadata.initialize(constructor, parentMetadata);
+        const parentMetadata = parentClass[Symbol.metadata];
+        const metadata = Metadata.initialize(constructor);
         let fieldIndex = metadata[field];
         /**
          * skip if descriptor already exists for this field (`@deprecated()`)
          */
-        if (metadata[fieldIndex]) {
+        if (metadata[fieldIndex] !== undefined) {
             if (metadata[fieldIndex].deprecated) {
                 // do not create accessors for deprecated properties.
                 return;
@@ -3900,6 +3942,10 @@ class Encoder {
             number$1(bytes, targetTypeId, it);
         }
     }
+    get hasChanges() {
+        return (this.root.changes.length > 0 ||
+            this.root.filteredChanges.length > 0);
+    }
 }
 
 class DecodingWarning extends Error {
@@ -4247,18 +4293,14 @@ class Reflection extends Schema {
             const parentClass = typeContext.get(reflectionType.extendsId) ?? Schema;
             const schema = class _ extends parentClass {
             };
-            const parentMetadata = parentClass[Symbol.metadata];
             // register for inheritance support
             TypeContext.register(schema);
-            // for inheritance support
-            Metadata.initialize(schema, parentMetadata);
+            // // for inheritance support
+            // Metadata.initialize(schema);
             typeContext.add(schema, reflectionType.id);
         }, {});
-        // 2nd pass, set fields
-        reflection.types.forEach((reflectionType) => {
-            const schemaType = typeContext.get(reflectionType.id);
-            const metadata = schemaType[Symbol.metadata];
-            const parentFieldIndex = 0;
+        // define fields
+        const addFields = (metadata, reflectionType, parentFieldIndex) => {
             reflectionType.fields.forEach((field, i) => {
                 const fieldIndex = parentFieldIndex + i;
                 if (field.referencedType !== undefined) {
@@ -4281,6 +4323,25 @@ class Reflection extends Schema {
                     Metadata.addField(metadata, fieldIndex, field.name, field.type);
                 }
             });
+        };
+        // 2nd pass, set fields
+        reflection.types.forEach((reflectionType) => {
+            const schema = typeContext.get(reflectionType.id);
+            // for inheritance support
+            const metadata = Metadata.initialize(schema);
+            const inheritedTypes = [];
+            let parentType = reflectionType;
+            do {
+                inheritedTypes.push(parentType);
+                parentType = reflection.types.find((t) => t.id === parentType.extendsId);
+            } while (parentType);
+            let parentFieldIndex = 0;
+            inheritedTypes.reverse().forEach((reflectionType) => {
+                // add fields from all inherited classes
+                // TODO: refactor this to avoid adding fields from parent classes
+                addFields(metadata, reflectionType, parentFieldIndex);
+                parentFieldIndex += reflectionType.fields.length;
+            });
         });
         const state = new (typeContext.get(0))();
         return new Decoder(state, typeContext);