@needle-tools/needle-component-compiler 2.4.0-pre → 3.0.0-alpha

package/dist/impl/csharp-compiler.js

@@ -0,0 +1,306 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSharpWriter = void 0;
+var base_compiler_1 = require("../base-compiler");
+var BaseWriter_1 = require("../BaseWriter");
+var allowDebugLogs = false;
+/** Inline type dictionary: TypeScript type name → fully-qualified C# type name */
+var TYPE_MAP = {
+    // Primitives
+    "number": "float",
+    "boolean": "bool",
+    "string": "string",
+    "any": "object",
+    "object": "UnityEngine.Object",
+    "void": "void",
+    // Unity base types
+    "Behaviour": "UnityEngine.MonoBehaviour",
+    "MonoBehaviour": "UnityEngine.MonoBehaviour",
+    "Component": "UnityEngine.Component",
+    "ScriptableObject": "UnityEngine.ScriptableObject",
+    // GameObjects / Transforms
+    "GameObject": "UnityEngine.GameObject",
+    "Object3D": "UnityEngine.Transform",
+    "Transform": "UnityEngine.Transform",
+    "AssetReference": "UnityEngine.Transform",
+    "THREE.Object3D": "UnityEngine.Transform",
+    // Math types
+    "Vector2": "UnityEngine.Vector2",
+    "Vector3": "UnityEngine.Vector3",
+    "Vector4": "UnityEngine.Vector4",
+    "Quaternion": "UnityEngine.Quaternion",
+    "Color": "UnityEngine.Color",
+    "RGBAColor": "UnityEngine.Color",
+    "THREE.Color": "UnityEngine.Color",
+    "THREE.Vector2": "UnityEngine.Vector2",
+    "THREE.Vector3": "UnityEngine.Vector3",
+    "THREE.Vector4": "UnityEngine.Vector4",
+    "Matrix4": "UnityEngine.Matrix4x4",
+    "Box3": "UnityEngine.Bounds",
+    // Rendering
+    "Renderer": "UnityEngine.Renderer",
+    "Material": "UnityEngine.Material",
+    "Mesh": "UnityEngine.Mesh",
+    "Texture": "UnityEngine.Texture",
+    "Texture2D": "UnityEngine.Texture2D",
+    "RenderTexture": "UnityEngine.RenderTexture",
+    // Audio
+    "AudioClip": "UnityEngine.AudioClip",
+    "AudioSource": "UnityEngine.AudioSource",
+    // Animation
+    "Animator": "UnityEngine.Animator",
+    "Animation": "UnityEngine.Animation",
+    "AnimationClip": "UnityEngine.AnimationClip",
+    // Events
+    "EventList": "UnityEngine.Events.UnityEvent",
+    "UnityEvent": "UnityEngine.Events.UnityEvent",
+    // Physics / Colliders
+    "ICollider": "UnityEngine.Collider",
+    // UI
+    "Text": "UnityEngine.UI.Text",
+    "Image": "UnityEngine.UI.Image",
+    "RawImage": "UnityEngine.UI.RawImage",
+    // Camera / Light
+    "Camera": "UnityEngine.Camera",
+    "Light": "UnityEngine.Light",
+    // Timeline / Playables
+    "SignalAsset": "UnityEngine.Timeline.SignalAsset",
+    "PlayableDirector": "UnityEngine.Playables.PlayableDirector",
+    // Miscellaneous
+    "Rigidbody": "UnityEngine.Rigidbody",
+    "Map": "System.Collections.Generic.Dictionary",
+};
+/** Lifecycle method name mappings: camelCase TS → PascalCase C# */
+var LIFECYCLE_METHODS = {
+    "awake": "Awake",
+    "start": "Start",
+    "onEnable": "OnEnable",
+    "onDisable": "OnDisable",
+    "update": "Update",
+    "lateUpdate": "LateUpdate",
+    "fixedUpdate": "FixedUpdate",
+    "onDestroy": "OnDestroy",
+    "onCollisionEnter": "OnCollisionEnter",
+    "onCollisionExit": "OnCollisionExit",
+    "onCollisionStay": "OnCollisionStay",
+    "onTriggerEnter": "OnTriggerEnter",
+    "onTriggerExit": "OnTriggerExit",
+    "onTriggerStay": "OnTriggerStay",
+    "onApplicationQuit": "OnApplicationQuit",
+    "onBecameVisible": "OnBecameVisible",
+    "onBecameInvisible": "OnBecameInvisible",
+    "onGUI": "OnGUI",
+    "onValidate": "OnValidate",
+    "reset": "Reset",
+};
+/** UnityEditor types that need #if UNITY_EDITOR wrapping */
+var EDITOR_TYPES = new Set([
+    "UnityEditor", "AnimatorController", "EditorApplication",
+    "EditorUtility", "SerializedObject", "SerializedProperty",
+]);
+function isEditorType(typeName) {
+    return EDITOR_TYPES.has(typeName) || typeName.startsWith("UnityEditor.");
+}
+var CSharpWriter = /** @class */ (function (_super) {
+    __extends(CSharpWriter, _super);
+    function CSharpWriter() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CSharpWriter.prototype.resolveCSharpTypeName = function (typescriptTypeName) {
+        var _a, _b;
+        if (!typescriptTypeName)
+            return undefined;
+        // Strip THREE. prefix for lookup fallback
+        var stripped = typescriptTypeName.startsWith("THREE.") ? typescriptTypeName.substring(6) : typescriptTypeName;
+        return (_b = (_a = TYPE_MAP[typescriptTypeName]) !== null && _a !== void 0 ? _a : TYPE_MAP[stripped]) !== null && _b !== void 0 ? _b : typescriptTypeName;
+    };
+    CSharpWriter.prototype.startNewType = function (filePath, typeName, baseTypes, comments) {
+        var _a;
+        if (comments === null || comments === void 0 ? void 0 : comments.includes("@dont-generate-component"))
+            return false;
+        // @type override: first comment matching "@type <T>" overrides base class
+        var resolvedBase = "UnityEngine.MonoBehaviour";
+        var typeOverride = comments === null || comments === void 0 ? void 0 : comments.find(function (c) { return c.startsWith("@type "); });
+        if (typeOverride) {
+            resolvedBase = typeOverride.substring("@type ".length).trim();
+        }
+        else if (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) {
+            var first = baseTypes[0];
+            resolvedBase = (_a = this.resolveCSharpTypeName(first)) !== null && _a !== void 0 ? _a : "UnityEngine.MonoBehaviour";
+        }
+        // Abstract modifier
+        var isAbstract = comments === null || comments === void 0 ? void 0 : comments.includes("@abstract");
+        var modifiers = isAbstract ? "abstract partial" : "partial";
+        this.writer.writeLine("// NEEDLE_CODEGEN_START");
+        this.writer.writeLine("// auto generated code - do not edit directly");
+        this.writer.writeLine("");
+        this.writer.writeLine("#pragma warning disable");
+        this.writer.writeLine("");
+        this.writer.beginBlock("namespace Needle.Typescript.GeneratedComponents\n{");
+        this.writer.beginBlock("public ".concat(modifiers, " class ").concat(typeName, " : ").concat(resolvedBase, "\n{"));
+    };
+    CSharpWriter.prototype.endNewType = function (filePath, typeName) {
+        this.writer.endBlock("}");
+        this.writer.endBlock("}");
+        this.writer.writeLine("");
+        this.writer.writeLine("// NEEDLE_CODEGEN_END");
+        this.writeCSharpScheme(filePath, typeName);
+    };
+    CSharpWriter.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
+        var _a;
+        if (allowDebugLogs)
+            console.log("[CSharp] writeMember", name, type, comments);
+        // @nonSerialized → skip entirely
+        if (comments === null || comments === void 0 ? void 0 : comments.some(function (c) { return c.startsWith("@nonSerialized"); }))
+            return;
+        // @type override
+        var typeOverride = comments === null || comments === void 0 ? void 0 : comments.find(function (c) { return c.startsWith("@type "); });
+        var csharpType = typeOverride
+            ? typeOverride.substring("@type ".length).trim()
+            : ((_a = this.resolveCSharpTypeName(type)) !== null && _a !== void 0 ? _a : type);
+        // Determine visibility string
+        var vis = "public";
+        if (visibility === base_compiler_1.Visibility.Private || visibility === base_compiler_1.Visibility.Protected) {
+            vis = visibility === base_compiler_1.Visibility.Protected ? "protected" : "private";
+        }
+        // @serializeField → add attribute + force private becomes serialized
+        var serializeField = comments === null || comments === void 0 ? void 0 : comments.some(function (c) { return c.startsWith("@serializeField") || c.startsWith("@serializable"); });
+        // @tooltip
+        var tooltipComment = comments === null || comments === void 0 ? void 0 : comments.find(function (c) { return c.startsWith("@tooltip "); });
+        var tooltip = tooltipComment ? tooltipComment.substring("@tooltip ".length).trim().replace(/^["']|["']$/g, "") : null;
+        // @contextmenu
+        var contextMenuComment = comments === null || comments === void 0 ? void 0 : comments.find(function (c) { return c.startsWith("@contextmenu "); });
+        var contextMenu = contextMenuComment ? contextMenuComment.substring("@contextmenu ".length).trim() : null;
+        // @ifdef
+        var ifdefComment = comments === null || comments === void 0 ? void 0 : comments.find(function (c) { return c.startsWith("@ifdef "); });
+        var ifdef = ifdefComment ? ifdefComment.substring("@ifdef ".length).trim() : null;
+        // Skip private/protected fields unless @serializeField
+        if (visibility !== base_compiler_1.Visibility.Public && !serializeField)
+            return;
+        // Resolve assignment
+        var assignment = "";
+        if (initialValue !== undefined && initialValue !== null) {
+            if (initialValue === "null") {
+                // keep null for reference types, skip for value types
+            }
+            else if (csharpType === "float") {
+                assignment = " = ".concat(initialValue, "f");
+            }
+            else if (csharpType === "bool") {
+                assignment = " = ".concat(initialValue.toLowerCase());
+            }
+            else if (csharpType === "string") {
+                assignment = " = \"".concat(initialValue, "\"");
+            }
+            else if (initialValue.startsWith("new ")) {
+                // constructor expression already prefixed with new
+                var resolved = this.resolveNewExpression(initialValue);
+                assignment = " = ".concat(resolved);
+            }
+            else {
+                assignment = " = ".concat(initialValue);
+            }
+        }
+        // Array suffix
+        if (isArray)
+            csharpType += "[]";
+        // Editor type wrapping
+        var needsEditorWrap = isEditorType(csharpType.split("[")[0].split("<")[0]);
+        if (ifdef)
+            this.writer.writeLine("#ifdef ".concat(ifdef));
+        if (needsEditorWrap)
+            this.writer.writeLine("#if UNITY_EDITOR");
+        // Emit attributes
+        if (tooltip)
+            this.writer.writeLine("[UnityEngine.Tooltip(\"".concat(tooltip, "\")]"));
+        if (contextMenu)
+            this.writer.writeLine("[UnityEngine.ContextMenu(\"".concat(contextMenu, "\")]"));
+        if (serializeField && visibility !== base_compiler_1.Visibility.Public) {
+            this.writer.writeLine("[UnityEngine.SerializeField]");
+        }
+        // Emit field
+        var varName = "@".concat(name);
+        this.writer.writeLine("".concat(vis, " ").concat(csharpType, " ").concat(varName).concat(assignment, ";"));
+        if (needsEditorWrap)
+            this.writer.writeLine("#endif");
+        if (ifdef)
+            this.writer.writeLine("#endif");
+    };
+    CSharpWriter.prototype.writeMethod = function (visibility, name, returnType, args, comments) {
+        var _this = this;
+        var _a, _b;
+        if (allowDebugLogs)
+            console.log("[CSharp] writeMethod", name, returnType);
+        // @contextmenu on method → add attribute
+        var contextMenuComment = comments === null || comments === void 0 ? void 0 : comments.find(function (c) { return c.startsWith("@contextmenu "); });
+        var contextMenu = contextMenuComment ? contextMenuComment.substring("@contextmenu ".length).trim() : null;
+        // Only emit public methods and lifecycle methods (which are always public)
+        var lifecycleName = LIFECYCLE_METHODS[name];
+        if (visibility !== base_compiler_1.Visibility.Public && !lifecycleName)
+            return;
+        // Lifecycle methods get PascalCase; regular public methods keep their name as-is
+        var methodName = lifecycleName !== null && lifecycleName !== void 0 ? lifecycleName : name;
+        // Build parameter list — inline object types (e.g. { x: number }) resolve to "object"
+        var paramList = (_a = args === null || args === void 0 ? void 0 : args.map(function (arg) {
+            var _a, _b;
+            var csharpType;
+            if (!arg.type || arg.type.includes("{")) {
+                csharpType = "object";
+            }
+            else {
+                csharpType = (_b = (_a = _this.resolveCSharpTypeName(arg.type)) !== null && _a !== void 0 ? _a : arg.type) !== null && _b !== void 0 ? _b : "object";
+            }
+            return "".concat(csharpType, " @").concat(arg.name);
+        }).join(", ")) !== null && _a !== void 0 ? _a : "";
+        var csReturnType = returnType
+            ? ((_b = this.resolveCSharpTypeName(returnType)) !== null && _b !== void 0 ? _b : returnType)
+            : "void";
+        if (contextMenu)
+            this.writer.writeLine("[UnityEngine.ContextMenu(\"".concat(contextMenu, "\")]"));
+        this.writer.writeLine("public void ".concat(methodName, "(").concat(paramList, ") {}"));
+    };
+    CSharpWriter.prototype.writeNewTypeExpression = function (typeName, args) {
+        // no-op for C# output
+    };
+    // ── Helpers ────────────────────────────────────────────────────────────
+    /** Converts camelCase to PascalCase for method names */
+    CSharpWriter.prototype.toPascalCase = function (name) {
+        return name.charAt(0).toUpperCase() + name.slice(1);
+    };
+    /** Resolve a "new Type(args)" expression: map TS types to C# qualified types */
+    CSharpWriter.prototype.resolveNewExpression = function (expr) {
+        var _a;
+        // expr is already resolved: "new UnityEngine.Vector2(1, 0.5)" → "new UnityEngine.Vector2(1f, 0.5f)"
+        var match = expr.match(/^new\s+([\w.]+)\s*\((.*)\)$/s);
+        if (!match)
+            return expr;
+        var typeName = match[1], argsStr = match[2];
+        var csharpType = (_a = this.resolveCSharpTypeName(typeName)) !== null && _a !== void 0 ? _a : typeName;
+        // Convert numeric literals to float
+        var csharpArgs = argsStr.replace(/(\d+\.?\d*)/g, function (n) {
+            return n.includes(".") ? "".concat(n, "f") : "".concat(n, "f");
+        });
+        return "new ".concat(csharpType, "(").concat(csharpArgs, ")");
+    };
+    /** Override writeScheme to use .cs extension instead of .component.json */
+    CSharpWriter.prototype.writeCSharpScheme = function (processingFilePath, component) {
+        var res = this.sink.flush(component + ".cs", this.writer.flush());
+    };
+    return CSharpWriter;
+}(BaseWriter_1.BaseWriter));
+exports.CSharpWriter = CSharpWriter;

package/dist/impl/react-three-fiber-compiler.d.ts

@@ -0,0 +1,20 @@
+import { IWriter, Visibility } from "../base-compiler";
+import { TypeSourceInformation } from "../register-types";
+export declare class ReactThreeFiberCompiler implements IWriter {
+    get outputInfo(): TypeSourceInformation;
+    private readonly _typeSourceInformation;
+    constructor();
+    resolveCSharpTypeName(typescriptTypeName: string): string | void;
+    begin(filePath: string): void;
+    end(filePath: string): void;
+    startNewType(filePath: string, typeName: string, baseType: string[], comments?: string[]): boolean | void;
+    endNewType(filePath: string, typeName: string): void;
+    writeMember(visibility: Visibility, name: string, isArray: boolean, type: string, initialValue?: string, comments?: string[]): void;
+    writeMethod(visibility: Visibility, name: string, returnType: string, args: {
+        name: string;
+        type: string;
+        defaultValue?: string;
+    }[], comments: string[]): void;
+    writeNewTypeExpression(typeName: string, args?: string[]): void;
+    registerEnum(name: string, members: import("../base-compiler").EnumMember[]): void;
+}

package/{src → dist/impl}/react-three-fiber-compiler.js

@@ -12,7 +12,7 @@ var ReactThreeFiberCompiler = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    ReactThreeFiberCompiler.prototype.resolveTypeName = function (typescriptTypeName) {
+    ReactThreeFiberCompiler.prototype.resolveCSharpTypeName = function (typescriptTypeName) {
         return typescriptTypeName;
     };
     ReactThreeFiberCompiler.prototype.begin = function (filePath) {
@@ -29,6 +29,8 @@ var ReactThreeFiberCompiler = /** @class */ (function () {
     };
     ReactThreeFiberCompiler.prototype.writeNewTypeExpression = function (typeName, args) {
     };
+    ReactThreeFiberCompiler.prototype.registerEnum = function (name, members) {
+    };
     return ReactThreeFiberCompiler;
 }());
 exports.ReactThreeFiberCompiler = ReactThreeFiberCompiler;

package/dist/register-types.d.ts

@@ -0,0 +1,8 @@
+/**@key is the typescript source file */
+export declare type TypeSourceInformation = {
+    [key: string]: {
+        componentName: string;
+        filePath: string;
+    }[];
+};
+export declare function writeTypeRegistry(types: TypeSourceInformation, registerTypesPath: string): void;

package/dist/watcher.d.ts

@@ -0,0 +1,6 @@
+import { IWriter } from "./base-compiler";
+export declare class DirectoryWatcher {
+    private readonly compiler;
+    private _typesChanged;
+    startWatching(dir: string, writer: IWriter, registerTypesPath: string): void;
+}

package/{src → dist}/watcher.js

@@ -3,14 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DirectoryWatcher = void 0;
 var fs = require("fs");
 var base_compiler_1 = require("./base-compiler");
-var blender_compiler_1 = require("./blender-compiler");
+var Compiler_1 = require("./Compiler");
+var blender_compiler_1 = require("./impl/blender-compiler");
 var chokidar = require("chokidar");
 var commands_1 = require("./commands");
 var register_types_1 = require("./register-types");
 // https://github.com/paulmillr/chokidar
 var DirectoryWatcher = /** @class */ (function () {
     function DirectoryWatcher() {
-        this.compiler = new base_compiler_1.Compiler();
+        this.compiler = new Compiler_1.Compiler();
         this._typesChanged = false;
     }
     DirectoryWatcher.prototype.startWatching = function (dir, writer, registerTypesPath) {

package/package.json

@@ -1,17 +1,23 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "2.4.0-pre",
-    "description": "Compile mock unity components from typescript",
-    "main": "index.js",
+    "version": "3.0.0-alpha",
+    "description": "Compile Editor components for Needle Engine for C# and Blender",
+    "main": "dist/index.js",
     "scripts": {
         "tsc": "tsc",
-        "dev": "npm-watch compile || exit 1",
+        "dev": "npm-watch compile",
         "compile": "tsc",
-        "test" : "npm run test:csharp & npm run test:blender",
-        "test:csharp": "mocha -r ts-node/register test/csharp/**.test.ts",
-        "test:blender": "mocha -r ts-node/register test/blender/**.test.ts",
+        "test": "npm run test:csharp && npm run test:blender",
+        "test:csharp": "mocha -r ts-node/register 'test/csharp/**/*.test.ts'",
+        "test:blender": "mocha -r ts-node/register 'test/blender/**/*.test.ts'",
         "test:single": "mocha"
     },
+    "files": [
+        "Readme.md",
+        "Changelog.md",
+        "package.json",
+        "dist/**/*"
+    ],
     "dependencies": {
         "chokidar": "^3.5.3",
         "typescript": "^4.5.5"

package/src/blender-compiler.js

@@ -1,180 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlenderWriter = void 0;
-var fs_1 = require("fs");
-var base_compiler_1 = require("./base-compiler");
-var commands_1 = require("./commands");
-var supportedTypes = ["string", "float", "int", "bool", "col", "obj", "evt", "fn", "vec2", "vec3", "comp"];
-var knownBaseTypes = ["Behaviour", "IComponent"];
-var BlenderWriter = /** @class */ (function () {
-    function BlenderWriter(_sink) {
-        this._sink = _sink;
-        this.writer = new base_compiler_1.CodeTextWriter();
-        this._createdSchemesPerFile = {};
-        this._currentlyProcessingFiles = {};
-    }
-    Object.defineProperty(BlenderWriter.prototype, "outputInfo", {
-        get: function () {
-            return this._createdSchemesPerFile;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(BlenderWriter.prototype, "sink", {
-        get: function () {
-            return this._sink;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    BlenderWriter.prototype.resolveTypeName = function (typeName, comments) {
-        typeName = typeName.toLocaleLowerCase();
-        if (typeName.startsWith("three."))
-            typeName = typeName.substring("three.".length);
-        switch (typeName) {
-            case "number":
-                return "float";
-            case "int":
-                return "int";
-            case "boolean":
-                return "bool";
-            case "string":
-                return "string";
-            case "void":
-                return "void";
-            case "vector2":
-                return "vec2";
-            case "vector3":
-                return "vec3";
-            case "vector4":
-                return "vec4";
-            case "quaternion":
-                return "quat";
-            case "euler":
-                return "vec3";
-            case "color":
-                return "col";
-            case "eventlist":
-                return "evt";
-            case "behaviour":
-                return "comp";
-        }
-        return typeName;
-    };
-    BlenderWriter.prototype.begin = function (filePath) {
-        if (!this._currentlyProcessingFiles[filePath]) {
-            this._currentlyProcessingFiles[filePath] = [];
-        }
-    };
-    BlenderWriter.prototype.end = function (filePath) {
-        var results = this._currentlyProcessingFiles[filePath];
-        console.log("Writing schemes for", filePath, results);
-        if (results) {
-            var previousResultsFromThisFile = this._createdSchemesPerFile[filePath];
-            if (previousResultsFromThisFile) {
-                for (var _i = 0, previousResultsFromThisFile_1 = previousResultsFromThisFile; _i < previousResultsFromThisFile_1.length; _i++) {
-                    var previouslyCreated = previousResultsFromThisFile_1[_i];
-                    var foundInAny = false;
-                    for (var _a = 0, results_1 = results; _a < results_1.length; _a++) {
-                        var res = results_1[_a];
-                        if (res.filePath === previouslyCreated.filePath) {
-                            foundInAny = true;
-                            break;
-                        }
-                    }
-                    if (!foundInAny) {
-                        for (var sourcePath in this._createdSchemesPerFile) {
-                            if (foundInAny)
-                                break;
-                            if (sourcePath === filePath)
-                                continue;
-                            var otherSourceSchemes = this._createdSchemesPerFile[sourcePath];
-                            if (otherSourceSchemes.includes(previouslyCreated)) {
-                                // the file was moved to another source file
-                                foundInAny = true;
-                            }
-                        }
-                    }
-                    if (!foundInAny && (0, fs_1.existsSync)(previouslyCreated.filePath)) {
-                        (0, fs_1.unlinkSync)(previouslyCreated.filePath);
-                        (0, commands_1.sendFileDeletedCommand)(previouslyCreated.filePath);
-                    }
-                }
-            }
-            this._createdSchemesPerFile[filePath] = results;
-        }
-        delete this._currentlyProcessingFiles[filePath];
-    };
-    BlenderWriter.prototype.startNewType = function (filePath, typeName, baseTypes, comments) {
-        var isSupportedType = false;
-        for (var i = 0; i < knownBaseTypes.length; i++) {
-            if (baseTypes.includes(knownBaseTypes[i])) {
-                isSupportedType = true;
-                break;
-            }
-        }
-        // console.log(baseTypes, knownBaseTypes, isSupportedType)
-        if (!isSupportedType)
-            return false;
-        this.writer.beginBlock("{");
-        if (comments)
-            console.log(comments);
-        this.writer.beginBlock("\"" + typeName + "\": {");
-    };
-    BlenderWriter.prototype.endNewType = function (filePath, typeName) {
-        this.writer.endBlock("},");
-        this.writer.endBlock("}");
-        this.writeScheme(filePath, typeName);
-    };
-    BlenderWriter.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
-        if (visibility !== base_compiler_1.Visibility.Public)
-            return;
-        // if (!supportedTypes.includes(type)) {
-        //     console.log("-- unsupported type:", type);
-        //     return;
-        // }
-        this.writer.beginBlock("\"" + name + "\": {");
-        this.writer.writeLine("\"type\": \"" + type + "\",");
-        if (initialValue && !isArray) {
-            if (initialValue.startsWith("new "))
-                initialValue = undefined;
-            switch (type) {
-                case "bool":
-                    initialValue = initialValue.toLowerCase();
-                    break;
-                case "string":
-                    initialValue = "\"" + initialValue + "\"";
-            }
-            if (initialValue)
-                this.writer.writeLine("\"value\": " + initialValue);
-        }
-        if (isArray) {
-            this.writer.writeLine("\"value\": []");
-        }
-        this.writer.endBlock("},");
-    };
-    BlenderWriter.prototype.writeMethod = function (visibility, name, returnType, args, comments) {
-        if (visibility !== base_compiler_1.Visibility.Public)
-            return;
-        this.writer.beginBlock("\"" + name + "\": {");
-        this.writer.writeLine("\"type\": \"fn\",");
-        this.writer.endBlock("},");
-    };
-    BlenderWriter.prototype.writeNewTypeExpression = function (typeName, args) {
-        console.log("new type:", typeName);
-    };
-    BlenderWriter.prototype.writeScheme = function (processingFilePath, component) {
-        var res = this.sink.flush(component + ".component.json", this.writer.flush());
-        // if an output path is returned it means a file has been written to that path
-        if (res && (0, fs_1.existsSync)(res)) {
-            (0, commands_1.sendFileWrittenCommand)(res);
-            // add the scheme to the list of created schemes
-            if (processingFilePath && this._currentlyProcessingFiles[processingFilePath]) {
-                this._currentlyProcessingFiles[processingFilePath].push({ componentName: component, filePath: res });
-            }
-        }
-    };
-    return BlenderWriter;
-}());
-exports.BlenderWriter = BlenderWriter;
-// runFromFile(new BlenderWriter("dist"), "src\\test.ts");

package/src/csharp-compiler.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CSharpWriter = void 0;
-var fs_1 = require("fs");
-var path = require("path");
-var allowDebugLogs = false;
-var CSharpWriter = /** @class */ (function () {
-    function CSharpWriter(_outputDir) {
-        this._outputDir = _outputDir;
-    }
-    Object.defineProperty(CSharpWriter.prototype, "outputInfo", {
-        get: function () {
-            return this._outputInfo;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    CSharpWriter.prototype.resolveTypeName = function (typescriptTypeName) {
-        if (this._typesFileContent === undefined) {
-            this._typesFileContent = null;
-            var filePath = path.dirname(__dirname) + "/src/types.json";
-            if ((0, fs_1.existsSync)(filePath)) {
-                if (allowDebugLogs)
-                    console.log("Reading types file");
-                var content = (0, fs_1.readFileSync)(filePath, "utf8");
-                this._typesFileContent = JSON.parse(content);
-            }
-        }
-        if (this._typesFileContent) {
-            var fullType = this._typesFileContent[typescriptTypeName];
-            if (fullType && allowDebugLogs)
-                console.log(fullType);
-            return fullType;
-        }
-        return null;
-    };
-    CSharpWriter.prototype.begin = function (filePath) {
-    };
-    CSharpWriter.prototype.end = function (filePath) {
-    };
-    CSharpWriter.prototype.startNewType = function (filePath, typeName, baseType, comments) {
-        throw new Error("Method not implemented.");
-    };
-    CSharpWriter.prototype.endNewType = function (filePath, typeName) {
-        throw new Error("Method not implemented.");
-    };
-    CSharpWriter.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
-        throw new Error("Method not implemented.");
-    };
-    CSharpWriter.prototype.writeMethod = function (visibility, name, returnType, args, comments) {
-        throw new Error("Method not implemented.");
-    };
-    CSharpWriter.prototype.writeNewTypeExpression = function (typeName, args) {
-        throw new Error("Method not implemented.");
-    };
-    return CSharpWriter;
-}());
-exports.CSharpWriter = CSharpWriter;