@vcmap/core 5.0.0-rc.3 → 5.0.0-rc.30

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

@@ -1,6 +1,12 @@
 import { v4 as uuidv4 } from 'uuid';
 import RBush from 'rbush';
-import { Rectangle, Math as CesiumMath, WebMercatorTilingScheme, Cartographic } from '@vcmap/cesium';
+import { check } from '@vcsuite/check';
+import {
+  Rectangle,
+  Math as CesiumMath,
+  WebMercatorTilingScheme,
+  Cartographic,
+} from '@vcmap-cesium/engine';
 import LRUCache from 'ol/structs/LRUCache.js';
 import { buffer, createOrUpdateFromCoordinate } from 'ol/extent.js';
 import { parseBoolean, parseInteger } from '@vcsuite/parsers';
@@ -10,8 +16,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
@@ -33,7 +40,7 @@ for (let i = 0; i < mercatorResolutionsToLevel.length; i++) {
 
 /**
  * transforms cesium geographic rectangle to mercator extent
- * @param {import("@vcmap/cesium").Rectangle} rectangle in wgs84 radians
+ * @param {import("@vcmap-cesium/engine").Rectangle} rectangle in wgs84 radians
  * @returns {import("ol/extent").Extent} extent in mercator
  */
 export function rectangleToExtent(rectangle) {
@@ -68,13 +75,11 @@ export function rectangleToExtent(rectangle) {
  * @api
  */
 
-
 /**
  * TileProvider class
  *
  * @class
  * @extends {VcsObject}
- * @export
  * @api
  */
 class TileProvider extends VcsObject {
@@ -82,7 +87,9 @@ class TileProvider extends VcsObject {
    * @readonly
    * @returns {string}
    */
-  static get className() { return 'vcs.vcm.layer.tileProvider.TileProvider'; }
+  static get className() {
+    return 'TileProvider';
+  }
 
   /**
    * @returns {TileProviderOptions}
@@ -105,7 +112,7 @@ class TileProvider extends VcsObject {
 
     /**
      * Cesium Webmercator TilingScheme
-     * @type {import("@vcmap/cesium").WebMercatorTilingScheme}
+     * @type {import("@vcmap-cesium/engine").WebMercatorTilingScheme}
      * @api
      * @readonly
      */
@@ -115,13 +122,17 @@ class TileProvider extends VcsObject {
      * @type {number}
      * @private
      */
-    this._tileCacheSize = parseInteger(options.tileCacheSize, defaultOptions.tileCacheSize);
-
-
-    const baseLevels = Array.isArray(options.baseLevels) ?
-      options.baseLevels.slice() :
-      defaultOptions.baseLevels.slice();
-    baseLevels.sort((a, b) => { return b - a; });
+    this._tileCacheSize = parseInteger(
+      options.tileCacheSize,
+      defaultOptions.tileCacheSize,
+    );
+
+    const baseLevels = Array.isArray(options.baseLevels)
+      ? options.baseLevels.slice()
+      : defaultOptions.baseLevels.slice();
+    baseLevels.sort((a, b) => {
+      return b - a;
+    });
 
     /**
      * sorted baseLevels, maximumLevel first example: [18,17,16]
@@ -154,13 +165,19 @@ class TileProvider extends VcsObject {
      * @api
      * @readonly
      */
-    this.trackFeaturesToTiles = parseBoolean(options.trackFeaturesToTiles, defaultOptions.trackFeaturesToTiles);
+    this.trackFeaturesToTiles = parseBoolean(
+      options.trackFeaturesToTiles,
+      defaultOptions.trackFeaturesToTiles,
+    );
 
     /**
      * @type {boolean}
      * @api
      */
-    this.allowTileAggregation = parseBoolean(options.allowTileAggregation, defaultOptions.allowTileAggregation);
+    this.allowTileAggregation = parseBoolean(
+      options.allowTileAggregation,
+      defaultOptions.allowTileAggregation,
+    );
 
     /**
      * set of currently loaded featureIds with the corresponding tileIds
@@ -176,6 +193,12 @@ class TileProvider extends VcsObject {
      * @api
      */
     this.tileLoadedEvent = new VcsEvent();
+
+    /**
+     * @type {string}
+     * @private
+     */
+    this._locale = 'en';
   }
 
   /**
@@ -188,6 +211,24 @@ 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<*>}
@@ -255,43 +296,52 @@ class TileProvider extends VcsObject {
    * @private
    */
   _addTilePromiseToCache(featuresPromise, baseLevel, tileId) {
-    const rtreePromise = featuresPromise.then((features) => {
-      features.forEach((feature) => {
-        if (!feature.getId()) {
-          feature.setId(uuidv4());
-        }
+    const rtreePromise = featuresPromise
+      .then((features) => {
+        features.forEach((feature) => {
+          if (!feature.getId()) {
+            feature.setId(uuidv4());
+          }
+        });
+        const rtree = new RBush(features.length);
+        rtree.load(
+          features
+            .map((feature) => {
+              const geometry = feature.getGeometry();
+              if (geometry) {
+                const extent = geometry.getExtent();
+                const item = {
+                  minX: extent[0],
+                  minY: extent[1],
+                  maxX: extent[2],
+                  maxY: extent[3],
+                  value: feature,
+                };
+                return item;
+              }
+              return null;
+            })
+            .filter((item) => item),
+        );
+        this.tileLoadedEvent.raiseEvent({ tileId, rtree });
+        this._trackFeatures(features, tileId);
+        this.rtreeCache.set(tileId, rtree);
+        return rtree;
+      })
+      .catch(() => {
+        // Discussion, do we want to go on on tileLoadFailure ?
+        this.getLogger().warning(`Could not load Tile ${tileId}`);
+        const rtree = new RBush();
+        this.rtreeCache.set(tileId, rtree);
+        return rtree;
       });
-      const rtree = new RBush(features.length);
-      rtree.load(features.map((feature) => {
-        const geometry = feature.getGeometry();
-        if (geometry) {
-          const extent = geometry.getExtent();
-          const item = {
-            minX: extent[0],
-            minY: extent[1],
-            maxX: extent[2],
-            maxY: extent[3],
-            value: feature,
-          };
-          return item;
-        }
-        return null;
-      }).filter(item => item));
-      this.tileLoadedEvent.raiseEvent({ tileId, rtree });
-      this._trackFeatures(features, tileId);
-      this.rtreeCache.set(tileId, rtree);
-      return rtree;
-    }).catch(() => {
-      // Discussion, do we want to go on on tileLoadFailure ?
-      this.getLogger().warning(`Could not load Tile ${tileId}`);
-      const rtree = new RBush();
-      this.rtreeCache.set(tileId, rtree);
-      return rtree;
-    });
 
     this.cache.get(baseLevel).set(tileId, rtreePromise);
     if (this.cache.get(baseLevel).canExpireCache()) {
-      return Promise.all([rtreePromise, this._removeLastTileFromCache(baseLevel)]);
+      return Promise.all([
+        rtreePromise,
+        this._removeLastTileFromCache(baseLevel),
+      ]);
     }
     return rtreePromise;
   }
@@ -309,7 +359,10 @@ class TileProvider extends VcsObject {
         if (rtree) {
           this.rtreeCache.delete(tileIdToRemove);
           setTimeout(() => {
-            this._unTrackFeatures(rtree.all().map(item => item.value), tileIdToRemove);
+            this._unTrackFeatures(
+              rtree.all().map((item) => item.value),
+              tileIdToRemove,
+            );
             rtree.clear();
           }, 0);
         }
@@ -335,7 +388,9 @@ class TileProvider extends VcsObject {
       }
     }
     const baseLevel = this.getBaseLevel(currentLevel);
-    return baseLevel === undefined ? this.baseLevels[this.baseLevels.length - 1] : baseLevel;
+    return baseLevel === undefined
+      ? this.baseLevels[this.baseLevels.length - 1]
+      : baseLevel;
   }
 
   /**
@@ -365,17 +420,25 @@ class TileProvider extends VcsObject {
 
   /**
    * @param {number} baseLevel
-   * @param {import("@vcmap/cesium").Cartographic} tileCenter
+   * @param {import("@vcmap-cesium/engine").Cartographic} tileCenter
    * @returns {Promise<import("rbush").default<tileProviderRTreeEntry>|null>}
    * @private
    */
   async _getRtreeForBaseTile(baseLevel, tileCenter) {
     const baseTile = this.tilingScheme.positionToTileXY(tileCenter, baseLevel);
-    const baseTileCacheKey = this.getCacheKey(baseTile.x, baseTile.y, baseLevel);
+    const baseTileCacheKey = this.getCacheKey(
+      baseTile.x,
+      baseTile.y,
+      baseLevel,
+    );
     if (this.cache.has(baseLevel)) {
       if (!this.cache.get(baseLevel).containsKey(baseTileCacheKey)) {
         const featuresPromise = this.loader(baseTile.x, baseTile.y, baseLevel);
-        this._addTilePromiseToCache(featuresPromise, baseLevel, baseTileCacheKey);
+        this._addTilePromiseToCache(
+          featuresPromise,
+          baseLevel,
+          baseTileCacheKey,
+        );
       }
       return this.cache.get(baseLevel).get(baseTileCacheKey);
     }
@@ -394,16 +457,24 @@ class TileProvider extends VcsObject {
     const extent = createOrUpdateFromCoordinate(coordinate);
     buffer(extent, resolution, extent);
     const wgs84Coordinate = mercatorToWgs84Transformer(coordinate);
-    const cartographic = Cartographic.fromDegrees(wgs84Coordinate[0], wgs84Coordinate[1]);
-    const baseLevel = this.getBaseLevelForResolution(resolution, cartographic.latitude);
+    const cartographic = Cartographic.fromDegrees(
+      wgs84Coordinate[0],
+      wgs84Coordinate[1],
+    );
+    const baseLevel = this.getBaseLevelForResolution(
+      resolution,
+      cartographic.latitude,
+    );
     const rtree = await this._getRtreeForBaseTile(baseLevel, cartographic);
     if (rtree) {
-      const features = rtree.search({
-        minX: extent[0],
-        minY: extent[1],
-        maxX: extent[2],
-        maxY: extent[3],
-      }).map(item => item.value);
+      const features = rtree
+        .search({
+          minX: extent[0],
+          minY: extent[1],
+          maxX: extent[2],
+          maxY: extent[3],
+        })
+        .map((item) => item.value);
       return features;
     }
     return [];
@@ -425,28 +496,45 @@ class TileProvider extends VcsObject {
       const rtree = await this._getRtreeForBaseTile(baseLevel, tileCenter);
       if (rtree) {
         if (level === baseLevel) {
-          return rtree.all().map(item => item.value);
+          return rtree.all().map((item) => item.value);
         } else {
           const extent = rectangleToExtent(rectangle);
-          const features = rtree.search({
-            minX: extent[0],
-            minY: extent[1],
-            maxX: extent[2],
-            maxY: extent[3],
-          }).map(item => item.value);
+          const features = rtree
+            .search({
+              minX: extent[0],
+              minY: extent[1],
+              maxX: extent[2],
+              maxY: extent[3],
+            })
+            .map((item) => item.value);
           return features;
         }
       }
-    } else if (this.allowTileAggregation && (this.baseLevels[this.baseLevels.length - 1] - level) <= 2) {
+    } else if (
+      this.allowTileAggregation &&
+      this.baseLevels[this.baseLevels.length - 1] - level <= 2
+    ) {
       // tile aggregation, only allowed for 2 levels
       const childLevel = level + 1;
       const childNorth = x * 2;
       const childWest = y * 2;
       return [
-        ...await this.getFeaturesForTile(childNorth, childWest, childLevel),
-        ...await this.getFeaturesForTile(childNorth + 1, childWest, childLevel),
-        ...await this.getFeaturesForTile(childNorth + 1, childWest + 1, childLevel),
-        ...await this.getFeaturesForTile(childNorth, childWest + 1, childLevel),
+        ...(await this.getFeaturesForTile(childNorth, childWest, childLevel)),
+        ...(await this.getFeaturesForTile(
+          childNorth + 1,
+          childWest,
+          childLevel,
+        )),
+        ...(await this.getFeaturesForTile(
+          childNorth + 1,
+          childWest + 1,
+          childLevel,
+        )),
+        ...(await this.getFeaturesForTile(
+          childNorth,
+          childWest + 1,
+          childLevel,
+        )),
       ];
     }
     return [];
@@ -462,9 +550,16 @@ class TileProvider extends VcsObject {
   async getFeaturesForExtent(extent, level) {
     let usedLevel = level != null ? level : this.baseLevels[0];
     usedLevel = this.getBaseLevel(usedLevel);
-    const [minx, miny, maxx, maxy] = extent.getCoordinatesInProjection(wgs84Projection);
-    const topLeft = this.tilingScheme.positionToTileXY(Cartographic.fromDegrees(minx, maxy), usedLevel);
-    const bottomRight = this.tilingScheme.positionToTileXY(Cartographic.fromDegrees(maxx, miny), usedLevel);
+    const [minx, miny, maxx, maxy] =
+      extent.getCoordinatesInProjection(wgs84Projection);
+    const topLeft = this.tilingScheme.positionToTileXY(
+      Cartographic.fromDegrees(minx, maxy),
+      usedLevel,
+    );
+    const bottomRight = this.tilingScheme.positionToTileXY(
+      Cartographic.fromDegrees(maxx, miny),
+      usedLevel,
+    );
     const tileCoordinates = [];
     for (let { x } = topLeft; x <= bottomRight.x; x++) {
       for (let { y } = topLeft; y <= bottomRight.y; y++) {
@@ -472,14 +567,15 @@ class TileProvider extends VcsObject {
       }
     }
 
-    const features = await Promise.all(tileCoordinates.map(([x, y]) => this.getFeaturesForTile(x, y, usedLevel)));
-    const mercatorExtent = extent.getCoordinatesInProjection(mercatorProjection);
-    return features
-      .flat()
-      .filter((f) => {
-        const geometry = f.getGeometry();
-        return geometry && geometry.intersectsExtent(mercatorExtent);
-      });
+    const features = await Promise.all(
+      tileCoordinates.map(([x, y]) => this.getFeaturesForTile(x, y, usedLevel)),
+    );
+    const mercatorExtent =
+      extent.getCoordinatesInProjection(mercatorProjection);
+    return features.flat().filter((f) => {
+      const geometry = f.getGeometry();
+      return geometry && geometry.intersectsExtent(mercatorExtent);
+    });
   }
 
   /**
@@ -489,12 +585,15 @@ class TileProvider extends VcsObject {
    */
   forEachFeature(callback) {
     this.rtreeCache.forEach((rtree) => {
-      rtree.all().map(item => item.value).forEach(callback);
+      rtree
+        .all()
+        .map((item) => item.value)
+        .forEach(callback);
     });
   }
 
   /**
-   * 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 +637,24 @@ 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 +692,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,8 @@
-import axios from 'axios';
-import { Math as CesiumMath, Rectangle } from '@vcmap/cesium';
+import { Math as CesiumMath, Rectangle } from '@vcmap-cesium/engine';
 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
@@ -13,16 +13,17 @@ import { getCurrentLocale } from '../../util/locale.js';
 /**
  * replaces {x}, {y}, {z} with the x, y, z tiling coordinates
  * replaces {minx}, {miny}, {maxx}, {maxy} with extent of the tile if tilingExtent is provided
- * replaces {locale} with the current locale
+ * replaces {locale} with the given locale
  *
  * @param {string} url
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {import("@vcmap/cesium").Rectangle=} tilingExtent
+ * @param {import("@vcmap-cesium/engine").Rectangle=} tilingExtent
+ * @param {string=} locale
  * @returns {string}
  */
-export function getURL(url, x, y, z, tilingExtent) {
+export function getURL(url, x, y, z, tilingExtent, locale = 'en') {
   let replacedURL = url;
   if (tilingExtent) {
     const southwest = Rectangle.southwest(tilingExtent);
@@ -42,19 +43,18 @@ export function getURL(url, x, y, z, tilingExtent) {
     .replace(/\{x\}/, String(x))
     .replace(/\{y\}/, String(y))
     .replace(/\{z\}/, String(z))
-    .replace(/\{locale\}/, getCurrentLocale());
+    .replace(/\{locale\}/, locale);
   return replacedURL;
 }
 
 /**
- * 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.
  *
  * @class
  * @extends {TileProvider}
- * @export
  * @api
  */
 class URLTemplateTileProvider extends TileProvider {
@@ -62,7 +62,9 @@ class URLTemplateTileProvider extends TileProvider {
    * @readonly
    * @returns {string}
    */
-  static get className() { return 'vcs.vcm.layer.tileProvider.URLTemplateTileProvider'; }
+  static get className() {
+    return 'URLTemplateTileProvider';
+  }
 
   /**
    * @returns {URLTemplateTileProviderOptions}
@@ -87,6 +89,26 @@ class URLTemplateTileProvider extends TileProvider {
     this.url = options.url || defaultOptions.url;
   }
 
+  /**
+   * @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
@@ -96,11 +118,30 @@ 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 url = getURL(this.url, x, y, z, rectangle, this.locale);
+    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,15 @@ 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,20 +45,19 @@ 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,
-      CesiumMap.className,
-    ];
+    this._supportedMaps = [OpenlayersMap.className, CesiumMap.className];
 
     /** @type {?string} */
     this.format = options.format || defaultOptions.format;
 
     /** @type {import("ol/size").Size} */
-    this.tileSize = Array.isArray(options.tileSize) ? options.tileSize.slice() : defaultOptions.tileSize;
+    this.tileSize = Array.isArray(options.tileSize)
+      ? options.tileSize.slice()
+      : defaultOptions.tileSize;
   }
 
   /**
@@ -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 [];
   }
@@ -94,7 +94,7 @@ class TMS extends RasterLayer {
    */
   toJSON() {
     const config = /** @type {TMSOptions} */ (super.toJSON());
-    const defaultOptions = TMS.getDefaultOptions();
+    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;