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

package/Changelog.md

@@ -4,7 +4,13 @@ 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.2.0-pre] - 2022-11-13
+## [2.3.0-pre] - 2022-11-22
+
+# Blender compiler
+- Add emit array
+- Add emit types by class name if unknown
+
+## [2.2.0-pre.1] - 2022-11-13
 - Add: watcher now also generates the register_types file
 - Add: deleting code files now also deletes the generated files and reports it
 

package/package.json

@@ -1,13 +1,15 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "2.2.0-pre",
+    "version": "2.3.0-pre",
     "description": "Compile mock unity components from typescript",
     "main": "index.js",
     "scripts": {
         "tsc": "tsc",
         "dev": "npm-watch compile || exit 1",
         "compile": "tsc",
-        "test": "mocha -r ts-node/register test/**.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"
     },
     "dependencies": {
         "chokidar": "^3.5.3",
@@ -25,11 +27,9 @@
     "watch": {
         "compile": {
             "patterns": [
-                "src/base-compiler.ts",
-                "src/blender-compiler.ts",
-                "src/component-compiler.ts",
-                "src/watcher.ts",
-                "src/register-types.ts"
+                "src/**/*.ts",
+                "test/*/*.ts",
+                "test/*.ts"
             ],
             "ignore": "src/test.ts",
             "extensions": "ts",
@@ -45,4 +45,4 @@
         "type": "git",
         "url": "git+https://github.com/needle-tools/needle-tiny-component-compiler.git"
     }
-}
+}

package/src/base-compiler.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Compiler = exports.runFromFile = exports.handleDeletedFile = exports.CodeTextWriter = exports.Visibility = void 0;
+exports.Compiler = exports.runFromFile = exports.handleDeletedFile = exports.CodeTextWriter = exports.MemorySink = exports.FileSink = exports.Visibility = void 0;
 var fs_1 = require("fs");
 var ts = require("typescript");
 var fs = require("fs");
@@ -11,6 +11,36 @@ var Visibility;
     Visibility[Visibility["Protected"] = 1] = "Protected";
     Visibility[Visibility["Private"] = 2] = "Private";
 })(Visibility = exports.Visibility || (exports.Visibility = {}));
+var FileSink = /** @class */ (function () {
+    function FileSink(directory) {
+        this.directory = directory;
+    }
+    FileSink.prototype.flush = function (id, str) {
+        if (!fs.existsSync(this.directory)) {
+            fs.mkdirSync(this.directory, { recursive: true });
+        }
+        console.log("Writing " + id + " to " + this.directory);
+        var fullPath = this.directory + "/" + id;
+        fs.writeFileSync(fullPath, str);
+        return fs.realpathSync(fullPath);
+    };
+    return FileSink;
+}());
+exports.FileSink = FileSink;
+var MemorySink = /** @class */ (function () {
+    function MemorySink() {
+        this.results = [];
+    }
+    MemorySink.prototype.clear = function () {
+        this.results.length = 0;
+    };
+    MemorySink.prototype.flush = function (id, str) {
+        this.results.push(str);
+        return "";
+    };
+    return MemorySink;
+}());
+exports.MemorySink = MemorySink;
 var CodeTextWriter = /** @class */ (function () {
     function CodeTextWriter() {
         this.indent = 0;
@@ -69,18 +99,20 @@ var CodeTextWriter = /** @class */ (function () {
     // }
     // endArray() {
     // }
-    CodeTextWriter.prototype.flush = function (directory, filename) {
-        if (this.lines.length === 0)
-            return;
-        if (!fs.existsSync(directory)) {
-            fs.mkdirSync(directory, { recursive: true });
-        }
-        console.log("Writing " + filename + " to " + directory);
-        var content = this.toString();
+    CodeTextWriter.prototype.flush = function () {
+        var str = this.toString();
         this.lines.length = 0;
-        var fullPath = directory + "/" + filename;
-        fs.writeFileSync(fullPath, content);
-        return fs.realpathSync(fullPath);
+        return str;
+        // if (this.lines.length === 0) return;
+        // if (!fs.existsSync(directory)) {
+        //     fs.mkdirSync(directory, { recursive: true });
+        // }
+        // console.log("Writing " + filename + " to " + directory);
+        // const content = this.toString();
+        // this.lines.length = 0;
+        // const fullPath = directory + "/" + filename;
+        // fs.writeFileSync(fullPath, content);
+        // return fs.realpathSync(fullPath);
     };
     CodeTextWriter.prototype.clear = function () {
         this.lines.length = 0;
@@ -172,9 +204,22 @@ var Compiler = /** @class */ (function () {
     Compiler.prototype.visitClassDeclaration = function (filePath, node, writer) {
         var _this = this;
         var name = node.name.text;
-        var base = node.heritageClauses && node.heritageClauses[0].types[0].expression.getText();
-        this.debugLog("CLASS START", name, base);
-        var res = writer.startNewType(filePath, name, base, this.getComments(node));
+        // get all parent types
+        var baseTypes = [];
+        if (node.heritageClauses) {
+            for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) {
+                var clause = _a[_i];
+                if (clause.token == ts.SyntaxKind.ExtendsKeyword) {
+                    for (var _b = 0, _c = clause.types; _b < _c.length; _b++) {
+                        var type = _c[_b];
+                        var typeName = type.expression.getText();
+                        baseTypes.push(typeName);
+                    }
+                }
+            }
+        }
+        this.debugLog("CLASS START", name, baseTypes);
+        var res = writer.startNewType(filePath, name, baseTypes, this.getComments(node));
         if (res === false) {
             this.debugLog("CLASS SKIPPED", name);
             return;
@@ -282,6 +327,7 @@ var Compiler = /** @class */ (function () {
         }
     };
     Compiler.prototype.resolveType = function (typeNode, writer) {
+        var _a;
         if (!typeNode)
             return undefined;
         // check if its an array
@@ -330,6 +376,19 @@ var Compiler = /** @class */ (function () {
             console.error("!!!!! ----- Unknown array type", typeNode.getText());
         }
         var type = typeNode.getText();
+        var baseTypes = [];
+        if (typeNode.kind === ts.SyntaxKind.TypeReference) {
+            var typeReference = typeNode;
+            if ((_a = typeReference.typeArguments) === null || _a === void 0 ? void 0 : _a.length) {
+                for (var _i = 0, _b = typeReference.typeArguments; _i < _b.length; _i++) {
+                    var arg = _b[_i];
+                    var type_1 = this.resolveType(arg, writer);
+                    if (type_1) {
+                        baseTypes.push(type_1);
+                    }
+                }
+            }
+        }
         return this.resolveTypeFromString(type, writer);
     };
     Compiler.prototype.resolveTypeFromString = function (type, writer) {

package/src/blender-compiler.js

@@ -4,13 +4,13 @@ exports.BlenderWriter = void 0;
 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"];
+var supportedTypes = ["string", "float", "int", "bool", "col", "obj", "evt", "fn", "vec2", "vec3", "comp"];
 var BlenderWriter = /** @class */ (function () {
-    function BlenderWriter(outputDirectory) {
+    function BlenderWriter(_sink) {
+        this._sink = _sink;
         this.writer = new base_compiler_1.CodeTextWriter();
         this._createdSchemesPerFile = {};
         this._currentlyProcessingFiles = {};
-        this._outputDirectory = outputDirectory;
     }
     Object.defineProperty(BlenderWriter.prototype, "outputInfo", {
         get: function () {
@@ -19,9 +19,9 @@ var BlenderWriter = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(BlenderWriter.prototype, "outputDirectory", {
+    Object.defineProperty(BlenderWriter.prototype, "sink", {
         get: function () {
-            return this._outputDirectory;
+            return this._sink;
         },
         enumerable: false,
         configurable: true
@@ -55,9 +55,10 @@ var BlenderWriter = /** @class */ (function () {
                 return "col";
             case "eventlist":
                 return "evt";
-            case "renderer":
+            case "behaviour":
                 return "comp";
         }
+        return typeName;
     };
     BlenderWriter.prototype.begin = function (filePath) {
         if (!this._currentlyProcessingFiles[filePath]) {
@@ -103,8 +104,8 @@ var BlenderWriter = /** @class */ (function () {
         }
         delete this._currentlyProcessingFiles[filePath];
     };
-    BlenderWriter.prototype.startNewType = function (filePath, typeName, baseType, comments) {
-        if (baseType !== "Behaviour")
+    BlenderWriter.prototype.startNewType = function (filePath, typeName, baseTypes, comments) {
+        if (baseTypes.includes("Behaviour") == false)
             return false;
         this.writer.beginBlock("{");
         if (comments)
@@ -119,10 +120,10 @@ var BlenderWriter = /** @class */ (function () {
     BlenderWriter.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
         if (visibility !== base_compiler_1.Visibility.Public)
             return;
-        if (!supportedTypes.includes(type)) {
-            console.log("-- unsupported type:", type);
-            return;
-        }
+        // if (!supportedTypes.includes(type)) {
+        //     console.log("-- unsupported type:", type);
+        //     return;
+        // }
         this.writer.beginBlock("\"" + name + "\": {");
         this.writer.writeLine("\"type\": \"" + type + "\",");
         if (initialValue && !isArray) {
@@ -139,7 +140,7 @@ var BlenderWriter = /** @class */ (function () {
                 this.writer.writeLine("\"value\": " + initialValue);
         }
         if (isArray) {
-            this.writer.writeLine("\"isArray\": true");
+            this.writer.writeLine("\"value\": []");
         }
         this.writer.endBlock("},");
     };
@@ -154,13 +155,13 @@ var BlenderWriter = /** @class */ (function () {
         console.log("new type:", typeName);
     };
     BlenderWriter.prototype.writeScheme = function (processingFilePath, component) {
-        var outputPath = this.writer.flush(this._outputDirectory, component + ".component.json");
+        var res = this.sink.flush(component + ".component.json", this.writer.flush());
         // if an output path is returned it means a file has been written to that path
-        if (outputPath) {
-            (0, commands_1.sendFileWrittenCommand)(outputPath);
+        if (res && (0, fs_1.existsSync)(res)) {
+            (0, commands_1.sendFileWrittenCommand)(res);
             // add the scheme to the list of created schemes
             if (processingFilePath && this._currentlyProcessingFiles[processingFilePath]) {
-                this._currentlyProcessingFiles[processingFilePath].push({ componentName: component, filePath: outputPath });
+                this._currentlyProcessingFiles[processingFilePath].push({ componentName: component, filePath: res });
             }
         }
     };

package/src/csharp-compiler.js

@@ -0,0 +1,58 @@
+"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/react-three-fiber-compiler.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactThreeFiberCompiler = void 0;
+var ReactThreeFiberCompiler = /** @class */ (function () {
+    function ReactThreeFiberCompiler() {
+        this._typeSourceInformation = {};
+    }
+    Object.defineProperty(ReactThreeFiberCompiler.prototype, "outputInfo", {
+        get: function () {
+            return this._typeSourceInformation;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ReactThreeFiberCompiler.prototype.resolveTypeName = function (typescriptTypeName) {
+        return typescriptTypeName;
+    };
+    ReactThreeFiberCompiler.prototype.begin = function (filePath) {
+    };
+    ReactThreeFiberCompiler.prototype.end = function (filePath) {
+    };
+    ReactThreeFiberCompiler.prototype.startNewType = function (filePath, typeName, baseType, comments) {
+    };
+    ReactThreeFiberCompiler.prototype.endNewType = function (filePath, typeName) {
+    };
+    ReactThreeFiberCompiler.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
+    };
+    ReactThreeFiberCompiler.prototype.writeMethod = function (visibility, name, returnType, args, comments) {
+    };
+    ReactThreeFiberCompiler.prototype.writeNewTypeExpression = function (typeName, args) {
+    };
+    return ReactThreeFiberCompiler;
+}());
+exports.ReactThreeFiberCompiler = ReactThreeFiberCompiler;

package/src/register-types.js

@@ -26,7 +26,7 @@ function writeTypeRegistry(types, registerTypesPath) {
         }
     }
     writer.writeLine("\n// Made with 🌵 Needle");
-    writer.writeLine("\n// www.needle.tools");
+    writer.writeLine("// https://needle.tools");
     var code = writer.toString();
     file.write(code);
     file.end();

package/src/watcher.js

@@ -74,4 +74,5 @@ if (fs.existsSync(outputDirectory))
     fs.rmSync(outputDirectory, { recursive: true });
 console.log("Watch: " + directoryToWatch + " and output to: " + outputDirectory);
 var watcher = new DirectoryWatcher();
-watcher.startWatching(directoryToWatch, new blender_compiler_1.BlenderWriter(outputDirectory), registerTypesPath);
+var sink = new base_compiler_1.FileSink(outputDirectory);
+watcher.startWatching(directoryToWatch, new blender_compiler_1.BlenderWriter(sink), registerTypesPath);

package/test/component.basic.test.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: 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

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: 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

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: 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

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: 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

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: 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/tsconfig.json

@@ -1,9 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "es5",
-        "types": [
-            "mocha",
-            "node"
-        ]
-    }
-}

package/workspace.code-workspace

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