@colyseus/schema 4.0.4 → 4.0.6

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,6 +1,6 @@
 {
   "name": "@colyseus/schema",
-  "version": "4.0.4",
+  "version": "4.0.6",
   "description": "Binary state serializer with delta encoding for games",
   "type": "module",
   "bin": {

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/Schema.ts

@@ -42,6 +42,16 @@ export class Schema<C = any> implements IRef {
         return typeof((type as typeof Schema)[Symbol.metadata]) === "object";
     }
 
+    /**
+     * Check if a value is an instance of Schema.
+     * This method uses duck-typing to avoid issues with multiple @colyseus/schema versions.
+     * @param obj Value to check
+     * @returns true if the value is a Schema instance
+     */
+    static isSchema(obj: any): obj is Schema {
+        return typeof obj?.assign === "function";
+    }
+
     /**
      * Track property changes
      */

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/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>,
@@ -344,7 +344,7 @@ export class StateCallbackStrategy<TState extends Schema> {
             //
             if (
                 (change.op & OPERATION.DELETE) === OPERATION.DELETE &&
-                change.previousValue instanceof Schema
+                Schema.isSchema(change.previousValue)
             ) {
                 const childRefId = (change.previousValue as Ref)[$refId];
                 const deleteCallbacks = this.callbacks[childRefId]?.[OPERATION.DELETE];
@@ -355,7 +355,7 @@ export class StateCallbackStrategy<TState extends Schema> {
                 }
             }
 
-            if (ref instanceof Schema) {
+            if (Schema.isSchema(ref)) {
                 //
                 // Handle Schema instance
                 //
@@ -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/decoder/strategy/getDecoderStateCallbacks.ts

@@ -137,7 +137,7 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
             //
             if (
                 (change.op & OPERATION.DELETE) === OPERATION.DELETE &&
-                change.previousValue instanceof Schema
+                Schema.isSchema(change.previousValue)
             ) {
                 const deleteCallbacks = callbacks[(change.previousValue as Ref)[$refId]]?.[OPERATION.DELETE];
                 for (let i = deleteCallbacks?.length - 1; i >= 0; i--) {
@@ -145,7 +145,7 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                 }
             }
 
-            if (ref instanceof Schema) {
+            if (Schema.isSchema(ref)) {
                 //
                 // Handle schema instance
                 //

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