@angular/compiler-cli 9.1.0 → 9.1.4

package/ngcc/src/migrations/utils.js

@@ -67,7 +67,8 @@
             identifier: null,
             import: { name: 'Directive', from: '@angular/core' },
             node: null,
-            synthesizedFor: clazz.name, args: args,
+            synthesizedFor: clazz.name,
+            args: args,
         };
     }
     exports.createDirectiveDecorator = createDirectiveDecorator;
@@ -132,4 +133,4 @@
         return stmt.declarationList.declarations[0].initializer;
     }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/migrations/utils.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';\nimport {Reference} from '../../../src/ngtsc/imports';\nimport {ClassDeclaration, Decorator, isNamedClassDeclaration, isNamedFunctionDeclaration, isNamedVariableDeclaration} from '../../../src/ngtsc/reflection';\nimport {MigrationHost} from './migration';\n\nexport function isClassDeclaration(clazz: ts.Declaration): clazz is ClassDeclaration {\n  return isNamedClassDeclaration(clazz) || isNamedFunctionDeclaration(clazz) ||\n      isNamedVariableDeclaration(clazz);\n}\n\n/**\n * Returns true if the `clazz` is decorated as a `Directive` or `Component`.\n */\nexport function hasDirectiveDecorator(host: MigrationHost, clazz: ClassDeclaration): boolean {\n  const ref = new Reference(clazz);\n  return host.metadata.getDirectiveMetadata(ref) !== null;\n}\n\n/**\n * Returns true if the `clazz` is decorated as a `Pipe`.\n */\nexport function hasPipeDecorator(host: MigrationHost, clazz: ClassDeclaration): boolean {\n  const ref = new Reference(clazz);\n  return host.metadata.getPipeMetadata(ref) !== null;\n}\n\n/**\n * Returns true if the `clazz` has its own constructor function.\n */\nexport function hasConstructor(host: MigrationHost, clazz: ClassDeclaration): boolean {\n  return host.reflectionHost.getConstructorParameters(clazz) !== null;\n}\n\n/**\n * Create an empty `Directive` decorator that will be associated with the `clazz`.\n */\nexport function createDirectiveDecorator(\n    clazz: ClassDeclaration,\n    metadata?: {selector: string | null, exportAs: string[] | null}): Decorator {\n  const args: ts.Expression[] = [];\n  if (metadata !== undefined) {\n    const metaArgs: ts.PropertyAssignment[] = [];\n    if (metadata.selector !== null) {\n      metaArgs.push(property('selector', metadata.selector));\n    }\n    if (metadata.exportAs !== null) {\n      metaArgs.push(property('exportAs', metadata.exportAs.join(', ')));\n    }\n    args.push(reifySourceFile(ts.createObjectLiteral(metaArgs)));\n  }\n  return {\n    name: 'Directive',\n    identifier: null,\n    import: {name: 'Directive', from: '@angular/core'},\n    node: null,\n    synthesizedFor: clazz.name, args,\n  };\n}\n\n/**\n * Create an empty `Component` decorator that will be associated with the `clazz`.\n */\nexport function createComponentDecorator(\n    clazz: ClassDeclaration,\n    metadata: {selector: string | null, exportAs: string[] | null}): Decorator {\n  const metaArgs: ts.PropertyAssignment[] = [\n    property('template', ''),\n  ];\n  if (metadata.selector !== null) {\n    metaArgs.push(property('selector', metadata.selector));\n  }\n  if (metadata.exportAs !== null) {\n    metaArgs.push(property('exportAs', metadata.exportAs.join(', ')));\n  }\n  return {\n    name: 'Component',\n    identifier: null,\n    import: {name: 'Component', from: '@angular/core'},\n    node: null,\n    synthesizedFor: clazz.name,\n    args: [\n      reifySourceFile(ts.createObjectLiteral(metaArgs)),\n    ],\n  };\n}\n\n/**\n * Create an empty `Injectable` decorator that will be associated with the `clazz`.\n */\nexport function createInjectableDecorator(clazz: ClassDeclaration): Decorator {\n  return {\n    name: 'Injectable',\n    identifier: null,\n    import: {name: 'Injectable', from: '@angular/core'},\n    node: null,\n    synthesizedFor: clazz.name,\n    args: [],\n  };\n}\n\nfunction property(name: string, value: string): ts.PropertyAssignment {\n  return ts.createPropertyAssignment(name, ts.createStringLiteral(value));\n}\n\nconst EMPTY_SF = ts.createSourceFile('(empty)', '', ts.ScriptTarget.Latest);\n\n/**\n * Takes a `ts.Expression` and returns the same `ts.Expression`, but with an associated\n * `ts.SourceFile`.\n *\n * This transformation is necessary to use synthetic `ts.Expression`s with the `PartialEvaluator`,\n * and many decorator arguments are interpreted in this way.\n */\nfunction reifySourceFile(expr: ts.Expression): ts.Expression {\n  const printer = ts.createPrinter();\n  const exprText = printer.printNode(ts.EmitHint.Unspecified, expr, EMPTY_SF);\n  const sf = ts.createSourceFile(\n      '(synthetic)', `const expr = ${exprText};`, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);\n  const stmt = sf.statements[0];\n  if (!ts.isVariableStatement(stmt)) {\n    throw new Error(`Expected VariableStatement, got ${ts.SyntaxKind[stmt.kind]}`);\n  }\n  return stmt.declarationList.declarations[0].initializer !;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/migrations/utils.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';\nimport {Reference} from '../../../src/ngtsc/imports';\nimport {ClassDeclaration, Decorator, isNamedClassDeclaration, isNamedFunctionDeclaration, isNamedVariableDeclaration} from '../../../src/ngtsc/reflection';\nimport {MigrationHost} from './migration';\n\nexport function isClassDeclaration(clazz: ts.Declaration): clazz is ClassDeclaration {\n  return isNamedClassDeclaration(clazz) || isNamedFunctionDeclaration(clazz) ||\n      isNamedVariableDeclaration(clazz);\n}\n\n/**\n * Returns true if the `clazz` is decorated as a `Directive` or `Component`.\n */\nexport function hasDirectiveDecorator(host: MigrationHost, clazz: ClassDeclaration): boolean {\n  const ref = new Reference(clazz);\n  return host.metadata.getDirectiveMetadata(ref) !== null;\n}\n\n/**\n * Returns true if the `clazz` is decorated as a `Pipe`.\n */\nexport function hasPipeDecorator(host: MigrationHost, clazz: ClassDeclaration): boolean {\n  const ref = new Reference(clazz);\n  return host.metadata.getPipeMetadata(ref) !== null;\n}\n\n/**\n * Returns true if the `clazz` has its own constructor function.\n */\nexport function hasConstructor(host: MigrationHost, clazz: ClassDeclaration): boolean {\n  return host.reflectionHost.getConstructorParameters(clazz) !== null;\n}\n\n/**\n * Create an empty `Directive` decorator that will be associated with the `clazz`.\n */\nexport function createDirectiveDecorator(\n    clazz: ClassDeclaration,\n    metadata?: {selector: string|null, exportAs: string[]|null}): Decorator {\n  const args: ts.Expression[] = [];\n  if (metadata !== undefined) {\n    const metaArgs: ts.PropertyAssignment[] = [];\n    if (metadata.selector !== null) {\n      metaArgs.push(property('selector', metadata.selector));\n    }\n    if (metadata.exportAs !== null) {\n      metaArgs.push(property('exportAs', metadata.exportAs.join(', ')));\n    }\n    args.push(reifySourceFile(ts.createObjectLiteral(metaArgs)));\n  }\n  return {\n    name: 'Directive',\n    identifier: null,\n    import: {name: 'Directive', from: '@angular/core'},\n    node: null,\n    synthesizedFor: clazz.name,\n    args,\n  };\n}\n\n/**\n * Create an empty `Component` decorator that will be associated with the `clazz`.\n */\nexport function createComponentDecorator(\n    clazz: ClassDeclaration,\n    metadata: {selector: string|null, exportAs: string[]|null}): Decorator {\n  const metaArgs: ts.PropertyAssignment[] = [\n    property('template', ''),\n  ];\n  if (metadata.selector !== null) {\n    metaArgs.push(property('selector', metadata.selector));\n  }\n  if (metadata.exportAs !== null) {\n    metaArgs.push(property('exportAs', metadata.exportAs.join(', ')));\n  }\n  return {\n    name: 'Component',\n    identifier: null,\n    import: {name: 'Component', from: '@angular/core'},\n    node: null,\n    synthesizedFor: clazz.name,\n    args: [\n      reifySourceFile(ts.createObjectLiteral(metaArgs)),\n    ],\n  };\n}\n\n/**\n * Create an empty `Injectable` decorator that will be associated with the `clazz`.\n */\nexport function createInjectableDecorator(clazz: ClassDeclaration): Decorator {\n  return {\n    name: 'Injectable',\n    identifier: null,\n    import: {name: 'Injectable', from: '@angular/core'},\n    node: null,\n    synthesizedFor: clazz.name,\n    args: [],\n  };\n}\n\nfunction property(name: string, value: string): ts.PropertyAssignment {\n  return ts.createPropertyAssignment(name, ts.createStringLiteral(value));\n}\n\nconst EMPTY_SF = ts.createSourceFile('(empty)', '', ts.ScriptTarget.Latest);\n\n/**\n * Takes a `ts.Expression` and returns the same `ts.Expression`, but with an associated\n * `ts.SourceFile`.\n *\n * This transformation is necessary to use synthetic `ts.Expression`s with the `PartialEvaluator`,\n * and many decorator arguments are interpreted in this way.\n */\nfunction reifySourceFile(expr: ts.Expression): ts.Expression {\n  const printer = ts.createPrinter();\n  const exprText = printer.printNode(ts.EmitHint.Unspecified, expr, EMPTY_SF);\n  const sf = ts.createSourceFile(\n      '(synthetic)', `const expr = ${exprText};`, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);\n  const stmt = sf.statements[0];\n  if (!ts.isVariableStatement(stmt)) {\n    throw new Error(`Expected VariableStatement, got ${ts.SyntaxKind[stmt.kind]}`);\n  }\n  return stmt.declarationList.declarations[0].initializer!;\n}\n"]}

package/ngcc/src/ngcc_options.d.ts

@@ -0,0 +1,142 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/ngcc_options" />
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { AbsoluteFsPath, FileSystem } from '../../src/ngtsc/file_system';
+import { ParsedConfiguration } from '../../src/perform_compile';
+import { Logger } from './logging/logger';
+/**
+ * The options to configure the ngcc compiler for synchronous execution.
+ */
+export interface SyncNgccOptions {
+    /** The absolute path to the `node_modules` folder that contains the packages to process. */
+    basePath: string;
+    /**
+     * The path to the primary package to be processed. If not absolute then it must be relative to
+     * `basePath`.
+     *
+     * All its dependencies will need to be processed too.
+     *
+     * If this property is provided then `errorOnFailedEntryPoint` is forced to true.
+     */
+    targetEntryPointPath?: string;
+    /**
+     * Which entry-point properties in the package.json to consider when processing an entry-point.
+     * Each property should hold a path to the particular bundle format for the entry-point.
+     * Defaults to all the properties in the package.json.
+     */
+    propertiesToConsider?: string[];
+    /**
+     * Whether to process all formats specified by (`propertiesToConsider`)  or to stop processing
+     * this entry-point at the first matching format. Defaults to `true`.
+     */
+    compileAllFormats?: boolean;
+    /**
+     * Whether to create new entry-points bundles rather than overwriting the original files.
+     */
+    createNewEntryPointFormats?: boolean;
+    /**
+     * 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.
+     *
+     * Note that `pathMappings` specified here take precedence over any `pathMappings` loaded from a
+     * TS config file.
+     */
+    pathMappings?: PathMappings;
+    /**
+     * Provide a file-system service that will be used by ngcc for all file interactions.
+     */
+    fileSystem?: FileSystem;
+    /**
+     * Whether the compilation should run and return asynchronously. Allowing asynchronous execution
+     * may speed up the compilation by utilizing multiple CPU cores (if available).
+     *
+     * Default: `false` (i.e. run synchronously)
+     */
+    async?: false;
+    /**
+     * Set to true in order to terminate immediately with an error code if an entry-point fails to be
+     * processed.
+     *
+     * If `targetEntryPointPath` is provided then this property is always true and cannot be
+     * changed. Otherwise the default is false.
+     *
+     * When set to false, ngcc will continue to process entry-points after a failure. In which case it
+     * will log an error and resume processing other entry-points.
+     */
+    errorOnFailedEntryPoint?: boolean;
+    /**
+     * Render `$localize` messages with legacy format ids.
+     *
+     * The default value is `true`. Only set this to `false` if you do not want legacy message ids to
+     * be rendered. For example, if you are not using legacy message ids in your translation files
+     * AND are not doing compile-time inlining of translations, in which case the extra message ids
+     * would add unwanted size to the final source bundle.
+     *
+     * It is safe to leave this set to true if you are doing compile-time inlining because the extra
+     * legacy message ids will all be stripped during translation.
+     */
+    enableI18nLegacyMessageIdFormat?: boolean;
+    /**
+     * Whether to invalidate any entry-point manifest file that is on disk. Instead, walk the
+     * directory tree looking for entry-points, and then write a new entry-point manifest, if
+     * possible.
+     *
+     * Default: `false` (i.e. the manifest will be used if available)
+     */
+    invalidateEntryPointManifest?: boolean;
+    /**
+     * An absolute path to a TS config file (e.g. `tsconfig.json`) or a directory containing one, that
+     * will be used to configure module resolution with things like path mappings, if not specified
+     * explicitly via the `pathMappings` property to `mainNgcc`.
+     *
+     * If `undefined`, ngcc will attempt to load a `tsconfig.json` file from the directory above the
+     * `basePath`.
+     *
+     * If `null`, ngcc will not attempt to load any TS config file at all.
+     */
+    tsConfigPath?: string | null;
+}
+/**
+ * The options to configure the ngcc compiler for asynchronous execution.
+ */
+export declare type AsyncNgccOptions = Omit<SyncNgccOptions, 'async'> & {
+    async: true;
+};
+/**
+ * The options to configure the ngcc compiler.
+ */
+export declare type NgccOptions = AsyncNgccOptions | SyncNgccOptions;
+export declare type PathMappings = {
+    baseUrl: string;
+    paths: {
+        [key: string]: string[];
+    };
+};
+/**
+ * If `pathMappings` is not provided directly, then try getting it from `tsConfig`, if available.
+ */
+export declare function getPathMappingsFromTsConfig(tsConfig: ParsedConfiguration | null, projectPath: AbsoluteFsPath): PathMappings | undefined;
+export declare type OptionalNgccOptionKeys = 'targetEntryPointPath' | 'tsConfigPath' | 'pathMappings';
+export declare type RequiredNgccOptions = Required<Omit<NgccOptions, OptionalNgccOptionKeys>>;
+export declare type OptionalNgccOptions = Pick<NgccOptions, OptionalNgccOptionKeys>;
+export declare type SharedSetup = {
+    fileSystem: FileSystem;
+    absBasePath: AbsoluteFsPath;
+    projectPath: AbsoluteFsPath;
+    tsConfig: ParsedConfiguration | null;
+};
+/**
+ * Instantiate common utilities that are always used and fix up options with defaults, as necessary.
+ *
+ * NOTE: Avoid eagerly instantiating anything that might not be used when running sync/async.
+ */
+export declare function getSharedSetup(options: NgccOptions): SharedSetup & RequiredNgccOptions & OptionalNgccOptions;

package/ngcc/src/ngcc_options.js

@@ -0,0 +1,74 @@
+(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/ngcc_options", ["require", "exports", "@angular/compiler-cli/src/ngtsc/file_system", "@angular/compiler-cli/src/perform_compile", "@angular/compiler-cli/ngcc/src/logging/console_logger", "@angular/compiler-cli/ngcc/src/logging/logger", "@angular/compiler-cli/ngcc/src/packages/entry_point"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    var file_system_1 = require("@angular/compiler-cli/src/ngtsc/file_system");
+    var perform_compile_1 = require("@angular/compiler-cli/src/perform_compile");
+    var console_logger_1 = require("@angular/compiler-cli/ngcc/src/logging/console_logger");
+    var logger_1 = require("@angular/compiler-cli/ngcc/src/logging/logger");
+    var entry_point_1 = require("@angular/compiler-cli/ngcc/src/packages/entry_point");
+    /**
+     * If `pathMappings` is not provided directly, then try getting it from `tsConfig`, if available.
+     */
+    function getPathMappingsFromTsConfig(tsConfig, projectPath) {
+        if (tsConfig !== null && tsConfig.options.baseUrl !== undefined &&
+            tsConfig.options.paths !== undefined) {
+            return {
+                baseUrl: file_system_1.resolve(projectPath, tsConfig.options.baseUrl),
+                paths: tsConfig.options.paths,
+            };
+        }
+    }
+    exports.getPathMappingsFromTsConfig = getPathMappingsFromTsConfig;
+    /**
+     * Instantiate common utilities that are always used and fix up options with defaults, as necessary.
+     *
+     * NOTE: Avoid eagerly instantiating anything that might not be used when running sync/async.
+     */
+    function getSharedSetup(options) {
+        var fileSystem = file_system_1.getFileSystem();
+        var absBasePath = file_system_1.absoluteFrom(options.basePath);
+        var projectPath = fileSystem.dirname(absBasePath);
+        var tsConfig = options.tsConfigPath !== null ? perform_compile_1.readConfiguration(options.tsConfigPath || projectPath) : null;
+        var basePath = options.basePath, targetEntryPointPath = options.targetEntryPointPath, _a = options.propertiesToConsider, propertiesToConsider = _a === void 0 ? entry_point_1.SUPPORTED_FORMAT_PROPERTIES : _a, _b = options.compileAllFormats, compileAllFormats = _b === void 0 ? true : _b, _c = options.createNewEntryPointFormats, createNewEntryPointFormats = _c === void 0 ? false : _c, _d = options.logger, logger = _d === void 0 ? new console_logger_1.ConsoleLogger(logger_1.LogLevel.info) : _d, pathMappings = options.pathMappings, _e = options.async, async = _e === void 0 ? false : _e, _f = options.errorOnFailedEntryPoint, errorOnFailedEntryPoint = _f === void 0 ? false : _f, _g = options.enableI18nLegacyMessageIdFormat, enableI18nLegacyMessageIdFormat = _g === void 0 ? true : _g, _h = options.invalidateEntryPointManifest, invalidateEntryPointManifest = _h === void 0 ? false : _h, tsConfigPath = options.tsConfigPath;
+        pathMappings = options.pathMappings || getPathMappingsFromTsConfig(tsConfig, projectPath);
+        if (!!options.targetEntryPointPath) {
+            // targetEntryPointPath forces us to error if an entry-point fails.
+            errorOnFailedEntryPoint = true;
+        }
+        return {
+            basePath: basePath,
+            targetEntryPointPath: targetEntryPointPath,
+            propertiesToConsider: propertiesToConsider,
+            compileAllFormats: compileAllFormats,
+            createNewEntryPointFormats: createNewEntryPointFormats,
+            logger: logger,
+            pathMappings: pathMappings,
+            async: async,
+            errorOnFailedEntryPoint: errorOnFailedEntryPoint,
+            enableI18nLegacyMessageIdFormat: enableI18nLegacyMessageIdFormat,
+            invalidateEntryPointManifest: invalidateEntryPointManifest,
+            tsConfigPath: tsConfigPath,
+            fileSystem: fileSystem,
+            absBasePath: absBasePath,
+            projectPath: projectPath,
+            tsConfig: tsConfig,
+        };
+    }
+    exports.getSharedSetup = getSharedSetup;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngcc_options.js","sourceRoot":"","sources":["../../../../../../../packages/compiler-cli/ngcc/src/ngcc_options.ts"],"names":[],"mappings":";;;;;;;;;;;IAAA;;;;;;OAMG;IACH,2EAA6G;IAC7G,6EAAiF;IAEjF,wFAAuD;IACvD,wEAAkD;IAClD,mFAAmE;IA8HnE;;OAEG;IACH,SAAgB,2BAA2B,CACvC,QAAkC,EAAE,WAA2B;QACjE,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,CAAC,OAAO,CAAC,OAAO,KAAK,SAAS;YAC3D,QAAQ,CAAC,OAAO,CAAC,KAAK,KAAK,SAAS,EAAE;YACxC,OAAO;gBACL,OAAO,EAAE,qBAAO,CAAC,WAAW,EAAE,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC;gBACvD,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,KAAK;aAC9B,CAAC;SACH;IACH,CAAC;IATD,kEASC;IAUD;;;;OAIG;IACH,SAAgB,cAAc,CAAC,OAAoB;QAEjD,IAAM,UAAU,GAAG,2BAAa,EAAE,CAAC;QACnC,IAAM,WAAW,GAAG,0BAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACnD,IAAM,WAAW,GAAG,UAAU,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QACpD,IAAM,QAAQ,GACV,OAAO,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,mCAAiB,CAAC,OAAO,CAAC,YAAY,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAGhG,IAAA,2BAAQ,EACR,mDAAoB,EACpB,iCAAkD,EAAlD,qFAAkD,EAClD,8BAAwB,EAAxB,6CAAwB,EACxB,uCAAkC,EAAlC,uDAAkC,EAClC,mBAAyC,EAAzC,wFAAyC,EACzC,mCAAY,EACZ,kBAAa,EAAb,kCAAa,EACb,oCAA+B,EAA/B,oDAA+B,EAC/B,4CAAsC,EAAtC,2DAAsC,EACtC,yCAAoC,EAApC,yDAAoC,EACpC,mCAAY,CACF;QAEZ,YAAY,GAAG,OAAO,CAAC,YAAY,IAAI,2BAA2B,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAE1F,IAAI,CAAC,CAAC,OAAO,CAAC,oBAAoB,EAAE;YAClC,mEAAmE;YACnE,uBAAuB,GAAG,IAAI,CAAC;SAChC;QAED,OAAO;YACL,QAAQ,UAAA;YACR,oBAAoB,sBAAA;YACpB,oBAAoB,sBAAA;YACpB,iBAAiB,mBAAA;YACjB,0BAA0B,4BAAA;YAC1B,MAAM,QAAA;YACN,YAAY,cAAA;YACZ,KAAK,OAAA;YACL,uBAAuB,yBAAA;YACvB,+BAA+B,iCAAA;YAC/B,4BAA4B,8BAAA;YAC5B,YAAY,cAAA;YACZ,UAAU,YAAA;YACV,WAAW,aAAA;YACX,WAAW,aAAA;YACX,QAAQ,UAAA;SACT,CAAC;IACJ,CAAC;IAhDD,wCAgDC","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, FileSystem, getFileSystem, resolve} from '../../src/ngtsc/file_system';\nimport {ParsedConfiguration, readConfiguration} from '../../src/perform_compile';\n\nimport {ConsoleLogger} from './logging/console_logger';\nimport {Logger, LogLevel} from './logging/logger';\nimport {SUPPORTED_FORMAT_PROPERTIES} from './packages/entry_point';\n\n/**\n * The options to configure the ngcc compiler for synchronous execution.\n */\nexport interface SyncNgccOptions {\n  /** The absolute path to the `node_modules` folder that contains the packages to process. */\n  basePath: string;\n\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   * If this property is provided then `errorOnFailedEntryPoint` is forced to true.\n   */\n  targetEntryPointPath?: string;\n\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  /**\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  /**\n   * Whether to create new entry-points bundles rather than overwriting the original files.\n   */\n  createNewEntryPointFormats?: boolean;\n\n  /**\n   * Provide a logger that will be called with log messages.\n   */\n  logger?: Logger;\n\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   * Note that `pathMappings` specified here take precedence over any `pathMappings` loaded from a\n   * TS config file.\n   */\n  pathMappings?: PathMappings;\n\n  /**\n   * Provide a file-system service that will be used by ngcc for all file interactions.\n   */\n  fileSystem?: FileSystem;\n\n  /**\n   * Whether the compilation should run and return asynchronously. Allowing asynchronous execution\n   * may speed up the compilation by utilizing multiple CPU cores (if available).\n   *\n   * Default: `false` (i.e. run synchronously)\n   */\n  async?: false;\n\n  /**\n   * Set to true in order to terminate immediately with an error code if an entry-point fails to be\n   * processed.\n   *\n   * If `targetEntryPointPath` is provided then this property is always true and cannot be\n   * changed. Otherwise the default is false.\n   *\n   * When set to false, ngcc will continue to process entry-points after a failure. In which case it\n   * will log an error and resume processing other entry-points.\n   */\n  errorOnFailedEntryPoint?: boolean;\n\n  /**\n   * Render `$localize` messages with legacy format ids.\n   *\n   * The default value is `true`. Only set this to `false` if you do not want legacy message ids to\n   * be rendered. For example, if you are not using legacy message ids in your translation files\n   * AND are not doing compile-time inlining of translations, in which case the extra message ids\n   * would add unwanted size to the final source bundle.\n   *\n   * It is safe to leave this set to true if you are doing compile-time inlining because the extra\n   * legacy message ids will all be stripped during translation.\n   */\n  enableI18nLegacyMessageIdFormat?: boolean;\n\n  /**\n   * Whether to invalidate any entry-point manifest file that is on disk. Instead, walk the\n   * directory tree looking for entry-points, and then write a new entry-point manifest, if\n   * possible.\n   *\n   * Default: `false` (i.e. the manifest will be used if available)\n   */\n  invalidateEntryPointManifest?: boolean;\n\n  /**\n   * An absolute path to a TS config file (e.g. `tsconfig.json`) or a directory containing one, that\n   * will be used to configure module resolution with things like path mappings, if not specified\n   * explicitly via the `pathMappings` property to `mainNgcc`.\n   *\n   * If `undefined`, ngcc will attempt to load a `tsconfig.json` file from the directory above the\n   * `basePath`.\n   *\n   * If `null`, ngcc will not attempt to load any TS config file at all.\n   */\n  tsConfigPath?: string|null;\n}\n\n/**\n * The options to configure the ngcc compiler for asynchronous execution.\n */\nexport type AsyncNgccOptions = Omit<SyncNgccOptions, 'async'>&{async: true};\n\n/**\n * The options to configure the ngcc compiler.\n */\nexport type NgccOptions = AsyncNgccOptions|SyncNgccOptions;\n\nexport type PathMappings = {\n  baseUrl: string,\n  paths: {[key: string]: string[]}\n};\n\n/**\n * If `pathMappings` is not provided directly, then try getting it from `tsConfig`, if available.\n */\nexport function getPathMappingsFromTsConfig(\n    tsConfig: ParsedConfiguration|null, projectPath: AbsoluteFsPath): PathMappings|undefined {\n  if (tsConfig !== null && tsConfig.options.baseUrl !== undefined &&\n      tsConfig.options.paths !== undefined) {\n    return {\n      baseUrl: resolve(projectPath, tsConfig.options.baseUrl),\n      paths: tsConfig.options.paths,\n    };\n  }\n}\n\nexport type OptionalNgccOptionKeys = 'targetEntryPointPath'|'tsConfigPath'|'pathMappings';\nexport type RequiredNgccOptions = Required<Omit<NgccOptions, OptionalNgccOptionKeys>>;\nexport type OptionalNgccOptions = Pick<NgccOptions, OptionalNgccOptionKeys>;\nexport type SharedSetup = {\n  fileSystem: FileSystem; absBasePath: AbsoluteFsPath; projectPath: AbsoluteFsPath;\n  tsConfig: ParsedConfiguration | null;\n};\n\n/**\n * Instantiate common utilities that are always used and fix up options with defaults, as necessary.\n *\n * NOTE: Avoid eagerly instantiating anything that might not be used when running sync/async.\n */\nexport function getSharedSetup(options: NgccOptions): SharedSetup&RequiredNgccOptions&\n    OptionalNgccOptions {\n  const fileSystem = getFileSystem();\n  const absBasePath = absoluteFrom(options.basePath);\n  const projectPath = fileSystem.dirname(absBasePath);\n  const tsConfig =\n      options.tsConfigPath !== null ? readConfiguration(options.tsConfigPath || projectPath) : null;\n\n  let {\n    basePath,\n    targetEntryPointPath,\n    propertiesToConsider = SUPPORTED_FORMAT_PROPERTIES,\n    compileAllFormats = true,\n    createNewEntryPointFormats = false,\n    logger = new ConsoleLogger(LogLevel.info),\n    pathMappings,\n    async = false,\n    errorOnFailedEntryPoint = false,\n    enableI18nLegacyMessageIdFormat = true,\n    invalidateEntryPointManifest = false,\n    tsConfigPath,\n  } = options;\n\n  pathMappings = options.pathMappings || getPathMappingsFromTsConfig(tsConfig, projectPath);\n\n  if (!!options.targetEntryPointPath) {\n    // targetEntryPointPath forces us to error if an entry-point fails.\n    errorOnFailedEntryPoint = true;\n  }\n\n  return {\n    basePath,\n    targetEntryPointPath,\n    propertiesToConsider,\n    compileAllFormats,\n    createNewEntryPointFormats,\n    logger,\n    pathMappings,\n    async,\n    errorOnFailedEntryPoint,\n    enableI18nLegacyMessageIdFormat,\n    invalidateEntryPointManifest,\n    tsConfigPath,\n    fileSystem,\n    absBasePath,\n    projectPath,\n    tsConfig,\n  };\n}\n"]}

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

@@ -9,7 +9,7 @@
 import { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
 import { PackageJsonUpdater } from '../writing/package_json_updater';
 import { EntryPointPackageJson, PackageJsonFormatProperties } from './entry_point';
-export declare const NGCC_VERSION = "9.1.0";
+export declare const NGCC_VERSION = "9.1.4";
 /**
  * Returns true if there is a format in this entry-point that was compiled with an outdated version
  * of ngcc.

package/ngcc/src/packages/build_marker.js

@@ -11,7 +11,7 @@
     Object.defineProperty(exports, "__esModule", { value: true });
     var tslib_1 = require("tslib");
     var new_entry_point_file_writer_1 = require("@angular/compiler-cli/ngcc/src/writing/new_entry_point_file_writer");
-    exports.NGCC_VERSION = '9.1.0';
+    exports.NGCC_VERSION = '9.1.4';
     /**
      * Returns true if there is a format in this entry-point that was compiled with an outdated version
      * of ngcc.

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

@@ -9,13 +9,13 @@
 import * as ts from 'typescript';
 import { AbsoluteFsPath, FileSystem } from '../../../src/ngtsc/file_system';
 /**
-* An entry point bundle contains one or two programs, e.g. `src` and `dts`,
-* that are compiled via TypeScript.
-*
-* To aid with processing the program, this interface exposes the program itself,
-* as well as path and TS file of the entry-point to the program and the r3Symbols
-* file, if appropriate.
-*/
+ * An entry point bundle contains one or two programs, e.g. `src` and `dts`,
+ * that are compiled via TypeScript.
+ *
+ * To aid with processing the program, this interface exposes the program itself,
+ * as well as path and TS file of the entry-point to the program and the r3Symbols
+ * file, if appropriate.
+ */
 export interface BundleProgram {
     program: ts.Program;
     options: ts.CompilerOptions;

package/ngcc/src/packages/bundle_program.js

@@ -77,4 +77,4 @@
     }
     exports.findR3SymbolsPath = findR3SymbolsPath;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/packages/configuration.js

@@ -168,10 +168,8 @@
             var configFilePath = file_system_1.join(packagePath, NGCC_CONFIG_FILENAME);
             if (this.fs.exists(configFilePath)) {
                 try {
-                    return {
-                        versionRange: version || '*',
-                        entryPoints: this.processEntryPoints(packagePath, this.evalSrcFile(configFilePath)),
-                    };
+                    var packageConfig = this.evalSrcFile(configFilePath);
+                    return tslib_1.__assign(tslib_1.__assign({}, packageConfig), { versionRange: version || '*', entryPoints: this.processEntryPoints(packagePath, packageConfig) });
                 }
                 catch (e) {
                     throw new Error("Invalid package configuration file at \"" + configFilePath + "\": " + e.message);
@@ -186,7 +184,8 @@
             var theExports = {};
             var sandbox = {
                 module: { exports: theExports },
-                exports: theExports, require: require,
+                exports: theExports,
+                require: require,
                 __dirname: file_system_1.dirname(srcPath),
                 __filename: srcPath
             };
@@ -229,7 +228,8 @@
             // So just return the first config that matches the package name.
             return configs[0];
         }
-        return configs.find(function (config) { return semver_1.satisfies(version, config.versionRange); }) || null;
+        return configs.find(function (config) { return semver_1.satisfies(version, config.versionRange, { includePrerelease: true }); }) ||
+            null;
     }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/packages/configuration.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 {createHash} from 'crypto';\nimport {satisfies} from 'semver';\nimport * as vm from 'vm';\nimport {AbsoluteFsPath, FileSystem, dirname, join, resolve} from '../../../src/ngtsc/file_system';\nimport {PackageJsonFormatPropertiesMap} from './entry_point';\n\n/**\n * The format of a project level configuration file.\n */\nexport interface NgccProjectConfig<T = NgccPackageConfig> {\n  /**\n   * The packages that are configured by this project config.\n   */\n  packages: {[packagePath: string]: T};\n}\n\n/**\n * The format of a package level configuration file.\n */\nexport interface NgccPackageConfig {\n  /**\n   * The entry-points to configure for this package.\n   *\n   * In the config file the keys can be paths relative to the package path;\n   * but when being read back from the `NgccConfiguration` service, these paths\n   * will be absolute.\n   */\n  entryPoints: {[entryPointPath: string]: NgccEntryPointConfig;};\n  /**\n   * A collection of regexes that match deep imports to ignore, for this package, rather than\n   * displaying a warning.\n   */\n  ignorableDeepImportMatchers?: RegExp[];\n}\n\n/**\n * Configuration options for an entry-point.\n *\n * The existence of a configuration for a path tells ngcc that this should be considered for\n * processing as an entry-point.\n */\nexport interface NgccEntryPointConfig {\n  /** Do not process (or even acknowledge the existence of) this entry-point, if true. */\n  ignore?: boolean;\n  /**\n   * This property, if provided, holds values that will override equivalent properties in an\n   * entry-point's package.json file.\n   */\n  override?: PackageJsonFormatPropertiesMap;\n\n  /**\n   * Normally, ngcc will skip compilation of entrypoints that contain imports that can't be resolved\n   * or understood. If this option is specified, ngcc will proceed with compiling the entrypoint\n   * even in the face of such missing dependencies.\n   */\n  ignoreMissingDependencies?: boolean;\n\n  /**\n   * Enabling this option for an entrypoint tells ngcc that deep imports might be used for the files\n   * it contains, and that it should generate private re-exports alongside the NgModule of all the\n   * directives/pipes it makes available in support of those imports.\n   */\n  generateDeepReexports?: boolean;\n}\n\n/**\n * The default configuration for ngcc.\n *\n * This is the ultimate fallback configuration that ngcc will use if there is no configuration\n * for a package at the package level or project level.\n *\n * This configuration is for packages that are \"dead\" - i.e. no longer maintained and so are\n * unlikely to be fixed to work with ngcc, nor provide a package level config of their own.\n *\n * The fallback process for looking up configuration is:\n *\n * Project -> Package -> Default\n *\n * If a package provides its own configuration then that would override this default one.\n *\n * Also application developers can always provide configuration at their project level which\n * will override everything else.\n *\n * Note that the fallback is package based not entry-point based.\n * For example, if a there is configuration for a package at the project level this will replace all\n * entry-point configurations that may have been provided in the package level or default level\n * configurations, even if the project level configuration does not provide for a given entry-point.\n */\nexport const DEFAULT_NGCC_CONFIG: NgccProjectConfig = {\n  packages: {\n    // Add default package configuration here. For example:\n    // '@angular/fire@^5.2.0': {\n    //   entryPoints: {\n    //     './database-deprecated': {ignore: true},\n    //   },\n    // },\n\n    // The package does not contain any `.metadata.json` files in the root directory but only inside\n    // `dist/`. Without this config, ngcc does not realize this is a ViewEngine-built Angular\n    // package that needs to be compiled to Ivy.\n    'angular2-highcharts': {\n      entryPoints: {\n        '.': {\n          override: {\n            main: './index.js',\n          },\n        },\n      },\n    },\n\n    // The `dist/` directory has a duplicate `package.json` pointing to the same files, which (under\n    // certain configurations) can causes ngcc to try to process the files twice and fail.\n    // Ignore the `dist/` entry-point.\n    'ng2-dragula': {\n      entryPoints: {\n        './dist': {ignore: true},\n      },\n    },\n  },\n};\n\ninterface VersionedPackageConfig extends NgccPackageConfig {\n  versionRange: string;\n}\n\nconst NGCC_CONFIG_FILENAME = 'ngcc.config.js';\n\n/**\n * Ngcc has a hierarchical configuration system that lets us \"fix up\" packages that do not\n * work with ngcc out of the box.\n *\n * There are three levels at which configuration can be declared:\n *\n * * Default level - ngcc comes with built-in configuration for well known cases.\n * * Package level - a library author publishes a configuration with their package to fix known\n *   issues.\n * * Project level - the application developer provides a configuration that fixes issues specific\n *   to the libraries used in their application.\n *\n * Ngcc will match configuration based on the package name but also on its version. This allows\n * configuration to provide different fixes to different version ranges of a package.\n *\n * * Package level configuration is specific to the package version where the configuration is\n *   found.\n * * Default and project level configuration should provide version ranges to ensure that the\n *   configuration is only applied to the appropriate versions of a package.\n *\n * When getting a configuration for a package (via `getConfig()`) the caller should provide the\n * version of the package in question, if available. If it is not provided then the first available\n * configuration for a package is returned.\n */\nexport class NgccConfiguration {\n  private defaultConfig: NgccProjectConfig<VersionedPackageConfig[]>;\n  private projectConfig: NgccProjectConfig<VersionedPackageConfig[]>;\n  private cache = new Map<string, VersionedPackageConfig>();\n  readonly hash: string;\n\n  constructor(private fs: FileSystem, baseDir: AbsoluteFsPath) {\n    this.defaultConfig = this.processProjectConfig(baseDir, DEFAULT_NGCC_CONFIG);\n    this.projectConfig = this.processProjectConfig(baseDir, this.loadProjectConfig(baseDir));\n    this.hash = this.computeHash();\n  }\n\n  /**\n   * Get a configuration for the given `version` of a package at `packagePath`.\n   *\n   * @param packagePath The path to the package whose config we want.\n   * @param version The version of the package whose config we want, or `null` if the package's\n   * package.json did not exist or was invalid.\n   */\n  getConfig(packagePath: AbsoluteFsPath, version: string|null): VersionedPackageConfig {\n    const cacheKey = packagePath + (version !== null ? `@${version}` : '');\n    if (this.cache.has(cacheKey)) {\n      return this.cache.get(cacheKey) !;\n    }\n\n    const projectLevelConfig =\n        findSatisfactoryVersion(this.projectConfig.packages[packagePath], version);\n    if (projectLevelConfig !== null) {\n      this.cache.set(cacheKey, projectLevelConfig);\n      return projectLevelConfig;\n    }\n\n    const packageLevelConfig = this.loadPackageConfig(packagePath, version);\n    if (packageLevelConfig !== null) {\n      this.cache.set(cacheKey, packageLevelConfig);\n      return packageLevelConfig;\n    }\n\n    const defaultLevelConfig =\n        findSatisfactoryVersion(this.defaultConfig.packages[packagePath], version);\n    if (defaultLevelConfig !== null) {\n      this.cache.set(cacheKey, defaultLevelConfig);\n      return defaultLevelConfig;\n    }\n\n    return {versionRange: '*', entryPoints: {}};\n  }\n\n  private processProjectConfig(baseDir: AbsoluteFsPath, projectConfig: NgccProjectConfig):\n      NgccProjectConfig<VersionedPackageConfig[]> {\n    const processedConfig: NgccProjectConfig<VersionedPackageConfig[]> = {packages: {}};\n    for (const packagePathAndVersion in projectConfig.packages) {\n      const packageConfig = projectConfig.packages[packagePathAndVersion];\n      if (packageConfig) {\n        const [packagePath, versionRange = '*'] = this.splitPathAndVersion(packagePathAndVersion);\n        const absPackagePath = resolve(baseDir, 'node_modules', packagePath);\n        const entryPoints = this.processEntryPoints(absPackagePath, packageConfig);\n        processedConfig.packages[absPackagePath] = processedConfig.packages[absPackagePath] || [];\n        processedConfig.packages[absPackagePath].push(\n            {...packageConfig, versionRange, entryPoints});\n      }\n    }\n    return processedConfig;\n  }\n\n  private loadProjectConfig(baseDir: AbsoluteFsPath): NgccProjectConfig {\n    const configFilePath = join(baseDir, NGCC_CONFIG_FILENAME);\n    if (this.fs.exists(configFilePath)) {\n      try {\n        return this.evalSrcFile(configFilePath);\n      } catch (e) {\n        throw new Error(`Invalid project configuration file at \"${configFilePath}\": ` + e.message);\n      }\n    } else {\n      return {packages: {}};\n    }\n  }\n\n  private loadPackageConfig(packagePath: AbsoluteFsPath, version: string|null):\n      VersionedPackageConfig|null {\n    const configFilePath = join(packagePath, NGCC_CONFIG_FILENAME);\n    if (this.fs.exists(configFilePath)) {\n      try {\n        return {\n          versionRange: version || '*',\n          entryPoints: this.processEntryPoints(packagePath, this.evalSrcFile(configFilePath)),\n        };\n      } catch (e) {\n        throw new Error(`Invalid package configuration file at \"${configFilePath}\": ` + e.message);\n      }\n    } else {\n      return null;\n    }\n  }\n\n  private evalSrcFile(srcPath: AbsoluteFsPath): any {\n    const src = this.fs.readFile(srcPath);\n    const theExports = {};\n    const sandbox = {\n      module: {exports: theExports},\n      exports: theExports, require,\n      __dirname: dirname(srcPath),\n      __filename: srcPath\n    };\n    vm.runInNewContext(src, sandbox, {filename: srcPath});\n    return sandbox.module.exports;\n  }\n\n  private processEntryPoints(packagePath: AbsoluteFsPath, packageConfig: NgccPackageConfig):\n      {[entryPointPath: string]: NgccEntryPointConfig;} {\n    const processedEntryPoints: {[entryPointPath: string]: NgccEntryPointConfig;} = {};\n    for (const entryPointPath in packageConfig.entryPoints) {\n      // Change the keys to be absolute paths\n      processedEntryPoints[resolve(packagePath, entryPointPath)] =\n          packageConfig.entryPoints[entryPointPath];\n    }\n    return processedEntryPoints;\n  }\n\n  private splitPathAndVersion(packagePathAndVersion: string): [string, string|undefined] {\n    const versionIndex = packagePathAndVersion.lastIndexOf('@');\n    // Note that > 0 is because we don't want to match @ at the start of the line\n    // which is what you would have with a namespaced package, e.g. `@angular/common`.\n    return versionIndex > 0 ?\n        [\n          packagePathAndVersion.substring(0, versionIndex),\n          packagePathAndVersion.substring(versionIndex + 1)\n        ] :\n        [packagePathAndVersion, undefined];\n  }\n\n  private computeHash(): string {\n    return createHash('md5').update(JSON.stringify(this.projectConfig)).digest('hex');\n  }\n}\n\nfunction findSatisfactoryVersion(\n    configs: VersionedPackageConfig[] | undefined, version: string | null): VersionedPackageConfig|\n    null {\n  if (configs === undefined) {\n    return null;\n  }\n  if (version === null) {\n    // The package has no version (!) - perhaps the entry-point was from a deep import, which made\n    // it impossible to find the package.json.\n    // So just return the first config that matches the package name.\n    return configs[0];\n  }\n  return configs.find(config => satisfies(version, config.versionRange)) || null;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/packages/configuration.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA;;;;;;OAMG;IACH,iCAAkC;IAClC,iCAAiC;IACjC,uBAAyB;IAEzB,2EAAkG;IA+DlG;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACU,QAAA,mBAAmB,GAAsB;QACpD,QAAQ,EAAE;YACR,uDAAuD;YACvD,4BAA4B;YAC5B,mBAAmB;YACnB,+CAA+C;YAC/C,OAAO;YACP,KAAK;YAEL,gGAAgG;YAChG,yFAAyF;YACzF,4CAA4C;YAC5C,qBAAqB,EAAE;gBACrB,WAAW,EAAE;oBACX,GAAG,EAAE;wBACH,QAAQ,EAAE;4BACR,IAAI,EAAE,YAAY;yBACnB;qBACF;iBACF;aACF;YAED,gGAAgG;YAChG,sFAAsF;YACtF,kCAAkC;YAClC,aAAa,EAAE;gBACb,WAAW,EAAE;oBACX,QAAQ,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC;iBACzB;aACF;SACF;KACF,CAAC;IAMF,IAAM,oBAAoB,GAAG,gBAAgB,CAAC;IAE9C;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH;QAME,2BAAoB,EAAc,EAAE,OAAuB;YAAvC,OAAE,GAAF,EAAE,CAAY;YAH1B,UAAK,GAAG,IAAI,GAAG,EAAkC,CAAC;YAIxD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,EAAE,2BAAmB,CAAC,CAAC;YAC7E,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,EAAE,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;YACzF,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QACjC,CAAC;QAED;;;;;;WAMG;QACH,qCAAS,GAAT,UAAU,WAA2B,EAAE,OAAoB;YACzD,IAAM,QAAQ,GAAG,WAAW,GAAG,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,MAAI,OAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACvE,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE;gBAC5B,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAE,CAAC;aAClC;YAED,IAAM,kBAAkB,GACpB,uBAAuB,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,CAAC;YAC/E,IAAI,kBAAkB,KAAK,IAAI,EAAE;gBAC/B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,kBAAkB,CAAC,CAAC;gBAC7C,OAAO,kBAAkB,CAAC;aAC3B;YAED,IAAM,kBAAkB,GAAG,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;YACxE,IAAI,kBAAkB,KAAK,IAAI,EAAE;gBAC/B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,kBAAkB,CAAC,CAAC;gBAC7C,OAAO,kBAAkB,CAAC;aAC3B;YAED,IAAM,kBAAkB,GACpB,uBAAuB,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,CAAC;YAC/E,IAAI,kBAAkB,KAAK,IAAI,EAAE;gBAC/B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,kBAAkB,CAAC,CAAC;gBAC7C,OAAO,kBAAkB,CAAC;aAC3B;YAED,OAAO,EAAC,YAAY,EAAE,GAAG,EAAE,WAAW,EAAE,EAAE,EAAC,CAAC;QAC9C,CAAC;QAEO,gDAAoB,GAA5B,UAA6B,OAAuB,EAAE,aAAgC;YAEpF,IAAM,eAAe,GAAgD,EAAC,QAAQ,EAAE,EAAE,EAAC,CAAC;YACpF,KAAK,IAAM,qBAAqB,IAAI,aAAa,CAAC,QAAQ,EAAE;gBAC1D,IAAM,aAAa,GAAG,aAAa,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAC;gBACpE,IAAI,aAAa,EAAE;oBACX,IAAA,uEAAmF,EAAlF,mBAAW,EAAE,UAAkB,EAAlB,uCAAqE,CAAC;oBAC1F,IAAM,cAAc,GAAG,qBAAO,CAAC,OAAO,EAAE,cAAc,EAAE,WAAW,CAAC,CAAC;oBACrE,IAAM,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,cAAc,EAAE,aAAa,CAAC,CAAC;oBAC3E,eAAe,CAAC,QAAQ,CAAC,cAAc,CAAC,GAAG,eAAe,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;oBAC1F,eAAe,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,IAAI,uCACrC,aAAa,KAAE,YAAY,cAAA,EAAE,WAAW,aAAA,IAAE,CAAC;iBACpD;aACF;YACD,OAAO,eAAe,CAAC;QACzB,CAAC;QAEO,6CAAiB,GAAzB,UAA0B,OAAuB;YAC/C,IAAM,cAAc,GAAG,kBAAI,CAAC,OAAO,EAAE,oBAAoB,CAAC,CAAC;YAC3D,IAAI,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,EAAE;gBAClC,IAAI;oBACF,OAAO,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;iBACzC;gBAAC,OAAO,CAAC,EAAE;oBACV,MAAM,IAAI,KAAK,CAAC,6CAA0C,cAAc,SAAK,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC;iBAC5F;aACF;iBAAM;gBACL,OAAO,EAAC,QAAQ,EAAE,EAAE,EAAC,CAAC;aACvB;QACH,CAAC;QAEO,6CAAiB,GAAzB,UAA0B,WAA2B,EAAE,OAAoB;YAEzE,IAAM,cAAc,GAAG,kBAAI,CAAC,WAAW,EAAE,oBAAoB,CAAC,CAAC;YAC/D,IAAI,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,EAAE;gBAClC,IAAI;oBACF,IAAM,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;oBACvD,6CACK,aAAa,KAChB,YAAY,EAAE,OAAO,IAAI,GAAG,EAC5B,WAAW,EAAE,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,aAAa,CAAC,IAChE;iBACH;gBAAC,OAAO,CAAC,EAAE;oBACV,MAAM,IAAI,KAAK,CAAC,6CAA0C,cAAc,SAAK,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC;iBAC5F;aACF;iBAAM;gBACL,OAAO,IAAI,CAAC;aACb;QACH,CAAC;QAEO,uCAAW,GAAnB,UAAoB,OAAuB;YACzC,IAAM,GAAG,GAAG,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YACtC,IAAM,UAAU,GAAG,EAAE,CAAC;YACtB,IAAM,OAAO,GAAG;gBACd,MAAM,EAAE,EAAC,OAAO,EAAE,UAAU,EAAC;gBAC7B,OAAO,EAAE,UAAU;gBACnB,OAAO,SAAA;gBACP,SAAS,EAAE,qBAAO,CAAC,OAAO,CAAC;gBAC3B,UAAU,EAAE,OAAO;aACpB,CAAC;YACF,EAAE,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,EAAC,QAAQ,EAAE,OAAO,EAAC,CAAC,CAAC;YACtD,OAAO,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC;QAChC,CAAC;QAEO,8CAAkB,GAA1B,UAA2B,WAA2B,EAAE,aAAgC;YAEtF,IAAM,oBAAoB,GAAsD,EAAE,CAAC;YACnF,KAAK,IAAM,cAAc,IAAI,aAAa,CAAC,WAAW,EAAE;gBACtD,uCAAuC;gBACvC,oBAAoB,CAAC,qBAAO,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;oBACtD,aAAa,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;aAC/C;YACD,OAAO,oBAAoB,CAAC;QAC9B,CAAC;QAEO,+CAAmB,GAA3B,UAA4B,qBAA6B;YACvD,IAAM,YAAY,GAAG,qBAAqB,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;YAC5D,6EAA6E;YAC7E,kFAAkF;YAClF,OAAO,YAAY,GAAG,CAAC,CAAC,CAAC;gBACrB;oBACE,qBAAqB,CAAC,SAAS,CAAC,CAAC,EAAE,YAAY,CAAC;oBAChD,qBAAqB,CAAC,SAAS,CAAC,YAAY,GAAG,CAAC,CAAC;iBAClD,CAAC,CAAC;gBACH,CAAC,qBAAqB,EAAE,SAAS,CAAC,CAAC;QACzC,CAAC;QAEO,uCAAW,GAAnB;YACE,OAAO,mBAAU,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACpF,CAAC;QACH,wBAAC;IAAD,CAAC,AAzID,IAyIC;IAzIY,8CAAiB;IA2I9B,SAAS,uBAAuB,CAAC,OAA2C,EAAE,OAAoB;QAEhG,IAAI,OAAO,KAAK,SAAS,EAAE;YACzB,OAAO,IAAI,CAAC;SACb;QACD,IAAI,OAAO,KAAK,IAAI,EAAE;YACpB,8FAA8F;YAC9F,0CAA0C;YAC1C,iEAAiE;YACjE,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC;SACnB;QACD,OAAO,OAAO,CAAC,IAAI,CACR,UAAA,MAAM,IAAI,OAAA,kBAAS,CAAC,OAAO,EAAE,MAAM,CAAC,YAAY,EAAE,EAAC,iBAAiB,EAAE,IAAI,EAAC,CAAC,EAAlE,CAAkE,CAAC;YACpF,IAAI,CAAC;IACX,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 {createHash} from 'crypto';\nimport {satisfies} from 'semver';\nimport * as vm from 'vm';\n\nimport {AbsoluteFsPath, dirname, FileSystem, join, resolve} from '../../../src/ngtsc/file_system';\n\nimport {PackageJsonFormatPropertiesMap} from './entry_point';\n\n/**\n * The format of a project level configuration file.\n */\nexport interface NgccProjectConfig<T = NgccPackageConfig> {\n  /**\n   * The packages that are configured by this project config.\n   */\n  packages: {[packagePath: string]: T};\n}\n\n/**\n * The format of a package level configuration file.\n */\nexport interface NgccPackageConfig {\n  /**\n   * The entry-points to configure for this package.\n   *\n   * In the config file the keys can be paths relative to the package path;\n   * but when being read back from the `NgccConfiguration` service, these paths\n   * will be absolute.\n   */\n  entryPoints: {[entryPointPath: string]: NgccEntryPointConfig;};\n  /**\n   * A collection of regexes that match deep imports to ignore, for this package, rather than\n   * displaying a warning.\n   */\n  ignorableDeepImportMatchers?: RegExp[];\n}\n\n/**\n * Configuration options for an entry-point.\n *\n * The existence of a configuration for a path tells ngcc that this should be considered for\n * processing as an entry-point.\n */\nexport interface NgccEntryPointConfig {\n  /** Do not process (or even acknowledge the existence of) this entry-point, if true. */\n  ignore?: boolean;\n  /**\n   * This property, if provided, holds values that will override equivalent properties in an\n   * entry-point's package.json file.\n   */\n  override?: PackageJsonFormatPropertiesMap;\n\n  /**\n   * Normally, ngcc will skip compilation of entrypoints that contain imports that can't be resolved\n   * or understood. If this option is specified, ngcc will proceed with compiling the entrypoint\n   * even in the face of such missing dependencies.\n   */\n  ignoreMissingDependencies?: boolean;\n\n  /**\n   * Enabling this option for an entrypoint tells ngcc that deep imports might be used for the files\n   * it contains, and that it should generate private re-exports alongside the NgModule of all the\n   * directives/pipes it makes available in support of those imports.\n   */\n  generateDeepReexports?: boolean;\n}\n\n/**\n * The default configuration for ngcc.\n *\n * This is the ultimate fallback configuration that ngcc will use if there is no configuration\n * for a package at the package level or project level.\n *\n * This configuration is for packages that are \"dead\" - i.e. no longer maintained and so are\n * unlikely to be fixed to work with ngcc, nor provide a package level config of their own.\n *\n * The fallback process for looking up configuration is:\n *\n * Project -> Package -> Default\n *\n * If a package provides its own configuration then that would override this default one.\n *\n * Also application developers can always provide configuration at their project level which\n * will override everything else.\n *\n * Note that the fallback is package based not entry-point based.\n * For example, if a there is configuration for a package at the project level this will replace all\n * entry-point configurations that may have been provided in the package level or default level\n * configurations, even if the project level configuration does not provide for a given entry-point.\n */\nexport const DEFAULT_NGCC_CONFIG: NgccProjectConfig = {\n  packages: {\n    // Add default package configuration here. For example:\n    // '@angular/fire@^5.2.0': {\n    //   entryPoints: {\n    //     './database-deprecated': {ignore: true},\n    //   },\n    // },\n\n    // The package does not contain any `.metadata.json` files in the root directory but only inside\n    // `dist/`. Without this config, ngcc does not realize this is a ViewEngine-built Angular\n    // package that needs to be compiled to Ivy.\n    'angular2-highcharts': {\n      entryPoints: {\n        '.': {\n          override: {\n            main: './index.js',\n          },\n        },\n      },\n    },\n\n    // The `dist/` directory has a duplicate `package.json` pointing to the same files, which (under\n    // certain configurations) can causes ngcc to try to process the files twice and fail.\n    // Ignore the `dist/` entry-point.\n    'ng2-dragula': {\n      entryPoints: {\n        './dist': {ignore: true},\n      },\n    },\n  },\n};\n\ninterface VersionedPackageConfig extends NgccPackageConfig {\n  versionRange: string;\n}\n\nconst NGCC_CONFIG_FILENAME = 'ngcc.config.js';\n\n/**\n * Ngcc has a hierarchical configuration system that lets us \"fix up\" packages that do not\n * work with ngcc out of the box.\n *\n * There are three levels at which configuration can be declared:\n *\n * * Default level - ngcc comes with built-in configuration for well known cases.\n * * Package level - a library author publishes a configuration with their package to fix known\n *   issues.\n * * Project level - the application developer provides a configuration that fixes issues specific\n *   to the libraries used in their application.\n *\n * Ngcc will match configuration based on the package name but also on its version. This allows\n * configuration to provide different fixes to different version ranges of a package.\n *\n * * Package level configuration is specific to the package version where the configuration is\n *   found.\n * * Default and project level configuration should provide version ranges to ensure that the\n *   configuration is only applied to the appropriate versions of a package.\n *\n * When getting a configuration for a package (via `getConfig()`) the caller should provide the\n * version of the package in question, if available. If it is not provided then the first available\n * configuration for a package is returned.\n */\nexport class NgccConfiguration {\n  private defaultConfig: NgccProjectConfig<VersionedPackageConfig[]>;\n  private projectConfig: NgccProjectConfig<VersionedPackageConfig[]>;\n  private cache = new Map<string, VersionedPackageConfig>();\n  readonly hash: string;\n\n  constructor(private fs: FileSystem, baseDir: AbsoluteFsPath) {\n    this.defaultConfig = this.processProjectConfig(baseDir, DEFAULT_NGCC_CONFIG);\n    this.projectConfig = this.processProjectConfig(baseDir, this.loadProjectConfig(baseDir));\n    this.hash = this.computeHash();\n  }\n\n  /**\n   * Get a configuration for the given `version` of a package at `packagePath`.\n   *\n   * @param packagePath The path to the package whose config we want.\n   * @param version The version of the package whose config we want, or `null` if the package's\n   * package.json did not exist or was invalid.\n   */\n  getConfig(packagePath: AbsoluteFsPath, version: string|null): VersionedPackageConfig {\n    const cacheKey = packagePath + (version !== null ? `@${version}` : '');\n    if (this.cache.has(cacheKey)) {\n      return this.cache.get(cacheKey)!;\n    }\n\n    const projectLevelConfig =\n        findSatisfactoryVersion(this.projectConfig.packages[packagePath], version);\n    if (projectLevelConfig !== null) {\n      this.cache.set(cacheKey, projectLevelConfig);\n      return projectLevelConfig;\n    }\n\n    const packageLevelConfig = this.loadPackageConfig(packagePath, version);\n    if (packageLevelConfig !== null) {\n      this.cache.set(cacheKey, packageLevelConfig);\n      return packageLevelConfig;\n    }\n\n    const defaultLevelConfig =\n        findSatisfactoryVersion(this.defaultConfig.packages[packagePath], version);\n    if (defaultLevelConfig !== null) {\n      this.cache.set(cacheKey, defaultLevelConfig);\n      return defaultLevelConfig;\n    }\n\n    return {versionRange: '*', entryPoints: {}};\n  }\n\n  private processProjectConfig(baseDir: AbsoluteFsPath, projectConfig: NgccProjectConfig):\n      NgccProjectConfig<VersionedPackageConfig[]> {\n    const processedConfig: NgccProjectConfig<VersionedPackageConfig[]> = {packages: {}};\n    for (const packagePathAndVersion in projectConfig.packages) {\n      const packageConfig = projectConfig.packages[packagePathAndVersion];\n      if (packageConfig) {\n        const [packagePath, versionRange = '*'] = this.splitPathAndVersion(packagePathAndVersion);\n        const absPackagePath = resolve(baseDir, 'node_modules', packagePath);\n        const entryPoints = this.processEntryPoints(absPackagePath, packageConfig);\n        processedConfig.packages[absPackagePath] = processedConfig.packages[absPackagePath] || [];\n        processedConfig.packages[absPackagePath].push(\n            {...packageConfig, versionRange, entryPoints});\n      }\n    }\n    return processedConfig;\n  }\n\n  private loadProjectConfig(baseDir: AbsoluteFsPath): NgccProjectConfig {\n    const configFilePath = join(baseDir, NGCC_CONFIG_FILENAME);\n    if (this.fs.exists(configFilePath)) {\n      try {\n        return this.evalSrcFile(configFilePath);\n      } catch (e) {\n        throw new Error(`Invalid project configuration file at \"${configFilePath}\": ` + e.message);\n      }\n    } else {\n      return {packages: {}};\n    }\n  }\n\n  private loadPackageConfig(packagePath: AbsoluteFsPath, version: string|null):\n      VersionedPackageConfig|null {\n    const configFilePath = join(packagePath, NGCC_CONFIG_FILENAME);\n    if (this.fs.exists(configFilePath)) {\n      try {\n        const packageConfig = this.evalSrcFile(configFilePath);\n        return {\n          ...packageConfig,\n          versionRange: version || '*',\n          entryPoints: this.processEntryPoints(packagePath, packageConfig),\n        };\n      } catch (e) {\n        throw new Error(`Invalid package configuration file at \"${configFilePath}\": ` + e.message);\n      }\n    } else {\n      return null;\n    }\n  }\n\n  private evalSrcFile(srcPath: AbsoluteFsPath): any {\n    const src = this.fs.readFile(srcPath);\n    const theExports = {};\n    const sandbox = {\n      module: {exports: theExports},\n      exports: theExports,\n      require,\n      __dirname: dirname(srcPath),\n      __filename: srcPath\n    };\n    vm.runInNewContext(src, sandbox, {filename: srcPath});\n    return sandbox.module.exports;\n  }\n\n  private processEntryPoints(packagePath: AbsoluteFsPath, packageConfig: NgccPackageConfig):\n      {[entryPointPath: string]: NgccEntryPointConfig;} {\n    const processedEntryPoints: {[entryPointPath: string]: NgccEntryPointConfig;} = {};\n    for (const entryPointPath in packageConfig.entryPoints) {\n      // Change the keys to be absolute paths\n      processedEntryPoints[resolve(packagePath, entryPointPath)] =\n          packageConfig.entryPoints[entryPointPath];\n    }\n    return processedEntryPoints;\n  }\n\n  private splitPathAndVersion(packagePathAndVersion: string): [string, string|undefined] {\n    const versionIndex = packagePathAndVersion.lastIndexOf('@');\n    // Note that > 0 is because we don't want to match @ at the start of the line\n    // which is what you would have with a namespaced package, e.g. `@angular/common`.\n    return versionIndex > 0 ?\n        [\n          packagePathAndVersion.substring(0, versionIndex),\n          packagePathAndVersion.substring(versionIndex + 1)\n        ] :\n        [packagePathAndVersion, undefined];\n  }\n\n  private computeHash(): string {\n    return createHash('md5').update(JSON.stringify(this.projectConfig)).digest('hex');\n  }\n}\n\nfunction findSatisfactoryVersion(configs: VersionedPackageConfig[]|undefined, version: string|null):\n    VersionedPackageConfig|null {\n  if (configs === undefined) {\n    return null;\n  }\n  if (version === null) {\n    // The package has no version (!) - perhaps the entry-point was from a deep import, which made\n    // it impossible to find the package.json.\n    // So just return the first config that matches the package name.\n    return configs[0];\n  }\n  return configs.find(\n             config => satisfies(version, config.versionRange, {includePrerelease: true})) ||\n      null;\n}\n"]}

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

@@ -36,6 +36,7 @@ export interface JsonObject {
     [key: string]: JsonValue;
 }
 export interface PackageJsonFormatPropertiesMap {
+    browser?: string;
     fesm2015?: string;
     fesm5?: string;
     es2015?: string;
@@ -66,17 +67,17 @@ export declare const NO_ENTRY_POINT = "no-entry-point";
 /**
  * The path has a package.json, but it is not a valid entry-point for ngcc processing.
  */
-export declare const INVALID_ENTRY_POINT = "invalid-entry-point";
+export declare const INCOMPATIBLE_ENTRY_POINT = "incompatible-entry-point";
 /**
  * The result of calling `getEntryPointInfo()`.
  *
  * This will be an `EntryPoint` object if an Angular entry-point was identified;
  * Otherwise it will be a flag indicating one of:
  * * NO_ENTRY_POINT - the path is not an entry-point or ngcc is configured to ignore it
- * * INVALID_ENTRY_POINT - the path was a non-processable entry-point that should be searched
+ * * INCOMPATIBLE_ENTRY_POINT - the path was a non-processable entry-point that should be searched
  * for sub-entry-points
  */
-export declare type GetEntryPointResult = EntryPoint | typeof INVALID_ENTRY_POINT | typeof NO_ENTRY_POINT;
+export declare type GetEntryPointResult = EntryPoint | typeof INCOMPATIBLE_ENTRY_POINT | typeof NO_ENTRY_POINT;
 /**
  * Try to create an entry-point from the given paths and properties.
  *
@@ -84,9 +85,10 @@ export declare type GetEntryPointResult = EntryPoint | typeof INVALID_ENTRY_POIN
  * @param entryPointPath the absolute path to the potential entry-point.
  * @returns
  * - An entry-point if it is valid.
- * - `undefined` when there is no package.json at the path and there is no config to force an
+ * - `NO_ENTRY_POINT` when there is no package.json at the path and there is no config to force an
  * entry-point or the entrypoint is `ignored`.
- * - `null` there is a package.json but it is not a valid Angular compiled entry-point.
+ * - `INCOMPATIBLE_ENTRY_POINT` there is a package.json but it is not a valid Angular compiled
+ * entry-point.
  */
 export declare function getEntryPointInfo(fs: FileSystem, config: NgccConfiguration, logger: Logger, packagePath: AbsoluteFsPath, entryPointPath: AbsoluteFsPath): GetEntryPointResult;
 /**