tnp-core 21.0.166 → 21.0.167

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

@@ -0,0 +1,327 @@
+export declare namespace UtilsProjects {
+    interface OrderAbleProject {
+        location?: string;
+        name?: string;
+    }
+    /**
+     * Sorts Taon projects using their dependency graph.
+     *
+     * This function has 3 main modes:
+     *
+     * ============================================================================
+     * 1. STANDARD MODE
+     * ============================================================================
+     *
+     * Sort all projects in normal dependency build order.
+     *
+     * Meaning:
+     *
+     *   If:
+     *
+     *     app  depends on ui
+     *     ui   depends on core
+     *     core depends on nothing
+     *
+     *   Then build order is:
+     *
+     *     core -> ui -> app
+     *
+     * Example:
+     *
+     *   Projects:
+     *
+     *     not-related
+     *     core
+     *     ui   -> core
+     *     app  -> ui
+     *
+     *   Result:
+     *
+     *     [
+     *       'not-related',
+     *       'core',
+     *       'ui',
+     *       'app',
+     *     ]
+     *
+     * Graph:
+     *
+     *     core
+     *       |
+     *       v
+     *      ui
+     *       |
+     *       v
+     *      app
+     *
+     *   Build direction:
+     *
+     *     core ---> ui ---> app
+     *
+     * Usage:
+     *
+     *   sortGroupOfProject({
+     *     projects,
+     *     resoveDepsArray: p => p.dependencies,
+     *     projNameToCompare: p => p.name,
+     *   });
+     *
+     *
+     * ============================================================================
+     * 2. onlyDepsForProject MODE
+     * ============================================================================
+     *
+     * Returns selected project plus its dependency chain.
+     *
+     * This answers the question:
+     *
+     *   "What does this project need before it can be built?"
+     *
+     * Example:
+     *
+     *   app depends on ui
+     *   ui  depends on core
+     *
+     *   onlyDepsForProject: 'app'
+     *
+     * Result:
+     *
+     *   [
+     *     'app',
+     *     'ui',
+     *     'core',
+     *   ]
+     *
+     * Graph:
+     *
+     *      app
+     *       |
+     *       v
+     *      ui
+     *       |
+     *       v
+     *     core
+     *
+     * Read as:
+     *
+     *   app needs ui
+     *   ui needs core
+     *
+     * This mode walks backwards through dependencies.
+     *
+     * Possible usage:
+     *
+     *   - debugging project dependency chain
+     *   - checking what project depends on directly/indirectly
+     *   - maybe useful before creating a build plan
+     *
+     * NOTE:
+     *
+     *   This mode may not be needed for Taon watch rebuilds.
+     *   For leader builds, `onlyAffectedByProject` is usually more useful.
+     *
+     * Usage:
+     *
+     *   sortGroupOfProject({
+     *     projects,
+     *     resoveDepsArray: p => p.dependencies,
+     *     projNameToCompare: p => p.name,
+     *     onlyDepsForProject: 'app',
+     *   });
+     *
+     *
+     * ============================================================================
+     * 3. onlyAffectedByProject MODE
+     * ============================================================================
+     *
+     * Returns selected project plus all projects that are affected by it.
+     *
+     * This answers the question:
+     *
+     *   "Project X changed. What active projects must be rebuilt?"
+     *
+     * Example:
+     *
+     *   app depends on ui
+     *   ui  depends on core
+     *
+     *   onlyAffectedByProject: 'core'
+     *
+     * Result:
+     *
+     *   [
+     *     'core',
+     *     'ui',
+     *     'app',
+     *   ]
+     *
+     * Graph:
+     *
+     *     core
+     *       |
+     *       v
+     *      ui
+     *       |
+     *       v
+     *      app
+     *
+     * Read as:
+     *
+     *   core changed
+     *   therefore ui is affected
+     *   therefore app is affected
+     *
+     * This mode walks forward through dependents.
+     *
+     * This is the most important mode for Taon lightweight watch.
+     *
+     * Leader build flow:
+     *
+     *   1. User changes file in project X.
+     *   2. Current build session is canceled.
+     *   3. Worker calculates projects affected by X.
+     *   4. Worker returns ordered build plan.
+     *   5. Last changed project becomes build leader.
+     *   6. Build leader executes projects one by one.
+     *
+     * Example:
+     *
+     *   Changed project:
+     *
+     *     core
+     *
+     *   Active projects:
+     *
+     *     core
+     *     ui
+     *     app
+     *     not-related
+     *
+     *   Dependency graph:
+     *
+     *     core ---> ui ---> app
+     *
+     *     not-related
+     *
+     *   onlyAffectedByProject: 'core'
+     *
+     *   Build plan:
+     *
+     *     [
+     *       'core',
+     *       'ui',
+     *       'app',
+     *     ]
+     *
+     *   not-related is skipped because it does not depend on core.
+     *
+     * Usage:
+     *
+     *   sortGroupOfProject({
+     *     projects,
+     *     resoveDepsArray: p => p.dependencies,
+     *     projNameToCompare: p => p.name,
+     *     onlyAffectedByProject: 'core',
+     *   });
+     *
+     *
+     * ============================================================================
+     * Extra behavior
+     * ============================================================================
+     *
+     * Circular dependencies:
+     *
+     *   The function detects cycles.
+     *
+     *   Example:
+     *
+     *     a -> b -> c -> a
+     *
+     *   This throws:
+     *
+     *     Circular dependency detected involving project: <project>
+     *
+     *
+     * Duplicate project names:
+     *
+     *   Dependencies are resolved by logical project/package name:
+     *
+     *     projNameToCompare(project)
+     *
+     *   But project identity can be resolved by unique key:
+     *
+     *     projUniqueKeyToCompare(project)
+     *
+     *   This is useful when multiple active projects have the same package name
+     *   but different location, port, or runtime context.
+     *
+     *
+     * Override order:
+     *
+     *   overridePackagesOrder can be used for special/hacky cases where some
+     *   projects must be moved manually inside the sorted result.
+     *
+     *
+     * Mental model:
+     *
+     *   Standard mode:
+     *
+     *     dependencies first
+     *
+     *   onlyDepsForProject:
+     *
+     *     "what do I need?"
+     *
+     *   onlyAffectedByProject:
+     *
+     *     "who needs me?"
+     *
+     *
+     * Best Taon watcher usage:
+     *
+     *   Use `onlyAffectedByProject` for leader build plans.
+     */
+    const sortGroupOfProject: <T extends OrderAbleProject>(options: {
+        /**
+         * Projects that needs to be sorted by dependencies
+         */
+        projects: T[];
+        /**
+         * How to resolve dependencies array:
+         * exmaple: proj => proj.dependencies # or something similar
+         */
+        resoveDepsArray: (proj: T) => string[];
+        /**
+         * each project has name that is being use also for project.dependencies list.
+         * exmaple: proj => proj.name
+         */
+        projNameToCompare: (proj: T) => string;
+        /**
+         * Since there may be duplicated project with the same name but diffrent
+         * other propers => this is a way to compares projects
+         * example: proj => proj.uniqueKey # or other unique property
+         * <uniqueKey may be for example: projectName+Localtion+port>
+         */
+        projUniqueKeyToCompare?: (proj: T) => string;
+        /**
+         * Override packages order (sometimes needed for some hacks)
+         */
+        overridePackagesOrder?: string[];
+        /**
+         * Filter project and give me only deps for specyfic proj
+         */
+        onlyDepsForProject?: string;
+        /**
+         * Filter projects and return only projects affected by this project.
+         *
+         * Example:
+         * core changed
+         * -> ui depends on core
+         * -> app depends on ui
+         *
+         * result:
+         * ['core', 'ui', 'app']
+         */
+        onlyAffectedByProject?: string | string[];
+    }) => T[];
+}

package/full-dts/utils-secret-env.d.ts

@@ -0,0 +1,41 @@
+export declare function decodeEnv(encryptedValue: string | any): Promise<string>;
+export declare namespace UtilsSecretEnv {
+    const MASTER_PASS_KEY = "TAON_MASTER_PASS_KEY";
+    const TAON_ENCRYPTED_START = "$$$TAON_ENCRYPTED_START$$$";
+    const TAON_ENCRYPTED_END = "$$$TAON_ENCRYPTED_END$$$";
+    /**
+     * Result format:
+     *
+     * v1:<iterations>:<salt>:<iv>:<ciphertext>
+     *
+     * Salt and IV are intentionally stored with the ciphertext.
+     * They are not secrets.
+     */
+    function encrypt(value: string, password: string): Promise<string>;
+    function decrypt(encryptedValue: string, password: string): Promise<string>;
+    /**
+     * Extracts a static string from forms such as:
+     *
+     * () => 'secret'
+     * () => "secret"
+     * () => `secret`
+     * () => `s${'asd'}ecret`
+     * () => `port-${123}`
+     *
+     * Returns undefined for dynamic expressions:
+     *
+     * () => getSecret()
+     * () => process.env.SECRET
+     * () => `secret-${someVariable}`
+     */
+    function extractStaticStringFromArrowFunction(contentPropFunction: string): string | undefined;
+    /**
+     * Generates a cryptographically secure random password.
+     *
+     * Works in:
+     * - Node.js
+     * - Browser
+     * - Cloudflare Workers
+     */
+    function generateRandomPassword(length?: number): string;
+}

package/full-dts/utils-start-async.d.ts

@@ -0,0 +1,67 @@
+import { ChildProcess } from 'child_process';
+import { Observable } from 'rxjs';
+export interface ProcessStartOptions {
+    /**
+     * unique name for the process
+     */
+    uniqueName?: string;
+    /**
+     * by default is process.cwd();
+     */
+    cwd?: string;
+    /**
+     * by default is false
+     */
+    showCommand?: boolean;
+    /**
+     * Line by line check and remove not needed stuff
+     */
+    extractFromLine?: (string | Function)[];
+    /**
+     * Modify output line by line
+     */
+    outputLineReplace?: (outputLineStderOrStdout: string) => string;
+    resolvePromiseMsg_stdout: string | string[];
+    resolvePromiseMsg_stderr: string | string[];
+    resolvePromiseMsgCallback_stdout: () => void | Promise<void>;
+    resolvePromiseMsgCallback_stderr: () => void | Promise<void>;
+    resolvePromiseMsgCallback_anystd: () => void | Promise<void>;
+    /**
+     * Exit with
+     */
+    onExitCallback?: (code?: number, resolve?: () => any, reject?: () => any) => void | Promise<void>;
+    hideOutput_stdout?: boolean;
+    hideOutput_stderr?: boolean;
+    env: any;
+    /**
+     * Prefix messages output from child_process
+     * (if true - it will take unique name)
+     */
+    prefix?: string | boolean;
+    /**
+     * Try command again after fail after n milliseconds
+     */
+    tryAgainWhenFailAfter?: number;
+    askToTryAgainOnError?: boolean;
+    /**
+     * Use big buffer for big webpack logs
+     * (it may slow down smaller processes execution)
+     */
+    biggerBuffer?: boolean;
+    rebuildOnChange?: Observable<any>;
+    /**
+     * todo implement
+     */
+    similarProcessKey?: string;
+    onChildProcessChange?: (childProcess: ChildProcess) => void;
+    /**
+     * TODO do I need this ?
+     */
+    outputBuffer?: string[];
+    outputBufferMaxSize?: number;
+}
+/**
+ * TODO IMPLEMENT
+ * start async node process
+ */
+export declare const startAsync: (command: string, cwd: string, options?: Partial<ProcessStartOptions>) => Promise<void>;

package/full-dts/utils-stdin-stdout-logger.d.ts

@@ -0,0 +1,9 @@
+export declare namespace UtilsStdinStdoutLogger {
+    const __REGISTER_STARTED__ = "UtilsStdinStdoutLogger-registering-started";
+    interface RegisteredAppLogging {
+        logFilePath: string;
+        unregister: () => void;
+    }
+    const startedRegistering: () => boolean;
+    const registerFor: (workerName: string, groupName: string) => RegisteredAppLogging;
+}

package/full-dts/utils-string-regex.d.ts

@@ -0,0 +1,11 @@
+export declare namespace UtilsString {
+    const kebabCaseNoSplitNumbers: (input: string) => string;
+    const listDiff: (arr1: string[], arr2: string[]) => {
+        added: string[];
+        removed: string[];
+        infoMessage: () => void;
+    };
+}
+export declare namespace UtilsStringRegex {
+    const containsNonAscii: (pathStringOrPathParts: string) => boolean;
+}

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

@@ -0,0 +1,32 @@
+export declare namespace UtilsSudo {
+    /**
+     * All possible sudo states on Windows 11 (24H2+)
+     */
+    enum SudoStatus {
+        NotInstalled = "NotInstalled",
+        Disabled = "Disabled",
+        Enabled_ForceNewWindow = "Enabled_ForceNewWindow",// Enabled = 2
+        Enabled_Inline = "Enabled_Inline",// Enabled = 3 ← current default
+        Unknown = "Unknown"
+    }
+    /**
+     * @returns true if current process is elevated (admin or sudo root), false otherwise
+     */
+    export const isCurrentProcessElevated: () => Promise<boolean>;
+    /**
+     * Main function – returns detailed sudo status
+     */
+    export function getStatus(): Promise<{
+        status: SudoStatus;
+        label: string;
+        isAvailable: boolean;
+        isInline: boolean;
+    }>;
+    /**
+     * check if sudo is available and in proper mode
+     */
+    export const isInProperModeForTaon: ({ displayErrorMessage, }: {
+        displayErrorMessage?: boolean;
+    }) => Promise<boolean>;
+    export {};
+}

package/full-dts/utils-temp-folder.d.ts

@@ -0,0 +1,29 @@
+export declare namespace UtilsTempFolder {
+    interface GetTempFolderOptions {
+        /**
+         * Automatically remove this folder after the specified number of days.
+         *
+         * Folders with expiration enabled are created inside:
+         *   <system-temp>/__temp__folders__with__exp__date
+         */
+        deleteAfterDays?: number;
+        /**
+         * Optional readable part of the generated folder name.
+         */
+        prefix?: string;
+        /**
+         * When true, creates a unique folder on every call.
+         *
+         * Example:
+         *   /tmp/cloudflare-db-1789309118998-1234-a1b2c3d4e5f6
+         *
+         * When false, creates/reuses a persistent folder:
+         *   /tmp/cloudflare-db
+         *
+         * @default false
+         */
+        everytimeNew?: boolean;
+    }
+    const getPath: (options?: GetTempFolderOptions) => Promise<string>;
+    function getPathForNodeOnly(options: GetTempFolderOptions): string;
+}

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

@@ -0,0 +1,171 @@
+import 'reflect-metadata';
+import { CoreModels } from './core-models';
+export declare namespace UtilsTerminal {
+    export interface SelectChoice {
+        /**
+         * Title of the choice
+         */
+        name?: string;
+        disabled?: boolean;
+    }
+    export interface SelectChoiceValue<T = string> extends SelectChoice {
+        value?: T;
+    }
+    type SelectActionChoice = {
+        [choice: string]: SelectChoice & {
+            /**
+             * Action to execute
+             */
+            action?: () => any;
+        };
+    };
+    export const wait: (second: number) => Promise<void>;
+    export const waitMilliseconds: (milliseconds: number) => Promise<void>;
+    /**
+     * Check if cli is running in verbose mode
+     * @returns true if cli is running with arugment -verbose
+     */
+    export const isVerboseModeTaon: () => boolean;
+    export const waitForUserAnyKey: (callback: () => void | Promise<void>, options?: {
+        /**
+         * by default, the action is only triggered once when a key is pressed.
+         * if this option is set, the action will be triggered on every key press.
+         * (Promise will not be resolved until process is killed)
+         */
+        triggerActionEveryKeypress?: boolean;
+    }) => Promise<void>;
+    export const getTerminalHeight: () => number;
+    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: SelectChoiceValue<T>[] | {
+            [choice: string]: SelectChoice;
+        };
+        autocomplete?: boolean;
+        /**
+         * at least one choice must be selected
+         */
+        required?: boolean;
+        defaultSelected?: string[];
+    }) => Promise<T[]>;
+    /**
+     * 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
+     */
+    export const selectActionAndExecute: <CHOICE extends SelectActionChoice = SelectActionChoice>(choices: CHOICE, options?: {
+        question?: string;
+        autocomplete?: boolean;
+        defaultSelected?: string;
+        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: {
+        question?: string;
+        choices: SelectChoiceValue<T>[] | {
+            [choice: string]: SelectChoice;
+        };
+        autocomplete?: boolean;
+        defaultSelected?: string;
+        hint?: string;
+    }) => Promise<T | undefined>;
+    export const pipeEnterToStdin: () => void;
+    export const input: ({ defaultValue, question, required, validate, }: {
+        defaultValue?: string;
+        question: string;
+        required?: boolean;
+        validate?: (value: string) => boolean;
+    }) => Promise<string>;
+    export const password: ({ question, required, validate, }: {
+        defaultValue?: string;
+        question: string;
+        required?: boolean;
+        validate?: (value: string) => boolean;
+    }) => Promise<string>;
+    export function canUseInteractiveToggle(): Promise<boolean>;
+    export function basicYesNo(message: string, defaultValue?: boolean): Promise<boolean>;
+    export const confirm: (options?: {
+        /**
+         * default: Are you sure?
+         */
+        message?: string;
+        callbackTrue?: () => any;
+        callbackFalse?: () => any;
+        /**
+         * default: true
+         */
+        defaultValue?: boolean;
+        engine?: "inquirer-toggle" | "prompts" | "enquirer" | "@inquirer/prompts";
+    }) => Promise<boolean>;
+    export const pressAnyKeyToContinueAsync: (options?: {
+        message?: string;
+    }) => Promise<void>;
+    /**
+     * @deprecated use UtilsTerminal.pressAnyKey
+     */
+    export const pressKeyAndContinueSync: (message?: string) => void;
+    /**
+     * @returns true if user wants to try again, false otherwise
+     */
+    export const pressAnyKeyToTryAgainErrorOccurred: (error: unknown) => Promise<boolean>;
+    /**
+     * @deprecated use UtilsTerminal.pressAnyKeyToContinueAsync()
+     */
+    export const pressAnyKey: (options?: {
+        message?: string;
+    }) => void;
+    export const previewLongList: (list: string | string[], listName?: string) => Promise<void>;
+    /**
+     * Displays a long list in the console using a pager like `less`.
+     * Returns a Promise that resolves when the user exits the pager.
+     *
+     * @param {string} list - The long string content to display.
+     * @returns {Promise<void>} A Promise that resolves when the pager exits.
+     */
+    export const previewLongListGitLogLike: (list: string | string[]) => Promise<void>;
+    export const drawBigText: (text: string, options?: {
+        skipDrawing?: boolean;
+        align?: CoreModels.CfontAlign;
+        style?: CoreModels.CfontStyle;
+    }) => Promise<string>;
+    export const drawVerticalLine: (col?: number) => void;
+    export const drawHorizontalLine: (col?: number) => void;
+    export function fetchAndDisplay<DataModel = any>(opt: {
+        fetchFn: () => Promise<DataModel[]>;
+        title: string;
+        refreshEveryMs?: number;
+        requestTimeoutMs?: number;
+        onTimeout?: () => void;
+    }): Promise<void>;
+    export {};
+}