@angular-devkit/build-angular 0.803.4 → 0.803.8

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@angular-devkit/build-angular",
-  "version": "0.803.4",
+  "version": "0.803.8",
   "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.4",
-    "@angular-devkit/build-optimizer": "0.803.4",
-    "@angular-devkit/build-webpack": "0.803.4",
-    "@angular-devkit/core": "8.3.4",
+    "@angular-devkit/architect": "0.803.8",
+    "@angular-devkit/build-optimizer": "0.803.8",
+    "@angular-devkit/build-webpack": "0.803.8",
+    "@angular-devkit/core": "8.3.8",
     "@babel/core": "7.5.5",
     "@babel/preset-env": "7.5.5",
-    "@ngtools/webpack": "8.3.4",
+    "@ngtools/webpack": "8.3.8",
     "ajv": "6.10.2",
     "autoprefixer": "9.6.1",
     "browserslist": "4.6.6",
@@ -27,6 +27,7 @@
     "find-cache-dir": "3.0.0",
     "glob": "7.1.4",
     "istanbul-instrumenter-loader": "3.0.1",
+    "jest-worker": "24.9.0",
     "karma-source-map-support": "1.4.0",
     "less": "3.9.0",
     "less-loader": "5.0.0",
@@ -61,7 +62,6 @@
     "webpack-merge": "4.2.1",
     "webpack-sources": "1.4.3",
     "webpack-subresource-integrity": "1.1.0-rc.6",
-    "worker-farm": "1.7.0",
     "worker-plugin": "3.2.0"
   },
   "peerDependencies": {

package/plugins/webpack/analytics.d.ts

@@ -26,6 +26,7 @@ export declare function countOccurrences(source: string, match: string, wordBrea
  * Holder of statistics related to the build.
  */
 declare class AnalyticsBuildStats {
+    isIvy: boolean;
     errors: string[];
     numberOfNgOnInit: number;
     numberOfComponents: number;
@@ -51,7 +52,7 @@ export declare class NgBuildAnalyticsPlugin {
     constructor(_projectRoot: string, _analytics: analytics.Analytics, _category: string);
     protected _reset(): void;
     protected _getMetrics(stats: Stats): (string | number)[];
-    protected _getDimensions(stats: Stats): (string | number)[];
+    protected _getDimensions(stats: Stats): import("../../../../../dist-schema/packages/angular/cli/commands/config").Value[];
     protected _reportBuildMetrics(stats: Stats): void;
     protected _reportRebuildMetrics(stats: Stats): void;
     protected _checkTsNormalModule(module: NormalModule): void;

package/plugins/webpack/analytics.js

@@ -54,6 +54,7 @@ exports.countOccurrences = countOccurrences;
  */
 class AnalyticsBuildStats {
     constructor() {
+        this.isIvy = false;
         this.errors = [];
         this.numberOfNgOnInit = 0;
         this.numberOfComponents = 0;
@@ -106,6 +107,7 @@ class NgBuildAnalyticsPlugin {
             // Adding commas before and after so the regex are easier to define filters.
             dimensions[core_1.analytics.NgCliAnalyticsDimensions.BuildErrors] = `,${this._stats.errors.join()},`;
         }
+        dimensions[core_1.analytics.NgCliAnalyticsDimensions.NgIvyEnabled] = this._stats.isIvy;
         return dimensions;
     }
     _reportBuildMetrics(stats) {
@@ -129,7 +131,14 @@ class NgBuildAnalyticsPlugin {
             // This does not include View Engine AOT compilation, we use the ngfactory for it.
             this._stats.numberOfComponents += countOccurrences(module._source.source(), ' Component({');
             // For Ivy we just count ngComponentDef.
-            this._stats.numberOfComponents += countOccurrences(module._source.source(), 'ngComponentDef', true);
+            const numIvyComponents = countOccurrences(module._source.source(), 'ngComponentDef', true);
+            this._stats.numberOfComponents += numIvyComponents;
+            // Check whether this is an Ivy app so that it can reported as part of analytics.
+            if (!this._stats.isIvy) {
+                if (numIvyComponents > 0 || module._source.source().includes('ngModuleDef')) {
+                    this._stats.isIvy = true;
+                }
+            }
         }
     }
     _checkNgFactoryNormalModule(module) {

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

@@ -254,11 +254,13 @@ function getCommonConfig(wco) {
                 };
             }
         }
+        // TODO: Investigate why this fails for some packages: wco.supportES2015 ? 6 : 5;
+        const terserEcma = 5;
         const terserOptions = {
             warnings: !!buildOptions.verbose,
             safari10: true,
             output: {
-                ecma: wco.supportES2015 ? 6 : 5,
+                ecma: terserEcma,
                 comments: false,
                 webkit: true,
             },
@@ -266,12 +268,12 @@ function getCommonConfig(wco) {
             // to remove dev code, and ngI18nClosureMode to remove Closure compiler i18n code
             compress: buildOptions.platform == 'server'
                 ? {
-                    ecma: wco.supportES2015 ? 6 : 5,
+                    ecma: terserEcma,
                     global_defs: angularGlobalDefinitions,
                     keep_fnames: true,
                 }
                 : {
-                    ecma: wco.supportES2015 ? 6 : 5,
+                    ecma: terserEcma,
                     pure_getters: buildOptions.buildOptimizer,
                     // PURE comments work best with 3 passes.
                     // See https://github.com/webpack/webpack/issues/2899#issuecomment-317425926.
@@ -375,6 +377,8 @@ function getCommonConfig(wco) {
                 },
                 {
                     test: /\.js$/,
+                    // Factory files are processed by BO in the rules added in typescript.ts.
+                    exclude: /(ngfactory|ngstyle)\.js$/,
                     ...buildOptimizerUseRule,
                 },
                 {

package/src/angular-cli-files/utilities/package-chunk-sort.js

@@ -12,11 +12,13 @@ function generateEntryPoints(appConfig) {
     };
     const entryPoints = [
         'polyfills-nomodule-es5',
+        'runtime',
         'polyfills-es5',
         'polyfills',
         'sw-register',
         ...extraEntryPoints(appConfig.styles, 'styles'),
         ...extraEntryPoints(appConfig.scripts, 'scripts'),
+        'vendor',
         'main',
     ];
     const duplicates = [

package/src/angular-cli-files/utilities/stats.d.ts

@@ -1,4 +1,14 @@
 export declare function formatSize(size: number): string;
+export declare function generateBundleStats(info: {
+    id: string | number;
+    size?: number;
+    files: string[];
+    names?: string[];
+    entry: boolean;
+    initial: boolean;
+    rendered?: boolean;
+}, colors: boolean): string;
+export declare function generateBuildStats(hash: string, time: number, colors: boolean): string;
 export declare function statsToString(json: any, statsConfig: any): string;
 export declare function statsWarningsToString(json: any, statsConfig: any): string;
 export declare function statsErrorsToString(json: any, statsConfig: any): string;

package/src/angular-cli-files/utilities/stats.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // tslint:disable
 // TODO: cleanup this file, it's copied as is from Angular CLI.
 const core_1 = require("@angular-devkit/core");
+const path = require("path");
 const { bold, green, red, reset, white, yellow } = core_1.terminal;
 function formatSize(size) {
     if (size <= 0) {
@@ -20,24 +21,33 @@ function formatSize(size) {
     return `${+(size / Math.pow(1024, index)).toPrecision(3)} ${abbreviations[index]}`;
 }
 exports.formatSize = formatSize;
+function generateBundleStats(info, colors) {
+    const g = (x) => (colors ? bold(green(x)) : x);
+    const y = (x) => (colors ? bold(yellow(x)) : x);
+    const size = typeof info.size === 'number' ? ` ${formatSize(info.size)}` : '';
+    const files = info.files.map(f => path.basename(f)).join(', ');
+    const names = info.names ? ` (${info.names.join(', ')})` : '';
+    const initial = y(info.entry ? '[entry]' : info.initial ? '[initial]' : '');
+    const flags = ['rendered', 'recorded']
+        .map(f => (f && info[f] ? g(` [${f}]`) : ''))
+        .join('');
+    return `chunk {${y(info.id.toString())}} ${g(files)}${names}${size} ${initial}${flags}`;
+}
+exports.generateBundleStats = generateBundleStats;
+function generateBuildStats(hash, time, colors) {
+    const w = (x) => colors ? bold(white(x)) : x;
+    return `Date: ${w(new Date().toISOString())} - Hash: ${w(hash)} - Time: ${w('' + time)}ms`;
+}
+exports.generateBuildStats = generateBuildStats;
 function statsToString(json, statsConfig) {
     const colors = statsConfig.colors;
     const rs = (x) => colors ? reset(x) : x;
     const w = (x) => colors ? bold(white(x)) : x;
-    const g = (x) => colors ? bold(green(x)) : x;
-    const y = (x) => colors ? bold(yellow(x)) : x;
     const changedChunksStats = json.chunks
         .filter((chunk) => chunk.rendered)
         .map((chunk) => {
         const asset = json.assets.filter((x) => x.name == chunk.files[0])[0];
-        const size = asset ? ` ${formatSize(asset.size)}` : '';
-        const files = chunk.files.join(', ');
-        const names = chunk.names ? ` (${chunk.names.join(', ')})` : '';
-        const initial = y(chunk.entry ? '[entry]' : chunk.initial ? '[initial]' : '');
-        const flags = ['rendered', 'recorded']
-            .map(f => f && chunk[f] ? g(` [${f}]`) : '')
-            .join('');
-        return `chunk {${y(chunk.id)}} ${g(files)}${names}${size} ${initial}${flags}`;
+        return generateBundleStats({ ...chunk, size: asset && asset.size }, colors);
     });
     const unchangedChunkNumber = json.chunks.length - changedChunksStats.length;
     if (unchangedChunkNumber > 0) {

package/src/browser/action-executor.d.ts

@@ -0,0 +1,12 @@
+export declare class ActionExecutor<Input extends {
+    size: number;
+}, Output> {
+    private readonly actionName;
+    private largeWorker;
+    private smallWorker;
+    private smallThreshold;
+    constructor(actionFile: string, actionName: string);
+    execute(options: Input): Promise<Output>;
+    executeAll(options: Input[]): Promise<Output[]>;
+    stop(): void;
+}

package/src/browser/action-executor.js

@@ -0,0 +1,45 @@
+"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 jest_worker_1 = require("jest-worker");
+const os = require("os");
+class ActionExecutor {
+    constructor(actionFile, actionName) {
+        this.actionName = actionName;
+        this.smallThreshold = 32 * 1024;
+        // larger files are processed in a separate process to limit memory usage in the main process
+        this.largeWorker = new jest_worker_1.default(actionFile, {
+            exposedMethods: [actionName],
+        });
+        // small files are processed in a limited number of threads to improve speed
+        // The limited number also prevents a large increase in memory usage for an otherwise short operation
+        this.smallWorker = new jest_worker_1.default(actionFile, {
+            exposedMethods: [actionName],
+            numWorkers: os.cpus().length < 2 ? 1 : 2,
+            // Will automatically fallback to processes if not supported
+            enableWorkerThreads: true,
+        });
+    }
+    execute(options) {
+        if (options.size > this.smallThreshold) {
+            return this.largeWorker[this.actionName](options);
+        }
+        else {
+            return this.smallWorker[this.actionName](options);
+        }
+    }
+    executeAll(options) {
+        return Promise.all(options.map(o => this.execute(o)));
+    }
+    stop() {
+        this.largeWorker.end();
+        this.smallWorker.end();
+    }
+}
+exports.ActionExecutor = ActionExecutor;

package/src/browser/index.js

@@ -18,7 +18,6 @@ const path = require("path");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const typescript_1 = require("typescript");
-const workerFarm = require("worker-farm");
 const analytics_1 = require("../../plugins/webpack/analytics");
 const webpack_configs_1 = require("../angular-cli-files/models/webpack-configs");
 const write_index_html_1 = require("../angular-cli-files/utilities/index-file/write-index-html");
@@ -26,8 +25,10 @@ const read_tsconfig_1 = require("../angular-cli-files/utilities/read-tsconfig");
 const service_worker_1 = require("../angular-cli-files/utilities/service-worker");
 const stats_1 = require("../angular-cli-files/utilities/stats");
 const utils_1 = require("../utils");
+const mangle_options_1 = require("../utils/mangle-options");
 const version_1 = require("../utils/version");
 const webpack_browser_config_1 = require("../utils/webpack-browser-config");
+const action_executor_1 = require("./action-executor");
 const cacache = require('cacache');
 const cacheDownlevelPath = findCacheDirectory({ name: 'angular-build-dl' });
 const packageVersion = require('../../package.json').version;
@@ -104,7 +105,6 @@ function buildWebpackBrowser(options, context, transforms = {}) {
     const root = core_1.normalize(context.workspaceRoot);
     // Check Angular version.
     version_1.assertCompatibleAngularVersion(context.workspaceRoot, context.logger);
-    const loggingFn = transforms.logging || createBrowserLoggingCallback(!!options.verbose, context.logger);
     return rxjs_1.from(initialize(options, context, host, transforms.webpackConfiguration)).pipe(
     // tslint:disable-next-line: no-big-function
     operators_1.switchMap(({ workspace, config: configs }) => {
@@ -126,13 +126,20 @@ function buildWebpackBrowser(options, context, transforms = {}) {
           referenced with script[type="module"] but they may not support ES2016+ syntax.
         `);
         }
+        const useBundleDownleveling = isDifferentialLoadingNeeded && !(utils_1.fullDifferential || options.watch);
+        const startTime = Date.now();
         return rxjs_1.from(configs).pipe(
         // the concurrency parameter (3rd parameter of mergeScan) is deliberately
         // set to 1 to make sure the build steps are executed in sequence.
         operators_1.mergeScan((lastResult, config) => {
             // Make sure to only run the 2nd build step, if 1st one succeeded
             if (lastResult.success) {
-                return build_webpack_1.runWebpack(config, context, { logging: loggingFn });
+                return build_webpack_1.runWebpack(config, context, {
+                    logging: transforms.logging ||
+                        (useBundleDownleveling
+                            ? () => { }
+                            : createBrowserLoggingCallback(!!options.verbose, context.logger)),
+                });
             }
             else {
                 return rxjs_1.of();
@@ -142,7 +149,19 @@ function buildWebpackBrowser(options, context, transforms = {}) {
         operators_1.switchMap(async (buildEvents) => {
             configs.length = 0;
             const success = buildEvents.every(r => r.success);
-            if (success) {
+            if (!success && useBundleDownleveling) {
+                // If using bundle downleveling then there is only one build
+                // If it fails show any diagnostic messages and bail
+                const webpackStats = buildEvents[0].webpackStats;
+                if (webpackStats && webpackStats.warnings.length > 0) {
+                    context.logger.warn(stats_1.statsWarningsToString(webpackStats, { colors: true }));
+                }
+                if (webpackStats && webpackStats.errors.length > 0) {
+                    context.logger.error(stats_1.statsErrorsToString(webpackStats, { colors: true }));
+                }
+                return { success };
+            }
+            else if (success) {
                 let noModuleFiles;
                 let moduleFiles;
                 let files;
@@ -156,7 +175,7 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                     }
                 }
                 else if (isDifferentialLoadingNeeded && !utils_1.fullDifferential) {
-                    const { emittedFiles = [] } = firstBuild;
+                    const { emittedFiles = [], webpackStats } = firstBuild;
                     moduleFiles = [];
                     noModuleFiles = [];
                     // Common options for all bundle process actions
@@ -166,6 +185,7 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                         sourceMaps: sourceMapOptions.scripts,
                         hiddenSourceMaps: sourceMapOptions.hidden,
                         vendorSourceMaps: sourceMapOptions.vendor,
+                        integrityAlgorithm: options.subresourceIntegrity ? 'sha384' : undefined,
                     };
                     const actions = [];
                     const seen = new Set();
@@ -189,8 +209,9 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                         }
                         seen.add(file.file);
                         // All files at this point except ES5 polyfills are module scripts
-                        const es5Polyfills = file.file.startsWith('polyfills-es5');
-                        if (!es5Polyfills && !file.file.startsWith('polyfills-nomodule-es5')) {
+                        const es5Polyfills = file.file.startsWith('polyfills-es5') ||
+                            file.file.startsWith('polyfills-nomodule-es5');
+                        if (!es5Polyfills) {
                             moduleFiles.push(file);
                         }
                         // If not optimizing then ES2015 polyfills do not need processing
@@ -223,6 +244,9 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                                 filename,
                                 code,
                                 map,
+                                // id is always present for non-assets
+                                // tslint:disable-next-line: no-non-null-assertion
+                                name: file.id,
                                 optimizeOnly: true,
                             });
                             continue;
@@ -234,6 +258,9 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                             filename,
                             code,
                             map,
+                            // id is always present for non-assets
+                            // tslint:disable-next-line: no-non-null-assertion
+                            name: file.id,
                             runtime: file.file.startsWith('runtime'),
                             ignoreOriginal: es5Polyfills,
                         });
@@ -246,15 +273,21 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                     // Execute the bundle processing actions
                     context.logger.info('Generating ES5 bundles for differential loading...');
                     const processActions = [];
+                    let processRuntimeAction;
                     const cacheActions = [];
+                    const processResults = [];
                     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')
+                        const algorithm = action.integrityAlgorithm || 'sha1';
+                        const codeHash = crypto_1.createHash(algorithm)
                             .update(action.code)
-                            .digest('hex');
-                        const baseCacheKey = `${packageVersion}|${action.code.length}|${codeHash}`;
+                            .digest('base64');
+                        let baseCacheKey = `${packageVersion}|${action.code.length}|${algorithm}-${codeHash}`;
+                        if (mangle_options_1.manglingDisabled) {
+                            baseCacheKey += '|MD';
+                        }
                         // 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' : '';
@@ -280,49 +313,99 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                         }
                         // Attempt to get required cache entries
                         const cacheEntries = [];
+                        let cached = cacheKeys.length > 0;
                         for (const key of cacheKeys) {
                             if (key) {
-                                cacheEntries.push(await cacache.get.info(cacheDownlevelPath, key));
+                                const entry = await cacache.get.info(cacheDownlevelPath, key);
+                                if (!entry) {
+                                    cached = false;
+                                    break;
+                                }
+                                cacheEntries.push(entry);
                             }
                             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 */]) {
+                        // If SRI is enabled always process the runtime bundle
+                        // Lazy route integrity values are stored in the runtime bundle
+                        if (action.integrityAlgorithm && action.runtime) {
+                            processRuntimeAction = action;
+                        }
+                        else if (cached) {
+                            const result = { name: action.name };
+                            if (action.integrityAlgorithm) {
+                                result.integrity = `${action.integrityAlgorithm}-${codeHash}`;
+                            }
+                            let cacheEntry = cacheEntries[0 /* OriginalCode */];
+                            if (cacheEntry) {
                                 cacheActions.push({
-                                    src: cacheEntries[0 /* OriginalCode */].path,
+                                    src: cacheEntry.path,
                                     dest: action.filename,
                                 });
+                                result.original = {
+                                    filename: action.filename,
+                                    size: cacheEntry.size,
+                                    integrity: cacheEntry.metadata && cacheEntry.metadata.integrity,
+                                };
+                                cacheEntry = cacheEntries[1 /* OriginalMap */];
+                                if (cacheEntry) {
+                                    cacheActions.push({
+                                        src: cacheEntry.path,
+                                        dest: action.filename + '.map',
+                                    });
+                                    result.original.map = {
+                                        filename: action.filename + '.map',
+                                        size: cacheEntry.size,
+                                    };
+                                }
                             }
-                            if (cacheEntries[1 /* OriginalMap */]) {
-                                cacheActions.push({
-                                    src: cacheEntries[1 /* OriginalMap */].path,
-                                    dest: action.filename + '.map',
-                                });
+                            else if (!action.ignoreOriginal) {
+                                // If the original wasn't processed (and therefore not cached), add info
+                                result.original = {
+                                    filename: action.filename,
+                                    size: Buffer.byteLength(action.code, 'utf8'),
+                                    map: action.map === undefined
+                                        ? undefined
+                                        : {
+                                            filename: action.filename + '.map',
+                                            size: Buffer.byteLength(action.map, 'utf8'),
+                                        },
+                                };
                             }
-                            if (cacheEntries[2 /* DownlevelCode */]) {
+                            cacheEntry = cacheEntries[2 /* DownlevelCode */];
+                            if (cacheEntry) {
                                 cacheActions.push({
-                                    src: cacheEntries[2 /* DownlevelCode */].path,
+                                    src: cacheEntry.path,
                                     dest: action.filename.replace('es2015', 'es5'),
                                 });
+                                result.downlevel = {
+                                    filename: action.filename.replace('es2015', 'es5'),
+                                    size: cacheEntry.size,
+                                    integrity: cacheEntry.metadata && cacheEntry.metadata.integrity,
+                                };
+                                cacheEntry = cacheEntries[3 /* DownlevelMap */];
+                                if (cacheEntry) {
+                                    cacheActions.push({
+                                        src: cacheEntry.path,
+                                        dest: action.filename.replace('es2015', 'es5') + '.map',
+                                    });
+                                    result.downlevel.map = {
+                                        filename: action.filename.replace('es2015', 'es5') + '.map',
+                                        size: cacheEntry.size,
+                                    };
+                                }
                             }
-                            if (cacheEntries[3 /* DownlevelMap */]) {
-                                cacheActions.push({
-                                    src: cacheEntries[3 /* DownlevelMap */].path,
-                                    dest: action.filename.replace('es2015', 'es5') + '.map',
-                                });
-                            }
+                            processResults.push(result);
+                        }
+                        else if (action.runtime) {
+                            processRuntimeAction = {
+                                ...action,
+                                cacheKeys,
+                                cachePath: cacheDownlevelPath || undefined,
+                            };
                         }
                         else {
                             processActions.push({
@@ -332,7 +415,24 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                             });
                         }
                     }
+                    // Workaround Node.js issue prior to 10.16 with copyFile on macOS
+                    // https://github.com/angular/angular-cli/issues/15544 & https://github.com/nodejs/node/pull/27241
+                    let copyFileWorkaround = false;
+                    if (process.platform === 'darwin') {
+                        const version = process.versions.node.split('.').map(part => Number(part));
+                        if (version[0] < 10 ||
+                            version[0] === 11 ||
+                            (version[0] === 10 && version[1] < 16)) {
+                            copyFileWorkaround = true;
+                        }
+                    }
                     for (const action of cacheActions) {
+                        if (copyFileWorkaround) {
+                            try {
+                                fs.unlinkSync(action.dest);
+                            }
+                            catch (_b) { }
+                        }
                         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.
@@ -341,28 +441,74 @@ function buildWebpackBrowser(options, context, transforms = {}) {
                         }
                     }
                     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));
-                        });
+                        const workerFile = require.resolve('../utils/process-bundle');
+                        const executor = new action_executor_1.ActionExecutor(path.extname(workerFile) !== '.ts'
+                            ? workerFile
+                            : require.resolve('../utils/process-bundle-bootstrap'), 'process');
+                        try {
+                            const results = await executor.executeAll(processActions.map(a => ({ ...a, size: a.code.length })));
+                            results.forEach(result => processResults.push(result));
+                        }
+                        finally {
+                            executor.stop();
+                        }
+                    }
+                    // Runtime must be processed after all other files
+                    if (processRuntimeAction) {
+                        const runtimeOptions = {
+                            ...processRuntimeAction,
+                            runtimeData: processResults,
+                        };
+                        processResults.push(await Promise.resolve().then(() => require('../utils/process-bundle')).then(m => m.process(runtimeOptions)));
                     }
                     context.logger.info('ES5 bundle generation complete.');
+                    function generateBundleInfoStats(id, bundle, chunk) {
+                        return stats_1.generateBundleStats({
+                            id,
+                            size: bundle.size,
+                            files: bundle.map ? [bundle.filename, bundle.map.filename] : [bundle.filename],
+                            names: chunk && chunk.names,
+                            entry: !!chunk && chunk.names.includes('runtime'),
+                            initial: !!chunk && chunk.initial,
+                            rendered: true,
+                        }, true);
+                    }
+                    let bundleInfoText = '';
+                    const processedNames = new Set();
+                    for (const result of processResults) {
+                        processedNames.add(result.name);
+                        const chunk = webpackStats &&
+                            webpackStats.chunks &&
+                            webpackStats.chunks.find(c => result.name === c.id.toString());
+                        if (result.original) {
+                            bundleInfoText +=
+                                '\n' + generateBundleInfoStats(result.name, result.original, chunk);
+                        }
+                        if (result.downlevel) {
+                            bundleInfoText +=
+                                '\n' + generateBundleInfoStats(result.name, result.downlevel, chunk);
+                        }
+                    }
+                    if (webpackStats && webpackStats.chunks) {
+                        for (const chunk of webpackStats.chunks) {
+                            if (processedNames.has(chunk.id.toString())) {
+                                continue;
+                            }
+                            const asset = webpackStats.assets && webpackStats.assets.find(a => a.name === chunk.files[0]);
+                            bundleInfoText +=
+                                '\n' + stats_1.generateBundleStats({ ...chunk, size: asset && asset.size }, true);
+                        }
+                    }
+                    bundleInfoText +=
+                        '\n' +
+                            stats_1.generateBuildStats((webpackStats && webpackStats.hash) || '<unknown>', Date.now() - startTime, true);
+                    context.logger.info(bundleInfoText);
+                    if (webpackStats && webpackStats.warnings.length > 0) {
+                        context.logger.warn(stats_1.statsWarningsToString(webpackStats, { colors: true }));
+                    }
+                    if (webpackStats && webpackStats.errors.length > 0) {
+                        context.logger.error(stats_1.statsErrorsToString(webpackStats, { colors: true }));
+                    }
                 }
                 else {
                     const { emittedFiles = [] } = firstBuild;

package/src/protractor/index.js

@@ -71,7 +71,7 @@ async function execute(options, context) {
     if (options.webdriverUpdate) {
         await updateWebdriver();
     }
-    let baseUrl;
+    let baseUrl = options.baseUrl;
     let server;
     if (options.devServerTarget) {
         const target = architect_1.targetFromTargetString(options.devServerTarget);

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

@@ -2,15 +2,33 @@ export interface ProcessBundleOptions {
     filename: string;
     code: string;
     map?: string;
+    name: string;
     sourceMaps?: boolean;
     hiddenSourceMaps?: boolean;
     vendorSourceMaps?: boolean;
     runtime?: boolean;
-    optimize: boolean;
+    optimize?: boolean;
     optimizeOnly?: boolean;
     ignoreOriginal?: boolean;
     cacheKeys?: (string | null)[];
     cachePath?: string;
+    integrityAlgorithm?: 'sha256' | 'sha384' | 'sha512';
+    runtimeData?: ProcessBundleResult[];
+}
+export interface ProcessBundleResult {
+    name: string;
+    integrity?: string;
+    original?: ProcessBundleFile;
+    downlevel?: ProcessBundleFile;
+}
+export interface ProcessBundleFile {
+    filename: string;
+    size: number;
+    integrity?: string;
+    map?: {
+        filename: string;
+        size: number;
+    };
 }
 export declare const enum CacheKey {
     OriginalCode = 0,
@@ -18,4 +36,4 @@ export declare const enum CacheKey {
     DownlevelCode = 2,
     DownlevelMap = 3
 }
-export declare function process(options: ProcessBundleOptions, callback: (error: Error | null, result?: {}) => void): void;
+export declare function process(options: ProcessBundleOptions): Promise<ProcessBundleResult>;

package/src/utils/process-bundle.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * 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 crypto_1 = require("crypto");
 const fs = require("fs");
 const path = require("path");
 const source_map_1 = require("source-map");
@@ -14,34 +15,47 @@ 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) {
+async function process(options) {
     if (!options.cacheKeys) {
         options.cacheKeys = [];
     }
     // If no downlevelling required than just mangle code and return
     if (options.optimizeOnly) {
-        return mangleOriginal(options);
+        const result = { name: options.name };
+        if (options.integrityAlgorithm) {
+            result.integrity = generateIntegrityValue(options.integrityAlgorithm, options.code);
+        }
+        // Replace integrity hashes with updated values
+        // NOTE: This should eventually be a babel plugin
+        if (options.runtime && options.integrityAlgorithm && options.runtimeData) {
+            for (const data of options.runtimeData) {
+                if (!data.integrity || !data.original || !data.original.integrity) {
+                    continue;
+                }
+                options.code = options.code.replace(data.integrity, data.original.integrity);
+            }
+        }
+        result.original = await mangleOriginal(options);
+        return result;
     }
     // if code size is larger than 500kB, manually handle sourcemaps with newer source-map package.
     // babel currently uses an older version that still supports sync calls
     const codeSize = Buffer.byteLength(options.code, 'utf8');
-    const manualSourceMaps = codeSize >= 500 * 1024;
+    const mapSize = options.map ? Buffer.byteLength(options.map, 'utf8') : 0;
+    const manualSourceMaps = codeSize >= 500 * 1024 || mapSize >= 500 * 1024;
     // downlevel the bundle
     let { code, map } = await transformAsync(options.code, {
         filename: options.filename,
         inputSourceMap: !manualSourceMaps && options.map !== undefined && JSON.parse(options.map),
         babelrc: false,
-        // modules aren't needed since the bundles use webpacks custom module loading
-        // loose generates more ES5-like code but does not strictly adhere to the ES2015 spec (Typescript is loose)
+        // modules aren't needed since the bundles use webpack's custom module loading
         // 'transform-typeof-symbol' generates slower code
         presets: [
-            ['@babel/preset-env', { modules: false, loose: true, exclude: ['transform-typeof-symbol'] }],
+            ['@babel/preset-env', { modules: false, exclude: ['transform-typeof-symbol'] }],
         ],
-        minified: true,
+        minified: options.optimize,
+        // `false` ensures it is disabled and prevents large file warnings
+        compact: options.optimize || false,
         sourceMaps: options.sourceMaps,
     });
     const newFilePath = options.filename.replace('es2015', 'es5');
@@ -49,6 +63,16 @@ async function processWorker(options) {
     // Extra spacing is intentional to align source line positions
     if (options.runtime) {
         code = code.replace('"-es2015.', '   "-es5.');
+        // Replace integrity hashes with updated values
+        // NOTE: This should eventually be a babel plugin
+        if (options.integrityAlgorithm && options.runtimeData) {
+            for (const data of options.runtimeData) {
+                if (!data.integrity || !data.downlevel || !data.downlevel.integrity) {
+                    continue;
+                }
+                code = code.replace(data.integrity, data.downlevel.integrity);
+            }
+        }
     }
     if (options.sourceMaps && manualSourceMaps && options.map) {
         const generator = new source_map_1.SourceMapGenerator();
@@ -88,11 +112,12 @@ async function processWorker(options) {
         map.file = path.basename(newFilePath);
         map.sourceRoot = sourceRoot;
     }
+    const result = { name: options.name };
     if (options.optimize) {
         // Note: Investigate converting the AST instead of re-parsing
         // estree -> terser is already supported; need babel -> estree/terser
         // Mangle downlevel code
-        const result = terser_1.minify(code, {
+        const minifyOutput = terser_1.minify(code, {
             compress: true,
             ecma: 5,
             mangle: !mangle_options_1.manglingDisabled,
@@ -106,14 +131,14 @@ async function processWorker(options) {
                 content: map,
             },
         });
-        if (result.error) {
-            throw result.error;
+        if (minifyOutput.error) {
+            throw minifyOutput.error;
         }
-        code = result.code;
-        map = result.map;
+        code = minifyOutput.code;
+        map = minifyOutput.map;
         // Mangle original code
         if (!options.ignoreOriginal) {
-            await mangleOriginal(options);
+            result.original = await mangleOriginal(options);
         }
     }
     else if (map) {
@@ -128,11 +153,23 @@ async function processWorker(options) {
         }
         fs.writeFileSync(newFilePath + '.map', map);
     }
+    result.downlevel = createFileEntry(newFilePath, code, map, options.integrityAlgorithm);
     if (options.cachePath && options.cacheKeys[2 /* DownlevelCode */]) {
-        await cacache.put(options.cachePath, options.cacheKeys[2 /* DownlevelCode */], code);
+        await cacache.put(options.cachePath, options.cacheKeys[2 /* DownlevelCode */], code, {
+            metadata: { integrity: result.downlevel.integrity },
+        });
     }
     fs.writeFileSync(newFilePath, code);
+    // If original was not processed, add info
+    if (!result.original && !options.ignoreOriginal) {
+        result.original = createFileEntry(options.filename, options.code, options.map, options.integrityAlgorithm);
+    }
+    if (options.integrityAlgorithm) {
+        result.integrity = generateIntegrityValue(options.integrityAlgorithm, options.code);
+    }
+    return result;
 }
+exports.process = process;
 async function mangleOriginal(options) {
     const resultOriginal = terser_1.minify(options.code, {
         compress: false,
@@ -161,8 +198,34 @@ async function mangleOriginal(options) {
         }
         fs.writeFileSync(options.filename + '.map', resultOriginal.map);
     }
+    const fileResult = createFileEntry(options.filename, 
+    // tslint:disable-next-line: no-non-null-assertion
+    resultOriginal.code, resultOriginal.map, options.integrityAlgorithm);
     if (options.cachePath && options.cacheKeys && options.cacheKeys[0 /* OriginalCode */]) {
-        await cacache.put(options.cachePath, options.cacheKeys[0 /* OriginalCode */], resultOriginal.code);
+        await cacache.put(options.cachePath, options.cacheKeys[0 /* OriginalCode */], resultOriginal.code, {
+            metadata: { integrity: fileResult.integrity },
+        });
     }
     fs.writeFileSync(options.filename, resultOriginal.code);
+    return fileResult;
+}
+function createFileEntry(filename, code, map, integrityAlgorithm) {
+    return {
+        filename: filename,
+        size: Buffer.byteLength(code),
+        integrity: integrityAlgorithm && generateIntegrityValue(integrityAlgorithm, code),
+        map: !map
+            ? undefined
+            : {
+                filename: filename + '.map',
+                size: Buffer.byteLength(map),
+            },
+    };
+}
+function generateIntegrityValue(hashAlgorithm, code) {
+    return (hashAlgorithm +
+        '-' +
+        crypto_1.createHash(hashAlgorithm)
+            .update(code)
+            .digest('base64'));
 }