@needle-tools/needle-component-compiler 1.0.0

package/COMPILE.bat

@@ -0,0 +1 @@
+npm run tsc src/component-compiler

package/INSTALL.bat

@@ -0,0 +1 @@
+npm install && timeout 10

package/RUNTEST.bat

@@ -0,0 +1 @@
+npm run tsc src/component-compiler && node src/component-compiler.js dist src/test.ts

package/Readme.md

@@ -0,0 +1,7 @@
+## Typescript to Unity component
+
+Little helper package to transpile typescript files to Unity C# components.  
+Please run ``npm install`` first before using.
+
+### Usage
+``node <path to>/component-compiler.js <output_directory> <path_to/my_script.ts>``

package/dist/GltfExport.cs

@@ -0,0 +1,11 @@
+// auto generated code - do not edit
+namespace Needle.Typescript.GeneratedComponents
+{
+	// source: C:\git\needle-tiny-playground\modules\needle-tiny\component-compiler\src\test.ts
+	public class GltfExport : UnityEngine.MonoBehaviour
+	{
+		public bool @binary = true;
+		[UnityEngine.ContextMenu("enable this")]
+		public void test(){}
+	}
+}

package/dist/GltfExportBox.cs

@@ -0,0 +1,11 @@
+// auto generated code - do not edit
+namespace Needle.Typescript.GeneratedComponents
+{
+	// source: C:\git\needle-tiny-playground\modules\needle-tiny\component-compiler\src\test.ts
+	public class GltfExportBox : UnityEngine.MonoBehaviour
+	{
+		public UnityEngine.Transform @sceneRoot;
+		public void start(){}
+		public void updateGltfBox(){}
+	}
+}

package/dist/MyArray.cs

@@ -0,0 +1,8 @@
+// auto generated code - do not edit
+namespace Needle.Typescript.GeneratedComponents
+{
+	public class MyArray : UnityEngine.MonoBehaviour
+	{
+		public float[] @arr = new float[]{ 1, 2, 3 };
+	}
+}

package/dist/MyClass.cs

@@ -0,0 +1,23 @@
+// auto generated code - do not edit
+namespace Needle.Typescript.GeneratedComponents
+{
+	// source: C:\git\needle-tiny-playground\projects\Compiled_Export\myProject\src\scripts\MyClass.ts
+	public class MyClass : UnityEngine.MonoBehaviour
+	{
+		public void start(){}
+		public float myFloat = 15;
+		public bool myBool;
+		// just some default values
+		public float[] myArray = new float[]{ 1, 2, 3 };
+		// comment for myString
+		public string myString = "this is a string";
+		public UnityEngine.Transform myObject;
+		public bool myBool2;
+		public void myFunction(){}
+		public void myFunctionWithStringParameter(string @string){}
+		public void myFunctionWithSomeObjectAndArray(UnityEngine.Transform @obj, float[] @arr){}
+		public void myFunctionWithoutParamTypes(object @test){}
+		public UnityEngine.Transform[] someOtherStuff;
+		public UnityEngine.Events.UnityEvent myEvent;
+	}
+}

package/dist/MyClassWithAFloat.cs

@@ -0,0 +1,10 @@
+// auto generated code - do not edit
+namespace Needle.Typescript.GeneratedComponents
+{
+	// source: C:\git\needle-tiny-playground\modules\needle-tiny\component-compiler\src\test.ts
+	public class MyClassWithAFloat : UnityEngine.MonoBehaviour
+	{
+		public float @myfloat = 0.5f;
+		private string @myString;
+	}
+}

package/dist/PrivateSerializedField.cs

@@ -0,0 +1,9 @@
+// auto generated code - do not edit
+namespace Needle.Typescript.GeneratedComponents
+{
+	public class PrivateSerializedField : UnityEngine.MonoBehaviour
+	{
+		[UnityEngine.SerializeField]
+		private UnityEngine.Color @color;
+	}
+}

package/dist/Test.cs

@@ -0,0 +1,8 @@
+// auto generated code - do not edit
+namespace Needle.Typescript.GeneratedComponents
+{
+	// source: C:\git\needle-tiny-playground\projects\Compiled_Export\myProject\src\scripts\SomeTestComponent.ts
+	public class Test : UnityEngine.MonoBehaviour
+	{
+	}
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+    "name": "@needle-tools/needle-component-compiler",
+    "version": "1.0.0",
+    "description": "Compile mock unity components from typescript",
+    "main": "index.js",
+    "scripts": {
+        "tsc": "tsc"
+    },
+    "dependencies": {
+        "typescript": "^4.5.5"
+    },
+    "devDependencies": {
+        "@types/node": "^17.0.16"
+    },
+    "author": {
+        "name": "Needle",
+        "email": "help@needle.tools",
+        "url": "https://needle.tools/"
+    },
+    "license": "ISC"
+}

package/src/component-compiler.js

@@ -0,0 +1,341 @@
+"use strict";
+exports.__esModule = true;
+exports.run = void 0;
+var fs_1 = require("fs");
+var ts = require("typescript");
+var fs = require("fs");
+var types = require("./types");
+var dict = types.dict;
+// add either of these two comments above a class to enforce code gen or disable it for the next class
+var exportNextClassCommand = "@generate-component";
+var dontExportNextClassCommand = "@dont-generate-component";
+// add above field to add [SerializeField] attribute
+var serializeCommand = "@serializeField";
+// will be set to true when e.g. a comment for export is found
+var exportNextClass = false;
+var dontExportNextClass = false;
+var serializeField = false;
+function resetExportNextClass() {
+    dontExportNextClass = false;
+    exportNextClass = false;
+}
+// https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API
+// const exportDir = "../dist";
+var commentStarts = [];
+var ExportContext = /** @class */ (function () {
+    function ExportContext(outputDir, fileName) {
+        this.classEnd = -1;
+        this.indentLevel = 0;
+        this.emitMethodContextMenu = null;
+        this.outputDir = outputDir;
+        this.fileName = fileName;
+        this.reset();
+    }
+    ExportContext.prototype.onBeforeMethod = function (name) {
+        if (this.emitMethodContextMenu !== undefined) {
+            var contextMenuText = this.emitMethodContextMenu === null ? name : this.emitMethodContextMenu;
+            this.appendLine("[UnityEngine.ContextMenu(\"" + contextMenuText + "\")]");
+        }
+    };
+    ExportContext.prototype.append = function (text) {
+        for (var i = 0; i < this.indentLevel; i++)
+            text = "\t" + text;
+        this.textBuffer += text;
+        this.emitMethodContextMenu = undefined;
+    };
+    ExportContext.prototype.appendLine = function (text) {
+        this.append(text + "\n");
+    };
+    ExportContext.prototype.flush = function () {
+        if (this.textBuffer.length <= 0)
+            return;
+        var dir = this.outputDir + "/";
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir);
+        }
+        var path = dir + this.fileName;
+        console.log("Write to " + path);
+        fs.writeFileSync(path, this.textBuffer);
+        this.reset();
+    };
+    ExportContext.prototype.reset = function () {
+        this.textBuffer = "";
+        this.classEnd = -1;
+    };
+    return ExportContext;
+}());
+var contexts = [];
+function run(program, outputDir, sourceFile) {
+    if (!fs.existsSync(outputDir)) {
+        console.error("Output directory does not exist: \"" + outputDir + "\"");
+        return;
+    }
+    traverseFile(sourceFile);
+    function traverseFile(node) {
+        visit(node);
+        ts.forEachChild(node, traverseFile);
+    }
+    function visit(node) {
+        var _a, _b, _c;
+        var context = contexts.length > 0 ? contexts[contexts.length - 1] : null;
+        if ((context === null || context === void 0 ? void 0 : context.classEnd) > 0 && node.pos >= (context === null || context === void 0 ? void 0 : context.classEnd)) {
+            while (context.indentLevel > 0) {
+                context.indentLevel -= 1;
+                context.append("}\n");
+            }
+            context.flush();
+            context = null;
+            contexts.pop();
+        }
+        console.log("\t", ts.SyntaxKind[node.kind]);
+        var commentRanges = ts.getLeadingCommentRanges(sourceFile.getFullText(), node.getFullStart());
+        if (commentRanges === null || commentRanges === void 0 ? void 0 : commentRanges.length) {
+            for (var _i = 0, commentRanges_1 = commentRanges; _i < commentRanges_1.length; _i++) {
+                var r = commentRanges_1[_i];
+                // avoid emitting comments multiple times
+                if (commentStarts.includes(r.pos))
+                    continue;
+                commentStarts.push(r.pos);
+                var comment = node.getSourceFile().getFullText().slice(r.pos, r.end);
+                if (context) {
+                    // https://regex101.com/r/ud4oev/1
+                    var emitContextMenu = comment.match("(\/{2,}|\/\*)\s*@contextmenu {0,}(?<text>[a-zA-Z 0-9]+)?");
+                    if (emitContextMenu) {
+                        context.emitMethodContextMenu = (_b = (_a = emitContextMenu.groups) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : null;
+                    }
+                    else if (comment.includes(serializeCommand))
+                        serializeField = true;
+                    else
+                        context.appendLine(comment);
+                }
+                if (comment.includes(exportNextClassCommand))
+                    exportNextClass = true;
+                if (comment.includes(dontExportNextClassCommand))
+                    dontExportNextClass = true;
+            }
+        }
+        switch (node.kind) {
+            // case ts.SyntaxKind.ClassDeclaration:
+            // case ts.SyntaxKind.SingleLineCommentTrivia:
+            //     console.log("comment: " + node.getText())
+            //     break;
+            case ts.SyntaxKind.Decorator:
+                break;
+            case ts.SyntaxKind.MethodDeclaration:
+                serializeField = false;
+                resetExportNextClass();
+                if (!context)
+                    break;
+                // TODO: always emit at least OnEnable method per class so generated components have toggle in editor
+                var meth = node;
+                // const isCoroutine = func.asteriskToken;
+                if (meth.name) {
+                    var paramsStr = "";
+                    for (var _d = 0, _e = meth.parameters; _d < _e.length; _d++) {
+                        var param = _e[_d];
+                        if (!param || !param.name)
+                            continue;
+                        if (paramsStr.length > 0)
+                            paramsStr += ", ";
+                        var type = tryResolveTypeRecursive(param);
+                        if (type === undefined)
+                            type = "object";
+                        paramsStr += type + " @" + param.name.getText();
+                    }
+                    var methodName = meth.name.getText();
+                    context.onBeforeMethod(methodName);
+                    context.append("public void " + methodName + "(" + paramsStr + "){}\n");
+                }
+                break;
+            case ts.SyntaxKind.SetAccessor:
+            case ts.SyntaxKind.PropertyDeclaration:
+                resetExportNextClass();
+                if (!context)
+                    break;
+                console.log("Found variable", node.getText());
+                var vardec = node;
+                var name_1 = vardec.name.getText();
+                console.log(name_1);
+                if (name_1.startsWith("\"@") || name_1.startsWith("\"$") || name_1.startsWith("$"))
+                    break;
+                var typeString = tryResolveTypeRecursive(node);
+                if (typeString === undefined) {
+                    context.append("// Could not resolve type \"" + ((_c = vardec.type) === null || _c === void 0 ? void 0 : _c.getText()) + "\"\n");
+                }
+                var prefix = typeString === undefined ? "// " : "";
+                var assignment = "";
+                if (typeString !== undefined) {
+                    for (var _f = 0, _g = node.getChildren(); _f < _g.length; _f++) {
+                        var ch = _g[_f];
+                        switch (ch.kind) {
+                            case ts.SyntaxKind.FalseKeyword:
+                            case ts.SyntaxKind.TrueKeyword:
+                                assignment = " = " + ch.getText();
+                                break;
+                            case ts.SyntaxKind.StringLiteral:
+                                var str = ch;
+                                assignment = " = \"" + str.text + "\"";
+                                break;
+                            case ts.SyntaxKind.FirstLiteralToken:
+                                var lit = ch;
+                                assignment = " = " + lit.text;
+                                if (ts.isNumericLiteral(lit))
+                                    assignment += "f";
+                                break;
+                            case ts.SyntaxKind.ArrayLiteralExpression:
+                                var arr = ch;
+                                assignment = " = new " + typeString + "{" + arr.elements.map(function (e) { return " " + e.getText(); }) + " }";
+                                break;
+                        }
+                    }
+                }
+                var varName = "@" + vardec.name.getText();
+                var pub = isPublic(vardec);
+                var visibility = pub ? "public" : "private";
+                if (!pub && serializeField) {
+                    console.log("SERIALIZE");
+                    context.appendLine("[UnityEngine.SerializeField]");
+                }
+                context.append(prefix + visibility + " " + typeString + " " + varName + assignment + ";\n");
+                break;
+            case ts.SyntaxKind.ClassDeclaration:
+                serializeField = false;
+                var dec = node;
+                // a class must inherit a component
+                if (!dontExportNextClass && (exportNextClass || testInheritsComponent(node))) {
+                    resetExportNextClass();
+                    var name_2 = dec.name.escapedText;
+                    console.log("Found class: ", name_2);
+                    var newContext = new ExportContext(outputDir, name_2 + ".cs");
+                    newContext.appendLine("// auto generated code - do not edit");
+                    newContext.appendLine("namespace Needle.Typescript.GeneratedComponents");
+                    newContext.appendLine("{");
+                    newContext.indentLevel += 1;
+                    // newContext.appendLine("// source: " + path.resolve(sourceFile.fileName));
+                    newContext.appendLine("public class " + name_2 + " : UnityEngine.MonoBehaviour");
+                    newContext.appendLine("{");
+                    newContext.indentLevel += 1;
+                    newContext.classEnd = dec.end;
+                    contexts.push(newContext);
+                }
+                break;
+        }
+        function testInheritsComponent(node) {
+            switch (node.kind) {
+                case ts.SyntaxKind.ClassDeclaration:
+                    var dec = node;
+                    if (dec.heritageClauses) {
+                        for (var _i = 0, _a = dec.heritageClauses; _i < _a.length; _i++) {
+                            var h = _a[_i];
+                            if (h.types.length <= 0)
+                                continue;
+                            for (var _b = 0, _c = h.types; _b < _c.length; _b++) {
+                                var type = _c[_b];
+                                // const symbol = program.getTypeChecker().getSymbolAtLocation(type.expression);
+                                // console.log(symbol);
+                                if (type.expression.getText() === "Component")
+                                    return true;
+                                if (type.expression.getText() === "Behaviour")
+                                    return true;
+                            }
+                        }
+                    }
+                    return false;
+            }
+            return false;
+        }
+        function isPublic(node) {
+            if (node.kind === ts.SyntaxKind.PublicKeyword) {
+                return true;
+            }
+            else if (node.kind === ts.SyntaxKind.PrivateKeyword) {
+                return false;
+            }
+            for (var _i = 0, _a = node.getChildren(); _i < _a.length; _i++) {
+                var ch = _a[_i];
+                if (!isPublic(ch))
+                    return false;
+            }
+            return true;
+        }
+        function tryResolveTypeRecursive(node) {
+            var _a;
+            if (!node)
+                return undefined;
+            // skip decorators (e.g. @serializable() may break array generation)
+            if (node.kind === ts.SyntaxKind.Decorator)
+                return undefined;
+            var typeName = node === null || node === void 0 ? void 0 : node.getText();
+            var varDec = node;
+            if (varDec.type) {
+                typeName = varDec.type.getText();
+            }
+            var res = dict[typeName];
+            if (res !== undefined) {
+                // console.log("FOUND " + res, ts.SyntaxKind[node.kind]);
+                // console.log(node);
+                return res;
+            }
+            // console.log("Unknown type: " + typeName);
+            switch (node.kind) {
+                case ts.SyntaxKind.SyntaxList:
+                    // const list = node as ts.SyntaxList;
+                    // for(const ch of list._children)
+                    //     res = tryResolveTypeRecursive(ch);
+                    break;
+                case ts.SyntaxKind.UnionType:
+                    var union = node;
+                    for (var _i = 0, _b = union.types; _i < _b.length; _i++) {
+                        var t = _b[_i];
+                        res = tryResolveTypeRecursive(t);
+                        if (res !== undefined)
+                            return res;
+                    }
+                    break;
+                case ts.SyntaxKind.ArrayType:
+                    var arrayType = node;
+                    var typeName_1 = (_a = arrayType.elementType) === null || _a === void 0 ? void 0 : _a.getText();
+                    if (typeName_1 !== undefined) {
+                        res = dict[typeName_1];
+                        if (res !== undefined) {
+                            res += "[]";
+                            return res;
+                        }
+                    }
+            }
+            for (var _c = 0, _d = node.getChildren(); _c < _d.length; _c++) {
+                var child = _d[_c];
+                if (res !== undefined)
+                    break;
+                console.log("Child type: " + ts.SyntaxKind[child.kind]);
+                res = tryResolveTypeRecursive(child);
+            }
+            if (ts.isTypeReferenceNode(node)) {
+                var typeRef = node;
+                var typeName_2 = typeRef.typeName.getText();
+                switch (typeName_2) {
+                    case "Array":
+                        res += "[]";
+                        return res;
+                }
+            }
+            return res;
+        }
+    }
+}
+exports.run = run;
+if (process.argv.length < 4) {
+    console.error("Missing args, call with: <output_dir> <input_files>");
+}
+else {
+    var outputDir_1 = process.argv[2];
+    var fileNames = process.argv.slice(3);
+    fileNames.forEach(function (fileName) {
+        // Parse a file
+        var sourceFile = ts.createSourceFile(fileName, (0, fs_1.readFileSync)(fileName).toString(), ts.ScriptTarget.ES2015, 
+        /*setParentNodes */ true);
+        var prog = ts.createProgram([fileName], {});
+        // delint it
+        run(prog, outputDir_1, sourceFile);
+    });
+}

package/src/component-compiler.ts

@@ -0,0 +1,362 @@
+import { readFileSync } from "fs";
+import * as ts from "typescript";
+import * as fs from "fs";
+import * as path from "path";
+
+import * as types from "./types";
+const dict = types.dict;
+
+// add either of these two comments above a class to enforce code gen or disable it for the next class
+const exportNextClassCommand = "@generate-component";
+const dontExportNextClassCommand = "@dont-generate-component";
+// add above field to add [SerializeField] attribute
+const serializeCommand = "@serializeField";
+
+// will be set to true when e.g. a comment for export is found
+let exportNextClass: boolean = false;
+let dontExportNextClass: boolean = false;
+let serializeField: boolean = false;
+function resetExportNextClass() {
+    dontExportNextClass = false;
+    exportNextClass = false;
+}
+
+
+// https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API
+
+// const exportDir = "../dist";
+const commentStarts: Array<number> = [];
+
+class ExportContext {
+    outputDir: string;
+    fileName: string;
+    textBuffer: string;
+    classEnd: number = -1;
+    indentLevel: number = 0;
+
+    constructor(outputDir: string, fileName: string) {
+        this.outputDir = outputDir;
+        this.fileName = fileName;
+        this.reset();
+    }
+
+    emitMethodContextMenu: string | null | undefined = null;
+
+    onBeforeMethod(name: string) {
+        if (this.emitMethodContextMenu !== undefined) {
+            const contextMenuText = this.emitMethodContextMenu === null ? name : this.emitMethodContextMenu;
+            this.appendLine("[UnityEngine.ContextMenu(\"" + contextMenuText + "\")]");
+        }
+    }
+
+    append(text: string) {
+        for (let i = 0; i < this.indentLevel; i++)
+            text = "\t" + text;
+        this.textBuffer += text;
+        this.emitMethodContextMenu = undefined;
+    }
+
+    appendLine(text: string) {
+        this.append(text + "\n");
+    }
+
+    flush() {
+        if (this.textBuffer.length <= 0) return;
+        const dir = this.outputDir + "/";
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir);
+        }
+        const path = dir + this.fileName;
+        console.log("Write to " + path);
+        fs.writeFileSync(path, this.textBuffer);
+        this.reset();
+    }
+
+    reset() {
+        this.textBuffer = "";
+        this.classEnd = -1;
+    }
+}
+
+const contexts: ExportContext[] = [];
+
+export function run(program: ts.Program, outputDir: string, sourceFile: ts.SourceFile) {
+
+    if (!fs.existsSync(outputDir)) {
+        console.error("Output directory does not exist: \"" + outputDir + "\"");
+        return;
+    }
+
+    traverseFile(sourceFile);
+    function traverseFile(node: ts.Node) {
+
+        visit(node);
+        ts.forEachChild(node, traverseFile);
+    }
+
+    function visit(node: ts.Node) {
+        let context: ExportContext | null = contexts.length > 0 ? contexts[contexts.length - 1] : null;
+
+        if (context?.classEnd > 0 && node.pos >= context?.classEnd) {
+            while (context.indentLevel > 0) {
+                context.indentLevel -= 1;
+                context.append("}\n");
+            }
+            context.flush();
+            context = null;
+            contexts.pop();
+        }
+        console.log("\t", ts.SyntaxKind[node.kind]);
+
+        const commentRanges = ts.getLeadingCommentRanges(
+            sourceFile.getFullText(),
+            node.getFullStart());
+        if (commentRanges?.length) {
+            for (const r of commentRanges) {
+                // avoid emitting comments multiple times
+                if (commentStarts.includes(r.pos)) continue;
+                commentStarts.push(r.pos);
+                const comment = node.getSourceFile().getFullText().slice(r.pos, r.end);
+                if (context) {
+                    // https://regex101.com/r/ud4oev/1
+                    const emitContextMenu = comment.match("(\/{2,}|\/\*)\s*@contextmenu {0,}(?<text>[a-zA-Z 0-9]+)?");
+                    if (emitContextMenu) {
+                        context.emitMethodContextMenu = emitContextMenu.groups?.text ?? null;
+                    }
+                    else if (comment.includes(serializeCommand))
+                        serializeField = true;
+                    else
+                        context.appendLine(comment);
+                }
+                if (comment.includes(exportNextClassCommand))
+                    exportNextClass = true;
+                if (comment.includes(dontExportNextClassCommand))
+                    dontExportNextClass = true;
+            }
+        }
+
+        switch (node.kind) {
+            // case ts.SyntaxKind.ClassDeclaration:
+            // case ts.SyntaxKind.SingleLineCommentTrivia:
+            //     console.log("comment: " + node.getText())
+            //     break;
+            case ts.SyntaxKind.Decorator:
+                break;
+            case ts.SyntaxKind.MethodDeclaration:
+                serializeField = false;
+                resetExportNextClass();
+                if (!context) break;
+                // TODO: always emit at least OnEnable method per class so generated components have toggle in editor
+                const meth = node as ts.MethodDeclaration;
+                // const isCoroutine = func.asteriskToken;
+                if (meth.name) {
+                    let paramsStr = "";
+                    for (let param of meth.parameters) {
+                        if (!param || !param.name) continue;
+                        if (paramsStr.length > 0) paramsStr += ", ";
+                        let type = tryResolveTypeRecursive(param);
+                        if (type === undefined) type = "object";
+                        paramsStr += type + " @" + param.name.getText();
+                    }
+                    const methodName = meth.name.getText();
+                    context.onBeforeMethod(methodName);
+                    context.append("public void " + methodName + "(" + paramsStr + "){}\n");
+                }
+                break;
+
+
+            case ts.SyntaxKind.SetAccessor:
+            case ts.SyntaxKind.PropertyDeclaration:
+                resetExportNextClass();
+                if (!context) break;
+                console.log("Found variable", node.getText());
+                const vardec = node as ts.VariableDeclaration;
+                const name = vardec.name.getText();
+                console.log(name);
+                if (name.startsWith("\"@") || name.startsWith("\"$") || name.startsWith("$")) break;
+                let typeString = tryResolveTypeRecursive(node);
+                if (typeString === undefined) {
+                    context.append("// Could not resolve type \"" + vardec.type?.getText() + "\"\n");
+                }
+                const prefix = typeString === undefined ? "// " : "";
+                let assignment = "";
+                if (typeString !== undefined) {
+                    for (const ch of node.getChildren()) {
+                        switch (ch.kind) {
+                            case ts.SyntaxKind.FalseKeyword:
+                            case ts.SyntaxKind.TrueKeyword:
+                                assignment = " = " + ch.getText();
+                                break;
+                            case ts.SyntaxKind.StringLiteral:
+                                const str = ch as ts.StringLiteral;
+                                assignment = " = \"" + str.text + "\"";
+                                break;
+                            case ts.SyntaxKind.FirstLiteralToken:
+                                const lit = ch as ts.LiteralExpression;
+                                assignment = " = " + lit.text;
+                                if (ts.isNumericLiteral(lit))
+                                    assignment += "f";
+                                break;
+                            case ts.SyntaxKind.ArrayLiteralExpression:
+                                const arr = ch as ts.ArrayLiteralExpression;
+                                assignment = " = new " + typeString + "{" + arr.elements.map(e => " " + e.getText()) + " }"
+                                break;
+                        }
+                    }
+                }
+                const varName = "@" + vardec.name.getText();
+                const pub = isPublic(vardec);
+                const visibility = pub ? "public" : "private";
+                if (!pub && serializeField) {
+                    console.log("SERIALIZE");
+                    context.appendLine("[UnityEngine.SerializeField]");
+                }
+                context.append(prefix + visibility + " " + typeString + " " + varName + assignment + ";\n");
+                break;
+
+            case ts.SyntaxKind.ClassDeclaration:
+                serializeField = false;
+                const dec = <ts.ClassDeclaration>node;
+                // a class must inherit a component
+                if (!dontExportNextClass && (exportNextClass || testInheritsComponent(node))) {
+                    resetExportNextClass();
+                    const name = dec.name.escapedText;
+                    console.log("Found class: ", name);
+                    const newContext = new ExportContext(outputDir, name + ".cs");
+                    newContext.appendLine("// auto generated code - do not edit")
+                    newContext.appendLine("namespace Needle.Typescript.GeneratedComponents");
+                    newContext.appendLine("{");
+                    newContext.indentLevel += 1;
+                    // newContext.appendLine("// source: " + path.resolve(sourceFile.fileName));
+                    newContext.appendLine("public class " + name + " : UnityEngine.MonoBehaviour");
+                    newContext.appendLine("{");
+                    newContext.indentLevel += 1;
+                    newContext.classEnd = dec.end;
+                    contexts.push(newContext);
+                }
+                break;
+        }
+
+        function testInheritsComponent(node: ts.Node): boolean {
+            switch (node.kind) {
+                case ts.SyntaxKind.ClassDeclaration:
+                    const dec = <ts.ClassDeclaration>node;
+                    if (dec.heritageClauses) {
+                        for (const h of dec.heritageClauses) {
+                            if (h.types.length <= 0) continue;
+                            for (const type of h.types) {
+                                // const symbol = program.getTypeChecker().getSymbolAtLocation(type.expression);
+                                // console.log(symbol);
+                                if (type.expression.getText() === "Component") return true;
+                                if (type.expression.getText() === "Behaviour") return true;
+                            }
+                        }
+                    }
+                    return false;
+            }
+            return false;
+        }
+
+        function isPublic(node: ts.Node): boolean {
+            if (node.kind === ts.SyntaxKind.PublicKeyword) {
+                return true;
+            }
+            else if (node.kind === ts.SyntaxKind.PrivateKeyword) {
+                return false;
+            }
+
+            for (const ch of node.getChildren()) {
+                if (!isPublic(ch)) return false;
+            }
+            return true;
+        }
+
+        function tryResolveTypeRecursive(node: ts.Node | ts.VariableDeclaration): string | undefined {
+            if (!node) return undefined;
+
+            // skip decorators (e.g. @serializable() may break array generation)
+            if(node.kind === ts.SyntaxKind.Decorator) 
+                return undefined;
+
+            let typeName = node?.getText();
+
+            const varDec: ts.VariableDeclaration = node as ts.VariableDeclaration;
+            if (varDec.type) {
+                typeName = varDec.type.getText();
+            }
+
+            let res = dict[typeName];
+            if (res !== undefined) {
+                // console.log("FOUND " + res, ts.SyntaxKind[node.kind]);
+                // console.log(node);
+                return res;
+            }
+            // console.log("Unknown type: " + typeName);
+
+            switch (node.kind) {
+                case ts.SyntaxKind.SyntaxList:
+                    // const list = node as ts.SyntaxList;
+                    // for(const ch of list._children)
+                    //     res = tryResolveTypeRecursive(ch);
+                    break;
+                case ts.SyntaxKind.UnionType:
+                    const union = node as ts.UnionTypeNode;
+                    for (const t of union.types) {
+                        res = tryResolveTypeRecursive(t);
+                        if (res !== undefined) return res;
+                    }
+                    break;
+                case ts.SyntaxKind.ArrayType:
+                    const arrayType = <ts.ArrayTypeNode>node;
+                    const typeName = arrayType.elementType?.getText();
+                    if (typeName !== undefined) {
+                        res = dict[typeName];
+                        if (res !== undefined) {
+                            res += "[]";
+                            return res;
+                        }
+                    }
+            }
+
+            for (const child of node.getChildren()) {
+                if (res !== undefined) break;
+                console.log("Child type: " + ts.SyntaxKind[child.kind]);
+                res = tryResolveTypeRecursive(child);
+            }
+            
+            if(ts.isTypeReferenceNode(node)){
+                const typeRef = node as ts.TypeReferenceNode;
+                const typeName = typeRef.typeName.getText();
+                switch(typeName)
+                {
+                    case "Array":
+                        res += "[]";
+                        return res;
+                }
+            }
+            return res;
+        }
+    }
+}
+
+if (process.argv.length < 4) {
+    console.error("Missing args, call with: <output_dir> <input_files>");
+}
+else {
+    const outputDir = process.argv[2];
+    const fileNames = process.argv.slice(3);
+    fileNames.forEach(fileName => {
+        // Parse a file
+        const sourceFile = ts.createSourceFile(
+            fileName,
+            readFileSync(fileName).toString(),
+            ts.ScriptTarget.ES2015,
+        /*setParentNodes */ true
+        );
+
+        const prog = ts.createProgram([fileName], {});
+
+        // delint it
+        run(prog, outputDir, sourceFile);
+    });
+}

package/src/component.cs

@@ -0,0 +1 @@
+public class MyClass : MonoBehaviour { 

package/src/test.ts

@@ -0,0 +1,97 @@
+
+// @generate-component
+
+
+export class MaterialColorHandler extends Behaviour {
+
+    @serializeable(Renderer)
+    renderer?: Renderer[];
+}
+
+// export class MyArray extends Behaviour {
+    
+//     arr? : Array<number> = [1,2,3];
+// }
+
+// export class PrivateSerializedField extends Behaviour {
+    
+//     //@serializeField
+//     private color? : THREE.Color; 
+// }
+// export class MyPropertyClass extends Behaviour {
+//     set color(col: THREE.Color) {
+//     }
+// }
+
+// export class MyClassWithAFloat extends Behaviour {
+//     myfloat:number = .5;
+//     private myString : string;
+// }
+
+// export class GltfExport extends Behaviour {
+//     binary: boolean = true;
+//     "$serializedTypes" = {
+//         url:null
+//     }
+
+//     // @contextmenu enable this
+//     test(){
+
+//     }
+// }
+
+// export class SetColor  extends Behaviour {
+
+//     "@serializedTypes" = { 
+//         col: Number,
+//     }
+// }
+
+// class Behaviour {
+
+// }
+
+// export class PlatformerMusic extends Behaviour implements IPlaymodeChangeListener {
+//     source?: AudioSource;
+//     editMode?: string;
+//     playMode?: string;
+
+//     onPlaymodeChange(playmode: PlayMode): void {
+//         console.log(this);
+//         if(!this.source) return;
+//         const clip = playmode.isInPlayMode ? this.playMode : this.editMode;
+//         console.log("PLAY", clip);
+//         this.source.play(clip);
+//     }
+
+// }
+
+// // TODO: export UnityEvent like this
+// // disable codegen
+// class UnityEvent {
+//     methods: Function[] = [];
+//     invoke() {
+//         for (const m of this.methods) {
+//             m();
+//         }
+//     }
+// }
+
+// export class MyClass extends Behaviour {
+//     myFloat: number = 15;
+//     myBool: boolean;
+//     // just some default values
+//     myArray: number[] = [1, 2, 3];
+//     // comment for myString
+//     myString: string = "this is a string1";
+//     myObject: THREE.Object3D;
+//     myBool2: boolean;
+
+//     myFunction() { }
+//     myFunctionWithStringParameter(string: string) { }
+//     myFunctionWithSomeObjectAndArray(obj: THREE.Object3D, arr: number[]) { }
+//     myFunctionWithoutParamTypes(test) { }
+
+//     someOtherStuff: THREE.Object3D[] | null = null;
+//     myEvent: UnityEvent;
+// }

package/src/types.js

@@ -0,0 +1,47 @@
+"use strict";
+exports.__esModule = true;
+exports.delint = void 0;
+
+const dict = {
+    "number": "float",
+    "string": "string",
+    "boolean": "bool",
+    // basic
+    "Behaviour" : "UnityEngine.Behaviour",
+    "Component" : "UnityEngine.Component",
+    "GameObject" : "UnityEngine.GameObject",
+    "Object3D" : "UnityEngine.Transform",
+    // Addressables
+    "AssetReference" : "UnityEngine.Transform",
+    // events
+    "EventList" : "UnityEngine.Events.UnityEvent",
+    // audio
+    "AudioClip" : "UnityEngine.AudioClip",
+    "THREE.Object3D" : "UnityEngine.Transform",
+    "UnityEvent" : "UnityEngine.Events.UnityEvent",
+    "AudioSource" : "UnityEngine.AudioSource",
+    "THREE.Color" : "UnityEngine.Color",
+    "Color" : "UnityEngine.Color",
+    "THREE.Vector2" : "UnityEngine.Vector2",
+    "Vector2" : "UnityEngine.Vector2",
+    "THREE.Vector3" : "UnityEngine.Vector3",
+    "Vector3" : "UnityEngine.Vector3",
+    "THREE.Vector4" : "UnityEngine.Vector4",
+    "Vector4" : "UnityEngine.Vector4",
+    // animation
+    "Animator" : "UnityEngine.Animator",
+    "Animation" : "UnityEngine.Animation",
+    "AnimationClip" : "UnityEngine.AnimationClip",
+    "SignalAsset" : "UnityEngine.Timeline.SignalAsset",
+    "PlayableDirector" : "UnityEngine.Playables.PlayableDirector",
+    // Rendering
+    "Renderer" : "UnityEngine.Renderer",
+    "Material" : "UnityEngine.Material",
+    // UI
+    "Text" : "UnityEngine.UI.Text",
+    "Image" : "UnityEngine.UI.Image",
+    "RawImage": "UnityEngine.UI.RawImage",
+
+}
+
+exports.dict = dict;

package/workspace.code-workspace

@@ -0,0 +1,8 @@
+{
+	"folders": [
+		{
+			"path": "."
+		}
+	],
+	"settings": {}
+}