@vcmap/core 6.0.7 → 6.1.0-rc.1

package/src/map/vcsMap.ts

@@ -18,6 +18,8 @@ import type Viewpoint from '../util/viewpoint.js';
 import type Layer from '../layer/layer.js';
 import type { MapEvent } from '../interaction/abstractInteraction.js';
 import type { DisableMapControlOptions } from '../util/mapCollection.js';
+import type VectorClusterGroup from '../vectorCluster/vectorClusterGroup.js';
+import { vectorClusterGroupName } from '../vectorCluster/vectorClusterSymbols.js';
 
 function getLogger(): Logger {
   return getLoggerByName('vcMap');
@@ -106,7 +108,9 @@ class VcsMap<
    */
   fallbackToCurrentMap: boolean;
 
-  private _visualizations: Map<string, Set<V>>;
+  private _visualizations = new Map<string, Set<V>>();
+
+  private _clusterVisualizations = new Map<string, Set<V>>();
 
   private _state: MapState;
 
@@ -125,7 +129,7 @@ class VcsMap<
    */
   private _splitPosition: number;
 
-  private _postRender: VcsEvent<VcsMapRenderEvent<V>>;
+  private _postRender = new VcsEvent<VcsMapRenderEvent<V>>();
 
   /**
    * @param  options
@@ -162,8 +166,6 @@ class VcsMap<
       defaultOptions.fallbackToCurrentMap,
     );
 
-    this._visualizations = new Map();
-
     this._state = MapState.INACTIVE;
 
     this.stateChanged = new VcsEvent();
@@ -171,8 +173,6 @@ class VcsMap<
     this.pointerInteractionEvent = new VcsEvent();
 
     this._splitPosition = 0.5;
-
-    this._postRender = new VcsEvent();
   }
 
   /**
@@ -253,12 +253,24 @@ class VcsMap<
     [...this._layerCollection].forEach((l) => {
       l.removedFromMap(this);
     });
+    [...this._layerCollection.vectorClusterGroups].forEach((g) => {
+      g.removedFromMap(this);
+    });
+
     this._layerCollection = layerCollection;
 
     if (this.active) {
       [...this._layerCollection].forEach((l) => {
-        // eslint-disable-next-line no-void
-        void l.mapActivated(this);
+        l.mapActivated(this).catch((_e) => {
+          this.getLogger().error(`Failed to activate map on layer: ${l.name}`);
+        });
+      });
+      [...this._layerCollection.vectorClusterGroups].forEach((g) => {
+        g.mapActivated(this).catch((_e) => {
+          this.getLogger().error(
+            `Failed to activate map on vector cluster group: ${g.name}`,
+          );
+        });
       });
     }
 
@@ -293,16 +305,28 @@ class VcsMap<
       cb();
     });
 
+    const added = (i: Layer | VectorClusterGroup): void => {
+      if (this.active) {
+        i.mapActivated(this).catch((_e) => {
+          this.getLogger().error(`Failed to activate map on layer: ${i.name}`);
+        });
+      }
+    };
+
+    const removed = (i: Layer | VectorClusterGroup): void => {
+      i.removedFromMap(this);
+    };
+
     this._collectionListeners = [
       this.layerCollection.moved.addEventListener((layer) => {
         this.indexChanged(layer);
       }),
-      this.layerCollection.added.addEventListener((layer) => {
-        this._layerAdded(layer);
-      }),
-      this.layerCollection.removed.addEventListener((layer) => {
-        this._layerRemoved(layer);
-      }),
+      this.layerCollection.added.addEventListener(added),
+      this.layerCollection.removed.addEventListener(removed),
+      this.layerCollection.vectorClusterGroups.added.addEventListener(added),
+      this.layerCollection.vectorClusterGroups.removed.addEventListener(
+        removed,
+      ),
     ];
   }
 
@@ -342,28 +366,20 @@ class VcsMap<
   // eslint-disable-next-line no-unused-vars,class-methods-use-this
   indexChanged(_layer: Layer): void {}
 
-  /**
-   * is called if a layer is added to the layerCollection.
-   */
-  private _layerAdded(layer: Layer): void {
-    if (this.active) {
-      // eslint-disable-next-line no-void
-      void layer.mapActivated(this);
-    }
-  }
-
-  /**
-   * is called if a layer is added to the layerCollection.
-   */
-  private _layerRemoved(layer: Layer): void {
-    layer.removedFromMap(this);
-  }
-
   /**
    * Validates a visualization. A visualization must have the vcsLayeName symbol set and a layer with said name must be
    * part of the maps layerCollection.
    */
-  validateVisualization(item: V): item is V & { [vcsLayerName]: string } {
+  validateVisualization(item: V): item is V & {
+    [vcsLayerName]?: string;
+    [vectorClusterGroupName]?: string;
+  } {
+    const vectorCluster = (item as OLLayer)[vectorClusterGroupName];
+    if (vectorCluster) {
+      return this.layerCollection.vectorClusterGroups.hasKey(
+        vectorCluster,
+      ) as boolean;
+    }
     const layerName = item[vcsLayerName];
     if (layerName == null) {
       this.getLogger().warning('item is missing vcsLayerName symbol');
@@ -376,45 +392,75 @@ class VcsMap<
   /**
    * Adds a visualization to the visualizations map for its layer. The visualization must be valid, use validateVisualization first
    */
-  addVisualization(item: V): void {
+  addVisualization(item: V & { [vectorClusterGroupName]?: string }): void {
     if (!this.validateVisualization(item)) {
       throw new Error(
         'Visualization item is not valid, validate before adding',
       );
     }
-    const layerName = item[vcsLayerName];
-    if (!this._visualizations.has(layerName)) {
-      this._visualizations.set(layerName, new Set());
+    let name: string;
+    let setMap;
+    if (item[vectorClusterGroupName]) {
+      name = item[vectorClusterGroupName];
+      setMap = this._clusterVisualizations;
+    } else {
+      name = item[vcsLayerName]!;
+      setMap = this._visualizations;
+    }
+
+    if (!setMap.has(name)) {
+      setMap.set(name, new Set());
     }
-    (this._visualizations.get(layerName) as Set<V>).add(item);
+    (setMap.get(name) as Set<V>).add(item);
   }
 
   /**
    * Removes a visualization
    */
-  removeVisualization(item: V): void {
-    const layerName = item[vcsLayerName];
-    const viz = layerName ? this._visualizations.get(layerName) : undefined;
-    if (viz && layerName) {
+  removeVisualization(item: V & { [vectorClusterGroupName]?: string }): void {
+    let name: string | undefined;
+    let setMap;
+    if (item[vectorClusterGroupName]) {
+      name = item[vectorClusterGroupName];
+      setMap = this._clusterVisualizations;
+    } else {
+      name = item[vcsLayerName];
+      setMap = this._visualizations;
+    }
+
+    const viz = name ? setMap.get(name) : undefined;
+    if (viz && name) {
       viz.delete(item);
       if (viz.size === 0) {
-        this._visualizations.delete(layerName);
+        setMap.delete(name);
       }
     }
   }
 
   /**
-   * Gets the visualizations for a specific layer.
+   * Gets the visualizations for a specific layer
    */
   getVisualizationsForLayer(layer: Layer): Set<V> | undefined {
     return this._visualizations.get(layer.name);
   }
 
+  /**
+   * Gets the visualizations of a vector cluster group
+   */
+  getVisualizationsForVectorClusterGroup(
+    group: VectorClusterGroup,
+  ): Set<V> | undefined {
+    return this._clusterVisualizations.get(group.name);
+  }
+
   /**
    * Get all visualizations added to this map.
    */
   getVisualizations(): V[] {
-    return [...this._visualizations.values()]
+    return [
+      ...this._visualizations.values(),
+      ...this._clusterVisualizations.values(),
+    ]
       .map((layerVisualizations) => [...layerVisualizations])
       .flat();
   }
@@ -433,9 +479,12 @@ class VcsMap<
         return;
       }
       this._state = MapState.ACTIVE;
-      await Promise.all(
-        [...this.layerCollection].map((layer) => layer.mapActivated(this)),
-      );
+      await Promise.all([
+        ...[...this.layerCollection].map((layer) => layer.mapActivated(this)),
+        ...[...this.layerCollection.vectorClusterGroups].map((clusterGroup) =>
+          clusterGroup.mapActivated(this),
+        ),
+      ]);
       if (this._state !== MapState.ACTIVE) {
         return;
       }
@@ -453,6 +502,9 @@ class VcsMap<
       [...this.layerCollection].forEach((layer) => {
         layer.mapDeactivated(this);
       });
+      [...this.layerCollection.vectorClusterGroups].forEach((clusterGroup) =>
+        clusterGroup.mapDeactivated(this),
+      );
       this.stateChanged.raiseEvent(this._state);
     }
   }
@@ -559,6 +611,9 @@ class VcsMap<
       [...this.layerCollection].forEach((l) => {
         l.removedFromMap(this);
       });
+      [...this.layerCollection.vectorClusterGroups].forEach((g) => {
+        g.removedFromMap(this);
+      });
     }
     if (this.stateChanged) {
       this.stateChanged.destroy();

package/src/ol/ol.d.ts

@@ -42,6 +42,7 @@ import {
   globalHiderLastUpdated,
 } from '../layer/vectorHelpers.js';
 import { validityPlaceholder } from '../util/editor/interactions/createPolygonInteraction.js';
+import { vectorClusterGroupName } from '../vectorCluster/vectorClusterSymbols.js';
 
 declare module 'ol/geom.js' {
   interface Geometry {
@@ -113,6 +114,7 @@ declare module 'ol/index.js' {
     [handlerSymbol]?: AxisAndPlanes;
     [vertexSymbol]?: boolean;
     [createSync]?: boolean;
+    [vectorClusterGroupName]?: string;
   }
 
   class CanvasTileRenderer extends CanvasImmediateRenderer {
@@ -141,6 +143,7 @@ declare module 'ol/style.js' {
 declare module 'ol/layer.js' {
   interface Layer {
     [vcsLayerName]: string;
+    [vectorClusterGroupName]?: string;
   }
 }
 

package/src/ol/source/{ClusterEnhancedVectorSource.js → ClusterEnhancedVectorSource.ts}

@@ -1,5 +1,5 @@
-import { getUid } from 'ol/util.js';
 import VectorSource from 'ol/source/Vector.js';
+import Feature from 'ol/Feature.js';
 
 /**
  * @class
@@ -11,15 +11,12 @@ class ClusterEnhancedVectorSource extends VectorSource {
    * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
    * @param {boolean=} silent
    */
-  removeFeature(feature, silent) {
-    const featureKey = getUid(feature);
-    if (featureKey in this.nullGeometryFeatures_) {
-      delete this.nullGeometryFeatures_[featureKey];
-    } else if (this.featuresRtree_) {
-      this.featuresRtree_.remove(feature);
+  removeFeature(feature: Feature, silent?: boolean): void {
+    if (!feature) {
+      return;
     }
-    this.removeFeatureInternal(feature);
-    if (!silent) {
+    const removed = this.removeFeatureInternal(feature);
+    if (removed && !silent) {
       this.changed();
     }
   }
@@ -28,7 +25,7 @@ class ClusterEnhancedVectorSource extends VectorSource {
    * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
    * @param {boolean=} silent
    */
-  addFeature(feature, silent) {
+  addFeature(feature: Feature, silent?: boolean): void {
     this.addFeatureInternal(feature);
     if (!silent) {
       this.changed();

package/src/ol/source/VcsCluster.ts

@@ -0,0 +1,58 @@
+import Cluster, { type Options } from 'ol/source/Cluster.js';
+import Feature from 'ol/Feature.js';
+import { Point } from 'ol/geom.js';
+import { vectorClusterGroupName } from '../../vectorCluster/vectorClusterSymbols.js';
+import { hidden } from '../../layer/featureVisibility.js';
+
+/**
+ * @class
+ * @extends {import("ol/source/Cluster").default}
+ * @memberOf ol
+ */
+class VcsCluster extends Cluster<Feature> {
+  private _paused = false;
+
+  constructor(
+    props: Options<Feature>,
+    private _name: string,
+  ) {
+    props.geometryFunction =
+      props.geometryFunction ??
+      ((feature: Feature): Point | null => {
+        if (feature[hidden]) {
+          return null;
+        }
+        return feature.getGeometry() as Point;
+      });
+
+    super(props);
+    /**
+     * @type {boolean}
+     */
+    this._paused = false;
+  }
+
+  addFeatures(features: Feature[]): void {
+    features.forEach((f) => {
+      f[vectorClusterGroupName] = this._name;
+    });
+    super.addFeatures(features);
+  }
+
+  get paused(): boolean {
+    return this._paused;
+  }
+
+  set paused(pause: boolean) {
+    this._paused = pause;
+  }
+
+  refresh(): void {
+    if (this._paused) {
+      return;
+    }
+    super.refresh();
+  }
+}
+
+export default VcsCluster;

package/src/util/layerCollection.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { parseBoolean } from '@vcsuite/parsers';
 import { check } from '@vcsuite/check';
 import IndexedCollection from './indexedCollection.js';
 import ExclusiveManager from './exclusiveManager.js';
@@ -7,6 +7,9 @@ import VcsEvent from '../vcsEvent.js';
 import GlobalHider from '../layer/globalHider.js';
 // eslint-disable-next-line import/no-named-default
 import type { default as Layer, SplitLayer } from '../layer/layer.js';
+import VectorClusterGroupCollection from '../vectorCluster/vectorClusterGroupCollection.js';
+import type VectorLayer from '../layer/vectorLayer.js';
+import { destroyCollection } from '../vcsModuleHelpers.js';
 
 /**
  * The largest integer zindex which can be safely assigned to a layer (equal to Number.MAX_SAFE_INTEGER)
@@ -14,6 +17,11 @@ import type { default as Layer, SplitLayer } from '../layer/layer.js';
  */
 export const maxZIndex = Number.MAX_SAFE_INTEGER;
 
+export type LayerCollectionOptions = {
+  vectorClusterGroupCollection?: VectorClusterGroupCollection;
+  destroyVectorClusterGroupCollection?: boolean;
+};
+
 /**
  * A collection of layers. Manages rendering order and layer exclusivity. Emits state changes for convenience. Passed to
  * {@link Map} for layers available to said map. Layers must have unique names.
@@ -57,6 +65,8 @@ class LayerCollection extends IndexedCollection<Layer> {
    */
   private _globalHider: GlobalHider;
 
+  private _vectorClusterGroups: VectorClusterGroupCollection;
+
   /**
    * Locale for this layerCollection, will be synchronized by the vcsApp, if part of an vcsApp.
    * This Locale will be set on all Member Layers. On setting the Locale this will trigger a reload of all locale
@@ -64,7 +74,11 @@ class LayerCollection extends IndexedCollection<Layer> {
    */
   private _locale: string;
 
-  constructor() {
+  private _vectorClusterGroupListeners: (() => void) | undefined;
+
+  destroyVectorClusterGroupCollection: boolean;
+
+  constructor(options: LayerCollectionOptions = {}) {
     super();
 
     this._layerEventListeners = {};
@@ -73,6 +87,18 @@ class LayerCollection extends IndexedCollection<Layer> {
     this.exclusiveManager = new ExclusiveManager();
     this._globalHider = new GlobalHider();
     this._locale = 'en';
+    if (options.vectorClusterGroupCollection) {
+      this._vectorClusterGroups = options.vectorClusterGroupCollection;
+    } else {
+      this._vectorClusterGroups = new VectorClusterGroupCollection(
+        this._globalHider,
+      );
+    }
+    this.destroyVectorClusterGroupCollection = parseBoolean(
+      options.destroyVectorClusterGroupCollection,
+      !options.vectorClusterGroupCollection,
+    );
+    this._setupVectorClusterGroupListeners();
   }
 
   /**
@@ -102,6 +128,7 @@ class LayerCollection extends IndexedCollection<Layer> {
     this._array.forEach((layer) => {
       layer.setGlobalHider(this._globalHider);
     });
+    this.vectorClusterGroups.globalHider = this._globalHider;
   }
 
   get locale(): string {
@@ -119,6 +146,10 @@ class LayerCollection extends IndexedCollection<Layer> {
     }
   }
 
+  get vectorClusterGroups(): VectorClusterGroupCollection {
+    return this._vectorClusterGroups;
+  }
+
   private _listenToLayerEvents(layer: Layer): void {
     const stateListener = layer.stateChanged.addEventListener(
       (state: LayerState) => {
@@ -148,6 +179,25 @@ class LayerCollection extends IndexedCollection<Layer> {
         ),
       );
     }
+
+    if ((layer as VectorLayer).vectorClusterGroupChanged) {
+      listeners.push(
+        (layer as VectorLayer).vectorClusterGroupChanged.addEventListener(
+          ({ newGroup, oldGroup }) => {
+            if (oldGroup) {
+              this._vectorClusterGroups
+                .getByKey(oldGroup)
+                ?.removeLayer(layer as VectorLayer);
+            }
+            if (newGroup) {
+              this._vectorClusterGroups
+                .getByKey(newGroup)
+                ?.addLayer(layer as VectorLayer);
+            }
+          },
+        ),
+      );
+    }
     this._layerEventListeners[layer.name] = listeners;
   }
 
@@ -158,7 +208,7 @@ class LayerCollection extends IndexedCollection<Layer> {
    */
   private _findZIndexPosition(zIndex: number): number | null {
     const usedIndex = this._array.findIndex(
-      // @ts-ignore
+      // @ts-expect-error: z index is undefined
       (l) => l[this._zIndexSymbol] > zIndex,
     );
     return usedIndex > -1 ? usedIndex : null;
@@ -173,7 +223,7 @@ class LayerCollection extends IndexedCollection<Layer> {
   private _zIndexChanged(layer: Layer): void {
     const currentIndex = this.indexOf(layer);
     if (currentIndex > -1) {
-      // @ts-ignore
+      // @ts-expect-error: z index is undefined
       layer[this._zIndexSymbol] = layer.zIndex;
       let zIndexPosition = this._findZIndexPosition(layer.zIndex);
       if (
@@ -197,29 +247,43 @@ class LayerCollection extends IndexedCollection<Layer> {
    */
   private _ensureLocalZIndex(layer: Layer): void {
     const currentIndex = this.indexOf(layer);
-    // @ts-ignore
+    // @ts-expect-error: z index is undefined
     const currentLayerZIndex = layer[this._zIndexSymbol] as number;
     if (currentIndex > 0) {
-      // @ts-ignore
+      // @ts-expect-error: z index is undefined
       const below: number = this._array[currentIndex - 1][
         this._zIndexSymbol
       ] as number;
       if (below > currentLayerZIndex) {
-        // @ts-ignore
+        // @ts-expect-error: z index is undefined
         layer[this._zIndexSymbol] = below;
       }
     }
 
     if (currentIndex < this._array.length - 1) {
-      // @ts-ignore
+      // @ts-expect-error: z index is undefined
       const above = this._array[currentIndex + 1][this._zIndexSymbol] as number;
       if (above < currentLayerZIndex) {
-        // @ts-ignore
+        // @ts-expect-error: z index is undefined
         layer[this._zIndexSymbol] = above;
       }
     }
   }
 
+  private _setupVectorClusterGroupListeners(): void {
+    this._vectorClusterGroupListeners =
+      this._vectorClusterGroups.added.addEventListener((collection) => {
+        this._array
+          .filter(
+            (layer) =>
+              (layer as VectorLayer).vectorClusterGroup === collection.name,
+          )
+          .forEach((layer) => {
+            collection.addLayer(layer as VectorLayer);
+          });
+      });
+  }
+
   /**
    * Adds a layer to the collection. Can optionally be passed an index at which to insert the layer.
    * The layer locale will be set to the same locale of the layerCollection. This will trigger a forceRedraw
@@ -235,13 +299,18 @@ class LayerCollection extends IndexedCollection<Layer> {
     }
     const insertedAt = super.add(layer, usedIndex);
     if (insertedAt != null) {
-      // @ts-ignore
+      // @ts-expect-error: z index is undefined
       layer[this._zIndexSymbol] = layer.zIndex;
       layer.setGlobalHider(this._globalHider);
       layer.locale = this.locale;
       this._ensureLocalZIndex(layer);
       this._listenToLayerEvents(layer);
       this.exclusiveManager.registerLayer(layer);
+      if ((layer as VectorLayer).vectorClusterGroup) {
+        this._vectorClusterGroups
+          .getByKey((layer as VectorLayer).vectorClusterGroup)
+          ?.addLayer(layer as VectorLayer);
+      }
     }
     return insertedAt;
   }
@@ -253,10 +322,15 @@ class LayerCollection extends IndexedCollection<Layer> {
       });
       delete this._layerEventListeners[layer.name];
     }
-    // @ts-ignore
+    // @ts-expect-error: z index is undefined
     delete layer[this._zIndexSymbol];
     layer.setGlobalHider();
     this.exclusiveManager.unregisterLayer(layer);
+    if ((layer as VectorLayer).vectorClusterGroup) {
+      this._vectorClusterGroups
+        .getByKey((layer as VectorLayer).vectorClusterGroup)
+        ?.removeLayer(layer as VectorLayer);
+    }
     return super._remove(layer);
   }
 
@@ -267,7 +341,7 @@ class LayerCollection extends IndexedCollection<Layer> {
         r();
       });
     this._array.forEach((l) => {
-      // @ts-ignore
+      // @ts-expect-error: z index is undefined
       delete l[this._zIndexSymbol];
     });
 
@@ -286,6 +360,10 @@ class LayerCollection extends IndexedCollection<Layer> {
     this._layerEventListeners = {};
     this.exclusiveManager.destroy();
     this._globalHider.destroy();
+    this._vectorClusterGroupListeners?.();
+    if (this.destroyVectorClusterGroupCollection) {
+      destroyCollection(this._vectorClusterGroups);
+    }
     super.destroy();
   }
 }