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

package/src/analytics/analytics.js

@@ -0,0 +1,306 @@
+"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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = 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];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAnalyticsInfoString = exports.createAnalytics = exports.getSharedAnalytics = exports.getAnalytics = exports.promptAnalytics = exports.setAnalyticsConfig = exports.isPackageNameSafeForAnalytics = exports.analyticsPackageSafelist = exports.AnalyticsProperties = void 0;
+const core_1 = require("@angular-devkit/core");
+const debug_1 = __importDefault(require("debug"));
+const uuid_1 = require("uuid");
+const color_1 = require("../utilities/color");
+const config_1 = require("../utilities/config");
+const environment_options_1 = require("../utilities/environment-options");
+const tty_1 = require("../utilities/tty");
+const version_1 = require("../utilities/version");
+const analytics_collector_1 = require("./analytics-collector");
+/* eslint-disable no-console */
+const analyticsDebug = (0, debug_1.default)('ng:analytics'); // Generate analytics, including settings and users.
+let _defaultAngularCliPropertyCache;
+exports.AnalyticsProperties = {
+    AngularCliProd: 'UA-8594346-29',
+    AngularCliStaging: 'UA-8594346-32',
+    get AngularCliDefault() {
+        if (_defaultAngularCliPropertyCache) {
+            return _defaultAngularCliPropertyCache;
+        }
+        const v = version_1.VERSION.full;
+        // The logic is if it's a full version then we should use the prod GA property.
+        _defaultAngularCliPropertyCache =
+            /^\d+\.\d+\.\d+$/.test(v) && v !== '0.0.0'
+                ? exports.AnalyticsProperties.AngularCliProd
+                : exports.AnalyticsProperties.AngularCliStaging;
+        return _defaultAngularCliPropertyCache;
+    },
+};
+/**
+ * This is the ultimate safelist for checking if a package name is safe to report to analytics.
+ */
+exports.analyticsPackageSafelist = [
+    /^@angular\//,
+    /^@angular-devkit\//,
+    /^@ngtools\//,
+    '@schematics/angular',
+];
+function isPackageNameSafeForAnalytics(name) {
+    return exports.analyticsPackageSafelist.some((pattern) => {
+        if (typeof pattern == 'string') {
+            return pattern === name;
+        }
+        else {
+            return pattern.test(name);
+        }
+    });
+}
+exports.isPackageNameSafeForAnalytics = isPackageNameSafeForAnalytics;
+/**
+ * Set analytics settings. This does not work if the user is not inside a project.
+ * @param global Which config to use. "global" for user-level, and "local" for project-level.
+ * @param value Either a user ID, true to generate a new User ID, or false to disable analytics.
+ */
+async function setAnalyticsConfig(global, value) {
+    var _a;
+    var _b;
+    const level = global ? 'global' : 'local';
+    analyticsDebug('setting %s level analytics to: %s', level, value);
+    const workspace = await (0, config_1.getWorkspace)(level);
+    if (!workspace) {
+        throw new Error(`Could not find ${level} workspace.`);
+    }
+    const cli = ((_a = (_b = workspace.extensions)['cli']) !== null && _a !== void 0 ? _a : (_b['cli'] = {}));
+    if (!workspace || !core_1.json.isJsonObject(cli)) {
+        throw new Error(`Invalid config found at ${workspace.filePath}. CLI should be an object.`);
+    }
+    cli.analytics = value === true ? (0, uuid_1.v4)() : value;
+    await workspace.save();
+    analyticsDebug('done');
+}
+exports.setAnalyticsConfig = setAnalyticsConfig;
+/**
+ * Prompt the user for usage gathering permission.
+ * @param force Whether to ask regardless of whether or not the user is using an interactive shell.
+ * @return Whether or not the user was shown a prompt.
+ */
+async function promptAnalytics(global, force = false) {
+    analyticsDebug('prompting user');
+    const level = global ? 'global' : 'local';
+    const workspace = await (0, config_1.getWorkspace)(level);
+    if (!workspace) {
+        throw new Error(`Could not find a ${level} workspace. Are you in a project?`);
+    }
+    if (force || (0, tty_1.isTTY)()) {
+        const { prompt } = await Promise.resolve().then(() => __importStar(require('inquirer')));
+        const answers = await prompt([
+            {
+                type: 'confirm',
+                name: 'analytics',
+                message: core_1.tags.stripIndents `
+          Would you like to share anonymous usage data about this project with the Angular Team at
+          Google under Google’s Privacy Policy at https://policies.google.com/privacy. For more
+          details and how to change this setting, see https://angular.io/analytics.
+
+        `,
+                default: false,
+            },
+        ]);
+        await setAnalyticsConfig(global, answers.analytics);
+        if (answers.analytics) {
+            console.log('');
+            console.log(core_1.tags.stripIndent `
+        Thank you for sharing anonymous usage data. Should you change your mind, the following
+        command will disable this feature entirely:
+
+            ${color_1.colors.yellow(`ng analytics disable${global ? ' --global' : ''}`)}
+      `);
+            console.log('');
+            // Send back a ping with the user `optin`.
+            const ua = new analytics_collector_1.AnalyticsCollector(exports.AnalyticsProperties.AngularCliDefault, 'optin');
+            ua.pageview('/telemetry/project/optin');
+            await ua.flush();
+        }
+        else {
+            // Send back a ping with the user `optout`. This is the only thing we send.
+            const ua = new analytics_collector_1.AnalyticsCollector(exports.AnalyticsProperties.AngularCliDefault, 'optout');
+            ua.pageview('/telemetry/project/optout');
+            await ua.flush();
+        }
+        process.stderr.write(await getAnalyticsInfoString());
+        return true;
+    }
+    return false;
+}
+exports.promptAnalytics = promptAnalytics;
+/**
+ * Get the analytics object for the user.
+ *
+ * @returns
+ * - `AnalyticsCollector` when enabled.
+ * - `analytics.NoopAnalytics` when disabled.
+ * - `undefined` when not configured.
+ */
+async function getAnalytics(level) {
+    var _a;
+    analyticsDebug('getAnalytics');
+    if (environment_options_1.analyticsDisabled) {
+        analyticsDebug('NG_CLI_ANALYTICS is false');
+        return new core_1.analytics.NoopAnalytics();
+    }
+    try {
+        const workspace = await (0, config_1.getWorkspace)(level);
+        const analyticsConfig = (_a = workspace === null || workspace === void 0 ? void 0 : workspace.getCli()) === null || _a === void 0 ? void 0 : _a['analytics'];
+        analyticsDebug('Workspace Analytics config found: %j', analyticsConfig);
+        if (analyticsConfig === false) {
+            return new core_1.analytics.NoopAnalytics();
+        }
+        else if (analyticsConfig === undefined || analyticsConfig === null) {
+            return undefined;
+        }
+        else {
+            let uid = undefined;
+            if (typeof analyticsConfig == 'string') {
+                uid = analyticsConfig;
+            }
+            else if (typeof analyticsConfig == 'object' && typeof analyticsConfig['uid'] == 'string') {
+                uid = analyticsConfig['uid'];
+            }
+            analyticsDebug('client id: %j', uid);
+            if (uid == undefined) {
+                return undefined;
+            }
+            return new analytics_collector_1.AnalyticsCollector(exports.AnalyticsProperties.AngularCliDefault, uid);
+        }
+    }
+    catch (err) {
+        analyticsDebug('Error happened during reading of analytics config: %s', err.message);
+        return undefined;
+    }
+}
+exports.getAnalytics = getAnalytics;
+/**
+ * Return the usage analytics sharing setting, which is either a property string (GA-XXXXXXX-XX),
+ * or undefined if no sharing.
+ */
+async function getSharedAnalytics() {
+    var _a;
+    analyticsDebug('getSharedAnalytics');
+    if (environment_options_1.analyticsShareDisabled) {
+        analyticsDebug('NG_CLI_ANALYTICS is false');
+        return undefined;
+    }
+    // If anything happens we just keep the NOOP analytics.
+    try {
+        const globalWorkspace = await (0, config_1.getWorkspace)('global');
+        const analyticsConfig = (_a = globalWorkspace === null || globalWorkspace === void 0 ? void 0 : globalWorkspace.getCli()) === null || _a === void 0 ? void 0 : _a['analyticsSharing'];
+        if (!analyticsConfig || !analyticsConfig.tracking || !analyticsConfig.uuid) {
+            return undefined;
+        }
+        else {
+            analyticsDebug('Analytics sharing info: %j', analyticsConfig);
+            return new analytics_collector_1.AnalyticsCollector(analyticsConfig.tracking, analyticsConfig.uuid);
+        }
+    }
+    catch (err) {
+        analyticsDebug('Error happened during reading of analytics sharing config: %s', err.message);
+        return undefined;
+    }
+}
+exports.getSharedAnalytics = getSharedAnalytics;
+async function createAnalytics(workspace, skipPrompt = false) {
+    // Global config takes precedence over local config only for the disabled check.
+    // IE:
+    // global: disabled & local: enabled = disabled
+    // global: id: 123 & local: id: 456 = 456
+    var _a;
+    // check global
+    const globalConfig = await getAnalytics('global');
+    if (globalConfig instanceof core_1.analytics.NoopAnalytics) {
+        return globalConfig;
+    }
+    let config = globalConfig;
+    // Not disabled globally, check locally or not set globally and command is run outside of workspace example: `ng new`
+    if (workspace || globalConfig === undefined) {
+        const level = workspace ? 'local' : 'global';
+        let localOrGlobalConfig = await getAnalytics(level);
+        if (localOrGlobalConfig === undefined) {
+            if (!skipPrompt) {
+                // config is unset, prompt user.
+                // TODO: This should honor the `no-interactive` option.
+                // It is currently not an `ng` option but rather only an option for specific commands.
+                // The concept of `ng`-wide options are needed to cleanly handle this.
+                await promptAnalytics(!workspace /** global */);
+                localOrGlobalConfig = await getAnalytics(level);
+            }
+        }
+        if (localOrGlobalConfig instanceof core_1.analytics.NoopAnalytics) {
+            return localOrGlobalConfig;
+        }
+        else if (localOrGlobalConfig) {
+            // Favor local settings over global when defined.
+            config = localOrGlobalConfig;
+        }
+    }
+    // Get shared analytics
+    // TODO: evalute if this should be completly removed.
+    const maybeSharedAnalytics = await getSharedAnalytics();
+    if (config && maybeSharedAnalytics) {
+        return new core_1.analytics.MultiAnalytics([config, maybeSharedAnalytics]);
+    }
+    return (_a = config !== null && config !== void 0 ? config : maybeSharedAnalytics) !== null && _a !== void 0 ? _a : new core_1.analytics.NoopAnalytics();
+}
+exports.createAnalytics = createAnalytics;
+function analyticsConfigValueToHumanFormat(value) {
+    if (value === false) {
+        return 'disabled';
+    }
+    else if (typeof value === 'string' || value === true) {
+        return 'enabled';
+    }
+    else {
+        return 'not set';
+    }
+}
+async function getAnalyticsInfoString() {
+    var _a, _b;
+    const globalWorkspace = await (0, config_1.getWorkspace)('global');
+    const localWorkspace = await (0, config_1.getWorkspace)('local');
+    const globalSetting = (_a = globalWorkspace === null || globalWorkspace === void 0 ? void 0 : globalWorkspace.getCli()) === null || _a === void 0 ? void 0 : _a['analytics'];
+    const localSetting = (_b = localWorkspace === null || localWorkspace === void 0 ? void 0 : localWorkspace.getCli()) === null || _b === void 0 ? void 0 : _b['analytics'];
+    const analyticsInstance = await createAnalytics(!!localWorkspace /** workspace */, true /** skipPrompt */);
+    return (core_1.tags.stripIndents `
+    Global setting: ${analyticsConfigValueToHumanFormat(globalSetting)}
+    Local setting: ${localWorkspace
+        ? analyticsConfigValueToHumanFormat(localSetting)
+        : 'No local workspace configuration file.'}
+    Effective status: ${analyticsInstance instanceof core_1.analytics.NoopAnalytics ? 'disabled' : 'enabled'}
+  ` + '\n');
+}
+exports.getAnalyticsInfoString = getAnalyticsInfoString;

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

@@ -0,0 +1,30 @@
+/**
+ * @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 { Architect, Target } from '@angular-devkit/architect';
+import { WorkspaceNodeModulesArchitectHost } from '@angular-devkit/architect/node';
+import { CommandModule, CommandModuleImplementation, CommandScope, OtherOptions } from './command-module';
+import { Option } from './utilities/json-schema';
+export interface MissingTargetChoice {
+    name: string;
+    value: string;
+}
+export declare abstract class ArchitectBaseCommandModule<T> extends CommandModule<T> implements CommandModuleImplementation<T> {
+    static scope: CommandScope;
+    protected shouldReportAnalytics: boolean;
+    protected readonly missingTargetChoices: MissingTargetChoice[] | undefined;
+    protected runSingleTarget(target: Target, options: OtherOptions): Promise<number>;
+    private _architectHost;
+    protected getArchitectHost(): WorkspaceNodeModulesArchitectHost;
+    private _architect;
+    protected getArchitect(): Architect;
+    protected getArchitectTargetOptions(target: Target): Promise<Option[]>;
+    private warnOnMissingNodeModules;
+    protected getArchitectTarget(): string;
+    protected onMissingTarget(defaultMessage: string): Promise<1>;
+    private getMissingTargetPackageToInstall;
+}

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

@@ -0,0 +1,165 @@
+"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.ArchitectBaseCommandModule = void 0;
+const architect_1 = require("@angular-devkit/architect");
+const node_1 = require("@angular-devkit/architect/node");
+const core_1 = require("@angular-devkit/core");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const analytics_1 = require("../analytics/analytics");
+const prompt_1 = require("../utilities/prompt");
+const tty_1 = require("../utilities/tty");
+const command_module_1 = require("./command-module");
+const json_schema_1 = require("./utilities/json-schema");
+class ArchitectBaseCommandModule extends command_module_1.CommandModule {
+    constructor() {
+        super(...arguments);
+        this.shouldReportAnalytics = false;
+    }
+    async runSingleTarget(target, options) {
+        const architectHost = await this.getArchitectHost();
+        let builderName;
+        try {
+            builderName = await architectHost.getBuilderNameForTarget(target);
+        }
+        catch (e) {
+            return this.onMissingTarget(e.message);
+        }
+        await this.reportAnalytics({
+            ...(await architectHost.getOptionsForTarget(target)),
+            ...options,
+        });
+        const { logger } = this.context;
+        const run = await this.getArchitect().scheduleTarget(target, options, {
+            logger,
+            analytics: (0, analytics_1.isPackageNameSafeForAnalytics)(builderName) ? await this.getAnalytics() : undefined,
+        });
+        const { error, success } = await run.output.toPromise();
+        await run.stop();
+        if (error) {
+            logger.error(error);
+        }
+        return success ? 0 : 1;
+    }
+    getArchitectHost() {
+        if (this._architectHost) {
+            return this._architectHost;
+        }
+        const workspace = this.getWorkspaceOrThrow();
+        return (this._architectHost = new node_1.WorkspaceNodeModulesArchitectHost(workspace, workspace.basePath));
+    }
+    getArchitect() {
+        if (this._architect) {
+            return this._architect;
+        }
+        const registry = new core_1.json.schema.CoreSchemaRegistry();
+        registry.addPostTransform(core_1.json.schema.transforms.addUndefinedDefaults);
+        registry.useXDeprecatedProvider((msg) => this.context.logger.warn(msg));
+        const architectHost = this.getArchitectHost();
+        return (this._architect = new architect_1.Architect(architectHost, registry));
+    }
+    async getArchitectTargetOptions(target) {
+        const architectHost = this.getArchitectHost();
+        let builderConf;
+        try {
+            builderConf = await architectHost.getBuilderNameForTarget(target);
+        }
+        catch {
+            return [];
+        }
+        let builderDesc;
+        try {
+            builderDesc = await architectHost.resolveBuilder(builderConf);
+        }
+        catch (e) {
+            if (e.code === 'MODULE_NOT_FOUND') {
+                this.warnOnMissingNodeModules();
+                throw new command_module_1.CommandModuleError(`Could not find the '${builderConf}' builder's node package.`);
+            }
+            throw e;
+        }
+        return (0, json_schema_1.parseJsonSchemaToOptions)(new core_1.json.schema.CoreSchemaRegistry(), builderDesc.optionSchema, true);
+    }
+    warnOnMissingNodeModules() {
+        var _a;
+        const basePath = (_a = this.context.workspace) === null || _a === void 0 ? void 0 : _a.basePath;
+        if (!basePath) {
+            return;
+        }
+        // Check for a `node_modules` directory (npm, yarn non-PnP, etc.)
+        if ((0, fs_1.existsSync)((0, path_1.resolve)(basePath, 'node_modules'))) {
+            return;
+        }
+        // Check for yarn PnP files
+        if ((0, fs_1.existsSync)((0, path_1.resolve)(basePath, '.pnp.js')) ||
+            (0, fs_1.existsSync)((0, path_1.resolve)(basePath, '.pnp.cjs')) ||
+            (0, fs_1.existsSync)((0, path_1.resolve)(basePath, '.pnp.mjs'))) {
+            return;
+        }
+        this.context.logger.warn(`Node packages may not be installed. Try installing with '${this.context.packageManager} install'.`);
+    }
+    getArchitectTarget() {
+        return this.commandName;
+    }
+    async onMissingTarget(defaultMessage) {
+        const { logger } = this.context;
+        const choices = this.missingTargetChoices;
+        if (!(choices === null || choices === void 0 ? void 0 : choices.length)) {
+            logger.error(defaultMessage);
+            return 1;
+        }
+        const missingTargetMessage = `Cannot find "${this.getArchitectTarget()}" target for the specified project.\n` +
+            `You can add a package that implements these capabilities.\n\n` +
+            `For example:\n` +
+            choices.map(({ name, value }) => `  ${name}: ng add ${value}`).join('\n') +
+            '\n';
+        if ((0, tty_1.isTTY)()) {
+            // Use prompts to ask the user if they'd like to install a package.
+            logger.warn(missingTargetMessage);
+            const packageToInstall = await this.getMissingTargetPackageToInstall(choices);
+            if (packageToInstall) {
+                // Example run: `ng add @angular-eslint/schematics`.
+                const binPath = (0, path_1.resolve)(__dirname, '../../bin/ng.js');
+                const { error } = (0, child_process_1.spawnSync)(process.execPath, [binPath, 'add', packageToInstall], {
+                    stdio: 'inherit',
+                });
+                if (error) {
+                    throw error;
+                }
+            }
+        }
+        else {
+            // Non TTY display error message.
+            logger.error(missingTargetMessage);
+        }
+        return 1;
+    }
+    async getMissingTargetPackageToInstall(choices) {
+        if (choices.length === 1) {
+            // Single choice
+            const { name, value } = choices[0];
+            if (await (0, prompt_1.askConfirmation)(`Would you like to add ${name} now?`, true, false)) {
+                return value;
+            }
+            return null;
+        }
+        // Multiple choice
+        return (0, prompt_1.askQuestion)(`Would you like to add a package with "${this.getArchitectTarget()}" capabilities now?`, [
+            {
+                name: 'No',
+                value: null,
+            },
+            ...choices,
+        ], 0, null);
+    }
+}
+exports.ArchitectBaseCommandModule = ArchitectBaseCommandModule;
+ArchitectBaseCommandModule.scope = command_module_1.CommandScope.In;

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

@@ -0,0 +1,25 @@
+/**
+ * @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 { ArchitectBaseCommandModule } from './architect-base-command-module';
+import { CommandModuleImplementation, Options, OtherOptions } from './command-module';
+export interface ArchitectCommandArgs {
+    configuration?: string;
+    project?: string;
+}
+export declare abstract class ArchitectCommandModule extends ArchitectBaseCommandModule<ArchitectCommandArgs> implements CommandModuleImplementation<ArchitectCommandArgs> {
+    abstract readonly multiTarget: boolean;
+    builder(argv: Argv): Promise<Argv<ArchitectCommandArgs>>;
+    run(options: Options<ArchitectCommandArgs> & OtherOptions): Promise<number | void>;
+    private getArchitectProject;
+    private getProjectNamesByTarget;
+    /** @returns a sorted list of project names to be used for auto completion. */
+    private getProjectChoices;
+    /** @returns a sorted list of configuration names to be used for auto completion. */
+    private getConfigurationChoices;
+}

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

@@ -0,0 +1,134 @@
+"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
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArchitectCommandModule = void 0;
+const config_1 = require("../utilities/config");
+const memoize_1 = require("../utilities/memoize");
+const architect_base_command_module_1 = require("./architect-base-command-module");
+class ArchitectCommandModule extends architect_base_command_module_1.ArchitectBaseCommandModule {
+    async builder(argv) {
+        const project = this.getArchitectProject();
+        const { jsonHelp, getYargsCompletions, help } = this.context.args.options;
+        const localYargs = argv
+            .positional('project', {
+            describe: 'The name of the project to build. Can be an application or a library.',
+            type: 'string',
+            // Hide choices from JSON help so that we don't display them in AIO.
+            choices: jsonHelp ? undefined : this.getProjectChoices(),
+        })
+            .option('configuration', {
+            describe: `One or more named builder configurations as a comma-separated ` +
+                `list as specified in the "configurations" section in angular.json.\n` +
+                `The builder uses the named configurations to run the given target.\n` +
+                `For more information, see https://angular.io/guide/workspace-config#alternate-build-configurations.`,
+            alias: 'c',
+            type: 'string',
+            // Show only in when using --help and auto completion because otherwise comma seperated configuration values will be invalid.
+            // Also, hide choices from JSON help so that we don't display them in AIO.
+            choices: (getYargsCompletions || help) && !jsonHelp && project
+                ? this.getConfigurationChoices(project)
+                : undefined,
+        })
+            .strict();
+        if (!project) {
+            return localYargs;
+        }
+        const target = this.getArchitectTarget();
+        const schemaOptions = await this.getArchitectTargetOptions({
+            project,
+            target,
+        });
+        return this.addSchemaOptionsToCommand(localYargs, schemaOptions);
+    }
+    async run(options) {
+        const target = this.getArchitectTarget();
+        const { configuration = '', project, ...architectOptions } = options;
+        if (!project) {
+            // This runs each target sequentially.
+            // Running them in parallel would jumble the log messages.
+            let result = 0;
+            const projectNames = this.getProjectNamesByTarget(target);
+            if (!projectNames) {
+                return this.onMissingTarget('Cannot determine project or target for command.');
+            }
+            for (const project of projectNames) {
+                result |= await this.runSingleTarget({ configuration, target, project }, architectOptions);
+            }
+            return result;
+        }
+        else {
+            return await this.runSingleTarget({ configuration, target, project }, architectOptions);
+        }
+    }
+    getArchitectProject() {
+        const workspace = this.context.workspace;
+        if (!workspace) {
+            return undefined;
+        }
+        const [, projectName] = this.context.args.positional;
+        if (projectName) {
+            return workspace.projects.has(projectName) ? projectName : undefined;
+        }
+        const target = this.getArchitectTarget();
+        const projectFromTarget = this.getProjectNamesByTarget(target);
+        return (projectFromTarget === null || projectFromTarget === void 0 ? void 0 : projectFromTarget.length) ? projectFromTarget[0] : undefined;
+    }
+    getProjectNamesByTarget(target) {
+        const workspace = this.getWorkspaceOrThrow();
+        const allProjectsForTargetName = [];
+        for (const [name, project] of workspace.projects) {
+            if (project.targets.has(target)) {
+                allProjectsForTargetName.push(name);
+            }
+        }
+        if (allProjectsForTargetName.length === 0) {
+            return undefined;
+        }
+        if (this.multiTarget) {
+            // For multi target commands, we always list all projects that have the target.
+            return allProjectsForTargetName;
+        }
+        else {
+            if (allProjectsForTargetName.length === 1) {
+                return allProjectsForTargetName;
+            }
+            const maybeProject = (0, config_1.getProjectByCwd)(workspace);
+            if (maybeProject && allProjectsForTargetName.includes(maybeProject)) {
+                return [maybeProject];
+            }
+        }
+        return undefined;
+    }
+    /** @returns a sorted list of project names to be used for auto completion. */
+    getProjectChoices() {
+        const { workspace } = this.context;
+        return workspace ? [...workspace.projects.keys()].sort() : undefined;
+    }
+    /** @returns a sorted list of configuration names to be used for auto completion. */
+    getConfigurationChoices(project) {
+        var _a, _b;
+        const projectDefinition = (_a = this.context.workspace) === null || _a === void 0 ? void 0 : _a.projects.get(project);
+        if (!projectDefinition) {
+            return undefined;
+        }
+        const target = this.getArchitectTarget();
+        const configurations = (_b = projectDefinition.targets.get(target)) === null || _b === void 0 ? void 0 : _b.configurations;
+        return configurations ? Object.keys(configurations).sort() : undefined;
+    }
+}
+__decorate([
+    memoize_1.memoize
+], ArchitectCommandModule.prototype, "getProjectNamesByTarget", null);
+exports.ArchitectCommandModule = ArchitectCommandModule;