@vcmap/core 6.2.2 → 6.3.0-rc.1

package/src/layer/panoramaDatasetLayer.ts

@@ -34,7 +34,7 @@ export type PanoramaDatasetOptions = Omit<
 
 export type PanoramaDatasetFeatureProperties = {
   name: string;
-  time: string;
+  time: Date;
   dataset: PanoramaDatasetLayer;
 };
 
@@ -48,11 +48,11 @@ export default class PanoramaDatasetLayer extends VectorTileLayer<PanoramaDatase
       ...VectorTileLayer.getDefaultOptions(),
       url: '',
       baseLevel: 15,
-      activeOnStartup: false,
       cameraOffset: 0,
       minLevel: 15,
       maxLevel: 22,
       zIndex: maxZIndexMin50,
+      ignoreMapLayerTypes: true,
     };
   }
 
@@ -100,7 +100,7 @@ export default class PanoramaDatasetLayer extends VectorTileLayer<PanoramaDatase
         if (name && time) {
           feature[panoramaFeature] = {
             name,
-            time,
+            time: new Date(time),
             dataset: this,
           };
         }
@@ -172,10 +172,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 +201,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 +215,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 +226,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 +244,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;
     }

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

@@ -41,8 +41,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 }]),
@@ -90,13 +91,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

@@ -36,7 +36,7 @@ class MVTTileProvider extends TileProvider {
 
   constructor(options: MVTTileProviderOptions) {
     const defaultOptions = MVTTileProvider.getDefaultOptions();
-    super(options);
+    super({ ...defaultOptions, ...options });
 
     this.url = options.url || defaultOptions.url;
   }
@@ -90,8 +90,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

@@ -163,8 +163,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,
@@ -649,9 +649,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;

package/src/layer/vectorLayer.ts

@@ -45,6 +45,8 @@ import type { GeoJSONwriteOptions } from './geojsonHelpers.js';
 import { vcsLayerName } from './layerSymbols.js';
 import type CesiumTilesetCesiumImpl from './cesium/cesiumTilesetCesiumImpl.js';
 import VcsEvent from '../vcsEvent.js';
+import PanoramaMap from '../map/panoramaMap.js';
+import VectorPanoramaImpl from './panorama/vectorPanoramaImpl.js';
 
 export type VectorOptions = FeatureLayerOptions & {
   /**
@@ -72,8 +74,13 @@ export type VectorImplementationOptions = FeatureLayerImplementationOptions & {
 };
 
 /**
- * VectorLayer Layer for OpenlayersMap, Cesium and ObliqueMap
- * @group Layer
+ * the vector layer is the standard layer to display vector features on the map. mostly, a specialization
+ * is used to load data from a certain source, e.g. GeoJSONLayer, FlatGeobufLayer, etc. But it can also
+ * be used as a generic layer to add features to, mostly at runtime.
+ *
+ * This layer ignores the mapLayerTypes configuration by default, as it is mostly used to display user data.
+ * Be sure to configure this otherwise if needed and reset the default when extending this class to implement
+ * a layer for a specific data source.
  */
 class VectorLayer
   extends FeatureLayer<
@@ -81,6 +88,7 @@ class VectorLayer
     | VectorOpenlayersImpl
     | VectorCesiumImpl
     | CesiumTilesetCesiumImpl
+    | VectorPanoramaImpl
   >
   implements SplitLayer
 {
@@ -95,11 +103,11 @@ class VectorLayer
       maxResolution: undefined,
       minResolution: undefined,
       dontUseTerrainForOblique: false,
-      zIndex: 50,
       highlightStyle: undefined,
       isDynamic: false,
       vectorProperties: {}, // XXX or should we return VectorProperties default options?
       vectorClusterGroup: undefined,
+      ignoreMapLayerTypes: true,
     };
   }
 
@@ -107,6 +115,7 @@ class VectorLayer
     CesiumMap.className,
     ObliqueMap.className,
     OpenlayersMap.className,
+    PanoramaMap.className,
   ];
 
   source: VectorSource = new VectorSource({});
@@ -148,9 +157,9 @@ class VectorLayer
   }>();
 
   constructor(options: VectorOptions) {
-    super(options);
-
     const defaultOptions = VectorLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
+
     this.projection = new Projection(options.projection);
     this.maxResolution =
       options.maxResolution != null
@@ -291,6 +300,7 @@ class VectorLayer
     | VectorOpenlayersImpl
     | VectorCesiumImpl
     | CesiumTilesetCesiumImpl
+    | VectorPanoramaImpl
   )[] {
     if (!this.visibility || !!this.vectorClusterGroup) {
       return [];
@@ -308,6 +318,10 @@ class VectorLayer
       return [new VectorObliqueImpl(map, this.getImplementationOptions())];
     }
 
+    if (map instanceof PanoramaMap) {
+      return [new VectorPanoramaImpl(map, this.getImplementationOptions())];
+    }
+
     return [];
   }
 
@@ -499,11 +513,13 @@ class VectorLayer
     return null;
   }
 
-  toJSON(): VectorOptions {
-    const config: VectorOptions = super.toJSON();
-    const defaultOptions = VectorLayer.getDefaultOptions();
+  toJSON(defaultOptions = VectorLayer.getDefaultOptions()): VectorOptions {
+    const config: VectorOptions = super.toJSON(defaultOptions);
+
+    const defaultProjection =
+      defaultOptions.projection ?? getDefaultProjection();
 
-    if (this.projection.epsg !== getDefaultProjection().epsg) {
+    if (this.projection.epsg !== defaultProjection.epsg) {
       config.projection = this.projection.toJSON();
     }
 

package/src/layer/vectorTileLayer.ts

@@ -204,12 +204,11 @@ class VectorTileLayer<
    * @param  options
    */
   constructor(options: VectorTileOptions) {
-    super(options);
+    const defaultOptions = VectorTileLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
 
     this._supportedMaps = [CesiumMap.className, OpenlayersMap.className];
 
-    const defaultOptions = VectorTileLayer.getDefaultOptions();
-
     this.highlightStyle = undefined;
     if (options.highlightStyle) {
       this.highlightStyle =
@@ -535,9 +534,10 @@ class VectorTileLayer<
     }
   }
 
-  toJSON(): VectorTileOptions {
-    const config: VectorTileOptions = super.toJSON();
-    const defaultOptions = VectorTileLayer.getDefaultOptions();
+  toJSON(
+    defaultOptions = VectorTileLayer.getDefaultOptions(),
+  ): VectorTileOptions {
+    const config: VectorTileOptions = super.toJSON(defaultOptions);
 
     if (this._maxLevel !== defaultOptions.maxLevel) {
       config.maxLevel = this._maxLevel;

package/src/layer/wfsLayer.ts

@@ -56,6 +56,7 @@ class WFSLayer extends VectorLayer {
       featurePrefix: '',
       getFeatureOptions: {},
       version: undefined,
+      ignoreMapLayerTypes: false,
     };
   }
 
@@ -66,7 +67,8 @@ class WFSLayer extends VectorLayer {
         (proj.epsg as string).match(/\d+/)?.[0] as string
       }`,
     ];
-    super({ ...options, projection: proj });
+    const defaultOptions = WFSLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options, projection: proj });
 
     this.featureType = Array.isArray(options.featureType)
       ? options.featureType
@@ -157,15 +159,16 @@ class WFSLayer extends VectorLayer {
     this.addFeatures(features);
   }
 
-  toJSON(): WFSOptions {
-    const config: Partial<WFSOptions> = super.toJSON();
-    const defaultOptions = WFSLayer.getDefaultOptions();
+  toJSON(defaultOptions = WFSLayer.getDefaultOptions()): WFSOptions {
+    const config: Partial<WFSOptions> = super.toJSON(defaultOptions);
     config.featureType = this.featureType.slice();
     config.featureNS = this.featureNS;
     config.featurePrefix = this.featurePrefix;
+
     if (Object.keys(this.getFeaturesOptions).length > 0) {
       config.getFeatureOptions = this.getFeaturesOptions;
     }
+
     if (this.version !== defaultOptions.version) {
       config.version = this.version;
     }

package/src/layer/wmsLayer.ts

@@ -96,8 +96,8 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
    * @param  options
    */
   constructor(options: WMSOptions) {
-    super(options);
     const defaultOptions = WMSLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
 
     this.version = options.version || (defaultOptions.version as string);
 
@@ -217,9 +217,8 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
     return this.parameters.LAYERS ? this.parameters.LAYERS.split(',') : [];
   }
 
-  toJSON(): WMSOptions {
-    const config: WMSOptions = super.toJSON();
-    const defaultOptions = WMSLayer.getDefaultOptions();
+  toJSON(defaultOptions = WMSLayer.getDefaultOptions()): WMSOptions {
+    const config: WMSOptions = super.toJSON(defaultOptions);
 
     if (this.parameters.LAYERS) {
       config.layers = this.parameters.LAYERS;

package/src/layer/wmtsLayer.ts

@@ -106,7 +106,7 @@ class WMTSLayer extends RasterLayer<WmtsCesiumImpl | WmtsOpenlayersImpl> {
 
   constructor(options: WMTSOptions) {
     const defaultOptions = WMTSLayer.getDefaultOptions();
-    super({ tilingSchema: defaultOptions.tilingSchema, ...options });
+    super({ ...defaultOptions, ...options });
 
     this._supportedMaps = [OpenlayersMap.className, CesiumMap.className];
 
@@ -174,15 +174,8 @@ class WMTSLayer extends RasterLayer<WmtsCesiumImpl | WmtsOpenlayersImpl> {
     return [];
   }
 
-  toJSON(): WMTSOptions {
-    const config: Partial<WMTSOptions> = super.toJSON();
-    const defaultOptions = WMTSLayer.getDefaultOptions();
-
-    if (this.tilingSchema !== defaultOptions.tilingSchema) {
-      config.tilingSchema = this.tilingSchema;
-    } else {
-      delete config.tilingSchema;
-    }
+  toJSON(defaultOptions = WMTSLayer.getDefaultOptions()): WMTSOptions {
+    const config: Partial<WMTSOptions> = super.toJSON(defaultOptions);
 
     if (
       this.numberOfLevelZeroTilesX !== defaultOptions.numberOfLevelZeroTilesX