@needle-tools/needle-component-compiler 3.0.0-alpha → 3.0.0-alpha.1.42c96bd

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

@@ -1,14 +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;
-}
+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

@@ -1,179 +1,185 @@
-"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");
+"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;
+        // }
+        // @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

@@ -1,16 +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;
-}
+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;
+}