@angular/material
Version:
Angular Material
458 lines • 43.7 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: src/material/core/ripple/ripple-renderer.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { normalizePassiveListenerOptions } from '@angular/cdk/platform';
import { isFakeMousedownFromScreenReader } from '@angular/cdk/a11y';
import { coerceElement } from '@angular/cdk/coercion';
import { RippleRef, RippleState } from './ripple-ref';
/**
* Interface that describes the configuration for the animation of a ripple.
* There are two animation phases with different durations for the ripples.
* @record
*/
export function RippleAnimationConfig() { }
if (false) {
/**
* Duration in milliseconds for the enter animation (expansion from point of contact).
* @type {?|undefined}
*/
RippleAnimationConfig.prototype.enterDuration;
/**
* Duration in milliseconds for the exit animation (fade-out).
* @type {?|undefined}
*/
RippleAnimationConfig.prototype.exitDuration;
}
/**
* Interface that describes the target for launching ripples.
* It defines the ripple configuration and disabled state for interaction ripples.
* \@docs-private
* @record
*/
export function RippleTarget() { }
if (false) {
/**
* Configuration for ripples that are launched on pointer down.
* @type {?}
*/
RippleTarget.prototype.rippleConfig;
/**
* Whether ripples on pointer down should be disabled.
* @type {?}
*/
RippleTarget.prototype.rippleDisabled;
}
/**
* Default ripple animation configuration for ripples without an explicit
* animation config specified.
* @type {?}
*/
export const defaultRippleAnimationConfig = {
enterDuration: 450,
exitDuration: 400
};
/**
* Timeout for ignoring mouse events. Mouse events will be temporary ignored after touch
* events to avoid synthetic mouse events.
* @type {?}
*/
const ignoreMouseEventsTimeout = 800;
/**
* Options that apply to all the event listeners that are bound by the ripple renderer.
* @type {?}
*/
const 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
*/
export class RippleRenderer {
/**
* @param {?} _target
* @param {?} _ngZone
* @param {?} elementOrElementRef
* @param {?} platform
*/
constructor(_target, _ngZone, elementOrElementRef, platform) {
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 = (/**
* @param {?} event
* @return {?}
*/
(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.
/** @type {?} */
const isFakeMousedown = isFakeMousedownFromScreenReader(event);
/** @type {?} */
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.
*/
this._onTouchStart = (/**
* @param {?} event
* @return {?}
*/
(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.
/** @type {?} */
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.
*/
this._onPointerUp = (/**
* @return {?}
*/
() => {
if (!this._isPointerDown) {
return;
}
this._isPointerDown = false;
// Fade-out all ripples that are visible and not persistent.
this._activeRipples.forEach((/**
* @param {?} ripple
* @return {?}
*/
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.
/** @type {?} */
const isVisible = ripple.state === RippleState.VISIBLE ||
ripple.config.terminateOnPointerUp && ripple.state === RippleState.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.
* @return {?}
*/
fadeInRipple(x, y, config = {}) {
/** @type {?} */
const containerRect = this._containerRect =
this._containerRect || this._containerElement.getBoundingClientRect();
/** @type {?} */
const animationConfig = Object.assign(Object.assign({}, defaultRippleAnimationConfig), config.animation);
if (config.centered) {
x = containerRect.left + containerRect.width / 2;
y = containerRect.top + containerRect.height / 2;
}
/** @type {?} */
const radius = config.radius || distanceToFurthestCorner(x, y, containerRect);
/** @type {?} */
const offsetX = x - containerRect.left;
/** @type {?} */
const offsetY = y - containerRect.top;
/** @type {?} */
const duration = animationConfig.enterDuration;
/** @type {?} */
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.
/** @type {?} */
const rippleRef = new RippleRef(this, ripple, config);
rippleRef.state = RippleState.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((/**
* @return {?}
*/
() => {
/** @type {?} */
const isMostRecentTransientRipple = rippleRef === this._mostRecentTransientRipple;
rippleRef.state = RippleState.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.
* @param {?} rippleRef
* @return {?}
*/
fadeOutRipple(rippleRef) {
/** @type {?} */
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;
}
/** @type {?} */
const rippleEl = rippleRef.element;
/** @type {?} */
const animationConfig = Object.assign(Object.assign({}, defaultRippleAnimationConfig), rippleRef.config.animation);
rippleEl.style.transitionDuration = `${animationConfig.exitDuration}ms`;
rippleEl.style.opacity = '0';
rippleRef.state = RippleState.FADING_OUT;
// Once the ripple faded out, the ripple can be safely removed from the DOM.
this._runTimeoutOutsideZone((/**
* @return {?}
*/
() => {
rippleRef.state = RippleState.HIDDEN;
(/** @type {?} */ (rippleEl.parentNode)).removeChild(rippleEl);
}), animationConfig.exitDuration);
}
/**
* Fades out all currently active ripples.
* @return {?}
*/
fadeOutAll() {
this._activeRipples.forEach((/**
* @param {?} ripple
* @return {?}
*/
ripple => ripple.fadeOut()));
}
/**
* Sets up the trigger event listeners
* @param {?} elementOrElementRef
* @return {?}
*/
setupTriggerEvents(elementOrElementRef) {
/** @type {?} */
const element = coerceElement(elementOrElementRef);
if (!element || element === this._triggerElement) {
return;
}
// Remove all previously registered event listeners from the trigger element.
this._removeTriggerEvents();
this._ngZone.runOutsideAngular((/**
* @return {?}
*/
() => {
this._triggerEvents.forEach((/**
* @param {?} fn
* @param {?} type
* @return {?}
*/
(fn, type) => {
element.addEventListener(type, fn, passiveEventOptions);
}));
}));
this._triggerElement = element;
}
/**
* Runs a timeout outside of the Angular zone to avoid triggering the change detection.
* @private
* @param {?} fn
* @param {?=} delay
* @return {?}
*/
_runTimeoutOutsideZone(fn, delay = 0) {
this._ngZone.runOutsideAngular((/**
* @return {?}
*/
() => setTimeout(fn, delay)));
}
/**
* Removes previously registered event listeners from the trigger element.
* @return {?}
*/
_removeTriggerEvents() {
if (this._triggerElement) {
this._triggerEvents.forEach((/**
* @param {?} fn
* @param {?} type
* @return {?}
*/
(fn, type) => {
(/** @type {?} */ (this._triggerElement)).removeEventListener(type, fn, passiveEventOptions);
}));
}
}
}
if (false) {
/**
* Element where the ripples are being added to.
* @type {?}
* @private
*/
RippleRenderer.prototype._containerElement;
/**
* Element which triggers the ripple elements on mouse events.
* @type {?}
* @private
*/
RippleRenderer.prototype._triggerElement;
/**
* Whether the pointer is currently down or not.
* @type {?}
* @private
*/
RippleRenderer.prototype._isPointerDown;
/**
* Events to be registered on the trigger element.
* @type {?}
* @private
*/
RippleRenderer.prototype._triggerEvents;
/**
* Set of currently active ripple references.
* @type {?}
* @private
*/
RippleRenderer.prototype._activeRipples;
/**
* Latest non-persistent ripple that was triggered.
* @type {?}
* @private
*/
RippleRenderer.prototype._mostRecentTransientRipple;
/**
* Time in milliseconds when the last touchstart event happened.
* @type {?}
* @private
*/
RippleRenderer.prototype._lastTouchStartEvent;
/**
* Cached dimensions of the ripple container. Set when the first
* ripple is shown and cleared once no more ripples are visible.
* @type {?}
* @private
*/
RippleRenderer.prototype._containerRect;
/**
* Function being called whenever the trigger is being pressed using mouse.
* @type {?}
* @private
*/
RippleRenderer.prototype._onMousedown;
/**
* Function being called whenever the trigger is being pressed using touch.
* @type {?}
* @private
*/
RippleRenderer.prototype._onTouchStart;
/**
* Function being called whenever the trigger is being released.
* @type {?}
* @private
*/
RippleRenderer.prototype._onPointerUp;
/**
* @type {?}
* @private
*/
RippleRenderer.prototype._target;
/**
* @type {?}
* @private
*/
RippleRenderer.prototype._ngZone;
}
/**
* Enforces a style recalculation of a DOM element by computing its styles.
* @param {?} element
* @return {?}
*/
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.
* @param {?} x
* @param {?} y
* @param {?} rect
* @return {?}
*/
function distanceToFurthestCorner(x, y, rect) {
/** @type {?} */
const distX = Math.max(Math.abs(x - rect.left), Math.abs(x - rect.right));
/** @type {?} */
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":";;;;;AAQA,OAAO,EAAW,+BAA+B,EAAC,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAC,+BAA+B,EAAC,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAC,aAAa,EAAC,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAC,SAAS,EAAE,WAAW,EAAC,MAAM,cAAc,CAAC;;;;;;AAepD,2CAKC;;;;;;IAHC,8CAAuB;;;;;IAEvB,6CAAsB;;;;;;;;AAQxB,kCAKC;;;;;;IAHC,oCAA2B;;;;;IAE3B,sCAAwB;;;;;;;AAO1B,MAAM,OAAO,4BAA4B,GAAG;IAC1C,aAAa,EAAE,GAAG;IAClB,YAAY,EAAE,GAAG;CAClB;;;;;;MAMK,wBAAwB,GAAG,GAAG;;;;;MAG9B,mBAAmB,GAAG,+BAA+B,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;;;;;;;;AAS5E,MAAM,OAAO,cAAc;;;;;;;IA4BzB,YAAoB,OAAqB,EACrB,OAAe,EACvB,mBAA0D,EAC1D,QAAkB;QAHV,YAAO,GAAP,OAAO,CAAc;QACrB,YAAO,GAAP,OAAO,CAAQ;;;;QArB3B,mBAAc,GAAG,KAAK,CAAC;;;;QAGvB,mBAAc,GAAG,IAAI,GAAG,EAAe,CAAC;;;;QAGxC,mBAAc,GAAG,IAAI,GAAG,EAAa,CAAC;;;;QAyKtC,iBAAY;;;;QAAG,CAAC,KAAiB,EAAE,EAAE;;;;kBAGrC,eAAe,GAAG,+BAA+B,CAAC,KAAK,CAAC;;kBACxD,gBAAgB,GAAG,IAAI,CAAC,oBAAoB;gBAC9C,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,oBAAoB,GAAG,wBAAwB;YAErE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,IAAI,CAAC,eAAe,IAAI,CAAC,gBAAgB,EAAE;gBACzE,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;gBAC3B,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;aAC5E;QACH,CAAC,EAAA;;;;QAGO,kBAAa;;;;QAAG,CAAC,KAAiB,EAAE,EAAE;YAC5C,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE;gBAChC,oFAAoF;gBACpF,oFAAoF;gBACpF,iCAAiC;gBACjC,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;gBACvC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;;;;sBAIrB,OAAO,GAAG,KAAK,CAAC,cAAc;gBAEpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBACvC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;iBACtF;aACF;QACH,CAAC,EAAA;;;;QAGO,iBAAY;;;QAAG,GAAG,EAAE;YAC1B,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE;gBACxB,OAAO;aACR;YAED,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;YAE5B,4DAA4D;YAC5D,IAAI,CAAC,cAAc,CAAC,OAAO;;;;YAAC,MAAM,CAAC,EAAE;;;;sBAG7B,SAAS,GAAG,MAAM,CAAC,KAAK,KAAK,WAAW,CAAC,OAAO;oBACpD,MAAM,CAAC,MAAM,CAAC,oBAAoB,IAAI,MAAM,CAAC,KAAK,KAAK,WAAW,CAAC,SAAS;gBAE9E,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,IAAI,SAAS,EAAE;oBAC1C,MAAM,CAAC,OAAO,EAAE,CAAC;iBAClB;YACH,CAAC,EAAC,CAAC;QACL,CAAC,EAAA;QAzMC,4CAA4C;QAC5C,IAAI,QAAQ,CAAC,SAAS,EAAE;YACtB,IAAI,CAAC,iBAAiB,GAAG,aAAa,CAAC,mBAAmB,CAAC,CAAC;YAE5D,6DAA6D;YAC7D,IAAI,CAAC,cAAc;iBAChB,GAAG,CAAC,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC;iBACnC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC;iBACjC,GAAG,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC;iBAEpC,GAAG,CAAC,YAAY,EAAE,IAAI,CAAC,aAAa,CAAC;iBACrC,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC;iBAClC,GAAG,CAAC,aAAa,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;SAC1C;IACH,CAAC;;;;;;;;IAQD,YAAY,CAAC,CAAS,EAAE,CAAS,EAAE,SAAuB,EAAE;;cACpD,aAAa,GAAG,IAAI,CAAC,cAAc;YACnB,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,iBAAiB,CAAC,qBAAqB,EAAE;;cACrF,eAAe,mCAAO,4BAA4B,GAAK,MAAM,CAAC,SAAS,CAAC;QAE9E,IAAI,MAAM,CAAC,QAAQ,EAAE;YACnB,CAAC,GAAG,aAAa,CAAC,IAAI,GAAG,aAAa,CAAC,KAAK,GAAG,CAAC,CAAC;YACjD,CAAC,GAAG,aAAa,CAAC,GAAG,GAAG,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC;SAClD;;cAEK,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,wBAAwB,CAAC,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC;;cACvE,OAAO,GAAG,CAAC,GAAG,aAAa,CAAC,IAAI;;cAChC,OAAO,GAAG,CAAC,GAAG,aAAa,CAAC,GAAG;;cAC/B,QAAQ,GAAG,eAAe,CAAC,aAAa;;cAExC,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC;QAC5C,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;QAE3C,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,GAAG,OAAO,GAAG,MAAM,IAAI,CAAC;QAC5C,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,OAAO,GAAG,MAAM,IAAI,CAAC;QAC3C,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC;QACxC,MAAM,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC;QAEvC,+EAA+E;QAC/E,0EAA0E;QAC1E,IAAI,MAAM,CAAC,KAAK,IAAI,IAAI,EAAE;YACxB,MAAM,CAAC,KAAK,CAAC,eAAe,GAAG,MAAM,CAAC,KAAK,CAAC;SAC7C;QAED,MAAM,CAAC,KAAK,CAAC,kBAAkB,GAAG,GAAG,QAAQ,IAAI,CAAC;QAElD,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAE3C,gFAAgF;QAChF,yFAAyF;QACzF,yBAAyB,CAAC,MAAM,CAAC,CAAC;QAElC,MAAM,CAAC,KAAK,CAAC,SAAS,GAAG,UAAU,CAAC;;;cAG9B,SAAS,GAAG,IAAI,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC;QAErD,SAAS,CAAC,KAAK,GAAG,WAAW,CAAC,SAAS,CAAC;QAExC,8DAA8D;QAC9D,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAEnC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE;YACtB,IAAI,CAAC,0BAA0B,GAAG,SAAS,CAAC;SAC7C;QAED,yDAAyD;QACzD,qFAAqF;QACrF,IAAI,CAAC,sBAAsB;;;QAAC,GAAG,EAAE;;kBACzB,2BAA2B,GAAG,SAAS,KAAK,IAAI,CAAC,0BAA0B;YAEjF,SAAS,CAAC,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC;YAEtC,iFAAiF;YACjF,gFAAgF;YAChF,8EAA8E;YAC9E,0BAA0B;YAC1B,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,CAAC,CAAC,2BAA2B,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE;gBAChF,SAAS,CAAC,OAAO,EAAE,CAAC;aACrB;QACH,CAAC,GAAE,QAAQ,CAAC,CAAC;QAEb,OAAO,SAAS,CAAC;IACnB,CAAC;;;;;;IAGD,aAAa,CAAC,SAAoB;;cAC1B,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,SAAS,CAAC;QAEvD,IAAI,SAAS,KAAK,IAAI,CAAC,0BAA0B,EAAE;YACjD,IAAI,CAAC,0BAA0B,GAAG,IAAI,CAAC;SACxC;QAED,iEAAiE;QACjE,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE;YAC7B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;SAC5B;QAED,gFAAgF;QAChF,IAAI,CAAC,SAAS,EAAE;YACd,OAAO;SACR;;cAEK,QAAQ,GAAG,SAAS,CAAC,OAAO;;cAC5B,eAAe,mCAAO,4BAA4B,GAAK,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC;QAExF,QAAQ,CAAC,KAAK,CAAC,kBAAkB,GAAG,GAAG,eAAe,CAAC,YAAY,IAAI,CAAC;QACxE,QAAQ,CAAC,KAAK,CAAC,OAAO,GAAG,GAAG,CAAC;QAC7B,SAAS,CAAC,KAAK,GAAG,WAAW,CAAC,UAAU,CAAC;QAEzC,4EAA4E;QAC5E,IAAI,CAAC,sBAAsB;;;QAAC,GAAG,EAAE;YAC/B,SAAS,CAAC,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC;YACrC,mBAAA,QAAQ,CAAC,UAAU,EAAC,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QAC7C,CAAC,GAAE,eAAe,CAAC,YAAY,CAAC,CAAC;IACnC,CAAC;;;;;IAGD,UAAU;QACR,IAAI,CAAC,cAAc,CAAC,OAAO;;;;QAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,EAAC,CAAC;IAC1D,CAAC;;;;;;IAGD,kBAAkB,CAAC,mBAA0D;;cACrE,OAAO,GAAG,aAAa,CAAC,mBAAmB,CAAC;QAElD,IAAI,CAAC,OAAO,IAAI,OAAO,KAAK,IAAI,CAAC,eAAe,EAAE;YAChD,OAAO;SACR;QAED,6EAA6E;QAC7E,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAE5B,IAAI,CAAC,OAAO,CAAC,iBAAiB;;;QAAC,GAAG,EAAE;YAClC,IAAI,CAAC,cAAc,CAAC,OAAO;;;;;YAAC,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE;gBACvC,OAAO,CAAC,gBAAgB,CAAC,IAAI,EAAE,EAAE,EAAE,mBAAmB,CAAC,CAAC;YAC1D,CAAC,EAAC,CAAC;QACL,CAAC,EAAC,CAAC;QAEH,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC;IACjC,CAAC;;;;;;;;IAyDO,sBAAsB,CAAC,EAAY,EAAE,KAAK,GAAG,CAAC;QACpD,IAAI,CAAC,OAAO,CAAC,iBAAiB;;;QAAC,GAAG,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,KAAK,CAAC,EAAC,CAAC;IAC9D,CAAC;;;;;IAGD,oBAAoB;QAClB,IAAI,IAAI,CAAC,eAAe,EAAE;YACxB,IAAI,CAAC,cAAc,CAAC,OAAO;;;;;YAAC,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE;gBACvC,mBAAA,IAAI,CAAC,eAAe,EAAC,CAAC,mBAAmB,CAAC,IAAI,EAAE,EAAE,EAAE,mBAAmB,CAAC,CAAC;YAC3E,CAAC,EAAC,CAAC;SACJ;IACH,CAAC;CACF;;;;;;;IAvPC,2CAAuC;;;;;;IAGvC,yCAA4C;;;;;;IAG5C,wCAA+B;;;;;;IAG/B,wCAAgD;;;;;;IAGhD,wCAA8C;;;;;;IAG9C,oDAAqD;;;;;;IAGrD,8CAAqC;;;;;;;IAMrC,wCAA0C;;;;;;IA6J1C,sCAWC;;;;;;IAGD,uCAgBC;;;;;;IAGD,sCAkBC;;;;;IA9MW,iCAA6B;;;;;IAC7B,iCAAuB;;;;;;;AA+NrC,SAAS,yBAAyB,CAAC,OAAoB;IACrD,0FAA0F;IAC1F,0FAA0F;IAC1F,8DAA8D;IAC9D,MAAM,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;AAC/D,CAAC;;;;;;;;AAKD,SAAS,wBAAwB,CAAC,CAAS,EAAE,CAAS,EAAE,IAAgB;;UAChE,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;;UACnE,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IACzE,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC,CAAC;AAClD,CAAC","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"]}