@depup/nx 22.5.4-depup.0

package/src/utils/collapse-expanded-outputs.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collapseExpandedOutputs = collapseExpandedOutputs;
+const path_1 = require("path");
+/**
+ * Heuristic to prevent writing too many hash files
+ */
+const MAX_OUTPUTS_TO_CHECK_HASHES = 3;
+/**
+ * Collapses a list of file paths into a smaller set of parent directories
+ * when there are too many outputs to efficiently track individually.
+ *
+ * This prevents creating too many hash files by:
+ * 1. Building a tree structure of all path components
+ * 2. Finding the "collapse level" - the deepest level before exceeding MAX_OUTPUTS_TO_CHECK_HASHES
+ * 3. Returning parent paths at/above collapse level, while preserving leaf paths that terminate early
+ */
+function collapseExpandedOutputs(expandedOutputs) {
+    // Small output sets don't need collapsing
+    if (expandedOutputs.length <= MAX_OUTPUTS_TO_CHECK_HASHES) {
+        return [...expandedOutputs];
+    }
+    const tree = [];
+    // Create a Tree of directories/files
+    for (const output of expandedOutputs) {
+        const pathParts = [];
+        pathParts.unshift(output);
+        let dir = (0, path_1.dirname)(output);
+        while (dir !== (0, path_1.dirname)(dir)) {
+            pathParts.unshift(dir);
+            dir = (0, path_1.dirname)(dir);
+        }
+        for (let i = 0; i < pathParts.length; i++) {
+            tree[i] ??= new Set();
+            tree[i].add(pathParts[i]);
+        }
+    }
+    // Find collapse level: the level before the first level with too many outputs
+    let collapseLevel = tree.length - 1;
+    for (let j = 0; j < tree.length; j++) {
+        if (tree[j].size > MAX_OUTPUTS_TO_CHECK_HASHES) {
+            collapseLevel = Math.max(0, j - 1);
+            break;
+        }
+    }
+    // Collect paths, preserving leaf paths that terminate before collapse level
+    const result = new Set();
+    // Convert sets to arrays once for faster iteration
+    const levelArrays = [];
+    for (let i = 0; i <= collapseLevel + 1 && i < tree.length; i++) {
+        levelArrays[i] = Array.from(tree[i]);
+    }
+    for (let level = 0; level <= collapseLevel; level++) {
+        const nextLevelArray = levelArrays[level + 1];
+        for (const path of levelArrays[level]) {
+            let hasChildren = false;
+            if (nextLevelArray) {
+                for (const child of nextLevelArray) {
+                    if (child.startsWith(path + '/')) {
+                        hasChildren = true;
+                        break;
+                    }
+                }
+            }
+            // Include path if it's at collapse level or doesn't have children (leaf)
+            if (level === collapseLevel || !hasChildren) {
+                result.add(path);
+            }
+        }
+    }
+    return Array.from(result);
+}

package/src/utils/command-line-utils.d.ts

@@ -0,0 +1,58 @@
+import type { Arguments } from 'yargs';
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+export interface RawNxArgs extends NxArgs {
+    prod?: boolean;
+}
+export interface NxArgs {
+    targets?: string[];
+    configuration?: string;
+    /**
+     * @deprecated Custom task runners will be replaced by a new API starting with Nx 21. More info: https://nx.dev/deprecated/custom-tasks-runner
+     */
+    runner?: string;
+    parallel?: number;
+    untracked?: boolean;
+    uncommitted?: boolean;
+    all?: boolean;
+    base?: string;
+    head?: string;
+    exclude?: string[];
+    files?: string[];
+    verbose?: boolean;
+    help?: boolean;
+    version?: boolean;
+    plain?: boolean;
+    projects?: string[];
+    select?: string;
+    graph?: string | boolean;
+    skipNxCache?: boolean;
+    skipRemoteCache?: boolean;
+    outputStyle?: string;
+    tui?: boolean;
+    nxBail?: boolean;
+    nxIgnoreCycles?: boolean;
+    type?: string;
+    batch?: boolean;
+    excludeTaskDependencies?: boolean;
+    skipSync?: boolean;
+    sortRootTsconfigPaths?: boolean;
+}
+export declare function createOverrides(__overrides_unparsed__?: string[]): Record<string, any>;
+export declare function getBaseRef(nxJson: NxJsonConfiguration): string;
+export declare function splitArgsIntoNxArgsAndOverrides(args: {
+    [k: string]: any;
+}, mode: 'run-one' | 'run-many' | 'affected' | 'print-affected', options: {
+    printWarnings: boolean;
+}, nxJson: NxJsonConfiguration): {
+    nxArgs: NxArgs;
+    overrides: Arguments & {
+        __overrides_unparsed__: string[];
+    };
+};
+export declare function parseFiles(options: NxArgs): {
+    files: string[];
+};
+export declare function getProjectRoots(projectNames: string[], { nodes }: ProjectGraph): string[];
+export declare function readGraphFileFromGraphArg({ graph }: Pick<NxArgs, 'graph'>): string;
+//# sourceMappingURL=command-line-utils.d.ts.map

package/src/utils/command-line-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-line-utils.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/command-line-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAIvD,MAAM,WAAW,SAAU,SAAQ,MAAM;IACvC,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,MAAM;IACrB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,wBAAgB,eAAe,CAAC,sBAAsB,GAAE,MAAM,EAAO,uBAepE;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,mBAAmB,UAErD;AAED,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC1B,IAAI,EAAE,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,gBAAgB,EAC5D,OAAO;;CAA0B,EACjC,MAAM,EAAE,mBAAmB,GAC1B;IACD,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,SAAS,GAAG;QAAE,sBAAsB,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAC7D,CA4HA;AA4CD,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CA8B/D;AAuDD,wBAAgB,eAAe,CAC7B,YAAY,EAAE,MAAM,EAAE,EACtB,EAAE,KAAK,EAAE,EAAE,YAAY,GACtB,MAAM,EAAE,CAEV;AAED,wBAAgB,yBAAyB,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,UAIzE"}

package/src/utils/command-line-utils.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOverrides = createOverrides;
+exports.getBaseRef = getBaseRef;
+exports.splitArgsIntoNxArgsAndOverrides = splitArgsIntoNxArgsAndOverrides;
+exports.parseFiles = parseFiles;
+exports.getProjectRoots = getProjectRoots;
+exports.readGraphFileFromGraphArg = readGraphFileFromGraphArg;
+const yargsParser = require("yargs-parser");
+const file_utils_1 = require("../project-graph/file-utils");
+const output_1 = require("./output");
+const child_process_1 = require("child_process");
+const workspace_root_1 = require("./workspace-root");
+const shared_options_1 = require("../command-line/yargs-utils/shared-options");
+function createOverrides(__overrides_unparsed__ = []) {
+    let overrides = yargsParser(__overrides_unparsed__, {
+        configuration: {
+            'camel-case-expansion': false,
+            'dot-notation': true,
+        },
+    }) || {};
+    if (!overrides._ || overrides._.length === 0) {
+        delete overrides._;
+    }
+    overrides.__overrides_unparsed__ = __overrides_unparsed__;
+    return overrides;
+}
+function getBaseRef(nxJson) {
+    return nxJson.defaultBase ?? nxJson.affected?.defaultBase ?? 'main';
+}
+function splitArgsIntoNxArgsAndOverrides(args, mode, options = { printWarnings: true }, nxJson) {
+    // this is to lerna case when this function is invoked imperatively
+    if (args['target'] && !args['targets']) {
+        args['targets'] = [args['target']];
+    }
+    delete args['target'];
+    delete args['t'];
+    if (!args.__overrides_unparsed__ && args._) {
+        // required for backwards compatibility
+        args.__overrides_unparsed__ = args._;
+        delete args._;
+    }
+    // This handles the way Lerna passes in overrides
+    if (!args.__overrides_unparsed__ && args.__overrides__) {
+        // required for backwards compatibility
+        args.__overrides_unparsed__ = args.__overrides__;
+        delete args._;
+    }
+    const nxArgs = args;
+    let overrides = createOverrides(args.__overrides_unparsed__);
+    delete nxArgs.$0;
+    delete nxArgs.__overrides_unparsed__;
+    if (mode === 'run-many') {
+        const args = nxArgs;
+        if (!args.projects) {
+            args.projects = [];
+        }
+        else if (typeof args.projects === 'string') {
+            args.projects = args.projects.split(',');
+        }
+    }
+    if (nxArgs.prod) {
+        delete nxArgs.prod;
+        nxArgs.configuration = 'production';
+    }
+    if (mode === 'affected') {
+        if (options.printWarnings && nxArgs.all) {
+            output_1.output.warn({
+                title: `Running affected:* commands with --all can result in very slow builds.`,
+                bodyLines: [
+                    `${output_1.output.bold('--all')} is not meant to be used for any sizable project or to be used in CI.`,
+                    '',
+                    `${output_1.output.dim('Learn more about checking only what is affected: https://nx.dev/nx/affected')}`,
+                ],
+            });
+        }
+        // Allow setting base and head via environment variables (lower priority than direct command arguments)
+        if (!nxArgs.base && process.env.NX_BASE) {
+            nxArgs.base = process.env.NX_BASE;
+            if (options.printWarnings) {
+                output_1.output.note({
+                    title: `No explicit --base argument provided, but found environment variable NX_BASE so using its value as the affected base: ${output_1.output.bold(`${nxArgs.base}`)}`,
+                });
+            }
+        }
+        if (!nxArgs.head && process.env.NX_HEAD) {
+            nxArgs.head = process.env.NX_HEAD;
+            if (options.printWarnings) {
+                output_1.output.note({
+                    title: `No explicit --head argument provided, but found environment variable NX_HEAD so using its value as the affected head: ${output_1.output.bold(`${nxArgs.head}`)}`,
+                });
+            }
+        }
+        if (!nxArgs.base) {
+            nxArgs.base = getBaseRef(nxJson);
+            // No user-provided arguments to set the affected criteria, so inform the user of the defaults being used
+            if (options.printWarnings &&
+                !nxArgs.head &&
+                !nxArgs.files &&
+                !nxArgs.uncommitted &&
+                !nxArgs.untracked &&
+                !nxArgs.all) {
+                output_1.output.note({
+                    title: `Affected criteria defaulted to --base=${output_1.output.bold(`${nxArgs.base}`)} --head=${output_1.output.bold('HEAD')}`,
+                });
+            }
+        }
+        if (nxArgs.base) {
+            nxArgs.base = getMergeBase(nxArgs.base, nxArgs.head);
+        }
+    }
+    if (typeof args.exclude === 'string') {
+        nxArgs.exclude = args.exclude.split(',');
+    }
+    if (!nxArgs.skipNxCache) {
+        nxArgs.skipNxCache =
+            process.env.NX_SKIP_NX_CACHE === 'true' ||
+                process.env.NX_DISABLE_NX_CACHE === 'true';
+    }
+    if (!nxArgs.skipRemoteCache) {
+        nxArgs.skipRemoteCache =
+            process.env.NX_DISABLE_REMOTE_CACHE === 'true' ||
+                process.env.NX_SKIP_REMOTE_CACHE === 'true';
+    }
+    normalizeNxArgsRunner(nxArgs, nxJson, options);
+    nxArgs['parallel'] = (0, shared_options_1.readParallelFromArgsAndEnv)(args);
+    return { nxArgs, overrides };
+}
+function normalizeNxArgsRunner(nxArgs, nxJson, options) {
+    if (!nxArgs.runner) {
+        const envKey = 'NX_TASKS_RUNNER';
+        const runner = process.env[envKey];
+        if (runner) {
+            const runnerExists = nxJson.tasksRunnerOptions?.[runner];
+            if (options.printWarnings) {
+                if (runnerExists) {
+                    output_1.output.note({
+                        title: `No explicit --runner argument provided, but found environment variable ${envKey} so using its value: ${output_1.output.bold(`${runner}`)}`,
+                    });
+                }
+                else if (nxArgs.verbose ||
+                    process.env.NX_VERBOSE_LOGGING === 'true') {
+                    output_1.output.warn({
+                        title: `Could not find ${output_1.output.bold(`${runner}`)} within \`nx.json\` tasksRunnerOptions.`,
+                        bodyLines: [
+                            `${output_1.output.bold(`${runner}`)} was set by ${envKey}`,
+                            ``,
+                            `To suppress this message, either:`,
+                            `  - provide a valid task runner with --runner`,
+                            `  - ensure NX_TASKS_RUNNER matches a task runner defined in nx.json`,
+                        ],
+                    });
+                }
+            }
+            if (runnerExists) {
+                nxArgs.runner = runner;
+            }
+        }
+    }
+}
+function parseFiles(options) {
+    const { files, uncommitted, untracked, base, head } = options;
+    if (files) {
+        return {
+            files,
+        };
+    }
+    else if (uncommitted) {
+        return {
+            files: getUncommittedFiles(),
+        };
+    }
+    else if (untracked) {
+        return {
+            files: getUntrackedFiles(),
+        };
+    }
+    else if (base && head) {
+        return {
+            files: getFilesUsingBaseAndHead(base, head),
+        };
+    }
+    else if (base) {
+        return {
+            files: Array.from(new Set([
+                ...getFilesUsingBaseAndHead(base, 'HEAD'),
+                ...getUncommittedFiles(),
+                ...getUntrackedFiles(),
+            ])),
+        };
+    }
+}
+function getUncommittedFiles() {
+    return parseGitOutput(`git diff --name-only --no-renames --relative HEAD .`);
+}
+function getUntrackedFiles() {
+    return parseGitOutput(`git ls-files --others --exclude-standard`);
+}
+function getMergeBase(base, head = 'HEAD') {
+    try {
+        return (0, child_process_1.execSync)(`git merge-base "${base}" "${head}"`, {
+            maxBuffer: file_utils_1.TEN_MEGABYTES,
+            cwd: workspace_root_1.workspaceRoot,
+            stdio: 'pipe',
+            windowsHide: false,
+        })
+            .toString()
+            .trim();
+    }
+    catch {
+        try {
+            return (0, child_process_1.execSync)(`git merge-base --fork-point "${base}" "${head}"`, {
+                maxBuffer: file_utils_1.TEN_MEGABYTES,
+                cwd: workspace_root_1.workspaceRoot,
+                stdio: 'pipe',
+                windowsHide: false,
+            })
+                .toString()
+                .trim();
+        }
+        catch {
+            return base;
+        }
+    }
+}
+function getFilesUsingBaseAndHead(base, head) {
+    return parseGitOutput(`git diff --name-only --no-renames --relative "${base}" "${head}"`);
+}
+function parseGitOutput(command) {
+    return (0, child_process_1.execSync)(command, {
+        maxBuffer: file_utils_1.TEN_MEGABYTES,
+        cwd: workspace_root_1.workspaceRoot,
+        stdio: 'pipe',
+        windowsHide: false,
+    })
+        .toString('utf-8')
+        .split('\n')
+        .map((a) => a.trim())
+        .filter((a) => a.length > 0);
+}
+function getProjectRoots(projectNames, { nodes }) {
+    return projectNames.map((name) => nodes[name].data.root);
+}
+function readGraphFileFromGraphArg({ graph }) {
+    return typeof graph === 'string' && graph !== 'true' && graph !== ''
+        ? graph
+        : undefined;
+}

package/src/utils/consume-messages-from-socket.d.ts

@@ -0,0 +1,4 @@
+export declare const MESSAGE_END_SEQ: string;
+export declare function consumeMessagesFromSocket(callback: (message: string) => void): (data: any) => void;
+export declare function isJsonMessage(message: string): boolean;
+//# sourceMappingURL=consume-messages-from-socket.d.ts.map

package/src/utils/consume-messages-from-socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consume-messages-from-socket.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/consume-messages-from-socket.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe,QACuB,CAAC;AAEpD,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,IAGnE,SAAI,UA4Bb;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAYtD"}

package/src/utils/consume-messages-from-socket.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MESSAGE_END_SEQ = void 0;
+exports.consumeMessagesFromSocket = consumeMessagesFromSocket;
+exports.isJsonMessage = isJsonMessage;
+const string_decoder_1 = require("string_decoder");
+const VERY_END_CODE = 4;
+exports.MESSAGE_END_SEQ = 'NX_MSG_END' + String.fromCharCode(VERY_END_CODE);
+function consumeMessagesFromSocket(callback) {
+    let message = '';
+    const decoder = new string_decoder_1.StringDecoder('utf8');
+    return (data) => {
+        const chunk = decoder.write(data);
+        message += chunk;
+        // Check if accumulated message ends with MESSAGE_END_SEQ (not just the chunk)
+        // This handles TCP packet fragmentation where MESSAGE_END_SEQ may be split across packets
+        if (chunk.codePointAt(chunk.length - 1) === VERY_END_CODE &&
+            message.endsWith(exports.MESSAGE_END_SEQ)) {
+            // Remove the trailing MESSAGE_END_SEQ
+            const fullMessage = message.substring(0, message.length - exports.MESSAGE_END_SEQ.length);
+            // Server may send multiple messages in one chunk, so splitting by MESSAGE_END_SEQ
+            const messages = fullMessage.split(exports.MESSAGE_END_SEQ);
+            for (const splitMessage of messages) {
+                if (splitMessage) {
+                    callback(splitMessage);
+                }
+            }
+            message = '';
+        }
+        // If message doesn't end with MESSAGE_END_SEQ, keep accumulating chunks
+    };
+}
+function isJsonMessage(message) {
+    return (
+    // json objects
+    ['[', '{'].some((prefix) => message.startsWith(prefix)) ||
+        // booleans
+        message === 'true' ||
+        message === 'false' ||
+        // strings
+        (message.startsWith('"') && message.endsWith('"')) ||
+        // numbers
+        /^[0-9]+(\.?[0-9]+)?$/.test(message));
+}

package/src/utils/db-connection.d.ts

@@ -0,0 +1,7 @@
+import { ExternalObject } from '../native';
+export declare function getDbConnection(opts?: {
+    directory?: string;
+    dbName?: string;
+}): ExternalObject<NxDbConnection>;
+export declare function removeDbConnections(): void;
+//# sourceMappingURL=db-connection.d.ts.map

package/src/utils/db-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-connection.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/db-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,cAAc,EAAE,MAAM,WAAW,CAAC;AAM7E,wBAAgB,eAAe,CAC7B,IAAI,GAAE;IACJ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACZ,kCAQP;AAED,wBAAgB,mBAAmB,SAKlC"}

package/src/utils/db-connection.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDbConnection = getDbConnection;
+exports.removeDbConnections = removeDbConnections;
+const native_1 = require("../native");
+const cache_directory_1 = require("./cache-directory");
+const package_json_1 = require("../../package.json");
+const dbConnectionMap = new Map();
+function getDbConnection(opts = {}) {
+    opts.directory ??= cache_directory_1.workspaceDataDirectory;
+    const key = `${opts.directory}:${opts.dbName ?? 'default'}`;
+    const connection = getEntryOrSet(dbConnectionMap, key, () => (0, native_1.connectToNxDb)(opts.directory, package_json_1.version, opts.dbName));
+    return connection;
+}
+function removeDbConnections() {
+    for (const connection of dbConnectionMap.values()) {
+        (0, native_1.closeDbConnection)(connection);
+    }
+    dbConnectionMap.clear();
+}
+function getEntryOrSet(map, key, defaultValue) {
+    const existing = map.get(key);
+    if (existing) {
+        return existing;
+    }
+    const val = defaultValue();
+    map.set(key, val);
+    return val;
+}

package/src/utils/default-base.d.ts

@@ -0,0 +1,2 @@
+export declare function deduceDefaultBase(): string;
+//# sourceMappingURL=default-base.d.ts.map

package/src/utils/default-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-base.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/default-base.ts"],"names":[],"mappings":"AAEA,wBAAgB,iBAAiB,IAAI,MAAM,CAa1C"}

package/src/utils/default-base.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduceDefaultBase = deduceDefaultBase;
+const child_process_1 = require("child_process");
+function deduceDefaultBase() {
+    const nxDefaultBase = 'main';
+    try {
+        return ((0, child_process_1.execSync)('git config --get init.defaultBranch', {
+            windowsHide: false,
+        })
+            .toString()
+            .trim() || nxDefaultBase);
+    }
+    catch {
+        return nxDefaultBase;
+    }
+}

package/src/utils/delayed-spinner.d.ts

@@ -0,0 +1,43 @@
+import { globalSpinner } from './spinner';
+export type DelayedSpinnerOptions = {
+    delay?: number;
+    ciDelay?: number;
+};
+/**
+ * A class that allows to delay the creation of a spinner, as well
+ * as schedule updates to the message of the spinner. Useful for
+ * scenarios where one wants to only show a spinner if an operation
+ * takes longer than a certain amount of time.
+ */
+export declare class DelayedSpinner {
+    spinner: typeof globalSpinner;
+    timeouts: NodeJS.Timeout[];
+    private lastMessage;
+    private ready;
+    /**
+     * Constructs a new {@link DelayedSpinner} instance.
+     *
+     * @param opts The options for the spinner
+     */
+    constructor(message: string, opts?: DelayedSpinnerOptions);
+    /**
+     * Sets the message to display in the spinner.
+     *
+     * @param message The message to display in the spinner
+     * @returns The {@link DelayedSpinner} instance
+     */
+    setMessage(message: string): this;
+    /**
+     * Schedules an update to the message of the spinner. Useful for
+     * changing the message after a certain amount of time has passed.
+     *
+     * @param opts The options for the update
+     * @returns The {@link DelayedSpinner} instance
+     */
+    scheduleMessageUpdate(message: string, opts?: DelayedSpinnerOptions): this;
+    /**
+     * Stops the spinner and cleans up any scheduled timeouts.
+     */
+    cleanup(): void;
+}
+//# sourceMappingURL=delayed-spinner.d.ts.map

package/src/utils/delayed-spinner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delayed-spinner.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/delayed-spinner.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAwB,MAAM,WAAW,CAAC;AAEhE,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,cAAc;IACzB,OAAO,EAAE,OAAO,aAAa,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC,OAAO,EAAE,CAAM;IAEhC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,KAAK,CAAU;IAEvB;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,qBAAqB;IAiBzD;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM;IAY1B;;;;;;OAMG;IACH,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,qBAAqB;IAanE;;OAEG;IACH,OAAO;CAIR"}

package/src/utils/delayed-spinner.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelayedSpinner = void 0;
+const spinner_1 = require("./spinner");
+/**
+ * A class that allows to delay the creation of a spinner, as well
+ * as schedule updates to the message of the spinner. Useful for
+ * scenarios where one wants to only show a spinner if an operation
+ * takes longer than a certain amount of time.
+ */
+class DelayedSpinner {
+    /**
+     * Constructs a new {@link DelayedSpinner} instance.
+     *
+     * @param opts The options for the spinner
+     */
+    constructor(message, opts) {
+        this.timeouts = [];
+        opts = normalizeDelayedSpinnerOpts(opts);
+        const delay = spinner_1.SHOULD_SHOW_SPINNERS ? opts.delay : opts.ciDelay;
+        this.timeouts.push(setTimeout(() => {
+            this.ready = true;
+            this.lastMessage = message;
+            if (!spinner_1.SHOULD_SHOW_SPINNERS) {
+                console.warn(this.lastMessage);
+            }
+            else if (!spinner_1.globalSpinner.isSpinning()) {
+                this.spinner = spinner_1.globalSpinner.start(this.lastMessage);
+            }
+        }, delay).unref());
+    }
+    /**
+     * Sets the message to display in the spinner.
+     *
+     * @param message The message to display in the spinner
+     * @returns The {@link DelayedSpinner} instance
+     */
+    setMessage(message) {
+        if (spinner_1.SHOULD_SHOW_SPINNERS) {
+            if (this.spinner) {
+                this.spinner.updateText(message);
+            }
+        }
+        else if (this.ready && this.lastMessage && this.lastMessage !== message) {
+            console.warn(message);
+        }
+        this.lastMessage = message;
+        return this;
+    }
+    /**
+     * Schedules an update to the message of the spinner. Useful for
+     * changing the message after a certain amount of time has passed.
+     *
+     * @param opts The options for the update
+     * @returns The {@link DelayedSpinner} instance
+     */
+    scheduleMessageUpdate(message, opts) {
+        opts = normalizeDelayedSpinnerOpts(opts);
+        this.timeouts.push(setTimeout(() => {
+            this.setMessage(message);
+        }, spinner_1.SHOULD_SHOW_SPINNERS ? opts.delay : opts.ciDelay).unref());
+        return this;
+    }
+    /**
+     * Stops the spinner and cleans up any scheduled timeouts.
+     */
+    cleanup() {
+        this.spinner?.stop();
+        this.timeouts.forEach((t) => clearTimeout(t));
+    }
+}
+exports.DelayedSpinner = DelayedSpinner;
+function normalizeDelayedSpinnerOpts(opts) {
+    opts ??= {};
+    opts.delay ??= 500;
+    opts.ciDelay ??= 30_000;
+    return opts;
+}

package/src/utils/dotenv.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This loads dotenv files from:
+ * - .env
+ * - .local.env
+ * - .env.local
+ */
+export declare function loadRootEnvFiles(root?: string): void;
+//# sourceMappingURL=dotenv.d.ts.map

package/src/utils/dotenv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dotenv.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/utils/dotenv.ts"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,SAAgB,QAOpD"}

package/src/utils/dotenv.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRootEnvFiles = loadRootEnvFiles;
+const dotenv_1 = require("dotenv");
+const dotenv_expand_1 = require("dotenv-expand");
+const workspace_root_1 = require("./workspace-root");
+const path_1 = require("path");
+/**
+ * This loads dotenv files from:
+ * - .env
+ * - .local.env
+ * - .env.local
+ */
+function loadRootEnvFiles(root = workspace_root_1.workspaceRoot) {
+    for (const file of ['.local.env', '.env.local', '.env']) {
+        const myEnv = (0, dotenv_1.config)({
+            path: (0, path_1.join)(root, file),
+        });
+        (0, dotenv_expand_1.expand)(myEnv);
+    }
+}