@needle-tools/needle-component-compiler 2.4.0-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/dist/impl/blender-compiler.js

@@ -0,0 +1,179 @@
+"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 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 (_super) {
+    __extends(BlenderWriter, _super);
+    function BlenderWriter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    BlenderWriter.prototype.resolveCSharpTypeName = function (typeName, comments) {
+        typeName = typeName.toLocaleLowerCase();
+        if (typeName.startsWith("three."))
+            typeName = typeName.substring("three.".length);
+        switch (typeName) {
+            case "number":
+                return "float";
+            case "int":
+                return "int";
+            case "boolean":
+                return "bool";
+            case "string":
+                return "string";
+            case "void":
+                return "void";
+            case "vector2":
+                return "vec2";
+            case "vector3":
+                return "vec3";
+            case "vector4":
+                return "vec4";
+            case "quaternion":
+                return "quat";
+            case "euler":
+                return "vec3";
+            case "color":
+                return "col";
+            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.startNewType = function (filePath, typeName, baseTypes, comments) {
+        var isSupportedType = false;
+        for (var i = 0; i < knownBaseTypes.length; i++) {
+            if (baseTypes.includes(knownBaseTypes[i])) {
+                isSupportedType = true;
+                break;
+            }
+        }
+        // console.log(baseTypes, knownBaseTypes, isSupportedType)
+        if (!isSupportedType)
+            return false;
+        this.writer.beginBlock("{");
+        if (comments)
+            console.log(comments);
+        this.writer.beginBlock("\"" + typeName + "\": {");
+    };
+    BlenderWriter.prototype.endNewType = function (filePath, typeName) {
+        this.writer.endBlock("},");
+        this.writer.endBlock("}");
+        this.writeScheme(filePath, typeName);
+    };
+    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;
+        // }
+        this.writer.beginBlock("\"" + name + "\": {");
+        this.writer.writeLine("\"type\": \"" + type + "\",");
+        if (initialValue && !isArray) {
+            if (initialValue.startsWith("new "))
+                initialValue = undefined;
+            switch (type) {
+                case "bool":
+                    initialValue = initialValue.toLowerCase();
+                    break;
+                case "string":
+                    initialValue = "\"" + initialValue + "\"";
+            }
+            if (initialValue)
+                this.writer.writeLine("\"value\": " + initialValue);
+        }
+        if (isArray) {
+            this.writer.writeLine("\"value\": []");
+        }
+        this.writer.endBlock("},");
+    };
+    BlenderWriter.prototype.writeMethod = function (visibility, name, returnType, args, comments) {
+        if (visibility !== base_compiler_1.Visibility.Public)
+            return;
+        this.writer.beginBlock("\"" + name + "\": {");
+        this.writer.writeLine("\"type\": \"fn\",");
+        this.writer.endBlock("},");
+    };
+    BlenderWriter.prototype.writeNewTypeExpression = function (typeName, args) {
+        console.log("new type:", typeName);
+    };
+    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;
+}