@angular/cdk 19.1.0-next.3 → 19.1.0-rc.0

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2024 Google LLC.
+Copyright (c) 2025 Google LLC.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/a11y/index.d.ts

@@ -318,8 +318,6 @@ export declare class FocusKeyManager<T> extends ListKeyManager<FocusableOption &
 export declare class FocusMonitor implements OnDestroy {
     private _ngZone;
     private _platform;
-    private _renderer;
-    private _cleanupWindowFocus;
     private readonly _inputModalityDetector;
     /** The focus origin that the next focus event is a result of. */
     private _origin;
@@ -346,7 +344,7 @@ export declare class FocusMonitor implements OnDestroy {
      * handlers differently from the rest of the events, because the browser won't emit events
      * to the document when focus moves inside of a shadow root.
      */
-    private _rootNodeFocusListeners;
+    private _rootNodeFocusListenerCount;
     /**
      * The specified detection mode, used for attributing the origin of a focus
      * event.
@@ -410,6 +408,8 @@ export declare class FocusMonitor implements OnDestroy {
     ngOnDestroy(): void;
     /** Access injected document if available or fallback to global document reference */
     private _getDocument;
+    /** Use defaultView of injected document if available or fallback to global window reference */
+    private _getWindow;
     private _getFocusOrigin;
     /**
      * Returns whether the focus event should be attributed to touch. Recall that in IMMEDIATE mode, a
@@ -788,7 +788,6 @@ export declare type InputModality = 'keyboard' | 'mouse' | 'touch' | null;
  */
 export declare class InputModalityDetector implements OnDestroy {
     private readonly _platform;
-    private readonly _listenerCleanups;
     /** Emits whenever an input modality is detected. */
     readonly modalityDetected: Observable<InputModality>;
     /** Emits when the input modality changes. */

package/drag-drop/index.d.ts

@@ -582,8 +582,6 @@ export declare class DragDropRegistry<_ = unknown, __ = unknown> implements OnDe
     private _ngZone;
     private _document;
     private _styleLoader;
-    private _renderer;
-    private _cleanupDocumentTouchmove;
     /** Registered drop container instances. */
     private _dropInstances;
     /** Registered drag item instances. */
@@ -701,8 +699,6 @@ export declare class DragRef<T = any> {
     private _viewportRuler;
     private _dragDropRegistry;
     private _renderer;
-    private _rootElementCleanups;
-    private _cleanupShadowRootSelectStart;
     /** Element displayed next to the user's pointer while the element is dragged. */
     private _preview;
     /** Container into which to insert the preview. */

package/fesm2022/a11y.mjs

@@ -1,7 +1,7 @@
 import { DOCUMENT } from '@angular/common';
 import * as i0 from '@angular/core';
-import { inject, APP_ID, Injectable, signal, QueryList, isSignal, effect, InjectionToken, afterNextRender, NgZone, Injector, ElementRef, booleanAttribute, Directive, Input, RendererFactory2, EventEmitter, Output, NgModule } from '@angular/core';
-import { Platform, _getFocusedElementPierceShadowDom, _getEventTarget, _bindEventWithOptions, _getShadowRoot } from '@angular/cdk/platform';
+import { inject, APP_ID, Injectable, signal, QueryList, isSignal, effect, InjectionToken, afterNextRender, NgZone, Injector, ElementRef, booleanAttribute, Directive, Input, EventEmitter, Output, NgModule } from '@angular/core';
+import { Platform, _getFocusedElementPierceShadowDom, normalizePassiveListenerOptions, _getEventTarget, _getShadowRoot } from '@angular/cdk/platform';
 import { _CdkPrivateStyleLoader, _VisuallyHiddenLoader } from '@angular/cdk/private';
 import { A, Z, ZERO, NINE, hasModifierKey, PAGE_DOWN, PAGE_UP, END, HOME, LEFT_ARROW, RIGHT_ARROW, UP_ARROW, DOWN_ARROW, TAB, ALT, CONTROL, MAC_META, META, SHIFT } from '@angular/cdk/keycodes';
 import { Subject, Subscription, isObservable, of, BehaviorSubject } from 'rxjs';
@@ -1994,10 +1994,10 @@ const TOUCH_BUFFER_MS = 650;
  * Event listener options that enable capturing and also mark the listener as passive if the browser
  * supports it.
  */
-const modalityEventListenerOptions = {
+const modalityEventListenerOptions = normalizePassiveListenerOptions({
     passive: true,
     capture: true,
-};
+});
 /**
  * Service that detects the user's input modality.
  *
@@ -2014,7 +2014,6 @@ const modalityEventListenerOptions = {
  */
 class InputModalityDetector {
     _platform = inject(Platform);
-    _listenerCleanups;
     /** Emits whenever an input modality is detected. */
     modalityDetected;
     /** Emits when the input modality changes. */
@@ -2097,19 +2096,20 @@ class InputModalityDetector {
         // If we're not in a browser, this service should do nothing, as there's no relevant input
         // modality to detect.
         if (this._platform.isBrowser) {
-            const renderer = inject(RendererFactory2).createRenderer(null, null);
-            this._listenerCleanups = ngZone.runOutsideAngular(() => {
-                return [
-                    _bindEventWithOptions(renderer, document, 'keydown', this._onKeydown, modalityEventListenerOptions),
-                    _bindEventWithOptions(renderer, document, 'mousedown', this._onMousedown, modalityEventListenerOptions),
-                    _bindEventWithOptions(renderer, document, 'touchstart', this._onTouchstart, modalityEventListenerOptions),
-                ];
+            ngZone.runOutsideAngular(() => {
+                document.addEventListener('keydown', this._onKeydown, modalityEventListenerOptions);
+                document.addEventListener('mousedown', this._onMousedown, modalityEventListenerOptions);
+                document.addEventListener('touchstart', this._onTouchstart, modalityEventListenerOptions);
             });
         }
     }
     ngOnDestroy() {
         this._modality.complete();
-        this._listenerCleanups?.forEach(cleanup => cleanup());
+        if (this._platform.isBrowser) {
+            document.removeEventListener('keydown', this._onKeydown, modalityEventListenerOptions);
+            document.removeEventListener('mousedown', this._onMousedown, modalityEventListenerOptions);
+            document.removeEventListener('touchstart', this._onTouchstart, modalityEventListenerOptions);
+        }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.0-next.3", ngImport: i0, type: InputModalityDetector, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.0-next.3", ngImport: i0, type: InputModalityDetector, providedIn: 'root' });
@@ -2343,16 +2343,14 @@ const FOCUS_MONITOR_DEFAULT_OPTIONS = new InjectionToken('cdk-focus-monitor-defa
  * Event listener options that enable capturing and also
  * mark the listener as passive if the browser supports it.
  */
-const captureEventListenerOptions = {
+const captureEventListenerOptions = normalizePassiveListenerOptions({
     passive: true,
     capture: true,
-};
+});
 /** Monitors mouse and keyboard events to determine the cause of focus events. */
 class FocusMonitor {
     _ngZone = inject(NgZone);
     _platform = inject(Platform);
-    _renderer = inject(RendererFactory2).createRenderer(null, null);
-    _cleanupWindowFocus;
     _inputModalityDetector = inject(InputModalityDetector);
     /** The focus origin that the next focus event is a result of. */
     _origin = null;
@@ -2379,7 +2377,7 @@ class FocusMonitor {
      * handlers differently from the rest of the events, because the browser won't emit events
      * to the document when focus moves inside of a shadow root.
      */
-    _rootNodeFocusListeners = new Map();
+    _rootNodeFocusListenerCount = new Map();
     /**
      * The specified detection mode, used for attributing the origin of a focus
      * event.
@@ -2487,6 +2485,11 @@ class FocusMonitor {
     _getDocument() {
         return this._document || document;
     }
+    /** Use defaultView of injected document if available or fallback to global window reference */
+    _getWindow() {
+        const doc = this._getDocument();
+        return doc.defaultView || window;
+    }
     _getFocusOrigin(focusEventTarget) {
         if (this._origin) {
             // If the origin was realized via a touch interaction, we need to perform additional checks
@@ -2623,28 +2626,21 @@ class FocusMonitor {
             return;
         }
         const rootNode = elementInfo.rootNode;
-        const listeners = this._rootNodeFocusListeners.get(rootNode);
-        if (listeners) {
-            listeners.count++;
-        }
-        else {
+        const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode) || 0;
+        if (!rootNodeFocusListeners) {
             this._ngZone.runOutsideAngular(() => {
-                this._rootNodeFocusListeners.set(rootNode, {
-                    count: 1,
-                    cleanups: [
-                        _bindEventWithOptions(this._renderer, rootNode, 'focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions),
-                        _bindEventWithOptions(this._renderer, rootNode, 'blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions),
-                    ],
-                });
+                rootNode.addEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                rootNode.addEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
             });
         }
+        this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners + 1);
         // Register global listeners when first element is monitored.
         if (++this._monitoredElementCount === 1) {
             // Note: we listen to events in the capture phase so we
             // can detect them even if the user stops propagation.
             this._ngZone.runOutsideAngular(() => {
-                this._cleanupWindowFocus?.();
-                this._cleanupWindowFocus = this._renderer.listen('window', 'focus', this._windowFocusListener);
+                const window = this._getWindow();
+                window.addEventListener('focus', this._windowFocusListener);
             });
             // The InputModalityDetector is also just a collection of global listeners.
             this._inputModalityDetector.modalityDetected
@@ -2655,19 +2651,22 @@ class FocusMonitor {
         }
     }
     _removeGlobalListeners(elementInfo) {
-        const listeners = this._rootNodeFocusListeners.get(elementInfo.rootNode);
-        if (listeners) {
-            if (listeners.count > 1) {
-                listeners.count--;
+        const rootNode = elementInfo.rootNode;
+        if (this._rootNodeFocusListenerCount.has(rootNode)) {
+            const rootNodeFocusListeners = this._rootNodeFocusListenerCount.get(rootNode);
+            if (rootNodeFocusListeners > 1) {
+                this._rootNodeFocusListenerCount.set(rootNode, rootNodeFocusListeners - 1);
             }
             else {
-                listeners.cleanups.forEach(cleanup => cleanup());
-                this._rootNodeFocusListeners.delete(elementInfo.rootNode);
+                rootNode.removeEventListener('focus', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                rootNode.removeEventListener('blur', this._rootNodeFocusAndBlurListener, captureEventListenerOptions);
+                this._rootNodeFocusListenerCount.delete(rootNode);
             }
         }
         // Unregister global listeners when last element is unmonitored.
         if (!--this._monitoredElementCount) {
-            this._cleanupWindowFocus?.();
+            const window = this._getWindow();
+            window.removeEventListener('focus', this._windowFocusListener);
             // Equivalently, stop our InputModalityDetector subscription.
             this._stopInputModalityDetector.next();
             // Clear timeouts for all potentially pending timeouts to prevent the leaks.