@needle-tools/needle-component-compiler 3.0.10 → 3.0.12

package/Changelog.md

@@ -4,6 +4,10 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [3.0.12] - 2026-03-23
+### Fixed
+- Fix nullable array types (`Texture[] | null`, `Array<Texture> | null`, `Array<Texture | null>`) not emitting as arrays in C# and Blender output
+
 ## [3.0.5] - 2026-03-15
 ### Added
 - `--types <path>` CLI flag to load external type mappings from a JSON file (e.g. Unity's `Types.json`)

package/dist/BaseWriter.js

@@ -4,6 +4,7 @@ exports.BaseWriter = void 0;
 var fs_1 = require("fs");
 var base_compiler_1 = require("./base-compiler");
 var commands_1 = require("./commands");
+var log_1 = require("./log");
 var BaseWriter = /** @class */ (function () {
     function BaseWriter(_sink) {
         this._sink = _sink;
@@ -38,7 +39,9 @@ var BaseWriter = /** @class */ (function () {
     };
     BaseWriter.prototype.end = function (filePath) {
         var results = this._currentlyProcessingFiles[filePath];
-        console.log("Writing schemes for", filePath, results);
+        if (results === null || results === void 0 ? void 0 : results.length) {
+            log_1.logger.log("  Schemes:", results.map(function (r) { return r.componentName; }).join(", "));
+        }
         if (results) {
             var previousResultsFromThisFile = this._createdSchemesPerFile[filePath];
             if (previousResultsFromThisFile) {

package/dist/Compiler.d.ts

@@ -6,6 +6,8 @@ export declare class Compiler {
     private visitEnumDeclaration;
     private visit;
     private visitClassDeclaration;
+    /** Format a structured log line for a member */
+    private logMember;
     private visitPropertyDeclaration;
     private hasSerializableDecorator;
     /** Track accessor names already emitted per class to avoid duplicates when both getter and setter have @serializable() */
@@ -13,7 +15,6 @@ export declare class Compiler {
     private visitAccessorDeclaration;
     private visitMethodDeclaration;
     private resolveParameters;
-    private debugLog;
     private getComments;
     /** Strip markdown/code/images/URLs/JSDoc tags to produce a plain-text tooltip */
     private static sanitizeJsdocForTooltip;

package/dist/Compiler.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Compiler = void 0;
 var ts = require("typescript");
 var base_compiler_1 = require("./base-compiler");
+var log_1 = require("./log");
 /** Typescript Walker */
 var Compiler = /** @class */ (function () {
     function Compiler() {
@@ -17,7 +18,7 @@ var Compiler = /** @class */ (function () {
     };
     Compiler.prototype.run = function (prog, writer, sourceFile, filePath) {
         var _this = this;
-        console.log("Starting compilation of " + filePath);
+        log_1.logger.log("Compiling", filePath);
         writer.begin(filePath);
         // Pre-scan: collect enum declarations so type resolution works for class fields
         ts.forEachChild(sourceFile, function (node) {
@@ -62,7 +63,7 @@ var Compiler = /** @class */ (function () {
             }
             members.push({ name: memberName, value: value });
         }
-        this.debugLog("[COMPILER] ENUM", name, members);
+        log_1.logger.log("  enum", name, "(" + members.length + " members)");
         writer.registerEnum(name, members);
     };
     Compiler.prototype.visit = function (filePath, node, writer) {
@@ -102,10 +103,10 @@ var Compiler = /** @class */ (function () {
                 }
             }
         }
-        this.debugLog("[COMPILER] CLASS START", name, baseTypes);
+        log_1.logger.log("  class " + name + (baseTypes.length ? " extends " + baseTypes.join(", ") : ""));
         var res = writer.startNewType(filePath, name, baseTypes, this.getComments(node));
         if (res === false) {
-            this.debugLog("CLASS SKIPPED", name);
+            log_1.logger.log("    (skipped)");
             return;
         }
         this._emittedAccessors.clear();
@@ -113,13 +114,23 @@ var Compiler = /** @class */ (function () {
             _this.visit(filePath, node, writer);
         });
         writer.endNewType(filePath, name);
-        this.debugLog("[COMPILER] CLASS END", name, "\n");
+    };
+    /** Format a structured log line for a member */
+    Compiler.prototype.logMember = function (kind, visibility, name, type, initialValue, flags) {
+        var parts = [];
+        parts.push(base_compiler_1.Visibility[visibility].toLowerCase());
+        if (flags && flags.length)
+            parts.push.apply(parts, flags);
+        var detail = parts.length ? " (" + parts.join(", ") + ")" : "";
+        var valStr = initialValue !== undefined && initialValue !== null ? " = " + initialValue : "";
+        log_1.logger.log("    " + kind + " " + name + ": " + (type || "?") + valStr + detail);
     };
     Compiler.prototype.visitPropertyDeclaration = function (node, writer) {
+        var _a;
         // Skip static and abstract properties — they don't map to serialized fields
         if (node.modifiers) {
-            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
-                var modifier = _a[_i];
+            for (var _i = 0, _b = node.modifiers; _i < _b.length; _i++) {
+                var modifier = _b[_i];
                 if (modifier.kind === ts.SyntaxKind.StaticKeyword ||
                     modifier.kind === ts.SyntaxKind.AbstractKeyword) {
                     return;
@@ -134,10 +145,22 @@ var Compiler = /** @class */ (function () {
         if (!type && node.initializer) {
             type = this.tryResolveTypeFromExpression(node.initializer, writer);
         }
-        this.debugLog("[COMPILER] PROPERTY", base_compiler_1.Visibility[visibility], name, isArray, type, initialValue);
         if (!type)
             return; // cannot determine type — skip the field
-        writer.writeMember(visibility, name, isArray, type, initialValue, this.getComments(node));
+        var comments = (_a = this.getComments(node)) !== null && _a !== void 0 ? _a : [];
+        // If the property has a @serializable() decorator, ensure it's in the comments
+        // so the writer emits private/protected fields with [SerializeField]
+        var hasSerialized = this.hasSerializableDecorator(node);
+        if (hasSerialized && !comments.some(function (c) { return c.startsWith("@serializable"); })) {
+            comments.push("@serializable");
+        }
+        var flags = [];
+        if (isArray)
+            flags.push("array");
+        if (hasSerialized)
+            flags.push("@serializable");
+        this.logMember("+", visibility, name, type, initialValue, flags);
+        writer.writeMember(visibility, name, isArray, type, initialValue, comments);
     };
     Compiler.prototype.hasSerializableDecorator = function (node) {
         var _a;
@@ -167,7 +190,6 @@ var Compiler = /** @class */ (function () {
             typeNode = (_b = (_a = node.parameters) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.type;
         }
         type = this.resolveType(typeNode, writer);
-        this.debugLog("[COMPILER] ACCESSOR (serializable)", name, type);
         if (!type)
             return;
         var isArray = typeNode ? this.isArrayType(typeNode) : false;
@@ -177,6 +199,10 @@ var Compiler = /** @class */ (function () {
         if (!comments.some(function (c) { return c.startsWith("@serializable"); })) {
             comments.push("@serializable");
         }
+        var flags = ["accessor", "@serializable"];
+        if (isArray)
+            flags.push("array");
+        this.logMember("+", visibility, name, type, undefined, flags);
         writer.writeMember(visibility, name, isArray, type, undefined, comments);
     };
     Compiler.prototype.visitMethodDeclaration = function (node, writer) {
@@ -198,7 +224,8 @@ var Compiler = /** @class */ (function () {
         if ((_a = node.parameters) === null || _a === void 0 ? void 0 : _a.length) {
             args = this.resolveParameters(node.parameters, writer);
         }
-        this.debugLog("[COMPILER] METHOD", base_compiler_1.Visibility[visibility], name, returnType, args);
+        var argsStr = (args === null || args === void 0 ? void 0 : args.length) ? "(" + args.map(function (a) { return (a.type || "?") + " " + a.name; }).join(", ") + ")" : "()";
+        this.logMember("+", visibility, name + argsStr, returnType || "void");
         writer.writeMethod(visibility, name, returnType, args, this.getComments(node));
     };
     Compiler.prototype.resolveParameters = function (parameters, writer) {
@@ -213,13 +240,6 @@ var Compiler = /** @class */ (function () {
         }
         return result;
     };
-    Compiler.prototype.debugLog = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        console.log.apply(console, args);
-    };
     Compiler.prototype.getComments = function (node) {
         var commentRanges = ts.getLeadingCommentRanges(node.getFullText(), 0);
         if (commentRanges) {
@@ -305,19 +325,15 @@ var Compiler = /** @class */ (function () {
         }
         // Infer type from literal initializers (no explicit type annotation)
         if (ts.isNumericLiteral(exp)) {
-            // e.g. speed = 5  or  ratio = 5.5  → number → float
             return this.resolveTypeFromString("number", write);
         }
         if (ts.isStringLiteral(exp)) {
-            // e.g. label = "hello" → string
             return this.resolveTypeFromString("string", write);
         }
         if (exp.kind === ts.SyntaxKind.TrueKeyword || exp.kind === ts.SyntaxKind.FalseKeyword) {
-            // e.g. active = true → boolean → bool
             return this.resolveTypeFromString("boolean", write);
         }
         if (ts.isPrefixUnaryExpression(exp) && ts.isNumericLiteral(exp.operand)) {
-            // e.g. speed = -5  or  ratio = -1.5 → number → float
             return this.resolveTypeFromString("number", write);
         }
     };
@@ -326,6 +342,17 @@ var Compiler = /** @class */ (function () {
             return undefined;
         // check if its an array
         if (this.isArrayType(typeNode)) {
+            // Unwrap union types (e.g. Texture[] | null) to find the array member
+            if (ts.isUnionTypeNode(typeNode)) {
+                for (var _i = 0, _a = typeNode.types; _i < _a.length; _i++) {
+                    var member = _a[_i];
+                    if (member.kind !== ts.SyntaxKind.NullKeyword &&
+                        member.kind !== ts.SyntaxKind.UndefinedKeyword &&
+                        member.kind !== ts.SyntaxKind.VoidKeyword) {
+                        return this.resolveType(member, writer);
+                    }
+                }
+            }
             if (typeNode.kind === ts.SyntaxKind.ArrayType) {
                 var arrayType = typeNode;
                 return this.resolveType(arrayType.elementType, writer);
@@ -361,18 +388,12 @@ var Compiler = /** @class */ (function () {
                     }
                 }
             }
-            // is generic
-            // if (typeNode.kind === ts.SyntaxKind.TypeReference) {
-            //     const typeReference = typeNode as ts.TypeReferenceNode;
-            //     const typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
-            //     return this.resolveType(typeArgument, writer);
-            // }
-            console.error("!!!!! ----- Unknown array type", typeNode.getText());
+            log_1.logger.warn("Unknown array type:", typeNode.getText());
         }
         // Union types: Object3D | null | undefined → resolve the first concrete member
         if (ts.isUnionTypeNode(typeNode)) {
-            for (var _i = 0, _a = typeNode.types; _i < _a.length; _i++) {
-                var member = _a[_i];
+            for (var _b = 0, _c = typeNode.types; _b < _c.length; _b++) {
+                var member = _c[_b];
                 if (member.kind !== ts.SyntaxKind.NullKeyword &&
                     member.kind !== ts.SyntaxKind.UndefinedKeyword &&
                     member.kind !== ts.SyntaxKind.VoidKeyword) {
@@ -400,6 +421,18 @@ var Compiler = /** @class */ (function () {
     Compiler.prototype.isArrayType = function (typeNode) {
         if (!typeNode)
             return false;
+        // Unwrap union types (e.g. Texture[] | null → Texture[])
+        if (ts.isUnionTypeNode(typeNode)) {
+            for (var _i = 0, _a = typeNode.types; _i < _a.length; _i++) {
+                var member = _a[_i];
+                if (member.kind !== ts.SyntaxKind.NullKeyword &&
+                    member.kind !== ts.SyntaxKind.UndefinedKeyword &&
+                    member.kind !== ts.SyntaxKind.VoidKeyword) {
+                    return this.isArrayType(member);
+                }
+            }
+            return false;
+        }
         // check if its an array
         if (typeNode.kind === ts.SyntaxKind.ArrayType) {
             return true;
@@ -499,14 +532,11 @@ var Compiler = /** @class */ (function () {
         else if (ts.isNewExpression(node)) {
             var typeName = this.resolveTypeFromString(node.expression.getText(), writer);
             if (typeName) {
-                console.log("TODO: new expression");
                 var args = node.arguments.map(function (a) { return _this.resolveExpression(a, writer); }).filter(function (a) { return a; });
-                // writer.writeNewTypeExpression(typeName, args);
-                // return;
                 return "new " + typeName + "(" + args.join(", ") + ")";
             }
         }
-        console.error("!!!!! ----- Unknown expression", ts.SyntaxKind[node.kind], node.getText());
+        log_1.logger.warn("Unknown expression:", ts.SyntaxKind[node.kind], node.getText());
     };
     return Compiler;
 }());

package/dist/base-compiler.js

@@ -6,6 +6,7 @@ exports.runFromFile = runFromFile;
 var fs_1 = require("fs");
 var fs = require("fs");
 var commands_1 = require("./commands");
+var log_1 = require("./log");
 var Compiler_1 = require("./Compiler");
 var Visibility;
 (function (Visibility) {
@@ -21,7 +22,7 @@ var FileSink = /** @class */ (function () {
         if (!fs.existsSync(this.directory)) {
             fs.mkdirSync(this.directory, { recursive: true });
         }
-        console.log("Writing " + id + " to " + this.directory);
+        log_1.logger.log("  → Writing " + id);
         var fullPath = this.directory + "/" + id;
         // If the file already exists and contains codegen fences,
         // preserve content outside the fences
@@ -172,7 +173,7 @@ function handleDeletedFile(filePath, types) {
 }
 function runFromFile(writer, path) {
     if (!fs.existsSync(path)) {
-        console.error("File not found", path);
+        log_1.logger.error("File not found", path);
         return;
     }
     var code = (0, fs_1.readFileSync)(path).toString();

package/dist/cli.js

@@ -7,6 +7,7 @@ var Compiler_1 = require("./Compiler");
 var base_compiler_1 = require("./base-compiler");
 var csharp_compiler_1 = require("./impl/csharp-compiler");
 var blender_compiler_1 = require("./impl/blender-compiler");
+var log_1 = require("./log");
 var pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf-8"));
 var rawArgs = process.argv.slice(2);
 if (rawArgs.includes("--version") || rawArgs.includes("-v")) {
@@ -26,6 +27,7 @@ if (rawArgs.includes("--help") || rawArgs.includes("-h") || rawArgs.length < 3)
     console.log("  --types <path>  path to Types.json with extra type mappings");
     console.log("");
     console.log("Flags:");
+    console.log("  --silent, -s    only output errors and CMD: lines");
     console.log("  --version, -v   print version");
     console.log("  --help, -h      print this help");
     if (rawArgs.length < 3 && !rawArgs.includes("--help") && !rawArgs.includes("-h")) {
@@ -33,42 +35,49 @@ if (rawArgs.includes("--help") || rawArgs.includes("-h") || rawArgs.length < 3)
     }
     process.exit(0);
 }
-// Extract --types flag from anywhere in the args
+// Extract flags from anywhere in the args
 var typesPath;
+var silent = false;
 var positionalArgs = [];
 for (var i = 0; i < rawArgs.length; i++) {
     if (rawArgs[i] === "--types" && i + 1 < rawArgs.length) {
         typesPath = rawArgs[++i];
     }
+    else if (rawArgs[i] === "--silent" || rawArgs[i] === "-s") {
+        silent = true;
+    }
     else {
         positionalArgs.push(rawArgs[i]);
     }
 }
+if (silent) {
+    log_1.logger.silent = true;
+}
 var target = positionalArgs[0];
 var outputDir = positionalArgs[1];
 var inputFiles = positionalArgs.slice(2);
 if (target !== "csharp" && target !== "blender") {
-    console.error("Error: unknown target \"".concat(target, "\". Use \"csharp\" or \"blender\"."));
+    log_1.logger.error("Error: unknown target \"".concat(target, "\". Use \"csharp\" or \"blender\"."));
     process.exit(1);
 }
+log_1.logger.log("needle-component-compiler v".concat(pkg.version));
 // Load external types if provided
 var externalTypes;
 if (typesPath) {
     if (!fs.existsSync(typesPath)) {
-        console.warn("Warning: types file not found: ".concat(typesPath));
+        log_1.logger.warn("Warning: types file not found: ".concat(typesPath));
     }
     else {
         try {
             externalTypes = JSON.parse(fs.readFileSync(typesPath, "utf-8"));
-            console.log("Loaded ".concat(Object.keys(externalTypes).length, " external type mappings from ").concat(typesPath));
+            log_1.logger.log("Loaded ".concat(Object.keys(externalTypes).length, " external type mappings from ").concat(typesPath));
         }
         catch (e) {
-            console.error("Error reading types file: ".concat(e));
+            log_1.logger.error("Error reading types file: ".concat(e));
             process.exit(1);
         }
     }
 }
-console.log("needle-component-compiler v".concat(pkg.version));
 var sink = new base_compiler_1.FileSink(outputDir);
 var writer = target === "csharp" ? new csharp_compiler_1.CSharpWriter(sink, externalTypes) : new blender_compiler_1.BlenderWriter(sink);
 var compiler = new Compiler_1.Compiler();
@@ -77,7 +86,7 @@ for (var _i = 0, inputFiles_1 = inputFiles; _i < inputFiles_1.length; _i++) {
     var filePath = inputFiles_1[_i];
     try {
         if (!fs.existsSync(filePath)) {
-            console.error("Error: file not found: ".concat(filePath));
+            log_1.logger.error("Error: file not found: ".concat(filePath));
             hasErrors = true;
             continue;
         }
@@ -85,7 +94,7 @@ for (var _i = 0, inputFiles_1 = inputFiles; _i < inputFiles_1.length; _i++) {
         compiler.compile(writer, code, filePath);
     }
     catch (e) {
-        console.error("Error processing ".concat(filePath, ": ").concat(e));
+        log_1.logger.error("Error processing ".concat(filePath, ": ").concat(e));
         hasErrors = true;
     }
 }

package/dist/impl/blender-compiler.js

@@ -18,6 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlenderWriter = void 0;
 var base_compiler_1 = require("../base-compiler");
 var BaseWriter_1 = require("../BaseWriter");
+var log_1 = require("../log");
 var supportedTypes = ["string", "float", "int", "bool", "col", "obj", "evt", "fn", "vec2", "vec3", "comp"];
 var knownBaseTypes = ["Behaviour", "IComponent"];
 var BlenderWriter = /** @class */ (function (_super) {
@@ -187,7 +188,7 @@ var BlenderWriter = /** @class */ (function (_super) {
         this.writer.endBlock("},");
     };
     BlenderWriter.prototype.writeNewTypeExpression = function (typeName, args) {
-        console.log("new type:", typeName);
+        log_1.logger.log("new type:", typeName);
     };
     return BlenderWriter;
 }(BaseWriter_1.BaseWriter));

package/dist/impl/csharp-compiler.js

@@ -18,6 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CSharpWriter = void 0;
 var base_compiler_1 = require("../base-compiler");
 var BaseWriter_1 = require("../BaseWriter");
+var log_1 = require("../log");
 var allowDebugLogs = false;
 /** Inline type dictionary: TypeScript type name → fully-qualified C# type name */
 var TYPE_MAP = {
@@ -209,7 +210,7 @@ var CSharpWriter = /** @class */ (function (_super) {
     CSharpWriter.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
         var _a;
         if (allowDebugLogs)
-            console.log("[CSharp] writeMember", name, type, comments);
+            log_1.logger.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;
@@ -290,7 +291,7 @@ var CSharpWriter = /** @class */ (function (_super) {
         var _this = this;
         var _a, _b;
         if (allowDebugLogs)
-            console.log("[CSharp] writeMethod", name, returnType);
+            log_1.logger.log("[CSharp] writeMethod", name, returnType);
         // @nonSerialized → skip entirely
         if (comments === null || comments === void 0 ? void 0 : comments.some(function (c) { return c.startsWith("@nonSerialized"); }))
             return;

package/dist/log.d.ts

@@ -0,0 +1,8 @@
+/** Simple logger that can be silenced via the `silent` flag.
+ *  Errors and CMD: lines are always emitted regardless of silent mode. */
+export declare const logger: {
+    silent: boolean;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+};

package/dist/log.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+/** Simple logger that can be silenced via the `silent` flag.
+ *  Errors and CMD: lines are always emitted regardless of silent mode. */
+exports.logger = {
+    silent: false,
+    log: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (!this.silent)
+            console.log.apply(console, args);
+    },
+    warn: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        console.warn.apply(console, args);
+    },
+    error: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        console.error.apply(console, args);
+    },
+};

package/dist/register-types.js

@@ -4,8 +4,9 @@ exports.writeTypeRegistry = writeTypeRegistry;
 var fs_1 = require("fs");
 var path = require("path");
 var base_compiler_1 = require("./base-compiler");
+var log_1 = require("./log");
 function writeTypeRegistry(types, registerTypesPath) {
-    console.log("Writing type registry to", registerTypesPath);
+    log_1.logger.log("Writing type registry to", registerTypesPath);
     var directory = path.dirname(registerTypesPath);
     if (!(0, fs_1.existsSync)(directory)) {
         (0, fs_1.mkdirSync)(directory);

package/dist/watcher.js

@@ -7,6 +7,7 @@ var Compiler_1 = require("./Compiler");
 var blender_compiler_1 = require("./impl/blender-compiler");
 var chokidar = require("chokidar");
 var commands_1 = require("./commands");
+var log_1 = require("./log");
 var register_types_1 = require("./register-types");
 // https://github.com/paulmillr/chokidar
 var DirectoryWatcher = /** @class */ (function () {
@@ -21,26 +22,26 @@ var DirectoryWatcher = /** @class */ (function () {
             try {
                 switch (event) {
                     case "add":
-                        console.log("File", path, "has been added");
+                        log_1.logger.log("File added:", path);
                         _this.compiler.compile(writer, fs.readFileSync(path).toString(), path);
                         _this._typesChanged = true;
                         break;
                     case "change":
-                        console.log("File", path, "has been changed");
+                        log_1.logger.log("File changed:", path);
                         _this.compiler.compile(writer, fs.readFileSync(path).toString(), path);
                         _this._typesChanged = true;
                         break;
                     case "unlink":
-                        console.log("File", path, "has been removed");
+                        log_1.logger.log("File removed:", path);
                         (0, base_compiler_1.handleDeletedFile)(path, writer.outputInfo);
                         _this._typesChanged = true;
                         break;
                     default:
-                        console.log("File unhandled event", event, path);
+                        log_1.logger.log("File unhandled event:", event, path);
                 }
             }
             catch (err) {
-                console.error(err);
+                log_1.logger.error(err);
             }
         });
         // call reload cmd 
@@ -61,19 +62,19 @@ process.on('exit', function () {
 });
 var args = process.argv.slice(2);
 if (args.length < 3) {
-    console.error("Missing arguments, usage: node watcher.js <directory> <output> <registerTypesPath>");
+    log_1.logger.error("Missing arguments, usage: node watcher.js <directory> <output> <registerTypesPath>");
     process.exit(1);
 }
 var directoryToWatch = args[0].replace("\"", "");
 var outputDirectory = args[1].replace("\"", "");
 var registerTypesPath = args[2].replace("\"", "");
 if (!fs.existsSync(directoryToWatch)) {
-    console.error("Directory to watch does not exist");
+    log_1.logger.error("Directory to watch does not exist");
     process.exit(1);
 }
 if (fs.existsSync(outputDirectory))
     fs.rmSync(outputDirectory, { recursive: true });
-console.log("Watch: " + directoryToWatch + " and output to: " + outputDirectory);
+log_1.logger.log("Watch:", directoryToWatch, "→", outputDirectory);
 var watcher = new DirectoryWatcher();
 var sink = new base_compiler_1.FileSink(outputDirectory);
 watcher.startWatching(directoryToWatch, new blender_compiler_1.BlenderWriter(sink), registerTypesPath);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "3.0.10",
+    "version": "3.0.12",
     "description": "Compile Editor components for Needle Engine for C# and Blender",
     "main": "dist/index.js",
     "bin": "dist/cli.js",