tnp-helpers 18.0.20 → 18.0.21

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

@@ -1,17 +1,17 @@
 // @ts-nocheck
 import { CoreModels } from 'tnp-core/websql';
 import { CoreProject } from '../../index';
-import { BaseProjectResolver } from './base-project-resolver';
 import { BaseProjectType } from '../../models';
+import { BaseGit } from './base-git';
 import type { BaseLibraryBuild } from './base-library-build';
-import { BaseNpmHelpers } from './base-npm-helpers';
 import { BaseLinkedProjects } from './base-linked-projects';
-import { BaseGit } from './base-git';
-import { BaseVscodeHelpers } from './base-vscode';
-import { BaseReleaseProcess } from './base-release-process';
+import { BaseNpmHelpers } from './base-npm-helpers';
+import { BaseProjectResolver } from './base-project-resolver';
 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> {
+import { BaseReleaseProcess } from './base-release-process';
+import { BaseStaticPages } from './base-static-pages';
+import { BaseVscodeHelpers } from './base-vscode';
+export declare abstract class BaseProject<PROJECT extends BaseProject<any, any> = BaseProject<any, any>, TYPE = BaseProjectType> {
     static ins: BaseProjectResolver<BaseProject<BaseProject<any, any>, CoreModels.BaseProjectType>>;
     cache: any;
     static cache: any;
@@ -28,20 +28,22 @@ export declare abstract class BaseProject<PROJECT extends BaseProject = BaseProj
     readonly port: string;
     libraryBuild?: BaseLibraryBuild<BaseProject>;
     npmHelpers?: BaseNpmHelpers;
+    get packageJson(): import("./base-package-json").BasePackageJson;
+    get nodeModules(): import("./base-node-modules").BaseNodeModules<BaseNpmHelpers<BaseProject<BaseProject<any, any>, CoreModels.BaseProjectType>>>;
     linkedProjects?: BaseLinkedProjects;
     vsCodeHelpers?: BaseVscodeHelpers;
     releaseProcess?: BaseReleaseProcess;
     git?: BaseGit;
     quickFixes?: BaseQuickFixes;
-    githubPages?: BaseGithubPages;
+    staticPages?: BaseStaticPages;
     private __location;
     get location(): string;
     set location(v: string);
-    constructor(
     /**
-     * doesn't need to be real path -> can be link
+     * TODO move this to framework
+     * Linked projects are actual inside repo
+     * not in separated folders/git sub repos
      */
-    location: string);
     get isMonorepo(): boolean;
     protected orderCoreProjects(coreProjects: CoreProject[]): CoreProject[];
     get core(): CoreProject;
@@ -62,6 +64,7 @@ export declare abstract class BaseProject<PROJECT extends BaseProject = BaseProj
      */
     get name(): string;
     get nameForCli(): string;
+    get nameForNpmPackage(): string;
     get nameFromPomXML(): string;
     protected getFoldersForPossibleProjectChildren(): string[];
     protected getAllChildren(): any;
@@ -187,15 +190,10 @@ export declare abstract class BaseProject<PROJECT extends BaseProject = BaseProj
      * fs.copy option filter function for copying only not selected folders from project
      */
     filterDontCopy(basePathFoldersTosSkip: string[]): any;
-    /**
-     * general default development branch for all kinds of projects
-     */
-    getDefaultDevelopmentBranch(): string;
     /**
      * main/default hardcoded branches
      */
     getMainBranches(): string[];
-    isUnsingActionCommit(): boolean;
     useFeatureInBranchNameForTests(): boolean;
     resetProcess(overrideBranch?: string, recrusive?: boolean): Promise<void>;
     linkTo(destPackageLocation: string): void;

package/websql/lib/base/classes/base-quick-fixes.d.ts

@@ -1,7 +1,9 @@
 // @ts-nocheck
 import { BaseFeatureForProject } from './base-feature-for-project';
 import type { BaseProject } from './base-project';
-export declare class BaseQuickFixes<PROJECT extends BaseProject<any, any> = BaseProject<any, any>> extends BaseFeatureForProject {
+export declare class BaseQuickFixes<PROJECT extends BaseProject<any, any> = BaseProject<any, any>> extends BaseFeatureForProject<PROJECT> {
+    project: PROJECT;
     constructor(project: PROJECT);
     fixSQLLiteModuleInNodeModules(): any;
+    createDummyEmptyLibsReplacements(missingLibsNames?: string[]): any;
 }

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

@@ -1,17 +1,14 @@
 // @ts-nocheck
-import { BaseFeatureForProject } from './base-feature-for-project';
-import type { BaseProject } from './base-project';
 import { CoreModels } from 'tnp-core/websql';
 import type { ChangelogData } from '../../models';
-export declare class BaseReleaseProcess<PROJECT extends BaseProject<any, any> = any, ARTIFACT = string> extends BaseFeatureForProject {
-    project: PROJECT;
+import { BaseFeatureForProject } from './base-feature-for-project';
+import type { BaseProject } from './base-project';
+export declare class BaseReleaseProcess<PROJECT extends BaseProject<any, any> = any> extends BaseFeatureForProject<PROJECT> {
     /**
      * Automatic release process of patch plus one version
      */
     automaticRelease: boolean;
     versionType: CoreModels.ReleaseVersionType;
-    processType: CoreModels.ReleaseProcessType;
-    releaseArtifactName: ARTIFACT;
     preReleaseVersionTag: CoreModels.PreReleaseVersionTag;
     lastChangesSummary: string;
     newVersion: string;
@@ -21,13 +18,15 @@ export declare class BaseReleaseProcess<PROJECT extends BaseProject<any, any> =
     }[];
     startRelease(options?: Partial<BaseReleaseProcess<PROJECT>>): Promise<void>;
     getReleaseWords(): string[];
-    protected reinstallNodeModules(): Promise<void>;
     selectChangelogCommits(): Promise<{
         commitMessages: string;
         index: number;
     }[]>;
     private getCommitsUpToReleaseCommit;
-    protected publishToNpm(): Promise<boolean>;
+    /**
+     * @returns true if publish , faslse if just version bump
+     */
+    publishToNpm(cwdForCode?: any, automaticRelease?: boolean): Promise<boolean>;
     protected testAfterPublish(): Promise<boolean>;
     protected testBeforePublish(): Promise<boolean>;
     protected commitAndPush(): Promise<void>;
@@ -38,7 +37,7 @@ export declare class BaseReleaseProcess<PROJECT extends BaseProject<any, any> =
     get toBumpProjects(): PROJECT[];
     bumpNewVersionEverywhere(): Promise<any>;
     confirmNewVersion(): Promise<void>;
-    protected selectReleaseType(): Promise<CoreModels.ReleaseVersionType>;
+    protected selectReleaseType(versionToUseResolveFn?: (releaseVersionBumpType: CoreModels.ReleaseVersionType) => string): Promise<CoreModels.ReleaseVersionType>;
     protected commitMessageInChangelogTransformFn(message: string): Promise<string>;
     getChangelogContentToAppend(askForEveryItem: boolean): Promise<string>;
     /**

package/websql/lib/base/classes/base-static-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 BaseStaticPages<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
+    readonly TMP_STATIC_PAGE_SITE_REPOS = "tmp-static-pages-sites-repos";
+    protected cleanFolderForStaticPages(pathToBranchRepoFolder: string): Promise<any>;
+    protected get mainFolder(): any;
+    get mainFolderAbsPath(): any;
+    get pagesBranchName(): string;
+    init(mainFolder: string, completeProcess?: boolean): Promise<any>;
+}

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

@@ -1,6 +1,9 @@
 // @ts-nocheck
 import type { BaseProject } from './base-project';
 import { BaseFeatureForProject } from './base-feature-for-project';
+export interface ISettingsVscode {
+    'workbench.colorTheme': string;
+}
 export declare class BaseVscodeHelpers<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
     /**
      * settings.json relative path
@@ -21,4 +24,5 @@ export declare class BaseVscodeHelpers<PROJECT extends BaseProject = any> extend
     protected stripVersion(folderName: string): string;
     get installedExtensions(): string[];
     applyProperGlobalSettings(): Promise<void>;
+    get vscodeSettingsJson(): ISettingsVscode;
 }

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

@@ -3,6 +3,9 @@ export * from './base-project';
 export * from './base-project-resolver';
 export * from './base-feature-for-project';
 export * from './base-library-build';
+export * from './base-json-file-reader';
+export * from './base-package-json';
+export * from './base-node-modules';
 export * from './base-npm-helpers';
 export * from './base-linked-projects';
 export * from './base-git';
@@ -13,4 +16,5 @@ 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 './base-cli-worker-config';
+export * from './base-process-manager';

package/websql/lib/base/commit-data.d.ts

@@ -39,6 +39,7 @@ export declare class CommitData {
          * taon pfix proper input my-username/my-repo#344
          */
         currentOrigin?: string;
+        jiraIssuesAreOutsideBrackets?: boolean;
     }): Promise<CommitData>;
     static getFromBranch(currentBranchName: string, options?: {
         releaseWords?: string[];
@@ -50,14 +51,26 @@ export declare class CommitData {
          * taon pfix proper input my-username/my-repo#344
          */
         currentOrigin?: string;
+        jiraIssuesAreOutsideBrackets?: boolean;
     }): Promise<CommitData>;
-    static from(options: Pick<CommitData, 'message' | 'jiraNumbers' | 'typeOfCommit' | 'commitModuleName' | 'teamID' | 'issuesFromOtherProjects'>): CommitData;
+    static from(options: Pick<CommitData, 'message' | 'jiraNumbers' | 'typeOfCommit' | 'commitModuleName' | 'teamID' | 'issuesFromOtherProjects' | 'jiraIssuesAreOutsideBrackets'>): CommitData;
     private _message;
     typeOfCommit: TypeOfCommit;
     /**
      * ex. JIRA-2132 or MYJIRAREFIX-234234
      */
     jiraNumbers: string[];
+    /**
+     * if true then jira issues are outside brackets
+     * feat: proper git commands JIRA-1234
+     *
+     * by default is false
+     * feat(JIRA-1234): proper git commands
+     */
+    jiraIssuesAreOutsideBrackets: boolean;
+    /**
+     * when set -> jiraIssuesAreOutsideBrackets is true
+     */
     readonly commitModuleName: string;
     readonly teamID: string;
     private clearMessage;

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

@@ -25,7 +25,7 @@ export declare class LinkedProject {
      */
     remoteUrl(): string;
     remoteUrlTransformed(setOrigin: 'ssh' | 'http'): string;
-    deafultBranch?: string;
+    defaultBranch?: string;
     purpose?: string;
     relativeClonePath?: string;
 }

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

@@ -3,7 +3,7 @@ import { Taon } from 'taon/websql';
 export type PortStatus = 'unassigned' | 'assigned' | 'assigned-not-registered' | 'assigned-taken-by-os';
 export declare const PortStatusArr: PortStatus[];
 export declare class Port extends Taon.Base.Entity {
-    static from(opt: Omit<Port, 'version' | '_' | 'clone' | 'titleOnList'>): Port & Omit<Port, "_" | "version" | "clone" | "titleOnList">;
+    static from(opt: Omit<Port, 'version' | '_' | 'clone' | 'titleOnList'>): Port & Omit<Port, "version" | "_" | "clone" | "titleOnList">;
     static getTitleForFreePort(port: Number): string;
     get titleOnList(): string;
     port: number;

package/websql/lib/base/translate.d.ts

@@ -0,0 +1,228 @@
+// @ts-nocheck
+declare const names: {
+    readonly afar: "aa";
+    readonly abkhazian: "ab";
+    readonly afrikaans: "af";
+    readonly akan: "ak";
+    readonly albanian: "sq";
+    readonly amharic: "am";
+    readonly arabic: "ar";
+    readonly aragonese: "an";
+    readonly armenian: "hy";
+    readonly assamese: "as";
+    readonly avaric: "av";
+    readonly avestan: "ae";
+    readonly aymara: "ay";
+    readonly azerbaijani: "az";
+    readonly bashkir: "ba";
+    readonly bambara: "bm";
+    readonly basque: "eu";
+    readonly belarusian: "be";
+    readonly bengali: "bn";
+    readonly 'bihari languages': "bh";
+    readonly bislama: "bi";
+    readonly tibetan: "bo";
+    readonly bosnian: "bs";
+    readonly breton: "br";
+    readonly bulgarian: "bg";
+    readonly burmese: "my";
+    readonly catalan: "ca";
+    readonly valencian: "ca";
+    readonly czech: "cs";
+    readonly chamorro: "ch";
+    readonly chechen: "ce";
+    readonly chinese: "zh";
+    readonly 'church slavic': "cu";
+    readonly 'old slavonic': "cu";
+    readonly 'church slavonic': "cu";
+    readonly 'old bulgarian': "cu";
+    readonly 'old church slavonic': "cu";
+    readonly chuvash: "cv";
+    readonly cornish: "kw";
+    readonly corsican: "co";
+    readonly cree: "cr";
+    readonly welsh: "cy";
+    readonly danish: "da";
+    readonly german: "de";
+    readonly divehi: "dv";
+    readonly dhivehi: "dv";
+    readonly maldivian: "dv";
+    readonly dutch: "nl";
+    readonly flemish: "nl";
+    readonly dzongkha: "dz";
+    readonly greek: "el";
+    readonly english: "en";
+    readonly esperanto: "eo";
+    readonly estonian: "et";
+    readonly ewe: "ee";
+    readonly faroese: "fo";
+    readonly persian: "fa";
+    readonly fijian: "fj";
+    readonly finnish: "fi";
+    readonly french: "fr";
+    readonly 'western frisian': "fy";
+    readonly fulah: "ff";
+    readonly georgian: "ka";
+    readonly gaelic: "gd";
+    readonly 'scottish gaelic': "gd";
+    readonly irish: "ga";
+    readonly galician: "gl";
+    readonly manx: "gv";
+    readonly guarani: "gn";
+    readonly gujarati: "gu";
+    readonly haitian: "ht";
+    readonly 'haitian creole': "ht";
+    readonly hausa: "ha";
+    readonly hebrew: "he";
+    readonly herero: "hz";
+    readonly hindi: "hi";
+    readonly 'hiri motu': "ho";
+    readonly croatian: "hr";
+    readonly hungarian: "hu";
+    readonly igbo: "ig";
+    readonly icelandic: "is";
+    readonly ido: "io";
+    readonly 'sichuan yi': "ii";
+    readonly nuosu: "ii";
+    readonly inuktitut: "iu";
+    readonly interlingue: "ie";
+    readonly occidental: "ie";
+    readonly interlingua: "ia";
+    readonly indonesian: "id";
+    readonly inupiaq: "ik";
+    readonly italian: "it";
+    readonly javanese: "jv";
+    readonly japanese: "ja";
+    readonly kalaallisut: "kl";
+    readonly greenlandic: "kl";
+    readonly kannada: "kn";
+    readonly kashmiri: "ks";
+    readonly kanuri: "kr";
+    readonly kazakh: "kk";
+    readonly 'central khmer': "km";
+    readonly kikuyu: "ki";
+    readonly gikuyu: "ki";
+    readonly kinyarwanda: "rw";
+    readonly kirghiz: "ky";
+    readonly kyrgyz: "ky";
+    readonly komi: "kv";
+    readonly kongo: "kg";
+    readonly korean: "ko";
+    readonly kuanyama: "kj";
+    readonly kwanyama: "kj";
+    readonly kurdish: "ku";
+    readonly lao: "lo";
+    readonly latin: "la";
+    readonly latvian: "lv";
+    readonly limburgan: "li";
+    readonly limburger: "li";
+    readonly limburgish: "li";
+    readonly lingala: "ln";
+    readonly lithuanian: "lt";
+    readonly luxembourgish: "lb";
+    readonly letzeburgesch: "lb";
+    readonly 'luba-katanga': "lu";
+    readonly ganda: "lg";
+    readonly macedonian: "mk";
+    readonly marshallese: "mh";
+    readonly malayalam: "ml";
+    readonly maori: "mi";
+    readonly marathi: "mr";
+    readonly malay: "ms";
+    readonly malagasy: "mg";
+    readonly maltese: "mt";
+    readonly mongolian: "mn";
+    readonly nauru: "na";
+    readonly navajo: "nv";
+    readonly navaho: "nv";
+    readonly 'ndebele, south': "nr";
+    readonly 'south ndebele': "nr";
+    readonly 'ndebele, north': "nd";
+    readonly 'north ndebele': "nd";
+    readonly ndonga: "ng";
+    readonly nepali: "ne";
+    readonly 'norwegian nynorsk': "nn";
+    readonly 'nynorsk, norwegian': "nn";
+    readonly 'norwegian bokm\u00E5l': "nb";
+    readonly 'bokm\u00E5l, norwegian': "nb";
+    readonly norwegian: "no";
+    readonly chichewa: "ny";
+    readonly chewa: "ny";
+    readonly nyanja: "ny";
+    readonly occitan: "oc";
+    readonly ojibwa: "oj";
+    readonly oriya: "or";
+    readonly oromo: "om";
+    readonly ossetian: "os";
+    readonly ossetic: "os";
+    readonly panjabi: "pa";
+    readonly punjabi: "pa";
+    readonly pali: "pi";
+    readonly polish: "pl";
+    readonly portuguese: "pt";
+    readonly pushto: "ps";
+    readonly pashto: "ps";
+    readonly quechua: "qu";
+    readonly romansh: "rm";
+    readonly romanian: "ro";
+    readonly moldavian: "ro";
+    readonly moldovan: "ro";
+    readonly rundi: "rn";
+    readonly russian: "ru";
+    readonly sango: "sg";
+    readonly sanskrit: "sa";
+    readonly sinhala: "si";
+    readonly sinhalese: "si";
+    readonly slovak: "sk";
+    readonly slovenian: "sl";
+    readonly 'northern sami': "se";
+    readonly samoan: "sm";
+    readonly shona: "sn";
+    readonly sindhi: "sd";
+    readonly somali: "so";
+    readonly 'sotho, southern': "st";
+    readonly spanish: "es";
+    readonly castilian: "es";
+    readonly sardinian: "sc";
+    readonly serbian: "sr";
+    readonly swati: "ss";
+    readonly sundanese: "su";
+    readonly swahili: "sw";
+    readonly swedish: "sv";
+    readonly tahitian: "ty";
+    readonly tamil: "ta";
+    readonly tatar: "tt";
+    readonly telugu: "te";
+    readonly tajik: "tg";
+    readonly tagalog: "tl";
+    readonly thai: "th";
+    readonly tigrinya: "ti";
+    readonly tonga: "to";
+    readonly tswana: "tn";
+    readonly tsonga: "ts";
+    readonly turkmen: "tk";
+    readonly turkish: "tr";
+    readonly twi: "tw";
+    readonly uighur: "ug";
+    readonly uyghur: "ug";
+    readonly ukrainian: "uk";
+    readonly urdu: "ur";
+    readonly uzbek: "uz";
+    readonly venda: "ve";
+    readonly vietnamese: "vi";
+    readonly volapük: "vo";
+    readonly walloon: "wa";
+    readonly wolof: "wo";
+    readonly xhosa: "xh";
+    readonly yiddish: "yi";
+    readonly yoruba: "yo";
+    readonly zhuang: "za";
+    readonly chuang: "za";
+    readonly zulu: "zu";
+};
+export type LangType = (typeof names)[keyof typeof names];
+export declare const translate: (textToTranslate: string, options: {
+    to: LangType;
+    from: LangType;
+}) => string;
+export {};

package/websql/lib/helpers/helpers-array-obj.d.ts

@@ -18,6 +18,9 @@ export declare class HelpersArrayObj {
      * @deprecated use Utils.uniqArray from tnp-core
      */
     uniqArray<T = any>(array: any[], uniqueProperty?: keyof T): T[];
+    /**
+     * @deprecated use Utils.uniqArray from tnp-core
+     */
     sortKeys(obj: any): any;
     /**
      * Fuzzy search

package/websql/lib/helpers/helpers.d.ts

@@ -35,14 +35,18 @@ export declare class HelpersTaon extends CoreHelpers {
     /**
      * Bundle file with node_modules into one file
      */
-    ncc(pathToJsFile: string, outputFilePath: string, 
-    /**
-     * ! beforeWrite needs to return output
-     */
-    beforeWrite?: (options: {
-        output?: string;
-        copyToDestination?: (fileOrFolderAbsPath: string) => void;
-    }) => string): Promise<void>;
+    ncc(pathToJsFile: string, outputFilePath: string, options?: {
+        /**
+         * ! beforeWrite needs to return output
+         */
+        beforeWrite?: (options: {
+            output?: string;
+            copyToDestination?: (fileOrFolderAbsPath: string) => void;
+        }) => string;
+        additionalExternals?: string[];
+        skipRemovingElectron?: boolean;
+        skipFixingSQLlite?: boolean;
+    }): Promise<void>;
     /**
      * @deprecated
      * use Utils.uniqArray from tnp-core

package/websql/lib/models.d.ts

@@ -1,7 +1,9 @@
 // @ts-nocheck
-import * as core from 'tnp-core/websql';
+import { ChildProcess } from 'child_process';
+import { CoreModels } from 'tnp-core/websql';
 import type { BaseProject, TypeOfCommit } from './base';
-export type BaseProjectType = core.CoreModels.BaseProjectType;
+import type { BaseProcessManger } from './base/classes/base-process-manager';
+export type BaseProjectType = CoreModels.BaseProjectType;
 export declare const BaseProjectTypeArr: string[];
 /**
  * Angular project type
@@ -70,4 +72,68 @@ export interface PushProcessOptions {
     currentOrigin?: string;
     skipChildren?: boolean;
     noExit?: boolean;
+}
+export declare class CommandConfig {
+    static from(config: CommandConfig): CommandConfig;
+    private constructor();
+    name: string;
+    cmd: string;
+    headerMessageWhenActive?: string;
+    /**
+     * If true, the output will be stored in a buffer and displayed when requested.
+     * Default: true
+     */
+    useDataBuffer?: boolean;
+    /**
+     * Process that should be started
+     * before this process starts.
+     */
+    shouldBeActiveOrAlreadyBuild?: CommandConfig[];
+    goToNextCommandWhenOutput?: string | {
+        stdoutContains?: string | string[];
+        stderrContains?: string | string[];
+    };
+}
+export interface ProcessManagerConfig<PROJECT> {
+    title: string;
+    header?: string;
+    commands: CommandConfig[];
+    /**
+     * Default: false
+     * If false - after first selection of processes, it will be not possible
+     * to add new processes to build and build will be done after
+     * all processes are done.
+     */
+    watch?: boolean;
+}
+export declare enum CommandProcessState {
+    NOT_STARTED = "not-started",
+    WAITING_TO_START = "waiting-to-start",
+    RUNNING = "running",
+    FINISHED_AND_RUNNING = "finished-and-running",// only for watch mode
+    FINISHED = "finished"
+}
+export interface CommandProcessRunOptions {
+    progress?: (n: number, total: number) => void;
+    resolveNextProcess?: (currentProcess: CommandProcess) => Promise<CommandProcess>;
+    resolveWhenFinish?: boolean;
+}
+export declare class CommandProcess {
+    private project;
+    private config;
+    private manager;
+    private state;
+    readonly child_process?: ChildProcess;
+    protected get cmd(): string;
+    get name(): string;
+    get headerMessageWhenActive(): string | undefined;
+    get pid(): number | undefined;
+    get isFinished(): boolean;
+    get isRunning(): boolean;
+    get isWaitingToStart(): boolean;
+    markForStart(): void;
+    dependenciesProcesses: CommandProcess[];
+    constructor(project: BaseProject, config: CommandConfig, manager: BaseProcessManger);
+    start(options?: CommandProcessRunOptions): Promise<void>;
+    stop(): Promise<void>;
 }