@needle-tools/needle-component-compiler 1.9.2-exp → 1.9.3

package/test/helpers.ts

@@ -0,0 +1,72 @@
+import { compile } from "../src/component-compiler";
+import { expect } from 'chai';
+import * as fs from "fs";
+import { debuglog } from "util";
+
+class TestOptions {
+    ignoreWhiteSpace: boolean = true;
+}
+
+export function testCompile(code: string): string | null {
+
+    const res = compile(code, "test", null, false);
+    const output = res?.length > 0 ? res[0] : "";
+
+    return output;
+
+}
+
+function compareByLine(output: string, expected: string) {
+    const splitCode = /\r?\n/;
+
+    if (output == null) {
+
+        expect(expected).to.equal(output);
+    }
+    else {
+
+        const outputLines = output.split(splitCode);
+        const expectedLines = expected.split(splitCode);
+        for (let i = 0; i < outputLines.length; i++) {
+            const outputLine = outputLines[i].trim();
+            const expectedLine = expectedLines[i].trim();
+            expect(outputLine).to.equal(expectedLine, `Line ${i} does not match`);
+        }
+    }
+
+}
+
+export function compareCodegen(id: string, input: string, expected: string) {
+    const baseDir = "test/codegen";
+    if (!fs.existsSync(baseDir))
+        fs.mkdirSync(baseDir);
+    const dir = `${baseDir}/${id}`;
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir);
+    fs.writeFileSync(`${dir}\\input.ts`, input);
+    const result = testCompile(input);
+    if (result !== null)
+        fs.writeFileSync(`${dir}\\output.cs`, result);
+    fs.writeFileSync(`${dir}\\expected.cs`, expected);
+
+    compareByLine(result, expected);
+
+    // expect(result).to.equal(expected);
+}
+
+export function compareCodegenWithDefaultContext(id: string, input: string, expected: string) {
+
+
+    expected = `// NEEDLE_CODEGEN_START
+    // auto generated code - do not edit directly
+    
+    #pragma warning disable
+    
+    namespace Needle.Typescript.GeneratedComponents
+    {
+    \t` + expected + `
+    }
+    
+    // NEEDLE_CODEGEN_END`;
+    return compareCodegen(id, input, expected);
+}

package/workspace.code-workspace

@@ -1,12 +1,12 @@
-{
-	"folders": [
-		{
-			"path": "."
-		}
-	],
-	"settings": {
-		"files.exclude": {
-		  "test/*.js": true
-		}
-	}
+{
+	"folders": [
+		{
+			"path": "."
+		}
+	],
+	"settings": {
+		"files.exclude": {
+		  "test/*.js": true
+		}
+	}
 }

package/src/base-compiler.js

@@ -1,404 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.Compiler = exports.runFromFile = exports.CodeTextWriter = exports.Visibility = void 0;
-var fs_1 = require("fs");
-var ts = require("typescript");
-var fs = require("fs");
-var Visibility;
-(function (Visibility) {
-    Visibility[Visibility["Public"] = 0] = "Public";
-    Visibility[Visibility["Protected"] = 1] = "Protected";
-    Visibility[Visibility["Private"] = 2] = "Private";
-})(Visibility = exports.Visibility || (exports.Visibility = {}));
-var CodeTextWriter = /** @class */ (function () {
-    function CodeTextWriter() {
-        this.indent = 0;
-        this.lines = [];
-    }
-    CodeTextWriter.prototype.beginBlock = function (line) {
-        this.writeLine(line);
-        this.indent++;
-    };
-    CodeTextWriter.prototype.endBlock = function (line) {
-        // remove the comma from the last line
-        if (this.lines.length > 0) {
-            var prevLine = this.lines[this.lines.length - 1];
-            if (prevLine.endsWith(",")) {
-                this.lines[this.lines.length - 1] = prevLine.substring(0, prevLine.length - 1);
-            }
-        }
-        this.indent--;
-        this.writeLine(line);
-    };
-    CodeTextWriter.prototype.writeLine = function (line) {
-        var indent = "";
-        for (var i = 0; i < this.indent; i++) {
-            indent += "    ";
-        }
-        // remove whitespace so we can ensure we correctly end with a comma
-        this.lines.push(indent + (line === null || line === void 0 ? void 0 : line.trim()));
-    };
-    CodeTextWriter.prototype.write = function (text) {
-        var lines = text.split("\r");
-        if (lines.length > 1) {
-            for (var i = 0; i < lines.length; i++) {
-                this.writeLine(lines[i]);
-            }
-        }
-        else {
-            if (this.lines.length == 0) {
-                this.writeLine(text);
-            }
-            else {
-                var lastLine = this.lines[this.lines.length - 1];
-                this.lines[this.lines.length - 1] = lastLine + text;
-            }
-        }
-    };
-    CodeTextWriter.prototype.beginArray = function () {
-        this.writeLine("[");
-        this.indent++;
-    };
-    CodeTextWriter.prototype.insertArrayItem = function (item) {
-        this.writeLine(item + ",");
-    };
-    CodeTextWriter.prototype.endArray = function () {
-    };
-    CodeTextWriter.prototype.flush = function (directory, filename) {
-        if (this.lines.length === 0)
-            return;
-        if (!fs.existsSync(directory)) {
-            fs.mkdirSync(directory, { recursive: true });
-        }
-        console.log("Writing " + filename + " to " + directory);
-        var content = this.lines.join("\r");
-        this.lines.length = 0;
-        var fullPath = directory + "/" + filename;
-        fs.writeFileSync(fullPath, content);
-        return fs.realpathSync(fullPath);
-    };
-    return CodeTextWriter;
-}());
-exports.CodeTextWriter = CodeTextWriter;
-function runFromFile(writer, path) {
-    if (!fs.existsSync(path)) {
-        console.error("File not found", path);
-        return;
-    }
-    var code = (0, fs_1.readFileSync)(path).toString();
-    var compiler = new Compiler();
-    compiler.compile(writer, code);
-    return compiler;
-}
-exports.runFromFile = runFromFile;
-var Compiler = /** @class */ (function () {
-    function Compiler() {
-    }
-    Compiler.prototype.compile = function (writer, code) {
-        var file = "needle_compiled.ts";
-        var sourceFile = ts.createSourceFile(file, code, ts.ScriptTarget.ES2015, true, /*setParentNodes */ ts.ScriptKind.TS);
-        var prog = ts.createProgram([file], {});
-        this.run(prog, writer, sourceFile);
-    };
-    Compiler.prototype.run = function (prog, writer, sourceFile) {
-        var _this = this;
-        writer.begin();
-        ts.forEachChild(sourceFile, function (node) {
-            _this.visit(node, writer);
-        });
-        writer.end();
-    };
-    Compiler.prototype.visit = function (node, writer) {
-        var _this = this;
-        if (ts.isClassDeclaration(node)) {
-            this.visitClassDeclaration(node, writer);
-        }
-        else if (ts.isPropertyDeclaration(node)) {
-            this.visitPropertyDeclaration(node, writer);
-        }
-        else if (ts.isMethodDeclaration(node)) {
-            this.visitMethodDeclaration(node, writer);
-        }
-        else {
-            ts.forEachChild(node, function (node) {
-                _this.visit(node, writer);
-            });
-        }
-    };
-    Compiler.prototype.visitClassDeclaration = function (node, writer) {
-        var _this = this;
-        var name = node.name.text;
-        var base = node.heritageClauses && node.heritageClauses[0].types[0].expression.getText();
-        this.debugLog("CLASS START", name, base);
-        var res = writer.startNewType(name, base, this.getComments(node));
-        if (res === false) {
-            this.debugLog("CLASS SKIPPED", name);
-            return;
-        }
-        ts.forEachChild(node, function (node) {
-            _this.visit(node, writer);
-        });
-        writer.endNewType(name);
-        this.debugLog("CLASS END", name, "\n");
-    };
-    Compiler.prototype.visitPropertyDeclaration = function (node, writer) {
-        var name = node.name.getText();
-        var type = this.resolveType(node.type, writer);
-        var visibility = this.getVisibility(node);
-        var initialValue = node.initializer && this.resolveExpression(node.initializer, writer);
-        var isArray = this.isArrayType(node.type);
-        if (!type && node.initializer) {
-            type = this.tryResolveTypeFromExpression(node.initializer, writer);
-        }
-        this.debugLog("PROPERTY", Visibility[visibility], name, isArray, type, initialValue);
-        writer.writeMember(visibility, name, isArray, type, initialValue, this.getComments(node));
-    };
-    Compiler.prototype.visitMethodDeclaration = function (node, writer) {
-        var _a;
-        var name = node.name.getText();
-        var visibility = this.getVisibility(node);
-        var returnType = this.resolveType(node.type, writer);
-        var args;
-        if ((_a = node.parameters) === null || _a === void 0 ? void 0 : _a.length) {
-            args = this.resolveParameters(node.parameters, writer);
-        }
-        this.debugLog("METHOD", Visibility[visibility], name, returnType, args);
-        writer.writeMethod(visibility, name, returnType, args, this.getComments(node));
-    };
-    Compiler.prototype.resolveParameters = function (parameters, writer) {
-        var result = [];
-        for (var _i = 0, parameters_1 = parameters; _i < parameters_1.length; _i++) {
-            var parameter = parameters_1[_i];
-            var name_1 = parameter.name.getText();
-            var type = this.resolveType(parameter.type, writer);
-            var defaultValue = parameter.initializer && this.resolveExpression(parameter.initializer, writer);
-            result.push({ name: name_1, type: type, defaultValue: defaultValue });
-        }
-        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) {
-            var comments = [];
-            for (var _i = 0, commentRanges_1 = commentRanges; _i < commentRanges_1.length; _i++) {
-                var range = commentRanges_1[_i];
-                var text = node.getFullText().substring(range.pos, range.end).trimStart();
-                // match only lines that starts with //@ or // @
-                var match = text.match(/\/\/\s*@(.+)/);
-                if (match) {
-                    comments.push(text.substring(match.index + 2).trim());
-                }
-            }
-            return comments;
-        }
-    };
-    Compiler.prototype.getVisibility = function (node) {
-        if (node.modifiers) {
-            for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) {
-                var modifier = _a[_i];
-                if (modifier.kind === ts.SyntaxKind.PublicKeyword) {
-                    return Visibility.Public;
-                }
-                else if (modifier.kind === ts.SyntaxKind.ProtectedKeyword) {
-                    return Visibility.Protected;
-                }
-                else if (modifier.kind === ts.SyntaxKind.PrivateKeyword) {
-                    return Visibility.Private;
-                }
-            }
-        }
-        return Visibility.Public;
-    };
-    Compiler.prototype.tryResolveTypeFromExpression = function (exp, write) {
-        var _a;
-        if (ts.isNewExpression(exp)) {
-            // try get generic type from expression
-            if ((_a = exp.typeArguments) === null || _a === void 0 ? void 0 : _a.length) {
-                for (var _i = 0, _b = exp.typeArguments; _i < _b.length; _i++) {
-                    var arg = _b[_i];
-                    var type = this.resolveType(arg, write);
-                    if (type) {
-                        return type;
-                    }
-                }
-            }
-            var typeName = exp.expression.getText();
-            // const typeName = exp.expression.getText();
-            // console.log("NEW EXPRESSION", typeName);
-            // const args = exp.arguments?.map(arg => this.resolveExpression(arg, write));
-            // write.writeNewTypeExpression(typeName, args);
-            return typeName;
-        }
-    };
-    Compiler.prototype.resolveType = function (typeNode, writer) {
-        if (!typeNode)
-            return undefined;
-        // check if its an array
-        if (this.isArrayType(typeNode)) {
-            if (typeNode.kind === ts.SyntaxKind.ArrayType) {
-                var arrayType = typeNode;
-                return this.resolveType(arrayType.elementType, writer);
-            }
-            // check if its Array<> or Map
-            if (typeNode.kind === ts.SyntaxKind.TypeReference) {
-                var typeReference = typeNode;
-                if (typeReference.typeName.getText() === "Array") {
-                    var typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
-                    return this.resolveType(typeArgument, writer);
-                }
-                else if (typeReference.typeName.getText() === "Map") {
-                    var typeArgument = typeReference.typeArguments && typeReference.typeArguments[0];
-                    return this.resolveType(typeArgument, writer);
-                }
-            }
-            // check if its dictionary
-            if (typeNode.kind === ts.SyntaxKind.TypeLiteral) {
-                var typeLiteral = typeNode;
-                var members = typeLiteral.members;
-                if (members.length === 2) {
-                    var firstMember = members[0];
-                    var secondMember = members[1];
-                    if (firstMember.kind === ts.SyntaxKind.IndexSignature && secondMember.kind === ts.SyntaxKind.IndexSignature) {
-                        var firstIndexSignature = firstMember;
-                        var secondIndexSignature = secondMember;
-                        var firstIndexType = firstIndexSignature.parameters[0].type;
-                        var secondIndexType = secondIndexSignature.parameters[0].type;
-                        if (firstIndexType.kind === ts.SyntaxKind.StringKeyword && secondIndexType.kind === ts.SyntaxKind.NumberKeyword) {
-                            var valueType = firstIndexSignature.type;
-                            return this.resolveType(valueType, writer);
-                        }
-                    }
-                }
-            }
-            // 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());
-        }
-        var type = typeNode.getText();
-        return this.resolveTypeFromString(type, writer);
-    };
-    Compiler.prototype.resolveTypeFromString = function (type, writer) {
-        var resolved = writer.resolveTypeName(type);
-        return resolved || type;
-    };
-    Compiler.prototype.isArrayType = function (typeNode) {
-        if (!typeNode)
-            return false;
-        // check if its an array
-        if (typeNode.kind === ts.SyntaxKind.ArrayType) {
-            return true;
-        }
-        // check if its Array<> or map
-        if (typeNode.kind === ts.SyntaxKind.TypeReference) {
-            var typeReference = typeNode;
-            if (typeReference.typeName.getText() === "Array") {
-                return true;
-            }
-            else if (typeReference.typeName.getText() === "Map") {
-                return true;
-            }
-        }
-        // check if its array or dictionary
-        if (typeNode.kind === ts.SyntaxKind.TypeLiteral) {
-            var typeLiteral = typeNode;
-            if (typeLiteral.members.length === 2) {
-                var first = typeLiteral.members[0];
-                var second = typeLiteral.members[1];
-                if (first.kind === ts.SyntaxKind.IndexSignature && second.kind === ts.SyntaxKind.IndexSignature) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    };
-    Compiler.prototype.resolveExpression = function (node, writer) {
-        var _this = this;
-        if (ts.isStringLiteral(node)) {
-            return this.resolveTypeFromString(node.text, writer);
-        }
-        else if (ts.isNumericLiteral(node)) {
-            return this.resolveTypeFromString(node.text, writer);
-        }
-        else if (ts.isIdentifier(node)) {
-            return this.resolveTypeFromString(node.text, writer);
-        }
-        // is true or false
-        else if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) {
-            return this.resolveTypeFromString(node.getText(), writer);
-        }
-        else if (ts.isPropertyAccessExpression(node)) {
-            var left = this.resolveExpression(node.expression, writer);
-            if (left) {
-                return left + "." + this.resolveTypeFromString(node.name.text, writer);
-            }
-        }
-        else if (ts.isCallExpression(node)) {
-            var left = this.resolveExpression(node.expression, writer);
-            if (left) {
-                var args = node.arguments.map(function (a) { return _this.resolveExpression(a, writer); }).filter(function (a) { return a; });
-                return left + "(" + args.join(", ") + ")";
-            }
-        }
-        else if (ts.isBinaryExpression(node)) {
-            var left = this.resolveExpression(node.left, writer);
-            var right = this.resolveExpression(node.right, writer);
-            if (left && right) {
-                return left + " " + node.operatorToken.getText() + " " + right;
-            }
-        }
-        else if (ts.isPrefixUnaryExpression(node)) {
-            var operand = this.resolveExpression(node.operand, writer);
-            if (operand) {
-                return node.operator + operand;
-            }
-        }
-        else if (ts.isPostfixUnaryExpression(node)) {
-            var operand = this.resolveExpression(node.operand, writer);
-            if (operand) {
-                return operand + node.operator;
-            }
-        }
-        else if (ts.isParenthesizedExpression(node)) {
-            return this.resolveExpression(node.expression, writer);
-        }
-        else if (ts.isArrayLiteralExpression(node)) {
-            var elements = node.elements.map(function (e) { return _this.resolveExpression(e, writer); }).filter(function (e) { return e; });
-            return "[" + elements.join(", ") + "]";
-        }
-        else if (ts.isObjectLiteralExpression(node)) {
-            var properties = node.properties.map(function (p) {
-                if (ts.isPropertyAssignment(p)) {
-                    var name_2 = p.name.getText();
-                    var value = _this.resolveExpression(p.initializer, writer);
-                    if (value) {
-                        return name_2 + ": " + value;
-                    }
-                }
-            }).filter(function (p) { return p; });
-            return "{" + properties.join(", ") + "}";
-        }
-        else if (ts.isNewExpression(node)) {
-            var typeName = this.resolveTypeFromString(node.expression.getText(), writer);
-            if (typeName) {
-                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());
-    };
-    return Compiler;
-}());
-exports.Compiler = Compiler;

package/src/blender-compiler.js

@@ -1,100 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.BlenderWriter = void 0;
-var base_compiler_1 = require("./base-compiler");
-var commands_1 = require("./commands");
-var supportedTypes = ["string", "float", "int", "bool", "col", "obj", "evt", "fn"];
-var BlenderWriter = /** @class */ (function () {
-    function BlenderWriter(outputDirectory) {
-        this.writer = new base_compiler_1.CodeTextWriter();
-        this.outputDirectory = outputDirectory;
-    }
-    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 "any":
-                return "any";
-            case "vector2":
-                return "vec2";
-            case "color":
-                return "col";
-            case "renderer":
-                return "comp";
-            case "eventlist":
-                return "evt";
-        }
-    };
-    BlenderWriter.prototype.begin = function () {
-        // this.writer.beginBlock("{")
-    };
-    BlenderWriter.prototype.end = function () {
-        // this.writer.endBlock("}");
-        // this.writer.flush(this.outputFilePath);
-    };
-    BlenderWriter.prototype.startNewType = function (typeName, baseType, comments) {
-        if (baseType !== "Behaviour")
-            return false;
-        this.writer.beginBlock("{");
-        if (comments)
-            console.log(comments);
-        this.writer.beginBlock("\"" + typeName + "\": {");
-    };
-    BlenderWriter.prototype.endNewType = function (typeName) {
-        this.writer.endBlock("},");
-        this.writer.endBlock("}");
-        this.writeScheme(typeName);
-    };
-    BlenderWriter.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
-        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("\"isArray\": true");
-        }
-        this.writer.endBlock("},");
-    };
-    BlenderWriter.prototype.writeMethod = function (visibility, name, returnType, args, comments) {
-        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 (component) {
-        var outputPath = this.writer.flush(this.outputDirectory, component + ".component.json");
-        if (outputPath)
-            (0, commands_1.sendFileWrittenCommand)(outputPath);
-    };
-    return BlenderWriter;
-}());
-exports.BlenderWriter = BlenderWriter;
-// runFromFile(new BlenderWriter("dist"), "src\\test.ts");

package/src/commands.js

@@ -1,11 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.sendFileWrittenCommand = exports.sendReloadCommand = void 0;
-function sendReloadCommand() {
-    process.stdout.write("CMD:reload\r");
-}
-exports.sendReloadCommand = sendReloadCommand;
-function sendFileWrittenCommand(path) {
-    process.stdout.write("CMD:writefile " + path + "\r");
-}
-exports.sendFileWrittenCommand = sendFileWrittenCommand;

package/src/watcher.js

@@ -1,64 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.DirectoryWatcher = void 0;
-var fs = require("fs");
-var base_compiler_1 = require("./base-compiler");
-var blender_compiler_1 = require("./blender-compiler");
-var chokidar = require("chokidar");
-var commands_1 = require("./commands");
-// https://github.com/paulmillr/chokidar
-var DirectoryWatcher = /** @class */ (function () {
-    function DirectoryWatcher() {
-        this.compiler = new base_compiler_1.Compiler();
-        this._needReload = false;
-    }
-    DirectoryWatcher.prototype.startWatching = function (dir, writer) {
-        var _this = this;
-        // console.log("Start watching", dir);
-        chokidar.watch(dir + "/**/*.ts").on('all', function (event, path) {
-            try {
-                switch (event) {
-                    case "add":
-                        console.log("File", path, "has been added");
-                        break;
-                    case "change":
-                        console.log("File", path, "has been changed");
-                        _this.compiler.compile(writer, fs.readFileSync(path).toString());
-                        _this._needReload = true;
-                        break;
-                    case "unlink":
-                        console.log("File", path, "has been removed");
-                        break;
-                    default:
-                        console.log("File unhandled event", event, path);
-                }
-            }
-            catch (err) {
-                console.error(err);
-            }
-        });
-        // call reload cmd 
-        setInterval(function () {
-            if (_this._needReload) {
-                _this._needReload = false;
-                (0, commands_1.sendReloadCommand)();
-            }
-        }, 2000);
-    };
-    return DirectoryWatcher;
-}());
-exports.DirectoryWatcher = DirectoryWatcher;
-// listen to process exit 
-process.on('exit', function () {
-    console.log('Bye node');
-});
-var args = process.argv.slice(2);
-if (args.length < 2) {
-    console.error("Missing arguments, usage: node watcher.js <directory> <output>");
-    process.exit(1);
-}
-var directoryToWatch = args[0].replace("\"", "");
-var outputDirectory = args[1].replace("\"", "");
-console.log("Watch: " + directoryToWatch + " and output to: " + outputDirectory);
-var watcher = new DirectoryWatcher();
-watcher.startWatching(directoryToWatch, new blender_compiler_1.BlenderWriter(outputDirectory));