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

package/src/commands/version/cli.js

@@ -11,7 +11,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VersionCommandModule = void 0;
-const child_process_1 = require("child_process");
 const module_1 = __importDefault(require("module"));
 const path_1 = require("path");
 const command_module_1 = require("../../command-builder/command-module");
@@ -43,10 +42,11 @@ class VersionCommandModule extends command_module_1.CommandModule {
         return localYargs;
     }
     async run() {
-        const logger = this.context.logger;
+        var _a;
+        const { packageManager, logger, root } = this.context;
         const localRequire = module_1.default.createRequire((0, path_1.resolve)(__filename, '../../../'));
         // Trailing slash is used to allow the path to be treated as a directory
-        const workspaceRequire = module_1.default.createRequire(this.context.root + '/');
+        const workspaceRequire = module_1.default.createRequire(root + '/');
         const cliPackage = localRequire('./package.json');
         let workspacePackage;
         try {
@@ -100,7 +100,7 @@ class VersionCommandModule extends command_module_1.CommandModule {
         logger.info(`
       Angular CLI: ${ngCliVersion}
       Node: ${process.versions.node}${unsupportedNodeVersion ? ' (Unsupported)' : ''}
-      Package Manager: ${this.getPackageManagerVersion()}
+      Package Manager: ${packageManager.name} ${(_a = packageManager.version) !== null && _a !== void 0 ? _a : '<error>'} 
       OS: ${process.platform} ${process.arch}
 
       Angular: ${angularCoreVersion}
@@ -157,24 +157,5 @@ class VersionCommandModule extends command_module_1.CommandModule {
         }
         return '<error>';
     }
-    getPackageManagerVersion() {
-        try {
-            const manager = this.context.packageManager;
-            const version = (0, child_process_1.execSync)(`${manager} --version`, {
-                encoding: 'utf8',
-                stdio: ['ignore', 'pipe', 'ignore'],
-                env: {
-                    ...process.env,
-                    //  NPM updater notifier will prevents the child process from closing until it timeout after 3 minutes.
-                    NO_UPDATE_NOTIFIER: '1',
-                    NPM_CONFIG_UPDATE_NOTIFIER: 'false',
-                },
-            }).trim();
-            return `${manager} ${version}`;
-        }
-        catch {
-            return '<error>';
-        }
-    }
 }
 exports.VersionCommandModule = VersionCommandModule;

package/src/typings-bazel.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
+ */
+
+/* eslint-disable import/no-extraneous-dependencies */
+// Workaround for https://github.com/bazelbuild/rules_nodejs/issues/1033
+// Alternative approach instead of https://github.com/angular/angular/pull/33226
+declare module '@yarnpkg/lockfile' {
+  export * from '@types/yarnpkg__lockfile';
+}

package/src/typings.d.ts

@@ -5,20 +5,7 @@
  * 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
  */
-declare module '@yarnpkg/lockfile' {
-    function parse(data: string): Record<string, any>;
-}
-declare module 'ini' {
-    function parse(data: string): Record<string, any>;
-}
 declare module 'npm-pick-manifest' {
     function pickManifest(metadata: import('./utilities/package-metadata').PackageMetadata, selector: string): import('./utilities/package-metadata').PackageManifest;
     export = pickManifest;
 }
-declare module 'pacote' {
-    function manifest(specifier: string, options: Record<string, unknown>): Promise<{
-        name: string;
-        version: string;
-    }>;
-    function packument(specifier: string, options: Record<string, unknown>): Promise<import('./utilities/package-metadata').NpmRepositoryPackageJson>;
-}

package/src/utilities/config.d.ts

@@ -20,7 +20,7 @@ export declare class AngularWorkspace {
     getProjectCli(projectName: string): Record<string, any>;
     static load(workspaceFilePath: string): Promise<AngularWorkspace>;
 }
-export declare function getWorkspace(level?: 'local' | 'global'): Promise<AngularWorkspace | null>;
+export declare function getWorkspace(level?: 'local' | 'global'): Promise<AngularWorkspace | undefined>;
 export declare function createGlobalSettings(): string;
 export declare function getWorkspaceRaw(level?: 'local' | 'global'): [JSONFile | null, string | null];
 export declare function validateWorkspace(data: json.JsonObject): Promise<void>;
@@ -28,4 +28,3 @@ export declare function getProjectByCwd(workspace: AngularWorkspace): string | n
 export declare function getConfiguredPackageManager(): Promise<PackageManager | null>;
 export declare function getSchematicDefaults(collection: string, schematic: string, project?: string | null): Promise<{}>;
 export declare function isWarningEnabled(warning: string): Promise<boolean>;
-export declare function getProjectsByPath(workspace: workspaces.WorkspaceDefinition, cwd: string, root: string): string[];

package/src/utilities/config.js

@@ -30,7 +30,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getProjectsByPath = exports.isWarningEnabled = exports.getSchematicDefaults = exports.getConfiguredPackageManager = exports.getProjectByCwd = exports.validateWorkspace = exports.getWorkspaceRaw = exports.createGlobalSettings = exports.getWorkspace = exports.AngularWorkspace = exports.workspaceSchemaPath = void 0;
+exports.isWarningEnabled = exports.getSchematicDefaults = exports.getConfiguredPackageManager = exports.getProjectByCwd = exports.validateWorkspace = exports.getWorkspaceRaw = exports.createGlobalSettings = exports.getWorkspace = exports.AngularWorkspace = exports.workspaceSchemaPath = void 0;
 const core_1 = require("@angular-devkit/core");
 const fs_1 = require("fs");
 const os = __importStar(require("os"));
@@ -42,15 +42,16 @@ function isJsonObject(value) {
 }
 function createWorkspaceHost() {
     return {
-        async readFile(path) {
-            return (0, fs_1.readFileSync)(path, 'utf-8');
+        readFile(path) {
+            return fs_1.promises.readFile(path, 'utf-8');
         },
         async writeFile(path, data) {
-            (0, fs_1.writeFileSync)(path, data);
+            await fs_1.promises.writeFile(path, data);
         },
         async isDirectory(path) {
             try {
-                return (0, fs_1.statSync)(path).isDirectory();
+                const stats = await fs_1.promises.stat(path);
+                return stats.isDirectory();
             }
             catch {
                 return false;
@@ -58,7 +59,8 @@ function createWorkspaceHost() {
         },
         async isFile(path) {
             try {
-                return (0, fs_1.statSync)(path).isFile();
+                const stats = await fs_1.promises.stat(path);
+                return stats.isFile();
             }
             catch {
                 return false;
@@ -147,14 +149,13 @@ class AngularWorkspace {
 exports.AngularWorkspace = AngularWorkspace;
 const cachedWorkspaces = new Map();
 async function getWorkspace(level = 'local') {
-    const cached = cachedWorkspaces.get(level);
-    if (cached !== undefined) {
-        return cached;
+    if (cachedWorkspaces.has(level)) {
+        return cachedWorkspaces.get(level);
     }
     const configPath = level === 'local' ? projectFilePath() : globalFilePath();
     if (!configPath) {
-        cachedWorkspaces.set(level, null);
-        return null;
+        cachedWorkspaces.set(level, undefined);
+        return undefined;
     }
     try {
         const workspace = await AngularWorkspace.load(configPath);
@@ -237,6 +238,7 @@ function findProjectByPath(workspace, location) {
     }
     return projects[0][1];
 }
+let defaultProjectDeprecationWarningShown = false;
 function getProjectByCwd(workspace) {
     if (workspace.projects.size === 1) {
         // If there is only one project, return that one.
@@ -249,6 +251,11 @@ function getProjectByCwd(workspace) {
     const defaultProject = workspace.extensions['defaultProject'];
     if (defaultProject && typeof defaultProject === 'string') {
         // If there is a default project name, return it.
+        if (!defaultProjectDeprecationWarningShown) {
+            console.warn(`DEPRECATED: The 'defaultProject' workspace option has been deprecated. ` +
+                `The project to use will be determined from the current working directory.`);
+            defaultProjectDeprecationWarningShown = true;
+        }
         return defaultProject;
     }
     return null;
@@ -341,33 +348,3 @@ async function isWarningEnabled(warning) {
     return result !== null && result !== void 0 ? result : true;
 }
 exports.isWarningEnabled = isWarningEnabled;
-function getProjectsByPath(workspace, cwd, root) {
-    if (workspace.projects.size === 1) {
-        return Array.from(workspace.projects.keys());
-    }
-    const isInside = (base, potential) => {
-        const absoluteBase = path.resolve(root, base);
-        const absolutePotential = path.resolve(root, potential);
-        const relativePotential = path.relative(absoluteBase, absolutePotential);
-        if (!relativePotential.startsWith('..') && !path.isAbsolute(relativePotential)) {
-            return true;
-        }
-        return false;
-    };
-    const projects = Array.from(workspace.projects.entries())
-        .map(([name, project]) => [path.resolve(root, project.root), name])
-        .filter((tuple) => isInside(tuple[0], cwd))
-        // Sort tuples by depth, with the deeper ones first. Since the first member is a path and
-        // we filtered all invalid paths, the longest will be the deepest (and in case of equality
-        // the sort is stable and the first declared project will win).
-        .sort((a, b) => b[0].length - a[0].length);
-    if (projects.length === 1) {
-        return [projects[0][1]];
-    }
-    else if (projects.length > 1) {
-        const firstPath = projects[0][0];
-        return projects.filter((v) => v[0] === firstPath).map((v) => v[1]);
-    }
-    return [];
-}
-exports.getProjectsByPath = getProjectsByPath;

package/src/{analytics/analytics-environment-options.d.ts → utilities/environment-options.d.ts}

@@ -7,3 +7,6 @@
  */
 export declare const analyticsDisabled: boolean;
 export declare const analyticsShareDisabled: boolean;
+export declare const isCI: boolean;
+export declare const disableVersionCheck: boolean;
+export declare const ngDebug: boolean;

package/src/utilities/environment-options.js

@@ -0,0 +1,24 @@
+"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.ngDebug = exports.disableVersionCheck = exports.isCI = exports.analyticsShareDisabled = exports.analyticsDisabled = void 0;
+function isPresent(variable) {
+    return typeof variable === 'string' && variable !== '';
+}
+function isDisabled(variable) {
+    return isPresent(variable) && (variable === '0' || variable.toLowerCase() === 'false');
+}
+function isEnabled(variable) {
+    return isPresent(variable) && (variable === '1' || variable.toLowerCase() === 'true');
+}
+exports.analyticsDisabled = isDisabled(process.env['NG_CLI_ANALYTICS']);
+exports.analyticsShareDisabled = isDisabled(process.env['NG_CLI_ANALYTICS_SHARE']);
+exports.isCI = isEnabled(process.env['CI']);
+exports.disableVersionCheck = isEnabled(process.env['NG_DISABLE_VERSION_CHECK']);
+exports.ngDebug = isEnabled(process.env['NG_DEBUG']);

package/src/utilities/package-manager.d.ts

@@ -6,8 +6,36 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { PackageManager } from '../../lib/config/workspace-schema';
-export declare function getPackageManager(root: string): Promise<PackageManager>;
-/**
- * Checks if the npm version is a supported 7.x version.  If not, display a warning.
- */
-export declare function ensureCompatibleNpm(root: string): Promise<void>;
+import { AngularWorkspace } from './config';
+export interface PackageManagerUtilsContext {
+    globalConfiguration?: AngularWorkspace;
+    workspace?: AngularWorkspace;
+    root: string;
+}
+export declare class PackageManagerUtils {
+    private readonly context;
+    constructor(context: PackageManagerUtilsContext);
+    /** Get the package manager name. */
+    get name(): PackageManager;
+    /** Get the package manager version. */
+    get version(): string | undefined;
+    /**
+     * Checks if the package manager is supported. If not, display a warning.
+     */
+    ensureCompatibility(): void;
+    /** Install a single package. */
+    install(packageName: string, save?: 'dependencies' | 'devDependencies' | true, extraArgs?: string[], cwd?: string): Promise<boolean>;
+    /** Install all packages. */
+    installAll(extraArgs?: string[], cwd?: string): Promise<boolean>;
+    /** Install a single package temporary. */
+    installTemp(packageName: string, extraArgs?: string[]): Promise<{
+        success: boolean;
+        tempNodeModules: string;
+    }>;
+    private getArguments;
+    private run;
+    private getVersion;
+    private getName;
+    private hasLockfile;
+    private getConfiguredPackageManager;
+}

package/src/utilities/package-manager.js

@@ -7,26 +7,231 @@
  * found in the LICENSE file at https://angular.io/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureCompatibleNpm = exports.getPackageManager = void 0;
+exports.PackageManagerUtils = void 0;
+const core_1 = require("@angular-devkit/core");
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
+const os_1 = require("os");
 const path_1 = require("path");
 const semver_1 = require("semver");
-const util_1 = require("util");
 const workspace_schema_1 = require("../../lib/config/workspace-schema");
 const config_1 = require("./config");
-const exec = (0, util_1.promisify)(child_process_1.exec);
-async function supports(name) {
-    try {
-        await exec(`${name} --version`);
-        return true;
+const spinner_1 = require("./spinner");
+class PackageManagerUtils {
+    constructor(context) {
+        this.context = context;
     }
-    catch {
-        return false;
+    /** Get the package manager name. */
+    get name() {
+        return this.getName();
     }
-}
-async function hasLockfile(root, packageManager) {
-    try {
+    /** Get the package manager version. */
+    get version() {
+        return this.getVersion(this.name);
+    }
+    /**
+     * Checks if the package manager is supported. If not, display a warning.
+     */
+    ensureCompatibility() {
+        if (this.name !== workspace_schema_1.PackageManager.Npm) {
+            return;
+        }
+        try {
+            const version = (0, semver_1.valid)(this.version);
+            if (!version) {
+                return;
+            }
+            if ((0, semver_1.satisfies)(version, '>=7 <7.5.6')) {
+                // eslint-disable-next-line no-console
+                console.warn(`npm version ${version} detected.` +
+                    ' When using npm 7 with the Angular CLI, npm version 7.5.6 or higher is recommended.');
+            }
+        }
+        catch {
+            // npm is not installed.
+        }
+    }
+    /** Install a single package. */
+    async install(packageName, save = true, extraArgs = [], cwd) {
+        const packageManagerArgs = this.getArguments();
+        const installArgs = [
+            packageManagerArgs.install,
+            packageName,
+            packageManagerArgs.silent,
+        ];
+        if (save === 'devDependencies') {
+            installArgs.push(packageManagerArgs.saveDev);
+        }
+        return this.run([...installArgs, ...extraArgs], cwd);
+    }
+    /** Install all packages. */
+    async installAll(extraArgs = [], cwd) {
+        const packageManagerArgs = this.getArguments();
+        const installArgs = [packageManagerArgs.silent];
+        if (packageManagerArgs.installAll) {
+            installArgs.push(packageManagerArgs.installAll);
+        }
+        return this.run([...installArgs, ...extraArgs], cwd);
+    }
+    /** Install a single package temporary. */
+    async installTemp(packageName, extraArgs) {
+        const tempPath = await fs_1.promises.mkdtemp((0, path_1.join)((0, fs_1.realpathSync)((0, os_1.tmpdir)()), 'angular-cli-packages-'));
+        // clean up temp directory on process exit
+        process.on('exit', () => {
+            try {
+                (0, fs_1.rmdirSync)(tempPath, { recursive: true, maxRetries: 3 });
+            }
+            catch { }
+        });
+        // NPM will warn when a `package.json` is not found in the install directory
+        // Example:
+        // npm WARN enoent ENOENT: no such file or directory, open '/tmp/.ng-temp-packages-84Qi7y/package.json'
+        // npm WARN .ng-temp-packages-84Qi7y No description
+        // npm WARN .ng-temp-packages-84Qi7y No repository field.
+        // npm WARN .ng-temp-packages-84Qi7y No license field.
+        // While we can use `npm init -y` we will end up needing to update the 'package.json' anyways
+        // because of missing fields.
+        await fs_1.promises.writeFile((0, path_1.join)(tempPath, 'package.json'), JSON.stringify({
+            name: 'temp-cli-install',
+            description: 'temp-cli-install',
+            repository: 'temp-cli-install',
+            license: 'MIT',
+        }));
+        // setup prefix/global modules path
+        const packageManagerArgs = this.getArguments();
+        const tempNodeModules = (0, path_1.join)(tempPath, 'node_modules');
+        // Yarn will not append 'node_modules' to the path
+        const prefixPath = this.name === workspace_schema_1.PackageManager.Yarn ? tempNodeModules : tempPath;
+        const installArgs = [
+            ...(extraArgs !== null && extraArgs !== void 0 ? extraArgs : []),
+            `${packageManagerArgs.prefix}="${prefixPath}"`,
+            packageManagerArgs.noLockfile,
+        ];
+        return {
+            success: await this.install(packageName, true, installArgs, tempPath),
+            tempNodeModules,
+        };
+    }
+    getArguments() {
+        switch (this.name) {
+            case workspace_schema_1.PackageManager.Yarn:
+                return {
+                    silent: '--silent',
+                    saveDev: '--dev',
+                    install: 'add',
+                    prefix: '--modules-folder',
+                    noLockfile: '--no-lockfile',
+                };
+            case workspace_schema_1.PackageManager.Pnpm:
+                return {
+                    silent: '--silent',
+                    saveDev: '--save-dev',
+                    install: 'add',
+                    installAll: 'install',
+                    prefix: '--prefix',
+                    noLockfile: '--no-lockfile',
+                };
+            default:
+                return {
+                    silent: '--quiet',
+                    saveDev: '--save-dev',
+                    install: 'install',
+                    installAll: 'install',
+                    prefix: '--prefix',
+                    noLockfile: '--no-package-lock',
+                };
+        }
+    }
+    async run(args, cwd = process.cwd()) {
+        const spinner = new spinner_1.Spinner();
+        spinner.start('Installing packages...');
+        return new Promise((resolve) => {
+            var _a, _b;
+            const bufferedOutput = [];
+            const childProcess = (0, child_process_1.spawn)(this.name, args, {
+                stdio: 'pipe',
+                shell: true,
+                cwd,
+            }).on('close', (code) => {
+                if (code === 0) {
+                    spinner.succeed('Packages successfully installed.');
+                    resolve(true);
+                }
+                else {
+                    spinner.stop();
+                    bufferedOutput.forEach(({ stream, data }) => stream.write(data));
+                    spinner.fail('Packages installation failed, see above.');
+                    resolve(false);
+                }
+            });
+            (_a = childProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => bufferedOutput.push({ stream: process.stdout, data: data }));
+            (_b = childProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => bufferedOutput.push({ stream: process.stderr, data: data }));
+        });
+    }
+    // TODO(alan-agius4): use the memoize decorator when it's merged.
+    getVersion(name) {
+        try {
+            return (0, child_process_1.execSync)(`${name} --version`, {
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+                env: {
+                    ...process.env,
+                    //  NPM updater notifier will prevents the child process from closing until it timeout after 3 minutes.
+                    NO_UPDATE_NOTIFIER: '1',
+                    NPM_CONFIG_UPDATE_NOTIFIER: 'false',
+                },
+            }).trim();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // TODO(alan-agius4): use the memoize decorator when it's merged.
+    getName() {
+        const packageManager = this.getConfiguredPackageManager();
+        if (packageManager) {
+            return packageManager;
+        }
+        const hasNpmLock = this.hasLockfile(workspace_schema_1.PackageManager.Npm);
+        const hasYarnLock = this.hasLockfile(workspace_schema_1.PackageManager.Yarn);
+        const hasPnpmLock = this.hasLockfile(workspace_schema_1.PackageManager.Pnpm);
+        // PERF NOTE: `this.getVersion` spawns the package a the child_process which can take around ~300ms at times.
+        // Therefore, we should only call this method when needed. IE: don't call `this.getVersion(PackageManager.Pnpm)` unless truly needed.
+        // The result of this method is not stored in a variable because it's memoized.
+        if (hasNpmLock) {
+            // Has NPM lock file.
+            if (!hasYarnLock && !hasPnpmLock && this.getVersion(workspace_schema_1.PackageManager.Npm)) {
+                // Only NPM lock file and NPM binary is available.
+                return workspace_schema_1.PackageManager.Npm;
+            }
+        }
+        else {
+            // No NPM lock file.
+            if (hasYarnLock && this.getVersion(workspace_schema_1.PackageManager.Yarn)) {
+                // Yarn lock file and Yarn binary is available.
+                return workspace_schema_1.PackageManager.Yarn;
+            }
+            else if (hasPnpmLock && this.getVersion(workspace_schema_1.PackageManager.Pnpm)) {
+                // PNPM lock file and PNPM binary is available.
+                return workspace_schema_1.PackageManager.Pnpm;
+            }
+        }
+        if (!this.getVersion(workspace_schema_1.PackageManager.Npm)) {
+            // Doesn't have NPM installed.
+            const hasYarn = !!this.getVersion(workspace_schema_1.PackageManager.Yarn);
+            const hasPnpm = !!this.getVersion(workspace_schema_1.PackageManager.Pnpm);
+            if (hasYarn && !hasPnpm) {
+                return workspace_schema_1.PackageManager.Yarn;
+            }
+            else if (!hasYarn && hasPnpm) {
+                return workspace_schema_1.PackageManager.Pnpm;
+            }
+        }
+        // TODO: This should eventually inform the user of ambiguous package manager usage.
+        //       Potentially with a prompt to choose and optionally set as the default.
+        return workspace_schema_1.PackageManager.Npm;
+    }
+    hasLockfile(packageManager) {
         let lockfileName;
         switch (packageManager) {
             case workspace_schema_1.PackageManager.Yarn:
@@ -40,67 +245,32 @@ async function hasLockfile(root, packageManager) {
                 lockfileName = 'package-lock.json';
                 break;
         }
-        await fs_1.promises.access((0, path_1.join)(root, lockfileName), fs_1.constants.F_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function getPackageManager(root) {
-    const packageManager = await (0, config_1.getConfiguredPackageManager)();
-    if (packageManager) {
-        return packageManager;
-    }
-    const [hasYarnLock, hasNpmLock, hasPnpmLock] = await Promise.all([
-        hasLockfile(root, workspace_schema_1.PackageManager.Yarn),
-        hasLockfile(root, workspace_schema_1.PackageManager.Npm),
-        hasLockfile(root, workspace_schema_1.PackageManager.Pnpm),
-    ]);
-    const hasYarn = await supports(workspace_schema_1.PackageManager.Yarn);
-    if (hasYarn && hasYarnLock && !hasNpmLock) {
-        return workspace_schema_1.PackageManager.Yarn;
-    }
-    const hasPnpm = await supports(workspace_schema_1.PackageManager.Pnpm);
-    if (hasPnpm && hasPnpmLock && !hasNpmLock) {
-        return workspace_schema_1.PackageManager.Pnpm;
+        return (0, fs_1.existsSync)((0, path_1.join)(this.context.root, lockfileName));
     }
-    const hasNpm = await supports(workspace_schema_1.PackageManager.Npm);
-    if (hasNpm && hasNpmLock && !hasYarnLock && !hasPnpmLock) {
-        return workspace_schema_1.PackageManager.Npm;
-    }
-    if (hasYarn && !hasNpm && !hasPnpm) {
-        return workspace_schema_1.PackageManager.Yarn;
-    }
-    if (hasPnpm && !hasYarn && !hasNpm) {
-        return workspace_schema_1.PackageManager.Pnpm;
-    }
-    // TODO: This should eventually inform the user of ambiguous package manager usage.
-    //       Potentially with a prompt to choose and optionally set as the default.
-    return workspace_schema_1.PackageManager.Npm;
-}
-exports.getPackageManager = getPackageManager;
-/**
- * Checks if the npm version is a supported 7.x version.  If not, display a warning.
- */
-async function ensureCompatibleNpm(root) {
-    if ((await getPackageManager(root)) !== workspace_schema_1.PackageManager.Npm) {
-        return;
-    }
-    try {
-        const versionText = (0, child_process_1.execSync)('npm --version', { encoding: 'utf8', stdio: 'pipe' }).trim();
-        const version = (0, semver_1.valid)(versionText);
-        if (!version) {
-            return;
+    getConfiguredPackageManager() {
+        var _a;
+        const getPackageManager = (source) => {
+            if (source && (0, core_1.isJsonObject)(source)) {
+                const value = source['packageManager'];
+                if (typeof value === 'string') {
+                    return value;
+                }
+            }
+            return undefined;
+        };
+        let result;
+        const { workspace: localWorkspace, globalConfiguration: globalWorkspace } = this.context;
+        if (localWorkspace) {
+            const project = (0, config_1.getProjectByCwd)(localWorkspace);
+            if (project) {
+                result = getPackageManager((_a = localWorkspace.projects.get(project)) === null || _a === void 0 ? void 0 : _a.extensions['cli']);
+            }
+            result !== null && result !== void 0 ? result : (result = getPackageManager(localWorkspace.extensions['cli']));
         }
-        if ((0, semver_1.satisfies)(version, '>=7 <7.5.6')) {
-            // eslint-disable-next-line no-console
-            console.warn(`npm version ${version} detected.` +
-                ' When using npm 7 with the Angular CLI, npm version 7.5.6 or higher is recommended.');
+        if (!result) {
+            result = getPackageManager(globalWorkspace === null || globalWorkspace === void 0 ? void 0 : globalWorkspace.extensions['cli']);
         }
-    }
-    catch {
-        // npm is not installed
+        return result;
     }
 }
-exports.ensureCompatibleNpm = ensureCompatibleNpm;
+exports.PackageManagerUtils = PackageManagerUtils;