@colijnit/corecomponents_v12 255.1.1 → 255.1.2

package/esm2015/lib/core/model/element-position.js

@@ -0,0 +1,10 @@
+// Represents a positional model
+export class ElementPosition {
+    constructor(top, right, bottom, left) {
+        this.top = top;
+        this.right = right;
+        this.bottom = bottom;
+        this.left = left;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC1wb3NpdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmVjb21wb25lbnRzL3NyYy9saWIvY29yZS9tb2RlbC9lbGVtZW50LXBvc2l0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGdDQUFnQztBQUNoQyxNQUFNLE9BQU8sZUFBZTtJQU14QixZQUFhLEdBQVksRUFBRSxLQUFjLEVBQUUsTUFBZSxFQUFFLElBQWE7UUFDckUsSUFBSSxDQUFDLEdBQUcsR0FBRyxHQUFHLENBQUM7UUFDZixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNuQixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztRQUNyQixJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztJQUNyQixDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBSZXByZXNlbnRzIGEgcG9zaXRpb25hbCBtb2RlbFxyXG5leHBvcnQgY2xhc3MgRWxlbWVudFBvc2l0aW9uIHtcclxuICAgIHB1YmxpYyB0b3A6IG51bWJlcjtcclxuICAgIHB1YmxpYyByaWdodDogbnVtYmVyO1xyXG4gICAgcHVibGljIGJvdHRvbTogbnVtYmVyO1xyXG4gICAgcHVibGljIGxlZnQ6IG51bWJlcjtcclxuXHJcbiAgICBjb25zdHJ1Y3RvciAodG9wPzogbnVtYmVyLCByaWdodD86IG51bWJlciwgYm90dG9tPzogbnVtYmVyLCBsZWZ0PzogbnVtYmVyKSB7XHJcbiAgICAgICAgdGhpcy50b3AgPSB0b3A7XHJcbiAgICAgICAgdGhpcy5yaWdodCA9IHJpZ2h0O1xyXG4gICAgICAgIHRoaXMuYm90dG9tID0gYm90dG9tO1xyXG4gICAgICAgIHRoaXMubGVmdCA9IGxlZnQ7XHJcbiAgICB9XHJcbn1cclxuIl19

package/esm2015/lib/core/model/event/string-prompt-result-event.js

@@ -0,0 +1,8 @@
+// for PromptService.promptString
+export class StringPromptResultEvent {
+    constructor(eventType, output) {
+        this.eventType = eventType;
+        this.output = output;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5nLXByb21wdC1yZXN1bHQtZXZlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlY29tcG9uZW50cy9zcmMvbGliL2NvcmUvbW9kZWwvZXZlbnQvc3RyaW5nLXByb21wdC1yZXN1bHQtZXZlbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsaUNBQWlDO0FBQ2pDLE1BQU0sT0FBTyx1QkFBdUI7SUFDaEMsWUFDVyxTQUEwQixFQUMxQixNQUFjO1FBRGQsY0FBUyxHQUFULFNBQVMsQ0FBaUI7UUFDMUIsV0FBTSxHQUFOLE1BQU0sQ0FBUTtJQUV6QixDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQb3B1cEJ1dHRvblR5cGUgfSBmcm9tICcuLi8uLi9lbnVtL3BvcHVwLWJ1dHRvbi10eXBlLmVudW0nO1xyXG5cclxuLy8gZm9yIFByb21wdFNlcnZpY2UucHJvbXB0U3RyaW5nXHJcbmV4cG9ydCBjbGFzcyBTdHJpbmdQcm9tcHRSZXN1bHRFdmVudCB7XHJcbiAgICBjb25zdHJ1Y3RvcihcclxuICAgICAgICBwdWJsaWMgZXZlbnRUeXBlOiBQb3B1cEJ1dHRvblR5cGUsXHJcbiAgICAgICAgcHVibGljIG91dHB1dDogc3RyaW5nXHJcbiAgICApIHtcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2015/lib/core/service/form-input-user-change-listener.service.js

@@ -0,0 +1,25 @@
+import { Injectable } from "@angular/core";
+import { Subject } from "rxjs";
+export class FormInputUserModelChangeListenerService {
+    constructor() {
+        // Signal from input-field to change-listener user. Emits (or: should be emitted) each time the end-user has changed the state of a form input's model. Emits model as value.
+        this.userModelChange = new Subject();
+        // Signal from user of this change-listener to all its child input-fields. Resets their user touched marks.
+        this.clearAllMarkedAsUserTouched = new Subject();
+        this.hasUserModelChanges = false;
+        this._subs = [];
+        this._subs.push(this.userModelChange.subscribe(() => {
+            this.hasUserModelChanges = true;
+        }), this.clearAllMarkedAsUserTouched.subscribe(() => {
+            this.hasUserModelChanges = false;
+        }));
+    }
+    ngOnDestroy() {
+        this._subs.forEach(sub => sub.unsubscribe());
+    }
+}
+FormInputUserModelChangeListenerService.decorators = [
+    { type: Injectable }
+];
+FormInputUserModelChangeListenerService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/core/service/form-master.service.js

@@ -0,0 +1,102 @@
+import { Injectable } from "@angular/core";
+import { Subject } from "rxjs";
+import { ArrayUtils } from '../utils/array-utils';
+import { ElementPosition } from '../model/element-position';
+/**
+ * Service to use inside [providers] of some leaf component that contains multiple <co-form>'s inside, possibly nested. Gives the master
+ * full control over submits etc. of all its inner co-forms with just one service.
+ */
+export class FormMasterService {
+    constructor() {
+        // emits when ALL slaves valid-submitted
+        this.validSlavesSubmit = new Subject();
+        this._slaveForms = [];
+        this._subs = [];
+        this._positionOfFirstInvalidFieldInDom = new ElementPosition(9999, 9999, 9999, 9999);
+        this._firstErrorTooltipSpawned = false;
+    }
+    ngOnDestroy() {
+        this._slaveForms.length = 0;
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    addSlave(coFormComp) {
+        this._slaveForms.push(coFormComp);
+        this._subs.push(coFormComp.invalidSubmit.subscribe(() => {
+            this._handleFormCompInvalidity();
+        }));
+        this._subs.push(coFormComp.anySubmit.subscribe(() => {
+            this._resetFirstInvalidFieldProps();
+        }));
+    }
+    removeSlave(coFormComp) {
+        ArrayUtils.RemoveElement(coFormComp, this._slaveForms);
+        this._firstErrorTooltipSpawned = false;
+    }
+    // Returns true if ALL submits were succesful, false if at least one submit failed. Returns undefined if we had no slaves.
+    submitSlaves() {
+        this._resetFirstInvalidFieldProps();
+        let success = true;
+        if (this._slaveForms) {
+            for (let i = 0, len = this._slaveForms.length; i < len; i++) {
+                if (!this._slaveForms[i].submit(true)) {
+                    success = false;
+                }
+            }
+        }
+        if (success) {
+            this.validSlavesSubmit.next();
+        }
+        else {
+            this._handleFormCompInvalidity();
+        }
+        return success;
+    }
+    resetSlaves() {
+        if (this._slaveForms) {
+            for (let i = 0, len = this._slaveForms.length; i < len; i++) {
+                this._slaveForms[i].reset();
+            }
+        }
+    }
+    setFirstInvalidField(form, key, element) {
+        if (!element) {
+            return;
+        }
+        const clientRect = element.getBoundingClientRect(), scrollLeft = window.pageXOffset || document.documentElement.scrollLeft, scrollTop = window.pageYOffset || document.documentElement.scrollTop, top = clientRect.top + scrollTop, left = clientRect.left + scrollLeft;
+        if (this._positionOfFirstInvalidFieldInDom.top >= top && this._positionOfFirstInvalidFieldInDom.left >= left) {
+            this._slaveHoldingFirstInvalidField = form;
+            this._keyOfFirstInvalidFieldInDom = key;
+            this._positionOfFirstInvalidFieldInDom = new ElementPosition(top, clientRect.right, clientRect.bottom, left);
+        }
+    }
+    allSlavesValid() {
+        if (this._slaveForms) {
+            for (let i = 0, len = this._slaveForms.length; i < len; i++) {
+                if (!this._slaveForms[i].isValid()) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        else {
+            return true;
+        }
+    }
+    _resetFirstInvalidFieldProps() {
+        this._positionOfFirstInvalidFieldInDom = new ElementPosition(9999, 9999, 9999, 9999);
+        this._keyOfFirstInvalidFieldInDom = "";
+        this._slaveHoldingFirstInvalidField = undefined;
+        this._firstErrorTooltipSpawned = false;
+    }
+    _handleFormCompInvalidity() {
+        if (this._slaveHoldingFirstInvalidField && !this._firstErrorTooltipSpawned) {
+            this._slaveHoldingFirstInvalidField.showErrorTooltipOnFormGroupControl(this._keyOfFirstInvalidFieldInDom);
+            this._firstErrorTooltipSpawned = true;
+        }
+    }
+}
+FormMasterService.decorators = [
+    { type: Injectable }
+];
+FormMasterService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-master.service.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/core/service/form-master.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from \"@angular/core\";\r\nimport {Subject, Subscription} from \"rxjs\";\r\nimport { FormComponent } from '../../components/form/form.component';\r\nimport { ArrayUtils } from '../utils/array-utils';\r\nimport { ElementPosition } from '../model/element-position';\r\n\r\n/**\r\n * Service to use inside [providers] of some leaf component that contains multiple <co-form>'s inside, possibly nested. Gives the master\r\n * full control over submits etc. of all its inner co-forms with just one service.\r\n */\r\n@Injectable()\r\nexport class FormMasterService implements OnDestroy {\r\n    // emits when ALL slaves valid-submitted\r\n    public readonly validSlavesSubmit: Subject<void> = new Subject<void>();\r\n\r\n    private _slaveForms: FormComponent[] = [];\r\n\r\n    private _subs: Subscription[] = [];\r\n\r\n    private _slaveHoldingFirstInvalidField: FormComponent;\r\n    private _keyOfFirstInvalidFieldInDom: string;\r\n    private _positionOfFirstInvalidFieldInDom: ElementPosition = new ElementPosition(9999, 9999, 9999, 9999);\r\n\r\n    private _firstErrorTooltipSpawned: boolean = false;\r\n\r\n    constructor() {\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this._slaveForms.length = 0;\r\n        this._subs.forEach(s => s.unsubscribe());\r\n    }\r\n\r\n    public addSlave(coFormComp: FormComponent): void {\r\n        this._slaveForms.push(coFormComp);\r\n        this._subs.push(coFormComp.invalidSubmit.subscribe(() => {\r\n            this._handleFormCompInvalidity();\r\n        }));\r\n        this._subs.push(coFormComp.anySubmit.subscribe(() => {\r\n            this._resetFirstInvalidFieldProps();\r\n        }));\r\n    }\r\n\r\n    public removeSlave(coFormComp: FormComponent): void {\r\n        ArrayUtils.RemoveElement(coFormComp, this._slaveForms);\r\n        this._firstErrorTooltipSpawned = false;\r\n    }\r\n\r\n    // Returns true if ALL submits were succesful, false if at least one submit failed. Returns undefined if we had no slaves.\r\n    public submitSlaves(): boolean {\r\n        this._resetFirstInvalidFieldProps();\r\n        let success: boolean = true;\r\n        if (this._slaveForms) {\r\n            for (let i: number = 0, len: number = this._slaveForms.length; i < len; i++) {\r\n                if (!this._slaveForms[i].submit(true)) {\r\n                    success = false;\r\n                }\r\n            }\r\n        }\r\n\r\n        if (success) {\r\n            this.validSlavesSubmit.next();\r\n        } else {\r\n            this._handleFormCompInvalidity();\r\n        }\r\n        return success;\r\n    }\r\n\r\n    public resetSlaves(): void {\r\n        if (this._slaveForms) {\r\n            for (let i: number = 0, len: number = this._slaveForms.length; i < len; i++) {\r\n                this._slaveForms[i].reset();\r\n            }\r\n        }\r\n    }\r\n\r\n    public setFirstInvalidField(form: FormComponent, key: string, element: HTMLElement): void {\r\n        if (!element) {\r\n            return;\r\n        }\r\n        const clientRect: ClientRect = element.getBoundingClientRect(),\r\n            scrollLeft: number = window.pageXOffset || document.documentElement.scrollLeft,\r\n            scrollTop: number = window.pageYOffset || document.documentElement.scrollTop,\r\n            top: number = clientRect.top + scrollTop,\r\n            left: number = clientRect.left + scrollLeft;\r\n        if (this._positionOfFirstInvalidFieldInDom.top >= top && this._positionOfFirstInvalidFieldInDom.left >= left) {\r\n            this._slaveHoldingFirstInvalidField = form;\r\n            this._keyOfFirstInvalidFieldInDom = key;\r\n            this._positionOfFirstInvalidFieldInDom = new ElementPosition(top, clientRect.right, clientRect.bottom, left);\r\n        }\r\n    }\r\n\r\n    public allSlavesValid(): boolean {\r\n        if (this._slaveForms) {\r\n            for (let i: number = 0, len: number = this._slaveForms.length; i < len; i++) {\r\n                if (!this._slaveForms[i].isValid()) {\r\n                    return false;\r\n                }\r\n            }\r\n            return true;\r\n        } else {\r\n            return true;\r\n        }\r\n    }\r\n\r\n    private _resetFirstInvalidFieldProps(): void {\r\n        this._positionOfFirstInvalidFieldInDom = new ElementPosition(9999, 9999, 9999, 9999);\r\n        this._keyOfFirstInvalidFieldInDom = \"\";\r\n        this._slaveHoldingFirstInvalidField = undefined;\r\n        this._firstErrorTooltipSpawned = false;\r\n    }\r\n\r\n    private _handleFormCompInvalidity(): void {\r\n        if (this._slaveHoldingFirstInvalidField && !this._firstErrorTooltipSpawned) {\r\n            this._slaveHoldingFirstInvalidField.showErrorTooltipOnFormGroupControl(this._keyOfFirstInvalidFieldInDom);\r\n            this._firstErrorTooltipSpawned = true;\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2015/lib/core/service/ng-zone-wrapper.service.js

@@ -0,0 +1,20 @@
+import { Injectable, NgZone } from "@angular/core";
+export class NgZoneWrapperService {
+    constructor(_ngZone) {
+        this._ngZone = _ngZone;
+    }
+    setTimeoutOutsideAngular(fn, millis = 0) {
+        this._ngZone.runOutsideAngular(() => {
+            setTimeout(() => {
+                fn();
+            }, millis);
+        });
+    }
+}
+NgZoneWrapperService.decorators = [
+    { type: Injectable }
+];
+NgZoneWrapperService.ctorParameters = () => [
+    { type: NgZone }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctem9uZS13cmFwcGVyLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlY29tcG9uZW50cy9zcmMvbGliL2NvcmUvc2VydmljZS9uZy16b25lLXdyYXBwZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFFLE1BQU0sRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUdqRCxNQUFNLE9BQU8sb0JBQW9CO0lBQzdCLFlBQW9CLE9BQWU7UUFBZixZQUFPLEdBQVAsT0FBTyxDQUFRO0lBQ25DLENBQUM7SUFFTSx3QkFBd0IsQ0FBQyxFQUFZLEVBQUUsU0FBaUIsQ0FBQztRQUM1RCxJQUFJLENBQUMsT0FBTyxDQUFDLGlCQUFpQixDQUFDLEdBQUcsRUFBRTtZQUNoQyxVQUFVLENBQUMsR0FBRyxFQUFFO2dCQUNaLEVBQUUsRUFBRSxDQUFDO1lBQ1QsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBQ2YsQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDOzs7WUFYSixVQUFVOzs7WUFGUyxNQUFNIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3RhYmxlLCBOZ1pvbmV9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcblxyXG5ASW5qZWN0YWJsZSgpXHJcbmV4cG9ydCBjbGFzcyBOZ1pvbmVXcmFwcGVyU2VydmljZSB7XHJcbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIF9uZ1pvbmU6IE5nWm9uZSkge1xyXG4gICAgfVxyXG5cclxuICAgIHB1YmxpYyBzZXRUaW1lb3V0T3V0c2lkZUFuZ3VsYXIoZm46IEZ1bmN0aW9uLCBtaWxsaXM6IG51bWJlciA9IDApOiB2b2lkIHtcclxuICAgICAgICB0aGlzLl9uZ1pvbmUucnVuT3V0c2lkZUFuZ3VsYXIoKCkgPT4ge1xyXG4gICAgICAgICAgICBzZXRUaW1lb3V0KCgpID0+IHtcclxuICAgICAgICAgICAgICAgIGZuKCk7XHJcbiAgICAgICAgICAgIH0sIG1pbGxpcyk7XHJcbiAgICAgICAgfSk7XHJcbiAgICB9XHJcbn0iXX0=

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

@@ -0,0 +1,264 @@
+import { isNill } from "../function/is-nill.function";
+import { notNill } from "../function/not-nill.function";
+import { StringUtils } from "./string-utils";
+import { NumberUtils } from "./number-utils";
+import { ObjectUtils } from "./object-utils";
+export class ArrayUtils {
+    /**
+     * Inserts given element into given array, on given index number.
+     *
+     * @param index The index position for the element to insert, use negatives to count from the arrays end
+     * @param element The element to insert
+     * @param array The array to insert the element into
+     * @returns True if and only if given element is succesfully inserted into given array.
+     */
+    static InsertElement(index, element, array) {
+        if (!Array.isArray(array) || Math.abs(index) > array.length || isNill(index)) {
+            // cannot insert something into nothing, and cannot insert an element into a non-array (via this contract that is), and
+            // we will not insert anything beyond the arrays limits (but we can append to the start or end)
+            return false;
+        }
+        const lenBefore = array.length;
+        array.splice(index, 0, element);
+        return (array.length === lenBefore + 1);
+    }
+    /**
+     * Removes given element from given array. Doesn't just set it to null like JavaScripts standard 'delete' keyword, but truly removes the
+     * element using splice(). Also works on associative arrays.
+     *
+     * @param element The element to remove.
+     * @param array The array to remove the element from.
+     * @returns True iff given element was truly successfully removed from given array.
+     */
+    static RemoveElement(element, array) {
+        if (!Array.isArray(array)) {
+            return false;
+        }
+        let index = array.indexOf(element);
+        return ArrayUtils.RemoveElementAtIndex(index, array);
+    }
+    /**
+     * Returns a true shallow clone of given array plus all its items. Its first-level members are object-shallow-cloned (optionally with a
+     * strongly typed constructor),
+     * or just as plain object (see param arrayItemsClass).
+     * @param arrayGiven
+     * @param arrayItemsClass If provided, the cloned array's first-level items will be strongly typed to / constructed as this class. Otherwise
+     * it'll be a plain object.
+     * @returns a true shallow clone of given array plus all its items
+     */
+    static ShallowCloneArrayAndItsItem(arrayGiven, arrayItemsClass) {
+        let arrayClone = [];
+        if (arrayGiven) {
+            for (let i = 0, len = arrayGiven.length; i < len; i++) {
+                arrayClone.push(ObjectUtils.GetShallowClone(arrayGiven[i], arrayItemsClass));
+            }
+        }
+        else {
+            return [];
+        }
+        return arrayClone;
+    }
+    /**
+     * Moves given element to given toIndex in given array. Returns whether the element was really moved, thus changing the given array.
+     */
+    static MoveElement(element, toIndex, array) {
+        if (!Array.isArray(array) || isNill(toIndex)) {
+            return false;
+        }
+        let fromIndex = array.indexOf(element);
+        let toIndexCorrected = NumberUtils.GetNearestNumberWithinBounds(toIndex, 0, array.length - 1);
+        if (fromIndex === -1 || array[toIndexCorrected] === element) {
+            // element did not exist in given array, or already existed on given toIndex
+            return false;
+        }
+        array.splice(toIndexCorrected, 0, array.splice(fromIndex, 1)[0]);
+        return true;
+    }
+    /**
+     * Returns max value from all resulting values from applying given itemValueFunction to all items of given array.
+     * @param array
+     * @param itemValueFunction The function aplied to each array item that gives it a numerical value. The max num val found is returned.
+     */
+    static GetMaxCalculatedValue(array, itemValueFunction) {
+        if (!array || !itemValueFunction) {
+            return NaN;
+        }
+        let max = undefined;
+        let len = array.length;
+        for (let i = 0; i < len; i++) {
+            let valueCur = itemValueFunction.call(this);
+            if (valueCur > max) {
+                max = valueCur;
+            }
+        }
+        return max;
+    }
+    // Checks if given array is defined, and is an array, and has length > 0, and, optionally checks that the first element is of type given clazz.
+    static IsArrayWithElements(arrayToCheck, clazz) {
+        if (isNill(arrayToCheck)) {
+            return false;
+        }
+        if (Array.isArray(arrayToCheck) && arrayToCheck.length > 0) {
+            if (clazz) {
+                return arrayToCheck[0] instanceof clazz;
+            }
+            return true;
+        }
+        return false;
+    }
+    // Removes all elements from given array for which given filter function holds true. Returns true if at least one removed, else false.
+    static RemoveElementsByFilter(array, filterFunction) {
+        if (!ArrayUtils.IsArrayWithElements(array) || !filterFunction) {
+            return false;
+        }
+        let atLeastOneRemoved = false;
+        let len = array.length;
+        for (let i = len - 1; i >= 0; i--) {
+            let item = array[i];
+            if (filterFunction.call(this, item) === true) {
+                array.splice(i, 1);
+                atLeastOneRemoved = true;
+            }
+        }
+        return atLeastOneRemoved;
+    }
+    // Replaces the elementOut with given elementIn.
+    static ReplaceElement(elementIn, elementOut, array) {
+        if (!array || !Array.isArray(array)) {
+            return;
+        }
+        const indexOut = array.indexOf(elementOut);
+        if (indexOut > -1) {
+            ArrayUtils.InsertElement(indexOut, elementIn, array);
+            ArrayUtils.RemoveElement(elementOut, array);
+        }
+    }
+    // Swaps the elements in given array with each other. Returns whether a real swap was made. From and To elements have to exist in array.
+    static SwapElements(elementOne, elementTwo, array) {
+        if (!Array.isArray(array)) {
+            return false;
+        }
+        const elOneIdx = array.indexOf(elementTwo);
+        const elTwoIdx = array.indexOf(elementOne);
+        if (elOneIdx === -1 || elTwoIdx === -1) {
+            return false;
+        }
+        array[elOneIdx] = array.splice(elTwoIdx, 1, array[elOneIdx])[0];
+        return true;
+    }
+    // Inserts or removes given toggle element into given elements array; inserts if not yet exists, and removes if already exists.
+    static ToggleElement(toggle, elements) {
+        elements.indexOf(toggle) > -1 ? ArrayUtils.RemoveElement(toggle, elements) : elements.push(toggle);
+    }
+    // Returns the number of elements from given array for which given whereFunction holds true.
+    static CountWhere(array, whereFunction) {
+        if (!ArrayUtils.IsArrayWithElements(array) || !whereFunction) {
+            return 0;
+        }
+        let count = 0;
+        const len = array.length;
+        for (let i = 0; i < len; i++) {
+            if (whereFunction.call(this, array[i])) {
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Returns whether at least one element in given array could be found by given finder function.
+     *
+     * @param array
+     * @param finder A finder function that takes an element of the array and returns a boolean that represents
+     * the 'found status' for that element; whether it should have been found or not.
+     */
+    static ContainsAnElementFoundBy(array, finder) {
+        if (!array || !finder) {
+            return false;
+        }
+        return notNill(ArrayUtils.Find(array, finder));
+    }
+    /**
+     * Cross-browser Array.find() function. Returns the first item in given array for which the foundBy function returns true. Returns
+     * undefined when none was found.
+     *
+     * Example usage:
+     * let foundItem: BusinessObject = ArrayUtils.Find<BusinessObject>(modelArray, (modelItem: BusinessObject) => <br>
+     *     (return modelItem.getId() === '1')
+     *   * });
+     *
+     * @param array The array with items to search in.
+     * @param foundBy The finder function applied on each items of the array, when that returns true, the item is considered found.
+     */
+    static Find(array, foundBy) {
+        if (!array || !foundBy) {
+            return undefined;
+        }
+        for (let i = 0, len = array.length; i < len; i++) {
+            let itemCur = array[i];
+            if (foundBy(itemCur)) {
+                return itemCur;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Sorts all items in the given array alphabetically (A-to-Z) according to the values of their given property.
+     * @param theArray
+     * @param propertyName = undefined] When not defined, assumes an array of STRINGS is given, instead of array of OBJECTS.
+     * @param [reverseOrder = false] Set to true to sort from Z-to-A instead
+     */
+    static SortAlphabetically(theArray, propertyName = undefined, reverseOrder = false) {
+        if (!theArray || !Array.isArray(theArray)) {
+            return;
+        }
+        let switcher = reverseOrder ? -1 : 1;
+        let stringSort = StringUtils.IsStringWithLength(propertyName);
+        theArray.sort((itemOne, itemTwo) => {
+            let valOne = stringSort ? itemOne[propertyName] : itemOne;
+            let valTwo = stringSort ? itemTwo[propertyName] : itemTwo;
+            return (valOne > valTwo ? 1 : (valOne < valTwo ? -1 : 0)) * switcher;
+        });
+    }
+    static PushIfNotExist(item, array) {
+        if (!array) {
+            return false;
+        }
+        if (array.indexOf(item) === -1) {
+            array.push(item);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Removes element at given index from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really
+     * removes the element using splice().
+     *
+     * @param index
+     * @param array
+     * @returns True if and only if the element on given index is succesfully removed from given array.
+     */
+    static RemoveElementAtIndex(index, array) {
+        if (NumberUtils.IsNaN(index) || index < 0 || !Array.isArray(array) || array.length === 0) {
+            return false;
+        }
+        if (index in array) {
+            array.splice(index, 1);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    // Returns true if and only if given array includes given item. Checked by ===.
+    static Includes(array, item) {
+        if (Array.isArray(array)) {
+            for (let i = 0, len = array.length; i < len; i++) {
+                if (array[i] === item) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"array-utils.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/core/utils/array-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {isNill} from \"../function/is-nill.function\";\r\nimport {notNill} from \"../function/not-nill.function\";\r\nimport {StringUtils} from \"./string-utils\";\r\nimport {NumberUtils} from \"./number-utils\";\r\nimport {ObjectUtils} from \"./object-utils\";\r\n\r\nexport class ArrayUtils {\r\n    /**\r\n     * Inserts given element into given array, on given index number.\r\n     *\r\n     * @param index The index position for the element to insert, use negatives to count from the arrays end\r\n     * @param element The element to insert\r\n     * @param array The array to insert the element into\r\n     * @returns True if and only if given element is succesfully inserted into given array.\r\n     */\r\n    public static InsertElement<T>(index: number, element: T, array: T[]): boolean {\r\n        if (!Array.isArray(array) || Math.abs(index) > array.length || isNill(index)) {\r\n            // cannot insert something into nothing, and cannot insert an element into a non-array (via this contract that is), and\r\n            // we will not insert anything beyond the arrays limits (but we can append to the start or end)\r\n            return false;\r\n        }\r\n\r\n        const lenBefore: number = array.length;\r\n        array.splice(index, 0, element);\r\n        return (array.length === lenBefore + 1);\r\n    }\r\n\r\n    /**\r\n     * Removes given element from given array. Doesn't just set it to null like JavaScripts standard 'delete' keyword, but truly removes the\r\n     * element using splice(). Also works on associative arrays.\r\n     *\r\n     * @param element The element to remove.\r\n     * @param array The array to remove the element from.\r\n     * @returns True iff given element was truly successfully removed from given array.\r\n     */\r\n    public static RemoveElement<T>(element: T, array: T[]): boolean {\r\n        if (!Array.isArray(array)) {\r\n            return false;\r\n        }\r\n\r\n        let index: number = array.indexOf(element);\r\n        return ArrayUtils.RemoveElementAtIndex(index, array);\r\n    }\r\n\r\n    /**\r\n     * Returns a true shallow clone of given array plus all its items. Its first-level members are object-shallow-cloned (optionally with a\r\n     * strongly typed constructor),\r\n     * or just as plain object (see param arrayItemsClass).\r\n     * @param arrayGiven\r\n     * @param arrayItemsClass If provided, the cloned array's first-level items will be strongly typed to / constructed as this class. Otherwise\r\n     * it'll be a plain object.\r\n     * @returns a true shallow clone of given array plus all its items\r\n     */\r\n    public static ShallowCloneArrayAndItsItem<T>(arrayGiven: T[], arrayItemsClass?: any): T[] {\r\n        let arrayClone: T[] = [];\r\n\r\n        if (arrayGiven) {\r\n            for (let i: number = 0, len: number = arrayGiven.length; i < len; i++) {\r\n                arrayClone.push(ObjectUtils.GetShallowClone(arrayGiven[i], arrayItemsClass));\r\n            }\r\n        } else {\r\n            return [];\r\n        }\r\n\r\n        return arrayClone;\r\n    }\r\n\r\n    /**\r\n     * Moves given element to given toIndex in given array. Returns whether the element was really moved, thus changing the given array.\r\n     */\r\n    public static MoveElement<T>(element: T, toIndex: number, array: T[]): boolean {\r\n        if (!Array.isArray(array) || isNill(toIndex)) {\r\n            return false;\r\n        }\r\n\r\n        let fromIndex: number = array.indexOf(element);\r\n        let toIndexCorrected: number = NumberUtils.GetNearestNumberWithinBounds(toIndex, 0, array.length - 1);\r\n        if (fromIndex === -1 || array[toIndexCorrected] === element) {\r\n            // element did not exist in given array, or already existed on given toIndex\r\n            return false;\r\n        }\r\n        array.splice(toIndexCorrected, 0, array.splice(fromIndex, 1)[0]);\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * Returns max value from all resulting values from applying given itemValueFunction to all items of given array.\r\n     * @param array\r\n     * @param itemValueFunction The function aplied to each array item that gives it a numerical value. The max num val found is returned.\r\n     */\r\n    public static GetMaxCalculatedValue<T>(array: T[], itemValueFunction: (item: T) => number): number {\r\n        if (!array || !itemValueFunction) {\r\n            return NaN;\r\n        }\r\n\r\n        let max: number = undefined;\r\n\r\n        let len: number = array.length;\r\n        for (let i: number = 0; i < len; i++) {\r\n            let valueCur: number = itemValueFunction.call(this);\r\n            if (valueCur > max) {\r\n                max = valueCur;\r\n            }\r\n        }\r\n\r\n        return max;\r\n    }\r\n\r\n    // Checks if given array is defined, and is an array, and has length > 0, and, optionally checks that the first element is of type given clazz.\r\n    public static IsArrayWithElements<T>(arrayToCheck: T[], clazz?: any): boolean {\r\n        if (isNill(arrayToCheck)) {\r\n            return false;\r\n        }\r\n\r\n        if (Array.isArray(arrayToCheck) && arrayToCheck.length > 0) {\r\n            if (clazz) {\r\n                return arrayToCheck[0] instanceof clazz;\r\n            }\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    // Removes all elements from given array for which given filter function holds true. Returns true if at least one removed, else false.\r\n    public static RemoveElementsByFilter(array: any[], filterFunction: (item: any) => boolean): boolean {\r\n        if (!ArrayUtils.IsArrayWithElements(array) || !filterFunction) {\r\n            return false;\r\n        }\r\n\r\n        let atLeastOneRemoved: boolean = false;\r\n\r\n        let len: number = array.length;\r\n        for (let i: number = len - 1; i >= 0; i--) {\r\n            let item: any = array[i];\r\n            if (filterFunction.call(this, item) === true) {\r\n                array.splice(i, 1);\r\n                atLeastOneRemoved = true;\r\n            }\r\n        }\r\n\r\n        return atLeastOneRemoved;\r\n    }\r\n\r\n    // Replaces the elementOut with given elementIn.\r\n    public static ReplaceElement<T>(elementIn: T, elementOut: T, array: T[]): void {\r\n        if (!array || !Array.isArray(array)) {\r\n            return;\r\n        }\r\n\r\n        const indexOut: number = array.indexOf(elementOut);\r\n        if (indexOut > -1) {\r\n            ArrayUtils.InsertElement(indexOut, elementIn, array);\r\n            ArrayUtils.RemoveElement(elementOut, array);\r\n        }\r\n    }\r\n\r\n    // Swaps the elements in given array with each other. Returns whether a real swap was made. From and To elements have to exist in array.\r\n    public static SwapElements<T>(elementOne: T, elementTwo: T, array: T[]): boolean {\r\n        if (!Array.isArray(array)) {\r\n            return false;\r\n        }\r\n\r\n        const elOneIdx: number = array.indexOf(elementTwo);\r\n        const elTwoIdx: number = array.indexOf(elementOne);\r\n        if (elOneIdx === -1 || elTwoIdx === -1) {\r\n            return false;\r\n        }\r\n\r\n        array[elOneIdx] = array.splice(elTwoIdx, 1, array[elOneIdx])[0];\r\n        return true;\r\n    }\r\n\r\n    // Inserts or removes given toggle element into given elements array; inserts if not yet exists, and removes if already exists.\r\n    public static ToggleElement<T>(toggle: T, elements: T[]): void {\r\n        elements.indexOf(toggle) > -1 ? ArrayUtils.RemoveElement(toggle, elements) : elements.push(toggle);\r\n    }\r\n\r\n    // Returns the number of elements from given array for which given whereFunction holds true.\r\n    public static CountWhere<T>(array: T[], whereFunction: (item: T) => boolean): number {\r\n        if (!ArrayUtils.IsArrayWithElements(array) || !whereFunction) {\r\n            return 0;\r\n        }\r\n\r\n        let count: number = 0;\r\n\r\n        const len: number = array.length;\r\n        for (let i: number = 0; i < len; i++) {\r\n            if (whereFunction.call(this, array[i])) {\r\n                count++;\r\n            }\r\n        }\r\n\r\n        return count;\r\n    }\r\n\r\n    /**\r\n     * Returns whether at least one element in given array could be found by given finder function.\r\n     *\r\n     * @param array\r\n     * @param finder A finder function that takes an element of the array and returns a boolean that represents\r\n     * the 'found status' for that element; whether it should have been found or not.\r\n     */\r\n    public static ContainsAnElementFoundBy<T>(array: T[], finder: (element: T) => boolean): boolean {\r\n        if (!array || !finder) {\r\n            return false;\r\n        }\r\n\r\n        return notNill(ArrayUtils.Find<T>(array, finder));\r\n    }\r\n\r\n    /**\r\n     * Cross-browser Array.find() function. Returns the first item in given array for which the foundBy function returns true. Returns\r\n     * undefined when none was found.\r\n     *\r\n     * Example usage:\r\n     * let foundItem: BusinessObject = ArrayUtils.Find<BusinessObject>(modelArray, (modelItem: BusinessObject) => <br>\r\n     *     (return modelItem.getId() === '1')\r\n     *   * });\r\n     *\r\n     * @param array The array with items to search in.\r\n     * @param foundBy The finder function applied on each items of the array, when that returns true, the item is considered found.\r\n     */\r\n    public static Find<T>(array: T[], foundBy: (item: T) => boolean): T {\r\n        if (!array || !foundBy) {\r\n            return undefined;\r\n        }\r\n\r\n        for (let i: number = 0, len: number = array.length; i < len; i++) {\r\n            let itemCur: T = array[i];\r\n            if (foundBy(itemCur)) {\r\n                return itemCur;\r\n            }\r\n        }\r\n        return undefined;\r\n    }\r\n\r\n    /**\r\n     * Sorts all items in the given array alphabetically (A-to-Z) according to the values of their given property.\r\n     * @param theArray\r\n     * @param propertyName = undefined] When not defined, assumes an array of STRINGS is given, instead of array of OBJECTS.\r\n     * @param [reverseOrder = false] Set to true to sort from Z-to-A instead\r\n     */\r\n    public static SortAlphabetically<T>(theArray: T[], propertyName: string = undefined, reverseOrder: boolean = false): void {\r\n        if (!theArray || !Array.isArray(theArray)) {\r\n            return;\r\n        }\r\n\r\n        let switcher: number = reverseOrder ? -1 : 1;\r\n        let stringSort: boolean = StringUtils.IsStringWithLength(propertyName);\r\n        theArray.sort((itemOne: T, itemTwo: T) => {\r\n            let valOne: any = stringSort ? itemOne[propertyName] : itemOne;\r\n            let valTwo: any = stringSort ? itemTwo[propertyName] : itemTwo;\r\n            return (valOne > valTwo ? 1 : (valOne < valTwo ? -1 : 0)) * switcher;\r\n        });\r\n    }\r\n\r\n    public static PushIfNotExist(item: any, array: any[]): boolean {\r\n        if (!array) {\r\n            return false;\r\n        }\r\n\r\n        if (array.indexOf(item) === -1) {\r\n            array.push(item);\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Removes element at given index from given array. Doesn't just set it to null like JavaScripts standard 'delete' does, but really\r\n     * removes the element using splice().\r\n     *\r\n     * @param index\r\n     * @param array\r\n     * @returns True if and only if the element on given index is succesfully removed from given array.\r\n     */\r\n    public static RemoveElementAtIndex(index: number, array: any[]): boolean {\r\n        if (NumberUtils.IsNaN(index) || index < 0 || !Array.isArray(array) || array.length === 0) {\r\n            return false;\r\n        }\r\n\r\n        if (index in array) {\r\n            array.splice(index, 1);\r\n            return true;\r\n        } else {\r\n            return false;\r\n        }\r\n    }\r\n\r\n    // Returns true if and only if given array includes given item. Checked by ===.\r\n    public static Includes(array: any[], item: any): boolean {\r\n        if (Array.isArray(array)) {\r\n            for (let i: number = 0, len: number = array.length; i < len; i++) {\r\n                if (array[i] === item) {\r\n                    return true;\r\n                }\r\n            }\r\n            return false;\r\n        }\r\n    }\r\n}\r\n"]}

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

@@ -0,0 +1,100 @@
+export class BrowserUtils {
+    static ScrollToTop(nativeElement, milliSeconds = 200) {
+        return BrowserUtils._ScrollTo("scrollTop", nativeElement, milliSeconds, 0);
+    }
+    static DownloadFile(encodedUri, fileType) {
+        const link = document.createElement("a");
+        const date = new Date().toDateString();
+        link.href = encodedUri;
+        link.target = '_blank';
+        link.download = "export_" + date + fileType;
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+    }
+    static CopyToClipboard(data) {
+        const textArea = document.createElement("TEXTAREA");
+        const textNode = document.createTextNode(data);
+        textArea.appendChild(textNode);
+        document.body.appendChild(textArea); // Required for FF
+        textArea.select();
+        document.execCommand("copy");
+        document.body.removeChild(textArea);
+    }
+    static TabFocusNextElement() {
+        const nextTabStop = BrowserUtils._FindNextTabStop(document.activeElement);
+        if (nextTabStop) {
+            nextTabStop.focus();
+        }
+    }
+    static AreDimensionsInView(dimensions, view) {
+        const vp = BrowserUtils.GetDimensions(view);
+        return dimensions.top >= vp.top && dimensions.left >= vp.left && dimensions.bottom <= vp.bottom && dimensions.right <= vp.right;
+    }
+    static HorizontalFitInView(dimensions, view) {
+        const vp = BrowserUtils.GetDimensions(view);
+        return dimensions.left >= vp.left && dimensions.right <= vp.right;
+    }
+    static VerticalFitInView(dimensions, view) {
+        const vp = BrowserUtils.GetDimensions(view);
+        return dimensions.top >= vp.top && dimensions.bottom <= vp.bottom;
+    }
+    static GetViewport() {
+        let viewPortWidth;
+        let viewPortHeight;
+        // the more standards compliant browsers (mozilla/netscape/opera/IE7) use window.innerWidth and window.innerHeight
+        if (typeof window.innerWidth !== 'undefined') {
+            viewPortWidth = window.innerWidth;
+            viewPortHeight = window.innerHeight;
+        }
+        else if (typeof document.documentElement !== 'undefined' &&
+            typeof document.documentElement.clientWidth !== 'undefined' &&
+            document.documentElement.clientWidth !== 0) {
+            viewPortWidth = document.documentElement.clientWidth;
+            viewPortHeight = document.documentElement.clientHeight;
+        }
+        else {
+            viewPortWidth = document.getElementsByTagName('body')[0].clientWidth;
+            viewPortHeight = document.getElementsByTagName('body')[0].clientHeight;
+        }
+        return { left: 0, top: 0, right: viewPortWidth, bottom: viewPortHeight };
+    }
+    static GetDimensions(view) {
+        if (!view) {
+            return this.GetViewport();
+        }
+        else {
+            const elem = view instanceof HTMLElement ? view : view.nativeElement;
+            const cr = elem.getBoundingClientRect();
+            return { left: cr.left, top: cr.top, right: cr.right, bottom: cr.bottom };
+        }
+    }
+    // Recursive.
+    static _ScrollTo(elementScrollProp, element, milliSeconds, toScrollEnd) {
+        if (!element || milliSeconds <= 0) {
+            return;
+        }
+        const difference = toScrollEnd - element[elementScrollProp];
+        const scrollPerTick = difference / milliSeconds * 10;
+        setTimeout(() => {
+            element[elementScrollProp] = element[elementScrollProp] + scrollPerTick;
+            if (element[elementScrollProp] === toScrollEnd) {
+                return;
+            }
+            BrowserUtils._ScrollTo(elementScrollProp, element, milliSeconds - 10, toScrollEnd);
+        }, 10);
+    }
+    static _FindNextTabStop(element) {
+        const tabStopElements = document.querySelectorAll('a[href], area[href], input:not(.hidden):not(.disabled):not(.readonly):not(.read-only), select:not(.hidden):not(.disabled):not(.readonly):not(.read-only), textarea:not(.hidden):not(.disabled):not(.readonly):not(.read-only), button:not(.hidden):not(.disabled):not(.readonly):not(.read-only), iframe, object, embed, *[tabindex]:not(.hidden):not(.disabled):not(.readonly):not(.read-only), *[contenteditable]:not(.hidden):not(.disabled):not(.readonly):not(.read-only)');
+        const actualStopEls = [];
+        for (let i = 0, len = tabStopElements.length; i < len; i++) {
+            const tabEl = tabStopElements[i];
+            if (tabEl.tabIndex >= 0) {
+                actualStopEls.push(tabEl);
+            }
+        }
+        const elIdx = actualStopEls.indexOf(element);
+        return actualStopEls[elIdx + 1] || undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser-utils.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/core/utils/browser-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef } from '@angular/core';\r\nimport { ElementPosition } from '../model/element-position';\r\n\r\nexport class BrowserUtils {\r\n    public static ScrollToTop(nativeElement: any, milliSeconds: number = 200): void {\r\n        return BrowserUtils._ScrollTo(\"scrollTop\", nativeElement, milliSeconds, 0);\r\n    }\r\n\r\n    public static DownloadFile(encodedUri: string, fileType: string): void {\r\n        const link: HTMLAnchorElement = document.createElement(\"a\");\r\n        const date: string = new Date().toDateString();\r\n\r\n        link.href = encodedUri;\r\n        link.target = '_blank';\r\n        link.download = \"export_\" + date + fileType;\r\n\r\n        document.body.appendChild(link);\r\n        link.click();\r\n        document.body.removeChild(link);\r\n    }\r\n\r\n    public static CopyToClipboard(data: string): void {\r\n\r\n        const textArea: any = document.createElement(\"TEXTAREA\");\r\n        const textNode: any = document.createTextNode(data);\r\n\r\n        textArea.appendChild(textNode);\r\n        document.body.appendChild(textArea); // Required for FF\r\n        textArea.select();\r\n        document.execCommand(\"copy\");\r\n        document.body.removeChild(textArea);\r\n    }\r\n\r\n    public static TabFocusNextElement(): void {\r\n        const nextTabStop: any = BrowserUtils._FindNextTabStop(document.activeElement);\r\n        if (nextTabStop) {\r\n            nextTabStop.focus();\r\n        }\r\n    }\r\n\r\n    public static AreDimensionsInView(dimensions: ElementPosition, view?: ElementRef): boolean {\r\n        const vp: ElementPosition = BrowserUtils.GetDimensions(view);\r\n\r\n        return dimensions.top >= vp.top && dimensions.left >= vp.left && dimensions.bottom <= vp.bottom && dimensions.right <= vp.right;\r\n    }\r\n\r\n    public static HorizontalFitInView(dimensions: ElementPosition, view?: ElementRef): boolean {\r\n        const vp: ElementPosition = BrowserUtils.GetDimensions(view);\r\n\r\n        return dimensions.left >= vp.left && dimensions.right <= vp.right;\r\n    }\r\n\r\n    public static VerticalFitInView(dimensions: ElementPosition, view?: ElementRef): boolean {\r\n        const vp: ElementPosition = BrowserUtils.GetDimensions(view);\r\n\r\n        return dimensions.top >= vp.top && dimensions.bottom <= vp.bottom;\r\n    }\r\n\r\n    public static GetViewport(): ElementPosition {\r\n\r\n        let viewPortWidth: number;\r\n        let viewPortHeight: number;\r\n\r\n        // the more standards compliant browsers (mozilla/netscape/opera/IE7) use window.innerWidth and window.innerHeight\r\n        if (typeof window.innerWidth !== 'undefined') {\r\n            viewPortWidth = window.innerWidth;\r\n            viewPortHeight = window.innerHeight;\r\n        } else if (typeof document.documentElement !== 'undefined' &&\r\n            typeof document.documentElement.clientWidth !== 'undefined' &&\r\n            document.documentElement.clientWidth !== 0) {\r\n            viewPortWidth = document.documentElement.clientWidth;\r\n            viewPortHeight = document.documentElement.clientHeight;\r\n        } else {\r\n            viewPortWidth = document.getElementsByTagName('body')[0].clientWidth;\r\n            viewPortHeight = document.getElementsByTagName('body')[0].clientHeight;\r\n        }\r\n\r\n        return {left: 0, top: 0, right: viewPortWidth, bottom: viewPortHeight};\r\n    }\r\n\r\n    public static GetDimensions(view?: ElementRef): ElementPosition {\r\n        if (!view) {\r\n            return this.GetViewport();\r\n        } else {\r\n            const elem: HTMLElement = view instanceof HTMLElement ? view : view.nativeElement;\r\n            const cr: ClientRect = elem.getBoundingClientRect();\r\n            return {left: cr.left, top: cr.top, right: cr.right, bottom: cr.bottom};\r\n        }\r\n    }\r\n\r\n    // Recursive.\r\n    private static _ScrollTo(elementScrollProp: string, element: any, milliSeconds: number, toScrollEnd: number): void {\r\n        if (!element || milliSeconds <= 0) {\r\n            return;\r\n        }\r\n\r\n        const difference: number = toScrollEnd - element[elementScrollProp];\r\n        const scrollPerTick: number = difference / milliSeconds * 10;\r\n\r\n        setTimeout(() => {\r\n            element[elementScrollProp] = element[elementScrollProp] + scrollPerTick;\r\n            if (element[elementScrollProp] === toScrollEnd) {\r\n                return;\r\n            }\r\n            BrowserUtils._ScrollTo(elementScrollProp, element, milliSeconds - 10, toScrollEnd);\r\n        }, 10);\r\n    }\r\n\r\n    private static _FindNextTabStop(element: Element): Element {\r\n        const tabStopElements: NodeListOf<Element> = document.querySelectorAll(\r\n            'a[href], area[href], input:not(.hidden):not(.disabled):not(.readonly):not(.read-only), select:not(.hidden):not(.disabled):not(.readonly):not(.read-only), textarea:not(.hidden):not(.disabled):not(.readonly):not(.read-only), button:not(.hidden):not(.disabled):not(.readonly):not(.read-only), iframe, object, embed, *[tabindex]:not(.hidden):not(.disabled):not(.readonly):not(.read-only), *[contenteditable]:not(.hidden):not(.disabled):not(.readonly):not(.read-only)'\r\n        );\r\n        const actualStopEls: Element[] = [];\r\n        for (let i: number = 0, len: number = tabStopElements.length; i < len; i++) {\r\n            const tabEl: any = tabStopElements[i];\r\n            if (tabEl.tabIndex >= 0) {\r\n                actualStopEls.push(tabEl);\r\n            }\r\n        }\r\n        const elIdx: number = actualStopEls.indexOf(element);\r\n        return actualStopEls[elIdx + 1] || undefined;\r\n    }\r\n}\r\n"]}