tnp-helpers 18.0.15 → 18.0.17

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

@@ -18,7 +18,11 @@ export declare class BaseCliWorkerConfig {
      * (in other cases = null)
      */
     startTimestamp: number;
+    /**
+     * version
+     */
+    version: string;
+    hasBiggerOrEqualWorkerVersionThan(other: BaseCliWorkerConfig): any;
     isEquals(other: BaseCliWorkerConfig): boolean;
     get isEmpty(): boolean;
-    toString(): any;
 }

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

@@ -7,8 +7,10 @@ export declare abstract class BaseCliWorkerController<ENTITY> extends Taon.Base
      * service id
      */
     private cliWorkerServiceId;
-    baseCLiWorkerCommand_initializeMetadata(serviceId: string): Taon.Response<void>;
+    private cliWorkerServiceVersion;
+    baseCLiWorkerCommand_initializeMetadata(serviceId: string, serviceVersion: string): Taon.Response<void>;
     baseCLiWorkerCommand_kill(): Taon.Response<void>;
     info(): Taon.Response<string>;
-    baseCLiWorkerCommand_isHealthy(configWorker: BaseCliWorkerConfig): Taon.Response<boolean>;
+    baseCLiWorkerCommand_isHealthy(checkingProcessConfig: BaseCliWorkerConfig): Taon.Response<boolean>;
+    baseCLiWorkerCommand_hasUpToDateVersion(checkingProcessConfig: BaseCliWorkerConfig): Taon.Response<boolean>;
 }

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

@@ -1,7 +1,9 @@
 // @ts-nocheck
 import type { BaseCliWorkerController } from './base-cli-worker-controller';
 import { BaseCliWorkerConfig } from './base-cli-worker-config';
-export declare abstract class BaseCliWorker {
+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<any> = BaseCliWorkerController<any>> {
     /**
      * unique id for service
      */
@@ -10,6 +12,10 @@ export declare abstract class BaseCliWorker {
      * external command that will start service
      */
     protected readonly startCommand: string;
+    /**
+     * unique id for service
+     */
+    protected readonly serviceVersion: string;
     constructor(
     /**
      * unique id for service
@@ -18,27 +24,57 @@ export declare abstract class BaseCliWorker {
     /**
      * external command that will start service
      */
-    startCommand: string);
-    protected abstract startNormallyInCurrentProcess(): any;
-    protected abstract getControllerForRemoteConnection(): Promise<BaseCliWorkerController<any>>;
-    private get pathToProcessLocalInfoJson();
+    startCommand: string, 
+    /**
+     * unique id for service
+     */
+    serviceVersion: string);
+    protected abstract startNormallyInCurrentProcess(options?: {}): any;
+    abstract getControllerForRemoteConnection(): Promise<REMOTE_CTRL>;
+    protected get pathToProcessLocalInfoJson(): string;
     protected get processLocalInfoObj(): BaseCliWorkerConfig;
     startDetachedIfNeedsToBeStarted(): Promise<any>;
     /**
      * stop if started
      */
-    kill(): Promise<void>;
+    kill(options?: {
+        dontRemoveConfigFile?: boolean;
+    }): Promise<any>;
     /**
      * kill detached process and start again
+     * @param options.detached - default true
      */
-    restart(): Promise<void>;
-    protected isServiceHealthy(options?: {
+    restart(options?: {
+        detached?: boolean;
+    }): Promise<void>;
+    /**
+     * only for cli start
+     * @param cliParams on from cli
+     */
+    cliStartProcedure(cliParams: any): Promise<any>;
+    protected preventExternalConfigChange(): any;
+    protected preventStartIfAlreadyStarted(): Promise<any>;
+    protected killWorkerWithLowerVersion(): Promise<any>;
+    /**
+     * This has 2 purposes:
+     * - infinite check when when detached process finished starting
+     * - quick check if service is healthy / already started
+     */
+    protected isServiceHealthy(options: {
         healthCheckRequestTrys?: number;
     }): Promise<boolean>;
     /**
      * start if not started detached process
      */
     protected startDetached(): Promise<any>;
+    protected headerText(): Promise<string>;
+    protected textHeaderStyle(): CfontStyle;
+    protected headerTextAlign(): CfontAlign;
+    /**
+     * override whole terminal header
+     */
+    protected header(): Promise<void>;
+    infoMessageBelowHeader(): Promise<void>;
     protected _infoScreen(): Promise<void>;
     private saveProcessInfo;
     protected initializeWorkerMetadata(): Promise<any>;

package/browser/lib/base/base-compiler-for-project.d.ts

@@ -2,5 +2,7 @@
 import { IncCompiler } from 'incremental-compiler/browser';
 import { BaseProject } from './base-project';
 export declare abstract class BaseCompilerForProject<ADDITIONAL_DATA = any, PROJECT extends BaseProject = BaseProject> extends IncCompiler.Base<ADDITIONAL_DATA> {
+    project: PROJECT;
     protected checkFolderCompiler(project: PROJECT, options: IncCompiler.Models.BaseClientCompilerOptions, dontCheck?: boolean): any;
+    constructor(project: PROJECT, options?: IncCompiler.Models.BaseClientCompilerOptions, allowFolderOutSideProject?: boolean);
 }

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

@@ -4,6 +4,10 @@ import { BaseCompilerForProject } from './base-compiler-for-project';
 import { ChangeOfFile } from 'incremental-compiler/browser';
 export declare abstract class BaseDebounceCompilerForProject<ADDITIONAL_DATA = any, PROJECT extends BaseProject = BaseProject> extends BaseCompilerForProject<ADDITIONAL_DATA, PROJECT> {
     protected initalParams: ADDITIONAL_DATA;
+    /**
+     * default debounce time is 1s
+     */
+    protected debounceTime: number;
     abstract action({ changeOfFiles, asyncEvent, }: {
         changeOfFiles: ChangeOfFile[];
         asyncEvent: boolean;

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

@@ -94,7 +94,7 @@ export declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeat
     /**
      * usefull when pushing in project with childrens as git repos
      */
-    automaticallyAddAllChnagesWhenPushingToGit(): boolean;
+    automaticallyAddAllChangesWhenPushingToGit(): boolean;
     /**
      * usefull when pushing in project with childrens as git repos
      */
@@ -117,8 +117,8 @@ export declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeat
     }): Promise<void>;
     pushProcess(options?: PushProcessOptions): Promise<void>;
     _beforeAnyActionOnGitRoot(): any;
-    protected _beforePushProcessAction(): Promise<any>;
-    protected _beforePullProcessAction(cloneChildren?: boolean): Promise<any>;
+    protected _beforePushProcessAction(setOrigin: 'ssh' | 'http'): Promise<any>;
+    protected _beforePullProcessAction(setOrigin: 'ssh' | 'http', cloneChildren?: boolean): Promise<any>;
     protected _getCommitMessage(typeOfCommit: TypeOfCommit, args: string[], commitMessageRequired?: boolean, 
     /**
      * only needed when push github

package/browser/lib/base/base-github-pages.d.ts

@@ -0,0 +1,15 @@
+// @ts-nocheck
+import { BaseFeatureForProject } from './base-feature-for-project';
+import type { BaseProject } from './base-project';
+/**
+ * Easy way to create github pages
+ * (or similar static site hosting)
+ */
+export declare class BaseGithubPages<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
+    readonly TMP_GH_PAGE_SITE_REPOS = "tmp-gh-pages-sites-repos";
+    protected cleanFolderForGhPages(pathToBranchRepoFolder: string): Promise<any>;
+    protected get mainFolder(): any;
+    get mainFolderAbsPath(): any;
+    get pagesBranchName(): string;
+    init(mainFolder: string, completeProcess?: boolean): Promise<any>;
+}

package/browser/lib/base/base-linked-projects.d.ts

@@ -13,11 +13,12 @@ export declare class BaseLinkedProjects<PROJECT extends BaseProject = any> exten
     addLinkedProjects(linkedProjs: LinkedProject[]): any;
     setLinkedProjectsConfig(linkedPorjectsConfig: Partial<LinkedPorjectsConfig>): any;
     private get linkedProjectsConfigPath();
+    private get linkedProjectsConfigTempPath();
     protected recreateLinkedProjectsConfig(): any;
     getLinkedProjectsConfig(): LinkedPorjectsConfig;
     get linkedProjects(): LinkedProject[];
     get detectedLinkedProjects(): LinkedProject[];
     get linkedProjectsPrefix(): string;
     resetLinkedProjectsOnlyToCoreBranches(): boolean;
-    cloneUnexistedLinkedProjects(actionType: 'pull' | 'push', cloneChildren?: boolean): Promise<any>;
+    cloneUnexistedLinkedProjects(actionType: 'pull' | 'push', setOrigin: 'ssh' | 'http', cloneChildren?: boolean): Promise<any>;
 }

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

@@ -4,8 +4,8 @@ import { ProjectDatabase } from './project-database';
 import { BaseProject } from './base-project';
 import { PortsWorker } from './ports-worker';
 export declare class BaseProjectResolver<PROJECT extends Partial<BaseProject> = any> {
-    protected classFn: any;
-    cliToolName: string;
+    protected readonly classFn: any;
+    readonly cliToolName: string;
     configDb: ConfigDatabase;
     projectsDb: ProjectDatabase;
     readonly portsWorker: PortsWorker;

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

@@ -10,6 +10,7 @@ import { BaseGit } from './base-git';
 import { BaseVscodeHelpers } from './base-vscode';
 import { BaseReleaseProcess } from './base-release-process';
 import { BaseQuickFixes } from './base-quick-fixes';
+import { BaseGithubPages } from './base-github-pages';
 export declare abstract class BaseProject<PROJECT extends BaseProject = BaseProject<any, any>, TYPE = BaseProjectType> {
     static ins: BaseProjectResolver<BaseProject<BaseProject<any, any>, CoreModels.BaseProjectType>>;
     cache: any;
@@ -32,6 +33,7 @@ export declare abstract class BaseProject<PROJECT extends BaseProject = BaseProj
     releaseProcess?: BaseReleaseProcess;
     git?: BaseGit;
     quickFixes?: BaseQuickFixes;
+    githubPages?: BaseGithubPages;
     private __location;
     get location(): string;
     set location(v: string);
@@ -51,6 +53,10 @@ export declare abstract class BaseProject<PROJECT extends BaseProject = BaseProj
      * project folder basename
      */
     get basename(): string;
+    /**
+     * project folder parent basename
+     */
+    get parentBasename(): string;
     /**
      * name from package.json
      */
@@ -80,6 +86,9 @@ export declare abstract class BaseProject<PROJECT extends BaseProject = BaseProj
      */
     hasFile(relativePath: string | string[]): boolean;
     hasFolder(relativePath: string | string[]): boolean;
+    /**
+     * Function will return relative path from project location
+     */
     relative(absoultePath: string): string;
     /**
      *
@@ -89,6 +98,8 @@ export declare abstract class BaseProject<PROJECT extends BaseProject = BaseProj
     createFolder(relativePath: string | string[], options?: {
         override?: boolean;
     }): any;
+    formatFile(specificRelativePath: string | string[]): any;
+    formatAllFiles(): any;
     /**
      * same as project.pathhasFileExists();
      * but with path.resolve
@@ -151,6 +162,10 @@ export declare abstract class BaseProject<PROJECT extends BaseProject = BaseProj
     };
     remove(relativePath: string | string[], exactPath?: boolean): any;
     removeFolderByRelativePath(relativePathToFolder: string): void;
+    registerAndAssignPort(): Promise<number>;
+    /**
+     * @deprecated
+     */
     assignFreePort(startFrom?: number, howManyFreePortsAfterThatPort?: number): Promise<number>;
     removeItself(): void;
     /**

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

@@ -11,6 +11,9 @@ export * from './base-release-process';
 export * from './base-compiler-for-project';
 export * from './base-debounce-compiler-for-project';
 export * from './base-quick-fixes';
+export * from './base-cli-worker-controller';
+export * from './base-cli-worker';
+export * from './base-cli-worker-config';
 export * from './commit-data';
 export * from './core-project';
 export * from './linked-project';

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

@@ -24,6 +24,7 @@ export declare class LinkedProject {
      * url for git repo
      */
     remoteUrl(): string;
+    remoteUrlTransformed(setOrigin: 'ssh' | 'http'): string;
     deafultBranch?: string;
     purpose?: string;
     relativeClonePath?: string;

package/browser/lib/base/ports-worker.d.ts

@@ -1,11 +1,33 @@
 // @ts-nocheck
-import { BaseCliWorker } from './base-cli-worker';
+import { BaseCliWorker, CfontStyle } from './base-cli-worker';
+import { Taon } from 'taon/browser';
 import { BaseCliWorkerController } from './base-cli-worker-controller';
-export declare class PortsWorker extends BaseCliWorker {
-    protected getControllerForRemoteConnection(): Promise<BaseCliWorkerController<any>>;
+declare class Port extends Taon.Base.Entity {
+    static from(opt: Omit<Port, 'version' | '_' | 'clone'>): Port & Omit<Port, "_" | "version" | "clone">;
+    port: number;
+    assigned: boolean;
+    serviceId: string;
+}
+declare class PortsController extends BaseCliWorkerController<Port> {
+    entityClassResolveFn: () => typeof Port;
+    private portsCacheByServiceId;
+    /**
+     * @param uniqueServiceName unique service name
+     * @param startFrom start searching for free port from this number
+     * @returns
+     */
+    registerAndAssignPort(uniqueServiceName: string, startFrom?: string): Taon.Response<Port>;
+    initExampleDbData(): Promise<void>;
+}
+export declare class PortsWorker extends BaseCliWorker<PortsController> {
+    private portsController;
+    getControllerForRemoteConnection(): Promise<PortsController>;
+    protected headerText(): Promise<string>;
+    protected textHeaderStyle(): CfontStyle;
     /**
      * start normally process
      * this will crash if process already started
      */
     startNormallyInCurrentProcess(): Promise<any>;
-}
+}
+export {};

package/browser/lib/utils.d.ts

@@ -41,6 +41,12 @@ export declare namespace UtilsTerminal {
         autocomplete?: boolean;
         defaultSelected?: string;
     }) => Promise<T>;
+    const input: ({ defaultValue, question, required, }: {
+        defaultValue?: string;
+        question: string;
+        required?: boolean;
+        validate?: (value: string) => boolean;
+    }) => Promise<string>;
 }
 export declare namespace UtilsTypescript {
     /**
@@ -58,6 +64,12 @@ export declare namespace UtilsTypescript {
         type: "class" | "function" | "const" | "let" | "var" | "enum" | "type" | "interface" | "default" | "module" | "namespace";
         name: string;
     }[];
+    const extractDefaultClassNameFromString: (sourceCode: string) => string | undefined;
+    const extractClassNameFromString: (sourceCode: string) => string[];
+    const extractClassNamesFromFile: (absoluteFilePath: string) => string[];
+    const extractDefaultClassNameFromFile: (absoluteFilePath: string) => any;
+    const formatFile: (absPathToFile: string) => void;
+    const formatAllFilesInsideFolder: (absPathToFolder: string) => void;
 }
 export declare namespace UtilsHttp {
     const startHttpServer: (cwd: string, port: number) => Promise<any>;

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

@@ -1,10 +1,27 @@
 import { _ } from 'tnp-core/browser';
 /* */
 /* */
+/* */
 export class BaseCliWorkerConfig {
     static from(opt) {
         return _.merge(new BaseCliWorkerConfig(), opt);
     }
+    hasBiggerOrEqualWorkerVersionThan(other) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
     isEquals(other) {
         other = BaseCliWorkerConfig.from(other);
         return (!!this.serviceID &&
@@ -17,17 +34,7 @@ export class BaseCliWorkerConfig {
     get isEmpty() {
         return !this.serviceID && !this.port && !this.pid;
     }
-    toString() {
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        return (void 0);
-    }
 }
 ;
 ({}); // @--end-of-file-for-module=tnp-helpers lib/base/base-cli-worker-config.ts
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -9,8 +9,10 @@ let BaseCliWorkerController = class BaseCliWorkerController extends Taon.Base
          * service id
          */
         this.cliWorkerServiceId = null;
+        this.cliWorkerServiceVersion = null;
     }
-    baseCLiWorkerCommand_initializeMetadata(serviceId) {
+    baseCLiWorkerCommand_initializeMetadata(serviceId, serviceVersion) {
+        /* */
         /* */
         /* */
         /* */
@@ -25,16 +27,44 @@ let BaseCliWorkerController = class BaseCliWorkerController extends Taon.Base
         /* */
         /* */
         /* */
+        /* */
         return (void 0);
     }
     info() {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        return (void 0);
+    }
+    baseCLiWorkerCommand_isHealthy(checkingProcessConfig) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
         /* */
         /* */
         /* */
         /* */
         return (void 0);
     }
-    baseCLiWorkerCommand_isHealthy(configWorker) {
+    baseCLiWorkerCommand_hasUpToDateVersion(checkingProcessConfig) {
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
         /* */
         /* */
         /* */
@@ -51,8 +81,9 @@ let BaseCliWorkerController = class BaseCliWorkerController extends Taon.Base
 __decorate([
     Taon.Http.PUT(),
     __param(0, Taon.Http.Param.Body('serviceId')),
+    __param(1, Taon.Http.Param.Body('serviceVersion')),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
+    __metadata("design:paramtypes", [String, String]),
     __metadata("design:returntype", Object)
 ], BaseCliWorkerController.prototype, "baseCLiWorkerCommand_initializeMetadata", null);
 __decorate([
@@ -76,6 +107,13 @@ __decorate([
     __metadata("design:paramtypes", [BaseCliWorkerConfig]),
     __metadata("design:returntype", Object)
 ], BaseCliWorkerController.prototype, "baseCLiWorkerCommand_isHealthy", null);
+__decorate([
+    Taon.Http.POST(),
+    __param(0, Taon.Http.Param.Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [BaseCliWorkerConfig]),
+    __metadata("design:returntype", Object)
+], BaseCliWorkerController.prototype, "baseCLiWorkerCommand_hasUpToDateVersion", null);
 BaseCliWorkerController = __decorate([
     Taon.Controller({
         className: 'BaseCliWorkerController',
@@ -84,4 +122,4 @@ BaseCliWorkerController = __decorate([
 export { BaseCliWorkerController };
 ;
 ({}); // @--end-of-file-for-module=tnp-helpers lib/base/base-cli-worker-controller.ts
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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