@lucca-front/ng 15.3.0 → 16.0.0

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

@@ -0,0 +1,316 @@
+/* eslint-disable @angular-eslint/no-output-native */
+import { A11yModule } from '@angular/cdk/a11y';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { CommonModule, 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 { LuOptionItemComponent } from '../item';
+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";
+class ALuOptionPickerComponent extends ALuOptionPicker {
+    /**
+     * 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;
+    }
+    constructor(_changeDetectorRef, document) {
+        super();
+        this._changeDetectorRef = _changeDetectorRef;
+        this.document = document;
+        this.close = new EventEmitter();
+        this.open = new EventEmitter();
+        this.hovered = new EventEmitter();
+        // eslint-disable-next-line @angular-eslint/no-output-on-prefix
+        this.onSelectValue = new EventEmitter();
+        this._defaultOverlayPaneClasses = ['mod-optionPicker'];
+        this._options = [];
+        this._highlightIndex = -1;
+        this._isOptionItemsInitialized = false;
+        this.overlayPaneClass = this._defaultOverlayPaneClasses;
+    }
+    _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 = -1;
+        this._incrHighlight();
+        this._applySelected();
+    }
+    set vcTemplateRef(tr) {
+        this.templateRef = tr;
+    }
+    // keydown
+    _handleKeydown(event) {
+        super._handleKeydown(event);
+        switch (event.key) {
+            case 'Enter':
+                this._selectHighlighted();
+                event.preventDefault();
+                event.stopPropagation();
+                break;
+            case 'ArrowUp':
+                this._decrHighlight();
+                event.preventDefault();
+                event.stopPropagation();
+                break;
+            case 'ArrowDown':
+                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 nextIndex = this._options.findIndex((item, index) => index > this.highlightIndex && !item.disabled);
+        this.highlightIndex = nextIndex > -1 ? nextIndex : this._options.findIndex((item) => !item.disabled);
+    }
+    _decrHighlight() {
+        //NB: findLastIndex would be better but is not available on this project
+        let nextIndex = -1;
+        for (let i = this.highlightIndex - 1; i >= 0; --i) {
+            if (!this._options[i].disabled) {
+                nextIndex = i;
+                break;
+            }
+        }
+        if (nextIndex > -1) {
+            this.highlightIndex = nextIndex;
+            return;
+        }
+        const optionsLength = this._options.length - 1;
+        for (let i = optionsLength; i >= 0; --i) {
+            if (!this._options[i].disabled) {
+                nextIndex = i;
+                break;
+            }
+        }
+        this.highlightIndex = nextIndex;
+    }
+    _applyHighlight(reScroll = false) {
+        if (!this.isOpen) {
+            return;
+        }
+        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();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ALuOptionPickerComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", 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 }); }
+}
+export { ALuOptionPickerComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", 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
+ */
+class LuOptionPickerComponent extends ALuOptionPickerComponent {
+    constructor(_changeDetectorRef, document) {
+        super(_changeDetectorRef, document);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LuOptionPickerComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: LuOptionPickerComponent, isStandalone: true, selector: "lu-option-picker", providers: [
+            {
+                provide: ALuPickerPanel,
+                useExisting: forwardRef(() => LuOptionPickerComponent),
+            },
+        ], exportAs: ["LuOptionPicker"], usesInheritance: true, ngImport: i0, template: "<ng-template>\r\n\t<div\r\n\t\tclass=\"lu-picker-panel lu-option-picker-panel\"\r\n\t\trole=\"dialog\"\r\n\t\t[ngClass]=\"panelClassesMap\"\r\n\t\t[class.mod-multiple]=\"multiple\"\r\n\t\t(click)=\"onClick()\"\r\n\t\t(mouseover)=\"onMouseOver()\"\r\n\t\t(mouseleave)=\"onMouseLeave()\"\r\n\t\t(mousedown)=\"onMouseDown()\"\r\n\t>\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", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "ngmodule", type: OverlayModule }, { kind: "ngmodule", type: A11yModule }, { kind: "directive", type: i2.CdkTrapFocus, selector: "[cdkTrapFocus]", inputs: ["cdkTrapFocus", "cdkTrapFocusAutoCapture"], exportAs: ["cdkTrapFocus"] }], animations: [luTransformPopover], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+export { LuOptionPickerComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LuOptionPickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lu-option-picker', changeDetection: ChangeDetectionStrategy.OnPush, animations: [luTransformPopover], exportAs: 'LuOptionPicker', standalone: true, imports: [CommonModule, OverlayModule, LuOptionItemComponent, A11yModule], providers: [
+                        {
+                            provide: ALuPickerPanel,
+                            useExisting: forwardRef(() => LuOptionPickerComponent),
+                        },
+                    ], template: "<ng-template>\r\n\t<div\r\n\t\tclass=\"lu-picker-panel lu-option-picker-panel\"\r\n\t\trole=\"dialog\"\r\n\t\t[ngClass]=\"panelClassesMap\"\r\n\t\t[class.mod-multiple]=\"multiple\"\r\n\t\t(click)=\"onClick()\"\r\n\t\t(mouseover)=\"onMouseOver()\"\r\n\t\t(mouseleave)=\"onMouseLeave()\"\r\n\t\t(mousedown)=\"onMouseDown()\"\r\n\t>\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" }]
+        }], 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":["/* eslint-disable @angular-eslint/no-output-native */\r\nimport { A11yModule } from '@angular/cdk/a11y';\r\nimport { OverlayModule } from '@angular/cdk/overlay';\r\nimport { CommonModule, DOCUMENT } from '@angular/common';\r\nimport {\r\n\tAfterViewInit,\r\n\tChangeDetectionStrategy,\r\n\tChangeDetectorRef,\r\n\tComponent,\r\n\tContentChildren,\r\n\tDirective,\r\n\tEventEmitter,\r\n\tforwardRef,\r\n\tInject,\r\n\tInput,\r\n\tOnDestroy,\r\n\tOutput,\r\n\tQueryList,\r\n\tTemplateRef,\r\n\tViewChild,\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 { LuOptionItemComponent } from '../item';\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{\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\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// eslint-disable-next-line @angular-eslint/no-output-on-prefix\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(protected _changeDetectorRef: ChangeDetectorRef, @Inject(DOCUMENT) protected document: Document) {\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: boolean): 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 = -1;\r\n\t\tthis._incrHighlight();\r\n\t\tthis._applySelected();\r\n\t}\r\n\t@ViewChild(TemplateRef, { static: true })\r\n\tset vcTemplateRef(tr: TemplateRef<HTMLElement>) {\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.key) {\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 'ArrowUp':\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 'ArrowDown':\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() {\r\n\t\treturn this._highlightIndex;\r\n\t}\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(\r\n\t\t\tthis._options$.subscribe((options) => {\r\n\t\t\t\tconst optionCount = options.length;\r\n\t\t\t\tconst newHighlight = Math.max(Math.min(this.highlightIndex, optionCount - 1), -1);\r\n\t\t\t\tif (newHighlight !== this.highlightIndex) {\r\n\t\t\t\t\tthis.highlightIndex = newHighlight;\r\n\t\t\t\t}\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 nextIndex = this._options.findIndex((item, index) => index > this.highlightIndex && !item.disabled);\r\n\t\tthis.highlightIndex = nextIndex > -1 ? nextIndex : this._options.findIndex((item) => !item.disabled);\r\n\t}\r\n\tprotected _decrHighlight() {\r\n\t\t//NB: findLastIndex would be better but is not available on this project\r\n\t\tlet nextIndex = -1;\r\n\t\tfor (let i = this.highlightIndex - 1; i >= 0; --i) {\r\n\t\t\tif (!this._options[i].disabled) {\r\n\t\t\t\tnextIndex = i;\r\n\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (nextIndex > -1) {\r\n\t\t\tthis.highlightIndex = nextIndex;\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tconst optionsLength = this._options.length - 1;\r\n\t\tfor (let i = optionsLength; i >= 0; --i) {\r\n\t\t\tif (!this._options[i].disabled) {\r\n\t\t\t\tnextIndex = i;\r\n\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t}\r\n\t\tthis.highlightIndex = nextIndex;\r\n\t}\r\n\tprotected _applyHighlight(reScroll = false) {\r\n\t\tif (!this.isOpen) {\r\n\t\t\treturn;\r\n\t\t}\r\n\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\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) {\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tconst contentElt = this.document.querySelector<HTMLElement>('.lu-picker-content');\r\n\t\tif (!contentElt) {\r\n\t\t\treturn;\r\n\t\t}\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(\r\n\t\t\tthis._options$.subscribe(() => {\r\n\t\t\t\tthis._applySelected();\r\n\t\t\t}),\r\n\t\t);\r\n\t}\r\n\tprotected _applySelected() {\r\n\t\tif (!this._options) {\r\n\t\t\treturn;\r\n\t\t}\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) {\r\n\t\t\t\tselectedIndexes.push(selectedIndex);\r\n\t\t\t}\r\n\t\t\tif (selectedIndex !== -1 && this.highlightIndex === -1) {\r\n\t\t\t\tthis.highlightIndex = selectedIndex;\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tconst values = <T[]>this._value || [];\r\n\t\t\tconst matchingIndexes = this._options\r\n\t\t\t\t.map((o) => values.some((v) => this.optionComparer(o.value, v)))\r\n\t\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\t\tconst items$ = merge(of(this._optionsQL), this._optionsQL.changes).pipe(\r\n\t\t\tmap<QueryList<O>, O[]>((q) => q.toArray()),\r\n\t\t\tdelay(0),\r\n\t\t\tshare(),\r\n\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\tchangeDetection: ChangeDetectionStrategy.OnPush,\r\n\tanimations: [luTransformPopover],\r\n\texportAs: 'LuOptionPicker',\r\n\tstandalone: true,\r\n\timports: [CommonModule, OverlayModule, LuOptionItemComponent, A11yModule],\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(_changeDetectorRef: ChangeDetectorRef, @Inject(DOCUMENT) document: Document) {\r\n\t\tsuper(_changeDetectorRef, document);\r\n\t}\r\n}\r\n","<ng-template>\r\n\t<div\r\n\t\tclass=\"lu-picker-panel lu-option-picker-panel\"\r\n\t\trole=\"dialog\"\r\n\t\t[ngClass]=\"panelClassesMap\"\r\n\t\t[class.mod-multiple]=\"multiple\"\r\n\t\t(click)=\"onClick()\"\r\n\t\t(mouseover)=\"onMouseOver()\"\r\n\t\t(mouseleave)=\"onMouseLeave()\"\r\n\t\t(mousedown)=\"onMouseDown()\"\r\n\t>\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"]}

package/esm2022/option/lib/picker/option-picker.model.mjs

@@ -0,0 +1,69 @@
+import { ALuPickerPanel } from '@lucca-front/ng/picker';
+import { merge, Subscription } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+export class ALuOptionPicker extends ALuPickerPanel {
+    constructor() {
+        super(...arguments);
+        this._subs = new Subscription();
+        this.optionComparer = (option1, option2) => JSON.stringify(option1) === JSON.stringify(option2);
+    }
+    setValue(value) {
+        this._value = value;
+        this._applySelected();
+    }
+    get _options$() {
+        return this.__options$;
+    }
+    set _options$(options$) {
+        this.__options$ = options$;
+        // reapply selected when the options change
+        this._subs.add(options$.subscribe(() => {
+            this._applySelected();
+            this._applyHighlight();
+        }));
+        // subscribe to any option.onSelect
+        const singleFlow$ = options$.pipe(switchMap((items) => merge(...items.map((i) => i.onSelect))));
+        this._subs.add(singleFlow$.subscribe((option) => this._toggle(option)));
+    }
+    _toggle(option) {
+        const value = option.value;
+        if (!this.multiple) {
+            this._select(value);
+        }
+        else {
+            const values = this._value || [];
+            let newValues;
+            if (values.some((v) => this.optionComparer(v, value))) {
+                // value was present, we remove it
+                newValues = values.filter((v) => !this.optionComparer(v, value));
+            }
+            else {
+                // value was absent, we add it
+                newValues = [...values, value];
+            }
+            this._select(newValues);
+        }
+    }
+    _select(val) {
+        this._emitSelectValue(val);
+        if (!this.multiple) {
+            this._emitCloseEvent();
+        }
+    }
+    destroy() {
+        this._subs.unsubscribe();
+    }
+    _handleKeydown(event) {
+        switch (event.key) {
+            case 'Escape':
+                this._emitCloseEvent();
+                event.preventDefault();
+                event.stopPropagation();
+                break;
+            case 'Tab':
+                this._emitCloseEvent();
+                break;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/option/lib/picker/option-picker.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { LuOptionItemComponent } from '../item/index';
+import { LuOptionPickerAdvancedComponent } from './option-picker-advanced.component';
+import { LuOptionPickerComponent } from './option-picker.component';
+import * as i0 from "@angular/core";
+class LuOptionPickerModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LuOptionPickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: LuOptionPickerModule, imports: [LuOptionPickerComponent, LuOptionPickerAdvancedComponent, LuOptionItemComponent], exports: [LuOptionPickerComponent, LuOptionPickerAdvancedComponent, LuOptionItemComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LuOptionPickerModule, imports: [LuOptionPickerComponent, LuOptionPickerAdvancedComponent, LuOptionItemComponent] }); }
+}
+export { LuOptionPickerModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LuOptionPickerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [LuOptionPickerComponent, LuOptionPickerAdvancedComponent, LuOptionItemComponent],
+                    exports: [LuOptionPickerComponent, LuOptionPickerAdvancedComponent, LuOptionItemComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uLXBpY2tlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy9vcHRpb24vc3JjL2xpYi9waWNrZXIvb3B0aW9uLXBpY2tlci5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDdEQsT0FBTyxFQUFFLCtCQUErQixFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFDckYsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7O0FBRXBFLE1BSWEsb0JBQW9COzhHQUFwQixvQkFBb0I7K0dBQXBCLG9CQUFvQixZQUh0Qix1QkFBdUIsRUFBRSwrQkFBK0IsRUFBRSxxQkFBcUIsYUFDL0UsdUJBQXVCLEVBQUUsK0JBQStCLEVBQUUscUJBQXFCOytHQUU3RSxvQkFBb0IsWUFIdEIsdUJBQXVCLEVBQUUsK0JBQStCLEVBQUUscUJBQXFCOztTQUc3RSxvQkFBb0I7MkZBQXBCLG9CQUFvQjtrQkFKaEMsUUFBUTttQkFBQztvQkFDVCxPQUFPLEVBQUUsQ0FBQyx1QkFBdUIsRUFBRSwrQkFBK0IsRUFBRSxxQkFBcUIsQ0FBQztvQkFDMUYsT0FBTyxFQUFFLENBQUMsdUJBQXVCLEVBQUUsK0JBQStCLEVBQUUscUJBQXFCLENBQUM7aUJBQzFGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgTHVPcHRpb25JdGVtQ29tcG9uZW50IH0gZnJvbSAnLi4vaXRlbS9pbmRleCc7XHJcbmltcG9ydCB7IEx1T3B0aW9uUGlja2VyQWR2YW5jZWRDb21wb25lbnQgfSBmcm9tICcuL29wdGlvbi1waWNrZXItYWR2YW5jZWQuY29tcG9uZW50JztcclxuaW1wb3J0IHsgTHVPcHRpb25QaWNrZXJDb21wb25lbnQgfSBmcm9tICcuL29wdGlvbi1waWNrZXIuY29tcG9uZW50JztcclxuXHJcbkBOZ01vZHVsZSh7XHJcblx0aW1wb3J0czogW0x1T3B0aW9uUGlja2VyQ29tcG9uZW50LCBMdU9wdGlvblBpY2tlckFkdmFuY2VkQ29tcG9uZW50LCBMdU9wdGlvbkl0ZW1Db21wb25lbnRdLFxyXG5cdGV4cG9ydHM6IFtMdU9wdGlvblBpY2tlckNvbXBvbmVudCwgTHVPcHRpb25QaWNrZXJBZHZhbmNlZENvbXBvbmVudCwgTHVPcHRpb25JdGVtQ29tcG9uZW50XSxcclxufSlcclxuZXhwb3J0IGNsYXNzIEx1T3B0aW9uUGlja2VyTW9kdWxlIHt9XHJcbiJdfQ==