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

package/src/component-compiler.ts

@@ -4,7 +4,6 @@ import * as fs from "fs";
 import * as path from 'path';
 
 import * as types from "./types";
-import { type } from "os";
 const dict = types.dict;
 
 // add either of these two comments above a class to enforce code gen or disable it for the next class
@@ -20,24 +19,46 @@ const ifdefPattern = new RegExp("@ifdef ?(?<ifdef>.+)")
 const CODEGEN_MARKER_START = "// NEEDLE_CODEGEN_START";
 const CODEGEN_MARKER_END = "// NEEDLE_CODEGEN_END";
 
+let allowDebugLogs = true;
+
 // will be set to true when e.g. a comment for export is found
 let exportNextClass: boolean = false;
 let dontExportNextClass: boolean = false;
 let serializeField: boolean = false;
 let dontSerialize: boolean = false;
+let typesFileContent: object | undefined | null = undefined;
+
+// const exportDir = "../dist";
+const commentStarts: Array<number> = [];
+const contexts: ExportContext[] = [];
+let lastTypeFound: string | null = null;
+let ifdefSections: string[] = [];
+
+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;
 }
 
-
-let typesFileContent: object | undefined | null = undefined;
 function tryGetKnownType(str: string): string | null {
     if (typesFileContent === undefined) {
         typesFileContent = null;
         const filePath = path.dirname(__dirname) + "/src/types.json";
         if (fs.existsSync(filePath)) {
-            console.log("Reading types file");
+            if (allowDebugLogs)
+                console.log("Reading types file");
             const content = fs.readFileSync(filePath, "utf8");
             typesFileContent = JSON.parse(content);
         }
@@ -45,7 +66,7 @@ function tryGetKnownType(str: string): string | null {
 
     if (typesFileContent) {
         const fullType = typesFileContent[str];
-        if (fullType)
+        if (fullType && allowDebugLogs)
             console.log(fullType);
         return fullType;
     }
@@ -54,17 +75,15 @@ function tryGetKnownType(str: string): string | null {
 
 // https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API
 
-// const exportDir = "../dist";
-const commentStarts: Array<number> = [];
 
 class ExportContext {
-    outputDir: string;
+    outputDir: string | null;
     fileName: string;
     textBuffer: string;
     classEnd: number = -1;
     indentLevel: number = 0;
 
-    constructor(outputDir: string, fileName: string) {
+    constructor(outputDir: string | null, fileName: string) {
         this.outputDir = outputDir;
         this.fileName = fileName;
         this.reset();
@@ -90,14 +109,20 @@ class ExportContext {
         this.append(text + "\n");
     }
 
-    flush() {
+    flush(): string {
         if (this.textBuffer.length <= 0) return;
-        const dir = this.outputDir + "/";
-        const 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;
+        const code = this.textBuffer;
+        if (this.outputDir !== null) {
+            const dir = this.outputDir + "/";
+            const path = dir + this.fileName;
+            this.replaceGeneratedCodeSection(path);
+            if (allowDebugLogs)
+                console.log("Write to " + path);
+            fs.writeFileSync(path, code);
+        }
         this.reset();
+        return code;
     }
 
     reset() {
@@ -106,13 +131,13 @@ class ExportContext {
     }
 
     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")
+                if (allowDebugLogs)
+                    console.log("Found codegen sections")
                 const before = matches.groups.before;
                 const after = matches.groups.after;
                 this.textBuffer = before + this.textBuffer + after;
@@ -121,18 +146,34 @@ class ExportContext {
     }
 }
 
-const contexts: ExportContext[] = [];
+export function compile(code: string, fileName: string, outputDir: string | null, debugLogs: boolean = true): string[] {
 
-let lastTypeFound: string | null = null;
-let ifdefSections: string[] = [];
+    resetAllState();
+    allowDebugLogs = debugLogs;
+
+    // Parse a file
+    const sourceFile = ts.createSourceFile(
+        fileName,
+        code,
+        ts.ScriptTarget.ES2015,
+        true, /*setParentNodes */
+    );
+
+    const prog = ts.createProgram([fileName], {});
+
+    // delint it
+    return run(prog, outputDir, sourceFile);
+}
 
-export function run(program: ts.Program, outputDir: string, sourceFile: ts.SourceFile) {
+export function run(program: ts.Program, outputDir: string | null, sourceFile: ts.SourceFile): string[] {
 
-    if (!fs.existsSync(outputDir)) {
+    if (outputDir !== null && !fs.existsSync(outputDir)) {
         console.error("Output directory does not exist: \"" + outputDir + "\"");
         return;
     }
 
+    const results: string[] = [];
+
     traverseFile(sourceFile);
     function traverseFile(node: ts.Node) {
 
@@ -140,6 +181,8 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
         ts.forEachChild(node, traverseFile);
     }
 
+    return results;
+
     function visit(node: ts.Node) {
         let context: ExportContext | null = contexts.length > 0 ? contexts[contexts.length - 1] : null;
 
@@ -149,12 +192,14 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                     context.indentLevel -= 1;
                     context.append("}\n");
                 }
-                context.flush();
+                const 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]);
 
         const commentRanges = ts.getLeadingCommentRanges(
             sourceFile.getFullText(),
@@ -186,7 +231,8 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                     // so we remove them
                     let type = typeMatch.groups["type"];
                     type = type.replace(/\(/, "").replace(/\)/, "");
-                    console.log("Found type: ", type);
+                    if (allowDebugLogs)
+                        console.log("Found type: ", type);
                     lastTypeFound = type;
                 }
 
@@ -226,6 +272,9 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                 const meth = node as ts.MethodDeclaration;
                 // const isCoroutine = func.asteriskToken;
                 if (!skip && meth.name) {
+                    const pub = isPublic(meth);
+                    if (!pub) return;
+
                     let paramsStr = "";
                     for (let param of meth.parameters) {
                         if (!param || !param.name) continue;
@@ -234,8 +283,13 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                         if (type === undefined) type = "object";
                         paramsStr += type + " @" + param.name.getText();
                     }
-                    const methodName = meth.name.getText();
+                    let 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;
@@ -245,7 +299,8 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
             case ts.SyntaxKind.PropertyDeclaration:
                 resetExportNextClass();
                 if (!context) break;
-                console.log("Found variable", node.getText());
+                if (allowDebugLogs)
+                    console.log("Found variable", node.getText());
                 const vardec = node as ts.VariableDeclaration;
 
                 const varName = "@" + vardec.name.getText();
@@ -254,20 +309,23 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                 let isAccessible = pub;
                 dontSerialize = false;
                 if (serializeField) {
-                    console.log("[SerializeField]");
+                    if (allowDebugLogs)
+                        console.log("[SerializeField]");
                     context.appendLine("[UnityEngine.SerializeField]");
                     isAccessible = true;
                 }
-                else if(skip) 
+                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;
                 }
 
                 const name = vardec.name.getText();
-                console.log("Variable:", name);
+                if (allowDebugLogs)
+                    console.log("Variable:", name);
                 if (name.startsWith("\"@") || name.startsWith("\"$") || name.startsWith("$")) break;
                 let typeString = lastTypeFound ?? tryResolveTypeRecursive(node);
                 let postFix = "";
@@ -317,12 +375,14 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                 }
                 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);
                 const prefix = shouldCommentTheLine ? "// " : "";
                 context.append(prefix + visibility + " " + typeString + " " + varName + assignment + ";" + postFix + "\n");
                 lastTypeFound = null;
@@ -339,9 +399,11 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                 if (!dontExportNextClass && (lastTypeFound || exportNextClass || inheritsComponent)) {
                     resetExportNextClass();
                     const name = dec.name?.escapedText;
-                    console.log("Found class: ", name);
+                    if (allowDebugLogs)
+                        console.log("Found class: ", name);
                     const namespace = tryParseNamespace(node) ?? "Needle.Typescript.GeneratedComponents";
-                    console.log("NAMESPACE", namespace);
+                    if (allowDebugLogs)
+                        console.log("NAMESPACE", namespace);
                     const newContext = new ExportContext(outputDir, name + ".cs");
                     newContext.appendLine("// auto generated code - do not edit directly");
                     newContext.appendLine("");
@@ -354,14 +416,16 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                     let typeName = "UnityEngine.MonoBehaviour";
                     if (typeof inheritsComponent === "string") typeName = inheritsComponent;
                     if (lastTypeFound) typeName = lastTypeFound;
-                    console.log(name + " inherits " + typeName);
+                    if (allowDebugLogs)
+                        console.log(name + " inherits " + typeName);
                     let modifiers = "";
                     if (dec.modifiers) {
                         for (const mod of dec.modifiers) {
                             switch (mod.getText()) {
                                 case "abstract":
                                     modifiers += " abstract";
-                                    console.log(name + " is abstract");
+                                    if (allowDebugLogs)
+                                        console.log(name + " is abstract");
                                     break;
                             }
                         }
@@ -374,7 +438,8 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                     contexts.push(newContext);
                 }
                 else {
-                    console.log("Class type is unknown and will not generate a component: ", dec.name?.escapedText);
+                    if (allowDebugLogs)
+                        console.log("Class type is unknown and will not generate a component: ", dec.name?.escapedText);
                 }
                 lastTypeFound = null;
                 break;
@@ -420,18 +485,32 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                                 type = tryGetTypeFromText(text);
                                 break;
                             case ts.SyntaxKind.SyntaxList:
-                                args = text;
+                                for (const arg of ch.getChildren()) {
+                                    if (args === undefined) args = "";
+                                    const 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)
+                    if (type) {
+                        console.log(type, args)
                         return "new " + type + "(" + args + ")";
+                    }
                     // const expType = node.getChildren().find(c => c.kind === ts.SyntaxKind.Identifier);
                     break;
             }
             const 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;
         }
 
@@ -439,7 +518,7 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
             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;
             }
 
@@ -480,7 +559,8 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
             const separatorIndex = typeName.lastIndexOf(".");
             if (separatorIndex > 0) {
                 let 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;
             }
 
@@ -541,7 +621,8 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                 case ts.SyntaxKind.TypeReference:
                     const typeRef = node as ts.TypeReferenceNode;
                     const typeName = typeRef.typeName.getText();
-                    console.log("TypeReference:", typeName);
+                    if (allowDebugLogs)
+                        console.log("TypeReference:", typeName);
                     switch (typeName) {
                         case "Array":
                             break;
@@ -600,7 +681,8 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                 const childResult = tryResolveTypeRecursive(child);
                 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 + ">";
@@ -630,24 +712,23 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
     }
 }
 
-if (process.argv.length < 4) {
-    console.error("Missing args, call with: <output_dir> <input_files>");
-}
-else {
-    const outputDir = process.argv[2];
-    const fileNames = process.argv.slice(3);
-    fileNames.forEach(fileName => {
-        // Parse a file
-        const sourceFile = ts.createSourceFile(
-            fileName,
-            readFileSync(fileName).toString(),
-            ts.ScriptTarget.ES2015,
-        /*setParentNodes */ true
-        );
-
-        const prog = ts.createProgram([fileName], {});
-
-        // delint it
-        run(prog, outputDir, sourceFile);
-    });
+
+if (process) {
+
+    if (process.argv.length < 4) {
+        console.error("Missing args, call with: <output_dir> <input_files>");
+    }
+    else {
+        const outputDir = process.argv[2];
+        const fileNames = process.argv.slice(3);
+        fileNames.forEach(fileName => {
+            if (!fs.existsSync(fileName)) {
+
+            }
+            else {
+                const code = readFileSync(fileName).toString();
+                compile(code, fileName, outputDir);
+            }
+        });
+    }
 }

package/src/test.js

@@ -0,0 +1,194 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.MyTestComponent = void 0;
+var MyTestComponent = /** @class */ (function (_super) {
+    __extends(MyTestComponent, _super);
+    function MyTestComponent() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.myVector2 = new Vector2(1, .5);
+        return _this;
+    }
+    MyTestComponent.prototype.myMethod = function () {
+    };
+    return MyTestComponent;
+}(Behaviour));
+exports.MyTestComponent = MyTestComponent;
+// export class SkipFieldAndMethod extends Behaviour {
+//     //@nonSerialized
+//     myMethod() {
+//     }
+//     // @nonSerialized
+//     myField : string;
+// }
+// export class ComponentWithUnknownType extends Behaviour {
+//     views: SomeUnknownType;
+// }
+// export class ComponentWithAnimationClip extends Behaviour implements IPointerClickHandler {
+//     @serializeable(AnimationClip)
+//     animation?: THREE.AnimationClip;
+// }
+// export abstract class MyAbstractComponent extends Behaviour {
+//     abstract myMethod();
+// }
+// export class CameraView extends Behaviour {
+//     static views: CameraView[] = [];
+// }
+// export class EventComponent extends Behaviour {    
+//     @serializeable(EventList)
+//     roomChanged: EventList = new EventList();
+// }
+// export class SocLoader extends Behaviour {    
+//     @serializeable(AssetReference) 
+//     scenes: Array<AssetReference> = [];
+// }
+// // class Test123 {}
+// export class Bla extends Behaviour
+// {
+//     myNumber:number = 42;
+//     myBool:boolean = true;
+//     myString:string = "test";
+//     numberArr: number[] = [1,2,3];
+//     myColor : THREE.Color = new THREE.Color(255, 0, 0);
+//     renderers = new Array<Renderer>();
+//     renderers2 : Renderer[] = [];
+//     objArr : object[];
+//     colArr: THREE.Color[] = [new THREE.Color(1,2,3)];
+//     map : Map<string> = new Map<string>();
+//     map2 : Map<object> = new Map<object>();
+//     private myThing : Test123;
+// } 
+// //@type UnityEngine.MonoBehaviour
+// export class ButtonObject extends Interactable implements IPointerClickHandler, ISerializable {
+//     //@type UnityEngine.Transform[]
+//     myType?: SceneFXWindow;
+// }
+// import { Behaviour } from "needle.tiny.engine/engine-components/Component";
+// import { RoomEntity } from "./Room";
+// import { Behaviour } from "needle.tiny.engine/engine-components/Component";
+// export class MyNewScript extends DriveClient
+// {
+//     //@type test
+//     texture : RenderTexture;  
+// }    
+// 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 {
+//     fl:number = 1;
+//     nav_forward() {
+//     }
+//     nav_backward() { 
+//     }
+// }
+// export abstract class NavComponent extends Behaviour {
+//     abstract next();  
+//     abstract prev();
+//     abstract isAtEnd():boolean; 
+// } 
+// export class PointOfInterest extends Behaviour {
+//     myVal:number = 12;
+//     // @type(HELLO)
+//     myFunction(){
+//     }
+//     // @type(UnityEngine.Camera)
+//     view?:Camera;
+//     test:string = "123";
+//     // test
+// }
+// export class MaterialColorHandler extends Behaviour {
+//     @serializeable(Renderer)
+//     renderer?: Renderer[];
+// }
+// export class MyArray extends Behaviour {
+//     arr? : Array<number> = [1,2,3];
+// }
+// export class PrivateSerializedField extends Behaviour {
+//     //@serializeField
+//     private color? : THREE.Color; 
+// }
+// export class MyPropertyClass extends Behaviour {
+//     set color(col: THREE.Color) {
+//     }
+// }
+// export class MyClassWithAFloat extends Behaviour {
+//     myfloat:number = .5;
+//     private myString : string;
+// }
+// export class GltfExport extends Behaviour {
+//     binary: boolean = true;
+//     "$serializedTypes" = {
+//         url:null
+//     }
+//     // @contextmenu enable this
+//     test(){
+//     }
+// }
+// export class SetColor  extends Behaviour {
+//     "@serializedTypes" = { 
+//         col: Number,
+//     }
+// }
+// class Behaviour {
+// }
+// export class PlatformerMusic extends Behaviour implements IPlaymodeChangeListener {
+//     source?: AudioSource;
+//     editMode?: string;
+//     playMode?: string;
+//     onPlaymodeChange(playmode: PlayMode): void {
+//         console.log(this);
+//         if(!this.source) return;
+//         const clip = playmode.isInPlayMode ? this.playMode : this.editMode;
+//         console.log("PLAY", clip);
+//         this.source.play(clip);
+//     }
+// }
+// // TODO: export UnityEvent like this
+// // disable codegen
+// class UnityEvent {
+//     methods: Function[] = [];
+//     invoke() {
+//         for (const m of this.methods) {
+//             m();
+//         }
+//     }
+// }
+// export class MyClass extends Behaviour {
+//     myFloat: number = 15;
+//     myBool: boolean;
+//     // just some default values
+//     myArray: number[] = [1, 2, 3];
+//     // comment for myString
+//     myString: string = "this is a string1";
+//     myObject: THREE.Object3D;
+//     myBool2: boolean;
+//     myFunction() { }
+//     myFunctionWithStringParameter(string: string) { }
+//     myFunctionWithSomeObjectAndArray(obj: THREE.Object3D, arr: number[]) { }
+//     myFunctionWithoutParamTypes(test) { }
+//     someOtherStuff: THREE.Object3D[] | null = null;
+//     myEvent: UnityEvent;
+// }

package/src/test.ts

@@ -1,17 +1,24 @@
 import { ThisExpression } from "typescript";
 
+export class MyTestComponent extends Behaviour {
+    public myVector2: Vector2 = new Vector2(1, .5);
+    private myMethod(){
+        
+    }
+}
 
-export class SkipFieldAndMethod extends Behaviour {
+
+// export class SkipFieldAndMethod extends Behaviour {
     
-    //@nonSerialized
-    myMethod() {
+//     //@nonSerialized
+//     myMethod() {
 
-    }
+//     }
 
-    // @nonSerialized
-    myField : string;
+//     // @nonSerialized
+//     myField : string;
 
-}
+// }
 
 
 // export class ComponentWithUnknownType extends Behaviour {