@masterportal/masterportalapi 2.38.0 → 2.40.0

package/CHANGELOG.md

@@ -3,21 +3,61 @@
 
  The [Semantic Versioning](https://semver.org/spec/v2.0.0.html) is used.
 
+## Unreleased - in development
+### __Breaking Changes__
+
+### Added
+
+### Changed
+
+### Deprecated
+
+### Removed
+
+### Fixed
+
+---
+
+## 2.40.0 - 2024-07-17
+
+### Added
+- vectorStyle: enables support for additional polygon highlighting, including default styles.
+
+### Changed
+- Replace `XMLHttpRequest` with `fetch` in `initializeLayerList`
+
+### Fixed
+- OAF-Layer: bbox and bboxCrs are respected when building url.
+- OAF-Layer: prevent url to not use more than one questionmark.
+
+---
+
+## 2.39.0 - 2024-06-18
+
+### Changed
+- peerDependencies:
+    - @cesium/engine: 6.2.0 to 9.2.0
+
+---
+
 ## 2.38.0 - 2024-06-04
 
 ### Added
 - Added support for Node LTS version ^20.12.2 and npm Version ^10.5.0.
+- OAF, GeoJSON: added function loadFeaturesManually.
 
 ### Changed
 - The following packages have been updated:
     - dependencies:
         - ol: 9.1.0 to 9.2.4
         - olcs: 2.19.3 to 2.20.0
+- Exports in src/layer/oaf.js changed to export default {} to provide  ES-Syntax.
 
 ### Fixed
 - The mitigation for issue 666 in ol-cesium since version 2.37.0 is removed
 - Webgl: vectorTiles were not displayed.
 - WMS-Layer: special loadFunction is only used if layer's attribute `isSecured` is true.
+- Issue#1170: checkProperty was not negated, although it should be, so that styling-rules can be properly excluded.
 
 ---
 

package/example/config/services.json

@@ -105,7 +105,8 @@
     "url": "https://api.hamburg.de/datasets/v1/schulen",
     "collection": "staatliche_schulen",
     "typ": "OAF",
-    "crs": "http://www.opengis.net/def/crs/EPSG/0/25832"
+    "crs": "http://www.opengis.net/def/crs/EPSG/0/25832",
+    "bboxCrs": "http://www.opengis.net/def/crs/EPSG/0/25832"
   },
   {
     "id": "8712",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masterportal/masterportalapi",
   "author": "Implementierungspartnerschaft Masterportal <info@masterportal.org> (https://www.masterportal.org)",
-  "version": "2.38.0",
+  "version": "2.40.0",
   "license": "MIT",
   "description": "Basic functions of the Masterportal as api",
   "repository": {
@@ -56,7 +56,7 @@
     "util": "^0.12.5"
   },
   "peerDependencies": {
-    "@cesium/engine": "^6.2.0"
+    "@cesium/engine": "^9.2.0"
   },
   "engines": {
     "node": "^16.13.2 || ^18.12.0 || ^20.12.2",

package/src/index.js

@@ -6,7 +6,7 @@ import wmts from "./layer/wmts";
 import wfs from "./layer/wfs";
 import * as geojson from "./layer/geojson";
 import * as vectorTile from "./layer/vectorTile";
-import * as oaf from "./layer/oaf";
+import oaf from "./layer/oaf";
 import * as terrain from "./layer/terrain";
 import * as entities from "./layer/entities";
 import * as webgl from "./renderer/webgl";

package/src/layer/geojson/index.js

@@ -167,3 +167,28 @@ export function showFeaturesById (layer, featureIdList) {
     hideAllFeatures(layer);
     setFeatureStyle(features, undefined);
 }
+
+/**
+ * Load the features manually.
+ * @param {Object} layerAttributes raw layer attributes.
+ * @param {module:ol/vector/Source} layerSource - the source of the layer
+ * @returns {void}
+ */
+export function loadFeaturesManually (layerAttributes, layerSource) {
+    const getUrl = layerAttributes.url;
+
+    fetch(getUrl, layerSource)
+        .then(response => response.text())
+        .then(responseString => {
+            const features = layerSource.getFormat().readFeatures(responseString);
+
+            layerSource.addFeatures(features);
+            layerSource.dispatchEvent({
+                type: "featuresloadend",
+                features: layerSource.getFeatures()
+            });
+        })
+        .catch(error => {
+            console.error(error);
+        });
+}

package/src/layer/oaf.js

@@ -3,7 +3,6 @@ import {bbox} from "ol/loadingstrategy.js";
 import GeoJSON from "ol/format/GeoJSON.js";
 import {createVectorSource, createClusterVectorSource} from "./vector";
 import {onError, onLoad} from "../lib/wfsUtil";
-import {getParamsUrl} from "../lib/oafUtil";
 import * as webgl from "../renderer/webgl";
 
 /**
@@ -110,20 +109,75 @@ function loadSource (url, source, {onErrorFn, success, failure}, options, collec
         });
 }
 
+/**
+ * Creates the url for OAF request.
+ * @param {rawLayer} rawLayer layer specification as in services.json
+ * @param {object} loadingParams added as params to url
+ * @param {number[]} [extent] the current viewport extent
+ * @returns {string} the url
+ */
+export function createUrl (rawLayer, loadingParams) {
+    const bboxParam = loadingParams?.bbox || rawLayer.bbox,
+        rawUrl = rawLayer.url;
+    let bboxValue = typeof bboxParam === "string" && bboxParam.length ? bboxParam : null,
+        url = null;
+
+    url = new URL(rawUrl);
+    if (typeof rawLayer.collection === "string") {
+        if (!url.pathname.endsWith("/")) {
+            url.pathname += "/collections/" + rawLayer.collection + "/items";
+        }
+        else {
+            url.pathname = "collections/" + rawLayer.collection + "/items";
+        }
+
+    }
+    if (typeof rawLayer.limit === "number") {
+        url.searchParams.set("limit", rawLayer.limit);
+    }
+    if (Array.isArray(bboxParam) && bboxParam.length === 4) {
+        bboxValue = bboxParam.join(",");
+    }
+    if (bboxValue) {
+        url.searchParams.set("bbox", bboxParam);
+        if (typeof rawLayer.bboxCrs === "string" && rawLayer.bboxCrs !== "") {
+            url.searchParams.set("bbox-crs", rawLayer.bboxCrs);
+        }
+    }
+    if (typeof rawLayer.crs === "string") {
+        url.searchParams.set("crs", rawLayer.crs);
+    }
+    if (typeof rawLayer.datetime === "string" && rawLayer.datetime !== "") {
+        url.searchParams.set("datetime", rawLayer.datetime);
+    }
+    if (typeof rawLayer.params === "object" && Object.keys(rawLayer.params).length) {
+        Object.entries(rawLayer.params).forEach(([key, value]) => {
+            url.searchParams.set(key, value);
+        });
+    }
+
+    return url;
+}
+
 /**
  * Creates an ol/source element for the rawLayer by using a loader.
  * The 'featuresloadend' and 'featuresloaderror' events will be fired by using success and failure callbacks of the loader.
  * @param {rawLayer} rawLayer layer specification as in services.json
  * @param {options} [options] additional options
- * @param {String} url the parsed url
  * {@link https://openlayers.org/en/latest/apidoc/module-ol_source_Vector-VectorSource.html failure/success see}
  * @returns {(ol.source.VectorSource|ol.source.Cluster)} VectorSource or Cluster, depending on whether clusterDistance is set.
  */
-function getLayerSource (rawLayer, options, url) {
+function getLayerSource (rawLayer, options) {
     const format = new GeoJSON();
     let source = null;
 
-    function loader (extent, resolution, projection, success, failure) {
+    function loader (extent, _, __, success, failure) {
+        const bboxParam = options.loadingStrategy === bbox ? extent : options.loadingParams.bbox,
+            url = createUrl(rawLayer, {
+                ...options.loadingParams,
+                bbox: bboxParam
+            });
+
         loadSource(url, source, {onErrorFn: onError, success, failure}, options);
     }
     source = createVectorSource(loader, options.loadingStrategy, format);
@@ -138,36 +192,6 @@ function getLayerSource (rawLayer, options, url) {
     return source;
 }
 
-/**
- * Creates the url for OAF request.
- * @param {rawLayer} rawLayer layer specification as in services.json
- * @returns {string} the url
- */
-function createUrl (rawLayer) {
-    let url = rawLayer.url,
-        appendingString;
-    const crsDefault = "";
-
-    url += typeof rawLayer.collection === "string" ? "/collections/" + rawLayer.collection + "/items?" : "";
-    url += typeof rawLayer.limit === "number" ? "limit=" + rawLayer.limit + "&" : "";
-    if (Array.isArray(rawLayer.bbox) && rawLayer.bbox.length === 4) {
-        appendingString = "";
-
-        rawLayer.bbox.forEach((bboxEntry, i) => {
-            appendingString += i !== rawLayer.bbox.length - 1 ? bboxEntry + "," : bboxEntry;
-        });
-        url += "bbox=" + appendingString + "&";
-    }
-    url += typeof rawLayer.bboxCrs === "string" && rawLayer.bboxCrs !== "" ? "bbox-crs=" + encodeURIComponent(rawLayer.bboxCrs) + "&" : "";
-    if (rawLayer.crs !== false) {
-        url += "crs=" + encodeURIComponent(typeof rawLayer.crs === "string" && rawLayer.crs !== "" ? rawLayer.crs : crsDefault) + "&";
-    }
-    url += typeof rawLayer.datetime === "string" && rawLayer.datetime !== "" ? "datetime=" + rawLayer.datetime + "&" : "";
-    url += getParamsUrl(rawLayer.params);
-
-    return url;
-}
-
 /**
  * Creates an ol/source element for the rawLayer by OAF (XML or Geojson)
  * @param {rawLayer} rawLayer layer specification as in services.json
@@ -178,13 +202,11 @@ function createUrl (rawLayer) {
  * {@link https://openlayers.org/en/latest/apidoc/module-ol_source_Vector-VectorSource.html failure/success see}
  * @returns {(ol.source.VectorSource|ol.source.Cluster)} VectorSource or Cluster, depending on whether clusterDistance is set.
  */
-export function createLayerSource (rawLayer, options = {}) {
+function createLayerSource (rawLayer, options = {}) {
     if (!options.loadingStrategy) {
         options.loadingStrategy = bbox;
     }
-
-    const url = createUrl(rawLayer),
-        source = getLayerSource(rawLayer, options, url);
+    const source = getLayerSource(rawLayer, options);
 
     if (rawLayer.renderer === "webgl") {
         source.once("featuresloadend", event => {
@@ -203,7 +225,7 @@ export function createLayerSource (rawLayer, options = {}) {
  * @param {options} [optionalParams.options] - additional options
  * @returns {ol.Layer} Layer that can be added to map.
  */
-export function createLayer (rawLayer = {}, {layerParams = {}, options = {}} = {}) {
+function createLayer (rawLayer = {}, {layerParams = {}, options = {}} = {}) {
     let layer, source;
 
     // use WebGL render pipeline, if specified
@@ -239,3 +261,26 @@ export function createLayer (rawLayer = {}, {layerParams = {}, options = {}} = {
     }
     return layer;
 }
+
+/**
+ * Load the features manually.
+ * @param {Object} layerAttributes raw layer attributes.
+ * @param {module:ol/vector/Source} layerSource - the source of the layer
+ * @returns {void}
+ */
+function loadFeaturesManually (layerAttributes, layerSource) {
+    const getUrl = createUrl(layerAttributes, layerAttributes.version, {getCode: () => layerAttributes.crs}, "");
+
+    fetch(getUrl, layerSource)
+        .then(response => {
+            return response.text();
+        })
+        .then(responseString => {
+            layerSource.addFeatures(layerSource.getFormat().readFeatures(responseString));
+        })
+        .catch(error => {
+            console.error(error);
+        });
+}
+
+export default {createLayer, createLayerSource, createUrl, loadFeaturesManually};

package/src/maps/ol/olMap.js

@@ -8,7 +8,7 @@ import wmts from "../../layer/wmts";
 import * as geojson from "../../layer/geojson";
 import wfs from "../../layer/wfs";
 import * as vectortile from "../../layer/vectorTile";
-import * as oaf from "../../layer/oaf";
+import oaf from "../../layer/oaf";
 import {createMapView} from "../../maps/mapView";
 import rawLayerList from "../../rawLayerList";
 import crs from "../../crs";

package/src/rawLayerList.js

@@ -26,28 +26,25 @@ function initializeLayerList (layerConf = defaults.layerConf, callback) {
     }
 
     // case: parameter is URL
-    const Http = new XMLHttpRequest();
-
-    Http.open("GET", layerConf);
-    Http.timeout = 10000;
-    Http.send();
-    Http.onload = function () {
-        try {
-            layerList = JSON.parse(Http.responseText);
-        }
-        catch (error) {
-            console.error("An error occured when parsing the response after loading '" + layerConf + "':", error);
-            return callback(false, error);
-        }
-        if (typeof callback === "function") {
-            return callback(layerList);
-        }
-        return true;
-    };
-    Http.onerror = function (e) {
-        console.error("An error occured when trying to fetch services from '" + layerConf + "':", e);
-        callback(false, e);
-    };
+    fetch(layerConf, {method: "GET", timeout: 10000})
+        .then((response) => {
+            response.json()
+                .then((json) => {
+                    layerList = json;
+                    if (typeof callback === "function") {
+                        return callback(layerList);
+                    }
+                    return true;
+                })
+                .catch((error) => {
+                    console.error("An error occured when parsing the response after loading '" + layerConf + "':", error);
+                    return callback(false, error);
+                });
+        })
+        .catch((error) => {
+            console.error("An error occured when trying to fetch services from '" + layerConf + "':", error);
+            callback(false, error);
+        });
 }
 
 /**

package/src/vectorStyle/lib/valueOperations.js

@@ -152,7 +152,7 @@ export function checkProperties (feature, rule) {
 
                 key = properties[i].attrName;
 
-                if (checkProperty(featureProperties, key, value)) {
+                if (!checkProperty(featureProperties, key, value)) {
                     return false;
                 }
             }

package/src/vectorStyle/styleList.js

@@ -14,6 +14,7 @@ let styleList,
     configuredTools,
     mapMarkerPointStyleId,
     mapMarkerPolygonStyleId,
+    additionalPolygonStyleId,
     highlightFeaturesPointStyleId,
     highlightFeaturesPolygonStyleId,
     highlightFeaturesLineStyleId,
@@ -140,6 +141,23 @@ function getStyleIdForMapMarkerPolygon () {
     return styleId;
 }
 
+/**
+ * Gets the style id for an additional MapMarker.
+ * If the additionalPolygonStyleId exists, return it; otherwise, returns the default styleId.
+ * @returns {String} - The styleId of the additional MapMarker
+ */
+function getStyleIdForAdditionalMapMarkerPolygon () {
+    let styleId;
+
+    if (additionalPolygonStyleId) {
+        styleId = additionalPolygonStyleId;
+    }
+    else {
+        styleId = "defaultAdditionalMapMarkerPolygon";
+    }
+    return styleId;
+}
+
 /**
  * gets style id from HighlightFeatures
  * @returns {String} - Style id of highlightFeatures.
@@ -186,6 +204,7 @@ function parseStyles (data) {
     dataWithDefaultValue.push({styleId: "default", rules: [{style: {}}]},
         defaultStyle.defaultMapMarkerPoint,
         defaultStyle.defaultMapMarkerPolygon,
+        defaultStyle.defaultAdditionalMapMarkerPolygon,
         defaultStyle.defaultHighlightFeaturesPoint,
         defaultStyle.defaultHighlightFeaturesPolygon,
         defaultStyle.defaultHighlightFeaturesLine);
@@ -193,6 +212,7 @@ function parseStyles (data) {
     styleIds.push(getStyleIdsFromLayers(),
         getStyleIdForMapMarkerPoint(),
         getStyleIdForMapMarkerPolygon(),
+        getStyleIdForAdditionalMapMarkerPolygon(),
         getStyleIdForHighlightFeaturesPoint(),
         getStyleIdForHighlightFeaturesPolygon(),
         getStyleIdForHighlightFeaturesLine(),
@@ -222,6 +242,7 @@ async function initializeStyleList (styleGetters, Config, layers, tools, callbac
 
     mapMarkerPointStyleId = styleGetters.mapMarkerPointStyleId;
     mapMarkerPolygonStyleId = styleGetters.mapMarkerPolygonStyleId;
+    additionalPolygonStyleId = styleGetters.additionalPolygonStyleId;
     highlightFeaturesPointStyleId = styleGetters.highlightFeaturesPointStyleId;
     highlightFeaturesPolygonStyleId = styleGetters.highlightFeaturesPolygonStyleId;
     highlightFeaturesLineStyleId = styleGetters.highlightFeaturesLineStyleId;

package/src/vectorStyle/styles/defaultStyles.js

@@ -137,6 +137,17 @@ const defaultColors = {
                 }
             }]
         },
+        defaultAdditionalMapMarkerPolygon: {
+            styleId: "defaultAdditionalMapMarkerPolygon",
+            rules: [{
+                style: {
+                    polygonStrokeColor: [255, 255, 0, 1],
+                    polygonStrokeWidth: 4,
+                    polygonFillColor: [255, 255, 0, 0.3],
+                    polygonStrokeDash: [8]
+                }
+            }]
+        },
         defaultHighlightFeaturesPoint: {
             styleId: "defaultHighlightFeaturesPoint",
             rules: [{

package/test/layer/geojson/index.test.js

@@ -167,4 +167,34 @@ describe("geojson/index", function () {
             expect(features[1].getStyle()()).toBeNull();
         });
     });
+    describe("loadFeaturesManually", function () {
+        it("loadFeaturesManually shall call fetch", function () {
+            console.error = jest.fn();
+            global.fetch = jest.fn().mockImplementationOnce(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        json: () => {
+                            return [];
+                        }
+                    });
+                });
+            });
+
+            const layerParams = {
+                    id: "id",
+                    url: "url",
+                    featureNS: "http://www.deegree.org/app",
+                    featureType: "krankenhaeuser_hh",
+                    version: "1.0.0"
+                },
+                options = {},
+                layer = geojson.createLayer(layerParams, {options});
+
+            geojson.loadFeaturesManually(layerParams, layer.getSource());
+
+            expect(global.fetch.mock.calls.length).toBe(1);
+        });
+    });
 });

package/test/layer/oaf.test.js

@@ -5,7 +5,7 @@ import {Style, Icon} from "ol/style.js";
 import map from "../../src/maps/map.js";
 import defaults from "../../src/defaults";
 import GeoJSON from "ol/format/GeoJSON.js";
-import * as oaf from "../../src/layer/oaf";
+import oaf from "../../src/layer/oaf";
 import {featureCollection} from "./resources/oafFeatures";
 import * as webgl from "../../src/renderer/webgl.js";
 
@@ -38,7 +38,7 @@ describe("oaf.js", function () {
             const attr = {
                     "id": "id",
                     "name": "Schulen",
-                    "url": "https://url.de",
+                    "url": "https://url",
                     "collection": "staatliche_schulen",
                     "typ": "OAF",
                     "bbox": "",
@@ -137,7 +137,7 @@ describe("oaf.js", function () {
             console.error = consoleError;
         });
         it("creates a GeoJSON VectorSource", function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -153,7 +153,7 @@ describe("oaf.js", function () {
             const rawLayer = {
                     id: "id",
                     name: "Schulen",
-                    url: "https://url.de",
+                    url: "https://url",
                     collection: "staatliche_schulen",
                     typ: "OAF",
                     limit: 10,
@@ -167,7 +167,7 @@ describe("oaf.js", function () {
             expect(layer.getSource().getFormat()).toBeInstanceOf(GeoJSON);
         });
         it("creates a VectorSource and onLoadingError is called", function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: false,
@@ -184,7 +184,7 @@ describe("oaf.js", function () {
             const rawLayer = {
                     id: "id",
                     name: "Schulen",
-                    url: "https://url.de",
+                    url: "https://url",
                     collection: "staatliche_schulen",
                     typ: "OAF",
                     limit: 10,
@@ -206,7 +206,7 @@ describe("oaf.js", function () {
             });
         });
         it("creates a clustered VectorSource and beforeLoading, afterLoading and featuresFilter are called", function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -223,7 +223,7 @@ describe("oaf.js", function () {
                 rawLayer = {
                     id: "id",
                     name: "Schulen",
-                    url: "https://url.de",
+                    url: "https://url",
                     collection: "staatliche_schulen",
                     typ: "OAF",
                     limit: 10,
@@ -259,7 +259,7 @@ describe("oaf.js", function () {
         });
         it("creates a vectorSource with an additional listener, when renderer is \"webgl\"", () => {
             const
-                url = "https://url.de",
+                url = "https://url",
                 rawLayer = {
                     id: "id",
                     url: url,
@@ -287,4 +287,114 @@ describe("oaf.js", function () {
             expect(webgl.afterLoading).toHaveBeenCalledWith(features, layerParams.styleId, layerParams.excludeTypesFromParsing, layerParams.isPointLayer);
         });
     });
+    describe("loadFeaturesManually", function () {
+        it("loadFeaturesManually shall call fetch", function () {
+            console.error = jest.fn();
+            global.fetch = jest.fn().mockImplementation(() => {
+                return new Promise((resolve) => {
+                    resolve({
+                        ok: true,
+                        status: 200,
+                        json: () => {
+                            return featureCollection;
+                        }
+                    });
+                });
+            });
+
+            const rawLayer = {
+                    id: "id",
+                    url: "https://url",
+                    featureNS: "http://www.deegree.org/app",
+                    featureType: "krankenhaeuser_hh",
+                    version: "1.0.0"
+                },
+                options = {},
+                layer = oaf.createLayer(rawLayer, {options});
+
+            oaf.loadFeaturesManually(rawLayer, layer.getSource());
+
+            expect(global.fetch.mock.calls.length).toBe(1);
+        });
+    });
+    describe("createUrl", () => {
+        it("should append bbox, collection, limit, datetime, bboxCrs, and crs, as provided in rawLayer", () => {
+            const rawLayer = {
+                    id: "id",
+                    name: "Schulen",
+                    url: "https://url.de",
+                    collection: "staatliche_schulen",
+                    typ: "OAF",
+                    limit: 10,
+                    bbox: [0, 0, 10, 10],
+                    bboxCrs: "EPSG:4326",
+                    datetime: "123",
+                    crs: "EPSG:25832"
+                },
+                loadingParams = undefined,
+                createdUrl = oaf.createUrl(rawLayer, loadingParams);
+
+            expect(createdUrl.origin).toEqual(rawLayer.url);
+            expect(createdUrl.pathname).toEqual("/collections/" + rawLayer.collection + "/items");
+            expect(createdUrl.searchParams.get("limit")).toEqual("10");
+            expect(createdUrl.searchParams.get("bbox")).toEqual("0,0,10,10");
+            expect(createdUrl.searchParams.get("bbox-crs")).toEqual(rawLayer.bboxCrs);
+            expect(createdUrl.searchParams.get("crs")).toEqual(rawLayer.crs);
+            expect(createdUrl.searchParams.get("datetime")).toEqual(rawLayer.datetime);
+        });
+        it("should append the bbox, if provided as string in rawLayer", () => {
+            const rawLayer = {
+                    id: "id",
+                    name: "Schulen",
+                    url: "https://url.de",
+                    collection: "staatliche_schulen",
+                    typ: "OAF",
+                    bbox: "0,0,10,10",
+                    bboxCrs: "EPSG:4326"
+                },
+                loadingParams = undefined,
+                createdUrl = oaf.createUrl(rawLayer, loadingParams);
+
+            expect(createdUrl.origin).toEqual(rawLayer.url);
+            expect(createdUrl.pathname).toEqual("/collections/" + rawLayer.collection + "/items");
+            expect(createdUrl.searchParams.get("bbox")).toEqual("0,0,10,10");
+            expect(createdUrl.searchParams.get("bbox-crs")).toEqual(rawLayer.bboxCrs);
+        });
+        it("should append the bbox, if provided as string in loadingParams", () => {
+            const rawLayer = {
+                    id: "id",
+                    name: "Schulen",
+                    url: "https://mapservice.regensburg.de/cgi-bin/mapserv?map=wfs.map",
+                    collection: "staatliche_schulen",
+                    typ: "OAF"
+                },
+                loadingParams = {bbox: "0,0,10,10"},
+                createdUrl = oaf.createUrl(rawLayer, loadingParams);
+
+            expect(createdUrl.origin).toEqual("https://mapservice.regensburg.de");
+            expect(createdUrl.pathname).toEqual("/cgi-bin/mapserv/collections/" + rawLayer.collection + "/items");
+            expect(createdUrl.searchParams.get("map")).toEqual("wfs.map");
+            expect(createdUrl.searchParams.get("bbox")).toEqual("0,0,10,10");
+        });
+        it("should append additional key:value filters, if provided as in rawLayer.params", () => {
+            const rawLayer = {
+                    id: "id",
+                    name: "Schulen",
+                    url: "https://url/",
+                    collection: "staatliche_schulen",
+                    typ: "OAF",
+                    params: {
+                        kapitelbezeichnung: "Gymnasien",
+                        anzahl_schueler: ">1000"
+                    }
+                },
+                loadingParams = undefined,
+                createdUrl = oaf.createUrl(rawLayer, loadingParams);
+
+            expect(createdUrl.origin).toEqual("https://url");
+            expect(createdUrl.pathname).toEqual("/collections/" + rawLayer.collection + "/items");
+            expect(createdUrl.searchParams.get("kapitelbezeichnung")).toEqual("Gymnasien");
+            expect(createdUrl.searchParams.get("anzahl_schueler")).toEqual(">1000");
+        });
+    });
 });

package/test/layer/wfs.test.js

@@ -152,7 +152,7 @@ describe("wfs.js", function () {
         });
 
         it("creates a VectorSource and beforeLoading, afterLoading and featuresFilter are called", function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -202,7 +202,7 @@ describe("wfs.js", function () {
             });
         });
         it("creates a VectorSource with doNotLoadInitially", function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -255,7 +255,7 @@ describe("wfs.js", function () {
         it("creates a VectorSource with wfsFilter", function () {
             let secondFetchCalled = false;
 
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -265,7 +265,7 @@ describe("wfs.js", function () {
                         }
                     });
                 });
-            }).mockImplementationOnce(() => {
+            }).mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -317,7 +317,7 @@ describe("wfs.js", function () {
             });
         });
         it("creates a VectorSource and onLoadingError is called", function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 // NOTE: fetch only rejects if a network error occurs, which do not apply to 4xx or 5xx http codes.
                 return new Promise((resolve) => {
                     resolve({
@@ -360,7 +360,7 @@ describe("wfs.js", function () {
             });
         });
         it("creates a clustered VectorSource and beforeLoading, afterLoading and featuresFilter are called", function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,
@@ -442,7 +442,7 @@ describe("wfs.js", function () {
             expect(webgl.afterLoading).toHaveBeenCalledWith(features, layerParams.styleId, layerParams.excludeTypesFromParsing, layerParams.isPointLayer);
         });
         it("creates a vectorSource with credentials: include as params", () => {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 // NOTE: fetch only rejects if a network error occurs, which do not apply to 4xx or 5xx http codes.
                 return new Promise((resolve) => {
                     resolve({
@@ -1068,7 +1068,7 @@ describe("wfs.js", function () {
         });
 
         it("load features manually", async function () {
-            global.fetch = jest.fn().mockImplementationOnce(() => {
+            global.fetch = jest.fn().mockImplementation(() => {
                 return new Promise((resolve) => {
                     resolve({
                         ok: true,

package/test/searchAddress/search.test.js

@@ -33,7 +33,7 @@ jest.mock("../../src/searchAddress/searchGazetteer", () => {
 
 import {searchGazetteer as mockedSearchGazetteer} from "../../src/searchAddress/searchGazetteer";
 
-describe.only("searchAddress", function () {
+describe("searchAddress", function () {
     describe("search", function () {
         it("rejects if missing configuration of what to search for", function (done) {
             search("Pflugacker", {}).catch(e => {

package/src/lib/oafUtil.js

@@ -1,22 +0,0 @@
-/**
- * Parsing the params object in to string for url
- * @param {Object} params the paramters in object
- * @returns {String} The url parameters in string format
- */
-function getParamsUrl (params) {
-    if (!params || typeof params !== "object" || params.constructor !== Object || !Object.keys(params).length) {
-        return "";
-    }
-
-    let paramsUrl = "";
-
-    Object.entries(params).forEach(([key, value]) => {
-        paramsUrl += "&" + key + "=" + value;
-    });
-
-    return paramsUrl;
-}
-
-export {
-    getParamsUrl
-};

package/test/lib/oafUtil.test.js

@@ -1,24 +0,0 @@
-import {getParamsUrl} from "../../src/lib/oafUtil";
-
-describe("oafUtil.js", function () {
-    describe("getParamsUrl", function () {
-        const params = {
-            "anzahl_schueler": ">1000",
-            "bezirk": "Bergedorf"
-        };
-
-        it("should return the parsed paramsUrl", function () {
-            expect(getParamsUrl(params)).toEqual("&anzahl_schueler=>1000&bezirk=Bergedorf");
-        });
-
-        it("should return an empty string", function () {
-            expect(getParamsUrl("string")).toEqual("");
-            expect(getParamsUrl(0)).toEqual("");
-            expect(getParamsUrl(null)).toEqual("");
-            expect(getParamsUrl(undefined)).toEqual("");
-            expect(getParamsUrl(true)).toEqual("");
-            expect(getParamsUrl([])).toEqual("");
-            expect(getParamsUrl({})).toEqual("");
-        });
-    });
-});