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

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

@@ -6,27 +6,237 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 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 memoize_1 = require("./memoize");
+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 }));
+        });
+    }
+    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;
+        }
+    }
+    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 +250,38 @@ 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;
+__decorate([
+    memoize_1.memoize
+], PackageManagerUtils.prototype, "getVersion", null);
+__decorate([
+    memoize_1.memoize
+], PackageManagerUtils.prototype, "getName", null);
+exports.PackageManagerUtils = PackageManagerUtils;

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

@@ -6,24 +6,15 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { logging } from '@angular-devkit/core';
-import { JsonSchemaForNpmPackageJsonFiles } from './package-json';
-export interface NpmRepositoryPackageJson {
-    name: string;
-    requestedName: string;
-    description: string;
-    'dist-tags': {
-        [name: string]: string;
-    };
-    versions: {
-        [version: string]: JsonSchemaForNpmPackageJsonFiles;
-    };
-    time: {
-        modified: string;
-        created: string;
-        [version: string]: string;
-    };
+import type { Manifest, Packument } from 'pacote';
+export interface PackageMetadata extends Packument, NgPackageManifestProperties {
+    tags: Record<string, PackageManifest>;
+    versions: Record<string, PackageManifest>;
 }
-export declare type NgAddSaveDepedency = 'dependencies' | 'devDependencies' | boolean;
+export interface NpmRepositoryPackageJson extends PackageMetadata {
+    requestedName?: string;
+}
+export declare type NgAddSaveDependency = 'dependencies' | 'devDependencies' | boolean;
 export interface PackageIdentifier {
     type: 'git' | 'tag' | 'version' | 'range' | 'file' | 'directory' | 'remote';
     name: string;
@@ -33,31 +24,18 @@ export interface PackageIdentifier {
     fetchSpec: string;
     rawSpec: string;
 }
-export interface PackageManifest {
-    name: string;
-    version: string;
-    license?: string;
-    private?: boolean;
-    deprecated?: boolean;
-    dependencies: Record<string, string>;
-    devDependencies: Record<string, string>;
-    peerDependencies: Record<string, string>;
-    optionalDependencies: Record<string, string>;
+export interface NgPackageManifestProperties {
     'ng-add'?: {
-        save?: NgAddSaveDepedency;
+        save?: NgAddSaveDependency;
     };
     'ng-update'?: {
-        migrations: string;
-        packageGroup: Record<string, string>;
+        migrations?: string;
+        packageGroup?: string[] | Record<string, string>;
+        packageGroupName?: string;
+        requirements?: string[] | Record<string, string>;
     };
 }
-export interface PackageMetadata {
-    name: string;
-    tags: {
-        [tag: string]: PackageManifest | undefined;
-    };
-    versions: Record<string, PackageManifest>;
-    'dist-tags'?: unknown;
+export interface PackageManifest extends Manifest, NgPackageManifestProperties {
 }
 export declare function fetchPackageMetadata(name: string, logger: logging.LoggerApi, options?: {
     registry?: string;

package/src/utilities/package-metadata.js

@@ -35,10 +35,9 @@ const lockfile = __importStar(require("@yarnpkg/lockfile"));
 const fs_1 = require("fs");
 const ini = __importStar(require("ini"));
 const os_1 = require("os");
-const pacote = __importStar(require("pacote"));
 const path = __importStar(require("path"));
-const npmPackageJsonCache = new Map();
 let npmrc;
+const npmPackageJsonCache = new Map();
 function ensureNpmrc(logger, usingYarn, verbose) {
     if (!npmrc) {
         try {
@@ -170,16 +169,6 @@ function normalizeOptions(rawOptions, location = process.cwd(), existingNormaliz
     }
     return options;
 }
-function normalizeManifest(rawManifest) {
-    // TODO: Fully normalize and sanitize
-    return {
-        dependencies: {},
-        devDependencies: {},
-        peerDependencies: {},
-        optionalDependencies: {},
-        ...rawManifest,
-    };
-}
 async function fetchPackageMetadata(name, logger, options) {
     const { usingYarn, verbose, registry } = {
         registry: undefined,
@@ -188,25 +177,18 @@ async function fetchPackageMetadata(name, logger, options) {
         ...options,
     };
     ensureNpmrc(logger, usingYarn, verbose);
-    const response = await pacote.packument(name, {
+    const { packument } = await Promise.resolve().then(() => __importStar(require('pacote')));
+    const response = await packument(name, {
         fullMetadata: true,
         ...npmrc,
         ...(registry ? { registry } : {}),
     });
     // Normalize the response
     const metadata = {
-        name: response.name,
+        ...response,
         tags: {},
-        versions: {},
     };
-    if (response.versions) {
-        for (const [version, manifest] of Object.entries(response.versions)) {
-            metadata.versions[version] = normalizeManifest(manifest);
-        }
-    }
     if (response['dist-tags']) {
-        // Store this for use with other npm utility packages
-        metadata['dist-tags'] = response['dist-tags'];
         for (const [tag, version] of Object.entries(response['dist-tags'])) {
             const manifest = metadata.versions[version];
             if (manifest) {
@@ -223,22 +205,24 @@ exports.fetchPackageMetadata = fetchPackageMetadata;
 async function fetchPackageManifest(name, logger, options = {}) {
     const { usingYarn = false, verbose = false, registry } = options;
     ensureNpmrc(logger, usingYarn, verbose);
-    const response = await pacote.manifest(name, {
+    const { manifest } = await Promise.resolve().then(() => __importStar(require('pacote')));
+    const response = await manifest(name, {
         fullMetadata: true,
         ...npmrc,
         ...(registry ? { registry } : {}),
     });
-    return normalizeManifest(response);
+    return response;
 }
 exports.fetchPackageManifest = fetchPackageManifest;
-function getNpmPackageJson(packageName, logger, options = {}) {
+async function getNpmPackageJson(packageName, logger, options = {}) {
     const cachedResponse = npmPackageJsonCache.get(packageName);
     if (cachedResponse) {
         return cachedResponse;
     }
     const { usingYarn = false, verbose = false, registry } = options;
     ensureNpmrc(logger, usingYarn, verbose);
-    const resultPromise = pacote.packument(packageName, {
+    const { packument } = await Promise.resolve().then(() => __importStar(require('pacote')));
+    const resultPromise = packument(packageName, {
         fullMetadata: true,
         ...npmrc,
         ...(registry ? { registry } : {}),

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

@@ -5,7 +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
  */
-import { NgAddSaveDepedency } from './package-metadata';
+import { NgAddSaveDependency } from './package-metadata';
 interface PackageJson {
     name: string;
     version: string;
@@ -17,7 +17,7 @@ interface PackageJson {
         migrations?: string;
     };
     'ng-add'?: {
-        save?: NgAddSaveDepedency;
+        save?: NgAddSaveDependency;
     };
 }
 export interface PackageTreeNode {

package/src/utilities/prompt.d.ts

@@ -5,4 +5,6 @@
  * 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 type { ListChoiceOptions } from 'inquirer';
 export declare function askConfirmation(message: string, defaultResponse: boolean, noTTYResponse?: boolean): Promise<boolean>;
+export declare function askQuestion(message: string, choices: ListChoiceOptions[], defaultResponseIndex: number, noTTYResponse: null | string): Promise<string | null>;

package/src/utilities/prompt.js

@@ -30,8 +30,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.askConfirmation = void 0;
-const inquirer = __importStar(require("inquirer"));
+exports.askQuestion = exports.askConfirmation = void 0;
 const tty_1 = require("./tty");
 async function askConfirmation(message, defaultResponse, noTTYResponse) {
     if (!(0, tty_1.isTTY)()) {
@@ -44,7 +43,25 @@ async function askConfirmation(message, defaultResponse, noTTYResponse) {
         message,
         default: defaultResponse,
     };
-    const answers = await inquirer.prompt([question]);
+    const { prompt } = await Promise.resolve().then(() => __importStar(require('inquirer')));
+    const answers = await prompt([question]);
     return answers['confirmation'];
 }
 exports.askConfirmation = askConfirmation;
+async function askQuestion(message, choices, defaultResponseIndex, noTTYResponse) {
+    if (!(0, tty_1.isTTY)()) {
+        return noTTYResponse;
+    }
+    const question = {
+        type: 'list',
+        name: 'answer',
+        prefix: '',
+        message,
+        choices,
+        default: defaultResponseIndex,
+    };
+    const { prompt } = await Promise.resolve().then(() => __importStar(require('inquirer')));
+    const answers = await prompt([question]);
+    return answers['answer'];
+}
+exports.askQuestion = askQuestion;

package/bin/postinstall/analytics-prompt.js

@@ -1,27 +0,0 @@
-/**
- * @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
- */
-
-'use strict';
-// This file is ES5 because it needs to be executed as is.
-
-if ('NG_CLI_ANALYTICS' in process.env) {
-  return;
-}
-
-try {
-  var analytics = require('../../src/analytics/analytics');
-
-  analytics
-    .getAnalytics('global')
-    .then((hasGlobalConfig) => {
-      if (!hasGlobalConfig) {
-        return analytics.promptAnalytics(true /** global */);
-      }
-    })
-    .catch(() => {});
-} catch (_) {}

package/bin/postinstall/script.js

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-/**
- * @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
- */
-
-'use strict';
-
-// These should not fail but if they do they should not block installation of the package
-try {
-  // eslint-disable-next-line import/no-unassigned-import
-  require('./analytics-prompt');
-} catch (_) {}