@angular/material 9.1.3 → 9.2.2

package/esm5/core/ripple/ripple-renderer.js

@@ -18,6 +18,10 @@ export var defaultRippleAnimationConfig = {
 var ignoreMouseEventsTimeout = 800;
 /** Options that apply to all the event listeners that are bound by the ripple renderer. */
 var passiveEventOptions = normalizePassiveListenerOptions({ passive: true });
+/** Events that signal that the pointer is down. */
+var pointerDownEvents = ['mousedown', 'touchstart'];
+/** Events that signal that the pointer is up. */
+var 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
@@ -27,71 +31,17 @@ var passiveEventOptions = normalizePassiveListenerOptions({ passive: true });
  */
 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();
-                }
-            });
-        };
+        /** 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);
-            // 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);
         }
     }
     /**
@@ -185,32 +135,108 @@ var RippleRenderer = /** @class */ (function () {
     };
     /** 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;
+        this._registerEvents(pointerDownEvents);
+    };
+    /**
+     * Handles all registered events.
+     * @docs-private
+     */
+    RippleRenderer.prototype.handleEvent = function (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. */
+    RippleRenderer.prototype._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. */
+    RippleRenderer.prototype._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. */
+    RippleRenderer.prototype._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();
+            }
+        });
     };
     /** 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); });
     };
+    /** Registers event listeners for a given list of events. */
+    RippleRenderer.prototype._registerEvents = function (eventTypes) {
+        var _this = this;
+        this._ngZone.runOutsideAngular(function () {
+            eventTypes.forEach(function (type) {
+                _this._triggerElement.addEventListener(type, _this, passiveEventOptions);
+            });
+        });
+    };
     /** 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);
+            pointerDownEvents.forEach(function (type) {
+                _this._triggerElement.removeEventListener(type, _this, passiveEventOptions);
             });
+            if (this._pointerUpEventsRegistered) {
+                pointerUpEvents.forEach(function (type) {
+                    _this._triggerElement.removeEventListener(type, _this, passiveEventOptions);
+                });
+            }
         }
     };
     return RippleRenderer;
@@ -231,4 +257,4 @@ function distanceToFurthestCorner(x, y, rect) {
     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"]}
+//# 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/** 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(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.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._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 = 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  /** 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"]}

package/esm5/core/ripple/ripple.js

@@ -13,8 +13,9 @@ import { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';
 /** Injection token that can be used to specify the global ripple options. */
 export var MAT_RIPPLE_GLOBAL_OPTIONS = new InjectionToken('mat-ripple-global-options');
 var MatRipple = /** @class */ (function () {
-    function MatRipple(_elementRef, ngZone, platform, globalOptions, animationMode) {
+    function MatRipple(_elementRef, ngZone, platform, globalOptions, _animationMode) {
         this._elementRef = _elementRef;
+        this._animationMode = _animationMode;
         /**
          * If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius
          * will be the distance from the center of the ripple to the furthest corner of the host element's
@@ -26,9 +27,6 @@ var MatRipple = /** @class */ (function () {
         this._isInitialized = false;
         this._globalOptions = globalOptions || {};
         this._rippleRenderer = new RippleRenderer(this, ngZone, _elementRef, platform);
-        if (animationMode === 'NoopAnimations') {
-            this._globalOptions.animation = { enterDuration: 0, exitDuration: 0 };
-        }
     }
     Object.defineProperty(MatRipple.prototype, "disabled", {
         /**
@@ -77,7 +75,7 @@ var MatRipple = /** @class */ (function () {
                 centered: this.centered,
                 radius: this.radius,
                 color: this.color,
-                animation: __assign(__assign({}, this._globalOptions.animation), this.animation),
+                animation: __assign(__assign(__assign({}, this._globalOptions.animation), (this._animationMode === 'NoopAnimations' ? { enterDuration: 0, exitDuration: 0 } : {})), this.animation),
                 terminateOnPointerUp: this._globalOptions.terminateOnPointerUp,
             };
         },
@@ -141,4 +139,4 @@ var MatRipple = /** @class */ (function () {
     return MatRipple;
 }());
 export { MatRipple };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ripple.js","sourceRoot":"","sources":["../../../../../../../../../../../src/material/core/ripple/ripple.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 {Platform} from '@angular/cdk/platform';\nimport {\n  Directive,\n  ElementRef,\n  Inject,\n  InjectionToken,\n  Input,\n  NgZone,\n  OnDestroy,\n  OnInit,\n  Optional,\n} from '@angular/core';\nimport {RippleRef} from './ripple-ref';\nimport {RippleAnimationConfig, RippleConfig, RippleRenderer, RippleTarget} from './ripple-renderer';\nimport {ANIMATION_MODULE_TYPE} from '@angular/platform-browser/animations';\n\n/** Configurable options for `matRipple`. */\nexport interface RippleGlobalOptions {\n  /**\n   * Whether ripples should be disabled. Ripples can be still launched manually by using\n   * the `launch()` method. Therefore focus indicators will still show up.\n   */\n  disabled?: boolean;\n\n  /**\n   * Configuration for the animation duration of the ripples. There are two phases with different\n   * durations for the ripples. The animation durations will be overwritten if the\n   * `NoopAnimationsModule` is being used.\n   */\n  animation?: RippleAnimationConfig;\n\n  /**\n   * Whether ripples should start fading out immediately after the mouse or touch is released. By\n   * default, ripples will wait for the enter animation to complete and for mouse or touch release.\n   */\n  terminateOnPointerUp?: boolean;\n}\n\n/** Injection token that can be used to specify the global ripple options. */\nexport const MAT_RIPPLE_GLOBAL_OPTIONS =\n    new InjectionToken<RippleGlobalOptions>('mat-ripple-global-options');\n\n@Directive({\n  selector: '[mat-ripple], [matRipple]',\n  exportAs: 'matRipple',\n  host: {\n    'class': 'mat-ripple',\n    '[class.mat-ripple-unbounded]': 'unbounded'\n  }\n})\nexport class MatRipple implements OnInit, OnDestroy, RippleTarget {\n\n  /** Custom color for all ripples. */\n  @Input('matRippleColor') color: string;\n\n  /** Whether the ripples should be visible outside the component's bounds. */\n  @Input('matRippleUnbounded') unbounded: boolean;\n\n  /**\n   * Whether the ripple always originates from the center of the host element's bounds, rather\n   * than originating from the location of the click event.\n   */\n  @Input('matRippleCentered') centered: boolean;\n\n  /**\n   * If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius\n   * will be the distance from the center of the ripple to the furthest corner of the host element's\n   * bounding rectangle.\n   */\n  @Input('matRippleRadius') radius: number = 0;\n\n  /**\n   * Configuration for the ripple animation. Allows modifying the enter and exit animation\n   * duration of the ripples. The animation durations will be overwritten if the\n   * `NoopAnimationsModule` is being used.\n   */\n  @Input('matRippleAnimation') animation: RippleAnimationConfig;\n\n  /**\n   * Whether click events will not trigger the ripple. Ripples can be still launched manually\n   * by using the `launch()` method.\n   */\n  @Input('matRippleDisabled')\n  get disabled() { return this._disabled; }\n  set disabled(value: boolean) {\n    this._disabled = value;\n    this._setupTriggerEventsIfEnabled();\n  }\n  private _disabled: boolean = false;\n\n  /**\n   * The element that triggers the ripple when click events are received.\n   * Defaults to the directive's host element.\n   */\n  @Input('matRippleTrigger')\n  get trigger() { return this._trigger || this._elementRef.nativeElement; }\n  set trigger(trigger: HTMLElement) {\n    this._trigger = trigger;\n    this._setupTriggerEventsIfEnabled();\n  }\n  private _trigger: HTMLElement;\n\n  /** Renderer for the ripple DOM manipulations. */\n  private _rippleRenderer: RippleRenderer;\n\n  /** Options that are set globally for all ripples. */\n  private _globalOptions: RippleGlobalOptions;\n\n  /** Whether ripple directive is initialized and the input bindings are set. */\n  private _isInitialized: boolean = false;\n\n  constructor(private _elementRef: ElementRef<HTMLElement>,\n              ngZone: NgZone,\n              platform: Platform,\n              @Optional() @Inject(MAT_RIPPLE_GLOBAL_OPTIONS) globalOptions?: RippleGlobalOptions,\n              @Optional() @Inject(ANIMATION_MODULE_TYPE) animationMode?: string) {\n\n    this._globalOptions = globalOptions || {};\n    this._rippleRenderer = new RippleRenderer(this, ngZone, _elementRef, platform);\n\n    if (animationMode === 'NoopAnimations') {\n      this._globalOptions.animation = {enterDuration: 0, exitDuration: 0};\n    }\n  }\n\n  ngOnInit() {\n    this._isInitialized = true;\n    this._setupTriggerEventsIfEnabled();\n  }\n\n  ngOnDestroy() {\n    this._rippleRenderer._removeTriggerEvents();\n  }\n\n  /** Fades out all currently showing ripple elements. */\n  fadeOutAll() {\n    this._rippleRenderer.fadeOutAll();\n  }\n\n  /**\n   * Ripple configuration from the directive's input values.\n   * @docs-private Implemented as part of RippleTarget\n   */\n  get rippleConfig(): RippleConfig {\n    return {\n      centered: this.centered,\n      radius: this.radius,\n      color: this.color,\n      animation: {...this._globalOptions.animation, ...this.animation},\n      terminateOnPointerUp: this._globalOptions.terminateOnPointerUp,\n    };\n  }\n\n  /**\n   * Whether ripples on pointer-down are disabled or not.\n   * @docs-private Implemented as part of RippleTarget\n   */\n  get rippleDisabled(): boolean {\n    return this.disabled || !!this._globalOptions.disabled;\n  }\n\n  /** Sets up the trigger event listeners if ripples are enabled. */\n  private _setupTriggerEventsIfEnabled() {\n    if (!this.disabled && this._isInitialized) {\n      this._rippleRenderer.setupTriggerEvents(this.trigger);\n    }\n  }\n\n  /**\n   * Launches a manual ripple using the specified ripple configuration.\n   * @param config Configuration for the manual ripple.\n   */\n  launch(config: RippleConfig): RippleRef;\n\n  /**\n   * Launches a manual ripple at the specified coordinates within the element.\n   * @param x Coordinate within the element, along the X axis at which to fade-in the ripple.\n   * @param y Coordinate within the element, along the Y axis at which to fade-in the ripple.\n   * @param config Optional ripple configuration for the manual ripple.\n   */\n  launch(x: number, y: number, config?: RippleConfig): RippleRef;\n\n  /** Launches a manual ripple at the specified coordinated or just by the ripple config. */\n  launch(configOrX: number | RippleConfig, y: number = 0, config?: RippleConfig): RippleRef {\n    if (typeof configOrX === 'number') {\n      return this._rippleRenderer.fadeInRipple(configOrX, y, {...this.rippleConfig, ...config});\n    } else {\n      return this._rippleRenderer.fadeInRipple(0, 0, {...this.rippleConfig, ...configOrX});\n    }\n  }\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ripple.js","sourceRoot":"","sources":["../../../../../../../../../../../src/material/core/ripple/ripple.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 {Platform} from '@angular/cdk/platform';\nimport {\n  Directive,\n  ElementRef,\n  Inject,\n  InjectionToken,\n  Input,\n  NgZone,\n  OnDestroy,\n  OnInit,\n  Optional,\n} from '@angular/core';\nimport {RippleRef} from './ripple-ref';\nimport {RippleAnimationConfig, RippleConfig, RippleRenderer, RippleTarget} from './ripple-renderer';\nimport {ANIMATION_MODULE_TYPE} from '@angular/platform-browser/animations';\n\n/** Configurable options for `matRipple`. */\nexport interface RippleGlobalOptions {\n  /**\n   * Whether ripples should be disabled. Ripples can be still launched manually by using\n   * the `launch()` method. Therefore focus indicators will still show up.\n   */\n  disabled?: boolean;\n\n  /**\n   * Configuration for the animation duration of the ripples. There are two phases with different\n   * durations for the ripples. The animation durations will be overwritten if the\n   * `NoopAnimationsModule` is being used.\n   */\n  animation?: RippleAnimationConfig;\n\n  /**\n   * Whether ripples should start fading out immediately after the mouse or touch is released. By\n   * default, ripples will wait for the enter animation to complete and for mouse or touch release.\n   */\n  terminateOnPointerUp?: boolean;\n}\n\n/** Injection token that can be used to specify the global ripple options. */\nexport const MAT_RIPPLE_GLOBAL_OPTIONS =\n    new InjectionToken<RippleGlobalOptions>('mat-ripple-global-options');\n\n@Directive({\n  selector: '[mat-ripple], [matRipple]',\n  exportAs: 'matRipple',\n  host: {\n    'class': 'mat-ripple',\n    '[class.mat-ripple-unbounded]': 'unbounded'\n  }\n})\nexport class MatRipple implements OnInit, OnDestroy, RippleTarget {\n\n  /** Custom color for all ripples. */\n  @Input('matRippleColor') color: string;\n\n  /** Whether the ripples should be visible outside the component's bounds. */\n  @Input('matRippleUnbounded') unbounded: boolean;\n\n  /**\n   * Whether the ripple always originates from the center of the host element's bounds, rather\n   * than originating from the location of the click event.\n   */\n  @Input('matRippleCentered') centered: boolean;\n\n  /**\n   * If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius\n   * will be the distance from the center of the ripple to the furthest corner of the host element's\n   * bounding rectangle.\n   */\n  @Input('matRippleRadius') radius: number = 0;\n\n  /**\n   * Configuration for the ripple animation. Allows modifying the enter and exit animation\n   * duration of the ripples. The animation durations will be overwritten if the\n   * `NoopAnimationsModule` is being used.\n   */\n  @Input('matRippleAnimation') animation: RippleAnimationConfig;\n\n  /**\n   * Whether click events will not trigger the ripple. Ripples can be still launched manually\n   * by using the `launch()` method.\n   */\n  @Input('matRippleDisabled')\n  get disabled() { return this._disabled; }\n  set disabled(value: boolean) {\n    this._disabled = value;\n    this._setupTriggerEventsIfEnabled();\n  }\n  private _disabled: boolean = false;\n\n  /**\n   * The element that triggers the ripple when click events are received.\n   * Defaults to the directive's host element.\n   */\n  @Input('matRippleTrigger')\n  get trigger() { return this._trigger || this._elementRef.nativeElement; }\n  set trigger(trigger: HTMLElement) {\n    this._trigger = trigger;\n    this._setupTriggerEventsIfEnabled();\n  }\n  private _trigger: HTMLElement;\n\n  /** Renderer for the ripple DOM manipulations. */\n  private _rippleRenderer: RippleRenderer;\n\n  /** Options that are set globally for all ripples. */\n  private _globalOptions: RippleGlobalOptions;\n\n  /** Whether ripple directive is initialized and the input bindings are set. */\n  private _isInitialized: boolean = false;\n\n  constructor(private _elementRef: ElementRef<HTMLElement>,\n              ngZone: NgZone,\n              platform: Platform,\n              @Optional() @Inject(MAT_RIPPLE_GLOBAL_OPTIONS) globalOptions?: RippleGlobalOptions,\n              @Optional() @Inject(ANIMATION_MODULE_TYPE) private _animationMode?: string) {\n\n    this._globalOptions = globalOptions || {};\n    this._rippleRenderer = new RippleRenderer(this, ngZone, _elementRef, platform);\n  }\n\n  ngOnInit() {\n    this._isInitialized = true;\n    this._setupTriggerEventsIfEnabled();\n  }\n\n  ngOnDestroy() {\n    this._rippleRenderer._removeTriggerEvents();\n  }\n\n  /** Fades out all currently showing ripple elements. */\n  fadeOutAll() {\n    this._rippleRenderer.fadeOutAll();\n  }\n\n  /**\n   * Ripple configuration from the directive's input values.\n   * @docs-private Implemented as part of RippleTarget\n   */\n  get rippleConfig(): RippleConfig {\n    return {\n      centered: this.centered,\n      radius: this.radius,\n      color: this.color,\n      animation: {\n        ...this._globalOptions.animation,\n        ...(this._animationMode === 'NoopAnimations' ? {enterDuration: 0, exitDuration: 0} : {}),\n        ...this.animation\n      },\n      terminateOnPointerUp: this._globalOptions.terminateOnPointerUp,\n    };\n  }\n\n  /**\n   * Whether ripples on pointer-down are disabled or not.\n   * @docs-private Implemented as part of RippleTarget\n   */\n  get rippleDisabled(): boolean {\n    return this.disabled || !!this._globalOptions.disabled;\n  }\n\n  /** Sets up the trigger event listeners if ripples are enabled. */\n  private _setupTriggerEventsIfEnabled() {\n    if (!this.disabled && this._isInitialized) {\n      this._rippleRenderer.setupTriggerEvents(this.trigger);\n    }\n  }\n\n  /**\n   * Launches a manual ripple using the specified ripple configuration.\n   * @param config Configuration for the manual ripple.\n   */\n  launch(config: RippleConfig): RippleRef;\n\n  /**\n   * Launches a manual ripple at the specified coordinates within the element.\n   * @param x Coordinate within the element, along the X axis at which to fade-in the ripple.\n   * @param y Coordinate within the element, along the Y axis at which to fade-in the ripple.\n   * @param config Optional ripple configuration for the manual ripple.\n   */\n  launch(x: number, y: number, config?: RippleConfig): RippleRef;\n\n  /** Launches a manual ripple at the specified coordinated or just by the ripple config. */\n  launch(configOrX: number | RippleConfig, y: number = 0, config?: RippleConfig): RippleRef {\n    if (typeof configOrX === 'number') {\n      return this._rippleRenderer.fadeInRipple(configOrX, y, {...this.rippleConfig, ...config});\n    } else {\n      return this._rippleRenderer.fadeInRipple(0, 0, {...this.rippleConfig, ...configOrX});\n    }\n  }\n}\n\n"]}

package/esm5/core/version.js

@@ -7,5 +7,5 @@
  */
 import { Version } from '@angular/core';
 /** Current version of Angular Material. */
-export var VERSION = new Version('9.1.3');
+export var VERSION = new Version('9.2.2');
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9tYXRlcmlhbC9jb3JlL3ZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLE9BQU8sRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUV0QywyQ0FBMkM7QUFDM0MsTUFBTSxDQUFDLElBQU0sT0FBTyxHQUFHLElBQUksT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtWZXJzaW9ufSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqIEN1cnJlbnQgdmVyc2lvbiBvZiBBbmd1bGFyIE1hdGVyaWFsLiAqL1xuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBuZXcgVmVyc2lvbignMC4wLjAtUExBQ0VIT0xERVInKTtcbiJdfQ==

package/esm5/datepicker/calendar-body.js

@@ -93,7 +93,7 @@ var MatCalendarBody = /** @class */ (function () {
                     exportAs: 'matCalendarBody',
                     encapsulation: ViewEncapsulation.None,
                     changeDetection: ChangeDetectionStrategy.OnPush,
-                    styles: [".mat-calendar-body{min-width:224px}.mat-calendar-body-label{height:0;line-height:0;text-align:left;padding-left:4.7142857143%;padding-right:4.7142857143%}.mat-calendar-body-cell{position:relative;height:0;line-height:0;text-align:center;outline:none;cursor:pointer}.mat-calendar-body-disabled{cursor:default}.mat-calendar-body-cell-content{position:absolute;top:5%;left:5%;display:flex;align-items:center;justify-content:center;box-sizing:border-box;width:90%;height:90%;line-height:1;border-width:1px;border-style:solid;border-radius:999px}.cdk-high-contrast-active .mat-calendar-body-cell-content{border:none}.cdk-high-contrast-active .mat-datepicker-popup:not(:empty),.cdk-high-contrast-active .mat-calendar-body-selected{outline:solid 1px}.cdk-high-contrast-active .mat-calendar-body-today{outline:dotted 1px}.cdk-high-contrast-active .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected),.cdk-high-contrast-active .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected){outline:dotted 2px}[dir=rtl] .mat-calendar-body-label{text-align:right}\n"]
+                    styles: [".mat-calendar-body{min-width:224px}.mat-calendar-body-label{height:0;line-height:0;text-align:left;padding-left:4.7142857143%;padding-right:4.7142857143%}.mat-calendar-body-cell{position:relative;height:0;line-height:0;text-align:center;outline:none;cursor:pointer}.mat-calendar-body-disabled{cursor:default}.mat-calendar-body-cell-content{position:absolute;top:5%;left:5%;display:flex;align-items:center;justify-content:center;box-sizing:border-box;width:90%;height:90%;line-height:1;border-width:1px;border-style:solid;border-radius:999px}.cdk-high-contrast-active .mat-calendar-body-cell-content{border:none}.cdk-high-contrast-active .mat-datepicker-popup:not(:empty),.cdk-high-contrast-active .mat-calendar-body-selected{outline:solid 1px}.cdk-high-contrast-active .mat-calendar-body-today{outline:dotted 1px}.cdk-high-contrast-active .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected),.cdk-high-contrast-active .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected){outline:dotted 2px}[dir=rtl] .mat-calendar-body-label{text-align:right}@media(hover: none){.mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected){background-color:transparent}}\n"]
                 }] }
     ];
     /** @nocollapse */