nx 20.8.4 → 22.7.7

package/dist/src/utils/split-target.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitTargetFromNodes = splitTargetFromNodes;
+exports.splitTargetFromConfigurations = splitTargetFromConfigurations;
+exports.splitTarget = splitTarget;
+exports.splitByColons = splitByColons;
+const output_1 = require("../utils/output");
+function nodeLookup(nodes) {
+    return {
+        has: (name) => !!nodes[name],
+        getTargets: (name) => nodes[name]?.data?.targets,
+    };
+}
+function configLookup(configs) {
+    return {
+        has: (name) => !!configs[name],
+        getTargets: (name) => configs[name]?.targets,
+    };
+}
+/**
+ * Collects all valid [project, target?, config?] interpretations of a
+ * colon-delimited string by iterating over the *segments* of the string
+ * (O(k²) where k = number of segments) rather than over every project in the
+ * graph.
+ *
+ * When `currentProject` is provided, bare-target interpretations (the string
+ * is `target` or `target:config` on that project) are also collected.
+ */
+function findAllMatchingSegments(segments, lookup, currentProject) {
+    const matches = [];
+    // --- Bare-target matches (currentProject context) ---
+    if (currentProject && lookup.has(currentProject)) {
+        const targets = lookup.getTargets(currentProject) || {};
+        for (let j = 1; j <= segments.length; j++) {
+            const candidateTarget = segments.slice(0, j).join(':');
+            if (!(candidateTarget in targets)) {
+                continue;
+            }
+            const configSegments = segments.slice(j);
+            if (configSegments.length === 0) {
+                matches.push([currentProject, candidateTarget]);
+            }
+            else {
+                const candidateConfig = configSegments.join(':');
+                const configurations = targets[candidateTarget]?.configurations;
+                if (configurations && candidateConfig in configurations) {
+                    matches.push([currentProject, candidateTarget, candidateConfig]);
+                }
+            }
+        }
+    }
+    // --- Project-based matches ---
+    for (let i = 1; i <= segments.length; i++) {
+        const candidateProject = segments.slice(0, i).join(':');
+        if (!lookup.has(candidateProject)) {
+            continue;
+        }
+        const remaining = segments.slice(i);
+        if (remaining.length === 0) {
+            matches.push([candidateProject]);
+            continue;
+        }
+        const targets = lookup.getTargets(candidateProject) || {};
+        for (let j = 1; j <= remaining.length; j++) {
+            const candidateTarget = remaining.slice(0, j).join(':');
+            if (!(candidateTarget in targets)) {
+                continue;
+            }
+            const configSegments = remaining.slice(j);
+            if (configSegments.length === 0) {
+                matches.push([candidateProject, candidateTarget]);
+            }
+            else {
+                const candidateConfig = configSegments.join(':');
+                const configurations = targets[candidateTarget]?.configurations;
+                if (configurations && candidateConfig in configurations) {
+                    matches.push([candidateProject, candidateTarget, candidateConfig]);
+                }
+            }
+        }
+    }
+    return matches;
+}
+/**
+ * Returns whether `a` should be preferred over `b` using deterministic
+ * precedence rules:
+ *
+ * 1. Bare-target matches (currentProject) rank highest.
+ * 2. Longest (most-specific) project name.
+ * 3. Longest target name.
+ * 4. Longest configuration name.
+ */
+function isHigherPrecedence(a, b, currentProject) {
+    const aIsBare = currentProject && a[0] === currentProject ? 1 : 0;
+    const bIsBare = currentProject && b[0] === currentProject ? 1 : 0;
+    if (aIsBare !== bIsBare)
+        return aIsBare > bIsBare;
+    if (a[0].length !== b[0].length)
+        return a[0].length > b[0].length;
+    const aTarget = (a[1] ?? '').length;
+    const bTarget = (b[1] ?? '').length;
+    if (aTarget !== bTarget)
+        return aTarget > bTarget;
+    return (a[2] ?? '').length > (b[2] ?? '').length;
+}
+/**
+ * Single-pass selection of the highest-precedence match.
+ */
+function bestMatch(matches, currentProject) {
+    let best = matches[0];
+    for (let i = 1; i < matches.length; i++) {
+        if (isHigherPrecedence(matches[i], best, currentProject)) {
+            best = matches[i];
+        }
+    }
+    return best;
+}
+function formatMatch(match) {
+    return match.filter(Boolean).join(':');
+}
+/**
+ * Internal implementation shared by splitTargetFromNodes and
+ * splitTargetFromConfigurations.
+ */
+function splitTargetImpl(s, lookup, options) {
+    const silent = options?.silent ?? false;
+    const currentProject = options?.currentProject;
+    const segments = splitByColons(s);
+    const matches = findAllMatchingSegments(segments, lookup, currentProject);
+    if (matches.length > 0) {
+        const best = bestMatch(matches, currentProject);
+        if (matches.length > 1 && !silent) {
+            output_1.output.warn({
+                title: `Ambiguous target specifier "${s}"`,
+                bodyLines: [
+                    `This string can be interpreted in multiple ways:`,
+                    ...matches.map((m) => `  ${m === best ? '→' : ' '} ${formatMatch(m)}${m === best ? ' (selected)' : ''}`),
+                    ``,
+                    `The most specific match was selected. To avoid ambiguity, use a unique target specifier.`,
+                ],
+            });
+        }
+        return best;
+    }
+    // --- Fallback: no exact match found in the graph ---
+    let colonIndex = s.indexOf(':');
+    if (colonIndex === 0) {
+        // first colon can't be at the beginning of the string, try to find the next one
+        colonIndex = s.indexOf(':', 1);
+    }
+    if (colonIndex > 0) {
+        let [project, ...remainingSegments] = segments;
+        // splitByColons splits on every ':', so a leading colon (e.g. ":pkg:build")
+        // produces an empty first element. Greedily absorb segments to reconstruct
+        // the longest known colon-prefixed project name (e.g. ":utils:common").
+        if (project === '' && remainingSegments.length > 0) {
+            let absorbed = 1; // absorb at least one segment
+            for (let k = remainingSegments.length - 1; k >= 1; k--) {
+                const candidate = ':' + remainingSegments.slice(0, k).join(':');
+                if (lookup.has(candidate)) {
+                    absorbed = k;
+                    break;
+                }
+            }
+            project = ':' + remainingSegments.slice(0, absorbed).join(':');
+            remainingSegments = remainingSegments.slice(absorbed);
+        }
+        // if only configuration cannot be matched, try to match project and target
+        const configuration = remainingSegments[remainingSegments.length - 1];
+        const rest = s.slice(0, -(configuration.length + 1));
+        const restSegments = splitByColons(rest);
+        const restMatches = findAllMatchingSegments(restSegments, lookup, currentProject);
+        if (restMatches.length > 0) {
+            const best = bestMatch(restMatches, currentProject);
+            if (best.length === 2) {
+                return [...best, configuration];
+            }
+        }
+        // no project-target pair found, do the naive matching
+        const validTargets = lookup.getTargets(project);
+        const validTargetNames = new Set(Object.keys(validTargets ?? {}));
+        return [
+            project,
+            ...groupJointSegments(remainingSegments, validTargetNames),
+        ];
+    }
+    // we don't know what to do with the string, return as is
+    return [s];
+}
+function splitTargetFromNodes(s, nodes, options) {
+    return splitTargetImpl(s, nodeLookup(nodes), options);
+}
+/**
+ * Splits a colon-delimited target specifier using a name-keyed
+ * `Record<string, ProjectConfiguration>` — the format used during
+ * the merge phase before the full project graph is available.
+ */
+function splitTargetFromConfigurations(s, configs, options) {
+    return splitTargetImpl(s, configLookup(configs), options);
+}
+function splitTarget(s, projectGraph, options) {
+    return splitTargetFromNodes(s, projectGraph.nodes, options);
+}
+function groupJointSegments(segments, validTargetNames) {
+    for (let endingSegmentIdx = segments.length; endingSegmentIdx > 0; endingSegmentIdx--) {
+        const potentialTargetName = segments.slice(0, endingSegmentIdx).join(':');
+        if (validTargetNames.has(potentialTargetName)) {
+            const configurationName = endingSegmentIdx < segments.length
+                ? segments.slice(endingSegmentIdx).join(':')
+                : null;
+            return configurationName
+                ? [potentialTargetName, configurationName]
+                : [potentialTargetName];
+        }
+    }
+    // If we can't find a segment match, keep older behaviour
+    return segments;
+}
+function splitByColons(s) {
+    const parts = [];
+    let currentPart = '';
+    for (let i = 0; i < s.length; ++i) {
+        if (s[i] === ':') {
+            parts.push(currentPart);
+            currentPart = '';
+        }
+        else if (s[i] === '"') {
+            i++;
+            for (; i < s.length && s[i] != '"'; ++i) {
+                currentPart += s[i];
+            }
+        }
+        else {
+            currentPart += s[i];
+        }
+    }
+    parts.push(currentPart);
+    return parts;
+}

package/dist/src/utils/sync-generators.d.ts

@@ -0,0 +1,66 @@
+import type { GeneratorCallback } from '../config/misc-interfaces';
+import { type NxJsonConfiguration } from '../config/nx-json';
+import type { ProjectGraph } from '../config/project-graph';
+import type { TaskGraph } from '../config/task-graph';
+import type { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { type FileChange, type Tree } from '../generators/tree';
+export type SyncGeneratorResult = void | {
+    callback?: GeneratorCallback;
+    outOfSyncMessage?: string;
+    outOfSyncDetails?: string[];
+};
+export type SyncGenerator = (tree: Tree) => SyncGeneratorResult | Promise<SyncGeneratorResult>;
+export type SyncGeneratorRunSuccessResult = {
+    generatorName: string;
+    changes: FileChange[];
+    callback?: GeneratorCallback;
+    outOfSyncMessage?: string;
+    outOfSyncDetails?: string[];
+};
+type SerializableSimpleError = {
+    message: string;
+    stack: string | undefined;
+    title?: string;
+    bodyLines?: string[];
+};
+export type SyncGeneratorRunErrorResult = {
+    generatorName: string;
+    error: SerializableSimpleError;
+};
+export type SyncGeneratorRunResult = SyncGeneratorRunSuccessResult | SyncGeneratorRunErrorResult;
+type FlushSyncGeneratorChangesSuccess = {
+    success: true;
+};
+type FlushSyncGeneratorFailure = {
+    generator: string;
+    error: SerializableSimpleError;
+};
+type FlushSyncGeneratorChangesFailure = {
+    generatorFailures: FlushSyncGeneratorFailure[];
+    generalFailure?: SerializableSimpleError;
+};
+export type FlushSyncGeneratorChangesResult = FlushSyncGeneratorChangesSuccess | FlushSyncGeneratorChangesFailure;
+export declare class SyncError extends Error {
+    title: string;
+    bodyLines?: string[];
+    constructor(title: string, bodyLines?: string[]);
+}
+export declare function getSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorRunResult[]>;
+export declare function flushSyncGeneratorChanges(results: SyncGeneratorRunResult[]): Promise<FlushSyncGeneratorChangesResult>;
+export declare function collectAllRegisteredSyncGenerators(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Promise<{
+    globalGenerators: string[];
+    taskGenerators: string[];
+}>;
+export declare function runSyncGenerator(tree: Tree, generatorSpecifier: string, projects: Record<string, ProjectConfiguration>): Promise<SyncGeneratorRunResult>;
+export declare function collectEnabledTaskSyncGeneratorsFromProjectGraph(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Set<string>;
+export declare function collectEnabledTaskSyncGeneratorsFromTaskGraph(taskGraph: TaskGraph, projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Set<string>;
+export declare function collectRegisteredGlobalSyncGenerators(nxJson?: NxJsonConfiguration<string[] | "*">): Set<string>;
+export declare function getSyncGeneratorSuccessResultsMessageLines(results: SyncGeneratorRunResult[], logOutOfSyncDetails?: boolean): string[];
+export declare function getFailedSyncGeneratorsFixMessageLines(results: SyncGeneratorRunResult[], verbose: boolean, globalGeneratorSet?: Set<string>): string[];
+export declare function getFlushFailureMessageLines(result: FlushSyncGeneratorChangesFailure, verbose: boolean, globalGeneratorSet?: Set<string>): string[];
+export declare function processSyncGeneratorResultErrors(results: SyncGeneratorRunResult[]): {
+    failedGeneratorsCount: number;
+    areAllResultsFailures: boolean;
+    anySyncGeneratorsFailed: boolean;
+};
+export {};

package/dist/src/utils/sync-generators.js

@@ -0,0 +1,355 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncError = void 0;
+exports.getSyncGeneratorChanges = getSyncGeneratorChanges;
+exports.flushSyncGeneratorChanges = flushSyncGeneratorChanges;
+exports.collectAllRegisteredSyncGenerators = collectAllRegisteredSyncGenerators;
+exports.runSyncGenerator = runSyncGenerator;
+exports.collectEnabledTaskSyncGeneratorsFromProjectGraph = collectEnabledTaskSyncGeneratorsFromProjectGraph;
+exports.collectEnabledTaskSyncGeneratorsFromTaskGraph = collectEnabledTaskSyncGeneratorsFromTaskGraph;
+exports.collectRegisteredGlobalSyncGenerators = collectRegisteredGlobalSyncGenerators;
+exports.getSyncGeneratorSuccessResultsMessageLines = getSyncGeneratorSuccessResultsMessageLines;
+exports.getFailedSyncGeneratorsFixMessageLines = getFailedSyncGeneratorsFixMessageLines;
+exports.getFlushFailureMessageLines = getFlushFailureMessageLines;
+exports.processSyncGeneratorResultErrors = processSyncGeneratorResultErrors;
+const tslib_1 = require("tslib");
+const perf_hooks_1 = require("perf_hooks");
+const generate_1 = require("../command-line/generate/generate");
+const generator_utils_1 = require("../command-line/generate/generator-utils");
+const nx_json_1 = require("../config/nx-json");
+const client_1 = require("../daemon/client/client");
+const is_on_daemon_1 = require("../daemon/is-on-daemon");
+const tree_1 = require("../generators/tree");
+const project_graph_1 = require("../project-graph/project-graph");
+const workspace_context_1 = require("./workspace-context");
+const workspace_root_1 = require("./workspace-root");
+const pc = tslib_1.__importStar(require("picocolors"));
+class SyncError extends Error {
+    constructor(title, bodyLines) {
+        super(title);
+        this.title = title;
+        this.bodyLines = bodyLines;
+        this.name = this.constructor.name;
+    }
+}
+exports.SyncError = SyncError;
+async function getSyncGeneratorChanges(generators) {
+    perf_hooks_1.performance.mark('get-sync-generators-changes:start');
+    let results;
+    if (!client_1.daemonClient.enabled()) {
+        results = await runSyncGenerators(generators);
+    }
+    else {
+        results = await client_1.daemonClient.getSyncGeneratorChanges(generators);
+    }
+    perf_hooks_1.performance.mark('get-sync-generators-changes:end');
+    perf_hooks_1.performance.measure('get-sync-generators-changes', 'get-sync-generators-changes:start', 'get-sync-generators-changes:end');
+    return results.filter((r) => ('error' in r ? true : r.changes.length > 0));
+}
+async function flushSyncGeneratorChanges(results) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        return await flushSyncGeneratorChangesToDisk(results);
+    }
+    return await client_1.daemonClient.flushSyncGeneratorChangesToDisk(results.map((r) => r.generatorName));
+}
+async function collectAllRegisteredSyncGenerators(projectGraph, nxJson) {
+    if (!client_1.daemonClient.enabled()) {
+        return {
+            globalGenerators: [...collectRegisteredGlobalSyncGenerators()],
+            taskGenerators: [
+                ...collectEnabledTaskSyncGeneratorsFromProjectGraph(projectGraph, nxJson),
+            ],
+        };
+    }
+    return await client_1.daemonClient.getRegisteredSyncGenerators();
+}
+async function runSyncGenerator(tree, generatorSpecifier, projects) {
+    try {
+        perf_hooks_1.performance.mark(`run-sync-generator:${generatorSpecifier}:start`);
+        const { collection, generator } = (0, generate_1.parseGeneratorString)(generatorSpecifier);
+        const { implementationFactory } = (0, generator_utils_1.getGeneratorInformation)(collection, generator, workspace_root_1.workspaceRoot, projects);
+        const implementation = implementationFactory();
+        const result = await implementation(tree);
+        let callback;
+        let outOfSyncMessage;
+        let outOfSyncDetails;
+        if (result && typeof result === 'object') {
+            callback = result.callback;
+            outOfSyncMessage = result.outOfSyncMessage;
+            outOfSyncDetails = result.outOfSyncDetails;
+        }
+        perf_hooks_1.performance.mark(`run-sync-generator:${generatorSpecifier}:end`);
+        perf_hooks_1.performance.measure(`run-sync-generator:${generatorSpecifier}`, `run-sync-generator:${generatorSpecifier}:start`, `run-sync-generator:${generatorSpecifier}:end`);
+        return {
+            changes: tree.listChanges(),
+            generatorName: generatorSpecifier,
+            callback,
+            outOfSyncMessage,
+            outOfSyncDetails,
+        };
+    }
+    catch (e) {
+        return {
+            generatorName: generatorSpecifier,
+            error: toSerializableError(e),
+        };
+    }
+}
+function collectEnabledTaskSyncGeneratorsFromProjectGraph(projectGraph, nxJson) {
+    const taskSyncGenerators = new Set();
+    const disabledTaskSyncGenerators = new Set(nxJson.sync?.disabledTaskSyncGenerators ?? []);
+    for (const { data: { targets }, } of Object.values(projectGraph.nodes)) {
+        if (!targets) {
+            continue;
+        }
+        for (const target of Object.values(targets)) {
+            if (!target.syncGenerators?.length) {
+                continue;
+            }
+            for (const generator of target.syncGenerators) {
+                if (!disabledTaskSyncGenerators.has(generator) &&
+                    !taskSyncGenerators.has(generator)) {
+                    taskSyncGenerators.add(generator);
+                }
+            }
+        }
+    }
+    return taskSyncGenerators;
+}
+function collectEnabledTaskSyncGeneratorsFromTaskGraph(taskGraph, projectGraph, nxJson) {
+    const taskSyncGenerators = new Set();
+    const disabledTaskSyncGenerators = new Set(nxJson.sync?.disabledTaskSyncGenerators ?? []);
+    for (const { target } of Object.values(taskGraph.tasks)) {
+        const { syncGenerators } = projectGraph.nodes[target.project].data.targets[target.target];
+        if (!syncGenerators?.length) {
+            continue;
+        }
+        for (const generator of syncGenerators) {
+            if (!disabledTaskSyncGenerators.has(generator) &&
+                !taskSyncGenerators.has(generator)) {
+                taskSyncGenerators.add(generator);
+            }
+        }
+    }
+    return taskSyncGenerators;
+}
+function collectRegisteredGlobalSyncGenerators(nxJson = (0, nx_json_1.readNxJson)()) {
+    const globalSyncGenerators = new Set();
+    if (!nxJson.sync?.globalGenerators?.length) {
+        return globalSyncGenerators;
+    }
+    for (const generator of nxJson.sync.globalGenerators) {
+        globalSyncGenerators.add(generator);
+    }
+    return globalSyncGenerators;
+}
+function getSyncGeneratorSuccessResultsMessageLines(results, logOutOfSyncDetails = false) {
+    const messageLines = [];
+    for (const result of results) {
+        if ('error' in result) {
+            continue;
+        }
+        messageLines.push(`[${pc.bold(result.generatorName)}]: ${result.outOfSyncMessage ?? `Some files are out of sync.`}`);
+        if (logOutOfSyncDetails && result.outOfSyncDetails?.length) {
+            messageLines.push(...result.outOfSyncDetails);
+        }
+    }
+    return messageLines;
+}
+function getFailedSyncGeneratorsFixMessageLines(results, verbose, globalGeneratorSet = new Set()) {
+    const messageLines = [];
+    const globalGenerators = [];
+    const taskGenerators = [];
+    let isFirst = true;
+    for (const result of results) {
+        if ('error' in result) {
+            if (!isFirst && verbose) {
+                messageLines.push('');
+            }
+            isFirst = false;
+            messageLines.push(`[${pc.bold(result.generatorName)}]: ${errorToString(result.error, verbose)}`);
+            if (globalGeneratorSet.has(result.generatorName)) {
+                globalGenerators.push(result.generatorName);
+            }
+            else {
+                taskGenerators.push(result.generatorName);
+            }
+        }
+    }
+    messageLines.push(...getFailedSyncGeneratorsMessageLines(taskGenerators, globalGenerators, verbose));
+    return messageLines;
+}
+function getFlushFailureMessageLines(result, verbose, globalGeneratorSet = new Set()) {
+    const messageLines = [];
+    const globalGenerators = [];
+    const taskGenerators = [];
+    let isFirst = true;
+    for (const failure of result.generatorFailures) {
+        if (!isFirst && verbose) {
+            messageLines.push('');
+        }
+        isFirst = false;
+        messageLines.push(`[${pc.bold(failure.generator)}]: ${errorToString(failure.error, verbose)}`);
+        if (globalGeneratorSet.has(failure.generator)) {
+            globalGenerators.push(failure.generator);
+        }
+        else {
+            taskGenerators.push(failure.generator);
+        }
+    }
+    messageLines.push(...getFailedSyncGeneratorsMessageLines(taskGenerators, globalGenerators, verbose));
+    if (result.generalFailure) {
+        if (messageLines.length > 0) {
+            messageLines.push('');
+            messageLines.push('Additionally, an unexpected error occurred:');
+        }
+        else {
+            messageLines.push('An unexpected error occurred:');
+        }
+        messageLines.push(...[
+            '',
+            result.generalFailure.message,
+            ...(!!result.generalFailure.stack
+                ? [`\n${result.generalFailure.stack}`]
+                : []),
+            '',
+            'Please report the error at: https://github.com/nrwl/nx/issues/new/choose',
+        ]);
+    }
+    return messageLines;
+}
+function processSyncGeneratorResultErrors(results) {
+    let failedGeneratorsCount = 0;
+    for (const result of results) {
+        if ('error' in result) {
+            failedGeneratorsCount++;
+        }
+    }
+    const areAllResultsFailures = failedGeneratorsCount === results.length;
+    const anySyncGeneratorsFailed = failedGeneratorsCount > 0;
+    return {
+        failedGeneratorsCount,
+        areAllResultsFailures,
+        anySyncGeneratorsFailed,
+    };
+}
+async function runSyncGenerators(generators) {
+    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, false, 'running sync generators');
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+    const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    const results = [];
+    for (const generator of generators) {
+        const result = await runSyncGenerator(tree, generator, projects);
+        results.push(result);
+    }
+    return results;
+}
+async function flushSyncGeneratorChangesToDisk(results) {
+    perf_hooks_1.performance.mark('flush-sync-generator-changes-to-disk:start');
+    const createdFiles = [];
+    const updatedFiles = [];
+    const deletedFiles = [];
+    const generatorFailures = [];
+    for (const result of results) {
+        if ('error' in result) {
+            continue;
+        }
+        for (const change of result.changes) {
+            if (change.type === 'CREATE') {
+                createdFiles.push(change.path);
+            }
+            else if (change.type === 'UPDATE') {
+                updatedFiles.push(change.path);
+            }
+            else if (change.type === 'DELETE') {
+                deletedFiles.push(change.path);
+            }
+        }
+        try {
+            // Write changes to disk
+            (0, tree_1.flushChanges)(workspace_root_1.workspaceRoot, result.changes);
+            // Run the callback
+            if (result.callback) {
+                await result.callback();
+            }
+        }
+        catch (e) {
+            generatorFailures.push({
+                generator: result.generatorName,
+                error: toSerializableError(e),
+            });
+        }
+    }
+    try {
+        // Update the context files
+        await (0, workspace_context_1.updateContextWithChangedFiles)(workspace_root_1.workspaceRoot, createdFiles, updatedFiles, deletedFiles);
+        perf_hooks_1.performance.mark('flush-sync-generator-changes-to-disk:end');
+        perf_hooks_1.performance.measure('flush sync generator changes to disk', 'flush-sync-generator-changes-to-disk:start', 'flush-sync-generator-changes-to-disk:end');
+    }
+    catch (e) {
+        return {
+            generatorFailures,
+            generalFailure: toSerializableError(e),
+        };
+    }
+    return generatorFailures.length > 0
+        ? { generatorFailures }
+        : { success: true };
+}
+function getFailedSyncGeneratorsMessageLines(taskGenerators, globalGenerators, verbose) {
+    const messageLines = [];
+    if (taskGenerators.length + globalGenerators.length === 1) {
+        messageLines.push('', verbose
+            ? 'Please check the error above and address the issue.'
+            : 'Please check the error above and address the issue. You can provide the `--verbose` flag to get more details.');
+        if (taskGenerators.length === 1) {
+            messageLines.push(`If needed, you can disable the failing sync generator by setting \`sync.disabledTaskSyncGenerators: ["${taskGenerators[0]}"]\` in your \`nx.json\`.`);
+        }
+        else {
+            messageLines.push(`If needed, you can remove the failing global sync generator "${globalGenerators[0]}" from the \`sync.globalGenerators\` array in your \`nx.json\`.`);
+        }
+    }
+    else if (taskGenerators.length + globalGenerators.length > 1) {
+        messageLines.push('', verbose
+            ? 'Please check the errors above and address the issues.'
+            : 'Please check the errors above and address the issues. You can provide the `--verbose` flag to get more details.');
+        if (taskGenerators.length > 0) {
+            const generatorsString = taskGenerators.map((g) => `"${g}"`).join(', ');
+            messageLines.push(`If needed, you can disable the failing task sync generators by setting \`sync.disabledTaskSyncGenerators: [${generatorsString}]\` in your \`nx.json\`.`);
+        }
+        if (globalGenerators.length > 0) {
+            const lastGenerator = globalGenerators.pop();
+            const generatorsString = globalGenerators.length > 0
+                ? `${globalGenerators
+                    .map((g) => `"${g}"`)
+                    .join(', ')} and "${lastGenerator}"`
+                : `"${lastGenerator}"`;
+            messageLines.push(`If needed, you can remove the failing global sync generators ${generatorsString} from the \`sync.globalGenerators\` array in your \`nx.json\`.`);
+        }
+    }
+    return messageLines;
+}
+function errorToString(error, verbose) {
+    if (error.title) {
+        let message = `${pc.red(error.title)}`;
+        if (error.bodyLines?.length) {
+            message += `
+
+  ${error.bodyLines
+                .map((bodyLine) => `${bodyLine.split('\n').join('\n  ')}`)
+                .join('\n  ')}`;
+            return message;
+        }
+    }
+    return `${pc.red(error.message)}${verbose && error.stack ? '\n  ' + error.stack : ''}`;
+}
+function toSerializableError(error) {
+    return error instanceof SyncError
+        ? {
+            title: error.title,
+            bodyLines: error.bodyLines,
+            message: error.message,
+            stack: error.stack,
+        }
+        : { message: error.message, stack: error.stack };
+}