ngx-ode-ui 4.6.0-dev-produit.3 → 4.6.0-dev-integration.2

package/esm2015/lib/pipes/orderBy.pipe.js

@@ -0,0 +1,269 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/pipes/orderBy.pipe.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Pipe } from '@angular/core';
+export class OrderPipe {
+    /**
+     * @param {?} array
+     * @param {?} sortPredicate
+     * @param {?=} reverseOrder
+     * @param {?=} compareFn
+     * @return {?}
+     */
+    transform(array, sortPredicate, reverseOrder, compareFn) {
+        if (array == null || !sortPredicate) {
+            return array;
+        }
+        /**
+         * **
+         * @type {?}
+         */
+        const isString = (/**
+         * @param {?} value
+         * @return {?}
+         */
+        (value) => {
+            return typeof value === 'string';
+        });
+        /** @type {?} */
+        const isFunction = (/**
+         * @param {?} value
+         * @return {?}
+         */
+        (value) => {
+            return typeof value === 'function';
+        });
+        /** @type {?} */
+        const isArray = (/**
+         * @param {?} value
+         * @return {?}
+         */
+        (value) => {
+            return value && value instanceof Array;
+        });
+        /** @type {?} */
+        const isObject = (/**
+         * @param {?} value
+         * @return {?}
+         */
+        (value) => {
+            return typeof value === 'object';
+        });
+        /** @type {?} */
+        const isPrimitive = (/**
+         * @param {?} value
+         * @return {?}
+         */
+        (value) => {
+            switch (typeof value) {
+                case 'number': /* falls through */
+                case 'boolean': /* falls through */
+                case 'string':
+                    return true;
+                default:
+                    return false;
+            }
+        });
+        /** @type {?} */
+        const hasCustomToString = (/**
+         * @param {?} value
+         * @return {?}
+         */
+        (value) => {
+            return value &&
+                typeof value.toString === 'function' &&
+                value.toString !== Object.prototype.toString;
+        });
+        /** @type {?} */
+        const getComparisonObject = (/**
+         * @param {?} value
+         * @param {?} index
+         * @return {?}
+         */
+        (value, index) => {
+            // NOTE: We are adding an extra `tieBreaker` value based on the element's index.
+            // This will be used to keep the sort stable when none of the input predicates can
+            // distinguish between two elements.
+            return {
+                value,
+                tieBreaker: { value: index, type: 'number', index },
+                predicateValues: predicates.map((/**
+                 * @param {?} predicate
+                 * @return {?}
+                 */
+                function (predicate) {
+                    return getPredicateValue(predicate.get(value), index);
+                }))
+            };
+        });
+        /** @type {?} */
+        const doComparison = (/**
+         * @param {?} v1
+         * @param {?} v2
+         * @return {?}
+         */
+        (v1, v2) => {
+            for (let i = 0, ii = predicates.length; i < ii; i++) {
+                /** @type {?} */
+                const result = compare(v1.predicateValues[i], v2.predicateValues[i]);
+                if (result) {
+                    return result * predicates[i].descending * descending;
+                }
+            }
+            return compare(v1.tieBreaker, v2.tieBreaker) * descending;
+        });
+        /** @type {?} */
+        const processPredicates = (/**
+         * @param {?} sortPredicates
+         * @return {?}
+         */
+        (sortPredicates) => {
+            return sortPredicates.map((/**
+             * @param {?} predicate
+             * @return {?}
+             */
+            function (predicate) {
+                /** @type {?} */
+                let descending = 1;
+                /** @type {?} */
+                let get = (/**
+                 * @param {?} value
+                 * @return {?}
+                 */
+                (value) => value);
+                if (isFunction(predicate)) {
+                    get = predicate;
+                }
+                else if (isString(predicate)) {
+                    if ((predicate.charAt(0) === '+' || predicate.charAt(0) === '-')) {
+                        descending = predicate.charAt(0) === '-' ? -1 : 1;
+                        predicate = predicate.substring(1);
+                    }
+                    if (predicate !== '') {
+                        get = (/**
+                         * @param {?} value
+                         * @return {?}
+                         */
+                        (value) => value[predicate]);
+                    }
+                }
+                return { get, descending };
+            }));
+        });
+        /** @type {?} */
+        const objectValue = (/**
+         * @param {?} value
+         * @return {?}
+         */
+        (value) => {
+            // If `valueOf` is a valid function use that
+            if (isFunction(value.valueOf)) {
+                value = value.valueOf();
+                if (isPrimitive(value)) {
+                    return value;
+                }
+            }
+            // If `toString` is a valid function and not the one from `Object.prototype` use that
+            if (hasCustomToString(value)) {
+                value = value.toString();
+                if (isPrimitive(value)) {
+                    return value;
+                }
+            }
+            return value;
+        });
+        /** @type {?} */
+        const getPredicateValue = (/**
+         * @param {?} value
+         * @param {?} index
+         * @return {?}
+         */
+        (value, index) => {
+            /** @type {?} */
+            let type = typeof value;
+            if (value === null) {
+                type = 'string';
+                value = 'null';
+            }
+            else if (type === 'object') {
+                value = objectValue(value);
+            }
+            return { value, type, index };
+        });
+        /** @type {?} */
+        const defaultCompare = (/**
+         * @param {?} v1
+         * @param {?} v2
+         * @return {?}
+         */
+        (v1, v2) => {
+            /** @type {?} */
+            let result = 0;
+            /** @type {?} */
+            const type1 = v1.type;
+            /** @type {?} */
+            const type2 = v2.type;
+            if (type1 === type2) {
+                /** @type {?} */
+                let value1 = v1.value;
+                /** @type {?} */
+                let value2 = v2.value;
+                if (type1 === 'string') {
+                    // Compare strings case-insensitively
+                    value1 = value1.toLowerCase();
+                    value2 = value2.toLowerCase();
+                    result = value1.localeCompare(value2);
+                }
+                else if (type1 === 'object') {
+                    // For basic objects, use the position of the object
+                    // in the collection instead of the value
+                    if (isObject(value1)) {
+                        value1 = v1.index;
+                    }
+                    if (isObject(value2)) {
+                        value2 = v2.index;
+                    }
+                    if (value1 !== value2) {
+                        result = value1 < value2 ? -1 : 1;
+                    }
+                }
+            }
+            else {
+                result = type1 < type2 ? -1 : 1;
+            }
+            return result;
+        });
+        /*** ***/
+        if (!isArray(sortPredicate)) {
+            sortPredicate = [sortPredicate];
+        }
+        if (sortPredicate.length === 0) {
+            sortPredicate = ['+'];
+        }
+        /** @type {?} */
+        const predicates = processPredicates(sortPredicate);
+        /** @type {?} */
+        const descending = reverseOrder ? -1 : 1;
+        // Define the `compare()` function. Use a default comparator if none is specified.
+        /** @type {?} */
+        const compare = isFunction(compareFn) ? compareFn : defaultCompare;
+        // The next three lines are a version of a Swartzian Transform idiom from Perl
+        // (sometimes called the Decorate-Sort-Undecorate idiom)
+        // See https://en.wikipedia.org/wiki/Schwartzian_transform
+        /** @type {?} */
+        const compareValues = Array.prototype.map.call(array, getComparisonObject);
+        compareValues.sort(doComparison);
+        array = compareValues.map((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) { return item.value; }));
+        return array;
+    }
+}
+OrderPipe.decorators = [
+    { type: Pipe, args: [{ name: 'orderBy' },] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"orderBy.pipe.js","sourceRoot":"ng://ngx-ode-ui/","sources":["lib/pipes/orderBy.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import {Pipe, PipeTransform} from '@angular/core';\n\n@Pipe({ name: 'orderBy' })\nexport class OrderPipe implements PipeTransform {\n\n    transform(array, sortPredicate, reverseOrder?, compareFn?) {\n        if (array == null || !sortPredicate) { return array; }\n\n        /*** ***/\n        const isString = (value) => {\n            return typeof value === 'string';\n        };\n\n        const isFunction = (value) => {\n            return typeof value === 'function';\n        };\n\n        const isArray = (value) => {\n            return value && value instanceof Array;\n        };\n\n        const isObject = (value) => {\n            return typeof value === 'object';\n        };\n\n        const isPrimitive = (value) => {\n            switch (typeof value) {\n                case 'number': /* falls through */\n                case 'boolean': /* falls through */\n                case 'string':\n                    return true;\n                default:\n                    return false;\n            }\n        };\n\n        const hasCustomToString = (value) => {\n            return value &&\n                typeof value.toString === 'function' &&\n                    value.toString !== Object.prototype.toString;\n        };\n\n        const getComparisonObject = (value, index) => {\n            // NOTE: We are adding an extra `tieBreaker` value based on the element's index.\n            // This will be used to keep the sort stable when none of the input predicates can\n            // distinguish between two elements.\n            return {\n                value,\n                tieBreaker: { value: index, type: 'number', index },\n                predicateValues: predicates.map(function(predicate) {\n                    return getPredicateValue(predicate.get(value), index);\n                })\n            };\n        };\n\n        const doComparison = (v1, v2) => {\n            for (let i = 0, ii = predicates.length; i < ii; i++) {\n                const result = compare(v1.predicateValues[i], v2.predicateValues[i]);\n                if (result) {\n                    return result * predicates[i].descending * descending;\n                }\n            }\n\n            return compare(v1.tieBreaker, v2.tieBreaker) * descending;\n        };\n\n        const processPredicates = (sortPredicates) => {\n            return sortPredicates.map(function(predicate) {\n                let descending = 1, get = (value) => value;\n\n                if (isFunction(predicate)) {\n                    get = predicate;\n                } else if (isString(predicate)) {\n                    if ((predicate.charAt(0) === '+' || predicate.charAt(0) === '-')) {\n                        descending = predicate.charAt(0) === '-' ? -1 : 1;\n                        predicate = predicate.substring(1);\n                    }\n                    if (predicate !== '') {\n                        get = (value) => value[predicate];\n                    }\n                }\n                return { get, descending };\n            });\n        };\n\n        const objectValue = (value) => {\n            // If `valueOf` is a valid function use that\n            if (isFunction(value.valueOf)) {\n                value = value.valueOf();\n                if (isPrimitive(value)) { return value; }\n            }\n            // If `toString` is a valid function and not the one from `Object.prototype` use that\n            if (hasCustomToString(value)) {\n                value = value.toString();\n                if (isPrimitive(value)) { return value; }\n            }\n\n            return value;\n        };\n\n        const getPredicateValue = (value, index) => {\n            let type = typeof value;\n            if (value === null) {\n                type = 'string';\n                value = 'null';\n            } else if (type === 'object') {\n                value = objectValue(value);\n            }\n            return { value, type, index };\n        };\n\n        const defaultCompare = (v1, v2) => {\n            let result = 0;\n            const type1 = v1.type;\n            const type2 = v2.type;\n\n            if (type1 === type2) {\n                let value1 = v1.value;\n                let value2 = v2.value;\n\n                if (type1 === 'string') {\n                    // Compare strings case-insensitively\n                    value1 = value1.toLowerCase();\n                    value2 = value2.toLowerCase();\n\n                    result = value1.localeCompare(value2);\n                } else if (type1 === 'object') {\n                    // For basic objects, use the position of the object\n                    // in the collection instead of the value\n                    if (isObject(value1)) { value1 = v1.index; }\n                    if (isObject(value2)) { value2 = v2.index; }\n\n                    if (value1 !== value2) {\n                      result = value1 < value2 ? -1 : 1;\n                    }\n                }\n            } else {\n                result = type1 < type2 ? -1 : 1;\n            }\n\n            return result;\n        };\n        /*** ***/\n\n        if (!isArray(sortPredicate)) {\n            sortPredicate = [sortPredicate];\n        }\n        if (sortPredicate.length === 0) {\n            sortPredicate = ['+'];\n        }\n\n        const predicates = processPredicates(sortPredicate);\n\n        const descending = reverseOrder ? -1 : 1;\n\n        // Define the `compare()` function. Use a default comparator if none is specified.\n        const compare = isFunction(compareFn) ? compareFn : defaultCompare;\n\n        // The next three lines are a version of a Swartzian Transform idiom from Perl\n        // (sometimes called the Decorate-Sort-Undecorate idiom)\n        // See https://en.wikipedia.org/wiki/Schwartzian_transform\n        const compareValues = Array.prototype.map.call(array, getComparisonObject);\n        compareValues.sort(doComparison);\n        array = compareValues.map(function(item) { return item.value; });\n\n        return array;\n    }\n\n}\n"]}

package/esm2015/lib/pipes/store.pipe.js

@@ -0,0 +1,24 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/pipes/store.pipe.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Pipe } from '@angular/core';
+export class StorePipe {
+    /**
+     * @param {?} value
+     * @param {?} context
+     * @param {?=} prop
+     * @return {?}
+     */
+    transform(value, context, prop = '_storedRef') {
+        context[prop] = value;
+        return value;
+    }
+}
+StorePipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'store'
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmUucGlwZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25neC1vZGUtdWkvIiwic291cmNlcyI6WyJsaWIvcGlwZXMvc3RvcmUucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLE9BQU8sRUFBQyxJQUFJLEVBQWdCLE1BQU0sZUFBZSxDQUFDO0FBS2xELE1BQU0sT0FBTyxTQUFTOzs7Ozs7O0lBRWxCLFNBQVMsQ0FBQyxLQUFLLEVBQUUsT0FBTyxFQUFFLElBQUksR0FBRyxZQUFZO1FBQ3pDLE9BQU8sQ0FBQyxJQUFJLENBQUMsR0FBRyxLQUFLLENBQUM7UUFDdEIsT0FBTyxLQUFLLENBQUM7SUFDakIsQ0FBQzs7O1lBUkosSUFBSSxTQUFDO2dCQUNGLElBQUksRUFBRSxPQUFPO2FBQ2hCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtQaXBlLCBQaXBlVHJhbnNmb3JtfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQFBpcGUoe1xuICAgIG5hbWU6ICdzdG9yZSdcbn0pXG5leHBvcnQgY2xhc3MgU3RvcmVQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG5cbiAgICB0cmFuc2Zvcm0odmFsdWUsIGNvbnRleHQsIHByb3AgPSAnX3N0b3JlZFJlZicpIHtcbiAgICAgICAgY29udGV4dFtwcm9wXSA9IHZhbHVlO1xuICAgICAgICByZXR1cm4gdmFsdWU7XG4gICAgfVxuXG59XG4iXX0=

package/esm2015/lib/services/dynamicModuleImports.service.js

@@ -0,0 +1,19 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/services/dynamicModuleImports.service.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Injectable } from '@angular/core';
+export class DynamicModuleImportsService {
+    constructor() {
+        this.imports = [];
+    }
+}
+DynamicModuleImportsService.decorators = [
+    { type: Injectable }
+];
+if (false) {
+    /** @type {?} */
+    DynamicModuleImportsService.prototype.imports;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pY01vZHVsZUltcG9ydHMuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25neC1vZGUtdWkvIiwic291cmNlcyI6WyJsaWIvc2VydmljZXMvZHluYW1pY01vZHVsZUltcG9ydHMuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFHekMsTUFBTSxPQUFPLDJCQUEyQjtJQUR4QztRQUVJLFlBQU8sR0FBRyxFQUFFLENBQUM7SUFDakIsQ0FBQzs7O1lBSEEsVUFBVTs7OztJQUVQLDhDQUFhIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3RhYmxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIER5bmFtaWNNb2R1bGVJbXBvcnRzU2VydmljZSB7XG4gICAgaW1wb3J0cyA9IFtdO1xufVxuIl19

package/esm2015/lib/services/inputFile.service.js

@@ -0,0 +1,80 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/services/inputFile.service.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { throwError as observableThrowError, Observable } from 'rxjs';
+import { Injectable } from '@angular/core';
+export class InputFileService {
+    /**
+     * @param {?} files
+     * @param {?} maxFilesNumber
+     * @param {?} allowedExtensions
+     * @return {?}
+     */
+    validateFiles(files, maxFilesNumber, allowedExtensions) {
+        if (!files) {
+            return observableThrowError('files is empty');
+        }
+        if (files.length > maxFilesNumber) {
+            return observableThrowError(`Only ${maxFilesNumber} file(s) allowed`);
+        }
+        /** @type {?} */
+        const validFiles = [];
+        /** @type {?} */
+        const invalidFiles = [];
+        for (let i = 0; i < files.length; i++) {
+            /** @type {?} */
+            const filenameSplit = files[i].name.split('.');
+            /** @type {?} */
+            const ext = filenameSplit[filenameSplit.length - 1];
+            if (allowedExtensions.lastIndexOf(ext.toLowerCase()) !== -1) {
+                validFiles.push(files[i]);
+            }
+            else {
+                invalidFiles.push(files[i]);
+            }
+        }
+        return new Observable((/**
+         * @param {?} observer
+         * @return {?}
+         */
+        observer => {
+            if (validFiles.length > 0) {
+                observer.next(validFiles);
+            }
+            if (invalidFiles.length > 0) {
+                observer.error(`Extension not allowed. Allowed extensions: ${allowedExtensions}`);
+            }
+            observer.complete();
+        }));
+    }
+    /**
+     * @param {?} src
+     * @return {?}
+     */
+    isSrcExternalUrl(src) {
+        if (src) {
+            return src.startsWith('http://') || src.startsWith('https://');
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * @param {?} src
+     * @return {?}
+     */
+    isSrcWorkspace(src) {
+        if (src) {
+            return src.startsWith('/workspace');
+        }
+        else {
+            return false;
+        }
+    }
+}
+InputFileService.decorators = [
+    { type: Injectable }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/labels.service.js

@@ -0,0 +1,54 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/services/labels.service.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Injectable } from '@angular/core';
+export class LabelsService {
+    constructor() {
+        this.labels = {
+            'select.all': 'Select all',
+            'deselect.all': 'Deselect all',
+            search: 'Search'
+        };
+    }
+    /**
+     * @param {?} labels
+     * @return {?}
+     */
+    static withLabels(labels) {
+        /** @type {?} */
+        const newService = new LabelsService();
+        for (const prop in labels) {
+            newService.labels[prop] = labels[prop];
+        }
+        return newService;
+    }
+    /**
+     * @param {?} label
+     * @return {?}
+     */
+    getLabel(label) {
+        return this.labels[label] || label;
+    }
+    /**
+     * @param {?} labels
+     * @return {?}
+     */
+    mixin(labels) {
+        for (const property in labels) {
+            this.labels[property] = labels[property];
+        }
+    }
+}
+LabelsService.decorators = [
+    { type: Injectable }
+];
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    LabelsService.prototype.labels;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFiZWxzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9uZ3gtb2RlLXVpLyIsInNvdXJjZXMiOlsibGliL3NlcnZpY2VzL2xhYmVscy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUd6QyxNQUFNLE9BQU8sYUFBYTtJQUQxQjtRQUdZLFdBQU0sR0FBRztZQUNiLFlBQVksRUFBRSxZQUFZO1lBQzFCLGNBQWMsRUFBRSxjQUFjO1lBQzlCLE1BQU0sRUFBRSxRQUFRO1NBQ25CLENBQUM7SUFtQk4sQ0FBQzs7Ozs7SUFqQkcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFjOztjQUN0QixVQUFVLEdBQUcsSUFBSSxhQUFhLEVBQUU7UUFDdEMsS0FBSyxNQUFNLElBQUksSUFBSSxNQUFNLEVBQUU7WUFDdkIsVUFBVSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7U0FDMUM7UUFDRCxPQUFPLFVBQVUsQ0FBQztJQUN0QixDQUFDOzs7OztJQUVELFFBQVEsQ0FBQyxLQUFhO1FBQ2xCLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsSUFBSSxLQUFLLENBQUM7SUFDdkMsQ0FBQzs7Ozs7SUFFRCxLQUFLLENBQUMsTUFBYztRQUNoQixLQUFLLE1BQU0sUUFBUSxJQUFJLE1BQU0sRUFBRTtZQUMzQixJQUFJLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQztTQUM1QztJQUNMLENBQUM7OztZQXpCSixVQUFVOzs7Ozs7O0lBR1AsK0JBSUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGFibGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgTGFiZWxzU2VydmljZSB7XG5cbiAgICBwcml2YXRlIGxhYmVscyA9IHtcbiAgICAgICAgJ3NlbGVjdC5hbGwnOiAnU2VsZWN0IGFsbCcsXG4gICAgICAgICdkZXNlbGVjdC5hbGwnOiAnRGVzZWxlY3QgYWxsJyxcbiAgICAgICAgc2VhcmNoOiAnU2VhcmNoJ1xuICAgIH07XG5cbiAgICBzdGF0aWMgd2l0aExhYmVscyhsYWJlbHM6IE9iamVjdCkge1xuICAgICAgICBjb25zdCBuZXdTZXJ2aWNlID0gbmV3IExhYmVsc1NlcnZpY2UoKTtcbiAgICAgICAgZm9yIChjb25zdCBwcm9wIGluIGxhYmVscykge1xuICAgICAgICAgICAgbmV3U2VydmljZS5sYWJlbHNbcHJvcF0gPSBsYWJlbHNbcHJvcF07XG4gICAgICAgIH1cbiAgICAgICAgcmV0dXJuIG5ld1NlcnZpY2U7XG4gICAgfVxuXG4gICAgZ2V0TGFiZWwobGFiZWw6IHN0cmluZykge1xuICAgICAgICByZXR1cm4gdGhpcy5sYWJlbHNbbGFiZWxdIHx8IGxhYmVsO1xuICAgIH1cblxuICAgIG1peGluKGxhYmVsczogT2JqZWN0KSB7XG4gICAgICAgIGZvciAoY29uc3QgcHJvcGVydHkgaW4gbGFiZWxzKSB7XG4gICAgICAgICAgICB0aGlzLmxhYmVsc1twcm9wZXJ0eV0gPSBsYWJlbHNbcHJvcGVydHldO1xuICAgICAgICB9XG4gICAgfVxufVxuIl19

package/esm2015/lib/services/spinner.service.js

@@ -0,0 +1,163 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/services/spinner.service.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { ApplicationRef, Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+export class SpinnerService {
+    /**
+     * @param {?} appRef
+     */
+    constructor(appRef) {
+        this.appRef = appRef;
+        this.timer = 250;
+        this.loading = new Set();
+        this.timers = new Map();
+        this._trigger = new Subject();
+        this.wrap = (/**
+         * @param {?} func
+         * @param {?} label
+         * @param {?=} props
+         * @param {...?} args
+         * @return {?}
+         */
+        (func, label, props = {}, ...args) => {
+            this.load(label, props.delay);
+            /** @type {?} */
+            const promise = props.binding ?
+                func.bind(props.binding)(...args) :
+                func(...args);
+            promise.catch((/**
+             * @param {?} err
+             * @return {?}
+             */
+            (err) => {
+                this.done(label);
+                throw err;
+            })).then((/**
+             * @param {?} _
+             * @return {?}
+             */
+            _ => {
+                this.done(label);
+                return _;
+            }));
+            if (props.cdRef) {
+                props.cdRef.markForCheck();
+            }
+            return promise;
+        });
+    }
+    /**
+     * @return {?}
+     */
+    get trigger() {
+        return this._trigger;
+    }
+    /**
+     * @param {?} something
+     * @param {?=} pending
+     * @return {?}
+     */
+    isLoading(something, pending = false) {
+        return this.loading.has(something) ||
+            (pending && this.timers.has(something));
+    }
+    /**
+     * @template T
+     * @param {?} something
+     * @param {?} promise
+     * @param {?=} timer
+     * @return {?}
+     */
+    perform(something, promise, timer) {
+        this.load(something, timer);
+        return promise.catch((/**
+         * @param {?} err
+         * @return {?}
+         */
+        err => {
+            this.done(something);
+            throw err;
+        })).then((/**
+         * @param {?} _
+         * @return {?}
+         */
+        _ => {
+            this.done(something);
+            return _;
+        }));
+    }
+    /**
+     * @param {?} something
+     * @param {?=} timer
+     * @return {?}
+     */
+    load(something, timer) {
+        if (this.timers.has(something)) {
+            window.clearTimeout(this.timers.get(something));
+        }
+        /** @type {?} */
+        const addToQueue = (/**
+         * @return {?}
+         */
+        () => {
+            this.loading.add(something);
+            this.timers.delete(something);
+            this.appRef.tick();
+            this.trigger.next(true);
+        });
+        if (timer === 0) {
+            addToQueue();
+        }
+        else {
+            this.timers.set(something, window.setTimeout(addToQueue, timer || this.timer));
+        }
+    }
+    /**
+     * @param {?} something
+     * @return {?}
+     */
+    done(something) {
+        window.clearTimeout(this.timers.get(something));
+        this.timers.delete(something);
+        this.loading.delete(something);
+        this.trigger.next(true);
+        this.appRef.tick();
+    }
+}
+SpinnerService.decorators = [
+    { type: Injectable }
+];
+/** @nocollapse */
+SpinnerService.ctorParameters = () => [
+    { type: ApplicationRef }
+];
+if (false) {
+    /** @type {?} */
+    SpinnerService.prototype.timer;
+    /**
+     * @type {?}
+     * @private
+     */
+    SpinnerService.prototype.loading;
+    /**
+     * @type {?}
+     * @private
+     */
+    SpinnerService.prototype.timers;
+    /**
+     * @type {?}
+     * @private
+     */
+    SpinnerService.prototype._trigger;
+    /** @type {?} */
+    SpinnerService.prototype.wrap;
+    /**
+     * @type {?}
+     * @private
+     */
+    SpinnerService.prototype.appRef;
+}
+//# sourceMappingURL=data:application/json;base64,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