@needle-tools/needle-component-compiler 2.4.0-pre → 3.0.0-alpha

package/Changelog.md

@@ -4,7 +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).
 
-## [2.4.0-pre] - 2022-11-22
+## [2.4.1-pre] - 2023-04-03
+# Blender compiler
+- Add: typenames
+
+## [2.4.0-pre] - 2023-03-31
 # Blender compiler
 - Add: emit types from declared class implementing `IComponent` e.g. ``declare class MyComp implements IComponent``
 

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,19 +114,31 @@ 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) {
@@ -293,17 +180,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 +206,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 +274,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 +337,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 +367,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 +398,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;

package/dist/base-compiler.d.ts

@@ -0,0 +1,54 @@
+import { TypeSourceInformation } from "./register-types";
+import { Compiler } from "./Compiler";
+export declare enum Visibility {
+    Public = 0,
+    Protected = 1,
+    Private = 2
+}
+export declare type Argument = {
+    name: string;
+    type: string;
+    defaultValue?: string;
+};
+export interface ISink {
+    flush(id: string, str: string): string;
+}
+export declare class FileSink implements ISink {
+    private directory;
+    constructor(directory: string);
+    flush(id: string, str: string): string;
+}
+export declare class MemorySink implements ISink {
+    results: string[];
+    clear(): void;
+    flush(id: string, str: string): string;
+}
+export declare class CodeTextWriter {
+    private indent;
+    private lines;
+    beginBlock(line: string): void;
+    endBlock(line: string): void;
+    writeLine(line: string): void;
+    write(text: string): void;
+    flush(): string;
+    clear(): void;
+    toString(): string;
+}
+export declare function handleDeletedFile(filePath: string, types: TypeSourceInformation): void;
+export declare type EnumMember = {
+    name: string;
+    value: number | string;
+};
+export interface IWriter {
+    get outputInfo(): TypeSourceInformation;
+    begin(filePath: string | null): void;
+    resolveCSharpTypeName(typescriptTypeName: string, baseTypes?: string[]): string | void;
+    end(filePath: string | null): void;
+    startNewType(filePath: string | null, typeName: string, baseType: string[], comments?: string[]): void | boolean;
+    endNewType(filePath: string | null, typeName: string): void;
+    writeMember(visibility: Visibility, name: string, isArray: boolean, type: string, initialValue?: string, comments?: string[]): void;
+    writeMethod(visibility: Visibility, name: string, returnType: string | undefined, args: Argument[], comments: string[]): void;
+    writeNewTypeExpression(typeName: string, args?: string[]): void;
+    registerEnum(name: string, members: EnumMember[]): void;
+}
+export declare function runFromFile(writer: IWriter, path: string): Compiler;