@needle-tools/needle-component-compiler 1.8.0 → 1.9.1

package/Changelog.md

@@ -4,6 +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).
 
+## [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
+
 ## [1.8.0] - 2022-09-02
 - Add ``@nonSerialized`` decorator for fields and methods
 - Fix comment gen for unknown types

package/DEV.bat

@@ -0,0 +1 @@
+npm install && npm run dev

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_TESTS.bat

@@ -0,0 +1 @@
+npm run test & pause

package/package.json

@@ -1,16 +1,34 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "1.8.0",
+    "version": "1.9.1",
     "description": "Compile mock unity components from typescript",
     "main": "index.js",
     "scripts": {
-        "tsc": "tsc"
+        "tsc": "tsc",
+        "dev": "npm-watch compile",
+        "compile" : "tsc",
+        "test": "mocha -r ts-node/register test/**.test.ts"
     },
     "dependencies": {
         "typescript": "^4.5.5"
     },
     "devDependencies": {
-        "@types/node": "^17.0.16"
+        "@types/chai": "^4.3.3",
+        "@types/mocha": "^9.1.1",
+        "@types/node": "^18.7.18",
+        "chai": "^4.3.6",
+        "mocha": "^10.0.0",
+        "ts-node": "^10.9.1",
+        "npm-watch": "^0.11.0"
+    },
+    "watch": {
+      "compile": {
+        "patterns": [
+          "src/component-compiler.ts"
+        ],
+        "extensions": "ts",
+        "quiet": false
+      }
     },
     "author": {
         "name": "Needle",

package/src/component-compiler.js

@@ -1,6 +1,6 @@
 "use strict";
 exports.__esModule = true;
-exports.run = void 0;
+exports.run = exports.compile = void 0;
 var fs_1 = require("fs");
 var ts = require("typescript");
 var fs = require("fs");
@@ -18,37 +18,53 @@ var typePattern = new RegExp("@type ?(?<type>.+)");
 var ifdefPattern = new RegExp("@ifdef ?(?<ifdef>.+)");
 var CODEGEN_MARKER_START = "// NEEDLE_CODEGEN_START";
 var CODEGEN_MARKER_END = "// NEEDLE_CODEGEN_END";
+var allowDebugLogs = true;
 // will be set to true when e.g. a comment for export is found
 var exportNextClass = false;
 var dontExportNextClass = false;
 var serializeField = false;
 var dontSerialize = false;
+var typesFileContent = undefined;
+// const exportDir = "../dist";
+var commentStarts = [];
+var contexts = [];
+var lastTypeFound = null;
+var ifdefSections = [];
+function resetAllState() {
+    exportNextClass = false;
+    dontExportNextClass = false;
+    serializeField = false;
+    dontSerialize = false;
+    typesFileContent = undefined;
+    commentStarts.length = 0;
+    contexts.length = 0;
+    lastTypeFound = null;
+    ifdefSections.length = 0;
+}
 function resetExportNextClass() {
     dontExportNextClass = false;
     exportNextClass = false;
 }
-var typesFileContent = undefined;
 function tryGetKnownType(str) {
     if (typesFileContent === undefined) {
         typesFileContent = null;
         var filePath = path.dirname(__dirname) + "/src/types.json";
         if (fs.existsSync(filePath)) {
-            console.log("Reading types file");
+            if (allowDebugLogs)
+                console.log("Reading types file");
             var content = fs.readFileSync(filePath, "utf8");
             typesFileContent = JSON.parse(content);
         }
     }
     if (typesFileContent) {
         var fullType = typesFileContent[str];
-        if (fullType)
+        if (fullType && allowDebugLogs)
             console.log(fullType);
         return fullType;
     }
     return null;
 }
 // https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API
-// const exportDir = "../dist";
-var commentStarts = [];
 var ExportContext = /** @class */ (function () {
     function ExportContext(outputDir, fileName) {
         this.classEnd = -1;
@@ -76,46 +92,62 @@ var ExportContext = /** @class */ (function () {
     ExportContext.prototype.flush = function () {
         if (this.textBuffer.length <= 0)
             return;
-        var dir = this.outputDir + "/";
-        var path = dir + this.fileName;
-        this.replaceGeneratedCodeSection(path);
-        console.log("Write to " + path);
-        fs.writeFileSync(path, this.textBuffer);
+        this.textBuffer = CODEGEN_MARKER_START + "\n" + this.textBuffer + "\n" + CODEGEN_MARKER_END;
+        var code = this.textBuffer;
+        if (this.outputDir !== null) {
+            var dir = this.outputDir + "/";
+            var path_1 = dir + this.fileName;
+            this.replaceGeneratedCodeSection(path_1);
+            if (allowDebugLogs)
+                console.log("Write to " + path_1);
+            fs.writeFileSync(path_1, code);
+        }
         this.reset();
+        return code;
     };
     ExportContext.prototype.reset = function () {
         this.textBuffer = "";
         this.classEnd = -1;
     };
     ExportContext.prototype.replaceGeneratedCodeSection = function (path) {
-        this.textBuffer = CODEGEN_MARKER_START + "\n" + this.textBuffer + "\n" + CODEGEN_MARKER_END;
         if (fs.existsSync(path)) {
             var existing = fs.readFileSync(path, "utf8");
             var regex = new RegExp("(?<before>.*?)\/\/ ?NEEDLE_CODEGEN_START.+\/\/ ?NEEDLE_CODEGEN_END(?<after>.*)", "s");
             var matches = regex.exec(existing);
             if (matches === null || matches === void 0 ? void 0 : matches.groups) {
-                console.log("Found codegen sections");
-                var before = matches.groups.before;
-                var after = matches.groups.after;
-                this.textBuffer = before + this.textBuffer + after;
+                if (allowDebugLogs)
+                    console.log("Found codegen sections");
+                var before_1 = matches.groups.before;
+                var after_1 = matches.groups.after;
+                this.textBuffer = before_1 + this.textBuffer + after_1;
             }
         }
     };
     return ExportContext;
 }());
-var contexts = [];
-var lastTypeFound = null;
-var ifdefSections = [];
+function compile(code, fileName, outputDir, debugLogs) {
+    if (debugLogs === void 0) { debugLogs = true; }
+    resetAllState();
+    allowDebugLogs = debugLogs;
+    // Parse a file
+    var sourceFile = ts.createSourceFile(fileName, code, ts.ScriptTarget.ES2015, true);
+    var prog = ts.createProgram([fileName], {});
+    // delint it
+    return run(prog, outputDir, sourceFile);
+}
+exports.compile = compile;
 function run(program, outputDir, sourceFile) {
-    if (!fs.existsSync(outputDir)) {
+    if (outputDir !== null && !fs.existsSync(outputDir)) {
         console.error("Output directory does not exist: \"" + outputDir + "\"");
         return;
     }
+    var results = [];
     traverseFile(sourceFile);
     function traverseFile(node) {
         visit(node);
         ts.forEachChild(node, traverseFile);
     }
+    return results;
     function visit(node) {
         var _a, _b, _c, _d, _e, _f;
         var context = contexts.length > 0 ? contexts[contexts.length - 1] : null;
@@ -125,12 +157,14 @@ function run(program, outputDir, sourceFile) {
                     context.indentLevel -= 1;
                     context.append("}\n");
                 }
-                context.flush();
+                var code = context.flush();
+                results.push(code);
                 context = null;
                 contexts.pop();
             }
         }
-        console.log("\t", ts.SyntaxKind[node.kind]);
+        if (allowDebugLogs)
+            console.log("\t", ts.SyntaxKind[node.kind]);
         var commentRanges = ts.getLeadingCommentRanges(sourceFile.getFullText(), node.getFullStart());
         if (commentRanges === null || commentRanges === void 0 ? void 0 : commentRanges.length) {
             for (var _i = 0, commentRanges_1 = commentRanges; _i < commentRanges_1.length; _i++) {
@@ -159,10 +193,11 @@ function run(program, outputDir, sourceFile) {
                 if (typeMatch && typeMatch.groups) {
                     // for some reason our regex does also match surrounding ( ) even tho: https://regex101.com/r/PoWK6V/1
                     // so we remove them
-                    var type_1 = typeMatch.groups["type"];
-                    type_1 = type_1.replace(/\(/, "").replace(/\)/, "");
-                    console.log("Found type: ", type_1);
-                    lastTypeFound = type_1;
+                    var type = typeMatch.groups["type"];
+                    type = type.replace(/\(/, "").replace(/\)/, "");
+                    if (allowDebugLogs)
+                        console.log("Found type: ", type);
+                    lastTypeFound = type;
                 }
                 var ifdefMatch = ifdefPattern.exec(comment);
                 if (ifdefMatch && ifdefMatch.groups) {
@@ -200,6 +235,9 @@ function run(program, outputDir, sourceFile) {
                 var meth = node;
                 // const isCoroutine = func.asteriskToken;
                 if (!skip && meth.name) {
+                    var pub_1 = isPublic(meth);
+                    if (!pub_1)
+                        return;
                     var paramsStr = "";
                     for (var _g = 0, _h = meth.parameters; _g < _h.length; _g++) {
                         var param = _h[_g];
@@ -207,13 +245,22 @@ function run(program, outputDir, sourceFile) {
                             continue;
                         if (paramsStr.length > 0)
                             paramsStr += ", ";
-                        var type_2 = tryResolveTypeRecursive(param);
-                        if (type_2 === undefined)
-                            type_2 = "object";
-                        paramsStr += type_2 + " @" + param.name.getText();
+                        var type = tryResolveTypeRecursive(param);
+                        if (type === undefined)
+                            type = "object";
+                        paramsStr += type + " @" + param.name.getText();
                     }
                     var methodName = meth.name.getText();
+                    switch (methodName) {
+                        case "onEnable":
+                            methodName = "OnEnable";
+                            break;
+                        case "onDisable":
+                            methodName = "OnDisable";
+                            break;
+                    }
                     context.onBeforeMethod(methodName);
+                    // let visibility = pub ? "public" : "private";
                     context.append("public void " + methodName + "(" + paramsStr + "){}\n");
                 }
                 break;
@@ -222,7 +269,8 @@ function run(program, outputDir, sourceFile) {
                 resetExportNextClass();
                 if (!context)
                     break;
-                console.log("Found variable", node.getText());
+                if (allowDebugLogs)
+                    console.log("Found variable", node.getText());
                 var vardec = node;
                 var varName = "@" + vardec.name.getText();
                 var pub = isPublic(vardec);
@@ -230,18 +278,21 @@ function run(program, outputDir, sourceFile) {
                 var isAccessible = pub;
                 dontSerialize = false;
                 if (serializeField) {
-                    console.log("[SerializeField]");
+                    if (allowDebugLogs)
+                        console.log("[SerializeField]");
                     context.appendLine("[UnityEngine.SerializeField]");
                     isAccessible = true;
                 }
                 else if (skip)
                     isAccessible = false;
                 if (!isAccessible) {
-                    console.log("Skip because not public or serializeable");
+                    if (allowDebugLogs)
+                        console.log("Skip because not public or serializeable");
                     break;
                 }
                 var name_1 = vardec.name.getText();
-                console.log("Variable:", name_1);
+                if (allowDebugLogs)
+                    console.log("Variable:", name_1);
                 if (name_1.startsWith("\"@") || name_1.startsWith("\"$") || name_1.startsWith("$"))
                     break;
                 var typeString = lastTypeFound !== null && lastTypeFound !== void 0 ? lastTypeFound : tryResolveTypeRecursive(node);
@@ -294,12 +345,14 @@ function run(program, outputDir, sourceFile) {
                 if (typeString === undefined)
                     typeString = typeName;
                 if (typeString === "[]") {
-                    console.log("Unknown array type for \"" + varName + " " + typeName + "\" - your type is probably not known (did you just create it this session?) and you might need to regenerate the Typemap in Unity. Go to \"Needle Engine/Internal/Generate Type Map for component compiler");
+                    if (allowDebugLogs)
+                        console.log("Unknown array type for \"" + varName + " " + typeName + "\" - your type is probably not known (did you just create it this session?) and you might need to regenerate the Typemap in Unity. Go to \"Needle Engine/Internal/Generate Type Map for component compiler");
                     // typeString = "object[]";
                     // assignment = " = new object[0]";
                     shouldCommentTheLine = true;
                 }
-                console.log("EMIT member: \"" + typeString + "\" " + varName, assignment, "Last type found:", lastTypeFound);
+                if (allowDebugLogs)
+                    console.log("EMIT member: \"" + typeString + "\" " + varName, assignment, "Last type found:", lastTypeFound);
                 var prefix = shouldCommentTheLine ? "// " : "";
                 context.append(prefix + visibility + " " + typeString + " " + varName + assignment + ";" + postFix + "\n");
                 lastTypeFound = null;
@@ -315,9 +368,11 @@ function run(program, outputDir, sourceFile) {
                 if (!dontExportNextClass && (lastTypeFound || exportNextClass || inheritsComponent)) {
                     resetExportNextClass();
                     var name_2 = (_d = dec.name) === null || _d === void 0 ? void 0 : _d.escapedText;
-                    console.log("Found class: ", name_2);
+                    if (allowDebugLogs)
+                        console.log("Found class: ", name_2);
                     var namespace = (_e = tryParseNamespace(node)) !== null && _e !== void 0 ? _e : "Needle.Typescript.GeneratedComponents";
-                    console.log("NAMESPACE", namespace);
+                    if (allowDebugLogs)
+                        console.log("NAMESPACE", namespace);
                     var newContext = new ExportContext(outputDir, name_2 + ".cs");
                     newContext.appendLine("// auto generated code - do not edit directly");
                     newContext.appendLine("");
@@ -332,7 +387,8 @@ function run(program, outputDir, sourceFile) {
                         typeName_1 = inheritsComponent;
                     if (lastTypeFound)
                         typeName_1 = lastTypeFound;
-                    console.log(name_2 + " inherits " + typeName_1);
+                    if (allowDebugLogs)
+                        console.log(name_2 + " inherits " + typeName_1);
                     var modifiers = "";
                     if (dec.modifiers) {
                         for (var _l = 0, _m = dec.modifiers; _l < _m.length; _l++) {
@@ -340,7 +396,8 @@ function run(program, outputDir, sourceFile) {
                             switch (mod.getText()) {
                                 case "abstract":
                                     modifiers += " abstract";
-                                    console.log(name_2 + " is abstract");
+                                    if (allowDebugLogs)
+                                        console.log(name_2 + " is abstract");
                                     break;
                             }
                         }
@@ -353,7 +410,8 @@ function run(program, outputDir, sourceFile) {
                     contexts.push(newContext);
                 }
                 else {
-                    console.log("Class type is unknown and will not generate a component: ", (_f = dec.name) === null || _f === void 0 ? void 0 : _f.escapedText);
+                    if (allowDebugLogs)
+                        console.log("Class type is unknown and will not generate a component: ", (_f = dec.name) === null || _f === void 0 ? void 0 : _f.escapedText);
                 }
                 lastTypeFound = null;
                 break;
@@ -368,10 +426,10 @@ function run(program, outputDir, sourceFile) {
                             if (h.types.length <= 0)
                                 continue;
                             for (var _b = 0, _c = h.types; _b < _c.length; _b++) {
-                                var type_3 = _c[_b];
+                                var type = _c[_b];
                                 // const symbol = program.getTypeChecker().getSymbolAtLocation(type.expression);
                                 // console.log(symbol);
-                                var text = type_3.expression.getText();
+                                var text = type.expression.getText();
                                 if (text === "Component")
                                     return true;
                                 if (text === "Behaviour")
@@ -392,7 +450,7 @@ function run(program, outputDir, sourceFile) {
                 case ts.SyntaxKind.FirstLiteralToken:
                     return node.getText();
                 case ts.SyntaxKind.NewExpression:
-                    var type_4 = undefined;
+                    var type = undefined;
                     var args = undefined;
                     for (var _i = 0, _a = node.getChildren(); _i < _a.length; _i++) {
                         var ch = _a[_i];
@@ -401,29 +459,46 @@ function run(program, outputDir, sourceFile) {
                         switch (ch.kind) {
                             case ts.SyntaxKind.Identifier:
                             case ts.SyntaxKind.PropertyAccessExpression:
-                                type_4 = tryGetTypeFromText(text);
+                                type = tryGetTypeFromText(text);
                                 break;
                             case ts.SyntaxKind.SyntaxList:
-                                args = text;
+                                for (var _b = 0, _c = ch.getChildren(); _b < _c.length; _b++) {
+                                    var arg = _c[_b];
+                                    if (args === undefined)
+                                        args = "";
+                                    var res = getTypeForAssignment(arg);
+                                    // handle floats being assigned with "f" suffix
+                                    if (Number.parseFloat(res) >= 0) {
+                                        args += res + "f";
+                                    }
+                                    else {
+                                        args += res;
+                                        if (res === ",")
+                                            args += " ";
+                                    }
+                                }
                                 break;
                         }
                     }
                     if (!args)
                         args = "";
-                    if (type_4)
-                        return "new " + type_4 + "(" + args + ")";
+                    if (type) {
+                        console.log(type, args);
+                        return "new " + type + "(" + args + ")";
+                    }
                     // const expType = node.getChildren().find(c => c.kind === ts.SyntaxKind.Identifier);
                     break;
             }
             var str = node.getText();
-            console.log("Unknown assignment:", str, ts.SyntaxKind[node.kind]);
+            if (allowDebugLogs)
+                console.log("Unknown assignment:", str, ts.SyntaxKind[node.kind]);
             return str;
         }
         function isPublic(node) {
             if (node.kind === ts.SyntaxKind.PublicKeyword) {
                 return true;
             }
-            else if (node.kind === ts.SyntaxKind.PrivateKeyword) {
+            else if (node.kind === ts.SyntaxKind.PrivateKeyword || node.kind === ts.SyntaxKind.ProtectedKeyword) {
                 return false;
             }
             for (var _i = 0, _a = node.getChildren(); _i < _a.length; _i++) {
@@ -464,7 +539,8 @@ function run(program, outputDir, sourceFile) {
             var separatorIndex = typeName.lastIndexOf(".");
             if (separatorIndex > 0) {
                 var newName = typeName.substring(separatorIndex + 1);
-                console.log("Remove import name from type: \"" + typeName + "\" → \"" + newName + "\"");
+                if (allowDebugLogs)
+                    console.log("Remove import name from type: \"" + typeName + "\" → \"" + newName + "\"");
                 typeName = newName;
             }
             var res = dict[typeName];
@@ -516,7 +592,8 @@ function run(program, outputDir, sourceFile) {
                 case ts.SyntaxKind.TypeReference:
                     var typeRef = node;
                     var typeName_2 = typeRef.typeName.getText();
-                    console.log("TypeReference:", typeName_2);
+                    if (allowDebugLogs)
+                        console.log("TypeReference:", typeName_2);
                     switch (typeName_2) {
                         case "Array":
                             break;
@@ -574,7 +651,8 @@ function run(program, outputDir, sourceFile) {
                 if (childResult !== undefined) {
                     if (res === undefined)
                         res = "";
-                    console.log("Child: " + ts.SyntaxKind[child.kind] + " → " + childResult);
+                    if (allowDebugLogs)
+                        console.log("Child: " + ts.SyntaxKind[child.kind] + " → " + childResult);
                     // if the thing is a generic return as generic result
                     if (isInGenericDeclaration && !res.includes("[]")) {
                         res = "<" + childResult + ">";
@@ -602,18 +680,20 @@ function run(program, outputDir, sourceFile) {
     }
 }
 exports.run = run;
-if (process.argv.length < 4) {
-    console.error("Missing args, call with: <output_dir> <input_files>");
-}
-else {
-    var outputDir_1 = process.argv[2];
-    var fileNames = process.argv.slice(3);
-    fileNames.forEach(function (fileName) {
-        // Parse a file
-        var sourceFile = ts.createSourceFile(fileName, (0, fs_1.readFileSync)(fileName).toString(), ts.ScriptTarget.ES2015, 
-        /*setParentNodes */ true);
-        var prog = ts.createProgram([fileName], {});
-        // delint it
-        run(prog, outputDir_1, sourceFile);
-    });
+if (process) {
+    if (process.argv.length < 4) {
+        console.error("Missing args, call with: <output_dir> <input_files>");
+    }
+    else {
+        var outputDir_1 = process.argv[2];
+        var fileNames = process.argv.slice(3);
+        fileNames.forEach(function (fileName) {
+            if (!fs.existsSync(fileName)) {
+            }
+            else {
+                var code = (0, fs_1.readFileSync)(fileName).toString();
+                compile(code, fileName, outputDir_1);
+            }
+        });
+    }
 }