@angular/compiler-cli 21.2.2 → 21.2.3

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.
  *