@needle-tools/needle-component-compiler 3.0.20-next.2ca1149 → 3.0.21-next.1fbd5ac

package/Changelog.md

@@ -4,6 +4,11 @@ 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.21] - 2026-09-09
+### Fixed
+- C# and Blender: skip function-valued fields, including arrow callbacks, even when marked serializable.
+- C# and Blender: resolve intersection types (e.g. `Material & Custom`) to the first known type from left to right; skip fields when none is known.
+
 ## [3.0.20] - 2026-05-05
 ### Changed
 - Fields without `@serializable()` decorator (or `//@serializable` / `//@serializeField` comment directive) are no longer emitted in C# or Blender output. This prevents unresolvable types (e.g. `article: Article | undefined = undefined`) from producing compile errors in generated stubs.
@@ -256,4 +261,4 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - add mesh and texture types
 
 ## [1.0.0] - 2022-04-22
-- initial release
+- initial release

package/dist/Compiler.d.ts

@@ -22,6 +22,7 @@ export declare class Compiler {
     private tryResolveTypeFromExpression;
     private resolveType;
     private resolveTypeFromString;
+    private resolveKnownIntersectionType;
     private isArrayType;
     private resolveExpression;
 }

package/dist/Compiler.js

@@ -127,6 +127,15 @@ var Compiler = /** @class */ (function () {
     };
     Compiler.prototype.visitPropertyDeclaration = function (node, writer) {
         var _a;
+        // Function-valued properties are runtime callbacks, not serialized fields.
+        var initializer = node.initializer;
+        while (initializer && ts.isParenthesizedExpression(initializer)) {
+            initializer = initializer.expression;
+        }
+        if ((initializer && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer))) ||
+            (node.type && ts.isFunctionTypeNode(node.type))) {
+            return;
+        }
         // Skip static and abstract properties — they don't map to serialized fields
         if (node.modifiers) {
             for (var _i = 0, _b = node.modifiers; _i < _b.length; _i++) {
@@ -343,6 +352,12 @@ var Compiler = /** @class */ (function () {
     Compiler.prototype.resolveType = function (typeNode, writer) {
         if (!typeNode)
             return undefined;
+        if (ts.isParenthesizedTypeNode(typeNode)) {
+            return this.resolveType(typeNode.type, writer);
+        }
+        if (ts.isIntersectionTypeNode(typeNode)) {
+            return this.resolveKnownIntersectionType(typeNode, writer);
+        }
         // check if its an array
         if (this.isArrayType(typeNode)) {
             // Unwrap union types (e.g. Texture[] | null) to find the array member
@@ -435,9 +450,31 @@ var Compiler = /** @class */ (function () {
         var resolved = writer.resolveNeedleTypeName(type);
         return resolved || type;
     };
+    Compiler.prototype.resolveKnownIntersectionType = function (node, writer) {
+        if (ts.isParenthesizedTypeNode(node)) {
+            return this.resolveKnownIntersectionType(node.type, writer);
+        }
+        if (ts.isIntersectionTypeNode(node)) {
+            for (var _i = 0, _a = node.types; _i < _a.length; _i++) {
+                var member = _a[_i];
+                var resolved = this.resolveKnownIntersectionType(member, writer);
+                if (resolved)
+                    return resolved;
+            }
+            return undefined;
+        }
+        // Do not use resolveTypeFromString: its fallback preserves unknown TS types.
+        var name = ts.isTypeReferenceNode(node) ? node.typeName.getText() : node.getText();
+        return writer.resolveKnownTypeName
+            ? writer.resolveKnownTypeName(name)
+            : writer.resolveNeedleTypeName(name) || undefined;
+    };
     Compiler.prototype.isArrayType = function (typeNode) {
         if (!typeNode)
             return false;
+        if (ts.isParenthesizedTypeNode(typeNode)) {
+            return this.isArrayType(typeNode.type);
+        }
         // Unwrap union types (e.g. Texture[] | null → Texture[])
         if (ts.isUnionTypeNode(typeNode)) {
             for (var _i = 0, _a = typeNode.types; _i < _a.length; _i++) {

package/dist/base-compiler.d.ts

@@ -45,6 +45,7 @@ export interface IWriter {
     get outputInfo(): TypeSourceInformation;
     begin(filePath: string | null): void;
     resolveNeedleTypeName(typescriptTypeName: string, baseTypes?: string[]): string | void;
+    resolveKnownTypeName?(typescriptTypeName: string): string | undefined;
     end(filePath: string | null): void;
     startNewType(filePath: string | null, typeName: string, baseType: string[], comments?: string[]): void | boolean;
     endNewType(filePath: string | null, typeName: string): void;

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

@@ -2,6 +2,7 @@ import { Visibility } from "../base-compiler";
 import { BaseWriter } from "../BaseWriter";
 export declare class BlenderWriter extends BaseWriter {
     resolveNeedleTypeName(typeName: string, comments?: string[]): string | void;
+    resolveKnownTypeName(typeName: string): string | undefined;
     startNewType(filePath: string | null, typeName: string, baseTypes: string[], comments?: string[]): void | boolean;
     endNewType(filePath: string | null, typeName: string): void;
     writeMember(visibility: Visibility, name: string, isArray: boolean, type: string, initialValue?: string, comments?: string[]): void;

package/dist/impl/blender-compiler.js

@@ -27,6 +27,13 @@ var BlenderWriter = /** @class */ (function (_super) {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     BlenderWriter.prototype.resolveNeedleTypeName = function (typeName, comments) {
+        var known = this.resolveKnownTypeName(typeName);
+        if (known)
+            return known;
+        typeName = typeName.toLocaleLowerCase();
+        return typeName.startsWith("three.") ? typeName.substring("three.".length) : typeName;
+    };
+    BlenderWriter.prototype.resolveKnownTypeName = function (typeName) {
         typeName = typeName.toLocaleLowerCase();
         if (typeName.startsWith("three."))
             typeName = typeName.substring("three.".length);
@@ -104,7 +111,7 @@ var BlenderWriter = /** @class */ (function (_super) {
             case "timelineasset":
                 return "timeline";
         }
-        return typeName;
+        return undefined;
     };
     BlenderWriter.prototype.startNewType = function (filePath, typeName, baseTypes, comments) {
         if (comments === null || comments === void 0 ? void 0 : comments.includes("@dont-generate-component"))

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

@@ -4,6 +4,7 @@ export declare class CSharpWriter extends BaseWriter {
     private externalTypes;
     constructor(sink?: ISink, externalTypes?: Record<string, string>);
     resolveNeedleTypeName(typescriptTypeName: string): string | void;
+    resolveKnownTypeName(typeName: string): string | undefined;
     /** 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;

package/dist/impl/csharp-compiler.js

@@ -148,6 +148,9 @@ var CSharpWriter = /** @class */ (function (_super) {
             return typescriptTypeName;
         return (_e = (_c = (_b = this.externalTypes) === null || _b === void 0 ? void 0 : _b[typescriptTypeName]) !== null && _c !== void 0 ? _c : (_d = this.externalTypes) === null || _d === void 0 ? void 0 : _d[stripped]) !== null && _e !== void 0 ? _e : typescriptTypeName;
     };
+    CSharpWriter.prototype.resolveKnownTypeName = function (typeName) {
+        return this.resolveKnownCSharpTypeName(typeName);
+    };
     /** 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) {

package/package.json

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