@vcmap/core 6.3.0-rc.1 → 6.3.0-rc.2

package/src/layer/tileProvider/flatGeobufTileProvider.ts

@@ -1,7 +1,7 @@
 import type Feature from 'ol/Feature.js';
 import type { HttpReader } from 'flatgeobuf/lib/mjs/http-reader.js';
 import type { TileProviderOptions } from './tileProvider.js';
-import TileProvider, { rectangleToExtent } from './tileProvider.js';
+import TileProvider from './tileProvider.js';
 import type { ProjectionOptions } from '../../util/projection.js';
 import Projection, {
   getDefaultProjection,
@@ -14,6 +14,7 @@ import {
   getRootNode,
   getValidReader,
 } from '../flatGeobufHelpers.js';
+import { rectangleToMercatorExtent } from '../../util/math.js';
 
 export type FlatGeobufTileProviderOptions = Omit<
   TileProviderOptions,
@@ -81,7 +82,7 @@ export default class FlatGeobufTileProvider extends TileProvider {
 
   async loader(x: number, y: number, z: number): Promise<Feature[]> {
     const rectangle = this.tilingScheme.tileXYToRectangle(x, y, z);
-    const extent = rectangleToExtent(rectangle);
+    const extent = rectangleToMercatorExtent(rectangle);
     const mercatorExtent = new Extent({
       coordinates: extent,
       projection: mercatorProjection,

package/src/layer/tileProvider/mvtTileProvider.ts

@@ -3,10 +3,11 @@ import Feature from 'ol/Feature.js';
 import { getCenter } from 'ol/extent.js';
 import type { Geometry } from 'ol/geom.js';
 import type { TileProviderOptions } from './tileProvider.js';
-import TileProvider, { rectangleToExtent } from './tileProvider.js';
+import TileProvider from './tileProvider.js';
 import { getURL } from './urlTemplateTileProvider.js';
 import { getInitForUrl, requestArrayBuffer } from '../../util/fetch.js';
 import { tileProviderClassRegistry } from '../../classRegistry.js';
+import { rectangleToMercatorExtent } from '../../util/math.js';
 
 export type MVTTileProviderOptions = TileProviderOptions & {
   /**
@@ -66,7 +67,7 @@ class MVTTileProvider extends TileProvider {
   ): Promise<Feature[]> {
     const rectangle = this.tilingScheme.tileXYToRectangle(x, y, z);
     const url = getURL(this.url, x, y, z, rectangle, this.locale);
-    const extent = rectangleToExtent(rectangle);
+    const extent = rectangleToMercatorExtent(rectangle);
     const center = getCenter(extent);
     const init = getInitForUrl(this.url, headers);
     const data = await requestArrayBuffer(url, init);

package/src/layer/tileProvider/tileProvider.ts

@@ -27,6 +27,7 @@ import VcsObject from '../../vcsObject.js';
 import VcsEvent from '../../vcsEvent.js';
 import { tileProviderClassRegistry } from '../../classRegistry.js';
 import type Extent from '../../util/extent.js';
+import { rectangleToMercatorExtent } from '../../util/math.js';
 
 export type TileProviderRTreeEntry = {
   minX: number;
@@ -56,6 +57,7 @@ for (let i = 0; i < mercatorResolutionsToLevel.length; i++) {
  * transforms cesium geographic rectangle to mercator extent
  * @param  rectangle in wgs84 radians
  * @returns  extent in mercator
+ * @deprecated use rectangleToMercatorExtent
  */
 export function rectangleToExtent(rectangle: Rectangle): OLExtent {
   const baseSouthWestLevel = Rectangle.southwest(rectangle);
@@ -387,6 +389,16 @@ class TileProvider extends VcsObject {
     return `${level}/${x}/${y}`;
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  parseCacheKey(key: string): { x: number; y: number; level: number } {
+    const parts = key.split('/');
+    return {
+      level: parseInt(parts[0], 10),
+      x: parseInt(parts[1], 10),
+      y: parseInt(parts[2], 10),
+    };
+  }
+
   private async _getRtreeForBaseTile(
     baseLevel: number,
     tileCenter: Cartographic,
@@ -506,7 +518,7 @@ class TileProvider extends VcsObject {
         if (level === baseLevel) {
           return rtree.all().map((item) => item.value);
         } else {
-          const extent = rectangleToExtent(rectangle);
+          const extent = rectangleToMercatorExtent(rectangle);
           const features = rtree
             .search({
               minX: extent[0],

package/src/layer/vectorLayer.ts

@@ -105,7 +105,7 @@ class VectorLayer
       dontUseTerrainForOblique: false,
       highlightStyle: undefined,
       isDynamic: false,
-      vectorProperties: {}, // XXX or should we return VectorProperties default options?
+      vectorProperties: undefined, // XXX or should we return VectorProperties default options?
       vectorClusterGroup: undefined,
       ignoreMapLayerTypes: true,
     };
@@ -545,7 +545,9 @@ class VectorLayer
       config.isDynamic = this.isDynamic;
     }
 
-    const vectorPropertiesConfig = this.vectorProperties.getVcsMeta();
+    const vectorPropertiesConfig = this.vectorProperties.getVcsMeta(
+      defaultOptions.vectorProperties,
+    );
     if (Object.keys(vectorPropertiesConfig).length > 0) {
       config.vectorProperties = vectorPropertiesConfig;
     }

package/src/layer/vectorProperties.ts

@@ -347,8 +347,8 @@ class VectorProperties {
       modelRoll: 0,
       modelOptions: undefined,
       modelAutoScale: false,
-      baseUrl: undefined,
       primitiveOptions: undefined,
+      baseUrl: undefined,
     };
   }
 
@@ -1683,6 +1683,15 @@ class VectorProperties {
     if (this.baseUrl !== defaultValues.baseUrl) {
       vcsMeta.baseUrl = this.baseUrl;
     }
+    if (!deepEqual(this.modelOptions, defaultOptions?.modelOptions)) {
+      vcsMeta.modelOptions = this.modelOptions;
+    }
+    if (this.modelAutoScale !== defaultValues.modelAutoScale) {
+      vcsMeta.modelAutoScale = this.modelAutoScale;
+    }
+    if (!deepEqual(this.primitiveOptions, defaultOptions?.primitiveOptions)) {
+      vcsMeta.primitiveOptions = this.primitiveOptions;
+    }
     return vcsMeta;
   }
 

package/src/layer/vectorTileLayer.ts

@@ -1,3 +1,4 @@
+import { check, is, maybe, oneOf } from '@vcsuite/check';
 import Style, { type StyleFunction } from 'ol/style/Style.js';
 import type { Feature } from 'ol/index.js';
 import type { Size } from 'ol/size.js';
@@ -53,6 +54,14 @@ import VectorTileCesiumImpl from './cesium/vectorTileCesiumImpl.js';
 import VectorTilePanoramaImpl from './panorama/vectorTilePanoramaImpl.js';
 import PanoramaMap from '../map/panoramaMap.js';
 import type LayerImplementation from './layerImplementation.js';
+import AbstractFeatureProvider from '../featureProvider/abstractFeatureProvider.js';
+import AbstractAttributeProvider, {
+  type AbstractAttributeProviderOptions,
+  type AttributeProvider,
+} from '../featureProvider/abstractAttributeProvider.js';
+import CompositeFeatureProvider from '../featureProvider/compositeFeatureProvider.js';
+import { rectangleToMercatorExtent } from '../util/math.js';
+import { getProviderForOption } from '../featureProvider/featureProviderFactory.js';
 
 /**
  * synchronizes featureVisibility Symbols on the feature;
@@ -113,14 +122,18 @@ export type VectorTileOptions = FeatureLayerOptions & {
   declutter?: boolean;
   debug?: boolean;
   renderer?: VectorTileRenderer;
+  /**
+   * an optional attribute provider to provide custom attributes for the tileset features on load
+   */
+  attributeProvider?: AttributeProvider | AbstractAttributeProviderOptions;
 };
 
 export type VectorTileImplementationOptions =
   FeatureLayerImplementationOptions & {
     tileProvider: TileProvider;
     tileSize: Size;
-    minLevel: number;
-    maxLevel: number;
+    minLevel?: number;
+    maxLevel?: number;
     extent?: Extent;
     declutter: boolean;
     vectorProperties: VectorProperties;
@@ -163,6 +176,7 @@ class VectorTileLayer<
       declutter: true,
       debug: false,
       renderer: 'image',
+      attributeProvider: undefined,
     };
   }
 
@@ -177,9 +191,11 @@ class VectorTileLayer<
 
   tileProvider: TileProvider;
 
-  private _maxLevel: number;
+  private _attributeProvider?: AttributeProvider;
+
+  private _maxLevel?: number;
 
-  private _minLevel: number;
+  private _minLevel?: number;
 
   private _declutter: boolean;
 
@@ -200,6 +216,10 @@ class VectorTileLayer<
 
   private _renderer: VectorTileRenderer;
 
+  private _defaultFeatureProvider?:
+    | TileProviderFeatureProvider
+    | CompositeFeatureProvider;
+
   /**
    * @param  options
    */
@@ -229,6 +249,7 @@ class VectorTileLayer<
             tileProviderClassRegistry,
             options.tileProvider ?? { type: TileProvider.className },
           ) as TileProvider);
+
     if (this.tileProvider) {
       this.tileProvider.locale = this.locale;
     }
@@ -242,6 +263,17 @@ class VectorTileLayer<
       vectorTileRenderers,
       defaultOptions.renderer,
     );
+
+    const attributeProvider = getProviderForOption(options.attributeProvider);
+
+    if (
+      is(
+        attributeProvider,
+        oneOf(CompositeFeatureProvider, AbstractAttributeProvider),
+      )
+    ) {
+      this._attributeProvider = attributeProvider;
+    }
   }
 
   /**
@@ -267,6 +299,26 @@ class VectorTileLayer<
     this.vectorProperties.allowPicking = allowPicking;
   }
 
+  get attributeProvider(): AttributeProvider | undefined {
+    return this._attributeProvider;
+  }
+
+  set attributeProvider(provider: AttributeProvider | undefined) {
+    check(
+      provider,
+      maybe(oneOf(AbstractAttributeProvider, CompositeFeatureProvider)),
+    );
+
+    if (this._attributeProvider !== provider) {
+      this._attributeProvider = provider;
+      this.forceRedraw().catch((e: unknown) => {
+        this.getLogger().error(
+          `Error forcing redraw after setting attribute provider: ${String(e)}`,
+        );
+      });
+    }
+  }
+
   async initialize(): Promise<void> {
     if (!this.initialized) {
       this._tileLoadEventListener =
@@ -279,14 +331,26 @@ class VectorTileLayer<
           void this.reload();
         });
 
-      if (this._renderer === 'image') {
-        // primitives dont need a feature provider
-        this.featureProvider = new TileProviderFeatureProvider(this.name, {
-          // XXX this overwrites
+      if (
+        this._renderer === 'image' &&
+        !(this.featureProvider instanceof AbstractFeatureProvider)
+      ) {
+        const defaultFeatureProvider = new TileProviderFeatureProvider({
           style: this.style,
           tileProvider: this.tileProvider,
           vectorProperties: this.vectorProperties,
         });
+
+        if (this.featureProvider instanceof AbstractAttributeProvider) {
+          const attributeProvider = this.featureProvider;
+          this._defaultFeatureProvider = new CompositeFeatureProvider({
+            featureProviders: [defaultFeatureProvider],
+            attributeProviders: [attributeProvider],
+          });
+        } else {
+          this._defaultFeatureProvider = defaultFeatureProvider;
+        }
+        this.featureProvider = this._defaultFeatureProvider;
       }
     }
     await super.initialize();
@@ -297,27 +361,40 @@ class VectorTileLayer<
     return this._styleZIndex;
   }
 
-  private _handleTileLoaded({ rtree }: TileLoadedEvent): void {
-    rtree
-      .all()
-      .map((item) => item.value)
-      .forEach((feature) => {
-        const featureStyle = feature.getStyle();
-        if (featureStyle && featureStyle instanceof Style) {
-          featureStyle.setZIndex(this._getNextStyleZIndex());
-        }
-        feature[vcsLayerName] = this.name;
-        feature.getStyleFunction = (): StyleFunction => {
-          return this._featureStyle.bind(this) as StyleFunction;
-        };
-        if (this.tileProvider.trackFeaturesToTiles && this.globalHider) {
-          synchronizeFeatureVisibility(
-            this.featureVisibility,
-            this.globalHider,
-            feature,
-          );
-        }
-      });
+  private _handleTileLoaded({ rtree, tileId }: TileLoadedEvent): void {
+    const features = rtree.all().map((item) => {
+      const feature = item.value;
+      const featureStyle = feature.getStyle();
+      if (featureStyle && featureStyle instanceof Style) {
+        featureStyle.setZIndex(this._getNextStyleZIndex());
+      }
+      feature[vcsLayerName] = this.name;
+      feature.getStyleFunction = (): StyleFunction => {
+        return this._featureStyle.bind(this) as StyleFunction;
+      };
+      if (this.tileProvider.trackFeaturesToTiles && this.globalHider) {
+        synchronizeFeatureVisibility(
+          this.featureVisibility,
+          this.globalHider,
+          feature,
+        );
+      }
+      return feature;
+    });
+
+    if (this._attributeProvider) {
+      const { x, y, level } = this.tileProvider.parseCacheKey(tileId);
+      const rectangle = this.tileProvider.tilingScheme.tileXYToRectangle(
+        x,
+        y,
+        level,
+      );
+      this._attributeProvider
+        .augmentFeatures(features, rectangleToMercatorExtent(rectangle))
+        .catch((error: unknown) => {
+          this.getLogger().error(`Error augmenting features: ${String(error)}`);
+        });
+    }
   }
 
   setGlobalHider(globalHider: GlobalHider): void {
@@ -516,24 +593,6 @@ class VectorTileLayer<
     });
   }
 
-  destroy(): void {
-    this._featureVisibilityListeners.forEach((cb) => {
-      cb();
-    });
-    super.destroy();
-    this._tileLoadEventListener();
-    if (this.featureProvider) {
-      this.featureProvider.destroy();
-    }
-    if (this.tileProvider) {
-      this.tileProvider.destroy();
-    }
-    this._vectorPropertiesChangedListener();
-    if (this.vectorProperties) {
-      this.vectorProperties.destroy();
-    }
-  }
-
   toJSON(
     defaultOptions = VectorTileLayer.getDefaultOptions(),
   ): VectorTileOptions {
@@ -572,8 +631,37 @@ class VectorTileLayer<
       config.debug = this._debug;
     }
 
+    if (this.featureProvider === this._defaultFeatureProvider) {
+      delete config.featureProvider;
+      if (this.featureProvider instanceof CompositeFeatureProvider) {
+        const { attributeProviders } = this.featureProvider.toJSON();
+        config.featureProvider = attributeProviders[0];
+      }
+    }
+
+    if (this._attributeProvider) {
+      config.attributeProvider = this._attributeProvider.toJSON();
+    }
+
     return config;
   }
+
+  destroy(): void {
+    this._featureVisibilityListeners.forEach((cb) => {
+      cb();
+    });
+    this.attributeProvider?.destroy();
+    this._defaultFeatureProvider?.destroy();
+    super.destroy();
+    this._tileLoadEventListener();
+    if (this.tileProvider) {
+      this.tileProvider.destroy();
+    }
+    this._vectorPropertiesChangedListener();
+    if (this.vectorProperties) {
+      this.vectorProperties.destroy();
+    }
+  }
 }
 
 layerClassRegistry.registerClass(VectorTileLayer.className, VectorTileLayer);

package/src/layer/wmsLayer.ts

@@ -16,6 +16,10 @@ import WmsOpenlayersImpl from './openlayers/wmsOpenlayersImpl.js';
 import Extent from '../util/extent.js';
 import { layerClassRegistry } from '../classRegistry.js';
 import type VcsMap from '../map/vcsMap.js';
+import AbstractAttributeProvider from '../featureProvider/abstractAttributeProvider.js';
+import CompositeFeatureProvider, {
+  type CompositeFeatureProviderOptions,
+} from '../featureProvider/compositeFeatureProvider.js';
 
 export type WMSImplementationOptions = RasterLayerImplementationOptions & {
   parameters: Record<string, string>;
@@ -39,9 +43,10 @@ export type WMSOptions = RasterLayerOptions & {
    * key value pair of additional WMS parameters, url query notation possible
    */
   parameters?: Record<string, string> | string;
-
   /**
    * whether this layer should send getFeatureInfo requests to the service when objects are clicked.
+   * do not provide this option AND a feature provider. this option will configure a
+   * layer specific WMSFeatureProvider. providing an attribute provider will create a composite feature provider.
    */
   featureInfo?: Partial<WMSFeatureProviderOptions>;
   /**
@@ -92,6 +97,8 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
 
   private _featureInfoOptions: Partial<WMSFeatureProviderOptions> | undefined;
 
+  private _attributeProvider?: AbstractAttributeProvider;
+
   /**
    * @param  options
    */
@@ -140,6 +147,10 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
       options.singleImage2d,
       defaultOptions.singleImage2d,
     );
+
+    if (this.featureProvider instanceof AbstractAttributeProvider) {
+      this._attributeProvider = this.featureProvider;
+    }
   }
 
   initialize(): Promise<void> {
@@ -163,9 +174,19 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
         extent: this.extent,
         parameters: this.parameters,
         version: this.version,
+        headers: this.headers,
         ...this._featureInfoOptions,
       };
-      this.featureProvider = new WMSFeatureProvider(this.name, options);
+
+      const wmsFeatureProvider = new WMSFeatureProvider(options);
+      if (this._attributeProvider) {
+        this.featureProvider = new CompositeFeatureProvider({
+          featureProviders: [wmsFeatureProvider],
+          attributeProviders: [this._attributeProvider],
+        });
+      } else {
+        this.featureProvider = wmsFeatureProvider;
+      }
     }
   }
 
@@ -260,49 +281,61 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
       config.singleImage2d = this.singleImage2d;
     }
 
-    if (
-      this.featureProvider &&
-      this.featureProvider instanceof WMSFeatureProvider
-    ) {
-      const featureInfoConfig: Partial<WMSFeatureProviderOptions> =
-        this.featureProvider.toJSON();
-      if (
-        this.tileSize[0] === featureInfoConfig?.tileSize?.[0] ||
-        this.tileSize[1] === featureInfoConfig?.tileSize?.[1]
-      ) {
-        delete featureInfoConfig.tileSize;
-      }
-      if (
-        Object.entries(this.parameters).every(
-          ([key, value]) => featureInfoConfig?.parameters?.[key] === value,
-        )
-      ) {
-        delete featureInfoConfig.parameters;
-      }
-      if (
-        featureInfoConfig.extent &&
-        new Extent(featureInfoConfig.extent).equals(this.extent)
-      ) {
-        delete featureInfoConfig.extent;
-      }
-      if (this.url === featureInfoConfig.url) {
-        delete featureInfoConfig.url;
-      }
-      if (this.tilingSchema === featureInfoConfig.tilingSchema) {
-        delete featureInfoConfig.tilingSchema;
-      }
-      if (this.version === featureInfoConfig.version) {
-        delete featureInfoConfig.version;
-      }
-      if (this.minLevel === featureInfoConfig.minLevel) {
-        delete featureInfoConfig.minLevel;
-      }
-      if (this.maxLevel === featureInfoConfig.maxLevel) {
-        delete featureInfoConfig.maxLevel;
+    if (this._featureInfoOptions) {
+      delete config.featureProvider;
+      if (this.featureProvider) {
+        let featureInfoConfig: Partial<WMSFeatureProviderOptions>;
+        if (this._attributeProvider) {
+          const compositeInfo =
+            this.featureProvider.toJSON() as CompositeFeatureProviderOptions;
+          featureInfoConfig = compositeInfo.featureProviders[0];
+          config.featureProvider = this._attributeProvider.toJSON();
+        } else {
+          featureInfoConfig = this.featureProvider.toJSON();
+        }
+        if (
+          this.tileSize[0] === featureInfoConfig?.tileSize?.[0] ||
+          this.tileSize[1] === featureInfoConfig?.tileSize?.[1]
+        ) {
+          delete featureInfoConfig.tileSize;
+        }
+        if (
+          Object.entries(this.parameters).every(
+            ([key, value]) => featureInfoConfig?.parameters?.[key] === value,
+          )
+        ) {
+          delete featureInfoConfig.parameters;
+        }
+        if (
+          featureInfoConfig.extent &&
+          new Extent(featureInfoConfig.extent).equals(this.extent)
+        ) {
+          delete featureInfoConfig.extent;
+        }
+        if (this.url === featureInfoConfig.url) {
+          delete featureInfoConfig.url;
+        }
+        if (this.tilingSchema === featureInfoConfig.tilingSchema) {
+          delete featureInfoConfig.tilingSchema;
+        }
+        if (this.version === featureInfoConfig.version) {
+          delete featureInfoConfig.version;
+        }
+        if (this.minLevel === featureInfoConfig.minLevel) {
+          delete featureInfoConfig.minLevel;
+        }
+        if (this.maxLevel === featureInfoConfig.maxLevel) {
+          delete featureInfoConfig.maxLevel;
+        }
+
+        if (this._featureInfoOptions) {
+          delete featureInfoConfig.name;
+          delete featureInfoConfig.type;
+        }
+        config.featureInfo = featureInfoConfig;
+      } else {
+        config.featureInfo = this._featureInfoOptions;
       }
-      config.featureInfo = featureInfoConfig;
-    } else if (this._featureInfoOptions) {
-      config.featureInfo = this._featureInfoOptions;
     }
 
     return config;

package/src/map/baseCesiumMap.ts

@@ -7,6 +7,7 @@ import {
   type CustomDataSource,
   type CzmlDataSource,
   Ellipsoid,
+  type I3SDataProvider,
   ImageryLayer,
   type ImageryLayerCollection,
   JulianDate,
@@ -47,7 +48,7 @@ function ensureInCollection<
 >(
   cesiumCollection: T,
   item: T extends PrimitiveCollection
-    ? PrimitiveCollection | Cesium3DTileset
+    ? PrimitiveCollection | Cesium3DTileset | I3SDataProvider
     : ImageryLayer,
   layerCollection: LayerCollection,
 ): void {
@@ -62,7 +63,7 @@ function ensureInCollection<
         const collectionItem = cesiumCollection.get(
           i,
         ) as T extends PrimitiveCollection
-          ? PrimitiveCollection | Cesium3DTileset
+          ? PrimitiveCollection | Cesium3DTileset | I3SDataProvider
           : ImageryLayer;
         if (
           (layerCollection.indexOfKey(collectionItem[vcsLayerName]) as number) >
@@ -139,7 +140,8 @@ export type CesiumVisualisationType =
   | CzmlDataSource
   | PrimitiveCollection
   | Cesium3DTileset
-  | ImageryLayer;
+  | ImageryLayer
+  | I3SDataProvider;
 
 export default class BaseCesiumMap extends VcsMap<CesiumVisualisationType> {
   static get className(): string {
@@ -183,6 +185,22 @@ export default class BaseCesiumMap extends VcsMap<CesiumVisualisationType> {
       ),
     );
 
+    this._cesiumWidget.scene.frameState.creditDisplay.update = (): void => {};
+    this._cesiumWidget.scene.frameState.creditDisplay.beginFrame =
+      (): void => {};
+    this._cesiumWidget.scene.frameState.creditDisplay.endFrame = (): void => {};
+
+    // hide default cesium credits container
+    const creditsContainer = document.getElementsByClassName(
+      'cesium-widget-credits',
+    );
+    if (creditsContainer) {
+      for (let i = 0; i < creditsContainer.length; i++) {
+        const element = creditsContainer[i] as HTMLElement;
+        element.style.display = 'none';
+      }
+    }
+
     this._listeners.push(
       this._cesiumWidget.scene.postRender.addEventListener(
         (eventScene: Scene, time: JulianDate) => {
@@ -465,7 +483,10 @@ export default class BaseCesiumMap extends VcsMap<CesiumVisualisationType> {
    * @param  primitiveCollection
    */
   addPrimitiveCollection(
-    primitiveCollection: PrimitiveCollection | Cesium3DTileset,
+    primitiveCollection:
+      | PrimitiveCollection
+      | Cesium3DTileset
+      | I3SDataProvider,
   ): void {
     if (!this._cesiumWidget) {
       throw new Error('Cannot add primitive to uninitialized map');
@@ -485,7 +506,10 @@ export default class BaseCesiumMap extends VcsMap<CesiumVisualisationType> {
    * @param  primitiveCollection
    */
   removePrimitiveCollection(
-    primitiveCollection: PrimitiveCollection | Cesium3DTileset,
+    primitiveCollection:
+      | PrimitiveCollection
+      | Cesium3DTileset
+      | I3SDataProvider,
   ): void {
     // XXX add destroy as boolean?
     this.removeVisualization(primitiveCollection);