@vcmap/core 6.2.4 → 6.3.0-rc.2

package/src/layer/panoramaDatasetLayer.ts

@@ -9,7 +9,10 @@ import VectorTileLayer, {
 import PanoramaDatasetPanoramaImpl from './panorama/panoramaDatasetPanoramaImpl.js';
 import type VcsMap from '../map/vcsMap.js';
 import PanoramaMap from '../map/panoramaMap.js';
-import VectorProperties, { PrimitiveOptionsType } from './vectorProperties.js';
+import VectorProperties, {
+  PrimitiveOptionsType,
+  type VectorPropertiesOptions,
+} from './vectorProperties.js';
 import { maxZIndexMin50 } from '../util/layerCollection.js';
 import { layerClassRegistry } from '../classRegistry.js';
 import FlatGeobufTileProvider from './tileProvider/flatGeobufTileProvider.js';
@@ -30,11 +33,12 @@ export type PanoramaDatasetOptions = Omit<
   url: string;
   baseLevel?: number;
   cameraOffset?: number;
+  panoramaVectorProperties?: VectorPropertiesOptions;
 };
 
 export type PanoramaDatasetFeatureProperties = {
   name: string;
-  time: string;
+  time: Date;
   dataset: PanoramaDatasetLayer;
 };
 
@@ -48,11 +52,22 @@ export default class PanoramaDatasetLayer extends VectorTileLayer<PanoramaDatase
       ...VectorTileLayer.getDefaultOptions(),
       url: '',
       baseLevel: 15,
-      activeOnStartup: false,
       cameraOffset: 0,
       minLevel: 15,
       maxLevel: 22,
       zIndex: maxZIndexMin50,
+      ignoreMapLayerTypes: true,
+      panoramaVectorProperties: {
+        altitudeMode: 'absolute',
+        primitiveOptions: {
+          type: PrimitiveOptionsType.CYLINDER,
+          geometryOptions: {
+            topRadius: 1,
+            bottomRadius: 1,
+            length: 0.01,
+          },
+        },
+      },
     };
   }
 
@@ -100,7 +115,7 @@ export default class PanoramaDatasetLayer extends VectorTileLayer<PanoramaDatase
         if (name && time) {
           feature[panoramaFeature] = {
             name,
-            time,
+            time: new Date(time),
             dataset: this,
           };
         }
@@ -115,18 +130,20 @@ export default class PanoramaDatasetLayer extends VectorTileLayer<PanoramaDatase
       defaultOptions.cameraOffset,
     );
 
-    this._panoramaVectorProperties = new VectorProperties({
-      altitudeMode: 'absolute',
-      primitiveOptions: {
-        type: PrimitiveOptionsType.CYLINDER,
-        geometryOptions: {
-          topRadius: 1,
-          bottomRadius: 1,
-          length: 0.01,
-        },
-        offset: [0, 0, this.cameraOffset],
-      },
-    });
+    defaultOptions.panoramaVectorProperties!.primitiveOptions!.offset = [
+      0,
+      0,
+      this.cameraOffset,
+    ];
+
+    this._panoramaVectorProperties = new VectorProperties(
+      defaultOptions.panoramaVectorProperties!,
+    );
+    if (options.panoramaVectorProperties) {
+      this._panoramaVectorProperties.setValues(
+        options.panoramaVectorProperties,
+      );
+    }
 
     this._supportedMaps.push(PanoramaMap.className);
   }
@@ -172,10 +189,15 @@ export default class PanoramaDatasetLayer extends VectorTileLayer<PanoramaDatase
    * Creates a panorama image with the given name, if it belongs to this dataset.
    * Will cache the image for later use.
    * @param name
+   * @param [time] - optional time for the image.
    * @returns
    */
-  createPanoramaImage(name: string): Promise<PanoramaImage> {
-    return createPanoramaImageFromURL(`${this.baseUrl}/${name}_rgb.tif`, this);
+  createPanoramaImage(name: string, time?: Date): Promise<PanoramaImage> {
+    return createPanoramaImageFromURL(
+      `${this.baseUrl}/${name}_rgb.tif`,
+      this,
+      time,
+    );
   }
 
   override getZoomToExtent(): Extent | null {
@@ -196,7 +218,9 @@ export default class PanoramaDatasetLayer extends VectorTileLayer<PanoramaDatase
   async getClosestImage(
     coordinate: Coordinate,
     maxDistance = 200,
-  ): Promise<{ imageName: string; distanceSqrd: number } | undefined> {
+  ): Promise<
+    { imageName: string; distanceSqrd: number; time?: Date } | undefined
+  > {
     const extent = createOrUpdateFromCoordinate(coordinate);
     buffer(extent, maxDistance, extent);
     const features = await this.tileProvider.getFeaturesForExtent(
@@ -208,6 +232,7 @@ export default class PanoramaDatasetLayer extends VectorTileLayer<PanoramaDatase
     );
     let minDistanceSqrd = Infinity;
     let closestImageName: string | undefined;
+    let closestImageTime: Date | undefined;
     features.forEach((feature) => {
       const imagePosition = (feature.getGeometry() as Point).getCoordinates();
       const distanceSqrd = cartesian2DDistanceSquared(
@@ -218,12 +243,17 @@ export default class PanoramaDatasetLayer extends VectorTileLayer<PanoramaDatase
       if (distanceSqrd < minDistanceSqrd) {
         minDistanceSqrd = distanceSqrd;
         closestImageName = feature.get('name') as string;
+        const dateString = feature.get('time') as string | undefined;
+        if (dateString) {
+          closestImageTime = new Date(dateString);
+        }
       }
     });
 
     if (closestImageName) {
       return {
         imageName: closestImageName,
+        time: closestImageTime,
         distanceSqrd: minDistanceSqrd,
       };
     }
@@ -231,13 +261,15 @@ export default class PanoramaDatasetLayer extends VectorTileLayer<PanoramaDatase
     return undefined;
   }
 
-  override toJSON(): PanoramaDatasetOptions {
-    const config = super.toJSON() as Partial<PanoramaDatasetOptions> &
-      VectorTileOptions;
+  override toJSON(
+    defaultOptions = PanoramaDatasetLayer.getDefaultOptions(),
+  ): PanoramaDatasetOptions {
+    const config = super.toJSON(
+      defaultOptions,
+    ) as Partial<PanoramaDatasetOptions> & VectorTileOptions;
     delete config.tileProvider; // tileProvider is not serializable
     config.url = this.url;
 
-    const defaultOptions = PanoramaDatasetLayer.getDefaultOptions();
     if (this.cameraOffset !== defaultOptions.cameraOffset) {
       config.cameraOffset = this.cameraOffset;
     }
@@ -257,6 +289,20 @@ export default class PanoramaDatasetLayer extends VectorTileLayer<PanoramaDatase
       delete config.zIndex;
     }
 
+    defaultOptions.panoramaVectorProperties!.primitiveOptions!.offset = [
+      0,
+      0,
+      this.cameraOffset,
+    ];
+    const vectorPropertiesConfig = this._panoramaVectorProperties.getVcsMeta({
+      ...VectorProperties.getDefaultOptions(),
+      ...defaultOptions.panoramaVectorProperties,
+    });
+
+    if (Object.keys(vectorPropertiesConfig).length > 0) {
+      config.panoramaVectorProperties = vectorPropertiesConfig;
+    }
+
     const thisDefaultStyle = getStyleOrDefaultStyle(defaultOptions.style);
     if (this.style.equals(thisDefaultStyle)) {
       delete config.style;

package/src/layer/pointCloudLayer.ts

@@ -8,11 +8,8 @@ import type DeclarativeStyleItem from '../style/declarativeStyleItem.js';
 import { defaultDeclarativeStyle } from '../style/declarativeStyleItem.js';
 import type { VectorStyleItemOptions } from '../style/vectorStyleItem.js';
 import VectorStyleItem from '../style/vectorStyleItem.js';
-import CesiumMap from '../map/cesiumMap.js';
-import CesiumTilesetCesiumImpl from './cesium/cesiumTilesetCesiumImpl.js';
 import { layerClassRegistry } from '../classRegistry.js';
 import type StyleItem from '../style/styleItem.js';
-import type VcsMap from '../map/vcsMap.js';
 
 export type PointCloudOptions = CesiumTilesetOptions & {
   pointSize?: number | string;
@@ -46,12 +43,9 @@ class PointCloudLayer extends CesiumTilesetLayer {
 
   private _pointSize: number | string | undefined;
 
-  protected _supportedMaps = [CesiumMap.className];
-
   constructor(options: PointCloudOptions) {
-    super(options);
-
     const defaultOptions = PointCloudLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
 
     this.defaultPointSize =
       options.pointSize != null ? options.pointSize : defaultOptions.pointSize;
@@ -86,16 +80,6 @@ class PointCloudLayer extends CesiumTilesetLayer {
     this.pointSize = this._pointSize;
   }
 
-  createImplementationsForMap(map: VcsMap): CesiumTilesetCesiumImpl[] {
-    if (map instanceof CesiumMap) {
-      return [
-        new CesiumTilesetCesiumImpl(map, this.getImplementationOptions()),
-      ];
-    }
-
-    return [];
-  }
-
   /**
    * Clears the style of this layer resets the point size to the defaultPointSize
    */
@@ -117,9 +101,10 @@ class PointCloudLayer extends CesiumTilesetLayer {
     }
   }
 
-  toJSON(): PointCloudOptions {
-    const config: PointCloudOptions = super.toJSON();
-    const defaultOptions = PointCloudLayer.getDefaultOptions();
+  toJSON(
+    defaultOptions = PointCloudLayer.getDefaultOptions(),
+  ): PointCloudOptions {
+    const config: PointCloudOptions = super.toJSON(defaultOptions);
 
     if (this.defaultPointSize !== defaultOptions.pointSize) {
       config.pointSize = this.defaultPointSize;

package/src/layer/rasterLayer.ts

@@ -186,6 +186,7 @@ class RasterLayer<
   static getDefaultOptions(): RasterLayerOptions {
     return {
       ...Layer.getDefaultOptions(),
+      url: '',
       minLevel: 0,
       maxLevel: 18,
       minRenderingLevel: undefined,
@@ -251,8 +252,8 @@ class RasterLayer<
    * @param  options
    */
   constructor(options: RasterLayerOptions) {
-    super({ url: '', ...options });
     const defaultOptions = RasterLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
     this.extent = options.extent ? new Extent(options.extent) : new Extent();
     this.tilingSchema = parseEnumValue(
       options.tilingSchema,
@@ -349,9 +350,8 @@ class RasterLayer<
     return options;
   }
 
-  toJSON(): RasterLayerOptions {
-    const config: RasterLayerOptions = super.toJSON();
-    const defaultOptions = RasterLayer.getDefaultOptions();
+  toJSON(defaultOptions = RasterLayer.getDefaultOptions()): RasterLayerOptions {
+    const config: RasterLayerOptions = super.toJSON(defaultOptions);
 
     if (this.extent?.equals(new Extent())) {
       delete config.extent;

package/src/layer/singleImageLayer.ts

@@ -43,8 +43,8 @@ class SingleImageLayer extends RasterLayer<
   credit: string | undefined;
 
   constructor(options: SingleImageOptions) {
-    super(options);
     const defaultOptions = SingleImageLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
     this.credit = options.credit || defaultOptions.credit;
 
     if (!this.extent.isValid()) {
@@ -95,8 +95,10 @@ class SingleImageLayer extends RasterLayer<
     void this.forceRedraw();
   }
 
-  toJSON(): SingleImageOptions {
-    const config: SingleImageOptions = super.toJSON();
+  toJSON(
+    defaultOptions = SingleImageLayer.getDefaultOptions(),
+  ): SingleImageOptions {
+    const config: SingleImageOptions = super.toJSON(defaultOptions);
     delete config.tilingSchema;
 
     if (this.credit) {

package/src/layer/terrainLayer.ts

@@ -10,6 +10,8 @@ import CesiumMap from '../map/cesiumMap.js';
 import TerrainCesiumImpl from './cesium/terrainCesiumImpl.js';
 import { layerClassRegistry } from '../classRegistry.js';
 import type VcsMap from '../map/vcsMap.js';
+import PanoramaMap from '../map/panoramaMap.js';
+import BaseCesiumMap from '../map/baseCesiumMap.js';
 
 export type TerrainOptions = LayerOptions & {
   requestVertexNormals?: boolean;
@@ -32,20 +34,21 @@ class TerrainLayer extends Layer<TerrainCesiumImpl> {
   static getDefaultOptions(): TerrainOptions {
     return {
       ...Layer.getDefaultOptions(),
+      ignoreMapLayerTypes: true,
       requestVertexNormals: true,
       requestWaterMask: false,
     };
   }
 
-  protected _supportedMaps = [CesiumMap.className];
+  protected _supportedMaps = [CesiumMap.className, PanoramaMap.className];
 
   requestVertexNormals: boolean;
 
   requestWaterMask: boolean;
 
   constructor(options: TerrainOptions) {
-    super(options);
     const defaultOptions = TerrainLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
 
     this.requestVertexNormals = parseBoolean(
       options.requestVertexNormals,
@@ -66,7 +69,7 @@ class TerrainLayer extends Layer<TerrainCesiumImpl> {
   }
 
   createImplementationsForMap(map: VcsMap): TerrainCesiumImpl[] {
-    if (map instanceof CesiumMap) {
+    if (map instanceof BaseCesiumMap) {
       return [new TerrainCesiumImpl(map, this.getImplementationOptions())];
     }
     return [];
@@ -95,13 +98,13 @@ class TerrainLayer extends Layer<TerrainCesiumImpl> {
     );
   }
 
-  toJSON(): TerrainOptions {
-    const config: TerrainOptions = super.toJSON();
-    const defaultOptions = TerrainLayer.getDefaultOptions();
+  toJSON(defaultOptions = TerrainLayer.getDefaultOptions()): TerrainOptions {
+    const config: TerrainOptions = super.toJSON(defaultOptions);
 
     if (this.requestVertexNormals !== defaultOptions.requestVertexNormals) {
       config.requestVertexNormals = this.requestVertexNormals;
     }
+
     if (this.requestWaterMask !== defaultOptions.requestWaterMask) {
       config.requestWaterMask = this.requestWaterMask;
     }

package/src/layer/tileProvider/flatGeobufTileProvider.ts

@@ -1,7 +1,7 @@
 import type Feature from 'ol/Feature.js';
 import type { HttpReader } from 'flatgeobuf/lib/mjs/http-reader.js';
 import type { TileProviderOptions } from './tileProvider.js';
-import TileProvider, { rectangleToExtent } from './tileProvider.js';
+import TileProvider from './tileProvider.js';
 import type { ProjectionOptions } from '../../util/projection.js';
 import Projection, {
   getDefaultProjection,
@@ -14,6 +14,7 @@ import {
   getRootNode,
   getValidReader,
 } from '../flatGeobufHelpers.js';
+import { rectangleToMercatorExtent } from '../../util/math.js';
 
 export type FlatGeobufTileProviderOptions = Omit<
   TileProviderOptions,
@@ -41,8 +42,9 @@ export default class FlatGeobufTileProvider extends TileProvider {
   private _projection: Projection;
 
   constructor(options: FlatGeobufTileProviderOptions) {
+    const defaultOptions = FlatGeobufTileProvider.getDefaultOptions();
     const baseLevels = options.levels.map((level) => level.level);
-    super({ ...options, baseLevels });
+    super({ ...defaultOptions, ...options, baseLevels });
 
     this._levels = new Map(
       options.levels.map((level) => [level.level, { url: level.url }]),
@@ -80,7 +82,7 @@ export default class FlatGeobufTileProvider extends TileProvider {
 
   async loader(x: number, y: number, z: number): Promise<Feature[]> {
     const rectangle = this.tilingScheme.tileXYToRectangle(x, y, z);
-    const extent = rectangleToExtent(rectangle);
+    const extent = rectangleToMercatorExtent(rectangle);
     const mercatorExtent = new Extent({
       coordinates: extent,
       projection: mercatorProjection,
@@ -90,13 +92,15 @@ export default class FlatGeobufTileProvider extends TileProvider {
     return getOlFeatures(reader, this._projection, mercatorExtent);
   }
 
-  toJSON(): FlatGeobufTileProviderOptions {
+  toJSON(
+    defaultOptions = FlatGeobufTileProvider.getDefaultOptions(),
+  ): FlatGeobufTileProviderOptions {
     const config: FlatGeobufTileProviderOptions & { baseLevels?: number[] } = {
       levels: Array.from(this._levels.entries()).map(([level, { url }]) => ({
         level,
         url,
       })),
-      ...super.toJSON(),
+      ...super.toJSON(defaultOptions),
     };
     delete config.baseLevels;
     if (this._projection.epsg !== getDefaultProjection().epsg) {

package/src/layer/tileProvider/mvtTileProvider.ts

@@ -3,10 +3,11 @@ import Feature from 'ol/Feature.js';
 import { getCenter } from 'ol/extent.js';
 import type { Geometry } from 'ol/geom.js';
 import type { TileProviderOptions } from './tileProvider.js';
-import TileProvider, { rectangleToExtent } from './tileProvider.js';
+import TileProvider from './tileProvider.js';
 import { getURL } from './urlTemplateTileProvider.js';
 import { getInitForUrl, requestArrayBuffer } from '../../util/fetch.js';
 import { tileProviderClassRegistry } from '../../classRegistry.js';
+import { rectangleToMercatorExtent } from '../../util/math.js';
 
 export type MVTTileProviderOptions = TileProviderOptions & {
   /**
@@ -36,7 +37,7 @@ class MVTTileProvider extends TileProvider {
 
   constructor(options: MVTTileProviderOptions) {
     const defaultOptions = MVTTileProvider.getDefaultOptions();
-    super(options);
+    super({ ...defaultOptions, ...options });
 
     this.url = options.url || defaultOptions.url;
   }
@@ -66,7 +67,7 @@ class MVTTileProvider extends TileProvider {
   ): Promise<Feature[]> {
     const rectangle = this.tilingScheme.tileXYToRectangle(x, y, z);
     const url = getURL(this.url, x, y, z, rectangle, this.locale);
-    const extent = rectangleToExtent(rectangle);
+    const extent = rectangleToMercatorExtent(rectangle);
     const center = getCenter(extent);
     const init = getInitForUrl(this.url, headers);
     const data = await requestArrayBuffer(url, init);
@@ -90,8 +91,12 @@ class MVTTileProvider extends TileProvider {
     return features;
   }
 
-  toJSON(): MVTTileProviderOptions {
-    const config: Partial<MVTTileProviderOptions> = super.toJSON();
+  toJSON(
+    defaultOptions = MVTTileProvider.getDefaultOptions(),
+  ): MVTTileProviderOptions {
+    const config: Partial<MVTTileProviderOptions> = super.toJSON(
+      defaultOptions,
+    );
 
     if (this.url) {
       config.url = this.url;

package/src/layer/tileProvider/staticFeatureTileProvider.ts

@@ -25,7 +25,7 @@ export default class StaticFeatureTileProvider extends TileProvider {
 
   constructor(options: StaticFeatureTileProviderOptions) {
     const defaultOptions = StaticFeatureTileProvider.getDefaultOptions();
-    super({ ...options, baseLevels: [0] });
+    super({ ...defaultOptions, ...options, baseLevels: [0] });
     this._features = options.features || defaultOptions.features;
   }
 
@@ -42,8 +42,10 @@ export default class StaticFeatureTileProvider extends TileProvider {
     return Promise.resolve(this._features);
   }
 
-  toJSON(): StaticFeatureTileProviderOptions {
-    const config: TileProviderOptions = super.toJSON();
+  toJSON(
+    defaultOptions = StaticFeatureTileProvider.getDefaultOptions(),
+  ): StaticFeatureTileProviderOptions {
+    const config: TileProviderOptions = super.toJSON(defaultOptions);
 
     delete config.baseLevels;
     const staticFeatureConfig: StaticFeatureTileProviderOptions = {

package/src/layer/tileProvider/staticGeojsonTileProvider.ts

@@ -30,7 +30,11 @@ class StaticGeoJSONTileProvider extends TileProvider {
 
   constructor(options: StaticGeoJSONTileProviderOptions) {
     const defaultOptions = StaticGeoJSONTileProvider.getDefaultOptions();
-    super({ ...options, baseLevels: defaultOptions.baseLevels });
+    super({
+      ...defaultOptions,
+      ...options,
+      baseLevels: defaultOptions.baseLevels,
+    });
 
     this.url = options.url || defaultOptions.url;
   }
@@ -47,9 +51,12 @@ class StaticGeoJSONTileProvider extends TileProvider {
     return features;
   }
 
-  toJSON(): StaticGeoJSONTileProviderOptions {
-    const config: Partial<StaticGeoJSONTileProviderOptions> = super.toJSON();
-    delete config.baseLevels;
+  toJSON(
+    defaultOptions = StaticGeoJSONTileProvider.getDefaultOptions(),
+  ): StaticGeoJSONTileProviderOptions {
+    const config: Partial<StaticGeoJSONTileProviderOptions> = super.toJSON(
+      defaultOptions,
+    );
 
     if (this.url) {
       config.url = this.url;

package/src/layer/tileProvider/tileProvider.ts

@@ -27,6 +27,7 @@ import VcsObject from '../../vcsObject.js';
 import VcsEvent from '../../vcsEvent.js';
 import { tileProviderClassRegistry } from '../../classRegistry.js';
 import type Extent from '../../util/extent.js';
+import { rectangleToMercatorExtent } from '../../util/math.js';
 
 export type TileProviderRTreeEntry = {
   minX: number;
@@ -56,6 +57,7 @@ for (let i = 0; i < mercatorResolutionsToLevel.length; i++) {
  * transforms cesium geographic rectangle to mercator extent
  * @param  rectangle in wgs84 radians
  * @returns  extent in mercator
+ * @deprecated use rectangleToMercatorExtent
  */
 export function rectangleToExtent(rectangle: Rectangle): OLExtent {
   const baseSouthWestLevel = Rectangle.southwest(rectangle);
@@ -163,8 +165,8 @@ class TileProvider extends VcsObject {
   private _idProperty: string | undefined;
 
   constructor(options: TileProviderOptions) {
-    super(options);
     const defaultOptions = TileProvider.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
 
     this._tileCacheSize = parseInteger(
       options.tileCacheSize,
@@ -387,6 +389,16 @@ class TileProvider extends VcsObject {
     return `${level}/${x}/${y}`;
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  parseCacheKey(key: string): { x: number; y: number; level: number } {
+    const parts = key.split('/');
+    return {
+      level: parseInt(parts[0], 10),
+      x: parseInt(parts[1], 10),
+      y: parseInt(parts[2], 10),
+    };
+  }
+
   private async _getRtreeForBaseTile(
     baseLevel: number,
     tileCenter: Cartographic,
@@ -506,7 +518,7 @@ class TileProvider extends VcsObject {
         if (level === baseLevel) {
           return rtree.all().map((item) => item.value);
         } else {
-          const extent = rectangleToExtent(rectangle);
+          const extent = rectangleToMercatorExtent(rectangle);
           const features = rtree
             .search({
               minX: extent[0],
@@ -649,9 +661,10 @@ class TileProvider extends VcsObject {
     return Promise.resolve([]);
   }
 
-  toJSON(): TileProviderOptions {
-    const config: TileProviderOptions = super.toJSON();
-    const defaultOptions = TileProvider.getDefaultOptions();
+  toJSON(
+    defaultOptions = TileProvider.getDefaultOptions(),
+  ): TileProviderOptions {
+    const config: TileProviderOptions = super.toJSON(defaultOptions);
 
     if (defaultOptions.tileCacheSize !== this.tileCacheSize) {
       config.tileCacheSize = this.tileCacheSize;

package/src/layer/tileProvider/urlTemplateTileProvider.ts

@@ -74,7 +74,7 @@ class URLTemplateTileProvider extends TileProvider {
 
   constructor(options: URLTemplateTileProviderOptions) {
     const defaultOptions = URLTemplateTileProvider.getDefaultOptions();
-    super(options);
+    super({ ...defaultOptions, ...options });
     this.url = options.url || defaultOptions.url;
   }
 
@@ -110,8 +110,12 @@ class URLTemplateTileProvider extends TileProvider {
     return features;
   }
 
-  toJSON(): URLTemplateTileProviderOptions {
-    const config: Partial<URLTemplateTileProviderOptions> = super.toJSON();
+  toJSON(
+    defaultOptions = URLTemplateTileProvider.getDefaultOptions(),
+  ): URLTemplateTileProviderOptions {
+    const config: Partial<URLTemplateTileProviderOptions> = super.toJSON(
+      defaultOptions,
+    );
 
     if (this.url) {
       config.url = this.url;

package/src/layer/tmsLayer.ts

@@ -44,7 +44,7 @@ class TMSLayer extends RasterLayer<TmsCesiumImpl | TmsOpenlayersImpl> {
 
   constructor(options: TMSOptions) {
     const defaultOptions = TMSLayer.getDefaultOptions();
-    super({ tilingSchema: defaultOptions.tilingSchema, ...options });
+    super({ ...defaultOptions, ...options });
 
     this._supportedMaps = [OpenlayersMap.className, CesiumMap.className];
 
@@ -75,15 +75,8 @@ class TMSLayer extends RasterLayer<TmsCesiumImpl | TmsOpenlayersImpl> {
     return [];
   }
 
-  toJSON(): TMSOptions {
-    const config: TMSOptions = super.toJSON();
-    const defaultOptions = TMSLayer.getDefaultOptions();
-
-    if (this.tilingSchema !== defaultOptions.tilingSchema) {
-      config.tilingSchema = this.tilingSchema;
-    } else {
-      delete config.tilingSchema;
-    }
+  toJSON(defaultOptions = TMSLayer.getDefaultOptions()): TMSOptions {
+    const config: TMSOptions = super.toJSON(defaultOptions);
 
     if (this.format !== defaultOptions.format) {
       config.format = this.format;