@needle-tools/needle-component-compiler 1.9.0 → 1.9.1

package/Changelog.md

@@ -4,6 +4,9 @@ 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).
 
+## [1.9.1] - 2022-11-05
+- Fix ``new Vector2(1, .5)`` generating invalid C# where number arguments were emitted as double instead of float
+
 ## [1.9.0] - 2022-10-18
 - Change: emit ``onEnable`` as ``OnEnable`` and ``onDisable`` as ``OnDisable`` so Unity creates component checkboxes
 - Change: ignore private and protected methods

package/PUBLISH.bat

@@ -3,6 +3,6 @@ echo Press a key to publish! (close the window if you changed your mind)
 pause
 echo Publishing in 2 sec
 timeout 2
-npm set registry https://registry.npmjs.org && npm publish
+npm run compile & npm set registry https://registry.npmjs.org && npm publish & pause
 echo Finished...
 timeout 10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "1.9.0",
+    "version": "1.9.1",
     "description": "Compile mock unity components from typescript",
     "main": "index.js",
     "scripts": {

package/src/component-compiler.js

@@ -462,14 +462,30 @@ function run(program, outputDir, sourceFile) {
                                 type = tryGetTypeFromText(text);
                                 break;
                             case ts.SyntaxKind.SyntaxList:
-                                args = text;
+                                for (var _b = 0, _c = ch.getChildren(); _b < _c.length; _b++) {
+                                    var arg = _c[_b];
+                                    if (args === undefined)
+                                        args = "";
+                                    var res = getTypeForAssignment(arg);
+                                    // handle floats being assigned with "f" suffix
+                                    if (Number.parseFloat(res) >= 0) {
+                                        args += res + "f";
+                                    }
+                                    else {
+                                        args += res;
+                                        if (res === ",")
+                                            args += " ";
+                                    }
+                                }
                                 break;
                         }
                     }
                     if (!args)
                         args = "";
-                    if (type)
+                    if (type) {
+                        console.log(type, args);
                         return "new " + type + "(" + args + ")";
+                    }
                     // const expType = node.getChildren().find(c => c.kind === ts.SyntaxKind.Identifier);
                     break;
             }

package/src/component-compiler.ts

@@ -273,7 +273,7 @@ export function run(program: ts.Program, outputDir: string | null, sourceFile: t
                 // const isCoroutine = func.asteriskToken;
                 if (!skip && meth.name) {
                     const pub = isPublic(meth);
-                    if(!pub) return;
+                    if (!pub) return;
 
                     let paramsStr = "";
                     for (let param of meth.parameters) {
@@ -485,13 +485,26 @@ export function run(program: ts.Program, outputDir: string | null, sourceFile: t
                                 type = tryGetTypeFromText(text);
                                 break;
                             case ts.SyntaxKind.SyntaxList:
-                                args = text;
+                                for (const arg of ch.getChildren()) {
+                                    if (args === undefined) args = "";
+                                    const res = getTypeForAssignment(arg);
+                                    // handle floats being assigned with "f" suffix
+                                    if (Number.parseFloat(res) >= 0) {
+                                        args += res + "f";
+                                    }
+                                    else {
+                                        args += res;
+                                        if (res === ",") args += " ";
+                                    }
+                                }
                                 break;
                         }
                     }
                     if (!args) args = "";
-                    if (type)
+                    if (type) {
+                        console.log(type, args)
                         return "new " + type + "(" + args + ")";
+                    }
                     // const expType = node.getChildren().find(c => c.kind === ts.SyntaxKind.Identifier);
                     break;
             }

package/src/test.js

@@ -0,0 +1,194 @@
+"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;
+// }

package/src/test.ts

@@ -1,6 +1,7 @@
 import { ThisExpression } from "typescript";
 
 export class MyTestComponent extends Behaviour {
+    public myVector2: Vector2 = new Vector2(1, .5);
     private myMethod(){
         
     }

package/test/component.basic.test.js

@@ -0,0 +1,26 @@
+"use strict";
+exports.__esModule = true;
+var helpers_1 = require("./helpers");
+describe('Basic typescript', function () {
+    it('should generate component', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("basic", 
+        // INPUT
+        "export class BasicComponet extends Behaviour {\n}\n", 
+        // EXPECTED
+        "public partial class BasicComponet : UnityEngine.MonoBehaviour\n\t{\n\t}");
+    });
+    it('should not generate component', function () {
+        (0, helpers_1.compareCodegen)("basic-no-export", 
+        // INPUT
+        "\n      //@dont-generate-component\n      export class BasicComponet extends Behaviour {\n}\n", 
+        // EXPECTED
+        "");
+    });
+    it('should ignore abstract type', function () {
+        (0, helpers_1.compareCodegen)("basic-no-export", 
+        // INPUT
+        "\n      //@dont-generate-component\n      export abstract class BasicComponet extends Behaviour {\n}\n", 
+        // EXPECTED
+        "");
+    });
+});

package/test/component.methods.test.js

@@ -0,0 +1,82 @@
+"use strict";
+exports.__esModule = true;
+var helpers_1 = require("./helpers");
+describe('Typescript with public methods', function () {
+    it('should generate component with public method', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("public.methods", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n    public myMethod(): void {}\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n    public void myMethod(){}\n\t}");
+    });
+    it('should generate component method and number args', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("public method with args", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n    public myMethod(myNumber: number): void {}\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n    public void myMethod(float @myNumber){}\n\t}");
+    });
+    it('should generate component method and multiple number args', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("public method with multiple args", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n    public myMethod(myNumber: number, myOtherNumber : number): void {}\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n    public void myMethod(float @myNumber, float @myOtherNumber){}\n\t}");
+    });
+    // https://github.com/needle-tools/needle-tiny-component-compiler/issues/11
+    it('should generate component method but ignore inline type declaration', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("method ignore inline type declaration", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n    public myMethod(myNumber: { x : number, y:number, z : number}): void {}\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n    public void myMethod(object @myNumber){}\n\t}");
+    });
+});
+describe('Typescript with private or protected methods', function () {
+    // https://github.com/needle-tools/needle-tiny-component-compiler/issues/13
+    it('should ignore private method', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("private.methods", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n    private myMethod(): void {}\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n\t}");
+    });
+    // https://github.com/needle-tools/needle-tiny-component-compiler/issues/13
+    it('should ignore protected method', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("protected.methods", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n    protected myMethod(): void {}\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n\t}");
+    });
+});
+describe('Typescript with methods', function () {
+    it('should not generate static method', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("static method", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n    public static myMethod(): void {}\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n\t}");
+    });
+    it('should not generate abstract method', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("abstract method", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n    public abstract myMethod(): void {}\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n\t}");
+    });
+    it('should convert onEnable to OnEnable', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("abstract method", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n      onEnable() {}\n    }\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n    public void OnEnable(){}\n\t}");
+    });
+    it('should convert onDisable to OnDisable', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("abstract method", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n      onDisable() {}\n    }\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n    public void OnDisable(){}\n\t}");
+    });
+});

package/test/component.nonserialized.test.js

@@ -0,0 +1,20 @@
+"use strict";
+exports.__esModule = true;
+var helpers_1 = require("./helpers");
+describe('Typescript with nonSerialized', function () {
+    it('should ignore field', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("nonserialized ignore field", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n        //@nonSerialized\n    public myField: number;\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n\t}");
+    });
+    // https://github.com/needle-tools/needle-tiny-component-compiler/issues/14
+    it('should not affect next method', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("nonserialized on property does not affect method", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n        //@nonSerialized\n    public get myField(): number { return 0; }\n\n    public myMethod() {\n\n    }\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n    public void myMethod() {}\n\t}");
+    });
+});

package/test/component.primitives.test.js

@@ -0,0 +1,47 @@
+"use strict";
+exports.__esModule = true;
+var helpers_1 = require("./helpers");
+describe('Typescript with fields', function () {
+    it('should generate component with number', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("number", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n    public myField: number;\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n    public float @myField;\n\t}");
+    });
+    it('should generate component with string', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("string", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n    public myField: string;\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n    public string @myField;\n\t}");
+    });
+    it('should generate component with string array', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("stringArray", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n    public myField: string[];\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n    public string[] @myField;\n\t}");
+    });
+    it('should generate component with boolean', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("bool", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n    public myField: boolean;\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n    public bool @myField;\n\t}");
+    });
+    it('should generate component with object', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("object", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n    public myField: object;\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n    public UnityEngine.Object @myField;\n\t}");
+    });
+    it('should generate component with default values', function () {
+        (0, helpers_1.compareCodegenWithDefaultContext)("fields with default values", 
+        // INPUT
+        "export class MyComponent extends Behaviour {\n    public myField: number = 42;\n    public myField2: string = \"hello\";\n    public myField3: boolean = true;\n    public myField4: object = null;\n    public myVector2: Vector2 = new Vector2(1, .5);\n}\n", 
+        // EXPECTED
+        "public partial class MyComponent : UnityEngine.MonoBehaviour\n\t{\n    public float @myField = 42f;\n    public string @myField2 = \"hello\";\n    public bool @myField3 = true;\n    public UnityEngine.Object @myField4;\n\t\tpublic UnityEngine.Vector2 @myVector2 = new UnityEngine.Vector2(1f, .5f);\n\t}");
+    });
+});

package/test/component.primitives.test.ts

@@ -91,7 +91,7 @@ describe('Typescript with fields', () => {
   });
 
 
-  
+
 
   it('should generate component with default values', () => {
     compareCodegenWithDefaultContext("fields with default values",
@@ -101,6 +101,7 @@ describe('Typescript with fields', () => {
     public myField2: string = "hello";
     public myField3: boolean = true;
     public myField4: object = null;
+    public myVector2: Vector2 = new Vector2(1, .5);
 }
 `,
       // EXPECTED
@@ -109,7 +110,8 @@ describe('Typescript with fields', () => {
     public float @myField = 42f;
     public string @myField2 = "hello";
     public bool @myField3 = true;
-    public UnityEngine.Object @myField4 = null;
+    public UnityEngine.Object @myField4;
+		public UnityEngine.Vector2 @myVector2 = new UnityEngine.Vector2(1f, .5f);
 	}`
     );
   });

package/test/helpers.js

@@ -0,0 +1,54 @@
+"use strict";
+exports.__esModule = true;
+exports.compareCodegenWithDefaultContext = exports.compareCodegen = exports.testCompile = void 0;
+var component_compiler_1 = require("../src/component-compiler");
+var chai_1 = require("chai");
+var fs = require("fs");
+var TestOptions = /** @class */ (function () {
+    function TestOptions() {
+        this.ignoreWhiteSpace = true;
+    }
+    return TestOptions;
+}());
+function testCompile(code) {
+    var res = (0, component_compiler_1.compile)(code, "test", null, false);
+    var output = (res === null || res === void 0 ? void 0 : res.length) > 0 ? res[0] : "";
+    return output;
+}
+exports.testCompile = testCompile;
+function compareByLine(output, expected) {
+    var splitCode = /\r?\n/;
+    if (output == null) {
+        (0, chai_1.expect)(expected).to.equal(output);
+    }
+    else {
+        var outputLines = output.split(splitCode);
+        var expectedLines = expected.split(splitCode);
+        for (var i = 0; i < outputLines.length; i++) {
+            var outputLine = outputLines[i].trim();
+            var expectedLine = expectedLines[i].trim();
+            (0, chai_1.expect)(outputLine).to.equal(expectedLine, "Line ".concat(i, " does not match"));
+        }
+    }
+}
+function compareCodegen(id, input, expected) {
+    var baseDir = "test/codegen";
+    if (!fs.existsSync(baseDir))
+        fs.mkdirSync(baseDir);
+    var dir = "".concat(baseDir, "/").concat(id);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir);
+    fs.writeFileSync("".concat(dir, "\\input.ts"), input);
+    var result = testCompile(input);
+    if (result !== null)
+        fs.writeFileSync("".concat(dir, "\\output.cs"), result);
+    fs.writeFileSync("".concat(dir, "\\expected.cs"), expected);
+    compareByLine(result, expected);
+    // expect(result).to.equal(expected);
+}
+exports.compareCodegen = compareCodegen;
+function compareCodegenWithDefaultContext(id, input, expected) {
+    expected = "// NEEDLE_CODEGEN_START\n    // auto generated code - do not edit directly\n    \n    #pragma warning disable\n    \n    namespace Needle.Typescript.GeneratedComponents\n    {\n    \t" + expected + "\n    }\n    \n    // NEEDLE_CODEGEN_END";
+    return compareCodegen(id, input, expected);
+}
+exports.compareCodegenWithDefaultContext = compareCodegenWithDefaultContext;

package/workspace.code-workspace

@@ -1,8 +1,12 @@
-{
-	"folders": [
-		{
-			"path": "."
-		}
-	],
-	"settings": {}
+{
+	"folders": [
+		{
+			"path": "."
+		}
+	],
+	"settings": {
+		"files.exclude": {
+		  "test/*.js": true
+		}
+	}
 }

package/test/codegen/abstract method/expected.cs

@@ -1,14 +0,0 @@
-// NEEDLE_CODEGEN_START
-    // auto generated code - do not edit directly
-    
-    #pragma warning disable
-    
-    namespace Needle.Typescript.GeneratedComponents
-    {
-    	public partial class MyComponent : UnityEngine.MonoBehaviour
-	{
-    public void OnDisable(){}
-	}
-    }
-    
-    // NEEDLE_CODEGEN_END

package/test/codegen/abstract method/input.js

@@ -1,27 +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.MyComponent = void 0;
-var MyComponent = /** @class */ (function (_super) {
-    __extends(MyComponent, _super);
-    function MyComponent() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    MyComponent.prototype.onDisable = function () { };
-    return MyComponent;
-}(Behaviour));
-exports.MyComponent = MyComponent;

package/test/codegen/abstract method/input.ts

@@ -1,4 +0,0 @@
-export class MyComponent extends Behaviour {
-      onDisable() {}
-    }
-}

package/test/codegen/abstract method/output.cs

@@ -1,14 +0,0 @@
-// NEEDLE_CODEGEN_START
-// auto generated code - do not edit directly
-
-#pragma warning disable
-
-namespace Needle.Typescript.GeneratedComponents
-{
-	public partial class MyComponent : UnityEngine.MonoBehaviour
-	{
-		public void OnDisable(){}
-	}
-}
-
-// NEEDLE_CODEGEN_END

package/test/codegen/basic/expected.cs

@@ -1,13 +0,0 @@
-// NEEDLE_CODEGEN_START
-    // auto generated code - do not edit directly
-    
-    #pragma warning disable
-    
-    namespace Needle.Typescript.GeneratedComponents
-    {
-    	public partial class BasicComponet : UnityEngine.MonoBehaviour
-	{
-	}
-    }
-    
-    // NEEDLE_CODEGEN_END