@needle-tools/needle-component-compiler 1.2.1 → 1.5.0

package/Changelog.md

@@ -4,6 +4,16 @@ 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.5.0] - 2022-07-07
+- change ``@type`` annotation to work with and without braces (e.g. ``@type My.Type`` or ``@type (My.Type)``)
+
+## [1.4.0] - 2022-07-06
+- add CODEGEN_START and END sections to allow adding code before or after a generated componnet
+- add ``@ifdef`` to ifdef fields 
+
+## [1.3.0] - 2022-06-27
+- add support for typescript namespace
+
 ## [1.2.1] - 2022-06-15
 - allow adding ``@type(MyNamespace.MyType)`` to class declaration
 

package/Readme.md

@@ -11,4 +11,5 @@ Please run ``npm install`` first before using.
 - ``@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]``
-- ``@type(MyNamespace.MyType)`` field decorator, specifiy C# type of field
+- ``@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/dist/MyClass.cs

@@ -1,23 +1,16 @@
-// auto generated code - do not edit
-namespace Needle.Typescript.GeneratedComponents
+// NEEDLE_CODEGEN_START
+// auto generated code - do not edit directly
+
+#pragma warning disable
+
+namespace Hello.World.Deep
 {
-	// source: C:\git\needle-tiny-playground\projects\Compiled_Export\myProject\src\scripts\MyClass.ts
-	public class MyClass : UnityEngine.MonoBehaviour
+	public partial class MyClass : UnityEngine.MonoBehaviour
 	{
-		public void start(){}
-		public float myFloat = 15;
-		public bool myBool;
-		// just some default values
-		public float[] myArray = new float[]{ 1, 2, 3 };
-		// comment for myString
-		public string myString = "this is a string";
-		public UnityEngine.Transform myObject;
-		public bool myBool2;
-		public void myFunction(){}
-		public void myFunctionWithStringParameter(string @string){}
-		public void myFunctionWithSomeObjectAndArray(UnityEngine.Transform @obj, float[] @arr){}
-		public void myFunctionWithoutParamTypes(object @test){}
-		public UnityEngine.Transform[] someOtherStuff;
-		public UnityEngine.Events.UnityEvent myEvent;
+		#ifdef TEST
+		public float @myFloat;
+		#endif
 	}
 }
+
+// NEEDLE_CODEGEN_END

package/dist/OtherClass.cs

@@ -0,0 +1,17 @@
+
+// I can edit this
+
+
+// NEEDLE_CODEGEN_START
+// auto generated code - do not edit directly
+
+#pragma warning disable
+
+namespace Needle.Typescript.GeneratedComponents
+{
+	public partial class OtherClass : UnityEngine.MonoBehaviour
+	{
+	}
+}
+
+// NEEDLE_CODEGEN_END

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "1.2.1",
+    "version": "1.5.0",
     "description": "Compile mock unity components from typescript",
     "main": "index.js",
     "scripts": {

package/src/component-compiler.js

@@ -11,7 +11,10 @@ var exportNextClassCommand = "@generate-component";
 var dontExportNextClassCommand = "@dont-generate-component";
 // add above field to add [SerializeField] attribute
 var serializeCommand = "@serializeField";
-var typePattern = new RegExp("@type ?\((?<type>.+)\)");
+var typePattern = new RegExp("@type ?\(?(?<type>[\w\.]+)\)?");
+var ifdefPattern = new RegExp("@ifdef ?(?<ifdef>.+)");
+var CODEGEN_MARKER_START = "// NEEDLE_CODEGEN_START";
+var CODEGEN_MARKER_END = "// NEEDLE_CODEGEN_END";
 // will be set to true when e.g. a comment for export is found
 var exportNextClass = false;
 var dontExportNextClass = false;
@@ -51,10 +54,8 @@ var ExportContext = /** @class */ (function () {
         if (this.textBuffer.length <= 0)
             return;
         var dir = this.outputDir + "/";
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir);
-        }
         var path = dir + this.fileName;
+        this.replaceGeneratedCodeSection(path);
         console.log("Write to " + path);
         fs.writeFileSync(path, this.textBuffer);
         this.reset();
@@ -63,10 +64,25 @@ var ExportContext = /** @class */ (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;
+            }
+        }
+    };
     return ExportContext;
 }());
 var contexts = [];
 var lastTypeFound = null;
+var ifdefSections = [];
 function run(program, outputDir, sourceFile) {
     if (!fs.existsSync(outputDir)) {
         console.error("Output directory does not exist: \"" + outputDir + "\"");
@@ -78,7 +94,7 @@ function run(program, outputDir, sourceFile) {
         ts.forEachChild(node, traverseFile);
     }
     function visit(node) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         var context = contexts.length > 0 ? contexts[contexts.length - 1] : null;
         if (context) {
             if ((context === null || context === void 0 ? void 0 : context.classEnd) > 0 && node.pos >= (context === null || context === void 0 ? void 0 : context.classEnd)) {
@@ -114,18 +130,33 @@ function run(program, outputDir, sourceFile) {
                     exportNextClass = true;
                 if (comment.includes(dontExportNextClassCommand))
                     dontExportNextClass = true;
-                var match = typePattern.exec(comment);
-                if (match && match.groups) {
+                var typeMatch = typePattern.exec(comment);
+                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 = match.groups["type"];
+                    var type = typeMatch.groups["type"];
                     type = type.replace(/\(/, "").replace(/\)/, "");
                     console.log("found type: ", type);
                     lastTypeFound = type;
                 }
+                var ifdefMatch = ifdefPattern.exec(comment);
+                if (ifdefMatch && ifdefMatch.groups) {
+                    var ifdef = ifdefMatch.groups["ifdef"];
+                    if (ifdef)
+                        ifdefSections.push(ifdef);
+                }
             }
         }
         switch (node.kind) {
+            // Namespace
+            // case ts.SyntaxKind.ModuleDeclaration:
+            //     const mod = node as ts.ModuleDeclaration;
+            //     console.log(ts.SyntaxKind[mod.getChildAt(1).kind])
+            //     const type = mod.getChildAt(1) as ts.Identifier;
+            //     console.log("MODULE", type.text)
+            //     break;
+            // case ts.SyntaxKind.Identifier:
+            //     break;
             // case ts.SyntaxKind.ClassDeclaration:
             // case ts.SyntaxKind.SingleLineCommentTrivia:
             //     console.log("comment: " + node.getText())
@@ -143,8 +174,8 @@ function run(program, outputDir, sourceFile) {
                 // const isCoroutine = func.asteriskToken;
                 if (meth.name) {
                     var paramsStr = "";
-                    for (var _e = 0, _f = meth.parameters; _e < _f.length; _e++) {
-                        var param = _f[_e];
+                    for (var _f = 0, _g = meth.parameters; _f < _g.length; _f++) {
+                        var param = _g[_f];
                         if (!param || !param.name)
                             continue;
                         if (paramsStr.length > 0)
@@ -177,8 +208,8 @@ function run(program, outputDir, sourceFile) {
                 var prefix = typeString === undefined ? "// " : "";
                 var assignment = "";
                 if (typeString !== undefined) {
-                    for (var _g = 0, _h = node.getChildren(); _g < _h.length; _g++) {
-                        var ch = _h[_g];
+                    for (var _h = 0, _j = node.getChildren(); _h < _j.length; _h++) {
+                        var ch = _j[_h];
                         switch (ch.kind) {
                             case ts.SyntaxKind.FalseKeyword:
                             case ts.SyntaxKind.TrueKeyword:
@@ -208,8 +239,16 @@ function run(program, outputDir, sourceFile) {
                     console.log("SERIALIZE");
                     context.appendLine("[UnityEngine.SerializeField]");
                 }
+                var requireEndIf = false;
+                if (ifdefSections.length > 0) {
+                    requireEndIf = true;
+                    context.appendLine("#ifdef " + ifdefSections.pop());
+                }
                 context.append(prefix + visibility + " " + typeString + " " + varName + assignment + ";\n");
                 lastTypeFound = null;
+                if (requireEndIf) {
+                    context.appendLine("#endif");
+                }
                 break;
             case ts.SyntaxKind.ClassDeclaration:
                 serializeField = false;
@@ -219,12 +258,14 @@ function run(program, outputDir, sourceFile) {
                     resetExportNextClass();
                     var name_2 = (_d = dec.name) === null || _d === void 0 ? void 0 : _d.escapedText;
                     console.log("Found class: ", name_2);
+                    var namespace = (_e = tryParseNamespace(node)) !== null && _e !== void 0 ? _e : "Needle.Typescript.GeneratedComponents";
+                    console.log("NAMESPACE", namespace);
                     var newContext = new ExportContext(outputDir, name_2 + ".cs");
                     newContext.appendLine("// auto generated code - do not edit directly");
                     newContext.appendLine("");
                     newContext.appendLine("#pragma warning disable");
                     newContext.appendLine("");
-                    newContext.appendLine("namespace Needle.Typescript.GeneratedComponents");
+                    newContext.appendLine("namespace " + namespace);
                     newContext.appendLine("{");
                     newContext.indentLevel += 1;
                     // newContext.appendLine("// source: " + path.resolve(sourceFile.fileName));
@@ -277,6 +318,31 @@ function run(program, outputDir, sourceFile) {
             }
             return true;
         }
+        function tryParseNamespace(node, namespace) {
+            // console.log("TRAVERSE - " + ts.SyntaxKind[node.kind]);
+            switch (node.kind) {
+                case ts.SyntaxKind.ModuleDeclaration:
+                    for (var _i = 0, _a = node.getChildren(); _i < _a.length; _i++) {
+                        var ch = _a[_i];
+                        // console.log("-- TRAVERSE - " + ts.SyntaxKind[ch.kind]);
+                        switch (ch.kind) {
+                            case ts.SyntaxKind.Identifier:
+                                var id = ch;
+                                if (id.text) {
+                                    if (!namespace)
+                                        namespace = "";
+                                    namespace = id.text + (namespace ? "." : "") + namespace;
+                                }
+                                break;
+                        }
+                    }
+                    break;
+            }
+            if (node.parent) {
+                return tryParseNamespace(node.parent, namespace);
+            }
+            return namespace;
+        }
         function tryResolveTypeRecursive(node) {
             var _a;
             if (!node)

package/src/component-compiler.ts

@@ -4,6 +4,7 @@ import * as fs from "fs";
 import * as path from "path";
 
 import * as types from "./types";
+import { traceDeprecation } from "process";
 const dict = types.dict;
 
 // add either of these two comments above a class to enforce code gen or disable it for the next class
@@ -11,7 +12,12 @@ const exportNextClassCommand = "@generate-component";
 const dontExportNextClassCommand = "@dont-generate-component";
 // add above field to add [SerializeField] attribute
 const serializeCommand = "@serializeField";
-const typePattern = new RegExp("@type ?\((?<type>.+)\)");
+// https://regex101.com/r/ltpcKT/1
+const typePattern = new RegExp("@type ?\(?(?<type>[\w\.]+)\)?");
+const ifdefPattern = new RegExp("@ifdef ?(?<ifdef>.+)")
+
+const CODEGEN_MARKER_START = "// NEEDLE_CODEGEN_START";
+const CODEGEN_MARKER_END = "// NEEDLE_CODEGEN_END";
 
 // will be set to true when e.g. a comment for export is found
 let exportNextClass: boolean = false;
@@ -64,10 +70,8 @@ class ExportContext {
     flush() {
         if (this.textBuffer.length <= 0) return;
         const dir = this.outputDir + "/";
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir);
-        }
         const path = dir + this.fileName;
+        this.replaceGeneratedCodeSection(path);
         console.log("Write to " + path);
         fs.writeFileSync(path, this.textBuffer);
         this.reset();
@@ -77,11 +81,27 @@ class ExportContext {
         this.textBuffer = "";
         this.classEnd = -1;
     }
+
+    private replaceGeneratedCodeSection(path: string) {
+        this.textBuffer = CODEGEN_MARKER_START + "\n" + this.textBuffer + "\n" + CODEGEN_MARKER_END;
+        if (fs.existsSync(path)) {
+            const existing = fs.readFileSync(path, "utf8");
+            const regex = new RegExp("(?<before>.*?)\/\/ ?NEEDLE_CODEGEN_START.+\/\/ ?NEEDLE_CODEGEN_END(?<after>.*)", "s");
+            const matches = regex.exec(existing);
+            if (matches?.groups) {
+                console.log("Found codegen sections")
+                const before = matches.groups.before;
+                const after = matches.groups.after;
+                this.textBuffer = before + this.textBuffer + after;
+            }
+        }
+    }
 }
 
 const contexts: ExportContext[] = [];
 
 let lastTypeFound: string | null = null;
+let ifdefSections: string[] = [];
 
 export function run(program: ts.Program, outputDir: string, sourceFile: ts.SourceFile) {
 
@@ -135,19 +155,35 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                     exportNextClass = true;
                 if (comment.includes(dontExportNextClassCommand))
                     dontExportNextClass = true;
-                const match = typePattern.exec(comment);
-                if (match && match.groups) {
+                const typeMatch = typePattern.exec(comment);
+                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
-                    let type = match.groups["type"];
+                    let type = typeMatch.groups["type"];
                     type = type.replace(/\(/, "").replace(/\)/, "");
                     console.log("found type: ", type);
                     lastTypeFound = type;
                 }
+
+                const ifdefMatch = ifdefPattern.exec(comment);
+                if (ifdefMatch && ifdefMatch.groups) {
+                    const ifdef = ifdefMatch.groups["ifdef"];
+                    if (ifdef)
+                        ifdefSections.push(ifdef);
+                }
             }
         }
 
         switch (node.kind) {
+            // Namespace
+            // case ts.SyntaxKind.ModuleDeclaration:
+            //     const mod = node as ts.ModuleDeclaration;
+            //     console.log(ts.SyntaxKind[mod.getChildAt(1).kind])
+            //     const type = mod.getChildAt(1) as ts.Identifier;
+            //     console.log("MODULE", type.text)
+            //     break;
+            // case ts.SyntaxKind.Identifier:
+            //     break;
             // case ts.SyntaxKind.ClassDeclaration:
             // case ts.SyntaxKind.SingleLineCommentTrivia:
             //     console.log("comment: " + node.getText())
@@ -224,8 +260,16 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                     console.log("SERIALIZE");
                     context.appendLine("[UnityEngine.SerializeField]");
                 }
+                let requireEndIf = false;
+                if(ifdefSections.length > 0){
+                    requireEndIf = true;
+                    context.appendLine("#ifdef " + ifdefSections.pop());
+                }
                 context.append(prefix + visibility + " " + typeString + " " + varName + assignment + ";\n");
                 lastTypeFound = null;
+                if(requireEndIf){
+                    context.appendLine("#endif");
+                }
                 break;
 
             case ts.SyntaxKind.ClassDeclaration:
@@ -236,12 +280,14 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                     resetExportNextClass();
                     const name = dec.name?.escapedText;
                     console.log("Found class: ", name);
+                    const namespace = tryParseNamespace(node) ?? "Needle.Typescript.GeneratedComponents";
+                    console.log("NAMESPACE", namespace);
                     const newContext = new ExportContext(outputDir, name + ".cs");
                     newContext.appendLine("// auto generated code - do not edit directly");
                     newContext.appendLine("");
                     newContext.appendLine("#pragma warning disable");
                     newContext.appendLine("");
-                    newContext.appendLine("namespace Needle.Typescript.GeneratedComponents");
+                    newContext.appendLine("namespace " + namespace);
                     newContext.appendLine("{");
                     newContext.indentLevel += 1;
                     // newContext.appendLine("// source: " + path.resolve(sourceFile.fileName));
@@ -291,6 +337,30 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
             return true;
         }
 
+        function tryParseNamespace(node: ts.Node, namespace?: string): string | null | undefined {
+            // console.log("TRAVERSE - " + ts.SyntaxKind[node.kind]);
+            switch (node.kind) {
+                case ts.SyntaxKind.ModuleDeclaration:
+                    for (const ch of node.getChildren()) {
+                        // console.log("-- TRAVERSE - " + ts.SyntaxKind[ch.kind]);
+                        switch (ch.kind) {
+                            case ts.SyntaxKind.Identifier:
+                                const id = ch as ts.Identifier;
+                                if (id.text) {
+                                    if (!namespace) namespace = "";
+                                    namespace = id.text + (namespace ? "." : "") + namespace;
+                                }
+                                break;
+                        }
+                    }
+                    break;
+            }
+            if (node.parent) {
+                return tryParseNamespace(node.parent, namespace);
+            }
+            return namespace;
+        }
+
         function tryResolveTypeRecursive(node: ts.Node | ts.VariableDeclaration): string | undefined {
             if (!node) return undefined;
 

package/src/test.ts

@@ -1,27 +1,42 @@
 
-import { Behaviour } from "needle.tiny.engine/engine-components/Component";
-import { RoomEntity } from "./Room";
+// import { Behaviour } from "needle.tiny.engine/engine-components/Component";
+// import { RoomEntity } from "./Room";
+
+
+namespace Hello.World
+{
+    namespace Deep {
+        export class MyClass extends Behaviour {
+            //@ifdef TEST
+            public myFloat :number;
+        }
+    }
+}
+
+class OtherClass extends Behaviour {
+
+}
 
 //@type (RoomEntity) 
-export class NavigationManager extends RoomEntity {
+// export class NavigationManager extends RoomEntity {
 
-    fl:number = 1;
+//     fl:number = 1;
 
-    nav_forward() {
+//     nav_forward() {
 
-    }
+//     }
 
-    nav_backward() { 
+//     nav_backward() { 
 
-    }
-}
+//     }
+// }
 
-export abstract class NavComponent extends Behaviour {
+// export abstract class NavComponent extends Behaviour {
 
-    abstract next();  
-    abstract prev();
-    abstract isAtEnd():boolean; 
-} 
+//     abstract next();  
+//     abstract prev();
+//     abstract isAtEnd():boolean; 
+// } 
 
 
 // export class PointOfInterest extends Behaviour {