@angular-devkit/build-angular 0.803.0-rc.0 → 0.803.3

package/package.json

@@ -1,28 +1,30 @@
 {
   "name": "@angular-devkit/build-angular",
-  "version": "0.803.0-rc.0",
+  "version": "0.803.3",
   "description": "Angular Webpack Build Facade",
   "experimental": true,
   "main": "src/index.js",
   "typings": "src/index.d.ts",
   "builders": "builders.json",
   "dependencies": {
-    "@angular-devkit/architect": "0.803.0-rc.0",
-    "@angular-devkit/build-optimizer": "0.803.0-rc.0",
-    "@angular-devkit/build-webpack": "0.803.0-rc.0",
-    "@angular-devkit/core": "8.3.0-rc.0",
+    "@angular-devkit/architect": "0.803.3",
+    "@angular-devkit/build-optimizer": "0.803.3",
+    "@angular-devkit/build-webpack": "0.803.3",
+    "@angular-devkit/core": "8.3.3",
     "@babel/core": "7.5.5",
     "@babel/preset-env": "7.5.5",
-    "@ngtools/webpack": "8.3.0-rc.0",
+    "@ngtools/webpack": "8.3.3",
     "ajv": "6.10.2",
     "autoprefixer": "9.6.1",
     "browserslist": "4.6.6",
+    "cacache": "12.0.2",
     "caniuse-lite": "1.0.30000989",
     "circular-dependency-plugin": "5.2.0",
     "clean-css": "4.2.1",
     "copy-webpack-plugin": "5.0.4",
     "core-js": "3.2.1",
     "file-loader": "4.2.0",
+    "find-cache-dir": "3.0.0",
     "glob": "7.1.4",
     "istanbul-instrumenter-loader": "3.0.1",
     "karma-source-map-support": "1.4.0",
@@ -38,6 +40,7 @@
     "postcss-import": "12.0.1",
     "postcss-loader": "3.0.0",
     "raw-loader": "3.1.0",
+    "regenerator-runtime": "0.13.3",
     "rxjs": "6.4.0",
     "sass": "1.22.9",
     "sass-loader": "7.2.0",
@@ -59,7 +62,7 @@
     "webpack-sources": "1.4.3",
     "webpack-subresource-integrity": "1.1.0-rc.6",
     "worker-farm": "1.7.0",
-    "worker-plugin": "3.1.0"
+    "worker-plugin": "3.2.0"
   },
   "peerDependencies": {
     "@angular/compiler-cli": "^8.0.0-beta.0 || ^8.1.0-beta.0 || ^8.2.0-beta.0 || ^8.3.0-beta.0 || ^8.4.0-beta.0 || >=9.0.0-beta < 9",

package/src/angular-cli-files/models/es5-polyfills.js

@@ -7,10 +7,7 @@
  */
 
 // ES2015 symbol capabilities
-import 'core-js/modules/es.symbol';
-import 'core-js/modules/es.symbol.description';
-import 'core-js/modules/es.symbol.iterator';
-import 'core-js/modules/es.symbol.to-string-tag';
+import 'core-js/es/symbol';
 
 // ES2015 function capabilities
 import 'core-js/modules/es.function.bind';
@@ -103,3 +100,5 @@ import 'core-js/modules/web.dom-collections.for-each';
 import 'core-js/modules/web.dom-collections.iterator';
 import 'core-js/modules/es.promise';
 import 'core-js/modules/es.json.to-string-tag';
+
+import 'regenerator-runtime/runtime';

package/src/angular-cli-files/models/webpack-configs/common.js

@@ -15,6 +15,7 @@ const typescript_1 = require("typescript");
 const webpack_1 = require("webpack");
 const webpack_sources_1 = require("webpack-sources");
 const utils_1 = require("../../../utils");
+const mangle_options_1 = require("../../../utils/mangle-options");
 const bundle_budget_1 = require("../../plugins/bundle-budget");
 const cleancss_webpack_plugin_1 = require("../../plugins/cleancss-webpack-plugin");
 const named_chunks_plugin_1 = require("../../plugins/named-chunks-plugin");
@@ -271,6 +272,7 @@ function getCommonConfig(wco) {
             compress: buildOptions.platform == 'server'
                 ? {
                     global_defs: angularGlobalDefinitions,
+                    keep_fnames: true,
                 }
                 : {
                     pure_getters: buildOptions.buildOptimizer,
@@ -281,7 +283,8 @@ function getCommonConfig(wco) {
                 },
             // We also want to avoid mangling on server.
             // Name mangling is handled within the browser builder
-            mangle: buildOptions.platform !== 'server' &&
+            mangle: !mangle_options_1.manglingDisabled &&
+                buildOptions.platform !== 'server' &&
                 (!differentialLoadingNeeded || (differentialLoadingNeeded && utils_1.fullDifferential)),
         };
         extraMinimizers.push(new TerserPlugin({

package/src/browser/index.js

@@ -11,6 +11,8 @@ const architect_1 = require("@angular-devkit/architect");
 const build_webpack_1 = require("@angular-devkit/build-webpack");
 const core_1 = require("@angular-devkit/core");
 const node_1 = require("@angular-devkit/core/node");
+const crypto_1 = require("crypto");
+const findCacheDirectory = require("find-cache-dir");
 const fs = require("fs");
 const path = require("path");
 const rxjs_1 = require("rxjs");
@@ -26,6 +28,9 @@ const stats_1 = require("../angular-cli-files/utilities/stats");
 const utils_1 = require("../utils");
 const version_1 = require("../utils/version");
 const webpack_browser_config_1 = require("../utils/webpack-browser-config");
+const cacache = require('cacache');
+const cacheDownlevelPath = findCacheDirectory({ name: 'angular-build-dl' });
+const packageVersion = require('../../package.json').version;
 function createBrowserLoggingCallback(verbose, logger) {
     return (stats, config) => {
         // config.stats contains our own stats settings, added during buildWebpackConfig().
@@ -132,7 +137,9 @@ function buildWebpackBrowser(options, context, transforms = {}) {
             else {
                 return rxjs_1.of();
             }
-        }, { success: true }, 1), operators_1.bufferCount(configs.length), operators_1.switchMap(async (buildEvents) => {
+        }, { success: true }, 1), operators_1.bufferCount(configs.length), 
+        // tslint:disable-next-line: no-big-function
+        operators_1.switchMap(async (buildEvents) => {
             configs.length = 0;
             const success = buildEvents.every(r => r.success);
             if (success) {
@@ -158,10 +165,15 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                         optimize: utils_1.normalizeOptimization(options.optimization).scripts,
                         sourceMaps: sourceMapOptions.scripts,
                         hiddenSourceMaps: sourceMapOptions.hidden,
+                        vendorSourceMaps: sourceMapOptions.vendor,
                     };
                     const actions = [];
                     const seen = new Set();
                     for (const file of emittedFiles) {
+                        // Assets are not processed nor injected into the index
+                        if (file.asset) {
+                            continue;
+                        }
                         // Scripts and non-javascript files are not processed
                         if (file.extension !== '.js' ||
                             (file.name && scriptsEntryPointName.includes(file.name))) {
@@ -223,6 +235,7 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                             code,
                             map,
                             runtime: file.file.startsWith('runtime'),
+                            ignoreOriginal: es5Polyfills,
                         });
                         // Add the newly created ES5 bundles to the index as nomodule scripts
                         const newFilename = es5Polyfills
@@ -232,26 +245,123 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                     }
                     // Execute the bundle processing actions
                     context.logger.info('Generating ES5 bundles for differential loading...');
-                    await new Promise((resolve, reject) => {
-                        const workerFile = require.resolve('../utils/process-bundle');
-                        const workers = workerFarm({
-                            maxRetries: 1,
-                        }, path.extname(workerFile) !== '.ts'
-                            ? workerFile
-                            : require.resolve('../utils/process-bundle-bootstrap'), ['process']);
-                        let completed = 0;
-                        const workCallback = (error) => {
-                            if (error) {
-                                workerFarm.end(workers);
-                                reject(error);
+                    const processActions = [];
+                    const cacheActions = [];
+                    for (const action of actions) {
+                        // Create base cache key with elements:
+                        // * package version - different build-angular versions cause different final outputs
+                        // * code length/hash - ensure cached version matches the same input code
+                        const codeHash = crypto_1.createHash('sha1')
+                            .update(action.code)
+                            .digest('hex');
+                        const baseCacheKey = `${packageVersion}|${action.code.length}|${codeHash}`;
+                        // Postfix added to sourcemap cache keys when vendor sourcemaps are present
+                        // Allows non-destructive caching of both variants
+                        const SourceMapVendorPostfix = !!action.sourceMaps && action.vendorSourceMaps ? '|vendor' : '';
+                        // Determine cache entries required based on build settings
+                        const cacheKeys = [];
+                        // If optimizing and the original is not ignored, add original as required
+                        if ((action.optimize || action.optimizeOnly) && !action.ignoreOriginal) {
+                            cacheKeys[0 /* OriginalCode */] = baseCacheKey + '|orig';
+                            // If sourcemaps are enabled, add original sourcemap as required
+                            if (action.sourceMaps) {
+                                cacheKeys[1 /* OriginalMap */] =
+                                    baseCacheKey + SourceMapVendorPostfix + '|orig-map';
+                            }
+                        }
+                        // If not only optimizing, add downlevel as required
+                        if (!action.optimizeOnly) {
+                            cacheKeys[2 /* DownlevelCode */] = baseCacheKey + '|dl';
+                            // If sourcemaps are enabled, add downlevel sourcemap as required
+                            if (action.sourceMaps) {
+                                cacheKeys[3 /* DownlevelMap */] =
+                                    baseCacheKey + SourceMapVendorPostfix + '|dl-map';
+                            }
+                        }
+                        // Attempt to get required cache entries
+                        const cacheEntries = [];
+                        for (const key of cacheKeys) {
+                            if (key) {
+                                cacheEntries.push(await cacache.get.info(cacheDownlevelPath, key));
+                            }
+                            else {
+                                cacheEntries.push(null);
+                            }
+                        }
+                        // Check if required cache entries are present
+                        let cached = cacheKeys.length > 0;
+                        for (let i = 0; i < cacheKeys.length; ++i) {
+                            if (cacheKeys[i] && !cacheEntries[i]) {
+                                cached = false;
+                                break;
+                            }
+                        }
+                        // If all required cached entries are present, use the cached entries
+                        // Otherwise process the files
+                        if (cached) {
+                            if (cacheEntries[0 /* OriginalCode */]) {
+                                cacheActions.push({
+                                    src: cacheEntries[0 /* OriginalCode */].path,
+                                    dest: action.filename,
+                                });
+                            }
+                            if (cacheEntries[1 /* OriginalMap */]) {
+                                cacheActions.push({
+                                    src: cacheEntries[1 /* OriginalMap */].path,
+                                    dest: action.filename + '.map',
+                                });
                             }
-                            else if (++completed === actions.length) {
-                                workerFarm.end(workers);
-                                resolve();
+                            if (cacheEntries[2 /* DownlevelCode */]) {
+                                cacheActions.push({
+                                    src: cacheEntries[2 /* DownlevelCode */].path,
+                                    dest: action.filename.replace('es2015', 'es5'),
+                                });
                             }
-                        };
-                        actions.forEach(action => workers['process'](action, workCallback));
-                    });
+                            if (cacheEntries[3 /* DownlevelMap */]) {
+                                cacheActions.push({
+                                    src: cacheEntries[3 /* DownlevelMap */].path,
+                                    dest: action.filename.replace('es2015', 'es5') + '.map',
+                                });
+                            }
+                        }
+                        else {
+                            processActions.push({
+                                ...action,
+                                cacheKeys,
+                                cachePath: cacheDownlevelPath || undefined,
+                            });
+                        }
+                    }
+                    for (const action of cacheActions) {
+                        fs.copyFileSync(action.src, action.dest, fs.constants.COPYFILE_FICLONE);
+                        if (process.platform !== 'win32') {
+                            // The cache writes entries as readonly and when using copyFile the permissions will also be copied.
+                            // See: https://github.com/npm/cacache/blob/073fbe1a9f789ba42d9a41de7b8429c93cf61579/lib/util/move-file.js#L36
+                            fs.chmodSync(action.dest, 0o644);
+                        }
+                    }
+                    if (processActions.length > 0) {
+                        await new Promise((resolve, reject) => {
+                            const workerFile = require.resolve('../utils/process-bundle');
+                            const workers = workerFarm({
+                                maxRetries: 1,
+                            }, path.extname(workerFile) !== '.ts'
+                                ? workerFile
+                                : require.resolve('../utils/process-bundle-bootstrap'), ['process']);
+                            let completed = 0;
+                            const workCallback = (error) => {
+                                if (error) {
+                                    workerFarm.end(workers);
+                                    reject(error);
+                                }
+                                else if (++completed === processActions.length) {
+                                    workerFarm.end(workers);
+                                    resolve();
+                                }
+                            };
+                            processActions.forEach(action => workers['process'](action, workCallback));
+                        });
+                    }
                     context.logger.info('ES5 bundle generation complete.');
                 }
                 else {

package/src/protractor/schema.d.ts

@@ -4,7 +4,6 @@
 export interface Schema {
     /**
      * Base URL for protractor to connect to.
-     * @deprecated Use "baseUrl" in the Protractor config file instead.
      */
     baseUrl?: string;
     /**

package/src/protractor/schema.json

@@ -45,8 +45,7 @@
     },
     "baseUrl": {
       "type": "string",
-      "description": "Base URL for protractor to connect to.",
-      "x-deprecated": "Use \"baseUrl\" in the Protractor config file instead."
+      "description": "Base URL for protractor to connect to."
     }
   },
   "additionalProperties": false,

package/src/utils/mangle-options.d.ts

@@ -0,0 +1 @@
+export declare const manglingDisabled: boolean;

package/src/utils/mangle-options.js

@@ -0,0 +1,11 @@
+"use strict";
+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
+ */
+const mangleVariable = process.env['NG_BUILD_MANGLE'];
+exports.manglingDisabled = !!mangleVariable && (mangleVariable === '0' || mangleVariable.toLowerCase() === 'false');

package/src/utils/process-bundle.d.ts

@@ -1,12 +1,21 @@
-interface ProcessBundleOptions {
+export interface ProcessBundleOptions {
     filename: string;
     code: string;
     map?: string;
-    sourceMaps: boolean;
-    hiddenSourceMaps: boolean;
-    runtime: boolean;
+    sourceMaps?: boolean;
+    hiddenSourceMaps?: boolean;
+    vendorSourceMaps?: boolean;
+    runtime?: boolean;
     optimize: boolean;
     optimizeOnly?: boolean;
+    ignoreOriginal?: boolean;
+    cacheKeys?: (string | null)[];
+    cachePath?: string;
+}
+export declare const enum CacheKey {
+    OriginalCode = 0,
+    OriginalMap = 1,
+    DownlevelCode = 2,
+    DownlevelMap = 3
 }
 export declare function process(options: ProcessBundleOptions, callback: (error: Error | null, result?: {}) => void): void;
-export {};

package/src/utils/process-bundle.js

@@ -11,12 +11,17 @@ const fs = require("fs");
 const path = require("path");
 const source_map_1 = require("source-map");
 const terser_1 = require("terser");
+const mangle_options_1 = require("./mangle-options");
 const { transformAsync } = require('@babel/core');
+const cacache = require('cacache');
 function process(options, callback) {
     processWorker(options).then(() => callback(null, {}), error => callback(error));
 }
 exports.process = process;
 async function processWorker(options) {
+    if (!options.cacheKeys) {
+        options.cacheKeys = [];
+    }
     // If no downlevelling required than just mangle code and return
     if (options.optimizeOnly) {
         return mangleOriginal(options);
@@ -88,11 +93,10 @@ async function processWorker(options) {
         // estree -> terser is already supported; need babel -> estree/terser
         // Mangle downlevel code
         const result = terser_1.minify(code, {
-            compress: false,
+            compress: true,
             ecma: 5,
-            mangle: true,
+            mangle: !mangle_options_1.manglingDisabled,
             safari10: true,
-            toplevel: true,
             output: {
                 ascii_only: true,
                 webkit: true,
@@ -108,7 +112,9 @@ async function processWorker(options) {
         code = result.code;
         map = result.map;
         // Mangle original code
-        mangleOriginal(options);
+        if (!options.ignoreOriginal) {
+            await mangleOriginal(options);
+        }
     }
     else if (map) {
         map = JSON.stringify(map);
@@ -117,15 +123,21 @@ async function processWorker(options) {
         if (!options.hiddenSourceMaps) {
             code += `\n//# sourceMappingURL=${path.basename(newFilePath)}.map`;
         }
+        if (options.cachePath && options.cacheKeys[3 /* DownlevelMap */]) {
+            await cacache.put(options.cachePath, options.cacheKeys[3 /* DownlevelMap */], map);
+        }
         fs.writeFileSync(newFilePath + '.map', map);
     }
+    if (options.cachePath && options.cacheKeys[2 /* DownlevelCode */]) {
+        await cacache.put(options.cachePath, options.cacheKeys[2 /* DownlevelCode */], code);
+    }
     fs.writeFileSync(newFilePath, code);
 }
-function mangleOriginal(options) {
+async function mangleOriginal(options) {
     const resultOriginal = terser_1.minify(options.code, {
         compress: false,
         ecma: 6,
-        mangle: true,
+        mangle: !mangle_options_1.manglingDisabled,
         safari10: true,
         output: {
             ascii_only: true,
@@ -140,8 +152,17 @@ function mangleOriginal(options) {
     if (resultOriginal.error) {
         throw resultOriginal.error;
     }
-    fs.writeFileSync(options.filename, resultOriginal.code);
     if (resultOriginal.map) {
+        if (!options.hiddenSourceMaps) {
+            resultOriginal.code += `\n//# sourceMappingURL=${path.basename(options.filename)}.map`;
+        }
+        if (options.cachePath && options.cacheKeys && options.cacheKeys[1 /* OriginalMap */]) {
+            await cacache.put(options.cachePath, options.cacheKeys[1 /* OriginalMap */], resultOriginal.map);
+        }
         fs.writeFileSync(options.filename + '.map', resultOriginal.map);
     }
+    if (options.cachePath && options.cacheKeys && options.cacheKeys[0 /* OriginalCode */]) {
+        await cacache.put(options.cachePath, options.cacheKeys[0 /* OriginalCode */], resultOriginal.code);
+    }
+    fs.writeFileSync(options.filename, resultOriginal.code);
 }