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

package/src/{vcs/vcm/layer/vectorTile.js → layer/vectorTileLayer.js}

@@ -1,21 +1,21 @@
 import Style from 'ol/style/Style.js';
 import { parseInteger } from '@vcsuite/parsers';
-import CesiumMap from '../maps/cesium.js';
-import VectorRasterTileCesium from './cesium/vectorRasterTileCesium.js';
-import Openlayers from '../maps/openlayers.js';
-import VectorTileOpenlayers from './openlayers/vectorTileOpenlayers.js';
+import CesiumMap from '../map/cesiumMap.js';
+import VectorRasterTileCesiumImpl from './cesium/vectorRasterTileCesiumImpl.js';
+import OpenlayersMap from '../map/openlayersMap.js';
+import VectorTileOpenlayersImpl from './openlayers/vectorTileOpenlayersImpl.js';
 import FeatureLayer from './featureLayer.js';
-import VectorStyleItem, { defaultVectorStyle } from '../util/style/vectorStyleItem.js';
+import VectorStyleItem, { defaultVectorStyle } from '../style/vectorStyleItem.js';
 import VectorProperties from './vectorProperties.js';
-import DeclarativeStyleItem from '../util/style/declarativeStyleItem.js';
+import DeclarativeStyleItem from '../style/declarativeStyleItem.js';
 import { FeatureVisibilityAction, globalHidden, hidden, highlighted } from './featureVisibility.js';
 import { getStylesArray } from '../util/featureconverter/convert.js';
 import { vcsLayerName } from './layerSymbols.js';
-import TileProviderFeatureProvider from '../util/featureProvider/tileProviderFeatureProvider.js';
-import tileProviderFactory from './tileProvider/tileProviderFactory.js';
+import TileProviderFeatureProvider from '../featureProvider/tileProviderFeatureProvider.js';
 import { getGenericFeatureFromClickedObject } from './vectorHelpers.js';
 import { originalFeatureSymbol } from './vectorSymbols.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { getObjectFromClassRegistry, layerClassRegistry, tileProviderClassRegistry } from '../classRegistry.js';
+import TileProvider from './tileProvider/tileProvider.js';
 
 /**
  * synchronizes featureVisibility Symbols on the feature;
@@ -44,7 +44,7 @@ function synchronizeFeatureVisibility(featureVisibility, globalHider, feature) {
 
 /**
  * @typedef {FeatureLayerOptions} VectorTileOptions
- * @property {TileProviderOptions} tileProvider
+ * @property {TileProviderOptions|import("@vcmap/core").TileProvider} tileProvider
  * @property {VectorStyleItemOptions|import("@vcmap/core").VectorStyleItem|undefined} highlightStyle
  * @property {VectorPropertiesOptions|undefined} vectorProperties
  * @property {number|undefined} minLevel used to restrict the zoom level visibility (minlevel does not allow rendering above tileProvider baseLevel)
@@ -67,18 +67,17 @@ function synchronizeFeatureVisibility(featureVisibility, globalHider, feature) {
  */
 
 /**
- * VectorTile Layer for tiled vector Data. Can be connected to data with a TileProvider
+ * VectorTileLayer Layer for tiled vector Data. Can be connected to data with a TileProvider
  * @class
- * @export
  * @extends {FeatureLayer}
  * @api stable
  */
-class VectorTile extends FeatureLayer {
+class VectorTileLayer extends FeatureLayer {
   /**
    * @readonly
    * @returns {string}
    */
-  static get className() { return 'vcs.vcm.layer.VectorTile'; }
+  static get className() { return 'VectorTileLayer'; }
 
   /**
    * @returns {VectorTileOptions}
@@ -103,10 +102,10 @@ class VectorTile extends FeatureLayer {
 
     this._supportedMaps = [
       CesiumMap.className,
-      Openlayers.className,
+      OpenlayersMap.className,
     ];
 
-    const defaultOptions = VectorTile.getDefaultOptions();
+    const defaultOptions = VectorTileLayer.getDefaultOptions();
 
     /** @type {VectorStyleItem} */
     this.highlightStyle = /** @type {undefined} */ (defaultOptions.highlightStyle);
@@ -132,17 +131,13 @@ class VectorTile extends FeatureLayer {
       ...options.vectorProperties,
     });
 
-    /**
-     * @type {TileProviderOptions}
-     * @private
-     */
-    this._tileProviderOptions = options.tileProvider;
-
     /**
      * @type {import("@vcmap/core").TileProvider}
      * @api
      */
-    this.tileProvider = undefined;
+    this.tileProvider = options.tileProvider instanceof TileProvider ? // XXX this now throws if not passing in a tileProvider.
+      options.tileProvider :
+      getObjectFromClassRegistry(tileProviderClassRegistry, options.tileProvider);
 
     /**
      * @type {number|undefined}
@@ -160,7 +155,7 @@ class VectorTile extends FeatureLayer {
      * @type {Array<Function>}
      * @private
      */
-    this._featureVisibilityListener = [];
+    this._featureVisibilityListeners = [];
 
     /**
      * @type {Function}
@@ -187,21 +182,19 @@ class VectorTile extends FeatureLayer {
    * @returns {Promise<void>}
    */
   async initialize() {
-    await super.initialize();
-    if (!this.tileProvider) {
-      this.tileProvider = await tileProviderFactory(this._tileProviderOptions);
-      // this.tileProvider = await tileProviderFactory(this._tileProviderOptions);
+    if (!this.initialized) {
       this._tileLoadEventListener =
         this.tileProvider.tileLoadedEvent.addEventListener(event => this._handleTileLoaded(event));
       this._vectorPropertiesChangedListener =
         this.vectorProperties.propertyChanged.addEventListener(() => {
           this.reload();
         });
-      this.featureProvider = new TileProviderFeatureProvider(this.name, {
+      this.featureProvider = new TileProviderFeatureProvider(this.name, { // XXX this overwrites
         tileProvider: this.tileProvider,
         vectorProperties: this.vectorProperties,
       });
     }
+    await super.initialize();
   }
 
 
@@ -261,15 +254,24 @@ class VectorTile extends FeatureLayer {
   }
 
   /**
-   *
-   * @returns {Array<Function>}
+   * @param {import("@vcmap/core").GlobalHider} globalHider
+   */
+  setGlobalHider(globalHider) {
+    super.setGlobalHider(globalHider);
+    this._setupFeatureVisibilityHandlers();
+  }
+
+  /**
+   * Sets up listeners for featureVisibility and global hider
    * @private
    */
   _setupFeatureVisibilityHandlers() {
     if (!this.tileProvider.trackFeaturesToTiles) {
-      return [];
+      return;
     }
-    return [
+    this._featureVisibilityListeners.forEach((cb) => { cb(); });
+
+    this._featureVisibilityListeners = [
       this.featureVisibility.changed.addEventListener(({ action, ids }) => {
         const tileIdsChanged = new Set();
         ids.forEach((id) => {
@@ -296,8 +298,10 @@ class VectorTile extends FeatureLayer {
         });
         this.updateTiles([...tileIdsChanged]);
       }),
+    ];
 
-      this.globalHider.changed.addEventListener(({ action, ids }) => {
+    if (this.globalHider) {
+      this._featureVisibilityListeners.push(this.globalHider.changed.addEventListener(({ action, ids }) => {
         const tileIdsChanged = new Set();
         ids.forEach((id) => {
           const tileIds = this.tileProvider.featureIdToTileIds.get(id);
@@ -318,8 +322,8 @@ class VectorTile extends FeatureLayer {
           }
         });
         this.updateTiles([...tileIdsChanged]);
-      }),
-    ];
+      }));
+    }
   }
 
   /**
@@ -375,16 +379,16 @@ class VectorTile extends FeatureLayer {
   /**
    * @inheritDoc
    * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<VectorRasterTileCesium|VectorTileOpenlayers>}
+   * @returns {Array<VectorRasterTileCesiumImpl|VectorTileOpenlayersImpl>}
    */
   createImplementationsForMap(map) {
     if (map instanceof CesiumMap) {
-      return [new VectorRasterTileCesium(map, this.getImplementationOptions())];
+      return [new VectorRasterTileCesiumImpl(map, this.getImplementationOptions())];
     }
 
-    if (map instanceof Openlayers) {
+    if (map instanceof OpenlayersMap) {
       return [
-        new VectorTileOpenlayers(map, this.getImplementationOptions()),
+        new VectorTileOpenlayersImpl(map, this.getImplementationOptions()),
       ];
     }
 
@@ -392,7 +396,7 @@ class VectorTile extends FeatureLayer {
   }
 
   /**
-   * @param {(Reference|DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem|string)=} styleOptions
+   * @param {(DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem)=} styleOptions
    * @param {VectorStyleItem=} defaultStyle
    * @returns {import("@vcmap/core").StyleItem}
    */
@@ -407,8 +411,8 @@ class VectorTile extends FeatureLayer {
    */
   async activate() {
     await super.activate();
-    this._featureVisibilityListener = this._setupFeatureVisibilityHandlers();
-    if (this.tileProvider.trackFeaturesToTiles) {
+    this._setupFeatureVisibilityHandlers();
+    if (this.tileProvider.trackFeaturesToTiles && this.globalHider) {
       this.tileProvider.forEachFeature((feature) => {
         synchronizeFeatureVisibility(this.featureVisibility, this.globalHider, feature);
       });
@@ -421,7 +425,7 @@ class VectorTile extends FeatureLayer {
    */
   deactivate() {
     super.deactivate();
-    this._featureVisibilityListener.forEach((cb) => { cb(); });
+    this._featureVisibilityListeners.forEach((cb) => { cb(); });
   }
 
   /**
@@ -429,7 +433,7 @@ class VectorTile extends FeatureLayer {
    * @api
    */
   destroy() {
-    this._featureVisibilityListener.forEach((cb) => { cb(); });
+    this._featureVisibilityListeners.forEach((cb) => { cb(); });
     super.destroy();
     this._tileLoadEventListener();
     if (this.featureProvider) {
@@ -448,9 +452,9 @@ class VectorTile extends FeatureLayer {
    * @inheritDoc
    * @returns {VectorTileOptions}
    */
-  getConfigObject() {
-    const config = /** @type {VectorTileOptions} */ (super.getConfigObject());
-    const defaultOptions = VectorTile.getDefaultOptions();
+  toJSON() {
+    const config = /** @type {VectorTileOptions} */ (super.toJSON());
+    const defaultOptions = VectorTileLayer.getDefaultOptions();
 
     if (this._maxLevel !== defaultOptions.maxLevel) {
       config.maxLevel = this._maxLevel;
@@ -466,15 +470,12 @@ class VectorTile extends FeatureLayer {
     }
 
     if (this.tileProvider) {
-      const tileProviderConfig = this.tileProvider.getConfigObject();
-      config.tileProvider = tileProviderConfig;
-    } else if (this._tileProviderOptions) {
-      config.tileProvider = this._tileProviderOptions;
+      config.tileProvider = this.tileProvider.toJSON();
     }
 
     return config;
   }
 }
 
-VcsClassRegistry.registerClass(VectorTile.className, VectorTile);
-export default VectorTile;
+layerClassRegistry.registerClass(VectorTileLayer.className, VectorTileLayer);
+export default VectorTileLayer;

package/src/{vcs/vcm/layer/wfs.js → layer/wfsLayer.js}

@@ -1,8 +1,8 @@
 import WFSFormat from 'ol/format/WFS.js';
-import axios from 'axios';
-import Vector from './vector.js';
+import VectorLayer from './vectorLayer.js';
 import Projection from '../util/projection.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { layerClassRegistry } from '../classRegistry.js';
+import { requestJson } from '../util/fetch.js';
 
 /**
  * @typedef {VectorOptions} WFSOptions
@@ -14,21 +14,20 @@ import { VcsClassRegistry } from '../classRegistry.js';
  */
 
 /**
- * WFS Vector Layer
+ * WfsLayer VectorLayer Layer
  * @class
- * @export
- * @extends {Vector}
+ * @extends {VectorLayer}
  * @api
  */
-class WFS extends Vector {
-  static get className() { return 'vcs.vcm.layer.WFS'; }
+class WFSLayer extends VectorLayer {
+  static get className() { return 'WFSLayer'; }
 
   /**
    * @returns {WFSOptions}
    */
   static getDefaultOptions() {
     return {
-      ...Vector.getDefaultOptions(),
+      ...VectorLayer.getDefaultOptions(),
       featureType: [],
       featureNS: '',
       featurePrefix: '',
@@ -40,7 +39,7 @@ class WFS extends Vector {
    * @param {WFSOptions} options
    */
   constructor(options) {
-    const proj = new Projection(options.projection).getConfigObject();
+    const proj = new Projection(options.projection).toJSON();
     proj.alias = [`http://www.opengis.net/gml/srs/epsg.xml#${/** @type {string} */ (proj.epsg).match(/\d+/)[0]}`];
     options.projection = proj;
     super(options);
@@ -116,14 +115,14 @@ class WFS extends Vector {
           ...this.getFeaturesOptions,
         }));
       const postData = new XMLSerializer().serializeToString(requestDocument);
-      this._dataFetchedPromise = axios.post(this.url, postData, {
+      this._dataFetchedPromise = requestJson(this.url, {
+        method: 'POST',
         headers: {
           'Content-Type': 'application/text+xml',
         },
+        body: JSON.stringify(postData),
       })
-        .then((response) => {
-          this._parseWFSData(response.data);
-        })
+        .then(data => this._parseWFSData(data))
         .catch((err) => {
           this.getLogger().info(`Could not send request for loading layer content (${err.message})`);
           return Promise.reject(err);
@@ -131,8 +130,8 @@ class WFS extends Vector {
 
       return this._dataFetchedPromise;
     }
-    this.getLogger().warning('Could not load WFS layer, no url is set');
-    return Promise.reject(new Error('missing url in WFS layer'));
+    this.getLogger().warning('Could not load WFSLayer layer, no url is set');
+    return Promise.reject(new Error('missing url in WFSLayer layer'));
   }
 
   /**
@@ -148,8 +147,8 @@ class WFS extends Vector {
    * @inheritDoc
    * @returns {WFSOptions}
    */
-  getConfigObject() {
-    const config = /** @type {WFSOptions} */ (super.getConfigObject());
+  toJSON() {
+    const config = /** @type {WFSOptions} */ (super.toJSON());
 
     config.featureType = this.featureType.slice();
     config.featureNS = this.featureNS;
@@ -161,5 +160,5 @@ class WFS extends Vector {
   }
 }
 
-VcsClassRegistry.registerClass(WFS.className, WFS);
-export default WFS;
+layerClassRegistry.registerClass(WFSLayer.className, WFSLayer);
+export default WFSLayer;

package/src/{vcs/vcm/layer → layer}/wmsHelpers.js

@@ -33,7 +33,7 @@ export function getWMSSource(options) {
   const maxZoom = options.maxLevel + 1;
   const resolutions = [];
   for (let z = 0; z < maxZoom; ++z) {
-    // generate resolutions and matrixIds arrays for options WMTS
+    // generate resolutions and matrixIds arrays for options WmtsLayer
     resolutions.push(size / (2 ** z));
   }
   const tilingOptions = {

package/src/{vcs/vcm/layer/wms.js → layer/wmsLayer.js}

@@ -1,13 +1,13 @@
 import { check } from '@vcsuite/check';
 import { parseBoolean } from '@vcsuite/parsers';
 import RasterLayer from './rasterLayer.js';
-import WMSFeatureProvider from '../util/featureProvider/wmsFeatureProvider.js';
-import CesiumMap from '../maps/cesium.js';
-import WMSCesium from './cesium/wmsCesium.js';
-import Openlayers from '../maps/openlayers.js';
-import WMSOpenlayers from './openlayers/wmsOpenlayers.js';
+import WMSFeatureProvider from '../featureProvider/wmsFeatureProvider.js';
+import CesiumMap from '../map/cesiumMap.js';
+import WmsCesiumImpl from './cesium/wmsCesiumImpl.js';
+import OpenlayersMap from '../map/openlayersMap.js';
+import WmsOpenlayersImpl from './openlayers/wmsOpenlayersImpl.js';
 import Extent from '../util/extent.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {RasterLayerImplementationOptions} WMSImplementationOptions
@@ -30,14 +30,13 @@ import { VcsClassRegistry } from '../classRegistry.js';
  */
 
 /**
- * WMS layer for Cesium and Openlayers
+ * WmsLayer layer for Cesium and OpenlayersMap
  * @class
- * @export
  * @extends {RasterLayer}
  * @api stable
  */
-class WMS extends RasterLayer {
-  static get className() { return 'vcs.vcm.layer.WMS'; }
+class WMSLayer extends RasterLayer {
+  static get className() { return 'WMSLayer'; }
 
   /**
    * @returns {WMSOptions}
@@ -59,7 +58,7 @@ class WMS extends RasterLayer {
    */
   constructor(options) {
     super(options);
-    const defaultOptions = WMS.getDefaultOptions();
+    const defaultOptions = WMSLayer.getDefaultOptions();
 
     /** @type {string} */
     this.version = options.version || defaultOptions.version;
@@ -97,7 +96,7 @@ class WMS extends RasterLayer {
     this._featureInfoOptions = options.featureInfo || defaultOptions.featureInfo;
     this._supportedMaps = [
       CesiumMap.className,
-      Openlayers.className,
+      OpenlayersMap.className,
     ];
   }
 
@@ -156,19 +155,19 @@ class WMS extends RasterLayer {
 
   /**
    * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<WMSCesium|WMSOpenlayers>}
+   * @returns {Array<WmsCesiumImpl|WmsOpenlayersImpl>}
    */
   createImplementationsForMap(map) {
     if (map instanceof CesiumMap) {
-      return [new WMSCesium(map, this.getImplementationOptions())];
-    } else if (map instanceof Openlayers) {
-      return [new WMSOpenlayers(map, this.getImplementationOptions())];
+      return [new WmsCesiumImpl(map, this.getImplementationOptions())];
+    } else if (map instanceof OpenlayersMap) {
+      return [new WmsOpenlayersImpl(map, this.getImplementationOptions())];
     }
     return [];
   }
 
   /**
-   * Sets the layers to request from the WMS
+   * Sets the layers to request from the WmsLayer
    * @param {string|Array<string>} layers - a layer name or an array of layer names
    * @returns {Promise<void>}
    * @api stable
@@ -192,9 +191,9 @@ class WMS extends RasterLayer {
   /**
    * @returns {WMSOptions}
    */
-  getConfigObject() {
-    const config = /** @type {WMSOptions} */ (super.getConfigObject());
-    const defaultOptions = WMS.getDefaultOptions();
+  toJSON() {
+    const config = /** @type {WMSOptions} */ (super.toJSON());
+    const defaultOptions = WMSLayer.getDefaultOptions();
 
     if (this.parameters.LAYERS) {
       config.layers = this.parameters.LAYERS;
@@ -229,7 +228,7 @@ class WMS extends RasterLayer {
     }
 
     if (this.featureProvider && this.featureProvider instanceof WMSFeatureProvider) {
-      const featureInfoConfig = this.featureProvider.getConfigObject();
+      const featureInfoConfig = this.featureProvider.toJSON();
       if (this.tileSize[0] === featureInfoConfig.tileSize[0] || this.tileSize[1] === featureInfoConfig.tileSize[1]) {
         delete featureInfoConfig.tileSize;
       }
@@ -266,5 +265,5 @@ class WMS extends RasterLayer {
   }
 }
 
-VcsClassRegistry.registerClass(WMS.className, WMS);
-export default WMS;
+layerClassRegistry.registerClass(WMSLayer.className, WMSLayer);
+export default WMSLayer;

package/src/{vcs/vcm/layer/wmts.js → layer/wmtsLayer.js}

@@ -1,11 +1,11 @@
 import { parseInteger } from '@vcsuite/parsers';
 import { getLogger } from '@vcsuite/logger';
 import RasterLayer from './rasterLayer.js';
-import Openlayers from '../maps/openlayers.js';
-import CesiumMap from '../maps/cesium.js';
-import WMTSOpenlayers from './openlayers/wmtsOpenlayers.js';
-import WMTSCesium from './cesium/wmtsCesium.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import OpenlayersMap from '../map/openlayersMap.js';
+import CesiumMap from '../map/cesiumMap.js';
+import WmtsOpenlayersImpl from './openlayers/wmtsOpenlayersImpl.js';
+import WmtsCesiumImpl from './cesium/wmtsCesiumImpl.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {RasterLayerOptions} WMTSOptions
@@ -47,7 +47,7 @@ function getMatrixIds(matrixIds, maxLevel, prefix) {
     if (matrixIds.length === (maxLevel + 1)) {
       return matrixIds;
     } else {
-      getLogger('vcs.vcm.layer.cesium.WMTSCesium')
+      getLogger('WmtsCesiumImpl')
         .log('matrixIds must have the same length as maxLevel');
     }
   }
@@ -58,14 +58,13 @@ function getMatrixIds(matrixIds, maxLevel, prefix) {
 
 
 /**
- * WMTS layer
+ * WmtsLayer layer
  * @class
- * @export
  * @extends {RasterLayer}
  * @api stable
  */
-class WMTS extends RasterLayer {
-  static get className() { return 'vcs.vcm.layer.WMTS'; }
+class WMTSLayer extends RasterLayer {
+  static get className() { return 'WMTSLayer'; }
 
   /**
    * @returns {WMTSOptions}
@@ -91,12 +90,12 @@ class WMTS extends RasterLayer {
    * @param {WMTSOptions} options
    */
   constructor(options) {
-    const defaultOptions = WMTS.getDefaultOptions();
+    const defaultOptions = WMTSLayer.getDefaultOptions();
     options.tilingSchema = options.tilingSchema || defaultOptions.tilingSchema;
     super(options);
 
     this._supportedMaps = [
-      Openlayers.className,
+      OpenlayersMap.className,
       CesiumMap.className,
     ];
 
@@ -159,15 +158,15 @@ class WMTS extends RasterLayer {
   /**
    * @inheritDoc
    * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<WMTSOpenlayers|WMTSCesium>}
+   * @returns {Array<WmtsOpenlayersImpl|WmtsCesiumImpl>}
    */
   createImplementationsForMap(map) {
-    if (map instanceof Openlayers) {
-      return [new WMTSOpenlayers(map, this.getImplementationOptions())];
+    if (map instanceof OpenlayersMap) {
+      return [new WmtsOpenlayersImpl(map, this.getImplementationOptions())];
     }
 
     if (map instanceof CesiumMap) {
-      return [new WMTSCesium(map, this.getImplementationOptions())];
+      return [new WmtsCesiumImpl(map, this.getImplementationOptions())];
     }
     return [];
   }
@@ -176,9 +175,9 @@ class WMTS extends RasterLayer {
    * @inheritDoc
    * @returns {WMTSOptions}
    */
-  getConfigObject() {
-    const config = /** @type {WMTSOptions} */ (super.getConfigObject());
-    const defaultOptions = WMTS.getDefaultOptions();
+  toJSON() {
+    const config = /** @type {WMTSOptions} */ (super.toJSON());
+    const defaultOptions = WMTSLayer.getDefaultOptions();
 
     if (this.tilingSchema !== defaultOptions.tilingSchema) {
       config.tilingSchema = this.tilingSchema;
@@ -230,6 +229,6 @@ class WMTS extends RasterLayer {
   }
 }
 
-VcsClassRegistry.registerClass(WMTS.className, WMTS);
-export default WMTS;
+layerClassRegistry.registerClass(WMTSLayer.className, WMTSLayer);
+export default WMTSLayer;
 

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

@@ -2,10 +2,10 @@ import { Cartesian2 } from '@vcmap/cesium';
 import { unByKey } from 'ol/Observable.js';
 import OLMap from 'ol/Map.js';
 import { defaults as defaultInteractions } from 'ol/interaction.js';
-import VcsMap from './map.js';
+import VcsMap from './vcsMap.js';
 import { vcsLayerName } from '../layer/layerSymbols.js';
 import { ModificationKeyType, PointerEventType, PointerKeyType } from '../interaction/interactionType.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { mapClassRegistry } from '../classRegistry.js';
 
 /**
  * @param {import("ol/Collection").default<import("ol/layer/Layer").default>} layers
@@ -32,15 +32,14 @@ export function ensureLayerInCollection(layers, layer, layerCollection) {
 }
 
 /**
- * Openlayers Map base map.
+ * OpenlayersMap Map base map.
  * @class
  * @abstract
  * @api
- * @export
  * @extends {VcsMap}
  */
 class BaseOLMap extends VcsMap {
-  static get className() { return 'vcs.vcm.maps.BaseOLMap'; }
+  static get className() { return 'BaseOLMap'; }
 
   /**
    * @param {VcsMapOptions} options
@@ -253,5 +252,5 @@ class BaseOLMap extends VcsMap {
   }
 }
 
-VcsClassRegistry.registerClass(BaseOLMap.className, BaseOLMap);
+mapClassRegistry.registerClass(BaseOLMap.className, BaseOLMap);
 export default BaseOLMap;