@needle-tools/needle-component-compiler 1.9.2-exp → 2.1.0-pre

package/Changelog.md

@@ -4,8 +4,8 @@ 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).
 
-## [1.9.2-exp] - 2022-11-12
-- Add first version of blender scheme compiler
+## [2.1.0-pre] - 2022-11-12
+- Add blender scheme compiler for creating and updating schemes (or removing them when the component gets deleted)
 
 ## [1.9.1] - 2022-11-05
 - Fix ``new Vector2(1, .5)`` generating invalid C# where number arguments were emitted as double instead of float

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "1.9.2-exp",
+    "version": "2.1.0-pre",
     "description": "Compile mock unity components from typescript",
     "main": "index.js",
     "scripts": {

package/src/base-compiler.js

@@ -55,15 +55,15 @@ var CodeTextWriter = /** @class */ (function () {
             }
         }
     };
-    CodeTextWriter.prototype.beginArray = function () {
-        this.writeLine("[");
-        this.indent++;
-    };
-    CodeTextWriter.prototype.insertArrayItem = function (item) {
-        this.writeLine(item + ",");
-    };
-    CodeTextWriter.prototype.endArray = function () {
-    };
+    // beginArray() {
+    //     this.writeLine("[");
+    //     this.indent++;
+    // }
+    // insertArrayItem(item: string) {
+    //     this.writeLine(item + ",");
+    // }
+    // endArray() {
+    // }
     CodeTextWriter.prototype.flush = function (directory, filename) {
         if (this.lines.length === 0)
             return;
@@ -87,31 +87,32 @@ function runFromFile(writer, path) {
     }
     var code = (0, fs_1.readFileSync)(path).toString();
     var compiler = new Compiler();
-    compiler.compile(writer, code);
+    compiler.compile(writer, code, path);
     return compiler;
 }
 exports.runFromFile = runFromFile;
 var Compiler = /** @class */ (function () {
     function Compiler() {
     }
-    Compiler.prototype.compile = function (writer, code) {
+    Compiler.prototype.compile = function (writer, code, sourceFilePath) {
         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);
+        this.run(prog, writer, sourceFile, sourceFilePath);
     };
-    Compiler.prototype.run = function (prog, writer, sourceFile) {
+    Compiler.prototype.run = function (prog, writer, sourceFile, filePath) {
         var _this = this;
-        writer.begin();
+        console.log("Starting compilation of " + filePath);
+        writer.begin(filePath);
         ts.forEachChild(sourceFile, function (node) {
-            _this.visit(node, writer);
+            _this.visit(filePath, node, writer);
         });
-        writer.end();
+        writer.end(filePath);
     };
-    Compiler.prototype.visit = function (node, writer) {
+    Compiler.prototype.visit = function (filePath, node, writer) {
         var _this = this;
         if (ts.isClassDeclaration(node)) {
-            this.visitClassDeclaration(node, writer);
+            this.visitClassDeclaration(filePath, node, writer);
         }
         else if (ts.isPropertyDeclaration(node)) {
             this.visitPropertyDeclaration(node, writer);
@@ -121,24 +122,24 @@ var Compiler = /** @class */ (function () {
         }
         else {
             ts.forEachChild(node, function (node) {
-                _this.visit(node, writer);
+                _this.visit(filePath, node, writer);
             });
         }
     };
-    Compiler.prototype.visitClassDeclaration = function (node, writer) {
+    Compiler.prototype.visitClassDeclaration = function (filePath, 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));
+        var res = writer.startNewType(filePath, name, base, this.getComments(node));
         if (res === false) {
             this.debugLog("CLASS SKIPPED", name);
             return;
         }
         ts.forEachChild(node, function (node) {
-            _this.visit(node, writer);
+            _this.visit(filePath, node, writer);
         });
-        writer.endNewType(name);
+        writer.endNewType(filePath, name);
         this.debugLog("CLASS END", name, "\n");
     };
     Compiler.prototype.visitPropertyDeclaration = function (node, writer) {

package/src/blender-compiler.js

@@ -1,12 +1,15 @@
 "use strict";
 exports.__esModule = 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"];
 var BlenderWriter = /** @class */ (function () {
     function BlenderWriter(outputDirectory) {
         this.writer = new base_compiler_1.CodeTextWriter();
+        this.createdSchemesPerFile = {};
+        this.currentlyProcessingFiles = {};
         this.outputDirectory = outputDirectory;
     }
     BlenderWriter.prototype.resolveTypeName = function (typeName, comments) {
@@ -36,14 +39,47 @@ var BlenderWriter = /** @class */ (function () {
                 return "evt";
         }
     };
-    BlenderWriter.prototype.begin = function () {
+    BlenderWriter.prototype.begin = function (filePath) {
+        if (!this.currentlyProcessingFiles[filePath]) {
+            this.currentlyProcessingFiles[filePath] = [];
+        }
         // this.writer.beginBlock("{")
     };
-    BlenderWriter.prototype.end = function () {
+    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 = results.includes(previouslyCreated);
+                    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)) {
+                        (0, fs_1.unlinkSync)(previouslyCreated);
+                        (0, commands_1.sendFileDeletedCommand)(previouslyCreated);
+                    }
+                }
+            }
+            this.createdSchemesPerFile[filePath] = results;
+        }
+        delete this.currentlyProcessingFiles[filePath];
         // this.writer.endBlock("}");
         // this.writer.flush(this.outputFilePath);
     };
-    BlenderWriter.prototype.startNewType = function (typeName, baseType, comments) {
+    BlenderWriter.prototype.startNewType = function (filePath, typeName, baseType, comments) {
         if (baseType !== "Behaviour")
             return false;
         this.writer.beginBlock("{");
@@ -51,10 +87,10 @@ var BlenderWriter = /** @class */ (function () {
             console.log(comments);
         this.writer.beginBlock("\"" + typeName + "\": {");
     };
-    BlenderWriter.prototype.endNewType = function (typeName) {
+    BlenderWriter.prototype.endNewType = function (filePath, typeName) {
         this.writer.endBlock("},");
         this.writer.endBlock("}");
-        this.writeScheme(typeName);
+        this.writeScheme(filePath, typeName);
     };
     BlenderWriter.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
         if (!supportedTypes.includes(type)) {
@@ -89,10 +125,16 @@ var BlenderWriter = /** @class */ (function () {
     BlenderWriter.prototype.writeNewTypeExpression = function (typeName, args) {
         console.log("new type:", typeName);
     };
-    BlenderWriter.prototype.writeScheme = function (component) {
+    BlenderWriter.prototype.writeScheme = function (processingFilePath, component) {
         var outputPath = this.writer.flush(this.outputDirectory, component + ".component.json");
-        if (outputPath)
+        // if an output path is returned it means a file has been written to that path
+        if (outputPath) {
             (0, commands_1.sendFileWrittenCommand)(outputPath);
+            // add the scheme to the list of created schemes
+            if (processingFilePath && this.currentlyProcessingFiles[processingFilePath]) {
+                this.currentlyProcessingFiles[processingFilePath].push(outputPath);
+            }
+        }
     };
     return BlenderWriter;
 }());

package/src/commands.js

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

package/src/test.js

@@ -1,34 +1,5 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 exports.__esModule = true;
-exports.MyTestComponent = void 0;
-var MyTestComponent = /** @class */ (function (_super) {
-    __extends(MyTestComponent, _super);
-    function MyTestComponent() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.myVector2 = new Vector2(1, .5);
-        _this.myNumber = 1;
-        return _this;
-    }
-    MyTestComponent.prototype.myMethod = function () {
-    };
-    return MyTestComponent;
-}(Behaviour));
-exports.MyTestComponent = MyTestComponent;
 //@type("MyComponent")
 // export class CameraView extends Behaviour {
 //     static views: CameraView[] = [];

package/src/watcher.js

@@ -20,10 +20,12 @@ var DirectoryWatcher = /** @class */ (function () {
                 switch (event) {
                     case "add":
                         console.log("File", path, "has been added");
+                        _this.compiler.compile(writer, fs.readFileSync(path).toString(), path);
+                        _this._needReload = true;
                         break;
                     case "change":
                         console.log("File", path, "has been changed");
-                        _this.compiler.compile(writer, fs.readFileSync(path).toString());
+                        _this.compiler.compile(writer, fs.readFileSync(path).toString(), path);
                         _this._needReload = true;
                         break;
                     case "unlink":
@@ -50,7 +52,7 @@ var DirectoryWatcher = /** @class */ (function () {
 exports.DirectoryWatcher = DirectoryWatcher;
 // listen to process exit 
 process.on('exit', function () {
-    console.log('Bye node');
+    // console.log('Bye node');
 });
 var args = process.argv.slice(2);
 if (args.length < 2) {
@@ -59,6 +61,12 @@ if (args.length < 2) {
 }
 var directoryToWatch = args[0].replace("\"", "");
 var outputDirectory = args[1].replace("\"", "");
+if (!fs.existsSync(directoryToWatch)) {
+    console.error("Directory to watch does not exist");
+    process.exit(1);
+}
+if (fs.existsSync(outputDirectory))
+    fs.rmdirSync(outputDirectory, { recursive: true });
 console.log("Watch: " + directoryToWatch + " and output to: " + outputDirectory);
 var watcher = new DirectoryWatcher();
 watcher.startWatching(directoryToWatch, new blender_compiler_1.BlenderWriter(outputDirectory));