@needle-tools/needle-component-compiler 3.0.0-alpha → 3.0.0-alpha.1.42c96bd

package/dist/Compiler.js

@@ -1,412 +1,447 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Compiler = void 0;
-var ts = require("typescript");
-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, 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)) {
-            this.visitClassDeclaration(filePath, node, writer);
-        }
-        else if (ts.isPropertyDeclaration(node)) {
-            this.visitPropertyDeclaration(node, writer);
-        }
-        else if (ts.isMethodDeclaration(node)) {
-            this.visitMethodDeclaration(node, writer);
-        }
-        else {
-            ts.forEachChild(node, function (node) {
-                _this.visit(filePath, node, writer);
-            });
-        }
-    };
-    Compiler.prototype.visitClassDeclaration = function (filePath, node, writer) {
-        var _this = this;
-        var name = node.name.text;
-        // get all parent types
-        var baseTypes = [];
-        if (node.heritageClauses) {
-            for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) {
-                var clause = _a[_i];
-                if (clause.token == ts.SyntaxKind.ExtendsKeyword || clause.token == ts.SyntaxKind.ImplementsKeyword) {
-                    for (var _b = 0, _c = clause.types; _b < _c.length; _b++) {
-                        var type = _c[_b];
-                        var typeName = type.expression.getText();
-                        baseTypes.push(typeName);
-                    }
-                }
-            }
-        }
-        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);
-            return;
-        }
-        ts.forEachChild(node, function (node) {
-            _this.visit(filePath, node, writer);
-        });
-        writer.endNewType(filePath, name);
-        this.debugLog("[COMPILER] CLASS END", name, "\n");
-    };
-    Compiler.prototype.visitPropertyDeclaration = function (node, writer) {
-        var name = node.name.getText();
-        var type = this.resolveType(node.type, writer);
-        var visibility = this.getVisibility(node);
-        var initialValue = node.initializer && this.resolveExpression(node.initializer, writer);
-        var isArray = this.isArrayType(node.type);
-        if (!type && node.initializer) {
-            type = this.tryResolveTypeFromExpression(node.initializer, writer);
-        }
-        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("[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();
-            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 });
-        }
-        return result;
-    };
-    Compiler.prototype.debugLog = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        console.log.apply(console, args);
-    };
-    Compiler.prototype.getComments = function (node) {
-        var commentRanges = ts.getLeadingCommentRanges(node.getFullText(), 0);
-        if (commentRanges) {
-            var comments = [];
-            for (var _i = 0, commentRanges_1 = commentRanges; _i < commentRanges_1.length; _i++) {
-                var range = commentRanges_1[_i];
-                var text = node.getFullText().substring(range.pos, range.end).trimStart();
-                // match only lines that starts with //@ or // @
-                var match = text.match(/\/\/\s*@(.+)/);
-                if (match) {
-                    comments.push(text.substring(match.index + 2).trim());
-                }
-            }
-            return comments;
-        }
-    };
-    Compiler.prototype.getVisibility = function (node) {
-        if (node.modifiers) {
-            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
-                var modifier = _a[_i];
-                if (modifier.kind === ts.SyntaxKind.PublicKeyword) {
-                    return base_compiler_1.Visibility.Public;
-                }
-                else if (modifier.kind === ts.SyntaxKind.ProtectedKeyword) {
-                    return base_compiler_1.Visibility.Protected;
-                }
-                else if (modifier.kind === ts.SyntaxKind.PrivateKeyword) {
-                    return base_compiler_1.Visibility.Private;
-                }
-            }
-        }
-        return base_compiler_1.Visibility.Public;
-    };
-    Compiler.prototype.tryResolveTypeFromExpression = function (exp, write) {
-        var _a;
-        if (ts.isNewExpression(exp)) {
-            // try get generic type from expression
-            if ((_a = exp.typeArguments) === null || _a === void 0 ? void 0 : _a.length) {
-                for (var _i = 0, _b = exp.typeArguments; _i < _b.length; _i++) {
-                    var arg = _b[_i];
-                    var type = this.resolveType(arg, write);
-                    if (type) {
-                        return type;
-                    }
-                }
-            }
-            var typeName = exp.expression.getText();
-            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) {
-        if (!typeNode)
-            return undefined;
-        // check if its an array
-        if (this.isArrayType(typeNode)) {
-            if (typeNode.kind === ts.SyntaxKind.ArrayType) {
-                var arrayType = typeNode;
-                return this.resolveType(arrayType.elementType, writer);
-            }
-            // check if its Array<> or Map
-            if (typeNode.kind === ts.SyntaxKind.TypeReference) {
-                var typeReference = typeNode;
-                if (typeReference.typeName.getText() === "Array") {
-                    var typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
-                    return this.resolveType(typeArgument, writer);
-                }
-                else if (typeReference.typeName.getText() === "Map") {
-                    var typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
-                    return this.resolveType(typeArgument, writer);
-                }
-            }
-            // check if its dictionary
-            if (typeNode.kind === ts.SyntaxKind.TypeLiteral) {
-                var typeLiteral = typeNode;
-                var members = typeLiteral.members;
-                if (members.length === 2) {
-                    var firstMember = members[0];
-                    var secondMember = members[1];
-                    if (firstMember.kind === ts.SyntaxKind.IndexSignature && secondMember.kind === ts.SyntaxKind.IndexSignature) {
-                        var firstIndexSignature = firstMember;
-                        var secondIndexSignature = secondMember;
-                        var firstIndexType = firstIndexSignature.parameters[0].type;
-                        var secondIndexType = secondIndexSignature.parameters[0].type;
-                        if (firstIndexType.kind === ts.SyntaxKind.StringKeyword && secondIndexType.kind === ts.SyntaxKind.NumberKeyword) {
-                            var valueType = firstIndexSignature.type;
-                            return this.resolveType(valueType, writer);
-                        }
-                    }
-                }
-            }
-            // is generic
-            // if (typeNode.kind === ts.SyntaxKind.TypeReference) {
-            //     const typeReference = typeNode as ts.TypeReferenceNode;
-            //     const typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
-            //     return this.resolveType(typeArgument, writer);
-            // }
-            console.error("!!!!! ----- Unknown array type", typeNode.getText());
-        }
-        // 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(typeNode.getText(), writer);
-    };
-    Compiler.prototype.resolveTypeFromString = function (type, writer) {
-        var resolved = writer.resolveCSharpTypeName(type);
-        return resolved || type;
-    };
-    Compiler.prototype.isArrayType = function (typeNode) {
-        if (!typeNode)
-            return false;
-        // check if its an array
-        if (typeNode.kind === ts.SyntaxKind.ArrayType) {
-            return true;
-        }
-        // check if its Array<> or map
-        if (typeNode.kind === ts.SyntaxKind.TypeReference) {
-            var typeReference = typeNode;
-            if (typeReference.typeName.getText() === "Array") {
-                return true;
-            }
-            else if (typeReference.typeName.getText() === "Map") {
-                return true;
-            }
-        }
-        // check if its array or dictionary
-        if (typeNode.kind === ts.SyntaxKind.TypeLiteral) {
-            var typeLiteral = typeNode;
-            if (typeLiteral.members.length === 2) {
-                var first = typeLiteral.members[0];
-                var second = typeLiteral.members[1];
-                if (first.kind === ts.SyntaxKind.IndexSignature && second.kind === ts.SyntaxKind.IndexSignature) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    };
-    Compiler.prototype.resolveExpression = function (node, writer) {
-        var _this = this;
-        if (ts.isStringLiteral(node)) {
-            return this.resolveTypeFromString(node.text, writer);
-        }
-        else if (ts.isNumericLiteral(node)) {
-            return this.resolveTypeFromString(node.text, writer);
-        }
-        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);
-        }
-        else if (ts.isPropertyAccessExpression(node)) {
-            var left = this.resolveExpression(node.expression, writer);
-            if (left) {
-                return left + "." + this.resolveTypeFromString(node.name.text, writer);
-            }
-        }
-        else if (ts.isCallExpression(node)) {
-            var left = this.resolveExpression(node.expression, writer);
-            if (left) {
-                var args = node.arguments.map(function (a) { return _this.resolveExpression(a, writer); }).filter(function (a) { return a; });
-                return left + "(" + args.join(", ") + ")";
-            }
-        }
-        else if (ts.isBinaryExpression(node)) {
-            var left = this.resolveExpression(node.left, writer);
-            var right = this.resolveExpression(node.right, writer);
-            if (left && right) {
-                return left + " " + node.operatorToken.getText() + " " + right;
-            }
-        }
-        else if (ts.isPrefixUnaryExpression(node)) {
-            var operand = this.resolveExpression(node.operand, writer);
-            if (operand) {
-                return ts.tokenToString(node.operator) + operand;
-            }
-        }
-        else if (ts.isPostfixUnaryExpression(node)) {
-            var operand = this.resolveExpression(node.operand, writer);
-            if (operand) {
-                return operand + node.operator;
-            }
-        }
-        else if (ts.isParenthesizedExpression(node)) {
-            return this.resolveExpression(node.expression, writer);
-        }
-        else if (ts.isArrayLiteralExpression(node)) {
-            var elements = node.elements.map(function (e) { return _this.resolveExpression(e, writer); }).filter(function (e) { return e; });
-            return "[" + elements.join(", ") + "]";
-        }
-        else if (ts.isObjectLiteralExpression(node)) {
-            var properties = node.properties.map(function (p) {
-                if (ts.isPropertyAssignment(p)) {
-                    var name_2 = p.name.getText();
-                    var value = _this.resolveExpression(p.initializer, writer);
-                    if (value) {
-                        return name_2 + ": " + value;
-                    }
-                }
-            }).filter(function (p) { return p; });
-            return "{" + properties.join(", ") + "}";
-        }
-        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;
-                return "new " + typeName + "(" + args.join(", ") + ")";
-            }
-        }
-        console.error("!!!!! ----- Unknown expression", ts.SyntaxKind[node.kind], node.getText());
-    };
-    return Compiler;
-}());
-exports.Compiler = Compiler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Compiler = void 0;
+var ts = require("typescript");
+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, 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)) {
+            this.visitClassDeclaration(filePath, node, writer);
+        }
+        else if (ts.isPropertyDeclaration(node)) {
+            this.visitPropertyDeclaration(node, writer);
+        }
+        else if (ts.isMethodDeclaration(node)) {
+            this.visitMethodDeclaration(node, writer);
+        }
+        else {
+            ts.forEachChild(node, function (node) {
+                _this.visit(filePath, node, writer);
+            });
+        }
+    };
+    Compiler.prototype.visitClassDeclaration = function (filePath, node, writer) {
+        var _this = this;
+        var name = node.name.text;
+        // get all parent types
+        var baseTypes = [];
+        if (node.heritageClauses) {
+            for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) {
+                var clause = _a[_i];
+                if (clause.token == ts.SyntaxKind.ExtendsKeyword || clause.token == ts.SyntaxKind.ImplementsKeyword) {
+                    for (var _b = 0, _c = clause.types; _b < _c.length; _b++) {
+                        var type = _c[_b];
+                        var typeName = type.expression.getText();
+                        baseTypes.push(typeName);
+                    }
+                }
+            }
+        }
+        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);
+            return;
+        }
+        ts.forEachChild(node, function (node) {
+            _this.visit(filePath, node, writer);
+        });
+        writer.endNewType(filePath, name);
+        this.debugLog("[COMPILER] CLASS END", name, "\n");
+    };
+    Compiler.prototype.visitPropertyDeclaration = function (node, writer) {
+        var name = node.name.getText();
+        var type = this.resolveType(node.type, writer);
+        var visibility = this.getVisibility(node);
+        var initialValue = node.initializer && this.resolveExpression(node.initializer, writer);
+        var isArray = this.isArrayType(node.type);
+        if (!type && node.initializer) {
+            type = this.tryResolveTypeFromExpression(node.initializer, writer);
+        }
+        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("[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];
+            // 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 });
+        }
+        return result;
+    };
+    Compiler.prototype.debugLog = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        console.log.apply(console, args);
+    };
+    Compiler.prototype.getComments = function (node) {
+        var commentRanges = ts.getLeadingCommentRanges(node.getFullText(), 0);
+        if (commentRanges) {
+            var comments = [];
+            var jsdocText = void 0;
+            for (var _i = 0, commentRanges_1 = commentRanges; _i < commentRanges_1.length; _i++) {
+                var range = commentRanges_1[_i];
+                var text = node.getFullText().substring(range.pos, range.end).trimStart();
+                // match only lines that starts with //@ or // @
+                var match = text.match(/\/\/\s*@(.+)/);
+                if (match) {
+                    comments.push(text.substring(match.index + 2).trim());
+                }
+                // detect JSDoc block comments /** ... */
+                else {
+                    var jsdocMatch = text.match(/^\/\*\*\s*([\s\S]*?)\s*\*\/$/);
+                    if (jsdocMatch) {
+                        jsdocText = jsdocMatch[1].replace(/^\s*\*\s?/gm, '').trim();
+                    }
+                }
+            }
+            // Synthesize @tooltip from JSDoc if no explicit @tooltip exists
+            if (jsdocText && !comments.some(function (c) { return c.startsWith("@tooltip "); })) {
+                jsdocText = Compiler.sanitizeJsdocForTooltip(jsdocText);
+                if (jsdocText) {
+                    comments.push("@tooltip " + jsdocText);
+                }
+            }
+            return comments;
+        }
+    };
+    /** Strip markdown/code/images/URLs/JSDoc tags to produce a plain-text tooltip */
+    Compiler.sanitizeJsdocForTooltip = function (text) {
+        var result = text;
+        // Remove fenced code blocks (```...```)
+        result = result.replace(/```[\s\S]*?```/g, '');
+        // Remove inline code (`...`)
+        result = result.replace(/`[^`]*`/g, '');
+        // Remove markdown image syntax ![alt](url)
+        result = result.replace(/!\[[^\]]*\]\([^)]*\)/g, '');
+        // Remove markdown links [text](url) → keep text
+        result = result.replace(/\[([^\]]*)\]\([^)]*\)/g, '$1');
+        // Remove bare URLs (http/https)
+        result = result.replace(/https?:\/\/\S+/g, '');
+        // Remove JSDoc block tags (@param, @returns, @example, etc.) and everything after them on the same line
+        result = result.replace(/@\w+[^\n]*/g, '');
+        // Collapse whitespace
+        result = result.replace(/\s+/g, ' ').trim();
+        return result;
+    };
+    Compiler.prototype.getVisibility = function (node) {
+        if (node.modifiers) {
+            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
+                var modifier = _a[_i];
+                if (modifier.kind === ts.SyntaxKind.PublicKeyword) {
+                    return base_compiler_1.Visibility.Public;
+                }
+                else if (modifier.kind === ts.SyntaxKind.ProtectedKeyword) {
+                    return base_compiler_1.Visibility.Protected;
+                }
+                else if (modifier.kind === ts.SyntaxKind.PrivateKeyword) {
+                    return base_compiler_1.Visibility.Private;
+                }
+            }
+        }
+        return base_compiler_1.Visibility.Public;
+    };
+    Compiler.prototype.tryResolveTypeFromExpression = function (exp, write) {
+        var _a;
+        if (ts.isNewExpression(exp)) {
+            // try get generic type from expression
+            if ((_a = exp.typeArguments) === null || _a === void 0 ? void 0 : _a.length) {
+                for (var _i = 0, _b = exp.typeArguments; _i < _b.length; _i++) {
+                    var arg = _b[_i];
+                    var type = this.resolveType(arg, write);
+                    if (type) {
+                        return type;
+                    }
+                }
+            }
+            var typeName = exp.expression.getText();
+            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) {
+        if (!typeNode)
+            return undefined;
+        // check if its an array
+        if (this.isArrayType(typeNode)) {
+            if (typeNode.kind === ts.SyntaxKind.ArrayType) {
+                var arrayType = typeNode;
+                return this.resolveType(arrayType.elementType, writer);
+            }
+            // check if its Array<> or Map
+            if (typeNode.kind === ts.SyntaxKind.TypeReference) {
+                var typeReference = typeNode;
+                if (typeReference.typeName.getText() === "Array") {
+                    var typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
+                    return this.resolveType(typeArgument, writer);
+                }
+                else if (typeReference.typeName.getText() === "Map") {
+                    var typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
+                    return this.resolveType(typeArgument, writer);
+                }
+            }
+            // check if its dictionary
+            if (typeNode.kind === ts.SyntaxKind.TypeLiteral) {
+                var typeLiteral = typeNode;
+                var members = typeLiteral.members;
+                if (members.length === 2) {
+                    var firstMember = members[0];
+                    var secondMember = members[1];
+                    if (firstMember.kind === ts.SyntaxKind.IndexSignature && secondMember.kind === ts.SyntaxKind.IndexSignature) {
+                        var firstIndexSignature = firstMember;
+                        var secondIndexSignature = secondMember;
+                        var firstIndexType = firstIndexSignature.parameters[0].type;
+                        var secondIndexType = secondIndexSignature.parameters[0].type;
+                        if (firstIndexType.kind === ts.SyntaxKind.StringKeyword && secondIndexType.kind === ts.SyntaxKind.NumberKeyword) {
+                            var valueType = firstIndexSignature.type;
+                            return this.resolveType(valueType, writer);
+                        }
+                    }
+                }
+            }
+            // is generic
+            // if (typeNode.kind === ts.SyntaxKind.TypeReference) {
+            //     const typeReference = typeNode as ts.TypeReferenceNode;
+            //     const typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
+            //     return this.resolveType(typeArgument, writer);
+            // }
+            console.error("!!!!! ----- Unknown array type", typeNode.getText());
+        }
+        // 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(typeNode.getText(), writer);
+    };
+    Compiler.prototype.resolveTypeFromString = function (type, writer) {
+        var resolved = writer.resolveCSharpTypeName(type);
+        return resolved || type;
+    };
+    Compiler.prototype.isArrayType = function (typeNode) {
+        if (!typeNode)
+            return false;
+        // check if its an array
+        if (typeNode.kind === ts.SyntaxKind.ArrayType) {
+            return true;
+        }
+        // check if its Array<> or map
+        if (typeNode.kind === ts.SyntaxKind.TypeReference) {
+            var typeReference = typeNode;
+            if (typeReference.typeName.getText() === "Array") {
+                return true;
+            }
+            else if (typeReference.typeName.getText() === "Map") {
+                return true;
+            }
+        }
+        // check if its array or dictionary
+        if (typeNode.kind === ts.SyntaxKind.TypeLiteral) {
+            var typeLiteral = typeNode;
+            if (typeLiteral.members.length === 2) {
+                var first = typeLiteral.members[0];
+                var second = typeLiteral.members[1];
+                if (first.kind === ts.SyntaxKind.IndexSignature && second.kind === ts.SyntaxKind.IndexSignature) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    Compiler.prototype.resolveExpression = function (node, writer) {
+        var _this = this;
+        if (ts.isStringLiteral(node)) {
+            return this.resolveTypeFromString(node.text, writer);
+        }
+        else if (ts.isNumericLiteral(node)) {
+            return this.resolveTypeFromString(node.text, writer);
+        }
+        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);
+        }
+        else if (ts.isPropertyAccessExpression(node)) {
+            var left = this.resolveExpression(node.expression, writer);
+            if (left) {
+                return left + "." + this.resolveTypeFromString(node.name.text, writer);
+            }
+        }
+        else if (ts.isCallExpression(node)) {
+            var left = this.resolveExpression(node.expression, writer);
+            if (left) {
+                var args = node.arguments.map(function (a) { return _this.resolveExpression(a, writer); }).filter(function (a) { return a; });
+                return left + "(" + args.join(", ") + ")";
+            }
+        }
+        else if (ts.isBinaryExpression(node)) {
+            var left = this.resolveExpression(node.left, writer);
+            var right = this.resolveExpression(node.right, writer);
+            if (left && right) {
+                return left + " " + node.operatorToken.getText() + " " + right;
+            }
+        }
+        else if (ts.isPrefixUnaryExpression(node)) {
+            var operand = this.resolveExpression(node.operand, writer);
+            if (operand) {
+                return ts.tokenToString(node.operator) + operand;
+            }
+        }
+        else if (ts.isPostfixUnaryExpression(node)) {
+            var operand = this.resolveExpression(node.operand, writer);
+            if (operand) {
+                return operand + node.operator;
+            }
+        }
+        else if (ts.isParenthesizedExpression(node)) {
+            return this.resolveExpression(node.expression, writer);
+        }
+        else if (ts.isArrayLiteralExpression(node)) {
+            var elements = node.elements.map(function (e) { return _this.resolveExpression(e, writer); }).filter(function (e) { return e; });
+            return "[" + elements.join(", ") + "]";
+        }
+        else if (ts.isObjectLiteralExpression(node)) {
+            var properties = node.properties.map(function (p) {
+                if (ts.isPropertyAssignment(p)) {
+                    var name_2 = p.name.getText();
+                    var value = _this.resolveExpression(p.initializer, writer);
+                    if (value) {
+                        return name_2 + ": " + value;
+                    }
+                }
+            }).filter(function (p) { return p; });
+            return "{" + properties.join(", ") + "}";
+        }
+        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;
+                return "new " + typeName + "(" + args.join(", ") + ")";
+            }
+        }
+        console.error("!!!!! ----- Unknown expression", ts.SyntaxKind[node.kind], node.getText());
+    };
+    return Compiler;
+}());
+exports.Compiler = Compiler;