@angular/compiler-cli 8.0.0 → 8.1.0-beta.0

package/ngcc/src/host/umd_host.js

@@ -0,0 +1,250 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/ngcc/src/host/umd_host", ["require", "exports", "tslib", "typescript", "@angular/compiler-cli/ngcc/src/host/esm5_host"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    var ts = require("typescript");
+    var esm5_host_1 = require("@angular/compiler-cli/ngcc/src/host/esm5_host");
+    var UmdReflectionHost = /** @class */ (function (_super) {
+        tslib_1.__extends(UmdReflectionHost, _super);
+        function UmdReflectionHost(logger, isCore, program, compilerHost, dts) {
+            var _this = _super.call(this, logger, isCore, program.getTypeChecker(), dts) || this;
+            _this.program = program;
+            _this.compilerHost = compilerHost;
+            _this.umdModules = new Map();
+            _this.umdExports = new Map();
+            _this.umdImportPaths = new Map();
+            return _this;
+        }
+        UmdReflectionHost.prototype.getImportOfIdentifier = function (id) {
+            var importParameter = this.findUmdImportParameter(id);
+            var from = importParameter && this.getUmdImportPath(importParameter);
+            return from !== null ? { from: from, name: id.text } : null;
+        };
+        UmdReflectionHost.prototype.getDeclarationOfIdentifier = function (id) {
+            return this.getUmdImportedDeclaration(id) || _super.prototype.getDeclarationOfIdentifier.call(this, id);
+        };
+        UmdReflectionHost.prototype.getExportsOfModule = function (module) {
+            return _super.prototype.getExportsOfModule.call(this, module) || this.getUmdExports(module.getSourceFile());
+        };
+        UmdReflectionHost.prototype.getUmdModule = function (sourceFile) {
+            if (sourceFile.isDeclarationFile) {
+                return null;
+            }
+            if (!this.umdModules.has(sourceFile)) {
+                if (sourceFile.statements.length !== 1) {
+                    throw new Error("Expected UMD module file (" + sourceFile.fileName + ") to contain exactly one statement, but found " + sourceFile.statements + ".");
+                }
+                this.umdModules.set(sourceFile, parseStatementForUmdModule(sourceFile.statements[0]));
+            }
+            return this.umdModules.get(sourceFile);
+        };
+        UmdReflectionHost.prototype.getUmdImportPath = function (importParameter) {
+            var e_1, _a;
+            if (this.umdImportPaths.has(importParameter)) {
+                return this.umdImportPaths.get(importParameter);
+            }
+            var umdModule = this.getUmdModule(importParameter.getSourceFile());
+            if (umdModule === null) {
+                return null;
+            }
+            var imports = getImportsOfUmdModule(umdModule);
+            if (imports === null) {
+                return null;
+            }
+            try {
+                for (var imports_1 = tslib_1.__values(imports), imports_1_1 = imports_1.next(); !imports_1_1.done; imports_1_1 = imports_1.next()) {
+                    var i = imports_1_1.value;
+                    this.umdImportPaths.set(i.parameter, i.path);
+                    if (i.parameter === importParameter) {
+                        return i.path;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (imports_1_1 && !imports_1_1.done && (_a = imports_1.return)) _a.call(imports_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return null;
+        };
+        UmdReflectionHost.prototype.getUmdExports = function (sourceFile) {
+            if (!this.umdExports.has(sourceFile)) {
+                var moduleExports = this.computeExportsOfUmdModule(sourceFile);
+                this.umdExports.set(sourceFile, moduleExports);
+            }
+            return this.umdExports.get(sourceFile);
+        };
+        /** Get the top level statements for a module.
+         *
+         * In UMD modules these are the body of the UMD factory function.
+         *
+         * @param sourceFile The module whose statements we want.
+         * @returns An array of top level statements for the given module.
+         */
+        UmdReflectionHost.prototype.getModuleStatements = function (sourceFile) {
+            var umdModule = this.getUmdModule(sourceFile);
+            return umdModule !== null ? Array.from(umdModule.factoryFn.body.statements) : [];
+        };
+        UmdReflectionHost.prototype.computeExportsOfUmdModule = function (sourceFile) {
+            var _this = this;
+            var moduleMap = new Map();
+            var exportStatements = this.getModuleStatements(sourceFile).filter(isUmdExportStatement);
+            var exportDeclarations = exportStatements.map(function (statement) { return _this.extractUmdExportDeclaration(statement); });
+            exportDeclarations.forEach(function (decl) {
+                if (decl) {
+                    moduleMap.set(decl.name, decl.declaration);
+                }
+            });
+            return moduleMap;
+        };
+        UmdReflectionHost.prototype.extractUmdExportDeclaration = function (statement) {
+            var exportExpression = statement.expression.right;
+            var name = statement.expression.left.name.text;
+            var declaration = this.getDeclarationOfExpression(exportExpression);
+            if (declaration === null) {
+                return null;
+            }
+            return { name: name, declaration: declaration };
+        };
+        UmdReflectionHost.prototype.findUmdImportParameter = function (id) {
+            // Is `id` a namespaced property access, e.g. `Directive` in `core.Directive`?
+            // If so capture the symbol of the namespace, e.g. `core`.
+            var nsIdentifier = findNamespaceOfIdentifier(id);
+            var nsSymbol = nsIdentifier && this.checker.getSymbolAtLocation(nsIdentifier) || null;
+            // Is the namespace a parameter on a UMD factory function, e.g. `function factory(this, core)`?
+            // If so then return its declaration.
+            var nsDeclaration = nsSymbol && nsSymbol.valueDeclaration;
+            return nsDeclaration && ts.isParameter(nsDeclaration) ? nsDeclaration : null;
+        };
+        UmdReflectionHost.prototype.getUmdImportedDeclaration = function (id) {
+            var importInfo = this.getImportOfIdentifier(id);
+            if (importInfo === null) {
+                return null;
+            }
+            var importedFile = this.resolveModuleName(importInfo.from, id.getSourceFile());
+            if (importedFile === undefined) {
+                return null;
+            }
+            // We need to add the `viaModule` because  the `getExportsOfModule()` call
+            // did not know that we were importing the declaration.
+            return { node: importedFile, viaModule: importInfo.from };
+        };
+        UmdReflectionHost.prototype.resolveModuleName = function (moduleName, containingFile) {
+            if (this.compilerHost.resolveModuleNames) {
+                var moduleInfo = this.compilerHost.resolveModuleNames([moduleName], containingFile.fileName)[0];
+                return moduleInfo && this.program.getSourceFile(moduleInfo.resolvedFileName);
+            }
+            else {
+                var moduleInfo = ts.resolveModuleName(moduleName, containingFile.fileName, this.program.getCompilerOptions(), this.compilerHost);
+                return moduleInfo.resolvedModule &&
+                    this.program.getSourceFile(moduleInfo.resolvedModule.resolvedFileName);
+            }
+        };
+        return UmdReflectionHost;
+    }(esm5_host_1.Esm5ReflectionHost));
+    exports.UmdReflectionHost = UmdReflectionHost;
+    function parseStatementForUmdModule(statement) {
+        var wrapperCall = getUmdWrapperCall(statement);
+        if (!wrapperCall)
+            return null;
+        var wrapperFn = wrapperCall.expression;
+        if (!ts.isFunctionExpression(wrapperFn))
+            return null;
+        var factoryFnParamIndex = wrapperFn.parameters.findIndex(function (parameter) { return ts.isIdentifier(parameter.name) && parameter.name.text === 'factory'; });
+        if (factoryFnParamIndex === -1)
+            return null;
+        var factoryFn = stripParentheses(wrapperCall.arguments[factoryFnParamIndex]);
+        if (!factoryFn || !ts.isFunctionExpression(factoryFn))
+            return null;
+        return { wrapperFn: wrapperFn, factoryFn: factoryFn };
+    }
+    exports.parseStatementForUmdModule = parseStatementForUmdModule;
+    function getUmdWrapperCall(statement) {
+        if (!ts.isExpressionStatement(statement) || !ts.isParenthesizedExpression(statement.expression) ||
+            !ts.isCallExpression(statement.expression.expression) ||
+            !ts.isFunctionExpression(statement.expression.expression.expression)) {
+            return null;
+        }
+        return statement.expression.expression;
+    }
+    function getImportsOfUmdModule(umdModule) {
+        var imports = [];
+        for (var i = 1; i < umdModule.factoryFn.parameters.length; i++) {
+            imports.push({
+                parameter: umdModule.factoryFn.parameters[i],
+                path: getRequiredModulePath(umdModule.wrapperFn, i)
+            });
+        }
+        return imports;
+    }
+    exports.getImportsOfUmdModule = getImportsOfUmdModule;
+    function isUmdExportStatement(s) {
+        return ts.isExpressionStatement(s) && ts.isBinaryExpression(s.expression) &&
+            ts.isPropertyAccessExpression(s.expression.left) &&
+            ts.isIdentifier(s.expression.left.expression) &&
+            s.expression.left.expression.text === 'exports';
+    }
+    function getRequiredModulePath(wrapperFn, paramIndex) {
+        var statement = wrapperFn.body.statements[0];
+        if (!ts.isExpressionStatement(statement)) {
+            throw new Error('UMD wrapper body is not an expression statement:\n' + wrapperFn.body.getText());
+        }
+        var modulePaths = [];
+        findModulePaths(statement.expression);
+        // Since we were only interested in the `require()` calls, we miss the `exports` argument, so we
+        // need to subtract 1.
+        // E.g. `function(exports, dep1, dep2)` maps to `function(exports, require('path/to/dep1'),
+        // require('path/to/dep2'))`
+        return modulePaths[paramIndex - 1];
+        // Search the statement for calls to `require('...')` and extract the string value of the first
+        // argument
+        function findModulePaths(node) {
+            if (isRequireCall(node)) {
+                var argument = node.arguments[0];
+                if (ts.isStringLiteral(argument)) {
+                    modulePaths.push(argument.text);
+                }
+            }
+            else {
+                node.forEachChild(findModulePaths);
+            }
+        }
+    }
+    function isRequireCall(node) {
+        return ts.isCallExpression(node) && ts.isIdentifier(node.expression) &&
+            node.expression.text === 'require' && node.arguments.length === 1;
+    }
+    /**
+     * If the identifier `id` is the RHS of a property access of the form `namespace.id`
+     * and `namespace` is an identifer then return `namespace`, otherwise `null`.
+     * @param id The identifier whose namespace we want to find.
+     */
+    function findNamespaceOfIdentifier(id) {
+        return id.parent && ts.isPropertyAccessExpression(id.parent) &&
+            ts.isIdentifier(id.parent.expression) ?
+            id.parent.expression :
+            null;
+    }
+    function stripParentheses(node) {
+        return ts.isParenthesizedExpression(node) ? node.expression : node;
+    }
+    exports.stripParentheses = stripParentheses;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"umd_host.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/host/umd_host.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 */\n\nimport * as ts from 'typescript';\n\nimport {Declaration, Import} from '../../../src/ngtsc/reflection';\nimport {Logger} from '../logging/logger';\nimport {BundleProgram} from '../packages/bundle_program';\nimport {Esm5ReflectionHost} from './esm5_host';\n\nexport class UmdReflectionHost extends Esm5ReflectionHost {\n  protected umdModules = new Map<ts.SourceFile, UmdModule|null>();\n  protected umdExports = new Map<ts.SourceFile, Map<string, Declaration>|null>();\n  protected umdImportPaths = new Map<ts.ParameterDeclaration, string|null>();\n  constructor(\n      logger: Logger, isCore: boolean, protected program: ts.Program,\n      protected compilerHost: ts.CompilerHost, dts?: BundleProgram|null) {\n    super(logger, isCore, program.getTypeChecker(), dts);\n  }\n\n  getImportOfIdentifier(id: ts.Identifier): Import|null {\n    const importParameter = this.findUmdImportParameter(id);\n    const from = importParameter && this.getUmdImportPath(importParameter);\n    return from !== null ? {from, name: id.text} : null;\n  }\n\n  getDeclarationOfIdentifier(id: ts.Identifier): Declaration|null {\n    return this.getUmdImportedDeclaration(id) || super.getDeclarationOfIdentifier(id);\n  }\n\n  getExportsOfModule(module: ts.Node): Map<string, Declaration>|null {\n    return super.getExportsOfModule(module) || this.getUmdExports(module.getSourceFile());\n  }\n\n  getUmdModule(sourceFile: ts.SourceFile): UmdModule|null {\n    if (sourceFile.isDeclarationFile) {\n      return null;\n    }\n    if (!this.umdModules.has(sourceFile)) {\n      if (sourceFile.statements.length !== 1) {\n        throw new Error(\n            `Expected UMD module file (${sourceFile.fileName}) to contain exactly one statement, but found ${sourceFile.statements}.`);\n      }\n      this.umdModules.set(sourceFile, parseStatementForUmdModule(sourceFile.statements[0]));\n    }\n    return this.umdModules.get(sourceFile) !;\n  }\n\n  getUmdImportPath(importParameter: ts.ParameterDeclaration): string|null {\n    if (this.umdImportPaths.has(importParameter)) {\n      return this.umdImportPaths.get(importParameter) !;\n    }\n\n    const umdModule = this.getUmdModule(importParameter.getSourceFile());\n    if (umdModule === null) {\n      return null;\n    }\n\n    const imports = getImportsOfUmdModule(umdModule);\n    if (imports === null) {\n      return null;\n    }\n\n    for (const i of imports) {\n      this.umdImportPaths.set(i.parameter, i.path);\n      if (i.parameter === importParameter) {\n        return i.path;\n      }\n    }\n\n    return null;\n  }\n\n  getUmdExports(sourceFile: ts.SourceFile): Map<string, Declaration>|null {\n    if (!this.umdExports.has(sourceFile)) {\n      const moduleExports = this.computeExportsOfUmdModule(sourceFile);\n      this.umdExports.set(sourceFile, moduleExports);\n    }\n    return this.umdExports.get(sourceFile) !;\n  }\n\n  /** Get the top level statements for a module.\n   *\n   * In UMD modules these are the body of the UMD factory function.\n   *\n   * @param sourceFile The module whose statements we want.\n   * @returns An array of top level statements for the given module.\n   */\n  protected getModuleStatements(sourceFile: ts.SourceFile): ts.Statement[] {\n    const umdModule = this.getUmdModule(sourceFile);\n    return umdModule !== null ? Array.from(umdModule.factoryFn.body.statements) : [];\n  }\n\n  private computeExportsOfUmdModule(sourceFile: ts.SourceFile): Map<string, Declaration>|null {\n    const moduleMap = new Map<string, Declaration>();\n    const exportStatements = this.getModuleStatements(sourceFile).filter(isUmdExportStatement);\n    const exportDeclarations =\n        exportStatements.map(statement => this.extractUmdExportDeclaration(statement));\n    exportDeclarations.forEach(decl => {\n      if (decl) {\n        moduleMap.set(decl.name, decl.declaration);\n      }\n    });\n    return moduleMap;\n  }\n\n  private extractUmdExportDeclaration(statement: UmdExportStatement): UmdExportDeclaration|null {\n    const exportExpression = statement.expression.right;\n    const name = statement.expression.left.name.text;\n\n    const declaration = this.getDeclarationOfExpression(exportExpression);\n    if (declaration === null) {\n      return null;\n    }\n\n    return {name, declaration};\n  }\n\n  private findUmdImportParameter(id: ts.Identifier): ts.ParameterDeclaration|null {\n    // Is `id` a namespaced property access, e.g. `Directive` in `core.Directive`?\n    // If so capture the symbol of the namespace, e.g. `core`.\n    const nsIdentifier = findNamespaceOfIdentifier(id);\n    const nsSymbol = nsIdentifier && this.checker.getSymbolAtLocation(nsIdentifier) || null;\n\n    // Is the namespace a parameter on a UMD factory function, e.g. `function factory(this, core)`?\n    // If so then return its declaration.\n    const nsDeclaration = nsSymbol && nsSymbol.valueDeclaration;\n    return nsDeclaration && ts.isParameter(nsDeclaration) ? nsDeclaration : null;\n  }\n\n  private getUmdImportedDeclaration(id: ts.Identifier): Declaration|null {\n    const importInfo = this.getImportOfIdentifier(id);\n    if (importInfo === null) {\n      return null;\n    }\n\n    const importedFile = this.resolveModuleName(importInfo.from, id.getSourceFile());\n    if (importedFile === undefined) {\n      return null;\n    }\n\n    // We need to add the `viaModule` because  the `getExportsOfModule()` call\n    // did not know that we were importing the declaration.\n    return {node: importedFile, viaModule: importInfo.from};\n  }\n\n  private resolveModuleName(moduleName: string, containingFile: ts.SourceFile): ts.SourceFile\n      |undefined {\n    if (this.compilerHost.resolveModuleNames) {\n      const moduleInfo =\n          this.compilerHost.resolveModuleNames([moduleName], containingFile.fileName)[0];\n      return moduleInfo && this.program.getSourceFile(moduleInfo.resolvedFileName);\n    } else {\n      const moduleInfo = ts.resolveModuleName(\n          moduleName, containingFile.fileName, this.program.getCompilerOptions(),\n          this.compilerHost);\n      return moduleInfo.resolvedModule &&\n          this.program.getSourceFile(moduleInfo.resolvedModule.resolvedFileName);\n    }\n  }\n}\n\nexport function parseStatementForUmdModule(statement: ts.Statement): UmdModule|null {\n  const wrapperCall = getUmdWrapperCall(statement);\n  if (!wrapperCall) return null;\n\n  const wrapperFn = wrapperCall.expression;\n  if (!ts.isFunctionExpression(wrapperFn)) return null;\n\n  const factoryFnParamIndex = wrapperFn.parameters.findIndex(\n      parameter => ts.isIdentifier(parameter.name) && parameter.name.text === 'factory');\n  if (factoryFnParamIndex === -1) return null;\n\n  const factoryFn = stripParentheses(wrapperCall.arguments[factoryFnParamIndex]);\n  if (!factoryFn || !ts.isFunctionExpression(factoryFn)) return null;\n\n  return {wrapperFn, factoryFn};\n}\n\nfunction getUmdWrapperCall(statement: ts.Statement): ts.CallExpression&\n    {expression: ts.FunctionExpression}|null {\n  if (!ts.isExpressionStatement(statement) || !ts.isParenthesizedExpression(statement.expression) ||\n      !ts.isCallExpression(statement.expression.expression) ||\n      !ts.isFunctionExpression(statement.expression.expression.expression)) {\n    return null;\n  }\n  return statement.expression.expression as ts.CallExpression & {expression: ts.FunctionExpression};\n}\n\n\nexport function getImportsOfUmdModule(umdModule: UmdModule):\n    {parameter: ts.ParameterDeclaration, path: string}[] {\n  const imports: {parameter: ts.ParameterDeclaration, path: string}[] = [];\n  for (let i = 1; i < umdModule.factoryFn.parameters.length; i++) {\n    imports.push({\n      parameter: umdModule.factoryFn.parameters[i],\n      path: getRequiredModulePath(umdModule.wrapperFn, i)\n    });\n  }\n  return imports;\n}\n\ninterface UmdModule {\n  wrapperFn: ts.FunctionExpression;\n  factoryFn: ts.FunctionExpression;\n}\n\ntype UmdExportStatement = ts.ExpressionStatement & {\n  expression:\n      ts.BinaryExpression & {left: ts.PropertyAccessExpression & {expression: ts.Identifier}}\n};\n\nfunction isUmdExportStatement(s: ts.Statement): s is UmdExportStatement {\n  return ts.isExpressionStatement(s) && ts.isBinaryExpression(s.expression) &&\n      ts.isPropertyAccessExpression(s.expression.left) &&\n      ts.isIdentifier(s.expression.left.expression) &&\n      s.expression.left.expression.text === 'exports';\n}\n\ninterface UmdExportDeclaration {\n  name: string;\n  declaration: Declaration;\n}\n\nfunction getRequiredModulePath(wrapperFn: ts.FunctionExpression, paramIndex: number): string {\n  const statement = wrapperFn.body.statements[0];\n  if (!ts.isExpressionStatement(statement)) {\n    throw new Error(\n        'UMD wrapper body is not an expression statement:\\n' + wrapperFn.body.getText());\n  }\n  const modulePaths: string[] = [];\n  findModulePaths(statement.expression);\n\n  // Since we were only interested in the `require()` calls, we miss the `exports` argument, so we\n  // need to subtract 1.\n  // E.g. `function(exports, dep1, dep2)` maps to `function(exports, require('path/to/dep1'),\n  // require('path/to/dep2'))`\n  return modulePaths[paramIndex - 1];\n\n  // Search the statement for calls to `require('...')` and extract the string value of the first\n  // argument\n  function findModulePaths(node: ts.Node) {\n    if (isRequireCall(node)) {\n      const argument = node.arguments[0];\n      if (ts.isStringLiteral(argument)) {\n        modulePaths.push(argument.text);\n      }\n    } else {\n      node.forEachChild(findModulePaths);\n    }\n  }\n}\n\nfunction isRequireCall(node: ts.Node): node is ts.CallExpression {\n  return ts.isCallExpression(node) && ts.isIdentifier(node.expression) &&\n      node.expression.text === 'require' && node.arguments.length === 1;\n}\n\n/**\n * If the identifier `id` is the RHS of a property access of the form `namespace.id`\n * and `namespace` is an identifer then return `namespace`, otherwise `null`.\n * @param id The identifier whose namespace we want to find.\n */\nfunction findNamespaceOfIdentifier(id: ts.Identifier): ts.Identifier|null {\n  return id.parent && ts.isPropertyAccessExpression(id.parent) &&\n          ts.isIdentifier(id.parent.expression) ?\n      id.parent.expression :\n      null;\n}\n\nexport function stripParentheses(node: ts.Node): ts.Node {\n  return ts.isParenthesizedExpression(node) ? node.expression : node;\n}"]}

package/ngcc/src/main.d.ts

@@ -1,12 +1,6 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
 /// <amd-module name="@angular/compiler-cli/ngcc/src/main" />
 import { Logger } from './logging/logger';
+import { PathMappings } from './utils';
 /**
  * The options to configure the ngcc compiler.
  */
@@ -39,6 +33,11 @@ export interface NgccOptions {
      * Provide a logger that will be called with log messages.
      */
     logger?: Logger;
+    /**
+     * Paths mapping configuration (`paths` and `baseUrl`), as found in `ts.CompilerOptions`.
+     * These are used to resolve paths to locally built Angular libraries.
+     */
+    pathMappings?: PathMappings;
 }
 /**
  * This is the main entry-point into ngcc (aNGular Compatibility Compiler).
@@ -48,4 +47,4 @@ export interface NgccOptions {
  *
  * @param options The options telling ngcc what to compile and how.
  */
-export declare function mainNgcc({ basePath, targetEntryPointPath, propertiesToConsider, compileAllFormats, createNewEntryPointFormats, logger }: NgccOptions): void;
+export declare function mainNgcc({ basePath, targetEntryPointPath, propertiesToConsider, compileAllFormats, createNewEntryPointFormats, logger, pathMappings }: NgccOptions): void;

package/ngcc/src/main.js

@@ -1,36 +1,38 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
 (function (factory) {
     if (typeof module === "object" && typeof module.exports === "object") {
         var v = factory(require, exports);
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/ngcc/src/main", ["require", "exports", "tslib", "canonical-path", "fs", "@angular/compiler-cli/src/ngtsc/path", "@angular/compiler-cli/ngcc/src/logging/console_logger", "@angular/compiler-cli/ngcc/src/packages/build_marker", "@angular/compiler-cli/ngcc/src/packages/dependency_host", "@angular/compiler-cli/ngcc/src/packages/dependency_resolver", "@angular/compiler-cli/ngcc/src/packages/entry_point", "@angular/compiler-cli/ngcc/src/packages/entry_point_bundle", "@angular/compiler-cli/ngcc/src/packages/entry_point_finder", "@angular/compiler-cli/ngcc/src/packages/transformer", "@angular/compiler-cli/ngcc/src/writing/in_place_file_writer", "@angular/compiler-cli/ngcc/src/writing/new_entry_point_file_writer"], factory);
+        define("@angular/compiler-cli/ngcc/src/main", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/path", "@angular/compiler-cli/ngcc/src/dependencies/commonjs_dependency_host", "@angular/compiler-cli/ngcc/src/dependencies/dependency_resolver", "@angular/compiler-cli/ngcc/src/dependencies/esm_dependency_host", "@angular/compiler-cli/ngcc/src/dependencies/module_resolver", "@angular/compiler-cli/ngcc/src/dependencies/umd_dependency_host", "@angular/compiler-cli/ngcc/src/file_system/node_js_file_system", "@angular/compiler-cli/ngcc/src/logging/console_logger", "@angular/compiler-cli/ngcc/src/packages/build_marker", "@angular/compiler-cli/ngcc/src/packages/entry_point", "@angular/compiler-cli/ngcc/src/packages/entry_point_bundle", "@angular/compiler-cli/ngcc/src/packages/entry_point_finder", "@angular/compiler-cli/ngcc/src/packages/transformer", "@angular/compiler-cli/ngcc/src/writing/in_place_file_writer", "@angular/compiler-cli/ngcc/src/writing/new_entry_point_file_writer"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     var tslib_1 = require("tslib");
-    var canonical_path_1 = require("canonical-path");
-    var fs_1 = require("fs");
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
     var path_1 = require("@angular/compiler-cli/src/ngtsc/path");
+    var commonjs_dependency_host_1 = require("@angular/compiler-cli/ngcc/src/dependencies/commonjs_dependency_host");
+    var dependency_resolver_1 = require("@angular/compiler-cli/ngcc/src/dependencies/dependency_resolver");
+    var esm_dependency_host_1 = require("@angular/compiler-cli/ngcc/src/dependencies/esm_dependency_host");
+    var module_resolver_1 = require("@angular/compiler-cli/ngcc/src/dependencies/module_resolver");
+    var umd_dependency_host_1 = require("@angular/compiler-cli/ngcc/src/dependencies/umd_dependency_host");
+    var node_js_file_system_1 = require("@angular/compiler-cli/ngcc/src/file_system/node_js_file_system");
     var console_logger_1 = require("@angular/compiler-cli/ngcc/src/logging/console_logger");
     var build_marker_1 = require("@angular/compiler-cli/ngcc/src/packages/build_marker");
-    var dependency_host_1 = require("@angular/compiler-cli/ngcc/src/packages/dependency_host");
-    var dependency_resolver_1 = require("@angular/compiler-cli/ngcc/src/packages/dependency_resolver");
     var entry_point_1 = require("@angular/compiler-cli/ngcc/src/packages/entry_point");
     var entry_point_bundle_1 = require("@angular/compiler-cli/ngcc/src/packages/entry_point_bundle");
     var entry_point_finder_1 = require("@angular/compiler-cli/ngcc/src/packages/entry_point_finder");
     var transformer_1 = require("@angular/compiler-cli/ngcc/src/packages/transformer");
     var in_place_file_writer_1 = require("@angular/compiler-cli/ngcc/src/writing/in_place_file_writer");
     var new_entry_point_file_writer_1 = require("@angular/compiler-cli/ngcc/src/writing/new_entry_point_file_writer");
-    var SUPPORTED_FORMATS = ['esm5', 'esm2015'];
+    var SUPPORTED_FORMATS = ['esm5', 'esm2015', 'umd', 'commonjs'];
     /**
      * This is the main entry-point into ngcc (aNGular Compatibility Compiler).
      *
@@ -40,34 +42,34 @@
      * @param options The options telling ngcc what to compile and how.
      */
     function mainNgcc(_a) {
-        var basePath = _a.basePath, targetEntryPointPath = _a.targetEntryPointPath, _b = _a.propertiesToConsider, propertiesToConsider = _b === void 0 ? entry_point_1.SUPPORTED_FORMAT_PROPERTIES : _b, _c = _a.compileAllFormats, compileAllFormats = _c === void 0 ? true : _c, _d = _a.createNewEntryPointFormats, createNewEntryPointFormats = _d === void 0 ? false : _d, _e = _a.logger, logger = _e === void 0 ? new console_logger_1.ConsoleLogger(console_logger_1.LogLevel.info) : _e;
-        var transformer = new transformer_1.Transformer(logger, basePath);
-        var host = new dependency_host_1.DependencyHost();
-        var resolver = new dependency_resolver_1.DependencyResolver(logger, host);
-        var finder = new entry_point_finder_1.EntryPointFinder(logger, resolver);
-        var fileWriter = getFileWriter(createNewEntryPointFormats);
-        var absoluteTargetEntryPointPath = targetEntryPointPath ?
-            path_1.AbsoluteFsPath.from(canonical_path_1.resolve(basePath, targetEntryPointPath)) :
-            undefined;
+        var basePath = _a.basePath, targetEntryPointPath = _a.targetEntryPointPath, _b = _a.propertiesToConsider, propertiesToConsider = _b === void 0 ? entry_point_1.SUPPORTED_FORMAT_PROPERTIES : _b, _c = _a.compileAllFormats, compileAllFormats = _c === void 0 ? true : _c, _d = _a.createNewEntryPointFormats, createNewEntryPointFormats = _d === void 0 ? false : _d, _e = _a.logger, logger = _e === void 0 ? new console_logger_1.ConsoleLogger(console_logger_1.LogLevel.info) : _e, pathMappings = _a.pathMappings;
+        var fs = new node_js_file_system_1.NodeJSFileSystem();
+        var transformer = new transformer_1.Transformer(fs, logger);
+        var moduleResolver = new module_resolver_1.ModuleResolver(fs, pathMappings);
+        var esmDependencyHost = new esm_dependency_host_1.EsmDependencyHost(fs, moduleResolver);
+        var umdDependencyHost = new umd_dependency_host_1.UmdDependencyHost(fs, moduleResolver);
+        var commonJsDependencyHost = new commonjs_dependency_host_1.CommonJsDependencyHost(fs, moduleResolver);
+        var resolver = new dependency_resolver_1.DependencyResolver(fs, logger, {
+            esm5: esmDependencyHost,
+            esm2015: esmDependencyHost,
+            umd: umdDependencyHost,
+            commonjs: commonJsDependencyHost
+        });
+        var finder = new entry_point_finder_1.EntryPointFinder(fs, logger, resolver);
+        var fileWriter = getFileWriter(fs, createNewEntryPointFormats);
+        var absoluteTargetEntryPointPath = targetEntryPointPath ? path_1.AbsoluteFsPath.resolve(basePath, targetEntryPointPath) : undefined;
         if (absoluteTargetEntryPointPath &&
-            hasProcessedTargetEntryPoint(absoluteTargetEntryPointPath, propertiesToConsider, compileAllFormats)) {
+            hasProcessedTargetEntryPoint(fs, absoluteTargetEntryPointPath, propertiesToConsider, compileAllFormats)) {
             logger.debug('The target entry-point has already been processed');
             return;
         }
-        var entryPoints = finder.findEntryPoints(path_1.AbsoluteFsPath.from(basePath), absoluteTargetEntryPointPath).entryPoints;
-        if (absoluteTargetEntryPointPath && entryPoints.every(function (entryPoint) {
-            return entryPoint.path !== absoluteTargetEntryPointPath;
-        })) {
-            // If we get here, then the requested entry-point did not contain anything compiled by
-            // the old Angular compiler. Therefore there is nothing for ngcc to do.
-            // So mark all formats in this entry-point as processed so that clients of ngcc can avoid
-            // triggering ngcc for this entry-point in the future.
-            var packageJsonPath_1 = path_1.AbsoluteFsPath.from(canonical_path_1.resolve(absoluteTargetEntryPointPath, 'package.json'));
-            var packageJson_1 = JSON.parse(fs_1.readFileSync(packageJsonPath_1, 'utf8'));
-            propertiesToConsider.forEach(function (formatProperty) {
-                if (packageJson_1[formatProperty])
-                    build_marker_1.markAsProcessed(packageJson_1, packageJsonPath_1, formatProperty);
-            });
+        var _f = finder.findEntryPoints(path_1.AbsoluteFsPath.from(basePath), absoluteTargetEntryPointPath, pathMappings), entryPoints = _f.entryPoints, invalidEntryPoints = _f.invalidEntryPoints;
+        invalidEntryPoints.forEach(function (invalidEntryPoint) {
+            logger.debug("Invalid entry-point " + invalidEntryPoint.entryPoint.path + ".", "It is missing required dependencies:\n" +
+                invalidEntryPoint.missingDependencies.map(function (dep) { return " - " + dep; }).join('\n'));
+        });
+        if (absoluteTargetEntryPointPath && entryPoints.length === 0) {
+            markNonAngularPackageAsProcessed(fs, absoluteTargetEntryPointPath, propertiesToConsider);
             return;
         }
         entryPoints.forEach(function (entryPoint) {
@@ -75,12 +77,12 @@
             var isCore = entryPoint.name === '@angular/core';
             var compiledFormats = new Set();
             var entryPointPackageJson = entryPoint.packageJson;
-            var entryPointPackageJsonPath = path_1.AbsoluteFsPath.from(canonical_path_1.resolve(entryPoint.path, 'package.json'));
+            var entryPointPackageJsonPath = path_1.AbsoluteFsPath.fromUnchecked(entryPoint.path + "/package.json");
             var hasProcessedDts = build_marker_1.hasBeenProcessed(entryPointPackageJson, 'typings');
             for (var i = 0; i < propertiesToConsider.length; i++) {
                 var property = propertiesToConsider[i];
                 var formatPath = entryPointPackageJson[property];
-                var format = entry_point_1.getEntryPointFormat(property);
+                var format = entry_point_1.getEntryPointFormat(fs, entryPoint, property);
                 // No format then this property is not supposed to be compiled.
                 if (!formatPath || !format || SUPPORTED_FORMATS.indexOf(format) === -1)
                     continue;
@@ -94,7 +96,7 @@
                 // We don't break if this if statement fails because we still want to mark
                 // the property as processed even if its underlying format has been built already.
                 if (!compiledFormats.has(formatPath) && (compileAllFormats || isFirstFormat)) {
-                    var bundle = entry_point_bundle_1.makeEntryPointBundle(entryPoint.path, formatPath, entryPoint.typings, isCore, property, format, processDts);
+                    var bundle = entry_point_bundle_1.makeEntryPointBundle(fs, entryPoint.path, formatPath, entryPoint.typings, isCore, property, format, processDts, pathMappings);
                     if (bundle) {
                         logger.info("Compiling " + entryPoint.name + " : " + property + " as " + format);
                         var transformedFiles = transformer.transform(bundle);
@@ -111,9 +113,9 @@
                 // Either this format was just compiled or its underlying format was compiled because of a
                 // previous property.
                 if (compiledFormats.has(formatPath)) {
-                    build_marker_1.markAsProcessed(entryPointPackageJson, entryPointPackageJsonPath, property);
+                    build_marker_1.markAsProcessed(fs, entryPointPackageJson, entryPointPackageJsonPath, property);
                     if (processDts) {
-                        build_marker_1.markAsProcessed(entryPointPackageJson, entryPointPackageJsonPath, 'typings');
+                        build_marker_1.markAsProcessed(fs, entryPointPackageJson, entryPointPackageJsonPath, 'typings');
                     }
                 }
             }
@@ -123,13 +125,13 @@
         });
     }
     exports.mainNgcc = mainNgcc;
-    function getFileWriter(createNewEntryPointFormats) {
-        return createNewEntryPointFormats ? new new_entry_point_file_writer_1.NewEntryPointFileWriter() : new in_place_file_writer_1.InPlaceFileWriter();
+    function getFileWriter(fs, createNewEntryPointFormats) {
+        return createNewEntryPointFormats ? new new_entry_point_file_writer_1.NewEntryPointFileWriter(fs) : new in_place_file_writer_1.InPlaceFileWriter(fs);
     }
-    function hasProcessedTargetEntryPoint(targetPath, propertiesToConsider, compileAllFormats) {
+    function hasProcessedTargetEntryPoint(fs, targetPath, propertiesToConsider, compileAllFormats) {
         var e_1, _a;
-        var packageJsonPath = path_1.AbsoluteFsPath.from(canonical_path_1.resolve(targetPath, 'package.json'));
-        var packageJson = JSON.parse(fs_1.readFileSync(packageJsonPath, 'utf8'));
+        var packageJsonPath = path_1.AbsoluteFsPath.resolve(targetPath, 'package.json');
+        var packageJson = JSON.parse(fs.readFile(packageJsonPath));
         try {
             for (var propertiesToConsider_1 = tslib_1.__values(propertiesToConsider), propertiesToConsider_1_1 = propertiesToConsider_1.next(); !propertiesToConsider_1_1.done; propertiesToConsider_1_1 = propertiesToConsider_1.next()) {
                 var property = propertiesToConsider_1_1.value;
@@ -160,5 +162,19 @@
         // property before the first processed format that was unprocessed.
         return true;
     }
+    /**
+     * If we get here, then the requested entry-point did not contain anything compiled by
+     * the old Angular compiler. Therefore there is nothing for ngcc to do.
+     * So mark all formats in this entry-point as processed so that clients of ngcc can avoid
+     * triggering ngcc for this entry-point in the future.
+     */
+    function markNonAngularPackageAsProcessed(fs, path, propertiesToConsider) {
+        var packageJsonPath = path_1.AbsoluteFsPath.resolve(path, 'package.json');
+        var packageJson = JSON.parse(fs.readFile(packageJsonPath));
+        propertiesToConsider.forEach(function (formatProperty) {
+            if (packageJson[formatProperty])
+                build_marker_1.markAsProcessed(fs, packageJson, packageJsonPath, formatProperty);
+        });
+    }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main.js","sourceRoot":"","sources":["../../../../../../../packages/compiler-cli/ngcc/src/main.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 */\n\nimport {resolve} from 'canonical-path';\nimport {readFileSync} from 'fs';\n\nimport {AbsoluteFsPath} from '../../src/ngtsc/path';\n\nimport {ConsoleLogger, LogLevel} from './logging/console_logger';\nimport {Logger} from './logging/logger';\nimport {hasBeenProcessed, markAsProcessed} from './packages/build_marker';\nimport {DependencyHost} from './packages/dependency_host';\nimport {DependencyResolver} from './packages/dependency_resolver';\nimport {EntryPointFormat, EntryPointJsonProperty, SUPPORTED_FORMAT_PROPERTIES, getEntryPointFormat} from './packages/entry_point';\nimport {makeEntryPointBundle} from './packages/entry_point_bundle';\nimport {EntryPointFinder} from './packages/entry_point_finder';\nimport {Transformer} from './packages/transformer';\nimport {FileWriter} from './writing/file_writer';\nimport {InPlaceFileWriter} from './writing/in_place_file_writer';\nimport {NewEntryPointFileWriter} from './writing/new_entry_point_file_writer';\n\n\n\n/**\n * The options to configure the ngcc compiler.\n */\nexport interface NgccOptions {\n  /** The absolute path to the `node_modules` folder that contains the packages to process. */\n  basePath: string;\n  /**\n   * The path to the primary package to be processed. If not absolute then it must be relative to\n   * `basePath`.\n   *\n   * All its dependencies will need to be processed too.\n   */\n  targetEntryPointPath?: string;\n  /**\n   * Which entry-point properties in the package.json to consider when processing an entry-point.\n   * Each property should hold a path to the particular bundle format for the entry-point.\n   * Defaults to all the properties in the package.json.\n   */\n  propertiesToConsider?: string[];\n  /**\n   * Whether to process all formats specified by (`propertiesToConsider`)  or to stop processing\n   * this entry-point at the first matching format. Defaults to `true`.\n   */\n  compileAllFormats?: boolean;\n  /**\n   * Whether to create new entry-points bundles rather than overwriting the original files.\n   */\n  createNewEntryPointFormats?: boolean;\n  /**\n   * Provide a logger that will be called with log messages.\n   */\n  logger?: Logger;\n}\n\nconst SUPPORTED_FORMATS: EntryPointFormat[] = ['esm5', 'esm2015'];\n\n/**\n * This is the main entry-point into ngcc (aNGular Compatibility Compiler).\n *\n * You can call this function to process one or more npm packages, to ensure\n * that they are compatible with the ivy compiler (ngtsc).\n *\n * @param options The options telling ngcc what to compile and how.\n */\nexport function mainNgcc({basePath, targetEntryPointPath,\n                          propertiesToConsider = SUPPORTED_FORMAT_PROPERTIES,\n                          compileAllFormats = true, createNewEntryPointFormats = false,\n                          logger = new ConsoleLogger(LogLevel.info)}: NgccOptions): void {\n  const transformer = new Transformer(logger, basePath);\n  const host = new DependencyHost();\n  const resolver = new DependencyResolver(logger, host);\n  const finder = new EntryPointFinder(logger, resolver);\n  const fileWriter = getFileWriter(createNewEntryPointFormats);\n\n  const absoluteTargetEntryPointPath = targetEntryPointPath ?\n      AbsoluteFsPath.from(resolve(basePath, targetEntryPointPath)) :\n      undefined;\n\n  if (absoluteTargetEntryPointPath &&\n      hasProcessedTargetEntryPoint(\n          absoluteTargetEntryPointPath, propertiesToConsider, compileAllFormats)) {\n    logger.debug('The target entry-point has already been processed');\n    return;\n  }\n\n  const {entryPoints} =\n      finder.findEntryPoints(AbsoluteFsPath.from(basePath), absoluteTargetEntryPointPath);\n\n  if (absoluteTargetEntryPointPath && entryPoints.every(entryPoint => {\n        return entryPoint.path !== absoluteTargetEntryPointPath;\n      })) {\n    // If we get here, then the requested entry-point did not contain anything compiled by\n    // the old Angular compiler. Therefore there is nothing for ngcc to do.\n    // So mark all formats in this entry-point as processed so that clients of ngcc can avoid\n    // triggering ngcc for this entry-point in the future.\n    const packageJsonPath =\n        AbsoluteFsPath.from(resolve(absoluteTargetEntryPointPath, 'package.json'));\n    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));\n    propertiesToConsider.forEach(formatProperty => {\n      if (packageJson[formatProperty])\n        markAsProcessed(packageJson, packageJsonPath, formatProperty as EntryPointJsonProperty);\n    });\n    return;\n  }\n\n  entryPoints.forEach(entryPoint => {\n    // Are we compiling the Angular core?\n    const isCore = entryPoint.name === '@angular/core';\n\n    const compiledFormats = new Set<string>();\n    const entryPointPackageJson = entryPoint.packageJson;\n    const entryPointPackageJsonPath = AbsoluteFsPath.from(resolve(entryPoint.path, 'package.json'));\n\n    const hasProcessedDts = hasBeenProcessed(entryPointPackageJson, 'typings');\n\n    for (let i = 0; i < propertiesToConsider.length; i++) {\n      const property = propertiesToConsider[i] as EntryPointJsonProperty;\n      const formatPath = entryPointPackageJson[property];\n      const format = getEntryPointFormat(property);\n\n      // No format then this property is not supposed to be compiled.\n      if (!formatPath || !format || SUPPORTED_FORMATS.indexOf(format) === -1) continue;\n\n      if (hasBeenProcessed(entryPointPackageJson, property)) {\n        compiledFormats.add(formatPath);\n        logger.debug(`Skipping ${entryPoint.name} : ${property} (already compiled).`);\n        continue;\n      }\n\n      const isFirstFormat = compiledFormats.size === 0;\n      const processDts = !hasProcessedDts && isFirstFormat;\n\n      // We don't break if this if statement fails because we still want to mark\n      // the property as processed even if its underlying format has been built already.\n      if (!compiledFormats.has(formatPath) && (compileAllFormats || isFirstFormat)) {\n        const bundle = makeEntryPointBundle(\n            entryPoint.path, formatPath, entryPoint.typings, isCore, property, format, processDts);\n        if (bundle) {\n          logger.info(`Compiling ${entryPoint.name} : ${property} as ${format}`);\n          const transformedFiles = transformer.transform(bundle);\n          fileWriter.writeBundle(entryPoint, bundle, transformedFiles);\n          compiledFormats.add(formatPath);\n        } else {\n          logger.warn(\n              `Skipping ${entryPoint.name} : ${format} (no valid entry point file for this format).`);\n        }\n      } else if (!compileAllFormats) {\n        logger.debug(`Skipping ${entryPoint.name} : ${property} (already compiled).`);\n      }\n\n      // Either this format was just compiled or its underlying format was compiled because of a\n      // previous property.\n      if (compiledFormats.has(formatPath)) {\n        markAsProcessed(entryPointPackageJson, entryPointPackageJsonPath, property);\n        if (processDts) {\n          markAsProcessed(entryPointPackageJson, entryPointPackageJsonPath, 'typings');\n        }\n      }\n    }\n\n    if (compiledFormats.size === 0) {\n      throw new Error(\n          `Failed to compile any formats for entry-point at (${entryPoint.path}). Tried ${propertiesToConsider}.`);\n    }\n  });\n}\n\nfunction getFileWriter(createNewEntryPointFormats: boolean): FileWriter {\n  return createNewEntryPointFormats ? new NewEntryPointFileWriter() : new InPlaceFileWriter();\n}\n\nfunction hasProcessedTargetEntryPoint(\n    targetPath: AbsoluteFsPath, propertiesToConsider: string[], compileAllFormats: boolean) {\n  const packageJsonPath = AbsoluteFsPath.from(resolve(targetPath, 'package.json'));\n  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));\n\n  for (const property of propertiesToConsider) {\n    if (packageJson[property]) {\n      // Here is a property that should be processed\n      if (hasBeenProcessed(packageJson, property as EntryPointJsonProperty)) {\n        if (!compileAllFormats) {\n          // It has been processed and we only need one, so we are done.\n          return true;\n        }\n      } else {\n        // It has not been processed but we need all of them, so we are done.\n        return false;\n      }\n    }\n  }\n  // Either all formats need to be compiled and there were none that were unprocessed,\n  // Or only the one matching format needs to be compiled but there was at least one matching\n  // property before the first processed format that was unprocessed.\n  return true;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main.js","sourceRoot":"","sources":["../../../../../../../packages/compiler-cli/ngcc/src/main.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} from '../../src/ngtsc/path';\n\nimport {CommonJsDependencyHost} from './dependencies/commonjs_dependency_host';\nimport {DependencyResolver} from './dependencies/dependency_resolver';\nimport {EsmDependencyHost} from './dependencies/esm_dependency_host';\nimport {ModuleResolver} from './dependencies/module_resolver';\nimport {UmdDependencyHost} from './dependencies/umd_dependency_host';\nimport {FileSystem} from './file_system/file_system';\nimport {NodeJSFileSystem} from './file_system/node_js_file_system';\nimport {ConsoleLogger, LogLevel} from './logging/console_logger';\nimport {Logger} from './logging/logger';\nimport {hasBeenProcessed, markAsProcessed} from './packages/build_marker';\nimport {EntryPointFormat, EntryPointJsonProperty, SUPPORTED_FORMAT_PROPERTIES, getEntryPointFormat} from './packages/entry_point';\nimport {makeEntryPointBundle} from './packages/entry_point_bundle';\nimport {EntryPointFinder} from './packages/entry_point_finder';\nimport {Transformer} from './packages/transformer';\nimport {PathMappings} from './utils';\nimport {FileWriter} from './writing/file_writer';\nimport {InPlaceFileWriter} from './writing/in_place_file_writer';\nimport {NewEntryPointFileWriter} from './writing/new_entry_point_file_writer';\n\n/**\n * The options to configure the ngcc compiler.\n */\nexport interface NgccOptions {\n  /** The absolute path to the `node_modules` folder that contains the packages to process. */\n  basePath: string;\n  /**\n   * The path to the primary package to be processed. If not absolute then it must be relative to\n   * `basePath`.\n   *\n   * All its dependencies will need to be processed too.\n   */\n  targetEntryPointPath?: string;\n  /**\n   * Which entry-point properties in the package.json to consider when processing an entry-point.\n   * Each property should hold a path to the particular bundle format for the entry-point.\n   * Defaults to all the properties in the package.json.\n   */\n  propertiesToConsider?: string[];\n  /**\n   * Whether to process all formats specified by (`propertiesToConsider`)  or to stop processing\n   * this entry-point at the first matching format. Defaults to `true`.\n   */\n  compileAllFormats?: boolean;\n  /**\n   * Whether to create new entry-points bundles rather than overwriting the original files.\n   */\n  createNewEntryPointFormats?: boolean;\n  /**\n   * Provide a logger that will be called with log messages.\n   */\n  logger?: Logger;\n  /**\n   * Paths mapping configuration (`paths` and `baseUrl`), as found in `ts.CompilerOptions`.\n   * These are used to resolve paths to locally built Angular libraries.\n   */\n  pathMappings?: PathMappings;\n}\n\nconst SUPPORTED_FORMATS: EntryPointFormat[] = ['esm5', 'esm2015', 'umd', 'commonjs'];\n\n/**\n * This is the main entry-point into ngcc (aNGular Compatibility Compiler).\n *\n * You can call this function to process one or more npm packages, to ensure\n * that they are compatible with the ivy compiler (ngtsc).\n *\n * @param options The options telling ngcc what to compile and how.\n */\nexport function mainNgcc(\n    {basePath, targetEntryPointPath, propertiesToConsider = SUPPORTED_FORMAT_PROPERTIES,\n     compileAllFormats = true, createNewEntryPointFormats = false,\n     logger = new ConsoleLogger(LogLevel.info), pathMappings}: NgccOptions): void {\n  const fs = new NodeJSFileSystem();\n  const transformer = new Transformer(fs, logger);\n  const moduleResolver = new ModuleResolver(fs, pathMappings);\n  const esmDependencyHost = new EsmDependencyHost(fs, moduleResolver);\n  const umdDependencyHost = new UmdDependencyHost(fs, moduleResolver);\n  const commonJsDependencyHost = new CommonJsDependencyHost(fs, moduleResolver);\n  const resolver = new DependencyResolver(fs, logger, {\n    esm5: esmDependencyHost,\n    esm2015: esmDependencyHost,\n    umd: umdDependencyHost,\n    commonjs: commonJsDependencyHost\n  });\n  const finder = new EntryPointFinder(fs, logger, resolver);\n  const fileWriter = getFileWriter(fs, createNewEntryPointFormats);\n\n  const absoluteTargetEntryPointPath =\n      targetEntryPointPath ? AbsoluteFsPath.resolve(basePath, targetEntryPointPath) : undefined;\n\n  if (absoluteTargetEntryPointPath &&\n      hasProcessedTargetEntryPoint(\n          fs, absoluteTargetEntryPointPath, propertiesToConsider, compileAllFormats)) {\n    logger.debug('The target entry-point has already been processed');\n    return;\n  }\n\n  const {entryPoints, invalidEntryPoints} = finder.findEntryPoints(\n      AbsoluteFsPath.from(basePath), absoluteTargetEntryPointPath, pathMappings);\n\n  invalidEntryPoints.forEach(invalidEntryPoint => {\n    logger.debug(\n        `Invalid entry-point ${invalidEntryPoint.entryPoint.path}.`,\n        `It is missing required dependencies:\\n` +\n            invalidEntryPoint.missingDependencies.map(dep => ` - ${dep}`).join('\\n'));\n  });\n\n  if (absoluteTargetEntryPointPath && entryPoints.length === 0) {\n    markNonAngularPackageAsProcessed(fs, absoluteTargetEntryPointPath, propertiesToConsider);\n    return;\n  }\n\n  entryPoints.forEach(entryPoint => {\n    // Are we compiling the Angular core?\n    const isCore = entryPoint.name === '@angular/core';\n\n    const compiledFormats = new Set<string>();\n    const entryPointPackageJson = entryPoint.packageJson;\n    const entryPointPackageJsonPath =\n        AbsoluteFsPath.fromUnchecked(`${entryPoint.path}/package.json`);\n\n    const hasProcessedDts = hasBeenProcessed(entryPointPackageJson, 'typings');\n\n    for (let i = 0; i < propertiesToConsider.length; i++) {\n      const property = propertiesToConsider[i] as EntryPointJsonProperty;\n      const formatPath = entryPointPackageJson[property];\n      const format = getEntryPointFormat(fs, entryPoint, property);\n\n      // No format then this property is not supposed to be compiled.\n      if (!formatPath || !format || SUPPORTED_FORMATS.indexOf(format) === -1) continue;\n\n      if (hasBeenProcessed(entryPointPackageJson, property)) {\n        compiledFormats.add(formatPath);\n        logger.debug(`Skipping ${entryPoint.name} : ${property} (already compiled).`);\n        continue;\n      }\n\n      const isFirstFormat = compiledFormats.size === 0;\n      const processDts = !hasProcessedDts && isFirstFormat;\n\n      // We don't break if this if statement fails because we still want to mark\n      // the property as processed even if its underlying format has been built already.\n      if (!compiledFormats.has(formatPath) && (compileAllFormats || isFirstFormat)) {\n        const bundle = makeEntryPointBundle(\n            fs, entryPoint.path, formatPath, entryPoint.typings, isCore, property, format,\n            processDts, pathMappings);\n        if (bundle) {\n          logger.info(`Compiling ${entryPoint.name} : ${property} as ${format}`);\n          const transformedFiles = transformer.transform(bundle);\n          fileWriter.writeBundle(entryPoint, bundle, transformedFiles);\n          compiledFormats.add(formatPath);\n        } else {\n          logger.warn(\n              `Skipping ${entryPoint.name} : ${format} (no valid entry point file for this format).`);\n        }\n      } else if (!compileAllFormats) {\n        logger.debug(`Skipping ${entryPoint.name} : ${property} (already compiled).`);\n      }\n\n      // Either this format was just compiled or its underlying format was compiled because of a\n      // previous property.\n      if (compiledFormats.has(formatPath)) {\n        markAsProcessed(fs, entryPointPackageJson, entryPointPackageJsonPath, property);\n        if (processDts) {\n          markAsProcessed(fs, entryPointPackageJson, entryPointPackageJsonPath, 'typings');\n        }\n      }\n    }\n\n    if (compiledFormats.size === 0) {\n      throw new Error(\n          `Failed to compile any formats for entry-point at (${entryPoint.path}). Tried ${propertiesToConsider}.`);\n    }\n  });\n}\n\nfunction getFileWriter(fs: FileSystem, createNewEntryPointFormats: boolean): FileWriter {\n  return createNewEntryPointFormats ? new NewEntryPointFileWriter(fs) : new InPlaceFileWriter(fs);\n}\n\nfunction hasProcessedTargetEntryPoint(\n    fs: FileSystem, targetPath: AbsoluteFsPath, propertiesToConsider: string[],\n    compileAllFormats: boolean) {\n  const packageJsonPath = AbsoluteFsPath.resolve(targetPath, 'package.json');\n  const packageJson = JSON.parse(fs.readFile(packageJsonPath));\n\n  for (const property of propertiesToConsider) {\n    if (packageJson[property]) {\n      // Here is a property that should be processed\n      if (hasBeenProcessed(packageJson, property as EntryPointJsonProperty)) {\n        if (!compileAllFormats) {\n          // It has been processed and we only need one, so we are done.\n          return true;\n        }\n      } else {\n        // It has not been processed but we need all of them, so we are done.\n        return false;\n      }\n    }\n  }\n  // Either all formats need to be compiled and there were none that were unprocessed,\n  // Or only the one matching format needs to be compiled but there was at least one matching\n  // property before the first processed format that was unprocessed.\n  return true;\n}\n\n/**\n * If we get here, then the requested entry-point did not contain anything compiled by\n * the old Angular compiler. Therefore there is nothing for ngcc to do.\n * So mark all formats in this entry-point as processed so that clients of ngcc can avoid\n * triggering ngcc for this entry-point in the future.\n */\nfunction markNonAngularPackageAsProcessed(\n    fs: FileSystem, path: AbsoluteFsPath, propertiesToConsider: string[]) {\n  const packageJsonPath = AbsoluteFsPath.resolve(path, 'package.json');\n  const packageJson = JSON.parse(fs.readFile(packageJsonPath));\n  propertiesToConsider.forEach(formatProperty => {\n    if (packageJson[formatProperty])\n      markAsProcessed(fs, packageJson, packageJsonPath, formatProperty as EntryPointJsonProperty);\n  });\n}\n"]}

package/ngcc/src/packages/build_marker.d.ts

@@ -7,8 +7,9 @@
  */
 /// <amd-module name="@angular/compiler-cli/ngcc/src/packages/build_marker" />
 import { AbsoluteFsPath } from '../../../src/ngtsc/path';
+import { FileSystem } from '../file_system/file_system';
 import { EntryPointJsonProperty, EntryPointPackageJson } from './entry_point';
-export declare const NGCC_VERSION = "8.0.0";
+export declare const NGCC_VERSION = "8.1.0-beta.0";
 /**
  * Check whether ngcc has already processed a given entry-point format.
  *
@@ -29,4 +30,4 @@ export declare function hasBeenProcessed(packageJson: EntryPointPackageJson, for
  * @param entryPoint the entry-point to write a marker.
  * @param format the property in the package.json of the format for which we are writing the marker.
  */
-export declare function markAsProcessed(packageJson: EntryPointPackageJson, packageJsonPath: AbsoluteFsPath, format: EntryPointJsonProperty): void;
+export declare function markAsProcessed(fs: FileSystem, packageJson: EntryPointPackageJson, packageJsonPath: AbsoluteFsPath, format: EntryPointJsonProperty): void;