@needle-tools/needle-component-compiler 3.0.1 → 3.0.2-130283d

package/dist/Compiler.js

@@ -328,7 +328,8 @@ var Compiler = /** @class */ (function () {
             for (var _i = 0, _a = typeNode.types; _i < _a.length; _i++) {
                 var member = _a[_i];
                 if (member.kind !== ts.SyntaxKind.NullKeyword &&
-                    member.kind !== ts.SyntaxKind.UndefinedKeyword) {
+                    member.kind !== ts.SyntaxKind.UndefinedKeyword &&
+                    member.kind !== ts.SyntaxKind.VoidKeyword) {
                     return this.resolveType(member, writer);
                 }
             }
@@ -337,7 +338,12 @@ var Compiler = /** @class */ (function () {
         // TypeReference: use base name only (strips generic args like EventList<void> → EventList)
         if (typeNode.kind === ts.SyntaxKind.TypeReference) {
             var typeReference = typeNode;
-            return this.resolveTypeFromString(typeReference.typeName.getText(), writer);
+            var typeName = typeReference.typeName.getText();
+            // Promise<T> → resolve to void (no C# equivalent for async stubs)
+            if (typeName === "Promise") {
+                return undefined;
+            }
+            return this.resolveTypeFromString(typeName, writer);
         }
         return this.resolveTypeFromString(typeNode.getText(), writer);
     };

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

@@ -2,6 +2,9 @@ import { Argument, Visibility } from "../base-compiler";
 import { BaseWriter } from "../BaseWriter";
 export declare class CSharpWriter extends BaseWriter {
     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. */
+    resolveKnownCSharpTypeName(typeName: string): string | undefined;
     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;

package/dist/impl/csharp-compiler.js

@@ -73,6 +73,7 @@ var TYPE_MAP = {
     // Physics / Colliders
     "ICollider": "UnityEngine.Collider",
     // UI
+    "Button": "UnityEngine.UI.Button",
     "Text": "UnityEngine.UI.Text",
     "Image": "UnityEngine.UI.Image",
     "RawImage": "UnityEngine.UI.RawImage",
@@ -86,6 +87,8 @@ var TYPE_MAP = {
     "Rigidbody": "UnityEngine.Rigidbody",
     "Map": "System.Collections.Generic.Dictionary",
 };
+/** Set of all known C# type names (values from TYPE_MAP) for reverse-lookup */
+var KNOWN_CSHARP_TYPES = new Set(Object.values(TYPE_MAP));
 /** Lifecycle method name mappings: camelCase TS → PascalCase C# */
 var LIFECYCLE_METHODS = {
     "awake": "Awake",
@@ -130,6 +133,25 @@ var CSharpWriter = /** @class */ (function (_super) {
         var stripped = typescriptTypeName.startsWith("THREE.") ? typescriptTypeName.substring(6) : typescriptTypeName;
         return (_b = (_a = TYPE_MAP[typescriptTypeName]) !== null && _a !== void 0 ? _a : TYPE_MAP[stripped]) !== null && _b !== void 0 ? _b : typescriptTypeName;
     };
+    /** Tries to resolve a C# type name; returns undefined if the type is not known.
+     *  Checks TYPE_MAP keys/values and the enum registry. */
+    CSharpWriter.prototype.resolveKnownCSharpTypeName = function (typeName) {
+        var _a;
+        if (!typeName)
+            return undefined;
+        // Check if it's a TS type name in the map
+        var stripped = typeName.startsWith("THREE.") ? typeName.substring(6) : typeName;
+        var mapped = (_a = TYPE_MAP[typeName]) !== null && _a !== void 0 ? _a : TYPE_MAP[stripped];
+        if (mapped)
+            return mapped;
+        // Check if it's already a resolved C# type (e.g. "float", "UnityEngine.Vector3")
+        if (KNOWN_CSHARP_TYPES.has(typeName))
+            return typeName;
+        // Check if it's a registered enum type
+        if (this._enumRegistry.has(typeName.toLowerCase()))
+            return typeName;
+        return undefined;
+    };
     CSharpWriter.prototype.startNewType = function (filePath, typeName, baseTypes, comments) {
         var _a;
         if (comments === null || comments === void 0 ? void 0 : comments.includes("@dont-generate-component"))
@@ -247,6 +269,9 @@ var CSharpWriter = /** @class */ (function (_super) {
         var _a, _b;
         if (allowDebugLogs)
             console.log("[CSharp] writeMethod", name, returnType);
+        // @nonSerialized → skip entirely
+        if (comments === null || comments === void 0 ? void 0 : comments.some(function (c) { return c.startsWith("@nonSerialized"); }))
+            return;
         // @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;
@@ -256,20 +281,20 @@ var CSharpWriter = /** @class */ (function (_super) {
             return;
         // Lifecycle methods get PascalCase; regular public methods keep their name as-is
         var methodName = lifecycleName !== null && lifecycleName !== void 0 ? lifecycleName : name;
-        // Build parameter list — inline object types (e.g. { x: number }) resolve to "object"
+        // Build parameter list — unknown/unmapped types resolve to "object"
         var paramList = (_a = args === null || args === void 0 ? void 0 : args.map(function (arg) {
-            var _a, _b;
+            var _a;
             var csharpType;
             if (!arg.type || arg.type.includes("{")) {
                 csharpType = "object";
             }
             else {
-                csharpType = (_b = (_a = _this.resolveCSharpTypeName(arg.type)) !== null && _a !== void 0 ? _a : arg.type) !== null && _b !== void 0 ? _b : "object";
+                csharpType = (_a = _this.resolveKnownCSharpTypeName(arg.type)) !== null && _a !== void 0 ? _a : "object";
             }
             return "".concat(csharpType, " @").concat(arg.name);
         }).join(", ")) !== null && _a !== void 0 ? _a : "";
         var csReturnType = returnType
-            ? ((_b = this.resolveCSharpTypeName(returnType)) !== null && _b !== void 0 ? _b : returnType)
+            ? ((_b = this.resolveKnownCSharpTypeName(returnType)) !== null && _b !== void 0 ? _b : "void")
             : "void";
         if (contextMenu)
             this.writer.writeLine("[UnityEngine.ContextMenu(\"".concat(contextMenu, "\")]"));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "3.0.1",
+    "version": "3.0.2-130283d",
     "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/"
     }
-}
+}