@angular/cli 18.1.0-next.2 → 18.1.0-rc.0

package/src/commands/add/cli.js

@@ -6,24 +6,48 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/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 });
 const tools_1 = require("@angular-devkit/schematics/tools");
+const listr2_1 = require("listr2");
 const module_1 = require("module");
+const node_assert_1 = __importDefault(require("node:assert"));
 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 schematics_command_module_1 = require("../../command-builder/schematics-command-module");
-const color_1 = require("../../utilities/color");
 const error_1 = require("../../utilities/error");
 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 version_1 = require("../../utilities/version");
+class CommandError extends Error {
+}
 /**
  * The set of packages that should have certain versions excluded from consideration
  * when attempting to find a compatible version for a package.
@@ -66,7 +90,7 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
             // `ng add @angular/localize -- --package-options`.
             .strict(false);
         const collectionName = await this.getCollectionName();
-        const workflow = await this.getOrCreateWorkflowForBuilder(collectionName);
+        const workflow = this.getOrCreateWorkflowForBuilder(collectionName);
         try {
             const collection = workflow.engine.createCollection(collectionName);
             const options = await this.getSchematicOptions(collection, this.schematicName, workflow);
@@ -102,135 +126,181 @@ class AddCommandModule extends schematics_command_module_1.SchematicsCommandModu
                 return this.executeSchematic({ ...options, collection: packageIdentifier.name });
             }
         }
-        const spinner = new spinner_1.Spinner();
-        spinner.start('Determining package manager...');
-        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 === 'range' &&
-            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, logger, {
-                    registry,
-                    usingYarn,
-                    verbose,
-                });
-            }
-            catch (e) {
-                (0, error_1.assertIsError)(e);
-                spinner.fail(`Unable to load package information from registry: ${e.message}`);
-                return 1;
-            }
-            // Start with the version tagged as `latest` if it exists
-            const latestManifest = packageMetadata.tags['latest'];
-            if (latestManifest) {
-                packageIdentifier = npm_package_arg_1.default.resolve(latestManifest.name, latestManifest.version);
-            }
-            // Adjust the version based on name and peer dependencies
-            if (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))) {
-                // 'latest' is invalid so search for most recent matching package
-                // Allow prelease versions if the CLI itself is a prerelease
-                const allowPrereleases = (0, semver_1.prerelease)(version_1.VERSION.full);
-                const versionExclusions = packageVersionExclusions[packageMetadata.name];
-                const versionManifests = Object.values(packageMetadata.versions).filter((value) => {
-                    // Prerelease versions are not stable and should not be considered by default
-                    if (!allowPrereleases && (0, semver_1.prerelease)(value.version)) {
-                        return false;
+        const taskContext = {
+            packageIdentifier,
+            executeSchematic: this.executeSchematic.bind(this),
+            hasMismatchedPeer: this.hasMismatchedPeer.bind(this),
+        };
+        const tasks = new listr2_1.Listr([
+            {
+                title: 'Determining Package Manager',
+                task(context, task) {
+                    context.usingYarn = packageManager.name === workspace_schema_1.PackageManager.Yarn;
+                    task.output = `Using package manager: ${listr2_1.color.dim(packageManager.name)}`;
+                },
+                rendererOptions: { persistentOutput: true },
+            },
+            {
+                title: 'Searching for compatible package version',
+                enabled: packageIdentifier.type === 'range' && packageIdentifier.rawSpec === '*',
+                async task(context, task) {
+                    (0, node_assert_1.default)(context.packageIdentifier.name, 'Registry package identifiers should always have a name.');
+                    // only package name provided; search for viable version
+                    // plus special cases for packages that did not have peer deps setup
+                    let packageMetadata;
+                    try {
+                        packageMetadata = await (0, package_metadata_1.fetchPackageMetadata)(context.packageIdentifier.name, logger, {
+                            registry,
+                            usingYarn: context.usingYarn,
+                            verbose,
+                        });
                     }
-                    // Deprecated versions should not be used or considered
-                    if (value.deprecated) {
-                        return false;
+                    catch (e) {
+                        (0, error_1.assertIsError)(e);
+                        throw new CommandError(`Unable to load package information from registry: ${e.message}`);
                     }
-                    // Excluded package versions should not be considered
-                    if (versionExclusions &&
-                        (0, semver_1.satisfies)(value.version, versionExclusions, { includePrerelease: true })) {
-                        return false;
+                    // Start with the version tagged as `latest` if it exists
+                    const latestManifest = packageMetadata.tags['latest'];
+                    if (latestManifest) {
+                        context.packageIdentifier = npm_package_arg_1.default.resolve(latestManifest.name, latestManifest.version);
                     }
-                    return true;
-                });
-                // Sort in reverse SemVer order so that the newest compatible version is chosen
-                versionManifests.sort((a, b) => (0, semver_1.compare)(b.version, a.version, true));
-                let newIdentifier;
-                for (const versionManifest of versionManifests) {
-                    if (!(await this.hasMismatchedPeer(versionManifest))) {
-                        newIdentifier = npm_package_arg_1.default.resolve(versionManifest.name, versionManifest.version);
-                        break;
+                    // Adjust the version based on name and peer dependencies
+                    if (latestManifest?.peerDependencies &&
+                        Object.keys(latestManifest.peerDependencies).length === 0) {
+                        task.output = `Found compatible package version: ${listr2_1.color.blue(latestManifest.version)}.`;
                     }
-                }
-                if (!newIdentifier) {
-                    spinner.warn("Unable to find compatible package. Using 'latest' tag.");
-                }
-                else {
-                    packageIdentifier = newIdentifier;
-                    spinner.succeed(`Found compatible package version: ${color_1.colors.grey(packageIdentifier.toString())}.`);
-                }
-            }
-            else {
-                spinner.succeed(`Found compatible package version: ${color_1.colors.grey(packageIdentifier.toString())}.`);
-            }
-        }
-        let collectionName = packageIdentifier.name;
-        let savePackage;
+                    else if (!latestManifest || (await context.hasMismatchedPeer(latestManifest))) {
+                        // 'latest' is invalid so search for most recent matching package
+                        // Allow prelease versions if the CLI itself is a prerelease
+                        const allowPrereleases = (0, semver_1.prerelease)(version_1.VERSION.full);
+                        const versionExclusions = packageVersionExclusions[packageMetadata.name];
+                        const versionManifests = Object.values(packageMetadata.versions).filter((value) => {
+                            // Prerelease versions are not stable and should not be considered by default
+                            if (!allowPrereleases && (0, semver_1.prerelease)(value.version)) {
+                                return false;
+                            }
+                            // Deprecated versions should not be used or considered
+                            if (value.deprecated) {
+                                return false;
+                            }
+                            // Excluded package versions should not be considered
+                            if (versionExclusions &&
+                                (0, semver_1.satisfies)(value.version, versionExclusions, { includePrerelease: true })) {
+                                return false;
+                            }
+                            return true;
+                        });
+                        // Sort in reverse SemVer order so that the newest compatible version is chosen
+                        versionManifests.sort((a, b) => (0, semver_1.compare)(b.version, a.version, true));
+                        let found = false;
+                        for (const versionManifest of versionManifests) {
+                            const mismatch = await context.hasMismatchedPeer(versionManifest);
+                            if (mismatch) {
+                                continue;
+                            }
+                            context.packageIdentifier = npm_package_arg_1.default.resolve(versionManifest.name, versionManifest.version);
+                            found = true;
+                        }
+                        if (!found) {
+                            task.output = "Unable to find compatible package. Using 'latest' tag.";
+                        }
+                        else {
+                            task.output = `Found compatible package version: ${listr2_1.color.blue(context.packageIdentifier.toString())}.`;
+                        }
+                    }
+                    else {
+                        task.output = `Found compatible package version: ${listr2_1.color.blue(context.packageIdentifier.toString())}.`;
+                    }
+                },
+                rendererOptions: { persistentOutput: true },
+            },
+            {
+                title: 'Loading package information from registry',
+                async task(context, task) {
+                    let manifest;
+                    try {
+                        manifest = await (0, package_metadata_1.fetchPackageManifest)(context.packageIdentifier.toString(), logger, {
+                            registry,
+                            verbose,
+                            usingYarn: context.usingYarn,
+                        });
+                    }
+                    catch (e) {
+                        (0, error_1.assertIsError)(e);
+                        throw new CommandError(`Unable to fetch package information for '${context.packageIdentifier}': ${e.message}`);
+                    }
+                    context.savePackage = manifest['ng-add']?.save;
+                    context.collectionName = manifest.name;
+                    if (await context.hasMismatchedPeer(manifest)) {
+                        task.output = listr2_1.color.yellow(listr2_1.figures.warning +
+                            ' Package has unmet peer dependencies. Adding the package may not succeed.');
+                    }
+                },
+                rendererOptions: { persistentOutput: true },
+            },
+            {
+                title: 'Confirming installation',
+                enabled: !skipConfirmation,
+                async task(context, task) {
+                    if (!(0, tty_1.isTTY)()) {
+                        task.output =
+                            `'--skip-confirmation' can be used to bypass installation confirmation. ` +
+                                `Ensure package name is correct prior to '--skip-confirmation' option usage.`;
+                        throw new CommandError('No terminal detected');
+                    }
+                    const { ListrInquirerPromptAdapter } = await Promise.resolve().then(() => __importStar(require('@listr2/prompt-adapter-inquirer')));
+                    const { confirm } = await Promise.resolve().then(() => __importStar(require('@inquirer/prompts')));
+                    const shouldProceed = await task.prompt(ListrInquirerPromptAdapter).run(confirm, {
+                        message: `The package ${listr2_1.color.blue(context.packageIdentifier.toString())} will be installed and executed.\n` +
+                            'Would you like to proceed?',
+                        default: true,
+                        theme: { prefix: '' },
+                    });
+                    if (!shouldProceed) {
+                        throw new CommandError('Command aborted');
+                    }
+                },
+                rendererOptions: { persistentOutput: true },
+            },
+            {
+                async task(context, task) {
+                    // Only show if installation will actually occur
+                    task.title = 'Installing package';
+                    if (context.savePackage === false) {
+                        task.title += ' in temporary location';
+                        // Temporary packages are located in a different directory
+                        // Hence we need to resolve them using the temp path
+                        const { success, tempNodeModules } = await packageManager.installTemp(context.packageIdentifier.toString(), registry ? [`--registry="${registry}"`] : undefined);
+                        const tempRequire = (0, module_1.createRequire)(tempNodeModules + '/');
+                        (0, node_assert_1.default)(context.collectionName, 'Collection name should always be available');
+                        const resolvedCollectionPath = tempRequire.resolve((0, path_1.join)(context.collectionName, 'package.json'));
+                        if (!success) {
+                            throw new CommandError('Unable to install package');
+                        }
+                        context.collectionName = (0, path_1.dirname)(resolvedCollectionPath);
+                    }
+                    else {
+                        const success = await packageManager.install(context.packageIdentifier.toString(), context.savePackage, registry ? [`--registry="${registry}"`] : undefined, undefined);
+                        if (!success) {
+                            throw new CommandError('Unable to install package');
+                        }
+                    }
+                },
+                rendererOptions: { bottomBar: Infinity },
+            },
+            // TODO: Rework schematic execution as a task and insert here
+        ]);
         try {
-            spinner.start('Loading package information from registry...');
-            const manifest = await (0, package_metadata_1.fetchPackageManifest)(packageIdentifier.toString(), logger, {
-                registry,
-                verbose,
-                usingYarn,
-            });
-            savePackage = manifest['ng-add']?.save;
-            collectionName = manifest.name;
-            if (await this.hasMismatchedPeer(manifest)) {
-                spinner.warn('Package has unmet peer dependencies. Adding the package may not succeed.');
-            }
-            else {
-                spinner.succeed(`Package information loaded.`);
-            }
+            const result = await tasks.run(taskContext);
+            (0, node_assert_1.default)(result.collectionName, 'Collection name should always be available');
+            return this.executeSchematic({ ...options, collection: result.collectionName });
         }
         catch (e) {
-            (0, error_1.assertIsError)(e);
-            spinner.fail(`Unable to fetch package information for '${packageIdentifier}': ${e.message}`);
-            return 1;
-        }
-        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)()) {
-                    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.`);
-                }
-                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 { success, tempNodeModules } = await packageManager.installTemp(packageIdentifier.raw, registry ? [`--registry="${registry}"`] : undefined);
-            const tempRequire = (0, module_1.createRequire)(tempNodeModules + '/');
-            const resolvedCollectionPath = tempRequire.resolve((0, path_1.join)(collectionName, 'package.json'));
-            if (!success) {
-                return 1;
-            }
-            collectionName = (0, path_1.dirname)(resolvedCollectionPath);
-        }
-        else {
-            const success = await packageManager.install(packageIdentifier.raw, savePackage, registry ? [`--registry="${registry}"`] : undefined);
-            if (!success) {
+            if (e instanceof CommandError) {
                 return 1;
             }
+            throw e;
         }
-        return this.executeSchematic({ ...options, collection: collectionName });
     }
     async isProjectVersionValid(packageIdentifier) {
         if (!packageIdentifier.name) {

package/src/commands/new/cli.js

@@ -30,7 +30,7 @@ class NewCommandModule extends schematics_command_module_1.SchematicsCommandModu
         const collectionName = typeof collectionNameFromArgs === 'string'
             ? collectionNameFromArgs
             : await this.getCollectionFromConfig();
-        const workflow = await this.getOrCreateWorkflowForBuilder(collectionName);
+        const workflow = this.getOrCreateWorkflowForBuilder(collectionName);
         const collection = workflow.engine.createCollection(collectionName);
         const options = await this.getSchematicOptions(collection, this.schematicName, workflow);
         return this.addSchemaOptionsToCommand(localYargs, options);

package/src/commands/update/cli.js

@@ -35,9 +35,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const schematics_1 = require("@angular-devkit/schematics");
 const tools_1 = require("@angular-devkit/schematics/tools");
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const module_1 = require("module");
+const listr2_1 = require("listr2");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
 const npm_package_arg_1 = __importDefault(require("npm-package-arg"));
 const npm_pick_manifest_1 = __importDefault(require("npm-pick-manifest"));
 const path = __importStar(require("path"));
@@ -56,6 +57,8 @@ const package_tree_1 = require("../../utilities/package-tree");
 const prompt_1 = require("../../utilities/prompt");
 const tty_1 = require("../../utilities/tty");
 const version_1 = require("../../utilities/version");
+class CommandError extends Error {
+}
 const ANGULAR_PACKAGES_REGEXP = /^@(?:angular|nguniversal)\//;
 const UPDATE_SCHEMATIC_COLLECTION = path.join(__dirname, 'schematic/collection.json');
 class UpdateCommandModule extends command_module_1.CommandModule {
@@ -188,7 +191,7 @@ class UpdateCommandModule extends command_module_1.CommandModule {
                 return 1;
             }
         }
-        logger.info(`Using package manager: ${color_1.colors.grey(packageManager.name)}`);
+        logger.info(`Using package manager: ${color_1.colors.gray(packageManager.name)}`);
         logger.info('Collecting installed dependencies...');
         const rootDependencies = await (0, package_tree_1.getProjectDependencies)(this.context.root);
         logger.info(`Found ${rootDependencies.size} dependencies.`);
@@ -233,12 +236,12 @@ class UpdateCommandModule extends command_module_1.CommandModule {
         }
         catch (e) {
             if (e instanceof schematics_1.UnsuccessfulWorkflowExecution) {
-                logger.error(`${color_1.colors.symbols.cross} Migration failed. See above for further details.\n`);
+                logger.error(`${color_1.figures.cross} Migration failed. See above for further details.\n`);
             }
             else {
                 (0, error_1.assertIsError)(e);
                 const logPath = (0, log_file_1.writeErrorToLogFile)(e);
-                logger.fatal(`${color_1.colors.symbols.cross} Migration failed: ${e.message}\n` +
+                logger.fatal(`${color_1.figures.cross} Migration failed: ${e.message}\n` +
                     `  See "${logPath}" for further details.\n`);
             }
             return { success: false, files: workflowSubscription.files };
@@ -308,7 +311,7 @@ class UpdateCommandModule extends command_module_1.CommandModule {
         const { logger } = this.context;
         for (const migration of migrations) {
             const { title, description } = getMigrationTitleAndDescription(migration);
-            logger.info(color_1.colors.cyan(color_1.colors.symbols.pointer) + ' ' + color_1.colors.bold(title));
+            logger.info(color_1.colors.cyan(color_1.figures.pointer) + ' ' + color_1.colors.bold(title));
             if (description) {
                 logger.info('  ' + description);
             }
@@ -390,14 +393,14 @@ class UpdateCommandModule extends command_module_1.CommandModule {
         }
         // Check if it is a package-local location
         const localMigrations = path.join(packagePath, migrations);
-        if ((0, fs_1.existsSync)(localMigrations)) {
+        if ((0, node_fs_1.existsSync)(localMigrations)) {
             migrations = localMigrations;
         }
         else {
             // Try to resolve from package location.
             // This avoids issues with package hoisting.
             try {
-                const packageRequire = (0, module_1.createRequire)(packagePath + '/');
+                const packageRequire = (0, node_module_1.createRequire)(packagePath + '/');
                 migrations = packageRequire.resolve(migrations, { paths: this.resolvePaths });
             }
             catch (e) {
@@ -540,17 +543,45 @@ class UpdateCommandModule extends command_module_1.CommandModule {
             packages: packagesToUpdate,
         });
         if (success) {
+            const { root: commandRoot, packageManager } = this.context;
+            const installArgs = this.packageManagerForce(options.verbose) ? ['--force'] : [];
+            const tasks = new listr2_1.Listr([
+                {
+                    title: 'Cleaning node modules directory',
+                    async task(_, task) {
+                        try {
+                            await node_fs_1.promises.rm(path.join(commandRoot, 'node_modules'), {
+                                force: true,
+                                recursive: true,
+                                maxRetries: 3,
+                            });
+                        }
+                        catch (e) {
+                            (0, error_1.assertIsError)(e);
+                            if (e.code === 'ENOENT') {
+                                task.skip('Cleaning not required. Node modules directory not found.');
+                            }
+                        }
+                    },
+                },
+                {
+                    title: 'Installing packages',
+                    async task() {
+                        const installationSuccess = await packageManager.installAll(installArgs, commandRoot);
+                        if (!installationSuccess) {
+                            throw new CommandError('Unable to install packages');
+                        }
+                    },
+                },
+            ]);
             try {
-                await fs_1.promises.rm(path.join(this.context.root, 'node_modules'), {
-                    force: true,
-                    recursive: true,
-                    maxRetries: 3,
-                });
+                await tasks.run();
             }
-            catch { }
-            const installationSuccess = await this.context.packageManager.installAll(this.packageManagerForce(options.verbose) ? ['--force'] : [], this.context.root);
-            if (!installationSuccess) {
-                return 1;
+            catch (e) {
+                if (e instanceof CommandError) {
+                    return 1;
+                }
+                throw e;
             }
         }
         if (success && options.createCommits) {
@@ -562,7 +593,7 @@ class UpdateCommandModule extends command_module_1.CommandModule {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const migrations = global.externalMigrations;
         if (success && migrations) {
-            const rootRequire = (0, module_1.createRequire)(this.context.root + '/');
+            const rootRequire = (0, node_module_1.createRequire)(this.context.root + '/');
             for (const migration of migrations) {
                 // Resolve the package from the workspace root, as otherwise it will be resolved from the temp
                 // installed CLI version.
@@ -600,14 +631,14 @@ class UpdateCommandModule extends command_module_1.CommandModule {
                 let migrations;
                 // Check if it is a package-local location
                 const localMigrations = path.join(packagePath, migration.collection);
-                if ((0, fs_1.existsSync)(localMigrations)) {
+                if ((0, node_fs_1.existsSync)(localMigrations)) {
                     migrations = localMigrations;
                 }
                 else {
                     // Try to resolve from package location.
                     // This avoids issues with package hoisting.
                     try {
-                        const packageRequire = (0, module_1.createRequire)(packagePath + '/');
+                        const packageRequire = (0, node_module_1.createRequire)(packagePath + '/');
                         migrations = packageRequire.resolve(migration.collection);
                     }
                     catch (e) {
@@ -672,11 +703,11 @@ class UpdateCommandModule extends command_module_1.CommandModule {
     }
     checkCleanGit() {
         try {
-            const topLevel = (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+            const topLevel = (0, node_child_process_1.execSync)('git rev-parse --show-toplevel', {
                 encoding: 'utf8',
                 stdio: 'pipe',
             });
-            const result = (0, child_process_1.execSync)('git status --porcelain', { encoding: 'utf8', stdio: 'pipe' });
+            const result = (0, node_child_process_1.execSync)('git status --porcelain', { encoding: 'utf8', stdio: 'pipe' });
             if (result.trim().length === 0) {
                 return true;
             }
@@ -736,8 +767,8 @@ class UpdateCommandModule extends command_module_1.CommandModule {
         const packageJsonPath = (0, path_1.join)(pkgLocation, 'package.json');
         // Get a binary location for this package
         let binPath;
-        if ((0, fs_1.existsSync)(packageJsonPath)) {
-            const content = await fs_1.promises.readFile(packageJsonPath, 'utf-8');
+        if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+            const content = await node_fs_1.promises.readFile(packageJsonPath, 'utf-8');
             if (content) {
                 const { bin = {} } = JSON.parse(content);
                 const binKeys = Object.keys(bin);
@@ -749,7 +780,7 @@ class UpdateCommandModule extends command_module_1.CommandModule {
         if (!binPath) {
             throw new Error(`Cannot locate bin for temporary package: ${packageNameNoVersion}.`);
         }
-        const { status, error } = (0, child_process_1.spawnSync)(process.execPath, [binPath, ...args], {
+        const { status, error } = (0, node_child_process_1.spawnSync)(process.execPath, [binPath, ...args], {
             stdio: 'inherit',
             env: {
                 ...process.env,
@@ -789,7 +820,7 @@ class UpdateCommandModule extends command_module_1.CommandModule {
         if (!(0, tty_1.isTTY)()) {
             for (const migration of optionalMigrations) {
                 const { title } = getMigrationTitleAndDescription(migration);
-                logger.info(color_1.colors.cyan(color_1.colors.symbols.pointer) + ' ' + color_1.colors.bold(title));
+                logger.info(color_1.colors.cyan(color_1.figures.pointer) + ' ' + color_1.colors.bold(title));
                 logger.info(color_1.colors.gray(`  ng update ${packageName} --name ${migration.name}`));
                 logger.info(''); // Extra trailing newline.
             }
@@ -815,7 +846,7 @@ exports.default = UpdateCommandModule;
 function hasChangesToCommit() {
     // List all modified files not covered by .gitignore.
     // If any files are returned, then there must be something to commit.
-    return (0, child_process_1.execSync)('git ls-files -m -d -o --exclude-standard').toString() !== '';
+    return (0, node_child_process_1.execSync)('git ls-files -m -d -o --exclude-standard').toString() !== '';
 }
 /**
  * Precondition: Must have pending changes to commit, they do not need to be staged.
@@ -824,16 +855,16 @@ function hasChangesToCommit() {
  */
 function createCommit(message) {
     // Stage entire working tree for commit.
-    (0, child_process_1.execSync)('git add -A', { encoding: 'utf8', stdio: 'pipe' });
+    (0, node_child_process_1.execSync)('git add -A', { encoding: 'utf8', stdio: 'pipe' });
     // Commit with the message passed via stdin to avoid bash escaping issues.
-    (0, child_process_1.execSync)('git commit --no-verify -F -', { encoding: 'utf8', stdio: 'pipe', input: message });
+    (0, node_child_process_1.execSync)('git commit --no-verify -F -', { encoding: 'utf8', stdio: 'pipe', input: message });
 }
 /**
  * @return The Git SHA hash of the HEAD commit. Returns null if unable to retrieve the hash.
  */
 function findCurrentGitSha() {
     try {
-        return (0, child_process_1.execSync)('git rev-parse HEAD', { encoding: 'utf8', stdio: 'pipe' }).trim();
+        return (0, node_child_process_1.execSync)('git rev-parse HEAD', { encoding: 'utf8', stdio: 'pipe' }).trim();
     }
     catch {
         return null;

package/src/utilities/color.d.ts

@@ -5,6 +5,5 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import * as ansiColors from 'ansi-colors';
-declare const colors: typeof ansiColors;
-export { colors };
+export { color as colors, figures } from 'listr2';
+export declare function supportColor(stream?: NodeJS.WritableStream): boolean;