@angular/compiler-cli 21.0.0-rc.2 → 21.0.0

package/bundles/{chunk-UI6E44E7.js → chunk-EZPRBQ4S.js}

@@ -8,7 +8,7 @@ import {
   TrackedIncrementalBuildStrategy,
   freshCompilationTicket,
   incrementalFromCompilerTicket
-} from "./chunk-JCBKDAHA.js";
+} from "./chunk-3UWOVJPM.js";
 import {
   ActivePerfRecorder,
   OptimizeFor,
@@ -18,7 +18,7 @@ import {
   TsCreateProgramDriver,
   replaceTsWithNgInErrors,
   retagAllTsFiles
-} from "./chunk-Y65S2AOA.js";
+} from "./chunk-67N3I5R2.js";
 import {
   absoluteFrom,
   createFileSystemTsReadDirectoryFn,

package/bundles/{chunk-Z6XYTYZD.js → chunk-IUWOX36C.js}

@@ -12,7 +12,7 @@ import {
   formatDiagnostics,
   performCompilation,
   readConfiguration
-} from "./chunk-UI6E44E7.js";
+} from "./chunk-EZPRBQ4S.js";
 
 // packages/compiler-cli/src/main.js
 import ts2 from "typescript";

package/bundles/chunk-ZJZNLTWN.js

@@ -455,7 +455,7 @@ import { compileDirectiveFromMetadata, makeBindingParser, ParseLocation, ParseSo
 // packages/compiler-cli/linker/src/file_linker/partial_linkers/util.js
 import { createMayBeForwardRefExpression, outputAst as o2 } from "@angular/compiler";
 import semver from "semver";
-var PLACEHOLDER_VERSION = "21.0.0-rc.2";
+var PLACEHOLDER_VERSION = "21.0.0";
 function wrapReference(wrapped) {
   return { value: wrapped, type: wrapped };
 }

package/bundles/index.js

@@ -17,7 +17,7 @@ import {
   isTsDiagnostic,
   performCompilation,
   readConfiguration
-} from "./chunk-UI6E44E7.js";
+} from "./chunk-EZPRBQ4S.js";
 import {
   ConsoleLogger,
   LogLevel
@@ -34,7 +34,7 @@ import {
   freshCompilationTicket,
   incrementalFromStateTicket,
   isDocEntryWithSourceInfo
-} from "./chunk-JCBKDAHA.js";
+} from "./chunk-3UWOVJPM.js";
 import {
   ActivePerfRecorder,
   ErrorCode,
@@ -46,7 +46,7 @@ import {
   getInitializerApiJitTransform,
   isLocalCompilationDiagnostics,
   ngErrorCode
-} from "./chunk-Y65S2AOA.js";
+} from "./chunk-67N3I5R2.js";
 import "./chunk-LS5RJ5CS.js";
 import {
   InvalidFileSystem,
@@ -77,7 +77,7 @@ import "./chunk-G7GFT6BU.js";
 
 // packages/compiler-cli/src/version.js
 import { Version } from "@angular/compiler";
-var VERSION = new Version("21.0.0-rc.2");
+var VERSION = new Version("21.0.0");
 
 // packages/compiler-cli/private/tooling.js
 var GLOBAL_DEFS_FOR_TERSER = {

package/bundles/private/migrations.js

@@ -5,7 +5,7 @@
 import {
   DiagnosticCategoryLabel,
   NgCompiler
-} from "../chunk-JCBKDAHA.js";
+} from "../chunk-3UWOVJPM.js";
 import {
   CompilationMode,
   DtsMetadataReader,
@@ -32,7 +32,7 @@ import {
   queryDecoratorNames,
   reflectObjectLiteral,
   unwrapExpression
-} from "../chunk-Y65S2AOA.js";
+} from "../chunk-67N3I5R2.js";
 import "../chunk-LS5RJ5CS.js";
 import {
   getFileSystem,

package/bundles/private/testing.js

@@ -6,7 +6,7 @@ import {
   ImportedSymbolsTracker,
   TypeScriptReflectionHost,
   getInitializerApiJitTransform
-} from "../chunk-Y65S2AOA.js";
+} from "../chunk-67N3I5R2.js";
 import "../chunk-LS5RJ5CS.js";
 import {
   InvalidFileSystem,

package/bundles/private/tooling.js

@@ -4,7 +4,7 @@
     
 import {
   angularJitApplicationTransform
-} from "../chunk-Y65S2AOA.js";
+} from "../chunk-67N3I5R2.js";
 import "../chunk-LS5RJ5CS.js";
 import "../chunk-GWZQLAGK.js";
 import "../chunk-XYYEESKY.js";

package/bundles/src/bin/ng_xi18n.js

@@ -6,12 +6,12 @@
 import {
   main,
   readCommandLineAndConfiguration
-} from "../../chunk-Z6XYTYZD.js";
+} from "../../chunk-IUWOX36C.js";
 import {
   EmitFlags
-} from "../../chunk-UI6E44E7.js";
-import "../../chunk-JCBKDAHA.js";
-import "../../chunk-Y65S2AOA.js";
+} from "../../chunk-EZPRBQ4S.js";
+import "../../chunk-3UWOVJPM.js";
+import "../../chunk-67N3I5R2.js";
 import "../../chunk-LS5RJ5CS.js";
 import {
   setFileSystem

package/bundles/src/bin/ngc.js

@@ -5,10 +5,10 @@
     
 import {
   main
-} from "../../chunk-Z6XYTYZD.js";
-import "../../chunk-UI6E44E7.js";
-import "../../chunk-JCBKDAHA.js";
-import "../../chunk-Y65S2AOA.js";
+} from "../../chunk-IUWOX36C.js";
+import "../../chunk-EZPRBQ4S.js";
+import "../../chunk-3UWOVJPM.js";
+import "../../chunk-67N3I5R2.js";
 import "../../chunk-LS5RJ5CS.js";
 import {
   setFileSystem

package/linker/src/file_linker/partial_linkers/util.d.ts

@@ -7,7 +7,7 @@
  */
 import { MaybeForwardRefExpression, outputAst as o, R3DeclareDependencyMetadata, R3DependencyMetadata, R3Reference } from '@angular/compiler';
 import { AstObject, AstValue } from '../../ast/ast_value';
-export declare const PLACEHOLDER_VERSION = "21.0.0-rc.2";
+export declare const PLACEHOLDER_VERSION = "21.0.0";
 export declare function wrapReference<TExpression>(wrapped: o.WrappedNodeExpr<TExpression>): R3Reference;
 /**
  * Parses the value of an enum from the AST value's symbol name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "21.0.0-rc.2",
+  "version": "21.0.0",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -40,7 +40,7 @@
     "yargs": "^18.0.0"
   },
   "peerDependencies": {
-    "@angular/compiler": "21.0.0-rc.2",
+    "@angular/compiler": "21.0.0",
     "typescript": ">=5.9 <6.0"
   },
   "peerDependenciesMeta": {

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

@@ -0,0 +1,43 @@
+/*!
+ * @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 ts from 'typescript';
+/**
+ * A code generation operation that's involved in the construction of a Type Check Block.
+ *
+ * The generation of a TCB is non-linear. Bindings within a template may result in the need to
+ * construct certain types earlier than they otherwise would be constructed. That is, if the
+ * generation of a TCB for a template is broken down into specific operations (constructing a
+ * directive, extracting a variable from a let- operation, etc), then it's possible for operations
+ * earlier in the sequence to depend on operations which occur later in the sequence.
+ *
+ * `TcbOp` abstracts the different types of operations which are required to convert a template into
+ * a TCB. This allows for two phases of processing for the template, where 1) a linear sequence of
+ * `TcbOp`s is generated, and then 2) these operations are executed, not necessarily in linear
+ * order.
+ *
+ * Each `TcbOp` may insert statements into the body of the TCB, and also optionally return a
+ * `ts.Expression` which can be used to reference the operation's result.
+ */
+export declare abstract class TcbOp {
+    /**
+     * Set to true if this operation can be considered optional. Optional operations are only executed
+     * when depended upon by other operations, otherwise they are disregarded. This allows for less
+     * code to generate, parse and type-check, overall positively contributing to performance.
+     */
+    abstract readonly optional: boolean;
+    abstract execute(): ts.Expression | null;
+    /**
+     * Replacement value or operation used while this `TcbOp` is executing (i.e. to resolve circular
+     * references during its execution).
+     *
+     * This is usually a `null!` expression (which asks TS to infer an appropriate type), but another
+     * `TcbOp` can be returned in cases where additional code generation is necessary to deal with
+     * circular references.
+     */
+    circularFallback(): TcbOp | ts.Expression;
+}

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

@@ -0,0 +1,64 @@
+/*!
+ * @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 { AST, ParseSourceSpan, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstTemplate } from '@angular/compiler';
+import ts from 'typescript';
+import { TypeCheckableDirectiveMeta } from '../../api';
+import { ClassPropertyName } from '../../../metadata';
+import { Reference } from '../../../imports';
+import { Context } from './context';
+export interface TcbBoundAttribute {
+    value: AST | string;
+    sourceSpan: ParseSourceSpan;
+    keySpan: ParseSourceSpan | null;
+    inputs: {
+        fieldName: ClassPropertyName;
+        required: boolean;
+        isSignal: boolean;
+        transformType: Reference<ts.TypeNode> | null;
+        isTwoWayBinding: boolean;
+    }[];
+}
+/**
+ * An input binding that corresponds with a field of a directive.
+ */
+export interface TcbDirectiveBoundInput {
+    type: 'binding';
+    /**
+     * The name of a field on the directive that is set.
+     */
+    field: string;
+    /**
+     * The `ts.Expression` corresponding with the input binding expression.
+     */
+    expression: ts.Expression;
+    /**
+     * The source span of the full attribute binding.
+     */
+    sourceSpan: ParseSourceSpan;
+    /**
+     * Whether the binding is part of a two-way binding.
+     */
+    isTwoWayBinding: boolean;
+}
+/**
+ * Indicates that a certain field of a directive does not have a corresponding input binding.
+ */
+export interface TcbDirectiveUnsetInput {
+    type: 'unset';
+    /**
+     * The name of a field on the directive for which no input binding is present.
+     */
+    field: string;
+}
+export type TcbDirectiveInput = TcbDirectiveBoundInput | TcbDirectiveUnsetInput;
+export declare function getBoundAttributes(directive: TypeCheckableDirectiveMeta, 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.
+ */
+export declare function widenBinding(expr: ts.Expression, tcb: Context): ts.Expression;

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

@@ -0,0 +1,22 @@
+/*!
+ * @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 { TcbOp } from './base';
+import type { Scope } from './scope';
+/**
+ * A `TcbOp` which generates a completion point for the component context.
+ *
+ * This completion point looks like `this. ;` in the TCB output, and does not produce diagnostics.
+ * TypeScript autocompletion APIs can be used at this completion point (after the '.') to produce
+ * autocompletion results of properties and methods from the template's component context.
+ */
+export declare class TcbComponentContextCompletionOp extends TcbOp {
+    private scope;
+    constructor(scope: Scope);
+    readonly optional = false;
+    execute(): null;
+}

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

@@ -0,0 +1,34 @@
+/*!
+ * @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 { TmplAstComponent, TmplAstElement } from '@angular/compiler';
+import { TcbOp } from './base';
+import { Context } from './context';
+/**
+ * A `TcbOp` that finds and flags control flow nodes that interfere with content projection.
+ *
+ * Context:
+ * Control flow blocks try to emulate the content projection behavior of `*ngIf` and `*ngFor`
+ * in order to reduce breakages when moving from one syntax to the other (see #52414), however the
+ * approach only works if there's only one element at the root of the control flow expression.
+ * This means that a stray sibling node (e.g. text) can prevent an element from being projected
+ * into the right slot. The purpose of the `TcbOp` is to find any places where a node at the root
+ * of a control flow expression *would have been projected* into a specific slot, if the control
+ * flow node didn't exist.
+ */
+export declare class TcbControlFlowContentProjectionOp extends TcbOp {
+    private tcb;
+    private element;
+    private ngContentSelectors;
+    private componentName;
+    private readonly category;
+    constructor(tcb: Context, element: TmplAstElement | TmplAstComponent, ngContentSelectors: string[], componentName: string);
+    readonly optional = false;
+    execute(): null;
+    private findPotentialControlFlowNodes;
+    private shouldCheck;
+}

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

@@ -0,0 +1,67 @@
+/*!
+ * @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 { BoundTarget, SchemaMetadata } from '@angular/compiler';
+import ts from 'typescript';
+import { DomSchemaChecker } from '../dom';
+import { OutOfBandDiagnosticRecorder } from '../oob';
+import { TypeCheckableDirectiveMeta, TypeCheckId } from '../../api';
+import { PipeMeta } from '../../../metadata';
+import { Environment } from '../environment';
+/**
+ * Controls how generics for the component context class will be handled during TCB generation.
+ */
+export declare enum TcbGenericContextBehavior {
+    /**
+     * References to generic parameter bounds will be emitted via the `TypeParameterEmitter`.
+     *
+     * The caller must verify that all parameter bounds are emittable in order to use this mode.
+     */
+    UseEmitter = 0,
+    /**
+     * Generic parameter declarations will be copied directly from the `ts.ClassDeclaration` of the
+     * component class.
+     *
+     * The caller must only use the generated TCB code in a context where such copies will still be
+     * valid, such as an inline type check block.
+     */
+    CopyClassNodes = 1,
+    /**
+     * Any generic parameters for the component context class will be set to `any`.
+     *
+     * Produces a less useful type, but is always safe to use.
+     */
+    FallbackToAny = 2
+}
+/**
+ * Overall generation context for the type check block.
+ *
+ * `Context` handles operations during code generation which are global with respect to the whole
+ * block. It's responsible for variable name allocation and management of any imports needed. It
+ * also contains the template metadata itself.
+ */
+export declare class Context {
+    readonly env: Environment;
+    readonly domSchemaChecker: DomSchemaChecker;
+    readonly oobRecorder: OutOfBandDiagnosticRecorder;
+    readonly id: TypeCheckId;
+    readonly boundTarget: BoundTarget<TypeCheckableDirectiveMeta>;
+    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);
+    /**
+     * Allocate a new variable name for use within the `Context`.
+     *
+     * Currently this uses a monotonically increasing counter, but in the future the variable name
+     * might change depending on the type of data being stored.
+     */
+    allocateId(): ts.Identifier;
+    getPipeByName(name: string): PipeMeta | null;
+}

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

@@ -0,0 +1,59 @@
+/*!
+ * @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 { DirectiveOwner } from '@angular/compiler';
+import ts from 'typescript';
+import { TcbOp } from './base';
+import { Context } from './context';
+import type { Scope } from './scope';
+import { TypeCheckableDirectiveMeta } from '../../api';
+import { CustomFieldType } from './signal_forms';
+/**
+ * A `TcbOp` which constructs an instance of a directive with types inferred from its inputs. The
+ * inputs themselves are not checked here; checking of inputs is achieved in `TcbDirectiveInputsOp`.
+ * Any errors reported in this statement are ignored, as the type constructor call is only present
+ * for type-inference.
+ *
+ * When a Directive is generic, it is required that the TCB generates the instance using this method
+ * in order to infer the type information correctly.
+ *
+ * Executing this operation returns a reference to the directive instance variable with its inferred
+ * type.
+ */
+export declare class TcbDirectiveCtorOp extends TcbOp {
+    private tcb;
+    private scope;
+    private node;
+    private dir;
+    private customControlType;
+    constructor(tcb: Context, scope: Scope, node: DirectiveOwner, dir: TypeCheckableDirectiveMeta, customControlType: CustomFieldType | null);
+    get optional(): boolean;
+    execute(): ts.Identifier;
+    circularFallback(): TcbOp;
+}
+/**
+ * A `TcbOp` which is used to generate a fallback expression if the inference of a directive type
+ * via `TcbDirectiveCtorOp` requires a reference to its own type. This can happen using a template
+ * reference:
+ *
+ * ```html
+ * <some-cmp #ref [prop]="ref.foo"></some-cmp>
+ * ```
+ *
+ * In this case, `TcbDirectiveCtorCircularFallbackOp` will add a second inference of the directive
+ * type to the type-check block, this time calling the directive's type constructor without any
+ * input expressions. This infers the widest possible supertype for the directive, which is used to
+ * resolve any recursive references required to infer the real type.
+ */
+export declare class TcbDirectiveCtorCircularFallbackOp extends TcbOp {
+    private tcb;
+    private scope;
+    private dir;
+    constructor(tcb: Context, scope: Scope, dir: TypeCheckableDirectiveMeta);
+    get optional(): boolean;
+    execute(): ts.Identifier;
+}

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

@@ -0,0 +1,53 @@
+/*!
+ * @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 { DirectiveOwner } from '@angular/compiler';
+import ts from 'typescript';
+import type { Context } from './context';
+import type { Scope } from './scope';
+import { TcbOp } from './base';
+import { TypeCheckableDirectiveMeta } from '../../api';
+/**
+ * A `TcbOp` which constructs an instance of a directive. For generic directives, generic
+ * parameters are set to `any` type.
+ */
+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);
+    get optional(): boolean;
+    execute(): ts.Identifier;
+}
+/**
+ * A `TcbOp` which constructs an instance of a non-generic directive _without_ setting any of its
+ * inputs. Inputs are later set in the `TcbDirectiveInputsOp`. Type checking was found to be
+ * faster when done in this way as opposed to `TcbDirectiveCtorOp` which is only necessary when the
+ * directive is generic.
+ *
+ * Executing this operation returns a reference to the directive instance variable with its inferred
+ * type.
+ */
+export declare class TcbNonGenericDirectiveTypeOp extends TcbDirectiveTypeOpBase {
+    /**
+     * Creates a variable declaration for this op's directive of the argument type. Returns the id of
+     * the newly created variable.
+     */
+    execute(): ts.Identifier;
+}
+/**
+ * A `TcbOp` which constructs an instance of a generic directive with its generic parameters set
+ * to `any` type. This op is like `TcbDirectiveTypeOp`, except that generic parameters are set to
+ * `any` type. This is used for situations where we want to avoid inlining.
+ *
+ * Executing this operation returns a reference to the directive instance variable with its generic
+ * type parameters set to `any`.
+ */
+export declare class TcbGenericDirectiveTypeWithAnyParamsOp extends TcbDirectiveTypeOpBase {
+    execute(): ts.Identifier;
+}

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

@@ -0,0 +1,26 @@
+/*!
+ * @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 { TmplAstElement } from '@angular/compiler';
+import ts from 'typescript';
+import { TcbOp } from './base';
+import type { Context } from './context';
+import type { Scope } from './scope';
+/**
+ * A `TcbOp` which creates an expression for a native DOM element (or web component) from a
+ * `TmplAstElement`.
+ *
+ * Executing this operation returns a reference to the element variable.
+ */
+export declare class TcbElementOp extends TcbOp {
+    private tcb;
+    private scope;
+    private element;
+    constructor(tcb: Context, scope: Scope, element: TmplAstElement);
+    get optional(): boolean;
+    execute(): ts.Identifier;
+}

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

@@ -0,0 +1,55 @@
+/*!
+ * @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 { AST, DirectiveOwner, TmplAstBoundAttribute, TmplAstBoundEvent } from '@angular/compiler';
+import ts from 'typescript';
+import { TcbOp } from './base';
+import type { Context } from './context';
+import type { Scope } from './scope';
+import { TypeCheckableDirectiveMeta } from '../../api';
+import { LocalSymbol } from './references';
+/**
+ * Similar to `tcbExpression`, this function converts the provided `AST` expression into a
+ * `ts.Expression`, with special handling of the `$event` variable that can be used within event
+ * bindings.
+ */
+export declare function tcbEventHandlerExpression(ast: AST, tcb: Context, scope: Scope): ts.Expression;
+/**
+ * A `TcbOp` which generates code to check event bindings on an element that correspond with the
+ * outputs of a directive.
+ *
+ * Executing this operation returns nothing.
+ */
+export declare class TcbDirectiveOutputsOp extends TcbOp {
+    private tcb;
+    private scope;
+    private node;
+    private inputs;
+    private outputs;
+    private dir;
+    constructor(tcb: Context, scope: Scope, node: DirectiveOwner, inputs: TmplAstBoundAttribute[] | null, outputs: TmplAstBoundEvent[], dir: TypeCheckableDirectiveMeta);
+    get optional(): boolean;
+    execute(): null;
+}
+/**
+ * A `TcbOp` which generates code to check "unclaimed outputs" - event bindings on an element which
+ * were not attributed to any directive or component, and are instead processed against the HTML
+ * element itself.
+ *
+ * Executing this operation returns nothing.
+ */
+export declare class TcbUnclaimedOutputsOp extends TcbOp {
+    private tcb;
+    private scope;
+    private target;
+    private outputs;
+    private inputs;
+    private claimedOutputs;
+    constructor(tcb: Context, scope: Scope, target: LocalSymbol, outputs: TmplAstBoundEvent[], inputs: TmplAstBoundAttribute[] | null, claimedOutputs: Set<string> | null);
+    get optional(): boolean;
+    execute(): null;
+}

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

@@ -0,0 +1,49 @@
+/*!
+ * @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 { AST, PropertyRead, TmplAstLetDeclaration } from '@angular/compiler';
+import ts from 'typescript';
+import { TcbOp } from './base';
+import type { Context } from './context';
+import type { Scope } from './scope';
+/**
+ * Process an `AST` expression and convert it into a `ts.Expression`, generating references to the
+ * correct identifiers in the current scope.
+ */
+export declare function tcbExpression(ast: AST, tcb: Context, scope: Scope): ts.Expression;
+/**
+ * Wraps an expression in an `unwrapSignal` call which extracts the signal's value.
+ */
+export declare function unwrapWritableSignal(expression: ts.Expression, tcb: Context): ts.CallExpression;
+/**
+ * A `TcbOp` which renders an Angular expression (e.g. `{{foo() && bar.baz}}`).
+ *
+ * Executing this operation returns nothing.
+ */
+export declare class TcbExpressionOp extends TcbOp {
+    private tcb;
+    private scope;
+    private expression;
+    constructor(tcb: Context, scope: Scope, expression: AST);
+    get optional(): boolean;
+    execute(): null;
+}
+export declare class TcbExpressionTranslator {
+    protected tcb: Context;
+    protected scope: Scope;
+    constructor(tcb: Context, scope: Scope);
+    translate(ast: AST): ts.Expression;
+    /**
+     * Resolve an `AST` expression within the given scope.
+     *
+     * Some `AST` expressions refer to top-level concepts (references, variables, the component
+     * context). This method assists in resolving those.
+     */
+    protected resolve(ast: AST): ts.Expression | null;
+    private getTargetNodeExpression;
+    protected isValidLetDeclarationAccess(target: TmplAstLetDeclaration, ast: PropertyRead): boolean;
+}