tnp-helpers 16.5.16 → 16.5.19

package/lib/base/base-project.js

@@ -0,0 +1,1451 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProject = exports.ChildProcess = void 0;
+var tslib_1 = require("tslib");
+//#region @backend
+var tnp_core_1 = require("tnp-core");
+var child_process_1 = require("child_process");
+Object.defineProperty(exports, "ChildProcess", { enumerable: true, get: function () { return child_process_1.ChildProcess; } });
+//#endregion
+var tnp_cli_1 = require("tnp-cli");
+var tnp_core_2 = require("tnp-core");
+var tnp_config_1 = require("tnp-config");
+var tnp_core_3 = require("tnp-core");
+var index_1 = require("../index");
+var base_project_resolver_1 = require("./base-project-resolver");
+var translate_1 = require("./translate");
+//#endregion
+var takenPorts = [];
+var BaseProject = exports.BaseProject = /** @class */ (function () {
+    //#endregion
+    //#region constructor
+    // @ts-ignore
+    function BaseProject(
+    /**
+     * doesn't need to be real path -> can be link
+     */
+    location) {
+        var _this = this;
+        this.location = location;
+        //#endregion
+        //#endregion
+        //#region fields
+        this.cache = {};
+        this.type = 'unknow';
+        //#endregion
+        //#region getters & methods / to string
+        this.toString = function () {
+            return "".concat(_this.name, "=>").concat(_this.location);
+        };
+    }
+    //#endregion
+    //#region static / sort group of projects
+    BaseProject.sortGroupOfProject = function (projects, resoveDepsArray, projNameToCompare) {
+        var visited = {};
+        var stack = {};
+        var result = [];
+        var visit = function (project) {
+            if (stack[projNameToCompare(project)]) {
+                // Circular dependency detected
+                index_1.Helpers.error("Circular dependency detected involving project: ".concat(projNameToCompare(project)));
+            }
+            if (!visited[projNameToCompare(project)]) {
+                visited[projNameToCompare(project)] = true;
+                stack[projNameToCompare(project)] = true;
+                var depsResolved = resoveDepsArray(project);
+                depsResolved.forEach(function (dependency) {
+                    var dependentProject = projects.find(function (p) {
+                        // console.log(`comparing :"${projNameToCompare(p)}" and "${dependency}"`)
+                        return projNameToCompare(p) === dependency;
+                    });
+                    if (dependentProject) {
+                        visit(dependentProject);
+                    }
+                });
+                stack[projNameToCompare(project)] = false;
+                result.push(project);
+            }
+        };
+        projects.forEach(function (project) { return visit(project); });
+        return result;
+        // return result.reverse(); // Reverse the result to get the correct order
+    };
+    //#endregion
+    //#region  methods & getters
+    //#region  methods & getters / set type
+    BaseProject.prototype.setType = function (type) {
+        // @ts-ignore
+        this.type = type;
+    };
+    //#endregion
+    //#region  methods & getters / type is
+    BaseProject.prototype.typeIs = function () {
+        var types = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            types[_i] = arguments[_i];
+        }
+        return this.type && types.includes(this.type);
+    };
+    //#endregion
+    //#region  methods & getters / type is not
+    BaseProject.prototype.typeIsNot = function () {
+        var types = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            types[_i] = arguments[_i];
+        }
+        return !this.typeIs.apply(this, tslib_1.__spreadArray([], tslib_1.__read(types), false));
+    };
+    Object.defineProperty(BaseProject.prototype, "basename", {
+        //#endregion
+        //#region  methods & getters / basename
+        /**
+         * project folder basename
+         */
+        get: function () {
+            //#region @websqlFunc
+            return tnp_core_2.path.basename(this.location);
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseProject.prototype, "name", {
+        //#endregion
+        //#region  methods & getters / name
+        /**
+         * name from package.json
+         */
+        get: function () {
+            var _a;
+            return (_a = this.packageJSON) === null || _a === void 0 ? void 0 : _a.name;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseProject.prototype, "version", {
+        //#endregion
+        //#region  methods & getters / version
+        /**
+         * version from package.json -> property version
+         */
+        get: function () {
+            var _a;
+            return (_a = this.packageJSON) === null || _a === void 0 ? void 0 : _a.version;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseProject.prototype, "majorVersion", {
+        //#endregion
+        //#region  methods & getters / major version
+        /**
+        * Major Version from package.json
+        */
+        // @ts-ignore
+        get: function () {
+            //#region @backendFunc
+            return Number(tnp_core_3._.first((this.version || '').split('.')));
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseProject.prototype, "minorVersion", {
+        //#endregion
+        //#region  methods & getters / minor version
+        /**
+         * Minor Version from package.json
+         */
+        // @ts-ignore
+        get: function () {
+            var _a;
+            //#region @backendFunc
+            var __ = (_a = tslib_1.__read(((this.version || '').split('.') || [void 0, void 0]), 2), _a[0]), minor = _a[1];
+            return Number(minor);
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseProject.prototype, "versionPathAsNumber", {
+        //#endregion
+        //#region  methods & getters / get version path as number
+        get: function () {
+            //#region @backendFunc
+            var ver = this.version.split('.');
+            var res = Number(tnp_core_3._.last(ver));
+            return isNaN(res) ? 0 : res;
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseProject.prototype, "dependencies", {
+        //#endregion
+        //#region  methods & getters / dependencies
+        /**
+         * npm dependencies from package.json
+         */
+        get: function () {
+            return (this.packageJSON ? this.packageJSON.dependencies : {}) || {};
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseProject.prototype, "peerDependencies", {
+        //#endregion
+        //#region  methods & getters / peer dependencies
+        /**
+         * peerDependencies dependencies
+         */
+        get: function () {
+            return (this.packageJSON ? this.packageJSON.peerDependencies : {}) || {};
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseProject.prototype, "devDependencies", {
+        //#endregion
+        //#region  methods & getters / dev dependencies
+        /**
+         * devDependencies dependencies
+         */
+        get: function () {
+            return (this.packageJSON ? this.packageJSON.devDependencies : {}) || {};
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseProject.prototype, "resolutions", {
+        //#endregion
+        //#region  methods & getters / resolutions dependencies
+        /**
+         * resolutions dependencies
+         */
+        get: function () {
+            return (this.packageJSON ? this.packageJSON['resolutions'] : {}) || {};
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseProject.prototype, "allDependencies", {
+        //#endregion
+        //#region  methods & getters / all dependencies
+        /**
+         *  object with all deps from package json
+         */
+        get: function () {
+            return tnp_core_3._.merge(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, this.devDependencies), this.peerDependencies), this.dependencies), this.resolutions));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region  methods & getters / get folder for possible project chhildrens
+    BaseProject.prototype.getFoldersForPossibleProjectChildren = function () {
+        //#region @backendFunc
+        var isDirectory = function (source) { return tnp_core_1.fse.lstatSync(source).isDirectory(); };
+        var getDirectories = function (source) {
+            return tnp_core_1.fse.readdirSync(source).map(function (name) { return tnp_core_2.path.join(source, name); }).filter(isDirectory);
+        };
+        var subdirectories = getDirectories(this.location)
+            .filter(function (f) {
+            var folderName = tnp_core_2.path.basename(f);
+            return index_1.Helpers.checkIfNameAllowedForFiredevProj(folderName);
+        });
+        // if (this.isTnp' && fse.existsSync(path.join(this.location, '../firedev-projects'))) {
+        //   subdirectories = subdirectories.concat(getDirectories(path.join(this.location, '../firedev-projects'))
+        //     .filter(f => {
+        //       const folderName = path.basename(f);
+        //       return Helpers.checkIfNameAllowedForFiredevProj(folderName);
+        //     }))
+        // }'
+        return subdirectories;
+        //#endregion
+    };
+    //#endregion
+    //#region  methods * getters / get all childrens
+    BaseProject.prototype.getAllChildren = function () {
+        var _this = this;
+        //#region @backendFunc
+        var subdirectories = this.getFoldersForPossibleProjectChildren();
+        var res = subdirectories
+            .map(function (dir) {
+            // console.log('child:', dir)
+            return _this.ins.From(dir);
+        })
+            .filter(function (c) { return !!c; });
+        return res;
+        //#endregion
+    };
+    Object.defineProperty(BaseProject.prototype, "children", {
+        //#endregion
+        //#region  methods & getters / children
+        /**
+         * alias to getAllChildren
+         */
+        get: function () {
+            //#region @websqlFunc
+            return this.getAllChildren();
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region  methods & getters / get child
+    BaseProject.prototype.getChildBy = function (nameOrBasename, errors) {
+        if (errors === void 0) { errors = true; }
+        //#region @websqlFunc
+        var c = this.children.find(function (c) { return c.name === nameOrBasename || c.basename === nameOrBasename; });
+        if (errors && !c) {
+            index_1.Helpers.warn("Project doesnt contain child with name or basename: ".concat(nameOrBasename));
+        }
+        return c;
+        //#endregion
+    };
+    Object.defineProperty(BaseProject.prototype, "parent", {
+        //#endregion
+        //#region  methods & getters / parent
+        get: function () {
+            //#region @websqlFunc
+            if (!tnp_core_3._.isString(this.location) || this.location.trim() === '') {
+                return void 0;
+            }
+            return this.ins.From(tnp_core_2.path.join(this.location, '..'));
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseProject.prototype, "grandpa", {
+        //#endregion
+        //#region  methods & getters / grandpa
+        get: function () {
+            //#region @websqlFunc
+            if (!tnp_core_3._.isString(this.location) || this.location.trim() === '') {
+                return void 0;
+            }
+            var grandpa = this.ins.From(tnp_core_2.path.join(this.location, '..', '..'));
+            return grandpa;
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseProject.prototype, "genericName", {
+        //#endregion
+        //#region  methods & getters / generic name
+        get: function () {
+            //#region @websqlFunc
+            var parent = this.parent;
+            return [
+                parent ? tnp_core_2.path.basename(tnp_core_2.path.dirname(parent.location)) : void 0,
+                parent ? parent.basename : tnp_core_2.path.basename(this.location),
+                this.basename,
+                //#region @backend
+                "(".concat(tnp_cli_1.CLI.chalk.bold(this.name), ")"),
+                //#endregion
+            ]
+                .filter(function (f) { return !!f; })
+                .join('/');
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region  methods & getters / path exits
+    /**
+    * same has project.hasFile();
+    */
+    BaseProject.prototype.pathExists = function (relativePath) {
+        return this.hasFile(relativePath);
+    };
+    //#endregion
+    //#region  methods & getters / has file
+    /**
+     * same as project.pathExists();
+     */
+    BaseProject.prototype.hasFile = function (relativePath) {
+        return index_1.Helpers.exists(this.pathFor(relativePath));
+    };
+    //#endregion
+    //#region  methods & getters / contains file
+    /**
+     * same as project.pathhasFileExists();
+     * but with path.resolve
+     */
+    BaseProject.prototype.containsFile = function (fileRelativeToProjectPath) {
+        var fullPath = tnp_core_2.path.resolve(tnp_core_2.path.join(this.location, fileRelativeToProjectPath));
+        return index_1.Helpers.exists(fullPath);
+    };
+    //#endregion
+    //#region  methods & getters / path for
+    /**
+     * absolute path:
+     * concated project location with relative path
+     */
+    BaseProject.prototype.pathFor = function (relativePath) {
+        //#region @backendFunc
+        if (Array.isArray(relativePath)) {
+            relativePath = relativePath.join('/');
+        }
+        if (tnp_core_2.path.isAbsolute(relativePath)) {
+            index_1.Helpers.error("Cannot join relative path with absolute: ".concat(relativePath));
+        }
+        return (0, tnp_core_2.crossPlatformPath)(tnp_core_2.path.join(this.location, relativePath));
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / write json
+    BaseProject.prototype.writeJson = function (relativePath, json) {
+        //#region @backendFunc
+        if (tnp_core_2.path.isAbsolute(relativePath)) {
+            index_1.Helpers.error("Cannot join relative path with absolute: ".concat(relativePath));
+        }
+        index_1.Helpers.writeJson((0, tnp_core_2.crossPlatformPath)([this.location, relativePath]), json);
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / run
+    /**
+     * @deprecated us execute instead
+     * use output from or more preciese crafted api
+     */
+    BaseProject.prototype.run = function (command, options) {
+        //#region @backendFunc
+        options = tnp_core_3._.cloneDeep(options) || {};
+        index_1.Helpers.log("command: ".concat(command));
+        if (tnp_core_3._.isUndefined(options.showCommand)) {
+            options.showCommand = false;
+        }
+        var opt = options;
+        if (!opt.cwd) {
+            opt.cwd = this.location;
+        }
+        if (opt.showCommand) {
+            index_1.Helpers.info("[".concat(tnp_cli_1.CLI.chalk.underline('Executing shell command'), "]  \"").concat(command, "\" in [").concat(opt.cwd, "]"));
+        }
+        else {
+            index_1.Helpers.log("[".concat(tnp_cli_1.CLI.chalk.underline('Executing shell command'), "]  \"").concat(command, "\" in [").concat(opt.cwd, "]"));
+        }
+        return index_1.Helpers.run(command, opt);
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / execute
+    /**
+     * same as run but async
+     */
+    BaseProject.prototype.execute = function (command, options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var cwd;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        //#region @backendFunc
+                        if (tnp_core_3._.isUndefined(options.showCommand)) {
+                            options.showCommand = false;
+                        }
+                        if (!options) {
+                            options = {};
+                        }
+                        cwd = this.location;
+                        if (options.showCommand) {
+                            index_1.Helpers.logInfo("[".concat(tnp_cli_1.CLI.chalk.underline('Executing shell command'), "]  \"").concat(command, "\" in [").concat(cwd, "]"));
+                        }
+                        else {
+                            index_1.Helpers.log("[".concat(tnp_cli_1.CLI.chalk.underline('Executing shell command'), "]  \"").concat(command, "\" in [").concat(cwd, "]"));
+                        }
+                        return [4 /*yield*/, index_1.Helpers.execute(command, cwd, options)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region  methods & getters / try run sync command
+    /**
+     * try run but continue when it fails
+     * @param command
+     * @param options
+     * @returns
+     */
+    BaseProject.prototype.tryRunSync = function (command
+    //#region @backend
+    , options
+    //#endregion
+    ) {
+        //#region @backendFunc
+        try {
+            this.run(command, options).sync();
+        }
+        catch (error) {
+            index_1.Helpers.warn("Not able to execute: ".concat(command));
+        }
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / output from command
+    BaseProject.prototype.outputFrom = function (command
+    //#region @backend
+    , options
+    //#endregion
+    ) {
+        //#region @backendFunc
+        return index_1.Helpers.commnadOutputAsString(command, this.location, options);
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / remove file
+    BaseProject.prototype.removeFile = function (fileRelativeToProjectPath) {
+        //#region @backendFunc
+        var fullPath = tnp_core_2.path.resolve(tnp_core_2.path.join(this.location, fileRelativeToProjectPath));
+        return index_1.Helpers.removeFileIfExists(fullPath);
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / remove (fiel or folder)
+    BaseProject.prototype.remove = function (relativePath, exactPath) {
+        if (exactPath === void 0) { exactPath = true; }
+        //#region @backend
+        relativePath = relativePath.replace(/^\//, '');
+        index_1.Helpers.remove([this.location, relativePath], exactPath);
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / remove folder by relative path
+    BaseProject.prototype.removeFolderByRelativePath = function (relativePathToFolder) {
+        //#region @backend
+        relativePathToFolder = relativePathToFolder.replace(/^\//, '');
+        var location = this.location;
+        var p = tnp_core_2.path.join(location, relativePathToFolder);
+        index_1.Helpers.remove(p, true);
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / link node_modules to other project
+    BaseProject.prototype.linkNodeModulesTo = function (proj) {
+        //#region @backendFunc
+        var source = this.pathFor(tnp_config_1.config.folder.node_modules);
+        var dest = proj.pathFor(tnp_config_1.config.folder.node_modules);
+        index_1.Helpers.remove(dest, true);
+        index_1.Helpers.createSymLink(source, dest);
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / reinstall node_modules
+    BaseProject.prototype.reinstallNodeModules = function (forcerRemoveNodeModules) {
+        if (forcerRemoveNodeModules === void 0) { forcerRemoveNodeModules = false; }
+        //#region @backendFunc
+        index_1.Helpers.taskStarted("Reinstalling node_modules in ".concat(this.genericName));
+        var source = this.pathFor(tnp_config_1.config.folder.node_modules);
+        if (forcerRemoveNodeModules) {
+            index_1.Helpers.remove(source, true);
+        }
+        this.run('yarn install').sync();
+        index_1.Helpers.taskDone("Reinstalling done for ".concat(this.genericName));
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / assign free port to project instance
+    BaseProject.prototype.assignFreePort = function (startFrom, howManyFreePortsAfterThatPort) {
+        if (startFrom === void 0) { startFrom = 4200; }
+        if (howManyFreePortsAfterThatPort === void 0) { howManyFreePortsAfterThatPort = 0; }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var max, i, port, err_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        //#region @backendFunc
+                        if (tnp_core_3._.isNumber(this.port) && this.port >= startFrom) {
+                            return [2 /*return*/, startFrom];
+                        }
+                        max = 2000;
+                        i = 0;
+                        while (takenPorts.includes(startFrom)) {
+                            startFrom += (1 + howManyFreePortsAfterThatPort);
+                        }
+                        _a.label = 1;
+                    case 1:
+                        if (!true) return [3 /*break*/, 6];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, tnp_core_1.portfinder.getPortPromise({ port: startFrom })];
+                    case 3:
+                        port = _a.sent();
+                        takenPorts.push(port);
+                        // @ts-ignore
+                        this.port = port;
+                        return [2 /*return*/, port];
+                    case 4:
+                        err_1 = _a.sent();
+                        console.log(err_1);
+                        index_1.Helpers.warn("Trying to assign port  :".concat(startFrom, " but already in use."), false);
+                        return [3 /*break*/, 5];
+                    case 5:
+                        startFrom += 1;
+                        if (i++ === max) {
+                            index_1.Helpers.error("[firedev-helpers]] failed to assign free port after ".concat(max, " trys..."));
+                        }
+                        return [3 /*break*/, 1];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region  methods & getters / remove project from disk/memory
+    BaseProject.prototype.removeItself = function () {
+        //#region @backend
+        this.ins.remove(this);
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / define property
+    /**
+     * Purpose: not initializing all classes at the beginning
+     * Only for BaseFeatureForProject class
+     */
+    BaseProject.prototype.defineProperty = function (variableName, classFn, options) {
+        //#region @backendFunc
+        var customInstanceReturn = (options || {}).customInstanceReturn;
+        var that = this;
+        // @ts-ignore
+        var prefixedName = "__".concat(variableName);
+        Object.defineProperty(this, variableName, {
+            get: function () {
+                if (!that[prefixedName]) {
+                    if (typeof classFn === 'function') {
+                        if (!!customInstanceReturn) {
+                            that[prefixedName] = customInstanceReturn();
+                        }
+                        else {
+                            that[prefixedName] = new classFn(that);
+                        }
+                    }
+                    else {
+                        index_1.Helpers.warn("[firedev-helpers] Cannot create dynamic instance of class \"".concat(tnp_core_3._.kebabCase(prefixedName.replace('__', '')), "\"."));
+                    }
+                    // }
+                }
+                return that[prefixedName];
+            },
+            set: function (v) {
+                that[prefixedName] = v;
+            },
+        });
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / filter only copy
+    /**
+     * fs.copy option filter function for copying only selected folders from project
+     */
+    BaseProject.prototype.filterOnlyCopy = function (basePathFoldersOnlyToInclude) {
+        //#region @backendFunc
+        return index_1.Helpers.filterOnlyCopy(basePathFoldersOnlyToInclude, this.location);
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / filter don't copy
+    /**
+     * fs.copy option filter function for copying only not selected folders from project
+     */
+    BaseProject.prototype.filterDontCopy = function (basePathFoldersTosSkip) {
+        //#region @backendFunc
+        return index_1.Helpers.filterDontCopy(basePathFoldersTosSkip, this.location);
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / get default develop Branch
+    BaseProject.prototype.getDefaultDevelopmentBranch = function () {
+        return 'develop';
+    };
+    //#endregion
+    //#region  methods & getters / get main branches
+    /**
+     * main/default hardcoded branches
+     */
+    BaseProject.prototype.getMainBranches = function () {
+        return ['master', 'develop', 'stage', 'prod', 'test'];
+    };
+    //#endregion
+    //#region  methods & getters / is using aciton commit
+    BaseProject.prototype.isUnsingActionCommit = function () {
+        return false;
+    };
+    //#endregion
+    //#region  methods & getters / reset process
+    BaseProject.prototype.resetProcess = function (overrideBranch) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var defaultBranch, childrenRepos, childrenRepos_1, childrenRepos_1_1, child, e_1_1;
+            var e_1, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        //#region @backend
+                        this._beforeAnyActionOnGitRoot();
+                        defaultBranch = overrideBranch
+                            ? overrideBranch : this.getDefaultDevelopmentBranch();
+                        this.git.fetch();
+                        this.git.stageAllFiles();
+                        this.git.stash();
+                        this.git.resetHard();
+                        this.git.checkout(defaultBranch);
+                        if (!this.isUnsingActionCommit()) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.git.pullCurrentBranch({ askToRetry: true })];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.git.pullCurrentBranch({ askToRetry: true, defaultHardResetCommits: 5 })];
+                    case 3:
+                        _b.sent();
+                        _b.label = 4;
+                    case 4:
+                        this.git.stashApply();
+                        return [4 /*yield*/, this.struct()];
+                    case 5:
+                        _b.sent();
+                        index_1.Helpers.info("RESET DONE for branch: ".concat(tnp_core_1.chalk.bold(defaultBranch)));
+                        childrenRepos = this.children.filter(function (f) { return f.git.isGitRepo && f.git.isGitRoot; });
+                        _b.label = 6;
+                    case 6:
+                        _b.trys.push([6, 11, 12, 13]);
+                        childrenRepos_1 = tslib_1.__values(childrenRepos), childrenRepos_1_1 = childrenRepos_1.next();
+                        _b.label = 7;
+                    case 7:
+                        if (!!childrenRepos_1_1.done) return [3 /*break*/, 10];
+                        child = childrenRepos_1_1.value;
+                        return [4 /*yield*/, child.resetProcess(overrideBranch)];
+                    case 8:
+                        _b.sent();
+                        _b.label = 9;
+                    case 9:
+                        childrenRepos_1_1 = childrenRepos_1.next();
+                        return [3 /*break*/, 7];
+                    case 10: return [3 /*break*/, 13];
+                    case 11:
+                        e_1_1 = _b.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 13];
+                    case 12:
+                        try {
+                            if (childrenRepos_1_1 && !childrenRepos_1_1.done && (_a = childrenRepos_1.return)) _a.call(childrenRepos_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 13: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region  methods & getters / push process
+    BaseProject.prototype.pullProcess = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var uncommitedChanges, location, childrenRepos, childrenRepos_2, childrenRepos_2_1, child, e_2_1;
+            var e_2, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: 
+                    //#region @backendFunc
+                    return [4 /*yield*/, this._beforePullProcessAction()];
+                    case 1:
+                        //#region @backendFunc
+                        _b.sent();
+                        uncommitedChanges = this.git.thereAreSomeUncommitedChange;
+                        if (uncommitedChanges) {
+                            index_1.Helpers.warn("Stashing uncommit changes... in ".concat(this.genericName));
+                            try {
+                                this.git.stageAllFiles();
+                            }
+                            catch (error) { }
+                            try {
+                                this.git.stash();
+                            }
+                            catch (error) { }
+                            ;
+                        }
+                        return [4 /*yield*/, this.git.pullCurrentBranch({ askToRetry: true })];
+                    case 2:
+                        _b.sent();
+                        location = this.location;
+                        this.ins.unload(this);
+                        this.ins.add(this.ins.From(location));
+                        if (!this.automaticallyAddAllChnagesWhenPushingToGit()) return [3 /*break*/, 10];
+                        childrenRepos = this.children.filter(function (f) { return f.git.isGitRepo && f.git.isGitRoot; });
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 8, 9, 10]);
+                        childrenRepos_2 = tslib_1.__values(childrenRepos), childrenRepos_2_1 = childrenRepos_2.next();
+                        _b.label = 4;
+                    case 4:
+                        if (!!childrenRepos_2_1.done) return [3 /*break*/, 7];
+                        child = childrenRepos_2_1.value;
+                        return [4 /*yield*/, child.pullProcess()];
+                    case 5:
+                        _b.sent();
+                        _b.label = 6;
+                    case 6:
+                        childrenRepos_2_1 = childrenRepos_2.next();
+                        return [3 /*break*/, 4];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_2_1 = _b.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (childrenRepos_2_1 && !childrenRepos_2_1.done && (_a = childrenRepos_2.return)) _a.call(childrenRepos_2);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region  methods & getters / push process
+    BaseProject.prototype.pushProcess = function (options) {
+        var _a;
+        if (options === void 0) { options = {}; }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var force, typeofCommit, forcePushNoQuestion, origin, exitCallBack, args, commitMessageRequired, commitData, error_1, childrenRepos, childrenRepos_3, childrenRepos_3_1, child, e_3_1;
+            var _b, _c, _d, e_3, _e;
+            return tslib_1.__generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        force = (_b = options.force, _b === void 0 ? false : _b), typeofCommit = options.typeofCommit, forcePushNoQuestion = options.forcePushNoQuestion, origin = (_c = options.origin, _c === void 0 ? 'origin' : _c), exitCallBack = options.exitCallBack, args = (_d = options.args, _d === void 0 ? [] : _d), commitMessageRequired = options.commitMessageRequired;
+                        this._beforePushProcessAction();
+                        return [4 /*yield*/, this._getCommitMessage(typeofCommit, args, commitMessageRequired)];
+                    case 1:
+                        commitData = _f.sent();
+                        _f.label = 2;
+                    case 2:
+                        if (!true) return [3 /*break*/, 8];
+                        _f.label = 3;
+                    case 3:
+                        _f.trys.push([3, 5, , 7]);
+                        return [4 /*yield*/, this.lint()];
+                    case 4:
+                        _f.sent();
+                        return [3 /*break*/, 8];
+                    case 5:
+                        error_1 = _f.sent();
+                        index_1.Helpers.warn('Fix your code...');
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.question.yesNo('Try again lint ? .. (or just skip it)')];
+                    case 6:
+                        if (!(_f.sent())) {
+                            return [3 /*break*/, 8];
+                        }
+                        return [3 /*break*/, 7];
+                    case 7: return [3 /*break*/, 2];
+                    case 8:
+                        if (!!commitData.isActionCommit) return [3 /*break*/, 10];
+                        index_1.Helpers.info("Current commit:\n      - message to include {".concat(commitData.commitMessage, "}\n      - branch to checkout {").concat(commitData.branchName, "}\n      "));
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo('Commit and push this ?')];
+                    case 9:
+                        if (!(_f.sent())) {
+                            exitCallBack();
+                        }
+                        _f.label = 10;
+                    case 10:
+                        if (this.automaticallyAddAllChnagesWhenPushingToGit()) { // my project
+                            this.git.stageAllFiles();
+                        }
+                        if (this.useGitBranchesAsMetadataForCommits()) {
+                            if (((_a = this.git.currentBranchName) === null || _a === void 0 ? void 0 : _a.trim()) !== commitData.branchName) {
+                                try {
+                                    this.git.checkout(commitData.branchName, { createBranchIfNotExists: true });
+                                }
+                                catch (error) {
+                                    index_1.Helpers.error('Please modyfiy you commit message or delete branch,');
+                                }
+                            }
+                        }
+                        try {
+                            this.git.commit(commitData.commitMessage);
+                        }
+                        catch (error) {
+                            index_1.Helpers.warn("Not commiting anything... ");
+                        }
+                        return [4 /*yield*/, this.git.pushCurrentBranch({ force: force, origin: origin, forcePushNoQuestion: forcePushNoQuestion, askToRetry: true })];
+                    case 11:
+                        _f.sent();
+                        if (!this.automaticallyAddAllChnagesWhenPushingToGit()) return [3 /*break*/, 19];
+                        childrenRepos = this.children.filter(function (f) { return f.git.isGitRepo && f.git.isGitRoot; });
+                        _f.label = 12;
+                    case 12:
+                        _f.trys.push([12, 17, 18, 19]);
+                        childrenRepos_3 = tslib_1.__values(childrenRepos), childrenRepos_3_1 = childrenRepos_3.next();
+                        _f.label = 13;
+                    case 13:
+                        if (!!childrenRepos_3_1.done) return [3 /*break*/, 16];
+                        child = childrenRepos_3_1.value;
+                        return [4 /*yield*/, child.pushProcess(options)];
+                    case 14:
+                        _f.sent();
+                        _f.label = 15;
+                    case 15:
+                        childrenRepos_3_1 = childrenRepos_3.next();
+                        return [3 /*break*/, 13];
+                    case 16: return [3 /*break*/, 19];
+                    case 17:
+                        e_3_1 = _f.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 19];
+                    case 18:
+                        try {
+                            if (childrenRepos_3_1 && !childrenRepos_3_1.done && (_e = childrenRepos_3.return)) _e.call(childrenRepos_3);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 19: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region  methods & getters / before any action on git root
+    BaseProject.prototype._beforeAnyActionOnGitRoot = function () {
+        //#region @backendFunc
+        if (!this.git.isGitRepo) {
+            index_1.Helpers.error("Project ".concat(tnp_core_1.chalk.bold(this.name), " is not a git repository\n      locaiton: ").concat(this.location), false, true);
+        }
+        if (!this.git.isGitRoot) {
+            index_1.Helpers.error("Project ".concat(tnp_core_1.chalk.bold(this.name), " is not a git root\n      locaiton: ").concat(this.location), false, true);
+        }
+        //#endregion
+    };
+    //#endregion
+    //#region before push action
+    BaseProject.prototype._beforePushProcessAction = function () {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        //#region @backendFunc
+                        this._beforeAnyActionOnGitRoot();
+                        if (!(this.git.isGitRepo && this.git.isGitRoot && !((_a = this.git.currentBranchName) === null || _a === void 0 ? void 0 : _a.trim()))) return [3 /*break*/, 2];
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.question.yesNo('Repository is empty...Commit "master" branch and commit all as "first commit" ?')];
+                    case 1:
+                        if (_b.sent()) {
+                            this.git.checkout('master');
+                            this.git.stageAllFiles();
+                            this.git.commit('first commit ');
+                        }
+                        _b.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region before push action
+    BaseProject.prototype._beforePullProcessAction = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                //#region @backendFunc
+                this._beforeAnyActionOnGitRoot();
+                return [2 /*return*/];
+            });
+        });
+    };
+    //#endregion
+    //#region resovle commit message
+    BaseProject.prototype._getCommitMessage = function (typeofCommit, args, commitMessageRequired) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var commitData, argsCommitData, commitDataBranch, argsCommitData, from, to, _a, _b, _c;
+            var _d;
+            return tslib_1.__generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        if (!this.useGitBranchesWhenCommitingAndPushing()) return [3 /*break*/, 5];
+                        return [4 /*yield*/, index_1.CommitData.getFromArgs(args, typeofCommit)];
+                    case 1:
+                        argsCommitData = _e.sent();
+                        if (!argsCommitData.message) return [3 /*break*/, 2];
+                        commitData = argsCommitData;
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, index_1.CommitData.getFromBranch(this.git.currentBranchName)];
+                    case 3:
+                        commitDataBranch = _e.sent();
+                        commitData = commitDataBranch;
+                        _e.label = 4;
+                    case 4: return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, index_1.CommitData.getFromArgs(args, typeofCommit)];
+                    case 6:
+                        argsCommitData = _e.sent();
+                        // console.log({ argsCommitData })
+                        // console.log(argsCommitData)
+                        if (!argsCommitData.message && commitMessageRequired) {
+                            index_1.Helpers.error('Please provide message in argument', false, true);
+                        }
+                        if (!argsCommitData.message) {
+                            argsCommitData.message = index_1.Helpers.git.ACTION_MSG_RESET_GIT_HARD_COMMIT;
+                        }
+                        commitData = argsCommitData;
+                        _e.label = 7;
+                    case 7:
+                        if (!(commitData.message !== index_1.Helpers.git.ACTION_MSG_RESET_GIT_HARD_COMMIT)) return [3 /*break*/, 9];
+                        from = (_d = this.transalteGitCommitFromArgs(), _d.from), to = _d.to;
+                        if (!(from && to)) return [3 /*break*/, 9];
+                        _a = commitData;
+                        _c = (_b = tnp_core_3._).kebabCase;
+                        return [4 /*yield*/, (0, translate_1.translate)(commitData.message, { from: from, to: to })];
+                    case 8:
+                        _a.message = _c.apply(_b, [_e.sent()]);
+                        _e.label = 9;
+                    case 9: return [2 /*return*/, commitData];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region  methods & getters / link project to
+    BaseProject.prototype.linkTo = function (destPackageLocation) {
+        //#region @backend
+        index_1.Helpers.createSymLink(this.location, destPackageLocation);
+        //#endregion
+    };
+    //#endregion
+    //#region  methods & getters / write file
+    BaseProject.prototype.writeFile = function (relativePath, content) {
+        //#region @backend
+        index_1.Helpers.writeFile([this.location, relativePath], content);
+        //#endregion
+    };
+    //#endregion
+    //#region getters & methods / ru command and get string
+    BaseProject.prototype.runCommandGetString = function (command) {
+        //#region @backendFunc
+        return index_1.Helpers.commnadOutputAsString(command, this.location, { biggerBuffer: false });
+        //#endregion
+    };
+    Object.defineProperty(BaseProject.prototype, "git", {
+        //#endregion
+        //#region getters & methods / git
+        get: function () {
+            var self = this;
+            return {
+                revertFileChanges: function (fileReletivePath) {
+                    //#region @backendFunc
+                    index_1.Helpers.git.revertFileChanges(self.location, fileReletivePath);
+                    //#endregion
+                },
+                clone: function (url, destinationFolderName) {
+                    if (destinationFolderName === void 0) { destinationFolderName = ''; }
+                    //#region @backendFunc
+                    return index_1.Helpers.git.clone({ cwd: self.location, url: url, destinationFolderName: destinationFolderName });
+                    //#endregion
+                },
+                restoreLastVersion: function (localFilePath) {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.restoreLastVersion(self.location, localFilePath);
+                    //#endregion
+                },
+                stageAllFiles: function () {
+                    //#region @backendFunc
+                    index_1.Helpers.git.stageAllFiles(self.location);
+                    //#endregion
+                },
+                stash: function (optinos) {
+                    //#region @backendFunc
+                    index_1.Helpers.git.stash(self.location, optinos);
+                    //#endregion
+                },
+                stashApply: function () {
+                    //#region @backendFunc
+                    index_1.Helpers.git.stashApply(self.location);
+                    //#endregion
+                },
+                fetch: function () {
+                    //#region @backendFunc
+                    index_1.Helpers.git.fetch(self.location);
+                    //#endregion
+                },
+                resetFiles: function () {
+                    var _a;
+                    var relativePathes = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        relativePathes[_i] = arguments[_i];
+                    }
+                    //#region @backendFunc
+                    return (_a = index_1.Helpers.git).resetFiles.apply(_a, tslib_1.__spreadArray([self.location], tslib_1.__read(relativePathes), false));
+                    //#endregion
+                },
+                get isGitRepo() {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.isGitRepo(self.location);
+                    //#endregion
+                },
+                get isGitRoot() {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.isGitRoot(self.location);
+                    //#endregion
+                },
+                get originURL() {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.getOriginURL(self.location);
+                    //#endregion
+                },
+                commit: function (commitMessage) {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.commit(self.location, commitMessage);
+                    //#endregion
+                },
+                /**
+                 * alias to stage all and commit
+                 */
+                addAndCommit: function (commitMessage) {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.stageAllAndCommit(self.location, commitMessage);
+                    //#endregion
+                },
+                stageAllAndCommit: function (commitMessage) {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.stageAllAndCommit(self.location, commitMessage);
+                    //#endregion
+                },
+                pushCurrentBranch: function (options) {
+                    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*/, index_1.Helpers.git.pushCurrentBranch(self.location, options)];
+                                case 1: 
+                                //#region @backendFunc
+                                return [2 /*return*/, _a.sent()];
+                            }
+                        });
+                    });
+                },
+                get allOrigins() {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.allOrigins(self.location);
+                    //#endregion
+                },
+                get thereAreSomeUncommitedChange() {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.checkIfthereAreSomeUncommitedChange(self.location);
+                    //#endregion
+                },
+                thereAreSomeUncommitedChangeExcept: function (filesList) {
+                    if (filesList === void 0) { filesList = []; }
+                    //#region @backendFunc
+                    return index_1.Helpers.git.thereAreSomeUncommitedChangeExcept(filesList, self.location);
+                    //#endregion
+                },
+                meltActionCommits: function (soft) {
+                    if (soft === void 0) { soft = false; }
+                    //#region @backend
+                    return index_1.Helpers.git.meltActionCommits(self.location, soft);
+                    //#endregion
+                },
+                pullCurrentBranch: function (options) {
+                    return tslib_1.__awaiter(this, void 0, void 0, function () {
+                        return tslib_1.__generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: 
+                                //#region @backendFunc
+                                return [4 /*yield*/, index_1.Helpers.git.pullCurrentBranch(self.location, tslib_1.__assign({}, options))];
+                                case 1:
+                                    //#region @backendFunc
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    });
+                },
+                get currentBranchName() {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.currentBranchName(self.location);
+                    //#endregion
+                },
+                getBranchesNamesBy: function (pattern) {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.getBranchesNames(self.location, pattern);
+                    //#endregion
+                },
+                resetSoftHEAD: function (HEAD) {
+                    if (HEAD === void 0) { HEAD = 1; }
+                    //#region @backendFunc
+                    index_1.Helpers.git.resetSoftHEAD(self.location, HEAD);
+                    //#endregion
+                },
+                resetHard: function (options) {
+                    //#region @backendFunc
+                    index_1.Helpers.git.resetHard(self.location, options);
+                    //#endregion
+                },
+                countComits: function () {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.countCommits(self.location);
+                    //#endregion
+                },
+                hasAnyCommits: function () {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.hasAnyCommits(self.location);
+                    //#endregion
+                },
+                get isInMergeProcess() {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.isInMergeProcess(self.location);
+                    //#endregion
+                },
+                lastCommitDate: function () {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.lastCommitDate(self.location);
+                    //#endregion
+                },
+                lastCommitHash: function () {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.lastCommitHash(self.location);
+                    //#endregion
+                },
+                lastCommitMessage: function () {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.lastCommitMessage(self.location);
+                    //#endregion
+                },
+                penultimageCommitHash: function () {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.penultimageCommitHash(self.location);
+                    //#endregion
+                },
+                checkTagExists: function (tag) {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.checkTagExists(tag, self.location);
+                    //#endregion
+                },
+                checkout: function (branchName, options) {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.checkout(self.location, branchName, options);
+                    //#endregion
+                },
+                checkoutFromTo: function (checkoutFromBranch, branch, origin) {
+                    if (origin === void 0) { origin = 'origin'; }
+                    //#region @backendFunc
+                    return index_1.Helpers.git.checkoutFromTo(checkoutFromBranch, branch, origin, self.location);
+                    //#endregion
+                },
+                /**
+                 *
+                 * @param majorVersion example: v1, v2 etc.
+                 * @returns tag name
+                 */
+                lastTagNameForMajorVersion: function (majorVersion) {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.lastTagNameForMajorVersion(self.location, majorVersion);
+                    //#endregion
+                },
+                lastTagHash: function () {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.lastTagHash(self.location);
+                    //#endregion
+                },
+                get remoteOriginUrl() {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.getOriginURL(self.location);
+                    //#endregion
+                },
+                get lastTagVersionName() {
+                    //#region @backendFunc
+                    return (index_1.Helpers.git.lastTagVersionName(self.location) || '');
+                    //#endregion
+                },
+                get stagedFiles() {
+                    //#region @backendFunc
+                    return index_1.Helpers.git.stagedFiles(self.location);
+                    //#endregion
+                },
+                /**
+                 * TODO does this make any sense
+                 */
+                renameOrigin: function (newNameOrUlr) {
+                    //#region @backendFunc
+                    if (!newNameOrUlr.endsWith('.git')) {
+                        newNameOrUlr = (newNameOrUlr + '.git');
+                    }
+                    var oldOrigin = self.git.originURL;
+                    if (!newNameOrUlr.startsWith('git@') && !newNameOrUlr.startsWith('https://')) {
+                        newNameOrUlr = oldOrigin.replace(tnp_core_2.path.basename(oldOrigin), newNameOrUlr);
+                    }
+                    try {
+                        self.run("git remote rm origin").sync();
+                    }
+                    catch (error) { }
+                    try {
+                        self.run("git remote add origin ".concat(newNameOrUlr)).sync();
+                        index_1.Helpers.info("Origin changed:\n        from: ".concat(oldOrigin, "\n          to: ").concat(newNameOrUlr, "\n"));
+                    }
+                    catch (e) {
+                        index_1.Helpers.error("Not able to change origin.. reverting to old", true, true);
+                        self.run("git remote add origin ".concat(oldOrigin)).sync();
+                    }
+                    //#endregion
+                },
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region getters & methods / check if loggin in to npm
+    BaseProject.prototype.checkIfLogginInToNpm = function () {
+        //#region @backendFunc
+        // if (!this.canBePublishToNpmRegistry) {
+        //   return;
+        // }
+        try {
+            this.run('npm whoami').sync();
+        }
+        catch (e) {
+            index_1.Helpers.error("Please login in to npm.", false, true);
+        }
+        //#endregion
+    };
+    Object.defineProperty(BaseProject.prototype, "parentsNames", {
+        //#endregion
+        //#region getters & methods / find partners names
+        get: function () {
+            //#region @backendFunc
+            return this.findParentsNames();
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BaseProject.prototype.findParentsNames = function (project, parent, result) {
+        if (result === void 0) { result = []; }
+        //#region @backendFunc
+        if (!project && !parent) {
+            project = this;
+        }
+        if (!project && parent) {
+            return result.reverse();
+        }
+        if (project && project.parent) {
+            result.push(project.parent.name);
+        }
+        return this.findParentsNames(project.parent, project, result);
+        //#endregion
+    };
+    //#endregion
+    //#region getters & methods / init
+    /**
+     * init project files structure and depedencies
+     */
+    BaseProject.prototype.init = function (initOptions) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                throw (new Error('TODO IMPLEMENT'));
+            });
+        });
+    };
+    //#endregion
+    //#region getters & methods / link
+    /**
+     * globally link npm as package
+     */
+    BaseProject.prototype.link = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                throw (new Error('TODO IMPLEMENT'));
+            });
+        });
+    };
+    //#endregion
+    //#region getters & methods / struct
+    /**
+     * init project files structure without depedencies
+     */
+    BaseProject.prototype.struct = function (initOptions) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                throw (new Error('TODO IMPLEMENT'));
+            });
+        });
+    };
+    //#endregion
+    //#region getters & methods / build
+    /**
+    * init and build() project
+    */
+    BaseProject.prototype.build = function (buildOptions) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                throw (new Error('TODO IMPLEMENT'));
+            });
+        });
+    };
+    //#endregion
+    //#region getters & methods / lint
+    /**
+     * lint porject
+     */
+    BaseProject.prototype.lint = function (lintOptions) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                throw (new Error('TODO IMPLEMENT'));
+            });
+        });
+    };
+    //#endregion
+    //#region getters & methods / lint
+    /**
+     * get info about porject
+     */
+    BaseProject.prototype.info = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var proj;
+            return tslib_1.__generator(this, function (_a) {
+                proj = this;
+                index_1.Helpers.info("\n\n  name: ".concat(proj === null || proj === void 0 ? void 0 : proj.name, "\n  type: ").concat(proj === null || proj === void 0 ? void 0 : proj.type, "\n  children (").concat(proj === null || proj === void 0 ? void 0 : proj.children.length, "): ").concat((!proj || !proj.children.length) ? '< none >' : '', "\n").concat(proj === null || proj === void 0 ? void 0 : proj.children.map(function (c) { return '+' + c.genericName; }).join('\n'), "\n\n\n  "));
+                return [2 /*return*/];
+            });
+        });
+    };
+    //#endregion
+    //#region getters & methods / translate git commit from args
+    /**
+     * By default no translation of commit
+     */
+    BaseProject.prototype.transalteGitCommitFromArgs = function () {
+        return { from: void 0, to: void 0 };
+    };
+    //#endregion
+    //#region getters & methods / us git branches when commiting and pushing
+    /**
+     * By defult true.. when commit branches will not function.
+     * (false is better for simple projects)
+     */
+    BaseProject.prototype.useGitBranchesWhenCommitingAndPushing = function () {
+        return true;
+    };
+    //#endregion
+    //#region getters & methods / automatically add all changes when pushing to git
+    /**
+     * usefull when pushing in project with childrens as git repos
+     */
+    BaseProject.prototype.automaticallyAddAllChnagesWhenPushingToGit = function () {
+        return false;
+    };
+    //#endregion
+    //#region getters & methods / use git branches as metadata for commits
+    /**
+     * usefull when pushing in project with childrens as git repos
+     */
+    BaseProject.prototype.useGitBranchesAsMetadataForCommits = function () {
+        return true;
+    };
+    //#region static
+    //#region static / instance of resovle
+    BaseProject.ins = new base_project_resolver_1.BaseProjectResolver(BaseProject);
+    return BaseProject;
+}());
+//# sourceMappingURL=base-project.js.map