@vcmap/core 6.2.2 → 6.3.0-rc.1

package/src/interaction/featureAtPixelInteraction.ts

@@ -26,10 +26,10 @@ import { allowPicking, vcsLayerName } from '../layer/layerSymbols.js';
 import { originalFeatureSymbol, primitives } from '../layer/vectorSymbols.js';
 import type OpenlayersMap from '../map/openlayersMap.js';
 import type ObliqueMap from '../map/obliqueMap.js';
-import type CesiumMap from '../map/cesiumMap.js';
 import { vectorClusterGroupName } from '../vectorCluster/vectorClusterSymbols.js';
-import { cartesianToMercator } from '../util/math.js';
+import { cartesian3DDistance, cartesianToMercator } from '../util/math.js';
 import type { PrimitiveType } from '../util/featureconverter/convert.js';
+import type BaseCesiumMap from '../map/baseCesiumMap.js';
 import type PanoramaMap from '../map/panoramaMap.js';
 
 /**
@@ -283,7 +283,7 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
   }
 
   private _cesiumHandler(event: InteractionEvent): Promise<InteractionEvent> {
-    const cesiumMap = event.map as CesiumMap | PanoramaMap;
+    const cesiumMap = event.map as BaseCesiumMap;
     const { scene } = cesiumMap.getCesiumWidget()!;
 
     if (!scene) {
@@ -301,14 +301,10 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
     }
 
     const { pickTranslucentDepth } = scene;
-    if (!(event.type & this.pickPosition)) {
-      return Promise.resolve(event);
-    }
-
     if (
+      !!(event.type & this.pickPosition) &&
       pickObject &&
-      scene.pickPositionSupported &&
-      event.map.className === 'CesiumMap'
+      scene.pickPositionSupported
     ) {
       if (this.pickTranslucent) {
         scene.pickTranslucentDepth = true;
@@ -334,30 +330,44 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
       );
 
       if (
-        !cartesianPosition ||
-        Cartesian3.equals(cartesianPosition, Cartesian3.ZERO)
+        cartesianPosition &&
+        !Cartesian3.equals(cartesianPosition, Cartesian3.ZERO)
       ) {
-        return Promise.resolve(event);
-      }
+        if (this.pullPickedPosition && event.ray) {
+          const pulledCartesian = Cartesian3.multiplyByScalar(
+            event.ray.direction,
+            this.pullPickedPosition,
+            new Cartesian3(),
+          );
+
+          Cartesian3.subtract(
+            cartesianPosition,
+            pulledCartesian,
+            cartesianPosition,
+          );
+        }
 
-      if (this.pullPickedPosition && event.ray) {
-        const pulledCartesian = Cartesian3.multiplyByScalar(
-          event.ray.direction,
-          this.pullPickedPosition,
-          new Cartesian3(),
-        );
-
-        Cartesian3.subtract(
-          cartesianPosition,
-          pulledCartesian,
-          cartesianPosition,
-        );
+        if (event.map.className === 'CesiumMap') {
+          event.position = cartesianToMercator(cartesianPosition);
+          event.positionOrPixel = event.position.slice();
+        } else {
+          const currentImage = (event.map as PanoramaMap).currentPanoramaImage;
+          if (currentImage) {
+            const imageCenter = cartesianToMercator(currentImage.position);
+            const newPosition = cartesianToMercator(cartesianPosition);
+            const newDistance = cartesian3DDistance(imageCenter, newPosition);
+            const currentDistance = event.position
+              ? cartesian3DDistance(imageCenter, event.position)
+              : undefined;
+
+            if (currentDistance == null || newDistance < currentDistance) {
+              event.position = newPosition;
+              event.positionOrPixel = event.position.slice();
+            }
+          }
+        }
       }
-
-      event.position = cartesianToMercator(cartesianPosition);
-      event.positionOrPixel = event.position.slice();
       scene.pickTranslucentDepth = pickTranslucentDepth;
-      return Promise.resolve(event);
     }
 
     return Promise.resolve(event);

package/src/interaction/panoramaImageSelection.ts

@@ -13,8 +13,10 @@ export default class PanoramaImageSelection extends AbstractInteraction {
 
   override async pipe(event: InteractionEvent): Promise<InteractionEvent> {
     if (event.feature && (event.feature as Feature)[panoramaFeature]) {
-      const { dataset, name } = (event.feature as Feature)[panoramaFeature]!;
-      const panoramaImage = await dataset.createPanoramaImage(name);
+      const { dataset, name, time } = (event.feature as Feature)[
+        panoramaFeature
+      ]!;
+      const panoramaImage = await dataset.createPanoramaImage(name, time);
       event.stopPropagation = true;
 
       if (event.map instanceof PanoramaMap) {

package/src/layer/cesium/cesiumTilesetCesiumImpl.ts

@@ -33,11 +33,11 @@ import type {
   CesiumTilesetImplementationOptions,
   CesiumTilesetTilesetProperties,
 } from '../cesiumTilesetLayer.js';
-import type CesiumMap from '../../map/cesiumMap.js';
 import type { FeatureLayerImplementation } from '../featureLayer.js';
 import type StyleItem from '../../style/styleItem.js';
 import type GlobalHider from '../globalHider.js';
 import { getResourceOrUrl } from './resourceHelper.js';
+import type BaseCesiumMap from '../../map/baseCesiumMap.js';
 
 export const cesiumTilesetLastUpdated: unique symbol = Symbol(
   'cesiumTilesetLastUpdated',
@@ -84,7 +84,7 @@ export function getExtentFromTileset(
  * represents the cesium implementation for a {@link CesiumTilesetLayer} layer.
  */
 class CesiumTilesetCesiumImpl
-  extends LayerImplementation<CesiumMap>
+  extends LayerImplementation<BaseCesiumMap>
   implements FeatureLayerImplementation
 {
   static get className(): string {
@@ -121,7 +121,7 @@ class CesiumTilesetCesiumImpl
 
   private _customShader: CustomShader | undefined;
 
-  constructor(map: CesiumMap, options: CesiumTilesetImplementationOptions) {
+  constructor(map: BaseCesiumMap, options: CesiumTilesetImplementationOptions) {
     super(map, options);
 
     this.cesium3DTileset = null;

package/src/layer/cesium/cogImageryProvider.ts

@@ -98,6 +98,10 @@ export default class COGImageryProvider {
     level: number,
   ) => Promise<ImageryTypes>;
 
+  readonly tileWidth: number = 256;
+
+  readonly tileHeight: number = 256;
+
   constructor(private _source: GeoTIFFSource) {
     this._emptyCanvas = createEmptyCanvas(this.tileWidth, this.tileHeight);
     this._projection = this._source.getProjection()!;
@@ -108,6 +112,11 @@ export default class COGImageryProvider {
     } else {
       this._boundTileLoader = this._loadUnalignedTile.bind(this);
     }
+
+    // @ts-expect-error protected
+    const [width, height] = this._source.getTileSize(0);
+    this.tileWidth = Math.round(width);
+    this.tileHeight = Math.round(height);
   }
 
   // eslint-disable-next-line class-methods-use-this,@typescript-eslint/naming-convention
@@ -140,32 +149,6 @@ export default class COGImageryProvider {
     return undefined;
   }
 
-  get tileWidth(): number {
-    const tileGrid = this._source.getTileGrid();
-    if (tileGrid) {
-      const tileSizeAtZoom0 = tileGrid.getTileSize(0);
-      if (Array.isArray(tileSizeAtZoom0)) {
-        return Math.round(tileSizeAtZoom0[0]);
-      } else {
-        return Math.round(tileSizeAtZoom0); // same width and height
-      }
-    }
-    return 256;
-  }
-
-  get tileHeight(): number {
-    const tileGrid = this._source.getTileGrid();
-    if (tileGrid) {
-      const tileSizeAtZoom0 = tileGrid.getTileSize(0);
-      if (Array.isArray(tileSizeAtZoom0)) {
-        return Math.round(tileSizeAtZoom0[1]);
-      } else {
-        return Math.round(tileSizeAtZoom0); // same width and height
-      }
-    }
-    return 256;
-  }
-
   get maximumLevel(): number {
     const tileGrid = this._source.getTileGrid();
     if (tileGrid) {

package/src/layer/cesium/rasterLayerCesiumImpl.ts

@@ -1,16 +1,16 @@
 import type { ImageryLayer, SplitDirection } from '@vcmap-cesium/engine';
 import { vcsLayerName } from '../layerSymbols.js';
 import LayerImplementation from '../layerImplementation.js';
-import type CesiumMap from '../../map/cesiumMap.js';
 import type {
   RasterLayerImplementation,
   RasterLayerImplementationOptions,
   TilingScheme,
 } from '../rasterLayer.js';
 import type Extent from '../../util/extent.js';
+import type BaseCesiumMap from '../../map/baseCesiumMap.js';
 
 class RasterLayerCesiumImpl
-  extends LayerImplementation<CesiumMap>
+  extends LayerImplementation<BaseCesiumMap>
   implements RasterLayerImplementation
 {
   static get className(): string {
@@ -37,7 +37,7 @@ class RasterLayerCesiumImpl
 
   imageryLayerOptions: ImageryLayer.ConstructorOptions | undefined;
 
-  constructor(map: CesiumMap, options: RasterLayerImplementationOptions) {
+  constructor(map: BaseCesiumMap, options: RasterLayerImplementationOptions) {
     super(map, options);
     this.splitDirection = options.splitDirection;
     this.minLevel = options.minLevel;

package/src/layer/cesium/terrainCesiumImpl.ts

@@ -2,13 +2,13 @@ import type { CesiumTerrainProvider } from '@vcmap-cesium/engine';
 import LayerImplementation from '../layerImplementation.js';
 import { vcsLayerName } from '../layerSymbols.js';
 import { getTerrainProviderForUrl } from '../terrainHelpers.js';
-import type CesiumMap from '../../map/cesiumMap.js';
 import type { TerrainImplementationOptions } from '../terrainLayer.js';
+import type BaseCesiumMap from '../../map/baseCesiumMap.js';
 
 /**
  * TerrainLayer implementation for {@link CesiumMap}
  */
-class TerrainCesiumImpl extends LayerImplementation<CesiumMap> {
+class TerrainCesiumImpl extends LayerImplementation<BaseCesiumMap> {
   static get className(): string {
     return 'TerrainCesiumImpl';
   }
@@ -19,7 +19,7 @@ class TerrainCesiumImpl extends LayerImplementation<CesiumMap> {
 
   terrainProvider: CesiumTerrainProvider | undefined = undefined;
 
-  constructor(map: CesiumMap, options: TerrainImplementationOptions) {
+  constructor(map: BaseCesiumMap, options: TerrainImplementationOptions) {
     super(map, options);
 
     this.requestVertexNormals = options.requestVertexNormals;

package/src/layer/cesium/vectorContext.ts

@@ -31,7 +31,7 @@ import {
   scaleSymbol,
 } from '../vectorSymbols.js';
 import type PanoramaMap from '../../map/panoramaMap.js';
-import { getResolution } from '../../map/cesiumMapHelpers.js';
+import { getResolution } from '../../map/baseCesiumMap.js';
 
 export function setReferenceForPicking(
   feature: Feature,

package/src/layer/cesiumTilesetLayer.ts

@@ -23,6 +23,8 @@ import type { LayerOptions } from './layer.js';
 import type FeatureVisibility from './featureVisibility.js';
 import type VcsMap from '../map/vcsMap.js';
 import { cesiumColorToColor, getStringColor } from '../style/styleHelpers.js';
+import PanoramaMap from '../map/panoramaMap.js';
+import BaseCesiumMap from '../map/baseCesiumMap.js';
 
 export type CesiumTilesetOptions = LayerOptions & {
   /**
@@ -94,14 +96,13 @@ class CesiumTilesetLayer extends FeatureLayer<CesiumTilesetCesiumImpl> {
 
   private _offset: Coordinate | undefined;
 
-  protected _supportedMaps = [CesiumMap.className];
+  protected _supportedMaps = [CesiumMap.className, PanoramaMap.className];
 
   private _customShader: CustomShader | undefined = undefined;
 
   constructor(options: CesiumTilesetOptions) {
-    super(options);
-    this._supportedMaps = [CesiumMap.className];
     const defaultOptions = CesiumTilesetLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
 
     this.highlightStyle = null;
     if (options.highlightStyle) {
@@ -199,7 +200,7 @@ class CesiumTilesetLayer extends FeatureLayer<CesiumTilesetCesiumImpl> {
   }
 
   createImplementationsForMap(map: VcsMap): CesiumTilesetCesiumImpl[] {
-    if (map instanceof CesiumMap) {
+    if (map instanceof BaseCesiumMap) {
       return [
         new CesiumTilesetCesiumImpl(map, this.getImplementationOptions()),
       ];
@@ -244,9 +245,10 @@ class CesiumTilesetLayer extends FeatureLayer<CesiumTilesetCesiumImpl> {
     });
   }
 
-  toJSON(): CesiumTilesetOptions {
-    const config: CesiumTilesetOptions = super.toJSON();
-    const defaultOptions = CesiumTilesetLayer.getDefaultOptions();
+  toJSON(
+    defaultOptions = CesiumTilesetLayer.getDefaultOptions(),
+  ): CesiumTilesetOptions {
+    const config: CesiumTilesetOptions = super.toJSON(defaultOptions);
     if (this.highlightStyle) {
       config.highlightStyle = this.highlightStyle.toJSON();
     }

package/src/layer/cogLayer.ts

@@ -1,4 +1,7 @@
-import GeoTIFF, { type Options as GeoTIFFOptions } from 'ol/source/GeoTIFF.js';
+import GeoTIFF, {
+  type GeoTIFFSourceOptions,
+  type Options as GeoTIFFOptions,
+} from 'ol/source/GeoTIFF.js';
 import type { EventsKey } from 'ol/events.js';
 import { unByKey } from 'ol/Observable.js';
 import RasterLayer, {
@@ -28,6 +31,11 @@ export type COGLayerOptions = Omit<RasterLayerOptions, 'tilingSchema'> & {
    * Passed directly to the GeoTIFF source.
    */
   interpolate?: boolean;
+  /**
+   * Passed directly to the GeoTIFF.js source options see
+   * https://openlayers.org/en/latest/apidoc/module-ol_source_GeoTIFF.html#~GeoTIFFSourceOptions
+   */
+  sourceOptions?: GeoTIFFSourceOptions;
 };
 
 export type COGLayerImplementationOptions = RasterLayerImplementationOptions & {
@@ -72,6 +80,7 @@ class COGLayer extends RasterLayer<COGOpenlayersImpl | COGCesiumImpl> {
       convertToRGB: 'auto',
       normalize: undefined,
       interpolate: undefined,
+      sourceOptions: undefined,
     };
   }
 
@@ -79,12 +88,15 @@ class COGLayer extends RasterLayer<COGOpenlayersImpl | COGCesiumImpl> {
   private _source: GeoTIFF | undefined;
 
   constructor(options: COGLayerOptions) {
-    super(options);
     const defaultOptions = COGLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
     this._sourceOptions = {
       convertToRGB: options.convertToRGB ?? defaultOptions.convertToRGB,
       normalize: options.normalize,
       interpolate: options.interpolate,
+      sourceOptions: options.sourceOptions
+        ? structuredClone(options.sourceOptions)
+        : defaultOptions.sourceOptions,
     };
 
     this._supportedMaps = [OpenlayersMap.className, CesiumMap.className];
@@ -120,10 +132,10 @@ class COGLayer extends RasterLayer<COGOpenlayersImpl | COGCesiumImpl> {
     return [];
   }
 
-  toJSON(): COGLayerOptions {
-    const config: Partial<COGLayerOptions> & RasterLayerOptions =
-      super.toJSON();
-    const defaultOptions = COGLayer.getDefaultOptions();
+  toJSON(defaultOptions = COGLayer.getDefaultOptions()): COGLayerOptions {
+    const config: Partial<COGLayerOptions> & RasterLayerOptions = super.toJSON(
+      defaultOptions,
+    );
 
     delete config.tilingSchema;
     if (this._sourceOptions.convertToRGB !== defaultOptions.convertToRGB) {
@@ -138,6 +150,10 @@ class COGLayer extends RasterLayer<COGOpenlayersImpl | COGCesiumImpl> {
       config.interpolate = this._sourceOptions.interpolate;
     }
 
+    if (this._sourceOptions.sourceOptions != null) {
+      config.sourceOptions = structuredClone(this._sourceOptions.sourceOptions);
+    }
+
     return config;
   }
 

package/src/layer/czmlLayer.ts

@@ -49,10 +49,10 @@ class CzmlLayer extends DataSourceLayer {
    * @param  options
    */
   constructor(options: CzmlOptions) {
-    super(options);
+    const defaultOptions = CzmlLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
     this.entities = this.dataSource.entities;
 
-    const defaultOptions = CzmlLayer.getDefaultOptions();
     this.sourceUri = options.sourceUri || defaultOptions.sourceUri;
   }
 
@@ -99,8 +99,8 @@ class CzmlLayer extends DataSourceLayer {
     await this.forceRedraw();
   }
 
-  toJSON(): CzmlOptions {
-    const config: CzmlOptions = super.toJSON();
+  toJSON(defaultOptions = CzmlLayer.getDefaultOptions()): CzmlOptions {
+    const config: CzmlOptions = super.toJSON(defaultOptions);
     if (this.sourceUri) {
       config.sourceUri = this.sourceUri;
     }

package/src/layer/featureLayer.ts

@@ -1,7 +1,6 @@
 import Style, { type StyleFunction } from 'ol/style/Style.js';
 
 import { check, oneOf } from '@vcsuite/check';
-import { parseInteger } from '@vcsuite/parsers';
 import { SplitDirection } from '@vcmap-cesium/engine';
 import type {
   LayerImplementationOptions,
@@ -25,7 +24,6 @@ import type { DeclarativeStyleItemOptions } from '../style/declarativeStyleItem.
 
 export type FeatureLayerOptions = LayerOptions & {
   style?: VectorStyleItemOptions | DeclarativeStyleItemOptions | StyleItem;
-  balloonHeightOffset?: number;
   splitDirection?: string;
   featureVisibility?: FeatureVisibility;
 };
@@ -60,7 +58,6 @@ class FeatureLayer<
     return {
       ...Layer.getDefaultOptions(),
       style: undefined,
-      balloonHeightOffset: 10,
       splitDirection: undefined,
     };
   }
@@ -74,11 +71,6 @@ class FeatureLayer<
    */
   readonly styleChanged = new VcsEvent<StyleItem>();
 
-  /**
-   * a height offset for rendering of a balloon for a feature of this layer.
-   */
-  balloonHeightOffset: number;
-
   private _splitDirection: SplitDirection = SplitDirection.NONE;
 
   /**
@@ -95,17 +87,12 @@ class FeatureLayer<
    * @param  options
    */
   constructor(options: FeatureLayerOptions) {
-    super(options);
     const defaultOptions = FeatureLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
 
     this._style = this.getStyleOrDefaultStyle(options.style);
     this._defaultStyle = this._style;
 
-    this.balloonHeightOffset = parseInteger(
-      options.balloonHeightOffset,
-      defaultOptions.balloonHeightOffset,
-    );
-
     if (options.splitDirection) {
       this._splitDirection =
         options.splitDirection === 'left'
@@ -201,8 +188,10 @@ class FeatureLayer<
     this.setStyle(this.defaultStyle);
   }
 
-  toJSON(): FeatureLayerOptions {
-    const config: FeatureLayerOptions = super.toJSON();
+  toJSON(
+    defaultOptions = FeatureLayer.getDefaultOptions(),
+  ): FeatureLayerOptions {
+    const config: FeatureLayerOptions = super.toJSON(defaultOptions);
     if (!this.getStyleOrDefaultStyle().equals(this._style)) {
       config.style = this.style.toJSON();
     }

package/src/layer/featureStoreLayer.ts

@@ -46,6 +46,8 @@ import type StyleItem from '../style/styleItem.js';
 import type VcsMap from '../map/vcsMap.js';
 import type VectorCesiumImpl from './cesium/vectorCesiumImpl.js';
 import FeatureStoreFeatureVisibility from './featureStoreFeatureVisibility.js';
+import BaseCesiumMap from '../map/baseCesiumMap.js';
+import type VectorPanoramaImpl from './panorama/vectorPanoramaImpl.js';
 
 export type FeatureStoreStaticRepresentation = {
   /**
@@ -179,9 +181,10 @@ class FeatureStoreLayer extends VectorLayer {
   constructor(options: FeatureStoreOptions) {
     const defaultOptions = FeatureStoreLayer.getDefaultOptions();
     super({
-      projection: defaultOptions.projection,
+      ...defaultOptions,
       ...options,
     });
+
     this._supportedMaps = [
       CesiumMap.className,
       OpenlayersMap.className,
@@ -315,10 +318,11 @@ class FeatureStoreLayer extends VectorLayer {
     | VectorOpenlayersImpl
     | VectorCesiumImpl
     | CesiumTilesetCesiumImpl
+    | VectorPanoramaImpl
   )[] {
     const impls = super.createImplementationsForMap(map);
     if (
-      map instanceof CesiumMap &&
+      map instanceof BaseCesiumMap &&
       this.staticRepresentation &&
       this.staticRepresentation.threeDim
     ) {
@@ -588,9 +592,10 @@ class FeatureStoreLayer extends VectorLayer {
     }
   }
 
-  toJSON(): FeatureStoreOptions {
-    const config = super.toJSON() as Partial<FeatureStoreOptions>;
-    const defaultOptions = FeatureStoreLayer.getDefaultOptions();
+  toJSON(
+    defaultOptions = FeatureStoreLayer.getDefaultOptions(),
+  ): FeatureStoreOptions {
+    const config = super.toJSON(defaultOptions) as Partial<FeatureStoreOptions>;
 
     delete config.projection;
     const vcsMeta = this.vectorProperties.getVcsMeta({
@@ -616,6 +621,7 @@ class FeatureStoreLayer extends VectorLayer {
     if (this.hiddenStaticFeatureIds.size > 0) {
       config.hiddenStaticFeatureIds = [...this.hiddenStaticFeatureIds];
     }
+
     return config as FeatureStoreOptions;
   }
 

package/src/layer/flatGeobufLayer.ts

@@ -18,11 +18,17 @@ export default class FlatGeobufLayer extends VectorLayer {
     return {
       ...super.getDefaultOptions(),
       url: '',
+      ignoreMapLayerTypes: false,
     };
   }
 
   private _dataFetchedPromise: Promise<void> | undefined;
 
+  constructor(options: FlatGeobufLayerOptions) {
+    const defaultOptions = FlatGeobufLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
+  }
+
   async initialize(): Promise<void> {
     if (!this.initialized) {
       await super.initialize();
@@ -63,5 +69,11 @@ export default class FlatGeobufLayer extends VectorLayer {
     }
     return this.forceRedraw();
   }
+
+  override toJSON(
+    defaultOptions = FlatGeobufLayer.getDefaultOptions(),
+  ): VectorOptions {
+    return super.toJSON(defaultOptions);
+  }
 }
 layerClassRegistry.registerClass(FlatGeobufLayer.className, FlatGeobufLayer);

package/src/layer/geojsonLayer.ts

@@ -3,7 +3,7 @@ import type { FeatureCollection } from 'geojson';
 import type { VectorOptions } from './vectorLayer.js';
 import VectorLayer from './vectorLayer.js';
 import { parseGeoJSON, writeGeoJSONFeature } from './geojsonHelpers.js';
-import Projection, { wgs84Projection } from '../util/projection.js';
+import { wgs84Projection } from '../util/projection.js';
 import { layerClassRegistry } from '../classRegistry.js';
 import { getInitForUrl, requestJson } from '../util/fetch.js';
 
@@ -29,6 +29,7 @@ class GeoJSONLayer extends VectorLayer {
       ...VectorLayer.getDefaultOptions(),
       projection: wgs84Projection.toJSON(),
       features: undefined,
+      ignoreMapLayerTypes: false,
     };
   }
 
@@ -39,7 +40,7 @@ class GeoJSONLayer extends VectorLayer {
   constructor(options: GeoJSONOptions) {
     const defaultOptions = GeoJSONLayer.getDefaultOptions();
     super({
-      projection: defaultOptions.projection,
+      ...defaultOptions,
       ...options,
     });
     this._featuresToLoad = options.features || defaultOptions.features;
@@ -120,16 +121,8 @@ class GeoJSONLayer extends VectorLayer {
     }
   }
 
-  toJSON(): GeoJSONOptions {
-    const config: GeoJSONOptions = super.toJSON();
-    const defaultOptions = GeoJSONLayer.getDefaultOptions();
-
-    const defaultProjection = new Projection(defaultOptions.projection);
-    if (!this.projection.equals(defaultProjection)) {
-      config.projection = this.projection.toJSON();
-    } else {
-      delete config.projection;
-    }
+  toJSON(defaultOptions = GeoJSONLayer.getDefaultOptions()): GeoJSONOptions {
+    const config: GeoJSONOptions = super.toJSON(defaultOptions);
 
     if (Array.isArray(this._featuresToLoad)) {
       config.features = this._featuresToLoad.slice();