@lucca-front/ng 17.2.1 → 17.2.3-backfix

package/core-select/api/api-v3.directive.d.ts

@@ -0,0 +1,25 @@
+import { HttpClient } from '@angular/common/http';
+import { ILuApiItem } from '@lucca-front/ng/api';
+import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
+import { ALuCoreSelectApiDirective } from './api.directive';
+import * as i0 from "@angular/core";
+export declare class LuCoreSelectApiV3Directive<T extends ILuApiItem> extends ALuCoreSelectApiDirective<T> {
+    set apiV3(value: string);
+    set fields(value: string);
+    set orderBy(value: string | null);
+    set filters(value: Record<string, string | number | boolean>);
+    protected url$: ReplaySubject<string>;
+    protected fields$: BehaviorSubject<string>;
+    protected orderBy$: BehaviorSubject<string>;
+    protected filters$: BehaviorSubject<Record<string, string | number | boolean>>;
+    protected httpClient: HttpClient;
+    protected params$: Observable<{
+        name?: string;
+        orderBy?: string;
+        fields: string;
+    }>;
+    protected getOptions(params: Record<string, string | number | boolean>, page: number): Observable<T[]>;
+    protected optionComparer: (a: T, b: T) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuCoreSelectApiV3Directive<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuCoreSelectApiV3Directive<any>, "lu-simple-select[apiV3],lu-multi-select[apiV3]", never, { "apiV3": { "alias": "apiV3"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "orderBy": { "alias": "orderBy"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; }, {}, never, never, true, never>;
+}

package/core-select/api/api-v4.directive.d.ts

@@ -0,0 +1,22 @@
+import { HttpClient } from '@angular/common/http';
+import { ILuApiItem } from '@lucca-front/ng/api';
+import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
+import { ALuCoreSelectApiDirective } from './api.directive';
+import * as i0 from "@angular/core";
+export declare class LuCoreSelectApiV4Directive<T extends ILuApiItem> extends ALuCoreSelectApiDirective<T> {
+    set apiV4(value: string);
+    set sort(value: string | null);
+    set filters(value: Record<string, string | number | boolean>);
+    protected url$: ReplaySubject<string>;
+    protected sort$: BehaviorSubject<string>;
+    protected filters$: BehaviorSubject<Record<string, string | number | boolean>>;
+    protected httpClient: HttpClient;
+    protected params$: Observable<{
+        search?: string;
+        sort?: string;
+    }>;
+    protected getOptions(params: Record<string, string | number | boolean>, page: number): Observable<T[]>;
+    protected optionComparer: (a: T, b: T) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuCoreSelectApiV4Directive<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuCoreSelectApiV4Directive<any>, "lu-simple-select[apiV4],lu-multi-select[apiV4]", never, { "apiV4": { "alias": "apiV4"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; }, {}, never, never, true, never>;
+}

package/core-select/api/api.directive.d.ts

@@ -0,0 +1,31 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { ALuSelectInputComponent } from '@lucca-front/ng/core-select';
+import { Observable, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare const MAGIC_PAGE_SIZE = 20;
+export declare const MAGIC_DEBOUNCE_DURATION = 250;
+export declare abstract class ALuCoreSelectApiDirective<TOption, TParams = Record<string, string | number | boolean>> implements OnDestroy, OnInit {
+    protected destroy$: Subject<void>;
+    protected pageSize: number;
+    protected debounceDuration: number;
+    protected select: ALuSelectInputComponent<TOption, unknown>;
+    protected page$: Observable<number>;
+    protected clue$: Observable<string>;
+    /**
+     * Create an object that will be used as params for the api call
+     */
+    protected abstract params$: Observable<TParams>;
+    /**
+     * Compare two options to know if they are the same. For example, compare by id or by JSON
+     */
+    protected abstract optionComparer: (a: TOption, b: TOption) => boolean;
+    /**
+     * Return the options for the given params and page
+     */
+    protected abstract getOptions(params: TParams, page: number): Observable<TOption[]>;
+    ngOnInit(): void;
+    protected buildOptions(): Observable<TOption[]>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ALuCoreSelectApiDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ALuCoreSelectApiDirective<any, any>, never, never, {}, {}, never, never, false, never>;
+}

package/core-select/api/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@lucca-front/ng/core-select/api" />
+export * from './public-api';

package/core-select/api/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './api-v3.directive';
+export * from './api-v4.directive';
+export { ALuCoreSelectApiDirective } from './api.directive';

package/core-select/input/select-input.component.d.ts

@@ -34,9 +34,9 @@ export declare abstract class ALuSelectInputComponent<TOption, TValue> implement
     clueChanged(clue: string): void;
     protected _value?: TValue;
     options$: ReplaySubject<TOption[]>;
-    loading$: ReplaySubject<boolean>;
+    loading$: BehaviorSubject<boolean>;
     clue: string | null;
-    previousClue: string | null;
+    lastEmittedClue: string;
     protected onChange?: (value: TValue | null) => void;
     protected onTouched?: () => void;
     get panelRef(): LuSelectPanelRef<TOption, TValue> | undefined;
@@ -54,7 +54,7 @@ export declare abstract class ALuSelectInputComponent<TOption, TValue> implement
     ngOnDestroy(): void;
     ngOnInit(): void;
     clearValue(event: Event): void;
-    openPanel(): void;
+    openPanel(clue?: string): void;
     protected abstract buildPanelRef(): this['panelRef'];
     protected bindInputToPanelRefEvents(): void;
     protected focusInput(): void;

package/core-select/option/option.component.d.ts

@@ -3,6 +3,7 @@ import { AfterViewInit, ElementRef, OnDestroy, TemplateRef, Type } from '@angula
 import { BehaviorSubject } from 'rxjs';
 import { LuOptionContext } from '../select.model';
 import * as i0 from "@angular/core";
+export declare const MAGIC_OPTION_SCROLL_DELAY = 15;
 export declare class LuOptionComponent<T> implements Highlightable, AfterViewInit, OnDestroy {
     hasOptionItemClass: boolean;
     optionTpl: TemplateRef<LuOptionContext<T>> | Type<unknown> | undefined;

package/esm2022/core-select/api/api-v3.directive.mjs

@@ -0,0 +1,62 @@
+import { HttpClient } from '@angular/common/http';
+import { Directive, inject, Input } from '@angular/core';
+import { BehaviorSubject, combineLatest, map, ReplaySubject, switchMap, take } from 'rxjs';
+import { ALuCoreSelectApiDirective } from './api.directive';
+import * as i0 from "@angular/core";
+export class LuCoreSelectApiV3Directive extends ALuCoreSelectApiDirective {
+    constructor() {
+        super(...arguments);
+        this.url$ = new ReplaySubject(1);
+        this.fields$ = new BehaviorSubject('id,name');
+        this.orderBy$ = new BehaviorSubject('name,asc');
+        this.filters$ = new BehaviorSubject({});
+        this.httpClient = inject(HttpClient);
+        this.params$ = combineLatest([this.fields$, this.filters$, this.orderBy$, this.clue$]).pipe(map(([fields, filters, orderBy, clue]) => ({
+            ...filters,
+            fields,
+            ...(orderBy ? { orderBy } : {}),
+            ...(clue ? { name: `like,${clue}` } : {}),
+        })));
+        this.optionComparer = (a, b) => a.id === b.id;
+    }
+    set apiV3(value) {
+        this.url$.next(value);
+    }
+    set fields(value) {
+        this.fields$.next(value);
+    }
+    set orderBy(value) {
+        this.orderBy$.next(value);
+    }
+    set filters(value) {
+        this.filters$.next(value);
+    }
+    getOptions(params, page) {
+        return this.url$.pipe(take(1), switchMap((url) => this.httpClient.get(url, {
+            params: {
+                ...params,
+                paging: `${page * this.pageSize},${this.pageSize}`,
+            },
+        })), map((res) => res.data.items));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.2", ngImport: i0, type: LuCoreSelectApiV3Directive, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.2", type: LuCoreSelectApiV3Directive, isStandalone: true, selector: "lu-simple-select[apiV3],lu-multi-select[apiV3]", inputs: { apiV3: "apiV3", fields: "fields", orderBy: "orderBy", filters: "filters" }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.2", ngImport: i0, type: LuCoreSelectApiV3Directive, decorators: [{
+            type: Directive,
+            args: [{
+                    // The attribute is already prefixed with "lu-simple-select"
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'lu-simple-select[apiV3],lu-multi-select[apiV3]',
+                    standalone: true,
+                }]
+        }], propDecorators: { apiV3: [{
+                type: Input
+            }], fields: [{
+                type: Input
+            }], orderBy: [{
+                type: Input
+            }], filters: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLXYzLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL25nL2NvcmUtc2VsZWN0L2FwaS9hcGktdjMuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUNsRCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekQsT0FBTyxFQUFFLGVBQWUsRUFBRSxhQUFhLEVBQUUsR0FBRyxFQUFjLGFBQWEsRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ3ZHLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGlCQUFpQixDQUFDOztBQVE1RCxNQUFNLE9BQU8sMEJBQWlELFNBQVEseUJBQTRCO0lBTmxHOztRQTJCVyxTQUFJLEdBQUcsSUFBSSxhQUFhLENBQVMsQ0FBQyxDQUFDLENBQUM7UUFDcEMsWUFBTyxHQUFHLElBQUksZUFBZSxDQUFTLFNBQVMsQ0FBQyxDQUFDO1FBQ2pELGFBQVEsR0FBRyxJQUFJLGVBQWUsQ0FBZ0IsVUFBVSxDQUFDLENBQUM7UUFDMUQsYUFBUSxHQUFHLElBQUksZUFBZSxDQUE0QyxFQUFFLENBQUMsQ0FBQztRQUU5RSxlQUFVLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBRXZCLFlBQU8sR0FBRyxhQUFhLENBQUMsQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQyxRQUFRLEVBQUUsSUFBSSxDQUFDLFFBQVEsRUFBRSxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQ3hHLEdBQUcsQ0FBQyxDQUFDLENBQUMsTUFBTSxFQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsSUFBSSxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUM7WUFDMUMsR0FBRyxPQUFPO1lBQ1YsTUFBTTtZQUNOLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztZQUMvQixHQUFHLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLElBQUksRUFBRSxRQUFRLElBQUksRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztTQUN6QyxDQUFDLENBQUMsQ0FDSCxDQUFDO1FBaUJpQixtQkFBYyxHQUFHLENBQUMsQ0FBSSxFQUFFLENBQUksRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUMsRUFBRSxDQUFDO0tBQ2xFO0lBcERBLElBQ1csS0FBSyxDQUFDLEtBQWE7UUFDN0IsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDdkIsQ0FBQztJQUVELElBQ1csTUFBTSxDQUFDLEtBQWE7UUFDOUIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDMUIsQ0FBQztJQUVELElBQ1csT0FBTyxDQUFDLEtBQW9CO1FBQ3RDLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzNCLENBQUM7SUFFRCxJQUNXLE9BQU8sQ0FBQyxLQUFnRDtRQUNsRSxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUMzQixDQUFDO0lBa0JrQixVQUFVLENBQUMsTUFBaUQsRUFBRSxJQUFZO1FBQzVGLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQ3BCLElBQUksQ0FBQyxDQUFDLENBQUMsRUFDUCxTQUFTLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUNqQixJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBOEIsR0FBRyxFQUFFO1lBQ3JELE1BQU0sRUFBRTtnQkFDUCxHQUFHLE1BQU07Z0JBQ1QsTUFBTSxFQUFFLEdBQUcsSUFBSSxHQUFHLElBQUksQ0FBQyxRQUFRLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRTthQUNsRDtTQUNELENBQUMsQ0FDRixFQUNELEdBQUcsQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FDNUIsQ0FBQztJQUNILENBQUM7OEdBbERXLDBCQUEwQjtrR0FBMUIsMEJBQTBCOzsyRkFBMUIsMEJBQTBCO2tCQU50QyxTQUFTO21CQUFDO29CQUNWLDREQUE0RDtvQkFDNUQsOERBQThEO29CQUM5RCxRQUFRLEVBQUUsZ0RBQWdEO29CQUMxRCxVQUFVLEVBQUUsSUFBSTtpQkFDaEI7OEJBR1csS0FBSztzQkFEZixLQUFLO2dCQU1LLE1BQU07c0JBRGhCLEtBQUs7Z0JBTUssT0FBTztzQkFEakIsS0FBSztnQkFNSyxPQUFPO3NCQURqQixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSHR0cENsaWVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IERpcmVjdGl2ZSwgaW5qZWN0LCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgSUx1QXBpQ29sbGVjdGlvblJlc3BvbnNlLCBJTHVBcGlJdGVtIH0gZnJvbSAnQGx1Y2NhLWZyb250L25nL2FwaSc7XG5pbXBvcnQgeyBCZWhhdmlvclN1YmplY3QsIGNvbWJpbmVMYXRlc3QsIG1hcCwgT2JzZXJ2YWJsZSwgUmVwbGF5U3ViamVjdCwgc3dpdGNoTWFwLCB0YWtlIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBBTHVDb3JlU2VsZWN0QXBpRGlyZWN0aXZlIH0gZnJvbSAnLi9hcGkuZGlyZWN0aXZlJztcblxuQERpcmVjdGl2ZSh7XG5cdC8vIFRoZSBhdHRyaWJ1dGUgaXMgYWxyZWFkeSBwcmVmaXhlZCB3aXRoIFwibHUtc2ltcGxlLXNlbGVjdFwiXG5cdC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAYW5ndWxhci1lc2xpbnQvZGlyZWN0aXZlLXNlbGVjdG9yXG5cdHNlbGVjdG9yOiAnbHUtc2ltcGxlLXNlbGVjdFthcGlWM10sbHUtbXVsdGktc2VsZWN0W2FwaVYzXScsXG5cdHN0YW5kYWxvbmU6IHRydWUsXG59KVxuZXhwb3J0IGNsYXNzIEx1Q29yZVNlbGVjdEFwaVYzRGlyZWN0aXZlPFQgZXh0ZW5kcyBJTHVBcGlJdGVtPiBleHRlbmRzIEFMdUNvcmVTZWxlY3RBcGlEaXJlY3RpdmU8VD4ge1xuXHRASW5wdXQoKVxuXHRwdWJsaWMgc2V0IGFwaVYzKHZhbHVlOiBzdHJpbmcpIHtcblx0XHR0aGlzLnVybCQubmV4dCh2YWx1ZSk7XG5cdH1cblxuXHRASW5wdXQoKVxuXHRwdWJsaWMgc2V0IGZpZWxkcyh2YWx1ZTogc3RyaW5nKSB7XG5cdFx0dGhpcy5maWVsZHMkLm5leHQodmFsdWUpO1xuXHR9XG5cblx0QElucHV0KClcblx0cHVibGljIHNldCBvcmRlckJ5KHZhbHVlOiBzdHJpbmcgfCBudWxsKSB7XG5cdFx0dGhpcy5vcmRlckJ5JC5uZXh0KHZhbHVlKTtcblx0fVxuXG5cdEBJbnB1dCgpXG5cdHB1YmxpYyBzZXQgZmlsdGVycyh2YWx1ZTogUmVjb3JkPHN0cmluZywgc3RyaW5nIHwgbnVtYmVyIHwgYm9vbGVhbj4pIHtcblx0XHR0aGlzLmZpbHRlcnMkLm5leHQodmFsdWUpO1xuXHR9XG5cblx0cHJvdGVjdGVkIHVybCQgPSBuZXcgUmVwbGF5U3ViamVjdDxzdHJpbmc+KDEpO1xuXHRwcm90ZWN0ZWQgZmllbGRzJCA9IG5ldyBCZWhhdmlvclN1YmplY3Q8c3RyaW5nPignaWQsbmFtZScpO1xuXHRwcm90ZWN0ZWQgb3JkZXJCeSQgPSBuZXcgQmVoYXZpb3JTdWJqZWN0PHN0cmluZyB8IG51bGw+KCduYW1lLGFzYycpO1xuXHRwcm90ZWN0ZWQgZmlsdGVycyQgPSBuZXcgQmVoYXZpb3JTdWJqZWN0PFJlY29yZDxzdHJpbmcsIHN0cmluZyB8IG51bWJlciB8IGJvb2xlYW4+Pih7fSk7XG5cblx0cHJvdGVjdGVkIGh0dHBDbGllbnQgPSBpbmplY3QoSHR0cENsaWVudCk7XG5cblx0cHJvdGVjdGVkIG92ZXJyaWRlIHBhcmFtcyQgPSBjb21iaW5lTGF0ZXN0KFt0aGlzLmZpZWxkcyQsIHRoaXMuZmlsdGVycyQsIHRoaXMub3JkZXJCeSQsIHRoaXMuY2x1ZSRdKS5waXBlKFxuXHRcdG1hcCgoW2ZpZWxkcywgZmlsdGVycywgb3JkZXJCeSwgY2x1ZV0pID0+ICh7XG5cdFx0XHQuLi5maWx0ZXJzLFxuXHRcdFx0ZmllbGRzLFxuXHRcdFx0Li4uKG9yZGVyQnkgPyB7IG9yZGVyQnkgfSA6IHt9KSxcblx0XHRcdC4uLihjbHVlID8geyBuYW1lOiBgbGlrZSwke2NsdWV9YCB9IDoge30pLFxuXHRcdH0pKSxcblx0KTtcblxuXHRwcm90ZWN0ZWQgb3ZlcnJpZGUgZ2V0T3B0aW9ucyhwYXJhbXM6IFJlY29yZDxzdHJpbmcsIHN0cmluZyB8IG51bWJlciB8IGJvb2xlYW4+LCBwYWdlOiBudW1iZXIpOiBPYnNlcnZhYmxlPFRbXT4ge1xuXHRcdHJldHVybiB0aGlzLnVybCQucGlwZShcblx0XHRcdHRha2UoMSksXG5cdFx0XHRzd2l0Y2hNYXAoKHVybCkgPT5cblx0XHRcdFx0dGhpcy5odHRwQ2xpZW50LmdldDxJTHVBcGlDb2xsZWN0aW9uUmVzcG9uc2U8VD4+KHVybCwge1xuXHRcdFx0XHRcdHBhcmFtczoge1xuXHRcdFx0XHRcdFx0Li4ucGFyYW1zLFxuXHRcdFx0XHRcdFx0cGFnaW5nOiBgJHtwYWdlICogdGhpcy5wYWdlU2l6ZX0sJHt0aGlzLnBhZ2VTaXplfWAsXG5cdFx0XHRcdFx0fSxcblx0XHRcdFx0fSksXG5cdFx0XHQpLFxuXHRcdFx0bWFwKChyZXMpID0+IHJlcy5kYXRhLml0ZW1zKSxcblx0XHQpO1xuXHR9XG5cblx0cHJvdGVjdGVkIG92ZXJyaWRlIG9wdGlvbkNvbXBhcmVyID0gKGE6IFQsIGI6IFQpID0+IGEuaWQgPT09IGIuaWQ7XG59XG4iXX0=

package/esm2022/core-select/api/api-v4.directive.mjs

@@ -0,0 +1,56 @@
+import { HttpClient } from '@angular/common/http';
+import { Directive, inject, Input } from '@angular/core';
+import { BehaviorSubject, combineLatest, map, ReplaySubject, switchMap, take } from 'rxjs';
+import { ALuCoreSelectApiDirective } from './api.directive';
+import * as i0 from "@angular/core";
+export class LuCoreSelectApiV4Directive extends ALuCoreSelectApiDirective {
+    constructor() {
+        super(...arguments);
+        this.url$ = new ReplaySubject(1);
+        this.sort$ = new BehaviorSubject('+name');
+        this.filters$ = new BehaviorSubject({});
+        this.httpClient = inject(HttpClient);
+        this.params$ = combineLatest([this.filters$, this.sort$, this.clue$]).pipe(map(([filters, sort, clue]) => ({
+            ...filters,
+            ...(sort ? { sort } : {}),
+            ...(clue ? { search: clue } : {}),
+        })));
+        this.optionComparer = (a, b) => a.id === b.id;
+    }
+    set apiV4(value) {
+        this.url$.next(value);
+    }
+    set sort(value) {
+        this.sort$.next(value);
+    }
+    set filters(value) {
+        this.filters$.next(value);
+    }
+    getOptions(params, page) {
+        return this.url$.pipe(take(1), switchMap((url) => this.httpClient.get(url, {
+            params: {
+                ...params,
+                page: page + 1,
+                limit: this.pageSize,
+            },
+        })), map((res) => (Array.isArray(res) ? res : res?.items) ?? []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.2", ngImport: i0, type: LuCoreSelectApiV4Directive, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.2", type: LuCoreSelectApiV4Directive, isStandalone: true, selector: "lu-simple-select[apiV4],lu-multi-select[apiV4]", inputs: { apiV4: "apiV4", sort: "sort", filters: "filters" }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.2", ngImport: i0, type: LuCoreSelectApiV4Directive, decorators: [{
+            type: Directive,
+            args: [{
+                    // The attribute is already prefixed with "lu-simple-select"
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'lu-simple-select[apiV4],lu-multi-select[apiV4]',
+                    standalone: true,
+                }]
+        }], propDecorators: { apiV4: [{
+                type: Input
+            }], sort: [{
+                type: Input
+            }], filters: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,46 @@
+import { Directive, inject } from '@angular/core';
+import { ALuSelectInputComponent } from '@lucca-front/ng/core-select';
+import { catchError, combineLatest, concatMap, debounceTime, distinctUntilChanged, map, merge, of, pairwise, scan, startWith, Subject, switchMap, takeUntil, takeWhile, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+export const MAGIC_PAGE_SIZE = 20;
+export const MAGIC_DEBOUNCE_DURATION = 250;
+export class ALuCoreSelectApiDirective {
+    constructor() {
+        this.destroy$ = new Subject();
+        this.pageSize = MAGIC_PAGE_SIZE;
+        this.debounceDuration = MAGIC_DEBOUNCE_DURATION;
+        this.select = inject(ALuSelectInputComponent);
+        this.page$ = this.select.nextPage.pipe(scan((page) => page + 1, 0), startWith(0));
+        this.clue$ = this.select.clueChange.pipe(debounceTime(this.debounceDuration), startWith(''));
+    }
+    ngOnInit() {
+        this.select.optionComparer = this.optionComparer;
+        this.buildOptions().pipe(takeUntil(this.destroy$)).subscribe(this.select.options$);
+    }
+    buildOptions() {
+        // Prevent a double call to getOptions when the clue is changed while the panel is closed
+        const clueIsPendingDebounce$ = merge(this.select.clueChange.pipe(map(() => true)), this.clue$.pipe(map(() => false))).pipe(distinctUntilChanged());
+        const isOpen$ = combineLatest([this.select.isPanelOpen$, clueIsPendingDebounce$]).pipe(debounceTime(0), startWith([false, false]), pairwise(), tap(([[wasOpen], [isOpen, clueIsPendingDebounce]]) => {
+            // Start the loader as soon as the panel is opened to avoid a short display of the "no result" message
+            if (!wasOpen && isOpen && clueIsPendingDebounce) {
+                this.select.loading = true;
+            }
+        }), map(([[wasOpen], [isOpen, clueIsPendingDebounce]]) => (isOpen && !wasOpen ? !clueIsPendingDebounce : isOpen)), distinctUntilChanged());
+        return combineLatest([this.params$, isOpen$]).pipe(switchMap(([params, isOpened]) => isOpened
+            ? this.page$.pipe(concatMap((page) => {
+                this.select.loading = true;
+                return this.getOptions(params, page).pipe(catchError(() => of([])), tap(() => (this.select.loading = false)));
+            }), takeWhile((items) => items.length === this.pageSize, true), scan((acc, items) => [...acc, ...items], []))
+            : of([])));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.2", ngImport: i0, type: ALuCoreSelectApiDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.2", type: ALuCoreSelectApiDirective, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.2", ngImport: i0, type: ALuCoreSelectApiDirective, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.directive.js","sourceRoot":"","sources":["../../../../../packages/ng/core-select/api/api.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, inject, OnDestroy, OnInit } from '@angular/core';\nimport { ALuSelectInputComponent } from '@lucca-front/ng/core-select';\nimport { catchError, combineLatest, concatMap, debounceTime, distinctUntilChanged, map, merge, Observable, of, pairwise, scan, startWith, Subject, switchMap, takeUntil, takeWhile, tap } from 'rxjs';\n\nexport const MAGIC_PAGE_SIZE = 20;\nexport const MAGIC_DEBOUNCE_DURATION = 250;\n\n@Directive()\nexport abstract class ALuCoreSelectApiDirective<TOption, TParams = Record<string, string | number | boolean>> implements OnDestroy, OnInit {\n\tprotected destroy$ = new Subject<void>();\n\tprotected pageSize = MAGIC_PAGE_SIZE;\n\tprotected debounceDuration = MAGIC_DEBOUNCE_DURATION;\n\n\tprotected select = inject<ALuSelectInputComponent<TOption, unknown>>(ALuSelectInputComponent);\n\n\tprotected page$ = this.select.nextPage.pipe(\n\t\tscan((page) => page + 1, 0),\n\t\tstartWith(0),\n\t);\n\n\tprotected clue$ = this.select.clueChange.pipe(debounceTime(this.debounceDuration), startWith(''));\n\n\t/**\n\t * Create an object that will be used as params for the api call\n\t */\n\tprotected abstract params$: Observable<TParams>;\n\n\t/**\n\t * Compare two options to know if they are the same. For example, compare by id or by JSON\n\t */\n\tprotected abstract optionComparer: (a: TOption, b: TOption) => boolean;\n\n\t/**\n\t * Return the options for the given params and page\n\t */\n\tprotected abstract getOptions(params: TParams, page: number): Observable<TOption[]>;\n\n\tpublic ngOnInit(): void {\n\t\tthis.select.optionComparer = this.optionComparer;\n\t\tthis.buildOptions().pipe(takeUntil(this.destroy$)).subscribe(this.select.options$);\n\t}\n\n\tprotected buildOptions(): Observable<TOption[]> {\n\t\t// Prevent a double call to getOptions when the clue is changed while the panel is closed\n\t\tconst clueIsPendingDebounce$ = merge(this.select.clueChange.pipe(map(() => true)), this.clue$.pipe(map(() => false))).pipe(distinctUntilChanged());\n\t\tconst isOpen$ = combineLatest([this.select.isPanelOpen$, clueIsPendingDebounce$]).pipe(\n\t\t\tdebounceTime(0),\n\t\t\tstartWith([false, false]),\n\t\t\tpairwise(),\n\t\t\ttap(([[wasOpen], [isOpen, clueIsPendingDebounce]]) => {\n\t\t\t\t// Start the loader as soon as the panel is opened to avoid a short display of the \"no result\" message\n\t\t\t\tif (!wasOpen && isOpen && clueIsPendingDebounce) {\n\t\t\t\t\tthis.select.loading = true;\n\t\t\t\t}\n\t\t\t}),\n\t\t\tmap(([[wasOpen], [isOpen, clueIsPendingDebounce]]) => (isOpen && !wasOpen ? !clueIsPendingDebounce : isOpen)),\n\t\t\tdistinctUntilChanged(),\n\t\t);\n\n\t\treturn combineLatest([this.params$, isOpen$]).pipe(\n\t\t\tswitchMap(([params, isOpened]) =>\n\t\t\t\tisOpened\n\t\t\t\t\t? this.page$.pipe(\n\t\t\t\t\t\t\tconcatMap((page) => {\n\t\t\t\t\t\t\t\tthis.select.loading = true;\n\t\t\t\t\t\t\t\treturn this.getOptions(params, page).pipe(\n\t\t\t\t\t\t\t\t\tcatchError(() => of([] as TOption[])),\n\t\t\t\t\t\t\t\t\ttap(() => (this.select.loading = false)),\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\ttakeWhile((items) => items.length === this.pageSize, true),\n\t\t\t\t\t\t\tscan((acc, items) => [...acc, ...items], [] as TOption[]),\n\t\t\t\t\t  )\n\t\t\t\t\t: of([] as TOption[]),\n\t\t\t),\n\t\t);\n\t}\n\n\tpublic ngOnDestroy(): void {\n\t\tthis.destroy$.next();\n\t\tthis.destroy$.complete();\n\t}\n}\n"]}

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

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

package/esm2022/core-select/api/public-api.mjs

@@ -0,0 +1,4 @@
+export * from './api-v3.directive';
+export * from './api-v4.directive';
+export { ALuCoreSelectApiDirective } from './api.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL25nL2NvcmUtc2VsZWN0L2FwaS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXBpLXYzLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2FwaS12NC5kaXJlY3RpdmUnO1xuZXhwb3J0IHsgQUx1Q29yZVNlbGVjdEFwaURpcmVjdGl2ZSB9IGZyb20gJy4vYXBpLmRpcmVjdGl2ZSc7XG4iXX0=

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

@@ -22,10 +22,10 @@ export class ALuSelectInputComponent {
         this.nextPage = new EventEmitter();
         this.previousPage = new EventEmitter();
         this.options$ = new ReplaySubject(1);
-        this.loading$ = new ReplaySubject(1);
+        this.loading$ = new BehaviorSubject(false);
         this.clue = null;
         // This is the clue stored after we selected an option to know if we should emit an empty clue on open or not
-        this.previousClue = null;
+        this.lastEmittedClue = '';
         this.destroyed$ = new Subject();
         this.changeDetectorRef = inject(ChangeDetectorRef);
         this.overlayContainerRef = inject(OverlayContainer).getContainerElement();
@@ -48,7 +48,9 @@ export class ALuSelectInputComponent {
         return this.overlayContainerRef.id;
     }
     set loading(value) {
-        this.loading$.next(value);
+        if (value !== this.loading) {
+            this.loading$.next(value);
+        }
     }
     set options(options) {
         this.options$.next(options);
@@ -64,9 +66,12 @@ export class ALuSelectInputComponent {
         return this.value ? null : this.placeholder;
     }
     clueChanged(clue) {
-        this.clueChange.emit(clue);
         if (!this.isPanelOpen) {
-            this.openPanel();
+            this.openPanel(clue);
+        }
+        else if (this.lastEmittedClue !== clue) {
+            this.clueChange.emit(clue);
+            this.lastEmittedClue = clue;
         }
     }
     get panelRef() {
@@ -132,15 +137,12 @@ export class ALuSelectInputComponent {
         this.updateValue(null);
         this.inputElementRef.nativeElement.focus();
     }
-    openPanel() {
+    openPanel(clue = '') {
         if (this.isPanelOpen || this.disabled) {
             return;
         }
         this.isPanelOpen$.next(true);
-        if (this.previousClue) {
-            this.clueChanged('');
-            this.previousClue = null;
-        }
+        this.clueChanged(clue);
         this._panelRef = this.buildPanelRef();
         this.bindInputToPanelRefEvents();
         setTimeout(() => this.focusInput());
@@ -165,7 +167,6 @@ export class ALuSelectInputComponent {
     }
     emptyClue() {
         if (this.clue) {
-            this.previousClue = this.clue;
             this.clue = null;
         }
     }
@@ -243,4 +244,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.2", ngImpor
                 type: HostListener,
                 args: ['keydown', ['$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 */\nimport { OverlayConfig, OverlayContainer } from '@angular/cdk/overlay';\nimport {\n\tChangeDetectorRef,\n\tContentChild,\n\tDirective,\n\tElementRef,\n\tEventEmitter,\n\tHostBinding,\n\tHostListener,\n\tInput,\n\tOnDestroy,\n\tOnInit,\n\tOutput,\n\tTemplateRef,\n\tType,\n\tViewChild,\n\tbooleanAttribute,\n\tinject,\n} from '@angular/core';\nimport { BehaviorSubject, ReplaySubject, Subject } from 'rxjs';\nimport { LuOptionGroupDirective, LuSimpleSelectDefaultOptionComponent } from '../option';\nimport { LuSelectPanelRef } from '../panel';\nimport { LuOptionContext, SELECT_LABEL, SELECT_LABEL_ID } from '../select.model';\n\n@Directive()\nexport abstract class ALuSelectInputComponent<TOption, TValue> implements OnDestroy, OnInit {\n\t@ViewChild('inputElement')\n\tprivate inputElementRef: ElementRef<HTMLInputElement>;\n\n\t@Input() placeholder = '';\n\n\t@Input({ transform: booleanAttribute })\n\t@HostBinding('class.is-clearable')\n\tclearable = false;\n\n\tget searchable(): boolean {\n\t\treturn this.clueChange.observed;\n\t}\n\n\t@Input({ transform: booleanAttribute })\n\tdisabled = false;\n\n\t@HostBinding('class.is-selected')\n\tprotected get isSelectedClass(): boolean {\n\t\treturn this.hasValue;\n\t}\n\n\t@HostBinding('class.is-searchFilled')\n\tprotected get isSearchFilledClass(): boolean {\n\t\treturn this.clue?.length > 0;\n\t}\n\n\tprotected abstract readonly hasValue: boolean;\n\n\tpublic get isPanelOpen(): boolean {\n\t\treturn this.isPanelOpen$.value;\n\t}\n\n\tpublic isPanelOpen$ = new BehaviorSubject(false);\n\n\tpublic activeDescendant$ = new BehaviorSubject('');\n\n\tget ariaControls(): string {\n\t\treturn this.overlayContainerRef.id;\n\t}\n\n\t@Input()\n\toverlayConfig?: OverlayConfig = {\n\t\thasBackdrop: true,\n\t\tbackdropClass: 'cdk-overlay-transparent-backdrop',\n\t};\n\n\t@Input() set loading(value: boolean) {\n\t\tthis.loading$.next(value);\n\t}\n\n\t@Input() set options(options: TOption[]) {\n\t\tthis.options$.next(options);\n\t}\n\n\t@Input() optionComparer: (option1: TOption, option2: TOption) => boolean = (option1, option2) => JSON.stringify(option1) === JSON.stringify(option2);\n\t@Input() optionTpl?: TemplateRef<LuOptionContext<TOption>> | Type<unknown> = LuSimpleSelectDefaultOptionComponent;\n\t@Input() valueTpl?: TemplateRef<LuOptionContext<TOption>> | Type<unknown>;\n\t@ContentChild(LuOptionGroupDirective) grouping?: LuOptionGroupDirective<TOption, TValue, unknown>;\n\n\t@Output() clueChange = new EventEmitter<string>();\n\t@Output() nextPage = new EventEmitter<void>();\n\t@Output() previousPage = new EventEmitter<void>();\n\n\tpublic get value(): TValue {\n\t\treturn this._value;\n\t}\n\n\tprotected set value(value: TValue) {\n\t\tthis._value = value;\n\t\tthis.changeDetectorRef.markForCheck();\n\t}\n\n\tpublic get inputPlaceholder(): string | null {\n\t\treturn this.value ? null : this.placeholder;\n\t}\n\n\tpublic clueChanged(clue: string): void {\n\t\tthis.clueChange.emit(clue);\n\t\tif (!this.isPanelOpen) {\n\t\t\tthis.openPanel();\n\t\t}\n\t}\n\n\tprotected _value?: TValue;\n\n\toptions$ = new ReplaySubject<TOption[]>(1);\n\tloading$ = new ReplaySubject<boolean>(1);\n\tclue: string | null = null;\n\t// This is the clue stored after we selected an option to know if we should emit an empty clue on open or not\n\tpreviousClue: string | null = null;\n\n\tprotected onChange?: (value: TValue | null) => void;\n\tprotected onTouched?: () => void;\n\n\tpublic get panelRef(): LuSelectPanelRef<TOption, TValue> | undefined {\n\t\treturn this._panelRef;\n\t}\n\n\tprotected _panelRef?: LuSelectPanelRef<TOption, TValue>;\n\n\tprotected destroyed$ = new Subject<void>();\n\n\t@HostListener('click', ['$event'])\n\tonClickOpenPanel($event: KeyboardEvent) {\n\t\tif (!this.isPanelOpen) {\n\t\t\tthis.openPanel();\n\t\t\t$event.stopPropagation();\n\t\t\t$event.preventDefault();\n\t\t}\n\t}\n\n\t@HostListener('keydown', ['$event'])\n\tonKeyDownNavigation($event: KeyboardEvent): void {\n\t\tswitch ($event.key) {\n\t\t\tcase 'Escape':\n\t\t\tcase 'Tab':\n\t\t\t\tthis.panelRef?.close();\n\t\t\t\tbreak;\n\t\t\tcase 'Enter':\n\t\t\t\tif (this.isPanelOpen) {\n\t\t\t\t\tthis.panelRef.selectCurrentlyHighlightedValue();\n\t\t\t\t} else {\n\t\t\t\t\tthis.panelRef?.handleKeyManagerEvent($event);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase 'Space':\n\t\t\tcase 'ArrowDown':\n\t\t\tcase 'ArrowUp':\n\t\t\t\tif (this.isPanelOpen) {\n\t\t\t\t\tthis.panelRef?.handleKeyManagerEvent($event);\n\t\t\t\t} else {\n\t\t\t\t\tthis.openPanel();\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthis.panelRef?.handleKeyManagerEvent($event);\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\tprotected changeDetectorRef = inject(ChangeDetectorRef);\n\tprotected overlayContainerRef: HTMLElement = inject(OverlayContainer).getContainerElement();\n\n\tprotected labelElement: HTMLElement | undefined = inject(SELECT_LABEL);\n\tprotected labelId: string = inject(SELECT_LABEL_ID);\n\n\tregisterOnChange(onChange: (value: TValue) => void): void {\n\t\tthis.onChange = onChange;\n\t}\n\n\tregisterOnTouched(onTouched: () => void): void {\n\t\tthis.onTouched = onTouched;\n\t}\n\n\tsetDisabledState(isDisabled: boolean): void {\n\t\tthis.disabled = isDisabled;\n\t}\n\n\tngOnDestroy(): void {\n\t\tthis.closePanel();\n\t\tthis.destroyed$.next();\n\t\tthis.destroyed$.complete();\n\t}\n\n\tngOnInit(): void {\n\t\tif (this.labelElement) {\n\t\t\tthis.labelElement.id = this.labelId;\n\t\t}\n\t}\n\n\tclearValue(event: Event): void {\n\t\tevent.stopPropagation();\n\t\tthis.updateValue(null);\n\t\tthis.inputElementRef.nativeElement.focus();\n\t}\n\n\topenPanel(): void {\n\t\tif (this.isPanelOpen || this.disabled) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis.isPanelOpen$.next(true);\n\t\tif (this.previousClue) {\n\t\t\tthis.clueChanged('');\n\t\t\tthis.previousClue = null;\n\t\t}\n\t\tthis._panelRef = this.buildPanelRef();\n\t\tthis.bindInputToPanelRefEvents();\n\t\tsetTimeout(() => this.focusInput());\n\t}\n\n\tprotected abstract buildPanelRef(): this['panelRef'];\n\n\tprotected bindInputToPanelRefEvents(): void {\n\t\tif (!this.panelRef) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis.panelRef.valueChanged.subscribe((value) => this.updateValue(value));\n\t\tthis.panelRef.nextPage.subscribe(() => this.nextPage.emit());\n\t\tthis.panelRef.previousPage.subscribe(() => this.previousPage.emit());\n\t\tthis.panelRef.activeOptionIdChanged.subscribe((optionId) => {\n\t\t\tthis.activeDescendant$.next(optionId);\n\t\t\tthis.changeDetectorRef.markForCheck();\n\t\t});\n\t\tthis.panelRef.closed.subscribe(() => this.closePanel());\n\t}\n\n\tprotected focusInput(): void {\n\t\tif (this.inputElementRef) {\n\t\t\tthis.inputElementRef.nativeElement.focus();\n\t\t}\n\t}\n\n\tprotected emptyClue(): void {\n\t\tif (this.clue) {\n\t\t\tthis.previousClue = this.clue;\n\t\t\tthis.clue = null;\n\t\t}\n\t}\n\n\tpublic closePanel(): void {\n\t\tif (!this.isPanelOpen) {\n\t\t\treturn;\n\t\t}\n\t\tthis.emptyClue();\n\t\tthis.activeDescendant$.next('');\n\t\tthis.changeDetectorRef.markForCheck();\n\t\tthis.onTouched?.();\n\t\tthis.isPanelOpen$.next(false);\n\t\tthis.panelRef.close();\n\t\tthis._panelRef = undefined;\n\t}\n\n\tpublic writeValue(value: TValue): void {\n\t\tthis.value = value;\n\t}\n\n\tpublic updateValue(value: TValue): void {\n\t\tthis.value = value;\n\t\tthis.emptyClue();\n\t\tthis.onChange?.(value);\n\t\tthis.onTouched?.();\n\t}\n}\n"]}
+//# 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 */\nimport { OverlayConfig, OverlayContainer } from '@angular/cdk/overlay';\nimport {\n\tChangeDetectorRef,\n\tContentChild,\n\tDirective,\n\tElementRef,\n\tEventEmitter,\n\tHostBinding,\n\tHostListener,\n\tInput,\n\tOnDestroy,\n\tOnInit,\n\tOutput,\n\tTemplateRef,\n\tType,\n\tViewChild,\n\tbooleanAttribute,\n\tinject,\n} from '@angular/core';\nimport { BehaviorSubject, ReplaySubject, Subject } from 'rxjs';\nimport { LuOptionGroupDirective, LuSimpleSelectDefaultOptionComponent } from '../option';\nimport { LuSelectPanelRef } from '../panel';\nimport { LuOptionContext, SELECT_LABEL, SELECT_LABEL_ID } from '../select.model';\n\n@Directive()\nexport abstract class ALuSelectInputComponent<TOption, TValue> implements OnDestroy, OnInit {\n\t@ViewChild('inputElement')\n\tprivate inputElementRef: ElementRef<HTMLInputElement>;\n\n\t@Input() placeholder = '';\n\n\t@Input({ transform: booleanAttribute })\n\t@HostBinding('class.is-clearable')\n\tclearable = false;\n\n\tget searchable(): boolean {\n\t\treturn this.clueChange.observed;\n\t}\n\n\t@Input({ transform: booleanAttribute })\n\tdisabled = false;\n\n\t@HostBinding('class.is-selected')\n\tprotected get isSelectedClass(): boolean {\n\t\treturn this.hasValue;\n\t}\n\n\t@HostBinding('class.is-searchFilled')\n\tprotected get isSearchFilledClass(): boolean {\n\t\treturn this.clue?.length > 0;\n\t}\n\n\tprotected abstract readonly hasValue: boolean;\n\n\tpublic get isPanelOpen(): boolean {\n\t\treturn this.isPanelOpen$.value;\n\t}\n\n\tpublic isPanelOpen$ = new BehaviorSubject(false);\n\n\tpublic activeDescendant$ = new BehaviorSubject('');\n\n\tget ariaControls(): string {\n\t\treturn this.overlayContainerRef.id;\n\t}\n\n\t@Input()\n\toverlayConfig?: OverlayConfig = {\n\t\thasBackdrop: true,\n\t\tbackdropClass: 'cdk-overlay-transparent-backdrop',\n\t};\n\n\t@Input() set loading(value: boolean) {\n\t\tif (value !== this.loading) {\n\t\t\tthis.loading$.next(value);\n\t\t}\n\t}\n\n\t@Input() set options(options: TOption[]) {\n\t\tthis.options$.next(options);\n\t}\n\n\t@Input() optionComparer: (option1: TOption, option2: TOption) => boolean = (option1, option2) => JSON.stringify(option1) === JSON.stringify(option2);\n\t@Input() optionTpl?: TemplateRef<LuOptionContext<TOption>> | Type<unknown> = LuSimpleSelectDefaultOptionComponent;\n\t@Input() valueTpl?: TemplateRef<LuOptionContext<TOption>> | Type<unknown>;\n\t@ContentChild(LuOptionGroupDirective) grouping?: LuOptionGroupDirective<TOption, TValue, unknown>;\n\n\t@Output() clueChange = new EventEmitter<string>();\n\t@Output() nextPage = new EventEmitter<void>();\n\t@Output() previousPage = new EventEmitter<void>();\n\n\tpublic get value(): TValue {\n\t\treturn this._value;\n\t}\n\n\tprotected set value(value: TValue) {\n\t\tthis._value = value;\n\t\tthis.changeDetectorRef.markForCheck();\n\t}\n\n\tpublic get inputPlaceholder(): string | null {\n\t\treturn this.value ? null : this.placeholder;\n\t}\n\n\tpublic clueChanged(clue: string): void {\n\t\tif (!this.isPanelOpen) {\n\t\t\tthis.openPanel(clue);\n\t\t} else if (this.lastEmittedClue !== clue) {\n\t\t\tthis.clueChange.emit(clue);\n\t\t\tthis.lastEmittedClue = clue;\n\t\t}\n\t}\n\n\tprotected _value?: TValue;\n\n\toptions$ = new ReplaySubject<TOption[]>(1);\n\tloading$ = new BehaviorSubject(false);\n\tclue: string | null = null;\n\t// This is the clue stored after we selected an option to know if we should emit an empty clue on open or not\n\tlastEmittedClue: string = '';\n\n\tprotected onChange?: (value: TValue | null) => void;\n\tprotected onTouched?: () => void;\n\n\tpublic get panelRef(): LuSelectPanelRef<TOption, TValue> | undefined {\n\t\treturn this._panelRef;\n\t}\n\n\tprotected _panelRef?: LuSelectPanelRef<TOption, TValue>;\n\n\tprotected destroyed$ = new Subject<void>();\n\n\t@HostListener('click', ['$event'])\n\tonClickOpenPanel($event: KeyboardEvent) {\n\t\tif (!this.isPanelOpen) {\n\t\t\tthis.openPanel();\n\t\t\t$event.stopPropagation();\n\t\t\t$event.preventDefault();\n\t\t}\n\t}\n\n\t@HostListener('keydown', ['$event'])\n\tonKeyDownNavigation($event: KeyboardEvent): void {\n\t\tswitch ($event.key) {\n\t\t\tcase 'Escape':\n\t\t\tcase 'Tab':\n\t\t\t\tthis.panelRef?.close();\n\t\t\t\tbreak;\n\t\t\tcase 'Enter':\n\t\t\t\tif (this.isPanelOpen) {\n\t\t\t\t\tthis.panelRef.selectCurrentlyHighlightedValue();\n\t\t\t\t} else {\n\t\t\t\t\tthis.panelRef?.handleKeyManagerEvent($event);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase 'Space':\n\t\t\tcase 'ArrowDown':\n\t\t\tcase 'ArrowUp':\n\t\t\t\tif (this.isPanelOpen) {\n\t\t\t\t\tthis.panelRef?.handleKeyManagerEvent($event);\n\t\t\t\t} else {\n\t\t\t\t\tthis.openPanel();\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthis.panelRef?.handleKeyManagerEvent($event);\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\tprotected changeDetectorRef = inject(ChangeDetectorRef);\n\tprotected overlayContainerRef: HTMLElement = inject(OverlayContainer).getContainerElement();\n\n\tprotected labelElement: HTMLElement | undefined = inject(SELECT_LABEL);\n\tprotected labelId: string = inject(SELECT_LABEL_ID);\n\n\tregisterOnChange(onChange: (value: TValue) => void): void {\n\t\tthis.onChange = onChange;\n\t}\n\n\tregisterOnTouched(onTouched: () => void): void {\n\t\tthis.onTouched = onTouched;\n\t}\n\n\tsetDisabledState(isDisabled: boolean): void {\n\t\tthis.disabled = isDisabled;\n\t}\n\n\tngOnDestroy(): void {\n\t\tthis.closePanel();\n\t\tthis.destroyed$.next();\n\t\tthis.destroyed$.complete();\n\t}\n\n\tngOnInit(): void {\n\t\tif (this.labelElement) {\n\t\t\tthis.labelElement.id = this.labelId;\n\t\t}\n\t}\n\n\tclearValue(event: Event): void {\n\t\tevent.stopPropagation();\n\t\tthis.updateValue(null);\n\t\tthis.inputElementRef.nativeElement.focus();\n\t}\n\n\topenPanel(clue: string = ''): void {\n\t\tif (this.isPanelOpen || this.disabled) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis.isPanelOpen$.next(true);\n\t\tthis.clueChanged(clue);\n\t\tthis._panelRef = this.buildPanelRef();\n\t\tthis.bindInputToPanelRefEvents();\n\t\tsetTimeout(() => this.focusInput());\n\t}\n\n\tprotected abstract buildPanelRef(): this['panelRef'];\n\n\tprotected bindInputToPanelRefEvents(): void {\n\t\tif (!this.panelRef) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis.panelRef.valueChanged.subscribe((value) => this.updateValue(value));\n\t\tthis.panelRef.nextPage.subscribe(() => this.nextPage.emit());\n\t\tthis.panelRef.previousPage.subscribe(() => this.previousPage.emit());\n\t\tthis.panelRef.activeOptionIdChanged.subscribe((optionId) => {\n\t\t\tthis.activeDescendant$.next(optionId);\n\t\t\tthis.changeDetectorRef.markForCheck();\n\t\t});\n\t\tthis.panelRef.closed.subscribe(() => this.closePanel());\n\t}\n\n\tprotected focusInput(): void {\n\t\tif (this.inputElementRef) {\n\t\t\tthis.inputElementRef.nativeElement.focus();\n\t\t}\n\t}\n\n\tprotected emptyClue(): void {\n\t\tif (this.clue) {\n\t\t\tthis.clue = null;\n\t\t}\n\t}\n\n\tpublic closePanel(): void {\n\t\tif (!this.isPanelOpen) {\n\t\t\treturn;\n\t\t}\n\t\tthis.emptyClue();\n\t\tthis.activeDescendant$.next('');\n\t\tthis.changeDetectorRef.markForCheck();\n\t\tthis.onTouched?.();\n\t\tthis.isPanelOpen$.next(false);\n\t\tthis.panelRef.close();\n\t\tthis._panelRef = undefined;\n\t}\n\n\tpublic writeValue(value: TValue): void {\n\t\tthis.value = value;\n\t}\n\n\tpublic updateValue(value: TValue): void {\n\t\tthis.value = value;\n\t\tthis.emptyClue();\n\t\tthis.onChange?.(value);\n\t\tthis.onTouched?.();\n\t}\n}\n"]}