@needle-tools/needle-component-compiler 2.4.1-pre → 3.0.0-alpha

package/dist/impl/csharp-compiler.js

@@ -0,0 +1,306 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSharpWriter = void 0;
+var base_compiler_1 = require("../base-compiler");
+var BaseWriter_1 = require("../BaseWriter");
+var allowDebugLogs = false;
+/** Inline type dictionary: TypeScript type name → fully-qualified C# type name */
+var TYPE_MAP = {
+    // Primitives
+    "number": "float",
+    "boolean": "bool",
+    "string": "string",
+    "any": "object",
+    "object": "UnityEngine.Object",
+    "void": "void",
+    // Unity base types
+    "Behaviour": "UnityEngine.MonoBehaviour",
+    "MonoBehaviour": "UnityEngine.MonoBehaviour",
+    "Component": "UnityEngine.Component",
+    "ScriptableObject": "UnityEngine.ScriptableObject",
+    // GameObjects / Transforms
+    "GameObject": "UnityEngine.GameObject",
+    "Object3D": "UnityEngine.Transform",
+    "Transform": "UnityEngine.Transform",
+    "AssetReference": "UnityEngine.Transform",
+    "THREE.Object3D": "UnityEngine.Transform",
+    // Math types
+    "Vector2": "UnityEngine.Vector2",
+    "Vector3": "UnityEngine.Vector3",
+    "Vector4": "UnityEngine.Vector4",
+    "Quaternion": "UnityEngine.Quaternion",
+    "Color": "UnityEngine.Color",
+    "RGBAColor": "UnityEngine.Color",
+    "THREE.Color": "UnityEngine.Color",
+    "THREE.Vector2": "UnityEngine.Vector2",
+    "THREE.Vector3": "UnityEngine.Vector3",
+    "THREE.Vector4": "UnityEngine.Vector4",
+    "Matrix4": "UnityEngine.Matrix4x4",
+    "Box3": "UnityEngine.Bounds",
+    // Rendering
+    "Renderer": "UnityEngine.Renderer",
+    "Material": "UnityEngine.Material",
+    "Mesh": "UnityEngine.Mesh",
+    "Texture": "UnityEngine.Texture",
+    "Texture2D": "UnityEngine.Texture2D",
+    "RenderTexture": "UnityEngine.RenderTexture",
+    // Audio
+    "AudioClip": "UnityEngine.AudioClip",
+    "AudioSource": "UnityEngine.AudioSource",
+    // Animation
+    "Animator": "UnityEngine.Animator",
+    "Animation": "UnityEngine.Animation",
+    "AnimationClip": "UnityEngine.AnimationClip",
+    // Events
+    "EventList": "UnityEngine.Events.UnityEvent",
+    "UnityEvent": "UnityEngine.Events.UnityEvent",
+    // Physics / Colliders
+    "ICollider": "UnityEngine.Collider",
+    // UI
+    "Text": "UnityEngine.UI.Text",
+    "Image": "UnityEngine.UI.Image",
+    "RawImage": "UnityEngine.UI.RawImage",
+    // Camera / Light
+    "Camera": "UnityEngine.Camera",
+    "Light": "UnityEngine.Light",
+    // Timeline / Playables
+    "SignalAsset": "UnityEngine.Timeline.SignalAsset",
+    "PlayableDirector": "UnityEngine.Playables.PlayableDirector",
+    // Miscellaneous
+    "Rigidbody": "UnityEngine.Rigidbody",
+    "Map": "System.Collections.Generic.Dictionary",
+};
+/** Lifecycle method name mappings: camelCase TS → PascalCase C# */
+var LIFECYCLE_METHODS = {
+    "awake": "Awake",
+    "start": "Start",
+    "onEnable": "OnEnable",
+    "onDisable": "OnDisable",
+    "update": "Update",
+    "lateUpdate": "LateUpdate",
+    "fixedUpdate": "FixedUpdate",
+    "onDestroy": "OnDestroy",
+    "onCollisionEnter": "OnCollisionEnter",
+    "onCollisionExit": "OnCollisionExit",
+    "onCollisionStay": "OnCollisionStay",
+    "onTriggerEnter": "OnTriggerEnter",
+    "onTriggerExit": "OnTriggerExit",
+    "onTriggerStay": "OnTriggerStay",
+    "onApplicationQuit": "OnApplicationQuit",
+    "onBecameVisible": "OnBecameVisible",
+    "onBecameInvisible": "OnBecameInvisible",
+    "onGUI": "OnGUI",
+    "onValidate": "OnValidate",
+    "reset": "Reset",
+};
+/** UnityEditor types that need #if UNITY_EDITOR wrapping */
+var EDITOR_TYPES = new Set([
+    "UnityEditor", "AnimatorController", "EditorApplication",
+    "EditorUtility", "SerializedObject", "SerializedProperty",
+]);
+function isEditorType(typeName) {
+    return EDITOR_TYPES.has(typeName) || typeName.startsWith("UnityEditor.");
+}
+var CSharpWriter = /** @class */ (function (_super) {
+    __extends(CSharpWriter, _super);
+    function CSharpWriter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CSharpWriter.prototype.resolveCSharpTypeName = function (typescriptTypeName) {
+        var _a, _b;
+        if (!typescriptTypeName)
+            return undefined;
+        // Strip THREE. prefix for lookup fallback
+        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;
+    };
+    CSharpWriter.prototype.startNewType = function (filePath, typeName, baseTypes, comments) {
+        var _a;
+        if (comments === null || comments === void 0 ? void 0 : comments.includes("@dont-generate-component"))
+            return false;
+        // @type override: first comment matching "@type <T>" overrides base class
+        var resolvedBase = "UnityEngine.MonoBehaviour";
+        var typeOverride = comments === null || comments === void 0 ? void 0 : comments.find(function (c) { return c.startsWith("@type "); });
+        if (typeOverride) {
+            resolvedBase = typeOverride.substring("@type ".length).trim();
+        }
+        else if (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) {
+            var first = baseTypes[0];
+            resolvedBase = (_a = this.resolveCSharpTypeName(first)) !== null && _a !== void 0 ? _a : "UnityEngine.MonoBehaviour";
+        }
+        // Abstract modifier
+        var isAbstract = comments === null || comments === void 0 ? void 0 : comments.includes("@abstract");
+        var modifiers = isAbstract ? "abstract partial" : "partial";
+        this.writer.writeLine("// NEEDLE_CODEGEN_START");
+        this.writer.writeLine("// auto generated code - do not edit directly");
+        this.writer.writeLine("");
+        this.writer.writeLine("#pragma warning disable");
+        this.writer.writeLine("");
+        this.writer.beginBlock("namespace Needle.Typescript.GeneratedComponents\n{");
+        this.writer.beginBlock("public ".concat(modifiers, " class ").concat(typeName, " : ").concat(resolvedBase, "\n{"));
+    };
+    CSharpWriter.prototype.endNewType = function (filePath, typeName) {
+        this.writer.endBlock("}");
+        this.writer.endBlock("}");
+        this.writer.writeLine("");
+        this.writer.writeLine("// NEEDLE_CODEGEN_END");
+        this.writeCSharpScheme(filePath, typeName);
+    };
+    CSharpWriter.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
+        var _a;
+        if (allowDebugLogs)
+            console.log("[CSharp] writeMember", name, type, comments);
+        // @nonSerialized → skip entirely
+        if (comments === null || comments === void 0 ? void 0 : comments.some(function (c) { return c.startsWith("@nonSerialized"); }))
+            return;
+        // @type override
+        var typeOverride = comments === null || comments === void 0 ? void 0 : comments.find(function (c) { return c.startsWith("@type "); });
+        var csharpType = typeOverride
+            ? typeOverride.substring("@type ".length).trim()
+            : ((_a = this.resolveCSharpTypeName(type)) !== null && _a !== void 0 ? _a : type);
+        // Determine visibility string
+        var vis = "public";
+        if (visibility === base_compiler_1.Visibility.Private || visibility === base_compiler_1.Visibility.Protected) {
+            vis = visibility === base_compiler_1.Visibility.Protected ? "protected" : "private";
+        }
+        // @serializeField → add attribute + force private becomes serialized
+        var serializeField = comments === null || comments === void 0 ? void 0 : comments.some(function (c) { return c.startsWith("@serializeField") || c.startsWith("@serializable"); });
+        // @tooltip
+        var tooltipComment = comments === null || comments === void 0 ? void 0 : comments.find(function (c) { return c.startsWith("@tooltip "); });
+        var tooltip = tooltipComment ? tooltipComment.substring("@tooltip ".length).trim().replace(/^["']|["']$/g, "") : null;
+        // @contextmenu
+        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;
+        // @ifdef
+        var ifdefComment = comments === null || comments === void 0 ? void 0 : comments.find(function (c) { return c.startsWith("@ifdef "); });
+        var ifdef = ifdefComment ? ifdefComment.substring("@ifdef ".length).trim() : null;
+        // Skip private/protected fields unless @serializeField
+        if (visibility !== base_compiler_1.Visibility.Public && !serializeField)
+            return;
+        // Resolve assignment
+        var assignment = "";
+        if (initialValue !== undefined && initialValue !== null) {
+            if (initialValue === "null") {
+                // keep null for reference types, skip for value types
+            }
+            else if (csharpType === "float") {
+                assignment = " = ".concat(initialValue, "f");
+            }
+            else if (csharpType === "bool") {
+                assignment = " = ".concat(initialValue.toLowerCase());
+            }
+            else if (csharpType === "string") {
+                assignment = " = \"".concat(initialValue, "\"");
+            }
+            else if (initialValue.startsWith("new ")) {
+                // constructor expression already prefixed with new
+                var resolved = this.resolveNewExpression(initialValue);
+                assignment = " = ".concat(resolved);
+            }
+            else {
+                assignment = " = ".concat(initialValue);
+            }
+        }
+        // Array suffix
+        if (isArray)
+            csharpType += "[]";
+        // Editor type wrapping
+        var needsEditorWrap = isEditorType(csharpType.split("[")[0].split("<")[0]);
+        if (ifdef)
+            this.writer.writeLine("#ifdef ".concat(ifdef));
+        if (needsEditorWrap)
+            this.writer.writeLine("#if UNITY_EDITOR");
+        // Emit attributes
+        if (tooltip)
+            this.writer.writeLine("[UnityEngine.Tooltip(\"".concat(tooltip, "\")]"));
+        if (contextMenu)
+            this.writer.writeLine("[UnityEngine.ContextMenu(\"".concat(contextMenu, "\")]"));
+        if (serializeField && visibility !== base_compiler_1.Visibility.Public) {
+            this.writer.writeLine("[UnityEngine.SerializeField]");
+        }
+        // Emit field
+        var varName = "@".concat(name);
+        this.writer.writeLine("".concat(vis, " ").concat(csharpType, " ").concat(varName).concat(assignment, ";"));
+        if (needsEditorWrap)
+            this.writer.writeLine("#endif");
+        if (ifdef)
+            this.writer.writeLine("#endif");
+    };
+    CSharpWriter.prototype.writeMethod = function (visibility, name, returnType, args, comments) {
+        var _this = this;
+        var _a, _b;
+        if (allowDebugLogs)
+            console.log("[CSharp] writeMethod", name, returnType);
+        // @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;
+        // Only emit public methods and lifecycle methods (which are always public)
+        var lifecycleName = LIFECYCLE_METHODS[name];
+        if (visibility !== base_compiler_1.Visibility.Public && !lifecycleName)
+            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"
+        var paramList = (_a = args === null || args === void 0 ? void 0 : args.map(function (arg) {
+            var _a, _b;
+            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";
+            }
+            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)
+            : "void";
+        if (contextMenu)
+            this.writer.writeLine("[UnityEngine.ContextMenu(\"".concat(contextMenu, "\")]"));
+        this.writer.writeLine("public void ".concat(methodName, "(").concat(paramList, ") {}"));
+    };
+    CSharpWriter.prototype.writeNewTypeExpression = function (typeName, args) {
+        // no-op for C# output
+    };
+    // ── Helpers ────────────────────────────────────────────────────────────
+    /** Converts camelCase to PascalCase for method names */
+    CSharpWriter.prototype.toPascalCase = function (name) {
+        return name.charAt(0).toUpperCase() + name.slice(1);
+    };
+    /** Resolve a "new Type(args)" expression: map TS types to C# qualified types */
+    CSharpWriter.prototype.resolveNewExpression = function (expr) {
+        var _a;
+        // expr is already resolved: "new UnityEngine.Vector2(1, 0.5)" → "new UnityEngine.Vector2(1f, 0.5f)"
+        var match = expr.match(/^new\s+([\w.]+)\s*\((.*)\)$/s);
+        if (!match)
+            return expr;
+        var typeName = match[1], argsStr = match[2];
+        var csharpType = (_a = this.resolveCSharpTypeName(typeName)) !== null && _a !== void 0 ? _a : typeName;
+        // Convert numeric literals to float
+        var csharpArgs = argsStr.replace(/(\d+\.?\d*)/g, function (n) {
+            return n.includes(".") ? "".concat(n, "f") : "".concat(n, "f");
+        });
+        return "new ".concat(csharpType, "(").concat(csharpArgs, ")");
+    };
+    /** Override writeScheme to use .cs extension instead of .component.json */
+    CSharpWriter.prototype.writeCSharpScheme = function (processingFilePath, component) {
+        var res = this.sink.flush(component + ".cs", this.writer.flush());
+    };
+    return CSharpWriter;
+}(BaseWriter_1.BaseWriter));
+exports.CSharpWriter = CSharpWriter;

package/dist/impl/react-three-fiber-compiler.d.ts

@@ -0,0 +1,20 @@
+import { IWriter, Visibility } from "../base-compiler";
+import { TypeSourceInformation } from "../register-types";
+export declare class ReactThreeFiberCompiler implements IWriter {
+    get outputInfo(): TypeSourceInformation;
+    private readonly _typeSourceInformation;
+    constructor();
+    resolveCSharpTypeName(typescriptTypeName: string): string | void;
+    begin(filePath: string): void;
+    end(filePath: string): void;
+    startNewType(filePath: string, typeName: string, baseType: 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;
+    writeMethod(visibility: Visibility, name: string, returnType: string, args: {
+        name: string;
+        type: string;
+        defaultValue?: string;
+    }[], comments: string[]): void;
+    writeNewTypeExpression(typeName: string, args?: string[]): void;
+    registerEnum(name: string, members: import("../base-compiler").EnumMember[]): void;
+}

package/{src → dist/impl}/react-three-fiber-compiler.js

@@ -12,7 +12,7 @@ var ReactThreeFiberCompiler = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    ReactThreeFiberCompiler.prototype.resolveTypeName = function (typescriptTypeName) {
+    ReactThreeFiberCompiler.prototype.resolveCSharpTypeName = function (typescriptTypeName) {
         return typescriptTypeName;
     };
     ReactThreeFiberCompiler.prototype.begin = function (filePath) {
@@ -29,6 +29,8 @@ var ReactThreeFiberCompiler = /** @class */ (function () {
     };
     ReactThreeFiberCompiler.prototype.writeNewTypeExpression = function (typeName, args) {
     };
+    ReactThreeFiberCompiler.prototype.registerEnum = function (name, members) {
+    };
     return ReactThreeFiberCompiler;
 }());
 exports.ReactThreeFiberCompiler = ReactThreeFiberCompiler;

package/dist/register-types.d.ts

@@ -0,0 +1,8 @@
+/**@key is the typescript source file */
+export declare type TypeSourceInformation = {
+    [key: string]: {
+        componentName: string;
+        filePath: string;
+    }[];
+};
+export declare function writeTypeRegistry(types: TypeSourceInformation, registerTypesPath: string): void;

package/dist/watcher.d.ts

@@ -0,0 +1,6 @@
+import { IWriter } from "./base-compiler";
+export declare class DirectoryWatcher {
+    private readonly compiler;
+    private _typesChanged;
+    startWatching(dir: string, writer: IWriter, registerTypesPath: string): void;
+}

package/{src → dist}/watcher.js

@@ -3,14 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DirectoryWatcher = void 0;
 var fs = require("fs");
 var base_compiler_1 = require("./base-compiler");
-var blender_compiler_1 = require("./blender-compiler");
+var Compiler_1 = require("./Compiler");
+var blender_compiler_1 = require("./impl/blender-compiler");
 var chokidar = require("chokidar");
 var commands_1 = require("./commands");
 var register_types_1 = require("./register-types");
 // https://github.com/paulmillr/chokidar
 var DirectoryWatcher = /** @class */ (function () {
     function DirectoryWatcher() {
-        this.compiler = new base_compiler_1.Compiler();
+        this.compiler = new Compiler_1.Compiler();
         this._typesChanged = false;
     }
     DirectoryWatcher.prototype.startWatching = function (dir, writer, registerTypesPath) {

package/package.json

@@ -1,17 +1,23 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "2.4.1-pre",
-    "description": "Compile mock unity components from typescript",
-    "main": "index.js",
+    "version": "3.0.0-alpha",
+    "description": "Compile Editor components for Needle Engine for C# and Blender",
+    "main": "dist/index.js",
     "scripts": {
         "tsc": "tsc",
-        "dev": "npm-watch compile || exit 1",
+        "dev": "npm-watch compile",
         "compile": "tsc",
-        "test" : "npm run test:csharp & npm run test:blender",
-        "test:csharp": "mocha -r ts-node/register test/csharp/**.test.ts",
-        "test:blender": "mocha -r ts-node/register test/blender/**.test.ts",
+        "test": "npm run test:csharp && npm run test:blender",
+        "test:csharp": "mocha -r ts-node/register 'test/csharp/**/*.test.ts'",
+        "test:blender": "mocha -r ts-node/register 'test/blender/**/*.test.ts'",
         "test:single": "mocha"
     },
+    "files": [
+        "Readme.md",
+        "Changelog.md",
+        "package.json",
+        "dist/**/*"
+    ],
     "dependencies": {
         "chokidar": "^3.5.3",
         "typescript": "^4.5.5"

package/src/csharp-compiler.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CSharpWriter = void 0;
-var fs_1 = require("fs");
-var path = require("path");
-var allowDebugLogs = false;
-var CSharpWriter = /** @class */ (function () {
-    function CSharpWriter(_outputDir) {
-        this._outputDir = _outputDir;
-    }
-    Object.defineProperty(CSharpWriter.prototype, "outputInfo", {
-        get: function () {
-            return this._outputInfo;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    CSharpWriter.prototype.resolveTypeName = function (typescriptTypeName) {
-        if (this._typesFileContent === undefined) {
-            this._typesFileContent = null;
-            var filePath = path.dirname(__dirname) + "/src/types.json";
-            if ((0, fs_1.existsSync)(filePath)) {
-                if (allowDebugLogs)
-                    console.log("Reading types file");
-                var content = (0, fs_1.readFileSync)(filePath, "utf8");
-                this._typesFileContent = JSON.parse(content);
-            }
-        }
-        if (this._typesFileContent) {
-            var fullType = this._typesFileContent[typescriptTypeName];
-            if (fullType && allowDebugLogs)
-                console.log(fullType);
-            return fullType;
-        }
-        return null;
-    };
-    CSharpWriter.prototype.begin = function (filePath) {
-    };
-    CSharpWriter.prototype.end = function (filePath) {
-    };
-    CSharpWriter.prototype.startNewType = function (filePath, typeName, baseType, comments) {
-        throw new Error("Method not implemented.");
-    };
-    CSharpWriter.prototype.endNewType = function (filePath, typeName) {
-        throw new Error("Method not implemented.");
-    };
-    CSharpWriter.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
-        throw new Error("Method not implemented.");
-    };
-    CSharpWriter.prototype.writeMethod = function (visibility, name, returnType, args, comments) {
-        throw new Error("Method not implemented.");
-    };
-    CSharpWriter.prototype.writeNewTypeExpression = function (typeName, args) {
-        throw new Error("Method not implemented.");
-    };
-    return CSharpWriter;
-}());
-exports.CSharpWriter = CSharpWriter;

package/src/test.js

@@ -1,194 +0,0 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-exports.__esModule = true;
-exports.MyTestComponent = void 0;
-var MyTestComponent = /** @class */ (function (_super) {
-    __extends(MyTestComponent, _super);
-    function MyTestComponent() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.myVector2 = new Vector2(1, .5);
-        return _this;
-    }
-    MyTestComponent.prototype.myMethod = function () {
-    };
-    return MyTestComponent;
-}(Behaviour));
-exports.MyTestComponent = MyTestComponent;
-// export class SkipFieldAndMethod extends Behaviour {
-//     //@nonSerialized
-//     myMethod() {
-//     }
-//     // @nonSerialized
-//     myField : string;
-// }
-// export class ComponentWithUnknownType extends Behaviour {
-//     views: SomeUnknownType;
-// }
-// export class ComponentWithAnimationClip extends Behaviour implements IPointerClickHandler {
-//     @serializeable(AnimationClip)
-//     animation?: THREE.AnimationClip;
-// }
-// export abstract class MyAbstractComponent extends Behaviour {
-//     abstract myMethod();
-// }
-// export class CameraView extends Behaviour {
-//     static views: CameraView[] = [];
-// }
-// export class EventComponent extends Behaviour {    
-//     @serializeable(EventList)
-//     roomChanged: EventList = new EventList();
-// }
-// export class SocLoader extends Behaviour {    
-//     @serializeable(AssetReference) 
-//     scenes: Array<AssetReference> = [];
-// }
-// // class Test123 {}
-// export class Bla extends Behaviour
-// {
-//     myNumber:number = 42;
-//     myBool:boolean = true;
-//     myString:string = "test";
-//     numberArr: number[] = [1,2,3];
-//     myColor : THREE.Color = new THREE.Color(255, 0, 0);
-//     renderers = new Array<Renderer>();
-//     renderers2 : Renderer[] = [];
-//     objArr : object[];
-//     colArr: THREE.Color[] = [new THREE.Color(1,2,3)];
-//     map : Map<string> = new Map<string>();
-//     map2 : Map<object> = new Map<object>();
-//     private myThing : Test123;
-// } 
-// //@type UnityEngine.MonoBehaviour
-// export class ButtonObject extends Interactable implements IPointerClickHandler, ISerializable {
-//     //@type UnityEngine.Transform[]
-//     myType?: SceneFXWindow;
-// }
-// import { Behaviour } from "needle.tiny.engine/engine-components/Component";
-// import { RoomEntity } from "./Room";
-// import { Behaviour } from "needle.tiny.engine/engine-components/Component";
-// export class MyNewScript extends DriveClient
-// {
-//     //@type test
-//     texture : RenderTexture;  
-// }    
-// namespace Hello.World
-// {
-//     namespace Deep {
-//         export class MyClass extends Behaviour {
-//             //@ifdef TEST
-//             public myFloat :number;
-//         }
-//     }
-// }
-// class OtherClass extends Behaviour {
-// }
-//@type (RoomEntity) 
-// export class NavigationManager extends RoomEntity {
-//     fl:number = 1;
-//     nav_forward() {
-//     }
-//     nav_backward() { 
-//     }
-// }
-// export abstract class NavComponent extends Behaviour {
-//     abstract next();  
-//     abstract prev();
-//     abstract isAtEnd():boolean; 
-// } 
-// export class PointOfInterest extends Behaviour {
-//     myVal:number = 12;
-//     // @type(HELLO)
-//     myFunction(){
-//     }
-//     // @type(UnityEngine.Camera)
-//     view?:Camera;
-//     test:string = "123";
-//     // test
-// }
-// export class MaterialColorHandler extends Behaviour {
-//     @serializeable(Renderer)
-//     renderer?: Renderer[];
-// }
-// export class MyArray extends Behaviour {
-//     arr? : Array<number> = [1,2,3];
-// }
-// export class PrivateSerializedField extends Behaviour {
-//     //@serializeField
-//     private color? : THREE.Color; 
-// }
-// export class MyPropertyClass extends Behaviour {
-//     set color(col: THREE.Color) {
-//     }
-// }
-// export class MyClassWithAFloat extends Behaviour {
-//     myfloat:number = .5;
-//     private myString : string;
-// }
-// export class GltfExport extends Behaviour {
-//     binary: boolean = true;
-//     "$serializedTypes" = {
-//         url:null
-//     }
-//     // @contextmenu enable this
-//     test(){
-//     }
-// }
-// export class SetColor  extends Behaviour {
-//     "@serializedTypes" = { 
-//         col: Number,
-//     }
-// }
-// class Behaviour {
-// }
-// export class PlatformerMusic extends Behaviour implements IPlaymodeChangeListener {
-//     source?: AudioSource;
-//     editMode?: string;
-//     playMode?: string;
-//     onPlaymodeChange(playmode: PlayMode): void {
-//         console.log(this);
-//         if(!this.source) return;
-//         const clip = playmode.isInPlayMode ? this.playMode : this.editMode;
-//         console.log("PLAY", clip);
-//         this.source.play(clip);
-//     }
-// }
-// // TODO: export UnityEvent like this
-// // disable codegen
-// class UnityEvent {
-//     methods: Function[] = [];
-//     invoke() {
-//         for (const m of this.methods) {
-//             m();
-//         }
-//     }
-// }
-// export class MyClass extends Behaviour {
-//     myFloat: number = 15;
-//     myBool: boolean;
-//     // just some default values
-//     myArray: number[] = [1, 2, 3];
-//     // comment for myString
-//     myString: string = "this is a string1";
-//     myObject: THREE.Object3D;
-//     myBool2: boolean;
-//     myFunction() { }
-//     myFunctionWithStringParameter(string: string) { }
-//     myFunctionWithSomeObjectAndArray(obj: THREE.Object3D, arr: number[]) { }
-//     myFunctionWithoutParamTypes(test) { }
-//     someOtherStuff: THREE.Object3D[] | null = null;
-//     myEvent: UnityEvent;
-// }