@igo2/geo 18.0.1-next.2 → 18.0.2

package/esm2022/lib/query/shared/query.utils.mjs

@@ -0,0 +1,45 @@
+import { isLayerGroup } from '../../layer/utils/layer.utils';
+/**
+ * Whether a layer is queryable
+ * @param layer Layer
+ * @returns True if the layer s squeryable
+ */
+export function layerIsQueryable(layer) {
+    if (isLayerGroup(layer)) {
+        return false;
+    }
+    const dataSource = layer.dataSource;
+    return dataSource.options.queryable === true;
+}
+/**
+ * Whether an OL layer is queryable
+ * @param layer Layer
+ * @returns True if the ol layer is queryable
+ */
+export function olLayerIsQueryable(olLayer) {
+    const layer = olLayer.get('_layer');
+    return layer === undefined ? false : layerIsQueryable(layer);
+}
+/**
+ * Whether a layer's feature is queryable
+ * @param layer Layer
+ * @returns True if the layer's feature is queryable
+ */
+export function layerFeatureIsQueryable(layer) {
+    const dataSource = layer.dataSource;
+    return dataSource.options.queryLayerFeatures !== undefined
+        ? dataSource.options.queryLayerFeatures === true
+        : true;
+}
+/**
+ * Whether an OL Vector layer is queryable
+ * @param layer Layer
+ * @returns True if the ol vector layer is queryable
+ */
+export function olLayerFeatureIsQueryable(olLayer) {
+    const layer = olLayer.get('_layer');
+    return layer === undefined
+        ? false
+        : layerIsQueryable(layer) && layerFeatureIsQueryable(layer);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/search/index.mjs

@@ -0,0 +1,10 @@
+export * from './shared';
+export * from './search.module';
+export * from './search-selector/search-selector.component';
+export * from './search-selector/search-selector.module';
+export * from './search-settings/search-settings.component';
+export * from './search-settings/search-settings.module';
+export * from './search-bar/search-bar.component';
+export * from './search-bar/search-bar.module';
+export * from './search-results';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9zZWFyY2gvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLDZDQUE2QyxDQUFDO0FBQzVELGNBQWMsMENBQTBDLENBQUM7QUFDekQsY0FBYyw2Q0FBNkMsQ0FBQztBQUM1RCxjQUFjLDBDQUEwQyxDQUFDO0FBQ3pELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zaGFyZWQnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2gubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLXNlbGVjdG9yL3NlYXJjaC1zZWxlY3Rvci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2gtc2VsZWN0b3Ivc2VhcmNoLXNlbGVjdG9yLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC1zZXR0aW5ncy9zZWFyY2gtc2V0dGluZ3MuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLXNldHRpbmdzL3NlYXJjaC1zZXR0aW5ncy5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2gtYmFyL3NlYXJjaC1iYXIuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLWJhci9zZWFyY2gtYmFyLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC1yZXN1bHRzJztcbiJdfQ==

package/esm2022/lib/search/search-bar/search-bar.component.mjs

@@ -0,0 +1,483 @@
+import { AsyncPipe, NgClass, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ElementRef, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { MatButtonModule } from '@angular/material/button';
+import { MatDividerModule } from '@angular/material/divider';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { EntityStore } from '@igo2/common/entity';
+import { ConfigService } from '@igo2/core/config';
+import { IgoLanguageModule } from '@igo2/core/language';
+import { BehaviorSubject, timer } from 'rxjs';
+import { debounce, distinctUntilChanged } from 'rxjs/operators';
+import { SearchSelectorComponent } from '../search-selector/search-selector.component';
+import { SearchSettingsComponent } from '../search-settings/search-settings.component';
+import { SearchSourceService } from '../shared/search-source.service';
+import { SEARCH_TYPES } from '../shared/search.enums';
+import { SearchService } from '../shared/search.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core/config";
+import * as i2 from "../shared/search.service";
+import * as i3 from "../shared/search-source.service";
+import * as i4 from "@angular/material/form-field";
+import * as i5 from "@angular/material/input";
+import * as i6 from "@angular/material/button";
+import * as i7 from "@angular/material/tooltip";
+import * as i8 from "@angular/material/icon";
+import * as i9 from "@angular/material/divider";
+import * as i10 from "@ngx-translate/core";
+/**
+ * Searchbar that triggers a research in all search sources enabled.
+ * If the store input is defined, the search results will be loaded
+ * into that store. An event is always emitted when a research is completed.
+ */
+export class SearchBarComponent {
+    configService;
+    searchService;
+    searchSourceService;
+    /**
+     * Invalid keys
+     */
+    static invalidKeys = [
+        'Control',
+        'Shift',
+        'Alt',
+        'ArrowDown',
+        'ArrowUp',
+        'ArrowRight',
+        'ArrowLeft'
+    ];
+    placeholder$ = new BehaviorSubject('igo.geo.search.placeholder');
+    empty$ = new BehaviorSubject(true);
+    /**
+     * Subscription to the ssearch bar term
+     */
+    term$$;
+    /**
+     * Search term stream
+     */
+    stream$ = new BehaviorSubject('');
+    /**
+     * Subscription to the search term stream
+     */
+    stream$$;
+    /**
+     * Subscription to the search type
+     */
+    searchType$$;
+    researches$$;
+    /**
+     * whether to show search button or not
+     */
+    showSearchButton = false;
+    /**
+     * List of available search types
+     */
+    searchTypes = SEARCH_TYPES;
+    withDivider;
+    /**
+     * Search term
+     */
+    set searchType(value) {
+        this.setSearchType(value);
+    }
+    get searchType() {
+        return this.searchType$.value;
+    }
+    searchType$ = new BehaviorSubject(undefined);
+    /**
+     * Event emitted when the pointer summary is activated by the searchbar setting
+     */
+    pointerSummaryStatus = new EventEmitter();
+    /**
+     * Event emitted when the show geometry setting is changed
+     */
+    searchResultsGeometryStatus = new EventEmitter();
+    /**
+     * Event emitted when the coords format setting is changed
+     */
+    reverseSearchCoordsFormatStatus = new EventEmitter();
+    /**
+     * Search term
+     */
+    set term(value) {
+        this.setTerm(value);
+    }
+    get term() {
+        return this.term$.value;
+    }
+    term$ = new BehaviorSubject('');
+    /**
+     * Whether this component is disabled
+     */
+    set disabled(value) {
+        this.disabled$.next(value);
+    }
+    get disabled() {
+        return this.disabled$.value;
+    }
+    disabled$ = new BehaviorSubject(false);
+    pointerSummaryEnabled = false;
+    searchResultsGeometryEnabled = false;
+    /**
+     * When reverse coordinates status change
+     */
+    get reverseSearchCoordsFormatEnabled() {
+        return this._reverseSearchCoordsFormatEnabled;
+    }
+    set reverseSearchCoordsFormatEnabled(value) {
+        this._reverseSearchCoordsFormatEnabled = value;
+        this.setTerm(this.term, true);
+    }
+    _reverseSearchCoordsFormatEnabled = false;
+    /**
+     * Whether a float label should be displayed
+     */
+    floatLabel = 'auto';
+    appearance = 'fill';
+    placeholder;
+    label;
+    /**
+     * Icons color (search and clear)
+     */
+    color = 'primary';
+    termSplitter = '|';
+    /**
+     * Debounce time between each keystroke
+     */
+    debounce = 200;
+    /**
+     * Minimum term length required to trigger a research
+     */
+    minLength = 2;
+    /**
+     * Search Selector
+     */
+    searchSelector = false;
+    /**
+     * Search Settings
+     */
+    searchSettings = false;
+    /**
+     * Force coordinates in north america
+     */
+    forceNA = false;
+    /**
+     * Search results store
+     */
+    store;
+    /**
+     * Event emitted when the search term changes
+     */
+    searchTermChange = new EventEmitter();
+    /**
+     * Event emitted when a research is completed
+     */
+    search = new EventEmitter();
+    /**
+     * Event emitted when the search type changes
+     */
+    searchTypeChange = new EventEmitter();
+    /**
+     * Event emitted when the search type changes
+     */
+    clearFeature = new EventEmitter();
+    /**
+     * Event emitted when the search settings changes
+     */
+    searchSettingsChange = new EventEmitter();
+    /**
+     * Input element
+     * @internal
+     */
+    input;
+    /**
+     * Whether the search bar is empty
+     * @internal
+     */
+    get empty() {
+        return this.term.length === 0;
+    }
+    constructor(configService, searchService, searchSourceService) {
+        this.configService = configService;
+        this.searchService = searchService;
+        this.searchSourceService = searchSourceService;
+    }
+    /**
+     * Subscribe to the search term stream and trigger researches
+     * @internal
+     */
+    ngOnInit() {
+        this.term$$ = this.term$.subscribe((term) => {
+            this.empty$.next(term === undefined || term.length === 0);
+        });
+        this.stream$$ = this.stream$
+            .pipe(debounce(() => timer(this.debounce)))
+            .subscribe((term) => this.onSetTerm(term));
+        this.handlePlaceholder();
+        this.searchType$$ = this.searchType$
+            .pipe(distinctUntilChanged())
+            .subscribe((searchType) => this.onSetSearchType(searchType));
+        const configValue = this.configService.getConfig('searchBar.showSearchButton');
+        this.showSearchButton = configValue !== undefined ? configValue : false;
+    }
+    /**
+     * Unsubscribe to the search term stream
+     * @internal
+     */
+    ngOnDestroy() {
+        this.term$$.unsubscribe();
+        this.stream$$.unsubscribe();
+        this.searchType$$.unsubscribe();
+    }
+    /**
+     * When a user types, validates the key and send it into the
+     * stream if it's valid
+     * @param event Keyboard event
+     * @internal
+     */
+    onKeyup(event) {
+        const key = event.key;
+        if (!this.keyIsValid(key)) {
+            return;
+        }
+        const term = event.target.value;
+        this.setTerm(term);
+    }
+    /**
+     * Clear the stream and the input
+     * @internal
+     */
+    onClearButtonClick() {
+        this.clear();
+        this.clearFeature.emit();
+    }
+    /**
+     * Update search type
+     * @param searchType Enabled search type
+     * @internal
+     */
+    onSearchTypeChange(searchType) {
+        this.setSearchType(searchType);
+    }
+    /**
+     * Update the placeholder with the enabled search type. The placeholder
+     * for all availables search typers needs to be defined in the locale
+     * files or an error will be thrown.
+     * @param searchType Enabled search type
+     * @internal
+     */
+    setSearchType(searchType) {
+        this.searchType$.next(searchType);
+    }
+    onSearchSettingsChange() {
+        this.doSearch(this.term);
+        this.searchSettingsChange.emit();
+        this.handlePlaceholder();
+    }
+    /**
+     * Send the term into the stream only if this component is not disabled
+     * @param term Search term
+     */
+    setTerm(term, reverseCoordEvent) {
+        if (this.disabled) {
+            return;
+        }
+        term = term || '';
+        if (term !== this.term && !reverseCoordEvent) {
+            this.term$.next(term);
+        }
+        const slug = term.replace(/(#[^\s]*)/g, '').trim();
+        if (slug.length >= this.minLength || slug.length === 0) {
+            this.stream$.next(term);
+        }
+    }
+    handleSearch() {
+        this.doSearch(this.term);
+    }
+    /**
+     * Clear the stream and the input
+     */
+    clear() {
+        this.term$.next('');
+        this.stream$.next('');
+        this.input.nativeElement.focus();
+    }
+    /**
+     * Validate if a given key stroke is a valid input
+     */
+    keyIsValid(key) {
+        return SearchBarComponent.invalidKeys.indexOf(key) === -1;
+    }
+    /**
+     * When the search term changes, emit an event and trigger a
+     * research in every enabled search sources.
+     * @param term Search term
+     */
+    onSetTerm(term) {
+        this.searchTermChange.emit(term);
+        this.doSearch(term);
+    }
+    handlePlaceholder() {
+        const searchTypes = [
+            ...new Set(this.searchSourceService
+                .getEnabledSources()
+                .filter((ss) => !['map', 'coordinatesreverse'].includes(ss.getId()))
+                .map((ss) => ss.getType()))
+        ];
+        let placeholder = `igo.geo.search.placeholder`;
+        if (searchTypes.length === 1) {
+            placeholder = `igo.geo.search.${searchTypes[0].toLowerCase()}.placeholder`;
+        }
+        else if (searchTypes.length === 0) {
+            placeholder = `igo.geo.search.emptyType.placeholder`;
+        }
+        this.placeholder$.next(placeholder);
+    }
+    onSetSearchType(searchType) {
+        if (searchType === undefined || searchType === null) {
+            return;
+        }
+        this.searchTypeChange.emit(searchType);
+        const placeholder = `igo.geo.search.${searchType.toLowerCase()}.placeholder`;
+        this.placeholder$.next(placeholder);
+        this.setTerm(this.term);
+    }
+    /**
+     * Execute the search
+     * @param term Search term
+     */
+    doSearch(rawTerm) {
+        if (this.researches$$) {
+            this.researches$$.map((research) => research.unsubscribe());
+            this.researches$$ = undefined;
+        }
+        let terms;
+        if (this.termSplitter &&
+            rawTerm.match(new RegExp(this.termSplitter, 'g'))) {
+            terms = rawTerm
+                .split(this.termSplitter)
+                .filter((t) => t.length >= this.minLength);
+            if (this.store) {
+                this.store.clear();
+            }
+        }
+        else {
+            terms = [rawTerm];
+        }
+        let researches = [];
+        terms.map((term) => {
+            const slug = term ? term.replace(/(#[^\s]*)/g, '').trim() : '';
+            if (slug === '') {
+                if (this.store !== undefined) {
+                    this.store.clear();
+                }
+                return;
+            }
+            researches = researches.concat(this.searchService.search(term, {
+                forceNA: this.forceNA
+            }));
+        });
+        this.researches$$ = researches.map((research) => {
+            return research.request.subscribe((results) => {
+                this.onResearchCompleted(research, results);
+            });
+        });
+    }
+    /**
+     * When a research  is completed, emit an event and update
+     * the store's items.
+     * @param research Research
+     * @param results Research results
+     */
+    onResearchCompleted(research, results) {
+        this.search.emit({ research, results });
+        if (this.store !== undefined) {
+            const newResults = this.store
+                .all()
+                .filter((result) => result.source !== research.source)
+                .concat(results);
+            this.store.updateMany(newResults);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchBarComponent, deps: [{ token: i1.ConfigService }, { token: i2.SearchService }, { token: i3.SearchSourceService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: SearchBarComponent, isStandalone: true, selector: "igo-search-bar", inputs: { searchTypes: "searchTypes", withDivider: "withDivider", searchType: "searchType", term: "term", disabled: "disabled", pointerSummaryEnabled: "pointerSummaryEnabled", searchResultsGeometryEnabled: "searchResultsGeometryEnabled", reverseSearchCoordsFormatEnabled: "reverseSearchCoordsFormatEnabled", floatLabel: "floatLabel", appearance: "appearance", placeholder: "placeholder", label: "label", color: "color", termSplitter: "termSplitter", debounce: "debounce", minLength: "minLength", searchSelector: "searchSelector", searchSettings: "searchSettings", forceNA: "forceNA", store: "store" }, outputs: { pointerSummaryStatus: "pointerSummaryStatus", searchResultsGeometryStatus: "searchResultsGeometryStatus", reverseSearchCoordsFormatStatus: "reverseSearchCoordsFormatStatus", searchTermChange: "searchTermChange", search: "search", searchTypeChange: "searchTypeChange", clearFeature: "clearFeature", searchSettingsChange: "searchSettingsChange" }, viewQueries: [{ propertyName: "input", first: true, predicate: ["input"], descendants: true, static: true }], ngImport: i0, template: "<div class=\"igo-search-bar-container\" [ngClass]=\"{ empty: empty$ | async }\">\n  <mat-form-field [floatLabel]=\"floatLabel\" [appearance]=\"appearance\">\n    <mat-label *ngIf=\"label\">{{ label }}</mat-label>\n    <input\n      #input\n      matInput\n      autocomplete=\"off\"\n      [ngClass]=\"{ hasSearchIcon: showSearchButton }\"\n      [disabled]=\"disabled$ | async\"\n      [placeholder]=\"\n        placeholder\n          ? placeholder\n          : (placeholder$ | async)\n            ? (placeholder$.value | translate)\n            : undefined\n      \"\n      [value]=\"term$ | async\"\n      (keyup)=\"onKeyup($event)\"\n    />\n    <button\n      *ngIf=\"(empty$ | async) === false\"\n      mat-icon-button\n      matSuffix\n      [color]=\"color\"\n      (click)=\"onClearButtonClick()\"\n      [matTooltip]=\"'igo.geo.search.clearSearch' | translate\"\n    >\n      <mat-icon>close</mat-icon>\n    </button>\n  </mat-form-field>\n\n  <mat-divider *ngIf=\"withDivider\" [vertical]=\"true\"></mat-divider>\n\n  <div class=\"search-bar-buttons\">\n    <button\n      *ngIf=\"showSearchButton\"\n      mat-icon-button\n      [color]=\"color\"\n      (click)=\"handleSearch()\"\n    >\n      <mat-icon>search</mat-icon>\n    </button>\n\n    <igo-search-selector\n      *ngIf=\"searchSelector\"\n      [searchTypes]=\"searchTypes\"\n      [searchType]=\"searchType$ | async\"\n      (searchTypeChange)=\"onSearchTypeChange($event)\"\n    >\n    </igo-search-selector>\n\n    <igo-search-settings\n      *ngIf=\"searchSettings\"\n      [pointerSummaryEnabled]=\"pointerSummaryEnabled\"\n      (pointerSummaryStatus)=\"pointerSummaryStatus.emit($event)\"\n      [searchResultsGeometryEnabled]=\"searchResultsGeometryEnabled\"\n      (searchResultsGeometryStatus)=\"searchResultsGeometryStatus.emit($event)\"\n      [reverseSearchCoordsFormatEnabled]=\"reverseSearchCoordsFormatEnabled\"\n      (reverseSearchCoordsFormatStatus)=\"\n        reverseSearchCoordsFormatStatus.emit($event)\n      \"\n      (searchSourceChange)=\"onSearchSettingsChange()\"\n    >\n    </igo-search-settings>\n  </div>\n</div>\n", styles: [":host ::ng-deep .mat-mdc-form-field-subscript-wrapper{display:none}:host ::ng-deep .mat-mdc-text-field-wrapper{align-items:center;padding-right:0}:host ::ng-deep .mat-mdc-form-field-infix{align-self:center}@media (max-width: 599px){:host ::ng-deep .mat-mdc-form-field-infix{width:158px}}:host ::ng-deep mat-form-field .mdc-line-ripple{display:none}:host ::ng-deep mat-form-field input{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.igo-search-bar-container{position:relative;width:100%;display:flex}mat-form-field{flex:1}mat-divider{margin:8px 0}.search-bar-buttons{position:relative;display:inline-flex}.search-bar-buttons>button:nth-child(2):before{content:\"\";border-right:1px solid #ddd;height:28px}igo-search-selector{background-color:#fff;top:0;border-radius:0}igo-search-settings{background-color:#fff;top:0;border-radius:0}\n"], dependencies: [{ kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i4.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i4.MatLabel, selector: "mat-label" }, { kind: "directive", type: i4.MatSuffix, selector: "[matSuffix], [matIconSuffix], [matTextSuffix]", inputs: ["matTextSuffix"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i5.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"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i6.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i7.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i8.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatDividerModule }, { kind: "component", type: i9.MatDivider, selector: "mat-divider", inputs: ["vertical", "inset"] }, { kind: "component", type: SearchSelectorComponent, selector: "igo-search-selector", inputs: ["searchTypes", "searchType"], outputs: ["searchTypeChange"] }, { kind: "component", type: SearchSettingsComponent, selector: "igo-search-settings", inputs: ["pointerSummaryEnabled", "searchResultsGeometryEnabled", "reverseSearchCoordsFormatEnabled"], outputs: ["searchSourceChange", "pointerSummaryStatus", "searchResultsGeometryStatus", "reverseSearchCoordsFormatStatus"] }, { kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "ngmodule", type: IgoLanguageModule }, { kind: "pipe", type: i10.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchBarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'igo-search-bar', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                        NgClass,
+                        MatFormFieldModule,
+                        NgIf,
+                        MatInputModule,
+                        MatButtonModule,
+                        MatTooltipModule,
+                        MatIconModule,
+                        MatDividerModule,
+                        SearchSelectorComponent,
+                        SearchSettingsComponent,
+                        AsyncPipe,
+                        IgoLanguageModule
+                    ], template: "<div class=\"igo-search-bar-container\" [ngClass]=\"{ empty: empty$ | async }\">\n  <mat-form-field [floatLabel]=\"floatLabel\" [appearance]=\"appearance\">\n    <mat-label *ngIf=\"label\">{{ label }}</mat-label>\n    <input\n      #input\n      matInput\n      autocomplete=\"off\"\n      [ngClass]=\"{ hasSearchIcon: showSearchButton }\"\n      [disabled]=\"disabled$ | async\"\n      [placeholder]=\"\n        placeholder\n          ? placeholder\n          : (placeholder$ | async)\n            ? (placeholder$.value | translate)\n            : undefined\n      \"\n      [value]=\"term$ | async\"\n      (keyup)=\"onKeyup($event)\"\n    />\n    <button\n      *ngIf=\"(empty$ | async) === false\"\n      mat-icon-button\n      matSuffix\n      [color]=\"color\"\n      (click)=\"onClearButtonClick()\"\n      [matTooltip]=\"'igo.geo.search.clearSearch' | translate\"\n    >\n      <mat-icon>close</mat-icon>\n    </button>\n  </mat-form-field>\n\n  <mat-divider *ngIf=\"withDivider\" [vertical]=\"true\"></mat-divider>\n\n  <div class=\"search-bar-buttons\">\n    <button\n      *ngIf=\"showSearchButton\"\n      mat-icon-button\n      [color]=\"color\"\n      (click)=\"handleSearch()\"\n    >\n      <mat-icon>search</mat-icon>\n    </button>\n\n    <igo-search-selector\n      *ngIf=\"searchSelector\"\n      [searchTypes]=\"searchTypes\"\n      [searchType]=\"searchType$ | async\"\n      (searchTypeChange)=\"onSearchTypeChange($event)\"\n    >\n    </igo-search-selector>\n\n    <igo-search-settings\n      *ngIf=\"searchSettings\"\n      [pointerSummaryEnabled]=\"pointerSummaryEnabled\"\n      (pointerSummaryStatus)=\"pointerSummaryStatus.emit($event)\"\n      [searchResultsGeometryEnabled]=\"searchResultsGeometryEnabled\"\n      (searchResultsGeometryStatus)=\"searchResultsGeometryStatus.emit($event)\"\n      [reverseSearchCoordsFormatEnabled]=\"reverseSearchCoordsFormatEnabled\"\n      (reverseSearchCoordsFormatStatus)=\"\n        reverseSearchCoordsFormatStatus.emit($event)\n      \"\n      (searchSourceChange)=\"onSearchSettingsChange()\"\n    >\n    </igo-search-settings>\n  </div>\n</div>\n", styles: [":host ::ng-deep .mat-mdc-form-field-subscript-wrapper{display:none}:host ::ng-deep .mat-mdc-text-field-wrapper{align-items:center;padding-right:0}:host ::ng-deep .mat-mdc-form-field-infix{align-self:center}@media (max-width: 599px){:host ::ng-deep .mat-mdc-form-field-infix{width:158px}}:host ::ng-deep mat-form-field .mdc-line-ripple{display:none}:host ::ng-deep mat-form-field input{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.igo-search-bar-container{position:relative;width:100%;display:flex}mat-form-field{flex:1}mat-divider{margin:8px 0}.search-bar-buttons{position:relative;display:inline-flex}.search-bar-buttons>button:nth-child(2):before{content:\"\";border-right:1px solid #ddd;height:28px}igo-search-selector{background-color:#fff;top:0;border-radius:0}igo-search-settings{background-color:#fff;top:0;border-radius:0}\n"] }]
+        }], ctorParameters: () => [{ type: i1.ConfigService }, { type: i2.SearchService }, { type: i3.SearchSourceService }], propDecorators: { searchTypes: [{
+                type: Input
+            }], withDivider: [{
+                type: Input
+            }], searchType: [{
+                type: Input
+            }], pointerSummaryStatus: [{
+                type: Output
+            }], searchResultsGeometryStatus: [{
+                type: Output
+            }], reverseSearchCoordsFormatStatus: [{
+                type: Output
+            }], term: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], pointerSummaryEnabled: [{
+                type: Input
+            }], searchResultsGeometryEnabled: [{
+                type: Input
+            }], reverseSearchCoordsFormatEnabled: [{
+                type: Input
+            }], floatLabel: [{
+                type: Input
+            }], appearance: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], termSplitter: [{
+                type: Input
+            }], debounce: [{
+                type: Input
+            }], minLength: [{
+                type: Input
+            }], searchSelector: [{
+                type: Input
+            }], searchSettings: [{
+                type: Input
+            }], forceNA: [{
+                type: Input
+            }], store: [{
+                type: Input
+            }], searchTermChange: [{
+                type: Output
+            }], search: [{
+                type: Output
+            }], searchTypeChange: [{
+                type: Output
+            }], clearFeature: [{
+                type: Output
+            }], searchSettingsChange: [{
+                type: Output
+            }], input: [{
+                type: ViewChild,
+                args: ['input', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-bar.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/search/search-bar/search-bar.component.ts","../../../../../../packages/geo/src/lib/search/search-bar/search-bar.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AsyncPipe, NgClass, NgIf } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  ViewChild\n} from '@angular/core';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatDividerModule } from '@angular/material/divider';\nimport {\n  FloatLabelType,\n  MatFormFieldAppearance,\n  MatFormFieldModule\n} from '@angular/material/form-field';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatInputModule } from '@angular/material/input';\nimport { MatTooltipModule } from '@angular/material/tooltip';\n\nimport { EntityStore } from '@igo2/common/entity';\nimport { ConfigService } from '@igo2/core/config';\nimport { IgoLanguageModule } from '@igo2/core/language';\n\nimport { BehaviorSubject, Subscription, timer } from 'rxjs';\nimport { debounce, distinctUntilChanged } from 'rxjs/operators';\n\nimport { SearchSelectorComponent } from '../search-selector/search-selector.component';\nimport { SearchSettingsComponent } from '../search-settings/search-settings.component';\nimport { SearchSourceService } from '../shared/search-source.service';\nimport { SEARCH_TYPES } from '../shared/search.enums';\nimport { Research, SearchResult } from '../shared/search.interfaces';\nimport { SearchService } from '../shared/search.service';\n\n/**\n * Searchbar that triggers a research in all search sources enabled.\n * If the store input is defined, the search results will be loaded\n * into that store. An event is always emitted when a research is completed.\n */\n@Component({\n  selector: 'igo-search-bar',\n  templateUrl: './search-bar.component.html',\n  styleUrls: ['./search-bar.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    NgClass,\n    MatFormFieldModule,\n    NgIf,\n    MatInputModule,\n    MatButtonModule,\n    MatTooltipModule,\n    MatIconModule,\n    MatDividerModule,\n    SearchSelectorComponent,\n    SearchSettingsComponent,\n    AsyncPipe,\n    IgoLanguageModule\n  ]\n})\nexport class SearchBarComponent implements OnInit, OnDestroy {\n  /**\n   * Invalid keys\n   */\n  static invalidKeys = [\n    'Control',\n    'Shift',\n    'Alt',\n    'ArrowDown',\n    'ArrowUp',\n    'ArrowRight',\n    'ArrowLeft'\n  ];\n\n  readonly placeholder$ = new BehaviorSubject<string>(\n    'igo.geo.search.placeholder'\n  );\n\n  readonly empty$ = new BehaviorSubject<boolean>(true);\n\n  /**\n   * Subscription to the ssearch bar term\n   */\n  private term$$: Subscription;\n\n  /**\n   * Search term stream\n   */\n  private stream$ = new BehaviorSubject<string>('');\n\n  /**\n   * Subscription to the search term stream\n   */\n  private stream$$: Subscription;\n\n  /**\n   * Subscription to the search type\n   */\n  private searchType$$: Subscription;\n\n  private researches$$: Subscription[];\n\n  /**\n   * whether to show search button or not\n   */\n\n  public showSearchButton = false;\n\n  /**\n   * List of available search types\n   */\n  @Input() searchTypes: string[] = SEARCH_TYPES;\n\n  @Input() withDivider: boolean;\n\n  /**\n   * Search term\n   */\n  @Input()\n  set searchType(value: string) {\n    this.setSearchType(value);\n  }\n  get searchType(): string {\n    return this.searchType$.value;\n  }\n  readonly searchType$ = new BehaviorSubject<string>(undefined);\n\n  /**\n   * Event emitted when the pointer summary is activated by the searchbar setting\n   */\n  @Output() pointerSummaryStatus = new EventEmitter<boolean>();\n\n  /**\n   * Event emitted when the show geometry setting is changed\n   */\n  @Output() searchResultsGeometryStatus = new EventEmitter<boolean>();\n\n  /**\n   * Event emitted when the coords format setting is changed\n   */\n  @Output() reverseSearchCoordsFormatStatus = new EventEmitter<boolean>();\n\n  /**\n   * Search term\n   */\n  @Input()\n  set term(value: string) {\n    this.setTerm(value);\n  }\n  get term(): string {\n    return this.term$.value;\n  }\n  readonly term$ = new BehaviorSubject<string>('');\n\n  /**\n   * Whether this component is disabled\n   */\n  @Input()\n  set disabled(value: boolean) {\n    this.disabled$.next(value);\n  }\n  get disabled(): boolean {\n    return this.disabled$.value;\n  }\n  readonly disabled$ = new BehaviorSubject<boolean>(false);\n\n  @Input() pointerSummaryEnabled = false;\n  @Input() searchResultsGeometryEnabled = false;\n\n  /**\n   * When reverse coordinates status change\n   */\n  @Input()\n  get reverseSearchCoordsFormatEnabled(): boolean {\n    return this._reverseSearchCoordsFormatEnabled;\n  }\n  set reverseSearchCoordsFormatEnabled(value: boolean) {\n    this._reverseSearchCoordsFormatEnabled = value;\n    this.setTerm(this.term, true);\n  }\n  private _reverseSearchCoordsFormatEnabled = false;\n\n  /**\n   * Whether a float label should be displayed\n   */\n  @Input() floatLabel: FloatLabelType = 'auto';\n\n  @Input() appearance: MatFormFieldAppearance = 'fill';\n\n  @Input() placeholder: string;\n\n  @Input() label: string;\n\n  /**\n   * Icons color (search and clear)\n   */\n  @Input() color = 'primary';\n\n  @Input() termSplitter = '|';\n\n  /**\n   * Debounce time between each keystroke\n   */\n  @Input() debounce = 200;\n\n  /**\n   * Minimum term length required to trigger a research\n   */\n  @Input() minLength = 2;\n\n  /**\n   * Search Selector\n   */\n  @Input() searchSelector = false;\n\n  /**\n   * Search Settings\n   */\n  @Input() searchSettings = false;\n\n  /**\n   * Force coordinates in north america\n   */\n  @Input() forceNA = false;\n\n  /**\n   * Search results store\n   */\n  @Input() store: EntityStore<SearchResult>;\n\n  /**\n   * Event emitted when the search term changes\n   */\n  @Output() searchTermChange = new EventEmitter<string>();\n\n  /**\n   * Event emitted when a research is completed\n   */\n  @Output() search = new EventEmitter<{\n    research: Research;\n    results: SearchResult[];\n  }>();\n\n  /**\n   * Event emitted when the search type changes\n   */\n  @Output() searchTypeChange = new EventEmitter<string>();\n\n  /**\n   * Event emitted when the search type changes\n   */\n  @Output() clearFeature = new EventEmitter();\n\n  /**\n   * Event emitted when the search settings changes\n   */\n  @Output() searchSettingsChange = new EventEmitter();\n\n  /**\n   * Input element\n   * @internal\n   */\n  @ViewChild('input', { static: true }) input: ElementRef;\n\n  /**\n   * Whether the search bar is empty\n   * @internal\n   */\n  get empty(): boolean {\n    return this.term.length === 0;\n  }\n\n  constructor(\n    private configService: ConfigService,\n    private searchService: SearchService,\n    private searchSourceService: SearchSourceService\n  ) {}\n\n  /**\n   * Subscribe to the search term stream and trigger researches\n   * @internal\n   */\n  ngOnInit(): void {\n    this.term$$ = this.term$.subscribe((term: string) => {\n      this.empty$.next(term === undefined || term.length === 0);\n    });\n\n    this.stream$$ = this.stream$\n      .pipe(debounce(() => timer(this.debounce)))\n      .subscribe((term: string) => this.onSetTerm(term));\n\n    this.handlePlaceholder();\n\n    this.searchType$$ = this.searchType$\n      .pipe(distinctUntilChanged())\n      .subscribe((searchType: string) => this.onSetSearchType(searchType));\n\n    const configValue = this.configService.getConfig(\n      'searchBar.showSearchButton'\n    );\n    this.showSearchButton = configValue !== undefined ? configValue : false;\n  }\n\n  /**\n   * Unsubscribe to the search term stream\n   * @internal\n   */\n  ngOnDestroy() {\n    this.term$$.unsubscribe();\n    this.stream$$.unsubscribe();\n    this.searchType$$.unsubscribe();\n  }\n\n  /**\n   * When a user types, validates the key and send it into the\n   * stream if it's valid\n   * @param event Keyboard event\n   * @internal\n   */\n  onKeyup(event: KeyboardEvent) {\n    const key = event.key;\n    if (!this.keyIsValid(key)) {\n      return;\n    }\n    const term = (event.target as HTMLInputElement).value;\n    this.setTerm(term);\n  }\n\n  /**\n   * Clear the stream and the input\n   * @internal\n   */\n  onClearButtonClick() {\n    this.clear();\n    this.clearFeature.emit();\n  }\n\n  /**\n   * Update search type\n   * @param searchType Enabled search type\n   * @internal\n   */\n  onSearchTypeChange(searchType: string) {\n    this.setSearchType(searchType);\n  }\n\n  /**\n   * Update the placeholder with the enabled search type. The placeholder\n   * for all availables search typers needs to be defined in the locale\n   * files or an error will be thrown.\n   * @param searchType Enabled search type\n   * @internal\n   */\n  setSearchType(searchType: string) {\n    this.searchType$.next(searchType);\n  }\n\n  onSearchSettingsChange() {\n    this.doSearch(this.term);\n    this.searchSettingsChange.emit();\n    this.handlePlaceholder();\n  }\n\n  /**\n   * Send the term into the stream only if this component is not disabled\n   * @param term Search term\n   */\n  setTerm(term: string, reverseCoordEvent?: boolean) {\n    if (this.disabled) {\n      return;\n    }\n\n    term = term || '';\n\n    if (term !== this.term && !reverseCoordEvent) {\n      this.term$.next(term);\n    }\n\n    const slug = term.replace(/(#[^\\s]*)/g, '').trim();\n    if (slug.length >= this.minLength || slug.length === 0) {\n      this.stream$.next(term);\n    }\n  }\n\n  handleSearch(): void {\n    this.doSearch(this.term);\n  }\n\n  /**\n   * Clear the stream and the input\n   */\n  private clear() {\n    this.term$.next('');\n    this.stream$.next('');\n    this.input.nativeElement.focus();\n  }\n\n  /**\n   * Validate if a given key stroke is a valid input\n   */\n  private keyIsValid(key: string) {\n    return SearchBarComponent.invalidKeys.indexOf(key) === -1;\n  }\n\n  /**\n   * When the search term changes, emit an event and trigger a\n   * research in every enabled search sources.\n   * @param term Search term\n   */\n  private onSetTerm(term: string | undefined) {\n    this.searchTermChange.emit(term);\n    this.doSearch(term);\n  }\n\n  private handlePlaceholder() {\n    const searchTypes = [\n      ...new Set(\n        this.searchSourceService\n          .getEnabledSources()\n          .filter((ss) => !['map', 'coordinatesreverse'].includes(ss.getId()))\n          .map((ss) => ss.getType())\n      )\n    ];\n\n    let placeholder = `igo.geo.search.placeholder`;\n    if (searchTypes.length === 1) {\n      placeholder = `igo.geo.search.${searchTypes[0].toLowerCase()}.placeholder`;\n    } else if (searchTypes.length === 0) {\n      placeholder = `igo.geo.search.emptyType.placeholder`;\n    }\n    this.placeholder$.next(placeholder);\n  }\n\n  private onSetSearchType(searchType: string) {\n    if (searchType === undefined || searchType === null) {\n      return;\n    }\n\n    this.searchTypeChange.emit(searchType);\n\n    const placeholder = `igo.geo.search.${searchType.toLowerCase()}.placeholder`;\n    this.placeholder$.next(placeholder);\n\n    this.setTerm(this.term);\n  }\n\n  /**\n   * Execute the search\n   * @param term Search term\n   */\n  private doSearch(rawTerm: string | undefined) {\n    if (this.researches$$) {\n      this.researches$$.map((research) => research.unsubscribe());\n      this.researches$$ = undefined;\n    }\n\n    let terms;\n    if (\n      this.termSplitter &&\n      rawTerm.match(new RegExp(this.termSplitter, 'g'))\n    ) {\n      terms = rawTerm\n        .split(this.termSplitter)\n        .filter((t) => t.length >= this.minLength);\n      if (this.store) {\n        this.store.clear();\n      }\n    } else {\n      terms = [rawTerm];\n    }\n\n    let researches: Research[] = [];\n    terms.map((term: string) => {\n      const slug = term ? term.replace(/(#[^\\s]*)/g, '').trim() : '';\n      if (slug === '') {\n        if (this.store !== undefined) {\n          this.store.clear();\n        }\n        return;\n      }\n\n      researches = researches.concat(\n        this.searchService.search(term, {\n          forceNA: this.forceNA\n        })\n      );\n    });\n    this.researches$$ = researches.map((research) => {\n      return research.request.subscribe((results: SearchResult[]) => {\n        this.onResearchCompleted(research, results);\n      });\n    });\n  }\n\n  /**\n   * When a research  is completed, emit an event and update\n   * the store's items.\n   * @param research Research\n   * @param results Research results\n   */\n  private onResearchCompleted(research: Research, results: SearchResult[]) {\n    this.search.emit({ research, results });\n\n    if (this.store !== undefined) {\n      const newResults = this.store\n        .all()\n        .filter((result) => result.source !== research.source)\n        .concat(results);\n      this.store.updateMany(newResults);\n    }\n  }\n}\n","<div class=\"igo-search-bar-container\" [ngClass]=\"{ empty: empty$ | async }\">\n  <mat-form-field [floatLabel]=\"floatLabel\" [appearance]=\"appearance\">\n    <mat-label *ngIf=\"label\">{{ label }}</mat-label>\n    <input\n      #input\n      matInput\n      autocomplete=\"off\"\n      [ngClass]=\"{ hasSearchIcon: showSearchButton }\"\n      [disabled]=\"disabled$ | async\"\n      [placeholder]=\"\n        placeholder\n          ? placeholder\n          : (placeholder$ | async)\n            ? (placeholder$.value | translate)\n            : undefined\n      \"\n      [value]=\"term$ | async\"\n      (keyup)=\"onKeyup($event)\"\n    />\n    <button\n      *ngIf=\"(empty$ | async) === false\"\n      mat-icon-button\n      matSuffix\n      [color]=\"color\"\n      (click)=\"onClearButtonClick()\"\n      [matTooltip]=\"'igo.geo.search.clearSearch' | translate\"\n    >\n      <mat-icon>close</mat-icon>\n    </button>\n  </mat-form-field>\n\n  <mat-divider *ngIf=\"withDivider\" [vertical]=\"true\"></mat-divider>\n\n  <div class=\"search-bar-buttons\">\n    <button\n      *ngIf=\"showSearchButton\"\n      mat-icon-button\n      [color]=\"color\"\n      (click)=\"handleSearch()\"\n    >\n      <mat-icon>search</mat-icon>\n    </button>\n\n    <igo-search-selector\n      *ngIf=\"searchSelector\"\n      [searchTypes]=\"searchTypes\"\n      [searchType]=\"searchType$ | async\"\n      (searchTypeChange)=\"onSearchTypeChange($event)\"\n    >\n    </igo-search-selector>\n\n    <igo-search-settings\n      *ngIf=\"searchSettings\"\n      [pointerSummaryEnabled]=\"pointerSummaryEnabled\"\n      (pointerSummaryStatus)=\"pointerSummaryStatus.emit($event)\"\n      [searchResultsGeometryEnabled]=\"searchResultsGeometryEnabled\"\n      (searchResultsGeometryStatus)=\"searchResultsGeometryStatus.emit($event)\"\n      [reverseSearchCoordsFormatEnabled]=\"reverseSearchCoordsFormatEnabled\"\n      (reverseSearchCoordsFormatStatus)=\"\n        reverseSearchCoordsFormatStatus.emit($event)\n      \"\n      (searchSourceChange)=\"onSearchSettingsChange()\"\n    >\n    </igo-search-settings>\n  </div>\n</div>\n"]}

package/esm2022/lib/search/search-bar/search-bar.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { SearchBarComponent } from './search-bar.component';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated import the SearchBarComponent directly
+ */
+export class IgoSearchBarModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoSearchBarModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: IgoSearchBarModule, imports: [SearchBarComponent], exports: [SearchBarComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoSearchBarModule, imports: [SearchBarComponent] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoSearchBarModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [SearchBarComponent],
+                    exports: [SearchBarComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLWJhci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9zZWFyY2gvc2VhcmNoLWJhci9zZWFyY2gtYmFyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDOztBQUU1RDs7R0FFRztBQUtILE1BQU0sT0FBTyxrQkFBa0I7d0dBQWxCLGtCQUFrQjt5R0FBbEIsa0JBQWtCLFlBSG5CLGtCQUFrQixhQUNsQixrQkFBa0I7eUdBRWpCLGtCQUFrQixZQUhuQixrQkFBa0I7OzRGQUdqQixrQkFBa0I7a0JBSjlCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsa0JBQWtCLENBQUM7b0JBQzdCLE9BQU8sRUFBRSxDQUFDLGtCQUFrQixDQUFDO2lCQUM5QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFNlYXJjaEJhckNvbXBvbmVudCB9IGZyb20gJy4vc2VhcmNoLWJhci5jb21wb25lbnQnO1xuXG4vKipcbiAqIEBkZXByZWNhdGVkIGltcG9ydCB0aGUgU2VhcmNoQmFyQ29tcG9uZW50IGRpcmVjdGx5XG4gKi9cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtTZWFyY2hCYXJDb21wb25lbnRdLFxuICBleHBvcnRzOiBbU2VhcmNoQmFyQ29tcG9uZW50XVxufSlcbmV4cG9ydCBjbGFzcyBJZ29TZWFyY2hCYXJNb2R1bGUge31cbiJdfQ==

package/esm2022/lib/search/search-results/index.mjs

@@ -0,0 +1,5 @@
+export * from './search-results-add-button.component';
+export * from './search-results.component';
+export * from './search-results.module';
+export * from './search-results.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9zZWFyY2gvc2VhcmNoLXJlc3VsdHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyw0QkFBNEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLXJlc3VsdHMtYWRkLWJ1dHRvbi5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2gtcmVzdWx0cy5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2gtcmVzdWx0cy5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2gtcmVzdWx0cy5kaXJlY3RpdmUnO1xuIl19