@ohos-ports/nx 19.8.4-beta.0

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

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = format;
+const node_child_process_1 = require("node:child_process");
+const path = require("node:path");
+const file_utils_1 = require("../../project-graph/file-utils");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const fileutils_1 = require("../../utils/fileutils");
+const ignore_1 = require("../../utils/ignore");
+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 project_graph_1 = require("../../project-graph/project-graph");
+const all_file_data_1 = require("../../utils/all-file-data");
+const chunkify_1 = require("../../utils/chunkify");
+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) {
+    try {
+        require('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({ ...args, ...nxArgs })).map(
+    // prettier removes one of the \
+    // prettier-ignore
+    (p) => `"${p.replace(/\$/g, "\\\$")}"`);
+    // Chunkify the patterns array to prevent crashing the windows terminal
+    const chunkList = (0, chunkify_1.chunkify)(patterns);
+    switch (command) {
+        case 'write':
+            sortTsConfig();
+            addRootConfigFiles(chunkList, nxArgs);
+            chunkList.forEach((chunk) => write(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(args) {
+    const graph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    const allFilesPattern = ['.'];
+    if (args.all) {
+        return allFilesPattern;
+    }
+    try {
+        if (args.projects && args.projects.length > 0) {
+            return getPatternsFromProjects(args.projects, graph);
+        }
+        const p = (0, command_line_utils_1.parseFiles)(args);
+        // In prettier v3 the getSupportInfo result is a promise
+        const supportedExtensions = new Set((await require('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);
+        return args.libsAndApps
+            ? await getPatternsFromApps(nonIgnoredPatterns, await (0, all_file_data_1.allFileData)(), graph)
+            : 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, allWorkspaceFiles, projectGraph) {
+    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, allWorkspaceFiles));
+    return getPatternsFromProjects(Object.keys(affectedGraph.nodes), projectGraph);
+}
+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(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();
+        (0, node_child_process_1.execSync)(`node "${prettierPath}" --write --list-different ${regularPatterns.join(' ')}`, {
+            stdio: [0, 1, 2],
+            windowsHide: true,
+        });
+        if (swcrcPatterns.length > 0) {
+            (0, node_child_process_1.execSync)(`node "${prettierPath}" --write --list-different ${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) => {
+        (0, node_child_process_1.exec)(`node "${prettierPath}" --list-different ${patterns.join(' ')}`, { encoding: 'utf-8', windowsHide: true }, (error, stdout) => {
+            if (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 { bin } = (0, package_json_1.readModulePackageJson)('prettier').packageJson;
+    prettierPath = require.resolve(path.join('prettier', bin));
+    return prettierPath;
+}

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

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

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsGenerateCommand = void 0;
+const path_1 = require("../../utils/path");
+const shared_options_1 = require("../yargs-utils/shared-options");
+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 Promise.resolve().then(() => require('./generate'))).generate((0, path_1.getCwd)(), 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/src/command-line/generate/generate.d.ts

@@ -0,0 +1,21 @@
+import { FileChange } from '../../generators/tree';
+import { Options, Schema } from '../../utils/params';
+export interface GenerateOptions {
+    collectionName: string;
+    generatorName: string;
+    generatorOptions: Options;
+    help: boolean;
+    dryRun: boolean;
+    interactive: boolean;
+    defaults: boolean;
+    quiet: boolean;
+}
+export declare function printChanges(fileChanges: FileChange[]): void;
+export declare function parseGeneratorString(value: string): {
+    collection?: string;
+    generator: string;
+};
+export declare function printGenHelp(opts: GenerateOptions, schema: Schema, normalizedGeneratorName: string, aliases: string[]): void;
+export declare function generate(cwd: string, args: {
+    [k: string]: any;
+}): Promise<number>;

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

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printChanges = printChanges;
+exports.parseGeneratorString = parseGeneratorString;
+exports.printGenHelp = printGenHelp;
+exports.generate = generate;
+const chalk = require("chalk");
+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 logger_1 = require("../../utils/logger");
+const params_1 = require("../../utils/params");
+const handle_errors_1 = require("../../utils/handle-errors");
+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");
+function printChanges(fileChanges) {
+    fileChanges.forEach((f) => {
+        if (f.type === 'CREATE') {
+            console.log(`${chalk.green('CREATE')} ${f.path}`);
+        }
+        else if (f.type === 'UPDATE') {
+            console.log(`${chalk.white('UPDATE')} ${f.path}`);
+        }
+        else if (f.type === 'DELETE') {
+            console.log(`${chalk.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: chalk.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(cwd, args) {
+    return (0, handle_errors_1.handleErrors)(args.verbose, async () => {
+        const nxJsonConfiguration = (0, configuration_1.readNxJson)();
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+        const 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 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);
+        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 {
+            require('../../adapter/compat');
+            return (await Promise.resolve().then(() => require('../../adapter/ngcli-adapter'))).generate(workspace_root_1.workspaceRoot, {
+                ...opts,
+                generatorOptions: combinedOpts,
+            }, projectsConfigurations.projects, args.verbose);
+        }
+    });
+}

package/src/command-line/generate/generator-utils.d.ts

@@ -0,0 +1,18 @@
+import { Generator, GeneratorsJson, GeneratorsJsonEntry } from '../../config/misc-interfaces';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+export type GeneratorInformation = {
+    resolvedCollectionName: string;
+    normalizedGeneratorName: string;
+    schema: any;
+    implementationFactory: () => Generator<unknown>;
+    isNgCompat: boolean;
+    isNxGenerator: boolean;
+    generatorConfiguration: GeneratorsJsonEntry;
+};
+export declare function getGeneratorInformation(collectionName: string, generatorName: string, root: string | null, projects: Record<string, ProjectConfiguration>): GeneratorInformation;
+export declare function readGeneratorsJson(collectionName: string, generator: string, root: string | null, projects: Record<string, ProjectConfiguration>): {
+    generatorsFilePath: string;
+    generatorsJson: GeneratorsJson;
+    normalizedGeneratorName: string;
+    resolvedCollectionName: string;
+};

package/src/command-line/generate/generator-utils.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGeneratorInformation = getGeneratorInformation;
+exports.readGeneratorsJson = readGeneratorsJson;
+const path_1 = require("path");
+const schema_utils_1 = require("../../config/schema-utils");
+const fileutils_1 = require("../../utils/fileutils");
+const plugins_1 = require("../../project-graph/plugins");
+function getGeneratorInformation(collectionName, generatorName, root, projects) {
+    try {
+        const { generatorsFilePath, generatorsJson, resolvedCollectionName, normalizedGeneratorName, } = readGeneratorsJson(collectionName, generatorName, root, projects);
+        const generatorsDir = (0, path_1.dirname)(generatorsFilePath);
+        const generatorConfig = generatorsJson.generators?.[normalizedGeneratorName] ||
+            generatorsJson.schematics?.[normalizedGeneratorName];
+        const isNgCompat = !generatorsJson.generators?.[normalizedGeneratorName];
+        const schemaPath = (0, schema_utils_1.resolveSchema)(generatorConfig.schema, generatorsDir);
+        const schema = (0, fileutils_1.readJsonFile)(schemaPath);
+        if (!schema.properties || typeof schema.properties !== 'object') {
+            schema.properties = {};
+        }
+        generatorConfig.implementation =
+            generatorConfig.implementation || generatorConfig.factory;
+        const implementationFactory = (0, schema_utils_1.getImplementationFactory)(generatorConfig.implementation, generatorsDir);
+        const normalizedGeneratorConfiguration = {
+            ...generatorConfig,
+            aliases: generatorConfig.aliases ?? [],
+            hidden: !!generatorConfig.hidden,
+        };
+        return {
+            resolvedCollectionName,
+            normalizedGeneratorName,
+            schema,
+            implementationFactory,
+            isNgCompat,
+            isNxGenerator: !isNgCompat,
+            generatorConfiguration: normalizedGeneratorConfiguration,
+        };
+    }
+    catch (e) {
+        throw new Error(`Unable to resolve ${collectionName}:${generatorName}.\n${e.message}`);
+    }
+}
+function readGeneratorsJson(collectionName, generator, root, projects) {
+    let generatorsFilePath;
+    if (collectionName.endsWith('.json')) {
+        generatorsFilePath = require.resolve(collectionName, {
+            paths: root ? [root, __dirname] : [__dirname],
+        });
+    }
+    else {
+        const { json: packageJson, path: packageJsonPath } = (0, plugins_1.readPluginPackageJson)(collectionName, projects, root ? [root, __dirname] : [__dirname]);
+        const generatorsFile = packageJson.generators ?? packageJson.schematics;
+        if (!generatorsFile) {
+            throw new Error(`The "${collectionName}" package does not support Nx generators.`);
+        }
+        generatorsFilePath = require.resolve((0, path_1.join)((0, path_1.dirname)(packageJsonPath), generatorsFile));
+    }
+    const generatorsJson = (0, fileutils_1.readJsonFile)(generatorsFilePath);
+    let normalizedGeneratorName = findFullGeneratorName(generator, generatorsJson.generators) ||
+        findFullGeneratorName(generator, generatorsJson.schematics);
+    if (!normalizedGeneratorName) {
+        for (let parent of generatorsJson.extends || []) {
+            try {
+                return readGeneratorsJson(parent, generator, root, projects);
+            }
+            catch (e) { }
+        }
+        throw new Error(`Cannot find generator '${generator}' in ${generatorsFilePath}.`);
+    }
+    return {
+        generatorsFilePath,
+        generatorsJson,
+        normalizedGeneratorName,
+        resolvedCollectionName: collectionName,
+    };
+}
+function findFullGeneratorName(name, generators) {
+    if (generators) {
+        for (let [key, data] of Object.entries(generators)) {
+            if (key === name ||
+                (data.aliases && data.aliases.includes(name))) {
+                return key;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+import { Argv, CommandModule } from 'yargs';
+export declare const yargsGraphCommand: CommandModule;
+export declare function withGraphOptions(yargs: Argv): Argv<{
+    file: string;
+} & {
+    print: boolean;
+} & {
+    view: string;
+} & {
+    targets: string;
+} & {
+    focus: string;
+} & {
+    exclude: string;
+} & {
+    groupByFolder: boolean;
+} & {
+    host: string;
+} & {
+    port: number;
+} & {
+    watch: boolean;
+} & {
+    open: boolean;
+}>;