@angular/compiler-cli 21.2.2 → 21.2.4

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

@@ -153,7 +153,7 @@ export declare class TypeCheckContextImpl implements TypeCheckContext {
     private inlining;
     private perf;
     private fileMap;
-    constructor(config: TypeCheckingConfig, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>, refEmitter: ReferenceEmitter, reflector: ReflectionHost, host: TypeCheckingHost, inlining: InliningMode, perf: PerfRecorder);
+    constructor(config: TypeCheckingConfig, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName' | 'getSourceFile'>, refEmitter: ReferenceEmitter, reflector: ReflectionHost, host: TypeCheckingHost, inlining: InliningMode, perf: PerfRecorder);
     /**
      * A `Map` of `ts.SourceFile`s that the context has seen to the operations (additions of methods
      * or type-check blocks) that need to be eventually performed on that file.

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

@@ -9,7 +9,7 @@ import ts from 'typescript';
 import { Reference, ReferenceEmitter } from '../../imports';
 import { ClassDeclaration, ReflectionHost } from '../../reflection';
 import { ImportManager } from '../../translator';
-import { TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
+import { TcbDirectiveMetadata, TcbPipeMetadata, TcbReferenceKey, TcbReferenceMetadata, TypeCheckingConfig } from '../api';
 import { ReferenceEmitEnvironment } from './reference_emit_environment';
 import { TcbExpr } from './ops/codegen';
 /**
@@ -37,8 +37,8 @@ export declare class Environment extends ReferenceEmitEnvironment {
      * Depending on the shape of the directive itself, this could be either a reference to a declared
      * type constructor, or to an inline type constructor.
      */
-    typeCtorFor(dir: TypeCheckableDirectiveMeta): TcbExpr;
-    pipeInst(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>): TcbExpr;
+    typeCtorFor(dir: TcbDirectiveMetadata): TcbExpr;
+    pipeInst(pipe: TcbPipeMetadata): TcbExpr;
     /**
      * Generate a `ts.Expression` that references the given node.
      *
@@ -48,3 +48,4 @@ export declare class Environment extends ReferenceEmitEnvironment {
     private emitTypeParameters;
     getPreludeStatements(): TcbExpr[];
 }
+export declare function getTcbReferenceKey(ref: TcbReferenceMetadata): TcbReferenceKey;

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

@@ -8,7 +8,7 @@
 import { AST, BindingPipe, PropertyRead, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstForLoopBlock, TmplAstForLoopBlockEmpty, TmplAstHoverDeferredTrigger, TmplAstIfBlockBranch, TmplAstInteractionDeferredTrigger, TmplAstLetDeclaration, TmplAstReference, TmplAstSwitchBlockCase, TmplAstTemplate, TmplAstTextAttribute, TmplAstVariable, TmplAstViewportDeferredTrigger } from '@angular/compiler';
 import ts from 'typescript';
 import { ClassDeclaration } from '../../reflection';
-import { TemplateDiagnostic, TypeCheckId } from '../api';
+import { TcbDirectiveMetadata, TemplateDiagnostic, TypeCheckId } from '../api';
 import { TypeCheckSourceResolver } from './tcb_util';
 /**
  * Collects `ts.Diagnostic`s on problems which occur in the template which aren't directly sourced
@@ -73,7 +73,7 @@ export interface OutOfBandDiagnosticRecorder {
     /**
      * Reports a split two way binding error message.
      */
-    splitTwoWayBinding(id: TypeCheckId, input: TmplAstBoundAttribute, output: TmplAstBoundEvent, inputConsumer: ClassDeclaration, outputConsumer: ClassDeclaration | TmplAstElement): void;
+    splitTwoWayBinding(id: TypeCheckId, input: TmplAstBoundAttribute, output: TmplAstBoundEvent, inputConsumer: Pick<TcbDirectiveMetadata, 'name' | 'isComponent' | 'ref'>, outputConsumer: Pick<TcbDirectiveMetadata, 'name' | 'isComponent' | 'ref'> | TmplAstElement): void;
     /** Reports required inputs that haven't been bound. */
     missingRequiredInputs(id: TypeCheckId, element: TmplAstElement | TmplAstTemplate | TmplAstComponent | TmplAstDirective, directiveName: string, isComponent: boolean, inputAliases: string[]): void;
     /**
@@ -136,6 +136,7 @@ export interface OutOfBandDiagnosticRecorder {
 }
 export declare class OutOfBandDiagnosticRecorderImpl implements OutOfBandDiagnosticRecorder {
     private resolver;
+    private getSourceFile;
     private readonly _diagnostics;
     /**
      * Tracks which `BindingPipe` nodes have already been recorded as invalid, so only one diagnostic
@@ -144,7 +145,7 @@ export declare class OutOfBandDiagnosticRecorderImpl implements OutOfBandDiagnos
     private readonly recordedPipes;
     /** Common pipes that can be suggested to users. */
     private readonly pipeSuggestions;
-    constructor(resolver: TypeCheckSourceResolver);
+    constructor(resolver: TypeCheckSourceResolver, getSourceFile?: (fileName: string) => ts.SourceFile | undefined);
     get diagnostics(): ReadonlyArray<TemplateDiagnostic>;
     missingReferenceTarget(id: TypeCheckId, ref: TmplAstReference): void;
     missingPipe(id: TypeCheckId, ast: BindingPipe, isStandalone: boolean): void;
@@ -154,7 +155,7 @@ export declare class OutOfBandDiagnosticRecorderImpl implements OutOfBandDiagnos
     requiresInlineTcb(id: TypeCheckId, node: ClassDeclaration): void;
     requiresInlineTypeConstructors(id: TypeCheckId, node: ClassDeclaration, directives: ClassDeclaration[]): void;
     suboptimalTypeInference(id: TypeCheckId, variables: TmplAstVariable[]): void;
-    splitTwoWayBinding(id: TypeCheckId, input: TmplAstBoundAttribute, output: TmplAstBoundEvent, inputConsumer: ClassDeclaration, outputConsumer: ClassDeclaration | TmplAstElement): void;
+    splitTwoWayBinding(id: TypeCheckId, input: TmplAstBoundAttribute, output: TmplAstBoundEvent, inputConsumer: Pick<TcbDirectiveMetadata, 'name' | 'isComponent' | 'ref'>, outputConsumer: Pick<TcbDirectiveMetadata, 'name' | 'isComponent' | 'ref'> | TmplAstElement): void;
     missingRequiredInputs(id: TypeCheckId, element: TmplAstElement | TmplAstTemplate | TmplAstComponent | TmplAstDirective, directiveName: string, isComponent: boolean, inputAliases: string[]): void;
     illegalForLoopTrackAccess(id: TypeCheckId, block: TmplAstForLoopBlock, access: PropertyRead): void;
     inaccessibleDeferredTriggerElement(id: TypeCheckId, trigger: TmplAstHoverDeferredTrigger | TmplAstInteractionDeferredTrigger | TmplAstViewportDeferredTrigger): void;

package/src/ngtsc/typecheck/src/ops/bindings.d.ts

@@ -6,10 +6,8 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { AST, ParseSourceSpan, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstTemplate } from '@angular/compiler';
-import ts from 'typescript';
-import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbDirectiveMetadata } from '../../api';
 import { ClassPropertyName } from '../../../metadata';
-import { Reference } from '../../../imports';
 import { Context } from './context';
 import { TcbExpr } from './codegen';
 export interface TcbBoundAttribute {
@@ -20,7 +18,7 @@ export interface TcbBoundAttribute {
         fieldName: ClassPropertyName;
         required: boolean;
         isSignal: boolean;
-        transformType: Reference<ts.TypeNode> | null;
+        transformType?: string;
         isTwoWayBinding: boolean;
     }[];
 }
@@ -61,7 +59,7 @@ export interface TcbDirectiveUnsetInput {
     field: string;
 }
 export type TcbDirectiveInput = TcbDirectiveBoundInput | TcbDirectiveUnsetInput;
-export declare function getBoundAttributes(directive: TypeCheckableDirectiveMeta, node: TmplAstTemplate | TmplAstElement | TmplAstComponent | TmplAstDirective): TcbBoundAttribute[];
+export declare function getBoundAttributes(directive: TcbDirectiveMetadata, node: TmplAstTemplate | TmplAstElement | TmplAstComponent | TmplAstDirective): TcbBoundAttribute[];
 export declare function checkSplitTwoWayBinding(inputName: string, output: TmplAstBoundEvent, inputs: TmplAstBoundAttribute[], tcb: Context): boolean;
 /**
  * Potentially widens the type of `expr` according to the type-checking configuration.

package/src/ngtsc/typecheck/src/ops/context.d.ts

@@ -8,8 +8,7 @@
 import { BoundTarget, SchemaMetadata } from '@angular/compiler';
 import { DomSchemaChecker } from '../dom';
 import { OutOfBandDiagnosticRecorder } from '../oob';
-import { TypeCheckableDirectiveMeta, TypeCheckId } from '../../api';
-import { PipeMeta } from '../../../metadata';
+import { TypeCheckId, TcbDirectiveMetadata, TcbPipeMetadata } from '../../api';
 import { Environment } from '../environment';
 /**
  * Controls how generics for the component context class will be handled during TCB generation.
@@ -48,13 +47,13 @@ export declare class Context {
     readonly domSchemaChecker: DomSchemaChecker;
     readonly oobRecorder: OutOfBandDiagnosticRecorder;
     readonly id: TypeCheckId;
-    readonly boundTarget: BoundTarget<TypeCheckableDirectiveMeta>;
+    readonly boundTarget: BoundTarget<TcbDirectiveMetadata>;
     private pipes;
     readonly schemas: SchemaMetadata[];
     readonly hostIsStandalone: boolean;
     readonly hostPreserveWhitespaces: boolean;
     private nextId;
-    constructor(env: Environment, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, id: TypeCheckId, boundTarget: BoundTarget<TypeCheckableDirectiveMeta>, pipes: Map<string, PipeMeta> | null, schemas: SchemaMetadata[], hostIsStandalone: boolean, hostPreserveWhitespaces: boolean);
+    constructor(env: Environment, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, id: TypeCheckId, boundTarget: BoundTarget<TcbDirectiveMetadata>, pipes: Map<string, TcbPipeMetadata> | null, schemas: SchemaMetadata[], hostIsStandalone: boolean, hostPreserveWhitespaces: boolean);
     /**
      * Allocate a new variable name for use within the `Context`.
      *
@@ -62,5 +61,5 @@ export declare class Context {
      * might change depending on the type of data being stored.
      */
     allocateId(): string;
-    getPipeByName(name: string): PipeMeta | null;
+    getPipeByName(name: string): TcbPipeMetadata | null;
 }

package/src/ngtsc/typecheck/src/ops/directive_constructor.d.ts

@@ -10,7 +10,7 @@ import { TcbOp } from './base';
 import { TcbExpr } from './codegen';
 import { Context } from './context';
 import type { Scope } from './scope';
-import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbDirectiveMetadata } from '../../api';
 import { CustomFormControlType } from './signal_forms';
 /**
  * A `TcbOp` which constructs an instance of a directive with types inferred from its inputs. The
@@ -30,7 +30,7 @@ export declare class TcbDirectiveCtorOp extends TcbOp {
     private node;
     private dir;
     private customFormControlType;
-    constructor(tcb: Context, scope: Scope, node: DirectiveOwner, dir: TypeCheckableDirectiveMeta, customFormControlType: CustomFormControlType | null);
+    constructor(tcb: Context, scope: Scope, node: DirectiveOwner, dir: TcbDirectiveMetadata, customFormControlType: CustomFormControlType | null);
     get optional(): boolean;
     execute(): TcbExpr;
     circularFallback(): TcbOp;
@@ -53,7 +53,7 @@ export declare class TcbDirectiveCtorCircularFallbackOp extends TcbOp {
     private tcb;
     private scope;
     private dir;
-    constructor(tcb: Context, scope: Scope, dir: TypeCheckableDirectiveMeta);
+    constructor(tcb: Context, scope: Scope, dir: TcbDirectiveMetadata);
     get optional(): boolean;
     execute(): TcbExpr;
 }

package/src/ngtsc/typecheck/src/ops/directive_type.d.ts

@@ -10,7 +10,7 @@ import type { Context } from './context';
 import type { Scope } from './scope';
 import { TcbOp } from './base';
 import { TcbExpr } from './codegen';
-import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbDirectiveMetadata } from '../../api';
 /**
  * A `TcbOp` which constructs an instance of a directive. For generic directives, generic
  * parameters are set to `any` type.
@@ -19,8 +19,8 @@ export declare abstract class TcbDirectiveTypeOpBase extends TcbOp {
     protected tcb: Context;
     protected scope: Scope;
     protected node: DirectiveOwner;
-    protected dir: TypeCheckableDirectiveMeta;
-    constructor(tcb: Context, scope: Scope, node: DirectiveOwner, dir: TypeCheckableDirectiveMeta);
+    protected dir: TcbDirectiveMetadata;
+    constructor(tcb: Context, scope: Scope, node: DirectiveOwner, dir: TcbDirectiveMetadata);
     get optional(): boolean;
     execute(): TcbExpr;
 }

package/src/ngtsc/typecheck/src/ops/events.d.ts

@@ -10,7 +10,7 @@ import { TcbOp } from './base';
 import { TcbExpr } from './codegen';
 import type { Context } from './context';
 import type { Scope } from './scope';
-import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbDirectiveMetadata } from '../../api';
 import { LocalSymbol } from './references';
 /**
  * Similar to `tcbExpression`, this function converts the provided `AST` expression into a
@@ -31,7 +31,7 @@ export declare class TcbDirectiveOutputsOp extends TcbOp {
     private inputs;
     private outputs;
     private dir;
-    constructor(tcb: Context, scope: Scope, node: DirectiveOwner, inputs: TmplAstBoundAttribute[] | null, outputs: TmplAstBoundEvent[], dir: TypeCheckableDirectiveMeta);
+    constructor(tcb: Context, scope: Scope, node: DirectiveOwner, inputs: TmplAstBoundAttribute[] | null, outputs: TmplAstBoundEvent[], dir: TcbDirectiveMetadata);
     get optional(): boolean;
     execute(): null;
 }

package/src/ngtsc/typecheck/src/ops/inputs.d.ts

@@ -8,7 +8,7 @@
 import { AST, TmplAstBoundAttribute, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstTemplate } from '@angular/compiler';
 import type { Context } from './context';
 import type { Scope } from './scope';
-import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbDirectiveMetadata } from '../../api';
 import { TcbOp } from './base';
 import { TcbExpr } from './codegen';
 import { CustomFormControlType } from './signal_forms';
@@ -30,7 +30,7 @@ export declare class TcbDirectiveInputsOp extends TcbOp {
     private dir;
     private isFormControl;
     private customFormControlType;
-    constructor(tcb: Context, scope: Scope, node: TmplAstTemplate | TmplAstElement | TmplAstComponent | TmplAstDirective, dir: TypeCheckableDirectiveMeta, isFormControl: boolean | undefined, customFormControlType: CustomFormControlType | null);
+    constructor(tcb: Context, scope: Scope, node: TmplAstTemplate | TmplAstElement | TmplAstComponent | TmplAstDirective, dir: TcbDirectiveMetadata, isFormControl: boolean | undefined, customFormControlType: CustomFormControlType | null);
     get optional(): boolean;
     execute(): null;
     private checkRequiredInputs;

package/src/ngtsc/typecheck/src/ops/references.d.ts

@@ -10,7 +10,7 @@ import { TcbOp } from './base';
 import { TcbExpr } from './codegen';
 import type { Context } from './context';
 import type { Scope } from './scope';
-import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbDirectiveMetadata } from '../../api';
 /** Types that can referenced locally in a template. */
 export type LocalSymbol = TmplAstElement | TmplAstTemplate | TmplAstVariable | TmplAstLetDeclaration | TmplAstReference | TmplAstHostElement | TmplAstComponent | TmplAstDirective;
 /**
@@ -39,7 +39,7 @@ export declare class TcbReferenceOp extends TcbOp {
     private readonly node;
     private readonly host;
     private readonly target;
-    constructor(tcb: Context, scope: Scope, node: TmplAstReference, host: TmplAstElement | TmplAstTemplate | TmplAstComponent | TmplAstDirective, target: TypeCheckableDirectiveMeta | TmplAstTemplate | TmplAstElement);
+    constructor(tcb: Context, scope: Scope, node: TmplAstReference, host: TmplAstElement | TmplAstTemplate | TmplAstComponent | TmplAstDirective, target: TcbDirectiveMetadata | TmplAstTemplate | TmplAstElement);
     readonly optional = true;
     execute(): TcbExpr;
 }

package/src/ngtsc/typecheck/src/ops/scope.d.ts

@@ -7,7 +7,7 @@
  */
 import { TmplAstForLoopBlock, TmplAstHostElement, TmplAstIfBlockBranch, TmplAstLetDeclaration, TmplAstNode, TmplAstReference, TmplAstTemplate, TmplAstVariable } from '@angular/compiler';
 import { TcbExpr } from './codegen';
-import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbDirectiveMetadata } from '../../api';
 import { Context } from './context';
 import { LocalSymbol } from './references';
 /**
@@ -123,7 +123,7 @@ export declare class Scope {
      * @param directive if present, a directive type on a `TmplAstElement` or `TmplAstTemplate` to
      * look up instead of the default for an element or template node.
      */
-    resolve(node: LocalSymbol, directive?: TypeCheckableDirectiveMeta): TcbExpr;
+    resolve(node: LocalSymbol, directive?: TcbDirectiveMetadata): TcbExpr;
     /**
      * Add a statement to this scope.
      */

package/src/ngtsc/typecheck/src/ops/signal_forms.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { DirectiveOwner, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstNode, TmplAstTemplate } from '@angular/compiler';
-import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbDirectiveMetadata } from '../../api';
 import { TcbOp } from './base';
 import { TcbBoundAttribute } from './bindings';
 import type { Context } from './context';
@@ -39,12 +39,12 @@ export declare class TcbNativeRadioButtonFieldOp extends TcbNativeFieldOp {
     execute(): null;
 }
 /** Expands the set of bound inputs with the ones from custom field directives. */
-export declare function expandBoundAttributesForField(directive: TypeCheckableDirectiveMeta, node: TmplAstTemplate | TmplAstElement | TmplAstComponent | TmplAstDirective, customFormControlType: CustomFormControlType | null): TcbBoundAttribute[] | null;
-export declare function isFieldDirective(meta: TypeCheckableDirectiveMeta): boolean;
+export declare function expandBoundAttributesForField(directive: TcbDirectiveMetadata, node: TmplAstTemplate | TmplAstElement | TmplAstComponent | TmplAstDirective, customFormControlType: CustomFormControlType | null): TcbBoundAttribute[] | null;
+export declare function isFieldDirective(meta: TcbDirectiveMetadata): boolean;
 /** Determines if a directive is a custom field and its type. */
-export declare function getCustomFieldDirectiveType(meta: TypeCheckableDirectiveMeta): CustomFormControlType | null;
+export declare function getCustomFieldDirectiveType(meta: TcbDirectiveMetadata): CustomFormControlType | null;
 /** Determines if a directive usage is on a native field. */
-export declare function isNativeField(dir: TypeCheckableDirectiveMeta, node: TmplAstNode, allDirectiveMatches: TypeCheckableDirectiveMeta[]): node is TmplAstElement & {
+export declare function isNativeField(dir: TcbDirectiveMetadata, node: TmplAstNode, allDirectiveMatches: TcbDirectiveMetadata[]): node is TmplAstElement & {
     name: 'input' | 'select' | 'textarea';
 };
 /** Checks whether a node has bindings that aren't supported on fields. */
@@ -55,4 +55,4 @@ export declare function checkUnsupportedFieldBindings(node: DirectiveOwner, unsu
  * A node is a form control if it has a matching `FormField` directive, and no other directives match
  * the `field` input.
  */
-export declare function isFormControl(allDirectiveMatches: TypeCheckableDirectiveMeta[]): boolean;
+export declare function isFormControl(allDirectiveMatches: TcbDirectiveMetadata[]): boolean;

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

@@ -10,6 +10,7 @@ import ts from 'typescript';
 import { ImportFlags, Reference, ReferenceEmitter } from '../../imports';
 import { ReflectionHost } from '../../reflection';
 import { ImportManager } from '../../translator';
+import { TcbReferenceMetadata } from '../api';
 import { TcbExpr } from './ops/codegen';
 /**
  * An environment for a given source file that can be used to emit references.
@@ -19,7 +20,7 @@ import { TcbExpr } from './ops/codegen';
  */
 export declare class ReferenceEmitEnvironment {
     readonly importManager: ImportManager;
-    protected refEmitter: ReferenceEmitter;
+    refEmitter: ReferenceEmitter;
     readonly reflector: ReflectionHost;
     contextFile: ts.SourceFile;
     constructor(importManager: ImportManager, refEmitter: ReferenceEmitter, reflector: ReflectionHost, contextFile: ts.SourceFile);
@@ -30,6 +31,22 @@ export declare class ReferenceEmitEnvironment {
      * This may involve importing the node into the file if it's not declared there already.
      */
     referenceType(ref: Reference, flags?: ImportFlags): ts.TypeNode;
+    /**
+     * Generates a `ts.TypeNode` from a `TcbReferenceMetadata` object.
+     * This is used by the TCB operations which do not hold on to the original `ts.Declaration`.
+     *
+     * Note: It's important that we do not try to evaluate the `typeParameters` here and pad them
+     * out with `any` type arguments. If we supply `any` to a generic pipe (e.g. `var _pipe1: MyPipe<any>;`),
+     * it destroys the generic constraints and degrades the `transform` signature. When they are omitted
+     * entirely, TypeScript implicitly flags an error, which the Angular compiler filters out, and
+     * crucially recovers by falling back to constraint inference (e.g. `var _pipe1: MyPipe;` infers
+     * bounds safely).
+     */
+    referenceTcbType(ref: TcbReferenceMetadata): ts.TypeNode;
+    /**
+     * Generates a `TcbExpr` from a `TcbReferenceMetadata` object.
+     */
+    referenceTcbValue(ref: TcbReferenceMetadata): TcbExpr;
     referenceExternalSymbol(moduleName: string, name: string): TcbExpr;
     /**
      * Generate a `ts.TypeNode` that references a given type from the provided module.

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

@@ -0,0 +1,20 @@
+/**
+ * @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.dev/license
+ */
+import { TypeCheckBlockMetadata, TcbTypeCheckBlockMetadata, TcbComponentMetadata } from '../api';
+import { Environment } from './environment';
+import { Reference } from '../../imports';
+import { ClassDeclaration } from '../../reflection';
+import ts from 'typescript';
+/**
+ * Adapts the compiler's `TypeCheckBlockMetadata` (which includes full TS AST nodes)
+ * into a purely detached `TcbTypeCheckBlockMetadata` that can be mapped to JSON.
+ */
+export declare function adaptTypeCheckBlockMetadata(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, meta: TypeCheckBlockMetadata, env: Environment): {
+    tcbMeta: TcbTypeCheckBlockMetadata;
+    component: TcbComponentMetadata;
+};

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

@@ -9,7 +9,7 @@ import { AbsoluteSourceSpan, ParseSourceSpan } from '@angular/compiler';
 import ts from 'typescript';
 import { ClassDeclaration, ReflectionHost } from '../../../../src/ngtsc/reflection';
 import { Reference } from '../../imports';
-import { FullSourceMapping, SourceLocation, TypeCheckId, SourceMapping } from '../api';
+import { FullSourceMapping, SourceLocation, TypeCheckId, SourceMapping, TcbTypeParameter } from '../api';
 import { ReferenceEmitEnvironment } from './reference_emit_environment';
 /**
  * Adapter interface which allows the directive type-checking diagnostics code to interpret offsets
@@ -78,3 +78,4 @@ export declare function ensureTypeCheckFilePreparationImports(env: ReferenceEmit
 export declare function checkIfGenericTypeBoundsCanBeEmitted(node: ClassDeclaration<ts.ClassDeclaration>, reflector: ReflectionHost, env: ReferenceEmitEnvironment): boolean;
 export declare function findNodeInFile<T extends ts.Node>(file: ts.SourceFile, predicate: (node: ts.Node) => node is T): T | null;
 export declare function findNodeInFile(file: ts.SourceFile, predicate: (node: ts.Node) => boolean): ts.Node | null;
+export declare function generateTcbTypeParameters(typeParameters: ReadonlyArray<ts.TypeParameterDeclaration>, sourceFile: ts.SourceFile): TcbTypeParameter[];

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

@@ -6,9 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import ts from 'typescript';
-import { Reference } from '../../imports';
-import { ClassDeclaration } from '../../reflection';
-import { TypeCheckBlockMetadata } from '../api';
+import { TcbComponentMetadata, TcbTypeCheckBlockMetadata } from '../api';
 import { DomSchemaChecker } from './dom';
 import { Environment } from './environment';
 import { OutOfBandDiagnosticRecorder } from './oob';
@@ -37,4 +35,4 @@ import { TcbGenericContextBehavior } from './ops/context';
  * @param genericContextBehavior controls how generic parameters (especially parameters with generic
  * bounds) will be referenced from the generated TCB code.
  */
-export declare function generateTypeCheckBlock(env: Environment, ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, name: ts.Identifier, meta: TypeCheckBlockMetadata, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, genericContextBehavior: TcbGenericContextBehavior): string;
+export declare function generateTypeCheckBlock(env: Environment, component: TcbComponentMetadata, name: ts.Identifier, meta: TcbTypeCheckBlockMetadata, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, genericContextBehavior: TcbGenericContextBehavior): string;

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

@@ -25,6 +25,7 @@ import { TcbExpr } from './ops/codegen';
  */
 export declare class TypeCheckFile extends Environment {
     readonly fileName: AbsoluteFsPath;
+    readonly isTypeCheckFile = true;
     private nextTcbId;
     private tcbStatements;
     constructor(fileName: AbsoluteFsPath, config: TypeCheckingConfig, refEmitter: ReferenceEmitter, reflector: ReflectionHost, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>);

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

@@ -7,10 +7,10 @@
  */
 import ts from 'typescript';
 import { ClassDeclaration, ReflectionHost } from '../../reflection';
-import { TypeCtorMetadata } from '../api';
+import { TypeCtorMetadata, TcbTypeParameter } from '../api';
 import { ReferenceEmitEnvironment } from './reference_emit_environment';
 import { TcbExpr } from './ops/codegen';
-export declare function generateTypeCtorDeclarationFn(env: ReferenceEmitEnvironment, meta: TypeCtorMetadata, nodeTypeRef: ts.EntityName, typeParams: ts.TypeParameterDeclaration[] | undefined): TcbExpr;
+export declare function generateTypeCtorDeclarationFn(env: ReferenceEmitEnvironment, meta: TypeCtorMetadata, nodeTypeRef: ts.EntityName, typeParams: TcbTypeParameter[] | undefined): TcbExpr;
 /**
  * Generate an inline type constructor for the given class and metadata.
  *