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

package/{utilities → src/command-builder/utilities}/json-schema.js

@@ -7,102 +7,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJsonSchemaToOptions = exports.parseJsonSchemaToCommandDescription = exports.parseJsonSchemaToSubCommandDescription = exports.CommandJsonPathException = void 0;
+exports.parseJsonSchemaToOptions = void 0;
 const core_1 = require("@angular-devkit/core");
-const tools_1 = require("@angular-devkit/schematics/tools");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const interface_1 = require("../models/interface");
-class CommandJsonPathException extends core_1.BaseException {
-    constructor(path, name) {
-        super(`File ${path} was not found while constructing the subcommand ${name}.`);
-        this.path = path;
-        this.name = name;
-    }
-}
-exports.CommandJsonPathException = CommandJsonPathException;
-function _getEnumFromValue(value, enumeration, defaultValue) {
-    if (typeof value !== 'string') {
-        return defaultValue;
-    }
-    if (Object.values(enumeration).includes(value)) {
-        return value;
-    }
-    return defaultValue;
-}
-async function parseJsonSchemaToSubCommandDescription(name, jsonPath, registry, schema) {
-    const options = await parseJsonSchemaToOptions(registry, schema);
-    const aliases = [];
-    if (core_1.json.isJsonArray(schema.$aliases)) {
-        schema.$aliases.forEach((value) => {
-            if (typeof value == 'string') {
-                aliases.push(value);
-            }
-        });
-    }
-    if (core_1.json.isJsonArray(schema.aliases)) {
-        schema.aliases.forEach((value) => {
-            if (typeof value == 'string') {
-                aliases.push(value);
-            }
-        });
-    }
-    if (typeof schema.alias == 'string') {
-        aliases.push(schema.alias);
-    }
-    let longDescription = '';
-    if (typeof schema.$longDescription == 'string' && schema.$longDescription) {
-        const ldPath = (0, path_1.resolve)((0, path_1.dirname)(jsonPath), schema.$longDescription);
-        try {
-            longDescription = (0, fs_1.readFileSync)(ldPath, 'utf-8');
-        }
-        catch (e) {
-            throw new CommandJsonPathException(ldPath, name);
-        }
-    }
-    let usageNotes = '';
-    if (typeof schema.$usageNotes == 'string' && schema.$usageNotes) {
-        const unPath = (0, path_1.resolve)((0, path_1.dirname)(jsonPath), schema.$usageNotes);
-        try {
-            usageNotes = (0, fs_1.readFileSync)(unPath, 'utf-8');
-        }
-        catch (e) {
-            throw new CommandJsonPathException(unPath, name);
-        }
-    }
-    const description = '' + (schema.description === undefined ? '' : schema.description);
-    return {
-        name,
-        description,
-        ...(longDescription ? { longDescription } : {}),
-        ...(usageNotes ? { usageNotes } : {}),
-        options,
-        aliases,
-    };
-}
-exports.parseJsonSchemaToSubCommandDescription = parseJsonSchemaToSubCommandDescription;
-async function parseJsonSchemaToCommandDescription(name, jsonPath, registry, schema) {
-    const subcommand = await parseJsonSchemaToSubCommandDescription(name, jsonPath, registry, schema);
-    // Before doing any work, let's validate the implementation.
-    if (typeof schema.$impl != 'string') {
-        throw new Error(`Command ${name} has an invalid implementation.`);
-    }
-    const ref = new tools_1.ExportStringRef(schema.$impl, (0, path_1.dirname)(jsonPath));
-    const impl = ref.ref;
-    if (impl === undefined || typeof impl !== 'function') {
-        throw new Error(`Command ${name} has an invalid implementation.`);
-    }
-    const scope = _getEnumFromValue(schema.$scope, interface_1.CommandScope, interface_1.CommandScope.Default);
-    const hidden = !!schema.$hidden;
-    return {
-        ...subcommand,
-        scope,
-        hidden,
-        impl,
-    };
-}
-exports.parseJsonSchemaToCommandDescription = parseJsonSchemaToCommandDescription;
-async function parseJsonSchemaToOptions(registry, schema) {
+async function parseJsonSchemaToOptions(registry, schema, interactive = true) {
     const options = [];
     function visitor(current, pointer, parentSchema) {
         if (!parentSchema) {
@@ -131,8 +38,7 @@ async function parseJsonSchemaToOptions(registry, schema) {
             throw new Error('Cannot find type of schema.');
         }
         // We only support number, string or boolean (or array of those), so remove everything else.
-        const types = [...typeSet]
-            .filter((x) => {
+        const types = [...typeSet].filter((x) => {
             switch (x) {
                 case 'boolean':
                 case 'number':
@@ -149,8 +55,7 @@ async function parseJsonSchemaToOptions(registry, schema) {
                 default:
                     return false;
             }
-        })
-            .map((x) => _getEnumFromValue(x, interface_1.OptionType, interface_1.OptionType.String));
+        });
         if (types.length == 0) {
             // This means it's not usable on the command line. e.g. an Object.
             return;
@@ -190,10 +95,11 @@ async function parseJsonSchemaToOptions(registry, schema) {
         const $default = current.$default;
         const $defaultIndex = core_1.json.isJsonObject($default) && $default['$source'] == 'argv' ? $default['index'] : undefined;
         const positional = typeof $defaultIndex == 'number' ? $defaultIndex : undefined;
-        const required = core_1.json.isJsonArray(current.required)
-            ? current.required.indexOf(name) != -1
-            : false;
-        const aliases = core_1.json.isJsonArray(current.aliases)
+        let required = core_1.json.isJsonArray(schema.required) ? schema.required.includes(name) : false;
+        if (required && interactive && current['x-prompt']) {
+            required = false;
+        }
+        const alias = core_1.json.isJsonArray(current.aliases)
             ? [...current.aliases].map((x) => '' + x)
             : current.alias
                 ? ['' + current.alias]
@@ -209,37 +115,30 @@ async function parseJsonSchemaToOptions(registry, schema) {
         const option = {
             name,
             description: '' + (current.description === undefined ? '' : current.description),
-            ...(types.length == 1 ? { type } : { type, types }),
-            ...(defaultValue !== undefined ? { default: defaultValue } : {}),
-            ...(enumValues && enumValues.length > 0 ? { enum: enumValues } : {}),
+            type,
+            default: defaultValue,
+            choices: enumValues.length ? enumValues : undefined,
             required,
-            aliases,
-            ...(format !== undefined ? { format } : {}),
+            alias,
+            format,
             hidden,
-            ...(userAnalytics ? { userAnalytics } : {}),
-            ...(deprecated !== undefined ? { deprecated } : {}),
-            ...(positional !== undefined ? { positional } : {}),
+            userAnalytics,
+            deprecated,
+            positional,
         };
         options.push(option);
     }
     const flattenedSchema = await registry.flatten(schema).toPromise();
     core_1.json.schema.visitJsonSchema(flattenedSchema, visitor);
-    // Sort by positional.
+    // Sort by positional and name.
     return options.sort((a, b) => {
         if (a.positional) {
-            if (b.positional) {
-                return a.positional - b.positional;
-            }
-            else {
-                return 1;
-            }
+            return b.positional ? a.positional - b.positional : a.name.localeCompare(b.name);
         }
         else if (b.positional) {
             return -1;
         }
-        else {
-            return 0;
-        }
+        return a.name.localeCompare(b.name);
     });
 }
 exports.parseJsonSchemaToOptions = parseJsonSchemaToOptions;

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

@@ -0,0 +1,14 @@
+/**
+ * @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 { logging } from '@angular-devkit/core';
+import { NodeWorkflow } from '@angular-devkit/schematics/tools';
+export declare function subscribeToWorkflow(workflow: NodeWorkflow, logger: logging.LoggerApi): {
+    files: Set<string>;
+    error: boolean;
+    unsubscribe: () => void;
+};

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

@@ -0,0 +1,68 @@
+"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.subscribeToWorkflow = void 0;
+const core_1 = require("@angular-devkit/core");
+const color_1 = require("../../utilities/color");
+function subscribeToWorkflow(workflow, logger) {
+    const files = new Set();
+    let error = false;
+    let logs = [];
+    const reporterSubscription = workflow.reporter.subscribe((event) => {
+        // Strip leading slash to prevent confusion.
+        const eventPath = event.path.charAt(0) === '/' ? event.path.substring(1) : event.path;
+        switch (event.kind) {
+            case 'error':
+                error = true;
+                const desc = event.description == 'alreadyExist' ? 'already exists' : 'does not exist';
+                logger.error(`ERROR! ${eventPath} ${desc}.`);
+                break;
+            case 'update':
+                logs.push(core_1.tags.oneLine `
+              ${color_1.colors.cyan('UPDATE')} ${eventPath} (${event.content.length} bytes)
+            `);
+                files.add(eventPath);
+                break;
+            case 'create':
+                logs.push(core_1.tags.oneLine `
+              ${color_1.colors.green('CREATE')} ${eventPath} (${event.content.length} bytes)
+            `);
+                files.add(eventPath);
+                break;
+            case 'delete':
+                logs.push(`${color_1.colors.yellow('DELETE')} ${eventPath}`);
+                files.add(eventPath);
+                break;
+            case 'rename':
+                const eventToPath = event.to.charAt(0) === '/' ? event.to.substring(1) : event.to;
+                logs.push(`${color_1.colors.blue('RENAME')} ${eventPath} => ${eventToPath}`);
+                files.add(eventPath);
+                break;
+        }
+    });
+    const lifecycleSubscription = workflow.lifeCycle.subscribe((event) => {
+        if (event.kind == 'end' || event.kind == 'post-tasks-start') {
+            if (!error) {
+                // Output the logging queue, no error happened.
+                logs.forEach((log) => logger.info(log));
+            }
+            logs = [];
+            error = false;
+        }
+    });
+    return {
+        files,
+        error,
+        unsubscribe: () => {
+            reporterSubscription.unsubscribe();
+            lifecycleSubscription.unsubscribe();
+        },
+    };
+}
+exports.subscribeToWorkflow = subscribeToWorkflow;

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

@@ -0,0 +1,33 @@
+/**
+ * @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 { CommandModuleImplementation, Options, OtherOptions } from '../../command-builder/command-module';
+import { SchematicsCommandArgs, SchematicsCommandModule } from '../../command-builder/schematics-command-module';
+interface AddCommandArgs extends SchematicsCommandArgs {
+    collection: string;
+    verbose?: boolean;
+    registry?: string;
+    'skip-confirmation'?: boolean;
+}
+export declare class AddCommandModule extends SchematicsCommandModule implements CommandModuleImplementation<AddCommandArgs> {
+    command: string;
+    describe: string;
+    longDescriptionPath: string;
+    protected allowPrivateSchematics: boolean;
+    private readonly schematicName;
+    builder(argv: Argv): Promise<Argv<AddCommandArgs>>;
+    run(options: Options<AddCommandArgs> & OtherOptions): Promise<number | void>;
+    private isProjectVersionValid;
+    reportAnalytics(options: OtherOptions, paths: string[]): Promise<void>;
+    private getCollectionName;
+    private isPackageInstalled;
+    private executeSchematic;
+    private findProjectVersion;
+    private hasMismatchedPeer;
+}
+export {};

package/{commands/add-impl.js → src/commands/add/cli.js}

@@ -10,22 +10,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddCommand = void 0;
+exports.AddCommandModule = void 0;
 const core_1 = require("@angular-devkit/core");
 const tools_1 = require("@angular-devkit/schematics/tools");
 const npm_package_arg_1 = __importDefault(require("npm-package-arg"));
 const path_1 = require("path");
 const semver_1 = require("semver");
-const workspace_schema_1 = require("../lib/config/workspace-schema");
-const analytics_1 = require("../models/analytics");
-const schematic_command_1 = require("../models/schematic-command");
-const color_1 = require("../utilities/color");
-const install_package_1 = require("../utilities/install-package");
-const package_manager_1 = require("../utilities/package-manager");
-const package_metadata_1 = require("../utilities/package-metadata");
-const prompt_1 = require("../utilities/prompt");
-const spinner_1 = require("../utilities/spinner");
-const tty_1 = require("../utilities/tty");
+const workspace_schema_1 = require("../../../lib/config/workspace-schema");
+const analytics_1 = require("../../analytics/analytics");
+const schematics_command_module_1 = require("../../command-builder/schematics-command-module");
+const color_1 = require("../../utilities/color");
+const package_metadata_1 = require("../../utilities/package-metadata");
+const prompt_1 = require("../../utilities/prompt");
+const spinner_1 = require("../../utilities/spinner");
+const tty_1 = require("../../utilities/tty");
 /**
  * The set of packages that should have certain versions excluded from consideration
  * when attempting to find a compatible version for a package.
@@ -35,34 +33,64 @@ const packageVersionExclusions = {
     // @angular/localize@9.x versions do not have peer dependencies setup
     '@angular/localize': '9.x',
 };
-class AddCommand extends schematic_command_1.SchematicCommand {
+class AddCommandModule extends schematics_command_module_1.SchematicsCommandModule {
     constructor() {
         super(...arguments);
+        this.command = 'add <collection>';
+        this.describe = 'Adds support for an external library to your project.';
+        this.longDescriptionPath = (0, path_1.join)(__dirname, 'long-description.md');
         this.allowPrivateSchematics = true;
+        this.schematicName = 'ng-add';
     }
-    async initialize(options) {
-        if (options.registry) {
-            return super.initialize({ ...options, packageRegistry: options.registry });
+    async builder(argv) {
+        const localYargs = (await super.builder(argv))
+            .positional('collection', {
+            description: 'The package to be added.',
+            type: 'string',
+            demandOption: true,
+        })
+            .option('registry', { description: 'The NPM registry to use.', type: 'string' })
+            .option('verbose', {
+            description: 'Display additional details about internal operations during execution.',
+            type: 'boolean',
+            default: false,
+        })
+            .option('skip-confirmation', {
+            description: 'Skip asking a confirmation prompt before installing and executing the package. ' +
+                'Ensure package name is correct prior to using this option.',
+            type: 'boolean',
+            default: false,
+        })
+            // Prior to downloading we don't know the full schema and therefore we cannot be strict on the options.
+            // Possibly in the future update the logic to use the following syntax:
+            // `ng add @angular/localize -- --package-options`.
+            .strict(false);
+        const collectionName = await this.getCollectionName();
+        const workflow = await this.getOrCreateWorkflowForBuilder(collectionName);
+        try {
+            const collection = workflow.engine.createCollection(collectionName);
+            const options = await this.getSchematicOptions(collection, this.schematicName, workflow);
+            return this.addSchemaOptionsToCommand(localYargs, options);
         }
-        else {
-            return super.initialize(options);
+        catch (error) {
+            // During `ng add` prior to the downloading of the package
+            // we are not able to resolve and create a collection.
+            // Or when the the collection value is a path to a tarball.
         }
+        return localYargs;
     }
     // eslint-disable-next-line max-lines-per-function
     async run(options) {
         var _a;
-        await (0, package_manager_1.ensureCompatibleNpm)(this.context.root);
-        if (!options.collection) {
-            this.logger.fatal(`The "ng add" command requires a name argument to be specified eg. ` +
-                `${color_1.colors.yellow('ng add [name] ')}. For more details, use "ng help".`);
-            return 1;
-        }
+        const { logger, packageManager } = this.context;
+        const { verbose, registry, collection, skipConfirmation } = options;
+        packageManager.ensureCompatibility();
         let packageIdentifier;
         try {
-            packageIdentifier = (0, npm_package_arg_1.default)(options.collection);
+            packageIdentifier = (0, npm_package_arg_1.default)(collection);
         }
         catch (e) {
-            this.logger.error(e.message);
+            logger.error(e.message);
             return 1;
         }
         if (packageIdentifier.name &&
@@ -71,29 +99,28 @@ class AddCommand extends schematic_command_1.SchematicCommand {
             const validVersion = await this.isProjectVersionValid(packageIdentifier);
             if (validVersion) {
                 // Already installed so just run schematic
-                this.logger.info('Skipping installation: Package already installed');
-                return this.executeSchematic(packageIdentifier.name, options['--']);
+                logger.info('Skipping installation: Package already installed');
+                return this.executeSchematic({ ...options, collection: packageIdentifier.name });
             }
         }
         const spinner = new spinner_1.Spinner();
         spinner.start('Determining package manager...');
-        const packageManager = await (0, package_manager_1.getPackageManager)(this.context.root);
-        const usingYarn = packageManager === workspace_schema_1.PackageManager.Yarn;
-        spinner.info(`Using package manager: ${color_1.colors.grey(packageManager)}`);
+        const usingYarn = packageManager.name === workspace_schema_1.PackageManager.Yarn;
+        spinner.info(`Using package manager: ${color_1.colors.grey(packageManager.name)}`);
         if (packageIdentifier.name && packageIdentifier.type === 'tag' && !packageIdentifier.rawSpec) {
             // only package name provided; search for viable version
             // plus special cases for packages that did not have peer deps setup
             spinner.start('Searching for compatible package version...');
             let packageMetadata;
             try {
-                packageMetadata = await (0, package_metadata_1.fetchPackageMetadata)(packageIdentifier.name, this.logger, {
-                    registry: options.registry,
+                packageMetadata = await (0, package_metadata_1.fetchPackageMetadata)(packageIdentifier.name, logger, {
+                    registry,
                     usingYarn,
-                    verbose: options.verbose,
+                    verbose,
                 });
             }
             catch (e) {
-                spinner.fail('Unable to load package information from registry: ' + e.message);
+                spinner.fail(`Unable to load package information from registry: ${e.message}`);
                 return 1;
             }
             // Start with the version tagged as `latest` if it exists
@@ -102,16 +129,8 @@ class AddCommand extends schematic_command_1.SchematicCommand {
                 packageIdentifier = npm_package_arg_1.default.resolve(latestManifest.name, latestManifest.version);
             }
             // Adjust the version based on name and peer dependencies
-            if (latestManifest && Object.keys(latestManifest.peerDependencies).length === 0) {
-                if (latestManifest.name === '@angular/pwa') {
-                    const version = await this.findProjectVersion('@angular/cli');
-                    const semverOptions = { includePrerelease: true };
-                    if (version &&
-                        (((0, semver_1.validRange)(version) && (0, semver_1.intersects)(version, '7', semverOptions)) ||
-                            ((0, semver_1.valid)(version) && (0, semver_1.satisfies)(version, '7', semverOptions)))) {
-                        packageIdentifier = npm_package_arg_1.default.resolve('@angular/pwa', '0.12');
-                    }
-                }
+            if ((latestManifest === null || latestManifest === void 0 ? void 0 : latestManifest.peerDependencies) &&
+                Object.keys(latestManifest.peerDependencies).length === 0) {
                 spinner.succeed(`Found compatible package version: ${color_1.colors.grey(packageIdentifier.toString())}.`);
             }
             else if (!latestManifest || (await this.hasMismatchedPeer(latestManifest))) {
@@ -132,7 +151,7 @@ class AddCommand extends schematic_command_1.SchematicCommand {
                     }
                     return true;
                 });
-                versionManifests.sort((a, b) => (0, semver_1.rcompare)(a.version, b.version, true));
+                versionManifests.sort((a, b) => (0, semver_1.compare)(a.version, b.version, true));
                 let newIdentifier;
                 for (const versionManifest of versionManifests) {
                     if (!(await this.hasMismatchedPeer(versionManifest))) {
@@ -156,9 +175,9 @@ class AddCommand extends schematic_command_1.SchematicCommand {
         let savePackage;
         try {
             spinner.start('Loading package information from registry...');
-            const manifest = await (0, package_metadata_1.fetchPackageManifest)(packageIdentifier.toString(), this.logger, {
-                registry: options.registry,
-                verbose: options.verbose,
+            const manifest = await (0, package_metadata_1.fetchPackageManifest)(packageIdentifier.toString(), logger, {
+                registry,
+                verbose,
                 usingYarn,
             });
             savePackage = (_a = manifest['ng-add']) === null || _a === void 0 ? void 0 : _a.save;
@@ -174,38 +193,38 @@ class AddCommand extends schematic_command_1.SchematicCommand {
             spinner.fail(`Unable to fetch package information for '${packageIdentifier}': ${e.message}`);
             return 1;
         }
-        if (!options.skipConfirmation) {
+        if (!skipConfirmation) {
             const confirmationResponse = await (0, prompt_1.askConfirmation)(`\nThe package ${color_1.colors.blue(packageIdentifier.raw)} will be installed and executed.\n` +
                 'Would you like to proceed?', true, false);
             if (!confirmationResponse) {
                 if (!(0, tty_1.isTTY)()) {
-                    this.logger.error('No terminal detected. ' +
+                    logger.error('No terminal detected. ' +
                         `'--skip-confirmation' can be used to bypass installation confirmation. ` +
                         `Ensure package name is correct prior to '--skip-confirmation' option usage.`);
                 }
-                this.logger.error('Command aborted.');
+                logger.error('Command aborted.');
                 return 1;
             }
         }
         if (savePackage === false) {
             // Temporary packages are located in a different directory
             // Hence we need to resolve them using the temp path
-            const { status, tempNodeModules } = await (0, install_package_1.installTempPackage)(packageIdentifier.raw, packageManager, options.registry ? [`--registry="${options.registry}"`] : undefined);
+            const { success, tempNodeModules } = await packageManager.installTemp(packageIdentifier.raw, registry ? [`--registry="${registry}"`] : undefined);
             const resolvedCollectionPath = require.resolve((0, path_1.join)(collectionName, 'package.json'), {
                 paths: [tempNodeModules],
             });
-            if (status !== 0) {
-                return status;
+            if (!success) {
+                return 1;
             }
             collectionName = (0, path_1.dirname)(resolvedCollectionPath);
         }
         else {
-            const status = await (0, install_package_1.installPackage)(packageIdentifier.raw, packageManager, savePackage, options.registry ? [`--registry="${options.registry}"`] : undefined);
-            if (status !== 0) {
-                return status;
+            const success = await packageManager.install(packageIdentifier.raw, savePackage, registry ? [`--registry="${registry}"`] : undefined);
+            if (!success) {
+                return 1;
             }
         }
-        return this.executeSchematic(collectionName, options['--']);
+        return this.executeSchematic({ ...options, collection: collectionName });
     }
     async isProjectVersionValid(packageIdentifier) {
         if (!packageIdentifier.name) {
@@ -228,16 +247,18 @@ class AddCommand extends schematic_command_1.SchematicCommand {
         }
         return validVersion;
     }
-    async reportAnalytics(paths, options, dimensions = [], metrics = []) {
-        const collection = options.collection;
+    async reportAnalytics(options, paths) {
+        const collection = await this.getCollectionName();
+        const dimensions = [];
         // Add the collection if it's safe listed.
         if (collection && (0, analytics_1.isPackageNameSafeForAnalytics)(collection)) {
             dimensions[core_1.analytics.NgCliAnalyticsDimensions.NgAddCollection] = collection;
         }
-        else {
-            delete dimensions[core_1.analytics.NgCliAnalyticsDimensions.NgAddCollection];
-        }
-        return super.reportAnalytics(paths, options, dimensions, metrics);
+        return super.reportAnalytics(options, paths, dimensions);
+    }
+    async getCollectionName() {
+        const [, collectionName] = this.context.args.positional;
+        return collectionName;
     }
     isPackageInstalled(name) {
         try {
@@ -251,20 +272,25 @@ class AddCommand extends schematic_command_1.SchematicCommand {
         }
         return false;
     }
-    async executeSchematic(collectionName, options = []) {
-        const runOptions = {
-            schematicOptions: options,
-            collectionName,
-            schematicName: 'ng-add',
-            dryRun: false,
-            force: false,
-        };
+    async executeSchematic(options) {
         try {
-            return await this.runSchematic(runOptions);
+            const { verbose, skipConfirmation, interactive, force, dryRun, registry, defaults, collection: collectionName, ...schematicOptions } = options;
+            return await this.runSchematic({
+                schematicOptions,
+                schematicName: this.schematicName,
+                collectionName,
+                executionOptions: {
+                    interactive,
+                    force,
+                    dryRun,
+                    defaults,
+                    packageRegistry: registry,
+                },
+            });
         }
         catch (e) {
             if (e instanceof tools_1.NodePackageDoesNotSupportSchematics) {
-                this.logger.error(core_1.tags.oneLine `
+                this.context.logger.error(core_1.tags.oneLine `
           The package that you are trying to add does not support schematics. You can try using
           a different version of the package or contact the package author to add ng-add support.
         `);
@@ -274,27 +300,29 @@ class AddCommand extends schematic_command_1.SchematicCommand {
         }
     }
     async findProjectVersion(name) {
+        var _a, _b;
+        const { logger, root } = this.context;
         let installedPackage;
         try {
             installedPackage = require.resolve((0, path_1.join)(name, 'package.json'), {
-                paths: [this.context.root],
+                paths: [root],
             });
         }
         catch { }
         if (installedPackage) {
             try {
-                const installed = await (0, package_metadata_1.fetchPackageManifest)((0, path_1.dirname)(installedPackage), this.logger);
+                const installed = await (0, package_metadata_1.fetchPackageManifest)((0, path_1.dirname)(installedPackage), logger);
                 return installed.version;
             }
             catch { }
         }
         let projectManifest;
         try {
-            projectManifest = await (0, package_metadata_1.fetchPackageManifest)(this.context.root, this.logger);
+            projectManifest = await (0, package_metadata_1.fetchPackageManifest)(root, logger);
         }
         catch { }
         if (projectManifest) {
-            const version = projectManifest.dependencies[name] || projectManifest.devDependencies[name];
+            const version = ((_a = projectManifest.dependencies) === null || _a === void 0 ? void 0 : _a[name]) || ((_b = projectManifest.devDependencies) === null || _b === void 0 ? void 0 : _b[name]);
             if (version) {
                 return version;
             }
@@ -308,7 +336,7 @@ class AddCommand extends schematic_command_1.SchematicCommand {
                 peerIdentifier = npm_package_arg_1.default.resolve(peer, manifest.peerDependencies[peer]);
             }
             catch {
-                this.logger.warn(`Invalid peer dependency ${peer} found in package.`);
+                this.context.logger.warn(`Invalid peer dependency ${peer} found in package.`);
                 continue;
             }
             if (peerIdentifier.type === 'version' || peerIdentifier.type === 'range') {
@@ -336,4 +364,4 @@ class AddCommand extends schematic_command_1.SchematicCommand {
         return false;
     }
 }
-exports.AddCommand = AddCommand;
+exports.AddCommandModule = AddCommandModule;