@vcmap/core 6.2.4 → 6.3.0-rc.2

package/src/layer/cesium/i3sCesiumImpl.ts

@@ -0,0 +1,141 @@
+import type {
+  Cesium3DTile,
+  Cesium3DTileContent,
+  SplitDirection,
+} from '@vcmap-cesium/engine';
+import { I3SDataProvider } from '@vcmap-cesium/engine';
+import type BaseCesiumMap from '../../map/baseCesiumMap.js';
+import type StyleItem from '../../style/styleItem.js';
+import type { AttributeProvider } from '../../featureProvider/abstractAttributeProvider.js';
+import type { FeatureLayerImplementation } from '../featureLayer.js';
+import type FeatureVisibility from '../featureVisibility.js';
+import type GlobalHider from '../globalHider.js';
+import type { I3SImplementationOptions } from '../i3sLayer.js';
+import LayerImplementation from '../layerImplementation.js';
+import { allowPicking, vcsLayerName } from '../layerSymbols.js';
+import { getResourceOrUrl } from './resourceHelper.js';
+import {
+  createCesiumStylingContext,
+  createTilesetEventListeners,
+} from './cesiumTilesetCesiumImpl.js';
+
+class I3SCesiumImpl
+  extends LayerImplementation<BaseCesiumMap>
+  implements FeatureLayerImplementation
+{
+  static get className(): string {
+    return 'I3SCesiumImpl';
+  }
+
+  data: I3SDataProvider | null;
+  i3sOptions: I3SImplementationOptions;
+  splitDirection: SplitDirection;
+  style: StyleItem;
+  featureVisibility: FeatureVisibility;
+  globalHider: GlobalHider | undefined;
+  allowPicking: boolean;
+
+  attributeProvider?: AttributeProvider;
+  private _initializedPromise: Promise<I3SDataProvider> | null = null;
+  private _destroyStyle: (() => void) | null = null;
+  styleContent: (content: Cesium3DTileContent) => void;
+  updateStyle: (style: StyleItem) => void;
+  applyStyle: (tile: Cesium3DTile) => void;
+
+  constructor(map: BaseCesiumMap, options: I3SImplementationOptions) {
+    super(map, options);
+    this.data = null;
+    this.i3sOptions = options;
+    this.splitDirection = options.splitDirection;
+    this.style = options.style;
+    this.featureVisibility = options.featureVisibility;
+    this.globalHider = options.globalHider;
+    this.allowPicking = options.allowPicking;
+    this.attributeProvider = options.attributeProvider;
+
+    const stylingContext = createCesiumStylingContext(this);
+    this.styleContent = stylingContext.styleContent;
+    this.updateStyle = stylingContext.updateStyle;
+    this.applyStyle = stylingContext.applyStyle;
+    this._destroyStyle = stylingContext.destroy;
+  }
+
+  async initialize(): Promise<void> {
+    if (!this._initializedPromise) {
+      this._initializedPromise = I3SDataProvider.fromUrl(
+        getResourceOrUrl(this.url!, this.headers),
+        { ...this.i3sOptions, show: false },
+      );
+      this.data = await this._initializedPromise;
+
+      if (this.isDestroyed) {
+        this.data.destroy();
+        return;
+      }
+      this.data[vcsLayerName] = this.name;
+      this.data[allowPicking] = this.allowPicking;
+      this.data.layers.forEach(({ tileset }) => {
+        if (tileset) {
+          createTilesetEventListeners(this, tileset);
+        }
+      });
+
+      this.map.addPrimitiveCollection(this.data);
+      await super.initialize();
+
+      if (this.splitDirection) {
+        this.data.layers.forEach(({ tileset }) => {
+          if (tileset) {
+            tileset.splitDirection = this.splitDirection;
+          }
+        });
+      }
+      this.updateStyle(this.style);
+    }
+    await this._initializedPromise;
+  }
+
+  async activate(): Promise<void> {
+    await super.activate();
+    if (this.active && this.data) {
+      this.data.show = true;
+    }
+  }
+
+  deactivate(): void {
+    super.deactivate();
+    if (this.data) {
+      this.data.show = false;
+    }
+  }
+
+  updateSplitDirection(splitDirection: SplitDirection): void {
+    this.splitDirection = splitDirection;
+    if (this.data) {
+      this.data.layers.forEach(({ tileset }) => {
+        if (tileset) {
+          tileset.splitDirection = splitDirection;
+        }
+      });
+    }
+  }
+
+  destroy(): void {
+    if (this.data) {
+      if (this.map.initialized) {
+        const toRemove = this.data;
+        this.map.removePrimitiveCollection(toRemove);
+      } else {
+        this.data.destroy();
+      }
+      this.data = null;
+    }
+
+    if (this._destroyStyle) {
+      this._destroyStyle();
+    }
+
+    super.destroy();
+  }
+}
+export default I3SCesiumImpl;

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/vcsTile/vcsQuadtreeTileProvider.ts

@@ -91,10 +91,11 @@ export default class VcsQuadtreeTileProvider
         this.tilingScheme,
       );
 
+    const { tileProvider } = layerOptions;
     const { dataLevels, dataRange } = getDataTiles(
-      layerOptions.minLevel,
-      layerOptions.maxLevel,
-      layerOptions.tileProvider,
+      layerOptions.minLevel ?? tileProvider.baseLevels.at(-1) ?? 0,
+      layerOptions.maxLevel ?? tileProvider.baseLevels[0],
+      tileProvider,
     );
     this._dataLevels = dataLevels;
     this._dataRange = dataRange;

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/cesium/vectorRasterTileCesiumImpl.ts

@@ -33,8 +33,14 @@ class VectorRasterTileCesiumImpl extends RasterLayerCesiumImpl {
   imageryProvider: undefined | VectorTileImageryProvider = undefined;
 
   constructor(map: CesiumMap, options: VectorTileImplementationOptions) {
+    const minRenderingLevel = options.minLevel;
+    const maxRenderingLevel = options.maxLevel;
     const rasterLayerOptions: RasterLayerImplementationOptions = {
+      maxLevel: 25,
+      minLevel: 0,
       ...options,
+      minRenderingLevel,
+      maxRenderingLevel,
       tilingSchema: TilingScheme.MERCATOR,
       opacity: 1,
     };
@@ -50,12 +56,7 @@ class VectorRasterTileCesiumImpl extends RasterLayerCesiumImpl {
       headers: this.headers,
     });
 
-    const layerOptions: CesiumImageryLayer.ConstructorOptions = {
-      alpha: this.opacity,
-      splitDirection: this.splitDirection,
-      minimumTerrainLevel: this.minLevel,
-      maximumTerrainLevel: this.maxLevel,
-    };
+    const layerOptions = this.getCesiumLayerOptions();
     if (this.extent && this.extent.isValid()) {
       const extent = this.extent.getCoordinatesInProjection(wgs84Projection);
       layerOptions.rectangle = Rectangle.fromDegrees(

package/src/layer/cesium/vectorTileImageryProvider.ts

@@ -17,9 +17,9 @@ import type { Feature } from 'ol/index.js';
 // eslint-disable-next-line import/no-named-default
 import type { default as Style, StyleFunction } from 'ol/style/Style.js';
 import type TileProvider from '../tileProvider/tileProvider.js';
-import { rectangleToExtent } from '../tileProvider/tileProvider.js';
 import { wgs84ToMercatorTransformer } from '../../util/projection.js';
 import CanvasTileRenderer from '../../ol/render/canvas/canvasTileRenderer.js';
+import { rectangleToMercatorExtent } from '../../util/math.js';
 
 export function toContext(
   extent: Extent,
@@ -222,7 +222,7 @@ class VectorTileImageryProvider {
       y,
       level,
     );
-    const extent = rectangleToExtent(rectangle);
+    const extent = rectangleToMercatorExtent(rectangle);
     const center = Rectangle.center(rectangle);
     return getCanvasFromFeatures(features, extent, center, this._tileSize);
   }

package/src/layer/cesiumTilesetLayer.ts

@@ -4,7 +4,7 @@ import {
   type CustomShader,
   Matrix4,
 } from '@vcmap-cesium/engine';
-import { check, maybe } from '@vcsuite/check';
+import { check, is, maybe, oneOf } from '@vcsuite/check';
 import { parseInteger } from '@vcsuite/parsers';
 import type { Coordinate } from 'ol/coordinate.js';
 import type { VectorStyleItemOptions } from '../style/vectorStyleItem.js';
@@ -23,6 +23,14 @@ 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';
+import AbstractAttributeProvider, {
+  type AbstractAttributeProviderOptions,
+  type AttributeProvider,
+} from '../featureProvider/abstractAttributeProvider.js';
+import { getProviderForOption } from '../featureProvider/featureProviderFactory.js';
+import CompositeFeatureProvider from '../featureProvider/compositeFeatureProvider.js';
 
 export type CesiumTilesetOptions = LayerOptions & {
   /**
@@ -44,6 +52,10 @@ export type CesiumTilesetOptions = LayerOptions & {
    * a css string color to be used as an outline.
    */
   outlineColor?: string;
+  /**
+   * an optional attribute provider to provide custom attributes for the tileset features on load
+   */
+  attributeProvider?: AttributeProvider | AbstractAttributeProviderOptions;
 };
 
 export type CesiumTilesetTilesetProperties = {
@@ -59,6 +71,7 @@ export type CesiumTilesetImplementationOptions =
     modelMatrix?: Matrix4;
     offset?: Coordinate;
     customShader?: CustomShader;
+    attributeProvider?: AttributeProvider;
   };
 
 /**
@@ -94,14 +107,15 @@ class CesiumTilesetLayer extends FeatureLayer<CesiumTilesetCesiumImpl> {
 
   private _offset: Coordinate | undefined;
 
-  protected _supportedMaps = [CesiumMap.className];
+  protected _supportedMaps = [CesiumMap.className, PanoramaMap.className];
 
   private _customShader: CustomShader | undefined = undefined;
 
+  private _attributeProvider?: AttributeProvider;
+
   constructor(options: CesiumTilesetOptions) {
-    super(options);
-    this._supportedMaps = [CesiumMap.className];
     const defaultOptions = CesiumTilesetLayer.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
 
     this.highlightStyle = null;
     if (options.highlightStyle) {
@@ -137,6 +151,17 @@ class CesiumTilesetLayer extends FeatureLayer<CesiumTilesetCesiumImpl> {
     this._modelMatrix = undefined;
 
     this._offset = options.offset || defaultOptions.offset;
+
+    const attributeProvider = getProviderForOption(options.attributeProvider);
+
+    if (
+      is(
+        attributeProvider,
+        oneOf(CompositeFeatureProvider, AbstractAttributeProvider),
+      )
+    ) {
+      this._attributeProvider = attributeProvider;
+    }
   }
 
   /**
@@ -187,6 +212,26 @@ class CesiumTilesetLayer extends FeatureLayer<CesiumTilesetCesiumImpl> {
     }
   }
 
+  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)}`,
+        );
+      });
+    }
+  }
+
   getImplementationOptions(): CesiumTilesetImplementationOptions {
     return {
       ...super.getImplementationOptions(),
@@ -195,11 +240,12 @@ class CesiumTilesetLayer extends FeatureLayer<CesiumTilesetCesiumImpl> {
       modelMatrix: this.modelMatrix,
       offset: this.offset,
       customShader: this.customShader,
+      attributeProvider: this._attributeProvider,
     };
   }
 
   createImplementationsForMap(map: VcsMap): CesiumTilesetCesiumImpl[] {
-    if (map instanceof CesiumMap) {
+    if (map instanceof BaseCesiumMap) {
       return [
         new CesiumTilesetCesiumImpl(map, this.getImplementationOptions()),
       ];
@@ -244,9 +290,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();
     }
@@ -282,6 +329,10 @@ class CesiumTilesetLayer extends FeatureLayer<CesiumTilesetCesiumImpl> {
       config.offset = this.offset.slice();
     }
 
+    if (this._attributeProvider) {
+      config.attributeProvider = this._attributeProvider.toJSON();
+    }
+
     return config;
   }
 
@@ -289,6 +340,7 @@ class CesiumTilesetLayer extends FeatureLayer<CesiumTilesetCesiumImpl> {
    * disposes of this layer, removes instances from the current maps and the framework
    */
   destroy(): void {
+    this.attributeProvider?.destroy();
     super.destroy();
   }
 }

package/src/layer/cogLayer.ts

@@ -88,8 +88,8 @@ 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,
@@ -132,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) {

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();