tnp-helpers 16.444.21 → 16.444.23

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

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseReleaseProcess = void 0;
 var tslib_1 = require("tslib");
-//#region imports
-var lib_1 = require("../../lib");
+//#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);
@@ -15,10 +17,14 @@ var BaseReleaseProcess = /** @class */ (function (_super) {
          * 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 () {
@@ -26,21 +32,433 @@ var BaseReleaseProcess = /** @class */ (function (_super) {
             return tslib_1.__generator(this, function (_g) {
                 switch (_g.label) {
                     case 0:
-                        //#region @backendFunc
-                        lib_1.Helpers.clearConsole();
+                        if (!true) return [3 /*break*/, 15];
+                        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 1:
+                    case 2:
                         _a.lastChangesSummary = _g.sent();
                         _c = (_b = console).log;
-                        _e = (_d = "".concat(tnp_core_1.chalk.bold.underline("Release process for ".concat(this.project.name)), ":\n\n")).concat;
+                        _d = "".concat(tnp_core_1.chalk.bold.underline("Release process for ".concat(this.project.name)), ":\n");
                         return [4 /*yield*/, this.lastChangesSummary];
-                    case 2:
-                        _c.apply(_b, [_e.apply(_d, [_g.sent(), "\n    "])]);
-                        _f = this;
+                    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.commitAndPush()];
+                    case 14:
+                        _g.sent();
+                        return [3 /*break*/, 0];
+                    case 15: 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) {
+                index_1.Helpers.taskStarted("Reinstalling node_modules to recreate package-lock.json");
+                this.project.npmHelpers.reinstalNodeModules();
+                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*/, 6];
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo("Preview compiled code before publish ?")];
+                    case 1:
+                        if (!_a.sent()) return [3 /*break*/, 6];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.project.ins.configDb.getCodeEditor()];
                     case 3:
-                        _f.type = _g.sent();
+                        editor = _a.sent();
+                        this.project.run("cd dist && ".concat(editor, " ."), { output: true }).sync();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_1 = _a.sent();
+                        return [3 /*break*/, 5];
+                    case 5:
+                        index_1.Helpers.pressKeyOrWait("Press any key to continue");
+                        _a.label = 6;
+                    case 6: return [4 /*yield*/, index_1.Helpers.questionYesNo("Publish ".concat(this.newVersion, " to npm ?"))];
+                    case 7:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/, false];
+                        }
+                        return [4 /*yield*/, this.project.publish()];
+                    case 8:
+                        _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(libName, (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?')];
+                    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*/];
                 }
             });
@@ -72,7 +490,7 @@ var BaseReleaseProcess = /** @class */ (function (_super) {
                                 value: 'major',
                             },
                         ];
-                        return [4 /*yield*/, lib_1.Helpers.consoleGui.select('Select release type', options)];
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.select('Select release type', options)];
                     case 1:
                         selected = _a.sent();
                         return [2 /*return*/, selected];
@@ -81,7 +499,193 @@ var BaseReleaseProcess = /** @class */ (function (_super) {
         });
     };
     //#endregion
-    BaseReleaseProcess.prototype.generateChangesForChangelog = function () { };
+    //#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 thing for change log:\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, confirmEveryItem) {
+        if (confirmEveryItem === void 0) { confirmEveryItem = false; }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var hash, index, useHash, commitMessage, _a, jiraNumbers, message, extractedLibraries, translatedMessage, _b, _c, result, itemIsOK, confirm_2;
+            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 () {
@@ -95,7 +699,7 @@ var BaseReleaseProcess = /** @class */ (function (_super) {
                         lastReleaseCommitMsg = !hasLastReleaseCommit
                             ? '< nothing release yet >'
                             : lastReleaseCommitData.lastRelaseCommitMsg;
-                        _c = (_b = "".concat(tnp_core_1.chalk.bold.gray('Last changelog notest summary'), ":\n")).concat;
+                        _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;
@@ -156,16 +760,17 @@ var BaseReleaseProcess = /** @class */ (function (_super) {
                         index = 0;
                         maxMessages = 50;
                         _loop_1 = function () {
-                            var commitMessage, releaseWorlds, npmVersionRegex, match;
+                            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();
-                                        releaseWorlds = ['release', 'wydanie'];
                                         npmVersionRegex = /\d+\.\d+\.\d+/;
                                         // console.log('commitMessage', { index, commitMessage });
-                                        if (releaseWorlds.some(function (r) { return commitMessage.toLowerCase().includes(r); })) {
+                                        if (this_1.getReleaseWords().some(function (r) {
+                                            return commitMessage.toLowerCase().includes(r);
+                                        })) {
                                             match = commitMessage.match(npmVersionRegex);
                                             if (match) {
                                                 2;