@angular-devkit/build-angular 0.1101.0-next.3 → 0.1101.1

package/src/karma/schema.d.ts

@@ -65,7 +65,8 @@ export interface Schema {
      */
     scripts?: ExtraEntryPoint[];
     /**
-     * Output source maps.
+     * Output source maps for scripts and styles. For more information, see
+     * https://angular.io/guide/workspace-config#source-map-configuration.
      */
     sourceMap?: SourceMapUnion;
     /**
@@ -130,7 +131,8 @@ export interface ExtraEntryPointClass {
     input: string;
 }
 /**
- * Output source maps.
+ * Output source maps for scripts and styles. For more information, see
+ * https://angular.io/guide/workspace-config#source-map-configuration.
  */
 export declare type SourceMapUnion = boolean | SourceMapClass;
 export interface SourceMapClass {

package/src/karma/schema.json

@@ -67,7 +67,7 @@
       "description": "Globs of files to include, relative to workspace or project root. \nThere are 2 special cases:\n - when a path to directory is provided, all spec files ending \".spec.@(ts|tsx)\" will be included\n - when a path to a file is provided, and a matching spec file exists it will be included instead"
     },
     "sourceMap": {
-      "description": "Output source maps.",
+      "description": "Output source maps for scripts and styles. For more information, see https://angular.io/guide/workspace-config#source-map-configuration.",
       "default": true,
       "oneOf": [
         {

package/src/server/index.js

@@ -44,7 +44,7 @@ function execute(options, context, transforms = {}) {
             context.logger.warn(core_1.tags.stripIndent `
       Warning: Turning off 'bundleDependencies' with Ivy may result in undefined behaviour
       unless 'node_modules' are transformed using the standalone Angular compatibility compiler (NGCC).
-      See: http://v9.angular.io/guide/ivy#ivy-and-universal-app-shell
+      See: https://angular.io/guide/ivy#ivy-and-universal-app-shell
     `);
         }
     }

package/src/server/schema.d.ts

@@ -70,7 +70,7 @@ export interface Schema {
     /**
      * Enables optimization of the build output. Including minification of scripts and styles,
      * tree-shaking and dead-code elimination. For more information, see
-     * https://angular.io/guide/workspace-config#optimization-and-source-map-configuration.
+     * https://angular.io/guide/workspace-config#optimization-configuration.
      */
     optimization?: OptimizationUnion;
     /**
@@ -103,7 +103,8 @@ export interface Schema {
      */
     showCircularDependencies?: boolean;
     /**
-     * Output source maps.
+     * Output source maps for scripts and styles. For more information, see
+     * https://angular.io/guide/workspace-config#source-map-configuration.
      */
     sourceMap?: SourceMapUnion;
     /**
@@ -158,7 +159,7 @@ export declare type Localize = string[] | boolean;
 /**
  * Enables optimization of the build output. Including minification of scripts and styles,
  * tree-shaking and dead-code elimination. For more information, see
- * https://angular.io/guide/workspace-config#optimization-and-source-map-configuration.
+ * https://angular.io/guide/workspace-config#optimization-configuration.
  */
 export declare type OptimizationUnion = boolean | OptimizationClass;
 export interface OptimizationClass {
@@ -181,7 +182,8 @@ export declare enum OutputHashing {
     None = "none"
 }
 /**
- * Output source maps.
+ * Output source maps for scripts and styles. For more information, see
+ * https://angular.io/guide/workspace-config#source-map-configuration.
  */
 export declare type SourceMapUnion = boolean | SourceMapClass;
 export interface SourceMapClass {

package/src/server/schema.json

@@ -29,7 +29,7 @@
       "additionalProperties": false
     },
     "optimization": {
-      "description": "Enables optimization of the build output. Including minification of scripts and styles, tree-shaking and dead-code elimination. For more information, see https://angular.io/guide/workspace-config#optimization-and-source-map-configuration.",
+      "description": "Enables optimization of the build output. Including minification of scripts and styles, tree-shaking and dead-code elimination. For more information, see https://angular.io/guide/workspace-config#optimization-configuration.",
       "x-user-analytics": 16,
       "default": false,
       "oneOf": [
@@ -72,7 +72,7 @@
       "default": ""
     },
     "sourceMap": {
-      "description": "Output source maps.",
+      "description": "Output source maps for scripts and styles. For more information, see https://angular.io/guide/workspace-config#source-map-configuration.",
       "default": true,
       "oneOf": [
         {

package/src/testing/builder-harness.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="node" />
+/**
+ * @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 { BuilderHandlerFn, BuilderInfo, BuilderOutput } from '@angular-devkit/architect';
+import { TestProjectHost } from '@angular-devkit/architect/testing';
+import { json, logging } from '@angular-devkit/core';
+import { Observable } from 'rxjs';
+export interface BuilderHarnessExecutionResult<T extends BuilderOutput = BuilderOutput> {
+    result?: T;
+    error?: Error;
+    logs: readonly logging.LogEntry[];
+}
+export interface BuilderHarnessExecutionOptions {
+    configuration: string;
+    outputLogsOnFailure: boolean;
+    outputLogsOnException: boolean;
+    useNativeFileWatching: boolean;
+}
+export declare class BuilderHarness<T> {
+    private readonly builderHandler;
+    private readonly host;
+    private readonly builderInfo;
+    private schemaRegistry;
+    private projectName;
+    private projectMetadata;
+    private targetName?;
+    private options;
+    private builderTargets;
+    private watcherNotifier?;
+    constructor(builderHandler: BuilderHandlerFn<T & json.JsonObject>, host: TestProjectHost, builderInfo?: Partial<BuilderInfo>);
+    useProject(name: string, metadata?: Record<string, unknown>): this;
+    useTarget(name: string, baseOptions: T): this;
+    withConfiguration(configuration: string, options: T): this;
+    withBuilderTarget<O>(target: string, handler: BuilderHandlerFn<O & json.JsonObject>, options?: O, info?: Partial<BuilderInfo>): this;
+    execute(options?: Partial<BuilderHarnessExecutionOptions>): Observable<BuilderHarnessExecutionResult>;
+    executeOnce(options?: Partial<BuilderHarnessExecutionOptions>): Promise<BuilderHarnessExecutionResult>;
+    appendToFile(path: string, content: string): Promise<void>;
+    writeFile(path: string, content: string | Buffer): Promise<void>;
+    writeFiles(files: Record<string, string | Buffer>): Promise<void>;
+    removeFile(path: string): Promise<void>;
+    modifyFile(path: string, modifier: (content: string) => string | Promise<string>): Promise<void>;
+    hasFile(path: string): boolean;
+    readFile(path: string): string;
+    private validateProjectName;
+}

package/src/testing/builder-harness.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuilderHarness = void 0;
+/**
+ * @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 architect_1 = require("@angular-devkit/architect");
+const core_1 = require("@angular-devkit/core");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const file_watching_1 = require("./file-watching");
+class BuilderHarness {
+    constructor(builderHandler, host, builderInfo) {
+        this.builderHandler = builderHandler;
+        this.host = host;
+        this.schemaRegistry = new core_1.json.schema.CoreSchemaRegistry();
+        this.projectName = 'test';
+        this.projectMetadata = { root: '.', sourceRoot: 'src' };
+        this.options = new Map();
+        this.builderTargets = new Map();
+        // Generate default pseudo builder info for test purposes
+        this.builderInfo = {
+            builderName: builderHandler.name,
+            description: '',
+            optionSchema: true,
+            ...builderInfo,
+        };
+        this.schemaRegistry.addPostTransform(core_1.json.schema.transforms.addUndefinedDefaults);
+    }
+    useProject(name, metadata = {}) {
+        if (!name) {
+            throw new Error('Project name cannot be an empty string.');
+        }
+        this.projectName = name;
+        this.projectMetadata = metadata;
+        return this;
+    }
+    useTarget(name, baseOptions) {
+        if (!name) {
+            throw new Error('Target name cannot be an empty string.');
+        }
+        this.targetName = name;
+        this.options.set(null, baseOptions);
+        return this;
+    }
+    withConfiguration(configuration, options) {
+        this.options.set(configuration, options);
+        return this;
+    }
+    withBuilderTarget(target, handler, options, info) {
+        this.builderTargets.set(target, {
+            handler,
+            options: options || {},
+            info: { builderName: handler.name, description: '', optionSchema: true, ...info },
+        });
+        return this;
+    }
+    execute(options = {}) {
+        var _a;
+        const { configuration, outputLogsOnException = true, outputLogsOnFailure = true, useNativeFileWatching = false, } = options;
+        const targetOptions = {
+            ...this.options.get(null),
+            ...((_a = (configuration && this.options.get(configuration))) !== null && _a !== void 0 ? _a : {}),
+        };
+        if (!useNativeFileWatching) {
+            if (this.watcherNotifier) {
+                throw new Error('Only one harness execution at a time is supported.');
+            }
+            this.watcherNotifier = new file_watching_1.WatcherNotifier();
+        }
+        const contextHost = {
+            findBuilderByTarget: async (project, target) => {
+                this.validateProjectName(project);
+                if (target === this.targetName) {
+                    return {
+                        info: this.builderInfo,
+                        handler: this.builderHandler,
+                    };
+                }
+                const builderTarget = this.builderTargets.get(target);
+                if (builderTarget) {
+                    return { info: builderTarget.info, handler: builderTarget.handler };
+                }
+                throw new Error('Project target does not exist.');
+            },
+            async getBuilderName(project, target) {
+                return (await this.findBuilderByTarget(project, target)).info.builderName;
+            },
+            getMetadata: async (project) => {
+                this.validateProjectName(project);
+                return this.projectMetadata;
+            },
+            getOptions: async (project, target, configuration) => {
+                var _a, _b;
+                this.validateProjectName(project);
+                if (target === this.targetName) {
+                    return (_a = this.options.get(configuration !== null && configuration !== void 0 ? configuration : null)) !== null && _a !== void 0 ? _a : {};
+                }
+                else if (configuration !== undefined) {
+                    // Harness builder targets currently do not support configurations
+                    return {};
+                }
+                else {
+                    return ((_b = this.builderTargets.get(target)) === null || _b === void 0 ? void 0 : _b.options) || {};
+                }
+            },
+            hasTarget: async (project, target) => {
+                this.validateProjectName(project);
+                return this.targetName === target || this.builderTargets.has(target);
+            },
+            validate: async (options, builderName) => {
+                let schema;
+                if (builderName === this.builderInfo.builderName) {
+                    schema = this.builderInfo.optionSchema;
+                }
+                else {
+                    for (const [, value] of this.builderTargets) {
+                        if (value.info.builderName === builderName) {
+                            schema = value.info.optionSchema;
+                            break;
+                        }
+                    }
+                }
+                const validator = await this.schemaRegistry.compile(schema !== null && schema !== void 0 ? schema : true).toPromise();
+                const { data } = await validator(options).toPromise();
+                return data;
+            },
+        };
+        const context = new HarnessBuilderContext(this.builderInfo, core_1.getSystemPath(this.host.root()), contextHost, useNativeFileWatching ? undefined : this.watcherNotifier);
+        if (this.targetName !== undefined) {
+            context.target = {
+                project: this.projectName,
+                target: this.targetName,
+                configuration: configuration,
+            };
+        }
+        const logs = [];
+        context.logger.subscribe((e) => logs.push(e));
+        return this.schemaRegistry.compile(this.builderInfo.optionSchema).pipe(operators_1.mergeMap((validator) => validator(targetOptions)), operators_1.map((validationResult) => validationResult.data), operators_1.mergeMap((data) => convertBuilderOutputToObservable(this.builderHandler(data, context))), operators_1.map((buildResult) => ({ result: buildResult, error: undefined })), operators_1.catchError((error) => {
+            if (outputLogsOnException) {
+                // tslint:disable-next-line: no-console
+                console.error(logs.map((entry) => entry.message).join('\n'));
+                // tslint:disable-next-line: no-console
+                console.error(error);
+            }
+            return rxjs_1.of({ result: undefined, error });
+        }), operators_1.map(({ result, error }) => {
+            if (outputLogsOnFailure && (result === null || result === void 0 ? void 0 : result.success) === false && logs.length > 0) {
+                // tslint:disable-next-line: no-console
+                console.error(logs.map((entry) => entry.message).join('\n'));
+            }
+            // Capture current logs and clear for next
+            const currentLogs = logs.slice();
+            logs.length = 0;
+            return { result, error, logs: currentLogs };
+        }), operators_1.finalize(() => {
+            this.watcherNotifier = undefined;
+            for (const teardown of context.teardowns) {
+                teardown();
+            }
+        }));
+    }
+    async executeOnce(options) {
+        // Return the first result
+        return this.execute(options).pipe(operators_1.first()).toPromise();
+    }
+    async appendToFile(path, content) {
+        await this.writeFile(path, this.readFile(path).concat(content));
+    }
+    async writeFile(path, content) {
+        var _a;
+        this.host
+            .scopedSync()
+            .write(core_1.normalize(path), typeof content === 'string' ? Buffer.from(content) : content);
+        (_a = this.watcherNotifier) === null || _a === void 0 ? void 0 : _a.notify([
+            { path: core_1.getSystemPath(core_1.join(this.host.root(), path)), type: 'modified' },
+        ]);
+    }
+    async writeFiles(files) {
+        var _a;
+        const watchEvents = this.watcherNotifier
+            ? []
+            : undefined;
+        for (const [path, content] of Object.entries(files)) {
+            this.host
+                .scopedSync()
+                .write(core_1.normalize(path), typeof content === 'string' ? Buffer.from(content) : content);
+            watchEvents === null || watchEvents === void 0 ? void 0 : watchEvents.push({ path: core_1.getSystemPath(core_1.join(this.host.root(), path)), type: 'modified' });
+        }
+        if (watchEvents) {
+            (_a = this.watcherNotifier) === null || _a === void 0 ? void 0 : _a.notify(watchEvents);
+        }
+    }
+    async removeFile(path) {
+        var _a;
+        this.host.scopedSync().delete(core_1.normalize(path));
+        (_a = this.watcherNotifier) === null || _a === void 0 ? void 0 : _a.notify([
+            { path: core_1.getSystemPath(core_1.join(this.host.root(), path)), type: 'deleted' },
+        ]);
+    }
+    async modifyFile(path, modifier) {
+        var _a;
+        const content = this.readFile(path);
+        await this.writeFile(path, await modifier(content));
+        (_a = this.watcherNotifier) === null || _a === void 0 ? void 0 : _a.notify([
+            { path: core_1.getSystemPath(core_1.join(this.host.root(), path)), type: 'modified' },
+        ]);
+    }
+    hasFile(path) {
+        return this.host.scopedSync().exists(core_1.normalize(path));
+    }
+    readFile(path) {
+        const content = this.host.scopedSync().read(core_1.normalize(path));
+        return Buffer.from(content).toString('utf8');
+    }
+    validateProjectName(name) {
+        if (name !== this.projectName) {
+            throw new Error(`Project "${name}" does not exist.`);
+        }
+    }
+}
+exports.BuilderHarness = BuilderHarness;
+class HarnessBuilderContext {
+    constructor(builder, basePath, contextHost, watcherFactory) {
+        this.builder = builder;
+        this.contextHost = contextHost;
+        this.watcherFactory = watcherFactory;
+        this.id = Math.trunc(Math.random() * 1000000);
+        this.logger = new core_1.logging.Logger(`builder-harness-${this.id}`);
+        this.teardowns = [];
+        this.workspaceRoot = this.currentDirectory = basePath;
+    }
+    get analytics() {
+        // Can be undefined even though interface does not allow it
+        return undefined;
+    }
+    addTeardown(teardown) {
+        this.teardowns.push(teardown);
+    }
+    async getBuilderNameForTarget(target) {
+        return this.contextHost.getBuilderName(target.project, target.target);
+    }
+    async getProjectMetadata(targetOrName) {
+        const project = typeof targetOrName === 'string' ? targetOrName : targetOrName.project;
+        return this.contextHost.getMetadata(project);
+    }
+    async getTargetOptions(target) {
+        return this.contextHost.getOptions(target.project, target.target, target.configuration);
+    }
+    // Unused by builders in this package
+    async scheduleBuilder(builderName, options, scheduleOptions) {
+        throw new Error('Not Implemented.');
+    }
+    async scheduleTarget(target, overrides, scheduleOptions) {
+        const { info, handler } = await this.contextHost.findBuilderByTarget(target.project, target.target);
+        const targetOptions = await this.validateOptions({
+            ...(await this.getTargetOptions(target)),
+            ...overrides,
+        }, info.builderName);
+        const context = new HarnessBuilderContext(info, this.workspaceRoot, this.contextHost, this.watcherFactory);
+        context.target = target;
+        context.logger = (scheduleOptions === null || scheduleOptions === void 0 ? void 0 : scheduleOptions.logger) || this.logger.createChild('');
+        const progressSubject = new rxjs_1.Subject();
+        const output = convertBuilderOutputToObservable(handler(targetOptions, context));
+        const run = {
+            id: context.id,
+            info,
+            progress: progressSubject.asObservable(),
+            async stop() {
+                for (const teardown of context.teardowns) {
+                    await teardown();
+                }
+                progressSubject.complete();
+            },
+            output: output.pipe(operators_1.shareReplay()),
+            get result() {
+                return this.output.pipe(operators_1.first()).toPromise();
+            },
+        };
+        return run;
+    }
+    async validateOptions(options, builderName) {
+        return this.contextHost.validate(options, builderName);
+    }
+    // Unused report methods
+    reportRunning() { }
+    reportStatus() { }
+    reportProgress() { }
+}
+function isAsyncIterable(obj) {
+    return !!obj && typeof obj[Symbol.asyncIterator] === 'function';
+}
+function convertBuilderOutputToObservable(output) {
+    if (architect_1.isBuilderOutput(output)) {
+        return rxjs_1.of(output);
+    }
+    else if (isAsyncIterable(output)) {
+        return architect_1.fromAsyncIterable(output);
+    }
+    else {
+        return rxjs_1.from(output);
+    }
+}

package/src/testing/file-watching.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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 { BuilderWatcherCallback, BuilderWatcherFactory } from '../webpack/plugins/builder-watch-plugin';
+export declare class WatcherNotifier implements BuilderWatcherFactory {
+    private readonly descriptors;
+    notify(events: Iterable<{
+        path: string;
+        type: 'modified' | 'deleted';
+    }>): void;
+    watch(files: Iterable<string>, directories: Iterable<string>, callback: BuilderWatcherCallback): {
+        close(): void;
+    };
+}
+export { BuilderWatcherFactory };

package/src/testing/file-watching.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatcherNotifier = void 0;
+class WatcherDescriptor {
+    constructor(files, directories, callback) {
+        this.files = files;
+        this.directories = directories;
+        this.callback = callback;
+    }
+    shouldNotify(path) {
+        return true;
+    }
+}
+class WatcherNotifier {
+    constructor() {
+        this.descriptors = new Set();
+    }
+    notify(events) {
+        for (const descriptor of this.descriptors) {
+            for (const { path } of events) {
+                if (descriptor.shouldNotify(path)) {
+                    descriptor.callback([...events]);
+                    break;
+                }
+            }
+        }
+    }
+    watch(files, directories, callback) {
+        const descriptor = new WatcherDescriptor(new Set(files), new Set(directories), callback);
+        this.descriptors.add(descriptor);
+        return { close: () => this.descriptors.delete(descriptor) };
+    }
+}
+exports.WatcherNotifier = WatcherNotifier;

package/src/testing/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @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
+ */
+export { BuilderHarnessExecutionOptions, BuilderHarnessExecutionResult } from './builder-harness';
+export { HarnessFileMatchers, describeBuilder } from './jasmine-helpers';

package/src/testing/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeBuilder = void 0;
+var jasmine_helpers_1 = require("./jasmine-helpers");
+Object.defineProperty(exports, "describeBuilder", { enumerable: true, get: function () { return jasmine_helpers_1.describeBuilder; } });

package/src/testing/jasmine-helpers.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="jasmine" />
+/**
+ * @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 { BuilderHandlerFn } from '@angular-devkit/architect';
+import { json } from '@angular-devkit/core';
+import { BuilderHarness } from './builder-harness';
+export declare function describeBuilder<T>(builderHandler: BuilderHandlerFn<T & json.JsonObject>, options: {
+    name?: string;
+    schemaPath: string;
+}, specDefinitions: (harness: JasmineBuilderHarness<T>) => void): void;
+declare class JasmineBuilderHarness<T> extends BuilderHarness<T> {
+    expectFile(path: string): HarnessFileMatchers;
+}
+export interface HarnessFileMatchers {
+    toExist(): boolean;
+    toNotExist(): boolean;
+    readonly content: jasmine.ArrayLikeMatchers<string>;
+    readonly size: jasmine.Matchers<number>;
+}
+export declare function expectFile<T>(path: string, harness: BuilderHarness<T>): HarnessFileMatchers;
+export {};

package/src/testing/jasmine-helpers.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectFile = exports.describeBuilder = void 0;
+const fs_1 = require("fs");
+const test_utils_1 = require("../test-utils");
+const builder_harness_1 = require("./builder-harness");
+const optionSchemaCache = new Map();
+function describeBuilder(builderHandler, options, specDefinitions) {
+    let optionSchema = optionSchemaCache.get(options.schemaPath);
+    if (optionSchema === undefined) {
+        optionSchema = JSON.parse(fs_1.readFileSync(options.schemaPath, 'utf8'));
+        optionSchemaCache.set(options.schemaPath, optionSchema);
+    }
+    const harness = new JasmineBuilderHarness(builderHandler, test_utils_1.host, {
+        builderName: options.name,
+        optionSchema,
+    });
+    describe(options.name || builderHandler.name, () => {
+        beforeEach(() => test_utils_1.host.initialize().toPromise());
+        afterEach(() => test_utils_1.host.restore().toPromise());
+        specDefinitions(harness);
+    });
+}
+exports.describeBuilder = describeBuilder;
+class JasmineBuilderHarness extends builder_harness_1.BuilderHarness {
+    expectFile(path) {
+        return expectFile(path, this);
+    }
+}
+/**
+ * Add a Jasmine expectation filter to an expectation that always fails with a message.
+ * @param base The base expectation (`expect(...)`) to use.
+ * @param message The message to provide in the expectation failure.
+ */
+function createFailureExpectation(base, message) {
+    // Needed typings are not included in the Jasmine types
+    const expectation = base;
+    expectation.expector = expectation.expector.addFilter({
+        selectComparisonFunc() {
+            return () => ({
+                pass: false,
+                message,
+            });
+        },
+    });
+    return expectation;
+}
+function expectFile(path, harness) {
+    return {
+        toExist() {
+            const exists = harness.hasFile(path);
+            expect(exists).toBe(true, 'Expected file to exist: ' + path);
+            return exists;
+        },
+        toNotExist() {
+            const exists = harness.hasFile(path);
+            expect(exists).toBe(false, 'Expected file to not exist: ' + path);
+            return !exists;
+        },
+        get content() {
+            try {
+                return expect(harness.readFile(path)).withContext(`With file content for '${path}'`);
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT') {
+                    throw e;
+                }
+                // File does not exist so always fail the expectation
+                return createFailureExpectation(expect(''), `Expected file content but file does not exist: '${path}'`);
+            }
+        },
+        get size() {
+            try {
+                return expect(Buffer.byteLength(harness.readFile(path))).withContext(`With file size for '${path}'`);
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT') {
+                    throw e;
+                }
+                // File does not exist so always fail the expectation
+                return createFailureExpectation(expect(0), `Expected file size but file does not exist: '${path}'`);
+            }
+        },
+    };
+}
+exports.expectFile = expectFile;

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

@@ -68,7 +68,7 @@ export interface BuildOptions {
     fileReplacements: NormalizedFileReplacement[];
     experimentalRollupPass?: boolean;
     allowedCommonJsDependencies?: string[];
-    differentialLoadingMode?: boolean;
+    differentialLoadingNeeded?: boolean;
 }
 export interface WebpackTestOptions extends BuildOptions {
     codeCoverage?: boolean;
@@ -84,5 +84,5 @@ export interface WebpackConfigOptions<T = BuildOptions> {
     buildOptions: T;
     tsConfig: ParsedConfiguration;
     tsConfigPath: string;
-    supportES2015: boolean;
+    scriptTarget: import('typescript').ScriptTarget;
 }

package/src/utils/load-translations.js

@@ -51,6 +51,9 @@ async function importParsers() {
         const localizeDiag = await Promise.resolve().then(() => require('@angular/localize/src/tools/src/diagnostics'));
         const diagnostics = new localizeDiag.Diagnostics();
         const parsers = {
+            arb: new (await Promise.resolve().then(() => require(
+            // tslint:disable-next-line:trailing-comma
+            '@angular/localize/src/tools/src/translate/translation_files/translation_parsers/arb_translation_parser'))).ArbTranslationParser(),
             json: new (await Promise.resolve().then(() => require(
             // tslint:disable-next-line:trailing-comma
             '@angular/localize/src/tools/src/translate/translation_files/translation_parsers/simple_json_translation_parser'))).SimpleJsonTranslationParser(),