@vcmap/core 6.2.4 → 6.3.0-rc.2

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?
+      vectorProperties: undefined, // 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();
     }
 
@@ -529,7 +545,9 @@ class VectorLayer
       config.isDynamic = this.isDynamic;
     }
 
-    const vectorPropertiesConfig = this.vectorProperties.getVcsMeta();
+    const vectorPropertiesConfig = this.vectorProperties.getVcsMeta(
+      defaultOptions.vectorProperties,
+    );
     if (Object.keys(vectorPropertiesConfig).length > 0) {
       config.vectorProperties = vectorPropertiesConfig;
     }

package/src/layer/vectorProperties.ts

@@ -347,8 +347,8 @@ class VectorProperties {
       modelRoll: 0,
       modelOptions: undefined,
       modelAutoScale: false,
-      baseUrl: undefined,
       primitiveOptions: undefined,
+      baseUrl: undefined,
     };
   }
 
@@ -1683,6 +1683,15 @@ class VectorProperties {
     if (this.baseUrl !== defaultValues.baseUrl) {
       vcsMeta.baseUrl = this.baseUrl;
     }
+    if (!deepEqual(this.modelOptions, defaultOptions?.modelOptions)) {
+      vcsMeta.modelOptions = this.modelOptions;
+    }
+    if (this.modelAutoScale !== defaultValues.modelAutoScale) {
+      vcsMeta.modelAutoScale = this.modelAutoScale;
+    }
+    if (!deepEqual(this.primitiveOptions, defaultOptions?.primitiveOptions)) {
+      vcsMeta.primitiveOptions = this.primitiveOptions;
+    }
     return vcsMeta;
   }
 

package/src/layer/vectorTileLayer.ts

@@ -1,3 +1,4 @@
+import { check, is, maybe, oneOf } from '@vcsuite/check';
 import Style, { type StyleFunction } from 'ol/style/Style.js';
 import type { Feature } from 'ol/index.js';
 import type { Size } from 'ol/size.js';
@@ -53,6 +54,14 @@ import VectorTileCesiumImpl from './cesium/vectorTileCesiumImpl.js';
 import VectorTilePanoramaImpl from './panorama/vectorTilePanoramaImpl.js';
 import PanoramaMap from '../map/panoramaMap.js';
 import type LayerImplementation from './layerImplementation.js';
+import AbstractFeatureProvider from '../featureProvider/abstractFeatureProvider.js';
+import AbstractAttributeProvider, {
+  type AbstractAttributeProviderOptions,
+  type AttributeProvider,
+} from '../featureProvider/abstractAttributeProvider.js';
+import CompositeFeatureProvider from '../featureProvider/compositeFeatureProvider.js';
+import { rectangleToMercatorExtent } from '../util/math.js';
+import { getProviderForOption } from '../featureProvider/featureProviderFactory.js';
 
 /**
  * synchronizes featureVisibility Symbols on the feature;
@@ -113,14 +122,18 @@ export type VectorTileOptions = FeatureLayerOptions & {
   declutter?: boolean;
   debug?: boolean;
   renderer?: VectorTileRenderer;
+  /**
+   * an optional attribute provider to provide custom attributes for the tileset features on load
+   */
+  attributeProvider?: AttributeProvider | AbstractAttributeProviderOptions;
 };
 
 export type VectorTileImplementationOptions =
   FeatureLayerImplementationOptions & {
     tileProvider: TileProvider;
     tileSize: Size;
-    minLevel: number;
-    maxLevel: number;
+    minLevel?: number;
+    maxLevel?: number;
     extent?: Extent;
     declutter: boolean;
     vectorProperties: VectorProperties;
@@ -163,6 +176,7 @@ class VectorTileLayer<
       declutter: true,
       debug: false,
       renderer: 'image',
+      attributeProvider: undefined,
     };
   }
 
@@ -177,9 +191,11 @@ class VectorTileLayer<
 
   tileProvider: TileProvider;
 
-  private _maxLevel: number;
+  private _attributeProvider?: AttributeProvider;
+
+  private _maxLevel?: number;
 
-  private _minLevel: number;
+  private _minLevel?: number;
 
   private _declutter: boolean;
 
@@ -200,16 +216,19 @@ class VectorTileLayer<
 
   private _renderer: VectorTileRenderer;
 
+  private _defaultFeatureProvider?:
+    | TileProviderFeatureProvider
+    | CompositeFeatureProvider;
+
   /**
    * @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 =
@@ -230,6 +249,7 @@ class VectorTileLayer<
             tileProviderClassRegistry,
             options.tileProvider ?? { type: TileProvider.className },
           ) as TileProvider);
+
     if (this.tileProvider) {
       this.tileProvider.locale = this.locale;
     }
@@ -243,6 +263,17 @@ class VectorTileLayer<
       vectorTileRenderers,
       defaultOptions.renderer,
     );
+
+    const attributeProvider = getProviderForOption(options.attributeProvider);
+
+    if (
+      is(
+        attributeProvider,
+        oneOf(CompositeFeatureProvider, AbstractAttributeProvider),
+      )
+    ) {
+      this._attributeProvider = attributeProvider;
+    }
   }
 
   /**
@@ -268,6 +299,26 @@ class VectorTileLayer<
     this.vectorProperties.allowPicking = allowPicking;
   }
 
+  get attributeProvider(): AttributeProvider | undefined {
+    return this._attributeProvider;
+  }
+
+  set attributeProvider(provider: AttributeProvider | undefined) {
+    check(
+      provider,
+      maybe(oneOf(AbstractAttributeProvider, CompositeFeatureProvider)),
+    );
+
+    if (this._attributeProvider !== provider) {
+      this._attributeProvider = provider;
+      this.forceRedraw().catch((e: unknown) => {
+        this.getLogger().error(
+          `Error forcing redraw after setting attribute provider: ${String(e)}`,
+        );
+      });
+    }
+  }
+
   async initialize(): Promise<void> {
     if (!this.initialized) {
       this._tileLoadEventListener =
@@ -280,14 +331,26 @@ class VectorTileLayer<
           void this.reload();
         });
 
-      if (this._renderer === 'image') {
-        // primitives dont need a feature provider
-        this.featureProvider = new TileProviderFeatureProvider(this.name, {
-          // XXX this overwrites
+      if (
+        this._renderer === 'image' &&
+        !(this.featureProvider instanceof AbstractFeatureProvider)
+      ) {
+        const defaultFeatureProvider = new TileProviderFeatureProvider({
           style: this.style,
           tileProvider: this.tileProvider,
           vectorProperties: this.vectorProperties,
         });
+
+        if (this.featureProvider instanceof AbstractAttributeProvider) {
+          const attributeProvider = this.featureProvider;
+          this._defaultFeatureProvider = new CompositeFeatureProvider({
+            featureProviders: [defaultFeatureProvider],
+            attributeProviders: [attributeProvider],
+          });
+        } else {
+          this._defaultFeatureProvider = defaultFeatureProvider;
+        }
+        this.featureProvider = this._defaultFeatureProvider;
       }
     }
     await super.initialize();
@@ -298,27 +361,40 @@ class VectorTileLayer<
     return this._styleZIndex;
   }
 
-  private _handleTileLoaded({ rtree }: TileLoadedEvent): void {
-    rtree
-      .all()
-      .map((item) => item.value)
-      .forEach((feature) => {
-        const featureStyle = feature.getStyle();
-        if (featureStyle && featureStyle instanceof Style) {
-          featureStyle.setZIndex(this._getNextStyleZIndex());
-        }
-        feature[vcsLayerName] = this.name;
-        feature.getStyleFunction = (): StyleFunction => {
-          return this._featureStyle.bind(this) as StyleFunction;
-        };
-        if (this.tileProvider.trackFeaturesToTiles && this.globalHider) {
-          synchronizeFeatureVisibility(
-            this.featureVisibility,
-            this.globalHider,
-            feature,
-          );
-        }
-      });
+  private _handleTileLoaded({ rtree, tileId }: TileLoadedEvent): void {
+    const features = rtree.all().map((item) => {
+      const feature = item.value;
+      const featureStyle = feature.getStyle();
+      if (featureStyle && featureStyle instanceof Style) {
+        featureStyle.setZIndex(this._getNextStyleZIndex());
+      }
+      feature[vcsLayerName] = this.name;
+      feature.getStyleFunction = (): StyleFunction => {
+        return this._featureStyle.bind(this) as StyleFunction;
+      };
+      if (this.tileProvider.trackFeaturesToTiles && this.globalHider) {
+        synchronizeFeatureVisibility(
+          this.featureVisibility,
+          this.globalHider,
+          feature,
+        );
+      }
+      return feature;
+    });
+
+    if (this._attributeProvider) {
+      const { x, y, level } = this.tileProvider.parseCacheKey(tileId);
+      const rectangle = this.tileProvider.tilingScheme.tileXYToRectangle(
+        x,
+        y,
+        level,
+      );
+      this._attributeProvider
+        .augmentFeatures(features, rectangleToMercatorExtent(rectangle))
+        .catch((error: unknown) => {
+          this.getLogger().error(`Error augmenting features: ${String(error)}`);
+        });
+    }
   }
 
   setGlobalHider(globalHider: GlobalHider): void {
@@ -517,27 +593,10 @@ class VectorTileLayer<
     });
   }
 
-  destroy(): void {
-    this._featureVisibilityListeners.forEach((cb) => {
-      cb();
-    });
-    super.destroy();
-    this._tileLoadEventListener();
-    if (this.featureProvider) {
-      this.featureProvider.destroy();
-    }
-    if (this.tileProvider) {
-      this.tileProvider.destroy();
-    }
-    this._vectorPropertiesChangedListener();
-    if (this.vectorProperties) {
-      this.vectorProperties.destroy();
-    }
-  }
-
-  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;
@@ -572,8 +631,37 @@ class VectorTileLayer<
       config.debug = this._debug;
     }
 
+    if (this.featureProvider === this._defaultFeatureProvider) {
+      delete config.featureProvider;
+      if (this.featureProvider instanceof CompositeFeatureProvider) {
+        const { attributeProviders } = this.featureProvider.toJSON();
+        config.featureProvider = attributeProviders[0];
+      }
+    }
+
+    if (this._attributeProvider) {
+      config.attributeProvider = this._attributeProvider.toJSON();
+    }
+
     return config;
   }
+
+  destroy(): void {
+    this._featureVisibilityListeners.forEach((cb) => {
+      cb();
+    });
+    this.attributeProvider?.destroy();
+    this._defaultFeatureProvider?.destroy();
+    super.destroy();
+    this._tileLoadEventListener();
+    if (this.tileProvider) {
+      this.tileProvider.destroy();
+    }
+    this._vectorPropertiesChangedListener();
+    if (this.vectorProperties) {
+      this.vectorProperties.destroy();
+    }
+  }
 }
 
 layerClassRegistry.registerClass(VectorTileLayer.className, VectorTileLayer);

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

@@ -16,6 +16,10 @@ import WmsOpenlayersImpl from './openlayers/wmsOpenlayersImpl.js';
 import Extent from '../util/extent.js';
 import { layerClassRegistry } from '../classRegistry.js';
 import type VcsMap from '../map/vcsMap.js';
+import AbstractAttributeProvider from '../featureProvider/abstractAttributeProvider.js';
+import CompositeFeatureProvider, {
+  type CompositeFeatureProviderOptions,
+} from '../featureProvider/compositeFeatureProvider.js';
 
 export type WMSImplementationOptions = RasterLayerImplementationOptions & {
   parameters: Record<string, string>;
@@ -39,9 +43,10 @@ export type WMSOptions = RasterLayerOptions & {
    * key value pair of additional WMS parameters, url query notation possible
    */
   parameters?: Record<string, string> | string;
-
   /**
    * whether this layer should send getFeatureInfo requests to the service when objects are clicked.
+   * do not provide this option AND a feature provider. this option will configure a
+   * layer specific WMSFeatureProvider. providing an attribute provider will create a composite feature provider.
    */
   featureInfo?: Partial<WMSFeatureProviderOptions>;
   /**
@@ -92,12 +97,14 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
 
   private _featureInfoOptions: Partial<WMSFeatureProviderOptions> | undefined;
 
+  private _attributeProvider?: AbstractAttributeProvider;
+
   /**
    * @param  options
    */
   constructor(options: WMSOptions) {
-    super(options);
     const defaultOptions = WMSLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
 
     this.version = options.version || (defaultOptions.version as string);
 
@@ -140,6 +147,10 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
       options.singleImage2d,
       defaultOptions.singleImage2d,
     );
+
+    if (this.featureProvider instanceof AbstractAttributeProvider) {
+      this._attributeProvider = this.featureProvider;
+    }
   }
 
   initialize(): Promise<void> {
@@ -163,9 +174,19 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
         extent: this.extent,
         parameters: this.parameters,
         version: this.version,
+        headers: this.headers,
         ...this._featureInfoOptions,
       };
-      this.featureProvider = new WMSFeatureProvider(this.name, options);
+
+      const wmsFeatureProvider = new WMSFeatureProvider(options);
+      if (this._attributeProvider) {
+        this.featureProvider = new CompositeFeatureProvider({
+          featureProviders: [wmsFeatureProvider],
+          attributeProviders: [this._attributeProvider],
+        });
+      } else {
+        this.featureProvider = wmsFeatureProvider;
+      }
     }
   }
 
@@ -217,9 +238,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;
@@ -261,49 +281,61 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
       config.singleImage2d = this.singleImage2d;
     }
 
-    if (
-      this.featureProvider &&
-      this.featureProvider instanceof WMSFeatureProvider
-    ) {
-      const featureInfoConfig: Partial<WMSFeatureProviderOptions> =
-        this.featureProvider.toJSON();
-      if (
-        this.tileSize[0] === featureInfoConfig?.tileSize?.[0] ||
-        this.tileSize[1] === featureInfoConfig?.tileSize?.[1]
-      ) {
-        delete featureInfoConfig.tileSize;
-      }
-      if (
-        Object.entries(this.parameters).every(
-          ([key, value]) => featureInfoConfig?.parameters?.[key] === value,
-        )
-      ) {
-        delete featureInfoConfig.parameters;
-      }
-      if (
-        featureInfoConfig.extent &&
-        new Extent(featureInfoConfig.extent).equals(this.extent)
-      ) {
-        delete featureInfoConfig.extent;
-      }
-      if (this.url === featureInfoConfig.url) {
-        delete featureInfoConfig.url;
-      }
-      if (this.tilingSchema === featureInfoConfig.tilingSchema) {
-        delete featureInfoConfig.tilingSchema;
-      }
-      if (this.version === featureInfoConfig.version) {
-        delete featureInfoConfig.version;
-      }
-      if (this.minLevel === featureInfoConfig.minLevel) {
-        delete featureInfoConfig.minLevel;
-      }
-      if (this.maxLevel === featureInfoConfig.maxLevel) {
-        delete featureInfoConfig.maxLevel;
+    if (this._featureInfoOptions) {
+      delete config.featureProvider;
+      if (this.featureProvider) {
+        let featureInfoConfig: Partial<WMSFeatureProviderOptions>;
+        if (this._attributeProvider) {
+          const compositeInfo =
+            this.featureProvider.toJSON() as CompositeFeatureProviderOptions;
+          featureInfoConfig = compositeInfo.featureProviders[0];
+          config.featureProvider = this._attributeProvider.toJSON();
+        } else {
+          featureInfoConfig = this.featureProvider.toJSON();
+        }
+        if (
+          this.tileSize[0] === featureInfoConfig?.tileSize?.[0] ||
+          this.tileSize[1] === featureInfoConfig?.tileSize?.[1]
+        ) {
+          delete featureInfoConfig.tileSize;
+        }
+        if (
+          Object.entries(this.parameters).every(
+            ([key, value]) => featureInfoConfig?.parameters?.[key] === value,
+          )
+        ) {
+          delete featureInfoConfig.parameters;
+        }
+        if (
+          featureInfoConfig.extent &&
+          new Extent(featureInfoConfig.extent).equals(this.extent)
+        ) {
+          delete featureInfoConfig.extent;
+        }
+        if (this.url === featureInfoConfig.url) {
+          delete featureInfoConfig.url;
+        }
+        if (this.tilingSchema === featureInfoConfig.tilingSchema) {
+          delete featureInfoConfig.tilingSchema;
+        }
+        if (this.version === featureInfoConfig.version) {
+          delete featureInfoConfig.version;
+        }
+        if (this.minLevel === featureInfoConfig.minLevel) {
+          delete featureInfoConfig.minLevel;
+        }
+        if (this.maxLevel === featureInfoConfig.maxLevel) {
+          delete featureInfoConfig.maxLevel;
+        }
+
+        if (this._featureInfoOptions) {
+          delete featureInfoConfig.name;
+          delete featureInfoConfig.type;
+        }
+        config.featureInfo = featureInfoConfig;
+      } else {
+        config.featureInfo = this._featureInfoOptions;
       }
-      config.featureInfo = featureInfoConfig;
-    } else if (this._featureInfoOptions) {
-      config.featureInfo = this._featureInfoOptions;
     }
 
     return config;

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