@needle-tools/needle-component-compiler 2.3.0-pre → 2.4.0-pre

package/Changelog.md

@@ -4,8 +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).
 
-## [2.3.0-pre] - 2022-11-22
+## [2.4.0-pre] - 2022-11-22
+# Blender compiler
+- Add: emit types from declared class implementing `IComponent` e.g. ``declare class MyComp implements IComponent``
 
+## [2.3.0-pre] - 2022-11-22
 # Blender compiler
 - Add emit array
 - Add emit types by class name if unknown

package/Readme.md

@@ -13,4 +13,7 @@ Please run ``npm install`` first before using.
 - ``@serializeField`` field decorator, similar to ``[SerializeField]`` in Unity
 - ``@nonSerialized`` field or method decorator to skip generating c# code for a field or a method, similar to ``[NonSerialized]`` in Unity
 - ``@type MyNamespace.MyType`` decorator for fields or classes, specifiy C# type of field or class
-- ``@ifdef MY_IFDEF`` field decorator only at the moment
+- ``@ifdef MY_IFDEF`` field decorator only at the moment
+
+### Test
+- Run single test: `` npm run test:single -- -r ts-node/register "./test/blender/blender.from_typedef.test.ts"``

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "2.3.0-pre",
+    "version": "2.4.0-pre",
     "description": "Compile mock unity components from typescript",
     "main": "index.js",
     "scripts": {
@@ -9,7 +9,8 @@
         "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:blender": "mocha -r ts-node/register test/blender/**.test.ts",
+        "test:single": "mocha"
     },
     "dependencies": {
         "chokidar": "^3.5.3",

package/src/base-compiler.js

@@ -209,7 +209,7 @@ var Compiler = /** @class */ (function () {
         if (node.heritageClauses) {
             for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) {
                 var clause = _a[_i];
-                if (clause.token == ts.SyntaxKind.ExtendsKeyword) {
+                if (clause.token == ts.SyntaxKind.ExtendsKeyword || clause.token == ts.SyntaxKind.ImplementsKeyword) {
                     for (var _b = 0, _c = clause.types; _b < _c.length; _b++) {
                         var type = _c[_b];
                         var typeName = type.expression.getText();

package/src/blender-compiler.js

@@ -5,6 +5,7 @@ var fs_1 = require("fs");
 var base_compiler_1 = require("./base-compiler");
 var commands_1 = require("./commands");
 var supportedTypes = ["string", "float", "int", "bool", "col", "obj", "evt", "fn", "vec2", "vec3", "comp"];
+var knownBaseTypes = ["Behaviour", "IComponent"];
 var BlenderWriter = /** @class */ (function () {
     function BlenderWriter(_sink) {
         this._sink = _sink;
@@ -105,7 +106,15 @@ var BlenderWriter = /** @class */ (function () {
         delete this._currentlyProcessingFiles[filePath];
     };
     BlenderWriter.prototype.startNewType = function (filePath, typeName, baseTypes, comments) {
-        if (baseTypes.includes("Behaviour") == false)
+        var isSupportedType = false;
+        for (var i = 0; i < knownBaseTypes.length; i++) {
+            if (baseTypes.includes(knownBaseTypes[i])) {
+                isSupportedType = true;
+                break;
+            }
+        }
+        // console.log(baseTypes, knownBaseTypes, isSupportedType)
+        if (!isSupportedType)
             return false;
         this.writer.beginBlock("{");
         if (comments)

package/src/test.js

@@ -1,10 +1,58 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//@type("MyComponent")
+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 SocLoader extends Behaviour {     
+// export class EventComponent extends Behaviour {    
+//     @serializeable(EventList)
+//     roomChanged: EventList = new EventList();
+// }
+// export class SocLoader extends Behaviour {    
 //     @serializeable(AssetReference) 
 //     scenes: Array<AssetReference> = [];
 // }
@@ -24,32 +72,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 //     map2 : Map<object> = new Map<object>();
 //     private myThing : Test123;
 // } 
-// // @type UnityEngine.MonoBehaviour
+// //@type UnityEngine.MonoBehaviour
 // export class ButtonObject extends Interactable implements IPointerClickHandler, ISerializable {
 //     //@type UnityEngine.Transform[]
 //     myType?: SceneFXWindow;
 // }
-// export class EventComponent extends Behaviour {    
-//     @serializeable(EventList)
-//     roomChanged: EventList = new EventList();
-// }
-// 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();
-// }
 // import { Behaviour } from "needle.tiny.engine/engine-components/Component";
 // import { RoomEntity } from "./Room";
 // import { Behaviour } from "needle.tiny.engine/engine-components/Component";

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/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;