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

package/dist/base-compiler.d.ts

@@ -0,0 +1,56 @@
+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;
+    private static readonly CODEGEN_START;
+    private static readonly CODEGEN_END;
+    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;

package/dist/base-compiler.js

@@ -0,0 +1,182 @@
+"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;
+        // If the file already exists and contains codegen fences,
+        // preserve content outside the fences
+        if (fs.existsSync(fullPath)) {
+            var existing = fs.readFileSync(fullPath, "utf-8");
+            var startIdx = existing.indexOf(FileSink.CODEGEN_START);
+            var endIdx = existing.indexOf(FileSink.CODEGEN_END);
+            if (startIdx !== -1 && endIdx !== -1) {
+                var before_1 = existing.substring(0, startIdx);
+                var after_1 = existing.substring(endIdx + FileSink.CODEGEN_END.length);
+                str = before_1 + str + after_1;
+            }
+        }
+        fs.writeFileSync(fullPath, str);
+        return fs.realpathSync(fullPath);
+    };
+    FileSink.CODEGEN_START = "// NEEDLE_CODEGEN_START";
+    FileSink.CODEGEN_END = "// NEEDLE_CODEGEN_END";
+    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 += "\t";
+        }
+        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("\n");
+    };
+    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/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs = require("fs");
+var path = require("path");
+var Compiler_1 = require("./Compiler");
+var base_compiler_1 = require("./base-compiler");
+var csharp_compiler_1 = require("./impl/csharp-compiler");
+var blender_compiler_1 = require("./impl/blender-compiler");
+var pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf-8"));
+var args = process.argv.slice(2);
+if (args.includes("--version") || args.includes("-v")) {
+    console.log("needle-component-compiler v".concat(pkg.version));
+    process.exit(0);
+}
+if (args.includes("--help") || args.includes("-h") || args.length < 3) {
+    console.log("needle-component-compiler v".concat(pkg.version));
+    console.log("");
+    console.log("Usage: needle-component-compiler <target> <output_dir> <input_files...>");
+    console.log("");
+    console.log("  target       csharp or blender");
+    console.log("  output_dir   directory for generated files");
+    console.log("  input_files  one or more .ts source files");
+    console.log("");
+    console.log("Flags:");
+    console.log("  --version, -v   print version");
+    console.log("  --help, -h      print this help");
+    if (args.length < 3 && !args.includes("--help") && !args.includes("-h")) {
+        process.exit(1);
+    }
+    process.exit(0);
+}
+var target = args[0];
+var outputDir = args[1];
+var inputFiles = args.slice(2);
+if (target !== "csharp" && target !== "blender") {
+    console.error("Error: unknown target \"".concat(target, "\". Use \"csharp\" or \"blender\"."));
+    process.exit(1);
+}
+console.log("needle-component-compiler v".concat(pkg.version));
+var sink = new base_compiler_1.FileSink(outputDir);
+var writer = target === "csharp" ? new csharp_compiler_1.CSharpWriter(sink) : new blender_compiler_1.BlenderWriter(sink);
+var compiler = new Compiler_1.Compiler();
+var hasErrors = false;
+for (var _i = 0, inputFiles_1 = inputFiles; _i < inputFiles_1.length; _i++) {
+    var filePath = inputFiles_1[_i];
+    try {
+        if (!fs.existsSync(filePath)) {
+            console.error("Error: file not found: ".concat(filePath));
+            hasErrors = true;
+            continue;
+        }
+        var code = fs.readFileSync(filePath, "utf-8");
+        compiler.compile(writer, code, filePath);
+    }
+    catch (e) {
+        console.error("Error processing ".concat(filePath, ": ").concat(e));
+        hasErrors = true;
+    }
+}
+if (hasErrors) {
+    process.exit(1);
+}

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/{src → dist}/commands.js

@@ -1,15 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendFileDeletedCommand = exports.sendFileWrittenCommand = exports.sendReloadCommand = void 0;
-function sendReloadCommand() {
-    process.stdout.write("CMD:reload\r");
-}
-exports.sendReloadCommand = sendReloadCommand;
-function sendFileWrittenCommand(path) {
-    process.stdout.write("CMD:writefile " + path + "\r");
-}
-exports.sendFileWrittenCommand = sendFileWrittenCommand;
-function sendFileDeletedCommand(path) {
-    process.stdout.write("CMD:deletedfile " + path + "\r");
-}
-exports.sendFileDeletedCommand = sendFileDeletedCommand;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendFileDeletedCommand = exports.sendFileWrittenCommand = exports.sendReloadCommand = void 0;
+function sendReloadCommand() {
+    process.stdout.write("CMD:reload\r");
+}
+exports.sendReloadCommand = sendReloadCommand;
+function sendFileWrittenCommand(path) {
+    process.stdout.write("CMD:writefile " + path + "\r");
+}
+exports.sendFileWrittenCommand = sendFileWrittenCommand;
+function sendFileDeletedCommand(path) {
+    process.stdout.write("CMD:deletedfile " + path + "\r");
+}
+exports.sendFileDeletedCommand = sendFileDeletedCommand;

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,195 @@
+"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);
+        // If the type is a registered enum, return as-is so writeMember handles it
+        if (this._enumRegistry.has(typeName))
+            return typeName;
+        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) {
+        if (comments === null || comments === void 0 ? void 0 : comments.includes("@dont-generate-component"))
+            return false;
+        var isSupportedType = false;
+        for (var i = 0; i < knownBaseTypes.length; i++) {
+            if (baseTypes.includes(knownBaseTypes[i])) {
+                isSupportedType = true;
+                break;
+            }
+        }
+        if (!isSupportedType)
+            return false;
+        this.writer.beginBlock("{");
+        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;
+        // @nonSerialized → skip entirely
+        if (comments === null || comments === void 0 ? void 0 : comments.some(function (c) { return c.startsWith("@nonSerialized"); }))
+            return;
+        // @type override
+        var typeOverride = comments === null || comments === void 0 ? void 0 : comments.find(function (c) { return c.startsWith("@type "); });
+        if (typeOverride) {
+            type = typeOverride.substring("@type ".length).trim();
+        }
+        // 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;
+        // }
+        // @tooltip → description
+        var tooltipComment = comments === null || comments === void 0 ? void 0 : comments.find(function (c) { return c.startsWith("@tooltip "); });
+        var tooltip = tooltipComment ? tooltipComment.substring("@tooltip ".length).trim() : null;
+        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\": [],");
+        }
+        if (tooltip) {
+            this.writer.writeLine("\"description\": \"" + tooltip.replace(/"/g, "'") + "\"");
+        }
+        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;
+}