nx 20.8.4 → 22.7.7

package/dist/src/command-line/nx-cloud/login/command-object.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsLoginCommand = void 0;
+const shared_options_1 = require("../../yargs-utils/shared-options");
+const handle_import_1 = require("../../../utils/handle-import");
+exports.yargsLoginCommand = {
+    command: 'login [nxCloudUrl]',
+    describe: 'Login to Nx Cloud. This command is an alias for `nx-cloud login`.',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs.positional('nxCloudUrl', {
+        describe: 'The Nx Cloud URL of the instance you are trying to connect to. If no positional argument is provided, this command will connect to your configured Nx Cloud instance by default.',
+        type: 'string',
+        required: false,
+    }))
+        .help(false)
+        .showHelpOnFail(false)
+        .option('help', { describe: 'Show help.', type: 'boolean' }),
+    handler: async (args) => {
+        process.exit(await (await (0, handle_import_1.handleImport)('./login.js', __dirname)).loginHandler(args));
+    },
+};

package/dist/src/command-line/nx-cloud/login/login.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginHandler = loginHandler;
+const utils_1 = require("../utils");
+function loginHandler(args) {
+    if (args.nxCloudUrl) {
+        process.env.NX_CLOUD_API = args.nxCloudUrl;
+    }
+    return (0, utils_1.executeNxCloudCommand)('login', args.verbose);
+}

package/dist/src/command-line/nx-cloud/logout/command-object.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsLogoutCommand = void 0;
+const handle_import_1 = require("../../../utils/handle-import");
+const shared_options_1 = require("../../yargs-utils/shared-options");
+exports.yargsLogoutCommand = {
+    command: 'logout',
+    describe: 'Logout from Nx Cloud. This command is an alias for `nx-cloud logout`.',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs)
+        .help(false)
+        .showHelpOnFail(false)
+        .option('help', { describe: 'Show help.', type: 'boolean' }),
+    handler: async (args) => {
+        process.exit(await (await (0, handle_import_1.handleImport)('./logout.js', __dirname)).logoutHandler(args));
+    },
+};

package/dist/src/command-line/nx-cloud/logout/logout.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logoutHandler = logoutHandler;
+const utils_1 = require("../utils");
+function logoutHandler(args) {
+    return (0, utils_1.executeNxCloudCommand)('logout', args.verbose);
+}

package/dist/src/command-line/nx-cloud/record/command-object.d.ts

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const yargsRecordCommand: CommandModule;

package/dist/src/command-line/nx-cloud/record/command-object.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsRecordCommand = void 0;
+const handle_import_1 = require("../../../utils/handle-import");
+const shared_options_1 = require("../../yargs-utils/shared-options");
+exports.yargsRecordCommand = {
+    command: 'record [options]',
+    describe: 'Records a command execution for distributed task execution. This command is an alias for [`nx-cloud record`](/ci/reference/nx-cloud-cli#npx-nxcloud-record).',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs)
+        .parserConfiguration({
+        'populate--': true,
+    })
+        .help(false)
+        .showHelpOnFail(false)
+        .option('help', { describe: 'Show help.', type: 'boolean' }),
+    handler: async (args) => {
+        process.exit(await (await (0, handle_import_1.handleImport)('./record.js', __dirname)).recordHandler(args));
+    },
+};

package/dist/src/command-line/nx-cloud/record/record.d.ts

@@ -0,0 +1,5 @@
+export interface RecordArgs {
+    verbose?: boolean;
+    '--'?: string[];
+}
+export declare function recordHandler(args: RecordArgs): Promise<number>;

package/dist/src/command-line/nx-cloud/record/record.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordHandler = recordHandler;
+const child_process_1 = require("child_process");
+const nx_json_1 = require("../../../config/nx-json");
+const output_1 = require("../../../utils/output");
+const nx_cloud_utils_1 = require("../../../utils/nx-cloud-utils");
+const utils_1 = require("../utils");
+function recordHandler(args) {
+    if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
+        let exitCode = 0;
+        const commandArgs = args['--'];
+        if (commandArgs && commandArgs.length > 0) {
+            const [cmd, ...cmdArgs] = commandArgs;
+            const result = (0, child_process_1.spawnSync)(cmd, cmdArgs, {
+                stdio: 'inherit',
+                shell: true,
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+                windowsHide: true,
+            });
+            exitCode = result.status ?? 1;
+        }
+        output_1.output.warn({
+            title: 'Nx Cloud is not enabled',
+            bodyLines: [
+                'To record command using Nx Cloud, connect your workspace with `nx connect`.',
+            ],
+        });
+        return Promise.resolve(exitCode);
+    }
+    return (0, utils_1.executeNxCloudCommand)('record', args.verbose);
+}

package/dist/src/command-line/nx-cloud/start-agent/command-object.d.ts

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const yargsStartAgentCommand: CommandModule;

package/dist/src/command-line/nx-cloud/start-agent/command-object.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsStartAgentCommand = void 0;
+const handle_import_1 = require("../../../utils/handle-import");
+const shared_options_1 = require("../../yargs-utils/shared-options");
+exports.yargsStartAgentCommand = {
+    command: 'start-agent [options]',
+    describe: 'Starts a new agent for distributed task execution. This command is an alias for [`nx-cloud start-agent`](/docs/reference/nx-cloud-cli).',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs)
+        .help(false)
+        .showHelpOnFail(false)
+        .option('help', { describe: 'Show help.', type: 'boolean' }),
+    handler: async (args) => {
+        process.exit(await (await (0, handle_import_1.handleImport)('./start-agent.js', __dirname)).startAgentHandler(args));
+    },
+};

package/dist/src/command-line/nx-cloud/start-agent/start-agent.d.ts

@@ -0,0 +1,4 @@
+export interface StartAgentArgs {
+    verbose?: boolean;
+}
+export declare function startAgentHandler(args: StartAgentArgs): Promise<number>;

package/dist/src/command-line/nx-cloud/start-agent/start-agent.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startAgentHandler = startAgentHandler;
+const nx_json_1 = require("../../../config/nx-json");
+const nx_cloud_utils_1 = require("../../../utils/nx-cloud-utils");
+const utils_1 = require("../utils");
+function startAgentHandler(args) {
+    if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
+        (0, utils_1.warnNotConnectedToCloud)();
+        return Promise.resolve(0);
+    }
+    return (0, utils_1.executeNxCloudCommand)('start-agent', args.verbose);
+}

package/dist/src/command-line/nx-cloud/start-ci-run/command-object.d.ts

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const yargsStartCiRunCommand: CommandModule;

package/dist/src/command-line/nx-cloud/start-ci-run/command-object.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsStartCiRunCommand = void 0;
+const handle_import_1 = require("../../../utils/handle-import");
+const shared_options_1 = require("../../yargs-utils/shared-options");
+exports.yargsStartCiRunCommand = {
+    command: 'start-ci-run [options]',
+    describe: 'Starts a new CI run for distributed task execution. This command is an alias for [`nx-cloud start-ci-run`](/docs/reference/nx-cloud-cli#npx-nxcloud-start-ci-run).',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs)
+        .help(false)
+        .showHelpOnFail(false)
+        .option('help', { describe: 'Show help.', type: 'boolean' }),
+    handler: async (args) => {
+        process.exit(await (await (0, handle_import_1.handleImport)('./start-ci-run.js', __dirname)).startCiRunHandler(args));
+    },
+};

package/dist/src/command-line/nx-cloud/start-ci-run/start-ci-run.d.ts

@@ -0,0 +1,4 @@
+export interface StartCiRunArgs {
+    verbose?: boolean;
+}
+export declare function startCiRunHandler(args: StartCiRunArgs): Promise<number>;

package/dist/src/command-line/nx-cloud/start-ci-run/start-ci-run.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startCiRunHandler = startCiRunHandler;
+const nx_json_1 = require("../../../config/nx-json");
+const nx_cloud_utils_1 = require("../../../utils/nx-cloud-utils");
+const utils_1 = require("../utils");
+function startCiRunHandler(args) {
+    if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
+        (0, utils_1.warnNotConnectedToCloud)();
+        return Promise.resolve(0);
+    }
+    return (0, utils_1.executeNxCloudCommand)('start-ci-run', args.verbose);
+}

package/dist/src/command-line/nx-cloud/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function warnNotConnectedToCloud(): void;
+export declare function executeNxCloudCommand(commandName: string, verbose?: boolean): Promise<number>;

package/dist/src/command-line/nx-cloud/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnNotConnectedToCloud = warnNotConnectedToCloud;
+exports.executeNxCloudCommand = executeNxCloudCommand;
+const update_manager_1 = require("../../nx-cloud/update-manager");
+const get_cloud_options_1 = require("../../nx-cloud/utilities/get-cloud-options");
+const handle_errors_1 = require("../../utils/handle-errors");
+const resolution_helpers_1 = require("../../nx-cloud/resolution-helpers");
+const output_1 = require("../../utils/output");
+function warnNotConnectedToCloud() {
+    output_1.output.warn({
+        title: 'Nx Cloud is not enabled',
+        bodyLines: [
+            'This command requires a connection to the full Nx platform.',
+            'Run `nx connect` to connect your workspace.',
+        ],
+    });
+}
+function tryGetCloudOptions() {
+    try {
+        return (0, get_cloud_options_1.getCloudOptions)();
+    }
+    catch {
+        return {};
+    }
+}
+async function executeNxCloudCommand(commandName, verbose) {
+    return (0, handle_errors_1.handleErrors)(verbose, async () => {
+        const nxCloudClient = (await (0, update_manager_1.verifyOrUpdateNxCloudClient)(tryGetCloudOptions())).nxCloudClient;
+        const paths = (0, resolution_helpers_1.findAncestorNodeModules)(__dirname, []);
+        nxCloudClient.configureLightClientRequire()(paths);
+        await nxCloudClient.commands[commandName]();
+    });
+}

package/dist/src/command-line/nx-commands.d.ts

@@ -0,0 +1,10 @@
+import * as yargs from 'yargs';
+export declare const parserConfiguration: Partial<yargs.ParserConfigurationOptions>;
+/**
+ * Exposing the Yargs commands object so the documentation generator can
+ * parse it. The CLI will consume it and call the `.argv` to bootstrapped
+ * the CLI. These command declarations needs to be in a different file
+ * from the `.argv` call, so the object and it's relative scripts can
+ * be executed correctly.
+ */
+export declare const commandsObject: yargs.Argv<unknown>;

package/dist/src/command-line/nx-commands.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandsObject = exports.parserConfiguration = void 0;
+const tslib_1 = require("tslib");
+const pc = tslib_1.__importStar(require("picocolors"));
+const yargs = tslib_1.__importStar(require("yargs"));
+const analytics_1 = require("../analytics");
+const output_1 = require("../utils/output");
+const command_object_1 = require("./add/command-object");
+const command_object_2 = require("./affected/command-object");
+const command_object_3 = require("./configure-ai-agents/command-object");
+const command_object_4 = require("./daemon/command-object");
+const command_objects_1 = require("./deprecated/command-objects");
+const command_object_5 = require("./exec/command-object");
+const command_object_6 = require("./format/command-object");
+const command_object_7 = require("./generate/command-object");
+const command_object_8 = require("./graph/command-object");
+const command_object_9 = require("./import/command-object");
+const command_object_10 = require("./init/command-object");
+const command_object_11 = require("./list/command-object");
+const command_object_12 = require("./mcp/command-object");
+const command_object_13 = require("./migrate/command-object");
+const command_object_14 = require("./new/command-object");
+const command_object_15 = require("./nx-cloud/apply-locally/command-object");
+const command_object_16 = require("./nx-cloud/complete-run/command-object");
+const command_object_17 = require("./nx-cloud/connect/command-object");
+const command_object_18 = require("./nx-cloud/download-cloud-client/command-object");
+const command_object_19 = require("./nx-cloud/fix-ci/command-object");
+const command_object_20 = require("./nx-cloud/login/command-object");
+const command_object_21 = require("./nx-cloud/logout/command-object");
+const command_object_22 = require("./nx-cloud/record/command-object");
+const command_object_23 = require("./nx-cloud/start-agent/command-object");
+const command_object_24 = require("./nx-cloud/start-ci-run/command-object");
+const command_object_25 = require("./register/command-object");
+const command_object_26 = require("./release/command-object");
+const command_object_27 = require("./repair/command-object");
+const command_object_28 = require("./report/command-object");
+const command_object_29 = require("./reset/command-object");
+const command_object_30 = require("./run-many/command-object");
+const command_object_31 = require("./run/command-object");
+const command_object_32 = require("./show/command-object");
+const command_object_33 = require("./sync/command-object");
+const command_object_34 = require("./watch/command-object");
+// Ensure that the output takes up the available width of the terminal.
+yargs.wrap(yargs.terminalWidth());
+exports.parserConfiguration = {
+    'strip-dashed': true,
+};
+/**
+ * Exposing the Yargs commands object so the documentation generator can
+ * parse it. The CLI will consume it and call the `.argv` to bootstrapped
+ * the CLI. These command declarations needs to be in a different file
+ * from the `.argv` call, so the object and it's relative scripts can
+ * be executed correctly.
+ */
+exports.commandsObject = yargs
+    .parserConfiguration(exports.parserConfiguration)
+    .usage(pc.bold('Smart Monorepos · Fast Builds'))
+    .demandCommand(1, '')
+    .command(command_object_25.yargsRegisterCommand)
+    .command(command_object_1.yargsAddCommand)
+    .command(command_object_3.yargsConfigureAiAgentsCommand)
+    .command(command_object_2.yargsAffectedBuildCommand)
+    .command(command_object_2.yargsAffectedCommand)
+    .command(command_object_2.yargsAffectedE2ECommand)
+    .command(command_object_2.yargsAffectedLintCommand)
+    .command(command_object_2.yargsAffectedTestCommand)
+    .command(command_objects_1.yargsAffectedGraphCommand)
+    .command(command_object_17.yargsConnectCommand)
+    .command(command_object_4.yargsDaemonCommand)
+    .command(command_object_8.yargsGraphCommand)
+    .command(command_object_5.yargsExecCommand)
+    .command(command_object_6.yargsFormatCheckCommand)
+    .command(command_object_6.yargsFormatWriteCommand)
+    .command(command_object_7.yargsGenerateCommand)
+    .command(command_object_9.yargsImportCommand)
+    .command(command_object_10.yargsInitCommand)
+    .command(command_object_13.yargsInternalMigrateCommand)
+    .command(command_object_11.yargsListCommand)
+    .command(command_object_13.yargsMigrateCommand)
+    .command(command_object_14.yargsNewCommand)
+    .command(command_objects_1.yargsPrintAffectedCommand)
+    .command(command_object_26.yargsReleaseCommand)
+    .command(command_object_27.yargsRepairCommand)
+    .command(command_object_28.yargsReportCommand)
+    .command(command_object_29.yargsResetCommand)
+    .command(command_object_31.yargsRunCommand)
+    .command(command_object_30.yargsRunManyCommand)
+    .command(command_object_32.yargsShowCommand)
+    .command(command_object_33.yargsSyncCommand)
+    .command(command_object_33.yargsSyncCheckCommand)
+    .command(command_object_17.yargsViewLogsCommand)
+    .command(command_object_34.yargsWatchCommand)
+    .command(command_object_31.yargsNxInfixCommand)
+    .command(command_object_20.yargsLoginCommand)
+    .command(command_object_21.yargsLogoutCommand)
+    .command(command_object_22.yargsRecordCommand)
+    .command(command_object_24.yargsStartCiRunCommand)
+    .command(command_object_23.yargsStartAgentCommand)
+    .command(command_object_16.yargsStopAllAgentsCommand)
+    .command(command_object_19.yargsFixCiCommand)
+    .command(command_object_15.yargsApplyLocallyCommand)
+    .command(command_object_18.yargsDownloadCloudClientCommand)
+    .command(command_object_12.yargsMcpCommand)
+    .command(resolveConformanceCommandObject())
+    .command(resolveConformanceCheckCommandObject())
+    .scriptName('nx')
+    .middleware((args) => {
+    const context = exports.commandsObject.getInternalMethods().getContext();
+    const command = (context.commands ?? []).join(' ') ||
+        (args._ ?? []).slice(0, 1).join(' ');
+    if (command) {
+        (0, analytics_1.reportCommandRunEvent)(command, undefined, args);
+    }
+})
+    .help(false)
+    // NOTE: we handle --version in nx.ts, this just tells yargs that the option exists
+    // so that it shows up in help. The default yargs implementation of --version is not
+    // hit, as the implementation in nx.ts is hit first and calls process.exit(0).
+    .version();
+function createMissingConformanceCommand(command) {
+    return {
+        command,
+        // Hide from --help output in the common case of not having the plugin installed
+        describe: false,
+        handler: () => {
+            output_1.output.error({
+                title: `${command} is not available`,
+                bodyLines: [
+                    `In order to use the \`nx ${command}\` command you must have an active Nx key and the \`@nx/conformance\` plugin installed.`,
+                    '',
+                    'To learn more, visit https://nx.dev/nx-enterprise/powerpack/conformance',
+                ],
+            });
+            process.exit(1);
+        },
+    };
+}
+function resolveConformanceCommandObject() {
+    try {
+        const { yargsConformanceCommand } = (() => {
+            try {
+                return require('@nx/powerpack-conformance');
+            }
+            catch {
+                return require('@nx/conformance');
+            }
+        })();
+        return yargsConformanceCommand;
+    }
+    catch {
+        return createMissingConformanceCommand('conformance');
+    }
+}
+function resolveConformanceCheckCommandObject() {
+    try {
+        const { yargsConformanceCheckCommand } = (() => {
+            try {
+                return require('@nx/powerpack-conformance');
+            }
+            catch {
+                return require('@nx/conformance');
+            }
+        })();
+        return yargsConformanceCheckCommand;
+    }
+    catch {
+        return createMissingConformanceCommand('conformance:check');
+    }
+}

package/dist/src/command-line/register/command-object.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsRegisterCommand = void 0;
+const handle_import_1 = require("../../utils/handle-import");
+const shared_options_1 = require("../yargs-utils/shared-options");
+const handle_errors_1 = require("../../utils/handle-errors");
+exports.yargsRegisterCommand = {
+    command: 'register [key]',
+    aliases: ['activate-powerpack'],
+    describe: false,
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs)
+        .parserConfiguration({
+        'strip-dashed': true,
+        'unknown-options-as-args': true,
+    })
+        .positional('key', {
+        type: 'string',
+        description: 'This is a key for Nx.',
+    })
+        .example('$0 register <key>', 'Register a Nx key'),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? false, async () => {
+            return (await (0, handle_import_1.handleImport)('./register.js', __dirname)).handleRegister(args);
+        });
+        process.exit(exitCode);
+    },
+};

package/dist/src/command-line/release/changelog/commit-utils.d.ts

@@ -0,0 +1,13 @@
+import { GitCommit } from '../utils/git';
+import { FileData, ProjectFileMap } from '../../../config/project-graph';
+import { NxReleaseConfig } from '../config/config';
+import { ChangelogChange } from './version-plan-utils';
+export declare function mapCommitToChange(commit: GitCommit, affectedProjects: string[] | '*'): ChangelogChange;
+export declare function createChangesFromCommits(commits: GitCommit[], fileMap: {
+    projectFileMap: ProjectFileMap;
+    nonProjectFiles: FileData[];
+}, fileToProjectMap: Record<string, string>, conventionalCommitsConfig: NxReleaseConfig['conventionalCommits']): ChangelogChange[];
+export declare function filterHiddenChanges(changes: ChangelogChange[], conventionalCommitsConfig: NxReleaseConfig['conventionalCommits']): ChangelogChange[];
+export declare function getProjectsAffectedByCommit(commit: GitCommit, fileToProjectMap: Record<string, string>): string[];
+export declare function commitChangesNonProjectFiles(commit: GitCommit, nonProjectFiles: FileData[]): boolean;
+export declare function createFileToProjectMap(projectFileMap: ProjectFileMap): Record<string, string>;

package/dist/src/command-line/release/changelog/commit-utils.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapCommitToChange = mapCommitToChange;
+exports.createChangesFromCommits = createChangesFromCommits;
+exports.filterHiddenChanges = filterHiddenChanges;
+exports.getProjectsAffectedByCommit = getProjectsAffectedByCommit;
+exports.commitChangesNonProjectFiles = commitChangesNonProjectFiles;
+exports.createFileToProjectMap = createFileToProjectMap;
+function mapCommitToChange(commit, affectedProjects) {
+    return {
+        type: commit.type,
+        scope: commit.scope,
+        description: commit.description,
+        body: commit.body,
+        isBreaking: commit.isBreaking,
+        githubReferences: commit.references,
+        authors: commit.authors,
+        shortHash: commit.shortHash,
+        revertedHashes: commit.revertedHashes,
+        affectedProjects,
+    };
+}
+function createChangesFromCommits(commits, fileMap, fileToProjectMap, conventionalCommitsConfig) {
+    return filterHiddenChanges(commits.map((c) => {
+        const affectedProjects = commitChangesNonProjectFiles(c, fileMap.nonProjectFiles)
+            ? '*'
+            : getProjectsAffectedByCommit(c, fileToProjectMap);
+        return mapCommitToChange(c, affectedProjects);
+    }), conventionalCommitsConfig);
+}
+function filterHiddenChanges(changes, conventionalCommitsConfig) {
+    return changes.filter((change) => {
+        const type = change.type;
+        const typeConfig = conventionalCommitsConfig.types[type];
+        if (!typeConfig) {
+            // don't include changes with unknown types
+            return false;
+        }
+        return !typeConfig.changelog.hidden;
+    });
+}
+function getProjectsAffectedByCommit(commit, fileToProjectMap) {
+    const affectedProjects = new Set();
+    for (const affectedFile of commit.affectedFiles) {
+        const affectedProject = fileToProjectMap[affectedFile];
+        if (affectedProject) {
+            affectedProjects.add(affectedProject);
+        }
+    }
+    return Array.from(affectedProjects);
+}
+function commitChangesNonProjectFiles(commit, nonProjectFiles) {
+    return nonProjectFiles.some((fileData) => commit.affectedFiles.includes(fileData.file));
+}
+function createFileToProjectMap(projectFileMap) {
+    const fileToProjectMap = {};
+    for (const [projectName, projectFiles] of Object.entries(projectFileMap)) {
+        for (const file of projectFiles) {
+            fileToProjectMap[file.file] = projectName;
+        }
+    }
+    return fileToProjectMap;
+}

package/dist/src/command-line/release/changelog/version-plan-filtering.d.ts

@@ -0,0 +1,41 @@
+import type { ChangelogOptions } from '../command-object';
+import type { NxReleaseConfig } from '../config/config';
+import { RawVersionPlan } from '../config/version-plans';
+import type { VersionData } from '../utils/shared';
+import type { CheckAllBranchesWhen, RepoGitTags } from '../utils/repository-git-tags';
+/**
+ * Filters version plans to only include those that were committed between the specified SHAs
+ * @param versionPlans The raw version plans to filter
+ * @param fromSHA The starting commit SHA (exclusive)
+ * @param toSHA The ending commit SHA (inclusive)
+ * @param isVerbose Whether to output verbose logging
+ * @returns The filtered version plans
+ */
+export declare function filterVersionPlansByCommitRange(versionPlans: RawVersionPlan[], fromSHA: string, toSHA: string, isVerbose: boolean): Promise<RawVersionPlan[]>;
+/**
+ * Resolves the "from SHA" for changelog purposes.
+ * This determines the starting point for changelog generation and optional version plan filtering.
+ */
+export declare function resolveChangelogFromSHA({ fromRef, tagPattern, tagPatternValues, checkAllBranchesWhen, preid, requireSemver, strictPreid, useAutomaticFromRef, resolveRepositoryTags, }: {
+    fromRef?: string;
+    tagPattern: string;
+    tagPatternValues: Record<string, string>;
+    checkAllBranchesWhen: CheckAllBranchesWhen;
+    preid?: string;
+    requireSemver: boolean;
+    strictPreid: boolean;
+    useAutomaticFromRef: boolean;
+    resolveRepositoryTags: RepoGitTags['resolveTags'];
+}): Promise<string | null>;
+/**
+ * Helper function for workspace-level "from SHA" resolution.
+ * Extracts preids and calls the generic resolver.
+ */
+export declare function resolveWorkspaceChangelogFromSHA({ args, nxReleaseConfig, useAutomaticFromRef, resolveRepositoryTags, }: {
+    args: ChangelogOptions;
+    nxReleaseConfig: NxReleaseConfig;
+    useAutomaticFromRef: boolean;
+    resolveRepositoryTags: RepoGitTags['resolveTags'];
+}): Promise<string | null>;
+export declare function extractPreidFromVersion(version: string | null | undefined): string | undefined;
+export declare function extractProjectsPreidFromVersionData(versionData: VersionData | undefined): Record<string, string | undefined> | undefined;