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

package/src/commands/analytics/settings/cli.js

@@ -0,0 +1,61 @@
+"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.AnalyticsPromptModule = exports.AnalyticsEnableModule = exports.AnalyticsDisableModule = void 0;
+const analytics_1 = require("../../../analytics/analytics");
+const command_module_1 = require("../../../command-builder/command-module");
+class AnalyticsSettingModule extends command_module_1.CommandModule {
+    builder(localYargs) {
+        return localYargs
+            .option('global', {
+            description: `Configure analytics gathering and reporting globally in the caller's home directory.`,
+            alias: ['g'],
+            type: 'boolean',
+            default: false,
+        })
+            .strict();
+    }
+}
+class AnalyticsDisableModule extends AnalyticsSettingModule {
+    constructor() {
+        super(...arguments);
+        this.command = 'disable';
+        this.aliases = 'off';
+        this.describe = 'Disables analytics gathering and reporting for the user.';
+    }
+    async run({ global }) {
+        (0, analytics_1.setAnalyticsConfig)(global, false);
+        process.stderr.write(await (0, analytics_1.getAnalyticsInfoString)());
+    }
+}
+exports.AnalyticsDisableModule = AnalyticsDisableModule;
+class AnalyticsEnableModule extends AnalyticsSettingModule {
+    constructor() {
+        super(...arguments);
+        this.command = 'enable';
+        this.aliases = 'on';
+        this.describe = 'Enables analytics gathering and reporting for the user.';
+    }
+    async run({ global }) {
+        (0, analytics_1.setAnalyticsConfig)(global, true);
+        process.stderr.write(await (0, analytics_1.getAnalyticsInfoString)());
+    }
+}
+exports.AnalyticsEnableModule = AnalyticsEnableModule;
+class AnalyticsPromptModule extends AnalyticsSettingModule {
+    constructor() {
+        super(...arguments);
+        this.command = 'prompt';
+        this.describe = 'Prompts the user to set the analytics gathering status interactively.';
+    }
+    async run({ global }) {
+        await (0, analytics_1.promptAnalytics)(global, true);
+    }
+}
+exports.AnalyticsPromptModule = AnalyticsPromptModule;

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

@@ -7,7 +7,7 @@
  */
 import { Argv } from 'yargs';
 import { CommandModule, CommandModuleImplementation, Options } from '../../command-builder/command-module';
-export interface ConfigCommandArgs {
+interface ConfigCommandArgs {
     'json-path': string;
     value?: string;
     global?: boolean;
@@ -18,4 +18,7 @@ export declare class ConfigCommandModule extends CommandModule<ConfigCommandArgs
     longDescriptionPath: string;
     builder(localYargs: Argv): Argv<ConfigCommandArgs>;
     run(options: Options<ConfigCommandArgs>): Promise<number | void>;
+    private get;
+    private set;
 }
+export {};

package/src/commands/config/cli.js

@@ -9,8 +9,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigCommandModule = void 0;
 const path_1 = require("path");
+const uuid_1 = require("uuid");
 const command_module_1 = require("../../command-builder/command-module");
-const config_impl_1 = require("./config-impl");
+const config_1 = require("../../utilities/config");
+const json_file_1 = require("../../utilities/json-file");
 class ConfigCommandModule extends command_module_1.CommandModule {
     constructor() {
         super(...arguments);
@@ -38,9 +40,129 @@ class ConfigCommandModule extends command_module_1.CommandModule {
         })
             .strict();
     }
-    run(options) {
-        const command = new config_impl_1.ConfigCommand(this.context, 'config');
-        return command.validateAndRun(options);
+    async run(options) {
+        const level = options.global ? 'global' : 'local';
+        const [config] = (0, config_1.getWorkspaceRaw)(level);
+        if (options.value == undefined) {
+            if (!config) {
+                this.context.logger.error('No config found.');
+                return 1;
+            }
+            return this.get(config, options);
+        }
+        else {
+            return this.set(options);
+        }
+    }
+    get(jsonFile, options) {
+        const { logger } = this.context;
+        const value = options.jsonPath
+            ? jsonFile.get(parseJsonPath(options.jsonPath))
+            : jsonFile.content;
+        if (value === undefined) {
+            logger.error('Value cannot be found.');
+            return 1;
+        }
+        else if (typeof value === 'string') {
+            logger.info(value);
+        }
+        else {
+            logger.info(JSON.stringify(value, null, 2));
+        }
+        return 0;
+    }
+    async set(options) {
+        var _a, _b, _c;
+        if (!((_a = options.jsonPath) === null || _a === void 0 ? void 0 : _a.trim())) {
+            throw new command_module_1.CommandModuleError('Invalid Path.');
+        }
+        const validCliPaths = new Map([
+            ['cli.warnings.versionMismatch', undefined],
+            ['cli.defaultCollection', undefined],
+            ['cli.packageManager', undefined],
+            ['cli.analytics', undefined],
+            ['cli.analyticsSharing.tracking', undefined],
+            ['cli.analyticsSharing.uuid', (v) => (v === '' ? (0, uuid_1.v4)() : `${v}`)],
+            ['cli.cache.enabled', undefined],
+            ['cli.cache.environment', undefined],
+            ['cli.cache.path', undefined],
+        ]);
+        if (options.global &&
+            !options.jsonPath.startsWith('schematics.') &&
+            !validCliPaths.has(options.jsonPath)) {
+            throw new command_module_1.CommandModuleError('Invalid Path.');
+        }
+        const [config, configPath] = (0, config_1.getWorkspaceRaw)(options.global ? 'global' : 'local');
+        const { logger } = this.context;
+        if (!config || !configPath) {
+            throw new command_module_1.CommandModuleError('Confguration file cannot be found.');
+        }
+        const value = (_c = (_b = validCliPaths.get(options.jsonPath)) === null || _b === void 0 ? void 0 : _b(options.value)) !== null && _c !== void 0 ? _c : options.value;
+        const modified = config.modify(parseJsonPath(options.jsonPath), normalizeValue(value));
+        if (!modified) {
+            logger.error('Value cannot be found.');
+            return 1;
+        }
+        await (0, config_1.validateWorkspace)((0, json_file_1.parseJson)(config.content));
+        config.save();
+        return 0;
     }
 }
 exports.ConfigCommandModule = ConfigCommandModule;
+/**
+ * Splits a JSON path string into fragments. Fragments can be used to get the value referenced
+ * by the path. For example, a path of "a[3].foo.bar[2]" would give you a fragment array of
+ * ["a", 3, "foo", "bar", 2].
+ * @param path The JSON string to parse.
+ * @returns {(string|number)[]} The fragments for the string.
+ * @private
+ */
+function parseJsonPath(path) {
+    const fragments = (path || '').split(/\./g);
+    const result = [];
+    while (fragments.length > 0) {
+        const fragment = fragments.shift();
+        if (fragment == undefined) {
+            break;
+        }
+        const match = fragment.match(/([^[]+)((\[.*\])*)/);
+        if (!match) {
+            throw new command_module_1.CommandModuleError('Invalid JSON path.');
+        }
+        result.push(match[1]);
+        if (match[2]) {
+            const indices = match[2]
+                .slice(1, -1)
+                .split('][')
+                .map((x) => (/^\d$/.test(x) ? +x : x.replace(/"|'/g, '')));
+            result.push(...indices);
+        }
+    }
+    return result.filter((fragment) => fragment != null);
+}
+function normalizeValue(value) {
+    const valueString = `${value}`.trim();
+    switch (valueString) {
+        case 'true':
+            return true;
+        case 'false':
+            return false;
+        case 'null':
+            return null;
+        case 'undefined':
+            return undefined;
+    }
+    if (isFinite(+valueString)) {
+        return +valueString;
+    }
+    try {
+        // We use `JSON.parse` instead of `parseJson` because the latter will parse UUIDs
+        // and convert them into a numberic entities.
+        // Example: 73b61974-182c-48e4-b4c6-30ddf08c5c98 -> 73.
+        // These values should never contain comments, therefore using `JSON.parse` is safe.
+        return JSON.parse(valueString);
+    }
+    catch {
+        return value;
+    }
+}

package/src/commands/doc/cli.js

@@ -8,7 +8,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];

package/src/commands/generate/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 GenerateCommandArgs extends SchematicsCommandArgs {
+interface GenerateCommandArgs extends SchematicsCommandArgs {
     schematic?: string;
 }
 export declare class GenerateCommandModule extends SchematicsCommandModule implements CommandModuleImplementation<GenerateCommandArgs> {
@@ -17,7 +17,8 @@ export declare class GenerateCommandModule extends SchematicsCommandModule imple
     describe: string;
     longDescriptionPath?: string | undefined;
     builder(argv: Argv): Promise<Argv<GenerateCommandArgs>>;
-    run(options: Options<GenerateCommandArgs> & OtherOptions): number | void | Promise<number | void>;
+    run(options: Options<GenerateCommandArgs> & OtherOptions): Promise<number | void>;
+    private getCollectionName;
     /**
      * Generate a command string to be passed to the command builder.
      *
@@ -25,3 +26,4 @@ export declare class GenerateCommandModule extends SchematicsCommandModule imple
      */
     private generateCommandString;
 }
+export {};

package/src/commands/generate/cli.js

@@ -10,37 +10,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenerateCommandModule = void 0;
 const core_1 = require("@angular-devkit/core");
 const schematics_command_module_1 = require("../../command-builder/schematics-command-module");
-const generate_impl_1 = require("./generate-impl");
+const command_1 = require("../../command-builder/utilities/command");
 class GenerateCommandModule extends schematics_command_module_1.SchematicsCommandModule {
     constructor() {
         super(...arguments);
-        this.command = 'generate [schematic]';
+        this.command = 'generate';
         this.aliases = 'g';
         this.describe = 'Generates and/or modifies files based on a schematic.';
     }
     async builder(argv) {
-        const [, schematicNameFromArgs] = this.parseSchematicInfo(
-        // positional = [generate, component] or [generate]
-        this.context.args.positional[1]);
-        const baseYargs = await super.builder(argv);
-        if (this.schematicName) {
-            return baseYargs;
-        }
-        // When we do know the schematic name we need to add the 'schematic'
-        // positional option as the schematic will be accessable as a subcommand.
-        let localYargs = schematicNameFromArgs
-            ? baseYargs
-            : baseYargs.positional('schematic', {
-                describe: 'The schematic or collection:schematic to generate.',
+        let localYargs = (await super.builder(argv)).command({
+            command: '$0 <schematic>',
+            describe: 'Run the provided schematic.',
+            builder: (localYargs) => localYargs
+                .positional('schematic', {
+                describe: 'The [collection:schematic] to run.',
                 type: 'string',
                 demandOption: true,
-            });
+            })
+                .strict(),
+            handler: (options) => this.handler(options),
+        });
         const collectionName = await this.getCollectionName();
-        const workflow = this.getOrCreateWorkflow(collectionName);
+        const workflow = this.getOrCreateWorkflowForBuilder(collectionName);
         const collection = workflow.engine.createCollection(collectionName);
         const schematicsInCollection = collection.description.schematics;
         // We cannot use `collection.listSchematicNames()` as this doesn't return hidden schematics.
         const schematicNames = new Set(Object.keys(schematicsInCollection).sort());
+        const [, schematicNameFromArgs] = this.parseSchematicInfo(
+        // positional = [generate, component] or [generate]
+        this.context.args.positional[1]);
         if (schematicNameFromArgs && schematicNames.has(schematicNameFromArgs)) {
             // No need to process all schematics since we know which one the user invoked.
             schematicNames.clear();
@@ -63,11 +62,28 @@ class GenerateCommandModule extends schematics_command_module_1.SchematicsComman
                 handler: (options) => this.handler({ ...options, schematic: `${collectionName}:${schematicName}` }),
             });
         }
-        return localYargs;
+        return localYargs.demandCommand(1, command_1.demandCommandFailureMessage);
+    }
+    async run(options) {
+        const { dryRun, schematic, defaults, force, interactive, ...schematicOptions } = options;
+        const [collectionName = await this.getCollectionName(), schematicName = ''] = this.parseSchematicInfo(schematic);
+        return this.runSchematic({
+            collectionName,
+            schematicName,
+            schematicOptions,
+            executionOptions: {
+                dryRun,
+                defaults,
+                force,
+                interactive,
+            },
+        });
     }
-    run(options) {
-        const command = new generate_impl_1.GenerateCommand(this.context, 'generate');
-        return command.validateAndRun(options);
+    async getCollectionName() {
+        const [collectionName = await this.getDefaultSchematicCollection()] = this.parseSchematicInfo(
+        // positional = [generate, component] or [generate]
+        this.context.args.positional[1]);
+        return collectionName;
     }
     /**
      * Generate a command string to be passed to the command builder.

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

@@ -8,16 +8,18 @@
 import { Argv } from 'yargs';
 import { CommandModuleImplementation, CommandScope, Options, OtherOptions } from '../../command-builder/command-module';
 import { SchematicsCommandArgs, SchematicsCommandModule } from '../../command-builder/schematics-command-module';
-export interface NewCommandArgs extends SchematicsCommandArgs {
+interface NewCommandArgs extends SchematicsCommandArgs {
     collection?: string;
 }
 export declare class NewCommandModule extends SchematicsCommandModule implements CommandModuleImplementation<NewCommandArgs> {
-    protected schematicName: string;
+    private readonly schematicName;
     static scope: CommandScope;
+    protected allowPrivateSchematics: boolean;
     command: string;
     aliases: string;
     describe: string;
     longDescriptionPath?: string | undefined;
     builder(argv: Argv): Promise<Argv<NewCommandArgs>>;
-    run(options: Options<NewCommandArgs> & OtherOptions): number | void | Promise<number | void>;
+    run(options: Options<NewCommandArgs> & OtherOptions): Promise<number | void>;
 }
+export {};

package/src/commands/new/cli.js

@@ -10,26 +10,56 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NewCommandModule = void 0;
 const command_module_1 = require("../../command-builder/command-module");
 const schematics_command_module_1 = require("../../command-builder/schematics-command-module");
-const new_impl_1 = require("./new-impl");
+const package_manager_1 = require("../../utilities/package-manager");
+const version_1 = require("../../utilities/version");
 class NewCommandModule extends schematics_command_module_1.SchematicsCommandModule {
     constructor() {
         super(...arguments);
         this.schematicName = 'ng-new';
+        this.allowPrivateSchematics = true;
         this.command = 'new [name]';
         this.aliases = 'n';
         this.describe = 'Creates a new Angular workspace.';
     }
     async builder(argv) {
-        const baseYargs = await super.builder(argv);
-        return baseYargs.option('collection', {
+        const localYargs = (await super.builder(argv)).option('collection', {
             alias: 'c',
             describe: 'A collection of schematics to use in generating the initial application.',
             type: 'string',
         });
+        const { options: { collectionNameFromArgs }, } = this.context.args;
+        const collectionName = typeof collectionNameFromArgs === 'string'
+            ? collectionNameFromArgs
+            : await this.getDefaultSchematicCollection();
+        const workflow = await this.getOrCreateWorkflowForBuilder(collectionName);
+        const collection = workflow.engine.createCollection(collectionName);
+        const options = await this.getSchematicOptions(collection, this.schematicName, workflow);
+        return this.addSchemaOptionsToCommand(localYargs, options);
     }
-    run(options) {
-        const command = new new_impl_1.NewCommand(this.context, 'new');
-        return command.validateAndRun(options);
+    async run(options) {
+        var _a;
+        // Register the version of the CLI in the registry.
+        const collectionName = (_a = options.collection) !== null && _a !== void 0 ? _a : (await this.getDefaultSchematicCollection());
+        const workflow = await this.getOrCreateWorkflowForExecution(collectionName, options);
+        workflow.registry.addSmartDefaultProvider('ng-cli-version', () => version_1.VERSION.full);
+        const { dryRun, force, interactive, defaults, collection, ...schematicOptions } = options;
+        // Compatibility check for NPM 7
+        if (collectionName === '@schematics/angular' &&
+            !schematicOptions.skipInstall &&
+            (schematicOptions.packageManager === undefined || schematicOptions.packageManager === 'npm')) {
+            await (0, package_manager_1.ensureCompatibleNpm)(this.context.root);
+        }
+        return this.runSchematic({
+            collectionName,
+            schematicName: this.schematicName,
+            schematicOptions,
+            executionOptions: {
+                dryRun,
+                force,
+                interactive,
+                defaults,
+            },
+        });
     }
 }
 exports.NewCommandModule = NewCommandModule;

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

@@ -6,9 +6,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { Argv } from 'yargs';
-import { CommandModule, CommandScope, Options, OtherOptions } from '../../command-builder/command-module';
-export interface UpdateCommandArgs {
-    packages?: string | string[];
+import { CommandModule, CommandScope, Options } from '../../command-builder/command-module';
+interface UpdateCommandArgs {
+    packages?: string[];
     force: boolean;
     next: boolean;
     'migrate-only'?: boolean;
@@ -21,9 +21,34 @@ export interface UpdateCommandArgs {
 }
 export declare class UpdateCommandModule extends CommandModule<UpdateCommandArgs> {
     static scope: CommandScope;
+    protected shouldReportAnalytics: boolean;
     command: string;
     describe: string;
-    longDescriptionPath?: string | undefined;
+    longDescriptionPath: string;
     builder(localYargs: Argv): Argv<UpdateCommandArgs>;
-    run(options: Options<UpdateCommandArgs> & OtherOptions): Promise<number | void>;
+    run(options: Options<UpdateCommandArgs>): Promise<number | void>;
+    private executeSchematic;
+    /**
+     * @return Whether or not the migration was performed successfully.
+     */
+    private executeMigration;
+    /**
+     * @return Whether or not the migrations were performed successfully.
+     */
+    private executeMigrations;
+    private executePackageMigrations;
+    private migrateOnly;
+    private updatePackagesAndMigrate;
+    /**
+     * @return Whether or not the commit was successful.
+     */
+    private commit;
+    private checkCleanGit;
+    /**
+     * Checks if the current installed CLI version is older or newer than a compatible version.
+     * @returns the version to install or null when there is no update to install.
+     */
+    private checkCLIVersion;
+    private getCLIUpdateRunnerVersion;
 }
+export {};