tnp-helpers 19.0.64 → 19.0.66

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

@@ -1,16 +1,15 @@
 // @ts-nocheck
 import { Taon } from 'taon/browser';
 import { BaseCliWorkerConfig } from './base-cli-worker-config';
-export declare abstract class BaseCliWorkerController extends Taon.Base
-    .Controller {
+export declare abstract class BaseCliWorkerController<UPLOAD_FILE_QUERY_PARAMS = {}> extends Taon.Base.Controller<UPLOAD_FILE_QUERY_PARAMS> {
     /**
      * service id
      */
     private cliWorkerServiceId;
     private cliWorkerServiceVersion;
     baseCLiWorkerCommand_initializeMetadata(serviceId: string, serviceVersion: string): Taon.Response<void>;
-    baseCLiWorkerCommand_kill(): Taon.Response<void>;
-    info(): Taon.Response<string>;
+    baseCLiWorkerCommand_kill(dontRemoveConfigFile?: boolean): Taon.Response<void>;
+    info(): Taon.ResponseHtml;
     baseCLiWorkerCommand_isHealthy(checkingProcessConfig: BaseCliWorkerConfig): Taon.Response<boolean>;
     baseCLiWorkerCommand_hasUpToDateVersion(checkingProcessConfig: BaseCliWorkerConfig): Taon.Response<boolean>;
 }

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

@@ -8,7 +8,7 @@ export type BaseWorkerTerminalActionReturnType = {
         action: () => unknown | Promise<unknown>;
     };
 };
-export declare class BaseCliWorkerTerminalUI<WORKER extends BaseCliWorker<BaseCliWorkerController, any>> {
+export declare class BaseCliWorkerTerminalUI<WORKER extends BaseCliWorker<BaseCliWorkerController<any>, any>> {
     protected worker: WORKER;
     constructor(worker: WORKER);
     protected headerText(): Promise<string>;

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

@@ -1,9 +1,10 @@
 // @ts-nocheck
-import { Taon } from 'taon/browser';
+import { EndpointContext, Taon } from 'taon/browser';
 import { BaseCliWorkerConfig } from './base-cli-worker-config';
 import type { BaseCliWorkerController } from './base-cli-worker-controller';
 import { BaseCliWorkerTerminalUI } from './base-cli-worker-terminal-ui';
-export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerController, TERMINAL_UI extends BaseCliWorkerTerminalUI<any>> {
+import { BaseCliMethodOptions } from './base-cli-worker.models';
+export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerController<any>, TERMINAL_UI extends BaseCliWorkerTerminalUI<any> = any> {
     /**
      * unique id for service
      */
@@ -17,15 +18,13 @@ export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerCon
      */
     readonly serviceVersion: string;
     readonly SPECIAL_WORKER_READY_MESSAGE = "$$$ WORKER_READY $$$";
+    /**
+     * dependency workers that should be started before this worker
+     */
+    readonly dependencyWorkers: Map<string, BaseCliWorker<any, any>>;
     readonly terminalUI: TERMINAL_UI;
     readonly workerContextTemplate: ReturnType<typeof Taon.createContextTemplate>;
-    private workerMainContext;
-    getRemoteControllerFor(ipAddressOfTaonInstance: string, port?: number): Promise<REMOTE_CTRL>;
-    private workerRemoteContext;
     readonly controllerClass: new () => REMOTE_CTRL;
-    private contextForRemoteConnection;
-    protected get pathToProcessLocalInfoJson(): string;
-    get processLocalInfoObj(): BaseCliWorkerConfig;
     constructor(
     /**
      * unique id for service
@@ -39,43 +38,65 @@ export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerCon
      * unique id for service
      */
     serviceVersion: string);
-    /**
-     * <strong>IMPORTANT USE ONLY IN DEVELOPMENT !!!</strong>
-     * for production use startDetachedIfNeedsToBeStarted()
-     * start normally process
-     * this will crash if process already started
-     */
-    startNormallyInCurrentProcess(options?: {
-        actionBeforeTerminalUI?: () => Promise<void>;
-    }): Promise<void>;
-    getControllerForRemoteConnection(options?: {
-        calledFrom?: string;
-    }): Promise<REMOTE_CTRL>;
-    startDetachedIfNeedsToBeStarted(options?: {
-        useCurrentWindowForDetach?: boolean;
-    }): Promise<any>;
+    get processLocalInfoObj(): BaseCliWorkerConfig;
+    getRemoteControllerFor<ctrl = REMOTE_CTRL>(options?: {
+        methodOptions: Partial<BaseCliMethodOptions>;
+        /**
+         * Optionally get other controller from remote context
+         */
+        controllerClass?: new () => ctrl;
+    }): Promise<ctrl>;
     /**
      * stop if started
      */
     kill(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
         dontRemoveConfigFile?: boolean;
-    }): Promise<any>;
+    }): Promise<void>;
     /**
      * kill detached process and start again
      * @param options.detached - default true
      */
     restart(options?: {
-        detached?: boolean;
-        useCurrentWindowForDetach?: boolean;
+        methodOptions?: BaseCliMethodOptions;
     }): Promise<void>;
     /**
      * only for cli start
      * @param cliParams on from cli
      */
-    cliStartProcedure(cliParams: any): Promise<any>;
-    protected preventExternalConfigChange(): any;
-    protected preventStartIfAlreadyStarted(): Promise<void>;
-    protected killWorkerWithLowerVersion(): Promise<void>;
+    cliStartProcedure(options: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<{
+        controller: REMOTE_CTRL;
+        worker: BaseCliWorker<any, any>;
+        serviceId: string;
+    }>;
+    protected getRemoteContextFor(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<EndpointContext>;
+    protected get pathToProcessLocalInfoJson(): string;
+    protected get processLocalInfoPortNotInited(): boolean;
+    protected get workerIsStarting(): boolean;
+    protected startDetachedIfNeedsToBeStarted(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<void>;
+    /**
+     * <strong>IMPORTANT USE ONLY IN DEVELOPMENT !!!</strong>
+     * for production use startDetachedIfNeedsToBeStarted()
+     * start normally process
+     * this will crash if process already started
+     */
+    protected startNormallyInCurrentProcess(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+        actionBeforeTerminalUI?: () => Promise<void>;
+    }): Promise<void>;
+    protected preventExternalConfigChange(): void;
+    protected preventStartIfAlreadyStarted(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<void>;
+    protected killWorkerWithLowerVersion(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<void>;
     /**
      * This has 2 purposes:
      * - infinite check when when detached process finished starting
@@ -83,17 +104,20 @@ export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerCon
      */
     protected isServiceHealthy(options: {
         healthCheckRequestTrys?: number;
+        methodOptions?: Partial<BaseCliMethodOptions>;
     }): Promise<boolean>;
     /**
      * start if not started detached process
      */
     protected startDetached(options?: {
-        useCurrentWindowForDetach?: boolean;
+        methodOptions?: Partial<BaseCliMethodOptions>;
     }): Promise<void>;
     private saveProcessInfo;
-    protected initializeWorkerMetadata(): Promise<any>;
-    protected waitForProcessPortSavedToDisk(options?: {
-        calledFrom?: string;
+    protected initializeWorkerMetadata(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<void>;
+    protected waitForProcessPortSavedToDisk(options: {
+        methodOptions: BaseCliMethodOptions;
     }): Promise<void>;
-    getServicePort(): Promise<number>;
+    protected getServicePort(): Promise<number>;
 }

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

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { BaseClass } from 'taon/browser';
+interface BaseCliWorkerOptionCallable {
+    /**
+     * Name of the function from which the option was called
+     */
+    calledFrom: string;
+}
+declare class BaseCliWorkerConfigGetContextOptions {
+    /**
+     * default localhost
+     */
+    ipAddressOfTaonInstance?: string;
+    port?: number;
+}
+/**
+ * Default mode: DETACHED_CHILD_PROCESS
+ */
+export declare enum BaseCLiWorkerStartMode {
+    CHILD_PROCESS = "child",
+    IN_CURRENT_PROCESS = "process",
+    DETACHED_WINDOW = "window"
+}
+export declare class BaseCLiWorkerStartParams {
+    /**
+     * Start mode
+     * Default mode DETACHED_CHILD_PROCESS
+     */
+    mode: BaseCLiWorkerStartMode;
+    restart?: boolean;
+    kill?: boolean;
+}
+export declare class BaseCliMethodOptions extends BaseClass<BaseCliMethodOptions> implements BaseCliWorkerOptionCallable {
+    static from(opt?: Partial<BaseCliMethodOptions>): BaseCliMethodOptions;
+    connectionOptions?: BaseCliWorkerConfigGetContextOptions;
+    cliParams?: BaseCLiWorkerStartParams;
+    /**
+     * Name of the function from which the option was called
+     */
+    calledFrom: string;
+}
+export {};

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

@@ -0,0 +1,4 @@
+// @ts-nocheck
+export declare namespace BaseCliWorkerUtils {
+    const getPathToProcessLocalInfoJson: (serviceID: string) => string;
+}

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

@@ -1,5 +1,6 @@
 // @ts-nocheck
 export * from './base-cli-worker';
+export * from './base-cli-worker.models';
 export * from './base-cli-worker-database-config';
 export * from './base-cli-worker-controller';
 export * from './base-cli-worker-config';

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

@@ -13,4 +13,5 @@ export declare class BaseDocker<PROJECT extends BaseProject = any> extends BaseF
         env?: NodeJS.ProcessEnv;
         stdio?: StdioOptions;
     }): ChildProcess;
+    removeAllImagesBy_Env_COMPOSE_PROJECT_NAME(): Promise<void>;
 }

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

@@ -61,6 +61,7 @@ export declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeat
     resolveLastChanges(options?: {
         tryAutomaticActionFirst?: boolean;
         projectNameAsOutputPrefix?: string;
+        questionPrefixMessage?: string;
     }): Promise<void>;
     get hasActionCommitsToMelt(): boolean;
     /**
@@ -172,6 +173,7 @@ export declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeat
     }): Promise<void>;
     validateEmailDomain(allowedEmailsEnds: string[]): Promise<void>;
     protected _afterPullProcessAction(setOrigin: 'ssh' | 'http', skipCloneGitChildren?: boolean): Promise<void>;
+    backupBranch(branchName?: string): Promise<string>;
     pushProcess(options?: PushProcessOptions): Promise<void>;
     _beforeAnyActionOnGitRoot(): void;
     protected _beforePushProcessAction(setOrigin: 'ssh' | 'http'): Promise<void>;

package/browser/lib/base/classes/base-global-command-line.d.ts

@@ -0,0 +1,254 @@
+// @ts-nocheck
+import { PushProcessOptions } from '../../index';
+import { TypeOfCommit } from '../commit-data';
+import { BaseCommandLineFeature } from './base-command-line-feature';
+import { BaseProject } from './base-project';
+import type { BaseProjectResolver } from './base-project-resolver';
+export declare class BaseGlobalCommandLine<PARAMS = any, PROJECT extends BaseProject<any, any> = BaseProject<any, any>, PROJECT_RESOLVER extends BaseProjectResolver<PROJECT> = BaseProjectResolver<PROJECT>> extends BaseCommandLineFeature<PARAMS, PROJECT, PROJECT_RESOLVER> {
+    _(): void;
+    /**
+     * TODO return argument not need for now
+     */
+    cwdIsProject(options?: {
+        requireProjectWithGitRoot?: boolean;
+    }): Promise<boolean>;
+    hosts(): any;
+    countCommits(): any;
+    removeSubmodules(): any;
+    removeSubmodule(): any;
+    setEditor(): Promise<any>;
+    upapi(): Promise<any>;
+    apiup(): Promise<any>;
+    apiUpdate(): Promise<any>;
+    cu(): Promise<any>;
+    choreUpdate(): Promise<any>;
+    colorvscode(): any;
+    /**
+     * Generate or update .vscode/settings.json file color settings
+     */
+    settingsVscode(): any;
+    refreshVscodeColors(): any;
+    protected _regenerateVscodeSettingsColors(overideBottomColor?: string): void;
+    /**
+     * quick git update push
+     */
+    update(): Promise<any>;
+    private updateProject;
+    deepUp(noExit?: boolean): Promise<any>;
+    deepUpForce(noExit?: boolean): Promise<any>;
+    deepUpdateForce(noExit?: boolean): Promise<any>;
+    deepUpdate(noExit?: boolean): Promise<any>;
+    /**
+     * Push update
+     */
+    up(): Promise<any>;
+    /**
+     * Push update
+     */
+    pu(): Promise<any>;
+    develop(): Promise<any>;
+    dev(): Promise<any>;
+    repul(): Promise<any>;
+    repull(): Promise<any>;
+    pul(): Promise<any>;
+    pull(): Promise<any>;
+    pullAll(): Promise<any>;
+    pp(): Promise<any>;
+    private __resetInfo;
+    fetch(): Promise<any>;
+    reset(): Promise<any>;
+    soft(): Promise<any>;
+    rebase(): Promise<any>;
+    /**
+     * stash only staged files
+     */
+    stash(): Promise<any>;
+    /**
+     * stash all files
+     */
+    stashAll(): Promise<any>;
+    /**
+     * push force to all orgins
+     */
+    pushAllForce(): Promise<any>;
+    pAllForce(): Promise<any>;
+    pAllf(): Promise<any>;
+    pAll(): Promise<any>;
+    /**
+     * push to all origins
+     */
+    pushAll(force?: boolean): Promise<any>;
+    forcePush(): Promise<any>;
+    pushForce(): Promise<any>;
+    /**
+     * Commit and push this for single repo
+     */
+    commit(options?: {
+        force?: boolean;
+        typeofCommit?: TypeOfCommit;
+        origin?: string;
+        commitMessageRequired?: boolean;
+        noExit?: boolean;
+    }): Promise<any>;
+    _preventPushPullFromNotCorrectBranch(): Promise<any>;
+    qPush(): Promise<any>;
+    quickPush(): Promise<any>;
+    repushauto(): Promise<any>;
+    rePush(skipQuesion?: boolean): Promise<any>;
+    push(options?: PushProcessOptions): Promise<void>;
+    melt(): Promise<any>;
+    meltUp(): Promise<any>;
+    meltAll(): Promise<any>;
+    private __meltCommitsFunc;
+    private meltUpdateCommits;
+    pf(): Promise<any>;
+    pRel(): Promise<any>;
+    pRelease(): Promise<any>;
+    pushRelease(): Promise<any>;
+    mPush(): Promise<any>;
+    fmPush(): Promise<any>;
+    mfPush(): Promise<any>;
+    mforcePush(): Promise<any>;
+    meltforcePush(): Promise<any>;
+    forceMeltPush(): Promise<any>;
+    meltPush(force?: boolean): Promise<any>;
+    pushFeature(): Promise<any>;
+    pushFix(): Promise<any>;
+    pfix(): any;
+    pushChore(): Promise<any>;
+    pc(): Promise<any>;
+    pushRefactor(): Promise<any>;
+    pushref(): Promise<any>;
+    pref(): Promise<any>;
+    pushStyle(): Promise<any>;
+    pstyl(): Promise<any>;
+    pstyle(): Promise<any>;
+    pushDocs(): Promise<any>;
+    pd(): Promise<any>;
+    pdocs(): Promise<any>;
+    pushTest(): Promise<any>;
+    pTest(): Promise<any>;
+    pTests(): Promise<any>;
+    pushPerf(): Promise<any>;
+    pushCi(): Promise<any>;
+    branch(): Promise<any>;
+    pushBuild(): Promise<any>;
+    SET_ORIGIN(): Promise<any>;
+    RENAME_ORIGIN(): Promise<any>;
+    LAST_TAG_HASH(): Promise<any>;
+    LAST_TAG(): Promise<any>;
+    CHECK_TAG_EXISTS(): any;
+    /**
+     * TODO move somewhere
+     */
+    lint(): Promise<any>;
+    /**
+     * TODO move somewhere
+     */
+    version(): Promise<any>;
+    /**
+     * TODO move somewhere
+     */
+    init(): Promise<any>;
+    /**
+     * init parent and first level children
+     */
+    initAll(): Promise<any>;
+    /**
+     * TODO move somewhere
+     */
+    struct(): Promise<any>;
+    /**
+     * TODO move somewhere
+     */
+    info(): Promise<any>;
+    modified(): Promise<any>;
+    refresh(): Promise<void>;
+    changes(): Promise<any>;
+    allTags(): Promise<any>;
+    removeTag(): Promise<any>;
+    BRANCH_NAME(): any;
+    REMOTES(): any;
+    SET_REMOTE_SSH(): Promise<any>;
+    SET_REMOTE_http(): Promise<any>;
+    SET_REMOTE_https(): Promise<any>;
+    protected _resolveChildFromArg(): any;
+    origin(): any;
+    remote(): any;
+    originHttp(): any;
+    originHttps(): any;
+    originssh(): any;
+    origins(): any;
+    gitConfig(): any;
+    LAST_COMMIT_HASH(): any;
+    COMMIT_MESSAGE_BY_HASH(): Promise<any>;
+    LAST_5_COMMITS(): Promise<any>;
+    updateDepsFrom(): Promise<any>;
+    isSupportedTaonTerminal(): any;
+    isRunningInWindowsCmd(): any;
+    isRunningInWindowsPowerShell(): any;
+    INSTALL_PROJECT_EXTENSIONS(): Promise<void>;
+    INSTALL_PROJECT_EXT(): Promise<void>;
+    INS_PROJ_EXT(): Promise<void>;
+    INSTALL_PROJ_EXT(): Promise<void>;
+    projdb(): Promise<any>;
+    private __filterBranchesByPattern;
+    private __selectBrach;
+    clone(): Promise<any>;
+    ghSave(): Promise<any>;
+    ghRestore(): Promise<any>;
+    ports(): Promise<any>;
+    /**
+     * tnp startCliServicePortsWorker --restart
+     */
+    startCliServicePortsWorker(): Promise<void>;
+    waitForUserAnyKey(): Promise<any>;
+    pauseTerminal(): any;
+    sleepTerminal(): any;
+    ghPagesInit(): Promise<any>;
+    isPortInUse(): Promise<any>;
+    procInfo(): any;
+    processInfo(): any;
+    lastGitTag(): any;
+    checkPort(): Promise<any>;
+    checkPorts(): Promise<any>;
+    removeSymlinksDryRun(): any;
+    selectJava(): Promise<any>;
+    selectTomcat(): Promise<any>;
+    LN(): any;
+    copy(): any;
+    simulateDomain(): Promise<any>;
+    preview(): Promise<void>;
+    /**
+     * read huge file and display only lines with specyfic words
+     */
+    shorten(): Promise<any>;
+    dumpPackagesVersions(): void;
+    zip(): Promise<any>;
+    unzip(): Promise<any>;
+    startTransmission(): Promise<any>;
+    _removeTransmission(): Promise<any>;
+    backupBranch(): Promise<any>;
+    bb(): Promise<any>;
+    countCodeLines(): Promise<any>;
+    countCode(): Promise<any>;
+    countLines(): Promise<any>;
+    isNodeVersionOk(): any;
+    pwd(): void;
+    more(): Promise<any>;
+    less(): Promise<any>;
+    /**
+     *  npm install --global bin-version-check-cli
+     *  npm i -g yt-dlp
+     *  choco install ffmpeg
+     */
+    MP3(args: any): any;
+    MP4(args: any): any;
+    gif(): void;
+    killZs(): any;
+    startZs(): any;
+    zsKill(): any;
+    zsStart(): any;
+    startZscaller(): any;
+    killZscaller(): any;
+}

package/browser/lib/base/classes/base-node-modules.d.ts

@@ -58,5 +58,12 @@ export declare class BaseNodeModules<NPM_HELPERS extends BaseNpmHelpers = BaseNp
      * (or yarn install)
      */
     prepareCommand(options: CoreModels.NpmInstallOptions, cwd?: string): Promise<string>;
+    /**
+     *
+     * @param rootDir
+     * @param packageName
+     * @returns absolute paths to package dirs
+     */
+    private findPackageDirs;
     dedupePackages(packagesConfig?: DedupePackage[], countOnly?: boolean, fake?: boolean): void;
 }

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

@@ -39,6 +39,7 @@ export declare class BaseNpmHelpers<PROJECT extends BaseProject = BaseProject> e
             children: boolean;
         };
         skipQuestionToUser?: boolean;
+        messagePrefix?: string;
     }): Promise<boolean>;
     /**
      * @param registry when not specified, it will use the default npm registry

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

@@ -38,7 +38,9 @@ export declare class BaseReleaseProcess<PROJECT extends BaseProject<any, any> =
     get toBumpProjects(): PROJECT[];
     bumpNewVersionEverywhere(): Promise<any>;
     confirmNewVersion(): Promise<void>;
-    protected selectReleaseType(versionToUseResolveFn?: (releaseVersionBumpType: CoreModels.ReleaseVersionType) => string): Promise<CoreModels.ReleaseVersionType>;
+    protected selectReleaseType(versionToUseResolveFn?: (releaseVersionBumpType: CoreModels.ReleaseVersionType) => string, options?: {
+        quesitonPrefixMessage?: string;
+    }): Promise<CoreModels.ReleaseVersionType>;
     protected commitMessageInChangelogTransformFn(message: string): Promise<string>;
     getChangelogContentToAppend(askForEveryItem: boolean): Promise<string>;
     /**

package/browser/lib/base/classes/index.d.ts

@@ -19,4 +19,5 @@ export * from './base-quick-fixes';
 export * from './base-cli-worker';
 export * from './base-process-manager';
 export * from './base-command-line-feature';
-export * from './base-file-folders-operations';
+export * from './base-file-folders-operations';
+export * from './base-global-command-line';

package/browser/lib/base/gh-temp-code.d.ts

@@ -0,0 +1,17 @@
+// @ts-nocheck
+import { BaseProject } from './classes/base-project';
+/**
+ * Class to save and restore temporary code
+ * TODO fix removing files from repo
+ */
+export declare class GhTempCode {
+    private cwd;
+    private project;
+    constructor(cwd: string, project: BaseProject);
+    private GHTEMP_CODE_REPO_PATH;
+    private get cwdRepo();
+    private get tempPathRepo();
+    init(): any;
+    save(): Promise<any>;
+    restore(): Promise<any>;
+}

package/browser/lib/build-info._auto-generated_.d.ts

@@ -18,4 +18,4 @@ export declare const PROJECT_NPM_NAME = "tnp-helpers";
 /**
  *  Autogenerated by current cli tool. Use *tnp release* to bump version.
  */
-export declare const CURRENT_PACKAGE_VERSION = "19.0.64";
+export declare const CURRENT_PACKAGE_VERSION = "19.0.66";

package/browser/lib/utils.d.ts

@@ -192,44 +192,7 @@ export declare namespace UtilsPasswords {
     const hashPassword: (password: string) => Promise<string>;
     const verifyPassword: (password: string, stored: string) => Promise<boolean>;
 }
-export declare namespace FilePathMetaData {
-    /**
-     * Embed metadata into filename while preserving the extension.
-     *
-     * Example:
-     * embedData({ version: "1.2.3", envName: "__" }, "project.zip")
-     * -> "version|-|1.2.3||--||envName|-|__|||project.zip"
-     */
-    function embedData<T extends Record<string, any>>(data: T, orgFilename: string, options?: {
-        skipAddingBasenameAtEnd?: boolean;
-    }): string;
-    /**
-     * Extract metadata from filename (reverse of embedData).
-     *
-     * Example:
-     * extractData<{ version: string; env: string }>("myfile__version-1.2.3__env-prod.zip")
-     * -> { version: "1.2.3", env: "prod" }
-     */
-    function extractData<T extends Record<string, any>>(filename: string): T;
-    const getOnlyMetadataString: (filename: string) => string;
-}
-/**
- * Easy way to connect CLI commands to cli class methods.
- *
- * Example:
- * in clic class
- * $FirstCli {
- *
- *   @UtilsCliMethod.decorator('doSomething')
- *   doSomething() {
- *     console.log('doing something');
- *   }
- * }
- *
- * UtilsCliMethod.getFrom($FirstCli.prototype.doSomething) // "firstcli:dosomething"
- *
- */
-export declare namespace UtilsCliMethod {
-    const decorator: (methodName: string) => MethodDecorator;
-    const getFrom: (ClassPrototypeMethodFnHere: Function, globalMethod?: boolean) => string;
+export declare namespace UtilsDocker {
+    const DOCKER_LABEL_KEY = "com.docker.compose.project";
+    const cleanImagesByDockerLabel: (labelKey: string, labelValue: string) => Promise<void>;
 }

package/browser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tnp-helpers/browser",
-  "version": "19.0.64",
+  "version": "19.0.66",
   "module": "fesm2022/tnp-helpers.mjs",
   "typings": "index.d.ts",
   "exports": {

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

@@ -1,15 +1,14 @@
 import { Taon } from 'taon';
 import { BaseCliWorkerConfig } from './base-cli-worker-config';
-export declare abstract class BaseCliWorkerController extends Taon.Base
-    .Controller {
+export declare abstract class BaseCliWorkerController<UPLOAD_FILE_QUERY_PARAMS = {}> extends Taon.Base.Controller<UPLOAD_FILE_QUERY_PARAMS> {
     /**
      * service id
      */
     private cliWorkerServiceId;
     private cliWorkerServiceVersion;
     baseCLiWorkerCommand_initializeMetadata(serviceId: string, serviceVersion: string): Taon.Response<void>;
-    baseCLiWorkerCommand_kill(): Taon.Response<void>;
-    info(): Taon.Response<string>;
+    baseCLiWorkerCommand_kill(dontRemoveConfigFile?: boolean): Taon.Response<void>;
+    info(): Taon.ResponseHtml;
     baseCLiWorkerCommand_isHealthy(checkingProcessConfig: BaseCliWorkerConfig): Taon.Response<boolean>;
     baseCLiWorkerCommand_hasUpToDateVersion(checkingProcessConfig: BaseCliWorkerConfig): Taon.Response<boolean>;
 }