@geogirafe/lib-geoportal 1.1.0-dev.2605752849 → 1.1.0-dev.2623495582

package/tools/offline/offlinemanager.js

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 import GirafeSingleton from '../../base/GirafeSingleton.js';
+import { IndexedDbHelper } from '../sw/service-worker.tools';
 import { Feature } from 'ol';
 import VectorLayer from 'ol/layer/Vector.js';
 import VectorSource from 'ol/source/Vector.js';
@@ -8,13 +9,17 @@ import Style from 'ol/style/Style.js';
 import { Stroke } from 'ol/style.js';
 class OfflineManager extends GirafeSingleton {
     serviceWorker = null;
-    database;
+    indexedDbHelper = new IndexedDbHelper();
     get map() {
         return this.context.mapManager.getMap();
     }
     get state() {
         return this.context.stateManager.state;
     }
+    async database() {
+        const database = await this.indexedDbHelper.openDb(this.dbCacheName, this.storeVersion, this.upgradeIndexedDb);
+        return database;
+    }
     totalLength = 0;
     counter = 0;
     progressCallback;
@@ -38,10 +43,10 @@ class OfflineManager extends GirafeSingleton {
         this.context.stateManager.state.isOffline = isOffline;
     }
     registerEvents() {
-        window.addEventListener('offline', () => {
+        globalThis.addEventListener('offline', () => {
             this.state.isOffline = true;
         });
-        window.addEventListener('online', () => {
+        globalThis.addEventListener('online', () => {
             this.state.isOffline = false;
         });
         this.context.stateManager.subscribe('isOffline', () => {
@@ -55,45 +60,16 @@ class OfflineManager extends GirafeSingleton {
         const tileUrls = this.getAllTileUrls(bbox, wmtsLayers);
         await this.fetchAndSaveTiles(tileUrls);
     }
-    async openIndexedDB() {
-        return new Promise((resolve, reject) => {
-            console.debug('Opening IndexedDB');
-            const request = indexedDB.open(this.dbCacheName, this.storeVersion);
-            let timedOut = false;
-            const timeoutId = setTimeout(() => {
-                timedOut = true;
-                console.debug('Timeout while opening IndexedDB');
-                reject(new Error('Timeout while opening IndexedDB'));
-            }, 3000);
-            request.onerror = (event) => {
-                if (!timedOut) {
-                    clearTimeout(timeoutId);
-                    const message = event.target.error?.message;
-                    console.debug(`IndexedDB could not be opened : ${message}`);
-                    reject(new Error(message));
-                }
-            };
-            request.onsuccess = (event) => {
-                if (!timedOut) {
-                    clearTimeout(timeoutId);
-                    console.debug('IndexedDB is open');
-                    resolve(event.target.result);
-                }
-            };
-            request.onupgradeneeded = (event) => {
-                // Version migration is necessary.
-                // open the indexedDB and create the new structure
-                console.debug('Upgrading IndexedDB');
-                const database = event.target.result;
-                // First : a store for tiles
-                const tilesStore = database.createObjectStore('tiles', { autoIncrement: true });
-                tilesStore.createIndex('url', 'url', { unique: true });
-                // Second : A store for offline available bbox
-                database.createObjectStore('bbox', { autoIncrement: true });
-                console.debug('IndexedDB upgraded.');
-                resolve(database);
-            };
-        });
+    upgradeIndexedDb(database) {
+        // Version migration is necessary.
+        // open the indexedDB and create the new structure
+        console.debug('Upgrading IndexedDB');
+        // First : a store for tiles
+        const tilesStore = database.createObjectStore('tiles', { autoIncrement: true });
+        tilesStore.createIndex('url', 'url', { unique: true });
+        // Second : A store for offline available bbox
+        database.createObjectStore('bbox', { autoIncrement: true });
+        console.debug('IndexedDB upgraded.');
     }
     /** The offline manager works with a ServiceWorker in charge of intercepting
      * the fetch requests and read the data from the local cache if the application
@@ -108,7 +84,6 @@ class OfflineManager extends GirafeSingleton {
         this.serviceWorker = sw;
         this.storeVersion = storeVersion;
         this.dbCacheName = dbCacheName;
-        this.database = await this.openIndexedDB();
         this.serviceWorker.postMessage({
             storeVersion: this.storeVersion,
             dbCacheName: this.dbCacheName,
@@ -165,9 +140,7 @@ class OfflineManager extends GirafeSingleton {
         const iterator = tileUrls.values();
         // Use 4 parallel workers to download tiles
         this.counter = 0;
-        const workers = Array(4)
-            .fill(iterator)
-            .map((iterator) => this.doWork(iterator));
+        const workers = new Array(4).fill(iterator).map((iterator) => this.doWork(iterator));
         Promise.allSettled(workers).then(() => {
             console.debug('Everything downloaded.');
             if (this.progressCallback) {
@@ -180,41 +153,41 @@ class OfflineManager extends GirafeSingleton {
         for (const url of iterator) {
             const response = await fetch(url);
             if (response.ok) {
-                response.blob().then((blob) => {
-                    const transaction = this.database.transaction([this.tilesStoreName], 'readwrite');
-                    const store = transaction.objectStore(this.tilesStoreName);
-                    const index = store.index('url');
-                    const dbRequest = index.getKey(url);
-                    dbRequest.onsuccess = () => {
-                        let request;
-                        if (dbRequest.result) {
-                            const key = dbRequest.result;
-                            request = store.put({ url: url, data: blob }, key);
-                        }
-                        else {
-                            request = store.put({ url: url, data: blob });
+                const blob = await response.blob();
+                const transaction = (await this.database()).transaction([this.tilesStoreName], 'readwrite');
+                const store = transaction.objectStore(this.tilesStoreName);
+                const index = store.index('url');
+                const dbRequest = index.getKey(url);
+                dbRequest.onsuccess = () => {
+                    let request;
+                    if (dbRequest.result) {
+                        const key = dbRequest.result;
+                        request = store.put({ url: url, data: blob }, key);
+                    }
+                    else {
+                        request = store.put({ url: url, data: blob });
+                    }
+                    request.onsuccess = () => {
+                        if (this.progressCallback) {
+                            this.progressCallback(Math.round((this.counter * 100) / this.totalLength));
                         }
-                        request.onsuccess = () => {
-                            if (this.progressCallback) {
-                                this.progressCallback(Math.round((this.counter * 100) / this.totalLength));
-                            }
-                            console.debug(`${this.counter++}/${this.totalLength} Tile ${url} added.`);
-                        };
-                        request.onerror = () => {
-                            console.error(`Error while saving tile ${url}`);
-                        };
+                        console.debug(`${this.counter++}/${this.totalLength} Tile ${url} added.`);
                     };
-                });
+                    request.onerror = () => {
+                        console.error(`Error while saving tile ${url}`);
+                    };
+                };
             }
         }
     }
     async getTotalSizeMB() {
+        const database = await this.database();
         return new Promise((resolve, reject) => {
-            if (!this.database) {
+            if (!database) {
                 reject(new Error('Database is not initialized.'));
                 return;
             }
-            const transaction = this.database.transaction([this.tilesStoreName], 'readonly');
+            const transaction = database.transaction([this.tilesStoreName], 'readonly');
             const store = transaction.objectStore(this.tilesStoreName);
             const request = store.openCursor();
             let totalBytes = 0;
@@ -239,12 +212,13 @@ class OfflineManager extends GirafeSingleton {
         });
     }
     async clearStore(storeName) {
+        const database = await this.database();
         return new Promise((resolve, reject) => {
             if (!this.database) {
                 reject(new Error('Database is not initialized.'));
                 return;
             }
-            const transaction = this.database.transaction([storeName], 'readwrite');
+            const transaction = database.transaction([storeName], 'readwrite');
             const store = transaction.objectStore(storeName);
             const request = store.clear();
             request.onsuccess = () => {
@@ -264,11 +238,9 @@ class OfflineManager extends GirafeSingleton {
         this.clearStore(this.bboxStoreName);
     }
     async saveBoundingBox(bbox) {
-        if (this.database === undefined) {
-            this.database = await this.openIndexedDB();
-        }
+        const database = await this.database();
         // Save bbox to the store
-        const transaction = this.database.transaction([this.bboxStoreName], 'readwrite');
+        const transaction = database.transaction([this.bboxStoreName], 'readwrite');
         const store = transaction.objectStore(this.bboxStoreName);
         const request = store.put(bbox);
         request.onsuccess = () => {
@@ -279,11 +251,9 @@ class OfflineManager extends GirafeSingleton {
         };
     }
     async displayBoundBoxes() {
-        if (this.database === undefined) {
-            this.database = await this.openIndexedDB();
-        }
+        const database = await this.database();
         // Read bbox for offline tiles
-        const transaction = this.database.transaction([this.bboxStoreName], 'readonly');
+        const transaction = database.transaction([this.bboxStoreName], 'readonly');
         const store = transaction.objectStore(this.bboxStoreName);
         const request = store.getAll();
         request.onsuccess = () => {

package/tools/search/abstractsearchclient.d.ts

@@ -0,0 +1,42 @@
+import Feature from 'ol/Feature.js';
+import { GeoJSON } from 'ol/format.js';
+import GirafeSingleton from '../../base/GirafeSingleton.js';
+import IGirafeContext from '../context/icontext.js';
+import { Extent } from 'ol/extent.js';
+export declare const SEARCH_PROVIDER_DEFAULT = "default";
+export declare const SEARCH_GROUP_DEFAULT = "default";
+export declare const SEARCH_GROUP_RECENTER_MAP = "recenter_map";
+declare abstract class AbstractSearchClient extends GirafeSingleton {
+    readonly type: string;
+    readonly providerName: string;
+    protected url: URL;
+    protected readonly resultSrid: string;
+    protected readonly searchTermPlaceholder = "###SEARCHTERM###";
+    protected readonly searchLangPlaceholder = "###SEARCHLANG###";
+    protected readonly geoJsonFormatter: GeoJSON<Feature<import("ol/geom.js").Geometry, {
+        [x: string]: any;
+    }>>;
+    protected constructor(context: IGirafeContext, type: string, name: string, url: string, resultSrid: string);
+    initializeSingleton(): void;
+    protected get mapProjection(): import("ol/proj.js").Projection;
+    requestSearch(term: string, abortController: AbortController): Promise<Feature[]>;
+    /**
+     * Parses the response from the server and returns an array of features.
+     * Features must have the following properties to be used correctly with the search component:
+     * - `provider`
+     * - `label`
+     * - `label_html`: optional, for styled entries in the search results list
+     * - `actions`: optional, a list of SearchResultsActions
+     */
+    protected parseResponse(response: Response): Promise<Feature[]>;
+    /**
+     * Groups results by the default group, which equivalates to no grouping. Should be overridden by the client class
+     * to group results by a custom criteria.
+     */
+    groupedResults(results: Feature[]): Record<string, Feature[]>;
+    /**
+     * Returns a bbox around the geometry that is 50% larger than the geometry.
+     */
+    getZoomToBbox(feature: Feature): Extent | undefined;
+}
+export default AbstractSearchClient;

package/tools/search/abstractsearchclient.js

@@ -0,0 +1,85 @@
+import { GeoJSON } from 'ol/format.js';
+import GirafeSingleton from '../../base/GirafeSingleton.js';
+import { buffer, getHeight, getWidth } from 'ol/extent.js';
+// The default provider is a container for search results that do not result from a provider search (e.g. map re-centering)
+export const SEARCH_PROVIDER_DEFAULT = 'default';
+// The default search group contains search results that do not belong to a specific category
+export const SEARCH_GROUP_DEFAULT = 'default';
+// The map recenter search group contains the coordinates for re-centering the map
+export const SEARCH_GROUP_RECENTER_MAP = 'recenter_map';
+class AbstractSearchClient extends GirafeSingleton {
+    type;
+    providerName;
+    url;
+    resultSrid;
+    searchTermPlaceholder = '###SEARCHTERM###';
+    searchLangPlaceholder = '###SEARCHLANG###';
+    geoJsonFormatter = new GeoJSON();
+    constructor(context, type, name, url, resultSrid) {
+        super(context);
+        this.type = type;
+        this.providerName = name;
+        this.url = new URL(url);
+        this.resultSrid = resultSrid;
+    }
+    initializeSingleton() {
+        super.initializeSingleton();
+    }
+    get mapProjection() {
+        return this.context.mapManager.getMap().getView().getProjection();
+    }
+    async requestSearch(term, abortController) {
+        const url = this.url
+            .toString()
+            .replace(this.searchTermPlaceholder, term)
+            .replace(this.searchLangPlaceholder, this.context.stateManager.state.language);
+        try {
+            const response = await fetch(url, { signal: abortController.signal });
+            return await this.parseResponse(response);
+        }
+        catch (error) {
+            console.error(`Error fetching search results from ${this.url.toString()}:`, error);
+            return [];
+        }
+    }
+    /**
+     * Parses the response from the server and returns an array of features.
+     * Features must have the following properties to be used correctly with the search component:
+     * - `provider`
+     * - `label`
+     * - `label_html`: optional, for styled entries in the search results list
+     * - `actions`: optional, a list of SearchResultsActions
+     */
+    async parseResponse(response) {
+        const data = (await response.json());
+        const features = this.geoJsonFormatter.readFeatures(data, {
+            dataProjection: this.resultSrid,
+            featureProjection: this.mapProjection
+        });
+        return features.map((f) => {
+            f.set('provider', this.providerName);
+            return f;
+        });
+    }
+    /**
+     * Groups results by the default group, which equivalates to no grouping. Should be overridden by the client class
+     * to group results by a custom criteria.
+     */
+    groupedResults(results) {
+        return { [SEARCH_GROUP_DEFAULT]: results };
+    }
+    /**
+     * Returns a bbox around the geometry that is 50% larger than the geometry.
+     */
+    getZoomToBbox(feature) {
+        const geom = feature.getGeometry();
+        if (geom) {
+            const extent = geom.getExtent();
+            // We create a buffer around the extent from 50% of the width/height
+            const bufferValue = Math.max((getWidth(extent) * 50) / 100, (getHeight(extent) * 50) / 100);
+            return buffer(extent, bufferValue);
+        }
+        return undefined;
+    }
+}
+export default AbstractSearchClient;

package/tools/search/geoadminchsearchclient.d.ts

@@ -0,0 +1,63 @@
+import Feature from 'ol/Feature.js';
+import AbstractSearchClient from './abstractsearchclient.js';
+import IGirafeContext from '../context/icontext.js';
+import { Extent } from 'ol/extent.js';
+export type GeoAdminChSearchConfig = {
+    type: 'geoadminch';
+    providerName: string;
+    bbox?: string;
+    locationOrigins?: string;
+};
+/**
+ * Search provider for the Swiss search service of geo.admin.ch.
+ * See documentation at https://docs.geo.admin.ch/access-data/search.html
+ *
+ * The GeoAdmin search provider allows 3 different types of searches:
+ * - locations: POIs like addresses, swissnames, boundaries, parcels
+ * - layers: layers of the GeoAdmin portal
+ * - features: features inside one or multiple layers of the GeoAdmin portal
+ *
+ * This client currently only supports location search.
+ * The API returns max 50 items per request.
+ *
+ * Configuration:
+ * - providerName: The name of the search provider, or geoadminch.
+ * - resultSrid: The spatial reference system (SRID) of the search results, always EPSG:2056.
+ * - bbox: Comma-separated list of bounding box coordinates in EPSG:2056 (e.g. "2580000,1150000,2600000,1200000")
+ *         If no bbox is set, the max extent of the map is used.
+ * - locationOrigins: Array of categories that are searched. Default: All categories.
+ *            Available categories and data origin:
+ *            - zipcode (ch.swisstopo-vd.ortschaftenverzeichnis_plz)
+ *            - gg25 (ch.swisstopo.swissboundaries3d-gemeinde-flaeche.fill)
+ *            - district (ch.swisstopo.swissboundaries3d-bezirk-flaeche.fill)
+ *            - kantone (ch.swisstopo.swissboundaries3d-kanton-flaeche.fill)
+ *            - gazetteer (ch.swisstopo.swissnames3d, ch.bav.haltestellen-oev)
+ *            - address (ch.swisstopo.amtliches-gebaeudeadressverzeichnis, including EGID)
+ *            - parcel
+ */
+declare class GeoAdminChSearchClient extends AbstractSearchClient {
+    constructor(context: IGirafeContext, config: GeoAdminChSearchConfig);
+    private setSearchExtent;
+    requestSearch(term: string, abortController: AbortController): Promise<Feature[]>;
+    protected parseResponse(response: Response): Promise<Feature[]>;
+    /**
+     * GeoAdmin geoJson responses contain coordinates as [north, east], but the GeoJson standard is [east, north].
+     * To be able to use the ol GeoJson format reader, the coordinates are rearranged.
+     * Note that other spatial information in the GeoAdmin response is valid, e.g. the bbox has the correct order.
+     */
+    private fixGeoAdminCoordinates;
+    /**
+     * Swap first (north) and second (east) coordinate in an array of coordinates.
+     */
+    private swapCoordinates;
+    /**
+     * Property origin contains the result category:
+     */
+    groupedResults(results: Feature[]): Record<string, Feature[]>;
+    getZoomToBbox(feature: Feature): Extent | undefined;
+    /**
+     * Remove bold and italic HTML tags from the label
+     */
+    private sanitizeHtmlLabel;
+}
+export default GeoAdminChSearchClient;

package/tools/search/geoadminchsearchclient.js

@@ -0,0 +1,147 @@
+import AbstractSearchClient from './abstractsearchclient.js';
+import { transformExtent } from 'ol/proj.js';
+/**
+ * Search provider for the Swiss search service of geo.admin.ch.
+ * See documentation at https://docs.geo.admin.ch/access-data/search.html
+ *
+ * The GeoAdmin search provider allows 3 different types of searches:
+ * - locations: POIs like addresses, swissnames, boundaries, parcels
+ * - layers: layers of the GeoAdmin portal
+ * - features: features inside one or multiple layers of the GeoAdmin portal
+ *
+ * This client currently only supports location search.
+ * The API returns max 50 items per request.
+ *
+ * Configuration:
+ * - providerName: The name of the search provider, or geoadminch.
+ * - resultSrid: The spatial reference system (SRID) of the search results, always EPSG:2056.
+ * - bbox: Comma-separated list of bounding box coordinates in EPSG:2056 (e.g. "2580000,1150000,2600000,1200000")
+ *         If no bbox is set, the max extent of the map is used.
+ * - locationOrigins: Array of categories that are searched. Default: All categories.
+ *            Available categories and data origin:
+ *            - zipcode (ch.swisstopo-vd.ortschaftenverzeichnis_plz)
+ *            - gg25 (ch.swisstopo.swissboundaries3d-gemeinde-flaeche.fill)
+ *            - district (ch.swisstopo.swissboundaries3d-bezirk-flaeche.fill)
+ *            - kantone (ch.swisstopo.swissboundaries3d-kanton-flaeche.fill)
+ *            - gazetteer (ch.swisstopo.swissnames3d, ch.bav.haltestellen-oev)
+ *            - address (ch.swisstopo.amtliches-gebaeudeadressverzeichnis, including EGID)
+ *            - parcel
+ */
+class GeoAdminChSearchClient extends AbstractSearchClient {
+    constructor(context, config) {
+        super(context, 'geoadminch', config.providerName, 'https://api3.geo.admin.ch/rest/services/api/SearchServer', 'EPSG:2056');
+        this.url.searchParams.set('type', 'locations');
+        this.url.searchParams.set('sr', this.resultSrid.replace('EPSG:', ''));
+        this.url.searchParams.set('geometryFormat', 'geojson');
+        this.url.searchParams.set('sortbox', 'false');
+        if (config.locationOrigins) {
+            this.url.searchParams.set('origins', config.locationOrigins);
+        }
+        this.setSearchExtent(config.bbox);
+    }
+    setSearchExtent(bbox) {
+        let searchExtent;
+        if (bbox) {
+            searchExtent = bbox;
+        }
+        else {
+            // If no bbox is configured, set the search extent to the max map extent
+            searchExtent = this.context.configManager.Config.map.maxExtent;
+        }
+        if (!searchExtent) {
+            return;
+        }
+        // If the default map extent isn't specified in EPSG:2056, transform it
+        const defaultSrid = this.context.configManager.getDefaultConfigValue('map.srid');
+        if (defaultSrid !== this.resultSrid) {
+            const extent = searchExtent.split(',').map(Number);
+            searchExtent = transformExtent(extent, defaultSrid, this.resultSrid).join(',');
+        }
+        this.url.searchParams.set('bbox', searchExtent);
+    }
+    async requestSearch(term, abortController) {
+        try {
+            const url = new URL(this.url);
+            url.searchParams.set('searchText', term);
+            url.searchParams.set('lang', this.context.stateManager.state.language);
+            const response = await fetch(url, { signal: abortController.signal });
+            return await this.parseResponse(response);
+        }
+        catch (error) {
+            console.error('Error fetching search results from GeoAdminSearch:', error);
+            return new Promise(() => []);
+        }
+    }
+    async parseResponse(response) {
+        const data = this.fixGeoAdminCoordinates((await response.json()));
+        const features = this.geoJsonFormatter.readFeatures(data, {
+            dataProjection: this.resultSrid,
+            featureProjection: this.mapProjection
+        });
+        // Property `label` contains an HTML string. Rename `label` to `label_html` to use in the dropdown,
+        // and sanitize `label` to be used in the input field
+        return features.map((f) => {
+            f.set('provider', this.providerName);
+            f.set('label_html', f.get('label'));
+            f.set('label', this.sanitizeHtmlLabel(f.get('label')));
+            return f;
+        });
+    }
+    /**
+     * GeoAdmin geoJson responses contain coordinates as [north, east], but the GeoJson standard is [east, north].
+     * To be able to use the ol GeoJson format reader, the coordinates are rearranged.
+     * Note that other spatial information in the GeoAdmin response is valid, e.g. the bbox has the correct order.
+     */
+    fixGeoAdminCoordinates(data) {
+        if ('features' in data && Array.isArray(data.features)) {
+            for (const feature of data.features) {
+                if (feature.geometry) {
+                    feature.geometry.coordinates = this.swapCoordinates(feature.geometry.coordinates);
+                }
+            }
+        }
+        return data;
+    }
+    /**
+     * Swap first (north) and second (east) coordinate in an array of coordinates.
+     */
+    swapCoordinates(coordinates) {
+        if (Array.isArray(coordinates) &&
+            coordinates.length >= 2 &&
+            typeof coordinates[0] === 'number' &&
+            typeof coordinates[1] === 'number' &&
+            coordinates[0] < coordinates[1]) {
+            const pos = coordinates;
+            return [pos[1], pos[0], ...pos.slice(2)];
+        }
+        return coordinates.map(this.swapCoordinates);
+    }
+    /**
+     * Property origin contains the result category:
+     */
+    groupedResults(results) {
+        const groupedResults = {};
+        for (const result of results) {
+            const group = `geoadminch_${result.get('origin') ?? 'Other'}`;
+            groupedResults[group] ??= [];
+            groupedResults[group].push(result);
+        }
+        return groupedResults;
+    }
+    getZoomToBbox(feature) {
+        const st_bbox = feature.get('geom_st_box2d');
+        if (st_bbox) {
+            const bbox_coords = st_bbox.replace('BOX(', '').replace(')', '').replaceAll(' ', ',');
+            const extent = bbox_coords.split(',').map((coord) => Number.parseFloat(coord));
+            return transformExtent(extent, this.resultSrid, this.mapProjection);
+        }
+        return undefined;
+    }
+    /**
+     * Remove bold and italic HTML tags from the label
+     */
+    sanitizeHtmlLabel(label) {
+        return label.replace(/<\/?[ib]>/g, '');
+    }
+}
+export default GeoAdminChSearchClient;

package/tools/search/gmfsearchclient.d.ts

@@ -0,0 +1,23 @@
+import IGirafeContext from '../context/icontext.js';
+import Feature from 'ol/Feature.js';
+import AbstractSearchClient from './abstractsearchclient.js';
+export type GmfSearchConfig = {
+    type: 'geomapfish';
+    providerName: string;
+    url: string;
+    resultSrid: string;
+};
+/**
+ * A search provider for the GeoMapFish backend.
+ * Extends the AbstractSearchClient and provides methods tailored to processing GMF-specific search results.
+ *
+ * Configuration:
+ * - providerName: The name of the search provider, or geomapfish.
+ * - url: The URL of the GMF search service.
+ * - resultSrid: The spatial reference system (SRID) of the search results. Default same as map SRID.
+ */
+declare class GmfSearchClient extends AbstractSearchClient {
+    constructor(context: IGirafeContext, config: GmfSearchConfig);
+    groupedResults(results: Feature[]): Record<string, Feature[]>;
+}
+export default GmfSearchClient;

package/tools/search/gmfsearchclient.js

@@ -0,0 +1,37 @@
+import AbstractSearchClient from './abstractsearchclient.js';
+/**
+ * A search provider for the GeoMapFish backend.
+ * Extends the AbstractSearchClient and provides methods tailored to processing GMF-specific search results.
+ *
+ * Configuration:
+ * - providerName: The name of the search provider, or geomapfish.
+ * - url: The URL of the GMF search service.
+ * - resultSrid: The spatial reference system (SRID) of the search results. Default same as map SRID.
+ */
+class GmfSearchClient extends AbstractSearchClient {
+    constructor(context, config) {
+        super(context, 'geomapfish', config.providerName, config.url, config.resultSrid);
+    }
+    groupedResults(results) {
+        const groupedResults = {};
+        for (const result of results) {
+            let group = 'Unknown layer type';
+            if (result.get('layer_name')) {
+                group = result.get('layer_name');
+            }
+            else if (result.get('actions')[0].action.startsWith('add_theme')) {
+                group = 'add_theme';
+            }
+            else if (result.get('actions')[0].action.startsWith('add_group')) {
+                group = 'add_group';
+            }
+            else if (result.get('actions')[0].action.startsWith('add_layer')) {
+                group = 'add_layer';
+            }
+            groupedResults[group] ??= [];
+            groupedResults[group].push(result);
+        }
+        return groupedResults;
+    }
+}
+export default GmfSearchClient;

package/tools/search/searchmanager.d.ts

@@ -0,0 +1,33 @@
+import IGirafeContext from '../context/icontext.js';
+import GirafeSingleton from '../../base/GirafeSingleton.js';
+import Feature from 'ol/Feature.js';
+import { Extent } from 'ol/extent.js';
+export type SearchProviderConfig = {
+    type: 'geomapfish' | 'geoadminch';
+    providerName: string;
+    [key: string]: unknown;
+};
+declare class SearchManager extends GirafeSingleton {
+    private readonly clients;
+    private abortController;
+    readonly minSearchTermLength = 3;
+    constructor(context: IGirafeContext);
+    initializeSingleton(): void;
+    private createClient;
+    abortSearch(): void;
+    /**
+     * Performs a search operation with all available clients based on the provided term and returns results
+     * grouped by provider name and result category.
+     */
+    doSearch(term: string): Promise<Record<string, Record<string, Feature[]>> | null>;
+    private createCoordinateSearchResult;
+    /**
+     * Detects and parses a coordinate search term into an array of two numerical values.
+     * The method attempts to identify valid coordinate pairs from the given term,
+     * using different separators such as `;`, `/`, `,`, or whitespace.
+     */
+    detectCoordinatesInTerm(term: string): [number, number] | null;
+    private parseCoordinate;
+    getZoomToBbox(feature: Feature): Extent | undefined;
+}
+export default SearchManager;