@angular/compiler-cli 22.0.0-next.2 → 22.0.0-next.4

package/bundles/{chunk-OBSXELUC.js → chunk-ARNGIZEA.js}

@@ -122,13 +122,13 @@ import {
   validateHostDirectives,
   wrapFunctionExpressionsInParens,
   wrapTypeReference
-} from "./chunk-2KXHLD7K.js";
+} from "./chunk-BCQGTZBZ.js";
 import {
   absoluteFrom,
   absoluteFromSourceFile,
   getSourceFileOrError,
   relative
-} from "./chunk-CEBE44Q5.js";
+} from "./chunk-UTWH365F.js";
 
 // packages/compiler-cli/src/ngtsc/transform/jit/src/downlevel_decorators_transform.js
 import ts from "typescript";
@@ -5134,8 +5134,9 @@ import ts18 from "typescript";
 // packages/compiler-cli/src/ngtsc/typecheck/src/tcb_adapter.js
 import { AbsoluteSourceSpan, ExternalExpr as ExternalExpr4, TransplantedType, WrappedNodeExpr as WrappedNodeExpr2 } from "@angular/compiler";
 import ts15 from "typescript";
-function adaptTypeCheckBlockMetadata(ref, meta, env) {
+function adaptTypeCheckBlockMetadata(ref, meta, env, genericContextBehavior) {
   const refCache = /* @__PURE__ */ new Map();
+  const dirCache = /* @__PURE__ */ new Map();
   const extractRef = (ref2) => {
     if (refCache.has(ref2)) {
       return refCache.get(ref2);
@@ -5144,7 +5145,6 @@ function adaptTypeCheckBlockMetadata(ref, meta, env) {
     refCache.set(ref2, result);
     return result;
   };
-  const dirCache = /* @__PURE__ */ new Map();
   const convertDir = (dir) => {
     if (dirCache.has(dir))
       return dirCache.get(dir);
@@ -5185,36 +5185,21 @@ function adaptTypeCheckBlockMetadata(ref, meta, env) {
       publicMethods: dir.publicMethods,
       ref: extractRef(dir.ref),
       isGeneric: dir.isGeneric,
-      typeParameters: (() => {
-        const node = dir.ref.node;
-        if (!node.typeParameters) {
-          return null;
-        }
-        const emitter = new TypeParameterEmitter(node.typeParameters, env.reflector);
-        let emitted;
-        if (!emitter.canEmit((ref2) => env.canReferenceType(ref2))) {
-          emitted = [...node.typeParameters];
-        } else {
-          emitted = emitter.emit((ref2) => env.referenceType(ref2));
-        }
-        return generateTcbTypeParameters(emitted || [], env.contextFile);
-      })(),
-      hasRequiresInlineTypeCtor: requiresInlineTypeCtor(dir.ref.node, env.reflector, env)
+      requiresInlineTypeCtor: requiresInlineTypeCtor(dir.ref.node, env.reflector, env),
+      ...adaptGenerics(dir.ref.node, env, TcbGenericContextBehavior.UseEmitter)
     };
     dirCache.set(dir, tcbDir);
     return tcbDir;
   };
+  const originalBoundTarget = meta.boundTarget.target;
   const adaptedBoundTarget = {
-    target: (() => {
-      const originalTarget = meta.boundTarget.target;
-      return {
-        template: originalTarget.template,
-        host: originalTarget.host ? {
-          node: originalTarget.host.node,
-          directives: originalTarget.host.directives.map(convertDir)
-        } : void 0
-      };
-    })(),
+    target: {
+      template: originalBoundTarget.template,
+      host: originalBoundTarget.host ? {
+        node: originalBoundTarget.host.node,
+        directives: originalBoundTarget.host.directives.map(convertDir)
+      } : void 0
+    },
     getUsedDirectives: () => meta.boundTarget.getUsedDirectives().map(convertDir),
     getEagerlyUsedDirectives: () => meta.boundTarget.getEagerlyUsedDirectives().map(convertDir),
     getUsedPipes: () => meta.boundTarget.getUsedPipes(),
@@ -5272,25 +5257,37 @@ function adaptTypeCheckBlockMetadata(ref, meta, env) {
       isStandalone: meta.isStandalone,
       preserveWhitespaces: meta.preserveWhitespaces
     },
-    component: (() => {
-      return {
-        ref: extractRef(ref),
-        typeParameters: (() => {
-          if (!ref.node.typeParameters)
-            return null;
-          const emitter = new TypeParameterEmitter(ref.node.typeParameters, env.reflector);
-          let emitted;
-          if (!emitter.canEmit((r) => env.canReferenceType(r))) {
-            emitted = [...ref.node.typeParameters];
-          } else {
-            emitted = emitter.emit((r) => env.referenceType(r));
-          }
-          return generateTcbTypeParameters(emitted || [], env.contextFile);
-        })()
-      };
-    })()
+    component: {
+      ref: extractRef(ref),
+      ...adaptGenerics(ref.node, env, env.config.useContextGenericType ? genericContextBehavior : TcbGenericContextBehavior.FallbackToAny)
+    }
   };
 }
+function adaptGenerics(node, env, genericContextBehavior) {
+  let typeParameters;
+  let typeArguments;
+  if (node.typeParameters !== void 0 && node.typeParameters.length > 0) {
+    switch (genericContextBehavior) {
+      case TcbGenericContextBehavior.UseEmitter:
+        const emitter = new TypeParameterEmitter(node.typeParameters, env.reflector);
+        const emittedParams = emitter.canEmit((r) => env.canReferenceType(r)) ? emitter.emit((typeRef) => env.referenceType(typeRef)) : void 0;
+        typeParameters = generateTcbTypeParameters(emittedParams || node.typeParameters, env.contextFile);
+        typeArguments = typeParameters.map((param) => param.name);
+        break;
+      case TcbGenericContextBehavior.CopyClassNodes:
+        typeParameters = generateTcbTypeParameters(node.typeParameters, env.contextFile);
+        typeArguments = typeParameters.map((param) => param.name);
+        break;
+      case TcbGenericContextBehavior.FallbackToAny:
+        typeParameters = generateTcbTypeParameters(node.typeParameters, env.contextFile);
+        typeArguments = new Array(node.typeParameters.length).fill("any");
+        break;
+    }
+  } else {
+    typeParameters = typeArguments = null;
+  }
+  return { typeParameters, typeArguments };
+}
 function extractReferenceMetadata(ref, env) {
   let name = ref.debugName || ref.node.name.text;
   let moduleName = ref.ownedByModuleGuess;
@@ -5371,8 +5368,8 @@ var TypeCheckFile = class extends Environment {
   }
   addTypeCheckBlock(ref, meta, domSchemaChecker, oobRecorder, genericContextBehavior) {
     const fnId = `_tcb${this.nextTcbId++}`;
-    const { tcbMeta, component } = adaptTypeCheckBlockMetadata(ref, meta, this);
-    const fn = generateTypeCheckBlock(this, component, fnId, tcbMeta, domSchemaChecker, oobRecorder, genericContextBehavior);
+    const { tcbMeta, component } = adaptTypeCheckBlockMetadata(ref, meta, this, genericContextBehavior);
+    const fn = generateTypeCheckBlock(this, component, fnId, tcbMeta, domSchemaChecker, oobRecorder);
     this.tcbStatements.push(fn);
   }
   render() {
@@ -5699,8 +5696,8 @@ var InlineTcbOp = class {
   execute(im, sf, refEmitter) {
     const env = new Environment(this.config, im, refEmitter, this.reflector, sf);
     const fnName = `_tcb_${this.ref.node.pos}`;
-    const { tcbMeta, component } = adaptTypeCheckBlockMetadata(this.ref, this.meta, env);
-    const fn = generateTypeCheckBlock(env, component, fnName, tcbMeta, this.domSchemaChecker, this.oobRecorder, TcbGenericContextBehavior.CopyClassNodes);
+    const { tcbMeta, component } = adaptTypeCheckBlockMetadata(this.ref, this.meta, env, TcbGenericContextBehavior.CopyClassNodes);
+    const fn = generateTypeCheckBlock(env, component, fnName, tcbMeta, this.domSchemaChecker, this.oobRecorder);
     return fn;
   }
 };
@@ -11369,3 +11366,4 @@ export {
  * 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
  */
+//# sourceMappingURL=chunk-ARNGIZEA.js.map