@angular/core 19.1.0-next.4 → 19.1.0-rc.0

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.1.0-next.4
+ * @license Angular v19.1.0-rc.0
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -1715,8 +1715,7 @@ function getPipeDef$1(type) {
  */
 function isStandalone(type) {
     const def = getComponentDef(type) || getDirectiveDef(type) || getPipeDef$1(type);
-    // TODO: standalone as default value (invert the condition)
-    return def !== null ? def.standalone : false;
+    return def !== null && def.standalone;
 }
 
 /**
@@ -2903,6 +2902,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.
  *
@@ -2910,7 +2910,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
@@ -2985,6 +2985,7 @@ function hasI18n(lView) {
     return (lView[FLAGS] & 32 /* LViewFlags.HasI18n */) === 32 /* LViewFlags.HasI18n */;
 }
 function isDestroyed(lView) {
+    // Determines whether a given LView is marked as destroyed.
     return (lView[FLAGS] & 256 /* LViewFlags.Destroyed */) === 256 /* LViewFlags.Destroyed */;
 }
 
@@ -3430,7 +3431,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 */;
     }
@@ -3465,7 +3466,7 @@ function markAncestorsForTraversal(lView) {
  * Stores a LView-specific destroy callback.
  */
 function storeLViewOnDestroy(lView, onDestroyCallback) {
-    if ((lView[FLAGS] & 256 /* LViewFlags.Destroyed */) === 256 /* LViewFlags.Destroyed */) {
+    if (isDestroyed(lView)) {
         throw new RuntimeError(911 /* RuntimeErrorCode.VIEW_ALREADY_DESTROYED */, ngDevMode && 'View has already been destroyed.');
     }
     if (lView[ON_DESTROY_HOOKS] === null) {
@@ -6139,7 +6140,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);
         };
     }
@@ -6181,7 +6182,8 @@ class PendingTasks {
 }
 
 class EventEmitter_ extends Subject {
-    __isAsync; // tslint:disable-line
+    // tslint:disable-next-line:require-internal-with-underscore
+    __isAsync;
     destroyRef = undefined;
     pendingTasks = undefined;
     constructor(isAsync = false) {
@@ -8587,6 +8589,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.
  *
@@ -8717,21 +8736,32 @@ 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();
     }
     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.
@@ -8761,6 +8791,7 @@ class AfterRenderImpl {
 class AfterRenderSequence {
     impl;
     hooks;
+    view;
     once;
     snapshot;
     /**
@@ -8774,9 +8805,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());
@@ -8794,6 +8826,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);
+        }
     }
 }
 
@@ -8844,7 +8880,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;
 }
@@ -9316,9 +9353,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);
@@ -9326,14 +9365,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;
@@ -9360,7 +9401,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';
@@ -11674,7 +11715,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);
 }
 /**
@@ -11858,13 +11899,14 @@ function detachView(lContainer, removeIndex) {
  * @param lView The view to be destroyed.
  */
 function destroyLView(tView, lView) {
-    if (!(lView[FLAGS] & 256 /* LViewFlags.Destroyed */)) {
-        const renderer = lView[RENDERER];
-        if (renderer.destroyNode) {
-            applyView(tView, lView, renderer, 3 /* WalkTNodeTreeAction.Destroy */, null, null);
-        }
-        destroyViewTree(lView);
+    if (isDestroyed(lView)) {
+        return;
     }
+    const renderer = lView[RENDERER];
+    if (renderer.destroyNode) {
+        applyView(tView, lView, renderer, 3 /* WalkTNodeTreeAction.Destroy */, null, null);
+    }
+    destroyViewTree(lView);
 }
 /**
  * Calls onDestroys hooks for all directives and pipes in a given view and then removes all
@@ -11875,7 +11917,7 @@ function destroyLView(tView, lView) {
  * @param lView The LView to clean up
  */
 function cleanUpView(tView, lView) {
-    if (lView[FLAGS] & 256 /* LViewFlags.Destroyed */) {
+    if (isDestroyed(lView)) {
         return;
     }
     const prevConsumer = setActiveConsumer$1(null);
@@ -14660,6 +14702,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.
@@ -14861,9 +14912,9 @@ function checkNoChangesInternal(lView, mode, notifyErrorHandler = true) {
  */
 function refreshView(tView, lView, templateFn, context) {
     ngDevMode && assertEqual(isCreationMode(lView), false, 'Should be run in update mode');
-    const flags = lView[FLAGS];
-    if ((flags & 256 /* LViewFlags.Destroyed */) === 256 /* LViewFlags.Destroyed */)
+    if (isDestroyed(lView))
         return;
+    const flags = lView[FLAGS];
     // Check no changes mode is a dev only mode used to verify that bindings have not changed
     // since they were assigned. We do not want to execute lifecycle hooks in that mode.
     const isInCheckNoChangesPass = ngDevMode && isInCheckNoChangesMode();
@@ -15005,6 +15056,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 */);
         }
     }
@@ -15120,12 +15172,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). */
@@ -15229,7 +15286,7 @@ class ViewRef$1 {
         this._lView[CONTEXT] = value;
     }
     get destroyed() {
-        return (this._lView[FLAGS] & 256 /* LViewFlags.Destroyed */) === 256 /* LViewFlags.Destroyed */;
+        return isDestroyed(this._lView);
     }
     destroy() {
         if (this._appRef) {
@@ -18110,7 +18167,7 @@ function createRootComponent(componentView, rootComponentDef, rootDirectives, ho
 function setRootNodeAttributes(hostRenderer, componentDef, hostRNode, rootSelectorOrNode) {
     if (rootSelectorOrNode) {
         // The placeholder will be replaced with the actual version at build time.
-        setUpAttributes(hostRenderer, hostRNode, ['ng-version', '19.1.0-next.4']);
+        setUpAttributes(hostRenderer, hostRNode, ['ng-version', '19.1.0-rc.0']);
     }
     else {
         // If host element is created as a part of this function call (i.e. `rootSelectorOrNode`
@@ -19709,7 +19766,6 @@ class NgModuleRef extends NgModuleRef$1 {
     _parent;
     // tslint:disable-next-line:require-internal-with-underscore
     _bootstrapComponents = [];
-    // tslint:disable-next-line:require-internal-with-underscore
     _r3Injector;
     instance;
     destroyCbs = [];
@@ -21197,7 +21253,8 @@ class CachedInjectorService {
  *
  * This token is only injected in devMode
  */
-const DEFER_BLOCK_DEPENDENCY_INTERCEPTOR = new InjectionToken('DEFER_BLOCK_DEPENDENCY_INTERCEPTOR');
+const DEFER_BLOCK_DEPENDENCY_INTERCEPTOR = 
+/* @__PURE__ */ new InjectionToken('DEFER_BLOCK_DEPENDENCY_INTERCEPTOR');
 /**
  * **INTERNAL**, token used for configuring defer block behavior.
  */
@@ -21589,7 +21646,6 @@ class Console {
     }
     // Note: for reporting errors use `DOM.logError()` as it is platform specific
     warn(message) {
-        // tslint:disable-next-line:no-console
         console.warn(message);
     }
     static ɵfac = function Console_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || Console)(); };
@@ -23046,6 +23102,77 @@ function isSubscribable(obj) {
     return !!obj && typeof obj.subscribe === 'function';
 }
 
+/**
+ * A scheduler which manages the execution of effects.
+ */
+class EffectScheduler {
+    /** @nocollapse */
+    static ɵprov = /** @pureOrBreakMyCode */ /* @__PURE__ */ ɵɵdefineInjectable({
+        token: EffectScheduler,
+        providedIn: 'root',
+        factory: () => new ZoneAwareEffectScheduler(),
+    });
+}
+/**
+ * A wrapper around `ZoneAwareQueueingScheduler` that schedules flushing via the microtask queue
+ * when.
+ */
+class ZoneAwareEffectScheduler {
+    queuedEffectCount = 0;
+    queues = new Map();
+    schedule(handle) {
+        this.enqueue(handle);
+    }
+    remove(handle) {
+        const zone = handle.zone;
+        const queue = this.queues.get(zone);
+        if (!queue.has(handle)) {
+            return;
+        }
+        queue.delete(handle);
+        this.queuedEffectCount--;
+    }
+    enqueue(handle) {
+        const zone = handle.zone;
+        if (!this.queues.has(zone)) {
+            this.queues.set(zone, new Set());
+        }
+        const queue = this.queues.get(zone);
+        if (queue.has(handle)) {
+            return;
+        }
+        this.queuedEffectCount++;
+        queue.add(handle);
+    }
+    /**
+     * Run all scheduled effects.
+     *
+     * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no
+     * ordering guarantee between effects scheduled in different zones.
+     */
+    flush() {
+        while (this.queuedEffectCount > 0) {
+            for (const [zone, queue] of this.queues) {
+                // `zone` here must be defined.
+                if (zone === null) {
+                    this.flushQueue(queue);
+                }
+                else {
+                    zone.run(() => this.flushQueue(queue));
+                }
+            }
+        }
+    }
+    flushQueue(queue) {
+        for (const handle of queue) {
+            queue.delete(handle);
+            this.queuedEffectCount--;
+            // TODO: what happens if this throws an error?
+            handle.run();
+        }
+    }
+}
+
 /**
  * A DI token that you can use to provide
  * one or more initialization functions.
@@ -23290,68 +23417,6 @@ class ApplicationInitStatus {
         args: [{ providedIn: 'root' }]
     }], () => [], null); })();
 
-/**
- * A scheduler which manages the execution of effects.
- */
-class EffectScheduler {
-    /** @nocollapse */
-    static ɵprov = /** @pureOrBreakMyCode */ /* @__PURE__ */ ɵɵdefineInjectable({
-        token: EffectScheduler,
-        providedIn: 'root',
-        factory: () => new ZoneAwareEffectScheduler(),
-    });
-}
-/**
- * A wrapper around `ZoneAwareQueueingScheduler` that schedules flushing via the microtask queue
- * when.
- */
-class ZoneAwareEffectScheduler {
-    queuedEffectCount = 0;
-    queues = new Map();
-    schedule(handle) {
-        this.enqueue(handle);
-    }
-    enqueue(handle) {
-        const zone = handle.zone;
-        if (!this.queues.has(zone)) {
-            this.queues.set(zone, new Set());
-        }
-        const queue = this.queues.get(zone);
-        if (queue.has(handle)) {
-            return;
-        }
-        this.queuedEffectCount++;
-        queue.add(handle);
-    }
-    /**
-     * Run all scheduled effects.
-     *
-     * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no
-     * ordering guarantee between effects scheduled in different zones.
-     */
-    flush() {
-        while (this.queuedEffectCount > 0) {
-            for (const [zone, queue] of this.queues) {
-                // `zone` here must be defined.
-                if (zone === null) {
-                    this.flushQueue(queue);
-                }
-                else {
-                    zone.run(() => this.flushQueue(queue));
-                }
-            }
-        }
-    }
-    flushQueue(queue) {
-        for (const handle of queue) {
-            queue.delete(handle);
-            this.queuedEffectCount--;
-            // TODO: what happens if this throws an error?
-            handle.run();
-        }
-    }
-}
-
 /**
  * A DI token that provides a set of callbacks to
  * be called for every component that is bootstrapped.
@@ -23529,12 +23594,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.
      *
@@ -23639,7 +23698,7 @@ class ApplicationRef {
      * {@example core/ts/platform/platform.ts region='domNode'}
      */
     bootstrap(componentOrFactory, rootSelectorOrNode) {
-        (typeof ngDevMode === 'undefined' || ngDevMode) && this.warnIfDestroyed();
+        (typeof ngDevMode === 'undefined' || ngDevMode) && warnIfDestroyed(this._destroyed);
         const isComponentFactory = componentOrFactory instanceof ComponentFactory$1;
         const initStatus = this._injector.get(ApplicationInitStatus);
         if (!initStatus.done) {
@@ -23709,7 +23768,7 @@ class ApplicationRef {
             snapshot.dispose();
             return;
         }
-        (typeof ngDevMode === 'undefined' || ngDevMode) && this.warnIfDestroyed();
+        (typeof ngDevMode === 'undefined' || ngDevMode) && warnIfDestroyed(this._destroyed);
         if (this._runningTick) {
             throw new RuntimeError(101 /* RuntimeErrorCode.RECURSIVE_APPLICATION_REF_TICK */, ngDevMode && 'ApplicationRef.tick is called recursively');
         }
@@ -23741,9 +23800,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) {
             this.synchronizeOnce();
@@ -23759,9 +23815,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 */;
@@ -23840,7 +23893,7 @@ class ApplicationRef {
      * This will throw if the view is already attached to a ViewContainer.
      */
     attachView(viewRef) {
-        (typeof ngDevMode === 'undefined' || ngDevMode) && this.warnIfDestroyed();
+        (typeof ngDevMode === 'undefined' || ngDevMode) && warnIfDestroyed(this._destroyed);
         const view = viewRef;
         this._views.push(view);
         view.attachToAppRef(this);
@@ -23849,7 +23902,7 @@ class ApplicationRef {
      * Detaches a view from dirty checking again.
      */
     detachView(viewRef) {
-        (typeof ngDevMode === 'undefined' || ngDevMode) && this.warnIfDestroyed();
+        (typeof ngDevMode === 'undefined' || ngDevMode) && warnIfDestroyed(this._destroyed);
         const view = viewRef;
         remove(this._views, view);
         view.detachFromAppRef();
@@ -23893,7 +23946,7 @@ class ApplicationRef {
      * @returns A function which unregisters a listener.
      */
     onDestroy(callback) {
-        (typeof ngDevMode === 'undefined' || ngDevMode) && this.warnIfDestroyed();
+        (typeof ngDevMode === 'undefined' || ngDevMode) && warnIfDestroyed(this._destroyed);
         this._destroyListeners.push(callback);
         return () => remove(this._destroyListeners, callback);
     }
@@ -23920,11 +23973,6 @@ class ApplicationRef {
     get viewCount() {
         return this._views.length;
     }
-    warnIfDestroyed() {
-        if ((typeof ngDevMode === 'undefined' || ngDevMode) && this._destroyed) {
-            console.warn(formatRuntimeError(406 /* RuntimeErrorCode.APPLICATION_REF_ALREADY_DESTROYED */, 'This instance of the `ApplicationRef` has already been destroyed.'));
-        }
-    }
     static ɵfac = function ApplicationRef_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || ApplicationRef)(); };
     static ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: ApplicationRef, factory: ApplicationRef.ɵfac, providedIn: 'root' });
 }
@@ -23932,6 +23980,11 @@ class ApplicationRef {
         type: Injectable,
         args: [{ providedIn: 'root' }]
     }], () => [], null); })();
+function warnIfDestroyed(destroyed) {
+    if (destroyed) {
+        console.warn(formatRuntimeError(406 /* RuntimeErrorCode.APPLICATION_REF_ALREADY_DESTROYED */, 'This instance of the `ApplicationRef` has already been destroyed.'));
+    }
+}
 function remove(list, el) {
     const index = list.indexOf(el);
     if (index > -1) {
@@ -24092,7 +24145,7 @@ function triggerResourceLoading(tDetails, lView, tNode) {
             tDetails.loadingState = DeferDependenciesLoadingState.FAILED;
             if (tDetails.errorTmplIndex === null) {
                 const templateLocation = ngDevMode ? getTemplateLocationDetails(lView) : '';
-                const error = new RuntimeError(750 /* RuntimeErrorCode.DEFER_LOADING_FAILED */, ngDevMode &&
+                const error = new RuntimeError(-750 /* RuntimeErrorCode.DEFER_LOADING_FAILED */, ngDevMode &&
                     'Loading dependencies for `@defer` block failed, ' +
                         `but no \`@error\` block was configured${templateLocation}. ` +
                         'Consider using the `@error` block to render an error state.');
@@ -27677,7 +27730,6 @@ function reconcile(liveCollection, newCollection, trackByFn) {
                 'Duplicated keys were: \n' +
                 duplicatedKeysMsg.join(', \n') +
                 '.');
-            // tslint:disable-next-line:no-console
             console.warn(message);
         }
     }
@@ -28505,10 +28557,8 @@ if (typeof ngI18nClosureMode === 'undefined') {
     // Make sure to refer to ngI18nClosureMode as ['ngI18nClosureMode'] for closure.
     // NOTE: we need to have it in IIFE so that the tree-shaker is happy.
     (function () {
-        // tslint:disable-next-line:no-toplevel-property-access
         _global['ngI18nClosureMode'] =
             // TODO(FW-1250): validate that this actually, you know, works.
-            // tslint:disable-next-line:no-toplevel-property-access
             typeof goog !== 'undefined' && typeof goog.getMsg === 'function';
     })();
 }
@@ -33509,8 +33559,9 @@ function recreateMatchingLViews(def, rootLView) {
  */
 function clearRendererCache(factory, def) {
     // Cast to read a private field.
-    // NOTE: This must be kept synchronized with the renderer factory implementation in platform-browser.
-    factory.rendererByCompId?.delete(def.id);
+    // NOTE: This must be kept synchronized with the renderer factory implementation in
+    // platform-browser and platform-browser/animations.
+    factory.componentReplaced?.(def.id);
 }
 /**
  * Recreates an LView in-place from a new component definition.
@@ -34976,7 +35027,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('19.1.0-next.4');
+const VERSION = new Version('19.1.0-rc.0');
 
 /**
  * Combination of NgModuleFactory and ComponentFactories.
@@ -35386,13 +35437,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
@@ -35401,7 +35445,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
@@ -35409,7 +35453,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 */;
@@ -35419,7 +35463,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
@@ -35428,10 +35472,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
@@ -40027,7 +40071,6 @@ function withDomHydration() {
                         'thus hydration was not enabled. ' +
                         'Make sure the `provideClientHydration()` is included into the list ' +
                         'of providers in the server part of the application configuration.');
-                    // tslint:disable-next-line:no-console
                     console.warn(message);
                 }
             },
@@ -40598,23 +40641,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.
  */
@@ -40882,12 +40908,13 @@ 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);
         this.onDestroyFn();
         this.maybeCleanup();
+        this.scheduler.remove(this);
     },
 }))();
 const VIEW_EFFECT_NODE = 
@@ -40896,7 +40923,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);
@@ -40923,7 +40950,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;
 }
 
@@ -41014,10 +41041,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) {
@@ -41076,7 +41103,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;
 }