@colyseus/schema 5.0.20 → 5.0.21

package/build/Reflection.d.ts

@@ -76,7 +76,7 @@ export declare const ReflectionField: import("./annotations.js").SchemaWithExten
         max: number;
         bits: number;
         mode: number;
-    } & {} & Schema<any> & Schema<unknown>, false, true>;
+    } & {} & Schema<any> & Schema<unknown>, true, true>;
 }, import("./index.js").BuilderInitProps<{
     name: FieldBuilder<string, false, false>;
     type: FieldBuilder<string, false, false>;
@@ -91,7 +91,7 @@ export declare const ReflectionField: import("./annotations.js").SchemaWithExten
         max: number;
         bits: number;
         mode: number;
-    } & {} & Schema<any> & Schema<unknown>, false, true>;
+    } & {} & Schema<any> & Schema<unknown>, true, true>;
 }>, typeof Schema>;
 export type ReflectionField = SchemaType<typeof ReflectionField>;
 export declare const ReflectionType: import("./annotations.js").SchemaWithExtendsConstructor<{

package/build/annotations.d.ts

@@ -161,13 +161,14 @@ export interface SchemaWithExtendsConstructor<T, InitProps, P extends typeof Sch
     new (...args: [
         InitProps
     ] extends [never] ? [] : InitProps extends readonly any[] ? InitProps : HasExplicitInit<T> extends true ? [InitProps] : IsInitPropsRequired<T> extends true ? ([] | [InitProps]) : [InitProps?]): SchemaInstance<T, P>;
-    prototype: SchemaInstance<T, P> & {
-        initialize(...args: [InitProps] extends [never] ? [] : InitProps extends readonly any[] ? InitProps : [InitProps]): void;
-    };
+    prototype: SchemaInstance<T, P>;
 }
 /**
  * Define a Schema class declaratively.
  *
+ * `initialize()` acts as the constructor: a class created with `.extend()`
+ * inherits the parent's unless it defines its own.
+ *
  * @example
  * import { schema, t } from '@colyseus/schema';
  *

package/build/index.cjs

@@ -1411,6 +1411,10 @@ const Metadata = {
             });
         }
         for (const field in fields) {
+            // metadata inherits the parent's, so this also catches a redeclared parent field
+            if (metadata[field] !== undefined) {
+                throw new Error(`@colyseus/schema: Duplicate '${field}' definition on '${constructor.name || "(anonymous)"}'.`);
+            }
             Metadata.defineField(constructor, metadata, fieldIndex, field, fields[field]);
             fieldIndex++;
         }
@@ -7275,6 +7279,9 @@ function makeAutoDefaultFactory(rawType) {
 /**
  * Define a Schema class declaratively.
  *
+ * `initialize()` acts as the constructor: a class created with `.extend()`
+ * inherits the parent's unless it defines its own.
+ *
  * @example
  * import { schema, t } from '@colyseus/schema';
  *
@@ -7435,8 +7442,11 @@ function schema(fieldsAndMethods, name, inherits = Schema) {
         return parentProps;
     };
     const hasInitialize = typeof methods.initialize === "function";
-    /** @codegen-ignore */
-    const klass = Metadata.setFields(class extends inherits {
+    // Like a constructor: the most-derived initialize() runs once, own or
+    // inherited from a schema() parent. A custom base's initialize() is not
+    // picked up — the constructor type only sees the fields map.
+    const initialize = methods.initialize ?? inherits._initialize;
+    const klass = class extends inherits {
         constructor(...args) {
             const props = args[0];
             if (props === undefined) {
@@ -7451,13 +7461,20 @@ function schema(fieldsAndMethods, name, inherits = Schema) {
                 // `initialize()` owns the schema fields, so only parent props flow up.
                 super(Object.assign(getDefaultValues(), hasInitialize ? getParentProps(props) : props));
             }
-            // Only call initialize() on the exact target class, not parents.
-            if (hasInitialize && new.target === klass) {
-                methods.initialize.apply(this, args);
+            // Only on the exact target class — parents' constructors skip it.
+            if (initialize && new.target === klass) {
+                initialize.apply(this, args);
             }
         }
-    }, fields);
+    };
+    // named before setFields so a duplicate-field error can say which class
+    if (name) {
+        Object.defineProperty(klass, "name", { value: name });
+    }
+    /** @codegen-ignore */
+    Metadata.setFields(klass, fields);
     klass._getDefaultValues = getDefaultValues;
+    klass._initialize = initialize;
     Object.assign(klass.prototype, methods);
     for (const fieldName in viewTagFields) {
         view(viewTagFields[fieldName])(klass.prototype, fieldName);
@@ -7489,9 +7506,6 @@ function schema(fieldsAndMethods, name, inherits = Schema) {
             metadata[metadata[fieldName]].optional = true;
         }
     }
-    if (name) {
-        Object.defineProperty(klass, "name", { value: name });
-    }
     klass.extend = (childFields, childName) => schema(childFields, childName, klass);
     return klass;
 }