@angular/compiler-cli 9.1.3 → 9.1.7

package/ngcc/index.d.ts

@@ -2,6 +2,7 @@
 import { AsyncNgccOptions, SyncNgccOptions } from './src/ngcc_options';
 export { ConsoleLogger } from './src/logging/console_logger';
 export { Logger, LogLevel } from './src/logging/logger';
-export { AsyncNgccOptions, NgccOptions, PathMappings, SyncNgccOptions } from './src/ngcc_options';
+export { AsyncNgccOptions, NgccOptions, SyncNgccOptions } from './src/ngcc_options';
+export { PathMappings } from './src/path_mappings';
 export declare function process(options: AsyncNgccOptions): Promise<void>;
 export declare function process(options: SyncNgccOptions): void;

package/ngcc/index.js

@@ -28,4 +28,4 @@
     }
     exports.process = process;
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvbmdjYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztJQUFBOzs7Ozs7T0FNRztJQUNILDJFQUF5RTtJQUV6RSw0REFBb0M7SUFHcEMsd0ZBQTJEO0lBQW5ELHlDQUFBLGFBQWEsQ0FBQTtJQUNyQix3RUFBc0Q7SUFBdEMsNEJBQUEsUUFBUSxDQUFBO0lBS3hCLFNBQWdCLE9BQU8sQ0FBQyxPQUFvQjtRQUMxQywyQkFBYSxDQUFDLElBQUksOEJBQWdCLEVBQUUsQ0FBQyxDQUFDO1FBQ3RDLE9BQU8sZUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQzNCLENBQUM7SUFIRCwwQkFHQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbmltcG9ydCB7Tm9kZUpTRmlsZVN5c3RlbSwgc2V0RmlsZVN5c3RlbX0gZnJvbSAnLi4vc3JjL25ndHNjL2ZpbGVfc3lzdGVtJztcblxuaW1wb3J0IHttYWluTmdjY30gZnJvbSAnLi9zcmMvbWFpbic7XG5pbXBvcnQge0FzeW5jTmdjY09wdGlvbnMsIE5nY2NPcHRpb25zLCBTeW5jTmdjY09wdGlvbnN9IGZyb20gJy4vc3JjL25nY2Nfb3B0aW9ucyc7XG5cbmV4cG9ydCB7Q29uc29sZUxvZ2dlcn0gZnJvbSAnLi9zcmMvbG9nZ2luZy9jb25zb2xlX2xvZ2dlcic7XG5leHBvcnQge0xvZ2dlciwgTG9nTGV2ZWx9IGZyb20gJy4vc3JjL2xvZ2dpbmcvbG9nZ2VyJztcbmV4cG9ydCB7QXN5bmNOZ2NjT3B0aW9ucywgTmdjY09wdGlvbnMsIFBhdGhNYXBwaW5ncywgU3luY05nY2NPcHRpb25zfSBmcm9tICcuL3NyYy9uZ2NjX29wdGlvbnMnO1xuXG5leHBvcnQgZnVuY3Rpb24gcHJvY2VzcyhvcHRpb25zOiBBc3luY05nY2NPcHRpb25zKTogUHJvbWlzZTx2b2lkPjtcbmV4cG9ydCBmdW5jdGlvbiBwcm9jZXNzKG9wdGlvbnM6IFN5bmNOZ2NjT3B0aW9ucyk6IHZvaWQ7XG5leHBvcnQgZnVuY3Rpb24gcHJvY2VzcyhvcHRpb25zOiBOZ2NjT3B0aW9ucyk6IHZvaWR8UHJvbWlzZTx2b2lkPiB7XG4gIHNldEZpbGVTeXN0ZW0obmV3IE5vZGVKU0ZpbGVTeXN0ZW0oKSk7XG4gIHJldHVybiBtYWluTmdjYyhvcHRpb25zKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvbmdjYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztJQUFBOzs7Ozs7T0FNRztJQUNILDJFQUF5RTtJQUV6RSw0REFBb0M7SUFHcEMsd0ZBQTJEO0lBQW5ELHlDQUFBLGFBQWEsQ0FBQTtJQUNyQix3RUFBc0Q7SUFBdEMsNEJBQUEsUUFBUSxDQUFBO0lBTXhCLFNBQWdCLE9BQU8sQ0FBQyxPQUFvQjtRQUMxQywyQkFBYSxDQUFDLElBQUksOEJBQWdCLEVBQUUsQ0FBQyxDQUFDO1FBQ3RDLE9BQU8sZUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQzNCLENBQUM7SUFIRCwwQkFHQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbmltcG9ydCB7Tm9kZUpTRmlsZVN5c3RlbSwgc2V0RmlsZVN5c3RlbX0gZnJvbSAnLi4vc3JjL25ndHNjL2ZpbGVfc3lzdGVtJztcblxuaW1wb3J0IHttYWluTmdjY30gZnJvbSAnLi9zcmMvbWFpbic7XG5pbXBvcnQge0FzeW5jTmdjY09wdGlvbnMsIE5nY2NPcHRpb25zLCBTeW5jTmdjY09wdGlvbnN9IGZyb20gJy4vc3JjL25nY2Nfb3B0aW9ucyc7XG5cbmV4cG9ydCB7Q29uc29sZUxvZ2dlcn0gZnJvbSAnLi9zcmMvbG9nZ2luZy9jb25zb2xlX2xvZ2dlcic7XG5leHBvcnQge0xvZ2dlciwgTG9nTGV2ZWx9IGZyb20gJy4vc3JjL2xvZ2dpbmcvbG9nZ2VyJztcbmV4cG9ydCB7QXN5bmNOZ2NjT3B0aW9ucywgTmdjY09wdGlvbnMsIFN5bmNOZ2NjT3B0aW9uc30gZnJvbSAnLi9zcmMvbmdjY19vcHRpb25zJztcbmV4cG9ydCB7UGF0aE1hcHBpbmdzfSBmcm9tICcuL3NyYy9wYXRoX21hcHBpbmdzJztcblxuZXhwb3J0IGZ1bmN0aW9uIHByb2Nlc3Mob3B0aW9uczogQXN5bmNOZ2NjT3B0aW9ucyk6IFByb21pc2U8dm9pZD47XG5leHBvcnQgZnVuY3Rpb24gcHJvY2VzcyhvcHRpb25zOiBTeW5jTmdjY09wdGlvbnMpOiB2b2lkO1xuZXhwb3J0IGZ1bmN0aW9uIHByb2Nlc3Mob3B0aW9uczogTmdjY09wdGlvbnMpOiB2b2lkfFByb21pc2U8dm9pZD4ge1xuICBzZXRGaWxlU3lzdGVtKG5ldyBOb2RlSlNGaWxlU3lzdGVtKCkpO1xuICByZXR1cm4gbWFpbk5nY2Mob3B0aW9ucyk7XG59XG4iXX0=

package/ngcc/src/analysis/module_with_providers_analyzer.d.ts

@@ -8,29 +8,55 @@
  */
 import * as ts from 'typescript';
 import { ReferencesRegistry } from '../../../src/ngtsc/annotations';
-import { ClassDeclaration, ConcreteDeclaration } from '../../../src/ngtsc/reflection';
+import { Reference } from '../../../src/ngtsc/imports';
+import { ClassDeclaration } from '../../../src/ngtsc/reflection';
 import { NgccReflectionHost } from '../host/ngcc_host';
+/**
+ * A structure returned from `getModuleWithProvidersFunctions()` that describes functions
+ * that return ModuleWithProviders objects.
+ */
 export interface ModuleWithProvidersInfo {
     /**
-     * The declaration (in the .d.ts file) of the function that returns
-     * a `ModuleWithProviders object, but has a signature that needs
-     * a type parameter adding.
+     * The name of the declared function.
+     */
+    name: string;
+    /**
+     * The declaration of the function that returns the `ModuleWithProviders` object.
      */
-    declaration: ts.MethodDeclaration | ts.FunctionDeclaration;
+    declaration: ts.SignatureDeclaration;
     /**
-     * The NgModule class declaration (in the .d.ts file) to add as a type parameter.
+     * Declaration of the containing class (if this is a method)
      */
-    ngModule: ConcreteDeclaration<ClassDeclaration>;
+    container: ts.Declaration | null;
+    /**
+     * The declaration of the class that the `ngModule` property on the `ModuleWithProviders` object
+     * refers to.
+     */
+    ngModule: Reference<ClassDeclaration>;
 }
 export declare type ModuleWithProvidersAnalyses = Map<ts.SourceFile, ModuleWithProvidersInfo[]>;
 export declare const ModuleWithProvidersAnalyses: MapConstructor;
 export declare class ModuleWithProvidersAnalyzer {
     private host;
+    private typeChecker;
     private referencesRegistry;
     private processDts;
-    constructor(host: NgccReflectionHost, referencesRegistry: ReferencesRegistry, processDts: boolean);
+    private evaluator;
+    constructor(host: NgccReflectionHost, typeChecker: ts.TypeChecker, referencesRegistry: ReferencesRegistry, processDts: boolean);
     analyzeProgram(program: ts.Program): ModuleWithProvidersAnalyses;
     private getRootFiles;
-    private getDtsDeclarationForFunction;
+    private getModuleWithProvidersFunctions;
+    /**
+     * Parse a function/method node (or its implementation), to see if it returns a
+     * `ModuleWithProviders` object.
+     * @param name The name of the function.
+     * @param node the node to check - this could be a function, a method or a variable declaration.
+     * @param implementation the actual function expression if `node` is a variable declaration.
+     * @param container the class that contains the function, if it is a method.
+     * @returns info about the function if it does return a `ModuleWithProviders` object; `null`
+     * otherwise.
+     */
+    private parseForModuleWithProviders;
+    private getDtsModuleWithProvidersFunction;
     private resolveNgModuleReference;
 }

package/ngcc/src/analysis/module_with_providers_analyzer.js

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/ngcc/src/analysis/module_with_providers_analyzer", ["require", "exports", "typescript", "@angular/compiler-cli/src/ngtsc/imports", "@angular/compiler-cli/ngcc/src/utils"], factory);
+        define("@angular/compiler-cli/ngcc/src/analysis/module_with_providers_analyzer", ["require", "exports", "typescript", "@angular/compiler-cli/src/ngtsc/imports", "@angular/compiler-cli/src/ngtsc/partial_evaluator", "@angular/compiler-cli/src/ngtsc/reflection", "@angular/compiler-cli/ngcc/src/utils"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -18,36 +18,40 @@
      */
     var ts = require("typescript");
     var imports_1 = require("@angular/compiler-cli/src/ngtsc/imports");
+    var partial_evaluator_1 = require("@angular/compiler-cli/src/ngtsc/partial_evaluator");
+    var reflection_1 = require("@angular/compiler-cli/src/ngtsc/reflection");
     var utils_1 = require("@angular/compiler-cli/ngcc/src/utils");
     exports.ModuleWithProvidersAnalyses = Map;
     var ModuleWithProvidersAnalyzer = /** @class */ (function () {
-        function ModuleWithProvidersAnalyzer(host, referencesRegistry, processDts) {
+        function ModuleWithProvidersAnalyzer(host, typeChecker, referencesRegistry, processDts) {
             this.host = host;
+            this.typeChecker = typeChecker;
             this.referencesRegistry = referencesRegistry;
             this.processDts = processDts;
+            this.evaluator = new partial_evaluator_1.PartialEvaluator(this.host, this.typeChecker, null);
         }
         ModuleWithProvidersAnalyzer.prototype.analyzeProgram = function (program) {
             var _this = this;
             var analyses = new exports.ModuleWithProvidersAnalyses();
             var rootFiles = this.getRootFiles(program);
             rootFiles.forEach(function (f) {
-                var fns = _this.host.getModuleWithProvidersFunctions(f);
+                var fns = _this.getModuleWithProvidersFunctions(f);
                 fns && fns.forEach(function (fn) {
-                    if (fn.ngModule.viaModule === null) {
+                    if (fn.ngModule.bestGuessOwningModule === null) {
                         // Record the usage of an internal module as it needs to become an exported symbol
                         _this.referencesRegistry.add(fn.ngModule.node, new imports_1.Reference(fn.ngModule.node));
                     }
                     // Only when processing the dts files do we need to determine which declaration to update.
                     if (_this.processDts) {
-                        var dtsFn = _this.getDtsDeclarationForFunction(fn);
-                        var typeParam = dtsFn.type && ts.isTypeReferenceNode(dtsFn.type) &&
-                            dtsFn.type.typeArguments && dtsFn.type.typeArguments[0] ||
+                        var dtsFn = _this.getDtsModuleWithProvidersFunction(fn);
+                        var dtsFnType = dtsFn.declaration.type;
+                        var typeParam = dtsFnType && ts.isTypeReferenceNode(dtsFnType) &&
+                            dtsFnType.typeArguments && dtsFnType.typeArguments[0] ||
                             null;
                         if (!typeParam || isAnyKeyword(typeParam)) {
-                            var ngModule = _this.resolveNgModuleReference(fn);
-                            var dtsFile = dtsFn.getSourceFile();
+                            var dtsFile = dtsFn.declaration.getSourceFile();
                             var analysis = analyses.has(dtsFile) ? analyses.get(dtsFile) : [];
-                            analysis.push({ declaration: dtsFn, ngModule: ngModule });
+                            analysis.push(dtsFn);
                             analyses.set(dtsFile, analysis);
                         }
                     }
@@ -58,7 +62,86 @@
         ModuleWithProvidersAnalyzer.prototype.getRootFiles = function (program) {
             return program.getRootFileNames().map(function (f) { return program.getSourceFile(f); }).filter(utils_1.isDefined);
         };
-        ModuleWithProvidersAnalyzer.prototype.getDtsDeclarationForFunction = function (fn) {
+        ModuleWithProvidersAnalyzer.prototype.getModuleWithProvidersFunctions = function (f) {
+            var _this = this;
+            var exports = this.host.getExportsOfModule(f);
+            if (!exports)
+                return [];
+            var infos = [];
+            exports.forEach(function (declaration) {
+                if (declaration.node === null) {
+                    return;
+                }
+                if (_this.host.isClass(declaration.node)) {
+                    _this.host.getMembersOfClass(declaration.node).forEach(function (member) {
+                        if (member.isStatic) {
+                            var info = _this.parseForModuleWithProviders(member.name, member.node, member.implementation, declaration.node);
+                            if (info) {
+                                infos.push(info);
+                            }
+                        }
+                    });
+                }
+                else {
+                    if (utils_1.hasNameIdentifier(declaration.node)) {
+                        var info = _this.parseForModuleWithProviders(declaration.node.name.text, declaration.node);
+                        if (info) {
+                            infos.push(info);
+                        }
+                    }
+                }
+            });
+            return infos;
+        };
+        /**
+         * Parse a function/method node (or its implementation), to see if it returns a
+         * `ModuleWithProviders` object.
+         * @param name The name of the function.
+         * @param node the node to check - this could be a function, a method or a variable declaration.
+         * @param implementation the actual function expression if `node` is a variable declaration.
+         * @param container the class that contains the function, if it is a method.
+         * @returns info about the function if it does return a `ModuleWithProviders` object; `null`
+         * otherwise.
+         */
+        ModuleWithProvidersAnalyzer.prototype.parseForModuleWithProviders = function (name, node, implementation, container) {
+            if (implementation === void 0) { implementation = node; }
+            if (container === void 0) { container = null; }
+            if (implementation === null ||
+                (!ts.isFunctionDeclaration(implementation) && !ts.isMethodDeclaration(implementation) &&
+                    !ts.isFunctionExpression(implementation))) {
+                return null;
+            }
+            var declaration = implementation;
+            var definition = this.host.getDefinitionOfFunction(declaration);
+            if (definition === null) {
+                return null;
+            }
+            var body = definition.body;
+            if (body === null || body.length === 0) {
+                return null;
+            }
+            // Get hold of the return statement expression for the function
+            var lastStatement = body[body.length - 1];
+            if (!ts.isReturnStatement(lastStatement) || lastStatement.expression === undefined) {
+                return null;
+            }
+            // Evaluate this expression and extract the `ngModule` reference
+            var result = this.evaluator.evaluate(lastStatement.expression);
+            if (!(result instanceof Map) || !result.has('ngModule')) {
+                return null;
+            }
+            var ngModuleRef = result.get('ngModule');
+            if (!(ngModuleRef instanceof imports_1.Reference)) {
+                return null;
+            }
+            if (!reflection_1.isNamedClassDeclaration(ngModuleRef.node) &&
+                !reflection_1.isNamedVariableDeclaration(ngModuleRef.node)) {
+                throw new Error("The identity given by " + ngModuleRef.debugName + " referenced in \"" + declaration.getText() + "\" doesn't appear to be a \"class\" declaration.");
+            }
+            var ngModule = ngModuleRef;
+            return { name: name, ngModule: ngModule, declaration: declaration, container: container };
+        };
+        ModuleWithProvidersAnalyzer.prototype.getDtsModuleWithProvidersFunction = function (fn) {
             var dtsFn = null;
             var containerClass = fn.container && this.host.getClassSymbol(fn.container);
             if (containerClass) {
@@ -78,12 +161,14 @@
             if (!isFunctionOrMethod(dtsFn)) {
                 throw new Error("Matching type declaration for " + fn.declaration.getText() + " is not a function: " + dtsFn.getText());
             }
-            return dtsFn;
+            var container = containerClass ? containerClass.declaration.valueDeclaration : null;
+            var ngModule = this.resolveNgModuleReference(fn);
+            return { name: fn.name, container: container, declaration: dtsFn, ngModule: ngModule };
         };
         ModuleWithProvidersAnalyzer.prototype.resolveNgModuleReference = function (fn) {
             var ngModule = fn.ngModule;
             // For external module references, use the declaration as is.
-            if (ngModule.viaModule !== null) {
+            if (ngModule.bestGuessOwningModule !== null) {
                 return ngModule;
             }
             // For internal (non-library) module references, redirect the module's value declaration
@@ -92,11 +177,11 @@
             if (!dtsNgModule) {
                 throw new Error("No typings declaration can be found for the referenced NgModule class in " + fn.declaration.getText() + ".");
             }
-            if (!ts.isClassDeclaration(dtsNgModule) || !utils_1.hasNameIdentifier(dtsNgModule)) {
+            if (!reflection_1.isNamedClassDeclaration(dtsNgModule)) {
                 throw new Error("The referenced NgModule in " + fn.declaration
                     .getText() + " is not a named class declaration in the typings program; instead we get " + dtsNgModule.getText());
             }
-            return { node: dtsNgModule, known: null, viaModule: null };
+            return new imports_1.Reference(dtsNgModule, null);
         };
         return ModuleWithProvidersAnalyzer;
     }());
@@ -108,4 +193,4 @@
         return typeParam.kind === ts.SyntaxKind.AnyKeyword;
     }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module_with_providers_analyzer.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/analysis/module_with_providers_analyzer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as ts from 'typescript';\n\nimport {ReferencesRegistry} from '../../../src/ngtsc/annotations';\nimport {Reference} from '../../../src/ngtsc/imports';\nimport {ClassDeclaration, ConcreteDeclaration} from '../../../src/ngtsc/reflection';\nimport {ModuleWithProvidersFunction, NgccReflectionHost} from '../host/ngcc_host';\nimport {hasNameIdentifier, isDefined} from '../utils';\n\nexport interface ModuleWithProvidersInfo {\n  /**\n   * The declaration (in the .d.ts file) of the function that returns\n   * a `ModuleWithProviders object, but has a signature that needs\n   * a type parameter adding.\n   */\n  declaration: ts.MethodDeclaration|ts.FunctionDeclaration;\n  /**\n   * The NgModule class declaration (in the .d.ts file) to add as a type parameter.\n   */\n  ngModule: ConcreteDeclaration<ClassDeclaration>;\n}\n\nexport type ModuleWithProvidersAnalyses = Map<ts.SourceFile, ModuleWithProvidersInfo[]>;\nexport const ModuleWithProvidersAnalyses = Map;\n\nexport class ModuleWithProvidersAnalyzer {\n  constructor(\n      private host: NgccReflectionHost, private referencesRegistry: ReferencesRegistry,\n      private processDts: boolean) {}\n\n  analyzeProgram(program: ts.Program): ModuleWithProvidersAnalyses {\n    const analyses = new ModuleWithProvidersAnalyses();\n    const rootFiles = this.getRootFiles(program);\n    rootFiles.forEach(f => {\n      const fns = this.host.getModuleWithProvidersFunctions(f);\n      fns && fns.forEach(fn => {\n        if (fn.ngModule.viaModule === null) {\n          // Record the usage of an internal module as it needs to become an exported symbol\n          this.referencesRegistry.add(fn.ngModule.node, new Reference(fn.ngModule.node));\n        }\n\n        // Only when processing the dts files do we need to determine which declaration to update.\n        if (this.processDts) {\n          const dtsFn = this.getDtsDeclarationForFunction(fn);\n          const typeParam = dtsFn.type && ts.isTypeReferenceNode(dtsFn.type) &&\n                  dtsFn.type.typeArguments && dtsFn.type.typeArguments[0] ||\n              null;\n          if (!typeParam || isAnyKeyword(typeParam)) {\n            const ngModule = this.resolveNgModuleReference(fn);\n            const dtsFile = dtsFn.getSourceFile();\n            const analysis = analyses.has(dtsFile) ? analyses.get(dtsFile) : [];\n            analysis.push({declaration: dtsFn, ngModule});\n            analyses.set(dtsFile, analysis);\n          }\n        }\n      });\n    });\n    return analyses;\n  }\n\n  private getRootFiles(program: ts.Program): ts.SourceFile[] {\n    return program.getRootFileNames().map(f => program.getSourceFile(f)).filter(isDefined);\n  }\n\n  private getDtsDeclarationForFunction(fn: ModuleWithProvidersFunction) {\n    let dtsFn: ts.Declaration|null = null;\n    const containerClass = fn.container && this.host.getClassSymbol(fn.container);\n    if (containerClass) {\n      const dtsClass = this.host.getDtsDeclaration(containerClass.declaration.valueDeclaration);\n      // Get the declaration of the matching static method\n      dtsFn = dtsClass && ts.isClassDeclaration(dtsClass) ?\n          dtsClass.members.find(\n              member => ts.isMethodDeclaration(member) && ts.isIdentifier(member.name) &&\n                  member.name.text === fn.name) as ts.Declaration :\n          null;\n    } else {\n      dtsFn = this.host.getDtsDeclaration(fn.declaration);\n    }\n    if (!dtsFn) {\n      throw new Error(`Matching type declaration for ${fn.declaration.getText()} is missing`);\n    }\n    if (!isFunctionOrMethod(dtsFn)) {\n      throw new Error(`Matching type declaration for ${\n          fn.declaration.getText()} is not a function: ${dtsFn.getText()}`);\n    }\n    return dtsFn;\n  }\n\n  private resolveNgModuleReference(fn: ModuleWithProvidersFunction):\n      ConcreteDeclaration<ClassDeclaration> {\n    const ngModule = fn.ngModule;\n\n    // For external module references, use the declaration as is.\n    if (ngModule.viaModule !== null) {\n      return ngModule;\n    }\n\n    // For internal (non-library) module references, redirect the module's value declaration\n    // to its type declaration.\n    const dtsNgModule = this.host.getDtsDeclaration(ngModule.node);\n    if (!dtsNgModule) {\n      throw new Error(`No typings declaration can be found for the referenced NgModule class in ${\n          fn.declaration.getText()}.`);\n    }\n    if (!ts.isClassDeclaration(dtsNgModule) || !hasNameIdentifier(dtsNgModule)) {\n      throw new Error(`The referenced NgModule in ${\n          fn.declaration\n              .getText()} is not a named class declaration in the typings program; instead we get ${\n          dtsNgModule.getText()}`);\n    }\n\n    return {node: dtsNgModule, known: null, viaModule: null};\n  }\n}\n\n\nfunction isFunctionOrMethod(declaration: ts.Declaration): declaration is ts.FunctionDeclaration|\n    ts.MethodDeclaration {\n  return ts.isFunctionDeclaration(declaration) || ts.isMethodDeclaration(declaration);\n}\n\nfunction isAnyKeyword(typeParam: ts.TypeNode): typeParam is ts.KeywordTypeNode {\n  return typeParam.kind === ts.SyntaxKind.AnyKeyword;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module_with_providers_analyzer.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/analysis/module_with_providers_analyzer.ts"],"names":[],"mappings":";;;;;;;;;;;IAAA;;;;;;OAMG;IACH,+BAAiC;IAGjC,mEAAqD;IACrD,uFAAsE;IACtE,yEAAoH;IAEpH,8DAAsD;IA2BzC,QAAA,2BAA2B,GAAG,GAAG,CAAC;IAE/C;QAGE,qCACY,IAAwB,EAAU,WAA2B,EAC7D,kBAAsC,EAAU,UAAmB;YADnE,SAAI,GAAJ,IAAI,CAAoB;YAAU,gBAAW,GAAX,WAAW,CAAgB;YAC7D,uBAAkB,GAAlB,kBAAkB,CAAoB;YAAU,eAAU,GAAV,UAAU,CAAS;YAJvE,cAAS,GAAG,IAAI,oCAAgB,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QAIM,CAAC;QAEnF,oDAAc,GAAd,UAAe,OAAmB;YAAlC,iBA4BC;YA3BC,IAAM,QAAQ,GAAgC,IAAI,mCAA2B,EAAE,CAAC;YAChF,IAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;YAC7C,SAAS,CAAC,OAAO,CAAC,UAAA,CAAC;gBACjB,IAAM,GAAG,GAAG,KAAI,CAAC,+BAA+B,CAAC,CAAC,CAAC,CAAC;gBACpD,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,UAAA,EAAE;oBACnB,IAAI,EAAE,CAAC,QAAQ,CAAC,qBAAqB,KAAK,IAAI,EAAE;wBAC9C,kFAAkF;wBAClF,KAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,mBAAS,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;qBAChF;oBAED,0FAA0F;oBAC1F,IAAI,KAAI,CAAC,UAAU,EAAE;wBACnB,IAAM,KAAK,GAAG,KAAI,CAAC,iCAAiC,CAAC,EAAE,CAAC,CAAC;wBACzD,IAAM,SAAS,GAAG,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC;wBACzC,IAAM,SAAS,GAAG,SAAS,IAAI,EAAE,CAAC,mBAAmB,CAAC,SAAS,CAAC;4BACxD,SAAS,CAAC,aAAa,IAAI,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC;4BACzD,IAAI,CAAC;wBACT,IAAI,CAAC,SAAS,IAAI,YAAY,CAAC,SAAS,CAAC,EAAE;4BACzC,IAAM,OAAO,GAAG,KAAK,CAAC,WAAW,CAAC,aAAa,EAAE,CAAC;4BAClD,IAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAE,CAAC,CAAC,CAAC,EAAE,CAAC;4BACrE,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;4BACrB,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;yBACjC;qBACF;gBACH,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;YACH,OAAO,QAAQ,CAAC;QAClB,CAAC;QAEO,kDAAY,GAApB,UAAqB,OAAmB;YACtC,OAAO,OAAO,CAAC,gBAAgB,EAAE,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,EAAxB,CAAwB,CAAC,CAAC,MAAM,CAAC,iBAAS,CAAC,CAAC;QACzF,CAAC;QAEO,qEAA+B,GAAvC,UAAwC,CAAgB;YAAxD,iBA6BC;YA5BC,IAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;YAChD,IAAI,CAAC,OAAO;gBAAE,OAAO,EAAE,CAAC;YACxB,IAAM,KAAK,GAA8B,EAAE,CAAC;YAC5C,OAAO,CAAC,OAAO,CAAC,UAAC,WAAW;gBAC1B,IAAI,WAAW,CAAC,IAAI,KAAK,IAAI,EAAE;oBAC7B,OAAO;iBACR;gBACD,IAAI,KAAI,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;oBACvC,KAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,UAAA,MAAM;wBAC1D,IAAI,MAAM,CAAC,QAAQ,EAAE;4BACnB,IAAM,IAAI,GAAG,KAAI,CAAC,2BAA2B,CACzC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,cAAc,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;4BACvE,IAAI,IAAI,EAAE;gCACR,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;6BAClB;yBACF;oBACH,CAAC,CAAC,CAAC;iBACJ;qBAAM;oBACL,IAAI,yBAAiB,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;wBACvC,IAAM,IAAI,GACN,KAAI,CAAC,2BAA2B,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;wBACnF,IAAI,IAAI,EAAE;4BACR,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;yBAClB;qBACF;iBACF;YACH,CAAC,CAAC,CAAC;YACH,OAAO,KAAK,CAAC;QACf,CAAC;QAED;;;;;;;;;WASG;QACK,iEAA2B,GAAnC,UACI,IAAY,EAAE,IAAkB,EAAE,cAAmC,EACrE,SAAqC;YADH,+BAAA,EAAA,qBAAmC;YACrE,0BAAA,EAAA,gBAAqC;YACvC,IAAI,cAAc,KAAK,IAAI;gBACvB,CAAC,CAAC,EAAE,CAAC,qBAAqB,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,cAAc,CAAC;oBACpF,CAAC,EAAE,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC,EAAE;gBAC9C,OAAO,IAAI,CAAC;aACb;YACD,IAAM,WAAW,GAAG,cAAc,CAAC;YACnC,IAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAC;YAClE,IAAI,UAAU,KAAK,IAAI,EAAE;gBACvB,OAAO,IAAI,CAAC;aACb;YAED,IAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;YAC7B,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;gBACtC,OAAO,IAAI,CAAC;aACb;YAED,+DAA+D;YAC/D,IAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAC5C,IAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,UAAU,KAAK,SAAS,EAAE;gBAClF,OAAO,IAAI,CAAC;aACb;YAED,gEAAgE;YAChE,IAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YACjE,IAAI,CAAC,CAAC,MAAM,YAAY,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;gBACvD,OAAO,IAAI,CAAC;aACb;YAED,IAAM,WAAW,GAAG,MAAM,CAAC,GAAG,CAAC,UAAU,CAAE,CAAC;YAC5C,IAAI,CAAC,CAAC,WAAW,YAAY,mBAAS,CAAC,EAAE;gBACvC,OAAO,IAAI,CAAC;aACb;YAED,IAAI,CAAC,oCAAuB,CAAC,WAAW,CAAC,IAAI,CAAC;gBAC1C,CAAC,uCAA0B,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;gBACjD,MAAM,IAAI,KAAK,CAAC,2BAAyB,WAAW,CAAC,SAAS,yBAC1D,WAAY,CAAC,OAAO,EAAE,qDAA+C,CAAC,CAAC;aAC5E;YAED,IAAM,QAAQ,GAAG,WAA0C,CAAC;YAC5D,OAAO,EAAC,IAAI,MAAA,EAAE,QAAQ,UAAA,EAAE,WAAW,aAAA,EAAE,SAAS,WAAA,EAAC,CAAC;QAClD,CAAC;QAEO,uEAAiC,GAAzC,UAA0C,EAA2B;YACnE,IAAI,KAAK,GAAwB,IAAI,CAAC;YACtC,IAAM,cAAc,GAAG,EAAE,CAAC,SAAS,IAAI,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;YAC9E,IAAI,cAAc,EAAE;gBAClB,IAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC;gBAC1F,oDAAoD;gBACpD,KAAK,GAAG,QAAQ,IAAI,EAAE,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAC;oBACjD,QAAQ,CAAC,OAAO,CAAC,IAAI,CACjB,UAAA,MAAM,IAAI,OAAA,EAAE,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC;wBACpE,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,IAAI,EADtB,CACsB,CAAmB,CAAC,CAAC;oBACzD,IAAI,CAAC;aACV;iBAAM;gBACL,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,WAAW,CAAC,CAAC;aACrD;YACD,IAAI,CAAC,KAAK,EAAE;gBACV,MAAM,IAAI,KAAK,CAAC,mCAAiC,EAAE,CAAC,WAAW,CAAC,OAAO,EAAE,gBAAa,CAAC,CAAC;aACzF;YACD,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE;gBAC9B,MAAM,IAAI,KAAK,CAAC,mCACZ,EAAE,CAAC,WAAW,CAAC,OAAO,EAAE,4BAAuB,KAAK,CAAC,OAAO,EAAI,CAAC,CAAC;aACvE;YACD,IAAM,SAAS,GAAG,cAAc,CAAC,CAAC,CAAC,cAAc,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC;YACtF,IAAM,QAAQ,GAAG,IAAI,CAAC,wBAAwB,CAAC,EAAE,CAAC,CAAC;YACnD,OAAO,EAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,SAAS,WAAA,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,UAAA,EAAC,CAAC;QAClE,CAAC;QAEO,8DAAwB,GAAhC,UAAiC,EAA2B;YAC1D,IAAM,QAAQ,GAAG,EAAE,CAAC,QAAQ,CAAC;YAE7B,6DAA6D;YAC7D,IAAI,QAAQ,CAAC,qBAAqB,KAAK,IAAI,EAAE;gBAC3C,OAAO,QAAQ,CAAC;aACjB;YAED,wFAAwF;YACxF,2BAA2B;YAC3B,IAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC/D,IAAI,CAAC,WAAW,EAAE;gBAChB,MAAM,IAAI,KAAK,CAAC,8EACZ,EAAE,CAAC,WAAW,CAAC,OAAO,EAAE,MAAG,CAAC,CAAC;aAClC;YACD,IAAI,CAAC,oCAAuB,CAAC,WAAW,CAAC,EAAE;gBACzC,MAAM,IAAI,KAAK,CAAC,gCACZ,EAAE,CAAC,WAAW;qBACT,OAAO,EAAE,iFACd,WAAW,CAAC,OAAO,EAAI,CAAC,CAAC;aAC9B;YACD,OAAO,IAAI,mBAAS,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QAC1C,CAAC;QACH,kCAAC;IAAD,CAAC,AAjLD,IAiLC;IAjLY,kEAA2B;IAoLxC,SAAS,kBAAkB,CAAC,WAA2B;QAErD,OAAO,EAAE,CAAC,qBAAqB,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;IACtF,CAAC;IAED,SAAS,YAAY,CAAC,SAAsB;QAC1C,OAAO,SAAS,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC;IACrD,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as ts from 'typescript';\n\nimport {ReferencesRegistry} from '../../../src/ngtsc/annotations';\nimport {Reference} from '../../../src/ngtsc/imports';\nimport {PartialEvaluator} from '../../../src/ngtsc/partial_evaluator';\nimport {ClassDeclaration, isNamedClassDeclaration, isNamedVariableDeclaration} from '../../../src/ngtsc/reflection';\nimport {NgccReflectionHost} from '../host/ngcc_host';\nimport {hasNameIdentifier, isDefined} from '../utils';\n\n/**\n * A structure returned from `getModuleWithProvidersFunctions()` that describes functions\n * that return ModuleWithProviders objects.\n */\nexport interface ModuleWithProvidersInfo {\n  /**\n   * The name of the declared function.\n   */\n  name: string;\n  /**\n   * The declaration of the function that returns the `ModuleWithProviders` object.\n   */\n  declaration: ts.SignatureDeclaration;\n  /**\n   * Declaration of the containing class (if this is a method)\n   */\n  container: ts.Declaration|null;\n  /**\n   * The declaration of the class that the `ngModule` property on the `ModuleWithProviders` object\n   * refers to.\n   */\n  ngModule: Reference<ClassDeclaration>;\n}\n\nexport type ModuleWithProvidersAnalyses = Map<ts.SourceFile, ModuleWithProvidersInfo[]>;\nexport const ModuleWithProvidersAnalyses = Map;\n\nexport class ModuleWithProvidersAnalyzer {\n  private evaluator = new PartialEvaluator(this.host, this.typeChecker, null);\n\n  constructor(\n      private host: NgccReflectionHost, private typeChecker: ts.TypeChecker,\n      private referencesRegistry: ReferencesRegistry, private processDts: boolean) {}\n\n  analyzeProgram(program: ts.Program): ModuleWithProvidersAnalyses {\n    const analyses: ModuleWithProvidersAnalyses = new ModuleWithProvidersAnalyses();\n    const rootFiles = this.getRootFiles(program);\n    rootFiles.forEach(f => {\n      const fns = this.getModuleWithProvidersFunctions(f);\n      fns && fns.forEach(fn => {\n        if (fn.ngModule.bestGuessOwningModule === null) {\n          // Record the usage of an internal module as it needs to become an exported symbol\n          this.referencesRegistry.add(fn.ngModule.node, new Reference(fn.ngModule.node));\n        }\n\n        // Only when processing the dts files do we need to determine which declaration to update.\n        if (this.processDts) {\n          const dtsFn = this.getDtsModuleWithProvidersFunction(fn);\n          const dtsFnType = dtsFn.declaration.type;\n          const typeParam = dtsFnType && ts.isTypeReferenceNode(dtsFnType) &&\n                  dtsFnType.typeArguments && dtsFnType.typeArguments[0] ||\n              null;\n          if (!typeParam || isAnyKeyword(typeParam)) {\n            const dtsFile = dtsFn.declaration.getSourceFile();\n            const analysis = analyses.has(dtsFile) ? analyses.get(dtsFile)! : [];\n            analysis.push(dtsFn);\n            analyses.set(dtsFile, analysis);\n          }\n        }\n      });\n    });\n    return analyses;\n  }\n\n  private getRootFiles(program: ts.Program): ts.SourceFile[] {\n    return program.getRootFileNames().map(f => program.getSourceFile(f)).filter(isDefined);\n  }\n\n  private getModuleWithProvidersFunctions(f: ts.SourceFile): ModuleWithProvidersInfo[] {\n    const exports = this.host.getExportsOfModule(f);\n    if (!exports) return [];\n    const infos: ModuleWithProvidersInfo[] = [];\n    exports.forEach((declaration) => {\n      if (declaration.node === null) {\n        return;\n      }\n      if (this.host.isClass(declaration.node)) {\n        this.host.getMembersOfClass(declaration.node).forEach(member => {\n          if (member.isStatic) {\n            const info = this.parseForModuleWithProviders(\n                member.name, member.node, member.implementation, declaration.node);\n            if (info) {\n              infos.push(info);\n            }\n          }\n        });\n      } else {\n        if (hasNameIdentifier(declaration.node)) {\n          const info =\n              this.parseForModuleWithProviders(declaration.node.name.text, declaration.node);\n          if (info) {\n            infos.push(info);\n          }\n        }\n      }\n    });\n    return infos;\n  }\n\n  /**\n   * Parse a function/method node (or its implementation), to see if it returns a\n   * `ModuleWithProviders` object.\n   * @param name The name of the function.\n   * @param node the node to check - this could be a function, a method or a variable declaration.\n   * @param implementation the actual function expression if `node` is a variable declaration.\n   * @param container the class that contains the function, if it is a method.\n   * @returns info about the function if it does return a `ModuleWithProviders` object; `null`\n   * otherwise.\n   */\n  private parseForModuleWithProviders(\n      name: string, node: ts.Node|null, implementation: ts.Node|null = node,\n      container: ts.Declaration|null = null): ModuleWithProvidersInfo|null {\n    if (implementation === null ||\n        (!ts.isFunctionDeclaration(implementation) && !ts.isMethodDeclaration(implementation) &&\n         !ts.isFunctionExpression(implementation))) {\n      return null;\n    }\n    const declaration = implementation;\n    const definition = this.host.getDefinitionOfFunction(declaration);\n    if (definition === null) {\n      return null;\n    }\n\n    const body = definition.body;\n    if (body === null || body.length === 0) {\n      return null;\n    }\n\n    // Get hold of the return statement expression for the function\n    const lastStatement = body[body.length - 1];\n    if (!ts.isReturnStatement(lastStatement) || lastStatement.expression === undefined) {\n      return null;\n    }\n\n    // Evaluate this expression and extract the `ngModule` reference\n    const result = this.evaluator.evaluate(lastStatement.expression);\n    if (!(result instanceof Map) || !result.has('ngModule')) {\n      return null;\n    }\n\n    const ngModuleRef = result.get('ngModule')!;\n    if (!(ngModuleRef instanceof Reference)) {\n      return null;\n    }\n\n    if (!isNamedClassDeclaration(ngModuleRef.node) &&\n        !isNamedVariableDeclaration(ngModuleRef.node)) {\n      throw new Error(`The identity given by ${ngModuleRef.debugName} referenced in \"${\n          declaration!.getText()}\" doesn't appear to be a \"class\" declaration.`);\n    }\n\n    const ngModule = ngModuleRef as Reference<ClassDeclaration>;\n    return {name, ngModule, declaration, container};\n  }\n\n  private getDtsModuleWithProvidersFunction(fn: ModuleWithProvidersInfo): ModuleWithProvidersInfo {\n    let dtsFn: ts.Declaration|null = null;\n    const containerClass = fn.container && this.host.getClassSymbol(fn.container);\n    if (containerClass) {\n      const dtsClass = this.host.getDtsDeclaration(containerClass.declaration.valueDeclaration);\n      // Get the declaration of the matching static method\n      dtsFn = dtsClass && ts.isClassDeclaration(dtsClass) ?\n          dtsClass.members.find(\n              member => ts.isMethodDeclaration(member) && ts.isIdentifier(member.name) &&\n                  member.name.text === fn.name) as ts.Declaration :\n          null;\n    } else {\n      dtsFn = this.host.getDtsDeclaration(fn.declaration);\n    }\n    if (!dtsFn) {\n      throw new Error(`Matching type declaration for ${fn.declaration.getText()} is missing`);\n    }\n    if (!isFunctionOrMethod(dtsFn)) {\n      throw new Error(`Matching type declaration for ${\n          fn.declaration.getText()} is not a function: ${dtsFn.getText()}`);\n    }\n    const container = containerClass ? containerClass.declaration.valueDeclaration : null;\n    const ngModule = this.resolveNgModuleReference(fn);\n    return {name: fn.name, container, declaration: dtsFn, ngModule};\n  }\n\n  private resolveNgModuleReference(fn: ModuleWithProvidersInfo): Reference<ClassDeclaration> {\n    const ngModule = fn.ngModule;\n\n    // For external module references, use the declaration as is.\n    if (ngModule.bestGuessOwningModule !== null) {\n      return ngModule;\n    }\n\n    // For internal (non-library) module references, redirect the module's value declaration\n    // to its type declaration.\n    const dtsNgModule = this.host.getDtsDeclaration(ngModule.node);\n    if (!dtsNgModule) {\n      throw new Error(`No typings declaration can be found for the referenced NgModule class in ${\n          fn.declaration.getText()}.`);\n    }\n    if (!isNamedClassDeclaration(dtsNgModule)) {\n      throw new Error(`The referenced NgModule in ${\n          fn.declaration\n              .getText()} is not a named class declaration in the typings program; instead we get ${\n          dtsNgModule.getText()}`);\n    }\n    return new Reference(dtsNgModule, null);\n  }\n}\n\n\nfunction isFunctionOrMethod(declaration: ts.Declaration): declaration is ts.FunctionDeclaration|\n    ts.MethodDeclaration {\n  return ts.isFunctionDeclaration(declaration) || ts.isMethodDeclaration(declaration);\n}\n\nfunction isAnyKeyword(typeParam: ts.TypeNode): typeParam is ts.KeywordTypeNode {\n  return typeParam.kind === ts.SyntaxKind.AnyKeyword;\n}\n"]}

package/ngcc/src/dependencies/dts_dependency_host.d.ts

@@ -7,7 +7,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { AbsoluteFsPath, FileSystem } from '../../../src/ngtsc/file_system';
-import { PathMappings } from '../ngcc_options';
+import { PathMappings } from '../path_mappings';
 import { EsmDependencyHost } from './esm_dependency_host';
 /**
  * Helper functions for computing dependencies via typings files.

package/ngcc/src/dependencies/dts_dependency_host.js

@@ -31,4 +31,4 @@
     }(esm_dependency_host_1.EsmDependencyHost));
     exports.DtsDependencyHost = DtsDependencyHost;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/dependencies/module_resolver.d.ts

@@ -7,7 +7,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { AbsoluteFsPath, FileSystem } from '../../../src/ngtsc/file_system';
-import { PathMappings } from '../ngcc_options';
+import { PathMappings } from '../path_mappings';
 /**
  * This is a very cut-down implementation of the TypeScript module resolution strategy.
  *

package/ngcc/src/dependencies/module_resolver.js

@@ -274,4 +274,4 @@
         return to.startsWith(from) && !to.includes('node_modules');
     }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module_resolver.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/dependencies/module_resolver.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {absoluteFrom, AbsoluteFsPath, dirname, FileSystem, isRoot, join, resolve} from '../../../src/ngtsc/file_system';\nimport {PathMappings} from '../ngcc_options';\nimport {isRelativePath, resolveFileWithPostfixes} from '../utils';\n\n/**\n * This is a very cut-down implementation of the TypeScript module resolution strategy.\n *\n * It is specific to the needs of ngcc and is not intended to be a drop-in replacement\n * for the TS module resolver. It is used to compute the dependencies between entry-points\n * that may be compiled by ngcc.\n *\n * The algorithm only finds `.js` files for internal/relative imports and paths to\n * the folder containing the `package.json` of the entry-point for external imports.\n *\n * It can cope with nested `node_modules` folders and also supports `paths`/`baseUrl`\n * configuration properties, as provided in a `ts.CompilerOptions` object.\n */\nexport class ModuleResolver {\n  private pathMappings: ProcessedPathMapping[];\n\n  constructor(private fs: FileSystem, pathMappings?: PathMappings, readonly relativeExtensions = [\n    '', '.js', '/index.js'\n  ]) {\n    this.pathMappings = pathMappings ? this.processPathMappings(pathMappings) : [];\n  }\n\n  /**\n   * Resolve an absolute path for the `moduleName` imported into a file at `fromPath`.\n   * @param moduleName The name of the import to resolve.\n   * @param fromPath The path to the file containing the import.\n   * @returns A path to the resolved module or null if missing.\n   * Specifically:\n   *  * the absolute path to the package.json of an external module\n   *  * a JavaScript file of an internal module\n   *  * null if none exists.\n   */\n  resolveModuleImport(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    if (isRelativePath(moduleName)) {\n      return this.resolveAsRelativePath(moduleName, fromPath);\n    } else {\n      return this.pathMappings.length && this.resolveByPathMappings(moduleName, fromPath) ||\n          this.resolveAsEntryPoint(moduleName, fromPath);\n    }\n  }\n\n  /**\n   * Convert the `pathMappings` into a collection of `PathMapper` functions.\n   */\n  private processPathMappings(pathMappings: PathMappings): ProcessedPathMapping[] {\n    const baseUrl = absoluteFrom(pathMappings.baseUrl);\n    return Object.keys(pathMappings.paths).map(pathPattern => {\n      const matcher = splitOnStar(pathPattern);\n      const templates = pathMappings.paths[pathPattern].map(splitOnStar);\n      return {matcher, templates, baseUrl};\n    });\n  }\n\n  /**\n   * Try to resolve a module name, as a relative path, from the `fromPath`.\n   *\n   * As it is relative, it only looks for files that end in one of the `relativeExtensions`.\n   * For example: `${moduleName}.js` or `${moduleName}/index.js`.\n   * If neither of these files exist then the method returns `null`.\n   */\n  private resolveAsRelativePath(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    const resolvedPath = resolveFileWithPostfixes(\n        this.fs, resolve(dirname(fromPath), moduleName), this.relativeExtensions);\n    return resolvedPath && new ResolvedRelativeModule(resolvedPath);\n  }\n\n  /**\n   * Try to resolve the `moduleName`, by applying the computed `pathMappings` and\n   * then trying to resolve the mapped path as a relative or external import.\n   *\n   * Whether the mapped path is relative is defined as it being \"below the `fromPath`\" and not\n   * containing `node_modules`.\n   *\n   * If the mapped path is not relative but does not resolve to an external entry-point, then we\n   * check whether it would have resolved to a relative path, in which case it is marked as a\n   * \"deep-import\".\n   */\n  private resolveByPathMappings(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    const mappedPaths = this.findMappedPaths(moduleName);\n    if (mappedPaths.length > 0) {\n      const packagePath = this.findPackagePath(fromPath);\n      if (packagePath !== null) {\n        for (const mappedPath of mappedPaths) {\n          if (this.isEntryPoint(mappedPath)) {\n            return new ResolvedExternalModule(mappedPath);\n          }\n          const nonEntryPointImport = this.resolveAsRelativePath(mappedPath, fromPath);\n          if (nonEntryPointImport !== null) {\n            return isRelativeImport(packagePath, mappedPath) ? nonEntryPointImport :\n                                                               new ResolvedDeepImport(mappedPath);\n          }\n        }\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Try to resolve the `moduleName` as an external entry-point by searching the `node_modules`\n   * folders up the tree for a matching `.../node_modules/${moduleName}`.\n   *\n   * If a folder is found but the path does not contain a `package.json` then it is marked as a\n   * \"deep-import\".\n   */\n  private resolveAsEntryPoint(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    let folder = fromPath;\n    while (!isRoot(folder)) {\n      folder = dirname(folder);\n      if (folder.endsWith('node_modules')) {\n        // Skip up if the folder already ends in node_modules\n        folder = dirname(folder);\n      }\n      const modulePath = resolve(folder, 'node_modules', moduleName);\n      if (this.isEntryPoint(modulePath)) {\n        return new ResolvedExternalModule(modulePath);\n      } else if (this.resolveAsRelativePath(modulePath, fromPath)) {\n        return new ResolvedDeepImport(modulePath);\n      }\n    }\n    return null;\n  }\n\n\n  /**\n   * Can we consider the given path as an entry-point to a package?\n   *\n   * This is achieved by checking for the existence of `${modulePath}/package.json`.\n   */\n  private isEntryPoint(modulePath: AbsoluteFsPath): boolean {\n    return this.fs.exists(join(modulePath, 'package.json'));\n  }\n\n  /**\n   * Apply the `pathMappers` to the `moduleName` and return all the possible\n   * paths that match.\n   *\n   * The mapped path is computed for each template in `mapping.templates` by\n   * replacing the `matcher.prefix` and `matcher.postfix` strings in `path with the\n   * `template.prefix` and `template.postfix` strings.\n   */\n  private findMappedPaths(moduleName: string): AbsoluteFsPath[] {\n    const matches = this.pathMappings.map(mapping => this.matchMapping(moduleName, mapping));\n\n    let bestMapping: ProcessedPathMapping|undefined;\n    let bestMatch: string|undefined;\n\n    for (let index = 0; index < this.pathMappings.length; index++) {\n      const mapping = this.pathMappings[index];\n      const match = matches[index];\n      if (match !== null) {\n        // If this mapping had no wildcard then this must be a complete match.\n        if (!mapping.matcher.hasWildcard) {\n          bestMatch = match;\n          bestMapping = mapping;\n          break;\n        }\n        // The best matched mapping is the one with the longest prefix.\n        if (!bestMapping || mapping.matcher.prefix > bestMapping.matcher.prefix) {\n          bestMatch = match;\n          bestMapping = mapping;\n        }\n      }\n    }\n\n    return (bestMapping !== undefined && bestMatch !== undefined) ?\n        this.computeMappedTemplates(bestMapping, bestMatch) :\n        [];\n  }\n\n  /**\n   * Attempt to find a mapped path for the given `path` and a `mapping`.\n   *\n   * The `path` matches the `mapping` if if it starts with `matcher.prefix` and ends with\n   * `matcher.postfix`.\n   *\n   * @returns the wildcard segment of a matched `path`, or `null` if no match.\n   */\n  private matchMapping(path: string, mapping: ProcessedPathMapping): string|null {\n    const {prefix, postfix, hasWildcard} = mapping.matcher;\n    if (hasWildcard) {\n      return (path.startsWith(prefix) && path.endsWith(postfix)) ?\n          path.substring(prefix.length, path.length - postfix.length) :\n          null;\n    } else {\n      return (path === prefix) ? '' : null;\n    }\n  }\n\n  /**\n   * Compute the candidate paths from the given mapping's templates using the matched\n   * string.\n   */\n  private computeMappedTemplates(mapping: ProcessedPathMapping, match: string) {\n    return mapping.templates.map(\n        template => resolve(mapping.baseUrl, template.prefix + match + template.postfix));\n  }\n\n  /**\n   * Search up the folder tree for the first folder that contains `package.json`\n   * or `null` if none is found.\n   */\n  private findPackagePath(path: AbsoluteFsPath): AbsoluteFsPath|null {\n    let folder = path;\n    while (!isRoot(folder)) {\n      folder = dirname(folder);\n      if (this.fs.exists(join(folder, 'package.json'))) {\n        return folder;\n      }\n    }\n    return null;\n  }\n}\n\n/** The result of resolving an import to a module. */\nexport type ResolvedModule = ResolvedExternalModule|ResolvedRelativeModule|ResolvedDeepImport;\n\n/**\n * A module that is external to the package doing the importing.\n * In this case we capture the folder containing the entry-point.\n */\nexport class ResolvedExternalModule {\n  constructor(public entryPointPath: AbsoluteFsPath) {}\n}\n\n/**\n * A module that is relative to the module doing the importing, and so internal to the\n * source module's package.\n */\nexport class ResolvedRelativeModule {\n  constructor(public modulePath: AbsoluteFsPath) {}\n}\n\n/**\n * A module that is external to the package doing the importing but pointing to a\n * module that is deep inside a package, rather than to an entry-point of the package.\n */\nexport class ResolvedDeepImport {\n  constructor(public importPath: AbsoluteFsPath) {}\n}\n\nfunction splitOnStar(str: string): PathMappingPattern {\n  const [prefix, postfix] = str.split('*', 2);\n  return {prefix, postfix: postfix || '', hasWildcard: postfix !== undefined};\n}\n\ninterface ProcessedPathMapping {\n  baseUrl: AbsoluteFsPath;\n  matcher: PathMappingPattern;\n  templates: PathMappingPattern[];\n}\n\ninterface PathMappingPattern {\n  prefix: string;\n  postfix: string;\n  hasWildcard: boolean;\n}\n\nfunction isRelativeImport(from: AbsoluteFsPath, to: AbsoluteFsPath) {\n  return to.startsWith(from) && !to.includes('node_modules');\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module_resolver.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/dependencies/module_resolver.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {absoluteFrom, AbsoluteFsPath, dirname, FileSystem, isRoot, join, resolve} from '../../../src/ngtsc/file_system';\nimport {PathMappings} from '../path_mappings';\nimport {isRelativePath, resolveFileWithPostfixes} from '../utils';\n\n/**\n * This is a very cut-down implementation of the TypeScript module resolution strategy.\n *\n * It is specific to the needs of ngcc and is not intended to be a drop-in replacement\n * for the TS module resolver. It is used to compute the dependencies between entry-points\n * that may be compiled by ngcc.\n *\n * The algorithm only finds `.js` files for internal/relative imports and paths to\n * the folder containing the `package.json` of the entry-point for external imports.\n *\n * It can cope with nested `node_modules` folders and also supports `paths`/`baseUrl`\n * configuration properties, as provided in a `ts.CompilerOptions` object.\n */\nexport class ModuleResolver {\n  private pathMappings: ProcessedPathMapping[];\n\n  constructor(private fs: FileSystem, pathMappings?: PathMappings, readonly relativeExtensions = [\n    '', '.js', '/index.js'\n  ]) {\n    this.pathMappings = pathMappings ? this.processPathMappings(pathMappings) : [];\n  }\n\n  /**\n   * Resolve an absolute path for the `moduleName` imported into a file at `fromPath`.\n   * @param moduleName The name of the import to resolve.\n   * @param fromPath The path to the file containing the import.\n   * @returns A path to the resolved module or null if missing.\n   * Specifically:\n   *  * the absolute path to the package.json of an external module\n   *  * a JavaScript file of an internal module\n   *  * null if none exists.\n   */\n  resolveModuleImport(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    if (isRelativePath(moduleName)) {\n      return this.resolveAsRelativePath(moduleName, fromPath);\n    } else {\n      return this.pathMappings.length && this.resolveByPathMappings(moduleName, fromPath) ||\n          this.resolveAsEntryPoint(moduleName, fromPath);\n    }\n  }\n\n  /**\n   * Convert the `pathMappings` into a collection of `PathMapper` functions.\n   */\n  private processPathMappings(pathMappings: PathMappings): ProcessedPathMapping[] {\n    const baseUrl = absoluteFrom(pathMappings.baseUrl);\n    return Object.keys(pathMappings.paths).map(pathPattern => {\n      const matcher = splitOnStar(pathPattern);\n      const templates = pathMappings.paths[pathPattern].map(splitOnStar);\n      return {matcher, templates, baseUrl};\n    });\n  }\n\n  /**\n   * Try to resolve a module name, as a relative path, from the `fromPath`.\n   *\n   * As it is relative, it only looks for files that end in one of the `relativeExtensions`.\n   * For example: `${moduleName}.js` or `${moduleName}/index.js`.\n   * If neither of these files exist then the method returns `null`.\n   */\n  private resolveAsRelativePath(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    const resolvedPath = resolveFileWithPostfixes(\n        this.fs, resolve(dirname(fromPath), moduleName), this.relativeExtensions);\n    return resolvedPath && new ResolvedRelativeModule(resolvedPath);\n  }\n\n  /**\n   * Try to resolve the `moduleName`, by applying the computed `pathMappings` and\n   * then trying to resolve the mapped path as a relative or external import.\n   *\n   * Whether the mapped path is relative is defined as it being \"below the `fromPath`\" and not\n   * containing `node_modules`.\n   *\n   * If the mapped path is not relative but does not resolve to an external entry-point, then we\n   * check whether it would have resolved to a relative path, in which case it is marked as a\n   * \"deep-import\".\n   */\n  private resolveByPathMappings(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    const mappedPaths = this.findMappedPaths(moduleName);\n    if (mappedPaths.length > 0) {\n      const packagePath = this.findPackagePath(fromPath);\n      if (packagePath !== null) {\n        for (const mappedPath of mappedPaths) {\n          if (this.isEntryPoint(mappedPath)) {\n            return new ResolvedExternalModule(mappedPath);\n          }\n          const nonEntryPointImport = this.resolveAsRelativePath(mappedPath, fromPath);\n          if (nonEntryPointImport !== null) {\n            return isRelativeImport(packagePath, mappedPath) ? nonEntryPointImport :\n                                                               new ResolvedDeepImport(mappedPath);\n          }\n        }\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Try to resolve the `moduleName` as an external entry-point by searching the `node_modules`\n   * folders up the tree for a matching `.../node_modules/${moduleName}`.\n   *\n   * If a folder is found but the path does not contain a `package.json` then it is marked as a\n   * \"deep-import\".\n   */\n  private resolveAsEntryPoint(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule|null {\n    let folder = fromPath;\n    while (!isRoot(folder)) {\n      folder = dirname(folder);\n      if (folder.endsWith('node_modules')) {\n        // Skip up if the folder already ends in node_modules\n        folder = dirname(folder);\n      }\n      const modulePath = resolve(folder, 'node_modules', moduleName);\n      if (this.isEntryPoint(modulePath)) {\n        return new ResolvedExternalModule(modulePath);\n      } else if (this.resolveAsRelativePath(modulePath, fromPath)) {\n        return new ResolvedDeepImport(modulePath);\n      }\n    }\n    return null;\n  }\n\n\n  /**\n   * Can we consider the given path as an entry-point to a package?\n   *\n   * This is achieved by checking for the existence of `${modulePath}/package.json`.\n   */\n  private isEntryPoint(modulePath: AbsoluteFsPath): boolean {\n    return this.fs.exists(join(modulePath, 'package.json'));\n  }\n\n  /**\n   * Apply the `pathMappers` to the `moduleName` and return all the possible\n   * paths that match.\n   *\n   * The mapped path is computed for each template in `mapping.templates` by\n   * replacing the `matcher.prefix` and `matcher.postfix` strings in `path with the\n   * `template.prefix` and `template.postfix` strings.\n   */\n  private findMappedPaths(moduleName: string): AbsoluteFsPath[] {\n    const matches = this.pathMappings.map(mapping => this.matchMapping(moduleName, mapping));\n\n    let bestMapping: ProcessedPathMapping|undefined;\n    let bestMatch: string|undefined;\n\n    for (let index = 0; index < this.pathMappings.length; index++) {\n      const mapping = this.pathMappings[index];\n      const match = matches[index];\n      if (match !== null) {\n        // If this mapping had no wildcard then this must be a complete match.\n        if (!mapping.matcher.hasWildcard) {\n          bestMatch = match;\n          bestMapping = mapping;\n          break;\n        }\n        // The best matched mapping is the one with the longest prefix.\n        if (!bestMapping || mapping.matcher.prefix > bestMapping.matcher.prefix) {\n          bestMatch = match;\n          bestMapping = mapping;\n        }\n      }\n    }\n\n    return (bestMapping !== undefined && bestMatch !== undefined) ?\n        this.computeMappedTemplates(bestMapping, bestMatch) :\n        [];\n  }\n\n  /**\n   * Attempt to find a mapped path for the given `path` and a `mapping`.\n   *\n   * The `path` matches the `mapping` if if it starts with `matcher.prefix` and ends with\n   * `matcher.postfix`.\n   *\n   * @returns the wildcard segment of a matched `path`, or `null` if no match.\n   */\n  private matchMapping(path: string, mapping: ProcessedPathMapping): string|null {\n    const {prefix, postfix, hasWildcard} = mapping.matcher;\n    if (hasWildcard) {\n      return (path.startsWith(prefix) && path.endsWith(postfix)) ?\n          path.substring(prefix.length, path.length - postfix.length) :\n          null;\n    } else {\n      return (path === prefix) ? '' : null;\n    }\n  }\n\n  /**\n   * Compute the candidate paths from the given mapping's templates using the matched\n   * string.\n   */\n  private computeMappedTemplates(mapping: ProcessedPathMapping, match: string) {\n    return mapping.templates.map(\n        template => resolve(mapping.baseUrl, template.prefix + match + template.postfix));\n  }\n\n  /**\n   * Search up the folder tree for the first folder that contains `package.json`\n   * or `null` if none is found.\n   */\n  private findPackagePath(path: AbsoluteFsPath): AbsoluteFsPath|null {\n    let folder = path;\n    while (!isRoot(folder)) {\n      folder = dirname(folder);\n      if (this.fs.exists(join(folder, 'package.json'))) {\n        return folder;\n      }\n    }\n    return null;\n  }\n}\n\n/** The result of resolving an import to a module. */\nexport type ResolvedModule = ResolvedExternalModule|ResolvedRelativeModule|ResolvedDeepImport;\n\n/**\n * A module that is external to the package doing the importing.\n * In this case we capture the folder containing the entry-point.\n */\nexport class ResolvedExternalModule {\n  constructor(public entryPointPath: AbsoluteFsPath) {}\n}\n\n/**\n * A module that is relative to the module doing the importing, and so internal to the\n * source module's package.\n */\nexport class ResolvedRelativeModule {\n  constructor(public modulePath: AbsoluteFsPath) {}\n}\n\n/**\n * A module that is external to the package doing the importing but pointing to a\n * module that is deep inside a package, rather than to an entry-point of the package.\n */\nexport class ResolvedDeepImport {\n  constructor(public importPath: AbsoluteFsPath) {}\n}\n\nfunction splitOnStar(str: string): PathMappingPattern {\n  const [prefix, postfix] = str.split('*', 2);\n  return {prefix, postfix: postfix || '', hasWildcard: postfix !== undefined};\n}\n\ninterface ProcessedPathMapping {\n  baseUrl: AbsoluteFsPath;\n  matcher: PathMappingPattern;\n  templates: PathMappingPattern[];\n}\n\ninterface PathMappingPattern {\n  prefix: string;\n  postfix: string;\n  hasWildcard: boolean;\n}\n\nfunction isRelativeImport(from: AbsoluteFsPath, to: AbsoluteFsPath) {\n  return to.startsWith(from) && !to.includes('node_modules');\n}\n"]}

package/ngcc/src/entry_point_finder/directory_walker_entry_point_finder.d.ts

@@ -10,9 +10,9 @@ import { AbsoluteFsPath, FileSystem } from '../../../src/ngtsc/file_system';
 import { EntryPointWithDependencies } from '../dependencies/dependency_host';
 import { DependencyResolver, SortedEntryPointsInfo } from '../dependencies/dependency_resolver';
 import { Logger } from '../logging/logger';
-import { PathMappings } from '../ngcc_options';
 import { NgccConfiguration } from '../packages/configuration';
 import { EntryPointManifest } from '../packages/entry_point_manifest';
+import { PathMappings } from '../path_mappings';
 import { EntryPointFinder } from './interface';
 /**
  * An EntryPointFinder that searches for all entry-points that can be found given a `basePath` and

package/ngcc/src/entry_point_finder/directory_walker_entry_point_finder.js

@@ -194,4 +194,4 @@
         return path.startsWith('.') || path === 'node_modules' || path === new_entry_point_file_writer_1.NGCC_DIRECTORY;
     }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directory_walker_entry_point_finder.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/entry_point_finder/directory_walker_entry_point_finder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {AbsoluteFsPath, FileSystem, PathSegment} from '../../../src/ngtsc/file_system';\nimport {EntryPointWithDependencies} from '../dependencies/dependency_host';\nimport {DependencyResolver, SortedEntryPointsInfo} from '../dependencies/dependency_resolver';\nimport {Logger} from '../logging/logger';\nimport {PathMappings} from '../ngcc_options';\nimport {NgccConfiguration} from '../packages/configuration';\nimport {getEntryPointInfo, INCOMPATIBLE_ENTRY_POINT, NO_ENTRY_POINT} from '../packages/entry_point';\nimport {EntryPointManifest} from '../packages/entry_point_manifest';\nimport {NGCC_DIRECTORY} from '../writing/new_entry_point_file_writer';\n\nimport {EntryPointFinder} from './interface';\nimport {getBasePaths, trackDuration} from './utils';\n\n/**\n * An EntryPointFinder that searches for all entry-points that can be found given a `basePath` and\n * `pathMappings`.\n */\nexport class DirectoryWalkerEntryPointFinder implements EntryPointFinder {\n  private basePaths = getBasePaths(this.logger, this.sourceDirectory, this.pathMappings);\n  constructor(\n      private fs: FileSystem, private config: NgccConfiguration, private logger: Logger,\n      private resolver: DependencyResolver, private entryPointManifest: EntryPointManifest,\n      private sourceDirectory: AbsoluteFsPath, private pathMappings: PathMappings|undefined) {}\n  /**\n   * Search the `sourceDirectory`, and sub-directories, using `pathMappings` as necessary, to find\n   * all package entry-points.\n   */\n  findEntryPoints(): SortedEntryPointsInfo {\n    const unsortedEntryPoints: EntryPointWithDependencies[] = [];\n    for (const basePath of this.basePaths) {\n      const entryPoints = this.entryPointManifest.readEntryPointsUsingManifest(basePath) ||\n          this.walkBasePathForPackages(basePath);\n      entryPoints.forEach(e => unsortedEntryPoints.push(e));\n    }\n    return this.resolver.sortEntryPointsByDependency(unsortedEntryPoints);\n  }\n\n  /**\n   * Search the `basePath` for possible Angular packages and entry-points.\n   *\n   * @param basePath The path at which to start the search\n   * @returns an array of `EntryPoint`s that were found within `basePath`.\n   */\n  walkBasePathForPackages(basePath: AbsoluteFsPath): EntryPointWithDependencies[] {\n    this.logger.debug(\n        `No manifest found for ${basePath} so walking the directories for entry-points.`);\n    const entryPoints = trackDuration(\n        () => this.walkDirectoryForPackages(basePath),\n        duration => this.logger.debug(`Walking ${basePath} for entry-points took ${duration}s.`));\n    this.entryPointManifest.writeEntryPointManifest(basePath, entryPoints);\n    return entryPoints;\n  }\n\n  /**\n   * Look for Angular packages that need to be compiled, starting at the source directory.\n   * The function will recurse into directories that start with `@...`, e.g. `@angular/...`.\n   *\n   * @param sourceDirectory An absolute path to the root directory where searching begins.\n   * @returns an array of `EntryPoint`s that were found within `sourceDirectory`.\n   */\n  walkDirectoryForPackages(sourceDirectory: AbsoluteFsPath): EntryPointWithDependencies[] {\n    // Try to get a primary entry point from this directory\n    const primaryEntryPoint =\n        getEntryPointInfo(this.fs, this.config, this.logger, sourceDirectory, sourceDirectory);\n\n    // If there is an entry-point but it is not compatible with ngcc (it has a bad package.json or\n    // invalid typings) then exit. It is unlikely that such an entry point has a dependency on an\n    // Angular library.\n    if (primaryEntryPoint === INCOMPATIBLE_ENTRY_POINT) {\n      return [];\n    }\n\n    const entryPoints: EntryPointWithDependencies[] = [];\n    if (primaryEntryPoint !== NO_ENTRY_POINT) {\n      entryPoints.push(this.resolver.getEntryPointWithDependencies(primaryEntryPoint));\n      this.collectSecondaryEntryPoints(\n          entryPoints, sourceDirectory, sourceDirectory, this.fs.readdir(sourceDirectory));\n\n      // Also check for any nested node_modules in this package but only if at least one of the\n      // entry-points was compiled by Angular.\n      if (entryPoints.some(e => e.entryPoint.compiledByAngular)) {\n        const nestedNodeModulesPath = this.fs.join(sourceDirectory, 'node_modules');\n        if (this.fs.exists(nestedNodeModulesPath)) {\n          entryPoints.push(...this.walkDirectoryForPackages(nestedNodeModulesPath));\n        }\n      }\n\n      return entryPoints;\n    }\n\n    // The `sourceDirectory` was not a package (i.e. there was no package.json)\n    // So search its sub-directories for Angular packages and entry-points\n    for (const path of this.fs.readdir(sourceDirectory)) {\n      if (isIgnorablePath(path)) {\n        // Ignore hidden files, node_modules and ngcc directory\n        continue;\n      }\n\n      const absolutePath = this.fs.resolve(sourceDirectory, path);\n      const stat = this.fs.lstat(absolutePath);\n      if (stat.isSymbolicLink() || !stat.isDirectory()) {\n        // Ignore symbolic links and non-directories\n        continue;\n      }\n\n      entryPoints.push(...this.walkDirectoryForPackages(this.fs.join(sourceDirectory, path)));\n    }\n\n    return entryPoints;\n  }\n\n  /**\n   * Search the `directory` looking for any secondary entry-points for a package, adding any that\n   * are found to the `entryPoints` array.\n   *\n   * @param entryPoints An array where we will add any entry-points found in this directory\n   * @param packagePath The absolute path to the package that may contain entry-points\n   * @param directory The current directory being searched\n   * @param paths The paths contained in the current `directory`.\n   */\n  private collectSecondaryEntryPoints(\n      entryPoints: EntryPointWithDependencies[], packagePath: AbsoluteFsPath,\n      directory: AbsoluteFsPath, paths: PathSegment[]): void {\n    for (const path of paths) {\n      if (isIgnorablePath(path)) {\n        // Ignore hidden files, node_modules and ngcc directory\n        continue;\n      }\n\n      const absolutePath = this.fs.resolve(directory, path);\n      const stat = this.fs.lstat(absolutePath);\n      if (stat.isSymbolicLink()) {\n        // Ignore symbolic links\n        continue;\n      }\n\n      const isDirectory = stat.isDirectory();\n      if (!path.endsWith('.js') && !isDirectory) {\n        // Ignore files that do not end in `.js`\n        continue;\n      }\n\n      // If the path is a JS file then strip its extension and see if we can match an\n      // entry-point.\n      const possibleEntryPointPath = isDirectory ? absolutePath : stripJsExtension(absolutePath);\n      let isEntryPoint = false;\n      const subEntryPoint =\n          getEntryPointInfo(this.fs, this.config, this.logger, packagePath, possibleEntryPointPath);\n      if (subEntryPoint !== NO_ENTRY_POINT && subEntryPoint !== INCOMPATIBLE_ENTRY_POINT) {\n        entryPoints.push(this.resolver.getEntryPointWithDependencies(subEntryPoint));\n        isEntryPoint = true;\n      }\n\n      if (!isDirectory) {\n        // This path is not a directory so we are done.\n        continue;\n      }\n\n      // This directory may contain entry-points of its own.\n      const childPaths = this.fs.readdir(absolutePath);\n      if (!isEntryPoint &&\n          childPaths.some(\n              childPath => childPath.endsWith('.js') &&\n                  this.fs.stat(this.fs.resolve(absolutePath, childPath)).isFile())) {\n        // We do not consider non-entry-point directories that contain JS files as they are very\n        // unlikely to be containers for sub-entry-points.\n        continue;\n      }\n      this.collectSecondaryEntryPoints(entryPoints, packagePath, absolutePath, childPaths);\n    }\n  }\n}\n\nfunction stripJsExtension<T extends string>(filePath: T): T {\n  return filePath.replace(/\\.js$/, '') as T;\n}\n\nfunction isIgnorablePath(path: PathSegment): boolean {\n  return path.startsWith('.') || path === 'node_modules' || path === NGCC_DIRECTORY;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directory_walker_entry_point_finder.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/entry_point_finder/directory_walker_entry_point_finder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {AbsoluteFsPath, FileSystem, PathSegment} from '../../../src/ngtsc/file_system';\nimport {EntryPointWithDependencies} from '../dependencies/dependency_host';\nimport {DependencyResolver, SortedEntryPointsInfo} from '../dependencies/dependency_resolver';\nimport {Logger} from '../logging/logger';\nimport {NgccConfiguration} from '../packages/configuration';\nimport {getEntryPointInfo, INCOMPATIBLE_ENTRY_POINT, NO_ENTRY_POINT} from '../packages/entry_point';\nimport {EntryPointManifest} from '../packages/entry_point_manifest';\nimport {PathMappings} from '../path_mappings';\nimport {NGCC_DIRECTORY} from '../writing/new_entry_point_file_writer';\n\nimport {EntryPointFinder} from './interface';\nimport {getBasePaths, trackDuration} from './utils';\n\n/**\n * An EntryPointFinder that searches for all entry-points that can be found given a `basePath` and\n * `pathMappings`.\n */\nexport class DirectoryWalkerEntryPointFinder implements EntryPointFinder {\n  private basePaths = getBasePaths(this.logger, this.sourceDirectory, this.pathMappings);\n  constructor(\n      private fs: FileSystem, private config: NgccConfiguration, private logger: Logger,\n      private resolver: DependencyResolver, private entryPointManifest: EntryPointManifest,\n      private sourceDirectory: AbsoluteFsPath, private pathMappings: PathMappings|undefined) {}\n  /**\n   * Search the `sourceDirectory`, and sub-directories, using `pathMappings` as necessary, to find\n   * all package entry-points.\n   */\n  findEntryPoints(): SortedEntryPointsInfo {\n    const unsortedEntryPoints: EntryPointWithDependencies[] = [];\n    for (const basePath of this.basePaths) {\n      const entryPoints = this.entryPointManifest.readEntryPointsUsingManifest(basePath) ||\n          this.walkBasePathForPackages(basePath);\n      entryPoints.forEach(e => unsortedEntryPoints.push(e));\n    }\n    return this.resolver.sortEntryPointsByDependency(unsortedEntryPoints);\n  }\n\n  /**\n   * Search the `basePath` for possible Angular packages and entry-points.\n   *\n   * @param basePath The path at which to start the search\n   * @returns an array of `EntryPoint`s that were found within `basePath`.\n   */\n  walkBasePathForPackages(basePath: AbsoluteFsPath): EntryPointWithDependencies[] {\n    this.logger.debug(\n        `No manifest found for ${basePath} so walking the directories for entry-points.`);\n    const entryPoints = trackDuration(\n        () => this.walkDirectoryForPackages(basePath),\n        duration => this.logger.debug(`Walking ${basePath} for entry-points took ${duration}s.`));\n    this.entryPointManifest.writeEntryPointManifest(basePath, entryPoints);\n    return entryPoints;\n  }\n\n  /**\n   * Look for Angular packages that need to be compiled, starting at the source directory.\n   * The function will recurse into directories that start with `@...`, e.g. `@angular/...`.\n   *\n   * @param sourceDirectory An absolute path to the root directory where searching begins.\n   * @returns an array of `EntryPoint`s that were found within `sourceDirectory`.\n   */\n  walkDirectoryForPackages(sourceDirectory: AbsoluteFsPath): EntryPointWithDependencies[] {\n    // Try to get a primary entry point from this directory\n    const primaryEntryPoint =\n        getEntryPointInfo(this.fs, this.config, this.logger, sourceDirectory, sourceDirectory);\n\n    // If there is an entry-point but it is not compatible with ngcc (it has a bad package.json or\n    // invalid typings) then exit. It is unlikely that such an entry point has a dependency on an\n    // Angular library.\n    if (primaryEntryPoint === INCOMPATIBLE_ENTRY_POINT) {\n      return [];\n    }\n\n    const entryPoints: EntryPointWithDependencies[] = [];\n    if (primaryEntryPoint !== NO_ENTRY_POINT) {\n      entryPoints.push(this.resolver.getEntryPointWithDependencies(primaryEntryPoint));\n      this.collectSecondaryEntryPoints(\n          entryPoints, sourceDirectory, sourceDirectory, this.fs.readdir(sourceDirectory));\n\n      // Also check for any nested node_modules in this package but only if at least one of the\n      // entry-points was compiled by Angular.\n      if (entryPoints.some(e => e.entryPoint.compiledByAngular)) {\n        const nestedNodeModulesPath = this.fs.join(sourceDirectory, 'node_modules');\n        if (this.fs.exists(nestedNodeModulesPath)) {\n          entryPoints.push(...this.walkDirectoryForPackages(nestedNodeModulesPath));\n        }\n      }\n\n      return entryPoints;\n    }\n\n    // The `sourceDirectory` was not a package (i.e. there was no package.json)\n    // So search its sub-directories for Angular packages and entry-points\n    for (const path of this.fs.readdir(sourceDirectory)) {\n      if (isIgnorablePath(path)) {\n        // Ignore hidden files, node_modules and ngcc directory\n        continue;\n      }\n\n      const absolutePath = this.fs.resolve(sourceDirectory, path);\n      const stat = this.fs.lstat(absolutePath);\n      if (stat.isSymbolicLink() || !stat.isDirectory()) {\n        // Ignore symbolic links and non-directories\n        continue;\n      }\n\n      entryPoints.push(...this.walkDirectoryForPackages(this.fs.join(sourceDirectory, path)));\n    }\n\n    return entryPoints;\n  }\n\n  /**\n   * Search the `directory` looking for any secondary entry-points for a package, adding any that\n   * are found to the `entryPoints` array.\n   *\n   * @param entryPoints An array where we will add any entry-points found in this directory\n   * @param packagePath The absolute path to the package that may contain entry-points\n   * @param directory The current directory being searched\n   * @param paths The paths contained in the current `directory`.\n   */\n  private collectSecondaryEntryPoints(\n      entryPoints: EntryPointWithDependencies[], packagePath: AbsoluteFsPath,\n      directory: AbsoluteFsPath, paths: PathSegment[]): void {\n    for (const path of paths) {\n      if (isIgnorablePath(path)) {\n        // Ignore hidden files, node_modules and ngcc directory\n        continue;\n      }\n\n      const absolutePath = this.fs.resolve(directory, path);\n      const stat = this.fs.lstat(absolutePath);\n      if (stat.isSymbolicLink()) {\n        // Ignore symbolic links\n        continue;\n      }\n\n      const isDirectory = stat.isDirectory();\n      if (!path.endsWith('.js') && !isDirectory) {\n        // Ignore files that do not end in `.js`\n        continue;\n      }\n\n      // If the path is a JS file then strip its extension and see if we can match an\n      // entry-point.\n      const possibleEntryPointPath = isDirectory ? absolutePath : stripJsExtension(absolutePath);\n      let isEntryPoint = false;\n      const subEntryPoint =\n          getEntryPointInfo(this.fs, this.config, this.logger, packagePath, possibleEntryPointPath);\n      if (subEntryPoint !== NO_ENTRY_POINT && subEntryPoint !== INCOMPATIBLE_ENTRY_POINT) {\n        entryPoints.push(this.resolver.getEntryPointWithDependencies(subEntryPoint));\n        isEntryPoint = true;\n      }\n\n      if (!isDirectory) {\n        // This path is not a directory so we are done.\n        continue;\n      }\n\n      // This directory may contain entry-points of its own.\n      const childPaths = this.fs.readdir(absolutePath);\n      if (!isEntryPoint &&\n          childPaths.some(\n              childPath => childPath.endsWith('.js') &&\n                  this.fs.stat(this.fs.resolve(absolutePath, childPath)).isFile())) {\n        // We do not consider non-entry-point directories that contain JS files as they are very\n        // unlikely to be containers for sub-entry-points.\n        continue;\n      }\n      this.collectSecondaryEntryPoints(entryPoints, packagePath, absolutePath, childPaths);\n    }\n  }\n}\n\nfunction stripJsExtension<T extends string>(filePath: T): T {\n  return filePath.replace(/\\.js$/, '') as T;\n}\n\nfunction isIgnorablePath(path: PathSegment): boolean {\n  return path.startsWith('.') || path === 'node_modules' || path === NGCC_DIRECTORY;\n}\n"]}