@colyseus/schema 5.0.1 → 5.0.3

package/build/index.d.ts

@@ -22,7 +22,7 @@ export { Metadata } from "./Metadata.js";
 export { type, deprecated, owned, unreliable, transient, view, schema, entity, type DefinitionType, type PrimitiveType, type Definition, type FieldsAndMethods, type SchemaWithExtendsConstructor, type SchemaWithExtends, type SchemaType, } from "./annotations.js";
 export { t, FieldBuilder, isBuilder, type BuilderDefinition, type ChildType } from "./types/builder.js";
 export { TypeContext } from "./types/TypeContext.js";
-export type { InferValueType, InferSchemaInstanceType, AssignableProps } from "./types/HelperTypes.js";
+export type { InferValueType, InferSchemaInstanceType, AssignableProps, BuilderInitProps } from "./types/HelperTypes.js";
 export { getDecoderStateCallbacks, type CallbackProxy, type SchemaCallback, type CollectionCallback, type SchemaCallbackProxy } from "./decoder/strategy/getDecoderStateCallbacks.js";
 export { Callbacks, StateCallbackStrategy } from "./decoder/strategy/Callbacks.js";
 export { getRawChangesCallback } from "./decoder/strategy/RawChanges.js";

package/build/index.js

@@ -1218,6 +1218,33 @@
         getStreamPriority(metadata, index) {
             return metadata?.[$streamPriorities]?.[index];
         },
+        /**
+         * Install a single field with full encoder wiring: accessor descriptor
+         * on the prototype + `metadata[$encoders]` slot for primitives. Shared
+         * between `Metadata.setFields` (build path) and
+         * `Reflection.makeEncodable` (Reflection upgrade path).
+         */
+        defineField(target, metadata, fieldIndex, fieldName, type) {
+            const normalized = getNormalizedType(type);
+            const { complexTypeKlass, childType } = resolveFieldType(normalized);
+            Metadata.addField(metadata, fieldIndex, fieldName, normalized, getPropertyDescriptor(fieldName, fieldIndex, childType, complexTypeKlass));
+            // Install accessor descriptor on the prototype (once per class field).
+            if (metadata[$descriptors][fieldName]) {
+                Object.defineProperty(target.prototype, fieldName, metadata[$descriptors][fieldName]);
+            }
+            // Pre-compute encoder function for primitive types.
+            if (typeof normalized === "string") {
+                if (!metadata[$encoders]) {
+                    Object.defineProperty(metadata, $encoders, {
+                        value: [],
+                        enumerable: false,
+                        configurable: true,
+                        writable: true,
+                    });
+                }
+                metadata[$encoders][fieldIndex] = encode[normalized];
+            }
+        },
         setFields(target, fields) {
             // for inheritance support
             const constructor = target.prototype.constructor;
@@ -1255,17 +1282,7 @@
                 });
             }
             for (const field in fields) {
-                const type = getNormalizedType(fields[field]);
-                const { complexTypeKlass, childType } = resolveFieldType(type);
-                Metadata.addField(metadata, fieldIndex, field, type, getPropertyDescriptor(field, fieldIndex, childType, complexTypeKlass));
-                // Install accessor descriptor on the prototype (once per class field).
-                if (metadata[$descriptors][field]) {
-                    Object.defineProperty(target.prototype, field, metadata[$descriptors][field]);
-                }
-                // Pre-compute encoder function for primitive types.
-                if (typeof type === "string") {
-                    metadata[$encoders][fieldIndex] = encode[type];
-                }
+                Metadata.defineField(constructor, metadata, fieldIndex, field, fields[field]);
                 fieldIndex++;
             }
             return target;
@@ -8112,6 +8129,31 @@
         const state = new (typeContext.get(reflection.rootType || 0))();
         return new Decoder(state, typeContext);
     };
+    Reflection.makeEncodable = function (ctor) {
+        const metadata = ctor[Symbol.metadata];
+        if (!metadata)
+            return ctor;
+        const numFields = metadata[$numFields];
+        if (numFields === undefined)
+            return ctor;
+        // Walk every field index across the inheritance chain. Repeat calls
+        // are cheap: defineField overwrites the same descriptor and re-stamps
+        // the same `metadata[$encoders]` slot (idempotent).
+        for (let i = 0; i <= numFields; i++) {
+            const field = metadata[i];
+            if (!field)
+                continue;
+            Metadata.defineField(ctor, metadata, i, field.name, field.type);
+        }
+        // Invalidate any cached encode descriptor — `getEncodeDescriptor`
+        // memoizes on the constructor. If something already constructed it
+        // (e.g. a prior `InputEncoder(...)` call that threw), drop the stale
+        // entry so the next read sees the upgraded metadata.
+        if (Object.prototype.hasOwnProperty.call(ctor, $encodeDescriptor)) {
+            delete ctor[$encodeDescriptor];
+        }
+        return ctor;
+    };
 
     /**
      * Legacy callback system

package/build/index.mjs

@@ -1212,6 +1212,33 @@ const Metadata = {
     getStreamPriority(metadata, index) {
         return metadata?.[$streamPriorities]?.[index];
     },
+    /**
+     * Install a single field with full encoder wiring: accessor descriptor
+     * on the prototype + `metadata[$encoders]` slot for primitives. Shared
+     * between `Metadata.setFields` (build path) and
+     * `Reflection.makeEncodable` (Reflection upgrade path).
+     */
+    defineField(target, metadata, fieldIndex, fieldName, type) {
+        const normalized = getNormalizedType(type);
+        const { complexTypeKlass, childType } = resolveFieldType(normalized);
+        Metadata.addField(metadata, fieldIndex, fieldName, normalized, getPropertyDescriptor(fieldName, fieldIndex, childType, complexTypeKlass));
+        // Install accessor descriptor on the prototype (once per class field).
+        if (metadata[$descriptors][fieldName]) {
+            Object.defineProperty(target.prototype, fieldName, metadata[$descriptors][fieldName]);
+        }
+        // Pre-compute encoder function for primitive types.
+        if (typeof normalized === "string") {
+            if (!metadata[$encoders]) {
+                Object.defineProperty(metadata, $encoders, {
+                    value: [],
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                });
+            }
+            metadata[$encoders][fieldIndex] = encode[normalized];
+        }
+    },
     setFields(target, fields) {
         // for inheritance support
         const constructor = target.prototype.constructor;
@@ -1249,17 +1276,7 @@ const Metadata = {
             });
         }
         for (const field in fields) {
-            const type = getNormalizedType(fields[field]);
-            const { complexTypeKlass, childType } = resolveFieldType(type);
-            Metadata.addField(metadata, fieldIndex, field, type, getPropertyDescriptor(field, fieldIndex, childType, complexTypeKlass));
-            // Install accessor descriptor on the prototype (once per class field).
-            if (metadata[$descriptors][field]) {
-                Object.defineProperty(target.prototype, field, metadata[$descriptors][field]);
-            }
-            // Pre-compute encoder function for primitive types.
-            if (typeof type === "string") {
-                metadata[$encoders][fieldIndex] = encode[type];
-            }
+            Metadata.defineField(constructor, metadata, fieldIndex, field, fields[field]);
             fieldIndex++;
         }
         return target;
@@ -8106,6 +8123,31 @@ Reflection.decode = function (bytes, it) {
     const state = new (typeContext.get(reflection.rootType || 0))();
     return new Decoder(state, typeContext);
 };
+Reflection.makeEncodable = function (ctor) {
+    const metadata = ctor[Symbol.metadata];
+    if (!metadata)
+        return ctor;
+    const numFields = metadata[$numFields];
+    if (numFields === undefined)
+        return ctor;
+    // Walk every field index across the inheritance chain. Repeat calls
+    // are cheap: defineField overwrites the same descriptor and re-stamps
+    // the same `metadata[$encoders]` slot (idempotent).
+    for (let i = 0; i <= numFields; i++) {
+        const field = metadata[i];
+        if (!field)
+            continue;
+        Metadata.defineField(ctor, metadata, i, field.name, field.type);
+    }
+    // Invalidate any cached encode descriptor — `getEncodeDescriptor`
+    // memoizes on the constructor. If something already constructed it
+    // (e.g. a prior `InputEncoder(...)` call that threw), drop the stale
+    // entry so the next read sees the upgraded metadata.
+    if (Object.prototype.hasOwnProperty.call(ctor, $encodeDescriptor)) {
+        delete ctor[$encodeDescriptor];
+    }
+    return ctor;
+};
 
 /**
  * Legacy callback system