@needle-tools/needle-component-compiler 1.7.3 → 1.9.0

package/Changelog.md

@@ -4,6 +4,14 @@ 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.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
+
 ## [1.7.3] - 2022-09-02
 - Fix codegen for unknown array types
 - Fix codegen for abstract classes

package/DEV.bat

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

package/RUN_TESTS.bat

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

package/Readme.md

@@ -10,6 +10,7 @@ Please run ``npm install`` first before using.
 ### Command decorators
 - ``@dont-generate-component`` add before class to skip generating a component
 - ``@generate-component`` to enforce generating a component (not required)
-- ``@serializeField`` field decorator, similar to ``[SerializeField]``
+- ``@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

package/package.json

@@ -1,16 +1,34 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "1.7.3",
+    "version": "1.9.0",
     "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");
@@ -12,41 +12,59 @@ var exportNextClassCommand = "@generate-component";
 var dontExportNextClassCommand = "@dont-generate-component";
 // add above field to add [SerializeField] attribute
 var serializeCommand = "@serializeField";
+var dontSerializeCommand = "@nonSerialized";
 // https://regex101.com/r/ltpcKT/2
 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;
@@ -74,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;
@@ -123,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++) {
@@ -146,6 +182,8 @@ function run(program, outputDir, sourceFile) {
                     }
                     else if (comment.includes(serializeCommand))
                         serializeField = true;
+                    else if (comment.includes(dontSerializeCommand))
+                        dontSerialize = true;
                 }
                 if (comment.includes(exportNextClassCommand))
                     exportNextClass = true;
@@ -155,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) {
@@ -168,6 +207,7 @@ function run(program, outputDir, sourceFile) {
                 }
             }
         }
+        var skip = dontSerialize;
         switch (node.kind) {
             // Namespace
             // case ts.SyntaxKind.ModuleDeclaration:
@@ -187,13 +227,17 @@ function run(program, outputDir, sourceFile) {
             case ts.SyntaxKind.MethodDeclaration:
                 lastTypeFound = null;
                 serializeField = false;
+                dontSerialize = false;
                 resetExportNextClass();
                 if (!context)
                     break;
                 // TODO: always emit at least OnEnable method per class so generated components have toggle in editor
                 var meth = node;
                 // const isCoroutine = func.asteriskToken;
-                if (meth.name) {
+                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];
@@ -201,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;
@@ -216,28 +269,36 @@ 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);
                 var visibility = pub ? "public" : "private";
                 var isAccessible = pub;
-                if (!pub && serializeField) {
-                    console.log("[SerializeField]");
+                dontSerialize = false;
+                if (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);
                 var postFix = "";
                 var typeName = (_c = vardec.type) === null || _c === void 0 ? void 0 : _c.getText();
+                var shouldCommentTheLine = typeString === undefined;
                 if (typeString === undefined) {
                     postFix = " → Could not resolve C# type";
                 }
@@ -284,12 +345,15 @@ 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");
-                    typeString = "object[]";
-                    assignment = " = new object[0]";
+                    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);
-                var prefix = typeString === undefined ? "// " : "";
+                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;
                 if (requireEndIf) {
@@ -304,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("");
@@ -321,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++) {
@@ -329,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;
                             }
                         }
@@ -342,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;
@@ -357,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")
@@ -381,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];
@@ -390,7 +459,7 @@ 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;
@@ -399,20 +468,21 @@ function run(program, outputDir, sourceFile) {
                     }
                     if (!args)
                         args = "";
-                    if (type_4)
-                        return "new " + type_4 + "(" + args + ")";
+                    if (type)
+                        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++) {
@@ -453,7 +523,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];
@@ -505,7 +576,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;
@@ -563,7 +635,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 + ">";
@@ -591,18 +664,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);
+            }
+        });
+    }
 }