@ohos-ports/nx 17.3.2-beta.0

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

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watch = exports.BatchFunctionRunner = void 0;
+const child_process_1 = require("child_process");
+const client_1 = require("../../daemon/client/client");
+const output_1 = require("../../utils/output");
+const DEFAULT_PROJECT_NAME_ENV = 'NX_PROJECT_NAME';
+const DEFAULT_FILE_CHANGES_ENV = 'NX_FILE_CHANGES';
+class BatchFunctionRunner {
+    get _verbose() {
+        return process.env.NX_VERBOSE_LOGGING === 'true';
+    }
+    get hasPending() {
+        return this.pendingProjects.size > 0 || this.pendingFiles.size > 0;
+    }
+    constructor(callback) {
+        this.callback = callback;
+        this.running = false;
+        this.pendingProjects = new Set();
+        this.pendingFiles = new Set();
+    }
+    enqueue(projectNames, fileChanges) {
+        projectNames.forEach((projectName) => {
+            this.pendingProjects.add(projectName);
+        });
+        fileChanges.forEach((fileChange) => {
+            this.pendingFiles.add(fileChange.path);
+        });
+        return this.process();
+    }
+    async process() {
+        if (!this.running && this.hasPending) {
+            this.running = true;
+            // Clone the pending projects and files before clearing
+            const projects = new Set(this.pendingProjects);
+            const files = new Set(this.pendingFiles);
+            // Clear the pending projects and files
+            this.pendingProjects.clear();
+            this.pendingFiles.clear();
+            return this.callback(projects, files).then(() => {
+                this.running = false;
+                this.process();
+            });
+        }
+        else {
+            this._verbose &&
+                this.running &&
+                output_1.output.logSingleLine('waiting for function to finish executing');
+            this._verbose &&
+                !this.hasPending &&
+                output_1.output.logSingleLine('no more function to process');
+        }
+    }
+}
+exports.BatchFunctionRunner = BatchFunctionRunner;
+class BatchCommandRunner extends BatchFunctionRunner {
+    constructor(command, projectNameEnv = DEFAULT_PROJECT_NAME_ENV, fileChangesEnv = DEFAULT_FILE_CHANGES_ENV) {
+        super((projects, files) => {
+            // process all pending commands together
+            const envs = this.createCommandEnvironments(projects, files);
+            return this.run(envs);
+        });
+        this.command = command;
+        this.projectNameEnv = projectNameEnv;
+        this.fileChangesEnv = fileChangesEnv;
+    }
+    createCommandEnvironments(projects, files) {
+        const commandsToRun = [];
+        if (projects.size > 0) {
+            projects.forEach((projectName) => {
+                commandsToRun.push({
+                    [this.projectNameEnv]: projectName,
+                    [this.fileChangesEnv]: Array.from(files).join(' '),
+                });
+            });
+        }
+        else {
+            commandsToRun.push({
+                [this.projectNameEnv]: '',
+                [this.fileChangesEnv]: Array.from(files).join(' '),
+            });
+        }
+        return commandsToRun;
+    }
+    async run(envs) {
+        this._verbose &&
+            output_1.output.logSingleLine('about to run commands with these environments: ' + JSON.stringify(envs));
+        return Promise.all(envs.map((env) => {
+            return new Promise((resolve, reject) => {
+                const commandExec = (0, child_process_1.spawn)(this.command, {
+                    stdio: 'inherit',
+                    shell: true,
+                    cwd: process.cwd(),
+                    env: {
+                        ...process.env,
+                        [this.projectNameEnv]: env[this.projectNameEnv],
+                        [this.fileChangesEnv]: env[this.fileChangesEnv],
+                    },
+                });
+                commandExec.on('close', () => {
+                    resolve();
+                });
+                commandExec.on('exit', () => {
+                    resolve();
+                });
+            });
+        })).then((r) => {
+            this._verbose &&
+                output_1.output.logSingleLine('running complete, processing the next batch');
+            return r;
+        });
+    }
+}
+async function watch(args) {
+    const projectReplacementRegex = new RegExp(args.projectNameEnvName ?? DEFAULT_PROJECT_NAME_ENV, 'g');
+    if (args.verbose) {
+        process.env.NX_VERBOSE_LOGGING = 'true';
+    }
+    if (args.includeGlobalWorkspaceFiles &&
+        args.command.match(projectReplacementRegex)) {
+        output_1.output.error({
+            title: 'Invalid command',
+            bodyLines: [
+                'The command you provided has a replacement for projects ($NX_PROJECT_NAME), but you are also including global workspace files.',
+                'You cannot use a replacement for projects when including global workspace files because there will be scenarios where there are file changes not associated with a project.',
+            ],
+        });
+        process.exit(1);
+    }
+    args.verbose &&
+        output_1.output.logSingleLine('running with args: ' + JSON.stringify(args));
+    args.verbose && output_1.output.logSingleLine('starting watch process');
+    const whatToWatch = args.all ? 'all' : args.projects;
+    const batchQueue = new BatchCommandRunner(args.command ?? '', args.projectNameEnvName, args.fileChangesEnvName);
+    await client_1.daemonClient.registerFileWatcher({
+        watchProjects: whatToWatch,
+        includeDependentProjects: args.includeDependentProjects,
+        includeGlobalWorkspaceFiles: args.includeGlobalWorkspaceFiles,
+    }, async (err, data) => {
+        if (err === 'closed') {
+            output_1.output.error({
+                title: 'Watch connection closed',
+                bodyLines: [
+                    'The daemon has closed the connection to this watch process.',
+                    'Please restart your watch command.',
+                ],
+            });
+            process.exit(1);
+        }
+        else if (err !== null) {
+            output_1.output.error({
+                title: 'Watch error',
+                bodyLines: [
+                    'An error occurred during the watch process:',
+                    err.message,
+                ],
+            });
+        }
+        // Only pass the projects to the queue if the command has a replacement for projects
+        if (args.command.match(projectReplacementRegex)) {
+            batchQueue.enqueue(data.changedProjects, data.changedFiles);
+        }
+        else {
+            batchQueue.enqueue([], data.changedFiles);
+        }
+    });
+    args.verbose && output_1.output.logSingleLine('watch process waiting...');
+}
+exports.watch = watch;

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

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

package/src/command-line/watch.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("./watch/watch"), exports);

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

@@ -0,0 +1,2 @@
+import yargs = require('yargs');
+export declare function linkToNxDevAndExamples<T>(yargs: yargs.Argv<T>, command: string): yargs.Argv<T>;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkToNxDevAndExamples = void 0;
+const chalk = require("chalk");
+const examples_1 = require("../examples");
+function linkToNxDevAndExamples(yargs, command) {
+    (examples_1.examples[command] || []).forEach((t) => {
+        yargs = yargs.example(t.command, t.description);
+    });
+    return yargs.epilog(chalk.bold(`Find more information and examples at https://nx.dev/nx/${command.replace(':', '-')}`));
+}
+exports.linkToNxDevAndExamples = linkToNxDevAndExamples;

package/src/command-line/yargs-utils/shared-options.d.ts

@@ -0,0 +1,89 @@
+import { Argv } from 'yargs';
+interface ExcludeOptions {
+    exclude: string[];
+}
+export declare function withExcludeOption(yargs: Argv): Argv<ExcludeOptions>;
+export interface RunOptions {
+    exclude: string;
+    parallel: string;
+    maxParallel: number;
+    runner: string;
+    prod: boolean;
+    graph: string;
+    verbose: boolean;
+    nxBail: boolean;
+    nxIgnoreCycles: boolean;
+    skipNxCache: boolean;
+    cloud: boolean;
+    dte: boolean;
+    batch: boolean;
+}
+export declare function withRunOptions<T>(yargs: Argv<T>): Argv<T & RunOptions>;
+export declare function withTargetAndConfigurationOption(yargs: Argv, demandOption?: boolean): Argv<{
+    configuration: string;
+} & {
+    targets: string;
+}>;
+export declare function withConfiguration(yargs: Argv): Argv<{
+    configuration: string;
+}>;
+export declare function withBatch(yargs: Argv): any;
+export declare function withAffectedOptions(yargs: Argv): Argv<ExcludeOptions & {
+    files: string;
+} & {
+    uncommitted: boolean;
+} & {
+    untracked: boolean;
+} & {
+    base: string;
+} & {
+    head: string;
+}>;
+export interface RunManyOptions extends RunOptions {
+    projects: string[];
+    /**
+     * @deprecated This is deprecated
+     */
+    all: boolean;
+}
+export declare function withRunManyOptions<T>(yargs: Argv<T>): Argv<T & RunManyOptions>;
+export declare function withOverrides<T extends {
+    _: Array<string | number>;
+}>(args: T, commandLevel?: number): T & {
+    __overrides_unparsed__: string[];
+};
+declare const allOutputStyles: readonly ["dynamic", "static", "stream", "stream-without-prefixes", "compact"];
+export type OutputStyle = typeof allOutputStyles[number];
+export declare function withOutputStyleOption(yargs: Argv, choices?: ReadonlyArray<OutputStyle>): Argv<{
+    "output-style": string;
+}>;
+export declare function withDepGraphOptions(yargs: Argv): Argv<{
+    file: string;
+} & {
+    view: string;
+} & {
+    targets: string;
+} & {
+    focus: string;
+} & {
+    exclude: string;
+} & {
+    groupByFolder: boolean;
+} & {
+    host: string;
+} & {
+    port: number;
+} & {
+    watch: boolean;
+} & {
+    open: boolean;
+}>;
+export declare function withRunOneOptions(yargs: Argv): Argv<{
+    "output-style": string;
+} & RunOptions & {
+    project: string;
+} & {
+    help: boolean;
+}>;
+export declare function parseCSV(args: string[] | string): string[];
+export {};

package/src/command-line/yargs-utils/shared-options.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCSV = exports.withRunOneOptions = exports.withDepGraphOptions = exports.withOutputStyleOption = exports.withOverrides = exports.withRunManyOptions = exports.withAffectedOptions = exports.withBatch = exports.withConfiguration = exports.withTargetAndConfigurationOption = exports.withRunOptions = exports.withExcludeOption = void 0;
+function withExcludeOption(yargs) {
+    return yargs.option('exclude', {
+        describe: 'Exclude certain projects from being processed',
+        type: 'string',
+        coerce: parseCSV,
+    });
+}
+exports.withExcludeOption = withExcludeOption;
+function withRunOptions(yargs) {
+    return withExcludeOption(yargs)
+        .option('parallel', {
+        describe: 'Max number of parallel processes [default is 3]',
+        type: 'string',
+    })
+        .option('maxParallel', {
+        type: 'number',
+        hidden: true,
+    })
+        .options('runner', {
+        describe: 'This is the name of the tasks runner configured in nx.json',
+        type: 'string',
+    })
+        .option('prod', {
+        describe: 'Use the production configuration',
+        type: 'boolean',
+        default: false,
+        hidden: true,
+    })
+        .option('graph', {
+        type: 'string',
+        describe: 'Show the task graph of the command. Pass a file path to save the graph data instead of viewing it in the browser.',
+        coerce: (value) => 
+        // when the type of an opt is "string", passing `--opt` comes through as having an empty string value.
+        // this coercion allows `--graph` to be passed through as a boolean directly, and also normalizes the
+        // `--graph=true` to produce the same behaviour as `--graph`.
+        value === '' || value === 'true' || value === true
+            ? true
+            : value === 'false' || value === false
+                ? false
+                : value,
+    })
+        .option('verbose', {
+        type: 'boolean',
+        describe: 'Prints additional information about the commands (e.g., stack traces)',
+    })
+        .option('nxBail', {
+        describe: 'Stop command execution after the first failed task',
+        type: 'boolean',
+        default: false,
+    })
+        .option('nxIgnoreCycles', {
+        describe: 'Ignore cycles in the task graph',
+        type: 'boolean',
+        default: false,
+    })
+        .options('skipNxCache', {
+        describe: 'Rerun the tasks even when the results are available in the cache',
+        type: 'boolean',
+        default: false,
+    })
+        .options('cloud', {
+        type: 'boolean',
+        hidden: true,
+    })
+        .options('dte', {
+        type: 'boolean',
+        hidden: true,
+    });
+}
+exports.withRunOptions = withRunOptions;
+function withTargetAndConfigurationOption(yargs, demandOption = true) {
+    return withConfiguration(yargs).option('targets', {
+        describe: 'Tasks to run for affected projects',
+        type: 'string',
+        alias: ['target', 't'],
+        requiresArg: true,
+        coerce: parseCSV,
+        demandOption,
+        global: false,
+    });
+}
+exports.withTargetAndConfigurationOption = withTargetAndConfigurationOption;
+function withConfiguration(yargs) {
+    return yargs.options('configuration', {
+        describe: 'This is the configuration to use when performing tasks on projects',
+        type: 'string',
+        alias: 'c',
+    });
+}
+exports.withConfiguration = withConfiguration;
+function withBatch(yargs) {
+    return yargs.options('batch', {
+        type: 'boolean',
+        describe: 'Run task(s) in batches for executors which support batches',
+        coerce: (v) => {
+            return v || process.env.NX_BATCH_MODE === 'true';
+        },
+        default: false,
+    });
+}
+exports.withBatch = withBatch;
+function withAffectedOptions(yargs) {
+    return withExcludeOption(yargs)
+        .parserConfiguration({
+        'strip-dashed': true,
+        'unknown-options-as-args': true,
+        'populate--': true,
+    })
+        .option('files', {
+        describe: 'Change the way Nx is calculating the affected command by providing directly changed files, list of files delimited by commas or spaces',
+        type: 'string',
+        requiresArg: true,
+        coerce: parseCSV,
+    })
+        .option('uncommitted', {
+        describe: 'Uncommitted changes',
+        type: 'boolean',
+    })
+        .option('untracked', {
+        describe: 'Untracked changes',
+        type: 'boolean',
+    })
+        .option('base', {
+        describe: 'Base of the current branch (usually main)',
+        type: 'string',
+        requiresArg: true,
+    })
+        .option('head', {
+        describe: 'Latest commit of the current branch (usually HEAD)',
+        type: 'string',
+        requiresArg: true,
+    })
+        .group(['base'], 'Run command using --base=[SHA1] (affected by the committed, uncommitted and untracked changes):')
+        .group(['base', 'head'], 'or using --base=[SHA1] --head=[SHA2] (affected by the committed changes):')
+        .group(['files', 'uncommitted', 'untracked'], 'or using:')
+        .implies('head', 'base')
+        .conflicts({
+        files: ['uncommitted', 'untracked', 'base', 'head'],
+        untracked: ['uncommitted', 'files', 'base', 'head'],
+        uncommitted: ['files', 'untracked', 'base', 'head'],
+    });
+}
+exports.withAffectedOptions = withAffectedOptions;
+function withRunManyOptions(yargs) {
+    return withRunOptions(yargs)
+        .parserConfiguration({
+        'strip-dashed': true,
+        'unknown-options-as-args': true,
+        'populate--': true,
+    })
+        .option('projects', {
+        type: 'string',
+        alias: 'p',
+        coerce: parseCSV,
+        describe: 'Projects to run. (comma/space delimited project names and/or patterns)',
+    })
+        .option('all', {
+        describe: '[deprecated] `run-many` runs all targets on all projects in the workspace if no projects are provided. This option is no longer required.',
+        type: 'boolean',
+        default: true,
+    });
+}
+exports.withRunManyOptions = withRunManyOptions;
+function withOverrides(args, commandLevel = 1) {
+    const unparsedArgs = (args['--'] ?? args._.slice(commandLevel)).map((v) => v.toString());
+    delete args['--'];
+    delete args._;
+    return {
+        ...args,
+        __overrides_unparsed__: unparsedArgs,
+    };
+}
+exports.withOverrides = withOverrides;
+const allOutputStyles = [
+    'dynamic',
+    'static',
+    'stream',
+    'stream-without-prefixes',
+    'compact',
+];
+function withOutputStyleOption(yargs, choices = [
+    'dynamic',
+    'static',
+    'stream',
+    'stream-without-prefixes',
+]) {
+    return yargs.option('output-style', {
+        describe: 'Defines how Nx emits outputs tasks logs',
+        type: 'string',
+        choices,
+    });
+}
+exports.withOutputStyleOption = withOutputStyleOption;
+function withDepGraphOptions(yargs) {
+    return yargs
+        .option('file', {
+        describe: 'Output file (e.g. --file=output.json or --file=dep-graph.html)',
+        type: 'string',
+    })
+        .option('view', {
+        describe: 'Choose whether to view the projects or task graph',
+        type: 'string',
+        default: 'projects',
+        choices: ['projects', 'tasks'],
+    })
+        .option('targets', {
+        describe: 'The target to show tasks for in the task graph',
+        type: 'string',
+        coerce: parseCSV,
+    })
+        .option('focus', {
+        describe: 'Use to show the project graph for a particular project and every node that is either an ancestor or a descendant.',
+        type: 'string',
+    })
+        .option('exclude', {
+        describe: 'List of projects delimited by commas to exclude from the project graph.',
+        type: 'string',
+        coerce: parseCSV,
+    })
+        .option('groupByFolder', {
+        describe: 'Group projects by folder in the project graph',
+        type: 'boolean',
+    })
+        .option('host', {
+        describe: 'Bind the project graph server to a specific ip address.',
+        type: 'string',
+    })
+        .option('port', {
+        describe: 'Bind the project graph server to a specific port.',
+        type: 'number',
+    })
+        .option('watch', {
+        describe: 'Watch for changes to project graph and update in-browser',
+        type: 'boolean',
+        default: false,
+    })
+        .option('open', {
+        describe: 'Open the project graph in the browser.',
+        type: 'boolean',
+        default: true,
+    });
+}
+exports.withDepGraphOptions = withDepGraphOptions;
+function withRunOneOptions(yargs) {
+    const executorShouldShowHelp = !(process.argv[2] === 'run' && process.argv[3] === '--help');
+    const res = withRunOptions(withOutputStyleOption(withConfiguration(yargs), allOutputStyles))
+        .parserConfiguration({
+        'strip-dashed': true,
+        'unknown-options-as-args': true,
+        'populate--': true,
+    })
+        .option('project', {
+        describe: 'Target project',
+        type: 'string',
+    })
+        .option('help', {
+        describe: 'Show Help',
+        type: 'boolean',
+    });
+    if (executorShouldShowHelp) {
+        return res.help(false);
+    }
+    else {
+        return res.epilog(`Run "nx run myapp:mytarget --help" to see information about the executor's schema.`);
+    }
+}
+exports.withRunOneOptions = withRunOneOptions;
+function parseCSV(args) {
+    if (!args) {
+        return [];
+    }
+    if (Array.isArray(args)) {
+        // If parseCSV is used on `type: 'array'`, the first option may be something like ['a,b,c'].
+        return args.length === 1 && args[0].includes(',')
+            ? parseCSV(args[0])
+            : args;
+    }
+    const items = args.split(',');
+    return items.map((i) => i.startsWith('"') && i.endsWith('"') ? i.slice(1, -1) : i);
+}
+exports.parseCSV = parseCSV;

package/src/commands-runner/command-graph.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Graph of Tasks to be executed
+ */
+export interface CommandGraph {
+    /**
+     * Projects that do not have any dependencies and are thus ready to execute immediately
+     */
+    roots: string[];
+    /**
+     * Map of projects to projects which the task depends on
+     */
+    dependencies: Record<string, string[]>;
+}

package/src/commands-runner/command-graph.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/commands-runner/create-command-graph.d.ts

@@ -0,0 +1,4 @@
+import { ProjectGraph } from '../config/project-graph';
+import { NxArgs } from '../utils/command-line-utils';
+import { CommandGraph } from './command-graph';
+export declare function createCommandGraph(projectGraph: ProjectGraph, projectNames: string[], nxArgs: NxArgs): CommandGraph;

package/src/commands-runner/create-command-graph.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommandGraph = void 0;
+const task_graph_utils_1 = require("../tasks-runner/task-graph-utils");
+const output_1 = require("../utils/output");
+function createCommandGraph(projectGraph, projectNames, nxArgs) {
+    const dependencies = {};
+    for (const projectName of projectNames) {
+        if (projectGraph.dependencies[projectName].length >= 1) {
+            dependencies[projectName] = [
+                ...new Set(projectGraph.dependencies[projectName]
+                    .map((projectDep) => projectDep.target)
+                    .filter((projectDep) => projectGraph.nodes[projectDep])).values(),
+            ];
+        }
+        else {
+            dependencies[projectName] = [];
+        }
+    }
+    const roots = Object.keys(dependencies).filter((d) => dependencies[d].length === 0);
+    const commandGraph = {
+        dependencies,
+        roots,
+    };
+    const cycle = (0, task_graph_utils_1.findCycle)(commandGraph);
+    if (cycle) {
+        if (process.env.NX_IGNORE_CYCLES === 'true' || nxArgs.nxIgnoreCycles) {
+            output_1.output.warn({
+                title: `The command graph has a circular dependency`,
+                bodyLines: [`${cycle.join(' --> ')}`],
+            });
+            (0, task_graph_utils_1.makeAcyclic)(commandGraph);
+        }
+        else {
+            output_1.output.error({
+                title: `Could not execute command because the project graph has a circular dependency`,
+                bodyLines: [`${cycle.join(' --> ')}`],
+            });
+            process.exit(1);
+        }
+    }
+    return commandGraph;
+}
+exports.createCommandGraph = createCommandGraph;

package/src/commands-runner/get-command-projects.d.ts

@@ -0,0 +1,3 @@
+import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { NxArgs } from '../utils/command-line-utils';
+export declare function getCommandProjects(projectGraph: ProjectGraph, projects: ProjectGraphProjectNode[], nxArgs: NxArgs): string[];

package/src/commands-runner/get-command-projects.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommandProjects = void 0;
+const utils_1 = require("../tasks-runner/utils");
+const create_command_graph_1 = require("./create-command-graph");
+function getCommandProjects(projectGraph, projects, nxArgs) {
+    const commandGraph = (0, create_command_graph_1.createCommandGraph)(projectGraph, projects.map((project) => project.name), nxArgs);
+    return getSortedProjects(commandGraph);
+}
+exports.getCommandProjects = getCommandProjects;
+function getSortedProjects(commandGraph, sortedProjects = []) {
+    const roots = commandGraph.roots;
+    if (!roots.length) {
+        return sortedProjects;
+    }
+    sortedProjects.push(...roots);
+    const newGraph = (0, utils_1.removeIdsFromGraph)(commandGraph, roots, commandGraph.dependencies);
+    return getSortedProjects(newGraph, sortedProjects);
+}

package/src/config/calculate-default-project-name.d.ts

@@ -0,0 +1,4 @@
+import type { NxJsonConfiguration } from './nx-json';
+import { ProjectConfiguration, ProjectsConfigurations } from './workspace-json-project-json';
+export declare function calculateDefaultProjectName(cwd: string, root: string, { projects }: ProjectsConfigurations, nxJson: NxJsonConfiguration): string;
+export declare function findMatchingProjectInCwd(projects: Record<string, ProjectConfiguration>, relativeCwd: string): string | undefined;