@vcmap/core 5.0.0-rc.1 → 5.0.0-rc.10

package/src/{vcs/vcm/maps/oblique.js → map/obliqueMap.js}

@@ -1,5 +1,5 @@
 import { boundingExtent, containsXY } from 'ol/extent.js';
-import { get as getProjection, getTransform, transform, transformExtent } from 'ol/proj.js';
+import { getTransform, transform, transformExtent } from 'ol/proj.js';
 import { check } from '@vcsuite/check';
 import { parseBoolean, parseNumber } from '@vcsuite/parsers';
 import Extent from '../util/extent.js';
@@ -7,14 +7,14 @@ import { mercatorProjection, wgs84Projection } from '../util/projection.js';
 import { getResolutionOptions, getZoom } from '../layer/oblique/obliqueHelpers.js';
 import ViewPoint from '../util/viewpoint.js';
 import BaseOLMap from './baseOLMap.js';
-import VcsMap from './map.js';
-import VcsEvent from '../event/vcsEvent.js';
-import { obliqueCollectionCollection } from '../globalCollections.js';
-import { ObliqueViewDirection as ViewDirection } from '../oblique/ObliqueViewDirection.js';
-import ObliqueProvider from '../oblique/ObliqueProvider.js';
-import ObliqueCollection from '../oblique/ObliqueCollection.js';
+import VcsMap from './vcsMap.js';
+import VcsEvent from '../vcsEvent.js';
+import { ObliqueViewDirection as ViewDirection } from '../oblique/obliqueViewDirection.js';
+import ObliqueProvider from '../oblique/obliqueProvider.js';
+import ObliqueCollection from '../oblique/obliqueCollection.js';
 import { transformFromImage } from '../oblique/helpers.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { mapClassRegistry } from '../classRegistry.js';
+import DefaultObliqueCollection from '../oblique/defaultObliqueCollection.js';
 
 /**
  * @typedef {Object} ObliqueClickParameters
@@ -28,7 +28,6 @@ import { VcsClassRegistry } from '../classRegistry.js';
  * @property {boolean} [changeOnMoveEnd=false]
  * @property {number} [switchThreshold=0]
  * @property {boolean} [switchOnEdge=true]
- * @property {string|undefined} defaultCollectionName
  * @api
  */
 
@@ -39,6 +38,8 @@ const defaultHeadings = {
   [ViewDirection.WEST]: 270,
 };
 
+const defaultCollection = new DefaultObliqueCollection();
+
 /**
  * returns the direction which matches the heading of the viewpoint
  * @param {ViewPoint} viewpoint
@@ -72,15 +73,15 @@ export function getMercatorViewpointCenter(viewpoint) {
 }
 
 /**
- * Oblique Map Class (2D map with oblique imagery)
+ * ObliqueMap Map Class (2D map with oblique imagery)
  *
  * @class
  * @export
  * @extends {BaseOLMap}
  * @api stable
  */
-class Oblique extends BaseOLMap {
-  static get className() { return 'vcs.vcm.maps.Oblique'; }
+class ObliqueMap extends BaseOLMap {
+  static get className() { return 'ObliqueMap'; }
 
   /**
    * @returns {ObliqueOptions}
@@ -91,22 +92,12 @@ class Oblique extends BaseOLMap {
       changeOnMoveEnd: false,
       switchThreshold: 0,
       switchOnEdge: true,
-      defaultCollectionName: undefined,
     };
   }
 
-  /**
-   * @param {ObliqueOptions} options
-   */
   constructor(options) {
     super(options);
-    const defaultOptions = Oblique.getDefaultOptions();
-    /**
-     * @type {string|undefined}
-     * @private
-     */
-    this._defaultCollectionName = options.defaultCollectionName || defaultOptions.defaultCollectionName;
-
+    const defaultOptions = ObliqueMap.getDefaultOptions();
     /**
      * @type  {ObliqueCollection|null}
      * @private
@@ -139,6 +130,11 @@ class Oblique extends BaseOLMap {
      * @api
      */
     this.collectionChanged = new VcsEvent();
+    /**
+     * @type {function():void}
+     * @private
+     */
+    this._activeCollectionDestroyedListener = () => {};
   }
 
   /**
@@ -209,9 +205,7 @@ class Oblique extends BaseOLMap {
           this.switchEnabled = this._switchEnabled;
           let collectionToLoad = this._loadingCollection;
           if (!collectionToLoad) {
-            collectionToLoad = this._defaultCollectionName ?
-              obliqueCollectionCollection.getByKey(this._defaultCollectionName) :
-              [...obliqueCollectionCollection][0];
+            collectionToLoad = defaultCollection;
           }
           if (collectionToLoad) {
             await this._setCollection(collectionToLoad);
@@ -243,7 +237,7 @@ class Oblique extends BaseOLMap {
   get collection() { return this._obliqueProvider.collection; }
 
   /**
-   * @type {import("@vcmap/cesium").Event}
+   * @type {import("@vcmap/core").VcsEvent<import("@vcmap/core").ObliqueImage>}
    * @readonly
    * @api
    */
@@ -294,26 +288,16 @@ class Oblique extends BaseOLMap {
     if (image) {
       const coords = boundingExtent(image.groundCoordinates);
       return new Extent({
-        coordinates: transformExtent(coords, image.meta.projection, mercatorProjection.proj),
-        epsg: 'EPSG:3857',
+        coordinates: transformExtent(coords, image.meta.projection.proj, mercatorProjection.proj),
+        projection: mercatorProjection.toJSON(),
       });
     }
     return new Extent({
       coordinates: [-18924313.4349, -15538711.0963, 18924313.4349, 15538711.0963],
-      epsg: 'EPSG:3857',
+      projection: mercatorProjection.toJSON(),
     });
   }
 
-  /**
-   * @returns {import("@vcmap/core").ObliqueImage}
-   * @api
-   * @deprecated 4.0
-   */
-  getCurrentImage() {
-    this.getLogger().deprecate('getCurrentImage', 'access the currentImage property');
-    return this._obliqueProvider ? this._obliqueProvider.currentImage : null;
-  }
-
   deactivate() {
     super.deactivate();
     this._obliqueProvider.deactivate();
@@ -333,11 +317,11 @@ class Oblique extends BaseOLMap {
       return;
     }
 
-    if (!this.initializedPromise) { // TODO add collection to obliqueCollections?
-      this._defaultCollectionName = obliqueCollection.name;
+    this._loadingCollection = obliqueCollection;
+    if (!this.initializedPromise) {
       return;
     }
-    this._loadingCollection = obliqueCollection;
+
     await this.initializedPromise;
     if (this._loadingCollection !== obliqueCollection) {
       return;
@@ -354,6 +338,10 @@ class Oblique extends BaseOLMap {
    */
   async _setCollection(obliqueCollection, viewpoint) {
     this._loadingCollection = obliqueCollection;
+    this._activeCollectionDestroyedListener();
+    this._activeCollectionDestroyedListener = obliqueCollection.destroyed.addEventListener(() => {
+      this._setCollection(defaultCollection);
+    });
     await obliqueCollection.load();
     const vp = viewpoint || await this.getViewPoint();
     if (this._loadingCollection !== obliqueCollection) {
@@ -399,7 +387,7 @@ class Oblique extends BaseOLMap {
       return null;
     }
 
-    const transformationOptions = { dataProjection: getProjection('EPSG:4326') };
+    const transformationOptions = { dataProjection: wgs84Projection };
     const { coords } = await transformFromImage(image, viewCenter, transformationOptions);
     return this._computeViewpointInternal(coords);
   }
@@ -421,8 +409,9 @@ class Oblique extends BaseOLMap {
 
     const gpInternalProjection = image.transformImage2RealWorld(gpImageCoordinates, image.averageHeight);
 
-    const transfrom = getTransform(image.meta.projection, wgs84Projection.proj);
-    const gpWGS84 = transfrom(gpInternalProjection.slice(0, 2));
+    const transfrom = getTransform(image.meta.projection.proj, wgs84Projection.proj);
+    // getText can return a rich Text Array<string> We do not support this at the moment.
+    const gpWGS84 = transfrom(gpInternalProjection.slice(0, 2), undefined, undefined);
     return this._computeViewpointInternal(gpWGS84);
   }
 
@@ -489,7 +478,7 @@ class Oblique extends BaseOLMap {
     const bl = image.transformImage2RealWorld([extent[0], extent[1]]);
     const ur = image.transformImage2RealWorld([extent[2], extent[3]]);
     const bbox = [bl[0], bl[1], ur[0], ur[1]];
-    const transformedBbox = transformExtent(bbox, image.meta.projection, wgs84Projection.proj);
+    const transformedBbox = transformExtent(bbox, image.meta.projection.proj, wgs84Projection.proj);
     return containsXY(transformedBbox, coords[0], coords[1]);
   }
 
@@ -497,9 +486,9 @@ class Oblique extends BaseOLMap {
    * @returns {ObliqueOptions}
    * @api
    */
-  getConfigObject() {
-    const config = /** @type {ObliqueOptions} */ (super.getConfigObject());
-    const defaultOptions = Oblique.getDefaultOptions();
+  toJSON() {
+    const config = /** @type {ObliqueOptions} */ (super.toJSON());
+    const defaultOptions = ObliqueMap.getDefaultOptions();
 
     if (this.mapChangeEvent === 'movened') {
       config.changeOnMoveEnd = true;
@@ -513,10 +502,6 @@ class Oblique extends BaseOLMap {
       config.switchOnEdge = this.switchEnabled;
     }
 
-    if (this._defaultCollectionName !== defaultOptions.defaultCollectionName) {
-      config.defaultCollectionName = this._defaultCollectionName;
-    }
-
     return config;
   }
 
@@ -528,9 +513,10 @@ class Oblique extends BaseOLMap {
       this._obliqueProvider.destroy();
     }
     this.collectionChanged.destroy();
+    this._activeCollectionDestroyedListener();
     super.destroy();
   }
 }
 
-VcsClassRegistry.registerClass(Oblique.className, Oblique);
-export default Oblique;
+mapClassRegistry.registerClass(ObliqueMap.className, ObliqueMap);
+export default ObliqueMap;

package/src/{vcs/vcm/maps/openlayers.js → map/openlayersMap.js}

@@ -6,8 +6,8 @@ import { boundingExtent, containsXY } from 'ol/extent.js';
 import { parseBoolean } from '@vcsuite/parsers';
 import ViewPoint from '../util/viewpoint.js';
 import BaseOLMap from './baseOLMap.js';
-import VcsMap from './map.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import VcsMap from './vcsMap.js';
+import { mapClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {VcsMapOptions} OpenlayersOptions
@@ -16,17 +16,17 @@ import { VcsClassRegistry } from '../classRegistry.js';
  */
 
 /**
- * Openlayers Map Class (2D map)
+ * OpenlayersMap Map Class (2D map)
  * @class
  * @export
  * @extends {BaseOLMap}
  * @api stable
  */
-class Openlayers extends BaseOLMap {
+class OpenlayersMap extends BaseOLMap {
   /**
    * @type {string}
    */
-  static get className() { return 'vcs.vcm.maps.Openlayers'; }
+  static get className() { return 'OpenlayersMap'; }
 
   /**
    * @returns {OpenlayersOptions}
@@ -44,7 +44,7 @@ class Openlayers extends BaseOLMap {
   constructor(options) {
     super(options);
 
-    const defaultOptions = Openlayers.getDefaultOptions();
+    const defaultOptions = OpenlayersMap.getDefaultOptions();
 
     /** @type {boolean} */
     this.fixedNorthOrientation = parseBoolean(options.fixedNorthOrientation, defaultOptions.fixedNorthOrientation);
@@ -87,7 +87,8 @@ class Openlayers extends BaseOLMap {
     size.width = viewport.offsetWidth || 1;
     const aspectRatio = size.width / size.height;
     const fovy = Math.atan(Math.tan(fov * 0.5) / aspectRatio) * 2.0;
-    const latlon = toLatLon(coord.slice(0, 2));
+    // error in TransformFunction type definition, remove undefined after openlayer fixed the type
+    const latlon = toLatLon(coord.slice(0, 2), undefined, undefined);
     const metersPerUnit = view.getProjection().getMetersPerUnit();
 
     const resolution = view.getResolution();
@@ -129,7 +130,8 @@ class Openlayers extends BaseOLMap {
       coords = viewpoint.cameraPosition.slice(0, 2);
     }
     const { distance } = viewpoint;
-    const center = fromLatLon(coords);
+    // error in TransformFunction type definition, remove undefined after openlayer fixed the type
+    const center = fromLatLon(coords, undefined, undefined);
 
     const fov = Math.PI / 3.0;
     const viewport = this.olMap.getViewport();
@@ -180,7 +182,8 @@ class Openlayers extends BaseOLMap {
     const toLatLon = getTransform(view.getProjection(), 'EPSG:4326');
     const topLeft = [extent[0], extent[3]];
     const bottomRight = [extent[2], extent[1]];
-    const bbox = [toLatLon(topLeft), toLatLon(bottomRight)];
+    // error in TransformFunction type definition, remove undefined after openlayer fixed the type
+    const bbox = [toLatLon(topLeft, undefined, undefined), toLatLon(bottomRight, undefined, undefined)];
 
     return containsXY(boundingExtent(bbox), coords[0], coords[1]);
   }
@@ -189,10 +192,10 @@ class Openlayers extends BaseOLMap {
    * @returns {OpenlayersOptions}
    * @api
    */
-  getConfigObject() {
-    const config = /** @type {OpenlayersOptions} */ (super.getConfigObject());
+  toJSON() {
+    const config = /** @type {OpenlayersOptions} */ (super.toJSON());
 
-    const defaultOptions = Openlayers.getDefaultOptions();
+    const defaultOptions = OpenlayersMap.getDefaultOptions();
     if (this.fixedNorthOrientation !== defaultOptions.fixedNorthOrientation) {
       config.fixedNorthOrientation = this.fixedNorthOrientation;
     }
@@ -201,5 +204,5 @@ class Openlayers extends BaseOLMap {
   }
 }
 
-VcsClassRegistry.registerClass(Openlayers.className, Openlayers);
-export default Openlayers;
+mapClassRegistry.registerClass(OpenlayersMap.className, OpenlayersMap);
+export default OpenlayersMap;

package/src/{vcs/vcm/maps/map.js → map/vcsMap.js}

@@ -1,11 +1,11 @@
 import { v4 as uuidv4 } from 'uuid';
 import { check, checkMaybe } from '@vcsuite/check';
-import VcsObject from '../object.js';
+import VcsObject from '../vcsObject.js';
 import LayerCollection from '../util/layerCollection.js';
 import MapState from './mapState.js';
 import { vcsLayerName } from '../layer/layerSymbols.js';
-import VcsEvent from '../event/vcsEvent.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import VcsEvent from '../vcsEvent.js';
+import { mapClassRegistry } from '../classRegistry.js';
 
 /**
  * @namespace maps
@@ -44,7 +44,7 @@ const specificLayerImpl = {};
  * @api stable
  */
 class VcsMap extends VcsObject {
-  static get className() { return 'vcs.vcm.maps.VcsMap'; }
+  static get className() { return 'VcsMap'; }
 
   static get specificLayerImpl() { return specificLayerImpl; }
 
@@ -101,17 +101,9 @@ class VcsMap extends VcsObject {
      * @type {Array<Function>}
      * @private
      */
-    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._collectionListeners = [];
+
+    this._setLayerCollectionListeners();
 
     /** @type {boolean} */
     this.initialized = false;
@@ -221,6 +213,29 @@ class VcsMap extends VcsObject {
         l.mapActivated(this);
       });
     }
+
+    this._setLayerCollectionListeners();
+  }
+
+  /**
+   * @private
+   */
+  _setLayerCollectionListeners() {
+    this._collectionListeners.forEach((cb) => {
+      cb();
+    });
+
+    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);
+      }),
+    ];
   }
 
   /**
@@ -415,7 +430,7 @@ class VcsMap extends VcsObject {
 
   // eslint-disable-next-line jsdoc/require-returns-check
   /**
-   * Returns the most precise viewpoint possible in Oblique.
+   * Returns the most precise viewpoint possible in ObliqueMap.
    * @api
    * @returns {Promise<import("@vcmap/core").ViewPoint|null>}
    */
@@ -425,7 +440,7 @@ class VcsMap extends VcsObject {
   }
 
   /**
-   * Returns an approximate viewpoint in Oblique, not requesting terrain.
+   * Returns an approximate viewpoint in ObliqueMap, not requesting terrain.
    * @api
    * @returns {import("@vcmap/core").ViewPoint|null}
    */
@@ -464,8 +479,8 @@ class VcsMap extends VcsObject {
    * @returns {VcsMapOptions}
    * @api
    */
-  getConfigObject() {
-    const config = /** @type {VcsMapOptions} */ (super.getConfigObject());
+  toJSON() {
+    const config = /** @type {VcsMapOptions} */ (super.toJSON());
     if (this.fallbackMap) {
       config.fallbackMap = this.fallbackMap;
     }
@@ -507,5 +522,5 @@ class VcsMap extends VcsObject {
   }
 }
 
-VcsClassRegistry.registerClass(VcsMap.className, VcsMap);
+mapClassRegistry.registerClass(VcsMap.className, VcsMap);
 export default VcsMap;

package/src/oblique/defaultObliqueCollection.js

@@ -0,0 +1,62 @@
+import ObliqueCollection from './obliqueCollection.js';
+import ObliqueImage from './obliqueImage.js';
+import ObliqueImageMeta from './obliqueImageMeta.js';
+import { ObliqueViewDirection } from './obliqueViewDirection.js';
+import { mercatorProjection } from '../util/projection.js';
+
+const defaultMeta = new ObliqueImageMeta({
+  name: 'defaultObliqueMeta',
+  size: [512, 512],
+  tileSize: [512, 512],
+  tileResolution: [1],
+  projection: mercatorProjection,
+  format: 'png',
+  url: '',
+});
+
+/**
+ * @type {symbol}
+ * @private
+ */
+export const isDefaultImageSymbol = Symbol('isDefaultImage');
+
+/**
+ * This is a special oblique collection wich is shown, if no other oblique collection is set on an ObliqueMap map.
+ * It will render a single image which indicates that no images can be loaded.
+ * @class
+ * @extends {ObliqueCollection}
+ */
+class DefaultObliqueCollection extends ObliqueCollection {
+  constructor() {
+    super({});
+  }
+
+  /**
+   * @param {import("ol/coordinate").Coordinate} mercatorCoordinate
+   * @param {ObliqueViewDirection} viewDirection
+   * @returns {ObliqueImage}
+   */
+  // eslint-disable-next-line no-unused-vars
+  getImageForCoordinate(mercatorCoordinate, viewDirection) {
+    const groundCoordinates = [
+      [mercatorCoordinate[0] - 100, mercatorCoordinate[1] - 100, 0],
+      [mercatorCoordinate[0] + 100, mercatorCoordinate[1] - 100, 0],
+      [mercatorCoordinate[0] + 100, mercatorCoordinate[1] + 100, 0],
+      [mercatorCoordinate[0] - 100, mercatorCoordinate[1] + 100, 0],
+    ];
+
+    const image = new ObliqueImage({
+      meta: defaultMeta,
+      viewDirection: ObliqueViewDirection.NORTH,
+      viewDirectionAngle: 0,
+      name: this.name,
+      groundCoordinates,
+      centerPointOnGround: mercatorCoordinate,
+    });
+
+    image[isDefaultImageSymbol] = true;
+    return image;
+  }
+}
+
+export default DefaultObliqueCollection;

package/src/{vcs/vcm/oblique → oblique}/helpers.js

@@ -1,11 +1,12 @@
 /* eslint no-underscore-dangle: ["error", { "allow": ["_listeners", "_scopes", "_toRemove"] }] */
 /* eslint-disable no-continue */
 import { boundingExtent, getBottomLeft, getBottomRight, getTopLeft, getTopRight } from 'ol/extent.js';
-import { get as getProjection, transform } from 'ol/proj.js';
+import { transform } from 'ol/proj.js';
 import { Cartesian2 } from '@vcmap/cesium';
-import { ObliqueViewDirection } from './ObliqueViewDirection.js';
+import { ObliqueViewDirection } from './obliqueViewDirection.js';
 import { getHeightFromTerrainProvider } from '../layer/terrainHelpers.js';
 import { cartesian2DDistance } from '../util/math.js';
+import { mercatorProjection, wgs84Projection } from '../util/projection.js';
 
 /**
  * @type {import("@vcmap/cesium").Cartesian2}
@@ -292,7 +293,7 @@ export function transformCWIFC(inputOrigin, inputTarget, originIsImage, coordina
 /**
  * @typedef {Object} ImageTransformationOptions
  * @property {boolean|undefined} [dontUseTerrain]
- * @property {import("ol/proj/Projection").default|undefined} [dataProjection] - the projection of the input/output coordinates, assumes image source projection
+ * @property {import("@vcmap/core").Projection|undefined} [dataProjection] - the projection of the input/output coordinates, assumes image source projection
  * @property {number|undefined} [terrainErrorThreshold=1] - the transformToWorld process iterativly calculates a new Height Value from the terrainProvider until the difference to the new height value is smaller
  * @property {number|undefined} [terrainErrorCountThreshold=3] - how often the  transformToWorld process iterativly calculates a new Height Value from the terrainProvider
  * @api
@@ -313,8 +314,8 @@ export function transformToImage(image, worldCoordinate, options = {}) {
     gpInternalCoordinates = worldCoordinate;
   } else {
     gpInternalCoordinates = options.dataProjection ?
-      transform(worldCoordinate, options.dataProjection, image.meta.projection) :
-      transform(worldCoordinate, 'EPSG:3857', image.meta.projection);
+      transform(worldCoordinate, options.dataProjection.proj, image.meta.projection.proj) :
+      transform(worldCoordinate, mercatorProjection.proj, image.meta.projection.proj);
   }
 
   function useAverageHeight() {
@@ -369,14 +370,14 @@ function pickTerrain(pickTerrainOptions) {
     count,
     height,
   } = pickTerrainOptions;
-  const wgs84Projection = getProjection('EPSG:4326');
+
   return getHeightFromTerrainProvider(image.meta.terrainProvider, [worldCoordinate])
     .then(([worldCoordinateWithHeights]) => {
       if (worldCoordinateWithHeights[2] != null) {
         const newWorldCoords = transform(
           image.transformImage2RealWorld(imageCoordinate, worldCoordinateWithHeights[2]),
-          image.meta.projection,
-          wgs84Projection,
+          image.meta.projection.proj,
+          wgs84Projection.proj,
         );
         newWorldCoords[2] = worldCoordinateWithHeights[2];
         if (
@@ -406,11 +407,10 @@ function pickTerrain(pickTerrainOptions) {
  * @export
  */
 export async function transformFromImage(image, imageCoordinate, options = {}) {
-  const wgs84Projection = getProjection('EPSG:4326');
   const initialWorldCoords = transform(
     image.transformImage2RealWorld(imageCoordinate, image.averageHeight),
-    image.meta.projection,
-    wgs84Projection,
+    image.meta.projection.proj,
+    wgs84Projection.proj,
   );
 
   const terrainErrorThreshold = options.terrainErrorThreshold || 1;
@@ -430,8 +430,8 @@ export async function transformFromImage(image, imageCoordinate, options = {}) {
   }
 
   coordsObj.coords = options.dataProjection ?
-    transform(coordsObj.coords, wgs84Projection, options.dataProjection) :
-    transform(coordsObj.coords, wgs84Projection, getProjection('EPSG:3857'));
+    transform(coordsObj.coords, wgs84Projection.proj, options.dataProjection.proj) :
+    transform(coordsObj.coords, wgs84Projection.proj, mercatorProjection.proj);
   return coordsObj;
 }
 
@@ -453,31 +453,3 @@ export function hasSameOrigin(url) {
   const uri = new URL(url);
   return currentUri.host.toLowerCase() === uri.host.toLocaleLowerCase();
 }
-
-/**
- * destroys a cesium Event Emitter, (removes all listeners)
- * @param {import("@vcmap/cesium").Event} cesiumEvent
- */
-export function destroyCesiumEvent(cesiumEvent) {
-  // @ts-ignore
-  for (let i = 0; i < cesiumEvent._listeners.length; i++) {
-    // @ts-ignore
-    cesiumEvent._listeners[i] = undefined;
-  }
-  // @ts-ignore
-  for (let i = 0; i < cesiumEvent._scopes.length; i++) {
-    // @ts-ignore
-    cesiumEvent._scopes[i] = undefined;
-  }
-  // @ts-ignore
-  for (let i = 0; i < cesiumEvent._toRemove.length; i++) {
-    // @ts-ignore
-    cesiumEvent._toRemove[i] = undefined;
-  }
-  // @ts-ignore
-  cesiumEvent._listeners.length = 0;
-  // @ts-ignore
-  cesiumEvent._scopes.length = 0;
-  // @ts-ignore
-  cesiumEvent._toRemove.length = 0;
-}