@colyseus/schema 3.0.53 → 3.0.54

package/build/esm/index.mjs

@@ -683,15 +683,7 @@ class TypeContext {
             if (typeof (fieldType) === "string") {
                 continue;
             }
-            if (Array.isArray(fieldType)) {
-                const type = fieldType[0];
-                // skip primitive types
-                if (type === "string") {
-                    continue;
-                }
-                this.discoverTypes(type, klass, index, parentHasViewTag || fieldHasViewTag);
-            }
-            else if (typeof (fieldType) === "function") {
+            if (typeof (fieldType) === "function") {
                 this.discoverTypes(fieldType, klass, index, parentHasViewTag || fieldHasViewTag);
             }
             else {
@@ -741,11 +733,43 @@ class TypeContext {
 }
 
 function getNormalizedType(type) {
-    return (Array.isArray(type))
-        ? { array: type[0] }
-        : (typeof (type['type']) !== "undefined")
-            ? type['type']
-            : type;
+    if (Array.isArray(type)) {
+        return { array: getNormalizedType(type[0]) };
+    }
+    else if (typeof (type['type']) !== "undefined") {
+        return type['type'];
+    }
+    else if (isTSEnum(type)) {
+        // Detect TS Enum type (either string or number)
+        return Object.keys(type).every(key => typeof type[key] === "string")
+            ? "string"
+            : "number";
+    }
+    else if (typeof type === "object" && type !== null) {
+        // Handle collection types
+        const collectionType = Object.keys(type).find(k => registeredTypes[k] !== undefined);
+        if (collectionType) {
+            type[collectionType] = getNormalizedType(type[collectionType]);
+            return type;
+        }
+    }
+    return type;
+}
+function isTSEnum(_enum) {
+    if (typeof _enum === 'function' && _enum[Symbol.metadata]) {
+        return false;
+    }
+    const keys = Object.keys(_enum);
+    const numericFields = keys.filter(k => /\d+/.test(k));
+    // Check for number enum (has numeric keys and reverse mapping)
+    if (numericFields.length > 0 && numericFields.length === (keys.length / 2) && _enum[_enum[numericFields[0]]] == numericFields[0]) {
+        return true;
+    }
+    // Check for string enum (all values are strings and keys match values)
+    if (keys.length > 0 && keys.every(key => typeof _enum[key] === 'string' && _enum[key] === key)) {
+        return true;
+    }
+    return false;
 }
 const Metadata = {
     addField(metadata, index, name, type, descriptor) {
@@ -860,14 +884,12 @@ const Metadata = {
             ?? -1; // no fields defined
         fieldIndex++;
         for (const field in fields) {
-            const type = fields[field];
+            const type = getNormalizedType(fields[field]);
             // FIXME: this code is duplicated from @type() annotation
-            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]
-                : getNormalizedType(type);
+                : type;
             Metadata.addField(metadata, fieldIndex, field, type, getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass));
             fieldIndex++;
         }
@@ -3329,6 +3351,8 @@ function type(type, options) {
         if (!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);
         const parentClass = Object.getPrototypeOf(constructor);
@@ -3373,9 +3397,7 @@ function type(type, options) {
             });
         }
         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]
                 : type;
@@ -3502,9 +3524,10 @@ function schema(fieldsAndMethods, name, inherits = Schema) {
                     ? 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();
@@ -3534,14 +3557,14 @@ function schema(fieldsAndMethods, name, inherits = Schema) {
             if (Schema.is(value)) {
                 // Direct Schema type: Type → new Type()
                 defaultValues[fieldName] = new value();
-                fields[fieldName] = value;
+                fields[fieldName] = getNormalizedType(value);
             }
             else {
                 methods[fieldName] = value;
             }
         }
         else {
-            fields[fieldName] = value;
+            fields[fieldName] = getNormalizedType(value);
         }
     }
     const getDefaultValues = () => {