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

package/Changelog.md

@@ -4,6 +4,12 @@ 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-exp] - 2022-11-12
+- Add first version of blender scheme compiler
+
+## [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/RUN_MANUAL_BLENDER.bat

@@ -0,0 +1 @@
+npm run tsc src/blender-compiler && node src/blender-compiler.js dist src/test.ts

package/RUN_WATCHERS.bat

@@ -0,0 +1 @@
+npm run tsc src/watcher && node src/watcher.js

package/package.json

@@ -1,15 +1,16 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "1.9.0",
+    "version": "1.9.1-exp",
     "description": "Compile mock unity components from typescript",
     "main": "index.js",
     "scripts": {
         "tsc": "tsc",
-        "dev": "npm-watch compile",
-        "compile" : "tsc",
+        "dev": "npm-watch compile || exit 1",
+        "compile": "tsc",
         "test": "mocha -r ts-node/register test/**.test.ts"
     },
     "dependencies": {
+        "chokidar": "^3.5.3",
         "typescript": "^4.5.5"
     },
     "devDependencies": {
@@ -18,17 +19,21 @@
         "@types/node": "^18.7.18",
         "chai": "^4.3.6",
         "mocha": "^10.0.0",
-        "ts-node": "^10.9.1",
-        "npm-watch": "^0.11.0"
+        "npm-watch": "^0.11.0",
+        "ts-node": "^10.9.1"
     },
     "watch": {
-      "compile": {
-        "patterns": [
-          "src/component-compiler.ts"
-        ],
-        "extensions": "ts",
-        "quiet": false
-      }
+        "compile": {
+            "patterns": [
+                "src/base-compiler.ts",
+                "src/blender-compiler.ts",
+                "src/component-compiler.ts",
+                "src/watcher.ts"
+            ],
+            "ignore": "src/test.ts",
+            "extensions": "ts",
+            "quiet": false
+        }
     },
     "author": {
         "name": "Needle",

package/schemes/MyTestComponent.component.json

@@ -0,0 +1 @@
+{
    "MyTestComponent": {
        "myMethod": {
            "type": "fn"
        },
        "myEvent": {
            "type": "evt"
        },
        "myNumber": {
            "type": "float",
            "value": 1
        }
    }

package/src/base-compiler.js

@@ -0,0 +1,403 @@
+"use strict";
+exports.__esModule = true;
+exports.Compiler = exports.runFromFile = exports.CodeTextWriter = exports.Visibility = void 0;
+var fs_1 = require("fs");
+var ts = require("typescript");
+var fs = require("fs");
+var Visibility;
+(function (Visibility) {
+    Visibility[Visibility["Public"] = 0] = "Public";
+    Visibility[Visibility["Protected"] = 1] = "Protected";
+    Visibility[Visibility["Private"] = 2] = "Private";
+})(Visibility = exports.Visibility || (exports.Visibility = {}));
+var CodeTextWriter = /** @class */ (function () {
+    function CodeTextWriter() {
+        this.indent = 0;
+        this.lines = [];
+    }
+    CodeTextWriter.prototype.beginBlock = function (line) {
+        this.writeLine(line);
+        this.indent++;
+    };
+    CodeTextWriter.prototype.endBlock = function (line) {
+        // remove the comma from the last line
+        if (this.lines.length > 0) {
+            var prevLine = this.lines[this.lines.length - 1];
+            if (prevLine.endsWith(",")) {
+                this.lines[this.lines.length - 1] = prevLine.substring(0, prevLine.length - 1);
+            }
+        }
+        this.indent--;
+        this.writeLine(line);
+    };
+    CodeTextWriter.prototype.writeLine = function (line) {
+        var indent = "";
+        for (var i = 0; i < this.indent; i++) {
+            indent += "    ";
+        }
+        // remove whitespace so we can ensure we correctly end with a comma
+        this.lines.push(indent + (line === null || line === void 0 ? void 0 : line.trim()));
+    };
+    CodeTextWriter.prototype.write = function (text) {
+        var lines = text.split("\r");
+        if (lines.length > 1) {
+            for (var i = 0; i < lines.length; i++) {
+                this.writeLine(lines[i]);
+            }
+        }
+        else {
+            if (this.lines.length == 0) {
+                this.writeLine(text);
+            }
+            else {
+                var lastLine = this.lines[this.lines.length - 1];
+                this.lines[this.lines.length - 1] = lastLine + text;
+            }
+        }
+    };
+    CodeTextWriter.prototype.beginArray = function () {
+        this.writeLine("[");
+        this.indent++;
+    };
+    CodeTextWriter.prototype.insertArrayItem = function (item) {
+        this.writeLine(item + ",");
+    };
+    CodeTextWriter.prototype.endArray = function () {
+    };
+    CodeTextWriter.prototype.flush = function (directory, filename) {
+        if (this.lines.length === 0)
+            return;
+        if (!fs.existsSync(directory)) {
+            fs.mkdirSync(directory, { recursive: true });
+        }
+        var content = this.lines.join("\r");
+        this.lines.length = 0;
+        var fullPath = fs.realpathSync(directory + "/" + filename);
+        fs.writeFileSync(fullPath, content);
+        return fullPath;
+    };
+    return CodeTextWriter;
+}());
+exports.CodeTextWriter = CodeTextWriter;
+function runFromFile(writer, path) {
+    if (!fs.existsSync(path)) {
+        console.error("File not found", path);
+        return;
+    }
+    var code = (0, fs_1.readFileSync)(path).toString();
+    var compiler = new Compiler();
+    compiler.compile(writer, code);
+    return compiler;
+}
+exports.runFromFile = runFromFile;
+var Compiler = /** @class */ (function () {
+    function Compiler() {
+    }
+    Compiler.prototype.compile = function (writer, code) {
+        var file = "needle_compiled.ts";
+        var sourceFile = ts.createSourceFile(file, code, ts.ScriptTarget.ES2015, true, /*setParentNodes */ ts.ScriptKind.TS);
+        var prog = ts.createProgram([file], {});
+        this.run(prog, writer, sourceFile);
+    };
+    Compiler.prototype.run = function (prog, writer, sourceFile) {
+        var _this = this;
+        writer.begin();
+        ts.forEachChild(sourceFile, function (node) {
+            _this.visit(node, writer);
+        });
+        writer.end();
+    };
+    Compiler.prototype.visit = function (node, writer) {
+        var _this = this;
+        if (ts.isClassDeclaration(node)) {
+            this.visitClassDeclaration(node, writer);
+        }
+        else if (ts.isPropertyDeclaration(node)) {
+            this.visitPropertyDeclaration(node, writer);
+        }
+        else if (ts.isMethodDeclaration(node)) {
+            this.visitMethodDeclaration(node, writer);
+        }
+        else {
+            ts.forEachChild(node, function (node) {
+                _this.visit(node, writer);
+            });
+        }
+    };
+    Compiler.prototype.visitClassDeclaration = function (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(name, base, this.getComments(node));
+        if (res === false) {
+            this.debugLog("CLASS SKIPPED", name);
+            return;
+        }
+        ts.forEachChild(node, function (node) {
+            _this.visit(node, writer);
+        });
+        writer.endNewType(name);
+        this.debugLog("CLASS END", name, "\n");
+    };
+    Compiler.prototype.visitPropertyDeclaration = function (node, writer) {
+        var name = node.name.getText();
+        var type = this.resolveType(node.type, writer);
+        var visibility = this.getVisibility(node);
+        var initialValue = node.initializer && this.resolveExpression(node.initializer, writer);
+        var isArray = this.isArrayType(node.type);
+        if (!type && node.initializer) {
+            type = this.tryResolveTypeFromExpression(node.initializer, writer);
+        }
+        this.debugLog("PROPERTY", Visibility[visibility], name, isArray, type, initialValue);
+        writer.writeMember(visibility, name, isArray, type, initialValue, this.getComments(node));
+    };
+    Compiler.prototype.visitMethodDeclaration = function (node, writer) {
+        var _a;
+        var name = node.name.getText();
+        var visibility = this.getVisibility(node);
+        var returnType = this.resolveType(node.type, writer);
+        var args;
+        if ((_a = node.parameters) === null || _a === void 0 ? void 0 : _a.length) {
+            args = this.resolveParameters(node.parameters, writer);
+        }
+        this.debugLog("METHOD", Visibility[visibility], name, returnType, args);
+        writer.writeMethod(visibility, name, returnType, args, this.getComments(node));
+    };
+    Compiler.prototype.resolveParameters = function (parameters, writer) {
+        var result = [];
+        for (var _i = 0, parameters_1 = parameters; _i < parameters_1.length; _i++) {
+            var parameter = parameters_1[_i];
+            var name_1 = parameter.name.getText();
+            var type = this.resolveType(parameter.type, writer);
+            var defaultValue = parameter.initializer && this.resolveExpression(parameter.initializer, writer);
+            result.push({ name: name_1, type: type, defaultValue: defaultValue });
+        }
+        return result;
+    };
+    Compiler.prototype.debugLog = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        console.log.apply(console, args);
+    };
+    Compiler.prototype.getComments = function (node) {
+        var commentRanges = ts.getLeadingCommentRanges(node.getFullText(), 0);
+        if (commentRanges) {
+            var comments = [];
+            for (var _i = 0, commentRanges_1 = commentRanges; _i < commentRanges_1.length; _i++) {
+                var range = commentRanges_1[_i];
+                var text = node.getFullText().substring(range.pos, range.end).trimStart();
+                // match only lines that starts with //@ or // @
+                var match = text.match(/\/\/\s*@(.+)/);
+                if (match) {
+                    comments.push(text.substring(match.index + 2).trim());
+                }
+            }
+            return comments;
+        }
+    };
+    Compiler.prototype.getVisibility = function (node) {
+        if (node.modifiers) {
+            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
+                var modifier = _a[_i];
+                if (modifier.kind === ts.SyntaxKind.PublicKeyword) {
+                    return Visibility.Public;
+                }
+                else if (modifier.kind === ts.SyntaxKind.ProtectedKeyword) {
+                    return Visibility.Protected;
+                }
+                else if (modifier.kind === ts.SyntaxKind.PrivateKeyword) {
+                    return Visibility.Private;
+                }
+            }
+        }
+        return Visibility.Public;
+    };
+    Compiler.prototype.tryResolveTypeFromExpression = function (exp, write) {
+        var _a;
+        if (ts.isNewExpression(exp)) {
+            // try get generic type from expression
+            if ((_a = exp.typeArguments) === null || _a === void 0 ? void 0 : _a.length) {
+                for (var _i = 0, _b = exp.typeArguments; _i < _b.length; _i++) {
+                    var arg = _b[_i];
+                    var type = this.resolveType(arg, write);
+                    if (type) {
+                        return type;
+                    }
+                }
+            }
+            var typeName = exp.expression.getText();
+            // const typeName = exp.expression.getText();
+            // console.log("NEW EXPRESSION", typeName);
+            // const args = exp.arguments?.map(arg => this.resolveExpression(arg, write));
+            // write.writeNewTypeExpression(typeName, args);
+            return typeName;
+        }
+    };
+    Compiler.prototype.resolveType = function (typeNode, writer) {
+        if (!typeNode)
+            return undefined;
+        // check if its an array
+        if (this.isArrayType(typeNode)) {
+            if (typeNode.kind === ts.SyntaxKind.ArrayType) {
+                var arrayType = typeNode;
+                return this.resolveType(arrayType.elementType, writer);
+            }
+            // check if its Array<> or Map
+            if (typeNode.kind === ts.SyntaxKind.TypeReference) {
+                var typeReference = typeNode;
+                if (typeReference.typeName.getText() === "Array") {
+                    var typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
+                    return this.resolveType(typeArgument, writer);
+                }
+                else if (typeReference.typeName.getText() === "Map") {
+                    var typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
+                    return this.resolveType(typeArgument, writer);
+                }
+            }
+            // check if its dictionary
+            if (typeNode.kind === ts.SyntaxKind.TypeLiteral) {
+                var typeLiteral = typeNode;
+                var members = typeLiteral.members;
+                if (members.length === 2) {
+                    var firstMember = members[0];
+                    var secondMember = members[1];
+                    if (firstMember.kind === ts.SyntaxKind.IndexSignature && secondMember.kind === ts.SyntaxKind.IndexSignature) {
+                        var firstIndexSignature = firstMember;
+                        var secondIndexSignature = secondMember;
+                        var firstIndexType = firstIndexSignature.parameters[0].type;
+                        var secondIndexType = secondIndexSignature.parameters[0].type;
+                        if (firstIndexType.kind === ts.SyntaxKind.StringKeyword && secondIndexType.kind === ts.SyntaxKind.NumberKeyword) {
+                            var valueType = firstIndexSignature.type;
+                            return this.resolveType(valueType, writer);
+                        }
+                    }
+                }
+            }
+            // is generic
+            // if (typeNode.kind === ts.SyntaxKind.TypeReference) {
+            //     const typeReference = typeNode as ts.TypeReferenceNode;
+            //     const typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
+            //     return this.resolveType(typeArgument, writer);
+            // }
+            console.error("!!!!! ----- Unknown array type", typeNode.getText());
+        }
+        var type = typeNode.getText();
+        return this.resolveTypeFromString(type, writer);
+    };
+    Compiler.prototype.resolveTypeFromString = function (type, writer) {
+        var resolved = writer.resolveTypeName(type);
+        return resolved || type;
+    };
+    Compiler.prototype.isArrayType = function (typeNode) {
+        if (!typeNode)
+            return false;
+        // check if its an array
+        if (typeNode.kind === ts.SyntaxKind.ArrayType) {
+            return true;
+        }
+        // check if its Array<> or map
+        if (typeNode.kind === ts.SyntaxKind.TypeReference) {
+            var typeReference = typeNode;
+            if (typeReference.typeName.getText() === "Array") {
+                return true;
+            }
+            else if (typeReference.typeName.getText() === "Map") {
+                return true;
+            }
+        }
+        // check if its array or dictionary
+        if (typeNode.kind === ts.SyntaxKind.TypeLiteral) {
+            var typeLiteral = typeNode;
+            if (typeLiteral.members.length === 2) {
+                var first = typeLiteral.members[0];
+                var second = typeLiteral.members[1];
+                if (first.kind === ts.SyntaxKind.IndexSignature && second.kind === ts.SyntaxKind.IndexSignature) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    Compiler.prototype.resolveExpression = function (node, writer) {
+        var _this = this;
+        if (ts.isStringLiteral(node)) {
+            return this.resolveTypeFromString(node.text, writer);
+        }
+        else if (ts.isNumericLiteral(node)) {
+            return this.resolveTypeFromString(node.text, writer);
+        }
+        else if (ts.isIdentifier(node)) {
+            return this.resolveTypeFromString(node.text, writer);
+        }
+        // is true or false
+        else if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) {
+            return this.resolveTypeFromString(node.getText(), writer);
+        }
+        else if (ts.isPropertyAccessExpression(node)) {
+            var left = this.resolveExpression(node.expression, writer);
+            if (left) {
+                return left + "." + this.resolveTypeFromString(node.name.text, writer);
+            }
+        }
+        else if (ts.isCallExpression(node)) {
+            var left = this.resolveExpression(node.expression, writer);
+            if (left) {
+                var args = node.arguments.map(function (a) { return _this.resolveExpression(a, writer); }).filter(function (a) { return a; });
+                return left + "(" + args.join(", ") + ")";
+            }
+        }
+        else if (ts.isBinaryExpression(node)) {
+            var left = this.resolveExpression(node.left, writer);
+            var right = this.resolveExpression(node.right, writer);
+            if (left && right) {
+                return left + " " + node.operatorToken.getText() + " " + right;
+            }
+        }
+        else if (ts.isPrefixUnaryExpression(node)) {
+            var operand = this.resolveExpression(node.operand, writer);
+            if (operand) {
+                return node.operator + operand;
+            }
+        }
+        else if (ts.isPostfixUnaryExpression(node)) {
+            var operand = this.resolveExpression(node.operand, writer);
+            if (operand) {
+                return operand + node.operator;
+            }
+        }
+        else if (ts.isParenthesizedExpression(node)) {
+            return this.resolveExpression(node.expression, writer);
+        }
+        else if (ts.isArrayLiteralExpression(node)) {
+            var elements = node.elements.map(function (e) { return _this.resolveExpression(e, writer); }).filter(function (e) { return e; });
+            return "[" + elements.join(", ") + "]";
+        }
+        else if (ts.isObjectLiteralExpression(node)) {
+            var properties = node.properties.map(function (p) {
+                if (ts.isPropertyAssignment(p)) {
+                    var name_2 = p.name.getText();
+                    var value = _this.resolveExpression(p.initializer, writer);
+                    if (value) {
+                        return name_2 + ": " + value;
+                    }
+                }
+            }).filter(function (p) { return p; });
+            return "{" + properties.join(", ") + "}";
+        }
+        else if (ts.isNewExpression(node)) {
+            var typeName = this.resolveTypeFromString(node.expression.getText(), writer);
+            if (typeName) {
+                var args = node.arguments.map(function (a) { return _this.resolveExpression(a, writer); }).filter(function (a) { return a; });
+                // writer.writeNewTypeExpression(typeName, args);
+                // return;
+                return "new " + typeName + "(" + args.join(", ") + ")";
+            }
+        }
+        console.error("!!!!! ----- Unknown expression", ts.SyntaxKind[node.kind], node.getText());
+    };
+    return Compiler;
+}());
+exports.Compiler = Compiler;