@angular/cli 11.1.4 → 11.2.0

package/commands/add-impl.js

@@ -19,6 +19,7 @@ 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 spinner_1 = require("../utilities/spinner");
 const npa = require('npm-package-arg');
 class AddCommand extends schematic_command_1.SchematicCommand {
     constructor() {
@@ -71,11 +72,15 @@ class AddCommand extends schematic_command_1.SchematicCommand {
                 return this.executeSchematic(packageIdentifier.name, options['--']);
             }
         }
+        const spinner = new spinner_1.Spinner();
+        spinner.start('Determining package manager...');
         const packageManager = await package_manager_1.getPackageManager(this.context.root);
         const usingYarn = packageManager === schema_1.PackageManager.Yarn;
+        spinner.info(`Using package manager: ${color_1.colors.grey(packageManager)}`);
         if (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 package_metadata_1.fetchPackageMetadata(packageIdentifier.name, this.logger, {
@@ -85,7 +90,7 @@ class AddCommand extends schematic_command_1.SchematicCommand {
                 });
             }
             catch (e) {
-                this.logger.error('Unable to fetch package metadata: ' + e.message);
+                spinner.fail('Unable to load package information from registry: ' + e.message);
                 return 1;
             }
             const latestManifest = packageMetadata.tags['latest'];
@@ -99,6 +104,10 @@ class AddCommand extends schematic_command_1.SchematicCommand {
                         packageIdentifier = npa.resolve('@angular/pwa', '0.12');
                     }
                 }
+                else {
+                    packageIdentifier = npa.resolve(latestManifest.name, latestManifest.version);
+                }
+                spinner.succeed(`Found compatible package version: ${color_1.colors.grey(packageIdentifier)}.`);
             }
             else if (!latestManifest || (await this.hasMismatchedPeer(latestManifest))) {
                 // 'latest' is invalid so search for most recent matching package
@@ -112,16 +121,22 @@ class AddCommand extends schematic_command_1.SchematicCommand {
                     }
                 }
                 if (!newIdentifier) {
-                    this.logger.warn("Unable to find compatible package.  Using 'latest'.");
+                    spinner.warn("Unable to find compatible package.  Using 'latest'.");
                 }
                 else {
                     packageIdentifier = newIdentifier;
+                    spinner.succeed(`Found compatible package version: ${color_1.colors.grey(packageIdentifier)}.`);
                 }
             }
+            else {
+                packageIdentifier = npa.resolve(latestManifest.name, latestManifest.version);
+                spinner.succeed(`Found compatible package version: ${color_1.colors.grey(packageIdentifier)}.`);
+            }
         }
         let collectionName = packageIdentifier.name;
         let savePackage;
         try {
+            spinner.start('Loading package information from registry...');
             const manifest = await package_metadata_1.fetchPackageManifest(packageIdentifier, this.logger, {
                 registry: options.registry,
                 verbose: options.verbose,
@@ -130,24 +145,35 @@ class AddCommand extends schematic_command_1.SchematicCommand {
             savePackage = (_a = manifest['ng-add']) === null || _a === void 0 ? void 0 : _a.save;
             collectionName = manifest.name;
             if (await this.hasMismatchedPeer(manifest)) {
-                this.logger.warn('Package has unmet peer dependencies. Adding the package may not succeed.');
+                spinner.warn('Package has unmet peer dependencies. Adding the package may not succeed.');
+            }
+            else {
+                spinner.succeed(`Package information loaded.`);
             }
         }
         catch (e) {
-            this.logger.error('Unable to fetch package manifest: ' + e.message);
+            spinner.fail(`Unable to fetch package information for '${packageIdentifier}': ${e.message}`);
             return 1;
         }
-        if (savePackage === false) {
-            // Temporary packages are located in a different directory
-            // Hence we need to resolve them using the temp path
-            const tempPath = install_package_1.installTempPackage(packageIdentifier.raw, this.logger, packageManager, options.registry ? [`--registry="${options.registry}"`] : undefined);
-            const resolvedCollectionPath = require.resolve(path_1.join(collectionName, 'package.json'), {
-                paths: [tempPath],
-            });
-            collectionName = path_1.dirname(resolvedCollectionPath);
+        try {
+            spinner.start('Installing package...');
+            if (savePackage === false) {
+                // Temporary packages are located in a different directory
+                // Hence we need to resolve them using the temp path
+                const tempPath = install_package_1.installTempPackage(packageIdentifier.raw, undefined, packageManager, options.registry ? [`--registry="${options.registry}"`] : undefined);
+                const resolvedCollectionPath = require.resolve(path_1.join(collectionName, 'package.json'), {
+                    paths: [tempPath],
+                });
+                collectionName = path_1.dirname(resolvedCollectionPath);
+            }
+            else {
+                install_package_1.installPackage(packageIdentifier.raw, undefined, packageManager, savePackage, options.registry ? [`--registry="${options.registry}"`] : undefined);
+            }
+            spinner.succeed('Package successfully installed.');
         }
-        else {
-            install_package_1.installPackage(packageIdentifier.raw, this.logger, packageManager, savePackage, options.registry ? [`--registry="${options.registry}"`] : undefined);
+        catch (error) {
+            spinner.fail(`Package installation failed: ${error.message}`);
+            return 1;
         }
         return this.executeSchematic(collectionName, options['--']);
     }

package/commands/doc-impl.js

@@ -8,8 +8,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocCommand = void 0;
+const open = require("open");
 const command_1 = require("../models/command");
-const open = require('open');
 class DocCommand extends command_1.Command {
     async run(options) {
         if (!options.keyword) {
@@ -36,7 +36,7 @@ class DocCommand extends command_1.Command {
             // and use it if we can find it
             try {
                 /* tslint:disable-next-line:no-implicit-dependencies */
-                const currentNgVersion = require('@angular/core').VERSION.major;
+                const currentNgVersion = (await Promise.resolve().then(() => require('@angular/core'))).VERSION.major;
                 domain = `v${currentNgVersion}.angular.io`;
             }
             catch (e) { }

package/commands/lint-long.md

@@ -4,4 +4,4 @@ When a project name is not supplied, it will execute for all projects.
 The default linting tool is [TSLint](https://palantir.github.io/tslint/), and the default configuration is specified in the project's `tslint.json` file.
 
 **Note**: TSLint has been discontinued and support has been deprecated in the Angular CLI. The options shown below are for the deprecated TSLint builder.
-To opt-in using the community driven ESLint builder, see [angular-eslint](https://github.com/angular-eslint/angular-eslint#migrating-from-codelyzer-and-tslint) README.
+To opt-in using the community driven ESLint builder, see [angular-eslint](https://github.com/angular-eslint/angular-eslint#migrating-an-angular-cli-project-from-codelyzer-and-tslint) README.

package/commands/new-impl.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NewCommand = void 0;
 const schematic_command_1 = require("../models/schematic-command");
-const package_manager_1 = require("../utilities/package-manager");
 class NewCommand extends schematic_command_1.SchematicCommand {
     constructor() {
         super(...arguments);
@@ -14,7 +13,6 @@ class NewCommand extends schematic_command_1.SchematicCommand {
         return super.initialize(options);
     }
     async run(options) {
-        await package_manager_1.ensureCompatibleNpm(this.context.root);
         // Register the version of the CLI in the registry.
         const packageJson = require('../package.json');
         const version = packageJson.version;

package/commands/update-impl.js

@@ -16,6 +16,7 @@ const path = require("path");
 const semver = require("semver");
 const schema_1 = require("../lib/config/schema");
 const command_1 = require("../models/command");
+const schematic_engine_host_1 = require("../models/schematic-engine-host");
 const color_1 = require("../utilities/color");
 const install_package_1 = require("../utilities/install-package");
 const log_file_1 = require("../utilities/log-file");
@@ -49,6 +50,7 @@ class UpdateCommand extends command_1.Command {
             // Otherwise, use packages from the active workspace (migrations)
             resolvePaths: [__dirname, this.context.root],
             schemaValidation: true,
+            engineHostCreator: (options) => new schematic_engine_host_1.SchematicEngineHost(options.resolvePaths),
         });
     }
     async executeSchematic(collection, schematic, options = {}) {
@@ -189,24 +191,6 @@ class UpdateCommand extends command_1.Command {
     async run(options) {
         var _a;
         await package_manager_1.ensureCompatibleNpm(this.context.root);
-        // Check if the @angular-devkit/schematics package can be resolved from the workspace root
-        // This works around issues with packages containing migrations that cannot directly depend on the package
-        // This check can be removed once the schematic runtime handles this situation
-        try {
-            require.resolve('@angular-devkit/schematics', { paths: [this.context.root] });
-        }
-        catch (e) {
-            if (e.code === 'MODULE_NOT_FOUND') {
-                this.logger.fatal('The "@angular-devkit/schematics" package cannot be resolved from the workspace root directory. ' +
-                    'This may be due to an unsupported node modules structure.\n' +
-                    'Please remove both the "node_modules" directory and the package lock file; and then reinstall.\n' +
-                    'If this does not correct the problem, ' +
-                    'please temporarily install the "@angular-devkit/schematics" package within the workspace. ' +
-                    'It can be removed once the update is complete.');
-                return 1;
-            }
-            throw e;
-        }
         // Check if the current installed CLI version is older than the latest version.
         if (!disableVersionCheck && await this.checkCLILatestVersion(options.verbose, options.next)) {
             this.logger.warn(`The installed local Angular CLI version is older than the latest ${options.next ? 'pre-release' : 'stable'} version.\n` +

package/models/schematic-command.js

@@ -21,6 +21,7 @@ const tty_1 = require("../utilities/tty");
 const analytics_1 = require("./analytics");
 const command_1 = require("./command");
 const parser_1 = require("./parser");
+const schematic_engine_host_1 = require("./schematic-engine-host");
 class UnknownCollectionError extends Error {
     constructor(collectionName) {
         super(`Invalid collection (${collectionName}).`);
@@ -176,6 +177,7 @@ class SchematicCommand extends command_1.Command {
                     ...current,
                 }),
             ],
+            engineHostCreator: (options) => new schematic_engine_host_1.SchematicEngineHost(options.resolvePaths),
         });
         const getProjectName = () => {
             if (this.workspace) {
@@ -264,16 +266,6 @@ class SchematicCommand extends command_1.Command {
                                     };
                             });
                             break;
-                        case 'input':
-                            if (definition.propertyTypes.size === 1 &&
-                                (definition.propertyTypes.has('number') ||
-                                    definition.propertyTypes.has('integer'))) {
-                                question.type = 'number';
-                            }
-                            else {
-                                question.type = 'input';
-                            }
-                            break;
                         default:
                             question.type = definition.type;
                             break;
@@ -391,6 +383,13 @@ class SchematicCommand extends command_1.Command {
                 error = false;
             }
         });
+        // Temporary compatibility check for NPM 7
+        if (collectionName === '@schematics/angular' && schematicName === 'ng-new') {
+            if (!input.skipInstall &&
+                (input.packageManager === undefined || input.packageManager === 'npm')) {
+                await package_manager_1.ensureCompatibleNpm(this.context.root);
+            }
+        }
         return new Promise(resolve => {
             workflow
                 .execute({

package/models/schematic-engine-host.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google Inc. 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 { RuleFactory } from '@angular-devkit/schematics';
+import { NodeModulesEngineHost } from '@angular-devkit/schematics/tools';
+export declare class SchematicEngineHost extends NodeModulesEngineHost {
+    protected _resolveReferenceString(refString: string, parentPath: string): {
+        ref: RuleFactory<{}>;
+        path: string;
+    } | null;
+}

package/models/schematic-engine-host.js

@@ -0,0 +1,155 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchematicEngineHost = void 0;
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+const schematics_1 = require("@angular-devkit/schematics");
+const tools_1 = require("@angular-devkit/schematics/tools");
+const fs_1 = require("fs");
+const jsonc_parser_1 = require("jsonc-parser");
+const path_1 = require("path");
+const vm_1 = require("vm");
+/**
+ * Environment variable to control schematic package redirection
+ * Default: Angular schematics only
+ */
+const schematicRedirectVariable = (_a = process.env['NG_SCHEMATIC_REDIRECT']) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+function shouldWrapSchematic(schematicFile) {
+    // Check environment variable if present
+    if (schematicRedirectVariable !== undefined) {
+        switch (schematicRedirectVariable) {
+            case '0':
+            case 'false':
+            case 'off':
+            case 'none':
+                return false;
+            case 'all':
+                return true;
+        }
+    }
+    // Never wrap `@schematics/update` when executed directly
+    // It communicates with the update command via `global`
+    if (/[\/\\]node_modules[\/\\]@schematics[\/\\]update[\/\\]/.test(schematicFile)) {
+        return false;
+    }
+    // Default is only first-party Angular schematic packages
+    // Angular schematics are safe to use in the wrapped VM context
+    return /[\/\\]node_modules[\/\\]@(?:angular|schematics|nguniversal)[\/\\]/.test(schematicFile);
+}
+class SchematicEngineHost extends tools_1.NodeModulesEngineHost {
+    _resolveReferenceString(refString, parentPath) {
+        const [path, name] = refString.split('#', 2);
+        // Mimic behavior of ExportStringRef class used in default behavior
+        const fullPath = path[0] === '.' ? path_1.resolve(parentPath !== null && parentPath !== void 0 ? parentPath : process.cwd(), path) : path;
+        const schematicFile = require.resolve(fullPath, { paths: [parentPath] });
+        if (shouldWrapSchematic(schematicFile)) {
+            const schematicPath = path_1.dirname(schematicFile);
+            const moduleCache = new Map();
+            const factoryInitializer = wrap(schematicFile, schematicPath, moduleCache, name || 'default');
+            const factory = factoryInitializer();
+            if (!factory || typeof factory !== 'function') {
+                return null;
+            }
+            return { ref: factory, path: schematicPath };
+        }
+        // All other schematics use default behavior
+        return super._resolveReferenceString(refString, parentPath);
+    }
+}
+exports.SchematicEngineHost = SchematicEngineHost;
+/**
+ * Minimal shim modules for legacy deep imports of `@schematics/angular`
+ */
+const legacyModules = {
+    '@schematics/angular/utility/config': {
+        getWorkspace(host) {
+            const path = '/.angular.json';
+            const data = host.read(path);
+            if (!data) {
+                throw new schematics_1.SchematicsException(`Could not find (${path})`);
+            }
+            return jsonc_parser_1.parse(data.toString(), [], { allowTrailingComma: true });
+        },
+    },
+    '@schematics/angular/utility/project': {
+        buildDefaultPath(project) {
+            const root = project.sourceRoot ? `/${project.sourceRoot}/` : `/${project.root}/src/`;
+            return `${root}${project.projectType === 'application' ? 'app' : 'lib'}`;
+        },
+    },
+};
+/**
+ * Wrap a JavaScript file in a VM context to allow specific Angular dependencies to be redirected.
+ * This VM setup is ONLY intended to redirect dependencies.
+ *
+ * @param schematicFile A JavaScript schematic file path that should be wrapped.
+ * @param schematicDirectory A directory that will be used as the location of the JavaScript file.
+ * @param moduleCache A map to use for caching repeat module usage and proper `instanceof` support.
+ * @param exportName An optional name of a specific export to return. Otherwise, return all exports.
+ */
+function wrap(schematicFile, schematicDirectory, moduleCache, exportName) {
+    const { createRequire, createRequireFromPath } = require('module');
+    // Node.js 10.x does not support `createRequire` so fallback to `createRequireFromPath`
+    // `createRequireFromPath` is deprecated in 12+ and can be removed once 10.x support is removed
+    const scopedRequire = (createRequire === null || createRequire === void 0 ? void 0 : createRequire(schematicFile)) || createRequireFromPath(schematicFile);
+    const customRequire = function (id) {
+        if (legacyModules[id]) {
+            // Provide compatibility modules for older versions of @angular/cdk
+            return legacyModules[id];
+        }
+        else if (id.startsWith('@angular-devkit/') || id.startsWith('@schematics/')) {
+            // Resolve from inside the `@angular/cli` project
+            const packagePath = require.resolve(id);
+            return require(packagePath);
+        }
+        else if (id.startsWith('.') || id.startsWith('@angular/cdk')) {
+            // Wrap relative files inside the schematic collection
+            // Also wrap `@angular/cdk`, it contains helper utilities that import core schematic packages
+            // Resolve from the original file
+            const modulePath = scopedRequire.resolve(id);
+            // Use cached module if available
+            const cachedModule = moduleCache.get(modulePath);
+            if (cachedModule) {
+                return cachedModule;
+            }
+            // Do not wrap vendored third-party packages or JSON files
+            if (!/[\/\\]node_modules[\/\\]@schematics[\/\\]angular[\/\\]third_party[\/\\]/.test(modulePath) &&
+                !modulePath.endsWith('.json')) {
+                // Wrap module and save in cache
+                const wrappedModule = wrap(modulePath, path_1.dirname(modulePath), moduleCache)();
+                moduleCache.set(modulePath, wrappedModule);
+                return wrappedModule;
+            }
+        }
+        // All others are required directly from the original file
+        return scopedRequire(id);
+    };
+    // Setup a wrapper function to capture the module's exports
+    const schematicCode = fs_1.readFileSync(schematicFile, 'utf8');
+    // `module` is required due to @angular/localize ng-add being in UMD format
+    const headerCode = '(function() {\nvar exports = {};\nvar module = { exports };\n';
+    const footerCode = exportName ? `\nreturn exports['${exportName}'];});` : '\nreturn exports;});';
+    const script = new vm_1.Script(headerCode + schematicCode + footerCode, {
+        filename: schematicFile,
+        lineOffset: 3,
+    });
+    const context = {
+        __dirname: schematicDirectory,
+        __filename: schematicFile,
+        Buffer,
+        console,
+        process,
+        get global() {
+            return this;
+        },
+        require: customRequire,
+    };
+    const exportsFactory = script.runInNewContext(context);
+    return exportsFactory;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/cli",
-  "version": "11.1.4",
+  "version": "11.2.0",
   "description": "CLI tool for Angular",
   "main": "lib/cli/index.js",
   "bin": {
@@ -28,11 +28,11 @@
   },
   "homepage": "https://github.com/angular/angular-cli",
   "dependencies": {
-    "@angular-devkit/architect": "0.1101.4",
-    "@angular-devkit/core": "11.1.4",
-    "@angular-devkit/schematics": "11.1.4",
-    "@schematics/angular": "11.1.4",
-    "@schematics/update": "0.1101.4",
+    "@angular-devkit/architect": "0.1102.0",
+    "@angular-devkit/core": "11.2.0",
+    "@angular-devkit/schematics": "11.2.0",
+    "@schematics/angular": "11.2.0",
+    "@schematics/update": "0.1102.0",
     "@yarnpkg/lockfile": "1.1.0",
     "ansi-colors": "4.1.1",
     "debug": "4.3.1",
@@ -41,8 +41,9 @@
     "jsonc-parser": "3.0.0",
     "npm-package-arg": "8.1.0",
     "npm-pick-manifest": "6.1.0",
-    "open": "7.3.1",
-    "pacote": "11.1.14",
+    "open": "7.4.0",
+    "ora": "5.3.0",
+    "pacote": "11.2.4",
     "resolve": "1.19.0",
     "rimraf": "3.0.2",
     "semver": "7.3.4",
@@ -53,12 +54,12 @@
   "ng-update": {
     "migrations": "@schematics/angular/migrations/migration-collection.json",
     "packageGroup": {
-      "@angular/cli": "11.1.4",
-      "@angular-devkit/architect": "0.1101.4",
-      "@angular-devkit/build-angular": "0.1101.4",
-      "@angular-devkit/build-webpack": "0.1101.4",
-      "@angular-devkit/core": "11.1.4",
-      "@angular-devkit/schematics": "11.1.4"
+      "@angular/cli": "11.2.0",
+      "@angular-devkit/architect": "0.1102.0",
+      "@angular-devkit/build-angular": "0.1102.0",
+      "@angular-devkit/build-webpack": "0.1102.0",
+      "@angular-devkit/core": "11.2.0",
+      "@angular-devkit/schematics": "11.2.0"
     }
   },
   "engines": {

package/utilities/install-package.d.ts

@@ -8,6 +8,6 @@
 import { logging } from '@angular-devkit/core';
 import { PackageManager } from '../lib/config/schema';
 import { NgAddSaveDepedency } from '../utilities/package-metadata';
-export declare function installPackage(packageName: string, logger: logging.Logger, packageManager?: PackageManager, save?: Exclude<NgAddSaveDepedency, false>, extraArgs?: string[], cwd?: string): void;
-export declare function installTempPackage(packageName: string, logger: logging.Logger, packageManager?: PackageManager, extraArgs?: string[]): string;
+export declare function installPackage(packageName: string, logger: logging.Logger | undefined, packageManager?: PackageManager, save?: Exclude<NgAddSaveDepedency, false>, extraArgs?: string[], cwd?: string): void;
+export declare function installTempPackage(packageName: string, logger: logging.Logger | undefined, packageManager?: PackageManager, extraArgs?: string[]): string;
 export declare function runTempPackageBin(packageName: string, logger: logging.Logger, packageManager?: PackageManager, args?: string[]): number;

package/utilities/install-package.js

@@ -22,7 +22,7 @@ function installPackage(packageName, logger, packageManager = schema_1.PackageMa
         packageName,
         packageManagerArgs.silent,
     ];
-    logger.info(color_1.colors.green(`Installing packages for tooling via ${packageManager}.`));
+    logger === null || logger === void 0 ? void 0 : logger.info(color_1.colors.green(`Installing packages for tooling via ${packageManager}.`));
     if (save === 'devDependencies') {
         installArgs.push(packageManagerArgs.saveDev);
     }
@@ -39,7 +39,7 @@ function installPackage(packageName, logger, packageManager = schema_1.PackageMa
         }
         throw new Error(errorMessage + `Package install failed${errorMessage ? ', see above' : ''}.`);
     }
-    logger.info(color_1.colors.green(`Installed packages for tooling via ${packageManager}.`));
+    logger === null || logger === void 0 ? void 0 : logger.info(color_1.colors.green(`Installed packages for tooling via ${packageManager}.`));
 }
 exports.installPackage = installPackage;
 function installTempPackage(packageName, logger, packageManager = schema_1.PackageManager.Npm, extraArgs) {

package/utilities/package-manager.js

@@ -67,13 +67,14 @@ async function ensureCompatibleNpm(root) {
     try {
         const version = child_process_1.execSync('npm --version', { encoding: 'utf8', stdio: 'pipe' }).trim();
         const major = Number((_a = version.match(/^(\d+)\./)) === null || _a === void 0 ? void 0 : _a[1]);
-        if (major === 6) {
+        if (major <= 6) {
             return;
         }
         // tslint:disable-next-line: no-console
-        console.error(`npm version ${version} detected.\n` +
-            'The Angular CLI currently requires npm version 6.\n\n' +
-            'Please install a compatible version to proceed (`npm install --global npm@6`).\n');
+        console.error(`npm version ${version} detected. The Angular CLI temporarily requires npm version 6 while upstream issues are addressed.\n\n` +
+            'Please install a compatible version to proceed (`npm install --global npm@6`).\n' +
+            'For additional information and alternative workarounds, please see ' +
+            'https://github.com/angular/angular-cli/issues/19957#issuecomment-775407654');
         process.exit(3);
     }
     catch (_b) {

package/utilities/spinner.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+export declare class Spinner {
+    private readonly spinner;
+    /** When false, only fail messages will be displayed. */
+    enabled: boolean;
+    constructor(text?: string);
+    set text(text: string);
+    succeed(text?: string): void;
+    info(text?: string): void;
+    fail(text?: string): void;
+    warn(text?: string): void;
+    stop(): void;
+    start(text?: string): void;
+}

package/utilities/spinner.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google Inc. 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.Spinner = void 0;
+const ora = require("ora");
+const color_1 = require("./color");
+class Spinner {
+    constructor(text) {
+        /** When false, only fail messages will be displayed. */
+        this.enabled = true;
+        this.spinner = ora({
+            text,
+            // The below 2 options are needed because otherwise CTRL+C will be delayed
+            // when the underlying process is sync.
+            hideCursor: false,
+            discardStdin: false,
+        });
+    }
+    set text(text) {
+        this.spinner.text = text;
+    }
+    succeed(text) {
+        if (this.enabled) {
+            this.spinner.succeed(text);
+        }
+    }
+    info(text) {
+        this.spinner.info(text);
+    }
+    fail(text) {
+        this.spinner.fail(text && color_1.colors.redBright(text));
+    }
+    warn(text) {
+        this.spinner.fail(text && color_1.colors.yellowBright(text));
+    }
+    stop() {
+        this.spinner.stop();
+    }
+    start(text) {
+        if (this.enabled) {
+            this.spinner.start(text);
+        }
+    }
+}
+exports.Spinner = Spinner;