@igo2/geo 1.15.4 → 16.0.0-rc.1

package/esm2022/lib/map/shared/linkedLayers.utils.mjs

@@ -0,0 +1,248 @@
+import { getUid } from 'ol/util';
+import { WMSDataSource } from '../../datasource/shared/datasources/wms-datasource';
+import { LinkedProperties } from '../../layer/shared/layers';
+import { OgcFilterWriter } from '../../filter/shared/ogc-filter';
+export function getLinkedLayersOptions(layer) {
+    return layer.options.linkedLayers;
+}
+export function getIgoLayerByLinkId(map, id) {
+    return map.layers.find((l) => l.options.linkedLayers?.linkId === id);
+}
+export function layerHasLinkWithProperty(layer, property) {
+    let hasLinkWithProperty = false;
+    const layerLLOptions = getLinkedLayersOptions(layer);
+    if (layerLLOptions?.links) {
+        const link = layerLLOptions.links.find((l) => l.properties.includes(property));
+        hasLinkWithProperty = link ? true : false;
+    }
+    return hasLinkWithProperty;
+}
+export function layerHasLinkDeletion(layer) {
+    let hasLinkWithSyncedDelete = false;
+    const layerLLOptions = getLinkedLayersOptions(layer);
+    if (layerLLOptions?.links) {
+        const link = layerLLOptions.links.find((l) => l.syncedDelete);
+        hasLinkWithSyncedDelete = link ? true : false;
+    }
+    return hasLinkWithSyncedDelete;
+}
+export function getRootParentByProperty(map, layer, property) {
+    let layerToUse = layer;
+    let parentLayer = layerToUse;
+    let hasParentLayer = true;
+    while (hasParentLayer) {
+        layerToUse = parentLayer;
+        parentLayer = getDirectParentLayerByProperty(map, layerToUse, property);
+        hasParentLayer = parentLayer ? true : false;
+    }
+    if (!hasParentLayer) {
+        if (!layerHasLinkWithProperty(layerToUse, property)) {
+            layerToUse = undefined;
+        }
+    }
+    return hasParentLayer ? parentLayer : layerToUse;
+}
+export function getDirectParentLayerByProperty(map, layer, property) {
+    if (layer?.options.linkedLayers?.linkId) {
+        const currentLinkId = layer.options.linkedLayers.linkId;
+        let parents = map.layers.filter((pl) => {
+            const linkedLayers = pl.options.linkedLayers;
+            if (linkedLayers && linkedLayers.links) {
+                const a = linkedLayers.links.find((l) => l.linkedIds.includes(currentLinkId) &&
+                    l.properties.includes(property));
+                return a;
+            }
+        });
+        if (parents.length > 1) {
+            console.warn(`Your layer ${layer.title || layer.id} must only have 1 parent (${parents.map((p) => p.title || p.id)})
+            , The first parent (${parents[0].title || parents[0].id}) will be use to sync properties`);
+        }
+        return parents[0];
+    }
+}
+export function getDirectChildLayersByProperty(map, layer, property) {
+    let linkedIds = [];
+    if (layer?.options.linkedLayers?.links) {
+        layer.options.linkedLayers.links
+            .filter((l) => l.properties.includes(property))
+            .map((link) => {
+            linkedIds = linkedIds.concat(link.linkedIds);
+        });
+    }
+    return linkedIds.map((lid) => getIgoLayerByLinkId(map, lid));
+}
+export function getAllChildLayersByProperty(map, layer, knownChildLayers, property) {
+    let childLayers = getDirectChildLayersByProperty(map, layer, property);
+    childLayers.map((cl) => {
+        knownChildLayers.push(cl);
+        const directChildLayers = getDirectChildLayersByProperty(map, cl, property);
+        if (directChildLayers) {
+            getAllChildLayersByProperty(map, cl, knownChildLayers, property);
+        }
+    });
+    return knownChildLayers;
+}
+export function getRootParentByDeletion(map, layer) {
+    let layerToUse = layer;
+    let parentLayer = layerToUse;
+    let hasParentLayer = true;
+    while (hasParentLayer) {
+        layerToUse = parentLayer;
+        parentLayer = getDirectParentLayerByDeletion(map, layerToUse);
+        hasParentLayer = parentLayer ? true : false;
+    }
+    if (!hasParentLayer) {
+        if (!layerHasLinkDeletion(layerToUse)) {
+            layerToUse = undefined;
+        }
+    }
+    return hasParentLayer ? parentLayer : layerToUse;
+}
+export function getDirectParentLayerByDeletion(map, layer) {
+    if (layer.options.linkedLayers?.linkId) {
+        const currentLinkId = layer.options.linkedLayers.linkId;
+        let parents = map.layers.filter((pl) => {
+            const linkedLayers = pl.options.linkedLayers;
+            if (linkedLayers && linkedLayers.links) {
+                const a = linkedLayers.links.find((l) => l.linkedIds.includes(currentLinkId) && l.syncedDelete);
+                return a;
+            }
+        });
+        if (parents.length > 1) {
+            console.warn(`Your layer ${layer.title || layer.id} must only have 1 parent (${parents.map((p) => p.title || p.id)})
+          , The first parent (${parents[0].title || parents[0].id}) will be use to sync properties`);
+        }
+        return parents[0];
+    }
+}
+export function getDirectChildLayersByDeletion(map, layer) {
+    let linkedIds = [];
+    if (layer?.options.linkedLayers?.links) {
+        layer.options.linkedLayers.links
+            .filter((l) => l.syncedDelete)
+            .map((link) => {
+            linkedIds = linkedIds.concat(link.linkedIds);
+        });
+    }
+    return linkedIds.map((lid) => getIgoLayerByLinkId(map, lid));
+}
+export function getAllChildLayersByDeletion(map, layer, knownChildLayers) {
+    let childLayers = getDirectChildLayersByDeletion(map, layer);
+    childLayers.map((cl) => {
+        knownChildLayers.push(cl);
+        const directChildLayers = getDirectChildLayersByDeletion(map, cl);
+        if (directChildLayers) {
+            getAllChildLayersByDeletion(map, cl, knownChildLayers);
+        }
+    });
+    return knownChildLayers;
+}
+export function initLayerSyncFromRootParentLayers(map, layers) {
+    const rootLayersByProperty = {};
+    const keys = Object.keys(LinkedProperties);
+    keys.map((k) => {
+        rootLayersByProperty[LinkedProperties[k]] = [];
+    });
+    layers
+        .filter((l) => getLinkedLayersOptions(l))
+        .map((l) => {
+        keys.map((key) => {
+            const k = LinkedProperties[key];
+            const plbp = getRootParentByProperty(map, l, k);
+            const layers = rootLayersByProperty[k];
+            const layersId = layers.map((l) => l.id);
+            if (plbp && !layersId.includes(plbp.id)) {
+                rootLayersByProperty[k].push(plbp);
+            }
+        });
+    });
+    Object.keys(rootLayersByProperty).map((k) => {
+        const layers = rootLayersByProperty[k];
+        layers.map((l) => l.ol.notify(k, undefined));
+    });
+}
+export function handleLayerPropertyChange(map, propertyChange, initiatorIgoLayer) {
+    if (!propertyChange) {
+        return;
+    }
+    const ogcFilterWriter = new OgcFilterWriter();
+    let isLayerProperty = true;
+    let isDatasourceProperty = true;
+    const key = propertyChange.key;
+    let newValue;
+    if (key === 'ogcFilters') {
+        isLayerProperty = false;
+        isDatasourceProperty = true;
+        newValue = initiatorIgoLayer.dataSource.options.ogcFilters;
+    }
+    else if (key === 'timeFilter') {
+        isLayerProperty = false;
+        isDatasourceProperty = true;
+        newValue = initiatorIgoLayer.dataSource.options.timeFilter;
+    }
+    else {
+        isLayerProperty = true;
+        isDatasourceProperty = false;
+        newValue = initiatorIgoLayer.ol.get(key);
+    }
+    const initiatorLinkedLayersOptions = getLinkedLayersOptions(initiatorIgoLayer);
+    if (initiatorLinkedLayersOptions) {
+        let rootParentByProperty = getRootParentByProperty(map, initiatorIgoLayer, key);
+        if (!rootParentByProperty) {
+            rootParentByProperty = initiatorIgoLayer;
+        }
+        const clbp = [rootParentByProperty];
+        getAllChildLayersByProperty(map, rootParentByProperty, clbp, key);
+        let resolutionPropertyHasChanged = false;
+        const initiatorIgoLayerSourceType = initiatorIgoLayer.options.source.options.type;
+        const initiatorIgoLayerOgcFilterableDataSourceOptions = initiatorIgoLayer
+            .dataSource.options;
+        clbp.map((l) => {
+            if (initiatorIgoLayer &&
+                l &&
+                getUid(initiatorIgoLayer.ol) !== getUid(l?.ol)) {
+                const lLayerType = l.options.source.options.type;
+                if (isLayerProperty) {
+                    l.ol.set(key, newValue, true);
+                    if (key === 'visible') {
+                        l.visible$.next(newValue);
+                    }
+                    if (key === 'minResolution' || key === 'maxResolution') {
+                        resolutionPropertyHasChanged = true;
+                    }
+                }
+                else if (isDatasourceProperty) {
+                    if (key === 'ogcFilters') {
+                        l.dataSource.setOgcFilters(newValue, false);
+                        if (lLayerType === 'wfs') {
+                            l.ol.getSource().refresh();
+                        }
+                        if (lLayerType === 'wms') {
+                            let appliedOgcFilter;
+                            if (initiatorIgoLayerSourceType === 'wfs') {
+                                appliedOgcFilter = ogcFilterWriter.handleOgcFiltersAppliedValue(initiatorIgoLayerOgcFilterableDataSourceOptions, initiatorIgoLayer.dataSource.options
+                                    .fieldNameGeometry, undefined, map.viewController.getOlProjection());
+                            }
+                            else if (initiatorIgoLayerSourceType === 'wms') {
+                                appliedOgcFilter = initiatorIgoLayer.dataSource.ol.getParams().FILTER;
+                            }
+                            l.dataSource.ol.updateParams({
+                                FILTER: appliedOgcFilter
+                            });
+                        }
+                    }
+                    else if (l.dataSource instanceof WMSDataSource &&
+                        key === 'timeFilter') {
+                        l.dataSource.setTimeFilter(newValue, false);
+                        const appliedTimeFilter = initiatorIgoLayer.ol.getSource().getParams().TIME;
+                        l.dataSource.ol.updateParams({ TIME: appliedTimeFilter });
+                    }
+                }
+            }
+        });
+        if (resolutionPropertyHasChanged) {
+            map.viewController.resolution$.next(map.viewController.resolution$.value);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"linkedLayers.utils.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/map/shared/linkedLayers.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { ObjectEvent } from 'ol/Object';\nimport { getUid } from 'ol/util';\nimport { WMSDataSource } from '../../datasource/shared/datasources/wms-datasource';\nimport {\n  OgcFilterableDataSource,\n  OgcFilterableDataSourceOptions\n} from '../../filter/shared/ogc-filter.interface';\nimport { Layer, LinkedProperties } from '../../layer/shared/layers';\nimport olSourceImageWMS from 'ol/source/ImageWMS';\nimport { OgcFilterWriter } from '../../filter/shared/ogc-filter';\nimport {\n  TimeFilterableDataSource,\n  TimeFilterableDataSourceOptions\n} from '../../datasource';\nimport { MapBase } from '../shared/map.abstract';\n\nexport function getLinkedLayersOptions(layer: Layer) {\n  return layer.options.linkedLayers;\n}\n\nexport function getIgoLayerByLinkId(map: MapBase, id: string) {\n  return map.layers.find((l) => l.options.linkedLayers?.linkId === id);\n}\n\nexport function layerHasLinkWithProperty(\n  layer: Layer,\n  property: LinkedProperties\n): boolean {\n  let hasLinkWithProperty = false;\n  const layerLLOptions = getLinkedLayersOptions(layer);\n  if (layerLLOptions?.links) {\n    const link = layerLLOptions.links.find((l) =>\n      l.properties.includes(property)\n    );\n    hasLinkWithProperty = link ? true : false;\n  }\n  return hasLinkWithProperty;\n}\n\nexport function layerHasLinkDeletion(layer: Layer): boolean {\n  let hasLinkWithSyncedDelete = false;\n  const layerLLOptions = getLinkedLayersOptions(layer);\n  if (layerLLOptions?.links) {\n    const link = layerLLOptions.links.find((l) => l.syncedDelete);\n    hasLinkWithSyncedDelete = link ? true : false;\n  }\n  return hasLinkWithSyncedDelete;\n}\n\nexport function getRootParentByProperty(\n  map: MapBase,\n  layer: Layer,\n  property: LinkedProperties\n): Layer {\n  let layerToUse = layer;\n  let parentLayer = layerToUse;\n  let hasParentLayer = true;\n  while (hasParentLayer) {\n    layerToUse = parentLayer;\n    parentLayer = getDirectParentLayerByProperty(map, layerToUse, property);\n    hasParentLayer = parentLayer ? true : false;\n  }\n  if (!hasParentLayer) {\n    if (!layerHasLinkWithProperty(layerToUse, property)) {\n      layerToUse = undefined;\n    }\n  }\n  return hasParentLayer ? parentLayer : layerToUse;\n}\n\nexport function getDirectParentLayerByProperty(\n  map: MapBase,\n  layer: Layer,\n  property: LinkedProperties\n): Layer {\n  if (layer?.options.linkedLayers?.linkId) {\n    const currentLinkId = layer.options.linkedLayers.linkId;\n    let parents = map.layers.filter((pl) => {\n      const linkedLayers = pl.options.linkedLayers;\n      if (linkedLayers && linkedLayers.links) {\n        const a = linkedLayers.links.find(\n          (l) =>\n            l.linkedIds.includes(currentLinkId) &&\n            l.properties.includes(property)\n        );\n        return a;\n      }\n    });\n    if (parents.length > 1) {\n      console.warn(`Your layer ${\n        layer.title || layer.id\n      } must only have 1 parent (${parents.map((p) => p.title || p.id)})\n            , The first parent (${\n              parents[0].title || parents[0].id\n            }) will be use to sync properties`);\n    }\n    return parents[0];\n  }\n}\n\nexport function getDirectChildLayersByProperty(\n  map: MapBase,\n  layer: Layer,\n  property: LinkedProperties\n): Layer[] {\n  let linkedIds = [];\n  if (layer?.options.linkedLayers?.links) {\n    layer.options.linkedLayers.links\n      .filter((l) => l.properties.includes(property))\n      .map((link) => {\n        linkedIds = linkedIds.concat(link.linkedIds);\n      });\n  }\n  return linkedIds.map((lid) => getIgoLayerByLinkId(map, lid));\n}\n\nexport function getAllChildLayersByProperty(\n  map: MapBase,\n  layer: Layer,\n  knownChildLayers: Layer[],\n  property: LinkedProperties\n): Layer[] {\n  let childLayers = getDirectChildLayersByProperty(map, layer, property);\n  childLayers.map((cl) => {\n    knownChildLayers.push(cl);\n    const directChildLayers = getDirectChildLayersByProperty(map, cl, property);\n    if (directChildLayers) {\n      getAllChildLayersByProperty(map, cl, knownChildLayers, property);\n    }\n  });\n  return knownChildLayers;\n}\n\nexport function getRootParentByDeletion(map: MapBase, layer: Layer): Layer {\n  let layerToUse = layer;\n  let parentLayer = layerToUse;\n  let hasParentLayer = true;\n  while (hasParentLayer) {\n    layerToUse = parentLayer;\n    parentLayer = getDirectParentLayerByDeletion(map, layerToUse);\n    hasParentLayer = parentLayer ? true : false;\n  }\n  if (!hasParentLayer) {\n    if (!layerHasLinkDeletion(layerToUse)) {\n      layerToUse = undefined;\n    }\n  }\n  return hasParentLayer ? parentLayer : layerToUse;\n}\n\nexport function getDirectParentLayerByDeletion(\n  map: MapBase,\n  layer: Layer\n): Layer {\n  if (layer.options.linkedLayers?.linkId) {\n    const currentLinkId = layer.options.linkedLayers.linkId;\n    let parents = map.layers.filter((pl) => {\n      const linkedLayers = pl.options.linkedLayers;\n      if (linkedLayers && linkedLayers.links) {\n        const a = linkedLayers.links.find(\n          (l) => l.linkedIds.includes(currentLinkId) && l.syncedDelete\n        );\n        return a;\n      }\n    });\n    if (parents.length > 1) {\n      console.warn(`Your layer ${\n        layer.title || layer.id\n      } must only have 1 parent (${parents.map((p) => p.title || p.id)})\n          , The first parent (${\n            parents[0].title || parents[0].id\n          }) will be use to sync properties`);\n    }\n    return parents[0];\n  }\n}\n\nexport function getDirectChildLayersByDeletion(\n  map: MapBase,\n  layer: Layer\n): Layer[] {\n  let linkedIds = [];\n  if (layer?.options.linkedLayers?.links) {\n    layer.options.linkedLayers.links\n      .filter((l) => l.syncedDelete)\n      .map((link) => {\n        linkedIds = linkedIds.concat(link.linkedIds);\n      });\n  }\n  return linkedIds.map((lid) => getIgoLayerByLinkId(map, lid));\n}\n\nexport function getAllChildLayersByDeletion(\n  map: MapBase,\n  layer: Layer,\n  knownChildLayers: Layer[]\n): Layer[] {\n  let childLayers = getDirectChildLayersByDeletion(map, layer);\n  childLayers.map((cl) => {\n    knownChildLayers.push(cl);\n    const directChildLayers = getDirectChildLayersByDeletion(map, cl);\n    if (directChildLayers) {\n      getAllChildLayersByDeletion(map, cl, knownChildLayers);\n    }\n  });\n  return knownChildLayers;\n}\n\nexport function initLayerSyncFromRootParentLayers(\n  map: MapBase,\n  layers: Layer[]\n) {\n  const rootLayersByProperty = {};\n  const keys = Object.keys(LinkedProperties);\n  keys.map((k) => {\n    rootLayersByProperty[LinkedProperties[k]] = [];\n  });\n  layers\n    .filter((l) => getLinkedLayersOptions(l))\n    .map((l) => {\n      keys.map((key) => {\n        const k = LinkedProperties[key];\n        const plbp = getRootParentByProperty(map, l, k as LinkedProperties);\n        const layers = rootLayersByProperty[k];\n        const layersId = layers.map((l) => l.id);\n        if (plbp && !layersId.includes(plbp.id)) {\n          rootLayersByProperty[k].push(plbp);\n        }\n      });\n    });\n  Object.keys(rootLayersByProperty).map((k) => {\n    const layers = rootLayersByProperty[k];\n    layers.map((l: Layer) => l.ol.notify(k, undefined));\n  });\n}\n\nexport function handleLayerPropertyChange(\n  map: MapBase,\n  propertyChange: ObjectEvent,\n  initiatorIgoLayer: Layer\n) {\n  if (!propertyChange) {\n    return;\n  }\n  const ogcFilterWriter = new OgcFilterWriter();\n  let isLayerProperty = true;\n  let isDatasourceProperty = true;\n  const key = propertyChange.key;\n  let newValue;\n  if (key === 'ogcFilters') {\n    isLayerProperty = false;\n    isDatasourceProperty = true;\n    newValue = (\n      initiatorIgoLayer.dataSource.options as OgcFilterableDataSourceOptions\n    ).ogcFilters;\n  } else if (key === 'timeFilter') {\n    isLayerProperty = false;\n    isDatasourceProperty = true;\n    newValue = (\n      initiatorIgoLayer.dataSource.options as TimeFilterableDataSourceOptions\n    ).timeFilter;\n  } else {\n    isLayerProperty = true;\n    isDatasourceProperty = false;\n    newValue = initiatorIgoLayer.ol.get(key);\n  }\n\n  const initiatorLinkedLayersOptions =\n    getLinkedLayersOptions(initiatorIgoLayer);\n  if (initiatorLinkedLayersOptions) {\n    let rootParentByProperty = getRootParentByProperty(\n      map,\n      initiatorIgoLayer,\n      key as LinkedProperties\n    );\n    if (!rootParentByProperty) {\n      rootParentByProperty = initiatorIgoLayer;\n    }\n\n    const clbp = [rootParentByProperty];\n    getAllChildLayersByProperty(\n      map,\n      rootParentByProperty,\n      clbp,\n      key as LinkedProperties\n    );\n\n    let resolutionPropertyHasChanged = false;\n    const initiatorIgoLayerSourceType =\n      initiatorIgoLayer.options.source.options.type;\n    const initiatorIgoLayerOgcFilterableDataSourceOptions = initiatorIgoLayer\n      .dataSource.options as OgcFilterableDataSourceOptions;\n    clbp.map((l) => {\n      if (\n        initiatorIgoLayer &&\n        l &&\n        getUid(initiatorIgoLayer.ol) !== getUid(l?.ol)\n      ) {\n        const lLayerType = l.options.source.options.type;\n        if (isLayerProperty) {\n          l.ol.set(key, newValue, true);\n          if (key === 'visible') {\n            l.visible$.next(newValue);\n          }\n          if (key === 'minResolution' || key === 'maxResolution') {\n            resolutionPropertyHasChanged = true;\n          }\n        } else if (isDatasourceProperty) {\n          if (key === 'ogcFilters') {\n            (l.dataSource as OgcFilterableDataSource).setOgcFilters(\n              newValue,\n              false\n            );\n            if (lLayerType === 'wfs') {\n              l.ol.getSource().refresh();\n            }\n            if (lLayerType === 'wms') {\n              let appliedOgcFilter;\n              if (initiatorIgoLayerSourceType === 'wfs') {\n                appliedOgcFilter = ogcFilterWriter.handleOgcFiltersAppliedValue(\n                  initiatorIgoLayerOgcFilterableDataSourceOptions,\n                  (initiatorIgoLayer.dataSource.options as any)\n                    .fieldNameGeometry,\n                  undefined,\n                  map.viewController.getOlProjection()\n                );\n              } else if (initiatorIgoLayerSourceType === 'wms') {\n                appliedOgcFilter = (\n                  initiatorIgoLayer.dataSource as WMSDataSource\n                ).ol.getParams().FILTER;\n              }\n              (l.dataSource as WMSDataSource).ol.updateParams({\n                FILTER: appliedOgcFilter\n              });\n            }\n          } else if (\n            l.dataSource instanceof WMSDataSource &&\n            key === 'timeFilter'\n          ) {\n            (l.dataSource as TimeFilterableDataSource).setTimeFilter(\n              newValue,\n              false\n            );\n            const appliedTimeFilter = (\n              initiatorIgoLayer.ol.getSource() as olSourceImageWMS\n            ).getParams().TIME;\n            l.dataSource.ol.updateParams({ TIME: appliedTimeFilter });\n          }\n        }\n      }\n    });\n    if (resolutionPropertyHasChanged) {\n      map.viewController.resolution$.next(map.viewController.resolution$.value);\n    }\n  }\n}\n"]}

package/esm2022/lib/map/shared/map-pointer-position.directive.mjs

@@ -0,0 +1,121 @@
+import { Directive, Input, Output, EventEmitter, Self } from '@angular/core';
+import { MapBrowserComponent } from '../../map/map-browser/map-browser.component';
+import { transform } from 'ol/proj';
+import { MediaService } from '@igo2/core';
+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 "@igo2/core";
+/**
+ * This directive return the pointer coordinate (on click or pointermove)
+ * in [longitude, latitude], delayed by in input (pointerMoveDelay)
+ * to avoid too many emitted values.
+ */
+export class PointerPositionDirective {
+    component;
+    mediaService;
+    lastTimeoutRequest;
+    /**
+     * Listener to the pointer move event
+     */
+    pointerMoveListener;
+    /**
+     * Listener to the map click event
+     */
+    mapClickListener;
+    /**
+     * Delay before emitting an event
+     */
+    pointerPositionDelay = 1000;
+    /**
+     * Event emitted when the pointer move, delayed by pointerMoveDelay
+     */
+    pointerPositionCoord = new EventEmitter();
+    /**
+     * IGO map
+     * @internal
+     */
+    get map() {
+        return this.component.map;
+    }
+    get mapProjection() {
+        return this.component.map.projection;
+    }
+    constructor(component, mediaService) {
+        this.component = component;
+        this.mediaService = mediaService;
+    }
+    /**
+     * Start listening to pointermove
+     * @internal
+     */
+    ngOnInit() {
+        this.listenToMapPointerMove();
+        this.listenToMapClick();
+    }
+    /**
+     * Stop listening to pointermove
+     * @internal
+     */
+    ngOnDestroy() {
+        this.unlistenToMapPointerMove();
+        this.unlistenToMapClick();
+    }
+    /**
+     * On map pointermove
+     */
+    listenToMapPointerMove() {
+        this.pointerMoveListener = this.map.ol.on('pointermove', (event) => this.onPointerEvent(event, this.pointerPositionDelay));
+    }
+    /**
+     * On map click
+     */
+    listenToMapClick() {
+        this.mapClickListener = this.map.ol.on('singleclick', (event) => this.onPointerEvent(event, 0));
+    }
+    /**
+     * Stop listening for map pointermove
+     */
+    unlistenToMapPointerMove() {
+        unByKey(this.pointerMoveListener);
+        this.pointerMoveListener = undefined;
+    }
+    /**
+     * Stop listening for map clicks
+     */
+    unlistenToMapClick() {
+        this.mapClickListener = undefined;
+    }
+    /**
+     * emit delayed coordinate (longitude, latitude array) based on pointerMoveDelay or on click
+     * @param event OL map browser pointer event
+     */
+    onPointerEvent(event, delay) {
+        if (event.dragging || this.mediaService.isTouchScreen()) {
+            return;
+        }
+        if (typeof this.lastTimeoutRequest !== 'undefined') {
+            // cancel timeout when the mouse moves
+            clearTimeout(this.lastTimeoutRequest);
+        }
+        const lonlat = transform(event.coordinate, this.mapProjection, 'EPSG:4326');
+        this.lastTimeoutRequest = setTimeout(() => {
+            this.pointerPositionCoord.emit(lonlat);
+        }, delay);
+    }
+    static ɵfac = function PointerPositionDirective_Factory(t) { return new (t || PointerPositionDirective)(i0.ɵɵdirectiveInject(i1.MapBrowserComponent, 2), i0.ɵɵdirectiveInject(i2.MediaService)); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PointerPositionDirective, selectors: [["", "igoPointerPosition", ""]], inputs: { pointerPositionDelay: "pointerPositionDelay" }, outputs: { pointerPositionCoord: "pointerPositionCoord" } });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PointerPositionDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[igoPointerPosition]'
+            }]
+    }], function () { return [{ type: i1.MapBrowserComponent, decorators: [{
+                type: Self
+            }] }, { type: i2.MediaService }]; }, { pointerPositionDelay: [{
+            type: Input
+        }], pointerPositionCoord: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,23 @@
+export class MapBase {
+    ol;
+    forcedOffline$;
+    layers$;
+    layersAddedByClick$;
+    status$;
+    propertyChange$;
+    overlay;
+    queryResultsOverlay;
+    searchResultsOverlay;
+    viewController;
+    geolocationController;
+    swipeEnabled$;
+    mapCenter$;
+    selectedFeatures$;
+    bufferDataSource;
+    // Getter
+    layers;
+    projection;
+    viewProjection;
+    projectionCode;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,6 @@
+export var MapViewAction;
+(function (MapViewAction) {
+    MapViewAction[MapViewAction["Move"] = 0] = "Move";
+    MapViewAction[MapViewAction["Zoom"] = 1] = "Zoom";
+})(MapViewAction || (MapViewAction = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwLmVudW1zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvbWFwL3NoYXJlZC9tYXAuZW51bXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksYUFHWDtBQUhELFdBQVksYUFBYTtJQUN2QixpREFBSSxDQUFBO0lBQ0osaURBQUksQ0FBQTtBQUNOLENBQUMsRUFIVyxhQUFhLEtBQWIsYUFBYSxRQUd4QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIE1hcFZpZXdBY3Rpb24ge1xuICBNb3ZlLFxuICBab29tXG59XG4iXX0=

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL21hcC9zaGFyZWQvbWFwLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVW5pdHMgfSBmcm9tICdvbC9jb250cm9sL1NjYWxlTGluZSc7XG5cbmV4cG9ydCB0eXBlIE1hcEV4dGVudCA9IFtudW1iZXIsIG51bWJlciwgbnVtYmVyLCBudW1iZXJdO1xuXG5leHBvcnQgaW50ZXJmYWNlIE1hcFZpZXdPcHRpb25zIHtcbiAgcHJvamVjdGlvbj86IHN0cmluZztcbiAgY2VudGVyPzogW251bWJlciwgbnVtYmVyXTtcbiAgbWF4Wm9vbU9uRXh0ZW50PzogbnVtYmVyO1xuICBnZW9sb2NhdGU/OiBib29sZWFuO1xuICBidWZmZXI/OiBCdWZmZXI7XG4gIGFsd2F5c1RyYWNraW5nPzogYm9vbGVhbjtcbiAgY29uc3RyYWluUm90YXRpb24/OiBib29sZWFuIHwgbnVtYmVyO1xuICBlbmFibGVSb3RhdGlvbj86IGJvb2xlYW47XG4gIGV4dGVudD86IE1hcEV4dGVudDtcbiAgbWF4TGF5ZXJab29tRXh0ZW50PzogTWFwRXh0ZW50O1xuICBtYXhSZXNvbHV0aW9uPzogbnVtYmVyO1xuICBtaW5SZXNvbHV0aW9uPzogbnVtYmVyO1xuICBtYXhab29tPzogbnVtYmVyO1xuICBtaW5ab29tPzogbnVtYmVyO1xuICByZXNvbHV0aW9uPzogbnVtYmVyO1xuICByZXNvbHV0aW9ucz86IG51bWJlcltdO1xuICByb3RhdGlvbj86IG51bWJlcjtcbiAgem9vbT86IG51bWJlcjtcbiAgem9vbUZhY3Rvcj86IG51bWJlcjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBNYXBWaWV3U3RhdGUge1xuICByZXNvbHV0aW9uOiBudW1iZXI7XG4gIGNlbnRlcjogW251bWJlciwgbnVtYmVyXTtcbiAgem9vbTogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIE1hcE9wdGlvbnMge1xuICB2aWV3PzogTWFwVmlld09wdGlvbnM7XG4gIGNvbnRyb2xzPzogTWFwQ29udHJvbHNPcHRpb25zO1xuICBvdmVybGF5PzogYm9vbGVhbjtcbiAgaW50ZXJhY3Rpb25zPzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBNYXBDb250cm9sc09wdGlvbnMge1xuICBhdHRyaWJ1dGlvbj86IGJvb2xlYW4gfCBNYXBBdHRyaWJ1dGlvbk9wdGlvbnM7XG4gIHNjYWxlTGluZT86IGJvb2xlYW4gfCBNYXBTY2FsZUxpbmVPcHRpb25zO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIE1hcFNjYWxlTGluZU9wdGlvbnMge1xuICBjbGFzc05hbWU/OiBzdHJpbmc7XG4gIG1pbldpZHRoPzogbnVtYmVyO1xuICB0YXJnZXQ/OiBzdHJpbmcgfCBIVE1MRWxlbWVudDtcbiAgdW5pdHM/OiBVbml0cztcbiAgYmFyPzogYm9vbGVhbjtcbiAgc3RlcHM/OiBudW1iZXI7XG4gIHRleHQ/OiBib29sZWFuO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIE1hcEF0dHJpYnV0aW9uT3B0aW9ucyB7XG4gIGh0bWw/OiBzdHJpbmc7XG4gIGNvbGxhcHNlZDogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBCdWZmZXIge1xuICBidWZmZXJSYWRpdXM/OiBudW1iZXI7XG4gIGJ1ZmZlclN0cm9rZT86IFtudW1iZXIsIG51bWJlciwgbnVtYmVyLCBudW1iZXJdO1xuICBidWZmZXJGaWxsPzogW251bWJlciwgbnVtYmVyLCBudW1iZXIsIG51bWJlcl07XG4gIHNob3dCdWZmZXJSYWRpdXM/OiBib29sZWFuO1xufVxuIl19