tnp-helpers 18.0.18 → 18.0.20

package/browser/lib/base/classes/base-cli-worker.d.ts

@@ -16,6 +16,7 @@ export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerCon
      * unique id for service
      */
     protected readonly serviceVersion: string;
+    protected SPECIAL_WORKER_READY_MESSAGE: string;
     constructor(
     /**
      * unique id for service
@@ -33,7 +34,9 @@ export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerCon
     abstract getControllerForRemoteConnection(): Promise<REMOTE_CTRL>;
     protected get pathToProcessLocalInfoJson(): string;
     protected get processLocalInfoObj(): BaseCliWorkerConfig;
-    startDetachedIfNeedsToBeStarted(): Promise<any>;
+    startDetachedIfNeedsToBeStarted(options?: {
+        useCurrentWindowForDetach?: boolean;
+    }): Promise<any>;
     /**
      * stop if started
      */
@@ -46,6 +49,7 @@ export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerCon
      */
     restart(options?: {
         detached?: boolean;
+        useCurrentWindowForDetach?: boolean;
     }): Promise<void>;
     /**
      * only for cli start
@@ -66,7 +70,9 @@ export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerCon
     /**
      * start if not started detached process
      */
-    protected startDetached(): Promise<any>;
+    protected startDetached(options?: {
+        useCurrentWindowForDetach?: boolean;
+    }): Promise<any>;
     protected headerText(): Promise<string>;
     protected textHeaderStyle(): CfontStyle;
     protected headerTextAlign(): CfontAlign;
@@ -75,13 +81,30 @@ export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerCon
      */
     protected header(): Promise<void>;
     infoMessageBelowHeader(): Promise<void>;
-    protected getWorkerTerminalActions(): {
+    protected get backAction(): {
+        back: {
+            name: string;
+        };
+    };
+    protected get chooseAction(): {
+        emptyAction: {
+            name: string;
+            action: () => Promise<void>;
+        };
+    };
+    protected displaySpecialWorkerReadyMessage(): void;
+    protected getWorkerTerminalActions(options?: {
+        exitIsOnlyReturn?: boolean;
+        chooseAction?: boolean;
+    }): {
         [uniqeActionName: string]: {
             name: string;
-            action: () => void | Promise<void>;
+            action: () => unknown | Promise<unknown>;
         };
     };
-    protected _infoScreen(): Promise<void>;
+    infoScreen(options?: {
+        exitIsOnlyReturn?: boolean;
+    }): Promise<void>;
     private saveProcessInfo;
     protected initializeWorkerMetadata(): Promise<any>;
     protected waitForProcessPortSavedToDisk(): Promise<void>;

package/browser/lib/base/classes/base-git.d.ts

@@ -24,6 +24,14 @@ export declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeat
      * alias to stage all and commit
      */
     addAndCommit(commitMessage: string): any;
+    getUserInfo(global?: boolean): Promise<{
+        name?: string;
+        email?: string;
+    }>;
+    setUserInfo({ name, email }: {
+        name?: string;
+        email?: string;
+    }, global?: boolean): Promise<void>;
     stageAllAndCommit(commitMessage: string): any;
     pushCurrentBranch(options?: {
         force?: boolean;

package/browser/lib/base/classes/base-library-build.d.ts

@@ -1,5 +1,4 @@
 // @ts-nocheck
-import { CoreModels } from 'tnp-core/browser';
 import { BaseFeatureForProject } from './base-feature-for-project';
 import { LibrariesBuildOptions, LibraryBuildCommandOptions } from '../../models';
 import type { BaseProject } from './base-project';
@@ -39,21 +38,19 @@ export declare abstract class BaseLibraryBuild<PROJECT extends BaseProject<BaseP
     /**
      * Angular library build
      */
-    buildLibraries({ watch, strategy, releaseBuild, buildType, copylink_to_node_modules, outputLineReplace, libraries, useLastUserConfiguration, }?: LibrariesBuildOptions<PROJECT> & {
+    buildLibraries({ watch, strategy, releaseBuild, copylink_to_node_modules, outputLineReplace, libraries, useLastUserConfiguration, }?: LibrariesBuildOptions<PROJECT> & {
         watch?: boolean;
     }): Promise<void>;
-    protected libWatchBuildProcess({ lib, locationsForNodeModules, strategy, buildType, outputLineReplace, }: {
+    protected libWatchBuildProcess({ lib, locationsForNodeModules, strategy, outputLineReplace, }: {
         lib: PROJECT;
         locationsForNodeModules: string[];
         strategy: 'link' | 'copy';
-        buildType: CoreModels.LibraryType;
         outputLineReplace?: (outputLine: string) => string;
     }): Promise<any>;
-    protected libNormalBuildProcess({ lib, locationsForNodeModules, strategy, buildType, outputLineReplace, }: {
+    protected libNormalBuildProcess({ lib, locationsForNodeModules, strategy, outputLineReplace, }: {
         lib: PROJECT;
         locationsForNodeModules: string[];
         strategy: 'link' | 'copy';
-        buildType: CoreModels.LibraryType;
         outputLineReplace?: (outputLine: string) => string;
     }): Promise<any>;
     getLibraryBuildComamnd(options?: LibraryBuildCommandOptions): string | undefined;

package/browser/lib/base/classes/base-npm-helpers.d.ts

@@ -5,6 +5,7 @@ import { PackageJson } from 'type-fest';
 import { CoreModels } from 'tnp-core/browser';
 export declare class BaseNpmHelpers<PROJECT extends BaseProject = any> extends BaseFeatureForProject {
     private packageJSON;
+    private bowerJson;
     constructor(project: PROJECT);
     updateDepsFrom(locations: string[]): any;
     /**
@@ -61,6 +62,7 @@ export declare class BaseNpmHelpers<PROJECT extends BaseProject = any> extends B
      * npm dependencies from package.json
      */
     get dependencies(): Partial<Record<string, string>>;
+    get bowerDependencies(): Partial<Record<string, string>>;
     /**
      * peerDependencies dependencies
      */
@@ -101,7 +103,9 @@ export declare class BaseNpmHelpers<PROJECT extends BaseProject = any> extends B
             stdoutMsg: string | string[];
             stderMsg?: string | string[];
             timeout?: number;
-            stdoutOutputContainsCallback?: () => any;
+            stdoutOutputContainsCallback? /**
+             * resolutions dependencies
+             */: () => any;
             outputLineReplace?: (outputLine: string) => string;
         }): Promise<void>;
         unitlOutputContains(stdoutMsg: string | string[], stderMsg?: string | string[], timeout?: number, stdoutOutputContainsCallback?: () => any): any;

package/browser/lib/base/classes/base-project.d.ts

@@ -162,14 +162,15 @@ export declare abstract class BaseProject<PROJECT extends BaseProject = BaseProj
     };
     remove(relativePath: string | string[], exactPath?: boolean): any;
     removeFolderByRelativePath(relativePathToFolder: string): void;
+    get isAngularLib(): any;
     protected getUniqueForTask(task: string): string;
     registerAndAssignPort(taskName: string, options?: {
         startFrom?: number;
     }): Promise<number>;
     /**
-     * @deprecated use registerAndAssignPort() instead
+     * @deprecated use this.registerAndAssignPort() or Utils.getFreePort() instead
      */
-    assignFreePort(startFrom?: number, howManyFreePortsAfterThatPort?: number): Promise<number>;
+    assignFreePort(startFrom?: number): Promise<number>;
     removeItself(): void;
     /**
      * Purpose: not initializing all classes at the beginning

package/browser/lib/base/classes/base-release-process.d.ts

@@ -3,31 +3,34 @@ import { BaseFeatureForProject } from './base-feature-for-project';
 import type { BaseProject } from './base-project';
 import { CoreModels } from 'tnp-core/browser';
 import type { ChangelogData } from '../../models';
-export declare class BaseReleaseProcess<PROJECT extends BaseProject<any, any> = any> extends BaseFeatureForProject {
+export declare class BaseReleaseProcess<PROJECT extends BaseProject<any, any> = any, ARTIFACT = string> extends BaseFeatureForProject {
     project: PROJECT;
     /**
      * Automatic release process of patch plus one version
      */
     automaticRelease: boolean;
-    type: CoreModels.ReleaseType;
+    versionType: CoreModels.ReleaseVersionType;
+    processType: CoreModels.ReleaseProcessType;
+    releaseArtifactName: ARTIFACT;
+    preReleaseVersionTag: CoreModels.PreReleaseVersionTag;
     lastChangesSummary: string;
     newVersion: string;
     commitsForChangelog: {
         commitMessages: string;
         index: number;
     }[];
+    startRelease(options?: Partial<BaseReleaseProcess<PROJECT>>): Promise<void>;
     getReleaseWords(): string[];
-    startRelease(options?: Partial<Pick<BaseReleaseProcess<PROJECT>, 'automaticRelease' | 'type' | 'newVersion'>>): Promise<void>;
-    private reinstallNodeModules;
+    protected reinstallNodeModules(): Promise<void>;
     selectChangelogCommits(): Promise<{
         commitMessages: string;
         index: number;
     }[]>;
     private getCommitsUpToReleaseCommit;
-    private publishToNpm;
-    private testAfterPublish;
-    private testBeforePublish;
-    private commitAndPush;
+    protected publishToNpm(): Promise<boolean>;
+    protected testAfterPublish(): Promise<boolean>;
+    protected testBeforePublish(): Promise<boolean>;
+    protected commitAndPush(): Promise<void>;
     protected releaseCommitTemplate(): string;
     private testLibraries;
     buildAllLibraries(): Promise<void>;
@@ -35,7 +38,7 @@ export declare class BaseReleaseProcess<PROJECT extends BaseProject<any, any> =
     get toBumpProjects(): PROJECT[];
     bumpNewVersionEverywhere(): Promise<any>;
     confirmNewVersion(): Promise<void>;
-    private selectReleaseType;
+    protected selectReleaseType(): Promise<CoreModels.ReleaseVersionType>;
     protected commitMessageInChangelogTransformFn(message: string): Promise<string>;
     getChangelogContentToAppend(askForEveryItem: boolean): Promise<string>;
     /**
@@ -56,7 +59,7 @@ export declare class BaseReleaseProcess<PROJECT extends BaseProject<any, any> =
         stopOnCommitMessage?: string;
     }): Promise<string>;
     getLastReleaseCommitData(): Promise<{
-        lastRelaseCommitMsg: string;
+        lastReleaseCommitMsg: string;
         /**
          * -1 if not found
          */

package/browser/lib/base/core-project.d.ts

@@ -73,7 +73,7 @@ export declare class CoreProject<PROJECT extends BaseProject = BaseProject> {
      */
     environments?: CoreProjectEnvironment[];
     startCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
-    relaseCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
+    releaseCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
     publishCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
     deployCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
     testCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;

package/browser/lib/base/tcp-udp-ports/index.d.ts

@@ -1,5 +1,4 @@
 // @ts-nocheck
-export * from './not-assignable-port.entity';
 export * from './ports.entity';
 export * from './ports.controller';
 export * from './tcp-upd-ports.worker';

package/browser/lib/base/tcp-udp-ports/ports.controller.d.ts

@@ -2,15 +2,24 @@
 import { Taon } from 'taon/browser';
 import { BaseCliWorkerController } from '../classes/base-cli-worker-controller';
 import { Port, PortStatus } from './ports.entity';
-import { NotAssignablePort } from './not-assignable-port.entity';
 export declare class PortsController extends BaseCliWorkerController {
     START_PORT: number;
     END_PORT: number;
-    readonly takenByOsPorts: Map<number, NotAssignablePort>;
-    readonly assignedPorts: Map<string, Port>;
-    get firstFreePort(): Port;
-    protected firstUnassignedPortMoreThan(port: number): Port;
-    getPortByStatus(status: PortStatus): Taon.Response<Port[]>;
+    readonly portsCache: Map<string, Port>;
+    protected get firstFreePort(): any;
+    protected firstUnassignedPortMoreThan(port: number): any;
+    getFirstFreePort(): Taon.Response<Port>;
+    getPortByNumber(portNumber: number): Taon.Response<Port>;
+    getPortsByStatus(status: PortStatus): Taon.Response<Port[]>;
+    /**
+     * make it unassigned
+     */
+    deletePort(portNumber: number): Taon.Response<Port>;
+    /**
+     * make it unassigned
+     */
+    updatePortUniqueId(portNumber: number, serviceId: string): Taon.Response<Port>;
+    addTakeByOsPort(portNumber: number, uniqueId: string): Taon.Response<Port>;
     /**
      * @param uniqueServiceName unique service name
      * @param startFrom start searching for free port from this number

package/browser/lib/base/tcp-udp-ports/ports.entity.d.ts

@@ -1,13 +1,17 @@
 // @ts-nocheck
-import { NotAssignablePort } from './not-assignable-port.entity';
+import { Taon } from 'taon/browser';
 export type PortStatus = 'unassigned' | 'assigned' | 'assigned-not-registered' | 'assigned-taken-by-os';
 export declare const PortStatusArr: PortStatus[];
-export declare class Port extends NotAssignablePort {
-    static from(opt: Omit<Port, 'version' | '_' | 'clone'>): Port & Omit<Port, "_" | "version" | "clone">;
+export declare class Port extends Taon.Base.Entity {
+    static from(opt: Omit<Port, 'version' | '_' | 'clone' | 'titleOnList'>): Port & Omit<Port, "_" | "version" | "clone" | "titleOnList">;
+    static getTitleForFreePort(port: Number): string;
+    get titleOnList(): string;
+    port: number;
+    serviceId: string;
     /**
      * Port status
      */
-    status?: PortStatus;
+    status: PortStatus;
     /**
      * When port was assigned as registered service
      */

package/browser/lib/base/tcp-udp-ports/tcp-upd-ports.worker.d.ts

@@ -1,6 +1,6 @@
 // @ts-nocheck
 import { BaseCliWorker, CfontStyle } from '../classes/base-cli-worker';
-import { PortStatus } from '../../index';
+import { Port, PortStatus } from '../../index';
 import { PortsController } from '../tcp-udp-ports/ports.controller';
 export declare class PortsWorker extends BaseCliWorker<PortsController> {
     private portsController;
@@ -13,11 +13,13 @@ export declare class PortsWorker extends BaseCliWorker<PortsController> {
      */
     startNormallyInCurrentProcess(): Promise<any>;
     protected displayItemsForPortsStatus(status: PortStatus): Promise<any>;
-    get backAction(): {
-        back: {
-            name: string;
-            action: () => Promise<boolean>;
-        };
-    };
-    getWorkerTerminalActions(): any;
+    getWorkerTerminalActions(options?: {
+        exitIsOnlyReturn?: boolean;
+    }): any;
+    protected getNewPortToAdd(): Promise<number>;
+    protected addPortTerminalUiProcess(): Promise<void>;
+    protected selectPortProcess(ports: Port[], title: string): Promise<Port>;
+    protected deletePortTerminalUiProcess(): Promise<any>;
+    protected editPortTerminalUiProcess(): Promise<any>;
+    protected crudMenuForTakeByOsPorts(): Promise<void>;
 }

package/browser/lib/index.d.ts

@@ -3,8 +3,6 @@ export * from './validators/validators';
 export { HelpersAngular } from './helpers/for-browser/angular.helper';
 export * from './utils';
 import { HelpersTaon as Base } from './helpers/helpers';
-/**
- * Taon helpers
- */ export declare const Helpers: Base;
+export declare const Helpers: Base;
 export * from './base';
 export * from './models';

package/browser/lib/models.d.ts

@@ -20,15 +20,9 @@ export type NgProject = {
 };
 export type LibraryBuildCommandOptions = {
     watch?: boolean;
-    buildType: core.CoreModels.LibraryType;
 };
 export type LibrariesBuildOptions<PROJECT extends BaseProject = BaseProject> = {
     strategy?: 'link' | 'copy';
-    /**
-     * @deprecated
-     * this will be detected in future
-     */
-    buildType: core.CoreModels.LibraryType;
     /**
      * by default we are copying all libraries to node_modules of itself
      */

package/client/README.md

@@ -1,24 +1,24 @@
-# MyLib
-
-This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 13.2.0.
-
-## Code scaffolding
-
-Run `ng generate component component-name --project my-lib` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project my-lib`.
-> Note: Don't forget to add `--project my-lib` or else it will be added to the default project in your `angular.json` file. 
-
-## Build
-
-Run `ng build my-lib` to build the project. The build artifacts will be stored in the `dist/` directory.
-
-## Publishing
-
-After building your library with `ng build my-lib`, go to the dist folder `cd dist/my-lib` and run `npm publish`.
-
-## Running unit tests
-
-Run `ng test my-lib` to execute the unit tests via [Karma](https://karma-runner.github.io).
-
-## Further help
-
-To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.
+# MyLib
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 13.2.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project my-lib` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project my-lib`.
+> Note: Don't forget to add `--project my-lib` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build my-lib` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build my-lib`, go to the dist folder `cd dist/my-lib` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test my-lib` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/client/esm2022/lib/base/classes/base-cli-worker.mjs

@@ -19,6 +19,7 @@ export class BaseCliWorker {
         this.serviceID = serviceID;
         this.startCommand = startCommand;
         this.serviceVersion = serviceVersion;
+        this.SPECIAL_WORKER_READY_MESSAGE = '$$$ WORKER_READY $$$';
     }
     get pathToProcessLocalInfoJson() {
         /* */
@@ -40,7 +41,7 @@ export class BaseCliWorker {
         /* */
         return (void 0);
     }
-    async startDetachedIfNeedsToBeStarted() {
+    async startDetachedIfNeedsToBeStarted(options) {
         /* */
         /* */
         /* */
@@ -96,7 +97,7 @@ export class BaseCliWorker {
         //longer because os is disposing process previous process
         if (options.detached) {
             Helpers.info(`Restarting service "${this.serviceID}" in detached mode...`);
-            await this.startDetached();
+            await this.startDetached(options);
         }
         else {
             Helpers.info(`Restarting service "${this.serviceID}" in current process...`);
@@ -262,12 +263,25 @@ export class BaseCliWorker {
         /* */
         /* */
         /* */
+        /* */
+        /* */
+        /* */
         return (void 0);
     }
     /**
      * start if not started detached process
      */
-    async startDetached() {
+    async startDetached(options) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
         /* */
         /* */
         /* */
@@ -336,7 +350,38 @@ export class BaseCliWorker {
         /* */
         return (void 0);
     }
-    getWorkerTerminalActions() {
+    get backAction() {
+        return {
+            back: {
+                name: 'Back',
+            },
+        };
+    }
+    get chooseAction() {
+        return {
+            emptyAction: {
+                name: ' -- choose any action below --',
+                action: async () => { },
+            },
+        };
+    }
+    displaySpecialWorkerReadyMessage() {
+        console.log(this.SPECIAL_WORKER_READY_MESSAGE);
+    }
+    getWorkerTerminalActions(options) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
         /* */
         /* */
         /* */
@@ -363,18 +408,22 @@ export class BaseCliWorker {
         /* */
         return (void 0);
     }
-    async _infoScreen() {
+    async infoScreen(options) {
+        options = options || {};
         while (true) {
             Helpers.clearConsole();
             await this.header();
             await this.infoMessageBelowHeader();
-            const choices = this.getWorkerTerminalActions();
+            const choices = this.getWorkerTerminalActions(options);
             const choice = await UtilsTerminal.select({
                 choices,
                 question: 'Choose action',
             });
             const action = choices[choice].action;
-            await action();
+            const result = await action();
+            if (choice === 'exit' && result) {
+                break;
+            }
         }
     }
     saveProcessInfo(processConfig) {
@@ -463,4 +512,4 @@ export class BaseCliWorker {
 }
 ;
 ({}); // @--end-of-file-for-module=tnp-helpers lib/base/classes/base-cli-worker.ts
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-cli-worker.js","sourceRoot":"","sources":["../../../../../../tmp-libs-for-dist/tnp-helpers/projects/tnp-helpers/src/lib/base/classes/base-cli-worker.ts"],"names":[],"mappings":"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","sourcesContent":["\n\n\nimport {   chalk,   crossPlatformPath,   _, /* */ /* */ /* */ /* */ /* */      UtilsTerminal, } from 'tnp-core/browser';/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n\nimport { config } from 'tnp-config/browser';\nimport { Helpers } from '../../index';\nimport type { BaseCliWorkerController } from './base-cli-worker-controller';\nimport { BaseCliWorkerConfig } from './base-cli-worker-config';\n\n\n\nconst WORKER_INIT_START_TIME_LIMIT = 25; // 15 seconds max to start worker\nconst START_PORT_FOR_SERVICES = 3600;\n\n\n\nexport type CfontStyle =\n  | 'block'\n  | 'slick'\n  | 'tiny'\n  | 'grid'\n  | 'pallet'\n  | 'shade'\n  | 'chrome'\n  | 'simple'\n  | 'simpleBlock'\n  | '3d'\n  | 'simple3d'\n  | 'huge';\n\nexport type CfontAlign = 'left' | 'center' | 'right' | 'block';\n\n\nexport abstract class BaseCliWorker<\n  REMOTE_CTRL extends BaseCliWorkerController = BaseCliWorkerController,\n> {\n\n  constructor(\n    /**\n     * unique id for service\n     */\n    protected readonly serviceID: string,\n    /**\n     * external command that will start service\n     */\n    protected readonly startCommand: string,\n    /**\n     * unique id for service\n     */\n    protected readonly serviceVersion: string,\n  ) {}\n\n\n\n  protected abstract startNormallyInCurrentProcess(options?: {});\n\n  public abstract getControllerForRemoteConnection(): Promise<REMOTE_CTRL>;\n\n\n\n\n\n  protected get pathToProcessLocalInfoJson(): string {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  protected get processLocalInfoObj(): BaseCliWorkerConfig {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n\n\n\n\n  public async startDetachedIfNeedsToBeStarted() {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  /**\n   * stop if started\n   */\n  async kill(options?: { dontRemoveConfigFile?: boolean }) {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  /**\n   * kill detached process and start again\n   * @param options.detached - default true\n   */\n  async restart(options?: { detached?: boolean }) {\n    options = options || {};\n    options.detached = _.isUndefined(options.detached) ? true : false;\n    await this.kill();\n    //longer because os is disposing process previous process\n\n    if (options.detached) {\n      Helpers.info(\n        `Restarting service \"${this.serviceID}\" in detached mode...`,\n      );\n      await this.startDetached();\n    } else {\n      Helpers.info(\n        `Restarting service \"${this.serviceID}\" in current process...`,\n      );\n      await this.startNormallyInCurrentProcess();\n    }\n  }\n\n\n\n  /**\n   * only for cli start\n   * @param cliParams on from cli\n   */\n  async cliStartProcedure(cliParams: any) {\n    const instance: BaseCliWorker = this;\n    const detached = !!cliParams['detached'] || !!cliParams['detach'];\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n      return (void 0);\n  }\n\n\n\n\n\n\n\n  protected preventExternalConfigChange() {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  protected async preventStartIfAlreadyStarted() {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  protected async killWorkerWithLowerVersion() {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  /**\n   * This has 2 purposes:\n   * - infinite check when when detached process finished starting\n   * - quick check if service is healthy / already started\n   */\n  protected async isServiceHealthy(options: {\n    healthCheckRequestTrys?: number;\n  }): Promise<boolean> {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  /**\n   * start if not started detached process\n   */\n  protected async startDetached() {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  protected async headerText(): Promise<string> {\n    return _.startCase(this.serviceID);\n  }\n\n\n\n  protected textHeaderStyle(): CfontStyle {\n    return 'block';\n  }\n\n\n\n  protected headerTextAlign(): CfontAlign {\n    return 'left';\n  }\n\n\n\n  /**\n   * override whole terminal header\n   */\n  protected async header(): Promise<void> {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  async infoMessageBelowHeader(): Promise<void> {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n  protected getWorkerTerminalActions(): {\n    [uniqeActionName: string]: {\n      name: string;\n      action: () => void | Promise<void>;\n    };\n  } {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n  protected async _infoScreen() {\n    while (true) {\n      Helpers.clearConsole();\n\n      await this.header();\n\n      await this.infoMessageBelowHeader();\n      const choices = this.getWorkerTerminalActions();\n      const choice = await UtilsTerminal.select<keyof typeof choices>({\n        choices,\n        question: 'Choose action',\n      });\n      const action = choices[choice].action;\n      await action();\n    }\n  }\n\n\n\n  private saveProcessInfo(processConfig: Partial<BaseCliWorkerConfig>) {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  protected async initializeWorkerMetadata() {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  protected async waitForProcessPortSavedToDisk(): Promise<void> {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  async getServicePort(): Promise<number> {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n}\n\n ;({}); // @--end-of-file-for-module=tnp-helpers lib/base/classes/base-cli-worker.ts"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-cli-worker.js","sourceRoot":"","sources":["../../../../../../tmp-libs-for-dist/tnp-helpers/projects/tnp-helpers/src/lib/base/classes/base-cli-worker.ts"],"names":[],"mappings":"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","sourcesContent":["\n\n\nimport {   chalk,   crossPlatformPath,   _, /* */ /* */ /* */ /* */ /* */      UtilsTerminal, } from 'tnp-core/browser';/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n\nimport { config } from 'tnp-config/browser';\nimport { Helpers } from '../../index';\nimport type { BaseCliWorkerController } from './base-cli-worker-controller';\nimport { BaseCliWorkerConfig } from './base-cli-worker-config';\n\n\n\nconst WORKER_INIT_START_TIME_LIMIT = 25; // 15 seconds max to start worker\nconst START_PORT_FOR_SERVICES = 3600;\n\n\n\nexport type CfontStyle =\n  | 'block'\n  | 'slick'\n  | 'tiny'\n  | 'grid'\n  | 'pallet'\n  | 'shade'\n  | 'chrome'\n  | 'simple'\n  | 'simpleBlock'\n  | '3d'\n  | 'simple3d'\n  | 'huge';\n\nexport type CfontAlign = 'left' | 'center' | 'right' | 'block';\n\n\nexport abstract class BaseCliWorker<\n  REMOTE_CTRL extends BaseCliWorkerController = BaseCliWorkerController,\n> {\n  protected SPECIAL_WORKER_READY_MESSAGE = '$$$ WORKER_READY $$$';\n\n\n  constructor(\n    /**\n     * unique id for service\n     */\n    protected readonly serviceID: string,\n    /**\n     * external command that will start service\n     */\n    protected readonly startCommand: string,\n    /**\n     * unique id for service\n     */\n    protected readonly serviceVersion: string,\n  ) {}\n\n\n\n  protected abstract startNormallyInCurrentProcess(options?: {});\n\n  public abstract getControllerForRemoteConnection(): Promise<REMOTE_CTRL>;\n\n\n\n\n\n  protected get pathToProcessLocalInfoJson(): string {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  protected get processLocalInfoObj(): BaseCliWorkerConfig {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n\n\n\n\n  public async startDetachedIfNeedsToBeStarted(options?: {\n    useCurrentWindowForDetach?: boolean;\n  }) {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  /**\n   * stop if started\n   */\n  async kill(options?: { dontRemoveConfigFile?: boolean }) {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  /**\n   * kill detached process and start again\n   * @param options.detached - default true\n   */\n  async restart(options?: {\n    detached?: boolean;\n    useCurrentWindowForDetach?: boolean;\n  }) {\n    options = options || {};\n    options.detached = _.isUndefined(options.detached) ? true : false;\n    await this.kill();\n    //longer because os is disposing process previous process\n\n    if (options.detached) {\n      Helpers.info(\n        `Restarting service \"${this.serviceID}\" in detached mode...`,\n      );\n      await this.startDetached(options);\n    } else {\n      Helpers.info(\n        `Restarting service \"${this.serviceID}\" in current process...`,\n      );\n      await this.startNormallyInCurrentProcess();\n    }\n  }\n\n\n\n  /**\n   * only for cli start\n   * @param cliParams on from cli\n   */\n  async cliStartProcedure(cliParams: any) {\n    const instance: BaseCliWorker = this;\n    const detached = !!cliParams['detached'] || !!cliParams['detach'];\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n      return (void 0);\n  }\n\n\n\n\n\n\n\n  protected preventExternalConfigChange() {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  protected async preventStartIfAlreadyStarted() {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  protected async killWorkerWithLowerVersion() {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  /**\n   * This has 2 purposes:\n   * - infinite check when when detached process finished starting\n   * - quick check if service is healthy / already started\n   */\n  protected async isServiceHealthy(options: {\n    healthCheckRequestTrys?: number;\n  }): Promise<boolean> {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  /**\n   * start if not started detached process\n   */\n  protected async startDetached(options?: {\n    useCurrentWindowForDetach?: boolean;\n  }) {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  protected async headerText(): Promise<string> {\n    return _.startCase(this.serviceID);\n  }\n\n\n\n  protected textHeaderStyle(): CfontStyle {\n    return 'block';\n  }\n\n\n\n  protected headerTextAlign(): CfontAlign {\n    return 'left';\n  }\n\n\n\n  /**\n   * override whole terminal header\n   */\n  protected async header(): Promise<void> {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  async infoMessageBelowHeader(): Promise<void> {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  protected get backAction() {\n    return {\n      back: {\n        name: 'Back',\n      },\n    };\n  }\n\n\n\n  protected get chooseAction() {\n    return {\n      emptyAction: {\n        name: ' -- choose any action below --',\n        action: async () => {},\n      },\n    };\n  }\n\n\n\n  protected displaySpecialWorkerReadyMessage() {\n    console.log(this.SPECIAL_WORKER_READY_MESSAGE);\n  }\n\n\n\n  protected getWorkerTerminalActions(options?: {\n    exitIsOnlyReturn?: boolean;\n    chooseAction?: boolean;\n  }): {\n    [uniqeActionName: string]: {\n      name: string;\n      action: () => unknown | Promise<unknown>;\n    };\n  } {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  public async infoScreen(options?: { exitIsOnlyReturn?: boolean }) {\n    options = options || {};\n    while (true) {\n      Helpers.clearConsole();\n\n      await this.header();\n\n      await this.infoMessageBelowHeader();\n      const choices = this.getWorkerTerminalActions(options);\n      const choice = await UtilsTerminal.select<keyof typeof choices>({\n        choices,\n        question: 'Choose action',\n      });\n      const action = choices[choice].action;\n      const result = await action();\n      if (choice === 'exit' && result) {\n        break;\n      }\n    }\n  }\n\n\n\n  private saveProcessInfo(processConfig: Partial<BaseCliWorkerConfig>) {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  protected async initializeWorkerMetadata() {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  protected async waitForProcessPortSavedToDisk(): Promise<void> {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n  async getServicePort(): Promise<number> {\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n/* */\n    return (void 0);\n  }\n\n\n\n}\n\n ;({}); // @--end-of-file-for-module=tnp-helpers lib/base/classes/base-cli-worker.ts"]}