@needle-tools/needle-component-compiler 2.4.1-pre → 3.0.0-alpha.1

package/Changelog.md

@@ -4,6 +4,11 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [3.0.0-alpha.1] - 2026-03-02
+- Fix: destructured method parameters (e.g. `{xr}`) now emit as `object @obj` instead of invalid `object @{xr}`
+- Fix: `Object3D` type now correctly maps to `UnityEngine.Transform`
+- Add: `RectTransform` type mapping to `UnityEngine.RectTransform`
+
 ## [2.4.1-pre] - 2023-04-03
 # Blender compiler
 - Add: typenames
@@ -24,6 +29,46 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ## [2.1.0-pre] - 2022-11-12
 - Add blender scheme compiler for creating and updating schemes (or removing them when the component gets deleted)
 
+## [1.12.2] - 2025-06-06
+- Fix: Private fields decorated with `@serializable()` should be annotated with `UnityEngine.SerializeField`
+- Fix: Comment for `// @serializeField` should not affect subsequent fields
+
+## [1.12.0] - 2025-06-02
+- Add: Support to serialize unknown classes when annotated with `// @type object` 
+
+## [1.11.2] - 2023-12-16
+- Fix: property setter emitting invalid C# code
+
+## [1.11.1] - 2023-12-02
+- Fix: Use Unity AnimatorController type
+- Fix: method inline anonymous type declaration (e.g. `myMethod(arg: {x:number})`)
+
+## [1.11.0] - 2023-11-18
+- Add: support to wrap fields with `#if UNITY_EDITOR` if their namespace contains UnityEditor
+- Add: more threejs types to generate Unity Material fields for
+
+## [1.10.3] - 2023-09-08
+- Add: Needle Engine type `RGBAColor` is now automatically emitted as `UnityEngine.Color`
+
+## [1.10.2] - 2023-09-08
+- Fix: `@type` was not properly applied for `new expression` cases (e.g. `new RGBAColor` should produce a `new Color` when decorated with `@type Color`)
+
+## [1.10.1] - 2023-08-02
+- Add: use `@tooltip` to emit a UnityEngine.Tooltip
+- Update Readme
+
+## [1.9.4] - 2023-05-24
+- Change: `Object3D` now emits `GameObject` field instead of `Transform`
+- Fix: ignore `static` methods
+- Fix: ignore `abstract` methods
+
+## [1.9.3] - 2022-12-30
+- Add debug logs for when no file or target directory was passed in. Also wrapping core with try catch
+
+## [1.9.2] - 2022-11-29
+- Fix codegen deleting code added manually outside of codegen sections
+- Fix codegen creating output directory if it does not exist yet
+
 ## [1.9.1] - 2022-11-05
 - Fix ``new Vector2(1, .5)`` generating invalid C# where number arguments were emitted as double instead of float
 

package/Readme.md

@@ -1,19 +1,46 @@
-## 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>``
-
-
-### Command decorators
-- ``@dont-generate-component`` add before class to skip generating a component
-- ``@generate-component`` to enforce generating a component (not required)
-- ``@serializeField`` field decorator, similar to ``[SerializeField]`` in Unity
-- ``@nonSerialized`` field or method decorator to skip generating c# code for a field or a method, similar to ``[NonSerialized]`` in Unity
-- ``@type MyNamespace.MyType`` decorator for fields or classes, specifiy C# type of field or class
-- ``@ifdef MY_IFDEF`` field decorator only at the moment
-
-### Test
-- Run single test: `` npm run test:single -- -r ts-node/register "./test/blender/blender.from_typedef.test.ts"``
+## Needle Engine Component Compiler
+
+Compiles TypeScript component definitions into **Unity C#** component stubs and **Blender** Python component schemas for Needle Engine.
+
+```
+npm install @needle-tools/needle-component-compiler
+```
+
+### Supported TypeScript Features
+
+- Classes extending `Behaviour`, `MonoBehaviour`, or implementing `IComponent`
+- Public, protected, and private fields with type annotations
+- Default values (primitives, `new` expressions, literals)
+- Array types: `T[]`, `Array<T>`
+- Union types (nullable types like `Object3D | null` resolve to the concrete type)
+- Enums (with value initialization)
+- Methods with parameters and return types
+- Destructured parameters (compiled as `object`)
+
+### Comment Directives
+
+Use `//` comments above classes, fields, or methods to control code generation:
+
+| Directive | Target | Description |
+|---|---|---|
+| `@generate-component` | Class | Force generation (not required, classes are generated by default) |
+| `@dont-generate-component` | Class | Skip generating this class entirely |
+| `@type MyNamespace.MyType` | Class / Field | Override the resolved C# type or base class |
+| `@abstract` | Class | Mark the generated class as `abstract` |
+| `@serializeField` | Field | Emit `[UnityEngine.SerializeField]` attribute |
+| `@nonSerialized` | Field / Method | Skip generating C# code for this member |
+| `@tooltip "My text"` | Field | Emit `[UnityEngine.Tooltip("My text")]` |
+| `@contextmenu "Label"` | Method | Emit `[UnityEngine.ContextMenu("Label")]` |
+| `@ifdef MY_DEFINE` | Field | Wrap field in `#if MY_DEFINE` / `#endif` |
+
+### Codegen Fences
+
+Generated C# files are wrapped in `// NEEDLE_CODEGEN_START` and `// NEEDLE_CODEGEN_END` markers. This allows you to add custom code outside the fences that will be preserved when the file is regenerated.
+
+# Contact ✒️
+<b>[🌵 Needle](https://needle.tools)</b> •
+[Github](https://github.com/needle-tools) •
+[Twitter](https://twitter.com/NeedleTools) •
+[Discord](https://discord.needle.tools) •
+[Forum](https://forum.needle.tools) •
+[Youtube](https://youtube.com/@needle-tools)

package/dist/BaseWriter.d.ts

@@ -0,0 +1,23 @@
+import { Argument, CodeTextWriter, EnumMember, ISink, IWriter, Visibility } from "./base-compiler";
+import { TypeSourceInformation } from "./register-types";
+export declare abstract class BaseWriter implements IWriter {
+    private _sink?;
+    protected writer: CodeTextWriter;
+    get sink(): ISink;
+    constructor(_sink?: ISink);
+    /** Enum registry: lowercased enum name → members */
+    protected _enumRegistry: Map<string, EnumMember[]>;
+    registerEnum(name: string, members: EnumMember[]): void;
+    abstract resolveCSharpTypeName(typescriptTypeName: string, baseTypes?: string[]): string | void;
+    abstract startNewType(filePath: string, typeName: string, baseType: string[], comments?: string[]): boolean | void;
+    abstract endNewType(filePath: string, typeName: string): void;
+    abstract writeMember(visibility: Visibility, name: string, isArray: boolean, type: string, initialValue?: string, comments?: string[]): void;
+    abstract writeMethod(visibility: Visibility, name: string, returnType: string, args: Argument[], comments: string[]): void;
+    abstract writeNewTypeExpression(typeName: string, args?: string[]): void;
+    private _currentlyProcessingFiles;
+    get outputInfo(): TypeSourceInformation;
+    private _createdSchemesPerFile;
+    begin(filePath: string | null): void;
+    end(filePath: string | null): void;
+    protected writeScheme(processingFilePath: string | null, component: string): void;
+}

package/dist/BaseWriter.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseWriter = void 0;
+var fs_1 = require("fs");
+var base_compiler_1 = require("./base-compiler");
+var commands_1 = require("./commands");
+var BaseWriter = /** @class */ (function () {
+    function BaseWriter(_sink) {
+        this._sink = _sink;
+        this.writer = new base_compiler_1.CodeTextWriter();
+        /** Enum registry: lowercased enum name → members */
+        this._enumRegistry = new Map();
+        this._currentlyProcessingFiles = {};
+        this._createdSchemesPerFile = {};
+    }
+    Object.defineProperty(BaseWriter.prototype, "sink", {
+        get: function () {
+            return this._sink;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BaseWriter.prototype.registerEnum = function (name, members) {
+        this._enumRegistry.set(name.toLowerCase(), members);
+    };
+    Object.defineProperty(BaseWriter.prototype, "outputInfo", {
+        get: function () {
+            return this._createdSchemesPerFile;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BaseWriter.prototype.begin = function (filePath) {
+        if (!this._currentlyProcessingFiles[filePath]) {
+            this._currentlyProcessingFiles[filePath] = [];
+        }
+    };
+    BaseWriter.prototype.end = function (filePath) {
+        var results = this._currentlyProcessingFiles[filePath];
+        console.log("Writing schemes for", filePath, results);
+        if (results) {
+            var previousResultsFromThisFile = this._createdSchemesPerFile[filePath];
+            if (previousResultsFromThisFile) {
+                for (var _i = 0, previousResultsFromThisFile_1 = previousResultsFromThisFile; _i < previousResultsFromThisFile_1.length; _i++) {
+                    var previouslyCreated = previousResultsFromThisFile_1[_i];
+                    var foundInAny = false;
+                    for (var _a = 0, results_1 = results; _a < results_1.length; _a++) {
+                        var res = results_1[_a];
+                        if (res.filePath === previouslyCreated.filePath) {
+                            foundInAny = true;
+                            break;
+                        }
+                    }
+                    if (!foundInAny) {
+                        for (var sourcePath in this._createdSchemesPerFile) {
+                            if (foundInAny)
+                                break;
+                            if (sourcePath === filePath)
+                                continue;
+                            var otherSourceSchemes = this._createdSchemesPerFile[sourcePath];
+                            if (otherSourceSchemes.includes(previouslyCreated)) {
+                                // the file was moved to another source file
+                                foundInAny = true;
+                            }
+                        }
+                    }
+                    if (!foundInAny && (0, fs_1.existsSync)(previouslyCreated.filePath)) {
+                        (0, fs_1.unlinkSync)(previouslyCreated.filePath);
+                        (0, commands_1.sendFileDeletedCommand)(previouslyCreated.filePath);
+                    }
+                }
+            }
+            this._createdSchemesPerFile[filePath] = results;
+        }
+        delete this._currentlyProcessingFiles[filePath];
+    };
+    BaseWriter.prototype.writeScheme = function (processingFilePath, component) {
+        var res = this.sink.flush(component + ".component.json", this.writer.flush());
+        // if an output path is returned it means a file has been written to that path
+        if (res && (0, fs_1.existsSync)(res)) {
+            (0, commands_1.sendFileWrittenCommand)(res);
+            // add the scheme to the list of created schemes
+            if (processingFilePath && this._currentlyProcessingFiles[processingFilePath]) {
+                this._currentlyProcessingFiles[processingFilePath].push({ componentName: component, filePath: res });
+            }
+        }
+    };
+    return BaseWriter;
+}());
+exports.BaseWriter = BaseWriter;

package/dist/Compiler.d.ts

@@ -0,0 +1,20 @@
+import { IWriter } from "./base-compiler";
+/** Typescript Walker */
+export declare class Compiler {
+    compile(writer: IWriter, code: string, sourceFilePath: string | null): void;
+    private run;
+    private visitEnumDeclaration;
+    private visit;
+    private visitClassDeclaration;
+    private visitPropertyDeclaration;
+    private visitMethodDeclaration;
+    private resolveParameters;
+    private debugLog;
+    private getComments;
+    private getVisibility;
+    private tryResolveTypeFromExpression;
+    private resolveType;
+    private resolveTypeFromString;
+    private isArrayType;
+    private resolveExpression;
+}

package/{src/base-compiler.js → dist/Compiler.js}

@@ -1,189 +1,64 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Compiler = exports.runFromFile = exports.handleDeletedFile = exports.CodeTextWriter = exports.MemorySink = exports.FileSink = exports.Visibility = void 0;
-var fs_1 = require("fs");
+exports.Compiler = void 0;
 var ts = require("typescript");
-var fs = require("fs");
-var commands_1 = require("./commands");
-var Visibility;
-(function (Visibility) {
-    Visibility[Visibility["Public"] = 0] = "Public";
-    Visibility[Visibility["Protected"] = 1] = "Protected";
-    Visibility[Visibility["Private"] = 2] = "Private";
-})(Visibility = exports.Visibility || (exports.Visibility = {}));
-var FileSink = /** @class */ (function () {
-    function FileSink(directory) {
-        this.directory = directory;
-    }
-    FileSink.prototype.flush = function (id, str) {
-        if (!fs.existsSync(this.directory)) {
-            fs.mkdirSync(this.directory, { recursive: true });
-        }
-        console.log("Writing " + id + " to " + this.directory);
-        var fullPath = this.directory + "/" + id;
-        fs.writeFileSync(fullPath, str);
-        return fs.realpathSync(fullPath);
-    };
-    return FileSink;
-}());
-exports.FileSink = FileSink;
-var MemorySink = /** @class */ (function () {
-    function MemorySink() {
-        this.results = [];
-    }
-    MemorySink.prototype.clear = function () {
-        this.results.length = 0;
-    };
-    MemorySink.prototype.flush = function (id, str) {
-        this.results.push(str);
-        return "";
-    };
-    return MemorySink;
-}());
-exports.MemorySink = MemorySink;
-var CodeTextWriter = /** @class */ (function () {
-    function CodeTextWriter() {
-        this.indent = 0;
-        this.lines = [];
-    }
-    CodeTextWriter.prototype.beginBlock = function (line) {
-        this.writeLine(line);
-        this.indent++;
-    };
-    CodeTextWriter.prototype.endBlock = function (line) {
-        // remove the comma from the last line
-        if (this.lines.length > 0) {
-            var prevLine = this.lines[this.lines.length - 1];
-            if (prevLine.endsWith(",")) {
-                this.lines[this.lines.length - 1] = prevLine.substring(0, prevLine.length - 1);
-            }
-        }
-        this.indent--;
-        this.writeLine(line);
-    };
-    CodeTextWriter.prototype.writeLine = function (line) {
-        var indent = "";
-        for (var i = 0; i < this.indent; i++) {
-            indent += "    ";
-        }
-        var lines = line.split(/\r?\n/);
-        for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
-            var line_1 = lines_1[_i];
-            // remove whitespace so we can ensure we correctly end with a comma
-            this.lines.push(indent + (line_1 === null || line_1 === void 0 ? void 0 : line_1.trim()));
-        }
-    };
-    CodeTextWriter.prototype.write = function (text) {
-        var lines = text.split(/\r?\n/);
-        if (lines.length > 1) {
-            for (var i = 0; i < lines.length; i++) {
-                this.writeLine(lines[i]);
-            }
-        }
-        else {
-            if (this.lines.length == 0) {
-                this.writeLine(text);
-            }
-            else {
-                var lastLine = this.lines[this.lines.length - 1];
-                this.lines[this.lines.length - 1] = lastLine + text;
-            }
-        }
-    };
-    // beginArray() {
-    //     this.writeLine("[");
-    //     this.indent++;
-    // }
-    // insertArrayItem(item: string) {
-    //     this.writeLine(item + ",");
-    // }
-    // endArray() {
-    // }
-    CodeTextWriter.prototype.flush = function () {
-        var str = this.toString();
-        this.lines.length = 0;
-        return str;
-        // if (this.lines.length === 0) return;
-        // if (!fs.existsSync(directory)) {
-        //     fs.mkdirSync(directory, { recursive: true });
-        // }
-        // console.log("Writing " + filename + " to " + directory);
-        // const content = this.toString();
-        // this.lines.length = 0;
-        // const fullPath = directory + "/" + filename;
-        // fs.writeFileSync(fullPath, content);
-        // return fs.realpathSync(fullPath);
-    };
-    CodeTextWriter.prototype.clear = function () {
-        this.lines.length = 0;
-    };
-    CodeTextWriter.prototype.toString = function () {
-        return this.lines.join("\r");
-    };
-    return CodeTextWriter;
-}());
-exports.CodeTextWriter = CodeTextWriter;
-function handleDeletedFile(filePath, types) {
-    if (!fs.existsSync(filePath)) {
-        var infos = types[filePath];
-        if (!infos)
-            return;
-        for (var i = 0; i < infos.length; i++) {
-            var info = infos[i];
-            // check if the source file is in any other file
-            var found = false;
-            for (var otherSourceFile in types) {
-                if (otherSourceFile == filePath)
-                    continue;
-                for (var _i = 0, _a = types[otherSourceFile]; _i < _a.length; _i++) {
-                    var otherInfo = _a[_i];
-                    if (otherInfo.filePath == info.filePath) {
-                        found = true;
-                        break;
-                    }
-                }
-                if (found)
-                    break;
-                if (fs.existsSync(info.filePath)) {
-                    fs.rmSync(info.filePath);
-                    (0, commands_1.sendFileDeletedCommand)(info.filePath);
-                    infos.splice(i, 1);
-                    i--;
-                }
-            }
-        }
-    }
-}
-exports.handleDeletedFile = handleDeletedFile;
-function runFromFile(writer, path) {
-    if (!fs.existsSync(path)) {
-        console.error("File not found", path);
-        return;
-    }
-    var code = (0, fs_1.readFileSync)(path).toString();
-    var compiler = new Compiler();
-    compiler.compile(writer, code, path);
-    return compiler;
-}
-exports.runFromFile = runFromFile;
+var base_compiler_1 = require("./base-compiler");
+/** Typescript Walker */
 var Compiler = /** @class */ (function () {
     function Compiler() {
     }
     Compiler.prototype.compile = function (writer, code, sourceFilePath) {
         var file = "needle_compiled.ts";
-        var sourceFile = ts.createSourceFile(file, code, ts.ScriptTarget.ES2015, true, /*setParentNodes */ ts.ScriptKind.TS);
+        var sourceFile = ts.createSourceFile(file, code, ts.ScriptTarget.ES2015, true, ts.ScriptKind.TS);
         var prog = ts.createProgram([file], {});
         this.run(prog, writer, sourceFile, sourceFilePath);
     };
     Compiler.prototype.run = function (prog, writer, sourceFile, filePath) {
         var _this = this;
         console.log("Starting compilation of " + filePath);
+        // Pre-scan: collect enum declarations so type resolution works for class fields
+        ts.forEachChild(sourceFile, function (node) {
+            if (ts.isEnumDeclaration(node)) {
+                _this.visitEnumDeclaration(node, writer);
+            }
+        });
         writer.begin(filePath);
         ts.forEachChild(sourceFile, function (node) {
             _this.visit(filePath, node, writer);
         });
         writer.end(filePath);
     };
+    Compiler.prototype.visitEnumDeclaration = function (node, writer) {
+        var name = node.name.getText();
+        var members = [];
+        var nextValue = 0;
+        for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+            var member = _a[_i];
+            var memberName = member.name.getText();
+            var value = void 0;
+            if (member.initializer) {
+                if (ts.isNumericLiteral(member.initializer)) {
+                    value = parseFloat(member.initializer.getText());
+                    nextValue = value + 1;
+                }
+                else if (ts.isPrefixUnaryExpression(member.initializer) &&
+                    ts.isNumericLiteral(member.initializer.operand)) {
+                    value = parseFloat(ts.tokenToString(member.initializer.operator) + member.initializer.operand.getText());
+                    nextValue = value + 1;
+                }
+                else {
+                    // String or computed value — store as-is
+                    value = member.initializer.getText();
+                }
+            }
+            else {
+                value = nextValue++;
+            }
+            members.push({ name: memberName, value: value });
+        }
+        this.debugLog("[COMPILER] ENUM", name, members);
+        writer.registerEnum(name, members);
+    };
     Compiler.prototype.visit = function (filePath, node, writer) {
         var _this = this;
         if (ts.isClassDeclaration(node)) {
@@ -218,7 +93,7 @@ var Compiler = /** @class */ (function () {
                 }
             }
         }
-        this.debugLog("CLASS START", name, baseTypes);
+        this.debugLog("[COMPILER] CLASS START", name, baseTypes);
         var res = writer.startNewType(filePath, name, baseTypes, this.getComments(node));
         if (res === false) {
             this.debugLog("CLASS SKIPPED", name);
@@ -228,7 +103,7 @@ var Compiler = /** @class */ (function () {
             _this.visit(filePath, node, writer);
         });
         writer.endNewType(filePath, name);
-        this.debugLog("CLASS END", name, "\n");
+        this.debugLog("[COMPILER] CLASS END", name, "\n");
     };
     Compiler.prototype.visitPropertyDeclaration = function (node, writer) {
         var name = node.name.getText();
@@ -239,26 +114,39 @@ var Compiler = /** @class */ (function () {
         if (!type && node.initializer) {
             type = this.tryResolveTypeFromExpression(node.initializer, writer);
         }
-        this.debugLog("PROPERTY", Visibility[visibility], name, isArray, type, initialValue);
+        this.debugLog("[COMPILER] PROPERTY", base_compiler_1.Visibility[visibility], name, isArray, type, initialValue);
+        if (!type)
+            return; // cannot determine type — skip the field
         writer.writeMember(visibility, name, isArray, type, initialValue, this.getComments(node));
     };
     Compiler.prototype.visitMethodDeclaration = function (node, writer) {
         var _a;
         var name = node.name.getText();
         var visibility = this.getVisibility(node);
+        // Skip static and abstract methods — they don't map to Unity MonoBehaviour stubs
+        if (node.modifiers) {
+            for (var _i = 0, _b = node.modifiers; _i < _b.length; _i++) {
+                var modifier = _b[_i];
+                if (modifier.kind === ts.SyntaxKind.StaticKeyword ||
+                    modifier.kind === ts.SyntaxKind.AbstractKeyword) {
+                    return;
+                }
+            }
+        }
         var returnType = this.resolveType(node.type, writer);
         var args;
         if ((_a = node.parameters) === null || _a === void 0 ? void 0 : _a.length) {
             args = this.resolveParameters(node.parameters, writer);
         }
-        this.debugLog("METHOD", Visibility[visibility], name, returnType, args);
+        this.debugLog("[COMPILER] METHOD", base_compiler_1.Visibility[visibility], name, returnType, args);
         writer.writeMethod(visibility, name, returnType, args, this.getComments(node));
     };
     Compiler.prototype.resolveParameters = function (parameters, writer) {
         var result = [];
         for (var _i = 0, parameters_1 = parameters; _i < parameters_1.length; _i++) {
             var parameter = parameters_1[_i];
-            var name_1 = parameter.name.getText();
+            // Destructured parameters (e.g. { xr }) get a generic name
+            var name_1 = ts.isObjectBindingPattern(parameter.name) ? "obj" : parameter.name.getText();
             var type = this.resolveType(parameter.type, writer);
             var defaultValue = parameter.initializer && this.resolveExpression(parameter.initializer, writer);
             result.push({ name: name_1, type: type, defaultValue: defaultValue });
@@ -293,17 +181,17 @@ var Compiler = /** @class */ (function () {
             for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
                 var modifier = _a[_i];
                 if (modifier.kind === ts.SyntaxKind.PublicKeyword) {
-                    return Visibility.Public;
+                    return base_compiler_1.Visibility.Public;
                 }
                 else if (modifier.kind === ts.SyntaxKind.ProtectedKeyword) {
-                    return Visibility.Protected;
+                    return base_compiler_1.Visibility.Protected;
                 }
                 else if (modifier.kind === ts.SyntaxKind.PrivateKeyword) {
-                    return Visibility.Private;
+                    return base_compiler_1.Visibility.Private;
                 }
             }
         }
-        return Visibility.Public;
+        return base_compiler_1.Visibility.Public;
     };
     Compiler.prototype.tryResolveTypeFromExpression = function (exp, write) {
         var _a;
@@ -319,15 +207,27 @@ var Compiler = /** @class */ (function () {
                 }
             }
             var typeName = exp.expression.getText();
-            // const typeName = exp.expression.getText();
-            // console.log("NEW EXPRESSION", typeName);
-            // const args = exp.arguments?.map(arg => this.resolveExpression(arg, write));
-            // write.writeNewTypeExpression(typeName, args);
-            return typeName;
+            return this.resolveTypeFromString(typeName, write);
+        }
+        // Infer type from literal initializers (no explicit type annotation)
+        if (ts.isNumericLiteral(exp)) {
+            // e.g. speed = 5  or  ratio = 5.5  → number → float
+            return this.resolveTypeFromString("number", write);
+        }
+        if (ts.isStringLiteral(exp)) {
+            // e.g. label = "hello" → string
+            return this.resolveTypeFromString("string", write);
+        }
+        if (exp.kind === ts.SyntaxKind.TrueKeyword || exp.kind === ts.SyntaxKind.FalseKeyword) {
+            // e.g. active = true → boolean → bool
+            return this.resolveTypeFromString("boolean", write);
+        }
+        if (ts.isPrefixUnaryExpression(exp) && ts.isNumericLiteral(exp.operand)) {
+            // e.g. speed = -5  or  ratio = -1.5 → number → float
+            return this.resolveTypeFromString("number", write);
         }
     };
     Compiler.prototype.resolveType = function (typeNode, writer) {
-        var _a;
         if (!typeNode)
             return undefined;
         // check if its an array
@@ -375,24 +275,26 @@ var Compiler = /** @class */ (function () {
             // }
             console.error("!!!!! ----- Unknown array type", typeNode.getText());
         }
-        var type = typeNode.getText();
-        var baseTypes = [];
-        if (typeNode.kind === ts.SyntaxKind.TypeReference) {
-            var typeReference = typeNode;
-            if ((_a = typeReference.typeArguments) === null || _a === void 0 ? void 0 : _a.length) {
-                for (var _i = 0, _b = typeReference.typeArguments; _i < _b.length; _i++) {
-                    var arg = _b[_i];
-                    var type_1 = this.resolveType(arg, writer);
-                    if (type_1) {
-                        baseTypes.push(type_1);
-                    }
+        // Union types: Object3D | null | undefined → resolve the first concrete member
+        if (ts.isUnionTypeNode(typeNode)) {
+            for (var _i = 0, _a = typeNode.types; _i < _a.length; _i++) {
+                var member = _a[_i];
+                if (member.kind !== ts.SyntaxKind.NullKeyword &&
+                    member.kind !== ts.SyntaxKind.UndefinedKeyword) {
+                    return this.resolveType(member, writer);
                 }
             }
+            return undefined;
+        }
+        // TypeReference: use base name only (strips generic args like EventList<void> → EventList)
+        if (typeNode.kind === ts.SyntaxKind.TypeReference) {
+            var typeReference = typeNode;
+            return this.resolveTypeFromString(typeReference.typeName.getText(), writer);
         }
-        return this.resolveTypeFromString(type, writer);
+        return this.resolveTypeFromString(typeNode.getText(), writer);
     };
     Compiler.prototype.resolveTypeFromString = function (type, writer) {
-        var resolved = writer.resolveTypeName(type);
+        var resolved = writer.resolveCSharpTypeName(type);
         return resolved || type;
     };
     Compiler.prototype.isArrayType = function (typeNode) {
@@ -436,6 +338,9 @@ var Compiler = /** @class */ (function () {
         else if (ts.isIdentifier(node)) {
             return this.resolveTypeFromString(node.text, writer);
         }
+        else if (node.kind === ts.SyntaxKind.NullKeyword) {
+            return this.resolveTypeFromString(node.getText(), writer);
+        }
         // is true or false
         else if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) {
             return this.resolveTypeFromString(node.getText(), writer);
@@ -463,7 +368,7 @@ var Compiler = /** @class */ (function () {
         else if (ts.isPrefixUnaryExpression(node)) {
             var operand = this.resolveExpression(node.operand, writer);
             if (operand) {
-                return node.operator + operand;
+                return ts.tokenToString(node.operator) + operand;
             }
         }
         else if (ts.isPostfixUnaryExpression(node)) {
@@ -494,6 +399,7 @@ var Compiler = /** @class */ (function () {
         else if (ts.isNewExpression(node)) {
             var typeName = this.resolveTypeFromString(node.expression.getText(), writer);
             if (typeName) {
+                console.log("TODO: new expression");
                 var args = node.arguments.map(function (a) { return _this.resolveExpression(a, writer); }).filter(function (a) { return a; });
                 // writer.writeNewTypeExpression(typeName, args);
                 // return;