@angular/core 21.0.0-next.6 → 21.0.0-next.8

package/schematics/bundles/{project_tsconfig_paths-sFatqIE5.cjs → project_tsconfig_paths-CdhVNYMk.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v21.0.0-next.6
+ * @license Angular v21.0.0-next.8
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2725,6 +2725,8 @@ class Identifiers {
     static domProperty = { name: 'ɵɵdomProperty', moduleName: CORE };
     static ariaProperty = { name: 'ɵɵariaProperty', moduleName: CORE };
     static property = { name: 'ɵɵproperty', moduleName: CORE };
+    static control = { name: 'ɵɵcontrol', moduleName: CORE };
+    static controlCreate = { name: 'ɵɵcontrolCreate', moduleName: CORE };
     static animationEnterListener = {
         name: 'ɵɵanimateEnterListener',
         moduleName: CORE,
@@ -2905,6 +2907,16 @@ class Identifiers {
         name: 'ɵɵvalidateIframeAttribute',
         moduleName: CORE,
     };
+    // Decorators
+    static inputDecorator = { name: 'Input', moduleName: CORE };
+    static outputDecorator = { name: 'Output', moduleName: CORE };
+    static viewChildDecorator = { name: 'ViewChild', moduleName: CORE };
+    static viewChildrenDecorator = { name: 'ViewChildren', moduleName: CORE };
+    static contentChildDecorator = { name: 'ContentChild', moduleName: CORE };
+    static contentChildrenDecorator = {
+        name: 'ContentChildren',
+        moduleName: CORE,
+    };
     // type-checking
     static InputSignalBrandWriteType = { name: 'ɵINPUT_SIGNAL_BRAND_WRITE_TYPE', moduleName: CORE };
     static UnwrapDirectiveSignalInputs = { name: 'ɵUnwrapDirectiveSignalInputs', moduleName: CORE };
@@ -4831,9 +4843,11 @@ class InteractionDeferredTrigger extends DeferredTrigger {
 }
 class ViewportDeferredTrigger extends DeferredTrigger {
     reference;
-    constructor(reference, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan) {
+    options;
+    constructor(reference, options, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan) {
         super(nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
         this.reference = reference;
+        this.options = options;
     }
 }
 class BlockNode {
@@ -8657,6 +8671,17 @@ var OpKind;
      * An operation to bind animation events to an element.
      */
     OpKind[OpKind["AnimationListener"] = 56] = "AnimationListener";
+    /**
+     * An operation to bind an expression to a `field` property of an element.
+     */
+    OpKind[OpKind["Control"] = 57] = "Control";
+    /**
+     * An operation to set up a corresponding {@link Control} operation.
+     *
+     * This is responsible for setting up event listeners on a native or custom form control when
+     * bound to a specialized field directive.
+     */
+    OpKind[OpKind["ControlCreate"] = 58] = "ControlCreate";
 })(OpKind || (OpKind = {}));
 /**
  * Distinguishes different kinds of IR expressions.
@@ -9327,6 +9352,25 @@ function createStoreLetOp(target, declaredName, value, sourceSpan) {
         ...NEW_OP,
     };
 }
+/** Creates a {@link ControlOp}. */
+function createControlOp(op) {
+    return {
+        kind: OpKind.Control,
+        target: op.target,
+        expression: op.expression,
+        bindingKind: op.bindingKind,
+        securityContext: op.securityContext,
+        sanitizer: null,
+        isStructuralTemplateAttribute: op.isStructuralTemplateAttribute,
+        templateKind: op.templateKind,
+        i18nContext: op.i18nContext,
+        i18nMessage: op.i18nMessage,
+        sourceSpan: op.sourceSpan,
+        ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
+        ...NEW_OP,
+    };
+}
 
 /**
  * Check whether a given `o.Expression` is a logical IR expression type.
@@ -10109,6 +10153,7 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.Property:
         case OpKind.DomProperty:
         case OpKind.Attribute:
+        case OpKind.Control:
             if (op.expression instanceof Interpolation) {
                 transformExpressionsInInterpolation(op.expression, transform, flags);
             }
@@ -10234,6 +10279,7 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.SourceLocation:
         case OpKind.ConditionalCreate:
         case OpKind.ConditionalBranchCreate:
+        case OpKind.ControlCreate:
             // These operations contain no expressions.
             break;
         default:
@@ -11134,6 +11180,10 @@ function createSourceLocationOp(templatePath, locations) {
         ...NEW_OP,
     };
 }
+/** Creates a {@link ControlCreateOp}. */
+function createControlCreateOp(sourceSpan) {
+    return { kind: OpKind.ControlCreate, sourceSpan, ...NEW_OP };
+}
 
 function createDomPropertyOp(name, expression, bindingKind, i18nContext, securityContext, sourceSpan) {
     return {
@@ -11612,6 +11662,14 @@ function extractAttributes(job) {
                         /* i18nMessage */ null, op.securityContext), lookupElement$3(elements, op.target));
                     }
                     break;
+                case OpKind.Control:
+                    OpList.insertBefore(
+                    // Deliberately null i18nMessage value
+                    createExtractedAttributeOp(op.target, BindingKind.Property, null, 'field', 
+                    /* expression */ null, 
+                    /* i18nContext */ null, 
+                    /* i18nMessage */ null, op.securityContext), lookupElement$3(elements, op.target));
+                    break;
                 case OpKind.TwoWayProperty:
                     OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.TwoWayProperty, null, op.name, 
                     /* expression */ null, 
@@ -11771,6 +11829,9 @@ function specializeBindings(job) {
                     else if (job.kind === CompilationJobKind.Host) {
                         OpList.replace(op, createDomPropertyOp(op.name, op.expression, op.bindingKind, op.i18nContext, op.securityContext, op.sourceSpan));
                     }
+                    else if (op.name === 'field') {
+                        OpList.replace(op, createControlOp(op));
+                    }
                     else {
                         OpList.replace(op, createPropertyOp(op.target, op.name, op.expression, op.bindingKind, op.securityContext, op.isStructuralTemplateAttribute, op.templateKind, op.i18nContext, op.i18nMessage, op.sourceSpan));
                     }
@@ -23620,7 +23681,7 @@ function deferOn(trigger, args, modifier, sourceSpan) {
     if (instructionToCall === undefined) {
         throw new Error(`Unable to determine instruction for trigger ${trigger}`);
     }
-    return call(instructionToCall, args.map((a) => literal(a)), sourceSpan);
+    return call(instructionToCall, args, sourceSpan);
 }
 function projectionDef(def) {
     return call(Identifiers.projectionDef, def ? [def] : [], null);
@@ -23749,6 +23810,22 @@ function ariaProperty(name, expression, sourceSpan) {
 function property(name, expression, sanitizer, sourceSpan) {
     return propertyBase(Identifiers.property, name, expression, sanitizer, sourceSpan);
 }
+function control(expression, sanitizer, sourceSpan) {
+    const args = [];
+    if (expression instanceof Interpolation) {
+        args.push(interpolationToExpression(expression, sourceSpan));
+    }
+    else {
+        args.push(expression);
+    }
+    if (sanitizer !== null) {
+        args.push(sanitizer);
+    }
+    return call(Identifiers.control, args, sourceSpan);
+}
+function controlCreate(sourceSpan) {
+    return call(Identifiers.controlCreate, [], sourceSpan);
+}
 function twoWayProperty(name, expression, sanitizer, sourceSpan) {
     const args = [literal(name), expression];
     if (sanitizer !== null) {
@@ -24195,11 +24272,30 @@ function reifyCreateOperations(unit, ops) {
                     case DeferTriggerKind.Immediate:
                         break;
                     case DeferTriggerKind.Timer:
-                        args = [op.trigger.delay];
+                        args = [literal(op.trigger.delay)];
+                        break;
+                    case DeferTriggerKind.Viewport:
+                        // `hydrate` triggers don't support targets.
+                        if (op.modifier === "hydrate" /* ir.DeferOpModifierKind.HYDRATE */) {
+                            args = op.trigger.options ? [op.trigger.options] : [];
+                        }
+                        else {
+                            // The slots not being defined at this point is invalid, however we
+                            // catch it during type checking. Pass in null in such cases.
+                            args = [literal(op.trigger.targetSlot?.slot ?? null)];
+                            if (op.trigger.targetSlotViewSteps !== 0) {
+                                args.push(literal(op.trigger.targetSlotViewSteps));
+                            }
+                            else if (op.trigger.options) {
+                                args.push(literal(null));
+                            }
+                            if (op.trigger.options) {
+                                args.push(op.trigger.options);
+                            }
+                        }
                         break;
                     case DeferTriggerKind.Interaction:
                     case DeferTriggerKind.Hover:
-                    case DeferTriggerKind.Viewport:
                         // `hydrate` triggers don't support targets.
                         if (op.modifier === "hydrate" /* ir.DeferOpModifierKind.HYDRATE */) {
                             args = [];
@@ -24207,9 +24303,9 @@ function reifyCreateOperations(unit, ops) {
                         else {
                             // The slots not being defined at this point is invalid, however we
                             // catch it during type checking. Pass in null in such cases.
-                            args = [op.trigger.targetSlot?.slot ?? null];
+                            args = [literal(op.trigger.targetSlot?.slot ?? null)];
                             if (op.trigger.targetSlotViewSteps !== 0) {
-                                args.push(op.trigger.targetSlotViewSteps);
+                                args.push(literal(op.trigger.targetSlotViewSteps));
                             }
                         }
                         break;
@@ -24309,6 +24405,9 @@ function reifyCreateOperations(unit, ops) {
                 }));
                 OpList.replace(op, attachSourceLocation(op.templatePath, locationsLiteral));
                 break;
+            case OpKind.ControlCreate:
+                OpList.replace(op, controlCreate(op.sourceSpan));
+                break;
             case OpKind.Statement:
                 // Pass statement operations directly through.
                 break;
@@ -24331,6 +24430,9 @@ function reifyUpdateOperations(unit, ops) {
                     ? reifyDomProperty(op)
                     : reifyProperty(op));
                 break;
+            case OpKind.Control:
+                OpList.replace(op, reifyControl(op));
+                break;
             case OpKind.TwoWayProperty:
                 OpList.replace(op, twoWayProperty(op.name, op.expression, op.sanitizer, op.sourceSpan));
                 break;
@@ -24426,6 +24528,9 @@ function reifyProperty(op) {
         ? ariaProperty(op.name, op.expression, op.sourceSpan)
         : property(op.name, op.expression, op.sanitizer, op.sourceSpan);
 }
+function reifyControl(op) {
+    return control(op.expression, op.sanitizer, op.sourceSpan);
+}
 function reifyIrExpression(expr) {
     if (!isIrExpression(expr)) {
         return expr;
@@ -25938,6 +26043,7 @@ function varsUsedByOp(op) {
             return slots;
         case OpKind.Property:
         case OpKind.DomProperty:
+        case OpKind.Control:
             slots = 1;
             // We need to assign a slot even for singleton interpolations, because the
             // runtime needs to store both the raw value and the stringified one.
@@ -27075,6 +27181,9 @@ function ingestDeferTriggers(modifier, triggers, onOps, whenOps, unit, deferXref
             targetSlot: null,
             targetView: null,
             targetSlotViewSteps: null,
+            options: triggers.viewport.options
+                ? convertAst(triggers.viewport.options, unit.job, triggers.viewport.sourceSpan)
+                : null,
         }, modifier, triggers.viewport.sourceSpan);
         onOps.push(deferOnOp);
     }
@@ -27405,6 +27514,11 @@ function ingestElementBindings(unit, op, element) {
         }
         // All dynamic bindings (both attribute and property bindings).
         bindings.push(createBindingOp(op.xref, BINDING_KINDS.get(input.type), input.name, convertAstWithInterpolation(unit.job, astOf(input.value), input.i18n), input.unit, input.securityContext, false, false, null, asMessage(input.i18n) ?? null, input.sourceSpan));
+        // If the input name is 'field', this could be a form control binding which requires a
+        // `ControlCreateOp` to properly initialize.
+        if (input.type === exports.BindingType.Property && input.name === 'field') {
+            unit.create.push(createControlCreateOp(input.sourceSpan));
+        }
     }
     unit.create.push(bindings.filter((b) => b?.kind === OpKind.ExtractedAttribute));
     unit.update.push(bindings.filter((b) => b?.kind === OpKind.Binding));
@@ -28581,6 +28695,7 @@ function createForLoop(ast, connectedBlocks, visitor, bindingParser) {
             // main `for` body, use `mainSourceSpan`.
             const endSpan = empty?.endSourceSpan ?? ast.endSourceSpan;
             const sourceSpan = new ParseSourceSpan(ast.sourceSpan.start, endSpan?.end ?? ast.sourceSpan.end);
+            validateTrackByExpression(params.trackBy.expression, params.trackBy.keywordSpan, errors);
             node = new ForLoopBlock(params.itemName, params.expression, params.trackBy.expression, params.trackBy.keywordSpan, params.context, visitAll(visitor, ast.children, ast.children), empty, sourceSpan, ast.sourceSpan, ast.startSourceSpan, endSpan, ast.nameSpan, ast.i18n);
         }
     }
@@ -28680,6 +28795,13 @@ function parseForLoopParameters(block, errors, bindingParser) {
     }
     return result;
 }
+function validateTrackByExpression(expression, parseSourceSpan, errors) {
+    const visitor = new PipeVisitor();
+    expression.ast.visit(visitor);
+    if (visitor.hasPipe) {
+        errors.push(new ParseError(parseSourceSpan, 'Cannot use pipes in track expressions'));
+    }
+}
 /** Parses the `let` parameter of a `for` loop block. */
 function parseLetParameter(sourceSpan, expression, span, loopItemName, context, errors) {
     const parts = expression.split(',');
@@ -28890,6 +29012,12 @@ function stripOptionalParentheses(param, errors) {
     }
     return expression.slice(start, end);
 }
+class PipeVisitor extends RecursiveAstVisitor {
+    hasPipe = false;
+    visitPipe() {
+        this.hasPipe = true;
+    }
+}
 
 /** Pattern for a timing value in a trigger. */
 const TIME_PATTERN = /^\d+\.?\d*(ms|s)?$/;
@@ -28945,7 +29073,7 @@ function parseWhenTrigger({ expression, sourceSpan }, bindingParser, triggers, e
     }
 }
 /** Parses an `on` trigger */
-function parseOnTrigger({ expression, sourceSpan }, triggers, errors, placeholder) {
+function parseOnTrigger({ expression, sourceSpan }, bindingParser, triggers, errors, placeholder) {
     const onIndex = expression.indexOf('on');
     const onSourceSpan = new ParseSourceSpan(sourceSpan.start.moveBy(onIndex), sourceSpan.start.moveBy(onIndex + 'on'.length));
     const prefetchSpan = getPrefetchSpan(expression, sourceSpan);
@@ -28957,9 +29085,10 @@ function parseOnTrigger({ expression, sourceSpan }, triggers, errors, placeholde
     }
     else {
         const start = getTriggerParametersStart(expression, onIndex + 1);
-        const parser = new OnTriggerParser(expression, start, sourceSpan, triggers, errors, expression.startsWith('hydrate')
+        const isHydrationTrigger = expression.startsWith('hydrate');
+        const parser = new OnTriggerParser(expression, bindingParser, start, sourceSpan, triggers, errors, isHydrationTrigger
             ? validateHydrateReferenceBasedTrigger
-            : validatePlainReferenceBasedTrigger, placeholder, prefetchSpan, onSourceSpan, hydrateSpan);
+            : validatePlainReferenceBasedTrigger, isHydrationTrigger, prefetchSpan, onSourceSpan, hydrateSpan);
         parser.parse();
     }
 }
@@ -28977,25 +29106,27 @@ function getHydrateSpan(expression, sourceSpan) {
 }
 class OnTriggerParser {
     expression;
+    bindingParser;
     start;
     span;
     triggers;
     errors;
     validator;
-    placeholder;
+    isHydrationTrigger;
     prefetchSpan;
     onSourceSpan;
     hydrateSpan;
     index = 0;
     tokens;
-    constructor(expression, start, span, triggers, errors, validator, placeholder, prefetchSpan, onSourceSpan, hydrateSpan) {
+    constructor(expression, bindingParser, start, span, triggers, errors, validator, isHydrationTrigger, prefetchSpan, onSourceSpan, hydrateSpan) {
         this.expression = expression;
+        this.bindingParser = bindingParser;
         this.start = start;
         this.span = span;
         this.triggers = triggers;
         this.errors = errors;
         this.validator = validator;
-        this.placeholder = placeholder;
+        this.isHydrationTrigger = isHydrationTrigger;
         this.prefetchSpan = prefetchSpan;
         this.onSourceSpan = onSourceSpan;
         this.hydrateSpan = hydrateSpan;
@@ -29069,10 +29200,10 @@ class OnTriggerParser {
                     this.trackTrigger('immediate', createImmediateTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan));
                     break;
                 case OnTriggerType.HOVER:
-                    this.trackTrigger('hover', createHoverTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan, this.placeholder, this.validator));
+                    this.trackTrigger('hover', createHoverTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan, this.validator));
                     break;
                 case OnTriggerType.VIEWPORT:
-                    this.trackTrigger('viewport', createViewportTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan, this.validator));
+                    this.trackTrigger('viewport', createViewportTrigger(this.start, this.isHydrationTrigger, this.bindingParser, parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan, this.validator));
                     break;
                 default:
                     throw new Error(`Unrecognized trigger type "${identifier}"`);
@@ -29090,15 +29221,15 @@ class OnTriggerParser {
         }
         this.advance();
         const commaDelimStack = [];
-        let current = '';
+        let tokens = [];
         while (this.index < this.tokens.length) {
             const token = this.token();
             // Stop parsing if we've hit the end character and we're outside of a comma-delimited syntax.
             // Note that we don't need to account for strings here since the lexer already parsed them
             // into string tokens.
             if (token.isCharacter($RPAREN) && commaDelimStack.length === 0) {
-                if (current.length) {
-                    parameters.push(current);
+                if (tokens.length) {
+                    parameters.push({ expression: this.tokenRangeText(tokens), start: tokens[0].index });
                 }
                 break;
             }
@@ -29117,14 +29248,14 @@ class OnTriggerParser {
             }
             // If we hit a comma outside of a comma-delimited syntax, it means
             // that we're at the top level and we're starting a new parameter.
-            if (commaDelimStack.length === 0 && token.isCharacter($COMMA) && current.length > 0) {
-                parameters.push(current);
-                current = '';
+            if (commaDelimStack.length === 0 && token.isCharacter($COMMA) && tokens.length > 0) {
+                parameters.push({ expression: this.tokenRangeText(tokens), start: tokens[0].index });
                 this.advance();
+                tokens = [];
                 continue;
             }
             // Otherwise treat the token as a plain text character in the current parameter.
-            current += this.tokenText();
+            tokens.push(token);
             this.advance();
         }
         if (!this.token().isCharacter($RPAREN) || commaDelimStack.length > 0) {
@@ -29136,10 +29267,11 @@ class OnTriggerParser {
         }
         return parameters;
     }
-    tokenText() {
-        // Tokens have a toString already which we could use, but for string tokens it omits the quotes.
-        // Eventually we could expose this information on the token directly.
-        return this.expression.slice(this.start + this.token().index, this.start + this.token().end);
+    tokenRangeText(tokens) {
+        if (tokens.length === 0) {
+            return '';
+        }
+        return this.expression.slice(this.start + tokens[0].index, this.start + tokens[tokens.length - 1].end);
     }
     trackTrigger(name, trigger) {
         trackTrigger(name, this.triggers, this.errors, trigger);
@@ -29172,7 +29304,7 @@ function createTimerTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSo
     if (parameters.length !== 1) {
         throw new Error(`"${OnTriggerType.TIMER}" trigger must have exactly one parameter`);
     }
-    const delay = parseDeferredTime(parameters[0]);
+    const delay = parseDeferredTime(parameters[0].expression);
     if (delay === null) {
         throw new Error(`Could not parse time value of trigger "${OnTriggerType.TIMER}"`);
     }
@@ -29184,17 +29316,61 @@ function createImmediateTrigger(parameters, nameSpan, sourceSpan, prefetchSpan,
     }
     return new ImmediateDeferredTrigger(nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
 }
-function createHoverTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan, placeholder, validator) {
+function createHoverTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan, validator) {
     validator(OnTriggerType.HOVER, parameters);
-    return new HoverDeferredTrigger(parameters[0] ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
+    return new HoverDeferredTrigger(parameters[0]?.expression ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
 }
 function createInteractionTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan, validator) {
     validator(OnTriggerType.INTERACTION, parameters);
-    return new InteractionDeferredTrigger(parameters[0] ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
+    return new InteractionDeferredTrigger(parameters[0]?.expression ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
 }
-function createViewportTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan, validator) {
+function createViewportTrigger(start, isHydrationTrigger, bindingParser, parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan, validator) {
     validator(OnTriggerType.VIEWPORT, parameters);
-    return new ViewportDeferredTrigger(parameters[0] ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
+    let reference;
+    let options;
+    if (parameters.length === 0) {
+        reference = options = null;
+    }
+    else if (!parameters[0].expression.startsWith('{')) {
+        reference = parameters[0].expression;
+        options = null;
+    }
+    else {
+        const parsed = bindingParser.parseBinding(parameters[0].expression, false, sourceSpan, sourceSpan.start.offset + start + parameters[0].start);
+        if (!(parsed.ast instanceof LiteralMap)) {
+            throw new Error('Options parameter of the "viewport" trigger must be an object literal');
+        }
+        else if (parsed.ast.keys.some((key) => key.key === 'root')) {
+            throw new Error('The "root" option is not supported in the options parameter of the "viewport" trigger');
+        }
+        const triggerIndex = parsed.ast.keys.findIndex((key) => key.key === 'trigger');
+        if (triggerIndex === -1) {
+            reference = null;
+            options = parsed.ast;
+        }
+        else {
+            const value = parsed.ast.values[triggerIndex];
+            const triggerFilter = (_, index) => index !== triggerIndex;
+            if (!(value instanceof PropertyRead) ||
+                !(value.receiver instanceof ImplicitReceiver) ||
+                value.receiver instanceof ThisReceiver) {
+                throw new Error(`"trigger" option of the "viewport" trigger must be an identifier`);
+            }
+            reference = value.name;
+            options = new LiteralMap(parsed.ast.span, parsed.ast.sourceSpan, parsed.ast.keys.filter(triggerFilter), parsed.ast.values.filter(triggerFilter));
+        }
+    }
+    if (isHydrationTrigger && reference !== null) {
+        throw new Error(`"viewport" hydration trigger cannot have a "trigger"`);
+    }
+    else if (options) {
+        const dynamicNode = DynamicAstValidator.findDynamicNode(options);
+        if (dynamicNode !== null) {
+            throw new Error(`Options of the "viewport" trigger must be an object ` +
+                `literal containing only literal values, but "${dynamicNode.constructor.name}" was found`);
+        }
+    }
+    return new ViewportDeferredTrigger(reference, options, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
 }
 /**
  * Checks whether the structure of a non-hydrate reference-based trigger is valid.
@@ -29212,6 +29388,12 @@ function validatePlainReferenceBasedTrigger(type, parameters) {
  * @param parameters Parameters of the trigger.
  */
 function validateHydrateReferenceBasedTrigger(type, parameters) {
+    if (type === OnTriggerType.VIEWPORT) {
+        if (parameters.length > 1) {
+            throw new Error(`Hydration trigger "${type}" cannot have more than one parameter`);
+        }
+        return;
+    }
     if (parameters.length > 0) {
         throw new Error(`Hydration trigger "${type}" cannot have parameters`);
     }
@@ -29241,6 +29423,25 @@ function parseDeferredTime(value) {
     const [time, units] = match;
     return parseFloat(time) * (units === 's' ? 1000 : 1);
 }
+class DynamicAstValidator extends RecursiveAstVisitor {
+    dynamicNode = null;
+    static findDynamicNode(ast) {
+        const visitor = new DynamicAstValidator();
+        visitor.visit(ast);
+        return visitor.dynamicNode;
+    }
+    visit(ast) {
+        if (!(ast instanceof ASTWithSource) &&
+            !(ast instanceof LiteralPrimitive) &&
+            !(ast instanceof LiteralArray) &&
+            !(ast instanceof LiteralMap)) {
+            this.dynamicNode = ast;
+        }
+        else {
+            super.visit(ast);
+        }
+    }
+}
 
 /** Pattern to identify a `prefetch when` trigger. */
 const PREFETCH_WHEN_PATTERN = /^prefetch\s+when\s/;
@@ -29271,7 +29472,7 @@ function isConnectedDeferLoopBlock(name) {
 function createDeferredBlock(ast, connectedBlocks, visitor, bindingParser) {
     const errors = [];
     const { placeholder, loading, error } = parseConnectedBlocks(connectedBlocks, errors, visitor);
-    const { triggers, prefetchTriggers, hydrateTriggers } = parsePrimaryTriggers(ast, bindingParser, errors, placeholder);
+    const { triggers, prefetchTriggers, hydrateTriggers } = parsePrimaryTriggers(ast, bindingParser, errors);
     // The `defer` block has a main span encompassing all of the connected branches as well.
     let lastEndSourceSpan = ast.endSourceSpan;
     let endOfLastSourceSpan = ast.sourceSpan.end;
@@ -29393,19 +29594,19 @@ function parsePrimaryTriggers(ast, bindingParser, errors, placeholder) {
             parseWhenTrigger(param, bindingParser, triggers, errors);
         }
         else if (ON_PARAMETER_PATTERN.test(param.expression)) {
-            parseOnTrigger(param, triggers, errors, placeholder);
+            parseOnTrigger(param, bindingParser, triggers, errors);
         }
         else if (PREFETCH_WHEN_PATTERN.test(param.expression)) {
             parseWhenTrigger(param, bindingParser, prefetchTriggers, errors);
         }
         else if (PREFETCH_ON_PATTERN.test(param.expression)) {
-            parseOnTrigger(param, prefetchTriggers, errors, placeholder);
+            parseOnTrigger(param, bindingParser, prefetchTriggers, errors);
         }
         else if (HYDRATE_WHEN_PATTERN.test(param.expression)) {
             parseWhenTrigger(param, bindingParser, hydrateTriggers, errors);
         }
         else if (HYDRATE_ON_PATTERN.test(param.expression)) {
-            parseOnTrigger(param, hydrateTriggers, errors, placeholder);
+            parseOnTrigger(param, bindingParser, hydrateTriggers, errors);
         }
         else if (HYDRATE_NEVER_PATTERN.test(param.expression)) {
             parseNeverTrigger(param, hydrateTriggers, errors);
@@ -30360,7 +30561,7 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
         : TemplateCompilationMode.Full;
     // First the template is ingested into IR:
     const tpl = ingestComponent(meta.name, meta.template.nodes, constantPool, compilationMode, meta.relativeContextFilePath, meta.i18nUseExternalIds, meta.defer, allDeferrableDepsFn, meta.relativeTemplatePath, getTemplateSourceLocationsEnabled());
-    // Then the IR is transformed to prepare it for cod egeneration.
+    // Then the IR is transformed to prepare it for code generation.
     transform(tpl, CompilationJobKind.Tmpl);
     // Finally we emit the template function:
     const templateFn = emitTemplateFn(tpl, constantPool);
@@ -30815,6 +31016,9 @@ class CombinedRecursiveAstVisitor extends RecursiveAstVisitor {
         if (trigger instanceof BoundDeferredTrigger) {
             this.visit(trigger.value);
         }
+        else if (trigger instanceof ViewportDeferredTrigger && trigger.options !== null) {
+            this.visit(trigger.options);
+        }
     }
     visitDeferredBlockPlaceholder(block) {
         this.visitAllTemplateNodes(block.children);
@@ -32909,7 +33113,7 @@ function isAttrNode(ast) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('21.0.0-next.6');
+const VERSION = new Version('21.0.0-next.8');
 
 //////////////////////////////////////
 // THIS FILE HAS GLOBAL SIDE EFFECT //
@@ -33285,6 +33489,12 @@ exports.ErrorCode = void 0;
      * ```
      */
     ErrorCode[ErrorCode["DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER"] = 8020] = "DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER";
+    /**
+     * Raised when an `@defer` block defines unreachable or redundant triggers.
+     * Examples: multiple main triggers, 'on immediate' together with other mains or any prefetch,
+     * prefetch timer delay that is not earlier than the main timer, or an identical prefetch
+     */
+    ErrorCode[ErrorCode["DEFER_TRIGGER_MISCONFIGURATION"] = 8021] = "DEFER_TRIGGER_MISCONFIGURATION";
     /**
      * A two way binding in a template has an incorrect syntax,
      * parentheses outside brackets. For example:
@@ -33646,6 +33856,7 @@ exports.ExtendedTemplateDiagnosticName = void 0;
     ExtendedTemplateDiagnosticName["UNUSED_STANDALONE_IMPORTS"] = "unusedStandaloneImports";
     ExtendedTemplateDiagnosticName["UNPARENTHESIZED_NULLISH_COALESCING"] = "unparenthesizedNullishCoalescing";
     ExtendedTemplateDiagnosticName["UNINVOKED_FUNCTION_IN_TEXT_INTERPOLATION"] = "uninvokedFunctionInTextInterpolation";
+    ExtendedTemplateDiagnosticName["DEFER_TRIGGER_MISCONFIGURATION"] = "deferTriggerMisconfiguration";
 })(exports.ExtendedTemplateDiagnosticName || (exports.ExtendedTemplateDiagnosticName = {}));
 
 /**
@@ -33972,7 +34183,7 @@ class NodeJSPathManipulation {
 // G3-ESM-MARKER: G3 uses CommonJS, but externally everything in ESM.
 // CommonJS/ESM interop for determining the current file name and containing dir.
 const isCommonJS = typeof __filename !== 'undefined';
-const currentFileUrl = isCommonJS ? null : (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('project_tsconfig_paths-sFatqIE5.cjs', document.baseURI).href));
+const currentFileUrl = isCommonJS ? null : (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('project_tsconfig_paths-CdhVNYMk.cjs', document.baseURI).href));
 // Note, when this code loads in the browser, `url` may be an empty `{}` due to the Closure shims.
 const currentFileName = isCommonJS
     ? __filename
@@ -40375,6 +40586,120 @@ function parseFieldStringArrayValue(directive, field, evaluator) {
     }
     return value;
 }
+/**
+ * Returns a function that can be used to extract data for the `setClassMetadata`
+ * calls from undecorated directive class members.
+ */
+function getDirectiveUndecoratedMetadataExtractor(reflector, importTracker) {
+    return (member) => {
+        const input = tryParseSignalInputMapping(member, reflector, importTracker);
+        if (input !== null) {
+            return getDecoratorMetaArray([
+                [new ExternalExpr(Identifiers.inputDecorator), memberMetadataFromSignalInput(input)],
+            ]);
+        }
+        const output = tryParseInitializerBasedOutput(member, reflector, importTracker);
+        if (output !== null) {
+            return getDecoratorMetaArray([
+                [
+                    new ExternalExpr(Identifiers.outputDecorator),
+                    memberMetadataFromInitializerOutput(output.metadata),
+                ],
+            ]);
+        }
+        const model = tryParseSignalModelMapping(member, reflector, importTracker);
+        if (model !== null) {
+            return getDecoratorMetaArray([
+                [
+                    new ExternalExpr(Identifiers.inputDecorator),
+                    memberMetadataFromSignalInput(model.input),
+                ],
+                [
+                    new ExternalExpr(Identifiers.outputDecorator),
+                    memberMetadataFromInitializerOutput(model.output),
+                ],
+            ]);
+        }
+        const query = tryParseSignalQueryFromInitializer(member, reflector, importTracker);
+        if (query !== null) {
+            let identifier;
+            if (query.name === 'viewChild') {
+                identifier = Identifiers.viewChildDecorator;
+            }
+            else if (query.name === 'viewChildren') {
+                identifier = Identifiers.viewChildrenDecorator;
+            }
+            else if (query.name === 'contentChild') {
+                identifier = Identifiers.contentChildDecorator;
+            }
+            else if (query.name === 'contentChildren') {
+                identifier = Identifiers.contentChildrenDecorator;
+            }
+            else {
+                return null;
+            }
+            return getDecoratorMetaArray([
+                [new ExternalExpr(identifier), memberMetadataFromSignalQuery(query.call)],
+            ]);
+        }
+        return null;
+    };
+}
+function getDecoratorMetaArray(decorators) {
+    return new LiteralArrayExpr(decorators.map(([type, args]) => literalMap([
+        { key: 'type', value: type, quoted: false },
+        { key: 'args', value: args, quoted: false },
+    ])));
+}
+function memberMetadataFromSignalInput(input) {
+    // Note that for signal inputs the transform is captured in the signal
+    // initializer so we don't need to capture it here.
+    return new LiteralArrayExpr([
+        literalMap([
+            {
+                key: 'isSignal',
+                value: literal(true),
+                quoted: false,
+            },
+            {
+                key: 'alias',
+                value: literal(input.bindingPropertyName),
+                quoted: false,
+            },
+            {
+                key: 'required',
+                value: literal(input.required),
+                quoted: false,
+            },
+        ]),
+    ]);
+}
+function memberMetadataFromInitializerOutput(output) {
+    return new LiteralArrayExpr([literal(output.bindingPropertyName)]);
+}
+function memberMetadataFromSignalQuery(call) {
+    const firstArg = call.arguments[0];
+    const firstArgMeta = ts.isStringLiteralLike(firstArg) || ts.isCallExpression(firstArg)
+        ? new WrappedNodeExpr(firstArg)
+        : // If the first argument is a class reference, we need to wrap it in a `forwardRef`
+            // because the reference might occur after the current class. This wouldn't be flagged
+            // on the query initializer, because it executes after the class is initialized, whereas
+            // `setClassMetadata` runs immediately.
+            new ExternalExpr(Identifiers.forwardRef).callFn([
+                new ArrowFunctionExpr([], new WrappedNodeExpr(firstArg)),
+            ]);
+    const entries = [
+        // We use wrapped nodes here, because the output AST doesn't support spread assignments.
+        firstArgMeta,
+        new WrappedNodeExpr(ts.factory.createObjectLiteralExpression([
+            ...(call.arguments.length > 1
+                ? [ts.factory.createSpreadAssignment(call.arguments[1])]
+                : []),
+            ts.factory.createPropertyAssignment('isSignal', ts.factory.createTrue()),
+        ])),
+    ];
+    return new LiteralArrayExpr(entries);
+}
 function isStringArrayOrDie(value, name, node) {
     if (!Array.isArray(value)) {
         return false;
@@ -44695,10 +45020,10 @@ class OutOfBandDiagnosticRecorderImpl {
         this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), node.keySpan || node.sourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.UNCLAIMED_DIRECTIVE_BINDING), errorMsg));
     }
     deferImplicitTriggerMissingPlaceholder(id, trigger) {
-        this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), trigger.sourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.DEFER_IMPLICIT_TRIGGER_MISSING_PLACEHOLDER), 'Trigger with no parameters can only be placed on an @defer that has a @placeholder block'));
+        this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), trigger.sourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.DEFER_IMPLICIT_TRIGGER_MISSING_PLACEHOLDER), 'Trigger with no target can only be placed on an @defer that has a @placeholder block'));
     }
     deferImplicitTriggerInvalidPlaceholder(id, trigger) {
-        this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), trigger.sourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER), 'Trigger with no parameters can only be placed on an @defer that has a ' +
+        this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), trigger.sourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER), 'Trigger with no target can only be placed on an @defer that has a ' +
             '@placeholder block with exactly one root element node'));
     }
 }
@@ -46916,6 +47241,28 @@ class TcbForOfOp extends TcbOp {
         return null;
     }
 }
+/**
+ * A `TcbOp` which can be used to type check the options of an `IntersectionObserver`.
+ */
+class TcbIntersectionObserverOp extends TcbOp {
+    tcb;
+    scope;
+    options;
+    constructor(tcb, scope, options) {
+        super();
+        this.tcb = tcb;
+        this.scope = scope;
+        this.options = options;
+    }
+    optional = false;
+    execute() {
+        const options = tcbExpression(this.options, this.tcb, this.scope);
+        const callback = ts.factory.createNonNullExpression(ts.factory.createNull());
+        const expression = ts.factory.createNewExpression(ts.factory.createIdentifier('IntersectionObserver'), undefined, [callback, options]);
+        this.scope.addStatement(ts.factory.createExpressionStatement(expression));
+        return null;
+    }
+}
 /**
  * Overall generation context for the type check block.
  *
@@ -47687,6 +48034,9 @@ class Scope {
         if (triggers.when !== undefined) {
             this.opQueue.push(new TcbExpressionOp(this.tcb, this, triggers.when.value));
         }
+        if (triggers.viewport !== undefined && triggers.viewport.options !== null) {
+            this.opQueue.push(new TcbIntersectionObserverOp(this.tcb, this, triggers.viewport.options));
+        }
         if (triggers.hover !== undefined) {
             this.validateReferenceBasedDeferredTrigger(block, triggers.hover);
         }
@@ -49657,6 +50007,9 @@ class TemplateTypeCheckerImpl {
         const { data } = this.getLatestComponentState(directive, optimizeFor);
         return data?.hostElement ?? null;
     }
+    getDirectivesOfNode(component, node) {
+        return (this.getLatestComponentState(component).data?.boundTarget.getDirectivesOfNode(node) ?? null);
+    }
     getUsedDirectives(component) {
         return this.getLatestComponentState(component).data?.boundTarget.getUsedDirectives() ?? null;
     }
@@ -50992,6 +51345,7 @@ exports.Declaration = Declaration;
 exports.DeclareFunctionStmt = DeclareFunctionStmt;
 exports.DeclareVarStmt = DeclareVarStmt;
 exports.DefaultImportTracker = DefaultImportTracker;
+exports.DeferredBlock = DeferredBlock;
 exports.DefinitionMap = DefinitionMap;
 exports.Directive = Directive$1;
 exports.DomElementSchemaRegistry = DomElementSchemaRegistry;
@@ -51006,14 +51360,17 @@ exports.FatalDiagnosticError = FatalDiagnosticError;
 exports.FnParam = FnParam;
 exports.ForLoopBlock = ForLoopBlock;
 exports.FunctionExpr = FunctionExpr;
+exports.HoverDeferredTrigger = HoverDeferredTrigger;
 exports.HtmlParser = HtmlParser;
 exports.INPUT_INITIALIZER_FN = INPUT_INITIALIZER_FN;
 exports.Icu = Icu;
 exports.IcuPlaceholder = IcuPlaceholder;
 exports.Identifiers = Identifiers;
 exports.IfBlock = IfBlock;
+exports.ImmediateDeferredTrigger = ImmediateDeferredTrigger;
 exports.ImplicitReceiver = ImplicitReceiver;
 exports.ImportManager = ImportManager;
+exports.InteractionDeferredTrigger = InteractionDeferredTrigger;
 exports.Interpolation = Interpolation$1;
 exports.InvokeFunctionExpr = InvokeFunctionExpr;
 exports.KeyedRead = KeyedRead;
@@ -51068,6 +51425,7 @@ exports.Text$1 = Text$1;
 exports.Text$2 = Text$2;
 exports.TextAttribute = TextAttribute;
 exports.ThisReceiver = ThisReceiver;
+exports.TimerDeferredTrigger = TimerDeferredTrigger;
 exports.Trait = Trait;
 exports.TypeCheckShimGenerator = TypeCheckShimGenerator;
 exports.TypeScriptReflectionHost = TypeScriptReflectionHost;
@@ -51075,6 +51433,7 @@ exports.UNSAFE_OBJECT_KEY_NAME_REGEXP = UNSAFE_OBJECT_KEY_NAME_REGEXP;
 exports.UnifiedModulesStrategy = UnifiedModulesStrategy;
 exports.Variable = Variable;
 exports.Version = Version;
+exports.ViewportDeferredTrigger = ViewportDeferredTrigger;
 exports.WhitespaceVisitor = WhitespaceVisitor;
 exports.WrappedNodeExpr = WrappedNodeExpr;
 exports.Xmb = Xmb;
@@ -51130,6 +51489,7 @@ exports.getConstructorDependencies = getConstructorDependencies;
 exports.getContainingImportDeclaration = getContainingImportDeclaration;
 exports.getDefaultImportDeclaration = getDefaultImportDeclaration;
 exports.getDirectiveDiagnostics = getDirectiveDiagnostics;
+exports.getDirectiveUndecoratedMetadataExtractor = getDirectiveUndecoratedMetadataExtractor;
 exports.getFileSystem = getFileSystem;
 exports.getOriginNodeForDiagnostics = getOriginNodeForDiagnostics;
 exports.getProjectTsConfigPaths = getProjectTsConfigPaths;