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

package/src/analytics/analytics.js

@@ -0,0 +1,304 @@
+"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.
+ */
+function setAnalyticsConfig(global, value) {
+    const level = global ? 'global' : 'local';
+    analyticsDebug('setting %s level analytics to: %s', level, value);
+    const [config, configPath] = (0, config_1.getWorkspaceRaw)(level);
+    if (!config || !configPath) {
+        throw new Error(`Could not find ${level} workspace.`);
+    }
+    const cli = config.get(['cli']);
+    if (cli !== undefined && !core_1.json.isJsonObject(cli)) {
+        throw new Error(`Invalid config found at ${configPath}. CLI should be an object.`);
+    }
+    if (value === true) {
+        value = (0, uuid_1.v4)();
+    }
+    config.modify(['cli', 'analytics'], value);
+    config.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 [config, configPath] = (0, config_1.getWorkspaceRaw)(level);
+    if (!config || !configPath) {
+        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,
+            },
+        ]);
+        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) {
+    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 = workspace === null || workspace === void 0 ? void 0 : workspace.getCli()['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() {
+    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 = globalWorkspace === null || globalWorkspace === void 0 ? void 0 : globalWorkspace.getCli()['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() {
+    const [globalWorkspace] = (0, config_1.getWorkspaceRaw)('global');
+    const [localWorkspace] = (0, config_1.getWorkspaceRaw)('local');
+    const globalSetting = globalWorkspace === null || globalWorkspace === void 0 ? void 0 : globalWorkspace.get(['cli', 'analytics']);
+    const localSetting = localWorkspace === null || localWorkspace === void 0 ? void 0 : localWorkspace.get(['cli', '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,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,103 @@
+"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 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') {
+                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'.`);
+    }
+}
+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,108 @@
+"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 config_1 = require("../utilities/config");
+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 {
+            if (allProjectsForTargetName.length === 1) {
+                return allProjectsForTargetName;
+            }
+            const maybeProject = (0, config_1.getProjectByCwd)(workspace);
+            if (maybeProject && allProjectsForTargetName.includes(maybeProject)) {
+                return [maybeProject];
+            }
+        }
+        return undefined;
+    }
+}
+exports.ArchitectCommandModule = ArchitectCommandModule;

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

@@ -0,0 +1,89 @@
+/**
+ * @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 { analytics, logging } from '@angular-devkit/core';
+import { ArgumentsCamelCase, Argv, CamelCaseKey, CommandModule as YargsCommandModule } from 'yargs';
+import { AngularWorkspace } from '../utilities/config';
+import { PackageManagerUtils } from '../utilities/package-manager';
+import { Option } from './utilities/json-schema';
+export declare type Options<T> = {
+    [key in keyof T as CamelCaseKey<key>]: T[key];
+};
+export declare enum CommandScope {
+    /** Command can only run inside an Angular workspace. */
+    In = 0,
+    /** Command can only run outside an Angular workspace. */
+    Out = 1,
+    /** Command can run inside and outside an Angular workspace. */
+    Both = 2
+}
+export interface CommandContext {
+    currentDirectory: string;
+    root: string;
+    workspace?: AngularWorkspace;
+    globalConfiguration?: AngularWorkspace;
+    logger: logging.Logger;
+    packageManager: PackageManagerUtils;
+    /** Arguments parsed in free-from without parser configuration. */
+    args: {
+        positional: string[];
+        options: {
+            help: boolean;
+            jsonHelp: boolean;
+        } & Record<string, unknown>;
+    };
+}
+export declare type OtherOptions = Record<string, unknown>;
+export interface CommandModuleImplementation<T extends {} = {}> extends Omit<YargsCommandModule<{}, T>, 'builder' | 'handler'> {
+    /** Path used to load the long description for the command in JSON help text. */
+    longDescriptionPath?: string;
+    /** Object declaring the options the command accepts, or a function accepting and returning a yargs instance. */
+    builder(argv: Argv): Promise<Argv<T>> | Argv<T>;
+    /** A function which will be passed the parsed argv. */
+    run(options: Options<T> & OtherOptions): Promise<number | void> | number | void;
+}
+export interface FullDescribe {
+    describe?: string;
+    longDescription?: string;
+    longDescriptionRelativePath?: string;
+}
+export declare abstract class CommandModule<T extends {} = {}> implements CommandModuleImplementation<T> {
+    protected readonly context: CommandContext;
+    abstract readonly command: string;
+    abstract readonly describe: string | false;
+    abstract readonly longDescriptionPath?: string;
+    protected readonly shouldReportAnalytics: boolean;
+    static scope: CommandScope;
+    private readonly optionsWithAnalytics;
+    constructor(context: CommandContext);
+    /**
+     * Description object which contains the long command descroption.
+     * This is used to generate JSON help wich is used in AIO.
+     *
+     * `false` will result in a hidden command.
+     */
+    get fullDescribe(): FullDescribe | false;
+    protected get commandName(): string;
+    abstract builder(argv: Argv): Promise<Argv<T>> | Argv<T>;
+    abstract run(options: Options<T> & OtherOptions): Promise<number | void> | number | void;
+    handler(args: ArgumentsCamelCase<T> & OtherOptions): Promise<void>;
+    reportAnalytics(options: (Options<T> & OtherOptions) | OtherOptions, paths?: string[], dimensions?: (boolean | number | string)[]): Promise<void>;
+    private _analytics;
+    protected getAnalytics(): Promise<analytics.Analytics>;
+    /**
+     * Adds schema options to a command also this keeps track of options that are required for analytics.
+     * **Note:** This method should be called from the command bundler method.
+     */
+    protected addSchemaOptionsToCommand<T>(localYargs: Argv<T>, options: Option[]): Argv<T>;
+    protected getWorkspaceOrThrow(): AngularWorkspace;
+}
+/**
+ * Creates an known command module error.
+ * This is used so during executation we can filter between known validation error and real non handled errors.
+ */
+export declare class CommandModuleError extends Error {
+}