@colyseus/schema 3.0.0-alpha.19 → 3.0.0-alpha.22

package/build/cjs/index.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 const SWITCH_TO_STRUCTURE = 255; // (decoding collides with DELETE_AND_ADD + fieldIndex = 63)
 const TYPE_ID = 213;
 /**
@@ -147,10 +145,41 @@ const Metadata = {
     init(klass) {
         //
         // Used only to initialize an empty Schema (Encoder#constructor)
+        // TODO: remove/refactor this...
         //
         const metadata = {};
         klass.constructor[Symbol.metadata] = metadata;
-        Object.defineProperty(metadata, -1, { value: 0, enumerable: false, configurable: true });
+        Object.defineProperty(metadata, -1, {
+            value: 0,
+            enumerable: false,
+            configurable: true,
+        });
+    },
+    initialize(constructor, parentMetadata) {
+        let metadata = constructor[Symbol.metadata] ?? Object.create(null);
+        // make sure inherited classes have their own metadata object.
+        if (constructor[Symbol.metadata] === parentMetadata) {
+            metadata = Object.create(null);
+            if (parentMetadata) {
+                // assign parent metadata to current
+                Object.assign(metadata, parentMetadata);
+                for (let i = 0; i <= parentMetadata[-1]; i++) {
+                    Object.defineProperty(metadata, i, {
+                        value: parentMetadata[i],
+                        enumerable: false,
+                        configurable: true,
+                    });
+                }
+                Object.defineProperty(metadata, -1, {
+                    value: parentMetadata[-1],
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                });
+            }
+        }
+        constructor[Symbol.metadata] = metadata;
+        return metadata;
     },
     isValidInstance(klass) {
         return (klass.constructor[Symbol.metadata] &&
@@ -797,23 +826,23 @@ function number$1(bytes, value, it) {
 
 var encode = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    utf8Length: utf8Length,
-    utf8Write: utf8Write,
-    int8: int8$1,
-    uint8: uint8$1,
+    boolean: boolean$1,
+    float32: float32$1,
+    float64: float64$1,
     int16: int16$1,
-    uint16: uint16$1,
     int32: int32$1,
-    uint32: uint32$1,
     int64: int64$1,
+    int8: int8$1,
+    number: number$1,
+    string: string$1,
+    uint16: uint16$1,
+    uint32: uint32$1,
     uint64: uint64$1,
-    float32: float32$1,
-    float64: float64$1,
+    uint8: uint8$1,
+    utf8Length: utf8Length,
+    utf8Write: utf8Write,
     writeFloat32: writeFloat32,
-    writeFloat64: writeFloat64,
-    boolean: boolean$1,
-    string: string$1,
-    number: number$1
+    writeFloat64: writeFloat64
 });
 
 class EncodeSchemaError extends Error {
@@ -1246,26 +1275,26 @@ function switchStructureCheck(bytes, it) {
 
 var decode = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    utf8Read: utf8Read,
-    int8: int8,
-    uint8: uint8,
-    int16: int16,
-    uint16: uint16,
-    int32: int32,
-    uint32: uint32,
+    arrayCheck: arrayCheck,
+    boolean: boolean,
     float32: float32,
     float64: float64,
+    int16: int16,
+    int32: int32,
     int64: int64,
-    uint64: uint64,
+    int8: int8,
+    number: number,
+    numberCheck: numberCheck,
     readFloat32: readFloat32,
     readFloat64: readFloat64,
-    boolean: boolean,
     string: string,
     stringCheck: stringCheck,
-    number: number,
-    numberCheck: numberCheck,
-    arrayCheck: arrayCheck,
-    switchStructureCheck: switchStructureCheck
+    switchStructureCheck: switchStructureCheck,
+    uint16: uint16,
+    uint32: uint32,
+    uint64: uint64,
+    uint8: uint8,
+    utf8Read: utf8Read
 });
 
 const DEFINITION_MISMATCH = -1;
@@ -1905,14 +1934,6 @@ class ArraySchema {
     lastIndexOf(searchElement, fromIndex = this.length - 1) {
         return this.items.lastIndexOf(searchElement, fromIndex);
     }
-    /**
-     * Determines whether all the members of an array satisfy the specified test.
-     * @param callbackfn A function that accepts up to three arguments. The every method calls
-     * the callbackfn function for each element in the array until the callbackfn returns a value
-     * which is coercible to the Boolean value false, or until the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
     every(callbackfn, thisArg) {
         return this.items.every(callbackfn, thisArg);
     }
@@ -2591,6 +2612,7 @@ function view(tag = DEFAULT_VIEW_TAG) {
         const constructor = target.constructor;
         const parentClass = Object.getPrototypeOf(constructor);
         const parentMetadata = parentClass[Symbol.metadata];
+        // TODO: use Metadata.initialize()
         const metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
         if (!metadata[fieldName]) {
             //
@@ -2615,8 +2637,8 @@ function type(type, options) {
         // for inheritance support
         TypeContext.register(constructor);
         const parentClass = Object.getPrototypeOf(constructor);
-        const parentMetadata = parentClass[Symbol.metadata];
-        const metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
+        const parentMetadata = parentClass && parentClass[Symbol.metadata];
+        const metadata = Metadata.initialize(constructor, parentMetadata);
         let fieldIndex;
         /**
          * skip if descriptor already exists for this field (`@deprecated()`)
@@ -3389,6 +3411,8 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
 
 function __decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -3474,11 +3498,11 @@ class Encoder {
                 // try { throw new Error(); } catch (e) {
                 //     // only print if not coming from Reflection.ts
                 //     if (!e.stack.includes("src/Reflection.ts")) {
-                //         // console.log("WILL ENCODE", {
-                //         //     ref: changeTree.ref.constructor.name,
-                //         //     fieldIndex,
-                //         //     operation: OPERATION[operation],
-                //         // });
+                //         console.log("WILL ENCODE", {
+                //             ref: changeTree.ref.constructor.name,
+                //             fieldIndex,
+                //             operation: OPERATION[operation],
+                //         });
                 //     }
                 // }
                 encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView);
@@ -3939,53 +3963,60 @@ class Reflection extends Schema {
         const reflection = new Reflection();
         const reflectionDecoder = new Decoder(reflection);
         reflectionDecoder.decode(bytes, it);
-        const context = new TypeContext();
-        const schemaTypes = reflection.types.reduce((types, reflectionType) => {
-            const parentKlass = types[reflectionType.extendsId] || Schema;
-            const schema = class _ extends parentKlass {
+        const typeContext = new TypeContext();
+        // 1st pass, initialize metadata + inheritance
+        reflection.types.forEach((reflectionType) => {
+            const parentClass = typeContext.get(reflectionType.extendsId) ?? Schema;
+            const schema = class _ extends parentClass {
             };
-            // const _metadata = Object.create(_classSuper[Symbol.metadata] ?? null);
-            const _metadata = parentKlass && parentKlass[Symbol.metadata] || Object.create(null);
-            Object.defineProperty(schema, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            const parentMetadata = parentClass[Symbol.metadata];
             // register for inheritance support
             TypeContext.register(schema);
-            const typeid = reflectionType.id;
-            types[typeid] = schema;
-            context.add(schema, typeid);
-            return types;
+            // for inheritance support
+            Metadata.initialize(schema, parentMetadata);
+            typeContext.add(schema, reflectionType.id);
         }, {});
+        // 2nd pass, set fields
         reflection.types.forEach((reflectionType) => {
-            const schemaType = schemaTypes[reflectionType.id];
+            const schemaType = typeContext.get(reflectionType.id);
             const metadata = schemaType[Symbol.metadata];
-            const parentKlass = reflection.types[reflectionType.extendsId];
-            const parentFieldIndex = parentKlass && parentKlass.fields.length || 0;
+            // FIXME: use metadata[-1] to get field count
+            const parentFieldIndex = 0;
+            // console.log("--------------------");
+            // // console.log("reflectionType", reflectionType.toJSON());
+            // console.log("reflectionType.fields", reflectionType.fields.toJSON());
+            // console.log("parentFieldIndex", parentFieldIndex);
+            //
+            // FIXME: set fields using parentKlass as well
+            // currently the fields are duplicated on inherited classes
+            //
+            // // const parentKlass = reflection.types[reflectionType.extendsId];
+            // // parentKlass.fields
             reflectionType.fields.forEach((field, i) => {
                 const fieldIndex = parentFieldIndex + i;
                 if (field.referencedType !== undefined) {
                     let fieldType = field.type;
-                    let refType = schemaTypes[field.referencedType];
+                    let refType = typeContext.get(field.referencedType);
                     // map or array of primitive type (-1)
                     if (!refType) {
                         const typeInfo = field.type.split(":");
                         fieldType = typeInfo[0];
-                        refType = typeInfo[1];
+                        refType = typeInfo[1]; // string
                     }
                     if (fieldType === "ref") {
-                        // type(refType)(schemaType.prototype, field.name);
                         Metadata.addField(metadata, fieldIndex, field.name, refType);
                     }
                     else {
-                        // type({ [fieldType]: refType } as DefinitionType)(schemaType.prototype, field.name);
                         Metadata.addField(metadata, fieldIndex, field.name, { [fieldType]: refType });
                     }
                 }
                 else {
-                    // type(field.type as PrimitiveType)(schemaType.prototype, field.name);
                     Metadata.addField(metadata, fieldIndex, field.name, field.type);
                 }
             });
         });
-        return new (schemaTypes[0])();
+        // @ts-ignore
+        return new (typeContext.get(0))();
     }
 }
 __decorate([