@angular/material
Version:
Angular Material
261 lines • 41.1 kB
JavaScript
import { normalizePassiveListenerOptions } from '@angular/cdk/platform';
import { isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader } from '@angular/cdk/a11y';
import { coerceElement } from '@angular/cdk/coercion';
import { RippleRef } from './ripple-ref';
// TODO: import these values from `@material/ripple` eventually.
/**
* Default ripple animation configuration for ripples without an explicit
* animation config specified.
*/
export const defaultRippleAnimationConfig = {
enterDuration: 225,
exitDuration: 150,
};
/**
* Timeout for ignoring mouse events. Mouse events will be temporary ignored after touch
* events to avoid synthetic mouse events.
*/
const ignoreMouseEventsTimeout = 800;
/** Options that apply to all the event listeners that are bound by the ripple renderer. */
const passiveEventOptions = normalizePassiveListenerOptions({ passive: true });
/** Events that signal that the pointer is down. */
const pointerDownEvents = ['mousedown', 'touchstart'];
/** Events that signal that the pointer is up. */
const pointerUpEvents = ['mouseup', 'mouseleave', 'touchend', 'touchcancel'];
/**
* Helper service that performs DOM manipulations. Not intended to be used outside this module.
* The constructor takes a reference to the ripple directive's host element and a map of DOM
* event handlers to be installed on the element that triggers ripple animations.
* This will eventually become a custom renderer once Angular support exists.
* @docs-private
*/
export class RippleRenderer {
constructor(_target, _ngZone, elementOrElementRef, platform) {
this._target = _target;
this._ngZone = _ngZone;
/** Whether the pointer is currently down or not. */
this._isPointerDown = false;
/** Set of currently active ripple references. */
this._activeRipples = new Set();
/** Whether pointer-up event listeners have been registered. */
this._pointerUpEventsRegistered = false;
// Only do anything if we're on the browser.
if (platform.isBrowser) {
this._containerElement = coerceElement(elementOrElementRef);
}
}
/**
* Fades in a ripple at the given coordinates.
* @param x Coordinate within the element, along the X axis at which to start the ripple.
* @param y Coordinate within the element, along the Y axis at which to start the ripple.
* @param config Extra ripple options.
*/
fadeInRipple(x, y, config = {}) {
const containerRect = (this._containerRect =
this._containerRect || this._containerElement.getBoundingClientRect());
const animationConfig = { ...defaultRippleAnimationConfig, ...config.animation };
if (config.centered) {
x = containerRect.left + containerRect.width / 2;
y = containerRect.top + containerRect.height / 2;
}
const radius = config.radius || distanceToFurthestCorner(x, y, containerRect);
const offsetX = x - containerRect.left;
const offsetY = y - containerRect.top;
const duration = animationConfig.enterDuration;
const ripple = document.createElement('div');
ripple.classList.add('mat-ripple-element');
ripple.style.left = `${offsetX - radius}px`;
ripple.style.top = `${offsetY - radius}px`;
ripple.style.height = `${radius * 2}px`;
ripple.style.width = `${radius * 2}px`;
// If a custom color has been specified, set it as inline style. If no color is
// set, the default color will be applied through the ripple theme styles.
if (config.color != null) {
ripple.style.backgroundColor = config.color;
}
ripple.style.transitionDuration = `${duration}ms`;
this._containerElement.appendChild(ripple);
// By default the browser does not recalculate the styles of dynamically created
// ripple elements. This is critical because then the `scale` would not animate properly.
enforceStyleRecalculation(ripple);
ripple.style.transform = 'scale(1)';
// Exposed reference to the ripple that will be returned.
const rippleRef = new RippleRef(this, ripple, config);
rippleRef.state = 0 /* FADING_IN */;
// Add the ripple reference to the list of all active ripples.
this._activeRipples.add(rippleRef);
if (!config.persistent) {
this._mostRecentTransientRipple = rippleRef;
}
// Wait for the ripple element to be completely faded in.
// Once it's faded in, the ripple can be hidden immediately if the mouse is released.
this._runTimeoutOutsideZone(() => {
const isMostRecentTransientRipple = rippleRef === this._mostRecentTransientRipple;
rippleRef.state = 1 /* VISIBLE */;
// When the timer runs out while the user has kept their pointer down, we want to
// keep only the persistent ripples and the latest transient ripple. We do this,
// because we don't want stacked transient ripples to appear after their enter
// animation has finished.
if (!config.persistent && (!isMostRecentTransientRipple || !this._isPointerDown)) {
rippleRef.fadeOut();
}
}, duration);
return rippleRef;
}
/** Fades out a ripple reference. */
fadeOutRipple(rippleRef) {
const wasActive = this._activeRipples.delete(rippleRef);
if (rippleRef === this._mostRecentTransientRipple) {
this._mostRecentTransientRipple = null;
}
// Clear out the cached bounding rect if we have no more ripples.
if (!this._activeRipples.size) {
this._containerRect = null;
}
// For ripples that are not active anymore, don't re-run the fade-out animation.
if (!wasActive) {
return;
}
const rippleEl = rippleRef.element;
const animationConfig = { ...defaultRippleAnimationConfig, ...rippleRef.config.animation };
rippleEl.style.transitionDuration = `${animationConfig.exitDuration}ms`;
rippleEl.style.opacity = '0';
rippleRef.state = 2 /* FADING_OUT */;
// Once the ripple faded out, the ripple can be safely removed from the DOM.
this._runTimeoutOutsideZone(() => {
rippleRef.state = 3 /* HIDDEN */;
rippleEl.remove();
}, animationConfig.exitDuration);
}
/** Fades out all currently active ripples. */
fadeOutAll() {
this._activeRipples.forEach(ripple => ripple.fadeOut());
}
/** Fades out all currently active non-persistent ripples. */
fadeOutAllNonPersistent() {
this._activeRipples.forEach(ripple => {
if (!ripple.config.persistent) {
ripple.fadeOut();
}
});
}
/** Sets up the trigger event listeners */
setupTriggerEvents(elementOrElementRef) {
const element = coerceElement(elementOrElementRef);
if (!element || element === this._triggerElement) {
return;
}
// Remove all previously registered event listeners from the trigger element.
this._removeTriggerEvents();
this._triggerElement = element;
this._registerEvents(pointerDownEvents);
}
/**
* Handles all registered events.
* @docs-private
*/
handleEvent(event) {
if (event.type === 'mousedown') {
this._onMousedown(event);
}
else if (event.type === 'touchstart') {
this._onTouchStart(event);
}
else {
this._onPointerUp();
}
// If pointer-up events haven't been registered yet, do so now.
// We do this on-demand in order to reduce the total number of event listeners
// registered by the ripples, which speeds up the rendering time for large UIs.
if (!this._pointerUpEventsRegistered) {
this._registerEvents(pointerUpEvents);
this._pointerUpEventsRegistered = true;
}
}
/** Function being called whenever the trigger is being pressed using mouse. */
_onMousedown(event) {
// Screen readers will fire fake mouse events for space/enter. Skip launching a
// ripple in this case for consistency with the non-screen-reader experience.
const isFakeMousedown = isFakeMousedownFromScreenReader(event);
const isSyntheticEvent = this._lastTouchStartEvent &&
Date.now() < this._lastTouchStartEvent + ignoreMouseEventsTimeout;
if (!this._target.rippleDisabled && !isFakeMousedown && !isSyntheticEvent) {
this._isPointerDown = true;
this.fadeInRipple(event.clientX, event.clientY, this._target.rippleConfig);
}
}
/** Function being called whenever the trigger is being pressed using touch. */
_onTouchStart(event) {
if (!this._target.rippleDisabled && !isFakeTouchstartFromScreenReader(event)) {
// Some browsers fire mouse events after a `touchstart` event. Those synthetic mouse
// events will launch a second ripple if we don't ignore mouse events for a specific
// time after a touchstart event.
this._lastTouchStartEvent = Date.now();
this._isPointerDown = true;
// Use `changedTouches` so we skip any touches where the user put
// their finger down, but used another finger to tap the element again.
const touches = event.changedTouches;
for (let i = 0; i < touches.length; i++) {
this.fadeInRipple(touches[i].clientX, touches[i].clientY, this._target.rippleConfig);
}
}
}
/** Function being called whenever the trigger is being released. */
_onPointerUp() {
if (!this._isPointerDown) {
return;
}
this._isPointerDown = false;
// Fade-out all ripples that are visible and not persistent.
this._activeRipples.forEach(ripple => {
// By default, only ripples that are completely visible will fade out on pointer release.
// If the `terminateOnPointerUp` option is set, ripples that still fade in will also fade out.
const isVisible = ripple.state === 1 /* VISIBLE */ ||
(ripple.config.terminateOnPointerUp && ripple.state === 0 /* FADING_IN */);
if (!ripple.config.persistent && isVisible) {
ripple.fadeOut();
}
});
}
/** Runs a timeout outside of the Angular zone to avoid triggering the change detection. */
_runTimeoutOutsideZone(fn, delay = 0) {
this._ngZone.runOutsideAngular(() => setTimeout(fn, delay));
}
/** Registers event listeners for a given list of events. */
_registerEvents(eventTypes) {
this._ngZone.runOutsideAngular(() => {
eventTypes.forEach(type => {
this._triggerElement.addEventListener(type, this, passiveEventOptions);
});
});
}
/** Removes previously registered event listeners from the trigger element. */
_removeTriggerEvents() {
if (this._triggerElement) {
pointerDownEvents.forEach(type => {
this._triggerElement.removeEventListener(type, this, passiveEventOptions);
});
if (this._pointerUpEventsRegistered) {
pointerUpEvents.forEach(type => {
this._triggerElement.removeEventListener(type, this, passiveEventOptions);
});
}
}
}
}
/** Enforces a style recalculation of a DOM element by computing its styles. */
function enforceStyleRecalculation(element) {
// Enforce a style recalculation by calling `getComputedStyle` and accessing any property.
// Calling `getPropertyValue` is important to let optimizers know that this is not a noop.
// See: https://gist.github.com/paulirish/5d52fb081b3570c81e3a
window.getComputedStyle(element).getPropertyValue('opacity');
}
/**
* Returns the distance from the point (x, y) to the furthest corner of a rectangle.
*/
function distanceToFurthestCorner(x, y, rect) {
const distX = Math.max(Math.abs(x - rect.left), Math.abs(x - rect.right));
const distY = Math.max(Math.abs(y - rect.top), Math.abs(y - rect.bottom));
return Math.sqrt(distX * distX + distY * distY);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ripple-renderer.js","sourceRoot":"","sources":["../../../../../../../src/material/core/ripple/ripple-renderer.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 */\nimport {ElementRef, NgZone} from '@angular/core';\nimport {Platform, normalizePassiveListenerOptions} from '@angular/cdk/platform';\nimport {isFakeMousedownFromScreenReader, isFakeTouchstartFromScreenReader} from '@angular/cdk/a11y';\nimport {coerceElement} from '@angular/cdk/coercion';\nimport {RippleRef, RippleState, RippleConfig} from './ripple-ref';\n\n/**\n * Interface that describes the target for launching ripples.\n * It defines the ripple configuration and disabled state for interaction ripples.\n * @docs-private\n */\nexport interface RippleTarget {\n  /** Configuration for ripples that are launched on pointer down. */\n  rippleConfig: RippleConfig;\n  /** Whether ripples on pointer down should be disabled. */\n  rippleDisabled: boolean;\n}\n\n// TODO: import these values from `@material/ripple` eventually.\n/**\n * Default ripple animation configuration for ripples without an explicit\n * animation config specified.\n */\nexport const defaultRippleAnimationConfig = {\n  enterDuration: 225,\n  exitDuration: 150,\n};\n\n/**\n * Timeout for ignoring mouse events. Mouse events will be temporary ignored after touch\n * events to avoid synthetic mouse events.\n */\nconst ignoreMouseEventsTimeout = 800;\n\n/** Options that apply to all the event listeners that are bound by the ripple renderer. */\nconst passiveEventOptions = normalizePassiveListenerOptions({passive: true});\n\n/** Events that signal that the pointer is down. */\nconst pointerDownEvents = ['mousedown', 'touchstart'];\n\n/** Events that signal that the pointer is up. */\nconst pointerUpEvents = ['mouseup', 'mouseleave', 'touchend', 'touchcancel'];\n\n/**\n * Helper service that performs DOM manipulations. Not intended to be used outside this module.\n * The constructor takes a reference to the ripple directive's host element and a map of DOM\n * event handlers to be installed on the element that triggers ripple animations.\n * This will eventually become a custom renderer once Angular support exists.\n * @docs-private\n */\nexport class RippleRenderer implements EventListenerObject {\n  /** Element where the ripples are being added to. */\n  private _containerElement: HTMLElement;\n\n  /** Element which triggers the ripple elements on mouse events. */\n  private _triggerElement: HTMLElement | null;\n\n  /** Whether the pointer is currently down or not. */\n  private _isPointerDown = false;\n\n  /** Set of currently active ripple references. */\n  private _activeRipples = new Set<RippleRef>();\n\n  /** Latest non-persistent ripple that was triggered. */\n  private _mostRecentTransientRipple: RippleRef | null;\n\n  /** Time in milliseconds when the last touchstart event happened. */\n  private _lastTouchStartEvent: number;\n\n  /** Whether pointer-up event listeners have been registered. */\n  private _pointerUpEventsRegistered = false;\n\n  /**\n   * Cached dimensions of the ripple container. Set when the first\n   * ripple is shown and cleared once no more ripples are visible.\n   */\n  private _containerRect: ClientRect | null;\n\n  constructor(\n    private _target: RippleTarget,\n    private _ngZone: NgZone,\n    elementOrElementRef: HTMLElement | ElementRef<HTMLElement>,\n    platform: Platform,\n  ) {\n    // Only do anything if we're on the browser.\n    if (platform.isBrowser) {\n      this._containerElement = coerceElement(elementOrElementRef);\n    }\n  }\n\n  /**\n   * Fades in a ripple at the given coordinates.\n   * @param x Coordinate within the element, along the X axis at which to start the ripple.\n   * @param y Coordinate within the element, along the Y axis at which to start the ripple.\n   * @param config Extra ripple options.\n   */\n  fadeInRipple(x: number, y: number, config: RippleConfig = {}): RippleRef {\n    const containerRect = (this._containerRect =\n      this._containerRect || this._containerElement.getBoundingClientRect());\n    const animationConfig = {...defaultRippleAnimationConfig, ...config.animation};\n\n    if (config.centered) {\n      x = containerRect.left + containerRect.width / 2;\n      y = containerRect.top + containerRect.height / 2;\n    }\n\n    const radius = config.radius || distanceToFurthestCorner(x, y, containerRect);\n    const offsetX = x - containerRect.left;\n    const offsetY = y - containerRect.top;\n    const duration = animationConfig.enterDuration;\n\n    const ripple = document.createElement('div');\n    ripple.classList.add('mat-ripple-element');\n\n    ripple.style.left = `${offsetX - radius}px`;\n    ripple.style.top = `${offsetY - radius}px`;\n    ripple.style.height = `${radius * 2}px`;\n    ripple.style.width = `${radius * 2}px`;\n\n    // If a custom color has been specified, set it as inline style. If no color is\n    // set, the default color will be applied through the ripple theme styles.\n    if (config.color != null) {\n      ripple.style.backgroundColor = config.color;\n    }\n\n    ripple.style.transitionDuration = `${duration}ms`;\n\n    this._containerElement.appendChild(ripple);\n\n    // By default the browser does not recalculate the styles of dynamically created\n    // ripple elements. This is critical because then the `scale` would not animate properly.\n    enforceStyleRecalculation(ripple);\n\n    ripple.style.transform = 'scale(1)';\n\n    // Exposed reference to the ripple that will be returned.\n    const rippleRef = new RippleRef(this, ripple, config);\n\n    rippleRef.state = RippleState.FADING_IN;\n\n    // Add the ripple reference to the list of all active ripples.\n    this._activeRipples.add(rippleRef);\n\n    if (!config.persistent) {\n      this._mostRecentTransientRipple = rippleRef;\n    }\n\n    // Wait for the ripple element to be completely faded in.\n    // Once it's faded in, the ripple can be hidden immediately if the mouse is released.\n    this._runTimeoutOutsideZone(() => {\n      const isMostRecentTransientRipple = rippleRef === this._mostRecentTransientRipple;\n\n      rippleRef.state = RippleState.VISIBLE;\n\n      // When the timer runs out while the user has kept their pointer down, we want to\n      // keep only the persistent ripples and the latest transient ripple. We do this,\n      // because we don't want stacked transient ripples to appear after their enter\n      // animation has finished.\n      if (!config.persistent && (!isMostRecentTransientRipple || !this._isPointerDown)) {\n        rippleRef.fadeOut();\n      }\n    }, duration);\n\n    return rippleRef;\n  }\n\n  /** Fades out a ripple reference. */\n  fadeOutRipple(rippleRef: RippleRef) {\n    const wasActive = this._activeRipples.delete(rippleRef);\n\n    if (rippleRef === this._mostRecentTransientRipple) {\n      this._mostRecentTransientRipple = null;\n    }\n\n    // Clear out the cached bounding rect if we have no more ripples.\n    if (!this._activeRipples.size) {\n      this._containerRect = null;\n    }\n\n    // For ripples that are not active anymore, don't re-run the fade-out animation.\n    if (!wasActive) {\n      return;\n    }\n\n    const rippleEl = rippleRef.element;\n    const animationConfig = {...defaultRippleAnimationConfig, ...rippleRef.config.animation};\n\n    rippleEl.style.transitionDuration = `${animationConfig.exitDuration}ms`;\n    rippleEl.style.opacity = '0';\n    rippleRef.state = RippleState.FADING_OUT;\n\n    // Once the ripple faded out, the ripple can be safely removed from the DOM.\n    this._runTimeoutOutsideZone(() => {\n      rippleRef.state = RippleState.HIDDEN;\n      rippleEl.remove();\n    }, animationConfig.exitDuration);\n  }\n\n  /** Fades out all currently active ripples. */\n  fadeOutAll() {\n    this._activeRipples.forEach(ripple => ripple.fadeOut());\n  }\n\n  /** Fades out all currently active non-persistent ripples. */\n  fadeOutAllNonPersistent() {\n    this._activeRipples.forEach(ripple => {\n      if (!ripple.config.persistent) {\n        ripple.fadeOut();\n      }\n    });\n  }\n\n  /** Sets up the trigger event listeners */\n  setupTriggerEvents(elementOrElementRef: HTMLElement | ElementRef<HTMLElement>) {\n    const element = coerceElement(elementOrElementRef);\n\n    if (!element || element === this._triggerElement) {\n      return;\n    }\n\n    // Remove all previously registered event listeners from the trigger element.\n    this._removeTriggerEvents();\n\n    this._triggerElement = element;\n    this._registerEvents(pointerDownEvents);\n  }\n\n  /**\n   * Handles all registered events.\n   * @docs-private\n   */\n  handleEvent(event: Event) {\n    if (event.type === 'mousedown') {\n      this._onMousedown(event as MouseEvent);\n    } else if (event.type === 'touchstart') {\n      this._onTouchStart(event as TouchEvent);\n    } else {\n      this._onPointerUp();\n    }\n\n    // If pointer-up events haven't been registered yet, do so now.\n    // We do this on-demand in order to reduce the total number of event listeners\n    // registered by the ripples, which speeds up the rendering time for large UIs.\n    if (!this._pointerUpEventsRegistered) {\n      this._registerEvents(pointerUpEvents);\n      this._pointerUpEventsRegistered = true;\n    }\n  }\n\n  /** Function being called whenever the trigger is being pressed using mouse. */\n  private _onMousedown(event: MouseEvent) {\n    // Screen readers will fire fake mouse events for space/enter. Skip launching a\n    // ripple in this case for consistency with the non-screen-reader experience.\n    const isFakeMousedown = isFakeMousedownFromScreenReader(event);\n    const isSyntheticEvent =\n      this._lastTouchStartEvent &&\n      Date.now() < this._lastTouchStartEvent + ignoreMouseEventsTimeout;\n\n    if (!this._target.rippleDisabled && !isFakeMousedown && !isSyntheticEvent) {\n      this._isPointerDown = true;\n      this.fadeInRipple(event.clientX, event.clientY, this._target.rippleConfig);\n    }\n  }\n\n  /** Function being called whenever the trigger is being pressed using touch. */\n  private _onTouchStart(event: TouchEvent) {\n    if (!this._target.rippleDisabled && !isFakeTouchstartFromScreenReader(event)) {\n      // Some browsers fire mouse events after a `touchstart` event. Those synthetic mouse\n      // events will launch a second ripple if we don't ignore mouse events for a specific\n      // time after a touchstart event.\n      this._lastTouchStartEvent = Date.now();\n      this._isPointerDown = true;\n\n      // Use `changedTouches` so we skip any touches where the user put\n      // their finger down, but used another finger to tap the element again.\n      const touches = event.changedTouches;\n\n      for (let i = 0; i < touches.length; i++) {\n        this.fadeInRipple(touches[i].clientX, touches[i].clientY, this._target.rippleConfig);\n      }\n    }\n  }\n\n  /** Function being called whenever the trigger is being released. */\n  private _onPointerUp() {\n    if (!this._isPointerDown) {\n      return;\n    }\n\n    this._isPointerDown = false;\n\n    // Fade-out all ripples that are visible and not persistent.\n    this._activeRipples.forEach(ripple => {\n      // By default, only ripples that are completely visible will fade out on pointer release.\n      // If the `terminateOnPointerUp` option is set, ripples that still fade in will also fade out.\n      const isVisible =\n        ripple.state === RippleState.VISIBLE ||\n        (ripple.config.terminateOnPointerUp && ripple.state === RippleState.FADING_IN);\n\n      if (!ripple.config.persistent && isVisible) {\n        ripple.fadeOut();\n      }\n    });\n  }\n\n  /** Runs a timeout outside of the Angular zone to avoid triggering the change detection. */\n  private _runTimeoutOutsideZone(fn: Function, delay = 0) {\n    this._ngZone.runOutsideAngular(() => setTimeout(fn, delay));\n  }\n\n  /** Registers event listeners for a given list of events. */\n  private _registerEvents(eventTypes: string[]) {\n    this._ngZone.runOutsideAngular(() => {\n      eventTypes.forEach(type => {\n        this._triggerElement!.addEventListener(type, this, passiveEventOptions);\n      });\n    });\n  }\n\n  /** Removes previously registered event listeners from the trigger element. */\n  _removeTriggerEvents() {\n    if (this._triggerElement) {\n      pointerDownEvents.forEach(type => {\n        this._triggerElement!.removeEventListener(type, this, passiveEventOptions);\n      });\n\n      if (this._pointerUpEventsRegistered) {\n        pointerUpEvents.forEach(type => {\n          this._triggerElement!.removeEventListener(type, this, passiveEventOptions);\n        });\n      }\n    }\n  }\n}\n\n/** Enforces a style recalculation of a DOM element by computing its styles. */\nfunction enforceStyleRecalculation(element: HTMLElement) {\n  // Enforce a style recalculation by calling `getComputedStyle` and accessing any property.\n  // Calling `getPropertyValue` is important to let optimizers know that this is not a noop.\n  // See: https://gist.github.com/paulirish/5d52fb081b3570c81e3a\n  window.getComputedStyle(element).getPropertyValue('opacity');\n}\n\n/**\n * Returns the distance from the point (x, y) to the furthest corner of a rectangle.\n */\nfunction distanceToFurthestCorner(x: number, y: number, rect: ClientRect) {\n  const distX = Math.max(Math.abs(x - rect.left), Math.abs(x - rect.right));\n  const distY = Math.max(Math.abs(y - rect.top), Math.abs(y - rect.bottom));\n  return Math.sqrt(distX * distX + distY * distY);\n}\n"]}