@colyseus/schema 3.0.76 → 4.0.0

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@colyseus/schema",
-  "version": "3.0.76",
+  "version": "4.0.0",
   "description": "Binary state serializer with delta encoding for games",
   "bin": {
     "schema-codegen": "bin/schema-codegen",
     "schema-debug": "bin/schema-debug"
   },
   "scripts": {
-    "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",
+    "build": "tsc -p tsconfig.build.json && rollup -c rollup.config.mjs",
+    "watch": "tsc -p tsconfig.build.json -w",
+    "test": "tsx --tsconfig tsconfig.test.json ./node_modules/.bin/mocha test/*.test.ts test/**/*.test.ts",
+    "coverage": "c8 npm run test",
     "generate-test-1": "bin/schema-codegen test-external/PrimitiveTypes.ts --namespace SchemaTest.PrimitiveTypes --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/PrimitiveTypes",
     "generate-test-2": "bin/schema-codegen test-external/ChildSchemaTypes.ts --namespace SchemaTest.ChildSchemaTypes --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/ChildSchemaTypes",
     "generate-test-3": "bin/schema-codegen test-external/ArraySchemaTypes.ts --namespace SchemaTest.ArraySchemaTypes --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/ArraySchemaTypes",
@@ -66,34 +66,30 @@
     "@types/rimraf": "^2.0.3",
     "@types/sinon": "^7.0.3",
     "benchmark": "^2.1.4",
+    "c8": "^10.1.2",
     "core-js": "^3.44.0",
     "flatbuffers": "^1.10.2",
     "fossil-delta": "^1.0.2",
     "glob": "^7.1.5",
     "mocha": "^10.2.0",
     "msgpackr": "^1.6.1",
-    "nanoid": "^3.1.10",
-    "nyc": "^14.1.1",
+    "nanoid": "^5.1.6",
     "rimraf": "^3.0.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": "^3.13.0",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
-  "nyc": {
-    "extension": [
-      ".ts"
-    ],
+  "c8": {
     "include": [
-      "src",
-      "test"
+      "src/**/*.ts"
     ],
     "reporter": [
       "html",
-      "lcov"
+      "lcov",
+      "text"
     ],
     "all": true
   }

package/src/Metadata.ts

@@ -294,11 +294,7 @@ export const Metadata = {
             }
         }
 
-        Object.defineProperty(constructor, Symbol.metadata, {
-            value: metadata,
-            writable: false,
-            configurable: true
-        });
+        constructor[Symbol.metadata] = metadata;
 
         return metadata;
     },

package/src/Reflection.ts

@@ -1,31 +1,15 @@
-import { type, PrimitiveType } from "./annotations";
+import { PrimitiveType, schema, SchemaType } from "./annotations";
 import { TypeContext } from "./types/TypeContext";
 import { Metadata } from "./Metadata";
-import { ArraySchema } from "./types/custom/ArraySchema";
 import { Iterator } from "./encoding/decode";
 import { Encoder } from "./encoder/Encoder";
 import { Decoder } from "./decoder/Decoder";
 import { Schema } from "./Schema";
 
 /**
- * Reflection
+ * Static methods available on Reflection
  */
-export class ReflectionField extends Schema {
-    @type("string") name: string;
-    @type("string") type: string;
-    @type("number") referencedType: number;
-}
-
-export class ReflectionType extends Schema {
-    @type("number") id: number;
-    @type("number") extendsId: number;
-    @type([ ReflectionField ]) fields = new ArraySchema<ReflectionField>();
-}
-
-export class Reflection extends Schema {
-    @type([ReflectionType]) types: ArraySchema<ReflectionType> = new ArraySchema<ReflectionType>();
-    @type("number") rootType: number;
-
+interface ReflectionStatic {
     /**
      * Encodes the TypeContext of an Encoder into a buffer.
      *
@@ -33,207 +17,234 @@ export class Reflection extends Schema {
      * @param it
      * @returns
      */
-    static encode(encoder: Encoder, it: Iterator = { offset: 0 }) {
-        const context = encoder.context;
+    encode: (encoder: Encoder, it?: Iterator) => Uint8Array;
 
-        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; }
+    /**
+     * Decodes the TypeContext from a buffer into a Decoder instance.
+     *
+     * @param bytes Reflection.encode() output
+     * @param it
+     * @returns Decoder instance
+     */
+    decode: <T extends Schema = Schema>(bytes: Uint8Array, it?: Iterator) => Decoder<T>;
+}
 
-        const includedTypeIds = new Set<number>();
-        const pendingReflectionTypes: { [typeid: number]: ReflectionType[] } = {};
+/**
+ * Reflection
+ */
+export const ReflectionField = schema({
+    name: "string",
+    type: "string",
+    referencedType: "number",
+})
+export type ReflectionField = SchemaType<typeof ReflectionField>;
+
+export const ReflectionType = schema({
+    id: "number",
+    extendsId: "number",
+    fields: [ ReflectionField ],
+})
+export type ReflectionType = SchemaType<typeof ReflectionType>;
+
+export const Reflection = schema({
+    types: [ ReflectionType ],
+    rootType: "number",
+}) as ReturnType<typeof schema<{
+    types: [typeof ReflectionType];
+    rootType: "number";
+}>> & ReflectionStatic;
+
+export type Reflection = SchemaType<typeof Reflection>;
+
+Reflection.encode = function (encoder: Encoder, it: Iterator = { 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 includedTypeIds = new Set<number>();
+    const pendingReflectionTypes: { [typeid: number]: ReflectionType[] } = {};
+
+    // add type to reflection in a way that respects inheritance
+    // (parent types should be added before their children)
+    const addType = (type: ReflectionType) => {
+        if (type.extendsId === undefined || includedTypeIds.has(type.extendsId)) {
+            includedTypeIds.add(type.id);
+
+            reflection.types.push(type);
+
+            const deps = pendingReflectionTypes[type.id];
+            if (deps !== undefined) {
+                delete pendingReflectionTypes[type.id];
+                deps.forEach((childType) => addType(childType));
+            }
+        } else {
+            if (pendingReflectionTypes[type.extendsId] === undefined) {
+                pendingReflectionTypes[type.extendsId] = [];
+            }
+            pendingReflectionTypes[type.extendsId].push(type);
+        }
+    };
 
-        // add type to reflection in a way that respects inheritance
-        // (parent types should be added before their children)
-        const addType = (type: ReflectionType) => {
-            if (type.extendsId === undefined || includedTypeIds.has(type.extendsId)) {
-                includedTypeIds.add(type.id);
+    context.schemas.forEach((typeid, klass) => {
+        const type = new ReflectionType();
+        type.id = Number(typeid);
 
-                reflection.types.push(type);
+        // support inheritance
+        const inheritFrom = Object.getPrototypeOf(klass);
+        if (inheritFrom !== Schema) {
+            type.extendsId = context.schemas.get(inheritFrom);
+        }
 
-                const deps = pendingReflectionTypes[type.id];
-                if (deps !== undefined) {
-                    delete pendingReflectionTypes[type.id];
-                    deps.forEach((childType) => addType(childType));
-                }
-            } else {
-                if (pendingReflectionTypes[type.extendsId] === undefined) {
-                    pendingReflectionTypes[type.extendsId] = [];
-                }
-                pendingReflectionTypes[type.extendsId].push(type);
-            }
-        };
+        const metadata = klass[Symbol.metadata];
 
-        context.schemas.forEach((typeid, klass) => {
-            const type = new ReflectionType();
-            type.id = Number(typeid);
+        //
+        // FIXME: this is a workaround for inherited types without additional fields
+        // if metadata is the same reference as the parent class - it means the class has no own metadata
+        //
+        if (metadata !== inheritFrom[Symbol.metadata]) {
+            for (const fieldIndex in metadata) {
+                const index = Number(fieldIndex);
+                const fieldName = metadata[index].name;
 
-            // support inheritance
-            const inheritFrom = Object.getPrototypeOf(klass);
-            if (inheritFrom !== Schema) {
-                type.extendsId = context.schemas.get(inheritFrom);
-            }
+                // skip fields from parent classes
+                if (!Object.prototype.hasOwnProperty.call(metadata, fieldName)) {
+                    continue;
+                }
 
-            const metadata = klass[Symbol.metadata];
+                const reflectionField = new ReflectionField();
+                reflectionField.name = fieldName;
 
-            //
-            // FIXME: this is a workaround for inherited types without additional fields
-            // if metadata is the same reference as the parent class - it means the class has no own metadata
-            //
-            if (metadata !== inheritFrom[Symbol.metadata]) {
-                for (const fieldIndex in metadata) {
-                    const index = Number(fieldIndex);
-                    const fieldName = metadata[index].name;
+                let fieldType: string;
 
-                    // skip fields from parent classes
-                    if (!Object.prototype.hasOwnProperty.call(metadata, fieldName)) {
-                        continue;
-                    }
+                const field = metadata[index];
 
-                    const reflectionField = new ReflectionField();
-                    reflectionField.name = fieldName;
+                if (typeof (field.type) === "string") {
+                    fieldType = field.type;
 
-                    let fieldType: string;
-
-                    const field = metadata[index];
+                } else {
+                    let childTypeSchema: typeof Schema;
 
-                    if (typeof (field.type) === "string") {
-                        fieldType = field.type;
+                    //
+                    // TODO: refactor below.
+                    //
+                    if (Schema.is(field.type)) {
+                        fieldType = "ref";
+                        childTypeSchema = field.type as typeof Schema;
 
                     } else {
-                        let childTypeSchema: typeof Schema;
+                        fieldType = Object.keys(field.type)[0];
 
-                        //
-                        // TODO: refactor below.
-                        //
-                        if (Schema.is(field.type)) {
-                            fieldType = "ref";
-                            childTypeSchema = field.type as typeof Schema;
+                        if (typeof (field.type[fieldType as keyof typeof field.type]) === "string") {
+                            fieldType += ":" + field.type[fieldType as keyof typeof field.type]; // array:string
 
                         } else {
-                            fieldType = Object.keys(field.type)[0];
-
-                            if (typeof (field.type[fieldType as keyof typeof field.type]) === "string") {
-                                fieldType += ":" + field.type[fieldType as keyof typeof field.type]; // array:string
-
-                            } else {
-                                childTypeSchema = field.type[fieldType as keyof typeof field.type];
-                            }
+                            childTypeSchema = field.type[fieldType as keyof typeof field.type];
                         }
-
-                        reflectionField.referencedType = (childTypeSchema)
-                            ? context.getTypeId(childTypeSchema)
-                            : -1;
                     }
 
-                    reflectionField.type = fieldType;
-                    type.fields.push(reflectionField);
+                    reflectionField.referencedType = (childTypeSchema)
+                        ? context.getTypeId(childTypeSchema)
+                        : -1;
                 }
-            }
-
-            addType(type);
-        });
 
-        // in case there are types that were not added due to inheritance
-        for (const typeid in pendingReflectionTypes) {
-            pendingReflectionTypes[typeid].forEach((type) =>
-                reflection.types.push(type))
+                reflectionField.type = fieldType;
+                type.fields.push(reflectionField);
+            }
         }
 
-        const buf = reflectionEncoder.encodeAll(it);
-        return buf.slice(0, it.offset)
-        // return Buffer.from(buf, 0, it.offset);
-    }
+        addType(type);
+    });
 
-    /**
-     * Decodes the TypeContext from a buffer into a Decoder instance.
-     *
-     * @param bytes Reflection.encode() output
-     * @param it
-     * @returns Decoder instance
-     */
-    static decode<T extends Schema = Schema>(bytes: Buffer, it?: Iterator): Decoder<T> {
-        const reflection = new Reflection();
+    // in case there are types that were not added due to inheritance
+    for (const typeid in pendingReflectionTypes) {
+        pendingReflectionTypes[typeid].forEach((type) =>
+            reflection.types.push(type))
+    }
 
-        const reflectionDecoder = new Decoder(reflection);
-        reflectionDecoder.decode(bytes, it);
+    const buf = reflectionEncoder.encodeAll(it);
+    return buf.slice(0, it.offset);
+};
 
-        const typeContext = new TypeContext();
+Reflection.decode = function <T extends Schema = Schema>(bytes: Uint8Array, it?: Iterator): Decoder<T> {
+    const reflection = new Reflection();
 
-        // 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 reflectionDecoder = new Decoder(reflection);
+    reflectionDecoder.decode(bytes, it);
 
-            // register for inheritance support
-            TypeContext.register(schema);
+    const typeContext = new TypeContext();
 
-            // // for inheritance support
-            // Metadata.initialize(schema);
+    // 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 { };
 
-            typeContext.add(schema, reflectionType.id);
-        }, {});
+        // register for inheritance support
+        TypeContext.register(schema);
 
-        // define fields
-        const addFields = (metadata: Metadata, reflectionType: ReflectionType, parentFieldIndex: number) => {
-            reflectionType.fields.forEach((field, i) => {
-                const fieldIndex = parentFieldIndex + i;
+        typeContext.add(schema, reflectionType.id);
+    }, {});
 
-                if (field.referencedType !== undefined) {
-                    let fieldType = field.type;
-                    let refType: PrimitiveType = typeContext.get(field.referencedType);
+    // define fields
+    const addFields = (metadata: Metadata, reflectionType: ReflectionType, parentFieldIndex: number) => {
+        reflectionType.fields.forEach((field, i) => {
+            const fieldIndex = parentFieldIndex + i;
 
-                    // map or array of primitive type (-1)
-                    if (!refType) {
-                        const typeInfo = field.type.split(":");
-                        fieldType = typeInfo[0];
-                        refType = typeInfo[1] as PrimitiveType; // string
-                    }
+            if (field.referencedType !== undefined) {
+                let fieldType = field.type;
+                let refType: PrimitiveType = typeContext.get(field.referencedType);
 
-                    if (fieldType === "ref") {
-                        Metadata.addField(metadata, fieldIndex, field.name, refType);
+                // map or array of primitive type (-1)
+                if (!refType) {
+                    const typeInfo = field.type.split(":");
+                    fieldType = typeInfo[0];
+                    refType = typeInfo[1] as PrimitiveType; // string
+                }
 
-                    } else {
-                        Metadata.addField(metadata, fieldIndex, field.name, { [fieldType]: refType });
-                    }
+                if (fieldType === "ref") {
+                    Metadata.addField(metadata, fieldIndex, field.name, refType);
 
                 } else {
-                    Metadata.addField(metadata, fieldIndex, field.name, field.type as PrimitiveType);
+                    Metadata.addField(metadata, fieldIndex, field.name, { [fieldType]: refType });
                 }
-            });
-        };
 
-        // 2nd pass, set fields
-        reflection.types.forEach((reflectionType) => {
-            const schema = typeContext.get(reflectionType.id);
+            } else {
+                Metadata.addField(metadata, fieldIndex, field.name, field.type as PrimitiveType);
+            }
+        });
+    };
 
-            // for inheritance support
-            const metadata = Metadata.initialize(schema);
+    // 2nd pass, set fields
+    reflection.types.forEach((reflectionType) => {
+        const schema = typeContext.get(reflectionType.id);
 
-            const inheritedTypes: ReflectionType[] = [];
+        // for inheritance support
+        const metadata = Metadata.initialize(schema);
 
-            let parentType: ReflectionType = reflectionType;
-            do {
-                inheritedTypes.push(parentType);
-                parentType = reflection.types.find((t) => t.id === parentType.extendsId);
-            } while (parentType);
+        const inheritedTypes: ReflectionType[] = [];
 
-            let parentFieldIndex = 0;
+        let parentType: ReflectionType = reflectionType;
+        do {
+            inheritedTypes.push(parentType);
+            parentType = reflection.types.find((t) => t.id === parentType.extendsId);
+        } while (parentType);
 
-            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;
-            });
+        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: T = new (typeContext.get(reflection.rootType || 0) as unknown as any)();
+    const state: T = new (typeContext.get(reflection.rootType || 0) as unknown as any)();
 
-        return new Decoder<T>(state, typeContext);
-    }
-}
+    return new Decoder<T>(state, typeContext);
+}