@lucca-front/ng 7.2.0 → 8.0.0-alpha.1

package/esm2020/option/lib/option.module.mjs

@@ -0,0 +1,50 @@
+import { NgModule } from '@angular/core';
+import { LuOptionItemModule } from './item/index';
+import { LuOptionPickerModule } from './picker/index';
+import { LuOptionOperatorModule } from './operator/index';
+import { LuOptionSelectorModule } from './selector/index';
+import { LuOptionPlaceholderModule } from './placeholder/index';
+import * as i0 from "@angular/core";
+export class LuOptionModule {
+}
+LuOptionModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuOptionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LuOptionModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuOptionModule, imports: [LuOptionItemModule,
+        LuOptionPickerModule,
+        LuOptionOperatorModule,
+        LuOptionSelectorModule,
+        LuOptionPlaceholderModule], exports: [LuOptionItemModule,
+        LuOptionPickerModule,
+        LuOptionOperatorModule,
+        LuOptionSelectorModule,
+        LuOptionPlaceholderModule] });
+LuOptionModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuOptionModule, imports: [[
+            LuOptionItemModule,
+            LuOptionPickerModule,
+            LuOptionOperatorModule,
+            LuOptionSelectorModule,
+            LuOptionPlaceholderModule,
+        ], LuOptionItemModule,
+        LuOptionPickerModule,
+        LuOptionOperatorModule,
+        LuOptionSelectorModule,
+        LuOptionPlaceholderModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuOptionModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        LuOptionItemModule,
+                        LuOptionPickerModule,
+                        LuOptionOperatorModule,
+                        LuOptionSelectorModule,
+                        LuOptionPlaceholderModule,
+                    ],
+                    exports: [
+                        LuOptionItemModule,
+                        LuOptionPickerModule,
+                        LuOptionOperatorModule,
+                        LuOptionSelectorModule,
+                        LuOptionPlaceholderModule,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/option/lib/picker/option-picker-advanced.component.mjs

@@ -0,0 +1,142 @@
+import { ChangeDetectionStrategy, Component, ContentChildren, forwardRef, Directive, Inject, } from '@angular/core';
+import { luTransformPopover } from '@lucca-front/ng/popover';
+import { merge } from 'rxjs';
+import { first, mapTo, startWith, shareReplay, mergeAll } from 'rxjs/operators';
+import { ALuPickerPanel } from '@lucca-front/ng/picker';
+import { ALuOptionOperator, } from '../operator/index';
+import { ALuOnOpenSubscriber, ALuOnCloseSubscriber, ALuOnScrollBottomSubscriber, } from '@lucca-front/ng/core';
+import { ALuOptionPickerComponent } from './option-picker.component';
+import { ALuOptionSelector } from '../selector/index';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@lucca-front/ng/scroll";
+import * as i3 from "@angular/cdk/a11y";
+export class ALuOptionPickerAdvancedComponent extends ALuOptionPickerComponent {
+    constructor(_changeDetectorRef, document) {
+        super(_changeDetectorRef, document);
+        this._operators = [];
+        this._onOpenSubscribers = [];
+        this._onCloseSubscribers = [];
+        this._onScrollBottomSubscribers = [];
+        this._selectors = [];
+    }
+    set operatorsQL(ql) {
+        this._operatorsQL = ql;
+    }
+    set onOpenSubsQL(ql) {
+        this._onOpenSubscribers = ql.toArray();
+    }
+    set onCloseSubsQL(ql) {
+        this._onCloseSubscribers = ql.toArray();
+    }
+    set onScrollBottomSubsQL(ql) {
+        this._onScrollBottomSubscribers = ql.toArray();
+    }
+    set selectorsQL(ql) {
+        this._selectorsQL = ql;
+    }
+    onScrollBottom() {
+        this._onScrollBottomSubscribers.forEach(o => {
+            if (!o.onScrollBottom) {
+                return;
+            }
+            o.onScrollBottom();
+        });
+    }
+    onOpen() {
+        this._onOpenSubscribers.forEach(o => {
+            o.onOpen();
+        });
+        const operators = this._operators || [];
+        const lastOperator = operators[operators.length - 1];
+        if (lastOperator && lastOperator.outOptions$) {
+            this.loading$ = lastOperator.outOptions$.pipe(first(), mapTo(false), startWith(true), shareReplay());
+        }
+        super.onOpen();
+    }
+    onClose() {
+        this._onCloseSubscribers.forEach(o => {
+            o.onClose();
+        });
+        super.onClose();
+    }
+    setValue(value) {
+        super.setValue(value);
+        this._selectors.forEach(s => s.setValue(value));
+    }
+    initOperators() {
+        const operators = this._operatorsQL.toArray();
+        this._operators = operators;
+        let options$;
+        operators.forEach(operator => {
+            operator.inOptions$ = options$;
+            options$ = operator.outOptions$;
+        });
+    }
+    initSelectors() {
+        const selectors$ = this._selectorsQL.changes.pipe(startWith(this._selectorsQL.toArray()));
+        this._subs.add(selectors$.subscribe(selectors => {
+            this._selectors = selectors;
+            this._subs.add(merge(this._selectors.map(s => s.onSelectValue)).pipe(mergeAll()).subscribe(values => {
+                this._select(values);
+            }));
+        }));
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        this.initOperators();
+        this.initSelectors();
+    }
+}
+ALuOptionPickerAdvancedComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: ALuOptionPickerAdvancedComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });
+ALuOptionPickerAdvancedComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.2", type: ALuOptionPickerAdvancedComponent, queries: [{ propertyName: "operatorsQL", predicate: ALuOptionOperator, descendants: true }, { propertyName: "onOpenSubsQL", predicate: ALuOnOpenSubscriber, descendants: true }, { propertyName: "onCloseSubsQL", predicate: ALuOnCloseSubscriber, descendants: true }, { propertyName: "onScrollBottomSubsQL", predicate: ALuOnScrollBottomSubscriber, descendants: true }, { propertyName: "selectorsQL", predicate: ALuOptionSelector, descendants: true }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: ALuOptionPickerAdvancedComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { operatorsQL: [{
+                type: ContentChildren,
+                args: [ALuOptionOperator, { descendants: true }]
+            }], onOpenSubsQL: [{
+                type: ContentChildren,
+                args: [ALuOnOpenSubscriber, { descendants: true }]
+            }], onCloseSubsQL: [{
+                type: ContentChildren,
+                args: [ALuOnCloseSubscriber, { descendants: true }]
+            }], onScrollBottomSubsQL: [{
+                type: ContentChildren,
+                args: [ALuOnScrollBottomSubscriber, { descendants: true }]
+            }], selectorsQL: [{
+                type: ContentChildren,
+                args: [ALuOptionSelector, { descendants: true }]
+            }] } });
+/**
+* advanced option picker panel
+*/
+export class LuOptionPickerAdvancedComponent extends ALuOptionPickerAdvancedComponent {
+    constructor(_changeDetectorRef, document) {
+        super(_changeDetectorRef, document);
+    }
+}
+LuOptionPickerAdvancedComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuOptionPickerAdvancedComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
+LuOptionPickerAdvancedComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: LuOptionPickerAdvancedComponent, selector: "lu-option-picker-advanced", providers: [
+        {
+            provide: ALuPickerPanel,
+            useExisting: forwardRef(() => LuOptionPickerAdvancedComponent),
+        },
+    ], exportAs: ["LuOptionPickerAdvanced"], usesInheritance: true, ngImport: i0, template: "<ng-template>\r\n\t<div class=\"lu-picker-panel lu-option-picker-panel\" role=\"dialog\" [ngClass]=\"panelClassesMap\" [class.mod-multiple]=\"multiple\"\r\n\t (click)=\"onClick()\" (mouseover)=\"onMouseOver()\" (mouseleave)=\"onMouseLeave()\" (mousedown)=\"onMouseDown($event)\">\r\n\t\t<div [class.is-loading]=\"loading$ | async\" class=\"lu-picker-content\" [ngClass]=\"contentClassesMap\" [cdkTrapFocus]=\"trapFocus\" luScroll (onScrollBottom)=\"onScrollBottom()\">\r\n\t\t\t<ng-content></ng-content>\r\n\t\t\t<div *ngIf=\"loading$ | async\" class=\"loading lu-picker-loading\"></div>\r\n\t\t</div>\r\n\t</div>\r\n</ng-template>\r\n", styles: [""], directives: [{ type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i2.LuScrollDirective, selector: "[luScroll]", inputs: ["debounceTime"], outputs: ["onScroll", "onScrollTop", "onScrollBottom", "onScrollLeft", "onScrollRight"], exportAs: ["luScroll"] }, { type: i3.CdkTrapFocus, selector: "[cdkTrapFocus]", inputs: ["cdkTrapFocus", "cdkTrapFocusAutoCapture"], exportAs: ["cdkTrapFocus"] }, { type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "async": i1.AsyncPipe }, animations: [luTransformPopover], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuOptionPickerAdvancedComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lu-option-picker-advanced', changeDetection: ChangeDetectionStrategy.OnPush, animations: [luTransformPopover], exportAs: 'LuOptionPickerAdvanced', providers: [
+                        {
+                            provide: ALuPickerPanel,
+                            useExisting: forwardRef(() => LuOptionPickerAdvancedComponent),
+                        },
+                    ], template: "<ng-template>\r\n\t<div class=\"lu-picker-panel lu-option-picker-panel\" role=\"dialog\" [ngClass]=\"panelClassesMap\" [class.mod-multiple]=\"multiple\"\r\n\t (click)=\"onClick()\" (mouseover)=\"onMouseOver()\" (mouseleave)=\"onMouseLeave()\" (mousedown)=\"onMouseDown($event)\">\r\n\t\t<div [class.is-loading]=\"loading$ | async\" class=\"lu-picker-content\" [ngClass]=\"contentClassesMap\" [cdkTrapFocus]=\"trapFocus\" luScroll (onScrollBottom)=\"onScrollBottom()\">\r\n\t\t\t<ng-content></ng-content>\r\n\t\t\t<div *ngIf=\"loading$ | async\" class=\"loading lu-picker-loading\"></div>\r\n\t\t</div>\r\n\t</div>\r\n</ng-template>\r\n", styles: [""] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"option-picker-advanced.component.js","sourceRoot":"","sources":["../../../../../../packages/ng/option/src/lib/picker/option-picker-advanced.component.ts","../../../../../../packages/ng/option/src/lib/picker/option-picker-advanced.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n\tChangeDetectionStrategy,\r\n\tComponent,\r\n\tContentChildren,\r\n\tQueryList,\r\n\tforwardRef,\r\n\tChangeDetectorRef,\r\n\tAfterViewInit,\r\n\tDirective,\r\n\tInject,\r\n} from '@angular/core';\r\nimport { luTransformPopover } from '@lucca-front/ng/popover';\r\nimport { Observable, merge } from 'rxjs';\r\nimport { first, mapTo, startWith, shareReplay, delay, mergeAll } from 'rxjs/operators';\r\n\r\nimport { ALuPickerPanel } from '@lucca-front/ng/picker';\r\nimport {\r\n\tALuOptionOperator,\r\n\tILuOptionOperator,\r\n} from '../operator/index';\r\nimport {\r\n\tALuOnOpenSubscriber,\r\n\tALuOnCloseSubscriber,\r\n\tALuOnScrollBottomSubscriber,\r\n\tILuOnOpenSubscriber,\r\n\tILuOnCloseSubscriber,\r\n\tILuOnScrollBottomSubscriber,\r\n} from '@lucca-front/ng/core';\r\nimport { ALuOptionPickerComponent } from './option-picker.component';\r\nimport { ALuOptionSelector, ILuOptionSelector } from '../selector/index';\r\nimport { DOCUMENT } from '@angular/common';\r\n\r\n@Directive()\r\nexport abstract class ALuOptionPickerAdvancedComponent<T, O extends import('../item/option-item.model').ILuOptionItem<T> = import('../item/option-item.model').ILuOptionItem<T>>\r\nextends ALuOptionPickerComponent<T, O> implements AfterViewInit {\r\n\tloading$: Observable<boolean>;\r\n\r\n\tprotected _operators = [];\r\n\tprotected _operatorsQL: QueryList<ILuOptionOperator<T>>;\r\n\t@ContentChildren(ALuOptionOperator, { descendants: true }) set operatorsQL(ql: QueryList<ILuOptionOperator<T>>) {\r\n\t\tthis._operatorsQL = ql;\r\n\t}\r\n\tprotected _onOpenSubscribers = [];\r\n\t@ContentChildren(ALuOnOpenSubscriber, { descendants: true }) set onOpenSubsQL(ql: QueryList<ILuOnOpenSubscriber>) {\r\n\t\tthis._onOpenSubscribers = ql.toArray();\r\n\t}\r\n\tprotected _onCloseSubscribers = [];\r\n\t@ContentChildren(ALuOnCloseSubscriber, { descendants: true }) set onCloseSubsQL(ql: QueryList<ILuOnCloseSubscriber>) {\r\n\t\tthis._onCloseSubscribers = ql.toArray();\r\n\t}\r\n\tprotected _onScrollBottomSubscribers = [];\r\n\t@ContentChildren(ALuOnScrollBottomSubscriber, { descendants: true }) set onScrollBottomSubsQL(ql: QueryList<ILuOnScrollBottomSubscriber>) {\r\n\t\tthis._onScrollBottomSubscribers = ql.toArray();\r\n\t}\r\n\tprotected _selectors: ILuOptionSelector<T>[] = [];\r\n\tprotected _selectorsQL: QueryList<ILuOptionSelector<T>>;\r\n\t@ContentChildren(ALuOptionSelector, {descendants: true}) set selectorsQL(ql: QueryList<ILuOptionSelector<T>>) {\r\n\t\tthis._selectorsQL = ql;\r\n\t}\r\n\r\n\tconstructor(\r\n\t\t_changeDetectorRef: ChangeDetectorRef,\r\n\t\t@Inject(DOCUMENT) document: Document,\r\n\t) {\r\n\t\tsuper(_changeDetectorRef, document);\r\n\t}\r\n\tonScrollBottom() {\r\n\t\tthis._onScrollBottomSubscribers.forEach(o => {\r\n\t\t\tif (!o.onScrollBottom) { return; }\r\n\t\t\to.onScrollBottom();\r\n\t\t});\r\n\t}\r\n\toverride onOpen() {\r\n\t\tthis._onOpenSubscribers.forEach(o => {\r\n\t\t\to.onOpen();\r\n\t\t});\r\n\t\tconst operators = this._operators || [];\r\n\t\tconst lastOperator = operators[operators.length - 1];\r\n\t\tif (lastOperator && lastOperator.outOptions$) {\r\n\t\t\tthis.loading$ = lastOperator.outOptions$.pipe(\r\n\t\t\t\tfirst(),\r\n\t\t\t\tmapTo(false),\r\n\t\t\t\tstartWith(true),\r\n\t\t\t\tshareReplay(),\r\n\t\t\t);\r\n\t\t}\r\n\t\tsuper.onOpen();\r\n\t}\r\n\toverride onClose() {\r\n\t\tthis._onCloseSubscribers.forEach(o => {\r\n\t\t\to.onClose();\r\n\t\t});\r\n\t\tsuper.onClose();\r\n\t}\r\n\toverride setValue(value: T | T[]) {\r\n\t\tsuper.setValue(value);\r\n\t\tthis._selectors.forEach(s => s.setValue(value));\r\n\t}\r\n\tprotected initOperators() {\r\n\t\tconst operators = this._operatorsQL.toArray();\r\n\t\tthis._operators = operators;\r\n\t\tlet options$: Observable<T[]>;\r\n\t\toperators.forEach(operator => {\r\n\t\t\toperator.inOptions$ = options$;\r\n\t\t\toptions$ = operator.outOptions$;\r\n\t\t});\r\n\t}\r\n\tprotected initSelectors() {\r\n\t\tconst selectors$: Observable<ILuOptionSelector<T>[]> = this._selectorsQL.changes.pipe(\r\n\t\t\tstartWith(this._selectorsQL.toArray()),\r\n\t\t);\r\n\t\tthis._subs.add(\r\n\t\t\tselectors$.subscribe(selectors => {\r\n\t\t\t\tthis._selectors = selectors;\r\n\t\t\t\tthis._subs.add(\r\n\t\t\t\t\tmerge(\r\n\t\t\t\t\t\tthis._selectors.map(s => s.onSelectValue),\r\n\t\t\t\t\t).pipe(\r\n\t\t\t\t\t\tmergeAll(),\r\n\t\t\t\t\t).subscribe(values => {\r\n\t\t\t\t\t\tthis._select(values);\r\n\t\t\t\t\t})\r\n\t\t\t\t);\r\n\t\t\t}),\r\n\t\t);\r\n\t}\r\n\toverride ngAfterViewInit() {\r\n\t\tsuper.ngAfterViewInit();\r\n\t\tthis.initOperators();\r\n\t\tthis.initSelectors();\r\n\t}\r\n}\r\n\r\n/**\r\n* advanced option picker panel\r\n*/\r\n@Component({\r\n\tselector: 'lu-option-picker-advanced',\r\n\ttemplateUrl: './option-picker-advanced.component.html',\r\n\tstyleUrls: ['./option-picker.component.scss'],\r\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\r\n\tanimations: [luTransformPopover],\r\n\texportAs: 'LuOptionPickerAdvanced',\r\n\tproviders: [\r\n\t\t{\r\n\t\t\tprovide: ALuPickerPanel,\r\n\t\t\tuseExisting: forwardRef(() => LuOptionPickerAdvancedComponent),\r\n\t\t},\r\n\t]\r\n})\r\nexport class LuOptionPickerAdvancedComponent<T = any, O extends import('../item/option-item.model').ILuOptionItem<T> = import('../item/option-item.model').ILuOptionItem<T>> extends ALuOptionPickerAdvancedComponent<T, O> {\r\n\tconstructor(\r\n\t\t_changeDetectorRef: ChangeDetectorRef,\r\n\t\t@Inject(DOCUMENT) document: Document,\r\n\t) {\r\n\t\tsuper(_changeDetectorRef, document);\r\n\t}\r\n}\r\n","<ng-template>\r\n\t<div class=\"lu-picker-panel lu-option-picker-panel\" role=\"dialog\" [ngClass]=\"panelClassesMap\" [class.mod-multiple]=\"multiple\"\r\n\t (click)=\"onClick()\" (mouseover)=\"onMouseOver()\" (mouseleave)=\"onMouseLeave()\" (mousedown)=\"onMouseDown($event)\">\r\n\t\t<div [class.is-loading]=\"loading$ | async\" class=\"lu-picker-content\" [ngClass]=\"contentClassesMap\" [cdkTrapFocus]=\"trapFocus\" luScroll (onScrollBottom)=\"onScrollBottom()\">\r\n\t\t\t<ng-content></ng-content>\r\n\t\t\t<div *ngIf=\"loading$ | async\" class=\"loading lu-picker-loading\"></div>\r\n\t\t</div>\r\n\t</div>\r\n</ng-template>\r\n"]}

package/esm2020/option/lib/picker/option-picker.component.mjs

@@ -0,0 +1,289 @@
+import { DOWN_ARROW, ENTER, UP_ARROW } from '@angular/cdk/keycodes';
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ContentChildren, Directive, EventEmitter, forwardRef, Inject, Input, Output, TemplateRef, ViewChild } from '@angular/core';
+import { ALuPickerPanel } from '@lucca-front/ng/picker';
+import { luTransformPopover } from '@lucca-front/ng/popover';
+import { merge, of } from 'rxjs';
+import { delay, map, share } from 'rxjs/operators';
+import { ALuOptionItem } from '../item/option-item.model';
+import { ALuOptionPicker } from './option-picker.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/cdk/a11y";
+export class ALuOptionPickerComponent extends ALuOptionPicker {
+    constructor(_changeDetectorRef, document) {
+        super();
+        this._changeDetectorRef = _changeDetectorRef;
+        this.document = document;
+        this.close = new EventEmitter();
+        this.open = new EventEmitter();
+        this.hovered = new EventEmitter();
+        this.onSelectValue = new EventEmitter();
+        this._defaultOverlayPaneClasses = ['mod-optionPicker'];
+        this._options = [];
+        this._highlightIndex = -1;
+        this._isOptionItemsInitialized = false;
+        this.overlayPaneClass = this._defaultOverlayPaneClasses;
+    }
+    /**
+     * This method takes classes set on the host lu-popover element and applies them on the
+     * popover template that displays in the overlay container.  Otherwise, it's difficult
+     * to style the containing popover from outside the component.
+     * @param classes list of class names
+     */
+    set inputPanelClasses(classes) {
+        this.panelClasses = classes;
+    }
+    /**
+     * This method takes classes set on the host lu-popover element and applies them on the
+     * popover template that displays in the overlay container. Otherwise, it's difficult
+     * to style the containing popover from outside the component.
+     * @param classes list of class names
+     */
+    set inputContentClasses(classes) {
+        this.contentClasses = classes;
+    }
+    /**
+     * This method take a function that compare options from feeder and options from form value.
+     * By default, compare JSON values.
+     */
+    set inputOptionComparer(comparer) {
+        this.optionComparer = comparer;
+    }
+    set optionsQL(ql) {
+        this._optionsQL = ql;
+    }
+    _emitSelectValue(val) {
+        this.onSelectValue.emit(val);
+    }
+    ngOnDestroy() {
+        super.destroy();
+    }
+    _emitOpenEvent() {
+        this.open.emit();
+    }
+    _emitCloseEvent() {
+        this.close.emit();
+    }
+    _emitHoveredEvent(h) {
+        this.hovered.emit(h);
+    }
+    onOpen() {
+        super.onOpen();
+        this.highlightIndex = 0;
+        // this._initObserver();
+        this._applySelected();
+    }
+    set vcTemplateRef(tr) {
+        this.templateRef = tr;
+    }
+    // keydown
+    _handleKeydown(event) {
+        super._handleKeydown(event);
+        switch (event.keyCode) {
+            case ENTER:
+                this._selectHighlighted();
+                event.preventDefault();
+                event.stopPropagation();
+                break;
+            case UP_ARROW:
+                this._decrHighlight();
+                event.preventDefault();
+                event.stopPropagation();
+                break;
+            case DOWN_ARROW:
+                this._incrHighlight();
+                event.preventDefault();
+                event.stopPropagation();
+                break;
+        }
+    }
+    get highlightIndex() { return this._highlightIndex; }
+    set highlightIndex(i) {
+        this._highlightIndex = i;
+        this._applyHighlight(true);
+    }
+    _initHighlight() {
+        this._subs.add(this._options$.subscribe(options => {
+            const optionCount = options.length;
+            const newHighlight = Math.max(Math.min(this.highlightIndex, optionCount - 1), -1);
+            if (newHighlight !== this.highlightIndex) {
+                this.highlightIndex = newHighlight;
+            }
+        }));
+        setTimeout(() => {
+            this.highlightIndex = -1;
+        }, 1);
+    }
+    _incrHighlight() {
+        const optionCount = this._options.length;
+        this.highlightIndex = Math.max(Math.min(this.highlightIndex + 1, optionCount - 1), -1);
+    }
+    _decrHighlight() {
+        this.highlightIndex = Math.max(this.highlightIndex - 1, -1);
+    }
+    _applyHighlight(reScroll = false) {
+        if (!this.isOpen) {
+            return;
+        }
+        // const highlightClass = 'is-highlighted';
+        const options = this._options;
+        // remove `is-highlighted` class from all other options
+        options.forEach(option => option.highlighted = false);
+        // apply `is-highlighted` to current highlight
+        const highlightedOption = options[this.highlightIndex];
+        if (!!highlightedOption) {
+            highlightedOption.highlighted = true;
+            // scroll to let the highlighted option visible
+            if (reScroll) {
+                setTimeout(() => {
+                    this._scrollToHighlight(highlightedOption.element.nativeElement);
+                }, 1);
+            }
+        }
+        this._changeDetectorRef.markForCheck();
+    }
+    _scrollToHighlight(targetElt) {
+        if (!targetElt) {
+            return;
+        }
+        const contentElt = this.document.querySelector('.lu-picker-content');
+        if (!contentElt) {
+            return;
+        }
+        const headerElt = this.document.querySelector('.lu-picker-content .lu-picker-header');
+        const headerHeight = headerElt ? headerElt.offsetHeight : 0;
+        const footerElt = this.document.querySelector('.lu-picker-content .lu-picker-footer');
+        const footerHeight = footerElt ? footerElt.offsetHeight : 0;
+        // highlighted option is too high
+        if (contentElt.scrollTop + headerHeight > targetElt.offsetTop) {
+            contentElt.scrollTop = targetElt.offsetTop - headerHeight;
+            return;
+        }
+        // highlight option is too low
+        const offsetHeight = contentElt.offsetHeight;
+        if (contentElt.scrollTop + offsetHeight - footerHeight < targetElt.offsetTop + targetElt.offsetHeight) {
+            contentElt.scrollTop = targetElt.offsetTop + targetElt.offsetHeight - offsetHeight + footerHeight;
+            return;
+        }
+    }
+    _selectHighlighted() {
+        const options = this._options ? this._options : [];
+        const highlightedOption = options[this.highlightIndex];
+        if (!!highlightedOption) {
+            this._toggle(highlightedOption);
+        }
+    }
+    _initSelected() {
+        this._subs.add(this._options$.subscribe(() => {
+            this._applySelected();
+        }));
+    }
+    _applySelected() {
+        if (!this._options) {
+            return;
+        }
+        // const selectedClass = 'is-selected';
+        const options = this._options;
+        // remove `is-selected` class from all other options
+        options.forEach(option => option.selected = false);
+        // add `is-selected` to all selected indexes
+        const selectedIndexes = [];
+        if (!this.multiple) {
+            const selectedIndex = this._options.findIndex(o => this.optionComparer(o.value, this._value));
+            if (selectedIndex !== -1) {
+                selectedIndexes.push(selectedIndex);
+            }
+            if (selectedIndex !== -1 && this.highlightIndex === -1) {
+                this.highlightIndex = selectedIndex;
+            }
+        }
+        else {
+            const values = this._value || [];
+            const matchingIndexes = this._options.map(o => values.some(v => this.optionComparer(o.value, v))).map((f, i) => f ? i : null)
+                .filter(i => i !== null);
+            selectedIndexes.push(...matchingIndexes);
+            // selectedIndexes.push(
+            // 	...values
+            // 	.map(v => this._options.findIndex(o => this.optionComparer(o.value, v)))
+            // 	.filter(i => i !== -1)
+            // );
+        }
+        selectedIndexes.forEach(i => {
+            const option = options[i];
+            if (!!option) {
+                option.selected = true;
+            }
+        });
+    }
+    initItems() {
+        const items$ = merge(of(this._optionsQL), this._optionsQL.changes)
+            .pipe(map(q => q.toArray()), delay(0), share());
+        items$.subscribe(o => this._options = o || []);
+        this._options$ = items$;
+        this._initHighlight();
+        this._initSelected();
+    }
+    ngAfterViewInit() {
+        this.initItems();
+    }
+}
+ALuOptionPickerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: ALuOptionPickerComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });
+ALuOptionPickerComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.2", type: ALuOptionPickerComponent, inputs: { inputPanelClasses: ["panel-classes", "inputPanelClasses"], inputContentClasses: ["content-classes", "inputContentClasses"], inputOptionComparer: ["option-comparer", "inputOptionComparer"] }, outputs: { close: "close", open: "open", hovered: "hovered", onSelectValue: "onSelectValue" }, queries: [{ propertyName: "optionsQL", predicate: ALuOptionItem, descendants: true }], viewQueries: [{ propertyName: "vcTemplateRef", first: true, predicate: TemplateRef, descendants: true, static: true }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: ALuOptionPickerComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { inputPanelClasses: [{
+                type: Input,
+                args: ['panel-classes']
+            }], inputContentClasses: [{
+                type: Input,
+                args: ['content-classes']
+            }], inputOptionComparer: [{
+                type: Input,
+                args: ['option-comparer']
+            }], close: [{
+                type: Output
+            }], open: [{
+                type: Output
+            }], hovered: [{
+                type: Output
+            }], onSelectValue: [{
+                type: Output
+            }], optionsQL: [{
+                type: ContentChildren,
+                args: [ALuOptionItem, { descendants: true }]
+            }], vcTemplateRef: [{
+                type: ViewChild,
+                args: [TemplateRef, { static: true }]
+            }] } });
+/**
+* basic option picker panel
+*/
+export class LuOptionPickerComponent extends ALuOptionPickerComponent {
+    constructor(_changeDetectorRef, document) {
+        super(_changeDetectorRef, document);
+    }
+}
+LuOptionPickerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuOptionPickerComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
+LuOptionPickerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: LuOptionPickerComponent, selector: "lu-option-picker", providers: [
+        {
+            provide: ALuPickerPanel,
+            useExisting: forwardRef(() => LuOptionPickerComponent),
+        },
+    ], exportAs: ["LuOptionPicker"], usesInheritance: true, ngImport: i0, template: "<ng-template>\r\n\t<div class=\"lu-picker-panel lu-option-picker-panel\" role=\"dialog\" [ngClass]=\"panelClassesMap\" [class.mod-multiple]=\"multiple\"\r\n\t(click)=\"onClick()\" (mouseover)=\"onMouseOver()\" (mouseleave)=\"onMouseLeave()\" (mousedown)=\"onMouseDown($event)\">\r\n\t\t<div class=\"lu-picker-content\" [ngClass]=\"contentClassesMap\" [cdkTrapFocus]=\"trapFocus\">\r\n\t\t\t<ng-content></ng-content>\r\n\t\t</div>\r\n\t</div>\r\n</ng-template>\r\n", styles: [""], directives: [{ type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i2.CdkTrapFocus, selector: "[cdkTrapFocus]", inputs: ["cdkTrapFocus", "cdkTrapFocusAutoCapture"], exportAs: ["cdkTrapFocus"] }], animations: [luTransformPopover], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: LuOptionPickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lu-option-picker', changeDetection: ChangeDetectionStrategy.OnPush, animations: [luTransformPopover], exportAs: 'LuOptionPicker', providers: [
+                        {
+                            provide: ALuPickerPanel,
+                            useExisting: forwardRef(() => LuOptionPickerComponent),
+                        },
+                    ], template: "<ng-template>\r\n\t<div class=\"lu-picker-panel lu-option-picker-panel\" role=\"dialog\" [ngClass]=\"panelClassesMap\" [class.mod-multiple]=\"multiple\"\r\n\t(click)=\"onClick()\" (mouseover)=\"onMouseOver()\" (mouseleave)=\"onMouseLeave()\" (mousedown)=\"onMouseDown($event)\">\r\n\t\t<div class=\"lu-picker-content\" [ngClass]=\"contentClassesMap\" [cdkTrapFocus]=\"trapFocus\">\r\n\t\t\t<ng-content></ng-content>\r\n\t\t</div>\r\n\t</div>\r\n</ng-template>\r\n", styles: [""] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"option-picker.component.js","sourceRoot":"","sources":["../../../../../../packages/ng/option/src/lib/picker/option-picker.component.ts","../../../../../../packages/ng/option/src/lib/picker/option-picker.component.html"],"names":[],"mappings":"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","sourcesContent":["import { DOWN_ARROW, ENTER, UP_ARROW } from '@angular/cdk/keycodes';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport {\r\n\tAfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component,\r\n\tContentChildren, Directive, EventEmitter, forwardRef, Inject, Input, OnDestroy, Output, QueryList, TemplateRef, ViewChild\r\n} from '@angular/core';\r\nimport { ALuPickerPanel } from '@lucca-front/ng/picker';\r\nimport { luTransformPopover } from '@lucca-front/ng/popover';\r\nimport { merge, of } from 'rxjs';\r\nimport { delay, map, share } from 'rxjs/operators';\r\nimport { ALuOptionItem } from '../item/option-item.model';\r\nimport { ALuOptionPicker, ILuOptionPickerPanel, LuOptionComparer } from './option-picker.model';\r\n\r\n@Directive()\r\nexport abstract class ALuOptionPickerComponent<T, O extends import('../item/option-item.model').ILuOptionItem<T> = import('../item/option-item.model').ILuOptionItem<T>>\r\n\textends ALuOptionPicker<T, O>\r\n\timplements ILuOptionPickerPanel<T>, OnDestroy, AfterViewInit {\r\n\t/**\r\n\t * This method takes classes set on the host lu-popover element and applies them on the\r\n\t * popover template that displays in the overlay container.  Otherwise, it's difficult\r\n\t * to style the containing popover from outside the component.\r\n\t * @param classes list of class names\r\n\t */\r\n\t@Input('panel-classes')\r\n\tset inputPanelClasses(classes: string) {\r\n\t\tthis.panelClasses = classes;\r\n\t}\r\n\t/**\r\n\t * This method takes classes set on the host lu-popover element and applies them on the\r\n\t * popover template that displays in the overlay container. Otherwise, it's difficult\r\n\t * to style the containing popover from outside the component.\r\n\t * @param classes list of class names\r\n\t */\r\n\t@Input('content-classes')\r\n\tset inputContentClasses(classes: string) {\r\n\t\tthis.contentClasses = classes;\r\n\t}\r\n\r\n\t/**\r\n\t * This method take a function that compare options from feeder and options from form value.\r\n\t * By default, compare JSON values.\r\n\t */\r\n\t@Input('option-comparer')\r\n\tset inputOptionComparer(comparer: LuOptionComparer<T>) {\r\n\t\tthis.optionComparer = comparer;\r\n\t}\r\n\r\n\r\n\t@Output() override close = new EventEmitter<void>();\r\n\t@Output() override open = new EventEmitter<void>();\r\n\t@Output() override hovered = new EventEmitter<boolean>();\r\n\t@Output() override onSelectValue = new EventEmitter<T>();\r\n\r\n\tprotected _isOptionItemsInitialized: boolean;\r\n\tprotected _defaultOverlayPaneClasses = ['mod-optionPicker'];\r\n\r\n\tprotected _options: O[] = [];\r\n\tprotected _optionsQL: QueryList<O>;\r\n\t@ContentChildren(ALuOptionItem, { descendants: true }) set optionsQL(ql: QueryList<O>) {\r\n\t\tthis._optionsQL = ql;\r\n\t}\r\n\r\n\tconstructor(\r\n\t\tprotected _changeDetectorRef: ChangeDetectorRef,\r\n\t\t@Inject(DOCUMENT) protected document: Document,\r\n\t) {\r\n\t\tsuper();\r\n\t\tthis._isOptionItemsInitialized = false;\r\n\t\tthis.overlayPaneClass = this._defaultOverlayPaneClasses;\r\n\t}\r\n\r\n\tprotected _emitSelectValue(val: T) {\r\n\t\tthis.onSelectValue.emit(val);\r\n\t}\r\n\tngOnDestroy() {\r\n\t\tsuper.destroy();\r\n\t}\r\n\t_emitOpenEvent(): void {\r\n\t\tthis.open.emit();\r\n\t}\r\n\t_emitCloseEvent(): void {\r\n\t\tthis.close.emit();\r\n\t}\r\n\t_emitHoveredEvent(h): void {\r\n\t\tthis.hovered.emit(h);\r\n\t}\r\n\toverride onOpen() {\r\n\t\tsuper.onOpen();\r\n\t\tthis.highlightIndex = 0;\r\n\t\t// this._initObserver();\r\n\t\tthis._applySelected();\r\n\t}\r\n\t@ViewChild(TemplateRef, { static: true })\r\n\tset vcTemplateRef(tr: TemplateRef<any>) {\r\n\t\tthis.templateRef = tr;\r\n\t}\r\n\r\n\t// keydown\r\n\toverride _handleKeydown(event: KeyboardEvent) {\r\n\t\tsuper._handleKeydown(event);\r\n\t\tswitch (event.keyCode) {\r\n\t\t\tcase ENTER:\r\n\t\t\t\tthis._selectHighlighted();\r\n\t\t\t\tevent.preventDefault();\r\n\t\t\t\tevent.stopPropagation();\r\n\t\t\t\tbreak;\r\n\t\t\tcase UP_ARROW:\r\n\t\t\t\tthis._decrHighlight();\r\n\t\t\t\tevent.preventDefault();\r\n\t\t\t\tevent.stopPropagation();\r\n\t\t\t\tbreak;\r\n\t\t\tcase DOWN_ARROW:\r\n\t\t\t\tthis._incrHighlight();\r\n\t\t\t\tevent.preventDefault();\r\n\t\t\t\tevent.stopPropagation();\r\n\t\t\t\tbreak;\r\n\t\t}\r\n\t}\r\n\tprotected _highlightIndex = -1;\r\n\tget highlightIndex() { return this._highlightIndex; }\r\n\tset highlightIndex(i: number) {\r\n\t\tthis._highlightIndex = i;\r\n\t\tthis._applyHighlight(true);\r\n\t}\r\n\tprotected _initHighlight() {\r\n\t\tthis._subs.add(this._options$.subscribe(options => {\r\n\t\t\tconst optionCount = options.length;\r\n\t\t\tconst newHighlight = Math.max(Math.min(this.highlightIndex, optionCount - 1), -1);\r\n\t\t\tif (newHighlight !== this.highlightIndex) {\r\n\t\t\t\tthis.highlightIndex = newHighlight;\r\n\t\t\t}\r\n\t\t}));\r\n\t\tsetTimeout(() => {\r\n\t\t\tthis.highlightIndex = -1;\r\n\t\t}, 1);\r\n\t}\r\n\tprotected _incrHighlight() {\r\n\t\tconst optionCount = this._options.length;\r\n\t\tthis.highlightIndex = Math.max(Math.min(this.highlightIndex + 1, optionCount - 1), -1);\r\n\t}\r\n\tprotected _decrHighlight() {\r\n\t\tthis.highlightIndex = Math.max(this.highlightIndex - 1, -1);\r\n\t}\r\n\tprotected _applyHighlight(reScroll = false) {\r\n\t\tif (!this.isOpen) { return; }\r\n\t\t// const highlightClass = 'is-highlighted';\r\n\t\tconst options = this._options;\r\n\t\t// remove `is-highlighted` class from all other options\r\n\t\toptions.forEach(option => option.highlighted = false);\r\n\t\t// apply `is-highlighted` to current highlight\r\n\t\tconst highlightedOption = options[this.highlightIndex];\r\n\t\tif (!!highlightedOption) {\r\n\t\t\thighlightedOption.highlighted = true;\r\n\t\t\t// scroll to let the highlighted option visible\r\n\t\t\tif (reScroll) {\r\n\t\t\t\tsetTimeout(() => {\r\n\t\t\t\t\tthis._scrollToHighlight(highlightedOption.element.nativeElement);\r\n\t\t\t\t}, 1);\r\n\t\t\t}\r\n\t\t}\r\n\t\tthis._changeDetectorRef.markForCheck();\r\n\t}\r\n\tprotected _scrollToHighlight(targetElt: HTMLElement) {\r\n\t\tif (!targetElt) { return; }\r\n\t\tconst contentElt = this.document.querySelector<HTMLElement>('.lu-picker-content');\r\n\t\tif (!contentElt) { return; }\r\n\t\tconst headerElt = this.document.querySelector<HTMLElement>('.lu-picker-content .lu-picker-header');\r\n\t\tconst headerHeight = headerElt ? headerElt.offsetHeight : 0;\r\n\t\tconst footerElt = this.document.querySelector<HTMLElement>('.lu-picker-content .lu-picker-footer');\r\n\t\tconst footerHeight = footerElt ? footerElt.offsetHeight : 0;\r\n\t\t// highlighted option is too high\r\n\t\tif (contentElt.scrollTop + headerHeight > targetElt.offsetTop) {\r\n\t\t\tcontentElt.scrollTop = targetElt.offsetTop - headerHeight;\r\n\t\t\treturn;\r\n\t\t}\r\n\t\t// highlight option is too low\r\n\t\tconst offsetHeight = contentElt.offsetHeight;\r\n\t\tif (contentElt.scrollTop + offsetHeight - footerHeight < targetElt.offsetTop + targetElt.offsetHeight) {\r\n\t\t\tcontentElt.scrollTop = targetElt.offsetTop + targetElt.offsetHeight - offsetHeight + footerHeight;\r\n\t\t\treturn;\r\n\t\t}\r\n\t}\r\n\tprotected _selectHighlighted() {\r\n\t\tconst options = this._options ? this._options : [];\r\n\t\tconst highlightedOption = options[this.highlightIndex];\r\n\t\tif (!!highlightedOption) {\r\n\t\t\tthis._toggle(highlightedOption);\r\n\t\t}\r\n\t}\r\n\tprotected _initSelected() {\r\n\t\tthis._subs.add(this._options$.subscribe(() => {\r\n\t\t\tthis._applySelected();\r\n\t\t}));\r\n\t}\r\n\tprotected _applySelected() {\r\n\t\tif (!this._options) { return; }\r\n\t\t// const selectedClass = 'is-selected';\r\n\r\n\t\tconst options = this._options;\r\n\t\t// remove `is-selected` class from all other options\r\n\t\toptions.forEach(option => option.selected = false);\r\n\r\n\t\t// add `is-selected` to all selected indexes\r\n\t\tconst selectedIndexes: number[] = [];\r\n\t\tif (!this.multiple) {\r\n\t\t\tconst selectedIndex = this._options.findIndex(o => this.optionComparer(o.value, this._value as T));\r\n\t\t\tif (selectedIndex !== -1) { selectedIndexes.push(selectedIndex); }\r\n\t\t\tif (selectedIndex !== -1 && this.highlightIndex === -1) { this.highlightIndex = selectedIndex; }\r\n\t\t} else {\r\n\t\t\tconst values = <T[]>this._value || [];\r\n\t\t\tconst matchingIndexes = this._options.map(\r\n\t\t\t\to => values.some(v => this.optionComparer(o.value, v)),\r\n\t\t\t).map((f, i) => f ? i : null)\r\n\t\t\t\t.filter(i => i !== null);\r\n\t\t\tselectedIndexes.push(...matchingIndexes);\r\n\t\t\t// selectedIndexes.push(\r\n\t\t\t// \t...values\r\n\t\t\t// \t.map(v => this._options.findIndex(o => this.optionComparer(o.value, v)))\r\n\t\t\t// \t.filter(i => i !== -1)\r\n\t\t\t// );\r\n\t\t}\r\n\t\tselectedIndexes.forEach(i => {\r\n\t\t\tconst option = options[i];\r\n\t\t\tif (!!option) {\r\n\t\t\t\toption.selected = true;\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tprotected initItems() {\r\n\r\n\t\tconst items$ = merge(of(this._optionsQL), this._optionsQL.changes)\r\n\t\t\t.pipe(\r\n\t\t\t\tmap<QueryList<O>, O[]>(q => q.toArray()),\r\n\t\t\t\tdelay(0),\r\n\t\t\t\tshare(),\r\n\t\t\t);\r\n\t\titems$.subscribe(o => this._options = o || []);\r\n\t\tthis._options$ = items$;\r\n\t\tthis._initHighlight();\r\n\t\tthis._initSelected();\r\n\t}\r\n\tngAfterViewInit() {\r\n\t\tthis.initItems();\r\n\t}\r\n}\r\n/**\r\n* basic option picker panel\r\n*/\r\n@Component({\r\n\tselector: 'lu-option-picker',\r\n\ttemplateUrl: './option-picker.component.html',\r\n\tstyleUrls: ['./option-picker.component.scss'],\r\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\r\n\tanimations: [luTransformPopover],\r\n\texportAs: 'LuOptionPicker',\r\n\tproviders: [\r\n\t\t{\r\n\t\t\tprovide: ALuPickerPanel,\r\n\t\t\tuseExisting: forwardRef(() => LuOptionPickerComponent),\r\n\t\t},\r\n\t]\r\n})\r\nexport class LuOptionPickerComponent<T, O extends import('../item/option-item.model').ILuOptionItem<T> = import('../item/option-item.model').ILuOptionItem<T>> extends ALuOptionPickerComponent<T, O> {\r\n\tconstructor(\r\n\t\t_changeDetectorRef: ChangeDetectorRef,\r\n\t\t@Inject(DOCUMENT) document: Document,\r\n\t) {\r\n\t\tsuper(_changeDetectorRef, document);\r\n\t}\r\n}\r\n","<ng-template>\r\n\t<div class=\"lu-picker-panel lu-option-picker-panel\" role=\"dialog\" [ngClass]=\"panelClassesMap\" [class.mod-multiple]=\"multiple\"\r\n\t(click)=\"onClick()\" (mouseover)=\"onMouseOver()\" (mouseleave)=\"onMouseLeave()\" (mousedown)=\"onMouseDown($event)\">\r\n\t\t<div class=\"lu-picker-content\" [ngClass]=\"contentClassesMap\" [cdkTrapFocus]=\"trapFocus\">\r\n\t\t\t<ng-content></ng-content>\r\n\t\t</div>\r\n\t</div>\r\n</ng-template>\r\n"]}