@angular/compiler-cli 21.0.0-next.7 → 21.0.0-next.8

package/bundles/chunk-DT6FD4OE.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-next.7";
+var PLACEHOLDER_VERSION = "21.0.0-next.8";
 function wrapReference(wrapped) {
   return { value: wrapped, type: wrapped };
 }

package/bundles/{chunk-O7L4BBZY.js → chunk-ELPMV5DB.js}

@@ -102,6 +102,7 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["UNCLAIMED_DIRECTIVE_BINDING"] = 8018] = "UNCLAIMED_DIRECTIVE_BINDING";
   ErrorCode2[ErrorCode2["DEFER_IMPLICIT_TRIGGER_MISSING_PLACEHOLDER"] = 8019] = "DEFER_IMPLICIT_TRIGGER_MISSING_PLACEHOLDER";
   ErrorCode2[ErrorCode2["DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER"] = 8020] = "DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER";
+  ErrorCode2[ErrorCode2["DEFER_TRIGGER_MISCONFIGURATION"] = 8021] = "DEFER_TRIGGER_MISCONFIGURATION";
   ErrorCode2[ErrorCode2["INVALID_BANANA_IN_BOX"] = 8101] = "INVALID_BANANA_IN_BOX";
   ErrorCode2[ErrorCode2["NULLISH_COALESCING_NOT_NULLABLE"] = 8102] = "NULLISH_COALESCING_NOT_NULLABLE";
   ErrorCode2[ErrorCode2["MISSING_CONTROL_FLOW_DIRECTIVE"] = 8103] = "MISSING_CONTROL_FLOW_DIRECTIVE";
@@ -249,6 +250,7 @@ var ExtendedTemplateDiagnosticName;
   ExtendedTemplateDiagnosticName2["UNUSED_STANDALONE_IMPORTS"] = "unusedStandaloneImports";
   ExtendedTemplateDiagnosticName2["UNPARENTHESIZED_NULLISH_COALESCING"] = "unparenthesizedNullishCoalescing";
   ExtendedTemplateDiagnosticName2["UNINVOKED_FUNCTION_IN_TEXT_INTERPOLATION"] = "uninvokedFunctionInTextInterpolation";
+  ExtendedTemplateDiagnosticName2["DEFER_TRIGGER_MISCONFIGURATION"] = "deferTriggerMisconfiguration";
 })(ExtendedTemplateDiagnosticName || (ExtendedTemplateDiagnosticName = {}));
 
 // packages/compiler-cli/src/ngtsc/reflection/src/typescript.js
@@ -3145,8 +3147,8 @@ var StaticInterpreter = class {
     if (ts13.isIdentifier(node) || ts13.isStringLiteral(node) || ts13.isNumericLiteral(node)) {
       return node.text;
     } else if (ts13.isComputedPropertyName(node)) {
-      const literal3 = this.visitExpression(node.expression, context);
-      return typeof literal3 === "string" ? literal3 : void 0;
+      const literal4 = this.visitExpression(node.expression, context);
+      return typeof literal4 === "string" ? literal4 : void 0;
     } else {
       return void 0;
     }
@@ -7365,7 +7367,7 @@ var InjectableClassRegistry = class {
 // packages/compiler-cli/src/ngtsc/annotations/common/src/metadata.js
 import { ArrowFunctionExpr, LiteralArrayExpr, LiteralExpr as LiteralExpr2, literalMap, WrappedNodeExpr as WrappedNodeExpr4 } from "@angular/compiler";
 import ts35 from "typescript";
-function extractClassMetadata(clazz, reflection, isCore, annotateForClosureCompiler, angularDecoratorTransform = (dec) => dec) {
+function extractClassMetadata(clazz, reflection, isCore, annotateForClosureCompiler, angularDecoratorTransform = (dec) => dec, undecoratedMetadataExtractor = () => null) {
   if (!reflection.isClass(clazz)) {
     return null;
   }
@@ -7386,15 +7388,41 @@ function extractClassMetadata(clazz, reflection, isCore, annotateForClosureCompi
     metaCtorParameters = new ArrowFunctionExpr([], new LiteralArrayExpr(ctorParameters));
   }
   let metaPropDecorators = null;
-  const classMembers = reflection.getMembersOfClass(clazz).filter((member) => !member.isStatic && member.decorators !== null && member.decorators.length > 0 && // Private fields are not supported in the metadata emit
+  const classMembers = reflection.getMembersOfClass(clazz).filter((member) => !member.isStatic && // Private fields are not supported in the metadata emit
   member.accessLevel !== ClassMemberAccessLevel.EcmaScriptPrivate);
-  const duplicateDecoratedMembers = classMembers.filter((member, i, arr) => arr.findIndex((arrayMember) => arrayMember.name === member.name) < i);
-  if (duplicateDecoratedMembers.length > 0) {
+  const decoratedMembers = [];
+  const seenMemberNames = /* @__PURE__ */ new Set();
+  let duplicateDecoratedMembers = null;
+  for (const member of classMembers) {
+    const shouldQuoteName = member.nameNode !== null && ts35.isStringLiteralLike(member.nameNode);
+    if (member.decorators !== null && member.decorators.length > 0) {
+      decoratedMembers.push({
+        key: member.name,
+        quoted: shouldQuoteName,
+        value: decoratedClassMemberToMetadata(member.decorators, isCore)
+      });
+      if (seenMemberNames.has(member.name)) {
+        duplicateDecoratedMembers ??= [];
+        duplicateDecoratedMembers.push(member);
+      } else {
+        seenMemberNames.add(member.name);
+      }
+    } else {
+      const undecoratedMetadata = undecoratedMetadataExtractor(member);
+      if (undecoratedMetadata !== null) {
+        decoratedMembers.push({
+          key: member.name,
+          quoted: shouldQuoteName,
+          value: undecoratedMetadata
+        });
+      }
+    }
+  }
+  if (duplicateDecoratedMembers !== null) {
     throw new FatalDiagnosticError(ErrorCode.DUPLICATE_DECORATED_PROPERTIES, duplicateDecoratedMembers[0].nameNode ?? clazz, `Duplicate decorated properties found on class '${clazz.name.text}': ` + duplicateDecoratedMembers.map((member) => member.name).join(", "));
   }
-  const decoratedMembers = classMembers.map((member) => classMemberToMetadata(member.nameNode ?? member.name, member.decorators, isCore));
   if (decoratedMembers.length > 0) {
-    metaPropDecorators = new WrappedNodeExpr4(ts35.factory.createObjectLiteralExpression(decoratedMembers));
+    metaPropDecorators = literalMap(decoratedMembers);
   }
   return {
     type: new WrappedNodeExpr4(id),
@@ -7415,10 +7443,9 @@ function ctorParameterToMetadata(param, isCore) {
   }
   return literalMap(mapEntries);
 }
-function classMemberToMetadata(name, decorators, isCore) {
-  const ngDecorators = decorators.filter((dec) => isAngularDecorator2(dec, isCore)).map((decorator) => decoratorToMetadata(decorator));
-  const decoratorMeta = ts35.factory.createArrayLiteralExpression(ngDecorators);
-  return ts35.factory.createPropertyAssignment(name, decoratorMeta);
+function decoratedClassMemberToMetadata(decorators, isCore) {
+  const ngDecorators = decorators.filter((dec) => isAngularDecorator2(dec, isCore)).map((decorator) => new WrappedNodeExpr4(decoratorToMetadata(decorator)));
+  return new LiteralArrayExpr(ngDecorators);
 }
 function decoratorToMetadata(decorator, wrapFunctionsInParens) {
   if (decorator.identifier === null) {
@@ -8647,7 +8674,7 @@ import { compileClassMetadata, compileDeclareClassMetadata, compileDeclareDirect
 import ts65 from "typescript";
 
 // packages/compiler-cli/src/ngtsc/annotations/directive/src/shared.js
-import { createMayBeForwardRefExpression as createMayBeForwardRefExpression2, emitDistinctChangesOnlyDefaultValue, ExternalExpr as ExternalExpr6, ExternalReference as ExternalReference2, getSafePropertyAccessString, parseHostBindings, verifyHostBindings, WrappedNodeExpr as WrappedNodeExpr6 } from "@angular/compiler";
+import { createMayBeForwardRefExpression as createMayBeForwardRefExpression2, emitDistinctChangesOnlyDefaultValue, ExternalExpr as ExternalExpr6, ExternalReference as ExternalReference2, getSafePropertyAccessString, LiteralArrayExpr as LiteralArrayExpr2, literalMap as literalMap2, parseHostBindings, verifyHostBindings, R3Identifiers, ArrowFunctionExpr as ArrowFunctionExpr2, WrappedNodeExpr as WrappedNodeExpr6, literal as literal3 } from "@angular/compiler";
 import ts43 from "typescript";
 
 // packages/compiler-cli/src/ngtsc/annotations/directive/src/initializer_function_access.js
@@ -9322,6 +9349,108 @@ function parseFieldStringArrayValue(directive, field, evaluator) {
   }
   return value;
 }
+function getDirectiveUndecoratedMetadataExtractor(reflector, importTracker) {
+  return (member) => {
+    const input = tryParseSignalInputMapping(member, reflector, importTracker);
+    if (input !== null) {
+      return getDecoratorMetaArray([
+        [new ExternalExpr6(R3Identifiers.inputDecorator), memberMetadataFromSignalInput(input)]
+      ]);
+    }
+    const output = tryParseInitializerBasedOutput(member, reflector, importTracker);
+    if (output !== null) {
+      return getDecoratorMetaArray([
+        [
+          new ExternalExpr6(R3Identifiers.outputDecorator),
+          memberMetadataFromInitializerOutput(output.metadata)
+        ]
+      ]);
+    }
+    const model = tryParseSignalModelMapping(member, reflector, importTracker);
+    if (model !== null) {
+      return getDecoratorMetaArray([
+        [
+          new ExternalExpr6(R3Identifiers.inputDecorator),
+          memberMetadataFromSignalInput(model.input)
+        ],
+        [
+          new ExternalExpr6(R3Identifiers.outputDecorator),
+          memberMetadataFromInitializerOutput(model.output)
+        ]
+      ]);
+    }
+    const query = tryParseSignalQueryFromInitializer(member, reflector, importTracker);
+    if (query !== null) {
+      let identifier;
+      if (query.name === "viewChild") {
+        identifier = R3Identifiers.viewChildDecorator;
+      } else if (query.name === "viewChildren") {
+        identifier = R3Identifiers.viewChildrenDecorator;
+      } else if (query.name === "contentChild") {
+        identifier = R3Identifiers.contentChildDecorator;
+      } else if (query.name === "contentChildren") {
+        identifier = R3Identifiers.contentChildrenDecorator;
+      } else {
+        return null;
+      }
+      return getDecoratorMetaArray([
+        [new ExternalExpr6(identifier), memberMetadataFromSignalQuery(query.call)]
+      ]);
+    }
+    return null;
+  };
+}
+function getDecoratorMetaArray(decorators) {
+  return new LiteralArrayExpr2(decorators.map(([type, args]) => literalMap2([
+    { key: "type", value: type, quoted: false },
+    { key: "args", value: args, quoted: false }
+  ])));
+}
+function memberMetadataFromSignalInput(input) {
+  return new LiteralArrayExpr2([
+    literalMap2([
+      {
+        key: "isSignal",
+        value: literal3(true),
+        quoted: false
+      },
+      {
+        key: "alias",
+        value: literal3(input.bindingPropertyName),
+        quoted: false
+      },
+      {
+        key: "required",
+        value: literal3(input.required),
+        quoted: false
+      }
+    ])
+  ]);
+}
+function memberMetadataFromInitializerOutput(output) {
+  return new LiteralArrayExpr2([literal3(output.bindingPropertyName)]);
+}
+function memberMetadataFromSignalQuery(call) {
+  const firstArg = call.arguments[0];
+  const firstArgMeta = ts43.isStringLiteralLike(firstArg) || ts43.isCallExpression(firstArg) ? new WrappedNodeExpr6(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 ExternalExpr6(R3Identifiers.forwardRef).callFn([
+      new ArrowFunctionExpr2([], new WrappedNodeExpr6(firstArg))
+    ])
+  );
+  const entries = [
+    // We use wrapped nodes here, because the output AST doesn't support spread assignments.
+    firstArgMeta,
+    new WrappedNodeExpr6(ts43.factory.createObjectLiteralExpression([
+      ...call.arguments.length > 1 ? [ts43.factory.createSpreadAssignment(call.arguments[1])] : [],
+      ts43.factory.createPropertyAssignment("isSignal", ts43.factory.createTrue())
+    ]))
+  ];
+  return new LiteralArrayExpr2(entries);
+}
 function isStringArrayOrDie(value, name, node) {
   if (!Array.isArray(value)) {
     return false;
@@ -12178,11 +12307,11 @@ var ReferenceEmitEnvironment = class {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/type_constructor.js
-import { ExpressionType as ExpressionType2, R3Identifiers as R3Identifiers2, WrappedNodeExpr as WrappedNodeExpr7 } from "@angular/compiler";
+import { ExpressionType as ExpressionType2, R3Identifiers as R3Identifiers3, WrappedNodeExpr as WrappedNodeExpr7 } from "@angular/compiler";
 import ts54 from "typescript";
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/tcb_util.js
-import { R3Identifiers } from "@angular/compiler";
+import { R3Identifiers as R3Identifiers2 } from "@angular/compiler";
 import ts53 from "typescript";
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/type_parameter_emitter.js
@@ -12277,12 +12406,12 @@ var TypeParameterEmitter = class {
 import { BindingType, CssSelector as CssSelector2, makeBindingParser, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstHostElement, AbsoluteSourceSpan as AbsoluteSourceSpan2, ParseSpan, PropertyRead as PropertyRead2, ParsedEventType, Call, ThisReceiver, KeyedRead, LiteralPrimitive, RecursiveAstVisitor, ASTWithName, SafeCall, ImplicitReceiver as ImplicitReceiver2 } from "@angular/compiler";
 import ts52 from "typescript";
 var GUARD_COMMENT_TEXT = "hostBindingsBlockGuard";
-function createHostElement(type, selector, sourceNode, literal3, bindingDecorators, listenerDecorators) {
+function createHostElement(type, selector, sourceNode, literal4, bindingDecorators, listenerDecorators) {
   const bindings = [];
   const listeners = [];
   let parser = null;
-  if (literal3 !== null) {
-    for (const prop of literal3.properties) {
+  if (literal4 !== null) {
+    for (const prop of literal4.properties) {
       if (ts52.isPropertyAssignment(prop) && ts52.isStringLiteralLike(prop.initializer) && isStaticName(prop.name)) {
         parser ??= makeBindingParser();
         createNodeFromHostLiteralProperty(prop, parser, bindings, listeners);
@@ -12508,7 +12637,7 @@ var TCB_FILE_IMPORT_GRAPH_PREPARE_IDENTIFIERS = [
   // Imports may be added for signal input checking. We wouldn't want to change the
   // import graph for incremental compilations when suddenly a signal input is used,
   // or removed.
-  R3Identifiers.InputSignalBrandWriteType
+  R3Identifiers2.InputSignalBrandWriteType
 ];
 var TcbInliningRequirement;
 (function(TcbInliningRequirement2) {
@@ -12742,7 +12871,7 @@ function constructTypeCtorParameter(env, meta, rawType) {
   }
   if (signalInputKeys.length > 0) {
     const keyTypeUnion = ts54.factory.createUnionTypeNode(signalInputKeys);
-    const unwrapDirectiveSignalInputsExpr = env.referenceExternalType(R3Identifiers2.UnwrapDirectiveSignalInputs.moduleName, R3Identifiers2.UnwrapDirectiveSignalInputs.name, [
+    const unwrapDirectiveSignalInputsExpr = env.referenceExternalType(R3Identifiers3.UnwrapDirectiveSignalInputs.moduleName, R3Identifiers3.UnwrapDirectiveSignalInputs.name, [
       // TODO:
       new ExpressionType2(new WrappedNodeExpr7(rawType)),
       new ExpressionType2(new WrappedNodeExpr7(keyTypeUnion))
@@ -13118,10 +13247,10 @@ Deferred blocks can only access triggers in same view, a parent embedded view or
     this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), node.keySpan || node.sourceSpan, ts56.DiagnosticCategory.Error, ngErrorCode(ErrorCode.UNCLAIMED_DIRECTIVE_BINDING), errorMsg));
   }
   deferImplicitTriggerMissingPlaceholder(id, trigger) {
-    this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), trigger.sourceSpan, ts56.DiagnosticCategory.Error, ngErrorCode(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, ts56.DiagnosticCategory.Error, ngErrorCode(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, ts56.DiagnosticCategory.Error, ngErrorCode(ErrorCode.DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER), "Trigger with no parameters can only be placed on an @defer that has a @placeholder block with exactly one root element node"));
+    this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), trigger.sourceSpan, ts56.DiagnosticCategory.Error, ngErrorCode(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"));
   }
 };
 function makeInlineDiagnostic(id, code, node, messageText, relatedInformation) {
@@ -13149,7 +13278,7 @@ var TypeCheckShimGenerator = class {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/type_check_block.js
-import { BindingPipe, BindingType as BindingType2, Call as Call3, createCssSelectorFromNode, CssSelector as CssSelector3, DYNAMIC_TYPE, ImplicitReceiver as ImplicitReceiver3, ParsedEventType as ParsedEventType2, PropertyRead as PropertyRead4, R3Identifiers as R3Identifiers3, SafeCall as SafeCall2, SafePropertyRead as SafePropertyRead3, SelectorMatcher as SelectorMatcher2, ThisReceiver as ThisReceiver2, TmplAstBoundAttribute as TmplAstBoundAttribute2, TmplAstBoundText, TmplAstContent, TmplAstDeferredBlock, TmplAstElement as TmplAstElement2, TmplAstForLoopBlock, TmplAstIcu, TmplAstIfBlock, TmplAstIfBlockBranch, TmplAstLetDeclaration as TmplAstLetDeclaration2, TmplAstReference as TmplAstReference2, TmplAstSwitchBlock, TmplAstTemplate, TmplAstText, TmplAstTextAttribute as TmplAstTextAttribute2, TmplAstVariable, TmplAstHostElement as TmplAstHostElement2, TransplantedType, TmplAstComponent as TmplAstComponent2, TmplAstDirective as TmplAstDirective2, Binary } from "@angular/compiler";
+import { BindingPipe, BindingType as BindingType2, Call as Call3, createCssSelectorFromNode, CssSelector as CssSelector3, DYNAMIC_TYPE, ImplicitReceiver as ImplicitReceiver3, ParsedEventType as ParsedEventType2, PropertyRead as PropertyRead4, R3Identifiers as R3Identifiers4, SafeCall as SafeCall2, SafePropertyRead as SafePropertyRead3, SelectorMatcher as SelectorMatcher2, ThisReceiver as ThisReceiver2, TmplAstBoundAttribute as TmplAstBoundAttribute2, TmplAstBoundText, TmplAstContent, TmplAstDeferredBlock, TmplAstElement as TmplAstElement2, TmplAstForLoopBlock, TmplAstIcu, TmplAstIfBlock, TmplAstIfBlockBranch, TmplAstLetDeclaration as TmplAstLetDeclaration2, TmplAstReference as TmplAstReference2, TmplAstSwitchBlock, TmplAstTemplate, TmplAstText, TmplAstTextAttribute as TmplAstTextAttribute2, TmplAstVariable, TmplAstHostElement as TmplAstHostElement2, TransplantedType, TmplAstComponent as TmplAstComponent2, TmplAstDirective as TmplAstDirective2, Binary } from "@angular/compiler";
 import ts60 from "typescript";
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/diagnostics.js
@@ -13339,8 +13468,8 @@ var AstTranslator = class {
   }
   visitLiteralArray(ast) {
     const elements = ast.expressions.map((expr) => this.translate(expr));
-    const literal3 = ts59.factory.createArrayLiteralExpression(elements);
-    const node = this.config.strictLiteralTypes ? literal3 : tsCastToAny(literal3);
+    const literal4 = ts59.factory.createArrayLiteralExpression(elements);
+    const node = this.config.strictLiteralTypes ? literal4 : tsCastToAny(literal4);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
@@ -13349,8 +13478,8 @@ var AstTranslator = class {
       const value = this.translate(ast.values[idx]);
       return ts59.factory.createPropertyAssignment(ts59.factory.createStringLiteral(key), value);
     });
-    const literal3 = ts59.factory.createObjectLiteralExpression(properties, true);
-    const node = this.config.strictLiteralTypes ? literal3 : tsCastToAny(literal3);
+    const literal4 = ts59.factory.createObjectLiteralExpression(properties, true);
+    const node = this.config.strictLiteralTypes ? literal4 : tsCastToAny(literal4);
     addParseSpanInfo(node, ast.sourceSpan);
     return node;
   }
@@ -14124,9 +14253,9 @@ var TcbDirectiveInputsOp = class extends TcbOp {
           target = this.dir.stringLiteralInputFields.has(fieldName) ? ts60.factory.createElementAccessExpression(dirId, ts60.factory.createStringLiteral(fieldName)) : ts60.factory.createPropertyAccessExpression(dirId, ts60.factory.createIdentifier(fieldName));
         }
         if (isSignal) {
-          const inputSignalBrandWriteSymbol = this.tcb.env.referenceExternalSymbol(R3Identifiers3.InputSignalBrandWriteType.moduleName, R3Identifiers3.InputSignalBrandWriteType.name);
+          const inputSignalBrandWriteSymbol = this.tcb.env.referenceExternalSymbol(R3Identifiers4.InputSignalBrandWriteType.moduleName, R3Identifiers4.InputSignalBrandWriteType.name);
           if (!ts60.isIdentifier(inputSignalBrandWriteSymbol) && !ts60.isPropertyAccessExpression(inputSignalBrandWriteSymbol)) {
-            throw new Error(`Expected identifier or property access for reference to ${R3Identifiers3.InputSignalBrandWriteType.name}`);
+            throw new Error(`Expected identifier or property access for reference to ${R3Identifiers4.InputSignalBrandWriteType.name}`);
           }
           target = ts60.factory.createElementAccessExpression(target, inputSignalBrandWriteSymbol);
         }
@@ -14745,6 +14874,25 @@ var TcbForOfOp = class extends TcbOp {
     return null;
   }
 };
+var TcbIntersectionObserverOp = class 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 = ts60.factory.createNonNullExpression(ts60.factory.createNull());
+    const expression = ts60.factory.createNewExpression(ts60.factory.createIdentifier("IntersectionObserver"), void 0, [callback, options]);
+    this.scope.addStatement(ts60.factory.createExpressionStatement(expression));
+    return null;
+  }
+};
 var Context2 = class {
   env;
   domSchemaChecker;
@@ -15370,6 +15518,9 @@ var Scope = class _Scope {
     if (triggers.when !== void 0) {
       this.opQueue.push(new TcbExpressionOp(this.tcb, this, triggers.when.value));
     }
+    if (triggers.viewport !== void 0 && triggers.viewport.options !== null) {
+      this.opQueue.push(new TcbIntersectionObserverOp(this.tcb, this, triggers.viewport.options));
+    }
     if (triggers.hover !== void 0) {
       this.validateReferenceBasedDeferredTrigger(block, triggers.hover);
     }
@@ -15637,7 +15788,7 @@ function widenBinding(expr, tcb) {
   }
 }
 function unwrapWritableSignal(expression, tcb) {
-  const unwrapRef = tcb.env.referenceExternalSymbol(R3Identifiers3.unwrapWritableSignal.moduleName, R3Identifiers3.unwrapWritableSignal.name);
+  const unwrapRef = tcb.env.referenceExternalSymbol(R3Identifiers4.unwrapWritableSignal.moduleName, R3Identifiers4.unwrapWritableSignal.name);
   return ts60.factory.createCallExpression(unwrapRef, void 0, [expression]);
 }
 var EVENT_PARAMETER = "$event";
@@ -16254,7 +16405,7 @@ var DirectiveSourceManager = class {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/template_symbol_builder.js
-import { AST, ASTWithName as ASTWithName2, ASTWithSource as ASTWithSource2, Binary as Binary2, BindingPipe as BindingPipe2, PropertyRead as PropertyRead5, R3Identifiers as R3Identifiers4, SafePropertyRead as SafePropertyRead4, TmplAstBoundAttribute as TmplAstBoundAttribute3, TmplAstBoundEvent as TmplAstBoundEvent3, TmplAstComponent as TmplAstComponent3, TmplAstDirective as TmplAstDirective3, TmplAstElement as TmplAstElement3, TmplAstLetDeclaration as TmplAstLetDeclaration3, TmplAstReference as TmplAstReference3, TmplAstTemplate as TmplAstTemplate2, TmplAstTextAttribute as TmplAstTextAttribute3, TmplAstVariable as TmplAstVariable2 } from "@angular/compiler";
+import { AST, ASTWithName as ASTWithName2, ASTWithSource as ASTWithSource2, Binary as Binary2, BindingPipe as BindingPipe2, PropertyRead as PropertyRead5, R3Identifiers as R3Identifiers5, SafePropertyRead as SafePropertyRead4, TmplAstBoundAttribute as TmplAstBoundAttribute3, TmplAstBoundEvent as TmplAstBoundEvent3, TmplAstComponent as TmplAstComponent3, TmplAstDirective as TmplAstDirective3, TmplAstElement as TmplAstElement3, TmplAstLetDeclaration as TmplAstLetDeclaration3, TmplAstReference as TmplAstReference3, TmplAstTemplate as TmplAstTemplate2, TmplAstTextAttribute as TmplAstTextAttribute3, TmplAstVariable as TmplAstVariable2 } from "@angular/compiler";
 import ts63 from "typescript";
 var SymbolBuilder = class {
   tcbPath;
@@ -16884,7 +17035,7 @@ function unwrapSignalInputWriteTAccessor(expr) {
   if (!ts63.isElementAccessExpression(expr) || !ts63.isPropertyAccessExpression(expr.argumentExpression)) {
     return null;
   }
-  if (!ts63.isIdentifier(expr.argumentExpression.name) || expr.argumentExpression.name.text !== R3Identifiers4.InputSignalBrandWriteType.name) {
+  if (!ts63.isIdentifier(expr.argumentExpression.name) || expr.argumentExpression.name.text !== R3Identifiers5.InputSignalBrandWriteType.name) {
     return null;
   }
   if (!ts63.isPropertyAccessExpression(expr.expression) && !ts63.isElementAccessExpression(expr.expression) && !ts63.isIdentifier(expr.expression)) {
@@ -16990,6 +17141,9 @@ var TemplateTypeCheckerImpl = class {
     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;
   }
@@ -18148,9 +18302,11 @@ var DirectiveDecoratorHandler = class {
     this.usePoisonedData = usePoisonedData;
     this.typeCheckHostBindings = typeCheckHostBindings;
     this.emitDeclarationOnly = emitDeclarationOnly;
+    this.undecoratedMetadataExtractor = getDirectiveUndecoratedMetadataExtractor(reflector, importTracker);
   }
   precedence = HandlerPrecedence.PRIMARY;
   name = "DirectiveDecoratorHandler";
+  undecoratedMetadataExtractor;
   detect(node, decorators) {
     if (!decorators) {
       const angularField = this.findClassFieldWithAngularFeatures(node);
@@ -18202,7 +18358,7 @@ var DirectiveDecoratorHandler = class {
         meta: analysis,
         hostDirectives: directiveResult.hostDirectives,
         rawHostDirectives: directiveResult.rawHostDirectives,
-        classMetadata: this.includeClassMetadata ? extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler) : null,
+        classMetadata: this.includeClassMetadata ? extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler, void 0, this.undecoratedMetadataExtractor) : null,
         baseClass: readBaseClass(node, this.reflector, this.evaluator),
         typeCheckMeta: extractDirectiveTypeCheckMeta(node, directiveResult.inputs, this.reflector),
         providersRequiringFactory,
@@ -18376,7 +18532,7 @@ var DirectiveDecoratorHandler = class {
 };
 
 // packages/compiler-cli/src/ngtsc/annotations/ng_module/src/handler.js
-import { compileClassMetadata as compileClassMetadata2, compileDeclareClassMetadata as compileDeclareClassMetadata2, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileInjector, compileNgModule, ExternalExpr as ExternalExpr9, FactoryTarget as FactoryTarget2, FunctionExpr, InvokeFunctionExpr, LiteralArrayExpr as LiteralArrayExpr2, R3Identifiers as R3Identifiers5, R3NgModuleMetadataKind, R3SelectorScopeMode, ReturnStatement, WrappedNodeExpr as WrappedNodeExpr10 } from "@angular/compiler";
+import { compileClassMetadata as compileClassMetadata2, compileDeclareClassMetadata as compileDeclareClassMetadata2, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileInjector, compileNgModule, ExternalExpr as ExternalExpr9, FactoryTarget as FactoryTarget2, FunctionExpr, InvokeFunctionExpr, LiteralArrayExpr as LiteralArrayExpr3, R3Identifiers as R3Identifiers6, R3NgModuleMetadataKind, R3SelectorScopeMode, ReturnStatement, WrappedNodeExpr as WrappedNodeExpr10 } from "@angular/compiler";
 import ts67 from "typescript";
 
 // packages/compiler-cli/src/ngtsc/annotations/ng_module/src/module_with_providers.js
@@ -19012,14 +19168,14 @@ var NgModuleDecoratorHandler = class {
           assertSuccessfulReferenceEmit(type, node, "pipe");
           return type.expression;
         });
-        const directiveArray = new LiteralArrayExpr2(directives);
-        const pipesArray = new LiteralArrayExpr2(pipes);
+        const directiveArray = new LiteralArrayExpr3(directives);
+        const pipesArray = new LiteralArrayExpr3(pipes);
         const directiveExpr = remoteScopesMayRequireCycleProtection && directives.length > 0 ? new FunctionExpr([], [new ReturnStatement(directiveArray)]) : directiveArray;
         const pipesExpr = remoteScopesMayRequireCycleProtection && pipes.length > 0 ? new FunctionExpr([], [new ReturnStatement(pipesArray)]) : pipesArray;
         const componentType = this.refEmitter.emit(decl, context);
         assertSuccessfulReferenceEmit(componentType, node, "component");
         const declExpr = componentType.expression;
-        const setComponentScope = new ExternalExpr9(R3Identifiers5.setComponentScope);
+        const setComponentScope = new ExternalExpr9(R3Identifiers6.setComponentScope);
         const callExpr = new InvokeFunctionExpr(setComponentScope, [
           declExpr,
           directiveExpr,
@@ -20086,10 +20242,12 @@ var ComponentDecoratorHandler = class {
       enableSelectorless: this.enableSelectorless,
       preserveSignificantWhitespace: this.i18nPreserveSignificantWhitespace
     };
+    this.undecoratedMetadataExtractor = getDirectiveUndecoratedMetadataExtractor(reflector, importTracker);
     this.canDeferDeps = !enableHmr;
   }
   literalCache = /* @__PURE__ */ new Map();
   elementSchemaRegistry = new DomElementSchemaRegistry3();
+  undecoratedMetadataExtractor;
   /**
    * During the asynchronous preanalyze phase, it's necessary to parse the template to extract
    * any potential <link> tags which might need to be loaded. This cache ensures that work is not
@@ -20475,7 +20633,7 @@ var ComponentDecoratorHandler = class {
           relativeTemplatePath
         },
         typeCheckMeta: extractDirectiveTypeCheckMeta(node, inputs, this.reflector),
-        classMetadata: this.includeClassMetadata ? extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler, (dec) => transformDecoratorResources(dec, component, styles, template)) : null,
+        classMetadata: this.includeClassMetadata ? extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler, (dec) => transformDecoratorResources(dec, component, styles, template), this.undecoratedMetadataExtractor) : null,
         classDebugInfo: extractClassDebugInfo(
           node,
           this.reflector,

package/bundles/{chunk-CXWG7H5K.js → chunk-MVFPDRXS.js}

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

package/bundles/{chunk-3I7LEC2O.js → chunk-NBFYHUMW.js}

@@ -4,7 +4,7 @@
     
 import {
   angularJitApplicationTransform
-} from "./chunk-WX6HCNBV.js";
+} from "./chunk-WXJFCHPN.js";
 import {
   AbsoluteModuleStrategy,
   ActivePerfRecorder,
@@ -92,7 +92,7 @@ import {
   toUnredirectedSourceFile,
   tryParseInitializerApi,
   untagAllTsFiles
-} from "./chunk-O7L4BBZY.js";
+} from "./chunk-ELPMV5DB.js";
 import {
   LogicalFileSystem,
   absoluteFrom,
@@ -2804,7 +2804,7 @@ var StandaloneComponentScopeReader = class {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/extended/checks/interpolated_signal_not_invoked/index.js
-import { ASTWithSource as ASTWithSource2, BindingType, Interpolation, PrefixNot, PropertyRead as PropertyRead2, TmplAstBoundAttribute, TmplAstIfBlock, TmplAstSwitchBlock } from "@angular/compiler";
+import { ASTWithSource as ASTWithSource2, BindingType, Interpolation, PrefixNot, PropertyRead as PropertyRead2, TmplAstBoundAttribute, TmplAstElement as TmplAstElement2, TmplAstIfBlock, TmplAstSwitchBlock, TmplAstTemplate as TmplAstTemplate2 } from "@angular/compiler";
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/symbol_util.js
 import ts18 from "typescript";
@@ -2831,16 +2831,6 @@ function isSignalSymbol(symbol) {
 // packages/compiler-cli/src/ngtsc/typecheck/extended/api/api.js
 import { CombinedRecursiveAstVisitor as CombinedRecursiveAstVisitor2 } from "@angular/compiler";
 var TemplateCheckWithVisitor = class {
-  /**
-   * When extended diagnostics were first introduced, the visitor wasn't implemented correctly
-   * which meant that it wasn't visiting the `templateAttrs` of structural directives (e.g.
-   * the expression of `*ngIf`). Fixing the issue causes a lot of internal breakages and will likely
-   * need to be done in a major version to avoid external breakages. This flag is used to opt out
-   * pre-existing diagnostics from the correct behavior until the breakages have been fixed while
-   * ensuring that newly-written diagnostics are correct from the beginning.
-   * TODO(crisbeto): remove this flag and fix the internal brekages.
-   */
-  canVisitStructuralAttributes = true;
   /**
    * Base implementation for run function, visits all nodes in template and calls
    * `visitNode()` for each one.
@@ -2873,9 +2863,7 @@ var TemplateVisitor2 = class extends CombinedRecursiveAstVisitor2 {
       this.visitAllTemplateNodes(template.outputs);
     }
     this.visitAllTemplateNodes(template.directives);
-    if (this.check.canVisitStructuralAttributes || isInlineTemplate) {
-      this.visitAllTemplateNodes(template.templateAttrs);
-    }
+    this.visitAllTemplateNodes(template.templateAttrs);
     this.visitAllTemplateNodes(template.variables);
     this.visitAllTemplateNodes(template.references);
     this.visitAllTemplateNodes(template.children);
@@ -2895,23 +2883,21 @@ var InterpolatedSignalCheck = class extends TemplateCheckWithVisitor {
   visitNode(ctx, component, node) {
     if (node instanceof Interpolation) {
       return node.expressions.map((item) => item instanceof PrefixNot ? item.expression : item).filter((item) => item instanceof PropertyRead2).flatMap((item) => buildDiagnosticForSignal(ctx, item, component));
-    } else if (node instanceof TmplAstBoundAttribute) {
-      const symbol = ctx.templateTypeChecker.getSymbolOfNode(node, component);
-      if (symbol?.kind === SymbolKind.Input && symbol.bindings.length > 0 && symbol.bindings.some((binding) => binding.target.kind === SymbolKind.Directive)) {
-        return [];
-      }
-      const nodeAst = isPropertyReadNodeAst(node);
-      if (
-        // a bound property like `[prop]="mySignal"`
-        (node.type === BindingType.Property || // or a class binding like `[class.myClass]="mySignal"`
-        node.type === BindingType.Class || // or a style binding like `[style.width]="mySignal"`
-        node.type === BindingType.Style || // or an attribute binding like `[attr.role]="mySignal"`
-        node.type === BindingType.Attribute || // or an animation binding like `[animate.enter]="mySignal"`
-        node.type === BindingType.Animation || // or an animation binding like `[@myAnimation]="mySignal"`
-        node.type === BindingType.LegacyAnimation) && nodeAst
-      ) {
-        return buildDiagnosticForSignal(ctx, nodeAst, component);
-      }
+    } else if (node instanceof TmplAstElement2 && node.inputs.length > 0) {
+      const directivesOfElement = ctx.templateTypeChecker.getDirectivesOfNode(component, node);
+      return node.inputs.flatMap((input) => checkBoundAttribute(ctx, component, directivesOfElement, input));
+    } else if (node instanceof TmplAstTemplate2 && node.tagName === "ng-template") {
+      const directivesOfElement = ctx.templateTypeChecker.getDirectivesOfNode(component, node);
+      const inputDiagnostics = node.inputs.flatMap((input) => {
+        return checkBoundAttribute(ctx, component, directivesOfElement, input);
+      });
+      const templateAttrDiagnostics = node.templateAttrs.flatMap((attr) => {
+        if (!(attr instanceof TmplAstBoundAttribute)) {
+          return [];
+        }
+        return checkBoundAttribute(ctx, component, directivesOfElement, attr);
+      });
+      return inputDiagnostics.concat(templateAttrDiagnostics);
     } else if (node instanceof TmplAstIfBlock) {
       return node.branches.map((branch) => branch.expression).filter((expr) => expr instanceof ASTWithSource2).map((expr) => {
         const ast = expr.ast;
@@ -2926,6 +2912,24 @@ var InterpolatedSignalCheck = class extends TemplateCheckWithVisitor {
     return [];
   }
 };
+function checkBoundAttribute(ctx, component, directivesOfElement, node) {
+  if (directivesOfElement !== null && directivesOfElement.some((dir) => dir.inputs.getByBindingPropertyName(node.name) !== null)) {
+    return [];
+  }
+  const nodeAst = isPropertyReadNodeAst(node);
+  if (
+    // a bound property like `[prop]="mySignal"`
+    (node.type === BindingType.Property || // or a class binding like `[class.myClass]="mySignal"`
+    node.type === BindingType.Class || // or a style binding like `[style.width]="mySignal"`
+    node.type === BindingType.Style || // or an attribute binding like `[attr.role]="mySignal"`
+    node.type === BindingType.Attribute || // or an animation binding like `[animate.enter]="mySignal"`
+    node.type === BindingType.Animation || // or an animation binding like `[@myAnimation]="mySignal"`
+    node.type === BindingType.LegacyAnimation) && nodeAst
+  ) {
+    return buildDiagnosticForSignal(ctx, nodeAst, component);
+  }
+  return [];
+}
 function isPropertyReadNodeAst(node) {
   if (node.value instanceof ASTWithSource2 === false) {
     return void 0;
@@ -2952,8 +2956,11 @@ function buildDiagnosticForSignal(ctx, node, component) {
     const diagnostic = ctx.makeTemplateDiagnostic(templateMapping.span, errorString);
     return [diagnostic];
   }
+  if (!isFunctionInstanceProperty(node.name) && !isSignalInstanceProperty(node.name)) {
+    return [];
+  }
   const symbolOfReceiver = ctx.templateTypeChecker.getSymbolOfNode(node.receiver, component);
-  if ((isFunctionInstanceProperty(node.name) || isSignalInstanceProperty(node.name)) && symbolOfReceiver !== null && symbolOfReceiver.kind === SymbolKind.Expression && isSignalReference(symbolOfReceiver)) {
+  if (symbolOfReceiver !== null && symbolOfReceiver.kind === SymbolKind.Expression && isSignalReference(symbolOfReceiver)) {
     const templateMapping = ctx.templateTypeChecker.getSourceMappingAtTcbLocation(symbolOfReceiver.tcbLocation);
     const errorString = `${node.receiver.name} is a function and should be invoked: ${node.receiver.name}()`;
     const diagnostic = ctx.makeTemplateDiagnostic(templateMapping.span, errorString);
@@ -2991,7 +2998,7 @@ var factory2 = {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/extended/checks/missing_control_flow_directive/index.js
-import { TmplAstTemplate as TmplAstTemplate2 } from "@angular/compiler";
+import { TmplAstTemplate as TmplAstTemplate3 } from "@angular/compiler";
 var KNOWN_CONTROL_FLOW_DIRECTIVES = /* @__PURE__ */ new Map([
   ["ngIf", { directive: "NgIf", builtIn: "@if" }],
   ["ngFor", { directive: "NgFor", builtIn: "@for" }],
@@ -3008,7 +3015,7 @@ var MissingControlFlowDirectiveCheck = class extends TemplateCheckWithVisitor {
     return super.run(ctx, component, template);
   }
   visitNode(ctx, component, node) {
-    if (!(node instanceof TmplAstTemplate2))
+    if (!(node instanceof TmplAstTemplate3))
       return [];
     const controlFlowAttr = node.templateAttrs.find((attr) => KNOWN_CONTROL_FLOW_DIRECTIVES.has(attr.name));
     if (!controlFlowAttr)
@@ -3033,12 +3040,12 @@ var factory3 = {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/extended/checks/missing_ngforof_let/index.js
-import { TmplAstTemplate as TmplAstTemplate3 } from "@angular/compiler";
+import { TmplAstTemplate as TmplAstTemplate4 } from "@angular/compiler";
 var MissingNgForOfLetCheck = class extends TemplateCheckWithVisitor {
   code = ErrorCode.MISSING_NGFOROF_LET;
   visitNode(ctx, component, node) {
-    const isTemplate = node instanceof TmplAstTemplate3;
-    if (!(node instanceof TmplAstTemplate3)) {
+    const isTemplate = node instanceof TmplAstTemplate4;
+    if (!(node instanceof TmplAstTemplate4)) {
       return [];
     }
     if (node.templateAttrs.length === 0) {
@@ -3063,7 +3070,7 @@ var factory4 = {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/extended/checks/missing_structural_directive/index.js
-import { TmplAstTemplate as TmplAstTemplate4 } from "@angular/compiler";
+import { TmplAstTemplate as TmplAstTemplate5 } from "@angular/compiler";
 var KNOWN_CONTROL_FLOW_DIRECTIVES2 = /* @__PURE__ */ new Set([
   "ngIf",
   "ngFor",
@@ -3082,7 +3089,7 @@ var MissingStructuralDirectiveCheck = class extends TemplateCheckWithVisitor {
     return super.run(ctx, component, template);
   }
   visitNode(ctx, component, node) {
-    if (!(node instanceof TmplAstTemplate4))
+    if (!(node instanceof TmplAstTemplate5))
       return [];
     const customStructuralDirective = node.templateAttrs.find((attr) => !KNOWN_CONTROL_FLOW_DIRECTIVES2.has(attr.name));
     if (!customStructuralDirective)
@@ -3106,7 +3113,6 @@ var factory5 = {
 import { Binary } from "@angular/compiler";
 import ts19 from "typescript";
 var NullishCoalescingNotNullableCheck = class extends TemplateCheckWithVisitor {
-  canVisitStructuralAttributes = false;
   code = ErrorCode.NULLISH_COALESCING_NOT_NULLABLE;
   visitNode(ctx, component, node) {
     if (!(node instanceof Binary) || node.operation !== "??")
@@ -3150,7 +3156,6 @@ import { KeyedRead, SafeCall, SafeKeyedRead, SafePropertyRead } from "@angular/c
 import ts20 from "typescript";
 var OptionalChainNotNullableCheck = class extends TemplateCheckWithVisitor {
   noUncheckedIndexedAccess;
-  canVisitStructuralAttributes = false;
   code = ErrorCode.OPTIONAL_CHAIN_NOT_NULLABLE;
   constructor(noUncheckedIndexedAccess) {
     super();
@@ -3473,6 +3478,70 @@ var factory15 = {
   create: () => new UninvokedFunctionInTextInterpolation()
 };
 
+// packages/compiler-cli/src/ngtsc/typecheck/extended/checks/defer_trigger_misconfiguration/index.js
+import { TmplAstDeferredBlock, TmplAstHoverDeferredTrigger, TmplAstImmediateDeferredTrigger, TmplAstInteractionDeferredTrigger, TmplAstTimerDeferredTrigger, TmplAstViewportDeferredTrigger } from "@angular/compiler";
+var DeferTriggerMisconfiguration = class extends TemplateCheckWithVisitor {
+  code = ErrorCode.DEFER_TRIGGER_MISCONFIGURATION;
+  visitNode(ctx, component, node) {
+    if (!(node instanceof TmplAstDeferredBlock))
+      return [];
+    const mainKeys = Object.keys(node.triggers);
+    const prefetchKeys = Object.keys(node.prefetchTriggers);
+    const mains = mainKeys.map((k) => node.triggers[k]).filter((t) => t !== void 0 && t !== null);
+    const prefetches = prefetchKeys.map((k) => node.prefetchTriggers[k]).filter((t) => t !== void 0 && t !== null);
+    const diags = [];
+    const hasImmediateMain = mains.some((t) => t instanceof TmplAstImmediateDeferredTrigger);
+    if (hasImmediateMain) {
+      if (mains.length > 1) {
+        const msg = `The 'immediate' trigger makes additional triggers redundant.`;
+        diags.push(ctx.makeTemplateDiagnostic(node.sourceSpan, msg));
+      }
+      if (prefetches.length > 0) {
+        const msg = `Prefetch triggers have no effect because 'immediate' executes earlier.`;
+        diags.push(ctx.makeTemplateDiagnostic(node.sourceSpan, msg));
+      }
+    }
+    if (mains.length === 1 && prefetches.length > 0) {
+      const main = mains[0];
+      for (const pre of prefetches) {
+        const isTimerTriggger = main instanceof TmplAstTimerDeferredTrigger && pre instanceof TmplAstTimerDeferredTrigger;
+        if (isTimerTriggger) {
+          const mainDelay = main.delay;
+          const preDelay = pre.delay;
+          if (preDelay >= mainDelay) {
+            const msg = `The Prefetch 'timer(${preDelay}ms)' is not scheduled before the main 'timer(${mainDelay}ms)', so it won\u2019t run prior to rendering. Lower the prefetch delay or remove it.`;
+            diags.push(ctx.makeTemplateDiagnostic(pre.sourceSpan ?? node.sourceSpan, msg));
+          }
+        }
+        const isHoverTrigger = main instanceof TmplAstHoverDeferredTrigger && pre instanceof TmplAstHoverDeferredTrigger;
+        const isInteractionTrigger = main instanceof TmplAstInteractionDeferredTrigger && pre instanceof TmplAstInteractionDeferredTrigger;
+        const isViewportTrigger = main instanceof TmplAstViewportDeferredTrigger && pre instanceof TmplAstViewportDeferredTrigger;
+        if (isHoverTrigger || isInteractionTrigger || isViewportTrigger) {
+          const mainRef = main.reference;
+          const preRef = pre.reference;
+          if (mainRef && preRef && mainRef === preRef) {
+            const kindName = main.constructor.name.replace("DeferredTrigger", "").toLowerCase();
+            const msg = `Prefetch '${kindName}' matches the main trigger and provides no benefit. Remove the prefetch modifier.`;
+            diags.push(ctx.makeTemplateDiagnostic(pre.sourceSpan ?? node.sourceSpan, msg));
+          }
+          continue;
+        }
+        if (main.constructor === pre.constructor && !(main instanceof TmplAstTimerDeferredTrigger)) {
+          const kind = main instanceof TmplAstImmediateDeferredTrigger ? "immediate" : main.constructor.name.replace("DeferredTrigger", "").toLowerCase();
+          const msg = `Prefetch '${kind}' matches the main trigger and provides no benefit. Remove the prefetch modifier.`;
+          diags.push(ctx.makeTemplateDiagnostic(pre.sourceSpan ?? node.sourceSpan, msg));
+        }
+      }
+    }
+    return diags;
+  }
+};
+var factory16 = {
+  code: ErrorCode.DEFER_TRIGGER_MISCONFIGURATION,
+  name: ExtendedTemplateDiagnosticName.DEFER_TRIGGER_MISCONFIGURATION,
+  create: () => new DeferTriggerMisconfiguration()
+};
+
 // packages/compiler-cli/src/ngtsc/typecheck/extended/src/extended_template_checker.js
 import ts21 from "typescript";
 
@@ -3491,12 +3560,12 @@ var ExtendedTemplateCheckerImpl = class {
   constructor(templateTypeChecker, typeChecker, templateCheckFactories, options) {
     this.partialCtx = { templateTypeChecker, typeChecker };
     this.templateChecks = /* @__PURE__ */ new Map();
-    for (const factory16 of templateCheckFactories) {
-      const category = diagnosticLabelToCategory(options?.extendedDiagnostics?.checks?.[factory16.name] ?? options?.extendedDiagnostics?.defaultCategory ?? DiagnosticCategoryLabel.Warning);
+    for (const factory17 of templateCheckFactories) {
+      const category = diagnosticLabelToCategory(options?.extendedDiagnostics?.checks?.[factory17.name] ?? options?.extendedDiagnostics?.defaultCategory ?? DiagnosticCategoryLabel.Warning);
       if (category === null) {
         continue;
       }
-      const check = factory16.create(options);
+      const check = factory17.create(options);
       if (check === null) {
         continue;
       }
@@ -3556,12 +3625,13 @@ var ALL_DIAGNOSTIC_FACTORIES = [
   factory8,
   factory12,
   factory14,
-  factory15
+  factory15,
+  factory16
 ];
 var SUPPORTED_DIAGNOSTIC_NAMES = /* @__PURE__ */ new Set([
   ExtendedTemplateDiagnosticName.CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION,
   ExtendedTemplateDiagnosticName.UNUSED_STANDALONE_IMPORTS,
-  ...ALL_DIAGNOSTIC_FACTORIES.map((factory16) => factory16.name)
+  ...ALL_DIAGNOSTIC_FACTORIES.map((factory17) => factory17.name)
 ]);
 
 // packages/compiler-cli/src/ngtsc/typecheck/template_semantics/src/template_semantics_checker.js

package/bundles/{chunk-WX6HCNBV.js → chunk-WXJFCHPN.js}

@@ -16,7 +16,7 @@ import {
   tryParseSignalInputMapping,
   tryParseSignalModelMapping,
   tryParseSignalQueryFromInitializer
-} from "./chunk-O7L4BBZY.js";
+} from "./chunk-ELPMV5DB.js";
 
 // packages/compiler-cli/src/ngtsc/transform/jit/src/downlevel_decorators_transform.js
 import ts from "typescript";

package/bundles/index.js

@@ -28,7 +28,7 @@ import {
   isTsDiagnostic,
   performCompilation,
   readConfiguration
-} from "./chunk-3I7LEC2O.js";
+} from "./chunk-NBFYHUMW.js";
 import {
   ConsoleLogger,
   LogLevel
@@ -37,7 +37,7 @@ import {
   angularJitApplicationTransform,
   getDownlevelDecoratorsTransform,
   getInitializerApiJitTransform
-} from "./chunk-WX6HCNBV.js";
+} from "./chunk-WXJFCHPN.js";
 import {
   ActivePerfRecorder,
   ErrorCode,
@@ -46,7 +46,7 @@ import {
   TsCreateProgramDriver,
   isLocalCompilationDiagnostics,
   ngErrorCode
-} from "./chunk-O7L4BBZY.js";
+} from "./chunk-ELPMV5DB.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-next.7");
+var VERSION = new Version("21.0.0-next.8");
 
 // packages/compiler-cli/private/tooling.js
 var GLOBAL_DEFS_FOR_TERSER = {

package/bundles/private/migrations.js

@@ -13,7 +13,7 @@ import {
   TypeScriptReflectionHost,
   createForwardRefResolver,
   reflectObjectLiteral
-} from "../chunk-O7L4BBZY.js";
+} from "../chunk-ELPMV5DB.js";
 import "../chunk-LS5RJ5CS.js";
 import "../chunk-GWZQLAGK.js";
 import "../chunk-XYYEESKY.js";

package/bundles/private/tooling.js

@@ -4,8 +4,8 @@
     
 import {
   angularJitApplicationTransform
-} from "../chunk-WX6HCNBV.js";
-import "../chunk-O7L4BBZY.js";
+} from "../chunk-WXJFCHPN.js";
+import "../chunk-ELPMV5DB.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-CXWG7H5K.js";
+} from "../../chunk-MVFPDRXS.js";
 import {
   EmitFlags
-} from "../../chunk-3I7LEC2O.js";
-import "../../chunk-WX6HCNBV.js";
-import "../../chunk-O7L4BBZY.js";
+} from "../../chunk-NBFYHUMW.js";
+import "../../chunk-WXJFCHPN.js";
+import "../../chunk-ELPMV5DB.js";
 import "../../chunk-LS5RJ5CS.js";
 import {
   setFileSystem

package/bundles/src/bin/ngc.js

@@ -5,10 +5,10 @@
     
 import {
   main
-} from "../../chunk-CXWG7H5K.js";
-import "../../chunk-3I7LEC2O.js";
-import "../../chunk-WX6HCNBV.js";
-import "../../chunk-O7L4BBZY.js";
+} from "../../chunk-MVFPDRXS.js";
+import "../../chunk-NBFYHUMW.js";
+import "../../chunk-WXJFCHPN.js";
+import "../../chunk-ELPMV5DB.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-next.7";
+export declare const PLACEHOLDER_VERSION = "21.0.0-next.8";
 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-next.7",
+  "version": "21.0.0-next.8",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -48,7 +48,7 @@
     "yargs": "^18.0.0"
   },
   "peerDependencies": {
-    "@angular/compiler": "21.0.0-next.7",
+    "@angular/compiler": "21.0.0-next.8",
     "typescript": ">=5.9 <6.0"
   },
   "peerDependenciesMeta": {

package/src/ngtsc/annotations/common/src/metadata.d.ts

@@ -5,9 +5,11 @@
  * 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 { R3ClassMetadata } from '@angular/compiler';
+import { LiteralArrayExpr, R3ClassMetadata } from '@angular/compiler';
 import ts from 'typescript';
-import { DeclarationNode, Decorator, ReflectionHost } from '../../../reflection';
+import { ClassMember, DeclarationNode, Decorator, ReflectionHost } from '../../../reflection';
+/** Function that extracts metadata from an undercorated class member. */
+export type UndecoratedMetadataExtractor = (member: ClassMember) => LiteralArrayExpr | null;
 /**
  * Given a class declaration, generate a call to `setClassMetadata` with the Angular metadata
  * present on the class or its member fields. An ngDevMode guard is used to allow the call to be
@@ -16,7 +18,7 @@ import { DeclarationNode, Decorator, ReflectionHost } from '../../../reflection'
  * If no such metadata is present, this function returns `null`. Otherwise, the call is returned
  * as a `Statement` for inclusion along with the class.
  */
-export declare function extractClassMetadata(clazz: DeclarationNode, reflection: ReflectionHost, isCore: boolean, annotateForClosureCompiler?: boolean, angularDecoratorTransform?: (dec: Decorator) => Decorator): R3ClassMetadata | null;
+export declare function extractClassMetadata(clazz: DeclarationNode, reflection: ReflectionHost, isCore: boolean, annotateForClosureCompiler?: boolean, angularDecoratorTransform?: (dec: Decorator) => Decorator, undecoratedMetadataExtractor?: UndecoratedMetadataExtractor): R3ClassMetadata | null;
 /**
  * Recursively recreates all of the `Identifier` descendant nodes with a particular name inside
  * of an AST node, thus removing any references to them. Useful if a particular node has to be

package/src/ngtsc/annotations/component/src/handler.d.ts

@@ -79,6 +79,7 @@ export declare class ComponentDecoratorHandler implements DecoratorHandler<Decor
     constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, metaReader: MetadataReader, scopeReader: ComponentScopeReader, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>, scopeRegistry: LocalModuleScopeRegistry, typeCheckScopeRegistry: TypeCheckScopeRegistry, resourceRegistry: ResourceRegistry, isCore: boolean, strictCtorDeps: boolean, resourceLoader: ResourceLoader, rootDirs: ReadonlyArray<string>, defaultPreserveWhitespaces: boolean, i18nUseExternalIds: boolean, enableI18nLegacyMessageIdFormat: boolean, usePoisonedData: boolean, i18nNormalizeLineEndingsInICUs: boolean, moduleResolver: ModuleResolver, cycleAnalyzer: CycleAnalyzer, cycleHandlingStrategy: CycleHandlingStrategy, refEmitter: ReferenceEmitter, referencesRegistry: ReferencesRegistry, depTracker: DependencyTracker | null, injectableRegistry: InjectableClassRegistry, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, perf: PerfRecorder, hostDirectivesResolver: HostDirectivesResolver, importTracker: ImportedSymbolsTracker, includeClassMetadata: boolean, compilationMode: CompilationMode, deferredSymbolTracker: DeferredSymbolTracker, forbidOrphanRendering: boolean, enableBlockSyntax: boolean, enableLetSyntax: boolean, externalRuntimeStyles: boolean, localCompilationExtraImportsTracker: LocalCompilationExtraImportsTracker | null, jitDeclarationRegistry: JitDeclarationRegistry, i18nPreserveSignificantWhitespace: boolean, strictStandalone: boolean, enableHmr: boolean, implicitStandaloneValue: boolean, typeCheckHostBindings: boolean, enableSelectorless: boolean, emitDeclarationOnly: boolean);
     private literalCache;
     private elementSchemaRegistry;
+    private readonly undecoratedMetadataExtractor;
     /**
      * During the asynchronous preanalyze phase, it's necessary to parse the template to extract
      * any potential <link> tags which might need to be loaded. This cache ensures that work is not

package/src/ngtsc/annotations/directive/src/handler.d.ts

@@ -65,6 +65,7 @@ export declare class DirectiveDecoratorHandler implements DecoratorHandler<Decor
     constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, metaReader: MetadataReader, injectableRegistry: InjectableClassRegistry, refEmitter: ReferenceEmitter, referencesRegistry: ReferencesRegistry, isCore: boolean, strictCtorDeps: boolean, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, perf: PerfRecorder, importTracker: ImportedSymbolsTracker, includeClassMetadata: boolean, typeCheckScopeRegistry: TypeCheckScopeRegistry, compilationMode: CompilationMode, jitDeclarationRegistry: JitDeclarationRegistry, resourceRegistry: ResourceRegistry, strictStandalone: boolean, implicitStandaloneValue: boolean, usePoisonedData: boolean, typeCheckHostBindings: boolean, emitDeclarationOnly: boolean);
     readonly precedence = HandlerPrecedence.PRIMARY;
     readonly name = "DirectiveDecoratorHandler";
+    private readonly undecoratedMetadataExtractor;
     detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator | null> | undefined;
     analyze(node: ClassDeclaration, decorator: Readonly<Decorator | null>): AnalysisOutput<DirectiveHandlerData>;
     symbol(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>): DirectiveSymbol;

package/src/ngtsc/annotations/directive/src/shared.d.ts

@@ -12,7 +12,7 @@ import { ClassPropertyMapping, DecoratorInputTransform, HostDirectiveMeta, Input
 import { DynamicValue, PartialEvaluator } from '../../../partial_evaluator';
 import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
 import { CompilationMode } from '../../../transform';
-import { ReferencesRegistry } from '../../common';
+import { ReferencesRegistry, UndecoratedMetadataExtractor } from '../../common';
 type QueryDecoratorName = 'ViewChild' | 'ViewChildren' | 'ContentChild' | 'ContentChildren';
 export declare const queryDecoratorNames: QueryDecoratorName[];
 export interface HostBindingNodes {
@@ -43,6 +43,11 @@ export declare function extractDirectiveMetadata(clazz: ClassDeclaration, decora
 export declare function extractDecoratorQueryMetadata(exprNode: ts.Node, name: string, args: ReadonlyArray<ts.Expression>, propertyName: string, reflector: ReflectionHost, evaluator: PartialEvaluator): R3QueryMetadata;
 export declare function parseDirectiveStyles(directive: Map<string, ts.Expression>, evaluator: PartialEvaluator, compilationMode: CompilationMode): null | string[];
 export declare function parseFieldStringArrayValue(directive: Map<string, ts.Expression>, field: string, evaluator: PartialEvaluator): null | string[];
+/**
+ * Returns a function that can be used to extract data for the `setClassMetadata`
+ * calls from undecorated directive class members.
+ */
+export declare function getDirectiveUndecoratedMetadataExtractor(reflector: ReflectionHost, importTracker: ImportedSymbolsTracker): UndecoratedMetadataExtractor;
 /**
  * Parses the `transform` function and its type for a decorator `@Input`.
  *

package/src/ngtsc/diagnostics/src/error_code.d.ts

@@ -354,6 +354,12 @@ export declare enum ErrorCode {
      * ```
      */
     DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER = 8020,
+    /**
+     * 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
+     */
+    DEFER_TRIGGER_MISCONFIGURATION = 8021,
     /**
      * A two way binding in a template has an incorrect syntax,
      * parentheses outside brackets. For example:

package/src/ngtsc/diagnostics/src/extended_template_diagnostic_name.d.ts

@@ -31,5 +31,6 @@ export declare enum ExtendedTemplateDiagnosticName {
     UNINVOKED_TRACK_FUNCTION = "uninvokedTrackFunction",
     UNUSED_STANDALONE_IMPORTS = "unusedStandaloneImports",
     UNPARENTHESIZED_NULLISH_COALESCING = "unparenthesizedNullishCoalescing",
-    UNINVOKED_FUNCTION_IN_TEXT_INTERPOLATION = "uninvokedFunctionInTextInterpolation"
+    UNINVOKED_FUNCTION_IN_TEXT_INTERPOLATION = "uninvokedFunctionInTextInterpolation",
+    DEFER_TRIGGER_MISCONFIGURATION = "deferTriggerMisconfiguration"
 }

package/src/ngtsc/typecheck/api/checker.d.ts

@@ -204,6 +204,10 @@ export interface TemplateTypeChecker {
      * Retrieve the type checking engine's metadata for the given pipe class, if available.
      */
     getPipeMetadata(pipe: ts.ClassDeclaration): PipeMeta | null;
+    /**
+     * Gets the directives that apply to the given template node in a component's template.
+     */
+    getDirectivesOfNode(component: ts.ClassDeclaration, node: TmplAstElement | TmplAstTemplate): TypeCheckableDirectiveMeta[] | null;
     /**
      * Gets the directives that have been used in a component's template.
      */

package/src/ngtsc/typecheck/extended/api/api.d.ts

@@ -55,16 +55,6 @@ export interface TemplateCheckFactory<Code extends ErrorCode, Name extends Exten
  * This abstract class provides a base implementation for the run method.
  */
 export declare abstract class TemplateCheckWithVisitor<Code extends ErrorCode> implements TemplateCheck<Code> {
-    /**
-     * When extended diagnostics were first introduced, the visitor wasn't implemented correctly
-     * which meant that it wasn't visiting the `templateAttrs` of structural directives (e.g.
-     * the expression of `*ngIf`). Fixing the issue causes a lot of internal breakages and will likely
-     * need to be done in a major version to avoid external breakages. This flag is used to opt out
-     * pre-existing diagnostics from the correct behavior until the breakages have been fixed while
-     * ensuring that newly-written diagnostics are correct from the beginning.
-     * TODO(crisbeto): remove this flag and fix the internal brekages.
-     */
-    readonly canVisitStructuralAttributes: boolean;
     abstract code: Code;
     /**
      * Base implementation for run function, visits all nodes in template and calls

package/src/ngtsc/typecheck/extended/checks/defer_trigger_misconfiguration/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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 { ErrorCode, ExtendedTemplateDiagnosticName } from '../../../../diagnostics';
+import { TemplateCheckFactory } from '../../api';
+export declare const factory: TemplateCheckFactory<ErrorCode.DEFER_TRIGGER_MISCONFIGURATION, ExtendedTemplateDiagnosticName.DEFER_TRIGGER_MISCONFIGURATION>;

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

@@ -78,6 +78,7 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
     constructor(originalProgram: ts.Program, programDriver: ProgramDriver, typeCheckAdapter: ProgramTypeCheckAdapter, config: TypeCheckingConfig, refEmitter: ReferenceEmitter, reflector: ReflectionHost, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>, priorBuild: IncrementalBuild<unknown, FileTypeCheckingData>, metaReader: MetadataReader, localMetaReader: MetadataReaderWithIndex, ngModuleIndex: NgModuleIndex, componentScopeReader: ComponentScopeReader, typeCheckScopeRegistry: TypeCheckScopeRegistry, perf: PerfRecorder);
     getTemplate(component: ts.ClassDeclaration, optimizeFor?: OptimizeFor): TmplAstNode[] | null;
     getHostElement(directive: ts.ClassDeclaration, optimizeFor?: OptimizeFor): TmplAstHostElement | null;
+    getDirectivesOfNode(component: ts.ClassDeclaration, node: TmplAstElement | TmplAstTemplate): TypeCheckableDirectiveMeta[] | null;
     getUsedDirectives(component: ts.ClassDeclaration): TypeCheckableDirectiveMeta[] | null;
     getUsedPipes(component: ts.ClassDeclaration): string[] | null;
     private getLatestComponentState;