@angular/compiler 18.0.0-next.3 → 18.0.0-next.5

package/fesm2022/compiler.mjs

@@ -1,6 +1,6 @@
 /**
- * @license Angular v18.0.0-next.3
- * (c) 2010-2022 Google LLC. https://angular.io/
+ * @license Angular v18.0.0-next.5
+ * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
 
@@ -2662,10 +2662,6 @@ class Identifiers {
         name: 'ɵɵgetInheritedFactory',
         moduleName: CORE,
     }; }
-    static { this.InputFlags = {
-        name: 'ɵɵInputFlags',
-        moduleName: CORE,
-    }; }
     // sanitization-related functions
     static { this.sanitizeHtml = { name: 'ɵɵsanitizeHtml', moduleName: CORE }; }
     static { this.sanitizeStyle = { name: 'ɵɵsanitizeStyle', moduleName: CORE }; }
@@ -5638,19 +5634,19 @@ function conditionallyCreateDirectiveBindingLiteral(map, forInputs) {
             publicName = value.bindingPropertyName;
             const differentDeclaringName = publicName !== declaredName;
             const hasDecoratorInputTransform = value.transformFunction !== null;
+            let flags = InputFlags.None;
             // Build up input flags
-            let flags = null;
             if (value.isSignal) {
-                flags = bitwiseOrInputFlagsExpr(InputFlags.SignalBased, flags);
+                flags |= InputFlags.SignalBased;
             }
             if (hasDecoratorInputTransform) {
-                flags = bitwiseOrInputFlagsExpr(InputFlags.HasDecoratorInputTransform, flags);
+                flags |= InputFlags.HasDecoratorInputTransform;
             }
             // Inputs, compared to outputs, will track their declared name (for `ngOnChanges`), support
             // decorator input transform functions, or store flag information if there is any.
-            if (forInputs && (differentDeclaringName || hasDecoratorInputTransform || flags !== null)) {
-                const flagsExpr = flags ?? importExpr(Identifiers.InputFlags).prop(InputFlags[InputFlags.None]);
-                const result = [flagsExpr, asLiteral(publicName)];
+            if (forInputs &&
+                (differentDeclaringName || hasDecoratorInputTransform || flags !== InputFlags.None)) {
+                const result = [literal(flags), asLiteral(publicName)];
                 if (differentDeclaringName || hasDecoratorInputTransform) {
                     result.push(asLiteral(declaredName));
                     if (hasDecoratorInputTransform) {
@@ -5671,26 +5667,6 @@ function conditionallyCreateDirectiveBindingLiteral(map, forInputs) {
         };
     }));
 }
-/** Gets an output AST expression referencing the given flag. */
-function getInputFlagExpr(flag) {
-    return importExpr(Identifiers.InputFlags).prop(InputFlags[flag]);
-}
-/** Combines a given input flag with an existing flag expression, if present. */
-function bitwiseOrInputFlagsExpr(flag, expr) {
-    if (expr === null) {
-        return getInputFlagExpr(flag);
-    }
-    return getInputFlagExpr(flag).bitwiseOr(expr);
-}
-/**
- *  Remove trailing null nodes as they are implied.
- */
-function trimTrailingNulls(parameters) {
-    while (isNull(parameters[parameters.length - 1])) {
-        parameters.pop();
-    }
-    return parameters;
-}
 /**
  * A representation for an object literal used during codegen of definition objects. The generic
  * type `T` allows to reference a documented type of the generated structure, such that the
@@ -8569,11 +8545,10 @@ function createAdvanceOp(delta, sourceSpan) {
 /**
  * Create a conditional op, which will display an embedded view according to a condtion.
  */
-function createConditionalOp(target, targetSlot, test, conditions, sourceSpan) {
+function createConditionalOp(target, test, conditions, sourceSpan) {
     return {
         kind: OpKind.Conditional,
         target,
-        targetSlot,
         test,
         conditions,
         processed: null,
@@ -20813,21 +20788,7 @@ function pipeBindV(slot, varOffset, args) {
     ]);
 }
 function textInterpolate(strings, expressions, sourceSpan) {
-    if (strings.length < 1 || expressions.length !== strings.length - 1) {
-        throw new Error(`AssertionError: expected specific shape of args for strings/expressions in interpolation`);
-    }
-    const interpolationArgs = [];
-    if (expressions.length === 1 && strings[0] === '' && strings[1] === '') {
-        interpolationArgs.push(expressions[0]);
-    }
-    else {
-        let idx;
-        for (idx = 0; idx < expressions.length; idx++) {
-            interpolationArgs.push(literal(strings[idx]), expressions[idx]);
-        }
-        // idx points at the last string.
-        interpolationArgs.push(literal(strings[idx]));
-    }
+    const interpolationArgs = collateInterpolationArgs(strings, expressions);
     return callVariadicInstruction(TEXT_INTERPOLATE_CONFIG, [], interpolationArgs, [], sourceSpan);
 }
 function i18nExp(expr, sourceSpan) {
@@ -20909,8 +20870,8 @@ function call(instruction, args, sourceSpan) {
     const expr = importExpr(instruction).callFn(args, sourceSpan);
     return createStatementOp(new ExpressionStatement(expr, sourceSpan));
 }
-function conditional(slot, condition, contextValue, sourceSpan) {
-    const args = [literal(slot), condition];
+function conditional(condition, contextValue, sourceSpan) {
+    const args = [condition];
     if (contextValue !== null) {
         args.push(contextValue);
     }
@@ -21404,10 +21365,7 @@ function reifyUpdateOperations(_unit, ops) {
                 if (op.processed === null) {
                     throw new Error(`Conditional test was not set.`);
                 }
-                if (op.targetSlot.slot === null) {
-                    throw new Error(`Conditional slot was not set.`);
-                }
-                OpList.replace(op, conditional(op.targetSlot.slot, op.processed, op.contextValue, op.sourceSpan));
+                OpList.replace(op, conditional(op.processed, op.contextValue, op.sourceSpan));
                 break;
             case OpKind.Repeater:
                 OpList.replace(op, repeater(op.collection, op.sourceSpan));
@@ -22184,72 +22142,27 @@ function transformTwoWayBindingSet(job) {
         for (const op of unit.create) {
             if (op.kind === OpKind.TwoWayListener) {
                 transformExpressionsInOp(op, (expr) => {
-                    if (expr instanceof TwoWayBindingSetExpr) {
-                        return wrapAction(expr.target, expr.value);
+                    if (!(expr instanceof TwoWayBindingSetExpr)) {
+                        return expr;
                     }
-                    return expr;
+                    const { target, value } = expr;
+                    if (target instanceof ReadPropExpr || target instanceof ReadKeyExpr) {
+                        return twoWayBindingSet(target, value).or(target.set(value));
+                    }
+                    // ASSUMPTION: here we're assuming that `ReadVariableExpr` will be a reference
+                    // to a local template variable. This appears to be the case at the time of writing.
+                    // If the expression is targeting a variable read, we only emit the `twoWayBindingSet`
+                    // since the fallback would be attempting to write into a constant. Invalid usages will be
+                    // flagged during template type checking.
+                    if (target instanceof ReadVariableExpr) {
+                        return twoWayBindingSet(target, value);
+                    }
+                    throw new Error(`Unsupported expression in two-way action binding.`);
                 }, VisitorContextFlag.InChildOperation);
             }
         }
     }
 }
-function wrapSetOperation(target, value) {
-    // ASSUMPTION: here we're assuming that `ReadVariableExpr` will be a reference
-    // to a local template variable. This appears to be the case at the time of writing.
-    // If the expression is targeting a variable read, we only emit the `twoWayBindingSet` since
-    // the fallback would be attempting to write into a constant. Invalid usages will be flagged
-    // during template type checking.
-    if (target instanceof ReadVariableExpr) {
-        return twoWayBindingSet(target, value);
-    }
-    return twoWayBindingSet(target, value).or(target.set(value));
-}
-function isReadExpression(value) {
-    return value instanceof ReadPropExpr || value instanceof ReadKeyExpr ||
-        value instanceof ReadVariableExpr;
-}
-function wrapAction(target, value) {
-    // The only officially supported expressions inside of a two-way binding are read expressions.
-    if (isReadExpression(target)) {
-        return wrapSetOperation(target, value);
-    }
-    // However, historically the expression parser was handling two-way events by appending `=$event`
-    // to the raw string before attempting to parse it. This has led to bugs over the years (see
-    // #37809) and to unintentionally supporting unassignable events in the two-way binding. The
-    // logic below aims to emulate the old behavior while still supporting the new output format
-    // which uses `twoWayBindingSet`. Note that the generated code doesn't necessarily make sense
-    // based on what the user wrote, for example the event binding for `[(value)]="a ? b : c"`
-    // would produce `ctx.a ? ctx.b : ctx.c = $event`. We aim to reproduce what the parser used
-    // to generate before #54154.
-    if (target instanceof BinaryOperatorExpr && isReadExpression(target.rhs)) {
-        // `a && b` -> `ctx.a && twoWayBindingSet(ctx.b, $event) || (ctx.b = $event)`
-        return new BinaryOperatorExpr(target.operator, target.lhs, wrapSetOperation(target.rhs, value));
-    }
-    // Note: this also supports nullish coalescing expressions which
-    // would've been downleveled to ternary expressions by this point.
-    if (target instanceof ConditionalExpr && isReadExpression(target.falseCase)) {
-        // `a ? b : c` -> `ctx.a ? ctx.b : twoWayBindingSet(ctx.c, $event) || (ctx.c = $event)`
-        return new ConditionalExpr(target.condition, target.trueCase, wrapSetOperation(target.falseCase, value));
-    }
-    // `!!a` -> `twoWayBindingSet(ctx.a, $event) || (ctx.a = $event)`
-    // Note: previously we'd actually produce `!!(ctx.a = $event)`, but the wrapping
-    // node doesn't affect the result so we don't need to carry it over.
-    if (target instanceof NotExpr) {
-        let expr = target.condition;
-        while (true) {
-            if (expr instanceof NotExpr) {
-                expr = expr.condition;
-            }
-            else {
-                if (isReadExpression(expr)) {
-                    return wrapSetOperation(expr, value);
-                }
-                break;
-            }
-        }
-    }
-    throw new Error(`Unsupported expression in two-way action binding.`);
-}
 
 /**
  * When inside of a listener, we may need access to one or more enclosing views. Therefore, each
@@ -23634,7 +23547,6 @@ function ingestBoundText(unit, text, icuPlaceholder) {
  */
 function ingestIfBlock(unit, ifBlock) {
     let firstXref = null;
-    let firstSlotHandle = null;
     let conditions = [];
     for (let i = 0; i < ifBlock.branches.length; i++) {
         const ifCase = ifBlock.branches[i];
@@ -23654,15 +23566,13 @@ function ingestIfBlock(unit, ifBlock) {
         unit.create.push(templateOp);
         if (firstXref === null) {
             firstXref = cView.xref;
-            firstSlotHandle = templateOp.handle;
         }
         const caseExpr = ifCase.expression ? convertAst(ifCase.expression, unit.job, null) : null;
         const conditionalCaseExpr = new ConditionalCaseExpr(caseExpr, templateOp.xref, templateOp.handle, ifCase.expressionAlias);
         conditions.push(conditionalCaseExpr);
         ingestNodes(cView, ifCase.children);
     }
-    const conditional = createConditionalOp(firstXref, firstSlotHandle, null, conditions, ifBlock.sourceSpan);
-    unit.update.push(conditional);
+    unit.update.push(createConditionalOp(firstXref, null, conditions, ifBlock.sourceSpan));
 }
 /**
  * Ingest an `@switch` block into the given `ViewCompilation`.
@@ -23673,7 +23583,6 @@ function ingestSwitchBlock(unit, switchBlock) {
         return;
     }
     let firstXref = null;
-    let firstSlotHandle = null;
     let conditions = [];
     for (const switchCase of switchBlock.cases) {
         const cView = unit.job.allocateView(unit.xref);
@@ -23689,7 +23598,6 @@ function ingestSwitchBlock(unit, switchBlock) {
         unit.create.push(templateOp);
         if (firstXref === null) {
             firstXref = cView.xref;
-            firstSlotHandle = templateOp.handle;
         }
         const caseExpr = switchCase.expression ?
             convertAst(switchCase.expression, unit.job, switchBlock.startSourceSpan) :
@@ -23698,8 +23606,7 @@ function ingestSwitchBlock(unit, switchBlock) {
         conditions.push(conditionalCaseExpr);
         ingestNodes(cView, switchCase.children);
     }
-    const conditional = createConditionalOp(firstXref, firstSlotHandle, convertAst(switchBlock.expression, unit.job, null), conditions, switchBlock.sourceSpan);
-    unit.update.push(conditional);
+    unit.update.push(createConditionalOp(firstXref, convertAst(switchBlock.expression, unit.job, null), conditions, switchBlock.sourceSpan));
 }
 function ingestDeferView(unit, suffix, i18nMeta, children, sourceSpan) {
     if (i18nMeta !== undefined && !(i18nMeta instanceof BlockPlaceholder)) {
@@ -24696,11 +24603,12 @@ const ANIMATE_PROP_PREFIX = 'animate-';
  * Parses bindings in templates and in the directive host area.
  */
 class BindingParser {
-    constructor(_exprParser, _interpolationConfig, _schemaRegistry, errors) {
+    constructor(_exprParser, _interpolationConfig, _schemaRegistry, errors, _allowInvalidAssignmentEvents = false) {
         this._exprParser = _exprParser;
         this._interpolationConfig = _interpolationConfig;
         this._schemaRegistry = _schemaRegistry;
         this.errors = errors;
+        this._allowInvalidAssignmentEvents = _allowInvalidAssignmentEvents;
     }
     get interpolationConfig() {
         return this._interpolationConfig;
@@ -25080,6 +24988,11 @@ class BindingParser {
         if (ast instanceof PropertyRead || ast instanceof KeyedRead) {
             return true;
         }
+        // TODO(crisbeto): this logic is only here to support the automated migration away
+        // from invalid bindings. It should be removed once the migration is deleted.
+        if (!this._allowInvalidAssignmentEvents) {
+            return false;
+        }
         if (ast instanceof Binary) {
             return (ast.operation === '&&' || ast.operation === '||' || ast.operation === '??') &&
                 (ast.right instanceof PropertyRead || ast.right instanceof KeyedRead);
@@ -26604,8 +26517,8 @@ const LEADING_TRIVIA_CHARS = [' ', '\n', '\r', '\t'];
  * @param options options to modify how the template is parsed
  */
 function parseTemplate(template, templateUrl, options = {}) {
-    const { interpolationConfig, preserveWhitespaces, enableI18nLegacyMessageIdFormat } = options;
-    const bindingParser = makeBindingParser(interpolationConfig);
+    const { interpolationConfig, preserveWhitespaces, enableI18nLegacyMessageIdFormat, allowInvalidAssignmentEvents } = options;
+    const bindingParser = makeBindingParser(interpolationConfig, allowInvalidAssignmentEvents);
     const htmlParser = new HtmlParser();
     const parseResult = htmlParser.parse(template, templateUrl, {
         leadingTriviaChars: LEADING_TRIVIA_CHARS,
@@ -26683,8 +26596,8 @@ const elementRegistry = new DomElementSchemaRegistry();
 /**
  * Construct a `BindingParser` with a default configuration.
  */
-function makeBindingParser(interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
-    return new BindingParser(new Parser$1(new Lexer()), interpolationConfig, elementRegistry, []);
+function makeBindingParser(interpolationConfig = DEFAULT_INTERPOLATION_CONFIG, allowInvalidAssignmentEvents = false) {
+    return new BindingParser(new Parser$1(new Lexer()), interpolationConfig, elementRegistry, [], allowInvalidAssignmentEvents);
 }
 
 const COMPONENT_VARIABLE = '%COMP%';
@@ -28644,7 +28557,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('18.0.0-next.3');
+const VERSION = new Version('18.0.0-next.5');
 
 class CompilerConfig {
     constructor({ defaultEncapsulation = ViewEncapsulation.Emulated, preserveWhitespaces, strictInjectionParameters } = {}) {
@@ -30229,7 +30142,7 @@ const MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION = '18.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', literal('18.0.0-next.3'));
+    definitionMap.set('version', literal('18.0.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -30247,7 +30160,7 @@ function compileComponentDeclareClassMetadata(metadata, dependencies) {
     callbackReturnDefinitionMap.set('ctorParameters', metadata.ctorParameters ?? literal(null));
     callbackReturnDefinitionMap.set('propDecorators', metadata.propDecorators ?? literal(null));
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION));
-    definitionMap.set('version', literal('18.0.0-next.3'));
+    definitionMap.set('version', literal('18.0.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -30342,7 +30255,7 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', literal(minVersion));
-    definitionMap.set('version', literal('18.0.0-next.3'));
+    definitionMap.set('version', literal('18.0.0-next.5'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -30757,7 +30670,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', literal('18.0.0-next.3'));
+    definitionMap.set('version', literal('18.0.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -30792,7 +30705,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('18.0.0-next.3'));
+    definitionMap.set('version', literal('18.0.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -30843,7 +30756,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('18.0.0-next.3'));
+    definitionMap.set('version', literal('18.0.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -30876,7 +30789,7 @@ function createNgModuleDefinitionMap(meta) {
         throw new Error('Invalid path! Local compilation mode should not get into the partial compilation path');
     }
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', literal('18.0.0-next.3'));
+    definitionMap.set('version', literal('18.0.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -30927,7 +30840,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('18.0.0-next.3'));
+    definitionMap.set('version', literal('18.0.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);