@colijnit/corecomponents_v12 12.2.21 → 12.2.22

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

@@ -0,0 +1,161 @@
+import { Directive, ElementRef, Input } from '@angular/core';
+import { OverlayParentDirective } from './overlay-parent.directive';
+export class OverlayDirective {
+    constructor(elementRef) {
+        /**
+         * true; Element is added to the parent template
+         * false; Element is added to the bottom of the DOM
+         */
+        this.inline = false;
+        this.keepInView = false;
+        this.inheritWidth = false;
+        this.rightAlign = false;
+        this.fullSize = false;
+        this.handleScroll = (event) => {
+            this._checkAndPlaceElement();
+        };
+        this._elementRef = elementRef;
+    }
+    set parent(value) {
+        if (value) {
+            if (value instanceof ElementRef) {
+                this._parent = value.nativeElement;
+            }
+            else if (value instanceof OverlayParentDirective) {
+                this._parent = value.elementRef.nativeElement;
+            }
+            else {
+                this._parent = value;
+            }
+        }
+        else {
+            if (this._parent && this._resizeObserver) {
+                this._resizeObserver.disconnect();
+            }
+        }
+    }
+    ngOnDestroy() {
+        document.removeEventListener("scroll", this.handleScroll, true);
+        if (this._intersectionObserver) {
+            this._intersectionObserver.disconnect();
+        }
+        if (this._resizeObserver) {
+            this._resizeObserver.disconnect();
+        }
+        this._elementRef = undefined;
+        this._parent = undefined;
+    }
+    ngOnInit() {
+        if (!this._elementRef || !this._elementRef.nativeElement) {
+            return;
+        }
+        document.addEventListener("scroll", this.handleScroll, true);
+        this._checkAndPlaceElement();
+        this._resizeObserver = new ResizeObserver((entries) => {
+            this._checkAndPlaceElement();
+        });
+        this._intersectionObserver = new IntersectionObserver((entries) => {
+            if (entries && entries.length > 0) {
+                if (entries[0].isIntersecting === false) {
+                    this._elementRef.nativeElement.style.opacity = 0; // hide cause parent is not visible
+                }
+                else {
+                    this._elementRef.nativeElement.style.opacity = 1;
+                }
+            }
+        }, {
+            root: null
+        });
+        if (this._parent) {
+            this._intersectionObserver.observe(this._parent); // observe parent for visibility
+        }
+        this._resizeObserver.observe(document.body);
+    }
+    _checkAndPlaceElement() {
+        if (this._elementRef && this._elementRef.nativeElement && this._parent) {
+            const elementRect = this._elementRef.nativeElement.getBoundingClientRect();
+            const parentBoundingRect = this._parent.getBoundingClientRect();
+            let parentRect = {};
+            if (!this.inline) {
+                parentRect = {
+                    bottom: parentBoundingRect.bottom,
+                    right: parentBoundingRect.right,
+                    left: parentBoundingRect.left,
+                    top: parentBoundingRect.top,
+                    width: parentBoundingRect.width
+                };
+            }
+            else {
+                parentRect = {
+                    bottom: this._parent.offsetTop + parentBoundingRect.height,
+                    right: this._parent.offsetLeft + parentBoundingRect.width,
+                    left: this._parent.offsetLeft,
+                    top: this._parent.offsetTop,
+                    width: parentBoundingRect.width
+                };
+            }
+            this._placeElement(window.innerHeight, window.innerWidth, parentRect, elementRect);
+        }
+    }
+    _placeElement(bottom, right, parentRect, elementRect) {
+        this._elementRef.nativeElement.style.position = "fixed";
+        if (bottom < parentRect.bottom + elementRect.height) { // make sure it fits at the bottom
+            this._elementRef.nativeElement.style.top = (parentRect.top - elementRect.height) + "px";
+            this._elementRef.nativeElement.classList.add('top');
+        }
+        else {
+            this._elementRef.nativeElement.classList.remove('top');
+            this._elementRef.nativeElement.style.top = parentRect.bottom + "px";
+        }
+        if (this.inheritWidth) {
+            this._elementRef.nativeElement.style.width = parentRect.width + "px";
+        }
+        if (this.rightAlign) {
+            let left = (parentRect.right - elementRect.width);
+            if (this.keepInView) {
+                const viewToKeepIn = this.view ? this.view : window;
+                const viewLeft = viewToKeepIn.offsetLeft || 0;
+                left = Math.max(left, viewLeft);
+            }
+            this._elementRef.nativeElement.style.left = left + "px";
+        }
+        else if (this.fullSize) {
+            this._elementRef.nativeElement.style.left = "0px";
+        }
+        else {
+            this._elementRef.nativeElement.style.left = parentRect.left + "px";
+        }
+        if (this.keepInView) {
+            const viewToKeepIn = this.view ? this.view : window;
+            const viewWidth = viewToKeepIn.innerWidth || viewToKeepIn.clientWidth;
+            if (elementRect.right > viewWidth) {
+                //see if we can move it to the left
+                if (((viewWidth - elementRect.width) > 0) && !this.fullSize) {
+                    this._elementRef.nativeElement.style.left = (viewWidth - elementRect.width) + "px";
+                }
+                else { //resize so it fits into view
+                    this._elementRef.nativeElement.style.width = viewWidth + "px";
+                    this._elementRef.nativeElement.style.left = viewToKeepIn.offsetLeft + "px";
+                }
+            }
+        }
+    }
+}
+OverlayDirective.decorators = [
+    { type: Directive, args: [{
+                selector: "[overlay]"
+            },] }
+];
+OverlayDirective.ctorParameters = () => [
+    { type: ElementRef }
+];
+OverlayDirective.propDecorators = {
+    parent: [{ type: Input, args: ["overlay",] }],
+    view: [{ type: Input }],
+    inline: [{ type: Input }],
+    keepInView: [{ type: Input }],
+    inheritWidth: [{ type: Input }],
+    rightAlign: [{ type: Input }],
+    fullSize: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay.directive.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/directives/overlay/overlay.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {Directive, ElementRef, Input, OnDestroy, OnInit} from '@angular/core';\r\nimport {OverlayParentDirective} from './overlay-parent.directive';\r\n\r\n@Directive({\r\n  selector: \"[overlay]\"\r\n})\r\nexport class OverlayDirective implements OnDestroy, OnInit {\r\n\r\n  @Input(\"overlay\")\r\n  public set parent(value: OverlayParentDirective | ElementRef | HTMLElement) {\r\n    if (value) {\r\n      if (value instanceof ElementRef) {\r\n        this._parent = value.nativeElement;\r\n      } else if (value instanceof OverlayParentDirective) {\r\n        this._parent = value.elementRef.nativeElement;\r\n      } else {\r\n        this._parent = value;\r\n      }\r\n    } else {\r\n      if (this._parent && this._resizeObserver) {\r\n        this._resizeObserver.disconnect();\r\n      }\r\n    }\r\n  }\r\n\r\n  @Input()\r\n  public view: HTMLElement;\r\n\r\n  /**\r\n   * true; Element is added to the parent template\r\n   * false; Element is added to the bottom of the DOM\r\n   */\r\n  @Input()\r\n  public inline: boolean = false;\r\n\r\n  @Input()\r\n  public keepInView: boolean = false;\r\n\r\n  @Input()\r\n  public inheritWidth: boolean = false;\r\n\r\n  @Input()\r\n  public rightAlign: boolean = false;\r\n\r\n  @Input()\r\n  public fullSize: boolean = false;\r\n\r\n  private _elementRef: ElementRef;\r\n  private _resizeObserver: ResizeObserver;\r\n  private _intersectionObserver: IntersectionObserver;\r\n  private _parent: HTMLElement;\r\n\r\n  constructor(\r\n      elementRef: ElementRef\r\n  ) {\r\n    this._elementRef = elementRef;\r\n  }\r\n\r\n  public ngOnDestroy(): void {\r\n    document.removeEventListener(\"scroll\", this.handleScroll, true);\r\n    if (this._intersectionObserver) {\r\n      this._intersectionObserver.disconnect();\r\n    }\r\n    if (this._resizeObserver) {\r\n      this._resizeObserver.disconnect();\r\n    }\r\n    this._elementRef = undefined;\r\n    this._parent = undefined;\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    if (!this._elementRef || !this._elementRef.nativeElement) {\r\n      return;\r\n    }\r\n    document.addEventListener(\"scroll\", this.handleScroll, true);\r\n    this._checkAndPlaceElement();\r\n    this._resizeObserver = new ResizeObserver(\r\n        (entries) => {\r\n          this._checkAndPlaceElement();\r\n        }\r\n    );\r\n    this._intersectionObserver = new IntersectionObserver(\r\n        (entries: IntersectionObserverEntry[]) => {\r\n          if (entries && entries.length > 0) {\r\n            if (entries[0].isIntersecting === false) {\r\n              this._elementRef.nativeElement.style.opacity = 0; // hide cause parent is not visible\r\n            } else {\r\n              this._elementRef.nativeElement.style.opacity = 1;\r\n            }\r\n          }\r\n        }, {\r\n          root: null\r\n        }\r\n    );\r\n    if (this._parent) {\r\n      this._intersectionObserver.observe(this._parent); // observe parent for visibility\r\n    }\r\n    this._resizeObserver.observe(document.body);\r\n  }\r\n\r\n  public handleScroll = (event: Event) => {\r\n    this._checkAndPlaceElement();\r\n  }\r\n\r\n  private _checkAndPlaceElement(): void {\r\n    if (this._elementRef && this._elementRef.nativeElement && this._parent) {\r\n      const elementRect: ClientRect = this._elementRef.nativeElement.getBoundingClientRect();\r\n      const parentBoundingRect: ClientRect = this._parent.getBoundingClientRect();\r\n      let parentRect: {} = {};\r\n      if (!this.inline) {\r\n        parentRect = {\r\n          bottom: parentBoundingRect.bottom,\r\n          right: parentBoundingRect.right,\r\n          left: parentBoundingRect.left,\r\n          top: parentBoundingRect.top,\r\n          width: parentBoundingRect.width\r\n        }\r\n      } else {\r\n        parentRect = {\r\n          bottom: this._parent.offsetTop + parentBoundingRect.height,\r\n          right: this._parent.offsetLeft + parentBoundingRect.width,\r\n          left: this._parent.offsetLeft,\r\n          top: this._parent.offsetTop,\r\n          width: parentBoundingRect.width\r\n        }\r\n      }\r\n      this._placeElement(window.innerHeight, window.innerWidth, parentRect, elementRect);\r\n    }\r\n  }\r\n\r\n  private _placeElement(bottom: number, right: number, parentRect: any, elementRect: ClientRect): void {\r\n    this._elementRef.nativeElement.style.position = \"fixed\";\r\n    if (bottom < parentRect.bottom + elementRect.height) { // make sure it fits at the bottom\r\n      this._elementRef.nativeElement.style.top = (parentRect.top - elementRect.height) + \"px\";\r\n      this._elementRef.nativeElement.classList.add('top');\r\n    } else {\r\n      this._elementRef.nativeElement.classList.remove('top');\r\n      this._elementRef.nativeElement.style.top = parentRect.bottom + \"px\";\r\n    }\r\n    if (this.inheritWidth) {\r\n      this._elementRef.nativeElement.style.width = parentRect.width + \"px\";\r\n    }\r\n    if (this.rightAlign) {\r\n      let left: number = (parentRect.right - elementRect.width);\r\n      if (this.keepInView) {\r\n        const viewToKeepIn: any = this.view ? this.view : window;\r\n        const viewLeft: number = viewToKeepIn.offsetLeft || 0;\r\n        left = Math.max(left, viewLeft);\r\n      }\r\n      this._elementRef.nativeElement.style.left = left + \"px\";\r\n    } else if (this.fullSize) {\r\n      this._elementRef.nativeElement.style.left = \"0px\";\r\n    } else {\r\n      this._elementRef.nativeElement.style.left = parentRect.left + \"px\";\r\n    }\r\n    if (this.keepInView) {\r\n      const viewToKeepIn: any = this.view ? this.view : window;\r\n      const viewWidth: number = viewToKeepIn.innerWidth || viewToKeepIn.clientWidth;\r\n      if (elementRect.right > viewWidth) {\r\n        //see if we can move it to the left\r\n        if (((viewWidth - elementRect.width) > 0) && !this.fullSize) {\r\n          this._elementRef.nativeElement.style.left = (viewWidth - elementRect.width) + \"px\";\r\n        } else { //resize so it fits into view\r\n          this._elementRef.nativeElement.style.width = viewWidth + \"px\";\r\n          this._elementRef.nativeElement.style.left = viewToKeepIn.offsetLeft + \"px\";\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { OverlayDirective } from './overlay.directive';
+import { OverlayParentDirective } from './overlay-parent.directive';
+export class OverlayModule {
+}
+OverlayModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [
+                    OverlayDirective,
+                    OverlayParentDirective
+                ],
+                exports: [
+                    OverlayDirective,
+                    OverlayParentDirective
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlY29tcG9uZW50cy9zcmMvbGliL2RpcmVjdGl2ZXMvb3ZlcmxheS9vdmVybGF5Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxnQkFBZ0IsRUFBQyxNQUFNLHFCQUFxQixDQUFDO0FBQ3JELE9BQU8sRUFBQyxzQkFBc0IsRUFBQyxNQUFNLDRCQUE0QixDQUFDO0FBWWxFLE1BQU0sT0FBTyxhQUFhOzs7WUFWekIsUUFBUSxTQUFDO2dCQUNSLFlBQVksRUFBRTtvQkFDWixnQkFBZ0I7b0JBQ2hCLHNCQUFzQjtpQkFDdkI7Z0JBQ0QsT0FBTyxFQUFFO29CQUNQLGdCQUFnQjtvQkFDaEIsc0JBQXNCO2lCQUN2QjthQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7T3ZlcmxheURpcmVjdGl2ZX0gZnJvbSAnLi9vdmVybGF5LmRpcmVjdGl2ZSc7XHJcbmltcG9ydCB7T3ZlcmxheVBhcmVudERpcmVjdGl2ZX0gZnJvbSAnLi9vdmVybGF5LXBhcmVudC5kaXJlY3RpdmUnO1xyXG5cclxuQE5nTW9kdWxlKHtcclxuICBkZWNsYXJhdGlvbnM6IFtcclxuICAgIE92ZXJsYXlEaXJlY3RpdmUsXHJcbiAgICBPdmVybGF5UGFyZW50RGlyZWN0aXZlXHJcbiAgXSxcclxuICBleHBvcnRzOiBbXHJcbiAgICBPdmVybGF5RGlyZWN0aXZlLFxyXG4gICAgT3ZlcmxheVBhcmVudERpcmVjdGl2ZVxyXG4gIF1cclxufSlcclxuZXhwb3J0IGNsYXNzIE92ZXJsYXlNb2R1bGUge1xyXG59XHJcbiJdfQ==

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

@@ -0,0 +1,26 @@
+// NOTE: Copied and adapted to CoreComponents from iOneJS on 9-may-2018.
+/** Possible states for a ripple element. */
+export var CoRippleState;
+(function (CoRippleState) {
+    CoRippleState[CoRippleState["FADING_IN"] = 0] = "FADING_IN";
+    CoRippleState[CoRippleState["VISIBLE"] = 1] = "VISIBLE";
+    CoRippleState[CoRippleState["FADING_OUT"] = 2] = "FADING_OUT";
+    CoRippleState[CoRippleState["HIDDEN"] = 3] = "HIDDEN";
+})(CoRippleState || (CoRippleState = {}));
+/**
+ * Reference to a previously launched ripple element.
+ */
+export class CoRippleRef {
+    constructor(_renderer, element, config) {
+        this._renderer = _renderer;
+        this.element = element;
+        this.config = config;
+        /** Current state of the ripple reference. */
+        this.state = CoRippleState.HIDDEN;
+    }
+    /** Fades out the ripple element. */
+    fadeOut() {
+        this._renderer.fadeOutRipple(this);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmlwcGxlLXJlZi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmVjb21wb25lbnRzL3NyYy9saWIvZGlyZWN0aXZlcy9yaXBwbGUvcmlwcGxlLXJlZi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx3RUFBd0U7QUFJeEUsNENBQTRDO0FBQzVDLE1BQU0sQ0FBTixJQUFZLGFBRVg7QUFGRCxXQUFZLGFBQWE7SUFDckIsMkRBQVMsQ0FBQTtJQUFFLHVEQUFPLENBQUE7SUFBRSw2REFBVSxDQUFBO0lBQUUscURBQU0sQ0FBQTtBQUMxQyxDQUFDLEVBRlcsYUFBYSxLQUFiLGFBQWEsUUFFeEI7QUFFRDs7R0FFRztBQUNILE1BQU0sT0FBTyxXQUFXO0lBS3BCLFlBQ1ksU0FBMkIsRUFDNUIsT0FBb0IsRUFDcEIsTUFBc0I7UUFGckIsY0FBUyxHQUFULFNBQVMsQ0FBa0I7UUFDNUIsWUFBTyxHQUFQLE9BQU8sQ0FBYTtRQUNwQixXQUFNLEdBQU4sTUFBTSxDQUFnQjtRQU5qQyw2Q0FBNkM7UUFDN0MsVUFBSyxHQUFrQixhQUFhLENBQUMsTUFBTSxDQUFDO0lBTTVDLENBQUM7SUFFRCxvQ0FBb0M7SUFDcEMsT0FBTztRQUNILElBQUksQ0FBQyxTQUFTLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3ZDLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbIi8vIE5PVEU6IENvcGllZCBhbmQgYWRhcHRlZCB0byBDb3JlQ29tcG9uZW50cyBmcm9tIGlPbmVKUyBvbiA5LW1heS0yMDE4LlxyXG5cclxuaW1wb3J0IHtDb1JpcHBsZUNvbmZpZywgQ29SaXBwbGVSZW5kZXJlcn0gZnJvbSBcIi4vcmlwcGxlLXJlbmRlcmVyXCI7XHJcblxyXG4vKiogUG9zc2libGUgc3RhdGVzIGZvciBhIHJpcHBsZSBlbGVtZW50LiAqL1xyXG5leHBvcnQgZW51bSBDb1JpcHBsZVN0YXRlIHtcclxuICAgIEZBRElOR19JTiwgVklTSUJMRSwgRkFESU5HX09VVCwgSElEREVOXHJcbn1cclxuXHJcbi8qKlxyXG4gKiBSZWZlcmVuY2UgdG8gYSBwcmV2aW91c2x5IGxhdW5jaGVkIHJpcHBsZSBlbGVtZW50LlxyXG4gKi9cclxuZXhwb3J0IGNsYXNzIENvUmlwcGxlUmVmIHtcclxuXHJcbiAgICAvKiogQ3VycmVudCBzdGF0ZSBvZiB0aGUgcmlwcGxlIHJlZmVyZW5jZS4gKi9cclxuICAgIHN0YXRlOiBDb1JpcHBsZVN0YXRlID0gQ29SaXBwbGVTdGF0ZS5ISURERU47XHJcblxyXG4gICAgY29uc3RydWN0b3IoXHJcbiAgICAgICAgcHJpdmF0ZSBfcmVuZGVyZXI6IENvUmlwcGxlUmVuZGVyZXIsXHJcbiAgICAgICAgcHVibGljIGVsZW1lbnQ6IEhUTUxFbGVtZW50LFxyXG4gICAgICAgIHB1YmxpYyBjb25maWc6IENvUmlwcGxlQ29uZmlnKSB7XHJcbiAgICB9XHJcblxyXG4gICAgLyoqIEZhZGVzIG91dCB0aGUgcmlwcGxlIGVsZW1lbnQuICovXHJcbiAgICBmYWRlT3V0KCkge1xyXG4gICAgICAgIHRoaXMuX3JlbmRlcmVyLmZhZGVPdXRSaXBwbGUodGhpcyk7XHJcbiAgICB9XHJcbn0iXX0=

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

@@ -0,0 +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);
+}
+//# 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

@@ -0,0 +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',] }]
+};
+//# 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

@@ -0,0 +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
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmlwcGxlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmVjb21wb25lbnRzL3NyYy9saWIvZGlyZWN0aXZlcy9yaXBwbGUvcmlwcGxlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx3RUFBd0U7QUFFeEUsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUV2QyxPQUFPLEVBQUMsc0JBQXNCLEVBQUMsTUFBTSwwQkFBMEIsQ0FBQztBQUNoRSxPQUFPLEVBQUMsaUJBQWlCLEVBQUMsTUFBTSxvQkFBb0IsQ0FBQztBQUNyRCxPQUFPLEVBQUMscUJBQXFCLEVBQUMsTUFBTSx3QkFBd0IsQ0FBQztBQUM3RCxPQUFPLEVBQUMseUJBQXlCLEVBQUMsTUFBTSw2QkFBNkIsQ0FBQztBQWV0RSxNQUFNLE9BQU8sWUFBWTs7O1lBYnhCLFFBQVEsU0FBQztnQkFDTixZQUFZLEVBQUU7b0JBQ1YsaUJBQWlCO29CQUNqQixxQkFBcUI7aUJBQ3hCO2dCQUNELFNBQVMsRUFBRTtvQkFDUCx5QkFBeUI7b0JBQ3pCLHNCQUFzQjtpQkFDekI7Z0JBQ0QsT0FBTyxFQUFFO29CQUNMLGlCQUFpQjtpQkFDcEI7YUFDSiIsInNvdXJjZXNDb250ZW50IjpbIi8vIE5PVEU6IENvcGllZCBmcm9tIGlPbmVKUyBhbmQgYWRhcHRlZCB0byBDb3JlQ29tcG9uZW50cyBvbiA5LW1heS0yMDE4LlxyXG5cclxuaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuXHJcbmltcG9ydCB7Q29WaWV3cG9ydFJ1bGVyU2VydmljZX0gZnJvbSBcIi4vdmlld3BvcnQtcnVsZXIuc2VydmljZVwiO1xyXG5pbXBvcnQge0NvUmlwcGxlRGlyZWN0aXZlfSBmcm9tIFwiLi9yaXBwbGUuZGlyZWN0aXZlXCI7XHJcbmltcG9ydCB7Q29TY3JvbGxhYmxlRGlyZWN0aXZlfSBmcm9tIFwiLi9zY3JvbGxhYmxlLmRpcmVjdGl2ZVwiO1xyXG5pbXBvcnQge0NvU2Nyb2xsRGlzcGF0Y2hlclNlcnZpY2V9IGZyb20gXCIuL3Njcm9sbC1kaXNwYXRjaGVyLnNlcnZpY2VcIjtcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgICBkZWNsYXJhdGlvbnM6IFtcclxuICAgICAgICBDb1JpcHBsZURpcmVjdGl2ZSxcclxuICAgICAgICBDb1Njcm9sbGFibGVEaXJlY3RpdmVcclxuICAgIF0sXHJcbiAgICBwcm92aWRlcnM6IFtcclxuICAgICAgICBDb1Njcm9sbERpc3BhdGNoZXJTZXJ2aWNlLFxyXG4gICAgICAgIENvVmlld3BvcnRSdWxlclNlcnZpY2VcclxuICAgIF0sXHJcbiAgICBleHBvcnRzOiBbXHJcbiAgICAgICAgQ29SaXBwbGVEaXJlY3RpdmVcclxuICAgIF1cclxufSlcclxuZXhwb3J0IGNsYXNzIFJpcHBsZU1vZHVsZSB7XHJcbn0iXX0=