@angular/cli 6.2.8 → 6.2.9

package/commands/add-impl.d.ts

@@ -1,14 +1,12 @@
-/**
- * @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 { SchematicCommand } from '../models/schematic-command';
 export declare class AddCommand extends SchematicCommand {
     readonly allowPrivateSchematics: boolean;
+    readonly packageManager: string;
     private _parseSchematicOptions;
     validate(options: any): boolean;
     run(options: any): Promise<number | void>;
+    private isPackageInstalled;
+    private executeSchematic;
+    private findProjectVersion;
+    private hasMismatchedPeer;
 }

package/commands/add-impl.js

@@ -1,11 +1,4 @@
 "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
- */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -15,16 +8,29 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @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
+ */
 // tslint:disable:no-global-tslint-disable no-any
 const core_1 = require("@angular-devkit/core");
+const node_1 = require("@angular-devkit/core/node");
 const tools_1 = require("@angular-devkit/schematics/tools");
+const path_1 = require("path");
+const semver_1 = require("semver");
 const command_runner_1 = require("../models/command-runner");
 const schematic_command_1 = require("../models/schematic-command");
 const config_1 = require("../utilities/config");
+const package_metadata_1 = require("../utilities/package-metadata");
+const npa = require('npm-package-arg');
 class AddCommand extends schematic_command_1.SchematicCommand {
     constructor() {
         super(...arguments);
         this.allowPrivateSchematics = true;
+        this.packageManager = config_1.getPackageManager();
     }
     _parseSchematicOptions(collectionName) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -53,22 +59,105 @@ class AddCommand extends schematic_command_1.SchematicCommand {
                     + `${core_1.terminal.yellow('ng add [name] ')}. For more details, use "ng help".`);
                 return 1;
             }
-            const packageManager = config_1.getPackageManager();
+            let packageIdentifier;
+            try {
+                packageIdentifier = npa(options.collection);
+            }
+            catch (e) {
+                this.logger.error(e.message);
+                return 1;
+            }
+            if (packageIdentifier.registry && this.isPackageInstalled(packageIdentifier.name)) {
+                // Already installed so just run schematic
+                this.logger.info('Skipping installation: Package already installed');
+                // Reparse the options with the new schematic accessible.
+                options = yield this._parseSchematicOptions(packageIdentifier.name);
+                return this.executeSchematic(packageIdentifier.name, options);
+            }
+            const usingYarn = this.packageManager === 'yarn';
+            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
+                let packageMetadata;
+                try {
+                    packageMetadata = yield package_metadata_1.fetchPackageMetadata(packageIdentifier.name, this.logger, { usingYarn });
+                }
+                catch (e) {
+                    this.logger.error('Unable to fetch package metadata: ' + e.message);
+                    return 1;
+                }
+                const latestManifest = packageMetadata.tags['latest'];
+                if (latestManifest && Object.keys(latestManifest.peerDependencies).length === 0) {
+                    if (latestManifest.name === '@angular/pwa') {
+                        const version = yield this.findProjectVersion('@angular/cli');
+                        // tslint:disable-next-line:no-any
+                        const semverOptions = { includePrerelease: true };
+                        if (version
+                            && ((semver_1.validRange(version) && semver_1.intersects(version, '6', semverOptions))
+                                || (semver_1.valid(version) && semver_1.satisfies(version, '6', semverOptions)))) {
+                            packageIdentifier = npa.resolve('@angular/pwa', 'v6-lts');
+                        }
+                    }
+                }
+                else if (!latestManifest || (yield this.hasMismatchedPeer(latestManifest))) {
+                    // 'latest' is invalid so search for most recent matching package
+                    const versionManifests = Array.from(packageMetadata.versions.values())
+                        .filter(value => !semver_1.prerelease(value.version));
+                    versionManifests.sort((a, b) => semver_1.rcompare(a.version, b.version, true));
+                    let newIdentifier;
+                    for (const versionManifest of versionManifests) {
+                        if (!(yield this.hasMismatchedPeer(versionManifest))) {
+                            newIdentifier = npa.resolve(packageIdentifier.name, versionManifest.version);
+                            break;
+                        }
+                    }
+                    if (!newIdentifier) {
+                        this.logger.warn('Unable to find compatible package.  Using \'latest\'.');
+                    }
+                    else {
+                        packageIdentifier = newIdentifier;
+                    }
+                }
+            }
+            let collectionName = packageIdentifier.name;
+            if (!packageIdentifier.registry) {
+                try {
+                    const manifest = yield package_metadata_1.fetchPackageManifest(packageIdentifier, this.logger, { usingYarn });
+                    collectionName = manifest.name;
+                    if (yield this.hasMismatchedPeer(manifest)) {
+                        console.warn('Package has unmet peer dependencies. Adding the package may not succeed.');
+                    }
+                }
+                catch (e) {
+                    this.logger.error('Unable to fetch package manifest: ' + e.message);
+                    return 1;
+                }
+            }
             const npmInstall = require('../tasks/npm-install').default;
-            const packageName = firstArg.startsWith('@')
-                ? firstArg.split('/', 2).join('/')
-                : firstArg.split('/', 1)[0];
-            // Remove the tag/version from the package name.
-            const collectionName = (packageName.startsWith('@')
-                ? packageName.split('@', 2).join('@')
-                : packageName.split('@', 1).join('@')) + firstArg.slice(packageName.length);
             // We don't actually add the package to package.json, that would be the work of the package
             // itself.
-            yield npmInstall(packageName, this.logger, packageManager, this.project.root);
+            yield npmInstall(packageIdentifier.raw, this.logger, this.packageManager, this.project.root);
             // Reparse the options with the new schematic accessible.
             options = yield this._parseSchematicOptions(collectionName);
+            return this.executeSchematic(collectionName, options);
+        });
+    }
+    isPackageInstalled(name) {
+        try {
+            node_1.resolve(name, { checkLocal: true, basedir: this.project.root });
+            return true;
+        }
+        catch (e) {
+            if (!(e instanceof node_1.ModuleNotFoundException)) {
+                throw e;
+            }
+        }
+        return false;
+    }
+    executeSchematic(collectionName, options) {
+        return __awaiter(this, void 0, void 0, function* () {
             const runOptions = {
-                schematicOptions: options,
+                schematicOptions: options || [],
                 workingDir: this.project.root,
                 collectionName,
                 schematicName: 'ng-add',
@@ -91,6 +180,75 @@ class AddCommand extends schematic_command_1.SchematicCommand {
             }
         });
     }
+    findProjectVersion(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let installedPackage;
+            try {
+                installedPackage = node_1.resolve(name, { checkLocal: true, basedir: this.project.root, resolvePackageJson: true });
+            }
+            catch (_a) { }
+            if (installedPackage) {
+                try {
+                    const installed = yield package_metadata_1.fetchPackageManifest(path_1.dirname(installedPackage), this.logger);
+                    return installed.version;
+                }
+                catch (_b) { }
+            }
+            let projectManifest;
+            try {
+                projectManifest = yield package_metadata_1.fetchPackageManifest(this.project.root, this.logger);
+            }
+            catch (_c) { }
+            if (projectManifest) {
+                let version = projectManifest.dependencies[name];
+                if (version) {
+                    return version;
+                }
+                version = projectManifest.devDependencies[name];
+                if (version) {
+                    return version;
+                }
+            }
+            return null;
+        });
+    }
+    hasMismatchedPeer(manifest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const peer in manifest.peerDependencies) {
+                let peerIdentifier;
+                try {
+                    peerIdentifier = npa.resolve(peer, manifest.peerDependencies[peer]);
+                }
+                catch (_a) {
+                    this.logger.warn(`Invalid peer dependency ${peer} found in package.`);
+                    continue;
+                }
+                if (peerIdentifier.type === 'version' || peerIdentifier.type === 'range') {
+                    try {
+                        const version = yield this.findProjectVersion(peer);
+                        if (!version) {
+                            continue;
+                        }
+                        // tslint:disable-next-line:no-any
+                        const options = { includePrerelease: true };
+                        if (!semver_1.intersects(version, peerIdentifier.rawSpec, options)
+                            && !semver_1.satisfies(version, peerIdentifier.rawSpec, options)) {
+                            return true;
+                        }
+                    }
+                    catch (_b) {
+                        // Not found or invalid so ignore
+                        continue;
+                    }
+                }
+                else {
+                    // type === 'tag' | 'file' | 'directory' | 'remote' | 'git'
+                    // Cannot accurately compare these as the tag/location may have changed since install
+                }
+            }
+            return false;
+        });
+    }
 }
 exports.AddCommand = AddCommand;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"add-impl.js","sourceRoot":"./","sources":["packages/angular/cli/commands/add-impl.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// tslint:disable:no-global-tslint-disable no-any\nimport { tags, terminal } from '@angular-devkit/core';\nimport { ModuleNotFoundException, resolve } from '@angular-devkit/core/node';\nimport { NodePackageDoesNotSupportSchematics } from '@angular-devkit/schematics/tools';\nimport { dirname } from 'path';\nimport { intersects, prerelease, rcompare, satisfies, valid, validRange } from 'semver';\nimport { parseOptions } from '../models/command-runner';\nimport { SchematicCommand } from '../models/schematic-command';\nimport { NpmInstall } from '../tasks/npm-install';\nimport { getPackageManager } from '../utilities/config';\nimport {\n  PackageManifest,\n  fetchPackageManifest,\n  fetchPackageMetadata,\n} from '../utilities/package-metadata';\n\nconst npa = require('npm-package-arg');\n\nexport class AddCommand extends SchematicCommand {\n  readonly allowPrivateSchematics = true;\n  readonly packageManager = getPackageManager();\n\n  private async _parseSchematicOptions(collectionName: string): Promise<any> {\n    const schematicOptions = await this.getOptions({\n      schematicName: 'ng-add',\n      collectionName,\n    });\n    this.addOptions(schematicOptions);\n\n    return parseOptions(this._rawArgs, this.options);\n  }\n\n  validate(options: any) {\n    const collectionName = options._[0];\n\n    if (!collectionName) {\n      this.logger.fatal(\n        `The \"ng add\" command requires a name argument to be specified eg. `\n        + `${terminal.yellow('ng add [name] ')}. For more details, use \"ng help\".`,\n      );\n\n      return false;\n    }\n\n    return true;\n  }\n\n  async run(options: any) {\n    const firstArg = options._[0];\n\n    if (!firstArg) {\n      this.logger.fatal(\n        `The \"ng add\" command requires a name argument to be specified eg. `\n        + `${terminal.yellow('ng add [name] ')}. For more details, use \"ng help\".`,\n      );\n\n      return 1;\n    }\n\n    let packageIdentifier;\n    try {\n      packageIdentifier = npa(options.collection);\n    } catch (e) {\n      this.logger.error(e.message);\n\n      return 1;\n    }\n\n    if (packageIdentifier.registry && this.isPackageInstalled(packageIdentifier.name)) {\n      // Already installed so just run schematic\n      this.logger.info('Skipping installation: Package already installed');\n\n      // Reparse the options with the new schematic accessible.\n      options = await this._parseSchematicOptions(packageIdentifier.name);\n\n      return this.executeSchematic(packageIdentifier.name, options);\n    }\n\n    const usingYarn = this.packageManager === 'yarn';\n\n    if (packageIdentifier.type === 'tag' && !packageIdentifier.rawSpec) {\n      // only package name provided; search for viable version\n      // plus special cases for packages that did not have peer deps setup\n      let packageMetadata;\n      try {\n        packageMetadata = await fetchPackageMetadata(\n          packageIdentifier.name,\n          this.logger,\n          { usingYarn },\n        );\n      } catch (e) {\n        this.logger.error('Unable to fetch package metadata: ' + e.message);\n\n        return 1;\n      }\n\n      const latestManifest = packageMetadata.tags['latest'];\n      if (latestManifest && Object.keys(latestManifest.peerDependencies).length === 0) {\n        if (latestManifest.name === '@angular/pwa') {\n          const version = await this.findProjectVersion('@angular/cli');\n          // tslint:disable-next-line:no-any\n          const semverOptions = { includePrerelease: true } as any;\n\n          if (version\n              && ((validRange(version) && intersects(version, '6', semverOptions))\n                  || (valid(version) && satisfies(version, '6', semverOptions)))) {\n            packageIdentifier = npa.resolve('@angular/pwa', 'v6-lts');\n          }\n        }\n      } else if (!latestManifest || (await this.hasMismatchedPeer(latestManifest))) {\n        // 'latest' is invalid so search for most recent matching package\n        const versionManifests = Array.from(packageMetadata.versions.values())\n          .filter(value => !prerelease(value.version));\n\n        versionManifests.sort((a, b) => rcompare(a.version, b.version, true));\n\n        let newIdentifier;\n        for (const versionManifest of versionManifests) {\n          if (!(await this.hasMismatchedPeer(versionManifest))) {\n            newIdentifier = npa.resolve(packageIdentifier.name, versionManifest.version);\n            break;\n          }\n        }\n\n        if (!newIdentifier) {\n          this.logger.warn('Unable to find compatible package.  Using \\'latest\\'.');\n        } else {\n          packageIdentifier = newIdentifier;\n        }\n      }\n    }\n\n    let collectionName = packageIdentifier.name;\n    if (!packageIdentifier.registry) {\n      try {\n        const manifest = await fetchPackageManifest(\n          packageIdentifier,\n          this.logger,\n          { usingYarn },\n        );\n\n        collectionName = manifest.name;\n\n        if (await this.hasMismatchedPeer(manifest)) {\n          console.warn('Package has unmet peer dependencies. Adding the package may not succeed.');\n        }\n      } catch (e) {\n        this.logger.error('Unable to fetch package manifest: ' + e.message);\n\n        return 1;\n      }\n    }\n\n    const npmInstall: NpmInstall = require('../tasks/npm-install').default;\n\n    // We don't actually add the package to package.json, that would be the work of the package\n    // itself.\n    await npmInstall(\n      packageIdentifier.raw,\n      this.logger,\n      this.packageManager,\n      this.project.root,\n    );\n\n    // Reparse the options with the new schematic accessible.\n    options = await this._parseSchematicOptions(collectionName);\n\n    return this.executeSchematic(collectionName, options);\n  }\n\n  private isPackageInstalled(name: string): boolean {\n    try {\n      resolve(name, { checkLocal: true, basedir: this.project.root });\n\n      return true;\n    } catch (e) {\n      if (!(e instanceof ModuleNotFoundException)) {\n        throw e;\n      }\n    }\n\n    return false;\n  }\n\n  private async executeSchematic(\n    collectionName: string,\n    options?: string[],\n  ): Promise<number | void> {\n    const runOptions = {\n      schematicOptions: options || [],\n      workingDir: this.project.root,\n      collectionName,\n      schematicName: 'ng-add',\n      allowPrivate: true,\n      dryRun: false,\n      force: false,\n    };\n\n    try {\n      return await this.runSchematic(runOptions);\n    } catch (e) {\n      if (e instanceof NodePackageDoesNotSupportSchematics) {\n        this.logger.error(tags.oneLine`\n          The package that you are trying to add does not support schematics. You can try using\n          a different version of the package or contact the package author to add ng-add support.\n        `);\n\n        return 1;\n      }\n\n      throw e;\n    }\n  }\n\n  private async findProjectVersion(name: string): Promise<string | null> {\n    let installedPackage;\n    try {\n      installedPackage = resolve(\n        name,\n        { checkLocal: true, basedir: this.project.root, resolvePackageJson: true },\n      );\n    } catch { }\n\n    if (installedPackage) {\n      try {\n        const installed = await fetchPackageManifest(dirname(installedPackage), this.logger);\n\n        return installed.version;\n      } catch {}\n    }\n\n    let projectManifest;\n    try {\n      projectManifest = await fetchPackageManifest(this.project.root, this.logger);\n    } catch {}\n\n    if (projectManifest) {\n      let version = projectManifest.dependencies[name];\n      if (version) {\n        return version;\n      }\n\n      version = projectManifest.devDependencies[name];\n      if (version) {\n        return version;\n      }\n    }\n\n    return null;\n  }\n\n  private async hasMismatchedPeer(manifest: PackageManifest): Promise<boolean> {\n    for (const peer in manifest.peerDependencies) {\n      let peerIdentifier;\n      try {\n        peerIdentifier = npa.resolve(peer, manifest.peerDependencies[peer]);\n      } catch {\n        this.logger.warn(`Invalid peer dependency ${peer} found in package.`);\n        continue;\n      }\n\n      if (peerIdentifier.type === 'version' || peerIdentifier.type === 'range') {\n        try {\n          const version = await this.findProjectVersion(peer);\n          if (!version) {\n            continue;\n          }\n\n          // tslint:disable-next-line:no-any\n          const options = { includePrerelease: true } as any;\n\n          if (!intersects(version, peerIdentifier.rawSpec, options)\n              && !satisfies(version, peerIdentifier.rawSpec, options)) {\n            return true;\n          }\n        } catch {\n          // Not found or invalid so ignore\n          continue;\n        }\n      } else {\n        // type === 'tag' | 'file' | 'directory' | 'remote' | 'git'\n        // Cannot accurately compare these as the tag/location may have changed since install\n      }\n\n    }\n\n    return false;\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/cli",
-  "version": "6.2.8",
+  "version": "6.2.9",
   "description": "CLI tool for Angular",
   "main": "lib/cli/index.js",
   "trackingCode": "UA-8594346-19",
@@ -30,13 +30,17 @@
   },
   "homepage": "https://github.com/angular/angular-cli",
   "dependencies": {
-    "@angular-devkit/architect": "0.8.8",
-    "@angular-devkit/core": "0.8.8",
-    "@angular-devkit/schematics": "0.8.8",
-    "@schematics/angular": "0.8.8",
-    "@schematics/update": "0.8.8",
+    "@angular-devkit/architect": "0.8.9",
+    "@angular-devkit/core": "0.8.9",
+    "@angular-devkit/schematics": "0.8.9",
+    "@schematics/angular": "0.8.9",
+    "@schematics/update": "0.8.9",
+    "@yarnpkg/lockfile": "1.1.0",
+    "ini": "1.3.5",
     "json-schema-traverse": "0.4.1",
+    "npm-package-arg": "6.1.0",
     "opn": "5.4.0",
+    "pacote": "9.2.3",
     "rxjs": "6.2.2",
     "semver": "5.6.0",
     "symbol-observable": "1.2.0",

package/tasks/npm-install.js

@@ -16,7 +16,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@angular-devkit/core");
-const node_1 = require("@angular-devkit/core/node");
 const child_process_1 = require("child_process");
 function default_1(packageName, logger, packageManager, projectRoot, save = true) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -36,17 +35,6 @@ function default_1(packageName, logger, packageManager, projectRoot, save = true
         }
         logger.info(core_1.terminal.green(`Installing packages for tooling via ${packageManager}.`));
         if (packageName) {
-            try {
-                // Verify if we need to install the package (it might already be there).
-                // If it's available and we shouldn't save, simply return. Nothing to be done.
-                node_1.resolve(packageName, { checkLocal: true, basedir: projectRoot });
-                return;
-            }
-            catch (e) {
-                if (!(e instanceof node_1.ModuleNotFoundException)) {
-                    throw e;
-                }
-            }
             installArgs.push(packageName);
         }
         if (!save) {
@@ -73,4 +61,4 @@ function default_1(packageName, logger, packageManager, projectRoot, save = true
     });
 }
 exports.default = default_1;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/utilities/package-metadata.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @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 { logging } from '@angular-devkit/core';
+export interface PackageDependencies {
+    [dependency: string]: string;
+}
+export interface PackageIdentifier {
+    type: 'git' | 'tag' | 'version' | 'range' | 'file' | 'directory' | 'remote';
+    name: string;
+    scope: string | null;
+    registry: boolean;
+    raw: string;
+}
+export interface PackageManifest {
+    name: string;
+    version: string;
+    license?: string;
+    private?: boolean;
+    deprecated?: boolean;
+    dependencies: PackageDependencies;
+    devDependencies: PackageDependencies;
+    peerDependencies: PackageDependencies;
+    optionalDependencies: PackageDependencies;
+    'ng-add'?: {};
+    'ng-update'?: {
+        migrations: string;
+        packageGroup: {
+            [name: string]: string;
+        };
+    };
+}
+export interface PackageMetadata {
+    name: string;
+    tags: {
+        [tag: string]: PackageManifest | undefined;
+    };
+    versions: Map<string, PackageManifest>;
+}
+export declare function fetchPackageMetadata(name: string, logger: logging.LoggerApi, options?: {
+    registry?: string;
+    usingYarn?: boolean;
+    verbose?: boolean;
+}): Promise<PackageMetadata>;
+export declare function fetchPackageManifest(name: string, logger: logging.LoggerApi, options?: {
+    registry?: string;
+    usingYarn?: boolean;
+    verbose?: boolean;
+}): Promise<PackageManifest>;

package/utilities/package-metadata.js

@@ -0,0 +1,131 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path = require("path");
+const ini = require('ini');
+const lockfile = require('@yarnpkg/lockfile');
+const pacote = require('pacote');
+let npmrc;
+function ensureNpmrc(logger, usingYarn, verbose) {
+    if (!npmrc) {
+        try {
+            npmrc = readOptions(logger, false, verbose);
+        }
+        catch (_a) { }
+        if (usingYarn) {
+            try {
+                npmrc = Object.assign({}, npmrc, readOptions(logger, true, verbose));
+            }
+            catch (_b) { }
+        }
+    }
+}
+function readOptions(logger, yarn = false, showPotentials = false) {
+    const cwd = process.cwd();
+    const baseFilename = yarn ? 'yarnrc' : 'npmrc';
+    const dotFilename = '.' + baseFilename;
+    let globalPrefix;
+    if (process.env.PREFIX) {
+        globalPrefix = process.env.PREFIX;
+    }
+    else {
+        globalPrefix = path.dirname(process.execPath);
+        if (process.platform !== 'win32') {
+            globalPrefix = path.dirname(globalPrefix);
+        }
+    }
+    const defaultConfigLocations = [
+        path.join(globalPrefix, 'etc', baseFilename),
+        path.join(os_1.homedir(), dotFilename),
+    ];
+    const projectConfigLocations = [
+        path.join(cwd, dotFilename),
+    ];
+    const root = path.parse(cwd).root;
+    for (let curDir = path.dirname(cwd); curDir && curDir !== root; curDir = path.dirname(curDir)) {
+        projectConfigLocations.unshift(path.join(curDir, dotFilename));
+    }
+    if (showPotentials) {
+        logger.info(`Locating potential ${baseFilename} files:`);
+    }
+    let options = {};
+    for (const location of [...defaultConfigLocations, ...projectConfigLocations]) {
+        if (fs_1.existsSync(location)) {
+            if (showPotentials) {
+                logger.info(`Trying '${location}'...found.`);
+            }
+            const data = fs_1.readFileSync(location, 'utf8');
+            options = Object.assign({}, options, (yarn ? lockfile.parse(data) : ini.parse(data)));
+            if (options.cafile) {
+                const cafile = path.resolve(path.dirname(location), options.cafile);
+                delete options.cafile;
+                try {
+                    options.ca = fs_1.readFileSync(cafile, 'utf8').replace(/\r?\n/, '\\n');
+                }
+                catch (_a) { }
+            }
+        }
+        else if (showPotentials) {
+            logger.info(`Trying '${location}'...not found.`);
+        }
+    }
+    // Substitute any environment variable references
+    for (const key in options) {
+        options[key] = options[key].replace(/\$\{([^\}]+)\}/, (_, name) => process.env[name] || '');
+    }
+    return options;
+}
+function normalizeManifest(rawManifest) {
+    // TODO: Fully normalize and sanitize
+    return Object.assign({ dependencies: {}, devDependencies: {}, peerDependencies: {}, optionalDependencies: {} }, rawManifest);
+}
+function fetchPackageMetadata(name, logger, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { usingYarn, verbose, registry } = Object.assign({ registry: undefined, usingYarn: false, verbose: false }, options);
+        ensureNpmrc(logger, usingYarn, verbose);
+        const response = yield pacote.packument(name, Object.assign({ 'full-metadata': true }, npmrc, (registry ? { registry } : {})));
+        // Normalize the response
+        const metadata = {
+            name: response.name,
+            tags: {},
+            versions: new Map(),
+        };
+        if (response.versions) {
+            for (const [version, manifest] of Object.entries(response.versions)) {
+                metadata.versions.set(version, normalizeManifest(manifest));
+            }
+        }
+        if (response['dist-tags']) {
+            for (const [tag, version] of Object.entries(response['dist-tags'])) {
+                const manifest = metadata.versions.get(version);
+                if (manifest) {
+                    metadata.tags[tag] = manifest;
+                }
+                else if (verbose) {
+                    logger.warn(`Package ${metadata.name} has invalid version metadata for '${tag}'.`);
+                }
+            }
+        }
+        return metadata;
+    });
+}
+exports.fetchPackageMetadata = fetchPackageMetadata;
+function fetchPackageManifest(name, logger, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { usingYarn, verbose, registry } = Object.assign({ registry: undefined, usingYarn: false, verbose: false }, options);
+        ensureNpmrc(logger, usingYarn, verbose);
+        const response = yield pacote.manifest(name, Object.assign({ 'full-metadata': true }, npmrc, (registry ? { registry } : {})));
+        return normalizeManifest(response);
+    });
+}
+exports.fetchPackageManifest = fetchPackageManifest;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"package-metadata.js","sourceRoot":"./","sources":["packages/angular/cli/utilities/package-metadata.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { logging } from '@angular-devkit/core';\nimport { existsSync, readFileSync } from 'fs';\nimport { homedir } from 'os';\nimport * as path from 'path';\n\nconst ini = require('ini');\nconst lockfile = require('@yarnpkg/lockfile');\nconst pacote = require('pacote');\n\nexport interface PackageDependencies {\n  [dependency: string]: string;\n}\n\nexport interface PackageIdentifier {\n  type: 'git' | 'tag' | 'version' | 'range' | 'file' | 'directory' | 'remote';\n  name: string;\n  scope: string | null;\n  registry: boolean;\n  raw: string;\n}\n\nexport interface PackageManifest {\n  name: string;\n  version: string;\n  license?: string;\n  private?: boolean;\n  deprecated?: boolean;\n\n  dependencies: PackageDependencies;\n  devDependencies: PackageDependencies;\n  peerDependencies: PackageDependencies;\n  optionalDependencies: PackageDependencies;\n\n  'ng-add'?: {\n\n  };\n  'ng-update'?: {\n    migrations: string,\n    packageGroup: { [name: string]: string },\n  };\n}\n\nexport interface PackageMetadata {\n  name: string;\n  tags: { [tag: string]: PackageManifest | undefined };\n  versions: Map<string, PackageManifest>;\n}\n\nlet npmrc: { [key: string]: string };\n\nfunction ensureNpmrc(logger: logging.LoggerApi, usingYarn: boolean, verbose: boolean): void {\n  if (!npmrc) {\n    try {\n      npmrc = readOptions(logger, false, verbose);\n    } catch { }\n\n    if (usingYarn) {\n      try {\n        npmrc = { ...npmrc, ...readOptions(logger, true, verbose) };\n      } catch { }\n    }\n  }\n}\n\nfunction readOptions(\n  logger: logging.LoggerApi,\n  yarn = false,\n  showPotentials = false,\n): Record<string, string> {\n  const cwd = process.cwd();\n  const baseFilename = yarn ? 'yarnrc' : 'npmrc';\n  const dotFilename = '.' + baseFilename;\n\n  let globalPrefix: string;\n  if (process.env.PREFIX) {\n    globalPrefix = process.env.PREFIX;\n  } else {\n    globalPrefix = path.dirname(process.execPath);\n    if (process.platform !== 'win32') {\n      globalPrefix = path.dirname(globalPrefix);\n    }\n  }\n\n  const defaultConfigLocations = [\n    path.join(globalPrefix, 'etc', baseFilename),\n    path.join(homedir(), dotFilename),\n  ];\n\n  const projectConfigLocations: string[] = [\n    path.join(cwd, dotFilename),\n  ];\n  const root = path.parse(cwd).root;\n  for (let curDir = path.dirname(cwd); curDir && curDir !== root; curDir = path.dirname(curDir)) {\n    projectConfigLocations.unshift(path.join(curDir, dotFilename));\n  }\n\n  if (showPotentials) {\n    logger.info(`Locating potential ${baseFilename} files:`);\n  }\n\n  let options: { [key: string]: string } = {};\n  for (const location of [...defaultConfigLocations, ...projectConfigLocations]) {\n    if (existsSync(location)) {\n      if (showPotentials) {\n        logger.info(`Trying '${location}'...found.`);\n      }\n\n      const data = readFileSync(location, 'utf8');\n      options = {\n        ...options,\n        ...(yarn ? lockfile.parse(data) : ini.parse(data)),\n      };\n\n      if (options.cafile) {\n        const cafile = path.resolve(path.dirname(location), options.cafile);\n        delete options.cafile;\n        try {\n          options.ca = readFileSync(cafile, 'utf8').replace(/\\r?\\n/, '\\\\n');\n        } catch { }\n      }\n    } else if (showPotentials) {\n      logger.info(`Trying '${location}'...not found.`);\n    }\n  }\n\n  // Substitute any environment variable references\n  for (const key in options) {\n    options[key] = options[key].replace(/\\$\\{([^\\}]+)\\}/, (_, name) => process.env[name] || '');\n  }\n\n  return options;\n}\n\nfunction normalizeManifest(rawManifest: {}): PackageManifest {\n  // TODO: Fully normalize and sanitize\n\n  return {\n    dependencies: {},\n    devDependencies: {},\n    peerDependencies: {},\n    optionalDependencies: {},\n    // tslint:disable-next-line:no-any\n    ...rawManifest as any,\n  };\n}\n\nexport async function fetchPackageMetadata(\n  name: string,\n  logger: logging.LoggerApi,\n  options?: {\n    registry?: string;\n    usingYarn?: boolean;\n    verbose?: boolean;\n  },\n): Promise<PackageMetadata> {\n  const { usingYarn, verbose, registry } = {\n    registry: undefined,\n    usingYarn: false,\n    verbose: false,\n    ...options,\n  };\n\n  ensureNpmrc(logger, usingYarn, verbose);\n\n  const response = await pacote.packument(\n    name,\n    {\n      'full-metadata': true,\n      ...npmrc,\n      ...(registry ? { registry } : {}),\n    },\n  );\n\n  // Normalize the response\n  const metadata: PackageMetadata = {\n    name: response.name,\n    tags: {},\n    versions: new Map(),\n  };\n\n  if (response.versions) {\n    for (const [version, manifest] of Object.entries(response.versions)) {\n      metadata.versions.set(version, normalizeManifest(manifest));\n    }\n  }\n\n  if (response['dist-tags']) {\n    for (const [tag, version] of Object.entries(response['dist-tags'])) {\n      const manifest = metadata.versions.get(version as string);\n      if (manifest) {\n        metadata.tags[tag] = manifest;\n      } else if (verbose) {\n        logger.warn(`Package ${metadata.name} has invalid version metadata for '${tag}'.`);\n      }\n    }\n  }\n\n  return metadata;\n}\n\nexport async function fetchPackageManifest(\n  name: string,\n  logger: logging.LoggerApi,\n  options?: {\n    registry?: string;\n    usingYarn?: boolean;\n    verbose?: boolean;\n  },\n): Promise<PackageManifest> {\n  const { usingYarn, verbose, registry } = {\n    registry: undefined,\n    usingYarn: false,\n    verbose: false,\n    ...options,\n  };\n\n  ensureNpmrc(logger, usingYarn, verbose);\n\n  const response = await pacote.manifest(\n    name,\n    {\n      'full-metadata': true,\n      ...npmrc,\n      ...(registry ? { registry } : {}),\n    },\n  );\n\n  return normalizeManifest(response);\n}\n"]}