@ohos-ports/nx 17.3.2-beta.0

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

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = exports.printTargetRunHelp = exports.runExecutor = exports.validateProject = exports.printRunHelp = void 0;
+const params_1 = require("../../utils/params");
+const print_help_1 = require("../../utils/print-help");
+const path_1 = require("path");
+const serialize_overrides_into_command_line_1 = require("../../utils/serialize-overrides-into-command-line");
+const project_graph_1 = require("../../project-graph/project-graph");
+const configuration_1 = require("../../config/configuration");
+const native_1 = require("../../native");
+const async_iterator_1 = require("../../utils/async-iterator");
+const executor_utils_1 = require("./executor-utils");
+const child_process_1 = require("../../utils/child-process");
+function printRunHelp(opts, schema, plugin) {
+    (0, print_help_1.printHelp)(`run ${opts.project}:${opts.target}`, schema, {
+        mode: 'run',
+        ...plugin,
+    });
+}
+exports.printRunHelp = printRunHelp;
+function validateProject(projects, projectName) {
+    const project = projects.projects[projectName];
+    if (!project) {
+        throw new Error(`Could not find project "${projectName}"`);
+    }
+}
+exports.validateProject = validateProject;
+function isPromise(v) {
+    return typeof v?.then === 'function';
+}
+async function* promiseToIterator(v) {
+    yield await v;
+}
+async function iteratorToProcessStatusCode(i) {
+    // This is a workaround to fix an issue that only happens with
+    // the @angular-devkit/build-angular:browser builder. Starting
+    // on version 12.0.1, a SASS compilation implementation was
+    // introduced making use of workers and it's unref()-ing the worker
+    // too early, causing the process to exit early in environments
+    // like CI or when running Docker builds.
+    const keepProcessAliveInterval = setInterval(() => { }, 1000);
+    try {
+        const { success } = await (0, async_iterator_1.getLastValueFromAsyncIterableIterator)(i);
+        return success ? 0 : 1;
+    }
+    finally {
+        clearInterval(keepProcessAliveInterval);
+    }
+}
+async function parseExecutorAndTarget({ project, target }, root, projectsConfigurations) {
+    const proj = projectsConfigurations.projects[project];
+    const targetConfig = proj.targets?.[target];
+    if (!targetConfig) {
+        throw new Error(`Cannot find target '${target}' for project '${project}'`);
+    }
+    const [nodeModule, executor] = targetConfig.executor.split(':');
+    const { schema, implementationFactory } = (0, executor_utils_1.getExecutorInformation)(nodeModule, executor, root, projectsConfigurations.projects);
+    return { executor, implementationFactory, nodeModule, schema, targetConfig };
+}
+async function printTargetRunHelpInternal({ project, target }, root, projectsConfigurations) {
+    const { executor, nodeModule, schema, targetConfig } = await parseExecutorAndTarget({ project, target }, root, projectsConfigurations);
+    printRunHelp({ project, target }, schema, {
+        plugin: nodeModule,
+        entity: executor,
+    });
+    if (nodeModule === 'nx' &&
+        executor === 'run-commands' &&
+        targetConfig.options.command) {
+        const command = targetConfig.options.command.split(' ')[0];
+        await new Promise(() => {
+            const cp = new child_process_1.PseudoTtyProcess((0, native_1.runCommand)(`${command} --help`));
+            cp.onExit((code) => {
+                process.exit(code);
+            });
+        });
+    }
+    else {
+        process.exit(0);
+    }
+}
+async function runExecutorInternal({ project, target, configuration }, overrides, root, cwd, projectsConfigurations, nxJsonConfiguration, projectGraph, taskGraph, isVerbose) {
+    validateProject(projectsConfigurations, project);
+    const { executor, implementationFactory, nodeModule, schema, targetConfig } = await parseExecutorAndTarget({ project, target, configuration }, root, projectsConfigurations);
+    configuration ??= targetConfig.defaultConfiguration;
+    const combinedOptions = (0, params_1.combineOptionsForExecutor)(overrides, configuration, targetConfig, schema, project, (0, path_1.relative)(root, cwd), isVerbose);
+    if ((0, executor_utils_1.getExecutorInformation)(nodeModule, executor, root, projectsConfigurations.projects).isNxExecutor) {
+        const implementation = implementationFactory();
+        const r = implementation(combinedOptions, {
+            root,
+            target: targetConfig,
+            projectsConfigurations,
+            nxJsonConfiguration,
+            workspace: { ...projectsConfigurations, ...nxJsonConfiguration },
+            projectName: project,
+            targetName: target,
+            configurationName: configuration,
+            projectGraph,
+            taskGraph,
+            cwd,
+            isVerbose,
+        });
+        if (isPromise(r)) {
+            return promiseToIterator(r);
+        }
+        else if ((0, async_iterator_1.isAsyncIterator)(r)) {
+            return r;
+        }
+        else {
+            throw new TypeError(`NX Executor "${targetConfig.executor}" should return either a Promise or an AsyncIterator`);
+        }
+    }
+    else {
+        require('../../adapter/compat');
+        const observable = await (await Promise.resolve().then(() => require('../../adapter/ngcli-adapter'))).scheduleTarget(root, {
+            project,
+            target,
+            configuration,
+            runOptions: combinedOptions,
+            projects: projectsConfigurations.projects,
+        }, isVerbose);
+        const { eachValueFrom } = await Promise.resolve().then(() => require('../../adapter/rxjs-for-await'));
+        return eachValueFrom(observable);
+    }
+}
+/**
+ * Loads and invokes executor.
+ *
+ * This is analogous to invoking executor from the terminal, with the exception
+ * that the params aren't parsed from the string, but instead provided parsed already.
+ *
+ * Apart from that, it works the same way:
+ *
+ * - it will load the workspace configuration
+ * - it will resolve the target
+ * - it will load the executor and the schema
+ * - it will load the options for the appropriate configuration
+ * - it will run the validations and will set the default
+ * - and, of course, it will invoke the executor
+ *
+ * Example:
+ *
+ * ```typescript
+ * for await (const s of await runExecutor({project: 'myproj', target: 'serve'}, {watch: true}, context)) {
+ *   // s.success
+ * }
+ * ```
+ *
+ * Note that the return value is a promise of an iterator, so you need to await before iterating over it.
+ */
+async function runExecutor(targetDescription, overrides, context) {
+    return await runExecutorInternal(targetDescription, {
+        ...overrides,
+        __overrides_unparsed__: (0, serialize_overrides_into_command_line_1.serializeOverridesIntoCommandLine)(overrides),
+    }, context.root, context.cwd, context.projectsConfigurations, context.nxJsonConfiguration, context.projectGraph, context.taskGraph, context.isVerbose);
+}
+exports.runExecutor = runExecutor;
+function printTargetRunHelp(targetDescription, root) {
+    const projectGraph = (0, project_graph_1.readCachedProjectGraph)();
+    return (0, params_1.handleErrors)(false, async () => {
+        const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+        await printTargetRunHelpInternal(targetDescription, root, projectsConfigurations);
+    });
+}
+exports.printTargetRunHelp = printTargetRunHelp;
+function run(cwd, root, targetDescription, overrides, isVerbose, taskGraph) {
+    const projectGraph = (0, project_graph_1.readCachedProjectGraph)();
+    return (0, params_1.handleErrors)(isVerbose, async () => {
+        const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+        return iteratorToProcessStatusCode(await runExecutorInternal(targetDescription, overrides, root, cwd, projectsConfigurations, (0, configuration_1.readNxJson)(), projectGraph, taskGraph, isVerbose));
+    });
+}
+exports.run = run;

package/src/command-line/run-many/command-object.d.ts

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

package/src/command-line/run-many/command-object.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsRunManyCommand = void 0;
+const documentation_1 = require("../yargs-utils/documentation");
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsRunManyCommand = {
+    command: 'run-many',
+    describe: 'Run target for multiple listed projects',
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withRunManyOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withTargetAndConfigurationOption)((0, shared_options_1.withBatch)(yargs)))), 'run-many'),
+    handler: async (args) => (await Promise.resolve().then(() => require('./run-many'))).runMany((0, shared_options_1.withOverrides)(args)),
+};

package/src/command-line/run-many/run-many.d.ts

@@ -0,0 +1,10 @@
+import { NxArgs } from '../../utils/command-line-utils';
+import { ProjectGraph, ProjectGraphProjectNode } from '../../config/project-graph';
+import { TargetDependencyConfig } from '../../config/workspace-json-project-json';
+export declare function runMany(args: {
+    [k: string]: any;
+}, extraTargetDependencies?: Record<string, (TargetDependencyConfig | string)[]>, extraOptions?: {
+    excludeTaskDependencies: boolean;
+    loadDotEnvFiles: boolean;
+}): Promise<void>;
+export declare function projectsToRun(nxArgs: NxArgs, projectGraph: ProjectGraph): ProjectGraphProjectNode[];

package/src/command-line/run-many/run-many.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectsToRun = exports.runMany = void 0;
+const run_command_1 = require("../../tasks-runner/run-command");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const command_line_utils_2 = require("../../utils/command-line-utils");
+const project_graph_utils_1 = require("../../utils/project-graph-utils");
+const connect_to_nx_cloud_1 = require("../connect/connect-to-nx-cloud");
+const perf_hooks_1 = require("perf_hooks");
+const project_graph_1 = require("../../project-graph/project-graph");
+const configuration_1 = require("../../config/configuration");
+const output_1 = require("../../utils/output");
+const find_matching_projects_1 = require("../../utils/find-matching-projects");
+const workspace_configuration_check_1 = require("../../utils/workspace-configuration-check");
+const graph_1 = require("../graph/graph");
+async function runMany(args, extraTargetDependencies = {}, extraOptions = { excludeTaskDependencies: false, loadDotEnvFiles: true }) {
+    perf_hooks_1.performance.mark('code-loading:end');
+    perf_hooks_1.performance.measure('code-loading', 'init-local', 'code-loading:end');
+    (0, workspace_configuration_check_1.workspaceConfigurationCheck)();
+    const nxJson = (0, configuration_1.readNxJson)();
+    const { nxArgs, overrides } = (0, command_line_utils_2.splitArgsIntoNxArgsAndOverrides)(args, 'run-many', { printWarnings: args.graph !== 'stdout' }, nxJson);
+    if (nxArgs.verbose) {
+        process.env.NX_VERBOSE_LOGGING = 'true';
+    }
+    await (0, connect_to_nx_cloud_1.connectToNxCloudIfExplicitlyAsked)(nxArgs);
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    const projects = projectsToRun(nxArgs, projectGraph);
+    if (nxArgs.graph) {
+        const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(nxArgs);
+        const projectNames = projects.map((t) => t.name);
+        return await (0, graph_1.generateGraph)({
+            watch: false,
+            open: true,
+            view: 'tasks',
+            all: nxArgs.all,
+            targets: nxArgs.targets,
+            projects: projectNames,
+            file,
+        }, projectNames);
+    }
+    else {
+        const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, null, extraTargetDependencies, extraOptions);
+        process.exit(status);
+    }
+}
+exports.runMany = runMany;
+function projectsToRun(nxArgs, projectGraph) {
+    const selectedProjects = {};
+    const validProjects = runnableForTarget(projectGraph.nodes, nxArgs.targets);
+    const invalidProjects = [];
+    // --all is default now, if --projects is provided, it'll override the --all
+    if (nxArgs.all && nxArgs.projects.length === 0) {
+        for (const projectName of validProjects) {
+            selectedProjects[projectName] = projectGraph.nodes[projectName];
+        }
+    }
+    else {
+        const matchingProjects = (0, find_matching_projects_1.findMatchingProjects)(nxArgs.projects, projectGraph.nodes);
+        for (const project of matchingProjects) {
+            if (!validProjects.has(project)) {
+                invalidProjects.push(project);
+            }
+            else {
+                selectedProjects[project] = projectGraph.nodes[project];
+            }
+        }
+        if (invalidProjects.length > 0) {
+            output_1.output.warn({
+                title: `The following projects do not have a configuration for any of the provided targets ("${nxArgs.targets.join(', ')}")`,
+                bodyLines: invalidProjects.map((name) => `- ${name}`),
+            });
+        }
+    }
+    const excludedProjects = (0, find_matching_projects_1.findMatchingProjects)(nxArgs.exclude, selectedProjects);
+    for (const excludedProject of excludedProjects) {
+        delete selectedProjects[excludedProject];
+    }
+    return Object.values(selectedProjects);
+}
+exports.projectsToRun = projectsToRun;
+function runnableForTarget(projects, targets) {
+    const runnable = new Set();
+    for (let projectName in projects) {
+        const project = projects[projectName];
+        if (targets.find((target) => (0, project_graph_utils_1.projectHasTarget)(project, target))) {
+            runnable.add(projectName);
+        }
+    }
+    return runnable;
+}

package/src/command-line/run-many.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @deprecated(v17) This file has moved. The reexport will be removed in Nx 17.
+ */
+export * from './run-many/run-many';

package/src/command-line/run-many.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/**
+ * @deprecated(v17) This file has moved. The reexport will be removed in Nx 17.
+ */
+tslib_1.__exportStar(require("./run-many/run-many"), exports);

package/src/command-line/run-one.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @deprecated(v17) This file has moved. The reexport will be removed in Nx 17.
+ */
+export * from './run/run-one';

package/src/command-line/run-one.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/**
+ * @deprecated(v17) This file has moved. The reexport will be removed in Nx 17.
+ */
+tslib_1.__exportStar(require("./run/run-one"), exports);

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

@@ -0,0 +1,4 @@
+/**
+ * @deprecated(v17) This file has moved. The reexport will be removed in Nx 17.
+ */
+export * from './run/run';

package/src/command-line/run.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/**
+ * @deprecated(v17) This file has moved. The reexport will be removed in Nx 17.
+ */
+tslib_1.__exportStar(require("./run/run"), exports);

package/src/command-line/show/command-object.d.ts

@@ -0,0 +1,22 @@
+import type { ProjectGraphProjectNode } from '../../config/project-graph';
+import { CommandModule } from 'yargs';
+export interface NxShowArgs {
+    json?: boolean;
+}
+export type ShowProjectsOptions = NxShowArgs & {
+    exclude: string;
+    files: string;
+    uncommitted: any;
+    untracked: any;
+    base: string;
+    head: string;
+    affected: boolean;
+    type: ProjectGraphProjectNode['type'];
+    projects: string[];
+    withTarget: string[];
+};
+export type ShowProjectOptions = NxShowArgs & {
+    projectName: string;
+    web?: boolean;
+};
+export declare const yargsShowCommand: CommandModule<Record<string, unknown>, NxShowArgs>;

package/src/command-line/show/command-object.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsShowCommand = void 0;
+const yargs_1 = require("yargs");
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsShowCommand = {
+    command: 'show',
+    describe: 'Show information about the workspace (e.g., list of projects)',
+    builder: (yargs) => yargs
+        .command(showProjectsCommand)
+        .command(showProjectCommand)
+        .demandCommand()
+        .option('json', {
+        type: 'boolean',
+        description: 'Output JSON',
+    })
+        .example('$0 show projects', 'Show a list of all projects in the workspace')
+        .example('$0 show projects --with-target serve', 'Show a list of all projects in the workspace that have a "serve" target')
+        .example('$0 show project [projectName]', 'Shows the resolved configuration for [projectName]'),
+    handler: async (args) => {
+        (0, yargs_1.showHelp)();
+        process.exit(1);
+    },
+};
+const showProjectsCommand = {
+    command: 'projects',
+    describe: 'Show a list of projects in the workspace',
+    builder: (yargs) => (0, shared_options_1.withAffectedOptions)(yargs)
+        .option('affected', {
+        type: 'boolean',
+        description: 'Show only affected projects',
+    })
+        .option('projects', {
+        type: 'string',
+        alias: ['p'],
+        description: 'Show only projects that match a given pattern.',
+        coerce: shared_options_1.parseCSV,
+    })
+        .option('withTarget', {
+        type: 'string',
+        alias: ['t'],
+        description: 'Show only projects that have a specific target',
+        coerce: shared_options_1.parseCSV,
+    })
+        .option('type', {
+        type: 'string',
+        description: 'Select only projects of the given type',
+        choices: ['app', 'lib', 'e2e'],
+    })
+        .implies('untracked', 'affected')
+        .implies('uncommitted', 'affected')
+        .implies('files', 'affected')
+        .implies('base', 'affected')
+        .implies('head', 'affected')
+        .example('$0 show projects --projects "apps/*"', 'Show all projects in the apps directory')
+        .example('$0 show projects --projects "shared-*"', 'Show all projects that start with "shared-"')
+        .example('$0 show projects --affected', 'Show affected projects in the workspace')
+        .example('$0 show projects --type app --affected', 'Show affected apps in the workspace')
+        .example('$0 show projects --affected --exclude=*-e2e', 'Show affected projects in the workspace, excluding end-to-end projects'),
+    handler: (args) => Promise.resolve().then(() => require('./show')).then((m) => m.showProjectsHandler(args)),
+};
+const showProjectCommand = {
+    command: 'project <projectName>',
+    describe: 'Shows resolved project configuration for a given project.',
+    builder: (yargs) => yargs
+        .positional('projectName', {
+        type: 'string',
+        alias: 'p',
+        description: 'Which project should be viewed?',
+    })
+        .default('json', true)
+        .option('web', {
+        type: 'boolean',
+        description: 'Show project details in the browser',
+    })
+        .check((argv) => {
+        if (argv.web) {
+            argv.json = false;
+        }
+        return true;
+    })
+        .example('$0 show project my-app', 'View project information for my-app in JSON format'),
+    handler: (args) => Promise.resolve().then(() => require('./show')).then((m) => m.showProjectHandler(args)),
+};

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

@@ -0,0 +1,3 @@
+import { ShowProjectOptions, ShowProjectsOptions } from './command-object';
+export declare function showProjectsHandler(args: ShowProjectsOptions): Promise<void>;
+export declare function showProjectHandler(args: ShowProjectOptions): Promise<void>;

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

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showProjectHandler = exports.showProjectsHandler = void 0;
+const output_1 = require("../../utils/output");
+const nx_json_1 = require("../../config/nx-json");
+const affected_project_graph_1 = require("../../project-graph/affected/affected-project-graph");
+const file_utils_1 = require("../../project-graph/file-utils");
+const operators_1 = require("../../project-graph/operators");
+const project_graph_1 = require("../../project-graph/project-graph");
+const all_file_data_1 = require("../../utils/all-file-data");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const find_matching_projects_1 = require("../../utils/find-matching-projects");
+const graph_1 = require("../graph/graph");
+async function showProjectsHandler(args) {
+    let graph = await (0, project_graph_1.createProjectGraphAsync)();
+    const nxJson = (0, nx_json_1.readNxJson)();
+    const { nxArgs } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', {
+        printWarnings: false,
+    }, nxJson);
+    // Affected touches dependencies so it needs to be processed first.
+    if (args.affected) {
+        const touchedFiles = await getTouchedFiles(nxArgs);
+        graph = await getAffectedGraph(touchedFiles, nxJson, graph);
+    }
+    const filter = (0, operators_1.filterNodes)((node) => {
+        if (args.type && node.type !== args.type) {
+            return false;
+        }
+        return true;
+    });
+    graph = filter(graph);
+    // Apply projects filter and get resultant graph
+    if (args.projects) {
+        graph.nodes = getGraphNodesMatchingPatterns(graph, args.projects);
+    }
+    // Grab only the nodes with the specified target
+    if (args.withTarget) {
+        graph.nodes = Object.entries(graph.nodes).reduce((acc, [name, node]) => {
+            if (args.withTarget.some((target) => node.data.targets?.[target])) {
+                acc[name] = node;
+            }
+            return acc;
+        }, {});
+    }
+    const selectedProjects = new Set(Object.keys(graph.nodes));
+    if (args.exclude) {
+        const excludedProjects = (0, find_matching_projects_1.findMatchingProjects)(nxArgs.exclude, graph.nodes);
+        for (const excludedProject of excludedProjects) {
+            selectedProjects.delete(excludedProject);
+        }
+    }
+    if (args.json) {
+        console.log(JSON.stringify(Array.from(selectedProjects)));
+    }
+    else {
+        for (const project of selectedProjects) {
+            console.log(project);
+        }
+    }
+    await output_1.output.drain();
+    process.exit(0);
+}
+exports.showProjectsHandler = showProjectsHandler;
+async function showProjectHandler(args) {
+    const graph = await (0, project_graph_1.createProjectGraphAsync)();
+    const node = graph.nodes[args.projectName];
+    if (!node) {
+        console.log(`Could not find project ${args.projectName}`);
+        process.exit(1);
+    }
+    if (args.json) {
+        console.log(JSON.stringify(node.data));
+    }
+    else if (args.web) {
+        await (0, graph_1.generateGraph)({
+            view: 'project-details',
+            focus: node.name,
+            watch: true,
+            open: true,
+        }, []);
+    }
+    else {
+        const chalk = require('chalk');
+        const logIfExists = (label, key) => {
+            if (node.data[key]) {
+                console.log(`${chalk.bold(label)}: ${node.data[key]}`);
+            }
+        };
+        logIfExists('Name', 'name');
+        logIfExists('Root', 'root');
+        logIfExists('Source Root', 'sourceRoot');
+        logIfExists('Tags', 'tags');
+        logIfExists('Implicit Dependencies', 'implicitDependencies');
+        const targets = Object.entries(node.data.targets ?? {});
+        const maxTargetNameLength = Math.max(...targets.map(([t]) => t.length));
+        const maxExecutorNameLength = Math.max(...targets.map(([, t]) => t?.executor?.length ?? 0));
+        if (targets.length > 0) {
+            console.log(`${chalk.bold('Targets')}: `);
+            for (const [target, targetConfig] of targets) {
+                console.log(`- ${chalk.bold((target + ':').padEnd(maxTargetNameLength + 2))} ${(targetConfig?.executor ?? '').padEnd(maxExecutorNameLength + 2)} ${(() => {
+                    const configurations = Object.keys(targetConfig.configurations ?? {});
+                    if (configurations.length) {
+                        return chalk.dim(configurations.join(', '));
+                    }
+                    return '';
+                })()}`);
+            }
+        }
+    }
+    process.exit(0);
+}
+exports.showProjectHandler = showProjectHandler;
+function getGraphNodesMatchingPatterns(graph, patterns) {
+    const nodes = {};
+    const matches = (0, find_matching_projects_1.findMatchingProjects)(patterns, graph.nodes);
+    for (const match of matches) {
+        nodes[match] = graph.nodes[match];
+    }
+    return nodes;
+}
+function getAffectedGraph(touchedFiles, nxJson, graph) {
+    return (0, affected_project_graph_1.filterAffected)(graph, touchedFiles, nxJson);
+}
+async function getTouchedFiles(nxArgs) {
+    return (0, file_utils_1.calculateFileChanges)((0, command_line_utils_1.parseFiles)(nxArgs).files, await (0, all_file_data_1.allFileData)(), nxArgs);
+}

package/src/command-line/watch/command-object.d.ts

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

package/src/command-line/watch/command-object.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsWatchCommand = void 0;
+const documentation_1 = require("../yargs-utils/documentation");
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsWatchCommand = {
+    command: 'watch',
+    describe: 'Watch for changes within projects, and execute commands',
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)(withWatchOptions(yargs), 'watch'),
+    handler: async (args) => {
+        await Promise.resolve().then(() => require('./watch')).then((m) => m.watch(args));
+    },
+};
+function withWatchOptions(yargs) {
+    return yargs
+        .parserConfiguration({
+        'strip-dashed': true,
+        'populate--': true,
+    })
+        .option('projects', {
+        type: 'string',
+        alias: 'p',
+        coerce: shared_options_1.parseCSV,
+        description: 'Projects to watch (comma/space delimited).',
+    })
+        .option('all', {
+        type: 'boolean',
+        description: 'Watch all projects.',
+    })
+        .option('includeDependentProjects', {
+        type: 'boolean',
+        description: 'When watching selected projects, include dependent projects as well.',
+        alias: 'd',
+    })
+        .option('includeGlobalWorkspaceFiles', {
+        type: 'boolean',
+        description: 'Include global workspace files that are not part of a project. For example, the root eslint, or tsconfig file.',
+        alias: 'g',
+        hidden: true,
+    })
+        .option('command', { type: 'string', hidden: true })
+        .option('verbose', {
+        type: 'boolean',
+        description: 'Run watch mode in verbose mode, where commands are logged before execution.',
+    })
+        .conflicts({
+        all: 'projects',
+    })
+        .check((args) => {
+        if (!args.all && !args.projects) {
+            throw Error('Please specify either --all or --projects');
+        }
+        return true;
+    })
+        .middleware((args) => {
+        const { '--': doubledash } = args;
+        if (doubledash && Array.isArray(doubledash)) {
+            args.command = doubledash.join(' ');
+        }
+        else {
+            throw Error('No command specified for watch mode.');
+        }
+    }, true);
+}

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

@@ -0,0 +1,23 @@
+import { ChangedFile } from '../../daemon/client/client';
+export interface WatchArguments {
+    projects?: string[];
+    all?: boolean;
+    includeDependentProjects?: boolean;
+    includeGlobalWorkspaceFiles?: boolean;
+    verbose?: boolean;
+    command?: string;
+    projectNameEnvName?: string;
+    fileChangesEnvName?: string;
+}
+export declare class BatchFunctionRunner {
+    private callback;
+    private running;
+    private pendingProjects;
+    private pendingFiles;
+    protected get _verbose(): boolean;
+    private get hasPending();
+    constructor(callback: (projects: Set<string>, files: Set<string>) => Promise<unknown>);
+    enqueue(projectNames: string[], fileChanges: ChangedFile[]): Promise<void>;
+    private process;
+}
+export declare function watch(args: WatchArguments): Promise<void>;