@geogirafe/lib-geoportal 1.2.0-dev.2829697690 → 1.2.0-dev.2836809138

package/tools/search/abstractsearchclient.d.ts

@@ -3,6 +3,12 @@ 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 type BaseSearchClientConfig = {
+    type: string;
+    providerName: string;
+    url: string;
+    resultSrid: string;
+};
 export declare const SEARCH_PROVIDER_DEFAULT = "default";
 export declare const SEARCH_GROUP_DEFAULT = "default";
 export declare const SEARCH_GROUP_RECENTER_MAP = "recenter_map";
@@ -13,13 +19,31 @@ declare abstract class AbstractSearchClient extends GirafeSingleton {
     protected readonly resultSrid: string;
     protected readonly searchTermPlaceholder = "###SEARCHTERM###";
     protected readonly searchLangPlaceholder = "###SEARCHLANG###";
+    protected searchTermQueryParameter: string | undefined;
+    protected searchLangQueryParameter: string | undefined;
+    protected searchFilterQueryParameter: string | undefined;
     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);
+    protected constructor(context: IGirafeContext, config: BaseSearchClientConfig);
     initializeSingleton(): void;
     protected get mapProjection(): import("ol/proj.js").Projection;
-    requestSearch(term: string, abortController: AbortController): Promise<Feature[]>;
+    /**
+     * Sanitize the url by removing placeholders that are wrongfully interpreted as URL fragments by the URL parser.
+     * The parameters are introduced again and set when fetching the search results.
+     */
+    private sanitizeUrl;
+    private extractQueryParamWithPlaceholder;
+    private sanitizePlaceholder;
+    /**
+     * Returns a list of categories that can be searched by.
+     */
+    getSearchCategories(): Promise<string[]>;
+    protected buildRequestUrl(term: string, filter: string[]): URL;
+    /**
+     * Executes a search request with the provided search term.
+     */
+    requestSearch(term: string, filter: 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:
@@ -30,13 +54,17 @@ declare abstract class AbstractSearchClient extends GirafeSingleton {
      */
     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.
+     * Groups the results by the default group, which equivalates to no grouping. Should be overridden by the client class
+     * to group results by a custom criteria like search category.
      */
     groupedResults(results: Feature[]): Record<string, Feature[]>;
     /**
      * Returns a bbox around the geometry that is 50% larger than the geometry.
      */
     getZoomToBbox(feature: Feature): Extent | undefined;
+    /**
+     * Retrieves the translation key for a given category. Default: use category string directly.
+     */
+    getI18nKeyForCategory(category: string): string;
 }
 export default AbstractSearchClient;

package/tools/search/abstractsearchclient.js

@@ -3,7 +3,7 @@ import GirafeSingleton from '../../base/GirafeSingleton.js';
 import { createBufferedExtentFromFeature } from '../geometrytools.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
+// The default search group contains search results that do not belong to a specific category, they are listed without a list header
 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';
@@ -14,13 +14,16 @@ class AbstractSearchClient extends GirafeSingleton {
     resultSrid;
     searchTermPlaceholder = '###SEARCHTERM###';
     searchLangPlaceholder = '###SEARCHLANG###';
+    searchTermQueryParameter;
+    searchLangQueryParameter;
+    searchFilterQueryParameter;
     geoJsonFormatter = new GeoJSON();
-    constructor(context, type, name, url, resultSrid) {
+    constructor(context, config) {
         super(context);
-        this.type = type;
-        this.providerName = name;
-        this.url = new URL(url);
-        this.resultSrid = resultSrid;
+        this.type = config.type;
+        this.providerName = config.providerName;
+        this.url = this.sanitizeUrl(config.url);
+        this.resultSrid = config.resultSrid;
     }
     initializeSingleton() {
         super.initializeSingleton();
@@ -28,11 +31,57 @@ class AbstractSearchClient extends GirafeSingleton {
     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);
+    /**
+     * Sanitize the url by removing placeholders that are wrongfully interpreted as URL fragments by the URL parser.
+     * The parameters are introduced again and set when fetching the search results.
+     */
+    sanitizeUrl(url) {
+        // First, replace problematic characters in the placeholders and url that cause issues with the URL parser
+        const sanitizedSearchTermPlaceholder = this.sanitizePlaceholder(this.searchTermPlaceholder);
+        const sanitizedSearchLangPlaceholder = this.sanitizePlaceholder(this.searchLangPlaceholder);
+        const sanitizedUrl = new URL(this.sanitizePlaceholder(url));
+        // Then, save and remove the query parameters that contain placeholders; they'll be introduced again when fetching the search results
+        this.searchTermQueryParameter = this.extractQueryParamWithPlaceholder(sanitizedUrl, sanitizedSearchTermPlaceholder);
+        this.searchLangQueryParameter = this.extractQueryParamWithPlaceholder(sanitizedUrl, sanitizedSearchLangPlaceholder);
+        return sanitizedUrl;
+    }
+    extractQueryParamWithPlaceholder(url, sanitizedPlaceholder) {
+        const queryParameter = Array.from(url.searchParams.entries()).find((entry) => entry[1] === sanitizedPlaceholder)?.[0];
+        if (queryParameter) {
+            url.searchParams.delete(queryParameter);
+        }
+        return queryParameter;
+    }
+    sanitizePlaceholder(urlOrPlaceholder) {
+        // Replace ### type placeholders because they are interpreted as URL fragments
+        const placeholderMarker = '###';
+        const urlSafePlaceholderMarker = '_';
+        return urlOrPlaceholder.replaceAll(placeholderMarker, urlSafePlaceholderMarker);
+    }
+    /**
+     * Returns a list of categories that can be searched by.
+     */
+    async getSearchCategories() {
+        return [];
+    }
+    buildRequestUrl(term, filter) {
+        const url = new URL(this.url);
+        if (this.searchTermQueryParameter) {
+            url.searchParams.set(this.searchTermQueryParameter, term);
+        }
+        if (this.searchLangQueryParameter && this.context.stateManager.state.language) {
+            url.searchParams.set(this.searchLangQueryParameter, this.context.stateManager.state.language);
+        }
+        if (this.searchFilterQueryParameter && filter.length) {
+            url.searchParams.set(this.searchFilterQueryParameter, filter.join(','));
+        }
+        return url;
+    }
+    /**
+     * Executes a search request with the provided search term.
+     */
+    async requestSearch(term, filter, abortController) {
+        const url = this.buildRequestUrl(term, filter);
         try {
             const response = await fetch(url, { signal: abortController.signal });
             return await this.parseResponse(response);
@@ -62,8 +111,8 @@ class AbstractSearchClient extends GirafeSingleton {
         });
     }
     /**
-     * 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.
+     * Groups the results by the default group, which equivalates to no grouping. Should be overridden by the client class
+     * to group results by a custom criteria like search category.
      */
     groupedResults(results) {
         return { [SEARCH_GROUP_DEFAULT]: results };
@@ -74,5 +123,11 @@ class AbstractSearchClient extends GirafeSingleton {
     getZoomToBbox(feature) {
         return createBufferedExtentFromFeature(feature);
     }
+    /**
+     * Retrieves the translation key for a given category. Default: use category string directly.
+     */
+    getI18nKeyForCategory(category) {
+        return category;
+    }
 }
 export default AbstractSearchClient;

package/tools/search/geoadminchsearchclient.d.ts

@@ -1,10 +1,9 @@
 import Feature from 'ol/Feature.js';
-import AbstractSearchClient from './abstractsearchclient.js';
+import AbstractSearchClient, { BaseSearchClientConfig } from './abstractsearchclient.js';
 import IGirafeContext from '../context/icontext.js';
 import { Extent } from 'ol/extent.js';
-export type GeoAdminChSearchConfig = {
+export type GeoAdminChSearchClientConfig = BaseSearchClientConfig & {
     type: 'geoadminch';
-    providerName: string;
     bbox?: string;
     locationOrigins?: string;
 };
@@ -36,9 +35,16 @@ export type GeoAdminChSearchConfig = {
  *            - parcel
  */
 declare class GeoAdminChSearchClient extends AbstractSearchClient {
-    constructor(context: IGirafeContext, config: GeoAdminChSearchConfig);
+    protected searchTermQueryParameter: string;
+    protected searchLangQueryParameter: string;
+    protected searchFilterQueryParameter: string;
+    private readonly locationOrigins;
+    private readonly hasLimitedOriginsConfigured;
+    private readonly i18nKeyPrefix;
+    constructor(context: IGirafeContext, config: GeoAdminChSearchClientConfig);
     private setSearchExtent;
-    requestSearch(term: string, abortController: AbortController): Promise<Feature[]>;
+    getSearchCategories(): Promise<string[]>;
+    protected buildRequestUrl(term: string, filter: string[]): URL;
     protected parseResponse(response: Response): Promise<Feature[]>;
     /**
      * GeoAdmin geoJson responses contain coordinates as [north, east], but the GeoJson standard is [east, north].
@@ -51,7 +57,7 @@ declare class GeoAdminChSearchClient extends AbstractSearchClient {
      */
     private swapCoordinates;
     /**
-     * Property origin contains the result category:
+     * The property `origin` contains the result category.
      */
     groupedResults(results: Feature[]): Record<string, Feature[]>;
     getZoomToBbox(feature: Feature): Extent | undefined;
@@ -59,5 +65,6 @@ declare class GeoAdminChSearchClient extends AbstractSearchClient {
      * Remove bold and italic HTML tags from the label
      */
     private sanitizeHtmlLabel;
+    getI18nKeyForCategory(category: string): string;
 }
 export default GeoAdminChSearchClient;

package/tools/search/geoadminchsearchclient.js

@@ -1,5 +1,6 @@
 import AbstractSearchClient from './abstractsearchclient.js';
 import { transformExtent } from 'ol/proj.js';
+const locationOrigins = ['zipcode', 'gg25', 'district', 'kantone', 'gazetteer', 'address', 'parcel'];
 /**
  * Search provider for the Swiss search service of geo.admin.ch.
  * See documentation at https://docs.geo.admin.ch/access-data/search.html
@@ -28,14 +29,23 @@ import { transformExtent } from 'ol/proj.js';
  *            - parcel
  */
 class GeoAdminChSearchClient extends AbstractSearchClient {
+    searchTermQueryParameter = 'searchText';
+    searchLangQueryParameter = 'lang';
+    searchFilterQueryParameter = 'origins';
+    locationOrigins = locationOrigins;
+    hasLimitedOriginsConfigured = false;
+    i18nKeyPrefix = 'geoadminch_';
     constructor(context, config) {
-        super(context, 'geoadminch', config.providerName, 'https://api3.geo.admin.ch/rest/services/api/SearchServer', 'EPSG:2056');
+        config.url = 'https://api3.geo.admin.ch/rest/services/api/SearchServer';
+        config.resultSrid = 'EPSG:2056';
+        super(context, config);
         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.locationOrigins = config.locationOrigins.split(',');
+            this.hasLimitedOriginsConfigured = true;
         }
         this.setSearchExtent(config.bbox);
     }
@@ -59,18 +69,15 @@ class GeoAdminChSearchClient extends AbstractSearchClient {
         }
         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 getSearchCategories() {
+        return this.locationOrigins;
+    }
+    buildRequestUrl(term, filter) {
+        if (this.hasLimitedOriginsConfigured && !filter.length) {
+            // Apply the limitations to searchable origins from config.json
+            filter = this.locationOrigins;
         }
+        return super.buildRequestUrl(term, filter);
     }
     async parseResponse(response) {
         const data = this.fixGeoAdminCoordinates((await response.json()));
@@ -117,12 +124,12 @@ class GeoAdminChSearchClient extends AbstractSearchClient {
         return coordinates.map(this.swapCoordinates);
     }
     /**
-     * Property origin contains the result category:
+     * The property `origin` contains the result category.
      */
     groupedResults(results) {
         const groupedResults = {};
         for (const result of results) {
-            const group = `geoadminch_${result.get('origin') ?? 'Other'}`;
+            const group = this.getI18nKeyForCategory(result.get('origin') ?? 'other');
             groupedResults[group] ??= [];
             groupedResults[group].push(result);
         }
@@ -143,5 +150,8 @@ class GeoAdminChSearchClient extends AbstractSearchClient {
     sanitizeHtmlLabel(label) {
         return label.replace(/<\/?[ib]>/g, '');
     }
+    getI18nKeyForCategory(category) {
+        return `${this.i18nKeyPrefix}${category}`;
+    }
 }
 export default GeoAdminChSearchClient;

package/tools/search/gmfsearchclient.d.ts

@@ -1,11 +1,8 @@
 import IGirafeContext from '../context/icontext.js';
 import Feature from 'ol/Feature.js';
-import AbstractSearchClient from './abstractsearchclient.js';
-export type GmfSearchConfig = {
+import AbstractSearchClient, { BaseSearchClientConfig } from './abstractsearchclient.js';
+export type GmfSearchClientConfig = BaseSearchClientConfig & {
     type: 'geomapfish';
-    providerName: string;
-    url: string;
-    resultSrid: string;
 };
 /**
  * A search provider for the GeoMapFish backend.
@@ -17,7 +14,22 @@ export type GmfSearchConfig = {
  * - 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);
+    protected searchFilterQueryParameter: string;
+    private readonly layerTreeCategory;
+    constructor(context: IGirafeContext, config: GmfSearchClientConfig);
+    /**
+     * Create the search capabilities URL by using the search URL and appending '/capabilities' to it.
+     */
+    private get searchCapabilitiesUrl();
+    /**
+     * Returns a list of categories that can be searched by
+     */
+    getSearchCategories(): Promise<string[]>;
+    /**
+     * If the search request should filter results by layer tree elements, the URL needs to include an additional parameter
+     * `null_category` to include layer results.
+     */
+    protected buildRequestUrl(term: string, filter: string[]): URL;
     groupedResults(results: Feature[]): Record<string, Feature[]>;
 }
 export default GmfSearchClient;

package/tools/search/gmfsearchclient.js

@@ -9,8 +9,66 @@ import AbstractSearchClient from './abstractsearchclient.js';
  * - resultSrid: The spatial reference system (SRID) of the search results. Default same as map SRID.
  */
 class GmfSearchClient extends AbstractSearchClient {
+    searchFilterQueryParameter = 'categories';
+    layerTreeCategory = 'category_layer_tree';
     constructor(context, config) {
-        super(context, 'geomapfish', config.providerName, config.url, config.resultSrid);
+        super(context, config);
+    }
+    /**
+     * Create the search capabilities URL by using the search URL and appending '/capabilities' to it.
+     */
+    get searchCapabilitiesUrl() {
+        const capabilitiesUrl = new URL(this.url.toString().split('?')[0]);
+        capabilitiesUrl.pathname += '/capabilities';
+        // Reintroduce language and interface parameter
+        const interfaceParameter = this.url.searchParams.get('interface');
+        if (interfaceParameter) {
+            capabilitiesUrl.searchParams.set('interface', interfaceParameter);
+        }
+        if (this.searchLangQueryParameter && this.context.stateManager.state.language) {
+            capabilitiesUrl.searchParams.set(this.searchLangQueryParameter, this.context.stateManager.state.language);
+        }
+        return capabilitiesUrl;
+    }
+    /**
+     * Returns a list of categories that can be searched by
+     */
+    async getSearchCategories() {
+        const response = await fetch(this.searchCapabilitiesUrl);
+        if (response.ok) {
+            try {
+                const content = (await response.json());
+                // Add a fixed category to search layers in the layer tree
+                const categories = content.categories;
+                categories.unshift(this.layerTreeCategory);
+                return categories;
+            }
+            catch (error) {
+                console.warn(`No search categories available: Search capabilities response malformed.\n${error}`);
+            }
+        }
+        else {
+            console.warn('No search categories available: Search capabilities endpoint not reachable.');
+        }
+        return [];
+    }
+    /**
+     * If the search request should filter results by layer tree elements, the URL needs to include an additional parameter
+     * `null_category` to include layer results.
+     */
+    buildRequestUrl(term, filter) {
+        if (!filter.length) {
+            return super.buildRequestUrl(term, filter);
+        }
+        let includeLayerResults = 'false';
+        const modifiedFilter = [...filter];
+        if (modifiedFilter.includes(this.layerTreeCategory)) {
+            modifiedFilter.splice(modifiedFilter.indexOf(this.layerTreeCategory), 1);
+            includeLayerResults = 'true';
+        }
+        const url = super.buildRequestUrl(term, modifiedFilter);
+        url.searchParams.set('null_category', includeLayerResults);
+        return url;
     }
     groupedResults(results) {
         const groupedResults = {};

package/tools/search/searchmanager.d.ts

@@ -8,6 +8,9 @@ export type SearchProviderConfig = {
     providerName: string;
     [key: string]: unknown;
 };
+export interface SearchCategories {
+    [provider: string]: string[];
+}
 declare class SearchManager extends GirafeSingleton {
     protected readonly clients: Map<string, AbstractSearchClient>;
     private abortController;
@@ -17,12 +20,24 @@ declare class SearchManager extends GirafeSingleton {
     constructor(context: IGirafeContext);
     initializeSingleton(): void;
     protected createClient(providerConfig: SearchProviderConfig): void;
+    /**
+     * Returns available search categories per provider.
+     */
+    getSearchCategories(): Promise<SearchCategories | null>;
+    hasFilterShortcutsEnabled(): boolean;
+    /**
+     * Detects whether a search filter shortcut is present in the provided search term.
+     * Updates the search state with the extracted prefix and shortcut if applicable.
+     */
+    detectSearchFilterShortcut(term: string): boolean;
+    private extractFilterPrefixFromTerm;
+    private extractFilterShortcutFromTerm;
     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.
+     * Performs a search operation with all available clients based on the provided term and optional search filters.
+     * Returns results grouped by provider name and result category.
      */
-    doSearch(term: string): Promise<Record<string, Record<string, Feature[]>> | null>;
+    doSearch(term: string, searchFilter?: SearchCategories | null): Promise<Record<string, Record<string, Feature[]>> | null>;
     private createCoordinateSearchResult;
     /**
      * Detects and parses a coordinate search term into an array of two numerical values.
@@ -33,5 +48,6 @@ declare class SearchManager extends GirafeSingleton {
     private parseCoordinateFromString;
     private isCoordinatePairValid;
     getZoomToBbox(feature: Feature): Extent | undefined;
+    getI18nKeyForCategory(providerName: string, category: string): string;
 }
 export default SearchManager;

package/tools/search/searchmanager.js

@@ -36,26 +36,83 @@ class SearchManager extends GirafeSingleton {
                 console.error(`Unknown search type: ${providerConfig.type}`);
         }
     }
+    /**
+     * Returns available search categories per provider.
+     */
+    async getSearchCategories() {
+        const categoriesByProvider = {};
+        await Promise.all(Array.from(this.clients.values()).map(async (client) => {
+            categoriesByProvider[client.providerName] = await client.getSearchCategories();
+        }));
+        // If only no provider or no categories are available, return null instead
+        if (Object.keys(categoriesByProvider).length === 0 ||
+            Object.values(categoriesByProvider).every((categories) => categories.length === 0))
+            return null;
+        return categoriesByProvider;
+    }
+    hasFilterShortcutsEnabled() {
+        const searchConfig = this.context.configManager.Config.search;
+        return (!!searchConfig?.filterEnabled &&
+            !!searchConfig?.filterShortcuts &&
+            !!searchConfig?.filterShortcutPrefix &&
+            !this.context.stateManager.state.interface.isMobile);
+    }
+    /**
+     * Detects whether a search filter shortcut is present in the provided search term.
+     * Updates the search state with the extracted prefix and shortcut if applicable.
+     */
+    detectSearchFilterShortcut(term) {
+        if (!this.hasFilterShortcutsEnabled()) {
+            return false;
+        }
+        term = term.trimStart();
+        const prefix = this.extractFilterPrefixFromTerm(term);
+        this.context.stateManager.state.search.filterShortcutPrefix = prefix;
+        if (prefix) {
+            this.context.stateManager.state.search.filterShortcut = this.extractFilterShortcutFromTerm(term, prefix);
+            return true;
+        }
+        return false;
+    }
+    extractFilterPrefixFromTerm(term) {
+        return (this.context.configManager.Config.search.filterShortcutPrefix.find((prefix) => term.startsWith(prefix)) ?? null);
+    }
+    extractFilterShortcutFromTerm(term, prefix) {
+        const availableShortcuts = this.context.configManager.Config.search?.filterShortcuts ?? {};
+        const shortcutCandidateWithoutPrefix = term.substring(prefix.length).split(' ')[0];
+        const categoriesToActivate = availableShortcuts[shortcutCandidateWithoutPrefix] ?? [];
+        if (categoriesToActivate.length) {
+            // A valid shortcut was detected
+            if (term.startsWith(`${prefix}${shortcutCandidateWithoutPrefix} `)) {
+                // Only when a space is added after the finished shortcut, the search filter is applied
+                return shortcutCandidateWithoutPrefix;
+            }
+        }
+        return null;
+    }
     abortSearch() {
         this.abortController.abort();
     }
     /**
-     * Performs a search operation with all available clients based on the provided term and returns results
-     * grouped by provider name and result category.
+     * Performs a search operation with all available clients based on the provided term and optional search filters.
+     * Returns results grouped by provider name and result category.
      */
-    async doSearch(term) {
+    async doSearch(term, searchFilter = null) {
         // Cancel any previous search
         this.abortSearch();
         // Create a new controller for the new request
         this.abortController = new AbortController();
         let searchResults = null;
-        const coordinates = this.detectCoordinatesInTerm(term);
-        if (coordinates) {
-            searchResults = this.createCoordinateSearchResult(coordinates);
+        term = term.trim();
+        if (!searchFilter) {
+            const coordinates = this.detectCoordinatesInTerm(term);
+            if (coordinates) {
+                searchResults = this.createCoordinateSearchResult(coordinates);
+            }
         }
         if (!searchResults && term.length >= this.minSearchTermLength) {
             const responsesArray = await Promise.all(Array.from(this.clients.values()).map(async (client) => {
-                const response = await client.requestSearch(term, this.abortController);
+                const response = await client.requestSearch(term, searchFilter ? (searchFilter[client.providerName] ?? []) : [], this.abortController);
                 return { [client.providerName]: client.groupedResults(response) };
             }));
             // Merge the responses of multiple clients into a single object that has the client name as key
@@ -95,6 +152,9 @@ class SearchManager extends GirafeSingleton {
      */
     detectCoordinatesInTerm(term) {
         term = term.trim();
+        if (term.length < 3) {
+            return null;
+        }
         let parts = [];
         // Supported separators:
         const separators = [
@@ -137,13 +197,16 @@ class SearchManager extends GirafeSingleton {
         return !!coordinates && coordinates.length === 2 && coordinates.every((coordinate) => Number.isFinite(coordinate));
     }
     getZoomToBbox(feature) {
-        const provider = feature.get('provider');
-        if (this.clients.has(provider)) {
-            return this.clients.get(provider)?.getZoomToBbox(feature);
+        const providerName = feature.get('provider');
+        if (this.clients.has(providerName)) {
+            return this.clients.get(providerName)?.getZoomToBbox(feature);
         }
         else {
             return createBufferedExtentFromFeature(feature);
         }
     }
+    getI18nKeyForCategory(providerName, category) {
+        return this.clients.get(providerName)?.getI18nKeyForCategory(category) ?? category;
+    }
 }
 export default SearchManager;

package/tools/state/graphicalInterface.d.ts

@@ -19,6 +19,7 @@ export default class GraphicalInterface {
     userPreferencesPanelVisible: boolean;
     infoWindowVisible: boolean;
     searchComponentVisible: boolean;
+    searchFilterComponentVisible: boolean;
     basemapComponentVisible: boolean;
     darkMapMode: boolean;
     fullscreenMode: boolean;

package/tools/state/graphicalInterface.js

@@ -19,6 +19,7 @@ export default class GraphicalInterface {
     userPreferencesPanelVisible = false;
     infoWindowVisible = false;
     searchComponentVisible = true;
+    searchFilterComponentVisible = false;
     basemapComponentVisible = true;
     darkMapMode = false;
     fullscreenMode = false;

package/tools/state/state.d.ts

@@ -82,6 +82,13 @@ export type InfoWindow = {
     top: string | number | null;
     left: string | number | null;
 };
+export type SearchState = {
+    filter: {
+        [provider: string]: string[];
+    } | null;
+    filterShortcutPrefix: string | null;
+    filterShortcut: string | null;
+};
 export type ExtendedState = Record<string, object>;
 export default class State {
     /**
@@ -125,6 +132,7 @@ export default class State {
     infoWindow: InfoWindow;
     isOffline: boolean;
     oauth: LoginState;
+    search: SearchState;
     extendedState: ExtendedState;
 }
 export {};

package/tools/state/state.js

@@ -114,6 +114,11 @@ export default class State {
         audience: [],
         somethingChanged: true
     };
+    search = {
+        filter: null,
+        filterShortcutPrefix: null,
+        filterShortcut: null
+    };
     // The State object is defined as <not extensible> by the StateManager.
     // This property can be used by third-parts components or extensions
     // to add custom attributes to the state.

package/tools/tests/mockconfig.d.ts

@@ -33,10 +33,17 @@ export declare const MockConfig: {
         maxExtent: string;
     };
     search: {
-        providers: {
+        providers: ({
             type: string;
             url: string;
-        }[];
+        } | {
+            type: string;
+            url?: undefined;
+        })[];
+        filterShortcutPrefix: string[];
+        filterShortcuts: {
+            adr: string[];
+        };
     };
     share: {
         createUrl: string;