@colyseus/schema 2.0.4 → 2.0.6

package/src/codegen/languages/csharp.ts

@@ -0,0 +1,208 @@
+import {
+    Class,
+    Property,
+    File,
+    getCommentHeader,
+    Interface,
+    Enum,
+} from "../types";
+import { GenerateOptions } from "../api";
+import { Context } from "../types";
+
+const typeMaps = {
+    "string": "string",
+    "number": "float",
+    "boolean": "bool",
+    "int8": "sbyte",
+    "uint8": "byte",
+    "int16": "short",
+    "uint16": "ushort",
+    "int32": "int",
+    "uint32": "uint",
+    "int64": "long",
+    "uint64": "ulong",
+    "float32": "float",
+    "float64": "double",
+}
+
+/**
+ * C# Code Generator
+ */
+const capitalize = (s) => {
+    if (typeof s !== 'string') return ''
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+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(structure => ({
+            name: `${structure.name}.cs`,
+            content: generateClass(structure, options.namespace)
+        })),
+        ...context.interfaces.map(structure => ({
+            name: `${structure.name}.cs`,
+            content: generateInterface(structure, options.namespace),
+        })),
+        ...context.enums.filter(structure => structure.name !== 'OPERATION').map((structure) => ({
+            name: `${structure.name}.cs`,
+            content: generateEnum(structure, options.namespace),
+        })),
+    ];
+}
+
+function generateClass(klass: Class, namespace: string) {
+    const indent = (namespace) ? "\t" : "";
+    return `${getCommentHeader()}
+
+using Colyseus.Schema;
+using Action = System.Action;
+${namespace ? `\nnamespace ${namespace} {` : ""}
+${indent}public partial class ${klass.name} : ${klass.extends} {
+${klass.properties.map((prop) => generateProperty(prop, indent)).join("\n\n")}
+
+${indent}\t/*
+${indent}\t * Support for individual property change callbacks below...
+${indent}\t */
+
+${generateAllFieldCallbacks(klass, indent)}
+${indent}}
+${namespace ? "}" : ""}
+`;
+}
+
+function generateEnum(_enum: Enum, namespace: string) {
+    const indent = namespace ? "\t" : "";
+    return `${getCommentHeader()}
+${namespace ? `\nnamespace ${namespace} {` : ""}
+${indent}public struct ${_enum.name} {
+
+${_enum.properties
+    .map((prop) => {
+        let dataType: string = "int";
+        let value: any;
+
+        if(prop.type) {
+            if(isNaN(Number(prop.type))) {
+                value = prop.type;
+                dataType = "string";
+            } else {
+                value = Number(prop.type);
+                dataType = Number.isInteger(value)? 'int': 'float';
+            }
+        } else {
+            value = _enum.properties.indexOf(prop);
+        }
+        return `${indent}\tpublic const ${dataType} ${prop.name} = ${value};`;
+    })
+        .join("\n")}
+${indent}}`
+}
+
+function generateProperty(prop: Property, indent: string = "") {
+    let typeArgs = `"${prop.type}"`;
+    let property = "public";
+    let langType: string;
+    let initializer = "";
+
+    if (prop.childType) {
+        const isUpcaseFirst = prop.childType.match(/^[A-Z]/);
+
+        langType = getType(prop);
+        typeArgs += `, typeof(${langType})`;
+
+        if (!isUpcaseFirst) {
+            typeArgs += `, "${prop.childType}"`;
+        }
+
+        initializer = `new ${langType}()`;
+
+    } else {
+        langType = getType(prop);
+        initializer = `default(${langType})`;
+    }
+
+    property += ` ${langType} ${prop.name}`;
+
+    let ret = (prop.deprecated) ? `\t\t[System.Obsolete("field '${prop.name}' is deprecated.", true)]\n` : '';
+
+    return ret + `\t${indent}[Type(${prop.index}, ${typeArgs})]
+\t${indent}${property} = ${initializer};`;
+}
+
+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}}
+${namespace ? "}" : ""}
+`;
+}
+
+function generateAllFieldCallbacks(klass: Class, indent: string) {
+    //
+    // TODO: improve me. It would be great to generate less boilerplate in favor
+    // of a single implementation on C# Schema class itself.
+    //
+    const eventNames: string[] = [];
+    return `${klass.properties
+        .filter(prop => !prop.deprecated) // generate only for properties that haven't been deprecated.
+        .map(prop => {
+        const eventName = `_${prop.name}Change`;
+        eventNames.push(eventName);
+        return `\t${indent}protected event PropertyChangeHandler<${getType(prop)}> ${eventName};
+\t${indent}public Action On${capitalize(prop.name)}Change(PropertyChangeHandler<${getType(prop)}> handler) {
+\t${indent}\tif (__callbacks == null) { __callbacks = new SchemaCallbacks(); }
+\t${indent}\t__callbacks.AddPropertyCallback(nameof(${prop.name}));
+\t${indent}\t${eventName} += handler;
+\t${indent}\treturn () => {
+\t${indent}\t\t__callbacks.RemovePropertyCallback(nameof(${prop.name}));
+\t${indent}\t\t${eventName} -= handler;
+\t${indent}\t};
+\t${indent}}`;
+    }).join("\n\n")}
+
+\t${indent}protected override void TriggerFieldChange(DataChange change) {
+\t${indent}\tswitch (change.Field) {
+${klass.properties.filter(prop => !prop.deprecated).map((prop, i) => {
+    return `\t${indent}\t\tcase nameof(${prop.name}): ${eventNames[i]}?.Invoke((${getType(prop)}) change.Value, (${getType(prop)}) change.PreviousValue); break;`;
+}).join("\n")}
+\t${indent}\t\tdefault: break;
+\t\t${indent}}
+\t${indent}}`;
+}
+
+function getChildType(prop: Property) {
+    return typeMaps[prop.childType];
+}
+
+function getType(prop: Property) {
+    if (prop.childType) {
+        const isUpcaseFirst = prop.childType.match(/^[A-Z]/);
+        let type: string;
+
+        if(prop.type === "ref") {
+            type = (isUpcaseFirst)
+                ? prop.childType
+                : getChildType(prop);
+        } else {
+            const containerClass = capitalize(prop.type);
+            type = (isUpcaseFirst)
+                ? `${containerClass}Schema<${prop.childType}>`
+                : `${containerClass}Schema<${getChildType(prop)}>`;
+        }
+        return type;
+
+    } else {
+        return (prop.type === "array")
+            ? `${typeMaps[prop.childType] || prop.childType}[]`
+            : typeMaps[prop.type];
+    }
+}

package/src/codegen/languages/haxe.ts

@@ -0,0 +1,110 @@
+import { Class, Property, File, getCommentHeader, Context } from "../types";
+import { GenerateOptions } from "../api";
+
+const typeMaps = {
+    "string": "String",
+    "number": "Dynamic",
+    "boolean": "Bool",
+    "int8": "Int",
+    "uint8": "UInt",
+    "int16": "Int",
+    "uint16": "UInt",
+    "int32": "Int",
+    "uint32": "UInt",
+    "int64": "Int",
+    "uint64": "UInt",
+    "float32": "Float",
+    "float64": "Float",
+}
+
+const typeInitializer = {
+    "string": '""',
+    "number": "0",
+    "boolean": "false",
+    "int8": "0",
+    "uint8": "0",
+    "int16": "0",
+    "uint16": "0",
+    "int32": "0",
+    "uint32": "0",
+    "int64": "0",
+    "uint64": "0",
+    "float32": "0",
+    "float64": "0",
+}
+
+export function generate (context: Context, options: GenerateOptions): File[] {
+    return context.classes.map(klass => ({
+        name: klass.name + ".hx",
+        content: generateClass(klass, options.namespace, context.classes)
+    }));
+}
+
+function getInheritanceTree(klass: Class, allClasses: Class[], includeSelf: boolean = true) {
+    let currentClass = klass;
+    let inheritanceTree: Class[] = [];
+
+    if (includeSelf) {
+        inheritanceTree.push(currentClass);
+    }
+
+    while (currentClass.extends !== "Schema") {
+        currentClass = allClasses.find(klass => klass.name == currentClass.extends);
+        inheritanceTree.push(currentClass);
+    }
+
+    return inheritanceTree;
+}
+
+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.*;
+
+class ${klass.name} extends ${klass.extends} {
+${klass.properties.map(prop => generateProperty(prop)).join("\n")}
+}
+`;
+}
+
+function generateProperty(prop: Property) {
+    let langType: string;
+    let initializer = "";
+    let typeArgs = `"${prop.type}"`;
+
+    if (prop.childType) {
+        const isUpcaseFirst = prop.childType.match(/^[A-Z]/);
+
+        if (isUpcaseFirst) {
+            typeArgs += `, ${prop.childType}`;
+
+        } else {
+            typeArgs += `, "${prop.childType}"`;
+        }
+
+        if(prop.type === "ref") {
+            langType = `${prop.childType}`;
+            initializer = `new ${prop.childType}()`;
+
+        } else if(prop.type === "array") {
+            langType = (isUpcaseFirst)
+                ? `ArraySchema<${prop.childType}>`
+                : `ArraySchema<${typeMaps[prop.childType]}>`;
+            initializer = `new ${langType}()`;
+
+        } else if(prop.type === "map") {
+            langType = (isUpcaseFirst)
+                ? `MapSchema<${prop.childType}>`
+                : `MapSchema<${typeMaps[prop.childType]}>`;
+            initializer = `new ${langType}()`;
+        }
+
+    } else {
+        langType = typeMaps[prop.type];
+        initializer = typeInitializer[prop.type];
+    }
+
+    return `\t@:type(${typeArgs})\n\tpublic var ${prop.name}: ${langType} = ${initializer};\n`
+}

package/src/codegen/languages/java.ts

@@ -0,0 +1,115 @@
+import { Class, Property, File, getCommentHeader, Context } from "../types";
+import { GenerateOptions } from "../api";
+
+const typeMaps = {
+    "string": "String",
+    "number": "float",
+    "boolean": "boolean",
+    "int8": "byte",
+    "uint8": "short",
+    "int16": "short",
+    "uint16": "int",
+    "int32": "int",
+    "uint32": "long",
+    "int64": "long",
+    "uint64": "long",
+    "float32": "float",
+    "float64": "double",
+}
+
+const typeInitializer = {
+    "string": '""',
+    "number": "0",
+    "boolean": "false",
+    "int8": "0",
+    "uint8": "0",
+    "int16": "0",
+    "uint16": "0",
+    "int32": "0",
+    "uint32": "0",
+    "int64": "0",
+    "uint64": "0",
+    "float32": "0",
+    "float64": "0",
+}
+
+/**
+ * C# Code Generator
+ */
+
+export function generate (context: Context, options: GenerateOptions): File[] {
+    return context.classes.map(klass => ({
+        name: klass.name + ".java",
+        content: generateClass(klass, options.namespace)
+    }));
+}
+
+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;
+
+@SchemaClass
+${indent}public class ${klass.name} extends ${klass.extends} {
+${klass.properties.map(prop => generateProperty(prop, indent)).join("\n\n")}
+${indent}}
+${namespace ? "}" : ""}
+`;
+}
+
+function generateProperty(prop: Property, indent: string = "") {
+    let typeArgs = `${prop.index}/${prop.type}`;
+    let property = "public";
+    let langType: string;
+    let ctorArgs: string = "";
+    let initializer = "";
+
+    if (prop.childType) {
+        const isUpcaseFirst = prop.childType.match(/^[A-Z]/);
+
+        if (prop.type !== "ref" && isUpcaseFirst) {
+            ctorArgs = `${prop.childType}.class`;
+        }
+
+        if(prop.type === "ref") {
+            langType = (isUpcaseFirst)
+                ? prop.childType
+                : typeMaps[prop.childType];
+
+            initializer = `new ${langType}${(prop.type !== "ref" && isUpcaseFirst) ? "<>" : ""}(${ctorArgs})`;
+
+        } else if(prop.type === "array") {
+            langType = (isUpcaseFirst)
+                ? `ArraySchema<${prop.childType}>`
+                : `ArraySchema`;
+
+            initializer = `new ArraySchema${(isUpcaseFirst) ? "<>" : ""}(${ctorArgs})`;
+
+        } else if(prop.type === "map") {
+            langType = (isUpcaseFirst)
+                ? `MapSchema<${prop.childType}>`
+                : `MapSchema`;
+
+            initializer = `new MapSchema${(isUpcaseFirst) ? "<>" : ""}(${ctorArgs})`;
+        }
+
+        if (prop.type !== "ref") {
+            typeArgs += (isUpcaseFirst)
+                ? `/ref`
+                : `/${prop.childType}`;
+        }
+
+    } else {
+        langType = typeMaps[prop.type];
+        initializer = typeInitializer[prop.type];
+    }
+
+    property += ` ${langType} ${prop.name}`;
+
+    return `\t@SchemaField("${typeArgs}")\t${indent}
+\t${indent}${property} = ${initializer};`
+}

package/src/codegen/languages/js.ts

@@ -0,0 +1,115 @@
+import { Class, Property, File, getCommentHeader, getInheritanceTree, Context } from "../types";
+import { GenerateOptions } from "../api";
+
+const typeMaps = {
+    "string": "string",
+    "number": "number",
+    "boolean": "boolean",
+    "int8": "number",
+    "uint8": "number",
+    "int16": "number",
+    "uint16": "number",
+    "int32": "number",
+    "uint32": "number",
+    "int64": "number",
+    "uint64": "number",
+    "float32": "number",
+    "float64": "number",
+}
+
+const distinct = (value, index, self) => self.indexOf(value) === index;
+
+export function generate (context: Context, options: GenerateOptions): File[] {
+    return context.classes.map(klass => ({
+        name: klass.name + ".js",
+        content: generateClass(klass, options.namespace, context.classes)
+    }));
+}
+
+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);
+        }
+    });
+
+    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")}
+
+export default ${klass.name};
+`;
+}
+
+function generatePropertyDeclaration(className: string, prop: Property) {
+    let typeArgs: string;
+
+    if (prop.childType) {
+        const isUpcaseFirst = prop.childType.match(/^[A-Z]/);
+
+        if (isUpcaseFirst) {
+            typeArgs += `, ${prop.childType}`;
+
+        } else {
+            typeArgs += `, "${prop.childType}"`;
+        }
+
+        if(prop.type === "ref") {
+            typeArgs = `${prop.childType}`;
+
+        } else if(prop.type === "array") {
+            typeArgs = (isUpcaseFirst)
+                ? `[ ${prop.childType} ]`
+                : `[ "${prop.childType}" ]`;
+
+        } else if(prop.type === "map") {
+            typeArgs = (isUpcaseFirst)
+                ? `{ map: ${prop.childType} }`
+                : `{ map: "${prop.childType}" }`;
+        }
+
+    } else {
+        typeArgs = `"${prop.type}"`;
+    }
+
+    return `type(${typeArgs})(${className}.prototype, "${prop.name}");`;
+}
+
+function generatePropertyInitializer(prop: Property) {
+    let initializer = "";
+
+    if(prop.type === "ref") {
+        initializer = `new ${prop.childType}()`;
+
+    } else if(prop.type === "array") {
+        initializer = `new schema.ArraySchema()`;
+
+    } else if(prop.type === "map") {
+        initializer = `new schema.MapSchema()`;
+    }
+
+    return `this.${prop.name} = ${initializer}`;
+}

package/src/codegen/languages/lua.ts

@@ -0,0 +1,125 @@
+import { Class, Property, File, getCommentHeader, getInheritanceTree, Context } from "../types";
+import { GenerateOptions } from "../api";
+
+/**
+    TODO:
+    - Support inheritance
+    - Support importing Schema dependencies
+*/
+
+const typeMaps = {
+    "string": "string",
+    "number": "number",
+    "boolean": "boolean",
+    "int8": "number",
+    "uint8": "number",
+    "int16": "number",
+    "uint16": "number",
+    "int32": "number",
+    "uint32": "number",
+    "int64": "number",
+    "uint64": "number",
+    "float32": "number",
+    "float64": "number",
+}
+
+const distinct = (value, index, self) => self.indexOf(value) === index;
+
+export function generate (context: Context, options: GenerateOptions): File[] {
+    return context.classes.map(klass => ({
+        name: klass.name + ".lua",
+        content: generateClass(klass, options.namespace, context.classes)
+    }));
+}
+
+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);
+        }
+    });
+
+// TOOD: inheritance
+
+    return `${getCommentHeader().replace(/\/\//mg, "--")}
+
+local schema = require 'colyseus.serialization.schema.schema'
+${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 => `local ${childType} = require '${(namespace ? `${namespace}.` : '')}${childType}'`).
+    join("\n")}
+
+local ${klass.name} = schema.define({
+${klass.properties.map(prop => generatePropertyDeclaration(prop)).join(",\n")},
+    ["_fields_by_index"] = { ${klass.properties.map(prop => `"${prop.name}"`).join(", ")} },
+})
+
+return ${klass.name}
+`;
+
+    // ["on_change"] = function(changes)
+    //     -- on change logic here
+    // end,
+
+    // ["on_add"] = function()
+    //     -- on add logic here
+    //  end,
+
+    // ["on_remove"] = function()
+    //     -- on remove logic here
+    // end,
+}
+
+function generatePropertyDeclaration(prop: Property) {
+    let typeArgs: string;
+
+    if (prop.childType) {
+        const isUpcaseFirst = prop.childType.match(/^[A-Z]/);
+
+        if (isUpcaseFirst) {
+            typeArgs += `${prop.childType}`;
+
+        } else {
+            typeArgs += `"${prop.childType}"`;
+        }
+
+        if(prop.type === "ref") {
+            typeArgs = (isUpcaseFirst)
+                ? `${prop.childType}`
+                : `"${prop.childType}"`;
+
+        } else {
+            typeArgs = (isUpcaseFirst)
+                ? `{ ${prop.type} = ${prop.childType} }`
+                : `{ ${prop.type} = "${prop.childType}" }`;
+        }
+
+    } else {
+        typeArgs = `"${prop.type}"`;
+    }
+
+    return `    ["${prop.name}"] = ${typeArgs}`;
+}
+
+// function generatePropertyInitializer(prop: Property) {
+//     let initializer = "";
+
+//     if(prop.type === "ref") {
+//         initializer = `new ${prop.childType}()`;
+
+//     } else if(prop.type === "array") {
+//         initializer = `new schema.ArraySchema()`;
+
+//     } else if(prop.type === "map") {
+//         initializer = `new schema.MapSchema()`;
+//     }
+
+//     return `this.${prop.name} = ${initializer}`;
+// }