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

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
@@ -12,6 +11,7 @@ const exportNextClassCommand = "@generate-component";
 const dontExportNextClassCommand = "@dont-generate-component";
 // add above field to add [SerializeField] attribute
 const serializeCommand = "@serializeField";
+const dontSerializeCommand = "@nonSerialized";
 // https://regex101.com/r/ltpcKT/2
 const typePattern = new RegExp("@type ?(?<type>.+)");
 const ifdefPattern = new RegExp("@ifdef ?(?<ifdef>.+)")
@@ -19,23 +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);
         }
@@ -43,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;
     }
@@ -52,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();
@@ -88,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() {
@@ -104,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;
@@ -119,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], {});
 
-export function run(program: ts.Program, outputDir: string, sourceFile: ts.SourceFile) {
+    // delint it
+    return run(prog, outputDir, 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) {
 
@@ -138,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;
 
@@ -147,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(),
@@ -171,6 +218,8 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                     }
                     else if (comment.includes(serializeCommand))
                         serializeField = true;
+                    else if (comment.includes(dontSerializeCommand))
+                        dontSerialize = true;
                 }
                 if (comment.includes(exportNextClassCommand))
                     exportNextClass = true;
@@ -182,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;
                 }
 
@@ -195,6 +245,7 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
             }
         }
 
+        const skip = dontSerialize;
         switch (node.kind) {
             // Namespace
             // case ts.SyntaxKind.ModuleDeclaration:
@@ -214,12 +265,16 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
             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
                 const meth = node as ts.MethodDeclaration;
                 // const isCoroutine = func.asteriskToken;
-                if (meth.name) {
+                if (!skip && meth.name) {
+                    const pub = isPublic(meth);
+                    if(!pub) return;
+
                     let paramsStr = "";
                     for (let param of meth.parameters) {
                         if (!param || !param.name) continue;
@@ -228,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;
@@ -239,29 +299,38 @@ 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();
                 const pub = isPublic(vardec);
                 const visibility = pub ? "public" : "private";
                 let 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;
                 }
 
                 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 = "";
                 let typeName = vardec.type?.getText();
+                let shouldCommentTheLine = typeString === undefined;
                 if (typeString === undefined) {
                     postFix = " → Could not resolve C# type";
                 }
@@ -306,12 +375,15 @@ 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")
-                    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);
-                const prefix = typeString === undefined ? "// " : "";
+                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;
                 if (requireEndIf) {
@@ -327,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("");
@@ -342,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;
                             }
                         }
@@ -362,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;
@@ -419,7 +496,8 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
                     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;
         }
 
@@ -427,7 +505,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;
             }
 
@@ -468,7 +546,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;
             }
 
@@ -529,7 +608,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;
@@ -588,7 +668,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 + ">";
@@ -618,24 +699,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.ts

@@ -1,5 +1,29 @@
 import { ThisExpression } from "typescript";
 
+export class MyTestComponent extends Behaviour {
+    private myMethod(){
+        
+    }
+}
+
+
+// export class SkipFieldAndMethod extends Behaviour {
+    
+//     //@nonSerialized
+//     myMethod() {
+
+//     }
+
+//     // @nonSerialized
+//     myField : string;
+
+// }
+
+
+// export class ComponentWithUnknownType extends Behaviour {
+//     views: SomeUnknownType;
+// }
+
 
 // export class ComponentWithAnimationClip extends Behaviour implements IPointerClickHandler {
 
@@ -7,9 +31,9 @@ import { ThisExpression } from "typescript";
 //     animation?: THREE.AnimationClip;
 // }
 
-export abstract class MyAbstractComponent extends Behaviour {
-    abstract myMethod();
-}
+// export abstract class MyAbstractComponent extends Behaviour {
+//     abstract myMethod();
+// }
 
 
 // export class CameraView extends Behaviour {

package/test/codegen/abstract method/expected.cs

@@ -0,0 +1,14 @@
+// NEEDLE_CODEGEN_START
+    // auto generated code - do not edit directly
+    
+    #pragma warning disable
+    
+    namespace Needle.Typescript.GeneratedComponents
+    {
+    	public partial class MyComponent : UnityEngine.MonoBehaviour
+	{
+    public void OnDisable(){}
+	}
+    }
+    
+    // NEEDLE_CODEGEN_END

package/test/codegen/abstract method/input.js

@@ -0,0 +1,27 @@
+"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.MyComponent = void 0;
+var MyComponent = /** @class */ (function (_super) {
+    __extends(MyComponent, _super);
+    function MyComponent() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MyComponent.prototype.onDisable = function () { };
+    return MyComponent;
+}(Behaviour));
+exports.MyComponent = MyComponent;

package/test/codegen/abstract method/input.ts

@@ -0,0 +1,4 @@
+export class MyComponent extends Behaviour {
+      onDisable() {}
+    }
+}

package/test/codegen/abstract method/output.cs

@@ -0,0 +1,14 @@
+// NEEDLE_CODEGEN_START
+// auto generated code - do not edit directly
+
+#pragma warning disable
+
+namespace Needle.Typescript.GeneratedComponents
+{
+	public partial class MyComponent : UnityEngine.MonoBehaviour
+	{
+		public void OnDisable(){}
+	}
+}
+
+// NEEDLE_CODEGEN_END

package/test/codegen/basic/expected.cs

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

package/test/codegen/basic/input.js

@@ -0,0 +1,26 @@
+"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.BasicComponet = void 0;
+var BasicComponet = /** @class */ (function (_super) {
+    __extends(BasicComponet, _super);
+    function BasicComponet() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return BasicComponet;
+}(Behaviour));
+exports.BasicComponet = BasicComponet;

package/test/codegen/basic/input.ts

@@ -0,0 +1,2 @@
+export class BasicComponet extends Behaviour {
+}

package/test/codegen/basic/output.cs

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

package/test/codegen/basic-no-export/input.js

@@ -0,0 +1,27 @@
+"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.BasicComponet = void 0;
+//@dont-generate-component
+var BasicComponet = /** @class */ (function (_super) {
+    __extends(BasicComponet, _super);
+    function BasicComponet() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return BasicComponet;
+}(Behaviour));
+exports.BasicComponet = BasicComponet;

package/test/codegen/basic-no-export/input.ts

@@ -0,0 +1,4 @@
+
+      //@dont-generate-component
+      export abstract class BasicComponet extends Behaviour {
+}