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

package/esm5/lib/components/lightbox/lightbox.component.js

@@ -0,0 +1,141 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/lightbox/lightbox.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';
+var LightBoxComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(LightBoxComponent, _super);
+    function LightBoxComponent(injector, renderer, host) {
+        var _this = _super.call(this, injector) || this;
+        _this.renderer = renderer;
+        _this.host = host;
+        _this._show = false;
+        _this.showCloseButton = true;
+        _this.onClose = new EventEmitter();
+        return _this;
+    }
+    Object.defineProperty(LightBoxComponent.prototype, "show", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._show;
+        },
+        set: /**
+         * @param {?} s
+         * @return {?}
+         */
+        function (s) {
+            var _this = this;
+            if (this.timer) {
+                clearTimeout(this.timer);
+            }
+            if (s) {
+                this._show = true;
+                this.timer = window.setTimeout((/**
+                 * @return {?}
+                 */
+                function () {
+                    _this.renderer.addClass(_this.host.nativeElement, 'shown');
+                    _this.timer = null;
+                    _this.changeDetector.markForCheck();
+                }), 100);
+            }
+            else {
+                /** @type {?} */
+                var wait = parseFloat(this.section &&
+                    window.getComputedStyle(this.section.nativeElement)['transition-duration']);
+                this.renderer.removeClass(this.host.nativeElement, 'shown');
+                this.timer = window.setTimeout((/**
+                 * @return {?}
+                 */
+                function () {
+                    _this._show = false;
+                    _this.timer = null;
+                    _this.changeDetector.markForCheck();
+                }), wait * 1000);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    LightBoxComponent.prototype.onClick = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        if (this.overlay.nativeElement.contains(event.target)) {
+            this.close();
+        }
+    };
+    /**
+     * @return {?}
+     */
+    LightBoxComponent.prototype.close = /**
+     * @return {?}
+     */
+    function () {
+        this.show = false;
+        this.onClose.emit();
+    };
+    LightBoxComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-lightbox',
+                    template: "<section *ngIf=\"_show\" #section>\n  <div overlay #overlay></div>\n  <div content>\n    <i (click)=\"close()\" *ngIf=\"showCloseButton == true\"></i>\n    <ng-content></ng-content>\n  </div>\n</section>\n",
+                    host: {
+                        '(click)': 'onClick($event)'
+                    },
+                    styles: ["section{position:fixed;display:flex;align-items:center;justify-content:center;height:100%;width:100%;z-index:100;top:0;left:0;opacity:0;transition:opacity .35s}section[hidden]{display:none!important}:host.shown>section{opacity:1}div[overlay]{position:absolute;top:0;left:0;opacity:.7;width:100%;height:100%;background-color:#000}div[content]{flex:0 0 auto;max-width:75%;max-height:75%;overflow:auto;background-color:#fff;z-index:2;position:relative}"]
+                }] }
+    ];
+    /** @nocollapse */
+    LightBoxComponent.ctorParameters = function () { return [
+        { type: Injector },
+        { type: Renderer2 },
+        { type: ElementRef }
+    ]; };
+    LightBoxComponent.propDecorators = {
+        show: [{ type: Input }],
+        showCloseButton: [{ type: Input }],
+        onClose: [{ type: Output }],
+        section: [{ type: ViewChild, args: ['section', { static: false },] }],
+        overlay: [{ type: ViewChild, args: ['overlay', { static: false },] }]
+    };
+    return LightBoxComponent;
+}(OdeComponent));
+export { LightBoxComponent };
+if (false) {
+    /** @type {?} */
+    LightBoxComponent.prototype._show;
+    /** @type {?} */
+    LightBoxComponent.prototype.showCloseButton;
+    /** @type {?} */
+    LightBoxComponent.prototype.onClose;
+    /** @type {?} */
+    LightBoxComponent.prototype.section;
+    /** @type {?} */
+    LightBoxComponent.prototype.overlay;
+    /**
+     * @type {?}
+     * @private
+     */
+    LightBoxComponent.prototype.timer;
+    /**
+     * @type {?}
+     * @private
+     */
+    LightBoxComponent.prototype.renderer;
+    /**
+     * @type {?}
+     * @private
+     */
+    LightBoxComponent.prototype.host;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/components/lightbox-confirm/lightbox-confirm.component.js

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/lightbox-confirm/lightbox-confirm.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 LightboxConfirmComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(LightboxConfirmComponent, _super);
+    function LightboxConfirmComponent(injector) {
+        var _this = _super.call(this, injector) || this;
+        _this.cancelText = "cancel";
+        _this.confirmText = "confirm";
+        _this.extraButtons = [];
+        _this.disableConfirm = false;
+        _this.onConfirm = new EventEmitter();
+        _this.onCancel = new EventEmitter();
+        _this.onExtra = new EventEmitter();
+        return _this;
+    }
+    LightboxConfirmComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-lightbox-confirm',
+                    template: "<ode-lightbox [show]=\"show\" (onClose)=\"onCancel.emit()\">\n  <h2 class=\"lightbox-confirm__header\">{{ lightboxTitle | translate }}</h2>\n  <div class=\"lightbox-confirm-content\">\n    <ng-content></ng-content>\n  </div>\n  <div class=\"lightbox-confirm-action\">\n    <button (click)=\"onConfirm.emit()\" [disabled]=\"disableConfirm\" class=\"confirm\">{{ confirmText | translate }}</button>\n    <button\n      *ngFor=\"let extraBtn of extraButtons.slice().reverse(); index as i;\"\n      (click)=\"onExtra.emit(extraButtons.length - 1 - i)\" class=\"confirm\">{{ extraBtn | translate }}</button>\n    <button (click)=\"onCancel.emit()\" class=\"cancel\">{{ cancelText | translate }}</button>\n  </div>\n</ode-lightbox>\n",
+                    styles: [".lightbox-confirm__header{margin-bottom:0}.lightbox-confirm-content{font-size:16px;padding:20px 0}.lightbox-confirm-action button{float:right;text-align:center;margin-left:5px;margin-bottom:20px}"]
+                }] }
+    ];
+    /** @nocollapse */
+    LightboxConfirmComponent.ctorParameters = function () { return [
+        { type: Injector }
+    ]; };
+    LightboxConfirmComponent.propDecorators = {
+        lightboxTitle: [{ type: Input }],
+        show: [{ type: Input }],
+        cancelText: [{ type: Input }],
+        confirmText: [{ type: Input }],
+        extraButtons: [{ type: Input }],
+        disableConfirm: [{ type: Input }],
+        onConfirm: [{ type: Output }],
+        onCancel: [{ type: Output }],
+        onExtra: [{ type: Output }]
+    };
+    return LightboxConfirmComponent;
+}(OdeComponent));
+export { LightboxConfirmComponent };
+if (false) {
+    /** @type {?} */
+    LightboxConfirmComponent.prototype.lightboxTitle;
+    /** @type {?} */
+    LightboxConfirmComponent.prototype.show;
+    /** @type {?} */
+    LightboxConfirmComponent.prototype.cancelText;
+    /** @type {?} */
+    LightboxConfirmComponent.prototype.confirmText;
+    /** @type {?} */
+    LightboxConfirmComponent.prototype.extraButtons;
+    /** @type {?} */
+    LightboxConfirmComponent.prototype.disableConfirm;
+    /** @type {?} */
+    LightboxConfirmComponent.prototype.onConfirm;
+    /** @type {?} */
+    LightboxConfirmComponent.prototype.onCancel;
+    /** @type {?} */
+    LightboxConfirmComponent.prototype.onExtra;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/components/list/list.component.js

@@ -0,0 +1,146 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/list/list.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, ContentChild, EventEmitter, Input, Output, TemplateRef, Injector } from '@angular/core';
+var ListComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(ListComponent, _super);
+    function ListComponent(injector) {
+        var _this = _super.call(this, injector) || this;
+        /* Store pipe */
+        _this.self = _this;
+        _this._storedElements = [];
+        _this.searchPlaceholder = 'search';
+        _this.noResultsLabel = 'list.results.no.items';
+        _this.placeholder = 'list.placeholder';
+        _this.isSearchActive = true;
+        _this.isSearchButtonDisabled = false;
+        _this.searchInput = false;
+        _this.inputChange = new EventEmitter();
+        _this.onSelect = new EventEmitter();
+        _this.listChange = new EventEmitter();
+        _this.scrolledDown = new EventEmitter();
+        _this.isSelected = (/**
+         * @param {?=} arg
+         * @return {?}
+         */
+        function (arg) { return false; });
+        _this.isDisabled = (/**
+         * @param {?=} arg
+         * @return {?}
+         */
+        function (arg) { return false; });
+        _this.ngClass = (/**
+         * @param {?=} arg
+         * @return {?}
+         */
+        function (arg) { return ({}); });
+        return _this;
+    }
+    Object.defineProperty(ListComponent.prototype, "storedElements", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._storedElements;
+        },
+        set: /**
+         * @param {?} list
+         * @return {?}
+         */
+        function (list) {
+            this._storedElements = list;
+            this.listChange.emit(list);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ListComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-list',
+                    template: "<ode-search-input\n  *ngIf=\"isSearchActive\"\n  [isSearchButtonDisabled]=\"isSearchButtonDisabled\"\n  [searchInput]=\"searchInput\"\n  [searchSubmit]=\"searchSubmit\"\n  [delay]=\"searchDelay\"\n  [attr.placeholder]=\"searchPlaceholder | translate\"\n  (onChange)=\"inputChange.emit($event)\"\n>\n</ode-search-input>\n\n<div class=\"toolbar\">\n  <ng-content select=\"[toolbar]\"></ng-content>\n</div>\n\n<div\n  class=\"list-wrapper\"\n  infiniteScroll\n  [scrollWindow]=\"false\"\n  (scrolled)=\"scrolledDown.emit()\"\n  [infiniteScrollThrottle]=\"50\"\n>\n  <ul>\n    <li\n      *ngFor=\"let item of model | filter: filters | filter: inputFilter | store:self:'storedElements' | orderBy: sort | slice: 0:limit\"\n      (click)=\"onSelect.emit(item)\"\n      [class.selected]=\"isSelected(item)\"\n      [class.disabled]=\"isDisabled(item)\"\n      [ngClass]=\"ngClass(item)\"\n      class=\"lct-list-item\"\n    >\n      <ng-template [ngTemplateOutlet]=\"templateRef\" [ngTemplateOutletContext]=\"{$implicit: item}\">\n      </ng-template>\n    </li>\n  </ul>\n\n  <ul *ngIf=\"storedElements && storedElements.length === 0\">\n    <li class=\"no-results\">{{ noResultsLabel | translate }}</li>\n  </ul>\n\n  <ul *ngIf=\"!model\">\n    <li class=\"placeholder\">{{ placeholder | translate }}</li>\n  </ul>\n</div>\n",
+                    styles: ["ul{margin:0;padding:0;font-size:.9em}ul li{cursor:pointer;border-top:1px solid #ddd;padding:10px}ul li.no-results{padding:50px;text-align:center;font-style:italic}ul li.no-results:hover{cursor:default!important;background-color:inherit!important}ul li.placeholder{color:#aaa;padding:2rem;text-align:left}ul li.placeholder:hover{cursor:default!important;background-color:inherit!important}ul li.disabled{pointer-events:none}"]
+                }] }
+    ];
+    /** @nocollapse */
+    ListComponent.ctorParameters = function () { return [
+        { type: Injector }
+    ]; };
+    ListComponent.propDecorators = {
+        model: [{ type: Input }],
+        filters: [{ type: Input }],
+        inputFilter: [{ type: Input }],
+        sort: [{ type: Input }],
+        limit: [{ type: Input }],
+        searchPlaceholder: [{ type: Input }],
+        noResultsLabel: [{ type: Input }],
+        placeholder: [{ type: Input }],
+        isSearchActive: [{ type: Input }],
+        isSearchButtonDisabled: [{ type: Input }],
+        searchInput: [{ type: Input }],
+        searchDelay: [{ type: Input }],
+        searchSubmit: [{ type: Input }],
+        inputChange: [{ type: Output }],
+        onSelect: [{ type: Output }],
+        listChange: [{ type: Output }],
+        scrolledDown: [{ type: Output }],
+        templateRef: [{ type: ContentChild, args: [TemplateRef, { static: false },] }],
+        isSelected: [{ type: Input }],
+        isDisabled: [{ type: Input }],
+        ngClass: [{ type: Input }]
+    };
+    return ListComponent;
+}(OdeComponent));
+export { ListComponent };
+if (false) {
+    /** @type {?} */
+    ListComponent.prototype.self;
+    /** @type {?} */
+    ListComponent.prototype._storedElements;
+    /** @type {?} */
+    ListComponent.prototype.model;
+    /** @type {?} */
+    ListComponent.prototype.filters;
+    /** @type {?} */
+    ListComponent.prototype.inputFilter;
+    /** @type {?} */
+    ListComponent.prototype.sort;
+    /** @type {?} */
+    ListComponent.prototype.limit;
+    /** @type {?} */
+    ListComponent.prototype.searchPlaceholder;
+    /** @type {?} */
+    ListComponent.prototype.noResultsLabel;
+    /** @type {?} */
+    ListComponent.prototype.placeholder;
+    /** @type {?} */
+    ListComponent.prototype.isSearchActive;
+    /** @type {?} */
+    ListComponent.prototype.isSearchButtonDisabled;
+    /** @type {?} */
+    ListComponent.prototype.searchInput;
+    /** @type {?} */
+    ListComponent.prototype.searchDelay;
+    /** @type {?} */
+    ListComponent.prototype.searchSubmit;
+    /** @type {?} */
+    ListComponent.prototype.inputChange;
+    /** @type {?} */
+    ListComponent.prototype.onSelect;
+    /** @type {?} */
+    ListComponent.prototype.listChange;
+    /** @type {?} */
+    ListComponent.prototype.scrolledDown;
+    /** @type {?} */
+    ListComponent.prototype.templateRef;
+    /** @type {?} */
+    ListComponent.prototype.isSelected;
+    /** @type {?} */
+    ListComponent.prototype.isDisabled;
+    /** @type {?} */
+    ListComponent.prototype.ngClass;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9uZ3gtb2RlLXVpLyIsInNvdXJjZXMiOlsibGliL2NvbXBvbmVudHMvbGlzdC9saXN0LmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQzVDLE9BQU8sRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLFlBQVksRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLFdBQVcsRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFNUc7SUFLbUMseUNBQVk7SUF1QzNDLHVCQUFZLFFBQWtCO1FBQTlCLFlBQ0ksa0JBQU0sUUFBUSxDQUFDLFNBQ2xCOztRQTdCRCxVQUFJLEdBQUcsS0FBSSxDQUFDO1FBQ1oscUJBQWUsR0FBRyxFQUFFLENBQUM7UUFPWix1QkFBaUIsR0FBRyxRQUFRLENBQUM7UUFDN0Isb0JBQWMsR0FBRyx1QkFBdUIsQ0FBQztRQUN6QyxpQkFBVyxHQUFHLGtCQUFrQixDQUFDO1FBQ2pDLG9CQUFjLEdBQUcsSUFBSSxDQUFDO1FBQ3RCLDRCQUFzQixHQUFZLEtBQUssQ0FBQztRQUN4QyxpQkFBVyxHQUFZLEtBQUssQ0FBQztRQUk1QixpQkFBVyxHQUF5QixJQUFJLFlBQVksRUFBVSxDQUFDO1FBQy9ELGNBQVEsR0FBc0IsSUFBSSxZQUFZLEVBQUUsQ0FBQztRQUNqRCxnQkFBVSxHQUFzQixJQUFJLFlBQVksRUFBRSxDQUFDO1FBQ25ELGtCQUFZLEdBQXNCLElBQUksWUFBWSxFQUFFLENBQUM7UUFHdEQsZ0JBQVU7Ozs7UUFBRyxVQUFDLEdBQVMsSUFBSyxPQUFBLEtBQUssRUFBTCxDQUFLLEVBQUM7UUFDbEMsZ0JBQVU7Ozs7UUFBRyxVQUFDLEdBQVMsSUFBSyxPQUFBLEtBQUssRUFBTCxDQUFLLEVBQUM7UUFDbEMsYUFBTzs7OztRQUFHLFVBQUMsR0FBUyxJQUFLLE9BQUEsQ0FBQyxFQUFFLENBQUMsRUFBSixDQUFJLEVBQUM7O0lBSXZDLENBQUM7SUF2Q0Qsc0JBQUkseUNBQWM7Ozs7UUFLbEI7WUFDSSxPQUFPLElBQUksQ0FBQyxlQUFlLENBQUM7UUFDaEMsQ0FBQzs7Ozs7UUFQRCxVQUFtQixJQUFJO1lBQ25CLElBQUksQ0FBQyxlQUFlLEdBQUcsSUFBSSxDQUFDO1lBQzVCLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQy9CLENBQUM7OztPQUFBOztnQkFWSixTQUFTLFNBQUM7b0JBQ1AsUUFBUSxFQUFFLFVBQVU7b0JBQ3BCLGt6Q0FBb0M7O2lCQUV2Qzs7OztnQkFOMkUsUUFBUTs7O3dCQXNCL0UsS0FBSzswQkFDTCxLQUFLOzhCQUNMLEtBQUs7dUJBQ0wsS0FBSzt3QkFDTCxLQUFLO29DQUNMLEtBQUs7aUNBQ0wsS0FBSzs4QkFDTCxLQUFLO2lDQUNMLEtBQUs7eUNBQ0wsS0FBSzs4QkFDTCxLQUFLOzhCQUNMLEtBQUs7K0JBQ0wsS0FBSzs4QkFFTCxNQUFNOzJCQUNOLE1BQU07NkJBQ04sTUFBTTsrQkFDTixNQUFNOzhCQUVOLFlBQVksU0FBQyxXQUFXLEVBQUUsRUFBQyxNQUFNLEVBQUUsS0FBSyxFQUFDOzZCQUN6QyxLQUFLOzZCQUNMLEtBQUs7MEJBQ0wsS0FBSzs7SUFLVixvQkFBQztDQUFBLEFBL0NELENBS21DLFlBQVksR0EwQzlDO1NBMUNZLGFBQWE7OztJQVl0Qiw2QkFBWTs7SUFDWix3Q0FBcUI7O0lBRXJCLDhCQUFlOztJQUNmLGdDQUFpQjs7SUFDakIsb0NBQXFCOztJQUNyQiw2QkFBYzs7SUFDZCw4QkFBdUI7O0lBQ3ZCLDBDQUFzQzs7SUFDdEMsdUNBQWtEOztJQUNsRCxvQ0FBMEM7O0lBQzFDLHVDQUErQjs7SUFDL0IsK0NBQWlEOztJQUNqRCxvQ0FBc0M7O0lBQ3RDLG9DQUE2Qjs7SUFDN0IscUNBQWtDOztJQUVsQyxvQ0FBeUU7O0lBQ3pFLGlDQUEyRDs7SUFDM0QsbUNBQTZEOztJQUM3RCxxQ0FBK0Q7O0lBRS9ELG9DQUEwRTs7SUFDMUUsbUNBQTJDOztJQUMzQyxtQ0FBMkM7O0lBQzNDLGdDQUF1QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9kZUNvbXBvbmVudCB9IGZyb20gJ25neC1vZGUtY29yZSc7XG5pbXBvcnQgeyBDb21wb25lbnQsIENvbnRlbnRDaGlsZCwgRXZlbnRFbWl0dGVyLCBJbnB1dCwgT3V0cHV0LCBUZW1wbGF0ZVJlZiwgSW5qZWN0b3IgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICdvZGUtbGlzdCcsXG4gICAgdGVtcGxhdGVVcmw6ICcuL2xpc3QuY29tcG9uZW50Lmh0bWwnLFxuICAgIHN0eWxlVXJsczogWycuL2xpc3QuY29tcG9uZW50LnNjc3MnXVxufSlcbmV4cG9ydCBjbGFzcyBMaXN0Q29tcG9uZW50IGV4dGVuZHMgT2RlQ29tcG9uZW50IHtcblxuICAgIHNldCBzdG9yZWRFbGVtZW50cyhsaXN0KSB7XG4gICAgICAgIHRoaXMuX3N0b3JlZEVsZW1lbnRzID0gbGlzdDtcbiAgICAgICAgdGhpcy5saXN0Q2hhbmdlLmVtaXQobGlzdCk7XG4gICAgfVxuXG4gICAgZ2V0IHN0b3JlZEVsZW1lbnRzKCkge1xuICAgICAgICByZXR1cm4gdGhpcy5fc3RvcmVkRWxlbWVudHM7XG4gICAgfVxuXG4gICAgLyogU3RvcmUgcGlwZSAqL1xuICAgIHNlbGYgPSB0aGlzO1xuICAgIF9zdG9yZWRFbGVtZW50cyA9IFtdO1xuXG4gICAgQElucHV0KCkgbW9kZWw7XG4gICAgQElucHV0KCkgZmlsdGVycztcbiAgICBASW5wdXQoKSBpbnB1dEZpbHRlcjtcbiAgICBASW5wdXQoKSBzb3J0O1xuICAgIEBJbnB1dCgpIGxpbWl0OiBudW1iZXI7XG4gICAgQElucHV0KCkgc2VhcmNoUGxhY2Vob2xkZXIgPSAnc2VhcmNoJztcbiAgICBASW5wdXQoKSBub1Jlc3VsdHNMYWJlbCA9ICdsaXN0LnJlc3VsdHMubm8uaXRlbXMnO1xuICAgIEBJbnB1dCgpIHBsYWNlaG9sZGVyID0gJ2xpc3QucGxhY2Vob2xkZXInO1xuICAgIEBJbnB1dCgpIGlzU2VhcmNoQWN0aXZlID0gdHJ1ZTtcbiAgICBASW5wdXQoKSBpc1NlYXJjaEJ1dHRvbkRpc2FibGVkOiBib29sZWFuID0gZmFsc2U7XG4gICAgQElucHV0KCkgc2VhcmNoSW5wdXQ6IGJvb2xlYW4gPSBmYWxzZTtcbiAgICBASW5wdXQoKSBzZWFyY2hEZWxheTogbnVtYmVyO1xuICAgIEBJbnB1dCgpIHNlYXJjaFN1Ym1pdDogKCkgPT4gdm9pZDtcblxuICAgIEBPdXRwdXQoKSBpbnB1dENoYW5nZTogRXZlbnRFbWl0dGVyPHN0cmluZz4gPSBuZXcgRXZlbnRFbWl0dGVyPHN0cmluZz4oKTtcbiAgICBAT3V0cHV0KCkgb25TZWxlY3Q6IEV2ZW50RW1pdHRlcjxhbnk+ID0gbmV3IEV2ZW50RW1pdHRlcigpO1xuICAgIEBPdXRwdXQoKSBsaXN0Q2hhbmdlOiBFdmVudEVtaXR0ZXI8YW55PiA9IG5ldyBFdmVudEVtaXR0ZXIoKTtcbiAgICBAT3V0cHV0KCkgc2Nyb2xsZWREb3duOiBFdmVudEVtaXR0ZXI8YW55PiA9IG5ldyBFdmVudEVtaXR0ZXIoKTtcblxuICAgIEBDb250ZW50Q2hpbGQoVGVtcGxhdGVSZWYsIHtzdGF0aWM6IGZhbHNlfSkgdGVtcGxhdGVSZWY6IFRlbXBsYXRlUmVmPGFueT47XG4gICAgQElucHV0KCkgaXNTZWxlY3RlZCA9IChhcmc/OiBhbnkpID0+IGZhbHNlO1xuICAgIEBJbnB1dCgpIGlzRGlzYWJsZWQgPSAoYXJnPzogYW55KSA9PiBmYWxzZTtcbiAgICBASW5wdXQoKSBuZ0NsYXNzID0gKGFyZz86IGFueSkgPT4gKHt9KTtcblxuICAgIGNvbnN0cnVjdG9yKGluamVjdG9yOiBJbmplY3Rvcikge1xuICAgICAgICBzdXBlcihpbmplY3Rvcik7XG4gICAgfVxufVxuIl19

package/esm5/lib/components/list-checkable/list-checkable.component.js

@@ -0,0 +1,148 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/list-checkable/list-checkable.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, ContentChild, EventEmitter, Input, Output, TemplateRef, Injector } from '@angular/core';
+var ListCheckableComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(ListCheckableComponent, _super);
+    function ListCheckableComponent(injector) {
+        var _this = _super.call(this, injector) || this;
+        _this.model = [];
+        _this.noResultsLabel = 'list.results.no.items';
+        _this.readOnly = false;
+        _this.onCheck = new EventEmitter();
+        _this.listChange = new EventEmitter();
+        _this.scrolledDown = new EventEmitter();
+        _this.areAllChecked = (/**
+         * @return {?}
+         */
+        function () { return false; });
+        _this.isChecked = (/**
+         * @param {?=} arg
+         * @return {?}
+         */
+        function (arg) { return false; });
+        _this.isDisabled = (/**
+         * @param {?=} arg
+         * @return {?}
+         */
+        function (arg) { return false; });
+        _this.ngClass = (/**
+         * @param {?=} arg
+         * @return {?}
+         */
+        function (arg) { return ({}); });
+        /* Store pipe */
+        _this.self = _this;
+        _this._storedElements = [];
+        return _this;
+    }
+    Object.defineProperty(ListCheckableComponent.prototype, "storedElements", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._storedElements;
+        },
+        set: /**
+         * @param {?} list
+         * @return {?}
+         */
+        function (list) {
+            this._storedElements = list;
+            this.listChange.emit(list);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @param {?} checkAll
+     * @return {?}
+     */
+    ListCheckableComponent.prototype.toggleAll = /**
+     * @param {?} checkAll
+     * @return {?}
+     */
+    function (checkAll) {
+        var _this = this;
+        this.model.forEach((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) {
+            /** @type {?} */
+            var isChecked = _this.isChecked(item);
+            if (!_this.isDisabled(item)
+                && ((isChecked && !checkAll) || (!isChecked && checkAll))) {
+                _this.onCheck.emit({ item: item, checked: checkAll });
+            }
+        }));
+    };
+    ListCheckableComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-list-checkable',
+                    template: "<div class=\"list-checkable-wrapper\"\n     infiniteScroll\n     [scrollWindow]=\"false\"\n     (scrolled)=\"scrolledDown.emit()\"\n     [infiniteScrollThrottle]=\"50\">\n\n  <ul *ngIf=\"storedElements && storedElements.length === 0\">\n    <li class=\"no-results\"><span>{{ noResultsLabel | translate }}</span></li>\n  </ul>\n  \n  <ul>\n    <li class=\"select-all\" \n        [class.checked]=\"areAllChecked()\"\n        *ngIf=\"!readOnly\">\n      <label>\n        <span>{{(areAllChecked() ? 'ux.multiselect.deselect-all' : 'ux.multiselect.select-all') | translate}}</span>\n        <input type=\"checkbox\" [checked]=\"areAllChecked()\" (change)=\"toggleAll($event.target.checked)\" />\n      </label>\n    </li>\n\n    <li class=\"lct-list-checkable-item\" \n        [class.checked]=\"isChecked(item)\"\n        [class.disabled]=\"isDisabled(item)\"\n        [ngClass]=\"ngClass(item)\"\n        *ngFor=\"let item of model | filter: filters | store:self:'storedElements' | orderBy: sort | slice: 0:limit\">\n      <label>\n        <span>\n          <ng-template [ngTemplateOutlet]=\"templateRef\" [ngTemplateOutletContext]=\"{$implicit: item}\"></ng-template>        \n        </span>\n        <input *ngIf=\"!readOnly\" type=\"checkbox\" \n              [disabled]=\"isDisabled(item)\"\n              [checked]=\"isChecked(item)\"\n              (change)=\"onCheck.emit({item:item, checked:$event.target.checked})\"/>\n      </label>\n    </li>\n  </ul>\n\n</div>\n",
+                    styles: ["ul{margin:0;padding:0;font-size:.9em}ul li{border-top:1px solid #ddd;width:-webkit-fill-available;width:-moz-available;display:flex}ul li:not(.checked){color:#939393}ul li.disabled{pointer-events:none}ul li.select-all{background-color:#ff83520a;color:#5b6472}ul li.select-all span{text-align:right}ul li label{cursor:pointer;width:100%;display:flex}ul li label:hover{background-color:#eaedf2}ul li label span{padding:7px 15px;width:100%}ul li label input[type=checkbox]{margin-right:15px;-ms-grid-row-align:center;align-self:center}"]
+                }] }
+    ];
+    /** @nocollapse */
+    ListCheckableComponent.ctorParameters = function () { return [
+        { type: Injector }
+    ]; };
+    ListCheckableComponent.propDecorators = {
+        model: [{ type: Input }],
+        filters: [{ type: Input }],
+        sort: [{ type: Input }],
+        limit: [{ type: Input }],
+        noResultsLabel: [{ type: Input }],
+        readOnly: [{ type: Input }],
+        onCheck: [{ type: Output }],
+        listChange: [{ type: Output }],
+        scrolledDown: [{ type: Output }],
+        templateRef: [{ type: ContentChild, args: [TemplateRef, { static: false },] }],
+        areAllChecked: [{ type: Input }],
+        isChecked: [{ type: Input }],
+        isDisabled: [{ type: Input }],
+        ngClass: [{ type: Input }]
+    };
+    return ListCheckableComponent;
+}(OdeComponent));
+export { ListCheckableComponent };
+if (false) {
+    /** @type {?} */
+    ListCheckableComponent.prototype.model;
+    /** @type {?} */
+    ListCheckableComponent.prototype.filters;
+    /** @type {?} */
+    ListCheckableComponent.prototype.sort;
+    /** @type {?} */
+    ListCheckableComponent.prototype.limit;
+    /** @type {?} */
+    ListCheckableComponent.prototype.noResultsLabel;
+    /** @type {?} */
+    ListCheckableComponent.prototype.readOnly;
+    /** @type {?} */
+    ListCheckableComponent.prototype.onCheck;
+    /** @type {?} */
+    ListCheckableComponent.prototype.listChange;
+    /** @type {?} */
+    ListCheckableComponent.prototype.scrolledDown;
+    /** @type {?} */
+    ListCheckableComponent.prototype.templateRef;
+    /** @type {?} */
+    ListCheckableComponent.prototype.areAllChecked;
+    /** @type {?} */
+    ListCheckableComponent.prototype.isChecked;
+    /** @type {?} */
+    ListCheckableComponent.prototype.isDisabled;
+    /** @type {?} */
+    ListCheckableComponent.prototype.ngClass;
+    /** @type {?} */
+    ListCheckableComponent.prototype.self;
+    /** @type {?} */
+    ListCheckableComponent.prototype._storedElements;
+}
+//# sourceMappingURL=data:application/json;base64,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