@colyseus/schema 4.0.13 → 4.0.14

package/src/codegen/languages/csharp.ts

@@ -9,6 +9,8 @@ import {
 import { GenerateOptions } from "../api.js";
 import { Context } from "../types.js";
 
+export const name = "Unity/C#";
+
 const typeMaps: { [key: string]: string } = {
     "string": "string",
     "number": "float",
@@ -25,6 +27,11 @@ const typeMaps: { [key: string]: string } = {
     "float64": "double",
 }
 
+const COMMON_IMPORTS = `using Colyseus.Schema;
+#if UNITY_5_3_OR_NEWER
+using UnityEngine.Scripting;
+#endif`;
+
 /**
  * C# Code Generator
  */
@@ -33,6 +40,9 @@ const capitalize = (s: string) => {
     return s.charAt(0).toUpperCase() + s.slice(1);
 }
 
+/**
+ * Generate individual files for each class/interface/enum
+ */
 export function generate(context: Context, options: GenerateOptions): File[] {
     // enrich typeMaps with enums
     context.enums.forEach((structure) => {
@@ -54,31 +64,69 @@ export function generate(context: Context, options: GenerateOptions): File[] {
     ];
 }
 
-function generateClass(klass: Class, namespace: string) {
-    const indent = (namespace) ? "\t" : "";
-    return `${getCommentHeader()}
+/**
+ * Generate a single bundled file containing all classes, interfaces, and enums
+ */
+export function renderBundle(context: Context, options: GenerateOptions): File {
+    const fileName = options.namespace ? `${options.namespace}.cs` : "Schema.cs";
+    const indent = options.namespace ? "\t" : "";
 
-using Colyseus.Schema;
-#if UNITY_5_3_OR_NEWER
-using UnityEngine.Scripting;
-#endif
-${namespace ? `\nnamespace ${namespace} {` : ""}
-${indent}public partial class ${klass.name} : ${klass.extends} {
+    // enrich typeMaps with enums
+    context.enums.forEach((structure) => {
+        typeMaps[structure.name] = structure.name;
+    });
+
+    // Collect all bodies
+    const classBodies = context.classes.map(klass => generateClassBody(klass, indent));
+    const interfaceBodies = context.interfaces.map(iface => generateInterfaceBody(iface, indent));
+    const enumBodies = context.enums
+        .filter(structure => structure.name !== 'OPERATION')
+        .map(e => generateEnumBody(e, indent));
+
+    const allBodies = [...classBodies, ...interfaceBodies, ...enumBodies].join("\n\n");
+
+    const content = `${getCommentHeader()}
+
+${COMMON_IMPORTS}
+${options.namespace ? `\nnamespace ${options.namespace} {\n` : ""}
+${allBodies}
+${options.namespace ? "}" : ""}`;
+
+    return { name: fileName, content };
+}
+
+/**
+ * Generate just the class body (without imports/namespace) for bundling
+ */
+function generateClassBody(klass: Class, indent: string = ""): string {
+    return `${indent}public partial class ${klass.name} : ${klass.extends} {
 #if UNITY_5_3_OR_NEWER
 [Preserve]
 #endif
 public ${klass.name}() { }
 ${klass.properties.map((prop) => generateProperty(prop, indent)).join("\n\n")}
-${indent}}
-${namespace ? "}" : ""}
-`;
+${indent}}`;
 }
 
-function generateEnum(_enum: Enum, namespace: string) {
-    const indent = namespace ? "\t" : "";
+/**
+ * Generate a complete class file with imports/namespace (for individual file mode)
+ */
+function generateClass(klass: Class, namespace: string) {
+    const indent = (namespace) ? "\t" : "";
     return `${getCommentHeader()}
+
+${COMMON_IMPORTS}
 ${namespace ? `\nnamespace ${namespace} {` : ""}
-${indent}public struct ${_enum.name} {
+${generateClassBody(klass, indent)}
+${namespace ? "}" : ""}
+`;
+}
+
+/**
+ * Generate just the enum body (without imports/namespace) for bundling
+ */
+function generateEnumBody(_enum: Enum, indent: string = ""): string {
+    return `${indent}public struct ${_enum.name} {
 
 ${_enum.properties
     .map((prop) => {
@@ -99,7 +147,17 @@ ${_enum.properties
         return `${indent}\tpublic const ${dataType} ${prop.name} = ${value};`;
     })
         .join("\n")}
-${indent}}
+${indent}}`;
+}
+
+/**
+ * Generate a complete enum file with imports/namespace (for individual file mode)
+ */
+function generateEnum(_enum: Enum, namespace: string) {
+    const indent = namespace ? "\t" : "";
+    return `${getCommentHeader()}
+${namespace ? `\nnamespace ${namespace} {` : ""}
+${generateEnumBody(_enum, indent)}
 ${namespace ? "}" : ""}`
 }
 
@@ -134,15 +192,25 @@ function generateProperty(prop: Property, indent: string = "") {
 \t${indent}${property} = ${initializer};`;
 }
 
+/**
+ * Generate just the interface body (without imports/namespace) for bundling
+ */
+function generateInterfaceBody(struct: Interface, indent: string = ""): string {
+    return `${indent}public class ${struct.name} {
+${struct.properties.map(prop => `\t${indent}public ${getType(prop)} ${prop.name};`).join("\n")}
+${indent}}`;
+}
+
+/**
+ * Generate a complete interface file with imports/namespace (for individual file mode)
+ */
 function generateInterface(struct: Interface, namespace: string) {
     const indent = (namespace) ? "\t" : "";
     return `${getCommentHeader()}
 
 using Colyseus.Schema;
 ${namespace ? `\nnamespace ${namespace} {` : ""}
-${indent}public class ${struct.name} {
-${struct.properties.map(prop => `\t${indent}public ${getType(prop)} ${prop.name};`).join("\n")}
-${indent}}
+${generateInterfaceBody(struct, indent)}
 ${namespace ? "}" : ""}
 `;
 }

package/src/codegen/languages/gdscript.ts

@@ -0,0 +1,219 @@
+import {
+    Class,
+    Property,
+    File,
+    getCommentHeader,
+    getInheritanceTree,
+    Context,
+    Enum,
+} from "../types.js";
+import { GenerateOptions } from "../api.js";
+
+export const name = "GDScript";
+
+/**
+ * Type mappings from schema types to GDScript Colyseus.Schema type constants
+ */
+const typeMaps: { [key: string]: string } = {
+    "string": "Colyseus.Schema.STRING",
+    "number": "Colyseus.Schema.NUMBER",
+    "boolean": "Colyseus.Schema.BOOLEAN",
+    "int8": "Colyseus.Schema.INT8",
+    "uint8": "Colyseus.Schema.UINT8",
+    "int16": "Colyseus.Schema.INT16",
+    "uint16": "Colyseus.Schema.UINT16",
+    "int32": "Colyseus.Schema.INT32",
+    "uint32": "Colyseus.Schema.UINT32",
+    "int64": "Colyseus.Schema.INT64",
+    "uint64": "Colyseus.Schema.UINT64",
+    "float32": "Colyseus.Schema.FLOAT32",
+    "float64": "Colyseus.Schema.FLOAT64",
+};
+
+const containerMaps: { [key: string]: string } = {
+    "array": "Colyseus.Schema.ARRAY",
+    "map": "Colyseus.Schema.MAP",
+    "ref": "Colyseus.Schema.REF",
+};
+
+const distinct = (value: string, index: number, self: string[]) =>
+    self.indexOf(value) === index;
+
+/**
+ * GDScript Code Generator
+ */
+
+/**
+ * Generate individual files for each class
+ */
+export function generate(context: Context, options: GenerateOptions): File[] {
+    // Enrich typeMaps with enums
+    context.enums.forEach((structure) => {
+        typeMaps[structure.name] = structure.name;
+    });
+
+    return [
+        ...context.classes.map(klass => ({
+            name: `${klass.name}.gd`,
+            content: generateClass(klass, options.namespace, context.classes)
+        })),
+        ...context.enums.filter(structure => structure.name !== 'OPERATION').map((structure) => ({
+            name: `${structure.name}.gd`,
+            content: generateEnum(structure, options.namespace),
+        })),
+    ];
+}
+
+/**
+ * Generate a single bundled file containing all classes and enums
+ */
+export function renderBundle(context: Context, options: GenerateOptions): File {
+    const fileName = options.namespace ? `${options.namespace}.gd` : "schema.gd";
+
+    // Enrich typeMaps with enums
+    context.enums.forEach((structure) => {
+        typeMaps[structure.name] = structure.name;
+    });
+
+    const enumBodies = context.enums
+        .filter(structure => structure.name !== 'OPERATION')
+        .map(e => generateEnumBody(e));
+
+    const classBodies = context.classes.map(klass => generateClassBody(klass));
+
+    const content = `${getCommentHeader("#")}
+
+${enumBodies.length > 0 ? enumBodies.join("\n\n") + "\n\n" : ""}${classBodies.join("\n\n")}
+`;
+
+    return { name: fileName, content };
+}
+
+/**
+ * Generate just the class body (without preload) for bundling
+ */
+function generateClassBody(klass: Class): string {
+    // Determine parent class
+    const parentClass = (klass.extends !== "Schema")
+        ? klass.extends
+        : "Colyseus.Schema";
+
+    const properties = klass.properties;
+
+    const fieldsContent = properties.length > 0
+        ? properties.map(prop => generateFieldDefinition(prop)).join(",\n") + ","
+        : "";
+
+    // Generate _to_string() method
+    const toStringMethod = generateToStringMethod(klass.name, properties);
+
+    return `class ${klass.name} extends ${parentClass}:
+	static func definition():
+		return [
+${fieldsContent}
+		]
+
+${toStringMethod}`;
+}
+
+/**
+ * Generate _to_string() method for the class
+ */
+function generateToStringMethod(className: string, properties: Property[]): string {
+    const fieldNames = properties.map(prop => prop.name);
+    const allFields = ["__ref_id", ...fieldNames];
+
+    const formatParts = allFields.map(name => `${name}: %s`).join(", ");
+    const formatString = `${className}(${formatParts})`;
+
+    const selfReferences = allFields.map(name => `self.${name}`).join(", ");
+
+    return `\tfunc _to_string() -> String:
+		return "${formatString}" % [${selfReferences}]`;
+}
+
+/**
+ * Generate a complete class file with preload (for individual file mode)
+ */
+function generateClass(klass: Class, namespace: string, allClasses: Class[]) {
+    const allRefs: Property[] = [];
+    klass.properties.forEach(property => {
+        let type = property.type;
+
+        // Keep all refs list
+        if ((type === "ref" || type === "array" || type === "map")) {
+            allRefs.push(property);
+        }
+    });
+
+    // Get required preloads for referenced types
+    const preloads = allRefs
+        .filter(ref => ref.childType && typeMaps[ref.childType] === undefined)
+        .map(ref => ref.childType)
+        .concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name))
+        .filter(distinct)
+        .map(childType => `const ${childType} = preload("${childType}.gd")`)
+        .join("\n");
+
+    return `${getCommentHeader("#")}
+
+${preloads ? preloads + "\n\n" : ""}${generateClassBody(klass)}
+`;
+}
+
+/**
+ * Generate a field definition for the definition() array
+ */
+function generateFieldDefinition(prop: Property): string {
+    let args: string[];
+
+    if (prop.childType) {
+        const isUpcaseFirst = prop.childType.match(/^[A-Z]/);
+
+        // Array or Map container
+        const containerType = containerMaps[prop.type];
+        const childTypeRef = isUpcaseFirst ? prop.childType : typeMaps[prop.childType] || `"${prop.childType}"`;
+        args = [`"${prop.name}"`, containerType, childTypeRef];
+    } else {
+        // Primitive type
+        const typeRef = typeMaps[prop.type] || `"${prop.type}"`;
+        args = [`"${prop.name}"`, typeRef];
+    }
+
+    return `\t\t\tColyseus.Schema.Field.new(${args.join(", ")})`;
+}
+
+/**
+ * Generate just the enum body for bundling
+ */
+function generateEnumBody(_enum: Enum): string {
+    const enumValues = _enum.properties.map((prop, index) => {
+        let value: any;
+
+        if (prop.type) {
+            if (isNaN(Number(prop.type))) {
+                value = `"${prop.type}"`;
+            } else {
+                value = Number(prop.type);
+            }
+        } else {
+            value = index;
+        }
+
+        return `\t"${prop.name}": ${value},`;
+    }).join("\n");
+
+    return `const ${_enum.name} = {
+${enumValues}
+}`;
+}
+
+/**
+ * Generate a complete enum file (for individual file mode)
+ */
+function generateEnum(_enum: Enum, _namespace: string) {
+    return `${getCommentHeader("#")}
+
+${generateEnumBody(_enum)}
+`;
+}

package/src/codegen/languages/haxe.ts

@@ -1,6 +1,8 @@
 import { Class, Property, File, getCommentHeader, Context } from "../types.js";
 import { GenerateOptions } from "../api.js";
 
+export const name = "Haxe";
+
 const typeMaps: { [key: string]: string } = {
     "string": "String",
     "number": "Dynamic",
@@ -33,6 +35,12 @@ const typeInitializer: { [key: string]: string } = {
     "float64": "0",
 }
 
+const COMMON_IMPORTS = `import io.colyseus.serializer.schema.Schema;
+import io.colyseus.serializer.schema.types.*;`;
+
+/**
+ * Generate individual files for each class
+ */
 export function generate (context: Context, options: GenerateOptions): File[] {
     return context.classes.map(klass => ({
         name: klass.name + ".hx",
@@ -40,6 +48,25 @@ export function generate (context: Context, options: GenerateOptions): File[] {
     }));
 }
 
+/**
+ * Generate a single bundled file containing all classes
+ */
+export function renderBundle(context: Context, options: GenerateOptions): File {
+    const fileName = options.namespace ? `${options.namespace}.hx` : "Schema.hx";
+
+    const classBodies = context.classes.map(klass => generateClassBody(klass));
+
+    const content = `${getCommentHeader()}
+
+${options.namespace ? `package ${options.namespace};` : ""}
+${COMMON_IMPORTS}
+
+${classBodies.join("\n\n")}
+`;
+
+    return { name: fileName, content };
+}
+
 function getInheritanceTree(klass: Class, allClasses: Class[], includeSelf: boolean = true) {
     let currentClass = klass;
     let inheritanceTree: Class[] = [];
@@ -56,16 +83,25 @@ function getInheritanceTree(klass: Class, allClasses: Class[], includeSelf: bool
     return inheritanceTree;
 }
 
+/**
+ * Generate just the class body (without package/imports) for bundling
+ */
+function generateClassBody(klass: Class): string {
+    return `class ${klass.name} extends ${klass.extends} {
+${klass.properties.map(prop => generateProperty(prop)).join("\n")}
+}`;
+}
+
+/**
+ * Generate a complete class file with package/imports (for individual file mode)
+ */
 function generateClass(klass: Class, namespace: string, allClasses: Class[]) {
     return `${getCommentHeader()}
 
 ${namespace ? `package ${namespace};` : ""}
-import io.colyseus.serializer.schema.Schema;
-import io.colyseus.serializer.schema.types.*;
+${COMMON_IMPORTS}
 
-class ${klass.name} extends ${klass.extends} {
-${klass.properties.map(prop => generateProperty(prop)).join("\n")}
-}
+${generateClassBody(klass)}
 `;
 }
 

package/src/codegen/languages/java.ts

@@ -1,6 +1,8 @@
 import { Class, Property, File, getCommentHeader, Context } from "../types.js";
 import { GenerateOptions } from "../api.js";
 
+export const name = "Java";
+
 const typeMaps: { [key: string]: string } = {
     "string": "String",
     "number": "float",
@@ -33,10 +35,17 @@ const typeInitializer: { [key: string]: string } = {
     "float64": "0",
 }
 
+const COMMON_IMPORTS = `import io.colyseus.serializer.schema.Schema;
+import io.colyseus.serializer.schema.annotations.SchemaClass;
+import io.colyseus.serializer.schema.annotations.SchemaField;`;
+
 /**
- * C# Code Generator
+ * Java Code Generator
  */
 
+/**
+ * Generate individual files for each class
+ */
 export function generate (context: Context, options: GenerateOptions): File[] {
     return context.classes.map(klass => ({
         name: klass.name + ".java",
@@ -44,14 +53,46 @@ export function generate (context: Context, options: GenerateOptions): File[] {
     }));
 }
 
+/**
+ * Generate a single bundled file containing all classes
+ * Note: Java typically requires one public class per file, so bundled mode
+ * generates all classes in a single file with package-private visibility
+ */
+export function renderBundle(context: Context, options: GenerateOptions): File {
+    const fileName = options.namespace ? `Schema.java` : "Schema.java";
+
+    const classBodies = context.classes.map(klass => generateClassBody(klass));
+
+    const content = `${getCommentHeader()}
+${options.namespace ? `\npackage ${options.namespace};` : ""}
+
+${COMMON_IMPORTS}
+
+${classBodies.join("\n\n")}
+`;
+
+    return { name: fileName, content };
+}
+
+/**
+ * Generate just the class body (without package/imports) for bundling
+ */
+function generateClassBody(klass: Class): string {
+    return `@SchemaClass
+class ${klass.name} extends ${klass.extends} {
+${klass.properties.map(prop => generateProperty(prop, "")).join("\n\n")}
+}`;
+}
+
+/**
+ * Generate a complete class file with package/imports (for individual file mode)
+ */
 function generateClass(klass: Class, namespace: string) {
     const indent = (namespace) ? "\t" : "";
     return `${getCommentHeader()}
 ${namespace ? `\npackage ${namespace};` : ""}
 
-import io.colyseus.serializer.schema.Schema;
-import io.colyseus.serializer.schema.annotations.SchemaClass;
-import io.colyseus.serializer.schema.annotations.SchemaField;
+${COMMON_IMPORTS}
 
 @SchemaClass
 ${indent}public class ${klass.name} extends ${klass.extends} {

package/src/codegen/languages/js.ts

@@ -1,6 +1,8 @@
 import { Class, Property, File, getCommentHeader, getInheritanceTree, Context } from "../types.js";
 import { GenerateOptions } from "../api.js";
 
+export const name = "JavaScript";
+
 const typeMaps: { [key: string]: string } = {
     "string": "string",
     "number": "number",
@@ -17,9 +19,16 @@ const typeMaps: { [key: string]: string } = {
     "float64": "number",
 }
 
+const COMMON_IMPORTS = `const schema = require("@colyseus/schema");
+const Schema = schema.Schema;
+const type = schema.type;`;
+
 const distinct = (value: string, index: number, self: string[]) =>
     self.indexOf(value) === index;
 
+/**
+ * Generate individual files for each class
+ */
 export function generate (context: Context, options: GenerateOptions): File[] {
     return context.classes.map(klass => ({
         name: klass.name + ".js",
@@ -27,6 +36,47 @@ export function generate (context: Context, options: GenerateOptions): File[] {
     }));
 }
 
+/**
+ * Generate a single bundled file containing all classes
+ */
+export function renderBundle(context: Context, options: GenerateOptions): File {
+    const fileName = options.namespace ? `${options.namespace}.js` : "schema.js";
+
+    const classBodies = context.classes.map(klass => generateClassBody(klass));
+    const classExports = context.classes.map(klass => `    ${klass.name},`).join("\n");
+
+    const content = `${getCommentHeader()}
+
+${COMMON_IMPORTS}
+
+${classBodies.join("\n\n")}
+
+module.exports = {
+${classExports}
+};
+`;
+
+    return { name: fileName, content };
+}
+
+/**
+ * Generate just the class body (without imports) for bundling
+ */
+function generateClassBody(klass: Class): string {
+    return `class ${klass.name} extends ${klass.extends} {
+    constructor () {
+        super();
+${klass.properties.
+    filter(prop => prop.childType !== undefined).
+    map(prop => "        " + generatePropertyInitializer(prop)).join("\n")}
+    }
+}
+${klass.properties.map(prop => generatePropertyDeclaration(klass.name, prop)).join("\n")}`;
+}
+
+/**
+ * Generate a complete class file with imports (for individual file mode)
+ */
 function generateClass(klass: Class, namespace: string, allClasses: Class[]) {
     const allRefs: Property[] = [];
     klass.properties.forEach(property => {
@@ -38,28 +88,20 @@ function generateClass(klass: Class, namespace: string, allClasses: Class[]) {
         }
     });
 
+    const localImports = allRefs.
+        filter(ref => ref.childType && typeMaps[ref.childType] === undefined).
+        map(ref => ref.childType).
+        concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
+        filter(distinct).
+        map(childType => `const ${childType} = require("./${childType}");`).
+        join("\n");
+
     return `${getCommentHeader()}
 
-const schema = require("@colyseus/schema");
-const Schema = schema.Schema;
-const type = schema.type;
-${allRefs.
-    filter(ref => ref.childType && typeMaps[ref.childType] === undefined).
-    map(ref => ref.childType).
-    concat(getInheritanceTree(klass, allClasses, false).map(klass => klass.name)).
-    filter(distinct).
-    map(childType => `const ${childType} = require("./${childType}");`).
-    join("\n")}
-
-class ${klass.name} extends ${klass.extends} {
-    constructor () {
-        super();
-${klass.properties.
-    filter(prop => prop.childType !== undefined).
-    map(prop => "        " + generatePropertyInitializer(prop)).join("\n")}
-    }
-}
-${klass.properties.map(prop => generatePropertyDeclaration(klass.name, prop)).join("\n")}
+${COMMON_IMPORTS}
+${localImports}
+
+${generateClassBody(klass)}
 
 export default ${klass.name};
 `;