@colijnit/corecomponents_v12 12.0.13 → 12.0.16

package/esm2015/lib/core/utils/string-utils.js

@@ -0,0 +1,94 @@
+import { notNill } from "../function/not-nill.function";
+import { ArrayUtils } from './array-utils';
+// @dynamic
+export class StringUtils {
+    // Returns the given argument as a string. Returns given defaultValue if conversion of argument to string was impossible.
+    static ParseString(arg, defaultValue = '') {
+        if (!StringUtils.IsString(arg)) {
+            if (arg && typeof arg.toString === 'function') {
+                arg = arg.toString();
+            }
+            else {
+                arg = defaultValue;
+            }
+        }
+        return arg;
+    }
+    static AsLowerCaseIfString(str) {
+        if (StringUtils.IsString(str)) {
+            return str.toLowerCase();
+        }
+        else {
+            return str;
+        }
+    }
+    /**
+     * Example usage:
+     * str = 'File is to large to upload. Maximum file size is {0} Mb'
+     * format = [FileUtils.MaxUploadSizeInMb]
+     * output = File is to large to upload. Maximum file size is 3 Mb
+     *
+     * str = '{0} is way better than {1}'
+     * format = ['Angular2','Angular1']
+     * output = Angular2 is way better than Angular1
+     *
+     * @param str The string that contains {0} and {1} etc, for replacement by given format data
+     * @param format The format replacement data
+     */
+    static Format(str, format) {
+        let args = Array.prototype.slice.call(format);
+        return str.replace(/{(\d+)}/g, function (match, number) {
+            return typeof args[number] !== 'undefined' ? (args[number] !== null ? args[number] : "") : "";
+        });
+    }
+    static IsString(str) {
+        return typeof str === 'string';
+    }
+    // Returns whether given str is a string and has a length > 0.
+    static IsStringWithLength(str) {
+        return notNill(str) && StringUtils.IsString(str) && str.length > 0;
+    }
+    // Returns a new string string with N amount of characters removed from the end of it.
+    static RemoveLastChars(str, amount) {
+        if (str) {
+            return str.slice(0, -1 * amount);
+        }
+        else {
+            return str;
+        }
+    }
+    static StringToStringArray(str) {
+        if (!str) {
+            return [];
+        }
+        const strArray = str.split(" ");
+        ArrayUtils.RemoveElementsByFilter(strArray, (txt) => {
+            return !txt || txt === "";
+        });
+        return strArray;
+    }
+    static CloneStringArray(strArray) {
+        const clone = [];
+        if (strArray) {
+            for (let i = 0, len = strArray.length; i < len; i++) {
+                clone.push(strArray[i]);
+            }
+        }
+        return clone;
+    }
+    static ToStringOrDefault(arg, defaultReturnVal = "") {
+        if (notNill(arg) && arg.toString) {
+            return arg.toString();
+        }
+        else {
+            return defaultReturnVal;
+        }
+    }
+    static CreateGuid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = Math.random() * 16 | 0;
+            return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"string-utils.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/core/utils/string-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {notNill} from \"../function/not-nill.function\";\r\nimport { ArrayUtils } from './array-utils';\r\n\r\n// @dynamic\r\nexport class StringUtils {\r\n    // Returns the given argument as a string. Returns given defaultValue if conversion of argument to string was impossible.\r\n    public static ParseString(arg: any, defaultValue: string = ''): string {\r\n        if (!StringUtils.IsString(arg)) {\r\n            if (arg && typeof arg.toString === 'function') {\r\n                arg = arg.toString();\r\n            } else {\r\n                arg = defaultValue;\r\n            }\r\n        }\r\n        return arg;\r\n    }\r\n\r\n    public static AsLowerCaseIfString(str: any): any {\r\n        if (StringUtils.IsString(str)) {\r\n            return str.toLowerCase();\r\n        } else {\r\n            return str;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Example usage:\r\n     * str = 'File is to large to upload. Maximum file size is {0} Mb'\r\n     * format = [FileUtils.MaxUploadSizeInMb]\r\n     * output = File is to large to upload. Maximum file size is 3 Mb\r\n     *\r\n     * str = '{0} is way better than {1}'\r\n     * format = ['Angular2','Angular1']\r\n     * output = Angular2 is way better than Angular1\r\n     *\r\n     * @param str The string that contains {0} and {1} etc, for replacement by given format data\r\n     * @param format The format replacement data\r\n     */\r\n    public static Format(str: string, format: any[]): string {\r\n        let args: any = Array.prototype.slice.call(format);\r\n        return str.replace(/{(\\d+)}/g, function (match: any, number: any): string {\r\n            return typeof args[number] !== 'undefined' ? (args[number] !== null ? args[number] : \"\") : \"\";\r\n        });\r\n    }\r\n\r\n    public static IsString(str: any): boolean {\r\n        return typeof str === 'string';\r\n    }\r\n\r\n    // Returns whether given str is a string and has a length > 0.\r\n    public static IsStringWithLength(str: any): boolean {\r\n        return notNill(str) && StringUtils.IsString(str) && str.length > 0;\r\n    }\r\n\r\n    // Returns a new string string with N amount of characters removed from the end of it.\r\n    public static RemoveLastChars(str: string, amount: number): string {\r\n        if (str) {\r\n            return str.slice(0, -1 * amount);\r\n        } else {\r\n            return str;\r\n        }\r\n    }\r\n\r\n    public static StringToStringArray(str: string): string[] {\r\n        if (!str) {\r\n            return [];\r\n        }\r\n\r\n        const strArray: string[] = str.split(\" \");\r\n        ArrayUtils.RemoveElementsByFilter(strArray, (txt: string) => {\r\n            return !txt || txt === \"\";\r\n        });\r\n        return strArray;\r\n    }\r\n\r\n    public static CloneStringArray(strArray: string[]): string[] {\r\n        const clone: string[] = [];\r\n        if (strArray) {\r\n            for (let i: number = 0, len: number = strArray.length; i < len; i++) {\r\n                clone.push(strArray[i]);\r\n            }\r\n        }\r\n        return clone;\r\n    }\r\n\r\n    public static ToStringOrDefault(arg: any, defaultReturnVal: string = \"\"): string {\r\n        if (notNill(arg) && arg.toString) {\r\n            return arg.toString();\r\n        } else {\r\n            return defaultReturnVal;\r\n        }\r\n    }\r\n\r\n    public static CreateGuid(): string {\r\n        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c: string) => {\r\n            const r: number = Math.random() * 16 | 0;\r\n            return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);\r\n        });\r\n    }\r\n}\r\n"]}

package/esm2015/lib/core/validator/max-string-length.validator.js

@@ -0,0 +1,10 @@
+export function maxStringLengthValidator(length) {
+    return function (control) {
+        let isValid = true;
+        if (control.value && typeof control.value === 'string') {
+            isValid = control.value.length <= length;
+        }
+        return isValid ? null : { "max-length": { message: "MESSAGE_FIELD_TOO_LONG", placeholder: "" + length } };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF4LXN0cmluZy1sZW5ndGgudmFsaWRhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29yZWNvbXBvbmVudHMvc3JjL2xpYi9jb3JlL3ZhbGlkYXRvci9tYXgtc3RyaW5nLWxlbmd0aC52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLHdCQUF3QixDQUFDLE1BQWM7SUFDbkQsT0FBTyxVQUFVLE9BQW9CO1FBQ2pDLElBQUksT0FBTyxHQUFZLElBQUksQ0FBQztRQUM1QixJQUFJLE9BQU8sQ0FBQyxLQUFLLElBQUksT0FBTyxPQUFPLENBQUMsS0FBSyxLQUFLLFFBQVEsRUFBRTtZQUNwRCxPQUFPLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQyxNQUFNLElBQUksTUFBTSxDQUFDO1NBQzVDO1FBQ0QsT0FBTyxPQUFPLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBQyxZQUFZLEVBQUUsRUFBQyxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsV0FBVyxFQUFFLEVBQUUsR0FBRyxNQUFNLEVBQUMsRUFBQyxDQUFDO0lBQzFHLENBQUMsQ0FBQztBQUNOLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGb3JtQ29udHJvbCwgVmFsaWRhdGlvbkVycm9ycywgVmFsaWRhdG9yRm4gfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XHJcblxyXG5leHBvcnQgZnVuY3Rpb24gbWF4U3RyaW5nTGVuZ3RoVmFsaWRhdG9yKGxlbmd0aDogbnVtYmVyKTogVmFsaWRhdG9yRm4ge1xyXG4gICAgcmV0dXJuIGZ1bmN0aW9uIChjb250cm9sOiBGb3JtQ29udHJvbCk6IFZhbGlkYXRpb25FcnJvcnMgfCBudWxsIHtcclxuICAgICAgICBsZXQgaXNWYWxpZDogYm9vbGVhbiA9IHRydWU7XHJcbiAgICAgICAgaWYgKGNvbnRyb2wudmFsdWUgJiYgdHlwZW9mIGNvbnRyb2wudmFsdWUgPT09ICdzdHJpbmcnKSB7XHJcbiAgICAgICAgICAgIGlzVmFsaWQgPSBjb250cm9sLnZhbHVlLmxlbmd0aCA8PSBsZW5ndGg7XHJcbiAgICAgICAgfVxyXG4gICAgICAgIHJldHVybiBpc1ZhbGlkID8gbnVsbCA6IHtcIm1heC1sZW5ndGhcIjoge21lc3NhZ2U6IFwiTUVTU0FHRV9GSUVMRF9UT09fTE9OR1wiLCBwbGFjZWhvbGRlcjogXCJcIiArIGxlbmd0aH19O1xyXG4gICAgfTtcclxufVxyXG4iXX0=

package/esm2015/lib/core/validator/precision-scale.validator.js

@@ -0,0 +1,11 @@
+import { NumberUtils } from '../utils/number-utils';
+export function precisionScaleValidator(precision, scale) {
+    return function (control) {
+        let isValid = true;
+        if (control) {
+            isValid = NumberUtils.CheckPrecisionAndScale(control.value, precision, scale).isOk;
+        }
+        return isValid ? null : { 'precision-scale': "MESSAGE_FIELD_PRECISION_OVERRIDDEN||" + precision };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJlY2lzaW9uLXNjYWxlLnZhbGlkYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmVjb21wb25lbnRzL3NyYy9saWIvY29yZS92YWxpZGF0b3IvcHJlY2lzaW9uLXNjYWxlLnZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFcEQsTUFBTSxVQUFVLHVCQUF1QixDQUFDLFNBQWlCLEVBQUUsS0FBYTtJQUNwRSxPQUFPLFVBQVUsT0FBb0I7UUFDakMsSUFBSSxPQUFPLEdBQVksSUFBSSxDQUFDO1FBRTVCLElBQUksT0FBTyxFQUFFO1lBQ1QsT0FBTyxHQUFHLFdBQVcsQ0FBQyxzQkFBc0IsQ0FBQyxPQUFPLENBQUMsS0FBSyxFQUFFLFNBQVMsRUFBRSxLQUFLLENBQUMsQ0FBQyxJQUFJLENBQUM7U0FDdEY7UUFFRCxPQUFPLE9BQU8sQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFDLGlCQUFpQixFQUFFLHNDQUFzQyxHQUFHLFNBQVMsRUFBQyxDQUFDO0lBQ3BHLENBQUMsQ0FBQztBQUNOLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGb3JtQ29udHJvbCwgVmFsaWRhdGlvbkVycm9ycywgVmFsaWRhdG9yRm4gfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XHJcbmltcG9ydCB7IE51bWJlclV0aWxzIH0gZnJvbSAnLi4vdXRpbHMvbnVtYmVyLXV0aWxzJztcclxuXHJcbmV4cG9ydCBmdW5jdGlvbiBwcmVjaXNpb25TY2FsZVZhbGlkYXRvcihwcmVjaXNpb246IG51bWJlciwgc2NhbGU6IG51bWJlcik6IFZhbGlkYXRvckZuIHtcclxuICAgIHJldHVybiBmdW5jdGlvbiAoY29udHJvbDogRm9ybUNvbnRyb2wpOiBWYWxpZGF0aW9uRXJyb3JzIHwgbnVsbCB7XHJcbiAgICAgICAgbGV0IGlzVmFsaWQ6IGJvb2xlYW4gPSB0cnVlO1xyXG5cclxuICAgICAgICBpZiAoY29udHJvbCkge1xyXG4gICAgICAgICAgICBpc1ZhbGlkID0gTnVtYmVyVXRpbHMuQ2hlY2tQcmVjaXNpb25BbmRTY2FsZShjb250cm9sLnZhbHVlLCBwcmVjaXNpb24sIHNjYWxlKS5pc09rO1xyXG4gICAgICAgIH1cclxuXHJcbiAgICAgICAgcmV0dXJuIGlzVmFsaWQgPyBudWxsIDogeydwcmVjaXNpb24tc2NhbGUnOiBcIk1FU1NBR0VfRklFTERfUFJFQ0lTSU9OX09WRVJSSURERU58fFwiICsgcHJlY2lzaW9ufTtcclxuICAgIH07XHJcbn1cclxuIl19

package/esm2015/lib/core/validator/required.validator.js

@@ -0,0 +1,5 @@
+export function requiredValidator(control) {
+    const isValid = !(control.value === null || control.value === undefined || control.value === "");
+    return isValid ? null : { 'required': 'MESSAGE_FIELD_REQUIRED' };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWlyZWQudmFsaWRhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29yZWNvbXBvbmVudHMvc3JjL2xpYi9jb3JlL3ZhbGlkYXRvci9yZXF1aXJlZC52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLGlCQUFpQixDQUFDLE9BQXdCO0lBRXRELE1BQU0sT0FBTyxHQUFZLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxLQUFLLElBQUksSUFBSSxPQUFPLENBQUMsS0FBSyxLQUFLLFNBQVMsSUFBSSxPQUFPLENBQUMsS0FBSyxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBRTFHLE9BQU8sT0FBTyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUMsVUFBVSxFQUFFLHdCQUF3QixFQUFDLENBQUM7QUFFbkUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFic3RyYWN0Q29udHJvbCwgVmFsaWRhdGlvbkVycm9ycyB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcclxuXHJcbmV4cG9ydCBmdW5jdGlvbiByZXF1aXJlZFZhbGlkYXRvcihjb250cm9sOiBBYnN0cmFjdENvbnRyb2wpOiBWYWxpZGF0aW9uRXJyb3JzIHwgbnVsbCB7XHJcblxyXG4gICAgY29uc3QgaXNWYWxpZDogYm9vbGVhbiA9ICEoY29udHJvbC52YWx1ZSA9PT0gbnVsbCB8fCBjb250cm9sLnZhbHVlID09PSB1bmRlZmluZWQgfHwgY29udHJvbC52YWx1ZSA9PT0gXCJcIik7XHJcblxyXG4gICAgcmV0dXJuIGlzVmFsaWQgPyBudWxsIDogeydyZXF1aXJlZCc6ICdNRVNTQUdFX0ZJRUxEX1JFUVVJUkVEJ307XHJcblxyXG59XHJcbiJdfQ==

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=

package/esm2015/lib/directives/ripple/scroll-dispatcher.service.js

@@ -0,0 +1,108 @@
+// NOTE: Copied and adapted to iOneJS from https://github.com/angular/material2/blob/master/src/lib/core on 14-march-2017.
+import { Injectable, Optional, SkipSelf } from '@angular/core';
+import { fromEvent, merge, Subject } from 'rxjs';
+import { auditTime } from 'rxjs/operators';
+/** Time in ms to throttle the scrolling events by default. */
+export const DEFAULT_SCROLL_TIME = 20;
+/**
+ * Service contained all registered Scrollable references and emits an event when any one of the
+ * Scrollable references emit a scrolled event.
+ */
+export class CoScrollDispatcherService {
+    constructor() {
+        /** Subject for notifying that a registered scrollable reference element has been scrolled. */
+        this._scrolled = new Subject();
+        /** Keeps track of the global `scroll` and `resize` subscriptions. */
+        this._globalSubscription = null;
+        /** Keeps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards. */
+        this._scrolledCount = 0;
+        /**
+         * Map of all the scrollable references that are registered with the service and their
+         * scroll event subscriptions.
+         */
+        this.scrollableReferences = new Map();
+    }
+    /**
+     * Registers a Scrollable with the service and listens for its scrolled events. When the
+     * scrollable is scrolled, the service emits the event in its scrolled observable.
+     * @param scrollable Scrollable instance to be registered.
+     */
+    register(scrollable) {
+        const scrollSubscription = scrollable.elementScrolled().subscribe(() => this._notify());
+        this.scrollableReferences.set(scrollable, scrollSubscription);
+    }
+    /**
+     * Deregisters a Scrollable reference and unsubscribes from its scroll event observable.
+     * @param scrollable Scrollable instance to be deregistered.
+     */
+    deregister(scrollable) {
+        if (this.scrollableReferences.has(scrollable)) {
+            this.scrollableReferences.get(scrollable).unsubscribe();
+            this.scrollableReferences.delete(scrollable);
+        }
+    }
+    /**
+     * Subscribes to an observable that emits an event whenever any of the registered Scrollable
+     * references (or window, document, or body) fire a scrolled event. Can provide a time in ms
+     * to override the default "throttle" time.
+     */
+    scrolled(auditTimeInMs = DEFAULT_SCROLL_TIME, callback) {
+        // In the case of a 0ms delay, use an observable without auditTime
+        // since it does add a perceptible delay in processing overhead.
+        let observable = auditTimeInMs > 0 ?
+            auditTime(auditTimeInMs) :
+            this._scrolled.asObservable();
+        this._scrolledCount++;
+        if (!this._globalSubscription) {
+            this._globalSubscription = merge(fromEvent(window.document, 'scroll'), fromEvent(window, 'resize')).subscribe(() => this._notify());
+        }
+        // Note that we need to do the subscribing from here, in order to be able to remove
+        // the global event listeners once there are no more subscriptions.
+        return observable.subscribe(callback).add(() => {
+            this._scrolledCount--;
+            if (this._globalSubscription && !this.scrollableReferences.size && !this._scrolledCount) {
+                this._globalSubscription.unsubscribe();
+                this._globalSubscription = null;
+            }
+        });
+    }
+    /** Returns all registered Scrollables that contain the provided element. */
+    getScrollContainers(elementRef) {
+        const scrollingContainers = [];
+        this.scrollableReferences.forEach((subscription, scrollable) => {
+            if (this.scrollableContainsElement(scrollable, elementRef)) {
+                scrollingContainers.push(scrollable);
+            }
+        });
+        return scrollingContainers;
+    }
+    /** Returns true if the element is contained within the provided Scrollable. */
+    scrollableContainsElement(scrollable, elementRef) {
+        let element = elementRef.nativeElement;
+        let scrollableElement = scrollable.getElementRef().nativeElement;
+        // Traverse through the element parents until we reach null, checking if any of the elements
+        // are the scrollable's element.
+        do {
+            if (element == scrollableElement) {
+                return true;
+            }
+        } while (element = element.parentElement);
+    }
+    /** Sends a notification that a scroll event has been fired. */
+    _notify() {
+        this._scrolled.next();
+    }
+}
+CoScrollDispatcherService.decorators = [
+    { type: Injectable }
+];
+export function SCROLL_DISPATCHER_PROVIDER_FACTORY(parentDispatcher) {
+    return parentDispatcher || new CoScrollDispatcherService();
+}
+export const SCROLL_DISPATCHER_PROVIDER = {
+    // If there is already a ScrollDispatcher available, use that. Otherwise, provide a new one.
+    provide: CoScrollDispatcherService,
+    deps: [[new Optional(), new SkipSelf(), CoScrollDispatcherService]],
+    useFactory: SCROLL_DISPATCHER_PROVIDER_FACTORY
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scroll-dispatcher.service.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/directives/ripple/scroll-dispatcher.service.ts"],"names":[],"mappings":"AAAA,0HAA0H;AAC1H,OAAO,EAAc,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC3E,OAAO,EAAE,SAAS,EAAE,KAAK,EAAc,OAAO,EAAgB,MAAM,MAAM,CAAC;AAG3E,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,8DAA8D;AAC9D,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAEtC;;;GAGG;AAEH,MAAM,OAAO,yBAAyB;IADtC;QAEI,8FAA8F;QAC9F,cAAS,GAAkB,IAAI,OAAO,EAAQ,CAAC;QAE/C,qEAAqE;QACrE,wBAAmB,GAAiB,IAAI,CAAC;QAEzC,iGAAiG;QACzF,mBAAc,GAAG,CAAC,CAAC;QAE3B;;;WAGG;QACH,yBAAoB,GAA6C,IAAI,GAAG,EAAE,CAAC;IAwF/E,CAAC;IAtFG;;;;OAIG;IACH,QAAQ,CAAC,UAAiC;QACtC,MAAM,kBAAkB,GAAG,UAAU,CAAC,eAAe,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;QAExF,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,CAAC;IAClE,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,UAAiC;QACxC,IAAI,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;YAC3C,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,WAAW,EAAE,CAAC;YACxD,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;SAChD;IACL,CAAC;IAED;;;;OAIG;IACH,QAAQ,CAAC,gBAAwB,mBAAmB,EAAE,QAAmB;QACrE,kEAAkE;QAClE,gEAAgE;QAChE,IAAI,UAAU,GAAQ,aAAa,GAAG,CAAC,CAAC,CAAC;YACrC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC;YAC1B,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC;QAElC,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE;YAC3B,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAC5B,SAAS,CAAC,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,EACpC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAC9B,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;SACrC;QAED,mFAAmF;QACnF,mEAAmE;QACnE,OAAO,UAAU,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE;YAC3C,IAAI,CAAC,cAAc,EAAE,CAAC;YAEtB,IAAI,IAAI,CAAC,mBAAmB,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE;gBACrF,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,CAAC;gBACvC,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;aACnC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED,4EAA4E;IAC5E,mBAAmB,CAAC,UAAsB;QACtC,MAAM,mBAAmB,GAA4B,EAAE,CAAC;QAExD,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,YAA0B,EAAE,UAAiC,EAAE,EAAE;YAChG,IAAI,IAAI,CAAC,yBAAyB,CAAC,UAAU,EAAE,UAAU,CAAC,EAAE;gBACxD,mBAAmB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aACxC;QACL,CAAC,CAAC,CAAC;QAEH,OAAO,mBAAmB,CAAC;IAC/B,CAAC;IAED,+EAA+E;IAC/E,yBAAyB,CAAC,UAAiC,EAAE,UAAsB;QAC/E,IAAI,OAAO,GAAG,UAAU,CAAC,aAAa,CAAC;QACvC,IAAI,iBAAiB,GAAG,UAAU,CAAC,aAAa,EAAE,CAAC,aAAa,CAAC;QAEjE,4FAA4F;QAC5F,gCAAgC;QAChC,GAAG;YACC,IAAI,OAAO,IAAI,iBAAiB,EAAE;gBAC9B,OAAO,IAAI,CAAC;aACf;SACJ,QAAQ,OAAO,GAAG,OAAO,CAAC,aAAa,EAAE;IAC9C,CAAC;IAED,+DAA+D;IAC/D,OAAO;QACH,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IAC1B,CAAC;;;YAtGJ,UAAU;;AAyGX,MAAM,UAAU,kCAAkC,CAAC,gBAA2C;IAC1F,OAAO,gBAAgB,IAAI,IAAI,yBAAyB,EAAE,CAAC;AAC/D,CAAC;AAED,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACtC,4FAA4F;IAC5F,OAAO,EAAE,yBAAyB;IAClC,IAAI,EAAE,CAAC,CAAC,IAAI,QAAQ,EAAE,EAAE,IAAI,QAAQ,EAAE,EAAE,yBAAyB,CAAC,CAAC;IACnE,UAAU,EAAE,kCAAkC;CACjD,CAAC","sourcesContent":["// NOTE: Copied and adapted to iOneJS from https://github.com/angular/material2/blob/master/src/lib/core on 14-march-2017.\r\nimport { ElementRef, Injectable, Optional, SkipSelf } from '@angular/core';\r\nimport { fromEvent, merge, Observable, Subject, Subscription } from 'rxjs';\r\n\r\nimport { CoScrollableDirective } from './scrollable.directive';\r\nimport { auditTime } from 'rxjs/operators';\r\n\r\n/** Time in ms to throttle the scrolling events by default. */\r\nexport const DEFAULT_SCROLL_TIME = 20;\r\n\r\n/**\r\n * Service contained all registered Scrollable references and emits an event when any one of the\r\n * Scrollable references emit a scrolled event.\r\n */\r\n@Injectable()\r\nexport class CoScrollDispatcherService {\r\n    /** Subject for notifying that a registered scrollable reference element has been scrolled. */\r\n    _scrolled: Subject<void> = new Subject<void>();\r\n\r\n    /** Keeps track of the global `scroll` and `resize` subscriptions. */\r\n    _globalSubscription: Subscription = null;\r\n\r\n    /** Keeps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards. */\r\n    private _scrolledCount = 0;\r\n\r\n    /**\r\n     * Map of all the scrollable references that are registered with the service and their\r\n     * scroll event subscriptions.\r\n     */\r\n    scrollableReferences: Map<CoScrollableDirective, Subscription> = new Map();\r\n\r\n    /**\r\n     * Registers a Scrollable with the service and listens for its scrolled events. When the\r\n     * scrollable is scrolled, the service emits the event in its scrolled observable.\r\n     * @param scrollable Scrollable instance to be registered.\r\n     */\r\n    register(scrollable: CoScrollableDirective): void {\r\n        const scrollSubscription = scrollable.elementScrolled().subscribe(() => this._notify());\r\n\r\n        this.scrollableReferences.set(scrollable, scrollSubscription);\r\n    }\r\n\r\n    /**\r\n     * Deregisters a Scrollable reference and unsubscribes from its scroll event observable.\r\n     * @param scrollable Scrollable instance to be deregistered.\r\n     */\r\n    deregister(scrollable: CoScrollableDirective): void {\r\n        if (this.scrollableReferences.has(scrollable)) {\r\n            this.scrollableReferences.get(scrollable).unsubscribe();\r\n            this.scrollableReferences.delete(scrollable);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Subscribes to an observable that emits an event whenever any of the registered Scrollable\r\n     * references (or window, document, or body) fire a scrolled event. Can provide a time in ms\r\n     * to override the default \"throttle\" time.\r\n     */\r\n    scrolled(auditTimeInMs: number = DEFAULT_SCROLL_TIME, callback: () => any): Subscription {\r\n        // In the case of a 0ms delay, use an observable without auditTime\r\n        // since it does add a perceptible delay in processing overhead.\r\n        let observable: any = auditTimeInMs > 0 ?\r\n            auditTime(auditTimeInMs) :\r\n            this._scrolled.asObservable();\r\n\r\n        this._scrolledCount++;\r\n\r\n        if (!this._globalSubscription) {\r\n            this._globalSubscription = merge(\r\n                fromEvent(window.document, 'scroll'),\r\n                fromEvent(window, 'resize')\r\n            ).subscribe(() => this._notify());\r\n        }\r\n\r\n        // Note that we need to do the subscribing from here, in order to be able to remove\r\n        // the global event listeners once there are no more subscriptions.\r\n        return observable.subscribe(callback).add(() => {\r\n            this._scrolledCount--;\r\n\r\n            if (this._globalSubscription && !this.scrollableReferences.size && !this._scrolledCount) {\r\n                this._globalSubscription.unsubscribe();\r\n                this._globalSubscription = null;\r\n            }\r\n        });\r\n    }\r\n\r\n    /** Returns all registered Scrollables that contain the provided element. */\r\n    getScrollContainers(elementRef: ElementRef): CoScrollableDirective[] {\r\n        const scrollingContainers: CoScrollableDirective[] = [];\r\n\r\n        this.scrollableReferences.forEach((subscription: Subscription, scrollable: CoScrollableDirective) => {\r\n            if (this.scrollableContainsElement(scrollable, elementRef)) {\r\n                scrollingContainers.push(scrollable);\r\n            }\r\n        });\r\n\r\n        return scrollingContainers;\r\n    }\r\n\r\n    /** Returns true if the element is contained within the provided Scrollable. */\r\n    scrollableContainsElement(scrollable: CoScrollableDirective, elementRef: ElementRef): boolean {\r\n        let element = elementRef.nativeElement;\r\n        let scrollableElement = scrollable.getElementRef().nativeElement;\r\n\r\n        // Traverse through the element parents until we reach null, checking if any of the elements\r\n        // are the scrollable's element.\r\n        do {\r\n            if (element == scrollableElement) {\r\n                return true;\r\n            }\r\n        } while (element = element.parentElement);\r\n    }\r\n\r\n    /** Sends a notification that a scroll event has been fired. */\r\n    _notify() {\r\n        this._scrolled.next();\r\n    }\r\n}\r\n\r\nexport function SCROLL_DISPATCHER_PROVIDER_FACTORY(parentDispatcher: CoScrollDispatcherService) {\r\n    return parentDispatcher || new CoScrollDispatcherService();\r\n}\r\n\r\nexport const SCROLL_DISPATCHER_PROVIDER = {\r\n    // If there is already a ScrollDispatcher available, use that. Otherwise, provide a new one.\r\n    provide: CoScrollDispatcherService,\r\n    deps: [[new Optional(), new SkipSelf(), CoScrollDispatcherService]],\r\n    useFactory: SCROLL_DISPATCHER_PROVIDER_FACTORY\r\n};\r\n"]}