From 2f99431f2d1809864120efddb71a12595569a7f2 Mon Sep 17 00:00:00 2001
From: Hendrik Oenings <hendrik.oenings@dataport.de>
Date: Tue, 13 Jan 2026 17:20:29 +0100
Subject: [PATCH 01/12] refactor(reverseGeocoder): introduce shared lib
 getRefStore

---
 src/lib/getRefStore.ts               | 13 +++++++++++++
 src/plugins/reverseGeocoder/store.ts |  9 +++------
 2 files changed, 16 insertions(+), 6 deletions(-)
 create mode 100644 src/lib/getRefStore.ts

diff --git a/src/lib/getRefStore.ts b/src/lib/getRefStore.ts
new file mode 100644
index 0000000000..bd466c7396
--- /dev/null
+++ b/src/lib/getRefStore.ts
@@ -0,0 +1,13 @@
+import type { StoreReference } from '@/core'
+import { useCoreStore } from '@/core/stores/export'
+
+/**
+ * Get the store for a `StoreReference`.
+ *
+ * @param ref - Store reference
+ * @returns Referenced store
+ */
+export function getRefStore(ref: StoreReference) {
+	const coreStore = useCoreStore()
+	return ref.plugin ? coreStore.getPluginStore(ref.plugin) : coreStore
+}
diff --git a/src/plugins/reverseGeocoder/store.ts b/src/plugins/reverseGeocoder/store.ts
index d39f2f70d9..07e2070a2c 100644
--- a/src/plugins/reverseGeocoder/store.ts
+++ b/src/plugins/reverseGeocoder/store.ts
@@ -12,6 +12,7 @@ import { acceptHMRUpdate, defineStore } from 'pinia'
 import { computed, ref, watch, type Reactive, type WatchHandle } from 'vue'
 
 import { useCoreStore } from '@/core/stores'
+import { getRefStore } from '@/lib/getRefStore'
 import { indicateLoading } from '@/lib/indicateLoading'
 
 import {
@@ -41,9 +42,7 @@ export const useReverseGeocoderStore = defineStore(
 
 		function setupPlugin() {
 			for (const source of configuration.value.coordinateSources || []) {
-				const store = source.plugin
-					? coreStore.getPluginStore(source.plugin)
-					: coreStore
+				const store = getRefStore(source)
 				if (!store) {
 					continue
 				}
@@ -71,9 +70,7 @@ export const useReverseGeocoderStore = defineStore(
 			target: NonNullable<ReverseGeocoderPluginOptions['addressTarget']>,
 			feature: ReverseGeocoderFeature
 		) {
-			const targetStore = target.plugin
-				? coreStore.getPluginStore(target.plugin)
-				: coreStore
+			const targetStore = getRefStore(target)
 			if (!targetStore) {
 				return
 			}

From 74e98dd1cde43759cd05805b3849ddca85e5f1b3 Mon Sep 17 00:00:00 2001
From: Hendrik Oenings <hendrik.oenings@dataport.de>
Date: Tue, 13 Jan 2026 17:22:14 +0100
Subject: [PATCH 02/12] feat(core): export `center` and `extent` as instable
 API

---
 src/core/components/PolarMap.ce.vue |  4 +++-
 src/core/stores/index.ts            | 15 +++++++++++++++
 src/core/stores/main.ts             |  3 +++
 3 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/src/core/components/PolarMap.ce.vue b/src/core/components/PolarMap.ce.vue
index 7f788a0422..dad3ac922b 100644
--- a/src/core/components/PolarMap.ce.vue
+++ b/src/core/components/PolarMap.ce.vue
@@ -31,13 +31,15 @@ import { updateDragAndZoomInteractions } from '../utils/map/updateDragAndZoomInt
 import PolarMapOverlay from './PolarMapOverlay.ce.vue'
 
 const mainStore = useMainStore()
-const { hasWindowSize, hasSmallDisplay, center, zoom } = storeToRefs(mainStore)
+const { hasWindowSize, hasSmallDisplay, center, extent, zoom } =
+	storeToRefs(mainStore)
 
 const polarMapContainer = useTemplateRef<HTMLDivElement>('polar-map-container')
 const overlay = useTemplateRef<typeof PolarMapOverlay>('polar-map-overlay')
 
 function onMove() {
 	center.value = mainStore.map.getView().getCenter() || center.value
+	extent.value = mainStore.map.getView().calculateExtent()
 	zoom.value = mainStore.map.getView().getZoom() || zoom.value
 }
 
diff --git a/src/core/stores/index.ts b/src/core/stores/index.ts
index 88a82d49c4..24b92ed3ab 100644
--- a/src/core/stores/index.ts
+++ b/src/core/stores/index.ts
@@ -29,6 +29,13 @@ export const useCoreStore = defineStore('core', () => {
 	const markerStore = useMarkerStore()
 
 	return {
+		/**
+		 * Read or modify center coordinate of the map.
+		 *
+		 * @internal
+		 */
+		center: mainStoreRefs.center,
+
 		/**
 		 * Color scheme the client should be using.
 		 *
@@ -60,6 +67,14 @@ export const useCoreStore = defineStore('core', () => {
 		 */
 		deviceIsHorizontal: computed(() => mainStore.deviceIsHorizontal),
 
+		/**
+		 * Extent of the map.
+		 *
+		 * @alpha
+		 * @readonly
+		 */
+		extent: computed(() => mainStore.extent),
+
 		/**
 		 * Whether the map has a maximum height of {@link SMALL_DISPLAY_HEIGHT} and
 		 * a maximum width of {@link SMALL_DISPLAY_WIDTH}.
diff --git a/src/core/stores/main.ts b/src/core/stores/main.ts
index e997721b57..de7e876255 100644
--- a/src/core/stores/main.ts
+++ b/src/core/stores/main.ts
@@ -1,5 +1,6 @@
 import type { Feature, Map } from 'ol'
 import type { Coordinate } from 'ol/coordinate'
+import type { Extent } from 'ol/extent'
 import type { Point } from 'ol/geom'
 
 import { toMerged } from 'es-toolkit'
@@ -27,6 +28,7 @@ export const useMainStore = defineStore('main', () => {
 			defaults
 		)
 	)
+	const extent = ref<Extent>([0, 0, 0, 0])
 	const language = ref('')
 	const lightElement = ref<HTMLElement | null>(null)
 	const map = shallowRef({} as Map)
@@ -100,6 +102,7 @@ export const useMainStore = defineStore('main', () => {
 		serviceRegister,
 		shadowRoot,
 		center,
+		extent,
 		zoom,
 		// Getters
 		layout,

From 0da4c0aace7a1fc2e4cbbf30975169fa28fcecb7 Mon Sep 17 00:00:00 2001
From: Hendrik Oenings <hendrik.oenings@dataport.de>
Date: Fri, 16 Jan 2026 13:54:17 +0100
Subject: [PATCH 03/12] feat(core): add shared pagination component

---
 src/components/kern/KernPagination.ce.vue | 154 ++++++++++++++++++++++
 src/core/types/locales.ts                 |  12 +-
 src/core/vuePlugins/i18next.ts            |   7 +
 src/locales.ts                            |  59 +++++++++
 4 files changed, 229 insertions(+), 3 deletions(-)
 create mode 100644 src/components/kern/KernPagination.ce.vue
 create mode 100644 src/locales.ts

diff --git a/src/components/kern/KernPagination.ce.vue b/src/components/kern/KernPagination.ce.vue
new file mode 100644
index 0000000000..8d717fa4c3
--- /dev/null
+++ b/src/components/kern/KernPagination.ce.vue
@@ -0,0 +1,154 @@
+<template>
+	<nav
+		v-if="pageCount > 1"
+		:aria-label="$t(($) => $.pagination.wrapper, { ns: 'shared' })"
+	>
+		<ul>
+			<li>
+				<button
+					class="kern-btn kern-btn--secondary"
+					:disabled="currentPage <= 1"
+					@click="currentPage--"
+				>
+					<span class="kern-icon kern-icon--arrow-back"></span>
+					<span class="kern-label kern-sr-only">
+						{{ $t(($) => $.pagination.previous, { ns: 'shared' }) }}
+					</span>
+				</button>
+			</li>
+			<li
+				v-for="option of visibleOptions"
+				:key="'dots' in option ? option.dots : option.page"
+			>
+				<template v-if="'dots' in option">…</template>
+				<button
+					v-else-if="option.page"
+					class="kern-btn kern-btn--secondary"
+					:class="{ active: currentPage === option.page }"
+					:aria-label="
+						$t(($) => $.pagination.page, { ns: 'shared', page: option.page })
+					"
+					@click="currentPage = option.page"
+				>
+					<span class="kern-label">
+						{{ option.page }}
+					</span>
+				</button>
+			</li>
+			<li>
+				<button
+					class="kern-btn kern-btn--secondary"
+					:disabled="currentPage >= pageCount"
+					@click="currentPage++"
+				>
+					<span class="kern-icon kern-icon--arrow-forward"></span>
+					<span class="kern-label kern-sr-only">
+						{{ $t(($) => $.pagination.next, { ns: 'shared' }) }}
+					</span>
+				</button>
+			</li>
+		</ul>
+	</nav>
+</template>
+
+<script lang="ts" setup>
+import { computed, watch } from 'vue'
+
+const props = defineProps<{
+	count: number
+	pageSize: number
+}>()
+
+const startIndex = defineModel<number>({ required: true })
+const currentPage = computed({
+	get: () => startIndex.value / props.pageSize + 1,
+	set: (page) => {
+		startIndex.value = (page - 1) * props.pageSize
+	},
+})
+
+const pageCount = computed(() => Math.ceil(props.count / props.pageSize))
+
+watch([() => props.count, () => props.pageSize], () => {
+	if (currentPage.value > pageCount.value) {
+		startIndex.value = 0
+	}
+})
+
+const visibleOptions = computed<({ dots: string } | { page: number })[]>(() => {
+	const generatePageInterval = (start: number, end: number) =>
+		new Array(end - start + 1).fill(null).map((_, idx) => ({
+			page: idx + start,
+		}))
+
+	if (pageCount.value <= 7) {
+		return generatePageInterval(1, pageCount.value)
+	}
+
+	if (currentPage.value < 5) {
+		return [
+			...generatePageInterval(1, 5),
+			{ dots: 'only' },
+			...generatePageInterval(pageCount.value, pageCount.value),
+		]
+	}
+
+	if (currentPage.value > pageCount.value - 4) {
+		return [
+			...generatePageInterval(1, 1),
+			{ dots: 'only' },
+			...generatePageInterval(pageCount.value - 4, pageCount.value),
+		]
+	}
+
+	return [
+		...generatePageInterval(1, 1),
+		{ dots: 'only' },
+		...generatePageInterval(currentPage.value - 1, currentPage.value + 1),
+		{ dots: 'only' },
+		...generatePageInterval(pageCount.value, pageCount.value),
+	]
+})
+</script>
+
+<style scoped>
+nav {
+	width: 100%;
+}
+
+ul {
+	width: 100%;
+	display: flex;
+	list-style-type: none;
+	padding: 0;
+	align-items: center;
+	justify-content: space-between;
+	gap: var(--kern-metric-space-x-small);
+}
+
+.kern-btn {
+	padding: 0;
+	min-width: var(--kern-metric-dimension-large);
+	min-height: calc(
+		var(--kern-metric-dimension-large) + var(--kern-metric-dimension-2x-small)
+	);
+
+	&:has(.kern-sr-only) {
+		width: var(--kern-metric-dimension-large);
+	}
+
+	&.active {
+		background-color: var(--kern-color-action-default);
+		pointer-events: none;
+
+		.kern-label {
+			color: white;
+		}
+	}
+
+	.kern-label {
+		font-size: var(--kern-typography-font-size-static-small);
+		line-height: var(--kern-typography-line-height-static-small);
+	}
+}
+</style>
diff --git a/src/core/types/locales.ts b/src/core/types/locales.ts
index 43ac237249..496c9d0c06 100644
--- a/src/core/types/locales.ts
+++ b/src/core/types/locales.ts
@@ -2,7 +2,8 @@ import type { ResourceKey } from 'i18next'
 
 import type { BundledPluginId, BundledPluginLocaleResources } from '@/core'
 import type { resourcesEn as core } from '@/core/locales'
-import type { CoreId } from '@/core/vuePlugins/i18next'
+import type { resourcesEn as shared } from '@/locales'
+import type { CoreId, SharedId } from '@/core/vuePlugins/i18next'
 
 /** @internal */
 export interface Locale {
@@ -12,9 +13,14 @@ export interface Locale {
 
 /** @internal */
 export type LocaleResources = {
-	[T in typeof CoreId | BundledPluginId]: T extends BundledPluginId
+	[T in
+		| typeof CoreId
+		| typeof SharedId
+		| BundledPluginId]: T extends BundledPluginId
 		? BundledPluginLocaleResources<T>
-		: typeof core
+		: T extends typeof SharedId
+			? typeof shared
+			: typeof core
 }
 
 type ToLocaleOverride<T> = T extends string
diff --git a/src/core/vuePlugins/i18next.ts b/src/core/vuePlugins/i18next.ts
index 17fee380a5..5c3291f0c3 100644
--- a/src/core/vuePlugins/i18next.ts
+++ b/src/core/vuePlugins/i18next.ts
@@ -5,8 +5,10 @@ import LanguageDetector from 'i18next-browser-languagedetector'
 import I18NextVue from 'i18next-vue'
 
 import locales from '../locales'
+import sharedLocales from '@/locales'
 
 export const CoreId = 'core'
+export const SharedId = 'shared'
 
 export const I18Next: Plugin = {
 	async install(app) {
@@ -28,6 +30,11 @@ export const I18Next: Plugin = {
 				supportedLngs: locales.map(({ type }) => type),
 			})
 
+			// This is no plugin itself, but bundled for usage of all plugins
+			sharedLocales.forEach((lng) => {
+				i18next.addResourceBundle(lng.type, SharedId, lng.resources, true)
+			})
+
 			// eslint-disable-next-line no-console
 			console.info(`Successfully initialized i18next.`)
 		} catch (error: unknown) {
diff --git a/src/locales.ts b/src/locales.ts
new file mode 100644
index 0000000000..28806ca6e1
--- /dev/null
+++ b/src/locales.ts
@@ -0,0 +1,59 @@
+/* eslint-disable tsdoc/syntax */
+/**
+ * This is the documentation for the locales keys for POLAR shared components.
+ * These locales are *NOT* exported, but documented only.
+ *
+ * @module locales/shared
+ */
+/* eslint-enable tsdoc/syntax */
+
+import type { Locale } from '@/core/types'
+
+/**
+ * German locales for POLAR core.
+ * For overwriting these values, pass a partial object of this in `locales`.
+ */
+export const resourcesDe = {
+	pagination: {
+		currentPage: 'Aktuelle Seite, Seite {{page}}',
+		page: 'Seite {{page}}',
+		next: 'Nächste Seite',
+		previous: 'Vorherige Seite',
+		wrapper: 'Seitenauswahl',
+	},
+} as const
+
+/**
+ * English locales for POLAR core.
+ * For overwriting these values, pass a partial object of this in `locales`.
+ */
+export const resourcesEn = {
+	pagination: {
+		currentPage: 'Aktuelle Seite, Seite {{page}}',
+		page: 'Seite {{page}}',
+		next: 'Nächste Seite',
+		previous: 'Vorherige Seite',
+		wrapper: 'Seitenauswahl',
+	},
+} as const
+
+/**
+ * Core locales.
+ *
+ * @privateRemarks
+ * The first entry will be used as fallback.
+ *
+ * @internal
+ */
+const locales: Locale[] = [
+	{
+		type: 'de',
+		resources: resourcesDe,
+	},
+	{
+		type: 'en',
+		resources: resourcesEn,
+	},
+]
+
+export default locales

From 15972bfff219673bb5a3ba109cbaae995271fcf1 Mon Sep 17 00:00:00 2001
From: Hendrik Oenings <hendrik.oenings@dataport.de>
Date: Tue, 13 Jan 2026 17:24:02 +0100
Subject: [PATCH 04/12] test(snowbox): allow jumping to Hamburg via button

---
 examples/snowbox/YetAnotherEmptyComponent.vue | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/examples/snowbox/YetAnotherEmptyComponent.vue b/examples/snowbox/YetAnotherEmptyComponent.vue
index affcb15908..ca48bebf73 100644
--- a/examples/snowbox/YetAnotherEmptyComponent.vue
+++ b/examples/snowbox/YetAnotherEmptyComponent.vue
@@ -1,7 +1,17 @@
 <template>
-	<div style="background: #fff">Awesome</div>
+	<div style="background: #fff; z-index: 99999; pointer-events: all">
+		Awesome
+		<button @click="goHamburg()">Go to Hamburg</button>
+	</div>
 </template>
 
 <script setup lang="ts">
-// keep this block to enforce language
+// eslint-disable-next-line
+// @ts-nocheck
+
+const coreStore = document.getElementById('snowbox').store
+
+function goHamburg() {
+	coreStore.center = [561210, 5932600]
+}
 </script>

From d449c8d5d3a0eb16984bb7c1c3b2490bdba8683c Mon Sep 17 00:00:00 2001
From: Hendrik Oenings <hendrik.oenings@dataport.de>
Date: Mon, 16 Feb 2026 14:09:32 +0100
Subject: [PATCH 05/12] test(snowbox): debug assistant for browser devtools

The usually helpful variables (map, stores, etc.) are auto-exported as
global variables for use with the browser's devtools in snowbox.
---
 examples/snowbox/debug-assistant.js | 25 +++++++++++++++++++++++++
 examples/snowbox/index.html         |  1 +
 src/core/stores/index.ts            | 16 ++++++++++++++++
 src/core/stores/plugin.ts           |  5 ++++-
 4 files changed, 46 insertions(+), 1 deletion(-)
 create mode 100644 examples/snowbox/debug-assistant.js

diff --git a/examples/snowbox/debug-assistant.js b/examples/snowbox/debug-assistant.js
new file mode 100644
index 0000000000..49a8b521ff
--- /dev/null
+++ b/examples/snowbox/debug-assistant.js
@@ -0,0 +1,25 @@
+import { getStore } from '@polar/polar'
+
+function initializeDebugAssistant() {
+	const map = document.getElementById('snowbox')
+	const coreStore = getStore(map, 'core')
+	const activePluginIds = coreStore.activePluginIds
+
+	window.map = map
+	window.olMap = coreStore.map
+	window.coreStore = coreStore
+	window.activePluginIds = activePluginIds
+	for (const pluginId of activePluginIds) {
+		window[`${pluginId}Store`] = coreStore.getPluginStore(pluginId)
+	}
+}
+
+// We want to load as late as possible.
+// Especially, the timeout stuff from snowbox code should be done when doing this.
+setTimeout(() => {
+	initializeDebugAssistant()
+
+	// 7 seconds may be long sometimes, inform the developer about it.
+	// eslint-disable-next-line no-console
+	console.info('POLAR debug assistant was successfully initialized')
+}, 7000)
diff --git a/examples/snowbox/index.html b/examples/snowbox/index.html
index 79a0317df1..69c45bfbe9 100644
--- a/examples/snowbox/index.html
+++ b/examples/snowbox/index.html
@@ -8,6 +8,7 @@
 		<meta http-equiv="Cache-Control" content="no-cache, no-store, must-revalidate, max-age=0" />
 		<link rel="stylesheet" href="@polar/polar/polar.css" />
 		<script type="module" defer src="index.js"></script>
+		<script type="module" defer src="debug-assistant.js"></script>
 		<style>
 			/* style just for example page, not directly related to POLAR */
 			:root {
diff --git a/src/core/stores/index.ts b/src/core/stores/index.ts
index 24b92ed3ab..3fe6c611ee 100644
--- a/src/core/stores/index.ts
+++ b/src/core/stores/index.ts
@@ -115,6 +115,22 @@ export const useCoreStore = defineStore('core', () => {
 		 */
 		language: mainStoreRefs.language,
 
+		/**
+		 * Returns the layer with the given ID.
+		 *
+		 * @param layerId - ID of the layer
+		 * @alpha
+		 */
+		getLayer: mainStore.getLayer,
+
+		/**
+		 * List of all active plugin's IDs.
+		 *
+		 * @readonly
+		 * @alpha
+		 */
+		activePluginIds: computed(() => pluginStore.activePluginIds),
+
 		/**
 		 * Before instantiating the map, all required plugins have to be added. Depending on how you use POLAR, this may
 		 * already have been done. Ready-made clients (that is, packages prefixed `@polar/client-`) come with plugins prepared.
diff --git a/src/core/stores/plugin.ts b/src/core/stores/plugin.ts
index 25f0812ad2..6e1d943d15 100644
--- a/src/core/stores/plugin.ts
+++ b/src/core/stores/plugin.ts
@@ -1,7 +1,7 @@
 import { toMerged } from 'es-toolkit'
 import i18next from 'i18next'
 import { acceptHMRUpdate, defineStore } from 'pinia'
-import { markRaw, reactive } from 'vue'
+import { computed, markRaw, reactive } from 'vue'
 
 import type {
 	PluginContainer,
@@ -18,6 +18,8 @@ export const usePluginStore = defineStore('plugin', () => {
 	const plugins = reactive<PluginContainer[]>([])
 	const mainStore = useMainStore()
 
+	const activePluginIds = computed(() => plugins.map((plugin) => plugin.id))
+
 	function addPlugin(plugin: PluginContainer) {
 		const { id, locales, options, storeModule } = plugin
 
@@ -81,6 +83,7 @@ export const usePluginStore = defineStore('plugin', () => {
 
 	return {
 		plugins,
+		activePluginIds,
 		addPlugin,
 		removePlugin,
 		getPluginStore,

From 1234994ed36a2d6adcb0bf683dec2e4a45eeabf9 Mon Sep 17 00:00:00 2001
From: Hendrik Oenings <hendrik.oenings@dataport.de>
Date: Thu, 8 Jan 2026 14:58:10 +0100
Subject: [PATCH 06/12] feat(gfi): migrate plugin

---
 examples/snowbox/index.js                     |  82 ++++
 examples/snowbox/services.js                  |  10 +
 src/architecture.spec.ts                      |   2 +-
 src/components/kern/KernPagination.ce.vue     |   4 +-
 src/core/stores/index.ts                      |  27 +-
 src/core/stores/main.ts                       |   5 +
 src/core/types/locales.ts                     |   2 +-
 src/core/types/plugin.ts                      |   6 +
 src/core/utils/map/setupMarkers.ts            |  18 +-
 src/core/vuePlugins/i18next.ts                |   3 +-
 src/lib/getRefStore.ts                        |   3 +-
 src/lib/getVectorSource.ts                    |  27 ++
 src/plugins/gfi/components/GfiFeature.ce.vue  | 104 +++++
 .../gfi/components/GfiFeatureList.ce.vue      |  68 ++++
 src/plugins/gfi/components/GfiUI.ce.vue       |  48 +++
 .../gfi/composables/useFeatureDisplayLayer.ts |  86 +++++
 .../gfi/composables/useMultiSelection.ts      |  63 +++
 src/plugins/gfi/index.ts                      |  31 ++
 src/plugins/gfi/locales.ts                    |  94 +++++
 src/plugins/gfi/store.ts                      | 186 +++++++++
 src/plugins/gfi/stores/feature.ts             | 250 ++++++++++++
 src/plugins/gfi/stores/list.ts                | 233 ++++++++++++
 src/plugins/gfi/stores/main.ts                |  89 +++++
 src/plugins/gfi/types.ts                      | 359 ++++++++++++++++++
 src/plugins/gfi/utils/getSourceFeatures.ts    |  17 +
 src/plugins/gfi/utils/isValidHttpUrl.ts       |  17 +
 src/plugins/gfi/utils/requestGfi.ts           |  67 ++++
 src/plugins/gfi/utils/requestGfiGeoJson.ts    |  50 +++
 src/plugins/gfi/utils/requestGfiWfs.ts        | 122 ++++++
 src/plugins/gfi/utils/requestGfiWms.ts        | 210 ++++++++++
 src/plugins/gfi/utils/serializeFeature.ts     |  13 +
 src/plugins/gfi/utils/updateTooltip.ts        |  52 +++
 vue2/packages/plugins/Gfi/CHANGELOG.md        |  68 ----
 vue2/packages/plugins/Gfi/LICENSE             | 287 --------------
 vue2/packages/plugins/Gfi/README.md           | 242 ------------
 vue2/packages/plugins/Gfi/package.json        |  44 ---
 vue2/packages/plugins/Gfi/src/index.ts        |  14 -
 vue2/packages/plugins/Gfi/src/locales.ts      |  90 -----
 vue2/packages/plugins/Gfi/src/store/index.ts  |  19 -
 .../plugins/Gfi/src/store/mutations.ts        |  11 -
 vue2/packages/plugins/Gfi/src/types.ts        |  83 ----
 .../Gfi/src/utils/displayFeatureLayer.ts      |  48 ---
 .../plugins/Gfi/src/utils/isValidHttpUrl.js   |  11 -
 .../plugins/Gfi/src/utils/requestGfi.ts       |  65 ----
 .../Gfi/src/utils/requestGfiGeoJson.ts        |  49 ---
 .../plugins/Gfi/src/utils/requestGfiWfs.ts    | 112 ------
 .../plugins/Gfi/src/utils/requestGfiWms.ts    | 204 ----------
 vue2/packages/plugins/Gfi/vite.config.js      |   3 -
 vue2/packages/types/custom/core.ts            | 110 +-----
 49 files changed, 2340 insertions(+), 1468 deletions(-)
 create mode 100644 src/lib/getVectorSource.ts
 create mode 100644 src/plugins/gfi/components/GfiFeature.ce.vue
 create mode 100644 src/plugins/gfi/components/GfiFeatureList.ce.vue
 create mode 100644 src/plugins/gfi/components/GfiUI.ce.vue
 create mode 100644 src/plugins/gfi/composables/useFeatureDisplayLayer.ts
 create mode 100644 src/plugins/gfi/composables/useMultiSelection.ts
 create mode 100644 src/plugins/gfi/index.ts
 create mode 100644 src/plugins/gfi/locales.ts
 create mode 100644 src/plugins/gfi/store.ts
 create mode 100644 src/plugins/gfi/stores/feature.ts
 create mode 100644 src/plugins/gfi/stores/list.ts
 create mode 100644 src/plugins/gfi/stores/main.ts
 create mode 100644 src/plugins/gfi/types.ts
 create mode 100644 src/plugins/gfi/utils/getSourceFeatures.ts
 create mode 100644 src/plugins/gfi/utils/isValidHttpUrl.ts
 create mode 100644 src/plugins/gfi/utils/requestGfi.ts
 create mode 100644 src/plugins/gfi/utils/requestGfiGeoJson.ts
 create mode 100644 src/plugins/gfi/utils/requestGfiWfs.ts
 create mode 100644 src/plugins/gfi/utils/requestGfiWms.ts
 create mode 100644 src/plugins/gfi/utils/serializeFeature.ts
 create mode 100644 src/plugins/gfi/utils/updateTooltip.ts
 delete mode 100644 vue2/packages/plugins/Gfi/CHANGELOG.md
 delete mode 100644 vue2/packages/plugins/Gfi/LICENSE
 delete mode 100644 vue2/packages/plugins/Gfi/README.md
 delete mode 100644 vue2/packages/plugins/Gfi/package.json
 delete mode 100644 vue2/packages/plugins/Gfi/src/index.ts
 delete mode 100644 vue2/packages/plugins/Gfi/src/locales.ts
 delete mode 100644 vue2/packages/plugins/Gfi/src/store/index.ts
 delete mode 100644 vue2/packages/plugins/Gfi/src/store/mutations.ts
 delete mode 100644 vue2/packages/plugins/Gfi/src/types.ts
 delete mode 100644 vue2/packages/plugins/Gfi/src/utils/displayFeatureLayer.ts
 delete mode 100644 vue2/packages/plugins/Gfi/src/utils/isValidHttpUrl.js
 delete mode 100644 vue2/packages/plugins/Gfi/src/utils/requestGfi.ts
 delete mode 100644 vue2/packages/plugins/Gfi/src/utils/requestGfiGeoJson.ts
 delete mode 100644 vue2/packages/plugins/Gfi/src/utils/requestGfiWfs.ts
 delete mode 100644 vue2/packages/plugins/Gfi/src/utils/requestGfiWms.ts
 delete mode 100644 vue2/packages/plugins/Gfi/vite.config.js

diff --git a/examples/snowbox/index.js b/examples/snowbox/index.js
index fd2c0465c8..7f7e7f2910 100644
--- a/examples/snowbox/index.js
+++ b/examples/snowbox/index.js
@@ -9,6 +9,7 @@ import {
 import pluginFooter from '@polar/polar/plugins/footer'
 import pluginFullscreen from '@polar/polar/plugins/fullscreen'
 import pluginGeoLocation from '@polar/polar/plugins/geoLocation'
+import pluginGfi from '@polar/polar/plugins/gfi'
 import pluginIconMenu from '@polar/polar/plugins/iconMenu'
 import pluginLayerChooser from '@polar/polar/plugins/layerChooser'
 import pluginLoadingIndicator from '@polar/polar/plugins/loadingIndicator'
@@ -29,6 +30,7 @@ const basemapGreyId = '23421'
 const ausgleichsflaechen = '1454'
 const reports = '6059'
 const denkmal = 'denkmaelerWMS'
+const kielPolygon = 'kiel_polygon'
 const hamburgBorder = '1693'
 
 let colorScheme = 'light'
@@ -141,6 +143,12 @@ const map = await createMap(
 					},
 				},
 			},
+			{
+				id: kielPolygon,
+				type: 'mask',
+				name: 'Kiel Polygone',
+				visibility: true,
+			},
 		],
 		layout: 'standard',
 		checkServiceAvailability: true,
@@ -185,6 +193,18 @@ const map = await createMap(
 							label_off: 'Mach klein',
 						},
 					},
+					gfi: {
+						layer: {
+							[reports]: {
+								property: {
+									addr: 'Adresse',
+									statu: 'Status',
+									beschr: 'Beschr.',
+									kat_text: 'Kat.',
+								},
+							},
+						},
+					},
 					iconMenu: {
 						hints: {
 							attributions: 'LMAO',
@@ -302,6 +322,68 @@ addPlugin(
 					}),
 				},
 			],
+			[
+				{
+					plugin: pluginGfi({
+						layers: {
+							[reports]: {
+								window: true,
+								properties: [
+									'addr',
+									'statu',
+									'beschr',
+									'pic',
+									'kat_text',
+									'skat_text',
+								],
+								exportProperty: 'pic',
+								showTooltip: (feature) => [
+									[
+										'span',
+										`Coordinates: ${feature.getGeometry().getCoordinates().join(', ')}`,
+									],
+								],
+							},
+							[kielPolygon]: {
+								window: true,
+							},
+						},
+						afterLoadFunction: (featuresByLayerId) => {
+							Object.values(featuresByLayerId).forEach((featureList) => {
+								featureList.forEach((feature) => {
+									if (feature.properties) {
+										feature.properties = {
+											addr: [
+												feature.properties.str,
+												feature.properties.hsnr,
+											].join(' '),
+											...feature.properties,
+										}
+									}
+								})
+							})
+							return featuresByLayerId
+						},
+						featureList: {
+							activeLayers: {
+								plugin: 'layerChooser',
+								key: 'activeMaskIds',
+							},
+							mode: 'visible',
+							bindWithCoreHoverSelect: false,
+							pageLength: 5,
+							text: {
+								title: (feature) =>
+									feature.get('str') + ' ' + feature.get('hsnr'),
+								subtitle: 'Michels Meldung',
+								subSubtitle: (feature) => feature.get('skat_text'),
+							},
+						},
+						multiSelect: 'box',
+						directSelect: true,
+					}),
+				},
+			],
 			[
 				{
 					plugin: {
diff --git a/examples/snowbox/services.js b/examples/snowbox/services.js
index ba08843c92..8f07642a29 100644
--- a/examples/snowbox/services.js
+++ b/examples/snowbox/services.js
@@ -74,4 +74,14 @@ export default [
 		version: '1.3.0',
 		transparent: true,
 	},
+	{
+		id: 'kiel_polygon',
+		name: 'Kiel Polygon',
+		url: 'https://polar.dataport.de/qgisserver?MAP=/home/qgis/projects/dev_services.qgz',
+		typ: 'WFS',
+		featureType: 'polygon_kiel',
+		outputFormat: 'XML',
+		version: '1.1.0',
+		legendURL: '',
+	},
 ]
diff --git a/src/architecture.spec.ts b/src/architecture.spec.ts
index ff18b41f7a..ccd0f5ca2c 100644
--- a/src/architecture.spec.ts
+++ b/src/architecture.spec.ts
@@ -33,7 +33,7 @@ describe('Architectural checks', () => {
 			.matchingPattern('^plugins/.*$')
 			.should()
 			.matchPattern(
-				'^plugins/[^/]+/((index|locales|store|types)\\.ts|utils/.*\\.ts|components/.*\\.spec\\.ts)$'
+				'^plugins/[^/]+/((index|locales|store|types)\\.ts|utils/.*\\.ts|components/.*\\.spec\\.ts|stores/.*\\.ts|composables/.*\\.ts)$'
 			)
 			.check()
 		expect(violations).toEqual([])
diff --git a/src/components/kern/KernPagination.ce.vue b/src/components/kern/KernPagination.ce.vue
index 8d717fa4c3..9695eecc34 100644
--- a/src/components/kern/KernPagination.ce.vue
+++ b/src/components/kern/KernPagination.ce.vue
@@ -10,7 +10,7 @@
 					:disabled="currentPage <= 1"
 					@click="currentPage--"
 				>
-					<span class="kern-icon kern-icon--arrow-back"></span>
+					<span class="kern-icon kern-icon--arrow-back" />
 					<span class="kern-label kern-sr-only">
 						{{ $t(($) => $.pagination.previous, { ns: 'shared' }) }}
 					</span>
@@ -41,7 +41,7 @@
 					:disabled="currentPage >= pageCount"
 					@click="currentPage++"
 				>
-					<span class="kern-icon kern-icon--arrow-forward"></span>
+					<span class="kern-icon kern-icon--arrow-forward" />
 					<span class="kern-label kern-sr-only">
 						{{ $t(($) => $.pagination.next, { ns: 'shared' }) }}
 					</span>
diff --git a/src/core/stores/index.ts b/src/core/stores/index.ts
index 3fe6c611ee..6d8736af8f 100644
--- a/src/core/stores/index.ts
+++ b/src/core/stores/index.ts
@@ -4,9 +4,12 @@
  */
 /* eslint-enable tsdoc/syntax */
 
+import type { Feature } from 'ol'
+
 import { acceptHMRUpdate, defineStore, storeToRefs } from 'pinia'
 import { computed } from 'vue'
 
+import { updateSelection } from '../utils/map/setupMarkers'
 import { useMainStore } from './main'
 import { useMarkerStore } from './marker'
 import { useMoveHandleStore } from './moveHandle'
@@ -22,11 +25,13 @@ import { usePluginStore } from './plugin'
 export const useCoreStore = defineStore('core', () => {
 	const mainStore = useMainStore()
 	const mainStoreRefs = storeToRefs(mainStore)
+
 	const moveHandleStore = useMoveHandleStore()
 
 	const pluginStore = usePluginStore()
 
 	const markerStore = useMarkerStore()
+	const markerStoreRefs = storeToRefs(markerStore)
 
 	return {
 		/**
@@ -184,7 +189,7 @@ export const useCoreStore = defineStore('core', () => {
 		/**
 		 * Allows reading or setting the OIDC token used for service accesses.
 		 */
-		oidcToken: mainStore.oidcToken,
+		oidcToken: mainStoreRefs.oidcToken,
 
 		/**
 		 * Allows accessing the POLAR DOM element (`<polar-map>`).
@@ -220,6 +225,26 @@ export const useCoreStore = defineStore('core', () => {
 		 */
 		moveHandleTop: computed(() => moveHandleStore.top),
 
+		/**
+		 * Feature that is hovered by the user with a marker.
+		 * NOTE: Set _polarLayerId!
+		 *
+		 * @alpha
+		 */
+		hoveredFeature: markerStoreRefs.hovered,
+
+		/**
+		 * Feature that was selected by the user with a marker.
+		 *
+		 * @alpha
+		 */
+		selectedFeature: computed({
+			get: () => markerStore.selected,
+			set: (feature) => {
+				updateSelection(mainStore.map, feature as Feature)
+			},
+		}),
+
 		/**
 		 * Coordinates that were selected by the user with a marker.
 		 *
diff --git a/src/core/stores/main.ts b/src/core/stores/main.ts
index de7e876255..0590d6a0cd 100644
--- a/src/core/stores/main.ts
+++ b/src/core/stores/main.ts
@@ -79,6 +79,10 @@ export const useMainStore = defineStore('main', () => {
 		center.value = (feature.getGeometry() as Point).getCoordinates()
 	}
 
+	function getLayer(layerId: string) {
+		return map.value.getAllLayers().find((layer) => layer.get('id') === layerId)
+	}
+
 	function setup() {
 		addEventListener('resize', updateHasSmallDisplay)
 		updateHasSmallDisplay()
@@ -112,6 +116,7 @@ export const useMainStore = defineStore('main', () => {
 		deviceIsHorizontal,
 		// Actions
 		centerOnFeature,
+		getLayer,
 		updateHasSmallDisplay,
 		setup,
 		teardown,
diff --git a/src/core/types/locales.ts b/src/core/types/locales.ts
index 496c9d0c06..07ab53668e 100644
--- a/src/core/types/locales.ts
+++ b/src/core/types/locales.ts
@@ -2,8 +2,8 @@ import type { ResourceKey } from 'i18next'
 
 import type { BundledPluginId, BundledPluginLocaleResources } from '@/core'
 import type { resourcesEn as core } from '@/core/locales'
-import type { resourcesEn as shared } from '@/locales'
 import type { CoreId, SharedId } from '@/core/vuePlugins/i18next'
+import type { resourcesEn as shared } from '@/locales'
 
 /** @internal */
 export interface Locale {
diff --git a/src/core/types/plugin.ts b/src/core/types/plugin.ts
index d28d27fba1..da7cdc85bd 100644
--- a/src/core/types/plugin.ts
+++ b/src/core/types/plugin.ts
@@ -10,6 +10,9 @@ import type { useFullscreenStore as FullscreenStore } from '@/plugins/fullscreen
 import type { PluginId as GeoLocationPluginId } from '@/plugins/geoLocation'
 import type { resourcesEn as GeoLocationResources } from '@/plugins/geoLocation/locales'
 import type { useGeoLocationStore as GeoLocationStore } from '@/plugins/geoLocation/store'
+import type { PluginId as GfiPluginId } from '@/plugins/gfi'
+import type { resourcesEn as GfiResources } from '@/plugins/gfi/locales'
+import type { useGfiStore as GfiStore } from '@/plugins/gfi/store'
 import type { PluginId as IconMenuPluginId } from '@/plugins/iconMenu'
 import type { resourcesEn as IconMenuResources } from '@/plugins/iconMenu/locales'
 import type { useIconMenuStore as IconMenuStore } from '@/plugins/iconMenu/store'
@@ -84,6 +87,7 @@ export type BundledPluginId =
 	| typeof FooterPluginId
 	| typeof FullscreenPluginId
 	| typeof GeoLocationPluginId
+	| typeof GfiPluginId
 	| typeof IconMenuPluginId
 	| typeof LayerChooserPluginId
 	| typeof LoadingIndicatorId
@@ -105,6 +109,7 @@ export type BundledPluginStores<T extends BundledPluginId> =
 	| GetPluginStore<T, typeof FooterPluginId, typeof FooterStore>
 	| GetPluginStore<T, typeof FullscreenPluginId, typeof FullscreenStore>
 	| GetPluginStore<T, typeof GeoLocationPluginId, typeof GeoLocationStore>
+	| GetPluginStore<T, typeof GfiPluginId, typeof GfiStore>
 	| GetPluginStore<T, typeof IconMenuPluginId, typeof IconMenuStore>
 	| GetPluginStore<T, typeof LayerChooserPluginId, typeof LayerChooserStore>
 	| GetPluginStore<T, typeof LoadingIndicatorId, typeof LoadingIndicatorStore>
@@ -131,6 +136,7 @@ export type BundledPluginLocaleResources<T extends BundledPluginId> =
 			typeof GeoLocationPluginId,
 			typeof GeoLocationResources
 	  >
+	| GetPluginResources<T, typeof GfiPluginId, typeof GfiResources>
 	| GetPluginResources<T, typeof IconMenuPluginId, typeof IconMenuResources>
 	| GetPluginResources<
 			T,
diff --git a/src/core/utils/map/setupMarkers.ts b/src/core/utils/map/setupMarkers.ts
index 9c64d54098..4831439a3e 100644
--- a/src/core/utils/map/setupMarkers.ts
+++ b/src/core/utils/map/setupMarkers.ts
@@ -89,7 +89,14 @@ function resolveClusterClick(map: Map, feature: Feature) {
 	})
 }
 
-function updateSelection(
+/**
+ * Update the selected marker in the map.
+ *
+ * @param map - Map
+ * @param feature - Feature to select
+ * @param centerOnFeature - Should the map center on the feature?
+ */
+export function updateSelection(
 	map: Map,
 	feature: Feature | null,
 	centerOnFeature = false
@@ -207,10 +214,9 @@ export function setupMarkers(map: Map) {
 
 	watch(
 		() => store.hovered,
-		(feature) => {
-			if (feature !== null && feature !== toRaw(store.selected)) {
-				store.hovered?.setStyle(undefined)
-				store.hovered = null
+		(feature, oldFeature) => {
+			if (oldFeature !== null && oldFeature !== toRaw(store.selected)) {
+				oldFeature.setStyle(undefined)
 			}
 			if (feature !== null && feature !== toRaw(store.selected)) {
 				store.hovered = markRaw(feature)
@@ -220,7 +226,7 @@ export function setupMarkers(map: Map) {
 						.hoverStyle,
 					isMultiFeature
 				)
-				store.hovered.setStyle(style)
+				feature.setStyle(style)
 			}
 		}
 	)
diff --git a/src/core/vuePlugins/i18next.ts b/src/core/vuePlugins/i18next.ts
index 5c3291f0c3..0f66fdfd97 100644
--- a/src/core/vuePlugins/i18next.ts
+++ b/src/core/vuePlugins/i18next.ts
@@ -4,9 +4,10 @@ import i18next from 'i18next'
 import LanguageDetector from 'i18next-browser-languagedetector'
 import I18NextVue from 'i18next-vue'
 
-import locales from '../locales'
 import sharedLocales from '@/locales'
 
+import locales from '../locales'
+
 export const CoreId = 'core'
 export const SharedId = 'shared'
 
diff --git a/src/lib/getRefStore.ts b/src/lib/getRefStore.ts
index bd466c7396..db4b396b1d 100644
--- a/src/lib/getRefStore.ts
+++ b/src/lib/getRefStore.ts
@@ -1,5 +1,6 @@
 import type { StoreReference } from '@/core'
-import { useCoreStore } from '@/core/stores/export'
+
+import { useCoreStore } from '@/core/stores'
 
 /**
  * Get the store for a `StoreReference`.
diff --git a/src/lib/getVectorSource.ts b/src/lib/getVectorSource.ts
new file mode 100644
index 0000000000..487a28863c
--- /dev/null
+++ b/src/lib/getVectorSource.ts
@@ -0,0 +1,27 @@
+import type Layer from 'ol/layer/Layer'
+
+import ClusterSource from 'ol/source/Cluster'
+import VectorSource from 'ol/source/Vector'
+
+/**
+ * Retrieves the vector source from a layer using (possibly nested) `.getSource()` calls.
+ *
+ * @param layer - Layer to get the vector source from
+ * @returns Vector source
+ */
+export function getVectorSource(layer: Layer): VectorSource {
+	let source = layer.getSource()
+	if (!source) {
+		throw new Error('Could not find a vector source for this layer')
+	}
+	while (source instanceof ClusterSource) {
+		source = source.getSource()
+		if (!source) {
+			throw new Error('Could not find a vector source for this layer')
+		}
+	}
+	if (!(source instanceof VectorSource)) {
+		throw new Error('Could not find a vector source for this layer')
+	}
+	return source
+}
diff --git a/src/plugins/gfi/components/GfiFeature.ce.vue b/src/plugins/gfi/components/GfiFeature.ce.vue
new file mode 100644
index 0000000000..07cfd067c8
--- /dev/null
+++ b/src/plugins/gfi/components/GfiFeature.ce.vue
@@ -0,0 +1,104 @@
+<template>
+	<div style="display: flex; gap: var(--kern-metric-space-default)">
+		<PolarIconButton
+			:hint="$t(($) => $.header.close, { ns: 'gfi' })"
+			icon="kern-icon--close"
+			@click="gfiStore.selectedFeatures = {}"
+		/>
+		<PolarIconButton
+			:hint="$t(($) => $.property.export, { ns: 'gfi' })"
+			icon="kern-icon--download"
+			@click="startDownload(gfiStore.exportProperty)"
+		/>
+	</div>
+	<table class="kern-table kern-table--striped">
+		<thead class="kern-table__head">
+			<tr class="kern-table__row">
+				<th scope="col" class="kern-table__header">
+					{{ $t(($) => $.header.field, { ns: 'gfi' }) }}
+				</th>
+				<th scope="col" class="kern-table__header">
+					{{ $t(($) => $.header.value, { ns: 'gfi' }) }}
+				</th>
+			</tr>
+		</thead>
+
+		<tbody class="kern-table__body">
+			<tr
+				v-for="[key, value] of Object.entries(gfiStore.properties)"
+				:key="key"
+				class="kern-table__row"
+			>
+				<td class="kern-table__cell">
+					{{
+						$t(($) => $['layer'][props.layerId]['property'][key], {
+							ns: 'gfi',
+							defaultValue: key,
+						})
+					}}
+				</td>
+				<td class="kern-table__cell">
+					<template v-if="isValidHttpUrl(value)">
+						<template
+							v-if="
+								['jpg', 'jpeg', 'png', 'gif', 'webp'].some((ext) =>
+									value.endsWith(`.${ext}`)
+								)
+							"
+						>
+							<a :href="value" target="_blank">
+								<img
+									:src="value"
+									:alt="$t(($) => $.property.imageAlt, { ns: 'gfi' })"
+									:title="$t(($) => $.property.linkTitle, { ns: 'gfi' })"
+									:height="Math.min(200, coreStore.clientHeight * 0.15)"
+									width="auto"
+								/>
+							</a>
+						</template>
+						<template v-else>
+							<a
+								:href="value"
+								target="_blank"
+								:title="$t(($) => $.property.linkTitle, { ns: 'gfi' })"
+							>
+								{{ $t(($) => $.property.linkText, { ns: 'gfi' }) }}
+							</a>
+						</template>
+					</template>
+					<template v-else>
+						{{ value }}
+					</template>
+				</td>
+			</tr>
+		</tbody>
+	</table>
+</template>
+
+<script setup lang="ts">
+import type { Feature as GeoJsonFeature } from 'geojson'
+
+import PolarIconButton from '@/components/PolarIconButton.ce.vue'
+import { useCoreStore } from '@/core/stores'
+
+import { useGfiStore } from '../store'
+import { isValidHttpUrl } from '../utils/isValidHttpUrl'
+
+const coreStore = useCoreStore()
+const gfiStore = useGfiStore()
+
+const props = defineProps<{
+	layerId: string
+	feature: GeoJsonFeature
+}>()
+
+function startDownload(url: string) {
+	open(url)
+}
+</script>
+
+<style scoped>
+td {
+	white-space: normal;
+}
+</style>
diff --git a/src/plugins/gfi/components/GfiFeatureList.ce.vue b/src/plugins/gfi/components/GfiFeatureList.ce.vue
new file mode 100644
index 0000000000..ba1291e255
--- /dev/null
+++ b/src/plugins/gfi/components/GfiFeatureList.ce.vue
@@ -0,0 +1,68 @@
+<template>
+	<h2 class="kern-heading-medium">
+		{{ $t(($) => $.list.header, { ns: 'gfi' }) }}
+	</h2>
+	<template v-if="gfiStore.listFlatFeatures.length === 0">
+		{{ $t(($) => $.list.emptyView, { ns: 'gfi' }) }}
+	</template>
+	<template v-else>
+		<KernPagination
+			v-if="gfiStore.listPaginationActive"
+			v-model="gfiStore.listPaginationStartIndex"
+			:count="gfiStore.listFlatFeatures.length"
+			:page-size="gfiStore.listPageLength"
+		/>
+		<section
+			v-for="(
+				{ layerId, feature, hovered }, idx
+			) of gfiStore.listPaginatedFeatures"
+			:key="idx"
+			tabindex="0"
+			:class="{
+				hovered,
+			}"
+			@click="
+				(() => {
+					gfiStore.selectedFeatures = { [layerId]: [feature] }
+					gfiStore.hoveredFeatures = {}
+				})()
+			"
+			@mouseenter="gfiStore.hoveredFeatures = { [layerId]: [feature] }"
+			@mouseleave="gfiStore.hoveredFeatures = {}"
+		>
+			<h2 class="kern-title kern-title--small">
+				{{ gfiStore.listGetText(feature, 'title') }}
+			</h2>
+			{{ gfiStore.listGetText(feature, 'subtitle') }}
+			<br />
+			<em>{{ gfiStore.listGetText(feature, 'subSubtitle') }}</em>
+		</section>
+	</template>
+</template>
+
+<script setup lang="ts">
+import KernPagination from '@/components/kern/KernPagination.ce.vue'
+
+import { useGfiStore } from '../store'
+
+const gfiStore = useGfiStore()
+</script>
+
+<style scoped>
+section {
+	width: 100%;
+	padding: var(--kern-metric-space-small);
+	overflow: hidden;
+	text-overflow: ellipsis;
+	border-width: var(--kern-metric-border-width-default);
+	border-style: dashed;
+	border-color: transparent;
+
+	&.hovered,
+	&:hover {
+		border-radius: var(--kern-metric-border-radius-default);
+		border-color: var(--kern-color-action-default);
+		cursor: pointer;
+	}
+}
+</style>
diff --git a/src/plugins/gfi/components/GfiUI.ce.vue b/src/plugins/gfi/components/GfiUI.ce.vue
new file mode 100644
index 0000000000..0a940eba09
--- /dev/null
+++ b/src/plugins/gfi/components/GfiUI.ce.vue
@@ -0,0 +1,48 @@
+<template>
+	<PolarCard id="polar-card-gfi">
+		<template v-if="gfiStore.features.length > 0">
+			<GfiFeature v-if="gfiStore.feature" v-bind="gfiStore.feature" />
+			<button
+				v-if="gfiStore.featureIndex > 0"
+				class="kern-btn kern-btn--block kern-btn--secondary"
+				@click="gfiStore.featureIndex--"
+			>
+				<span class="kern-icon kern-icon--arrow-back" aria-hidden="true" />
+				<span class="kern-label">
+					{{ $t(($) => $.switch.previous, { ns: 'gfi' }) }}
+				</span>
+			</button>
+			<button
+				v-if="gfiStore.featureIndex + 1 < gfiStore.features.length"
+				class="kern-btn kern-btn--block kern-btn--primary"
+				@click="gfiStore.featureIndex++"
+			>
+				<span class="kern-label">
+					{{ $t(($) => $.switch.next, { ns: 'gfi' }) }}
+				</span>
+				<span class="kern-icon kern-icon--arrow-forward" aria-hidden="true" />
+			</button>
+		</template>
+		<template v-else-if="gfiStore.configuration.featureList">
+			<GfiFeatureList />
+		</template>
+	</PolarCard>
+</template>
+
+<script setup lang="ts">
+import PolarCard from '@/components/PolarCard.ce.vue'
+
+import { useGfiStore } from '../store'
+import GfiFeature from './GfiFeature.ce.vue'
+import GfiFeatureList from './GfiFeatureList.ce.vue'
+
+const gfiStore = useGfiStore()
+</script>
+
+<style scoped>
+#polar-card-gfi {
+	width: 12em;
+	pointer-events: all;
+	padding-bottom: 3em;
+}
+</style>
diff --git a/src/plugins/gfi/composables/useFeatureDisplayLayer.ts b/src/plugins/gfi/composables/useFeatureDisplayLayer.ts
new file mode 100644
index 0000000000..fb7e91a272
--- /dev/null
+++ b/src/plugins/gfi/composables/useFeatureDisplayLayer.ts
@@ -0,0 +1,86 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+import type { Style } from 'ol/style'
+
+import { Feature, Map } from 'ol'
+import { GeoJSON } from 'ol/format'
+import VectorLayer from 'ol/layer/Vector'
+import { Vector } from 'ol/source'
+import { onScopeDispose, watch, type Ref } from 'vue'
+
+function getFeatureDisplayLayer() {
+	const featureDisplayLayer = new VectorLayer({
+		source: new Vector<Feature>({
+			features: [],
+		}),
+	})
+
+	featureDisplayLayer.set('polarInternalId', 'pluginGfiFeatureDisplay')
+	featureDisplayLayer.setZIndex(90)
+	// NOTE: This may be changed in the future to not use the default styling of @masterportal/masterportalapi
+	featureDisplayLayer.set('styleId', 'defaultHighlightFeaturesPoint')
+
+	return featureDisplayLayer
+}
+
+function isVectorSource(source): source is Vector {
+	return source instanceof Vector
+}
+
+/**
+ * reset feature layer's features.
+ */
+function clear(featureDisplayLayer: VectorLayer): void {
+	const source = featureDisplayLayer.getSource()
+	if (isVectorSource(source)) {
+		source.clear()
+	}
+}
+
+/**
+ * add feature from jsonable GeoJson object.
+ */
+function addFeature(
+	feature: GeoJsonFeature,
+	featureDisplayLayer: VectorLayer
+): void {
+	const source = featureDisplayLayer.getSource()
+	if (isVectorSource(source)) {
+		// Since ol@10, readFeature may also return a Feature[]?
+		source.addFeature(new GeoJSON().readFeature(feature) as Feature)
+	}
+}
+
+export function useFeatureDisplayLayer(options: {
+	map: Map
+	style: Ref<Style>
+	features: Ref<GeoJsonFeature[]>
+}) {
+	const { map, style, features } = options
+	const layer = getFeatureDisplayLayer()
+
+	map.addLayer(layer)
+	onScopeDispose(() => {
+		map.removeLayer(layer)
+	})
+
+	watch(
+		style,
+		(newStyle) => {
+			layer.setStyle(newStyle)
+		},
+		{ immediate: true }
+	)
+
+	watch(
+		features,
+		(newFeatures) => {
+			clear(layer)
+			newFeatures.forEach((feature) => {
+				addFeature(feature, layer)
+			})
+		},
+		{ immediate: true, deep: true }
+	)
+
+	return {}
+}
diff --git a/src/plugins/gfi/composables/useMultiSelection.ts b/src/plugins/gfi/composables/useMultiSelection.ts
new file mode 100644
index 0000000000..7c4c8bd4d2
--- /dev/null
+++ b/src/plugins/gfi/composables/useMultiSelection.ts
@@ -0,0 +1,63 @@
+import type { Map } from 'ol'
+
+import { platformModifierKeyOnly } from 'ol/events/condition'
+import Draw, {
+	createBox,
+	type Options as DrawOptions,
+} from 'ol/interaction/Draw'
+import { Fill, Stroke, Style } from 'ol/style'
+import { onScopeDispose, ref } from 'vue'
+
+import type { GfiPluginOptions } from '../types'
+
+export function useMultiSelection(options: {
+	map: Map
+	mode: GfiPluginOptions['multiSelect']
+}) {
+	const { map, mode } = options
+
+	const drawOptions: DrawOptions = {
+		stopClick: true,
+		type: 'Circle',
+		style: new Style({
+			stroke: new Stroke({ color: 'white', width: 1.5 }),
+			fill: new Fill({ color: [255, 255, 255, 0.75] }),
+		}),
+		freehandCondition: (event) => {
+			if (event.type === 'pointermove') {
+				return false
+			} else if (event.type === 'pointerup') {
+				return true
+			}
+			return platformModifierKeyOnly(event)
+		},
+		condition: () => false,
+	}
+
+	if (mode === 'box') {
+		drawOptions.geometryFunction = createBox()
+	} else {
+		delete drawOptions.geometryFunction
+	}
+
+	const selection = ref<[number, number, number, number] | null>(null)
+
+	const draw = new Draw(drawOptions)
+	draw.on(
+		'drawend',
+		(e) =>
+			(selection.value =
+				(e.feature.getGeometry()?.getExtent() as
+					| [number, number, number, number]
+					| undefined) ?? null)
+	)
+
+	map.addInteraction(draw)
+	onScopeDispose(() => {
+		map.removeInteraction(draw)
+	})
+
+	return {
+		selection,
+	}
+}
diff --git a/src/plugins/gfi/index.ts b/src/plugins/gfi/index.ts
new file mode 100644
index 0000000000..65e47f5764
--- /dev/null
+++ b/src/plugins/gfi/index.ts
@@ -0,0 +1,31 @@
+/* eslint-disable tsdoc/syntax */
+/**
+ * @module \@polar/polar/plugins/gfi
+ */
+/* eslint-enable tsdoc/syntax */
+
+import type { PluginContainer, PolarPluginStore } from '@/core'
+
+import component from './components/GfiUI.ce.vue'
+import locales from './locales'
+import { useGfiStore } from './store'
+import { PluginId, type GfiPluginOptions } from './types'
+
+/**
+ * Creates a plugin which fetches and optionally displays GFI (GetFeatureInfo) from WMS and WFS services or layers based on GeoJSON files.
+ * The feature information is accessible in the store and can also be accessed for custom display logic.
+ *
+ * @returns Plugin for use with {@link addPlugin}
+ */
+export default function pluginGfi(options: GfiPluginOptions): PluginContainer {
+	return {
+		id: PluginId,
+		component,
+		locales,
+		storeModule: useGfiStore as PolarPluginStore,
+		options,
+		icon: 'kern-icon--map-pin-heart',
+	}
+}
+
+export * from './types'
diff --git a/src/plugins/gfi/locales.ts b/src/plugins/gfi/locales.ts
new file mode 100644
index 0000000000..9b723d4419
--- /dev/null
+++ b/src/plugins/gfi/locales.ts
@@ -0,0 +1,94 @@
+/* eslint-disable tsdoc/syntax */
+/**
+ * This is the documentation for the locales keys in the gfi plugin.
+ * These locales are *NOT* exported, but documented only.
+ *
+ * @module locales/plugins/gfi
+ */
+/* eslint-enable tsdoc/syntax */
+
+import type { Locale } from '@/core'
+
+/**
+ * German locales for gfi plugin.
+ * For overwriting these values, use the plugin's ID as namespace.
+ */
+export const resourcesDe = {
+	header: {
+		close: 'Informationsfenster schließen',
+		field: 'Feld',
+		value: 'Wert',
+	},
+	property: {
+		export: 'Export als PDF',
+		imageAlt:
+			'Bitte entnehmen Sie Informationen zum Inhalt des Bildes aus den umliegenden Tabellenfeldern',
+		linkTitle: 'In neuem Tab öffnen',
+		linkText: 'Link',
+	},
+	switch: {
+		previous: 'Vorangehender Datensatz',
+		next: 'Nächster Datensatz',
+	},
+	noActiveLayer:
+		'Derzeit ist kein Kartenmaterial mit passenden Objekten eingeschaltet.',
+	list: {
+		header: 'Objektliste',
+		entry: 'Eintrag',
+		to: 'bis',
+		of: 'von',
+		emptyView: 'Im aktuellen Kartenausschnitt sind keine Objekte enthalten.',
+	},
+} as const
+
+/**
+ * English locales for gfi plugin.
+ * For overwriting these values, use the plugin's ID as namespace.
+ */
+export const resourcesEn = {
+	header: {
+		close: 'Close information window',
+		field: 'Field',
+		value: 'Value',
+	},
+	property: {
+		export: 'Export as a PDF document',
+		imageAlt:
+			'Please refer to the other table fields for further information about the topics of the displayed picture',
+		linkTitle: 'Open in a new tab',
+		linkText: 'Link',
+	},
+	switch: {
+		previous: 'Previous data',
+		next: 'Next data',
+	},
+	noActiveLayer: 'Currently, no map layer with fitting objects is active.',
+	list: {
+		header: 'Feature list',
+		entry: 'Entry',
+		to: 'to',
+		of: 'of',
+		emptyView: 'There are no features in the current view.',
+	},
+} as const
+
+/**
+ * Gfi plugin locales.
+ *
+ * @privateRemarks
+ * The first entry will be used as fallback.
+ *
+ * @internal
+ */
+const locales: Locale[] = [
+	{
+		type: 'de',
+		resources: resourcesDe,
+	},
+	{
+		type: 'en',
+		resources: resourcesEn,
+	},
+]
+
+export default locales
diff --git a/src/plugins/gfi/store.ts b/src/plugins/gfi/store.ts
new file mode 100644
index 0000000000..8b6522998e
--- /dev/null
+++ b/src/plugins/gfi/store.ts
@@ -0,0 +1,186 @@
+/* eslint-disable tsdoc/syntax */
+/**
+ * @module \@polar/polar/plugins/gfi/store
+ */
+/* eslint-enable tsdoc/syntax */
+
+import { acceptHMRUpdate, defineStore, storeToRefs } from 'pinia'
+
+import { useGfiFeatureStore } from './stores/feature'
+import { useGfiListStore } from './stores/list'
+import { useGfiMainStore } from './stores/main'
+
+/* eslint-disable tsdoc/syntax */
+/**
+ * @function
+ *
+ * Plugin store for feature information requests.
+ */
+/* eslint-enable tsdoc/syntax */
+export const useGfiStore = defineStore('plugins/gfi', () => {
+	const gfiMainStore = useGfiMainStore()
+	const gfiMainStoreRefs = storeToRefs(gfiMainStore)
+
+	const gfiListStore = useGfiListStore()
+	const gfiListStoreRefs = storeToRefs(gfiListStore)
+
+	const gfiFeatureStore = useGfiFeatureStore()
+	const gfiFeatureStoreRefs = storeToRefs(gfiFeatureStore)
+
+	return {
+		/**
+		 * Plugin configuration.
+		 *
+		 * @alpha
+		 */
+		configuration: gfiMainStoreRefs.configuration,
+
+		/**
+		 * Hovered features.
+		 * This is only used for the list view.
+		 *
+		 * @alpha
+		 */
+		hoveredFeatures: gfiListStoreRefs.hoveredFeatures,
+
+		/**
+		 * Selected features.
+		 * This is only used if the feature is loaded from the list view.
+		 *
+		 * @alpha
+		 */
+		selectedFeatures: gfiMainStoreRefs.selectedFeatures,
+
+		/**
+		 * Feature information for the currently selected feature(s).
+		 *
+		 * @alpha
+		 */
+		featureInformation: gfiMainStoreRefs.featureInformation,
+
+		/**
+		 * List of features that should be displayed in a list view.
+		 *
+		 * @alpha
+		 */
+		listFeatures: gfiListStoreRefs.features,
+
+		/**
+		 * Flattened list of features for the list view.
+		 *
+		 * @alpha
+		 */
+		listFlatFeatures: gfiListStoreRefs.flatFeatures,
+
+		/**
+		 * `true` if pagination is configured for the list view.
+		 *
+		 * @alpha
+		 */
+		listPaginationActive: gfiListStoreRefs.paginationActive,
+
+		/**
+		 * If pagination is configured, the number of features per page.
+		 * Otherwise, the behaviour is undefined.
+		 *
+		 * @alpha
+		 */
+		listPageLength: gfiListStoreRefs.pageLength,
+
+		/**
+		 * If pagination is configured, the page that is currently selected in the list view.
+		 * Otherwise, the behaviour is undefined.
+		 *
+		 * @alpha
+		 */
+		listPage: gfiListStoreRefs.page,
+
+		/**
+		 * If pagination is configured, the index of the first feature that is shown on the current page.
+		 * Otherwise, the value is zero.
+		 *
+		 * The index refers to `listFlatFeatures`.
+		 *
+		 * @alpha
+		 */
+		listPaginationStartIndex: gfiListStoreRefs.paginationStartIndex,
+
+		/**
+		 * If pagination is configured, the index of the last feature that is shown on the current page.
+		 * Otherwise, the value is `undefined`.
+		 *
+		 * The index refers to `listFlatFeatures`.
+		 *
+		 * To mutate this value, change `listPage` or `listPaginationStartIndex`.
+		 *
+		 * @readonly
+		 * @alpha
+		 */
+		listPaginationEndIndex: gfiListStoreRefs.paginationEndIndex,
+
+		/**
+		 * Paginated list of features to display in the list view.
+		 * If pagination is not configured, this equals `listFlatFeatures`.
+		 *
+		 * @alpha
+		 */
+		listPaginatedFeatures: gfiListStoreRefs.paginatedFeatures,
+
+		/**
+		 * Get the text description of a feature for the list view.
+		 *
+		 * @param feature - The feature to get the text description for
+		 * @param type - Type of text to retrieve (e.g., `'title'`)
+		 * @alpha
+		 */
+		listGetText: gfiListStore.getText,
+
+		/**
+		 * Features that should be displayed in a detail view.
+		 *
+		 * @alpha
+		 */
+		features: gfiFeatureStoreRefs.visibleFeatures,
+
+		/**
+		 * Index of the selected feature for the detail view.
+		 * This is used to calculate `feature`.
+		 *
+		 * @alpha
+		 */
+		featureIndex: gfiFeatureStoreRefs.selectedFeatureIndex,
+
+		/**
+		 * Selected feature for the detail view.
+		 * This is the currently shown feature.
+		 *
+		 * To mutate this value, change `featureIndex`.
+		 *
+		 * @readonly
+		 * @alpha
+		 */
+		feature: gfiFeatureStoreRefs.selectedFeature,
+
+		/**
+		 * Properties for the selected feature in detail view.
+		 * The properties are already filtered by configuration.
+		 *
+		 * @readonly
+		 * @alpha
+		 */
+		properties: gfiFeatureStoreRefs.selectedFeatureProperties,
+
+		/**
+		 * If an export property is configured and defined, the value of that property.
+		 * Otherwise `null`.
+		 *
+		 * @readonly
+		 * @alpha
+		 */
+		exportProperty: gfiFeatureStoreRefs.exportProperty,
+	}
+})
+
+if (import.meta.hot) {
+	import.meta.hot.accept(acceptHMRUpdate(useGfiStore, import.meta.hot))
+}
diff --git a/src/plugins/gfi/stores/feature.ts b/src/plugins/gfi/stores/feature.ts
new file mode 100644
index 0000000000..ac0d63d13c
--- /dev/null
+++ b/src/plugins/gfi/stores/feature.ts
@@ -0,0 +1,250 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+
+import { rawLayerList } from '@masterportal/masterportalapi'
+import { isEqual } from 'es-toolkit'
+import { MapBrowserEvent, Overlay } from 'ol'
+import { acceptHMRUpdate, defineStore } from 'pinia'
+import { computed, onScopeDispose, ref, watch } from 'vue'
+
+import { useCoreStore } from '@/core/stores'
+
+import type { GfiLayerConfiguration, RequestGfiParameters } from '../types'
+
+import { useMultiSelection } from '../composables/useMultiSelection'
+import { requestGfi } from '../utils/requestGfi'
+import { updateTooltip } from '../utils/updateTooltip'
+import { useGfiMainStore } from './main'
+
+export const useGfiFeatureStore = defineStore('plugins/gfi/feature', () => {
+	const coreStore = useCoreStore()
+	const gfiMainStore = useGfiMainStore()
+
+	async function getFeatureInfo(
+		coordinateOrExtent: RequestGfiParameters['coordinateOrExtent'],
+		options: {
+			toggleSelection?: boolean
+		} = {}
+	) {
+		let result = Object.fromEntries(
+			(
+				await Promise.all(
+					Object.entries(gfiMainStore.configuration.layers)
+						.map(([layerId, layerConfiguration]) => ({
+							layerId,
+							layerConfiguration,
+							layer: coreStore.getLayer(layerId),
+						}))
+						.filter(
+							(
+								layer
+							): layer is {
+								[K in keyof typeof layer]: NonNullable<(typeof layer)[K]>
+							} => Boolean(layer.layer)
+						)
+						.map(async ({ layerId, layer, layerConfiguration }) => {
+							return [
+								layerId,
+								(
+									await requestGfi({
+										coordinateOrExtent,
+										layer,
+										layerConfiguration,
+										layerSpecification: rawLayerList.getLayerWhere({
+											id: layerId,
+										}),
+										map: coreStore.map,
+										mode:
+											coreStore.configuration.layers.find(
+												(layer) => layer.id === layerId
+											)?.gfiMode ||
+											gfiMainStore.configuration.mode ||
+											'bboxDot',
+									})
+								)
+									.filter(
+										(feature) =>
+											!layerConfiguration.isSelectable ||
+											layerConfiguration.isSelectable(feature)
+									)
+									.slice(
+										0,
+										gfiMainStore.configuration.maxFeatures ||
+											Number.POSITIVE_INFINITY
+									),
+							]
+						})
+				)
+			).filter((it): it is GeoJsonFeature[][] => Boolean(it))
+		) as Record<string, GeoJsonFeature[]>
+
+		if (gfiMainStore.configuration.afterLoadFunction) {
+			result = gfiMainStore.configuration.afterLoadFunction(result)
+		}
+
+		if (options.toggleSelection) {
+			Object.entries(result).forEach(([layerId, features]) => {
+				if (!gfiMainStore.featureInformation[layerId]) {
+					gfiMainStore.featureInformation[layerId] = []
+				}
+				const layerFeatureList = gfiMainStore.featureInformation[layerId]
+
+				features.forEach((feature) => {
+					const oldFeatureIndex = layerFeatureList.findIndex((oldFeature) =>
+						isEqual(oldFeature.properties, feature.properties)
+					)
+					if (oldFeatureIndex < 0) {
+						layerFeatureList.push(feature)
+					} else {
+						layerFeatureList.splice(oldFeatureIndex, 1)
+					}
+				})
+			})
+			return
+		}
+
+		gfiMainStore.featureInformation = result
+	}
+
+	for (const source of gfiMainStore.configuration.coordinateSources || []) {
+		const store = source.plugin
+			? coreStore.getPluginStore(source.plugin)
+			: coreStore
+		if (!store) {
+			continue
+		}
+		watch(
+			() => store[source.key],
+			async (coordinate) => {
+				if (coordinate) {
+					await getFeatureInfo(coordinate)
+				} else {
+					gfiMainStore.featureInformation = {}
+				}
+			},
+			{ immediate: true }
+		)
+	}
+
+	if (gfiMainStore.configuration.multiSelect) {
+		const multiSelection = useMultiSelection({
+			map: coreStore.map,
+			mode: gfiMainStore.configuration.multiSelect,
+		})
+		watch(multiSelection.selection, async (selection) => {
+			if (selection) {
+				await getFeatureInfo(selection)
+			} else {
+				gfiMainStore.featureInformation = {}
+			}
+		})
+	}
+
+	if (gfiMainStore.configuration.directSelect) {
+		async function onMapClick({ coordinate, originalEvent }: MapBrowserEvent) {
+			await getFeatureInfo(coordinate as [number, number], {
+				toggleSelection:
+					navigator.userAgent.indexOf('Mac') !== -1
+						? originalEvent.metaKey
+						: originalEvent.ctrlKey,
+			})
+		}
+
+		coreStore.map.on('click', onMapClick)
+		onScopeDispose(() => {
+			coreStore.map.un('click', onMapClick)
+		})
+	}
+
+	const visibleFeatures = computed(() =>
+		Object.entries(gfiMainStore.featureInformation)
+			.filter(([layerId]) => gfiMainStore.configuration.layers[layerId]?.window)
+			.flatMap(([layerId, features]) =>
+				features.map((feature) => ({ layerId, feature }))
+			)
+	)
+
+	const selectedFeatureIndex = ref(0)
+	const selectedFeature = computed(
+		() => visibleFeatures.value[selectedFeatureIndex.value]
+	)
+
+	const selectedFeatureLayerConfiguration = computed(() =>
+		gfiMainStore.getLayerConfiguration(selectedFeature.value?.layerId || '')
+	)
+
+	const selectedFeaturePropertiesLayerConfiguration = computed(
+		() => selectedFeatureLayerConfiguration.value?.properties
+	)
+
+	const selectedFeatureProperties = computed(() =>
+		Object.fromEntries(
+			Object.entries(selectedFeature.value?.feature.properties || {})
+				.filter(
+					([key]) =>
+						!selectedFeaturePropertiesLayerConfiguration.value ||
+						selectedFeaturePropertiesLayerConfiguration.value.includes(key)
+				)
+				.map(([key, value]) => [key, value])
+		)
+	)
+
+	const exportPropertyLayerConfiguration = computed(
+		() => selectedFeatureLayerConfiguration.value?.exportProperty
+	)
+
+	const exportProperty = computed(() =>
+		exportPropertyLayerConfiguration.value
+			? selectedFeature.value?.feature.properties?.[
+					exportPropertyLayerConfiguration.value
+				]
+			: null
+	)
+
+	watch(
+		visibleFeatures,
+		() => {
+			selectedFeatureIndex.value = 0
+		},
+		{ deep: true }
+	)
+
+	const overlay = new Overlay({
+		positioning: 'bottom-center',
+		offset: [0, -5],
+	})
+	coreStore.map.addOverlay(overlay)
+	let teardownTooltip: (() => void) | null = null
+	coreStore.map.on('pointermove', (evt) => {
+		if (teardownTooltip) {
+			teardownTooltip()
+		}
+
+		teardownTooltip = updateTooltip(
+			evt,
+			overlay,
+			Object.fromEntries(
+				Object.entries(gfiMainStore.configuration.layers)
+					.filter(([, { showTooltip }]) => Boolean(showTooltip))
+					.map(([layerId, { showTooltip }]) => [layerId, showTooltip])
+			) as Record<string, NonNullable<GfiLayerConfiguration['showTooltip']>>
+		)
+	})
+	onScopeDispose(() => {
+		if (teardownTooltip) {
+			teardownTooltip()
+		}
+		coreStore.map.removeOverlay(overlay)
+	})
+
+	return {
+		visibleFeatures,
+		selectedFeatureIndex,
+		selectedFeature,
+		selectedFeatureProperties,
+		exportProperty,
+	}
+})
+
+if (import.meta.hot) {
+	import.meta.hot.accept(acceptHMRUpdate(useGfiFeatureStore, import.meta.hot))
+}
diff --git a/src/plugins/gfi/stores/list.ts b/src/plugins/gfi/stores/list.ts
new file mode 100644
index 0000000000..15bfcc3dba
--- /dev/null
+++ b/src/plugins/gfi/stores/list.ts
@@ -0,0 +1,233 @@
+import type { Feature } from 'ol'
+
+import { acceptHMRUpdate, defineStore, storeToRefs } from 'pinia'
+import { computed, ref, watch } from 'vue'
+
+import { useCoreStore } from '@/core/stores'
+import { getRefStore } from '@/lib/getRefStore'
+import { getVectorSource } from '@/lib/getVectorSource'
+import { isVisible } from '@/lib/invisibleStyle'
+
+import type { FeatureList } from '../types'
+
+import { getSourceFeatures } from '../utils/getSourceFeatures'
+import { serializeFeature } from '../utils/serializeFeature'
+import { useGfiMainStore } from './main'
+
+export const useGfiListStore = defineStore('plugins/gfi/list', () => {
+	const coreStore = useCoreStore()
+	const gfiMainStore = useGfiMainStore()
+
+	const hoveredFeatures = ref<Record<string, Feature[]>>({})
+	const { selectedFeatures } = storeToRefs(gfiMainStore)
+
+	const configuration = computed(() => gfiMainStore.configuration.featureList)
+
+	const activeLayers = computed((): string[] => {
+		if (!configuration.value) {
+			return []
+		}
+
+		const activeLayersRef = configuration.value.activeLayers
+		const store = getRefStore(activeLayersRef)
+		if (!store) {
+			return []
+		}
+		return store[activeLayersRef.key]
+	})
+
+	const features = computed(() => {
+		// We want to re-calculate on extent changes, as the features change then.
+		// eslint-disable-next-line @typescript-eslint/no-unused-expressions
+		coreStore.extent
+
+		// TODO: We also want to re-calculate when the features are actually loaded.
+		// Currently, we need an extent change to reload the list.
+
+		return Object.fromEntries(
+			activeLayers.value
+				.map((layerId) => ({
+					layerId,
+					layerConfiguration: gfiMainStore.getLayerConfiguration(layerId),
+					layer: coreStore.getLayer(layerId),
+				}))
+				.filter(
+					(
+						layer
+					): layer is {
+						[K in keyof typeof layer]: NonNullable<(typeof layer)[K]>
+					} => Boolean(layer.layerConfiguration) && Boolean(layer.layer)
+				)
+				.map(({ layerId, layerConfiguration, layer }) => {
+					const source = getVectorSource(layer)
+
+					return [
+						layerId,
+						getSourceFeatures(
+							coreStore.map,
+							source,
+							configuration.value?.mode || 'visible'
+						)
+							.filter((feature) => isVisible(feature))
+							.filter(
+								(feature) =>
+									!layerConfiguration.isSelectable ||
+									layerConfiguration.isSelectable(serializeFeature(feature))
+							)
+							.map((feature) => ({
+								feature,
+								...(configuration.value?.bindWithCoreHoverSelect
+									? {
+											hovered:
+												coreStore.hoveredFeature === feature ||
+												coreStore.hoveredFeature
+													?.get('features')
+													?.includes(feature),
+										}
+									: {}),
+							})),
+					]
+				})
+				.filter(
+					(
+						layer
+					): layer is [string, { feature: Feature; hovered?: boolean }[]] =>
+						Boolean(layer)
+				)
+		)
+	})
+
+	watch(
+		[
+			() => configuration.value?.bindWithCoreHoverSelect,
+			() => coreStore.selectedFeature,
+		],
+		([bindMarkers, feature]) => {
+			if (bindMarkers) {
+				if (feature) {
+					selectedFeatures.value[feature.get('_polarLayerId')] = feature.get(
+						'features'
+					) || [feature]
+				} else {
+					selectedFeatures.value = {}
+				}
+			}
+		},
+		{ immediate: true, deep: true }
+	)
+
+	watch(
+		[
+			() => configuration.value?.bindWithCoreHoverSelect,
+			() => hoveredFeatures.value,
+		],
+		([bindMarkers, featureMap]) => {
+			if (bindMarkers) {
+				const features = Object.entries(featureMap).flatMap(
+					([layerId, features]) =>
+						features.map((feature) => ({ layerId, feature }))
+				)
+
+				// The second condition is necessary for TypeScript checks.
+				if (features.length <= 0 || !features[0]) {
+					coreStore.hoveredFeature = null
+					return
+				}
+
+				features[0].feature.set('_polarLayerId', features[0].layerId)
+				coreStore.hoveredFeature = features[0].feature
+			}
+		},
+		{ immediate: true, deep: true }
+	)
+
+	watch(
+		[
+			() => configuration.value?.bindWithCoreHoverSelect,
+			() => selectedFeatures.value,
+		],
+		([bindMarkers, featureMap]) => {
+			if (bindMarkers) {
+				const features = Object.values(featureMap).flat()
+
+				if (features.length <= 0) {
+					coreStore.selectedFeature = null
+					return
+				}
+
+				coreStore.selectedFeature = features[0] as Feature
+			}
+		},
+		{ immediate: true, deep: true }
+	)
+
+	const flatFeatures = computed(() =>
+		Object.entries(features.value).flatMap(([layerId, features]) =>
+			features.map((feature) => ({
+				layerId,
+				...feature,
+			}))
+		)
+	)
+
+	const page = ref(0)
+
+	const pageLength = computed(() => configuration.value?.pageLength ?? 0)
+
+	const paginationActive = computed(
+		() => typeof configuration.value?.pageLength === 'number'
+	)
+
+	const paginationStartIndex = computed({
+		get: () => (paginationActive.value ? page.value * pageLength.value : 0),
+		set: (value) => {
+			page.value = paginationActive.value
+				? Math.round(value / pageLength.value)
+				: 0
+		},
+	})
+
+	const paginationEndIndex = computed(() =>
+		paginationActive.value
+			? paginationStartIndex.value + pageLength.value
+			: undefined
+	)
+
+	const paginatedFeatures = computed(() =>
+		flatFeatures.value.slice(
+			paginationStartIndex.value,
+			paginationEndIndex.value
+		)
+	)
+
+	function getText(
+		feature: Feature,
+		type: keyof NonNullable<FeatureList['text']>
+	) {
+		const text = configuration.value?.text?.[type]
+		if (typeof text === 'string') {
+			return text
+		}
+		if (typeof text === 'function') {
+			return text(feature)
+		}
+		return null
+	}
+
+	return {
+		features,
+		hoveredFeatures,
+		flatFeatures,
+		paginationActive,
+		pageLength,
+		page,
+		paginationStartIndex,
+		paginationEndIndex,
+		paginatedFeatures,
+		getText,
+	}
+})
+
+if (import.meta.hot) {
+	import.meta.hot.accept(acceptHMRUpdate(useGfiListStore, import.meta.hot))
+}
diff --git a/src/plugins/gfi/stores/main.ts b/src/plugins/gfi/stores/main.ts
new file mode 100644
index 0000000000..39c02c734b
--- /dev/null
+++ b/src/plugins/gfi/stores/main.ts
@@ -0,0 +1,89 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+import type { Feature } from 'ol'
+
+import { Fill, Stroke, Style } from 'ol/style'
+import { acceptHMRUpdate, defineStore } from 'pinia'
+import { computed, ref, watch } from 'vue'
+
+import { useCoreStore } from '@/core/stores'
+
+import { useFeatureDisplayLayer } from '../composables/useFeatureDisplayLayer'
+import {
+	PluginId,
+	type CustomHighlightStyle,
+	type GfiPluginOptions,
+} from '../types'
+import { serializeFeature } from '../utils/serializeFeature'
+
+const defaultHighlightStyle = {
+	stroke: {
+		color: '#003064',
+		width: 3,
+	},
+	fill: {
+		color: 'rgb(255, 255, 255, 0.7)',
+	},
+} satisfies CustomHighlightStyle
+
+export const useGfiMainStore = defineStore('plugins/gfi/main', () => {
+	const coreStore = useCoreStore()
+
+	const configuration = computed(
+		() => coreStore.configuration[PluginId] as GfiPluginOptions
+	)
+
+	function getLayerConfiguration(layerId: string) {
+		return configuration.value.layers[layerId]
+	}
+
+	const selectedFeatures = ref<Record<string, Feature[]>>({})
+	const featureInformation = ref<Record<string, GeoJsonFeature[]>>({})
+
+	watch(
+		selectedFeatures,
+		(features) => {
+			featureInformation.value = Object.fromEntries(
+				Object.entries(features).map(([layerId, features]) => [
+					layerId,
+					features.map((feature) => serializeFeature(feature)),
+				])
+			)
+		},
+		{ immediate: true, deep: true }
+	)
+
+	const customHighlightStyle = computed(
+		() =>
+			new Style({
+				stroke: new Stroke(
+					configuration.value.customHighlightStyle?.stroke ||
+						defaultHighlightStyle.stroke
+				),
+				fill: new Fill(
+					configuration.value.customHighlightStyle?.fill ||
+						defaultHighlightStyle.fill
+				),
+			})
+	)
+	const highlightedFeatures = computed(() =>
+		Object.entries(featureInformation.value)
+			.filter(([layerId]) => getLayerConfiguration(layerId)?.geometry ?? true)
+			.flatMap(([, features]) => features)
+	)
+	useFeatureDisplayLayer({
+		map: coreStore.map,
+		style: customHighlightStyle,
+		features: highlightedFeatures,
+	})
+
+	return {
+		configuration,
+		getLayerConfiguration,
+		selectedFeatures,
+		featureInformation,
+	}
+})
+
+if (import.meta.hot) {
+	import.meta.hot.accept(acceptHMRUpdate(useGfiMainStore, import.meta.hot))
+}
diff --git a/src/plugins/gfi/types.ts b/src/plugins/gfi/types.ts
new file mode 100644
index 0000000000..95b621d7ca
--- /dev/null
+++ b/src/plugins/gfi/types.ts
@@ -0,0 +1,359 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+import type { Feature, Map } from 'ol'
+import type BaseLayer from 'ol/layer/Base'
+import type ImageLayer from 'ol/layer/Image'
+import type TileLayer from 'ol/layer/Tile'
+import type { ImageWMS, TileWMS } from 'ol/source'
+import type { Options as Fill } from 'ol/style/Fill'
+import type { Options as Stroke } from 'ol/style/Stroke'
+
+import type { PluginOptions, StoreReference } from '@/core'
+
+/**
+ * Plugin identifier.
+ */
+export const PluginId = 'gfi'
+
+export const gfiFailedSymbol = Symbol('POLAR gfi call failed')
+
+/**
+ * Gfi configuration for a layer.
+ *
+ * @example
+ * ```ts
+ * {
+ * 	geometry: true,
+ * 	window: true,
+ * 	maxFeatures: 10,
+ * 	geometryName: 'app:geometry',
+ * 	exportProperty: 'Export',
+ * 	properties: {
+ * 		status: 'status',
+ * 		type: 'type',
+ * 	},
+ * 	showTooltip: (feature: Feature): [string, string][] => [
+ * 		['div', `Feature ID: ${feature.properties.id}`],
+ * 		['span', `Coordinates: ${feature.geometry.coordinates.join(', ')}`],
+ * 	],
+ * 	isSelectable: (feature: Feature): boolean => Boolean(Math.random() < 0.5)
+ * }
+ * ```
+ */
+export interface GfiLayerConfiguration {
+	/**
+	 * Property of the features of a service having an url usable to trigger a download of features as a document.
+	 */
+	exportProperty?: string
+
+	/**
+	 * (WMS-only)
+	 * Some WMS services may return features close to the clicked position.
+	 * By setting the value `clickPosition`, only features that intersect the clicked position are shown to the user.
+	 *
+	 * @defaultValue Show all features
+	 */
+	filterBy?: 'clickPosition'
+
+	/**
+	 * (WMS-only)
+	 * If the `infoFormat` is not set to `'application/geojson'`´, this can be configured to be the known file format of the response.
+	 * If not given, the format is parsed from the response data.
+	 */
+	format?: 'GML' | 'GML2' | 'GML3' | 'GML32' | 'text'
+
+	/**
+	 * If `true`, feature geometry will be highlighted within the map.
+	 *
+	 * @defaultValue true
+	 */
+	geometry?: boolean
+
+	/**
+	 * Name of the geometry property if not the default field.
+	 */
+	geometryName?: string
+
+	/**
+	 * A function can be defined to allow filtering features to be either selectable (return `true`) or not.
+	 * Unselectable features will be filtered out by the GFI plugin and have neither GFI display nor store presence, but may be visible in the map nonetheless, depending on your other configuration.
+	 * Please also mind that usage in combination with `extendedMasterportalapiMarkers` requires further configuration of that feature for smooth UX.
+	 *
+	 * @param feature - Feature to check
+	 * @returns `true` if the feature should be selectable, `false` otherwise
+	 */
+	isSelectable?: (feature: GeoJsonFeature) => boolean
+
+	/**
+	 * In case `window` is `true`, this will be used to determine which contents to show.
+	 * The property names can be localized, regardless if this is set or all properties are shown.
+	 *
+	 * @defaultValue Display all properties
+	 */
+	properties?: string[]
+
+	/**
+	 * (WFS- and GeoJSON-only)
+	 * If given, a tooltip will be shown with the values calculated for the feature.
+	 * The first string is the HTML tag to render, the second its contents; contants may be locale keys.
+	 *
+	 * Please mind that tooltips will only be shown if a mouse is used or the hovering device could not be detected.
+	 * Touch and pen interactions do not open tooltips since they will open the GFI window, rendering the gatherable information redundant.
+	 *
+	 * @defaultValue undefined
+	 * @param feature - Feature to calculate the tooltip for
+	 * @returns [HTML tag to render, content or locale key]
+	 */
+	showTooltip?: (feature: Feature) => [string, string][]
+
+	/**
+	 * If `true`, properties will be shown in the map client.
+	 *
+	 * @defaultValue false
+	 */
+	window?: boolean
+}
+
+/**
+ * Custom highlight style configuration.
+ *
+ * @example
+ * ```ts
+ * {
+ * 	stroke: {
+ * 		color: '#FFFF00',
+ * 		width: 3,
+ * 	},
+ * 	fill: {
+ * 		color: 'rgb(255, 255, 255, 0.7)',
+ * 	},
+ * }
+ * ```
+ */
+export interface CustomHighlightStyle {
+	/**
+	 * Object for defining the fill style.
+	 * See [OpenLayers documentation](https://openlayers.org/en/latest/apidoc/module-ol_style_Fill-Fill.html) for full options.
+	 */
+	fill: Fill
+
+	/**
+	 * Object for defining the stroke style.
+	 * See [OpenLayers documentation](https://openlayers.org/en/latest/apidoc/module-ol_style_Stroke-Stroke.html) for full options.
+	 */
+	stroke: Stroke
+}
+
+/**
+ * Configuration for visible features in the feature information window.
+ *
+ * @example
+ * ```ts
+ * {
+ * 	mode: 'visible',
+ * 	bindWithCoreHoverSelect: true,
+ * 	pageLength: 5,
+ * 	text: ['Nature reserves', (feature) => `${feature.get('str')} ${feature.get('hsnr')}`],
+ * }
+ * ```
+ */
+export interface FeatureList {
+	activeLayers: StoreReference
+
+	/**
+	 * Whether to show only features currently visible in the map view's bounding box or to display all loaded features.
+	 * In the latter case, if you desire to display all features of a layer (seen or not), set its loading strategy to `'all'`.
+	 * The loading strategy is a value in the OpenLayers vector source configuration; see [ol/loadingStrategy](https://openlayers.org/en/latest/apidoc/module-ol_loadingstrategy.html) for further details.
+	 */
+	mode: 'visible' | 'loaded'
+
+	/**
+	 * If `true`, the hover/select fields in the core's state will be listened to and interacted with.
+	 * This will result in a bilateral hovering and selecting of features with the core.
+	 *
+	 * @defaultValue false
+	 */
+	bindWithCoreHoverSelect?: boolean
+
+	/**
+	 * A number \>0 that sets the limit to the feature list's length.
+	 * If the length is surpassed, additional features can be reached by using the pagination that is generated in such a case.
+	 * If not defined, the list can be of arbitrary length.
+	 */
+	pageLength?: number
+
+	/**
+	 * Object with one to three entries that will produce title, subtitle, and an additional subtitle for the list view.
+	 * If string, the text item will simply be that feature's value for the denoted property.
+	 * If function, it's assumed to match the function signature `(feature: Feature): string`, and the returned string will be used for the text item.
+	 */
+	text?: {
+		title: ((feature: Feature) => string) | string
+		subtitle?: ((feature: Feature) => string) | string
+		subSubtitle?: ((feature: Feature) => string) | string
+	}
+}
+
+/**
+ * Plugin options for gfi plugin.
+ *
+ * @example
+ * An example configuration for the plugin might look like this:
+ * ```ts
+ * {
+ * 	mode: 'bboxDot',
+ * 	afterLoadFunction,
+ * 	layers: {
+ * 		'layerId': {
+ * 			geometry: true,
+ * 			window: true,
+ * 			maxFeatures: 10,
+ * 			geometryName: 'app:geometry',
+ * 			exportProperty: 'Export',
+ * 		},
+ * 	},
+ * 	coordinateSources: [
+ * 		{ plugin: 'pins', key: 'transformedCoordinate' },
+ * 		{ plugin: 'pins', key: 'coordinatesAfterDrag' },
+ * 	],
+ * 	customHighlightStyle: {
+ * 		stroke: {
+ * 			color: '#FFFF00',
+ * 			width: 3,
+ * 		},
+ * 		fill: {
+ * 			color: 'rgb(255, 255, 255, 0.7)',
+ * 		},
+ * 	},
+ * }
+ *
+ * function afterLoadFunction(featuresByLayerId: Record<string, GeoJsonFeature[]>): Record<string, GeoJsonFeature[]> {
+ * 	const filteredFeaturesByLayerId: Record<string, GeoJsonFeature[]> = {};
+ * 	for (const layerId in featuresByLayerId) {
+ * 		if (featuresByLayerId.hasOwnProperty(layerId)) {
+ * 			const features = featuresByLayerId[layerId];
+ * 			filteredFeaturesByLayerId[layerId] = features.filter(feature => feature.properties.type === 'desiredType');
+ * 		}
+ * 	}
+ * 	return filteredFeaturesByLayerId;
+ * }
+ * ```
+ */
+export interface GfiPluginOptions extends PluginOptions {
+	/**
+	 * Maps a string (must be a layer ID) to a behaviour configuration for that layer.
+	 */
+	layers: Record<string, GfiLayerConfiguration>
+
+	/**
+	 * This method can be used to extend, filter, or otherwise modify a GFI result.
+	 *
+	 * @param featuresByLayerId - List of features by layer ID
+	 * @returns Extended, filtered, or otherwise modified result
+	 */
+	afterLoadFunction?: (
+		featuresByLayerId: Record<string, GeoJsonFeature[]>
+	) => Record<string, GeoJsonFeature[]>
+
+	/**
+	 * The plugin will react to these coordinate positions in the store.
+	 * This allows it to react to e.g. the address search or the pins plugin.
+	 * Please see the example configuration for the common use-cases.
+	 * Please mind that, when referencing another plugin, that plugin must be in `addPlugins` before this one.
+	 */
+	coordinateSources?: StoreReference[]
+
+	/**
+	 * If required, a user can change the stroke and fill of the highlighted feature.
+	 * The default style as seen in the example will be used for each part that is not customized.
+	 * An empty object will return the complete default style while e.g. for an object without a configured fill the default fill will be applied.
+	 */
+	customHighlightStyle?: CustomHighlightStyle
+
+	/**
+	 * If `true`, a feature can be selected without defining a value in `gfi.coordinateSources`.
+	 *
+	 * It is also possible to add multiple features to the selection by using the modifier key (CTRL on Windows or Command on macOS).
+	 * To delesect a feature, simply reclick it with the modifier key pressed.
+	 * To create a new selection, click anywhere else without pressing the modifier key.
+	 *
+	 * Be careful when using this parameter together with some values set in `coordinateSources` as it may lead to unexpected results.
+	 * The features need to be distinguishable by their properties for the functionality to properly work.
+	 *
+	 * Does not work together with `extendedMasterportalapiMarkers`.
+	 *
+	 * @defaultValue false
+	 */
+	directSelect?: boolean
+
+	/**
+	 * If defined, a list of available vector layer features is visible when no feature is selected.
+	 * Only usable if `renderType` is set to `iconMenu` and `window` is set to `true` for at least one configured layer.
+	 */
+	featureList?: FeatureList
+
+	/**
+	 * Limits the viewable GFIs per layer by this number.
+	 * The first n elements are chosen arbitrarily.
+	 * Useful if you e.g. just want one result, or to limit an endless stream of returns to e.g. 10.
+	 * Infinite by default.
+	 *
+	 * @example 10
+	 */
+	maxFeatures?: number
+
+	/**
+	 * Method of calculating which feature has been chosen by the user.
+	 * `bboxDot` utilizes the `bbox`-url parameter using the clicked coordinate while `intersects` uses a `Filter` to calculate the intersected features.
+	 * Layers can have their own `gfiMode` parameter which would override this global mode.
+	 * To apply this, add the desired value to the parameter in the `mapConfiguration`.
+	 *
+	 * @defaultValue `'bboxDot'`
+	 */
+	mode?: 'bboxDot' | 'intersects'
+
+	/**
+	 * If configured, multiple features can be selected at once by using the modifier key (CTRL on Windows or Command on macOS) and dragging the mouse.
+	 * Can only be used in Desktop environments.
+	 *
+	 * If set to `'box'`, the selection will be done in a box.
+	 * If set to `'circle'`, the selection will be done in a circle.
+	 *
+	 * Similar to `directSelect`, features can be added and removed by selection / unselecting them.
+	 * The features need to be distinguishable by their properties for the functionality to properly work.
+	 * Does not work together with `extendedMasterportalapiMarkers` of `@polar/core`.
+	 *
+	 * @defaultValue Disabled by default
+	 */
+	multiSelect?: 'box' | 'circle'
+
+	/**
+	 * Only relevant if `window` is set to `true` for at least one layer.
+	 * Whether the gfi plugin is rendered independently or as part of the IconMenu.
+	 *
+	 * @defaultValue `'independent'`
+	 */
+	renderType?: 'independent' | 'iconMenu'
+}
+
+/** parameter specification for request method */
+export interface RequestGfiParameters {
+	coordinateOrExtent: [number, number] | [number, number, number, number]
+	layer: BaseLayer
+	layerConfiguration: GfiLayerConfiguration
+
+	/** rawLayerList entry, see https://bitbucket.org/geowerkstatt-hamburg/masterportal/src/dev/doc/services.json.md */
+	layerSpecification: Record<string, unknown>
+
+	map: Map
+
+	/** defaults to bboxDot (get from minimal coordinate bbox) */
+	mode?: 'bboxDot' | 'intersects'
+}
+
+export interface RequestGfiWmsParameters {
+	coordinate: [number, number]
+	layer: TileLayer<TileWMS> | ImageLayer<ImageWMS>
+	layerConfiguration: RequestGfiParameters['layerConfiguration']
+	layerSpecification: RequestGfiParameters['layerSpecification']
+	map: RequestGfiParameters['map']
+}
diff --git a/src/plugins/gfi/utils/getSourceFeatures.ts b/src/plugins/gfi/utils/getSourceFeatures.ts
new file mode 100644
index 0000000000..00dcb6b1d2
--- /dev/null
+++ b/src/plugins/gfi/utils/getSourceFeatures.ts
@@ -0,0 +1,17 @@
+import type { Map } from 'ol'
+import type VectorSource from 'ol/source/Vector'
+
+export function getSourceFeatures(
+	map: Map,
+	source: VectorSource,
+	mode: 'visible' | 'loaded'
+) {
+	if (mode === 'loaded') {
+		return source.getFeatures()
+	}
+
+	return source.getFeaturesInExtent(
+		map.getView().calculateExtent(map.getSize()),
+		map.getView().getProjection()
+	)
+}
diff --git a/src/plugins/gfi/utils/isValidHttpUrl.ts b/src/plugins/gfi/utils/isValidHttpUrl.ts
new file mode 100644
index 0000000000..e660b9fc77
--- /dev/null
+++ b/src/plugins/gfi/utils/isValidHttpUrl.ts
@@ -0,0 +1,17 @@
+/**
+ * Checks if a string is a possibly valid HTTP or HTTPS URL.
+ *
+ * @param string - String to check
+ * @returns true if the string could be an HTTP(S) URL, false otherwise
+ */
+export function isValidHttpUrl(string) {
+	let url
+
+	try {
+		url = new URL(string)
+	} catch {
+		return false
+	}
+
+	return url.protocol === 'http:' || url.protocol === 'https:'
+}
diff --git a/src/plugins/gfi/utils/requestGfi.ts b/src/plugins/gfi/utils/requestGfi.ts
new file mode 100644
index 0000000000..6a4918d675
--- /dev/null
+++ b/src/plugins/gfi/utils/requestGfi.ts
@@ -0,0 +1,67 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+
+import { rawLayerList } from '@masterportal/masterportalapi'
+import ImageLayer from 'ol/layer/Image'
+import TileLayer from 'ol/layer/Tile'
+import VectorLayer from 'ol/layer/Vector'
+
+import type { RequestGfiParameters } from '../types'
+
+import requestGfiGeoJson from './requestGfiGeoJson'
+import requestGfiWfs from './requestGfiWfs'
+import requestGfiWms from './requestGfiWms'
+
+/**
+ * The requestGfi method abstracts from service-specific implementation and
+ * retrieves feature information. Not all formats are supported yet.
+ *
+ * Namely, services returning any GML variant, or fitting text responses by
+ * default, should work. All others are not yet implemented.
+ * @param parameters - parameter object
+ * @returns found features for GFI request
+ */
+export function requestGfi({
+	map,
+	layer,
+	coordinateOrExtent,
+	layerConfiguration,
+	layerSpecification,
+	mode,
+}: RequestGfiParameters): Promise<GeoJsonFeature[]> {
+	const layerId = layer.get('id')
+	try {
+		const params = {
+			map,
+			layerConfiguration,
+			layerSpecification,
+		}
+		if (layer instanceof TileLayer || layer instanceof ImageLayer) {
+			return coordinateOrExtent.length === 2
+				? requestGfiWms({
+						...params,
+						coordinate: coordinateOrExtent,
+						layer,
+					})
+				: Promise.reject(
+						new Error(
+							`An extent can not be used for ${layerId} as it is a WMS layer which only support coordinates for gfi requests.`
+						)
+					)
+		}
+		if (
+			rawLayerList.getLayerWhere({ id: layerId })?.typ === 'GeoJSON' &&
+			// NOTE: This is the case by design of @masterportal/masterportalapi but is added here for type safety
+			layer instanceof VectorLayer
+		) {
+			return requestGfiGeoJson({ ...params, coordinateOrExtent, layer })
+		}
+		if (layer instanceof VectorLayer) {
+			return requestGfiWfs({ ...params, coordinateOrExtent, mode })
+		}
+		const notImplemented = `Layer ${layerId} was neither a Tile- nor a VectorLayer. GFI not implemented.`
+		return Promise.reject(new Error(notImplemented))
+	} catch {
+		const error = `An error occurred while requesting features from layer with the id ${layerId}.`
+		return Promise.reject(new Error(error))
+	}
+}
diff --git a/src/plugins/gfi/utils/requestGfiGeoJson.ts b/src/plugins/gfi/utils/requestGfiGeoJson.ts
new file mode 100644
index 0000000000..768e434c7b
--- /dev/null
+++ b/src/plugins/gfi/utils/requestGfiGeoJson.ts
@@ -0,0 +1,50 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+import type { FeatureLike } from 'ol/Feature'
+
+import { Feature, Map } from 'ol'
+import { GeoJSON } from 'ol/format'
+import VectorLayer from 'ol/layer/Vector'
+
+const writer = new GeoJSON()
+
+const getNestedFeatures = (
+	feature: Feature | FeatureLike
+): Feature | Feature[] | FeatureLike =>
+	feature instanceof Feature
+		? feature.get('features')?.length
+			? feature.get('features')
+			: feature
+		: feature
+
+/**
+ * Returns features from GeoJSON layer as GeoJSON.
+ */
+export default ({
+	map,
+	coordinateOrExtent,
+	layer,
+}: {
+	map: Map
+	coordinateOrExtent: [number, number] | [number, number, number, number]
+	layer: VectorLayer
+}): Promise<GeoJsonFeature[]> =>
+	Promise.resolve(
+		(coordinateOrExtent.length === 2
+			? map.getFeaturesAtPixel(map.getPixelFromCoordinate(coordinateOrExtent), {
+					layerFilter: (candidate) => candidate === layer,
+				})
+			: // @ts-expect-error | Layers reaching this place have a source
+				layer
+					.getSource()
+					.getFeaturesInExtent(coordinateOrExtent)
+					.map(getNestedFeatures)
+					.flat(1)
+		)
+			.map((feature) =>
+				feature instanceof Feature
+					? JSON.parse(writer.writeFeature(feature))
+					: false
+			)
+			// remove FeatureLikes
+			.filter((x) => x)
+	)
diff --git a/src/plugins/gfi/utils/requestGfiWfs.ts b/src/plugins/gfi/utils/requestGfiWfs.ts
new file mode 100644
index 0000000000..020d35545a
--- /dev/null
+++ b/src/plugins/gfi/utils/requestGfiWfs.ts
@@ -0,0 +1,122 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+
+import { GeoJSON, WFS } from 'ol/format'
+
+import type { RequestGfiParameters } from '../types'
+
+/**
+ * Parses WFS reply to jsonable objects.
+ * NOTE This method may break on unexpected formats and require further
+ * detection. For now, all WFS seem to "behave".
+ * @param xmlString - Features as returned by WFS service
+ * @param wfsVersion - Version of WFS service
+ * @returns features as flat GeoJSON (NOT ol/GeoJSON)
+ */
+const xml2GeoJson = (
+	xmlString: string,
+	wfsVersion: string
+): GeoJsonFeature[] => {
+	const parser = new WFS({ version: wfsVersion })
+	const writer = new GeoJSON()
+	const features = parser.readFeatures(xmlString)
+	const geoJsonFeatures = features.map((f) =>
+		JSON.parse(writer.writeFeature(f))
+	)
+
+	return geoJsonFeatures
+}
+
+/**
+ * Executes gfi request on wfs layer and returns result as GeoJSON.
+ * NOTE Optimization idea: For layers where features are regularly loaded,
+ * no new request should be started. Instead, wait for any running load to
+ * finish and use feature at layer source coordinate. (Not trivial.)
+ */
+export default ({
+	map,
+	coordinateOrExtent,
+	layerConfiguration,
+	layerSpecification,
+	mode,
+}: Pick<
+	RequestGfiParameters,
+	| 'map'
+	| 'coordinateOrExtent'
+	| 'layerConfiguration'
+	| 'layerSpecification'
+	| 'mode'
+>): Promise<GeoJsonFeature[]> => {
+	if (coordinateOrExtent.length === 4 && mode !== 'bboxDot') {
+		return Promise.reject(
+			new Error(
+				`Configuration error in requestGfiWfs.ts: mode must be "bboxDot" to be able to use an extent for gfi requests, but was "${mode}".`
+			)
+		)
+	}
+	const { featureType, url, version } = layerSpecification
+	const { geometryName } = layerConfiguration
+	const code = map.getView().getProjection().getCode()
+	const typeName = version === '2.0.0' ? 'typeNames' : 'typename'
+	// TODO: Layer list needs better typing
+
+	const featureUrl = new URL(url as string)
+	featureUrl.searchParams.set('service', 'WFS')
+	featureUrl.searchParams.set('version', version as string)
+	featureUrl.searchParams.set('request', 'GetFeature')
+	featureUrl.searchParams.set(typeName, featureType as string)
+	featureUrl.searchParams.set('srsName', code)
+
+	if (mode === 'bboxDot') {
+		const extent =
+			coordinateOrExtent.length === 2
+				? /* The extended extent is necessary because an extent with the same
+					 * coordinates could lead to an empty featureCollection. */
+					[
+						coordinateOrExtent[0] - 0.1,
+						coordinateOrExtent[1] - 0.1,
+						coordinateOrExtent[0] + 0.1,
+						coordinateOrExtent[1] + 0.1,
+					]
+				: coordinateOrExtent
+
+		// TODO: Layer list needs better typing
+		featureUrl.searchParams.set('bbox', `${extent.join(',')},${code}`)
+	} else if (mode === 'intersects') {
+		const point =
+			`<gml:Point srsName="${code}">` +
+			`<gml:coordinates>${coordinateOrExtent[0]},${coordinateOrExtent[1]}</gml:coordinates>` +
+			'</gml:Point>'
+		featureUrl.searchParams.set(
+			'FILTER',
+			// NOTE: fes as a namespace and ValueReference for a property has been introduced in 2.0.0
+			version === '2.0.0'
+				? '<fes:Filter>' +
+						'<fes:Intersects>' +
+						`<fes:ValueReference>${geometryName}</fes:ValueReference>` +
+						point +
+						'</fes:Intersects>' +
+						'</fes:Filter>'
+				: '<ogc:Filter xmlns:ogc="http://www.opengis.net/ogc">' +
+						'<ogc:Intersects>' +
+						`<ogc:PropertyName>${geometryName}</ogc:PropertyName>` +
+						point +
+						'</fes:Intersects>' +
+						'</fes:Filter>'
+		)
+	} else {
+		return Promise.reject(
+			new Error(
+				`Type error in requestGfiWfs.ts: mode must be "intersects" or "bboxDot", but was "${mode}".`
+			)
+		)
+	}
+
+	return (
+		fetch(featureUrl, { method: 'GET' })
+			.then((response) => response.text())
+			// TODO: Type of layerSpecification needs an update to better reflect the possibilities of the services
+			//  and get rid of this @ts-expect-error
+			// @ts-expect-error | Better typing is needed here
+			.then((xmlText) => xml2GeoJson(xmlText, version))
+	)
+}
diff --git a/src/plugins/gfi/utils/requestGfiWms.ts b/src/plugins/gfi/utils/requestGfiWms.ts
new file mode 100644
index 0000000000..24aaf48704
--- /dev/null
+++ b/src/plugins/gfi/utils/requestGfiWms.ts
@@ -0,0 +1,210 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+
+import { Feature } from 'ol'
+import { GeoJSON } from 'ol/format'
+import GML from 'ol/format/GML'
+import GML2 from 'ol/format/GML2'
+import GML3 from 'ol/format/GML3'
+import GML32 from 'ol/format/GML32'
+import WFS from 'ol/format/WFS'
+import { TileWMS } from 'ol/source'
+
+import type { RequestGfiWmsParameters } from '../types'
+
+// list of supported reply formats that can be used from OL
+const formats = {
+	GML,
+	GML2,
+	GML3,
+	GML32,
+}
+
+/**
+ * This is a custom text response reader working on an unspecified format that
+ * commonly occurs in WMS GFI replies. It can be used by specifying "text" as
+ * "format" on a GFI specification. Please mind that it's written from
+ * experience, not from a clear definition, and may need attention whenever
+ * new cases arise.
+ * @param text - Custom text response, hopefully in the implemented format
+ * @returns array of OpenLayers features
+ */
+function readTextFeatures(text: string): Feature[] {
+	const lines = text.split('\n')
+	const features: Feature[] = []
+	let feature: Feature | undefined
+
+	/* TODO: Format supposedly looks like this – is this a standard or arbitrary?
+		GetFeatureInfo results:
+			LayerName:
+				FeatureId:
+					Horse: Yes
+					Speed: Fast
+					Horsepower: 4
+	*/
+
+	for (const line of lines) {
+		if (
+			line === '' ||
+			line.startsWith('GetFeatureInfo results') ||
+			line.startsWith('Layer')
+		) {
+			continue
+		}
+		if (line.startsWith('    ')) {
+			if (typeof feature !== 'undefined') {
+				const equalIndex = line.indexOf('=')
+				const [key, value] = [
+					line.substring(0, equalIndex),
+					line.substring(equalIndex + 3, line.length - 1),
+				].map((s) => s.trim())
+				feature.set(key || '', value)
+			} else {
+				console.error(
+					'@polar/plugin-gfi: Found property before feature declaration in readTextFeatures.',
+					line,
+					'Skipping ...'
+				)
+			}
+			continue
+		}
+		if (line.startsWith('  ')) {
+			if (line.includes('Search returned no results')) {
+				break
+			}
+			const id = line.substring(0, line.length - 2).trim()
+			feature = new Feature()
+			feature.setId(id)
+			features.push(feature)
+		}
+	}
+	return features
+}
+
+/**
+ * In case the layer configuration does not specify a parser, we're trying to
+ * detect the returned XML format by searching for a GML namespace. Any return
+ * format outside GML will currently not work with this automated parsing.
+ * @param data - data as parsed from response body
+ * @returns WFS capable of parsing data
+ */
+function getParserFromData(data: string): WFS {
+	// NOTE: Tested for GML32 and GML, may break on GML2/GML3
+	const GMLFormat = data.includes('xmlns:gml="http://www.opengis.net/gml/3.2"')
+		? GML32
+		: data.includes('xmlns:gml="http://www.opengis.net/gml"')
+			? GML
+			: data.includes('xmlns:gml="http://www.opengis.net/gml/2')
+				? GML2
+				: GML3
+
+	return new WFS({
+		gmlFormat: new GMLFormat(),
+	})
+}
+
+/**
+ * A layer may have its parser specified in the configuration. In this case,
+ * the specified parser is retrieved from a list of supported GML parsers, or a
+ * custom text parser is used in case it fits.
+ * @param format - format as specified by mapConfiguration
+ * @returns object that supplies 'readTextFeatures' method
+ */
+function getParserFromFormat(format: string): Pick<WFS, 'readFeatures'> {
+	if (formats[format]) {
+		return new WFS({
+			gmlFormat: new formats[format](),
+		})
+	}
+
+	if (format === 'text') {
+		return {
+			readFeatures: readTextFeatures,
+		}
+	}
+
+	throw new Error(`Format '${format}' not yet implemented in requestGfiWms.ts.`)
+}
+
+/**
+ * @param parameters - map, layer, and coordinate to use for GFI request
+ * @returns url to request for feature information
+ */
+function getWmsGfiUrl(
+	{ map, layer, coordinate }: RequestGfiWmsParameters,
+	{ infoFormat }: Record<string, unknown>
+): string {
+	// Only layers with a valid source reach this point
+	const source = layer.getSource() as TileWMS
+	const view = map.getView()
+	const url = source.getFeatureInfoUrl(
+		coordinate,
+		// The view always has a resolution if this function is called
+		view.getResolution() as number,
+		view.getProjection(),
+		{
+			feature_count: 10,
+		}
+	)
+	const suffix =
+		infoFormat && typeof infoFormat === 'string'
+			? `&info_format=${infoFormat}`
+			: ''
+	return (url || '') + suffix
+}
+
+/**
+ * Method fetches WMS feature information. Result will be filtered and modified
+ * according to layerConfiguration.
+ * @param parameters - parameter object
+ * @returns promise of all features that hold relevant feature information
+ */
+export default (
+	parameters: RequestGfiWmsParameters
+): Promise<GeoJsonFeature[]> => {
+	const { coordinate, layerConfiguration, layerSpecification } = parameters
+	const { filterBy, geometryName, format } = layerConfiguration
+
+	const url = getWmsGfiUrl(parameters, layerSpecification)
+
+	return fetch(url)
+		.then((response) => response.text())
+		.then((data) => {
+			/* NOTE: test block for WMS GFI
+			import WMSGetFeatureInfo from 'ol/format/WMSGetFeatureInfo'
+			try {
+				console.error('WMS GFI', url)
+				console.error(new WMSGetFeatureInfo().readFeatures(data))
+			} catch (e) {
+				console.error(e)
+			}
+			*/
+
+			const parser =
+				layerSpecification.infoFormat === 'application/geojson'
+					? new GeoJSON()
+					: format
+						? getParserFromFormat(format)
+						: getParserFromData(data)
+
+			const parsedFeatures: Feature[] = parser.readFeatures(data)
+			const writer = new GeoJSON()
+
+			if (geometryName) {
+				parsedFeatures.forEach((f) => {
+					f.setGeometryName('geometry')
+				})
+			}
+
+			const jsonFeatures = parsedFeatures
+				// WMS may return features nearby - filter to hit features
+				.filter((feature) =>
+					filterBy === 'clickPosition'
+						? feature.getGeometry()?.intersectsCoordinate(coordinate)
+						: true
+				)
+				// transform to jsonable object representation
+				.map((f) => JSON.parse(writer.writeFeature(f)))
+
+			return jsonFeatures
+		})
+}
diff --git a/src/plugins/gfi/utils/serializeFeature.ts b/src/plugins/gfi/utils/serializeFeature.ts
new file mode 100644
index 0000000000..21f22bc41d
--- /dev/null
+++ b/src/plugins/gfi/utils/serializeFeature.ts
@@ -0,0 +1,13 @@
+import type { Feature as GeoJsonFeature } from 'geojson'
+import type { Feature } from 'ol'
+
+import { GeoJSON } from 'ol/format'
+
+const writer = new GeoJSON()
+
+/**
+ * Convert an OpenLayers feature to a GeoJSON feature.
+ */
+export function serializeFeature(feature: Feature): GeoJsonFeature {
+	return writer.writeFeatureObject(feature)
+}
diff --git a/src/plugins/gfi/utils/updateTooltip.ts b/src/plugins/gfi/utils/updateTooltip.ts
new file mode 100644
index 0000000000..7ed1fe73ce
--- /dev/null
+++ b/src/plugins/gfi/utils/updateTooltip.ts
@@ -0,0 +1,52 @@
+import { Feature, Overlay, type MapBrowserEvent } from 'ol'
+
+import { getTooltip } from '@/lib/tooltip'
+
+export function updateTooltip(
+	{ pixel, dragging, originalEvent, map }: MapBrowserEvent,
+	overlay: Overlay,
+	tooltipGenerators: Record<string, (feature: Feature) => [string, string][]>
+) {
+	if (
+		dragging ||
+		('pointerType' in originalEvent &&
+			['touch', 'pen'].includes(originalEvent.pointerType))
+	) {
+		return null
+	}
+
+	let hasFeatureAtPixel = false
+	let unregister: (() => void) | null = null
+
+	// stops on return `true`, thus only using the uppermost feature
+	map.forEachFeatureAtPixel(
+		pixel,
+		(feature, layer) => {
+			if (!(feature instanceof Feature)) {
+				return false
+			}
+			hasFeatureAtPixel = true
+			overlay.setPosition(map.getCoordinateFromPixel(pixel))
+			if (unregister) {
+				unregister()
+			}
+			let element
+			;({ element, unregister } = getTooltip(
+				tooltipGenerators[layer.get('id')]?.(feature) as [string, string][]
+			))
+			overlay.setElement(element)
+			return true
+		},
+		{
+			layerFilter: (layer) =>
+				Object.keys(tooltipGenerators).includes(layer.get('id')),
+		}
+	)
+
+	// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+	if (!hasFeatureAtPixel) {
+		overlay.setPosition(undefined)
+	}
+
+	return unregister
+}
diff --git a/vue2/packages/plugins/Gfi/CHANGELOG.md b/vue2/packages/plugins/Gfi/CHANGELOG.md
deleted file mode 100644
index 53b6526e35..0000000000
--- a/vue2/packages/plugins/Gfi/CHANGELOG.md
+++ /dev/null
@@ -1,68 +0,0 @@
-# CHANGELOG
-
-## unpublished
-
-- Fix: When using the gfi with `renderType` set to `'independent'` the window was not added to the MoveHandle to be displayed on mobile devices. Also, the closeIcon was incorrectly set if `ƒeatureList` was configured. This has been fixed by watching for changes to `windowFeatures`.
-
-## 3.0.2
-
-- Fix: Allow layers that have `singleTile` set to `true` and thus being an `ImageLayer` instead a `TileLayer` to be used for GFI-requests as well.
-
-## 3.0.1
-
-- Fix: Clean-up internal flag used for `multiSelect` if a drawing is aborted. This is always the case if a user simply clicks into the map holding CTRL / Command.
-
-## 3.0.0
-
-- Breaking: Upgrade `@masterportal/masterportalapi` from `2.40.0` to `2.45.0` and subsequently `ol` from `^9.2.4` to `^10.3.1`.
-- Feature: Add new configuration parameter `multiSelect` to enable the possibility to choose between the selecting multiple features through a box or through a circle. The addition of this parameter deprecates the previously used parameter `boxSelect`.
-- Fix: Correctly disable `directSelect` if the user is currently using functionality of `@polar/plugin-draw`.
-
-## 2.1.0
-
-- Feature: Add new action `setFeatureInformation` to be able to set feature information in the store and trigger all relevant processes so that the information displayed to the user is as if he has selected the features himself.
-
-## 2.0.0
-
-- Breaking: Upgrade `@masterportal/masterportalapi` from `2.8.0` to `2.40.0` and subsequently `ol` from `^7.1.0` to `^9.2.4`.
-- Feature: Add new configuration parameter `isSelectable` that can be used to filter features to be unselectable.
-- Feature: Add new configuration parameters `directSelect` and `boxSelect` to be able to select multiple features at once.
-- Fix: Adjust documentation to properly describe optionality of configuration parameters.
-- Fix: Add missing configuration parameters `featureList` and `maxFeatures` to the general documentation and `filterBy` and `format` to `gfi.gfiLayerConfiguration`
-- Fix: Add missing entry of `gfiContentComponent` to `GfiGetters`.
-- Fix: Fix issue rendering properties of a feature if a value is not a string.
-- Refactor: Replace redundant prop-forwarding with `getters`.
-- Refactor: Use core getter `clientWidth` instead of local computed value.
-- Chore: expand on the description to `gfiContentComponent` in the Readme.md.
-
-## 1.2.2
-
-- Fix: The `close` method previously always removed the pin when not in `extendedMasterportalapiMarkers` mode. This issue has been resolved by distinguishing whether a close operation happened in effect to a direct closing user interaction or was technically motivated.
-
-## 1.2.1
-
-- Fix: Add missing deregistration of event listeners on destruction.
-
-## 1.2.0
-
-- Feature: Improved implementation to make plugin SPA-ready.
-- Feature: Improve WFS list highlighting with focus/hover styles that are easier to decipher for end users.
-- Feature: Add the possibility to update the close-button to e.g. indicate movement to the vector layer feature list.
-- Feature: Prevent tooltip windows on touch and pen events; now only mouse hover events produce such tooltips now.
-- Feature: If a feature with related features (cluster) is selected in the feature list, users can now toggle between the features with forward/backward buttons, just like when selecting clustered features in the map.
-- Feature: If a feature becomes clustered / is no longer clustered when zooming out / in, the selected features are updated properly now based on the selected cluster in the map.
-
-## 1.1.0
-
-- Feature: Add cluster-ready vector layer feature list with pagination, see configuration parameter `gfiLayerConfiguration.featureList`.
-- Feature: Can now be rendered as child of icon menu, see configuration parameter `renderType`.
-- Feature: Add optional configuration parameter `activeLayerPath` to allow checking for whether any fitting layer is active.
-- Feature: Add support for type `GeoJSON` layers.
-- Feature: Render mobile content in `MoveHandle` of `@polar/core`.
-- Fix: Add space to dev GFI window to fully contain close button effects.
-- Fix: Documentation error regarding plugin state.
-- Fix: `<img>`s constantly firing `onload`-event thus constantly firing `resize`.
-
-## 1.0.0
-
-Initial release.
diff --git a/vue2/packages/plugins/Gfi/LICENSE b/vue2/packages/plugins/Gfi/LICENSE
deleted file mode 100644
index c29ce2f835..0000000000
--- a/vue2/packages/plugins/Gfi/LICENSE
+++ /dev/null
@@ -1,287 +0,0 @@
-                      EUROPEAN UNION PUBLIC LICENCE v. 1.2
-                      EUPL © the European Union 2007, 2016
-
-This European Union Public Licence (the ‘EUPL’) applies to the Work (as defined
-below) which is provided under the terms of this Licence. Any use of the Work,
-other than as authorised under this Licence is prohibited (to the extent such
-use is covered by a right of the copyright holder of the Work).
-
-The Work is provided under the terms of this Licence when the Licensor (as
-defined below) has placed the following notice immediately following the
-copyright notice for the Work:
-
-        Licensed under the EUPL
-
-or has expressed by any other means his willingness to license under the EUPL.
-
-1. Definitions
-
-In this Licence, the following terms have the following meaning:
-
-- ‘The Licence’: this Licence.
-
-- ‘The Original Work’: the work or software distributed or communicated by the
-  Licensor under this Licence, available as Source Code and also as Executable
-  Code as the case may be.
-
-- ‘Derivative Works’: the works or software that could be created by the
-  Licensee, based upon the Original Work or modifications thereof. This Licence
-  does not define the extent of modification or dependence on the Original Work
-  required in order to classify a work as a Derivative Work; this extent is
-  determined by copyright law applicable in the country mentioned in Article 15.
-
-- ‘The Work’: the Original Work or its Derivative Works.
-
-- ‘The Source Code’: the human-readable form of the Work which is the most
-  convenient for people to study and modify.
-
-- ‘The Executable Code’: any code which has generally been compiled and which is
-  meant to be interpreted by a computer as a program.
-
-- ‘The Licensor’: the natural or legal person that distributes or communicates
-  the Work under the Licence.
-
-- ‘Contributor(s)’: any natural or legal person who modifies the Work under the
-  Licence, or otherwise contributes to the creation of a Derivative Work.
-
-- ‘The Licensee’ or ‘You’: any natural or legal person who makes any usage of
-  the Work under the terms of the Licence.
-
-- ‘Distribution’ or ‘Communication’: any act of selling, giving, lending,
-  renting, distributing, communicating, transmitting, or otherwise making
-  available, online or offline, copies of the Work or providing access to its
-  essential functionalities at the disposal of any other natural or legal
-  person.
-
-2. Scope of the rights granted by the Licence
-
-The Licensor hereby grants You a worldwide, royalty-free, non-exclusive,
-sublicensable licence to do the following, for the duration of copyright vested
-in the Original Work:
-
-- use the Work in any circumstance and for all usage,
-- reproduce the Work,
-- modify the Work, and make Derivative Works based upon the Work,
-- communicate to the public, including the right to make available or display
-  the Work or copies thereof to the public and perform publicly, as the case may
-  be, the Work,
-- distribute the Work or copies thereof,
-- lend and rent the Work or copies thereof,
-- sublicense rights in the Work or copies thereof.
-
-Those rights can be exercised on any media, supports and formats, whether now
-known or later invented, as far as the applicable law permits so.
-
-In the countries where moral rights apply, the Licensor waives his right to
-exercise his moral right to the extent allowed by law in order to make effective
-the licence of the economic rights here above listed.
-
-The Licensor grants to the Licensee royalty-free, non-exclusive usage rights to
-any patents held by the Licensor, to the extent necessary to make use of the
-rights granted on the Work under this Licence.
-
-3. Communication of the Source Code
-
-The Licensor may provide the Work either in its Source Code form, or as
-Executable Code. If the Work is provided as Executable Code, the Licensor
-provides in addition a machine-readable copy of the Source Code of the Work
-along with each copy of the Work that the Licensor distributes or indicates, in
-a notice following the copyright notice attached to the Work, a repository where
-the Source Code is easily and freely accessible for as long as the Licensor
-continues to distribute or communicate the Work.
-
-4. Limitations on copyright
-
-Nothing in this Licence is intended to deprive the Licensee of the benefits from
-any exception or limitation to the exclusive rights of the rights owners in the
-Work, of the exhaustion of those rights or of other applicable limitations
-thereto.
-
-5. Obligations of the Licensee
-
-The grant of the rights mentioned above is subject to some restrictions and
-obligations imposed on the Licensee. Those obligations are the following:
-
-Attribution right: The Licensee shall keep intact all copyright, patent or
-trademarks notices and all notices that refer to the Licence and to the
-disclaimer of warranties. The Licensee must include a copy of such notices and a
-copy of the Licence with every copy of the Work he/she distributes or
-communicates. The Licensee must cause any Derivative Work to carry prominent
-notices stating that the Work has been modified and the date of modification.
-
-Copyleft clause: If the Licensee distributes or communicates copies of the
-Original Works or Derivative Works, this Distribution or Communication will be
-done under the terms of this Licence or of a later version of this Licence
-unless the Original Work is expressly distributed only under this version of the
-Licence — for example by communicating ‘EUPL v. 1.2 only’. The Licensee
-(becoming Licensor) cannot offer or impose any additional terms or conditions on
-the Work or Derivative Work that alter or restrict the terms of the Licence.
-
-Compatibility clause: If the Licensee Distributes or Communicates Derivative
-Works or copies thereof based upon both the Work and another work licensed under
-a Compatible Licence, this Distribution or Communication can be done under the
-terms of this Compatible Licence. For the sake of this clause, ‘Compatible
-Licence’ refers to the licences listed in the appendix attached to this Licence.
-Should the Licensee's obligations under the Compatible Licence conflict with
-his/her obligations under this Licence, the obligations of the Compatible
-Licence shall prevail.
-
-Provision of Source Code: When distributing or communicating copies of the Work,
-the Licensee will provide a machine-readable copy of the Source Code or indicate
-a repository where this Source will be easily and freely available for as long
-as the Licensee continues to distribute or communicate the Work.
-
-Legal Protection: This Licence does not grant permission to use the trade names,
-trademarks, service marks, or names of the Licensor, except as required for
-reasonable and customary use in describing the origin of the Work and
-reproducing the content of the copyright notice.
-
-6. Chain of Authorship
-
-The original Licensor warrants that the copyright in the Original Work granted
-hereunder is owned by him/her or licensed to him/her and that he/she has the
-power and authority to grant the Licence.
-
-Each Contributor warrants that the copyright in the modifications he/she brings
-to the Work are owned by him/her or licensed to him/her and that he/she has the
-power and authority to grant the Licence.
-
-Each time You accept the Licence, the original Licensor and subsequent
-Contributors grant You a licence to their contributions to the Work, under the
-terms of this Licence.
-
-7. Disclaimer of Warranty
-
-The Work is a work in progress, which is continuously improved by numerous
-Contributors. It is not a finished work and may therefore contain defects or
-‘bugs’ inherent to this type of development.
-
-For the above reason, the Work is provided under the Licence on an ‘as is’ basis
-and without warranties of any kind concerning the Work, including without
-limitation merchantability, fitness for a particular purpose, absence of defects
-or errors, accuracy, non-infringement of intellectual property rights other than
-copyright as stated in Article 6 of this Licence.
-
-This disclaimer of warranty is an essential part of the Licence and a condition
-for the grant of any rights to the Work.
-
-8. Disclaimer of Liability
-
-Except in the cases of wilful misconduct or damages directly caused to natural
-persons, the Licensor will in no event be liable for any direct or indirect,
-material or moral, damages of any kind, arising out of the Licence or of the use
-of the Work, including without limitation, damages for loss of goodwill, work
-stoppage, computer failure or malfunction, loss of data or any commercial
-damage, even if the Licensor has been advised of the possibility of such damage.
-However, the Licensor will be liable under statutory product liability laws as
-far such laws apply to the Work.
-
-9. Additional agreements
-
-While distributing the Work, You may choose to conclude an additional agreement,
-defining obligations or services consistent with this Licence. However, if
-accepting obligations, You may act only on your own behalf and on your sole
-responsibility, not on behalf of the original Licensor or any other Contributor,
-and only if You agree to indemnify, defend, and hold each Contributor harmless
-for any liability incurred by, or claims asserted against such Contributor by
-the fact You have accepted any warranty or additional liability.
-
-10. Acceptance of the Licence
-
-The provisions of this Licence can be accepted by clicking on an icon ‘I agree’
-placed under the bottom of a window displaying the text of this Licence or by
-affirming consent in any other similar way, in accordance with the rules of
-applicable law. Clicking on that icon indicates your clear and irrevocable
-acceptance of this Licence and all of its terms and conditions.
-
-Similarly, you irrevocably accept this Licence and all of its terms and
-conditions by exercising any rights granted to You by Article 2 of this Licence,
-such as the use of the Work, the creation by You of a Derivative Work or the
-Distribution or Communication by You of the Work or copies thereof.
-
-11. Information to the public
-
-In case of any Distribution or Communication of the Work by means of electronic
-communication by You (for example, by offering to download the Work from a
-remote location) the distribution channel or media (for example, a website) must
-at least provide to the public the information requested by the applicable law
-regarding the Licensor, the Licence and the way it may be accessible, concluded,
-stored and reproduced by the Licensee.
-
-12. Termination of the Licence
-
-The Licence and the rights granted hereunder will terminate automatically upon
-any breach by the Licensee of the terms of the Licence.
-
-Such a termination will not terminate the licences of any person who has
-received the Work from the Licensee under the Licence, provided such persons
-remain in full compliance with the Licence.
-
-13. Miscellaneous
-
-Without prejudice of Article 9 above, the Licence represents the complete
-agreement between the Parties as to the Work.
-
-If any provision of the Licence is invalid or unenforceable under applicable
-law, this will not affect the validity or enforceability of the Licence as a
-whole. Such provision will be construed or reformed so as necessary to make it
-valid and enforceable.
-
-The European Commission may publish other linguistic versions or new versions of
-this Licence or updated versions of the Appendix, so far this is required and
-reasonable, without reducing the scope of the rights granted by the Licence. New
-versions of the Licence will be published with a unique version number.
-
-All linguistic versions of this Licence, approved by the European Commission,
-have identical value. Parties can take advantage of the linguistic version of
-their choice.
-
-14. Jurisdiction
-
-Without prejudice to specific agreement between parties,
-
-- any litigation resulting from the interpretation of this License, arising
-  between the European Union institutions, bodies, offices or agencies, as a
-  Licensor, and any Licensee, will be subject to the jurisdiction of the Court
-  of Justice of the European Union, as laid down in article 272 of the Treaty on
-  the Functioning of the European Union,
-
-- any litigation arising between other parties and resulting from the
-  interpretation of this License, will be subject to the exclusive jurisdiction
-  of the competent court where the Licensor resides or conducts its primary
-  business.
-
-15. Applicable Law
-
-Without prejudice to specific agreement between parties,
-
-- this Licence shall be governed by the law of the European Union Member State
-  where the Licensor has his seat, resides or has his registered office,
-
-- this licence shall be governed by Belgian law if the Licensor has no seat,
-  residence or registered office inside a European Union Member State.
-
-Appendix
-
-‘Compatible Licences’ according to Article 5 EUPL are:
-
-- GNU General Public License (GPL) v. 2, v. 3
-- GNU Affero General Public License (AGPL) v. 3
-- Open Software License (OSL) v. 2.1, v. 3.0
-- Eclipse Public License (EPL) v. 1.0
-- CeCILL v. 2.0, v. 2.1
-- Mozilla Public Licence (MPL) v. 2
-- GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3
-- Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for
-  works other than software
-- European Union Public Licence (EUPL) v. 1.1, v. 1.2
-- Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong
-  Reciprocity (LiLiQ-R+).
-
-The European Commission may update this Appendix to later versions of the above
-licences without producing a new version of the EUPL, as long as they provide
-the rights granted in Article 2 of this Licence and protect the covered Source
-Code from exclusive appropriation.
-
-All other changes or additions to this Appendix require the production of a new
-EUPL version.
\ No newline at end of file
diff --git a/vue2/packages/plugins/Gfi/README.md b/vue2/packages/plugins/Gfi/README.md
deleted file mode 100644
index a7c9e9e05f..0000000000
--- a/vue2/packages/plugins/Gfi/README.md
+++ /dev/null
@@ -1,242 +0,0 @@
-# GFI
-
-## Scope
-
-The GFI plugin can be used to fetch and optionally display GFI (GetFeatureInfo) from WMS and WFS services as well as layers based on GeoJSON files. In a first step, the information is stored in the VueX store to allow for easy access. Display is optional and quite obstructive within the map client.
-
-> ⚠️ The display feature is currently not meant for production. Please use data bindings for display to avoid obstructing the map client.
-
-## Configuration
-
-### gfi
-
-| fieldName | type | description |
-| - | - | - |
-| coordinateSources | string[] | The GFI plugin will react to these coordinate positions in the store. This allows it to react to e.g. the address search of the pins plugin. Please see example configuration for the common use-cases. Please mind that, when referencing another plugin, that plugin must be in `addPlugins` before this one. |
-| layers | Record<string, gfiLayerConfiguration> | Maps a string (must be a layer ID) to a behaviour configuration for that layer. |
-| activeLayerPath | string? | Optional store path to array of active mask layer ids. If used with `LayerChooser`, setting this to `'plugin/layerChooser/activeMaskIds'` will result in an info text in the GFI box, should no layer be active. If used without `LayerChooser`, the active mask layers have to be provided by another plugin or the client. If not set, the GFI plugin may e.g. show an empty list, which may be confusing to some users. |
-| afterLoadFunction | function (featuresByLayerId: Record<string, GeoJsonFeature[]>): Record<layerId, GeoJsonFeature[]>? | This method can be used to extend, filter, or otherwise modify a GFI result. |
-| boxSelect | boolean? | **This parameter has been deprecated. Please use `multiSelect` to `'box'` instead.** If set to `true`, multiple features can be selected at once by using the modifier key (CTRL on Windows or Command on macOS) and dragging the mouse. Can only be used in Desktop environments. Similar to `gfi.directSelect`, features can be added and removed by selection / unselecting them. The features need to be distinguishable by their properties for the functionality to properly work. Does not work together with `extendedMasterportalapiMarkers` of `@polar/core`. Defaults to `false`. |
-| customHighlightStyle | customHighlightStyle? | If required a user can change the stroke and fill of the highlighted feature. The default style as seen in the example will be used for each part that is not customized. An empty object will return the complete default style while e.g. for an object without a configured fill the default fill will be applied. |
-| directSelect | boolean? | If set to `true`, a feature can be selected without defining a value in `gfi.coordinateSources`. It is also possible to add multiple features to the selection by using the modifier key (CTRL on Windows or Command on macOS). To delesect a feature, simply reclick it with the modifier key pressed. To create a new selection, click anywhere else without pressing the modifier key. Be careful when using this parameter together with some values set in `coordinateSources` as it may lead to unexpected results. The features need to be distinguishable by their properties for the functionality to properly work. Does not work together with `extendedMasterportalapiMarkers` of `@polar/core`. Defaults to `false`. |
-| featureList | featureList? | If defined, a list of available vector layer features is visible when no feature is selected. Only usable if `renderType` is set to `iconMenu` and `window` is set to `true` for at least one configured layer. |
-| gfiContentComponent | VueConstructor? | Allows overriding the GfiContent.vue component for custom design and functionality. Coding knowledge is required to use this feature, as any implementation will have to rely upon the VueX store model. Please refer to the implementation. |
-| maxFeatures | number? | Limits the viewable GFIs per layer by this number. The first n elements are chosen arbitrarily. Useful if you e.g. just want one result, or to limit an endless stream of returns to e.g. 10. Infinite by default. |
-| mode | enum["bboxDot", "intersects"]? | Method of calculating which feature has been chosen by the user. `bboxDot` utilizes the `bbox`-url parameter using the clicked coordinate while `intersects` uses a `Filter` to calculate the intersected features. Layers can have their own `gfiMode` parameter which would override this global mode. To apply this, add the desired value to the parameter in the `mapConfiguration`. Defaults to `'bboxDot'`. |
-| multiSelect | enum["box", "circle"]? | If configured, multiple features can be selected at once by using the modifier key (CTRL on Windows or Command on macOS) and dragging the mouse. Can only be used in Desktop environments. If set to `'box'`, the selection will be done in a box. If set to `'circle'`, the selection will be done in a circle. Similar to `gfi.directSelect`, features can be added and removed by selection / unselecting them. The features need to be distinguishable by their properties for the functionality to properly work. Does not work together with `extendedMasterportalapiMarkers` of `@polar/core`. Is disabled by default. |
-| renderType | ('iconMenu' \| 'independent')? | Only relevant if `window` is set to `true` for at least one layer. Whether the gfi plugin is rendered independently or as part of the IconMenu. Defaults to 'independent'. |
-
-For details on the `displayComponent` attribute, refer to the [Global Plugin Parameters](../../core/README.md#global-plugin-parameters) section of `@polar/core`.
-
-<details>
-<summary>Example configuration</summary>
-
-```ts
-import Component from '.component/vue'
-
-gfi: {
-  mode: 'bboxDot',
-  activeLayerPath: 'plugin/layerChooser/activeMaskIds',
-  afterLoadFunction: afterLoadFunction,
-  layers: {
-    'layerId': {
-      geometry: true,
-      window: true,
-      maxFeatures: 10,
-      geometryName: 'app:geometry',
-      exportProperty: 'Export',
-    },
-  },
-  coordinateSources: [
-    'plugin/pins/transformedCoordinate',
-    'plugin/pins/coordinatesAfterDrag',
-  ],
-  customHighlightStyle: {
-    stroke: {
-      color: '#FFFF00',
-      width: 3,
-    },
-    fill: {
-      color: 'rgb(255, 255, 255, 0.7)',
-    },
-  },
-  gfiContentComponent: Component,
-}
-
-function afterLoadFunction(featuresByLayerId: Record<string, GeoJsonFeature[]>): Record<string, GeoJsonFeature[]> {
-  const filteredFeaturesByLayerId: Record<string, GeoJsonFeature[]> = {};
-
-  for (const layerId in featuresByLayerId) {
-    if (featuresByLayerId.hasOwnProperty(layerId)) {
-      const features = featuresByLayerId[layerId];
-      filteredFeaturesByLayerId[layerId] = features.filter(feature => feature.properties.type === 'desiredType');
-    }
-  }
-
-  return filteredFeaturesByLayerId;
-}
-```
-
-</details>
-
-#### gfi.gfiLayerConfiguration
-
-| fieldName | type | description |
-| - | - | - |
-| exportProperty | string? | Property of the features of a service having an url usable to trigger a download of features as a document. |
-| geometry | boolean? | If true, feature geometry will be highlighted within the map. Defaults to `false`. |
-| geometryName | string? | Name of the geometry property if not the default field. |
-| isSelectable | ((feature: GeoJsonFeature) => boolean)? | A function can be defined to allow filtering features to be either selectable (return `true`) or not. Unselectable features will be filtered out by the GFI plugin and have neither GFI display nor store presence, but may be visible in the map nonetheless, depending on your other configuration. Please also mind that usage in combination with `extendedMasterportalapiMarkers` requires further configuration of that feature for smooth UX; see the respective documentation of `@polar/core`. |
-| properties | Record<propertyName, displayName>/string[]? | In case `window` is `true`, this will be used to determine which contents to show. In case of an array, keys are used to select properties. In case of an object, keys are used to select properties, but will be titles as their respective values. Displays all properties by default. |
-| showTooltip | ((feature: Feature) => [string, string][])? | If given, a tooltip will be shown with the values calculated for the feature. The first string is the HTML tag to render, the second its contents; contants may be locale keys. For more information regarding the strings, see the documentation of the `@polar/lib-tooltip` package. Defaults to `undefined`. Please mind that tooltips will only be shown if a mouse is used or the hovering device could not be detected. Touch and pen interactions do not open tooltips since they will open the GFI window, rendering the gatherable information redundant. |
-| window | boolean? | If true, properties will be shown in the map client. Defaults to `false`. |
-
-Example configuration:
-
-```js
-layers: {
-  'layerId': {
-    geometry: true,
-    window: true,
-    maxFeatures: 10,
-    geometryName: 'app:geometry',
-    exportProperty: 'Export',
-    properties: {
-      status: 'status',
-      type: 'type',
-    },
-    showTooltip: (feature: Feature): [string, string][] => {
-      return [
-        ['div', `Feature ID: ${feature.properties.id}`],
-        ['span', `Coordinates: ${feature.geometry.coordinates.join(', ')}`]
-      ];
-    },
-    isSelectable: (feature: Feature): boolean => Boolean(Math.random() < 0.5)
-  },
-}
-```
-
-Additionally, if using a WMS service, the following properties can be configured as well.
-
-| fieldName | type | description |
-| - | - | - |
-| filterBy | 'clickPosition'? | Some WMS services may return features close to the clicked position. By setting the value `clickPosition`, only features that intersect the clicked position are shown to the user. Defaults to showing all features. |
-| format | 'GML' \| 'GML2' \| 'GML3' \| 'GML32' \| 'text'? | If the `infoFormat` is not set to `'application/geojson'`´, this can be configured to be the known file format of the response. If not given, the format is parsed from the response data. |
-
-Example configuration:
-
-```js
-layers: {
-  'layerId': {
-    geometry: true,
-    window: true,
-    maxFeatures: 10,
-    geometryName: 'app:geometry',
-    filterBy: 'clickPosition',
-    format: 'text',
-  },
-}
-```
-
-#### gfi.customHighlightStyle
-
-| fieldName | type | description |
-| - | - | - |
-| fill | ol/style/Fill? | Object for defining the fill style. See [OpenLayers documentation](https://openlayers.org/en/latest/apidoc/module-ol_style_Fill-Fill.html) for full options. |
-| stroke | ol/style/Stroke? | Object for defining the stroke style. See [OpenLayers documentation](https://openlayers.org/en/latest/apidoc/module-ol_style_Stroke-Stroke.html) for full options. |
-
-Example configuration:
-```js
-customHighlightStyle: {
-  stroke: {
-    color: '#FFFF00',
-    width: 3,
-  },
-  fill: {
-    color: 'rgb(255, 255, 255, 0.7)',
-  },
-},
-```
-
-#### gfi.featureList
-
-| fieldName | type | description |
-| - | - | - |
-| mode | 'visible' \| 'loaded' | Whether to show only features currently visible in the map view's bounding box or to display all loaded features. In the latter case, if you desire to display all features of a layer (seen or not), set its loading strategy to `'all'`. The loading strategy is a value in the OpenLayers vector source configuration; see [ol/loadingStrategy](https://openlayers.org/en/latest/apidoc/module-ol_loadingstrategy.html) for further details. |
-| bindWithCoreHoverSelect | boolean? | If `true`, the hover/select fields in the core's state will be listened to and interacted with. This will result in a bilateral hovering and selecting of features with the core. Defaults to `false`. |
-| pageLength | number? | A number >0 that sets the limit to the feature list's length. If the length is surpassed, additional features can be reached by using the pagination that is generated in such a case. If not defined, the list can be of arbitrary length. |
-| text | (function \| string)[]? | Array of one to three entries that will produce title, subtitle, and an additional subtitle for the list view. If string, the text item will simply be that feature's value for the denoted property. If function, it's assumed to match the function signature `(feature: OpenLayersFeature): string`, and the returned string will be used for the text item. |
-
-Example configuration:
-```js
-featureList: {
-  mode: 'visible',
-  bindWithCoreHoverSelect: true,
-  pageLength: 5,
-  text: ['Nature reserves', (feature) => `${feature.get('str')} ${feature.get('hsnr')}`]
-}
-```
-
-## Store
-
-### Actions
-
-#### setFeatureInformation
-
-This method can be used to set the feature information in the store and trigger all relevant processes so that the information displayed to the user is as if he has selected the features himself.  
-Note that calling this method completely overrides the previously set feature information.
-
-If a layer has a `isSelectable`-function configured, the features are filtered using that function.
-
-```js
-map.$store.dispatch('plugin/gfi/setFeatureInformation', {
-  "anotherLayer": [],
-  "yetAnotherLayer": [],
-  "relevantInformation": [
-    {
-      "type": "Feature",
-      "geometry": {
-        "type": "Point",
-        "coordinates": [
-          565669.6521397199,
-          5930516.358614317
-        ]
-      },
-      "properties": {
-        "propertyOne": "B0",
-        "propertyTwo": "B1"
-      }
-    },
-    {
-      "type": "Feature",
-      "geometry": {
-        "type": "Point",
-        "coordinates": [
-          565594.9377660984,
-          5930524.52634174
-        ]
-      },
-      "properties": {
-        propertyOne: "A0",
-        propertyTwo: "A1"
-      }
-    }
-  ]
-})
-```
-
-The payload object expects a layer id as a key and an array of GeoJSON-Features as its value.
-
-The selected feature information can be reset by calling the method with an empty object.
-
-### State
-
-If a successful query has been sent and a response has been received, the result will be saved in the store and can be subscribed through the path `'plugin/gfi/featureInformation'`. If, however, a query for a layer fails, a `Symbol` containing the error will be saved in the store instead to indicate the error.
-
-The exact value of `featureInformation` may vary wildly depending on the service used, but is always given as json representation here.
-
-```js
-map.subscribe('plugin/gfi/featureInformation', (featureInformation) => {
-  /* Your code here */
-})
-```
diff --git a/vue2/packages/plugins/Gfi/package.json b/vue2/packages/plugins/Gfi/package.json
deleted file mode 100644
index c494dc4a52..0000000000
--- a/vue2/packages/plugins/Gfi/package.json
+++ /dev/null
@@ -1,44 +0,0 @@
-{
-  "name": "@polar/plugin-gfi",
-  "version": "3.0.2",
-  "description": "Gfi plugin for POLAR that adds feature information retrieval. UI elements can be provided by configuration, else it works as a store integration.",
-  "keywords": [
-    "OpenLayers",
-    "ol",
-    "POLAR",
-    "plugin",
-    "gfi",
-    "feature information"
-  ],
-  "license": "EUPL-1.2",
-  "type": "module",
-  "author": "Dataport AöR <polar@dataport.de>",
-  "main": "src/index.ts",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Dataport/polar.git",
-    "directory": "packages/plugins/Gfi"
-  },
-  "files": [
-    "src/**/*",
-    "CHANGELOG.md"
-  ],
-  "peerDependencies": {
-    "@masterportal/masterportalapi": "2.48.0",
-    "@repositoryname/vuex-generators": "^1.1.2",
-    "ol": "^10.4.0",
-    "vue": "^2.6.14",
-    "vuex": "^3.6.2"
-  },
-  "dependencies": {
-    "just-compare": "^2.3.0",
-    "lodash.debounce": "^4.0.8"
-  },
-  "devDependencies": {
-    "@polar/lib-custom-types": "^2.0.0",
-    "@polar/lib-get-cluster": "^3.0.0",
-    "@polar/lib-invisible-style": "^3.0.0",
-    "@polar/lib-test-mount-parameters": "^1.3.2",
-    "@polar/lib-tooltip": "^1.0.0"
-  }
-}
diff --git a/vue2/packages/plugins/Gfi/src/index.ts b/vue2/packages/plugins/Gfi/src/index.ts
deleted file mode 100644
index 7ed287870b..0000000000
--- a/vue2/packages/plugins/Gfi/src/index.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import Vue from 'vue'
-import { GfiConfiguration } from '@polar/lib-custom-types'
-import { Gfi } from './components'
-import locales from './locales'
-import { makeStoreModule } from './store'
-
-export default (options: GfiConfiguration) => (instance: Vue) =>
-  instance.$store.dispatch('addComponent', {
-    name: 'gfi',
-    plugin: Gfi,
-    locales,
-    storeModule: makeStoreModule(),
-    options,
-  })
diff --git a/vue2/packages/plugins/Gfi/src/locales.ts b/vue2/packages/plugins/Gfi/src/locales.ts
deleted file mode 100644
index b083d9c770..0000000000
--- a/vue2/packages/plugins/Gfi/src/locales.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-import { Locale } from '@polar/lib-custom-types'
-
-export const resourcesDe = {
-  plugins: {
-    gfi: {
-      header: {
-        close: 'Informationsfenster schließen',
-        field: 'Feld',
-        value: 'Wert',
-      },
-      property: {
-        export: 'Export als PDF',
-        imageAlt:
-          'Bitte entnehmen Sie Informationen zum Inhalt des Bildes aus den umliegenden Tabellenfeldern',
-        linkTitle: 'In neuem Tab öffnen',
-      },
-      switch: {
-        previous: 'Vorangehender Datensatz',
-        next: 'Nächster Datensatz',
-      },
-      noActiveLayer:
-        'Derzeit ist kein Kartenmaterial mit passenden Objekten eingeschaltet.',
-      list: {
-        header: 'Objektliste',
-        entry: 'Eintrag',
-        to: 'bis',
-        of: 'von',
-        emptyView:
-          'Im aktuellen Kartenausschnitt sind keine Objekte enthalten.',
-        pagination: {
-          currentPage: 'Aktuelle Seite, Seite {{page}}',
-          page: 'Seite {{page}}',
-          next: 'Nächste Seite',
-          previous: 'Vorherige Seite',
-          wrapper: 'Seitenauswahl',
-        },
-      },
-    },
-  },
-} as const
-
-export const resourcesEn = {
-  plugins: {
-    gfi: {
-      header: {
-        close: 'Close information window',
-        field: 'Field',
-        value: 'Value',
-      },
-      property: {
-        export: 'Export as a PDF document',
-        imageAlt:
-          'Please refer to the other table fields for further information about the topics of the displayed picture',
-        link: 'Open in a new tab',
-      },
-      switch: {
-        previous: 'Previous data',
-        next: 'Next data',
-      },
-      noActiveLayer: 'Currently, no map layer with fitting objects is active.',
-      list: {
-        header: 'Feature list',
-        entry: 'Entry',
-        to: 'to',
-        of: 'of',
-        emptyView: 'There are no features in the current view.',
-        pagination: {
-          currentPage: 'Current page, page {{page}}',
-          page: 'Page {{page}}',
-          next: 'Next page',
-          previous: 'Previous page',
-          wrapper: 'Pagination',
-        },
-      },
-    },
-  },
-} as const
-
-const locales: Locale[] = [
-  {
-    type: 'de',
-    resources: resourcesDe,
-  },
-  {
-    type: 'en',
-    resources: resourcesEn,
-  },
-]
-
-export default locales
diff --git a/vue2/packages/plugins/Gfi/src/store/index.ts b/vue2/packages/plugins/Gfi/src/store/index.ts
deleted file mode 100644
index dc8a4ed3ee..0000000000
--- a/vue2/packages/plugins/Gfi/src/store/index.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { PolarModule } from '@polar/lib-custom-types'
-import { GfiGetters, GfiState } from '../types'
-
-import getInitialState from './getInitialState'
-import { makeActions } from './actions'
-import mutations from './mutations'
-import getters from './getters'
-
-export const makeStoreModule = () => {
-  const storeModule: PolarModule<GfiState, GfiGetters> = {
-    namespaced: true,
-    state: getInitialState(),
-    actions: makeActions(),
-    mutations,
-    getters,
-  }
-
-  return storeModule
-}
diff --git a/vue2/packages/plugins/Gfi/src/store/mutations.ts b/vue2/packages/plugins/Gfi/src/store/mutations.ts
deleted file mode 100644
index 50d0333c91..0000000000
--- a/vue2/packages/plugins/Gfi/src/store/mutations.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { generateSimpleMutations } from '@repositoryname/vuex-generators'
-import getInitialState from './getInitialState'
-
-const mutations = {
-  ...generateSimpleMutations(getInitialState()),
-  clearFeatureInformation(state) {
-    state.featureInformation = {}
-  },
-}
-
-export default mutations
diff --git a/vue2/packages/plugins/Gfi/src/types.ts b/vue2/packages/plugins/Gfi/src/types.ts
deleted file mode 100644
index 3e4a24c842..0000000000
--- a/vue2/packages/plugins/Gfi/src/types.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-import { Map, Feature } from 'ol'
-import BaseLayer from 'ol/layer/Base'
-import ImageLayer from 'ol/layer/Image'
-import TileLayer from 'ol/layer/Tile'
-import { ImageWMS, TileWMS } from 'ol/source'
-import VectorSource from 'ol/source/Vector'
-import { Feature as GeoJsonFeature, GeoJsonProperties } from 'geojson'
-import {
-  HighlightStyle,
-  GfiAfterLoadFunction,
-  GfiConfiguration,
-  GfiLayerConfiguration,
-  RenderType,
-  FeatureList,
-} from '@polar/lib-custom-types'
-import { VueConstructor } from 'vue'
-
-/** parameter specification for request method */
-export interface RequestGfiParameters {
-  map: Map
-  layer: BaseLayer
-  coordinateOrExtent: [number, number] | [number, number, number, number]
-  layerConfiguration: GfiLayerConfiguration
-  /** rawLayerList entry, see https://bitbucket.org/geowerkstatt-hamburg/masterportal/src/dev/doc/services.json.md */
-  layerSpecification: Record<string, unknown>
-  /** defaults to bboxDot (get from minimal coordinate bbox) */
-  mode?: 'bboxDot' | 'intersects'
-}
-
-export interface RequestGfiWmsParameters {
-  map: RequestGfiParameters['map']
-  coordinate: [number, number]
-  layerConfiguration: RequestGfiParameters['layerConfiguration']
-  layerSpecification: RequestGfiParameters['layerSpecification']
-  layer: TileLayer<TileWMS> | ImageLayer<ImageWMS>
-}
-
-export type FeaturesByLayerId = Record<string, GeoJsonFeature[] | symbol>
-
-/** GFI Vuex Module State */
-export interface GfiState {
-  /** default style for stroke and fill of the highlighted feature. */
-  defaultHighlightStyle: HighlightStyle
-  /** mapping of layer id to features found for last GFI call */
-  featureInformation: Record<string, GeoJsonFeature[]>
-  imageLoaded: boolean
-  page: number
-  /** currently visible feature index regarding  */
-  visibleWindowFeatureIndex: number
-  /** count up if something in relevant features changed */
-  visibilityChangeIndicator: number
-}
-
-export interface GfiGetters extends GfiState {
-  afterLoadFunction: GfiAfterLoadFunction | null
-  currentProperties: GeoJsonProperties
-  exportProperty: string
-  exportPropertyLayerKeys: Record<string, string>
-  /** subset of layerKeys, where features' geometries are to be shown on map */
-  geometryLayerKeys: string[]
-  /** module configuration */
-  gfiConfiguration: GfiConfiguration
-  gfiContentComponent: VueConstructor | null
-  isFeatureHovered: (feature: Feature) => boolean
-  /** all layer keys to retrieve GFI information for */
-  layerKeys: string[]
-  listableLayerSources: VectorSource[]
-  listFeatures: Feature[]
-  listMode: FeatureList['mode'] | undefined
-  listText: FeatureList['text']
-  renderMoveHandle: boolean
-  renderType: RenderType
-  showList: boolean
-  showSwitchButtons: boolean
-  /** subset of layerKeys, where features' properties are to be shown in UI */
-  windowLayerKeys: string[]
-  /**
-   * features' properties from featureInformation where windowLayerKeys
-   * includes the key of the layer
-   */
-  windowFeatures: GeoJsonProperties[]
-  windowLayerKeysActive: boolean
-}
diff --git a/vue2/packages/plugins/Gfi/src/utils/displayFeatureLayer.ts b/vue2/packages/plugins/Gfi/src/utils/displayFeatureLayer.ts
deleted file mode 100644
index 88b75608bd..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/displayFeatureLayer.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { Feature } from 'ol'
-import VectorLayer from 'ol/layer/Vector'
-import { Vector } from 'ol/source'
-import { GeoJSON } from 'ol/format'
-import { Feature as GeoJsonFeature } from 'geojson'
-
-export function getFeatureDisplayLayer() {
-  const featureDisplayLayer = new VectorLayer({
-    source: new Vector<Feature>({
-      features: [],
-    }),
-  })
-
-  featureDisplayLayer.set('polarInternalId', 'pluginGfiFeatureDisplay')
-  featureDisplayLayer.setZIndex(90)
-  // NOTE: This may be changed in the future to not use the default styling of @masterportal/masterportalapi
-  featureDisplayLayer.set('styleId', 'defaultHighlightFeaturesPoint')
-
-  return featureDisplayLayer
-}
-
-function isVectorSource(source): source is Vector {
-  return source instanceof Vector
-}
-
-/**
- * reset feature layer's features.
- */
-export function clear(featureDisplayLayer: VectorLayer): void {
-  const source = featureDisplayLayer.getSource()
-  if (isVectorSource(source)) {
-    source.clear()
-  }
-}
-
-/**
- * add feature from jsonable GeoJson object.
- */
-export function addFeature(
-  feature: GeoJsonFeature,
-  featureDisplayLayer: VectorLayer
-): void {
-  const source = featureDisplayLayer.getSource()
-  if (isVectorSource(source)) {
-    // Since ol@10, readFeature may also return a Feature[]?
-    source.addFeature(new GeoJSON().readFeature(feature) as Feature)
-  }
-}
diff --git a/vue2/packages/plugins/Gfi/src/utils/isValidHttpUrl.js b/vue2/packages/plugins/Gfi/src/utils/isValidHttpUrl.js
deleted file mode 100644
index 7632b7dc2d..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/isValidHttpUrl.js
+++ /dev/null
@@ -1,11 +0,0 @@
-export default function isValidHttpUrl(string) {
-  let url
-
-  try {
-    url = new URL(string)
-  } catch (_) {
-    return false
-  }
-
-  return url.protocol === 'http:' || url.protocol === 'https:'
-}
diff --git a/vue2/packages/plugins/Gfi/src/utils/requestGfi.ts b/vue2/packages/plugins/Gfi/src/utils/requestGfi.ts
deleted file mode 100644
index 308b392be3..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/requestGfi.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import { Feature as GeoJsonFeature } from 'geojson'
-import ImageLayer from 'ol/layer/Image'
-import TileLayer from 'ol/layer/Tile'
-import VectorLayer from 'ol/layer/Vector'
-import { rawLayerList } from '@masterportal/masterportalapi'
-import { RequestGfiParameters } from '../types'
-
-import requestGfiWms from './requestGfiWms'
-import requestGfiWfs from './requestGfiWfs'
-import requestGfiGeoJson from './requestGfiGeoJson'
-
-/**
- * The requestGfi method abstracts from service-specific implementation and
- * retrieves feature information. Not all formats are supported yet.
- *
- * Namely, services returning any GML variant, or fitting text responses by
- * default, should work. All others are not yet implemented.
- * @param parameters - parameter object
- * @returns found features for GFI request
- */
-export function requestGfi({
-  map,
-  layer,
-  coordinateOrExtent,
-  layerConfiguration,
-  layerSpecification,
-  mode,
-}: RequestGfiParameters): Promise<GeoJsonFeature[]> {
-  const layerId = layer.get('id')
-  try {
-    const params = {
-      map,
-      layerConfiguration,
-      layerSpecification,
-    }
-    if (layer instanceof TileLayer || layer instanceof ImageLayer) {
-      return coordinateOrExtent.length === 2
-        ? requestGfiWms({
-            ...params,
-            coordinate: coordinateOrExtent,
-            layer,
-          })
-        : Promise.reject(
-            new Error(
-              `An extent can not be used for ${layerId} as it is a WMS layer which only support coordinates for gfi requests.`
-            )
-          )
-    }
-    if (
-      rawLayerList.getLayerWhere({ id: layerId })?.typ === 'GeoJSON' &&
-      // NOTE: This is the case by design of @masterportal/masterportalapi but is added here for type safety
-      layer instanceof VectorLayer
-    ) {
-      return requestGfiGeoJson({ ...params, coordinateOrExtent, layer })
-    }
-    if (layer instanceof VectorLayer) {
-      return requestGfiWfs({ ...params, coordinateOrExtent, mode })
-    }
-    const notImplemented = `Layer ${layerId} was neither a Tile- nor a VectorLayer. GFI not implemented.`
-    return Promise.reject(new Error(notImplemented))
-  } catch (e) {
-    const error = `An error occurred while requesting features from layer with the id ${layerId}.`
-    return Promise.reject(new Error(error))
-  }
-}
diff --git a/vue2/packages/plugins/Gfi/src/utils/requestGfiGeoJson.ts b/vue2/packages/plugins/Gfi/src/utils/requestGfiGeoJson.ts
deleted file mode 100644
index 9088c7b2be..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/requestGfiGeoJson.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { Feature as GeoJsonFeature } from 'geojson'
-import { Feature, Map } from 'ol'
-import { GeoJSON } from 'ol/format'
-import VectorLayer from 'ol/layer/Vector'
-import { FeatureLike } from 'ol/Feature'
-
-const writer = new GeoJSON()
-
-const getNestedFeatures = (
-  feature: Feature | FeatureLike
-): Feature | Feature[] | FeatureLike =>
-  feature instanceof Feature
-    ? feature.get('features')?.length
-      ? feature.get('features')
-      : feature
-    : feature
-
-/**
- * Returns features from GeoJSON layer as GeoJSON.
- */
-export default ({
-  map,
-  coordinateOrExtent,
-  layer,
-}: {
-  map: Map
-  coordinateOrExtent: [number, number] | [number, number, number, number]
-  layer: VectorLayer
-}): Promise<GeoJsonFeature[]> =>
-  Promise.resolve(
-    (coordinateOrExtent.length === 2
-      ? map.getFeaturesAtPixel(map.getPixelFromCoordinate(coordinateOrExtent), {
-          layerFilter: (candidate) => candidate === layer,
-        })
-      : // @ts-expect-error | Layers reaching this place have a source
-        layer
-          .getSource()
-          .getFeaturesInExtent(coordinateOrExtent)
-          .map(getNestedFeatures)
-          .flat(1)
-    )
-      .map((feature) =>
-        feature instanceof Feature
-          ? JSON.parse(writer.writeFeature(feature))
-          : false
-      )
-      // remove FeatureLikes
-      .filter((x) => x)
-  )
diff --git a/vue2/packages/plugins/Gfi/src/utils/requestGfiWfs.ts b/vue2/packages/plugins/Gfi/src/utils/requestGfiWfs.ts
deleted file mode 100644
index fec250ca5f..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/requestGfiWfs.ts
+++ /dev/null
@@ -1,112 +0,0 @@
-import { GeoJSON, WFS } from 'ol/format'
-import { Feature as GeoJsonFeature } from 'geojson'
-import { RequestGfiParameters } from '../types'
-
-/**
- * Parses WFS reply to jsonable objects.
- * NOTE This method may break on unexpected formats and require further
- * detection. For now, all WFS seem to "behave".
- * @param xmlString - Features as returned by WFS service
- * @param wfsVersion - Version of WFS service
- * @returns features as flat GeoJSON (NOT ol/GeoJSON)
- */
-const xml2GeoJson = (
-  xmlString: string,
-  wfsVersion: string
-): GeoJsonFeature[] => {
-  const parser = new WFS({ version: wfsVersion })
-  const writer = new GeoJSON()
-  const features = parser.readFeatures(xmlString)
-  const geoJsonFeatures = features.map((f) =>
-    JSON.parse(writer.writeFeature(f))
-  )
-
-  return geoJsonFeatures
-}
-
-/**
- * Executes gfi request on wfs layer and returns result as GeoJSON.
- * NOTE Optimization idea: For layers where features are regularly loaded,
- * no new request should be started. Instead, wait for any running load to
- * finish and use feature at layer source coordinate. (Not trivial.)
- */
-export default ({
-  map,
-  coordinateOrExtent,
-  layerConfiguration,
-  layerSpecification,
-  mode,
-}: Pick<
-  RequestGfiParameters,
-  | 'map'
-  | 'coordinateOrExtent'
-  | 'layerConfiguration'
-  | 'layerSpecification'
-  | 'mode'
->): Promise<GeoJsonFeature[]> => {
-  if (coordinateOrExtent.length === 4 && mode !== 'bboxDot') {
-    return Promise.reject(
-      new Error(
-        `Configuration error in requestGfiWfs.ts: mode must be "bboxDot" to be able to use an extent for gfi requests, but was "${mode}".`
-      )
-    )
-  }
-  const { featureType, url, version } = layerSpecification
-  const { geometryName } = layerConfiguration
-  const code = map.getView().getProjection().getCode()
-  const typeName = version === '2.0.0' ? 'typeNames' : 'typename'
-  let featureUrl = `${url}?service=WFS&version=${version}&request=GetFeature&${typeName}=${featureType}&srsName=${code}`
-
-  if (mode === 'bboxDot') {
-    const extent =
-      coordinateOrExtent.length === 2
-        ? /* The extended extent is necessary because an extent with the same
-           * coordinates could lead to an empty featureCollection. */
-          [
-            coordinateOrExtent[0] - 0.1,
-            coordinateOrExtent[1] - 0.1,
-            coordinateOrExtent[0] + 0.1,
-            coordinateOrExtent[1] + 0.1,
-          ]
-        : coordinateOrExtent
-
-    featureUrl += `&bbox=${extent},${code}`
-  } else if (mode === 'intersects') {
-    const point =
-      `<gml:Point srsName="${code}">` +
-      `<gml:coordinates>${coordinateOrExtent[0]},${coordinateOrExtent[1]}</gml:coordinates>` +
-      '</gml:Point>'
-    featureUrl +=
-      '&FILTER=' +
-      // NOTE: fes as a namespace and ValueReference for a property has been introduced in 2.0.0
-      (version === '2.0.0'
-        ? '<fes:Filter>' +
-          '<fes:Intersects>' +
-          `<fes:ValueReference>${geometryName}</fes:ValueReference>` +
-          point +
-          '</fes:Intersects>' +
-          '</fes:Filter>'
-        : '<ogc:Filter xmlns:ogc="http://www.opengis.net/ogc">' +
-          '<ogc:Intersects>' +
-          `<ogc:PropertyName>${geometryName}</ogc:PropertyName>` +
-          point +
-          '</fes:Intersects>' +
-          '</fes:Filter>')
-  } else {
-    return Promise.reject(
-      new Error(
-        `Type error in requestGfiWfs.ts: mode must be "intersects" or "bboxDot", but was "${mode}".`
-      )
-    )
-  }
-
-  return (
-    fetch(featureUrl, { method: 'GET' })
-      .then((response) => response.text())
-      // TODO: Type of layerSpecification needs an update to better reflect the possibilities of the services
-      //  and get rid of this @ts-ignore
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      .then((xmlText) => xml2GeoJson(xmlText, version))
-  )
-}
diff --git a/vue2/packages/plugins/Gfi/src/utils/requestGfiWms.ts b/vue2/packages/plugins/Gfi/src/utils/requestGfiWms.ts
deleted file mode 100644
index addad5ff85..0000000000
--- a/vue2/packages/plugins/Gfi/src/utils/requestGfiWms.ts
+++ /dev/null
@@ -1,204 +0,0 @@
-import WFS from 'ol/format/WFS'
-import GML32 from 'ol/format/GML32'
-import GML3 from 'ol/format/GML3'
-import GML2 from 'ol/format/GML2'
-import GML from 'ol/format/GML'
-import { GeoJSON } from 'ol/format'
-import { Feature } from 'ol'
-import { Feature as GeoJsonFeature } from 'geojson'
-import Geometry from 'ol/geom/Geometry'
-import { TileWMS } from 'ol/source'
-import { RequestGfiWmsParameters } from '../types'
-
-// list of supported reply formats that can be used from OL
-const formats = {
-  GML,
-  GML2,
-  GML3,
-  GML32,
-}
-
-/**
- * This is a custom text response reader working on an unspecified format that
- * commonly occurs in WMS GFI replies. It can be used by specifying "text" as
- * "format" on a GFI specification. Please mind that it's written from
- * experience, not from a clear definition, and may need attention whenever
- * new cases arise.
- * @param text - Custom text response, hopefully in the implemented format
- * @returns array of OpenLayers features
- */
-function readTextFeatures(text: string): Feature<Geometry>[] {
-  const lines = text.split('\n')
-  const features: Feature<Geometry>[] = []
-  let feature: Feature<Geometry> | undefined
-  /* TODO: Format supposedly looks like this – is this a standard or arbitrary?
-      GetFeatureInfo results:
-        LayerName:
-          FeatureId:
-            Horse: Yes
-            Speed: Fast
-            Horsepower: 4
-  */
-
-  for (const line of lines) {
-    if (
-      line === '' ||
-      line.startsWith('GetFeatureInfo results') ||
-      line.startsWith('Layer')
-    ) {
-      continue
-    }
-    if (line.startsWith('    ')) {
-      if (typeof feature !== 'undefined') {
-        const equalIndex = line.indexOf('=')
-        const [key, value] = [
-          line.substring(0, equalIndex),
-          line.substring(equalIndex + 3, line.length - 1),
-        ].map((s) => s.trim())
-        feature.set(key, value)
-      } else {
-        console.error(
-          '@polar/plugin-gfi: Found property before feature declaration in readTextFeatures.',
-          line,
-          'Skipping ...'
-        )
-      }
-      continue
-    }
-    if (line.startsWith('  ')) {
-      if (line.includes('Search returned no results')) {
-        break
-      }
-      const id = line.substring(0, line.length - 2).trim()
-      feature = new Feature()
-      feature.setId(id)
-      features.push(feature)
-    }
-  }
-  return features
-}
-
-/**
- * In case the layer configuration does not specify a parser, we're trying to
- * detect the returned XML format by searching for a GML namespace. Any return
- * format outside GML will currently not work with this automated parsing.
- * @param data - data as parsed from response body
- * @returns WFS capable of parsing data
- */
-function getParserFromData(data: string): WFS {
-  // NOTE: Tested for GML32 and GML, may break on GML2/GML3
-  const GMLFormat = data.includes('xmlns:gml="http://www.opengis.net/gml/3.2"')
-    ? GML32
-    : data.includes('xmlns:gml="http://www.opengis.net/gml"')
-    ? GML
-    : data.includes('xmlns:gml="http://www.opengis.net/gml/2')
-    ? GML2
-    : GML3
-
-  return new WFS({
-    gmlFormat: new GMLFormat(),
-  })
-}
-
-/**
- * A layer may have its parser specified in the configuration. In this case,
- * the specified parser is retrieved from a list of supported GML parsers, or a
- * custom text parser is used in case it fits.
- * @param format - format as specified by mapConfiguration
- * @returns object that supplies 'readTextFeatures' method
- */
-function getParserFromFormat(format: string): Pick<WFS, 'readFeatures'> {
-  if (formats[format]) {
-    return new WFS({
-      gmlFormat: new formats[format](),
-    })
-  }
-
-  if (format === 'text') {
-    return {
-      readFeatures: readTextFeatures,
-    }
-  }
-
-  throw new Error(`Format '${format}' not yet implemented in requestGfiWms.ts.`)
-}
-
-/**
- * @param parameters - map, layer, and coordinate to use for GFI request
- * @returns url to request for feature information
- */
-function getWmsGfiUrl(
-  { map, layer, coordinate }: RequestGfiWmsParameters,
-  { infoFormat }: Record<string, unknown>
-): string {
-  // Only layers with a valid source reach this point
-  const source = layer.getSource() as TileWMS
-  const view = map.getView()
-  const url = source.getFeatureInfoUrl(
-    coordinate,
-    // The view always has a resolution if this function is called
-    view.getResolution() as number,
-    view.getProjection(),
-    {
-      feature_count: 10,
-    }
-  )
-  const suffix = infoFormat ? `&info_format=${infoFormat}` : ''
-  return url + suffix
-}
-
-/**
- * Method fetches WMS feature information. Result will be filtered and modified
- * according to layerConfiguration.
- * @param parameters - parameter object
- * @returns promise of all features that hold relevant feature information
- */
-export default (
-  parameters: RequestGfiWmsParameters
-): Promise<GeoJsonFeature[]> => {
-  const { coordinate, layerConfiguration, layerSpecification } = parameters
-  const { filterBy, geometryName, format } = layerConfiguration
-
-  const url = getWmsGfiUrl(parameters, layerSpecification)
-
-  return fetch(url)
-    .then((response) => response.text())
-    .then((data) => {
-      /* NOTE: test block for WMS GFI
-      import WMSGetFeatureInfo from 'ol/format/WMSGetFeatureInfo'
-      try {
-        console.error('WMS GFI', url)
-        console.error(new WMSGetFeatureInfo().readFeatures(data))
-      } catch (e) {
-        console.error(e)
-      }
-      */
-
-      const parser =
-        layerSpecification.infoFormat === 'application/geojson'
-          ? new GeoJSON()
-          : format
-          ? getParserFromFormat(format)
-          : getParserFromData(data)
-
-      const parsedFeatures: Feature<Geometry>[] = parser.readFeatures(data)
-      const writer = new GeoJSON()
-
-      if (geometryName) {
-        parsedFeatures.forEach((f) => f.setGeometryName('geometry'))
-      }
-
-      const jsonFeatures = parsedFeatures
-        // WMS may return features nearby - filter to hit features
-        .filter((feature) =>
-          filterBy === 'clickPosition'
-            ? feature.getGeometry()?.intersectsCoordinate(coordinate)
-            : true
-        )
-        // transform to jsonable object representation
-        .map((f) => JSON.parse(writer.writeFeature(f)))
-
-      return jsonFeatures
-    })
-    .catch((e) => Promise.reject(e))
-}
diff --git a/vue2/packages/plugins/Gfi/vite.config.js b/vue2/packages/plugins/Gfi/vite.config.js
deleted file mode 100644
index 0d2ec38a15..0000000000
--- a/vue2/packages/plugins/Gfi/vite.config.js
+++ /dev/null
@@ -1,3 +0,0 @@
-import { getCodeConfig } from '../../../viteConfigs'
-
-export default getCodeConfig()
diff --git a/vue2/packages/types/custom/core.ts b/vue2/packages/types/custom/core.ts
index 921187fcb1..2eedb5530e 100644
--- a/vue2/packages/types/custom/core.ts
+++ b/vue2/packages/types/custom/core.ts
@@ -252,49 +252,6 @@ export interface FilterConfiguration extends PluginOptions {
 	>
 }
 
-/** Configuration of GFI feature regarding a specific layer */
-export interface GfiLayerConfiguration {
-	/**
-	 * Property of the features of a service having an url usable to trigger a
-	 * download of features as a document.
-	 */
-	exportProperty?: string
-	// filter method to apply on response features, only relevant for WMS services
-	filterBy?: 'clickPosition'
-	// format the response is known to come in (e.g. "GML"); only relevant for WMS services
-	format?: 'GML' | 'GML2' | 'GML3' | 'GML32' | 'text'
-	/**
-	 * Whether the found features' geometry, if available, is to be shown on the
-	 * map. It is simply printed to a helper layer.
-	 */
-	geometry?: boolean
-	// name of field to use for geometry, if not default field
-	geometryName?: string
-	isSelectable?: GfiIsSelectableFunction
-	maxFeatures?: number
-	/**
-	 * If window is true, the properties are either
-	 * 1. filtered by whether their key is in a string[]
-	 * 2. filtered by whether their key is in the given object's keys, and then
-	 *    translated to the object's value for that key
-	 * I.e., a feature \{ a: 0, b: 0, c: 0 \} with ['a', 'b'] will show key-value
-	 * pairs 'a':0 and 'b':0, and the same feature with object \{a: 'A'\} will
-	 * show key-value pair 'A':0, mind the uppercase A, which is the mapped key.
-	 *
-	 * This does not influence what information is available in the store,
-	 * only the UI is affected by these filters/mappings.
-	 */
-	properties?: string[] | Record<string, string>
-	showTooltip?: (feature: Feature, map: Map) => [string, string][]
-	/**
-	 * Whether the found features' properties are to be shown in the client's UI.
-	 * They are displayed as a table, one feature at a time, and if multiple
-	 * features are found, the user may step through all where the layer's window
-	 * value is true.
-	 */
-	window?: boolean
-}
-
 export interface GeoLocationConfiguration extends LayerBoundPluginOptions {
 	/**
 	 * Source paths through store to listen to for changes; it is assumed values
@@ -325,62 +282,6 @@ export interface FullscreenConfiguration extends PluginOptions {
 	targetContainerId?: string
 }
 
-export type GfiIsSelectableFunction = (feature: GeoJsonFeature) => boolean
-
-/** configurable function to gather additional info */
-export type GfiAfterLoadFunction = (
-	featureInformation: Record<string, GeoJsonFeature[]>,
-	srsName: string // TODO: Might be interesting to overlap this with mapConfig.namedProjections for type safety in using only allowed epsg codes
-) =>
-	| Record<string, GeoJsonFeature[] | symbol>
-	| Promise<Record<string, GeoJsonFeature[] | symbol>>
-
-/** GFI Module Configuration */
-export interface FeatureList {
-	mode: 'visible' | 'loaded'
-	bindWithCoreHoverSelect?: boolean
-	pageLength?: number
-	text?: (string | ((f: Feature) => string))[]
-}
-
-export interface GfiConfiguration extends PluginOptions {
-	/**
-	 * Source paths through store to listen to for changes; it is assumed values
-	 * listened to are coordinates that can be used to request information from
-	 * the specified layers.
-	 */
-	coordinateSources: string[]
-	/**
-	 * The layers to request feature information from. Both WMS and WFS layers are
-	 * supported. Keys are layer IDs as specified in the services.json registry.
-	 */
-	layers: Record<string, GfiLayerConfiguration>
-	activeLayerPath?: string
-	afterLoadFunction?: GfiAfterLoadFunction
-	boxSelect?: boolean
-	/**
-	 * If required the stroke and fill of the highlighted feature can be configured.
-	 * Otherwise, a default style is applied.
-	 */
-	customHighlightStyle?: HighlightStyle
-	directSelect?: boolean
-	featureList?: FeatureList
-	/**
-	 * Optionally replace GfiContent component.
-	 * Usable to completely redesign content of GFI window.
-	 */
-	gfiContentComponent?: VueConstructor
-	/**
-	 * Limits the viewable GFIs per layer by this number. The first n elements
-	 * are chosen arbitrarily. Useful if you e.g. just want one result, or to
-	 * limit an endless stream of returns to maybe 10 or so. Infinite by default.
-	 */
-	maxFeatures?: number
-	mode?: 'bboxDot' | 'intersects'
-	multiSelect?: 'box' | 'circle'
-	renderType?: RenderType
-}
-
 export interface LayerChooserConfiguration extends PluginOptions {
 	component?: VueConstructor
 }
@@ -503,7 +404,6 @@ export interface MapConfig extends MasterportalApiConfig {
 	filter?: FilterConfiguration
 	fullscreen?: FullscreenConfiguration
 	geoLocation?: GeoLocationConfiguration
-	gfi?: GfiConfiguration
 	layerChooser?: LayerChooserConfiguration
 	legend?: LegendConfiguration
 	pins?: PinsConfiguration
@@ -529,12 +429,12 @@ export interface CoreState {
 	components: number
 	// NOTE: The additional values are not required in the configuration but have default values.
 	configuration: MapConfig &
-		Required<
-			Pick<
-				MasterportalApiConfig,
-				'epsg' | 'namedProjections' | 'options' | 'startResolution'
-			>
+	Required<
+		Pick<
+			MasterportalApiConfig,
+			'epsg' | 'namedProjections' | 'options' | 'startResolution'
 		>
+	>
 	hasSmallDisplay: boolean
 	hovered: number
 	language: string

From 8757e3b7a22265ef744f3c091e8f3980afc8f120 Mon Sep 17 00:00:00 2001
From: Hendrik Oenings <hendrik.oenings@dataport.de>
Date: Tue, 17 Feb 2026 13:34:47 +0100
Subject: [PATCH 07/12] refactor(core): make `renderType` a global plugin
 option

---
 src/core/types/plugin.ts         | 21 +++++++++++++++++++++
 src/plugins/fullscreen/types.ts  |  9 ---------
 src/plugins/geoLocation/types.ts | 10 ----------
 src/plugins/gfi/types.ts         |  8 --------
 src/plugins/iconMenu/store.ts    |  9 ++++++++-
 5 files changed, 29 insertions(+), 28 deletions(-)

diff --git a/src/core/types/plugin.ts b/src/core/types/plugin.ts
index da7cdc85bd..f199069d0b 100644
--- a/src/core/types/plugin.ts
+++ b/src/core/types/plugin.ts
@@ -33,9 +33,30 @@ import type { useToastStore as ToastStore } from '@/plugins/toast/store'
 import type { NineLayoutTag } from '../utils/NineLayoutTag'
 import type { Locale } from './locales'
 
+/**
+ * Generic options for all plugins
+ */
 export interface PluginOptions {
+	/**
+	 * Should the component be visible at all.
+	 *
+	 * @defaultValue `false`
+	 */
 	displayComponent?: boolean
+
+	/**
+	 * The region where the plugin should be rendered.
+	 * Required for nine-regions layout, ignored otherwise.
+	 */
 	layoutTag?: keyof typeof NineLayoutTag
+
+	/**
+	 * Defines if the plugin is rendered independent or as part of the icon menu.
+	 * This is automatically set by the icon menu; you should not need to touch this.
+	 *
+	 * @defaultValue `'independent'`
+	 */
+	renderType?: 'independent' | 'iconMenu'
 }
 
 export interface BoundaryOptions {
diff --git a/src/plugins/fullscreen/types.ts b/src/plugins/fullscreen/types.ts
index aa1e5c3864..1e12f43c35 100644
--- a/src/plugins/fullscreen/types.ts
+++ b/src/plugins/fullscreen/types.ts
@@ -9,15 +9,6 @@ export const PluginId = 'fullscreen'
  * Plugin options for fullscreen plugin.
  */
 export interface FullscreenPluginOptions extends PluginOptions {
-	/**
-	 * Defines if the fullscreen button is rendered independent or as part of the icon menu.
-	 *
-	 * This is only applicable if the layout is `'nineRegions'`.
-	 *
-	 * @defaultValue `'independent'`
-	 */
-	renderType?: 'independent' | 'iconMenu'
-
 	/**
 	 * Defines the target container to show in fullscreen mode.
 	 * This defaults to the web component (i.e., the map with its plugin controls).
diff --git a/src/plugins/geoLocation/types.ts b/src/plugins/geoLocation/types.ts
index 3e99ddd847..6e96297d32 100644
--- a/src/plugins/geoLocation/types.ts
+++ b/src/plugins/geoLocation/types.ts
@@ -32,16 +32,6 @@ export interface GeoLocationPluginOptions extends LayerBoundPluginOptions {
 	 */
 	keepCentered?: boolean
 
-	/**
-	 * Defines if the geoLocation button is rendered independent or as part of the
-	 * icon menu.
-	 *
-	 * This is only applicable if the layout is `'nineRegions'`.
-	 *
-	 * @defaultValue `'independent'`
-	 */
-	renderType?: 'independent' | 'iconMenu'
-
 	/**
 	 * If set to `true`, a tooltip will be shown when hovering the geoposition
 	 * marker on the map, indicating that it shows the user's position.
diff --git a/src/plugins/gfi/types.ts b/src/plugins/gfi/types.ts
index 95b621d7ca..22bd13c344 100644
--- a/src/plugins/gfi/types.ts
+++ b/src/plugins/gfi/types.ts
@@ -325,14 +325,6 @@ export interface GfiPluginOptions extends PluginOptions {
 	 * @defaultValue Disabled by default
 	 */
 	multiSelect?: 'box' | 'circle'
-
-	/**
-	 * Only relevant if `window` is set to `true` for at least one layer.
-	 * Whether the gfi plugin is rendered independently or as part of the IconMenu.
-	 *
-	 * @defaultValue `'independent'`
-	 */
-	renderType?: 'independent' | 'iconMenu'
 }
 
 /** parameter specification for request method */
diff --git a/src/plugins/iconMenu/store.ts b/src/plugins/iconMenu/store.ts
index 9ac20bbd1d..e6aa0d43b7 100644
--- a/src/plugins/iconMenu/store.ts
+++ b/src/plugins/iconMenu/store.ts
@@ -53,7 +53,14 @@ export const useIconMenuStore = defineStore('plugins/iconMenu', () => {
 			.concat(focusMenus.value)
 			.flat()
 			.forEach(({ plugin }) => {
-				coreStore.addPlugin(toMerged(plugin, { independent: false }))
+				coreStore.addPlugin(
+					toMerged(plugin, {
+						independent: false,
+						options: {
+							renderType: 'iconMenu',
+						},
+					})
+				)
 			})
 
 		// Otherwise, the component itself is made reactive

From 425cfdb709d7ae4212bb1baccef34834e9708565 Mon Sep 17 00:00:00 2001
From: Hendrik Oenings <hendrik.oenings@dataport.de>
Date: Tue, 17 Feb 2026 13:26:08 +0100
Subject: [PATCH 08/12] feat(gfi): improve support for different rendering
 options

---
 src/plugins/gfi/components/GfiUI.ce.vue | 29 ++++++++++++++++++++++---
 src/plugins/gfi/stores/feature.ts       | 24 +++++++++++++++++---
 2 files changed, 47 insertions(+), 6 deletions(-)

diff --git a/src/plugins/gfi/components/GfiUI.ce.vue b/src/plugins/gfi/components/GfiUI.ce.vue
index 0a940eba09..837d46db2e 100644
--- a/src/plugins/gfi/components/GfiUI.ce.vue
+++ b/src/plugins/gfi/components/GfiUI.ce.vue
@@ -1,5 +1,12 @@
 <template>
-	<PolarCard id="polar-card-gfi">
+	<PolarCard
+		v-if="gfiStore.features.length > 0 || gfiStore.configuration.featureList"
+		id="polar-card-gfi"
+		:class="{
+			standard: coreStore.layout === 'standard',
+			'nine-regions': coreStore.layout === 'nineRegions',
+		}"
+	>
 		<template v-if="gfiStore.features.length > 0">
 			<GfiFeature v-if="gfiStore.feature" v-bind="gfiStore.feature" />
 			<button
@@ -31,18 +38,34 @@
 
 <script setup lang="ts">
 import PolarCard from '@/components/PolarCard.ce.vue'
+import { useCoreStore } from '@/core/stores'
 
 import { useGfiStore } from '../store'
 import GfiFeature from './GfiFeature.ce.vue'
 import GfiFeatureList from './GfiFeatureList.ce.vue'
 
+const coreStore = useCoreStore()
 const gfiStore = useGfiStore()
 </script>
 
 <style scoped>
 #polar-card-gfi {
 	width: 12em;
-	pointer-events: all;
-	padding-bottom: 3em;
+	margin: var(--kern-metric-space-small);
+	max-height: 80%;
+	overflow: auto;
+
+	&.standard {
+		position: absolute;
+	}
+
+	&::deep(.kern-card__container) {
+		width: 100%;
+		padding-bottom: var(--kern-metric-space-small);
+	}
+}
+
+button {
+	margin-top: var(--kern-metric-space-small);
 }
 </style>
diff --git a/src/plugins/gfi/stores/feature.ts b/src/plugins/gfi/stores/feature.ts
index ac0d63d13c..8369151744 100644
--- a/src/plugins/gfi/stores/feature.ts
+++ b/src/plugins/gfi/stores/feature.ts
@@ -4,13 +4,16 @@ import { rawLayerList } from '@masterportal/masterportalapi'
 import { isEqual } from 'es-toolkit'
 import { MapBrowserEvent, Overlay } from 'ol'
 import { acceptHMRUpdate, defineStore } from 'pinia'
-import { computed, onScopeDispose, ref, watch } from 'vue'
+import { computed, nextTick, onScopeDispose, ref, watch } from 'vue'
 
 import { useCoreStore } from '@/core/stores'
 
-import type { GfiLayerConfiguration, RequestGfiParameters } from '../types'
-
 import { useMultiSelection } from '../composables/useMultiSelection'
+import {
+	PluginId,
+	type GfiLayerConfiguration,
+	type RequestGfiParameters,
+} from '../types'
 import { requestGfi } from '../utils/requestGfi'
 import { updateTooltip } from '../utils/updateTooltip'
 import { useGfiMainStore } from './main'
@@ -236,6 +239,21 @@ export const useGfiFeatureStore = defineStore('plugins/gfi/feature', () => {
 		coreStore.map.removeOverlay(overlay)
 	})
 
+	if (gfiMainStore.configuration.renderType === 'iconMenu') {
+		// TODO: Find a better solution to wait for this plugin
+		// As, in this case, we render as part of the iconMenu, the iconMenu store will be available soon.
+		void nextTick(() => {
+			const iconMenuStore = coreStore.getPluginStore('iconMenu')
+			if (iconMenuStore) {
+				watch(selectedFeature, (newFeature) => {
+					if (newFeature) {
+						iconMenuStore.openMenuById(PluginId)
+					}
+				})
+			}
+		})
+	}
+
 	return {
 		visibleFeatures,
 		selectedFeatureIndex,

From 978d7183564ba9dd6a5f888092cb6c0b9838ac28 Mon Sep 17 00:00:00 2001
From: Hendrik Oenings <142312676+oeninghe-dataport@users.noreply.github.com>
Date: Mon, 2 Mar 2026 10:24:55 +0100
Subject: [PATCH 09/12] fix(gfi): remove legacy manual plugin prefix for
 console
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Pascal Röhling <73653210+dopenguin@users.noreply.github.com>
---
 src/plugins/gfi/utils/requestGfiWms.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/plugins/gfi/utils/requestGfiWms.ts b/src/plugins/gfi/utils/requestGfiWms.ts
index 24aaf48704..cba4bd2fdf 100644
--- a/src/plugins/gfi/utils/requestGfiWms.ts
+++ b/src/plugins/gfi/utils/requestGfiWms.ts
@@ -60,7 +60,7 @@ function readTextFeatures(text: string): Feature[] {
 				feature.set(key || '', value)
 			} else {
 				console.error(
-					'@polar/plugin-gfi: Found property before feature declaration in readTextFeatures.',
+					'Found property before feature declaration in readTextFeatures.',
 					line,
 					'Skipping ...'
 				)

From 6d6008610b652bce6a8af3ea91851e9567733d77 Mon Sep 17 00:00:00 2001
From: Hendrik Oenings <142312676+oeninghe-dataport@users.noreply.github.com>
Date: Mon, 2 Mar 2026 10:25:56 +0100
Subject: [PATCH 10/12] docs: fix shared locales hint
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Pascal Röhling <73653210+dopenguin@users.noreply.github.com>
---
 src/locales.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/locales.ts b/src/locales.ts
index 28806ca6e1..62c02c9aa6 100644
--- a/src/locales.ts
+++ b/src/locales.ts
@@ -10,7 +10,7 @@
 import type { Locale } from '@/core/types'
 
 /**
- * German locales for POLAR core.
+ * German locales for POLAR shared components.
  * For overwriting these values, pass a partial object of this in `locales`.
  */
 export const resourcesDe = {

From 6182677d1048092aafd7730eb1589250826de8a3 Mon Sep 17 00:00:00 2001
From: Hendrik Oenings <142312676+oeninghe-dataport@users.noreply.github.com>
Date: Mon, 2 Mar 2026 10:26:08 +0100
Subject: [PATCH 11/12] docs: fix shared locales hint
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Pascal Röhling <73653210+dopenguin@users.noreply.github.com>
---
 src/locales.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/locales.ts b/src/locales.ts
index 62c02c9aa6..1e89b2e026 100644
--- a/src/locales.ts
+++ b/src/locales.ts
@@ -38,7 +38,7 @@ export const resourcesEn = {
 } as const
 
 /**
- * Core locales.
+ * POLAR shared components locales.
  *
  * @privateRemarks
  * The first entry will be used as fallback.

From 439ae45a5d2e8c26b5173dba24e72a9a0852ff47 Mon Sep 17 00:00:00 2001
From: Hendrik Oenings <142312676+oeninghe-dataport@users.noreply.github.com>
Date: Mon, 2 Mar 2026 10:26:22 +0100
Subject: [PATCH 12/12] docs: fix shared locales hint
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Pascal Röhling <73653210+dopenguin@users.noreply.github.com>
---
 src/locales.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/locales.ts b/src/locales.ts
index 1e89b2e026..071900ed54 100644
--- a/src/locales.ts
+++ b/src/locales.ts
@@ -24,7 +24,7 @@ export const resourcesDe = {
 } as const
 
 /**
- * English locales for POLAR core.
+ * English locales for POLAR shared components.
  * For overwriting these values, pass a partial object of this in `locales`.
  */
 export const resourcesEn = {