@kato-lee/cdk 14.2.7

package/esm2020/a11y/focus-trap/focus-trap.mjs

@@ -0,0 +1,402 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { coerceBooleanProperty } from '@kato-lee/cdk/coercion';
+import { _getFocusedElementPierceShadowDom } from '@kato-lee/cdk/platform';
+import { DOCUMENT } from '@angular/common';
+import { Directive, ElementRef, Inject, Injectable, Input, NgZone, } from '@angular/core';
+import { take } from 'rxjs/operators';
+import { InteractivityChecker } from '../interactivity-checker/interactivity-checker';
+import * as i0 from "@angular/core";
+import * as i1 from "../interactivity-checker/interactivity-checker";
+/**
+ * Class that allows for trapping focus within a DOM element.
+ *
+ * This class currently uses a relatively simple approach to focus trapping.
+ * It assumes that the tab order is the same as DOM order, which is not necessarily true.
+ * Things like `tabIndex > 0`, flex `order`, and shadow roots can cause the two to be misaligned.
+ *
+ * @deprecated Use `ConfigurableFocusTrap` instead.
+ * @breaking-change 11.0.0
+ */
+export class FocusTrap {
+    constructor(_element, _checker, _ngZone, _document, deferAnchors = false) {
+        this._element = _element;
+        this._checker = _checker;
+        this._ngZone = _ngZone;
+        this._document = _document;
+        this._hasAttached = false;
+        // Event listeners for the anchors. Need to be regular functions so that we can unbind them later.
+        this.startAnchorListener = () => this.focusLastTabbableElement();
+        this.endAnchorListener = () => this.focusFirstTabbableElement();
+        this._enabled = true;
+        if (!deferAnchors) {
+            this.attachAnchors();
+        }
+    }
+    /** Whether the focus trap is active. */
+    get enabled() {
+        return this._enabled;
+    }
+    set enabled(value) {
+        this._enabled = value;
+        if (this._startAnchor && this._endAnchor) {
+            this._toggleAnchorTabIndex(value, this._startAnchor);
+            this._toggleAnchorTabIndex(value, this._endAnchor);
+        }
+    }
+    /** Destroys the focus trap by cleaning up the anchors. */
+    destroy() {
+        const startAnchor = this._startAnchor;
+        const endAnchor = this._endAnchor;
+        if (startAnchor) {
+            startAnchor.removeEventListener('focus', this.startAnchorListener);
+            startAnchor.remove();
+        }
+        if (endAnchor) {
+            endAnchor.removeEventListener('focus', this.endAnchorListener);
+            endAnchor.remove();
+        }
+        this._startAnchor = this._endAnchor = null;
+        this._hasAttached = false;
+    }
+    /**
+     * Inserts the anchors into the DOM. This is usually done automatically
+     * in the constructor, but can be deferred for cases like directives with `*ngIf`.
+     * @returns Whether the focus trap managed to attach successfully. This may not be the case
+     * if the target element isn't currently in the DOM.
+     */
+    attachAnchors() {
+        // If we're not on the browser, there can be no focus to trap.
+        if (this._hasAttached) {
+            return true;
+        }
+        this._ngZone.runOutsideAngular(() => {
+            if (!this._startAnchor) {
+                this._startAnchor = this._createAnchor();
+                this._startAnchor.addEventListener('focus', this.startAnchorListener);
+            }
+            if (!this._endAnchor) {
+                this._endAnchor = this._createAnchor();
+                this._endAnchor.addEventListener('focus', this.endAnchorListener);
+            }
+        });
+        if (this._element.parentNode) {
+            this._element.parentNode.insertBefore(this._startAnchor, this._element);
+            this._element.parentNode.insertBefore(this._endAnchor, this._element.nextSibling);
+            this._hasAttached = true;
+        }
+        return this._hasAttached;
+    }
+    /**
+     * Waits for the zone to stabilize, then focuses the first tabbable element.
+     * @returns Returns a promise that resolves with a boolean, depending
+     * on whether focus was moved successfully.
+     */
+    focusInitialElementWhenReady(options) {
+        return new Promise(resolve => {
+            this._executeOnStable(() => resolve(this.focusInitialElement(options)));
+        });
+    }
+    /**
+     * Waits for the zone to stabilize, then focuses
+     * the first tabbable element within the focus trap region.
+     * @returns Returns a promise that resolves with a boolean, depending
+     * on whether focus was moved successfully.
+     */
+    focusFirstTabbableElementWhenReady(options) {
+        return new Promise(resolve => {
+            this._executeOnStable(() => resolve(this.focusFirstTabbableElement(options)));
+        });
+    }
+    /**
+     * Waits for the zone to stabilize, then focuses
+     * the last tabbable element within the focus trap region.
+     * @returns Returns a promise that resolves with a boolean, depending
+     * on whether focus was moved successfully.
+     */
+    focusLastTabbableElementWhenReady(options) {
+        return new Promise(resolve => {
+            this._executeOnStable(() => resolve(this.focusLastTabbableElement(options)));
+        });
+    }
+    /**
+     * Get the specified boundary element of the trapped region.
+     * @param bound The boundary to get (start or end of trapped region).
+     * @returns The boundary element.
+     */
+    _getRegionBoundary(bound) {
+        // Contains the deprecated version of selector, for temporary backwards comparability.
+        const markers = this._element.querySelectorAll(`[cdk-focus-region-${bound}], ` + `[cdkFocusRegion${bound}], ` + `[cdk-focus-${bound}]`);
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            for (let i = 0; i < markers.length; i++) {
+                // @breaking-change 8.0.0
+                if (markers[i].hasAttribute(`cdk-focus-${bound}`)) {
+                    console.warn(`Found use of deprecated attribute 'cdk-focus-${bound}', ` +
+                        `use 'cdkFocusRegion${bound}' instead. The deprecated ` +
+                        `attribute will be removed in 8.0.0.`, markers[i]);
+                }
+                else if (markers[i].hasAttribute(`cdk-focus-region-${bound}`)) {
+                    console.warn(`Found use of deprecated attribute 'cdk-focus-region-${bound}', ` +
+                        `use 'cdkFocusRegion${bound}' instead. The deprecated attribute ` +
+                        `will be removed in 8.0.0.`, markers[i]);
+                }
+            }
+        }
+        if (bound == 'start') {
+            return markers.length ? markers[0] : this._getFirstTabbableElement(this._element);
+        }
+        return markers.length
+            ? markers[markers.length - 1]
+            : this._getLastTabbableElement(this._element);
+    }
+    /**
+     * Focuses the element that should be focused when the focus trap is initialized.
+     * @returns Whether focus was moved successfully.
+     */
+    focusInitialElement(options) {
+        // Contains the deprecated version of selector, for temporary backwards comparability.
+        const redirectToElement = this._element.querySelector(`[cdk-focus-initial], ` + `[cdkFocusInitial]`);
+        if (redirectToElement) {
+            // @breaking-change 8.0.0
+            if ((typeof ngDevMode === 'undefined' || ngDevMode) &&
+                redirectToElement.hasAttribute(`cdk-focus-initial`)) {
+                console.warn(`Found use of deprecated attribute 'cdk-focus-initial', ` +
+                    `use 'cdkFocusInitial' instead. The deprecated attribute ` +
+                    `will be removed in 8.0.0`, redirectToElement);
+            }
+            // Warn the consumer if the element they've pointed to
+            // isn't focusable, when not in production mode.
+            if ((typeof ngDevMode === 'undefined' || ngDevMode) &&
+                !this._checker.isFocusable(redirectToElement)) {
+                console.warn(`Element matching '[cdkFocusInitial]' is not focusable.`, redirectToElement);
+            }
+            if (!this._checker.isFocusable(redirectToElement)) {
+                const focusableChild = this._getFirstTabbableElement(redirectToElement);
+                focusableChild?.focus(options);
+                return !!focusableChild;
+            }
+            redirectToElement.focus(options);
+            return true;
+        }
+        return this.focusFirstTabbableElement(options);
+    }
+    /**
+     * Focuses the first tabbable element within the focus trap region.
+     * @returns Whether focus was moved successfully.
+     */
+    focusFirstTabbableElement(options) {
+        const redirectToElement = this._getRegionBoundary('start');
+        if (redirectToElement) {
+            redirectToElement.focus(options);
+        }
+        return !!redirectToElement;
+    }
+    /**
+     * Focuses the last tabbable element within the focus trap region.
+     * @returns Whether focus was moved successfully.
+     */
+    focusLastTabbableElement(options) {
+        const redirectToElement = this._getRegionBoundary('end');
+        if (redirectToElement) {
+            redirectToElement.focus(options);
+        }
+        return !!redirectToElement;
+    }
+    /**
+     * Checks whether the focus trap has successfully been attached.
+     */
+    hasAttached() {
+        return this._hasAttached;
+    }
+    /** Get the first tabbable element from a DOM subtree (inclusive). */
+    _getFirstTabbableElement(root) {
+        if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {
+            return root;
+        }
+        const children = root.children;
+        for (let i = 0; i < children.length; i++) {
+            const tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE
+                ? this._getFirstTabbableElement(children[i])
+                : null;
+            if (tabbableChild) {
+                return tabbableChild;
+            }
+        }
+        return null;
+    }
+    /** Get the last tabbable element from a DOM subtree (inclusive). */
+    _getLastTabbableElement(root) {
+        if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {
+            return root;
+        }
+        // Iterate in reverse DOM order.
+        const children = root.children;
+        for (let i = children.length - 1; i >= 0; i--) {
+            const tabbableChild = children[i].nodeType === this._document.ELEMENT_NODE
+                ? this._getLastTabbableElement(children[i])
+                : null;
+            if (tabbableChild) {
+                return tabbableChild;
+            }
+        }
+        return null;
+    }
+    /** Creates an anchor element. */
+    _createAnchor() {
+        const anchor = this._document.createElement('div');
+        this._toggleAnchorTabIndex(this._enabled, anchor);
+        anchor.classList.add('cdk-visually-hidden');
+        anchor.classList.add('cdk-focus-trap-anchor');
+        anchor.setAttribute('aria-hidden', 'true');
+        return anchor;
+    }
+    /**
+     * Toggles the `tabindex` of an anchor, based on the enabled state of the focus trap.
+     * @param isEnabled Whether the focus trap is enabled.
+     * @param anchor Anchor on which to toggle the tabindex.
+     */
+    _toggleAnchorTabIndex(isEnabled, anchor) {
+        // Remove the tabindex completely, rather than setting it to -1, because if the
+        // element has a tabindex, the user might still hit it when navigating with the arrow keys.
+        isEnabled ? anchor.setAttribute('tabindex', '0') : anchor.removeAttribute('tabindex');
+    }
+    /**
+     * Toggles the`tabindex` of both anchors to either trap Tab focus or allow it to escape.
+     * @param enabled: Whether the anchors should trap Tab.
+     */
+    toggleAnchors(enabled) {
+        if (this._startAnchor && this._endAnchor) {
+            this._toggleAnchorTabIndex(enabled, this._startAnchor);
+            this._toggleAnchorTabIndex(enabled, this._endAnchor);
+        }
+    }
+    /** Executes a function when the zone is stable. */
+    _executeOnStable(fn) {
+        if (this._ngZone.isStable) {
+            fn();
+        }
+        else {
+            this._ngZone.onStable.pipe(take(1)).subscribe(fn);
+        }
+    }
+}
+/**
+ * Factory that allows easy instantiation of focus traps.
+ * @deprecated Use `ConfigurableFocusTrapFactory` instead.
+ * @breaking-change 11.0.0
+ */
+export class FocusTrapFactory {
+    constructor(_checker, _ngZone, _document) {
+        this._checker = _checker;
+        this._ngZone = _ngZone;
+        this._document = _document;
+    }
+    /**
+     * Creates a focus-trapped region around the given element.
+     * @param element The element around which focus will be trapped.
+     * @param deferCaptureElements Defers the creation of focus-capturing elements to be done
+     *     manually by the user.
+     * @returns The created focus trap instance.
+     */
+    create(element, deferCaptureElements = false) {
+        return new FocusTrap(element, this._checker, this._ngZone, this._document, deferCaptureElements);
+    }
+}
+FocusTrapFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: FocusTrapFactory, deps: [{ token: i1.InteractivityChecker }, { token: i0.NgZone }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+FocusTrapFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: FocusTrapFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: FocusTrapFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.InteractivityChecker }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+/** Directive for trapping focus within a region. */
+export class CdkTrapFocus {
+    constructor(_elementRef, _focusTrapFactory,
+    /**
+     * @deprecated No longer being used. To be removed.
+     * @breaking-change 13.0.0
+     */
+    _document) {
+        this._elementRef = _elementRef;
+        this._focusTrapFactory = _focusTrapFactory;
+        /** Previously focused element to restore focus to upon destroy when using autoCapture. */
+        this._previouslyFocusedElement = null;
+        this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);
+    }
+    /** Whether the focus trap is active. */
+    get enabled() {
+        return this.focusTrap.enabled;
+    }
+    set enabled(value) {
+        this.focusTrap.enabled = coerceBooleanProperty(value);
+    }
+    /**
+     * Whether the directive should automatically move focus into the trapped region upon
+     * initialization and return focus to the previous activeElement upon destruction.
+     */
+    get autoCapture() {
+        return this._autoCapture;
+    }
+    set autoCapture(value) {
+        this._autoCapture = coerceBooleanProperty(value);
+    }
+    ngOnDestroy() {
+        this.focusTrap.destroy();
+        // If we stored a previously focused element when using autoCapture, return focus to that
+        // element now that the trapped region is being destroyed.
+        if (this._previouslyFocusedElement) {
+            this._previouslyFocusedElement.focus();
+            this._previouslyFocusedElement = null;
+        }
+    }
+    ngAfterContentInit() {
+        this.focusTrap.attachAnchors();
+        if (this.autoCapture) {
+            this._captureFocus();
+        }
+    }
+    ngDoCheck() {
+        if (!this.focusTrap.hasAttached()) {
+            this.focusTrap.attachAnchors();
+        }
+    }
+    ngOnChanges(changes) {
+        const autoCaptureChange = changes['autoCapture'];
+        if (autoCaptureChange &&
+            !autoCaptureChange.firstChange &&
+            this.autoCapture &&
+            this.focusTrap.hasAttached()) {
+            this._captureFocus();
+        }
+    }
+    _captureFocus() {
+        this._previouslyFocusedElement = _getFocusedElementPierceShadowDom();
+        this.focusTrap.focusInitialElementWhenReady();
+    }
+}
+CdkTrapFocus.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkTrapFocus, deps: [{ token: i0.ElementRef }, { token: FocusTrapFactory }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });
+CdkTrapFocus.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.0", type: CdkTrapFocus, selector: "[cdkTrapFocus]", inputs: { enabled: ["cdkTrapFocus", "enabled"], autoCapture: ["cdkTrapFocusAutoCapture", "autoCapture"] }, exportAs: ["cdkTrapFocus"], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: CdkTrapFocus, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkTrapFocus]',
+                    exportAs: 'cdkTrapFocus',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: FocusTrapFactory }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { enabled: [{
+                type: Input,
+                args: ['cdkTrapFocus']
+            }], autoCapture: [{
+                type: Input,
+                args: ['cdkTrapFocusAutoCapture']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"focus-trap.js","sourceRoot":"","sources":["../../../../../../../src/cdk/a11y/focus-trap/focus-trap.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {BooleanInput, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {_getFocusedElementPierceShadowDom} from '@angular/cdk/platform';\nimport {DOCUMENT} from '@angular/common';\nimport {\n  AfterContentInit,\n  Directive,\n  ElementRef,\n  Inject,\n  Injectable,\n  Input,\n  NgZone,\n  OnDestroy,\n  DoCheck,\n  SimpleChanges,\n  OnChanges,\n} from '@angular/core';\nimport {take} from 'rxjs/operators';\nimport {InteractivityChecker} from '../interactivity-checker/interactivity-checker';\n\n/**\n * Class that allows for trapping focus within a DOM element.\n *\n * This class currently uses a relatively simple approach to focus trapping.\n * It assumes that the tab order is the same as DOM order, which is not necessarily true.\n * Things like `tabIndex > 0`, flex `order`, and shadow roots can cause the two to be misaligned.\n *\n * @deprecated Use `ConfigurableFocusTrap` instead.\n * @breaking-change 11.0.0\n */\nexport class FocusTrap {\n  private _startAnchor: HTMLElement | null;\n  private _endAnchor: HTMLElement | null;\n  private _hasAttached = false;\n\n  // Event listeners for the anchors. Need to be regular functions so that we can unbind them later.\n  protected startAnchorListener = () => this.focusLastTabbableElement();\n  protected endAnchorListener = () => this.focusFirstTabbableElement();\n\n  /** Whether the focus trap is active. */\n  get enabled(): boolean {\n    return this._enabled;\n  }\n  set enabled(value: boolean) {\n    this._enabled = value;\n\n    if (this._startAnchor && this._endAnchor) {\n      this._toggleAnchorTabIndex(value, this._startAnchor);\n      this._toggleAnchorTabIndex(value, this._endAnchor);\n    }\n  }\n  protected _enabled: boolean = true;\n\n  constructor(\n    readonly _element: HTMLElement,\n    private _checker: InteractivityChecker,\n    readonly _ngZone: NgZone,\n    readonly _document: Document,\n    deferAnchors = false,\n  ) {\n    if (!deferAnchors) {\n      this.attachAnchors();\n    }\n  }\n\n  /** Destroys the focus trap by cleaning up the anchors. */\n  destroy() {\n    const startAnchor = this._startAnchor;\n    const endAnchor = this._endAnchor;\n\n    if (startAnchor) {\n      startAnchor.removeEventListener('focus', this.startAnchorListener);\n      startAnchor.remove();\n    }\n\n    if (endAnchor) {\n      endAnchor.removeEventListener('focus', this.endAnchorListener);\n      endAnchor.remove();\n    }\n\n    this._startAnchor = this._endAnchor = null;\n    this._hasAttached = false;\n  }\n\n  /**\n   * Inserts the anchors into the DOM. This is usually done automatically\n   * in the constructor, but can be deferred for cases like directives with `*ngIf`.\n   * @returns Whether the focus trap managed to attach successfully. This may not be the case\n   * if the target element isn't currently in the DOM.\n   */\n  attachAnchors(): boolean {\n    // If we're not on the browser, there can be no focus to trap.\n    if (this._hasAttached) {\n      return true;\n    }\n\n    this._ngZone.runOutsideAngular(() => {\n      if (!this._startAnchor) {\n        this._startAnchor = this._createAnchor();\n        this._startAnchor!.addEventListener('focus', this.startAnchorListener);\n      }\n\n      if (!this._endAnchor) {\n        this._endAnchor = this._createAnchor();\n        this._endAnchor!.addEventListener('focus', this.endAnchorListener);\n      }\n    });\n\n    if (this._element.parentNode) {\n      this._element.parentNode.insertBefore(this._startAnchor!, this._element);\n      this._element.parentNode.insertBefore(this._endAnchor!, this._element.nextSibling);\n      this._hasAttached = true;\n    }\n\n    return this._hasAttached;\n  }\n\n  /**\n   * Waits for the zone to stabilize, then focuses the first tabbable element.\n   * @returns Returns a promise that resolves with a boolean, depending\n   * on whether focus was moved successfully.\n   */\n  focusInitialElementWhenReady(options?: FocusOptions): Promise<boolean> {\n    return new Promise<boolean>(resolve => {\n      this._executeOnStable(() => resolve(this.focusInitialElement(options)));\n    });\n  }\n\n  /**\n   * Waits for the zone to stabilize, then focuses\n   * the first tabbable element within the focus trap region.\n   * @returns Returns a promise that resolves with a boolean, depending\n   * on whether focus was moved successfully.\n   */\n  focusFirstTabbableElementWhenReady(options?: FocusOptions): Promise<boolean> {\n    return new Promise<boolean>(resolve => {\n      this._executeOnStable(() => resolve(this.focusFirstTabbableElement(options)));\n    });\n  }\n\n  /**\n   * Waits for the zone to stabilize, then focuses\n   * the last tabbable element within the focus trap region.\n   * @returns Returns a promise that resolves with a boolean, depending\n   * on whether focus was moved successfully.\n   */\n  focusLastTabbableElementWhenReady(options?: FocusOptions): Promise<boolean> {\n    return new Promise<boolean>(resolve => {\n      this._executeOnStable(() => resolve(this.focusLastTabbableElement(options)));\n    });\n  }\n\n  /**\n   * Get the specified boundary element of the trapped region.\n   * @param bound The boundary to get (start or end of trapped region).\n   * @returns The boundary element.\n   */\n  private _getRegionBoundary(bound: 'start' | 'end'): HTMLElement | null {\n    // Contains the deprecated version of selector, for temporary backwards comparability.\n    const markers = this._element.querySelectorAll(\n      `[cdk-focus-region-${bound}], ` + `[cdkFocusRegion${bound}], ` + `[cdk-focus-${bound}]`,\n    ) as NodeListOf<HTMLElement>;\n\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      for (let i = 0; i < markers.length; i++) {\n        // @breaking-change 8.0.0\n        if (markers[i].hasAttribute(`cdk-focus-${bound}`)) {\n          console.warn(\n            `Found use of deprecated attribute 'cdk-focus-${bound}', ` +\n              `use 'cdkFocusRegion${bound}' instead. The deprecated ` +\n              `attribute will be removed in 8.0.0.`,\n            markers[i],\n          );\n        } else if (markers[i].hasAttribute(`cdk-focus-region-${bound}`)) {\n          console.warn(\n            `Found use of deprecated attribute 'cdk-focus-region-${bound}', ` +\n              `use 'cdkFocusRegion${bound}' instead. The deprecated attribute ` +\n              `will be removed in 8.0.0.`,\n            markers[i],\n          );\n        }\n      }\n    }\n\n    if (bound == 'start') {\n      return markers.length ? markers[0] : this._getFirstTabbableElement(this._element);\n    }\n    return markers.length\n      ? markers[markers.length - 1]\n      : this._getLastTabbableElement(this._element);\n  }\n\n  /**\n   * Focuses the element that should be focused when the focus trap is initialized.\n   * @returns Whether focus was moved successfully.\n   */\n  focusInitialElement(options?: FocusOptions): boolean {\n    // Contains the deprecated version of selector, for temporary backwards comparability.\n    const redirectToElement = this._element.querySelector(\n      `[cdk-focus-initial], ` + `[cdkFocusInitial]`,\n    ) as HTMLElement;\n\n    if (redirectToElement) {\n      // @breaking-change 8.0.0\n      if (\n        (typeof ngDevMode === 'undefined' || ngDevMode) &&\n        redirectToElement.hasAttribute(`cdk-focus-initial`)\n      ) {\n        console.warn(\n          `Found use of deprecated attribute 'cdk-focus-initial', ` +\n            `use 'cdkFocusInitial' instead. The deprecated attribute ` +\n            `will be removed in 8.0.0`,\n          redirectToElement,\n        );\n      }\n\n      // Warn the consumer if the element they've pointed to\n      // isn't focusable, when not in production mode.\n      if (\n        (typeof ngDevMode === 'undefined' || ngDevMode) &&\n        !this._checker.isFocusable(redirectToElement)\n      ) {\n        console.warn(`Element matching '[cdkFocusInitial]' is not focusable.`, redirectToElement);\n      }\n\n      if (!this._checker.isFocusable(redirectToElement)) {\n        const focusableChild = this._getFirstTabbableElement(redirectToElement) as HTMLElement;\n        focusableChild?.focus(options);\n        return !!focusableChild;\n      }\n\n      redirectToElement.focus(options);\n      return true;\n    }\n\n    return this.focusFirstTabbableElement(options);\n  }\n\n  /**\n   * Focuses the first tabbable element within the focus trap region.\n   * @returns Whether focus was moved successfully.\n   */\n  focusFirstTabbableElement(options?: FocusOptions): boolean {\n    const redirectToElement = this._getRegionBoundary('start');\n\n    if (redirectToElement) {\n      redirectToElement.focus(options);\n    }\n\n    return !!redirectToElement;\n  }\n\n  /**\n   * Focuses the last tabbable element within the focus trap region.\n   * @returns Whether focus was moved successfully.\n   */\n  focusLastTabbableElement(options?: FocusOptions): boolean {\n    const redirectToElement = this._getRegionBoundary('end');\n\n    if (redirectToElement) {\n      redirectToElement.focus(options);\n    }\n\n    return !!redirectToElement;\n  }\n\n  /**\n   * Checks whether the focus trap has successfully been attached.\n   */\n  hasAttached(): boolean {\n    return this._hasAttached;\n  }\n\n  /** Get the first tabbable element from a DOM subtree (inclusive). */\n  private _getFirstTabbableElement(root: HTMLElement): HTMLElement | null {\n    if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {\n      return root;\n    }\n\n    const children = root.children;\n\n    for (let i = 0; i < children.length; i++) {\n      const tabbableChild =\n        children[i].nodeType === this._document.ELEMENT_NODE\n          ? this._getFirstTabbableElement(children[i] as HTMLElement)\n          : null;\n\n      if (tabbableChild) {\n        return tabbableChild;\n      }\n    }\n\n    return null;\n  }\n\n  /** Get the last tabbable element from a DOM subtree (inclusive). */\n  private _getLastTabbableElement(root: HTMLElement): HTMLElement | null {\n    if (this._checker.isFocusable(root) && this._checker.isTabbable(root)) {\n      return root;\n    }\n\n    // Iterate in reverse DOM order.\n    const children = root.children;\n\n    for (let i = children.length - 1; i >= 0; i--) {\n      const tabbableChild =\n        children[i].nodeType === this._document.ELEMENT_NODE\n          ? this._getLastTabbableElement(children[i] as HTMLElement)\n          : null;\n\n      if (tabbableChild) {\n        return tabbableChild;\n      }\n    }\n\n    return null;\n  }\n\n  /** Creates an anchor element. */\n  private _createAnchor(): HTMLElement {\n    const anchor = this._document.createElement('div');\n    this._toggleAnchorTabIndex(this._enabled, anchor);\n    anchor.classList.add('cdk-visually-hidden');\n    anchor.classList.add('cdk-focus-trap-anchor');\n    anchor.setAttribute('aria-hidden', 'true');\n    return anchor;\n  }\n\n  /**\n   * Toggles the `tabindex` of an anchor, based on the enabled state of the focus trap.\n   * @param isEnabled Whether the focus trap is enabled.\n   * @param anchor Anchor on which to toggle the tabindex.\n   */\n  private _toggleAnchorTabIndex(isEnabled: boolean, anchor: HTMLElement) {\n    // Remove the tabindex completely, rather than setting it to -1, because if the\n    // element has a tabindex, the user might still hit it when navigating with the arrow keys.\n    isEnabled ? anchor.setAttribute('tabindex', '0') : anchor.removeAttribute('tabindex');\n  }\n\n  /**\n   * Toggles the`tabindex` of both anchors to either trap Tab focus or allow it to escape.\n   * @param enabled: Whether the anchors should trap Tab.\n   */\n  protected toggleAnchors(enabled: boolean) {\n    if (this._startAnchor && this._endAnchor) {\n      this._toggleAnchorTabIndex(enabled, this._startAnchor);\n      this._toggleAnchorTabIndex(enabled, this._endAnchor);\n    }\n  }\n\n  /** Executes a function when the zone is stable. */\n  private _executeOnStable(fn: () => any): void {\n    if (this._ngZone.isStable) {\n      fn();\n    } else {\n      this._ngZone.onStable.pipe(take(1)).subscribe(fn);\n    }\n  }\n}\n\n/**\n * Factory that allows easy instantiation of focus traps.\n * @deprecated Use `ConfigurableFocusTrapFactory` instead.\n * @breaking-change 11.0.0\n */\n@Injectable({providedIn: 'root'})\nexport class FocusTrapFactory {\n  private _document: Document;\n\n  constructor(\n    private _checker: InteractivityChecker,\n    private _ngZone: NgZone,\n    @Inject(DOCUMENT) _document: any,\n  ) {\n    this._document = _document;\n  }\n\n  /**\n   * Creates a focus-trapped region around the given element.\n   * @param element The element around which focus will be trapped.\n   * @param deferCaptureElements Defers the creation of focus-capturing elements to be done\n   *     manually by the user.\n   * @returns The created focus trap instance.\n   */\n  create(element: HTMLElement, deferCaptureElements: boolean = false): FocusTrap {\n    return new FocusTrap(\n      element,\n      this._checker,\n      this._ngZone,\n      this._document,\n      deferCaptureElements,\n    );\n  }\n}\n\n/** Directive for trapping focus within a region. */\n@Directive({\n  selector: '[cdkTrapFocus]',\n  exportAs: 'cdkTrapFocus',\n})\nexport class CdkTrapFocus implements OnDestroy, AfterContentInit, OnChanges, DoCheck {\n  /** Underlying FocusTrap instance. */\n  focusTrap: FocusTrap;\n\n  /** Previously focused element to restore focus to upon destroy when using autoCapture. */\n  private _previouslyFocusedElement: HTMLElement | null = null;\n\n  /** Whether the focus trap is active. */\n  @Input('cdkTrapFocus')\n  get enabled(): boolean {\n    return this.focusTrap.enabled;\n  }\n  set enabled(value: BooleanInput) {\n    this.focusTrap.enabled = coerceBooleanProperty(value);\n  }\n\n  /**\n   * Whether the directive should automatically move focus into the trapped region upon\n   * initialization and return focus to the previous activeElement upon destruction.\n   */\n  @Input('cdkTrapFocusAutoCapture')\n  get autoCapture(): boolean {\n    return this._autoCapture;\n  }\n  set autoCapture(value: BooleanInput) {\n    this._autoCapture = coerceBooleanProperty(value);\n  }\n  private _autoCapture: boolean;\n\n  constructor(\n    private _elementRef: ElementRef<HTMLElement>,\n    private _focusTrapFactory: FocusTrapFactory,\n    /**\n     * @deprecated No longer being used. To be removed.\n     * @breaking-change 13.0.0\n     */\n    @Inject(DOCUMENT) _document: any,\n  ) {\n    this.focusTrap = this._focusTrapFactory.create(this._elementRef.nativeElement, true);\n  }\n\n  ngOnDestroy() {\n    this.focusTrap.destroy();\n\n    // If we stored a previously focused element when using autoCapture, return focus to that\n    // element now that the trapped region is being destroyed.\n    if (this._previouslyFocusedElement) {\n      this._previouslyFocusedElement.focus();\n      this._previouslyFocusedElement = null;\n    }\n  }\n\n  ngAfterContentInit() {\n    this.focusTrap.attachAnchors();\n\n    if (this.autoCapture) {\n      this._captureFocus();\n    }\n  }\n\n  ngDoCheck() {\n    if (!this.focusTrap.hasAttached()) {\n      this.focusTrap.attachAnchors();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    const autoCaptureChange = changes['autoCapture'];\n\n    if (\n      autoCaptureChange &&\n      !autoCaptureChange.firstChange &&\n      this.autoCapture &&\n      this.focusTrap.hasAttached()\n    ) {\n      this._captureFocus();\n    }\n  }\n\n  private _captureFocus() {\n    this._previouslyFocusedElement = _getFocusedElementPierceShadowDom();\n    this.focusTrap.focusInitialElementWhenReady();\n  }\n}\n"]}

package/esm2020/a11y/high-contrast-mode/high-contrast-mode-detector.mjs

@@ -0,0 +1,109 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { inject, Inject, Injectable } from '@angular/core';
+import { BreakpointObserver } from '@kato-lee/cdk/layout';
+import { Platform } from '@kato-lee/cdk/platform';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@kato-lee/cdk/platform";
+/** CSS class applied to the document body when in black-on-white high-contrast mode. */
+export const BLACK_ON_WHITE_CSS_CLASS = 'cdk-high-contrast-black-on-white';
+/** CSS class applied to the document body when in white-on-black high-contrast mode. */
+export const WHITE_ON_BLACK_CSS_CLASS = 'cdk-high-contrast-white-on-black';
+/** CSS class applied to the document body when in high-contrast mode. */
+export const HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS = 'cdk-high-contrast-active';
+/**
+ * Service to determine whether the browser is currently in a high-contrast-mode environment.
+ *
+ * Microsoft Windows supports an accessibility feature called "High Contrast Mode". This mode
+ * changes the appearance of all applications, including web applications, to dramatically increase
+ * contrast.
+ *
+ * IE, Edge, and Firefox currently support this mode. Chrome does not support Windows High Contrast
+ * Mode. This service does not detect high-contrast mode as added by the Chrome "High Contrast"
+ * browser extension.
+ */
+export class HighContrastModeDetector {
+    constructor(_platform, document) {
+        this._platform = _platform;
+        this._document = document;
+        this._breakpointSubscription = inject(BreakpointObserver)
+            .observe('(forced-colors: active)')
+            .subscribe(() => {
+            if (this._hasCheckedHighContrastMode) {
+                this._hasCheckedHighContrastMode = false;
+                this._applyBodyHighContrastModeCssClasses();
+            }
+        });
+    }
+    /** Gets the current high-contrast-mode for the page. */
+    getHighContrastMode() {
+        if (!this._platform.isBrowser) {
+            return 0 /* HighContrastMode.NONE */;
+        }
+        // Create a test element with an arbitrary background-color that is neither black nor
+        // white; high-contrast mode will coerce the color to either black or white. Also ensure that
+        // appending the test element to the DOM does not affect layout by absolutely positioning it
+        const testElement = this._document.createElement('div');
+        testElement.style.backgroundColor = 'rgb(1,2,3)';
+        testElement.style.position = 'absolute';
+        this._document.body.appendChild(testElement);
+        // Get the computed style for the background color, collapsing spaces to normalize between
+        // browsers. Once we get this color, we no longer need the test element. Access the `window`
+        // via the document so we can fake it in tests. Note that we have extra null checks, because
+        // this logic will likely run during app bootstrap and throwing can break the entire app.
+        const documentWindow = this._document.defaultView || window;
+        const computedStyle = documentWindow && documentWindow.getComputedStyle
+            ? documentWindow.getComputedStyle(testElement)
+            : null;
+        const computedColor = ((computedStyle && computedStyle.backgroundColor) || '').replace(/ /g, '');
+        testElement.remove();
+        switch (computedColor) {
+            // Pre Windows 11 dark theme.
+            case 'rgb(0,0,0)':
+            // Windows 11 dark themes.
+            case 'rgb(45,50,54)':
+            case 'rgb(32,32,32)':
+                return 2 /* HighContrastMode.WHITE_ON_BLACK */;
+            // Pre Windows 11 light theme.
+            case 'rgb(255,255,255)':
+            // Windows 11 light theme.
+            case 'rgb(255,250,239)':
+                return 1 /* HighContrastMode.BLACK_ON_WHITE */;
+        }
+        return 0 /* HighContrastMode.NONE */;
+    }
+    ngOnDestroy() {
+        this._breakpointSubscription.unsubscribe();
+    }
+    /** Applies CSS classes indicating high-contrast mode to document body (browser-only). */
+    _applyBodyHighContrastModeCssClasses() {
+        if (!this._hasCheckedHighContrastMode && this._platform.isBrowser && this._document.body) {
+            const bodyClasses = this._document.body.classList;
+            bodyClasses.remove(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS, BLACK_ON_WHITE_CSS_CLASS, WHITE_ON_BLACK_CSS_CLASS);
+            this._hasCheckedHighContrastMode = true;
+            const mode = this.getHighContrastMode();
+            if (mode === 1 /* HighContrastMode.BLACK_ON_WHITE */) {
+                bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS, BLACK_ON_WHITE_CSS_CLASS);
+            }
+            else if (mode === 2 /* HighContrastMode.WHITE_ON_BLACK */) {
+                bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS, WHITE_ON_BLACK_CSS_CLASS);
+            }
+        }
+    }
+}
+HighContrastModeDetector.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: HighContrastModeDetector, deps: [{ token: i1.Platform }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+HighContrastModeDetector.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: HighContrastModeDetector, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: HighContrastModeDetector, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"high-contrast-mode-detector.js","sourceRoot":"","sources":["../../../../../../../src/cdk/a11y/high-contrast-mode/high-contrast-mode-detector.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {inject, Inject, Injectable, OnDestroy} from '@angular/core';\nimport {BreakpointObserver} from '@angular/cdk/layout';\nimport {Platform} from '@angular/cdk/platform';\nimport {DOCUMENT} from '@angular/common';\nimport {Subscription} from 'rxjs';\n\n/** Set of possible high-contrast mode backgrounds. */\nexport const enum HighContrastMode {\n  NONE,\n  BLACK_ON_WHITE,\n  WHITE_ON_BLACK,\n}\n\n/** CSS class applied to the document body when in black-on-white high-contrast mode. */\nexport const BLACK_ON_WHITE_CSS_CLASS = 'cdk-high-contrast-black-on-white';\n\n/** CSS class applied to the document body when in white-on-black high-contrast mode. */\nexport const WHITE_ON_BLACK_CSS_CLASS = 'cdk-high-contrast-white-on-black';\n\n/** CSS class applied to the document body when in high-contrast mode. */\nexport const HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS = 'cdk-high-contrast-active';\n\n/**\n * Service to determine whether the browser is currently in a high-contrast-mode environment.\n *\n * Microsoft Windows supports an accessibility feature called \"High Contrast Mode\". This mode\n * changes the appearance of all applications, including web applications, to dramatically increase\n * contrast.\n *\n * IE, Edge, and Firefox currently support this mode. Chrome does not support Windows High Contrast\n * Mode. This service does not detect high-contrast mode as added by the Chrome \"High Contrast\"\n * browser extension.\n */\n@Injectable({providedIn: 'root'})\nexport class HighContrastModeDetector implements OnDestroy {\n  /**\n   * Figuring out the high contrast mode and adding the body classes can cause\n   * some expensive layouts. This flag is used to ensure that we only do it once.\n   */\n  private _hasCheckedHighContrastMode: boolean;\n  private _document: Document;\n  private _breakpointSubscription: Subscription;\n\n  constructor(private _platform: Platform, @Inject(DOCUMENT) document: any) {\n    this._document = document;\n\n    this._breakpointSubscription = inject(BreakpointObserver)\n      .observe('(forced-colors: active)')\n      .subscribe(() => {\n        if (this._hasCheckedHighContrastMode) {\n          this._hasCheckedHighContrastMode = false;\n          this._applyBodyHighContrastModeCssClasses();\n        }\n      });\n  }\n\n  /** Gets the current high-contrast-mode for the page. */\n  getHighContrastMode(): HighContrastMode {\n    if (!this._platform.isBrowser) {\n      return HighContrastMode.NONE;\n    }\n\n    // Create a test element with an arbitrary background-color that is neither black nor\n    // white; high-contrast mode will coerce the color to either black or white. Also ensure that\n    // appending the test element to the DOM does not affect layout by absolutely positioning it\n    const testElement = this._document.createElement('div');\n    testElement.style.backgroundColor = 'rgb(1,2,3)';\n    testElement.style.position = 'absolute';\n    this._document.body.appendChild(testElement);\n\n    // Get the computed style for the background color, collapsing spaces to normalize between\n    // browsers. Once we get this color, we no longer need the test element. Access the `window`\n    // via the document so we can fake it in tests. Note that we have extra null checks, because\n    // this logic will likely run during app bootstrap and throwing can break the entire app.\n    const documentWindow = this._document.defaultView || window;\n    const computedStyle =\n      documentWindow && documentWindow.getComputedStyle\n        ? documentWindow.getComputedStyle(testElement)\n        : null;\n    const computedColor = ((computedStyle && computedStyle.backgroundColor) || '').replace(\n      / /g,\n      '',\n    );\n    testElement.remove();\n\n    switch (computedColor) {\n      // Pre Windows 11 dark theme.\n      case 'rgb(0,0,0)':\n      // Windows 11 dark themes.\n      case 'rgb(45,50,54)':\n      case 'rgb(32,32,32)':\n        return HighContrastMode.WHITE_ON_BLACK;\n      // Pre Windows 11 light theme.\n      case 'rgb(255,255,255)':\n      // Windows 11 light theme.\n      case 'rgb(255,250,239)':\n        return HighContrastMode.BLACK_ON_WHITE;\n    }\n    return HighContrastMode.NONE;\n  }\n\n  ngOnDestroy(): void {\n    this._breakpointSubscription.unsubscribe();\n  }\n\n  /** Applies CSS classes indicating high-contrast mode to document body (browser-only). */\n  _applyBodyHighContrastModeCssClasses(): void {\n    if (!this._hasCheckedHighContrastMode && this._platform.isBrowser && this._document.body) {\n      const bodyClasses = this._document.body.classList;\n      bodyClasses.remove(\n        HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS,\n        BLACK_ON_WHITE_CSS_CLASS,\n        WHITE_ON_BLACK_CSS_CLASS,\n      );\n      this._hasCheckedHighContrastMode = true;\n\n      const mode = this.getHighContrastMode();\n      if (mode === HighContrastMode.BLACK_ON_WHITE) {\n        bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS, BLACK_ON_WHITE_CSS_CLASS);\n      } else if (mode === HighContrastMode.WHITE_ON_BLACK) {\n        bodyClasses.add(HIGH_CONTRAST_MODE_ACTIVE_CSS_CLASS, WHITE_ON_BLACK_CSS_CLASS);\n      }\n    }\n  }\n}\n"]}

package/esm2020/a11y/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL2ExMXkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==