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

package/esm2015/lib/components/item-tree/item-tree.component.js

@@ -0,0 +1,289 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/item-tree/item-tree.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, EventEmitter, Input, Output, ViewChild, TemplateRef, Injector } from '@angular/core';
+/**
+ * @template T
+ */
+export class ItemTreeComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     */
+    constructor(injector) {
+        super(injector);
+        /**
+         * * Inputs ***
+         */
+        // Items
+        this.items = [];
+        // Property containing the list of child objects.
+        this.childrenProperty = 'children';
+        // Property to display in the list
+        this.displayProperty = 'label';
+        // Filter pipe argument
+        this.filter = '';
+        // OrderBy pipe argument
+        this.order = [];
+        // Reverse the order pipe
+        this.reverse = false;
+        this._flattenProps = [];
+        // Disable the opener icon
+        this.disableOpener = false;
+        // Use checkboxes instead of selecting items
+        this.checkboxMode = false;
+        /**
+         * * Outputs ***
+         */
+        this.onSelect = new EventEmitter();
+        this.onCheck = new EventEmitter();
+        this._depth = 0;
+        this.unfolded = [];
+    }
+    // Flatten the tree on the specified properties
+    /**
+     * @param {?} flattenProps
+     * @return {?}
+     */
+    set flatten(flattenProps) {
+        if (!this.isFlattened() && flattenProps.length > 0) {
+            this._selectedItem = this._lastSelectedItem;
+        }
+        else if (this.isFlattened && flattenProps.length < 1) {
+            this.flagIfParent();
+        }
+        this._flattenProps = flattenProps;
+    }
+    /**
+     * @return {?}
+     */
+    get flatten() {
+        return this._flattenProps;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        super.ngOnInit();
+        this.flagIfParent();
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    selectItem(item) {
+        this._selectedItem = item;
+        if (this.childItemTree) {
+            delete this.childItemTree._selectedItem;
+        }
+        /** @type {?} */
+        const idx = this.unfolded.indexOf(item);
+        if (!this.disableOpener && idx < 0) {
+            this.unfolded.push(item);
+        }
+        else {
+            this.unfolded.splice(idx, 1);
+        }
+        this.bubbleSelect(item);
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    checkItem(item) {
+        this.onCheck.emit(item);
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    bubbleSelect(item) {
+        this._lastSelectedItem = item;
+        this.onSelect.emit(item);
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    isSelected(item) {
+        return (this.disableOpener ? this._selectedItem : this._lastSelectedItem) === item;
+    }
+    /**
+     * @param {?} event
+     * @param {?} item
+     * @return {?}
+     */
+    toggleFold(event, item) {
+        event.stopPropagation();
+        /** @type {?} */
+        const idx = this.unfolded.indexOf(item);
+        if (idx < 0) {
+            this.unfolded.push(item);
+        }
+        else {
+            this.unfolded.splice(idx, 1);
+        }
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    isFolded(item) {
+        return this.disableOpener ? !this.isSelected(item) : this.unfolded.indexOf(item) < 0;
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    display(item) {
+        return this.displayProperty && item[this.displayProperty];
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    getChildren(item) {
+        return item[this.childrenProperty] || [];
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    hasChildren(item) {
+        return this.getChildren(item).length > 0;
+    }
+    /**
+     * @return {?}
+     */
+    isFlattened() {
+        return this._flattenProps.length;
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    flagIfParent() {
+        if (!this._lastSelectedItem) {
+            return;
+        }
+        /** @type {?} */
+        const findSubItem = (/**
+         * @param {?} item
+         * @param {?} target
+         * @return {?}
+         */
+        (item, target) => {
+            if (item === target) {
+                return true;
+            }
+            if (this.hasChildren(item)) {
+                return this.getChildren(item).find((/**
+                 * @param {?} subItem
+                 * @return {?}
+                 */
+                subItem => {
+                    return findSubItem(subItem, target);
+                }));
+            }
+            return false;
+        });
+        for (const i in this.items) {
+            /** @type {?} */
+            const item = this.items[i];
+            if (item === this._lastSelectedItem ||
+                findSubItem(item, this._lastSelectedItem)) {
+                this._selectedItem = item;
+                this.unfolded = [item];
+                break;
+            }
+        }
+        this.changeDetector.markForCheck();
+    }
+}
+ItemTreeComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ode-item-tree',
+                template: "<ul [ngClass]=\"{ flattened: isFlattened() }\">\n  <li *ngFor=\"let item of (items | flattenObjArray: flatten | filter: filter | orderBy: order:reverse)\"\n      [ngClass]=\"{ selected: isSelected(item), unfolded: !isFolded(item), parent: hasChildren(item), root: _depth === 0 }\">\n    <a href=\"javascript:void(0)\" (click)=\"selectItem(item)\" *ngIf=\"!checkboxMode\">\n      <i class=\"opener\" (click)=\"toggleFold($event, item)\"\n         *ngIf=\"!isFlattened() && hasChildren(item) && !disableOpener\"></i>\n      <span *ngIf=\"displayProperty\">{{ display(item) }}</span>\n      <span *ngIf=\"displayTemplate\">\n        <ng-template [ngTemplateOutlet]=\"displayTemplate\" [ngTemplateOutletContext]=\"{$implicit: item}\"></ng-template>\n      </span>\n    </a>\n    <div class=\"checkbox__item\" *ngIf=\"checkboxMode\">\n      <input id=\"all\" type=\"checkbox\" [(ngModel)]=\"item.check\" ngDefaultControl>\n      <label *ngIf=\"displayProperty\" for=\"all\" (click)=\"checkItem(item)\">{{display(item)}}</label>\n      <span *ngIf=\"displayTemplate\">\n        <ng-template [ngTemplateOutlet]=\"displayTemplate\" [ngTemplateOutletContext]=\"{$implicit: item}\"></ng-template>\n      </span>\n    </div>\n    <ode-item-tree\n      [items]=\"getChildren(item)\"\n      [children]=\"childrenProperty\"\n      [display]=\"displayProperty\"\n      [displayTemplate]=\"displayTemplate\"\n      [filter]=\"filter\"\n      [order]=\"order\"\n      [reverse]=\"reverse\"\n      [lastSelected]=\"_lastSelectedItem\"\n      [depth]=\"_depth + 1\"\n      [disableOpener]=\"disableOpener\"\n      [checkboxMode]=\"checkboxMode\"\n      (onSelect)=\"bubbleSelect($event)\"\n      (onCheck)=\"checkItem($event)\"\n      *ngIf=\"(checkboxMode && hasChildren(item)) || (!isFlattened() && hasChildren(item) && !isFolded(item))\">\n    </ode-item-tree>\n  </li>\n</ul>\n"
+            }] }
+];
+/** @nocollapse */
+ItemTreeComponent.ctorParameters = () => [
+    { type: Injector }
+];
+ItemTreeComponent.propDecorators = {
+    items: [{ type: Input }],
+    childrenProperty: [{ type: Input, args: ['children',] }],
+    displayProperty: [{ type: Input, args: ['display',] }],
+    displayTemplate: [{ type: Input }],
+    filter: [{ type: Input }],
+    order: [{ type: Input }],
+    reverse: [{ type: Input }],
+    flatten: [{ type: Input }],
+    disableOpener: [{ type: Input }],
+    checkboxMode: [{ type: Input }],
+    onSelect: [{ type: Output }],
+    onCheck: [{ type: Output }],
+    childItemTree: [{ type: ViewChild, args: [ItemTreeComponent, { static: false },] }],
+    _lastSelectedItem: [{ type: Input, args: ['lastSelected',] }],
+    _depth: [{ type: Input, args: ['depth',] }]
+};
+if (false) {
+    /**
+     * * Inputs ***
+     * @type {?}
+     */
+    ItemTreeComponent.prototype.items;
+    /** @type {?} */
+    ItemTreeComponent.prototype.childrenProperty;
+    /** @type {?} */
+    ItemTreeComponent.prototype.displayProperty;
+    /** @type {?} */
+    ItemTreeComponent.prototype.displayTemplate;
+    /** @type {?} */
+    ItemTreeComponent.prototype.filter;
+    /** @type {?} */
+    ItemTreeComponent.prototype.order;
+    /** @type {?} */
+    ItemTreeComponent.prototype.reverse;
+    /**
+     * @type {?}
+     * @private
+     */
+    ItemTreeComponent.prototype._flattenProps;
+    /** @type {?} */
+    ItemTreeComponent.prototype.disableOpener;
+    /** @type {?} */
+    ItemTreeComponent.prototype.checkboxMode;
+    /**
+     * * Outputs ***
+     * @type {?}
+     */
+    ItemTreeComponent.prototype.onSelect;
+    /** @type {?} */
+    ItemTreeComponent.prototype.onCheck;
+    /**
+     * * View ***
+     * @type {?}
+     */
+    ItemTreeComponent.prototype.childItemTree;
+    /**
+     * * Internal Logic ***
+     * @type {?}
+     */
+    ItemTreeComponent.prototype._lastSelectedItem;
+    /**
+     * @type {?}
+     * @private
+     */
+    ItemTreeComponent.prototype._selectedItem;
+    /** @type {?} */
+    ItemTreeComponent.prototype._depth;
+    /**
+     * @type {?}
+     * @private
+     */
+    ItemTreeComponent.prototype.unfolded;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"item-tree.component.js","sourceRoot":"ng://ngx-ode-ui/","sources":["lib/components/item-tree/item-tree.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { OdeComponent } from 'ngx-ode-core';\nimport { Component, EventEmitter, Input, OnInit, Output, ViewChild, ContentChild, TemplateRef, Injector } from '@angular/core';\n\n@Component({\n    selector: 'ode-item-tree',\n    templateUrl: './item-tree.component.html'\n})\nexport class ItemTreeComponent<T> extends OdeComponent implements OnInit {\n\n    constructor(injector: Injector) {\n        super(injector);\n    }\n\n    /**** Inputs ****/\n\n    // Items\n    @Input() items: Array<any> = [];\n\n    // Property containing the list of child objects.\n    @Input('children') childrenProperty = 'children';\n    // Property to display in the list\n    @Input('display') displayProperty = 'label';\n    @Input() displayTemplate: TemplateRef<any>;\n    // Filter pipe argument\n    @Input() filter: (Object | string | Function) = '';\n    // OrderBy pipe argument\n    @Input() order: (Array<any> | string | Function) = [];\n    // Reverse the order pipe\n    @Input() reverse: any = false;\n    // Flatten the tree on the specified properties\n    @Input()\n    set flatten(flattenProps: Array<string>) {\n        if (!this.isFlattened() && flattenProps.length > 0) {\n            this._selectedItem = this._lastSelectedItem;\n        } else if (this.isFlattened && flattenProps.length < 1) {\n            this.flagIfParent();\n        }\n        this._flattenProps = flattenProps;\n    }\n    get flatten(): Array<string> {\n        return this._flattenProps;\n    }\n    private _flattenProps: Array<string> = [];\n\n    // Disable the opener icon\n    @Input() disableOpener = false;\n\n    // Use checkboxes instead of selecting items\n    @Input() checkboxMode = false;\n\n    /**** Outputs ****/\n\n    @Output() onSelect: EventEmitter<T> = new EventEmitter<T>();\n\n    @Output() onCheck: EventEmitter<T> = new EventEmitter<T>();\n\n    /**** View ****/\n\n    @ViewChild(ItemTreeComponent, { static: false }) childItemTree: ItemTreeComponent<T>;\n\n    /**** Internal Logic ****/\n\n    @Input('lastSelected') _lastSelectedItem: T;\n    private _selectedItem: T;\n    @Input('depth') _depth = 0;\n    private unfolded: T[] = [];\n\n    ngOnInit() {\n        super.ngOnInit();\n        this.flagIfParent();\n    }\n\n    public selectItem(item: T) {\n        this._selectedItem = item;\n        if (this.childItemTree) {\n            delete this.childItemTree._selectedItem;\n        }\n        const idx = this.unfolded.indexOf(item);\n        if (!this.disableOpener && idx < 0) {\n            this.unfolded.push(item);\n        } else {\n          this.unfolded.splice(idx, 1);\n        }\n        this.bubbleSelect(item);\n    }\n\n    public checkItem(item: T) {\n        this.onCheck.emit(item);\n    }\n\n    public bubbleSelect(item: T) {\n        this._lastSelectedItem = item;\n        this.onSelect.emit(item);\n    }\n\n    public isSelected(item) {\n        return (this.disableOpener ? this._selectedItem : this._lastSelectedItem) === item;\n    }\n\n    public toggleFold(event: Event, item: T) {\n        event.stopPropagation();\n        const idx = this.unfolded.indexOf(item);\n        if (idx < 0) {\n            this.unfolded.push(item);\n        } else {\n            this.unfolded.splice(idx, 1);\n        }\n    }\n\n    public isFolded(item: T) {\n        return this.disableOpener ? !this.isSelected(item) : this.unfolded.indexOf(item) < 0;\n    }\n\n    public display(item: T) {\n        return this.displayProperty && item[this.displayProperty];\n    }\n\n    public getChildren(item) {\n        return item[this.childrenProperty] || [];\n    }\n\n    public hasChildren(item) {\n        return this.getChildren(item).length > 0;\n    }\n\n    isFlattened() {\n        return this._flattenProps.length;\n    }\n\n    private flagIfParent() {\n        if (!this._lastSelectedItem) {\n            return;\n        }\n\n        const findSubItem = (item, target) => {\n            if (item === target) {\n                return true;\n            }\n            if (this.hasChildren(item)) {\n                return this.getChildren(item).find(subItem => {\n                    return findSubItem(subItem, target);\n                });\n            }\n            return false;\n        };\n\n        for (const i in this.items) {\n            const item = this.items[i];\n\n            if (item === this._lastSelectedItem ||\n                    findSubItem(item, this._lastSelectedItem)) {\n                this._selectedItem = item;\n                this.unfolded = [item];\n                break;\n            }\n        }\n\n        this.changeDetector.markForCheck();\n    }\n\n}\n"]}

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

@@ -0,0 +1,129 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/lightbox/lightbox.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ElementRef, EventEmitter, Input, Output, Renderer2, ViewChild, Injector } from '@angular/core';
+export class LightBoxComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     * @param {?} renderer
+     * @param {?} host
+     */
+    constructor(injector, renderer, host) {
+        super(injector);
+        this.renderer = renderer;
+        this.host = host;
+        this._show = false;
+        this.showCloseButton = true;
+        this.onClose = new EventEmitter();
+    }
+    /**
+     * @param {?} s
+     * @return {?}
+     */
+    set show(s) {
+        if (this.timer) {
+            clearTimeout(this.timer);
+        }
+        if (s) {
+            this._show = true;
+            this.timer = window.setTimeout((/**
+             * @return {?}
+             */
+            () => {
+                this.renderer.addClass(this.host.nativeElement, 'shown');
+                this.timer = null;
+                this.changeDetector.markForCheck();
+            }), 100);
+        }
+        else {
+            /** @type {?} */
+            const wait = parseFloat(this.section &&
+                window.getComputedStyle(this.section.nativeElement)['transition-duration']);
+            this.renderer.removeClass(this.host.nativeElement, 'shown');
+            this.timer = window.setTimeout((/**
+             * @return {?}
+             */
+            () => {
+                this._show = false;
+                this.timer = null;
+                this.changeDetector.markForCheck();
+            }), wait * 1000);
+        }
+    }
+    /**
+     * @return {?}
+     */
+    get show() {
+        return this._show;
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onClick(event) {
+        if (this.overlay.nativeElement.contains(event.target)) {
+            this.close();
+        }
+    }
+    /**
+     * @return {?}
+     */
+    close() {
+        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 = () => [
+    { 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 },] }]
+};
+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/esm2015/lib/components/lightbox-confirm/lightbox-confirm.component.js

@@ -0,0 +1,65 @@
+/**
+ * @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 { OdeComponent } from 'ngx-ode-core';
+import { Component, EventEmitter, Input, Output, Injector } from '@angular/core';
+export class LightboxConfirmComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     */
+    constructor(injector) {
+        super(injector);
+        this.cancelText = "cancel";
+        this.confirmText = "confirm";
+        this.extraButtons = [];
+        this.disableConfirm = false;
+        this.onConfirm = new EventEmitter();
+        this.onCancel = new EventEmitter();
+        this.onExtra = new EventEmitter();
+    }
+}
+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 = () => [
+    { 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 }]
+};
+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/esm2015/lib/components/list/list.component.js

@@ -0,0 +1,140 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/list/list.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ContentChild, EventEmitter, Input, Output, TemplateRef, Injector } from '@angular/core';
+export class ListComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     */
+    constructor(injector) {
+        super(injector);
+        /* 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 {?}
+         */
+        (arg) => false);
+        this.isDisabled = (/**
+         * @param {?=} arg
+         * @return {?}
+         */
+        (arg) => false);
+        this.ngClass = (/**
+         * @param {?=} arg
+         * @return {?}
+         */
+        (arg) => ({}));
+    }
+    /**
+     * @param {?} list
+     * @return {?}
+     */
+    set storedElements(list) {
+        this._storedElements = list;
+        this.listChange.emit(list);
+    }
+    /**
+     * @return {?}
+     */
+    get storedElements() {
+        return this._storedElements;
+    }
+}
+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 = () => [
+    { 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 }]
+};
+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,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