@angular/cdk
Version:
Angular Material Component Development Kit
177 lines • 25.1 kB
JavaScript
/**
* @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 { ALT, CONTROL, MAC_META, META, SHIFT } from '@angular/cdk/keycodes';
import { Inject, Injectable, InjectionToken, Optional, NgZone } from '@angular/core';
import { normalizePassiveListenerOptions, Platform, _getEventTarget } from '@angular/cdk/platform';
import { DOCUMENT } from '@angular/common';
import { BehaviorSubject } from 'rxjs';
import { distinctUntilChanged, skip } from 'rxjs/operators';
import { isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader, } from '../fake-event-detection';
import * as i0 from "@angular/core";
import * as i1 from "@angular/cdk/platform";
/**
* Injectable options for the InputModalityDetector. These are shallowly merged with the default
* options.
*/
export const INPUT_MODALITY_DETECTOR_OPTIONS = new InjectionToken('cdk-input-modality-detector-options');
/**
* Default options for the InputModalityDetector.
*
* Modifier keys are ignored by default (i.e. when pressed won't cause the service to detect
* keyboard input modality) for two reasons:
*
* 1. Modifier keys are commonly used with mouse to perform actions such as 'right click' or 'open
* in new tab', and are thus less representative of actual keyboard interaction.
* 2. VoiceOver triggers some keyboard events when linearly navigating with Control + Option (but
* confusingly not with Caps Lock). Thus, to have parity with other screen readers, we ignore
* these keys so as to not update the input modality.
*
* Note that we do not by default ignore the right Meta key on Safari because it has the same key
* code as the ContextMenu key on other browsers. When we switch to using event.key, we can
* distinguish between the two.
*/
export const INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS = {
ignoreKeys: [ALT, CONTROL, MAC_META, META, SHIFT],
};
/**
* The amount of time needed to pass after a touchstart event in order for a subsequent mousedown
* event to be attributed as mouse and not touch.
*
* This is the value used by AngularJS Material. Through trial and error (on iPhone 6S) they found
* that a value of around 650ms seems appropriate.
*/
export 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 = normalizePassiveListenerOptions({
passive: true,
capture: true,
});
/**
* Service that detects the user's input modality.
*
* This service does not update the input modality when a user navigates with a screen reader
* (e.g. linear navigation with VoiceOver, object navigation / browse mode with NVDA, virtual PC
* cursor mode with JAWS). This is in part due to technical limitations (i.e. keyboard events do not
* fire as expected in these modes) but is also arguably the correct behavior. Navigating with a
* screen reader is akin to visually scanning a page, and should not be interpreted as actual user
* input interaction.
*
* When a user is not navigating but *interacting* with a screen reader, this service attempts to
* update the input modality to keyboard, but in general this service's behavior is largely
* undefined.
*/
class InputModalityDetector {
/** The most recently detected input modality. */
get mostRecentModality() {
return this._modality.value;
}
constructor(_platform, ngZone, document, options) {
this._platform = _platform;
/**
* The most recently detected input modality event target. Is null if no input modality has been
* detected or if the associated event target is null for some unknown reason.
*/
this._mostRecentTarget = null;
/** The underlying BehaviorSubject that emits whenever an input modality is detected. */
this._modality = new BehaviorSubject(null);
/**
* The timestamp of the last touch input modality. Used to determine whether mousedown events
* should be attributed to mouse or touch.
*/
this._lastTouchMs = 0;
/**
* Handles keydown events. Must be an arrow function in order to preserve the context when it gets
* bound.
*/
this._onKeydown = (event) => {
// If this is one of the keys we should ignore, then ignore it and don't update the input
// modality to keyboard.
if (this._options?.ignoreKeys?.some(keyCode => keyCode === event.keyCode)) {
return;
}
this._modality.next('keyboard');
this._mostRecentTarget = _getEventTarget(event);
};
/**
* Handles mousedown events. Must be an arrow function in order to preserve the context when it
* gets bound.
*/
this._onMousedown = (event) => {
// Touches trigger both touch and mouse events, so we need to distinguish between mouse events
// that were triggered via mouse vs touch. To do so, check if the mouse event occurs closely
// after the previous touch event.
if (Date.now() - this._lastTouchMs < TOUCH_BUFFER_MS) {
return;
}
// Fake mousedown events are fired by some screen readers when controls are activated by the
// screen reader. Attribute them to keyboard input modality.
this._modality.next(isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse');
this._mostRecentTarget = _getEventTarget(event);
};
/**
* Handles touchstart events. Must be an arrow function in order to preserve the context when it
* gets bound.
*/
this._onTouchstart = (event) => {
// Same scenario as mentioned in _onMousedown, but on touch screen devices, fake touchstart
// events are fired. Again, attribute to keyboard input modality.
if (isFakeTouchstartFromScreenReader(event)) {
this._modality.next('keyboard');
return;
}
// Store the timestamp of this touch event, as it's used to distinguish between mouse events
// triggered via mouse vs touch.
this._lastTouchMs = Date.now();
this._modality.next('touch');
this._mostRecentTarget = _getEventTarget(event);
};
this._options = {
...INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS,
...options,
};
// Skip the first emission as it's null.
this.modalityDetected = this._modality.pipe(skip(1));
this.modalityChanged = this.modalityDetected.pipe(distinctUntilChanged());
// If we're not in a browser, this service should do nothing, as there's no relevant input
// modality to detect.
if (_platform.isBrowser) {
ngZone.runOutsideAngular(() => {
document.addEventListener('keydown', this._onKeydown, modalityEventListenerOptions);
document.addEventListener('mousedown', this._onMousedown, modalityEventListenerOptions);
document.addEventListener('touchstart', this._onTouchstart, modalityEventListenerOptions);
});
}
}
ngOnDestroy() {
this._modality.complete();
if (this._platform.isBrowser) {
document.removeEventListener('keydown', this._onKeydown, modalityEventListenerOptions);
document.removeEventListener('mousedown', this._onMousedown, modalityEventListenerOptions);
document.removeEventListener('touchstart', this._onTouchstart, modalityEventListenerOptions);
}
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: InputModalityDetector, deps: [{ token: i1.Platform }, { token: i0.NgZone }, { token: DOCUMENT }, { token: INPUT_MODALITY_DETECTOR_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: InputModalityDetector, providedIn: 'root' }); }
}
export { InputModalityDetector };
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: InputModalityDetector, decorators: [{
type: Injectable,
args: [{ providedIn: 'root' }]
}], ctorParameters: function () { return [{ type: i1.Platform }, { type: i0.NgZone }, { type: Document, decorators: [{
type: Inject,
args: [DOCUMENT]
}] }, { type: undefined, decorators: [{
type: Optional
}, {
type: Inject,
args: [INPUT_MODALITY_DETECTOR_OPTIONS]
}] }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-modality-detector.js","sourceRoot":"","sources":["../../../../../../../src/cdk/a11y/input-modality/input-modality-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 {ALT, CONTROL, MAC_META, META, SHIFT} from '@angular/cdk/keycodes';\nimport {Inject, Injectable, InjectionToken, OnDestroy, Optional, NgZone} from '@angular/core';\nimport {normalizePassiveListenerOptions, Platform, _getEventTarget} from '@angular/cdk/platform';\nimport {DOCUMENT} from '@angular/common';\nimport {BehaviorSubject, Observable} from 'rxjs';\nimport {distinctUntilChanged, skip} from 'rxjs/operators';\nimport {\n  isFakeMousedownFromScreenReader,\n  isFakeTouchstartFromScreenReader,\n} from '../fake-event-detection';\n\n/**\n * The input modalities detected by this service. Null is used if the input modality is unknown.\n */\nexport type InputModality = 'keyboard' | 'mouse' | 'touch' | null;\n\n/** Options to configure the behavior of the InputModalityDetector. */\nexport interface InputModalityDetectorOptions {\n  /** Keys to ignore when detecting keyboard input modality. */\n  ignoreKeys?: number[];\n}\n\n/**\n * Injectable options for the InputModalityDetector. These are shallowly merged with the default\n * options.\n */\nexport const INPUT_MODALITY_DETECTOR_OPTIONS = new InjectionToken<InputModalityDetectorOptions>(\n  'cdk-input-modality-detector-options',\n);\n\n/**\n * Default options for the InputModalityDetector.\n *\n * Modifier keys are ignored by default (i.e. when pressed won't cause the service to detect\n * keyboard input modality) for two reasons:\n *\n * 1. Modifier keys are commonly used with mouse to perform actions such as 'right click' or 'open\n *    in new tab', and are thus less representative of actual keyboard interaction.\n * 2. VoiceOver triggers some keyboard events when linearly navigating with Control + Option (but\n *    confusingly not with Caps Lock). Thus, to have parity with other screen readers, we ignore\n *    these keys so as to not update the input modality.\n *\n * Note that we do not by default ignore the right Meta key on Safari because it has the same key\n * code as the ContextMenu key on other browsers. When we switch to using event.key, we can\n * distinguish between the two.\n */\nexport const INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS: InputModalityDetectorOptions = {\n  ignoreKeys: [ALT, CONTROL, MAC_META, META, SHIFT],\n};\n\n/**\n * The amount of time needed to pass after a touchstart event in order for a subsequent mousedown\n * event to be attributed as mouse and not touch.\n *\n * This is the value used by AngularJS Material. Through trial and error (on iPhone 6S) they found\n * that a value of around 650ms seems appropriate.\n */\nexport const TOUCH_BUFFER_MS = 650;\n\n/**\n * Event listener options that enable capturing and also mark the listener as passive if the browser\n * supports it.\n */\nconst modalityEventListenerOptions = normalizePassiveListenerOptions({\n  passive: true,\n  capture: true,\n});\n\n/**\n * Service that detects the user's input modality.\n *\n * This service does not update the input modality when a user navigates with a screen reader\n * (e.g. linear navigation with VoiceOver, object navigation / browse mode with NVDA, virtual PC\n * cursor mode with JAWS). This is in part due to technical limitations (i.e. keyboard events do not\n * fire as expected in these modes) but is also arguably the correct behavior. Navigating with a\n * screen reader is akin to visually scanning a page, and should not be interpreted as actual user\n * input interaction.\n *\n * When a user is not navigating but *interacting* with a screen reader, this service attempts to\n * update the input modality to keyboard, but in general this service's behavior is largely\n * undefined.\n */\n@Injectable({providedIn: 'root'})\nexport class InputModalityDetector implements OnDestroy {\n  /** Emits whenever an input modality is detected. */\n  readonly modalityDetected: Observable<InputModality>;\n\n  /** Emits when the input modality changes. */\n  readonly modalityChanged: Observable<InputModality>;\n\n  /** The most recently detected input modality. */\n  get mostRecentModality(): InputModality {\n    return this._modality.value;\n  }\n\n  /**\n   * The most recently detected input modality event target. Is null if no input modality has been\n   * detected or if the associated event target is null for some unknown reason.\n   */\n  _mostRecentTarget: HTMLElement | null = null;\n\n  /** The underlying BehaviorSubject that emits whenever an input modality is detected. */\n  private readonly _modality = new BehaviorSubject<InputModality>(null);\n\n  /** Options for this InputModalityDetector. */\n  private readonly _options: InputModalityDetectorOptions;\n\n  /**\n   * The timestamp of the last touch input modality. Used to determine whether mousedown events\n   * should be attributed to mouse or touch.\n   */\n  private _lastTouchMs = 0;\n\n  /**\n   * Handles keydown events. Must be an arrow function in order to preserve the context when it gets\n   * bound.\n   */\n  private _onKeydown = (event: KeyboardEvent) => {\n    // If this is one of the keys we should ignore, then ignore it and don't update the input\n    // modality to keyboard.\n    if (this._options?.ignoreKeys?.some(keyCode => keyCode === event.keyCode)) {\n      return;\n    }\n\n    this._modality.next('keyboard');\n    this._mostRecentTarget = _getEventTarget(event);\n  };\n\n  /**\n   * Handles mousedown events. Must be an arrow function in order to preserve the context when it\n   * gets bound.\n   */\n  private _onMousedown = (event: MouseEvent) => {\n    // Touches trigger both touch and mouse events, so we need to distinguish between mouse events\n    // that were triggered via mouse vs touch. To do so, check if the mouse event occurs closely\n    // after the previous touch event.\n    if (Date.now() - this._lastTouchMs < TOUCH_BUFFER_MS) {\n      return;\n    }\n\n    // Fake mousedown events are fired by some screen readers when controls are activated by the\n    // screen reader. Attribute them to keyboard input modality.\n    this._modality.next(isFakeMousedownFromScreenReader(event) ? 'keyboard' : 'mouse');\n    this._mostRecentTarget = _getEventTarget(event);\n  };\n\n  /**\n   * Handles touchstart events. Must be an arrow function in order to preserve the context when it\n   * gets bound.\n   */\n  private _onTouchstart = (event: TouchEvent) => {\n    // Same scenario as mentioned in _onMousedown, but on touch screen devices, fake touchstart\n    // events are fired. Again, attribute to keyboard input modality.\n    if (isFakeTouchstartFromScreenReader(event)) {\n      this._modality.next('keyboard');\n      return;\n    }\n\n    // Store the timestamp of this touch event, as it's used to distinguish between mouse events\n    // triggered via mouse vs touch.\n    this._lastTouchMs = Date.now();\n\n    this._modality.next('touch');\n    this._mostRecentTarget = _getEventTarget(event);\n  };\n\n  constructor(\n    private readonly _platform: Platform,\n    ngZone: NgZone,\n    @Inject(DOCUMENT) document: Document,\n    @Optional()\n    @Inject(INPUT_MODALITY_DETECTOR_OPTIONS)\n    options?: InputModalityDetectorOptions,\n  ) {\n    this._options = {\n      ...INPUT_MODALITY_DETECTOR_DEFAULT_OPTIONS,\n      ...options,\n    };\n\n    // Skip the first emission as it's null.\n    this.modalityDetected = this._modality.pipe(skip(1));\n    this.modalityChanged = this.modalityDetected.pipe(distinctUntilChanged());\n\n    // If we're not in a browser, this service should do nothing, as there's no relevant input\n    // modality to detect.\n    if (_platform.isBrowser) {\n      ngZone.runOutsideAngular(() => {\n        document.addEventListener('keydown', this._onKeydown, modalityEventListenerOptions);\n        document.addEventListener('mousedown', this._onMousedown, modalityEventListenerOptions);\n        document.addEventListener('touchstart', this._onTouchstart, modalityEventListenerOptions);\n      });\n    }\n  }\n\n  ngOnDestroy() {\n    this._modality.complete();\n\n    if (this._platform.isBrowser) {\n      document.removeEventListener('keydown', this._onKeydown, modalityEventListenerOptions);\n      document.removeEventListener('mousedown', this._onMousedown, modalityEventListenerOptions);\n      document.removeEventListener('touchstart', this._onTouchstart, modalityEventListenerOptions);\n    }\n  }\n}\n"]}