@needle-tools/needle-component-compiler 3.0.15 → 3.0.17

package/Changelog.md

@@ -4,6 +4,24 @@ 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.17] - 2026-04-17
+### Added
+- Support for string literal union types (e.g. `axis: "x" | "y" | "z" = "y"`)
+  - C#: emits as `string` field with default value
+  - Blender: emits as `enum` with string options and correct default value
+
+### Fixed
+- Blender: emit default values for `new` expressions with arguments (e.g. `new Vector3(0, 1, 0)` now emits `"value": [0, 1, 0]`)
+- Blender: emit actual values for primitive array initializers (e.g. `speeds: number[] = [1, 2, 3]` now emits `"value": [1, 2, 3]` instead of `[]`)
+- Blender: format enum `options` array with one entry per line, matching `builtin.component.json` style
+
+## [3.0.16] - 2026-03-24
+### Fixed
+- Fix array literal initializers (`= []`, `= [1, 2, 3]`) emitting C# 12 collection expressions not supported by Unity
+  - Empty arrays: initializer is omitted
+  - Non-empty primitive arrays: emit `new float[] { 1f, 2f, 3f }` syntax
+  - Non-empty non-primitive arrays: initializer is omitted
+
 ## [3.0.15] - 2026-03-23
 ### Fixed
 - Fix non-void method stubs producing uncompilable C# (`CS0161: not all code paths return a value`) by emitting `{ return default; }` instead of `{}`

package/dist/Compiler.js

@@ -392,6 +392,20 @@ var Compiler = /** @class */ (function () {
         }
         // Union types: Object3D | null | undefined → resolve the first concrete member
         if (ts.isUnionTypeNode(typeNode)) {
+            // Check if all non-null/undefined members are string literals (e.g. "none" | "XY" | "XZ")
+            var concreteMembers = typeNode.types.filter(function (m) {
+                return m.kind !== ts.SyntaxKind.NullKeyword &&
+                    m.kind !== ts.SyntaxKind.UndefinedKeyword &&
+                    m.kind !== ts.SyntaxKind.VoidKeyword;
+            });
+            if (concreteMembers.length > 0 && concreteMembers.every(function (m) { return ts.isLiteralTypeNode(m) && ts.isStringLiteral(m.literal); })) {
+                // Synthesize a virtual enum from the string literal values
+                var options = concreteMembers.map(function (m) { return m.literal.getText().replace(/^['"]|['"]$/g, ""); });
+                var syntheticName = "__strlit_" + options.join("_");
+                var members = options.map(function (o) { return ({ name: o, value: o }); });
+                writer.registerEnum(syntheticName, members);
+                return this.resolveTypeFromString(syntheticName, writer);
+            }
             for (var _b = 0, _c = typeNode.types; _b < _c.length; _b++) {
                 var member = _c[_b];
                 if (member.kind !== ts.SyntaxKind.NullKeyword &&

package/dist/impl/blender-compiler.js

@@ -136,17 +136,29 @@ var BlenderWriter = /** @class */ (function (_super) {
         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")
+            // Resolve default value: try to match explicit initializer (e.g. "lighttype.spot" or bare "none")
             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;
+            if (initialValue) {
+                if (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;
+                }
+                else {
+                    // Bare value (string literal union default, e.g. "none")
+                    var found = enumMembers.find(function (m) { return m.name.toLowerCase() === initialValue.toLowerCase() || String(m.value).toLowerCase() === initialValue.toLowerCase(); });
+                    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.beginBlock("\"options\": [");
+            for (var i = 0; i < options.length; i++) {
+                this.writer.writeLine(JSON.stringify(options[i]) + ",");
+            }
+            this.writer.endBlock("]");
             this.writer.endBlock("},");
             return;
         }
@@ -160,20 +172,41 @@ var BlenderWriter = /** @class */ (function (_super) {
         this.writer.beginBlock("\"" + name + "\": {");
         this.writer.writeLine("\"type\": \"" + type + "\",");
         if (initialValue && !isArray) {
-            if (initialValue.startsWith("new "))
+            if (initialValue.startsWith("new ")) {
+                // Extract constructor args: "new Vector3(1, 2, 3)" → [1, 2, 3]
+                var argsMatch = initialValue.match(/\(([^)]*)\)/);
+                var argsStr = argsMatch ? argsMatch[1].trim() : "";
+                if (argsStr.length > 0) {
+                    var args = argsStr.split(",").map(function (a) { return a.trim(); });
+                    this.writer.writeLine("\"value\": [" + args.join(", ") + "],");
+                }
                 initialValue = undefined;
+            }
             switch (type) {
                 case "bool":
-                    initialValue = initialValue.toLowerCase();
+                    initialValue = initialValue === null || initialValue === void 0 ? void 0 : initialValue.toLowerCase();
                     break;
                 case "string":
-                    initialValue = "\"" + initialValue + "\"";
+                    initialValue = initialValue ? "\"" + initialValue + "\"" : undefined;
             }
             if (initialValue)
                 this.writer.writeLine("\"value\": " + initialValue + ",");
         }
         if (isArray) {
-            this.writer.writeLine("\"value\": [],");
+            if (initialValue && initialValue.startsWith("[") && initialValue !== "[]") {
+                // For string arrays, re-quote each element: [a, b, c] → ["a", "b", "c"]
+                if (type === "string") {
+                    var inner = initialValue.slice(1, -1);
+                    var elements = inner.split(",").map(function (e) { return "\"" + e.trim() + "\""; });
+                    this.writer.writeLine("\"value\": [" + elements.join(", ") + "],");
+                }
+                else {
+                    this.writer.writeLine("\"value\": " + initialValue + ",");
+                }
+            }
+            else {
+                this.writer.writeLine("\"value\": [],");
+            }
         }
         if (tooltip) {
             this.writer.writeLine("\"description\": \"" + tooltip.replace(/"/g, "'") + "\"");

package/dist/impl/csharp-compiler.js

@@ -133,6 +133,9 @@ var CSharpWriter = /** @class */ (function (_super) {
         var _a, _b, _c, _d, _e;
         if (!typescriptTypeName)
             return undefined;
+        // String literal union synthetic enums (e.g. __strlit_none_XY_XZ) → string
+        if (typescriptTypeName.startsWith("__strlit_"))
+            return "string";
         // Strip THREE. prefix for lookup fallback
         var stripped = typescriptTypeName.startsWith("THREE.") ? typescriptTypeName.substring(6) : typescriptTypeName;
         // Check built-in TYPE_MAP first (TS→C# mapping)
@@ -245,6 +248,29 @@ var CSharpWriter = /** @class */ (function (_super) {
             if (initialValue === "null") {
                 // keep null for reference types, skip for value types
             }
+            else if (isArray && initialValue === "[]") {
+                // Skip empty array initializers — C# 12 collection expressions (= [])
+                // are not supported by Unity's C# version
+            }
+            else if (isArray && initialValue.startsWith("[")) {
+                // Convert [1, 2, 3] → new float[] { 1f, 2f, 3f }
+                // Only emit prefilled arrays for primitive types that can be expressed as literals
+                if (csharpType === "float" || csharpType === "bool" || csharpType === "string") {
+                    var inner = initialValue.slice(1, -1);
+                    var elements = inner.split(",").map(function (e) {
+                        var v = e.trim();
+                        if (csharpType === "float")
+                            return "".concat(v, "f");
+                        if (csharpType === "bool")
+                            return v.toLowerCase();
+                        if (csharpType === "string")
+                            return "\"".concat(v, "\"");
+                        return v;
+                    });
+                    assignment = " = new ".concat(csharpType, "[] { ").concat(elements.join(", "), " }");
+                }
+                // For non-primitive types, skip the initializer entirely
+            }
             else if (csharpType === "float") {
                 assignment = " = ".concat(initialValue, "f");
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "3.0.15",
+    "version": "3.0.17",
     "description": "Compile Editor components for Needle Engine for C# and Blender",
     "main": "dist/index.js",
     "bin": "dist/cli.js",