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

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

@@ -0,0 +1,333 @@
+"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 __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;
+};
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchematicsCommandModule = exports.DEFAULT_SCHEMATICS_COLLECTION = void 0;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const tools_1 = require("@angular-devkit/schematics/tools");
+const config_1 = require("../utilities/config");
+const memoize_1 = require("../utilities/memoize");
+const tty_1 = require("../utilities/tty");
+const command_module_1 = require("./command-module");
+const json_schema_1 = require("./utilities/json-schema");
+const schematic_engine_host_1 = require("./utilities/schematic-engine-host");
+const schematic_workflow_1 = require("./utilities/schematic-workflow");
+exports.DEFAULT_SCHEMATICS_COLLECTION = '@schematics/angular';
+class SchematicsCommandModule extends command_module_1.CommandModule {
+    constructor() {
+        super(...arguments);
+        this.allowPrivateSchematics = false;
+        this.shouldReportAnalytics = false;
+        this.defaultProjectDeprecationWarningShown = false;
+    }
+    async builder(argv) {
+        return argv
+            .option('interactive', {
+            describe: 'Enable interactive input prompts.',
+            type: 'boolean',
+            default: true,
+        })
+            .option('dry-run', {
+            describe: 'Run through and reports activity without writing out results.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('defaults', {
+            describe: 'Disable interactive input prompts for options with a default.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('force', {
+            describe: 'Force overwriting of existing files.',
+            type: 'boolean',
+            default: false,
+        })
+            .strict();
+    }
+    /** Get schematic schema options.*/
+    async getSchematicOptions(collection, schematicName, workflow) {
+        const schematic = collection.createSchematic(schematicName, true);
+        const { schemaJson } = schematic.description;
+        if (!schemaJson) {
+            return [];
+        }
+        return (0, json_schema_1.parseJsonSchemaToOptions)(workflow.registry, schemaJson);
+    }
+    getOrCreateWorkflowForBuilder(collectionName) {
+        return new tools_1.NodeWorkflow(this.context.root, {
+            resolvePaths: this.getResolvePaths(collectionName),
+            engineHostCreator: (options) => new schematic_engine_host_1.SchematicEngineHost(options.resolvePaths),
+        });
+    }
+    async getOrCreateWorkflowForExecution(collectionName, options) {
+        const { logger, root, packageManager } = this.context;
+        const { force, dryRun, packageRegistry } = options;
+        const workflow = new tools_1.NodeWorkflow(root, {
+            force,
+            dryRun,
+            packageManager: packageManager.name,
+            // A schema registry is required to allow customizing addUndefinedDefaults
+            registry: new core_1.schema.CoreSchemaRegistry(schematics_1.formats.standardFormats),
+            packageRegistry,
+            resolvePaths: this.getResolvePaths(collectionName),
+            schemaValidation: true,
+            optionTransforms: [
+                // Add configuration file defaults
+                async (schematic, current) => {
+                    const projectName = typeof (current === null || current === void 0 ? void 0 : current.project) === 'string' ? current.project : this.getProjectName();
+                    return {
+                        ...(await (0, config_1.getSchematicDefaults)(schematic.collection.name, schematic.name, projectName)),
+                        ...current,
+                    };
+                },
+            ],
+            engineHostCreator: (options) => new schematic_engine_host_1.SchematicEngineHost(options.resolvePaths),
+        });
+        workflow.registry.addPostTransform(core_1.schema.transforms.addUndefinedDefaults);
+        workflow.registry.addSmartDefaultProvider('projectName', () => this.getProjectName());
+        workflow.registry.useXDeprecatedProvider((msg) => logger.warn(msg));
+        let shouldReportAnalytics = true;
+        workflow.engineHost.registerOptionsTransform(async (schematic, options) => {
+            var _a;
+            if (shouldReportAnalytics) {
+                shouldReportAnalytics = false;
+                // ng generate lib -> ng generate
+                const commandName = (_a = this.command) === null || _a === void 0 ? void 0 : _a.split(' ', 1)[0];
+                await this.reportAnalytics(options, [
+                    commandName,
+                    schematic.collection.name.replace(/\//g, '_'),
+                    schematic.name.replace(/\//g, '_'),
+                ]);
+            }
+            return options;
+        });
+        if (options.interactive !== false && (0, tty_1.isTTY)()) {
+            workflow.registry.usePromptProvider(async (definitions) => {
+                const questions = definitions
+                    .filter((definition) => !options.defaults || definition.default === undefined)
+                    .map((definition) => {
+                    var _a;
+                    const question = {
+                        name: definition.id,
+                        message: definition.message,
+                        default: definition.default,
+                    };
+                    const validator = definition.validator;
+                    if (validator) {
+                        question.validate = (input) => validator(input);
+                        // Filter allows transformation of the value prior to validation
+                        question.filter = async (input) => {
+                            for (const type of definition.propertyTypes) {
+                                let value;
+                                switch (type) {
+                                    case 'string':
+                                        value = String(input);
+                                        break;
+                                    case 'integer':
+                                    case 'number':
+                                        value = Number(input);
+                                        break;
+                                    default:
+                                        value = input;
+                                        break;
+                                }
+                                // Can be a string if validation fails
+                                const isValid = (await validator(value)) === true;
+                                if (isValid) {
+                                    return value;
+                                }
+                            }
+                            return input;
+                        };
+                    }
+                    switch (definition.type) {
+                        case 'confirmation':
+                            question.type = 'confirm';
+                            break;
+                        case 'list':
+                            question.type = definition.multiselect ? 'checkbox' : 'list';
+                            question.choices = (_a = definition.items) === null || _a === void 0 ? void 0 : _a.map((item) => {
+                                return typeof item == 'string'
+                                    ? item
+                                    : {
+                                        name: item.label,
+                                        value: item.value,
+                                    };
+                            });
+                            break;
+                        default:
+                            question.type = definition.type;
+                            break;
+                    }
+                    return question;
+                });
+                if (questions.length) {
+                    const { prompt } = await Promise.resolve().then(() => __importStar(require('inquirer')));
+                    return prompt(questions);
+                }
+                else {
+                    return {};
+                }
+            });
+        }
+        return workflow;
+    }
+    async getSchematicCollections() {
+        var _a;
+        const getSchematicCollections = (configSection) => {
+            if (!configSection) {
+                return undefined;
+            }
+            const { schematicCollections, defaultCollection } = configSection;
+            if (Array.isArray(schematicCollections)) {
+                return new Set(schematicCollections);
+            }
+            else if (typeof defaultCollection === 'string') {
+                return new Set([defaultCollection]);
+            }
+            return undefined;
+        };
+        const { workspace, globalConfiguration } = this.context;
+        if (workspace) {
+            const project = (0, config_1.getProjectByCwd)(workspace);
+            if (project) {
+                const value = getSchematicCollections(workspace.getProjectCli(project));
+                if (value) {
+                    return value;
+                }
+            }
+        }
+        const value = (_a = getSchematicCollections(workspace === null || workspace === void 0 ? void 0 : workspace.getCli())) !== null && _a !== void 0 ? _a : getSchematicCollections(globalConfiguration === null || globalConfiguration === void 0 ? void 0 : globalConfiguration.getCli());
+        if (value) {
+            return value;
+        }
+        return new Set([exports.DEFAULT_SCHEMATICS_COLLECTION]);
+    }
+    parseSchematicInfo(schematic) {
+        if (schematic === null || schematic === void 0 ? void 0 : schematic.includes(':')) {
+            const [collectionName, schematicName] = schematic.split(':', 2);
+            return [collectionName, schematicName];
+        }
+        return [undefined, schematic];
+    }
+    async runSchematic(options) {
+        const { logger } = this.context;
+        const { schematicOptions, executionOptions, collectionName, schematicName } = options;
+        const workflow = await this.getOrCreateWorkflowForExecution(collectionName, executionOptions);
+        if (!schematicName) {
+            throw new Error('schematicName cannot be undefined.');
+        }
+        const { unsubscribe, files } = (0, schematic_workflow_1.subscribeToWorkflow)(workflow, logger);
+        try {
+            await workflow
+                .execute({
+                collection: collectionName,
+                schematic: schematicName,
+                options: schematicOptions,
+                logger,
+                allowPrivate: this.allowPrivateSchematics,
+            })
+                .toPromise();
+            if (!files.size) {
+                logger.info('Nothing to be done.');
+            }
+            if (executionOptions.dryRun) {
+                logger.warn(`\nNOTE: The "--dry-run" option means no changes were made.`);
+            }
+        }
+        catch (err) {
+            // In case the workflow was not successful, show an appropriate error message.
+            if (err instanceof schematics_1.UnsuccessfulWorkflowExecution) {
+                // "See above" because we already printed the error.
+                logger.fatal('The Schematic workflow failed. See above.');
+                return 1;
+            }
+            else {
+                throw err;
+            }
+        }
+        finally {
+            unsubscribe();
+        }
+        return 0;
+    }
+    getProjectName() {
+        const { workspace, logger } = this.context;
+        if (!workspace) {
+            return undefined;
+        }
+        const projectName = (0, config_1.getProjectByCwd)(workspace);
+        if (projectName) {
+            return projectName;
+        }
+        const defaultProjectName = workspace.extensions['defaultProject'];
+        if (typeof defaultProjectName === 'string' && defaultProjectName) {
+            if (!this.defaultProjectDeprecationWarningShown) {
+                logger.warn(core_1.tags.oneLine `
+            DEPRECATED: The 'defaultProject' workspace option has been deprecated.
+            The project to use will be determined from the current working directory.
+          `);
+                this.defaultProjectDeprecationWarningShown = true;
+            }
+            return defaultProjectName;
+        }
+        return undefined;
+    }
+    getResolvePaths(collectionName) {
+        const { workspace, root } = this.context;
+        return workspace
+            ? // Workspace
+                collectionName === exports.DEFAULT_SCHEMATICS_COLLECTION
+                    ? // Favor __dirname for @schematics/angular to use the build-in version
+                        [__dirname, process.cwd(), root]
+                    : [process.cwd(), root, __dirname]
+            : // Global
+                [__dirname, process.cwd()];
+    }
+}
+SchematicsCommandModule.scope = command_module_1.CommandScope.In;
+__decorate([
+    memoize_1.memoize
+], SchematicsCommandModule.prototype, "getOrCreateWorkflowForBuilder", null);
+__decorate([
+    memoize_1.memoize
+], SchematicsCommandModule.prototype, "getOrCreateWorkflowForExecution", null);
+__decorate([
+    memoize_1.memoize
+], SchematicsCommandModule.prototype, "getSchematicCollections", null);
+exports.SchematicsCommandModule = SchematicsCommandModule;

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

@@ -0,0 +1,13 @@
+/**
+ * @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 { CommandContext, CommandModule, CommandModuleImplementation } from '../command-module';
+export declare const demandCommandFailureMessage = "You need to specify a command before moving on. Use '--help' to view the available commands.";
+export declare function addCommandModuleToYargs<T, U extends Partial<CommandModuleImplementation> & {
+    new (context: CommandContext): Partial<CommandModuleImplementation> & CommandModule;
+}>(localYargs: Argv<T>, commandModule: U, context: CommandContext): Argv<T>;

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

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCommandModuleToYargs = exports.demandCommandFailureMessage = void 0;
+exports.demandCommandFailureMessage = `You need to specify a command before moving on. Use '--help' to view the available commands.`;
+function addCommandModuleToYargs(localYargs, commandModule, context) {
+    const cmd = new commandModule(context);
+    const describe = context.args.options.jsonHelp ? cmd.fullDescribe : cmd.describe;
+    return localYargs.command({
+        command: cmd.command,
+        aliases: cmd.aliases,
+        describe: 
+        // We cannot add custom fields in help, such as long command description which is used in AIO.
+        // Therefore, we get around this by adding a complex object as a string which we later parse when generating the help files.
+        typeof describe === 'object' ? JSON.stringify(describe) : describe,
+        deprecated: cmd.deprecated,
+        builder: (argv) => cmd.builder(argv),
+        handler: (args) => cmd.handler(args),
+    });
+}
+exports.addCommandModuleToYargs = addCommandModuleToYargs;

package/src/command-builder/utilities/json-help.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @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
+ */
+interface JsonHelpOption {
+    name: string;
+    type?: string;
+    deprecated: boolean | string;
+    aliases?: string[];
+    default?: string;
+    required?: boolean;
+    positional?: number;
+    enum?: string[];
+    description?: string;
+}
+interface JsonHelpDescription {
+    shortDescription?: string;
+    longDescription?: string;
+    longDescriptionRelativePath?: string;
+}
+interface JsonHelpSubcommand extends JsonHelpDescription {
+    name: string;
+    aliases: string[];
+    deprecated: string | boolean;
+}
+export interface JsonHelp extends JsonHelpDescription {
+    name: string;
+    command: string;
+    options: JsonHelpOption[];
+    subcommands?: JsonHelpSubcommand[];
+}
+export declare function jsonHelpUsage(): string;
+export {};

package/src/command-builder/utilities/json-help.js

@@ -0,0 +1,94 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonHelpUsage = void 0;
+const yargs_1 = __importDefault(require("yargs"));
+const yargsDefaultCommandRegExp = /^\$0|\*/;
+function jsonHelpUsage() {
+    var _a, _b, _c, _d, _e;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const localYargs = yargs_1.default;
+    const { deprecatedOptions, alias: aliases, array, string, boolean, number, choices, demandedOptions, default: defaultVal, hiddenOptions = [], } = localYargs.getOptions();
+    const internalMethods = localYargs.getInternalMethods();
+    const usageInstance = internalMethods.getUsageInstance();
+    const context = internalMethods.getContext();
+    const descriptions = usageInstance.getDescriptions();
+    const groups = localYargs.getGroups();
+    const positional = groups[usageInstance.getPositionalGroupName()];
+    const hidden = new Set(hiddenOptions);
+    const normalizeOptions = [];
+    const allAliases = new Set([...Object.values(aliases).flat()]);
+    for (const [names, type] of [
+        [array, 'array'],
+        [string, 'string'],
+        [boolean, 'boolean'],
+        [number, 'number'],
+    ]) {
+        for (const name of names) {
+            if (allAliases.has(name) || hidden.has(name)) {
+                // Ignore hidden, aliases and already visited option.
+                continue;
+            }
+            const positionalIndex = (_a = positional === null || positional === void 0 ? void 0 : positional.indexOf(name)) !== null && _a !== void 0 ? _a : -1;
+            const alias = aliases[name];
+            normalizeOptions.push({
+                name,
+                type,
+                deprecated: deprecatedOptions[name],
+                aliases: (alias === null || alias === void 0 ? void 0 : alias.length) > 0 ? alias : undefined,
+                default: defaultVal[name],
+                required: demandedOptions[name],
+                enum: choices[name],
+                description: (_b = descriptions[name]) === null || _b === void 0 ? void 0 : _b.replace('__yargsString__:', ''),
+                positional: positionalIndex >= 0 ? positionalIndex : undefined,
+            });
+        }
+    }
+    // https://github.com/yargs/yargs/blob/00e4ebbe3acd438e73fdb101e75b4f879eb6d345/lib/usage.ts#L124
+    const subcommands = usageInstance.getCommands()
+        .map(([name, rawDescription, isDefault, aliases, deprecated]) => ({
+        name: name.split(' ', 1)[0].replace(yargsDefaultCommandRegExp, ''),
+        command: name.replace(yargsDefaultCommandRegExp, ''),
+        default: isDefault || undefined,
+        ...parseDescription(rawDescription),
+        aliases,
+        deprecated,
+    }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const [command, rawDescription] = (_c = usageInstance.getUsage()[0]) !== null && _c !== void 0 ? _c : [];
+    const defaultSubCommand = (_e = (_d = subcommands.find((x) => x.default)) === null || _d === void 0 ? void 0 : _d.command) !== null && _e !== void 0 ? _e : '';
+    const otherSubcommands = subcommands.filter((s) => !s.default);
+    const output = {
+        name: [...context.commands].pop(),
+        command: `${command === null || command === void 0 ? void 0 : command.replace(yargsDefaultCommandRegExp, localYargs['$0'])}${defaultSubCommand}`,
+        ...parseDescription(rawDescription),
+        options: normalizeOptions.sort((a, b) => a.name.localeCompare(b.name)),
+        subcommands: otherSubcommands.length ? otherSubcommands : undefined,
+    };
+    return JSON.stringify(output, undefined, 2);
+}
+exports.jsonHelpUsage = jsonHelpUsage;
+function parseDescription(rawDescription) {
+    try {
+        const { longDescription, describe: shortDescription, longDescriptionRelativePath, } = JSON.parse(rawDescription);
+        return {
+            shortDescription,
+            longDescriptionRelativePath,
+            longDescription,
+        };
+    }
+    catch {
+        return {
+            shortDescription: rawDescription,
+        };
+    }
+}

package/src/command-builder/utilities/json-schema.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @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 { json } from '@angular-devkit/core';
+import yargs from 'yargs';
+/**
+ * An option description.
+ */
+export interface Option extends yargs.Options {
+    /**
+     * The name of the option.
+     */
+    name: string;
+    /**
+     * Whether this option is required or not.
+     */
+    required?: boolean;
+    /**
+     * Format field of this option.
+     */
+    format?: string;
+    /**
+     * Whether this option should be hidden from the help output. It will still show up in JSON help.
+     */
+    hidden?: boolean;
+    /**
+     * If this option can be used as an argument, the position of the argument. Otherwise omitted.
+     */
+    positional?: number;
+    /**
+     * Whether or not to report this option to the Angular Team, and which custom field to use.
+     * If this is falsey, do not report this option.
+     */
+    userAnalytics?: number;
+}
+export declare function parseJsonSchemaToOptions(registry: json.schema.SchemaRegistry, schema: json.JsonObject, interactive?: boolean): Promise<Option[]>;