tnp-core 21.0.166 → 21.0.167

package/full-dts/utils-i18n.d.ts

@@ -0,0 +1,38 @@
+export declare namespace UtilsI18n {
+    const defaultLangLocale: UtilsI18n.CommonLocaleCode;
+    enum CommonLocaleCodeEnum {
+        PL_PL = "pl-PL",
+        EN_US = "en-US",
+        EN_GB = "en-GB",
+        DE_DE = "de-DE",
+        FR_FR = "fr-FR",
+        ES_ES = "es-ES",
+        ZH_CN = "zh-CN"
+    }
+    const commonLocales: CommonLocaleCode[];
+    type CommonLocaleCode = `${CommonLocaleCodeEnum}`;
+    interface LangOption {
+        code: UtilsI18n.CommonLocaleCode;
+        label: string;
+    }
+    const LangOptionArr: LangOption[];
+    function detectLocale(): CommonLocaleCode;
+    interface GettextExtracted {
+        lineNumber: number;
+        gettextString: string;
+        context?: string;
+        /**
+         * translation for specyfic language
+         */
+        translation?: string;
+    }
+    interface GettextFile {
+        fileAbsPath: string;
+        fileRelativePath?: string;
+        /**
+         * taon thing - file can be for app or lib
+         */
+        isAppFile?: boolean;
+        tags: UtilsI18n.GettextExtracted[];
+    }
+}

package/full-dts/utils-json.d.ts

@@ -0,0 +1,37 @@
+export declare namespace UtilsJson {
+    interface AttrJsoncProp {
+        name: string;
+        value?: any;
+    }
+    /**
+     * ! TODO handle packages like zone.js with dot
+     * Get attributes from jsonc or json5 file
+     * @param jsonDeepPath lodash path to property in json ex. deep.path.to.prop
+     * @param fileContent jsonc or json5 - json with comments
+     * @returns array of attributes
+     */
+    const getAtrributiesFromJsonWithComments: (jsonDeepPath: string, // lodash path to property in json ex. deep.path.to.prop
+    fileContent: string) => AttrJsoncProp[];
+    const getAttributiesFromComment: (comment: string, attributes?: AttrJsoncProp[]) => AttrJsoncProp[];
+    /**
+     * read json from absolute path
+     * @returns json object
+     */
+    const readJson: (absoluteFilePath: string | string[], defaultValue?: {}, useJson5?: boolean) => any;
+    const readJsonWithComments: (absoluteFilePath: string | string[], defaultValue?: any) => any;
+    const validateLodashPath: (lodashGetPath: string | string[]) => string;
+    const getValue: (filepath: string | string[], lodashGetPath: string | string[], options?: {
+        defaultValue?: any;
+        /**
+         * true by default
+         */
+        isJsonWithComments?: boolean;
+    }) => any;
+    const setValue: (filepath: string | string[], lodashGetPath: string | string[], value: any, options?: {
+        defaultValue?: any;
+        /**
+         * true by default
+         */
+        isJsonWithComments?: boolean;
+    }) => void;
+}

package/full-dts/utils-jwt.d.ts

@@ -0,0 +1,12 @@
+export declare namespace UtilsJwt {
+    interface JwtPayload {
+        iat?: number;
+        exp?: number;
+        [key: string]: unknown;
+    }
+    function sign(payload: JwtPayload, secret: string, options: {
+        expiresIn: string | number;
+    }): Promise<string>;
+    function decode<T extends JwtPayload = JwtPayload>(token: string): T;
+    function verify<T extends JwtPayload = JwtPayload>(token: string, secret: string): Promise<T>;
+}

package/full-dts/utils-md-docs.d.ts

@@ -0,0 +1,21 @@
+export declare namespace UtilsMdDocs {
+    interface RenderImport {
+        packageName?: string;
+        isLocal: boolean;
+        relativePath: string;
+        context: any;
+        rawRenderTagString: string;
+        magicRenameRules: string;
+    }
+    function getRenderImports(mdContent: string): RenderImport[];
+    /**
+     * extract assets pathes from .md file
+     */
+    const getAssets: (mdfileContent: string) => string[];
+    const getAssetsFromFile: (absPathToFile: string) => string[];
+    /**
+     * Extract links to other Markdown files from a given Markdown content.
+     * @param mdfileContent
+     */
+    const getLinksToOtherMdFiles: (mdfileContent: string) => string[];
+}

package/full-dts/utils-network.d.ts

@@ -0,0 +1,79 @@
+import 'reflect-metadata';
+import { URL } from 'url';
+import { Subject } from 'rxjs';
+import { UtilsEtcHosts } from './utils-etc-hosts';
+export declare namespace UtilsNetwork {
+    interface PingResult {
+        host: string;
+        success: boolean;
+        timeMs?: number;
+        output?: string;
+    }
+    function checkPing(host: string, timeoutMs?: number): Promise<PingResult>;
+    const checkIfServerPings: (host: string, timeoutMs?: number) => Promise<boolean>;
+    /**
+     * Check if a server is online by attempting to open a TCP connection.
+     */
+    const checkIfServerOnline: (host: string, port?: number, timeoutMs?: number) => Promise<boolean>;
+    const isValidIp: (ip: string) => boolean;
+    const isValidDomain: (url: string, options?: {
+        /**
+         * if yes - domain should start with http:// or https://
+         */
+        shouldIncludeProtocol?: boolean | "http" | "https";
+    }) => boolean;
+    const urlParse: (portOrHost: number | string | URL, options?: {
+        forceDomain?: boolean;
+        httpsIfNotProvided?: boolean;
+    }) => URL;
+    const getEtcHostsPath: () => string;
+    /**
+     * Add or update a hosts entry
+     */
+    const setEtcHost: (domain: string, ip?: string, comment?: string) => void;
+    /**
+     * @deprecated use UtilsEtcHosts.getEntriesByDomain instead
+     */
+    const getEtcHostEntriesByDomain: (domain: string) => UtilsEtcHosts.EtchostEntry[];
+    /**
+     * @deprecated use UtilsEtcHosts.getEntryByComment instead
+     */
+    const getEtcHostEntryByComment: (commentOfEntry: string) => UtilsEtcHosts.EtchostEntry[];
+    /**
+     * @deprecated use UtilsEtcHosts.getEntriesByIp instead
+     */
+    const getEtcHostEntryByIp: (ip: string) => UtilsEtcHosts.EtchostEntry[];
+    /**
+     * Remove all lines containing the given domain
+     * @deprecated use UtilsEtcHosts.removeEntryByDomain instead
+     */
+    const removeEtcHost: (domain: string) => void;
+    const etcHostHasProperLocalhostIp4Entry: () => boolean;
+    const etcHostHasProperLocalhostIp6Entry: () => boolean;
+    /**
+     * @deprecated use UtilsEtcHosts.simulateDomain instead
+     */
+    const simulateDomain: (domainOrDomains: string | string[], options?: {
+        triggerRevertChangesToEtcHosts?: Subject<void>;
+    }) => Promise<void>;
+    interface LocalIpInfo {
+        interfaceName: string;
+        address: string;
+        family: 'IPv4' | 'IPv6';
+        internal: boolean;
+        type: 'lan' | 'wifi' | 'other' | 'virtual';
+    }
+    /**
+     * Returns all local IP addresses in preferred order:
+     * LAN → Wi-Fi → Other → Virtual
+     */
+    const getLocalIpAddresses: () => Promise<LocalIpInfo[]>;
+    /**
+     * Returns first active local ipv4 IP (LAN preferred over Wi-Fi).
+     */
+    const getFirstIpV4LocalActiveIpAddress: () => Promise<string | null>;
+    /**
+     * Returns current public IP address (or null if undetectable).
+     */
+    const getCurrentPublicIpAddress: () => Promise<string | null>;
+}

package/full-dts/utils-os.d.ts

@@ -0,0 +1,126 @@
+import 'reflect-metadata';
+export declare namespace UtilsOs {
+    /**
+     * check if script is running in client browser
+     * (websql model -> is also considered as browser
+     * because it is running in browser)
+     */
+    const isRunningInBrowser: () => boolean;
+    /**
+     * check if script is running in nodejs
+     * (backend script or electron script)
+     */
+    const isRunningInNode: () => boolean;
+    /**
+     * check if script is running special
+     * browser mode that has sql.js backend
+     * and executes sql queries in browser
+     */
+    const isRunningInWebSQL: () => boolean;
+    const isRunningInSSRMode: () => boolean;
+    /**
+     * check whether the current process is running inside
+     * Cloudflare worker
+     */
+    const isRunningInCloudflareWorker: () => boolean;
+    /**
+     * check whether the current process is running inside
+     * 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 isRunningInWindowsPowerShell: () => boolean;
+    const isRunningInWindowsCmd: () => boolean;
+    const isRunningInWindowsGitBash: () => boolean;
+    const isRunningInDocker: () => boolean;
+    /**
+     * check what linux you are running
+     */
+    const isRunningInLinuxDistro: (linuxType?: "arch" | "ubuntu" | "fedora") => boolean;
+    const isRunningInLinuxGraphicsCapableEnvironment: () => boolean;
+    const isRunningInOsWithGraphicsCapableEnvironment: () => boolean;
+    /**
+     * Check whether the current process is running in CLI mode.
+     */
+    const isRunningInCliMode: () => boolean;
+    /**
+     * Check whether the current process is running in mocha test.
+     */
+    const isRunningInMochaTest: () => boolean;
+    /**
+     * Checks if a given port is already in use (bound by another process).
+     *
+     * @param port - The port number to check.
+     * @param host - The hostname or IP address to bind to (default: '127.0.0.1').
+     * @returns Promise<boolean> - Resolves to `true` if the port is in use, otherwise `false`.
+     */
+    const isPortInUse: (port: number, options?: {
+        /**
+         * '127.0.0.1' etc..
+         */
+        checkForSpecificOnlyHost?: string;
+    }) => Promise<boolean>;
+    /**
+     * Check if docker is available on this system
+     * and it is running (daemon active)
+     */
+    const isDockerAvailable: () => Promise<boolean>;
+    const openFolderInFileExplorer: (folderPath: string) => void;
+    const getRealHomeDir: () => string;
+    type Editor = 'code' | 'codium' | 'cursor' | 'theia' | 'idea' | 'idea64';
+    type EditorProcess = `${Editor}` | 'code-oss';
+    const EditorArr: Editor[];
+    const EDITOR_PROCESSES: Record<EditorProcess, string[]>;
+    const killAllEditor: (editor: EditorProcess) => void;
+    const detectEditor: (options?: {
+        fallbackCheckCommandExists?: boolean;
+    }) => Editor | undefined;
+    const getEditorKeybindingPath: (editor: Editor) => string | undefined;
+    const getEditorSettingsJsonPath: (editor: Editor, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv) => string | undefined;
+    const isRunningNodeDebugger: () => boolean;
+    const isNodeVersionOk: (options?: {
+        required?: string;
+        log?: boolean;
+        throwErrorIfNotOk?: boolean;
+    }) => boolean;
+    const isElectron: boolean;
+    const isBrowser: boolean;
+    const isNode: boolean;
+    const isWebSQL: boolean;
+    const isVscodeExtension: boolean;
+    const isSSRMode: boolean;
+    const isRunningInWindows: boolean;
+    const commandExistsAsync: (commandName: string) => Promise<boolean>;
+    /**
+     * @deprecated use commandExistsAsync
+     */
+    const commandExistsSync: (commandName: string) => boolean;
+    const pipxPackageExists: (packageName: string) => Promise<boolean>;
+    const pipxNestedPackageExists: (mainPackageName: string, targetNestedFromMainPackage: string) => Promise<boolean>;
+    const pythonModuleExists: (moduleName: string, pythonPath?: string) => Promise<boolean>;
+    const drawHorizontalLine: (row?: number) => void;
+    const drawVerticalLine: (col?: number) => void;
+    function getInotifyWatchCount(): Promise<number>;
+    const sendNotification: (opt: {
+        title: string;
+        body: string;
+        subtitle?: string;
+        appName?: string;
+        iconPath?: string;
+        timeoutMs?: number;
+        doneCallback?: () => any;
+    }) => Promise<void>;
+    function safeExitProgramCleanUp(cleanFn: () => Promise<void> | void): void;
+    const whichOrWherePackageLocated: (packageName: string) => string | undefined;
+}
+export declare const taonRepoPathUserInUserDirFn: () => string;
+export declare const taonBasePathToGlobalDockerTemplatesFn: () => string;

package/full-dts/utils-passwords.d.ts

@@ -0,0 +1,8 @@
+export declare namespace UtilsPasswords {
+    /**
+     * Result:
+     * v1:<iterations>:<salt-base64>:<hash-base64>
+     */
+    function hash(password: string): Promise<string>;
+    function verify(password: string, storedHash: string): Promise<boolean>;
+}

package/full-dts/utils-process-logger.d.ts

@@ -0,0 +1,97 @@
+import 'reflect-metadata';
+import { ChildProcess } from 'child_process';
+/**
+ * Utils for logging ChildProcess output to files.
+ * - logging stdout and stderr to files
+ * - real-time monitoring of output
+ * - special event callbacks on specific output strings
+ * - caching last N lines of output for quick access
+ */
+export declare namespace UtilsProcessLogger {
+    interface ProcessFileLoggerOptions extends Record<string, string | number | boolean | undefined> {
+        name: string;
+        id?: string | number;
+        pid?: number;
+        ppid?: number;
+        hash?: string;
+        utime?: string;
+    }
+    interface SpecialEventInProcessLogger {
+        stdout?: {
+            stringInStream: string;
+            callback: (data: string) => void;
+        }[];
+        stderr?: {
+            stringInStream: string;
+            callback: (data: string) => void;
+        }[];
+    }
+    const baseDirTaonProcessLogs: () => string;
+    const getLogsFiles: <T extends ProcessFileLoggerOptions = ProcessFileLoggerOptions>(options: T, baseDir: string) => string[];
+    /**
+     * Logs the stdout and stderr of a ChildProcess to a file.
+     */
+    class ProcessFileLogger<T extends ProcessFileLoggerOptions = ProcessFileLoggerOptions> {
+        /**
+         * Options used to generate the log file name.
+         */
+        private dataForFilename;
+        private options?;
+        private _logFilePath;
+        private writeStream;
+        private _processLogFilename;
+        private lastNLinesFromStderr;
+        private lastNLinesFromStdout;
+        private lastNLinesFromOfOutput;
+        get processLogFilename(): string | null;
+        get processLogAbsFilePath(): string | null;
+        constructor(
+        /**
+         * Options used to generate the log file name.
+         */
+        dataForFilename: T, options?: {
+            baseDir?: string;
+            specialEvent?: SpecialEventInProcessLogger;
+        });
+        startLogging(proc: ChildProcess, cacheCallback?: {
+            /**
+             * @default 40
+             */
+            cacheLinesMax?: number;
+            /**
+             * Throttle in ms for callback update()
+             */
+            throttleMs?: number;
+            /**
+             * Special callback function for saving stuff in db/memory or elsewhere
+             */
+            update: (opt: {
+                outputLines: string;
+                stderrLines: string;
+                stdoutLines: string;
+            }) => void;
+        }): void;
+        stopLogging(): void;
+        /**
+         * Externally update the log file with additional stdout/stderr data.
+         */
+        update(stdout: string, stderr?: string): void;
+    }
+    /**
+     * Perfect for real-time logs with a sticky top box message.
+     *
+     * Example:
+     * const stickyBox = UtilsProcessLogger.createStickyTopBox('My Sticky Message');
+     * stickyBox.update('Initial log content...');
+     *
+     * // Later updates
+     * stickyBox.update('More log content...');
+     *
+     * // To clear the sticky box and logs
+     * stickyBox.clear();
+     */
+    const createStickyTopBox: (message: string) => {
+        update: (content: string) => void;
+        clear: () => void;
+    };
+}

package/full-dts/utils-process.d.ts

@@ -0,0 +1,93 @@
+import 'reflect-metadata';
+import { ChildProcess } from 'child_process';
+export declare namespace UtilsProcess {
+    /**
+     * This let you start child process and resolve promise when some
+     * condition is met. It is useful for example when you want to start
+     * process and wait until some output is in stdout or stderr.
+     */
+    const startAsyncChildProcessCommandUntil: (command: string, options: {
+        /**
+         * tels when to resolve promise
+         */
+        untilOptions: {
+            /**
+             * until this string is in output of stdout
+             */
+            stdout?: string | string[];
+            /**
+             * until this string is in output of stderr
+             */
+            stderr?: string | string[];
+            /**
+             * by default only resolve when exit code is 0
+             */
+            resolveAfterAnyExitCode?: boolean;
+        };
+        displayOutputInParentProcess?: boolean;
+        resolveAfterAnyExitCode?: boolean;
+        cwd?: string;
+    }) => Promise<void>;
+    const getGitBashPath: () => string;
+    /**
+     * TODO IMPLEMENT
+     * start async node process
+     */
+    const startInNewTerminalWindow: (command: string, options?: {
+        cwd?: string;
+        hideOutput?: {
+            stdout?: boolean;
+            stderr?: boolean;
+            acceptAllExitCodeAsSuccess?: boolean;
+        };
+    }) => any;
+    const getBashOrShellName: () => "browser" | "cmd" | "powershell" | "gitbash" | "cygwin" | "unknown" | "bash" | "zsh" | "fish" | "sh";
+    /**
+     * Get CPU and memory usage for a single PID.
+     */
+    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`.
+     */
+    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.
+     */
+    const getCurrentProcessAndChildUsage: () => Promise<{
+        current: {
+            cpu: number;
+            memoryInMB: number;
+        };
+        children: Array<{
+            pid: number;
+            cpu: number;
+            memoryInMB: number;
+        }>;
+    }>;
+    /**
+     * Kills all running Java processes cross‑platform.
+     * @returns Promise<boolean> true if processes were killed, false if none found
+     */
+    const killAllJava: () => Promise<boolean>;
+    const killProcess: (pidOrProcess: number | ChildProcess) => Promise<void>;
+    const killProcessOnPort: (port: number) => Promise<boolean>;
+    /**
+     * Kills all Node.js processes except the current process.
+     * Works on Windows, macOS, and Linux.
+     * @returns {number} Number of processes killed
+     */
+    const killAllOtherNodeProcesses: () => Promise<void>;
+    const isNodeVersionOk: (options?: {
+        required?: string;
+        log?: boolean;
+        throwErrorIfNotOk?: boolean;
+    }) => boolean;
+    function isCurrentProcessAttachedToTerminal(): boolean;
+    const getPathOfExecutable: (command: string) => Promise<string | null>;
+}

package/full-dts/utils-progress.d.ts

@@ -0,0 +1,26 @@
+export declare namespace UtilsProgress {
+    type TaonProgressType = 'info' | 'warning' | 'error' | 'event';
+    interface TaonProgressEvent {
+        /**
+         * Absolute progress value from 0 to 100.
+         */
+        value?: number;
+        message?: string;
+        type?: TaonProgressType;
+        /**
+         * ISO date string.
+         */
+        date?: string;
+    }
+    interface ResolveProgressOptions {
+        callbackOnFounded?: (event: TaonProgressEvent) => void;
+        /**
+         * When enabled, malformed progress messages are logged.
+         */
+        logParseErrors?: boolean;
+    }
+    function emitProgress(event: TaonProgressEvent, forceShow?: boolean): void;
+    function resolveFrom(chunk: string, options?: ResolveProgressOptions, checkSplit?: boolean): TaonProgressEvent[];
+    function hasProgressEvent(chunk: string): boolean;
+    function parseTaonProgressLine(line: string): TaonProgressEvent | undefined;
+}