@colyseus/schema 4.0.13 → 4.0.14

package/build/codegen/languages/c.d.ts

@@ -0,0 +1,11 @@
+import { File, Context } from "../types.js";
+import { GenerateOptions } from "../api.js";
+export declare const name = "C";
+/**
+ * Generate individual files for each class
+ */
+export declare function generate(context: Context, options: GenerateOptions): File[];
+/**
+ * Generate a single bundled header file containing all classes
+ */
+export declare function renderBundle(context: Context, options: GenerateOptions): File;

package/build/codegen/languages/cpp.d.ts

@@ -1,3 +1,11 @@
 import { File, Context } from "../types.js";
 import { GenerateOptions } from "../api.js";
+export declare const name = "C++";
+/**
+ * Generate individual files for each class
+ */
 export declare function generate(context: Context, options: GenerateOptions): File[];
+/**
+ * Generate a single bundled header file containing all classes
+ */
+export declare function renderBundle(context: Context, options: GenerateOptions): File;

package/build/codegen/languages/csharp.d.ts

@@ -1,4 +1,12 @@
 import { File } from "../types.js";
 import { GenerateOptions } from "../api.js";
 import { Context } from "../types.js";
+export declare const name = "Unity/C#";
+/**
+ * Generate individual files for each class/interface/enum
+ */
 export declare function generate(context: Context, options: GenerateOptions): File[];
+/**
+ * Generate a single bundled file containing all classes, interfaces, and enums
+ */
+export declare function renderBundle(context: Context, options: GenerateOptions): File;

package/build/codegen/languages/gdscript.d.ts

@@ -0,0 +1,14 @@
+import { File, Context } from "../types.js";
+import { GenerateOptions } from "../api.js";
+export declare const name = "GDScript";
+/**
+ * GDScript Code Generator
+ */
+/**
+ * Generate individual files for each class
+ */
+export declare function generate(context: Context, options: GenerateOptions): File[];
+/**
+ * Generate a single bundled file containing all classes and enums
+ */
+export declare function renderBundle(context: Context, options: GenerateOptions): File;

package/build/codegen/languages/haxe.d.ts

@@ -1,3 +1,11 @@
 import { File, Context } from "../types.js";
 import { GenerateOptions } from "../api.js";
+export declare const name = "Haxe";
+/**
+ * Generate individual files for each class
+ */
 export declare function generate(context: Context, options: GenerateOptions): File[];
+/**
+ * Generate a single bundled file containing all classes
+ */
+export declare function renderBundle(context: Context, options: GenerateOptions): File;

package/build/codegen/languages/java.d.ts

@@ -1,6 +1,16 @@
 import { File, Context } from "../types.js";
 import { GenerateOptions } from "../api.js";
+export declare const name = "Java";
 /**
- * C# Code Generator
+ * Java Code Generator
+ */
+/**
+ * Generate individual files for each class
  */
 export declare 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 declare function renderBundle(context: Context, options: GenerateOptions): File;

package/build/codegen/languages/js.d.ts

@@ -1,3 +1,11 @@
 import { File, Context } from "../types.js";
 import { GenerateOptions } from "../api.js";
+export declare const name = "JavaScript";
+/**
+ * Generate individual files for each class
+ */
 export declare function generate(context: Context, options: GenerateOptions): File[];
+/**
+ * Generate a single bundled file containing all classes
+ */
+export declare function renderBundle(context: Context, options: GenerateOptions): File;

package/build/codegen/languages/lua.d.ts

@@ -1,3 +1,11 @@
 import { File, Context } from "../types.js";
 import { GenerateOptions } from "../api.js";
+export declare const name = "LUA";
+/**
+ * Generate individual files for each class
+ */
 export declare function generate(context: Context, options: GenerateOptions): File[];
+/**
+ * Generate a single bundled file containing all classes
+ */
+export declare function renderBundle(context: Context, options: GenerateOptions): File;

package/build/codegen/languages/ts.d.ts

@@ -1,3 +1,11 @@
 import { File, Context } from "../types.js";
 import { GenerateOptions } from "../api.js";
+export declare const name = "TypeScript";
+/**
+ * Generate individual files for each class/interface
+ */
 export declare function generate(context: Context, options: GenerateOptions): File[];
+/**
+ * Generate a single bundled file containing all classes and interfaces
+ */
+export declare function renderBundle(context: Context, options: GenerateOptions): File;

package/build/codegen/types.d.ts

@@ -49,4 +49,18 @@ export interface File {
     name: string;
     content: string;
 }
+/**
+ * Structured file representation for code generation.
+ * Separates imports, local references, and body content to enable
+ * clean bundling without string parsing.
+ */
+export interface GeneratedFile {
+    name: string;
+    /** External imports (e.g., "@colyseus/schema", "Colyseus.Schema") */
+    imports: string[];
+    /** References to other generated classes (used for imports in non-bundle mode) */
+    localRefs: string[];
+    /** The class/interface/enum definition body (without imports or namespace wrapper) */
+    body: string;
+}
 export declare function getInheritanceTree(klass: Class, allClasses: Class[], includeSelf?: boolean): Class[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/schema",
-  "version": "4.0.13",
+  "version": "4.0.14",
   "description": "Binary state serializer with delta encoding for games",
   "type": "module",
   "bin": {

package/src/codegen/api.ts

@@ -5,21 +5,24 @@ import { File } from "./types.js";
 import { parseFiles } from "./parser.js";
 
 // Statically import all language generators (for bundling)
-import { generate as csharp } from "./languages/csharp.js";
-import { generate as cpp } from "./languages/cpp.js";
-import { generate as haxe } from "./languages/haxe.js";
-import { generate as ts } from "./languages/ts.js";
-import { generate as js } from "./languages/js.js";
-import { generate as java } from "./languages/java.js";
-import { generate as lua } from "./languages/lua.js";
+import * as csharp from "./languages/csharp.js";
+import * as cpp from "./languages/cpp.js";
+import * as haxe from "./languages/haxe.js";
+import * as ts from "./languages/ts.js";
+import * as js from "./languages/js.js";
+import * as java from "./languages/java.js";
+import * as lua from "./languages/lua.js";
+import * as c from "./languages/c.js";
+import * as gdscript from "./languages/gdscript.js";
 
-const generators: Record<string, Function> = { csharp, cpp, haxe, ts, js, java, lua, };
+export const generators: Record<string, any> = { csharp, cpp, haxe, ts, js, java, lua, c, gdscript, };
 
 export interface GenerateOptions {
     files: string[],
     output: string;
     decorator?: string;
     namespace?: string;
+    bundle?: boolean;
 }
 
 export function generate(targetId: string, options: GenerateOptions) {
@@ -54,13 +57,21 @@ export function generate(targetId: string, options: GenerateOptions) {
     // Post-process classes before generating
     structures.classes.forEach(klass => klass.postProcessing());
 
-    const files = generator(structures, options);
-
-    files.forEach((file: File) => {
-        const outputPath = path.resolve(options.output, file.name);
-        fs.writeFileSync(outputPath, file.content);
-        console.log("generated:", file.name);
-    });
+    if (options.bundle && generator.renderBundle) {
+        // Bundle mode: generate all classes/interfaces/enums into a single file
+        const bundled = generator.renderBundle(structures, options);
+        const outputPath = path.resolve(options.output, bundled.name);
+        fs.writeFileSync(outputPath, bundled.content);
+        console.log("generated (bundled):", bundled.name);
+    } else {
+        // Standard mode: write individual files
+        const generatedFiles = generator.generate(structures, options);
+        generatedFiles.forEach((file: File) => {
+            const outputPath = path.resolve(options.output, file.name);
+            fs.writeFileSync(outputPath, file.content);
+            console.log("generated:", file.name);
+        });
+    }
 }
 
 function recursiveFiles(dir: string): string[] {

package/src/codegen/cli.ts

@@ -1,15 +1,5 @@
 import argv from "./argv.js";
-import { generate } from "./api.js";
-
-const supportedTargets: Record<string, string> = {
-    csharp: 'generate for C#/Unity',
-    cpp: 'generate for C++',
-    haxe: 'generate for Haxe',
-    ts: 'generate for TypeScript',
-    js: 'generate for JavaScript',
-    java: 'generate for Java',
-    lua: 'generate for LUA',
-}
+import { generate, generators } from "./api.js";
 
 function displayHelp() {
     console.log(`\nschema-codegen [path/to/Schema.ts]
@@ -19,10 +9,13 @@ Usage (C#/Unity)
 
 Valid options:
     --output: the output directory for generated client-side schema files
+    --bundle: bundle all generated files into a single file
+
+Generators:
 ${Object.
-    keys(supportedTargets).
+    keys(generators).
     map((targetId) => (
-`    --${targetId}: ${supportedTargets[targetId]}`
+`    --${targetId}: generate for ${generators[targetId].name}`
     )).
     join("\n")}
 
@@ -38,7 +31,7 @@ if (args.help) {
 }
 
 let targetId: string;
-for (let target in supportedTargets) {
+for (let target in generators) {
     if (args[target]) {
         targetId = target;
     }
@@ -55,7 +48,8 @@ try {
         files: args._,
         decorator: args.decorator,
         output: args.output,
-        namespace: args.namespace
+        namespace: args.namespace,
+        bundle: args.bundle
     });
 
 } catch (e) {

package/src/codegen/languages/c.ts

@@ -0,0 +1,282 @@
+import { Class, Property, File, getCommentHeader, getInheritanceTree, Context } from "../types.js";
+import { GenerateOptions } from "../api.js";
+
+export const name = "C";
+
+/**
+ * Type mappings for C
+ */
+const typeMaps: { [key: string]: string } = {
+    "string": "char*",
+    "number": "double",
+    "boolean": "bool",
+    "int8": "int8_t",
+    "uint8": "uint8_t",
+    "int16": "int16_t",
+    "uint16": "uint16_t",
+    "int32": "int32_t",
+    "uint32": "uint32_t",
+    "int64": "int64_t",
+    "uint64": "uint64_t",
+    "float32": "float",
+    "float64": "double",
+};
+
+/**
+ * Colyseus field type enum mappings
+ */
+const fieldTypeMaps: { [key: string]: string } = {
+    "string": "COLYSEUS_FIELD_STRING",
+    "number": "COLYSEUS_FIELD_NUMBER",
+    "boolean": "COLYSEUS_FIELD_BOOLEAN",
+    "int8": "COLYSEUS_FIELD_INT8",
+    "uint8": "COLYSEUS_FIELD_UINT8",
+    "int16": "COLYSEUS_FIELD_INT16",
+    "uint16": "COLYSEUS_FIELD_UINT16",
+    "int32": "COLYSEUS_FIELD_INT32",
+    "uint32": "COLYSEUS_FIELD_UINT32",
+    "int64": "COLYSEUS_FIELD_INT64",
+    "uint64": "COLYSEUS_FIELD_UINT64",
+    "float32": "COLYSEUS_FIELD_FLOAT32",
+    "float64": "COLYSEUS_FIELD_FLOAT64",
+    "ref": "COLYSEUS_FIELD_REF",
+    "array": "COLYSEUS_FIELD_ARRAY",
+    "map": "COLYSEUS_FIELD_MAP",
+};
+
+const COMMON_INCLUDES = `#include "colyseus/schema/types.h"
+#include "colyseus/schema/collections.h"
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdbool.h>`;
+
+/**
+ * Native C Code Generator
+ */
+
+const toSnakeCase = (s: string) => {
+    return s.replace(/([A-Z])/g, (match, p1, offset) =>
+        (offset > 0 ? '_' : '') + p1.toLowerCase()
+    );
+};
+
+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: toSnakeCase(klass.name) + ".h",
+        content: generateClass(klass, options.namespace, context.classes)
+    }));
+}
+
+/**
+ * Generate a single bundled header file containing all classes
+ */
+export function renderBundle(context: Context, options: GenerateOptions): File {
+    const fileName = options.namespace ? `${toSnakeCase(options.namespace)}.h` : "schema.h";
+    const guardName = `__SCHEMA_CODEGEN_${(options.namespace || "SCHEMA").toUpperCase()}_H__`;
+
+    const classBodies = context.classes.map(klass =>
+        generateClassBody(klass, context.classes)
+    ).join("\n\n");
+
+    const content = `${getCommentHeader()}
+#ifndef ${guardName}
+#define ${guardName} 1
+
+${COMMON_INCLUDES}
+
+${classBodies}
+
+#endif
+`;
+
+    return { name: fileName, content };
+}
+
+/**
+ * Generate just the class body (without guards/includes) for bundling
+ */
+function generateClassBody(klass: Class, allClasses: Class[]): string {
+    const snakeName = toSnakeCase(klass.name);
+    const typeName = `${snakeName}_t`;
+    const allProperties = getAllProperties(klass, allClasses);
+
+    return `${generateTypedef(klass, typeName, allClasses)}
+
+${generateFieldsArray(klass, typeName, snakeName, allProperties)}
+
+${generateCreateFunction(snakeName, typeName)}
+
+${generateDestroyFunction(klass, snakeName, typeName, allProperties)}
+
+${generateVtable(klass, snakeName, typeName, allProperties)}`;
+}
+
+/**
+ * Generate a complete class file with guards/includes (for individual file mode)
+ */
+function generateClass(klass: Class, namespace: string, allClasses: Class[]) {
+    const snakeName = toSnakeCase(klass.name);
+    const typeName = `${snakeName}_t`;
+    const guardName = `__SCHEMA_CODEGEN_${klass.name.toUpperCase()}_H__`;
+
+    const allRefs: Property[] = [];
+
+    klass.properties.forEach(property => {
+        if (property.type === "ref" || property.type === "array" || property.type === "map") {
+            allRefs.push(property);
+        }
+    });
+
+    // Generate includes for referenced schema types
+    const refIncludes = allRefs
+        .filter(ref => ref.childType && typeMaps[ref.childType] === undefined)
+        .map(ref => ref.childType)
+        .concat(getInheritanceTree(klass, allClasses, false).map(k => k.name))
+        .filter(distinct)
+        .map(childType => `#include "${toSnakeCase(childType)}.h"`)
+        .join("\n");
+
+    return `${getCommentHeader()}
+#ifndef ${guardName}
+#define ${guardName} 1
+
+${COMMON_INCLUDES}
+${refIncludes ? `\n${refIncludes}\n` : ""}
+${generateClassBody(klass, allClasses)}
+
+#endif
+`;
+}
+
+function generateTypedef(klass: Class, typeName: string, allClasses: Class[]) {
+    const allProperties = getAllProperties(klass, allClasses);
+
+    const fields = allProperties.map(prop => {
+        const cType = getCType(prop);
+        return `    ${cType} ${prop.name};`;
+    }).join("\n");
+
+    return `typedef struct {
+    colyseus_schema_t __base;
+${fields}
+} ${typeName};`;
+}
+
+function getCType(prop: Property): string {
+    if (prop.type === "ref") {
+        return `${toSnakeCase(prop.childType)}_t*`;
+    } else if (prop.type === "array") {
+        if (typeMaps[prop.childType]) {
+            return `colyseus_array_schema_t*`;
+        } else {
+            return `colyseus_array_schema_t*`;
+        }
+    } else if (prop.type === "map") {
+        if (typeMaps[prop.childType]) {
+            return `colyseus_map_schema_t*`;
+        } else {
+            return `colyseus_map_schema_t*`;
+        }
+    } else {
+        return typeMaps[prop.type] || `${toSnakeCase(prop.type)}_t*`;
+    }
+}
+
+function getFieldType(prop: Property): string {
+    return fieldTypeMaps[prop.type] || "COLYSEUS_FIELD_REF";
+}
+
+function getFieldTypeString(prop: Property): string {
+    // Always return the type itself (ref, array, map, string, number, etc.)
+    return prop.type;
+}
+
+function generateFieldsArray(klass: Class, typeName: string, snakeName: string, allProperties: Property[]) {
+    if (allProperties.length === 0) {
+        return `static const colyseus_field_t ${snakeName}_fields[] = {};`;
+    }
+
+    const fields = allProperties.map((prop, i) => {
+        const fieldType = getFieldType(prop);
+        const typeString = getFieldTypeString(prop);
+
+        let vtableRef = "NULL";
+
+        if (prop.type === "ref" && prop.childType && !typeMaps[prop.childType]) {
+            const childSnake = toSnakeCase(prop.childType);
+            vtableRef = `&${childSnake}_vtable`;
+        } else if ((prop.type === "array" || prop.type === "map") && prop.childType && !typeMaps[prop.childType]) {
+            const childSnake = toSnakeCase(prop.childType);
+            vtableRef = `&${childSnake}_vtable`;
+        }
+
+        return `    {${prop.index}, "${prop.name}", ${fieldType}, "${typeString}", offsetof(${typeName}, ${prop.name}), ${vtableRef}, NULL}`;
+    }).join(",\n");
+
+    return `static const colyseus_field_t ${snakeName}_fields[] = {
+${fields}
+};`;
+}
+
+function generateCreateFunction(snakeName: string, typeName: string) {
+    return `static ${typeName}* ${snakeName}_create(void) {
+    ${typeName}* instance = calloc(1, sizeof(${typeName}));
+    return instance;
+}`;
+}
+
+function generateDestroyFunction(klass: Class, snakeName: string, typeName: string, allProperties: Property[]) {
+    const freeStatements: string[] = [];
+
+    allProperties.forEach(prop => {
+        if (prop.type === "string") {
+            freeStatements.push(`    if (instance->${prop.name}) free(instance->${prop.name});`);
+        } else if (prop.type === "ref") {
+            if (typeMaps[prop.childType]) {
+                freeStatements.push(`    if (instance->${prop.name}) free(instance->${prop.name});`);
+            } else {
+                const childSnake = toSnakeCase(prop.childType);
+                freeStatements.push(`    if (instance->${prop.name}) ${childSnake}_destroy((colyseus_schema_t*)instance->${prop.name});`);
+            }
+        } else if (prop.type === "array" || prop.type === "map") {
+            // arrays and maps are scheduled for destruction at the decoder level
+            // freeStatements.push(`    if (instance->${prop.name}) colyseus_${prop.type}_destroy(instance->${prop.name});`);
+        }
+    });
+
+    const freeCode = freeStatements.length > 0 ? freeStatements.join("\n") + "\n" : "";
+
+    return `static void ${snakeName}_destroy(colyseus_schema_t* schema) {
+    ${typeName}* instance = (${typeName}*)schema;
+${freeCode}    free(instance);
+}`;
+}
+
+function generateVtable(klass: Class, snakeName: string, typeName: string, allProperties: Property[]) {
+    const fieldCount = allProperties.length;
+
+    return `static const colyseus_schema_vtable_t ${snakeName}_vtable = {
+    "${klass.name}",
+    sizeof(${typeName}),
+    (colyseus_schema_t* (*)(void))${snakeName}_create,
+    ${snakeName}_destroy,
+    ${snakeName}_fields,
+    ${fieldCount}
+};`;
+}
+
+function getAllProperties(klass: Class, allClasses: Class[]) {
+    let properties: Property[] = [];
+
+    getInheritanceTree(klass, allClasses).reverse().forEach((k) => {
+        properties = properties.concat(k.properties);
+    });
+
+    return properties;
+}

package/src/codegen/languages/cpp.ts

@@ -1,6 +1,8 @@
 import { Class, Property, File, getCommentHeader, getInheritanceTree, Context } from "../types.js";
 import { GenerateOptions } from "../api.js";
 
+export const name = "C++";
+
 const typeMaps: { [key: string]: string } = {
     "string": "string",
     "number": "varint_t",
@@ -33,6 +35,12 @@ const typeInitializer: { [key: string]: string } = {
     "float64": "0",
 }
 
+const COMMON_INCLUDES = `#include "schema.h"
+#include <typeinfo>
+#include <typeindex>
+
+using namespace colyseus::schema;`;
+
 /**
  * C++ Code Generator
  */
@@ -44,6 +52,9 @@ const capitalize = (s: string) => {
 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 + ".hpp",
@@ -51,7 +62,35 @@ export function generate (context: Context, options: GenerateOptions): File[] {
     }));
 }
 
-function generateClass(klass: Class, namespace: string, allClasses: Class[]) {
+/**
+ * Generate a single bundled header file containing all classes
+ */
+export function renderBundle(context: Context, options: GenerateOptions): File {
+    const fileName = options.namespace ? `${options.namespace}.hpp` : "schema.hpp";
+    const guardName = `__SCHEMA_CODEGEN_${(options.namespace || "SCHEMA").toUpperCase()}_H__`;
+
+    const classBodies = context.classes.map(klass => generateClassBody(klass, context.classes, options.namespace));
+
+    const content = `${getCommentHeader()}
+#ifndef ${guardName}
+#define ${guardName} 1
+
+${COMMON_INCLUDES}
+
+${options.namespace ? `namespace ${options.namespace} {\n` : ""}
+${classBodies.join("\n\n")}
+${options.namespace ? "}" : ""}
+
+#endif
+`;
+
+    return { name: fileName, content };
+}
+
+/**
+ * Generate just the class body (without includes/guards) for bundling
+ */
+function generateClassBody(klass: Class, allClasses: Class[], namespace: string): string {
     const propertiesPerType: {[type: string]: Property[]} = {};
     const allRefs: Property[] = [];
     klass.properties.forEach(property => {
@@ -79,26 +118,7 @@ function generateClass(klass: Class, namespace: string, allClasses: Class[]) {
 \t\treturn ${klass.extends}::createInstance(type);
 \t}`;
 
-    return `${getCommentHeader()}
-#ifndef __SCHEMA_CODEGEN_${klass.name.toUpperCase()}_H__
-#define __SCHEMA_CODEGEN_${klass.name.toUpperCase()}_H__ 1
-
-#include "schema.h"
-#include <typeinfo>
-#include <typeindex>
-
-${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 => `#include "${childType}.hpp"`).
-    join("\n")}
-
-using namespace colyseus::schema;
-
-${namespace ? `namespace ${namespace} {` : ""}
-class ${klass.name} : public ${klass.extends} {
+    return `class ${klass.name} : public ${klass.extends} {
 public:
 ${klass.properties.map(prop => generateProperty(prop)).join("\n")}
 
@@ -119,7 +139,39 @@ ${Object.keys(propertiesPerType).map(type =>
     join("\n")}
 
 ${createInstanceMethod}
-};
+};`;
+}
+
+/**
+ * Generate a complete class file with includes/guards (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);
+        }
+    });
+
+    const localIncludes = 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 => `#include "${childType}.hpp"`).
+        join("\n");
+
+    return `${getCommentHeader()}
+#ifndef __SCHEMA_CODEGEN_${klass.name.toUpperCase()}_H__
+#define __SCHEMA_CODEGEN_${klass.name.toUpperCase()}_H__ 1
+
+${COMMON_INCLUDES}
+${localIncludes}
+
+${namespace ? `namespace ${namespace} {` : ""}
+${generateClassBody(klass, allClasses, namespace)}
 ${namespace ? "}" : ""}
 
 #endif