@needle-tools/needle-component-compiler 3.0.3-f6b855c → 3.0.4-9debd7d

package/Changelog.md

@@ -15,11 +15,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### 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
 

package/dist/BaseWriter.d.ts

@@ -14,8 +14,6 @@ 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,10 +23,6 @@ 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.d.ts

@@ -7,6 +7,10 @@ export declare class Compiler {
     private visit;
     private visitClassDeclaration;
     private visitPropertyDeclaration;
+    private hasSerializableDecorator;
+    /** Track accessor names already emitted per class to avoid duplicates when both getter and setter have @serializable() */
+    private _emittedAccessors;
+    private visitAccessorDeclaration;
     private visitMethodDeclaration;
     private resolveParameters;
     private debugLog;

package/dist/Compiler.js

@@ -6,6 +6,8 @@ var base_compiler_1 = require("./base-compiler");
 /** Typescript Walker */
 var Compiler = /** @class */ (function () {
     function Compiler() {
+        /** Track accessor names already emitted per class to avoid duplicates when both getter and setter have @serializable() */
+        this._emittedAccessors = new Set();
     }
     Compiler.prototype.compile = function (writer, code, sourceFilePath) {
         var file = "needle_compiled.ts";
@@ -29,12 +31,11 @@ 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, _b = node.members; _i < _b.length; _i++) {
-            var member = _b[_i];
+        for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+            var member = _a[_i];
             var memberName = member.name.getText();
             var value = void 0;
             if (member.initializer) {
@@ -62,13 +63,7 @@ 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;
@@ -81,6 +76,9 @@ var Compiler = /** @class */ (function () {
         else if (ts.isMethodDeclaration(node)) {
             this.visitMethodDeclaration(node, writer);
         }
+        else if (ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node)) {
+            this.visitAccessorDeclaration(node, writer);
+        }
         else {
             ts.forEachChild(node, function (node) {
                 _this.visit(filePath, node, writer);
@@ -110,6 +108,7 @@ var Compiler = /** @class */ (function () {
             this.debugLog("CLASS SKIPPED", name);
             return;
         }
+        this._emittedAccessors.clear();
         ts.forEachChild(node, function (node) {
             _this.visit(filePath, node, writer);
         });
@@ -140,6 +139,38 @@ var Compiler = /** @class */ (function () {
             return; // cannot determine type — skip the field
         writer.writeMember(visibility, name, isArray, type, initialValue, this.getComments(node));
     };
+    Compiler.prototype.hasSerializableDecorator = function (node) {
+        var _a;
+        var decorators = node.decorators;
+        return (_a = decorators === null || decorators === void 0 ? void 0 : decorators.some(function (d) { return d.expression.getText().startsWith("serializable"); })) !== null && _a !== void 0 ? _a : false;
+    };
+    Compiler.prototype.visitAccessorDeclaration = function (node, writer) {
+        var _a, _b;
+        // Only emit if the accessor has a @serializable() decorator
+        if (!this.hasSerializableDecorator(node))
+            return;
+        var name = node.name.getText();
+        // Deduplicate: if both getter and setter are decorated, only emit once
+        if (this._emittedAccessors.has(name))
+            return;
+        this._emittedAccessors.add(name);
+        var type;
+        var typeNode;
+        if (ts.isGetAccessorDeclaration(node)) {
+            typeNode = node.type;
+        }
+        else {
+            // Setter: get type from the first parameter
+            typeNode = (_b = (_a = node.parameters) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.type;
+        }
+        type = this.resolveType(typeNode, writer);
+        this.debugLog("[COMPILER] ACCESSOR (serializable)", name, type);
+        if (!type)
+            return;
+        var isArray = typeNode ? this.isArrayType(typeNode) : false;
+        var visibility = this.getVisibility(node);
+        writer.writeMember(visibility, name, isArray, type, undefined, this.getComments(node));
+    };
     Compiler.prototype.visitMethodDeclaration = function (node, writer) {
         var _a;
         var name = node.name.getText();

package/dist/base-compiler.d.ts

@@ -52,6 +52,5 @@ 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,9 +1,6 @@
 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. */
@@ -13,7 +10,6 @@ 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,20 +123,8 @@ function isEditorType(typeName) {
 var CSharpWriter = /** @class */ (function (_super) {
     __extends(CSharpWriter, _super);
     function CSharpWriter() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        /** Buffered enum outputs — flushed after all classes in end() */
-        _this._pendingEnums = [];
-        return _this;
+        return _super !== null && _super.apply(this, arguments) || 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)
@@ -335,29 +323,6 @@ 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,5 +17,4 @@ 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,8 +31,6 @@ 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,15 +1,13 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "3.0.3-f6b855c",
+    "version": "3.0.4-9debd7d",
     "description": "Compile Editor components for Needle Engine for C# and Blender",
     "main": "dist/index.js",
-    "bin": {
-        "needle-component-compiler": "dist/cli.js"
-    },
+    "bin": "dist/cli.js",
     "scripts": {
-        "tsc": "tsc",
+        "tsc": "tsc -p tsconfig.build.json",
         "dev": "npm-watch compile",
-        "compile": "tsc",
+        "compile": "tsc -p tsconfig.build.json",
         "prepublishOnly": "npm run compile",
         "test": "npm run test:csharp && npm run test:blender",
         "test:csharp": "mocha -r ts-node/register 'test/csharp/**/*.test.ts'",
@@ -28,7 +26,7 @@
     },
     "devDependencies": {
         "@types/chai": "^4.3.3",
-        "@types/mocha": "^9.1.1",
+        "@types/mocha": "^10",
         "@types/node": "^18.7.18",
         "chai": "^4.3.6",
         "mocha": "^10.0.0",