@igo2/geo 1.15.3 → 16.0.0-rc.0

package/esm2022/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()
+            ]
+        };
+    }
+    static ɵfac = function IgoSearchModule_Factory(t) { return new (t || IgoSearchModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoSearchModule });
+    static ɵ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/esm2022/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9zZWFyY2gvc2hhcmVkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NlYXJjaC5lbnVtcyc7XG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC5pbnRlcmZhY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLXBvaW50ZXItc3VtbWFyeS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2guc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC1zb3VyY2Uuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaC1zb3VyY2Utc2VydmljZS5wcm92aWRlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2gudXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9zb3VyY2VzJztcbiJdfQ==

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

@@ -0,0 +1,337 @@
+import { Directive, Input, Self, HostListener } from '@angular/core';
+import { first } from 'rxjs';
+import { MapBrowserComponent } from '../../map/map-browser/map-browser.component';
+import { SearchService } from './search.service';
+import olFeature from 'ol/Feature';
+import { transform } from 'ol/proj';
+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 { tryBindStoreLayer } from '../../feature/shared/feature-store.utils';
+import { FeatureStore } from '../../feature/shared/store';
+import { FeatureMotion, FEATURE } from '../../feature/shared/feature.enums';
+import { SearchSourceService } from './search-source.service';
+import { sourceCanReverseSearchAsSummary } from './search.utils';
+import { MediaService } from '@igo2/core';
+import { unByKey } from 'ol/Observable';
+import { pointerPositionSummaryMarkerStyle } from '../../style/shared/feature/feature-style';
+import { SubjectStatus } from '@igo2/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";
+/**
+ * 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$$;
+    layers$$;
+    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.subscribeToPointerStore();
+        this.map.status$
+            .pipe(first((status) => status === SubjectStatus.Done))
+            .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: 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();
+        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();
+        }
+    }
+    static ɵ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)); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: SearchPointerSummaryDirective, selectors: [["", "igoSearchPointerSummary", ""]], hostBindings: function SearchPointerSummaryDirective_HostBindings(rf, ctx) { if (rf & 1) {
+            i0.ɵɵlistener("mouseleave", function SearchPointerSummaryDirective_mouseleave_HostBindingHandler() { return ctx.mouseleave(); });
+        } }, 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
+        }], 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 { 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  HostListener\r\n} from '@angular/core';\r\n\r\nimport { Subscription, first } 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 olgeom from 'ol/geom';\r\nimport OlGeoJSON from 'ol/format/GeoJSON';\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 { tryBindStoreLayer } from '../../feature/shared/feature-store.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\nimport { pointerPositionSummaryMarkerStyle } from '../../style/shared/feature/feature-style';\r\nimport { SubjectStatus } from '@igo2/utils';\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\r\n  implements OnInit, OnDestroy, AfterContentChecked\r\n{\r\n  public store: FeatureStore<Feature>;\r\n  private lonLat: [number, number];\r\n  private pointerSearchStore: EntityStore<SearchResult> =\r\n    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 =\r\n    '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  @HostListener('mouseleave')\r\n  mouseleave() {\r\n    clearTimeout(this.lastTimeoutRequest);\r\n    this.clearLayer();\r\n  }\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$\r\n      .pipe(first((status) => status === SubjectStatus.Done))\r\n      .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 (\r\n        this.store &&\r\n        !layers.find((l) => l.id === 'searchPointerSummaryId')\r\n      ) {\r\n        this.initStore();\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: pointerPositionSummaryMarkerStyle\r\n    });\r\n    tryBindStoreLayer(store, layer);\r\n  }\r\n\r\n  ngAfterContentChecked(): void {\r\n    if (\r\n      !this.searchSourceService\r\n        .getEnabledSources()\r\n        .filter(sourceCanReverseSearchAsSummary).length\r\n    ) {\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(\r\n      (resultsUnderPointerPosition) => {\r\n        this.entitiesToPointerOverlay(resultsUnderPointerPosition);\r\n      }\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 =\r\n            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] = {\r\n              distance: result.data.properties.distance,\r\n              title\r\n            };\r\n          }\r\n        } else {\r\n          const title = result.meta.pointerSummaryTitle || result.meta.title;\r\n          closestResultByType[result.data.properties.type] = {\r\n            distance: result.data.properties.distance,\r\n            title\r\n          };\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(\r\n    resultsUnderPointerPosition: SearchResult[]\r\n  ) {\r\n    const closestResultByType = this.computeSummaryClosestFeature(\r\n      resultsUnderPointerPosition\r\n    );\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(\r\n        result.data.properties.type\r\n      );\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 (\r\n          processedSummarizedClosestType.indexOf(\r\n            result.data.properties.type\r\n          ) === -1\r\n        ) {\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 ||\r\n      !this.igoSearchPointerSummaryEnabled ||\r\n      !this.hasPointerReverseSearchSource ||\r\n      this.mediaService.isTouchScreen()\r\n    ) {\r\n      this.clearLayer();\r\n      return;\r\n    }\r\n    if (typeof this.lastTimeoutRequest !== 'undefined') {\r\n      // 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(\r\n      event.coordinate,\r\n      this.mapProjection,\r\n      'EPSG:4326'\r\n    ) 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(\r\n      this.lonLat,\r\n      { params: { geometry: 'false', icon: 'false' } },\r\n      true\r\n    );\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\r\n  private onSearch(event: { research: Research; results: SearchResult[] }) {\r\n    const results = event.results;\r\n    const newResults = this.pointerSearchStore\r\n      .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\n  private clearLayer() {\r\n    if (this.store) {\r\n      this.store.clearLayer();\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLXNvdXJjZS1zZXJ2aWNlLnByb3ZpZGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL3NlYXJjaC9zaGFyZWQvc2VhcmNoLXNvdXJjZS1zZXJ2aWNlLnByb3ZpZGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDaEQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFOUQ7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLDBCQUEwQixDQUFDLE9BQXVCO0lBQ2hFLE9BQU8sSUFBSSxtQkFBbUIsQ0FBQyxPQUFPLENBQUMsQ0FBQztBQUMxQyxDQUFDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsMEJBQTBCO0lBQ3hDLE9BQU87UUFDTCxPQUFPLEVBQUUsbUJBQW1CO1FBQzVCLFVBQVUsRUFBRSwwQkFBMEI7UUFDdEMsSUFBSSxFQUFFLENBQUMsWUFBWSxDQUFDO0tBQ3JCLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2VhcmNoU291cmNlIH0gZnJvbSAnLi9zb3VyY2VzL3NvdXJjZSc7XG5pbXBvcnQgeyBTZWFyY2hTb3VyY2VTZXJ2aWNlIH0gZnJvbSAnLi9zZWFyY2gtc291cmNlLnNlcnZpY2UnO1xuXG4vKipcbiAqIFNlYXJjaCBzb3VyY2UgZmFjdG9yeVxuICogQGlnbm9yZVxuICovXG5leHBvcnQgZnVuY3Rpb24gc2VhcmNoU291cmNlU2VydmljZUZhY3Rvcnkoc291cmNlczogU2VhcmNoU291cmNlW10pIHtcbiAgcmV0dXJuIG5ldyBTZWFyY2hTb3VyY2VTZXJ2aWNlKHNvdXJjZXMpO1xufVxuXG4vKipcbiAqIEZ1bmN0aW9uIHRoYXQgcmV0dXJucyBhIHByb3ZpZGVyIGZvciB0aGUgU2VhcmNoU291cmNlIHNlcnZpY2VcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHByb3ZpZGVTZWFyY2hTb3VyY2VTZXJ2aWNlKCkge1xuICByZXR1cm4ge1xuICAgIHByb3ZpZGU6IFNlYXJjaFNvdXJjZVNlcnZpY2UsXG4gICAgdXNlRmFjdG9yeTogc2VhcmNoU291cmNlU2VydmljZUZhY3RvcnksXG4gICAgZGVwczogW1NlYXJjaFNvdXJjZV1cbiAgfTtcbn1cbiJdfQ==

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';
+import { LAYER } from '../../layer/shared';
+export const SEARCH_TYPES = [FEATURE, LAYER];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLmVudW1zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvc2VhcmNoL3NoYXJlZC9zZWFyY2guZW51bXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN4QyxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFM0MsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLENBQUMsT0FBTyxFQUFFLEtBQUssQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRkVBVFVSRSB9IGZyb20gJy4uLy4uL2ZlYXR1cmUnO1xuaW1wb3J0IHsgTEFZRVIgfSBmcm9tICcuLi8uLi9sYXllci9zaGFyZWQnO1xuXG5leHBvcnQgY29uc3QgU0VBUkNIX1RZUEVTID0gW0ZFQVRVUkUsIExBWUVSXTtcbiJdfQ==

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

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