@ngtools/webpack 8.2.0-next.1 → 8.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngtools/webpack",
-  "version": "8.2.0-next.1",
+  "version": "8.2.2",
   "description": "Webpack plugin that AoT compiles your Angular components and modules.",
   "main": "./src/index.js",
   "typings": "src/index.d.ts",
@@ -25,7 +25,7 @@
   },
   "homepage": "https://github.com/angular/angular-cli",
   "dependencies": {
-    "@angular-devkit/core": "8.2.0-next.1",
+    "@angular-devkit/core": "8.2.2",
     "enhanced-resolve": "4.1.0",
     "rxjs": "6.4.0",
     "tree-kill": "1.2.1",
@@ -33,7 +33,7 @@
   },
   "peerDependencies": {
     "@angular/compiler-cli": "^8.0.0-beta.0 || ^8.1.0-beta.0 || ^8.2.0-beta.0 || ^8.3.0-beta.0 || ^8.4.0-beta.0 || >=9.0.0-beta < 9",
-    "typescript": ">=3.4 < 3.5",
+    "typescript": ">=3.4 < 3.6",
     "webpack": "^4.0.0"
   },
   "engines": {

package/src/angular_compiler_plugin.d.ts

@@ -22,6 +22,7 @@ export declare class AngularCompilerPlugin {
     private _JitMode;
     private _emitSkipped;
     private _hadFullJitEmit;
+    private _unusedFiles;
     private _changedFileExtensions;
     private _firstRun;
     private _donePromise;
@@ -55,6 +56,7 @@ export declare class AngularCompilerPlugin {
     private _createForkedTypeChecker;
     private _killForkedTypeChecker;
     private _updateForkedTypeChecker;
+    private _warnOnUnusedFiles;
     apply(compiler: Compiler & {
         watchMode?: boolean;
         parentCompilation?: compilation.Compilation;

package/src/angular_compiler_plugin.js

@@ -42,6 +42,7 @@ class AngularCompilerPlugin {
         this._platformTransformers = null;
         this._JitMode = false;
         this._emitSkipped = true;
+        this._unusedFiles = new Set();
         this._changedFileExtensions = new Set(['ts', 'tsx', 'html', 'css', 'js', 'json']);
         // Webpack plugin.
         this._firstRun = true;
@@ -236,8 +237,6 @@ class AngularCompilerPlugin {
         if (this._forkTypeChecker && this._typeCheckerProcess && !this._firstRun) {
             this._updateForkedTypeChecker(this._rootNames, this._getChangedCompilationFiles());
         }
-        // Use an identity function as all our paths are absolute already.
-        this._moduleResolutionCache = ts.createModuleResolutionCache(this._basePath, x => x);
         const oldTsProgram = this._getTsProgram();
         if (this._JitMode) {
             // Create the TypeScript program.
@@ -429,6 +428,47 @@ class AngularCompilerPlugin {
             this._typeCheckerProcess.send(new type_checker_messages_1.UpdateMessage(rootNames, changedCompilationFiles));
         }
     }
+    _warnOnUnusedFiles(compilation) {
+        // Only do the unused TS files checks when under Ivy
+        // since previously we did include unused files in the compilation
+        // See: https://github.com/angular/angular-cli/pull/15030
+        if (!this._compilerOptions.enableIvy) {
+            return;
+        }
+        const program = this._getTsProgram();
+        if (!program) {
+            return;
+        }
+        // Exclude the following files from unused checks
+        // - ngfactories & ngstyle might not have a correspondent
+        //   JS file example `@angular/core/core.ngfactory.ts`.
+        // - .d.ts files might not have a correspondent JS file due to bundling.
+        // - __ng_typecheck__.ts will never be requested.
+        const fileExcludeRegExp = /(\.(d|ngfactory|ngstyle)\.ts|ng_typecheck__\.ts)$/;
+        const usedFiles = new Set();
+        for (const compilationModule of compilation.modules) {
+            if (!compilationModule.resource) {
+                continue;
+            }
+            usedFiles.add(utils_1.forwardSlashPath(compilationModule.resource));
+            // We need the below for dependencies which
+            // are not emitted such as type only TS files
+            for (const dependency of compilationModule.buildInfo.fileDependencies) {
+                usedFiles.add(utils_1.forwardSlashPath(dependency));
+            }
+        }
+        const sourceFiles = program.getSourceFiles();
+        for (const { fileName } of sourceFiles) {
+            if (fileExcludeRegExp.test(fileName)
+                || usedFiles.has(fileName)
+                || this._unusedFiles.has(fileName)) {
+                continue;
+            }
+            compilation.warnings.push(`${fileName} is part of the TypeScript compilation but it's unused.\n` +
+                `Add only entry points to the 'files' or 'include' properties in your tsconfig.`);
+            this._unusedFiles.add(fileName);
+        }
+    }
     // Registration hook for webpack plugin.
     // tslint:disable-next-line:no-big-function
     apply(compiler) {
@@ -444,6 +484,7 @@ class AngularCompilerPlugin {
         // cleanup if not watching
         compiler.hooks.thisCompilation.tap('angular-compiler', compilation => {
             compilation.hooks.finishModules.tap('angular-compiler', () => {
+                this._warnOnUnusedFiles(compilation);
                 let rootCompiler = compiler;
                 while (rootCompiler.parentCompilation) {
                     // tslint:disable-next-line:no-any
@@ -491,8 +532,10 @@ class AngularCompilerPlugin {
             if (this._compilerOptions.enableIvy) {
                 ngccProcessor = new ngcc_processor_1.NgccProcessor(this._mainFields, compilerWithFileSystems.inputFileSystem, this._warnings, this._errors, this._basePath, this._compilerOptions);
             }
+            // Use an identity function as all our paths are absolute already.
+            this._moduleResolutionCache = ts.createModuleResolutionCache(this._basePath, x => x);
             // Create the webpack compiler host.
-            const webpackCompilerHost = new compiler_host_1.WebpackCompilerHost(this._compilerOptions, this._basePath, host, true, this._options.directTemplateLoading, ngccProcessor);
+            const webpackCompilerHost = new compiler_host_1.WebpackCompilerHost(this._compilerOptions, this._basePath, host, true, this._options.directTemplateLoading, ngccProcessor, this._moduleResolutionCache);
             // Create and set a new WebpackResourceLoader in AOT
             if (!this._JitMode) {
                 this._resourceLoader = new resource_loader_1.WebpackResourceLoader();
@@ -908,8 +951,7 @@ class AngularCompilerPlugin {
             ...resourceImports,
             ...this.getResourceDependencies(this._compilerHost.denormalizePath(resolvedFileName)),
         ].map((p) => p && this._compilerHost.denormalizePath(p)));
-        return [...uniqueDependencies]
-            .filter(x => !!x);
+        return [...uniqueDependencies];
     }
     getResourceDependencies(fileName) {
         if (!this._resourceLoader) {

package/src/compiler_host.d.ts

@@ -19,6 +19,7 @@ export declare class WebpackCompilerHost implements ts.CompilerHost {
     private readonly cacheSourceFiles;
     private readonly directTemplateLoading;
     private readonly ngccProcessor?;
+    private readonly moduleResolutionCache?;
     private _syncHost;
     private _memoryHost;
     private _changedFiles;
@@ -27,7 +28,8 @@ export declare class WebpackCompilerHost implements ts.CompilerHost {
     private _resourceLoader?;
     private _sourceFileCache;
     private _virtualFileExtensions;
-    constructor(_options: ts.CompilerOptions, basePath: string, host: virtualFs.Host, cacheSourceFiles: boolean, directTemplateLoading?: boolean, ngccProcessor?: NgccProcessor | undefined);
+    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;
     denormalizePath(path: string): string;
     resolve(path: string): Path;

package/src/compiler_host.js

@@ -13,11 +13,12 @@ const ts = require("typescript");
 const utils_1 = require("./utils");
 const dev = Math.floor(Math.random() * 10000);
 class WebpackCompilerHost {
-    constructor(_options, basePath, host, cacheSourceFiles, directTemplateLoading = false, ngccProcessor) {
+    constructor(_options, basePath, host, cacheSourceFiles, directTemplateLoading = false, ngccProcessor, moduleResolutionCache) {
         this._options = _options;
         this.cacheSourceFiles = cacheSourceFiles;
         this.directTemplateLoading = directTemplateLoading;
         this.ngccProcessor = ngccProcessor;
+        this.moduleResolutionCache = moduleResolutionCache;
         this._changedFiles = new Set();
         this._readResourceFiles = new Set();
         this._sourceFileCache = new Map();
@@ -26,10 +27,12 @@ class WebpackCompilerHost {
             '.js.map',
             '.ngfactory.js',
             '.ngfactory.js.map',
-            '.ngstyle.js',
-            '.ngstyle.js.map',
             '.ngsummary.json',
         ];
+        this._virtualStyleFileExtensions = [
+            '.shim.ngstyle.js',
+            '.shim.ngstyle.js.map',
+        ];
         this._syncHost = new core_1.virtualFs.SyncDelegateHost(host);
         this._memoryHost = new core_1.virtualFs.SyncDelegateHost(new core_1.virtualFs.SimpleMemoryHost());
         this._basePath = core_1.normalize(basePath);
@@ -84,6 +87,9 @@ class WebpackCompilerHost {
                 }
             });
         }
+        if (fullPath.endsWith('.ts')) {
+            return;
+        }
         // In case resolveJsonModule and allowJs we also need to remove virtual emitted files
         // both if they exists or not.
         if ((fullPath.endsWith('.js') || fullPath.endsWith('.json')) &&
@@ -91,6 +97,13 @@ class WebpackCompilerHost {
             if (this._memoryHost.exists(fullPath)) {
                 this._memoryHost.delete(fullPath);
             }
+            return;
+        }
+        for (const ext of this._virtualStyleFileExtensions) {
+            const virtualFile = (fullPath + ext);
+            if (this._memoryHost.exists(virtualFile)) {
+                this._memoryHost.delete(virtualFile);
+            }
         }
     }
     fileExists(fileName, delegate = true) {
@@ -313,7 +326,7 @@ class WebpackCompilerHost {
     }
     resolveModuleNames(moduleNames, containingFile) {
         return moduleNames.map(moduleName => {
-            const { resolvedModule } = ts.resolveModuleName(moduleName, utils_1.workaroundResolve(containingFile), this._options, this);
+            const { resolvedModule } = ts.resolveModuleName(moduleName, utils_1.workaroundResolve(containingFile), this._options, this, this.moduleResolutionCache);
             if (this._options.enableIvy && resolvedModule && this.ngccProcessor) {
                 this.ngccProcessor.processModule(moduleName, resolvedModule);
             }

package/src/resource_loader.js

@@ -77,15 +77,21 @@ class WebpackResourceLoader {
         // Compile and return a promise
         return new Promise((resolve, reject) => {
             childCompiler.compile((err, childCompilation) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
                 // Resolve / reject the promise
-                if (childCompilation && childCompilation.errors && childCompilation.errors.length) {
-                    const errorDetails = childCompilation.errors.map(function (error) {
-                        return error.message + (error.error ? ':\n' + error.error : '');
-                    }).join('\n');
-                    reject(new Error('Child compilation failed:\n' + errorDetails));
+                const { warnings, errors } = childCompilation;
+                if (warnings && warnings.length) {
+                    this._parentCompilation.warnings.push(...warnings);
                 }
-                else if (err) {
-                    reject(err);
+                if (errors && errors.length) {
+                    this._parentCompilation.errors.push(...errors);
+                    const errorDetails = errors
+                        .map((error) => error.message + (error.error ? ':\n' + error.error : ''))
+                        .join('\n');
+                    reject(new Error('Child compilation failed:\n' + errorDetails));
                 }
                 else {
                     Object.keys(childCompilation.assets).forEach(assetName => {

package/src/transformers/ctor-parameters.js

@@ -17,7 +17,6 @@ function downlevelConstructorParameters(getTypeChecker) {
 exports.downlevelConstructorParameters = downlevelConstructorParameters;
 // The following is sourced from tsickle with local modifications
 // Only the creation of `ctorParameters` is retained
-// tslint:disable-next-line:max-line-length
 // https://github.com/angular/tsickle/blob/0ceb7d6bc47f6945a6c4c09689f1388eb48f5c07/src/decorator_downlevel_transformer.ts
 //
 /**

package/src/transformers/import_factory.js

@@ -10,6 +10,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
 const ts = require("typescript");
 const utils_1 = require("../utils");
+// Check if a ts.Symbol is an alias.
+const isAlias = (symbol) => symbol.flags & ts.SymbolFlags.Alias;
 /**
  * Given this original source code:
  *
@@ -153,14 +155,24 @@ function replaceImport(node, context, emitWarning, fileName, typeChecker) {
     const importStringLit = importCall.arguments[0];
     // Try to resolve the import. It might be a reexport from somewhere and the ngfactory will only
     // be present next to the original module.
-    const exportedSymbol = typeChecker.getSymbolAtLocation(exportNameId);
+    let exportedSymbol = typeChecker.getSymbolAtLocation(exportNameId);
     if (!exportedSymbol) {
         return warnAndBail();
     }
+    // Named exports are also a declaration in the re-exporting module so we have to follow the
+    // re-exports to find the original symbol.
+    if (isAlias(exportedSymbol)) {
+        exportedSymbol = typeChecker.getAliasedSymbol(exportedSymbol);
+        if (!exportedSymbol) {
+            return warnAndBail();
+        }
+    }
+    // Find declarations of the original symbol so we can get their source file name.
     const exportedSymbolDecl = exportedSymbol.getDeclarations();
     if (!exportedSymbolDecl || exportedSymbolDecl.length === 0) {
         return warnAndBail();
     }
+    // Let's guess the first declaration is the one we want, because we don't have a better criteria.
     // Get the relative path from the containing module to the imported module.
     const relativePath = path_1.relative(path_1.dirname(fileName), exportedSymbolDecl[0].getSourceFile().fileName);
     // node's `relative` call doesn't actually add `./` so we add it here.