@angular/cli 14.0.0-next.1 → 14.0.0-next.12

package/src/commands/deploy/cli.js

@@ -0,0 +1,49 @@
+"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.DeployCommandModule = void 0;
+const path_1 = require("path");
+const architect_command_module_1 = require("../../command-builder/architect-command-module");
+class DeployCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    constructor() {
+        super(...arguments);
+        // The below choices should be kept in sync with the list in https://angular.io/guide/deployment
+        this.missingTargetChoices = [
+            {
+                name: 'Amazon S3',
+                value: '@jefiozie/ngx-aws-deploy',
+            },
+            {
+                name: 'Azure',
+                value: '@azure/ng-deploy',
+            },
+            {
+                name: 'Firebase',
+                value: '@angular/fire',
+            },
+            {
+                name: 'Netlify',
+                value: '@netlify-builder/deploy',
+            },
+            {
+                name: 'NPM',
+                value: 'ngx-deploy-npm',
+            },
+            {
+                name: 'GitHub Pages',
+                value: 'angular-cli-ghpages',
+            },
+        ];
+        this.multiTarget = false;
+        this.command = 'deploy [project]';
+        this.longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+        this.describe = 'Invokes the deploy builder for a specified project or for the default project in the workspace.';
+    }
+}
+exports.DeployCommandModule = DeployCommandModule;

package/src/commands/doc/cli.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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 { CommandModule, CommandModuleImplementation, Options } from '../../command-builder/command-module';
+interface DocCommandArgs {
+    keyword: string;
+    search?: boolean;
+    version?: string;
+}
+export declare class DocCommandModule extends CommandModule<DocCommandArgs> implements CommandModuleImplementation<DocCommandArgs> {
+    command: string;
+    aliases: string[];
+    describe: string;
+    longDescriptionPath?: string;
+    builder(localYargs: Argv): Argv<DocCommandArgs>;
+    run(options: Options<DocCommandArgs>): Promise<number | void>;
+}
+export {};

package/{commands/doc-impl.js → src/commands/doc/cli.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];
@@ -29,28 +33,53 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocCommand = void 0;
+exports.DocCommandModule = void 0;
 const open_1 = __importDefault(require("open"));
-const command_1 = require("../models/command");
-class DocCommand extends command_1.Command {
+const command_module_1 = require("../../command-builder/command-module");
+class DocCommandModule extends command_module_1.CommandModule {
+    constructor() {
+        super(...arguments);
+        this.command = 'doc <keyword>';
+        this.aliases = ['d'];
+        this.describe = 'Opens the official Angular documentation (angular.io) in a browser, and searches for a given keyword.';
+    }
+    builder(localYargs) {
+        return localYargs
+            .positional('keyword', {
+            description: 'The keyword to search for, as provided in the search bar in angular.io.',
+            type: 'string',
+            demandOption: true,
+        })
+            .option('search', {
+            description: `Search all of angular.io. Otherwise, searches only API reference documentation.`,
+            alias: ['s'],
+            type: 'boolean',
+            default: false,
+        })
+            .option('version', {
+            description: 'Contains the version of Angular to use for the documentation. ' +
+                'If not provided, the command uses your current Angular core version.',
+            type: 'string',
+        })
+            .strict();
+    }
     async run(options) {
-        if (!options.keyword) {
-            this.logger.error('You should specify a keyword, for instance, `ng doc ActivatedRoute`.');
-            return 0;
-        }
         let domain = 'angular.io';
         if (options.version) {
             // version can either be a string containing "next"
-            if (options.version == 'next') {
+            if (options.version === 'next') {
                 domain = 'next.angular.io';
+            }
+            else if (options.version === 'rc') {
+                domain = 'rc.angular.io';
                 // or a number where version must be a valid Angular version (i.e. not 0, 1 or 3)
             }
             else if (!isNaN(+options.version) && ![0, 1, 3].includes(+options.version)) {
                 domain = `v${options.version}.angular.io`;
             }
             else {
-                this.logger.error('Version should either be a number (2, 4, 5, 6...) or "next"');
-                return 0;
+                this.context.logger.error('Version should either be a number (2, 4, 5, 6...), "rc" or "next"');
+                return 1;
             }
         }
         else {
@@ -68,4 +97,4 @@ class DocCommand extends command_1.Command {
             : `https://${domain}/docs?search=${options.keyword}`);
     }
 }
-exports.DocCommand = DocCommand;
+exports.DocCommandModule = DocCommandModule;

package/src/commands/e2e/cli.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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 { MissingTargetChoice } from '../../command-builder/architect-base-command-module';
+import { ArchitectCommandModule } from '../../command-builder/architect-command-module';
+import { CommandModuleImplementation } from '../../command-builder/command-module';
+export declare class E2eCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    missingTargetChoices: MissingTargetChoice[];
+    multiTarget: boolean;
+    command: string;
+    aliases: string[];
+    describe: string;
+    longDescriptionPath?: string;
+}

package/src/commands/e2e/cli.js

@@ -0,0 +1,35 @@
+"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.E2eCommandModule = void 0;
+const architect_command_module_1 = require("../../command-builder/architect-command-module");
+class E2eCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    constructor() {
+        super(...arguments);
+        this.missingTargetChoices = [
+            {
+                name: 'Cypress',
+                value: '@cypress/schematic',
+            },
+            {
+                name: 'Nightwatch',
+                value: '@nightwatch/schematics',
+            },
+            {
+                name: 'WebdriverIO',
+                value: '@wdio/schematics',
+            },
+        ];
+        this.multiTarget = true;
+        this.command = 'e2e [project]';
+        this.aliases = ['e'];
+        this.describe = 'Builds and serves an Angular application, then runs end-to-end tests.';
+    }
+}
+exports.E2eCommandModule = E2eCommandModule;

package/src/commands/extract-i18n/cli.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @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 { ArchitectCommandModule } from '../../command-builder/architect-command-module';
+import { CommandModuleImplementation } from '../../command-builder/command-module';
+export declare class ExtractI18nCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    multiTarget: boolean;
+    command: string;
+    describe: string;
+    longDescriptionPath?: string | undefined;
+}

package/src/commands/extract-i18n/cli.js

@@ -0,0 +1,20 @@
+"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.ExtractI18nCommandModule = void 0;
+const architect_command_module_1 = require("../../command-builder/architect-command-module");
+class ExtractI18nCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    constructor() {
+        super(...arguments);
+        this.multiTarget = false;
+        this.command = 'extract-i18n [project]';
+        this.describe = 'Extracts i18n messages from source code.';
+    }
+}
+exports.ExtractI18nCommandModule = ExtractI18nCommandModule;

package/src/commands/generate/cli.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @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 { CommandModuleImplementation, Options, OtherOptions } from '../../command-builder/command-module';
+import { SchematicsCommandArgs, SchematicsCommandModule } from '../../command-builder/schematics-command-module';
+interface GenerateCommandArgs extends SchematicsCommandArgs {
+    schematic?: string;
+}
+export declare class GenerateCommandModule extends SchematicsCommandModule implements CommandModuleImplementation<GenerateCommandArgs> {
+    command: string;
+    aliases: string;
+    describe: string;
+    longDescriptionPath?: string | undefined;
+    builder(argv: Argv): Promise<Argv<GenerateCommandArgs>>;
+    run(options: Options<GenerateCommandArgs> & OtherOptions): Promise<number | void>;
+    private getCollectionNames;
+    /**
+     * Generate a command string to be passed to the command builder.
+     *
+     * @example `component [name]` or `@schematics/angular:component [name]`.
+     */
+    private generateCommandString;
+    /**
+     * Get schematics that can to be registered as subcommands.
+     */
+    private getSchematics;
+    /**
+     * Get schematics that should to be registered as subcommands.
+     *
+     * @returns a sorted list of schematic that needs to be registered as subcommands.
+     */
+    private getSchematicsToRegister;
+}
+export {};

package/src/commands/generate/cli.js

@@ -0,0 +1,145 @@
+"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.GenerateCommandModule = void 0;
+const core_1 = require("@angular-devkit/core");
+const command_module_1 = require("../../command-builder/command-module");
+const schematics_command_module_1 = require("../../command-builder/schematics-command-module");
+const command_1 = require("../../command-builder/utilities/command");
+class GenerateCommandModule extends schematics_command_module_1.SchematicsCommandModule {
+    constructor() {
+        super(...arguments);
+        this.command = 'generate';
+        this.aliases = 'g';
+        this.describe = 'Generates and/or modifies files based on a schematic.';
+    }
+    async builder(argv) {
+        let localYargs = (await super.builder(argv)).command({
+            command: '$0 <schematic>',
+            describe: 'Run the provided schematic.',
+            builder: (localYargs) => localYargs
+                .positional('schematic', {
+                describe: 'The [collection:schematic] to run.',
+                type: 'string',
+                demandOption: true,
+            })
+                .strict(),
+            handler: (options) => this.handler(options),
+        });
+        for (const [schematicName, collectionName] of await this.getSchematicsToRegister()) {
+            const workflow = this.getOrCreateWorkflowForBuilder(collectionName);
+            const collection = workflow.engine.createCollection(collectionName);
+            const { description: { schemaJson, aliases: schematicAliases, hidden: schematicHidden, description: schematicDescription, }, } = collection.createSchematic(schematicName, true);
+            if (!schemaJson) {
+                continue;
+            }
+            const { 'x-deprecated': xDeprecated, description = schematicDescription, aliases = schematicAliases, hidden = schematicHidden, } = schemaJson;
+            const options = await this.getSchematicOptions(collection, schematicName, workflow);
+            localYargs = localYargs.command({
+                command: await this.generateCommandString(collectionName, schematicName, options),
+                // When 'describe' is set to false, it results in a hidden command.
+                describe: hidden === true ? false : typeof description === 'string' ? description : '',
+                deprecated: xDeprecated === true || typeof xDeprecated === 'string' ? xDeprecated : false,
+                aliases: Array.isArray(aliases) ? aliases : undefined,
+                builder: (localYargs) => this.addSchemaOptionsToCommand(localYargs, options).strict(),
+                handler: (options) => this.handler({ ...options, schematic: `${collectionName}:${schematicName}` }),
+            });
+        }
+        return localYargs.demandCommand(1, command_1.demandCommandFailureMessage);
+    }
+    async run(options) {
+        const { dryRun, schematic, defaults, force, interactive, ...schematicOptions } = options;
+        const [collectionName, schematicName] = this.parseSchematicInfo(schematic);
+        if (!collectionName || !schematicName) {
+            throw new command_module_1.CommandModuleError('A collection and schematic is required during execution.');
+        }
+        return this.runSchematic({
+            collectionName,
+            schematicName,
+            schematicOptions,
+            executionOptions: {
+                dryRun,
+                defaults,
+                force,
+                interactive,
+            },
+        });
+    }
+    async getCollectionNames() {
+        const [collectionName] = this.parseSchematicInfo(
+        // positional = [generate, component] or [generate]
+        this.context.args.positional[1]);
+        return collectionName ? [collectionName] : [...(await this.getSchematicCollections())];
+    }
+    /**
+     * Generate a command string to be passed to the command builder.
+     *
+     * @example `component [name]` or `@schematics/angular:component [name]`.
+     */
+    async generateCommandString(collectionName, schematicName, options) {
+        const [collectionNameFromArgs] = this.parseSchematicInfo(
+        // positional = [generate, component] or [generate]
+        this.context.args.positional[1]);
+        const dasherizedSchematicName = core_1.strings.dasherize(schematicName);
+        const schematicCollectionsFromConfig = await this.getSchematicCollections();
+        const collectionNames = await this.getCollectionNames();
+        // Only add the collection name as part of the command when it's not a known
+        // schematics collection or when it has been provided via the CLI.
+        // Ex:`ng generate @schematics/angular:component`
+        const commandName = !!collectionNameFromArgs ||
+            !collectionNames.some((c) => schematicCollectionsFromConfig.has(c))
+            ? collectionName + ':' + dasherizedSchematicName
+            : dasherizedSchematicName;
+        const positionalArgs = options
+            .filter((o) => o.positional !== undefined)
+            .map((o) => {
+            const label = `${core_1.strings.dasherize(o.name)}${o.type === 'array' ? ' ..' : ''}`;
+            return o.required ? `<${label}>` : `[${label}]`;
+        })
+            .join(' ');
+        return `${commandName}${positionalArgs ? ' ' + positionalArgs : ''}`;
+    }
+    /**
+     * Get schematics that can to be registered as subcommands.
+     */
+    async *getSchematics() {
+        const seenNames = new Set();
+        for (const collectionName of await this.getCollectionNames()) {
+            const workflow = this.getOrCreateWorkflowForBuilder(collectionName);
+            const collection = workflow.engine.createCollection(collectionName);
+            for (const schematicName of collection.listSchematicNames(true /** includeHidden */)) {
+                // If a schematic with this same name is already registered skip.
+                if (!seenNames.has(schematicName)) {
+                    seenNames.add(schematicName);
+                    yield { schematicName, collectionName };
+                }
+            }
+        }
+    }
+    /**
+     * Get schematics that should to be registered as subcommands.
+     *
+     * @returns a sorted list of schematic that needs to be registered as subcommands.
+     */
+    async getSchematicsToRegister() {
+        const schematicsToRegister = [];
+        const [, schematicNameFromArgs] = this.parseSchematicInfo(
+        // positional = [generate, component] or [generate]
+        this.context.args.positional[1]);
+        for await (const { schematicName, collectionName } of this.getSchematics()) {
+            if (schematicName === schematicNameFromArgs) {
+                return [[schematicName, collectionName]];
+            }
+            schematicsToRegister.push([schematicName, collectionName]);
+        }
+        // Didn't find the schematic or no schematic name was provided Ex: `ng generate --help`.
+        return schematicsToRegister.sort(([nameA], [nameB]) => nameA.localeCompare(nameB, undefined, { sensitivity: 'accent' }));
+    }
+}
+exports.GenerateCommandModule = GenerateCommandModule;

package/src/commands/lint/cli.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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 { MissingTargetChoice } from '../../command-builder/architect-base-command-module';
+import { ArchitectCommandModule } from '../../command-builder/architect-command-module';
+import { CommandModuleImplementation } from '../../command-builder/command-module';
+export declare class LintCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    missingTargetChoices: MissingTargetChoice[];
+    multiTarget: boolean;
+    command: string;
+    longDescriptionPath: string;
+    describe: string;
+}

package/src/commands/lint/cli.js

@@ -0,0 +1,28 @@
+"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.LintCommandModule = void 0;
+const path_1 = require("path");
+const architect_command_module_1 = require("../../command-builder/architect-command-module");
+class LintCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    constructor() {
+        super(...arguments);
+        this.missingTargetChoices = [
+            {
+                name: 'ESLint',
+                value: '@angular-eslint/schematics',
+            },
+        ];
+        this.multiTarget = true;
+        this.command = 'lint [project]';
+        this.longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+        this.describe = 'Runs linting tools on Angular application code in a given project folder.';
+    }
+}
+exports.LintCommandModule = LintCommandModule;

package/src/commands/make-this-awesome/cli.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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 { CommandModule, CommandModuleImplementation } from '../../command-builder/command-module';
+export declare class AwesomeCommandModule extends CommandModule implements CommandModuleImplementation {
+    command: string;
+    describe: false;
+    deprecated: boolean;
+    longDescriptionPath?: string | undefined;
+    builder(localYargs: Argv): Argv;
+    run(): void;
+}

package/{commands/easter-egg-impl.js → src/commands/make-this-awesome/cli.js}

@@ -7,14 +7,21 @@
  * found in the LICENSE file at https://angular.io/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AwesomeCommand = void 0;
-const command_1 = require("../models/command");
-const color_1 = require("../utilities/color");
-function pickOne(of) {
-    return of[Math.floor(Math.random() * of.length)];
-}
-class AwesomeCommand extends command_1.Command {
-    async run() {
+exports.AwesomeCommandModule = void 0;
+const command_module_1 = require("../../command-builder/command-module");
+const color_1 = require("../../utilities/color");
+class AwesomeCommandModule extends command_module_1.CommandModule {
+    constructor() {
+        super(...arguments);
+        this.command = 'make-this-awesome';
+        this.describe = false;
+        this.deprecated = false;
+    }
+    builder(localYargs) {
+        return localYargs;
+    }
+    run() {
+        const pickOne = (of) => of[Math.floor(Math.random() * of.length)];
         const phrase = pickOne([
             `You're on it, there's nothing for me to do!`,
             `Let's take a look... nope, it's all good!`,
@@ -25,7 +32,7 @@ class AwesomeCommand extends command_1.Command {
             `I spy with my little eye a great developer!`,
             `Noop... already awesome.`,
         ]);
-        this.logger.info(color_1.colors.green(phrase));
+        this.context.logger.info(color_1.colors.green(phrase));
     }
 }
-exports.AwesomeCommand = AwesomeCommand;
+exports.AwesomeCommandModule = AwesomeCommandModule;

package/src/commands/new/cli.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @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 { CommandModuleImplementation, CommandScope, Options, OtherOptions } from '../../command-builder/command-module';
+import { SchematicsCommandArgs, SchematicsCommandModule } from '../../command-builder/schematics-command-module';
+interface NewCommandArgs extends SchematicsCommandArgs {
+    collection?: string;
+}
+export declare class NewCommandModule extends SchematicsCommandModule implements CommandModuleImplementation<NewCommandArgs> {
+    private readonly schematicName;
+    static scope: CommandScope;
+    protected allowPrivateSchematics: boolean;
+    command: string;
+    aliases: string;
+    describe: string;
+    longDescriptionPath?: string | undefined;
+    builder(argv: Argv): Promise<Argv<NewCommandArgs>>;
+    run(options: Options<NewCommandArgs> & OtherOptions): Promise<number | void>;
+    /** Find a collection from config that has an `ng-new` schematic. */
+    private getCollectionFromConfig;
+}
+export {};

package/src/commands/new/cli.js

@@ -0,0 +1,82 @@
+"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.NewCommandModule = void 0;
+const command_module_1 = require("../../command-builder/command-module");
+const schematics_command_module_1 = require("../../command-builder/schematics-command-module");
+const version_1 = require("../../utilities/version");
+class NewCommandModule extends schematics_command_module_1.SchematicsCommandModule {
+    constructor() {
+        super(...arguments);
+        this.schematicName = 'ng-new';
+        this.allowPrivateSchematics = true;
+        this.command = 'new [name]';
+        this.aliases = 'n';
+        this.describe = 'Creates a new Angular workspace.';
+    }
+    async builder(argv) {
+        const localYargs = (await super.builder(argv)).option('collection', {
+            alias: 'c',
+            describe: 'A collection of schematics to use in generating the initial application.',
+            type: 'string',
+        });
+        const { options: { collectionNameFromArgs }, } = this.context.args;
+        const collectionName = typeof collectionNameFromArgs === 'string'
+            ? collectionNameFromArgs
+            : await this.getCollectionFromConfig();
+        const workflow = await this.getOrCreateWorkflowForBuilder(collectionName);
+        const collection = workflow.engine.createCollection(collectionName);
+        const options = await this.getSchematicOptions(collection, this.schematicName, workflow);
+        return this.addSchemaOptionsToCommand(localYargs, options);
+    }
+    async run(options) {
+        var _a;
+        // Register the version of the CLI in the registry.
+        const collectionName = (_a = options.collection) !== null && _a !== void 0 ? _a : (await this.getCollectionFromConfig());
+        const { dryRun, force, interactive, defaults, collection, ...schematicOptions } = options;
+        const workflow = await this.getOrCreateWorkflowForExecution(collectionName, {
+            dryRun,
+            force,
+            interactive,
+            defaults,
+        });
+        workflow.registry.addSmartDefaultProvider('ng-cli-version', () => version_1.VERSION.full);
+        // Compatibility check for NPM 7
+        if (collectionName === '@schematics/angular' &&
+            !schematicOptions.skipInstall &&
+            (schematicOptions.packageManager === undefined || schematicOptions.packageManager === 'npm')) {
+            this.context.packageManager.ensureCompatibility();
+        }
+        return this.runSchematic({
+            collectionName,
+            schematicName: this.schematicName,
+            schematicOptions,
+            executionOptions: {
+                dryRun,
+                force,
+                interactive,
+                defaults,
+            },
+        });
+    }
+    /** Find a collection from config that has an `ng-new` schematic. */
+    async getCollectionFromConfig() {
+        for (const collectionName of await this.getSchematicCollections()) {
+            const workflow = this.getOrCreateWorkflowForBuilder(collectionName);
+            const collection = workflow.engine.createCollection(collectionName);
+            const schematicsInCollection = collection.description.schematics;
+            if (Object.keys(schematicsInCollection).includes(this.schematicName)) {
+                return collectionName;
+            }
+        }
+        return schematics_command_module_1.DEFAULT_SCHEMATICS_COLLECTION;
+    }
+}
+exports.NewCommandModule = NewCommandModule;
+NewCommandModule.scope = command_module_1.CommandScope.Out;