tnp-helpers 18.0.20 → 18.0.21

package/websql/lib/base/classes/base-bower-json.d.ts

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { BaseJsonFileReader } from './base-json-file-reader';
+/**
+ * Minimal interface describing a bower.json file according to:
+ * https://github.com/bower/spec/blob/master/json.md
+ */
+export interface BowerJson {
+    name: string;
+    version?: string;
+    description?: string;
+    main?: string | string[];
+    keywords?: string[];
+    authors?: Array<string | {
+        name: string;
+        email?: string;
+        homepage?: string;
+    }>;
+    license?: string;
+    homepage?: string;
+    private?: boolean;
+    repository?: {
+        type: string;
+        url: string;
+    };
+    ignore?: string[];
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    resolutions?: Record<string, string>;
+    moduleType?: string | string[];
+}
+export declare class BaseBowerJson extends BaseJsonFileReader<BowerJson> {
+    cwd: string;
+    constructor(cwd: string);
+    get dependencies(): Record<string, string>;
+}

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

@@ -1,6 +1,6 @@
 // @ts-nocheck
-import type { BaseCliWorkerController } from './base-cli-worker-controller';
 import { BaseCliWorkerConfig } from './base-cli-worker-config';
+import type { BaseCliWorkerController } from './base-cli-worker-controller';
 export type CfontStyle = 'block' | 'slick' | 'tiny' | 'grid' | 'pallet' | 'shade' | 'chrome' | 'simple' | 'simpleBlock' | '3d' | 'simple3d' | 'huge';
 export type CfontAlign = 'left' | 'center' | 'right' | 'block';
 export declare abstract class BaseCliWorker<REMOTE_CTRL extends BaseCliWorkerController = BaseCliWorkerController> {

package/websql/lib/base/classes/base-debounce-compiler-for-project.d.ts

@@ -1,9 +1,9 @@
 // @ts-nocheck
-import { BaseProject } from './base-project';
-import { BaseCompilerForProject } from './base-compiler-for-project';
 import { ChangeOfFile } from 'incremental-compiler/websql';
+import { BaseCompilerForProject } from './base-compiler-for-project';
+import { BaseProject } from './base-project';
 export declare abstract class BaseDebounceCompilerForProject<ADDITIONAL_DATA = any, PROJECT extends BaseProject = BaseProject> extends BaseCompilerForProject<ADDITIONAL_DATA, PROJECT> {
-    protected initalParams: ADDITIONAL_DATA;
+    protected initialParams: ADDITIONAL_DATA;
     /**
      * default debounce time is 1s
      */
@@ -19,11 +19,11 @@ export declare abstract class BaseDebounceCompilerForProject<ADDITIONAL_DATA = a
     /**
      * @deprecated use action() instead
      */
-    syncAction(absFilesPathes: string[], initalParams: ADDITIONAL_DATA): Promise<void>;
+    syncAction(absFilesPathes: string[], initialParams: ADDITIONAL_DATA): Promise<void>;
     private lastAsyncFilesChanges;
     private debounceAction;
     /**
      * @deprecated use action() instead
      */
-    asyncAction(asyncEvents: ChangeOfFile, initalParams?: ADDITIONAL_DATA): Promise<void>;
+    asyncAction(asyncEvents: ChangeOfFile, initialParams?: ADDITIONAL_DATA): Promise<void>;
 }

package/websql/lib/base/classes/base-feature-for-project.d.ts

@@ -1,6 +1,7 @@
 // @ts-nocheck
 import { BaseProject } from './base-project';
-export declare abstract class BaseFeatureForProject<PROJECT = BaseProject> {
+export declare abstract class BaseFeatureForProject<PROJECT extends BaseProject<any, any> = BaseProject<any, any>> {
     protected project: PROJECT;
+    get ins(): import("tnp-helpers/websql").BaseProjectResolver<any>;
     constructor(project: PROJECT);
 }

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

@@ -1,18 +1,19 @@
 // @ts-nocheck
-import { BaseFeatureForProject } from './base-feature-for-project';
 import { CommitData, PushProcessOptions, TypeOfCommit } from '../../index';
+import { BaseFeatureForProject } from './base-feature-for-project';
 import type { BaseProject } from './base-project';
-export declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeatureForProject {
-    project: PROJECT;
+export declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
     unstageAllFiles(): any;
     revertFileChanges(fileReletivePath: string): any;
     clone(url: string, destinationFolderName?: string, branchName?: string): Promise<any>;
     restoreLastVersion(relativeFilePath: string): void;
-    stageAllFiles(): any;
+    stageAllFiles(): void;
+    stageFile(relativeFilePath: string): void;
     stash(options?: {
         onlyStaged?: boolean;
     }): any;
-    stashApply(): any;
+    rebase(toBranch: string): any;
+    stashApply(): void;
     fetch(all?: boolean): any;
     resetFiles(...relativePathes: string[]): any;
     get isInsideGitRepo(): any;
@@ -24,6 +25,12 @@ export declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeat
      * alias to stage all and commit
      */
     addAndCommit(commitMessage: string): any;
+    /**
+     * general default development branch for all kinds of projects
+     */
+    getDefaultDevelopmentBranch(): string;
+    isUsingActionCommit(): boolean;
+    jiraIssuesAreOutsideBrackets(): boolean;
     getUserInfo(global?: boolean): Promise<{
         name?: string;
         email?: string;
@@ -43,6 +50,16 @@ export declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeat
     get uncommitedFiles(): any;
     get thereAreSomeUncommitedChange(): any;
     thereAreSomeUncommitedChangeExcept(filesList?: string[]): any;
+    /**
+     * Resolve last changes
+     * - uncommited changes
+     * - action commits to melt
+     */
+    resolveLastChanges(options?: {
+        tryAutomaticActionFirst?: boolean;
+        projectNameAsOutputPrefix?: string;
+    }): Promise<void>;
+    get hasActionCommitsToMelt(): boolean;
     meltActionCommits(): void;
     pullCurrentBranch(options?: {
         askToRetry?: boolean;
@@ -81,8 +98,13 @@ export declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeat
     lastTagNameForMajorVersion(majorVersion: any): any;
     lastTagHash(): any;
     get remoteOriginUrl(): any;
+    /**
+     * get provider of remote origin
+     */
+    get remoteProvider(): string;
     get lastTagVersionName(): any;
     get stagedFiles(): string[];
+    get stagedFilesRelativePaths(): string[];
     /**
      * TODO does this make any sense
      */
@@ -147,4 +169,11 @@ export declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeat
      */
     getChangedFilesInCommitByIndex(index: number): Promise<any>;
     changesSummary(): Promise<any>;
+    /**
+     * If true command navi reset will reset project
+     * and its children.
+     *
+     * If false command navi reset will reset only project.
+     */
+    resetIsRestingAlsoChildren(): boolean;
 }

package/websql/lib/base/classes/base-json-file-reader.d.ts

@@ -0,0 +1,72 @@
+// @ts-nocheck
+export interface BaseJsonFileReaderOptions<DATA> {
+    /**
+     * cwd for <my-json>.json
+     * <cwd>/<my-json>
+     * (you can also provide full path - basename will be cut)
+     */
+    cwd?: string;
+    /**
+     * file name
+     * example: package.json, taon.json etc.
+     */
+    fileName?: string;
+    /**
+     * json content to read from memory
+     */
+    jsonContent?: Partial<DATA>;
+    /**
+     * callback for external reload
+     */
+    reloadInMemoryCallback?: (data: DATA) => void;
+    /**
+     * use json with comments reader to read json file
+     */
+    readJsonAsJsonWithComments?: boolean;
+    /**
+     * default value for data
+     * if file not exist
+     * (ONLY FOR cwd + fileName mode)
+     */
+    defaultValue?: Partial<DATA>;
+}
+/**
+ * Base class for reading json files
+ * There are 2 modes of reading json files:
+ * - cwd + fileName (read and write to disk in cwd)
+ * - jsonContent (read and write to memory and use
+ *   reloadInMemoryCallback for external reload)
+ */
+export declare class BaseJsonFileReader<DATA> {
+    /**
+     * null when package.json not exist
+     */
+    protected data: DATA | null;
+    /**
+     * use json with comments reader to read package.json
+     */
+    protected readonly readJsonAsJsonWithComments: boolean;
+    readonly cwd: string;
+    protected readonly fileName: string;
+    /**
+     * @deprecated
+     * use only when cwd and fileName are not provided
+     */
+    protected readonly jsonContent?: Partial<DATA>;
+    protected readonly defaultValue?: Partial<DATA>;
+    protected readonly reloadInMemoryCallback?: (data: DATA) => void;
+    constructor(options: BaseJsonFileReaderOptions<DATA>);
+    /**
+     * cwd + fileName
+     */
+    get path(): string;
+    /**
+     * if something else change package.json in this project
+     * and you know that you need to reload it..
+     */
+    reloadPackageJsonInMemory(): void;
+    saveToDisk(purpose?: string): any;
+    linkTo(destination: string): void;
+    getAllData(): DATA;
+    setAllData(data: DATA): void;
+}

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

@@ -1,13 +1,13 @@
 // @ts-nocheck
-import { BaseFeatureForProject } from './base-feature-for-project';
 import { LibrariesBuildOptions, LibraryBuildCommandOptions } from '../../models';
+import { BaseFeatureForProject } from './base-feature-for-project';
 import type { BaseProject } from './base-project';
 /**
  * Base library build for standard angular/typescript projects
  */
-export declare abstract class BaseLibraryBuild<PROJECT extends BaseProject<BaseProject, any>> extends BaseFeatureForProject {
+export declare abstract class BaseLibraryBuild<PROJECT extends BaseProject<BaseProject, any>> extends BaseFeatureForProject<PROJECT> {
     private cache;
-    private tempOrgTsConfigFile;
+    protected readonly tempOrgTsConfigFile: string;
     protected sortByDeps(libraries: PROJECT[]): PROJECT[];
     /**
      * Use cases:
@@ -53,10 +53,10 @@ export declare abstract class BaseLibraryBuild<PROJECT extends BaseProject<BaseP
         strategy: 'link' | 'copy';
         outputLineReplace?: (outputLine: string) => string;
     }): Promise<any>;
-    getLibraryBuildComamnd(options?: LibraryBuildCommandOptions): string | undefined;
+    getLibraryBuildCommand(options?: LibraryBuildCommandOptions): string | undefined;
     get getLibraryBuildSuccessComamnds(): string[];
     selectCopytoProjects(): Promise<string[]>;
     private changeTsConfigForLibrariesTypes;
-    private replaceTsConfigsPathes;
+    protected replaceTsConfigsPathes(): Promise<any>;
     private restoreOriginalTsConfig;
 }

package/websql/lib/base/classes/base-linked-projects.d.ts

@@ -2,9 +2,8 @@
 import { LinkedPorjectsConfig, LinkedProject } from '../../index';
 import { BaseFeatureForProject } from './base-feature-for-project';
 import type { BaseProject } from './base-project';
-export declare class BaseLinkedProjects<PROJECT extends BaseProject = any> extends BaseFeatureForProject {
+export declare class BaseLinkedProjects<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
     private cache;
-    project: PROJECT;
     get embeddedProject(): PROJECT;
     get projectsDbLocation(): any;
     saveLocationToDB(): Promise<any>;

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

@@ -0,0 +1,56 @@
+// @ts-nocheck
+import { CoreModels } from 'tnp-core/websql';
+import type { BaseNpmHelpers } from '../../../lib';
+import type { BaseProject } from './base-project';
+export declare class BaseNodeModules<NPM_HELPERS extends BaseNpmHelpers = BaseNpmHelpers> {
+    /**
+     * my-path/node_modules
+     */
+    protected cwd: string;
+    protected npmHelpers: NPM_HELPERS;
+    protected _npmHelpersType: NPM_HELPERS;
+    constructor(
+    /**
+     * my-path/node_modules
+     */
+    cwd: string, npmHelpers: NPM_HELPERS);
+    /**
+     * cwd + node_modules
+     */
+    get path(): string;
+    /**
+     * Path to package inside node_modules folder
+     * @example <project-path>/node_modules/<package-name>
+     */
+    pathFor(packageName: string): string;
+    /**
+     * real path of node_modules
+     * if node_modules is a link
+     * it will return real path.
+     * if node_modules is folder = path
+     */
+    get realPath(): string;
+    protected preventWrongLinkDestination(dest: string): string;
+    linkToProject(project: Partial<BaseProject>): any;
+    linkToLocation(location: string): void;
+    makeSureInstalled(options?: Omit<CoreModels.NpmInstallOptions, 'pkg'>): Promise<void>;
+    remove(options?: {
+        skipQuestion?: boolean;
+    }): Promise<void>;
+    removePackage(packageInside: string): void;
+    reinstall(options?: Omit<CoreModels.NpmInstallOptions, 'pkg'>): Promise<any>;
+    get isLink(): boolean;
+    get empty(): any;
+    /**
+     * @returns true if node_modules folder is empty
+     * DEEP CHECK - also if node_modules is a link
+     * and is not existent
+     */
+    isEmpty(): any;
+    /**
+     *  Prepare command for npm install
+     * (or yarn install)
+     */
+    prepareCommand(options?: CoreModels.NpmInstallOptions): Promise<string>;
+    dedupePackages(packagesNames?: string[], countOnly?: boolean, warnings?: boolean): void;
+}

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

@@ -1,114 +1,22 @@
 // @ts-nocheck
+import { CoreModels } from 'tnp-core/websql';
+import { BaseBowerJson } from './base-bower-json';
 import { BaseFeatureForProject } from './base-feature-for-project';
+import { BaseNodeModules } from './base-node-modules';
+import { BasePackageJson } from './base-package-json';
 import type { BaseProject } from './base-project';
-import { PackageJson } from 'type-fest';
-import { CoreModels } from 'tnp-core/websql';
-export declare class BaseNpmHelpers<PROJECT extends BaseProject = any> extends BaseFeatureForProject {
-    private packageJSON;
-    private bowerJson;
+export declare class BaseNpmHelpers<PROJECT extends BaseProject = BaseProject> extends BaseFeatureForProject<PROJECT> {
+    readonly packageJson: BasePackageJson;
+    readonly _packageJsonType: typeof BasePackageJson;
+    private readonly _packageJsonTypeOriginal;
+    readonly nodeModules: BaseNodeModules;
+    readonly _nodeModulesType: typeof BaseNodeModules;
+    private readonly __nodeModulesTypeOriginal;
+    readonly bowerJson: BaseBowerJson;
     constructor(project: PROJECT);
-    updateDepsFrom(locations: string[]): any;
-    /**
-     * if something else change package.json in this project
-     * and you know that you need to reload it..
-     */
-    reloadPackageJsonInMemory(): void;
-    get name(): string;
-    /**
-     * version from package.json -> property version
-     */
-    get version(): string;
-    /**
-     * bin with cli config from package.json
-     */
-    get bin(): {
-        [cliName: string]: string;
-    };
-    set version(newVersion: string);
-    /**
-     * @deprecated use updateDep
-     */
-    updateDependency({ packageName, version, updateTaonJsonFirst, }: {
-        packageName: string;
-        version: string | null;
-        updateTaonJsonFirst?: boolean;
-    }): void;
-    /**
-     * Update dependency in package.json
-     */
-    updateDep({ packageName, version, updateTaonJsonFirst, addIfNotExists, }: {
-        packageName: string;
-        version: string | null;
-        updateTaonJsonFirst?: boolean;
-        addIfNotExists?: boolean;
-    }): Promise<void>;
-    get versionWithPatchPlusOne(): string;
-    get versionWithMinorPlusOneAndPatchZero(): string;
-    get versionWithMajorPlusOneAndMinorZeroAndPatchZero(): string;
-    /**
-     * Major Version from package.json
-     */
-    get majorVersion(): number;
-    /**
-     * Minor Version from package.json
-     */
-    get minorVersion(): number;
-    /**
-     * @deprecated
-     */
-    bumpPatchVersion(): Promise<any>;
-    get versionPathAsNumber(): number;
-    /**
-     * npm dependencies from package.json
-     */
-    get dependencies(): Partial<Record<string, string>>;
-    get bowerDependencies(): Partial<Record<string, string>>;
-    /**
-     * peerDependencies dependencies
-     */
-    get peerDependencies(): Partial<Record<string, string>>;
-    /**
-     * devDependencies dependencies
-     */
-    get devDependencies(): Partial<Record<string, string>>;
-    /**
-     * resolutions dependencies
-     */
-    get resolutions(): Partial<Record<string, string>>;
-    /**
-     * @returns object witl all deps from current project package json
-     */
-    get allDependencies(): {
-        [packageName: string]: string;
-    };
-    /**
-     * @returns object witl all deps from package json
-     */
-    allDepsFromPackageJson(packageJson: PackageJson): any;
-    linkNodeModulesTo(proj: Partial<BaseProject>): any;
     preferYarnOverNpm(): boolean;
-    makeSureNodeModulesInstalled(options?: Omit<CoreModels.NpmInstallOptions, 'pkg'>): Promise<void>;
-    deleteNodeModules(): void;
-    reinstallNodeModules(options?: Omit<CoreModels.NpmInstallOptions, 'pkg'>): Promise<any>;
-    /**
-     * @returns true if node_modules folder is empty
-     */
-    get emptyNodeModules(): any;
     resetPackageLockJson(): Promise<any>;
-    startNpmTask(taskName: string, additionalArguments?: string | object): {
-        sync(): any;
-        async(detach?: boolean, mockFun?: (stdoutCallback: (dataForStdout: any) => any, stdErrcCallback: (dataForStder: any) => any, shouldProcesBeDead?: () => boolean) => Promise<number> | number): import("child_process").ChildProcess;
-        asyncAsPromise(): Promise<void>;
-        unitlOutput(optionsOutput: {
-            stdoutMsg: string | string[];
-            stderMsg?: string | string[];
-            timeout?: number;
-            stdoutOutputContainsCallback?: () => any;
-            outputLineReplace?: (outputLine: string) => string;
-        }): Promise<void>;
-        unitlOutputContains(stdoutMsg: string | string[], stderMsg?: string | string[], timeout?: number, stdoutOutputContainsCallback?: () => any): any;
-    };
-    prepareCommand(options?: CoreModels.NpmInstallOptions): Promise<string>;
+    startNpmTask(taskName: string, additionalArguments?: string | object): any;
     /**
      *
      * @param registry without specified registr is checking npm registry
@@ -122,9 +30,20 @@ export declare class BaseNpmHelpers<PROJECT extends BaseProject = any> extends B
      */
     loginToRegistry(registry?: string): Promise<void>;
     makeSureLoggedInToNpmRegistry(registry?: string): Promise<void>;
-    /**
-     * @deprecated
-     * use makeSureLoggedInToNpmRegistry()
-     */
-    checkIfLogginInToNpm(): any;
+    shouldReleaseMessage(options: {
+        releaseVersionBumpType: CoreModels.ReleaseVersionType;
+        versionToUse?: string;
+        children?: BaseProject[];
+        whatToRelease: {
+            itself: boolean;
+            children: boolean;
+        };
+        skipQuestionToUser?: boolean;
+    }): Promise<boolean>;
+    /**
+     * @param registry when not specified, it will use the default npm registry
+     */
+    publishToNpmRegistry(options?: {
+        registry?: string;
+    }): Promise<void>;
 }

package/websql/lib/base/classes/base-package-json.d.ts

@@ -0,0 +1,107 @@
+// @ts-nocheck
+import { CoreModels } from 'tnp-core/websql';
+import { PackageJson as PackageJsonBase } from 'type-fest';
+import { BaseJsonFileReader, BaseJsonFileReaderOptions } from './base-json-file-reader';
+type PackageJson = PackageJsonBase & {
+    lastBuildTagHash: string;
+};
+export type PackageJsonDependencyObj = 'dependencies' | 'devDependencies' | 'peerDependencies' | 'resolutions';
+export declare const PackageJsonDependencyObjArr: PackageJsonDependencyObj[];
+export declare class BasePackageJson extends BaseJsonFileReader<PackageJson> {
+    constructor(options: Omit<BaseJsonFileReaderOptions<PackageJson>, 'fileName'>);
+    /**
+     * 'dependencies'
+     * 'devDependencies'
+     * 'peerDependencies'
+     * 'resolutions';
+     * and whatever is in package.json to npm install
+     */
+    get dependenciesTypesArray(): PackageJsonDependencyObj[];
+    get name(): string;
+    setName(name: string): Promise<void>;
+    /**
+     * devDependencies dependencies
+     */
+    get devDependencies(): PackageJson['devDependencies'];
+    /**
+     * resolutions dependencies
+     */
+    get resolutions(): PackageJson['resolutions'];
+    /**
+     * npm dependencies from package.json
+     */
+    get dependencies(): PackageJson['dependencies'];
+    /**
+     * set the WHOLE dependencies object
+     * THIS WILL NOT MERGE -> IT WILL REPLACE WHOLE DEPENDENCIES OBJECT
+     */
+    setDependencies(dependencies: PackageJson['dependencies']): void;
+    /**
+     * set the WHOLE dependencies object
+     * THIS WILL NOT MERGE -> IT WILL REPLACE WHOLE DEPENDENCIES OBJECT
+     */
+    setDevDependencies(devDependencies: PackageJson['devDependencies']): void;
+    /**
+     * peerDependencies dependencies
+     */
+    get peerDependencies(): PackageJson['peerDependencies'];
+    /**
+     * set the WHOLE peerDependencies object
+     * THIS WILL NOT MERGE -> IT WILL REPLACE WHOLE PEER DEPENDENCIES OBJECT
+     */
+    setPeerDependencies(peerDependencies: PackageJson['peerDependencies']): void;
+    removeDevDependencies(): void;
+    /**
+     * @returns object witl all deps from current project package json
+     */
+    get allDependencies(): {
+        [packageName: string]: string;
+    };
+    /**
+     * @returns object witl all deps from package json
+     */
+    protected allDepsFromPackageJson(packageJson: PackageJson): any;
+    /**
+     * version from package.json -> property version
+     */
+    get version(): string;
+    setVersion(version: string): void;
+    /**
+     * bin with cli config from package.json
+     */
+    get bin(): Partial<Record<string, string>>;
+    set bin(value: Partial<Record<string, string>>);
+    get engines(): PackageJson['engines'];
+    setEngines(engines: PackageJson['engines']): Promise<void>;
+    get homepage(): PackageJson['homepage'];
+    setHomepage(homepage: PackageJson['homepage']): Promise<void>;
+    get versionWithPatchPlusOne(): string;
+    get versionWithMinorPlusOneAndPatchZero(): string;
+    get versionWithMajorPlusOneAndMinorZeroAndPatchZero(): string;
+    get versionPathAsNumber(): number;
+    /**
+     * Major Version from package.json
+     */
+    get majorVersion(): number;
+    /**
+     * Minor Version from package.json
+     */
+    get minorVersion(): number;
+    bumpPatchVersion(): Promise<any>;
+    getVersionFor(releaseType: CoreModels.ReleaseVersionType): string;
+    updateDepsFrom(locations: string[]): any;
+    /**
+     * this will NOT SET dependency if
+     * dependency name is not in package.json
+     */
+    updateDependency({ packageName, version, }: {
+        packageName: string;
+        version: string | null;
+    }): void;
+    get isPrivate(): boolean;
+    setIsPrivate(value: boolean): any;
+    setMainProperty(main: string, purpose?: string): Promise<void>;
+    setBuildHash(hash: string): void;
+    getBuildHash(): string;
+}
+export {};

package/websql/lib/base/classes/base-process-manager.d.ts

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { CommandProcess, ProcessManagerConfig } from '../../models';
+import { BaseFeatureForProject } from './base-feature-for-project';
+import { BaseProject } from './base-project';
+export { CommandConfig } from '../../models';
+export declare class BaseProcessManger<PROJECT extends BaseProject<any, any> = BaseProject<any, any>> extends BaseFeatureForProject<PROJECT> {
+    private initialOptions;
+    private allProcesses;
+    private selectedProcesses;
+    outputBuffer: string[];
+    startedProcesses: Set<CommandProcess>;
+    watch: boolean;
+    private _showLogs;
+    set showLogs(value: boolean);
+    get showLogs(): boolean;
+    /**
+     * special config for Helpers.executer
+     */
+    hideOutput: {
+        stderr: boolean;
+        stdout: boolean;
+        acceptAllExitCodeAsSuccess: boolean;
+    };
+    constructor(project: PROJECT);
+    init<PROJECT = BaseProject<any, any>>(initialOptions: ProcessManagerConfig<PROJECT>): Promise<void>;
+    private showOutput;
+    private killOrBuildMenu;
+    makeSureSelectedProcessesAreRunning(): Promise<void>;
+    private startProcessWithDependencies;
+    private buildMenu;
+}

package/websql/lib/base/classes/base-project-resolver.d.ts

@@ -1,8 +1,8 @@
 // @ts-nocheck
 import { ConfigDatabase } from '../config-database';
 import { ProjectDatabase } from '../project-database';
-import { BaseProject } from './base-project';
 import { PortsWorker } from '../tcp-udp-ports';
+import { BaseProject } from './base-project';
 export declare class BaseProjectResolver<PROJECT extends Partial<BaseProject> = any> {
     protected readonly classFn: any;
     readonly cliToolName: string;
@@ -37,5 +37,5 @@ export declare class BaseProjectResolver<PROJECT extends Partial<BaseProject> =
     add(project: PROJECT): void;
     allProjectFrom(absoluteLocation: string, stopOnCwd?: string): any;
     allProjectsFromFolder(folderLocation: string): PROJECT[];
-    sortGroupOfProject<T extends BaseProject = BaseProject>(projects: T[], resoveDepsArray: (proj: T) => string[], projNameToCompare: (proj: T) => string): T[];
+    sortGroupOfProject<T extends BaseProject<any, any> = BaseProject<any, any>>(projects: T[], resoveDepsArray: (proj: T) => string[], projNameToCompare: (proj: T) => string): T[];
 }