@igo2/geo 1.15.3 → 16.0.0-rc.0

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';\r\nimport { getUid } from 'ol/util';\r\nimport { WMSDataSource } from '../../datasource/shared/datasources/wms-datasource';\r\nimport {\r\n  OgcFilterableDataSource,\r\n  OgcFilterableDataSourceOptions\r\n} from '../../filter/shared/ogc-filter.interface';\r\nimport { Layer, LinkedProperties } from '../../layer/shared/layers';\r\nimport olSourceImageWMS from 'ol/source/ImageWMS';\r\nimport { OgcFilterWriter } from '../../filter/shared/ogc-filter';\r\nimport {\r\n  TimeFilterableDataSource,\r\n  TimeFilterableDataSourceOptions\r\n} from '../../datasource';\r\nimport { MapBase } from '../shared/map.abstract';\r\n\r\nexport function getLinkedLayersOptions(layer: Layer) {\r\n  return layer.options.linkedLayers;\r\n}\r\n\r\nexport function getIgoLayerByLinkId(map: MapBase, id: string) {\r\n  return map.layers.find((l) => l.options.linkedLayers?.linkId === id);\r\n}\r\n\r\nexport function layerHasLinkWithProperty(\r\n  layer: Layer,\r\n  property: LinkedProperties\r\n): boolean {\r\n  let hasLinkWithProperty = false;\r\n  const layerLLOptions = getLinkedLayersOptions(layer);\r\n  if (layerLLOptions?.links) {\r\n    const link = layerLLOptions.links.find((l) =>\r\n      l.properties.includes(property)\r\n    );\r\n    hasLinkWithProperty = link ? true : false;\r\n  }\r\n  return hasLinkWithProperty;\r\n}\r\n\r\nexport function layerHasLinkDeletion(layer: Layer): boolean {\r\n  let hasLinkWithSyncedDelete = false;\r\n  const layerLLOptions = getLinkedLayersOptions(layer);\r\n  if (layerLLOptions?.links) {\r\n    const link = layerLLOptions.links.find((l) => l.syncedDelete);\r\n    hasLinkWithSyncedDelete = link ? true : false;\r\n  }\r\n  return hasLinkWithSyncedDelete;\r\n}\r\n\r\nexport function getRootParentByProperty(\r\n  map: MapBase,\r\n  layer: Layer,\r\n  property: LinkedProperties\r\n): Layer {\r\n  let layerToUse = layer;\r\n  let parentLayer = layerToUse;\r\n  let hasParentLayer = true;\r\n  while (hasParentLayer) {\r\n    layerToUse = parentLayer;\r\n    parentLayer = getDirectParentLayerByProperty(map, layerToUse, property);\r\n    hasParentLayer = parentLayer ? true : false;\r\n  }\r\n  if (!hasParentLayer) {\r\n    if (!layerHasLinkWithProperty(layerToUse, property)) {\r\n      layerToUse = undefined;\r\n    }\r\n  }\r\n  return hasParentLayer ? parentLayer : layerToUse;\r\n}\r\n\r\nexport function getDirectParentLayerByProperty(\r\n  map: MapBase,\r\n  layer: Layer,\r\n  property: LinkedProperties\r\n): Layer {\r\n  if (layer?.options.linkedLayers?.linkId) {\r\n    const currentLinkId = layer.options.linkedLayers.linkId;\r\n    let parents = map.layers.filter((pl) => {\r\n      const linkedLayers = pl.options.linkedLayers;\r\n      if (linkedLayers && linkedLayers.links) {\r\n        const a = linkedLayers.links.find(\r\n          (l) =>\r\n            l.linkedIds.includes(currentLinkId) &&\r\n            l.properties.includes(property)\r\n        );\r\n        return a;\r\n      }\r\n    });\r\n    if (parents.length > 1) {\r\n      console.warn(`Your layer ${\r\n        layer.title || layer.id\r\n      } must only have 1 parent (${parents.map((p) => p.title || p.id)})\r\n            , The first parent (${\r\n              parents[0].title || parents[0].id\r\n            }) will be use to sync properties`);\r\n    }\r\n    return parents[0];\r\n  }\r\n}\r\n\r\nexport function getDirectChildLayersByProperty(\r\n  map: MapBase,\r\n  layer: Layer,\r\n  property: LinkedProperties\r\n): Layer[] {\r\n  let linkedIds = [];\r\n  if (layer?.options.linkedLayers?.links) {\r\n    layer.options.linkedLayers.links\r\n      .filter((l) => l.properties.includes(property))\r\n      .map((link) => {\r\n        linkedIds = linkedIds.concat(link.linkedIds);\r\n      });\r\n  }\r\n  return linkedIds.map((lid) => getIgoLayerByLinkId(map, lid));\r\n}\r\n\r\nexport function getAllChildLayersByProperty(\r\n  map: MapBase,\r\n  layer: Layer,\r\n  knownChildLayers: Layer[],\r\n  property: LinkedProperties\r\n): Layer[] {\r\n  let childLayers = getDirectChildLayersByProperty(map, layer, property);\r\n  childLayers.map((cl) => {\r\n    knownChildLayers.push(cl);\r\n    const directChildLayers = getDirectChildLayersByProperty(map, cl, property);\r\n    if (directChildLayers) {\r\n      getAllChildLayersByProperty(map, cl, knownChildLayers, property);\r\n    }\r\n  });\r\n  return knownChildLayers;\r\n}\r\n\r\nexport function getRootParentByDeletion(map: MapBase, layer: Layer): Layer {\r\n  let layerToUse = layer;\r\n  let parentLayer = layerToUse;\r\n  let hasParentLayer = true;\r\n  while (hasParentLayer) {\r\n    layerToUse = parentLayer;\r\n    parentLayer = getDirectParentLayerByDeletion(map, layerToUse);\r\n    hasParentLayer = parentLayer ? true : false;\r\n  }\r\n  if (!hasParentLayer) {\r\n    if (!layerHasLinkDeletion(layerToUse)) {\r\n      layerToUse = undefined;\r\n    }\r\n  }\r\n  return hasParentLayer ? parentLayer : layerToUse;\r\n}\r\n\r\nexport function getDirectParentLayerByDeletion(\r\n  map: MapBase,\r\n  layer: Layer\r\n): Layer {\r\n  if (layer.options.linkedLayers?.linkId) {\r\n    const currentLinkId = layer.options.linkedLayers.linkId;\r\n    let parents = map.layers.filter((pl) => {\r\n      const linkedLayers = pl.options.linkedLayers;\r\n      if (linkedLayers && linkedLayers.links) {\r\n        const a = linkedLayers.links.find(\r\n          (l) => l.linkedIds.includes(currentLinkId) && l.syncedDelete\r\n        );\r\n        return a;\r\n      }\r\n    });\r\n    if (parents.length > 1) {\r\n      console.warn(`Your layer ${\r\n        layer.title || layer.id\r\n      } must only have 1 parent (${parents.map((p) => p.title || p.id)})\r\n          , The first parent (${\r\n            parents[0].title || parents[0].id\r\n          }) will be use to sync properties`);\r\n    }\r\n    return parents[0];\r\n  }\r\n}\r\n\r\nexport function getDirectChildLayersByDeletion(\r\n  map: MapBase,\r\n  layer: Layer\r\n): Layer[] {\r\n  let linkedIds = [];\r\n  if (layer?.options.linkedLayers?.links) {\r\n    layer.options.linkedLayers.links\r\n      .filter((l) => l.syncedDelete)\r\n      .map((link) => {\r\n        linkedIds = linkedIds.concat(link.linkedIds);\r\n      });\r\n  }\r\n  return linkedIds.map((lid) => getIgoLayerByLinkId(map, lid));\r\n}\r\n\r\nexport function getAllChildLayersByDeletion(\r\n  map: MapBase,\r\n  layer: Layer,\r\n  knownChildLayers: Layer[]\r\n): Layer[] {\r\n  let childLayers = getDirectChildLayersByDeletion(map, layer);\r\n  childLayers.map((cl) => {\r\n    knownChildLayers.push(cl);\r\n    const directChildLayers = getDirectChildLayersByDeletion(map, cl);\r\n    if (directChildLayers) {\r\n      getAllChildLayersByDeletion(map, cl, knownChildLayers);\r\n    }\r\n  });\r\n  return knownChildLayers;\r\n}\r\n\r\nexport function initLayerSyncFromRootParentLayers(\r\n  map: MapBase,\r\n  layers: Layer[]\r\n) {\r\n  const rootLayersByProperty = {};\r\n  const keys = Object.keys(LinkedProperties);\r\n  keys.map((k) => {\r\n    rootLayersByProperty[LinkedProperties[k]] = [];\r\n  });\r\n  layers\r\n    .filter((l) => getLinkedLayersOptions(l))\r\n    .map((l) => {\r\n      keys.map((key) => {\r\n        const k = LinkedProperties[key];\r\n        const plbp = getRootParentByProperty(map, l, k as LinkedProperties);\r\n        const layers = rootLayersByProperty[k];\r\n        const layersId = layers.map((l) => l.id);\r\n        if (plbp && !layersId.includes(plbp.id)) {\r\n          rootLayersByProperty[k].push(plbp);\r\n        }\r\n      });\r\n    });\r\n  Object.keys(rootLayersByProperty).map((k) => {\r\n    const layers = rootLayersByProperty[k];\r\n    layers.map((l: Layer) => l.ol.notify(k, undefined));\r\n  });\r\n}\r\n\r\nexport function handleLayerPropertyChange(\r\n  map: MapBase,\r\n  propertyChange: ObjectEvent,\r\n  initiatorIgoLayer: Layer\r\n) {\r\n  if (!propertyChange) {\r\n    return;\r\n  }\r\n  const ogcFilterWriter = new OgcFilterWriter();\r\n  let isLayerProperty = true;\r\n  let isDatasourceProperty = true;\r\n  const key = propertyChange.key;\r\n  let newValue;\r\n  if (key === 'ogcFilters') {\r\n    isLayerProperty = false;\r\n    isDatasourceProperty = true;\r\n    newValue = (\r\n      initiatorIgoLayer.dataSource.options as OgcFilterableDataSourceOptions\r\n    ).ogcFilters;\r\n  } else if (key === 'timeFilter') {\r\n    isLayerProperty = false;\r\n    isDatasourceProperty = true;\r\n    newValue = (\r\n      initiatorIgoLayer.dataSource.options as TimeFilterableDataSourceOptions\r\n    ).timeFilter;\r\n  } else {\r\n    isLayerProperty = true;\r\n    isDatasourceProperty = false;\r\n    newValue = initiatorIgoLayer.ol.get(key);\r\n  }\r\n\r\n  const initiatorLinkedLayersOptions =\r\n    getLinkedLayersOptions(initiatorIgoLayer);\r\n  if (initiatorLinkedLayersOptions) {\r\n    let rootParentByProperty = getRootParentByProperty(\r\n      map,\r\n      initiatorIgoLayer,\r\n      key as LinkedProperties\r\n    );\r\n    if (!rootParentByProperty) {\r\n      rootParentByProperty = initiatorIgoLayer;\r\n    }\r\n\r\n    const clbp = [rootParentByProperty];\r\n    getAllChildLayersByProperty(\r\n      map,\r\n      rootParentByProperty,\r\n      clbp,\r\n      key as LinkedProperties\r\n    );\r\n\r\n    let resolutionPropertyHasChanged = false;\r\n    const initiatorIgoLayerSourceType =\r\n      initiatorIgoLayer.options.source.options.type;\r\n    const initiatorIgoLayerOgcFilterableDataSourceOptions = initiatorIgoLayer\r\n      .dataSource.options as OgcFilterableDataSourceOptions;\r\n    clbp.map((l) => {\r\n      if (\r\n        initiatorIgoLayer &&\r\n        l &&\r\n        getUid(initiatorIgoLayer.ol) !== getUid(l?.ol)\r\n      ) {\r\n        const lLayerType = l.options.source.options.type;\r\n        if (isLayerProperty) {\r\n          l.ol.set(key, newValue, true);\r\n          if (key === 'visible') {\r\n            l.visible$.next(newValue);\r\n          }\r\n          if (key === 'minResolution' || key === 'maxResolution') {\r\n            resolutionPropertyHasChanged = true;\r\n          }\r\n        } else if (isDatasourceProperty) {\r\n          if (key === 'ogcFilters') {\r\n            (l.dataSource as OgcFilterableDataSource).setOgcFilters(\r\n              newValue,\r\n              false\r\n            );\r\n            if (lLayerType === 'wfs') {\r\n              l.ol.getSource().refresh();\r\n            }\r\n            if (lLayerType === 'wms') {\r\n              let appliedOgcFilter;\r\n              if (initiatorIgoLayerSourceType === 'wfs') {\r\n                appliedOgcFilter = ogcFilterWriter.handleOgcFiltersAppliedValue(\r\n                  initiatorIgoLayerOgcFilterableDataSourceOptions,\r\n                  (initiatorIgoLayer.dataSource.options as any)\r\n                    .fieldNameGeometry,\r\n                  undefined,\r\n                  map.viewController.getOlProjection()\r\n                );\r\n              } else if (initiatorIgoLayerSourceType === 'wms') {\r\n                appliedOgcFilter = (\r\n                  initiatorIgoLayer.dataSource as WMSDataSource\r\n                ).ol.getParams().FILTER;\r\n              }\r\n              (l.dataSource as WMSDataSource).ol.updateParams({\r\n                FILTER: appliedOgcFilter\r\n              });\r\n            }\r\n          } else if (\r\n            l.dataSource instanceof WMSDataSource &&\r\n            key === 'timeFilter'\r\n          ) {\r\n            (l.dataSource as TimeFilterableDataSource).setTimeFilter(\r\n              newValue,\r\n              false\r\n            );\r\n            const appliedTimeFilter = (\r\n              initiatorIgoLayer.ol.getSource() as olSourceImageWMS\r\n            ).getParams().TIME;\r\n            l.dataSource.ol.updateParams({ TIME: appliedTimeFilter });\r\n          }\r\n        }\r\n      }\r\n    });\r\n    if (resolutionPropertyHasChanged) {\r\n      map.viewController.resolution$.next(map.viewController.resolution$.value);\r\n    }\r\n  }\r\n}\r\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,{"version":3,"file":"map-pointer-position.directive.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/map/shared/map-pointer-position.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Directive,\r\n  Input,\r\n  Output,\r\n  EventEmitter,\r\n  OnDestroy,\r\n  Self,\r\n  OnInit\r\n} from '@angular/core';\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\n\r\nimport { transform } from 'ol/proj';\r\nimport { MediaService } from '@igo2/core';\r\nimport { unByKey } from 'ol/Observable';\r\n/**\r\n * This directive return the pointer coordinate (on click or pointermove)\r\n * in [longitude, latitude], delayed by in input (pointerMoveDelay)\r\n * to avoid too many emitted values.\r\n */\r\n@Directive({\r\n  selector: '[igoPointerPosition]'\r\n})\r\nexport class PointerPositionDirective implements OnInit, OnDestroy {\r\n  private lastTimeoutRequest;\r\n\r\n  /**\r\n   * Listener to the pointer move event\r\n   */\r\n  private pointerMoveListener;\r\n\r\n  /**\r\n   * Listener to the map click event\r\n   */\r\n  private mapClickListener;\r\n\r\n  /**\r\n   * Delay before emitting an event\r\n   */\r\n  @Input() pointerPositionDelay: number = 1000;\r\n\r\n  /**\r\n   * Event emitted when the pointer move, delayed by pointerMoveDelay\r\n   */\r\n  @Output() pointerPositionCoord = new EventEmitter<[number, number]>();\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 mediaService: MediaService\r\n  ) {}\r\n\r\n  /**\r\n   * Start listening to pointermove\r\n   * @internal\r\n   */\r\n  ngOnInit(): void {\r\n    this.listenToMapPointerMove();\r\n    this.listenToMapClick();\r\n  }\r\n\r\n  /**\r\n   * Stop listening to pointermove\r\n   * @internal\r\n   */\r\n  ngOnDestroy() {\r\n    this.unlistenToMapPointerMove();\r\n    this.unlistenToMapClick();\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>) =>\r\n        this.onPointerEvent(event, this.pointerPositionDelay)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * On map click\r\n   */\r\n  private listenToMapClick() {\r\n    this.mapClickListener = this.map.ol.on(\r\n      'singleclick',\r\n      (event: MapBrowserPointerEvent<any>) => this.onPointerEvent(event, 0)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Stop listening for map pointermove\r\n   */\r\n  private unlistenToMapPointerMove() {\r\n    unByKey(this.pointerMoveListener);\r\n    this.pointerMoveListener = undefined;\r\n  }\r\n\r\n  /**\r\n   * Stop listening for map clicks\r\n   */\r\n  private unlistenToMapClick() {\r\n    this.mapClickListener = undefined;\r\n  }\r\n\r\n  /**\r\n   * emit delayed coordinate (longitude, latitude array) based on pointerMoveDelay or on click\r\n   * @param event OL map browser pointer event\r\n   */\r\n  private onPointerEvent(event: MapBrowserPointerEvent<any>, delay: number) {\r\n    if (event.dragging || this.mediaService.isTouchScreen()) {\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    }\r\n\r\n    const lonlat = transform(\r\n      event.coordinate,\r\n      this.mapProjection,\r\n      'EPSG:4326'\r\n    ) as [number, number];\r\n    this.lastTimeoutRequest = setTimeout(() => {\r\n      this.pointerPositionCoord.emit(lonlat);\r\n    }, delay);\r\n  }\r\n}\r\n"]}

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,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