@angular/compiler 19.1.5 → 19.1.6

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.1.5
+ * @license Angular v19.1.6
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -10204,7 +10204,14 @@ function transformExpressionsInOp(op, transform, flags) {
                 op.trustedValueFn && transformExpressionsInExpression(op.trustedValueFn, transform, flags);
             break;
         case OpKind.RepeaterCreate:
-            op.track = transformExpressionsInExpression(op.track, transform, flags);
+            if (op.trackByOps === null) {
+                op.track = transformExpressionsInExpression(op.track, transform, flags);
+            }
+            else {
+                for (const innerOp of op.trackByOps) {
+                    transformExpressionsInOp(innerOp, transform, flags | VisitorContextFlag.InChildOperation);
+                }
+            }
             if (op.trackByFn !== null) {
                 op.trackByFn = transformExpressionsInExpression(op.trackByFn, transform, flags);
             }
@@ -10732,6 +10739,7 @@ function createRepeaterCreateOp(primaryView, emptyView, tag, track, varNames, em
         emptyView,
         track,
         trackByFn: null,
+        trackByOps: null,
         tag,
         emptyTag,
         emptyAttributes: null,
@@ -11232,6 +11240,11 @@ class CompilationUnit {
                     yield listenerOp;
                 }
             }
+            else if (op.kind === OpKind.RepeaterCreate && op.trackByOps !== null) {
+                for (const trackOp of op.trackByOps) {
+                    yield trackOp;
+                }
+            }
         }
         for (const op of this.update) {
             yield op;
@@ -12964,6 +12977,9 @@ function recursivelyProcessView(view, parentScope) {
                 if (op.emptyView) {
                     recursivelyProcessView(view.job.views.get(op.emptyView), scope);
                 }
+                if (op.trackByOps !== null) {
+                    op.trackByOps.prepend(generateVariablesInScopeForView(view, scope, false));
+                }
                 break;
             case OpKind.Listener:
             case OpKind.TwoWayListener:
@@ -23079,7 +23095,7 @@ function reifyCreateOperations(unit, ops) {
                     emptyDecls = emptyView.decls;
                     emptyVars = emptyView.vars;
                 }
-                OpList.replace(op, repeaterCreate(op.handle.slot, repeaterView.fnName, op.decls, op.vars, op.tag, op.attributes, op.trackByFn, op.usesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, op.emptyTag, op.emptyAttributes, op.wholeSourceSpan));
+                OpList.replace(op, repeaterCreate(op.handle.slot, repeaterView.fnName, op.decls, op.vars, op.tag, op.attributes, reifyTrackBy(unit, op), op.usesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, op.emptyTag, op.emptyAttributes, op.wholeSourceSpan));
                 break;
             case OpKind.SourceLocation:
                 const locationsLiteral = literalArr(op.locations.map(({ targetSlot, offset, line, column }) => {
@@ -23260,6 +23276,8 @@ function reifyIrExpression(expr) {
             return readContextLet(expr.targetSlot.slot);
         case ExpressionKind.StoreLet:
             return storeLet(expr.value, expr.sourceSpan);
+        case ExpressionKind.TrackContext:
+            return variable('this');
         default:
             throw new Error(`AssertionError: Unsupported reification of ir.Expression kind: ${ExpressionKind[expr.kind]}`);
     }
@@ -23288,6 +23306,42 @@ function reifyListenerHandler(unit, name, handlerOps, consumesDollarEvent) {
     }
     return fn(params, handlerStmts, undefined, undefined, name);
 }
+/** Reifies the tracking expression of a `RepeaterCreateOp`. */
+function reifyTrackBy(unit, op) {
+    // If the tracking function was created already, there's nothing left to do.
+    if (op.trackByFn !== null) {
+        return op.trackByFn;
+    }
+    const params = [new FnParam('$index'), new FnParam('$item')];
+    let fn$1;
+    if (op.trackByOps === null) {
+        // If there are no additional ops related to the tracking function, we just need
+        // to turn it into a function that returns the result of the expression.
+        fn$1 = op.usesComponentInstance
+            ? fn(params, [new ReturnStatement(op.track)])
+            : arrowFn(params, op.track);
+    }
+    else {
+        // Otherwise first we need to reify the track-related ops.
+        reifyUpdateOperations(unit, op.trackByOps);
+        const statements = [];
+        for (const trackOp of op.trackByOps) {
+            if (trackOp.kind !== OpKind.Statement) {
+                throw new Error(`AssertionError: expected reified statements, but found op ${OpKind[trackOp.kind]}`);
+            }
+            statements.push(trackOp.statement);
+        }
+        // Afterwards we can create the function from those ops.
+        fn$1 =
+            op.usesComponentInstance ||
+                statements.length !== 1 ||
+                !(statements[0] instanceof ReturnStatement)
+                ? fn(params, statements)
+                : arrowFn(params, statements[0].value);
+    }
+    op.trackByFn = unit.job.pool.getSharedFunctionReference(fn$1, '_forTrack');
+    return op.trackByFn;
+}
 
 /**
  * Binding with no content can be safely deleted.
@@ -23386,6 +23440,11 @@ function processLexicalScope$1(view, ops) {
             case OpKind.TwoWayListener:
                 processLexicalScope$1(view, op.handlerOps);
                 break;
+            case OpKind.RepeaterCreate:
+                if (op.trackByOps !== null) {
+                    processLexicalScope$1(view, op.trackByOps);
+                }
+                break;
         }
     }
     if (view === view.job.root) {
@@ -23818,6 +23877,11 @@ function processLexicalScope(unit, ops, savedView) {
                 // lexical scope.
                 processLexicalScope(unit, op.handlerOps, savedView);
                 break;
+            case OpKind.RepeaterCreate:
+                if (op.trackByOps !== null) {
+                    processLexicalScope(unit, op.trackByOps, savedView);
+                }
+                break;
         }
     }
     // Next, use the `scope` mapping to match `ir.LexicalReadExpr` with defined names in the lexical
@@ -24218,6 +24282,9 @@ function generateTemporaries(ops) {
         if (op.kind === OpKind.Listener || op.kind === OpKind.TwoWayListener) {
             op.handlerOps.prepend(generateTemporaries(op.handlerOps));
         }
+        else if (op.kind === OpKind.RepeaterCreate && op.trackByOps !== null) {
+            op.trackByOps.prepend(generateTemporaries(op.trackByOps));
+        }
     }
     return generatedStatements;
 }
@@ -24232,49 +24299,6 @@ function assignName(names, expr) {
     expr.name = name;
 }
 
-/**
- * Generate track functions that need to be extracted to the constant pool. This entails wrapping
- * them in an arrow (or traditional) function, replacing context reads with `this.`, and storing
- * them in the constant pool.
- *
- * Note that, if a track function was previously optimized, it will not need to be extracted, and
- * this phase is a no-op.
- */
-function generateTrackFns(job) {
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind !== OpKind.RepeaterCreate) {
-                continue;
-            }
-            if (op.trackByFn !== null) {
-                // The final track function was already set, probably because it was optimized.
-                continue;
-            }
-            // Find all component context reads.
-            let usesComponentContext = false;
-            op.track = transformExpressionsInExpression(op.track, (expr) => {
-                if (expr instanceof PipeBindingExpr || expr instanceof PipeBindingVariadicExpr) {
-                    throw new Error(`Illegal State: Pipes are not allowed in this context`);
-                }
-                if (expr instanceof TrackContextExpr) {
-                    usesComponentContext = true;
-                    return variable('this');
-                }
-                return expr;
-            }, VisitorContextFlag.None);
-            let fn;
-            const fnParams = [new FnParam('$index'), new FnParam('$item')];
-            if (usesComponentContext) {
-                fn = new FunctionExpr(fnParams, [new ReturnStatement(op.track)]);
-            }
-            else {
-                fn = arrowFn(fnParams, op.track);
-            }
-            op.trackByFn = job.pool.getSharedFunctionReference(fn, '_forTrack');
-        }
-    }
-}
-
 /**
  * `track` functions in `for` repeaters can sometimes be "optimized," i.e. transformed into inline
  * expressions, in lieu of an external function call. For example, tracking by `$index` can be be
@@ -24321,12 +24345,20 @@ function optimizeTrackFns(job) {
                 // Replace context reads with a special IR expression, since context reads in a track
                 // function are emitted specially.
                 op.track = transformExpressionsInExpression(op.track, (expr) => {
-                    if (expr instanceof ContextExpr) {
+                    if (expr instanceof PipeBindingExpr || expr instanceof PipeBindingVariadicExpr) {
+                        throw new Error(`Illegal State: Pipes are not allowed in this context`);
+                    }
+                    else if (expr instanceof ContextExpr) {
                         op.usesComponentInstance = true;
                         return new TrackContextExpr(expr.view);
                     }
                     return expr;
                 }, VisitorContextFlag.None);
+                // Also create an OpList for the tracking expression since it may need
+                // additional ops when generating the final code (e.g. temporary variables).
+                const trackOpList = new OpList();
+                trackOpList.push(createStatementOp(new ReturnStatement(op.track, op.track.sourceSpan)));
+                op.trackByOps = trackOpList;
             }
         }
     }
@@ -24551,6 +24583,9 @@ function optimizeVariables(job) {
             if (op.kind === OpKind.Listener || op.kind === OpKind.TwoWayListener) {
                 inlineAlwaysInlineVariables(op.handlerOps);
             }
+            else if (op.kind === OpKind.RepeaterCreate && op.trackByOps !== null) {
+                inlineAlwaysInlineVariables(op.trackByOps);
+            }
         }
         optimizeVariablesInOpList(unit.create, job.compatibility);
         optimizeVariablesInOpList(unit.update, job.compatibility);
@@ -24558,6 +24593,9 @@ function optimizeVariables(job) {
             if (op.kind === OpKind.Listener || op.kind === OpKind.TwoWayListener) {
                 optimizeVariablesInOpList(op.handlerOps, job.compatibility);
             }
+            else if (op.kind === OpKind.RepeaterCreate && op.trackByOps !== null) {
+                optimizeVariablesInOpList(op.trackByOps, job.compatibility);
+            }
         }
     }
 }
@@ -25138,7 +25176,6 @@ const phases = [
     { kind: CompilationJobKind.Tmpl, fn: resolveI18nElementPlaceholders },
     { kind: CompilationJobKind.Tmpl, fn: resolveI18nExpressionPlaceholders },
     { kind: CompilationJobKind.Tmpl, fn: extractI18nMessages },
-    { kind: CompilationJobKind.Tmpl, fn: generateTrackFns },
     { kind: CompilationJobKind.Tmpl, fn: collectI18nConsts },
     { kind: CompilationJobKind.Tmpl, fn: collectConstExpressions },
     { kind: CompilationJobKind.Both, fn: collectElementConsts },
@@ -30763,7 +30800,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('19.1.5');
+const VERSION = new Version('19.1.6');
 
 class CompilerConfig {
     defaultEncapsulation;
@@ -32514,29 +32551,32 @@ function compileClassDebugInfo(debugInfo) {
  * @param meta HMR metadata extracted from the class.
  */
 function compileHmrInitializer(meta) {
-    const id = encodeURIComponent(`${meta.filePath}@${meta.className}`);
-    const urlPartial = `./@ng/component?c=${id}&t=`;
     const moduleName = 'm';
     const dataName = 'd';
     const timestampName = 't';
+    const idName = 'id';
     const importCallbackName = `${meta.className}_HmrLoad`;
     const namespaces = meta.namespaceDependencies.map((dep) => {
         return new ExternalExpr({ moduleName: dep.moduleName, name: null });
     });
     // m.default
     const defaultRead = variable(moduleName).prop('default');
-    // ɵɵreplaceMetadata(Comp, m.default, [...namespaces], [...locals]);
+    // ɵɵreplaceMetadata(Comp, m.default, [...namespaces], [...locals], import.meta, id);
     const replaceCall = importExpr(Identifiers.replaceMetadata)
         .callFn([
         meta.type,
         defaultRead,
         literalArr(namespaces),
         literalArr(meta.localDependencies.map((l) => l.runtimeRepresentation)),
+        variable('import').prop('meta'),
+        variable(idName),
     ]);
     // (m) => m.default && ɵɵreplaceMetadata(...)
     const replaceCallback = arrowFn([new FnParam(moduleName)], defaultRead.and(replaceCall));
-    // '<urlPartial>' + encodeURIComponent(t)
-    const urlValue = literal(urlPartial)
+    // '<url>?c=' + id + '&t=' + encodeURIComponent(t)
+    const urlValue = literal(`./@ng/component?c=`)
+        .plus(variable(idName))
+        .plus(literal('&t='))
         .plus(variable('encodeURIComponent').callFn([variable(timestampName)]));
     // import.meta.url
     const urlBase = variable('import').prop('meta').prop('url');
@@ -32554,10 +32594,10 @@ function compileHmrInitializer(meta) {
             .callFn([replaceCallback])
             .toStmt(),
     ], null, StmtModifier.Final);
-    // (d) => d.id === <id> && Cmp_HmrLoad(d.timestamp)
+    // (d) => d.id === id && Cmp_HmrLoad(d.timestamp)
     const updateCallback = arrowFn([new FnParam(dataName)], variable(dataName)
         .prop('id')
-        .identical(literal(id))
+        .identical(variable(idName))
         .and(variable(importCallbackName).callFn([variable(dataName).prop('timestamp')])));
     // Cmp_HmrLoad(Date.now());
     // Initial call to kick off the loading in order to avoid edge cases with components
@@ -32572,6 +32612,8 @@ function compileHmrInitializer(meta) {
         .prop('on')
         .callFn([literal('angular:component-update'), updateCallback]);
     return arrowFn([], [
+        // const id = <id>;
+        new DeclareVarStmt(idName, literal(encodeURIComponent(`${meta.filePath}@${meta.className}`)), null, StmtModifier.Final),
         // function Cmp_HmrLoad() {...}.
         importCallback,
         // ngDevMode && Cmp_HmrLoad(Date.now());
@@ -32626,7 +32668,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('19.1.5'));
+    definitionMap.set('version', literal('19.1.6'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -32644,7 +32686,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('19.1.5'));
+    definitionMap.set('version', literal('19.1.6'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -32739,7 +32781,7 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', literal(minVersion));
-    definitionMap.set('version', literal('19.1.5'));
+    definitionMap.set('version', literal('19.1.6'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone !== undefined) {
@@ -33158,7 +33200,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('19.1.5'));
+    definitionMap.set('version', literal('19.1.6'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -33193,7 +33235,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('19.1.5'));
+    definitionMap.set('version', literal('19.1.6'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -33244,7 +33286,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('19.1.5'));
+    definitionMap.set('version', literal('19.1.6'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -33277,7 +33319,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('19.1.5'));
+    definitionMap.set('version', literal('19.1.6'));
     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.
@@ -33328,7 +33370,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('19.1.5'));
+    definitionMap.set('version', literal('19.1.6'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);