tnp-core 18.0.46 → 18.0.49

package/lib/safe-types/glob.d.ts

@@ -0,0 +1,102 @@
+import events = require('events');
+import fs = require('fs');
+import { MinimatchOptions, Minimatch } from './minimatch/index';
+export declare function GLOB(pattern: string, cb: (err: Error | null, matches: string[]) => void): void;
+export declare function GLOB(pattern: string, options: GLOB.IOptions, cb: (err: Error | null, matches: string[]) => void): void;
+export declare namespace GLOB {
+    function __promisify__(pattern: string, options?: IOptions): Promise<string[]>;
+    function sync(pattern: string, options?: IOptions): string[];
+    function hasMagic(pattern: string, options?: IOptions): boolean;
+    let Glob: IGlobStatic;
+    let GlobSync: IGlobSyncStatic;
+    interface IOptions extends MinimatchOptions {
+        cwd?: string;
+        root?: string;
+        dot?: boolean;
+        nomount?: boolean;
+        mark?: boolean;
+        nosort?: boolean;
+        stat?: boolean;
+        silent?: boolean;
+        strict?: boolean;
+        cache?: {
+            [path: string]: any;
+        };
+        statCache?: {
+            [path: string]: fs.Stats;
+        };
+        symlinks?: any;
+        sync?: boolean;
+        nounique?: boolean;
+        nonull?: boolean;
+        debug?: boolean;
+        nobrace?: boolean;
+        noglobstar?: boolean;
+        noext?: boolean;
+        nocase?: boolean;
+        matchBase?: any;
+        nodir?: boolean;
+        ignore?: any;
+        follow?: boolean;
+        realpath?: boolean;
+        nonegate?: boolean;
+        nocomment?: boolean;
+        absolute?: boolean;
+        /** Deprecated. */
+        globDebug?: boolean;
+    }
+    interface IGlobStatic extends events.EventEmitter {
+        new (pattern: string, cb?: (err: Error | null, matches: string[]) => void): IGlob;
+        new (pattern: string, options: IOptions, cb?: (err: Error | null, matches: string[]) => void): IGlob;
+        prototype: IGlob;
+    }
+    interface IGlobSyncStatic {
+        new (pattern: string, options?: IOptions): IGlobBase;
+        prototype: IGlobBase;
+    }
+    interface IGlobBase {
+        minimatch: Minimatch;
+        options: IOptions;
+        aborted: boolean;
+        cache: {
+            [path: string]: any;
+        };
+        statCache: {
+            [path: string]: fs.Stats;
+        };
+        symlinks: {
+            [path: string]: boolean;
+        };
+        realpathCache: {
+            [path: string]: string;
+        };
+        found: string[];
+    }
+    interface IGlob extends IGlobBase, events.EventEmitter {
+        pause(): void;
+        resume(): void;
+        abort(): void;
+        /** Deprecated. */
+        EOF: any;
+        /** Deprecated. */
+        paused: boolean;
+        /** Deprecated. */
+        maxDepth: number;
+        /** Deprecated. */
+        maxLength: number;
+        /** Deprecated. */
+        changedCwd: boolean;
+        /** Deprecated. */
+        cwd: string;
+        /** Deprecated. */
+        root: string;
+        /** Deprecated. */
+        error: any;
+        /** Deprecated. */
+        matches: string[];
+        /** Deprecated. */
+        log(...args: any[]): void;
+        /** Deprecated. */
+        emitMatch(m: any): void;
+    }
+}

package/lib/safe-types/minimatch/assert-valid-pattern.d.ts

@@ -0,0 +1 @@
+export declare const assertValidPattern: (pattern: any) => void;

package/lib/safe-types/minimatch/ast.d.ts

@@ -0,0 +1,17 @@
+import { MinimatchOptions, MMRegExp } from './index.js';
+export type ExtglobType = '!' | '?' | '+' | '*' | '@';
+export declare class AST {
+    type: ExtglobType | null;
+    constructor(type: ExtglobType | null, parent?: AST, options?: MinimatchOptions);
+    get hasMagic(): boolean | undefined;
+    toString(): string;
+    push(...parts: (string | AST)[]): void;
+    toJSON(): any[];
+    isStart(): boolean;
+    isEnd(): boolean;
+    copyIn(part: AST | string): void;
+    clone(parent: AST): AST;
+    static fromGlob(pattern: string, options?: MinimatchOptions): AST;
+    toMMPattern(): MMRegExp | string;
+    toRegExpSource(allowDot?: boolean): [re: string, body: string, hasMagic: boolean, uflag: boolean];
+}

package/lib/safe-types/minimatch/brace-expressions.d.ts

@@ -0,0 +1,7 @@
+export type ParseClassResult = [
+    src: string,
+    uFlag: boolean,
+    consumed: number,
+    hasMagic: boolean
+];
+export declare const parseClass: (glob: string, position: number) => ParseClassResult;

package/lib/safe-types/minimatch/escape.d.ts

@@ -0,0 +1,11 @@
+import { MinimatchOptions } from './index.js';
+/**
+ * Escape all magic characters in a glob pattern.
+ *
+ * If the {@link windowsPathsNoEscape | GlobOptions.windowsPathsNoEscape}
+ * option is used, then characters are escaped by wrapping in `[]`, because
+ * a magic character wrapped in a character class can only be satisfied by
+ * that exact character.  In this mode, `\` is _not_ escaped, because it is
+ * not interpreted as a magic character, but instead as a path separator.
+ */
+export declare const escape: (s: string, { windowsPathsNoEscape, }?: Pick<MinimatchOptions, 'windowsPathsNoEscape'>) => string;

package/lib/safe-types/minimatch/index.d copy.d.ts

@@ -0,0 +1,93 @@
+import { AST } from './ast.js';
+type Platform = 'aix' | 'android' | 'darwin' | 'freebsd' | 'haiku' | 'linux' | 'openbsd' | 'sunos' | 'win32' | 'cygwin' | 'netbsd';
+export interface MinimatchOptions {
+    nobrace?: boolean;
+    nocomment?: boolean;
+    nonegate?: boolean;
+    debug?: boolean;
+    noglobstar?: boolean;
+    noext?: boolean;
+    nonull?: boolean;
+    windowsPathsNoEscape?: boolean;
+    allowWindowsEscape?: boolean;
+    partial?: boolean;
+    dot?: boolean;
+    nocase?: boolean;
+    nocaseMagicOnly?: boolean;
+    magicalBraces?: boolean;
+    matchBase?: boolean;
+    flipNegate?: boolean;
+    preserveMultipleSlashes?: boolean;
+    optimizationLevel?: number;
+    platform?: Platform;
+    windowsNoMagicRoot?: boolean;
+}
+export declare const minimatch: {
+    (p: string, pattern: string, options?: MinimatchOptions): boolean;
+    sep: Sep;
+    GLOBSTAR: typeof GLOBSTAR;
+    filter: (pattern: string, options?: MinimatchOptions) => (p: string) => boolean;
+    defaults: (def: MinimatchOptions) => typeof minimatch;
+    braceExpand: (pattern: string, options?: MinimatchOptions) => string[];
+    makeRe: (pattern: string, options?: MinimatchOptions) => false | MMRegExp;
+    match: (list: string[], pattern: string, options?: MinimatchOptions) => string[];
+    AST: typeof AST;
+    Minimatch: typeof Minimatch;
+    escape: (s: string, { windowsPathsNoEscape, }?: Pick<MinimatchOptions, "windowsPathsNoEscape">) => string;
+    unescape: (s: string, { windowsPathsNoEscape, }?: Pick<MinimatchOptions, "windowsPathsNoEscape">) => string;
+};
+type Sep = '\\' | '/';
+export declare const sep: Sep;
+export declare const GLOBSTAR: unique symbol;
+export declare const filter: (pattern: string, options?: MinimatchOptions) => (p: string) => boolean;
+export declare const defaults: (def: MinimatchOptions) => typeof minimatch;
+export declare const braceExpand: (pattern: string, options?: MinimatchOptions) => string[];
+export declare const makeRe: (pattern: string, options?: MinimatchOptions) => false | MMRegExp;
+export declare const match: (list: string[], pattern: string, options?: MinimatchOptions) => string[];
+export type MMRegExp = RegExp & {
+    _src?: string;
+    _glob?: string;
+};
+export type ParseReturnFiltered = string | MMRegExp | typeof GLOBSTAR;
+export type ParseReturn = ParseReturnFiltered | false;
+export declare class Minimatch {
+    options: MinimatchOptions;
+    set: ParseReturnFiltered[][];
+    pattern: string;
+    windowsPathsNoEscape: boolean;
+    nonegate: boolean;
+    negate: boolean;
+    comment: boolean;
+    empty: boolean;
+    preserveMultipleSlashes: boolean;
+    partial: boolean;
+    globSet: string[];
+    globParts: string[][];
+    nocase: boolean;
+    isWindows: boolean;
+    platform: Platform;
+    windowsNoMagicRoot: boolean;
+    regexp: false | null | MMRegExp;
+    constructor(pattern: string, options?: MinimatchOptions);
+    hasMagic(): boolean;
+    debug(..._: any[]): void;
+    make(): void;
+    preprocess(globParts: string[][]): string[][];
+    adjascentGlobstarOptimize(globParts: string[][]): string[][];
+    levelOneOptimize(globParts: string[][]): string[][];
+    levelTwoFileOptimize(parts: string | string[]): string[];
+    firstPhasePreProcess(globParts: string[][]): string[][];
+    secondPhasePreProcess(globParts: string[][]): string[][];
+    partsMatch(a: string[], b: string[], emptyGSMatch?: boolean): false | string[];
+    parseNegate(): void;
+    matchOne(file: string[], pattern: ParseReturn[], partial?: boolean): boolean;
+    braceExpand(): string[];
+    parse(pattern: string): ParseReturn;
+    makeRe(): false | MMRegExp;
+    slashSplit(p: string): string[];
+    match(f: string, partial?: boolean): boolean;
+    static defaults(def: MinimatchOptions): typeof Minimatch;
+}
+export { AST } from './ast.js';
+export { escape } from './escape.js';
+export { unescape } from './unescape.js';

package/lib/safe-types/minimatch/index.d.ts

@@ -0,0 +1,93 @@
+import { AST } from './ast.js';
+type Platform = 'aix' | 'android' | 'darwin' | 'freebsd' | 'haiku' | 'linux' | 'openbsd' | 'sunos' | 'win32' | 'cygwin' | 'netbsd';
+export interface MinimatchOptions {
+    nobrace?: boolean;
+    nocomment?: boolean;
+    nonegate?: boolean;
+    debug?: boolean;
+    noglobstar?: boolean;
+    noext?: boolean;
+    nonull?: boolean;
+    windowsPathsNoEscape?: boolean;
+    allowWindowsEscape?: boolean;
+    partial?: boolean;
+    dot?: boolean;
+    nocase?: boolean;
+    nocaseMagicOnly?: boolean;
+    magicalBraces?: boolean;
+    matchBase?: boolean;
+    flipNegate?: boolean;
+    preserveMultipleSlashes?: boolean;
+    optimizationLevel?: number;
+    platform?: Platform;
+    windowsNoMagicRoot?: boolean;
+}
+export declare const minimatch: {
+    (p: string, pattern: string, options?: MinimatchOptions): boolean;
+    sep: Sep;
+    GLOBSTAR: typeof GLOBSTAR;
+    filter: (pattern: string, options?: MinimatchOptions) => (p: string) => boolean;
+    defaults: (def: MinimatchOptions) => typeof minimatch;
+    braceExpand: (pattern: string, options?: MinimatchOptions) => string[];
+    makeRe: (pattern: string, options?: MinimatchOptions) => false | MMRegExp;
+    match: (list: string[], pattern: string, options?: MinimatchOptions) => string[];
+    AST: typeof AST;
+    Minimatch: typeof Minimatch;
+    escape: (s: string, { windowsPathsNoEscape, }?: Pick<MinimatchOptions, "windowsPathsNoEscape">) => string;
+    unescape: (s: string, { windowsPathsNoEscape, }?: Pick<MinimatchOptions, "windowsPathsNoEscape">) => string;
+};
+type Sep = '\\' | '/';
+export declare const sep: Sep;
+export declare const GLOBSTAR: unique symbol;
+export declare const filter: (pattern: string, options?: MinimatchOptions) => (p: string) => boolean;
+export declare const defaults: (def: MinimatchOptions) => typeof minimatch;
+export declare const braceExpand: (pattern: string, options?: MinimatchOptions) => string[];
+export declare const makeRe: (pattern: string, options?: MinimatchOptions) => false | MMRegExp;
+export declare const match: (list: string[], pattern: string, options?: MinimatchOptions) => string[];
+export type MMRegExp = RegExp & {
+    _src?: string;
+    _glob?: string;
+};
+export type ParseReturnFiltered = string | MMRegExp | typeof GLOBSTAR;
+export type ParseReturn = ParseReturnFiltered | false;
+export declare class Minimatch {
+    options: MinimatchOptions;
+    set: ParseReturnFiltered[][];
+    pattern: string;
+    windowsPathsNoEscape: boolean;
+    nonegate: boolean;
+    negate: boolean;
+    comment: boolean;
+    empty: boolean;
+    preserveMultipleSlashes: boolean;
+    partial: boolean;
+    globSet: string[];
+    globParts: string[][];
+    nocase: boolean;
+    isWindows: boolean;
+    platform: Platform;
+    windowsNoMagicRoot: boolean;
+    regexp: false | null | MMRegExp;
+    constructor(pattern: string, options?: MinimatchOptions);
+    hasMagic(): boolean;
+    debug(..._: any[]): void;
+    make(): void;
+    preprocess(globParts: string[][]): string[][];
+    adjascentGlobstarOptimize(globParts: string[][]): string[][];
+    levelOneOptimize(globParts: string[][]): string[][];
+    levelTwoFileOptimize(parts: string | string[]): string[];
+    firstPhasePreProcess(globParts: string[][]): string[][];
+    secondPhasePreProcess(globParts: string[][]): string[][];
+    partsMatch(a: string[], b: string[], emptyGSMatch?: boolean): false | string[];
+    parseNegate(): void;
+    matchOne(file: string[], pattern: ParseReturn[], partial?: boolean): boolean;
+    braceExpand(): string[];
+    parse(pattern: string): ParseReturn;
+    makeRe(): false | MMRegExp;
+    slashSplit(p: string): string[];
+    match(f: string, partial?: boolean): boolean;
+    static defaults(def: MinimatchOptions): typeof Minimatch;
+}
+export { AST } from './ast.js';
+export { escape } from './escape.js';
+export { unescape } from './unescape.js';

package/lib/safe-types/minimatch/unescapd.d.ts

@@ -0,0 +1,16 @@
+import { MinimatchOptions } from './index.js';
+/**
+ * Un-escape a string that has been escaped with {@link escape}.
+ *
+ * If the {@link windowsPathsNoEscape} option is used, then square-brace
+ * escapes are removed, but not backslash escapes.  For example, it will turn
+ * the string `'[*]'` into `*`, but it will not turn `'\\*'` into `'*'`,
+ * becuase `\` is a path separator in `windowsPathsNoEscape` mode.
+ *
+ * When `windowsPathsNoEscape` is not set, then both brace escapes and
+ * backslash escapes are removed.
+ *
+ * Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped
+ * or unescaped.
+ */
+export declare const unescape: (s: string, { windowsPathsNoEscape, }?: Pick<MinimatchOptions, 'windowsPathsNoEscape'>) => string;

package/lib/safe-types/minimatch/unescape.d.ts

@@ -0,0 +1,16 @@
+import { MinimatchOptions } from './index.js';
+/**
+ * Un-escape a string that has been escaped with {@link escape}.
+ *
+ * If the {@link windowsPathsNoEscape} option is used, then square-brace
+ * escapes are removed, but not backslash escapes.  For example, it will turn
+ * the string `'[*]'` into `*`, but it will not turn `'\\*'` into `'*'`,
+ * becuase `\` is a path separator in `windowsPathsNoEscape` mode.
+ *
+ * When `windowsPathsNoEscape` is not set, then both brace escapes and
+ * backslash escapes are removed.
+ *
+ * Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped
+ * or unescaped.
+ */
+export declare const unescape: (s: string, { windowsPathsNoEscape, }?: Pick<MinimatchOptions, 'windowsPathsNoEscape'>) => string;

package/lib/safe-types/rimraf.d.ts

@@ -0,0 +1,28 @@
+import fs = require('fs');
+import { GLOB } from './glob';
+export declare function RIMRAF(path: string, options: RIMRAF.Options, callback: (error: Error) => void): void;
+export declare function RIMRAF(path: string, callback: (error: Error) => void): void;
+export declare namespace RIMRAF {
+    function __promisify__(path: string, options?: Options): Promise<void>;
+    function sync(path: string, options?: Options): void;
+    let EMFILE_MAX: number;
+    let BUSYTRIES_MAX: number;
+    interface Options {
+        maxBusyTries?: number;
+        emfileWait?: boolean;
+        disableGlob?: boolean;
+        glob?: GLOB.IOptions | false;
+        unlink?: typeof fs.unlink;
+        chmod?: typeof fs.chmod;
+        stat?: typeof fs.stat;
+        lstat?: typeof fs.lstat;
+        rmdir?: typeof fs.rmdir;
+        readdir?: typeof fs.readdir;
+        unlinkSync?: typeof fs.unlinkSync;
+        chmodSync?: typeof fs.chmodSync;
+        statSync?: typeof fs.statSync;
+        lstatSync?: typeof fs.lstatSync;
+        rmdirSync?: typeof fs.rmdirSync;
+        readdirSync?: typeof fs.readdirSync;
+    }
+}

package/lib/utils.d.ts

@@ -1,7 +1,12 @@
-import { CoreModels } from './core-models';
 import { Blob } from 'buffer';
+import { CoreModels } from './core-models';
 export declare namespace Utils {
     export const uniqArray: <T = any>(array: any[], uniqueProperty?: keyof T) => T[];
+    /**
+     * @param anyObject
+     * @returns object with sorted keys
+     */
+    export const sortKeys: (anyObject: any) => any;
     /**
      * Example:
      * new RegExp(escapeStringForRegEx('a.b.c'),'g') => /a\.b\.c/g
@@ -12,8 +17,13 @@ export declare namespace Utils {
     export const fullDate: () => string;
     export const getFreePort: (options?: {
         startFrom?: number;
-        howManyFreePortsAfterThatPort?: number;
     }) => Promise<number>;
+    export const requireUncached: (module: string) => any;
+    /**
+     * similar to camelCase but remove
+     * all non word / repeated characters
+     */
+    export const camelize: (str?: string) => string;
     interface AttrJsoncProp {
         name: string;
         value?: any;
@@ -150,6 +160,7 @@ export declare namespace UtilsProcess {
      * TODO IMPLEMENT
      * start async node process
      */
+    export const startAsync: (command: string, cwd: string, options?: Omit<CoreModels.ExecuteOptions, "tryAgainWhenFailAfter">) => Promise<void>;
     /**
      * This let you start child process and resolve promise when some
      * condition is met. It is useful for example when you want to start
@@ -171,6 +182,34 @@ export declare namespace UtilsProcess {
      */
     export const startInNewTerminalWindow: (command: string, options?: Pick<ProcessStartOptions, "cwd" | "hideOutput">) => any;
     export const getBashOrShellName: () => "browser" | "cmd" | "powershell" | "gitbash" | "cygwin" | "unknown" | "bash" | "zsh" | "fish" | "sh";
+    /**
+     * Get CPU and memory usage for a single PID.
+     */
+    export const getUsageForPid: (pid: number) => Promise<{
+        cpu: number;
+        memoryInGB: number;
+        memoryInMB: number;
+    }>;
+    /**
+     * Cross-platform function to list *direct* child PIDs of a given PID.
+     * Uses the appropriate command depending on `process.platform`.
+     */
+    export function getChildPidsOnce(pid: number): Promise<number[]>;
+    /**
+     * Get CPU and memory usage for the current process (the Node.js process itself),
+     * plus any child processes spawned by it.
+     */
+    export const getCurrentProcessAndChildUsage: () => Promise<{
+        current: {
+            cpu: number;
+            memoryInMB: number;
+        };
+        children: Array<{
+            pid: number;
+            cpu: number;
+            memoryInMB: number;
+        }>;
+    }>;
     export {};
 }
 export declare namespace UtilsOs {
@@ -196,11 +235,17 @@ export declare namespace UtilsOs {
      * Electron backend or browser.
      */
     const isRunningInElectron: () => boolean;
+    /**
+     * Check whether the current process is running inside
+     * a Visual Studio Code extension.
+     */
+    const isRunningInVscodeExtension: () => boolean;
     /**
      * Check wether the current process is running inside
      * windows subsystem for linux (WSL).
      */
     const isRunningInWsl: () => boolean;
+    const isRunningInWindowsCmd: () => boolean;
     const isRunningInDocker: () => boolean;
     const isRunningInLinuxGraphicsCapableEnvironment: () => boolean;
     /**
@@ -238,11 +283,30 @@ export declare namespace UtilsMigrations {
     const isValidTimestamp: (value: any) => boolean;
 }
 export declare namespace UtilsTerminal {
+    type SelectActionChoice = {
+        [choice: string]: {
+            /**
+             * Title of the choice
+             */
+            name: string;
+            /**
+             * Action to execute
+             */
+            action?: () => any;
+            /**
+             * If choice is visible
+             *  default: true
+             */
+            visible?: boolean;
+        };
+    };
+    export const wait: (second: number) => Promise<void>;
     export const clearConsole: () => void;
     export const multiselect: <T = string>(options: {
         question: string;
         /**
          * If true, then only one choice can be selected
+         * @deprecated use select instead
          */
         onlyOneChoice?: boolean;
         choices: {
@@ -256,18 +320,24 @@ export declare namespace UtilsTerminal {
         autocomplete?: boolean;
         defaultSelected?: string[];
     }) => Promise<T[]>;
-    type SelectActionChoice = {
-        [choice: string]: {
-            /**
-             * Title of the choice
-             */
-            name: string;
-            /**
-             * Action to execute
-             */
-            action?: () => any;
-        };
-    };
+    /**
+     * Similar to select but executes action if provided
+     * @returns selected and executed value
+     */
+    export const multiselectActionAndExecute: <CHOICE extends SelectActionChoice = SelectActionChoice>(choices: CHOICE, options?: {
+        question?: string;
+        autocomplete?: boolean;
+        defaultSelected?: string;
+        hint?: string;
+        executeActionsOnDefault?: boolean;
+    }) => Promise<{
+        selected: (keyof CHOICE)[];
+        actionResults: unknown[];
+        /**
+         * object containing all selected actions
+         */
+        actions: (() => any)[];
+    }>;
     /**
      * Similar to select but executes action if provided
      * @returns selected and executed value
@@ -279,7 +349,12 @@ export declare namespace UtilsTerminal {
         hint?: string;
         executeActionOnDefault?: boolean;
     }) => Promise<{
+        selected: any;
+        action: () => Promise<any>;
+        actionResult?: undefined;
+    } | {
         selected: keyof CHOICE;
+        actionResult: unknown;
         action: () => Promise<any>;
     }>;
     export const select: <T = string>(options: {