@vcmap/core 6.0.7 → 6.1.0-rc.2

package/src/vectorCluster/vectorClusterGroupImpl.ts

@@ -0,0 +1,107 @@
+import { StyleFunction } from 'ol/style/Style.js';
+import type { VectorClusterGroupImplementationOptions } from './vectorClusterGroup.js';
+import VcsObject from '../vcsObject.js';
+import LayerState from '../layer/layerState.js';
+import VectorProperties from '../layer/vectorProperties.js';
+import ClusterEnhancedVectorSource from '../ol/source/ClusterEnhancedVectorSource.js';
+import { synchronizeFeatureVisibilityWithSource } from '../layer/vectorHelpers.js';
+import type GlobalHider from '../layer/globalHider.js';
+import FeatureVisibility from '../layer/featureVisibility.js';
+import VcsMap from '../map/vcsMap.js';
+
+/**
+ * Clusters for vector layers containing point features only
+ */
+export default class VectorClusterGroupImpl<
+  M extends VcsMap,
+> extends VcsObject {
+  static get className(): string {
+    return 'VectorClusterCesiumImpl';
+  }
+
+  private _map: M | undefined;
+
+  private _state = LayerState.INACTIVE;
+
+  private _initialized = false;
+
+  style: StyleFunction;
+
+  protected _source: ClusterEnhancedVectorSource;
+
+  private _featureVisibilityListeners = [] as (() => void)[];
+
+  protected _featureVisibility: FeatureVisibility;
+
+  protected _globalHider: GlobalHider | undefined;
+
+  vectorProperties: VectorProperties;
+
+  constructor(map: M, options: VectorClusterGroupImplementationOptions) {
+    super(options);
+    this._map = map;
+
+    this.style = options.style;
+    this._source = options.source;
+    this.vectorProperties = options.vectorProperties;
+    this._featureVisibility = options.featureVisibility;
+    this._globalHider = options.globalHider;
+  }
+
+  get map(): M {
+    if (!this._map) {
+      throw new Error('Trying to access uninitialized VectorClusterGroupImpl');
+    }
+    return this._map;
+  }
+
+  get active(): boolean {
+    return this._state === LayerState.ACTIVE;
+  }
+
+  get initialized(): boolean {
+    return this._initialized;
+  }
+
+  initialize(): Promise<void> {
+    this._initialized = true;
+    return Promise.resolve();
+  }
+
+  async activate(): Promise<void> {
+    if (this.map.active && !this.active) {
+      this._state = LayerState.LOADING;
+      await this.initialize();
+      if (this._state === LayerState.LOADING) {
+        this._state = LayerState.ACTIVE;
+        if (this._featureVisibilityListeners.length === 0) {
+          this._featureVisibilityListeners =
+            synchronizeFeatureVisibilityWithSource(
+              this._featureVisibility,
+              this._source,
+              this._globalHider!,
+            );
+        }
+      }
+    }
+  }
+
+  deactivate(): void {
+    this._state = LayerState.INACTIVE;
+    this._featureVisibilityListeners.forEach((cb) => {
+      cb();
+    });
+    this._featureVisibilityListeners = [];
+  }
+
+  destroy(): void {
+    this._featureVisibilityListeners.forEach((cb) => {
+      cb();
+    });
+    this._featureVisibilityListeners = [];
+    this._initialized = false;
+    this._state = LayerState.INACTIVE;
+    this._map = undefined;
+    super.destroy();
+  }
+}

package/src/vectorCluster/vectorClusterGroupObliqueImpl.ts

@@ -0,0 +1,84 @@
+import OLVectorLayer from 'ol/layer/Vector.js';
+import VectorClusterGroupImpl from './vectorClusterGroupImpl.js';
+import ObliqueMap from '../map/obliqueMap.js';
+import VcsCluster from '../ol/source/VcsCluster.js';
+import { VectorClusterGroupImplementationOptions } from './vectorClusterGroup.js';
+import {
+  createSourceObliqueSync,
+  SourceObliqueSync,
+} from '../layer/oblique/sourceObliqueSync.js';
+import { vectorClusterGroupName } from './vectorClusterSymbols.js';
+
+export default class VectorClusterGroupObliqueImpl extends VectorClusterGroupImpl<ObliqueMap> {
+  private _clusterSource: VcsCluster;
+
+  private _olLayer: OLVectorLayer | undefined;
+
+  private _sourceObliqueSync: SourceObliqueSync;
+
+  constructor(
+    map: ObliqueMap,
+    options: VectorClusterGroupImplementationOptions,
+  ) {
+    super(map, options);
+
+    this._sourceObliqueSync = createSourceObliqueSync(options.source, map);
+    this._clusterSource = new VcsCluster(
+      {
+        source: this._sourceObliqueSync.obliqueSource,
+        distance: options.clusterDistance,
+      },
+      this.name,
+    );
+  }
+
+  get clusterSource(): VcsCluster {
+    return this._clusterSource;
+  }
+
+  get olLayer(): OLVectorLayer | undefined {
+    return this._olLayer;
+  }
+
+  async initialize(): Promise<void> {
+    if (!this.initialized) {
+      const olLayer = new OLVectorLayer({
+        visible: false,
+        source: this._clusterSource,
+        style: this.style,
+        zIndex: Number.MAX_SAFE_INTEGER,
+      });
+      olLayer[vectorClusterGroupName] = this.name;
+      this._olLayer = olLayer;
+      this.map.addOLLayer(this._olLayer);
+    }
+    await super.initialize();
+  }
+
+  async activate(): Promise<void> {
+    await super.activate();
+    if (this.active) {
+      this._olLayer?.setVisible(true);
+      this._clusterSource.paused = false;
+      this._clusterSource.refresh();
+      this._sourceObliqueSync.activate();
+    }
+  }
+
+  deactivate(): void {
+    super.deactivate();
+    this._olLayer?.setVisible(false);
+    this._clusterSource.paused = true;
+    this._sourceObliqueSync.deactivate();
+  }
+
+  destroy(): void {
+    if (this._olLayer) {
+      this.map.removeOLLayer(this._olLayer);
+    }
+    this._olLayer = undefined;
+
+    this._sourceObliqueSync.destroy();
+    super.destroy();
+  }
+}

package/src/vectorCluster/vectorClusterGroupOpenlayersImpl.ts

@@ -0,0 +1,81 @@
+import OLVectorLayer from 'ol/layer/Vector.js';
+import { VectorClusterGroupImplementationOptions } from './vectorClusterGroup.js';
+import OpenlayersMap from '../map/openlayersMap.js';
+import VcsCluster from '../ol/source/VcsCluster.js';
+import VectorClusterGroupImpl from './vectorClusterGroupImpl.js';
+import { vectorClusterGroupName } from './vectorClusterSymbols.js';
+
+export default class VectorClusterGroupOpenlayersImpl extends VectorClusterGroupImpl<OpenlayersMap> {
+  static get className(): string {
+    return 'VectorClusterGroupOpenlayersImpl';
+  }
+
+  private _clusterSource: VcsCluster;
+
+  private _olLayer: OLVectorLayer | undefined;
+
+  constructor(
+    map: OpenlayersMap,
+    options: VectorClusterGroupImplementationOptions,
+  ) {
+    super(map, options);
+    this._clusterSource = new VcsCluster(
+      {
+        source: options.source,
+        distance: options.clusterDistance,
+      },
+      this.name,
+    );
+    this._clusterSource.paused = true;
+  }
+
+  async initialize(): Promise<void> {
+    if (!this.initialized) {
+      const olLayer = new OLVectorLayer({
+        visible: false,
+        source: this._clusterSource,
+        style: this.style,
+        zIndex: Number.MAX_SAFE_INTEGER,
+      });
+
+      olLayer[vectorClusterGroupName] = this.name;
+      this._olLayer = olLayer;
+      this.map.addOLLayer(this._olLayer);
+    }
+    await super.initialize();
+  }
+
+  get clusterSource(): VcsCluster {
+    return this._clusterSource;
+  }
+
+  get olLayer(): OLVectorLayer | undefined {
+    return this._olLayer;
+  }
+
+  async activate(): Promise<void> {
+    await super.activate();
+    if (this.active) {
+      this._olLayer?.setVisible(true);
+      this._clusterSource.paused = false;
+      this._clusterSource.refresh();
+    }
+  }
+
+  deactivate(): void {
+    super.deactivate();
+    this._olLayer?.setVisible(false);
+    this._clusterSource.paused = true;
+  }
+
+  destroy(): void {
+    if (this._olLayer) {
+      this.map.removeOLLayer(this._olLayer);
+    }
+    this._olLayer = undefined;
+
+    this._clusterSource.clear(true);
+    this._clusterSource.dispose();
+    super.destroy();
+  }
+}