@needle-tools/needle-component-compiler 2.1.0-pre → 2.2.0-pre.1

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).
 
+## [2.2.0-pre.1] - 2022-11-13
+- Add: watcher now also generates the register_types file
+- Add: deleting code files now also deletes the generated files and reports it
+
 ## [2.1.0-pre] - 2022-11-12
 - Add blender scheme compiler for creating and updating schemes (or removing them when the component gets deleted)
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/needle-component-compiler",
-    "version": "2.1.0-pre",
+    "version": "2.2.0-pre.1",
     "description": "Compile mock unity components from typescript",
     "main": "index.js",
     "scripts": {
@@ -28,7 +28,8 @@
                 "src/base-compiler.ts",
                 "src/blender-compiler.ts",
                 "src/component-compiler.ts",
-                "src/watcher.ts"
+                "src/watcher.ts",
+                "src/register-types.ts"
             ],
             "ignore": "src/test.ts",
             "extensions": "ts",

package/src/base-compiler.js

@@ -1,9 +1,10 @@
 "use strict";
-exports.__esModule = true;
-exports.Compiler = exports.runFromFile = exports.CodeTextWriter = exports.Visibility = void 0;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Compiler = exports.runFromFile = exports.handleDeletedFile = exports.CodeTextWriter = exports.Visibility = void 0;
 var fs_1 = require("fs");
 var ts = require("typescript");
 var fs = require("fs");
+var commands_1 = require("./commands");
 var Visibility;
 (function (Visibility) {
     Visibility[Visibility["Public"] = 0] = "Public";
@@ -35,11 +36,15 @@ var CodeTextWriter = /** @class */ (function () {
         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()));
+        var lines = line.split(/\r?\n/);
+        for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+            var line_1 = lines_1[_i];
+            // remove whitespace so we can ensure we correctly end with a comma
+            this.lines.push(indent + (line_1 === null || line_1 === void 0 ? void 0 : line_1.trim()));
+        }
     };
     CodeTextWriter.prototype.write = function (text) {
-        var lines = text.split("\r");
+        var lines = text.split(/\r?\n/);
         if (lines.length > 1) {
             for (var i = 0; i < lines.length; i++) {
                 this.writeLine(lines[i]);
@@ -71,15 +76,53 @@ var CodeTextWriter = /** @class */ (function () {
             fs.mkdirSync(directory, { recursive: true });
         }
         console.log("Writing " + filename + " to " + directory);
-        var content = this.lines.join("\r");
+        var content = this.toString();
         this.lines.length = 0;
         var fullPath = directory + "/" + filename;
         fs.writeFileSync(fullPath, content);
         return fs.realpathSync(fullPath);
     };
+    CodeTextWriter.prototype.clear = function () {
+        this.lines.length = 0;
+    };
+    CodeTextWriter.prototype.toString = function () {
+        return this.lines.join("\r");
+    };
     return CodeTextWriter;
 }());
 exports.CodeTextWriter = CodeTextWriter;
+function handleDeletedFile(filePath, types) {
+    if (!fs.existsSync(filePath)) {
+        var infos = types[filePath];
+        if (!infos)
+            return;
+        for (var i = 0; i < infos.length; i++) {
+            var info = infos[i];
+            // check if the source file is in any other file
+            var found = false;
+            for (var otherSourceFile in types) {
+                if (otherSourceFile == filePath)
+                    continue;
+                for (var _i = 0, _a = types[otherSourceFile]; _i < _a.length; _i++) {
+                    var otherInfo = _a[_i];
+                    if (otherInfo.filePath == info.filePath) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (found)
+                    break;
+                if (fs.existsSync(info.filePath)) {
+                    fs.rmSync(info.filePath);
+                    (0, commands_1.sendFileDeletedCommand)(info.filePath);
+                    infos.splice(i, 1);
+                    i--;
+                }
+            }
+        }
+    }
+}
+exports.handleDeletedFile = handleDeletedFile;
 function runFromFile(writer, path) {
     if (!fs.existsSync(path)) {
         console.error("File not found", path);

package/src/blender-compiler.js

@@ -1,17 +1,31 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlenderWriter = void 0;
 var fs_1 = require("fs");
 var base_compiler_1 = require("./base-compiler");
 var commands_1 = require("./commands");
-var supportedTypes = ["string", "float", "int", "bool", "col", "obj", "evt", "fn"];
+var supportedTypes = ["string", "float", "int", "bool", "col", "obj", "evt", "fn", "vec2", "vec3"];
 var BlenderWriter = /** @class */ (function () {
     function BlenderWriter(outputDirectory) {
         this.writer = new base_compiler_1.CodeTextWriter();
-        this.createdSchemesPerFile = {};
-        this.currentlyProcessingFiles = {};
-        this.outputDirectory = outputDirectory;
+        this._createdSchemesPerFile = {};
+        this._currentlyProcessingFiles = {};
+        this._outputDirectory = outputDirectory;
     }
+    Object.defineProperty(BlenderWriter.prototype, "outputInfo", {
+        get: function () {
+            return this._createdSchemesPerFile;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BlenderWriter.prototype, "outputDirectory", {
+        get: function () {
+            return this._outputDirectory;
+        },
+        enumerable: false,
+        configurable: true
+    });
     BlenderWriter.prototype.resolveTypeName = function (typeName, comments) {
         typeName = typeName.toLocaleLowerCase();
         if (typeName.startsWith("three."))
@@ -27,57 +41,67 @@ var BlenderWriter = /** @class */ (function () {
                 return "string";
             case "void":
                 return "void";
-            case "any":
-                return "any";
             case "vector2":
                 return "vec2";
+            case "vector3":
+                return "vec3";
+            case "vector4":
+                return "vec4";
+            case "quaternion":
+                return "quat";
+            case "euler":
+                return "vec3";
             case "color":
                 return "col";
-            case "renderer":
-                return "comp";
             case "eventlist":
                 return "evt";
+            case "renderer":
+                return "comp";
         }
     };
     BlenderWriter.prototype.begin = function (filePath) {
-        if (!this.currentlyProcessingFiles[filePath]) {
-            this.currentlyProcessingFiles[filePath] = [];
+        if (!this._currentlyProcessingFiles[filePath]) {
+            this._currentlyProcessingFiles[filePath] = [];
         }
-        // this.writer.beginBlock("{")
     };
     BlenderWriter.prototype.end = function (filePath) {
-        var results = this.currentlyProcessingFiles[filePath];
+        var results = this._currentlyProcessingFiles[filePath];
         console.log("Writing schemes for", filePath, results);
         if (results) {
-            var previousResultsFromThisFile = this.createdSchemesPerFile[filePath];
+            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);
+                    var foundInAny = false;
+                    for (var _a = 0, results_1 = results; _a < results_1.length; _a++) {
+                        var res = results_1[_a];
+                        if (res.filePath === previouslyCreated.filePath) {
+                            foundInAny = true;
+                            break;
+                        }
+                    }
                     if (!foundInAny) {
-                        for (var sourcePath in this.createdSchemesPerFile) {
+                        for (var sourcePath in this._createdSchemesPerFile) {
                             if (foundInAny)
                                 break;
                             if (sourcePath === filePath)
                                 continue;
-                            var otherSourceSchemes = this.createdSchemesPerFile[sourcePath];
+                            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);
+                    if (!foundInAny && (0, fs_1.existsSync)(previouslyCreated.filePath)) {
+                        (0, fs_1.unlinkSync)(previouslyCreated.filePath);
+                        (0, commands_1.sendFileDeletedCommand)(previouslyCreated.filePath);
                     }
                 }
             }
-            this.createdSchemesPerFile[filePath] = results;
+            this._createdSchemesPerFile[filePath] = results;
         }
-        delete this.currentlyProcessingFiles[filePath];
-        // this.writer.endBlock("}");
-        // this.writer.flush(this.outputFilePath);
+        delete this._currentlyProcessingFiles[filePath];
     };
     BlenderWriter.prototype.startNewType = function (filePath, typeName, baseType, comments) {
         if (baseType !== "Behaviour")
@@ -93,6 +117,8 @@ var BlenderWriter = /** @class */ (function () {
         this.writeScheme(filePath, typeName);
     };
     BlenderWriter.prototype.writeMember = function (visibility, name, isArray, type, initialValue, comments) {
+        if (visibility !== base_compiler_1.Visibility.Public)
+            return;
         if (!supportedTypes.includes(type)) {
             console.log("-- unsupported type:", type);
             return;
@@ -118,6 +144,8 @@ var BlenderWriter = /** @class */ (function () {
         this.writer.endBlock("},");
     };
     BlenderWriter.prototype.writeMethod = function (visibility, name, returnType, args, comments) {
+        if (visibility !== base_compiler_1.Visibility.Public)
+            return;
         this.writer.beginBlock("\"" + name + "\": {");
         this.writer.writeLine("\"type\": \"fn\",");
         this.writer.endBlock("},");
@@ -126,13 +154,13 @@ var BlenderWriter = /** @class */ (function () {
         console.log("new type:", typeName);
     };
     BlenderWriter.prototype.writeScheme = function (processingFilePath, component) {
-        var outputPath = this.writer.flush(this.outputDirectory, component + ".component.json");
+        var outputPath = this.writer.flush(this._outputDirectory, component + ".component.json");
         // 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);
+            if (processingFilePath && this._currentlyProcessingFiles[processingFilePath]) {
+                this._currentlyProcessingFiles[processingFilePath].push({ componentName: component, filePath: outputPath });
             }
         }
     };

package/src/commands.js

@@ -1,5 +1,5 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendFileDeletedCommand = exports.sendFileWrittenCommand = exports.sendReloadCommand = void 0;
 function sendReloadCommand() {
     process.stdout.write("CMD:reload\r");

package/src/component-compiler.js

@@ -1,5 +1,5 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.run = exports.compile = void 0;
 var fs_1 = require("fs");
 var ts = require("typescript");

package/src/register-types.js

@@ -0,0 +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;

package/src/test.js

@@ -1,5 +1,5 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 //@type("MyComponent")
 // export class CameraView extends Behaviour {
 //     static views: CameraView[] = [];

package/src/watcher.js

@@ -1,18 +1,19 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.DirectoryWatcher = void 0;
 var fs = require("fs");
 var base_compiler_1 = require("./base-compiler");
 var blender_compiler_1 = require("./blender-compiler");
 var chokidar = require("chokidar");
 var commands_1 = require("./commands");
+var register_types_1 = require("./register-types");
 // https://github.com/paulmillr/chokidar
 var DirectoryWatcher = /** @class */ (function () {
     function DirectoryWatcher() {
         this.compiler = new base_compiler_1.Compiler();
-        this._needReload = false;
+        this._typesChanged = false;
     }
-    DirectoryWatcher.prototype.startWatching = function (dir, writer) {
+    DirectoryWatcher.prototype.startWatching = function (dir, writer, registerTypesPath) {
         var _this = this;
         // console.log("Start watching", dir);
         chokidar.watch(dir + "/**/*.ts").on('all', function (event, path) {
@@ -21,15 +22,17 @@ var DirectoryWatcher = /** @class */ (function () {
                     case "add":
                         console.log("File", path, "has been added");
                         _this.compiler.compile(writer, fs.readFileSync(path).toString(), path);
-                        _this._needReload = true;
+                        _this._typesChanged = true;
                         break;
                     case "change":
                         console.log("File", path, "has been changed");
                         _this.compiler.compile(writer, fs.readFileSync(path).toString(), path);
-                        _this._needReload = true;
+                        _this._typesChanged = true;
                         break;
                     case "unlink":
                         console.log("File", path, "has been removed");
+                        (0, base_compiler_1.handleDeletedFile)(path, writer.outputInfo);
+                        _this._typesChanged = true;
                         break;
                     default:
                         console.log("File unhandled event", event, path);
@@ -41,9 +44,10 @@ var DirectoryWatcher = /** @class */ (function () {
         });
         // call reload cmd 
         setInterval(function () {
-            if (_this._needReload) {
-                _this._needReload = false;
+            if (_this._typesChanged) {
+                _this._typesChanged = false;
                 (0, commands_1.sendReloadCommand)();
+                (0, register_types_1.writeTypeRegistry)(writer.outputInfo, registerTypesPath);
             }
         }, 2000);
     };
@@ -55,18 +59,19 @@ 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>");
+if (args.length < 3) {
+    console.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");
     process.exit(1);
 }
 if (fs.existsSync(outputDirectory))
-    fs.rmdirSync(outputDirectory, { recursive: true });
+    fs.rmSync(outputDirectory, { recursive: true });
 console.log("Watch: " + directoryToWatch + " and output to: " + outputDirectory);
 var watcher = new DirectoryWatcher();
-watcher.startWatching(directoryToWatch, new blender_compiler_1.BlenderWriter(outputDirectory));
+watcher.startWatching(directoryToWatch, new blender_compiler_1.BlenderWriter(outputDirectory), registerTypesPath);

package/test/component.basic.test.js

@@ -1,5 +1,5 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 var helpers_1 = require("./helpers");
 describe('Basic typescript', function () {
     it('should generate component', function () {

package/test/component.methods.test.js

@@ -1,5 +1,5 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 var helpers_1 = require("./helpers");
 describe('Typescript with public methods', function () {
     it('should generate component with public method', function () {

package/test/component.nonserialized.test.js

@@ -1,5 +1,5 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 var helpers_1 = require("./helpers");
 describe('Typescript with nonSerialized', function () {
     it('should ignore field', function () {

package/test/component.primitives.test.js

@@ -1,5 +1,5 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 var helpers_1 = require("./helpers");
 describe('Typescript with fields', function () {
     it('should generate component with number', function () {

package/test/helpers.js

@@ -1,5 +1,5 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.compareCodegenWithDefaultContext = exports.compareCodegen = exports.testCompile = void 0;
 var component_compiler_1 = require("../src/component-compiler");
 var chai_1 = require("chai");

package/tsconfig.json

@@ -1,5 +1,6 @@
 {
     "compilerOptions": {
+        "target": "es5",
         "types": [
             "mocha",
             "node"