tnp-helpers 18.0.20 → 18.0.21

package/lib/base/base-library-build.js

@@ -0,0 +1,717 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseLibraryBuild = exports.ChildProcess = void 0;
+var tslib_1 = require("tslib");
+//#region import
+//#region @backend
+var tnp_core_1 = require("tnp-core");
+var child_process_1 = require("child_process");
+Object.defineProperty(exports, "ChildProcess", { enumerable: true, get: function () { return child_process_1.ChildProcess; } });
+var tnp_core_2 = require("tnp-core");
+var tnp_config_1 = require("tnp-config");
+var tnp_core_3 = require("tnp-core");
+var base_feature_for_project_1 = require("./base-feature-for-project");
+var index_1 = require("../index");
+//#endregion
+/**
+ * Base library build for standard angular/typescript projects
+ */
+var BaseLibraryBuild = /** @class */ (function (_super) {
+    tslib_1.__extends(BaseLibraryBuild, _super);
+    function BaseLibraryBuild() {
+        var _this = _super.apply(this, tslib_1.__spreadArray([], tslib_1.__read(arguments), false)) || this;
+        _this.cache = {};
+        _this.tempOrgTsConfigFile = "tmp-original-".concat(tnp_config_1.config.file.tsconfig_json);
+        return _this;
+        //#endregion
+    }
+    //#region getters & methods / sort by deps
+    BaseLibraryBuild.prototype.sortByDeps = function (libraries) {
+        //#region @backendFunc
+        var libs = libraries;
+        var sorted = this.project.ins.sortGroupOfProject(libs, function (proj) {
+            // resolve dependencies names
+            if (!tnp_core_3._.isUndefined(proj.cache['deps'])) {
+                return proj.cache['deps'];
+            }
+            var allLibs = Object.keys(proj.npmHelpers.allDependencies);
+            proj.cache['deps'] = allLibs.filter(function (f) { return !tnp_core_3._.isUndefined(libs.find(function (c) { return c.name === f; })); });
+            return proj.cache['deps'];
+        }, function (proj) {
+            // resolve name to compare
+            if (!tnp_core_3._.isUndefined(proj.cache['nameToCompare'])) {
+                return proj.cache['nameToCompare'];
+            }
+            proj.cache['nameToCompare'] = proj.name;
+            return proj.cache['nameToCompare'];
+        });
+        return sorted;
+        //#endregion
+    };
+    //#endregion
+    //#region getters & methods / get sorted libraries by deps for build\
+    /**
+     * Use cases:
+     * 1. build all libraries in normal mode
+     * 2. build all libraries in watch mode
+     * 3. build selected libraries in normal mode
+     *   (with first time all libraries will be build)
+     * 4. build selected libraries in watch mode
+     *    (use normal build for not selected libraries)
+     * 5. build selected libraries in watch mode
+     *    (skip normal build for not selected libraries)
+     */
+    BaseLibraryBuild.prototype.selectAndSaveLibraries = function (_a) {
+        return tslib_1.__awaiter(this, arguments, void 0, function (
+        // this: {},
+        _b) {
+            var buildAll, skipRebuildingAllForWatch, lastSelected, selected, _c, _d, defaultSelected, pickedLibs, selected;
+            var _e;
+            var selectedLibs = _b.selectedLibs, watch = _b.watch, watchBuildSupported = _b.watchBuildSupported, skipAllLibsQuestion = _b.skipAllLibsQuestion, useLastUserConfiguration = _b.useLastUserConfiguration;
+            return tslib_1.__generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        buildAll = false;
+                        skipRebuildingAllForWatch = false;
+                        if (selectedLibs.length <= 1) {
+                            return [2 /*return*/, { selectedLibs: selectedLibs, skipRebuildingAllForWatch: skipRebuildingAllForWatch }];
+                        }
+                        if (tnp_core_3._.isUndefined(watchBuildSupported)) {
+                            watchBuildSupported = true;
+                        }
+                        lastSelected = ((_e = index_1.Helpers.readJson(this.project.pathFor(tnp_config_1.FilesNames.tmpLastSelectedJsonFile))) === null || _e === void 0 ? void 0 : _e.lastSelected) || [];
+                        if (!(tnp_core_3._.isArray(lastSelected) && lastSelected.length > 0)) return [3 /*break*/, 7];
+                        selected = lastSelected
+                            .map(function (c) { return selectedLibs.find(function (l) { return l.name == c; }); })
+                            .filter(function (c) { return !!c; });
+                        index_1.Helpers.info("\nLast selected libs\n\n".concat(selected.map(function (c, i) { return "".concat(i + 1, ". ").concat(c.basename, " ").concat(tnp_core_1.chalk.bold(c.name)); }).join('\n'), "\n\n            "));
+                        if (!useLastUserConfiguration) return [3 /*break*/, 1];
+                        _c = true;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, index_1.Helpers.consoleGui.question.yesNo("Continue ".concat(watch ? 'watch' : '', " build with last selected ?"))];
+                    case 2:
+                        _c = _f.sent();
+                        _f.label = 3;
+                    case 3:
+                        if (!_c) return [3 /*break*/, 7];
+                        selectedLibs = selected;
+                        if (!((watchBuildSupported && watch) || useLastUserConfiguration)) return [3 /*break*/, 6];
+                        _d = useLastUserConfiguration;
+                        if (_d) return [3 /*break*/, 5];
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.question.yesNo("Skip rebuilding all libraries for watch mode ?")];
+                    case 4:
+                        _d = (_f.sent());
+                        _f.label = 5;
+                    case 5:
+                        skipRebuildingAllForWatch = _d;
+                        _f.label = 6;
+                    case 6: return [2 /*return*/, { selectedLibs: selectedLibs, skipRebuildingAllForWatch: skipRebuildingAllForWatch }];
+                    case 7:
+                        if (!(!watch || (watch && selectedLibs.length < 6))) return [3 /*break*/, 9];
+                        if (!!skipAllLibsQuestion) return [3 /*break*/, 9];
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.question.yesNo("Should all libraries be included in".concat(watch ? ' watch' : ' ', "build ?"))];
+                    case 8:
+                        buildAll = _f.sent();
+                        _f.label = 9;
+                    case 9:
+                        if (buildAll) {
+                            return [2 /*return*/, { selectedLibs: selectedLibs, skipRebuildingAllForWatch: skipRebuildingAllForWatch }];
+                        }
+                        _f.label = 10;
+                    case 10:
+                        if (!true) return [3 /*break*/, 13];
+                        defaultSelected = lastSelected
+                            .map(function (c) { return selectedLibs.find(function (l) { return l.name == c; }); })
+                            .filter(function (c) { return !!c; })
+                            .map(function (c) { return c.name; });
+                        return [4 /*yield*/, index_1.UtilsTerminal.multiselect({
+                                question: "Select libraries to ".concat(watch ? 'watch' : '', " build "),
+                                choices: selectedLibs.map(function (c) {
+                                    return { name: c.name, value: c.name, selected: true };
+                                }),
+                                defaultSelected: defaultSelected,
+                            })];
+                    case 11:
+                        pickedLibs = (_f.sent()).map(function (c) { return selectedLibs.find(function (l) { return l.name == c; }); });
+                        selected = pickedLibs.filter(function (c) {
+                            // if (!!c) { // TODO QUICK_FIX
+                            //   this.project.removeFile(lastSelectedJsonFile);
+                            //   Helpers.warn(`Please restart this command`);
+                            //   process.exit(0);
+                            // }
+                            return !!c;
+                        });
+                        index_1.Helpers.info("\n\n".concat(selected.map(function (c, i) { return "".concat(i + 1, ". ").concat(c.basename, " ").concat(tnp_core_1.chalk.bold(c.name)); }).join('\n'), "\n\n      "));
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.question.yesNo("Continue build with ".concat(selected.length, " selected ?"))];
+                    case 12:
+                        if (_f.sent()) {
+                            selectedLibs = selected;
+                            return [3 /*break*/, 13];
+                        }
+                        return [3 /*break*/, 10];
+                    case 13:
+                        index_1.Helpers.writeJson(this.project.pathFor(tnp_config_1.FilesNames.tmpLastSelectedJsonFile), {
+                            lastSelected: selectedLibs.map(function (c) { return c.name; }),
+                        });
+                        return [2 /*return*/, { selectedLibs: selectedLibs, skipRebuildingAllForWatch: skipRebuildingAllForWatch }];
+                }
+            });
+        });
+    };
+    Object.defineProperty(BaseLibraryBuild.prototype, "libraries", {
+        //#endregion
+        //#region getters & methods / angular libraries
+        /**
+         * angular libraries from angular.json
+         */
+        get: function () {
+            //#region @backendFunc
+            if (!tnp_core_3._.isUndefined(this.cache['libraries'])) {
+                return this.cache['libraries'];
+            }
+            var libraries = this.getLibraries();
+            this.cache['libraries'] = libraries;
+            return libraries;
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BaseLibraryBuild.prototype.getLibraries = function () {
+        var _this = this;
+        var _a;
+        //#region @backendFunc
+        var projects = Object.values(((_a = index_1.Helpers.readJson(this.project.pathFor(tnp_config_1.config.file.angular_json))) === null || _a === void 0 ? void 0 : _a.projects) || {}).filter(function (f) { return f.projectType === 'library'; });
+        var libraries = projects.map(function (c) {
+            return _this.project.ins.From(tnp_core_2.path.join(_this.project.location, c.root));
+        });
+        libraries = this.sortByDeps(libraries);
+        return libraries;
+        //#endregion
+    };
+    //#endregion
+    //#region getters & methods / build libraries
+    /**
+     * Angular library build
+     */
+    BaseLibraryBuild.prototype.buildLibraries = function () {
+        return tslib_1.__awaiter(this, arguments, void 0, function (
+        // this:{},
+        _a) {
+            var useExternalProvidedLibs, allLibs, locationsForNodeModules, _b, selectedLibs, skipRebuildingAllForWatch, allParenProjsForExtenalLibsBuild, allParenProjsForExtenalLibsBuild_1, allParenProjsForExtenalLibsBuild_1_1, libProj, _c, _d, _e, index, lib, e_1_1, e_2_1, _f, _g, _h, index, lib, e_3_1;
+            var e_2, _j, e_1, _k, e_3, _l;
+            var 
+            // this:{},
+            _m = _a === void 0 ? {} : _a, _o = _m.watch, watch = _o === void 0 ? false : _o, strategy = _m.strategy, _p = _m.releaseBuild, releaseBuild = _p === void 0 ? false : _p, buildType = _m.buildType, copylink_to_node_modules = _m.copylink_to_node_modules, outputLineReplace = _m.outputLineReplace, libraries = _m.libraries, useLastUserConfiguration = _m.useLastUserConfiguration;
+            return tslib_1.__generator(this, function (_q) {
+                switch (_q.label) {
+                    case 0: 
+                    //#region @backend
+                    return [4 /*yield*/, this.project.linkedProjects.saveAllLinkedProjectsToDB()];
+                    case 1:
+                        //#region @backend
+                        _q.sent();
+                        return [4 /*yield*/, this.changeTsConfigForLibrariesTypes()];
+                    case 2:
+                        _q.sent();
+                        //#region prepare parameters
+                        if (!Array.isArray(copylink_to_node_modules)) {
+                            copylink_to_node_modules = [];
+                        }
+                        if (!strategy) {
+                            strategy = 'link';
+                        }
+                        useExternalProvidedLibs = !tnp_core_3._.isNil(libraries);
+                        allLibs = useExternalProvidedLibs ? libraries : this.libraries;
+                        locationsForNodeModules = releaseBuild
+                            ? []
+                            : tslib_1.__spreadArray(tslib_1.__spreadArray([
+                                this.project.pathFor(tnp_config_1.config.folder.node_modules)
+                            ], tslib_1.__read(copylink_to_node_modules), false), tslib_1.__read((!useExternalProvidedLibs
+                                ? []
+                                : index_1.Helpers.uniqArray(libraries.map(function (c) {
+                                    return c.parent.pathFor(tnp_config_1.config.folder.node_modules);
+                                })))), false);
+                        return [4 /*yield*/, this.selectAndSaveLibraries({
+                                selectedLibs: libraries ? libraries : allLibs,
+                                watch: watch,
+                                skipAllLibsQuestion: useExternalProvidedLibs,
+                                useLastUserConfiguration: useLastUserConfiguration,
+                            })];
+                    case 3:
+                        _b = _q.sent(), selectedLibs = _b.selectedLibs, skipRebuildingAllForWatch = _b.skipRebuildingAllForWatch;
+                        allParenProjsForExtenalLibsBuild = useExternalProvidedLibs
+                            ? index_1.Helpers.uniqArray(libraries.map(function (c) { return c.parent; }), 'location')
+                            : [this.project];
+                        _q.label = 4;
+                    case 4:
+                        _q.trys.push([4, 16, 17, 18]);
+                        allParenProjsForExtenalLibsBuild_1 = tslib_1.__values(allParenProjsForExtenalLibsBuild), allParenProjsForExtenalLibsBuild_1_1 = allParenProjsForExtenalLibsBuild_1.next();
+                        _q.label = 5;
+                    case 5:
+                        if (!!allParenProjsForExtenalLibsBuild_1_1.done) return [3 /*break*/, 15];
+                        libProj = allParenProjsForExtenalLibsBuild_1_1.value;
+                        return [4 /*yield*/, libProj.init()];
+                    case 6:
+                        _q.sent();
+                        _q.label = 7;
+                    case 7:
+                        _q.trys.push([7, 12, 13, 14]);
+                        _c = (e_1 = void 0, tslib_1.__values(libProj.libraryBuild.libraries.entries())), _d = _c.next();
+                        _q.label = 8;
+                    case 8:
+                        if (!!_d.done) return [3 /*break*/, 11];
+                        _e = tslib_1.__read(_d.value, 2), index = _e[0], lib = _e[1];
+                        if (watch && skipRebuildingAllForWatch) {
+                            index_1.Helpers.info("Skipping build for watch mode (".concat(index + 1, "/").concat(allLibs.length, ")") +
+                                " ".concat(lib.basename, " (").concat(tnp_core_1.chalk.bold(lib.name), ")"));
+                            return [3 /*break*/, 10];
+                        }
+                        index_1.Helpers.info("Building (".concat(index + 1, "/").concat(allLibs.length, ") ").concat(lib.basename) +
+                            " (".concat(tnp_core_1.chalk.bold(lib.name), ")"));
+                        return [4 /*yield*/, libProj.libraryBuild.libNormalBuildProcess({
+                                lib: lib,
+                                locationsForNodeModules: useExternalProvidedLibs
+                                    ? [
+                                        this.project.pathFor(tnp_config_1.config.folder.node_modules),
+                                        libProj.pathFor(tnp_config_1.config.folder.node_modules),
+                                    ]
+                                    : locationsForNodeModules,
+                                strategy: strategy,
+                                buildType: buildType,
+                                outputLineReplace: outputLineReplace &&
+                                    outputLineReplace(lib, useExternalProvidedLibs),
+                            })];
+                    case 9:
+                        _q.sent();
+                        _q.label = 10;
+                    case 10:
+                        _d = _c.next();
+                        return [3 /*break*/, 8];
+                    case 11: return [3 /*break*/, 14];
+                    case 12:
+                        e_1_1 = _q.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 14];
+                    case 13:
+                        try {
+                            if (_d && !_d.done && (_k = _c.return)) _k.call(_c);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 14:
+                        allParenProjsForExtenalLibsBuild_1_1 = allParenProjsForExtenalLibsBuild_1.next();
+                        return [3 /*break*/, 5];
+                    case 15: return [3 /*break*/, 18];
+                    case 16:
+                        e_2_1 = _q.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 18];
+                    case 17:
+                        try {
+                            if (allParenProjsForExtenalLibsBuild_1_1 && !allParenProjsForExtenalLibsBuild_1_1.done && (_j = allParenProjsForExtenalLibsBuild_1.return)) _j.call(allParenProjsForExtenalLibsBuild_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 18:
+                        _q.trys.push([18, 23, 24, 25]);
+                        _f = tslib_1.__values(selectedLibs.entries()), _g = _f.next();
+                        _q.label = 19;
+                    case 19:
+                        if (!!_g.done) return [3 /*break*/, 22];
+                        _h = tslib_1.__read(_g.value, 2), index = _h[0], lib = _h[1];
+                        index_1.Helpers.info("Building for watch (".concat(index + 1, "/").concat(selectedLibs.length, ") ") +
+                            "".concat(lib.basename, " (").concat(tnp_core_1.chalk.bold(lib.name), ")"));
+                        return [4 /*yield*/, this.libWatchBuildProcess({
+                                lib: lib,
+                                locationsForNodeModules: locationsForNodeModules,
+                                strategy: strategy,
+                                buildType: buildType,
+                                outputLineReplace: outputLineReplace && outputLineReplace(lib, useExternalProvidedLibs),
+                            })];
+                    case 20:
+                        _q.sent();
+                        _q.label = 21;
+                    case 21:
+                        _g = _f.next();
+                        return [3 /*break*/, 19];
+                    case 22: return [3 /*break*/, 25];
+                    case 23:
+                        e_3_1 = _q.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 25];
+                    case 24:
+                        try {
+                            if (_g && !_g.done && (_l = _f.return)) _l.call(_f);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 25:
+                        //#endregion
+                        //#region success message
+                        if (watch) {
+                            index_1.Helpers.success('BUILD DONE.. watching..');
+                        }
+                        else {
+                            // await this.__indexRebuilder.start({ taskName: 'index rebuild watch' });
+                            index_1.Helpers.success('BUILD DONE');
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region getters & methods / lib watch build process
+    BaseLibraryBuild.prototype.libWatchBuildProcess = function (_a) {
+        return tslib_1.__awaiter(this, arguments, void 0, function (_b) {
+            var debouncedBuild;
+            var lib = _b.lib, locationsForNodeModules = _b.locationsForNodeModules, strategy = _b.strategy, buildType = _b.buildType, outputLineReplace = _b.outputLineReplace;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        debouncedBuild = tnp_core_3._.debounce(function () {
+                            var e_4, _a;
+                            var sourceDist = lib.nearestParent.pathFor([
+                                tnp_config_1.config.folder.dist,
+                                lib.basename,
+                            ]);
+                            try {
+                                for (var locationsForNodeModules_1 = tslib_1.__values(locationsForNodeModules), locationsForNodeModules_1_1 = locationsForNodeModules_1.next(); !locationsForNodeModules_1_1.done; locationsForNodeModules_1_1 = locationsForNodeModules_1.next()) {
+                                    var node_modules = locationsForNodeModules_1_1.value;
+                                    var dest = (0, tnp_core_2.crossPlatformPath)([node_modules, lib.name]);
+                                    if (index_1.Helpers.isSymlinkFileExitedOrUnexisted(dest)) {
+                                        index_1.Helpers.remove(dest);
+                                    }
+                                    index_1.Helpers.copy(sourceDist, dest, {
+                                        recursive: true,
+                                        overwrite: true,
+                                    });
+                                    console.log("Sync (watch|copy) done for ".concat(lib.basename, " to ").concat(lib.name, " (").concat((0, tnp_core_2.crossPlatformPath)([
+                                        tnp_core_2.path.basename(tnp_core_2.path.dirname(node_modules)),
+                                        tnp_config_1.config.folder.node_modules,
+                                    ]), ")"));
+                                }
+                            }
+                            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                            finally {
+                                try {
+                                    if (locationsForNodeModules_1_1 && !locationsForNodeModules_1_1.done && (_a = locationsForNodeModules_1.return)) _a.call(locationsForNodeModules_1);
+                                }
+                                finally { if (e_4) throw e_4.error; }
+                            }
+                        }, 500);
+                        //#endregion
+                        //#region watch build process
+                        return [4 /*yield*/, lib.nearestParent.execute(lib.libraryBuild.getLibraryBuildComamnd({
+                                watch: true,
+                                buildType: buildType,
+                            }), {
+                                outputLineReplace: outputLineReplace,
+                                resolvePromiseMsg: {
+                                    stdout: lib.libraryBuild.getLibraryBuildSuccessComamnds,
+                                },
+                                resolvePromiseMsgCallback: {
+                                    stdout: function () {
+                                        if (strategy === 'copy') {
+                                            debouncedBuild();
+                                        }
+                                    },
+                                },
+                            })];
+                    case 1:
+                        //#endregion
+                        //#region watch build process
+                        _c.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region getters & methods / lib normal build process
+    BaseLibraryBuild.prototype.libNormalBuildProcess = function (_a) {
+        return tslib_1.__awaiter(this, arguments, void 0, function (_b) {
+            var libCompiledInDist, compileProcess, locationsForNodeModules_2, locationsForNodeModules_2_1, node_modules_abs_path, libInsideNodeModules, locationsForNodeModules_3, locationsForNodeModules_3_1, node_modules_abs_path, libInsideNodeModules;
+            var e_5, _c, e_6, _d;
+            var _this = this;
+            var lib = _b.lib, locationsForNodeModules = _b.locationsForNodeModules, strategy = _b.strategy, buildType = _b.buildType, outputLineReplace = _b.outputLineReplace;
+            return tslib_1.__generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        libCompiledInDist = lib.nearestParent.pathFor([
+                            tnp_config_1.config.folder.dist,
+                            lib.basename,
+                        ]);
+                        compileProcess = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!!index_1.Helpers.exists(libCompiledInDist)) return [3 /*break*/, 2];
+                                        index_1.Helpers.info("Compiling ".concat(lib.name, " ..."));
+                                        return [4 /*yield*/, lib.nearestParent.execute(lib.libraryBuild.getLibraryBuildComamnd({
+                                                watch: false,
+                                                buildType: buildType,
+                                            }), {
+                                                resolvePromiseMsg: {
+                                                    stdout: lib.libraryBuild.getLibraryBuildSuccessComamnds,
+                                                },
+                                                outputLineReplace: outputLineReplace,
+                                            })];
+                                    case 1:
+                                        _a.sent();
+                                        _a.label = 2;
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        if (!(strategy === 'link')) return [3 /*break*/, 2];
+                        try {
+                            //#region link dist to node_modules
+                            for (locationsForNodeModules_2 = tslib_1.__values(locationsForNodeModules), locationsForNodeModules_2_1 = locationsForNodeModules_2.next(); !locationsForNodeModules_2_1.done; locationsForNodeModules_2_1 = locationsForNodeModules_2.next()) {
+                                node_modules_abs_path = locationsForNodeModules_2_1.value;
+                                libInsideNodeModules = (0, tnp_core_2.crossPlatformPath)([
+                                    node_modules_abs_path,
+                                    lib.name,
+                                ]);
+                                if (!index_1.Helpers.isSymlinkFileExitedOrUnexisted(libInsideNodeModules)) {
+                                    index_1.Helpers.remove(libInsideNodeModules);
+                                }
+                                // console.log('linking from ', sourceDist);
+                                // console.log('linking to ', dest);
+                                // Helpers.remove(dest);
+                                index_1.Helpers.createSymLink(libCompiledInDist, libInsideNodeModules, {
+                                    continueWhenExistedFolderDoesntExists: true,
+                                });
+                                console.log("Sync (link) done for ".concat(lib.basename, " to ").concat(lib.name, " (").concat((0, tnp_core_2.crossPlatformPath)([
+                                    tnp_core_2.path.basename(tnp_core_2.path.dirname(node_modules_abs_path)),
+                                    tnp_config_1.config.folder.node_modules,
+                                ]), ")"));
+                            }
+                        }
+                        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                        finally {
+                            try {
+                                if (locationsForNodeModules_2_1 && !locationsForNodeModules_2_1.done && (_c = locationsForNodeModules_2.return)) _c.call(locationsForNodeModules_2);
+                            }
+                            finally { if (e_5) throw e_5.error; }
+                        }
+                        return [4 /*yield*/, compileProcess()];
+                    case 1:
+                        _e.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        if (!(strategy === 'copy')) return [3 /*break*/, 4];
+                        //#region copy dist to node_modules
+                        return [4 /*yield*/, compileProcess()];
+                    case 3:
+                        //#region copy dist to node_modules
+                        _e.sent();
+                        try {
+                            for (locationsForNodeModules_3 = tslib_1.__values(locationsForNodeModules), locationsForNodeModules_3_1 = locationsForNodeModules_3.next(); !locationsForNodeModules_3_1.done; locationsForNodeModules_3_1 = locationsForNodeModules_3.next()) {
+                                node_modules_abs_path = locationsForNodeModules_3_1.value;
+                                libInsideNodeModules = (0, tnp_core_2.crossPlatformPath)([
+                                    node_modules_abs_path,
+                                    lib.name,
+                                ]);
+                                if (index_1.Helpers.isSymlinkFileExitedOrUnexisted(libInsideNodeModules)) {
+                                    index_1.Helpers.remove(libInsideNodeModules);
+                                }
+                                index_1.Helpers.copy(libCompiledInDist, libInsideNodeModules, {
+                                    recursive: true,
+                                    overwrite: true,
+                                });
+                                console.log("Sync copy done for ".concat(lib.basename, " to ").concat(lib.name, " (").concat((0, tnp_core_2.crossPlatformPath)([
+                                    tnp_core_2.path.basename(tnp_core_2.path.dirname(node_modules_abs_path)),
+                                    tnp_config_1.config.folder.node_modules,
+                                ]), ")"));
+                            }
+                        }
+                        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                        finally {
+                            try {
+                                if (locationsForNodeModules_3_1 && !locationsForNodeModules_3_1.done && (_d = locationsForNodeModules_3.return)) _d.call(locationsForNodeModules_3);
+                            }
+                            finally { if (e_6) throw e_6.error; }
+                        }
+                        _e.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region getters & methods / get library build success command
+    BaseLibraryBuild.prototype.getLibraryBuildComamnd = function (options) {
+        //#region @backendFunc
+        var watch = options.watch;
+        var isAngularLib = index_1.Helpers.exists(this.project.pathFor('ng-package.json')) ||
+            index_1.Helpers.exists(this.project.pathFor('tsconfig.app.json'));
+        if (isAngularLib) {
+            return "npm-run ng build ".concat(this.project.basename, " ").concat(watch ? '--watch' : '');
+        }
+        else {
+            return ("npm-run tsc -p libraries/".concat(this.project.basename, "/tsconfig.lib.json ") +
+                " ".concat(watch ? '--watch' : '', " --preserveWatchOutput"));
+        }
+        //#endregion
+    };
+    Object.defineProperty(BaseLibraryBuild.prototype, "getLibraryBuildSuccessComamnds", {
+        //#endregion
+        //#region getters & methods / get library build success command
+        get: function () {
+            //#region @backendFunc
+            var isAngularLib = index_1.Helpers.exists(this.project.pathFor('ng-package.json'));
+            if (isAngularLib) {
+                return ["Trace: Build complete", 'Compilation complete'];
+            }
+            else {
+                return [
+                    "Found 0 errors. Watching for file change",
+                    'Compilation complete',
+                ];
+            }
+            //#endregion
+        },
+        enumerable: false,
+        configurable: true
+    });
+    //#endregion
+    //#region getters & methods / select copy to projects
+    BaseLibraryBuild.prototype.selectCopytoProjects = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var projects, locations;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        projects = this.project.ins.allProjectsFromFolder(tnp_core_2.path.dirname(this.project.location))
+                            .filter(function (c) { return c.location !== _this.project.location; })
+                            .map(function (p) {
+                            var _a;
+                            return ((_a = p.linkedProjects) === null || _a === void 0 ? void 0 : _a.embeddedProject)
+                                ? p.linkedProjects.embeddedProject
+                                : p;
+                        });
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.multiselect('Copy compiled version to projects', projects.map(function (c) {
+                                return {
+                                    name: c.genericName,
+                                    value: c.pathFor(tnp_config_1.config.folder.node_modules),
+                                };
+                            }), true)];
+                    case 1:
+                        locations = _a.sent();
+                        return [2 /*return*/, locations];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region private methods / change tsconfig for libraries typescript proper local types
+    BaseLibraryBuild.prototype.changeTsConfigForLibrariesTypes = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, libChild, howMuchBack;
+            var e_7, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: 
+                    //#region @backendFunc
+                    return [4 /*yield*/, this.restoreOriginalTsConfig()];
+                    case 1:
+                        //#region @backendFunc
+                        _d.sent();
+                        return [4 /*yield*/, this.replaceTsConfigsPathes()];
+                    case 2:
+                        _d.sent();
+                        try {
+                            for (_a = tslib_1.__values(this.project.libraryBuild.libraries), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                libChild = _b.value;
+                                howMuchBack = this.project
+                                    .relative(libChild.location)
+                                    .split('/').length;
+                                libChild.setValueToJSONC('tsconfig.lib.json', 'extends', "".concat(tnp_core_3._.times(howMuchBack, function () { return "../"; }).join('')).concat(this.tempOrgTsConfigFile));
+                            }
+                        }
+                        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_7) throw e_7.error; }
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region private methods / replace tsconfig pathes
+    BaseLibraryBuild.prototype.replaceTsConfigsPathes = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var paths;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                //#region @backendFunc
+                if (!this.project.hasFile(this.tempOrgTsConfigFile)) {
+                    index_1.Helpers.copyFile(this.project.pathFor(tnp_config_1.config.file.tsconfig_json), this.project.pathFor(this.tempOrgTsConfigFile));
+                }
+                paths = this.project.libraryBuild.libraries.reduce(function (a, b) {
+                    var _a;
+                    return tnp_core_3._.merge(a, (_a = {},
+                        _a[b.name] = [
+                            (0, tnp_core_2.crossPlatformPath)([_this.project.relative(b.location), 'src', 'lib']),
+                        ],
+                        _a["".concat(b.name, "/*")] = [
+                            "".concat((0, tnp_core_2.crossPlatformPath)([_this.project.relative(b.location), 'src', 'lib']), "/*"),
+                        ],
+                        _a));
+                }, {});
+                // console.log('paths', paths);
+                this.project.setValueToJSONC(tnp_config_1.config.file.tsconfig_json, 'compilerOptions.paths', paths);
+                return [2 /*return*/];
+            });
+        });
+    };
+    //#endregion
+    //#region private methods  / restore original tsconfig
+    BaseLibraryBuild.prototype.restoreOriginalTsConfig = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var commands, commands_1, commands_1_1, command;
+            var e_8, _a;
+            var _this = this;
+            return tslib_1.__generator(this, function (_b) {
+                //#region @backendFunc
+                index_1.Helpers.taskStarted('  original tsconfig files');
+                commands = tslib_1.__spreadArray([
+                    "git checkout ".concat(this.tempOrgTsConfigFile),
+                    "git checkout ".concat(tnp_config_1.config.file.tsconfig_json)
+                ], tslib_1.__read(this.project.libraryBuild.libraries.map(function (lib) {
+                    return "git checkout ".concat(_this.project.relative(lib.location), "/").concat(tnp_config_1.config.file.tsconfig_lib_json);
+                })), false);
+                try {
+                    for (commands_1 = tslib_1.__values(commands), commands_1_1 = commands_1.next(); !commands_1_1.done; commands_1_1 = commands_1.next()) {
+                        command = commands_1_1.value;
+                        try {
+                            this.project
+                                .run(command, { output: false, biggerBuffer: false, silence: true })
+                                .sync();
+                        }
+                        catch (err) { }
+                    }
+                }
+                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                finally {
+                    try {
+                        if (commands_1_1 && !commands_1_1.done && (_a = commands_1.return)) _a.call(commands_1);
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                }
+                index_1.Helpers.taskDone('Restore original tsconfig files');
+                return [2 /*return*/];
+            });
+        });
+    };
+    return BaseLibraryBuild;
+}(base_feature_for_project_1.BaseFeatureForProject));
+exports.BaseLibraryBuild = BaseLibraryBuild;
+//# sourceMappingURL=base-library-build.js.map