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

package/esm2015/lib/components/multi-combo/multi-combo.component.js

@@ -0,0 +1,255 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/multi-combo/multi-combo.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, ElementRef, EventEmitter, Input, Output, Injector } from '@angular/core';
+import { LabelsService } from '../../services/labels.service';
+import { OdeComponent } from 'ngx-ode-core';
+/* If you need to use multi-combo in a form you should give a look to the MultiSelectComponent. */
+export class MultiComboComponent extends OdeComponent {
+    /**
+     * @param {?} _eref
+     * @param {?} labelsService
+     * @param {?} injector
+     */
+    constructor(_eref, labelsService, injector) {
+        super(injector);
+        this._eref = _eref;
+        this.labelsService = labelsService;
+        this.filteredModel = [];
+        this.title = 'Select';
+        this.reverse = false;
+        this.disabled = false;
+        this.onSelectItem = new EventEmitter();
+        this.onDeselectItem = new EventEmitter();
+        this.filteredModelChange = new EventEmitter();
+        this.onOpen = new EventEmitter();
+        this.onClose = new EventEmitter();
+        this.self = this;
+        this._comboModel = [];
+        this.filteredComboModel = [];
+        this.search = {
+            input: '',
+            /**
+             * @return {?}
+             */
+            reset() {
+                this.input = '';
+            }
+        };
+        this.show = false;
+    }
+    /**
+     * @param {?} model
+     * @return {?}
+     */
+    set comboModel(model) {
+        this._comboModel = model;
+        if (!model) {
+            this.filteredModel = [];
+            return;
+        }
+        for (let i = 0; i < this.filteredModel.length; i++) {
+            /** @type {?} */
+            const idx = model.indexOf(this.filteredModel[i]);
+            if (idx < 0) {
+                this.filteredModel.splice(idx, 1);
+                i--;
+            }
+        }
+    }
+    /**
+     * @param {?} label
+     * @return {?}
+     */
+    labels(label) {
+        return this.labelsService.getLabel(label);
+    }
+    /**
+     * @return {?}
+     */
+    toggleVisibility() {
+        this.show = !this.show;
+        if (this.show) {
+            this.search.reset();
+            this.onOpen.emit();
+        }
+        else {
+            this.onClose.emit();
+        }
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    isSelected(item) {
+        return this.filteredModel && this.filteredModel.indexOf(item) >= 0;
+    }
+    /**
+     * @return {?}
+     */
+    isDisabled() {
+        return this.filteredModel && this.maxSelected &&
+            this.maxSelected <= this.filteredModel.length;
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    toggleItem(item) {
+        /** @type {?} */
+        const idx = this.filteredModel.indexOf(item);
+        if (idx >= 0) {
+            this.filteredModel.splice(idx, 1);
+            this.onDeselectItem.emit(item);
+        }
+        else if (!this.maxSelected ||
+            this.filteredModel.length < this.maxSelected) {
+            this.filteredModel.push(item);
+            this.onSelectItem.emit(item);
+        }
+        this.filteredModelChange.emit(this.filteredModel);
+    }
+    /**
+     * @return {?}
+     */
+    selectAll() {
+        this.filteredModel = [];
+        for (let i = 0; i < this.filteredComboModel.length; i++) {
+            this.filteredModel.push(this.filteredComboModel[i]);
+        }
+        this.filteredModelChange.emit(this.filteredModel);
+    }
+    /**
+     * @return {?}
+     */
+    deselectAll() {
+        this.filteredModel = [];
+        this.filteredModelChange.emit(this.filteredModel);
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    displayItem(item) {
+        return item instanceof Object ?
+            this.display && typeof this.display === 'string' ?
+                item[this.display] :
+                item.toString() :
+            this.display && this.display instanceof Function ?
+                this.display(item || '') :
+                item;
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onClick(event) {
+        if (this.show && !this._eref.nativeElement.contains(event.target)) {
+            this.toggleVisibility();
+        }
+        return true;
+    }
+    /**
+     * @return {?}
+     */
+    getFilter() {
+        if (!this.filter) {
+            return '';
+        }
+        /** @type {?} */
+        let filter = '';
+        if (this._comboModel.length > 0) {
+            if (typeof this._comboModel[0] === 'string') {
+                filter = this.search.input;
+            }
+            else {
+                filter = {};
+                filter[this.filter] = this.search.input;
+            }
+        }
+        return filter;
+    }
+}
+MultiComboComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ode-multi-combo',
+                template: "<button (click)=\"toggleVisibility()\"\n        [ngClass]=\"{ opened: show }\"\n        [disabled]=\"disabled\"\n        type=\"button\">\n  {{ title }}\n</button>\n<div [ngClass]=\"{ hidden: !show }\">\n  <div class=\"options\">\n    <button class=\"select-all\" (click)=\"selectAll()\" *ngIf=\"!maxSelected\"\n            [title]=\"labels('select.all')\" type=\"button\">{{ labels('select.all') }}</button>\n    <button class=\"deselect-all\" (click)=\"deselectAll()\"\n            [title]=\"labels('deselect.all')\" type=\"button\">{{ labels('deselect.all') }}</button>\n  </div>\n  <div *ngIf=\"filter\" class=\"filter\">\n    <ode-search-input (onChange)=\"search.input = $event\" [attr.placeholder]=\"labels('search')\"></ode-search-input>\n  </div>\n  <ul>\n    <li *ngFor=\"let item of _comboModel | filter: getFilter() | orderBy: orderBy | store: self:'filteredComboModel'\"\n        (click)=\"toggleItem(item)\"\n        [ngClass]=\"{ selected: isSelected(item) }\"\n        [attr.disabled]=\"isDisabled()\">\n      {{ displayItem(item) | translate }}\n    </li>\n  </ul>\n</div>\n",
+                host: {
+                    '(document:click)': 'onClick($event)',
+                },
+                styles: [":host{position:relative}:host>button{min-width:150px}:host>div{position:absolute;z-index:2;left:0;overflow:hidden;background:#fff;border:2px solid #000}:host>div.hidden{max-height:0;border-width:0}:host>div>div.options>*{display:inline-block;vertical-align:middle}:host>div>div.filter{margin:10px 0;width:100%;position:relative}:host>div>div.filter input{width:100%}:host>div>ul{list-style:none;padding:0;overflow-y:auto;max-height:200px}:host>div>ul>li{white-space:nowrap;cursor:pointer}:host>div>ul>li:not(.selected)[disabled=true]{pointer-events:none}"]
+            }] }
+];
+/** @nocollapse */
+MultiComboComponent.ctorParameters = () => [
+    { type: ElementRef },
+    { type: LabelsService },
+    { type: Injector }
+];
+MultiComboComponent.propDecorators = {
+    comboModel: [{ type: Input }],
+    filteredModel: [{ type: Input, args: ['outputModel',] }],
+    title: [{ type: Input }],
+    display: [{ type: Input }],
+    filter: [{ type: Input }],
+    orderBy: [{ type: Input }],
+    reverse: [{ type: Input }],
+    maxSelected: [{ type: Input, args: ['max',] }],
+    disabled: [{ type: Input }],
+    onSelectItem: [{ type: Output }],
+    onDeselectItem: [{ type: Output }],
+    filteredModelChange: [{ type: Output, args: ['outputModelChange',] }],
+    onOpen: [{ type: Output }],
+    onClose: [{ type: Output }]
+};
+if (false) {
+    /** @type {?} */
+    MultiComboComponent.prototype.filteredModel;
+    /** @type {?} */
+    MultiComboComponent.prototype.title;
+    /** @type {?} */
+    MultiComboComponent.prototype.display;
+    /** @type {?} */
+    MultiComboComponent.prototype.filter;
+    /** @type {?} */
+    MultiComboComponent.prototype.orderBy;
+    /** @type {?} */
+    MultiComboComponent.prototype.reverse;
+    /** @type {?} */
+    MultiComboComponent.prototype.maxSelected;
+    /** @type {?} */
+    MultiComboComponent.prototype.disabled;
+    /** @type {?} */
+    MultiComboComponent.prototype.onSelectItem;
+    /** @type {?} */
+    MultiComboComponent.prototype.onDeselectItem;
+    /** @type {?} */
+    MultiComboComponent.prototype.filteredModelChange;
+    /** @type {?} */
+    MultiComboComponent.prototype.onOpen;
+    /** @type {?} */
+    MultiComboComponent.prototype.onClose;
+    /** @type {?} */
+    MultiComboComponent.prototype.self;
+    /** @type {?} */
+    MultiComboComponent.prototype._comboModel;
+    /** @type {?} */
+    MultiComboComponent.prototype.filteredComboModel;
+    /** @type {?} */
+    MultiComboComponent.prototype.search;
+    /** @type {?} */
+    MultiComboComponent.prototype.show;
+    /**
+     * @type {?}
+     * @private
+     */
+    MultiComboComponent.prototype._eref;
+    /**
+     * @type {?}
+     * @private
+     */
+    MultiComboComponent.prototype.labelsService;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multi-combo.component.js","sourceRoot":"ng://ngx-ode-ui/","sources":["lib/components/multi-combo/multi-combo.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, EventEmitter, Input, Output, Injector } from '@angular/core';\nimport {LabelsService} from '../../services/labels.service';\nimport { OdeComponent } from 'ngx-ode-core';\n\n/* If you need to use multi-combo in a form you should give a look to the MultiSelectComponent. */\n\n@Component({\n    selector: 'ode-multi-combo',\n    templateUrl: './multi-combo.component.html',\n    styleUrls: ['./multi-combo.component.scss'],\n    host: {\n        '(document:click)': 'onClick($event)',\n    }\n})\nexport class MultiComboComponent extends OdeComponent {\n\n    constructor(\n        private _eref: ElementRef,\n        private labelsService: LabelsService,\n        injector: Injector) {\n        super(injector);\n    }\n\n    @Input()\n    set comboModel(model) {\n        this._comboModel = model;\n\n        if (!model) {\n            this.filteredModel = [];\n            return;\n        }\n\n        for (let i = 0; i < this.filteredModel.length; i++) {\n            const idx = model.indexOf(this.filteredModel[i]);\n            if (idx < 0) {\n                this.filteredModel.splice(idx, 1);\n                i--;\n            }\n        }\n    }\n    @Input('outputModel') filteredModel = [];\n    @Input() title = 'Select';\n    @Input() display: string | Function;\n    @Input() filter: string;\n    @Input() orderBy: (string | Array<(string | Function)> | Function);\n    @Input() reverse = false;\n    @Input('max') maxSelected: number;\n    @Input() disabled = false;\n\n    @Output() onSelectItem = new EventEmitter<any>();\n    @Output() onDeselectItem = new EventEmitter<any>();\n    @Output('outputModelChange') filteredModelChange = new EventEmitter<any>();\n    @Output() onOpen = new EventEmitter<any>();\n    @Output() onClose = new EventEmitter<any>();\n\n    self = this;\n    _comboModel = [];\n\n    filteredComboModel = [];\n\n    search = {\n        input: '',\n        reset() {\n            this.input = '';\n        }\n    };\n\n    show = false;\n\n    labels(label) {\n        return this.labelsService.getLabel(label);\n    }\n\n    toggleVisibility() {\n        this.show = !this.show;\n        if (this.show) {\n            this.search.reset();\n            this.onOpen.emit();\n        } else {\n             this.onClose.emit();\n        }\n    }\n\n    isSelected(item) {\n        return this.filteredModel && this.filteredModel.indexOf(item) >= 0;\n    }\n\n    isDisabled() {\n        return this.filteredModel && this.maxSelected &&\n            this.maxSelected <= this.filteredModel.length;\n    }\n\n    toggleItem(item) {\n        const idx = this.filteredModel.indexOf(item);\n        if (idx >= 0) {\n            this.filteredModel.splice(idx, 1);\n            this.onDeselectItem.emit(item);\n        } else if (!this.maxSelected ||\n                this.filteredModel.length < this.maxSelected) {\n            this.filteredModel.push(item);\n            this.onSelectItem.emit(item);\n        }\n        this.filteredModelChange.emit(this.filteredModel);\n    }\n\n    selectAll() {\n        this.filteredModel = [];\n        for (let i = 0; i < this.filteredComboModel.length; i++) {\n            this.filteredModel.push(this.filteredComboModel[i]);\n        }\n        this.filteredModelChange.emit(this.filteredModel);\n    }\n\n    deselectAll() {\n        this.filteredModel = [];\n        this.filteredModelChange.emit(this.filteredModel);\n    }\n\n    displayItem(item) {\n        return  item instanceof Object ?\n                    this.display && typeof this.display === 'string' ?\n                        item[this.display] :\n                        item.toString() :\n                    this.display && this.display instanceof Function ?\n                        this.display(item || '') :\n                        item;\n    }\n\n    onClick(event) {\n        if (this.show && !this._eref.nativeElement.contains(event.target)) {\n            this.toggleVisibility();\n        }\n        return true;\n    }\n\n    getFilter() {\n        if (!this.filter) {\n            return '';\n        }\n        let filter: string | {} = '';\n        if (this._comboModel.length > 0 ) {\n            if (typeof this._comboModel[0] === 'string') {\n                filter = this.search.input;\n            } else {\n                filter = {};\n                filter[this.filter] = this.search.input;\n            }\n        }\n        return filter;\n    }\n\n}\n"]}

package/esm2015/lib/components/multi-select/multi-select.component.js

@@ -0,0 +1,214 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/multi-select/multi-select.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ElementRef, forwardRef, Input, Injector } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+/**
+ * @record
+ * @template K
+ */
+export function SelectOption() { }
+if (false) {
+    /** @type {?} */
+    SelectOption.prototype.label;
+    /** @type {?} */
+    SelectOption.prototype.value;
+}
+/**
+ * @template K
+ */
+export class MultiSelectComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     * @param {?} elementRef
+     */
+    constructor(injector, elementRef) {
+        super(injector);
+        this.elementRef = elementRef;
+        this.label = '';
+        this.options = [];
+        this.preview = false;
+        this.model = [];
+        this.isDisabled = false;
+        this.isOptionsVisible = false;
+        this.onChange = (/**
+         * @param {?} _
+         * @return {?}
+         */
+        (_) => {
+        });
+        this.onTouched = (/**
+         * @return {?}
+         */
+        () => {
+        });
+    }
+    /**
+     * @param {?} option
+     * @return {?}
+     */
+    optionClicked(option) {
+        if (this.model) {
+            /** @type {?} */
+            const index = this.getIndexOfOptionInModel(option);
+            if (index < 0) {
+                this.model.push(option.value);
+            }
+            else {
+                this.model.splice(index, 1);
+            }
+        }
+        else {
+            this.model = [option.value];
+        }
+        this.onChange(this.model);
+    }
+    /**
+     * @return {?}
+     */
+    selectAll() {
+        this.options.forEach((/**
+         * @param {?} option
+         * @return {?}
+         */
+        option => {
+            if (!this.model.includes(option.value)) {
+                this.model.push(option.value);
+            }
+        }));
+        this.onChange(this.model);
+    }
+    /**
+     * @return {?}
+     */
+    deselectAll() {
+        this.model = [];
+        this.onChange(this.model);
+    }
+    /**
+     * @return {?}
+     */
+    toggleOptionsVisibility() {
+        this.isOptionsVisible = !this.isOptionsVisible;
+    }
+    /**
+     * @param {?} option
+     * @return {?}
+     */
+    isSelected(option) {
+        return this.model ? (this.getIndexOfOptionInModel(option) >= 0) : false;
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    closeIfOpened(event) {
+        if (this.isOptionsVisible
+            && !this.elementRef.nativeElement.querySelector('.lct-multi-select__options-container').contains(event.target)
+            && !this.elementRef.nativeElement.querySelector('.lct-multi-select__toggle').contains(event.target)) {
+            this.isOptionsVisible = false;
+        }
+        return true;
+    }
+    /**
+     * @private
+     * @param {?} option
+     * @return {?}
+     */
+    getIndexOfOptionInModel(option) {
+        return this.model.map(this.trackByFn).indexOf(this.trackByFn(option.value));
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /**
+     * @param {?} isDisabled
+     * @return {?}
+     */
+    setDisabledState(isDisabled) {
+        this.isDisabled = isDisabled;
+    }
+    /**
+     * @param {?} obj
+     * @return {?}
+     */
+    writeValue(obj) {
+        this.model = obj;
+        this.onChange(this.model);
+    }
+}
+MultiSelectComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ode-multi-select',
+                template: "<button type=\"button\"\n        (click)=\"toggleOptionsVisibility()\" [disabled]=\"isDisabled\"\n        class=\"multi-select__toggle lct-multi-select__toggle\"\n        [ngClass]=\"{'multi-select__toggle--active': isOptionsVisible}\">{{label |\u00A0translate}}</button>\n<div class=\"multi-select__options-container lct-multi-select__options-container\"\n     [ngClass]=\"{'multi-select__options-container--active': isOptionsVisible}\">\n  <div class=\"multi-select__options-actions\">\n    <button type=\"button\"\n            class=\"multi-select__options-actions-item\"\n            (click)=\"selectAll()\">{{'ux.multiselect.select-all' | translate}}</button>\n    <button type=\"button\"\n            class=\"multi-select__options-actions-item\"\n            (click)=\"deselectAll()\">{{'ux.multiselect.deselect-all' | translate}}</button>\n  </div>\n  <ul class=\"multi-select__options lct-multi-select__options\">\n    <li class=\"multi-select__options-item lct-multi-select__options-item\"\n        *ngFor=\"let option of options\"\n        (click)=\"optionClicked(option)\"\n        [ngClass]=\"{'multi-select__options-item--selected': isSelected(option)}\">{{option.label | translate}}</li>\n  </ul>\n</div>\n<div class=\"multi-select__options-preview lct-multi-select__options-preview\" *ngIf=\"preview\">\n  <ng-container *ngFor=\"let option of options\">\n    <button *ngIf=\"isSelected(option)\"\n            type=\"button\"\n            class=\"multi-select__options-preview-item lct-multi-select__options-preview-item\"\n            (click)=\"optionClicked(option)\">\n      <span>{{option.label | translate}}</span>\n      <i class=\"multi-select__options-preview-item-delete-icon fa fa-trash is-size-5\"></i>\n    </button>\n  </ng-container>\n</div>\n",
+                providers: [{
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef((/**
+                         * @return {?}
+                         */
+                        () => MultiSelectComponent)),
+                        multi: true
+                    }],
+                host: {
+                    '(document:click)': 'closeIfOpened($event)'
+                },
+                styles: ["@charset \"UTF-8\";:host{position:relative}.multi-select__toggle{min-width:210px;outline:0;background-color:#f2f2f2}.multi-select__toggle:after{content:\"\u25BC\";float:right;margin-left:10px;transition:transform .25s,color .25s}.multi-select__toggle:hover:after{color:#fff}.multi-select__toggle.multi-select__toggle--active,.multi-select__toggle:hover{background-color:#ff8352;color:#fff}.multi-select__toggle.multi-select__toggle--active:after{transform:rotate(180deg);color:#fff}.multi-select__options-container{display:none;position:absolute;z-index:2;left:1px;top:31px;overflow:hidden;background:#fff;border:1px solid #ddd;padding:0 10px 0 20px;min-width:160px}.multi-select__options-container.multi-select__options-container--active{display:block}.multi-select__options{list-style:none;padding:0;overflow-y:scroll;max-height:200px;margin-bottom:10px}.multi-select__options-item{white-space:nowrap;cursor:pointer;line-height:25px;font-size:13px;transition:background-color .25s,color .25s;margin-bottom:5px;padding:0 10px}.multi-select__options-item.multi-select__options-item--selected{color:#fff;background-color:#217b9e}.multi-select__options-preview{color:#fff;margin:10px 0}.multi-select__options-preview-item{border:1px solid #217b9e;display:inline-block;font-size:.8em;margin-right:10px;margin-bottom:10px;padding:10px;cursor:pointer;transition:.25s;border-radius:3px;background-color:#217b9e;line-height:1.5em;color:#fff}.multi-select__options-preview-item:hover{background-color:#61bbde;border-color:#fff}.multi-select__options-preview-item-delete-icon{opacity:0;transition:opacity .25s;float:right;padding-left:10px}.multi-select__options-preview-item:hover .multi-select__options-preview-item-delete-icon{opacity:1}.multi-select__options-actions{margin-top:10px}.multi-select__options-actions-item{margin-bottom:3px;min-width:136px}.multi-select__options-actions-item:hover{background:#ffccb8}"]
+            }] }
+];
+/** @nocollapse */
+MultiSelectComponent.ctorParameters = () => [
+    { type: Injector },
+    { type: ElementRef }
+];
+MultiSelectComponent.propDecorators = {
+    label: [{ type: Input }],
+    options: [{ type: Input }],
+    preview: [{ type: Input }],
+    trackByFn: [{ type: Input }]
+};
+if (false) {
+    /** @type {?} */
+    MultiSelectComponent.prototype.label;
+    /** @type {?} */
+    MultiSelectComponent.prototype.options;
+    /** @type {?} */
+    MultiSelectComponent.prototype.preview;
+    /** @type {?} */
+    MultiSelectComponent.prototype.trackByFn;
+    /** @type {?} */
+    MultiSelectComponent.prototype.model;
+    /** @type {?} */
+    MultiSelectComponent.prototype.isDisabled;
+    /** @type {?} */
+    MultiSelectComponent.prototype.isOptionsVisible;
+    /**
+     * @type {?}
+     * @private
+     */
+    MultiSelectComponent.prototype.onChange;
+    /**
+     * @type {?}
+     * @private
+     */
+    MultiSelectComponent.prototype.onTouched;
+    /**
+     * @type {?}
+     * @private
+     */
+    MultiSelectComponent.prototype.elementRef;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multi-select.component.js","sourceRoot":"ng://ngx-ode-ui/","sources":["lib/components/multi-select/multi-select.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { OdeComponent } from 'ngx-ode-core';\nimport { Component, ElementRef, forwardRef, Input, Injector } from '@angular/core';\nimport {ControlValueAccessor, NG_VALUE_ACCESSOR} from '@angular/forms';\n\n/* MultiSelectComponent is a rewrite of MultiComboComponent to integrate it easily in angular forms */\n\nexport interface SelectOption<K> {\n    label: string;\n    value: K;\n}\n\n@Component({\n    selector: 'ode-multi-select',\n    templateUrl: './multi-select.component.html',\n    styleUrls: ['./multi-select.component.scss'],\n    providers: [{\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => MultiSelectComponent),\n      multi: true\n    }],\n    host: {\n        '(document:click)': 'closeIfOpened($event)'\n    }\n})\nexport class MultiSelectComponent<K> extends OdeComponent implements ControlValueAccessor {\n    @Input()\n    public label = '';\n\n    @Input()\n    public options: Array<SelectOption<K>> = [];\n\n    @Input()\n    public preview = false;\n\n    @Input()\n    public trackByFn: (optionValue: K) => number | string;\n\n    public model: Array<K> = [];\n\n    public isDisabled = false;\n\n    public isOptionsVisible = false;\n\n    constructor(injector: Injector, private elementRef: ElementRef) {\n        super(injector);\n    }\n\n    public optionClicked(option: SelectOption<K>) {\n        if (this.model) {\n            const index = this.getIndexOfOptionInModel(option);\n            if (index < 0) {\n                this.model.push(option.value);\n            } else {\n                this.model.splice(index, 1);\n            }\n        } else {\n            this.model = [option.value];\n        }\n        this.onChange(this.model);\n    }\n\n    public selectAll(): void {\n      this.options.forEach(option => {\n        if (!this.model.includes(option.value)) {\n          this.model.push(option.value);\n        }\n      });\n      this.onChange(this.model);\n    }\n\n    public deselectAll(): void {\n        this.model = [];\n        this.onChange(this.model);\n    }\n\n    public toggleOptionsVisibility(): void {\n        this.isOptionsVisible = !this.isOptionsVisible;\n    }\n\n    public isSelected(option: SelectOption<K>): boolean {\n        return this.model ? (this.getIndexOfOptionInModel(option) >= 0) : false;\n    }\n\n    public closeIfOpened(event: any) {\n        if (this.isOptionsVisible\n          && !this.elementRef.nativeElement.querySelector('.lct-multi-select__options-container').contains(event.target)\n          && !this.elementRef.nativeElement.querySelector('.lct-multi-select__toggle').contains(event.target)) {\n            this.isOptionsVisible = false;\n        }\n        return true;\n    }\n\n    private getIndexOfOptionInModel(option: SelectOption<K>): number {\n        return this.model.map(this.trackByFn).indexOf(this.trackByFn(option.value));\n    }\n\n    private onChange = (_: Array<K>) => {\n    }\n\n    private onTouched = () => {\n    }\n\n    registerOnChange(fn: any): void {\n        this.onChange = fn;\n    }\n\n    registerOnTouched(fn: any): void {\n        this.onTouched = fn;\n    }\n\n    setDisabledState(isDisabled: boolean): void {\n        this.isDisabled = isDisabled;\n    }\n\n    writeValue(obj: Array<K>): void {\n        this.model = obj;\n        this.onChange(this.model);\n    }\n}\n"]}

package/esm2015/lib/components/panel-section/panel-section.component.js

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/panel-section/panel-section.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, Input, Injector } from '@angular/core';
+export class PanelSectionComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     */
+    constructor(injector) {
+        super(injector);
+        this.folded = null;
+    }
+}
+PanelSectionComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ode-panel-section',
+                template: "<section class=\"panel-section\">\n  <div class=\"panel-section-header is-display-flex has-space-between\" (click)=\"folded !== null ? folded=!folded : null\" [class.foldable]=\"folded !== null\">\n    <div class=\"is-display-flex\">\n      <s5l>{{ sectionTitle\u00A0}}</s5l>\n      <div class=\"has-left-padding-10\">\n        <ng-content select=\"[panel-section-header-icons]\"></ng-content>\n      </div>\n    </div>\n\n    <i class=\"opener\" *ngIf=\"folded !== null\"\n       [class.opened]=\"!folded\"></i>\n  </div>\n  <div class=\"panel-section-content\" *ngIf=\"!folded\">\n    <ng-content></ng-content>\n  </div>\n</section>\n",
+                styles: [".panel-section-header{font-size:1.1em;padding:10px}.panel-section-header.foldable{cursor:pointer}.panel-section-content{padding:15px}"]
+            }] }
+];
+/** @nocollapse */
+PanelSectionComponent.ctorParameters = () => [
+    { type: Injector }
+];
+PanelSectionComponent.propDecorators = {
+    sectionTitle: [{ type: Input, args: ['section-title',] }],
+    folded: [{ type: Input }]
+};
+if (false) {
+    /** @type {?} */
+    PanelSectionComponent.prototype.sectionTitle;
+    /** @type {?} */
+    PanelSectionComponent.prototype.folded;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFuZWwtc2VjdGlvbi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9uZ3gtb2RlLXVpLyIsInNvdXJjZXMiOlsibGliL2NvbXBvbmVudHMvcGFuZWwtc2VjdGlvbi9wYW5lbC1zZWN0aW9uLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFDNUMsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBTzNELE1BQU0sT0FBTyxxQkFBc0IsU0FBUSxZQUFZOzs7O0lBR25ELFlBQVksUUFBa0I7UUFDMUIsS0FBSyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBRlgsV0FBTSxHQUFZLElBQUksQ0FBQztJQUdoQyxDQUFDOzs7WUFWSixTQUFTLFNBQUM7Z0JBQ1AsUUFBUSxFQUFFLG1CQUFtQjtnQkFDN0Isd29CQUE2Qzs7YUFFaEQ7Ozs7WUFOMEIsUUFBUTs7OzJCQVE5QixLQUFLLFNBQUMsZUFBZTtxQkFDckIsS0FBSzs7OztJQUROLDZDQUE2Qzs7SUFDN0MsdUNBQWdDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT2RlQ29tcG9uZW50IH0gZnJvbSAnbmd4LW9kZS1jb3JlJztcbmltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQsIEluamVjdG9yIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICAgIHNlbGVjdG9yOiAnb2RlLXBhbmVsLXNlY3Rpb24nLFxuICAgIHRlbXBsYXRlVXJsOiAnLi9wYW5lbC1zZWN0aW9uLmNvbXBvbmVudC5odG1sJyxcbiAgICBzdHlsZVVybHM6IFsnLi9wYW5lbC1zZWN0aW9uLmNvbXBvbmVudC5zY3NzJ11cbn0pXG5leHBvcnQgY2xhc3MgUGFuZWxTZWN0aW9uQ29tcG9uZW50IGV4dGVuZHMgT2RlQ29tcG9uZW50IHtcbiAgICBASW5wdXQoJ3NlY3Rpb24tdGl0bGUnKSBzZWN0aW9uVGl0bGU6IHN0cmluZztcbiAgICBASW5wdXQoKSBmb2xkZWQ6IGJvb2xlYW4gPSBudWxsO1xuICAgIGNvbnN0cnVjdG9yKGluamVjdG9yOiBJbmplY3Rvcikge1xuICAgICAgICBzdXBlcihpbmplY3Rvcik7XG4gICAgfVxufVxuIl19

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

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/portal/portal.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, Injector } from '@angular/core';
+export class PortalComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     */
+    constructor(injector) {
+        super(injector);
+    }
+}
+PortalComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ode-portal',
+                template: "<header>\n  <ng-content select=\"[header-left]\"></ng-content>\n  <ng-content select=\"[header-middle]\"></ng-content>\n  <ng-content select=\"[header-right]\"></ng-content>\n</header>\n<section>\n  <ng-content select=\"[section]\"></ng-content>\n</section>\n<footer>\n  <ng-content select=\"[footer]\"></ng-content>\n</footer>\n",
+                styles: ["header{position:relative;display:flex;align-items:center;top:0;width:100%}"]
+            }] }
+];
+/** @nocollapse */
+PortalComponent.ctorParameters = () => [
+    { type: Injector }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9ydGFsLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25neC1vZGUtdWkvIiwic291cmNlcyI6WyJsaWIvY29tcG9uZW50cy9wb3J0YWwvcG9ydGFsLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFDNUMsT0FBTyxFQUFFLFNBQVMsRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFPcEQsTUFBTSxPQUFPLGVBQWdCLFNBQVEsWUFBWTs7OztJQUM3QyxZQUFZLFFBQWtCO1FBQzFCLEtBQUssQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUNwQixDQUFDOzs7WUFSSixTQUFTLFNBQUM7Z0JBQ1AsUUFBUSxFQUFFLFlBQVk7Z0JBQ3RCLHFWQUFzQzs7YUFFekM7Ozs7WUFObUIsUUFBUSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9kZUNvbXBvbmVudCB9IGZyb20gJ25neC1vZGUtY29yZSc7XG5pbXBvcnQgeyBDb21wb25lbnQsIEluamVjdG9yIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICAgIHNlbGVjdG9yOiAnb2RlLXBvcnRhbCcsXG4gICAgdGVtcGxhdGVVcmw6ICcuL3BvcnRhbC5jb21wb25lbnQuaHRtbCcsXG4gICAgc3R5bGVVcmxzOiBbJy4vcG9ydGFsLmNvbXBvbmVudC5zY3NzJ11cbn0pXG5leHBvcnQgY2xhc3MgUG9ydGFsQ29tcG9uZW50IGV4dGVuZHMgT2RlQ29tcG9uZW50IHtcbiAgICBjb25zdHJ1Y3RvcihpbmplY3RvcjogSW5qZWN0b3IpIHtcbiAgICAgICAgc3VwZXIoaW5qZWN0b3IpO1xuICAgIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,81 @@
+/**
+ * @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 { OdeComponent } from 'ngx-ode-core';
+import { Component, ElementRef, EventEmitter, Input, Output, ViewChild, Injector } from '@angular/core';
+export class PushPanelComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     */
+    constructor(injector) {
+        super(injector);
+        this.onClose = new EventEmitter();
+    }
+    /**
+     * @private
+     * @param {?} toggle
+     * @return {?}
+     */
+    set toggle(toggle) {
+        this._opened = toggle;
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onClick(event) {
+        /** @type {?} */
+        const 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 = () => [
+    { type: Injector }
+];
+PushPanelComponent.propDecorators = {
+    toggle: [{ type: Input }],
+    opener: [{ type: Input }],
+    onClose: [{ type: Output }],
+    inside: [{ type: ViewChild, args: ['inside', { static: false },] }]
+};
+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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