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

package/dist/base-compiler.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFromFile = exports.handleDeletedFile = exports.CodeTextWriter = exports.MemorySink = exports.FileSink = exports.Visibility = void 0;
+var fs_1 = require("fs");
+var fs = require("fs");
+var commands_1 = require("./commands");
+var Compiler_1 = require("./Compiler");
+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_1.Compiler();
+    compiler.compile(writer, code, path);
+    return compiler;
+}
+exports.runFromFile = runFromFile;

package/dist/commands.d.ts

@@ -0,0 +1,3 @@
+export declare function sendReloadCommand(): void;
+export declare function sendFileWrittenCommand(path: string): void;
+export declare function sendFileDeletedCommand(path: string): void;

package/dist/component-compiler.d.ts

@@ -0,0 +1,3 @@
+import * as ts from "typescript";
+export declare function compile(code: string, fileName: string, outputDir: string | null, debugLogs?: boolean): string[];
+export declare function run(program: ts.Program, outputDir: string | null, sourceFile: ts.SourceFile): string[];

package/{src → dist}/component-compiler.js

@@ -1,4 +1,9 @@
 "use strict";
+/*
+
+V1 csharp compiler
+
+*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.run = exports.compile = void 0;
 var fs_1 = require("fs");

package/dist/impl/blender-compiler.d.ts

@@ -0,0 +1,14 @@
+import { Visibility } from "../base-compiler";
+import { BaseWriter } from "../BaseWriter";
+export declare class BlenderWriter extends BaseWriter {
+    resolveCSharpTypeName(typeName: string, comments?: string[]): string | void;
+    startNewType(filePath: string | null, typeName: string, baseTypes: 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: {
+        name: string;
+        type: string;
+        defaultValue?: string;
+    }[], comments?: string[]): void;
+    writeNewTypeExpression(typeName: string, args?: string[]): void;
+}

package/{src → dist/impl}/blender-compiler.js

@@ -1,33 +1,31 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlenderWriter = void 0;
-var fs_1 = require("fs");
-var base_compiler_1 = require("./base-compiler");
-var commands_1 = require("./commands");
+var base_compiler_1 = require("../base-compiler");
+var BaseWriter_1 = require("../BaseWriter");
 var supportedTypes = ["string", "float", "int", "bool", "col", "obj", "evt", "fn", "vec2", "vec3", "comp"];
 var knownBaseTypes = ["Behaviour", "IComponent"];
-var BlenderWriter = /** @class */ (function () {
-    function BlenderWriter(_sink) {
-        this._sink = _sink;
-        this.writer = new base_compiler_1.CodeTextWriter();
-        this._createdSchemesPerFile = {};
-        this._currentlyProcessingFiles = {};
+var BlenderWriter = /** @class */ (function (_super) {
+    __extends(BlenderWriter, _super);
+    function BlenderWriter() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    Object.defineProperty(BlenderWriter.prototype, "outputInfo", {
-        get: function () {
-            return this._createdSchemesPerFile;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(BlenderWriter.prototype, "sink", {
-        get: function () {
-            return this._sink;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    BlenderWriter.prototype.resolveTypeName = function (typeName, comments) {
+    BlenderWriter.prototype.resolveCSharpTypeName = function (typeName, comments) {
         typeName = typeName.toLocaleLowerCase();
         if (typeName.startsWith("three."))
             typeName = typeName.substring("three.".length);
@@ -57,64 +55,47 @@ var BlenderWriter = /** @class */ (function () {
             case "eventlist":
                 return "evt";
             case "behaviour":
+            case "animation": // Animation component ref
+            case "animator": // Animator component ref
+            case "camera":
+            case "light":
+            case "rigidbody":
+            case "renderer": // Renderer component ref
+            case "canvas": // Canvas component ref
+            case "charactercontroller": // CharacterController component ref
+            case "videoplayer": // VideoPlayer component ref
+            case "lookatconstraint": // LookAtConstraint component ref
                 return "comp";
             case "texture":
                 return "tex";
             case "image":
                 return "img";
             case "object3d":
+            case "gameobject": // GameObject = scene object reference
                 return "obj";
+            case "vec2":
+                return "vec2";
             case "material":
                 return "mat";
             case "animationclip":
                 return "anim";
+            case "animatorcontroller":
+                return "animatorcontroller";
+            case "audioclip":
+                return "audioclip";
+            case "videoclip":
+            case "video":
+                return "videoclip";
+            case "assetreference":
+            case "asset":
+                return "assetreference";
+            case "mesh":
+                return "mesh";
+            case "timelineasset":
+                return "timeline";
         }
         return typeName;
     };
-    BlenderWriter.prototype.begin = function (filePath) {
-        if (!this._currentlyProcessingFiles[filePath]) {
-            this._currentlyProcessingFiles[filePath] = [];
-        }
-    };
-    BlenderWriter.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];
-    };
     BlenderWriter.prototype.startNewType = function (filePath, typeName, baseTypes, comments) {
         var isSupportedType = false;
         for (var i = 0; i < knownBaseTypes.length; i++) {
@@ -139,6 +120,25 @@ var BlenderWriter = /** @class */ (function () {
     BlenderWriter.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
         if (visibility !== base_compiler_1.Visibility.Public)
             return;
+        // Check if type is a registered TypeScript enum
+        var enumMembers = this._enumRegistry.get(type);
+        if (enumMembers && enumMembers.length > 0) {
+            this.writer.beginBlock("\"" + name + "\": {");
+            this.writer.writeLine("\"type\": \"enum\",");
+            // Resolve default value: try to match explicit initializer (e.g. "lighttype.spot")
+            var enumValue = enumMembers[0].value;
+            if (initialValue && initialValue.includes(".")) {
+                var memberKey_1 = initialValue.split(".").pop();
+                var found = enumMembers.find(function (m) { return m.name.toLowerCase() === memberKey_1; });
+                if (found !== undefined)
+                    enumValue = found.value;
+            }
+            this.writer.writeLine("\"value\": " + JSON.stringify(enumValue) + ",");
+            var options = enumMembers.map(function (m) { return m.name; });
+            this.writer.writeLine("\"options\": " + JSON.stringify(options));
+            this.writer.endBlock("},");
+            return;
+        }
         // if (!supportedTypes.includes(type)) {
         //     console.log("-- unsupported type:", type);
         //     return;
@@ -173,18 +173,7 @@ var BlenderWriter = /** @class */ (function () {
     BlenderWriter.prototype.writeNewTypeExpression = function (typeName, args) {
         console.log("new type:", typeName);
     };
-    BlenderWriter.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 BlenderWriter;
-}());
+}(BaseWriter_1.BaseWriter));
 exports.BlenderWriter = BlenderWriter;
 // runFromFile(new BlenderWriter("dist"), "src\\test.ts");

package/dist/impl/csharp-compiler.d.ts

@@ -0,0 +1,16 @@
+import { Argument, Visibility } from "../base-compiler";
+import { BaseWriter } from "../BaseWriter";
+export declare class CSharpWriter extends BaseWriter {
+    resolveCSharpTypeName(typescriptTypeName: string): string | void;
+    startNewType(filePath: string, typeName: string, baseTypes: string[], comments?: string[]): boolean | void;
+    endNewType(filePath: string, typeName: string): void;
+    writeMember(visibility: Visibility, name: string, isArray: boolean, type: string, initialValue?: string, comments?: string[]): void;
+    writeMethod(visibility: Visibility, name: string, returnType: string, args: Argument[], comments: string[]): void;
+    writeNewTypeExpression(typeName: string, args?: string[]): void;
+    /** Converts camelCase to PascalCase for method names */
+    private toPascalCase;
+    /** Resolve a "new Type(args)" expression: map TS types to C# qualified types */
+    private resolveNewExpression;
+    /** Override writeScheme to use .cs extension instead of .component.json */
+    protected writeCSharpScheme(processingFilePath: string | null, component: string): void;
+}