@vcmap/core 6.3.0-rc.3 → 6.3.1

package/src/layer/mapboxStyleLayer.ts

@@ -0,0 +1,244 @@
+import { SplitDirection } from '@vcmap-cesium/engine';
+import { parseInteger } from '@vcsuite/parsers';
+import { is } from '@vcsuite/check';
+import Collection from 'ol/Collection.js';
+import LayerGroup from 'ol/layer/Group.js';
+import type BaseLayer from 'ol/layer/Base.js';
+import { apply } from 'ol-mapbox-style';
+import { layerClassRegistry } from '../classRegistry.js';
+import AbstractAttributeProvider from '../featureProvider/abstractAttributeProvider.js';
+import CompositeFeatureProvider from '../featureProvider/compositeFeatureProvider.js';
+import MapboxFeatureProvider from '../featureProvider/mapboxFeatureProvider.js';
+import type VcsMap from '../map/vcsMap.js';
+import BaseCesiumMap from '../map/baseCesiumMap.js';
+import CesiumMap from '../map/cesiumMap.js';
+import ObliqueMap from '../map/obliqueMap.js';
+import OpenlayersMap from '../map/openlayersMap.js';
+import PanoramaMap from '../map/panoramaMap.js';
+import VcsEvent from '../vcsEvent.js';
+import MapboxVectorRasterTileCesiumImpl, {
+  type MapboxStyleLayerImplementationOptions,
+} from './cesium/mapboxStyleCesiumImpl.js';
+import Layer from './layer.js';
+import type { LayerOptions, SplitLayer } from './layer.js';
+import type LayerImplementation from './layerImplementation.js';
+import MapboxVectorTileOpenlayersImpl from './openlayers/mapboxStyleOpenlayersImpl.js';
+import { allowPicking, vcsLayerName } from './layerSymbols.js';
+
+export type MapboxStyleOptions = LayerOptions & {
+  /** The sources from the Mapbox Style to use. If not provided, all sources from the style will be used. */
+  sources?: string[];
+  /** The Mapbox layers to exclude from picking. */
+  excludeLayerFromPicking?: string[];
+  /** either 'left' or 'right', none if omitted */
+  splitDirection?: string;
+  /** configures the visible level in the rendered map. Maps to Openlayers `minZoom` and Cesium `minimiumTerrainLevel` */
+  minRenderingLevel?: number;
+  /** configures the visible level in the rendered map. Maps to Openlayers `maxZoom` and Cesium `maximumTerrainLevel` */
+  maxRenderingLevel?: number;
+};
+
+export interface MaboxStyleImplementation extends LayerImplementation<VcsMap> {
+  updateSplitDirection(direction: SplitDirection): void;
+}
+
+/**
+ * Layer class for Mapbox Style layers.
+ * @group Layer
+ */
+class MapboxStyleLayer
+  extends Layer<MaboxStyleImplementation>
+  implements SplitLayer
+{
+  static get className(): string {
+    return 'MapboxStyleLayer';
+  }
+
+  static getDefaultOptions(): MapboxStyleOptions {
+    return {
+      ...Layer.getDefaultOptions(),
+      minRenderingLevel: undefined,
+      maxRenderingLevel: undefined,
+    };
+  }
+
+  protected _supportedMaps = [
+    CesiumMap.className,
+    ObliqueMap.className,
+    OpenlayersMap.className,
+    PanoramaMap.className,
+  ];
+  private _mapboxLayerGroup: LayerGroup;
+  private _sources?: string[];
+  private _excludeLayerFromPicking?: string[];
+  private _splitDirection: SplitDirection = SplitDirection.NONE;
+  splitDirectionChanged = new VcsEvent<SplitDirection>();
+  /**
+   * defines the visible level in the rendered map, maps to Openlayers `minZoom` and Cesium `minimiumTerrainLevel`.
+   * Changes requires calling layer.redraw() to take effect.
+   */
+  minRenderingLevel: number | undefined;
+  /**
+   * defines the visible level in the rendered map, maps to Openlayers `minZoom` and Cesium `minimiumTerrainLevel`.
+   * Changes requires calling layer.redraw() to take effect.
+   */
+  maxRenderingLevel: number | undefined;
+
+  constructor(options: MapboxStyleOptions) {
+    const defaultOptions = MapboxStyleLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
+
+    this._sources = options.sources;
+    this._excludeLayerFromPicking = options.excludeLayerFromPicking;
+    if (options.splitDirection) {
+      this._splitDirection =
+        options.splitDirection === 'left'
+          ? SplitDirection.LEFT
+          : SplitDirection.RIGHT;
+    }
+    this.minRenderingLevel = parseInteger(
+      options.minRenderingLevel,
+      defaultOptions.minRenderingLevel,
+    );
+    this.maxRenderingLevel = parseInteger(
+      options.maxRenderingLevel,
+      defaultOptions.maxRenderingLevel,
+    );
+
+    this._mapboxLayerGroup = new LayerGroup({
+      minZoom: this.minRenderingLevel,
+      maxZoom: this.maxRenderingLevel,
+    });
+  }
+
+  async initialize(): Promise<void> {
+    if (!this.initialized) {
+      await apply(this._mapboxLayerGroup, this.url);
+
+      const layers = this._mapboxLayerGroup.getLayersArray();
+      layers.forEach((layer) => {
+        layer[vcsLayerName] = this.name;
+        layer[allowPicking] = super.allowPicking;
+      });
+
+      if (this._sources && this._sources.length > 0) {
+        const filteredCollection = new Collection<BaseLayer>();
+        layers
+          .filter((layer) =>
+            this._sources!.includes(layer.get('mapbox-source') as string),
+          )
+          .forEach((layer) => {
+            filteredCollection.push(layer);
+          });
+
+        this._mapboxLayerGroup.setLayers(filteredCollection);
+      }
+    }
+
+    if (!this.featureProvider) {
+      this.featureProvider = new MapboxFeatureProvider({
+        styledMapboxLayerGroup: this._mapboxLayerGroup,
+        excludeLayerFromPicking: this._excludeLayerFromPicking,
+      });
+    } else if (is(this.featureProvider, AbstractAttributeProvider)) {
+      this.featureProvider = new CompositeFeatureProvider({
+        attributeProviders: [this.featureProvider],
+        featureProviders: [
+          new MapboxFeatureProvider({
+            styledMapboxLayerGroup: this._mapboxLayerGroup,
+            excludeLayerFromPicking: this._excludeLayerFromPicking,
+          }),
+        ],
+      });
+    }
+
+    await super.initialize();
+  }
+
+  get splitDirection(): SplitDirection {
+    return this._splitDirection;
+  }
+
+  set splitDirection(direction: SplitDirection) {
+    if (direction !== this._splitDirection) {
+      this._splitDirection = direction;
+      this.getImplementations().forEach((impl) => {
+        impl.updateSplitDirection(direction);
+      });
+      this.splitDirectionChanged.raiseEvent(this._splitDirection);
+    }
+  }
+
+  getImplementationOptions(): MapboxStyleLayerImplementationOptions {
+    return {
+      ...super.getImplementationOptions(),
+      styledMapboxLayerGroup: this._mapboxLayerGroup,
+      splitDirection: this._splitDirection,
+      minRenderingLevel: this.minRenderingLevel,
+      maxRenderingLevel: this.maxRenderingLevel,
+    };
+  }
+
+  createImplementationsForMap(map: VcsMap): MaboxStyleImplementation[] {
+    if (map instanceof BaseCesiumMap) {
+      return [
+        new MapboxVectorRasterTileCesiumImpl(
+          map,
+          this.getImplementationOptions(),
+        ),
+      ];
+    }
+
+    if (map instanceof OpenlayersMap) {
+      return [
+        new MapboxVectorTileOpenlayersImpl(
+          map,
+          this.getImplementationOptions(),
+        ),
+      ];
+    }
+    return super.createImplementationsForMap(map);
+  }
+
+  toJSON(
+    defaultOptions = MapboxStyleLayer.getDefaultOptions(),
+  ): MapboxStyleOptions {
+    const config: MapboxStyleOptions = { ...super.toJSON() };
+
+    if (this._sources && this._sources.length > 0) {
+      config.sources = this._sources.slice();
+    }
+
+    if (
+      this._excludeLayerFromPicking &&
+      this._excludeLayerFromPicking.length > 0
+    ) {
+      config.excludeLayerFromPicking = this._excludeLayerFromPicking.slice();
+    }
+
+    if (this._splitDirection !== SplitDirection.NONE) {
+      config.splitDirection =
+        this._splitDirection === SplitDirection.LEFT ? 'left' : 'right';
+    }
+
+    if (this.minRenderingLevel !== defaultOptions.minRenderingLevel) {
+      config.minRenderingLevel = this.minRenderingLevel;
+    }
+
+    if (this.maxRenderingLevel !== defaultOptions.maxRenderingLevel) {
+      config.maxRenderingLevel = this.maxRenderingLevel;
+    }
+
+    return config;
+  }
+
+  destroy(): void {
+    this.splitDirectionChanged.destroy();
+    this._mapboxLayerGroup.dispose();
+    this.featureProvider?.destroy();
+    super.destroy();
+  }
+}
+
+layerClassRegistry.registerClass(MapboxStyleLayer.className, MapboxStyleLayer);
+export default MapboxStyleLayer;

package/src/layer/openlayers/layerOpenlayersImpl.ts

@@ -1,10 +1,11 @@
 import { SplitDirection } from '@vcmap-cesium/engine';
 import { unByKey } from 'ol/Observable.js';
 import type { EventsKey } from 'ol/events.js';
-import type OLLayer from 'ol/layer/Layer.js';
+import OLLayer from 'ol/layer/Layer.js';
 import type RenderEvent from 'ol/render/Event.js';
 import { vcsLayerName } from '../layerSymbols.js';
 import LayerImplementation from '../layerImplementation.js';
+import type { OLLayerLike } from '../../map/baseOLMap.js';
 import type OpenlayersMap from '../../map/openlayersMap.js';
 import type { LayerImplementationOptions } from '../layer.js';
 
@@ -22,7 +23,7 @@ class LayerOpenlayersImpl extends LayerImplementation<OpenlayersMap> {
     return 'LayerOpenlayersImpl';
   }
 
-  olLayer: OLLayer | null = null;
+  olLayer: OLLayerLike | null = null;
 
   splitDirection: SplitDirection;
 
@@ -62,10 +63,9 @@ class LayerOpenlayersImpl extends LayerImplementation<OpenlayersMap> {
 
   /**
    * returns the ol Layer
-   * @returns {import("ol/layer").Layer<import("ol/source/Source").default>}
    */
   // eslint-disable-next-line class-methods-use-this
-  getOLLayer(): OLLayer {
+  getOLLayer(): OLLayerLike {
     throw new Error();
   }
 
@@ -84,12 +84,23 @@ class LayerOpenlayersImpl extends LayerImplementation<OpenlayersMap> {
         !this._splitDirectionRenderListeners
       ) {
         this._splitDirectionRenderListeners = [];
-        this._splitDirectionRenderListeners.push(
-          this.olLayer!.on('prerender', this._splitPreRender.bind(this)),
-        );
-        this._splitDirectionRenderListeners.push(
-          this.olLayer!.on('postrender', this._splitPostReder.bind(this)),
-        );
+        if (this.olLayer instanceof OLLayer) {
+          this._splitDirectionRenderListeners.push(
+            this.olLayer.on('prerender', this._splitPreRender.bind(this)),
+          );
+          this._splitDirectionRenderListeners.push(
+            this.olLayer.on('postrender', this._splitPostReder.bind(this)),
+          );
+        } else {
+          this.olLayer!.getLayersArray().forEach((layer) => {
+            this._splitDirectionRenderListeners!.push(
+              layer.on('prerender', this._splitPreRender.bind(this)),
+            );
+            this._splitDirectionRenderListeners!.push(
+              layer.on('postrender', this._splitPostReder.bind(this)),
+            );
+          });
+        }
         this.olLayer!.changed();
       }
     }

package/src/layer/openlayers/mapboxStyleOpenlayersImpl.ts

@@ -0,0 +1,68 @@
+import type LayerGroup from 'ol/layer/Group.js';
+import { SplitDirection } from '@vcmap-cesium/engine';
+import { unByKey } from 'ol/Observable.js';
+import type { EventsKey } from 'ol/events.js';
+import type OpenlayersMap from '../../map/openlayersMap.js';
+import type { MapboxStyleLayerImplementationOptions } from '../cesium/mapboxStyleCesiumImpl.js';
+import type { OLLayerLike } from '../../map/baseOLMap.js';
+import LayerOpenlayersImpl from './layerOpenlayersImpl.js';
+
+class MapboxVectorTileOpenlayersImpl extends LayerOpenlayersImpl {
+  static get className(): string {
+    return 'MapboxVectorTileOpenlayersImpl';
+  }
+
+  private _styledMapboxLayerGroup: LayerGroup;
+
+  private _removeChildLayerListeners: (() => void) | null = null;
+
+  constructor(
+    map: OpenlayersMap,
+    options: MapboxStyleLayerImplementationOptions,
+  ) {
+    super(map, options);
+    this._styledMapboxLayerGroup = options.styledMapboxLayerGroup;
+  }
+
+  getOLLayer(): OLLayerLike {
+    return this._styledMapboxLayerGroup as OLLayerLike;
+  }
+
+  updateSplitDirection(splitDirection: SplitDirection): void {
+    this.splitDirection = splitDirection;
+    if (this.initialized) {
+      this._removeChildLayerListeners?.();
+      this._removeChildLayerListeners = null;
+
+      if (splitDirection !== SplitDirection.NONE) {
+        const childLayers = this._styledMapboxLayerGroup.getLayersArray();
+        const listenerKeys: EventsKey[] = [];
+        childLayers.forEach((layer) => {
+          listenerKeys.push(
+            layer.on('prerender', this._splitPreRender.bind(this)),
+          );
+          listenerKeys.push(
+            layer.on('postrender', this._splitPostReder.bind(this)),
+          );
+          layer.changed();
+        });
+        this._removeChildLayerListeners = (): void => {
+          unByKey(listenerKeys);
+        };
+      } else {
+        const childLayers = this._styledMapboxLayerGroup.getLayersArray();
+        childLayers.forEach((layer) => {
+          layer.changed();
+        });
+      }
+    }
+  }
+
+  destroy(): void {
+    this._removeChildLayerListeners?.();
+    this._removeChildLayerListeners = null;
+    super.destroy();
+  }
+}
+
+export default MapboxVectorTileOpenlayersImpl;

package/src/layer/panoramaDatasetLayer.ts

@@ -140,9 +140,17 @@ export default class PanoramaDatasetLayer extends VectorTileLayer<PanoramaDatase
       defaultOptions.panoramaVectorProperties!,
     );
     if (options.panoramaVectorProperties) {
-      this._panoramaVectorProperties.setValues(
-        options.panoramaVectorProperties,
-      );
+      const panoramaVectorPropertiesOptions =
+        options.panoramaVectorProperties.primitiveOptions == null
+          ? options.panoramaVectorProperties
+          : {
+              ...options.panoramaVectorProperties,
+              primitiveOptions: {
+                offset: [0, 0, this.cameraOffset],
+                ...options.panoramaVectorProperties.primitiveOptions,
+              },
+            };
+      this._panoramaVectorProperties.setValues(panoramaVectorPropertiesOptions);
     }
 
     this._supportedMaps.push(PanoramaMap.className);
@@ -289,16 +297,28 @@ export default class PanoramaDatasetLayer extends VectorTileLayer<PanoramaDatase
       delete config.zIndex;
     }
 
-    defaultOptions.panoramaVectorProperties!.primitiveOptions!.offset = [
-      0,
-      0,
-      this.cameraOffset,
-    ];
+    const defaultPanoramaPrimitiveOptions =
+      defaultOptions.panoramaVectorProperties!.primitiveOptions!;
     const vectorPropertiesConfig = this._panoramaVectorProperties.getVcsMeta({
       ...VectorProperties.getDefaultOptions(),
       ...defaultOptions.panoramaVectorProperties,
+      primitiveOptions: {
+        offset: [0, 0, this.cameraOffset],
+        ...defaultPanoramaPrimitiveOptions,
+      },
     });
 
+    if (
+      vectorPropertiesConfig.primitiveOptions?.offset?.[0] === 0 &&
+      vectorPropertiesConfig.primitiveOptions?.offset?.[1] === 0 &&
+      vectorPropertiesConfig.primitiveOptions?.offset?.[2] === this.cameraOffset
+    ) {
+      delete vectorPropertiesConfig.primitiveOptions.offset;
+      if (Object.keys(vectorPropertiesConfig.primitiveOptions).length === 0) {
+        delete vectorPropertiesConfig.primitiveOptions;
+      }
+    }
+
     if (Object.keys(vectorPropertiesConfig).length > 0) {
       config.panoramaVectorProperties = vectorPropertiesConfig;
     }

package/src/map/baseCesiumMap.ts

@@ -21,7 +21,9 @@ import {
   ScreenSpaceEventType,
   type TerrainProvider,
 } from '@vcmap-cesium/engine';
+import { parseBoolean } from '@vcsuite/parsers';
 import type { Coordinate } from 'ol/coordinate.js';
+import type { VcsMapOptions } from './vcsMap.js';
 import VcsMap from './vcsMap.js';
 import type Layer from '../layer/layer.js';
 import type LayerCollection from '../util/layerCollection.js';
@@ -36,6 +38,13 @@ import Projection from '../util/projection.js';
 
 RequestScheduler.maximumRequestsPerServer = 12;
 
+export type BaseCesiumMapOptions = VcsMapOptions & {
+  /**
+   * If true, ancestors will be preloaded
+   */
+  preloadAncestors?: boolean;
+};
+
 /**
  * Ensures, a primitive/imageryLayer/entity is part of a collection and placed at the correct location
  * @param  cesiumCollection
@@ -148,18 +157,48 @@ export default class BaseCesiumMap extends VcsMap<CesiumVisualisationType> {
     return 'BaseCesiumMap';
   }
 
+  static getDefaultOptions(): BaseCesiumMapOptions {
+    return {
+      ...VcsMap.getDefaultOptions(),
+      preloadAncestors: false,
+    };
+  }
+
   protected _cesiumWidget: CesiumWidget | null = null;
 
   protected _terrainProvider: TerrainProvider | null | undefined = null;
 
   private _screenSpaceListener: (() => void) | undefined;
 
+  private _preloadAncestors = false;
+
   screenSpaceEventHandler: ScreenSpaceEventHandler | null = null;
 
   defaultTerrainProvider: TerrainProvider | null = null;
 
   protected _listeners: (() => void)[] = [];
 
+  constructor(options: BaseCesiumMapOptions) {
+    const defaultOptions = BaseCesiumMap.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
+
+    this._preloadAncestors = parseBoolean(
+      options.preloadAncestors,
+      defaultOptions.preloadAncestors,
+    );
+  }
+
+  get preloadAncestors(): boolean {
+    return this._preloadAncestors;
+  }
+
+  set preloadAncestors(value: boolean) {
+    this._preloadAncestors = value;
+    if (this._cesiumWidget) {
+      this._cesiumWidget.scene.globe.preloadAncestors = value;
+    }
+  }
+
   get terrainProvider(): TerrainProvider | null | undefined {
     return this._terrainProvider;
   }
@@ -185,6 +224,7 @@ export default class BaseCesiumMap extends VcsMap<CesiumVisualisationType> {
       ),
     );
 
+    this._cesiumWidget.scene.globe.preloadAncestors = this.preloadAncestors;
     this._cesiumWidget.scene.frameState.creditDisplay.update = (): void => {};
     this._cesiumWidget.scene.frameState.creditDisplay.beginFrame =
       (): void => {};
@@ -453,6 +493,13 @@ export default class BaseCesiumMap extends VcsMap<CesiumVisualisationType> {
     return this._cesiumWidget?.scene;
   }
 
+  /**
+   * defines whether ancestors are preloaded or not
+   */
+  setPreloadAncestors(value: boolean): void {
+    this.preloadAncestors = value;
+  }
+
   protected _indexChangedOnVisualization(vis: CesiumVisualisationType): void {
     if (vis instanceof PrimitiveCollection) {
       indexChangedOnPrimitive(
@@ -579,6 +626,16 @@ export default class BaseCesiumMap extends VcsMap<CesiumVisualisationType> {
     }
   }
 
+  toJSON(
+    defaultOptions = BaseCesiumMap.getDefaultOptions(),
+  ): BaseCesiumMapOptions {
+    const config: BaseCesiumMapOptions = super.toJSON(defaultOptions);
+    if (this.preloadAncestors !== defaultOptions.preloadAncestors) {
+      config.preloadAncestors = this.preloadAncestors;
+    }
+    return config;
+  }
+
   override destroy(): void {
     this._listeners.forEach((cb) => {
       cb();

package/src/map/baseOLMap.ts

@@ -1,12 +1,12 @@
 import { Cartesian2 } from '@vcmap-cesium/engine';
 import { unByKey } from 'ol/Observable.js';
 import OLMap from 'ol/Map.js';
+import type OLLayer from 'ol/layer/Layer.js';
+import type OLLayerGroup from 'ol/layer/Group.js';
 import { defaults as defaultInteractions } from 'ol/interaction.js';
 import type { Collection as OLCollection, MapBrowserEvent } from 'ol';
-import type { Layer as OLLayer } from 'ol/layer.js';
 import type { EventsKey } from 'ol/events.js';
 import type { Coordinate } from 'ol/coordinate.js';
-
 import VcsMap from './vcsMap.js';
 import { vcsLayerName } from '../layer/layerSymbols.js';
 import {
@@ -20,22 +20,24 @@ import type Layer from '../layer/layer.js';
 import type { DisableMapControlOptions } from '../util/mapCollection.js';
 import { vectorClusterGroupName } from '../vectorCluster/vectorClusterSymbols.js';
 
+export type OLLayerLike = OLLayer | OLLayerGroup;
+
 function ensureLayerInCollection(
-  layers: OLCollection<OLLayer>,
-  layer: OLLayer,
+  layers: OLCollection<OLLayerLike>,
+  layer: OLLayerLike,
   layerCollection: LayerCollection,
 ): void {
   const sortedVectorClusterGroups = [
     ...layerCollection.vectorClusterGroups,
   ].sort((a, b) => a.zIndex - b.zIndex);
 
-  const getIndexOfOlLayer = (olL: OLLayer): number => {
+  const getIndexOfOlLayer = (olL: OLLayerLike): number => {
     let layerIndex;
     let clusterIndex = 0;
-    if (olL[vectorClusterGroupName]) {
-      const clusterGroup = layerCollection.vectorClusterGroups.getByKey(
-        olL[vectorClusterGroupName],
-      )!;
+    const clusterName = (olL as OLLayer)[vectorClusterGroupName];
+    if (clusterName) {
+      const clusterGroup =
+        layerCollection.vectorClusterGroups.getByKey(clusterName)!;
       layerIndex = layerCollection.findIndex(
         (l) => l.zIndex > clusterGroup.zIndex,
       );
@@ -90,7 +92,7 @@ function getPointerKeyType(button?: number): PointerKeyType {
 /**
  * @group Map
  */
-class BaseOLMap extends VcsMap<OLLayer> {
+class BaseOLMap extends VcsMap<OLLayerLike> {
   static get className(): string {
     return 'BaseOLMap';
   }
@@ -214,7 +216,7 @@ class BaseOLMap extends VcsMap<OLLayer> {
         const layers = (this._olMap as OLMap).getLayers();
         layers.remove(olLayer);
         ensureLayerInCollection(
-          layers as OLCollection<OLLayer>,
+          layers as OLCollection<OLLayerLike>,
           olLayer,
           this.layerCollection,
         );
@@ -226,11 +228,11 @@ class BaseOLMap extends VcsMap<OLLayer> {
    * Internal API for registering representations.
    * @param olLayer
    */
-  addOLLayer(olLayer: OLLayer): void {
+  addOLLayer(olLayer: OLLayerLike): void {
     if (this.validateVisualization(olLayer)) {
       this.addVisualization(olLayer);
       ensureLayerInCollection(
-        (this._olMap as OLMap).getLayers() as OLCollection<OLLayer>,
+        (this._olMap as OLMap).getLayers() as OLCollection<OLLayerLike>,
         olLayer,
         this.layerCollection,
       );
@@ -240,7 +242,7 @@ class BaseOLMap extends VcsMap<OLLayer> {
   /**
    * Internal API for deregistering representations.
    */
-  removeOLLayer(olLayer: OLLayer): void {
+  removeOLLayer(olLayer: OLLayerLike): void {
     this.removeVisualization(olLayer);
     if (this._olMap) {
       this._olMap.getLayers().remove(olLayer);

package/src/map/cesiumMap.ts

@@ -29,7 +29,11 @@ import {
 import type { Coordinate } from 'ol/coordinate.js';
 import { check, maybe } from '@vcsuite/check';
 import { parseBoolean, parseInteger, parseNumber } from '@vcsuite/parsers';
-import VcsMap, { type VcsMapOptions } from './vcsMap.js';
+import type {
+  BaseCesiumMapOptions,
+  CesiumVisualisationType,
+} from './baseCesiumMap.js';
+import BaseCesiumMap from './baseCesiumMap.js';
 import type Viewpoint from '../util/viewpoint.js';
 import Projection, { mercatorProjection } from '../util/projection.js';
 import { getHeightFromTerrainProvider } from '../layer/terrainHelpers.js';
@@ -41,9 +45,6 @@ import type LayerCollection from '../util/layerCollection.js';
 import VcsEvent from '../vcsEvent.js';
 import type { DisableMapControlOptions } from '../util/mapCollection.js';
 import { vectorClusterGroupName } from '../vectorCluster/vectorClusterSymbols.js';
-import BaseCesiumMap, {
-  type CesiumVisualisationType,
-} from './baseCesiumMap.js';
 
 /**
  * @param  dataSourceCollection
@@ -120,7 +121,7 @@ function indexChangedOnDataSource(
   );
 }
 
-export type CesiumMapOptions = VcsMapOptions & {
+export type CesiumMapOptions = BaseCesiumMapOptions & {
   /**
    * if true, lighting will be activated.
    */
@@ -203,7 +204,7 @@ class CesiumMap extends BaseCesiumMap {
 
   static getDefaultOptions(): CesiumMapOptions {
     return {
-      ...VcsMap.getDefaultOptions(),
+      ...BaseCesiumMap.getDefaultOptions(),
       enableLightning: true,
       tileCacheSize: 1,
       webGLaa: false,