@needle-tools/needle-component-compiler 1.9.1 → 2.0.0-pre

package/Changelog.md

@@ -4,6 +4,9 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [2.0.0-pre] - 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
 

package/package.json

@@ -1,15 +1,16 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "1.9.1",
+    "version": "2.0.0-pre",
     "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/src/base-compiler.js

@@ -0,0 +1,405 @@
+"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;
+            }
+        }
+    };
+    // beginArray() {
+    //     this.writeLine("[");
+    //     this.indent++;
+    // }
+    // insertArrayItem(item: string) {
+    //     this.writeLine(item + ",");
+    // }
+    // 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.lines.join("\r");
+        this.lines.length = 0;
+        var fullPath = directory + "/" + filename;
+        fs.writeFileSync(fullPath, content);
+        return fs.realpathSync(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, path);
+    return compiler;
+}
+exports.runFromFile = runFromFile;
+var Compiler = /** @class */ (function () {
+    function Compiler() {
+    }
+    Compiler.prototype.compile = function (writer, code, sourceFilePath) {
+        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, sourceFilePath);
+    };
+    Compiler.prototype.run = function (prog, writer, sourceFile, filePath) {
+        var _this = this;
+        console.log("Starting compilation of " + filePath);
+        writer.begin(filePath);
+        ts.forEachChild(sourceFile, function (node) {
+            _this.visit(filePath, node, writer);
+        });
+        writer.end(filePath);
+    };
+    Compiler.prototype.visit = function (filePath, node, writer) {
+        var _this = this;
+        if (ts.isClassDeclaration(node)) {
+            this.visitClassDeclaration(filePath, 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(filePath, node, writer);
+            });
+        }
+    };
+    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));
+        if (res === false) {
+            this.debugLog("CLASS SKIPPED", name);
+            return;
+        }
+        ts.forEachChild(node, function (node) {
+            _this.visit(filePath, node, writer);
+        });
+        writer.endNewType(filePath, 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;

package/src/blender-compiler.js

@@ -0,0 +1,141 @@
+"use strict";
+exports.__esModule = true;
+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"];
+var BlenderWriter = /** @class */ (function () {
+    function BlenderWriter(outputDirectory) {
+        this.writer = new base_compiler_1.CodeTextWriter();
+        this.createdSchemesPerFile = {};
+        this.currentlyProcessingFiles = {};
+        this.outputDirectory = outputDirectory;
+    }
+    BlenderWriter.prototype.resolveTypeName = function (typeName, comments) {
+        typeName = typeName.toLocaleLowerCase();
+        if (typeName.startsWith("three."))
+            typeName = typeName.substring("three.".length);
+        switch (typeName) {
+            case "number":
+                return "float";
+            case "int":
+                return "int";
+            case "boolean":
+                return "bool";
+            case "string":
+                return "string";
+            case "void":
+                return "void";
+            case "any":
+                return "any";
+            case "vector2":
+                return "vec2";
+            case "color":
+                return "col";
+            case "renderer":
+                return "comp";
+            case "eventlist":
+                return "evt";
+        }
+    };
+    BlenderWriter.prototype.begin = function (filePath) {
+        if (!this.currentlyProcessingFiles[filePath]) {
+            this.currentlyProcessingFiles[filePath] = [];
+        }
+        // this.writer.beginBlock("{")
+    };
+    BlenderWriter.prototype.end = function (filePath) {
+        var results = this.currentlyProcessingFiles[filePath];
+        console.log("Writing schemes for", filePath, results);
+        if (results) {
+            var previousResultsFromThisFile = this.createdSchemesPerFile[filePath];
+            if (previousResultsFromThisFile) {
+                for (var _i = 0, previousResultsFromThisFile_1 = previousResultsFromThisFile; _i < previousResultsFromThisFile_1.length; _i++) {
+                    var previouslyCreated = previousResultsFromThisFile_1[_i];
+                    var foundInAny = results.includes(previouslyCreated);
+                    if (!foundInAny) {
+                        for (var sourcePath in this.createdSchemesPerFile) {
+                            if (foundInAny)
+                                break;
+                            if (sourcePath === filePath)
+                                continue;
+                            var otherSourceSchemes = this.createdSchemesPerFile[sourcePath];
+                            if (otherSourceSchemes.includes(previouslyCreated)) {
+                                // the file was moved to another source file
+                                foundInAny = true;
+                            }
+                        }
+                    }
+                    if (!foundInAny) {
+                        (0, fs_1.unlinkSync)(previouslyCreated);
+                    }
+                }
+            }
+            this.createdSchemesPerFile[filePath] = results;
+        }
+        delete this.currentlyProcessingFiles[filePath];
+        // this.writer.endBlock("}");
+        // this.writer.flush(this.outputFilePath);
+    };
+    BlenderWriter.prototype.startNewType = function (filePath, typeName, baseType, comments) {
+        if (baseType !== "Behaviour")
+            return false;
+        this.writer.beginBlock("{");
+        if (comments)
+            console.log(comments);
+        this.writer.beginBlock("\"" + typeName + "\": {");
+    };
+    BlenderWriter.prototype.endNewType = function (filePath, typeName) {
+        this.writer.endBlock("},");
+        this.writer.endBlock("}");
+        this.writeScheme(filePath, typeName);
+    };
+    BlenderWriter.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
+        if (!supportedTypes.includes(type)) {
+            console.log("-- unsupported type:", type);
+            return;
+        }
+        this.writer.beginBlock("\"" + name + "\": {");
+        this.writer.writeLine("\"type\": \"" + type + "\",");
+        if (initialValue && !isArray) {
+            if (initialValue.startsWith("new "))
+                initialValue = undefined;
+            switch (type) {
+                case "bool":
+                    initialValue = initialValue.toLowerCase();
+                    break;
+                case "string":
+                    initialValue = "\"" + initialValue + "\"";
+            }
+            if (initialValue)
+                this.writer.writeLine("\"value\": " + initialValue);
+        }
+        if (isArray) {
+            this.writer.writeLine("\"isArray\": true");
+        }
+        this.writer.endBlock("},");
+    };
+    BlenderWriter.prototype.writeMethod = function (visibility, name, returnType, args, comments) {
+        this.writer.beginBlock("\"" + name + "\": {");
+        this.writer.writeLine("\"type\": \"fn\",");
+        this.writer.endBlock("},");
+    };
+    BlenderWriter.prototype.writeNewTypeExpression = function (typeName, args) {
+        console.log("new type:", typeName);
+    };
+    BlenderWriter.prototype.writeScheme = function (processingFilePath, component) {
+        var outputPath = this.writer.flush(this.outputDirectory, component + ".component.json");
+        // if an output path is returned it means a file has been written to that path
+        if (outputPath) {
+            (0, commands_1.sendFileWrittenCommand)(outputPath);
+            // add the scheme to the list of created schemes
+            if (processingFilePath && this.currentlyProcessingFiles[processingFilePath]) {
+                this.currentlyProcessingFiles[processingFilePath].push(outputPath);
+            }
+        }
+    };
+    return BlenderWriter;
+}());
+exports.BlenderWriter = BlenderWriter;
+// runFromFile(new BlenderWriter("dist"), "src\\test.ts");

package/src/commands.js

@@ -0,0 +1,11 @@
+"use strict";
+exports.__esModule = true;
+exports.sendFileWrittenCommand = exports.sendReloadCommand = void 0;
+function sendReloadCommand() {
+    process.stdout.write("CMD:reload\r");
+}
+exports.sendReloadCommand = sendReloadCommand;
+function sendFileWrittenCommand(path) {
+    process.stdout.write("CMD:writefile " + path + "\r");
+}
+exports.sendFileWrittenCommand = sendFileWrittenCommand;