@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

package/dist/src/command-line/show/show-target/inputs.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showTargetInputsHandler = showTargetInputsHandler;
+const check_task_files_1 = require("../../../hasher/check-task-files");
+const utils_1 = require("../../../tasks-runner/utils");
+const utils_2 = require("./utils");
+// ── Handler ─────────────────────────────────────────────────────────
+async function showTargetInputsHandler(args) {
+    const t = await (0, utils_2.resolveTarget)(args);
+    const { projectName, targetName, configuration } = t;
+    if ((0, utils_2.hasCustomHasher)(projectName, targetName, t.graph)) {
+        renderCustomHasherWarning(projectName, targetName, args);
+        process.exitCode = 1;
+        return;
+    }
+    const taskId = (0, utils_1.createTaskId)(projectName, targetName, configuration);
+    const hashInputs = await (0, check_task_files_1.getTaskRawInputs)(taskId, {
+        projectGraph: t.graph,
+        nxJson: t.nxJson,
+    });
+    if (!hashInputs) {
+        throw new Error(`Could not find hash plan for task "${taskId}".`);
+    }
+    if (args.check !== undefined) {
+        const results = await checkInputs(taskId, args.check, hashInputs);
+        (0, utils_2.renderCheckResults)(results, projectName, targetName, 'input');
+        (0, utils_2.setCheckExitCode)(results);
+        return;
+    }
+    renderInputs({ project: projectName, target: targetName, ...hashInputs }, t.node.data.targets[targetName].inputs, args);
+}
+// ── Data resolution ─────────────────────────────────────────────────
+async function checkInputs(taskId, check, hashInputs) {
+    // checkFilesAreInputs matches environment/runtime/external names against the
+    // raw argument and paths against the workspace-relative form, so both are
+    // passed through — it has no cwd of its own.
+    const candidates = (0, utils_2.deduplicateFolderEntries)(check).map((value) => ({
+        value,
+        path: (0, utils_2.normalizePath)(value),
+    }));
+    const { categories } = await (0, check_task_files_1.checkFilesAreInputs)(taskId, candidates);
+    return candidates.map(({ value, path }) => {
+        const category = categories.get(value);
+        return {
+            value,
+            file: path,
+            matched: !!category,
+            category,
+            contained: category ? [] : (0, utils_2.pathsUnder)(path, hashInputs.files),
+        };
+    });
+}
+// ── Render ──────────────────────────────────────────────────────────
+function renderInputs(data, configuredInputs, args) {
+    if (args.json) {
+        (0, utils_2.printJson)(data);
+        return;
+    }
+    const c = (0, utils_2.pc)();
+    console.log(`${c.bold('Inputs for')} ${c.cyan(data.project)}:${c.green(data.target)}`);
+    if (configuredInputs?.length) {
+        (0, utils_2.printList)('Configured inputs', configuredInputs.map((i) => typeof i === 'string' ? i : JSON.stringify(i)));
+    }
+    (0, utils_2.printList)('External dependencies', [...data.external].sort());
+    (0, utils_2.printList)('Runtime inputs', [...data.runtime].sort());
+    (0, utils_2.printList)('Environment variables', [...data.environment].sort());
+    (0, utils_2.printList)(`Files (${data.files.length})`, [...data.files, ...data.depOutputs].sort());
+}
+function renderCustomHasherWarning(projectName, targetName, args) {
+    const c = (0, utils_2.pc)();
+    if (args.json) {
+        (0, utils_2.printJson)({
+            project: projectName,
+            target: targetName,
+            warning: 'This target uses a custom hasher. Configured inputs do not affect the cache hash.',
+        });
+        return;
+    }
+    const label = `${c.cyan(projectName)}:${c.green(targetName)}`;
+    console.log(`\n${c.yellow('⚠')} ${label} uses a ${c.yellow('custom hasher')}.`);
+    console.log(`  Configured inputs do not affect the cache hash for this target.`);
+    console.log(`  The executor's hasher determines what is included in the hash.`);
+}

package/dist/src/command-line/show/show-target/outputs.d.ts

@@ -0,0 +1,2 @@
+import type { ShowTargetOutputsOptions } from '../command-object';
+export declare function showTargetOutputsHandler(args: ShowTargetOutputsOptions): Promise<void>;

package/dist/src/command-line/show/show-target/outputs.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showTargetOutputsHandler = showTargetOutputsHandler;
+const check_task_files_1 = require("../../../hasher/check-task-files");
+const utils_1 = require("../../../tasks-runner/utils");
+const utils_2 = require("./utils");
+// ── Handler ─────────────────────────────────────────────────────────
+async function showTargetOutputsHandler(args) {
+    const t = await (0, utils_2.resolveTarget)(args);
+    const { projectName, targetName, configuration } = t;
+    const taskId = (0, utils_1.createTaskId)(projectName, targetName, configuration);
+    const outputs = await (0, check_task_files_1.getTaskOutputs)(taskId, {
+        projectGraph: t.graph,
+        nxJson: t.nxJson,
+    });
+    if (args.check !== undefined) {
+        const results = await checkOutputs(taskId, args.check, outputs);
+        (0, utils_2.renderCheckResults)(results, projectName, targetName, 'output');
+        (0, utils_2.setCheckExitCode)(results);
+        return;
+    }
+    renderOutputs(projectName, targetName, outputs, args);
+}
+// ── Data resolution ─────────────────────────────────────────────────
+async function checkOutputs(taskId, check, { resolved, expanded }) {
+    const checkItems = (0, utils_2.deduplicateFolderEntries)(check);
+    const paths = checkItems.map(utils_2.normalizePath);
+    // checkFilesAreOutputs handles exact, directory-prefix and glob matching (and
+    // `!` exclusions) through the same native engine the task runner uses.
+    const { matched } = await (0, check_task_files_1.checkFilesAreOutputs)(taskId, paths);
+    const matchedPaths = new Set(matched);
+    return checkItems.map((value, i) => {
+        const path = paths[i];
+        const isMatch = matchedPaths.has(path);
+        return {
+            value,
+            file: path,
+            matched: isMatch,
+            contained: isMatch
+                ? []
+                : [
+                    ...new Set([
+                        ...(0, utils_2.pathsUnder)(path, resolved),
+                        ...(0, utils_2.pathsUnder)(path, expanded),
+                    ]),
+                ],
+        };
+    });
+}
+// ── Render ──────────────────────────────────────────────────────────
+function renderOutputs(project, target, { resolved, expanded, unresolved }, args) {
+    if (args.json) {
+        (0, utils_2.printJson)({
+            project,
+            target,
+            outputPaths: resolved,
+            expandedOutputs: expanded,
+            unresolvedOutputs: unresolved,
+        });
+        return;
+    }
+    const c = (0, utils_2.pc)();
+    console.log(`${c.bold('Output paths for')} ${c.cyan(project)}:${c.green(target)}`);
+    (0, utils_2.printList)('Configured outputs', resolved);
+    (0, utils_2.printList)('Resolved outputs', expanded);
+    (0, utils_2.printList)(`${c.yellow('Unresolved outputs')} (option not set)`, unresolved);
+    if (resolved.length === 0 && unresolved.length === 0) {
+        console.log(`\n  No outputs configured for this target.`);
+    }
+}

package/dist/src/command-line/show/show-target/utils.d.ts

@@ -0,0 +1,54 @@
+import type { NxJsonConfiguration } from '../../../config/nx-json';
+import type { ProjectGraph } from '../../../config/project-graph';
+import type { ConfigurationSourceMaps } from '../../../project-graph/utils/project-configuration/source-maps';
+import type { ShowTargetBaseOptions, ShowTargetInputsOptions } from '../command-object';
+export interface ResolvedTarget {
+    graph: ProjectGraph;
+    nxJson: NxJsonConfiguration;
+    projectName: string;
+    targetName: string;
+    configuration: string | undefined;
+    node: ProjectGraph['nodes'][string];
+    sourceMaps?: ConfigurationSourceMaps;
+}
+export declare function resolveTarget(args: ShowTargetBaseOptions | ShowTargetInputsOptions, opts?: {
+    withSourceMaps?: boolean;
+}): Promise<ResolvedTarget>;
+/**
+ * Checks whether a target's executor defines a custom hasher.
+ * Returns true if the executor has a hasherFactory — meaning the
+ * standard input-based hashing is bypassed for this target.
+ */
+export declare function hasCustomHasher(projectName: string, targetName: string, graph: ProjectGraph): boolean;
+export declare function normalizePath(p: string): string;
+export declare function deduplicateFolderEntries(items: string[]): string[];
+export declare function pc(): any;
+export declare function printList(header: string, items: unknown[], prefix?: string): void;
+export declare function printJson(data: Record<string, unknown>): void;
+/** The paths that live under `dir`. An empty `dir` is the workspace root. */
+export declare function pathsUnder(dir: string, paths: string[]): string[];
+export interface CheckResult {
+    /** The argument as the user typed it. */
+    value: string;
+    /** Workspace-relative form of `value`. */
+    file: string;
+    matched: boolean;
+    /** Which rule matched, when the caller can name one. */
+    category?: string;
+    /** Matches found underneath `value`, when it is a directory. */
+    contained: string[];
+}
+declare const NOUNS: {
+    readonly input: {
+        readonly preposition: 'for';
+        readonly contained: 'input file';
+    };
+    readonly output: {
+        readonly preposition: 'of';
+        readonly contained: 'output path';
+    };
+};
+type CheckNoun = keyof typeof NOUNS;
+export declare function renderCheckResults(results: CheckResult[], project: string, target: string, noun: CheckNoun): void;
+export declare function setCheckExitCode(results: CheckResult[]): void;
+export {};

package/dist/src/command-line/show/show-target/utils.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTarget = resolveTarget;
+exports.hasCustomHasher = hasCustomHasher;
+exports.normalizePath = normalizePath;
+exports.deduplicateFolderEntries = deduplicateFolderEntries;
+exports.pc = pc;
+exports.printList = printList;
+exports.printJson = printJson;
+exports.pathsUnder = pathsUnder;
+exports.renderCheckResults = renderCheckResults;
+exports.setCheckExitCode = setCheckExitCode;
+const path_1 = require("path");
+const calculate_default_project_name_1 = require("../../../config/calculate-default-project-name");
+const configuration_1 = require("../../../config/configuration");
+const project_graph_1 = require("../../../project-graph/project-graph");
+const find_matching_projects_1 = require("../../../utils/find-matching-projects");
+const output_1 = require("../../../utils/output");
+const split_target_1 = require("../../../utils/split-target");
+const workspace_root_1 = require("../../../utils/workspace-root");
+async function resolveTarget(args, opts) {
+    performance.mark('code-loading:end');
+    performance.measure('code-loading', 'init-local', 'code-loading:end');
+    let graph;
+    let sourceMaps;
+    if (opts?.withSourceMaps) {
+        const result = await (0, project_graph_1.createProjectGraphAndSourceMapsAsync)();
+        graph = result.projectGraph;
+        sourceMaps = result.sourceMaps;
+    }
+    else {
+        graph = await (0, project_graph_1.createProjectGraphAsync)();
+    }
+    const nxJson = (0, configuration_1.readNxJson)();
+    const { projectName, targetName, configurationName } = resolveTargetIdentifier(args, graph, nxJson);
+    // `resolveProjectNode` accepts a pattern specifier (`my-*`), so the concrete
+    // name it resolved to is the one everything downstream has to use — it is a
+    // lookup key for the task id, not just a label.
+    const node = resolveProjectNode(projectName, graph);
+    const resolvedProjectName = node.name;
+    if (!node.data.targets?.[targetName]) {
+        reportTargetNotFound(resolvedProjectName, targetName, node);
+    }
+    const configuration = configurationName ?? args.configuration;
+    if (configuration) {
+        validateConfiguration(resolvedProjectName, targetName, configuration, node.data.targets[targetName]);
+    }
+    return {
+        graph,
+        nxJson,
+        projectName: resolvedProjectName,
+        targetName,
+        configuration,
+        node,
+        sourceMaps,
+    };
+}
+// ── Target identifier & project resolution ──────────────────────────
+function resolveTargetIdentifier(args, graph, nxJson) {
+    if (!args.target) {
+        output_1.output.error({
+            title: 'No target specified.',
+            bodyLines: [
+                `Please specify a target using:`,
+                `  nx show target <project:target>`,
+                `  nx show target <target>  (infers project from cwd)`,
+            ],
+        });
+        process.exit(1);
+    }
+    const defaultProjectName = (0, calculate_default_project_name_1.calculateDefaultProjectName)(process.cwd(), workspace_root_1.workspaceRoot, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(graph), nxJson);
+    const [project, target, config] = (0, split_target_1.splitTarget)(args.target, graph, {
+        currentProject: defaultProjectName,
+    });
+    if (project && target) {
+        return {
+            projectName: project,
+            targetName: target,
+            configurationName: config,
+        };
+    }
+    const targetName = project; // splitTarget returns the string as the first element
+    const projectName = defaultProjectName;
+    if (!projectName) {
+        output_1.output.error({
+            title: `Could not infer project from the current working directory.`,
+            bodyLines: [
+                `Please specify the project explicitly:`,
+                `  nx show target <project>:${targetName}`,
+                ``,
+                `Or run this command from within a project directory.`,
+            ],
+        });
+        process.exit(1);
+    }
+    return { projectName, targetName };
+}
+function resolveProjectNode(projectName, graph) {
+    let node = graph.nodes[projectName];
+    if (!node) {
+        const projects = (0, find_matching_projects_1.findMatchingProjects)([projectName], graph.nodes);
+        if (projects.length === 1) {
+            node = graph.nodes[projects[0]];
+        }
+        else if (projects.length > 1) {
+            output_1.output.error({
+                title: `Multiple projects matched "${projectName}":`,
+                bodyLines: projects.length > 100 ? [...projects.slice(0, 100), '...'] : projects,
+            });
+            process.exit(1);
+        }
+        else {
+            output_1.output.error({ title: `Could not find project "${projectName}".` });
+            process.exit(1);
+        }
+    }
+    return node;
+}
+function reportTargetNotFound(projectName, targetName, node) {
+    const availableTargets = Object.keys(node.data.targets ?? {});
+    output_1.output.error({
+        title: `Target "${targetName}" not found for project "${projectName}".`,
+        bodyLines: availableTargets.length
+            ? [`Available targets:`, ...availableTargets.map((t) => `  - ${t}`)]
+            : [`This project has no targets configured.`],
+    });
+    process.exit(1);
+}
+function validateConfiguration(projectName, targetName, configuration, targetConfig) {
+    const availableConfigs = Object.keys(targetConfig.configurations ?? {});
+    if (!availableConfigs.includes(configuration)) {
+        output_1.output.error({
+            title: `Configuration "${configuration}" not found for target "${projectName}:${targetName}".`,
+            bodyLines: availableConfigs.length
+                ? [
+                    `Available configurations:`,
+                    ...availableConfigs.map((c) => `  - ${c}`),
+                ]
+                : [`This target has no configurations.`],
+        });
+        process.exit(1);
+    }
+}
+// ── Custom hasher detection ──────────────────────────────────────────
+/**
+ * Checks whether a target's executor defines a custom hasher.
+ * Returns true if the executor has a hasherFactory — meaning the
+ * standard input-based hashing is bypassed for this target.
+ */
+function hasCustomHasher(projectName, targetName, graph) {
+    // Lazy require avoids a circular dependency with tasks-runner/utils.
+    const { getExecutorForTask } = require('../../../tasks-runner/utils');
+    try {
+        const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(graph);
+        const task = {
+            id: `${projectName}:${targetName}`,
+            target: { project: projectName, target: targetName },
+            overrides: {},
+        };
+        return !!getExecutorForTask(task, projects).hasherFactory;
+    }
+    catch {
+        return false;
+    }
+}
+// ── Small helpers shared across slices ───────────────────────────────
+function normalizePath(p) {
+    const absolute = (0, path_1.resolve)(process.cwd(), p);
+    return (0, path_1.relative)(workspace_root_1.workspaceRoot, absolute).replace(/\\/g, '/');
+}
+function deduplicateFolderEntries(items) {
+    const normalized = items.map((item) => ({
+        original: item,
+        path: normalizePath(item),
+    }));
+    return normalized
+        .filter(({ path }) => {
+        const dirPrefix = path.endsWith('/') ? path : path + '/';
+        return !normalized.some((other) => other.path !== path && other.path.startsWith(dirPrefix));
+    })
+        .map(({ original }) => original);
+}
+let _pc;
+function pc() {
+    return (_pc ??= require('picocolors'));
+}
+function printList(header, items, prefix = '\n') {
+    if (items.length === 0)
+        return;
+    console.log(`${prefix}${pc().bold(header)}:`);
+    for (const item of items)
+        console.log(`  ${item}`);
+}
+function printJson(data) {
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (Array.isArray(value) && value.length === 0)
+            continue;
+        result[key] = value;
+    }
+    console.log(JSON.stringify(result, null, 2));
+}
+/** The paths that live under `dir`. An empty `dir` is the workspace root. */
+function pathsUnder(dir, paths) {
+    if (dir === '')
+        return [...paths];
+    const prefix = dir.endsWith('/') ? dir : dir + '/';
+    return paths.filter((p) => p.startsWith(prefix));
+}
+const NOUNS = {
+    input: { preposition: 'for', contained: 'input file' },
+    output: { preposition: 'of', contained: 'output path' },
+};
+function renderCheckResults(results, project, target, noun) {
+    if (results.length >= 2) {
+        renderBatchCheckResults(results, project, target, noun);
+        return;
+    }
+    for (const result of results) {
+        renderCheckResult(result, project, target, noun);
+    }
+}
+function setCheckExitCode(results) {
+    for (const result of results) {
+        process.exitCode ||= result.matched || result.contained.length ? 0 : 1;
+    }
+}
+function renderCheckResult(result, project, target, noun) {
+    const c = pc();
+    const { preposition, contained } = NOUNS[noun];
+    const label = `${c.cyan(project)}:${c.green(target)}`;
+    if (result.matched) {
+        const category = result.category ? ` (${result.category})` : '';
+        console.log(`${c.green('✓')} ${c.bold(result.value)} is an ${noun} ${preposition} ${label}${category}`);
+    }
+    else if (result.contained.length > 0) {
+        console.log(`${c.yellow('~')} ${c.bold(result.file)} is a directory containing ${c.bold(String(result.contained.length))} ${contained}(s) ${preposition} ${label}`);
+        for (const item of [...result.contained].sort())
+            console.log(`  ${item}`);
+    }
+    else {
+        console.log(`${c.red('✗')} ${c.bold(result.value)} is ${c.red('not')} an ${noun} ${preposition} ${label}`);
+    }
+}
+function renderBatchCheckResults(results, project, target, noun) {
+    const c = pc();
+    const { preposition, contained } = NOUNS[noun];
+    const label = `${c.cyan(project)}:${c.green(target)}`;
+    const matched = results.filter((r) => r.matched);
+    const directories = results.filter((r) => !r.matched && r.contained.length);
+    const unmatched = results.filter((r) => !r.matched && !r.contained.length);
+    if (matched.length > 0 || directories.length > 0) {
+        console.log(`\n${c.green('✓')} These arguments were ${noun}s ${preposition} ${label}:`);
+        for (const r of matched)
+            console.log(`  ${r.value}`);
+        for (const r of directories) {
+            console.log(`  ${r.file} (directory containing ${r.contained.length} ${contained}s)`);
+        }
+    }
+    if (unmatched.length > 0) {
+        console.log(`\n${c.red('✗')} These arguments were ${c.red('not')} ${noun}s ${preposition} ${label}:`);
+        for (const r of unmatched)
+            console.log(`  ${r.value}`);
+    }
+}

package/dist/src/command-line/sync/command-object.d.ts

@@ -0,0 +1,6 @@
+import type { CommandModule } from 'yargs';
+export interface SyncArgs {
+    verbose?: boolean;
+}
+export declare const yargsSyncCommand: CommandModule<Record<string, unknown>, SyncArgs>;
+export declare const yargsSyncCheckCommand: CommandModule<Record<string, unknown>, SyncArgs>;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsSyncCheckCommand = exports.yargsSyncCommand = void 0;
+const shared_options_1 = require("../yargs-utils/shared-options");
+const handle_import_1 = require("../../utils/handle-import");
+exports.yargsSyncCommand = {
+    command: 'sync',
+    describe: 'Sync the workspace files by running all the sync generators.',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs),
+    handler: async (args) => {
+        process.exit(await (0, handle_import_1.handleImport)('./sync.js', __dirname).then((m) => m.syncHandler(args)));
+    },
+};
+exports.yargsSyncCheckCommand = {
+    command: 'sync:check',
+    describe: 'Check that no changes are required after running all sync generators.',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs),
+    handler: async (args) => {
+        process.exit(await (0, handle_import_1.handleImport)('./sync.js', __dirname).then((m) => m.syncHandler({ ...args, check: true })));
+    },
+};

package/dist/src/command-line/sync/sync.d.ts

@@ -0,0 +1,6 @@
+import type { SyncArgs } from './command-object';
+interface SyncOptions extends SyncArgs {
+    check?: boolean;
+}
+export declare function syncHandler(options: SyncOptions): Promise<number>;
+export {};

package/dist/src/command-line/sync/sync.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncHandler = syncHandler;
+const tslib_1 = require("tslib");
+const nx_json_1 = require("../../config/nx-json");
+const project_graph_1 = require("../../project-graph/project-graph");
+const output_1 = require("../../utils/output");
+const handle_errors_1 = require("../../utils/handle-errors");
+const sync_generators_1 = require("../../utils/sync-generators");
+const pc = tslib_1.__importStar(require("picocolors"));
+const spinner_1 = require("../../utils/spinner");
+function syncHandler(options) {
+    return (0, handle_errors_1.handleErrors)(options.verbose, async () => {
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+        const nxJson = (0, nx_json_1.readNxJson)();
+        const { globalGenerators, taskGenerators } = await (0, sync_generators_1.collectAllRegisteredSyncGenerators)(projectGraph, nxJson);
+        if (!globalGenerators.length && !taskGenerators.length) {
+            output_1.output.success({
+                title: options.check
+                    ? 'The workspace is up to date'
+                    : 'The workspace is already up to date',
+                bodyLines: ['There are no sync generators to run.'],
+            });
+            return 0;
+        }
+        const syncGenerators = Array.from(new Set([...globalGenerators, ...taskGenerators]));
+        const results = await (0, sync_generators_1.getSyncGeneratorChanges)(syncGenerators);
+        if (!results.length) {
+            output_1.output.success({
+                title: options.check
+                    ? 'The workspace is up to date'
+                    : 'The workspace is already up to date',
+                bodyLines: syncGenerators.map((generator) => `[${pc.bold(generator)}]: All files are up to date.`),
+            });
+            return 0;
+        }
+        const { failedGeneratorsCount, areAllResultsFailures, anySyncGeneratorsFailed, } = (0, sync_generators_1.processSyncGeneratorResultErrors)(results);
+        const failedSyncGeneratorsFixMessageLines = (0, sync_generators_1.getFailedSyncGeneratorsFixMessageLines)(results, options.verbose, new Set(globalGenerators));
+        if (areAllResultsFailures) {
+            output_1.output.error({
+                title: `The workspace is probably out of sync because ${failedGeneratorsCount === 1
+                    ? 'a sync generator'
+                    : 'some sync generators'} failed to run`,
+                bodyLines: failedSyncGeneratorsFixMessageLines,
+            });
+            return 1;
+        }
+        const resultBodyLines = (0, sync_generators_1.getSyncGeneratorSuccessResultsMessageLines)(results, 
+        // log the out of sync details if the user is running `nx sync --check`
+        options.check);
+        if (options.check) {
+            output_1.output.error({
+                title: 'The workspace is out of sync',
+                bodyLines: [
+                    ...resultBodyLines,
+                    '',
+                    'Run `nx sync` to sync the workspace.',
+                ],
+            });
+            if (anySyncGeneratorsFailed) {
+                output_1.output.error({
+                    title: failedGeneratorsCount === 1
+                        ? 'A sync generator failed to run'
+                        : 'Some sync generators failed to run',
+                    bodyLines: failedSyncGeneratorsFixMessageLines,
+                });
+            }
+            return 1;
+        }
+        output_1.output.warn({
+            title: 'The workspace is out of sync',
+            bodyLines: resultBodyLines,
+        });
+        const spinner = spinner_1.globalSpinner.start('Syncing the workspace...');
+        try {
+            const flushResult = await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
+            if ('generatorFailures' in flushResult) {
+                spinner.fail();
+                output_1.output.error({
+                    title: 'Failed to sync the workspace',
+                    bodyLines: (0, sync_generators_1.getFlushFailureMessageLines)(flushResult, options.verbose, new Set(globalGenerators)),
+                });
+                return 1;
+            }
+        }
+        catch (e) {
+            spinner.fail();
+            output_1.output.error({
+                title: 'Failed to sync the workspace',
+                bodyLines: [
+                    'Syncing the workspace failed with the following error:',
+                    '',
+                    e.message,
+                    ...(!!e.stack ? [`\n${e.stack}`] : []),
+                    '',
+                    'Please report the error at: https://github.com/nrwl/nx/issues/new/choose',
+                ],
+            });
+            return 1;
+        }
+        const successTitle = anySyncGeneratorsFailed
+            ? // the identified changes were synced successfully, but the workspace
+                // is still not up to date, which we'll mention next
+                'The identified changes were synced successfully!'
+            : // the workspace is fully up to date
+                'The workspace was synced successfully!';
+        const successSubtitle = 'Please make sure to commit the changes to your repository.';
+        spinner.succeed(`${successTitle}\n\n${successSubtitle}`);
+        if (anySyncGeneratorsFailed) {
+            output_1.output.error({
+                title: `The workspace is probably still out of sync because ${failedGeneratorsCount === 1
+                    ? 'a sync generator'
+                    : 'some sync generators'} failed to run`,
+                bodyLines: failedSyncGeneratorsFixMessageLines,
+            });
+            return 1;
+        }
+        return 0;
+    });
+}

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

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