@igo2/geo 18.0.1-next.2 → 18.0.2

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

@@ -0,0 +1,77 @@
+import { NgModule } from '@angular/core';
+import { SearchBarComponent } from './search-bar/search-bar.component';
+import { IgoSearchBarModule } from './search-bar/search-bar.module';
+import { SEARCH_RESULTS_DIRECTIVES } from './search-results';
+import { IgoSearchResultsModule } from './search-results/search-results.module';
+import { SearchSelectorComponent } from './search-selector/search-selector.component';
+import { IgoSearchSelectorModule } from './search-selector/search-selector.module';
+import { SearchSettingsComponent } from './search-settings/search-settings.component';
+import { IgoSearchSettingsModule } from './search-settings/search-settings.module';
+import { SearchPointerSummaryDirective } from './shared/search-pointer-summary.directive';
+import { provideSearchSourceService } from './shared/search-source-service.providers';
+import { SearchService } from './shared/search.service';
+import { provideDefaultCoordinatesSearchResultFormatter } from './shared/sources/coordinates.providers';
+import { provideDefaultIChercheSearchResultFormatter } from './shared/sources/icherche.providers';
+import { provideILayerSearchResultFormatter } from './shared/sources/ilayer.providers';
+import * as i0 from "@angular/core";
+export const SEARCH_DIRECTIVES = [
+    SearchBarComponent,
+    SearchSelectorComponent,
+    ...SEARCH_RESULTS_DIRECTIVES,
+    SearchSettingsComponent,
+    SearchPointerSummaryDirective
+];
+export class IgoSearchModule {
+    /**
+     * @deprecated import the provideSearch() directly and add the source in the provider property
+     */
+    static forRoot() {
+        return {
+            ngModule: IgoSearchModule,
+            providers: [
+                SearchService,
+                provideSearchSourceService(),
+                provideDefaultIChercheSearchResultFormatter(),
+                provideDefaultCoordinatesSearchResultFormatter(),
+                provideILayerSearchResultFormatter()
+            ]
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoSearchModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: IgoSearchModule, imports: [IgoSearchBarModule,
+            IgoSearchSelectorModule,
+            IgoSearchResultsModule,
+            IgoSearchSettingsModule,
+            SearchPointerSummaryDirective], exports: [IgoSearchBarModule,
+            IgoSearchSelectorModule,
+            IgoSearchResultsModule,
+            IgoSearchSettingsModule,
+            SearchPointerSummaryDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoSearchModule, imports: [IgoSearchBarModule,
+            IgoSearchSelectorModule,
+            IgoSearchResultsModule,
+            IgoSearchSettingsModule, IgoSearchBarModule,
+            IgoSearchSelectorModule,
+            IgoSearchResultsModule,
+            IgoSearchSettingsModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoSearchModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        IgoSearchBarModule,
+                        IgoSearchSelectorModule,
+                        IgoSearchResultsModule,
+                        IgoSearchSettingsModule,
+                        SearchPointerSummaryDirective
+                    ],
+                    exports: [
+                        IgoSearchBarModule,
+                        IgoSearchSelectorModule,
+                        IgoSearchResultsModule,
+                        IgoSearchSettingsModule,
+                        SearchPointerSummaryDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/search/shared/index.mjs

@@ -0,0 +1,10 @@
+export * from './search.enums';
+export * from './search.provider';
+export * from './search.interfaces';
+export * from './search-pointer-summary.directive';
+export * from './search.service';
+export * from './search-source.service';
+export * from './search-source-service.providers';
+export * from './search.utils';
+export * from './sources';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9zZWFyY2gvc2hhcmVkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFdBQVcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLmVudW1zJztcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLnByb3ZpZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLmludGVyZmFjZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2gtcG9pbnRlci1zdW1tYXJ5LmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLXNvdXJjZS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLXNvdXJjZS1zZXJ2aWNlLnByb3ZpZGVycyc7XG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC51dGlscyc7XG5leHBvcnQgKiBmcm9tICcuL3NvdXJjZXMnO1xuIl19

package/esm2022/lib/search/shared/search-pointer-summary.directive.mjs

@@ -0,0 +1,328 @@
+import { Directive, HostListener, Input, Self } from '@angular/core';
+import { EntityStore } from '@igo2/common/entity';
+import { MediaService } from '@igo2/core/media';
+import { SubjectStatus } from '@igo2/utils';
+import olFeature from 'ol/Feature';
+import { unByKey } from 'ol/Observable';
+import OlGeoJSON from 'ol/format/GeoJSON';
+import * as olgeom from 'ol/geom';
+import { transform } from 'ol/proj';
+import { first } from 'rxjs';
+import { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';
+import { tryBindStoreLayer } from '../../feature/shared/feature-store.utils';
+import { FEATURE, FeatureMotion } from '../../feature/shared/feature.enums';
+import { FeatureStore } from '../../feature/shared/store';
+import { VectorLayer } from '../../layer/shared/layers/vector-layer';
+import { MapBrowserComponent } from '../../map/map-browser/map-browser.component';
+import { pointerPositionSummaryMarkerStyle } from '../../style/shared/feature/feature-style';
+import { SearchSourceService } from './search-source.service';
+import { SearchService } from './search.service';
+import { sourceCanReverseSearchAsSummary } from './search.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../map/map-browser/map-browser.component";
+import * as i2 from "./search.service";
+import * as i3 from "./search-source.service";
+import * as i4 from "@igo2/core/media";
+/**
+ * This directive makes the mouse coordinate trigger a reverse search on available search sources.
+ * The search results are placed into a label, on a cross icon, representing the mouse coordinate.
+ * By default, no search sources. Config in config file must be defined.
+ * the layer level.
+ */
+export class SearchPointerSummaryDirective {
+    component;
+    searchService;
+    searchSourceService;
+    mediaService;
+    store;
+    lonLat;
+    pointerSearchStore = new EntityStore([]);
+    lastTimeoutRequest;
+    store$$;
+    reverseSearch$$ = [];
+    hasPointerReverseSearchSource = false;
+    /**
+     * Listener to the pointer move event
+     */
+    pointerMoveListener;
+    searchPointerSummaryFeatureId = 'searchPointerSummaryFeatureId';
+    /**
+     * The delay where the mouse must be motionless before trigger the reverse search
+     */
+    igoSearchPointerSummaryDelay = 1000;
+    /**
+     * If the user has enabled or not the directive
+     */
+    igoSearchPointerSummaryEnabled = false;
+    mouseleave() {
+        clearTimeout(this.lastTimeoutRequest);
+        this.clearLayer();
+    }
+    /**
+     * IGO map
+     * @internal
+     */
+    get map() {
+        return this.component.map;
+    }
+    get mapProjection() {
+        return this.component.map.projection;
+    }
+    constructor(component, searchService, searchSourceService, mediaService) {
+        this.component = component;
+        this.searchService = searchService;
+        this.searchSourceService = searchSourceService;
+        this.mediaService = mediaService;
+    }
+    /**
+     * Start listening to pointermove and reverse search results.
+     * @internal
+     */
+    ngOnInit() {
+        this.listenToMapPointerMove();
+        this.map.status$
+            .pipe(first((status) => status === SubjectStatus.Done))
+            .subscribe(() => {
+            this.store = new FeatureStore([], { map: this.map });
+            this.initStore();
+            this.subscribeToPointerStore();
+        });
+    }
+    /**
+     * Initialize the pointer position store
+     * @internal
+     */
+    initStore() {
+        const store = this.store;
+        const layer = new VectorLayer({
+            isIgoInternalLayer: true,
+            id: 'searchPointerSummaryId',
+            title: 'searchPointerSummary',
+            zIndex: 900,
+            source: new FeatureDataSource(),
+            showInLayerList: false,
+            exportable: false,
+            browsable: false,
+            style: pointerPositionSummaryMarkerStyle
+        });
+        tryBindStoreLayer(store, layer);
+    }
+    ngAfterContentChecked() {
+        if (!this.searchSourceService
+            .getEnabledSources()
+            .filter(sourceCanReverseSearchAsSummary).length) {
+            this.hasPointerReverseSearchSource = false;
+        }
+        else {
+            this.hasPointerReverseSearchSource = true;
+        }
+    }
+    /**
+     * Stop listening to pointermove and reverse search results.
+     * @internal
+     */
+    ngOnDestroy() {
+        this.unlistenToMapPointerMove();
+        this.unsubscribeToPointerStore();
+        this.unsubscribeReverseSearch();
+    }
+    /**
+     * Subscribe to pointermove result store
+     * @internal
+     */
+    subscribeToPointerStore() {
+        this.store$$ = this.pointerSearchStore.entities$.subscribe((resultsUnderPointerPosition) => {
+            this.entitiesToPointerOverlay(resultsUnderPointerPosition);
+        });
+    }
+    /**
+     * Build an object based on the closest feature by type (base on type and distance properties )
+     * @param results SearchResult[]
+     * @returns OL style function
+     */
+    computeSummaryClosestFeature(results) {
+        const closestResultByType = {};
+        results.map((result) => {
+            if (result.data.properties.type && result.data.properties.distance >= 0) {
+                // eslint-disable-next-line no-prototype-builtins
+                if (closestResultByType.hasOwnProperty(result.data.properties.type)) {
+                    const prevDistance = closestResultByType[result.data.properties.type].distance;
+                    if (result.data.properties.distance < prevDistance) {
+                        const title = result.meta.pointerSummaryTitle || result.meta.title;
+                        closestResultByType[result.data.properties.type] = {
+                            distance: result.data.properties.distance,
+                            title
+                        };
+                    }
+                }
+                else {
+                    const title = result.meta.pointerSummaryTitle || result.meta.title;
+                    closestResultByType[result.data.properties.type] = {
+                        distance: result.data.properties.distance,
+                        title
+                    };
+                }
+            }
+        });
+        return closestResultByType;
+    }
+    /**
+     * convert store entities to a pointer position overlay with label summary on.
+     * @param event OL map browser pointer event
+     */
+    entitiesToPointerOverlay(resultsUnderPointerPosition) {
+        const closestResultByType = this.computeSummaryClosestFeature(resultsUnderPointerPosition);
+        const summarizedClosestType = Object.keys(closestResultByType);
+        const processedSummarizedClosestType = [];
+        const summary = [];
+        resultsUnderPointerPosition.map((result) => {
+            const typeIndex = summarizedClosestType.indexOf(result.data.properties.type);
+            if (typeIndex !== -1) {
+                summary.push(closestResultByType[result.data.properties.type].title);
+                summarizedClosestType.splice(typeIndex, 1);
+                processedSummarizedClosestType.push(result.data.properties.type);
+            }
+            else {
+                if (processedSummarizedClosestType.indexOf(result.data.properties.type) === -1) {
+                    summary.push(result.meta.pointerSummaryTitle || result.meta.title);
+                }
+            }
+        });
+        if (summary.length) {
+            this.addPointerOverlay(summary.join('\n'));
+        }
+    }
+    /**
+     * On map pointermove
+     */
+    listenToMapPointerMove() {
+        this.pointerMoveListener = this.map.ol.on('pointermove', (event) => this.onMapEvent(event));
+    }
+    /**
+     * Unsubscribe to pointer store.
+     * @internal
+     */
+    unsubscribeToPointerStore() {
+        this.store$$?.unsubscribe();
+    }
+    /**
+     * Unsubscribe to reverse seatch store.
+     * @internal
+     */
+    unsubscribeReverseSearch() {
+        this.reverseSearch$$.map((s) => s.unsubscribe());
+        this.reverseSearch$$ = [];
+    }
+    /**
+     * Stop listening for map pointermove
+     * @internal
+     */
+    unlistenToMapPointerMove() {
+        unByKey(this.pointerMoveListener);
+        this.pointerMoveListener = undefined;
+    }
+    /**
+     * Trigger reverse search when the mouse is motionless during the defined delay (pointerMoveDelay).
+     * @param event OL map browser pointer event
+     */
+    onMapEvent(event) {
+        if (event.dragging ||
+            !this.igoSearchPointerSummaryEnabled ||
+            !this.hasPointerReverseSearchSource ||
+            this.mediaService.isTouchScreen()) {
+            this.clearLayer();
+            return;
+        }
+        if (typeof this.lastTimeoutRequest !== 'undefined') {
+            // cancel timeout when the mouse moves
+            clearTimeout(this.lastTimeoutRequest);
+            this.clearLayer();
+            this.unsubscribeReverseSearch();
+        }
+        this.lonLat = transform(event.coordinate, this.mapProjection, 'EPSG:4326');
+        this.lastTimeoutRequest = setTimeout(() => {
+            this.onSearchCoordinate();
+        }, this.igoSearchPointerSummaryDelay);
+    }
+    /**
+     * Sort the results by display order.
+     * @param r1 First result
+     * @param r2 Second result
+     */
+    sortByOrder(r1, r2) {
+        return r1.source.displayOrder - r2.source.displayOrder;
+    }
+    onSearchCoordinate() {
+        this.pointerSearchStore.clear();
+        const results = this.searchService.reverseSearch(this.lonLat, { params: { geometry: 'false', icon: 'false' } }, true);
+        for (const i in results) {
+            if (results.length > 0) {
+                this.reverseSearch$$.push(results[i].request.subscribe((_results) => {
+                    this.onSearch({ research: results[i], results: _results });
+                }));
+            }
+        }
+    }
+    onSearch(event) {
+        const results = event.results;
+        const newResults = this.pointerSearchStore
+            .all()
+            .filter((result) => result.source !== event.research.source)
+            .concat(results);
+        this.pointerSearchStore.load(newResults.sort(this.sortByOrder));
+    }
+    /**
+     * Add a feature to the pointer store
+     * @param text string
+     */
+    addPointerOverlay(text) {
+        this.clearLayer();
+        const geometry = new olgeom.Point(transform(this.lonLat, 'EPSG:4326', this.mapProjection));
+        const feature = new olFeature({ geometry });
+        const geojsonGeom = new OlGeoJSON().writeGeometryObject(geometry, {
+            featureProjection: this.mapProjection,
+            dataProjection: this.mapProjection
+        });
+        const f = {
+            type: FEATURE,
+            geometry: geojsonGeom,
+            projection: this.mapProjection,
+            properties: {
+                id: this.searchPointerSummaryFeatureId,
+                pointerSummary: text
+            },
+            meta: {
+                id: this.searchPointerSummaryFeatureId
+            },
+            ol: feature
+        };
+        this.store.setLayerFeatures([f], FeatureMotion.None);
+    }
+    /**
+     * Clear the pointer store features
+     */
+    clearLayer() {
+        if (this.store) {
+            this.store.clearLayer();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchPointerSummaryDirective, deps: [{ token: i1.MapBrowserComponent, self: true }, { token: i2.SearchService }, { token: i3.SearchSourceService }, { token: i4.MediaService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: SearchPointerSummaryDirective, isStandalone: true, selector: "[igoSearchPointerSummary]", inputs: { igoSearchPointerSummaryDelay: "igoSearchPointerSummaryDelay", igoSearchPointerSummaryEnabled: "igoSearchPointerSummaryEnabled" }, host: { listeners: { "mouseleave": "mouseleave()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchPointerSummaryDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[igoSearchPointerSummary]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.MapBrowserComponent, decorators: [{
+                    type: Self
+                }] }, { type: i2.SearchService }, { type: i3.SearchSourceService }, { type: i4.MediaService }], propDecorators: { igoSearchPointerSummaryDelay: [{
+                type: Input
+            }], igoSearchPointerSummaryEnabled: [{
+                type: Input
+            }], mouseleave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-pointer-summary.directive.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/search/shared/search-pointer-summary.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentChecked,\n  Directive,\n  HostListener,\n  Input,\n  OnDestroy,\n  OnInit,\n  Self\n} from '@angular/core';\n\nimport { EntityStore } from '@igo2/common/entity';\nimport { MediaService } from '@igo2/core/media';\nimport { SubjectStatus } from '@igo2/utils';\n\nimport olFeature from 'ol/Feature';\nimport MapBrowserPointerEvent from 'ol/MapBrowserEvent';\nimport { unByKey } from 'ol/Observable';\nimport OlGeoJSON from 'ol/format/GeoJSON';\nimport * as olgeom from 'ol/geom';\nimport { transform } from 'ol/proj';\n\nimport { Subscription, first } from 'rxjs';\n\nimport { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';\nimport { tryBindStoreLayer } from '../../feature/shared/feature-store.utils';\nimport { FEATURE, FeatureMotion } from '../../feature/shared/feature.enums';\nimport { Feature } from '../../feature/shared/feature.interfaces';\nimport { FeatureStore } from '../../feature/shared/store';\nimport { VectorLayer } from '../../layer/shared/layers/vector-layer';\nimport { MapBrowserComponent } from '../../map/map-browser/map-browser.component';\nimport { IgoMap } from '../../map/shared/map';\nimport { pointerPositionSummaryMarkerStyle } from '../../style/shared/feature/feature-style';\nimport { FeatureGeometry } from './../../feature/shared/feature.interfaces';\nimport { SearchSourceService } from './search-source.service';\nimport { Research, SearchResult } from './search.interfaces';\nimport { SearchService } from './search.service';\nimport { sourceCanReverseSearchAsSummary } from './search.utils';\n\n/**\n * This directive makes the mouse coordinate trigger a reverse search on available search sources.\n * The search results are placed into a label, on a cross icon, representing the mouse coordinate.\n * By default, no search sources. Config in config file must be defined.\n * the layer level.\n */\n@Directive({\n  selector: '[igoSearchPointerSummary]',\n  standalone: true\n})\nexport class SearchPointerSummaryDirective\n  implements OnInit, OnDestroy, AfterContentChecked\n{\n  public store: FeatureStore<Feature>;\n  private lonLat: [number, number];\n  private pointerSearchStore: EntityStore<SearchResult> =\n    new EntityStore<SearchResult>([]);\n  private lastTimeoutRequest;\n  private store$$: Subscription;\n  private reverseSearch$$: Subscription[] = [];\n  private hasPointerReverseSearchSource = false;\n\n  /**\n   * Listener to the pointer move event\n   */\n  private pointerMoveListener;\n\n  private searchPointerSummaryFeatureId = 'searchPointerSummaryFeatureId';\n  /**\n   * The delay where the mouse must be motionless before trigger the reverse search\n   */\n  @Input() igoSearchPointerSummaryDelay = 1000;\n\n  /**\n   * If the user has enabled or not the directive\n   */\n  @Input() igoSearchPointerSummaryEnabled = false;\n\n  @HostListener('mouseleave')\n  mouseleave() {\n    clearTimeout(this.lastTimeoutRequest);\n    this.clearLayer();\n  }\n\n  /**\n   * IGO map\n   * @internal\n   */\n  get map(): IgoMap {\n    return this.component.map;\n  }\n\n  get mapProjection(): string {\n    return (this.component.map as IgoMap).projection;\n  }\n\n  constructor(\n    @Self() private component: MapBrowserComponent,\n    private searchService: SearchService,\n    private searchSourceService: SearchSourceService,\n    private mediaService: MediaService\n  ) {}\n\n  /**\n   * Start listening to pointermove and reverse search results.\n   * @internal\n   */\n  ngOnInit() {\n    this.listenToMapPointerMove();\n\n    this.map.status$\n      .pipe(first((status) => status === SubjectStatus.Done))\n      .subscribe(() => {\n        this.store = new FeatureStore<Feature>([], { map: this.map });\n        this.initStore();\n        this.subscribeToPointerStore();\n      });\n  }\n\n  /**\n   * Initialize the pointer position store\n   * @internal\n   */\n  private initStore() {\n    const store = this.store;\n\n    const layer = new VectorLayer({\n      isIgoInternalLayer: true,\n      id: 'searchPointerSummaryId',\n      title: 'searchPointerSummary',\n      zIndex: 900,\n      source: new FeatureDataSource(),\n      showInLayerList: false,\n      exportable: false,\n      browsable: false,\n      style: pointerPositionSummaryMarkerStyle\n    });\n    tryBindStoreLayer(store, layer);\n  }\n\n  ngAfterContentChecked(): void {\n    if (\n      !this.searchSourceService\n        .getEnabledSources()\n        .filter(sourceCanReverseSearchAsSummary).length\n    ) {\n      this.hasPointerReverseSearchSource = false;\n    } else {\n      this.hasPointerReverseSearchSource = true;\n    }\n  }\n\n  /**\n   * Stop listening to pointermove and reverse search results.\n   * @internal\n   */\n  ngOnDestroy() {\n    this.unlistenToMapPointerMove();\n    this.unsubscribeToPointerStore();\n    this.unsubscribeReverseSearch();\n  }\n\n  /**\n   * Subscribe to pointermove result store\n   * @internal\n   */\n  subscribeToPointerStore() {\n    this.store$$ = this.pointerSearchStore.entities$.subscribe(\n      (resultsUnderPointerPosition) => {\n        this.entitiesToPointerOverlay(resultsUnderPointerPosition);\n      }\n    );\n  }\n\n  /**\n   * Build an object based on the closest feature by type (base on type and distance properties )\n   * @param results SearchResult[]\n   * @returns OL style function\n   */\n  private computeSummaryClosestFeature(results: SearchResult[]) {\n    const closestResultByType = {};\n\n    results.map((result) => {\n      if (result.data.properties.type && result.data.properties.distance >= 0) {\n        // eslint-disable-next-line no-prototype-builtins\n        if (closestResultByType.hasOwnProperty(result.data.properties.type)) {\n          const prevDistance =\n            closestResultByType[result.data.properties.type].distance;\n          if (result.data.properties.distance < prevDistance) {\n            const title = result.meta.pointerSummaryTitle || result.meta.title;\n            closestResultByType[result.data.properties.type] = {\n              distance: result.data.properties.distance,\n              title\n            };\n          }\n        } else {\n          const title = result.meta.pointerSummaryTitle || result.meta.title;\n          closestResultByType[result.data.properties.type] = {\n            distance: result.data.properties.distance,\n            title\n          };\n        }\n      }\n    });\n\n    return closestResultByType;\n  }\n\n  /**\n   * convert store entities to a pointer position overlay with label summary on.\n   * @param event OL map browser pointer event\n   */\n  private entitiesToPointerOverlay(\n    resultsUnderPointerPosition: SearchResult[]\n  ) {\n    const closestResultByType = this.computeSummaryClosestFeature(\n      resultsUnderPointerPosition\n    );\n    const summarizedClosestType = Object.keys(closestResultByType);\n    const processedSummarizedClosestType = [];\n    const summary = [];\n    resultsUnderPointerPosition.map((result) => {\n      const typeIndex = summarizedClosestType.indexOf(\n        result.data.properties.type\n      );\n      if (typeIndex !== -1) {\n        summary.push(closestResultByType[result.data.properties.type].title);\n        summarizedClosestType.splice(typeIndex, 1);\n        processedSummarizedClosestType.push(result.data.properties.type);\n      } else {\n        if (\n          processedSummarizedClosestType.indexOf(\n            result.data.properties.type\n          ) === -1\n        ) {\n          summary.push(result.meta.pointerSummaryTitle || result.meta.title);\n        }\n      }\n    });\n    if (summary.length) {\n      this.addPointerOverlay(summary.join('\\n'));\n    }\n  }\n\n  /**\n   * On map pointermove\n   */\n  private listenToMapPointerMove() {\n    this.pointerMoveListener = this.map.ol.on(\n      'pointermove',\n      (event: MapBrowserPointerEvent<any>) => this.onMapEvent(event)\n    );\n  }\n\n  /**\n   * Unsubscribe to pointer store.\n   * @internal\n   */\n  unsubscribeToPointerStore() {\n    this.store$$?.unsubscribe();\n  }\n  /**\n   * Unsubscribe to reverse seatch store.\n   * @internal\n   */\n  unsubscribeReverseSearch() {\n    this.reverseSearch$$.map((s) => s.unsubscribe());\n    this.reverseSearch$$ = [];\n  }\n\n  /**\n   * Stop listening for map pointermove\n   * @internal\n   */\n  private unlistenToMapPointerMove() {\n    unByKey(this.pointerMoveListener);\n    this.pointerMoveListener = undefined;\n  }\n\n  /**\n   * Trigger reverse search when the mouse is motionless during the defined delay (pointerMoveDelay).\n   * @param event OL map browser pointer event\n   */\n  private onMapEvent(event: MapBrowserPointerEvent<any>) {\n    if (\n      event.dragging ||\n      !this.igoSearchPointerSummaryEnabled ||\n      !this.hasPointerReverseSearchSource ||\n      this.mediaService.isTouchScreen()\n    ) {\n      this.clearLayer();\n      return;\n    }\n    if (typeof this.lastTimeoutRequest !== 'undefined') {\n      // cancel timeout when the mouse moves\n      clearTimeout(this.lastTimeoutRequest);\n      this.clearLayer();\n      this.unsubscribeReverseSearch();\n    }\n\n    this.lonLat = transform(\n      event.coordinate,\n      this.mapProjection,\n      'EPSG:4326'\n    ) as [number, number];\n\n    this.lastTimeoutRequest = setTimeout(() => {\n      this.onSearchCoordinate();\n    }, this.igoSearchPointerSummaryDelay);\n  }\n\n  /**\n   * Sort the results by display order.\n   * @param r1 First result\n   * @param r2 Second result\n   */\n  private sortByOrder(r1: SearchResult, r2: SearchResult) {\n    return r1.source.displayOrder - r2.source.displayOrder;\n  }\n\n  private onSearchCoordinate() {\n    this.pointerSearchStore.clear();\n    const results = this.searchService.reverseSearch(\n      this.lonLat,\n      { params: { geometry: 'false', icon: 'false' } },\n      true\n    );\n\n    for (const i in results) {\n      if (results.length > 0) {\n        this.reverseSearch$$.push(\n          results[i].request.subscribe((_results: SearchResult<Feature>[]) => {\n            this.onSearch({ research: results[i], results: _results });\n          })\n        );\n      }\n    }\n  }\n\n  private onSearch(event: { research: Research; results: SearchResult[] }) {\n    const results = event.results;\n    const newResults = this.pointerSearchStore\n      .all()\n      .filter((result: SearchResult) => result.source !== event.research.source)\n      .concat(results);\n    this.pointerSearchStore.load(newResults.sort(this.sortByOrder));\n  }\n\n  /**\n   * Add a feature to the pointer store\n   * @param text string\n   */\n  private addPointerOverlay(text: string) {\n    this.clearLayer();\n\n    const geometry = new olgeom.Point(\n      transform(this.lonLat, 'EPSG:4326', this.mapProjection)\n    );\n    const feature = new olFeature({ geometry });\n    const geojsonGeom = new OlGeoJSON().writeGeometryObject(geometry, {\n      featureProjection: this.mapProjection,\n      dataProjection: this.mapProjection\n    }) as FeatureGeometry;\n\n    const f: Feature = {\n      type: FEATURE,\n      geometry: geojsonGeom,\n      projection: this.mapProjection,\n      properties: {\n        id: this.searchPointerSummaryFeatureId,\n        pointerSummary: text\n      },\n      meta: {\n        id: this.searchPointerSummaryFeatureId\n      },\n      ol: feature\n    };\n    this.store.setLayerFeatures([f], FeatureMotion.None);\n  }\n\n  /**\n   * Clear the pointer store features\n   */\n  private clearLayer() {\n    if (this.store) {\n      this.store.clearLayer();\n    }\n  }\n}\n"]}

package/esm2022/lib/search/shared/search-source-service.providers.mjs

@@ -0,0 +1,20 @@
+import { SearchSourceService } from './search-source.service';
+import { SearchSource } from './sources/source';
+/**
+ * Search source factory
+ * @ignore
+ */
+export function searchSourceServiceFactory(sources) {
+    return new SearchSourceService(sources);
+}
+/**
+ * Function that returns a provider for the SearchSource service
+ */
+export function provideSearchSourceService() {
+    return {
+        provide: SearchSourceService,
+        useFactory: searchSourceServiceFactory,
+        deps: [SearchSource]
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLXNvdXJjZS1zZXJ2aWNlLnByb3ZpZGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL3NlYXJjaC9zaGFyZWQvc2VhcmNoLXNvdXJjZS1zZXJ2aWNlLnByb3ZpZGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM5RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFaEQ7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLDBCQUEwQixDQUFDLE9BQXVCO0lBQ2hFLE9BQU8sSUFBSSxtQkFBbUIsQ0FBQyxPQUFPLENBQUMsQ0FBQztBQUMxQyxDQUFDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsMEJBQTBCO0lBQ3hDLE9BQU87UUFDTCxPQUFPLEVBQUUsbUJBQW1CO1FBQzVCLFVBQVUsRUFBRSwwQkFBMEI7UUFDdEMsSUFBSSxFQUFFLENBQUMsWUFBWSxDQUFDO0tBQ3JCLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2VhcmNoU291cmNlU2VydmljZSB9IGZyb20gJy4vc2VhcmNoLXNvdXJjZS5zZXJ2aWNlJztcbmltcG9ydCB7IFNlYXJjaFNvdXJjZSB9IGZyb20gJy4vc291cmNlcy9zb3VyY2UnO1xuXG4vKipcbiAqIFNlYXJjaCBzb3VyY2UgZmFjdG9yeVxuICogQGlnbm9yZVxuICovXG5leHBvcnQgZnVuY3Rpb24gc2VhcmNoU291cmNlU2VydmljZUZhY3Rvcnkoc291cmNlczogU2VhcmNoU291cmNlW10pIHtcbiAgcmV0dXJuIG5ldyBTZWFyY2hTb3VyY2VTZXJ2aWNlKHNvdXJjZXMpO1xufVxuXG4vKipcbiAqIEZ1bmN0aW9uIHRoYXQgcmV0dXJucyBhIHByb3ZpZGVyIGZvciB0aGUgU2VhcmNoU291cmNlIHNlcnZpY2VcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHByb3ZpZGVTZWFyY2hTb3VyY2VTZXJ2aWNlKCkge1xuICByZXR1cm4ge1xuICAgIHByb3ZpZGU6IFNlYXJjaFNvdXJjZVNlcnZpY2UsXG4gICAgdXNlRmFjdG9yeTogc2VhcmNoU291cmNlU2VydmljZUZhY3RvcnksXG4gICAgZGVwczogW1NlYXJjaFNvdXJjZV1cbiAgfTtcbn1cbiJdfQ==

package/esm2022/lib/search/shared/search-source.service.mjs

@@ -0,0 +1,56 @@
+/**
+ * Service where all available search sources are registered.
+ */
+export class SearchSourceService {
+    sources;
+    constructor(sources) {
+        this.sources = sources;
+    }
+    /**
+     * Return available search sources
+     * @returns Search sources
+     */
+    getSources() {
+        return this.sources;
+    }
+    /**
+     * Return enabled search sources
+     * @returns Search sources
+     */
+    getEnabledSources() {
+        return this.getSources().filter((source) => source.enabled === true);
+    }
+    /**
+     * Enable search sources of given type
+     * @param type Search type
+     * @todo It would be better to track the enabled search sources
+     *  without updating their 'enabled' property.
+     */
+    enableSourcesByType(type) {
+        this.getSources().forEach((source) => {
+            if (source.constructor.type === type) {
+                source.enabled = true;
+            }
+            else {
+                source.enabled = false;
+            }
+        });
+    }
+    /**
+     * Set Param from the selected settings
+     * @param source search-source
+     * @param setting settings
+     */
+    setParamFromSetting(source, setting) {
+        source.setParamFromSetting(setting);
+    }
+    /**
+     * Set Param from the selected settings
+     * @param source search-source
+     * @param setting settings
+     */
+    setWorkspaces(source, workspaces) {
+        source.setWorkspaces(workspaces);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/search/shared/search.enums.mjs

@@ -0,0 +1,4 @@
+import { FEATURE } from '../../feature/shared/feature.enums';
+import { LAYER } from '../../layer/shared/layer.enums';
+export const SEARCH_TYPES = [FEATURE, LAYER];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLmVudW1zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvc2VhcmNoL3NoYXJlZC9zZWFyY2guZW51bXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQzdELE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUV2RCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsQ0FBQyxPQUFPLEVBQUUsS0FBSyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGRUFUVVJFIH0gZnJvbSAnLi4vLi4vZmVhdHVyZS9zaGFyZWQvZmVhdHVyZS5lbnVtcyc7XG5pbXBvcnQgeyBMQVlFUiB9IGZyb20gJy4uLy4uL2xheWVyL3NoYXJlZC9sYXllci5lbnVtcyc7XG5cbmV4cG9ydCBjb25zdCBTRUFSQ0hfVFlQRVMgPSBbRkVBVFVSRSwgTEFZRVJdO1xuIl19

package/esm2022/lib/search/shared/search.interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/search/shared/search.provider.mjs

@@ -0,0 +1,20 @@
+import { provideSearchSourceService } from './search-source-service.providers';
+import { SearchService } from './search.service';
+export function provideSearch(sources, options) {
+    const providers = [
+        options?.analytics && {
+            provide: 'searchAnalytics',
+            useValue: options.analytics
+        },
+        {
+            provide: SearchService,
+            useClass: SearchService
+        },
+        provideSearchSourceService()
+    ].filter(Boolean);
+    for (const source of sources) {
+        providers.push(...source.providers);
+    }
+    return providers;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLnByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvc2VhcmNoL3NoYXJlZC9zZWFyY2gucHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLDBCQUEwQixFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFDL0UsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBV2pELE1BQU0sVUFBVSxhQUFhLENBQzNCLE9BQWdELEVBQ2hELE9BQWdDO0lBRWhDLE1BQU0sU0FBUyxHQUFlO1FBQzVCLE9BQU8sRUFBRSxTQUFTLElBQUk7WUFDcEIsT0FBTyxFQUFFLGlCQUFpQjtZQUMxQixRQUFRLEVBQUUsT0FBTyxDQUFDLFNBQVM7U0FDNUI7UUFDRDtZQUNFLE9BQU8sRUFBRSxhQUFhO1lBQ3RCLFFBQVEsRUFBRSxhQUFhO1NBQ3hCO1FBQ0QsMEJBQTBCLEVBQUU7S0FDN0IsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7SUFFbEIsS0FBSyxNQUFNLE1BQU0sSUFBSSxPQUFPLEVBQUUsQ0FBQztRQUM3QixTQUFTLENBQUMsSUFBSSxDQUFDLEdBQUcsTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3RDLENBQUM7SUFFRCxPQUFPLFNBQVMsQ0FBQztBQUNuQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUHJvdmlkZXIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgcHJvdmlkZVNlYXJjaFNvdXJjZVNlcnZpY2UgfSBmcm9tICcuL3NlYXJjaC1zb3VyY2Utc2VydmljZS5wcm92aWRlcnMnO1xuaW1wb3J0IHsgU2VhcmNoU2VydmljZSB9IGZyb20gJy4vc2VhcmNoLnNlcnZpY2UnO1xuaW1wb3J0IHtcbiAgU2VhcmNoU291cmNlRmVhdHVyZSxcbiAgU2VhcmNoU291cmNlS2luZFxufSBmcm9tICcuL3NvdXJjZXMvc291cmNlLmludGVyZmFjZXMnO1xuXG5pbnRlcmZhY2UgSVNlYXJjaFByb3ZpZGVyT3B0aW9ucyB7XG4gIC8qKiBTaGFyZSB0aGUgc2VhcmNoIHRlcm0gd2l0aCBhbmFseXRpY3MgdHJhY2tpbmcgKi9cbiAgYW5hbHl0aWNzPzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHByb3ZpZGVTZWFyY2goXG4gIHNvdXJjZXM6IFNlYXJjaFNvdXJjZUZlYXR1cmU8U2VhcmNoU291cmNlS2luZD5bXSxcbiAgb3B0aW9ucz86IElTZWFyY2hQcm92aWRlck9wdGlvbnNcbik6IFByb3ZpZGVyW10ge1xuICBjb25zdCBwcm92aWRlcnM6IFByb3ZpZGVyW10gPSBbXG4gICAgb3B0aW9ucz8uYW5hbHl0aWNzICYmIHtcbiAgICAgIHByb3ZpZGU6ICdzZWFyY2hBbmFseXRpY3MnLFxuICAgICAgdXNlVmFsdWU6IG9wdGlvbnMuYW5hbHl0aWNzXG4gICAgfSxcbiAgICB7XG4gICAgICBwcm92aWRlOiBTZWFyY2hTZXJ2aWNlLFxuICAgICAgdXNlQ2xhc3M6IFNlYXJjaFNlcnZpY2VcbiAgICB9LFxuICAgIHByb3ZpZGVTZWFyY2hTb3VyY2VTZXJ2aWNlKClcbiAgXS5maWx0ZXIoQm9vbGVhbik7XG5cbiAgZm9yIChjb25zdCBzb3VyY2Ugb2Ygc291cmNlcykge1xuICAgIHByb3ZpZGVycy5wdXNoKC4uLnNvdXJjZS5wcm92aWRlcnMpO1xuICB9XG5cbiAgcmV0dXJuIHByb3ZpZGVycztcbn1cbiJdfQ==