@angular/core 19.2.7 → 19.2.9

package/event_dispatcher.d-DlbccpYq.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.2.7
+ * @license Angular v19.2.9
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.2.7
+ * @license Angular v19.2.9
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -1666,6 +1666,8 @@ function isStandalone(type) {
 /**
  * Wrap an array of `Provider`s into `EnvironmentProviders`, preventing them from being accidentally
  * referenced in `@Component` in a component injector.
+ *
+ * @publicApi
  */
 function makeEnvironmentProviders(providers) {
     return {
@@ -5900,8 +5902,26 @@ class NodeInjectorDestroyRef extends DestroyRef {
         this._lView = _lView;
     }
     onDestroy(callback) {
-        storeLViewOnDestroy(this._lView, callback);
-        return () => removeLViewOnDestroy(this._lView, callback);
+        const lView = this._lView;
+        // Checking if `lView` is already destroyed before storing the `callback` enhances
+        // safety and integrity for applications.
+        // If `lView` is destroyed, we call the `callback` immediately to ensure that
+        // any necessary cleanup is handled gracefully.
+        // With this approach, we're providing better reliability in managing resources.
+        // One of the use cases is `takeUntilDestroyed`, which aims to replace `takeUntil`
+        // in existing applications. While `takeUntil` can be safely called once the view
+        // is destroyed — resulting in no errors and finalizing the subscription depending
+        // on whether a subject or replay subject is used, replacing it with
+        // `takeUntilDestroyed` introduces a breaking change, as it throws an error if
+        // the `lView` is destroyed (https://github.com/angular/angular/issues/54527).
+        if (isDestroyed(lView)) {
+            callback();
+            // We return a "noop" callback, which, when executed, does nothing because
+            // we haven't stored anything on the `lView`, and thus there's nothing to remove.
+            return () => { };
+        }
+        storeLViewOnDestroy(lView, callback);
+        return () => removeLViewOnDestroy(lView, callback);
     }
 }
 function injectDestroyRef() {
@@ -6095,9 +6115,13 @@ class EventEmitter_ extends Subject {
         return (value) => {
             const taskId = this.pendingTasks?.add();
             setTimeout(() => {
-                fn(value);
-                if (taskId !== undefined) {
-                    this.pendingTasks?.remove(taskId);
+                try {
+                    fn(value);
+                }
+                finally {
+                    if (taskId !== undefined) {
+                        this.pendingTasks?.remove(taskId);
+                    }
                 }
             });
         };
@@ -6915,12 +6939,13 @@ function createElementRef(tNode, lView) {
 // and could do better codegen in the future.
 class ElementRef {
     /**
-     * <div class="callout is-critical">
+     * <div class="docs-alert docs-alert-important">
      *   <header>Use with caution</header>
      *   <p>
      *    Use this API as the last resort when direct access to DOM is needed. Use templating and
-     *    data-binding provided by Angular instead. Alternatively you can take a look at
-     *    {@link Renderer2} which provides an API that can be safely used.
+     *    data-binding provided by Angular instead. If used, it is recommended in combination with
+     *    {@link /best-practices/security#direct-use-of-the-dom-apis-and-explicit-sanitization-calls DomSanitizer}
+     *    for maxiumum security;
      *   </p>
      * </div>
      */
@@ -16847,6 +16872,14 @@ class RendererFactory2 {
  * renders a template into DOM. You can use custom rendering to intercept
  * rendering calls, or to render to something other than DOM.
  *
+ * <div class="docs-alert docs-alert-important">
+ * <p>
+ * Please be aware that usage of `Renderer2`, in context of accessing DOM elements, provides no
+ * extra security which makes it equivalent to
+ * {@link /best-practices/security#direct-use-of-the-dom-apis-and-explicit-sanitization-calls Security vulnerabilities}.
+ * </p>
+ * </div>
+ *
  * Create your custom renderer using `RendererFactory2`.
  *
  * Use a custom renderer to bypass Angular's templating and
@@ -17911,7 +17944,7 @@ class ComponentFactory extends ComponentFactory$1 {
             const cmpDef = this.componentDef;
             ngDevMode && verifyNotAnOrphanComponent(cmpDef);
             const tAttributes = rootSelectorOrNode
-                ? ['ng-version', '19.2.7']
+                ? ['ng-version', '19.2.9']
                 : // 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.
@@ -30106,15 +30139,12 @@ function isOutputSubscribable(value) {
     return (value != null && typeof value.subscribe === 'function');
 }
 
-/**
- * Contains a reference to a function that disables event replay feature
- * for server-side rendered applications. This function is overridden with
- * an actual implementation when the event replay feature is enabled via
- * `withEventReplay()` call.
- */
-let stashEventListener = (el, eventName, listenerFn) => { };
-function setStashFn(fn) {
-    stashEventListener = fn;
+const stashEventListeners = new Map();
+function setStashFn(appId, fn) {
+    stashEventListeners.set(appId, fn);
+}
+function clearStashFn(appId) {
+    stashEventListeners.delete(appId);
 }
 /**
  * Adds an event listener to the current node.
@@ -30253,7 +30283,9 @@ function listenerInternal(tView, lView, renderer, tNode, eventName, listenerFn,
         }
         else {
             listenerFn = wrapListener(tNode, lView, listenerFn);
-            stashEventListener(target, eventName, listenerFn);
+            const appId = lView[INJECTOR].get(APP_ID);
+            const stashEventListener = stashEventListeners.get(appId);
+            stashEventListener?.(target, eventName, listenerFn);
             const cleanupFn = renderer.listen(target, eventName, listenerFn);
             ngDevMode && ngDevMode.rendererAddEventListener++;
             lCleanup.push(listenerFn, cleanupFn);
@@ -34651,7 +34683,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('19.2.7');
+const VERSION = new Version('19.2.9');
 
 /**
  * Combination of NgModuleFactory and ComponentFactories.
@@ -38154,7 +38186,8 @@ function withEventReplay() {
                 if (!appsWithEventReplay.has(appRef)) {
                     const jsActionMap = inject(JSACTION_BLOCK_ELEMENT_MAP);
                     if (shouldEnableEventReplay(injector)) {
-                        setStashFn((rEl, eventName, listenerFn) => {
+                        const appId = injector.get(APP_ID);
+                        setStashFn(appId, (rEl, eventName, listenerFn) => {
                             // If a user binds to a ng-container and uses a directive that binds using a host listener,
                             // this element could be a comment node. So we need to ensure we have an actual element
                             // node before stashing anything.
@@ -38170,7 +38203,6 @@ function withEventReplay() {
         }, {
             provide: APP_BOOTSTRAP_LISTENER,
             useFactory: () => {
-                const appId = inject(APP_ID);
                 const appRef = inject(ApplicationRef);
                 const { injector } = appRef;
                 return () => {
@@ -38185,6 +38217,7 @@ function withEventReplay() {
                         appsWithEventReplay.delete(appRef);
                         // Ensure that we're always safe calling this in the browser.
                         if (typeof ngServerMode !== 'undefined' && !ngServerMode) {
+                            const appId = injector.get(APP_ID);
                             // `_ejsa` should be deleted when the app is destroyed, ensuring that
                             // no elements are still captured in the global list and are not prevented
                             // from being garbage collected.
@@ -38192,7 +38225,7 @@ function withEventReplay() {
                             // Clean up the reference to the function set by the environment initializer,
                             // as the function closure may capture injected elements and prevent them
                             // from being properly garbage collected.
-                            setStashFn(() => { });
+                            clearStashFn(appId);
                         }
                     });
                     // Kick off event replay logic once hydration for the initial part
@@ -39585,14 +39618,6 @@ function effect(effectFn, options) {
     }
     return effectRef;
 }
-/**
- * Not public API, which guarantees `EffectScheduler` only ever comes from the application root
- * injector.
- */
-/* @__PURE__ */ new InjectionToken('', {
-    providedIn: 'root',
-    factory: () => inject(EffectScheduler),
-});
 const BASE_EFFECT_NODE = 
 /* @__PURE__ */ (() => ({
     ...REACTIVE_NODE,
@@ -40196,8 +40221,8 @@ function ɵɵngDeclarePipe(decl) {
     return compiler.compilePipeDeclaration(angularCoreEnv, `ng:///${decl.type.name}/ɵpipe.js`, decl);
 }
 
-const NOT_SET = Symbol('NOT_SET');
-const EMPTY_CLEANUP_SET = new Set();
+const NOT_SET = /* @__PURE__ */ Symbol('NOT_SET');
+const EMPTY_CLEANUP_SET = /* @__PURE__ */ new Set();
 const AFTER_RENDER_PHASE_EFFECT_NODE = /* @__PURE__ */ (() => ({
     ...SIGNAL_NODE,
     consumerIsAlwaysLive: true,