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

package/models/schematic-command.js

@@ -32,14 +32,13 @@ const schematics_1 = require("@angular-devkit/schematics");
 const tools_1 = require("@angular-devkit/schematics/tools");
 const inquirer = __importStar(require("inquirer"));
 const systemPath = __importStar(require("path"));
-const color_1 = require("../utilities/color");
-const config_1 = require("../utilities/config");
-const json_schema_1 = require("../utilities/json-schema");
-const package_manager_1 = require("../utilities/package-manager");
-const tty_1 = require("../utilities/tty");
-const analytics_1 = require("./analytics");
+const analytics_1 = require("../src/analytics/analytics");
+const json_schema_1 = require("../src/command-builder/utilities/json-schema");
+const color_1 = require("../src/utilities/color");
+const config_1 = require("../src/utilities/config");
+const package_manager_1 = require("../src/utilities/package-manager");
+const tty_1 = require("../src/utilities/tty");
 const command_1 = require("./command");
-const parser_1 = require("./parser");
 const schematic_engine_host_1 = require("./schematic-engine-host");
 class UnknownCollectionError extends Error {
     constructor(collectionName) {
@@ -48,93 +47,29 @@ class UnknownCollectionError extends Error {
 }
 exports.UnknownCollectionError = UnknownCollectionError;
 class SchematicCommand extends command_1.Command {
-    constructor(context, description, logger) {
-        super(context, description, logger);
+    constructor(context, commandName) {
+        super(context, commandName);
         this.allowPrivateSchematics = false;
         this.useReportAnalytics = false;
         this.defaultCollectionName = '@schematics/angular';
         this.collectionName = this.defaultCollectionName;
     }
     async initialize(options) {
-        await this.createWorkflow(options);
+        this._workflow = await this.createWorkflow(options);
         if (this.schematicName) {
             // Set the options.
             const collection = this.getCollection(this.collectionName);
             const schematic = this.getSchematic(collection, this.schematicName, true);
             const options = await (0, json_schema_1.parseJsonSchemaToOptions)(this._workflow.registry, schematic.description.schemaJson || {});
-            this.description.description = schematic.description.description;
-            this.description.options.push(...options.filter((x) => !x.hidden));
+            this.commandOptions.push(...options);
             // Remove any user analytics from schematics that are NOT part of our safelist.
-            for (const o of this.description.options) {
+            for (const o of this.commandOptions) {
                 if (o.userAnalytics && !(0, analytics_1.isPackageNameSafeForAnalytics)(this.collectionName)) {
                     o.userAnalytics = undefined;
                 }
             }
         }
     }
-    async printHelp() {
-        await super.printHelp();
-        this.logger.info('');
-        const subCommandOption = this.description.options.filter((x) => x.subcommands)[0];
-        if (!subCommandOption || !subCommandOption.subcommands) {
-            return 0;
-        }
-        const schematicNames = Object.keys(subCommandOption.subcommands);
-        if (schematicNames.length > 1) {
-            this.logger.info('Available Schematics:');
-            const namesPerCollection = {};
-            schematicNames.forEach((name) => {
-                let [collectionName, schematicName] = name.split(/:/, 2);
-                if (!schematicName) {
-                    schematicName = collectionName;
-                    collectionName = this.collectionName;
-                }
-                if (!namesPerCollection[collectionName]) {
-                    namesPerCollection[collectionName] = [];
-                }
-                namesPerCollection[collectionName].push(schematicName);
-            });
-            const defaultCollection = await this.getDefaultSchematicCollection();
-            Object.keys(namesPerCollection).forEach((collectionName) => {
-                const isDefault = defaultCollection == collectionName;
-                this.logger.info(`  Collection "${collectionName}"${isDefault ? ' (default)' : ''}:`);
-                namesPerCollection[collectionName].forEach((schematicName) => {
-                    this.logger.info(`    ${schematicName}`);
-                });
-            });
-        }
-        return 0;
-    }
-    async printHelpUsage() {
-        const subCommandOption = this.description.options.filter((x) => x.subcommands)[0];
-        if (!subCommandOption || !subCommandOption.subcommands) {
-            return;
-        }
-        const schematicNames = Object.keys(subCommandOption.subcommands);
-        if (schematicNames.length == 1) {
-            this.logger.info(this.description.description);
-            const opts = this.description.options.filter((x) => x.positional === undefined);
-            const [collectionName, schematicName] = schematicNames[0].split(/:/)[0];
-            // Display <collectionName:schematicName> if this is not the default collectionName,
-            // otherwise just show the schematicName.
-            const displayName = collectionName == (await this.getDefaultSchematicCollection())
-                ? schematicName
-                : schematicNames[0];
-            const schematicOptions = subCommandOption.subcommands[schematicNames[0]].options;
-            const schematicArgs = schematicOptions.filter((x) => x.positional !== undefined);
-            const argDisplay = schematicArgs.length > 0
-                ? ' ' + schematicArgs.map((a) => `<${core_1.strings.dasherize(a.name)}>`).join(' ')
-                : '';
-            this.logger.info(core_1.tags.oneLine `
-        usage: ng ${this.description.name} ${displayName}${argDisplay}
-        ${opts.length > 0 ? `[options]` : ``}
-      `);
-            this.logger.info('');
-        }
-        else {
-            await super.printHelpUsage();
-        }
-    }
     getEngine() {
         return this._workflow.engine;
     }
@@ -149,18 +84,6 @@ class SchematicCommand extends command_1.Command {
     getSchematic(collection, schematicName, allowPrivate) {
         return collection.createSchematic(schematicName, allowPrivate);
     }
-    setPathOptions(options, workingDir) {
-        if (workingDir === '') {
-            return {};
-        }
-        return options
-            .filter((o) => o.format === 'path')
-            .map((o) => o.name)
-            .reduce((acc, curr) => {
-            acc[curr] = workingDir;
-            return acc;
-        }, {});
-    }
     /*
      * Runtime hook to allow specifying customized workflow
      */
@@ -174,7 +97,7 @@ class SchematicCommand extends command_1.Command {
             force,
             dryRun,
             packageManager: await (0, package_manager_1.getPackageManager)(root),
-            packageRegistry: options.packageRegistry,
+            packageRegistry: options.registry,
             // A schema registry is required to allow customizing addUndefinedDefaults
             registry: new core_1.schema.CoreSchemaRegistry(schematics_1.formats.standardFormats),
             resolvePaths: this.workspace
@@ -229,7 +152,8 @@ class SchematicCommand extends command_1.Command {
         workflow.engineHost.registerOptionsTransform(async (_, options) => {
             if (shouldReportAnalytics) {
                 shouldReportAnalytics = false;
-                await this.reportAnalytics([this.description.name], options);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                await this.reportAnalytics([this.commandName], options);
             }
             return options;
         });
@@ -325,43 +249,18 @@ class SchematicCommand extends command_1.Command {
         return this.defaultCollectionName;
     }
     async runSchematic(options) {
-        const { schematicOptions, debug, dryRun } = options;
+        const { schematicOptions: input = {}, debug, dryRun } = options;
         let { collectionName, schematicName } = options;
         let nothingDone = true;
         let loggingQueue = [];
         let error = false;
         const workflow = this._workflow;
-        const workingDir = (0, core_1.normalize)(systemPath.relative(this.context.root, process.cwd()));
         // Get the option object from the schematic schema.
         const schematic = this.getSchematic(this.getCollection(collectionName), schematicName, this.allowPrivateSchematics);
         // Update the schematic and collection name in case they're not the same as the ones we
         // received in our options, e.g. after alias resolution or extension.
         collectionName = schematic.collection.description.name;
         schematicName = schematic.description.name;
-        // Set the options of format "path".
-        let o = null;
-        let args;
-        if (!schematic.description.schemaJson) {
-            args = await this.parseFreeFormArguments(schematicOptions || []);
-        }
-        else {
-            o = await (0, json_schema_1.parseJsonSchemaToOptions)(workflow.registry, schematic.description.schemaJson);
-            args = await this.parseArguments(schematicOptions || [], o);
-        }
-        const allowAdditionalProperties = typeof schematic.description.schemaJson === 'object' &&
-            schematic.description.schemaJson.additionalProperties;
-        if (args['--'] && !allowAdditionalProperties) {
-            args['--'].forEach((additional) => {
-                this.logger.fatal(`Unknown option: '${additional.split(/=/)[0]}'`);
-            });
-            return 1;
-        }
-        const pathOptions = o ? this.setPathOptions(o, workingDir) : {};
-        const input = {
-            ...pathOptions,
-            ...args,
-            ...options.additionalOptions,
-        };
         workflow.reporter.subscribe((event) => {
             nothingDone = false;
             // Strip leading slash to prevent confusion.
@@ -386,7 +285,7 @@ class SchematicCommand extends command_1.Command {
                     loggingQueue.push(`${color_1.colors.yellow('DELETE')} ${eventPath}`);
                     break;
                 case 'rename':
-                    const eventToPath = event.to.startsWith('/') ? event.to.substr(1) : event.to;
+                    const eventToPath = event.to.startsWith('/') ? event.to.substring(1) : event.to;
                     loggingQueue.push(`${color_1.colors.blue('RENAME')} ${eventPath} => ${eventToPath}`);
                     break;
             }
@@ -446,12 +345,6 @@ class SchematicCommand extends command_1.Command {
             });
         });
     }
-    async parseFreeFormArguments(schematicOptions) {
-        return (0, parser_1.parseFreeFormArguments)(schematicOptions);
-    }
-    async parseArguments(schematicOptions, options) {
-        return (0, parser_1.parseArguments)(schematicOptions, options, this.logger);
-    }
 }
 exports.SchematicCommand = SchematicCommand;
 function getProjectsByPath(workspace, path, root) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/cli",
-  "version": "14.0.0-next.4",
+  "version": "14.0.0-next.5",
   "description": "CLI tool for Angular",
   "main": "lib/cli/index.js",
   "bin": {
@@ -28,15 +28,15 @@
   },
   "homepage": "https://github.com/angular/angular-cli",
   "dependencies": {
-    "@angular-devkit/architect": "0.1400.0-next.4",
-    "@angular-devkit/core": "14.0.0-next.4",
-    "@angular-devkit/schematics": "14.0.0-next.4",
-    "@schematics/angular": "14.0.0-next.4",
+    "@angular-devkit/architect": "0.1400.0-next.5",
+    "@angular-devkit/core": "14.0.0-next.5",
+    "@angular-devkit/schematics": "14.0.0-next.5",
+    "@schematics/angular": "14.0.0-next.5",
     "@yarnpkg/lockfile": "1.1.0",
     "ansi-colors": "4.1.1",
     "debug": "4.3.3",
     "ini": "2.0.0",
-    "inquirer": "8.2.0",
+    "inquirer": "8.2.1",
     "jsonc-parser": "3.0.0",
     "npm-package-arg": "9.0.0",
     "npm-pick-manifest": "7.0.0",
@@ -46,21 +46,22 @@
     "resolve": "1.22.0",
     "semver": "7.3.5",
     "symbol-observable": "4.0.0",
-    "uuid": "8.3.2"
+    "uuid": "8.3.2",
+    "yargs": "17.3.1"
   },
   "ng-update": {
     "migrations": "@schematics/angular/migrations/migration-collection.json",
     "packageGroup": {
-      "@angular/cli": "14.0.0-next.4",
-      "@angular-devkit/architect": "0.1400.0-next.4",
-      "@angular-devkit/build-angular": "14.0.0-next.4",
-      "@angular-devkit/build-webpack": "0.1400.0-next.4",
-      "@angular-devkit/core": "14.0.0-next.4",
-      "@angular-devkit/schematics": "14.0.0-next.4"
+      "@angular/cli": "14.0.0-next.5",
+      "@angular-devkit/architect": "0.1400.0-next.5",
+      "@angular-devkit/build-angular": "14.0.0-next.5",
+      "@angular-devkit/build-webpack": "0.1400.0-next.5",
+      "@angular-devkit/core": "14.0.0-next.5",
+      "@angular-devkit/schematics": "14.0.0-next.5"
     }
   },
   "engines": {
-    "node": "^12.20.0 || ^14.15.0 || >=16.10.0",
+    "node": "^14.15.0 || >=16.10.0",
     "npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
     "yarn": ">= 1.13.0"
   }

package/{models → src/analytics}/analytics-collector.js

@@ -36,7 +36,7 @@ const debug_1 = __importDefault(require("debug"));
 const https = __importStar(require("https"));
 const os = __importStar(require("os"));
 const querystring = __importStar(require("querystring"));
-const version_1 = require("./version");
+const version_1 = require("../utilities/version");
 /**
  * See: https://developers.google.com/analytics/devguides/collection/protocol/v1/devguide
  */

package/{models → src/analytics}/analytics.d.ts

@@ -5,6 +5,7 @@
  * 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 { analytics } from '@angular-devkit/core';
 import { AnalyticsCollector } from './analytics-collector';
 export declare const AnalyticsProperties: {
     AngularCliProd: string;
@@ -56,3 +57,4 @@ export declare function getWorkspaceAnalytics(): Promise<AnalyticsCollector | un
  * or undefined if no sharing.
  */
 export declare function getSharedAnalytics(): Promise<AnalyticsCollector | undefined>;
+export declare function createAnalytics(workspace: boolean, skipPrompt?: boolean): Promise<analytics.Analytics>;

package/{models → src/analytics}/analytics.js

@@ -29,15 +29,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSharedAnalytics = exports.getWorkspaceAnalytics = exports.hasWorkspaceAnalyticsConfiguration = exports.getGlobalAnalytics = exports.hasGlobalAnalyticsConfiguration = exports.promptProjectAnalytics = exports.promptGlobalAnalytics = exports.setAnalyticsConfig = exports.isPackageNameSafeForAnalytics = exports.analyticsPackageSafelist = exports.AnalyticsProperties = void 0;
+exports.createAnalytics = exports.getSharedAnalytics = exports.getWorkspaceAnalytics = exports.hasWorkspaceAnalyticsConfiguration = exports.getGlobalAnalytics = exports.hasGlobalAnalyticsConfiguration = exports.promptProjectAnalytics = exports.promptGlobalAnalytics = exports.setAnalyticsConfig = exports.isPackageNameSafeForAnalytics = exports.analyticsPackageSafelist = exports.AnalyticsProperties = void 0;
 const core_1 = require("@angular-devkit/core");
 const debug_1 = __importDefault(require("debug"));
 const inquirer = __importStar(require("inquirer"));
 const uuid_1 = require("uuid");
-const version_1 = require("../models/version");
 const color_1 = require("../utilities/color");
 const config_1 = require("../utilities/config");
 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.
@@ -356,3 +356,34 @@ async function getSharedAnalytics() {
     }
 }
 exports.getSharedAnalytics = getSharedAnalytics;
+async function createAnalytics(workspace, skipPrompt = false) {
+    let config = await getGlobalAnalytics();
+    // If in workspace and global analytics is enabled, defer to workspace level
+    if (workspace && config) {
+        const skipAnalytics = skipPrompt ||
+            (process.env['NG_CLI_ANALYTICS'] &&
+                (process.env['NG_CLI_ANALYTICS'].toLowerCase() === 'false' ||
+                    process.env['NG_CLI_ANALYTICS'] === '0'));
+        // 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.
+        if (!skipAnalytics && !(await hasWorkspaceAnalyticsConfiguration())) {
+            await promptProjectAnalytics();
+        }
+        config = await getWorkspaceAnalytics();
+    }
+    const maybeSharedAnalytics = await getSharedAnalytics();
+    if (config && maybeSharedAnalytics) {
+        return new core_1.analytics.MultiAnalytics([config, maybeSharedAnalytics]);
+    }
+    else if (config) {
+        return config;
+    }
+    else if (maybeSharedAnalytics) {
+        return maybeSharedAnalytics;
+    }
+    else {
+        return new core_1.analytics.NoopAnalytics();
+    }
+}
+exports.createAnalytics = createAnalytics;

package/src/command-builder/architect-base-command-module.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 { 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 declare abstract class ArchitectBaseCommandModule<T> extends CommandModule<T> implements CommandModuleImplementation<T> {
+    static scope: CommandScope;
+    protected shouldReportAnalytics: boolean;
+    protected readonly missingErrorTarget: string | 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;
+}

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

@@ -0,0 +1,105 @@
+"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 fs_1 = require("fs");
+const path_1 = require("path");
+const analytics_1 = require("../analytics/analytics");
+const package_manager_1 = require("../utilities/package-manager");
+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) {
+        var _a;
+        const architectHost = await this.getArchitectHost();
+        let builderName;
+        try {
+            builderName = await architectHost.getBuilderNameForTarget(target);
+        }
+        catch (e) {
+            throw new command_module_1.CommandModuleError((_a = this.missingErrorTarget) !== null && _a !== void 0 ? _a : 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();
+        const builderConf = await architectHost.getBuilderNameForTarget(target);
+        let builderDesc;
+        try {
+            builderDesc = await architectHost.resolveBuilder(builderConf);
+        }
+        catch (e) {
+            if (e.code === 'MODULE_NOT_FOUND') {
+                await 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);
+    }
+    async 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;
+        }
+        const packageManager = await (0, package_manager_1.getPackageManager)(basePath);
+        this.context.logger.warn(`Node packages may not be installed. Try installing with '${packageManager} install'.`);
+    }
+}
+exports.ArchitectBaseCommandModule = ArchitectBaseCommandModule;
+ArchitectBaseCommandModule.scope = command_module_1.CommandScope.In;

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

@@ -0,0 +1,22 @@
+/**
+ * @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 getArchitectTarget;
+    private getProjectNamesByTarget;
+}

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

@@ -0,0 +1,110 @@
+"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.ArchitectCommandModule = void 0;
+const architect_base_command_module_1 = require("./architect-base-command-module");
+const command_module_1 = require("./command-module");
+class ArchitectCommandModule extends architect_base_command_module_1.ArchitectBaseCommandModule {
+    async builder(argv) {
+        const localYargs = argv
+            .positional('project', {
+            describe: 'The name of the project to build. Can be an application or a library.',
+            type: 'string',
+        })
+            .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',
+        })
+            .strict();
+        const project = this.getArchitectProject();
+        if (!project) {
+            return localYargs;
+        }
+        const target = this.getArchitectTarget();
+        const schemaOptions = await this.getArchitectTargetOptions({
+            project,
+            target,
+        });
+        return this.addSchemaOptionsToCommand(localYargs, schemaOptions);
+    }
+    async run(options) {
+        var _a;
+        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) {
+                throw new command_module_1.CommandModuleError((_a = this.missingErrorTarget) !== null && _a !== void 0 ? _a : '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) {
+            if (!workspace.projects.has(projectName)) {
+                throw new command_module_1.CommandModuleError(`Project '${projectName}' does not exist.`);
+            }
+            return projectName;
+        }
+        const target = this.getArchitectTarget();
+        const projectFromTarget = this.getProjectNamesByTarget(target);
+        return (projectFromTarget === null || projectFromTarget === void 0 ? void 0 : projectFromTarget.length) ? projectFromTarget[0] : undefined;
+    }
+    getArchitectTarget() {
+        return this.commandName;
+    }
+    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 {
+            // For single target commands, we try the default project first,
+            // then the full list if it has a single project, then error out.
+            const maybeDefaultProject = workspace.extensions['defaultProject'];
+            if (typeof maybeDefaultProject === 'string' &&
+                allProjectsForTargetName.includes(maybeDefaultProject)) {
+                return [maybeDefaultProject];
+            }
+            if (allProjectsForTargetName.length === 1) {
+                return allProjectsForTargetName;
+            }
+        }
+        return undefined;
+    }
+}
+exports.ArchitectCommandModule = ArchitectCommandModule;