@colijnit/corecomponents_v12 12.2.20 → 12.2.22

package/esm2015/lib/directives/ripple/ripple-renderer.js

@@ -1,160 +1,160 @@
-// NOTE: Copied and adapted to CoreComponents from iOneJS on 9-may-2018.
-import { CoRippleRef, CoRippleState } from "./ripple-ref";
-/** Fade-in duration for the ripples. Can be modified with the speedFactor option. */
-export const RIPPLE_FADE_IN_DURATION = 450;
-/** Fade-out duration for the ripples in milliseconds. This can't be modified by the speedFactor. */
-export const RIPPLE_FADE_OUT_DURATION = 400;
-/**
- * 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 CoRippleRenderer {
-    constructor(_elementRef, _ngZone, _ruler) {
-        this._ngZone = _ngZone;
-        this._ruler = _ruler;
-        /** Whether the mouse is currently down or not. */
-        this._isMousedown = false;
-        /** Events to be registered on the trigger element. */
-        this._triggerEvents = new Map();
-        /** Set of currently active ripple references. */
-        this._activeRipples = new Set();
-        /** Ripple config for all ripples created by events. */
-        this.rippleConfig = {};
-        /** Whether mouse ripples should be created or not. */
-        this.rippleDisabled = false;
-        this._containerElement = _elementRef.nativeElement;
-        // Specify events which need to be registered on the trigger.
-        this._triggerEvents.set('mousedown', this.onMousedown.bind(this));
-        this._triggerEvents.set('mouseup', this.onMouseup.bind(this));
-        this._triggerEvents.set('mouseleave', this.onMouseLeave.bind(this));
-        // By default use the host element as trigger element.
-        this.setTriggerElement(this._containerElement);
-    }
-    /** Fades in a ripple at the given coordinates. */
-    fadeInRipple(pageX, pageY, config = {}) {
-        let containerRect = this._containerElement.getBoundingClientRect();
-        if (config.centered) {
-            pageX = containerRect.left + containerRect.width / 2;
-            pageY = containerRect.top + containerRect.height / 2;
-        }
-        else {
-            // Subtract scroll values from the coordinates because calculations below
-            // are always relative to the viewport rectangle.
-            let scrollPosition = this._ruler.getViewportScrollPosition();
-            pageX -= scrollPosition.left;
-            pageY -= scrollPosition.top;
-        }
-        let radius = config.radius || distanceToFurthestCorner(pageX, pageY, containerRect);
-        let duration = RIPPLE_FADE_IN_DURATION * (1 / (config.speedFactor || 1));
-        let offsetX = pageX - containerRect.left;
-        let offsetY = pageY - containerRect.top;
-        let 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 the color is not set, the default CSS color will be used.
-        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.
-        let rippleRef = new CoRippleRef(this, ripple, config);
-        rippleRef.state = CoRippleState.FADING_IN;
-        // Add the ripple reference to the list of all active ripples.
-        this._activeRipples.add(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(() => {
-            rippleRef.state = CoRippleState.VISIBLE;
-            if (!config.persistent && !this._isMousedown) {
-                rippleRef.fadeOut();
-            }
-        }, duration);
-        return rippleRef;
-    }
-    /** Fades out a ripple reference. */
-    fadeOutRipple(rippleRef) {
-        // For ripples that are not active anymore, don't re-un the fade-out animation.
-        if (!this._activeRipples.delete(rippleRef)) {
-            return;
-        }
-        let rippleEl = rippleRef.element;
-        rippleEl.style.transitionDuration = `${RIPPLE_FADE_OUT_DURATION}ms`;
-        rippleEl.style.opacity = '0';
-        rippleRef.state = CoRippleState.FADING_OUT;
-        // Once the ripple faded out, the ripple can be safely removed from the DOM.
-        this.runTimeoutOutsideZone(() => {
-            rippleRef.state = CoRippleState.HIDDEN;
-            rippleEl.parentNode.removeChild(rippleEl);
-        }, RIPPLE_FADE_OUT_DURATION);
-    }
-    /** Fades out all currently active ripples. */
-    fadeOutAll() {
-        this._activeRipples.forEach(ripple => ripple.fadeOut());
-    }
-    /** Sets the trigger element and registers the mouse events. */
-    setTriggerElement(element) {
-        // Remove all previously register event listeners from the trigger element.
-        if (this._triggerElement) {
-            this._triggerEvents.forEach((fn, type) => this._triggerElement.removeEventListener(type, fn));
-        }
-        if (element) {
-            // If the element is not null, register all event listeners on the trigger element.
-            this._ngZone.runOutsideAngular(() => {
-                this._triggerEvents.forEach((fn, type) => element.addEventListener(type, fn));
-            });
-        }
-        this._triggerElement = element;
-    }
-    /** Listener being called on mousedown event. */
-    onMousedown(event) {
-        if (!this.rippleDisabled) {
-            this._isMousedown = true;
-            this.fadeInRipple(event.pageX, event.pageY, this.rippleConfig);
-        }
-    }
-    /** Listener being called on mouseup event. */
-    onMouseup() {
-        this._isMousedown = false;
-        // Fade-out all ripples that are completely visible and not persistent.
-        this._activeRipples.forEach(ripple => {
-            if (!ripple.config.persistent && ripple.state === CoRippleState.VISIBLE) {
-                ripple.fadeOut();
-            }
-        });
-    }
-    /** Listener being called on mouseleave event. */
-    onMouseLeave() {
-        if (this._isMousedown) {
-            this.onMouseup();
-        }
-    }
-    /** Runs a timeout outside of the Angular zone to avoid triggering the change detection. */
-    runTimeoutOutsideZone(fn, delay = 0) {
-        this._ngZone.runOutsideAngular(() => setTimeout(fn, delay));
-    }
-}
-/** Enforces a style recalculation of a DOM element by computing its styles. */
-function enforceStyleRecalculation(element) {
-    // Enforce a style recalculation by calling `getComputedStyle` and accessing any property.
-    // Calling `getPropertyValue` is important to let optimizers know that this is not a noop.
-    // See: https://gist.github.com/paulirish/5d52fb081b3570c81e3a
-    window.getComputedStyle(element).getPropertyValue('opacity');
-}
-/**
- * Returns the distance from the point (x, y) to the furthest corner of a rectangle.
- */
-function distanceToFurthestCorner(x, y, rect) {
-    const distX = Math.max(Math.abs(x - rect.left), Math.abs(x - rect.right));
-    const distY = Math.max(Math.abs(y - rect.top), Math.abs(y - rect.bottom));
-    return Math.sqrt(distX * distX + distY * distY);
-}
+// NOTE: Copied and adapted to CoreComponents from iOneJS on 9-may-2018.
+import { CoRippleRef, CoRippleState } from "./ripple-ref";
+/** Fade-in duration for the ripples. Can be modified with the speedFactor option. */
+export const RIPPLE_FADE_IN_DURATION = 450;
+/** Fade-out duration for the ripples in milliseconds. This can't be modified by the speedFactor. */
+export const RIPPLE_FADE_OUT_DURATION = 400;
+/**
+ * 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 CoRippleRenderer {
+    constructor(_elementRef, _ngZone, _ruler) {
+        this._ngZone = _ngZone;
+        this._ruler = _ruler;
+        /** Whether the mouse is currently down or not. */
+        this._isMousedown = false;
+        /** Events to be registered on the trigger element. */
+        this._triggerEvents = new Map();
+        /** Set of currently active ripple references. */
+        this._activeRipples = new Set();
+        /** Ripple config for all ripples created by events. */
+        this.rippleConfig = {};
+        /** Whether mouse ripples should be created or not. */
+        this.rippleDisabled = false;
+        this._containerElement = _elementRef.nativeElement;
+        // Specify events which need to be registered on the trigger.
+        this._triggerEvents.set('mousedown', this.onMousedown.bind(this));
+        this._triggerEvents.set('mouseup', this.onMouseup.bind(this));
+        this._triggerEvents.set('mouseleave', this.onMouseLeave.bind(this));
+        // By default use the host element as trigger element.
+        this.setTriggerElement(this._containerElement);
+    }
+    /** Fades in a ripple at the given coordinates. */
+    fadeInRipple(pageX, pageY, config = {}) {
+        let containerRect = this._containerElement.getBoundingClientRect();
+        if (config.centered) {
+            pageX = containerRect.left + containerRect.width / 2;
+            pageY = containerRect.top + containerRect.height / 2;
+        }
+        else {
+            // Subtract scroll values from the coordinates because calculations below
+            // are always relative to the viewport rectangle.
+            let scrollPosition = this._ruler.getViewportScrollPosition();
+            pageX -= scrollPosition.left;
+            pageY -= scrollPosition.top;
+        }
+        let radius = config.radius || distanceToFurthestCorner(pageX, pageY, containerRect);
+        let duration = RIPPLE_FADE_IN_DURATION * (1 / (config.speedFactor || 1));
+        let offsetX = pageX - containerRect.left;
+        let offsetY = pageY - containerRect.top;
+        let 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 the color is not set, the default CSS color will be used.
+        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.
+        let rippleRef = new CoRippleRef(this, ripple, config);
+        rippleRef.state = CoRippleState.FADING_IN;
+        // Add the ripple reference to the list of all active ripples.
+        this._activeRipples.add(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(() => {
+            rippleRef.state = CoRippleState.VISIBLE;
+            if (!config.persistent && !this._isMousedown) {
+                rippleRef.fadeOut();
+            }
+        }, duration);
+        return rippleRef;
+    }
+    /** Fades out a ripple reference. */
+    fadeOutRipple(rippleRef) {
+        // For ripples that are not active anymore, don't re-un the fade-out animation.
+        if (!this._activeRipples.delete(rippleRef)) {
+            return;
+        }
+        let rippleEl = rippleRef.element;
+        rippleEl.style.transitionDuration = `${RIPPLE_FADE_OUT_DURATION}ms`;
+        rippleEl.style.opacity = '0';
+        rippleRef.state = CoRippleState.FADING_OUT;
+        // Once the ripple faded out, the ripple can be safely removed from the DOM.
+        this.runTimeoutOutsideZone(() => {
+            rippleRef.state = CoRippleState.HIDDEN;
+            rippleEl.parentNode.removeChild(rippleEl);
+        }, RIPPLE_FADE_OUT_DURATION);
+    }
+    /** Fades out all currently active ripples. */
+    fadeOutAll() {
+        this._activeRipples.forEach(ripple => ripple.fadeOut());
+    }
+    /** Sets the trigger element and registers the mouse events. */
+    setTriggerElement(element) {
+        // Remove all previously register event listeners from the trigger element.
+        if (this._triggerElement) {
+            this._triggerEvents.forEach((fn, type) => this._triggerElement.removeEventListener(type, fn));
+        }
+        if (element) {
+            // If the element is not null, register all event listeners on the trigger element.
+            this._ngZone.runOutsideAngular(() => {
+                this._triggerEvents.forEach((fn, type) => element.addEventListener(type, fn));
+            });
+        }
+        this._triggerElement = element;
+    }
+    /** Listener being called on mousedown event. */
+    onMousedown(event) {
+        if (!this.rippleDisabled) {
+            this._isMousedown = true;
+            this.fadeInRipple(event.pageX, event.pageY, this.rippleConfig);
+        }
+    }
+    /** Listener being called on mouseup event. */
+    onMouseup() {
+        this._isMousedown = false;
+        // Fade-out all ripples that are completely visible and not persistent.
+        this._activeRipples.forEach(ripple => {
+            if (!ripple.config.persistent && ripple.state === CoRippleState.VISIBLE) {
+                ripple.fadeOut();
+            }
+        });
+    }
+    /** Listener being called on mouseleave event. */
+    onMouseLeave() {
+        if (this._isMousedown) {
+            this.onMouseup();
+        }
+    }
+    /** Runs a timeout outside of the Angular zone to avoid triggering the change detection. */
+    runTimeoutOutsideZone(fn, delay = 0) {
+        this._ngZone.runOutsideAngular(() => setTimeout(fn, delay));
+    }
+}
+/** Enforces a style recalculation of a DOM element by computing its styles. */
+function enforceStyleRecalculation(element) {
+    // Enforce a style recalculation by calling `getComputedStyle` and accessing any property.
+    // Calling `getPropertyValue` is important to let optimizers know that this is not a noop.
+    // See: https://gist.github.com/paulirish/5d52fb081b3570c81e3a
+    window.getComputedStyle(element).getPropertyValue('opacity');
+}
+/**
+ * Returns the distance from the point (x, y) to the furthest corner of a rectangle.
+ */
+function distanceToFurthestCorner(x, y, rect) {
+    const distX = Math.max(Math.abs(x - rect.left), Math.abs(x - rect.right));
+    const distY = Math.max(Math.abs(y - rect.top), Math.abs(y - rect.bottom));
+    return Math.sqrt(distX * distX + distY * distY);
+}
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ripple-renderer.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/directives/ripple/ripple-renderer.ts"],"names":[],"mappings":"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","sourcesContent":["// NOTE: Copied and adapted to CoreComponents from iOneJS on 9-may-2018.\r\n\r\nimport {ElementRef, NgZone} from '@angular/core';\r\n\r\nimport {CoRippleRef, CoRippleState} from \"./ripple-ref\";\r\nimport {CoViewportRulerService} from \"./viewport-ruler.service\";\r\n\r\n/** Fade-in duration for the ripples. Can be modified with the speedFactor option. */\r\nexport const RIPPLE_FADE_IN_DURATION = 450;\r\n\r\n/** Fade-out duration for the ripples in milliseconds. This can't be modified by the speedFactor. */\r\nexport const RIPPLE_FADE_OUT_DURATION = 400;\r\n\r\nexport type CoRippleConfig = {\r\n    color?: string;\r\n    centered?: boolean;\r\n    radius?: number;\r\n    speedFactor?: number;\r\n    persistent?: boolean;\r\n};\r\n\r\n/**\r\n * Helper service that performs DOM manipulations. Not intended to be used outside this module.\r\n * The constructor takes a reference to the ripple directive's host element and a map of DOM\r\n * event handlers to be installed on the element that triggers ripple animations.\r\n * This will eventually become a custom renderer once Angular support exists.\r\n * @docs-private\r\n */\r\nexport class CoRippleRenderer {\r\n\r\n    /** Element where the ripples are being added to. */\r\n    private _containerElement: HTMLElement;\r\n\r\n    /** Element which triggers the ripple elements on mouse events. */\r\n    private _triggerElement: HTMLElement;\r\n\r\n    /** Whether the mouse is currently down or not. */\r\n    private _isMousedown: boolean = false;\r\n\r\n    /** Events to be registered on the trigger element. */\r\n    private _triggerEvents = new Map<string, any>();\r\n\r\n    /** Set of currently active ripple references. */\r\n    private _activeRipples = new Set<CoRippleRef>();\r\n\r\n    /** Ripple config for all ripples created by events. */\r\n    rippleConfig: CoRippleConfig = {};\r\n\r\n    /** Whether mouse ripples should be created or not. */\r\n    rippleDisabled: boolean = false;\r\n\r\n    constructor(_elementRef: ElementRef, private _ngZone: NgZone, private _ruler: CoViewportRulerService) {\r\n        this._containerElement = _elementRef.nativeElement;\r\n\r\n        // Specify events which need to be registered on the trigger.\r\n        this._triggerEvents.set('mousedown', this.onMousedown.bind(this));\r\n        this._triggerEvents.set('mouseup', this.onMouseup.bind(this));\r\n        this._triggerEvents.set('mouseleave', this.onMouseLeave.bind(this));\r\n\r\n        // By default use the host element as trigger element.\r\n        this.setTriggerElement(this._containerElement);\r\n    }\r\n\r\n    /** Fades in a ripple at the given coordinates. */\r\n    fadeInRipple(pageX: number, pageY: number, config: CoRippleConfig = {}): CoRippleRef {\r\n        let containerRect = this._containerElement.getBoundingClientRect();\r\n\r\n        if (config.centered) {\r\n            pageX = containerRect.left + containerRect.width / 2;\r\n            pageY = containerRect.top + containerRect.height / 2;\r\n        } else {\r\n            // Subtract scroll values from the coordinates because calculations below\r\n            // are always relative to the viewport rectangle.\r\n            let scrollPosition = this._ruler.getViewportScrollPosition();\r\n            pageX -= scrollPosition.left;\r\n            pageY -= scrollPosition.top;\r\n        }\r\n\r\n        let radius = config.radius || distanceToFurthestCorner(pageX, pageY, containerRect);\r\n        let duration = RIPPLE_FADE_IN_DURATION * (1 / (config.speedFactor || 1));\r\n        let offsetX = pageX - containerRect.left;\r\n        let offsetY = pageY - containerRect.top;\r\n\r\n        let ripple = document.createElement('div');\r\n        ripple.classList.add('mat-ripple-element');\r\n\r\n        ripple.style.left = `${offsetX - radius}px`;\r\n        ripple.style.top = `${offsetY - radius}px`;\r\n        ripple.style.height = `${radius * 2}px`;\r\n        ripple.style.width = `${radius * 2}px`;\r\n\r\n        // If the color is not set, the default CSS color will be used.\r\n        ripple.style.backgroundColor = config.color;\r\n        ripple.style.transitionDuration = `${duration}ms`;\r\n\r\n        this._containerElement.appendChild(ripple);\r\n\r\n        // By default the browser does not recalculate the styles of dynamically created\r\n        // ripple elements. This is critical because then the `scale` would not animate properly.\r\n        enforceStyleRecalculation(ripple);\r\n\r\n        ripple.style.transform = 'scale(1)';\r\n\r\n        // Exposed reference to the ripple that will be returned.\r\n        let rippleRef = new CoRippleRef(this, ripple, config);\r\n\r\n        rippleRef.state = CoRippleState.FADING_IN;\r\n\r\n        // Add the ripple reference to the list of all active ripples.\r\n        this._activeRipples.add(rippleRef);\r\n\r\n        // Wait for the ripple element to be completely faded in.\r\n        // Once it's faded in, the ripple can be hidden immediately if the mouse is released.\r\n        this.runTimeoutOutsideZone(() => {\r\n            rippleRef.state = CoRippleState.VISIBLE;\r\n\r\n            if (!config.persistent && !this._isMousedown) {\r\n                rippleRef.fadeOut();\r\n            }\r\n        }, duration);\r\n\r\n        return rippleRef;\r\n    }\r\n\r\n    /** Fades out a ripple reference. */\r\n    fadeOutRipple(rippleRef: CoRippleRef) {\r\n        // For ripples that are not active anymore, don't re-un the fade-out animation.\r\n        if (!this._activeRipples.delete(rippleRef)) {\r\n            return;\r\n        }\r\n\r\n        let rippleEl = rippleRef.element;\r\n\r\n        rippleEl.style.transitionDuration = `${RIPPLE_FADE_OUT_DURATION}ms`;\r\n        rippleEl.style.opacity = '0';\r\n\r\n        rippleRef.state = CoRippleState.FADING_OUT;\r\n\r\n        // Once the ripple faded out, the ripple can be safely removed from the DOM.\r\n        this.runTimeoutOutsideZone(() => {\r\n            rippleRef.state = CoRippleState.HIDDEN;\r\n            rippleEl.parentNode.removeChild(rippleEl);\r\n        }, RIPPLE_FADE_OUT_DURATION);\r\n    }\r\n\r\n    /** Fades out all currently active ripples. */\r\n    fadeOutAll() {\r\n        this._activeRipples.forEach(ripple => ripple.fadeOut());\r\n    }\r\n\r\n    /** Sets the trigger element and registers the mouse events. */\r\n    setTriggerElement(element: HTMLElement) {\r\n        // Remove all previously register event listeners from the trigger element.\r\n        if (this._triggerElement) {\r\n            this._triggerEvents.forEach((fn, type) => this._triggerElement.removeEventListener(type, fn));\r\n        }\r\n\r\n        if (element) {\r\n            // If the element is not null, register all event listeners on the trigger element.\r\n            this._ngZone.runOutsideAngular(() => {\r\n                this._triggerEvents.forEach((fn, type) => element.addEventListener(type, fn));\r\n            });\r\n        }\r\n\r\n        this._triggerElement = element;\r\n    }\r\n\r\n    /** Listener being called on mousedown event. */\r\n    private onMousedown(event: MouseEvent) {\r\n        if (!this.rippleDisabled) {\r\n            this._isMousedown = true;\r\n            this.fadeInRipple(event.pageX, event.pageY, this.rippleConfig);\r\n        }\r\n    }\r\n\r\n    /** Listener being called on mouseup event. */\r\n    private onMouseup() {\r\n        this._isMousedown = false;\r\n\r\n        // Fade-out all ripples that are completely visible and not persistent.\r\n        this._activeRipples.forEach(ripple => {\r\n            if (!ripple.config.persistent && ripple.state === CoRippleState.VISIBLE) {\r\n                ripple.fadeOut();\r\n            }\r\n        });\r\n    }\r\n\r\n    /** Listener being called on mouseleave event. */\r\n    private onMouseLeave() {\r\n        if (this._isMousedown) {\r\n            this.onMouseup();\r\n        }\r\n    }\r\n\r\n    /** Runs a timeout outside of the Angular zone to avoid triggering the change detection. */\r\n    private runTimeoutOutsideZone(fn: Function, delay: number = 0): void {\r\n        this._ngZone.runOutsideAngular(() => setTimeout(fn, delay));\r\n    }\r\n\r\n}\r\n\r\n/** Enforces a style recalculation of a DOM element by computing its styles. */\r\nfunction enforceStyleRecalculation(element: HTMLElement) {\r\n    // Enforce a style recalculation by calling `getComputedStyle` and accessing any property.\r\n    // Calling `getPropertyValue` is important to let optimizers know that this is not a noop.\r\n    // See: https://gist.github.com/paulirish/5d52fb081b3570c81e3a\r\n    window.getComputedStyle(element).getPropertyValue('opacity');\r\n}\r\n\r\n/**\r\n * Returns the distance from the point (x, y) to the furthest corner of a rectangle.\r\n */\r\nfunction distanceToFurthestCorner(x: number, y: number, rect: ClientRect) {\r\n    const distX = Math.max(Math.abs(x - rect.left), Math.abs(x - rect.right));\r\n    const distY = Math.max(Math.abs(y - rect.top), Math.abs(y - rect.bottom));\r\n    return Math.sqrt(distX * distX + distY * distY);\r\n}"]}

package/esm2015/lib/directives/ripple/ripple.directive.js

@@ -1,80 +1,80 @@
-// NOTE: Copied from iOneJS and adapted to CoreComponents on 9-may-2018.
-import { Directive, ElementRef, Inject, InjectionToken, Input, NgZone, Optional } from '@angular/core';
-import { CoRippleRenderer } from "./ripple-renderer";
-import { CoViewportRulerService } from "./viewport-ruler.service";
-/** OpaqueToken that can be used to specify the global ripple options. */
-export const MD_RIPPLE_GLOBAL_OPTIONS = new InjectionToken('CoRippleGlobalOptions');
-export class CoRippleDirective {
-    constructor(elementRef, ngZone, ruler, 
-    // Type needs to be `any` because of https://github.com/angular/angular/issues/12631
-    globalOptions) {
-        /**
-         * 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
-         * bounding rectangle.
-         */
-        this.radius = 0;
-        /**
-         * If set, the normal duration of ripple animations is divided by this value. For example,
-         * setting it to 0.5 will cause the animations to take twice as long.
-         * A changed speedFactor will not modify the fade-out duration of the ripples.
-         */
-        this.speedFactor = 1;
-        this._rippleRenderer = new CoRippleRenderer(elementRef, ngZone, ruler);
-        this._globalOptions = globalOptions ? globalOptions : {};
-    }
-    ngOnChanges(changes) {
-        if (changes['trigger'] && this.trigger) {
-            this._rippleRenderer.setTriggerElement(this.trigger);
-        }
-        this._rippleRenderer.rippleDisabled = this._globalOptions.disabled || this.disabled;
-        this._rippleRenderer.rippleConfig = this.rippleConfig;
-    }
-    ngOnDestroy() {
-        // Set the trigger element to null to cleanup all listeners.
-        this._rippleRenderer.setTriggerElement(null);
-    }
-    /** Launches a manual ripple at the specified position. */
-    launch(pageX, pageY, config = this.rippleConfig) {
-        return this._rippleRenderer.fadeInRipple(pageX, pageY, config);
-    }
-    /** Fades out all currently showing ripple elements. */
-    fadeOutAll() {
-        this._rippleRenderer.fadeOutAll();
-    }
-    /** Ripple configuration from the directive's input values. */
-    get rippleConfig() {
-        return {
-            centered: this.centered,
-            speedFactor: this.speedFactor * (this._globalOptions.baseSpeedFactor || 1),
-            radius: this.radius,
-            color: this.color
-        };
-    }
-}
-CoRippleDirective.decorators = [
-    { type: Directive, args: [{
-                selector: '[md-ripple], [mat-ripple], [mdRipple], [matRipple]',
-                exportAs: 'mdRipple',
-                host: {
-                    '[class.mat-ripple]': 'true',
-                    '[class.mat-ripple-unbounded]': 'unbounded'
-                }
-            },] }
-];
-CoRippleDirective.ctorParameters = () => [
-    { type: ElementRef },
-    { type: NgZone },
-    { type: CoViewportRulerService },
-    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MD_RIPPLE_GLOBAL_OPTIONS,] }] }
-];
-CoRippleDirective.propDecorators = {
-    trigger: [{ type: Input, args: ['mdRippleTrigger',] }],
-    centered: [{ type: Input, args: ['mdRippleCentered',] }],
-    disabled: [{ type: Input, args: ['mdRippleDisabled',] }],
-    radius: [{ type: Input, args: ['mdRippleRadius',] }],
-    speedFactor: [{ type: Input, args: ['mdRippleSpeedFactor',] }],
-    color: [{ type: Input, args: ['mdRippleColor',] }],
-    unbounded: [{ type: Input, args: ['mdRippleUnbounded',] }]
-};
+// NOTE: Copied from iOneJS and adapted to CoreComponents on 9-may-2018.
+import { Directive, ElementRef, Inject, InjectionToken, Input, NgZone, Optional } from '@angular/core';
+import { CoRippleRenderer } from "./ripple-renderer";
+import { CoViewportRulerService } from "./viewport-ruler.service";
+/** OpaqueToken that can be used to specify the global ripple options. */
+export const MD_RIPPLE_GLOBAL_OPTIONS = new InjectionToken('CoRippleGlobalOptions');
+export class CoRippleDirective {
+    constructor(elementRef, ngZone, ruler, 
+    // Type needs to be `any` because of https://github.com/angular/angular/issues/12631
+    globalOptions) {
+        /**
+         * 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
+         * bounding rectangle.
+         */
+        this.radius = 0;
+        /**
+         * If set, the normal duration of ripple animations is divided by this value. For example,
+         * setting it to 0.5 will cause the animations to take twice as long.
+         * A changed speedFactor will not modify the fade-out duration of the ripples.
+         */
+        this.speedFactor = 1;
+        this._rippleRenderer = new CoRippleRenderer(elementRef, ngZone, ruler);
+        this._globalOptions = globalOptions ? globalOptions : {};
+    }
+    ngOnChanges(changes) {
+        if (changes['trigger'] && this.trigger) {
+            this._rippleRenderer.setTriggerElement(this.trigger);
+        }
+        this._rippleRenderer.rippleDisabled = this._globalOptions.disabled || this.disabled;
+        this._rippleRenderer.rippleConfig = this.rippleConfig;
+    }
+    ngOnDestroy() {
+        // Set the trigger element to null to cleanup all listeners.
+        this._rippleRenderer.setTriggerElement(null);
+    }
+    /** Launches a manual ripple at the specified position. */
+    launch(pageX, pageY, config = this.rippleConfig) {
+        return this._rippleRenderer.fadeInRipple(pageX, pageY, config);
+    }
+    /** Fades out all currently showing ripple elements. */
+    fadeOutAll() {
+        this._rippleRenderer.fadeOutAll();
+    }
+    /** Ripple configuration from the directive's input values. */
+    get rippleConfig() {
+        return {
+            centered: this.centered,
+            speedFactor: this.speedFactor * (this._globalOptions.baseSpeedFactor || 1),
+            radius: this.radius,
+            color: this.color
+        };
+    }
+}
+CoRippleDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[md-ripple], [mat-ripple], [mdRipple], [matRipple]',
+                exportAs: 'mdRipple',
+                host: {
+                    '[class.mat-ripple]': 'true',
+                    '[class.mat-ripple-unbounded]': 'unbounded'
+                }
+            },] }
+];
+CoRippleDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: NgZone },
+    { type: CoViewportRulerService },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MD_RIPPLE_GLOBAL_OPTIONS,] }] }
+];
+CoRippleDirective.propDecorators = {
+    trigger: [{ type: Input, args: ['mdRippleTrigger',] }],
+    centered: [{ type: Input, args: ['mdRippleCentered',] }],
+    disabled: [{ type: Input, args: ['mdRippleDisabled',] }],
+    radius: [{ type: Input, args: ['mdRippleRadius',] }],
+    speedFactor: [{ type: Input, args: ['mdRippleSpeedFactor',] }],
+    color: [{ type: Input, args: ['mdRippleColor',] }],
+    unbounded: [{ type: Input, args: ['mdRippleUnbounded',] }]
+};
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ripple.directive.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/directives/ripple/ripple.directive.ts"],"names":[],"mappings":"AAAA,wEAAwE;AAExE,OAAO,EAAC,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,EAAwB,QAAQ,EAAgB,MAAM,eAAe,CAAC;AAC1I,OAAO,EAAiB,gBAAgB,EAAC,MAAM,mBAAmB,CAAC;AAEnE,OAAO,EAAC,sBAAsB,EAAC,MAAM,0BAA0B,CAAC;AAEhE,yEAAyE;AACzE,MAAM,CAAC,MAAM,wBAAwB,GAA0C,IAAI,cAAc,CAAC,uBAAuB,CAAC,CAAC;AAe3H,MAAM,OAAO,iBAAiB;IAgD1B,YACI,UAAsB,EACtB,MAAc,EACd,KAA6B;IAC7B,oFAAoF;IACtC,aAAkB;QA/BpE;;;;WAIG;QACsB,WAAM,GAAW,CAAC,CAAC;QAE5C;;;;WAIG;QAC2B,gBAAW,GAAW,CAAC,CAAC;QAqBlD,IAAI,CAAC,eAAe,GAAG,IAAI,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;QACvE,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC;IAC7D,CAAC;IAED,WAAW,CAAC,OAAsB;QAC9B,IAAI,OAAO,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE;YACpC,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SACxD;QAED,IAAI,CAAC,eAAe,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC;QACpF,IAAI,CAAC,eAAe,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;IAC1D,CAAC;IAED,WAAW;QACP,4DAA4D;QAC5D,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IACjD,CAAC;IAED,0DAA0D;IAC1D,MAAM,CAAC,KAAa,EAAE,KAAa,EAAE,SAAyB,IAAI,CAAC,YAAY;QAC3E,OAAO,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IACnE,CAAC;IAED,uDAAuD;IACvD,UAAU;QACN,IAAI,CAAC,eAAe,CAAC,UAAU,EAAE,CAAC;IACtC,CAAC;IAED,8DAA8D;IAC9D,IAAI,YAAY;QACZ,OAAO;YACH,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,WAAW,EAAE,IAAI,CAAC,WAAW,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,eAAe,IAAI,CAAC,CAAC;YAC1E,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,KAAK,EAAE,IAAI,CAAC,KAAK;SACpB,CAAC;IACN,CAAC;;;YAnGJ,SAAS,SAAC;gBACP,QAAQ,EAAE,oDAAoD;gBAC9D,QAAQ,EAAE,UAAU;gBACpB,IAAI,EAAE;oBACF,oBAAoB,EAAE,MAAM;oBAC5B,8BAA8B,EAAE,WAAW;iBAC9C;aACJ;;;YApBkB,UAAU;YAAiC,MAAM;YAG5D,sBAAsB;4CAuErB,QAAQ,YAAI,MAAM,SAAC,wBAAwB;;;sBA7C/C,KAAK,SAAC,iBAAiB;uBAMvB,KAAK,SAAC,kBAAkB;uBAMxB,KAAK,SAAC,kBAAkB;qBAOxB,KAAK,SAAC,gBAAgB;0BAOtB,KAAK,SAAC,qBAAqB;oBAG3B,KAAK,SAAC,eAAe;wBAGrB,KAAK,SAAC,mBAAmB","sourcesContent":["// NOTE: Copied from iOneJS and adapted to CoreComponents on 9-may-2018.\r\n\r\nimport {Directive, ElementRef, Inject, InjectionToken, Input, NgZone, OnChanges, OnDestroy, Optional, SimpleChanges} from '@angular/core';\r\nimport {CoRippleConfig, CoRippleRenderer} from \"./ripple-renderer\";\r\nimport {CoRippleRef} from \"./ripple-ref\";\r\nimport {CoViewportRulerService} from \"./viewport-ruler.service\";\r\n\r\n/** OpaqueToken that can be used to specify the global ripple options. */\r\nexport const MD_RIPPLE_GLOBAL_OPTIONS: InjectionToken<CoRippleGlobalOptions> = new InjectionToken('CoRippleGlobalOptions');\r\n\r\nexport type CoRippleGlobalOptions = {\r\n    disabled?: boolean;\r\n    baseSpeedFactor?: number;\r\n};\r\n\r\n@Directive({\r\n    selector: '[md-ripple], [mat-ripple], [mdRipple], [matRipple]',\r\n    exportAs: 'mdRipple',\r\n    host: {\r\n        '[class.mat-ripple]': 'true',\r\n        '[class.mat-ripple-unbounded]': 'unbounded'\r\n    }\r\n})\r\nexport class CoRippleDirective implements OnChanges, OnDestroy {\r\n\r\n    /**\r\n     * The element that triggers the ripple when click events are received. Defaults to the\r\n     * directive's host element.\r\n     */\r\n        // Prevent TS metadata emit from referencing HTMLElement in ripple.js\r\n        // Otherwise running this code in a Node environment (e.g Universal) will not work.\r\n    @Input('mdRippleTrigger') trigger: HTMLElement | HTMLElement;\r\n\r\n    /**\r\n     * Whether the ripple always originates from the center of the host element's bounds, rather\r\n     * than originating from the location of the click event.\r\n     */\r\n    @Input('mdRippleCentered') centered: boolean;\r\n\r\n    /**\r\n     * Whether click events will not trigger the ripple. It can still be triggered by manually\r\n     * calling createRipple()\r\n     */\r\n    @Input('mdRippleDisabled') disabled: boolean;\r\n\r\n    /**\r\n     * If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius\r\n     * will be the distance from the center of the ripple to the furthest corner of the host element's\r\n     * bounding rectangle.\r\n     */\r\n    @Input('mdRippleRadius') radius: number = 0;\r\n\r\n    /**\r\n     * If set, the normal duration of ripple animations is divided by this value. For example,\r\n     * setting it to 0.5 will cause the animations to take twice as long.\r\n     * A changed speedFactor will not modify the fade-out duration of the ripples.\r\n     */\r\n    @Input('mdRippleSpeedFactor') speedFactor: number = 1;\r\n\r\n    /** Custom color for ripples. */\r\n    @Input('mdRippleColor') color: string;\r\n\r\n    /** Whether foreground ripples should be visible outside the component's bounds. */\r\n    @Input('mdRippleUnbounded') unbounded: boolean;\r\n\r\n    /** Renderer for the ripple DOM manipulations. */\r\n    private _rippleRenderer: CoRippleRenderer;\r\n\r\n    /** Options that are set globally for all ripples. */\r\n    private _globalOptions: CoRippleGlobalOptions;\r\n\r\n    constructor(\r\n        elementRef: ElementRef,\r\n        ngZone: NgZone,\r\n        ruler: CoViewportRulerService,\r\n        // Type needs to be `any` because of https://github.com/angular/angular/issues/12631\r\n        @Optional() @Inject(MD_RIPPLE_GLOBAL_OPTIONS) globalOptions: any\r\n    ) {\r\n        this._rippleRenderer = new CoRippleRenderer(elementRef, ngZone, ruler);\r\n        this._globalOptions = globalOptions ? globalOptions : {};\r\n    }\r\n\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        if (changes['trigger'] && this.trigger) {\r\n            this._rippleRenderer.setTriggerElement(this.trigger);\r\n        }\r\n\r\n        this._rippleRenderer.rippleDisabled = this._globalOptions.disabled || this.disabled;\r\n        this._rippleRenderer.rippleConfig = this.rippleConfig;\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        // Set the trigger element to null to cleanup all listeners.\r\n        this._rippleRenderer.setTriggerElement(null);\r\n    }\r\n\r\n    /** Launches a manual ripple at the specified position. */\r\n    launch(pageX: number, pageY: number, config: CoRippleConfig = this.rippleConfig): CoRippleRef {\r\n        return this._rippleRenderer.fadeInRipple(pageX, pageY, config);\r\n    }\r\n\r\n    /** Fades out all currently showing ripple elements. */\r\n    fadeOutAll(): void {\r\n        this._rippleRenderer.fadeOutAll();\r\n    }\r\n\r\n    /** Ripple configuration from the directive's input values. */\r\n    get rippleConfig(): CoRippleConfig {\r\n        return {\r\n            centered: this.centered,\r\n            speedFactor: this.speedFactor * (this._globalOptions.baseSpeedFactor || 1),\r\n            radius: this.radius,\r\n            color: this.color\r\n        };\r\n    }\r\n}"]}

package/esm2015/lib/directives/ripple/ripple.module.js

@@ -1,24 +1,24 @@
-// NOTE: Copied from iOneJS and adapted to CoreComponents on 9-may-2018.
-import { NgModule } from "@angular/core";
-import { CoViewportRulerService } from "./viewport-ruler.service";
-import { CoRippleDirective } from "./ripple.directive";
-import { CoScrollableDirective } from "./scrollable.directive";
-import { CoScrollDispatcherService } from "./scroll-dispatcher.service";
-export class RippleModule {
-}
-RippleModule.decorators = [
-    { type: NgModule, args: [{
-                declarations: [
-                    CoRippleDirective,
-                    CoScrollableDirective
-                ],
-                providers: [
-                    CoScrollDispatcherService,
-                    CoViewportRulerService
-                ],
-                exports: [
-                    CoRippleDirective
-                ]
-            },] }
-];
+// NOTE: Copied from iOneJS and adapted to CoreComponents on 9-may-2018.
+import { NgModule } from "@angular/core";
+import { CoViewportRulerService } from "./viewport-ruler.service";
+import { CoRippleDirective } from "./ripple.directive";
+import { CoScrollableDirective } from "./scrollable.directive";
+import { CoScrollDispatcherService } from "./scroll-dispatcher.service";
+export class RippleModule {
+}
+RippleModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [
+                    CoRippleDirective,
+                    CoScrollableDirective
+                ],
+                providers: [
+                    CoScrollDispatcherService,
+                    CoViewportRulerService
+                ],
+                exports: [
+                    CoRippleDirective
+                ]
+            },] }
+];
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmlwcGxlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmVjb21wb25lbnRzL3NyYy9saWIvZGlyZWN0aXZlcy9yaXBwbGUvcmlwcGxlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx3RUFBd0U7QUFFeEUsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUV2QyxPQUFPLEVBQUMsc0JBQXNCLEVBQUMsTUFBTSwwQkFBMEIsQ0FBQztBQUNoRSxPQUFPLEVBQUMsaUJBQWlCLEVBQUMsTUFBTSxvQkFBb0IsQ0FBQztBQUNyRCxPQUFPLEVBQUMscUJBQXFCLEVBQUMsTUFBTSx3QkFBd0IsQ0FBQztBQUM3RCxPQUFPLEVBQUMseUJBQXlCLEVBQUMsTUFBTSw2QkFBNkIsQ0FBQztBQWV0RSxNQUFNLE9BQU8sWUFBWTs7O1lBYnhCLFFBQVEsU0FBQztnQkFDTixZQUFZLEVBQUU7b0JBQ1YsaUJBQWlCO29CQUNqQixxQkFBcUI7aUJBQ3hCO2dCQUNELFNBQVMsRUFBRTtvQkFDUCx5QkFBeUI7b0JBQ3pCLHNCQUFzQjtpQkFDekI7Z0JBQ0QsT0FBTyxFQUFFO29CQUNMLGlCQUFpQjtpQkFDcEI7YUFDSiIsInNvdXJjZXNDb250ZW50IjpbIi8vIE5PVEU6IENvcGllZCBmcm9tIGlPbmVKUyBhbmQgYWRhcHRlZCB0byBDb3JlQ29tcG9uZW50cyBvbiA5LW1heS0yMDE4LlxyXG5cclxuaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuXHJcbmltcG9ydCB7Q29WaWV3cG9ydFJ1bGVyU2VydmljZX0gZnJvbSBcIi4vdmlld3BvcnQtcnVsZXIuc2VydmljZVwiO1xyXG5pbXBvcnQge0NvUmlwcGxlRGlyZWN0aXZlfSBmcm9tIFwiLi9yaXBwbGUuZGlyZWN0aXZlXCI7XHJcbmltcG9ydCB7Q29TY3JvbGxhYmxlRGlyZWN0aXZlfSBmcm9tIFwiLi9zY3JvbGxhYmxlLmRpcmVjdGl2ZVwiO1xyXG5pbXBvcnQge0NvU2Nyb2xsRGlzcGF0Y2hlclNlcnZpY2V9IGZyb20gXCIuL3Njcm9sbC1kaXNwYXRjaGVyLnNlcnZpY2VcIjtcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgICBkZWNsYXJhdGlvbnM6IFtcclxuICAgICAgICBDb1JpcHBsZURpcmVjdGl2ZSxcclxuICAgICAgICBDb1Njcm9sbGFibGVEaXJlY3RpdmVcclxuICAgIF0sXHJcbiAgICBwcm92aWRlcnM6IFtcclxuICAgICAgICBDb1Njcm9sbERpc3BhdGNoZXJTZXJ2aWNlLFxyXG4gICAgICAgIENvVmlld3BvcnRSdWxlclNlcnZpY2VcclxuICAgIF0sXHJcbiAgICBleHBvcnRzOiBbXHJcbiAgICAgICAgQ29SaXBwbGVEaXJlY3RpdmVcclxuICAgIF1cclxufSlcclxuZXhwb3J0IGNsYXNzIFJpcHBsZU1vZHVsZSB7XHJcbn0iXX0=