@ecodev/natural 41.3.0 → 42.2.0

package/esm2020/lib/modules/search/search.module.mjs

@@ -0,0 +1,84 @@
+import { OverlayModule } from '@angular/cdk/overlay';
+import { PortalModule } from '@angular/cdk/portal';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { MatRippleModule } from '@angular/material/core';
+import { MAT_FORM_FIELD_DEFAULT_OPTIONS } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { MatListModule } from '@angular/material/list';
+import { MatMenuModule } from '@angular/material/menu';
+import { NaturalIconModule } from '../icon/icon.module';
+import { NaturalDropdownContainerComponent } from './dropdown-container/dropdown-container.component';
+import { FacetSelectorComponent } from './facet-selector/facet-selector.component';
+import { NaturalGroupComponent } from './group/group.component';
+import { NaturalInputComponent } from './input/input.component';
+import { NaturalSearchComponent } from './search/search.component';
+import * as i0 from "@angular/core";
+export class NaturalSearchModule {
+}
+NaturalSearchModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalSearchModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NaturalSearchModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalSearchModule, declarations: [NaturalSearchComponent,
+        NaturalGroupComponent,
+        NaturalInputComponent,
+        NaturalDropdownContainerComponent,
+        FacetSelectorComponent], imports: [CommonModule,
+        ReactiveFormsModule,
+        MatInputModule,
+        MatButtonModule,
+        MatMenuModule,
+        MatRippleModule,
+        PortalModule,
+        OverlayModule,
+        MatListModule,
+        NaturalIconModule], exports: [NaturalSearchComponent] });
+NaturalSearchModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalSearchModule, providers: [
+        {
+            provide: MAT_FORM_FIELD_DEFAULT_OPTIONS,
+            useValue: { appearance: 'fill' },
+        },
+    ], imports: [[
+            CommonModule,
+            ReactiveFormsModule,
+            MatInputModule,
+            MatButtonModule,
+            MatMenuModule,
+            MatRippleModule,
+            PortalModule,
+            OverlayModule,
+            MatListModule,
+            NaturalIconModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalSearchModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        NaturalSearchComponent,
+                        NaturalGroupComponent,
+                        NaturalInputComponent,
+                        NaturalDropdownContainerComponent,
+                        FacetSelectorComponent,
+                    ],
+                    exports: [NaturalSearchComponent],
+                    imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        MatInputModule,
+                        MatButtonModule,
+                        MatMenuModule,
+                        MatRippleModule,
+                        PortalModule,
+                        OverlayModule,
+                        MatListModule,
+                        NaturalIconModule,
+                    ],
+                    providers: [
+                        {
+                            provide: MAT_FORM_FIELD_DEFAULT_OPTIONS,
+                            useValue: { appearance: 'fill' },
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/select/abstract-select.component.mjs

@@ -0,0 +1,186 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Directive, EventEmitter, Input, Optional, Output, Self } from '@angular/core';
+import { FormControl, FormControlDirective, FormControlName, Validators, } from '@angular/forms';
+import { ErrorStateMatcher } from '@angular/material/core';
+import { NaturalAbstractController } from '../../classes/abstract-controller';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+/**
+ * This will completely ignore internal formControl and instead use the one from the component
+ * which comes from outside of this component. This basically allows us to **not** depend on
+ * touched status propagation between outside and inside world, and thus get rid of our legacy
+ * custom FormControl class ("NaturalFormControl").
+ */
+class ExternalFormControlMatcher extends ErrorStateMatcher {
+    constructor(component) {
+        super();
+        this.component = component;
+    }
+    isErrorState(control, form) {
+        const externalCtrl = this.component.ngControl?.control || this.component.internalCtrl;
+        if (externalCtrl) {
+            return !!(externalCtrl.errors && (externalCtrl.touched || externalCtrl.dirty));
+        }
+        return false;
+    }
+}
+export class AbstractSelect extends NaturalAbstractController {
+    constructor(ngControl) {
+        super();
+        this.ngControl = ngControl;
+        this.floatPlaceholder = 'auto';
+        /**
+         * Whether to show the search icon
+         */
+        this.showIcon = true;
+        /**
+         * Icon name
+         */
+        this.icon = 'search';
+        /**
+         * Emit the selected value whenever it changes
+         */
+        this.selectionChange = new EventEmitter();
+        /**
+         * Emits when internal input is blurred
+         */
+        // eslint-disable-next-line @angular-eslint/no-output-native
+        this.blur = new EventEmitter();
+        /**
+         * Contains internal representation for current selection.
+         *
+         * It is **not** necessarily `V | null`.
+         *
+         * - NaturalSelectComponent: `string | V | null`. We allow `string`
+         *   only when `optionRequired` is false, so most of the time it is `V | null`.
+         * - NaturalSelectHierarchicComponent: `string | null`.
+         * - NaturalSelectEnumComponent: `V | null`.
+         */
+        this.internalCtrl = new FormControl();
+        if (this.ngControl) {
+            this.ngControl.valueAccessor = this;
+        }
+        this.matcher = new ExternalFormControlMatcher(this);
+    }
+    /**
+     * If the field is required
+     */
+    set required(value) {
+        this._required = coerceBooleanProperty(value);
+        this.applyRequired();
+    }
+    get required() {
+        return !!this._required;
+    }
+    ngDoCheck() {
+        if (this.ngControl) {
+            this.applyRequired();
+        }
+    }
+    writeValue(value) {
+        this.internalCtrl.setValue(value);
+    }
+    ngOnInit() {
+        const isReactive = this.ngControl instanceof FormControlDirective || this.ngControl instanceof FormControlName;
+        if (isReactive && typeof this._required !== 'undefined') {
+            console.warn('<natural-select-*> should not be used as ReactiveForm and with the [required] attribute');
+        }
+    }
+    /**
+     * Whether the value can be changed
+     */
+    set disabled(disabled) {
+        disabled ? this.internalCtrl.disable() : this.internalCtrl.enable();
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    clear(emitEvent = true) {
+        // Empty input
+        this.internalCtrl.setValue(null, { emitEvent: emitEvent });
+        // propagateValue change
+        if (emitEvent) {
+            this.propagateValue(null);
+        }
+    }
+    propagateValue(value) {
+        // before selectionChange to allow formControl to update before change is effectively emitted
+        if (this.onChange) {
+            this.onChange(value);
+        }
+        this.selectionChange.emit(value);
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    showClearButton() {
+        return this.internalCtrl?.enabled && this.clearLabel && this.internalCtrl.value;
+    }
+    touch() {
+        if (this.onTouched) {
+            this.onTouched();
+        }
+    }
+    hasRequiredError() {
+        const control = this.ngControl?.control ? this.ngControl?.control : this.internalCtrl;
+        return control.hasError('required');
+    }
+    /**
+     * Apply Validators.required on the internal form, based on ngControl or [required] attribute, giving priority to attribute.
+     */
+    applyRequired() {
+        // Required status on parent validator
+        const outerRequiredStatus = this?.ngControl?.control?.validator?.({})?.required;
+        // Wanted required status, giving priority to template
+        const newRequiredStatus = typeof this._required !== 'undefined' ? this._required : outerRequiredStatus;
+        // Actual internal validation status
+        const currentRequiredStatus = this.internalCtrl?.validator?.({})?.required;
+        // If wanted status is similar to actual status, stop everything
+        if (currentRequiredStatus === newRequiredStatus) {
+            return;
+        }
+        // Apply only if changed
+        if (newRequiredStatus) {
+            this.internalCtrl.setValidators(Validators.required);
+        }
+        else {
+            this.internalCtrl.clearValidators();
+        }
+        this.internalCtrl.updateValueAndValidity();
+    }
+}
+AbstractSelect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: AbstractSelect, deps: [{ token: i1.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });
+AbstractSelect.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: AbstractSelect, inputs: { placeholder: "placeholder", floatPlaceholder: "floatPlaceholder", required: "required", navigateTo: "navigateTo", clearLabel: "clearLabel", showIcon: "showIcon", icon: "icon", displayWith: "displayWith", disabled: "disabled" }, outputs: { selectionChange: "selectionChange", blur: "blur" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: AbstractSelect, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.NgControl, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }]; }, propDecorators: { placeholder: [{
+                type: Input
+            }], floatPlaceholder: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], navigateTo: [{
+                type: Input
+            }], clearLabel: [{
+                type: Input
+            }], showIcon: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], displayWith: [{
+                type: Input
+            }], selectionChange: [{
+                type: Output
+            }], blur: [{
+                type: Output
+            }], disabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-select.component.js","sourceRoot":"","sources":["../../../../../../projects/natural/src/lib/modules/select/abstract-select.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {Directive, DoCheck, EventEmitter, Input, OnDestroy, OnInit, Optional, Output, Self} from '@angular/core';\nimport {\n    AbstractControl,\n    ControlValueAccessor,\n    FormControl,\n    FormControlDirective,\n    FormControlName,\n    FormGroupDirective,\n    NgControl,\n    NgForm,\n    Validators,\n} from '@angular/forms';\nimport {ErrorStateMatcher} from '@angular/material/core';\nimport {FloatLabelType} from '@angular/material/form-field';\nimport {NaturalAbstractController} from '../../classes/abstract-controller';\n\n/**\n * This will completely ignore internal formControl and instead use the one from the component\n * which comes from outside of this component. This basically allows us to **not** depend on\n * touched status propagation between outside and inside world, and thus get rid of our legacy\n * custom FormControl class (\"NaturalFormControl\").\n */\nclass ExternalFormControlMatcher<T> extends ErrorStateMatcher {\n    public constructor(private readonly component: AbstractSelect<T>) {\n        super();\n    }\n\n    public isErrorState(control: FormControl | null, form: FormGroupDirective | NgForm | null): boolean {\n        const externalCtrl = this.component.ngControl?.control || this.component.internalCtrl;\n        if (externalCtrl) {\n            return !!(externalCtrl.errors && (externalCtrl.touched || externalCtrl.dirty));\n        }\n\n        return false;\n    }\n}\n\n@Directive()\nexport abstract class AbstractSelect<V>\n    extends NaturalAbstractController\n    implements OnInit, OnDestroy, ControlValueAccessor, DoCheck\n{\n    @Input() public placeholder?: string;\n    @Input() public floatPlaceholder: FloatLabelType = 'auto';\n\n    /**\n     * If the field is required\n     */\n    @Input()\n    public set required(value: boolean) {\n        this._required = coerceBooleanProperty(value);\n        this.applyRequired();\n    }\n\n    public get required(): boolean {\n        return !!this._required;\n    }\n\n    private _required: boolean | undefined;\n\n    /**\n     * Add a suffix button that is a link to given destination\n     */\n    @Input() public navigateTo?: any[] | string | null;\n\n    /**\n     * If provided cause a new clear button to appear\n     */\n    @Input() public clearLabel?: string;\n\n    /**\n     * Whether to show the search icon\n     */\n    @Input() public showIcon = true;\n\n    /**\n     * Icon name\n     */\n    @Input() public icon = 'search';\n\n    /**\n     * Function to customize the rendering of the selected item as text in input\n     */\n    @Input() public displayWith?: (item: V | null) => string;\n\n    /**\n     * Emit the selected value whenever it changes\n     */\n    @Output() public readonly selectionChange = new EventEmitter<V | null>();\n\n    /**\n     * Emits when internal input is blurred\n     */\n    // eslint-disable-next-line @angular-eslint/no-output-native\n    @Output() public readonly blur = new EventEmitter<void>();\n\n    /**\n     * Contains internal representation for current selection.\n     *\n     * It is **not** necessarily `V | null`.\n     *\n     * - NaturalSelectComponent: `string | V | null`. We allow `string`\n     *   only when `optionRequired` is false, so most of the time it is `V | null`.\n     * - NaturalSelectHierarchicComponent: `string | null`.\n     * - NaturalSelectEnumComponent: `V | null`.\n     */\n    public readonly internalCtrl: FormControl = new FormControl();\n\n    /**\n     * Interface with ControlValueAccessor\n     * Notifies parent model / form controller\n     */\n    public onChange?: (item: V | null) => void;\n\n    /**\n     * Interface with ControlValueAccessor\n     * Notifies parent model / form controller\n     */\n    public onTouched?: () => void;\n\n    public matcher: ExternalFormControlMatcher<V>;\n\n    public constructor(@Optional() @Self() public readonly ngControl: NgControl | null) {\n        super();\n\n        if (this.ngControl) {\n            this.ngControl.valueAccessor = this;\n        }\n\n        this.matcher = new ExternalFormControlMatcher(this);\n    }\n\n    public ngDoCheck(): void {\n        if (this.ngControl) {\n            this.applyRequired();\n        }\n    }\n\n    public writeValue(value: V | null): void {\n        this.internalCtrl.setValue(value);\n    }\n\n    public ngOnInit(): void {\n        const isReactive = this.ngControl instanceof FormControlDirective || this.ngControl instanceof FormControlName;\n        if (isReactive && typeof this._required !== 'undefined') {\n            console.warn('<natural-select-*> should not be used as ReactiveForm and with the [required] attribute');\n        }\n    }\n\n    /**\n     * Whether the value can be changed\n     */\n    @Input()\n    public set disabled(disabled: boolean) {\n        disabled ? this.internalCtrl.disable() : this.internalCtrl.enable();\n    }\n\n    public registerOnChange(fn: (item: V | null) => void): void {\n        this.onChange = fn;\n    }\n\n    public registerOnTouched(fn: () => void): void {\n        this.onTouched = fn;\n    }\n\n    public abstract getDisplayFn(): (item: V | null) => string;\n\n    public clear(emitEvent = true): void {\n        // Empty input\n        this.internalCtrl.setValue(null, {emitEvent: emitEvent});\n\n        // propagateValue change\n        if (emitEvent) {\n            this.propagateValue(null);\n        }\n    }\n\n    public propagateValue(value: V | null): void {\n        // before selectionChange to allow formControl to update before change is effectively emitted\n        if (this.onChange) {\n            this.onChange(value);\n        }\n\n        this.selectionChange.emit(value);\n    }\n\n    public setDisabledState(isDisabled: boolean): void {\n        this.disabled = isDisabled;\n    }\n\n    public showClearButton(): boolean {\n        return this.internalCtrl?.enabled && this.clearLabel && this.internalCtrl.value;\n    }\n\n    public touch(): void {\n        if (this.onTouched) {\n            this.onTouched();\n        }\n    }\n\n    public hasRequiredError(): boolean {\n        const control = this.ngControl?.control ? this.ngControl?.control : this.internalCtrl;\n\n        return control.hasError('required');\n    }\n\n    /**\n     * Apply Validators.required on the internal form, based on ngControl or [required] attribute, giving priority to attribute.\n     */\n    private applyRequired(): void {\n        // Required status on parent validator\n        const outerRequiredStatus = this?.ngControl?.control?.validator?.({} as AbstractControl)?.required;\n\n        // Wanted required status, giving priority to template\n        const newRequiredStatus = typeof this._required !== 'undefined' ? this._required : outerRequiredStatus;\n\n        // Actual internal validation status\n        const currentRequiredStatus = this.internalCtrl?.validator?.({} as AbstractControl)?.required;\n\n        // If wanted status is similar to actual status, stop everything\n        if (currentRequiredStatus === newRequiredStatus) {\n            return;\n        }\n\n        // Apply only if changed\n        if (newRequiredStatus) {\n            this.internalCtrl.setValidators(Validators.required);\n        } else {\n            this.internalCtrl.clearValidators();\n        }\n\n        this.internalCtrl.updateValueAndValidity();\n    }\n}\n"]}

package/esm2020/lib/modules/select/select/select.component.mjs

@@ -0,0 +1,207 @@
+import { Component, ContentChild, Input, TemplateRef, ViewChild } from '@angular/core';
+import { MatAutocompleteTrigger } from '@angular/material/autocomplete';
+import { merge } from 'lodash-es';
+import { debounceTime, distinctUntilChanged, finalize, map, takeUntil } from 'rxjs/operators';
+import { NaturalQueryVariablesManager } from '../../../classes/query-variable-manager';
+import { AbstractSelect } from '../abstract-select.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/autocomplete";
+import * as i2 from "@angular/material/core";
+import * as i3 from "@angular/material/form-field";
+import * as i4 from "../../icon/icon.component";
+import * as i5 from "@angular/material/progress-spinner";
+import * as i6 from "@angular/material/button";
+import * as i7 from "@angular/common";
+import * as i8 from "@angular/material/input";
+import * as i9 from "@angular/forms";
+import * as i10 from "@angular/material/tooltip";
+import * as i11 from "@angular/router";
+/**
+ * Default usage:
+ * <natural-select [service]="amazingServiceInstance" [(model)]="amazingModel" (modelChange)=amazingChangeFn($event)></natural-select>
+ *
+ * Custom template usage :
+ * <natural-select [service]="svc" [(ngModel)]="model">
+ *     <ng-template let-item="item">
+ *         <span>{{ item.xxx }}</span>
+ *     </ng-template>
+ * </natural-select>
+ *
+ * [(ngModel)] and (ngModelChange) are optional
+ *
+ * Placeholder :
+ * <natural-select placeholder="amazing placeholder">
+ *
+ * Never float placeholder :
+ * <natural-select placeholder="amazing placeholder" floatPlaceholder="never">
+ *
+ * Search with like %xxx% on specified attribute name instead of custom filter on whole object
+ * <natural-select [searchField]="string">
+ *
+ * Allows to input free string without selecting an option from autocomplete suggestions
+ * <natural-select [optionRequired]="false">
+ */
+export class NaturalSelectComponent extends AbstractSelect {
+    constructor() {
+        super(...arguments);
+        /**
+         * If false, allows to input free string without selecting an option from autocomplete suggestions
+         */
+        this.optionRequired = true;
+        /**
+         * The filter attribute to bind when searching for a term
+         */
+        this.searchField = 'custom';
+        /**
+         * Items returned by server to show in listing
+         */
+        this.items = null;
+        /**
+         * Whether a we are searching something
+         */
+        this.loading = false;
+        /**
+         * Number of items not shown in result list
+         * Shows a message after list if positive
+         */
+        this.moreNbItems = 0;
+        /**
+         * Default page size
+         */
+        this.pageSize = 10;
+        /**
+         * Init search options
+         */
+        this.variablesManager = new NaturalQueryVariablesManager();
+    }
+    /**
+     * Additional filter for query
+     */
+    set filter(filter) {
+        this.variablesManager.set('additional-filter', { filter: filter });
+    }
+    /**
+     * Whether the value can be changed
+     */
+    set disabled(disabled) {
+        disabled ? this.internalCtrl.disable() : this.internalCtrl.enable();
+    }
+    ngAfterViewInit() {
+        this.internalCtrl.valueChanges
+            .pipe(takeUntil(this.ngUnsubscribe), distinctUntilChanged(), debounceTime(300))
+            .subscribe(val => this.search(val));
+    }
+    onInternalFormChange() {
+        // If we allow free string typing, then we propagate it as it is being typed
+        if (!this.optionRequired) {
+            this.propagateValue(this.internalCtrl.value);
+        }
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.initService();
+    }
+    initService() {
+        // Assert given service has a watchAll function
+        if (typeof this.service.watchAll !== 'function') {
+            throw new TypeError('Provided service does not contain watchAll function');
+        }
+        const defaultPagination = {
+            pagination: {
+                pageIndex: 0,
+                pageSize: this.pageSize,
+            },
+        };
+        const variables = merge(defaultPagination, this.getSearchFilter(null));
+        this.variablesManager.set('variables', variables);
+    }
+    startSearch() {
+        // Start search only once
+        if (this.items) {
+            return;
+        }
+        // Init query, and when query results arrive, finish loading, and count items
+        this.items = this.service.watchAll(this.variablesManager).pipe(takeUntil(this.ngUnsubscribe), finalize(() => (this.loading = false)), map(data => {
+            this.loading = false;
+            const nbTotal = data.length;
+            const nbListed = Math.min(data.length, this.pageSize);
+            this.moreNbItems = nbTotal - nbListed;
+            return data.items;
+        }));
+        this.loading = true;
+        this.items.subscribe();
+    }
+    propagateValue(value) {
+        this.loading = false;
+        // If we cleared value via button, but we allow free string typing, then force to empty string
+        if (!this.optionRequired && value === null) {
+            value = '';
+        }
+        super.propagateValue(value);
+    }
+    /**
+     * Very important to return something, above all if [select]='displayedValue' attribute value is used
+     */
+    getDisplayFn() {
+        if (this.displayWith) {
+            return this.displayWith;
+        }
+        return (item) => {
+            if (!item) {
+                return '';
+            }
+            if (typeof item === 'string') {
+                return item;
+            }
+            return item.fullName || item.name || item.iban || item[this.searchField] || item.id;
+        };
+    }
+    clear(emitEvent = true) {
+        this.search(null);
+        super.clear(emitEvent);
+    }
+    search(term) {
+        if (typeof term === 'string' || term === null) {
+            if (term) {
+                this.loading = !!this.items;
+            }
+            this.variablesManager.merge('variables', this.getSearchFilter(term));
+        }
+    }
+    showClearButton() {
+        return this.internalCtrl?.enabled && this.clearLabel && this.internalCtrl.value;
+    }
+    getSearchFilter(term) {
+        let field = {};
+        if (this.searchField === 'custom') {
+            field = { custom: term ? { search: { value: term } } : null };
+        }
+        else if (term) {
+            field[this.searchField] = { like: { value: '%' + term + '%' } };
+        }
+        return { filter: { groups: [{ conditions: [field] }] } };
+    }
+}
+NaturalSelectComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalSelectComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+NaturalSelectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.0", type: NaturalSelectComponent, selector: "natural-select", inputs: { service: "service", optionRequired: "optionRequired", searchField: "searchField", filter: "filter", disabled: "disabled" }, queries: [{ propertyName: "itemTemplate", first: true, predicate: TemplateRef, descendants: true }], viewQueries: [{ propertyName: "autoTrigger", first: true, predicate: MatAutocompleteTrigger, descendants: true }], usesInheritance: true, ngImport: i0, template: "<!-- Autocomplete menu -->\n<mat-autocomplete\n    #ac=\"matAutocomplete\"\n    (optionSelected)=\"propagateValue($event?.option?.value)\"\n    [displayWith]=\"getDisplayFn()\"\n    panelWidth=\"auto !important\"\n>\n    <mat-option *ngFor=\"let item of items | async\" [value]=\"item\">\n        <ng-template\n            [ngTemplateOutletContext]=\"{item: item}\"\n            [ngTemplateOutlet]=\"itemTemplate ? itemTemplate : defaultACItem\"\n        ></ng-template>\n    </mat-option>\n    <div *ngIf=\"moreNbItems > 0\" class=\"mat-caption\" i18n style=\"padding: 5px 10px\"\n        >{{ moreNbItems }} \u00E9l\u00E9ment(s) suppl\u00E9mentaire(s)</div\n    >\n</mat-autocomplete>\n\n<ng-template #defaultACItem let-item=\"item\">\n    <span>{{ getDisplayFn()(item) }}</span>\n</ng-template>\n\n<!-- Input for autocomplete -->\n<mat-form-field [floatLabel]=\"floatPlaceholder\">\n    <mat-label>{{ placeholder }}</mat-label>\n\n    <input\n        (blur)=\"touch(); blur.emit()\"\n        (change)=\"onInternalFormChange()\"\n        (click)=\"autoTrigger.openPanel()\"\n        (focus)=\"startSearch()\"\n        (keydown.esc)=\"clear()\"\n        [formControl]=\"internalCtrl\"\n        [matAutocomplete]=\"ac\"\n        aria-label=\"Recherche et s\u00E9lection\"\n        i18n-aria-label\n        matInput\n        [errorStateMatcher]=\"matcher\"\n    />\n\n    <!-- Meta data -->\n    <natural-icon *ngIf=\"!loading && showIcon\" [name]=\"icon\" matPrefix></natural-icon>\n    <mat-progress-spinner\n        *ngIf=\"loading\"\n        [diameter]=\"21\"\n        [strokeWidth]=\"5\"\n        matPrefix\n        mode=\"indeterminate\"\n    ></mat-progress-spinner>\n\n    <!-- Clear button -->\n    <div class=\"suffix-buttons\" matSuffix>\n        <button\n            (click)=\"clear(); $event.stopPropagation()\"\n            *ngIf=\"internalCtrl.value && internalCtrl.enabled && !clearLabel\"\n            mat-icon-button\n            i18n-matTooltip\n            matTooltip=\"D\u00E9s\u00E9lectionner\"\n        >\n            <natural-icon name=\"close\"></natural-icon>\n        </button>\n        <button\n            *ngIf=\"internalCtrl.value && navigateTo\"\n            [routerLink]=\"navigateTo\"\n            mat-button\n            mat-icon-button\n            i18n-matTooltip\n            matTooltip=\"Naviguer vers\"\n        >\n            <natural-icon name=\"open_in_browser\"></natural-icon>\n        </button>\n    </div>\n\n    <mat-error *ngIf=\"hasRequiredError()\" i18n>Ce champ est requis</mat-error>\n</mat-form-field>\n\n<!-- Additional (un)select/(un)link buttons for more visual cohesion with natural-relations --><!-- [clearLabel] and/or [selectLabel] has to be given as attribute input -->\n<div *ngIf=\"showClearButton()\" class=\"external-buttons\">\n    <button (click)=\"clear()\" *ngIf=\"showClearButton()\" color=\"warn\" mat-button>{{ clearLabel }}</button>\n</div>\n", styles: [":host{display:flex;flex-direction:column}:host>*:not(:last-child){margin-bottom:20px}:host>mat-autocomplete{margin-bottom:0!important}:host .suffix-buttons,:host .external-buttons{display:flex;flex-direction:row}:host .external-buttons{display:flex;flex-direction:row}:host .external-buttons>*:not(:last-child){margin-right:10px}\n"], components: [{ type: i1.MatAutocomplete, selector: "mat-autocomplete", inputs: ["disableRipple"], exportAs: ["matAutocomplete"] }, { type: i2.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { type: i3.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { type: i4.NaturalIconComponent, selector: "natural-icon", inputs: ["label", "labelColor", "labelPosition", "name", "size"] }, { type: i5.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "diameter", "strokeWidth", "mode", "value"], exportAs: ["matProgressSpinner"] }, { type: i6.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }], directives: [{ type: i7.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i7.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.MatLabel, selector: "mat-label" }, { type: i8.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { type: i9.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i1.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", exportAs: ["matAutocompleteTrigger"] }, { type: i9.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i9.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i3.MatPrefix, selector: "[matPrefix]" }, { type: i3.MatSuffix, selector: "[matSuffix]" }, { type: i10.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }, { type: i11.RouterLink, selector: ":not(a):not(area)[routerLink]", inputs: ["queryParams", "fragment", "queryParamsHandling", "preserveFragment", "skipLocationChange", "replaceUrl", "state", "relativeTo", "routerLink"] }, { type: i3.MatError, selector: "mat-error", inputs: ["id"] }], pipes: { "async": i7.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalSelectComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'natural-select', template: "<!-- Autocomplete menu -->\n<mat-autocomplete\n    #ac=\"matAutocomplete\"\n    (optionSelected)=\"propagateValue($event?.option?.value)\"\n    [displayWith]=\"getDisplayFn()\"\n    panelWidth=\"auto !important\"\n>\n    <mat-option *ngFor=\"let item of items | async\" [value]=\"item\">\n        <ng-template\n            [ngTemplateOutletContext]=\"{item: item}\"\n            [ngTemplateOutlet]=\"itemTemplate ? itemTemplate : defaultACItem\"\n        ></ng-template>\n    </mat-option>\n    <div *ngIf=\"moreNbItems > 0\" class=\"mat-caption\" i18n style=\"padding: 5px 10px\"\n        >{{ moreNbItems }} \u00E9l\u00E9ment(s) suppl\u00E9mentaire(s)</div\n    >\n</mat-autocomplete>\n\n<ng-template #defaultACItem let-item=\"item\">\n    <span>{{ getDisplayFn()(item) }}</span>\n</ng-template>\n\n<!-- Input for autocomplete -->\n<mat-form-field [floatLabel]=\"floatPlaceholder\">\n    <mat-label>{{ placeholder }}</mat-label>\n\n    <input\n        (blur)=\"touch(); blur.emit()\"\n        (change)=\"onInternalFormChange()\"\n        (click)=\"autoTrigger.openPanel()\"\n        (focus)=\"startSearch()\"\n        (keydown.esc)=\"clear()\"\n        [formControl]=\"internalCtrl\"\n        [matAutocomplete]=\"ac\"\n        aria-label=\"Recherche et s\u00E9lection\"\n        i18n-aria-label\n        matInput\n        [errorStateMatcher]=\"matcher\"\n    />\n\n    <!-- Meta data -->\n    <natural-icon *ngIf=\"!loading && showIcon\" [name]=\"icon\" matPrefix></natural-icon>\n    <mat-progress-spinner\n        *ngIf=\"loading\"\n        [diameter]=\"21\"\n        [strokeWidth]=\"5\"\n        matPrefix\n        mode=\"indeterminate\"\n    ></mat-progress-spinner>\n\n    <!-- Clear button -->\n    <div class=\"suffix-buttons\" matSuffix>\n        <button\n            (click)=\"clear(); $event.stopPropagation()\"\n            *ngIf=\"internalCtrl.value && internalCtrl.enabled && !clearLabel\"\n            mat-icon-button\n            i18n-matTooltip\n            matTooltip=\"D\u00E9s\u00E9lectionner\"\n        >\n            <natural-icon name=\"close\"></natural-icon>\n        </button>\n        <button\n            *ngIf=\"internalCtrl.value && navigateTo\"\n            [routerLink]=\"navigateTo\"\n            mat-button\n            mat-icon-button\n            i18n-matTooltip\n            matTooltip=\"Naviguer vers\"\n        >\n            <natural-icon name=\"open_in_browser\"></natural-icon>\n        </button>\n    </div>\n\n    <mat-error *ngIf=\"hasRequiredError()\" i18n>Ce champ est requis</mat-error>\n</mat-form-field>\n\n<!-- Additional (un)select/(un)link buttons for more visual cohesion with natural-relations --><!-- [clearLabel] and/or [selectLabel] has to be given as attribute input -->\n<div *ngIf=\"showClearButton()\" class=\"external-buttons\">\n    <button (click)=\"clear()\" *ngIf=\"showClearButton()\" color=\"warn\" mat-button>{{ clearLabel }}</button>\n</div>\n", styles: [":host{display:flex;flex-direction:column}:host>*:not(:last-child){margin-bottom:20px}:host>mat-autocomplete{margin-bottom:0!important}:host .suffix-buttons,:host .external-buttons{display:flex;flex-direction:row}:host .external-buttons{display:flex;flex-direction:row}:host .external-buttons>*:not(:last-child){margin-right:10px}\n"] }]
+        }], propDecorators: { autoTrigger: [{
+                type: ViewChild,
+                args: [MatAutocompleteTrigger]
+            }], itemTemplate: [{
+                type: ContentChild,
+                args: [TemplateRef]
+            }], service: [{
+                type: Input
+            }], optionRequired: [{
+                type: Input
+            }], searchField: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select.component.js","sourceRoot":"","sources":["../../../../../../../projects/natural/src/lib/modules/select/select/select.component.ts","../../../../../../../projects/natural/src/lib/modules/select/select/select.component.html"],"names":[],"mappings":"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","sourcesContent":["import {AfterViewInit, Component, ContentChild, Input, OnDestroy, OnInit, TemplateRef, ViewChild} from '@angular/core';\nimport {ControlValueAccessor} from '@angular/forms';\nimport {MatAutocompleteTrigger} from '@angular/material/autocomplete';\nimport {merge} from 'lodash-es';\nimport {Observable} from 'rxjs';\nimport {debounceTime, distinctUntilChanged, finalize, map, takeUntil} from 'rxjs/operators';\nimport {PaginatedData} from '../../../classes/data-source';\nimport {NaturalQueryVariablesManager, QueryVariables} from '../../../classes/query-variable-manager';\nimport {NaturalAbstractModelService} from '../../../services/abstract-model.service';\nimport {ExtractTallOne, ExtractVall, Literal} from '../../../types/types';\nimport {AbstractSelect} from '../abstract-select.component';\n\n/**\n * Default usage:\n * <natural-select [service]=\"amazingServiceInstance\" [(model)]=\"amazingModel\" (modelChange)=amazingChangeFn($event)></natural-select>\n *\n * Custom template usage :\n * <natural-select [service]=\"svc\" [(ngModel)]=\"model\">\n *     <ng-template let-item=\"item\">\n *         <span>{{ item.xxx }}</span>\n *     </ng-template>\n * </natural-select>\n *\n * [(ngModel)] and (ngModelChange) are optional\n *\n * Placeholder :\n * <natural-select placeholder=\"amazing placeholder\">\n *\n * Never float placeholder :\n * <natural-select placeholder=\"amazing placeholder\" floatPlaceholder=\"never\">\n *\n * Search with like %xxx% on specified attribute name instead of custom filter on whole object\n * <natural-select [searchField]=\"string\">\n *\n * Allows to input free string without selecting an option from autocomplete suggestions\n * <natural-select [optionRequired]=\"false\">\n */\n@Component({\n    selector: 'natural-select',\n    templateUrl: './select.component.html',\n    styleUrls: ['./select.component.scss'],\n})\nexport class NaturalSelectComponent<\n        TService extends NaturalAbstractModelService<\n            any,\n            any,\n            PaginatedData<Literal>,\n            QueryVariables,\n            any,\n            any,\n            any,\n            any,\n            any,\n            any\n        >,\n    >\n    extends AbstractSelect<string | ExtractTallOne<TService>>\n    implements OnInit, OnDestroy, ControlValueAccessor, AfterViewInit\n{\n    @ViewChild(MatAutocompleteTrigger) public autoTrigger!: MatAutocompleteTrigger;\n    @ContentChild(TemplateRef) public itemTemplate?: TemplateRef<any>;\n\n    /**\n     * Service with watchAll function that accepts queryVariables.\n     */\n    @Input() public service!: TService;\n\n    /**\n     * If false, allows to input free string without selecting an option from autocomplete suggestions\n     */\n    @Input() public optionRequired = true;\n\n    /**\n     * The filter attribute to bind when searching for a term\n     */\n    @Input() public searchField: 'custom' | string = 'custom';\n\n    /**\n     * Additional filter for query\n     */\n    @Input()\n    public set filter(filter: ExtractVall<TService>['filter'] | null | undefined) {\n        this.variablesManager.set('additional-filter', {filter: filter});\n    }\n\n    /**\n     * Items returned by server to show in listing\n     */\n    public items: null | Observable<any[]> = null;\n\n    /**\n     * Whether a we are searching something\n     */\n    public loading = false;\n\n    /**\n     * Number of items not shown in result list\n     * Shows a message after list if positive\n     */\n    public moreNbItems = 0;\n\n    /**\n     * Default page size\n     */\n    private pageSize = 10;\n\n    /**\n     * Init search options\n     */\n    private variablesManager = new NaturalQueryVariablesManager<QueryVariables>();\n\n    /**\n     * Whether the value can be changed\n     */\n    @Input() public set disabled(disabled: boolean) {\n        disabled ? this.internalCtrl.disable() : this.internalCtrl.enable();\n    }\n\n    public ngAfterViewInit(): void {\n        this.internalCtrl.valueChanges\n            .pipe(takeUntil(this.ngUnsubscribe), distinctUntilChanged(), debounceTime(300))\n            .subscribe(val => this.search(val));\n    }\n\n    public onInternalFormChange(): void {\n        // If we allow free string typing, then we propagate it as it is being typed\n        if (!this.optionRequired) {\n            this.propagateValue(this.internalCtrl.value);\n        }\n    }\n\n    public ngOnInit(): void {\n        super.ngOnInit();\n        this.initService();\n    }\n\n    private initService(): void {\n        // Assert given service has a watchAll function\n        if (typeof this.service.watchAll !== 'function') {\n            throw new TypeError('Provided service does not contain watchAll function');\n        }\n\n        const defaultPagination = {\n            pagination: {\n                pageIndex: 0,\n                pageSize: this.pageSize,\n            },\n        };\n\n        const variables = merge(defaultPagination, this.getSearchFilter(null));\n        this.variablesManager.set('variables', variables);\n    }\n\n    public startSearch(): void {\n        // Start search only once\n        if (this.items) {\n            return;\n        }\n\n        // Init query, and when query results arrive, finish loading, and count items\n        this.items = this.service.watchAll(this.variablesManager).pipe(\n            takeUntil(this.ngUnsubscribe),\n            finalize(() => (this.loading = false)),\n            map(data => {\n                this.loading = false;\n                const nbTotal = data.length;\n                const nbListed = Math.min(data.length, this.pageSize);\n                this.moreNbItems = nbTotal - nbListed;\n\n                return data.items;\n            }),\n        );\n\n        this.loading = true;\n        this.items.subscribe();\n    }\n\n    public propagateValue(value: string | ExtractTallOne<TService> | null): void {\n        this.loading = false;\n\n        // If we cleared value via button, but we allow free string typing, then force to empty string\n        if (!this.optionRequired && value === null) {\n            value = '';\n        }\n\n        super.propagateValue(value);\n    }\n\n    /**\n     * Very important to return something, above all if [select]='displayedValue' attribute value is used\n     */\n    public getDisplayFn(): (item: string | ExtractTallOne<TService> | null) => string {\n        if (this.displayWith) {\n            return this.displayWith;\n        }\n\n        return (item: any) => {\n            if (!item) {\n                return '';\n            }\n\n            if (typeof item === 'string') {\n                return item;\n            }\n\n            return item.fullName || item.name || item.iban || item[this.searchField] || item.id;\n        };\n    }\n\n    public clear(emitEvent = true): void {\n        this.search(null);\n        super.clear(emitEvent);\n    }\n\n    public search(term: string | ExtractTallOne<TService> | null): void {\n        if (typeof term === 'string' || term === null) {\n            if (term) {\n                this.loading = !!this.items;\n            }\n\n            this.variablesManager.merge('variables', this.getSearchFilter(term as string | null));\n        }\n    }\n\n    public showClearButton(): boolean {\n        return this.internalCtrl?.enabled && this.clearLabel && this.internalCtrl.value;\n    }\n\n    private getSearchFilter(term: string | null): QueryVariables {\n        let field: Literal = {};\n\n        if (this.searchField === 'custom') {\n            field = {custom: term ? {search: {value: term}} : null};\n        } else if (term) {\n            field[this.searchField] = {like: {value: '%' + term + '%'}};\n        }\n\n        return {filter: {groups: [{conditions: [field]}]}};\n    }\n}\n","<!-- Autocomplete menu -->\n<mat-autocomplete\n    #ac=\"matAutocomplete\"\n    (optionSelected)=\"propagateValue($event?.option?.value)\"\n    [displayWith]=\"getDisplayFn()\"\n    panelWidth=\"auto !important\"\n>\n    <mat-option *ngFor=\"let item of items | async\" [value]=\"item\">\n        <ng-template\n            [ngTemplateOutletContext]=\"{item: item}\"\n            [ngTemplateOutlet]=\"itemTemplate ? itemTemplate : defaultACItem\"\n        ></ng-template>\n    </mat-option>\n    <div *ngIf=\"moreNbItems > 0\" class=\"mat-caption\" i18n style=\"padding: 5px 10px\"\n        >{{ moreNbItems }} élément(s) supplémentaire(s)</div\n    >\n</mat-autocomplete>\n\n<ng-template #defaultACItem let-item=\"item\">\n    <span>{{ getDisplayFn()(item) }}</span>\n</ng-template>\n\n<!-- Input for autocomplete -->\n<mat-form-field [floatLabel]=\"floatPlaceholder\">\n    <mat-label>{{ placeholder }}</mat-label>\n\n    <input\n        (blur)=\"touch(); blur.emit()\"\n        (change)=\"onInternalFormChange()\"\n        (click)=\"autoTrigger.openPanel()\"\n        (focus)=\"startSearch()\"\n        (keydown.esc)=\"clear()\"\n        [formControl]=\"internalCtrl\"\n        [matAutocomplete]=\"ac\"\n        aria-label=\"Recherche et sélection\"\n        i18n-aria-label\n        matInput\n        [errorStateMatcher]=\"matcher\"\n    />\n\n    <!-- Meta data -->\n    <natural-icon *ngIf=\"!loading && showIcon\" [name]=\"icon\" matPrefix></natural-icon>\n    <mat-progress-spinner\n        *ngIf=\"loading\"\n        [diameter]=\"21\"\n        [strokeWidth]=\"5\"\n        matPrefix\n        mode=\"indeterminate\"\n    ></mat-progress-spinner>\n\n    <!-- Clear button -->\n    <div class=\"suffix-buttons\" matSuffix>\n        <button\n            (click)=\"clear(); $event.stopPropagation()\"\n            *ngIf=\"internalCtrl.value && internalCtrl.enabled && !clearLabel\"\n            mat-icon-button\n            i18n-matTooltip\n            matTooltip=\"Désélectionner\"\n        >\n            <natural-icon name=\"close\"></natural-icon>\n        </button>\n        <button\n            *ngIf=\"internalCtrl.value && navigateTo\"\n            [routerLink]=\"navigateTo\"\n            mat-button\n            mat-icon-button\n            i18n-matTooltip\n            matTooltip=\"Naviguer vers\"\n        >\n            <natural-icon name=\"open_in_browser\"></natural-icon>\n        </button>\n    </div>\n\n    <mat-error *ngIf=\"hasRequiredError()\" i18n>Ce champ est requis</mat-error>\n</mat-form-field>\n\n<!-- Additional (un)select/(un)link buttons for more visual cohesion with natural-relations --><!-- [clearLabel] and/or [selectLabel] has to be given as attribute input -->\n<div *ngIf=\"showClearButton()\" class=\"external-buttons\">\n    <button (click)=\"clear()\" *ngIf=\"showClearButton()\" color=\"warn\" mat-button>{{ clearLabel }}</button>\n</div>\n"]}