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

package/esm5/lib/components/push-panel/push-panel.component.js

@@ -0,0 +1,91 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/push-panel/push-panel.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ElementRef, EventEmitter, Input, Output, ViewChild, Injector } from '@angular/core';
+var PushPanelComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(PushPanelComponent, _super);
+    function PushPanelComponent(injector) {
+        var _this = _super.call(this, injector) || this;
+        _this.onClose = new EventEmitter();
+        return _this;
+    }
+    Object.defineProperty(PushPanelComponent.prototype, "toggle", {
+        set: /**
+         * @private
+         * @param {?} toggle
+         * @return {?}
+         */
+        function (toggle) {
+            this._opened = toggle;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    PushPanelComponent.prototype.onClick = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        /** @type {?} */
+        var checkOpener = this.opener &&
+            (this.opener.contains && this.opener.contains(event.target)) ||
+            (this.opener.nativeElement && this.opener.nativeElement.contains(event.target));
+        if (this._opened &&
+            !this.inside.nativeElement.contains(event.target) &&
+            !checkOpener) {
+            this._opened = false;
+            this.onClose.emit();
+        }
+        return true;
+    };
+    PushPanelComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-push-panel',
+                    template: "<div [ngClass]=\"{ opened: _opened }\" #inside>\n  <ng-content select=\"[inside]\"></ng-content>\n</div>\n<div>\n  <ng-content select=\"[companion]\"></ng-content>\n</div>\n",
+                    host: {
+                        '(document:click)': 'onClick($event)',
+                    },
+                    styles: [":host>div:nth-child(1){position:fixed;z-index:10;overflow-x:hidden;overflow-y:scroll;height:100%;top:0;left:-30%;width:30%;transition:transform .25s}:host>div:nth-child(1).opened{transform:translateX(100%)}:host>div:nth-child(2){position:relative;left:0;opacity:1;transition:transform .25s,opacity .25s}:host>div:nth-child(1).opened+div{opacity:.7;transform:translateX(30%);overflow-x:hidden}"]
+                }] }
+    ];
+    /** @nocollapse */
+    PushPanelComponent.ctorParameters = function () { return [
+        { type: Injector }
+    ]; };
+    PushPanelComponent.propDecorators = {
+        toggle: [{ type: Input }],
+        opener: [{ type: Input }],
+        onClose: [{ type: Output }],
+        inside: [{ type: ViewChild, args: ['inside', { static: false },] }]
+    };
+    return PushPanelComponent;
+}(OdeComponent));
+export { PushPanelComponent };
+if (false) {
+    /** @type {?} */
+    PushPanelComponent.prototype._opened;
+    /**
+     * @type {?}
+     * @private
+     */
+    PushPanelComponent.prototype.opener;
+    /**
+     * @type {?}
+     * @private
+     */
+    PushPanelComponent.prototype.onClose;
+    /**
+     * @type {?}
+     * @private
+     */
+    PushPanelComponent.prototype.inside;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/components/search-input/search-input.component.js

@@ -0,0 +1,199 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/search-input/search-input.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ElementRef, EventEmitter, Input, Output, Renderer2, ViewChild, Injector } from '@angular/core';
+import { Subject } from 'rxjs';
+import { debounceTime, distinctUntilChanged } from 'rxjs/operators';
+var SearchInputComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(SearchInputComponent, _super);
+    function SearchInputComponent(injector, _elRef, _renderer) {
+        var _this = _super.call(this, injector) || this;
+        _this._elRef = _elRef;
+        _this._renderer = _renderer;
+        /* Inputs / Outputs / View */
+        _this.isSearchActive = false;
+        _this.isSearchButtonDisabled = false;
+        _this.searchInput = false;
+        _this._delay = 200;
+        _this.onChange = new EventEmitter();
+        /* Internal logic */
+        _this.$searchTerms = new Subject();
+        return _this;
+    }
+    Object.defineProperty(SearchInputComponent.prototype, "delay", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._delay;
+        },
+        set: /**
+         * @param {?} d
+         * @return {?}
+         */
+        function (d) {
+            var _this = this;
+            this._delay = d;
+            this.observable = this.$searchTerms.pipe(debounceTime(this.delay), distinctUntilChanged());
+            if (this.observer) {
+                this.observer.unsubscribe();
+            }
+            this.observer = this.observable.subscribe((/**
+             * @param {?} val
+             * @return {?}
+             */
+            function (val) {
+                _this.onChange.emit(val);
+            }));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     * @return {?}
+     */
+    SearchInputComponent.prototype.evalAttributes = /**
+     * @private
+     * @return {?}
+     */
+    function () {
+        /** @type {?} */
+        var element = this._elRef.nativeElement;
+        if (element && this.searchBox) {
+            for (var i = 0; i < element.attributes.length; i++) {
+                /** @type {?} */
+                var attr = element.attributes[i];
+                this._renderer.setAttribute(this.searchBox.nativeElement, attr.name, attr.value);
+            }
+        }
+    };
+    /**
+     * @return {?}
+     */
+    SearchInputComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        _super.prototype.ngOnInit.call(this);
+        if (!this.observable) {
+            this.observable = this.$searchTerms
+                .pipe(debounceTime(this.delay), distinctUntilChanged());
+            this.observer = this.observable.subscribe((/**
+             * @param {?} val
+             * @return {?}
+             */
+            function (val) {
+                _this.onChange.emit(val);
+            }));
+        }
+        setTimeout((/**
+         * @return {?}
+         */
+        function () { return _this.evalAttributes(); }), 20);
+    };
+    /**
+     * @return {?}
+     */
+    SearchInputComponent.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        _super.prototype.ngOnDestroy.call(this);
+        this.observer.unsubscribe();
+    };
+    /**
+     * @param {?} str
+     * @return {?}
+     */
+    SearchInputComponent.prototype.search = /**
+     * @param {?} str
+     * @return {?}
+     */
+    function (str) {
+        this.$searchTerms.next(str);
+    };
+    /**
+     * @return {?}
+     */
+    SearchInputComponent.prototype.handleSubmit = /**
+     * @return {?}
+     */
+    function () {
+        this.searchSubmit();
+    };
+    SearchInputComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-search-input',
+                    template: "<form\n    class=\"search-container\"\n    (ngSubmit)=\"searchInput && handleSubmit()\">\n    <input\n        #searchBox\n        class=\"search-input\"\n        name=\"searchTerm\"\n        type=\"search\"\n        (input)=\"search(searchBox.value)\" />\n    <button class=\"search-button\" *ngIf=\"searchInput\" [attr.disabled]=\"isSearchButtonDisabled ? true : null\">\n        <i class=\"fa fa-search is-size-4 search-icon\"></i>\n    </button>\n</form>\n\n<!-- <input *ngIf=\"!searchInput\" type=\"search\" #searchBox (input)=\"search(searchBox.value)\"/> -->",
+                    styles: [":host .search-container{margin:0;display:flex}:host .search-icon{padding-left:0}:host .search-button{margin:0;background:#ff8352;color:#fff}"]
+                }] }
+    ];
+    /** @nocollapse */
+    SearchInputComponent.ctorParameters = function () { return [
+        { type: Injector },
+        { type: ElementRef },
+        { type: Renderer2 }
+    ]; };
+    SearchInputComponent.propDecorators = {
+        isSearchActive: [{ type: Input }],
+        isSearchButtonDisabled: [{ type: Input }],
+        searchInput: [{ type: Input }],
+        searchSubmit: [{ type: Input }],
+        delay: [{ type: Input }],
+        onChange: [{ type: Output }],
+        searchBox: [{ type: ViewChild, args: ['searchBox', { static: false },] }]
+    };
+    return SearchInputComponent;
+}(OdeComponent));
+export { SearchInputComponent };
+if (false) {
+    /** @type {?} */
+    SearchInputComponent.prototype.isSearchActive;
+    /** @type {?} */
+    SearchInputComponent.prototype.isSearchButtonDisabled;
+    /** @type {?} */
+    SearchInputComponent.prototype.searchInput;
+    /** @type {?} */
+    SearchInputComponent.prototype.searchSubmit;
+    /**
+     * @type {?}
+     * @private
+     */
+    SearchInputComponent.prototype._delay;
+    /** @type {?} */
+    SearchInputComponent.prototype.onChange;
+    /** @type {?} */
+    SearchInputComponent.prototype.searchBox;
+    /**
+     * @type {?}
+     * @private
+     */
+    SearchInputComponent.prototype.$searchTerms;
+    /**
+     * @type {?}
+     * @private
+     */
+    SearchInputComponent.prototype.observable;
+    /**
+     * @type {?}
+     * @private
+     */
+    SearchInputComponent.prototype.observer;
+    /**
+     * @type {?}
+     * @private
+     */
+    SearchInputComponent.prototype._elRef;
+    /**
+     * @type {?}
+     * @private
+     */
+    SearchInputComponent.prototype._renderer;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/components/search-toolbar/search-toolbar.component.js

@@ -0,0 +1,93 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/search-toolbar/search-toolbar.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Component, EventEmitter, Injector, Input, Output } from "@angular/core";
+import { OdeComponent } from "ngx-ode-core";
+/**
+ * Search Toolbar component.
+ * Used within List component, Search Toolbar will display following information:
+ * - Label of the search filter section (example: 'Search by')
+ * - List of search type filters (example: 'Name', 'Email' , ...)
+ * - Number of items returned by the search
+ *
+ * ```
+ * <ode-search-toolbar
+ * [label]="'user.searchType.label'"
+ * [searchTypes]="searchTypes"
+ * [nbItem]="nbUser || 0"
+ * [nbItemLabel]="'list.results.users'"
+ * (selectSearchType)="handleSelectSearchType($event)"
+ * >
+ * </ode-search-toolbar>
+ * ```
+ */
+var SearchToolbarComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(SearchToolbarComponent, _super);
+    function SearchToolbarComponent(injector) {
+        var _this = _super.call(this, injector) || this;
+        _this.nbItem = 0;
+        _this.selectSearchType = new EventEmitter();
+        return _this;
+    }
+    /**
+     * @return {?}
+     */
+    SearchToolbarComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        if (this.searchTypes && this.searchTypes.length > 0) {
+            this.selectedSearchTypeValue = this.searchTypes[0].value;
+        }
+    };
+    /**
+     * @param {?} searchTypeValue
+     * @return {?}
+     */
+    SearchToolbarComponent.prototype.handleSearchTypeClick = /**
+     * @param {?} searchTypeValue
+     * @return {?}
+     */
+    function (searchTypeValue) {
+        this.selectedSearchTypeValue = searchTypeValue;
+        this.selectSearchType.emit(searchTypeValue);
+    };
+    SearchToolbarComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-search-toolbar',
+                    template: "<div class=\"search-toolbar\">\n  <div class=\"search-toolbar-label\">\n    <s5l>{{ label }}</s5l>\n    <button\n      *ngFor=\"let searchType of searchTypes\"\n      class=\"button has-left-margin-5\"\n      [ngClass]=\"{\n        'is-selected': searchType.value === selectedSearchTypeValue\n      }\"\n      (click)=\"handleSearchTypeClick(searchType.value)\"\n    >\n      <s5l>{{ searchType.label }}</s5l>\n    </button>\n  </div>\n  <div>\n    <strong class=\"badge\">{{ nbItem }} <s5l>{{ nbItemLabel }}</s5l></strong>\n  </div>\n</div>\n",
+                    styles: [".search-toolbar{display:flex;align-items:center;justify-content:space-between;padding:15px}.search-toolbar .search-toolbar-label{font-size:.85rem}.search-toolbar .search-toolbar-label .button{padding:4px 12px;border-radius:20px;font-size:12px;border-width:2px;border-color:#ff8d2e}"]
+                }] }
+    ];
+    /** @nocollapse */
+    SearchToolbarComponent.ctorParameters = function () { return [
+        { type: Injector }
+    ]; };
+    SearchToolbarComponent.propDecorators = {
+        label: [{ type: Input }],
+        searchTypes: [{ type: Input }],
+        nbItem: [{ type: Input }],
+        nbItemLabel: [{ type: Input }],
+        selectSearchType: [{ type: Output }]
+    };
+    return SearchToolbarComponent;
+}(OdeComponent));
+export { SearchToolbarComponent };
+if (false) {
+    /** @type {?} */
+    SearchToolbarComponent.prototype.label;
+    /** @type {?} */
+    SearchToolbarComponent.prototype.searchTypes;
+    /** @type {?} */
+    SearchToolbarComponent.prototype.nbItem;
+    /** @type {?} */
+    SearchToolbarComponent.prototype.nbItemLabel;
+    /** @type {?} */
+    SearchToolbarComponent.prototype.selectSearchType;
+    /** @type {?} */
+    SearchToolbarComponent.prototype.selectedSearchTypeValue;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/components/side-layout/side-layout.component.js

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/side-layout/side-layout.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, EventEmitter, Input, Output, Injector } from '@angular/core';
+var SideLayoutComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(SideLayoutComponent, _super);
+    function SideLayoutComponent(injector) {
+        var _this = _super.call(this, injector) || this;
+        _this.showCompanion = false;
+        _this.close = new EventEmitter();
+        return _this;
+    }
+    SideLayoutComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-side-layout',
+                    template: "<div class=\"side-layout\">\n  <div class=\"side-card\">\n    <ng-content select=\"[side-card]\"></ng-content>\n  </div>\n  <div class=\"side-companion\" *ngIf=\"showCompanion\">\n    <ng-content select=\"[side-companion]\"></ng-content>\n  </div>\n</div>\n",
+                    styles: ["div.side-layout{display:flex;flex-wrap:nowrap;align-items:flex-start}div.side-card{flex:400px 0 0;position:relative}div.side-companion{flex:1;position:relative;margin-left:25px}"]
+                }] }
+    ];
+    /** @nocollapse */
+    SideLayoutComponent.ctorParameters = function () { return [
+        { type: Injector }
+    ]; };
+    SideLayoutComponent.propDecorators = {
+        showCompanion: [{ type: Input }],
+        close: [{ type: Output, args: ['closeCompanion',] }]
+    };
+    return SideLayoutComponent;
+}(OdeComponent));
+export { SideLayoutComponent };
+if (false) {
+    /** @type {?} */
+    SideLayoutComponent.prototype.showCompanion;
+    /** @type {?} */
+    SideLayoutComponent.prototype.close;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lkZS1sYXlvdXQuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6Im5nOi8vbmd4LW9kZS11aS8iLCJzb3VyY2VzIjpbImxpYi9jb21wb25lbnRzL3NpZGUtbGF5b3V0L3NpZGUtbGF5b3V0LmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQzVDLE9BQU8sRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRWpGO0lBS3lDLCtDQUFZO0lBSWpELDZCQUFZLFFBQWtCO1FBQTlCLFlBQ0ksa0JBQU0sUUFBUSxDQUFDLFNBQ2xCO1FBTFEsbUJBQWEsR0FBRyxLQUFLLENBQUM7UUFDTCxXQUFLLEdBQXVCLElBQUksWUFBWSxFQUFRLENBQUM7O0lBSS9FLENBQUM7O2dCQVhKLFNBQVMsU0FBQztvQkFDUCxRQUFRLEVBQUUsaUJBQWlCO29CQUMzQiw2UUFBMkM7O2lCQUU5Qzs7OztnQkFOZ0QsUUFBUTs7O2dDQVFwRCxLQUFLO3dCQUNMLE1BQU0sU0FBQyxnQkFBZ0I7O0lBSzVCLDBCQUFDO0NBQUEsQUFaRCxDQUt5QyxZQUFZLEdBT3BEO1NBUFksbUJBQW1COzs7SUFDNUIsNENBQStCOztJQUMvQixvQ0FBK0UiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPZGVDb21wb25lbnQgfSBmcm9tICduZ3gtb2RlLWNvcmUnO1xuaW1wb3J0IHsgQ29tcG9uZW50LCBFdmVudEVtaXR0ZXIsIElucHV0LCBPdXRwdXQsIEluamVjdG9yIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICAgIHNlbGVjdG9yOiAnb2RlLXNpZGUtbGF5b3V0JyxcbiAgICB0ZW1wbGF0ZVVybDogJy4vc2lkZS1sYXlvdXQuY29tcG9uZW50Lmh0bWwnLFxuICAgIHN0eWxlVXJsczogWycuL3NpZGUtbGF5b3V0LmNvbXBvbmVudC5zY3NzJ11cbn0pXG5leHBvcnQgY2xhc3MgU2lkZUxheW91dENvbXBvbmVudCBleHRlbmRzIE9kZUNvbXBvbmVudCB7XG4gICAgQElucHV0KCkgc2hvd0NvbXBhbmlvbiA9IGZhbHNlO1xuICAgIEBPdXRwdXQoJ2Nsb3NlQ29tcGFuaW9uJykgY2xvc2U6IEV2ZW50RW1pdHRlcjx2b2lkPiA9IG5ldyBFdmVudEVtaXR0ZXI8dm9pZD4oKTtcblxuICAgIGNvbnN0cnVjdG9yKGluamVjdG9yOiBJbmplY3Rvcikge1xuICAgICAgICBzdXBlcihpbmplY3Rvcik7XG4gICAgfVxufVxuIl19

package/esm5/lib/components/side-panel/side-panel.component.js

@@ -0,0 +1,85 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/side-panel/side-panel.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ElementRef, EventEmitter, Input, Output, Injector } from '@angular/core';
+var SidePanelComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(SidePanelComponent, _super);
+    function SidePanelComponent(injector, elementRef) {
+        var _this = _super.call(this, injector) || this;
+        _this.elementRef = elementRef;
+        _this.onClose = new EventEmitter();
+        return _this;
+    }
+    Object.defineProperty(SidePanelComponent.prototype, "toggle", {
+        set: /**
+         * @param {?} toggle
+         * @return {?}
+         */
+        function (toggle) {
+            this.opened = toggle;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    SidePanelComponent.prototype.onClick = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        /** @type {?} */
+        var checkOpener = this.opener &&
+            (this.opener.contains && this.opener.contains(event.target)) ||
+            (this.opener.nativeElement && this.opener.nativeElement.contains(event.target));
+        if (this.opened &&
+            !this.elementRef.nativeElement.contains(event.target) &&
+            !checkOpener) {
+            this.opened = false;
+            this.onClose.emit();
+        }
+        return true;
+    };
+    SidePanelComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-side-panel',
+                    template: "<div [ngClass]=\"{ opened: opened }\">\n  <ng-content></ng-content>\n</div>\n",
+                    host: {
+                        '(document:click)': 'onClick($event)',
+                    },
+                    styles: ["div{position:fixed;z-index:10;overflow-x:hidden;overflow-y:scroll;top:0;left:-30%;width:30%;transition:transform .25s}div.opened{transform:translateX(100%)}"]
+                }] }
+    ];
+    /** @nocollapse */
+    SidePanelComponent.ctorParameters = function () { return [
+        { type: Injector },
+        { type: ElementRef }
+    ]; };
+    SidePanelComponent.propDecorators = {
+        toggle: [{ type: Input }],
+        opener: [{ type: Input }],
+        onClose: [{ type: Output }]
+    };
+    return SidePanelComponent;
+}(OdeComponent));
+export { SidePanelComponent };
+if (false) {
+    /** @type {?} */
+    SidePanelComponent.prototype.opened;
+    /** @type {?} */
+    SidePanelComponent.prototype.opener;
+    /** @type {?} */
+    SidePanelComponent.prototype.onClose;
+    /**
+     * @type {?}
+     * @private
+     */
+    SidePanelComponent.prototype.elementRef;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/components/spinner-cube/spinner-cube.component.js

@@ -0,0 +1,76 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/spinner-cube/spinner-cube.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { OdeComponent } from 'ngx-ode-core';
+import { ChangeDetectionStrategy, Component, Input, Injector } from '@angular/core';
+import { SpinnerService } from '../../services/spinner.service';
+var SpinnerCubeComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(SpinnerCubeComponent, _super);
+    function SpinnerCubeComponent(injector, spinner) {
+        var _this = _super.call(this, injector) || this;
+        _this.spinner = spinner;
+        return _this;
+    }
+    Object.defineProperty(SpinnerCubeComponent.prototype, "loadingProp", {
+        get: /**
+         * @return {?}
+         */
+        function () { return this._loadingProp; },
+        set: /**
+         * @param {?} prop
+         * @return {?}
+         */
+        function (prop) {
+            this._loadingProp = prop;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    SpinnerCubeComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        _super.prototype.ngOnInit.call(this);
+        this.subscriptions.add(this.spinner.trigger.subscribe((/**
+         * @return {?}
+         */
+        function () {
+            _this.changeDetector.markForCheck();
+        })));
+    };
+    SpinnerCubeComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-spinner-cube',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: "<div class=\"spinner-wrapper\" *ngIf=\"spinner.isLoading(loadingProp)\">\n  <div class=\"spinner-cube\">\n    <div class=\"sk-cube sk-cube1\"></div>\n    <div class=\"sk-cube sk-cube2\"></div>\n    <div class=\"sk-cube sk-cube3\"></div>\n    <div class=\"sk-cube sk-cube4\"></div>\n    <div class=\"sk-cube sk-cube5\"></div>\n    <div class=\"sk-cube sk-cube6\"></div>\n    <div class=\"sk-cube sk-cube7\"></div>\n    <div class=\"sk-cube sk-cube8\"></div>\n    <div class=\"sk-cube sk-cube9\"></div>\n  </div>\n</div>\n",
+                    styles: ["div.spinner-wrapper{position:fixed;width:100%;height:100%;pointer-events:all;display:flex;justify-content:center;align-items:center}div.spinner-cube{width:20vh;height:20vh}div.sk-cube{width:33%;height:33%;float:left;-webkit-animation:1.3s ease-in-out infinite sk-cubeGridScaleDelay;animation:1.3s ease-in-out infinite sk-cubeGridScaleDelay}div.sk-cube1{-webkit-animation-delay:.2s;animation-delay:.2s}div.sk-cube2{-webkit-animation-delay:.3s;animation-delay:.3s}div.sk-cube3{-webkit-animation-delay:.4s;animation-delay:.4s}div.sk-cube4{-webkit-animation-delay:.1s;animation-delay:.1s}div.sk-cube5{-webkit-animation-delay:.2s;animation-delay:.2s}div.sk-cube6{-webkit-animation-delay:.3s;animation-delay:.3s}div.sk-cube7{-webkit-animation-delay:0s;animation-delay:0s}div.sk-cube8{-webkit-animation-delay:.1s;animation-delay:.1s}div.sk-cube9{-webkit-animation-delay:.2s;animation-delay:.2s}@-webkit-keyframes sk-cubeGridScaleDelay{0%,100%,70%{transform:scale3D(1,1,1)}35%{transform:scale3D(0,0,1)}}@keyframes sk-cubeGridScaleDelay{0%,100%,70%{transform:scale3D(1,1,1)}35%{transform:scale3D(0,0,1)}}"]
+                }] }
+    ];
+    /** @nocollapse */
+    SpinnerCubeComponent.ctorParameters = function () { return [
+        { type: Injector },
+        { type: SpinnerService }
+    ]; };
+    SpinnerCubeComponent.propDecorators = {
+        loadingProp: [{ type: Input, args: ['waitingFor',] }]
+    };
+    return SpinnerCubeComponent;
+}(OdeComponent));
+export { SpinnerCubeComponent };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    SpinnerCubeComponent.prototype._loadingProp;
+    /** @type {?} */
+    SpinnerCubeComponent.prototype.spinner;
+}
+//# sourceMappingURL=data:application/json;base64,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