@angular/compiler-cli 9.0.0-rc.9 → 9.0.0

package/src/ngtsc/core/api.d.ts

@@ -0,0 +1,368 @@
+/**
+ * @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/src/ngtsc/core/api" />
+import * as ts from 'typescript';
+/**
+ * A host backed by a build system which has a unified view of the module namespace.
+ *
+ * Such a build system supports the `fileNameToModuleName` method provided by certain build system
+ * integrations (such as the integration with Bazel). See the docs on `fileNameToModuleName` for
+ * more details.
+ */
+export interface UnifiedModulesHost {
+    /**
+     * Converts a file path to a module name that can be used as an `import ...`.
+     *
+     * For example, such a host might determine that `/absolute/path/to/monorepo/lib/importedFile.ts`
+     * should be imported using a module specifier of `monorepo/lib/importedFile`.
+     */
+    fileNameToModuleName(importedFilePath: string, containingFilePath: string): string;
+}
+/**
+ * A host which additionally tracks and produces "resources" (HTML templates, CSS
+ * files, etc).
+ */
+export interface ResourceHost {
+    /**
+     * Converts a file path for a resource that is used in a source file or another resource
+     * into a filepath.
+     */
+    resourceNameToFileName(resourceName: string, containingFilePath: string): string | null;
+    /**
+     * Load a referenced resource either statically or asynchronously. If the host returns a
+     * `Promise<string>` it is assumed the user of the corresponding `Program` will call
+     * `loadNgStructureAsync()`. Returning  `Promise<string>` outside `loadNgStructureAsync()` will
+     * cause a diagnostics diagnostic error or an exception to be thrown.
+     */
+    readResource(fileName: string): Promise<string> | string;
+    /**
+     * Get the absolute paths to the changed files that triggered the current compilation
+     * or `undefined` if this is not an incremental build.
+     */
+    getModifiedResourceFiles?(): Set<string> | undefined;
+}
+/**
+ * A `ts.CompilerHost` interface which supports some number of optional methods in addition to the
+ * core interface.
+ */
+export interface ExtendedTsCompilerHost extends ts.CompilerHost, Partial<ResourceHost>, Partial<UnifiedModulesHost> {
+}
+/**
+ * Options supported by the legacy View Engine compiler, which are still consumed by the Angular Ivy
+ * compiler for backwards compatibility.
+ *
+ * These are expected to be removed at some point in the future.
+ */
+export interface LegacyNgcOptions {
+    /** generate all possible generated files  */
+    allowEmptyCodegenFiles?: boolean;
+    /**
+     * Whether to type check the entire template.
+     *
+     * This flag currently controls a couple aspects of template type-checking, including
+     * whether embedded views are checked.
+     *
+     * For maximum type-checking, set this to `true`, and set `strictTemplates` to `true`.
+     *
+     * It is an error for this flag to be `false`, while `strictTemplates` is set to `true`.
+     */
+    fullTemplateTypeCheck?: boolean;
+    /**
+     * Whether to generate a flat module index of the given name and the corresponding
+     * flat module metadata. This option is intended to be used when creating flat
+     * modules similar to how `@angular/core` and `@angular/common` are packaged.
+     * When this option is used the `package.json` for the library should refer to the
+     * generated flat module index instead of the library index file. When using this
+     * option only one .metadata.json file is produced that contains all the metadata
+     * necessary for symbols exported from the library index.
+     * In the generated .ngfactory.ts files flat module index is used to import symbols
+     * including both the public API from the library index as well as shrowded internal
+     * symbols.
+     * By default the .ts file supplied in the `files` field is assumed to be the
+     * library index. If more than one is specified, uses `libraryIndex` to select the
+     * file to use. If more than one .ts file is supplied and no `libraryIndex` is supplied
+     * an error is produced.
+     * A flat module index .d.ts and .js will be created with the given `flatModuleOutFile`
+     * name in the same location as the library index .d.ts file is emitted.
+     * For example, if a library uses `public_api.ts` file as the library index of the
+     * module the `tsconfig.json` `files` field would be `["public_api.ts"]`. The
+     * `flatModuleOutFile` options could then be set to, for example `"index.js"`, which
+     * produces `index.d.ts` and  `index.metadata.json` files. The library's
+     * `package.json`'s `module` field would be `"index.js"` and the `typings` field would
+     * be `"index.d.ts"`.
+     */
+    flatModuleOutFile?: string;
+    /**
+     * Preferred module id to use for importing flat module. References generated by `ngc`
+     * will use this module name when importing symbols from the flat module. This is only
+     * meaningful when `flatModuleOutFile` is also supplied. It is otherwise ignored.
+     */
+    flatModuleId?: string;
+    /**
+     * Always report errors a parameter is supplied whose injection type cannot
+     * be determined. When this value option is not provided or is `false`, constructor
+     * parameters of classes marked with `@Injectable` whose type cannot be resolved will
+     * produce a warning. With this option `true`, they produce an error. When this option is
+     * not provided is treated as if it were `false`.
+     */
+    strictInjectionParameters?: boolean;
+    /**
+     * Whether to remove blank text nodes from compiled templates. It is `false` by default starting
+     * from Angular 6.
+     */
+    preserveWhitespaces?: boolean;
+}
+/**
+ * Options which were added to the Angular Ivy compiler to support backwards compatibility with
+ * existing View Engine applications.
+ *
+ * These are expected to be removed at some point in the future.
+ */
+export interface NgcCompatibilityOptions {
+    /**
+     * Controls whether ngtsc will emit `.ngfactory.js` shims for each compiled `.ts` file.
+     *
+     * These shims support legacy imports from `ngfactory` files, by exporting a factory shim
+     * for each component or NgModule in the original `.ts` file.
+     */
+    generateNgFactoryShims?: boolean;
+    /**
+     * Controls whether ngtsc will emit `.ngsummary.js` shims for each compiled `.ts` file.
+     *
+     * These shims support legacy imports from `ngsummary` files, by exporting an empty object
+     * for each NgModule in the original `.ts` file. The only purpose of summaries is to feed them to
+     * `TestBed`, which is a no-op in Ivy.
+     */
+    generateNgSummaryShims?: boolean;
+    /**
+     * Tells the compiler to generate definitions using the Render3 style code generation.
+     * This option defaults to `true`.
+     *
+     * Acceptable values are as follows:
+     *
+     * `false` - run ngc normally
+     * `true` - run the ngtsc compiler instead of the normal ngc compiler
+     * `ngtsc` - alias for `true`
+     */
+    enableIvy?: boolean | 'ngtsc';
+}
+/**
+ * Options related to template type-checking and its strictness.
+ */
+export interface StrictTemplateOptions {
+    /**
+     * If `true`, implies all template strictness flags below (unless individually disabled).
+     *
+     * Has no effect unless `fullTemplateTypeCheck` is also enabled.
+     *
+     * Defaults to `false`, even if "fullTemplateTypeCheck" is set.
+     */
+    strictTemplates?: boolean;
+    /**
+     * Whether to check the type of a binding to a directive/component input against the type of the
+     * field on the directive/component.
+     *
+     * For example, if this is `false` then the expression `[input]="expr"` will have `expr` type-
+     * checked, but not the assignment of the resulting type to the `input` property of whichever
+     * directive or component is receiving the binding. If set to `true`, both sides of the assignment
+     * are checked.
+     *
+     * Defaults to `false`, even if "fullTemplateTypeCheck" is set.
+     */
+    strictInputTypes?: boolean;
+    /**
+     * Whether to use strict null types for input bindings for directives.
+     *
+     * If this is `true`, applications that are compiled with TypeScript's `strictNullChecks` enabled
+     * will produce type errors for bindings which can evaluate to `undefined` or `null` where the
+     * inputs's type does not include `undefined` or `null` in its type. If set to `false`, all
+     * binding expressions are wrapped in a non-null assertion operator to effectively disable strict
+     * null checks.
+     *
+     * Defaults to `false`, even if "fullTemplateTypeCheck" is set. Note that if `strictInputTypes` is
+     * not set, or set to `false`, this flag has no effect.
+     */
+    strictNullInputTypes?: boolean;
+    /**
+     * Whether to check text attributes that happen to be consumed by a directive or component.
+     *
+     * For example, in a template containing `<input matInput disabled>` the `disabled` attribute ends
+     * up being consumed as an input with type `boolean` by the `matInput` directive. At runtime, the
+     * input will be set to the attribute's string value, which is an empty string for attributes
+     * without a value, so with this flag set to `true`, an error would be reported. If set to
+     * `false`, text attributes will never report an error.
+     *
+     * Defaults to `false`, even if "fullTemplateTypeCheck" is set. Note that if `strictInputTypes` is
+     * not set, or set to `false`, this flag has no effect.
+     */
+    strictAttributeTypes?: boolean;
+    /**
+     * Whether to use a strict type for null-safe navigation operations.
+     *
+     * If this is `false`, then the return type of `a?.b` or `a?()` will be `any`. If set to `true`,
+     * then the return type of `a?.b` for example will be the same as the type of the ternary
+     * expression `a != null ? a.b : a`.
+     *
+     * Defaults to `false`, even if "fullTemplateTypeCheck" is set.
+     */
+    strictSafeNavigationTypes?: boolean;
+    /**
+     * Whether to infer the type of local references.
+     *
+     * If this is `true`, the type of a `#ref` variable on a DOM node in the template will be
+     * determined by the type of `document.createElement` for the given DOM node. If set to `false`,
+     * the type of `ref` for DOM nodes will be `any`.
+     *
+     * Defaults to `false`, even if "fullTemplateTypeCheck" is set.
+     */
+    strictDomLocalRefTypes?: boolean;
+    /**
+     * Whether to infer the type of the `$event` variable in event bindings for directive outputs or
+     * animation events.
+     *
+     * If this is `true`, the type of `$event` will be inferred based on the generic type of
+     * `EventEmitter`/`Subject` of the output. If set to `false`, the `$event` variable will be of
+     * type `any`.
+     *
+     * Defaults to `false`, even if "fullTemplateTypeCheck" is set.
+     */
+    strictOutputEventTypes?: boolean;
+    /**
+     * Whether to infer the type of the `$event` variable in event bindings to DOM events.
+     *
+     * If this is `true`, the type of `$event` will be inferred based on TypeScript's
+     * `HTMLElementEventMap`, with a fallback to the native `Event` type. If set to `false`, the
+     * `$event` variable will be of type `any`.
+     *
+     * Defaults to `false`, even if "fullTemplateTypeCheck" is set.
+     */
+    strictDomEventTypes?: boolean;
+    /**
+     * Whether to include the generic type of components when type-checking the template.
+     *
+     * If no component has generic type parameters, this setting has no effect.
+     *
+     * If a component has generic type parameters and this setting is `true`, those generic parameters
+     * will be included in the context type for the template. If `false`, any generic parameters will
+     * be set to `any` in the template context type.
+     *
+     * Defaults to `false`, even if "fullTemplateTypeCheck" is set.
+     */
+    strictContextGenerics?: boolean;
+}
+/**
+ * Options which control behavior useful for "monorepo" build cases using Bazel (such as the
+ * internal Google monorepo, g3).
+ */
+export interface BazelAndG3Options {
+    /**
+     * Enables the generation of alias re-exports of directives/pipes that are visible from an
+     * NgModule from that NgModule's file.
+     *
+     * This option should be disabled for application builds or for Angular Package Format libraries
+     * (where NgModules along with their directives/pipes are exported via a single entrypoint).
+     *
+     * For other library compilations which are intended to be path-mapped into an application build
+     * (or another library), enabling this option enables the resulting deep imports to work
+     * correctly.
+     *
+     * A consumer of such a path-mapped library will write an import like:
+     *
+     * ```typescript
+     * import {LibModule} from 'lib/deep/path/to/module';
+     * ```
+     *
+     * The compiler will attempt to generate imports of directives/pipes from that same module
+     * specifier (the compiler does not rewrite the user's given import path, unlike View Engine).
+     *
+     * ```typescript
+     * import {LibDir, LibCmp, LibPipe} from 'lib/deep/path/to/module';
+     * ```
+     *
+     * It would be burdensome for users to have to re-export all directives/pipes alongside each
+     * NgModule to support this import model. Enabling this option tells the compiler to generate
+     * private re-exports alongside the NgModule of all the directives/pipes it makes available, to
+     * support these future imports.
+     */
+    generateDeepReexports?: boolean;
+    /**
+     * Insert JSDoc type annotations needed by Closure Compiler
+     */
+    annotateForClosureCompiler?: boolean;
+}
+/**
+ * Options related to i18n compilation support.
+ */
+export interface I18nOptions {
+    /**
+     * Locale of the imported translations
+     */
+    i18nInLocale?: string;
+    /**
+     * Render `$localize` messages with legacy format ids.
+     *
+     * This is only active if we are building with `enableIvy: true`.
+     * The default value for now is `true`.
+     *
+     * Use this option when use are using the `$localize` based localization messages but
+     * have not migrated the translation files to use the new `$localize` message id format.
+     */
+    enableI18nLegacyMessageIdFormat?: boolean;
+    /**
+     * Whether translation variable name should contain external message id
+     * (used by Closure Compiler's output of `goog.getMsg` for transition period)
+     */
+    i18nUseExternalIds?: boolean;
+}
+/**
+ * Non-public options which are useful during testing of the compiler.
+ */
+export interface TestOnlyOptions {
+}
+/**
+ * A merged interface of all of the various Angular compiler options, as well as the standard
+ * `ts.CompilerOptions`.
+ *
+ * Also includes a few miscellaneous options.
+ */
+export interface NgCompilerOptions extends ts.CompilerOptions, LegacyNgcOptions, BazelAndG3Options, NgcCompatibilityOptions, StrictTemplateOptions, TestOnlyOptions, I18nOptions {
+    /**
+     * Whether the compiler should avoid generating code for classes that haven't been exported.
+     * This is only active when building with `enableIvy: true`. Defaults to `true`.
+     */
+    compileNonExportedClasses?: boolean;
+    /**
+     * Whether to remove blank text nodes from compiled templates. It is `false` by default starting
+     * from Angular 6.
+     */
+    preserveWhitespaces?: boolean;
+    /**
+     * Disable TypeScript Version Check.
+     */
+    disableTypeScriptVersionCheck?: boolean;
+    /** An option to enable ngtsc's internal performance tracing.
+     *
+     * This should be a path to a JSON file where trace information will be written. An optional 'ts:'
+     * prefix will cause the trace to be written via the TS host instead of directly to the filesystem
+     * (not all hosts support this mode of operation).
+     *
+     * This is currently not exposed to users as the trace format is still unstable.
+     */
+    tracePerformance?: string;
+}
+export interface LazyRoute {
+    route: string;
+    module: {
+        name: string;
+        filePath: string;
+    };
+    referencedModule: {
+        name: string;
+        filePath: string;
+    };
+}

package/src/ngtsc/core/api.js

@@ -0,0 +1,20 @@
+/**
+ * @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/src/ngtsc/core/api", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/src/ngtsc/core/api.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG","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\n/**\n * A host backed by a build system which has a unified view of the module namespace.\n *\n * Such a build system supports the `fileNameToModuleName` method provided by certain build system\n * integrations (such as the integration with Bazel). See the docs on `fileNameToModuleName` for\n * more details.\n */\nexport interface UnifiedModulesHost {\n  /**\n   * Converts a file path to a module name that can be used as an `import ...`.\n   *\n   * For example, such a host might determine that `/absolute/path/to/monorepo/lib/importedFile.ts`\n   * should be imported using a module specifier of `monorepo/lib/importedFile`.\n   */\n  fileNameToModuleName(importedFilePath: string, containingFilePath: string): string;\n}\n\n/**\n * A host which additionally tracks and produces \"resources\" (HTML templates, CSS\n * files, etc).\n */\nexport interface ResourceHost {\n  /**\n   * Converts a file path for a resource that is used in a source file or another resource\n   * into a filepath.\n   */\n  resourceNameToFileName(resourceName: string, containingFilePath: string): string|null;\n\n  /**\n   * Load a referenced resource either statically or asynchronously. If the host returns a\n   * `Promise<string>` it is assumed the user of the corresponding `Program` will call\n   * `loadNgStructureAsync()`. Returning  `Promise<string>` outside `loadNgStructureAsync()` will\n   * cause a diagnostics diagnostic error or an exception to be thrown.\n   */\n  readResource(fileName: string): Promise<string>|string;\n\n  /**\n   * Get the absolute paths to the changed files that triggered the current compilation\n   * or `undefined` if this is not an incremental build.\n   */\n  getModifiedResourceFiles?(): Set<string>|undefined;\n}\n\n/**\n * A `ts.CompilerHost` interface which supports some number of optional methods in addition to the\n * core interface.\n */\nexport interface ExtendedTsCompilerHost extends ts.CompilerHost, Partial<ResourceHost>,\n    Partial<UnifiedModulesHost> {}\n\n/**\n * Options supported by the legacy View Engine compiler, which are still consumed by the Angular Ivy\n * compiler for backwards compatibility.\n *\n * These are expected to be removed at some point in the future.\n */\nexport interface LegacyNgcOptions {\n  /** generate all possible generated files  */\n  allowEmptyCodegenFiles?: boolean;\n\n  /**\n   * Whether to type check the entire template.\n   *\n   * This flag currently controls a couple aspects of template type-checking, including\n   * whether embedded views are checked.\n   *\n   * For maximum type-checking, set this to `true`, and set `strictTemplates` to `true`.\n   *\n   * It is an error for this flag to be `false`, while `strictTemplates` is set to `true`.\n   */\n  fullTemplateTypeCheck?: boolean;\n\n  /**\n   * Whether to generate a flat module index of the given name and the corresponding\n   * flat module metadata. This option is intended to be used when creating flat\n   * modules similar to how `@angular/core` and `@angular/common` are packaged.\n   * When this option is used the `package.json` for the library should refer to the\n   * generated flat module index instead of the library index file. When using this\n   * option only one .metadata.json file is produced that contains all the metadata\n   * necessary for symbols exported from the library index.\n   * In the generated .ngfactory.ts files flat module index is used to import symbols\n   * including both the public API from the library index as well as shrowded internal\n   * symbols.\n   * By default the .ts file supplied in the `files` field is assumed to be the\n   * library index. If more than one is specified, uses `libraryIndex` to select the\n   * file to use. If more than one .ts file is supplied and no `libraryIndex` is supplied\n   * an error is produced.\n   * A flat module index .d.ts and .js will be created with the given `flatModuleOutFile`\n   * name in the same location as the library index .d.ts file is emitted.\n   * For example, if a library uses `public_api.ts` file as the library index of the\n   * module the `tsconfig.json` `files` field would be `[\"public_api.ts\"]`. The\n   * `flatModuleOutFile` options could then be set to, for example `\"index.js\"`, which\n   * produces `index.d.ts` and  `index.metadata.json` files. The library's\n   * `package.json`'s `module` field would be `\"index.js\"` and the `typings` field would\n   * be `\"index.d.ts\"`.\n   */\n  flatModuleOutFile?: string;\n\n  /**\n   * Preferred module id to use for importing flat module. References generated by `ngc`\n   * will use this module name when importing symbols from the flat module. This is only\n   * meaningful when `flatModuleOutFile` is also supplied. It is otherwise ignored.\n   */\n  flatModuleId?: string;\n\n  /**\n   * Always report errors a parameter is supplied whose injection type cannot\n   * be determined. When this value option is not provided or is `false`, constructor\n   * parameters of classes marked with `@Injectable` whose type cannot be resolved will\n   * produce a warning. With this option `true`, they produce an error. When this option is\n   * not provided is treated as if it were `false`.\n   */\n  strictInjectionParameters?: boolean;\n\n  /**\n   * Whether to remove blank text nodes from compiled templates. It is `false` by default starting\n   * from Angular 6.\n   */\n  preserveWhitespaces?: boolean;\n}\n\n/**\n * Options which were added to the Angular Ivy compiler to support backwards compatibility with\n * existing View Engine applications.\n *\n * These are expected to be removed at some point in the future.\n */\nexport interface NgcCompatibilityOptions {\n  /**\n   * Controls whether ngtsc will emit `.ngfactory.js` shims for each compiled `.ts` file.\n   *\n   * These shims support legacy imports from `ngfactory` files, by exporting a factory shim\n   * for each component or NgModule in the original `.ts` file.\n   */\n  generateNgFactoryShims?: boolean;\n\n  /**\n   * Controls whether ngtsc will emit `.ngsummary.js` shims for each compiled `.ts` file.\n   *\n   * These shims support legacy imports from `ngsummary` files, by exporting an empty object\n   * for each NgModule in the original `.ts` file. The only purpose of summaries is to feed them to\n   * `TestBed`, which is a no-op in Ivy.\n   */\n  generateNgSummaryShims?: boolean;\n\n  /**\n   * Tells the compiler to generate definitions using the Render3 style code generation.\n   * This option defaults to `true`.\n   *\n   * Acceptable values are as follows:\n   *\n   * `false` - run ngc normally\n   * `true` - run the ngtsc compiler instead of the normal ngc compiler\n   * `ngtsc` - alias for `true`\n   */\n  enableIvy?: boolean|'ngtsc';\n}\n\n/**\n * Options related to template type-checking and its strictness.\n */\nexport interface StrictTemplateOptions {\n  /**\n   * If `true`, implies all template strictness flags below (unless individually disabled).\n   *\n   * Has no effect unless `fullTemplateTypeCheck` is also enabled.\n   *\n   * Defaults to `false`, even if \"fullTemplateTypeCheck\" is set.\n   */\n  strictTemplates?: boolean;\n\n\n  /**\n   * Whether to check the type of a binding to a directive/component input against the type of the\n   * field on the directive/component.\n   *\n   * For example, if this is `false` then the expression `[input]=\"expr\"` will have `expr` type-\n   * checked, but not the assignment of the resulting type to the `input` property of whichever\n   * directive or component is receiving the binding. If set to `true`, both sides of the assignment\n   * are checked.\n   *\n   * Defaults to `false`, even if \"fullTemplateTypeCheck\" is set.\n   */\n  strictInputTypes?: boolean;\n\n  /**\n   * Whether to use strict null types for input bindings for directives.\n   *\n   * If this is `true`, applications that are compiled with TypeScript's `strictNullChecks` enabled\n   * will produce type errors for bindings which can evaluate to `undefined` or `null` where the\n   * inputs's type does not include `undefined` or `null` in its type. If set to `false`, all\n   * binding expressions are wrapped in a non-null assertion operator to effectively disable strict\n   * null checks.\n   *\n   * Defaults to `false`, even if \"fullTemplateTypeCheck\" is set. Note that if `strictInputTypes` is\n   * not set, or set to `false`, this flag has no effect.\n   */\n  strictNullInputTypes?: boolean;\n\n  /**\n   * Whether to check text attributes that happen to be consumed by a directive or component.\n   *\n   * For example, in a template containing `<input matInput disabled>` the `disabled` attribute ends\n   * up being consumed as an input with type `boolean` by the `matInput` directive. At runtime, the\n   * input will be set to the attribute's string value, which is an empty string for attributes\n   * without a value, so with this flag set to `true`, an error would be reported. If set to\n   * `false`, text attributes will never report an error.\n   *\n   * Defaults to `false`, even if \"fullTemplateTypeCheck\" is set. Note that if `strictInputTypes` is\n   * not set, or set to `false`, this flag has no effect.\n   */\n  strictAttributeTypes?: boolean;\n\n  /**\n   * Whether to use a strict type for null-safe navigation operations.\n   *\n   * If this is `false`, then the return type of `a?.b` or `a?()` will be `any`. If set to `true`,\n   * then the return type of `a?.b` for example will be the same as the type of the ternary\n   * expression `a != null ? a.b : a`.\n   *\n   * Defaults to `false`, even if \"fullTemplateTypeCheck\" is set.\n   */\n  strictSafeNavigationTypes?: boolean;\n\n  /**\n   * Whether to infer the type of local references.\n   *\n   * If this is `true`, the type of a `#ref` variable on a DOM node in the template will be\n   * determined by the type of `document.createElement` for the given DOM node. If set to `false`,\n   * the type of `ref` for DOM nodes will be `any`.\n   *\n   * Defaults to `false`, even if \"fullTemplateTypeCheck\" is set.\n   */\n  strictDomLocalRefTypes?: boolean;\n\n  /**\n   * Whether to infer the type of the `$event` variable in event bindings for directive outputs or\n   * animation events.\n   *\n   * If this is `true`, the type of `$event` will be inferred based on the generic type of\n   * `EventEmitter`/`Subject` of the output. If set to `false`, the `$event` variable will be of\n   * type `any`.\n   *\n   * Defaults to `false`, even if \"fullTemplateTypeCheck\" is set.\n   */\n  strictOutputEventTypes?: boolean;\n\n  /**\n   * Whether to infer the type of the `$event` variable in event bindings to DOM events.\n   *\n   * If this is `true`, the type of `$event` will be inferred based on TypeScript's\n   * `HTMLElementEventMap`, with a fallback to the native `Event` type. If set to `false`, the\n   * `$event` variable will be of type `any`.\n   *\n   * Defaults to `false`, even if \"fullTemplateTypeCheck\" is set.\n   */\n  strictDomEventTypes?: boolean;\n\n  /**\n   * Whether to include the generic type of components when type-checking the template.\n   *\n   * If no component has generic type parameters, this setting has no effect.\n   *\n   * If a component has generic type parameters and this setting is `true`, those generic parameters\n   * will be included in the context type for the template. If `false`, any generic parameters will\n   * be set to `any` in the template context type.\n   *\n   * Defaults to `false`, even if \"fullTemplateTypeCheck\" is set.\n   */\n  strictContextGenerics?: boolean;\n}\n\n/**\n * Options which control behavior useful for \"monorepo\" build cases using Bazel (such as the\n * internal Google monorepo, g3).\n */\nexport interface BazelAndG3Options {\n  /**\n   * Enables the generation of alias re-exports of directives/pipes that are visible from an\n   * NgModule from that NgModule's file.\n   *\n   * This option should be disabled for application builds or for Angular Package Format libraries\n   * (where NgModules along with their directives/pipes are exported via a single entrypoint).\n   *\n   * For other library compilations which are intended to be path-mapped into an application build\n   * (or another library), enabling this option enables the resulting deep imports to work\n   * correctly.\n   *\n   * A consumer of such a path-mapped library will write an import like:\n   *\n   * ```typescript\n   * import {LibModule} from 'lib/deep/path/to/module';\n   * ```\n   *\n   * The compiler will attempt to generate imports of directives/pipes from that same module\n   * specifier (the compiler does not rewrite the user's given import path, unlike View Engine).\n   *\n   * ```typescript\n   * import {LibDir, LibCmp, LibPipe} from 'lib/deep/path/to/module';\n   * ```\n   *\n   * It would be burdensome for users to have to re-export all directives/pipes alongside each\n   * NgModule to support this import model. Enabling this option tells the compiler to generate\n   * private re-exports alongside the NgModule of all the directives/pipes it makes available, to\n   * support these future imports.\n   */\n  generateDeepReexports?: boolean;\n\n  /**\n   * Insert JSDoc type annotations needed by Closure Compiler\n   */\n  annotateForClosureCompiler?: boolean;\n}\n\n/**\n * Options related to i18n compilation support.\n */\nexport interface I18nOptions {\n  /**\n   * Locale of the imported translations\n   */\n  i18nInLocale?: string;\n\n  /**\n   * Render `$localize` messages with legacy format ids.\n   *\n   * This is only active if we are building with `enableIvy: true`.\n   * The default value for now is `true`.\n   *\n   * Use this option when use are using the `$localize` based localization messages but\n   * have not migrated the translation files to use the new `$localize` message id format.\n   */\n  enableI18nLegacyMessageIdFormat?: boolean;\n\n  /**\n   * Whether translation variable name should contain external message id\n   * (used by Closure Compiler's output of `goog.getMsg` for transition period)\n   */\n  i18nUseExternalIds?: boolean;\n}\n\n/**\n * Non-public options which are useful during testing of the compiler.\n */\nexport interface TestOnlyOptions {\n  /**\n   * Whether to use the CompilerHost's fileNameToModuleName utility (if available) to generate\n   * import module specifiers. This is false by default, and exists to support running ngtsc\n   * within Google. This option is internal and is used by the ng_module.bzl rule to switch\n   * behavior between Bazel and Blaze.\n   *\n   * @internal\n   */\n  _useHostForImportGeneration?: boolean;\n\n  /**\n   * Turn on template type-checking in the Ivy compiler.\n   *\n   * This is an internal flag being used to roll out template type-checking in ngtsc. Turning it on\n   * by default before it's ready might break other users attempting to test the new compiler's\n   * behavior.\n   *\n   * @internal\n   */\n  ivyTemplateTypeCheck?: boolean;\n}\n\n/**\n * A merged interface of all of the various Angular compiler options, as well as the standard\n * `ts.CompilerOptions`.\n *\n * Also includes a few miscellaneous options.\n */\nexport interface NgCompilerOptions extends ts.CompilerOptions, LegacyNgcOptions, BazelAndG3Options,\n    NgcCompatibilityOptions, StrictTemplateOptions, TestOnlyOptions, I18nOptions {\n  /**\n   * Whether the compiler should avoid generating code for classes that haven't been exported.\n   * This is only active when building with `enableIvy: true`. Defaults to `true`.\n   */\n  compileNonExportedClasses?: boolean;\n\n  /**\n   * Whether to remove blank text nodes from compiled templates. It is `false` by default starting\n   * from Angular 6.\n   */\n  preserveWhitespaces?: boolean;\n\n  /**\n   * Disable TypeScript Version Check.\n   */\n  disableTypeScriptVersionCheck?: boolean;\n\n  /** An option to enable ngtsc's internal performance tracing.\n   *\n   * This should be a path to a JSON file where trace information will be written. An optional 'ts:'\n   * prefix will cause the trace to be written via the TS host instead of directly to the filesystem\n   * (not all hosts support this mode of operation).\n   *\n   * This is currently not exposed to users as the trace format is still unstable.\n   */\n  tracePerformance?: string;\n}\n\nexport interface LazyRoute {\n  route: string;\n  module: {name: string, filePath: string};\n  referencedModule: {name: string, filePath: string};\n}\n"]}

package/src/ngtsc/core/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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/src/ngtsc/core" />
+export { NgCompiler } from './src/compiler';
+export { NgCompilerHost } from './src/host';

package/src/ngtsc/core/index.js

@@ -0,0 +1,24 @@
+/**
+ * @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/src/ngtsc/core", ["require", "exports", "@angular/compiler-cli/src/ngtsc/core/src/compiler", "@angular/compiler-cli/src/ngtsc/core/src/host"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var compiler_1 = require("@angular/compiler-cli/src/ngtsc/core/src/compiler");
+    exports.NgCompiler = compiler_1.NgCompiler;
+    var host_1 = require("@angular/compiler-cli/src/ngtsc/core/src/host");
+    exports.NgCompilerHost = host_1.NgCompilerHost;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL2NvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7Ozs7SUFFSCw4RUFBMEM7SUFBbEMsZ0NBQUEsVUFBVSxDQUFBO0lBQ2xCLHNFQUEwQztJQUFsQyxnQ0FBQSxjQUFjLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCB7TmdDb21waWxlcn0gZnJvbSAnLi9zcmMvY29tcGlsZXInO1xuZXhwb3J0IHtOZ0NvbXBpbGVySG9zdH0gZnJvbSAnLi9zcmMvaG9zdCc7XG4iXX0=

package/src/ngtsc/core/src/compiler.d.ts

@@ -0,0 +1,120 @@
+/**
+ * @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/src/ngtsc/core/src/compiler" />
+import * as ts from 'typescript';
+import { IncrementalDriver } from '../../incremental';
+import { IndexedComponent } from '../../indexer';
+import { PerfRecorder } from '../../perf';
+import { LazyRoute, NgCompilerOptions } from '../api';
+import { NgCompilerHost } from './host';
+/**
+ * The heart of the Angular Ivy compiler.
+ *
+ * The `NgCompiler` provides an API for performing Angular compilation within a custom TypeScript
+ * compiler. Each instance of `NgCompiler` supports a single compilation, which might be
+ * incremental.
+ *
+ * `NgCompiler` is lazy, and does not perform any of the work of the compilation until one of its
+ * output methods (e.g. `getDiagnostics`) is called.
+ *
+ * See the README.md for more information.
+ */
+export declare class NgCompiler {
+    private host;
+    private options;
+    private tsProgram;
+    private perfRecorder;
+    /**
+     * Lazily evaluated state of the compilation.
+     *
+     * This is created on demand by calling `ensureAnalyzed`.
+     */
+    private compilation;
+    /**
+     * Any diagnostics related to the construction of the compilation.
+     *
+     * These are diagnostics which arose during setup of the host and/or program.
+     */
+    private constructionDiagnostics;
+    /**
+     * Semantic diagnostics related to the program itself.
+     *
+     * This is set by (and memoizes) `getDiagnostics`.
+     */
+    private diagnostics;
+    private closureCompilerEnabled;
+    private typeCheckFile;
+    private nextProgram;
+    private entryPoint;
+    private moduleResolver;
+    private resourceManager;
+    private cycleAnalyzer;
+    readonly incrementalDriver: IncrementalDriver;
+    constructor(host: NgCompilerHost, options: NgCompilerOptions, tsProgram: ts.Program, oldProgram?: ts.Program | null, perfRecorder?: PerfRecorder);
+    /**
+     * Get all Angular-related diagnostics for this compilation.
+     *
+     * If a `ts.SourceFile` is passed, only diagnostics related to that file are returned.
+     */
+    getDiagnostics(file?: ts.SourceFile): ts.Diagnostic[];
+    /**
+     * Get all setup-related diagnostics for this compilation.
+     */
+    getOptionDiagnostics(): ts.Diagnostic[];
+    /**
+     * Get the `ts.Program` to use as a starting point when spawning a subsequent incremental
+     * compilation.
+     *
+     * The `NgCompiler` spawns an internal incremental TypeScript compilation (inheriting the
+     * consumer's `ts.Program` into a new one for the purposes of template type-checking). After this
+     * operation, the consumer's `ts.Program` is no longer usable for starting a new incremental
+     * compilation. `getNextProgram` retrieves the `ts.Program` which can be used instead.
+     */
+    getNextProgram(): ts.Program;
+    /**
+     * Perform Angular's analysis step (as a precursor to `getDiagnostics` or `prepareEmit`)
+     * asynchronously.
+     *
+     * Normally, this operation happens lazily whenever `getDiagnostics` or `prepareEmit` are called.
+     * However, certain consumers may wish to allow for an asynchronous phase of analysis, where
+     * resources such as `styleUrls` are resolved asynchonously. In these cases `analyzeAsync` must be
+     * called first, and its `Promise` awaited prior to calling any other APIs of `NgCompiler`.
+     */
+    analyzeAsync(): Promise<void>;
+    /**
+     * List lazy routes detected during analysis.
+     *
+     * This can be called for one specific route, or to retrieve all top-level routes.
+     */
+    listLazyRoutes(entryRoute?: string): LazyRoute[];
+    /**
+     * Fetch transformers and other information which is necessary for a consumer to `emit` the
+     * program with Angular-added definitions.
+     */
+    prepareEmit(): {
+        transformers: ts.CustomTransformers;
+        ignoreFiles: Set<ts.SourceFile>;
+    };
+    /**
+     * Run the indexing process and return a `Map` of all indexed components.
+     *
+     * See the `indexing` package for more details.
+     */
+    getIndexedComponents(): Map<ts.Declaration, IndexedComponent>;
+    private ensureAnalyzed;
+    private analyzeSync;
+    private resolveCompilation;
+    private getTemplateDiagnostics;
+    /**
+     * Reifies the inter-dependencies of NgModules and the components within their compilation scopes
+     * into the `IncrementalDriver`'s dependency graph.
+     */
+    private recordNgModuleScopeDependencies;
+    private scanForMwp;
+    private makeCompilation;
+}