@colyseus/schema 1.0.44 → 1.0.46

package/src/codegen/languages/csharp.ts

@@ -1,4 +1,11 @@
-import { Class, Property, File, getCommentHeader, Interface } from "../types";
+import {
+    Class,
+    Property,
+    File,
+    getCommentHeader,
+    Interface,
+    Enum,
+} from "../types";
 import { GenerateOptions } from "../api";
 import { Context } from "../types";
 
@@ -26,7 +33,11 @@ const capitalize = (s) => {
     return s.charAt(0).toUpperCase() + s.slice(1);
 }
 
-export function generate (context: Context, options: GenerateOptions): File[] {
+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`,
@@ -34,8 +45,12 @@ export function generate (context: Context, options: GenerateOptions): File[] {
         })),
         ...context.interfaces.map(structure => ({
             name: `${structure.name}.cs`,
-            content: generateInterface(structure, options.namespace)
-        }))
+            content: generateInterface(structure, options.namespace),
+        })),
+        ...context.enums.filter(structure => structure.name !== 'OPERATION').map((structure) => ({
+            name: `${structure.name}.cs`,
+            content: generateEnum(structure, options.namespace),
+        })),
     ];
 }
 
@@ -46,12 +61,40 @@ function generateClass(klass: Class, namespace: string) {
 using Colyseus.Schema;
 ${namespace ? `\nnamespace ${namespace} {` : ""}
 ${indent}public partial class ${klass.name} : ${klass.extends} {
-${klass.properties.map(prop => generateProperty(prop, indent)).join("\n\n")}
+${klass.properties.map((prop) => generateProperty(prop, indent)).join("\n\n")}
 ${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";

package/src/codegen/parser.ts

@@ -1,7 +1,7 @@
 import * as ts from "typescript";
 import * as path from "path";
 import { readFileSync } from "fs";
-import { IStructure, Class, Interface, Property, Context } from "./types";
+import { IStructure, Class, Interface, Property, Context, Enum } from "./types";
 
 let currentStructure: IStructure;
 let currentProperty: Property;
@@ -62,6 +62,15 @@ function inspectNode(node: ts.Node, context: Context, decoratorName: string) {
             }
             break;
 
+        case ts.SyntaxKind.EnumDeclaration:
+            const enumName = (
+                node as ts.EnumDeclaration
+            ).name.escapedText.toString();
+            currentStructure = new Enum();
+            currentStructure.name = enumName;
+            context.addStructure(currentStructure);
+            break;
+
         case ts.SyntaxKind.ExtendsKeyword:
             // console.log(node.getText());
             break;
@@ -182,6 +191,20 @@ function inspectNode(node: ts.Node, context: Context, decoratorName: string) {
             currentProperty = undefined;
 
             break;
+
+        case ts.SyntaxKind.EnumMember:
+            if (currentStructure instanceof Enum) {
+                const initializer = (node as any).initializer?.getText();
+                const name = node.getFirstToken().getText();
+                const property = currentProperty || new Property();
+                property.name = name;
+                if (initializer !== undefined) {
+                    property.type = initializer;
+                }
+                currentStructure.addProperty(property);
+                currentProperty = undefined;
+            }
+            break;
     }
 
     ts.forEachChild(node, (n) => inspectNode(n, context, decoratorName));

package/src/codegen/types.ts

@@ -15,6 +15,7 @@ export function getCommentHeader(singleLineComment: string = "//") {
 export class Context {
     classes: Class[] = [];
     interfaces: Interface[] = [];
+    enums: Enum[] = [];
 
     getStructures() {
         return {
@@ -33,6 +34,7 @@ export class Context {
                 return false;
             }),
             interfaces: this.interfaces,
+            enums: this.enums,
         };
     }
 
@@ -41,9 +43,10 @@ export class Context {
 
         if (structure instanceof Class) {
             this.classes.push(structure);
-
         } else if (structure instanceof Interface) {
             this.interfaces.push(structure);
+        } else if (structure instanceof Enum) {
+            this.enums.push(structure);
         }
     }
 
@@ -134,6 +137,16 @@ export class Class implements IStructure {
     }
 }
 
+export class Enum implements IStructure {
+    context: Context;
+    name: string;
+    properties: Property[] = [];
+
+    addProperty(property: Property) {
+        this.properties.push(property);
+    }
+}
+
 export class Property {
     index: number;
     name: string;

package/src/types/ArraySchema.ts

@@ -492,9 +492,10 @@ export class ArraySchema<V=any> implements Array<V>, SchemaDecoderCallbacks {
         return Array.from(this.$items.values())[Symbol.iterator]();
     }
 
-    [Symbol.unscopables]() {
-        return this.$items[Symbol.unscopables]();
-    }
+    // WORKAROUND for compatibility
+    // - TypeScript 4 defines @@unscopables as a function
+    // - TypeScript 5 defines @@unscopables as an object
+    [Symbol.unscopables]: any;
 
     /**
      * Returns an iterable of key, value pairs for every entry in the array