@angular/cli 14.0.0-next.5 → 14.0.0-next.6

package/src/command-builder/architect-command-module.js

@@ -8,6 +8,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArchitectCommandModule = void 0;
+const config_1 = require("../utilities/config");
 const architect_base_command_module_1 = require("./architect-base-command-module");
 const command_module_1 = require("./command-module");
 class ArchitectCommandModule extends architect_base_command_module_1.ArchitectBaseCommandModule {
@@ -93,12 +94,9 @@ class ArchitectCommandModule extends architect_base_command_module_1.ArchitectBa
             return allProjectsForTargetName;
         }
         else {
-            // For single target commands, we try the default project first,
-            // then the full list if it has a single project, then error out.
-            const maybeDefaultProject = workspace.extensions['defaultProject'];
-            if (typeof maybeDefaultProject === 'string' &&
-                allProjectsForTargetName.includes(maybeDefaultProject)) {
-                return [maybeDefaultProject];
+            const maybeProject = (0, config_1.getProjectByCwd)(workspace);
+            if (maybeProject && allProjectsForTargetName.includes(maybeProject)) {
+                return [maybeProject];
             }
             if (allProjectsForTargetName.length === 1) {
                 return allProjectsForTargetName;

package/src/command-builder/command-module.d.ts

@@ -7,6 +7,7 @@
  */
 import { analytics, logging } from '@angular-devkit/core';
 import { ArgumentsCamelCase, Argv, CamelCaseKey, CommandModule as YargsCommandModule } from 'yargs';
+import { PackageManager } from '../../lib/config/workspace-schema';
 import { AngularWorkspace } from '../utilities/config';
 import { Option } from './utilities/json-schema';
 export declare type Options<T> = {
@@ -25,11 +26,13 @@ export interface CommandContext {
     root: string;
     workspace?: AngularWorkspace;
     logger: logging.Logger;
+    packageManager: PackageManager;
     /** Arguments parsed in free-from without parser configuration. */
     args: {
         positional: string[];
         options: {
             help: boolean;
+            jsonHelp: boolean;
         } & Record<string, unknown>;
     };
 }
@@ -52,7 +55,7 @@ export declare abstract class CommandModule<T extends {} = {}> implements Comman
     abstract readonly command: string;
     abstract readonly describe: string | false;
     abstract readonly longDescriptionPath?: string;
-    protected shouldReportAnalytics: boolean;
+    protected readonly shouldReportAnalytics: boolean;
     static scope: CommandScope;
     private readonly optionsWithAnalytics;
     constructor(context: CommandContext);

package/src/command-builder/command-module.js

@@ -8,7 +8,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -63,7 +67,7 @@ class CommandModule {
                         longDescriptionRelativePath: path
                             .relative(path.join(__dirname, '../../../../'), this.longDescriptionPath)
                             .replace(/\\/g, path.posix.sep),
-                        longDescription: (0, fs_1.readFileSync)(this.longDescriptionPath, 'utf8'),
+                        longDescription: (0, fs_1.readFileSync)(this.longDescriptionPath, 'utf8').replace(/\r\n/g, '\n'),
                     }
                     : {}),
             };
@@ -124,7 +128,9 @@ class CommandModule {
         if (this._analytics) {
             return this._analytics;
         }
-        return (this._analytics = await (0, analytics_1.createAnalytics)(!!this.context.workspace, this.commandName === 'update'));
+        return (this._analytics = await (0, analytics_1.createAnalytics)(!!this.context.workspace, 
+        // Don't prompt for `ng update` and `ng analytics` commands.
+        ['update', 'analytics'].includes(this.commandName)));
     }
     /**
      * Adds schema options to a command also this keeps track of options that are required for analytics.

package/src/command-builder/command-runner.js

@@ -31,7 +31,9 @@ const cli_15 = require("../commands/test/cli");
 const cli_16 = require("../commands/update/cli");
 const cli_17 = require("../commands/version/cli");
 const color_1 = require("../utilities/color");
+const package_manager_1 = require("../utilities/package-manager");
 const command_module_1 = require("./command-module");
+const command_1 = require("./utilities/command");
 const json_help_1 = require("./utilities/json-help");
 const COMMANDS = [
     cli_17.VersionCommandModule,
@@ -51,20 +53,22 @@ const COMMANDS = [
     cli_12.NewCommandModule,
     cli_16.UpdateCommandModule,
     cli_13.RunCommandModule,
-];
+].sort(); // Will be sorted by class name.
 const yargsParser = helpers_1.Parser;
 async function runCommand(args, logger, workspace) {
-    var _a, _b;
+    var _a, _b, _c;
     const { $0, _: positional, help = false, jsonHelp = false, ...rest } = yargsParser(args, { boolean: ['help', 'json-help'], alias: { 'collection': 'c' } });
     const context = {
         workspace,
         logger,
         currentDirectory: process.cwd(),
         root: (_a = workspace === null || workspace === void 0 ? void 0 : workspace.basePath) !== null && _a !== void 0 ? _a : process.cwd(),
+        packageManager: await (0, package_manager_1.getPackageManager)((_b = workspace === null || workspace === void 0 ? void 0 : workspace.basePath) !== null && _b !== void 0 ? _b : process.cwd()),
         args: {
             positional: positional.map((v) => v.toString()),
             options: {
                 help,
+                jsonHelp,
                 ...rest,
             },
         },
@@ -78,22 +82,7 @@ async function runCommand(args, logger, workspace) {
                 continue;
             }
         }
-        const commandModule = new CommandModule(context);
-        const describe = jsonHelp ? commandModule.fullDescribe : commandModule.describe;
-        localYargs = localYargs.command({
-            command: commandModule.command,
-            aliases: 'aliases' in commandModule ? commandModule.aliases : undefined,
-            describe: 
-            // We cannot add custom fields in help, such as long command description which is used in AIO.
-            // Therefore, we get around this by adding a complex object as a string which we later parse when generating the help files.
-            describe !== undefined && typeof describe === 'object'
-                ? JSON.stringify(describe)
-                : describe,
-            deprecated: 'deprecated' in commandModule ? commandModule.deprecated : undefined,
-            builder: (argv) => commandModule.builder(argv),
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            handler: (args) => commandModule.handler(args),
-        });
+        localYargs = (0, command_1.addCommandModuleToYargs)(localYargs, CommandModule, context);
     }
     if (jsonHelp) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -127,7 +116,7 @@ async function runCommand(args, logger, workspace) {
         'deprecated: %s': color_1.colors.yellow('deprecated:') + ' %s',
         'Did you mean %s?': 'Unknown command. Did you mean %s?',
     })
-        .demandCommand()
+        .demandCommand(1, command_1.demandCommandFailureMessage)
         .recommendCommands()
         .version(false)
         .showHelpOnFail(false)
@@ -141,6 +130,6 @@ async function runCommand(args, logger, workspace) {
     })
         .wrap(yargs_1.default.terminalWidth())
         .parseAsync();
-    return (_b = process.exitCode) !== null && _b !== void 0 ? _b : 0;
+    return (_c = process.exitCode) !== null && _c !== void 0 ? _c : 0;
 }
 exports.runCommand = runCommand;

package/src/command-builder/schematics-command-module.d.ts

@@ -8,7 +8,7 @@
 import { Collection } from '@angular-devkit/schematics';
 import { FileSystemCollectionDescription, FileSystemSchematicDescription, NodeWorkflow } from '@angular-devkit/schematics/tools';
 import { Argv } from 'yargs';
-import { CommandModule, CommandModuleImplementation, CommandScope } from './command-module';
+import { CommandModule, CommandModuleImplementation, CommandScope, Options, OtherOptions } from './command-module';
 import { Option } from './utilities/json-schema';
 export interface SchematicsCommandArgs {
     interactive: boolean;
@@ -16,16 +16,29 @@ export interface SchematicsCommandArgs {
     'dry-run': boolean;
     defaults: boolean;
 }
+export interface SchematicsExecutionOptions extends Options<SchematicsCommandArgs> {
+    packageRegistry?: string;
+}
 export declare abstract class SchematicsCommandModule extends CommandModule<SchematicsCommandArgs> implements CommandModuleImplementation<SchematicsCommandArgs> {
     static scope: CommandScope;
-    protected readonly schematicName: string | undefined;
+    protected readonly allowPrivateSchematics: boolean;
+    protected readonly shouldReportAnalytics = false;
     builder(argv: Argv): Promise<Argv<SchematicsCommandArgs>>;
     /** Get schematic schema options.*/
     protected getSchematicOptions(collection: Collection<FileSystemCollectionDescription, FileSystemSchematicDescription>, schematicName: string, workflow: NodeWorkflow): Promise<Option[]>;
-    protected getCollectionName(): Promise<string>;
-    private _workflow;
-    protected getOrCreateWorkflow(collectionName: string): NodeWorkflow;
+    private _workflowForBuilder;
+    protected getOrCreateWorkflowForBuilder(collectionName: string): NodeWorkflow;
+    private _workflowForExecution;
+    protected getOrCreateWorkflowForExecution(collectionName: string, options: SchematicsExecutionOptions): Promise<NodeWorkflow>;
     private _defaultSchematicCollection;
     protected getDefaultSchematicCollection(): Promise<string>;
     protected parseSchematicInfo(schematic: string | undefined): [collectionName: string | undefined, schematicName: string | undefined];
+    protected runSchematic(options: {
+        executionOptions: SchematicsExecutionOptions;
+        schematicOptions: OtherOptions;
+        collectionName: string;
+        schematicName: string;
+    }): Promise<number>;
+    private getProjectName;
+    private getResolvePaths;
 }

package/src/command-builder/schematics-command-module.js

@@ -6,17 +6,30 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchematicsCommandModule = void 0;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
 const tools_1 = require("@angular-devkit/schematics/tools");
-const schematic_engine_host_1 = require("../../models/schematic-engine-host");
+const inquirer_1 = __importDefault(require("inquirer"));
 const config_1 = require("../utilities/config");
+const tty_1 = require("../utilities/tty");
 const command_module_1 = require("./command-module");
 const json_schema_1 = require("./utilities/json-schema");
+const schematic_engine_host_1 = require("./utilities/schematic-engine-host");
+const schematic_workflow_1 = require("./utilities/schematic-workflow");
 const DEFAULT_SCHEMATICS_COLLECTION = '@schematics/angular';
 class SchematicsCommandModule extends command_module_1.CommandModule {
+    constructor() {
+        super(...arguments);
+        this.allowPrivateSchematics = false;
+        this.shouldReportAnalytics = false;
+    }
     async builder(argv) {
-        const localYargs = argv
+        return argv
             .option('interactive', {
             describe: 'Enable interactive input prompts.',
             type: 'boolean',
@@ -38,14 +51,6 @@ class SchematicsCommandModule extends command_module_1.CommandModule {
             default: false,
         })
             .strict();
-        if (this.schematicName) {
-            const collectionName = await this.getCollectionName();
-            const workflow = this.getOrCreateWorkflow(collectionName);
-            const collection = workflow.engine.createCollection(collectionName);
-            const options = await this.getSchematicOptions(collection, this.schematicName, workflow);
-            return this.addSchemaOptionsToCommand(localYargs, options);
-        }
-        return localYargs;
     }
     /** Get schematic schema options.*/
     async getSchematicOptions(collection, schematicName, workflow) {
@@ -56,29 +61,126 @@ class SchematicsCommandModule extends command_module_1.CommandModule {
         }
         return (0, json_schema_1.parseJsonSchemaToOptions)(workflow.registry, schemaJson);
     }
-    async getCollectionName() {
-        var _a, _b;
-        const { options: { collection }, positional, } = this.context.args;
-        return ((_b = (_a = (typeof collection === 'string' ? collection : undefined)) !== null && _a !== void 0 ? _a : 
-        // positional = [generate, lint] or [new, collection-package]
-        this.parseSchematicInfo(positional[1])[0]) !== null && _b !== void 0 ? _b : (await this.getDefaultSchematicCollection()));
+    getOrCreateWorkflowForBuilder(collectionName) {
+        if (this._workflowForBuilder) {
+            return this._workflowForBuilder;
+        }
+        return (this._workflowForBuilder = new tools_1.NodeWorkflow(this.context.root, {
+            resolvePaths: this.getResolvePaths(collectionName),
+            engineHostCreator: (options) => new schematic_engine_host_1.SchematicEngineHost(options.resolvePaths),
+        }));
     }
-    getOrCreateWorkflow(collectionName) {
-        if (this._workflow) {
-            return this._workflow;
+    async getOrCreateWorkflowForExecution(collectionName, options) {
+        if (this._workflowForExecution) {
+            return this._workflowForExecution;
         }
-        const { root, workspace } = this.context;
-        return new tools_1.NodeWorkflow(root, {
-            resolvePaths: workspace
-                ? // Workspace
-                    collectionName === DEFAULT_SCHEMATICS_COLLECTION
-                        ? // Favor __dirname for @schematics/angular to use the build-in version
-                            [__dirname, process.cwd(), root]
-                        : [process.cwd(), root, __dirname]
-                : // Global
-                    [__dirname, process.cwd()],
+        const { logger, root, packageManager } = this.context;
+        const { force, dryRun, packageRegistry } = options;
+        const workflow = new tools_1.NodeWorkflow(root, {
+            force,
+            dryRun,
+            packageManager,
+            // A schema registry is required to allow customizing addUndefinedDefaults
+            registry: new core_1.schema.CoreSchemaRegistry(schematics_1.formats.standardFormats),
+            packageRegistry,
+            resolvePaths: this.getResolvePaths(collectionName),
+            schemaValidation: true,
+            optionTransforms: [
+                // Add configuration file defaults
+                async (schematic, current) => {
+                    const projectName = typeof current.project === 'string'
+                        ? current.project
+                        : this.getProjectName();
+                    return {
+                        ...(await (0, config_1.getSchematicDefaults)(schematic.collection.name, schematic.name, projectName)),
+                        ...current,
+                    };
+                },
+            ],
             engineHostCreator: (options) => new schematic_engine_host_1.SchematicEngineHost(options.resolvePaths),
         });
+        workflow.registry.addPostTransform(core_1.schema.transforms.addUndefinedDefaults);
+        workflow.registry.addSmartDefaultProvider('projectName', () => this.getProjectName());
+        workflow.registry.useXDeprecatedProvider((msg) => logger.warn(msg));
+        let shouldReportAnalytics = true;
+        workflow.engineHost.registerOptionsTransform(async (schematic, options) => {
+            var _a;
+            if (shouldReportAnalytics) {
+                shouldReportAnalytics = false;
+                // ng generate lib -> ng generate
+                const commandName = (_a = this.command) === null || _a === void 0 ? void 0 : _a.split(' ', 1)[0];
+                await this.reportAnalytics(options, [
+                    commandName,
+                    schematic.collection.name.replace(/\//g, '_'),
+                    schematic.name.replace(/\//g, '_'),
+                ]);
+            }
+            return options;
+        });
+        if (options.interactive !== false && (0, tty_1.isTTY)()) {
+            workflow.registry.usePromptProvider((definitions) => {
+                const questions = definitions
+                    .filter((definition) => !options.defaults || definition.default === undefined)
+                    .map((definition) => {
+                    var _a;
+                    const question = {
+                        name: definition.id,
+                        message: definition.message,
+                        default: definition.default,
+                    };
+                    const validator = definition.validator;
+                    if (validator) {
+                        question.validate = (input) => validator(input);
+                        // Filter allows transformation of the value prior to validation
+                        question.filter = async (input) => {
+                            for (const type of definition.propertyTypes) {
+                                let value;
+                                switch (type) {
+                                    case 'string':
+                                        value = String(input);
+                                        break;
+                                    case 'integer':
+                                    case 'number':
+                                        value = Number(input);
+                                        break;
+                                    default:
+                                        value = input;
+                                        break;
+                                }
+                                // Can be a string if validation fails
+                                const isValid = (await validator(value)) === true;
+                                if (isValid) {
+                                    return value;
+                                }
+                            }
+                            return input;
+                        };
+                    }
+                    switch (definition.type) {
+                        case 'confirmation':
+                            question.type = 'confirm';
+                            break;
+                        case 'list':
+                            question.type = definition.multiselect ? 'checkbox' : 'list';
+                            question.choices = (_a = definition.items) === null || _a === void 0 ? void 0 : _a.map((item) => {
+                                return typeof item == 'string'
+                                    ? item
+                                    : {
+                                        name: item.label,
+                                        value: item.value,
+                                    };
+                            });
+                            break;
+                        default:
+                            question.type = definition.type;
+                            break;
+                    }
+                    return question;
+                });
+                return inquirer_1.default.prompt(questions);
+            });
+        }
+        return (this._workflowForExecution = workflow);
     }
     async getDefaultSchematicCollection() {
         if (this._defaultSchematicCollection) {
@@ -112,6 +214,82 @@ class SchematicsCommandModule extends command_module_1.CommandModule {
         }
         return [undefined, schematic];
     }
+    async runSchematic(options) {
+        const { logger } = this.context;
+        const { schematicOptions, executionOptions, collectionName, schematicName } = options;
+        const workflow = await this.getOrCreateWorkflowForExecution(collectionName, executionOptions);
+        if (!schematicName) {
+            throw new Error('schematicName cannot be undefined.');
+        }
+        const { unsubscribe, files } = (0, schematic_workflow_1.subscribeToWorkflow)(workflow, logger);
+        try {
+            await workflow
+                .execute({
+                collection: collectionName,
+                schematic: schematicName,
+                options: schematicOptions,
+                logger,
+                allowPrivate: this.allowPrivateSchematics,
+            })
+                .toPromise();
+            if (!files.size) {
+                logger.info('Nothing to be done.');
+            }
+            if (executionOptions.dryRun) {
+                logger.warn(`\nNOTE: The "--dry-run" option means no changes were made.`);
+            }
+        }
+        catch (err) {
+            // In case the workflow was not successful, show an appropriate error message.
+            if (err instanceof schematics_1.UnsuccessfulWorkflowExecution) {
+                // "See above" because we already printed the error.
+                logger.fatal('The Schematic workflow failed. See above.');
+                return 1;
+            }
+            else {
+                throw err;
+            }
+        }
+        finally {
+            unsubscribe();
+        }
+        return 0;
+    }
+    getProjectName() {
+        const { workspace, logger } = this.context;
+        if (!workspace) {
+            return undefined;
+        }
+        const projectNames = (0, config_1.getProjectsByPath)(workspace, process.cwd(), workspace.basePath);
+        if (projectNames.length === 1) {
+            return projectNames[0];
+        }
+        else {
+            if (projectNames.length > 1) {
+                logger.warn(core_1.tags.oneLine `
+            Two or more projects are using identical roots.
+            Unable to determine project using current working directory.
+            Using default workspace project instead.
+          `);
+            }
+            const defaultProjectName = workspace.extensions['defaultProject'];
+            if (typeof defaultProjectName === 'string' && defaultProjectName) {
+                return defaultProjectName;
+            }
+        }
+        return undefined;
+    }
+    getResolvePaths(collectionName) {
+        const { workspace, root } = this.context;
+        return workspace
+            ? // Workspace
+                collectionName === DEFAULT_SCHEMATICS_COLLECTION
+                    ? // Favor __dirname for @schematics/angular to use the build-in version
+                        [__dirname, process.cwd(), root]
+                    : [process.cwd(), root, __dirname]
+            : // Global
+                [__dirname, process.cwd()];
+    }
 }
 exports.SchematicsCommandModule = SchematicsCommandModule;
 SchematicsCommandModule.scope = command_module_1.CommandScope.In;

package/src/command-builder/utilities/command.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Argv } from 'yargs';
+import { CommandContext, CommandModule, CommandModuleImplementation } from '../command-module';
+export declare const demandCommandFailureMessage = "You need to specify a command before moving on. Use '--help' to view the available commands.";
+export declare function addCommandModuleToYargs<T, U extends Partial<CommandModuleImplementation> & {
+    new (context: CommandContext): Partial<CommandModuleImplementation> & CommandModule;
+}>(localYargs: Argv<T>, commandModule: U, context: CommandContext): Argv<T>;

package/src/command-builder/utilities/command.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCommandModuleToYargs = exports.demandCommandFailureMessage = void 0;
+exports.demandCommandFailureMessage = `You need to specify a command before moving on. Use '--help' to view the available commands.`;
+function addCommandModuleToYargs(localYargs, commandModule, context) {
+    const cmd = new commandModule(context);
+    const describe = context.args.options.jsonHelp ? cmd.fullDescribe : cmd.describe;
+    return localYargs.command({
+        command: cmd.command,
+        aliases: cmd.aliases,
+        describe: 
+        // We cannot add custom fields in help, such as long command description which is used in AIO.
+        // Therefore, we get around this by adding a complex object as a string which we later parse when generating the help files.
+        typeof describe === 'object' ? JSON.stringify(describe) : describe,
+        deprecated: cmd.deprecated,
+        builder: (argv) => cmd.builder(argv),
+        handler: (args) => cmd.handler(args),
+    });
+}
+exports.addCommandModuleToYargs = addCommandModuleToYargs;

package/src/command-builder/utilities/json-help.d.ts

@@ -5,20 +5,6 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-export interface JsonHelp {
-    name: string;
-    shortDescription?: string;
-    command: string;
-    longDescription?: string;
-    longDescriptionRelativePath?: string;
-    options: JsonHelpOption[];
-    subcommands?: {
-        name: string;
-        description: string;
-        aliases: string[];
-        deprecated: string | boolean;
-    }[];
-}
 interface JsonHelpOption {
     name: string;
     type?: string;
@@ -30,5 +16,21 @@ interface JsonHelpOption {
     enum?: string[];
     description?: string;
 }
+interface JsonHelpDescription {
+    shortDescription?: string;
+    longDescription?: string;
+    longDescriptionRelativePath?: string;
+}
+interface JsonHelpSubcommand extends JsonHelpDescription {
+    name: string;
+    aliases: string[];
+    deprecated: string | boolean;
+}
+export interface JsonHelp extends JsonHelpDescription {
+    name: string;
+    command: string;
+    options: JsonHelpOption[];
+    subcommands?: JsonHelpSubcommand[];
+}
 export declare function jsonHelpUsage(): string;
 export {};

package/src/command-builder/utilities/json-help.js

@@ -12,8 +12,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.jsonHelpUsage = void 0;
 const yargs_1 = __importDefault(require("yargs"));
+const yargsDefaultCommandRegExp = /^\$0|\*/;
 function jsonHelpUsage() {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const localYargs = yargs_1.default;
     const { deprecatedOptions, alias: aliases, array, string, boolean, number, choices, demandedOptions, default: defaultVal, hiddenOptions = [], } = localYargs.getOptions();
@@ -54,37 +55,40 @@ function jsonHelpUsage() {
     }
     // https://github.com/yargs/yargs/blob/00e4ebbe3acd438e73fdb101e75b4f879eb6d345/lib/usage.ts#L124
     const subcommands = usageInstance.getCommands()
-        .map(([name, description, _, aliases, deprecated]) => ({
-        name: name.split(' ', 1)[0],
-        command: name,
-        description,
+        .map(([name, rawDescription, isDefault, aliases, deprecated]) => ({
+        name: name.split(' ', 1)[0].replace(yargsDefaultCommandRegExp, ''),
+        command: name.replace(yargsDefaultCommandRegExp, ''),
+        default: isDefault || undefined,
+        ...parseDescription(rawDescription),
         aliases,
         deprecated,
     }))
         .sort((a, b) => a.name.localeCompare(b.name));
-    const parseDescription = (rawDescription) => {
-        try {
-            const { longDescription, describe: shortDescription, longDescriptionRelativePath, } = JSON.parse(rawDescription);
-            return {
-                shortDescription,
-                longDescriptionRelativePath,
-                longDescription,
-            };
-        }
-        catch {
-            return {
-                shortDescription: rawDescription,
-            };
-        }
-    };
     const [command, rawDescription] = (_c = usageInstance.getUsage()[0]) !== null && _c !== void 0 ? _c : [];
+    const defaultSubCommand = (_e = (_d = subcommands.find((x) => x.default)) === null || _d === void 0 ? void 0 : _d.command) !== null && _e !== void 0 ? _e : '';
+    const otherSubcommands = subcommands.filter((s) => !s.default);
     const output = {
         name: [...context.commands].pop(),
-        command: command === null || command === void 0 ? void 0 : command.replace('$0', localYargs['$0']),
+        command: `${command === null || command === void 0 ? void 0 : command.replace(yargsDefaultCommandRegExp, localYargs['$0'])}${defaultSubCommand}`,
         ...parseDescription(rawDescription),
         options: normalizeOptions.sort((a, b) => a.name.localeCompare(b.name)),
-        subcommands: subcommands.length ? subcommands : undefined,
+        subcommands: otherSubcommands.length ? otherSubcommands : undefined,
     };
     return JSON.stringify(output, undefined, 2);
 }
 exports.jsonHelpUsage = jsonHelpUsage;
+function parseDescription(rawDescription) {
+    try {
+        const { longDescription, describe: shortDescription, longDescriptionRelativePath, } = JSON.parse(rawDescription);
+        return {
+            shortDescription,
+            longDescriptionRelativePath,
+            longDescription,
+        };
+    }
+    catch {
+        return {
+            shortDescription: rawDescription,
+        };
+    }
+}

package/src/command-builder/utilities/schematic-workflow.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { logging } from '@angular-devkit/core';
+import { NodeWorkflow } from '@angular-devkit/schematics/tools';
+export declare function subscribeToWorkflow(workflow: NodeWorkflow, logger: logging.LoggerApi): {
+    files: Set<string>;
+    error: boolean;
+    unsubscribe: () => void;
+};