@vcmap/core 5.0.0-rc.2 → 5.0.0-rc.20

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

@@ -1,12 +1,12 @@
-import { ImagerySplitDirection, WebMercatorTilingScheme, GeographicTilingScheme, Cartographic } from '@vcmap/cesium';
+import { SplitDirection, WebMercatorTilingScheme, GeographicTilingScheme, Cartographic } from '@vcmap/cesium';
 import { getBottomLeft, getBottomRight, getTopLeft, getTopRight } from 'ol/extent.js';
 
 import { parseInteger, parseNumberRange, parseEnumValue } from '@vcsuite/parsers';
 import { wgs84Projection } from '../util/projection.js';
 import Layer from './layer.js';
-import VcsEvent from '../event/vcsEvent.js';
+import VcsEvent from '../vcsEvent.js';
 import Extent from '../util/extent.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {LayerOptions} RasterLayerOptions
@@ -24,14 +24,14 @@ import { VcsClassRegistry } from '../classRegistry.js';
  * @property {number} maxLevel
  * @property {string} tilingSchema
  * @property {number} opacity
- * @property {import("@vcmap/cesium").ImagerySplitDirection} splitDirection
+ * @property {import("@vcmap/cesium").SplitDirection} splitDirection
  * @property {Extent|undefined} extent
  */
 
 /**
  * @typedef {import("@vcmap/core").LayerImplementation<import("@vcmap/core").VcsMap>} RasterLayerImplementation
  * @property {function(number):void} updateOpacity
- * @property {function(import("@vcmap/cesium").ImagerySplitDirection):void} updateSplitDirection
+ * @property {function(import("@vcmap/cesium").SplitDirection):void} updateSplitDirection
  * @api
  */
 
@@ -41,7 +41,6 @@ import { VcsClassRegistry } from '../classRegistry.js';
  * @api
  * @property {string} GEOGRAPHIC
  * @property {string} MERCATOR
- * @export
  */
 export const TilingScheme = {
   GEOGRAPHIC: 'geographic',
@@ -112,13 +111,12 @@ export function calculateMinLevel(extent, tilingScheme, maxLevel, minLevel = 0)
  * This abstract class allows for automatic loading scheme determination
  * for raster layers
  * @class
- * @export
  * @extends {Layer}
  * @implements {SplitLayer}
  * @abstract
  */
 class RasterLayer extends Layer {
-  static get className() { return 'vcs.vcm.layer.RasterLayer'; }
+  static get className() { return 'RasterLayer'; }
 
   /**
    * @returns {RasterLayerOptions}
@@ -166,18 +164,18 @@ class RasterLayer extends Layer {
      */
     this._opacity = parseNumberRange(options.opacity, defaultOptions.opacity, 0.0, 1.0);
 
-    /** @type {import("@vcmap/cesium").ImagerySplitDirection} */
-    this._splitDirection = ImagerySplitDirection.NONE;
+    /** @type {import("@vcmap/cesium").SplitDirection} */
+    this._splitDirection = SplitDirection.NONE;
 
     if (options.splitDirection) {
       this._splitDirection = options.splitDirection === 'left' ?
-        ImagerySplitDirection.LEFT :
-        ImagerySplitDirection.RIGHT;
+        SplitDirection.LEFT :
+        SplitDirection.RIGHT;
     }
 
     /**
      * raised if the split direction changes, is passed the split direction as its only argument
-     * @type {VcsEvent<import("@vcmap/cesium").ImagerySplitDirection>}
+     * @type {VcsEvent<import("@vcmap/cesium").SplitDirection>}
      * @api
      */
     this.splitDirectionChanged = new VcsEvent();
@@ -186,12 +184,12 @@ class RasterLayer extends Layer {
   /**
    * The split directions of this layer
    * @api
-   * @type {import("@vcmap/cesium").ImagerySplitDirection}
+   * @type {import("@vcmap/cesium").SplitDirection}
    */
   get splitDirection() { return this._splitDirection; }
 
   /**
-   * @param {import("@vcmap/cesium").ImagerySplitDirection} direction
+   * @param {import("@vcmap/cesium").SplitDirection} direction
    */
   set splitDirection(direction) {
     if (direction !== this._splitDirection) {
@@ -272,8 +270,8 @@ class RasterLayer extends Layer {
       config.opacity = this.opacity;
     }
 
-    if (this._splitDirection !== ImagerySplitDirection.NONE) {
-      config.splitDirection = this._splitDirection === ImagerySplitDirection.RIGHT ?
+    if (this._splitDirection !== SplitDirection.NONE) {
+      config.splitDirection = this._splitDirection === SplitDirection.RIGHT ?
         'right' :
         'left';
     }
@@ -290,5 +288,5 @@ class RasterLayer extends Layer {
   }
 }
 
-VcsClassRegistry.registerClass(RasterLayer.className, RasterLayer);
+layerClassRegistry.registerClass(RasterLayer.className, RasterLayer);
 export default RasterLayer;

package/src/{vcs/vcm/layer/singleImage.js → layer/singleImageLayer.js}

@@ -1,11 +1,12 @@
 import { check } from '@vcsuite/check';
 import RasterLayer from './rasterLayer.js';
-import SingleImageCesium from './cesium/singleImageCesium.js';
-import SingleImageOpenlayers from './openlayers/singleImageOpenlayers.js';
-import CesiumMap from '../maps/cesium.js';
-import Openlayers from '../maps/openlayers.js';
+import SingleImageCesiumImpl from './cesium/singleImageCesiumImpl.js';
+import SingleImageOpenlayersImpl from './openlayers/singleImageOpenlayersImpl.js';
+import CesiumMap from '../map/cesiumMap.js';
+import OpenlayersMap from '../map/openlayersMap.js';
 import Extent from '../util/extent.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { layerClassRegistry } from '../classRegistry.js';
+import { wgs84Projection } from '../util/projection.js';
 
 /**
  * @typedef {RasterLayerOptions} SingleImageOptions
@@ -19,14 +20,13 @@ import { VcsClassRegistry } from '../classRegistry.js';
  */
 
 /**
- * Image layer for Cesium and Openlayers
+ * Image layer for Cesium and OpenlayersMap
  * @class
- * @export
  * @extends {RasterLayer}
  * @api stable
  */
-class SingleImage extends RasterLayer {
-  static get className() { return 'vcs.vcm.layer.SingleImage'; }
+class SingleImageLayer extends RasterLayer {
+  static get className() { return 'SingleImageLayer'; }
 
   /**
    * @returns {SingleImageOptions}
@@ -43,21 +43,21 @@ class SingleImage extends RasterLayer {
    */
   constructor(options) {
     super(options);
-    const defaultOptions = SingleImage.getDefaultOptions();
+    const defaultOptions = SingleImageLayer.getDefaultOptions();
     /** @type {string} */
     this.credit = options.credit || defaultOptions.credit;
 
     if (!this.extent.isValid()) {
       this.getLogger().warning(`layer ${this.name} was constructed with an invalid extent, defaulting to global extent`);
       this.extent = new Extent({
-        epsg: 'EPSG:4326',
+        projection: wgs84Projection.toJSON(),
         coordinates: [-180, -90, 180, 90],
       });
     }
 
     this._supportedMaps = [
       CesiumMap.className,
-      Openlayers.className,
+      OpenlayersMap.className,
     ];
   }
 
@@ -73,13 +73,13 @@ class SingleImage extends RasterLayer {
 
   /**
    * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<SingleImageOpenlayers|SingleImageCesium>}
+   * @returns {Array<SingleImageOpenlayersImpl|SingleImageCesiumImpl>}
    */
   createImplementationsForMap(map) {
     if (map instanceof CesiumMap) {
-      return [new SingleImageCesium(map, this.getImplementationOptions())];
-    } else if (map instanceof Openlayers) {
-      return [new SingleImageOpenlayers(map, this.getImplementationOptions())];
+      return [new SingleImageCesiumImpl(map, this.getImplementationOptions())];
+    } else if (map instanceof OpenlayersMap) {
+      return [new SingleImageOpenlayersImpl(map, this.getImplementationOptions())];
     }
     return [];
   }
@@ -115,5 +115,5 @@ class SingleImage extends RasterLayer {
   }
 }
 
-VcsClassRegistry.registerClass(SingleImage.className, SingleImage);
-export default SingleImage;
+layerClassRegistry.registerClass(SingleImageLayer.className, SingleImageLayer);
+export default SingleImageLayer;

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

@@ -1,6 +1,6 @@
-import { CesiumTerrainProvider, Cartographic, Cartesian2, sampleTerrainMostDetailed, sampleTerrain } from '@vcmap/cesium';
+import { CesiumTerrainProvider, Cartographic, Cartesian2, sampleTerrainMostDetailed } from '@vcmap/cesium';
 import { getTransform } from 'ol/proj.js';
-import Projection, { wgs84Projection } from '../util/projection.js';
+import { wgs84Projection } from '../util/projection.js';
 
 /**
  * @typedef {Object} TerrainProviderOptions
@@ -26,7 +26,7 @@ export function getTerrainProviderForUrl(options) {
   }
   let terrainProvider = terrainProviders[options.url];
   if ((options.requestVertexNormals !== undefined &&
-    terrainProvider.requestVertexNormals !== options.requestVertexNormals) ||
+      terrainProvider.requestVertexNormals !== options.requestVertexNormals) ||
     (options.requestWaterMask !== undefined &&
       terrainProvider.requestWaterMask !== options.requestWaterMask)) {
     terrainProviders[options.url] = new CesiumTerrainProvider(options);
@@ -35,52 +35,18 @@ export function getTerrainProviderForUrl(options) {
   return terrainProvider;
 }
 
-/**
- * @param {import("@vcmap/cesium").CesiumTerrainProvider} terrainProvider
- * @param {Array<import("@vcmap/cesium").Cartographic>} positions
- * @returns {Promise<Array<import("@vcmap/cesium").Cartographic>>}
- */
-export function sampleCesiumTerrainMostDetailed(terrainProvider, positions) {
-  return new Promise((resolve, reject) => {
-    sampleTerrainMostDetailed(terrainProvider, positions)
-      .then((updatedPositions) => {
-        resolve(updatedPositions);
-      }, reject);
-  });
-}
-
-/**
- * updates the height of the positions in place.
- * @param {import("@vcmap/cesium").CesiumTerrainProvider} terrainProvider
- * @param {number} level
- * @param {Array<import("@vcmap/cesium").Cartographic>} positions
- * @returns {Promise<Array<import("@vcmap/cesium").Cartographic>>}
- */
-export function sampleCesiumTerrain(terrainProvider, level, positions) {
-  return new Promise((resolve, reject) => {
-    sampleTerrain(terrainProvider, level, positions)
-      .then((updatedPositions) => {
-        resolve(updatedPositions);
-      }, reject);
-  });
-}
-
 /**
  * changes input coordinate Array in place, new height can also be accessed by coordinates[x][2]
  * @param {import("@vcmap/cesium").CesiumTerrainProvider} terrainProvider
  * @param {Array<import("ol/coordinate").Coordinate>} coordinates
- * @param {(import("@vcmap/core").Projection|import("ol/proj/Projection").default)=} optSourceProjection - if input is not WGS84
+ * @param {import("@vcmap/core").Projection=} optSourceProjection - if input is not WGS84
  * @param {Array<import("ol/coordinate").Coordinate>=} result
  * @returns {Promise<Array<import("ol/coordinate").Coordinate>>}
  */
 export function getHeightFromTerrainProvider(terrainProvider, coordinates, optSourceProjection, result) {
-  const usedProj = optSourceProjection instanceof Projection ?
-    optSourceProjection.proj :
-    optSourceProjection;
-
-  const sourceTransformer = usedProj ?
+  const sourceTransformer = optSourceProjection ?
     getTransform(
-      usedProj,
+      optSourceProjection.proj,
       wgs84Projection.proj,
     ) :
     null;
@@ -93,15 +59,13 @@ export function getHeightFromTerrainProvider(terrainProvider, coordinates, optSo
   });
 
   const outArray = result || coordinates.map(c => c.slice());
-  return new Promise((resolve, reject) => {
-    sampleTerrainMostDetailed(terrainProvider, positions)
-      .then((updatedPositions) => {
-        updatedPositions.forEach((position, index) => {
-          outArray[index][2] = position.height || 0;
-        });
-        resolve(outArray);
-      }, reject);
-  });
+  return sampleTerrainMostDetailed(terrainProvider, positions)
+    .then((updatedPositions) => {
+      updatedPositions.forEach((position, index) => {
+        outArray[index][2] = position.height || 0;
+      });
+      return outArray;
+    });
 }
 
 /**

package/src/{vcs/vcm/layer/terrain.js → layer/terrainLayer.js}

@@ -1,9 +1,9 @@
 import { parseBoolean } from '@vcsuite/parsers';
 import Layer from './layer.js';
 import { getHeightFromTerrainProvider, getTerrainProviderForUrl } from './terrainHelpers.js';
-import CesiumMap from '../maps/cesium.js';
-import TerrainCesium from './cesium/terrainCesium.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import CesiumMap from '../map/cesiumMap.js';
+import TerrainCesiumImpl from './cesium/terrainCesiumImpl.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {LayerOptions} TerrainOptions
@@ -21,12 +21,11 @@ import { VcsClassRegistry } from '../classRegistry.js';
 /**
  * represents a terrain layer.
  * @class
- * @export
  * @extends {Layer}
  * @api stable
  */
-class Terrain extends Layer {
-  static get className() { return 'vcs.vcm.layer.Terrain'; }
+class TerrainLayer extends Layer {
+  static get className() { return 'TerrainLayer'; }
 
   /**
    * @returns {TerrainOptions}
@@ -44,7 +43,7 @@ class Terrain extends Layer {
    */
   constructor(options) {
     super(options);
-    const defaultOptions = Terrain.getDefaultOptions();
+    const defaultOptions = TerrainLayer.getDefaultOptions();
 
     this._supportedMaps = [
       CesiumMap.className,
@@ -77,11 +76,11 @@ class Terrain extends Layer {
   /**
    * @inheritDoc
    * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<TerrainCesium>}
+   * @returns {Array<TerrainCesiumImpl>}
    */
   createImplementationsForMap(map) {
     if (map instanceof CesiumMap) {
-      return [new TerrainCesium(map, this.getImplementationOptions())];
+      return [new TerrainCesiumImpl(map, this.getImplementationOptions())];
     }
     return [];
   }
@@ -106,7 +105,7 @@ class Terrain extends Layer {
    */
   toJSON() {
     const config = /** @type {TerrainOptions} */ (super.toJSON());
-    const defaultOptions = Terrain.getDefaultOptions();
+    const defaultOptions = TerrainLayer.getDefaultOptions();
 
     if (this.requestVertexNormals !== defaultOptions.requestVertexNormals) {
       config.requestVertexNormals = this.requestVertexNormals;
@@ -118,5 +117,5 @@ class Terrain extends Layer {
   }
 }
 
-VcsClassRegistry.registerClass(Terrain.className, Terrain);
-export default Terrain;
+layerClassRegistry.registerClass(TerrainLayer.className, TerrainLayer);
+export default TerrainLayer;

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

@@ -1,7 +1,7 @@
-import CesiumTilesetCesium from './cesium/cesiumTilesetCesium.js';
+import CesiumTilesetCesiumImpl from './cesium/cesiumTilesetCesiumImpl.js';
 
 /**
- * @param {CesiumTilesetCesium} impl
+ * @param {CesiumTilesetCesiumImpl} impl
  * @param {number=} timeout
  * @returns {Promise<void>}
  */
@@ -26,13 +26,13 @@ function waitForImplTilesLoaded(impl, timeout) {
 }
 
 /**
- * @param {import("@vcmap/core").CesiumTileset|import("@vcmap/core").FeatureStore} layer
+ * @param {import("@vcmap/core").CesiumTilesetLayer|import("@vcmap/core").FeatureStoreLayer} layer
  * @param {number=} timeout
  * @returns {Promise<void>}
  */
 export async function tiledLayerLoaded(layer, timeout) {
-  const impls = /** @type {Array<CesiumTilesetCesium>} */
-    (layer.getImplementations().filter(i => i instanceof CesiumTilesetCesium));
+  const impls = /** @type {Array<CesiumTilesetCesiumImpl>} */
+    (layer.getImplementations().filter(i => i instanceof CesiumTilesetCesiumImpl));
   if (!layer.active || impls.every(i => i.cesium3DTileset.tilesLoaded)) {
     return;
   }

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

@@ -1,9 +1,10 @@
-import axios from 'axios';
 import MVT from 'ol/format/MVT.js';
 import Feature from 'ol/Feature.js';
 import { getCenter } from 'ol/extent.js';
 import TileProvider, { rectangleToExtent } from './tileProvider.js';
 import { getURL } from './urlTemplateTileProvider.js';
+import { requestArrayBuffer } from '../../util/fetch.js';
+import { tileProviderClassRegistry } from '../../classRegistry.js';
 
 /**
  * @typedef {TileProviderOptions} MVTTileProviderOptions
@@ -17,7 +18,6 @@ import { getURL } from './urlTemplateTileProvider.js';
  *
  * @class
  * @extends {TileProvider}
- * @export
  * @api
  */
 class MVTTileProvider extends TileProvider {
@@ -25,7 +25,7 @@ class MVTTileProvider extends TileProvider {
    * @readonly
    * @returns {string}
    */
-  static get className() { return 'vcs.vcm.layer.tileProvider.MVTTileProvider'; }
+  static get className() { return 'MVTTileProvider'; }
 
   /**
    * @returns {MVTTileProviderOptions}
@@ -62,6 +62,26 @@ class MVTTileProvider extends TileProvider {
     this._MVTFormat = new MVT({ featureClass: Feature });
   }
 
+  /**
+   * @type {string}
+   */
+  get locale() {
+    return super.locale;
+  }
+
+  /**
+   * sets the locale and clears the Cache if the URL is a locale aware Object.
+   * @param {string} value
+   */
+  set locale(value) {
+    if (this.locale !== value) {
+      super.locale = value;
+      if (this.url.includes('{locale}')) {
+        this.clearCache();
+      }
+    }
+  }
+
   /**
    * @inheritDoc
    * @param {number} x
@@ -71,12 +91,12 @@ class MVTTileProvider 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 url = getURL(this.url, x, y, z, rectangle, this.locale);
     const extent = rectangleToExtent(rectangle);
     const center = getCenter(extent);
-    const response = await axios.get(url, { responseType: 'arraybuffer' });
+    const data = await requestArrayBuffer(url);
     const features = /** @type {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} */
-      (this._MVTFormat.readFeatures(response.data));
+      (this._MVTFormat.readFeatures(data));
     const sx = ((extent[2] - extent[0]) / 4096);
     const sy = -((extent[3] - extent[1]) / 4096);
     features.forEach((feature) => {
@@ -99,6 +119,23 @@ class MVTTileProvider extends TileProvider {
     });
     return features;
   }
+
+  /**
+   * @returns {MVTTileProviderOptions}
+   */
+  toJSON() {
+    const config = /** @type {MVTTileProviderOptions} */ (super.toJSON());
+
+    if (this.url) {
+      config.url = this.url;
+    }
+
+    if (this.idProperty) {
+      config.idProperty = this.idProperty;
+    }
+    return config;
+  }
 }
 
 export default MVTTileProvider;
+tileProviderClassRegistry.registerClass(MVTTileProvider.className, MVTTileProvider);

package/src/layer/tileProvider/staticGeojsonTileProvider.js

@@ -0,0 +1,81 @@
+import { parseGeoJSON } from '../geojsonHelpers.js';
+import TileProvider from './tileProvider.js';
+import { requestJson } from '../../util/fetch.js';
+import { tileProviderClassRegistry } from '../../classRegistry.js';
+
+/**
+ * @typedef {TileProviderOptions} StaticGeoJSONTileProviderOptions
+ * @property {string} url - url to the geojson
+ * @api
+ */
+
+/**
+ * Loads the provided geojson url and tiles the content in memory, data is only requested once
+ *
+ * @class
+ * @extends {TileProvider}
+ * @api
+ */
+class StaticGeoJSONTileProvider extends TileProvider {
+  /**
+   * @readonly
+   * @returns {string}
+   */
+  static get className() { return 'StaticGeoJSONTileProvider'; }
+
+  /**
+   * @returns {StaticGeoJSONTileProviderOptions}
+   */
+  static getDefaultOptions() {
+    return {
+      ...TileProvider.getDefaultOptions(),
+      url: undefined,
+      baseLevels: [0],
+    };
+  }
+
+  /**
+   * @param {StaticGeoJSONTileProviderOptions} options
+   */
+  constructor(options) {
+    const defaultOptions = StaticGeoJSONTileProvider.getDefaultOptions();
+    options.baseLevels = defaultOptions.baseLevels;
+    super(options);
+
+    /**
+     * @type {string}
+     */
+    this.url = options.url || defaultOptions.url;
+  }
+
+
+  /**
+   * @inheritDoc
+   * @param {number} x
+   * @param {number} y
+   * @param {number} z
+   * @returns {Promise<Array<import("ol").Feature<import("ol/geom/Geometry").default>>>}
+   */
+  // eslint-disable-next-line no-unused-vars
+  async loader(x, y, z) {
+    const data = await requestJson(this.url);
+    const { features } = parseGeoJSON(data, { dynamicStyle: true });
+    return features;
+  }
+
+  /**
+   * @returns {StaticGeoJSONTileProviderOptions}
+   */
+  toJSON() {
+    const config = /** @type {StaticGeoJSONTileProviderOptions} */ (super.toJSON());
+    delete config.baseLevels;
+
+    if (this.url) {
+      config.url = this.url;
+    }
+    return config;
+  }
+}
+
+export default StaticGeoJSONTileProvider;
+tileProviderClassRegistry.registerClass(StaticGeoJSONTileProvider.className, StaticGeoJSONTileProvider);

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

@@ -1,5 +1,6 @@
 import { v4 as uuidv4 } from 'uuid';
 import RBush from 'rbush';
+import { check } from '@vcsuite/check';
 import { Rectangle, Math as CesiumMath, WebMercatorTilingScheme, Cartographic } from '@vcmap/cesium';
 import LRUCache from 'ol/structs/LRUCache.js';
 import { buffer, createOrUpdateFromCoordinate } from 'ol/extent.js';
@@ -10,8 +11,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
@@ -74,7 +76,6 @@ export function rectangleToExtent(rectangle) {
  *
  * @class
  * @extends {VcsObject}
- * @export
  * @api
  */
 class TileProvider extends VcsObject {
@@ -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}
@@ -176,6 +177,12 @@ class TileProvider extends VcsObject {
      * @api
      */
     this.tileLoadedEvent = new VcsEvent();
+
+    /**
+     * @type {string}
+     * @private
+     */
+    this._locale = 'en';
   }
 
   /**
@@ -188,6 +195,26 @@ class TileProvider extends VcsObject {
     return this._tileCacheSize;
   }
 
+
+  /**
+   * @type {string}
+   */
+  get locale() {
+    return this._locale;
+  }
+
+  /**
+   * sets the locale and reloads the layer the if the URL is a locale aware Object.
+   * @param {string} value
+   */
+  set locale(value) {
+    check(value, String);
+    if (this._locale !== value) {
+      this._locale = value;
+    }
+  }
+
+
   /**
    * @param {number} value
    * @returns {Promise<*>}
@@ -494,7 +521,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.
@@ -538,13 +565,20 @@ class TileProvider extends VcsObject {
       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 +616,4 @@ class TileProvider extends VcsObject {
 }
 
 export default TileProvider;
+tileProviderClassRegistry.registerClass(TileProvider.className, TileProvider);