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

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

@@ -10,8 +10,9 @@ import {
   wgs84Projection,
   wgs84ToMercatorTransformer,
 } from '../../util/projection.js';
-import VcsObject from '../../object.js';
-import VcsEvent from '../../event/vcsEvent.js';
+import VcsObject from '../../vcsObject.js';
+import VcsEvent from '../../vcsEvent.js';
+import { tileProviderClassRegistry } from '../../classRegistry.js';
 
 /**
  * @typedef {Object} tileProviderRTreeEntry
@@ -82,7 +83,7 @@ class TileProvider extends VcsObject {
    * @readonly
    * @returns {string}
    */
-  static get className() { return 'vcs.vcm.layer.tileProvider.TileProvider'; }
+  static get className() { return 'TileProvider'; }
 
   /**
    * @returns {TileProviderOptions}
@@ -494,7 +495,7 @@ class TileProvider extends VcsObject {
   }
 
   /**
-   * Public API to load features from a source (for example a rest API, or WFS)
+   * Public API to load features from a source (for example a rest API, or WfsLayer)
    *
    * Can be used to write custom TileProvider to provide an interface to a "feature Source"
    * Can also be used to manipulate the features, for example setting an ID Prefix or filter the features.
@@ -530,21 +531,28 @@ class TileProvider extends VcsObject {
    * @returns {TileProviderOptions}
    * @api
    */
-  getConfigObject() {
-    const config = /** @type {TileProviderOptions} */ (super.getConfigObject());
+  toJSON() {
+    const config = /** @type {TileProviderOptions} */ (super.toJSON());
     const defaultOptions = TileProvider.getDefaultOptions();
 
     if (defaultOptions.tileCacheSize !== this.tileCacheSize) {
       config.tileCacheSize = this.tileCacheSize;
     }
 
-    if (defaultOptions.baseLevels !== this.baseLevels) {
+    if (!(
+      this.baseLevels.length === defaultOptions.baseLevels.length &&
+      this.baseLevels.every(level => defaultOptions.baseLevels.includes(level))
+    )) {
       config.baseLevels = this.baseLevels.slice();
     }
 
     if (defaultOptions.trackFeaturesToTiles !== this.trackFeaturesToTiles) {
       config.trackFeaturesToTiles = this.trackFeaturesToTiles;
     }
+
+    if (defaultOptions.allowTileAggregation !== this.allowTileAggregation) {
+      config.allowTileAggregation = this.allowTileAggregation;
+    }
     return config;
   }
 
@@ -582,3 +590,4 @@ class TileProvider extends VcsObject {
 }
 
 export default TileProvider;
+tileProviderClassRegistry.registerClass(TileProvider.className, TileProvider);

package/src/{vcs/vcm/layer → layer}/tileProvider/urlTemplateTileProvider.js

@@ -1,8 +1,9 @@
-import axios from 'axios';
 import { Math as CesiumMath, Rectangle } from '@vcmap/cesium';
 import { parseGeoJSON } from '../geojsonHelpers.js';
 import TileProvider from './tileProvider.js';
 import { getCurrentLocale } from '../../util/locale.js';
+import { requestJson } from '../../util/fetch.js';
+import { tileProviderClassRegistry } from '../../classRegistry.js';
 
 /**
  * @typedef {TileProviderOptions} URLTemplateTileProviderOptions
@@ -47,7 +48,7 @@ export function getURL(url, x, y, z, tilingExtent) {
 }
 
 /**
- * TileProvider loads GeoJSON from the provided URL. The URL has placeholders:
+ * TileProvider loads GeojsonLayer from the provided URL. The URL has placeholders:
  * the extent in latitude/longitude via: {minx}, {miny}, {maxx}, {maxy}
  * tile Coordinates in x, y, z(level) via:  {x}, {y}, {z}
  * {locale} can be used to request locale aware content.
@@ -62,7 +63,7 @@ class URLTemplateTileProvider extends TileProvider {
    * @readonly
    * @returns {string}
    */
-  static get className() { return 'vcs.vcm.layer.tileProvider.URLTemplateTileProvider'; }
+  static get className() { return 'URLTemplateTileProvider'; }
 
   /**
    * @returns {URLTemplateTileProviderOptions}
@@ -97,10 +98,24 @@ class URLTemplateTileProvider extends TileProvider {
   async loader(x, y, z) {
     const rectangle = this.tilingScheme.tileXYToRectangle(x, y, z);
     const url = getURL(this.url, x, y, z, rectangle);
-    const response = await axios.get(url);
-    const { features } = parseGeoJSON(response.data, { dynamicStyle: true });
+    const data = await requestJson(url);
+    const { features } = parseGeoJSON(data, { dynamicStyle: true });
     return features;
   }
+
+  /**
+   * @returns {URLTemplateTileProviderOptions}
+   */
+  toJSON() {
+    const config = /** @type {URLTemplateTileProviderOptions} */ (super.toJSON());
+
+    if (this.url) {
+      config.url = this.url;
+    }
+
+    return config;
+  }
 }
 
 export default URLTemplateTileProvider;
+tileProviderClassRegistry.registerClass(URLTemplateTileProvider.className, URLTemplateTileProvider);

package/src/{vcs/vcm/layer/tms.js → layer/tmsLayer.js}

@@ -1,9 +1,9 @@
 import RasterLayer from './rasterLayer.js';
-import Openlayers from '../maps/openlayers.js';
-import CesiumMap from '../maps/cesium.js';
-import TMSOpenlayers from './openlayers/tmsOpenlayers.js';
-import TMSCesium from './cesium/tmsCesium.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import OpenlayersMap from '../map/openlayersMap.js';
+import CesiumMap from '../map/cesiumMap.js';
+import TmsOpenlayersImpl from './openlayers/tmsOpenlayersImpl.js';
+import TmsCesiumImpl from './cesium/tmsCesiumImpl.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {RasterLayerOptions} TMSOptions
@@ -19,14 +19,14 @@ import { VcsClassRegistry } from '../classRegistry.js';
  */
 
 /**
- * TMS Layer
+ * TmsLayer Layer
  * @class
  * @export
  * @extends {RasterLayer}
  * @api stable
  */
-class TMS extends RasterLayer {
-  static get className() { return 'vcs.vcm.layer.TMS'; }
+class TMSLayer extends RasterLayer {
+  static get className() { return 'TMSLayer'; }
 
   /**
    * @returns {TMSOptions}
@@ -44,12 +44,12 @@ class TMS extends RasterLayer {
    * @param {TMSOptions} options
    */
   constructor(options) {
-    const defaultOptions = TMS.getDefaultOptions();
+    const defaultOptions = TMSLayer.getDefaultOptions();
     options.tilingSchema = options.tilingSchema || defaultOptions.tilingSchema;
     super(options);
 
     this._supportedMaps = [
-      Openlayers.className,
+      OpenlayersMap.className,
       CesiumMap.className,
     ];
 
@@ -75,15 +75,15 @@ class TMS extends RasterLayer {
   /**
    * @inheritDoc
    * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<TMSOpenlayers|TMSCesium>}
+   * @returns {Array<TmsOpenlayersImpl|TmsCesiumImpl>}
    */
   createImplementationsForMap(map) {
-    if (map instanceof Openlayers) {
-      return [new TMSOpenlayers(map, this.getImplementationOptions())];
+    if (map instanceof OpenlayersMap) {
+      return [new TmsOpenlayersImpl(map, this.getImplementationOptions())];
     }
 
     if (map instanceof CesiumMap) {
-      return [new TMSCesium(map, this.getImplementationOptions())];
+      return [new TmsCesiumImpl(map, this.getImplementationOptions())];
     }
     return [];
   }
@@ -92,9 +92,9 @@ class TMS extends RasterLayer {
    * @inheritDoc
    * @returns {TMSOptions}
    */
-  getConfigObject() {
-    const config = /** @type {TMSOptions} */ (super.getConfigObject());
-    const defaultOptions = TMS.getDefaultOptions();
+  toJSON() {
+    const config = /** @type {TMSOptions} */ (super.toJSON());
+    const defaultOptions = TMSLayer.getDefaultOptions();
 
     if (this.tilingSchema !== defaultOptions.tilingSchema) {
       config.tilingSchema = this.tilingSchema;
@@ -117,5 +117,5 @@ class TMS extends RasterLayer {
   }
 }
 
-VcsClassRegistry.registerClass(TMS.className, TMS);
-export default TMS;
+layerClassRegistry.registerClass(TMSLayer.className, TMSLayer);
+export default TMSLayer;

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

@@ -6,7 +6,7 @@ import { FeatureVisibilityAction } from './featureVisibility.js';
 import Projection from '../util/projection.js';
 import { getHeightInfo } from '../util/featureconverter/featureconverterHelper.js';
 import { getFlatCoordinatesFromGeometry } from '../util/geometryHelpers.js';
-import { createOrUpdateFromGeometry, createOrUpdateFromHeightInfo } from '../util/featureconverter/extent3d.js';
+import Extent3D from '../util/featureconverter/extent3D.js';
 
 /**
  * Added to ol.source.Vector to determine, when the source has last had an update to its features visibility.
@@ -128,7 +128,7 @@ export function synchronizeFeatureVisibilityWithSource(featureVisibility, source
 
 /**
  * @param {VectorClickedObject} object
- * @param {import("@vcmap/core").Vector|import("@vcmap/core").VectorTile} layer
+ * @param {import("@vcmap/core").VectorLayer|import("@vcmap/core").VectorTileLayer} layer
  * @returns {?GenericFeature}
  */
 export function getGenericFeatureFromClickedObject(object, layer) {
@@ -170,9 +170,9 @@ export function getGenericFeatureFromClickedObject(object, layer) {
     const coordinates = getFlatCoordinatesFromGeometry(geometry);
     const heightInfo = getHeightInfo(object, layer.vectorProperties, coordinates);
     if (heightInfo.perPositionHeight || heightInfo.extruded) {
-      const extent = createOrUpdateFromGeometry(geometry);
-      createOrUpdateFromHeightInfo(heightInfo, extent);
-      heightOffset = extent[5];
+      const extent = Extent3D.fromGeometry(geometry);
+      extent.extendWithHeightInfo(heightInfo);
+      heightOffset = extent.maxZ;
     }
     // edge case points are rendered depending on the terrain, so we set relativeToGround to true.
     // In this case the heightAboveGroundAdjustment is also just an Offset.

package/src/{vcs/vcm/layer/vector.js → layer/vectorLayer.js}

@@ -6,9 +6,9 @@ import { check } from '@vcsuite/check';
 import { parseBoolean } from '@vcsuite/parsers';
 import Projection, { getDefaultProjection, mercatorProjection } from '../util/projection.js';
 import Layer, { vcsMetaVersion } from './layer.js';
-import VectorStyleItem, { defaultVectorStyle, vectorStyleSymbol } from '../util/style/vectorStyleItem.js';
-import DeclarativeStyleItem from '../util/style/declarativeStyleItem.js';
-import writeStyle from '../util/style/writeStyle.js';
+import VectorStyleItem, { defaultVectorStyle, vectorStyleSymbol } from '../style/vectorStyleItem.js';
+import DeclarativeStyleItem from '../style/declarativeStyleItem.js';
+import writeStyle from '../style/writeStyle.js';
 import {
   alreadyTransformedToImage,
   alreadyTransformedToMercator,
@@ -19,16 +19,16 @@ import {
 import Extent from '../util/extent.js';
 import VectorProperties from './vectorProperties.js';
 import FeatureLayer from './featureLayer.js';
-import Openlayers from '../maps/openlayers.js';
-import VectorOpenlayers from './openlayers/vectorOpenlayers.js';
-import VectorCesium from './cesium/vectorCesium.js';
-import VectorOblique from './oblique/vectorOblique.js';
-import Oblique from '../maps/oblique.js';
-import CesiumMap from '../maps/cesium.js';
+import OpenlayersMap from '../map/openlayersMap.js';
+import VectorOpenlayersImpl from './openlayers/vectorOpenlayersImpl.js';
+import VectorCesiumImpl from './cesium/vectorCesiumImpl.js';
+import VectorObliqueImpl from './oblique/vectorObliqueImpl.js';
+import ObliqueMap from '../map/obliqueMap.js';
+import CesiumMap from '../map/cesiumMap.js';
 import { originalStyle, updateOriginalStyle } from './featureVisibility.js';
-import StyleItem, { referenceableStyleSymbol, StyleType } from '../util/style/styleItem.js';
+import StyleItem from '../style/styleItem.js';
 import { getGenericFeatureFromClickedObject } from './vectorHelpers.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {FeatureLayerOptions} VectorOptions
@@ -82,18 +82,18 @@ import { VcsClassRegistry } from '../classRegistry.js';
  */
 
 /**
- * Vector Layer for Openlayers, Cesium and Oblique
+ * VectorLayer Layer for OpenlayersMap, Cesium and ObliqueMap
  * @class
  * @export
  * @extends {FeatureLayer}
  * @api stable
  */
-class Vector extends FeatureLayer {
+class VectorLayer extends FeatureLayer {
   /**
    * @readonly
    * @returns {string}
    */
-  static get className() { return 'vcs.vcm.layer.Vector'; }
+  static get className() { return 'VectorLayer'; }
 
   /**
    * @returns {symbol}
@@ -150,11 +150,11 @@ class Vector extends FeatureLayer {
 
     this._supportedMaps = [
       CesiumMap.className,
-      Oblique.className,
-      Openlayers.className,
+      ObliqueMap.className,
+      OpenlayersMap.className,
     ];
 
-    const defaultOptions = Vector.getDefaultOptions();
+    const defaultOptions = VectorLayer.getDefaultOptions();
     /** @type {import("ol/source").Vector<import("ol/geom/Geometry").default>} */
     this.source = new VectorSource({});
 
@@ -213,17 +213,12 @@ class Vector extends FeatureLayer {
     });
 
     let initialStyle = options.style;
-    if (options.activeStyleName) {
-      initialStyle = {
-        type: StyleType.REFERENCE,
-        name: options.activeStyleName,
-      };
-    } else if (options.style instanceof StyleItem) {
-      initialStyle = options.style.getOptions();
+    if (options.style instanceof StyleItem) {
+      initialStyle = options.style.toJSON();
     }
 
     /**
-     * @type {Reference|StyleItemOptions|string}
+     * @type {StyleItemOptions}
      * @private
      */
     this._initialStyle = initialStyle;
@@ -321,30 +316,30 @@ class Vector extends FeatureLayer {
   /**
    * @inheritDoc
    * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<VectorOblique|VectorCesium|VectorOpenlayers>}
+   * @returns {Array<VectorObliqueImpl|VectorCesiumImpl|VectorOpenlayersImpl>}
    */
   createImplementationsForMap(map) {
     if (!this.visibility) {
       return [];
     }
 
-    if (map instanceof Openlayers) {
-      return [new VectorOpenlayers(map, this.getImplementationOptions())];
+    if (map instanceof OpenlayersMap) {
+      return [new VectorOpenlayersImpl(map, this.getImplementationOptions())];
     }
 
     if (map instanceof CesiumMap) {
-      return [new VectorCesium(map, this.getImplementationOptions())];
+      return [new VectorCesiumImpl(map, this.getImplementationOptions())];
     }
 
-    if (map instanceof Oblique) {
-      return [new VectorOblique(map, this.getImplementationOptions())];
+    if (map instanceof ObliqueMap) {
+      return [new VectorObliqueImpl(map, this.getImplementationOptions())];
     }
 
     return [];
   }
 
   /**
-   * @param {(Reference|DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem|string)=} styleOptions
+   * @param {(DeclarativeStyleItemOptions|VectorStyleItemOptions|import("@vcmap/core").StyleItem)=} styleOptions
    * @param {import("@vcmap/core").VectorStyleItem=} defaultStyle
    * @returns {import("@vcmap/core").StyleItem}
    */
@@ -354,7 +349,7 @@ class Vector extends FeatureLayer {
 
   /**
    * sets the style of this layer
-   * @param {import("ol/style/Style").default|import("ol/style/Style").StyleFunction|import("@vcmap/core").StyleItem|string} style
+   * @param {import("ol/style/Style").default|import("ol/style/Style").StyleFunction|import("@vcmap/core").StyleItem} style
    * @param {boolean=} silent
    */
   setStyle(style, silent) {
@@ -453,9 +448,9 @@ class Vector extends FeatureLayer {
         if (this.projection.epsg !== mercatorProjection.epsg) {
           const geometry = feature.getGeometry();
           if (geometry) {
-            if (!geometry[Vector.alreadyTransformedToMercator]) {
+            if (!geometry[VectorLayer.alreadyTransformedToMercator]) {
               geometry.transform(this.projection.proj, mercatorProjection.proj);
-              geometry[Vector.alreadyTransformedToMercator] = true;
+              geometry[VectorLayer.alreadyTransformedToMercator] = true;
             }
           }
         }
@@ -538,7 +533,7 @@ class Vector extends FeatureLayer {
       return metaExtent;
     }
     const extent = new Extent({
-      ...mercatorProjection.getConfigObject(),
+      projection: mercatorProjection.toJSON(),
       coordinates: this.source.getExtent(),
     });
     if (extent.isValid()) {
@@ -573,12 +568,12 @@ class Vector extends FeatureLayer {
   /**
    * @returns {VectorOptions}
    */
-  getConfigObject() {
-    const config = /** @type {VectorOptions} */ (super.getConfigObject());
-    const defaultOptions = Vector.getDefaultOptions();
+  toJSON() {
+    const config = /** @type {VectorOptions} */ (super.toJSON());
+    const defaultOptions = VectorLayer.getDefaultOptions();
 
     if (this.projection.epsg !== getDefaultProjection().epsg) {
-      config.projection = this.projection.getConfigObject();
+      config.projection = this.projection.toJSON();
     }
 
     if (this.maxResolution !== defaultOptions.maxResolution) {
@@ -594,9 +589,7 @@ class Vector extends FeatureLayer {
     }
 
     if (this.highlightStyle) {
-      config.highlightStyle = this.highlightStyle[referenceableStyleSymbol] ?
-        this.highlightStyle.getReference() :
-        this.highlightStyle.getOptions();
+      config.highlightStyle = this.highlightStyle.toJSON();
     }
 
     if (this.isDynamic !== defaultOptions.isDynamic) {
@@ -608,8 +601,6 @@ class Vector extends FeatureLayer {
       config.vectorProperties = vectorPropertiesConfig;
     }
 
-    // XXX missing style
-
     return config;
   }
 
@@ -628,5 +619,5 @@ class Vector extends FeatureLayer {
   }
 }
 
-VcsClassRegistry.registerClass(Vector.className, Vector);
-export default Vector;
+layerClassRegistry.registerClass(VectorLayer.className, VectorLayer);
+export default VectorLayer;

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

@@ -3,13 +3,13 @@ import { HeightReference, ClassificationType, NearFarScalar, Cartesian3 } from '
 import { check, checkMaybe } from '@vcsuite/check';
 import { parseBoolean, parseEnumKey, parseNumber, parseInteger } from '@vcsuite/parsers';
 import { getLogger as getLoggerByName } from '@vcsuite/logger';
-import VcsEvent from '../event/vcsEvent.js';
+import VcsEvent from '../vcsEvent.js';
 
 /**
  * @returns {import("@vcsuite/logger").Logger}
  */
 function getLogger() {
-  return getLoggerByName('vcs.vcm.layer.VectorProperties');
+  return getLoggerByName('VectorProperties');
 }
 
 /**
@@ -162,7 +162,7 @@ export function getCartesian3Options(cartesian3) {
 }
 
 /**
- * Properties Collection for Vector Features
+ * Properties Collection for VectorLayer Features
  * @class
  * @export
  * @api stable

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,18 @@ 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 +103,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 +132,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}
@@ -187,21 +183,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();
   }
 
 
@@ -375,16 +369,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 +386,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}
    */
@@ -448,9 +442,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 +460,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;