@needle-tools/needle-component-compiler 3.0.2 → 3.0.3-f6b855c

package/Changelog.md

@@ -4,6 +4,23 @@ 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).
 
+## [3.0.3] - 2026-03-11
+
+### Fixed
+- Fix `Promise<T>` return types passing through as `Promise` instead of resolving to `void`
+- Fix unknown/web-only types (e.g. user-defined interfaces) in method parameters passing through instead of becoming `object`
+- Fix `@nonSerialized` comment directive not being respected on methods (only worked on fields before)
+- Fix `void` in union return types not being filtered out (e.g. `void | boolean` now correctly resolves to `bool`)
+- Fix enum types in method parameters and return types becoming `object` instead of preserving the enum name
+
+### Added
+- `@type` override on methods: `// @type ReturnType` overrides the return type, `// @type paramName ParamType` overrides a specific parameter's type
+- C# enum generation: exported enums are now generated as separate `.cs` files in the `Needle.Typescript.GeneratedComponents` namespace
+  - Supports numeric enums (with explicit or auto-incremented values) and string enums
+  - Lowercase enum names are automatically PascalCased (e.g. `lightType` → `LightType`)
+  - Non-exported enums are registered for type resolution but not generated as files
+  - Opt out per enum with `// @dont-generate-enum`
+
 ## [3.0.1] - 2026-03-04
 
 ### Fixed

package/dist/BaseWriter.d.ts

@@ -14,6 +14,8 @@ export declare abstract class BaseWriter implements IWriter {
     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;
+    /** Override to generate enum output. Default is no-op. */
+    writeEnum(name: string, members: EnumMember[], comments?: string[]): void;
     private _currentlyProcessingFiles;
     get outputInfo(): TypeSourceInformation;
     private _createdSchemesPerFile;

package/dist/BaseWriter.js

@@ -23,6 +23,10 @@ var BaseWriter = /** @class */ (function () {
     BaseWriter.prototype.registerEnum = function (name, members) {
         this._enumRegistry.set(name.toLowerCase(), members);
     };
+    /** Override to generate enum output. Default is no-op. */
+    BaseWriter.prototype.writeEnum = function (name, members, comments) {
+        // no-op by default — subclasses can override
+    };
     Object.defineProperty(BaseWriter.prototype, "outputInfo", {
         get: function () {
             return this._createdSchemesPerFile;

package/dist/Compiler.js

@@ -29,11 +29,12 @@ var Compiler = /** @class */ (function () {
         writer.end(filePath);
     };
     Compiler.prototype.visitEnumDeclaration = function (node, writer) {
+        var _a;
         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];
+        for (var _i = 0, _b = node.members; _i < _b.length; _i++) {
+            var member = _b[_i];
             var memberName = member.name.getText();
             var value = void 0;
             if (member.initializer) {
@@ -61,7 +62,13 @@ var Compiler = /** @class */ (function () {
             members.push({ name: memberName, value: value });
         }
         this.debugLog("[COMPILER] ENUM", name, members);
+        // Always register for type resolution
         writer.registerEnum(name, members);
+        // Only generate enum file for exported enums
+        var isExported = (_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.some(function (m) { return m.kind === ts.SyntaxKind.ExportKeyword; });
+        if (isExported) {
+            writer.writeEnum(name, members, this.getComments(node));
+        }
     };
     Compiler.prototype.visit = function (filePath, node, writer) {
         var _this = this;

package/dist/base-compiler.d.ts

@@ -52,5 +52,6 @@ export interface IWriter {
     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;
+    writeEnum(name: string, members: EnumMember[], comments?: string[]): void;
 }
 export declare function runFromFile(writer: IWriter, path: string): Compiler;

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

@@ -1,6 +1,9 @@
 import { Argument, Visibility } from "../base-compiler";
 import { BaseWriter } from "../BaseWriter";
 export declare class CSharpWriter extends BaseWriter {
+    /** Buffered enum outputs — flushed after all classes in end() */
+    private _pendingEnums;
+    end(filePath: string | null): void;
     resolveCSharpTypeName(typescriptTypeName: string): string | void;
     /** Tries to resolve a C# type name; returns undefined if the type is not known.
      *  Checks TYPE_MAP keys/values and the enum registry. */
@@ -10,6 +13,7 @@ export declare class CSharpWriter extends BaseWriter {
     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;
+    writeEnum(name: string, members: import("../base-compiler").EnumMember[], comments?: string[]): void;
     /** Converts camelCase to PascalCase for method names */
     private toPascalCase;
     /** Resolve a "new Type(args)" expression: map TS types to C# qualified types */

package/dist/impl/csharp-compiler.js

@@ -123,8 +123,20 @@ function isEditorType(typeName) {
 var CSharpWriter = /** @class */ (function (_super) {
     __extends(CSharpWriter, _super);
     function CSharpWriter() {
-        return _super !== null && _super.apply(this, arguments) || this;
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        /** Buffered enum outputs — flushed after all classes in end() */
+        _this._pendingEnums = [];
+        return _this;
     }
+    CSharpWriter.prototype.end = function (filePath) {
+        // Flush buffered enums AFTER all class outputs
+        for (var _i = 0, _a = this._pendingEnums; _i < _a.length; _i++) {
+            var pending = _a[_i];
+            this.sink.flush(pending.name + ".cs", pending.content);
+        }
+        this._pendingEnums.length = 0;
+        _super.prototype.end.call(this, filePath);
+    };
     CSharpWriter.prototype.resolveCSharpTypeName = function (typescriptTypeName) {
         var _a, _b;
         if (!typescriptTypeName)
@@ -275,6 +287,25 @@ var CSharpWriter = /** @class */ (function (_super) {
         // @contextmenu on method → add attribute
         var contextMenuComment = comments === null || comments === void 0 ? void 0 : comments.find(function (c) { return c.startsWith("@contextmenu "); });
         var contextMenu = contextMenuComment ? contextMenuComment.substring("@contextmenu ".length).trim() : null;
+        // @type overrides: "@type ReturnType" for return, "@type paramName ParamType" for params
+        var returnTypeOverride;
+        var paramTypeOverrides = {};
+        if (comments) {
+            for (var _i = 0, comments_1 = comments; _i < comments_1.length; _i++) {
+                var c = comments_1[_i];
+                if (!c.startsWith("@type "))
+                    continue;
+                var parts = c.substring("@type ".length).trim().split(/\s+/);
+                if (parts.length >= 2) {
+                    // "@type paramName Type" → param override
+                    paramTypeOverrides[parts[0]] = parts.slice(1).join(" ");
+                }
+                else if (parts.length === 1) {
+                    // "@type Type" → return type override
+                    returnTypeOverride = parts[0];
+                }
+            }
+        }
         // Only emit public methods and lifecycle methods (which are always public)
         var lifecycleName = LIFECYCLE_METHODS[name];
         if (visibility !== base_compiler_1.Visibility.Public && !lifecycleName)
@@ -285,7 +316,10 @@ var CSharpWriter = /** @class */ (function (_super) {
         var paramList = (_a = args === null || args === void 0 ? void 0 : args.map(function (arg) {
             var _a;
             var csharpType;
-            if (!arg.type || arg.type.includes("{")) {
+            if (paramTypeOverrides[arg.name]) {
+                csharpType = paramTypeOverrides[arg.name];
+            }
+            else if (!arg.type || arg.type.includes("{")) {
                 csharpType = "object";
             }
             else {
@@ -293,9 +327,7 @@ var CSharpWriter = /** @class */ (function (_super) {
             }
             return "".concat(csharpType, " @").concat(arg.name);
         }).join(", ")) !== null && _a !== void 0 ? _a : "";
-        var csReturnType = returnType
-            ? ((_b = this.resolveKnownCSharpTypeName(returnType)) !== null && _b !== void 0 ? _b : "void")
-            : "void";
+        var csReturnType = returnTypeOverride !== null && returnTypeOverride !== void 0 ? returnTypeOverride : (returnType ? ((_b = this.resolveKnownCSharpTypeName(returnType)) !== null && _b !== void 0 ? _b : "void") : "void");
         if (contextMenu)
             this.writer.writeLine("[UnityEngine.ContextMenu(\"".concat(contextMenu, "\")]"));
         this.writer.writeLine("public ".concat(csReturnType, " ").concat(methodName, "(").concat(paramList, ") {}"));
@@ -303,6 +335,29 @@ var CSharpWriter = /** @class */ (function (_super) {
     CSharpWriter.prototype.writeNewTypeExpression = function (typeName, args) {
         // no-op for C# output
     };
+    CSharpWriter.prototype.writeEnum = function (name, members, comments) {
+        // @dont-generate-enum → skip
+        if (comments === null || comments === void 0 ? void 0 : comments.some(function (c) { return c.startsWith("@dont-generate-enum"); }))
+            return;
+        // PascalCase: ensure first letter is uppercase
+        var pascalName = name.charAt(0).toUpperCase() + name.slice(1);
+        this.writer.beginBlock("namespace Needle.Typescript.GeneratedComponents\n{");
+        this.writer.beginBlock("public enum ".concat(pascalName, "\n{"));
+        for (var _i = 0, members_1 = members; _i < members_1.length; _i++) {
+            var member = members_1[_i];
+            if (typeof member.value === "string") {
+                // String enums can't have values in C# — emit name only
+                this.writer.writeLine("".concat(member.name, ","));
+            }
+            else {
+                this.writer.writeLine("".concat(member.name, " = ").concat(member.value, ","));
+            }
+        }
+        this.writer.endBlock("}");
+        this.writer.endBlock("}");
+        // Buffer the output — flush after all classes in end()
+        this._pendingEnums.push({ name: pascalName, content: this.writer.flush() });
+    };
     // ── Helpers ────────────────────────────────────────────────────────────
     /** Converts camelCase to PascalCase for method names */
     CSharpWriter.prototype.toPascalCase = function (name) {

package/dist/impl/react-three-fiber-compiler.d.ts

@@ -17,4 +17,5 @@ export declare class ReactThreeFiberCompiler implements IWriter {
     }[], comments: string[]): void;
     writeNewTypeExpression(typeName: string, args?: string[]): void;
     registerEnum(name: string, members: import("../base-compiler").EnumMember[]): void;
+    writeEnum(name: string, members: import("../base-compiler").EnumMember[], comments?: string[]): void;
 }

package/dist/impl/react-three-fiber-compiler.js

@@ -31,6 +31,8 @@ var ReactThreeFiberCompiler = /** @class */ (function () {
     };
     ReactThreeFiberCompiler.prototype.registerEnum = function (name, members) {
     };
+    ReactThreeFiberCompiler.prototype.writeEnum = function (name, members, comments) {
+    };
     return ReactThreeFiberCompiler;
 }());
 exports.ReactThreeFiberCompiler = ReactThreeFiberCompiler;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "3.0.2",
+    "version": "3.0.3-f6b855c",
     "description": "Compile Editor components for Needle Engine for C# and Blender",
     "main": "dist/index.js",
     "bin": {
@@ -57,7 +57,7 @@
         "url": "git+https://github.com/needle-tools/needle-tiny-component-compiler.git"
     },
     "publishConfig": {
-      "access": "public",
-      "registry": "https://registry.npmjs.org/"
+        "access": "public",
+        "registry": "https://registry.npmjs.org/"
     }
-}
+}