@igo2/geo 18.0.1-next.2 → 18.0.2

package/esm2022/lib/map/shared/hover-feature.directive.mjs

@@ -0,0 +1,481 @@
+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 * as OlGeom from 'ol/geom';
+import olLayerVector from 'ol/layer/Vector';
+import olLayerVectorTile from 'ol/layer/VectorTile';
+import RenderFeature from 'ol/render/Feature';
+import olVectorTileSource from 'ol/source/VectorTile';
+import { first } from 'rxjs/operators';
+import { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';
+import { tryBindStoreLayer } from '../../feature/shared/feature-store.utils';
+import { FeatureMotion } from '../../feature/shared/feature.enums';
+import { FeatureStore } from '../../feature/shared/store';
+import { VectorLayer } from '../../layer/shared/layers';
+import { MapBrowserComponent } from '../../map/map-browser/map-browser.component';
+import { hoverFeatureMarkerStyle } from '../../style/shared/feature/feature-style';
+import { StyleService } from '../../style/style-service/style.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../map/map-browser/map-browser.component";
+import * as i2 from "@igo2/core/media";
+import * as i3 from "../../style/style-service/style.service";
+/**
+ * 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 HoverFeatureDirective {
+    component;
+    mediaService;
+    styleService;
+    store;
+    pointerHoverFeatureStore = new EntityStore([]);
+    lastTimeoutRequest;
+    store$$;
+    selectionLayer;
+    selectionMVT = {};
+    mvtStyleOptions;
+    /**
+     * Listener to the pointer move event
+     */
+    pointerMoveListener;
+    singleClickMapListener;
+    hoverFeatureId = 'hoverFeatureId';
+    /**
+     * The delay where the mouse must be motionless before trigger the reverse search
+     */
+    igoHoverFeatureDelay = 1000;
+    /**
+     * If the user has enabled or not the directive
+     */
+    igoHoverFeatureEnabled = false;
+    mouseout() {
+        clearTimeout(this.lastTimeoutRequest);
+        this.clearLayer();
+    }
+    /**
+     * IGO map
+     * @internal
+     */
+    get map() {
+        return this.component.map;
+    }
+    get mapProjection() {
+        return this.component.map.projection;
+    }
+    constructor(component, mediaService, styleService) {
+        this.component = component;
+        this.mediaService = mediaService;
+        this.styleService = styleService;
+    }
+    /**
+     * Start listening to pointermove and reverse search results.
+     * @internal
+     */
+    ngOnInit() {
+        this.map.status$
+            .pipe(first((status) => status === SubjectStatus.Done))
+            .subscribe(() => {
+            this.store = new FeatureStore([], { map: this.map });
+            this.initStore();
+            this.listenToMapPointerMove();
+            this.subscribeToPointerStore();
+            this.listenToMapClick();
+        });
+    }
+    /**
+     * Initialize the pointer position store
+     * @internal
+     */
+    initStore() {
+        const store = this.store;
+        const layer = new VectorLayer({
+            isIgoInternalLayer: true,
+            id: 'hoverFeatureId',
+            title: 'hoverFeature',
+            zIndex: 900,
+            source: new FeatureDataSource(),
+            showInLayerList: false,
+            exportable: false,
+            browsable: false,
+            style: hoverFeatureMarkerStyle
+        });
+        tryBindStoreLayer(store, layer);
+        this.selectionLayer = new olLayerVectorTile({
+            map: this.map.ol,
+            zIndex: 901,
+            renderMode: 'vector',
+            declutter: true,
+            source: new olVectorTileSource({ projection: this.map.projection }),
+            style: (feature, resolution) => {
+                if (this.mvtStyleOptions && feature.getId() in this.selectionMVT) {
+                    return this.createHoverStyle(feature, this.mvtStyleOptions, resolution);
+                }
+            }
+        });
+    }
+    createHoverStyle(feature, hoverStyle, resolution) {
+        const localHoverStyle = { ...hoverStyle };
+        let label = hoverStyle.label ? hoverStyle.label.attribute : undefined;
+        let hasLabelStyle = hoverStyle.label?.style ? true : false;
+        if (!feature.get('_isLabel')) {
+            localHoverStyle.label = undefined;
+            hasLabelStyle = false;
+            label = undefined;
+        }
+        else {
+            // clear the style for label....
+            const size = localHoverStyle.data ? localHoverStyle.data.length : 0;
+            const radius = [];
+            const stroke = [];
+            const width = [];
+            const fill = [];
+            for (let i = 0; i < size; i++) {
+                radius.push(0);
+                stroke.push('rgba(255, 255, 255, 0)');
+                width.push(0);
+                fill.push('rgba(255, 255, 255, 0)');
+            }
+            localHoverStyle.radius = radius;
+            localHoverStyle.stroke = stroke;
+            localHoverStyle.width = width;
+            localHoverStyle.fill = fill;
+        }
+        if (!hasLabelStyle && label) {
+            localHoverStyle.label.style = {
+                textAlign: 'left',
+                textBaseline: 'top',
+                font: '12px Calibri,sans-serif',
+                fill: { color: '#000' },
+                backgroundFill: { color: 'rgba(255, 255, 255, 0.5)' },
+                backgroundStroke: { color: 'rgba(200, 200, 200, 0.75)', width: 2 },
+                stroke: { color: '#fff', width: 3 },
+                overflow: true,
+                offsetX: 10,
+                offsetY: 20,
+                padding: [2.5, 2.5, 2.5, 2.5]
+            };
+        }
+        return this.styleService.createStyleByAttribute(feature, localHoverStyle, resolution);
+    }
+    /**
+     * Stop listening to pointermove and reverse search results.
+     * @internal
+     */
+    ngOnDestroy() {
+        this.unlistenToMapPointerMove();
+        this.unsubscribeToPointerStore();
+        this.unlistenToMapSingleClick();
+    }
+    /**
+     * Subscribe to pointermove result store
+     * @internal
+     */
+    subscribeToPointerStore() {
+        this.store$$ = this.pointerHoverFeatureStore.entities$.subscribe((resultsUnderPointerPosition) => {
+            this.addFeatureOverlay(resultsUnderPointerPosition);
+        });
+    }
+    /**
+     * On map pointermove
+     */
+    listenToMapPointerMove() {
+        this.pointerMoveListener = this.map.ol.on('pointermove', (event) => this.onMapEvent(event));
+    }
+    /**
+     * On map singleclick
+     */
+    listenToMapClick() {
+        this.singleClickMapListener = this.map.ol.on('singleclick', () => this.onMapSingleClickEvent());
+    }
+    /**
+     * Unsubscribe to pointer store.
+     * @internal
+     */
+    unsubscribeToPointerStore() {
+        this.store$$?.unsubscribe();
+    }
+    /**
+     * Stop listening for map pointermove
+     * @internal
+     */
+    unlistenToMapPointerMove() {
+        unByKey(this.pointerMoveListener);
+        this.pointerMoveListener = undefined;
+    }
+    /**
+     * Stop listening for map singleclick
+     * @internal
+     */
+    unlistenToMapSingleClick() {
+        unByKey(this.singleClickMapListener);
+        this.singleClickMapListener = undefined;
+    }
+    /**
+     * Trigger clear layer on singleclick.
+     * @param event OL map browser singleclick event
+     */
+    onMapSingleClickEvent() {
+        this.clearLayer();
+    }
+    /**
+     * Trigger hover when the mouse is motionless during the defined delay (pointerMoveDelay).
+     * @param event OL map browser pointer event
+     */
+    onMapEvent(event) {
+        if (event.dragging ||
+            !this.igoHoverFeatureEnabled ||
+            this.mediaService.isTouchScreen()) {
+            this.clearLayer();
+            return;
+        }
+        if (typeof this.lastTimeoutRequest !== 'undefined') {
+            // cancel timeout when the mouse moves
+            clearTimeout(this.lastTimeoutRequest);
+        }
+        let maximumZindex = -Infinity;
+        let topMostOlLayer;
+        const pixel = this.map.ol.getPixelFromCoordinate(event.coordinate);
+        this.lastTimeoutRequest = setTimeout(() => {
+            // retrieve the topmost layer with feature to only apply the hover on this layer.
+            this.map.ol.forEachFeatureAtPixel(pixel, (mapFeature, layerOL) => {
+                if (!layerOL) {
+                    return;
+                }
+                const igoLayer = this.map.getLayerByOlUId(layerOL.ol_uid);
+                if (!this.canProcessHover(igoLayer)) {
+                    return;
+                }
+                if (igoLayer.zIndex <= maximumZindex) {
+                    return;
+                }
+                maximumZindex = igoLayer.zIndex;
+                topMostOlLayer = layerOL;
+            }, {
+                hitTolerance: 10,
+                layerFilter: (olLayer) => olLayer instanceof olLayerVector ||
+                    olLayer instanceof olLayerVectorTile
+            });
+            if (!topMostOlLayer) {
+                // To clear label
+                this.clearLayer();
+                this.pointerHoverFeatureStore.clear();
+                return;
+            }
+            this.map.ol.forEachFeatureAtPixel(pixel, (mapFeature, layerOL) => {
+                // To avoid flashing feature
+                if (mapFeature.get('hoverSummary') === undefined &&
+                    mapFeature.getProperties() !==
+                        this.pointerHoverFeatureStore.all()[0]?.getProperties()) {
+                    this.clearLayer();
+                    if (layerOL instanceof olLayerVector) {
+                        const myLayerVector = this.map.getLayerByOlUId(layerOL.ol_uid);
+                        if (!this.canProcessHover(myLayerVector)) {
+                            return;
+                        }
+                        const localOlFeature = this.handleRenderFeature(mapFeature);
+                        this.setLayerStyleFromOptions(myLayerVector, localOlFeature);
+                        const featuresToLoad = [localOlFeature];
+                        localOlFeature.set('_isLabel', false);
+                        const myLabelOlFeature = new OlFeature();
+                        myLabelOlFeature.setProperties(localOlFeature.getProperties());
+                        const labelGeom = localOlFeature.getGeometry().getType() === 'Point'
+                            ? localOlFeature.getGeometry()
+                            : new OlGeom.Point(event.coordinate);
+                        myLabelOlFeature.setGeometry(labelGeom);
+                        myLabelOlFeature.setId(localOlFeature.getId());
+                        myLabelOlFeature.set('_isLabel', true);
+                        this.setLayerStyleFromOptions(myLayerVector, myLabelOlFeature);
+                        featuresToLoad.push(myLabelOlFeature);
+                        this.pointerHoverFeatureStore.load(featuresToLoad);
+                        return true;
+                    }
+                    if (layerOL instanceof olLayerVectorTile) {
+                        const myLayerVectorTile = this.map.getLayerByOlUId(layerOL.ol_uid);
+                        if (!this.canProcessHover(myLayerVectorTile)) {
+                            return;
+                        }
+                        if (myLayerVectorTile?.options?.igoStyle?.styleByAttribute
+                            ?.hoverStyle) {
+                            this.mvtStyleOptions =
+                                myLayerVectorTile.options.igoStyle.styleByAttribute.hoverStyle;
+                        }
+                        else if (myLayerVectorTile?.options?.igoStyle?.hoverStyle) {
+                            this.mvtStyleOptions =
+                                myLayerVectorTile.options.igoStyle.hoverStyle;
+                        }
+                        this.selectionLayer.setSource(layerOL.getSource());
+                        layerOL
+                            .getFeatures(event.pixel)
+                            .then((mvtFeatures) => {
+                            if (!mvtFeatures.length) {
+                                this.selectionMVT = {};
+                                this.selectionLayer.changed();
+                                this.clearLayer();
+                                return;
+                            }
+                            const feature = mvtFeatures[0];
+                            if (!feature) {
+                                this.clearLayer();
+                                return;
+                            }
+                            const localOlFeature = this.handleRenderFeature(feature);
+                            localOlFeature.set('_isLabel', false);
+                            const myLabelOlFeature = new OlFeature();
+                            myLabelOlFeature.setProperties(localOlFeature.getProperties());
+                            const labelGeom = localOlFeature.getGeometry().getType() === 'Point'
+                                ? localOlFeature.getGeometry()
+                                : new OlGeom.Point(event.coordinate);
+                            myLabelOlFeature.setGeometry(labelGeom);
+                            myLabelOlFeature.setId(localOlFeature.getId());
+                            myLabelOlFeature.set('_isLabel', true);
+                            this.setLayerStyleFromOptions(myLayerVectorTile, myLabelOlFeature);
+                            this.pointerHoverFeatureStore.load([myLabelOlFeature]);
+                            this.selectionMVT[feature.getId()] = localOlFeature;
+                            this.selectionLayer.changed();
+                        });
+                    }
+                }
+            }, {
+                hitTolerance: 10,
+                layerFilter: (olLayer) => olLayer === topMostOlLayer
+            });
+        }, this.igoHoverFeatureDelay);
+    }
+    canProcessHover(igoLayer) {
+        if (!igoLayer) {
+            return false;
+        }
+        if (!igoLayer.visible) {
+            return false;
+        }
+        if (!igoLayer.options) {
+            return false;
+        }
+        if (!igoLayer.options.igoStyle?.styleByAttribute &&
+            !igoLayer.options.igoStyle?.hoverStyle) {
+            return false;
+        }
+        if (igoLayer.options.igoStyle?.styleByAttribute &&
+            !igoLayer.options.igoStyle?.styleByAttribute.hoverStyle &&
+            !igoLayer.options.igoStyle?.hoverStyle) {
+            return false;
+        }
+        return true;
+    }
+    handleRenderFeature(feature) {
+        let localFeature;
+        if (feature instanceof RenderFeature) {
+            localFeature = new OlFeature({
+                geometry: this.getGeometry(feature)
+            });
+            localFeature.setId(feature.getId());
+        }
+        else if (feature instanceof OlFeature) {
+            localFeature = feature;
+        }
+        localFeature.setProperties(feature.getProperties());
+        return localFeature;
+    }
+    /**
+     * Add a feature to the pointer store
+     * @param text string
+     */
+    addFeatureOverlay(hoverEntity) {
+        if (hoverEntity.length > 0) {
+            const result = hoverEntity[0];
+            this.clearLayer();
+            const feature = new OlFeature({
+                geometry: result.getGeometry(),
+                meta: { id: this.hoverFeatureId },
+                hoverSummary: this.getHoverSummary(result.getProperties())
+            });
+            this.store.setLayerOlFeatures([feature], FeatureMotion.None);
+        }
+    }
+    setLayerStyleFromOptions(igoLayer, feature) {
+        const resolution = this.store.layer.map.viewController.getResolution();
+        if (igoLayer?.options?.igoStyle?.styleByAttribute?.hoverStyle) {
+            this.store.layer.ol.setStyle(this.createHoverStyle(feature, igoLayer.options.igoStyle.styleByAttribute.hoverStyle, resolution));
+            return;
+        }
+        if (igoLayer?.options?.igoStyle?.hoverStyle) {
+            this.store.layer.ol.setStyle(this.createHoverStyle(feature, igoLayer.options.igoStyle.hoverStyle, resolution));
+        }
+    }
+    getHoverSummary(properties) {
+        let summary = '';
+        for (const [key, value] of Object.entries(properties)) {
+            if (!key.startsWith('_') && key !== 'geometry') {
+                summary += `${key}: ${value}` + '\n';
+            }
+        }
+        return summary.length >= 2 ? summary.slice(0, -2) : summary;
+    }
+    getGeometry(feature) {
+        let geom;
+        if (!feature.getOrientedFlatCoordinates) {
+            geom = feature.getGeometry();
+        }
+        else {
+            const coords = feature.getOrientedFlatCoordinates();
+            const flatCoords = [];
+            coords.forEach((c, idx) => {
+                if (idx % 2 === 0) {
+                    flatCoords.push([
+                        parseFloat(coords[idx]),
+                        parseFloat(coords[idx + 1])
+                    ]);
+                }
+            });
+            // TODO: test MultiX
+            switch (feature.getType()) {
+                case 'Point':
+                    geom = new OlGeom.Point(flatCoords);
+                    break;
+                case 'Polygon':
+                    geom = new OlGeom.Polygon([flatCoords]);
+                    break;
+                case 'LineString':
+                    geom = new OlGeom.LineString([flatCoords]);
+                    break;
+            }
+        }
+        return geom;
+    }
+    /**
+     * Clear the pointer store features
+     */
+    clearLayer() {
+        this.selectionMVT = {};
+        if (this.selectionLayer) {
+            this.selectionLayer.changed();
+        }
+        if (this.store) {
+            this.store.clearLayer();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HoverFeatureDirective, deps: [{ token: i1.MapBrowserComponent, self: true }, { token: i2.MediaService }, { token: i3.StyleService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: HoverFeatureDirective, isStandalone: true, selector: "[igoHoverFeature]", inputs: { igoHoverFeatureDelay: "igoHoverFeatureDelay", igoHoverFeatureEnabled: "igoHoverFeatureEnabled" }, host: { listeners: { "mouseout": "mouseout()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HoverFeatureDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[igoHoverFeature]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.MapBrowserComponent, decorators: [{
+                    type: Self
+                }] }, { type: i2.MediaService }, { type: i3.StyleService }], propDecorators: { igoHoverFeatureDelay: [{
+                type: Input
+            }], igoHoverFeatureEnabled: [{
+                type: Input
+            }], mouseout: [{
+                type: HostListener,
+                args: ['mouseout']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hover-feature.directive.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/map/shared/hover-feature.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\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 type { default as OlMapBrowserEvent } from 'ol/MapBrowserEvent';\nimport { unByKey } from 'ol/Observable';\nimport * as OlGeom from 'ol/geom';\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\nimport olLayerVector from 'ol/layer/Vector';\nimport olLayerVectorTile from 'ol/layer/VectorTile';\nimport RenderFeature from 'ol/render/Feature';\nimport olVectorTileSource from 'ol/source/VectorTile';\n\nimport { Subscription } from 'rxjs';\nimport { first } from 'rxjs/operators';\n\nimport { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';\nimport { tryBindStoreLayer } from '../../feature/shared/feature-store.utils';\nimport { FeatureMotion } from '../../feature/shared/feature.enums';\nimport { Feature } from '../../feature/shared/feature.interfaces';\nimport { FeatureStore } from '../../feature/shared/store';\nimport { VectorLayer, VectorTileLayer } from '../../layer/shared/layers';\nimport { MapBrowserComponent } from '../../map/map-browser/map-browser.component';\nimport { IgoMap } from '../../map/shared/map';\nimport { hoverFeatureMarkerStyle } from '../../style/shared/feature/feature-style';\nimport { StyleByAttribute } from '../../style/shared/vector/vector-style.interface';\nimport { StyleService } from '../../style/style-service/style.service';\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: '[igoHoverFeature]',\n  standalone: true\n})\nexport class HoverFeatureDirective implements OnInit, OnDestroy {\n  public store: FeatureStore<Feature>;\n  private pointerHoverFeatureStore: EntityStore<OlFeature<OlGeometry>> =\n    new EntityStore<OlFeature<OlGeometry>>([]);\n  private lastTimeoutRequest;\n  private store$$: Subscription;\n\n  private selectionLayer: olLayerVectorTile;\n  private selectionMVT = {};\n  private mvtStyleOptions: StyleByAttribute;\n\n  /**\n   * Listener to the pointer move event\n   */\n  private pointerMoveListener;\n\n  private singleClickMapListener;\n\n  private hoverFeatureId = 'hoverFeatureId';\n  /**\n   * The delay where the mouse must be motionless before trigger the reverse search\n   */\n  @Input() igoHoverFeatureDelay = 1000;\n\n  /**\n   * If the user has enabled or not the directive\n   */\n  @Input() igoHoverFeatureEnabled = false;\n\n  @HostListener('mouseout')\n  mouseout() {\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 mediaService: MediaService,\n    private styleService: StyleService\n  ) {}\n\n  /**\n   * Start listening to pointermove and reverse search results.\n   * @internal\n   */\n  ngOnInit() {\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.listenToMapPointerMove();\n        this.subscribeToPointerStore();\n        this.listenToMapClick();\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: 'hoverFeatureId',\n      title: 'hoverFeature',\n      zIndex: 900,\n      source: new FeatureDataSource(),\n      showInLayerList: false,\n      exportable: false,\n      browsable: false,\n      style: hoverFeatureMarkerStyle\n    });\n    tryBindStoreLayer(store, layer);\n\n    this.selectionLayer = new olLayerVectorTile({\n      map: this.map.ol,\n      zIndex: 901,\n      renderMode: 'vector',\n      declutter: true,\n      source: new olVectorTileSource({ projection: this.map.projection }),\n      style: (feature, resolution) => {\n        if (this.mvtStyleOptions && feature.getId() in this.selectionMVT) {\n          return this.createHoverStyle(\n            feature,\n            this.mvtStyleOptions,\n            resolution\n          );\n        }\n      }\n    });\n  }\n\n  createHoverStyle(\n    feature: RenderFeature | OlFeature<OlGeometry>,\n    hoverStyle: StyleByAttribute,\n    resolution: number\n  ) {\n    const localHoverStyle = { ...hoverStyle };\n    let label = hoverStyle.label ? hoverStyle.label.attribute : undefined;\n    let hasLabelStyle = hoverStyle.label?.style ? true : false;\n\n    if (!feature.get('_isLabel')) {\n      localHoverStyle.label = undefined;\n      hasLabelStyle = false;\n      label = undefined;\n    } else {\n      // clear the style for label....\n      const size = localHoverStyle.data ? localHoverStyle.data.length : 0;\n      const radius = [];\n      const stroke = [];\n      const width = [];\n      const fill = [];\n      for (let i = 0; i < size; i++) {\n        radius.push(0);\n        stroke.push('rgba(255, 255, 255, 0)');\n        width.push(0);\n        fill.push('rgba(255, 255, 255, 0)');\n      }\n      localHoverStyle.radius = radius;\n      localHoverStyle.stroke = stroke;\n      localHoverStyle.width = width;\n      localHoverStyle.fill = fill;\n    }\n    if (!hasLabelStyle && label) {\n      localHoverStyle.label.style = {\n        textAlign: 'left',\n        textBaseline: 'top',\n        font: '12px Calibri,sans-serif',\n        fill: { color: '#000' },\n        backgroundFill: { color: 'rgba(255, 255, 255, 0.5)' },\n        backgroundStroke: { color: 'rgba(200, 200, 200, 0.75)', width: 2 },\n        stroke: { color: '#fff', width: 3 },\n        overflow: true,\n        offsetX: 10,\n        offsetY: 20,\n        padding: [2.5, 2.5, 2.5, 2.5]\n      };\n    }\n    return this.styleService.createStyleByAttribute(\n      feature,\n      localHoverStyle,\n      resolution\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.unlistenToMapSingleClick();\n  }\n\n  /**\n   * Subscribe to pointermove result store\n   * @internal\n   */\n  subscribeToPointerStore() {\n    this.store$$ = this.pointerHoverFeatureStore.entities$.subscribe(\n      (resultsUnderPointerPosition) => {\n        this.addFeatureOverlay(resultsUnderPointerPosition);\n      }\n    );\n  }\n\n  /**\n   * On map pointermove\n   */\n  private listenToMapPointerMove() {\n    this.pointerMoveListener = this.map.ol.on(\n      'pointermove',\n      (event: OlMapBrowserEvent<any>) => this.onMapEvent(event)\n    );\n  }\n\n  /**\n   * On map singleclick\n   */\n  private listenToMapClick() {\n    this.singleClickMapListener = this.map.ol.on('singleclick', () =>\n      this.onMapSingleClickEvent()\n    );\n  }\n\n  /**\n   * Unsubscribe to pointer store.\n   * @internal\n   */\n  unsubscribeToPointerStore() {\n    this.store$$?.unsubscribe();\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   * Stop listening for map singleclick\n   * @internal\n   */\n  private unlistenToMapSingleClick() {\n    unByKey(this.singleClickMapListener);\n    this.singleClickMapListener = undefined;\n  }\n\n  /**\n   * Trigger clear layer on singleclick.\n   * @param event OL map browser singleclick event\n   */\n  private onMapSingleClickEvent() {\n    this.clearLayer();\n  }\n\n  /**\n   * Trigger hover when the mouse is motionless during the defined delay (pointerMoveDelay).\n   * @param event OL map browser pointer event\n   */\n  private onMapEvent(event: OlMapBrowserEvent<any>) {\n    if (\n      event.dragging ||\n      !this.igoHoverFeatureEnabled ||\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    }\n    let maximumZindex = -Infinity;\n    let topMostOlLayer;\n    const pixel = this.map.ol.getPixelFromCoordinate(event.coordinate);\n    this.lastTimeoutRequest = setTimeout(() => {\n      // retrieve the topmost layer with feature to only apply the hover on this layer.\n      this.map.ol.forEachFeatureAtPixel(\n        pixel,\n        (mapFeature: RenderFeature | OlFeature<OlGeometry>, layerOL: any) => {\n          if (!layerOL) {\n            return;\n          }\n          const igoLayer = this.map.getLayerByOlUId((layerOL as any).ol_uid);\n          if (!this.canProcessHover(igoLayer as any)) {\n            return;\n          }\n          if (igoLayer.zIndex <= maximumZindex) {\n            return;\n          }\n          maximumZindex = igoLayer.zIndex;\n          topMostOlLayer = layerOL;\n        },\n        {\n          hitTolerance: 10,\n          layerFilter: (olLayer) =>\n            olLayer instanceof olLayerVector ||\n            olLayer instanceof olLayerVectorTile\n        }\n      );\n      if (!topMostOlLayer) {\n        // To clear label\n        this.clearLayer();\n        this.pointerHoverFeatureStore.clear();\n        return;\n      }\n\n      this.map.ol.forEachFeatureAtPixel(\n        pixel,\n        (mapFeature: RenderFeature | OlFeature<OlGeometry>, layerOL: any) => {\n          // To avoid flashing feature\n          if (\n            mapFeature.get('hoverSummary') === undefined &&\n            mapFeature.getProperties() !==\n              this.pointerHoverFeatureStore.all()[0]?.getProperties()\n          ) {\n            this.clearLayer();\n            if (layerOL instanceof olLayerVector) {\n              const myLayerVector = this.map.getLayerByOlUId(\n                (layerOL as any).ol_uid\n              ) as VectorLayer;\n              if (!this.canProcessHover(myLayerVector)) {\n                return;\n              }\n              const localOlFeature = this.handleRenderFeature(mapFeature);\n              this.setLayerStyleFromOptions(myLayerVector, localOlFeature);\n              const featuresToLoad = [localOlFeature];\n              localOlFeature.set('_isLabel', false);\n              const myLabelOlFeature = new OlFeature();\n              myLabelOlFeature.setProperties(localOlFeature.getProperties());\n              const labelGeom =\n                localOlFeature.getGeometry().getType() === 'Point'\n                  ? localOlFeature.getGeometry()\n                  : new OlGeom.Point(event.coordinate);\n              myLabelOlFeature.setGeometry(labelGeom);\n              myLabelOlFeature.setId(localOlFeature.getId());\n              myLabelOlFeature.set('_isLabel', true);\n              this.setLayerStyleFromOptions(myLayerVector, myLabelOlFeature);\n              featuresToLoad.push(myLabelOlFeature);\n              this.pointerHoverFeatureStore.load(featuresToLoad);\n              return true;\n            }\n            if (layerOL instanceof olLayerVectorTile) {\n              const myLayerVectorTile = this.map.getLayerByOlUId(\n                (layerOL as any).ol_uid\n              ) as VectorTileLayer;\n              if (!this.canProcessHover(myLayerVectorTile)) {\n                return;\n              }\n              if (\n                myLayerVectorTile?.options?.igoStyle?.styleByAttribute\n                  ?.hoverStyle\n              ) {\n                this.mvtStyleOptions =\n                  myLayerVectorTile.options.igoStyle.styleByAttribute.hoverStyle;\n              } else if (myLayerVectorTile?.options?.igoStyle?.hoverStyle) {\n                this.mvtStyleOptions =\n                  myLayerVectorTile.options.igoStyle.hoverStyle;\n              }\n              this.selectionLayer.setSource(layerOL.getSource());\n              layerOL\n                .getFeatures(event.pixel)\n                .then(\n                  (mvtFeatures: (RenderFeature | OlFeature<OlGeometry>)[]) => {\n                    if (!mvtFeatures.length) {\n                      this.selectionMVT = {};\n                      this.selectionLayer.changed();\n                      this.clearLayer();\n                      return;\n                    }\n                    const feature = mvtFeatures[0];\n                    if (!feature) {\n                      this.clearLayer();\n                      return;\n                    }\n                    const localOlFeature = this.handleRenderFeature(feature);\n                    localOlFeature.set('_isLabel', false);\n                    const myLabelOlFeature = new OlFeature();\n                    myLabelOlFeature.setProperties(\n                      localOlFeature.getProperties()\n                    );\n                    const labelGeom =\n                      localOlFeature.getGeometry().getType() === 'Point'\n                        ? localOlFeature.getGeometry()\n                        : new OlGeom.Point(event.coordinate);\n                    myLabelOlFeature.setGeometry(labelGeom);\n                    myLabelOlFeature.setId(localOlFeature.getId());\n                    myLabelOlFeature.set('_isLabel', true);\n                    this.setLayerStyleFromOptions(\n                      myLayerVectorTile,\n                      myLabelOlFeature\n                    );\n                    this.pointerHoverFeatureStore.load([myLabelOlFeature]);\n                    this.selectionMVT[feature.getId()] = localOlFeature;\n                    this.selectionLayer.changed();\n                  }\n                );\n            }\n          }\n        },\n        {\n          hitTolerance: 10,\n          layerFilter: (olLayer) => olLayer === topMostOlLayer\n        }\n      );\n    }, this.igoHoverFeatureDelay);\n  }\n\n  canProcessHover(igoLayer: VectorLayer | VectorTileLayer): boolean {\n    if (!igoLayer) {\n      return false;\n    }\n    if (!igoLayer.visible) {\n      return false;\n    }\n    if (!igoLayer.options) {\n      return false;\n    }\n\n    if (\n      !igoLayer.options.igoStyle?.styleByAttribute &&\n      !igoLayer.options.igoStyle?.hoverStyle\n    ) {\n      return false;\n    }\n\n    if (\n      igoLayer.options.igoStyle?.styleByAttribute &&\n      !igoLayer.options.igoStyle?.styleByAttribute.hoverStyle &&\n      !igoLayer.options.igoStyle?.hoverStyle\n    ) {\n      return false;\n    }\n    return true;\n  }\n\n  handleRenderFeature(\n    feature: RenderFeature | OlFeature<OlGeometry>\n  ): OlFeature<OlGeometry> {\n    let localFeature: OlFeature<OlGeometry>;\n    if (feature instanceof RenderFeature) {\n      localFeature = new OlFeature({\n        geometry: this.getGeometry(feature)\n      });\n      localFeature.setId(feature.getId());\n    } else if (feature instanceof OlFeature) {\n      localFeature = feature;\n    }\n    localFeature.setProperties(feature.getProperties());\n    return localFeature;\n  }\n\n  /**\n   * Add a feature to the pointer store\n   * @param text string\n   */\n  private addFeatureOverlay(hoverEntity: OlFeature<OlGeometry>[]) {\n    if (hoverEntity.length > 0) {\n      const result = hoverEntity[0];\n      this.clearLayer();\n      const feature = new OlFeature({\n        geometry: result.getGeometry(),\n        meta: { id: this.hoverFeatureId },\n        hoverSummary: this.getHoverSummary(result.getProperties())\n      });\n\n      this.store.setLayerOlFeatures([feature], FeatureMotion.None);\n    }\n  }\n\n  private setLayerStyleFromOptions(\n    igoLayer: VectorLayer | VectorTileLayer,\n    feature: OlFeature<OlGeometry>\n  ) {\n    const resolution = this.store.layer.map.viewController.getResolution();\n    if (igoLayer?.options?.igoStyle?.styleByAttribute?.hoverStyle) {\n      this.store.layer.ol.setStyle(\n        this.createHoverStyle(\n          feature,\n          igoLayer.options.igoStyle.styleByAttribute.hoverStyle,\n          resolution\n        )\n      );\n      return;\n    }\n    if (igoLayer?.options?.igoStyle?.hoverStyle) {\n      this.store.layer.ol.setStyle(\n        this.createHoverStyle(\n          feature,\n          igoLayer.options.igoStyle.hoverStyle,\n          resolution\n        )\n      );\n    }\n  }\n\n  private getHoverSummary(properties): string {\n    let summary = '';\n    for (const [key, value] of Object.entries(properties)) {\n      if (!key.startsWith('_') && key !== 'geometry') {\n        summary += `${key}: ${value}` + '\\n';\n      }\n    }\n    return summary.length >= 2 ? summary.slice(0, -2) : summary;\n  }\n\n  private getGeometry(feature): OlGeom.Geometry {\n    let geom;\n    if (!feature.getOrientedFlatCoordinates) {\n      geom = feature.getGeometry();\n    } else {\n      const coords = feature.getOrientedFlatCoordinates();\n      const flatCoords = [];\n\n      coords.forEach((c, idx) => {\n        if (idx % 2 === 0) {\n          flatCoords.push([\n            parseFloat(coords[idx]),\n            parseFloat(coords[idx + 1])\n          ]);\n        }\n      });\n\n      // TODO: test MultiX\n      switch (feature.getType()) {\n        case 'Point':\n          geom = new OlGeom.Point(flatCoords);\n          break;\n        case 'Polygon':\n          geom = new OlGeom.Polygon([flatCoords]);\n          break;\n        case 'LineString':\n          geom = new OlGeom.LineString([flatCoords]);\n          break;\n      }\n    }\n\n    return geom;\n  }\n\n  /**\n   * Clear the pointer store features\n   */\n  private clearLayer() {\n    this.selectionMVT = {};\n    if (this.selectionLayer) {\n      this.selectionLayer.changed();\n    }\n    if (this.store) {\n      this.store.clearLayer();\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,15 @@
+export * from './map';
+export * from './map.abstract';
+export * from './map.enums';
+export * from './map.interface';
+export * from './map.service';
+export * from './map.utils';
+export * from './mapOffline.directive';
+export * from './map-pointer-position.directive';
+export * from './hover-feature.directive';
+export * from './projection.interfaces';
+export * from './projection.service';
+export * from './controllers';
+export * from './projection.utils';
+export * from './linkedLayers.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9tYXAvc2hhcmVkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsT0FBTyxDQUFDO0FBQ3RCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9tYXAnO1xuZXhwb3J0ICogZnJvbSAnLi9tYXAuYWJzdHJhY3QnO1xuZXhwb3J0ICogZnJvbSAnLi9tYXAuZW51bXMnO1xuZXhwb3J0ICogZnJvbSAnLi9tYXAuaW50ZXJmYWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbWFwLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9tYXAudXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9tYXBPZmZsaW5lLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL21hcC1wb2ludGVyLXBvc2l0aW9uLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2hvdmVyLWZlYXR1cmUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvamVjdGlvbi5pbnRlcmZhY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvamVjdGlvbi5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vY29udHJvbGxlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9wcm9qZWN0aW9uLnV0aWxzJztcbmV4cG9ydCAqIGZyb20gJy4vbGlua2VkTGF5ZXJzLnV0aWxzJztcbiJdfQ==