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

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

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

@@ -0,0 +1,68 @@
+"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.subscribeToWorkflow = void 0;
+const core_1 = require("@angular-devkit/core");
+const color_1 = require("../../utilities/color");
+function subscribeToWorkflow(workflow, logger) {
+    const files = new Set();
+    let error = false;
+    let logs = [];
+    const reporterSubscription = workflow.reporter.subscribe((event) => {
+        // Strip leading slash to prevent confusion.
+        const eventPath = event.path.charAt(0) === '/' ? event.path.substring(1) : event.path;
+        switch (event.kind) {
+            case 'error':
+                error = true;
+                const desc = event.description == 'alreadyExist' ? 'already exists' : 'does not exist';
+                logger.error(`ERROR! ${eventPath} ${desc}.`);
+                break;
+            case 'update':
+                logs.push(core_1.tags.oneLine `
+              ${color_1.colors.cyan('UPDATE')} ${eventPath} (${event.content.length} bytes)
+            `);
+                files.add(eventPath);
+                break;
+            case 'create':
+                logs.push(core_1.tags.oneLine `
+              ${color_1.colors.green('CREATE')} ${eventPath} (${event.content.length} bytes)
+            `);
+                files.add(eventPath);
+                break;
+            case 'delete':
+                logs.push(`${color_1.colors.yellow('DELETE')} ${eventPath}`);
+                files.add(eventPath);
+                break;
+            case 'rename':
+                const eventToPath = event.to.charAt(0) === '/' ? event.to.substring(1) : event.to;
+                logs.push(`${color_1.colors.blue('RENAME')} ${eventPath} => ${eventToPath}`);
+                files.add(eventPath);
+                break;
+        }
+    });
+    const lifecycleSubscription = workflow.lifeCycle.subscribe((event) => {
+        if (event.kind == 'end' || event.kind == 'post-tasks-start') {
+            if (!error) {
+                // Output the logging queue, no error happened.
+                logs.forEach((log) => logger.info(log));
+            }
+            logs = [];
+            error = false;
+        }
+    });
+    return {
+        files,
+        error,
+        unsubscribe: () => {
+            reporterSubscription.unsubscribe();
+            lifecycleSubscription.unsubscribe();
+        },
+    };
+}
+exports.subscribeToWorkflow = subscribeToWorkflow;

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

@@ -8,7 +8,7 @@
 import { Argv } from 'yargs';
 import { CommandModuleImplementation, Options, OtherOptions } from '../../command-builder/command-module';
 import { SchematicsCommandArgs, SchematicsCommandModule } from '../../command-builder/schematics-command-module';
-export interface AddCommandArgs extends SchematicsCommandArgs {
+interface AddCommandArgs extends SchematicsCommandArgs {
     collection: string;
     verbose?: boolean;
     registry?: string;
@@ -18,6 +18,16 @@ export declare class AddCommandModule extends SchematicsCommandModule implements
     command: string;
     describe: string;
     longDescriptionPath: string;
+    protected allowPrivateSchematics: boolean;
+    private readonly schematicName;
     builder(argv: Argv): Promise<Argv<AddCommandArgs>>;
     run(options: Options<AddCommandArgs> & OtherOptions): Promise<number | void>;
+    private isProjectVersionValid;
+    reportAnalytics(options: OtherOptions, paths: string[]): Promise<void>;
+    private getCollectionName;
+    private isPackageInstalled;
+    private executeSchematic;
+    private findProjectVersion;
+    private hasMismatchedPeer;
 }
+export {};

package/src/commands/add/cli.js

@@ -6,21 +6,44 @@
  * 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.AddCommandModule = void 0;
+const core_1 = require("@angular-devkit/core");
+const tools_1 = require("@angular-devkit/schematics/tools");
+const npm_package_arg_1 = __importDefault(require("npm-package-arg"));
 const path_1 = require("path");
+const semver_1 = require("semver");
+const workspace_schema_1 = require("../../../lib/config/workspace-schema");
+const analytics_1 = require("../../analytics/analytics");
 const schematics_command_module_1 = require("../../command-builder/schematics-command-module");
-const add_impl_1 = require("./add-impl");
+const color_1 = require("../../utilities/color");
+const package_metadata_1 = require("../../utilities/package-metadata");
+const prompt_1 = require("../../utilities/prompt");
+const spinner_1 = require("../../utilities/spinner");
+const tty_1 = require("../../utilities/tty");
+/**
+ * The set of packages that should have certain versions excluded from consideration
+ * when attempting to find a compatible version for a package.
+ * The key is a package name and the value is a SemVer range of versions to exclude.
+ */
+const packageVersionExclusions = {
+    // @angular/localize@9.x versions do not have peer dependencies setup
+    '@angular/localize': '9.x',
+};
 class AddCommandModule extends schematics_command_module_1.SchematicsCommandModule {
     constructor() {
         super(...arguments);
         this.command = 'add <collection>';
         this.describe = 'Adds support for an external library to your project.';
         this.longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
+        this.allowPrivateSchematics = true;
+        this.schematicName = 'ng-add';
     }
     async builder(argv) {
-        const localYargs = await super.builder(argv);
-        return localYargs
+        const localYargs = (await super.builder(argv))
             .positional('collection', {
             description: 'The package to be added.',
             type: 'string',
@@ -38,11 +61,307 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
             type: 'boolean',
             default: false,
         })
+            // Prior to downloading we don't know the full schema and therefore we cannot be strict on the options.
+            // Possibly in the future update the logic to use the following syntax:
+            // `ng add @angular/localize -- --package-options`.
             .strict(false);
+        const collectionName = await this.getCollectionName();
+        const workflow = await this.getOrCreateWorkflowForBuilder(collectionName);
+        try {
+            const collection = workflow.engine.createCollection(collectionName);
+            const options = await this.getSchematicOptions(collection, this.schematicName, workflow);
+            return this.addSchemaOptionsToCommand(localYargs, options);
+        }
+        catch (error) {
+            // During `ng add` prior to the downloading of the package
+            // we are not able to resolve and create a collection.
+            // Or when the the collection value is a path to a tarball.
+        }
+        return localYargs;
+    }
+    // eslint-disable-next-line max-lines-per-function
+    async run(options) {
+        var _a;
+        const { logger, packageManager } = this.context;
+        const { verbose, registry, collection, skipConfirmation } = options;
+        packageManager.ensureCompatibility();
+        let packageIdentifier;
+        try {
+            packageIdentifier = (0, npm_package_arg_1.default)(collection);
+        }
+        catch (e) {
+            logger.error(e.message);
+            return 1;
+        }
+        if (packageIdentifier.name &&
+            packageIdentifier.registry &&
+            this.isPackageInstalled(packageIdentifier.name)) {
+            const validVersion = await this.isProjectVersionValid(packageIdentifier);
+            if (validVersion) {
+                // Already installed so just run schematic
+                logger.info('Skipping installation: Package already installed');
+                return this.executeSchematic({ ...options, collection: packageIdentifier.name });
+            }
+        }
+        const spinner = new spinner_1.Spinner();
+        spinner.start('Determining package manager...');
+        const usingYarn = packageManager.name === workspace_schema_1.PackageManager.Yarn;
+        spinner.info(`Using package manager: ${color_1.colors.grey(packageManager.name)}`);
+        if (packageIdentifier.name && packageIdentifier.type === 'tag' && !packageIdentifier.rawSpec) {
+            // only package name provided; search for viable version
+            // plus special cases for packages that did not have peer deps setup
+            spinner.start('Searching for compatible package version...');
+            let packageMetadata;
+            try {
+                packageMetadata = await (0, package_metadata_1.fetchPackageMetadata)(packageIdentifier.name, logger, {
+                    registry,
+                    usingYarn,
+                    verbose,
+                });
+            }
+            catch (e) {
+                spinner.fail(`Unable to load package information from registry: ${e.message}`);
+                return 1;
+            }
+            // Start with the version tagged as `latest` if it exists
+            const latestManifest = packageMetadata.tags['latest'];
+            if (latestManifest) {
+                packageIdentifier = npm_package_arg_1.default.resolve(latestManifest.name, latestManifest.version);
+            }
+            // Adjust the version based on name and peer dependencies
+            if ((latestManifest === null || latestManifest === void 0 ? void 0 : latestManifest.peerDependencies) &&
+                Object.keys(latestManifest.peerDependencies).length === 0) {
+                spinner.succeed(`Found compatible package version: ${color_1.colors.grey(packageIdentifier.toString())}.`);
+            }
+            else if (!latestManifest || (await this.hasMismatchedPeer(latestManifest))) {
+                // 'latest' is invalid so search for most recent matching package
+                const versionExclusions = packageVersionExclusions[packageMetadata.name];
+                const versionManifests = Object.values(packageMetadata.versions).filter((value) => {
+                    // Prerelease versions are not stable and should not be considered by default
+                    if ((0, semver_1.prerelease)(value.version)) {
+                        return false;
+                    }
+                    // Deprecated versions should not be used or considered
+                    if (value.deprecated) {
+                        return false;
+                    }
+                    // Excluded package versions should not be considered
+                    if (versionExclusions && (0, semver_1.satisfies)(value.version, versionExclusions)) {
+                        return false;
+                    }
+                    return true;
+                });
+                versionManifests.sort((a, b) => (0, semver_1.compare)(a.version, b.version, true));
+                let newIdentifier;
+                for (const versionManifest of versionManifests) {
+                    if (!(await this.hasMismatchedPeer(versionManifest))) {
+                        newIdentifier = npm_package_arg_1.default.resolve(versionManifest.name, versionManifest.version);
+                        break;
+                    }
+                }
+                if (!newIdentifier) {
+                    spinner.warn("Unable to find compatible package. Using 'latest' tag.");
+                }
+                else {
+                    packageIdentifier = newIdentifier;
+                    spinner.succeed(`Found compatible package version: ${color_1.colors.grey(packageIdentifier.toString())}.`);
+                }
+            }
+            else {
+                spinner.succeed(`Found compatible package version: ${color_1.colors.grey(packageIdentifier.toString())}.`);
+            }
+        }
+        let collectionName = packageIdentifier.name;
+        let savePackage;
+        try {
+            spinner.start('Loading package information from registry...');
+            const manifest = await (0, package_metadata_1.fetchPackageManifest)(packageIdentifier.toString(), logger, {
+                registry,
+                verbose,
+                usingYarn,
+            });
+            savePackage = (_a = manifest['ng-add']) === null || _a === void 0 ? void 0 : _a.save;
+            collectionName = manifest.name;
+            if (await this.hasMismatchedPeer(manifest)) {
+                spinner.warn('Package has unmet peer dependencies. Adding the package may not succeed.');
+            }
+            else {
+                spinner.succeed(`Package information loaded.`);
+            }
+        }
+        catch (e) {
+            spinner.fail(`Unable to fetch package information for '${packageIdentifier}': ${e.message}`);
+            return 1;
+        }
+        if (!skipConfirmation) {
+            const confirmationResponse = await (0, prompt_1.askConfirmation)(`\nThe package ${color_1.colors.blue(packageIdentifier.raw)} will be installed and executed.\n` +
+                'Would you like to proceed?', true, false);
+            if (!confirmationResponse) {
+                if (!(0, tty_1.isTTY)()) {
+                    logger.error('No terminal detected. ' +
+                        `'--skip-confirmation' can be used to bypass installation confirmation. ` +
+                        `Ensure package name is correct prior to '--skip-confirmation' option usage.`);
+                }
+                logger.error('Command aborted.');
+                return 1;
+            }
+        }
+        if (savePackage === false) {
+            // Temporary packages are located in a different directory
+            // Hence we need to resolve them using the temp path
+            const { success, tempNodeModules } = await packageManager.installTemp(packageIdentifier.raw, registry ? [`--registry="${registry}"`] : undefined);
+            const resolvedCollectionPath = require.resolve((0, path_1.join)(collectionName, 'package.json'), {
+                paths: [tempNodeModules],
+            });
+            if (!success) {
+                return 1;
+            }
+            collectionName = (0, path_1.dirname)(resolvedCollectionPath);
+        }
+        else {
+            const success = await packageManager.install(packageIdentifier.raw, savePackage, registry ? [`--registry="${registry}"`] : undefined);
+            if (!success) {
+                return 1;
+            }
+        }
+        return this.executeSchematic({ ...options, collection: collectionName });
+    }
+    async isProjectVersionValid(packageIdentifier) {
+        if (!packageIdentifier.name) {
+            return false;
+        }
+        let validVersion = false;
+        const installedVersion = await this.findProjectVersion(packageIdentifier.name);
+        if (installedVersion) {
+            if (packageIdentifier.type === 'range' && packageIdentifier.fetchSpec) {
+                validVersion = (0, semver_1.satisfies)(installedVersion, packageIdentifier.fetchSpec);
+            }
+            else if (packageIdentifier.type === 'version') {
+                const v1 = (0, semver_1.valid)(packageIdentifier.fetchSpec);
+                const v2 = (0, semver_1.valid)(installedVersion);
+                validVersion = v1 !== null && v1 === v2;
+            }
+            else if (!packageIdentifier.rawSpec) {
+                validVersion = true;
+            }
+        }
+        return validVersion;
+    }
+    async reportAnalytics(options, paths) {
+        const collection = await this.getCollectionName();
+        const dimensions = [];
+        // Add the collection if it's safe listed.
+        if (collection && (0, analytics_1.isPackageNameSafeForAnalytics)(collection)) {
+            dimensions[core_1.analytics.NgCliAnalyticsDimensions.NgAddCollection] = collection;
+        }
+        return super.reportAnalytics(options, paths, dimensions);
+    }
+    async getCollectionName() {
+        const [, collectionName] = this.context.args.positional;
+        return collectionName;
+    }
+    isPackageInstalled(name) {
+        try {
+            require.resolve((0, path_1.join)(name, 'package.json'), { paths: [this.context.root] });
+            return true;
+        }
+        catch (e) {
+            if (e.code !== 'MODULE_NOT_FOUND') {
+                throw e;
+            }
+        }
+        return false;
+    }
+    async executeSchematic(options) {
+        try {
+            const { verbose, skipConfirmation, interactive, force, dryRun, registry, defaults, collection: collectionName, ...schematicOptions } = options;
+            return await this.runSchematic({
+                schematicOptions,
+                schematicName: this.schematicName,
+                collectionName,
+                executionOptions: {
+                    interactive,
+                    force,
+                    dryRun,
+                    defaults,
+                    packageRegistry: registry,
+                },
+            });
+        }
+        catch (e) {
+            if (e instanceof tools_1.NodePackageDoesNotSupportSchematics) {
+                this.context.logger.error(core_1.tags.oneLine `
+          The package that you are trying to add does not support schematics. You can try using
+          a different version of the package or contact the package author to add ng-add support.
+        `);
+                return 1;
+            }
+            throw e;
+        }
+    }
+    async findProjectVersion(name) {
+        var _a, _b;
+        const { logger, root } = this.context;
+        let installedPackage;
+        try {
+            installedPackage = require.resolve((0, path_1.join)(name, 'package.json'), {
+                paths: [root],
+            });
+        }
+        catch { }
+        if (installedPackage) {
+            try {
+                const installed = await (0, package_metadata_1.fetchPackageManifest)((0, path_1.dirname)(installedPackage), logger);
+                return installed.version;
+            }
+            catch { }
+        }
+        let projectManifest;
+        try {
+            projectManifest = await (0, package_metadata_1.fetchPackageManifest)(root, logger);
+        }
+        catch { }
+        if (projectManifest) {
+            const version = ((_a = projectManifest.dependencies) === null || _a === void 0 ? void 0 : _a[name]) || ((_b = projectManifest.devDependencies) === null || _b === void 0 ? void 0 : _b[name]);
+            if (version) {
+                return version;
+            }
+        }
+        return null;
     }
-    run(options) {
-        const command = new add_impl_1.AddCommandModule(this.context, 'add');
-        return command.validateAndRun(options);
+    async hasMismatchedPeer(manifest) {
+        for (const peer in manifest.peerDependencies) {
+            let peerIdentifier;
+            try {
+                peerIdentifier = npm_package_arg_1.default.resolve(peer, manifest.peerDependencies[peer]);
+            }
+            catch {
+                this.context.logger.warn(`Invalid peer dependency ${peer} found in package.`);
+                continue;
+            }
+            if (peerIdentifier.type === 'version' || peerIdentifier.type === 'range') {
+                try {
+                    const version = await this.findProjectVersion(peer);
+                    if (!version) {
+                        continue;
+                    }
+                    const options = { includePrerelease: true };
+                    if (!(0, semver_1.intersects)(version, peerIdentifier.rawSpec, options) &&
+                        !(0, semver_1.satisfies)(version, peerIdentifier.rawSpec, options)) {
+                        return true;
+                    }
+                }
+                catch {
+                    // Not found or invalid so ignore
+                    continue;
+                }
+            }
+            else {
+                // type === 'tag' | 'file' | 'directory' | 'remote' | 'git'
+                // Cannot accurately compare these as the tag/location may have changed since install
+            }
+        }
+        return false;
     }
 }
 exports.AddCommandModule = AddCommandModule;

package/src/commands/add/long-description.md

@@ -1,10 +1,7 @@
 Adds the npm package for a published library to your workspace, and configures
-the project in the current working directory (or the default project if you are
-not in a project directory) to use that library, as specified by the library's schematic.
+the project in the current working directory to use that library, as specified by the library's schematic.
 For example, adding `@angular/pwa` configures your project for PWA support:
 
 ```bash
 ng add @angular/pwa
 ```
-
-The default project is the value of `defaultProject` in `angular.json`.

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

@@ -6,16 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { Argv } from 'yargs';
-import { CommandModule, Options } from '../../command-builder/command-module';
-interface AnalyticsCommandArgs {
-    'setting-or-project': 'on' | 'off' | 'ci' | 'project' | 'prompt' | string;
-    'project-setting'?: 'on' | 'off' | 'prompt' | string;
-}
-export declare class AnalyticsCommandModule extends CommandModule<AnalyticsCommandArgs> {
+import { CommandModule, CommandModuleImplementation, Options } from '../../command-builder/command-module';
+export declare class AnalyticsCommandModule extends CommandModule implements CommandModuleImplementation {
     command: string;
     describe: string;
-    longDescriptionPath: string;
-    builder(localYargs: Argv): Argv<AnalyticsCommandArgs>;
-    run({ settingOrProject, projectSetting, }: Options<AnalyticsCommandArgs>): Promise<number | void>;
+    longDescriptionPath?: string;
+    builder(localYargs: Argv): Argv;
+    run(_options: Options<{}>): void;
 }
-export {};