@colyseus/schema 4.0.5 → 4.0.7

package/build/types/HelperTypes.d.ts

@@ -1,4 +1,4 @@
-import type { Definition, DefinitionType, PrimitiveType } from "../annotations.js";
+import type { Definition, DefinitionType, PrimitiveType, RawPrimitiveType } from "../annotations.js";
 import type { Schema } from "../Schema.js";
 import type { ArraySchema } from "./custom/ArraySchema.js";
 import type { CollectionSchema } from "./custom/CollectionSchema.js";
@@ -42,10 +42,14 @@ export type InferValueType<T extends DefinitionType> = T extends "string" ? stri
 } ? (ChildType extends Record<string | number, string | number> ? MapSchema<ChildType[keyof ChildType]> : MapSchema<PrimitiveStringToType<ChildType>>) : T extends {
     set: infer ChildType extends Constructor;
 } ? SetSchema<InstanceType<ChildType>> : T extends {
+    set: infer ChildType extends RawPrimitiveType;
+} ? SetSchema<InferValueType<ChildType>> : T extends {
     set: infer ChildType;
 } ? (ChildType extends Record<string | number, string | number> ? SetSchema<ChildType[keyof ChildType]> : SetSchema<ChildType>) : T extends {
     collection: infer ChildType extends Constructor;
 } ? CollectionSchema<InstanceType<ChildType>> : T extends {
+    collection: infer ChildType extends RawPrimitiveType;
+} ? CollectionSchema<InferValueType<ChildType>> : T extends {
     collection: infer ChildType;
 } ? (ChildType extends Record<string | number, string | number> ? CollectionSchema<ChildType[keyof ChildType]> : CollectionSchema<ChildType>) : T extends Constructor ? InstanceType<T> : T extends Record<string | number, string | number> ? T[keyof T] : T extends PrimitiveType ? T : never;
 export type InferSchemaInstanceType<T extends Definition> = {

package/package.json

@@ -1,12 +1,31 @@
 {
   "name": "@colyseus/schema",
-  "version": "4.0.5",
+  "version": "4.0.7",
   "description": "Binary state serializer with delta encoding for games",
   "type": "module",
   "bin": {
     "schema-codegen": "bin/schema-codegen",
     "schema-debug": "bin/schema-debug"
   },
+  "scripts": {
+    "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",
+    "generate-test-4": "bin/schema-codegen test-external/MapSchemaTypes.ts --namespace SchemaTest.MapSchemaTypes --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/MapSchemaTypes",
+    "generate-test-5": "bin/schema-codegen test-external/InheritedTypes.ts --namespace SchemaTest.InheritedTypes --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/InheritedTypes",
+    "generate-test-6": "bin/schema-codegen test-external/MapSchemaInt8.ts --namespace SchemaTest.MapSchemaInt8 --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/MapSchemaInt8",
+    "generate-test-7": "bin/schema-codegen test-external/BackwardsForwards.ts --namespace SchemaTest.BackwardsForwards --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/BackwardsForwards",
+    "generate-test-8": "bin/schema-codegen test-external/FilteredTypes.ts --namespace SchemaTest.FilteredTypes --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/FilteredTypes",
+    "generate-test-9": "bin/schema-codegen test-external/InstanceSharingTypes.ts --namespace SchemaTest.InstanceSharingTypes --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/InstanceSharingTypes",
+    "generate-test-10": "bin/schema-codegen test-external/Callbacks.ts --namespace SchemaTest.Callbacks --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/Callbacks",
+    "generate-test-11": "bin/schema-codegen test-external/MapSchemaMoveNullifyType.ts --namespace SchemaTest.MapSchemaMoveNullifyType --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/MapSchemaMoveNullifyType",
+    "generate-test-12": "bin/schema-codegen test-external/ArraySchemaClear --namespace SchemaTest.ArraySchemaClear --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/ArraySchemaClear",
+    "prepublishOnly": "npm run build"
+  },
   "files": [
     "src",
     "build",
@@ -74,23 +93,5 @@
       "text"
     ],
     "all": true
-  },
-  "scripts": {
-    "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",
-    "generate-test-4": "bin/schema-codegen test-external/MapSchemaTypes.ts --namespace SchemaTest.MapSchemaTypes --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/MapSchemaTypes",
-    "generate-test-5": "bin/schema-codegen test-external/InheritedTypes.ts --namespace SchemaTest.InheritedTypes --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/InheritedTypes",
-    "generate-test-6": "bin/schema-codegen test-external/MapSchemaInt8.ts --namespace SchemaTest.MapSchemaInt8 --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/MapSchemaInt8",
-    "generate-test-7": "bin/schema-codegen test-external/BackwardsForwards.ts --namespace SchemaTest.BackwardsForwards --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/BackwardsForwards",
-    "generate-test-8": "bin/schema-codegen test-external/FilteredTypes.ts --namespace SchemaTest.FilteredTypes --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/FilteredTypes",
-    "generate-test-9": "bin/schema-codegen test-external/InstanceSharingTypes.ts --namespace SchemaTest.InstanceSharingTypes --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/InstanceSharingTypes",
-    "generate-test-10": "bin/schema-codegen test-external/Callbacks.ts --namespace SchemaTest.Callbacks --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/Callbacks",
-    "generate-test-11": "bin/schema-codegen test-external/MapSchemaMoveNullifyType.ts --namespace SchemaTest.MapSchemaMoveNullifyType --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/MapSchemaMoveNullifyType",
-    "generate-test-12": "bin/schema-codegen test-external/ArraySchemaClear --namespace SchemaTest.ArraySchemaClear --output ../colyseus-unity-sdk/Assets/Colyseus/Tests/Editor/ColyseusTests/Schema/ArraySchemaClear"
   }
-}
+}

package/src/Metadata.ts

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

package/src/annotations.ts

@@ -600,7 +600,12 @@ export function schema<
 
                 } else if (value['type'] !== undefined && Schema.is(value['type'])) {
                     // Direct Schema type: Type → new Type()
-                    defaultValues[fieldName] = new value['type']();
+                    if (!value['type'].prototype.initialize || value['type'].prototype.initialize.length === 0) {
+                        // only auto-initialize Schema instances if:
+                        // - they don't have an initialize method
+                        // - or initialize method doesn't accept any parameters
+                        defaultValues[fieldName] = new value['type']();
+                    }
                 }
             } else {
                 defaultValues[fieldName] = value['default'];
@@ -610,7 +615,12 @@ export function schema<
         } else if (typeof (value) === "function") {
             if (Schema.is(value)) {
                 // Direct Schema type: Type → new Type()
-                defaultValues[fieldName] = new value();
+                if (!value.prototype.initialize || value.prototype.initialize.length === 0) {
+                    // only auto-initialize Schema instances if:
+                    // - they don't have an initialize method
+                    // - or initialize method doesn't accept any parameters
+                    defaultValues[fieldName] = new value();
+                }
                 fields[fieldName] = getNormalizedType(value);
             } else {
                 methods[fieldName] = value;
@@ -638,14 +648,33 @@ export function schema<
         return defaults;
     };
 
+    const getParentProps = (props: any) => {
+        const fieldNames = Object.keys(fields);
+        const parentProps: any = {};
+        for (const key in props) {
+            if (!fieldNames.includes(key)) {
+                parentProps[key] = props[key];
+            }
+        }
+        return parentProps;
+    }
+
     /** @codegen-ignore */
     const klass = Metadata.setFields<any>(class extends (inherits as any) {
         constructor(...args: any[]) {
-            super(Object.assign({}, getDefaultValues(), args[0] || {}));
-
             // call initialize method
             if (methods.initialize && typeof methods.initialize === 'function') {
-                methods.initialize.apply(this, args);
+                super(Object.assign({}, getDefaultValues(), getParentProps(args[0] || {})));
+                /**
+                 * only call initialize() in the current class, not the parent ones.
+                 * see "should not call initialize automatically when creating an instance of inherited Schema"
+                 */
+                if (new.target === klass) {
+                    methods.initialize.apply(this, args);
+                }
+
+            } else {
+                super(Object.assign({}, getDefaultValues(), args[0] || {}));
             }
         }
     }, fields) as SchemaWithExtendsConstructor<T, ExtractInitProps<T>, P>;

package/src/codegen/api.ts

@@ -1,15 +1,19 @@
 import * as fs from "fs";
 import * as path from "path";
-import { createRequire } from "module";
-// import { fileURLToPath } from "url";
 
 import { File } from "./types.js";
 import { parseFiles } from "./parser.js";
 
-// Create require relative to this file's location (for ESM compatibility)
-// const __filename = fileURLToPath(import.meta.url);
-// const __dirname = path.dirname(__filename);
-const require = createRequire(import.meta.url);
+// Statically import all language generators (for bundling)
+import { generate as csharp } from "./languages/csharp.js";
+import { generate as cpp } from "./languages/cpp.js";
+import { generate as haxe } from "./languages/haxe.js";
+import { generate as ts } from "./languages/ts.js";
+import { generate as js } from "./languages/js.js";
+import { generate as java } from "./languages/java.js";
+import { generate as lua } from "./languages/lua.js";
+
+const generators: Record<string, Function> = { csharp, cpp, haxe, ts, js, java, lua, };
 
 export interface GenerateOptions {
     files: string[],
@@ -19,12 +23,9 @@ export interface GenerateOptions {
 }
 
 export function generate(targetId: string, options: GenerateOptions) {
-    let generator: Function;
-
-    try {
-        generator = require('./languages/' + targetId + '.js').generate;
+    const generator = generators[targetId];
 
-    } catch (e) {
+    if (!generator) {
         throw new Error("You must provide a valid generator as argument, such as: --csharp, --haxe or --cpp");
     }
 

package/src/decoder/DecodeOperation.ts

@@ -1,20 +1,18 @@
 import { OPERATION } from "../encoding/spec.js";
 import { Metadata } from "../Metadata.js";
 import { Schema } from "../Schema.js";
-import type { Ref } from "../encoder/ChangeTree.js";
+import type { IRef, Ref } from "../encoder/ChangeTree.js";
 import type { Decoder } from "./Decoder.js";
 import { Iterator, decode } from "../encoding/decode.js";
 import { $childType, $deleteByIndex, $getByIndex, $refId } from "../types/symbols.js";
 
-import type { MapSchema } from "../types/custom/MapSchema.js";
 import type { ArraySchema } from "../types/custom/ArraySchema.js";
-import type { CollectionSchema } from "../types/custom/CollectionSchema.js";
 
 import { getType } from "../types/registry.js";
 import { Collection } from "../types/HelperTypes.js";
 
 export interface DataChange<T = any, F = string> {
-    ref: Ref,
+    ref: IRef,
     refId: number,
     op: OPERATION,
     field: F;
@@ -29,7 +27,7 @@ export type DecodeOperation<T extends Schema = any> = (
     decoder: Decoder<T>,
     bytes: Uint8Array,
     it: Iterator,
-    ref: Ref,
+    ref: IRef,
     allChanges: DataChange[],
 ) => number | void;
 

package/src/decoder/Decoder.ts

@@ -4,13 +4,13 @@ import { Schema } from "../Schema.js";
 
 import { decode } from "../encoding/decode.js";
 import { OPERATION, SWITCH_TO_STRUCTURE, TYPE_ID } from '../encoding/spec.js';
-import type { Ref } from "../encoder/ChangeTree.js";
+import type { IRef, Ref } from "../encoder/ChangeTree.js";
 import type { Iterator } from "../encoding/decode.js";
 import { ReferenceTracker } from "./ReferenceTracker.js";
 import { DEFINITION_MISMATCH, type DataChange, type DecodeOperation } from "./DecodeOperation.js";
 import { Collection } from "../types/HelperTypes.js";
 
-export class Decoder<T extends Schema = any> {
+export class Decoder<T extends IRef = any> {
     context: TypeContext;
 
     state: T;
@@ -40,7 +40,7 @@ export class Decoder<T extends Schema = any> {
     decode(
         bytes: Uint8Array,
         it: Iterator = { offset: 0 },
-        ref: Ref = this.state,
+        ref: IRef = this.state,
     ) {
         const allChanges: DataChange[] = [];
 

package/src/decoder/ReferenceTracker.ts

@@ -1,6 +1,6 @@
 import { Metadata } from "../Metadata.js";
 import { $childType, $refId } from "../types/symbols.js";
-import { Ref } from "../encoder/ChangeTree.js";
+import type { IRef } from "../encoder/ChangeTree.js";
 import { spliceOne } from "../types/utils.js";
 import { OPERATION } from "../encoding/spec.js";
 
@@ -25,7 +25,7 @@ export class ReferenceTracker {
     // Relation of refId => Schema structure
     // For direct access of structures during decoding time.
     //
-    public refs = new Map<number, Ref>();
+    public refs = new Map<number, IRef>();
 
     public refCount: { [refId: number]: number; } = {};
     public deletedRefs = new Set<number>();
@@ -38,7 +38,7 @@ export class ReferenceTracker {
     }
 
     // for decoding
-    addRef(refId: number, ref: Ref, incrementCount: boolean = true) {
+    addRef(refId: number, ref: IRef, incrementCount: boolean = true) {
         this.refs.set(refId, ref);
         ref[$refId] = refId;
 
@@ -103,7 +103,7 @@ export class ReferenceTracker {
                 const metadata: Metadata = (ref.constructor as typeof Schema)[Symbol.metadata];
                 for (const index in metadata) {
                     const field = metadata[index as any as number].name;
-                    const child = ref[field as keyof Ref];
+                    const child = ref[field as keyof IRef];
                     if (typeof(child) === "object" && child) {
                         const childRefId = (child as any)[$refId];
                         if (childRefId !== undefined && !this.deletedRefs.has(childRefId)) {

package/src/decoder/strategy/Callbacks.ts

@@ -1,6 +1,6 @@
 import { Metadata } from "../../Metadata.js";
 import { Collection, NonFunctionPropNames } from "../../types/HelperTypes.js";
-import { Ref } from "../../encoder/ChangeTree.js";
+import type { IRef, Ref } from "../../encoder/ChangeTree.js";
 import { Decoder } from "../Decoder.js";
 import { DataChange } from "../DecodeOperation.js";
 import { OPERATION } from "../../encoding/spec.js";
@@ -45,7 +45,7 @@ type CollectionKeyType<T, K extends keyof T> =
     T[K] extends ArraySchema<any> ? number :
     T[K] extends Collection<infer Key, any, any> ? Key : never;
 
-export class StateCallbackStrategy<TState extends Schema> {
+export class StateCallbackStrategy<TState extends IRef> {
     protected decoder: Decoder<TState>;
     protected uniqueRefIds: Set<number> = new Set();
     protected isTriggering: boolean = false;
@@ -72,7 +72,7 @@ export class StateCallbackStrategy<TState extends Schema> {
         return $root.addCallback(refId, operationOrProperty, handler);
     }
 
-    protected addCallbackOrWaitCollectionAvailable<TInstance extends Schema, TReturn extends Ref>(
+    protected addCallbackOrWaitCollectionAvailable<TInstance extends IRef, TReturn extends Ref>(
         instance: TInstance,
         propertyName: string,
         operation: OPERATION,
@@ -142,7 +142,7 @@ export class StateCallbackStrategy<TState extends Schema> {
         }
     }
 
-    protected listenInstance<TInstance extends Schema>(
+    protected listenInstance<TInstance extends IRef>(
         instance: TInstance,
         propertyName: string,
         handler: PropertyChangeCallback<any>,
@@ -485,7 +485,7 @@ export const Callbacks = {
      * @param roomOrDecoder - Room or Decoder instance to get the callbacks for.
      * @returns the new callbacks standard API.
      */
-    get<T extends Schema>(roomOrDecoder: Decoder<T> | { serializer: { decoder: Decoder<T> } }): StateCallbackStrategy<T> {
+    get<T extends IRef>(roomOrDecoder: Decoder<T> | { serializer: { decoder: Decoder<T> } }): StateCallbackStrategy<T> {
         if (roomOrDecoder instanceof Decoder) {
             return new StateCallbackStrategy<T>(roomOrDecoder);
 

package/src/types/HelperTypes.ts

@@ -56,9 +56,11 @@ export type InferValueType<T extends DefinitionType> =
     : T extends { map: infer ChildType } ? (ChildType extends Record<string | number, string | number> ? MapSchema<ChildType[keyof ChildType]> : MapSchema<PrimitiveStringToType<ChildType>>) // TS ENUM
 
     : T extends { set: infer ChildType extends Constructor } ? SetSchema<InstanceType<ChildType>>
+    : T extends { set: infer ChildType extends RawPrimitiveType } ? SetSchema<InferValueType<ChildType>> // primitive types
     : T extends { set: infer ChildType } ? (ChildType extends Record<string | number, string | number> ? SetSchema<ChildType[keyof ChildType]> : SetSchema<ChildType>) // TS ENUM
 
     : T extends { collection: infer ChildType extends Constructor } ? CollectionSchema<InstanceType<ChildType>>
+    : T extends { collection: infer ChildType extends RawPrimitiveType } ? CollectionSchema<InferValueType<ChildType>> // primitive types
     : T extends { collection: infer ChildType } ? (ChildType extends Record<string | number, string | number> ? CollectionSchema<ChildType[keyof ChildType]> : CollectionSchema<ChildType>) // TS ENUM
 
     // Handle direct types