tnp-helpers 18.0.19 → 18.0.21

package/lib/base/base-release-process.js

@@ -0,0 +1,913 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseReleaseProcess = void 0;
+var tslib_1 = require("tslib");
+//#endregion
+var index_1 = require("../index");
+var base_feature_for_project_1 = require("./base-feature-for-project");
+var tnp_core_1 = require("tnp-core");
+var commit_data_1 = require("./commit-data");
+var tnp_config_1 = require("tnp-config");
+//#endregion
+var BaseReleaseProcess = /** @class */ (function (_super) {
+    tslib_1.__extends(BaseReleaseProcess, _super);
+    function BaseReleaseProcess() {
+        var _this = _super.apply(this, tslib_1.__spreadArray([], tslib_1.__read(arguments), false)) || this;
+        /**
+         * Automatic release process of patch plus one version
+         */
+        _this.automaticRelease = false;
+        _this.commitsForChangelog = [];
+        return _this;
+        //#endregion
+    }
+    //#endregion
+    BaseReleaseProcess.prototype.getReleaseWords = function () {
+        return ['release'];
+    };
+    //#region methods & getters / start release
+    BaseReleaseProcess.prototype.startRelease = function (options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, _c, _d, _e, _f;
+            return tslib_1.__generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        if (!true) return [3 /*break*/, 17];
+                        index_1.Helpers.clearConsole();
+                        this.newVersion = options === null || options === void 0 ? void 0 : options.newVersion;
+                        this.automaticRelease = (options === null || options === void 0 ? void 0 : options.automaticRelease) || false;
+                        return [4 /*yield*/, this.resetReleaseFiles()];
+                    case 1:
+                        _g.sent();
+                        this.project.npmHelpers.reloadPackageJsonInMemory();
+                        _a = this;
+                        return [4 /*yield*/, this.generateLastChangesSummary()];
+                    case 2:
+                        _a.lastChangesSummary = _g.sent();
+                        _c = (_b = console).log;
+                        _d = "".concat(tnp_core_1.chalk.bold.underline("Release process for ".concat(this.project.name)), ":\n");
+                        return [4 /*yield*/, this.lastChangesSummary];
+                    case 3:
+                        _c.apply(_b, [_d +
+                                (_g.sent())]);
+                        _e = this;
+                        return [4 /*yield*/, this.selectReleaseType()];
+                    case 4:
+                        _e.type = _g.sent();
+                        return [4 /*yield*/, this.confirmNewVersion()];
+                    case 5:
+                        _g.sent();
+                        _f = this;
+                        return [4 /*yield*/, this.selectChangelogCommits()];
+                    case 6:
+                        _f.commitsForChangelog = _g.sent();
+                        return [4 /*yield*/, this.updateChangeLogFromCommits()];
+                    case 7:
+                        _g.sent();
+                        return [4 /*yield*/, this.bumpNewVersionEverywhere()];
+                    case 8:
+                        _g.sent();
+                        return [4 /*yield*/, this.buildAllLibraries()];
+                    case 9:
+                        _g.sent();
+                        return [4 /*yield*/, this.testBeforePublish()];
+                    case 10:
+                        if (!(_g.sent())) {
+                            return [3 /*break*/, 0];
+                        }
+                        return [4 /*yield*/, this.publishToNpm()];
+                    case 11:
+                        if (!(_g.sent())) {
+                            return [3 /*break*/, 0];
+                        }
+                        return [4 /*yield*/, this.reinstallNodeModules()];
+                    case 12:
+                        _g.sent();
+                        return [4 /*yield*/, this.testAfterPublish()];
+                    case 13:
+                        if (!(_g.sent())) {
+                            return [3 /*break*/, 0];
+                        }
+                        return [4 /*yield*/, this.project.git.stageAllFiles()];
+                    case 14:
+                        _g.sent();
+                        return [4 /*yield*/, this.project.git.restoreLastVersion(tnp_config_1.config.file._gitignore)];
+                    case 15:
+                        _g.sent();
+                        return [4 /*yield*/, this.commitAndPush()];
+                    case 16:
+                        _g.sent();
+                        return [3 /*break*/, 17];
+                    case 17: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / reinstall node modules
+    BaseReleaseProcess.prototype.reinstallNodeModules = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        index_1.Helpers.taskStarted("Reinstalling node_modules to recreate package-lock.json");
+                        return [4 /*yield*/, this.project.npmHelpers.reinstallNodeModules()];
+                    case 1:
+                        _a.sent();
+                        index_1.Helpers.taskDone("Reinstalling node_modules to recreate package-lock.json");
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / select changelog commits
+    BaseReleaseProcess.prototype.selectChangelogCommits = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var data, useAllCommitsForChangelog, choices;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getCommitsUpToReleaseCommit()];
+                    case 1:
+                        data = _a.sent();
+                        index_1.Helpers.info("Last commits up to release commiut:\n" +
+                            data.map(function (d) { return "- ".concat(d.commitMessages); }).join('\n'));
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo('Use all commits for changelog ?')];
+                    case 2:
+                        useAllCommitsForChangelog = _a.sent();
+                        if (useAllCommitsForChangelog) {
+                            return [2 /*return*/, data];
+                        }
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.multiselect('Select commits to add to changelog', data.map(function (d) {
+                                var _a;
+                                return {
+                                    name: d.commitMessages,
+                                    value: (_a = d.index) === null || _a === void 0 ? void 0 : _a.toString(),
+                                };
+                            }))];
+                    case 3:
+                        choices = _a.sent();
+                        return [2 /*return*/, choices.map(function (v) {
+                                return data.find(function (d) { return d.index.toString() === v; });
+                            })];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / get commits up to release commit
+    BaseReleaseProcess.prototype.getCommitsUpToReleaseCommit = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var lastReleaseCommitData, commits, index, commitMessages;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getLastReleaseCommitData()];
+                    case 1:
+                        lastReleaseCommitData = _a.sent();
+                        if (!(lastReleaseCommitData.index !== -1)) return [3 /*break*/, 6];
+                        commits = [];
+                        index = 0;
+                        _a.label = 2;
+                    case 2:
+                        if (!(index < lastReleaseCommitData.index)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.project.git.getCommitMessageByIndex(index)];
+                    case 3:
+                        commitMessages = _a.sent();
+                        commits.push({ commitMessages: commitMessages, index: index });
+                        _a.label = 4;
+                    case 4:
+                        index++;
+                        return [3 /*break*/, 2];
+                    case 5: return [2 /*return*/, commits];
+                    case 6: return [2 /*return*/, []];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / publish to npm
+    BaseReleaseProcess.prototype.publishToNpm = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var editor, error_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!this.automaticRelease) return [3 /*break*/, 7];
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo("Publish packages to npm (yes) ? ..or it's just a version bump (no)")];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/, true];
+                        }
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo("Preview compiled code before publish ?")];
+                    case 2:
+                        if (!_a.sent()) return [3 /*break*/, 7];
+                        _a.label = 3;
+                    case 3:
+                        _a.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, this.project.ins.configDb.getCodeEditor()];
+                    case 4:
+                        editor = _a.sent();
+                        this.project.run("cd dist && ".concat(editor, " ."), { output: true }).sync();
+                        return [3 /*break*/, 6];
+                    case 5:
+                        error_1 = _a.sent();
+                        return [3 /*break*/, 6];
+                    case 6:
+                        index_1.Helpers.pressKeyOrWait("Press any key to continue");
+                        _a.label = 7;
+                    case 7: return [4 /*yield*/, index_1.Helpers.questionYesNo("Publish ".concat(this.newVersion, " to npm ?"))];
+                    case 8:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/, false];
+                        }
+                        return [4 /*yield*/, this.project.publish()];
+                    case 9:
+                        _a.sent();
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / test after publish
+    BaseReleaseProcess.prototype.testAfterPublish = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!this.automaticRelease) return [3 /*break*/, 3];
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo("Do you want to run test after fresh install (and before release commit ?) ?")];
+                    case 1:
+                        if (!_a.sent()) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.testLibraries()];
+                    case 2:
+                        if (!(_a.sent())) {
+                            index_1.Helpers.pressKeyOrWait("Test failed.. starting release again.. press any key to continue");
+                            return [2 /*return*/, false];
+                        }
+                        _a.label = 3;
+                    case 3: return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / test before publish
+    BaseReleaseProcess.prototype.testBeforePublish = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!this.automaticRelease) return [3 /*break*/, 3];
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo("Do you want to run test before npm publish ?")];
+                    case 1:
+                        if (!_a.sent()) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.testLibraries()];
+                    case 2:
+                        if (!(_a.sent())) {
+                            index_1.Helpers.pressKeyOrWait("Test failed.. starting release again.. press any key to continue");
+                            return [2 /*return*/, false];
+                        }
+                        _a.label = 3;
+                    case 3: return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / commit and push
+    BaseReleaseProcess.prototype.commitAndPush = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var releaseCommitMessage, lastCommitMessage, jiraNumbers, args;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        releaseCommitMessage = this.releaseCommitTemplate();
+                        return [4 /*yield*/, this.project.git.penultimateCommitMessage()];
+                    case 1:
+                        lastCommitMessage = _a.sent();
+                        jiraNumbers = commit_data_1.CommitData.extractAndOrderJiraNumbers(lastCommitMessage);
+                        args = [jiraNumbers.join(' ') + ' ' + releaseCommitMessage];
+                        // console.log({ jiraNumbers, args, lastCommitMessage });
+                        return [4 /*yield*/, this.project.git.pushProcess({
+                                typeofCommit: 'release',
+                                askToConfirmPush: true,
+                                askToConfirmBranchChange: true,
+                                askToConfirmCommit: true,
+                                skipLint: true,
+                                args: args,
+                                exitCallBack: function () {
+                                    process.exit(1);
+                                },
+                            })];
+                    case 2:
+                        // console.log({ jiraNumbers, args, lastCommitMessage });
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / release commit template
+    BaseReleaseProcess.prototype.releaseCommitTemplate = function () {
+        return "Release v".concat(this.newVersion, " + changelog.md update");
+    };
+    //#endregion
+    //#region methods & getters / test libraries
+    BaseReleaseProcess.prototype.testLibraries = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                try {
+                    this.project.run('npm run test', { output: true }).sync();
+                    return [2 /*return*/, true];
+                }
+                catch (error) {
+                    index_1.Helpers.info("Test failed, you can run test manually");
+                    return [2 /*return*/, false];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / build all libraries
+    BaseReleaseProcess.prototype.buildAllLibraries = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.project.libraryBuild.buildLibraries({
+                            watch: false,
+                            releaseBuild: true,
+                            buildType: 'angular',
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / reset release files
+    BaseReleaseProcess.prototype.resetReleaseFiles = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, projToBump;
+            var e_1, _c;
+            return tslib_1.__generator(this, function (_d) {
+                //#region @backendFunc
+                this.project.git.restoreLastVersion(this.changeLogPath);
+                try {
+                    for (_a = tslib_1.__values(this.toBumpProjects), _b = _a.next(); !_b.done; _b = _a.next()) {
+                        projToBump = _b.value;
+                        projToBump.git.restoreLastVersion(tnp_config_1.config.file.package_json);
+                        projToBump.git.restoreLastVersion(tnp_config_1.config.file.package_lock_json);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    Object.defineProperty(BaseReleaseProcess.prototype, "toBumpProjects", {
+        //#endregion
+        //#region methods & getters / to bump projects
+        get: function () {
+            var toBumpProjects = tslib_1.__spreadArray([
+                this.project
+            ], tslib_1.__read(this.project.libraryBuild.libraries), false);
+            return toBumpProjects;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region methods & getters / bump new version everywhere
+    BaseReleaseProcess.prototype.bumpNewVersionEverywhere = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var allLibrariesNames, _a, _b, projToBump, allLibrariesNames_1, allLibrariesNames_1_1, libName;
+            var e_2, _c, e_3, _d;
+            return tslib_1.__generator(this, function (_e) {
+                allLibrariesNames = this.project.libraryBuild.libraries.map(function (l) { return l.name; });
+                try {
+                    for (_a = tslib_1.__values(this.toBumpProjects), _b = _a.next(); !_b.done; _b = _a.next()) {
+                        projToBump = _b.value;
+                        projToBump.npmHelpers.version = this.newVersion;
+                        try {
+                            for (allLibrariesNames_1 = (e_3 = void 0, tslib_1.__values(allLibrariesNames)), allLibrariesNames_1_1 = allLibrariesNames_1.next(); !allLibrariesNames_1_1.done; allLibrariesNames_1_1 = allLibrariesNames_1.next()) {
+                                libName = allLibrariesNames_1_1.value;
+                                projToBump.npmHelpers.updateDependency({
+                                    packageName: libName,
+                                    version: (this.project.location === projToBump.location ? '' : '^') +
+                                        this.newVersion,
+                                });
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (allLibrariesNames_1_1 && !allLibrariesNames_1_1.done && (_d = allLibrariesNames_1.return)) _d.call(allLibrariesNames_1);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / confirm release type
+    BaseReleaseProcess.prototype.confirmNewVersion = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var newVersion, originalNewVersion, confirm_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        //#region @backendFunc
+                        if (this.automaticRelease) {
+                            return [2 /*return*/];
+                        }
+                        newVersion = this.newVersion;
+                        if (!this.newVersion) {
+                            newVersion = this.project.npmHelpers.versionWithPatchPlusOne;
+                            if (this.type === 'minor') {
+                                newVersion =
+                                    this.project.npmHelpers.versionWithMinorPlusOneAndPatchZero;
+                            }
+                            if (this.type === 'major') {
+                                newVersion =
+                                    this.project.npmHelpers
+                                        .versionWithMajorPlusOneAndMinorZeroAndPatchZero;
+                            }
+                        }
+                        originalNewVersion = newVersion;
+                        _a.label = 1;
+                    case 1:
+                        if (!true) return [3 /*break*/, 6];
+                        index_1.Helpers.info("New version will be: ".concat(newVersion));
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo('Do you want to continue? (no -> edit version manually) ')];
+                    case 2:
+                        confirm_1 = _a.sent();
+                        if (!confirm_1) return [3 /*break*/, 3];
+                        return [3 /*break*/, 6];
+                    case 3: return [4 /*yield*/, index_1.Helpers.consoleGui.input({
+                            question: 'Provide proper new version and press enter',
+                            defaultValue: originalNewVersion,
+                            validate: function (value) {
+                                var regexForValidationNpmVersionWithPossiblePreRelease = /^(\d+\.\d+\.\d+)(\-[a-zA-Z0-9]+)?$/;
+                                return regexForValidationNpmVersionWithPossiblePreRelease.test(value);
+                            },
+                        })];
+                    case 4:
+                        newVersion = _a.sent();
+                        _a.label = 5;
+                    case 5: return [3 /*break*/, 1];
+                    case 6:
+                        this.newVersion = newVersion;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / select release type
+    BaseReleaseProcess.prototype.selectReleaseType = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var options, selected;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        //#region @backendFunc
+                        if (this.automaticRelease) {
+                            return [2 /*return*/, 'patch'];
+                        }
+                        options = [
+                            {
+                                name: "Patch release (v".concat(this.project.npmHelpers.versionWithPatchPlusOne, ")"),
+                                value: 'patch',
+                            },
+                            {
+                                name: "Minor release (v".concat(this.project.npmHelpers.versionWithMinorPlusOneAndPatchZero, ")"),
+                                value: 'minor',
+                            },
+                            {
+                                name: "Major release (v".concat(this.project.npmHelpers.versionWithMajorPlusOneAndMinorZeroAndPatchZero, ")"),
+                                value: 'major',
+                            },
+                        ];
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.select('Select release type', options)];
+                    case 1:
+                        selected = _a.sent();
+                        return [2 /*return*/, selected];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / commit message in changelog transform fn
+    BaseReleaseProcess.prototype.commitMessageInChangelogTransformFn = function (message) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, message];
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / caclulate item
+    BaseReleaseProcess.prototype.getChangelogContentToAppend = function (askForEveryItem) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var newChangeLogContentToAdd, _a, _b, commit, template, e_4_1, thingsToAddToChangeLog;
+            var e_4, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        newChangeLogContentToAdd = '';
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 6, 7, 8]);
+                        _a = tslib_1.__values(this.commitsForChangelog), _b = _a.next();
+                        _d.label = 2;
+                    case 2:
+                        if (!!_b.done) return [3 /*break*/, 5];
+                        commit = _b.value;
+                        return [4 /*yield*/, this.changelogItemTemplate(commit.index, askForEveryItem)];
+                    case 3:
+                        template = (_d.sent()) +
+                            '\n';
+                        newChangeLogContentToAdd += template;
+                        _d.label = 4;
+                    case 4:
+                        _b = _a.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_4_1 = _d.sent();
+                        e_4 = { error: e_4_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                        return [7 /*endfinally*/];
+                    case 8:
+                        thingsToAddToChangeLog = "".concat(newChangeLogContentToAdd
+                            ? "".concat(this.changeLogKeyWord(), " ").concat(this.newVersion, " ") +
+                                "(".concat((0, tnp_core_1.dateformat)(new Date(), 'yyyy-mm-dd'), ")\n") +
+                                "----------------------------------\n" +
+                                "".concat(newChangeLogContentToAdd.trim() + '\n', "\n")
+                            : '');
+                        return [2 /*return*/, thingsToAddToChangeLog];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / update changelog.md from commits
+    /**
+     * TODO extend this to all commits from last release
+     */
+    BaseReleaseProcess.prototype.updateChangeLogFromCommits = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var askForEveryItem, thingsToAddToChangeLog, changeLogNewContent;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        askForEveryItem = false;
+                        _a.label = 1;
+                    case 1:
+                        if (!true) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.getChangelogContentToAppend(askForEveryItem)];
+                    case 2:
+                        thingsToAddToChangeLog = _a.sent();
+                        console.log("New things for changelog.md:\n".concat(tnp_core_1.chalk.gray.bold(thingsToAddToChangeLog)));
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo('Accept this new things in changelog (if no -> edit mode) ?')];
+                    case 3:
+                        if (!(_a.sent())) {
+                            askForEveryItem = true;
+                            return [3 /*break*/, 1];
+                        }
+                        changeLogNewContent = thingsToAddToChangeLog + "".concat(this.changelogContent.trim(), "\n");
+                        this.project.writeFile(this.changeLogPath, changeLogNewContent);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / extract changed libraries in last commit
+    BaseReleaseProcess.prototype.extractChangedLibrariesInCommit = function (hashOrIndex) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var hash, index, useHash, lastChanges, _a, libraries;
+            var _this = this;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        hash = tnp_core_1._.isString(hashOrIndex) ? hashOrIndex : void 0;
+                        index = tnp_core_1._.isNumber(hashOrIndex) ? hashOrIndex : void 0;
+                        useHash = !!hash;
+                        if (!useHash) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.project.git.getChangedFilesInCommitByHash(hash)];
+                    case 1:
+                        _a = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.project.git.getChangedFilesInCommitByIndex(index)];
+                    case 3:
+                        _a = _b.sent();
+                        _b.label = 4;
+                    case 4:
+                        lastChanges = _a;
+                        libraries = this.project.libraryBuild.libraries.filter(function (l) {
+                            var libraryRelativePath = l.location.replace(_this.project.location + '/', '');
+                            return lastChanges.some(function (c) { return c.includes(libraryRelativePath); });
+                        });
+                        return [2 /*return*/, libraries.map(function (l) { return l.name; }).join(', ')];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / change log item template
+    BaseReleaseProcess.prototype.changelogItemTemplate = function (hashOrIndex_1) {
+        return tslib_1.__awaiter(this, arguments, void 0, function (hashOrIndex, confirmEveryItem) {
+            var hash, index, useHash, commitMessage, _a, jiraNumbers, message, extractedLibraries, translatedMessage, _b, _c, result, itemIsOK, confirm_2;
+            if (confirmEveryItem === void 0) { confirmEveryItem = false; }
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        hash = tnp_core_1._.isString(hashOrIndex) ? hashOrIndex : void 0;
+                        index = tnp_core_1._.isNumber(hashOrIndex) ? hashOrIndex : void 0;
+                        useHash = !!hash;
+                        if (!useHash) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.project.git.getCommitMessageByHash(hash)];
+                    case 1:
+                        _a = _d.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.project.git.getCommitMessageByIndex(index)];
+                    case 3:
+                        _a = _d.sent();
+                        _d.label = 4;
+                    case 4:
+                        commitMessage = _a;
+                        jiraNumbers = commit_data_1.CommitData.extractAndOrderJiraNumbers(commitMessage);
+                        message = commit_data_1.CommitData.cleanMessageFromJiraNumTeamIdEtc(commitMessage);
+                        return [4 /*yield*/, this.extractChangedLibrariesInCommit(hashOrIndex)];
+                    case 5:
+                        extractedLibraries = _d.sent();
+                        _c = (_b = tnp_core_1._).upperFirst;
+                        return [4 /*yield*/, this.commitMessageInChangelogTransformFn(message.replace(/\-/g, '').replace(/\:/g, ''))];
+                    case 6:
+                        translatedMessage = _c.apply(_b, [_d.sent()]);
+                        result = ("* [".concat(tnp_core_1._.last(jiraNumbers), "] - ") +
+                            "".concat(extractedLibraries ? extractedLibraries + ' - ' : '') +
+                            " ".concat(translatedMessage))
+                            .replace(/\-  \-/g, ' - ')
+                            .replace(/\ \ /g, ' ');
+                        if (!confirmEveryItem) return [3 /*break*/, 9];
+                        console.log("Confirm changelog new item ".concat(tnp_core_1.chalk.gray("(from \"".concat(commitMessage, "\")")), ":\n") +
+                            "\n".concat(tnp_core_1.chalk.italic(result), "\n"));
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo('Is this item OK ?')];
+                    case 7:
+                        itemIsOK = _d.sent();
+                        if (!!itemIsOK) return [3 /*break*/, 9];
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.input({
+                                question: 'Provide proper changelog item or press enter to confirm',
+                                defaultValue: result,
+                                // required: false,
+                            })];
+                    case 8:
+                        confirm_2 = _d.sent();
+                        result = confirm_2;
+                        _d.label = 9;
+                    case 9:
+                        // replace double spaces
+                        result = result.replace(/\ \ /g, ' ');
+                        result = result.replace(/\ \ /g, ' ');
+                        result = result.replace(/\ \ /g, ' ');
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / generate last changes summary
+    BaseReleaseProcess.prototype.generateLastChangesSummary = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var lastReleaseCommitData, hasLastReleaseCommit, lastReleaseCommitMsg, _a, _b, _c, _d;
+            return tslib_1.__generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0: return [4 /*yield*/, this.getLastReleaseCommitData()];
+                    case 1:
+                        lastReleaseCommitData = _e.sent();
+                        hasLastReleaseCommit = lastReleaseCommitData.index !== -1;
+                        lastReleaseCommitMsg = !hasLastReleaseCommit
+                            ? '< nothing release yet >'
+                            : lastReleaseCommitData.lastRelaseCommitMsg;
+                        _c = (_b = "".concat(tnp_core_1.chalk.bold.gray('Last changelog.md notes summary'), ":\n")).concat;
+                        return [4 /*yield*/, this.getLastPackageVersionChangesFromChnagelog()];
+                    case 2:
+                        _d = (_a = _c.apply(_b, [_e.sent(), "\n\n"]).concat(tnp_core_1.chalk.bold.gray(hasLastReleaseCommit ? 'Last commits up to relase commit' : 'Last 3 commits'), ":\n")).concat;
+                        return [4 /*yield*/, this.getLastChangesFromCommits({
+                                maxMessagesToCheck: hasLastReleaseCommit ? Number.POSITIVE_INFINITY : 3,
+                                stopOnCommitMessage: hasLastReleaseCommit
+                                    ? lastReleaseCommitData.lastRelaseCommitMsg
+                                    : '',
+                            })];
+                    case 3: return [2 /*return*/, _d.apply(_a, [_e.sent(), "\n    "])];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / get last changes from commits
+    BaseReleaseProcess.prototype.getLastChangesFromCommits = function () {
+        return tslib_1.__awaiter(this, arguments, void 0, function (_a) {
+            var index, commits, commitMessage;
+            var _b = _a === void 0 ? {} : _a, _c = _b.maxMessagesToCheck, maxMessagesToCheck = _c === void 0 ? 3 : _c, _d = _b.stopOnCommitMessage, stopOnCommitMessage = _d === void 0 ? '' : _d;
+            return tslib_1.__generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        index = 0;
+                        commits = [];
+                        _e.label = 1;
+                    case 1:
+                        if (!true) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.project.git.getCommitMessageByIndex(index)];
+                    case 2:
+                        commitMessage = _e.sent();
+                        commits.push(commitMessage);
+                        ++index;
+                        if (!!(stopOnCommitMessage || '').trim() &&
+                            commitMessage.includes(stopOnCommitMessage)) {
+                            return [3 /*break*/, 3];
+                        }
+                        if (index > maxMessagesToCheck) {
+                            return [3 /*break*/, 3];
+                        }
+                        return [3 /*break*/, 1];
+                    case 3: return [2 /*return*/, commits
+                            .map(function (c) { return tnp_core_1.chalk.italic(c); })
+                            .map(function (c, index) { return "".concat(index + 1, ". ").concat(c); })
+                            .join('\n')];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / get last relase commit data
+    BaseReleaseProcess.prototype.getLastReleaseCommitData = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var index, maxMessages, _loop_1, this_1, state_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        index = 0;
+                        maxMessages = 50;
+                        _loop_1 = function () {
+                            var commitMessage, npmVersionRegex, match;
+                            return tslib_1.__generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0: return [4 /*yield*/, this_1.project.git.getCommitMessageByIndex(index)];
+                                    case 1:
+                                        commitMessage = _b.sent();
+                                        npmVersionRegex = /\d+\.\d+\.\d+/;
+                                        // console.log('commitMessage', { index, commitMessage });
+                                        if (this_1.getReleaseWords().some(function (r) {
+                                            return commitMessage.toLowerCase().includes(r);
+                                        })) {
+                                            match = commitMessage.match(npmVersionRegex);
+                                            if (match) {
+                                                2;
+                                                return [2 /*return*/, { value: { lastRelaseCommitMsg: commitMessage, index: index } }];
+                                            }
+                                        }
+                                        ++index;
+                                        if (index > maxMessages) {
+                                            return [2 /*return*/, "break"];
+                                        }
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _a.label = 1;
+                    case 1:
+                        if (!true) return [3 /*break*/, 3];
+                        return [5 /*yield**/, _loop_1()];
+                    case 2:
+                        state_1 = _a.sent();
+                        if (typeof state_1 === "object")
+                            return [2 /*return*/, state_1.value];
+                        if (state_1 === "break")
+                            return [3 /*break*/, 3];
+                        return [3 /*break*/, 1];
+                    case 3: return [2 /*return*/, { lastRelaseCommitMsg: '', index: -1 }];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region methods & getters / get last changes from changelog
+    BaseReleaseProcess.prototype.getLastPackageVersionChangesFromChnagelog = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var changelogData, validToShow, lastRelease;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                //#region @backendFunc
+                if (!this.project.hasFile(this.changeLogPath)) {
+                    return [2 /*return*/, "< project doesn't use CHANGELOG.md yet >"];
+                }
+                changelogData = this.getChnagelogData();
+                if (changelogData.length === 0) {
+                    return [2 /*return*/, "< no changelog data >"];
+                }
+                validToShow = [];
+                while (true) {
+                    lastRelease = changelogData.shift();
+                    if (lastRelease.version === this.project.npmHelpers.version) {
+                        validToShow.push(lastRelease);
+                    }
+                    else {
+                        break;
+                    }
+                }
+                return [2 /*return*/, validToShow
+                        .map(function (cd) {
+                        return ("".concat(_this.changeLogKeyWord(), " ").concat(cd.version, " (").concat(cd.date, "):") +
+                            "\n".concat(cd.changes.join('\n')));
+                    })
+                        .join('\n')];
+            });
+        });
+    };
+    Object.defineProperty(BaseReleaseProcess.prototype, "changeLogPath", {
+        //#endregion
+        //#region methods & getters / get changelog path
+        get: function () {
+            //#region @backendFunc
+            return this.project.hasFile('changelog.md')
+                ? 'changelog.md'
+                : 'CHANGELOG.md';
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseReleaseProcess.prototype, "changelogContent", {
+        //#endregion
+        //#region methods & getters / get changelog content
+        get: function () {
+            return this.project.readFile(this.changeLogPath) || '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region methods & getters / change log key word
+    BaseReleaseProcess.prototype.changeLogKeyWord = function () {
+        return 'Changes in version';
+    };
+    //#endregion
+    //#region methods & getters / get changelog data
+    BaseReleaseProcess.prototype.getChnagelogData = function () {
+        //#region @backendFunc
+        var changelogData = [];
+        var keyword = this.changeLogKeyWord();
+        var regex = new RegExp("".concat(keyword, " (\\d+\\.\\d+\\.\\d+) \\((\\d{4}-\\d{2}-\\d{2})\\)\\s*[-]+\\s*([\\s\\S]*?)(?=").concat(keyword, " \\d+\\.\\d+\\.\\d+ \\(|$)"), 'g');
+        var match;
+        while ((match = regex.exec(this.changelogContent)) !== null) {
+            var version = match[1];
+            var date = match[2];
+            var changesText = match[3].trim();
+            var changes = changesText
+                .split('\n')
+                .map(function (line) { return line.trim(); })
+                .filter(function (line) { return line; });
+            changelogData.push({
+                changes: changes,
+                version: version,
+                date: date,
+            });
+        }
+        return changelogData;
+        //#endregion
+    };
+    return BaseReleaseProcess;
+}(base_feature_for_project_1.BaseFeatureForProject));
+exports.BaseReleaseProcess = BaseReleaseProcess;
+//# sourceMappingURL=base-release-process.js.map