@lucca-front/ng 16.3.1-rc.2 → 16.4.0-rc.1

package/esm2022/{simple-select/option → core-select/displayer}/displayer.directive.mjs

@@ -24,4 +24,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImpor
                 type: Input,
                 args: ['luDisplayerSelect']
             }] } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzcGxheWVyLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL25nL3NpbXBsZS1zZWxlY3Qvb3B0aW9uL2Rpc3BsYXllci5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQWUsTUFBTSxlQUFlLENBQUM7O0FBSTlELE1BSWEsb0JBQW9CO0lBQ2hDLElBQWdDLE1BQU0sQ0FBQyxNQUF1QztRQUM3RSxNQUFNLENBQUMsUUFBUSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUM7SUFDcEMsQ0FBQztJQUVELFlBQTJCLFdBQTRDO1FBQTVDLGdCQUFXLEdBQVgsV0FBVyxDQUFpQztJQUFHLENBQUM7SUFFcEUsTUFBTSxDQUFDLHNCQUFzQixDQUFJLElBQTZCLEVBQUUsR0FBWTtRQUNsRixPQUFPLElBQUksQ0FBQztJQUNiLENBQUM7OEdBVFcsb0JBQW9CO2tHQUFwQixvQkFBb0I7O1NBQXBCLG9CQUFvQjsyRkFBcEIsb0JBQW9CO2tCQUpoQyxTQUFTO21CQUFDO29CQUNWLFFBQVEsRUFBRSxlQUFlO29CQUN6QixVQUFVLEVBQUUsSUFBSTtpQkFDaEI7a0dBRWdDLE1BQU07c0JBQXJDLEtBQUs7dUJBQUMsbUJBQW1CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBJbnB1dCwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgTHVTaW1wbGVTZWxlY3RJbnB1dENvbXBvbmVudCB9IGZyb20gJy4uL2lucHV0JztcclxuaW1wb3J0IHsgTHVPcHRpb25Db250ZXh0IH0gZnJvbSAnLi4vc2VsZWN0Lm1vZGVsJztcclxuXHJcbkBEaXJlY3RpdmUoe1xyXG5cdHNlbGVjdG9yOiAnW2x1RGlzcGxheWVyXScsXHJcblx0c3RhbmRhbG9uZTogdHJ1ZSxcclxufSlcclxuZXhwb3J0IGNsYXNzIEx1RGlzcGxheWVyRGlyZWN0aXZlPFQ+IHtcclxuXHRASW5wdXQoJ2x1RGlzcGxheWVyU2VsZWN0Jykgc2V0IHNlbGVjdChzZWxlY3Q6IEx1U2ltcGxlU2VsZWN0SW5wdXRDb21wb25lbnQ8VD4pIHtcclxuXHRcdHNlbGVjdC52YWx1ZVRwbCA9IHRoaXMudGVtcGxhdGVSZWY7XHJcblx0fVxyXG5cclxuXHRwdWJsaWMgY29uc3RydWN0b3IocHJpdmF0ZSB0ZW1wbGF0ZVJlZjogVGVtcGxhdGVSZWY8THVPcHRpb25Db250ZXh0PFQ+Pikge31cclxuXHJcblx0cHVibGljIHN0YXRpYyBuZ1RlbXBsYXRlQ29udGV4dEd1YXJkPFQ+KF9kaXI6IEx1RGlzcGxheWVyRGlyZWN0aXZlPFQ+LCBjdHg6IHVua25vd24pOiBjdHggaXMgTHVPcHRpb25Db250ZXh0PFQ+IHtcclxuXHRcdHJldHVybiB0cnVlO1xyXG5cdH1cclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzcGxheWVyLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL25nL2NvcmUtc2VsZWN0L2Rpc3BsYXllci9kaXNwbGF5ZXIuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFlLE1BQU0sZUFBZSxDQUFDOztBQUk5RCxNQUlhLG9CQUFvQjtJQUNoQyxJQUFnQyxNQUFNLENBQUMsTUFBMkM7UUFDakYsTUFBTSxDQUFDLFFBQVEsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDO0lBQ3BDLENBQUM7SUFFRCxZQUEyQixXQUE0QztRQUE1QyxnQkFBVyxHQUFYLFdBQVcsQ0FBaUM7SUFBRyxDQUFDO0lBRXBFLE1BQU0sQ0FBQyxzQkFBc0IsQ0FBSSxJQUE2QixFQUFFLEdBQVk7UUFDbEYsT0FBTyxJQUFJLENBQUM7SUFDYixDQUFDOzhHQVRXLG9CQUFvQjtrR0FBcEIsb0JBQW9COztTQUFwQixvQkFBb0I7MkZBQXBCLG9CQUFvQjtrQkFKaEMsU0FBUzttQkFBQztvQkFDVixRQUFRLEVBQUUsZUFBZTtvQkFDekIsVUFBVSxFQUFFLElBQUk7aUJBQ2hCO2tHQUVnQyxNQUFNO3NCQUFyQyxLQUFLO3VCQUFDLG1CQUFtQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSW5wdXQsIFRlbXBsYXRlUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEFMdVNlbGVjdElucHV0Q29tcG9uZW50IH0gZnJvbSAnLi4vaW5wdXQnO1xyXG5pbXBvcnQgeyBMdU9wdGlvbkNvbnRleHQgfSBmcm9tICcuLi9zZWxlY3QubW9kZWwnO1xyXG5cclxuQERpcmVjdGl2ZSh7XHJcblx0c2VsZWN0b3I6ICdbbHVEaXNwbGF5ZXJdJyxcclxuXHRzdGFuZGFsb25lOiB0cnVlLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgTHVEaXNwbGF5ZXJEaXJlY3RpdmU8VD4ge1xyXG5cdEBJbnB1dCgnbHVEaXNwbGF5ZXJTZWxlY3QnKSBzZXQgc2VsZWN0KHNlbGVjdDogQUx1U2VsZWN0SW5wdXRDb21wb25lbnQ8VCwgdW5rbm93bj4pIHtcclxuXHRcdHNlbGVjdC52YWx1ZVRwbCA9IHRoaXMudGVtcGxhdGVSZWY7XHJcblx0fVxyXG5cclxuXHRwdWJsaWMgY29uc3RydWN0b3IocHJpdmF0ZSB0ZW1wbGF0ZVJlZjogVGVtcGxhdGVSZWY8THVPcHRpb25Db250ZXh0PFQ+Pikge31cclxuXHJcblx0cHVibGljIHN0YXRpYyBuZ1RlbXBsYXRlQ29udGV4dEd1YXJkPFQ+KF9kaXI6IEx1RGlzcGxheWVyRGlyZWN0aXZlPFQ+LCBjdHg6IHVua25vd24pOiBjdHggaXMgTHVPcHRpb25Db250ZXh0PFQ+IHtcclxuXHRcdHJldHVybiB0cnVlO1xyXG5cdH1cclxufVxyXG4iXX0=

package/esm2022/core-select/displayer/index.mjs

@@ -0,0 +1,2 @@
+export * from './displayer.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy9jb3JlLXNlbGVjdC9kaXNwbGF5ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGlzcGxheWVyLmRpcmVjdGl2ZSc7XHJcbiJdfQ==

package/esm2022/core-select/input/index.mjs

@@ -0,0 +1,3 @@
+export * from './select-input.component';
+export * from './select-input.models';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy9jb3JlLXNlbGVjdC9pbnB1dC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NlbGVjdC1pbnB1dC5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL3NlbGVjdC1pbnB1dC5tb2RlbHMnO1xyXG4iXX0=

package/esm2022/core-select/input/select-input.component.mjs

@@ -0,0 +1,203 @@
+/* eslint-disable @angular-eslint/no-output-on-prefix */
+import { OverlayContainer } from '@angular/cdk/overlay';
+import { ChangeDetectorRef, Directive, EventEmitter, HostBinding, HostListener, Input, Output, inject } from '@angular/core';
+import { BehaviorSubject, ReplaySubject, Subject } from 'rxjs';
+import { LuSimpleSelectDefaultOptionComponent } from '../option';
+import { SELECT_LABEL, SELECT_LABEL_ID } from '../select.model';
+import * as i0 from "@angular/core";
+class ALuSelectInputComponent {
+    constructor() {
+        this.tabindex = 0;
+        this.placeholder = '';
+        this.clearable = false;
+        this.disabled = false;
+        this.isPanelOpen$ = new BehaviorSubject(false);
+        this.role = 'combobox';
+        this.overlayConfig = {
+            hasBackdrop: true,
+            backdropClass: 'cdk-overlay-transparent-backdrop',
+        };
+        this.optionComparer = (option1, option2) => JSON.stringify(option1) === JSON.stringify(option2);
+        this.optionTpl = LuSimpleSelectDefaultOptionComponent;
+        this.clueChange = new EventEmitter();
+        this.nextPage = new EventEmitter();
+        this.previousPage = new EventEmitter();
+        this.options$ = new ReplaySubject(1);
+        this.loading$ = new ReplaySubject(1);
+        this.clue = null;
+        this.destroyed$ = new Subject();
+        this.changeDetectorRef = inject(ChangeDetectorRef);
+        this.overlayContainerRef = inject(OverlayContainer).getContainerElement();
+        this.label = inject(SELECT_LABEL);
+        this.labelId = inject(SELECT_LABEL_ID);
+    }
+    get searchable() {
+        return this.clueChange.observed;
+    }
+    get isFilledClass() {
+        return this.hasValue;
+    }
+    get isPanelOpen() {
+        return this.isPanelOpen$.value;
+    }
+    get ariaControls() {
+        return this.overlayContainerRef.id;
+    }
+    set loading(value) {
+        this.loading$.next(value);
+    }
+    set options(options) {
+        this.options$.next(options);
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+        this.changeDetectorRef.markForCheck();
+    }
+    get panelRef() {
+        return this._panelRef;
+    }
+    onKeydown($event) {
+        if (!this.isPanelOpen) {
+            this.openPanel();
+            $event.stopPropagation();
+            $event.preventDefault();
+        }
+    }
+    registerOnChange(onChange) {
+        this.onChange = onChange;
+    }
+    registerOnTouched(onTouched) {
+        this.onTouched = onTouched;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    ngOnDestroy() {
+        this.closePanel();
+        this.destroyed$.next();
+        this.destroyed$.complete();
+    }
+    ngOnInit() {
+        if (this.label) {
+            this.label.id = this.labelId;
+        }
+    }
+    clearValue(event) {
+        event.stopPropagation();
+        this.updateValue(null);
+    }
+    openPanel() {
+        if (this.isPanelOpen || this.disabled) {
+            return;
+        }
+        this.isPanelOpen$.next(true);
+        this._panelRef = this.buildPanelRef();
+        this.bindInputToPanelRefEvents();
+    }
+    bindInputToPanelRefEvents() {
+        if (!this.panelRef) {
+            return;
+        }
+        this.panelRef.valueChanged.subscribe((value) => this.updateValue(value));
+        this.panelRef.nextPage.subscribe(() => this.nextPage.emit());
+        this.panelRef.previousPage.subscribe(() => this.previousPage.emit());
+        this.panelRef.clueChanged.subscribe((clue) => {
+            this.clueChange.emit(clue);
+            this.clue = clue;
+        });
+        this.panelRef.activeOptionIdChanged.subscribe((optionId) => {
+            this.activeDescendant = optionId;
+            this.changeDetectorRef.markForCheck();
+        });
+        this.panelRef.closed.subscribe(() => this.closePanel());
+    }
+    closePanel() {
+        if (!this.isPanelOpen) {
+            return;
+        }
+        this.isPanelOpen$.next(false);
+        this.panelRef.close();
+        this._panelRef = undefined;
+    }
+    writeValue(value) {
+        this.value = value;
+    }
+    updateValue(value) {
+        this.value = value;
+        this.onChange?.(value);
+        this.onTouched?.();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: ALuSelectInputComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.3", type: ALuSelectInputComponent, inputs: { placeholder: "placeholder", clearable: "clearable", disabled: "disabled", overlayConfig: "overlayConfig", loading: "loading", options: "options", optionComparer: "optionComparer", optionTpl: "optionTpl", valueTpl: "valueTpl" }, outputs: { clueChange: "clueChange", nextPage: "nextPage", previousPage: "previousPage" }, host: { listeners: { "keydown.space": "onKeydown($event)", "keydown.enter": "onKeydown($event)", "keydown.arrowDown": "onKeydown($event)", "click": "onKeydown($event)" }, properties: { "tabindex": "this.tabindex", "class.is-clearable": "this.clearable", "class.is-disabled": "this.disabled", "class.is-filled": "this.isFilledClass", "class.is-focused": "this.isPanelOpen", "attr.aria-expanded": "this.isPanelOpen", "attr.role": "this.role", "attr.aria-activedescendant": "this.activeDescendant", "attr.aria-controls": "this.ariaControls" } }, ngImport: i0 }); }
+}
+export { ALuSelectInputComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: ALuSelectInputComponent, decorators: [{
+            type: Directive
+        }], propDecorators: { tabindex: [{
+                type: HostBinding,
+                args: ['tabindex']
+            }], placeholder: [{
+                type: Input
+            }], clearable: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['class.is-clearable']
+            }], disabled: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['class.is-disabled']
+            }], isFilledClass: [{
+                type: HostBinding,
+                args: ['class.is-filled']
+            }], isPanelOpen: [{
+                type: HostBinding,
+                args: ['class.is-focused']
+            }, {
+                type: HostBinding,
+                args: ['attr.aria-expanded']
+            }], role: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], activeDescendant: [{
+                type: HostBinding,
+                args: ['attr.aria-activedescendant']
+            }], ariaControls: [{
+                type: HostBinding,
+                args: ['attr.aria-controls']
+            }], overlayConfig: [{
+                type: Input
+            }], loading: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], optionComparer: [{
+                type: Input
+            }], optionTpl: [{
+                type: Input
+            }], valueTpl: [{
+                type: Input
+            }], clueChange: [{
+                type: Output
+            }], nextPage: [{
+                type: Output
+            }], previousPage: [{
+                type: Output
+            }], onKeydown: [{
+                type: HostListener,
+                args: ['keydown.space', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['keydown.enter', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['keydown.arrowDown', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select-input.component.js","sourceRoot":"","sources":["../../../../../packages/ng/core-select/input/select-input.component.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @angular-eslint/no-output-on-prefix */\r\nimport { OverlayConfig, OverlayContainer } from '@angular/cdk/overlay';\r\nimport { ChangeDetectorRef, Directive, EventEmitter, HostBinding, HostListener, Input, OnDestroy, OnInit, Output, TemplateRef, Type, inject } from '@angular/core';\r\nimport { BehaviorSubject, ReplaySubject, Subject } from 'rxjs';\r\nimport { LuSimpleSelectDefaultOptionComponent } from '../option';\r\nimport { LuSelectPanelRef } from '../panel';\r\nimport { LuOptionContext, SELECT_LABEL, SELECT_LABEL_ID } from '../select.model';\r\n\r\n@Directive()\r\nexport abstract class ALuSelectInputComponent<TOption, TValue> implements OnDestroy, OnInit {\r\n\t@HostBinding('tabindex') tabindex = 0;\r\n\r\n\t@Input() placeholder = '';\r\n\r\n\t@Input()\r\n\t@HostBinding('class.is-clearable')\r\n\tclearable = false;\r\n\r\n\tget searchable(): boolean {\r\n\t\treturn this.clueChange.observed;\r\n\t}\r\n\r\n\t@Input()\r\n\t@HostBinding('class.is-disabled')\r\n\tdisabled = false;\r\n\r\n\t@HostBinding('class.is-filled')\r\n\tprotected get isFilledClass(): boolean {\r\n\t\treturn this.hasValue;\r\n\t}\r\n\r\n\tprotected abstract readonly hasValue: boolean;\r\n\r\n\t@HostBinding('class.is-focused')\r\n\t@HostBinding('attr.aria-expanded')\r\n\tpublic get isPanelOpen(): boolean {\r\n\t\treturn this.isPanelOpen$.value;\r\n\t}\r\n\tpublic isPanelOpen$ = new BehaviorSubject(false);\r\n\r\n\t@HostBinding('attr.role')\r\n\tpublic role = 'combobox';\r\n\r\n\t@HostBinding('attr.aria-activedescendant')\r\n\tpublic activeDescendant: string | undefined;\r\n\r\n\t@HostBinding('attr.aria-controls')\r\n\tget ariaControls(): string {\r\n\t\treturn this.overlayContainerRef.id;\r\n\t}\r\n\r\n\t@Input()\r\n\toverlayConfig?: OverlayConfig = {\r\n\t\thasBackdrop: true,\r\n\t\tbackdropClass: 'cdk-overlay-transparent-backdrop',\r\n\t};\r\n\r\n\t@Input() set loading(value: boolean) {\r\n\t\tthis.loading$.next(value);\r\n\t}\r\n\r\n\t@Input() set options(options: TOption[]) {\r\n\t\tthis.options$.next(options);\r\n\t}\r\n\r\n\t@Input() optionComparer: (option1: TOption, option2: TOption) => boolean = (option1, option2) => JSON.stringify(option1) === JSON.stringify(option2);\r\n\t@Input() optionTpl?: TemplateRef<LuOptionContext<TOption>> | Type<unknown> = LuSimpleSelectDefaultOptionComponent;\r\n\t@Input() valueTpl?: TemplateRef<LuOptionContext<TOption>> | Type<unknown>;\r\n\r\n\t@Output() clueChange = new EventEmitter<string>();\r\n\t@Output() nextPage = new EventEmitter<void>();\r\n\t@Output() previousPage = new EventEmitter<void>();\r\n\r\n\tpublic get value(): TValue {\r\n\t\treturn this._value;\r\n\t}\r\n\r\n\tprotected set value(value: TValue) {\r\n\t\tthis._value = value;\r\n\t\tthis.changeDetectorRef.markForCheck();\r\n\t}\r\n\r\n\tprotected _value?: TValue;\r\n\r\n\toptions$ = new ReplaySubject<TOption[]>(1);\r\n\tloading$ = new ReplaySubject<boolean>(1);\r\n\tclue: string | null = null;\r\n\r\n\tprotected onChange?: (value: TValue | null) => void;\r\n\tprotected onTouched?: () => void;\r\n\r\n\tpublic get panelRef(): LuSelectPanelRef<TOption, TValue> | undefined {\r\n\t\treturn this._panelRef;\r\n\t}\r\n\r\n\tprotected _panelRef?: LuSelectPanelRef<TOption, TValue>;\r\n\r\n\tprotected destroyed$ = new Subject<void>();\r\n\r\n\t@HostListener('keydown.space', ['$event'])\r\n\t@HostListener('keydown.enter', ['$event'])\r\n\t@HostListener('keydown.arrowDown', ['$event'])\r\n\t@HostListener('click', ['$event'])\r\n\tonKeydown($event: KeyboardEvent) {\r\n\t\tif (!this.isPanelOpen) {\r\n\t\t\tthis.openPanel();\r\n\t\t\t$event.stopPropagation();\r\n\t\t\t$event.preventDefault();\r\n\t\t}\r\n\t}\r\n\r\n\tprotected changeDetectorRef = inject(ChangeDetectorRef);\r\n\tprotected overlayContainerRef: HTMLElement = inject(OverlayContainer).getContainerElement();\r\n\r\n\tprotected label: HTMLElement | undefined = inject(SELECT_LABEL);\r\n\tprotected labelId: string = inject(SELECT_LABEL_ID);\r\n\r\n\tregisterOnChange(onChange: (value: TValue) => void): void {\r\n\t\tthis.onChange = onChange;\r\n\t}\r\n\r\n\tregisterOnTouched(onTouched: () => void): void {\r\n\t\tthis.onTouched = onTouched;\r\n\t}\r\n\r\n\tsetDisabledState(isDisabled: boolean): void {\r\n\t\tthis.disabled = isDisabled;\r\n\t}\r\n\r\n\tngOnDestroy(): void {\r\n\t\tthis.closePanel();\r\n\t\tthis.destroyed$.next();\r\n\t\tthis.destroyed$.complete();\r\n\t}\r\n\r\n\tngOnInit(): void {\r\n\t\tif (this.label) {\r\n\t\t\tthis.label.id = this.labelId;\r\n\t\t}\r\n\t}\r\n\r\n\tclearValue(event: MouseEvent): void {\r\n\t\tevent.stopPropagation();\r\n\t\tthis.updateValue(null);\r\n\t}\r\n\r\n\topenPanel(): void {\r\n\t\tif (this.isPanelOpen || this.disabled) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tthis.isPanelOpen$.next(true);\r\n\t\tthis._panelRef = this.buildPanelRef();\r\n\t\tthis.bindInputToPanelRefEvents();\r\n\t}\r\n\r\n\tprotected abstract buildPanelRef(): this['panelRef'];\r\n\r\n\tprotected bindInputToPanelRefEvents(): void {\r\n\t\tif (!this.panelRef) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tthis.panelRef.valueChanged.subscribe((value) => this.updateValue(value));\r\n\t\tthis.panelRef.nextPage.subscribe(() => this.nextPage.emit());\r\n\t\tthis.panelRef.previousPage.subscribe(() => this.previousPage.emit());\r\n\t\tthis.panelRef.clueChanged.subscribe((clue) => {\r\n\t\t\tthis.clueChange.emit(clue);\r\n\t\t\tthis.clue = clue;\r\n\t\t});\r\n\t\tthis.panelRef.activeOptionIdChanged.subscribe((optionId) => {\r\n\t\t\tthis.activeDescendant = optionId;\r\n\t\t\tthis.changeDetectorRef.markForCheck();\r\n\t\t});\r\n\t\tthis.panelRef.closed.subscribe(() => this.closePanel());\r\n\t}\r\n\r\n\tpublic closePanel(): void {\r\n\t\tif (!this.isPanelOpen) {\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tthis.isPanelOpen$.next(false);\r\n\t\tthis.panelRef.close();\r\n\t\tthis._panelRef = undefined;\r\n\t}\r\n\r\n\tpublic writeValue(value: TValue): void {\r\n\t\tthis.value = value;\r\n\t}\r\n\r\n\tpublic updateValue(value: TValue): void {\r\n\t\tthis.value = value;\r\n\t\tthis.onChange?.(value);\r\n\t\tthis.onTouched?.();\r\n\t}\r\n}\r\n"]}

package/esm2022/core-select/input/select-input.models.mjs

@@ -0,0 +1,60 @@
+import { Overlay, OverlayContainer } from '@angular/cdk/overlay';
+import { Platform } from '@angular/cdk/platform';
+import { DOCUMENT } from '@angular/common';
+import { ElementRef, Injectable, inject } from '@angular/core';
+import { SELECT_ID, SELECT_LABEL, SELECT_LABEL_ID } from '../select.model';
+import * as i0 from "@angular/core";
+let selectId = 0;
+function selectIdFactory() {
+    return selectId++;
+}
+function selectLabelFactory() {
+    const elementRef = inject(ElementRef);
+    function getLabel(node) {
+        if (node instanceof HTMLLabelElement) {
+            return node;
+        }
+        if (!node.parentElement) {
+            return undefined;
+        }
+        return getLabel(node.parentElement);
+    }
+    return getLabel(elementRef.nativeElement);
+}
+function selectLabelIdFactory() {
+    return inject(SELECT_LABEL)?.id || `lu-select-label-${inject(SELECT_ID)}`;
+}
+export function provideLuSelectLabelsAndIds() {
+    return [
+        { provide: SELECT_ID, useFactory: selectIdFactory },
+        { provide: SELECT_LABEL, useFactory: selectLabelFactory },
+        { provide: SELECT_LABEL_ID, useFactory: selectLabelIdFactory },
+    ];
+}
+class LuSelectOverlayContainer extends OverlayContainer {
+    constructor() {
+        super(inject(DOCUMENT), inject(Platform));
+        this.selectLabelId = inject(SELECT_LABEL_ID);
+        this.selectId = inject(SELECT_ID);
+    }
+    _createContainer() {
+        super._createContainer();
+        this._containerElement.setAttribute('aria-labelledby', this.selectLabelId);
+        this._containerElement.id = `lu-select-overlay-container-${this.selectId}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: LuSelectOverlayContainer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: LuSelectOverlayContainer }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: LuSelectOverlayContainer, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+export function provideLuSelectOverlayContainer() {
+    return [
+        Overlay,
+        {
+            provide: OverlayContainer,
+            useClass: LuSelectOverlayContainer,
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core-select/lucca-front-ng-core-select.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibHVjY2EtZnJvbnQtbmctY29yZS1zZWxlY3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy9jb3JlLXNlbGVjdC9sdWNjYS1mcm9udC1uZy1jb3JlLXNlbGVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/{simple-select → core-select}/option/default-option.component.mjs

@@ -19,4 +19,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImpor
                     template: `<ng-container *ngIf="context.option$ | async as option">{{ option?.name ?? option }}</ng-container>`,
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1vcHRpb24uY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbmcvc2ltcGxlLXNlbGVjdC9vcHRpb24vZGVmYXVsdC1vcHRpb24uY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDbEQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbEQsT0FBTyxFQUFvQixpQkFBaUIsRUFBRSxNQUFNLGdCQUFnQixDQUFDOztBQUVyRSxNQU1hLG9DQUFvQztJQU5qRDtRQU9RLFlBQU8sR0FBRyxNQUFNLENBQXNDLGlCQUFpQixDQUFDLENBQUM7S0FDaEY7OEdBRlksb0NBQW9DO2tHQUFwQyxvQ0FBb0MsMkZBRnRDLHFHQUFxRyx1REFEckcsU0FBUyw4Q0FBRSxJQUFJOztTQUdiLG9DQUFvQzsyRkFBcEMsb0NBQW9DO2tCQU5oRCxTQUFTO21CQUFDO29CQUNWLFFBQVEsRUFBRSxpQ0FBaUM7b0JBQzNDLFVBQVUsRUFBRSxJQUFJO29CQUNoQixPQUFPLEVBQUUsQ0FBQyxTQUFTLEVBQUUsSUFBSSxDQUFDO29CQUMxQixRQUFRLEVBQUUscUdBQXFHO2lCQUMvRyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFzeW5jUGlwZSwgTmdJZiB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcbmltcG9ydCB7IENvbXBvbmVudCwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IElMdU9wdGlvbkNvbnRleHQsIExVX09QVElPTl9DT05URVhUIH0gZnJvbSAnLi9vcHRpb24udG9rZW4nO1xyXG5cclxuQENvbXBvbmVudCh7XHJcblx0c2VsZWN0b3I6ICdsdS1zaW1wbGUtc2VsZWN0LWRlZmF1bHQtb3B0aW9uJyxcclxuXHRzdGFuZGFsb25lOiB0cnVlLFxyXG5cdGltcG9ydHM6IFtBc3luY1BpcGUsIE5nSWZdLFxyXG5cdHRlbXBsYXRlOiBgPG5nLWNvbnRhaW5lciAqbmdJZj1cImNvbnRleHQub3B0aW9uJCB8IGFzeW5jIGFzIG9wdGlvblwiPnt7IG9wdGlvbj8ubmFtZSA/PyBvcHRpb24gfX08L25nLWNvbnRhaW5lcj5gLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgTHVTaW1wbGVTZWxlY3REZWZhdWx0T3B0aW9uQ29tcG9uZW50IHtcclxuXHRwdWJsaWMgY29udGV4dCA9IGluamVjdDxJTHVPcHRpb25Db250ZXh0PHsgbmFtZT86IHN0cmluZyB9Pj4oTFVfT1BUSU9OX0NPTlRFWFQpO1xyXG59XHJcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1vcHRpb24uY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbmcvY29yZS1zZWxlY3Qvb3B0aW9uL2RlZmF1bHQtb3B0aW9uLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ2xELE9BQU8sRUFBb0IsaUJBQWlCLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQzs7QUFFckUsTUFNYSxvQ0FBb0M7SUFOakQ7UUFPUSxZQUFPLEdBQUcsTUFBTSxDQUFzQyxpQkFBaUIsQ0FBQyxDQUFDO0tBQ2hGOzhHQUZZLG9DQUFvQztrR0FBcEMsb0NBQW9DLDJGQUZ0QyxxR0FBcUcsdURBRHJHLFNBQVMsOENBQUUsSUFBSTs7U0FHYixvQ0FBb0M7MkZBQXBDLG9DQUFvQztrQkFOaEQsU0FBUzttQkFBQztvQkFDVixRQUFRLEVBQUUsaUNBQWlDO29CQUMzQyxVQUFVLEVBQUUsSUFBSTtvQkFDaEIsT0FBTyxFQUFFLENBQUMsU0FBUyxFQUFFLElBQUksQ0FBQztvQkFDMUIsUUFBUSxFQUFFLHFHQUFxRztpQkFDL0ciLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBc3luY1BpcGUsIE5nSWYgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xyXG5pbXBvcnQgeyBDb21wb25lbnQsIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBJTHVPcHRpb25Db250ZXh0LCBMVV9PUFRJT05fQ09OVEVYVCB9IGZyb20gJy4vb3B0aW9uLnRva2VuJztcclxuXHJcbkBDb21wb25lbnQoe1xyXG5cdHNlbGVjdG9yOiAnbHUtc2ltcGxlLXNlbGVjdC1kZWZhdWx0LW9wdGlvbicsXHJcblx0c3RhbmRhbG9uZTogdHJ1ZSxcclxuXHRpbXBvcnRzOiBbQXN5bmNQaXBlLCBOZ0lmXSxcclxuXHR0ZW1wbGF0ZTogYDxuZy1jb250YWluZXIgKm5nSWY9XCJjb250ZXh0Lm9wdGlvbiQgfCBhc3luYyBhcyBvcHRpb25cIj57eyBvcHRpb24/Lm5hbWUgPz8gb3B0aW9uIH19PC9uZy1jb250YWluZXI+YCxcclxufSlcclxuZXhwb3J0IGNsYXNzIEx1U2ltcGxlU2VsZWN0RGVmYXVsdE9wdGlvbkNvbXBvbmVudCB7XHJcblx0cHVibGljIGNvbnRleHQgPSBpbmplY3Q8SUx1T3B0aW9uQ29udGV4dDx7IG5hbWU/OiBzdHJpbmcgfT4+KExVX09QVElPTl9DT05URVhUKTtcclxufVxyXG4iXX0=

package/esm2022/core-select/option/disabled.directive.mjs

@@ -0,0 +1,27 @@
+import { Directive, inject, Input } from '@angular/core';
+import { LU_OPTION_CONTEXT } from './option.token';
+import * as i0 from "@angular/core";
+class LuDisabledOptionDirective {
+    constructor() {
+        this.context = inject(LU_OPTION_CONTEXT);
+    }
+    set isDisabled(disabled) {
+        if (disabled !== null) {
+            this.context.isDisabled$.next(disabled);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: LuDisabledOptionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.3", type: LuDisabledOptionDirective, isStandalone: true, selector: "[luDisabledOption]", inputs: { isDisabled: ["luDisabledOption", "isDisabled"] }, ngImport: i0 }); }
+}
+export { LuDisabledOptionDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: LuDisabledOptionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[luDisabledOption]',
+                    standalone: true,
+                }]
+        }], propDecorators: { isDisabled: [{
+                type: Input,
+                args: ['luDisabledOption']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzYWJsZWQuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbmcvY29yZS1zZWxlY3Qvb3B0aW9uL2Rpc2FibGVkLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7O0FBRW5ELE1BSWEseUJBQXlCO0lBSnRDO1FBS1MsWUFBTyxHQUFHLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0tBTzVDO0lBTEEsSUFBc0MsVUFBVSxDQUFDLFFBQXdCO1FBQ3hFLElBQUksUUFBUSxLQUFLLElBQUksRUFBRTtZQUN0QixJQUFJLENBQUMsT0FBTyxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7U0FDeEM7SUFDRixDQUFDOzhHQVBXLHlCQUF5QjtrR0FBekIseUJBQXlCOztTQUF6Qix5QkFBeUI7MkZBQXpCLHlCQUF5QjtrQkFKckMsU0FBUzttQkFBQztvQkFDVixRQUFRLEVBQUUsb0JBQW9CO29CQUM5QixVQUFVLEVBQUUsSUFBSTtpQkFDaEI7OEJBSXNDLFVBQVU7c0JBQS9DLEtBQUs7dUJBQUMsa0JBQWtCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBpbmplY3QsIElucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IExVX09QVElPTl9DT05URVhUIH0gZnJvbSAnLi9vcHRpb24udG9rZW4nO1xyXG5cclxuQERpcmVjdGl2ZSh7XHJcblx0c2VsZWN0b3I6ICdbbHVEaXNhYmxlZE9wdGlvbl0nLFxyXG5cdHN0YW5kYWxvbmU6IHRydWUsXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBMdURpc2FibGVkT3B0aW9uRGlyZWN0aXZlIHtcclxuXHRwcml2YXRlIGNvbnRleHQgPSBpbmplY3QoTFVfT1BUSU9OX0NPTlRFWFQpO1xyXG5cclxuXHRASW5wdXQoJ2x1RGlzYWJsZWRPcHRpb24nKSBwdWJsaWMgc2V0IGlzRGlzYWJsZWQoZGlzYWJsZWQ6IGJvb2xlYW4gfCBudWxsKSB7XHJcblx0XHRpZiAoZGlzYWJsZWQgIT09IG51bGwpIHtcclxuXHRcdFx0dGhpcy5jb250ZXh0LmlzRGlzYWJsZWQkLm5leHQoZGlzYWJsZWQpO1xyXG5cdFx0fVxyXG5cdH1cclxufVxyXG4iXX0=

package/esm2022/core-select/option/index.mjs

@@ -0,0 +1,7 @@
+export * from './default-option.component';
+export * from './disabled.directive';
+export { LuOptionOutletDirective as ɵLuOptionOutletDirective } from './option-outlet.directive';
+export { LuOptionComponent as ɵLuOptionComponent } from './option.component';
+export * from './option.directive';
+export * from './option.token';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy9jb3JlLXNlbGVjdC9vcHRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLE9BQU8sRUFBRSx1QkFBdUIsSUFBSSx3QkFBd0IsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2hHLE9BQU8sRUFBRSxpQkFBaUIsSUFBSSxrQkFBa0IsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQzdFLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGVmYXVsdC1vcHRpb24uY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9kaXNhYmxlZC5kaXJlY3RpdmUnO1xyXG5leHBvcnQgeyBMdU9wdGlvbk91dGxldERpcmVjdGl2ZSBhcyDJtUx1T3B0aW9uT3V0bGV0RGlyZWN0aXZlIH0gZnJvbSAnLi9vcHRpb24tb3V0bGV0LmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCB7IEx1T3B0aW9uQ29tcG9uZW50IGFzIMm1THVPcHRpb25Db21wb25lbnQgfSBmcm9tICcuL29wdGlvbi5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL29wdGlvbi5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL29wdGlvbi50b2tlbic7XHJcbiJdfQ==

package/esm2022/core-select/option/option-outlet.directive.mjs

@@ -0,0 +1,71 @@
+import { Directive, inject, Injector, Input, TemplateRef, ViewContainerRef } from '@angular/core';
+import { LU_OPTION_CONTEXT, provideOptionContext } from './option.token';
+import * as i0 from "@angular/core";
+class LuOptionOutletDirective {
+    constructor() {
+        this.viewContainerRef = inject(ViewContainerRef);
+        this.injector = inject(Injector);
+        this.optionContext = inject(LU_OPTION_CONTEXT);
+    }
+    ngOnChanges(changes) {
+        if (changes['luOptionOutlet'] || !this.luOptionOutletValue) {
+            this.clearContainer();
+        }
+        const hasRef = this.embeddedViewRef || this.componentRef;
+        if (changes['luOptionOutlet'] || (changes['luOptionOutletValue'] && !hasRef)) {
+            this.createComponent();
+        }
+        else if (changes['luOptionOutletValue']) {
+            this.updateRefValue();
+        }
+    }
+    ngOnDestroy() {
+        this.optionContext.destroy();
+    }
+    clearContainer() {
+        this.viewContainerRef.clear();
+        this.embeddedViewRef?.destroy();
+        this.componentRef?.destroy();
+        this.embeddedViewRef = undefined;
+        this.componentRef = undefined;
+    }
+    createComponent() {
+        if (!this.luOptionOutlet || !this.luOptionOutletValue) {
+            return;
+        }
+        if (this.luOptionOutlet instanceof TemplateRef) {
+            this.embeddedViewRef = this.viewContainerRef.createEmbeddedView(this.luOptionOutlet, { $implicit: this.luOptionOutletValue }, { injector: this.injector });
+        }
+        else {
+            this.optionContext.option$.next(this.luOptionOutletValue);
+            this.componentRef = this.viewContainerRef.createComponent(this.luOptionOutlet, { injector: this.injector });
+        }
+    }
+    updateRefValue() {
+        if (!this.luOptionOutletValue) {
+            return;
+        }
+        if (this.embeddedViewRef) {
+            this.embeddedViewRef.context = { $implicit: this.luOptionOutletValue };
+        }
+        else if (this.componentRef) {
+            this.optionContext.option$.next(this.luOptionOutletValue);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: LuOptionOutletDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.3", type: LuOptionOutletDirective, isStandalone: true, selector: "[luOptionOutlet]", inputs: { luOptionOutlet: "luOptionOutlet", luOptionOutletValue: "luOptionOutletValue" }, providers: [provideOptionContext()], usesOnChanges: true, ngImport: i0 }); }
+}
+export { LuOptionOutletDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: LuOptionOutletDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[luOptionOutlet]',
+                    standalone: true,
+                    providers: [provideOptionContext()],
+                }]
+        }], propDecorators: { luOptionOutlet: [{
+                type: Input
+            }], luOptionOutletValue: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core-select/option/option.component.mjs

@@ -0,0 +1,81 @@
+import { AsyncPipe } from '@angular/common';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, HostBinding, inject, Input, ViewChild } from '@angular/core';
+import { asyncScheduler, BehaviorSubject, observeOn } from 'rxjs';
+import { SELECT_ID } from '../select.model';
+import { LuOptionOutletDirective } from './option-outlet.directive';
+import { LU_OPTION_CONTEXT } from './option.token';
+import * as i0 from "@angular/core";
+class LuOptionComponent {
+    constructor() {
+        this.hasOptionItemClass = true;
+        this.isSelected = false;
+        this.optionIndex = 0;
+        this.scrollIntoViewOptions = {};
+        this.isHighlighted$ = new BehaviorSubject(false);
+        /**
+         * Whether option is disabled. Used by ListKeyManager.
+         */
+        this.disabled = false;
+        this.cdr = inject(ChangeDetectorRef);
+        this.role = 'option';
+        this.elementRef = inject(ElementRef);
+        this.selectId = inject(SELECT_ID);
+    }
+    get id() {
+        return `lu-select-${this.selectId}-option-${this.optionIndex}`;
+    }
+    ngOnDestroy() {
+        this.subscription?.unsubscribe();
+    }
+    ngAfterViewInit() {
+        this.subscription = this.optionContext.isDisabled$.pipe(observeOn(asyncScheduler)).subscribe((isDisabled) => {
+            this.disabled = isDisabled;
+            this.cdr.markForCheck();
+        });
+    }
+    setActiveStyles() {
+        this.isHighlighted$.next(true);
+        this.elementRef.nativeElement.scrollIntoView(this.scrollIntoViewOptions);
+    }
+    setInactiveStyles() {
+        this.isHighlighted$.next(false);
+    }
+    selectOption($event) {
+        if (this.disabled) {
+            $event.stopPropagation();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: LuOptionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.3", type: LuOptionComponent, isStandalone: true, selector: "lu-select-option", inputs: { optionTpl: "optionTpl", isSelected: "isSelected", option: "option", optionIndex: "optionIndex", scrollIntoViewOptions: "scrollIntoViewOptions" }, host: { properties: { "class.optionItem": "this.hasOptionItemClass", "attr.aria-selected": "this.isSelected", "attr.role": "this.role", "attr.id": "this.id" } }, viewQueries: [{ propertyName: "optionContext", first: true, predicate: LuOptionOutletDirective, descendants: true, read: LU_OPTION_CONTEXT, static: true }], ngImport: i0, template: "<div\r\n\tclass=\"optionItem-value\"\r\n\t[class.is-selected]=\"isSelected\"\r\n\t[class.is-highlighted]=\"isHighlighted$ | async\"\r\n\t[class.is-disabled]=\"disabled\"\r\n\t(click)=\"selectOption($event)\"\r\n>\r\n\t<ng-container *luOptionOutlet=\"optionTpl; value: option\"></ng-container>\r\n</div>\r\n", styles: [":root{--components-options-item-padding-vertical: var(--spacings-XS);--components-options-item-padding-horizontal: var(--spacings-XS);--components-options-item-multiple-padding: 2.25rem;--components-options-item-icon-color: var(--palettes-grey-800);--components-options-checkbox-left: .5rem;--components-options-checkbox-size: 1.25rem;--components-options-checkbox-color: var(--palettes-primary-700);--components-options-checkbox-border-radius: 6px;--components-options-checkbox-border-color: var(--palettes-grey-700);--components-options-establishment-multiple-padding: 2rem}:host{display:block}.optionItem{position:relative}.optionItem-value{border-radius:var(--commons-borderRadius-M);display:block;padding:var(--components-options-item-padding-vertical) var(--components-options-item-padding-horizontal);transition:background-color 50ms;cursor:pointer}.optionItem-value.is-selected{background-color:var(--palettes-primary-50)}.optionItem-value.is-selected:hover{background-color:var(--palettes-primary-100)}.optionItem-value.is-selected:active{background-color:var(--palettes-primary-200)}.optionItem-value.is-selected.is-highlighted{background-color:var(--palettes-primary-100)}.optionItem-value.is-selected.is-highlighted:hover{background-color:var(--palettes-primary-200)}.optionItem-value:hover,.optionItem-value.is-highlighted,.optionItem-value.is-focus,.optionItem-value.is-highlighted:hover,.optionItem-value.is-focus:hover{background-color:var(--palettes-grey-50)}.optionItem-value.is-highlighted:active,.optionItem-value.is-focus:active,.optionItem-value:active{background-color:var(--palettes-grey-100)}:host-context(.lu-select-value) .optionItem-value{padding:0;overflow:hidden;text-overflow:ellipsis}:host-context(.lu-select-value) .optionItem-value:hover,:host-context(.lu-select-value) .optionItem-value.is-focus,:host-context(.lu-select-value) .optionItem-value.is-highlighted{background-color:inherit}:host-context(.mod-multiple) .optionItem-value{position:relative;padding-left:var(--components-options-item-multiple-padding)}:host-context(.mod-multiple) .optionItem-value:after,:host-context(.mod-multiple) .optionItem-value:before{display:block;position:absolute;left:var(--components-options-checkbox-left);top:50%;transform:translateY(-50%)}:host-context(.mod-multiple) .optionItem-value:before{content:\"\";border-radius:var(--components-options-checkbox-border-radius);box-shadow:inset 0 0 0 2px var(--components-options-checkbox-border-color);display:block;height:var(--components-options-checkbox-size);transition-property:background-color,box-shadow;transition-duration:var(--commons-animations-durations-fast);width:var(--components-options-checkbox-size)}:host-context(.mod-multiple) .optionItem-value:after{display:inline-block;vertical-align:text-bottom;font-style:normal;font-family:Lucca icons;color:transparent;font-size:var(--sizes-S-lineHeight);line-height:var(--components-options-checkbox-size);position:absolute;text-align:center;transform:translateY(-50%) scale(0);transition:all .1s;width:var(--components-options-checkbox-size)}@supports (content: \"*\"/\"\"){:host-context(.mod-multiple) .optionItem-value:after{content:\"\\e97d\"/\"\"}}@supports not (content: \"*\"/\"\"){:host-context(.mod-multiple) .optionItem-value:after{content:\"\\e97d\"}}:host-context(.mod-multiple) .optionItem-value.is-selected:before{background-color:var(--components-options-checkbox-color);box-shadow:inset 0 0 0 2px var(--components-options-checkbox-color)}:host-context(.mod-multiple) .optionItem-value.is-selected:after{color:var(--colors-white-color);transform:translateY(-50%) scale(1)}:host-context(.mod-multiple) .optionItem-value.is-disabled{--components-options-checkbox-border-color: var(--palettes-grey-500)}:host-context(.mod-multiple) .optionItem-value:not(.is-disabled):hover:before{box-shadow:inset 0 0 0 2px var(--components-options-checkbox-color)}:host-context(.mod-multiple).establishmentOption .optionItem-value{position:relative;padding-left:calc(var(--components-options-checkbox-size) + var(--spacings-XS) * 2)}:host-context(.mod-multiple).establishmentOption .optionItem-value:before,:host-context(.mod-multiple).establishmentOption .optionItem-value:after{left:var(--spacings-XS)}.is-disabled{color:var(--palettes-grey-500);-webkit-user-select:none;user-select:none;cursor:default}.is-disabled.is-selected{background-color:var(--palettes-grey-100)}.is-disabled:hover{background-color:inherit}\n"], dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "directive", type: LuOptionOutletDirective, selector: "[luOptionOutlet]", inputs: ["luOptionOutlet", "luOptionOutletValue"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+export { LuOptionComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: LuOptionComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lu-select-option', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [AsyncPipe, LuOptionOutletDirective], template: "<div\r\n\tclass=\"optionItem-value\"\r\n\t[class.is-selected]=\"isSelected\"\r\n\t[class.is-highlighted]=\"isHighlighted$ | async\"\r\n\t[class.is-disabled]=\"disabled\"\r\n\t(click)=\"selectOption($event)\"\r\n>\r\n\t<ng-container *luOptionOutlet=\"optionTpl; value: option\"></ng-container>\r\n</div>\r\n", styles: [":root{--components-options-item-padding-vertical: var(--spacings-XS);--components-options-item-padding-horizontal: var(--spacings-XS);--components-options-item-multiple-padding: 2.25rem;--components-options-item-icon-color: var(--palettes-grey-800);--components-options-checkbox-left: .5rem;--components-options-checkbox-size: 1.25rem;--components-options-checkbox-color: var(--palettes-primary-700);--components-options-checkbox-border-radius: 6px;--components-options-checkbox-border-color: var(--palettes-grey-700);--components-options-establishment-multiple-padding: 2rem}:host{display:block}.optionItem{position:relative}.optionItem-value{border-radius:var(--commons-borderRadius-M);display:block;padding:var(--components-options-item-padding-vertical) var(--components-options-item-padding-horizontal);transition:background-color 50ms;cursor:pointer}.optionItem-value.is-selected{background-color:var(--palettes-primary-50)}.optionItem-value.is-selected:hover{background-color:var(--palettes-primary-100)}.optionItem-value.is-selected:active{background-color:var(--palettes-primary-200)}.optionItem-value.is-selected.is-highlighted{background-color:var(--palettes-primary-100)}.optionItem-value.is-selected.is-highlighted:hover{background-color:var(--palettes-primary-200)}.optionItem-value:hover,.optionItem-value.is-highlighted,.optionItem-value.is-focus,.optionItem-value.is-highlighted:hover,.optionItem-value.is-focus:hover{background-color:var(--palettes-grey-50)}.optionItem-value.is-highlighted:active,.optionItem-value.is-focus:active,.optionItem-value:active{background-color:var(--palettes-grey-100)}:host-context(.lu-select-value) .optionItem-value{padding:0;overflow:hidden;text-overflow:ellipsis}:host-context(.lu-select-value) .optionItem-value:hover,:host-context(.lu-select-value) .optionItem-value.is-focus,:host-context(.lu-select-value) .optionItem-value.is-highlighted{background-color:inherit}:host-context(.mod-multiple) .optionItem-value{position:relative;padding-left:var(--components-options-item-multiple-padding)}:host-context(.mod-multiple) .optionItem-value:after,:host-context(.mod-multiple) .optionItem-value:before{display:block;position:absolute;left:var(--components-options-checkbox-left);top:50%;transform:translateY(-50%)}:host-context(.mod-multiple) .optionItem-value:before{content:\"\";border-radius:var(--components-options-checkbox-border-radius);box-shadow:inset 0 0 0 2px var(--components-options-checkbox-border-color);display:block;height:var(--components-options-checkbox-size);transition-property:background-color,box-shadow;transition-duration:var(--commons-animations-durations-fast);width:var(--components-options-checkbox-size)}:host-context(.mod-multiple) .optionItem-value:after{display:inline-block;vertical-align:text-bottom;font-style:normal;font-family:Lucca icons;color:transparent;font-size:var(--sizes-S-lineHeight);line-height:var(--components-options-checkbox-size);position:absolute;text-align:center;transform:translateY(-50%) scale(0);transition:all .1s;width:var(--components-options-checkbox-size)}@supports (content: \"*\"/\"\"){:host-context(.mod-multiple) .optionItem-value:after{content:\"\\e97d\"/\"\"}}@supports not (content: \"*\"/\"\"){:host-context(.mod-multiple) .optionItem-value:after{content:\"\\e97d\"}}:host-context(.mod-multiple) .optionItem-value.is-selected:before{background-color:var(--components-options-checkbox-color);box-shadow:inset 0 0 0 2px var(--components-options-checkbox-color)}:host-context(.mod-multiple) .optionItem-value.is-selected:after{color:var(--colors-white-color);transform:translateY(-50%) scale(1)}:host-context(.mod-multiple) .optionItem-value.is-disabled{--components-options-checkbox-border-color: var(--palettes-grey-500)}:host-context(.mod-multiple) .optionItem-value:not(.is-disabled):hover:before{box-shadow:inset 0 0 0 2px var(--components-options-checkbox-color)}:host-context(.mod-multiple).establishmentOption .optionItem-value{position:relative;padding-left:calc(var(--components-options-checkbox-size) + var(--spacings-XS) * 2)}:host-context(.mod-multiple).establishmentOption .optionItem-value:before,:host-context(.mod-multiple).establishmentOption .optionItem-value:after{left:var(--spacings-XS)}.is-disabled{color:var(--palettes-grey-500);-webkit-user-select:none;user-select:none;cursor:default}.is-disabled.is-selected{background-color:var(--palettes-grey-100)}.is-disabled:hover{background-color:inherit}\n"] }]
+        }], propDecorators: { hasOptionItemClass: [{
+                type: HostBinding,
+                args: ['class.optionItem']
+            }], optionTpl: [{
+                type: Input
+            }], isSelected: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['attr.aria-selected']
+            }], option: [{
+                type: Input
+            }], optionIndex: [{
+                type: Input
+            }], scrollIntoViewOptions: [{
+                type: Input
+            }], optionContext: [{
+                type: ViewChild,
+                args: [LuOptionOutletDirective, { read: LU_OPTION_CONTEXT, static: true }]
+            }], role: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], id: [{
+                type: HostBinding,
+                args: ['attr.id']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core-select/option/option.directive.mjs

@@ -0,0 +1,27 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+class LuOptionDirective {
+    set select(select) {
+        select.optionTpl = this.templateRef;
+    }
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+    static ngTemplateContextGuard(_dir, ctx) {
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: LuOptionDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.3", type: LuOptionDirective, isStandalone: true, selector: "[luOption]", inputs: { select: ["luOptionSelect", "select"] }, ngImport: i0 }); }
+}
+export { LuOptionDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: LuOptionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[luOption]',
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; }, propDecorators: { select: [{
+                type: Input,
+                args: ['luOptionSelect']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL25nL2NvcmUtc2VsZWN0L29wdGlvbi9vcHRpb24uZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFlLE1BQU0sZUFBZSxDQUFDOztBQUk5RCxNQUlhLGlCQUFpQjtJQUM3QixJQUE2QixNQUFNLENBQUMsTUFBMkM7UUFDOUUsTUFBTSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDO0lBQ3JDLENBQUM7SUFFRCxZQUEyQixXQUE0QztRQUE1QyxnQkFBVyxHQUFYLFdBQVcsQ0FBaUM7SUFBRyxDQUFDO0lBRXBFLE1BQU0sQ0FBQyxzQkFBc0IsQ0FBSSxJQUEwQixFQUFFLEdBQVk7UUFDL0UsT0FBTyxJQUFJLENBQUM7SUFDYixDQUFDOzhHQVRXLGlCQUFpQjtrR0FBakIsaUJBQWlCOztTQUFqQixpQkFBaUI7MkZBQWpCLGlCQUFpQjtrQkFKN0IsU0FBUzttQkFBQztvQkFDVixRQUFRLEVBQUUsWUFBWTtvQkFDdEIsVUFBVSxFQUFFLElBQUk7aUJBQ2hCO2tHQUU2QixNQUFNO3NCQUFsQyxLQUFLO3VCQUFDLGdCQUFnQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSW5wdXQsIFRlbXBsYXRlUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEFMdVNlbGVjdElucHV0Q29tcG9uZW50IH0gZnJvbSAnLi4vaW5wdXQnO1xyXG5pbXBvcnQgeyBMdU9wdGlvbkNvbnRleHQgfSBmcm9tICcuLi9zZWxlY3QubW9kZWwnO1xyXG5cclxuQERpcmVjdGl2ZSh7XHJcblx0c2VsZWN0b3I6ICdbbHVPcHRpb25dJyxcclxuXHRzdGFuZGFsb25lOiB0cnVlLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgTHVPcHRpb25EaXJlY3RpdmU8VD4ge1xyXG5cdEBJbnB1dCgnbHVPcHRpb25TZWxlY3QnKSBzZXQgc2VsZWN0KHNlbGVjdDogQUx1U2VsZWN0SW5wdXRDb21wb25lbnQ8VCwgdW5rbm93bj4pIHtcclxuXHRcdHNlbGVjdC5vcHRpb25UcGwgPSB0aGlzLnRlbXBsYXRlUmVmO1xyXG5cdH1cclxuXHJcblx0cHVibGljIGNvbnN0cnVjdG9yKHByaXZhdGUgdGVtcGxhdGVSZWY6IFRlbXBsYXRlUmVmPEx1T3B0aW9uQ29udGV4dDxUPj4pIHt9XHJcblxyXG5cdHB1YmxpYyBzdGF0aWMgbmdUZW1wbGF0ZUNvbnRleHRHdWFyZDxUPihfZGlyOiBMdU9wdGlvbkRpcmVjdGl2ZTxUPiwgY3R4OiB1bmtub3duKTogY3R4IGlzIEx1T3B0aW9uQ29udGV4dDxUPiB7XHJcblx0XHRyZXR1cm4gdHJ1ZTtcclxuXHR9XHJcbn1cclxuIl19