@needle-tools/needle-component-compiler 2.2.0-pre.1 → 2.4.0-pre

package/Changelog.md

@@ -4,6 +4,15 @@ 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.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
+
 ## [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/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,13 +1,16 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "2.2.0-pre.1",
+    "version": "2.4.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",
+        "test:single": "mocha"
     },
     "dependencies": {
         "chokidar": "^3.5.3",
@@ -25,11 +28,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 +46,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 || 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();
+                        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,14 @@ 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 knownBaseTypes = ["Behaviour", "IComponent"];
 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 +20,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 +56,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 +105,16 @@ 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) {
+        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)
@@ -119,10 +129,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 +149,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 +164,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/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/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,5 +1,5 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+exports.__esModule = true;
 var helpers_1 = require("./helpers");
 describe('Basic typescript', function () {
     it('should generate component', function () {

package/test/component.methods.test.js

@@ -1,5 +1,5 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+exports.__esModule = true;
 var helpers_1 = require("./helpers");
 describe('Typescript with public methods', function () {
     it('should generate component with public method', function () {

package/test/component.nonserialized.test.js

@@ -1,5 +1,5 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+exports.__esModule = true;
 var helpers_1 = require("./helpers");
 describe('Typescript with nonSerialized', function () {
     it('should ignore field', function () {

package/test/component.primitives.test.js

@@ -1,5 +1,5 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+exports.__esModule = true;
 var helpers_1 = require("./helpers");
 describe('Typescript with fields', function () {
     it('should generate component with number', function () {

package/test/helpers.js

@@ -1,5 +1,5 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+exports.__esModule = true;
 exports.compareCodegenWithDefaultContext = exports.compareCodegen = exports.testCompile = void 0;
 var component_compiler_1 = require("../src/component-compiler");
 var chai_1 = require("chai");

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
-		}
-	}
-}