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

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

@@ -0,0 +1,21 @@
+/**
+ * @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';
+export interface ConfigCommandArgs {
+    'json-path': string;
+    value?: string;
+    global?: boolean;
+}
+export declare class ConfigCommandModule extends CommandModule<ConfigCommandArgs> implements CommandModuleImplementation<ConfigCommandArgs> {
+    command: string;
+    describe: string;
+    longDescriptionPath: string;
+    builder(localYargs: Argv): Argv<ConfigCommandArgs>;
+    run(options: Options<ConfigCommandArgs>): Promise<number | void>;
+}

package/src/commands/config/cli.js

@@ -0,0 +1,46 @@
+"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.ConfigCommandModule = void 0;
+const path_1 = require("path");
+const command_module_1 = require("../../command-builder/command-module");
+const config_impl_1 = require("./config-impl");
+class ConfigCommandModule extends command_module_1.CommandModule {
+    constructor() {
+        super(...arguments);
+        this.command = 'config <json-path> [value]';
+        this.describe = 'Retrieves or sets Angular configuration values in the angular.json file for the workspace.';
+        this.longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+    }
+    builder(localYargs) {
+        return localYargs
+            .positional('json-path', {
+            description: `The configuration key to set or query, in JSON path format. ` +
+                `For example: "a[3].foo.bar[2]". If no new value is provided, returns the current value of this key.`,
+            type: 'string',
+            demandOption: true,
+        })
+            .positional('value', {
+            description: 'If provided, a new value for the given configuration key.',
+            type: 'string',
+        })
+            .option('global', {
+            description: `Access the global configuration in the caller's home directory.`,
+            alias: ['g'],
+            type: 'boolean',
+            default: false,
+        })
+            .strict();
+    }
+    run(options) {
+        const command = new config_impl_1.ConfigCommand(this.context, 'config');
+        return command.validateAndRun(options);
+    }
+}
+exports.ConfigCommandModule = ConfigCommandModule;

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

@@ -5,11 +5,13 @@
  * 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 ConfigCommandSchema } from './config';
-export declare class ConfigCommand extends Command<ConfigCommandSchema> {
-    run(options: ConfigCommandSchema & Arguments): Promise<0 | 1>;
+import { Command } from '../../../models/command';
+import { Options } from '../../command-builder/command-module';
+import { ConfigCommandArgs } from './cli';
+declare type ConfigCommandOptions = Options<ConfigCommandArgs>;
+export declare class ConfigCommand extends Command<ConfigCommandOptions> {
+    run(options: ConfigCommandOptions): Promise<0 | 1>;
     private get;
     private set;
 }
+export {};

package/{commands → src/commands/config}/config-impl.js

@@ -9,10 +9,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigCommand = void 0;
 const uuid_1 = require("uuid");
-const command_1 = require("../models/command");
-const interface_1 = require("../models/interface");
-const config_1 = require("../utilities/config");
-const json_file_1 = require("../utilities/json-file");
+const command_1 = require("../../../models/command");
+const config_1 = require("../../utilities/config");
+const json_file_1 = require("../../utilities/json-file");
 const validCliPaths = new Map([
     ['cli.warnings.versionMismatch', undefined],
     ['cli.defaultCollection', undefined],
@@ -84,9 +83,6 @@ function normalizeValue(value) {
 class ConfigCommand extends command_1.Command {
     async run(options) {
         const level = options.global ? 'global' : 'local';
-        if (!options.global) {
-            await this.validateScope(interface_1.CommandScope.InProject);
-        }
         const [config] = (0, config_1.getWorkspaceRaw)(level);
         if (options.value == undefined) {
             if (!config) {

package/{commands/config-long.md → src/commands/config/long-description.md}

@@ -6,8 +6,8 @@ or indirectly on the command line using this command.
 
 The configurable property names match command option names,
 except that in the configuration file, all names must use camelCase,
-while on the command line options can be given in either camelCase or dash-case.
+while on the command line options can be given dash-case.
 
 For further details, see [Workspace Configuration](guide/workspace-config).
 
-For configuration of CLI usage analytics, see [Gathering an Viewing CLI Usage Analytics](./usage-analytics-gathering).
+For configuration of CLI usage analytics, see [Gathering an Viewing CLI Usage Analytics](cli/usage-analytics-gathering).

package/src/commands/deploy/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 DeployCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    missingErrorTarget: string;
+    multiTarget: boolean;
+    command: string;
+    longDescriptionPath: string;
+    describe: string;
+}

package/src/commands/deploy/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.DeployCommandModule = 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 DeployCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    constructor() {
+        super(...arguments);
+        this.missingErrorTarget = core_1.tags.stripIndents `
+  Cannot find "deploy" target for the specified project.
+
+  You should add a package that implements deployment capabilities for your
+  favorite platform.
+  
+  For example:
+    ng add @angular/fire
+    ng add @azure/ng-deploy
+  
+  Find more packages on npm https://www.npmjs.com/search?q=ng%20deploy
+  `;
+        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 | undefined;
+    builder(localYargs: Argv): Argv<DocCommandArgs>;
+    run(options: Options<DocCommandArgs>): Promise<number | void>;
+}
+export {};

package/{commands/doc-impl.js → src/commands/doc/cli.js}

@@ -29,28 +29,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 +93,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,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 { ArchitectCommandModule } from '../../command-builder/architect-command-module';
+import { CommandModuleImplementation } from '../../command-builder/command-module';
+export declare class E2eCommandModule extends ArchitectCommandModule implements CommandModuleImplementation {
+    multiTarget: boolean;
+    missingErrorTarget: string;
+    command: string;
+    aliases: string[];
+    describe: string;
+    longDescriptionPath?: string | undefined;
+}

package/src/commands/e2e/cli.js

@@ -0,0 +1,34 @@
+"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 core_1 = require("@angular-devkit/core");
+const architect_command_module_1 = require("../../command-builder/architect-command-module");
+class E2eCommandModule extends architect_command_module_1.ArchitectCommandModule {
+    constructor() {
+        super(...arguments);
+        this.multiTarget = true;
+        this.missingErrorTarget = core_1.tags.stripIndents `
+  Cannot find "e2e" target for the specified project.
+  
+  You should add a package that implements end-to-end testing capabilities.
+  
+  For example:
+    Cypress: ng add @cypress/schematic
+    Nightwatch: ng add @nightwatch/schematics
+    WebdriverIO: ng add @wdio/schematics
+  
+  More options will be added to the list as they become available.
+  `;
+        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,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, Options, OtherOptions } from '../../command-builder/command-module';
+import { SchematicsCommandArgs, SchematicsCommandModule } from '../../command-builder/schematics-command-module';
+export 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): number | void | Promise<number | void>;
+    /**
+     * Generate a command string to be passed to the command builder.
+     *
+     * @example `component [name]` or `@schematics/angular:component [name]`.
+     */
+    private generateCommandString;
+}

package/src/commands/generate/cli.js

@@ -0,0 +1,98 @@
+"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 schematics_command_module_1 = require("../../command-builder/schematics-command-module");
+const generate_impl_1 = require("./generate-impl");
+class GenerateCommandModule extends schematics_command_module_1.SchematicsCommandModule {
+    constructor() {
+        super(...arguments);
+        this.command = 'generate [schematic]';
+        this.aliases = 'g';
+        this.describe = 'Generates and/or modifies files based on a schematic.';
+    }
+    async builder(argv) {
+        const [, schematicNameFromArgs] = this.parseSchematicInfo(
+        // positional = [generate, component] or [generate]
+        this.context.args.positional[1]);
+        const baseYargs = await super.builder(argv);
+        if (this.schematicName) {
+            return baseYargs;
+        }
+        // When we do know the schematic name we need to add the 'schematic'
+        // positional option as the schematic will be accessable as a subcommand.
+        let localYargs = schematicNameFromArgs
+            ? baseYargs
+            : baseYargs.positional('schematic', {
+                describe: 'The schematic or collection:schematic to generate.',
+                type: 'string',
+                demandOption: true,
+            });
+        const collectionName = await this.getCollectionName();
+        const workflow = this.getOrCreateWorkflow(collectionName);
+        const collection = workflow.engine.createCollection(collectionName);
+        const schematicsInCollection = collection.description.schematics;
+        // We cannot use `collection.listSchematicNames()` as this doesn't return hidden schematics.
+        const schematicNames = new Set(Object.keys(schematicsInCollection).sort());
+        if (schematicNameFromArgs && schematicNames.has(schematicNameFromArgs)) {
+            // No need to process all schematics since we know which one the user invoked.
+            schematicNames.clear();
+            schematicNames.add(schematicNameFromArgs);
+        }
+        for (const schematicName of schematicNames) {
+            const { description: { schemaJson, aliases: schematicAliases, hidden: schematicHidden }, } = collection.createSchematic(schematicName, true);
+            if (!schemaJson) {
+                continue;
+            }
+            const { description, 'x-deprecated': xDeprecated, 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;
+    }
+    run(options) {
+        const command = new generate_impl_1.GenerateCommand(this.context, 'generate');
+        return command.validateAndRun(options);
+    }
+    /**
+     * 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);
+        // Only add the collection name as part of the command when it's not the default collection or when it has been provided via the CLI.
+        // Ex:`ng generate @schematics/angular:component`
+        const commandName = !!collectionNameFromArgs ||
+            (await this.getDefaultSchematicCollection()) !== (await this.getCollectionName())
+            ? 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 : ''}`;
+    }
+}
+exports.GenerateCommandModule = GenerateCommandModule;

package/src/commands/generate/generate-impl.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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 { SchematicCommand } from '../../../models/schematic-command';
+import { Options, OtherOptions } from '../../command-builder/command-module';
+import { GenerateCommandArgs } from './cli';
+declare type GenerateCommandOptions = Options<GenerateCommandArgs>;
+export declare class GenerateCommand extends SchematicCommand<GenerateCommandOptions> {
+    longSchematicName: string | undefined;
+    initialize(options: GenerateCommandOptions): Promise<void>;
+    run(options: GenerateCommandOptions & OtherOptions): Promise<number | void>;
+    reportAnalytics(paths: string[], options: GenerateCommandOptions): Promise<void>;
+    private parseSchematicInfo;
+}
+export {};

package/src/commands/generate/generate-impl.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.GenerateCommand = void 0;
+const schematic_command_1 = require("../../../models/schematic-command");
+class GenerateCommand extends schematic_command_1.SchematicCommand {
+    async initialize(options) {
+        // Fill up the schematics property of the command description.
+        const [collectionName, schematicName] = await this.parseSchematicInfo(options.schematic);
+        this.collectionName = collectionName !== null && collectionName !== void 0 ? collectionName : (await this.getDefaultSchematicCollection());
+        this.schematicName = schematicName;
+        await super.initialize(options);
+    }
+    async run(options) {
+        if (!this.schematicName || !this.collectionName) {
+            return 1;
+        }
+        const { dryRun, force, interactive, defaults, schematic, ...schematicOptions } = options;
+        return this.runSchematic({
+            collectionName: this.collectionName,
+            schematicName: this.schematicName,
+            schematicOptions: schematicOptions,
+            debug: false,
+            dryRun,
+            force,
+        });
+    }
+    async reportAnalytics(paths, options) {
+        if (!this.collectionName || !this.schematicName) {
+            return;
+        }
+        const escapedSchematicName = (this.longSchematicName || this.schematicName).replace(/\//g, '_');
+        return super.reportAnalytics(['generate', this.collectionName.replace(/\//g, '_'), escapedSchematicName], options);
+    }
+    parseSchematicInfo(schematic) {
+        if (schematic === null || schematic === void 0 ? void 0 : schematic.includes(':')) {
+            const [collectionName, schematicName] = schematic.split(':', 2);
+            return [collectionName, schematicName];
+        }
+        return [undefined, schematic];
+    }
+}
+exports.GenerateCommand = GenerateCommand;

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;
+}