@angular/core 19.2.0-next.2 → 19.2.0-next.3

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.2.0-next.2
+ * @license Angular v19.2.0-next.3
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -377,13 +377,11 @@ function stringify(token) {
  * @returns concatenated string.
  */
 function concatStringsWithSpace(before, after) {
-    return before == null || before === ''
-        ? after === null
-            ? ''
-            : after
-        : after == null || after === ''
-            ? before
-            : before + ' ' + after;
+    if (!before)
+        return after || '';
+    if (!after)
+        return before;
+    return `${before} ${after}`;
 }
 /**
  * Ellipses the string in the middle when longer than the max length
@@ -2902,6 +2900,7 @@ const ON_DESTROY_HOOKS = 21;
 const EFFECTS_TO_SCHEDULE = 22;
 const EFFECTS = 23;
 const REACTIVE_TEMPLATE_CONSUMER = 24;
+const AFTER_RENDER_SEQUENCES_TO_ADD = 25;
 /**
  * Size of LView's header. Necessary to adjust for it when setting slots.
  *
@@ -2909,7 +2908,7 @@ const REACTIVE_TEMPLATE_CONSUMER = 24;
  * instruction index into `LView` index. All other indexes should be in the `LView` index space and
  * there should be no need to refer to `HEADER_OFFSET` anywhere else.
  */
-const HEADER_OFFSET = 25;
+const HEADER_OFFSET = 26;
 
 /**
  * Special location which allows easy identification of type. If we have an array which was
@@ -3419,7 +3418,7 @@ function requiresRefreshOrTraversal(lView) {
  * parents above.
  */
 function updateAncestorTraversalFlagsOnAttach(lView) {
-    lView[ENVIRONMENT].changeDetectionScheduler?.notify(9 /* NotificationSource.ViewAttached */);
+    lView[ENVIRONMENT].changeDetectionScheduler?.notify(8 /* NotificationSource.ViewAttached */);
     if (lView[FLAGS] & 64 /* LViewFlags.Dirty */) {
         lView[FLAGS] |= 1024 /* LViewFlags.RefreshView */;
     }
@@ -6162,7 +6161,7 @@ class PendingTasks {
                 return;
             }
             // Notifying the scheduler will hold application stability open until the next tick.
-            this.scheduler.notify(12 /* NotificationSource.PendingTaskRemoved */);
+            this.scheduler.notify(11 /* NotificationSource.PendingTaskRemoved */);
             this.internalPendingTasks.remove(taskId);
         };
     }
@@ -8656,6 +8655,23 @@ function assertNotInReactiveContext(debugFn, extraContext) {
     }
 }
 
+class ViewContext {
+    view;
+    node;
+    constructor(view, node) {
+        this.view = view;
+        this.node = node;
+    }
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static __NG_ELEMENT_ID__ = injectViewContext;
+}
+function injectViewContext() {
+    return new ViewContext(getLView(), getCurrentTNode());
+}
+
 /**
  * The phase to run an `afterRender` or `afterNextRender` callback in.
  *
@@ -8794,7 +8810,7 @@ class AfterRenderImpl {
             this.sequences.add(sequence);
         }
         if (this.deferredRegistrations.size > 0) {
-            this.scheduler.notify(8 /* NotificationSource.DeferredRenderHook */);
+            this.scheduler.notify(7 /* NotificationSource.RenderHook */);
         }
         this.deferredRegistrations.clear();
         if (hasSequencesToExecute) {
@@ -8802,16 +8818,27 @@ class AfterRenderImpl {
         }
     }
     register(sequence) {
-        if (!this.executing) {
-            this.sequences.add(sequence);
-            // Trigger an `ApplicationRef.tick()` if one is not already pending/running, because we have a
-            // new render hook that needs to run.
-            this.scheduler.notify(7 /* NotificationSource.RenderHook */);
+        const { view } = sequence;
+        if (view !== undefined) {
+            // Delay adding it to the manager, add it to the view instead.
+            (view[AFTER_RENDER_SEQUENCES_TO_ADD] ??= []).push(sequence);
+            // Mark the view for traversal to ensure we eventually schedule the afterNextRender.
+            markAncestorsForTraversal(view);
+            view[FLAGS] |= 8192 /* LViewFlags.HasChildViewsToRefresh */;
+        }
+        else if (!this.executing) {
+            this.addSequence(sequence);
         }
         else {
             this.deferredRegistrations.add(sequence);
         }
     }
+    addSequence(sequence) {
+        this.sequences.add(sequence);
+        // Trigger an `ApplicationRef.tick()` if one is not already pending/running, because we have a
+        // new render hook that needs to run.
+        this.scheduler.notify(7 /* NotificationSource.RenderHook */);
+    }
     unregister(sequence) {
         if (this.executing && this.sequences.has(sequence)) {
             // We can't remove an `AfterRenderSequence` in the middle of iteration.
@@ -8841,6 +8868,7 @@ class AfterRenderImpl {
 class AfterRenderSequence {
     impl;
     hooks;
+    view;
     once;
     snapshot;
     /**
@@ -8854,9 +8882,10 @@ class AfterRenderSequence {
      */
     pipelinedValue = undefined;
     unregisterOnDestroy;
-    constructor(impl, hooks, once, destroyRef, snapshot = null) {
+    constructor(impl, hooks, view, once, destroyRef, snapshot = null) {
         this.impl = impl;
         this.hooks = hooks;
+        this.view = view;
         this.once = once;
         this.snapshot = snapshot;
         this.unregisterOnDestroy = destroyRef?.onDestroy(() => this.destroy());
@@ -8874,6 +8903,10 @@ class AfterRenderSequence {
     destroy() {
         this.impl.unregister(this);
         this.unregisterOnDestroy?.();
+        const scheduled = this.view?.[AFTER_RENDER_SEQUENCES_TO_ADD];
+        if (scheduled) {
+            this.view[AFTER_RENDER_SEQUENCES_TO_ADD] = scheduled.filter((s) => s !== this);
+        }
     }
 }
 
@@ -8924,7 +8957,8 @@ function afterRenderImpl(callbackOrSpec, injector, options, once) {
     const tracing = injector.get(TracingService, null, { optional: true });
     const hooks = options?.phase ?? AfterRenderPhase.MixedReadWrite;
     const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
-    const sequence = new AfterRenderSequence(manager.impl, getHooks(callbackOrSpec, hooks), once, destroyRef, tracing?.snapshot(null));
+    const viewContext = injector.get(ViewContext, null, { optional: true });
+    const sequence = new AfterRenderSequence(manager.impl, getHooks(callbackOrSpec, hooks), viewContext?.view, once, destroyRef, tracing?.snapshot(null));
     manager.impl.register(sequence);
     return sequence;
 }
@@ -9396,9 +9430,11 @@ function getTriggerElement(triggerLView, triggerIndex) {
 function registerDomTrigger(initialLView, tNode, triggerIndex, walkUpTimes, registerFn, callback, type) {
     const injector = initialLView[INJECTOR];
     const zone = injector.get(NgZone);
+    let poll;
     function pollDomTrigger() {
         // If the initial view was destroyed, we don't need to do anything.
         if (isDestroyed(initialLView)) {
+            poll.destroy();
             return;
         }
         const lDetails = getLDeferBlockDetails(initialLView, tNode);
@@ -9406,14 +9442,16 @@ function registerDomTrigger(initialLView, tNode, triggerIndex, walkUpTimes, regi
         // If the block was loaded before the trigger was resolved, we don't need to do anything.
         if (renderedState !== DeferBlockInternalState.Initial &&
             renderedState !== DeferBlockState.Placeholder) {
+            poll.destroy();
             return;
         }
         const triggerLView = getTriggerLView(initialLView, tNode, walkUpTimes);
         // Keep polling until we resolve the trigger's LView.
         if (!triggerLView) {
-            afterNextRender({ read: pollDomTrigger }, { injector });
+            // Keep polling.
             return;
         }
+        poll.destroy();
         // It's possible that the trigger's view was destroyed before we resolved the trigger element.
         if (isDestroyed(triggerLView)) {
             return;
@@ -9440,7 +9478,7 @@ function registerDomTrigger(initialLView, tNode, triggerIndex, walkUpTimes, regi
         storeTriggerCleanupFn(type, lDetails, cleanup);
     }
     // Begin polling for the trigger.
-    afterNextRender({ read: pollDomTrigger }, { injector });
+    poll = afterRender({ read: pollDomTrigger }, { injector });
 }
 
 const DEFER_BLOCK_SSR_ID_ATTRIBUTE = 'ngb';
@@ -13205,7 +13243,7 @@ function detachViewFromDOM(tView, lView) {
     // When we remove a view from the DOM, we need to rerun afterRender hooks
     // We don't necessarily needs to run change detection. DOM removal only requires
     // change detection if animations are enabled (this notification is handled by animations).
-    lView[ENVIRONMENT].changeDetectionScheduler?.notify(10 /* NotificationSource.ViewDetachedFromDOM */);
+    lView[ENVIRONMENT].changeDetectionScheduler?.notify(9 /* NotificationSource.ViewDetachedFromDOM */);
     applyView(tView, lView, lView[RENDERER], 2 /* WalkTNodeTreeAction.Detach */, null, null);
 }
 /**
@@ -14095,6 +14133,15 @@ function collectNativeNodesInLContainer(lContainer, result) {
     }
 }
 
+function addAfterRenderSequencesForView(lView) {
+    if (lView[AFTER_RENDER_SEQUENCES_TO_ADD] !== null) {
+        for (const sequence of lView[AFTER_RENDER_SEQUENCES_TO_ADD]) {
+            sequence.impl.addSequence(sequence);
+        }
+        lView[AFTER_RENDER_SEQUENCES_TO_ADD].length = 0;
+    }
+}
+
 let freeConsumers = [];
 /**
  * Create a new template consumer pointing at the specified LView.
@@ -14440,6 +14487,7 @@ function refreshView(tView, lView, templateFn, context) {
         // no changes cycle, the component would be not be dirty for the next update pass. This would
         // be different in production mode where the component dirty state is not reset.
         if (!isInCheckNoChangesPass) {
+            addAfterRenderSequencesForView(lView);
             lView[FLAGS] &= ~(64 /* LViewFlags.Dirty */ | 8 /* LViewFlags.FirstLViewPass */);
         }
     }
@@ -14557,12 +14605,17 @@ function detectChangesInView(lView, mode) {
         refreshView(tView, lView, tView.template, lView[CONTEXT]);
     }
     else if (flags & 8192 /* LViewFlags.HasChildViewsToRefresh */) {
-        runEffectsInView(lView);
+        if (!isInCheckNoChangesPass) {
+            runEffectsInView(lView);
+        }
         detectChangesInEmbeddedViews(lView, 1 /* ChangeDetectionMode.Targeted */);
         const components = tView.components;
         if (components !== null) {
             detectChangesInChildComponents(lView, components, 1 /* ChangeDetectionMode.Targeted */);
         }
+        if (!isInCheckNoChangesPass) {
+            addAfterRenderSequencesForView(lView);
+        }
     }
 }
 /** Refreshes child components in the current view (update mode). */
@@ -17967,7 +18020,7 @@ class ComponentFactory extends ComponentFactory$1 {
             const cmpDef = this.componentDef;
             ngDevMode && verifyNotAnOrphanComponent(cmpDef);
             const tAttributes = rootSelectorOrNode
-                ? ['ng-version', '19.2.0-next.2']
+                ? ['ng-version', '19.2.0-next.3']
                 : // Extract attributes and classes from the first selector only to match VE behavior.
                     extractAttrsAndClassesFromSelector(this.componentDef.selectors[0]);
             // Create the root view. Uses empty TView and ContentTemplate.
@@ -23415,12 +23468,6 @@ class ApplicationRef {
      * @internal
      */
     dirtyFlags = 0 /* ApplicationRefDirtyFlags.None */;
-    /**
-     * Like `dirtyFlags` but don't cause `tick()` to loop.
-     *
-     * @internal
-     */
-    deferredDirtyFlags = 0 /* ApplicationRefDirtyFlags.None */;
     /**
      * Most recent snapshot from the `TracingService`, if any.
      *
@@ -23634,9 +23681,6 @@ class ApplicationRef {
         if (this._rendererFactory === null && !this._injector.destroyed) {
             this._rendererFactory = this._injector.get(RendererFactory2, null, { optional: true });
         }
-        // When beginning synchronization, all deferred dirtiness becomes active dirtiness.
-        this.dirtyFlags |= this.deferredDirtyFlags;
-        this.deferredDirtyFlags = 0 /* ApplicationRefDirtyFlags.None */;
         let runs = 0;
         while (this.dirtyFlags !== 0 /* ApplicationRefDirtyFlags.None */ && runs++ < MAXIMUM_REFRESH_RERUNS) {
             profiler(14 /* ProfilerEvent.ChangeDetectionSyncStart */);
@@ -23654,9 +23698,6 @@ class ApplicationRef {
      * Perform a single synchronization pass.
      */
     synchronizeOnce() {
-        // If we happened to loop, deferred dirtiness can be processed as active dirtiness again.
-        this.dirtyFlags |= this.deferredDirtyFlags;
-        this.deferredDirtyFlags = 0 /* ApplicationRefDirtyFlags.None */;
         // First, process any dirty root effects.
         if (this.dirtyFlags & 16 /* ApplicationRefDirtyFlags.RootEffects */) {
             this.dirtyFlags &= ~16 /* ApplicationRefDirtyFlags.RootEffects */;
@@ -33333,9 +33374,13 @@ function ɵsetClassDebugInfo(type, debugInfo) {
  * @param applyMetadata Callback that will apply a new set of metadata on the `type` when invoked.
  * @param environment Syntehtic namespace imports that need to be passed along to the callback.
  * @param locals Local symbols from the source location that have to be exposed to the callback.
+ * @param importMeta `import.meta` from the call site of the replacement function. Optional since
+ *   it isn't used internally.
+ * @param id ID to the class being replaced. **Not** the same as the component definition ID.
+ *   Optional since the ID might not be available internally.
  * @codeGenApi
  */
-function ɵɵreplaceMetadata(type, applyMetadata, namespaces, locals) {
+function ɵɵreplaceMetadata(type, applyMetadata, namespaces, locals, importMeta = null, id = null) {
     ngDevMode && assertComponentDef(type);
     const currentDef = getComponentDef(type);
     // The reason `applyMetadata` is a callback that is invoked (almost) immediately is because
@@ -33357,7 +33402,7 @@ function ɵɵreplaceMetadata(type, applyMetadata, namespaces, locals) {
             // Note: we have the additional check, because `IsRoot` can also indicate
             // a component created through something like `createComponent`.
             if (isRootView(root) && root[PARENT] === null) {
-                recreateMatchingLViews(newDef, oldDef, root);
+                recreateMatchingLViews(importMeta, id, newDef, oldDef, root);
             }
         }
     }
@@ -33393,10 +33438,12 @@ function mergeWithExistingDefinition(currentDef, newDef) {
 }
 /**
  * Finds all LViews matching a specific component definition and recreates them.
+ * @param importMeta `import.meta` information.
+ * @param id HMR ID of the component.
  * @param oldDef Component definition to search for.
  * @param rootLView View from which to start the search.
  */
-function recreateMatchingLViews(newDef, oldDef, rootLView) {
+function recreateMatchingLViews(importMeta, id, newDef, oldDef, rootLView) {
     ngDevMode &&
         assertDefined(oldDef.tView, 'Expected a component definition that has been instantiated at least once');
     const tView = rootLView[TVIEW];
@@ -33404,7 +33451,7 @@ function recreateMatchingLViews(newDef, oldDef, rootLView) {
     // produce false positives when using inheritance.
     if (tView === oldDef.tView) {
         ngDevMode && assertComponentDef(oldDef.type);
-        recreateLView(newDef, oldDef, rootLView);
+        recreateLView(importMeta, id, newDef, oldDef, rootLView);
         return;
     }
     for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
@@ -33412,14 +33459,14 @@ function recreateMatchingLViews(newDef, oldDef, rootLView) {
         if (isLContainer(current)) {
             // The host can be an LView if a component is injecting `ViewContainerRef`.
             if (isLView(current[HOST])) {
-                recreateMatchingLViews(newDef, oldDef, current[HOST]);
+                recreateMatchingLViews(importMeta, id, newDef, oldDef, current[HOST]);
             }
             for (let j = CONTAINER_HEADER_OFFSET; j < current.length; j++) {
-                recreateMatchingLViews(newDef, oldDef, current[j]);
+                recreateMatchingLViews(importMeta, id, newDef, oldDef, current[j]);
             }
         }
         else if (isLView(current)) {
-            recreateMatchingLViews(newDef, oldDef, current);
+            recreateMatchingLViews(importMeta, id, newDef, oldDef, current);
         }
     }
 }
@@ -33438,11 +33485,13 @@ function clearRendererCache(factory, def) {
 }
 /**
  * Recreates an LView in-place from a new component definition.
+ * @param importMeta `import.meta` information.
+ * @param id HMR ID for the component.
  * @param newDef Definition from which to recreate the view.
  * @param oldDef Previous component definition being swapped out.
  * @param lView View to be recreated.
  */
-function recreateLView(newDef, oldDef, lView) {
+function recreateLView(importMeta, id, newDef, oldDef, lView) {
     const instance = lView[CONTEXT];
     let host = lView[HOST];
     // In theory the parent can also be an LContainer, but it appears like that's
@@ -33494,10 +33543,29 @@ function recreateLView(newDef, oldDef, lView) {
     };
     // The callback isn't guaranteed to be inside the Zone so we need to bring it in ourselves.
     if (zone === null) {
-        recreate();
+        executeWithInvalidateFallback(importMeta, id, recreate);
     }
     else {
-        zone.run(recreate);
+        zone.run(() => executeWithInvalidateFallback(importMeta, id, recreate));
+    }
+}
+/**
+ * Runs an HMR-related function and falls back to
+ * invalidating the HMR data if it throws an error.
+ */
+function executeWithInvalidateFallback(importMeta, id, callback) {
+    try {
+        callback();
+    }
+    catch (e) {
+        const errorMessage = e.message;
+        // If we have all the necessary information and APIs to send off the invalidation
+        // request, send it before rethrowing so the dev server can decide what to do.
+        if (id !== null && errorMessage) {
+            importMeta?.hot?.send?.('angular:invalidate', { id, message: errorMessage, error: true });
+        }
+        // Throw the error in case the page doesn't get refreshed.
+        throw e;
     }
 }
 /**
@@ -34925,7 +34993,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('19.2.0-next.2');
+const VERSION = new Version('19.2.0-next.3');
 
 /**
  * Combination of NgModuleFactory and ComponentFactories.
@@ -35335,13 +35403,6 @@ class ChangeDetectionSchedulerImpl {
                 this.appRef.dirtyFlags |= 4 /* ApplicationRefDirtyFlags.ViewTreeCheck */;
                 break;
             }
-            case 8 /* NotificationSource.DeferredRenderHook */: {
-                // Render hooks are "deferred" when they're triggered from other render hooks. Using the
-                // deferred dirty flags ensures that adding new hooks doesn't automatically trigger a loop
-                // inside tick().
-                this.appRef.deferredDirtyFlags |= 8 /* ApplicationRefDirtyFlags.AfterRender */;
-                break;
-            }
             case 6 /* NotificationSource.CustomElement */: {
                 // We use `ViewTreeTraversal` to ensure we refresh the element even if this is triggered
                 // during CD. In practice this is a no-op since the elements code also calls via a
@@ -35350,7 +35411,7 @@ class ChangeDetectionSchedulerImpl {
                 force = true;
                 break;
             }
-            case 13 /* NotificationSource.RootEffect */: {
+            case 12 /* NotificationSource.RootEffect */: {
                 this.appRef.dirtyFlags |= 16 /* ApplicationRefDirtyFlags.RootEffects */;
                 // Root effects still force a CD, even if the scheduler is disabled. This ensures that
                 // effects always run, even when triggered from outside the zone when the scheduler is
@@ -35358,7 +35419,7 @@ class ChangeDetectionSchedulerImpl {
                 force = true;
                 break;
             }
-            case 14 /* NotificationSource.ViewEffect */: {
+            case 13 /* NotificationSource.ViewEffect */: {
                 // This is technically a no-op, since view effects will also send a
                 // `MarkAncestorsForTraversal` notification. Still, we set this for logical consistency.
                 this.appRef.dirtyFlags |= 2 /* ApplicationRefDirtyFlags.ViewTreeTraversal */;
@@ -35368,7 +35429,7 @@ class ChangeDetectionSchedulerImpl {
                 force = true;
                 break;
             }
-            case 12 /* NotificationSource.PendingTaskRemoved */: {
+            case 11 /* NotificationSource.PendingTaskRemoved */: {
                 // Removing a pending task via the public API forces a scheduled tick, ensuring that
                 // stability is async and delayed until there was at least an opportunity to run
                 // application synchronization. This prevents some footguns when working with the
@@ -35377,10 +35438,10 @@ class ChangeDetectionSchedulerImpl {
                 force = true;
                 break;
             }
-            case 10 /* NotificationSource.ViewDetachedFromDOM */:
-            case 9 /* NotificationSource.ViewAttached */:
+            case 9 /* NotificationSource.ViewDetachedFromDOM */:
+            case 8 /* NotificationSource.ViewAttached */:
             case 7 /* NotificationSource.RenderHook */:
-            case 11 /* NotificationSource.AsyncAnimationsLoaded */:
+            case 10 /* NotificationSource.AsyncAnimationsLoaded */:
             default: {
                 // These notifications only schedule a tick but do not change whether we should refresh
                 // views. Instead, we only need to run render hooks unless another notification from the
@@ -40589,23 +40650,6 @@ function untracked(nonReactiveReadsFn) {
     }
 }
 
-class ViewContext {
-    view;
-    node;
-    constructor(view, node) {
-        this.view = view;
-        this.node = node;
-    }
-    /**
-     * @internal
-     * @nocollapse
-     */
-    static __NG_ELEMENT_ID__ = injectViewContext;
-}
-function injectViewContext() {
-    return new ViewContext(getLView(), getCurrentTNode());
-}
-
 /**
  * Controls whether effects use the legacy `microtaskEffect` by default.
  */
@@ -40873,7 +40917,7 @@ const ROOT_EFFECT_NODE =
     ...BASE_EFFECT_NODE,
     consumerMarkedDirty() {
         this.scheduler.schedule(this);
-        this.notifier.notify(13 /* NotificationSource.RootEffect */);
+        this.notifier.notify(12 /* NotificationSource.RootEffect */);
     },
     destroy() {
         consumerDestroy$1(this);
@@ -40888,7 +40932,7 @@ const VIEW_EFFECT_NODE =
     consumerMarkedDirty() {
         this.view[FLAGS] |= 8192 /* LViewFlags.HasChildViewsToRefresh */;
         markAncestorsForTraversal(this.view);
-        this.notifier.notify(14 /* NotificationSource.ViewEffect */);
+        this.notifier.notify(13 /* NotificationSource.ViewEffect */);
     },
     destroy() {
         consumerDestroy$1(this);
@@ -40915,7 +40959,7 @@ function createRootEffect(fn, scheduler, notifier) {
     node.notifier = notifier;
     node.zone = typeof Zone !== 'undefined' ? Zone.current : null;
     node.scheduler.schedule(node);
-    node.notifier.notify(13 /* NotificationSource.RootEffect */);
+    node.notifier.notify(12 /* NotificationSource.RootEffect */);
     return node;
 }
 
@@ -41006,10 +41050,10 @@ class AfterRenderEffectSequence extends AfterRenderSequence {
      * These are initialized to `undefined` but set in the constructor.
      */
     nodes = [undefined, undefined, undefined, undefined];
-    constructor(impl, effectHooks, scheduler, destroyRef, snapshot = null) {
+    constructor(impl, effectHooks, view, scheduler, destroyRef, snapshot = null) {
         // Note that we also initialize the underlying `AfterRenderSequence` hooks to `undefined` and
         // populate them as we create reactive nodes below.
-        super(impl, [undefined, undefined, undefined, undefined], false, destroyRef, snapshot);
+        super(impl, [undefined, undefined, undefined, undefined], view, false, destroyRef, snapshot);
         this.scheduler = scheduler;
         // Setup a reactive node for each phase.
         for (const phase of AFTER_RENDER_PHASES) {
@@ -41068,7 +41112,8 @@ function afterRenderEffect(callbackOrSpec, options) {
     if (typeof spec === 'function') {
         spec = { mixedReadWrite: callbackOrSpec };
     }
-    const sequence = new AfterRenderEffectSequence(manager.impl, [spec.earlyRead, spec.write, spec.mixedReadWrite, spec.read], scheduler, injector.get(DestroyRef), tracing?.snapshot(null));
+    const viewContext = injector.get(ViewContext, null, { optional: true });
+    const sequence = new AfterRenderEffectSequence(manager.impl, [spec.earlyRead, spec.write, spec.mixedReadWrite, spec.read], viewContext?.view, scheduler, injector.get(DestroyRef), tracing?.snapshot(null));
     manager.impl.register(sequence);
     return sequence;
 }