@angular/cli 8.3.2 → 8.3.6

package/bin/postinstall/analytics-prompt.js

@@ -1,16 +1,14 @@
 'use strict';
-// This file is ES6 because it needs to be executed as is.
+// This file is ES5 because it needs to be executed as is.
 
-if ('NG_CLI_ANALYTICS' in process.env) {
+if (process.env['NG_CLI_ANALYTICS'] !== undefined) {
   return;
 }
 
-(async () => {
-  try {
-    const analytics = require('../../models/analytics');
+try {
+  var analytics = require('../../models/analytics');
 
-    if (!analytics.hasGlobalAnalyticsConfiguration()) {
-      await analytics.promptGlobalAnalytics();
-    }
-  } catch (_) {}
-})();
+  if (!analytics.hasGlobalAnalyticsConfiguration()) {
+    analytics.promptGlobalAnalytics().catch(function() { });
+  }
+} catch (_) {}

package/commands/add-impl.js

@@ -75,7 +75,7 @@ class AddCommand extends schematic_command_1.SchematicCommand {
             }
             else if (!latestManifest || (await 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));
+                const versionManifests = Object.values(packageMetadata.versions).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) {

package/commands/update-impl.js

@@ -10,12 +10,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const fs = require("fs");
 const path = require("path");
-const semver = require("semver");
 const schematic_command_1 = require("../models/schematic-command");
 const package_manager_1 = require("../utilities/package-manager");
 const package_metadata_1 = require("../utilities/package-metadata");
 const package_tree_1 = require("../utilities/package-tree");
 const npa = require('npm-package-arg');
+const pickManifest = require('npm-pick-manifest');
 const oldConfigFileNames = ['.angular-cli.json', 'angular-cli.json'];
 class UpdateCommand extends schematic_command_1.SchematicCommand {
     constructor() {
@@ -121,25 +121,25 @@ class UpdateCommand extends schematic_command_1.SchematicCommand {
                 this.logger.warn('"next" option has no effect when using "migrate-only" option.');
             }
             const packageName = packages[0].name;
-            let packageNode = rootDependencies[packageName];
-            if (typeof packageNode === 'string') {
+            const packageDependency = rootDependencies[packageName];
+            let packageNode = packageDependency && packageDependency.node;
+            if (packageDependency && !packageNode) {
                 this.logger.error('Package found in package.json but is not installed.');
                 return 1;
             }
-            else if (!packageNode) {
+            else if (!packageDependency) {
                 // Allow running migrations on transitively installed dependencies
                 // There can technically be nested multiple versions
                 // TODO: If multiple, this should find all versions and ask which one to use
                 const child = packageTree.children.find(c => c.name === packageName);
                 if (child) {
-                    // A link represents a symlinked package so use the actual in this case
-                    packageNode = child.isLink ? child.target : child;
-                }
-                if (!packageNode) {
-                    this.logger.error('Package is not installed.');
-                    return 1;
+                    packageNode = child;
                 }
             }
+            if (!packageNode) {
+                this.logger.error('Package is not installed.');
+                return 1;
+            }
             const updateMetadata = packageNode.package['ng-update'];
             let migrations = updateMetadata && updateMetadata.migrations;
             if (migrations === undefined) {
@@ -200,15 +200,13 @@ class UpdateCommand extends schematic_command_1.SchematicCommand {
         const requests = [];
         // Validate packages actually are part of the workspace
         for (const pkg of packages) {
-            const node = rootDependencies[pkg.name];
+            const node = rootDependencies[pkg.name] && rootDependencies[pkg.name].node;
             if (!node) {
                 this.logger.error(`Package '${pkg.name}' is not a dependency.`);
                 return 1;
             }
             // If a specific version is requested and matches the installed version, skip.
-            if (pkg.type === 'version' &&
-                typeof node === 'object' &&
-                node.package.version === pkg.fetchSpec) {
+            if (pkg.type === 'version' && node.package.version === pkg.fetchSpec) {
                 this.logger.info(`Package '${pkg.name}' is already at '${pkg.fetchSpec}'.`);
                 continue;
             }
@@ -234,24 +232,39 @@ class UpdateCommand extends schematic_command_1.SchematicCommand {
             // Try to find a package version based on the user requested package specifier
             // registry specifier types are either version, range, or tag
             let manifest;
-            if (requestIdentifier.type === 'version') {
-                manifest = metadata.versions.get(requestIdentifier.fetchSpec);
-            }
-            else if (requestIdentifier.type === 'range') {
-                const maxVersion = semver.maxSatisfying(Array.from(metadata.versions.keys()), requestIdentifier.fetchSpec);
-                if (maxVersion) {
-                    manifest = metadata.versions.get(maxVersion);
+            if (requestIdentifier.type === 'version' ||
+                requestIdentifier.type === 'range' ||
+                requestIdentifier.type === 'tag') {
+                try {
+                    manifest = pickManifest(metadata, requestIdentifier.fetchSpec);
+                }
+                catch (e) {
+                    if (e.code === 'ETARGET') {
+                        // If not found and next was used and user did not provide a specifier, try latest.
+                        // Package may not have a next tag.
+                        if (requestIdentifier.type === 'tag' &&
+                            requestIdentifier.fetchSpec === 'next' &&
+                            !requestIdentifier.rawSpec) {
+                            try {
+                                manifest = pickManifest(metadata, 'latest');
+                            }
+                            catch (e) {
+                                if (e.code !== 'ETARGET' && e.code !== 'ENOVERSIONS') {
+                                    throw e;
+                                }
+                            }
+                        }
+                    }
+                    else if (e.code !== 'ENOVERSIONS') {
+                        throw e;
+                    }
                 }
-            }
-            else if (requestIdentifier.type === 'tag') {
-                manifest = metadata.tags[requestIdentifier.fetchSpec];
             }
             if (!manifest) {
                 this.logger.error(`Package specified by '${requestIdentifier.raw}' does not exist within the registry.`);
                 return 1;
             }
-            if ((typeof node === 'string' && manifest.version === node) ||
-                (typeof node === 'object' && manifest.version === node.package.version)) {
+            if (manifest.version === node.package.version) {
                 this.logger.info(`Package '${packageName}' is already up to date.`);
                 continue;
             }

package/lib/config/schema.json

@@ -847,8 +847,31 @@
               "default": false
             },
             "index": {
-              "type": "string",
-              "description": "The name of the index HTML file."
+              "description": "Configures the generation of the application's HTML index.",
+              "oneOf": [
+                {
+                  "type": "string",
+                  "description": "The path of a file to use for the application's HTML index. The filename of the specified path will be used for the generated file and will be created in the root of the application's configured output path."
+                },
+                {
+                  "type": "object",
+                  "description": "",
+                  "properties": {
+                    "input": {
+                      "type": "string",
+                      "minLength": 1,
+                      "description": "The path of a file to use for the application's generated HTML index."
+                    },
+                    "output": {
+                      "type": "string",
+                      "minLength": 1,
+                      "default": "index.html",
+                      "description": "The output path of the application's generated HTML index file. The full provided path will be used and will be considered relative to the application's configured output path."
+                    }
+                  },
+                  "required": ["input"]
+                }
+              ]
             },
             "statsJson": {
               "type": "boolean",

package/models/parser.js

@@ -164,7 +164,7 @@ function _assignOption(arg, nextArg, { options, parsedOptions, leftovers, ignore
         const v = _coerce(value, option, parsedOptions[option.name]);
         if (v !== undefined) {
             if (parsedOptions[option.name] !== v) {
-                if (parsedOptions[option.name] !== undefined) {
+                if (parsedOptions[option.name] !== undefined && option.type !== interface_1.OptionType.Array) {
                     warnings.push(`Option ${JSON.stringify(option.name)} was already specified with value `
                         + `${JSON.stringify(parsedOptions[option.name])}. The new value ${JSON.stringify(v)} `
                         + `will override it.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/cli",
-  "version": "8.3.2",
+  "version": "8.3.6",
   "description": "CLI tool for Angular",
   "main": "lib/cli/index.js",
   "bin": {
@@ -28,17 +28,18 @@
   },
   "homepage": "https://github.com/angular/angular-cli",
   "dependencies": {
-    "@angular-devkit/architect": "0.803.2",
-    "@angular-devkit/core": "8.3.2",
-    "@angular-devkit/schematics": "8.3.2",
-    "@schematics/angular": "8.3.2",
-    "@schematics/update": "0.803.2",
+    "@angular-devkit/architect": "0.803.6",
+    "@angular-devkit/core": "8.3.6",
+    "@angular-devkit/schematics": "8.3.6",
+    "@schematics/angular": "8.3.6",
+    "@schematics/update": "0.803.6",
     "@yarnpkg/lockfile": "1.1.0",
     "ansi-colors": "4.1.1",
     "debug": "^4.1.1",
     "ini": "1.3.5",
     "inquirer": "6.5.1",
     "npm-package-arg": "6.1.0",
+    "npm-pick-manifest": "3.0.2",
     "open": "6.4.0",
     "pacote": "9.5.5",
     "read-package-tree": "5.3.1",
@@ -50,10 +51,10 @@
   "ng-update": {
     "migrations": "@schematics/angular/migrations/migration-collection.json",
     "packageGroup": {
-      "@angular/cli": "8.3.2",
-      "@angular-devkit/build-angular": "0.803.2",
-      "@angular-devkit/build-ng-packagr": "0.803.2",
-      "@angular-devkit/build-webpack": "0.803.2"
+      "@angular/cli": "8.3.6",
+      "@angular-devkit/build-angular": "0.803.6",
+      "@angular-devkit/build-ng-packagr": "0.803.6",
+      "@angular-devkit/build-webpack": "0.803.6"
     }
   },
   "engines": {

package/utilities/package-metadata.d.ts

@@ -41,7 +41,7 @@ export interface PackageMetadata {
     tags: {
         [tag: string]: PackageManifest | undefined;
     };
-    versions: Map<string, PackageManifest>;
+    versions: Record<string, PackageManifest>;
 }
 export declare function fetchPackageMetadata(name: string, logger: logging.LoggerApi, options?: {
     registry?: string;

package/utilities/package-metadata.js

@@ -39,9 +39,7 @@ function readOptions(logger, yarn = false, showPotentials = false) {
         path.join(globalPrefix, 'etc', baseFilename),
         path.join(os_1.homedir(), dotFilename),
     ];
-    const projectConfigLocations = [
-        path.join(cwd, 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));
@@ -109,16 +107,19 @@ async function fetchPackageMetadata(name, logger, options) {
     const metadata = {
         name: response.name,
         tags: {},
-        versions: new Map(),
+        versions: {},
     };
     if (response.versions) {
         for (const [version, manifest] of Object.entries(response.versions)) {
-            metadata.versions.set(version, normalizeManifest(manifest));
+            metadata.versions[version] = normalizeManifest(manifest);
         }
     }
     if (response['dist-tags']) {
+        // Store this for use with other npm utility packages
+        // tslint:disable-next-line: no-any
+        metadata['dist-tags'] = response['dist-tags'];
         for (const [tag, version] of Object.entries(response['dist-tags'])) {
-            const manifest = metadata.versions.get(version);
+            const manifest = metadata.versions[version];
             if (manifest) {
                 metadata.tags[tag] = manifest;
             }

package/utilities/package-tree.d.ts

@@ -18,21 +18,25 @@ export interface PackageTreeNodeBase {
         dependencies?: Record<string, string>;
         devDependencies?: Record<string, string>;
         peerDependencies?: Record<string, string>;
+        optionalDependencies?: Record<string, string>;
         'ng-update'?: {
             migrations?: string;
         };
     };
+    parent?: PackageTreeNode;
     children: PackageTreeNode[];
 }
 export interface PackageTreeActual extends PackageTreeNodeBase {
     isLink: false;
-    parent?: PackageTreeActual;
 }
 export interface PackageTreeLink extends PackageTreeNodeBase {
     isLink: true;
-    parent: null;
     target: PackageTreeActual;
 }
 export declare type PackageTreeNode = PackageTreeActual | PackageTreeLink;
 export declare function readPackageTree(path: string): Promise<PackageTreeNode>;
-export declare function findNodeDependencies(root: PackageTreeNode, node?: PackageTreeNode): Record<string, string | PackageTreeActual | undefined>;
+export interface NodeDependency {
+    version: string;
+    node?: PackageTreeNode;
+}
+export declare function findNodeDependencies(node: PackageTreeNode): Record<string, NodeDependency>;

package/utilities/package-tree.js

@@ -14,19 +14,25 @@ function readPackageTree(path) {
     });
 }
 exports.readPackageTree = readPackageTree;
-function findNodeDependencies(root, node = root) {
-    const actual = node.isLink ? node.target : node;
+function findNodeDependencies(node) {
     const rawDeps = {
-        ...actual.package.dependencies,
-        ...actual.package.devDependencies,
-        ...actual.package.peerDependencies,
+        ...node.package.dependencies,
+        ...node.package.devDependencies,
+        ...node.package.peerDependencies,
+        ...node.package.optionalDependencies,
     };
     return Object.entries(rawDeps).reduce((deps, [name, version]) => {
-        const depNode = root.children.find(child => {
-            return child.name === name && !child.isLink && child.parent === node;
-        });
-        deps[name] = depNode || version;
+        let dependencyNode;
+        let parent = node;
+        while (!dependencyNode && parent) {
+            dependencyNode = parent.children.find(child => child.name === name);
+            parent = parent.parent;
+        }
+        deps[name] = {
+            node: dependencyNode,
+            version,
+        };
         return deps;
-    }, {});
+    }, Object.create(null));
 }
 exports.findNodeDependencies = findNodeDependencies;