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

package/bundles/{chunk-5EGV6MZF.js → chunk-BCQGTZBZ.js}

@@ -5,7 +5,7 @@
 import {
   Context,
   ExpressionTranslatorVisitor
-} from "./chunk-I6T4FEIP.js";
+} from "./chunk-L35AQF75.js";
 import {
   LogicalProjectPath,
   absoluteFrom,
@@ -229,7 +229,7 @@ var COMPILER_ERRORS_WITH_GUIDES = /* @__PURE__ */ new Set([
 import { VERSION } from "@angular/compiler";
 var DOC_PAGE_BASE_URL = (() => {
   const full = VERSION.full;
-  const isPreRelease = full.includes("-next") || full.includes("-rc") || full === "22.0.0-next.3";
+  const isPreRelease = full.includes("-next") || full.includes("-rc") || full === "22.0.0-next.4";
   const prefix = isPreRelease ? "next" : `v${VERSION.major}`;
   return `https://${prefix}.angular.dev`;
 })();
@@ -5239,19 +5239,22 @@ var TypeScriptAstFactory = class {
     if (!ts25.isBlock(body)) {
       throw new Error(`Invalid syntax, expected a block, but got ${ts25.SyntaxKind[body.kind]}.`);
     }
-    return ts25.factory.createFunctionDeclaration(void 0, void 0, functionName, void 0, parameters.map((param) => ts25.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
+    return ts25.factory.createFunctionDeclaration(void 0, void 0, functionName, void 0, parameters.map((param) => this.createParameter(param)), void 0, body);
   }
   createFunctionExpression(functionName, parameters, body) {
     if (!ts25.isBlock(body)) {
       throw new Error(`Invalid syntax, expected a block, but got ${ts25.SyntaxKind[body.kind]}.`);
     }
-    return ts25.factory.createFunctionExpression(void 0, void 0, functionName ?? void 0, void 0, parameters.map((param) => ts25.factory.createParameterDeclaration(void 0, void 0, param)), void 0, body);
+    return ts25.factory.createFunctionExpression(void 0, void 0, functionName ?? void 0, void 0, parameters.map((param) => this.createParameter(param)), void 0, body);
   }
   createArrowFunctionExpression(parameters, body) {
     if (ts25.isStatement(body) && !ts25.isBlock(body)) {
       throw new Error(`Invalid syntax, expected a block, but got ${ts25.SyntaxKind[body.kind]}.`);
     }
-    return ts25.factory.createArrowFunction(void 0, void 0, parameters.map((param) => ts25.factory.createParameterDeclaration(void 0, void 0, param)), void 0, void 0, body);
+    return ts25.factory.createArrowFunction(void 0, void 0, parameters.map((param) => this.createParameter(param)), void 0, void 0, body);
+  }
+  createParameter(param) {
+    return ts25.factory.createParameterDeclaration(void 0, void 0, param.name, void 0, param.type ?? void 0);
   }
   createIdentifier = ts25.factory.createIdentifier;
   createIfStatement(condition, thenStatement, elseStatement) {
@@ -5326,10 +5329,10 @@ var TypeScriptAstFactory = class {
   createUnaryExpression(operator, operand) {
     return ts25.factory.createPrefixUnaryExpression(this.UNARY_OPERATORS[operator], operand);
   }
-  createVariableDeclaration(variableName, initializer, type) {
+  createVariableDeclaration(variableName, initializer, variableType, type) {
     return ts25.factory.createVariableStatement(void 0, ts25.factory.createVariableDeclarationList([
-      ts25.factory.createVariableDeclaration(variableName, void 0, void 0, initializer ?? void 0)
-    ], this.VAR_TYPES[type]));
+      ts25.factory.createVariableDeclaration(variableName, void 0, type ?? void 0, initializer ?? void 0)
+    ], this.VAR_TYPES[variableType]));
   }
   createRegularExpressionLiteral(body, flags) {
     return ts25.factory.createRegularExpressionLiteral(`/${body}/${flags ?? ""}`);
@@ -5350,6 +5353,44 @@ var TypeScriptAstFactory = class {
     });
     return node;
   }
+  createBuiltInType(type) {
+    switch (type) {
+      case "any":
+        return ts25.factory.createKeywordTypeNode(ts25.SyntaxKind.AnyKeyword);
+      case "boolean":
+        return ts25.factory.createKeywordTypeNode(ts25.SyntaxKind.BooleanKeyword);
+      case "number":
+        return ts25.factory.createKeywordTypeNode(ts25.SyntaxKind.NumberKeyword);
+      case "string":
+        return ts25.factory.createKeywordTypeNode(ts25.SyntaxKind.StringKeyword);
+      case "function":
+        return ts25.factory.createTypeReferenceNode(ts25.factory.createIdentifier("Function"));
+      case "never":
+        return ts25.factory.createKeywordTypeNode(ts25.SyntaxKind.NeverKeyword);
+      case "unknown":
+        return ts25.factory.createKeywordTypeNode(ts25.SyntaxKind.UnknownKeyword);
+    }
+  }
+  createExpressionType(expression, typeParams) {
+    const typeName = getEntityTypeFromExpression(expression);
+    return ts25.factory.createTypeReferenceNode(typeName, typeParams ?? void 0);
+  }
+  createArrayType(elementType) {
+    return ts25.factory.createArrayTypeNode(elementType);
+  }
+  createMapType(valueType) {
+    return ts25.factory.createTypeLiteralNode([
+      ts25.factory.createIndexSignature(void 0, [
+        ts25.factory.createParameterDeclaration(void 0, void 0, "key", void 0, ts25.factory.createKeywordTypeNode(ts25.SyntaxKind.StringKeyword))
+      ], valueType)
+    ]);
+  }
+  transplantType(type) {
+    if (typeof type.kind === "number" && typeof type.getSourceFile === "function" && ts25.isTypeNode(type)) {
+      return type;
+    }
+    throw new Error("Attempting to transplant a type node from a non-TypeScript AST: " + type);
+  }
 };
 function createTemplateMiddle(cooked, raw) {
   const node = ts25.factory.createTemplateHead(cooked, raw);
@@ -5373,6 +5414,19 @@ function attachComments(statement, leadingComments) {
     }
   }
 }
+function getEntityTypeFromExpression(expression) {
+  if (ts25.isIdentifier(expression)) {
+    return expression;
+  }
+  if (ts25.isPropertyAccessExpression(expression)) {
+    const left = getEntityTypeFromExpression(expression.expression);
+    if (!ts25.isIdentifier(expression.name)) {
+      throw new Error(`Unsupported property access for type reference: ${expression.name.text}`);
+    }
+    return ts25.factory.createQualifiedName(left, expression.name);
+  }
+  throw new Error(`Unsupported expression for type reference: ${ts25.SyntaxKind[expression.kind]}`);
+}
 
 // packages/compiler-cli/src/ngtsc/translator/src/typescript_translator.js
 function translateExpression(contextFile, expression, imports, options = {}) {
@@ -6569,7 +6623,7 @@ var IvyTransformationVisitor = class extends Visitor {
     } else if (ts30.isMethodDeclaration(node)) {
       node = ts30.factory.updateMethodDeclaration(node, combinedModifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body);
     } else if (ts30.isPropertyDeclaration(node)) {
-      node = ts30.factory.updatePropertyDeclaration(node, combinedModifiers, node.name, node.questionToken, node.type, node.initializer);
+      node = ts30.factory.updatePropertyDeclaration(node, combinedModifiers, node.name, node.questionToken || node.exclamationToken, node.type, node.initializer);
     } else if (ts30.isGetAccessor(node)) {
       node = ts30.factory.updateGetAccessorDeclaration(node, combinedModifiers, node.name, node.parameters, node.type, node.body);
     } else if (ts30.isSetAccessor(node)) {
@@ -6700,10 +6754,9 @@ function insertDebugNameIntoCallExpression(node, debugName) {
       spreadArgs.push(ts31.factory.createIdentifier("undefined"));
     }
     spreadArgs.push(ts31.factory.createObjectLiteralExpression([debugNameProperty]));
-    newArgs = [
-      ...node.arguments,
-      ts31.factory.createSpreadElement(createNgDevModeConditional(ts31.factory.createArrayLiteralExpression(spreadArgs), ts31.factory.createArrayLiteralExpression()))
-    ];
+    const spread = ts31.factory.createSpreadElement(createNgDevModeConditional(ts31.factory.createArrayLiteralExpression(spreadArgs), ts31.factory.createArrayLiteralExpression()));
+    ts31.addSyntheticLeadingComment(spread, ts31.SyntaxKind.MultiLineCommentTrivia, " @ts-ignore ", true);
+    newArgs = [...node.arguments, spread];
   }
   return ts31.factory.updateCallExpression(node, node.expression, node.typeArguments, newArgs);
 }
@@ -6889,6 +6942,52 @@ function signalMetadataTransform(program) {
   };
 }
 
+// packages/compiler-cli/src/ngtsc/typecheck/src/ops/context.js
+var TcbGenericContextBehavior;
+(function(TcbGenericContextBehavior2) {
+  TcbGenericContextBehavior2[TcbGenericContextBehavior2["UseEmitter"] = 0] = "UseEmitter";
+  TcbGenericContextBehavior2[TcbGenericContextBehavior2["CopyClassNodes"] = 1] = "CopyClassNodes";
+  TcbGenericContextBehavior2[TcbGenericContextBehavior2["FallbackToAny"] = 2] = "FallbackToAny";
+})(TcbGenericContextBehavior || (TcbGenericContextBehavior = {}));
+var Context2 = class {
+  env;
+  domSchemaChecker;
+  oobRecorder;
+  id;
+  boundTarget;
+  pipes;
+  schemas;
+  hostIsStandalone;
+  hostPreserveWhitespaces;
+  nextId = 1;
+  constructor(env, domSchemaChecker, oobRecorder, id, boundTarget, pipes, schemas, hostIsStandalone, hostPreserveWhitespaces) {
+    this.env = env;
+    this.domSchemaChecker = domSchemaChecker;
+    this.oobRecorder = oobRecorder;
+    this.id = id;
+    this.boundTarget = boundTarget;
+    this.pipes = pipes;
+    this.schemas = schemas;
+    this.hostIsStandalone = hostIsStandalone;
+    this.hostPreserveWhitespaces = hostPreserveWhitespaces;
+  }
+  /**
+   * Allocate a new variable name for use within the `Context`.
+   *
+   * Currently this uses a monotonically increasing counter, but in the future the variable name
+   * might change depending on the type of data being stored.
+   */
+  allocateId() {
+    return `_t${this.nextId++}`;
+  }
+  getPipeByName(name) {
+    if (this.pipes === null || !this.pipes.has(name)) {
+      return null;
+    }
+    return this.pipes.get(name);
+  }
+};
+
 // packages/compiler-cli/src/ngtsc/typecheck/src/dom.js
 import { DomElementSchemaRegistry } from "@angular/compiler";
 import ts33 from "typescript";
@@ -8595,7 +8694,7 @@ var Environment = class extends ReferenceEmitEnvironment {
     if (this.typeCtors.has(key)) {
       return new TcbExpr(this.typeCtors.get(key));
     }
-    if (dir.hasRequiresInlineTypeCtor) {
+    if (dir.requiresInlineTypeCtor) {
       const typeCtorExpr = `${this.referenceTcbValue(dir.ref).print()}.ngTypeCtor`;
       this.typeCtors.set(key, typeCtorExpr);
       return new TcbExpr(typeCtorExpr);
@@ -8946,52 +9045,6 @@ function makeInlineDiagnostic(id, code, node, messageText, relatedInformation) {
   };
 }
 
-// packages/compiler-cli/src/ngtsc/typecheck/src/ops/context.js
-var TcbGenericContextBehavior;
-(function(TcbGenericContextBehavior2) {
-  TcbGenericContextBehavior2[TcbGenericContextBehavior2["UseEmitter"] = 0] = "UseEmitter";
-  TcbGenericContextBehavior2[TcbGenericContextBehavior2["CopyClassNodes"] = 1] = "CopyClassNodes";
-  TcbGenericContextBehavior2[TcbGenericContextBehavior2["FallbackToAny"] = 2] = "FallbackToAny";
-})(TcbGenericContextBehavior || (TcbGenericContextBehavior = {}));
-var Context2 = class {
-  env;
-  domSchemaChecker;
-  oobRecorder;
-  id;
-  boundTarget;
-  pipes;
-  schemas;
-  hostIsStandalone;
-  hostPreserveWhitespaces;
-  nextId = 1;
-  constructor(env, domSchemaChecker, oobRecorder, id, boundTarget, pipes, schemas, hostIsStandalone, hostPreserveWhitespaces) {
-    this.env = env;
-    this.domSchemaChecker = domSchemaChecker;
-    this.oobRecorder = oobRecorder;
-    this.id = id;
-    this.boundTarget = boundTarget;
-    this.pipes = pipes;
-    this.schemas = schemas;
-    this.hostIsStandalone = hostIsStandalone;
-    this.hostPreserveWhitespaces = hostPreserveWhitespaces;
-  }
-  /**
-   * Allocate a new variable name for use within the `Context`.
-   *
-   * Currently this uses a monotonically increasing counter, but in the future the variable name
-   * might change depending on the type of data being stored.
-   */
-  allocateId() {
-    return `_t${this.nextId++}`;
-  }
-  getPipeByName(name) {
-    if (this.pipes === null || !this.pipes.has(name)) {
-      return null;
-    }
-    return this.pipes.get(name);
-  }
-};
-
 // packages/compiler-cli/src/ngtsc/typecheck/src/ops/scope.js
 import { TmplAstBoundText, TmplAstComponent as TmplAstComponent3, TmplAstContent, TmplAstDeferredBlock, TmplAstDirective as TmplAstDirective2, TmplAstElement as TmplAstElement8, TmplAstForLoopBlock as TmplAstForLoopBlock2, TmplAstHostElement as TmplAstHostElement5, TmplAstIcu, TmplAstIfBlock as TmplAstIfBlock2, TmplAstIfBlockBranch, TmplAstLetDeclaration as TmplAstLetDeclaration2, TmplAstReference, TmplAstSwitchBlock as TmplAstSwitchBlock2, TmplAstTemplate as TmplAstTemplate5, TmplAstText as TmplAstText2, TmplAstVariable as TmplAstVariable2 } from "@angular/compiler";
 
@@ -9227,16 +9280,16 @@ var TcbExprTranslator = class {
     const head = ast.elements[0];
     let result;
     if (length === 1) {
-      result = `\`${head.text}\``;
+      result = `\`${this.escapeTemplateLiteral(head.text)}\``;
     } else {
-      let parts = [`\`${head.text}`];
+      let parts = [`\`${this.escapeTemplateLiteral(head.text)}`];
       const tailIndex = length - 1;
       for (let i = 1; i < tailIndex; i++) {
         const expr = this.translate(ast.expressions[i - 1]);
-        parts.push(`\${${expr.print()}}${ast.elements[i].text}`);
+        parts.push(`\${${expr.print()}}${this.escapeTemplateLiteral(ast.elements[i].text)}`);
       }
       const resolvedExpression = this.translate(ast.expressions[tailIndex - 1]);
-      parts.push(`\${${resolvedExpression.print()}}${ast.elements[tailIndex].text}\``);
+      parts.push(`\${${resolvedExpression.print()}}${this.escapeTemplateLiteral(ast.elements[tailIndex].text)}\``);
       result = parts.join("");
     }
     return new TcbExpr(result);
@@ -9292,6 +9345,9 @@ var TcbExprTranslator = class {
     }
     return new TcbExpr(`(${expr}!(${args}) as any)`);
   }
+  escapeTemplateLiteral(value) {
+    return value.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\${/g, "$\\{");
+  }
 };
 var VeSafeLhsInferenceBugDetector = class _VeSafeLhsInferenceBugDetector {
   static SINGLETON = new _VeSafeLhsInferenceBugDetector();
@@ -11556,7 +11612,7 @@ var Scope = class _Scope {
   getDirectiveOp(dir, node, customFieldType) {
     if (!dir.isGeneric) {
       return new TcbNonGenericDirectiveTypeOp(this.tcb, this, node, dir);
-    } else if (!dir.hasRequiresInlineTypeCtor || this.tcb.env.config.useInlineTypeConstructors) {
+    } else if (!dir.requiresInlineTypeCtor || this.tcb.env.config.useInlineTypeConstructors) {
       return new TcbDirectiveCtorOp(this.tcb, this, node, dir, customFieldType);
     }
     return new TcbGenericDirectiveTypeWithAnyParamsOp(this.tcb, this, node, dir);
@@ -11733,33 +11789,12 @@ var Scope = class _Scope {
 };
 
 // packages/compiler-cli/src/ngtsc/typecheck/src/type_check_block.js
-function generateTypeCheckBlock(env, component, name, meta, domSchemaChecker, oobRecorder, genericContextBehavior) {
+function generateTypeCheckBlock(env, component, name, meta, domSchemaChecker, oobRecorder) {
   const tcb = new Context2(env, domSchemaChecker, oobRecorder, meta.id, meta.boundTarget, meta.pipes, meta.schemas, meta.isStandalone, meta.preserveWhitespaces);
   const ctxRawType = env.referenceTcbValue(component.ref);
-  let typeParameters = void 0;
-  let typeArguments = void 0;
-  if (component.typeParameters !== void 0) {
-    if (!env.config.useContextGenericType) {
-      genericContextBehavior = TcbGenericContextBehavior.FallbackToAny;
-    }
-    switch (genericContextBehavior) {
-      case TcbGenericContextBehavior.UseEmitter:
-        const emittedParams = component.typeParameters || [];
-        typeParameters = emittedParams;
-        typeArguments = typeParameters.map((param) => param.name);
-        break;
-      case TcbGenericContextBehavior.CopyClassNodes:
-        const copiedParams = component.typeParameters ? [...component.typeParameters] : [];
-        typeParameters = copiedParams;
-        typeArguments = typeParameters.map((param) => param.name);
-        break;
-      case TcbGenericContextBehavior.FallbackToAny:
-        typeArguments = Array.from({ length: component.typeParameters?.length ?? 0 }).map(() => "any");
-        break;
-    }
-  }
-  const typeParamsStr = typeParameters === void 0 || typeParameters.length === 0 ? "" : `<${typeParameters.map((p) => p.representation).join(", ")}>`;
-  const typeArgsStr = typeArguments === void 0 || typeArguments.length === 0 ? "" : `<${typeArguments.join(", ")}>`;
+  const { typeParameters, typeArguments } = component;
+  const typeParamsStr = !env.config.useContextGenericType || typeParameters === null || typeParameters.length === 0 ? "" : `<${typeParameters.map((p) => p.representation).join(", ")}>`;
+  const typeArgsStr = typeArguments === null || typeArguments.length === 0 ? "" : `<${typeArguments.join(", ")}>`;
   const thisParamStr = `this: ${ctxRawType.print()}${typeArgsStr}`;
   const statements = [];
   if (tcb.boundTarget.target.template !== void 0) {
@@ -11951,11 +11986,11 @@ export {
   generateTcbTypeParameters,
   generateInlineTypeCtor,
   requiresInlineTypeCtor,
+  TcbGenericContextBehavior,
   RegistryDomSchemaChecker,
   ReferenceEmitEnvironment,
   Environment,
   OutOfBandDiagnosticRecorderImpl,
-  TcbGenericContextBehavior,
   generateTypeCheckBlock
 };
 /**
@@ -11979,4 +12014,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-5EGV6MZF.js.map
+//# sourceMappingURL=chunk-BCQGTZBZ.js.map