@ngtools/webpack 9.0.0-rc.7 → 9.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngtools/webpack",
-  "version": "9.0.0-rc.7",
+  "version": "9.0.1",
   "description": "Webpack plugin that AoT compiles your Angular components and modules.",
   "main": "./src/index.js",
   "typings": "src/index.d.ts",
@@ -25,20 +25,19 @@
   },
   "homepage": "https://github.com/angular/angular-cli",
   "dependencies": {
-    "@angular-devkit/core": "9.0.0-rc.7",
+    "@angular-devkit/core": "9.0.1",
     "enhanced-resolve": "4.1.1",
     "rxjs": "6.5.3",
     "webpack-sources": "1.4.3"
   },
   "peerDependencies": {
     "@angular/compiler-cli": ">=9.0.0-beta < 10",
-    "typescript": ">=3.6 < 3.7",
+    "typescript": ">=3.6 < 3.8",
     "webpack": "^4.0.0"
   },
   "engines": {
     "node": ">= 10.13.0",
     "npm": ">= 6.11.0",
-    "pnpm": ">= 3.2.0",
     "yarn": ">= 1.13.0"
   },
   "husky": {

package/src/angular_compiler_plugin.d.ts

@@ -38,13 +38,13 @@ export declare class AngularCompilerPlugin {
     private _logger;
     private _mainFields;
     constructor(options: AngularCompilerPluginOptions);
-    readonly options: AngularCompilerPluginOptions;
-    readonly done: Promise<void> | null;
-    readonly entryModule: {
+    get options(): AngularCompilerPluginOptions;
+    get done(): Promise<void> | null;
+    get entryModule(): {
         path: string;
         className: string;
     } | null;
-    readonly typeChecker: ts.TypeChecker | null;
+    get typeChecker(): ts.TypeChecker | null;
     /** @deprecated  From 8.0.2 */
     static isSupported(): boolean;
     private _setupOptions;
@@ -75,7 +75,7 @@ export declare class AngularCompilerPlugin {
         errorDependencies: string[];
     };
     getDependencies(fileName: string, includeResources?: boolean): string[];
-    getResourceDependencies(fileName: string): string[];
+    getResourceDependencies(fileName: string): never[] | Set<string>;
     getTypeDependencies(fileName: string): string[];
     private _emit;
     private _validateLocale;

package/src/angular_compiler_plugin.js

@@ -26,6 +26,7 @@ const resource_loader_1 = require("./resource_loader");
 const transformers_1 = require("./transformers");
 const ast_helpers_1 = require("./transformers/ast_helpers");
 const ctor_parameters_1 = require("./transformers/ctor-parameters");
+const remove_ivy_jit_support_calls_1 = require("./transformers/remove-ivy-jit-support-calls");
 const type_checker_1 = require("./type_checker");
 const type_checker_messages_1 = require("./type_checker_messages");
 const utils_1 = require("./utils");
@@ -757,6 +758,14 @@ class AngularCompilerPlugin {
                 // In Ivy they are removed in ngc directly.
                 this._transformers.push(transformers_1.removeDecorators(isAppPath, getTypeChecker));
             }
+            else {
+                // Default for both options is to emit (undefined means true)
+                const removeClassMetadata = this._options.emitClassMetadata === false;
+                const removeNgModuleScope = this._options.emitNgModuleScope === false;
+                if (removeClassMetadata || removeNgModuleScope) {
+                    this._transformers.push(remove_ivy_jit_support_calls_1.removeIvyJitSupportCalls(removeClassMetadata, removeNgModuleScope, getTypeChecker));
+                }
+            }
             // Import ngfactory in loadChildren import syntax
             if (this._useFactories) {
                 // Only transform imports to use factories with View Engine.
@@ -931,12 +940,16 @@ class AngularCompilerPlugin {
             }
         })
             .filter(x => x);
-        let resourceImports = [], resourceDependencies = [];
+        let resourceImports = [];
+        const resourceDependencies = [];
         if (includeResources) {
             resourceImports = transformers_1.findResources(sourceFile)
                 .map(resourcePath => core_1.resolve(core_1.dirname(resolvedFileName), core_1.normalize(resourcePath)));
-            resourceDependencies =
-                this.getResourceDependencies(this._compilerHost.denormalizePath(resolvedFileName));
+            for (const resource of resourceImports) {
+                for (const dep of this.getResourceDependencies(this._compilerHost.denormalizePath(resource))) {
+                    resourceDependencies.push(dep);
+                }
+            }
         }
         // These paths are meant to be used by the loader so we must denormalize them.
         const uniqueDependencies = new Set([

package/src/compiler_host.d.ts

@@ -31,7 +31,7 @@ export declare class WebpackCompilerHost implements ts.CompilerHost {
     private _virtualFileExtensions;
     private _virtualStyleFileExtensions;
     constructor(_options: ts.CompilerOptions, basePath: string, host: virtualFs.Host, cacheSourceFiles: boolean, directTemplateLoading?: boolean, ngccProcessor?: NgccProcessor | undefined, moduleResolutionCache?: ts.ModuleResolutionCache | undefined);
-    private readonly virtualFiles;
+    private get virtualFiles();
     reset(): void;
     denormalizePath(path: string): string;
     resolve(path: string): Path;
@@ -48,7 +48,7 @@ export declare class WebpackCompilerHost implements ts.CompilerHost {
     getDirectories(path: string): string[];
     getSourceFile(fileName: string, languageVersion: ts.ScriptTarget, onError?: OnErrorFn): ts.SourceFile | undefined;
     getDefaultLibFileName(options: ts.CompilerOptions): string;
-    readonly writeFile: (fileName: string, data: string, _writeByteOrderMark: boolean, onError?: ((message: string) => void) | undefined, _sourceFiles?: readonly ts.SourceFile[] | undefined) => void;
+    get writeFile(): (fileName: string, data: string, _writeByteOrderMark: boolean, onError?: ((message: string) => void) | undefined, _sourceFiles?: readonly ts.SourceFile[] | undefined) => void;
     getCurrentDirectory(): string;
     getCanonicalFileName(fileName: string): string;
     useCaseSensitiveFileNames(): boolean;

package/src/diagnostics.js

@@ -118,11 +118,11 @@ function reportDiagnostics(diagnostics, compilerHost, reportError, reportWarning
         }
     }
     if (tsErrors.length > 0) {
-        const message = ts.formatDiagnosticsWithColorAndContext(tsErrors, compilerHost);
+        const message = compiler_cli_1.formatDiagnostics(tsErrors);
         reportError(message);
     }
     if (tsWarnings.length > 0) {
-        const message = ts.formatDiagnosticsWithColorAndContext(tsWarnings, compilerHost);
+        const message = compiler_cli_1.formatDiagnostics(tsWarnings);
         reportWarning(message);
     }
     if (ngErrors.length > 0) {

package/src/interfaces.d.ts

@@ -43,6 +43,8 @@ export interface AngularCompilerPluginOptions {
     nameLazyFiles?: boolean;
     logger?: logging.Logger;
     directTemplateLoading?: boolean;
+    emitClassMetadata?: boolean;
+    emitNgModuleScope?: boolean;
     /**
      * When using the loadChildren string syntax, @ngtools/webpack must query @angular/compiler-cli
      * via a private API to know which lazy routes exist. This increases build and rebuild time.

package/src/loader.js

@@ -83,8 +83,9 @@ function ngcLoader() {
         const ngStyleRe = /(?:\.shim)?\.ngstyle\.js$/;
         if (ngStyleRe.test(sourceFileName)) {
             const styleFile = sourceFileName.replace(ngStyleRe, '');
-            const styleDependencies = plugin.getResourceDependencies(styleFile);
-            styleDependencies.forEach(dep => this.addDependency(dep));
+            for (const dep of plugin.getResourceDependencies(styleFile)) {
+                this.addDependency(dep);
+            }
         }
         // Add type-only dependencies that should trigger a rebuild when they change.
         const typeDependencies = plugin.getTypeDependencies(sourceFileName);

package/src/refactor.d.ts

@@ -13,8 +13,8 @@ export declare function resolve(filePath: string, _host: ts.CompilerHost, compil
 export declare class TypeScriptFileRefactor {
     private _fileName;
     private _sourceFile;
-    readonly fileName: string;
-    readonly sourceFile: ts.SourceFile;
+    get fileName(): string;
+    get sourceFile(): ts.SourceFile;
     constructor(fileName: string, _host: ts.CompilerHost, _program?: ts.Program, source?: string | null);
     /**
      * Find all nodes from the AST in the subtree of node of SyntaxKind kind.

package/src/resource_loader.d.ts

@@ -7,8 +7,8 @@ export declare class WebpackResourceLoader {
     private _cachedEvaluatedSources;
     constructor();
     update(parentCompilation: any): void;
-    getResourceDependencies(filePath: string): string[];
-    getAffectedResources(file: string): string[];
+    getResourceDependencies(filePath: string): never[] | Set<string>;
+    getAffectedResources(file: string): never[] | Set<string>;
     private _compile;
     private _evaluate;
     get(filePath: string): Promise<string>;

package/src/resource_loader.js

@@ -13,6 +13,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path = require("path");
 const vm = require("vm");
 const webpack_sources_1 = require("webpack-sources");
+const utils_1 = require("./utils");
 const NodeTemplatePlugin = require('webpack/lib/node/NodeTemplatePlugin');
 const NodeTargetPlugin = require('webpack/lib/node/NodeTargetPlugin');
 const LoaderTargetPlugin = require('webpack/lib/LoaderTargetPlugin');
@@ -103,14 +104,15 @@ class WebpackResourceLoader {
             }
         });
         // Save the dependencies for this resource.
-        this._fileDependencies.set(filePath, childCompilation.fileDependencies);
+        this._fileDependencies.set(filePath, new Set(childCompilation.fileDependencies));
         for (const file of childCompilation.fileDependencies) {
-            const entry = this._reverseDependencies.get(file);
+            const resolvedFile = utils_1.forwardSlashPath(file);
+            const entry = this._reverseDependencies.get(resolvedFile);
             if (entry) {
-                entry.push(filePath);
+                entry.add(filePath);
             }
             else {
-                this._reverseDependencies.set(file, [filePath]);
+                this._reverseDependencies.set(resolvedFile, new Set([filePath]));
             }
         }
         const compilationHash = childCompilation.fullHash;

package/src/transformers/ast_helpers.d.ts

@@ -1,10 +1,11 @@
+/**
+ * @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 * as ts from 'typescript';
-import { WebpackCompilerHost } from '../compiler_host';
 export declare function collectDeepNodes<T extends ts.Node>(node: ts.Node, kind: ts.SyntaxKind | ts.SyntaxKind[]): T[];
 export declare function getFirstNode(sourceFile: ts.SourceFile): ts.Node;
 export declare function getLastNode(sourceFile: ts.SourceFile): ts.Node | null;
-export declare function createTypescriptContext(content: string, additionalFiles?: Record<string, string>, useLibs?: boolean, importHelpers?: boolean): {
-    compilerHost: WebpackCompilerHost;
-    program: ts.Program;
-};
-export declare function transformTypescript(content: string | undefined, transformers: ts.TransformerFactory<ts.SourceFile>[], program?: ts.Program, compilerHost?: WebpackCompilerHost): string | undefined;

package/src/transformers/ast_helpers.js

@@ -7,11 +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 core_1 = require("@angular-devkit/core");
-const fs_1 = require("fs");
-const path_1 = require("path");
 const ts = require("typescript");
-const compiler_host_1 = require("../compiler_host");
 // Find all nodes from the AST in the subtree of node of SyntaxKind kind.
 function collectDeepNodes(node, kind) {
     const kinds = Array.isArray(kind) ? kind : [kind];
@@ -40,76 +36,3 @@ function getLastNode(sourceFile) {
     return null;
 }
 exports.getLastNode = getLastNode;
-// Test transform helpers.
-const basePath = '/project/src/';
-const fileName = basePath + 'test-file.ts';
-const tsLibFiles = loadTsLibFiles();
-function createTypescriptContext(content, additionalFiles, useLibs = false, importHelpers = true) {
-    // Set compiler options.
-    const compilerOptions = {
-        noEmitOnError: useLibs,
-        allowJs: true,
-        newLine: ts.NewLineKind.LineFeed,
-        moduleResolution: ts.ModuleResolutionKind.NodeJs,
-        module: ts.ModuleKind.ESNext,
-        target: ts.ScriptTarget.ESNext,
-        skipLibCheck: true,
-        sourceMap: false,
-        importHelpers,
-    };
-    // Create compiler host.
-    const compilerHost = new compiler_host_1.WebpackCompilerHost(compilerOptions, basePath, new core_1.virtualFs.SimpleMemoryHost(), false);
-    // Add a dummy file to host content.
-    compilerHost.writeFile(fileName, content, false);
-    if (useLibs) {
-        // Write the default libs.
-        // These are needed for tests that use import(), because it relies on a Promise being there.
-        const compilerLibFolder = path_1.dirname(compilerHost.getDefaultLibFileName(compilerOptions));
-        for (const [k, v] of Object.entries(tsLibFiles)) {
-            compilerHost.writeFile(path_1.join(compilerLibFolder, k), v, false);
-        }
-    }
-    if (additionalFiles) {
-        for (const key in additionalFiles) {
-            compilerHost.writeFile(basePath + key, additionalFiles[key], false);
-        }
-    }
-    // Create the TypeScript program.
-    const program = ts.createProgram([fileName], compilerOptions, compilerHost);
-    return { compilerHost, program };
-}
-exports.createTypescriptContext = createTypescriptContext;
-function transformTypescript(content, transformers, program, compilerHost) {
-    // Use given context or create a new one.
-    if (content !== undefined) {
-        const typescriptContext = createTypescriptContext(content);
-        if (!program) {
-            program = typescriptContext.program;
-        }
-        if (!compilerHost) {
-            compilerHost = typescriptContext.compilerHost;
-        }
-    }
-    else if (!program || !compilerHost) {
-        throw new Error('transformTypescript needs either `content` or a `program` and `compilerHost');
-    }
-    // Emit.
-    const { emitSkipped, diagnostics } = program.emit(undefined, undefined, undefined, undefined, { before: transformers });
-    // Throw error with diagnostics if emit wasn't successfull.
-    if (emitSkipped) {
-        throw new Error(ts.formatDiagnostics(diagnostics, compilerHost));
-    }
-    // Return the transpiled js.
-    return compilerHost.readFile(fileName.replace(/\.tsx?$/, '.js'));
-}
-exports.transformTypescript = transformTypescript;
-function loadTsLibFiles() {
-    const libFolderPath = path_1.dirname(require.resolve('typescript/lib/lib.d.ts'));
-    const libFolderFiles = fs_1.readdirSync(libFolderPath);
-    const libFileNames = libFolderFiles.filter(f => f.startsWith('lib.') && f.endsWith('.d.ts'));
-    // Return a map of the lib names to their content.
-    return libFileNames.reduce((map, f) => {
-        map[f] = fs_1.readFileSync(path_1.join(libFolderPath, f), 'utf-8');
-        return map;
-    }, {});
-}

package/src/transformers/elide_imports.d.ts

@@ -7,4 +7,4 @@
  */
 import * as ts from 'typescript';
 import { TransformOperation } from './interfaces';
-export declare function elideImports(sourceFile: ts.SourceFile, removedNodes: ts.Node[], getTypeChecker: () => ts.TypeChecker): TransformOperation[];
+export declare function elideImports(sourceFile: ts.SourceFile, removedNodes: ts.Node[], getTypeChecker: () => ts.TypeChecker, compilerOptions: ts.CompilerOptions): TransformOperation[];

package/src/transformers/elide_imports.js

@@ -15,7 +15,7 @@ const interfaces_1 = require("./interfaces");
 // Doesn't use the `symbol.declarations` because that previous transforms might have removed nodes
 // but the type checker doesn't know.
 // See https://github.com/Microsoft/TypeScript/issues/17552 for more information.
-function elideImports(sourceFile, removedNodes, getTypeChecker) {
+function elideImports(sourceFile, removedNodes, getTypeChecker, compilerOptions) {
     const ops = [];
     if (removedNodes.length === 0) {
         return [];
@@ -25,8 +25,9 @@ function elideImports(sourceFile, removedNodes, getTypeChecker) {
     const usedSymbols = new Set();
     const imports = [];
     ts.forEachChild(sourceFile, function visit(node) {
-        // Skip type references and removed nodes. We consider both unused.
-        if (node.kind == ts.SyntaxKind.TypeReference || removedNodes.includes(node)) {
+        var _a, _b, _c, _d;
+        // Skip removed nodes.
+        if (removedNodes.includes(node)) {
             return;
         }
         // Record import and skip
@@ -35,16 +36,48 @@ function elideImports(sourceFile, removedNodes, getTypeChecker) {
             return;
         }
         let symbol;
-        switch (node.kind) {
-            case ts.SyntaxKind.Identifier:
+        if (ts.isTypeReferenceNode(node)) {
+            if (!compilerOptions.emitDecoratorMetadata) {
+                // Skip and mark as unused if emitDecoratorMetadata is disabled.
+                return;
+            }
+            const parent = node.parent;
+            let isTypeReferenceForDecoratoredNode = false;
+            switch (parent.kind) {
+                case ts.SyntaxKind.GetAccessor:
+                case ts.SyntaxKind.PropertyDeclaration:
+                case ts.SyntaxKind.MethodDeclaration:
+                    isTypeReferenceForDecoratoredNode = !!((_a = parent.decorators) === null || _a === void 0 ? void 0 : _a.length);
+                    break;
+                case ts.SyntaxKind.Parameter:
+                    // - A constructor parameter can be decorated or the class itself is decorated.
+                    // - The parent of the parameter is decorated example a method declaration or a set accessor.
+                    // In all cases we need the type reference not to be elided.
+                    isTypeReferenceForDecoratoredNode = !!(((_b = parent.decorators) === null || _b === void 0 ? void 0 : _b.length) ||
+                        (ts.isSetAccessor(parent.parent) && !!((_c = parent.parent.decorators) === null || _c === void 0 ? void 0 : _c.length)) ||
+                        (ts.isConstructorDeclaration(parent.parent) && !!((_d = parent.parent.parent.decorators) === null || _d === void 0 ? void 0 : _d.length)));
+                    break;
+            }
+            if (isTypeReferenceForDecoratoredNode) {
                 symbol = typeChecker.getSymbolAtLocation(node);
-                break;
-            case ts.SyntaxKind.ExportSpecifier:
-                symbol = typeChecker.getExportSpecifierLocalTargetSymbol(node);
-                break;
-            case ts.SyntaxKind.ShorthandPropertyAssignment:
-                symbol = typeChecker.getShorthandAssignmentValueSymbol(node);
-                break;
+            }
+            else {
+                // If type reference is not for Decorator skip and marked as unused.
+                return;
+            }
+        }
+        else {
+            switch (node.kind) {
+                case ts.SyntaxKind.Identifier:
+                    symbol = typeChecker.getSymbolAtLocation(node);
+                    break;
+                case ts.SyntaxKind.ExportSpecifier:
+                    symbol = typeChecker.getExportSpecifierLocalTargetSymbol(node);
+                    break;
+                case ts.SyntaxKind.ShorthandPropertyAssignment:
+                    symbol = typeChecker.getShorthandAssignmentValueSymbol(node);
+                    break;
+            }
         }
         if (symbol) {
             usedSymbols.add(symbol);

package/src/transformers/make_transform.js

@@ -24,7 +24,7 @@ function makeTransform(standardTransform, getTypeChecker) {
             // replace_resources), but may not be true for new transforms.
             if (getTypeChecker && removeOps.length + replaceOps.length > 0) {
                 const removedNodes = removeOps.concat(replaceOps).map(op => op.target);
-                removeOps.push(...elide_imports_1.elideImports(sf, removedNodes, getTypeChecker));
+                removeOps.push(...elide_imports_1.elideImports(sf, removedNodes, getTypeChecker, context.getCompilerOptions()));
             }
             const visitor = node => {
                 let modified = false;

package/src/transformers/remove-ivy-jit-support-calls.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
+ */
+import * as ts from 'typescript';
+export declare function removeIvyJitSupportCalls(classMetadata: boolean, ngModuleScope: boolean, getTypeChecker: () => ts.TypeChecker): ts.TransformerFactory<ts.SourceFile>;

package/src/transformers/remove-ivy-jit-support-calls.js

@@ -0,0 +1,73 @@
+"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 ts = require("typescript");
+const ast_helpers_1 = require("./ast_helpers");
+const interfaces_1 = require("./interfaces");
+const make_transform_1 = require("./make_transform");
+function removeIvyJitSupportCalls(classMetadata, ngModuleScope, getTypeChecker) {
+    const standardTransform = function (sourceFile) {
+        const ops = [];
+        ast_helpers_1.collectDeepNodes(sourceFile, ts.SyntaxKind.ExpressionStatement)
+            .filter(statement => {
+            const innerStatement = getIifeStatement(statement);
+            if (!innerStatement) {
+                return false;
+            }
+            if (ngModuleScope && ts.isBinaryExpression(innerStatement.expression)) {
+                return isIvyPrivateCallExpression(innerStatement.expression.right, 'ɵɵsetNgModuleScope');
+            }
+            return (classMetadata &&
+                isIvyPrivateCallExpression(innerStatement.expression, 'ɵsetClassMetadata'));
+        })
+            .forEach(statement => ops.push(new interfaces_1.RemoveNodeOperation(sourceFile, statement)));
+        return ops;
+    };
+    return make_transform_1.makeTransform(standardTransform, getTypeChecker);
+}
+exports.removeIvyJitSupportCalls = removeIvyJitSupportCalls;
+// Each Ivy private call expression is inside an IIFE
+function getIifeStatement(exprStmt) {
+    const expression = exprStmt.expression;
+    if (!expression || !ts.isCallExpression(expression) || expression.arguments.length !== 0) {
+        return null;
+    }
+    const parenExpr = expression;
+    if (!ts.isParenthesizedExpression(parenExpr.expression)) {
+        return null;
+    }
+    const funExpr = parenExpr.expression.expression;
+    if (!ts.isFunctionExpression(funExpr)) {
+        return null;
+    }
+    const innerStmts = funExpr.body.statements;
+    if (innerStmts.length !== 1) {
+        return null;
+    }
+    const innerExprStmt = innerStmts[0];
+    if (!ts.isExpressionStatement(innerExprStmt)) {
+        return null;
+    }
+    return innerExprStmt;
+}
+function isIvyPrivateCallExpression(expression, name) {
+    // Now we're in the IIFE and have the inner expression statement. We can check if it matches
+    // a private Ivy call.
+    if (!ts.isCallExpression(expression)) {
+        return false;
+    }
+    const propAccExpr = expression.expression;
+    if (!ts.isPropertyAccessExpression(propAccExpr)) {
+        return false;
+    }
+    if (propAccExpr.name.text != name) {
+        return false;
+    }
+    return true;
+}

package/src/transformers/spec_helpers.d.ts

@@ -0,0 +1,7 @@
+import * as ts from 'typescript';
+import { WebpackCompilerHost } from '../compiler_host';
+export declare function createTypescriptContext(content: string, additionalFiles?: Record<string, string>, useLibs?: boolean, extraCompilerOptions?: ts.CompilerOptions): {
+    compilerHost: WebpackCompilerHost;
+    program: ts.Program;
+};
+export declare function transformTypescript(content: string | undefined, transformers: ts.TransformerFactory<ts.SourceFile>[], program?: ts.Program, compilerHost?: WebpackCompilerHost): string | undefined;

package/src/transformers/spec_helpers.js

@@ -0,0 +1,106 @@
+"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 core_1 = require("@angular-devkit/core");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const ts = require("typescript");
+const compiler_host_1 = require("../compiler_host");
+// Test transform helpers.
+const basePath = '/project/src/';
+const fileName = basePath + 'test-file.ts';
+const typeScriptLibFiles = loadTypeScriptLibFiles();
+const tsLibFiles = loadTsLibFiles();
+function createTypescriptContext(content, additionalFiles, useLibs = false, extraCompilerOptions = {}) {
+    // Set compiler options.
+    const compilerOptions = {
+        noEmitOnError: useLibs,
+        allowJs: true,
+        newLine: ts.NewLineKind.LineFeed,
+        moduleResolution: ts.ModuleResolutionKind.NodeJs,
+        module: ts.ModuleKind.ESNext,
+        target: ts.ScriptTarget.ESNext,
+        skipLibCheck: true,
+        sourceMap: false,
+        importHelpers: true,
+        experimentalDecorators: true,
+        ...extraCompilerOptions,
+    };
+    // Create compiler host.
+    const compilerHost = new compiler_host_1.WebpackCompilerHost(compilerOptions, basePath, new core_1.virtualFs.SimpleMemoryHost(), false);
+    // Add a dummy file to host content.
+    compilerHost.writeFile(fileName, content, false);
+    if (useLibs) {
+        // Write the default libs.
+        // These are needed for tests that use import(), because it relies on a Promise being there.
+        const compilerLibFolder = path_1.dirname(compilerHost.getDefaultLibFileName(compilerOptions));
+        for (const [k, v] of Object.entries(typeScriptLibFiles)) {
+            compilerHost.writeFile(path_1.join(compilerLibFolder, k), v, false);
+        }
+    }
+    if (compilerOptions.importHelpers) {
+        for (const [k, v] of Object.entries(tsLibFiles)) {
+            compilerHost.writeFile(k, v, false);
+        }
+    }
+    if (additionalFiles) {
+        for (const key in additionalFiles) {
+            compilerHost.writeFile(basePath + key, additionalFiles[key], false);
+        }
+    }
+    // Create the TypeScript program.
+    const program = ts.createProgram([fileName], compilerOptions, compilerHost);
+    return { compilerHost, program };
+}
+exports.createTypescriptContext = createTypescriptContext;
+function transformTypescript(content, transformers, program, compilerHost) {
+    // Use given context or create a new one.
+    if (content !== undefined) {
+        const typescriptContext = createTypescriptContext(content);
+        if (!program) {
+            program = typescriptContext.program;
+        }
+        if (!compilerHost) {
+            compilerHost = typescriptContext.compilerHost;
+        }
+    }
+    else if (!program || !compilerHost) {
+        throw new Error('transformTypescript needs either `content` or a `program` and `compilerHost');
+    }
+    // Emit.
+    const { emitSkipped, diagnostics } = program.emit(undefined, undefined, undefined, undefined, { before: transformers });
+    // Throw error with diagnostics if emit wasn't successfull.
+    if (emitSkipped) {
+        throw new Error(ts.formatDiagnostics(diagnostics, compilerHost));
+    }
+    // Return the transpiled js.
+    return compilerHost.readFile(fileName.replace(/\.tsx?$/, '.js'));
+}
+exports.transformTypescript = transformTypescript;
+function loadTypeScriptLibFiles() {
+    const libFolderPath = path_1.dirname(require.resolve('typescript/lib/lib.d.ts'));
+    const libFolderFiles = fs_1.readdirSync(libFolderPath);
+    const libFileNames = libFolderFiles.filter(f => f.startsWith('lib.') && f.endsWith('.d.ts'));
+    // Return a map of the lib names to their content.
+    const libs = {};
+    for (const f of libFileNames) {
+        libs[f] = fs_1.readFileSync(path_1.join(libFolderPath, f), 'utf-8');
+    }
+    return libs;
+}
+function loadTsLibFiles() {
+    const libFolderPath = path_1.dirname(require.resolve('tslib/package.json'));
+    const libFolderFiles = fs_1.readdirSync(libFolderPath);
+    // Return a map of the lib names to their content.
+    const libs = {};
+    for (const f of libFolderFiles) {
+        libs[path_1.join('node_modules/tslib', f)] = fs_1.readFileSync(path_1.join(libFolderPath, f), 'utf-8');
+    }
+    return libs;
+}

package/src/webpack-input-host.d.ts

@@ -13,7 +13,7 @@ import { InputFileSystem } from 'webpack';
 export declare class WebpackInputHost implements virtualFs.Host<Stats> {
     readonly inputFileSystem: InputFileSystem;
     constructor(inputFileSystem: InputFileSystem);
-    readonly capabilities: virtualFs.HostCapabilities;
+    get capabilities(): virtualFs.HostCapabilities;
     write(_path: Path, _content: virtualFs.FileBufferLike): Observable<never>;
     delete(_path: Path): Observable<never>;
     rename(_from: Path, _to: Path): Observable<never>;