tnp-helpers 18.0.20 → 18.0.21

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

@@ -1,840 +1,565 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseReleaseProcess = void 0;
-var tslib_1 = require("tslib");
+//#region imports
+const tnp_config_1 = require("tnp-config");
+const tnp_core_1 = require("tnp-core");
+const index_1 = require("../../index");
+const commit_data_1 = require("../commit-data");
+const base_feature_for_project_1 = require("./base-feature-for-project");
 //#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
-    }
+class BaseReleaseProcess extends base_feature_for_project_1.BaseFeatureForProject {
+    //#region fields
+    /**
+     * Automatic release process of patch plus one version
+     */
+    automaticRelease = false;
+    versionType;
+    preReleaseVersionTag;
+    lastChangesSummary;
+    newVersion;
+    commitsForChangelog = [];
     //#endregion
     //#region methods & getters / start release
-    BaseReleaseProcess.prototype.startRelease = function (options) {
+    startRelease(options) {
         throw new Error('Method not implemented.');
-    };
+    }
     //#endregion
     //#region methods & getters / get release words
-    BaseReleaseProcess.prototype.getReleaseWords = function () {
+    getReleaseWords() {
         return ['release'];
-    };
-    //#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; });
-                            })];
-                }
-            });
+    async selectChangelogCommits() {
+        //#region @backendFunc
+        const data = await this.getCommitsUpToReleaseCommit();
+        index_1.Helpers.info(`Last commits up to release commiut:\n` +
+            data.map(d => `- ${d.commitMessages}`).join('\n'));
+        const useAllCommitsForChangelog = await index_1.Helpers.questionYesNo('Use all commits for changelog ?');
+        if (useAllCommitsForChangelog) {
+            return data;
+        }
+        const choices = await index_1.Helpers.consoleGui.multiselect('Select commits to add to changelog', data.map(d => {
+            return {
+                name: d.commitMessages,
+                value: d.index?.toString(),
+            };
+        }));
+        return choices.map(v => {
+            return data.find(d => d.index.toString() === v);
         });
-    };
+        //#endregion
+    }
     //#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*/, []];
-                }
-            });
-        });
-    };
+    async getCommitsUpToReleaseCommit() {
+        //#region @backendFunc
+        const lastReleaseCommitData = await this.getLastReleaseCommitData();
+        // console.log({ lastReleaseCommitData });
+        if (lastReleaseCommitData.index !== -1) {
+            const commits = [];
+            for (let index = 0; index < lastReleaseCommitData.index; index++) {
+                const commitMessages = await this.project.git.getCommitMessageByIndex(index);
+                commits.push({ commitMessages, index });
+            }
+            return commits;
+        }
+        return [];
+        //#endregion
+    }
     //#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];
+    /**
+     * @returns true if publish , faslse if just version bump
+     */
+    async publishToNpm(cwdForCode = this.project.pathFor('dist'), automaticRelease = this.automaticRelease) {
+        //#region   @backendFunc
+        if (!automaticRelease) {
+            if (await tnp_core_1.UtilsTerminal.confirm({
+                message: `Do you wanna check compiled version before publishing ?`,
+                defaultValue: true,
+            })) {
+                try {
+                    const editor = await this.project.ins.configDb.getCodeEditor();
+                    index_1.Helpers.run(`${editor} .`, {
+                        output: true,
+                        cwd: cwdForCode,
+                    }).sync();
                 }
-            });
-        });
-    };
+                catch (error) { }
+            }
+            while (true) {
+                const publishOpt = {
+                    select: {
+                        name: '< select option below >',
+                    },
+                    bump: {
+                        name: 'Just bump version',
+                    },
+                    publish: {
+                        name: 'Publish to npm',
+                    },
+                };
+                const selected = await tnp_core_1.UtilsTerminal.select({
+                    question: `Select publish option`,
+                    choices: publishOpt,
+                });
+                if (selected === 'bump') {
+                    return true;
+                }
+                if (selected === 'publish') {
+                    break;
+                }
+            }
+        }
+        await this.project.publish();
+        return true;
+        //#endregion
+    }
     //#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];
+    async testAfterPublish() {
+        //#region @backendFunc
+        if (!this.automaticRelease) {
+            if (await index_1.Helpers.questionYesNo(`Do you want to run test after fresh install (and before release commit ?) ?`)) {
+                if (!(await this.testLibraries())) {
+                    index_1.Helpers.pressKeyOrWait(`Test failed.. starting release again.. press any key to continue`);
+                    return false;
                 }
-            });
-        });
-    };
+            }
+        }
+        return true;
+        //#endregion
+    }
     //#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];
+    async testBeforePublish() {
+        //#region @backendFunc
+        if (!this.automaticRelease) {
+            if (await index_1.Helpers.questionYesNo(`Do you want to run test before npm publish ?`)) {
+                if (!(await this.testLibraries())) {
+                    index_1.Helpers.pressKeyOrWait(`Test failed.. starting release again.. press any key to continue`);
+                    return false;
                 }
-            });
-        });
-    };
+            }
+        }
+        return true;
+        //#endregion
+    }
     //#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*/];
-                }
-            });
+    async commitAndPush() {
+        //#region @backendFunc
+        const releaseCommitMessage = this.releaseCommitTemplate();
+        const lastCommitMessage = await this.project.git.penultimateCommitMessage();
+        const jiraNumbers = commit_data_1.CommitData.extractAndOrderJiraNumbers(lastCommitMessage);
+        const args = [jiraNumbers.join(' ') + ' ' + releaseCommitMessage];
+        // console.log({ jiraNumbers, args, lastCommitMessage });
+        await this.project.git.pushProcess({
+            typeofCommit: 'release',
+            askToConfirmPush: true,
+            askToConfirmBranchChange: true,
+            askToConfirmCommit: true,
+            skipLint: true,
+            args,
+            exitCallBack: () => {
+                process.exit(1);
+            },
         });
-    };
+        //#endregion
+    }
     //#endregion
     //#region methods & getters / release commit template
-    BaseReleaseProcess.prototype.releaseCommitTemplate = function () {
-        return "Release v".concat(this.newVersion, " + changelog.md update");
-    };
+    releaseCommitTemplate() {
+        return `Release v${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*/];
-            });
-        });
-    };
+    async testLibraries() {
+        try {
+            this.project.run('npm run test', { output: true }).sync();
+            return true;
+        }
+        catch (error) {
+            index_1.Helpers.info(`Test failed, you can run test manually`);
+            return false;
+        }
+    }
     //#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,
-                        })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
+    async buildAllLibraries() {
+        await this.project.libraryBuild.buildLibraries({
+            watch: false,
+            releaseBuild: true,
         });
-    };
+    }
     //#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", {
+    async resetReleaseFiles() {
+        //#region @backendFunc
+        this.project.git.restoreLastVersion(this.changeLogPath);
+        for (const projToBump of this.toBumpProjects) {
+            projToBump.git.restoreLastVersion(tnp_config_1.config.file.package_json);
+            projToBump.git.restoreLastVersion(tnp_config_1.config.file.package_lock_json);
+        }
         //#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 / to bump projects
+    get toBumpProjects() {
+        const toBumpProjects = [
+            this.project,
+            ...this.project.libraryBuild.libraries,
+        ];
+        return toBumpProjects;
+    }
     //#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*/];
-            });
-        });
-    };
+    async bumpNewVersionEverywhere() {
+        //#region @backendFunc
+        const allLibrariesNames = this.project.libraryBuild.libraries.map(l => l.name);
+        for (const projToBump of this.toBumpProjects) {
+            projToBump.packageJson.setVersion(this.newVersion);
+            for (const libName of allLibrariesNames) {
+                projToBump.packageJson.updateDependency({
+                    packageName: libName,
+                    version: (this.project.location === projToBump.location ? '' : '^') +
+                        this.newVersion,
+                });
+            }
+        }
+        //#endregion
+    }
     //#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.versionType === 'minor') {
-                                newVersion =
-                                    this.project.npmHelpers.versionWithMinorPlusOneAndPatchZero;
-                            }
-                            if (this.versionType === '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*/];
-                }
-            });
-        });
-    };
+    async confirmNewVersion() {
+        //#region @backendFunc
+        if (this.automaticRelease) {
+            return;
+        }
+        let newVersion = this.newVersion;
+        if (!this.newVersion) {
+            newVersion = this.project.packageJson.versionWithPatchPlusOne;
+            if (this.versionType === 'minor') {
+                newVersion =
+                    this.project.packageJson.versionWithMinorPlusOneAndPatchZero;
+            }
+            if (this.versionType === 'major') {
+                newVersion =
+                    this.project.packageJson
+                        .versionWithMajorPlusOneAndMinorZeroAndPatchZero;
+            }
+        }
+        const originalNewVersion = newVersion;
+        while (true) {
+            index_1.Helpers.info(`New version will be: ${newVersion}`);
+            const confirm = await index_1.Helpers.questionYesNo('Do you want to continue? (no -> edit version manually) ');
+            if (confirm) {
+                break;
+            }
+            else {
+                newVersion = await index_1.Helpers.consoleGui.input({
+                    question: 'Provide proper new version and press enter',
+                    defaultValue: originalNewVersion,
+                    validate(value) {
+                        const regexForValidationNpmVersionWithPossiblePreRelease = /^(\d+\.\d+\.\d+)(\-[a-zA-Z0-9]+)?$/;
+                        return regexForValidationNpmVersionWithPossiblePreRelease.test(value);
+                    },
+                });
+            }
+        }
+        this.newVersion = newVersion;
+        //#endregion
+    }
     //#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];
-                }
-            });
-        });
-    };
+    async selectReleaseType(versionToUseResolveFn) {
+        //#region @backendFunc
+        if (this.automaticRelease) {
+            return 'patch';
+        }
+        const options = [
+            {
+                name: `Patch release (v${versionToUseResolveFn
+                    ? versionToUseResolveFn('patch')
+                    : this.project.packageJson.versionWithPatchPlusOne})`,
+                value: 'patch',
+            },
+            {
+                name: `Minor release (v${versionToUseResolveFn
+                    ? versionToUseResolveFn('minor')
+                    : this.project.packageJson.versionWithMinorPlusOneAndPatchZero})`,
+                value: 'minor',
+            },
+            {
+                name: `Major release (v${versionToUseResolveFn
+                    ? versionToUseResolveFn('major')
+                    : this.project.packageJson
+                        .versionWithMajorPlusOneAndMinorZeroAndPatchZero})`,
+                value: 'major',
+            },
+        ];
+        const selected = await index_1.Helpers.consoleGui.select('Select release type', options);
+        return selected;
+        //#endregion
+    }
     //#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];
-            });
-        });
-    };
+    async commitMessageInChangelogTransformFn(message) {
+        return message;
+    }
     //#endregion
     //#region methods & getters / calculate 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];
-                }
-            });
-        });
-    };
+    async getChangelogContentToAppend(askForEveryItem) {
+        //#region @backendFunc
+        let newChangeLogContentToAdd = '';
+        for (const commit of this.commitsForChangelog) {
+            const template = (await this.changelogItemTemplate(commit.index, askForEveryItem)) +
+                '\n';
+            newChangeLogContentToAdd += template;
+        }
+        const thingsToAddToChangeLog = `${newChangeLogContentToAdd
+            ? `${this.changeLogKeyWord()} ${this.newVersion} ` +
+                `(${(0, tnp_core_1.dateformat)(new Date(), 'yyyy-mm-dd')})\n` +
+                `----------------------------------\n` +
+                `${newChangeLogContentToAdd.trim() + '\n'}\n`
+            : ''}`;
+        return thingsToAddToChangeLog;
+        //#endregion
+    }
     //#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*/];
-                }
-            });
-        });
-    };
+    async updateChangeLogFromCommits() {
+        //#region @backendFunc
+        let askForEveryItem = false;
+        while (true) {
+            let thingsToAddToChangeLog = await this.getChangelogContentToAppend(askForEveryItem);
+            console.log(`New things for changelog.md:\n${tnp_core_1.chalk.gray.bold(thingsToAddToChangeLog)}`);
+            if (!(await index_1.Helpers.questionYesNo('Accept this new things in changelog (if no -> edit mode) ?'))) {
+                askForEveryItem = true;
+                continue;
+            }
+            const changeLogNewContent = thingsToAddToChangeLog + `${this.changelogContent.trim()}\n`;
+            this.project.writeFile(this.changeLogPath, changeLogNewContent);
+            break;
+        }
+        //#endregion
+    }
     //#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(', ')];
-                }
-            });
+    async extractChangedLibrariesInCommit(hashOrIndex) {
+        //#region @backendFunc
+        const hash = tnp_core_1._.isString(hashOrIndex) ? hashOrIndex : void 0;
+        const index = tnp_core_1._.isNumber(hashOrIndex) ? hashOrIndex : void 0;
+        const useHash = !!hash;
+        const lastChanges = useHash
+            ? await this.project.git.getChangedFilesInCommitByHash(hash)
+            : await this.project.git.getChangedFilesInCommitByIndex(index);
+        const libraries = this.project.libraryBuild.libraries.filter(l => {
+            const libraryRelativePath = l.location.replace(this.project.location + '/', '');
+            return lastChanges.some(c => c.includes(libraryRelativePath));
         });
-    };
+        return libraries.map(l => l.name).join(', ');
+        //#endregion
+    }
     //#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];
-                }
-            });
-        });
-    };
+    async changelogItemTemplate(hashOrIndex, confirmEveryItem = false) {
+        //#region @backendFunc
+        const hash = tnp_core_1._.isString(hashOrIndex) ? hashOrIndex : void 0;
+        const index = tnp_core_1._.isNumber(hashOrIndex) ? hashOrIndex : void 0;
+        const useHash = !!hash;
+        const commitMessage = useHash
+            ? await this.project.git.getCommitMessageByHash(hash)
+            : await this.project.git.getCommitMessageByIndex(index);
+        const jiraNumbers = commit_data_1.CommitData.extractAndOrderJiraNumbers(commitMessage);
+        const message = commit_data_1.CommitData.cleanMessageFromJiraNumTeamIdEtc(commitMessage);
+        // console.log({ data, commit });
+        const extractedLibraries = await this.extractChangedLibrariesInCommit(hashOrIndex);
+        const translatedMessage = tnp_core_1._.upperFirst(await this.commitMessageInChangelogTransformFn(message.replace(/\-/g, '').replace(/\:/g, '')));
+        let result = (`* [${tnp_core_1._.last(jiraNumbers)}] - ` +
+            `${extractedLibraries ? extractedLibraries + ' - ' : ''}` +
+            ` ${translatedMessage}`)
+            .replace(/\-  \-/g, ' - ')
+            .replace(/\ \ /g, ' ');
+        if (confirmEveryItem) {
+            console.log(`Confirm changelog new item ${tnp_core_1.chalk.gray(`(from "${commitMessage}")`)}:\n` + `\n${tnp_core_1.chalk.italic(result)}\n`);
+            const itemIsOK = await index_1.Helpers.questionYesNo('Is this item OK ?');
+            if (!itemIsOK) {
+                const confirm = await index_1.Helpers.consoleGui.input({
+                    question: 'Provide proper changelog item or press enter to confirm',
+                    defaultValue: result,
+                    // required: false,
+                });
+                result = confirm;
+            }
+        }
+        // replace double spaces
+        result = result.replace(/\ \ /g, ' ');
+        result = result.replace(/\ \ /g, ' ');
+        result = result.replace(/\ \ /g, ' ');
+        return result;
+        //#endregion
+    }
     //#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.lastReleaseCommitMsg;
-                        _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 release commit' : 'Last 3 commits'), ":\n")).concat;
-                        return [4 /*yield*/, this.getLastChangesFromCommits({
-                                maxMessagesToCheck: hasLastReleaseCommit ? Number.POSITIVE_INFINITY : 3,
-                                stopOnCommitMessage: hasLastReleaseCommit
-                                    ? lastReleaseCommitData.lastReleaseCommitMsg
-                                    : '',
-                            })];
-                    case 3: return [2 /*return*/, _d.apply(_a, [_e.sent(), "\n    "])];
-                }
-            });
-        });
-    };
+    async generateLastChangesSummary() {
+        const lastReleaseCommitData = await this.getLastReleaseCommitData();
+        const hasLastReleaseCommit = lastReleaseCommitData.index !== -1;
+        const lastReleaseCommitMsg = !hasLastReleaseCommit
+            ? '< nothing release yet >'
+            : lastReleaseCommitData.lastReleaseCommitMsg;
+        return `${tnp_core_1.chalk.bold.gray('Last changelog.md notes summary')}:
+${await this.getLastPackageVersionChangesFromChnagelog()}
+
+${tnp_core_1.chalk.bold.gray(hasLastReleaseCommit ? 'Last commits up to release commit' : 'Last 3 commits')}:
+${await this.getLastChangesFromCommits({
+            maxMessagesToCheck: hasLastReleaseCommit ? Number.POSITIVE_INFINITY : 3,
+            stopOnCommitMessage: hasLastReleaseCommit
+                ? lastReleaseCommitData.lastReleaseCommitMsg
+                : '',
+        })}
+    `;
+    }
     //#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')];
-                }
-            });
-        });
-    };
+    async getLastChangesFromCommits({ maxMessagesToCheck = 3, stopOnCommitMessage = '', } = {}) {
+        //#region @backendFunc
+        let index = 0;
+        const commits = [];
+        while (true) {
+            const commitMessage = await this.project.git.getCommitMessageByIndex(index);
+            commits.push(commitMessage);
+            ++index;
+            if (!!(stopOnCommitMessage || '').trim() &&
+                commitMessage.includes(stopOnCommitMessage)) {
+                break;
+            }
+            if (index > maxMessagesToCheck) {
+                break;
+            }
+        }
+        return commits
+            .map(c => tnp_core_1.chalk.italic(c))
+            .map((c, index) => `${index + 1}. ${c}`)
+            .join('\n');
+        //#endregion
+    }
     //#endregion
     //#region methods & getters / get last release 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: { lastReleaseCommitMsg: 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*/, { lastReleaseCommitMsg: '', index: -1 }];
+    async getLastReleaseCommitData() {
+        //#region @backendFunc
+        let index = 0;
+        const maxMessages = 50;
+        while (true) {
+            const commitMessage = await this.project.git.getCommitMessageByIndex(index);
+            const npmVersionRegex = /\d+\.\d+\.\d+/;
+            // console.log('commitMessage', { index, commitMessage });
+            if (this.getReleaseWords().some(r => commitMessage.toLowerCase().includes(r))) {
+                // console.log('FOUNDED', { commitMessage });
+                const match = commitMessage.match(npmVersionRegex);
+                if (match) {
+                    2;
+                    return { lastReleaseCommitMsg: commitMessage, index };
                 }
-            });
-        });
-    };
+            }
+            ++index;
+            if (index > maxMessages) {
+                break;
+            }
+        }
+        return { lastReleaseCommitMsg: '', index: -1 };
+        //#endregion
+    }
     //#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", {
+    async getLastPackageVersionChangesFromChnagelog() {
+        //#region @backendFunc
+        if (!this.project.hasFile(this.changeLogPath)) {
+            return `< project doesn't use CHANGELOG.md yet >`;
+        }
+        const changelogData = this.getChnagelogData();
+        if (changelogData.length === 0) {
+            return `< no changelog data >`;
+        }
+        const validToShow = [];
+        while (true) {
+            const lastRelease = changelogData.shift();
+            if (lastRelease.version === this.project.packageJson.version) {
+                validToShow.push(lastRelease);
+            }
+            else {
+                break;
+            }
+        }
+        return validToShow
+            .map(cd => {
+            return (`${this.changeLogKeyWord()} ${cd.version} (${cd.date}):` +
+                `\n${cd.changes.join('\n')}`);
+        })
+            .join('\n');
+        // const changelogData = this.getChnagelogData();
+        // return changelogData.slice(0, 3).map(cd => {
+        //   return `${chalk.bold(cd.version)} (${cd.date}):`
+        //   // return `${chalk.bold(cd.version)} (${cd.date}):
+        // }).join('\n');
+        // const changelog = this.project.readFile(this.changeLogPath) || '';
+        // const splited = changelog
+        //   .split('\n')
+        //   .slice(0, 5)
+        //   .filter(l => !!l.trim())
+        //   .map(l => chalk.italic(l));
+        // return splited.join('\n').trim();
         //#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 path
+    get changeLogPath() {
+        //#region @backendFunc
+        return this.project.hasFile('changelog.md')
+            ? 'changelog.md'
+            : 'CHANGELOG.md';
         //#endregion
-        //#region methods & getters / get changelog content
-        get: function () {
-            return this.project.readFile(this.changeLogPath) || '';
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
+    //#endregion
+    //#region methods & getters / get changelog content
+    get changelogContent() {
+        return this.project.readFile(this.changeLogPath) || '';
+    }
     //#endregion
     //#region methods & getters / change log key word
-    BaseReleaseProcess.prototype.changeLogKeyWord = function () {
+    changeLogKeyWord() {
         return 'Changes in version';
-    };
+    }
     //#endregion
     //#region methods & getters / get changelog data
-    BaseReleaseProcess.prototype.getChnagelogData = function () {
+    getChnagelogData() {
         //#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;
+        const changelogData = [];
+        const keyword = this.changeLogKeyWord();
+        const regex = new RegExp(`${keyword} (\\d+\\.\\d+\\.\\d+) \\((\\d{4}-\\d{2}-\\d{2})\\)\\s*[-]+\\s*([\\s\\S]*?)(?=${keyword} \\d+\\.\\d+\\.\\d+ \\(|$)`, 'g');
+        let match;
         while ((match = regex.exec(this.changelogContent)) !== null) {
-            var version = match[1];
-            var date = match[2];
-            var changesText = match[3].trim();
-            var changes = changesText
+            const version = match[1];
+            const date = match[2];
+            const changesText = match[3].trim();
+            const changes = changesText
                 .split('\n')
-                .map(function (line) { return line.trim(); })
-                .filter(function (line) { return line; });
+                .map(line => line.trim())
+                .filter(line => line);
             changelogData.push({
-                changes: changes,
-                version: version,
-                date: date,
+                changes,
+                version,
+                date,
             });
         }
         return changelogData;
         //#endregion
-    };
-    return BaseReleaseProcess;
-}(base_feature_for_project_1.BaseFeatureForProject));
+    }
+}
 exports.BaseReleaseProcess = BaseReleaseProcess;
 //# sourceMappingURL=base-release-process.js.map