tnp 19.0.19 → 19.0.21

package/lib/project/cli/cli-_GLOBAL_.backend.js

@@ -0,0 +1,1730 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$Global = void 0;
+var tslib_1 = require("tslib");
+//#region imports
+var incremental_compiler_1 = require("incremental-compiler");
+var project_1 = require("../abstract/project");
+var tnp_config_1 = require("tnp-config");
+var tnp_core_1 = require("tnp-core");
+var tnp_core_2 = require("tnp-core");
+var tnp_config_2 = require("tnp-config");
+var tnp_helpers_1 = require("tnp-helpers");
+var tnp_core_3 = require("tnp-core");
+var psList = require("ps-list");
+var magic_renamer_1 = require("magic-renamer");
+var semver = require("semver");
+var lodash_walk_object_1 = require("lodash-walk-object");
+var ts_json_schema_generator_1 = require("ts-json-schema-generator");
+var tnp_core_4 = require("tnp-core");
+var options_1 = require("../../options");
+var constants_1 = require("../../constants");
+//#endregion
+var $Global = /** @class */ (function (_super) {
+    tslib_1.__extends($Global, _super);
+    function $Global() {
+        var _this = _super.apply(this, tslib_1.__spreadArray([], tslib_1.__read(arguments), false)) || this;
+        //#endregion
+        //#region show messages
+        _this.ASYNC_PROC = function (args) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var p;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                global.tnpShowProgress = true;
+                p = tnp_helpers_1.Helpers.run("".concat(tnp_config_1.config.frameworkName, " show:loop ").concat(args), {
+                    output: false,
+                    cwd: this.cwd,
+                }).async();
+                p.stdout.on('data', function (chunk) {
+                    console.log('prod:' + chunk);
+                });
+                p.on('exit', function (c) {
+                    console.log('process exited with code: ' + c);
+                    _this._exit();
+                });
+                return [2 /*return*/];
+            });
+        }); };
+        _this.SYNC_PROC = function (args) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var p;
+            return tslib_1.__generator(this, function (_a) {
+                global.tnpShowProgress = true;
+                try {
+                    p = tnp_helpers_1.Helpers.run("".concat(tnp_config_1.config.frameworkName, " show:loop ").concat(args), {
+                        output: false,
+                        cwd: this.cwd,
+                    }).sync();
+                    this._exit();
+                }
+                catch (err) {
+                    console.log('Erroroejk');
+                    this._exit(1);
+                }
+                return [2 /*return*/];
+            });
+        }); };
+        //#endregion
+        //#region file info
+        _this.FILEINFO = function (args) {
+            console.log(tnp_helpers_1.Helpers.getMostRecentFilesNames((0, tnp_core_2.crossPlatformPath)(_this.cwd)));
+            _this._exit();
+        };
+        return _this;
+        //#endregion
+    }
+    $Global.prototype._ = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.ins.taonProjectsWorker.infoScreen()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#region kill process on port
+    $Global.prototype.killonport = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var port;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        port = parseInt(this.firstArg);
+                        return [4 /*yield*/, tnp_helpers_1.Helpers.killProcessByPort(port)];
+                    case 1:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region kill all node processes
+    $Global.prototype.killAllNode = function () {
+        tnp_helpers_1.Helpers.killAllNode();
+        this._exit();
+    };
+    //#endregion
+    //#region kill vscode processes
+    $Global.prototype.killAllCode = function () {
+        if (process.platform === 'win32') {
+            tnp_helpers_1.Helpers.run("taskkill /f /im code.exe").sync();
+            this._exit();
+        }
+        else {
+            tnp_helpers_1.Helpers.run("fkill -f code").sync();
+        }
+        this._exit();
+    };
+    //#endregion
+    //#region fork
+    $Global.prototype.fork = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var argv, githubUrl, projectName, newProj;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        argv = this.args;
+                        githubUrl = tnp_core_2._.first(argv);
+                        projectName = tnp_core_2._.last(githubUrl.replace('.git', '').split('/'));
+                        if (argv.length > 1) {
+                            projectName = argv[1];
+                        }
+                        tnp_helpers_1.Helpers.info("Forking ".concat(githubUrl, " with name ").concat(projectName));
+                        return [4 /*yield*/, this.project.git.clone(githubUrl, projectName)];
+                    case 1:
+                        _a.sent();
+                        newProj = project_1.Project.ins.From(tnp_core_2.path.join(this.project.location, projectName));
+                        tnp_helpers_1.Helpers.setValueToJSON(tnp_core_2.path.join(newProj.location, tnp_config_1.config.file.package_json), 'name', projectName);
+                        tnp_helpers_1.Helpers.setValueToJSON(tnp_core_2.path.join(newProj.location, tnp_config_1.config.file.package_json), 'version', '0.0.0');
+                        if (!newProj.containsFile('angular.json')) return [3 /*break*/, 3];
+                        tnp_helpers_1.Helpers.setValueToJSON(tnp_core_2.path.join(newProj.location, tnp_config_1.config.file.package_json), 'tnp.type', 'angular-lib');
+                        tnp_helpers_1.Helpers.setValueToJSON(tnp_core_2.path.join(newProj.location, tnp_config_1.config.file.package_json), 'tnp.version', 'v2');
+                        tnp_helpers_1.Helpers.setValueToJSON(tnp_core_2.path.join(newProj.location, tnp_config_1.config.file.package_json), 'scripts', {});
+                        // const dependencies = Helpers.readValueFromJson(path.join(newProj.location, config.file.package_json), 'dependencies') as Object;
+                        return [4 /*yield*/, newProj.init('forking project')];
+                    case 2:
+                        // const dependencies = Helpers.readValueFromJson(path.join(newProj.location, config.file.package_json), 'dependencies') as Object;
+                        _a.sent();
+                        newProj = project_1.Project.ins.From(tnp_core_2.path.join(this.project.location, projectName));
+                        newProj.removeFile('.browserslistrc');
+                        _a.label = 3;
+                    case 3:
+                        tnp_helpers_1.Helpers.writeFile(tnp_core_2.path.join(newProj.location, tnp_config_1.config.file.README_MD), "\n  # ".concat(projectName, "\n\n  based on ").concat(githubUrl, "\n\n    "));
+                        tnp_helpers_1.Helpers.run("code ".concat(newProj.location)).sync();
+                        tnp_helpers_1.Helpers.info("Done");
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region watcher linux
+    $Global.prototype.watchersfix = function () {
+        tnp_helpers_1.Helpers.run("echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p").sync();
+        this._exit();
+    };
+    $Global.prototype.watchers = function () {
+        tnp_helpers_1.Helpers.run("find /proc/*/fd -user \"$USER\" -lname anon_inode:inotify -printf '%hinfo/%f\n' 2>/dev/null | xargs cat | grep -c '^inotify'").sync();
+        this._exit();
+    };
+    //#endregion
+    //#region code instal ext
+    $Global.prototype.code = function () {
+        this.project.run("code --install-extension ".concat(this.args.join(' '))).sync();
+        this._exit();
+    };
+    //#endregion
+    //#region proper watcher test
+    $Global.prototype.PROPERWATCHERTEST = function (engine) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var proj, watchLocation, symlinkCatalog, symlinkCatalogInWatch, symlinkCatalogFile, options;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        proj = this.project;
+                        watchLocation = (0, tnp_core_2.crossPlatformPath)([proj.location, tnp_config_1.config.folder.src]);
+                        symlinkCatalog = (0, tnp_core_2.crossPlatformPath)([proj.location, 'symlinkCatalog']);
+                        symlinkCatalogInWatch = (0, tnp_core_2.crossPlatformPath)([watchLocation, 'symlink']);
+                        symlinkCatalogFile = (0, tnp_core_2.crossPlatformPath)([
+                            proj.location,
+                            'symlinkCatalog',
+                            'aaa.txt',
+                        ]);
+                        options = {
+                            name: "[taon]  properwatchtest (testing only)",
+                            ignoreInitial: true,
+                        };
+                        tnp_helpers_1.Helpers.remove(symlinkCatalog);
+                        tnp_helpers_1.Helpers.writeFile(symlinkCatalogFile, 'hello aaa');
+                        tnp_helpers_1.Helpers.writeFile((0, tnp_core_2.crossPlatformPath)([proj.location, tnp_config_1.config.folder.src, 'a1', 'aa']), 'asdasdasdhello aaa');
+                        tnp_helpers_1.Helpers.writeFile((0, tnp_core_2.crossPlatformPath)([proj.location, tnp_config_1.config.folder.src, 'a2', 'ccc']), 'heasdasdllo asdasd');
+                        tnp_helpers_1.Helpers.createSymLink(symlinkCatalog, symlinkCatalogInWatch);
+                        return [4 /*yield*/, (0, incremental_compiler_1.incrementalWatcher)(watchLocation, options)];
+                    case 1:
+                        (_a.sent()).on('all', function (a, b) {
+                            console.log('FIRSTA', a, b);
+                        });
+                        return [4 /*yield*/, (0, incremental_compiler_1.incrementalWatcher)(watchLocation, options)];
+                    case 2:
+                        (_a.sent()).on('all', function (a, b) {
+                            console.log('SECOND', a, b);
+                        });
+                        return [4 /*yield*/, (0, incremental_compiler_1.incrementalWatcher)(symlinkCatalog, options)];
+                    case 3:
+                        (_a.sent()).on('all', function (a, b) {
+                            console.log('THIRD', a, b);
+                        });
+                        console.log('await done');
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region add import src
+    /**
+     * @deprecated
+     */
+    $Global.prototype.ADD_IMPORT_SRC = function () {
+        var e_1, _a;
+        var project = this.project;
+        var regexEnd = /from\s+(\'|\").+(\'|\")/g;
+        var singleLineImporrt = /import\((\'|\"|\`).+(\'|\"|\`)\)/g;
+        var singleLineRequire = /require\((\'|\"|\`).+(\'|\"|\`)\)/g;
+        var srcEnd = /\/src(\'|\"|\`)/;
+        var betweenApos = /(\'|\"|\`).+(\'|\"|\`)/g;
+        var commentMultilieStart = /^\/\*/;
+        var commentSingleLineStart = /^\/\//;
+        var processAddSrcAtEnd = function (regexEnd, line, packages, matchType) {
+            var matches = line.match(regexEnd);
+            var firstMatch = tnp_core_2._.first(matches);
+            var importMatch = tnp_core_2._.first(firstMatch.match(betweenApos)).replace(/(\'|\"|\`)/g, '');
+            var isOrg = importMatch.startsWith('@');
+            var packageName = importMatch
+                .split('/')
+                .slice(0, isOrg ? 2 : 1)
+                .join('/');
+            if (packages.includes(packageName) && !srcEnd.test(firstMatch)) {
+                var clean = void 0;
+                if (matchType === 'require' || matchType === 'imports') {
+                    var endCharacters = firstMatch.slice(-2);
+                    clean =
+                        firstMatch.slice(0, firstMatch.length - 2) + '/src' + endCharacters;
+                }
+                else {
+                    var endCharacters = firstMatch.slice(-1);
+                    clean =
+                        firstMatch.slice(0, firstMatch.length - 1) + '/src' + endCharacters;
+                }
+                return line.replace(firstMatch, clean);
+            }
+            return line;
+        };
+        var changeImport = function (content, packages) {
+            return (content
+                .split(/\r?\n/)
+                .map(function (line, index) {
+                var trimedLine = line.trimStart();
+                if (commentMultilieStart.test(trimedLine) ||
+                    commentSingleLineStart.test(trimedLine)) {
+                    return line;
+                }
+                if (regexEnd.test(line)) {
+                    return processAddSrcAtEnd(regexEnd, line, packages, 'from_import_export');
+                }
+                if (singleLineImporrt.test(line)) {
+                    return processAddSrcAtEnd(singleLineImporrt, line, packages, 'imports');
+                }
+                if (singleLineRequire.test(line)) {
+                    return processAddSrcAtEnd(singleLineRequire, line, packages, 'require');
+                }
+                return line;
+            })
+                .join('\n') + '\n');
+        };
+        var addImportSrc = function (proj) {
+            var e_2, _a;
+            var pacakges = tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(proj.allIsomorphicPackagesFromMemory), false), tslib_1.__read((proj.__isSmartContainerChild
+                ? proj.parent.children.map(function (c) { return "@".concat(proj.parent.name, "/").concat(c.name); })
+                : [])), false);
+            // console.log(pacakges)
+            var files = tnp_helpers_1.Helpers.filesFrom(proj.pathFor('src'), true).filter(function (f) {
+                return f.endsWith('.ts');
+            });
+            try {
+                for (var files_1 = tslib_1.__values(files), files_1_1 = files_1.next(); !files_1_1.done; files_1_1 = files_1.next()) {
+                    var file = files_1_1.value;
+                    var originalContent = tnp_helpers_1.Helpers.readFile(file);
+                    var changed = changeImport(originalContent, pacakges);
+                    if (originalContent &&
+                        changed &&
+                        (originalContent === null || originalContent === void 0 ? void 0 : originalContent.trim().replace(/\s/g, '')) !==
+                            (changed === null || changed === void 0 ? void 0 : changed.trim().replace(/\s/g, ''))) {
+                        tnp_helpers_1.Helpers.writeFile(file, changed);
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (files_1_1 && !files_1_1.done && (_a = files_1.return)) _a.call(files_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        };
+        if (project.__isStandaloneProject) {
+            addImportSrc(project);
+        }
+        else if (project.__isContainer) {
+            try {
+                for (var _b = tslib_1.__values(project.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var child = _c.value;
+                    addImportSrc(child);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        this._exit();
+    };
+    //#endregion
+    //#region move js to ts
+    $Global.prototype.$MOVE_JS_TO_TS = function (args) {
+        tnp_helpers_1.Helpers.filesFrom((0, tnp_core_2.crossPlatformPath)([this.cwd, args]), true).forEach(function (f) {
+            if (tnp_core_2.path.extname(f) === '.js') {
+                tnp_helpers_1.Helpers.move(f, (0, tnp_core_2.crossPlatformPath)([
+                    tnp_core_2.path.dirname(f),
+                    tnp_core_2.path.basename(f).replace('.js', '.ts'),
+                ]));
+            }
+        });
+        tnp_helpers_1.Helpers.info('DONE');
+        this._exit();
+    };
+    $Global.prototype.SHOW_RANDOM_HAMSTERS = function () {
+        while (true) {
+            var arr = ['Pluszla', 'Łapczuch', 'Misia', 'Chrupka'];
+            console.log(arr[tnp_helpers_1.Helpers.numbers.randomInteger(0, arr.length - 1)]);
+            tnp_helpers_1.Helpers.sleep(1);
+        }
+    };
+    $Global.prototype.SHOW_RANDOM_HAMSTERS_TYPES = function () {
+        while (true) {
+            var arr = [
+                'djungarian',
+                'syrian golden',
+                'syrian teddy bear',
+                'dwarf roborowski',
+                'dwarf russian',
+                'dwarf winter white',
+                'chinese hamster',
+            ];
+            console.log(arr[tnp_helpers_1.Helpers.numbers.randomInteger(0, arr.length - 1)]);
+            tnp_helpers_1.Helpers.sleep(1);
+        }
+    };
+    $Global.prototype.SHOW_LOOP_MESSAGES = function (args) {
+        console.log("\n\n    platform: ".concat(process.platform, "\n    terminal: ").concat(tnp_core_1.UtilsProcess.getBashOrShellName(), "\n\n    "));
+        global.tnpShowProgress = true;
+        console.log('process pid', process.pid);
+        console.log('process ppid', process.ppid);
+        // process.on('SIGTERM', () => {
+        //   this._exit()
+        // })
+        this._SHOW_LOOP_MESSAGES();
+    };
+    $Global.prototype.newTermMessages = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                tnp_core_1.UtilsProcess.startInNewTerminalWindow("tnp showloopmessages 10");
+                this._exit();
+                return [2 /*return*/];
+            });
+        });
+    };
+    $Global.prototype._SHOW_LOOP = function (c, maximum, errExit) {
+        var _this = this;
+        if (c === void 0) { c = 0; }
+        if (maximum === void 0) { maximum = Infinity; }
+        if (errExit === void 0) { errExit = false; }
+        if (tnp_core_2._.isString(c)) {
+            var _a = require('minimist')(c.split(' ')), _b = _a.max, max = _b === void 0 ? Infinity : _b, _c = _a.err, err = _c === void 0 ? false : _c;
+            maximum = max;
+            errExit = err;
+            // console.log('max',max)
+            // console.log('err',err)
+            c = 0;
+        }
+        if (c === maximum) {
+            this._exit(errExit ? 1 : 0);
+        }
+        console.log("counter: ".concat(c));
+        setTimeout(function () {
+            _this._SHOW_LOOP(++c, maximum, errExit);
+        }, 1000);
+    };
+    $Global.prototype._SHOW_LOOP_MESSAGES = function (c, maximum, errExit, throwErr) {
+        var _this = this;
+        if (c === void 0) { c = 0; }
+        if (maximum === void 0) { maximum = Infinity; }
+        if (errExit === void 0) { errExit = false; }
+        if (throwErr === void 0) { throwErr = false; }
+        if (tnp_core_2._.isString(c)) {
+            var obj = require('minimist')(c.split(' '));
+            var _a = obj.max, max = _a === void 0 ? Infinity : _a, _b = obj.err, err = _b === void 0 ? false : _b;
+            maximum = tnp_core_2._.isNumber(max) ? max : Infinity;
+            errExit = err;
+            throwErr = obj.throw;
+            // console.log('max',max)
+            // console.log('err',err)
+            c = 0;
+        }
+        if (c === maximum) {
+            if (throwErr) {
+                throw new Error('Custom error!');
+            }
+            if (errExit) {
+                this._exit(1);
+            }
+            this._exit();
+        }
+        console.log("counter: ".concat(c));
+        tnp_core_2.PROGRESS_DATA.log({ msg: "counter: ".concat(c), value: c * 7 });
+        setTimeout(function () {
+            _this._SHOW_LOOP_MESSAGES(++c, maximum, errExit, throwErr);
+        }, 2000);
+    };
+    //#endregion
+    //#region ln
+    $Global.prototype.LN = function () {
+        var _a = tslib_1.__read(this.args, 2), source = _a[0], dest = _a[1];
+        tnp_helpers_1.Helpers.createSymLink(source, dest);
+        this._exit();
+    };
+    //#endregion
+    //#region dedupe
+    $Global.prototype.DEDUPE = function () {
+        this.project.__node_modules.dedupe(this.args.join(' ').trim() === '' ? void 0 : this.args);
+        this._exit();
+    };
+    $Global.prototype.DEDUPE_COUNT = function () {
+        this.project.__node_modules.dedupeCount(this.args);
+        this._exit();
+    };
+    //#endregion
+    //#region deps
+    $Global.prototype.DEPS_SHOW = function () {
+        this.project.__packageJson.showDeps('deps show');
+        this._exit();
+    };
+    $Global.prototype.DEPS_HIDE = function () {
+        if (this.project.__isCoreProject) {
+            this.project.__packageJson.showDeps('deps show');
+        }
+        else {
+            this.project.__packageJson.hideDeps('deps hide');
+        }
+        this._exit();
+    };
+    /**
+     * generate deps json
+     */
+    $Global.prototype.DEPS_JSON = function () {
+        var node_moduels = tnp_core_2.path.join(this.cwd, tnp_config_1.config.folder.node_modules);
+        var result = {};
+        tnp_helpers_1.Helpers.foldersFrom(node_moduels)
+            .filter(function (f) { return tnp_core_2.path.basename(f) !== '.bin'; })
+            .forEach(function (f) {
+            var packageName = tnp_core_2.path.basename(f);
+            if (packageName.startsWith('@')) {
+                var orgPackageRootName_1 = packageName;
+                tnp_helpers_1.Helpers.foldersFrom(f).forEach(function (f2) {
+                    try {
+                        result["".concat(orgPackageRootName_1, "/").concat(tnp_core_2.path.basename(f2))] =
+                            tnp_helpers_1.Helpers.readValueFromJson(tnp_core_2.path.join(f2, tnp_config_1.config.file.package_json), 'version', '');
+                    }
+                    catch (error) { }
+                });
+            }
+            else {
+                try {
+                    result[packageName] = tnp_helpers_1.Helpers.readValueFromJson(tnp_core_2.path.join(f, tnp_config_1.config.file.package_json), 'version', '');
+                }
+                catch (error) { }
+            }
+        });
+        tnp_helpers_1.Helpers.writeJson(tnp_core_2.path.join(this.cwd, tnp_config_1.config.file.result_packages_json), result);
+        this._exit();
+    };
+    //#endregion
+    //#region reinstall
+    $Global.prototype.reinstallCore = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, ((_a = this.project.coreContainer) === null || _a === void 0 ? void 0 : _a.__npmPackages.installFromArgs(''))];
+                    case 1:
+                        _b.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    $Global.prototype.REINSTALL = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var proj, children, index, c;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        proj = this.project;
+                        if (!proj.__isContainer) return [3 /*break*/, 7];
+                        if (!proj.__isContainerCoreProject) return [3 /*break*/, 2];
+                        tnp_helpers_1.Helpers.taskStarted("Removing old node_modules for core container ".concat(proj.__frameworkVersion));
+                        proj.__node_modules.remove();
+                        tnp_helpers_1.Helpers.taskDone("Removed old node_modules for core container ".concat(proj.__frameworkVersion));
+                        return [4 /*yield*/, proj.__npmPackages.installFromArgs('')];
+                    case 1:
+                        _a.sent();
+                        tnp_helpers_1.Helpers.info("Reinstal done for core container");
+                        return [3 /*break*/, 6];
+                    case 2:
+                        children = proj.children.filter(function (c) {
+                            return c.__frameworkVersionAtLeast('v3') &&
+                                c.typeIs('isomorphic-lib') &&
+                                c.__npmPackages.useLinkAsNodeModules;
+                        });
+                        index = 0;
+                        _a.label = 3;
+                    case 3:
+                        if (!(index < children.length)) return [3 /*break*/, 6];
+                        c = children[index];
+                        tnp_helpers_1.Helpers.info("Recreating node_module for ".concat(c.genericName));
+                        c.__node_modules.remove();
+                        return [4 /*yield*/, c.init('initing after reinstall')];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5:
+                        index++;
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 10];
+                    case 7:
+                        if (!proj.__isStandaloneProject) return [3 /*break*/, 9];
+                        proj.__node_modules.remove();
+                        return [4 /*yield*/, proj.__npmPackages.installFromArgs('')];
+                    case 8:
+                        _a.sent();
+                        return [3 /*break*/, 10];
+                    case 9:
+                        tnp_helpers_1.Helpers.error("[".concat(tnp_config_1.config.frameworkName, "] This project does not support reinsall.\n    location: ").concat(proj === null || proj === void 0 ? void 0 : proj.location, "\n    "), false, false);
+                        _a.label = 10;
+                    case 10:
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region versions
+    $Global.prototype.VERSIONS = function () {
+        var children = this.project.children;
+        for (var index = 0; index < children.length; index++) {
+            var child = children[index];
+            tnp_helpers_1.Helpers.info("v".concat(child.__packageJson.data.version, "\t - ").concat(child.genericName));
+        }
+        this._exit();
+    };
+    //#endregion
+    //#region path
+    $Global.prototype.path = function () {
+        console.log(project_1.Project.ins.Tnp.location);
+        this._exit();
+    };
+    //#endregion
+    //#region env
+    $Global.prototype.ENV_CHECK = function (args) {
+        tnp_helpers_1.Helpers.checkEnvironment();
+        this._exit();
+    };
+    $Global.prototype.ENV_INSTALL = function () {
+        tnp_core_3.CLI.installEnvironment(tnp_core_1.requiredForDev);
+        this._exit();
+    };
+    //#endregion
+    //#region throw error
+    $Global.prototype.THROW_ERR = function () {
+        tnp_helpers_1.Helpers.error("Erororoororo here", false, true);
+    };
+    //#endregion
+    //#region brew
+    $Global.prototype.BREW = function (args) {
+        var isM1MacOS = tnp_core_2.os.cpus()[0].model.includes('Apple M1');
+        if (process.platform === 'darwin') {
+            if (isM1MacOS) {
+                tnp_helpers_1.Helpers.run("arch -x86_64 brew ".concat(args)).sync();
+            }
+            else {
+                tnp_helpers_1.Helpers.run("brew ".concat(args)).sync();
+            }
+        }
+        this._exit();
+    };
+    //#endregion
+    //#region version
+    $Global.prototype.version = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var tnpProj, taonProj;
+            return tslib_1.__generator(this, function (_a) {
+                // Helpers.log(`Framework name: '${config.frameworkName}'`);
+                //#region @notForNpm
+                if (ENV.notForNpm) {
+                    tnp_helpers_1.Helpers.success("I am secret project!!!");
+                }
+                tnpProj = project_1.Project.ins.Tnp;
+                taonProj = project_1.Project.ins.From([
+                    tnp_core_2.fse.realpathSync(tnp_core_2.path.dirname(tnpProj.location)),
+                    tnp_config_1.config.frameworkNames.productionFrameworkName,
+                ]);
+                tnp_helpers_1.Helpers.success("\n\n  Taon: ".concat((taonProj === null || taonProj === void 0 ? void 0 : taonProj.version) ? "v".concat(taonProj.version) : '-', "\n  Tnp: ").concat((tnpProj === null || tnpProj === void 0 ? void 0 : tnpProj.version) ? "v".concat(tnpProj.version) : '-', "\n\n    "));
+                this._exit();
+                return [2 /*return*/];
+            });
+        });
+    };
+    //#endregion
+    //#region run
+    $Global.prototype.run = function () {
+        tnp_helpers_1.Helpers.run("node run.js", {
+            output: true,
+            silence: false,
+        }).sync();
+        this._exit(0);
+    };
+    //#endregion
+    //#region ps info
+    $Global.prototype.PSINFO = function (args) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var pid, ps, psinfo;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pid = Number(args);
+                        return [4 /*yield*/, psList()];
+                    case 1:
+                        ps = _a.sent();
+                        psinfo = ps.find(function (p) { return p.pid == pid; });
+                        if (!psinfo) {
+                            tnp_helpers_1.Helpers.error("No process found with pid: ".concat(args), false, true);
+                        }
+                        console.log(psinfo);
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region init core porjects
+    $Global.prototype.INIT_CORE = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var allCoreProject, index, projectToInit, linkedFiles, index2, l, source, dest;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tnp_helpers_1.Helpers.taskStarted("".concat(tnp_config_1.config.frameworkName, " initing core projects"));
+                        allCoreProject = [];
+                        tnp_config_1.config.coreProjectVersions.forEach(function (v) {
+                            var corePorjectsTypes = ['isomorphic-lib'];
+                            var projects = corePorjectsTypes.map(function (t) { return project_1.Project.by(t, v); });
+                            allCoreProject = tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(projects), false), tslib_1.__read(allCoreProject), false);
+                        });
+                        index = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(index < allCoreProject.length)) return [3 /*break*/, 4];
+                        projectToInit = allCoreProject[index];
+                        tnp_helpers_1.Helpers.log("".concat(projectToInit.genericName, " ").concat(projectToInit.location));
+                        linkedFiles = projectToInit.__projectLinkedFiles();
+                        for (index2 = 0; index2 < linkedFiles.length; index2++) {
+                            l = linkedFiles[index2];
+                            source = tnp_core_2.path.join(l.sourceProject.location, l.relativePath);
+                            dest = tnp_core_2.path.join(projectToInit.location, l.relativePath);
+                            if (!tnp_helpers_1.Helpers.exists(source)) {
+                                tnp_helpers_1.Helpers.error("[".concat(tnp_config_1.config.frameworkName, "] Core source do not exists: ").concat(source), false, true);
+                            }
+                            tnp_helpers_1.Helpers.log("".concat(tnp_config_1.config.frameworkName, " link from: ").concat(source, " to ").concat(dest));
+                            tnp_helpers_1.Helpers.createSymLink(source, dest, {
+                                continueWhenExistedFolderDoesntExists: true,
+                            });
+                        }
+                        return [4 /*yield*/, projectToInit.struct()];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        index++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        tnp_helpers_1.Helpers.taskDone('DONE');
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region sync core repositories
+    $Global.prototype.SYNC = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                project_1.Project.sync({ syncFromCommand: true });
+                this._exit();
+                return [2 /*return*/];
+            });
+        });
+    };
+    //#endregion
+    //#region copy and rename (vscode option)
+    $Global.prototype.$COPY_AND_RENAME = function (args) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var ins;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ins = magic_renamer_1.MagicRenamer.Instance(this.cwd);
+                        return [4 /*yield*/, ins.start(args, true)];
+                    case 1:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region generate
+    $Global.prototype.GENERATE = function (args) {
+        var argsv = args.split(' ');
+        var _a = tslib_1.__read(argsv, 3), absPath = _a[0], moduleName = _a[1], entityName = _a[2];
+        if (!tnp_helpers_1.Helpers.exists(absPath)) {
+            tnp_helpers_1.Helpers.mkdirp(absPath);
+        }
+        var absFilePath = (0, tnp_core_2.crossPlatformPath)(absPath);
+        if (!tnp_helpers_1.Helpers.isFolder(absPath)) {
+            absPath = (0, tnp_core_2.crossPlatformPath)(tnp_core_2.path.dirname(absPath));
+        }
+        entityName = decodeURIComponent(entityName);
+        var nearestProj = project_1.Project.ins.nearestTo(this.cwd);
+        // console.log({
+        //   nearestProj: nearestProj?.location
+        // })
+        var container = project_1.Project.by('container', nearestProj.__frameworkVersion);
+        if (container.__frameworkVersionLessThan('v3')) {
+            container = project_1.Project.by('container', tnp_config_1.config.defaultFrameworkVersion);
+        }
+        var myEntity = 'my-entity';
+        var flags = {
+            flat: '_flat',
+            custom: '_custom',
+        };
+        var isFlat = moduleName.includes(flags.flat);
+        moduleName = moduleName.replace(flags.flat, '');
+        var isCustom = moduleName.includes(flags.custom);
+        moduleName = moduleName.replace(flags.custom, '');
+        var exampleLocation = (0, tnp_core_2.crossPlatformPath)([
+            container.location,
+            "gen-examples-".concat(container.__frameworkVersion),
+            moduleName,
+            myEntity,
+        ]);
+        var newEntityName = tnp_core_1.UtilsString.kebabCaseNoSplitNumbers(entityName);
+        var generatedCodeAbsLoc = (0, tnp_core_2.crossPlatformPath)([
+            container.location,
+            "gen-examples-".concat(container.__frameworkVersion),
+            moduleName,
+            newEntityName,
+        ]);
+        tnp_helpers_1.Helpers.remove(generatedCodeAbsLoc, true);
+        var destination = (0, tnp_core_2.crossPlatformPath)([absPath, newEntityName]);
+        if (isFlat) {
+            destination = (0, tnp_core_2.crossPlatformPath)(tnp_core_2.path.dirname(destination));
+        }
+        if (isCustom) {
+            //#region handle custom cases
+            if (moduleName === 'generated-index-exports') {
+                var folders = tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(tnp_helpers_1.Helpers.foldersFrom(absPath).map(function (f) { return tnp_core_2.path.basename(f); })), false), tslib_1.__read(tnp_helpers_1.Helpers.filesFrom(absPath, false).map(function (f) { return tnp_core_2.path.basename(f); })), false).filter(function (f) { return !['index.ts'].includes(f); })
+                    .filter(function (f) { return !f.startsWith('.'); })
+                    .filter(function (f) { return !f.startsWith('_'); })
+                    .filter(function (f) {
+                    return tnp_core_2._.isUndefined(tnp_config_2.notNeededForExportFiles.find(function (e) { return f.endsWith(e); }));
+                })
+                    .filter(function (f) {
+                    return tnp_core_2.path.extname(f) === '' ||
+                        !tnp_core_2._.isUndefined(tnp_config_2.extAllowedToExportAndReplaceTSJSCodeFiles.find(function (a) {
+                            return f.endsWith(a);
+                        }));
+                });
+                tnp_helpers_1.Helpers.writeFile((0, tnp_core_2.crossPlatformPath)([absPath, tnp_config_1.config.file.index_ts]), folders
+                    .map(function (f) {
+                    if (!tnp_core_2._.isUndefined(tnp_config_2.frontendFiles.find(function (bigExt) { return f.endsWith(bigExt); }))) {
+                        "".concat(tnp_config_2.TAGS.COMMENT_REGION, " ").concat(tnp_config_2.TAGS.BROWSER, "\n") +
+                            "export * from './".concat(f.replace(tnp_core_2.path.extname(f), ''), "';") +
+                            +"\n".concat(tnp_config_2.TAGS.COMMENT_END_REGION, "\n");
+                    }
+                    if (!tnp_core_2._.isUndefined(tnp_config_2.backendNodejsOnlyFiles.find(function (bigExt) { return f.endsWith(bigExt); }))) {
+                        return ("".concat(tnp_config_2.TAGS.COMMENT_REGION, " ").concat(tnp_config_2.TAGS.BACKEND, "\n") +
+                            "export * from './".concat(f.replace(tnp_core_2.path.extname(f), ''), "';") +
+                            +"\n".concat(tnp_config_2.TAGS.COMMENT_END_REGION, "\n"));
+                    }
+                    return "export * from './".concat(f.replace(tnp_core_2.path.extname(f), ''), "';");
+                })
+                    .join('\n') + '\n');
+            }
+            if (moduleName === 'wrap-with-browser-regions') {
+                if (!tnp_helpers_1.Helpers.isFolder(absFilePath)) {
+                    var content = tnp_helpers_1.Helpers.readFile(absFilePath);
+                    tnp_helpers_1.Helpers.writeFile(absFilePath, "".concat(tnp_config_2.TAGS.COMMENT_REGION, " ").concat(tnp_config_2.TAGS.BROWSER, "\n") +
+                        content +
+                        "\n".concat(tnp_config_2.TAGS.COMMENT_END_REGION, "\n"));
+                }
+            }
+            //#endregion
+        }
+        else {
+            var ins = magic_renamer_1.MagicRenamer.Instance(exampleLocation);
+            ins.start("".concat(myEntity, " -> ").concat(newEntityName), true);
+            if (isFlat) {
+                var files = tnp_helpers_1.Helpers.filesFrom(generatedCodeAbsLoc, true);
+                for (var index = 0; index < files.length; index++) {
+                    var fileAbsPath = (0, tnp_core_2.crossPlatformPath)(files[index]);
+                    var relative = fileAbsPath.replace(generatedCodeAbsLoc + '/', '');
+                    var destFileAbsPath = (0, tnp_core_2.crossPlatformPath)([destination, relative]);
+                    tnp_helpers_1.Helpers.copyFile(fileAbsPath, destFileAbsPath);
+                }
+                tnp_helpers_1.Helpers.remove(generatedCodeAbsLoc, true);
+            }
+            else {
+                tnp_helpers_1.Helpers.move(generatedCodeAbsLoc, destination);
+            }
+        }
+        console.info('GENERATION DONE');
+        this._exit(0);
+    };
+    //#endregion
+    //#region clear
+    $Global.prototype.CLEAN = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.project.clear()];
+                    case 1:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    $Global.prototype.CLEAR = function () {
+        this.CLEAN();
+    };
+    $Global.prototype.CL = function () {
+        this.CLEAN();
+    };
+    //#endregion
+    //#region show git in progress
+    $Global.prototype.inprogress = function () {
+        tnp_helpers_1.Helpers.info("\n    In progress\n".concat(this.project.children
+            .filter(function (f) {
+            return f.git
+                .lastCommitMessage()
+                .startsWith(tnp_helpers_1.Helpers.git.ACTION_MSG_RESET_GIT_HARD_COMMIT);
+        })
+            .map(function (c, index) { return "".concat(index + 1, ". ").concat(c.genericName); }), "\n\n    "));
+        this._exit();
+    };
+    //#endregion
+    //#region prettier
+    $Global.prototype.prettier = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tnp_helpers_1.Helpers.info("Initing before prettier...");
+                        return [4 /*yield*/, this.project.init('initing before prettier')];
+                    case 1:
+                        _a.sent();
+                        tnp_helpers_1.Helpers.info("Running prettier...");
+                        this.project.formatAllFiles();
+                        tnp_helpers_1.Helpers.info("Prettier done");
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region update deps for core container
+    $Global.prototype.updatedeps = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var allDeps, getLatestVersionFromNpm, checkIfPackageVersionAvailable, getLastMajorVersions, getLastMinorVersionsForMajor, getVerObj, allDepsKeys, _loop_1, this_1, out_index_1, index;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.project || !this.project.__isCoreProject) {
+                            tnp_helpers_1.Helpers.error("This command is only for core projects", false, true);
+                        }
+                        allDeps = this.project.npmHelpers.allDependencies;
+                        getLatestVersionFromNpm = function (packageName) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var res, json;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, fetch("https://registry.npmjs.org/".concat(packageName, "/latest"))];
+                                    case 1:
+                                        res = _a.sent();
+                                        return [4 /*yield*/, res.json()];
+                                    case 2:
+                                        json = _a.sent();
+                                        return [2 /*return*/, json.version];
+                                }
+                            });
+                        }); };
+                        checkIfPackageVersionAvailable = function (pkgName, pkgVersion) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var res;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, fetch("https://registry.npmjs.org/".concat(pkgName, "/").concat(pkgVersion))];
+                                    case 1:
+                                        res = _a.sent();
+                                        return [2 /*return*/, res.status === 200];
+                                }
+                            });
+                        }); };
+                        getLastMajorVersions = function (pkgName) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var res, json_1, error_1;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        _a.trys.push([0, 3, , 4]);
+                                        return [4 /*yield*/, fetch("https://registry.npmjs.org/".concat(pkgName))];
+                                    case 1:
+                                        res = _a.sent();
+                                        return [4 /*yield*/, res.json()];
+                                    case 2:
+                                        json_1 = _a.sent();
+                                        return [2 /*return*/, Object.keys(json_1.versions).filter(function (v) {
+                                                return v.startsWith(json_1['dist-tags'].latest.split('.')[0]);
+                                            })];
+                                    case 3:
+                                        error_1 = _a.sent();
+                                        return [2 /*return*/, []];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        getLastMinorVersionsForMajor = function (majorVer, pkgName) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var res, json, error_2;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        _a.trys.push([0, 3, , 4]);
+                                        return [4 /*yield*/, fetch("https://registry.npmjs.org/".concat(pkgName))];
+                                    case 1:
+                                        res = _a.sent();
+                                        return [4 /*yield*/, res.json()];
+                                    case 2:
+                                        json = _a.sent();
+                                        return [2 /*return*/, Object.keys(json.versions).filter(function (v) {
+                                                return v.startsWith("".concat(majorVer, "."));
+                                            })];
+                                    case 3:
+                                        error_2 = _a.sent();
+                                        return [2 /*return*/, []];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        getVerObj = function (version) {
+                            return version
+                                .replace('^', '')
+                                .replace('~', '')
+                                .split('.')
+                                .map(Number)
+                                .reduce(function (acc, c, i) {
+                                var _a, _b, _c;
+                                if (i === 0) {
+                                    return tslib_1.__assign(tslib_1.__assign({}, acc), (_a = {}, _a['major'] = c, _a));
+                                }
+                                else if (i === 1) {
+                                    return tslib_1.__assign(tslib_1.__assign({}, acc), (_b = {}, _b['minor'] = c, _b));
+                                }
+                                else {
+                                    return tslib_1.__assign(tslib_1.__assign({}, acc), (_c = {}, _c['patch'] = c, _c));
+                                }
+                            }, {});
+                        };
+                        allDepsKeys = Object.keys(allDeps);
+                        _loop_1 = function (index) {
+                            var packageName, currentPackageVersion, currentVerObj, taonJsonContent, tags, getLastVersions, latestToUpdate, latestVerObj, isTheSameVersion, isOnlyMajorpdate, isOnlyMinorUpdate, isOnlyPatchUpdate, trustedMajor, trustedMinor, trustedPath, notTrusted, automaticallyUpdate, someLastVersion, trustedMinorVersion, trustedPatchVersion, questionsForUpdate, whatToDo, _b, prefixOpt, prefix, _c, version, isAvailable, indexToSkip;
+                            return tslib_1.__generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        tnp_helpers_1.Helpers.clearConsole();
+                                        packageName = allDepsKeys[index];
+                                        currentPackageVersion = allDeps[packageName];
+                                        currentVerObj = getVerObj(currentPackageVersion);
+                                        taonJsonContent = this_1.project.readFile(tnp_config_1.config.file.taon_jsonc);
+                                        tags = tnp_core_2.Utils.json.getAtrributies(packageName, taonJsonContent);
+                                        tnp_helpers_1.Helpers.info("(".concat(index + 1, " / ").concat(allDepsKeys.length, ") ") +
+                                            "Downloading info about \"".concat(packageName, "\" (current ver: ").concat(currentPackageVersion, ")"));
+                                        getLastVersions = function (pkgName) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                            var someLastVersion, _a, _b, _c, _d, _e, _f, _g, _h;
+                                            return tslib_1.__generator(this, function (_j) {
+                                                switch (_j.label) {
+                                                    case 0:
+                                                        _b = (_a = tnp_helpers_1.Helpers).uniqArray;
+                                                        _c = [[]];
+                                                        return [4 /*yield*/, getLastMajorVersions(pkgName)];
+                                                    case 1:
+                                                        _d = [tslib_1.__spreadArray.apply(void 0, _c.concat([tslib_1.__read.apply(void 0, [(_j.sent())]), false]))];
+                                                        return [4 /*yield*/, getLastMinorVersionsForMajor(latestVerObj.major - 1, pkgName)];
+                                                    case 2:
+                                                        _e = [tslib_1.__spreadArray.apply(void 0, _d.concat([tslib_1.__read.apply(void 0, [(_j.sent())]), false]))];
+                                                        return [4 /*yield*/, getLastMinorVersionsForMajor(latestVerObj.major - 2, pkgName)];
+                                                    case 3:
+                                                        _f = [tslib_1.__spreadArray.apply(void 0, _e.concat([tslib_1.__read.apply(void 0, [(_j.sent())]), false]))];
+                                                        return [4 /*yield*/, getLastMinorVersionsForMajor(currentVerObj.major, pkgName)];
+                                                    case 4:
+                                                        _g = [tslib_1.__spreadArray.apply(void 0, _f.concat([tslib_1.__read.apply(void 0, [(_j.sent())]), false]))];
+                                                        return [4 /*yield*/, getLastMinorVersionsForMajor(currentVerObj.major - 1, pkgName)];
+                                                    case 5:
+                                                        _h = [tslib_1.__spreadArray.apply(void 0, _g.concat([tslib_1.__read.apply(void 0, [(_j.sent())]), false]))];
+                                                        return [4 /*yield*/, getLastMinorVersionsForMajor(currentVerObj.major - 2, pkgName)];
+                                                    case 6:
+                                                        someLastVersion = _b.apply(_a, [tslib_1.__spreadArray.apply(void 0, _h.concat([tslib_1.__read.apply(void 0, [(_j.sent())]), false]))])
+                                                            .sort(function (a, b) {
+                                                            var aVerObj = getVerObj(a);
+                                                            var bVerObj = getVerObj(b);
+                                                            if (aVerObj.major === bVerObj.major) {
+                                                                if (aVerObj.minor === bVerObj.minor) {
+                                                                    return aVerObj.patch - bVerObj.patch;
+                                                                }
+                                                                return aVerObj.minor - bVerObj.minor;
+                                                            }
+                                                            return aVerObj.major - bVerObj.major;
+                                                        })
+                                                            .reverse();
+                                                        return [2 /*return*/, someLastVersion];
+                                                }
+                                            });
+                                        }); };
+                                        return [4 /*yield*/, getLatestVersionFromNpm(packageName)];
+                                    case 1:
+                                        latestToUpdate = _d.sent();
+                                        latestVerObj = getVerObj(latestToUpdate);
+                                        isTheSameVersion = latestVerObj.major === currentVerObj.major &&
+                                            latestVerObj.minor === currentVerObj.minor &&
+                                            latestVerObj.patch === currentVerObj.patch;
+                                        isOnlyMajorpdate = latestVerObj.major >= currentVerObj.major;
+                                        isOnlyMinorUpdate = latestVerObj.major === currentVerObj.major &&
+                                            latestVerObj.minor > currentVerObj.minor;
+                                        isOnlyPatchUpdate = latestVerObj.major === currentVerObj.major &&
+                                            latestVerObj.minor === currentVerObj.minor &&
+                                            latestVerObj.patch > currentVerObj.patch;
+                                        trustedMajor = !!tags.find(function (c) { return c.name === '@trusted' && c.value === 'major'; });
+                                        trustedMinor = !!tags.find(function (c) { return c.name === '@trusted' && c.value === 'minor'; });
+                                        trustedPath = !!tags.find(function (c) { return c.name === '@trusted' && c.value === 'patch'; });
+                                        notTrusted = !tags.find(function (c) { return c.name === '@trusted'; });
+                                        if (notTrusted) {
+                                            console.log("Package \"".concat(packageName, "\" is not trusted. Skipping."));
+                                            return [2 /*return*/, (out_index_1 = index, "continue")];
+                                        }
+                                        automaticallyUpdate = (isOnlyMajorpdate && trustedMajor) ||
+                                            (isOnlyMinorUpdate && (trustedMajor || trustedMinor)) ||
+                                            (isOnlyPatchUpdate && (trustedMajor || trustedMinor || trustedPath));
+                                        //#endregion
+                                        if (currentPackageVersion === 'latest') {
+                                            console.log("Package \"".concat(packageName, "\" is set to latest. Skipping."));
+                                            return [2 /*return*/, (out_index_1 = index, "continue")];
+                                        }
+                                        if (isTheSameVersion) {
+                                            // await Helpers.questionYesNo('package is the same, continue ?');
+                                            this_1.project.npmHelpers.updateDependency({
+                                                packageName: packageName,
+                                                version: currentPackageVersion,
+                                                updateTaonJsonFirst: true,
+                                            });
+                                            return [2 /*return*/, (out_index_1 = index, "continue")];
+                                        }
+                                        if (!!automaticallyUpdate) return [3 /*break*/, 3];
+                                        return [4 /*yield*/, getLastVersions(packageName)];
+                                    case 2:
+                                        someLastVersion = _d.sent();
+                                        if (trustedMinor) {
+                                            trustedMinorVersion = someLastVersion.find(function (v) { return getVerObj(v).minor > currentVerObj.minor; });
+                                            if (trustedMinorVersion) {
+                                                latestToUpdate = trustedMinorVersion;
+                                                automaticallyUpdate = true;
+                                            }
+                                        }
+                                        if (trustedPath) {
+                                            trustedPatchVersion = someLastVersion.find(function (v) { return getVerObj(v).patch > currentVerObj.patch; });
+                                            if (trustedPatchVersion) {
+                                                latestToUpdate = trustedPatchVersion;
+                                                automaticallyUpdate = true;
+                                            }
+                                        }
+                                        if (!automaticallyUpdate) {
+                                            console.log("Can't update automatically. Latest versions for ".concat(packageName, ":\n\n") +
+                                                someLastVersion.map(function (v) { return "- ".concat(v); }).join('\n') +
+                                                '\n');
+                                        }
+                                        _d.label = 3;
+                                    case 3:
+                                        questionsForUpdate = {
+                                            //#region question for update options
+                                            update: {
+                                                name: "Update to latest version \"".concat(currentPackageVersion, "=>") +
+                                                    "".concat(tnp_core_2.chalk.bold.underline(latestToUpdate), "\" ") +
+                                                    "".concat(tags.length > 0
+                                                        ? '(' +
+                                                            tags
+                                                                .map(function (c) { return c.name + (c.value ? '=' + c.value : ''); })
+                                                                .join(',') +
+                                                            ')'
+                                                        : ''),
+                                            },
+                                            skip: {
+                                                name: 'Skip this package ?',
+                                            },
+                                            skipTo: {
+                                                name: 'Skip and got to package with index ?',
+                                            },
+                                            delete: {
+                                                name: 'Delete this package ?',
+                                            },
+                                            manual: {
+                                                name: 'Set version manually ?',
+                                            },
+                                            //#endregion
+                                        };
+                                        if (!automaticallyUpdate) return [3 /*break*/, 4];
+                                        _b = 'update';
+                                        return [3 /*break*/, 6];
+                                    case 4: return [4 /*yield*/, tnp_helpers_1.Helpers.selectChoicesAsk("(".concat(index + 1, " / ").concat(allDepsKeys.length, ") ") +
+                                            "".concat(tnp_core_2.chalk.gray('What to do with package ')) +
+                                            " \"".concat(tnp_core_2.chalk.bold(packageName), " ").concat(currentPackageVersion, "\" ?"), questionsForUpdate)];
+                                    case 5:
+                                        _b = _d.sent();
+                                        _d.label = 6;
+                                    case 6:
+                                        whatToDo = _b;
+                                        if (!(whatToDo === 'update')) return [3 /*break*/, 11];
+                                        prefixOpt = {
+                                            //#region prefix options
+                                            '~': {
+                                                name: "tilde (~) => ".concat(tnp_core_2.chalk.bold("~".concat(latestToUpdate))),
+                                            },
+                                            '^': {
+                                                name: "caret (^)  => ".concat(tnp_core_2.chalk.bold("^".concat(latestToUpdate))),
+                                            },
+                                            '': {
+                                                name: "no prefix => ".concat(tnp_core_2.chalk.bold("".concat(latestToUpdate))),
+                                            },
+                                            back: {
+                                                name: "-- go back -- => ".concat(tnp_core_2.chalk.bold("".concat(latestToUpdate))),
+                                            },
+                                            //#endregion
+                                        };
+                                        if (!automaticallyUpdate) return [3 /*break*/, 7];
+                                        _c = '~';
+                                        return [3 /*break*/, 9];
+                                    case 7: return [4 /*yield*/, tnp_helpers_1.Helpers.selectChoicesAsk('Select prefix', prefixOpt)];
+                                    case 8:
+                                        _c = _d.sent();
+                                        _d.label = 9;
+                                    case 9:
+                                        prefix = _c;
+                                        if (prefix === 'back') {
+                                            index--;
+                                            return [2 /*return*/, (out_index_1 = index, "continue")];
+                                        }
+                                        return [4 /*yield*/, this_1.project.npmHelpers.updateDep({
+                                                packageName: packageName,
+                                                version: "".concat(prefix).concat(latestToUpdate),
+                                                updateTaonJsonFirst: true,
+                                            })];
+                                    case 10:
+                                        _d.sent();
+                                        return [3 /*break*/, 26];
+                                    case 11:
+                                        if (!(whatToDo === 'delete')) return [3 /*break*/, 13];
+                                        return [4 /*yield*/, this_1.project.npmHelpers.updateDep({
+                                                packageName: packageName,
+                                                version: null,
+                                                updateTaonJsonFirst: true,
+                                            })];
+                                    case 12:
+                                        _d.sent();
+                                        return [3 /*break*/, 26];
+                                    case 13:
+                                        if (!(whatToDo === 'manual')) return [3 /*break*/, 21];
+                                        _d.label = 14;
+                                    case 14:
+                                        if (!true) return [3 /*break*/, 20];
+                                        return [4 /*yield*/, tnp_helpers_1.Helpers.input({
+                                                question: "Enter version for ".concat(packageName),
+                                                defaultValue: allDeps[packageName],
+                                            })];
+                                    case 15:
+                                        version = _d.sent();
+                                        console.log('Checking version...');
+                                        return [4 /*yield*/, checkIfPackageVersionAvailable(packageName, version)];
+                                    case 16:
+                                        isAvailable = _d.sent();
+                                        if (!isAvailable) return [3 /*break*/, 18];
+                                        return [4 /*yield*/, this_1.project.npmHelpers.updateDep({
+                                                packageName: packageName,
+                                                version: version,
+                                                updateTaonJsonFirst: true,
+                                            })];
+                                    case 17:
+                                        _d.sent();
+                                        return [3 /*break*/, 20];
+                                    case 18:
+                                        tnp_helpers_1.Helpers.error("Version ".concat(version, " not available on npm..."));
+                                        _d.label = 19;
+                                    case 19: return [3 /*break*/, 14];
+                                    case 20: return [3 /*break*/, 26];
+                                    case 21:
+                                        if (!(whatToDo === 'skipTo')) return [3 /*break*/, 25];
+                                        _d.label = 22;
+                                    case 22:
+                                        if (!true) return [3 /*break*/, 24];
+                                        return [4 /*yield*/, tnp_helpers_1.Helpers.input({
+                                                question: "Enter index to skip to",
+                                                defaultValue: "".concat(index),
+                                            })];
+                                    case 23:
+                                        indexToSkip = _d.sent();
+                                        index = Number(indexToSkip) - 1;
+                                        if (index >= 0 && index < allDepsKeys.length) {
+                                            return [3 /*break*/, 24];
+                                        }
+                                        return [3 /*break*/, 22];
+                                    case 24: return [3 /*break*/, 26];
+                                    case 25:
+                                        tnp_helpers_1.Helpers.info("Skipping ".concat(packageName));
+                                        _d.label = 26;
+                                    case 26:
+                                        out_index_1 = index;
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        index = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(index < allDepsKeys.length)) return [3 /*break*/, 4];
+                        return [5 /*yield**/, _loop_1(index)];
+                    case 2:
+                        _a.sent();
+                        index = out_index_1;
+                        _a.label = 3;
+                    case 3:
+                        index++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region compare containers
+    $Global.prototype.compareContainers = function () {
+        var e_3, _a;
+        tnp_helpers_1.Helpers.clearConsole();
+        var _b = tslib_1.__read(this.args, 2), c1ver = _b[0], c2ver = _b[1];
+        var c1 = project_1.Project.by('container', "v".concat(c1ver.replace('v', '')));
+        var c2 = project_1.Project.by('container', "v".concat(c2ver.replace('v', '')));
+        var c1Deps = c1.npmHelpers.allDependencies;
+        var c2Deps = c2.npmHelpers.allDependencies;
+        var displayCompare = function (depName, c1depVer, c2depVer) {
+            // console.log(`Comparing ${depName} ${c1depVer} => ${c2depVer}`);
+            c1depVer = tnp_helpers_1.UtilsNpm.fixMajorVerNumber(c1depVer);
+            c2depVer = tnp_helpers_1.UtilsNpm.fixMajorVerNumber(c2depVer);
+            if ([c1depVer, c2depVer].includes('latest')) {
+                console.log("".concat(tnp_core_2.chalk.gray(depName), "@(").concat(c1depVer, " => ").concat(c2depVer, ")\t"));
+            }
+            else if (c2depVer && c1depVer) {
+                if (semver.lt(c2depVer, c1depVer)) {
+                    console.log("".concat(tnp_core_2.chalk.red(depName), "@(").concat(c1depVer, " => ").concat(c2depVer, ")\t"));
+                }
+                else if (semver.gte(c2depVer, c1depVer)) {
+                    console.log("".concat(tnp_core_2.chalk.gray(depName), "@(").concat(c1depVer, " => ").concat(c2depVer, ")\t"));
+                }
+            }
+            else {
+                console.log("".concat(tnp_core_2.chalk.bold(depName), "@(").concat(c1depVer, " => ").concat(c2depVer, ")\t"));
+            }
+        };
+        var allDepsKeys = Object.keys(c1Deps).concat(Object.keys(c2Deps));
+        try {
+            for (var allDepsKeys_1 = tslib_1.__values(allDepsKeys), allDepsKeys_1_1 = allDepsKeys_1.next(); !allDepsKeys_1_1.done; allDepsKeys_1_1 = allDepsKeys_1.next()) {
+                var packageName = allDepsKeys_1_1.value;
+                displayCompare(packageName, tnp_helpers_1.UtilsNpm.clearVersion(c1Deps[packageName], { removePrefixes: true }), tnp_helpers_1.UtilsNpm.clearVersion(c2Deps[packageName], { removePrefixes: true }));
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (allDepsKeys_1_1 && !allDepsKeys_1_1.done && (_a = allDepsKeys_1.return)) _a.call(allDepsKeys_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        this._exit();
+    };
+    //#endregion
+    //#region not for npm / mp3
+    /**
+     *  npm install --global bin-version-check-cli
+     *  npm i -g yt-dlp
+     *  choco install ffmpeg
+     */
+    $Global.prototype.MP3 = function (args) {
+        var downloadPath = (0, tnp_core_2.crossPlatformPath)([
+            tnp_core_2.os.userInfo().homedir,
+            'Downloads',
+            'mp3-from-websites',
+        ]);
+        if (!tnp_helpers_1.Helpers.exists(downloadPath)) {
+            tnp_helpers_1.Helpers.mkdirp(downloadPath);
+        }
+        tnp_helpers_1.Helpers.run("cd ".concat(downloadPath, " && yt-dlp --verbose --extract-audio --audio-format mp3 ") +
+            args, {
+            output: true,
+            cwd: downloadPath,
+        }).sync();
+        this._exit();
+    };
+    //#endregion
+    //#region not for npm / mp4
+    $Global.prototype.MP4 = function (args) {
+        var downloadPath = (0, tnp_core_2.crossPlatformPath)([
+            tnp_core_2.os.userInfo().homedir,
+            'Downloads',
+            'mp4-from-websites',
+        ]);
+        // yt-dlp --print filename -o "%(uploader)s-%(upload_date)s-%(title)s.%(ext)s"
+        tnp_helpers_1.Helpers.run('yt-dlp --verbose  -S "res:1080,fps" -f "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best" ' +
+            args, {
+            output: true,
+            cwd: downloadPath,
+        }).sync();
+        this._exit();
+    };
+    //#endregion
+    //#region not for npm / kill zscaller
+    $Global.prototype.killZs = function () {
+        this.killZscaller();
+    };
+    $Global.prototype.startZs = function () {
+        this.startZscaller();
+    };
+    $Global.prototype.zsKill = function () {
+        this.killZscaller();
+    };
+    $Global.prototype.zsStart = function () {
+        this.startZscaller();
+    };
+    $Global.prototype.startZscaller = function () {
+        var e_4, _a;
+        var commands = [
+            // `open -a /Applications/Zscaler/Zscaler.app --hide`,
+            "open -a /Applications/Zscaler/Zscaler.app",
+            "sudo find /Library/LaunchDaemons -name '*zscaler*' -exec launchctl load {} \\;",
+        ];
+        try {
+            for (var commands_1 = tslib_1.__values(commands), commands_1_1 = commands_1.next(); !commands_1_1.done; commands_1_1 = commands_1.next()) {
+                var cmd = commands_1_1.value;
+                try {
+                    tnp_helpers_1.Helpers.run(cmd, {
+                        // stdio that will let me pass password in child process
+                        stdio: 'inherit',
+                    }).sync();
+                }
+                catch (error) { }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (commands_1_1 && !commands_1_1.done && (_a = commands_1.return)) _a.call(commands_1);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        tnp_helpers_1.Helpers.info("Zscaller started");
+        this._exit();
+    };
+    $Global.prototype.killZscaller = function () {
+        var e_5, _a;
+        var commands = [
+            "find /Library/LaunchAgents -name '*zscaler*' -exec launchctl unload {} \\;",
+            "sudo find /Library/LaunchDaemons -name '*zscaler*' -exec launchctl unload {} \\;",
+            "sudo killall -9 Zscaler ZscalerTunnel ZscalerAppServices",
+        ];
+        try {
+            for (var commands_2 = tslib_1.__values(commands), commands_2_1 = commands_2.next(); !commands_2_1.done; commands_2_1 = commands_2.next()) {
+                var cmd = commands_2_1.value;
+                try {
+                    tnp_helpers_1.Helpers.run(cmd, {
+                        // stdio that will let me pass password in child process
+                        stdio: 'inherit',
+                    }).sync();
+                }
+                catch (error) { }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (commands_2_1 && !commands_2_1.done && (_a = commands_2.return)) _a.call(commands_2);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        tnp_helpers_1.Helpers.info("Zscaller killed");
+        this._exit();
+    };
+    //#endregion
+    //#region not for npm / get trusted
+    //#region @notForNpm
+    $Global.prototype.getJsonCAttrs = function () {
+        var _this = this;
+        console.log("Scannign for args in jsonc files...");
+        var jsoncContent = this.project.readFile(tnp_config_1.config.file.taon_jsonc);
+        lodash_walk_object_1.walk.Object(tnp_helpers_1.Helpers.parse(jsoncContent, true), function (value, jsonPath) {
+            if (!_this.firstArg || jsonPath.includes(_this.firstArg)) {
+                // console.log('PATH: ' + jsonPath);
+                var attrs = tnp_core_2.Utils.json.getAtrributies(jsonPath, jsoncContent);
+                console.log("".concat(attrs.length > 0 ? tnp_core_2.chalk.bold('DETECTED') : 'DETECTED', " ") +
+                    "(".concat(attrs.length, " tags): ").concat(attrs.length > 0 ? tnp_core_2.chalk.bold(jsonPath) : jsonPath), attrs
+                    .map(function (c) {
+                    return tnp_core_2.chalk.red.underline(c.name + (c.value ? '=' + tnp_core_2.chalk.bold(c.value) : ''));
+                })
+                    .join(', '));
+            }
+        });
+        this._exit();
+    };
+    //#endregion
+    //#endregion
+    //#region not for npm / get trusted
+    //#region @notForNpm
+    $Global.prototype.trusted = function () {
+        console.log(this.project.__trusted);
+        this._exit();
+    };
+    //#endregion
+    //#endregion
+    //#region not for npm / tnp fix taon json
+    //#region @notForNpm
+    $Global.prototype.tnpFixTaonJson = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                this._exit();
+                return [2 /*return*/];
+            });
+        });
+    };
+    //#endregion
+    //#endregion
+    //#region list active core container
+    $Global.prototype.listActiveCoreContainer = function () {
+        tnp_config_1.config.activeFramewrokVersions.forEach(function (v) {
+            console.log("- ".concat(v, " = "), project_1.Project.by('container', v).location);
+        });
+        this._exit();
+    };
+    //#endregion
+    //#region start taon projects worker
+    $Global.prototype.startCliServiceTaonProjectsWorker = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.ins.taonProjectsWorker.cliStartProcedure(this.params)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region json schema docs watcher
+    $Global.prototype.jsonSchemaDocsWatch = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var fileToWatchRelative, fileToWatch, recreate, debouceRecreate;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.project.init('initing before json schema docs watch')];
+                    case 1:
+                        _a.sent();
+                        if (this.project.name !== 'tnp') {
+                            tnp_helpers_1.Helpers.error("This command is only for tnp project", false, true);
+                        }
+                        fileToWatchRelative = 'src/lib/models.ts';
+                        fileToWatch = this.project.pathFor(fileToWatchRelative);
+                        recreate = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var schema;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this._createJsonSchemaFrom({
+                                            nameOfTypeOrInterface: 'Models.DocsConfig',
+                                            project: this.project,
+                                            relativePathToTsFile: fileToWatch,
+                                        })];
+                                    case 1:
+                                        schema = _a.sent();
+                                        tnp_helpers_1.Helpers.writeFile(this.project.docs.docsConfigSchemaPath, schema);
+                                        tnp_helpers_1.Helpers.info("DocsConfig schema updated ".concat((0, tnp_core_1.dateformat)(new Date(), 'dd-mm-yyyy HH:MM:ss')));
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        debouceRecreate = tnp_core_2._.debounce(recreate, 100);
+                        tnp_helpers_1.Helpers.taskStarted('Recreating... src/lib/models.ts');
+                        return [4 /*yield*/, recreate()];
+                    case 2:
+                        _a.sent();
+                        tnp_helpers_1.Helpers.taskDone('Recreation done src/lib/models.ts');
+                        tnp_helpers_1.Helpers.taskStarted('Watching for changes in src/lib/models.ts');
+                        tnp_core_1.chokidar.watch(fileToWatch).on('change', function () {
+                            debouceRecreate();
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    $Global.prototype.jsonSchemaTaonWatch = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var fileToWatchRelative, fileToWatch, recreate, debouceRecreate;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.project.init('initing before json schema docs watch')];
+                    case 1:
+                        _a.sent();
+                        if (this.project.name !== 'tnp') {
+                            tnp_helpers_1.Helpers.error("This command is only for tnp project", false, true);
+                        }
+                        fileToWatchRelative = 'src/lib/models.ts';
+                        fileToWatch = this.project.pathFor(fileToWatchRelative);
+                        recreate = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var schema;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this._createJsonSchemaFrom({
+                                            nameOfTypeOrInterface: 'Models.TaonConfig',
+                                            project: this.project,
+                                            relativePathToTsFile: fileToWatch,
+                                        })];
+                                    case 1:
+                                        schema = _a.sent();
+                                        tnp_helpers_1.Helpers.writeFile(this.project.coreProject.pathFor(constants_1.taonConfigSchemaJson), schema);
+                                        tnp_helpers_1.Helpers.info("TaonConfig schema updated ".concat((0, tnp_core_1.dateformat)(new Date(), 'dd-mm-yyyy HH:MM:ss')));
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        debouceRecreate = tnp_core_2._.debounce(recreate, 100);
+                        tnp_helpers_1.Helpers.taskStarted('Recreating... src/lib/models.ts');
+                        return [4 /*yield*/, recreate()];
+                    case 2:
+                        _a.sent();
+                        tnp_helpers_1.Helpers.taskDone('Recreation done src/lib/models.ts');
+                        tnp_helpers_1.Helpers.taskStarted('Watching for changes in src/lib/models.ts');
+                        tnp_core_1.chokidar.watch(fileToWatch).on('change', function () {
+                            debouceRecreate();
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    $Global.prototype.jsonSchema = function () {
+        return this.schemaJson();
+    };
+    $Global.prototype._createJsonSchemaFrom = function (options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var project, relativePathToTsFile, nameOfTypeOrInterface, config, generator, schema, schemaJson;
+            return tslib_1.__generator(this, function (_a) {
+                project = options.project, relativePathToTsFile = options.relativePathToTsFile, nameOfTypeOrInterface = options.nameOfTypeOrInterface;
+                config = {
+                    path: relativePathToTsFile, // Path to the TypeScript file
+                    tsconfig: project.pathFor('tsconfig.json'), // Path to the tsconfig.json file
+                    type: nameOfTypeOrInterface, // Type or interface name
+                    skipTypeCheck: false, // Optional: Skip type checking
+                };
+                generator = (0, ts_json_schema_generator_1.createGenerator)(config);
+                schema = generator.createSchema(config.type);
+                schemaJson = JSON.stringify(schema, null, 2);
+                return [2 /*return*/, schemaJson];
+            });
+        });
+    };
+    $Global.prototype.schemaJson = function () {
+        console.log(this._createJsonSchemaFrom({
+            project: this.project,
+            relativePathToTsFile: this.firstArg,
+            nameOfTypeOrInterface: this.lastArg,
+        }));
+        this._exit();
+    };
+    //#endregion
+    //#region ts testing functions
+    $Global.prototype.ts = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        tnp_helpers_1.Helpers.clearConsole();
+                        return [4 /*yield*/, tnp_core_4.UtilsTerminal.selectActionAndExecute({
+                                recognizeImportExportRequire: {
+                                    name: 'Recognize import/export/require',
+                                    action: function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                        var files, selectedFileAbsPath, importsExports;
+                                        return tslib_1.__generator(this, function (_a) {
+                                            switch (_a.label) {
+                                                case 0:
+                                                    files = tnp_helpers_1.Helpers.filesFrom([this.cwd, tnp_config_1.config.folder.src], true);
+                                                    return [4 /*yield*/, tnp_core_4.UtilsTerminal.select({
+                                                            question: 'Select file to recognize imports/exports/requires',
+                                                            choices: files.map(function (f) {
+                                                                return {
+                                                                    name: f,
+                                                                    value: f,
+                                                                };
+                                                            }),
+                                                        })];
+                                                case 1:
+                                                    selectedFileAbsPath = _a.sent();
+                                                    importsExports = (0, tnp_helpers_1.recognizeImportsFromFile)(tnp_helpers_1.Helpers.readFile(selectedFileAbsPath)).map(function (i) {
+                                                        return "(".concat(i.type, ") ").concat(tnp_core_2.chalk.bold(i.cleanEmbeddedPathToFile));
+                                                    });
+                                                    console.log(importsExports.join('\n '));
+                                                    return [2 /*return*/];
+                                            }
+                                        });
+                                    }); },
+                                },
+                            })];
+                    case 1:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region electron build
+    $Global.prototype.electronBuild = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.project.tryKillAllElectronInstances()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.project.build(options_1.BuildOptions.from(tslib_1.__assign(tslib_1.__assign({}, this.params), { buildType: 'app', targetApp: 'electron', buildForRelease: true, finishCallback: function () { return _this._exit(); } })))];
+                    case 2:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    $Global.prototype.electronWatchBuild = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.project.tryKillAllElectronInstances()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.project.build(options_1.BuildOptions.from(tslib_1.__assign(tslib_1.__assign({}, this.params), { buildType: 'app', targetApp: 'electron', watch: true })))];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return $Global;
+}(tnp_helpers_1.BaseGlobalCommandLine));
+exports.$Global = $Global;
+exports.default = {
+    // registerd as empty
+    $Global: tnp_helpers_1.Helpers.CLIWRAP($Global, ''),
+};
+//# sourceMappingURL=cli-_GLOBAL_.backend.js.map