tnp-helpers 18.0.20 → 18.0.22

package/lib/base/base-git.js

@@ -0,0 +1,1202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseGit = void 0;
+var tslib_1 = require("tslib");
+//#region imports
+//#region @backend
+var tnp_core_1 = require("tnp-core");
+var translate_1 = require("./translate");
+//#endregion
+var base_feature_for_project_1 = require("./base-feature-for-project");
+var index_1 = require("../index");
+var tnp_core_2 = require("tnp-core");
+//#endregion
+var BaseGit = /** @class */ (function (_super) {
+    tslib_1.__extends(BaseGit, _super);
+    function BaseGit() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    //#region methods & getters / unstage all files
+    BaseGit.prototype.unstageAllFiles = function () {
+        //#region @backendFunc
+        index_1.Helpers.git.unstageAllFiles(this.project.location);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / revert file changes
+    BaseGit.prototype.revertFileChanges = function (fileReletivePath) {
+        //#region @backendFunc
+        index_1.Helpers.git.revertFileChanges(this.project.location, fileReletivePath);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / clone
+    BaseGit.prototype.clone = function (url_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function (url, destinationFolderName, branchName) {
+            var clondeFolderpath, error_1;
+            if (destinationFolderName === void 0) { destinationFolderName = ''; }
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, index_1.Helpers.git.clone({
+                            cwd: this.project.location,
+                            url: url,
+                            destinationFolderName: destinationFolderName,
+                        })];
+                    case 1:
+                        clondeFolderpath = _a.sent();
+                        if (!branchName) return [3 /*break*/, 5];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        index_1.Helpers.git.checkout(clondeFolderpath, branchName);
+                        return [4 /*yield*/, index_1.Helpers.git.pullCurrentBranch(clondeFolderpath, {
+                                askToRetry: true,
+                            })];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_1 = _a.sent();
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/, (0, tnp_core_2.crossPlatformPath)([
+                            clondeFolderpath,
+                            destinationFolderName || '',
+                        ]).replace(/\/$/g, '')];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / restore last version
+    BaseGit.prototype.restoreLastVersion = function (relativeFilePath) {
+        //#region @backendFunc
+        index_1.Helpers.git.restoreLastVersion(this.project.location, relativeFilePath);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / stage all files
+    BaseGit.prototype.stageAllFiles = function () {
+        //#region @backendFunc
+        index_1.Helpers.git.stageAllFiles(this.project.location);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / stash
+    BaseGit.prototype.stash = function (options) {
+        //#region @backendFunc
+        index_1.Helpers.git.stash(this.project.location, options);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / stash apply
+    BaseGit.prototype.stashApply = function () {
+        //#region @backendFunc
+        index_1.Helpers.git.stashApply(this.project.location);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / fetch
+    BaseGit.prototype.fetch = function (all) {
+        if (all === void 0) { all = false; }
+        //#region @backendFunc
+        index_1.Helpers.git.fetch(this.project.location, all);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / reset files
+    BaseGit.prototype.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([this.project.location], tslib_1.__read(relativePathes), false));
+        //#endregion
+    };
+    Object.defineProperty(BaseGit.prototype, "isInsideGitRepo", {
+        //#endregion
+        //#region methods & getters / is inside git repo
+        get: function () {
+            //#region @backendFunc
+            return index_1.Helpers.git.isInsideGitRepo(this.project.location);
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseGit.prototype, "isWithoutGitRepository", {
+        //#endregion
+        //#region methods & getters / is without git repository
+        get: function () {
+            //#region @backendFunc
+            return !tnp_core_1.fse.existsSync(tnp_core_2.path.join(this.project.location, '.git'));
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseGit.prototype, "isGitRoot", {
+        //#endregion
+        //#region methods & getters / is git root
+        get: function () {
+            //#region @backendFunc
+            return index_1.Helpers.git.isGitRoot(this.project.location);
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseGit.prototype, "originURL", {
+        //#endregion
+        //#region methods & getters / origin url
+        get: function () {
+            //#region @backendFunc
+            return index_1.Helpers.git.getOriginURL(this.project.location);
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region methods & getters / commit
+    BaseGit.prototype.commit = function (commitMessage) {
+        //#region @backendFunc
+        return index_1.Helpers.git.commit(this.project.location, commitMessage);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / add and commit
+    /**
+     * alias to stage all and commit
+     */
+    BaseGit.prototype.addAndCommit = function (commitMessage) {
+        //#region @backendFunc
+        return index_1.Helpers.git.stageAllAndCommit(this.project.location, commitMessage);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / stage all and commit
+    BaseGit.prototype.stageAllAndCommit = function (commitMessage) {
+        //#region @backendFunc
+        return index_1.Helpers.git.stageAllAndCommit(this.project.location, commitMessage);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / push current branch
+    BaseGit.prototype.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(this.project.location, options)];
+                    case 1: 
+                    //#region @backendFunc
+                    return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    Object.defineProperty(BaseGit.prototype, "allOrigins", {
+        //#endregion
+        //#region methods & getters / all origins
+        get: function () {
+            //#region @backendFunc
+            return index_1.Helpers.git.allOrigins(this.project.location);
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseGit.prototype, "uncommitedFiles", {
+        //#endregion
+        //#region methods & getters / uncommited files
+        get: function () {
+            //#region @backendFunc
+            return index_1.Helpers.git.uncommitedFiles(this.project.location);
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseGit.prototype, "thereAreSomeUncommitedChange", {
+        //#endregion
+        //#region methods & getters / there are some uncommited change
+        get: function () {
+            //#region @backendFunc
+            return index_1.Helpers.git.checkIfthereAreSomeUncommitedChange(this.project.location);
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region methods & getters / there are some uncommited change except
+    BaseGit.prototype.thereAreSomeUncommitedChangeExcept = function (filesList) {
+        if (filesList === void 0) { filesList = []; }
+        //#region @backendFunc
+        return index_1.Helpers.git.thereAreSomeUncommitedChangeExcept(filesList, this.project.location);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / melt action commits
+    BaseGit.prototype.meltActionCommits = function () {
+        //#region @backend
+        return index_1.Helpers.git.meltActionCommits(this.project.location);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / pull current branch
+    BaseGit.prototype.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(this.project.location, tslib_1.__assign({}, options))];
+                    case 1:
+                        //#region @backendFunc
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Object.defineProperty(BaseGit.prototype, "currentBranchName", {
+        //#endregion
+        //#region methods & getters / current branch name
+        get: function () {
+            //#region @backendFunc
+            return index_1.Helpers.git.currentBranchName(this.project.location);
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseGit.prototype, "listOfCurrentGitChanges", {
+        //#endregion
+        //#region methods & getters / list of current git changes
+        get: function () {
+            //#region @backendFunc
+            return index_1.Helpers.git.getListOfCurrentGitChanges(this.project.location);
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region methods & getters / get branches names by
+    BaseGit.prototype.getBranchesNamesBy = function (pattern) {
+        //#region @backendFunc
+        return index_1.Helpers.git.getBranchesNames(this.project.location, pattern);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / reset soft HEAD
+    BaseGit.prototype.resetSoftHEAD = function (HEAD) {
+        if (HEAD === void 0) { HEAD = 1; }
+        //#region @backendFunc
+        index_1.Helpers.git.resetSoftHEAD(this.project.location, HEAD);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / reset hard
+    BaseGit.prototype.resetHard = function (options) {
+        //#region @backendFunc
+        index_1.Helpers.git.resetHard(this.project.location, options);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / count commits
+    BaseGit.prototype.countComits = function () {
+        //#region @backendFunc
+        return index_1.Helpers.git.countCommits(this.project.location);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / has any commits
+    BaseGit.prototype.hasAnyCommits = function () {
+        //#region @backendFunc
+        return index_1.Helpers.git.hasAnyCommits(this.project.location);
+        //#endregion
+    };
+    Object.defineProperty(BaseGit.prototype, "isInMergeProcess", {
+        //#endregion
+        //#region methods & getters / is in merge process
+        get: function () {
+            //#region @backendFunc
+            return index_1.Helpers.git.isInMergeProcess(this.project.location);
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region methods & getters / last commit date
+    BaseGit.prototype.lastCommitDate = function () {
+        //#region @backendFunc
+        return index_1.Helpers.git.lastCommitDate(this.project.location);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / last commit hash
+    BaseGit.prototype.lastCommitHash = function () {
+        //#region @backendFunc
+        return index_1.Helpers.git.lastCommitHash(this.project.location);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / last commit message
+    BaseGit.prototype.lastCommitMessage = function () {
+        //#region @backendFunc
+        return index_1.Helpers.git.lastCommitMessage(this.project.location);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / last commit message
+    BaseGit.prototype.penultimateCommitMessage = 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*/, index_1.Helpers.git.penultimateCommitMessage(this.project.location)];
+                    case 1: 
+                    //#region @backendFunc
+                    return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / get commit message by index
+    BaseGit.prototype.getCommitMessageByIndex = function (index) {
+        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.getCommitMessageByIndex(this.project.location, index)];
+                    case 1: 
+                    //#region @backendFunc
+                    return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / get commit message by hash
+    BaseGit.prototype.getCommitMessageByHash = function (hash) {
+        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.getCommitMessageByHash(this.project.location, hash)];
+                    case 1: 
+                    //#region @backendFunc
+                    return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / get commit hash by index
+    BaseGit.prototype.getCommitHashByIndex = function (index) {
+        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.getCommitHashByIndex(this.project.location, index)];
+                    case 1: 
+                    //#region @backendFunc
+                    return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / penultimate commit hash
+    BaseGit.prototype.penultimateCommitHash = function () {
+        //#region @backendFunc
+        return index_1.Helpers.git.penultimateCommitHash(this.project.location);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / check tag exists
+    BaseGit.prototype.checkTagExists = function (tag) {
+        //#region @backendFunc
+        return index_1.Helpers.git.checkTagExists(tag, this.project.location);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / checkout
+    BaseGit.prototype.checkout = function (branchName, options) {
+        //#region @backendFunc
+        return index_1.Helpers.git.checkout(this.project.location, branchName, options);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / checkout from to
+    BaseGit.prototype.checkoutFromTo = function (checkoutFromBranch, branch, origin) {
+        if (origin === void 0) { origin = 'origin'; }
+        //#region @backendFunc
+        return index_1.Helpers.git.checkoutFromTo(checkoutFromBranch, branch, origin, this.project.location);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / last tag name for major version
+    /**
+     *
+     * @param majorVersion example: v1, v2 etc.
+     * @returns tag name
+     */
+    BaseGit.prototype.lastTagNameForMajorVersion = function (majorVersion) {
+        //#region @backendFunc
+        return index_1.Helpers.git.lastTagNameForMajorVersion(this.project.location, majorVersion);
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / last tag hash
+    BaseGit.prototype.lastTagHash = function () {
+        //#region @backendFunc
+        return index_1.Helpers.git.lastTagHash(this.project.location);
+        //#endregion
+    };
+    Object.defineProperty(BaseGit.prototype, "remoteOriginUrl", {
+        //#endregion
+        //#region methods & getters / remote origin url
+        get: function () {
+            //#region @backendFunc
+            return index_1.Helpers.git.getOriginURL(this.project.location);
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseGit.prototype, "lastTagVersionName", {
+        //#endregion
+        //#region methods & getters / last tag version name
+        get: function () {
+            //#region @backendFunc
+            return index_1.Helpers.git.lastTagVersionName(this.project.location) || '';
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseGit.prototype, "stagedFiles", {
+        //#endregion
+        //#region methods & getters / staged files
+        get: function () {
+            //#region @backendFunc
+            return index_1.Helpers.git.stagedFiles(this.project.location);
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region methods & getters / rename origin
+    /**
+     * TODO does this make any sense
+     */
+    BaseGit.prototype.renameOrigin = function (newNameOrUlr) {
+        //#region @backendFunc
+        if (!newNameOrUlr.endsWith('.git')) {
+            newNameOrUlr = newNameOrUlr + '.git';
+        }
+        var oldOrigin = this.project.git.originURL;
+        if (!newNameOrUlr.startsWith('git@') &&
+            !newNameOrUlr.startsWith('https://')) {
+            newNameOrUlr = oldOrigin.replace(tnp_core_2.path.basename(oldOrigin), newNameOrUlr);
+        }
+        try {
+            this.project.run("git remote rm origin").sync();
+        }
+        catch (error) { }
+        try {
+            this.project.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);
+            this.project.run("git remote add origin ".concat(oldOrigin)).sync();
+        }
+        //#endregion
+    };
+    //#endregion
+    //#region getters & methods / translate git commit from args
+    /**
+     * By default no translation of commit
+     */
+    BaseGit.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)
+     */
+    BaseGit.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
+     */
+    BaseGit.prototype.automaticallyAddAllChangesWhenPushingToGit = function () {
+        return false;
+    };
+    //#endregion
+    //#region getters & methods / use git branches as metadata for commits
+    /**
+     * usefull when pushing in project with childrens as git repos
+     */
+    BaseGit.prototype.useGitBranchesAsMetadataForCommits = function () {
+        return true;
+    };
+    //#endregion
+    //#region getters & methods / clone to
+    BaseGit.prototype.cloneTo = function (cwd, newProjectName) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var dest, res;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        //#region @backendFunc
+                        if (!newProjectName) {
+                            newProjectName = tnp_core_2.path.basename(this.project.location);
+                        }
+                        dest = (0, tnp_core_2.crossPlatformPath)([newProjectName, newProjectName]);
+                        if (!tnp_core_1.fse.existsSync(dest)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo("Folder ".concat(newProjectName, " alredy exist, delete it ?"))];
+                    case 1:
+                        res = _a.sent();
+                        if (res) {
+                            index_1.Helpers.tryRemoveDir(dest);
+                        }
+                        else {
+                            index_1.Helpers.pressKeyAndContinue('Operation not completed... press any key');
+                            return [2 /*return*/, false];
+                        }
+                        _a.label = 2;
+                    case 2:
+                        index_1.Helpers.info("Cloning ".concat(this.project.name, "..."));
+                        // copy instead cloning
+                        return [4 /*yield*/, index_1.Helpers.git.clone({
+                                cwd: cwd,
+                                url: this.project.git.remoteOriginUrl,
+                                destinationFolderName: newProjectName,
+                            })];
+                    case 3:
+                        // copy instead cloning
+                        _a.sent();
+                        index_1.Helpers.info("Clone success");
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    Object.defineProperty(BaseGit.prototype, "gitChildren", {
+        //#endregion
+        //#region getters & methods / get children
+        /**
+         * This is only for push/pull process
+         *
+         * There are 2 types of projects:
+         * - with linked-projects.json
+         * - with children from external folder
+         *
+         * projects that are children of this project (with its own git repo)
+         */
+        get: function () {
+            var _this = this;
+            var childrenRepos = [];
+            if (this.project.linkedProjects.linkedProjects.length > 0) {
+                childrenRepos = this.project.linkedProjects.linkedProjects
+                    .map(function (c) {
+                    return _this.project.ins.From([
+                        _this.project.location,
+                        c.relativeClonePath,
+                    ]);
+                })
+                    .filter(function (f) { return !!f; });
+            }
+            else {
+                childrenRepos = this.project.children;
+            }
+            childrenRepos = childrenRepos.filter(function (f) { return f.git.isInsideGitRepo && f.git.isGitRoot; });
+            return childrenRepos;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region getters & methods / set remote origin type
+    BaseGit.prototype.setRemoteOriginType = function (setOrigin) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        //#region @backendFunc
+                        if (setOrigin === 'https') {
+                            setOrigin = 'http';
+                        }
+                        if (!(setOrigin === 'ssh')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, index_1.Helpers.git.changeRemoteFromHttpsToSSh(this.project.location)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        if (!(setOrigin === 'http')) return [3 /*break*/, 4];
+                        return [4 /*yield*/, index_1.Helpers.git.changeRemoveFromSshToHttps(this.project.location)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / push process
+    BaseGit.prototype.pullProcess = function () {
+        return tslib_1.__awaiter(this, arguments, void 0, function (options) {
+            var cloneChildren, setOrigin, uncommitedChanges, location, _a, _b, child, e_1_1;
+            var e_1, _c;
+            if (options === void 0) { options = {}; }
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        //#region @backendFunc
+                        options = options || {};
+                        options.cloneChildren = !!options.cloneChildren;
+                        cloneChildren = options.cloneChildren, setOrigin = options.setOrigin;
+                        return [4 /*yield*/, this._beforePullProcessAction(setOrigin, cloneChildren)];
+                    case 1:
+                        _d.sent();
+                        return [4 /*yield*/, this.setRemoteOriginType(setOrigin)];
+                    case 2:
+                        _d.sent();
+                        uncommitedChanges = this.project.git.thereAreSomeUncommitedChange;
+                        if (uncommitedChanges) {
+                            index_1.Helpers.warn("Stashing uncommit changes... in ".concat(this.project.genericName));
+                            try {
+                                this.project.git.stageAllFiles();
+                            }
+                            catch (error) { }
+                            try {
+                                this.project.git.stash();
+                            }
+                            catch (error) { }
+                        }
+                        return [4 /*yield*/, this.project.git.pullCurrentBranch({ askToRetry: true })];
+                    case 3:
+                        _d.sent();
+                        location = this.project.location;
+                        this.project.ins.unload(this);
+                        this.project.ins.add(this.project.ins.From(location));
+                        return [4 /*yield*/, this.project.linkedProjects.saveLocationToDB()];
+                    case 4:
+                        _d.sent();
+                        if (!(this.automaticallyAddAllChangesWhenPushingToGit() || cloneChildren)) return [3 /*break*/, 12];
+                        _d.label = 5;
+                    case 5:
+                        _d.trys.push([5, 10, 11, 12]);
+                        _a = tslib_1.__values(this.gitChildren), _b = _a.next();
+                        _d.label = 6;
+                    case 6:
+                        if (!!_b.done) return [3 /*break*/, 9];
+                        child = _b.value;
+                        return [4 /*yield*/, child.git.pullProcess(options)];
+                    case 7:
+                        _d.sent();
+                        _d.label = 8;
+                    case 8:
+                        _b = _a.next();
+                        return [3 /*break*/, 6];
+                    case 9: return [3 /*break*/, 12];
+                    case 10:
+                        e_1_1 = _d.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 12];
+                    case 11:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 12: return [4 /*yield*/, this.project.linkedProjects.saveAllLinkedProjectsToDB()];
+                    case 13:
+                        _d.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / push process
+    BaseGit.prototype.pushProcess = function () {
+        return tslib_1.__awaiter(this, arguments, void 0, function (options) {
+            var _a, force, typeofCommit, skipLint, forcePushNoQuestion, _b, origin, exitCallBack, askToConfirmPush, askToConfirmCommit, askToConfirmBranchChange, _c, args, commitMessageRequired, overrideCommitMessage, skipChildren, setOrigin, currentOrigin, mergeUpdateCommits, commitData, mergeAction, action, _d, error_2, numberOfStagedFiles, error_3, commitMessageFromBranch, lastCommitMessage_1, _e, _f, child, e_2_1;
+            var e_2, _g;
+            var _this = this;
+            var _h, _j, _k, _l;
+            if (options === void 0) { options = {}; }
+            return tslib_1.__generator(this, function (_m) {
+                switch (_m.label) {
+                    case 0:
+                        _a = options.force, force = _a === void 0 ? false : _a, typeofCommit = options.typeofCommit, skipLint = options.skipLint, forcePushNoQuestion = options.forcePushNoQuestion, _b = options.origin, origin = _b === void 0 ? 'origin' : _b, exitCallBack = options.exitCallBack, askToConfirmPush = options.askToConfirmPush, askToConfirmCommit = options.askToConfirmCommit, askToConfirmBranchChange = options.askToConfirmBranchChange, _c = options.args, args = _c === void 0 ? [] : _c, commitMessageRequired = options.commitMessageRequired, overrideCommitMessage = options.overrideCommitMessage, skipChildren = options.skipChildren, setOrigin = options.setOrigin, currentOrigin = options.currentOrigin, mergeUpdateCommits = options.mergeUpdateCommits;
+                        return [4 /*yield*/, this._beforePushProcessAction(setOrigin)];
+                    case 1:
+                        _m.sent();
+                        return [4 /*yield*/, this.setRemoteOriginType(setOrigin)];
+                    case 2:
+                        _m.sent();
+                        return [4 /*yield*/, this.project.linkedProjects.saveLocationToDB()];
+                    case 3:
+                        _m.sent();
+                        return [4 /*yield*/, this._getCommitMessage(typeofCommit, args, commitMessageRequired, currentOrigin)];
+                    case 4:
+                        commitData = _m.sent();
+                        if (!(mergeUpdateCommits && this.project.git.stagedFiles.length > 0)) return [3 /*break*/, 13];
+                        //#region merge update commits
+                        index_1.Helpers.logInfo("Pushing detailed changes to project: ".concat(this.project.genericName));
+                        index_1.Helpers.logInfo("Modified files... ");
+                        index_1.Helpers.logInfo(tslib_1.__spreadArray([], tslib_1.__read(this.project.git.stagedFiles), false).map(function (f) { return " - ".concat(tnp_core_1.chalk.underline(f)); })
+                            .join('\n'));
+                        _m.label = 5;
+                    case 5:
+                        if (!true) return [3 /*break*/, 13];
+                        mergeAction = {
+                            useUpdateCommit: {
+                                name: "Use temporary update commit " +
+                                    "\"".concat(index_1.Helpers.git.ACTION_MSG_RESET_GIT_HARD_COMMIT, "\" and force push"),
+                            },
+                            provideCommitMessage: {
+                                name: 'Provide commit message and force push',
+                            },
+                            resetRemoveChanges: {
+                                name: 'Reset/remove changes and force push',
+                            },
+                            openInVscode: {
+                                name: 'Open project in vscode',
+                            },
+                        };
+                        if (!force) return [3 /*break*/, 6];
+                        _d = 'useUpdateCommit';
+                        return [3 /*break*/, 8];
+                    case 6: return [4 /*yield*/, index_1.UtilsTerminal.select({
+                            choices: mergeAction,
+                            question: 'What to do ?',
+                        })];
+                    case 7:
+                        _d = _m.sent();
+                        _m.label = 8;
+                    case 8:
+                        action = _d;
+                        if (action === 'openInVscode') {
+                            index_1.Helpers.run("code .", { cwd: this.project.location }).sync();
+                            return [3 /*break*/, 5];
+                        }
+                        if (action === 'resetRemoveChanges') {
+                            force = true;
+                            forcePushNoQuestion = true;
+                            this.project.git.resetHard();
+                            return [3 /*break*/, 13];
+                        }
+                        if (action === 'useUpdateCommit') {
+                            force = true;
+                            forcePushNoQuestion = true;
+                            overrideCommitMessage = index_1.Helpers.git.ACTION_MSG_RESET_GIT_HARD_COMMIT;
+                        }
+                        if (!(action === 'provideCommitMessage')) return [3 /*break*/, 12];
+                        force = true;
+                        forcePushNoQuestion = true;
+                        _m.label = 9;
+                    case 9:
+                        _m.trys.push([9, 11, , 12]);
+                        return [4 /*yield*/, index_1.Helpers.input({
+                                question: "Please provide commit message for current changes:",
+                                defaultValue: 'update',
+                            })];
+                    case 10:
+                        overrideCommitMessage = _m.sent();
+                        return [3 /*break*/, 12];
+                    case 11:
+                        error_2 = _m.sent();
+                        return [3 /*break*/, 12];
+                    case 12:
+                        if (overrideCommitMessage) {
+                            return [3 /*break*/, 13];
+                        }
+                        return [3 /*break*/, 5];
+                    case 13:
+                        if (!(commitData.typeOfCommit === 'feature' &&
+                            ((_h = commitData.jiraNumbers) === null || _h === void 0 ? void 0 : _h.length) === 1 &&
+                            ((_j = commitData.issuesFromOtherProjects) === null || _j === void 0 ? void 0 : _j.length) === 0)) return [3 /*break*/, 15];
+                        index_1.Helpers.info("\n\n        You current feature branch \"".concat(this.project.git.currentBranchName, "\"\n        doesn't have ").concat(tnp_core_1.chalk.bold('main-issue'), " and ").concat(tnp_core_1.chalk.bold('sub-issue'), " inlcueded.\n\n        Proper example: feature/JIRANUM-<number-of-sub-issue>-JIRANUM-<number-of-main-issue>-commit-name\n\n          "));
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo('Continue without sub-issue?')];
+                    case 14:
+                        if (!(_m.sent())) {
+                            process.exit(0);
+                        }
+                        _m.label = 15;
+                    case 15:
+                        //#endregion
+                        //#region automatic push to git
+                        if (!this.automaticallyAddAllChangesWhenPushingToGit()) {
+                            if ((_k = commitData.commitMessage) === null || _k === void 0 ? void 0 : _k.split(':').map(function (p) { return p.trim(); }).every(function (p) { return p === _this.project.git.currentBranchName; })) {
+                                // QUICK_FIX
+                                index_1.Helpers.error("\n\n        Please provide more specific commit message than branch name\n        or maybe you forgot ?\n        TEAM ID? (example TEAM2# <= hash at the end)\n\n        ", false, true);
+                            }
+                        }
+                        //#endregion
+                        //#region lint
+                        if (commitData.typeOfCommit === 'release') {
+                            skipLint = true;
+                        }
+                        numberOfStagedFiles = this.project.git.stagedFiles.length;
+                        if (numberOfStagedFiles === 0) {
+                            index_1.Helpers.warn("No staged files...");
+                            skipLint = true;
+                        }
+                        if (!!skipLint) return [3 /*break*/, 22];
+                        _m.label = 16;
+                    case 16:
+                        if (!true) return [3 /*break*/, 22];
+                        _m.label = 17;
+                    case 17:
+                        _m.trys.push([17, 19, , 21]);
+                        return [4 /*yield*/, this.project.lint()];
+                    case 18:
+                        _m.sent();
+                        return [3 /*break*/, 22];
+                    case 19:
+                        error_3 = _m.sent();
+                        index_1.Helpers.warn('Fix your code...');
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.question.yesNo('Try again lint before commit ?')];
+                    case 20:
+                        if (!(_m.sent())) {
+                            return [3 /*break*/, 22];
+                        }
+                        return [3 /*break*/, 21];
+                    case 21: return [3 /*break*/, 16];
+                    case 22:
+                        //#endregion
+                        if (this.project.useFeatureInBranchNameForTests() &&
+                            commitData.typeOfCommit === 'test') {
+                            commitData.useFeatureBranchForTestBranch = true;
+                        }
+                        if (!!commitData.isActionCommit) return [3 /*break*/, 27];
+                        return [4 /*yield*/, index_1.CommitData.getFromBranch(commitData.branchName, {
+                                currentOrigin: currentOrigin,
+                            })];
+                    case 23:
+                        commitMessageFromBranch = (_m.sent()).commitMessage;
+                        index_1.Helpers.info("\n\n      PROJECT: ".concat(this.project.genericName, "\n\n      Current commit:\n      - message to include {").concat(overrideCommitMessage ? overrideCommitMessage : commitData.commitMessage, "}\n      ").concat(this.useGitBranchesAsMetadataForCommits() && !overrideCommitMessage
+                            ? "- branch to checkout {".concat(commitData.branchName, "}")
+                            : "- using ".concat(tnp_core_1.chalk.bold('current'), " branch {").concat(this.project.git.currentBranchName, "} \n\n          (generated would be: ").concat(commitData.branchName, ")\n          ")));
+                        if (!overrideCommitMessage &&
+                            commitMessageFromBranch !== commitData.commitMessage) {
+                            index_1.Helpers.logWarn("Commit from args and commit from branch are different\n        commit message from args: ".concat(commitData.commitMessage, "\n        commit message from branch: ").concat(commitMessageFromBranch, "\n\n        ADVICE: Is is better to use words instead characters to describe multiple\n        commit changes in one commit message\n\n        "));
+                        }
+                        else {
+                            index_1.Helpers.logInfo(tnp_core_1.chalk.gray("Commit from args and commit from branch are the same..."));
+                        }
+                        lastCommitMessage_1 = this.project.git.lastCommitMessage();
+                        if (!(lastCommitMessage_1 &&
+                            [commitData.commitMessage, overrideCommitMessage]
+                                .filter(function (f) { return !!f; })
+                                .some(function (m) { return m === lastCommitMessage_1; }))) return [3 /*break*/, 25];
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo('Soft reset last commit with same message ?')];
+                    case 24:
+                        if (_m.sent()) {
+                            this.project.git.resetSoftHEAD(1);
+                        }
+                        _m.label = 25;
+                    case 25: return [4 /*yield*/, index_1.Helpers.questionYesNo('Commit and push this ?')];
+                    case 26:
+                        if (!(_m.sent())) {
+                            exitCallBack();
+                        }
+                        _m.label = 27;
+                    case 27:
+                        if (this.automaticallyAddAllChangesWhenPushingToGit()) {
+                            // my project
+                            this.project.git.stageAllFiles();
+                        }
+                        if (!(this.useGitBranchesAsMetadataForCommits() && !overrideCommitMessage)) return [3 /*break*/, 30];
+                        index_1.Helpers.info('Checkingout branches (if needed)...');
+                        if (!(((_l = this.project.git.currentBranchName) === null || _l === void 0 ? void 0 : _l.trim()) !== commitData.branchName)) return [3 /*break*/, 30];
+                        if (!askToConfirmBranchChange) return [3 /*break*/, 29];
+                        index_1.Helpers.info("Changing branch to: ".concat(commitData.branchName));
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo('Confirm branch change ?')];
+                    case 28:
+                        if (!(_m.sent())) {
+                            exitCallBack();
+                        }
+                        _m.label = 29;
+                    case 29:
+                        try {
+                            this.project.git.checkout(commitData.branchName, {
+                                createBranchIfNotExists: true,
+                            });
+                        }
+                        catch (error) {
+                            index_1.Helpers.error('Please modyfiy you commit message or delete branch,');
+                        }
+                        _m.label = 30;
+                    case 30:
+                        if (!askToConfirmCommit) return [3 /*break*/, 32];
+                        index_1.Helpers.info("Commit message: ".concat(overrideCommitMessage
+                            ? overrideCommitMessage
+                            : commitData.commitMessage));
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo('Confirm commit ?')];
+                    case 31:
+                        if (!(_m.sent())) {
+                            exitCallBack();
+                        }
+                        _m.label = 32;
+                    case 32:
+                        try {
+                            this.project.git.commit(overrideCommitMessage
+                                ? overrideCommitMessage
+                                : commitData.commitMessage);
+                        }
+                        catch (error) {
+                            index_1.Helpers.warn("Not commiting anything... ");
+                        }
+                        if (!askToConfirmPush) return [3 /*break*/, 34];
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo('Confirm push ?')];
+                    case 33:
+                        if (!(_m.sent())) {
+                            exitCallBack();
+                        }
+                        _m.label = 34;
+                    case 34: return [4 /*yield*/, this.project.git.pushCurrentBranch({
+                            force: force,
+                            origin: origin,
+                            forcePushNoQuestion: forcePushNoQuestion,
+                            askToRetry: true,
+                        })];
+                    case 35:
+                        _m.sent();
+                        if (!(this.automaticallyAddAllChangesWhenPushingToGit() && !skipChildren)) return [3 /*break*/, 45];
+                        if (this.project.linkedProjects.getLinkedProjectsConfig().skipRecrusivePush) {
+                            index_1.Helpers.warn("Skipping recrusive (children) push for ".concat(this.project.genericName));
+                            return [2 /*return*/];
+                        }
+                        _m.label = 36;
+                    case 36:
+                        _m.trys.push([36, 43, 44, 45]);
+                        _e = tslib_1.__values(this.gitChildren), _f = _e.next();
+                        _m.label = 37;
+                    case 37:
+                        if (!!_f.done) return [3 /*break*/, 42];
+                        child = _f.value;
+                        if (!mergeUpdateCommits) return [3 /*break*/, 39];
+                        return [4 /*yield*/, child.git.meltActionCommits()];
+                    case 38:
+                        _m.sent();
+                        _m.label = 39;
+                    case 39: return [4 /*yield*/, child.git.pushProcess(options)];
+                    case 40:
+                        _m.sent();
+                        _m.label = 41;
+                    case 41:
+                        _f = _e.next();
+                        return [3 /*break*/, 37];
+                    case 42: return [3 /*break*/, 45];
+                    case 43:
+                        e_2_1 = _m.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 45];
+                    case 44:
+                        try {
+                            if (_f && !_f.done && (_g = _e.return)) _g.call(_e);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 45: return [4 /*yield*/, this.project.linkedProjects.saveAllLinkedProjectsToDB()];
+                    case 46:
+                        _m.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / before any action on git root
+    BaseGit.prototype._beforeAnyActionOnGitRoot = function () {
+        //#region @backendFunc
+        if (!this.project.git.isInsideGitRepo) {
+            index_1.Helpers.error("Project ".concat(tnp_core_1.chalk.bold(this.project.name), " is not a git repository\n      locaiton: ").concat(this.project.location), false, true);
+        }
+        if (!this.project.git.isGitRoot) {
+            index_1.Helpers.error("Project ".concat(tnp_core_1.chalk.bold(this.project.name), " is not a git root\n      locaiton: ").concat(this.project.location), false, true);
+        }
+        //#endregion
+    };
+    //#endregion
+    //#region methods & getters / before push action
+    BaseGit.prototype._beforePushProcessAction = function (setOrigin) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        //#region @backendFunc
+                        this._beforeAnyActionOnGitRoot();
+                        if (!(this.project.git.isInsideGitRepo &&
+                            this.project.git.isGitRoot &&
+                            !((_a = this.project.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.project.git.checkout('master');
+                            this.project.git.stageAllFiles();
+                            this.project.git.commit('first commit ');
+                        }
+                        _b.label = 2;
+                    case 2: return [4 /*yield*/, this.project.linkedProjects.cloneUnexistedLinkedProjects('push', setOrigin)];
+                    case 3:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / before push action
+    BaseGit.prototype._beforePullProcessAction = function (setOrigin_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function (setOrigin, cloneChildren) {
+            if (cloneChildren === void 0) { cloneChildren = false; }
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        //#region @backendFunc
+                        this._beforeAnyActionOnGitRoot();
+                        return [4 /*yield*/, this.project.linkedProjects.cloneUnexistedLinkedProjects('pull', setOrigin, cloneChildren)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / resovle commit message
+    BaseGit.prototype._getCommitMessage = function (typeOfCommit, args, commitMessageRequired, 
+    /**
+     * only needed when push github
+     * and I forgot to add my username before issue
+     * taon pfix proper input my-repo#344
+     * that should be
+     * taon pfix proper input my-username/my-repo#344
+     */
+    currentOrigin) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var commitData, argsCommitData, commitDataBranch, argsCommitData, _a, from, to, _b, _c, _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: typeOfCommit,
+                                currentOrigin: currentOrigin,
+                            })];
+                    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.project.git.currentBranchName, {
+                            releaseWords: this.project.releaseProcess.getReleaseWords(),
+                            currentOrigin: currentOrigin,
+                        })];
+                    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: typeOfCommit,
+                            currentOrigin: currentOrigin,
+                        })];
+                    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];
+                        _a = this.transalteGitCommitFromArgs(), from = _a.from, to = _a.to;
+                        if (!(from && to)) return [3 /*break*/, 9];
+                        _b = commitData;
+                        _d = (_c = tnp_core_2._).kebabCase;
+                        return [4 /*yield*/, (0, translate_1.translate)(commitData.message, { from: from, to: to })];
+                    case 8:
+                        _b.message = _d.apply(_c, [_e.sent()]);
+                        _e.label = 9;
+                    case 9: return [2 /*return*/, commitData];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / prevent accidental branch change for taon projects
+    /**
+     * This will prevent accidental branch change for taon projects
+     * @returns branch name
+     */
+    BaseGit.prototype.duringPushWarnIfProjectNotOnSpecyficDevBranch = function () {
+        return void 0;
+    };
+    //#endregion
+    //#region methods & getters / get changed files in commit by hash
+    BaseGit.prototype.getChangedFilesInCommitByHash = function (hash) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                //#region @backendFunc
+                return [2 /*return*/, index_1.Helpers.git.getChangedFilesInCommitByHash(this.project.location, hash)];
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / get changed files in commit
+    /**
+     * @param index 0 - means last commit
+     */
+    BaseGit.prototype.getChangedFilesInCommitByIndex = function (index) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                //#region @backendFunc
+                return [2 /*return*/, index_1.Helpers.git.getChangedFilesInCommitByIndex(this.project.location, index)];
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / get changes summary
+    BaseGit.prototype.changesSummary = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var fillStringWithSpaceUpTo;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fillStringWithSpaceUpTo = function (str, length, specialCharacter) {
+                            if (specialCharacter === void 0) { specialCharacter = ' '; }
+                            return str + specialCharacter.repeat(length - str.length);
+                        };
+                        return [4 /*yield*/, index_1.Helpers.git.changesSummary(this.project.location, "".concat(fillStringWithSpaceUpTo("[".concat(this.project.name, "]"), 40, '.'), " "))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return BaseGit;
+}(base_feature_for_project_1.BaseFeatureForProject));
+exports.BaseGit = BaseGit;
+//# sourceMappingURL=base-git.js.map