@angular/compiler-cli 10.1.0-rc.0 → 10.1.3

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

@@ -10,7 +10,7 @@ import { BoundTarget, DirectiveMeta, SchemaMetadata } from '@angular/compiler';
 import * as ts from 'typescript';
 import { AbsoluteFsPath } from '../../file_system';
 import { Reference } from '../../imports';
-import { DirectiveTypeCheckMeta } from '../../metadata';
+import { ClassPropertyMapping, DirectiveTypeCheckMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
 /**
  * Extension of `DirectiveMeta` that includes additional information required to type-check the
@@ -19,6 +19,8 @@ import { ClassDeclaration } from '../../reflection';
 export interface TypeCheckableDirectiveMeta extends DirectiveMeta, DirectiveTypeCheckMeta {
     ref: Reference<ClassDeclaration>;
     queries: string[];
+    inputs: ClassPropertyMapping;
+    outputs: ClassPropertyMapping;
 }
 export declare type TemplateId = string & {
     __brand: 'TemplateId';

package/src/ngtsc/typecheck/api/api.js

@@ -32,4 +32,4 @@
         UpdateMode[UpdateMode["Incremental"] = 1] = "Incremental";
     })(UpdateMode = exports.UpdateMode || (exports.UpdateMode = {}));
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/api/api.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;IAmUH,IAAY,UAaX;IAbD,WAAY,UAAU;QACpB;;;;WAIG;QACH,mDAAQ,CAAA;QAER;;;WAGG;QACH,yDAAW,CAAA;IACb,CAAC,EAbW,UAAU,GAAV,kBAAU,KAAV,kBAAU,QAarB","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 {BoundTarget, DirectiveMeta, SchemaMetadata} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {AbsoluteFsPath} from '../../file_system';\nimport {Reference} from '../../imports';\nimport {DirectiveTypeCheckMeta} from '../../metadata';\nimport {ClassDeclaration} from '../../reflection';\n\n\n/**\n * Extension of `DirectiveMeta` that includes additional information required to type-check the\n * usage of a particular directive.\n */\nexport interface TypeCheckableDirectiveMeta extends DirectiveMeta, DirectiveTypeCheckMeta {\n  ref: Reference<ClassDeclaration>;\n  queries: string[];\n}\n\nexport type TemplateId = string&{__brand: 'TemplateId'};\n\n/**\n * Metadata required in addition to a component class in order to generate a type check block (TCB)\n * for that component.\n */\nexport interface TypeCheckBlockMetadata {\n  /**\n   * A unique identifier for the class which gave rise to this TCB.\n   *\n   * This can be used to map errors back to the `ts.ClassDeclaration` for the component.\n   */\n  id: TemplateId;\n\n  /**\n   * Semantic information about the template of the component.\n   */\n  boundTarget: BoundTarget<TypeCheckableDirectiveMeta>;\n\n  /*\n   * Pipes used in the template of the component.\n   */\n  pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>;\n\n  /**\n   * Schemas that apply to this template.\n   */\n  schemas: SchemaMetadata[];\n}\n\nexport interface TypeCtorMetadata {\n  /**\n   * The name of the requested type constructor function.\n   */\n  fnName: string;\n\n  /**\n   * Whether to generate a body for the function or not.\n   */\n  body: boolean;\n\n  /**\n   * Input, output, and query field names in the type which should be included as constructor input.\n   */\n  fields: {inputs: string[]; outputs: string[]; queries: string[];};\n\n  /**\n   * `Set` of field names which have type coercion enabled.\n   */\n  coercedInputFields: Set<string>;\n}\n\nexport interface TypeCheckingConfig {\n  /**\n   * Whether to check the left-hand side type of binding operations.\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   * This flag only affects bindings to components/directives. Bindings to the DOM are checked if\n   * `checkTypeOfDomBindings` is set.\n   */\n  checkTypeOfInputBindings: boolean;\n\n  /**\n   * Whether to honor the access modifiers on input bindings for the component/directive.\n   *\n   * If a template binding attempts to assign to an input that is private/protected/readonly,\n   * this will produce errors when enabled but will not when disabled.\n   */\n  honorAccessModifiersForInputBindings: 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. This may be particularly useful when the directive is from a library that is not\n   * compiled with `strictNullChecks` enabled.\n   *\n   * If `checkTypeOfInputBindings` is set to `false`, this flag has no effect.\n   */\n  strictNullInputBindings: 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   * Note that if `checkTypeOfInputBindings` is set to `false`, this flag has no effect.\n   */\n  checkTypeOfAttributes: boolean;\n\n  /**\n   * Whether to check the left-hand side type of binding operations to DOM properties.\n   *\n   * As `checkTypeOfBindings`, but only applies to bindings to DOM properties.\n   *\n   * This does not affect the use of the `DomSchemaChecker` to validate the template against the DOM\n   * schema. Rather, this flag is an experimental, not yet complete feature which uses the\n   * lib.dom.d.ts DOM typings in TypeScript to validate that DOM bindings are of the correct type\n   * for assignability to the underlying DOM element properties.\n   */\n  checkTypeOfDomBindings: 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  checkTypeOfOutputEvents: boolean;\n\n  /**\n   * Whether to infer the type of the `$event` variable in event bindings for animations.\n   *\n   * If this is `true`, the type of `$event` will be `AnimationEvent` from `@angular/animations`.\n   * If set to `false`, the `$event` variable will be of type `any`.\n   */\n  checkTypeOfAnimationEvents: 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  checkTypeOfDomEvents: boolean;\n\n  /**\n   * Whether to infer the type of local references to DOM elements.\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 type. If set to\n   * `false`, the type of `ref` for DOM nodes will be `any`.\n   */\n  checkTypeOfDomReferences: boolean;\n\n\n  /**\n   * Whether to infer the type of local references.\n   *\n   * If this is `true`, the type of a `#ref` variable that points to a directive or `TemplateRef` in\n   * the template will be inferred correctly. If set to `false`, the type of `ref` for will be\n   * `any`.\n   */\n  checkTypeOfNonDomReferences: boolean;\n\n  /**\n   * Whether to include type information from pipes in the type-checking operation.\n   *\n   * If this is `true`, then the pipe's type signature for `transform()` will be used to check the\n   * usage of the pipe. If this is `false`, then the result of applying a pipe will be `any`, and\n   * the types of the pipe's value and arguments will not be matched against the `transform()`\n   * method.\n   */\n  checkTypeOfPipes: boolean;\n\n  /**\n   * Whether to narrow the types of template contexts.\n   */\n  applyTemplateContextGuards: 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  strictSafeNavigationTypes: boolean;\n\n  /**\n   * Whether to descend into template bodies and check any bindings there.\n   */\n  checkTemplateBodies: boolean;\n\n  /**\n   * Whether to check resolvable queries.\n   *\n   * This is currently an unsupported feature.\n   */\n  checkQueries: false;\n\n  /**\n   * Whether to use any generic types of the context component.\n   *\n   * If this is `true`, then if the context component has generic types, those will be mirrored in\n   * the template type-checking context. If `false`, any generic type parameters of the context\n   * component will be set to `any` during type-checking.\n   */\n  useContextGenericType: boolean;\n\n  /**\n   * Whether or not to infer types for object and array literals in the template.\n   *\n   * If this is `true`, then the type of an object or an array literal in the template will be the\n   * same type that TypeScript would infer if the literal appeared in code. If `false`, then such\n   * literals are cast to `any` when declared.\n   */\n  strictLiteralTypes: boolean;\n}\n\n\nexport type TemplateSourceMapping =\n    DirectTemplateSourceMapping|IndirectTemplateSourceMapping|ExternalTemplateSourceMapping;\n\n/**\n * A mapping to an inline template in a TS file.\n *\n * `ParseSourceSpan`s for this template should be accurate for direct reporting in a TS error\n * message.\n */\nexport interface DirectTemplateSourceMapping {\n  type: 'direct';\n  node: ts.StringLiteral|ts.NoSubstitutionTemplateLiteral;\n}\n\n/**\n * A mapping to a template which is still in a TS file, but where the node positions in any\n * `ParseSourceSpan`s are not accurate for one reason or another.\n *\n * This can occur if the template expression was interpolated in a way where the compiler could not\n * construct a contiguous mapping for the template string. The `node` refers to the `template`\n * expression.\n */\nexport interface IndirectTemplateSourceMapping {\n  type: 'indirect';\n  componentClass: ClassDeclaration;\n  node: ts.Expression;\n  template: string;\n}\n\n/**\n * A mapping to a template declared in an external HTML file, where node positions in\n * `ParseSourceSpan`s represent accurate offsets into the external file.\n *\n * In this case, the given `node` refers to the `templateUrl` expression.\n */\nexport interface ExternalTemplateSourceMapping {\n  type: 'external';\n  componentClass: ClassDeclaration;\n  node: ts.Expression;\n  template: string;\n  templateUrl: string;\n}\n\n/**\n * Abstracts the operation of determining which shim file will host a particular component's\n * template type-checking code.\n *\n * Different consumers of the type checking infrastructure may choose different approaches to\n * optimize for their specific use case (for example, the command-line compiler optimizes for\n * efficient `ts.Program` reuse in watch mode).\n */\nexport interface ComponentToShimMappingStrategy {\n  /**\n   * Given a component, determine a path to the shim file into which that component's type checking\n   * code will be generated.\n   *\n   * A major constraint is that components in different input files must not share the same shim\n   * file. The behavior of the template type-checking system is undefined if this is violated.\n   */\n  shimPathForComponent(node: ts.ClassDeclaration): AbsoluteFsPath;\n}\n\n/**\n * Strategy used to manage a `ts.Program` which contains template type-checking code and update it\n * over time.\n *\n * This abstraction allows both the Angular compiler itself as well as the language service to\n * implement efficient template type-checking using common infrastructure.\n */\nexport interface TypeCheckingProgramStrategy extends ComponentToShimMappingStrategy {\n  /**\n   * Whether this strategy supports modifying user files (inline modifications) in addition to\n   * modifying type-checking shims.\n   */\n  readonly supportsInlineOperations: boolean;\n\n  /**\n   * Retrieve the latest version of the program, containing all the updates made thus far.\n   */\n  getProgram(): ts.Program;\n\n  /**\n   * Incorporate a set of changes to either augment or completely replace the type-checking code\n   * included in the type-checking program.\n   */\n  updateFiles(contents: Map<AbsoluteFsPath, string>, updateMode: UpdateMode): void;\n}\n\nexport enum UpdateMode {\n  /**\n   * A complete update creates a completely new overlay of type-checking code on top of the user's\n   * original program, which doesn't include type-checking code from previous calls to\n   * `updateFiles`.\n   */\n  Complete,\n\n  /**\n   * An incremental update changes the contents of some files in the type-checking program without\n   * reverting any prior changes.\n   */\n  Incremental,\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/api/api.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;IAqUH,IAAY,UAaX;IAbD,WAAY,UAAU;QACpB;;;;WAIG;QACH,mDAAQ,CAAA;QAER;;;WAGG;QACH,yDAAW,CAAA;IACb,CAAC,EAbW,UAAU,GAAV,kBAAU,KAAV,kBAAU,QAarB","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 {BoundTarget, DirectiveMeta, SchemaMetadata} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {AbsoluteFsPath} from '../../file_system';\nimport {Reference} from '../../imports';\nimport {ClassPropertyMapping, DirectiveTypeCheckMeta} from '../../metadata';\nimport {ClassDeclaration} from '../../reflection';\n\n\n/**\n * Extension of `DirectiveMeta` that includes additional information required to type-check the\n * usage of a particular directive.\n */\nexport interface TypeCheckableDirectiveMeta extends DirectiveMeta, DirectiveTypeCheckMeta {\n  ref: Reference<ClassDeclaration>;\n  queries: string[];\n  inputs: ClassPropertyMapping;\n  outputs: ClassPropertyMapping;\n}\n\nexport type TemplateId = string&{__brand: 'TemplateId'};\n\n/**\n * Metadata required in addition to a component class in order to generate a type check block (TCB)\n * for that component.\n */\nexport interface TypeCheckBlockMetadata {\n  /**\n   * A unique identifier for the class which gave rise to this TCB.\n   *\n   * This can be used to map errors back to the `ts.ClassDeclaration` for the component.\n   */\n  id: TemplateId;\n\n  /**\n   * Semantic information about the template of the component.\n   */\n  boundTarget: BoundTarget<TypeCheckableDirectiveMeta>;\n\n  /*\n   * Pipes used in the template of the component.\n   */\n  pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>;\n\n  /**\n   * Schemas that apply to this template.\n   */\n  schemas: SchemaMetadata[];\n}\n\nexport interface TypeCtorMetadata {\n  /**\n   * The name of the requested type constructor function.\n   */\n  fnName: string;\n\n  /**\n   * Whether to generate a body for the function or not.\n   */\n  body: boolean;\n\n  /**\n   * Input, output, and query field names in the type which should be included as constructor input.\n   */\n  fields: {inputs: string[]; outputs: string[]; queries: string[];};\n\n  /**\n   * `Set` of field names which have type coercion enabled.\n   */\n  coercedInputFields: Set<string>;\n}\n\nexport interface TypeCheckingConfig {\n  /**\n   * Whether to check the left-hand side type of binding operations.\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   * This flag only affects bindings to components/directives. Bindings to the DOM are checked if\n   * `checkTypeOfDomBindings` is set.\n   */\n  checkTypeOfInputBindings: boolean;\n\n  /**\n   * Whether to honor the access modifiers on input bindings for the component/directive.\n   *\n   * If a template binding attempts to assign to an input that is private/protected/readonly,\n   * this will produce errors when enabled but will not when disabled.\n   */\n  honorAccessModifiersForInputBindings: 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. This may be particularly useful when the directive is from a library that is not\n   * compiled with `strictNullChecks` enabled.\n   *\n   * If `checkTypeOfInputBindings` is set to `false`, this flag has no effect.\n   */\n  strictNullInputBindings: 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   * Note that if `checkTypeOfInputBindings` is set to `false`, this flag has no effect.\n   */\n  checkTypeOfAttributes: boolean;\n\n  /**\n   * Whether to check the left-hand side type of binding operations to DOM properties.\n   *\n   * As `checkTypeOfBindings`, but only applies to bindings to DOM properties.\n   *\n   * This does not affect the use of the `DomSchemaChecker` to validate the template against the DOM\n   * schema. Rather, this flag is an experimental, not yet complete feature which uses the\n   * lib.dom.d.ts DOM typings in TypeScript to validate that DOM bindings are of the correct type\n   * for assignability to the underlying DOM element properties.\n   */\n  checkTypeOfDomBindings: 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  checkTypeOfOutputEvents: boolean;\n\n  /**\n   * Whether to infer the type of the `$event` variable in event bindings for animations.\n   *\n   * If this is `true`, the type of `$event` will be `AnimationEvent` from `@angular/animations`.\n   * If set to `false`, the `$event` variable will be of type `any`.\n   */\n  checkTypeOfAnimationEvents: 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  checkTypeOfDomEvents: boolean;\n\n  /**\n   * Whether to infer the type of local references to DOM elements.\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 type. If set to\n   * `false`, the type of `ref` for DOM nodes will be `any`.\n   */\n  checkTypeOfDomReferences: boolean;\n\n\n  /**\n   * Whether to infer the type of local references.\n   *\n   * If this is `true`, the type of a `#ref` variable that points to a directive or `TemplateRef` in\n   * the template will be inferred correctly. If set to `false`, the type of `ref` for will be\n   * `any`.\n   */\n  checkTypeOfNonDomReferences: boolean;\n\n  /**\n   * Whether to include type information from pipes in the type-checking operation.\n   *\n   * If this is `true`, then the pipe's type signature for `transform()` will be used to check the\n   * usage of the pipe. If this is `false`, then the result of applying a pipe will be `any`, and\n   * the types of the pipe's value and arguments will not be matched against the `transform()`\n   * method.\n   */\n  checkTypeOfPipes: boolean;\n\n  /**\n   * Whether to narrow the types of template contexts.\n   */\n  applyTemplateContextGuards: 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  strictSafeNavigationTypes: boolean;\n\n  /**\n   * Whether to descend into template bodies and check any bindings there.\n   */\n  checkTemplateBodies: boolean;\n\n  /**\n   * Whether to check resolvable queries.\n   *\n   * This is currently an unsupported feature.\n   */\n  checkQueries: false;\n\n  /**\n   * Whether to use any generic types of the context component.\n   *\n   * If this is `true`, then if the context component has generic types, those will be mirrored in\n   * the template type-checking context. If `false`, any generic type parameters of the context\n   * component will be set to `any` during type-checking.\n   */\n  useContextGenericType: boolean;\n\n  /**\n   * Whether or not to infer types for object and array literals in the template.\n   *\n   * If this is `true`, then the type of an object or an array literal in the template will be the\n   * same type that TypeScript would infer if the literal appeared in code. If `false`, then such\n   * literals are cast to `any` when declared.\n   */\n  strictLiteralTypes: boolean;\n}\n\n\nexport type TemplateSourceMapping =\n    DirectTemplateSourceMapping|IndirectTemplateSourceMapping|ExternalTemplateSourceMapping;\n\n/**\n * A mapping to an inline template in a TS file.\n *\n * `ParseSourceSpan`s for this template should be accurate for direct reporting in a TS error\n * message.\n */\nexport interface DirectTemplateSourceMapping {\n  type: 'direct';\n  node: ts.StringLiteral|ts.NoSubstitutionTemplateLiteral;\n}\n\n/**\n * A mapping to a template which is still in a TS file, but where the node positions in any\n * `ParseSourceSpan`s are not accurate for one reason or another.\n *\n * This can occur if the template expression was interpolated in a way where the compiler could not\n * construct a contiguous mapping for the template string. The `node` refers to the `template`\n * expression.\n */\nexport interface IndirectTemplateSourceMapping {\n  type: 'indirect';\n  componentClass: ClassDeclaration;\n  node: ts.Expression;\n  template: string;\n}\n\n/**\n * A mapping to a template declared in an external HTML file, where node positions in\n * `ParseSourceSpan`s represent accurate offsets into the external file.\n *\n * In this case, the given `node` refers to the `templateUrl` expression.\n */\nexport interface ExternalTemplateSourceMapping {\n  type: 'external';\n  componentClass: ClassDeclaration;\n  node: ts.Expression;\n  template: string;\n  templateUrl: string;\n}\n\n/**\n * Abstracts the operation of determining which shim file will host a particular component's\n * template type-checking code.\n *\n * Different consumers of the type checking infrastructure may choose different approaches to\n * optimize for their specific use case (for example, the command-line compiler optimizes for\n * efficient `ts.Program` reuse in watch mode).\n */\nexport interface ComponentToShimMappingStrategy {\n  /**\n   * Given a component, determine a path to the shim file into which that component's type checking\n   * code will be generated.\n   *\n   * A major constraint is that components in different input files must not share the same shim\n   * file. The behavior of the template type-checking system is undefined if this is violated.\n   */\n  shimPathForComponent(node: ts.ClassDeclaration): AbsoluteFsPath;\n}\n\n/**\n * Strategy used to manage a `ts.Program` which contains template type-checking code and update it\n * over time.\n *\n * This abstraction allows both the Angular compiler itself as well as the language service to\n * implement efficient template type-checking using common infrastructure.\n */\nexport interface TypeCheckingProgramStrategy extends ComponentToShimMappingStrategy {\n  /**\n   * Whether this strategy supports modifying user files (inline modifications) in addition to\n   * modifying type-checking shims.\n   */\n  readonly supportsInlineOperations: boolean;\n\n  /**\n   * Retrieve the latest version of the program, containing all the updates made thus far.\n   */\n  getProgram(): ts.Program;\n\n  /**\n   * Incorporate a set of changes to either augment or completely replace the type-checking code\n   * included in the type-checking program.\n   */\n  updateFiles(contents: Map<AbsoluteFsPath, string>, updateMode: UpdateMode): void;\n}\n\nexport enum UpdateMode {\n  /**\n   * A complete update creates a completely new overlay of type-checking code on top of the user's\n   * original program, which doesn't include type-checking code from previous calls to\n   * `updateFiles`.\n   */\n  Complete,\n\n  /**\n   * An incremental update changes the contents of some files in the type-checking program without\n   * reverting any prior changes.\n   */\n  Incremental,\n}\n"]}

package/src/ngtsc/typecheck/diagnostics/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google LLC 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/typecheck/diagnostics" />
+export * from './src/diagnostic';
+export * from './src/id';

package/src/ngtsc/typecheck/diagnostics/index.js

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google LLC 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/typecheck/diagnostics", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/typecheck/diagnostics/src/diagnostic", "@angular/compiler-cli/src/ngtsc/typecheck/diagnostics/src/id"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    tslib_1.__exportStar(require("@angular/compiler-cli/src/ngtsc/typecheck/diagnostics/src/diagnostic"), exports);
+    tslib_1.__exportStar(require("@angular/compiler-cli/src/ngtsc/typecheck/diagnostics/src/id"), exports);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL3R5cGVjaGVjay9kaWFnbm9zdGljcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7Ozs7SUFFSCwrR0FBaUM7SUFDakMsdUdBQXlCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vc3JjL2RpYWdub3N0aWMnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMvaWQnO1xuIl19

package/src/ngtsc/typecheck/diagnostics/src/diagnostic.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright Google LLC 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/typecheck/diagnostics/src/diagnostic" />
+import { ParseSourceSpan } from '@angular/compiler';
+import * as ts from 'typescript';
+import { TemplateId, TemplateSourceMapping } from '../../api';
+/**
+ * A `ts.Diagnostic` with additional information about the diagnostic related to template
+ * type-checking.
+ */
+export interface TemplateDiagnostic extends ts.Diagnostic {
+    /**
+     * The component with the template that resulted in this diagnostic.
+     */
+    componentFile: ts.SourceFile;
+    /**
+     * The template id of the component that resulted in this diagnostic.
+     */
+    templateId: TemplateId;
+}
+/**
+ * Constructs a `ts.Diagnostic` for a given `ParseSourceSpan` within a template.
+ */
+export declare function makeTemplateDiagnostic(templateId: TemplateId, mapping: TemplateSourceMapping, span: ParseSourceSpan, category: ts.DiagnosticCategory, code: number, messageText: string | ts.DiagnosticMessageChain, relatedMessage?: {
+    text: string;
+    span: ParseSourceSpan;
+}): TemplateDiagnostic;
+export declare function isTemplateDiagnostic(diagnostic: ts.Diagnostic): diagnostic is TemplateDiagnostic;

package/src/ngtsc/typecheck/diagnostics/src/diagnostic.js

@@ -0,0 +1,114 @@
+/**
+ * @license
+ * Copyright Google LLC 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/typecheck/diagnostics/src/diagnostic", ["require", "exports", "typescript"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isTemplateDiagnostic = exports.makeTemplateDiagnostic = void 0;
+    var ts = require("typescript");
+    /**
+     * Constructs a `ts.Diagnostic` for a given `ParseSourceSpan` within a template.
+     */
+    function makeTemplateDiagnostic(templateId, mapping, span, category, code, messageText, relatedMessage) {
+        if (mapping.type === 'direct') {
+            var relatedInformation = undefined;
+            if (relatedMessage !== undefined) {
+                relatedInformation = [{
+                        category: ts.DiagnosticCategory.Message,
+                        code: 0,
+                        file: mapping.node.getSourceFile(),
+                        start: relatedMessage.span.start.offset,
+                        length: relatedMessage.span.end.offset - relatedMessage.span.start.offset,
+                        messageText: relatedMessage.text,
+                    }];
+            }
+            // For direct mappings, the error is shown inline as ngtsc was able to pinpoint a string
+            // constant within the `@Component` decorator for the template. This allows us to map the error
+            // directly into the bytes of the source file.
+            return {
+                source: 'ngtsc',
+                code: code,
+                category: category,
+                messageText: messageText,
+                file: mapping.node.getSourceFile(),
+                componentFile: mapping.node.getSourceFile(),
+                templateId: templateId,
+                start: span.start.offset,
+                length: span.end.offset - span.start.offset,
+                relatedInformation: relatedInformation,
+            };
+        }
+        else if (mapping.type === 'indirect' || mapping.type === 'external') {
+            // For indirect mappings (template was declared inline, but ngtsc couldn't map it directly
+            // to a string constant in the decorator), the component's file name is given with a suffix
+            // indicating it's not the TS file being displayed, but a template.
+            // For external temoplates, the HTML filename is used.
+            var componentSf = mapping.componentClass.getSourceFile();
+            var componentName = mapping.componentClass.name.text;
+            // TODO(alxhub): remove cast when TS in g3 supports this narrowing.
+            var fileName = mapping.type === 'indirect' ?
+                componentSf.fileName + " (" + componentName + " template)" :
+                mapping.templateUrl;
+            // TODO(alxhub): investigate creating a fake `ts.SourceFile` here instead of invoking the TS
+            // parser against the template (HTML is just really syntactically invalid TypeScript code ;).
+            // Also investigate caching the file to avoid running the parser multiple times.
+            var sf = ts.createSourceFile(fileName, mapping.template, ts.ScriptTarget.Latest, false, ts.ScriptKind.JSX);
+            var relatedInformation = [];
+            if (relatedMessage !== undefined) {
+                relatedInformation.push({
+                    category: ts.DiagnosticCategory.Message,
+                    code: 0,
+                    file: sf,
+                    start: relatedMessage.span.start.offset,
+                    length: relatedMessage.span.end.offset - relatedMessage.span.start.offset,
+                    messageText: relatedMessage.text,
+                });
+            }
+            relatedInformation.push({
+                category: ts.DiagnosticCategory.Message,
+                code: 0,
+                file: componentSf,
+                // mapping.node represents either the 'template' or 'templateUrl' expression. getStart()
+                // and getEnd() are used because they don't include surrounding whitespace.
+                start: mapping.node.getStart(),
+                length: mapping.node.getEnd() - mapping.node.getStart(),
+                messageText: "Error occurs in the template of component " + componentName + ".",
+            });
+            return {
+                source: 'ngtsc',
+                category: category,
+                code: code,
+                messageText: messageText,
+                file: sf,
+                componentFile: componentSf,
+                templateId: templateId,
+                start: span.start.offset,
+                length: span.end.offset - span.start.offset,
+                // Show a secondary message indicating the component whose template contains the error.
+                relatedInformation: relatedInformation,
+            };
+        }
+        else {
+            throw new Error("Unexpected source mapping type: " + mapping.type);
+        }
+    }
+    exports.makeTemplateDiagnostic = makeTemplateDiagnostic;
+    function isTemplateDiagnostic(diagnostic) {
+        return diagnostic.hasOwnProperty('componentFile') &&
+            ts.isSourceFile(diagnostic.componentFile);
+    }
+    exports.isTemplateDiagnostic = isTemplateDiagnostic;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diagnostic.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/diagnostics/src/diagnostic.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;IAGH,+BAAiC;IAoBjC;;OAEG;IACH,SAAgB,sBAAsB,CAClC,UAAsB,EAAE,OAA8B,EAAE,IAAqB,EAC7E,QAA+B,EAAE,IAAY,EAAE,WAA6C,EAC5F,cAGC;QACH,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE;YAC7B,IAAI,kBAAkB,GAAgD,SAAS,CAAC;YAChF,IAAI,cAAc,KAAK,SAAS,EAAE;gBAChC,kBAAkB,GAAG,CAAC;wBACpB,QAAQ,EAAE,EAAE,CAAC,kBAAkB,CAAC,OAAO;wBACvC,IAAI,EAAE,CAAC;wBACP,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE;wBAClC,KAAK,EAAE,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM;wBACvC,MAAM,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM;wBACzE,WAAW,EAAE,cAAc,CAAC,IAAI;qBACjC,CAAC,CAAC;aACJ;YACD,wFAAwF;YACxF,+FAA+F;YAC/F,8CAA8C;YAC9C,OAAO;gBACL,MAAM,EAAE,OAAO;gBACf,IAAI,MAAA;gBACJ,QAAQ,UAAA;gBACR,WAAW,aAAA;gBACX,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE;gBAClC,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE;gBAC3C,UAAU,YAAA;gBACV,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM;gBACxB,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM;gBAC3C,kBAAkB,oBAAA;aACnB,CAAC;SACH;aAAM,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE;YACrE,0FAA0F;YAC1F,2FAA2F;YAC3F,mEAAmE;YACnE,sDAAsD;YACtD,IAAM,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,aAAa,EAAE,CAAC;YAC3D,IAAM,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC;YACvD,mEAAmE;YACnE,IAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC;gBACvC,WAAW,CAAC,QAAQ,UAAK,aAAa,eAAY,CAAC,CAAC;gBACtD,OAAyC,CAAC,WAAW,CAAC;YAC3D,4FAA4F;YAC5F,6FAA6F;YAC7F,gFAAgF;YAChF,IAAM,EAAE,GAAG,EAAE,CAAC,gBAAgB,CAC1B,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YAElF,IAAI,kBAAkB,GAAsC,EAAE,CAAC;YAC/D,IAAI,cAAc,KAAK,SAAS,EAAE;gBAChC,kBAAkB,CAAC,IAAI,CAAC;oBACtB,QAAQ,EAAE,EAAE,CAAC,kBAAkB,CAAC,OAAO;oBACvC,IAAI,EAAE,CAAC;oBACP,IAAI,EAAE,EAAE;oBACR,KAAK,EAAE,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM;oBACvC,MAAM,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM;oBACzE,WAAW,EAAE,cAAc,CAAC,IAAI;iBACjC,CAAC,CAAC;aACJ;YAED,kBAAkB,CAAC,IAAI,CAAC;gBACtB,QAAQ,EAAE,EAAE,CAAC,kBAAkB,CAAC,OAAO;gBACvC,IAAI,EAAE,CAAC;gBACP,IAAI,EAAE,WAAW;gBACjB,wFAAwF;gBACxF,2EAA2E;gBAC3E,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE;gBAC9B,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE;gBACvD,WAAW,EAAE,+CAA6C,aAAa,MAAG;aAC3E,CAAC,CAAC;YAEH,OAAO;gBACL,MAAM,EAAE,OAAO;gBACf,QAAQ,UAAA;gBACR,IAAI,MAAA;gBACJ,WAAW,aAAA;gBACX,IAAI,EAAE,EAAE;gBACR,aAAa,EAAE,WAAW;gBAC1B,UAAU,YAAA;gBACV,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM;gBACxB,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM;gBAC3C,uFAAuF;gBACvF,kBAAkB,oBAAA;aACnB,CAAC;SACH;aAAM;YACL,MAAM,IAAI,KAAK,CAAC,qCAAoC,OAA0B,CAAC,IAAM,CAAC,CAAC;SACxF;IACH,CAAC;IA1FD,wDA0FC;IAED,SAAgB,oBAAoB,CAAC,UAAyB;QAC5D,OAAO,UAAU,CAAC,cAAc,CAAC,eAAe,CAAC;YAC7C,EAAE,CAAC,YAAY,CAAE,UAAkB,CAAC,aAAa,CAAC,CAAC;IACzD,CAAC;IAHD,oDAGC","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 {ParseSourceSpan} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {ExternalTemplateSourceMapping, TemplateId, TemplateSourceMapping} from '../../api';\n\n/**\n * A `ts.Diagnostic` with additional information about the diagnostic related to template\n * type-checking.\n */\nexport interface TemplateDiagnostic extends ts.Diagnostic {\n  /**\n   * The component with the template that resulted in this diagnostic.\n   */\n  componentFile: ts.SourceFile;\n\n  /**\n   * The template id of the component that resulted in this diagnostic.\n   */\n  templateId: TemplateId;\n}\n\n/**\n * Constructs a `ts.Diagnostic` for a given `ParseSourceSpan` within a template.\n */\nexport function makeTemplateDiagnostic(\n    templateId: TemplateId, mapping: TemplateSourceMapping, span: ParseSourceSpan,\n    category: ts.DiagnosticCategory, code: number, messageText: string|ts.DiagnosticMessageChain,\n    relatedMessage?: {\n      text: string,\n      span: ParseSourceSpan,\n    }): TemplateDiagnostic {\n  if (mapping.type === 'direct') {\n    let relatedInformation: ts.DiagnosticRelatedInformation[]|undefined = undefined;\n    if (relatedMessage !== undefined) {\n      relatedInformation = [{\n        category: ts.DiagnosticCategory.Message,\n        code: 0,\n        file: mapping.node.getSourceFile(),\n        start: relatedMessage.span.start.offset,\n        length: relatedMessage.span.end.offset - relatedMessage.span.start.offset,\n        messageText: relatedMessage.text,\n      }];\n    }\n    // For direct mappings, the error is shown inline as ngtsc was able to pinpoint a string\n    // constant within the `@Component` decorator for the template. This allows us to map the error\n    // directly into the bytes of the source file.\n    return {\n      source: 'ngtsc',\n      code,\n      category,\n      messageText,\n      file: mapping.node.getSourceFile(),\n      componentFile: mapping.node.getSourceFile(),\n      templateId,\n      start: span.start.offset,\n      length: span.end.offset - span.start.offset,\n      relatedInformation,\n    };\n  } else if (mapping.type === 'indirect' || mapping.type === 'external') {\n    // For indirect mappings (template was declared inline, but ngtsc couldn't map it directly\n    // to a string constant in the decorator), the component's file name is given with a suffix\n    // indicating it's not the TS file being displayed, but a template.\n    // For external temoplates, the HTML filename is used.\n    const componentSf = mapping.componentClass.getSourceFile();\n    const componentName = mapping.componentClass.name.text;\n    // TODO(alxhub): remove cast when TS in g3 supports this narrowing.\n    const fileName = mapping.type === 'indirect' ?\n        `${componentSf.fileName} (${componentName} template)` :\n        (mapping as ExternalTemplateSourceMapping).templateUrl;\n    // TODO(alxhub): investigate creating a fake `ts.SourceFile` here instead of invoking the TS\n    // parser against the template (HTML is just really syntactically invalid TypeScript code ;).\n    // Also investigate caching the file to avoid running the parser multiple times.\n    const sf = ts.createSourceFile(\n        fileName, mapping.template, ts.ScriptTarget.Latest, false, ts.ScriptKind.JSX);\n\n    let relatedInformation: ts.DiagnosticRelatedInformation[] = [];\n    if (relatedMessage !== undefined) {\n      relatedInformation.push({\n        category: ts.DiagnosticCategory.Message,\n        code: 0,\n        file: sf,\n        start: relatedMessage.span.start.offset,\n        length: relatedMessage.span.end.offset - relatedMessage.span.start.offset,\n        messageText: relatedMessage.text,\n      });\n    }\n\n    relatedInformation.push({\n      category: ts.DiagnosticCategory.Message,\n      code: 0,\n      file: componentSf,\n      // mapping.node represents either the 'template' or 'templateUrl' expression. getStart()\n      // and getEnd() are used because they don't include surrounding whitespace.\n      start: mapping.node.getStart(),\n      length: mapping.node.getEnd() - mapping.node.getStart(),\n      messageText: `Error occurs in the template of component ${componentName}.`,\n    });\n\n    return {\n      source: 'ngtsc',\n      category,\n      code,\n      messageText,\n      file: sf,\n      componentFile: componentSf,\n      templateId,\n      start: span.start.offset,\n      length: span.end.offset - span.start.offset,\n      // Show a secondary message indicating the component whose template contains the error.\n      relatedInformation,\n    };\n  } else {\n    throw new Error(`Unexpected source mapping type: ${(mapping as {type: string}).type}`);\n  }\n}\n\nexport function isTemplateDiagnostic(diagnostic: ts.Diagnostic): diagnostic is TemplateDiagnostic {\n  return diagnostic.hasOwnProperty('componentFile') &&\n      ts.isSourceFile((diagnostic as any).componentFile);\n}\n"]}

package/src/ngtsc/typecheck/diagnostics/src/id.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google LLC 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/typecheck/diagnostics/src/id" />
+import * as ts from 'typescript';
+import { TemplateId } from '../../api';
+export declare function getTemplateId(clazz: ts.Declaration): TemplateId;

package/src/ngtsc/typecheck/diagnostics/src/id.js

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright Google LLC 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/typecheck/diagnostics/src/id", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getTemplateId = void 0;
+    var TEMPLATE_ID = Symbol('ngTemplateId');
+    var NEXT_TEMPLATE_ID = Symbol('ngNextTemplateId');
+    function getTemplateId(clazz) {
+        var node = clazz;
+        if (node[TEMPLATE_ID] === undefined) {
+            node[TEMPLATE_ID] = allocateTemplateId(node.getSourceFile());
+        }
+        return node[TEMPLATE_ID];
+    }
+    exports.getTemplateId = getTemplateId;
+    function allocateTemplateId(sf) {
+        if (sf[NEXT_TEMPLATE_ID] === undefined) {
+            sf[NEXT_TEMPLATE_ID] = 1;
+        }
+        return ("tcb" + sf[NEXT_TEMPLATE_ID]++);
+    }
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -9,7 +9,6 @@
 export { ReusedProgramStrategy } from './src/augmented_program';
 export { FileTypeCheckingData, TemplateTypeCheckerImpl } from './src/checker';
 export { TypeCheckContextImpl } from './src/context';
-export { isTemplateDiagnostic, TemplateDiagnostic } from './src/diagnostics';
 export { TypeCheckProgramHost } from './src/host';
 export { TypeCheckShimGenerator } from './src/shim';
 export { typeCheckFilePath } from './src/type_check_file';

package/src/ngtsc/typecheck/index.js

@@ -11,20 +11,18 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/src/ngtsc/typecheck", ["require", "exports", "@angular/compiler-cli/src/ngtsc/typecheck/src/augmented_program", "@angular/compiler-cli/src/ngtsc/typecheck/src/checker", "@angular/compiler-cli/src/ngtsc/typecheck/src/context", "@angular/compiler-cli/src/ngtsc/typecheck/src/diagnostics", "@angular/compiler-cli/src/ngtsc/typecheck/src/host", "@angular/compiler-cli/src/ngtsc/typecheck/src/shim", "@angular/compiler-cli/src/ngtsc/typecheck/src/type_check_file"], factory);
+        define("@angular/compiler-cli/src/ngtsc/typecheck", ["require", "exports", "@angular/compiler-cli/src/ngtsc/typecheck/src/augmented_program", "@angular/compiler-cli/src/ngtsc/typecheck/src/checker", "@angular/compiler-cli/src/ngtsc/typecheck/src/context", "@angular/compiler-cli/src/ngtsc/typecheck/src/host", "@angular/compiler-cli/src/ngtsc/typecheck/src/shim", "@angular/compiler-cli/src/ngtsc/typecheck/src/type_check_file"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.typeCheckFilePath = exports.TypeCheckShimGenerator = exports.TypeCheckProgramHost = exports.isTemplateDiagnostic = exports.TypeCheckContextImpl = exports.TemplateTypeCheckerImpl = exports.ReusedProgramStrategy = void 0;
+    exports.typeCheckFilePath = exports.TypeCheckShimGenerator = exports.TypeCheckProgramHost = exports.TypeCheckContextImpl = exports.TemplateTypeCheckerImpl = exports.ReusedProgramStrategy = void 0;
     var augmented_program_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/src/augmented_program");
     Object.defineProperty(exports, "ReusedProgramStrategy", { enumerable: true, get: function () { return augmented_program_1.ReusedProgramStrategy; } });
     var checker_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/src/checker");
     Object.defineProperty(exports, "TemplateTypeCheckerImpl", { enumerable: true, get: function () { return checker_1.TemplateTypeCheckerImpl; } });
     var context_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/src/context");
     Object.defineProperty(exports, "TypeCheckContextImpl", { enumerable: true, get: function () { return context_1.TypeCheckContextImpl; } });
-    var diagnostics_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/src/diagnostics");
-    Object.defineProperty(exports, "isTemplateDiagnostic", { enumerable: true, get: function () { return diagnostics_1.isTemplateDiagnostic; } });
     var host_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/src/host");
     Object.defineProperty(exports, "TypeCheckProgramHost", { enumerable: true, get: function () { return host_1.TypeCheckProgramHost; } });
     var shim_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/src/shim");
@@ -32,4 +30,4 @@
     var type_check_file_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/src/type_check_file");
     Object.defineProperty(exports, "typeCheckFilePath", { enumerable: true, get: function () { return type_check_file_1.typeCheckFilePath; } });
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL3R5cGVjaGVjay9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7Ozs7SUFFSCxxR0FBOEQ7SUFBdEQsMEhBQUEscUJBQXFCLE9BQUE7SUFDN0IsaUZBQTRFO0lBQTlDLGtIQUFBLHVCQUF1QixPQUFBO0lBQ3JELGlGQUFtRDtJQUEzQywrR0FBQSxvQkFBb0IsT0FBQTtJQUM1Qix5RkFBMkU7SUFBbkUsbUhBQUEsb0JBQW9CLE9BQUE7SUFDNUIsMkVBQWdEO0lBQXhDLDRHQUFBLG9CQUFvQixPQUFBO0lBQzVCLDJFQUFrRDtJQUExQyw4R0FBQSxzQkFBc0IsT0FBQTtJQUM5QixpR0FBd0Q7SUFBaEQsb0hBQUEsaUJBQWlCLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IHtSZXVzZWRQcm9ncmFtU3RyYXRlZ3l9IGZyb20gJy4vc3JjL2F1Z21lbnRlZF9wcm9ncmFtJztcbmV4cG9ydCB7RmlsZVR5cGVDaGVja2luZ0RhdGEsIFRlbXBsYXRlVHlwZUNoZWNrZXJJbXBsfSBmcm9tICcuL3NyYy9jaGVja2VyJztcbmV4cG9ydCB7VHlwZUNoZWNrQ29udGV4dEltcGx9IGZyb20gJy4vc3JjL2NvbnRleHQnO1xuZXhwb3J0IHtpc1RlbXBsYXRlRGlhZ25vc3RpYywgVGVtcGxhdGVEaWFnbm9zdGljfSBmcm9tICcuL3NyYy9kaWFnbm9zdGljcyc7XG5leHBvcnQge1R5cGVDaGVja1Byb2dyYW1Ib3N0fSBmcm9tICcuL3NyYy9ob3N0JztcbmV4cG9ydCB7VHlwZUNoZWNrU2hpbUdlbmVyYXRvcn0gZnJvbSAnLi9zcmMvc2hpbSc7XG5leHBvcnQge3R5cGVDaGVja0ZpbGVQYXRofSBmcm9tICcuL3NyYy90eXBlX2NoZWNrX2ZpbGUnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL3R5cGVjaGVjay9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7Ozs7SUFFSCxxR0FBOEQ7SUFBdEQsMEhBQUEscUJBQXFCLE9BQUE7SUFDN0IsaUZBQTRFO0lBQTlDLGtIQUFBLHVCQUF1QixPQUFBO0lBQ3JELGlGQUFtRDtJQUEzQywrR0FBQSxvQkFBb0IsT0FBQTtJQUM1QiwyRUFBZ0Q7SUFBeEMsNEdBQUEsb0JBQW9CLE9BQUE7SUFDNUIsMkVBQWtEO0lBQTFDLDhHQUFBLHNCQUFzQixPQUFBO0lBQzlCLGlHQUF3RDtJQUFoRCxvSEFBQSxpQkFBaUIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQge1JldXNlZFByb2dyYW1TdHJhdGVneX0gZnJvbSAnLi9zcmMvYXVnbWVudGVkX3Byb2dyYW0nO1xuZXhwb3J0IHtGaWxlVHlwZUNoZWNraW5nRGF0YSwgVGVtcGxhdGVUeXBlQ2hlY2tlckltcGx9IGZyb20gJy4vc3JjL2NoZWNrZXInO1xuZXhwb3J0IHtUeXBlQ2hlY2tDb250ZXh0SW1wbH0gZnJvbSAnLi9zcmMvY29udGV4dCc7XG5leHBvcnQge1R5cGVDaGVja1Byb2dyYW1Ib3N0fSBmcm9tICcuL3NyYy9ob3N0JztcbmV4cG9ydCB7VHlwZUNoZWNrU2hpbUdlbmVyYXRvcn0gZnJvbSAnLi9zcmMvc2hpbSc7XG5leHBvcnQge3R5cGVDaGVja0ZpbGVQYXRofSBmcm9tICcuL3NyYy90eXBlX2NoZWNrX2ZpbGUnO1xuIl19