nx 20.8.4 → 22.7.7

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

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = format;
+const tslib_1 = require("tslib");
+const node_child_process_1 = require("node:child_process");
+const path = tslib_1.__importStar(require("node:path"));
+const semver_1 = require("semver");
+const configuration_1 = require("../../config/configuration");
+const typescript_1 = require("../../plugins/js/utils/typescript");
+const affected_project_graph_1 = require("../../project-graph/affected/affected-project-graph");
+const file_utils_1 = require("../../project-graph/file-utils");
+const project_graph_1 = require("../../project-graph/project-graph");
+const chunkify_1 = require("../../utils/chunkify");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const fileutils_1 = require("../../utils/fileutils");
+const handle_import_1 = require("../../utils/handle-import");
+const ignore_1 = require("../../utils/ignore");
+const object_sort_1 = require("../../utils/object-sort");
+const output_1 = require("../../utils/output");
+const package_json_1 = require("../../utils/package-json");
+const workspace_root_1 = require("../../utils/workspace-root");
+async function format(command, args) {
+    let prettier;
+    try {
+        prettier = await (0, handle_import_1.handleImport)('prettier');
+    }
+    catch {
+        output_1.output.error({
+            title: 'Prettier is not installed.',
+            bodyLines: [
+                `Please install "prettier" and try again, or don't run the "nx format:${command}" command.`,
+            ],
+        });
+        process.exit(1);
+    }
+    const { nxArgs } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', { printWarnings: false }, (0, configuration_1.readNxJson)());
+    const patterns = (await getPatterns(prettier, { ...args, ...nxArgs })).map((p) => {
+        // On non-Windows, escape $ to prevent shell variable interpolation
+        // (the shell consumes one \, so \\$ becomes \$ which the shell treats as literal $)
+        // On Windows (cmd.exe), $ is not a special character, so escaping it would
+        // cause prettier to look for a file with a literal \$ in the name
+        // prettier-ignore
+        const escaped = process.platform !== 'win32' ? p.replace(/\$/g, '\\\$') : p;
+        return `"${escaped}"`;
+    });
+    // Chunkify the patterns array to prevent crashing the windows terminal
+    const chunkList = (0, chunkify_1.chunkify)(patterns);
+    switch (command) {
+        case 'write':
+            if (nxArgs.sortRootTsconfigPaths) {
+                sortTsConfig();
+            }
+            addRootConfigFiles(chunkList, nxArgs);
+            chunkList.forEach((chunk) => write(prettier, chunk));
+            break;
+        case 'check': {
+            const filesWithDifferentFormatting = [];
+            for (const chunk of chunkList) {
+                const files = await check(chunk);
+                filesWithDifferentFormatting.push(...files);
+            }
+            if (filesWithDifferentFormatting.length > 0) {
+                if (nxArgs.verbose) {
+                    output_1.output.error({
+                        title: 'The following files are not formatted correctly based on your Prettier configuration',
+                        bodyLines: [
+                            '- Run "nx format:write" and commit the resulting diff to fix these files.',
+                            '- Please note, Prettier does not support a native way to diff the output of its check logic (https://github.com/prettier/prettier/issues/6885).',
+                            '',
+                            ...filesWithDifferentFormatting,
+                        ],
+                    });
+                }
+                else {
+                    console.log(filesWithDifferentFormatting.join('\n'));
+                }
+                process.exit(1);
+            }
+            break;
+        }
+    }
+}
+async function getPatterns(prettier, args) {
+    const allFilesPattern = ['.'];
+    if (args.all) {
+        return allFilesPattern;
+    }
+    try {
+        if (args.projects && args.projects.length > 0) {
+            const graph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+            return getPatternsFromProjects(args.projects, graph);
+        }
+        const p = (0, command_line_utils_1.parseFiles)(args);
+        const supportedExtensions = new Set((await prettier.getSupportInfo()).languages
+            .flatMap((language) => language.extensions)
+            .filter((extension) => !!extension)
+            // Prettier supports ".swcrc" as a file instead of an extension
+            // So we add ".swcrc" as a supported extension manually
+            // which allows it to be considered for calculating "patterns"
+            .concat('.swcrc'));
+        const patterns = p.files
+            .map((f) => path.relative(workspace_root_1.workspaceRoot, f))
+            .filter((f) => (0, fileutils_1.fileExists)(f) && supportedExtensions.has(path.extname(f)));
+        // exclude patterns in .nxignore or .gitignore
+        const nonIgnoredPatterns = (0, ignore_1.getIgnoreObject)().filter(patterns);
+        if (args.libsAndApps) {
+            return getPatternsFromApps(nonIgnoredPatterns);
+        }
+        return nonIgnoredPatterns;
+    }
+    catch (err) {
+        output_1.output.error({
+            title: err?.message ||
+                'Something went wrong when resolving the list of files for the formatter',
+            bodyLines: [`Defaulting to all files pattern: "${allFilesPattern}"`],
+        });
+        return allFilesPattern;
+    }
+}
+async function getPatternsFromApps(affectedFiles) {
+    const graph = await (0, project_graph_1.createProjectGraphAsync)({
+        exitOnError: true,
+    });
+    const affectedGraph = await (0, affected_project_graph_1.filterAffected)(graph, (0, file_utils_1.calculateFileChanges)(affectedFiles));
+    return getPatternsFromProjects(Object.keys(affectedGraph.nodes), affectedGraph);
+}
+function addRootConfigFiles(chunkList, nxArgs) {
+    if (nxArgs.all) {
+        return;
+    }
+    const chunk = [];
+    const addToChunkIfNeeded = (file) => {
+        if (chunkList.every((c) => !c.includes(`"${file}"`))) {
+            chunk.push(file);
+        }
+    };
+    // if (workspaceJsonPath) {
+    //   addToChunkIfNeeded(workspaceJsonPath);
+    // }
+    ['nx.json', (0, typescript_1.getRootTsConfigFileName)()]
+        .filter(Boolean)
+        .forEach(addToChunkIfNeeded);
+    if (chunk.length > 0) {
+        chunkList.push(chunk);
+    }
+}
+function getPatternsFromProjects(projects, projectGraph) {
+    return (0, command_line_utils_1.getProjectRoots)(projects, projectGraph);
+}
+function write(prettier, patterns) {
+    if (patterns.length > 0) {
+        const [swcrcPatterns, regularPatterns] = patterns.reduce((result, pattern) => {
+            result[pattern.includes('.swcrc') ? 0 : 1].push(pattern);
+            return result;
+        }, [[], []]);
+        const prettierPath = getPrettierPath();
+        const listDifferentArg = shouldUseListDifferent(prettier.version)
+            ? '--list-different '
+            : '';
+        (0, node_child_process_1.execSync)(`node "${prettierPath}" --write ${listDifferentArg}${regularPatterns.join(' ')}`, {
+            stdio: [0, 1, 2],
+            windowsHide: true,
+        });
+        if (swcrcPatterns.length > 0) {
+            (0, node_child_process_1.execSync)(`node "${prettierPath}" --write ${listDifferentArg}${swcrcPatterns.join(' ')} --parser json`, {
+                stdio: [0, 1, 2],
+                windowsHide: true,
+            });
+        }
+    }
+}
+async function check(patterns) {
+    if (patterns.length === 0) {
+        return [];
+    }
+    const prettierPath = getPrettierPath();
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.exec)(`node "${prettierPath}" --list-different ${patterns.join(' ')}`, { encoding: 'utf-8', windowsHide: true }, (error, stdout) => {
+            if (error) {
+                // The command failed because Prettier threw an error.
+                if (stdout.length === 0) {
+                    reject(error);
+                }
+                // The command failed so there are files with different formatting. Prettier writes them to stdout, newline separated.
+                resolve(stdout.trim().split('\n'));
+            }
+            else {
+                // The command succeeded so there are no files with different formatting
+                resolve([]);
+            }
+        });
+    });
+}
+function sortTsConfig() {
+    try {
+        const tsconfigPath = (0, typescript_1.getRootTsConfigPath)();
+        const tsconfig = (0, fileutils_1.readJsonFile)(tsconfigPath);
+        const sortedPaths = (0, object_sort_1.sortObjectByKeys)(tsconfig.compilerOptions.paths);
+        tsconfig.compilerOptions.paths = sortedPaths;
+        (0, fileutils_1.writeJsonFile)(tsconfigPath, tsconfig);
+    }
+    catch (e) {
+        // catch noop
+    }
+}
+let prettierPath;
+function getPrettierPath() {
+    if (prettierPath) {
+        return prettierPath;
+    }
+    const { packageJson, path: packageJsonPath } = (0, package_json_1.readModulePackageJson)('prettier');
+    const bin = packageJson.bin;
+    const binPath = typeof bin === 'string' ? bin : bin?.['prettier'];
+    if (!binPath) {
+        throw new Error(`Could not find prettier binary in ${packageJsonPath}`);
+    }
+    prettierPath = path.resolve(path.dirname(packageJsonPath), binPath);
+    return prettierPath;
+}
+let useListDifferent;
+/**
+ * Determines if --list-different should be used with --write.
+ * Prettier 4+ and 3.6.x with experimental CLI don't support combining these flags.
+ */
+function shouldUseListDifferent(prettierVersion) {
+    if (useListDifferent !== undefined) {
+        return useListDifferent;
+    }
+    const prettierMajor = (0, semver_1.major)(prettierVersion);
+    const isExperimentalCli = process.env.PRETTIER_EXPERIMENTAL_CLI === '1';
+    useListDifferent = prettierMajor < 4 && !isExperimentalCli;
+    return useListDifferent;
+}

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsGenerateCommand = void 0;
+const shared_options_1 = require("../yargs-utils/shared-options");
+const handle_import_1 = require("../../utils/handle-import");
+exports.yargsGenerateCommand = {
+    command: 'generate <generator> [_..]',
+    describe: 'Generate or update source code (e.g., nx generate @nx/js:lib mylib).',
+    aliases: ['g'],
+    builder: (yargs) => withGenerateOptions(yargs),
+    handler: async (args) => {
+        // Remove the command from the args
+        args._ = args._.slice(1);
+        process.exit(await (await (0, handle_import_1.handleImport)('./generate.js', __dirname)).generate(args));
+    },
+};
+function withGenerateOptions(yargs) {
+    const generatorWillShowHelp = process.argv[3] && !process.argv[3].startsWith('-');
+    const res = (0, shared_options_1.withVerbose)(yargs)
+        .positional('generator', {
+        describe: 'Name of the generator (e.g., @nx/js:library, library).',
+        type: 'string',
+        required: true,
+    })
+        .option('dryRun', {
+        describe: 'Preview the changes without updating files.',
+        alias: 'd',
+        type: 'boolean',
+        default: false,
+    })
+        .option('interactive', {
+        describe: 'When false disables interactive input prompts for options.',
+        type: 'boolean',
+        default: true,
+    })
+        .option('quiet', {
+        describe: 'Hides logs from tree operations (e.g. `CREATE package.json`).',
+        type: 'boolean',
+        conflicts: ['verbose'],
+    })
+        .middleware((args) => {
+        if (process.env.NX_INTERACTIVE === 'false') {
+            args.interactive = false;
+        }
+        else {
+            process.env.NX_INTERACTIVE = `${args.interactive}`;
+        }
+        if (process.env.NX_DRY_RUN === 'true') {
+            args.dryRun = true;
+        }
+        else {
+            process.env.NX_DRY_RUN = `${args.dryRun}`;
+        }
+        if (process.env.NX_GENERATE_QUIET === 'true') {
+            args.quiet = true;
+        }
+        else {
+            process.env.NX_GENERATE_QUIET = `${args.quiet}`;
+        }
+    });
+    if (generatorWillShowHelp) {
+        return res.help(false);
+    }
+    else {
+        return res.epilog(`Run "nx g collection:generator --help" to see information about the generator's schema.`);
+    }
+}

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

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printChanges = printChanges;
+exports.parseGeneratorString = parseGeneratorString;
+exports.printGenHelp = printGenHelp;
+exports.generate = generate;
+const tslib_1 = require("tslib");
+const pc = tslib_1.__importStar(require("picocolors"));
+const enquirer_1 = require("enquirer");
+const path_1 = require("path");
+const configuration_1 = require("../../config/configuration");
+const tree_1 = require("../../generators/tree");
+const project_graph_1 = require("../../project-graph/project-graph");
+const retrieve_workspace_files_1 = require("../../project-graph/utils/retrieve-workspace-files");
+const logger_1 = require("../../utils/logger");
+const params_1 = require("../../utils/params");
+const handle_errors_1 = require("../../utils/handle-errors");
+const handle_import_1 = require("../../utils/handle-import");
+const local_plugins_1 = require("../../utils/plugins/local-plugins");
+const print_help_1 = require("../../utils/print-help");
+const workspace_root_1 = require("../../utils/workspace-root");
+const calculate_default_project_name_1 = require("../../config/calculate-default-project-name");
+const installed_plugins_1 = require("../../utils/plugins/installed-plugins");
+const generator_utils_1 = require("./generator-utils");
+const path_2 = require("../../utils/path");
+const analytics_1 = require("../../analytics");
+function printChanges(fileChanges) {
+    fileChanges.forEach((f) => {
+        if (f.type === 'CREATE') {
+            console.log(`${pc.green('CREATE')} ${f.path}`);
+        }
+        else if (f.type === 'UPDATE') {
+            console.log(`${pc.white('UPDATE')} ${f.path}`);
+        }
+        else if (f.type === 'DELETE') {
+            console.log(`${pc.yellow('DELETE')} ${f.path}`);
+        }
+    });
+}
+async function promptForCollection(generatorName, interactive, projectsConfiguration) {
+    const localPlugins = await (0, local_plugins_1.getLocalWorkspacePlugins)(projectsConfiguration, (0, configuration_1.readNxJson)());
+    const installedCollections = Array.from(new Set((0, installed_plugins_1.findInstalledPlugins)().map((x) => x.name)));
+    const choicesMap = new Set();
+    const deprecatedChoices = new Set();
+    for (const collectionName of installedCollections) {
+        try {
+            const { resolvedCollectionName, normalizedGeneratorName, generatorConfiguration: { ['x-deprecated']: deprecated, hidden }, } = (0, generator_utils_1.getGeneratorInformation)(collectionName, generatorName, workspace_root_1.workspaceRoot, projectsConfiguration.projects);
+            if (hidden) {
+                continue;
+            }
+            if (deprecated) {
+                deprecatedChoices.add(`${resolvedCollectionName}:${normalizedGeneratorName}`);
+            }
+            else {
+                choicesMap.add(`${resolvedCollectionName}:${normalizedGeneratorName}`);
+            }
+        }
+        catch { }
+    }
+    const choicesFromLocalPlugins = [];
+    for (const [name] of localPlugins) {
+        try {
+            const { resolvedCollectionName, normalizedGeneratorName, generatorConfiguration: { ['x-deprecated']: deprecated, hidden }, } = (0, generator_utils_1.getGeneratorInformation)(name, generatorName, workspace_root_1.workspaceRoot, projectsConfiguration.projects);
+            if (hidden) {
+                continue;
+            }
+            const value = `${resolvedCollectionName}:${normalizedGeneratorName}`;
+            if (!choicesMap.has(value)) {
+                if (deprecated) {
+                    deprecatedChoices.add(value);
+                }
+                else {
+                    choicesFromLocalPlugins.push({
+                        name: value,
+                        message: pc.bold(value),
+                        value,
+                    });
+                }
+            }
+        }
+        catch { }
+    }
+    if (choicesFromLocalPlugins.length) {
+        choicesFromLocalPlugins[choicesFromLocalPlugins.length - 1].message += '\n';
+    }
+    const choices = choicesFromLocalPlugins.concat(...choicesMap);
+    if (choices.length === 1) {
+        return typeof choices[0] === 'string' ? choices[0] : choices[0].value;
+    }
+    else if (!interactive && choices.length > 1) {
+        throwInvalidInvocation(Array.from(choicesMap));
+    }
+    else if (interactive && choices.length > 1) {
+        const noneOfTheAbove = `\nNone of the above`;
+        choices.push(noneOfTheAbove);
+        let { generator, customCollection } = await (0, enquirer_1.prompt)([
+            {
+                name: 'generator',
+                message: `Which generator would you like to use?`,
+                type: 'autocomplete',
+                // enquirer's typings are incorrect here... It supports (string | Choice)[], but is typed as (string[] | Choice[])
+                choices: choices,
+            },
+            {
+                name: 'customCollection',
+                type: 'input',
+                message: `Which collection would you like to use?`,
+                skip: function () {
+                    // Skip this question if the user did not answer None of the above
+                    return this.state.answers.generator !== noneOfTheAbove;
+                },
+                validate: function (value) {
+                    if (this.skipped) {
+                        return true;
+                    }
+                    try {
+                        (0, generator_utils_1.getGeneratorInformation)(value, generatorName, workspace_root_1.workspaceRoot, projectsConfiguration.projects);
+                        return true;
+                    }
+                    catch {
+                        logger_1.logger.error(`\nCould not find ${value}:${generatorName}`);
+                        return false;
+                    }
+                },
+            },
+        ]);
+        return customCollection
+            ? `${customCollection}:${generatorName}`
+            : generator;
+    }
+    else if (deprecatedChoices.size > 0) {
+        throw new Error([
+            `All installed generators named "${generatorName}" are deprecated. To run one, provide its full \`collection:generator\` id.`,
+            [...deprecatedChoices].map((x) => `  - ${x}`),
+        ].join('\n'));
+    }
+    else {
+        throw new Error(`Could not find any generators named "${generatorName}"`);
+    }
+}
+function parseGeneratorString(value) {
+    const separatorIndex = value.lastIndexOf(':');
+    if (separatorIndex > 0) {
+        return {
+            collection: value.slice(0, separatorIndex),
+            generator: value.slice(separatorIndex + 1),
+        };
+    }
+    else {
+        return {
+            generator: value,
+        };
+    }
+}
+async function convertToGenerateOptions(generatorOptions, mode, projectsConfiguration) {
+    let collectionName = null;
+    let generatorName = null;
+    const interactive = generatorOptions.interactive;
+    if (mode === 'generate') {
+        const generatorDescriptor = generatorOptions['generator'];
+        const { collection, generator } = parseGeneratorString(generatorDescriptor);
+        if (collection) {
+            collectionName = collection;
+            generatorName = generator;
+        }
+        else {
+            const generatorString = await promptForCollection(generatorDescriptor, interactive, projectsConfiguration);
+            const parsedGeneratorString = parseGeneratorString(generatorString);
+            collectionName = parsedGeneratorString.collection;
+            generatorName = parsedGeneratorString.generator;
+        }
+    }
+    else {
+        collectionName = generatorOptions.collection;
+        generatorName = 'new';
+    }
+    const res = {
+        collectionName,
+        generatorName,
+        generatorOptions,
+        help: generatorOptions.help,
+        dryRun: generatorOptions.dryRun,
+        interactive,
+        defaults: generatorOptions.defaults,
+        quiet: generatorOptions.quiet,
+    };
+    delete generatorOptions.d;
+    delete generatorOptions.dryRun;
+    delete generatorOptions['dry-run'];
+    delete generatorOptions.interactive;
+    delete generatorOptions.help;
+    delete generatorOptions.collection;
+    delete generatorOptions.verbose;
+    delete generatorOptions.generator;
+    delete generatorOptions['--'];
+    delete generatorOptions['$0'];
+    delete generatorOptions.quiet;
+    return res;
+}
+function throwInvalidInvocation(availableGenerators) {
+    throw new Error(`Specify the generator name (e.g., nx generate ${availableGenerators.join(', ')})`);
+}
+function printGenHelp(opts, schema, normalizedGeneratorName, aliases) {
+    (0, print_help_1.printHelp)(`generate ${opts.collectionName}:${normalizedGeneratorName}`, {
+        ...schema,
+        properties: schema.properties,
+    }, {
+        mode: 'generate',
+        plugin: opts.collectionName,
+        entity: normalizedGeneratorName,
+        aliases,
+    });
+}
+async function generate(args) {
+    return (0, handle_errors_1.handleErrors)(args.verbose, async () => {
+        const nxJsonConfiguration = (0, configuration_1.readNxJson)();
+        let projectGraph;
+        let projectsConfigurations;
+        if (args.skipProjectGraph) {
+            const projects = await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(workspace_root_1.workspaceRoot);
+            projectsConfigurations = { version: 2, projects };
+        }
+        else {
+            projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+            projectsConfigurations =
+                (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+        }
+        const opts = await convertToGenerateOptions(args, 'generate', projectsConfigurations);
+        const { normalizedGeneratorName, schema, implementationFactory, generatorConfiguration: { aliases, hidden, ['x-deprecated']: deprecated, ['x-use-standalone-layout']: isStandalonePreset, }, } = (0, generator_utils_1.getGeneratorInformation)(opts.collectionName, opts.generatorName, workspace_root_1.workspaceRoot, projectsConfigurations.projects);
+        if (deprecated) {
+            logger_1.logger.warn([
+                `${logger_1.NX_PREFIX}: ${opts.collectionName}:${normalizedGeneratorName} is deprecated`,
+                `${deprecated}`,
+            ].join('\n'));
+        }
+        if (!opts.quiet && !opts.help) {
+            logger_1.logger.info(`NX Generating ${opts.collectionName}:${normalizedGeneratorName}`);
+        }
+        if (opts.help) {
+            printGenHelp(opts, schema, normalizedGeneratorName, aliases);
+            return 0;
+        }
+        const cwd = (0, path_2.getCwd)();
+        const combinedOpts = await (0, params_1.combineOptionsForGenerator)(opts.generatorOptions, opts.collectionName, normalizedGeneratorName, projectsConfigurations, nxJsonConfiguration, schema, opts.interactive, (0, calculate_default_project_name_1.calculateDefaultProjectName)(cwd, workspace_root_1.workspaceRoot, projectsConfigurations, nxJsonConfiguration), (0, path_1.relative)(workspace_root_1.workspaceRoot, cwd), args.verbose);
+        (0, analytics_1.reportNxGenerateCommand)(`${opts.collectionName}:${normalizedGeneratorName}`);
+        if ((0, generator_utils_1.getGeneratorInformation)(opts.collectionName, normalizedGeneratorName, workspace_root_1.workspaceRoot, projectsConfigurations.projects).isNxGenerator) {
+            const host = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose, `generating (${opts.collectionName}:${normalizedGeneratorName})`);
+            const implementation = implementationFactory();
+            // @todo(v17): Remove this, isStandalonePreset property is defunct.
+            if (normalizedGeneratorName === 'preset' && !isStandalonePreset) {
+                host.write('apps/.gitkeep', '');
+                host.write('libs/.gitkeep', '');
+            }
+            const task = await implementation(host, combinedOpts);
+            host.lock();
+            const changes = host.listChanges();
+            if (!opts.quiet) {
+                printChanges(changes);
+            }
+            if (!opts.dryRun) {
+                (0, tree_1.flushChanges)(workspace_root_1.workspaceRoot, changes);
+                if (task) {
+                    await task();
+                }
+            }
+            else {
+                logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
+            }
+        }
+        else {
+            if (!projectGraph) {
+                throw new Error(`Cannot run non-Nx generators with --skipProjectGraph. Remove the flag or use an Nx generator.`);
+            }
+            require('../../adapter/compat');
+            return (await (0, handle_import_1.handleImport)('../../adapter/ngcli-adapter.js', __dirname)).generate(workspace_root_1.workspaceRoot, {
+                ...opts,
+                generatorOptions: combinedOpts,
+            }, projectsConfigurations.projects, args.verbose, projectGraph);
+        }
+    });
+}

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsGraphCommand = void 0;
+exports.withGraphOptions = withGraphOptions;
+const documentation_1 = require("../yargs-utils/documentation");
+const shared_options_1 = require("../yargs-utils/shared-options");
+const handle_import_1 = require("../../utils/handle-import");
+exports.yargsGraphCommand = {
+    command: 'graph',
+    describe: 'Graph dependencies within workspace.',
+    aliases: ['dep-graph'],
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withVerbose)((0, shared_options_1.withAffectedOptions)(withGraphOptions(yargs))), 'dep-graph')
+        .option('affected', {
+        type: 'boolean',
+        description: 'Highlight affected projects.',
+    })
+        .implies('untracked', 'affected')
+        .implies('uncommitted', 'affected')
+        .implies('files', 'affected')
+        .implies('base', 'affected')
+        .implies('head', 'affected'),
+    handler: async (args) => await (await (0, handle_import_1.handleImport)('./graph.js', __dirname)).generateGraph(args, []),
+};
+function withGraphOptions(yargs) {
+    return yargs
+        .option('file', {
+        describe: 'Output file (e.g. --file=output.json or --file=dep-graph.html).',
+        type: 'string',
+    })
+        .option('print', {
+        describe: 'Print the project graph to stdout in the terminal.',
+        type: 'boolean',
+    })
+        .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: shared_options_1.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: shared_options_1.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: true,
+    })
+        .option('open', {
+        describe: 'Open the project graph in the browser.',
+        type: 'boolean',
+        default: true,
+    });
+}