@angular/cli 14.0.0-next.4 → 14.0.0-next.7

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,16 @@
+/**
+ * @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 LintCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    missingErrorTarget: string;
+    multiTarget: boolean;
+    command: string;
+    longDescriptionPath: string;
+    describe: string;
+}

package/src/commands/lint/cli.js

@@ -0,0 +1,31 @@
+"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 core_1 = require("@angular-devkit/core");
+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.missingErrorTarget = core_1.tags.stripIndents `
+  Cannot find "lint" target for the specified project.
+  
+  You should add a package that implements linting capabilities.
+  
+  For example:
+    ng add @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,77 @@
+"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 workflow = await this.getOrCreateWorkflowForExecution(collectionName, options);
+        workflow.registry.addSmartDefaultProvider('ng-cli-version', () => version_1.VERSION.full);
+        const { dryRun, force, interactive, defaults, collection, ...schematicOptions } = options;
+        // 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;

package/src/commands/run/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 { Target } from '@angular-devkit/architect';
+import { Argv } from 'yargs';
+import { ArchitectBaseCommandModule } from '../../command-builder/architect-base-command-module';
+import { CommandModuleImplementation, CommandScope, Options, OtherOptions } from '../../command-builder/command-module';
+export interface RunCommandArgs {
+    target: string;
+}
+export declare class RunCommandModule extends ArchitectBaseCommandModule<RunCommandArgs> implements CommandModuleImplementation<RunCommandArgs> {
+    static scope: CommandScope;
+    command: string;
+    describe: string;
+    longDescriptionPath: string;
+    builder(argv: Argv): Promise<Argv<RunCommandArgs>>;
+    run(options: Options<RunCommandArgs> & OtherOptions): Promise<number>;
+    protected makeTargetSpecifier(options?: Options<RunCommandArgs>): Target | undefined;
+}

package/src/commands/run/cli.js

@@ -0,0 +1,59 @@
+"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.RunCommandModule = void 0;
+const path_1 = require("path");
+const architect_base_command_module_1 = require("../../command-builder/architect-base-command-module");
+const command_module_1 = require("../../command-builder/command-module");
+class RunCommandModule extends architect_base_command_module_1.ArchitectBaseCommandModule {
+    constructor() {
+        super(...arguments);
+        this.command = 'run <target>';
+        this.describe = 'Runs an Architect target with an optional custom builder configuration defined in your project.';
+        this.longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+    }
+    async builder(argv) {
+        const localYargs = argv
+            .positional('target', {
+            describe: 'The Architect target to run.',
+            type: 'string',
+            demandOption: true,
+        })
+            .strict();
+        const target = this.makeTargetSpecifier();
+        if (!target) {
+            return localYargs;
+        }
+        const schemaOptions = await this.getArchitectTargetOptions(target);
+        return this.addSchemaOptionsToCommand(localYargs, schemaOptions);
+    }
+    async run(options) {
+        const target = this.makeTargetSpecifier(options);
+        const { target: _target, ...extraOptions } = options;
+        if (!target) {
+            throw new command_module_1.CommandModuleError('Cannot determine project or target.');
+        }
+        return this.runSingleTarget(target, extraOptions);
+    }
+    makeTargetSpecifier(options) {
+        var _a;
+        const architectTarget = (_a = options === null || options === void 0 ? void 0 : options.target) !== null && _a !== void 0 ? _a : this.context.args.positional[1];
+        if (!architectTarget) {
+            return undefined;
+        }
+        const [project = '', target = '', configuration] = architectTarget.split(':');
+        return {
+            project,
+            target,
+            configuration,
+        };
+    }
+}
+exports.RunCommandModule = RunCommandModule;
+RunCommandModule.scope = command_module_1.CommandScope.In;

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

@@ -0,0 +1,16 @@
+/**
+ * @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 ServeCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    multiTarget: boolean;
+    command: string;
+    aliases: string[];
+    describe: string;
+    longDescriptionPath?: string | undefined;
+}

package/src/commands/serve/cli.js

@@ -0,0 +1,21 @@
+"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.ServeCommandModule = void 0;
+const architect_command_module_1 = require("../../command-builder/architect-command-module");
+class ServeCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    constructor() {
+        super(...arguments);
+        this.multiTarget = false;
+        this.command = 'serve [project]';
+        this.aliases = ['s'];
+        this.describe = 'Builds and serves your application, rebuilding on file changes.';
+    }
+}
+exports.ServeCommandModule = ServeCommandModule;

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

@@ -0,0 +1,16 @@
+/**
+ * @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 TestCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    multiTarget: boolean;
+    command: string;
+    aliases: string[];
+    describe: string;
+    longDescriptionPath: string;
+}

package/src/commands/test/cli.js

@@ -0,0 +1,23 @@
+"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.TestCommandModule = void 0;
+const path_1 = require("path");
+const architect_command_module_1 = require("../../command-builder/architect-command-module");
+class TestCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    constructor() {
+        super(...arguments);
+        this.multiTarget = true;
+        this.command = 'test [project]';
+        this.aliases = ['t'];
+        this.describe = 'Runs unit tests in a project.';
+        this.longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+    }
+}
+exports.TestCommandModule = TestCommandModule;

package/{commands/update-impl.d.ts → src/commands/update/cli.d.ts}

@@ -5,14 +5,28 @@
  * 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 { Command } from '../models/command';
-import { Arguments } from '../models/interface';
-import { Schema as UpdateCommandSchema } from './update';
-export declare class UpdateCommand extends Command<UpdateCommandSchema> {
-    readonly allowMissingWorkspace = true;
-    private workflow;
-    private packageManager;
-    initialize(options: UpdateCommandSchema & Arguments): Promise<void>;
+import { Argv } from 'yargs';
+import { CommandModule, CommandScope, Options } from '../../command-builder/command-module';
+interface UpdateCommandArgs {
+    packages?: string[];
+    force: boolean;
+    next: boolean;
+    'migrate-only'?: boolean;
+    name?: string;
+    from?: string;
+    to?: string;
+    'allow-dirty': boolean;
+    verbose: boolean;
+    'create-commits': boolean;
+}
+export declare class UpdateCommandModule extends CommandModule<UpdateCommandArgs> {
+    static scope: CommandScope;
+    protected shouldReportAnalytics: boolean;
+    command: string;
+    describe: string;
+    longDescriptionPath: string;
+    builder(localYargs: Argv): Argv<UpdateCommandArgs>;
+    run(options: Options<UpdateCommandArgs>): Promise<number | void>;
     private executeSchematic;
     /**
      * @return Whether or not the migration was performed successfully.
@@ -23,7 +37,8 @@ export declare class UpdateCommand extends Command<UpdateCommandSchema> {
      */
     private executeMigrations;
     private executePackageMigrations;
-    run(options: UpdateCommandSchema & Arguments): Promise<number>;
+    private migrateOnly;
+    private updatePackagesAndMigrate;
     /**
      * @return Whether or not the commit was successful.
      */
@@ -35,4 +50,6 @@ export declare class UpdateCommand extends Command<UpdateCommandSchema> {
      */
     private checkCLIVersion;
     private getCLIUpdateRunnerVersion;
+    private runTempBinary;
 }
+export {};