@open-pioneer/map 0.1.0

package/api/MapConfig.d.ts

@@ -0,0 +1,111 @@
+import type { MapOptions as OlMapBaseOptions } from "ol/Map";
+import type OlView from "ol/View";
+import type { ViewOptions as OlViewOptions } from "ol/View";
+import { Layer } from "./layers";
+/**
+ * Configures an extent.
+ *
+ * Coordinates must be valid for the map's configured projection.
+ */
+export interface ExtentConfig {
+    xMin: number;
+    yMin: number;
+    xMax: number;
+    yMax: number;
+}
+/**
+ * Configures a coordinate.
+ *
+ * Coordinates must be valid for the map's configured projection.
+ */
+export interface CoordinateConfig {
+    x: number;
+    y: number;
+    z?: number;
+}
+/**
+ * Configures the map's initial extent.
+ */
+export interface InitialExtentConfig {
+    kind: "extent";
+    extent: ExtentConfig;
+}
+/**
+ * Configures the map's initial position.
+ */
+export interface InitialPositionConfig {
+    kind: "position";
+    center: CoordinateConfig;
+    zoom: number;
+}
+/**
+ * Configures the map's initial view.
+ */
+export type InitialViewConfig = InitialExtentConfig | InitialPositionConfig;
+/**
+ * Advanced options during map construction.
+ */
+export interface OlMapOptions extends Omit<OlMapBaseOptions, "target" | "view"> {
+    /**
+     * Advanced options to control the view.
+     *
+     * We recommend using the `OlViewOptions` type.
+     *
+     * > Warning: When a fully constructed `OlView` instance is provided, some options
+     * > of {@link MapConfig} (such as `initialView` or `projection`) cannot be applied anymore.
+     */
+    view: OlView | OlViewOptions | Promise<OlViewOptions> | undefined;
+}
+/**
+ * Options supported during map construction.
+ */
+export interface MapConfig {
+    /**
+     * Configures the initial view.
+     * This can be an extent, or a (center, zoom) value.
+     */
+    initialView?: InitialViewConfig;
+    /**
+     * Configures a specific projection, e.g. `"EPSG:4326"`.
+     * Defaults to `EPSG:3857`.
+     *
+     * To use custom projections, make sure that they are registered first:
+     *
+     * ```ts
+     * import { registerProjections } from "@open-pioneer/map";
+     *
+     * // Usually done at the top of the module.
+     * // This will register the projection(s) in proj4's global registry.
+     * registerProjections({
+     *   "EPSG:31466": "+proj=tmerc +lat_0=0 +lon_0=6 +k=1 +x_0=2500000 +y_0=0 +ellps=bessel +nadgrids=BETA2007.gsb +units=m +no_defs +type=crs",
+     *   // ... more projections
+     * });
+     *
+     * // later, use projection: "EPSG:31466"
+     * ```
+     */
+    projection?: "EPSG:3857" | "EPSG:4326" | "EPSG:25832" | "EPSG:25833" | (string & {});
+    /**
+     * Configures the layers of the map.
+     *
+     * **Layer order**
+     *
+     * Layers defined in this array are (by default) displayed in their listed order:
+     * layers defined first are shown at the bottom, and layers defined at a later position
+     * are shown _above_ their predecessors.
+     *
+     * Note: base layers are always shown below all operational layers.
+     */
+    layers?: Layer[];
+    /**
+     * Advanced OpenLayers configuration.
+     *
+     * Options in this object are passed to the OlMap's constructor.
+     * Other properties defined in this configuration (e.g. {@link initialView})
+     * will be applied on top of these map options.
+     *
+     * > Warning: Not all properties here are supported.
+     * > For example, you cannot set the `target` because the target is controlled by the `<MapContainer />`.
+     */
+    advanced?: Partial<OlMapOptions>;
+}

package/api/MapModel.d.ts

@@ -0,0 +1,112 @@
+import type { EventSource } from "@open-pioneer/core";
+import type OlMap from "ol/Map";
+import type OlBaseLayer from "ol/layer/Base";
+import type { ExtentConfig } from "./MapConfig";
+import type { Layer, LayerBase } from "./layers";
+import type { LayerRetrievalOptions } from "./shared";
+/** Events emitted by the {@link MapModel}. */
+export interface MapModelEvents {
+    "changed": void;
+    "changed:container": void;
+    "changed:initialExtent": void;
+    "destroy": void;
+}
+/**
+ * Represents a map.
+ */
+export interface MapModel extends EventSource<MapModelEvents> {
+    /**
+     * The unique id of the map.
+     */
+    readonly id: string;
+    /**
+     * The container in which the map is currently being rendered.
+     *
+     * May be undefined if the map is not being rendered at the moment.
+     * May change at runtime.
+     *
+     * The `changed:container` event is emitted when this value changes.
+     */
+    readonly container: HTMLElement | undefined;
+    /**
+     * The initial map extent.
+     *
+     * May be undefined before the map is shown.
+     * This is guaranteed to be initialized if the promise returned by {@link whenDisplayed} has resolved.
+     *
+     * The `changed:initialExtent` event is emitted when this value changes.
+     */
+    readonly initialExtent: ExtentConfig | undefined;
+    /**
+     * Contains all known layers of this map.
+     *
+     * Note that not all layers in this collection may be active in the OpenLayers map.
+     * Also note that not all layers in the OpenLayers map may be contained in this collection.
+     */
+    readonly layers: LayerCollection;
+    /**
+     * The raw OpenLayers map.
+     */
+    readonly olMap: OlMap;
+    /**
+     * Returns a promise that resolves when the map has mounted in the DOM.
+     */
+    whenDisplayed(): Promise<void>;
+}
+/** Events emitted by the {@link LayerCollection}. */
+export interface LayerCollectionEvents {
+    changed: void;
+}
+/**
+ * Contains the layers known to a {@link MapModel}.
+ */
+export interface LayerCollection extends EventSource<LayerCollectionEvents> {
+    /**
+     * Returns all configured base layers.
+     */
+    getBaseLayers(): Layer[];
+    /**
+     * Returns the currently active base layer.
+     */
+    getActiveBaseLayer(): Layer | undefined;
+    /**
+     * Activates the base layer with the given id.
+     * `undefined` can be used to hide all base layers.
+     *
+     * The associated layer is made visible and all other base layers are hidden.
+     *
+     * Returns true if the given layer has been successfully activated.
+     */
+    activateBaseLayer(id: string | undefined): boolean;
+    /**
+     * Adds a new layer to the map.
+     *
+     * The new layer is automatically registered with this collection.
+     *
+     * NOTE: by default, the new layer will be shown on _top_ of all existing layers.
+     */
+    addLayer(layer: Layer): void;
+    /**
+     * Returns all operational layers.
+     */
+    getOperationalLayers(options?: LayerRetrievalOptions): Layer[];
+    /**
+     * Returns the layer identified by the `id` or undefined, if no such layer exists.
+     */
+    getLayerById(id: string): LayerBase | undefined;
+    /**
+     * Returns all layers known to this collection.
+     */
+    getAllLayers(options?: LayerRetrievalOptions): Layer[];
+    /**
+     * Removes a layer identified by the `id` from the map.
+     *
+     * NOTE: The current implementation only supports removal of _top level_ layers.
+     */
+    removeLayerById(id: string): void;
+    /**
+     * Given a raw OpenLayers layer instance, returns the associated {@link Layer} - or undefined
+     * if the layer is unknown to this collection.
+     */
+    getLayerByRawInstance(olLayer: OlBaseLayer): Layer | undefined;
+}

package/api/MapRegistry.d.ts

@@ -0,0 +1,54 @@
+import type OlMap from "ol/Map";
+import type { MapConfig } from "./MapConfig";
+import type { MapModel } from "./MapModel";
+/**
+ * Provides access to registered map instances.
+ *
+ * Maps are identified by a unique id.
+ *
+ * Inject an instance of this service by referencing the interface name `"map.MapRegistry"`.
+ */
+export interface MapRegistry {
+    /**
+     * Returns the map model associated with the given id.
+     * Returns undefined if there is no such model.
+     */
+    getMapModel(mapId: string): Promise<MapModel | undefined>;
+    /**
+     * Like {@link getMapModel}, but throws if no model exists for the given `mapId`.
+     */
+    expectMapModel(mapId: string): Promise<MapModel>;
+    /**
+     * Given a raw OpenLayers map instance, returns the associated {@link MapModel} - or undefined
+     * if the map is unknown to this registry.
+     *
+     * All OpenLayers maps created by this registry (e.g. via {@link MapConfigProvider}) have an associated map model.
+     */
+    getMapModelByRawInstance(olMap: OlMap): MapModel | undefined;
+}
+/**
+ * Provides an OpenLayers map configuration with a given map id.
+ *
+ * The implementor must also provide the interface name `"map.MapConfigProvider"`.
+ */
+export interface MapConfigProvider {
+    /**
+     * Unique identifier of the map.
+     */
+    readonly mapId: string;
+    /**
+     * Returns the map configuration for this map.
+     *
+     * Called by the {@link MapRegistry} when the map is requested for the first time.
+     *
+     * See {@link MapConfig} for supported options.
+     */
+    getMapConfig(): Promise<MapConfig>;
+}
+import "@open-pioneer/runtime";
+declare module "@open-pioneer/runtime" {
+    interface ServiceRegistry {
+        "map.MapRegistry": MapRegistry;
+        "map.MapConfigProvider": MapConfigProvider;
+    }
+}

package/api/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./MapConfig";
+export * from "./MapModel";
+export * from "./MapRegistry";
+export * from "./layers";
+export * from "./shared";
+export { getProjection, registerProjections, type ProjectionDefinition } from "../projections";
+export { BkgTopPlusOpen, type BkgTopPlusOpenProps } from "../layers/BkgTopPlusOpen";
+export { useCenter, useProjection, useResolution, useScale } from "../ui/hooks";
+export { MapAnchor, type MapAnchorProps, type MapAnchorPosition } from "../ui/MapAnchor";
+export { MapContainer, type MapContainerProps, type MapPadding } from "../ui/MapContainer";
+export { useMapModel, type UseMapModelResult, type UseMapModelLoading, type UseMapModelResolved, type UseMapModelRejected } from "../ui/useMapModel";
+export { TOPMOST_LAYER_Z } from "../model/LayerCollectionImpl";

package/api/layers/SimpleLayer.d.ts

@@ -0,0 +1,24 @@
+import type OlBaseLayer from "ol/layer/Base";
+import { LayerConfig, Layer } from "./base";
+/**
+ * Options to construct a simple layer.
+ *
+ * Simple layers are wrappers around a custom OpenLayers layer.
+ */
+export interface SimpleLayerConfig extends LayerConfig {
+    /**
+     * The raw OpenLayers instance.
+     */
+    olLayer: OlBaseLayer;
+}
+/** Constructor for {@link SimpleLayer}. */
+export interface SimpleLayerConstructor {
+    prototype: SimpleLayer;
+    /** Creates a new {@link SimpleLayer}. */
+    new (config: SimpleLayerConfig): SimpleLayer;
+}
+/**
+ * A simple layer type wrapping an OpenLayers layer.
+ */
+export type SimpleLayer = Layer;
+export declare const SimpleLayer: SimpleLayerConstructor;

package/api/layers/SimpleLayer.js

@@ -0,0 +1,6 @@
+import { SimpleLayerImpl } from '../../model/layers/SimpleLayerImpl.js';
+
+const SimpleLayer = SimpleLayerImpl;
+
+export { SimpleLayer };
+//# sourceMappingURL=SimpleLayer.js.map

package/api/layers/SimpleLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimpleLayer.js","sources":["SimpleLayer.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2023 Open Pioneer project (https://github.com/open-pioneer)\n// SPDX-License-Identifier: Apache-2.0\nimport type OlBaseLayer from \"ol/layer/Base\";\nimport { LayerConfig, Layer } from \"./base\";\nimport { SimpleLayerImpl } from \"../../model/layers/SimpleLayerImpl\";\n\n/**\n * Options to construct a simple layer.\n *\n * Simple layers are wrappers around a custom OpenLayers layer.\n */\nexport interface SimpleLayerConfig extends LayerConfig {\n    /**\n     * The raw OpenLayers instance.\n     */\n    olLayer: OlBaseLayer;\n}\n\n/** Constructor for {@link SimpleLayer}. */\nexport interface SimpleLayerConstructor {\n    prototype: SimpleLayer;\n\n    /** Creates a new {@link SimpleLayer}. */\n    new (config: SimpleLayerConfig): SimpleLayer;\n}\n\n/**\n * A simple layer type wrapping an OpenLayers layer.\n */\nexport type SimpleLayer = Layer;\nexport const SimpleLayer: SimpleLayerConstructor = SimpleLayerImpl;\n"],"names":[],"mappings":";;AA8BO,MAAM,WAAsC,GAAA;;;;"}

package/api/layers/WMSLayer.d.ts

@@ -0,0 +1,42 @@
+import type { Options as WMSSourceOptions } from "ol/source/ImageWMS";
+import type { LayerBaseConfig, Layer, SublayersCollection } from "./base";
+/**
+ * Configuration options to construct a WMS layer.
+ */
+export interface WMSLayerConfig extends LayerBaseConfig {
+    /** URL of the WMS service. */
+    url: string;
+    /** Configures the layer's sublayers. */
+    sublayers?: WMSSublayerConfig[];
+    /**
+     * Additional source options for the layer's WMS source.
+     *
+     * NOTE: These options are intended for advanced configuration:
+     * the WMS Layer manages some of the open layers source options itself.
+     */
+    sourceOptions?: Partial<WMSSourceOptions>;
+}
+/**
+ * Configuration options to construct the sublayers of a WMS layer.
+ */
+export interface WMSSublayerConfig extends LayerBaseConfig {
+    /** The name of the WMS sublayer in the service's capabilities. */
+    name: string;
+    /** Configuration for nested sublayers. */
+    sublayers?: WMSSublayerConfig[];
+}
+/** Represents a WMS layer. */
+export interface WMSLayer extends Layer {
+    readonly sublayers: SublayersCollection;
+    /** The URL of the WMS service that was used during layer construction. */
+    readonly url: string;
+}
+/**
+ * Constructor for {@link WMSLayer}.
+ */
+export interface WMSLayerConstructor {
+    prototype: WMSLayer;
+    /** Creates a new {@link WMSLayer}. */
+    new (config: WMSLayerConfig): WMSLayer;
+}
+export declare const WMSLayer: WMSLayerConstructor;

package/api/layers/WMSLayer.js

@@ -0,0 +1,6 @@
+import { WMSLayerImpl } from '../../model/layers/WMSLayerImpl.js';
+
+const WMSLayer = WMSLayerImpl;
+
+export { WMSLayer };
+//# sourceMappingURL=WMSLayer.js.map

package/api/layers/WMSLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WMSLayer.js","sources":["WMSLayer.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2023 Open Pioneer project (https://github.com/open-pioneer)\n// SPDX-License-Identifier: Apache-2.0\nimport type { Options as WMSSourceOptions } from \"ol/source/ImageWMS\";\nimport { WMSLayerImpl } from \"../../model/layers/WMSLayerImpl\";\nimport type { LayerBaseConfig, Layer, SublayersCollection } from \"./base\";\n\n/**\n * Configuration options to construct a WMS layer.\n */\nexport interface WMSLayerConfig extends LayerBaseConfig {\n    /** URL of the WMS service. */\n    url: string;\n\n    /** Configures the layer's sublayers. */\n    sublayers?: WMSSublayerConfig[];\n\n    /**\n     * Additional source options for the layer's WMS source.\n     *\n     * NOTE: These options are intended for advanced configuration:\n     * the WMS Layer manages some of the open layers source options itself.\n     */\n    sourceOptions?: Partial<WMSSourceOptions>;\n}\n\n/**\n * Configuration options to construct the sublayers of a WMS layer.\n */\nexport interface WMSSublayerConfig extends LayerBaseConfig {\n    /** The name of the WMS sublayer in the service's capabilities. */\n    name: string;\n\n    /** Configuration for nested sublayers. */\n    sublayers?: WMSSublayerConfig[];\n}\n\n/** Represents a WMS layer. */\nexport interface WMSLayer extends Layer {\n    readonly sublayers: SublayersCollection;\n\n    /** The URL of the WMS service that was used during layer construction. */\n    readonly url: string;\n}\n\n/**\n * Constructor for {@link WMSLayer}.\n */\nexport interface WMSLayerConstructor {\n    prototype: WMSLayer;\n\n    /** Creates a new {@link WMSLayer}. */\n    new (config: WMSLayerConfig): WMSLayer;\n}\n\nexport const WMSLayer: WMSLayerConstructor = WMSLayerImpl;\n"],"names":[],"mappings":";;AAsDO,MAAM,QAAgC,GAAA;;;;"}

package/api/layers/base.d.ts

@@ -0,0 +1,170 @@
+import type { EventSource } from "@open-pioneer/core";
+import type OlBaseLayer from "ol/layer/Base";
+import type { MapModel } from "../MapModel";
+import type { LayerRetrievalOptions } from "../shared";
+/** Events emitted by the {@link Layer} and other layer types. */
+export interface LayerBaseEvents {
+    "changed": void;
+    "changed:title": void;
+    "changed:description": void;
+    "changed:visible": void;
+    "changed:attributes": void;
+    "changed:loadState": void;
+    "destroy": void;
+}
+/** The load state of a layer. */
+export type LayerLoadState = "not-loaded" | "loading" | "loaded" | "error";
+/**
+ * Configuration options supported by all layer types (layers and sublayers).
+ */
+export interface LayerBaseConfig {
+    /**
+     * The unique id of this layer.
+     * Defaults to a generated id.
+     */
+    id?: string;
+    /**
+     * The human-readable title of this layer.
+     */
+    title: string;
+    /**
+     * The human-readable description of this layer.
+     * Defaults to an empty string.
+     */
+    description?: string;
+    /**
+     * Whether this layer should initially be visible.
+     * Defaults to `true`.
+     */
+    visible?: boolean;
+    /**
+     * Additional attributes for this layer.
+     * These can be arbitrary values.
+     */
+    attributes?: Record<string | symbol, unknown>;
+}
+/**
+ * Interface shared by all layer types (operational layers and sublayers).
+ *
+ * Instances of this interface cannot be constructed directly; use a real layer
+ * class such as {@link SimpleLayer} instead.
+ */
+export interface LayerBase<AdditionalEvents = {}> extends EventSource<LayerBaseEvents & AdditionalEvents> {
+    /** The map this layer belongs to. */
+    readonly map: MapModel;
+    /**
+     * The unique id of this layer within its map model.
+     *
+     * NOTE: layer ids may not be globally unique: layers that belong
+     * to different map models may have the same id.
+     */
+    readonly id: string;
+    /** The human-readable title of this layer. */
+    readonly title: string;
+    /** The human-readable description of this layer. May be empty. */
+    readonly description: string;
+    /**
+     * Whether the layer is visible or not.
+     *
+     * NOTE: The model's visible state may do more than influence the raw OpenLayers's visibility property.
+     * Future versions may completely remove invisible layers from the OpenLayer's map under some circumstances.
+     */
+    readonly visible: boolean;
+    /**
+     * The collection of child sublayers for this layer.
+     *
+     * Layers that can never have any sublayers may not have a `sublayers` collection.
+     */
+    readonly sublayers: SublayersCollection | undefined;
+    /**
+     * Additional attributes associated with this layer.
+     */
+    readonly attributes: Readonly<Record<string | symbol, unknown>>;
+    /**
+     * Updates the title of this layer.
+     */
+    setTitle(newTitle: string): void;
+    /**
+     * Updates the description of this layer.
+     */
+    setDescription(newDescription: string): void;
+    /**
+     * Updates the visibility of this layer to the new value.
+     *
+     * NOTE: The visibility of base layers cannot be changed through this method.
+     * Call {@link LayerCollection.activateBaseLayer} instead.
+     */
+    setVisible(newVisibility: boolean): void;
+    /**
+     * Updates the attributes of this layer.
+     * Values in `newAttributes` are merged into the existing ones (i.e. via `Object.assign`).
+     */
+    updateAttributes(newAttributes: Record<string | symbol, unknown>): void;
+    /**
+     * Deletes the attribute of this layer.
+     */
+    deleteAttribute(deleteAttribute: string | symbol): void;
+}
+/**
+ * Configuration options supported by all operational layer types.
+ */
+export interface LayerConfig extends LayerBaseConfig {
+    /**
+     * Whether this layer is a base layer or not.
+     * Only one base layer can be active at a time.
+     *
+     * Defaults to `false`.
+     */
+    isBaseLayer?: boolean;
+}
+/**
+ * Represents an operational layer in the map.
+ *
+ * Instances of this interface cannot be constructed directly; use a real layer
+ * class such as {@link SimpleLayer} instead.
+ */
+export interface Layer<AdditionalEvents = {}> extends LayerBase<AdditionalEvents> {
+    /**
+     * The load state of a layer.
+     */
+    readonly loadState: LayerLoadState;
+    /**
+     * The raw OpenLayers layer.
+     */
+    readonly olLayer: OlBaseLayer;
+    /**
+     * True if this layer is a base layer.
+     *
+     * Only one base layer can be visible at a time.
+     */
+    readonly isBaseLayer: boolean;
+}
+/**
+ * Represents a sublayer of another layer.
+ */
+export interface Sublayer extends LayerBase {
+    /**
+     * The direct parent of this layer instance.
+     * This can either be the parent layer or another sublayer.
+     */
+    readonly parent: Layer | Sublayer;
+    /**
+     * The parent layer that owns this sublayer.
+     */
+    readonly parentLayer: Layer;
+}
+/**
+ * Events emitted by the {@link SublayersCollection}.
+ */
+export interface SublayersCollectionEvents {
+    changed: void;
+}
+/**
+ * Contains the sublayers that belong to a {@link Layer} or {@link Sublayer}.
+ */
+export interface SublayersCollection extends EventSource<SublayersCollectionEvents> {
+    /**
+     * Returns the child sublayers in this collection.
+     */
+    getSublayers(options?: LayerRetrievalOptions): Sublayer[];
+}

package/api/layers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./base";
+export * from "./SimpleLayer";
+export * from "./WMSLayer";

package/api/shared.d.ts

@@ -0,0 +1,10 @@
+/** These options can be used by some APIs returning an array of layers (or sublayers). */
+export interface LayerRetrievalOptions {
+    /**
+     * If set to `true`, layers will be ordered by their display order:
+     * Layers listed first in the returned array are shown _below_ layers listed at a later index.
+     *
+     * By default, layers are returned in arbitrary order.
+     */
+    sortByDisplayOrder?: boolean;
+}

package/index.d.ts

@@ -0,0 +1 @@
+export * from "./api";

package/index.js

@@ -0,0 +1,11 @@
+import '@open-pioneer/runtime';
+export { SimpleLayer } from './api/layers/SimpleLayer.js';
+export { WMSLayer } from './api/layers/WMSLayer.js';
+export { getProjection, registerProjections } from './projections.js';
+export { BkgTopPlusOpen } from './layers/BkgTopPlusOpen.js';
+export { useCenter, useProjection, useResolution, useScale } from './ui/hooks.js';
+export { MapAnchor } from './ui/MapAnchor.js';
+export { MapContainer } from './ui/MapContainer.js';
+export { useMapModel } from './ui/useMapModel.js';
+export { TOPMOST_LAYER_Z } from './model/LayerCollectionImpl.js';
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}

package/layers/BkgTopPlusOpen.d.ts

@@ -0,0 +1,21 @@
+import WMTS from "ol/source/WMTS";
+/** @internal */
+export interface BkgTopPlusOpenProps {
+    /**
+     * The name of the requesting layer.
+     * @default "web"
+     */
+    layer?: "web" | "web_grau" | "web_light";
+}
+/**
+ * Layer source for BKG TopPlus Open.
+ *
+ * Used for @open-pioneer unit tests: not part of the public interface.
+ *
+ * @see https://gdz.bkg.bund.de/index.php/default/wmts-topplusopen-wmts-topplus-open.html
+ *
+ * @internal
+ */
+export declare class BkgTopPlusOpen extends WMTS {
+    constructor(options?: BkgTopPlusOpenProps);
+}

package/layers/BkgTopPlusOpen.js

@@ -0,0 +1,61 @@
+import WMTS from 'ol/source/WMTS';
+import WMTSTileGrid from 'ol/tilegrid/WMTS';
+
+class BkgTopPlusOpen extends WMTS {
+  constructor(options) {
+    const topLeftCorner = [-380316598427299e-8, 880590808284866e-8];
+    const resolutions = [
+      4891.96981025128,
+      // AdV-Level 0  (1:17471320.7508974)
+      2445.98490512564,
+      // AdV-Level 1  (1:8735660.37544872)
+      1222.99245256282,
+      // AdV-Level 2  (1:4367830.18772436)
+      611.49622628141,
+      // AdV-Level 3   (1:2183915.09386218)
+      305.748113140705,
+      // AdV-Level 4  (1:1091957.54693109)
+      152.874056570353,
+      // AdV-Level 5  (1:545978.773465545)
+      76.4370282851763,
+      // AdV-Level 6  (1:272989,386732772)
+      38.2185141425881,
+      // AdV-Level 7  (1:136494,693366386)
+      19.1092570712941,
+      // AdV-Level 8  (1:68247,3466831931)
+      9.55462853564703,
+      // AdV-Level 9  (1:34123,6733415966)
+      4.77731426782352,
+      // AdV-Level 10 (1:17061,8366707983)
+      2.38865713391176,
+      // AdV-Level 11 (1:8530,91833539914)
+      1.19432856695588,
+      // AdV-Level 12 (1:4265,45916769957)
+      0.59716428347794
+      // AdV-Level 13 (1:2132,72958384978)
+    ];
+    const matrixIds = new Array(resolutions.length);
+    for (let i = 0; i < resolutions.length; i++) {
+      matrixIds[i] = i;
+    }
+    const layer = options?.layer ?? "web";
+    super({
+      url: `https://sgx.geodatenzentrum.de/wmts_topplus_open/tile/1.0.0/${layer}/{Style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.png`,
+      layer,
+      matrixSet: "EU_EPSG_25832_TOPPLUS",
+      format: "image/png",
+      projection: "EPSG:25832",
+      requestEncoding: "REST",
+      tileGrid: new WMTSTileGrid({
+        origin: topLeftCorner,
+        resolutions,
+        matrixIds
+      }),
+      style: "default",
+      attributions: `Kartendarstellung und Pr\xE4sentationsgraphiken: \xA9 Bundesamt f\xFCr Kartographie und Geod\xE4sie ${( new Date()).getFullYear()}, <a href="https://sg.geodatenzentrum.de/web_public/gdz/datenquellen/Datenquellen_TopPlusOpen.html" target="_blank">Datenquellen</a>`
+    });
+  }
+}
+
+export { BkgTopPlusOpen };
+//# sourceMappingURL=BkgTopPlusOpen.js.map