@angular/material
Version:
Angular Material
234 lines • 38.8 kB
JavaScript
import { __assign } from "tslib";
import { normalizePassiveListenerOptions } from '@angular/cdk/platform';
import { isFakeMousedownFromScreenReader } from '@angular/cdk/a11y';
import { coerceElement } from '@angular/cdk/coercion';
import { RippleRef } from './ripple-ref';
/**
* Default ripple animation configuration for ripples without an explicit
* animation config specified.
*/
export var defaultRippleAnimationConfig = {
enterDuration: 450,
exitDuration: 400
};
/**
* Timeout for ignoring mouse events. Mouse events will be temporary ignored after touch
* events to avoid synthetic mouse events.
*/
var ignoreMouseEventsTimeout = 800;
/** Options that apply to all the event listeners that are bound by the ripple renderer. */
var passiveEventOptions = normalizePassiveListenerOptions({ passive: true });
/**
* 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
*/
var RippleRenderer = /** @class */ (function () {
function RippleRenderer(_target, _ngZone, elementOrElementRef, platform) {
var _this = this;
this._target = _target;
this._ngZone = _ngZone;
/** Whether the pointer is currently down or not. */
this._isPointerDown = false;
/** Events to be registered on the trigger element. */
this._triggerEvents = new Map();
/** Set of currently active ripple references. */
this._activeRipples = new Set();
/** Function being called whenever the trigger is being pressed using mouse. */
this._onMousedown = function (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.
var isFakeMousedown = isFakeMousedownFromScreenReader(event);
var 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. */
this._onTouchStart = function (event) {
if (!_this._target.rippleDisabled) {
// 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.
var touches = event.changedTouches;
for (var 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. */
this._onPointerUp = function () {
if (!_this._isPointerDown) {
return;
}
_this._isPointerDown = false;
// Fade-out all ripples that are visible and not persistent.
_this._activeRipples.forEach(function (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.
var isVisible = ripple.state === 1 /* VISIBLE */ ||
ripple.config.terminateOnPointerUp && ripple.state === 0 /* FADING_IN */;
if (!ripple.config.persistent && isVisible) {
ripple.fadeOut();
}
});
};
// Only do anything if we're on the browser.
if (platform.isBrowser) {
this._containerElement = coerceElement(elementOrElementRef);
// Specify events which need to be registered on the trigger.
this._triggerEvents
.set('mousedown', this._onMousedown)
.set('mouseup', this._onPointerUp)
.set('mouseleave', this._onPointerUp)
.set('touchstart', this._onTouchStart)
.set('touchend', this._onPointerUp)
.set('touchcancel', this._onPointerUp);
}
}
/**
* 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.
*/
RippleRenderer.prototype.fadeInRipple = function (x, y, config) {
var _this = this;
if (config === void 0) { config = {}; }
var containerRect = this._containerRect =
this._containerRect || this._containerElement.getBoundingClientRect();
var animationConfig = __assign(__assign({}, defaultRippleAnimationConfig), config.animation);
if (config.centered) {
x = containerRect.left + containerRect.width / 2;
y = containerRect.top + containerRect.height / 2;
}
var radius = config.radius || distanceToFurthestCorner(x, y, containerRect);
var offsetX = x - containerRect.left;
var offsetY = y - containerRect.top;
var duration = animationConfig.enterDuration;
var 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.
var 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(function () {
var 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. */
RippleRenderer.prototype.fadeOutRipple = function (rippleRef) {
var 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;
}
var rippleEl = rippleRef.element;
var animationConfig = __assign(__assign({}, 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(function () {
rippleRef.state = 3 /* HIDDEN */;
rippleEl.parentNode.removeChild(rippleEl);
}, animationConfig.exitDuration);
};
/** Fades out all currently active ripples. */
RippleRenderer.prototype.fadeOutAll = function () {
this._activeRipples.forEach(function (ripple) { return ripple.fadeOut(); });
};
/** Sets up the trigger event listeners */
RippleRenderer.prototype.setupTriggerEvents = function (elementOrElementRef) {
var _this = this;
var element = coerceElement(elementOrElementRef);
if (!element || element === this._triggerElement) {
return;
}
// Remove all previously registered event listeners from the trigger element.
this._removeTriggerEvents();
this._ngZone.runOutsideAngular(function () {
_this._triggerEvents.forEach(function (fn, type) {
element.addEventListener(type, fn, passiveEventOptions);
});
});
this._triggerElement = element;
};
/** Runs a timeout outside of the Angular zone to avoid triggering the change detection. */
RippleRenderer.prototype._runTimeoutOutsideZone = function (fn, delay) {
if (delay === void 0) { delay = 0; }
this._ngZone.runOutsideAngular(function () { return setTimeout(fn, delay); });
};
/** Removes previously registered event listeners from the trigger element. */
RippleRenderer.prototype._removeTriggerEvents = function () {
var _this = this;
if (this._triggerElement) {
this._triggerEvents.forEach(function (fn, type) {
_this._triggerElement.removeEventListener(type, fn, passiveEventOptions);
});
}
};
return RippleRenderer;
}());
export { RippleRenderer };
/** 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) {
var distX = Math.max(Math.abs(x - rect.left), Math.abs(x - rect.right));
var 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} from '@angular/cdk/a11y';\nimport {coerceElement} from '@angular/cdk/coercion';\nimport {RippleRef, RippleState} from './ripple-ref';\n\nexport type RippleConfig = {\n  color?: string;\n  centered?: boolean;\n  radius?: number;\n  persistent?: boolean;\n  animation?: RippleAnimationConfig;\n  terminateOnPointerUp?: boolean;\n};\n\n/**\n * Interface that describes the configuration for the animation of a ripple.\n * There are two animation phases with different durations for the ripples.\n */\nexport interface RippleAnimationConfig {\n  /** Duration in milliseconds for the enter animation (expansion from point of contact). */\n  enterDuration?: number;\n  /** Duration in milliseconds for the exit animation (fade-out). */\n  exitDuration?: number;\n}\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/**\n * Default ripple animation configuration for ripples without an explicit\n * animation config specified.\n */\nexport const defaultRippleAnimationConfig = {\n  enterDuration: 450,\n  exitDuration: 400\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/**\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 {\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  /** Events to be registered on the trigger element. */\n  private _triggerEvents = new Map<string, any>();\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  /**\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(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      // Specify events which need to be registered on the trigger.\n      this._triggerEvents\n        .set('mousedown', this._onMousedown)\n        .set('mouseup', this._onPointerUp)\n        .set('mouseleave', this._onPointerUp)\n\n        .set('touchstart', this._onTouchStart)\n        .set('touchend', this._onPointerUp)\n        .set('touchcancel', this._onPointerUp);\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.parentNode!.removeChild(rippleEl);\n    }, animationConfig.exitDuration);\n  }\n\n  /** Fades out all currently active ripples. */\n  fadeOutAll() {\n    this._activeRipples.forEach(ripple => ripple.fadeOut());\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._ngZone.runOutsideAngular(() => {\n      this._triggerEvents.forEach((fn, type) => {\n        element.addEventListener(type, fn, passiveEventOptions);\n      });\n    });\n\n    this._triggerElement = element;\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 = 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) {\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 = 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  /** Removes previously registered event listeners from the trigger element. */\n  _removeTriggerEvents() {\n    if (this._triggerElement) {\n      this._triggerEvents.forEach((fn, type) => {\n        this._triggerElement!.removeEventListener(type, fn, passiveEventOptions);\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"]}