@igo2/geo 1.12.1 → 1.13.0-alpha.0

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

@@ -0,0 +1,67 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SearchService } from './shared/search.service';
+import { provideSearchSourceService } from './shared/search-source-service.providers';
+import { provideDefaultIChercheSearchResultFormatter } from './shared/sources/icherche.providers';
+import { provideDefaultCoordinatesSearchResultFormatter } from './shared/sources/coordinates.providers';
+import { provideILayerSearchResultFormatter } from './shared/sources/ilayer.providers';
+import { IgoSearchBarModule } from './search-bar/search-bar.module';
+import { IgoSearchSelectorModule } from './search-selector/search-selector.module';
+import { IgoSearchResultsModule } from './search-results/search-results.module';
+import { IgoSearchSettingsModule } from './search-settings/search-settings.module';
+import { SearchPointerSummaryDirective } from './shared/search-pointer-summary.directive';
+import * as i0 from "@angular/core";
+export class IgoSearchModule {
+    static forRoot() {
+        return {
+            ngModule: IgoSearchModule,
+            providers: [
+                SearchService,
+                provideSearchSourceService(),
+                provideDefaultIChercheSearchResultFormatter(),
+                provideDefaultCoordinatesSearchResultFormatter(),
+                provideILayerSearchResultFormatter()
+            ]
+        };
+    }
+}
+IgoSearchModule.ɵfac = function IgoSearchModule_Factory(t) { return new (t || IgoSearchModule)(); };
+IgoSearchModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoSearchModule });
+IgoSearchModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+        IgoSearchBarModule,
+        IgoSearchSelectorModule,
+        IgoSearchResultsModule,
+        IgoSearchSettingsModule, IgoSearchBarModule,
+        IgoSearchSelectorModule,
+        IgoSearchResultsModule,
+        IgoSearchSettingsModule] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoSearchModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    IgoSearchBarModule,
+                    IgoSearchSelectorModule,
+                    IgoSearchResultsModule,
+                    IgoSearchSettingsModule
+                ],
+                exports: [
+                    IgoSearchBarModule,
+                    IgoSearchSelectorModule,
+                    IgoSearchResultsModule,
+                    IgoSearchSettingsModule,
+                    SearchPointerSummaryDirective
+                ],
+                declarations: [SearchPointerSummaryDirective]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IgoSearchModule, { declarations: [SearchPointerSummaryDirective], imports: [CommonModule,
+        IgoSearchBarModule,
+        IgoSearchSelectorModule,
+        IgoSearchResultsModule,
+        IgoSearchSettingsModule], exports: [IgoSearchBarModule,
+        IgoSearchSelectorModule,
+        IgoSearchResultsModule,
+        IgoSearchSettingsModule,
+        SearchPointerSummaryDirective] }); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,9 @@
+export * from './search.enums';
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9zZWFyY2gvc2hhcmVkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NlYXJjaC5lbnVtcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLmludGVyZmFjZXMnO1xyXG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC1wb2ludGVyLXN1bW1hcnkuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2guc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLXNvdXJjZS5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2gtc291cmNlLXNlcnZpY2UucHJvdmlkZXJzJztcclxuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2gudXRpbHMnO1xyXG5leHBvcnQgKiBmcm9tICcuL3NvdXJjZXMnO1xyXG4iXX0=

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

@@ -0,0 +1,322 @@
+import { Directive, Input, Self } from '@angular/core';
+import olFeature from 'ol/Feature';
+import { transform } from 'ol/proj';
+import * as olstyle from 'ol/style';
+import * as olgeom from 'ol/geom';
+import OlGeoJSON from 'ol/format/GeoJSON';
+import { EntityStore } from '@igo2/common';
+import { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';
+import { VectorLayer } from '../../layer/shared/layers/vector-layer';
+import { take } from 'rxjs/operators';
+import { tryBindStoreLayer } from '../../feature/shared/feature.utils';
+import { FeatureStore } from '../../feature/shared/store';
+import { FeatureMotion, FEATURE } from '../../feature/shared/feature.enums';
+import { sourceCanReverseSearchAsSummary } from './search.utils';
+import { unByKey } from 'ol/Observable';
+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";
+/**
+ * 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 {
+    constructor(component, searchService, searchSourceService, mediaService) {
+        this.component = component;
+        this.searchService = searchService;
+        this.searchSourceService = searchSourceService;
+        this.mediaService = mediaService;
+        this.pointerSearchStore = new EntityStore([]);
+        this.reverseSearch$$ = [];
+        this.hasPointerReverseSearchSource = false;
+        this.searchPointerSummaryFeatureId = 'searchPointerSummaryFeatureId';
+        /**
+         * The delay where the mouse must be motionless before trigger the reverse search
+         */
+        this.igoSearchPointerSummaryDelay = 1000;
+        /**
+         * If the user has enabled or not the directive
+         */
+        this.igoSearchPointerSummaryEnabled = false;
+    }
+    /**
+     * IGO map
+     * @internal
+     */
+    get map() {
+        return this.component.map;
+    }
+    get mapProjection() {
+        return this.component.map.projection;
+    }
+    /**
+     * Start listening to pointermove and reverse search results.
+     * @internal
+     */
+    ngOnInit() {
+        this.listenToMapPointerMove();
+        this.subscribeToPointerStore();
+        this.map.status$.pipe(take(1)).subscribe(() => {
+            this.store = new FeatureStore([], { map: this.map });
+            this.initStore();
+        });
+        // To handle context change without using the contextService.
+        this.layers$$ = this.map.layers$.subscribe((layers) => {
+            if (this.store && !layers.find(l => l.id === 'searchPointerSummaryId')) {
+                this.initStore();
+            }
+        });
+    }
+    /**
+     * 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: pointerPositionSummaryMarker
+        });
+        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();
+        this.layers$$.unsubscribe();
+    }
+    /**
+     * 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) {
+                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();
+        }
+    }
+}
+SearchPointerSummaryDirective.ɵfac = function SearchPointerSummaryDirective_Factory(t) { return new (t || SearchPointerSummaryDirective)(i0.ɵɵdirectiveInject(i1.MapBrowserComponent, 2), i0.ɵɵdirectiveInject(i2.SearchService), i0.ɵɵdirectiveInject(i3.SearchSourceService), i0.ɵɵdirectiveInject(i4.MediaService)); };
+SearchPointerSummaryDirective.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: SearchPointerSummaryDirective, selectors: [["", "igoSearchPointerSummary", ""]], inputs: { igoSearchPointerSummaryDelay: "igoSearchPointerSummaryDelay", igoSearchPointerSummaryEnabled: "igoSearchPointerSummaryEnabled" } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SearchPointerSummaryDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[igoSearchPointerSummary]'
+            }]
+    }], function () { return [{ type: i1.MapBrowserComponent, decorators: [{
+                type: Self
+            }] }, { type: i2.SearchService }, { type: i3.SearchSourceService }, { type: i4.MediaService }]; }, { igoSearchPointerSummaryDelay: [{
+            type: Input
+        }], igoSearchPointerSummaryEnabled: [{
+            type: Input
+        }] }); })();
+/**
+ * Create a default style for the pointer position and it's label summary.
+ * @param feature OlFeature
+ * @returns OL style function
+ */
+export function pointerPositionSummaryMarker(feature, resolution) {
+    return new olstyle.Style({
+        image: new olstyle.Icon({
+            src: './assets/igo2/geo/icons/cross_black_18px.svg',
+            imgSize: [18, 18], // for ie
+        }),
+        text: new olstyle.Text({
+            text: feature.get('pointerSummary'),
+            textAlign: 'left',
+            textBaseline: 'bottom',
+            font: '12px Calibri,sans-serif',
+            fill: new olstyle.Fill({ color: '#000' }),
+            backgroundFill: new olstyle.Fill({ color: 'rgba(255, 255, 255, 0.5)' }),
+            backgroundStroke: new olstyle.Stroke({ color: 'rgba(200, 200, 200, 0.75)', width: 2 }),
+            stroke: new olstyle.Stroke({ color: '#fff', width: 3 }),
+            overflow: true,
+            offsetX: 10,
+            offsetY: -10,
+            padding: [2.5, 2.5, 2.5, 2.5]
+        })
+    });
+}
+//# 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 { FeatureGeometry } from './../../feature/shared/feature.interfaces';\r\nimport {\r\n  Directive,\r\n  Input,\r\n  OnDestroy,\r\n  Self,\r\n  OnInit,\r\n  AfterContentChecked\r\n} from '@angular/core';\r\n\r\nimport { Subscription } from 'rxjs';\r\n\r\nimport MapBrowserPointerEvent from 'ol/MapBrowserEvent';\r\n\r\nimport { IgoMap } from '../../map/shared/map';\r\nimport { MapBrowserComponent } from '../../map/map-browser/map-browser.component';\r\nimport { Feature } from '../../feature/shared/feature.interfaces';\r\nimport { SearchService } from './search.service';\r\n\r\nimport olFeature from 'ol/Feature';\r\nimport { transform } from 'ol/proj';\r\nimport * as olstyle from 'ol/style';\r\nimport * as olgeom from 'ol/geom';\r\nimport OlGeoJSON from 'ol/format/GeoJSON';\r\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\r\n\r\nimport { SearchResult, Research } from './search.interfaces';\r\nimport { EntityStore } from '@igo2/common';\r\nimport { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';\r\nimport { VectorLayer } from '../../layer/shared/layers/vector-layer';\r\nimport { take } from 'rxjs/operators';\r\nimport { tryBindStoreLayer } from '../../feature/shared/feature.utils';\r\nimport { FeatureStore } from '../../feature/shared/store';\r\nimport { FeatureMotion, FEATURE } from '../../feature/shared/feature.enums';\r\nimport { SearchSourceService } from './search-source.service';\r\nimport { sourceCanReverseSearchAsSummary } from './search.utils';\r\nimport { MediaService } from '@igo2/core';\r\nimport { unByKey } from 'ol/Observable';\r\n\r\n/**\r\n * This directive makes the mouse coordinate trigger a reverse search on available search sources.\r\n * The search results are placed into a label, on a cross icon, representing the mouse coordinate.\r\n * By default, no search sources. Config in config file must be defined.\r\n * the layer level.\r\n */\r\n@Directive({\r\n  selector: '[igoSearchPointerSummary]'\r\n})\r\nexport class SearchPointerSummaryDirective implements OnInit, OnDestroy, AfterContentChecked {\r\n\r\n  public store: FeatureStore<Feature>;\r\n  private lonLat: [number, number];\r\n  private pointerSearchStore: EntityStore<SearchResult> = new EntityStore<SearchResult>([]);\r\n  private lastTimeoutRequest;\r\n  private store$$: Subscription;\r\n  private layers$$: Subscription;\r\n  private reverseSearch$$: Subscription[] = [];\r\n  private hasPointerReverseSearchSource: boolean = false;\r\n\r\n  /**\r\n   * Listener to the pointer move event\r\n   */\r\n  private pointerMoveListener;\r\n\r\n  private searchPointerSummaryFeatureId: string = 'searchPointerSummaryFeatureId';\r\n  /**\r\n   * The delay where the mouse must be motionless before trigger the reverse search\r\n   */\r\n  @Input() igoSearchPointerSummaryDelay: number = 1000;\r\n\r\n  /**\r\n   * If the user has enabled or not the directive\r\n   */\r\n  @Input() igoSearchPointerSummaryEnabled: boolean = false;\r\n\r\n  /**\r\n   * IGO map\r\n   * @internal\r\n   */\r\n  get map(): IgoMap {\r\n    return this.component.map;\r\n  }\r\n\r\n  get mapProjection(): string {\r\n    return (this.component.map as IgoMap).projection;\r\n  }\r\n\r\n  constructor(\r\n    @Self() private component: MapBrowserComponent,\r\n    private searchService: SearchService,\r\n    private searchSourceService: SearchSourceService,\r\n    private mediaService: MediaService\r\n  ) { }\r\n\r\n  /**\r\n   * Start listening to pointermove and reverse search results.\r\n   * @internal\r\n   */\r\n  ngOnInit() {\r\n    this.listenToMapPointerMove();\r\n    this.subscribeToPointerStore();\r\n\r\n    this.map.status$.pipe(take(1)).subscribe(() => {\r\n      this.store = new FeatureStore<Feature>([], {map: this.map});\r\n      this.initStore();\r\n    });\r\n\r\n    // To handle context change without using the contextService.\r\n    this.layers$$ = this.map.layers$.subscribe((layers) => {\r\n      if (this.store && !layers.find(l => l.id === 'searchPointerSummaryId')) {\r\n        this.initStore();\r\n      }\r\n    });\r\n\r\n  }\r\n\r\n  /**\r\n   * Initialize the pointer position store\r\n   * @internal\r\n   */\r\n  private initStore() {\r\n    const store = this.store;\r\n\r\n    const layer = new VectorLayer({\r\n      isIgoInternalLayer: true,\r\n      id : 'searchPointerSummaryId',\r\n      title: 'searchPointerSummary',\r\n      zIndex: 900,\r\n      source: new FeatureDataSource(),\r\n      showInLayerList: false,\r\n      exportable: false,\r\n      browsable: false,\r\n      style: pointerPositionSummaryMarker\r\n    });\r\n    tryBindStoreLayer(store, layer);\r\n  }\r\n\r\n  ngAfterContentChecked(): void {\r\n      if (!this.searchSourceService.getEnabledSources().filter(sourceCanReverseSearchAsSummary).length) {\r\n        this.hasPointerReverseSearchSource = false;\r\n      } else {\r\n        this.hasPointerReverseSearchSource = true;\r\n      }\r\n    }\r\n\r\n  /**\r\n   * Stop listening to pointermove and reverse search results.\r\n   * @internal\r\n   */\r\n  ngOnDestroy() {\r\n    this.unlistenToMapPointerMove();\r\n    this.unsubscribeToPointerStore();\r\n    this.unsubscribeReverseSearch();\r\n    this.layers$$.unsubscribe();\r\n  }\r\n\r\n  /**\r\n   * Subscribe to pointermove result store\r\n   * @internal\r\n   */\r\n  subscribeToPointerStore() {\r\n    this.store$$ = this.pointerSearchStore.entities$.subscribe(resultsUnderPointerPosition => {\r\n      this.entitiesToPointerOverlay(resultsUnderPointerPosition);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Build an object based on the closest feature by type (base on type and distance properties )\r\n   * @param results SearchResult[]\r\n   * @returns OL style function\r\n   */\r\n  private computeSummaryClosestFeature(results: SearchResult[]): {} {\r\n    const closestResultByType = {};\r\n\r\n    results.map(result => {\r\n      if (result.data.properties.type && result.data.properties.distance >= 0) {\r\n        if (closestResultByType.hasOwnProperty(result.data.properties.type)) {\r\n          const prevDistance = closestResultByType[result.data.properties.type].distance;\r\n          if (result.data.properties.distance < prevDistance) {\r\n            const title = result.meta.pointerSummaryTitle || result.meta.title;\r\n            closestResultByType[result.data.properties.type] = { distance: result.data.properties.distance, title };\r\n          }\r\n        } else {\r\n          const title = result.meta.pointerSummaryTitle || result.meta.title;\r\n          closestResultByType[result.data.properties.type] = { distance: result.data.properties.distance, title };\r\n        }\r\n      }\r\n    });\r\n\r\n    return closestResultByType;\r\n  }\r\n\r\n  /**\r\n   * convert store entities to a pointer position overlay with label summary on.\r\n   * @param event OL map browser pointer event\r\n   */\r\n  private entitiesToPointerOverlay(resultsUnderPointerPosition: SearchResult[]) {\r\n    const closestResultByType = this.computeSummaryClosestFeature(resultsUnderPointerPosition);\r\n    const summarizedClosestType = Object.keys(closestResultByType);\r\n    const processedSummarizedClosestType = [];\r\n    const summary = [];\r\n    resultsUnderPointerPosition.map(result => {\r\n      const typeIndex = summarizedClosestType.indexOf(result.data.properties.type);\r\n      if (typeIndex !== -1) {\r\n        summary.push(closestResultByType[result.data.properties.type].title);\r\n        summarizedClosestType.splice(typeIndex, 1);\r\n        processedSummarizedClosestType.push(result.data.properties.type);\r\n      } else {\r\n        if (processedSummarizedClosestType.indexOf(result.data.properties.type) === -1) {\r\n          summary.push(result.meta.pointerSummaryTitle || result.meta.title);\r\n        }\r\n      }\r\n    });\r\n    if (summary.length) {\r\n      this.addPointerOverlay(summary.join('\\n'));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * On map pointermove\r\n   */\r\n  private listenToMapPointerMove() {\r\n    this.pointerMoveListener = this.map.ol.on(\r\n      'pointermove',\r\n      (event: MapBrowserPointerEvent<any>) => this.onMapEvent(event)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Unsubscribe to pointer store.\r\n   * @internal\r\n   */\r\n  unsubscribeToPointerStore() {\r\n    this.store$$.unsubscribe();\r\n  }\r\n  /**\r\n   * Unsubscribe to reverse seatch store.\r\n   * @internal\r\n   */\r\n  unsubscribeReverseSearch() {\r\n    this.reverseSearch$$.map(s => s.unsubscribe());\r\n    this.reverseSearch$$ = [];\r\n  }\r\n\r\n  /**\r\n   * Stop listening for map pointermove\r\n   * @internal\r\n   */\r\n  private unlistenToMapPointerMove() {\r\n    unByKey(this.pointerMoveListener);\r\n    this.pointerMoveListener = undefined;\r\n  }\r\n\r\n  /**\r\n   * Trigger reverse search when the mouse is motionless during the defined delay (pointerMoveDelay).\r\n   * @param event OL map browser pointer event\r\n   */\r\n  private onMapEvent(event: MapBrowserPointerEvent<any>) {\r\n    if (\r\n      event.dragging || !this.igoSearchPointerSummaryEnabled ||\r\n      !this.hasPointerReverseSearchSource || this.mediaService.isTouchScreen()) {\r\n      this.clearLayer();\r\n      return;\r\n    }\r\n    if (typeof this.lastTimeoutRequest !== 'undefined') { // cancel timeout when the mouse moves\r\n      clearTimeout(this.lastTimeoutRequest);\r\n      this.clearLayer();\r\n      this.unsubscribeReverseSearch();\r\n    }\r\n\r\n    this.lonLat = transform(event.coordinate, this.mapProjection, 'EPSG:4326') as [number, number];\r\n\r\n    this.lastTimeoutRequest = setTimeout(() => {\r\n      this.onSearchCoordinate();\r\n    }, this.igoSearchPointerSummaryDelay);\r\n  }\r\n\r\n    /**\r\n   * Sort the results by display order.\r\n   * @param r1 First result\r\n   * @param r2 Second result\r\n   */\r\n     private sortByOrder(r1: SearchResult, r2: SearchResult) {\r\n      return r1.source.displayOrder - r2.source.displayOrder;\r\n    }\r\n\r\n  private onSearchCoordinate() {\r\n    this.pointerSearchStore.clear();\r\n    const results = this.searchService.reverseSearch(this.lonLat, { params: { geometry: 'false', icon: 'false' } }, true);\r\n\r\n    for (const i in results) {\r\n      if (results.length > 0) {\r\n        this.reverseSearch$$.push(\r\n          results[i].request.subscribe((_results: SearchResult<Feature>[]) => {\r\n            this.onSearch({ research: results[i], results: _results });\r\n          }));\r\n      }\r\n    }\r\n  }\r\n\r\n  private onSearch(event: { research: Research; results: SearchResult[] }) {\r\n    const results = event.results;\r\n    const newResults = this.pointerSearchStore.all()\r\n      .filter((result: SearchResult) => result.source !== event.research.source)\r\n      .concat(results);\r\n    this.pointerSearchStore.load(newResults.sort(this.sortByOrder));\r\n  }\r\n\r\n  /**\r\n   * Add a feature to the pointer store\r\n   * @param text string\r\n   */\r\n  private addPointerOverlay(text: string) {\r\n    this.clearLayer();\r\n\r\n    const geometry = new olgeom.Point(\r\n      transform(this.lonLat, 'EPSG:4326', this.mapProjection)\r\n    );\r\n    const feature = new olFeature({ geometry });\r\n    const geojsonGeom = new OlGeoJSON().writeGeometryObject(geometry, {\r\n      featureProjection: this.mapProjection,\r\n      dataProjection: this.mapProjection\r\n    }) as FeatureGeometry;\r\n\r\n    const f: Feature = {\r\n      type: FEATURE,\r\n      geometry: geojsonGeom,\r\n      projection: this.mapProjection,\r\n      properties: {\r\n        id: this.searchPointerSummaryFeatureId,\r\n        pointerSummary: text\r\n      },\r\n      meta: {\r\n        id: this.searchPointerSummaryFeatureId\r\n      },\r\n      ol: feature\r\n    };\r\n    this.store.setLayerFeatures([f], FeatureMotion.None);\r\n  }\r\n\r\n/**\r\n * Clear the pointer store features\r\n */\r\nprivate clearLayer() {\r\n  if (this.store) {\r\n    this.store.clearLayer();\r\n  }\r\n}\r\n\r\n}\r\n\r\n/**\r\n * Create a default style for the pointer position and it's label summary.\r\n * @param feature OlFeature\r\n * @returns OL style function\r\n */\r\nexport function pointerPositionSummaryMarker(feature: olFeature<OlGeometry>, resolution: number): olstyle.Style {\r\n  return new olstyle.Style({\r\n    image: new olstyle.Icon({\r\n      src: './assets/igo2/geo/icons/cross_black_18px.svg',\r\n      imgSize: [18, 18], // for ie\r\n    }),\r\n\r\n    text: new olstyle.Text({\r\n      text: feature.get('pointerSummary'),\r\n      textAlign: 'left',\r\n      textBaseline: 'bottom',\r\n      font: '12px Calibri,sans-serif',\r\n      fill: new olstyle.Fill({ color: '#000' }),\r\n      backgroundFill: new olstyle.Fill({ color: 'rgba(255, 255, 255, 0.5)' }),\r\n      backgroundStroke: new olstyle.Stroke({ color: 'rgba(200, 200, 200, 0.75)', width: 2 }),\r\n      stroke: new olstyle.Stroke({ color: '#fff', width: 3 }),\r\n      overflow: true,\r\n      offsetX: 10,\r\n      offsetY: -10,\r\n      padding: [2.5, 2.5, 2.5, 2.5]\r\n    })\r\n  });\r\n}\r\n"]}

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

@@ -0,0 +1,20 @@
+import { SearchSource } from './sources/source';
+import { SearchSourceService } from './search-source.service';
+/**
+ * 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLXNvdXJjZS1zZXJ2aWNlLnByb3ZpZGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL3NlYXJjaC9zaGFyZWQvc2VhcmNoLXNvdXJjZS1zZXJ2aWNlLnByb3ZpZGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDaEQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFOUQ7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLDBCQUEwQixDQUFDLE9BQXVCO0lBQ2hFLE9BQU8sSUFBSSxtQkFBbUIsQ0FBQyxPQUFPLENBQUMsQ0FBQztBQUMxQyxDQUFDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsMEJBQTBCO0lBQ3hDLE9BQU87UUFDTCxPQUFPLEVBQUUsbUJBQW1CO1FBQzVCLFVBQVUsRUFBRSwwQkFBMEI7UUFDdEMsSUFBSSxFQUFFLENBQUMsWUFBWSxDQUFDO0tBQ3JCLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2VhcmNoU291cmNlIH0gZnJvbSAnLi9zb3VyY2VzL3NvdXJjZSc7XHJcbmltcG9ydCB7IFNlYXJjaFNvdXJjZVNlcnZpY2UgfSBmcm9tICcuL3NlYXJjaC1zb3VyY2Uuc2VydmljZSc7XHJcblxyXG4vKipcclxuICogU2VhcmNoIHNvdXJjZSBmYWN0b3J5XHJcbiAqIEBpZ25vcmVcclxuICovXHJcbmV4cG9ydCBmdW5jdGlvbiBzZWFyY2hTb3VyY2VTZXJ2aWNlRmFjdG9yeShzb3VyY2VzOiBTZWFyY2hTb3VyY2VbXSkge1xyXG4gIHJldHVybiBuZXcgU2VhcmNoU291cmNlU2VydmljZShzb3VyY2VzKTtcclxufVxyXG5cclxuLyoqXHJcbiAqIEZ1bmN0aW9uIHRoYXQgcmV0dXJucyBhIHByb3ZpZGVyIGZvciB0aGUgU2VhcmNoU291cmNlIHNlcnZpY2VcclxuICovXHJcbmV4cG9ydCBmdW5jdGlvbiBwcm92aWRlU2VhcmNoU291cmNlU2VydmljZSgpIHtcclxuICByZXR1cm4ge1xyXG4gICAgcHJvdmlkZTogU2VhcmNoU291cmNlU2VydmljZSxcclxuICAgIHVzZUZhY3Rvcnk6IHNlYXJjaFNvdXJjZVNlcnZpY2VGYWN0b3J5LFxyXG4gICAgZGVwczogW1NlYXJjaFNvdXJjZV1cclxuICB9O1xyXG59XHJcbiJdfQ==

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

@@ -0,0 +1,47 @@
+/**
+ * Service where all available search sources are registered.
+ */
+export class SearchSourceService {
+    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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLmludGVyZmFjZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9zZWFyY2gvc2hhcmVkL3NlYXJjaC5pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XHJcblxyXG5pbXBvcnQgeyBDb21tb25WZWN0b3JTdHlsZU9wdGlvbnMgfSBmcm9tICcuLi8uLi91dGlscy9jb21tb25WZWN0b3JTdHlsZS5pbnRlcmZhY2UnO1xyXG5pbXBvcnQgeyBTZWFyY2hTb3VyY2UgfSBmcm9tICcuL3NvdXJjZXMvc291cmNlJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgUmVzZWFyY2gge1xyXG4gIHJlcXVlc3Q6IE9ic2VydmFibGU8U2VhcmNoUmVzdWx0W10+O1xyXG4gIHJldmVyc2U6IGJvb2xlYW47XHJcbiAgc291cmNlOiBTZWFyY2hTb3VyY2U7XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgU2VhcmNoUmVzdWx0PFQgPSB7IFtrZXk6IHN0cmluZ106IGFueSB9PiB7XHJcbiAgZGF0YTogVDtcclxuICBzb3VyY2U6IFNlYXJjaFNvdXJjZTtcclxuICBtZXRhOiB7XHJcbiAgICBkYXRhVHlwZTogc3RyaW5nO1xyXG4gICAgaWQ6IHN0cmluZztcclxuICAgIHRpdGxlOiBzdHJpbmc7XHJcbiAgICB0aXRsZUh0bWw/OiBzdHJpbmc7XHJcbiAgICBwb2ludGVyU3VtbWFyeVRpdGxlPzogc3RyaW5nO1xyXG4gICAgaWNvbjogc3RyaW5nO1xyXG4gICAgc2NvcmU/OiBudW1iZXI7XHJcbiAgICBuZXh0UGFnZT86IGJvb2xlYW47XHJcbiAgfTtcclxuICBzdHlsZT86IHtcclxuICAgIGJhc2U/OiBDb21tb25WZWN0b3JTdHlsZU9wdGlvbnM7XHJcbiAgICBzZWxlY3Rpb24/OiBDb21tb25WZWN0b3JTdHlsZU9wdGlvbnM7XHJcbiAgICBmb2N1cz86IENvbW1vblZlY3RvclN0eWxlT3B0aW9ucztcclxuICB9O1xyXG59XHJcbiJdfQ==