@needle-tools/needle-component-compiler 2.4.0-pre → 3.0.0-68ab237

package/dist/impl/csharp-compiler.js

@@ -0,0 +1,307 @@
+"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",
+    "RectTransform": "UnityEngine.RectTransform",
+    "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 ".concat(csReturnType, " ").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

@@ -1,34 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReactThreeFiberCompiler = void 0;
-var ReactThreeFiberCompiler = /** @class */ (function () {
-    function ReactThreeFiberCompiler() {
-        this._typeSourceInformation = {};
-    }
-    Object.defineProperty(ReactThreeFiberCompiler.prototype, "outputInfo", {
-        get: function () {
-            return this._typeSourceInformation;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ReactThreeFiberCompiler.prototype.resolveTypeName = function (typescriptTypeName) {
-        return typescriptTypeName;
-    };
-    ReactThreeFiberCompiler.prototype.begin = function (filePath) {
-    };
-    ReactThreeFiberCompiler.prototype.end = function (filePath) {
-    };
-    ReactThreeFiberCompiler.prototype.startNewType = function (filePath, typeName, baseType, comments) {
-    };
-    ReactThreeFiberCompiler.prototype.endNewType = function (filePath, typeName) {
-    };
-    ReactThreeFiberCompiler.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
-    };
-    ReactThreeFiberCompiler.prototype.writeMethod = function (visibility, name, returnType, args, comments) {
-    };
-    ReactThreeFiberCompiler.prototype.writeNewTypeExpression = function (typeName, args) {
-    };
-    return ReactThreeFiberCompiler;
-}());
-exports.ReactThreeFiberCompiler = ReactThreeFiberCompiler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactThreeFiberCompiler = void 0;
+var ReactThreeFiberCompiler = /** @class */ (function () {
+    function ReactThreeFiberCompiler() {
+        this._typeSourceInformation = {};
+    }
+    Object.defineProperty(ReactThreeFiberCompiler.prototype, "outputInfo", {
+        get: function () {
+            return this._typeSourceInformation;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ReactThreeFiberCompiler.prototype.resolveCSharpTypeName = function (typescriptTypeName) {
+        return typescriptTypeName;
+    };
+    ReactThreeFiberCompiler.prototype.begin = function (filePath) {
+    };
+    ReactThreeFiberCompiler.prototype.end = function (filePath) {
+    };
+    ReactThreeFiberCompiler.prototype.startNewType = function (filePath, typeName, baseType, comments) {
+    };
+    ReactThreeFiberCompiler.prototype.endNewType = function (filePath, typeName) {
+    };
+    ReactThreeFiberCompiler.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
+    };
+    ReactThreeFiberCompiler.prototype.writeMethod = function (visibility, name, returnType, args, comments) {
+    };
+    ReactThreeFiberCompiler.prototype.writeNewTypeExpression = function (typeName, args) {
+    };
+    ReactThreeFiberCompiler.prototype.registerEnum = function (name, members) {
+    };
+    return ReactThreeFiberCompiler;
+}());
+exports.ReactThreeFiberCompiler = ReactThreeFiberCompiler;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { Compiler } from "./Compiler";
+export { CSharpWriter } from "./impl/csharp-compiler";
+export { BlenderWriter } from "./impl/blender-compiler";
+export { FileSink, MemorySink, CodeTextWriter, Visibility, handleDeletedFile, runFromFile } from "./base-compiler";
+export type { ISink, IWriter, Argument, EnumMember } from "./base-compiler";

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFromFile = exports.handleDeletedFile = exports.Visibility = exports.CodeTextWriter = exports.MemorySink = exports.FileSink = exports.BlenderWriter = exports.CSharpWriter = exports.Compiler = void 0;
+var Compiler_1 = require("./Compiler");
+Object.defineProperty(exports, "Compiler", { enumerable: true, get: function () { return Compiler_1.Compiler; } });
+var csharp_compiler_1 = require("./impl/csharp-compiler");
+Object.defineProperty(exports, "CSharpWriter", { enumerable: true, get: function () { return csharp_compiler_1.CSharpWriter; } });
+var blender_compiler_1 = require("./impl/blender-compiler");
+Object.defineProperty(exports, "BlenderWriter", { enumerable: true, get: function () { return blender_compiler_1.BlenderWriter; } });
+var base_compiler_1 = require("./base-compiler");
+Object.defineProperty(exports, "FileSink", { enumerable: true, get: function () { return base_compiler_1.FileSink; } });
+Object.defineProperty(exports, "MemorySink", { enumerable: true, get: function () { return base_compiler_1.MemorySink; } });
+Object.defineProperty(exports, "CodeTextWriter", { enumerable: true, get: function () { return base_compiler_1.CodeTextWriter; } });
+Object.defineProperty(exports, "Visibility", { enumerable: true, get: function () { return base_compiler_1.Visibility; } });
+Object.defineProperty(exports, "handleDeletedFile", { enumerable: true, get: function () { return base_compiler_1.handleDeletedFile; } });
+Object.defineProperty(exports, "runFromFile", { enumerable: true, get: function () { return base_compiler_1.runFromFile; } });

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/{src → dist}/register-types.js

@@ -1,34 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeTypeRegistry = void 0;
-var fs_1 = require("fs");
-var path = require("path");
-var base_compiler_1 = require("./base-compiler");
-function writeTypeRegistry(types, registerTypesPath) {
-    console.log("Writing type registry to", registerTypesPath);
-    var directory = path.dirname(registerTypesPath);
-    if (!(0, fs_1.existsSync)(directory)) {
-        (0, fs_1.mkdirSync)(directory);
-    }
-    var file = (0, fs_1.createWriteStream)(registerTypesPath);
-    var writer = new base_compiler_1.CodeTextWriter();
-    writer.writeLine("// This is an auto-generated file. Do not edit!\n");
-    writer.writeLine("import { TypeStore } from \"@needle-tools/engine\";\n");
-    for (var sourceFile in types) {
-        if (!(0, fs_1.existsSync)(sourceFile))
-            continue;
-        var generatedFile = types[sourceFile];
-        var relativePath = path.relative(directory, sourceFile).replace(/\\/g, "/");
-        for (var _i = 0, generatedFile_1 = generatedFile; _i < generatedFile_1.length; _i++) {
-            var fileInfo = generatedFile_1[_i];
-            writer.writeLine("import { ".concat(fileInfo.componentName, " } from \"").concat(relativePath, "\";"));
-            writer.writeLine("TypeStore.add(\"".concat(fileInfo.componentName, "\", ").concat(fileInfo.componentName, ");"));
-        }
-    }
-    writer.writeLine("\n// Made with 🌵 Needle");
-    writer.writeLine("// https://needle.tools");
-    var code = writer.toString();
-    file.write(code);
-    file.end();
-}
-exports.writeTypeRegistry = writeTypeRegistry;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeTypeRegistry = void 0;
+var fs_1 = require("fs");
+var path = require("path");
+var base_compiler_1 = require("./base-compiler");
+function writeTypeRegistry(types, registerTypesPath) {
+    console.log("Writing type registry to", registerTypesPath);
+    var directory = path.dirname(registerTypesPath);
+    if (!(0, fs_1.existsSync)(directory)) {
+        (0, fs_1.mkdirSync)(directory);
+    }
+    var file = (0, fs_1.createWriteStream)(registerTypesPath);
+    var writer = new base_compiler_1.CodeTextWriter();
+    writer.writeLine("// This is an auto-generated file. Do not edit!\n");
+    writer.writeLine("import { TypeStore } from \"@needle-tools/engine\";\n");
+    for (var sourceFile in types) {
+        if (!(0, fs_1.existsSync)(sourceFile))
+            continue;
+        var generatedFile = types[sourceFile];
+        var relativePath = path.relative(directory, sourceFile).replace(/\\/g, "/");
+        for (var _i = 0, generatedFile_1 = generatedFile; _i < generatedFile_1.length; _i++) {
+            var fileInfo = generatedFile_1[_i];
+            writer.writeLine("import { ".concat(fileInfo.componentName, " } from \"").concat(relativePath, "\";"));
+            writer.writeLine("TypeStore.add(\"".concat(fileInfo.componentName, "\", ").concat(fileInfo.componentName, ");"));
+        }
+    }
+    writer.writeLine("\n// Made with 🌵 Needle");
+    writer.writeLine("// https://needle.tools");
+    var code = writer.toString();
+    file.write(code);
+    file.end();
+}
+exports.writeTypeRegistry = writeTypeRegistry;

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;
+}