tnp-helpers 16.444.16 → 16.444.18

package/lib/base/base-git.js

@@ -0,0 +1,856 @@
+"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
+    };
+    //#region methods & getters /
+    //#region methods & getters / clone
+    BaseGit.prototype.clone = function (url, destinationFolderName, branchName) {
+        if (destinationFolderName === void 0) { destinationFolderName = ''; }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var clondeFolderpath, error_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        clondeFolderpath = index_1.Helpers.git.clone({
+                            cwd: this.project.location,
+                            url: url,
+                            destinationFolderName: destinationFolderName,
+                        });
+                        if (!branchName) return [3 /*break*/, 4];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        index_1.Helpers.git.checkout(clondeFolderpath, branchName);
+                        return [4 /*yield*/, index_1.Helpers.git.pullCurrentBranch(clondeFolderpath, {
+                                askToRetry: true,
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/, (0, tnp_core_2.crossPlatformPath)([
+                            clondeFolderpath,
+                            destinationFolderName || '',
+                        ]).replace(/\/$/g, '')];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / restore last version
+    BaseGit.prototype.restoreLastVersion = function (localFilePath) {
+        //#region @backendFunc
+        return index_1.Helpers.git.restoreLastVersion(this.project.location, localFilePath);
+        //#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 (optinos) {
+        //#region @backendFunc
+        index_1.Helpers.git.stash(this.project.location, optinos);
+        //#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 () {
+        //#region @backendFunc
+        index_1.Helpers.git.fetch(this.project.location);
+        //#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 (soft) {
+        if (soft === void 0) { soft = false; }
+        //#region @backend
+        return index_1.Helpers.git.meltActionCommits(this.project.location, soft);
+        //#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 / 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.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
+     */
+    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, "..."));
+                        // @LAST copy instead cloning
+                        index_1.Helpers.git.clone({
+                            cwd: cwd,
+                            url: this.project.git.remoteOriginUrl,
+                            destinationFolderName: newProjectName,
+                        });
+                        index_1.Helpers.info("Clone success");
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / push process
+    BaseGit.prototype.pullProcess = function (cloneChildren) {
+        if (cloneChildren === void 0) { cloneChildren = false; }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var uncommitedChanges, location, 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 @backendFunc
+                    return [4 /*yield*/, this._beforePullProcessAction(cloneChildren)];
+                    case 1:
+                        //#region @backendFunc
+                        _b.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 2:
+                        _b.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 3:
+                        _b.sent();
+                        if (!(this.automaticallyAddAllChnagesWhenPushingToGit() || cloneChildren)) return [3 /*break*/, 11];
+                        childrenRepos = this.project.children.filter(function (f) { return f.git.isInsideGitRepo && f.git.isGitRoot; });
+                        _b.label = 4;
+                    case 4:
+                        _b.trys.push([4, 9, 10, 11]);
+                        childrenRepos_1 = tslib_1.__values(childrenRepos), childrenRepos_1_1 = childrenRepos_1.next();
+                        _b.label = 5;
+                    case 5:
+                        if (!!childrenRepos_1_1.done) return [3 /*break*/, 8];
+                        child = childrenRepos_1_1.value;
+                        return [4 /*yield*/, child.pullProcess()];
+                    case 6:
+                        _b.sent();
+                        _b.label = 7;
+                    case 7:
+                        childrenRepos_1_1 = childrenRepos_1.next();
+                        return [3 /*break*/, 5];
+                    case 8: return [3 /*break*/, 11];
+                    case 9:
+                        e_1_1 = _b.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 11];
+                    case 10:
+                        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 11: return [4 /*yield*/, this.project.linkedProjects.saveAllLinkedProjectsToDB()];
+                    case 12:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / push process
+    BaseGit.prototype.pushProcess = function (options) {
+        var _a, _b;
+        if (options === void 0) { options = {}; }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _c, force, typeofCommit, forcePushNoQuestion, _d, origin, exitCallBack, _e, args, commitMessageRequired, skipChildren, commitData, error_2, childrenRepos, childrenRepos_2, childrenRepos_2_1, child, e_2_1;
+            var e_2, _f;
+            var _this = this;
+            return tslib_1.__generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        _c = options.force, force = _c === void 0 ? false : _c, typeofCommit = options.typeofCommit, forcePushNoQuestion = options.forcePushNoQuestion, _d = options.origin, origin = _d === void 0 ? 'origin' : _d, exitCallBack = options.exitCallBack, _e = options.args, args = _e === void 0 ? [] : _e, commitMessageRequired = options.commitMessageRequired, skipChildren = options.skipChildren;
+                        return [4 /*yield*/, this._beforePushProcessAction()];
+                    case 1:
+                        _g.sent();
+                        return [4 /*yield*/, this.project.linkedProjects.saveLocationToDB()];
+                    case 2:
+                        _g.sent();
+                        return [4 /*yield*/, this._getCommitMessage(typeofCommit, args, commitMessageRequired)];
+                    case 3:
+                        commitData = _g.sent();
+                        if (!this.automaticallyAddAllChnagesWhenPushingToGit()) {
+                            if ((_a = commitData.commitMessage) === null || _a === void 0 ? void 0 : _a.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\n\n        ", false, true);
+                            }
+                        }
+                        _g.label = 4;
+                    case 4:
+                        if (!true) return [3 /*break*/, 10];
+                        _g.label = 5;
+                    case 5:
+                        _g.trys.push([5, 7, , 9]);
+                        return [4 /*yield*/, this.project.lint()];
+                    case 6:
+                        _g.sent();
+                        return [3 /*break*/, 10];
+                    case 7:
+                        error_2 = _g.sent();
+                        index_1.Helpers.warn('Fix your code...');
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.question.yesNo('Try again lint before commit ?')];
+                    case 8:
+                        if (!(_g.sent())) {
+                            return [3 /*break*/, 10];
+                        }
+                        return [3 /*break*/, 9];
+                    case 9: return [3 /*break*/, 4];
+                    case 10:
+                        if (!!commitData.isActionCommit) return [3 /*break*/, 14];
+                        index_1.Helpers.info("\n\n      PROJECT: ".concat(this.project.genericName, "\n\n      Current commit:\n      - message to include {").concat(commitData.commitMessage, "}\n      ").concat(this.useGitBranchesAsMetadataForCommits()
+                            ? "- branch to checkout ".concat(commitData.branchName)
+                            : '- using current branch', "\n      "));
+                        if (!(this.project.git.lastCommitMessage() === commitData.commitMessage)) return [3 /*break*/, 12];
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo('Soft reset last commit with same message ?')];
+                    case 11:
+                        if (_g.sent()) {
+                            this.project.git.resetSoftHEAD(1);
+                        }
+                        _g.label = 12;
+                    case 12: return [4 /*yield*/, index_1.Helpers.questionYesNo('Commit and push this ?')];
+                    case 13:
+                        if (!(_g.sent())) {
+                            exitCallBack();
+                        }
+                        _g.label = 14;
+                    case 14:
+                        if (this.automaticallyAddAllChnagesWhenPushingToGit()) {
+                            // my project
+                            this.project.git.stageAllFiles();
+                        }
+                        if (this.useGitBranchesAsMetadataForCommits()) {
+                            index_1.Helpers.info('Checkingout branches (if needed)...');
+                            if (((_b = this.project.git.currentBranchName) === null || _b === void 0 ? void 0 : _b.trim()) !== commitData.branchName) {
+                                try {
+                                    this.project.git.checkout(commitData.branchName, {
+                                        createBranchIfNotExists: true,
+                                    });
+                                }
+                                catch (error) {
+                                    index_1.Helpers.error('Please modyfiy you commit message or delete branch,');
+                                }
+                            }
+                        }
+                        try {
+                            this.project.git.commit(commitData.commitMessage);
+                        }
+                        catch (error) {
+                            index_1.Helpers.warn("Not commiting anything... ");
+                        }
+                        return [4 /*yield*/, this.project.git.pushCurrentBranch({
+                                force: force,
+                                origin: origin,
+                                forcePushNoQuestion: forcePushNoQuestion,
+                                askToRetry: true,
+                            })];
+                    case 15:
+                        _g.sent();
+                        if (!(this.automaticallyAddAllChnagesWhenPushingToGit() && !skipChildren)) return [3 /*break*/, 23];
+                        if (this.project.linkedProjects.getLinkedProjectsConfig().skipRecrusivePush) {
+                            index_1.Helpers.warn("Skipping recrusive (children) push for ".concat(this.project.genericName));
+                            return [2 /*return*/];
+                        }
+                        childrenRepos = this.project.children.filter(function (f) { return f.git.isInsideGitRepo && f.git.isGitRoot; });
+                        _g.label = 16;
+                    case 16:
+                        _g.trys.push([16, 21, 22, 23]);
+                        childrenRepos_2 = tslib_1.__values(childrenRepos), childrenRepos_2_1 = childrenRepos_2.next();
+                        _g.label = 17;
+                    case 17:
+                        if (!!childrenRepos_2_1.done) return [3 /*break*/, 20];
+                        child = childrenRepos_2_1.value;
+                        return [4 /*yield*/, child.git.pushProcess(options)];
+                    case 18:
+                        _g.sent();
+                        _g.label = 19;
+                    case 19:
+                        childrenRepos_2_1 = childrenRepos_2.next();
+                        return [3 /*break*/, 17];
+                    case 20: return [3 /*break*/, 23];
+                    case 21:
+                        e_2_1 = _g.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 23];
+                    case 22:
+                        try {
+                            if (childrenRepos_2_1 && !childrenRepos_2_1.done && (_f = childrenRepos_2.return)) _f.call(childrenRepos_2);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 23: return [4 /*yield*/, this.project.linkedProjects.saveAllLinkedProjectsToDB()];
+                    case 24:
+                        _g.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 () {
+        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.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')];
+                    case 3:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / before push action
+    BaseGit.prototype._beforePullProcessAction = function (cloneChildren) {
+        if (cloneChildren === void 0) { cloneChildren = false; }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        //#region @backendFunc
+                        this._beforeAnyActionOnGitRoot();
+                        return [4 /*yield*/, this.project.linkedProjects.cloneUnexistedLinkedProjects('pull', cloneChildren)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / resovle commit message
+    BaseGit.prototype._getCommitMessage = function (typeofCommit, args, commitMessageRequired) {
+        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)];
+                    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)];
+                    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];
+                        _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];
+                }
+            });
+        });
+    };
+    return BaseGit;
+}(base_feature_for_project_1.BaseFeatureForProject));
+exports.BaseGit = BaseGit;
+//# sourceMappingURL=base-git.js.map