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

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@colyseus/schema",
-  "version": "3.0.0-alpha.19",
+  "version": "3.0.0-alpha.22",
   "description": "Binary state serializer with delta encoding for games",
   "bin": {
     "schema-codegen": "./bin/schema-codegen"
   },
   "scripts": {
-    "build": "tsc && rollup -c rollup.config.js",
+    "build": "tsc && rollup -c rollup.config.mjs",
     "watch": "tsc -w",
     "test": "mocha --require ts-node/register test/*.test.ts test/**/*.test.ts",
     "coverage": "nyc mocha --require ts-node/register --require source-map-support/register --recursive test/**Test.ts",
@@ -73,13 +73,13 @@
     "nanoid": "^3.1.10",
     "nyc": "^14.1.1",
     "rimraf": "^3.0.0",
-    "rollup": "^2.40.0",
+    "rollup": "^4.18.0",
     "sinon": "^7.2.2",
     "source-map-support": "^0.5.13",
     "ts-node": "^10.9.2",
     "tslib": "^2.1.0",
-    "tsx": "^4.15.7",
-    "typescript": "^5.3.3"
+    "tsx": "^3.13.0",
+    "typescript": "^5.4.5"
   },
   "nyc": {
     "extension": [

package/src/Metadata.ts

@@ -120,10 +120,48 @@ export const Metadata = {
     init(klass: any) {
         //
         // 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: any, parentMetadata?: any) {
+        let metadata: 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: any) {

package/src/Reflection.ts

@@ -106,62 +106,72 @@ export class Reflection extends Schema {
         const reflectionDecoder = new Decoder(reflection);
         reflectionDecoder.decode(bytes, it);
 
-        const context = new TypeContext();
+        const typeContext = new TypeContext();
 
-        const schemaTypes = reflection.types.reduce((types, reflectionType) => {
-            const parentKlass: typeof Schema = types[reflectionType.extendsId] || Schema;
-            const schema: typeof Schema = class _ extends parentKlass {};
+        // 1st pass, initialize metadata + inheritance
+        reflection.types.forEach((reflectionType) => {
+            const parentClass: typeof Schema = typeContext.get(reflectionType.extendsId) ?? Schema;
+            const schema: typeof 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: PrimitiveType = 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] as PrimitiveType; // 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 } as DefinitionType);
                     }
 
                 } else {
-                    // type(field.type as PrimitiveType)(schemaType.prototype, field.name);
                     Metadata.addField(metadata, fieldIndex, field.name, field.type as PrimitiveType);
                 }
             });
         });
 
-        return new (schemaTypes[0])();
+        // @ts-ignore
+        return new (typeContext.get(0))();
     }
 }

package/src/annotations.ts

@@ -330,6 +330,8 @@ export function view<T> (tag: number = DEFAULT_VIEW_TAG) {
 
         const parentClass = Object.getPrototypeOf(constructor);
         const parentMetadata = parentClass[Symbol.metadata];
+
+        // TODO: use Metadata.initialize()
         const metadata: Metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
 
         if (!metadata[fieldName]) {
@@ -356,6 +358,8 @@ export function unreliable<T> (target: T, field: string) {
 
     const parentClass = Object.getPrototypeOf(constructor);
     const parentMetadata = parentClass[Symbol.metadata];
+
+    // TODO: use Metadata.initialize()
     const metadata: Metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
 
     if (!metadata[field]) {
@@ -389,8 +393,8 @@ export function type (
         TypeContext.register(constructor);
 
         const parentClass = Object.getPrototypeOf(constructor);
-        const parentMetadata = parentClass[Symbol.metadata];
-        const metadata: 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: number;
 

package/src/encoder/Encoder.ts

@@ -112,11 +112,11 @@ export class Encoder<T extends Schema = any> {
                 // 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],
+                //         });
                 //     }
                 // }
 

package/src/index.ts

@@ -4,6 +4,8 @@ export type { DataChange } from "./decoder/DecodeOperation";
 import { $track, $encoder, $decoder, $filter, $getByIndex, $deleteByIndex, $changes, $childType } from "./types/symbols";
 export { $track, $encoder, $decoder, $filter, $getByIndex, $deleteByIndex, $changes, $childType };
 
+export type { ToJSON } from "./types/HelperTypes";
+
 import { MapSchema } from "./types/custom/MapSchema"
 export { MapSchema };
 

package/src/types/custom/ArraySchema.ts

@@ -471,6 +471,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
      * @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<S extends V>(predicate: (value: V, index: number, array: V[]) => value is S, thisArg?: any): this is S[];
     every(callbackfn: (value: V, index: number, array: V[]) => unknown, thisArg?: any): boolean {
         return this.items.every(callbackfn, thisArg);
     }
@@ -690,7 +691,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
     //
     // ES2023
     //
-    with(index: number, value: V): V[] {
+    with(index: number, value: V): ArraySchema<V> {
         const copy = this.items.slice();
         copy[index] = value;
         return new ArraySchema(...copy);