@needle-tools/needle-component-compiler 3.0.16 → 3.0.18

package/Changelog.md

@@ -4,6 +4,17 @@ 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

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/cli.js

@@ -8,6 +8,7 @@ var base_compiler_1 = require("./base-compiler");
 var csharp_compiler_1 = require("./impl/csharp-compiler");
 var blender_compiler_1 = require("./impl/blender-compiler");
 var log_1 = require("./log");
+var register_types_1 = require("./register-types");
 var pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf-8"));
 var rawArgs = process.argv.slice(2);
 if (rawArgs.includes("--version") || rawArgs.includes("-v")) {
@@ -24,7 +25,8 @@ if (rawArgs.includes("--help") || rawArgs.includes("-h") || rawArgs.length < 3)
     console.log("  input_files  one or more .ts source files");
     console.log("");
     console.log("Options:");
-    console.log("  --types <path>  path to Types.json with extra type mappings");
+    console.log("  --types <path>           path to Types.json with extra type mappings");
+    console.log("  --register-types <bool>  auto-generate register-types (default: true)");
     console.log("");
     console.log("Flags:");
     console.log("  --silent, -s    only output errors and CMD: lines");
@@ -38,11 +40,16 @@ if (rawArgs.includes("--help") || rawArgs.includes("-h") || rawArgs.length < 3)
 // Extract flags from anywhere in the args
 var typesPath;
 var silent = false;
+var registerTypes = true;
 var positionalArgs = [];
 for (var i = 0; i < rawArgs.length; i++) {
     if (rawArgs[i] === "--types" && i + 1 < rawArgs.length) {
         typesPath = rawArgs[++i];
     }
+    else if (rawArgs[i] === "--register-types" && i + 1 < rawArgs.length) {
+        var val = rawArgs[++i].toLowerCase();
+        registerTypes = val !== "false" && val !== "0";
+    }
     else if (rawArgs[i] === "--silent" || rawArgs[i] === "-s") {
         silent = true;
     }
@@ -98,6 +105,40 @@ for (var _i = 0, inputFiles_1 = inputFiles; _i < inputFiles_1.length; _i++) {
         hasErrors = true;
     }
 }
+// Auto-detect and write register-types files using needle.config.json
+if (registerTypes && target === "blender") {
+    var codegenDir = void 0;
+    // Search upward from outputDir for needle.config.json
+    var searchDir = path.resolve(outputDir);
+    while (searchDir !== path.dirname(searchDir)) {
+        var configPath = path.join(searchDir, "needle.config.json");
+        if (fs.existsSync(configPath)) {
+            try {
+                var config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+                if (config.codegenDirectory) {
+                    codegenDir = path.resolve(searchDir, config.codegenDirectory);
+                }
+            }
+            catch (_e) { }
+            break;
+        }
+        searchDir = path.dirname(searchDir);
+    }
+    if (codegenDir) {
+        var candidates = [
+            path.join(codegenDir, "register-types.js"),
+            path.join(codegenDir, "register-types.ts"),
+            path.join(codegenDir, "register_types.ts"),
+            path.join(codegenDir, "register_types.js"),
+        ];
+        for (var _a = 0, candidates_1 = candidates; _a < candidates_1.length; _a++) {
+            var candidate = candidates_1[_a];
+            if (fs.existsSync(candidate)) {
+                (0, register_types_1.writeTypeRegistry)(writer.outputInfo, candidate);
+            }
+        }
+    }
+}
 if (hasErrors) {
     process.exit(1);
 }

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)

package/package.json

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