@angular/compiler 17.2.0-next.0 → 17.2.0-rc.0

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.2.0-next.0
+ * @license Angular v17.2.0-rc.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -157,12 +157,12 @@ export declare abstract class ASTWithName extends AST {
     constructor(span: ParseSpan, sourceSpan: AbsoluteSourceSpan, nameSpan: AbsoluteSourceSpan);
 }
 
-export declare class ASTWithSource extends AST {
-    ast: AST;
+export declare class ASTWithSource<T extends AST = AST> extends AST {
+    ast: T;
     source: string | null;
     location: string;
     errors: ParserError[];
-    constructor(ast: AST, source: string | null, location: string, absoluteOffset: number, errors: ParserError[]);
+    constructor(ast: T, source: string | null, location: string, absoluteOffset: number, errors: ParserError[]);
     visit(visitor: AstVisitor, context?: any): any;
     toString(): string;
 }
@@ -401,7 +401,7 @@ declare class BindingParser {
      */
     private _parseTemplateBindings;
     parseLiteralAttr(name: string, value: string | null, sourceSpan: ParseSourceSpan, absoluteOffset: number, valueSpan: ParseSourceSpan | undefined, targetMatchableAttrs: string[][], targetProps: ParsedProperty[], keySpan: ParseSourceSpan): void;
-    parsePropertyBinding(name: string, expression: string, isHost: boolean, sourceSpan: ParseSourceSpan, absoluteOffset: number, valueSpan: ParseSourceSpan | undefined, targetMatchableAttrs: string[][], targetProps: ParsedProperty[], keySpan: ParseSourceSpan): void;
+    parsePropertyBinding(name: string, expression: string, isHost: boolean, isPartOfAssignmentBinding: boolean, sourceSpan: ParseSourceSpan, absoluteOffset: number, valueSpan: ParseSourceSpan | undefined, targetMatchableAttrs: string[][], targetProps: ParsedProperty[], keySpan: ParseSourceSpan): void;
     parsePropertyInterpolation(name: string, value: string, sourceSpan: ParseSourceSpan, valueSpan: ParseSourceSpan | undefined, targetMatchableAttrs: string[][], targetProps: ParsedProperty[], keySpan: ParseSourceSpan, interpolatedTokens: InterpolatedAttributeToken[] | InterpolatedTextToken[] | null): boolean;
     private _parsePropertyAst;
     private _parseAnimation;
@@ -420,6 +420,11 @@ declare class BindingParser {
      * @param isAttr true when binding to an attribute
      */
     private _validatePropertyOrAttributeName;
+    /**
+     * Returns whether a parsed AST is allowed to be used within the event side of a two-way binding.
+     * @param ast Parsed AST to be checked.
+     */
+    private _isAllowedAssignmentEvent;
 }
 
 export declare class BindingPipe extends ASTWithName {
@@ -435,7 +440,8 @@ export declare const enum BindingType {
     Attribute = 1,
     Class = 2,
     Style = 3,
-    Animation = 4
+    Animation = 4,
+    TwoWay = 5
 }
 
 export declare class Block extends NodeWithI18n {
@@ -691,7 +697,10 @@ export declare type CompileClassMetadataFn = (metadata: R3ClassMetadata) => outp
  * Similar to the `setClassMetadata` call, it's wrapped into the `ngDevMode`
  * check to tree-shake away this code in production mode.
  */
-export declare function compileComponentClassMetadata(metadata: R3ClassMetadata, deferrableTypes: Map<string, string> | null): outputAst.Expression;
+export declare function compileComponentClassMetadata(metadata: R3ClassMetadata, deferrableTypes: Map<string, {
+    importPath: string;
+    isDefaultImport: boolean;
+}> | null): outputAst.Expression;
 
 /**
  * Compile a component for the render3 runtime as defined by the `R3ComponentMetadata`.
@@ -799,6 +808,13 @@ export declare class ConstantPool {
     private literals;
     private literalFactories;
     private sharedConstants;
+    /**
+     * Constant pool also tracks claimed names from {@link uniqueName}.
+     * This is useful to avoid collisions if variables are intended to be
+     * named a certain way- but may conflict. We wouldn't want to always suffix
+     * them with unique numbers.
+     */
+    private _claimedNames;
     private nextNameIndex;
     constructor(isClosureCompilerEnabled?: boolean);
     getConstLiteral(literal: outputAst.Expression, forceShared?: boolean): outputAst.Expression;
@@ -810,13 +826,13 @@ export declare class ConstantPool {
     getSharedFunctionReference(fn: outputAst.FunctionExpr | outputAst.ArrowFunctionExpr, prefix: string, useUniqueName?: boolean): outputAst.Expression;
     private _getLiteralFactory;
     /**
-     * Produce a unique name.
+     * Produce a unique name in the context of this pool.
      *
      * The name might be unique among different prefixes if any of the prefixes end in
      * a digit so the prefix should be a constant string (not based on user input) and
      * must not end in a digit.
      */
-    uniqueName(prefix: string): string;
+    uniqueName(name: string, alwaysIncludeSuffix?: boolean): string;
     private freshName;
 }
 
@@ -2217,210 +2233,6 @@ declare namespace outputAst {
 }
 export { outputAst }
 
-export declare class _ParseAST {
-    input: string;
-    location: string;
-    absoluteOffset: number;
-    tokens: Token[];
-    parseFlags: ParseFlags;
-    private errors;
-    private offset;
-    private rparensExpected;
-    private rbracketsExpected;
-    private rbracesExpected;
-    private context;
-    private sourceSpanCache;
-    index: number;
-    constructor(input: string, location: string, absoluteOffset: number, tokens: Token[], parseFlags: ParseFlags, errors: ParserError[], offset: number);
-    peek(offset: number): Token;
-    get next(): Token;
-    /** Whether all the parser input has been processed. */
-    get atEOF(): boolean;
-    /**
-     * Index of the next token to be processed, or the end of the last token if all have been
-     * processed.
-     */
-    get inputIndex(): number;
-    /**
-     * End index of the last processed token, or the start of the first token if none have been
-     * processed.
-     */
-    get currentEndIndex(): number;
-    /**
-     * Returns the absolute offset of the start of the current token.
-     */
-    get currentAbsoluteOffset(): number;
-    /**
-     * Retrieve a `ParseSpan` from `start` to the current position (or to `artificialEndIndex` if
-     * provided).
-     *
-     * @param start Position from which the `ParseSpan` will start.
-     * @param artificialEndIndex Optional ending index to be used if provided (and if greater than the
-     *     natural ending index)
-     */
-    span(start: number, artificialEndIndex?: number): ParseSpan;
-    sourceSpan(start: number, artificialEndIndex?: number): AbsoluteSourceSpan;
-    advance(): void;
-    /**
-     * Executes a callback in the provided context.
-     */
-    private withContext;
-    consumeOptionalCharacter(code: number): boolean;
-    peekKeywordLet(): boolean;
-    peekKeywordAs(): boolean;
-    /**
-     * Consumes an expected character, otherwise emits an error about the missing expected character
-     * and skips over the token stream until reaching a recoverable point.
-     *
-     * See `this.error` and `this.skip` for more details.
-     */
-    expectCharacter(code: number): void;
-    consumeOptionalOperator(op: string): boolean;
-    expectOperator(operator: string): void;
-    prettyPrintToken(tok: Token): string;
-    expectIdentifierOrKeyword(): string | null;
-    expectIdentifierOrKeywordOrString(): string;
-    parseChain(): AST;
-    parsePipe(): AST;
-    parseExpression(): AST;
-    parseConditional(): AST;
-    parseLogicalOr(): AST;
-    parseLogicalAnd(): AST;
-    parseNullishCoalescing(): AST;
-    parseEquality(): AST;
-    parseRelational(): AST;
-    parseAdditive(): AST;
-    parseMultiplicative(): AST;
-    parsePrefix(): AST;
-    parseCallChain(): AST;
-    parsePrimary(): AST;
-    parseExpressionList(terminator: number): AST[];
-    parseLiteralMap(): LiteralMap;
-    parseAccessMember(readReceiver: AST, start: number, isSafe: boolean): AST;
-    parseCall(receiver: AST, start: number, isSafe: boolean): AST;
-    private consumeOptionalAssignment;
-    parseCallArguments(): BindingPipe[];
-    /**
-     * Parses an identifier, a keyword, a string with an optional `-` in between,
-     * and returns the string along with its absolute source span.
-     */
-    expectTemplateBindingKey(): TemplateBindingIdentifier;
-    /**
-     * Parse microsyntax template expression and return a list of bindings or
-     * parsing errors in case the given expression is invalid.
-     *
-     * For example,
-     * ```
-     *   <div *ngFor="let item of items; index as i; trackBy: func">
-     * ```
-     * contains five bindings:
-     * 1. ngFor -> null
-     * 2. item -> NgForOfContext.$implicit
-     * 3. ngForOf -> items
-     * 4. i -> NgForOfContext.index
-     * 5. ngForTrackBy -> func
-     *
-     * For a full description of the microsyntax grammar, see
-     * https://gist.github.com/mhevery/d3530294cff2e4a1b3fe15ff75d08855
-     *
-     * @param templateKey name of the microsyntax directive, like ngIf, ngFor,
-     * without the *, along with its absolute span.
-     */
-    parseTemplateBindings(templateKey: TemplateBindingIdentifier): TemplateBindingParseResult;
-    parseKeyedReadOrWrite(receiver: AST, start: number, isSafe: boolean): AST;
-    /**
-     * Parse a directive keyword, followed by a mandatory expression.
-     * For example, "of items", "trackBy: func".
-     * The bindings are: ngForOf -> items, ngForTrackBy -> func
-     * There could be an optional "as" binding that follows the expression.
-     * For example,
-     * ```
-     *   *ngFor="let item of items | slice:0:1 as collection".
-     *                    ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^
-     *               keyword    bound target   optional 'as' binding
-     * ```
-     *
-     * @param key binding key, for example, ngFor, ngIf, ngForOf, along with its
-     * absolute span.
-     */
-    private parseDirectiveKeywordBindings;
-    /**
-     * Return the expression AST for the bound target of a directive keyword
-     * binding. For example,
-     * ```
-     *   *ngIf="condition | pipe"
-     *          ^^^^^^^^^^^^^^^^ bound target for "ngIf"
-     *   *ngFor="let item of items"
-     *                       ^^^^^ bound target for "ngForOf"
-     * ```
-     */
-    private getDirectiveBoundTarget;
-    /**
-     * Return the binding for a variable declared using `as`. Note that the order
-     * of the key-value pair in this declaration is reversed. For example,
-     * ```
-     *   *ngFor="let item of items; index as i"
-     *                              ^^^^^    ^
-     *                              value    key
-     * ```
-     *
-     * @param value name of the value in the declaration, "ngIf" in the example
-     * above, along with its absolute span.
-     */
-    private parseAsBinding;
-    /**
-     * Return the binding for a variable declared using `let`. For example,
-     * ```
-     *   *ngFor="let item of items; let i=index;"
-     *           ^^^^^^^^           ^^^^^^^^^^^
-     * ```
-     * In the first binding, `item` is bound to `NgForOfContext.$implicit`.
-     * In the second binding, `i` is bound to `NgForOfContext.index`.
-     */
-    private parseLetBinding;
-    /**
-     * Consume the optional statement terminator: semicolon or comma.
-     */
-    private consumeStatementTerminator;
-    /**
-     * Records an error and skips over the token stream until reaching a recoverable point. See
-     * `this.skip` for more details on token skipping.
-     */
-    error(message: string, index?: number | null): void;
-    private locationText;
-    /**
-     * Records an error for an unexpected private identifier being discovered.
-     * @param token Token representing a private identifier.
-     * @param extraMessage Optional additional message being appended to the error.
-     */
-    private _reportErrorForPrivateIdentifier;
-    /**
-     * Error recovery should skip tokens until it encounters a recovery point.
-     *
-     * The following are treated as unconditional recovery points:
-     *   - end of input
-     *   - ';' (parseChain() is always the root production, and it expects a ';')
-     *   - '|' (since pipes may be chained and each pipe expression may be treated independently)
-     *
-     * The following are conditional recovery points:
-     *   - ')', '}', ']' if one of calling productions is expecting one of these symbols
-     *     - This allows skip() to recover from errors such as '(a.) + 1' allowing more of the AST to
-     *       be retained (it doesn't skip any tokens as the ')' is retained because of the '(' begins
-     *       an '(' <expr> ')' production).
-     *       The recovery points of grouping symbols must be conditional as they must be skipped if
-     *       none of the calling productions are not expecting the closing token else we will never
-     *       make progress in the case of an extraneous group closing symbol (such as a stray ')').
-     *       That is, we skip a closing symbol if we are not in a grouping production.
-     *   - '=' in a `Writable` context
-     *     - In this context, we are able to recover after seeing the `=` operator, which
-     *       signals the presence of an independent rvalue expression following the `=` operator.
-     *
-     * If a production expects one of these token it increments the corresponding nesting count,
-     * and then decrements it just prior to checking if the token is in the input.
-     */
-    private skip;
-}
-
 export declare class ParsedEvent {
     name: string;
     targetOrPhase: string;
@@ -2429,12 +2241,14 @@ export declare class ParsedEvent {
     sourceSpan: ParseSourceSpan;
     handlerSpan: ParseSourceSpan;
     readonly keySpan: ParseSourceSpan;
+    constructor(name: string, targetOrPhase: string, type: ParsedEventType.TwoWay, handler: ASTWithSource<NonNullAssert | PropertyRead | KeyedRead>, sourceSpan: ParseSourceSpan, handlerSpan: ParseSourceSpan, keySpan: ParseSourceSpan);
     constructor(name: string, targetOrPhase: string, type: ParsedEventType, handler: ASTWithSource, sourceSpan: ParseSourceSpan, handlerSpan: ParseSourceSpan, keySpan: ParseSourceSpan);
 }
 
 export declare const enum ParsedEventType {
     Regular = 0,
-    Animation = 1
+    Animation = 1,
+    TwoWay = 2
 }
 
 export declare interface ParsedHostBindings {
@@ -2468,7 +2282,8 @@ export declare class ParsedProperty {
 export declare enum ParsedPropertyType {
     DEFAULT = 0,
     LITERAL_ATTR = 1,
-    ANIMATION = 2
+    ANIMATION = 2,
+    TWO_WAY = 3
 }
 
 /**
@@ -2549,12 +2364,7 @@ export declare const enum ParseFlags {
     /**
      * Whether an output binding is being parsed.
      */
-    Action = 1,
-    /**
-     * Whether an assignment event is being parsed, i.e. an expression originating from
-     * two-way-binding aka banana-in-a-box syntax.
-     */
-    AssignmentEvent = 2
+    Action = 1
 }
 
 export declare function parseHostBindings(host: {
@@ -2579,7 +2389,7 @@ export declare class Parser {
     private _lexer;
     private errors;
     constructor(_lexer: Lexer);
-    parseAction(input: string, isAssignmentEvent: boolean, location: string, absoluteOffset: number, interpolationConfig?: InterpolationConfig): ASTWithSource;
+    parseAction(input: string, location: string, absoluteOffset: number, interpolationConfig?: InterpolationConfig): ASTWithSource;
     parseBinding(input: string, location: string, absoluteOffset: number, interpolationConfig?: InterpolationConfig): ASTWithSource;
     private checkSimpleExpression;
     parseSimpleBinding(input: string, location: string, absoluteOffset: number, interpolationConfig?: InterpolationConfig): ASTWithSource;
@@ -3035,7 +2845,10 @@ export declare interface R3ComponentMetadata<DeclarationT extends R3TemplateDepe
     /**
      * Map of deferrable symbol names -> corresponding import paths.
      */
-    deferrableTypes: Map<string, string>;
+    deferrableTypes: Map<string, {
+        importPath: string;
+        isDefaultImport: boolean;
+    }>;
     /**
      * Specifies how the 'directives' and/or `pipes` array, if generated, need to be emitted.
      */
@@ -3090,6 +2903,7 @@ export declare interface R3ComponentMetadata<DeclarationT extends R3TemplateDepe
      * not be set. If component has empty array imports then this field is not set.
      */
     rawImports?: outputAst.Expression;
+    useTemplatePipeline: boolean;
 }
 
 /**
@@ -3622,6 +3436,10 @@ export declare interface R3DeferBlockTemplateDependency {
      * Import path where this dependency is located.
      */
     importPath: string | null;
+    /**
+     * Whether the symbol is the default export.
+     */
+    isDefaultImport: boolean;
 }
 
 declare interface R3DelegatedFnOrClassMetadata extends R3ConstructorFactoryMetadata {
@@ -3840,6 +3658,7 @@ export declare interface R3HostMetadata {
         styleAttr?: string;
         classAttr?: string;
     };
+    useTemplatePipeline: boolean;
 }
 
 export declare class R3Identifiers {
@@ -4029,6 +3848,9 @@ export declare class R3Identifiers {
     static viewQuerySignal: outputAst.ExternalReference;
     static contentQuerySignal: outputAst.ExternalReference;
     static queryAdvance: outputAst.ExternalReference;
+    static twoWayProperty: outputAst.ExternalReference;
+    static twoWayBindingSet: outputAst.ExternalReference;
+    static twoWayListener: outputAst.ExternalReference;
     static NgOnChangesFeature: outputAst.ExternalReference;
     static InheritDefinitionFeature: outputAst.ExternalReference;
     static CopyDefinitionFeature: outputAst.ExternalReference;
@@ -4056,6 +3878,10 @@ export declare class R3Identifiers {
         name: string;
         moduleName: string;
     };
+    static unwrapWritableSignal: {
+        name: string;
+        moduleName: string;
+    };
 }
 
 export declare interface R3InjectableMetadata {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler",
-  "version": "17.2.0-next.0",
+  "version": "17.2.0-rc.0",
   "description": "Angular - the compiler library",
   "author": "angular",
   "license": "MIT",
@@ -11,7 +11,7 @@
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
-    "@angular/core": "17.2.0-next.0"
+    "@angular/core": "17.2.0-rc.0"
   },
   "peerDependenciesMeta": {
     "@angular/core": {