@needle-tools/needle-component-compiler 2.4.0-pre → 3.0.0-68ab237

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

@@ -1,507 +1,461 @@
-"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");
-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 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 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);
-        writer.begin(filePath);
-        ts.forEachChild(sourceFile, function (node) {
-            _this.visit(filePath, node, writer);
-        });
-        writer.end(filePath);
-    };
-    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("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("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("PROPERTY", Visibility[visibility], name, isArray, type, initialValue);
-        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);
-        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);
-        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 Visibility.Public;
-                }
-                else if (modifier.kind === ts.SyntaxKind.ProtectedKeyword) {
-                    return Visibility.Protected;
-                }
-                else if (modifier.kind === ts.SyntaxKind.PrivateKeyword) {
-                    return Visibility.Private;
-                }
-            }
-        }
-        return 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();
-            // 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;
-        }
-    };
-    Compiler.prototype.resolveType = function (typeNode, writer) {
-        var _a;
-        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());
-        }
-        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);
-                    }
-                }
-            }
-        }
-        return this.resolveTypeFromString(type, writer);
-    };
-    Compiler.prototype.resolveTypeFromString = function (type, writer) {
-        var resolved = writer.resolveTypeName(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);
-        }
-        // 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 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) {
-                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);
+        writer.begin(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);
+            }
+        });
+        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 if (ts.isStringLiteral(member.initializer)) {
+                    // String enum value — use .text to get the raw string without surrounding quotes
+                    value = member.initializer.text;
+                }
+                else {
+                    // Other 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) {
+        // Skip static and abstract properties — they don't map to serialized fields
+        if (node.modifiers) {
+            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
+                var modifier = _a[_i];
+                if (modifier.kind === ts.SyntaxKind.StaticKeyword ||
+                    modifier.kind === ts.SyntaxKind.AbstractKeyword) {
+                    return;
+                }
+            }
+        }
+        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;