@colyseus/schema 3.0.52 → 3.0.54

package/src/annotations.ts

@@ -2,7 +2,7 @@ import "./symbol.shim";
 import { Schema } from './Schema';
 import { ArraySchema } from './types/custom/ArraySchema';
 import { MapSchema } from './types/custom/MapSchema';
-import { Metadata } from "./Metadata";
+import { getNormalizedType, Metadata } from "./Metadata";
 import { $changes, $childType, $descriptors, $numFields, $track } from "./types/symbols";
 import { TypeDefinition, getType } from "./types/registry";
 import { OPERATION } from "./encoding/spec";
@@ -10,8 +10,8 @@ import { TypeContext } from "./types/TypeContext";
 import { assertInstanceType, assertType } from "./encoding/assert";
 import type { Ref } from "./encoder/ChangeTree";
 import type { DefinedSchemaType, InferValueType } from "./types/HelperTypes";
-import type { CollectionSchema } from "./types/custom/CollectionSchema";
-import type { SetSchema } from "./types/custom/SetSchema";
+import { CollectionSchema } from "./types/custom/CollectionSchema";
+import { SetSchema } from "./types/custom/SetSchema";
 
 export type RawPrimitiveType = "string" |
     "number" |
@@ -285,6 +285,9 @@ export function type (
             throw new Error(`${constructor.name}: @type() reference provided for "${field}" is undefined. Make sure you don't have any circular dependencies.`);
         }
 
+        // Normalize type (enum/collection/etc)
+        type = getNormalizedType(type);
+
         // for inheritance support
         TypeContext.register(constructor);
 
@@ -339,9 +342,7 @@ export function type (
             );
 
         } else {
-            const complexTypeKlass = (Array.isArray(type))
-                ? getType("array")
-                : (typeof(Object.keys(type)[0]) === "string") && getType(Object.keys(type)[0]);
+            const complexTypeKlass = typeof(Object.keys(type)[0]) === "string" && getType(Object.keys(type)[0]);
 
             const childType = (complexTypeKlass)
                 ? Object.values(type)[0]
@@ -512,27 +513,74 @@ export function schema<T extends Definition, P extends typeof Schema = typeof Sc
     for (let fieldName in fieldsAndMethods) {
         const value = fieldsAndMethods[fieldName] as DefinitionType;
         if (typeof (value) === "object") {
-            if (value['default'] !== undefined) {
-                defaultValues[fieldName] = value['default'];
-            }
             if (value['view'] !== undefined) {
                 viewTagFields[fieldName] = (typeof (value['view']) === "boolean")
                     ? DEFAULT_VIEW_TAG
                     : value['view'];
             }
-            fields[fieldName] = value;
+
+            fields[fieldName] = getNormalizedType(value);
+
+            // If no explicit default provided, handle automatic instantiation for collection types
+            if (!Object.prototype.hasOwnProperty.call(value, 'default')) {
+                // TODO: remove Array.isArray() check. Use ['array'] !== undefined only.
+                if (Array.isArray(value) || value['array'] !== undefined) {
+                    // Collection: Array → new ArraySchema()
+                    defaultValues[fieldName] = new ArraySchema();
+
+                } else if (value['map'] !== undefined) {
+                    // Collection: Map → new MapSchema()
+                    defaultValues[fieldName] = new MapSchema();
+
+                } else if (value['collection'] !== undefined) {
+                    // Collection: Collection → new CollectionSchema()
+                    defaultValues[fieldName] = new CollectionSchema();
+
+                } else if (value['set'] !== undefined) {
+                    // Collection: Set → new SetSchema()
+                    defaultValues[fieldName] = new SetSchema();
+
+                } else if (value['type'] !== undefined && Schema.is(value['type'])) {
+                    // Direct Schema type: Type → new Type()
+                    defaultValues[fieldName] = new value['type']();
+                }
+            } else {
+                defaultValues[fieldName] = value['default'];
+            }
+
 
         } else if (typeof (value) === "function") {
-            methods[fieldName] = value;
+            if (Schema.is(value)) {
+                // Direct Schema type: Type → new Type()
+                defaultValues[fieldName] = new value();
+                fields[fieldName] = getNormalizedType(value);
+            } else {
+                methods[fieldName] = value;
+            }
 
         } else {
-            fields[fieldName] = value;
+            fields[fieldName] = getNormalizedType(value);
         }
     }
 
+    const getDefaultValues = () => {
+        const defaults: any = {};
+        for (const fieldName in defaultValues) {
+            const defaultValue = defaultValues[fieldName];
+            // If the default value has a clone method, use it to get a fresh instance
+            if (defaultValue && typeof defaultValue.clone === 'function') {
+                defaults[fieldName] = defaultValue.clone();
+            } else {
+                // Otherwise, use the value as-is (for primitives and non-cloneable objects)
+                defaults[fieldName] = defaultValue;
+            }
+        }
+        return defaults;
+    };
+
     const klass = Metadata.setFields<any>(class extends inherits {
         constructor (...args: any[]) {
-            args[0] = Object.assign({}, defaultValues, args[0]);
+            args[0] = Object.assign({}, getDefaultValues(), args[0]);
             super(...args);
         }
     }, fields) as SchemaWithExtends<T, P>;

package/src/types/HelperTypes.ts

@@ -28,25 +28,34 @@ export type InferValueType<T extends DefinitionType> =
     : T extends "float64" ? number
     : T extends "boolean" ? boolean
 
+    // Handle { type: ... } patterns
     : T extends { type: infer ChildType extends Constructor } ? InstanceType<ChildType>
-    : T extends { type: infer ChildType extends PrimitiveType } ? ChildType
+    : T extends { type: Array<infer ChildType> } ? (ChildType extends Record<string | number, string | number> ? ChildType[keyof ChildType][] : ChildType[]) // TS ENUM
+    : T extends { type: { map: infer ChildType } } ? (ChildType extends Record<string | number, string | number> ? MapSchema<ChildType[keyof ChildType]> : MapSchema<ChildType>) // TS ENUM
+    : T extends { type: { set: infer ChildType } } ? (ChildType extends Record<string | number, string | number> ? SetSchema<ChildType[keyof ChildType]> : SetSchema<ChildType>) // TS ENUM
+    : T extends { type: { collection: infer ChildType } } ? (ChildType extends Record<string | number, string | number> ? CollectionSchema<ChildType[keyof ChildType]> : CollectionSchema<ChildType>) // TS ENUM
+    : T extends { type: infer ChildType } ? (ChildType extends Record<string | number, string | number> ? ChildType[keyof ChildType] : ChildType) // TS ENUM
 
+    // Handle direct array patterns
     : T extends Array<infer ChildType extends Constructor> ? InstanceType<ChildType>[]
-    : T extends Array<infer ChildType extends RawPrimitiveType> ? ChildType[]
+    : T extends Array<infer ChildType> ? (ChildType extends Record<string | number, string | number> ? ChildType[keyof ChildType][] : ChildType[]) // TS ENUM
 
+    // Handle collection object patterns
     : T extends { array: infer ChildType extends Constructor } ? InstanceType<ChildType>[]
-    : T extends { array: infer ChildType extends PrimitiveType } ? ChildType[]
+    : T extends { array: infer ChildType } ? (ChildType extends Record<string | number, string | number> ? ChildType[keyof ChildType][] : ChildType[]) // TS ENUM
 
     : T extends { map: infer ChildType extends Constructor } ? MapSchema<InstanceType<ChildType>>
-    : T extends { map: infer ChildType extends PrimitiveType } ? MapSchema<ChildType>
+    : T extends { map: infer ChildType } ? (ChildType extends Record<string | number, string | number> ? MapSchema<ChildType[keyof ChildType]> : MapSchema<ChildType>) // TS ENUM
 
     : T extends { set: infer ChildType extends Constructor } ? SetSchema<InstanceType<ChildType>>
-    : T extends { set: infer ChildType extends PrimitiveType } ? SetSchema<ChildType>
+    : 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 PrimitiveType } ? CollectionSchema<ChildType>
+    : T extends { collection: infer ChildType } ? (ChildType extends Record<string | number, string | number> ? CollectionSchema<ChildType[keyof ChildType]> : CollectionSchema<ChildType>) // TS ENUM
 
+    // Handle direct types
     : T extends Constructor ? InstanceType<T>
+    : T extends Record<string | number, string | number> ? T[keyof T] // TS ENUM
     : T extends PrimitiveType ? T
 
     : never;

package/src/types/TypeContext.ts

@@ -114,17 +114,7 @@ export class TypeContext {
                 continue;
             }
 
-            if (Array.isArray(fieldType)) {
-                const type = fieldType[0];
-
-                // skip primitive types
-                if (type === "string") {
-                    continue;
-                }
-
-                this.discoverTypes(type as typeof Schema, klass, index, parentHasViewTag || fieldHasViewTag);
-
-            } else if (typeof (fieldType) === "function") {
+            if (typeof (fieldType) === "function") {
                 this.discoverTypes(fieldType as typeof Schema, klass, index, parentHasViewTag || fieldHasViewTag);
 
             } else {

package/src/types/custom/ArraySchema.ts

@@ -362,7 +362,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         changeTree.delete(index, OPERATION.DELETE, allChangesIndex);
         changeTree.shiftAllChangeIndexes(-1, allChangesIndex);
 
-        // this.deletedIndexes[index] = true;
+        this.deletedIndexes[index] = true;
 
         return this.items.shift();
     }

package/src/types/registry.ts

@@ -8,7 +8,8 @@ export interface TypeDefinition {
     decode?: (bytes: BufferLike, it: Iterator) => any;
 }
 
-const registeredTypes: {[identifier: string] : TypeDefinition} = {};
+export const registeredTypes: {[identifier: string] : TypeDefinition} = {};
+
 const identifiers = new Map<any, string>();
 
 export function registerType(identifier: string, definition: TypeDefinition) {