@colyseus/schema 4.0.4 → 4.0.6

package/build/Schema.d.ts

@@ -20,6 +20,13 @@ export declare class Schema<C = any> implements IRef {
      */
     static initialize(instance: any): void;
     static is(type: DefinitionType): boolean;
+    /**
+     * 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;
     /**
      * Track property changes
      */

package/build/decoder/DecodeOperation.d.ts

@@ -1,10 +1,10 @@
 import { OPERATION } from "../encoding/spec.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 } from "../encoding/decode.js";
 export interface DataChange<T = any, F = string> {
-    ref: Ref;
+    ref: IRef;
     refId: number;
     op: OPERATION;
     field: F;
@@ -13,7 +13,7 @@ export interface DataChange<T = any, F = string> {
     previousValue: T;
 }
 export declare const DEFINITION_MISMATCH = -1;
-export type DecodeOperation<T extends Schema = any> = (decoder: Decoder<T>, bytes: Uint8Array, it: Iterator, ref: Ref, allChanges: DataChange[]) => number | void;
+export type DecodeOperation<T extends Schema = any> = (decoder: Decoder<T>, bytes: Uint8Array, it: Iterator, ref: IRef, allChanges: DataChange[]) => number | void;
 export declare function decodeValue<T extends Ref>(decoder: Decoder, operation: OPERATION, ref: T, index: number, type: any, bytes: Uint8Array, it: Iterator, allChanges: DataChange[]): {
     value: any;
     previousValue: T;

package/build/decoder/Decoder.d.ts

@@ -1,11 +1,11 @@
 import { TypeContext } from "../types/TypeContext.js";
 import { Schema } from "../Schema.js";
-import type { Ref } from "../encoder/ChangeTree.js";
+import type { IRef } from "../encoder/ChangeTree.js";
 import type { Iterator } from "../encoding/decode.js";
 import { ReferenceTracker } from "./ReferenceTracker.js";
 import { type DataChange } from "./DecodeOperation.js";
 import { Collection } from "../types/HelperTypes.js";
-export declare class Decoder<T extends Schema = any> {
+export declare class Decoder<T extends IRef = any> {
     context: TypeContext;
     state: T;
     root: ReferenceTracker;
@@ -13,7 +13,7 @@ export declare class Decoder<T extends Schema = any> {
     triggerChanges?: (allChanges: DataChange[]) => void;
     constructor(root: T, context?: TypeContext);
     protected setState(root: T): void;
-    decode(bytes: Uint8Array, it?: Iterator, ref?: Ref): DataChange<any, string>[];
+    decode(bytes: Uint8Array, it?: Iterator, ref?: IRef): DataChange<any, string>[];
     skipCurrentStructure(bytes: Uint8Array, it: Iterator, totalBytes: number): void;
     getInstanceType(bytes: Uint8Array, it: Iterator, defaultType: typeof Schema): typeof Schema;
     createInstanceOfType(type: typeof Schema): Schema;

package/build/decoder/ReferenceTracker.d.ts

@@ -1,4 +1,4 @@
-import { Ref } from "../encoder/ChangeTree.js";
+import type { IRef } from "../encoder/ChangeTree.js";
 /**
  * Used for decoding only.
  */
@@ -6,7 +6,7 @@ export type SchemaCallbacks = {
     [field: string | number]: Function[];
 };
 export declare class ReferenceTracker {
-    refs: Map<number, Ref>;
+    refs: Map<number, IRef>;
     refCount: {
         [refId: number]: number;
     };
@@ -16,7 +16,7 @@ export declare class ReferenceTracker {
     };
     protected nextUniqueId: number;
     getNextUniqueId(): number;
-    addRef(refId: number, ref: Ref, incrementCount?: boolean): void;
+    addRef(refId: number, ref: IRef, incrementCount?: boolean): void;
     removeRef(refId: number): void;
     clearRefs(): void;
     garbageCollectDeletedRefs(): void;

package/build/decoder/strategy/Callbacks.d.ts

@@ -1,5 +1,5 @@
 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";
@@ -18,7 +18,7 @@ type CollectionPropNames<T> = Exclude<{
 }[keyof T] & string, typeof $refId>;
 type CollectionValueType<T, K extends keyof T> = T[K] extends MapSchema<infer V, any> ? V : T[K] extends ArraySchema<infer V> ? V : T[K] extends Collection<any, infer V, any> ? V : never;
 type CollectionKeyType<T, K extends keyof T> = T[K] extends MapSchema<any, infer Key> ? Key : T[K] extends ArraySchema<any> ? number : T[K] extends Collection<infer Key, any, any> ? Key : never;
-export declare class StateCallbackStrategy<TState extends Schema> {
+export declare class StateCallbackStrategy<TState extends IRef> {
     protected decoder: Decoder<TState>;
     protected uniqueRefIds: Set<number>;
     protected isTriggering: boolean;
@@ -28,7 +28,7 @@ export declare class StateCallbackStrategy<TState extends Schema> {
     };
     protected get state(): TState;
     protected addCallback(refId: number, operationOrProperty: OPERATION | string, handler: Function): () => void;
-    protected addCallbackOrWaitCollectionAvailable<TInstance extends Schema, TReturn extends Ref>(instance: TInstance, propertyName: string, operation: OPERATION, handler: Function, immediate?: boolean): () => void;
+    protected addCallbackOrWaitCollectionAvailable<TInstance extends IRef, TReturn extends Ref>(instance: TInstance, propertyName: string, operation: OPERATION, handler: Function, immediate?: boolean): () => void;
     /**
      * Listen to property changes on the root state.
      */
@@ -37,7 +37,7 @@ export declare class StateCallbackStrategy<TState extends Schema> {
      * Listen to property changes on a nested instance.
      */
     listen<TInstance extends Schema, K extends PublicPropNames<TInstance>>(instance: TInstance, property: K, handler: PropertyChangeCallback<TInstance[K]>, immediate?: boolean): () => void;
-    protected listenInstance<TInstance extends Schema>(instance: TInstance, propertyName: string, handler: PropertyChangeCallback<any>, immediate?: boolean): () => void;
+    protected listenInstance<TInstance extends IRef>(instance: TInstance, propertyName: string, handler: PropertyChangeCallback<any>, immediate?: boolean): () => void;
     /**
      * Listen to any property change on an instance.
      */
@@ -106,7 +106,7 @@ export declare 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> | {
+    get<T extends IRef>(roomOrDecoder: Decoder<T> | {
         serializer: {
             decoder: Decoder<T>;
         };

package/build/index.cjs

@@ -929,7 +929,11 @@ const Metadata = {
                 });
             }
         }
-        constructor[Symbol.metadata] = metadata;
+        Object.defineProperty(constructor, Symbol.metadata, {
+            value: metadata,
+            writable: false,
+            configurable: true
+        });
         return metadata;
     },
     isValidInstance(klass) {
@@ -3551,7 +3555,12 @@ function schema(fieldsAndMethods, name, inherits = 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 {
@@ -3561,7 +3570,12 @@ function schema(fieldsAndMethods, name, inherits = 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 {
@@ -3588,13 +3602,32 @@ function schema(fieldsAndMethods, name, inherits = Schema) {
         }
         return defaults;
     };
+    const getParentProps = (props) => {
+        const fieldNames = Object.keys(fields);
+        const parentProps = {};
+        for (const key in props) {
+            if (!fieldNames.includes(key)) {
+                parentProps[key] = props[key];
+            }
+        }
+        return parentProps;
+    };
     /** @codegen-ignore */
     const klass = Metadata.setFields(class extends inherits {
         constructor(...args) {
-            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);
@@ -3668,6 +3701,15 @@ class Schema {
     static is(type) {
         return typeof (type[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) {
+        return typeof obj?.assign === "function";
+    }
     /**
      * Track property changes
      */
@@ -4872,13 +4914,13 @@ function getDecoderStateCallbacks(decoder) {
             // trigger onRemove on child structure.
             //
             if ((change.op & exports.OPERATION.DELETE) === exports.OPERATION.DELETE &&
-                change.previousValue instanceof Schema) {
+                Schema.isSchema(change.previousValue)) {
                 const deleteCallbacks = callbacks[change.previousValue[$refId]]?.[exports.OPERATION.DELETE];
                 for (let i = deleteCallbacks?.length - 1; i >= 0; i--) {
                     deleteCallbacks[i]();
                 }
             }
-            if (ref instanceof Schema) {
+            if (Schema.isSchema(ref)) {
                 //
                 // Handle schema instance
                 //
@@ -5262,7 +5304,7 @@ class StateCallbackStrategy {
             // trigger onRemove on child structure.
             //
             if ((change.op & exports.OPERATION.DELETE) === exports.OPERATION.DELETE &&
-                change.previousValue instanceof Schema) {
+                Schema.isSchema(change.previousValue)) {
                 const childRefId = change.previousValue[$refId];
                 const deleteCallbacks = this.callbacks[childRefId]?.[exports.OPERATION.DELETE];
                 if (deleteCallbacks) {
@@ -5271,7 +5313,7 @@ class StateCallbackStrategy {
                     }
                 }
             }
-            if (ref instanceof Schema) {
+            if (Schema.isSchema(ref)) {
                 //
                 // Handle Schema instance
                 //