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

package/build/esm/index.mjs

@@ -113,7 +113,7 @@ class TypeContext {
         // Workaround to allow using an empty Schema (with no `@type()` fields)
         //
         if (schema[Symbol.metadata] === undefined) {
-            Metadata.init(schema);
+            Metadata.initialize(schema);
         }
         this.schemas.set(schema, typeid);
         return true;
@@ -129,6 +129,14 @@ class TypeContext {
         TypeContext.inheritedTypes.get(klass)?.forEach((child) => {
             this.discoverTypes(child, parentIndex, parentFieldViewTag);
         });
+        // add parent classes
+        let parent = klass;
+        while ((parent = Object.getPrototypeOf(parent)) &&
+            parent !== Schema && // stop at root (Schema)
+            parent !== Function.prototype // stop at root (non-Schema)
+        ) {
+            this.discoverTypes(parent);
+        }
         const metadata = (klass[Symbol.metadata] ??= {});
         // if any schema/field has filters, mark "context" as having filters.
         if (metadata[$viewFieldIndexes]) {
@@ -167,6 +175,13 @@ class TypeContext {
     }
 }
 
+function getNormalizedType(type) {
+    return (Array.isArray(type))
+        ? { array: type[0] }
+        : (typeof (type['type']) !== "undefined")
+            ? type['type']
+            : type;
+}
 const Metadata = {
     addField(metadata, index, name, type, descriptor) {
         if (index > 64) {
@@ -174,14 +189,16 @@ const Metadata = {
         }
         metadata[index] = Object.assign(metadata[index] || {}, // avoid overwriting previous field metadata (@owned / @deprecated)
         {
-            type: (Array.isArray(type))
-                ? { array: type[0] }
-                : type,
+            type: getNormalizedType(type),
             index,
             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 +273,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];
@@ -279,11 +296,15 @@ const Metadata = {
         fieldIndex++;
         for (const field in fields) {
             const type = fields[field];
+            const normalizedType = getNormalizedType(type);
             // 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, fieldIndex, field, type, getPropertyDescriptor(`_${field}`, fieldIndex, type, complexTypeKlass));
+            const childType = (complexTypeKlass)
+                ? Object.values(type)[0]
+                : normalizedType;
+            Metadata.addField(metadata, fieldIndex, field, type, getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass));
             fieldIndex++;
         }
         return target;
@@ -304,24 +325,52 @@ 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);
+                // $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,
@@ -1096,7 +1145,6 @@ const encodeSchemaOperation = function (encoder, bytes, changeTree, index, opera
         return;
     }
     const ref = changeTree.ref;
-    // const metadata: Metadata = ref.constructor[Symbol.metadata];
     const field = metadata[index];
     // TODO: inline this function call small performance gain
     encodeValue(encoder, bytes, metadata[index].type, ref[field.name], operation, it);
@@ -1171,7 +1219,8 @@ const encodeArray = function (encoder, bytes, changeTree, field, operation, it,
     // encode operation
     bytes[it.offset++] = operation & 255;
     // custom operations
-    if (operation === OPERATION.CLEAR) {
+    if (operation === OPERATION.CLEAR ||
+        operation === OPERATION.REVERSE) {
         return;
     }
     // encode index
@@ -1649,6 +1698,10 @@ const decodeArray = function (decoder, bytes, it, ref, allChanges) {
         ref.clear();
         return;
     }
+    else if (operation === OPERATION.REVERSE) {
+        ref.reverse();
+        return;
+    }
     else if (operation === OPERATION.DELETE_BY_REFID) {
         // TODO: refactor here, try to follow same flow as below
         const refId = number(bytes, it);
@@ -2768,13 +2821,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;
@@ -2924,6 +2977,37 @@ function defineTypes(target, fields, options) {
     }
     return target;
 }
+function schema(fields, name, inherits = Schema) {
+    const defaultValues = {};
+    const viewTagFields = {};
+    for (let fieldName in fields) {
+        const field = fields[fieldName];
+        if (typeof (field) === "object") {
+            if (field['default'] !== undefined) {
+                defaultValues[fieldName] = field['default'];
+            }
+            if (field['view'] !== undefined) {
+                viewTagFields[fieldName] = (typeof (field['view']) === "boolean")
+                    ? DEFAULT_VIEW_TAG
+                    : field['view'];
+            }
+        }
+    }
+    const klass = Metadata.setFields(class extends inherits {
+        constructor(...args) {
+            args[0] = Object.assign({}, defaultValues, args[0]);
+            super(...args);
+        }
+    }, fields);
+    for (let fieldName in viewTagFields) {
+        view(viewTagFields[fieldName])(klass.prototype, fieldName);
+    }
+    if (name) {
+        Object.defineProperty(klass, "name", { value: name });
+    }
+    klass.extends = (fields, name) => schema(fields, name, klass);
+    return klass;
+}
 
 function getIndent(level) {
     return (new Array(level).fill(0)).map((_, i) => (i === level - 1) ? `└─ ` : `   `).join("");
@@ -4171,13 +4255,20 @@ class Reflection extends Schema {
     /**
      * Encodes the TypeContext of an Encoder into a buffer.
      *
-     * @param context TypeContext instance
+     * @param encoder Encoder instance
      * @param it
      * @returns
      */
-    static encode(context, it = { offset: 0 }) {
+    static encode(encoder, it = { offset: 0 }) {
+        const context = encoder.context;
         const reflection = new Reflection();
         const reflectionEncoder = new Encoder(reflection);
+        // rootType is usually the first schema passed to the Encoder
+        // (unless it inherits from another schema)
+        const rootType = context.schemas.get(encoder.state.constructor);
+        if (rootType > 0) {
+            reflection.rootType = rootType;
+        }
         const buildType = (currentType, metadata) => {
             for (const fieldIndex in metadata) {
                 const index = Number(fieldIndex);
@@ -4251,18 +4342,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) {
@@ -4285,14 +4372,36 @@ 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))();
+        const state = new (typeContext.get(reflection.rootType || 0))();
         return new Decoder(state, typeContext);
     }
 }
 __decorate([
     type([ReflectionType])
 ], Reflection.prototype, "types", void 0);
+__decorate([
+    type("number")
+], Reflection.prototype, "rootType", void 0);
 
 function getDecoderStateCallbacks(decoder) {
     const $root = decoder.root;
@@ -4731,5 +4840,5 @@ registerType("array", { constructor: ArraySchema });
 registerType("set", { constructor: SetSchema });
 registerType("collection", { constructor: CollectionSchema, });
 
-export { $changes, $childType, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex, $track, ArraySchema, ChangeTree, CollectionSchema, Decoder, Encoder, MapSchema, Metadata, OPERATION, Reflection, ReflectionField, ReflectionType, Schema, SetSchema, StateView, TypeContext, decode, decodeKeyValueOperation, decodeSchemaOperation, defineTypes, deprecated, dumpChanges, encode, encodeArray as encodeKeyValueOperation, encodeSchemaOperation, getDecoderStateCallbacks, getRawChangesCallback, registerType, type, view };
+export { $changes, $childType, $decoder, $deleteByIndex, $encoder, $filter, $getByIndex, $track, ArraySchema, ChangeTree, CollectionSchema, Decoder, Encoder, MapSchema, Metadata, OPERATION, Reflection, ReflectionField, ReflectionType, Schema, SetSchema, StateView, TypeContext, decode, decodeKeyValueOperation, decodeSchemaOperation, defineTypes, deprecated, dumpChanges, encode, encodeArray as encodeKeyValueOperation, encodeSchemaOperation, getDecoderStateCallbacks, getRawChangesCallback, registerType, schema, type, view };
 //# sourceMappingURL=index.mjs.map