@masterportal/masterportalapi 2.32.0 → 2.34.0

package/CHANGELOG.md

@@ -3,7 +3,34 @@
 
  The [Semantic Versioning](https://semver.org/spec/v2.0.0.html) is used.
 
-### 2.32.0 - 2024-01-17
+## Unreleased - in development
+
+### Added
+### Changed
+### Deprecated
+### Removed
+### Fixed
+
+---
+## 2.34.0 - 2024-03-04
+
+### Changed
+- stylePointCircle.js now has a zIndex of -1 to put unclustered Labels above clustered ones.
+
+---
+
+## 2.33.0 - 2024-02-07
+
+### Changed
+- createStyle: setting style to feature is limited to Point and MultiPoint geometries.
+
+### Fixed
+- 3D: the options are set correctly again for terrain.
+
+---
+
+
+## 2.32.0 - 2024-01-17
 ### Added
 
 ### Changed
@@ -15,31 +42,31 @@
 
 ---
 
-### 2.31.0 - 2023-12-13
-## Added
+## 2.31.0 - 2023-12-13
+### Added
 - Added support for Node LTS version ^20.9.0 and npm Version ^10.1.0.
 
-## Changed
+### Changed
 - WMS-Layer: the attribute extent of rawlayer is set at ol-layer.
 
-## Fixed
+### Fixed
 - OAF-Layer: fix oaf layer in examples
 
 ---
 
-### 2.30.0 - 2023-11-28
-## Changed
+## 2.30.0 - 2023-11-28
+### Changed
 - WMS-Layer and WMTS-Layer: create Layer no longer evaluates the minScale and maxScale attributes, but instead minResolution and maxResolution can be transferred.
 
-## Fixed
+### Fixed
 - Issue Masterportal #1052 VectorStyle: fixed blinking of initial loaded features on great amount of features with a lot of conditional styles.
 - Issue Masterportal #1088: gfiAttibutes with type=html are not displayed if there is no value in the data.
 - Issue Masterportal #1091: VectorStyle: read geometry type from geoserver featureTypeRequest
 
 ---
 
-### 2.29.0 - 2023-10-27
-## Added
+## 2.29.0 - 2023-10-27
+### Added
 - The following packages from parcel automatic were installed for node builtin:
     - dependencies:
         - assert": 2.1.0,
@@ -52,7 +79,7 @@
     - dependencies:
         - ol-mapbox-style: 12.0.0
 
-## Changed
+### Changed
 - The following packages have been updated:
     - dependencies:
         - core-js: 3.32.0 to 3.33.1
@@ -72,35 +99,35 @@
         - sass: 1.64.2 to 1.69.4
 - Revert Cesium.Cesium3DTileset.fromUrl(url, options) adaptions in tileset.js for Cesium v1.107 deprecated warnings
 
-## Fixed
+### Fixed
 - styleList: styles of type oaf are now also added to the stylelist
 - Issue Masterportal #1052 VectorStyle: path to an icon in the map or in the legend in style.json may be an icon name, a relative path to icon, a complete url or an svg.
 
 ---
 
-### 2.28.0 - 2023-09-27
-## Added
+## 2.28.0 - 2023-09-27
+### Added
 - GfiAttributes: GFI Attributes can now be configured as HTML tags, e.g <a>, <img> or <iframe>
 
-## Changed
+### Changed
 - The following packages have been updated:
     - dependencies:
         - ol: 7.5.1 to 7.5.2 (This version fix a bug for vectorTiles with declutter: true)
-## Fixed
+### Fixed
 - Issue Masterportal #1067 VectorStyle: if there is a ? in the services URL, no further one is added
 - Cesium tileset: set visibility and set opacity was fixed.
 - Webgl: set default style for feature and fix the opacity problem
 
 ---
 
-### 2.27.0 - 2023-08-31
-## Changed
+## 2.27.0 - 2023-08-31
+### Changed
 - VectorStyle: 'initializeStyleList' is asynchron, waits for loading finished and returns the loaded styles.
 
 ---
 
-### 2.26.0 - 2023-08-23
-## Changed
+## 2.26.0 - 2023-08-23
+### Changed
 - The following packages have been updated:
     - dependencies:
         - ol: 7.4.0 to 7.5.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masterportal/masterportalapi",
   "author": "Implementierungspartnerschaft Masterportal <info@masterportal.org> (https://www.masterportal.org)",
-  "version": "2.32.0",
+  "version": "2.34.0",
   "license": "MIT",
   "description": "Basic functions of the Masterportal as api",
   "repository": {

package/src/layer/terrain.js

@@ -6,12 +6,13 @@
  * @returns {void}
  */
 async function createTerrainProvider (rawLayer) {
-    const options = {},
-        terrainProvider = await Cesium.CesiumTerrainProvider.fromUrl(rawLayer.url, options);
+    const options = {};
+    let terrainProvider = "";
 
     if (rawLayer.cesiumTerrainProviderOptions) {
         Object.assign(options, rawLayer.cesiumTerrainProviderOptions);
     }
+    terrainProvider = await Cesium.CesiumTerrainProvider.fromUrl(rawLayer.url, options);
 
     return terrainProvider;
 }

package/src/vectorStyle/createStyle.js

@@ -261,7 +261,9 @@ function createStyle (styleObject, feature, isClustered, wfsImgPathFromConfig) {
             styleObjectGeometry.setText(getLabelStyle(feature, style, isClustered));
         }
     }
-    feature.setStyle(styleObjectGeometry);
+    if (feature?.getGeometry().getType() === "Point" || feature?.getGeometry().getType() === "MultiPoint") {
+        feature.setStyle(styleObjectGeometry);
+    }
     return styleObjectGeometry;
 }
 

package/src/vectorStyle/styles/point/stylePointCircle.js

@@ -24,6 +24,7 @@ export function createCircleStyle (attributes, isClustered) {
                 color: strokecolor,
                 width: strokewidth
             })
-        })
+        }),
+        zIndex: -1
     });
 }

package/test/vectorStyle/createStyle.test.js

@@ -5,76 +5,14 @@ import PolygonStyle from "../../src/vectorStyle/styles/polygon/stylePolygon";
 import {Style, Stroke, Fill} from "ol/style.js";
 import {GeoJSON} from "ol/format.js";
 
+let rules,
+    jsonObjects,
+    multiLineStringRules,
+    multiPolygonRules,
+    isClustered;
+
 const wfsImgPathFromConfig = "/path/to/wfs/images",
-    rules = [
-        {
-            conditions: {
-                properties: {
-                    id: "test1"
-                }
-            },
-            style: {
-                legendValue: "legendValueText",
-                circleStrokeColor: [255, 0, 0, 1],
-                type: "circle",
-                lineStrokeColor: [100, 0, 0, 1],
-                polygonStrokeColor: [100, 100, 0, 1]
-            }
-        },
-        {
-            style: {
-                legendValue: "LineStringLegend",
-                lineStrokeColor: [255, 0, 0, 1]
-            }
-        },
-        {
-            style: {
-                legendValue: "PolygonLegend",
-                polygonStrokeColor: [255, 0, 0, 255]
-            }
-        },
-        {
-            conditions: {
-                properties: {
-                    value: [0, 50, "@min", "@max"]
-                }
-            },
-            style: {
-                legendValue: "legendValueText",
-                circleStrokeColor: [255, 0, 0, 1]
-            }
-        },
-        {
-            style: {
-                legendValue: "legendValueText",
-                circleStrokeColor: [255, 255, 255, 1]
-            }
-        }
-    ],
-    multiLineStringRules = [{
-        style: {
-            legendValue: "legendValueText",
-            lineStrokeColor: [255, 255, 255, 1]
-        }
-    },
-    {
-        style: {
-            legendValue: "legendValueText",
-            lineStrokeColor: [255, 0, 0, 1]
-        }
-    }],
-    multiPolygonRules = [{
-        style: {
-            legendValue: "legendValueText",
-            polygonStrokeColor: [100, 100, 0, 1]
-        }
-    },
-    {
-        style: {
-            legendValue: "legendValueText",
-            polygonStrokeColor: [255, 0, 0, 1]
-        }
-    }],
+    defaultStrokeColor = [0, 0, 0, 1],
     geojsonReader = new GeoJSON(),
     jsonFeatures = {
         "type": "FeatureCollection",
@@ -221,8 +159,6 @@ const wfsImgPathFromConfig = "/path/to/wfs/images",
         null;
     });
 
-let jsonObjects;
-
 
 beforeAll(function () {
     jsonObjects = geojsonReader.readFeatures(jsonFeatures);
@@ -231,10 +167,82 @@ afterAll(() => {
     warn.mockReset();
 });
 
+beforeEach(() => {
+    isClustered = false;
+    rules = [
+        {
+            conditions: {
+                properties: {
+                    id: "test1"
+                }
+            },
+            style: {
+                legendValue: "legendValueText",
+                circleStrokeColor: [255, 0, 0, 1],
+                type: "circle",
+                lineStrokeColor: [100, 0, 0, 1],
+                polygonStrokeColor: [100, 100, 0, 1]
+            }
+        },
+        {
+            style: {
+                legendValue: "LineStringLegend",
+                lineStrokeColor: [255, 0, 0, 1]
+            }
+        },
+        {
+            style: {
+                legendValue: "PolygonLegend",
+                polygonStrokeColor: [255, 0, 0, 255]
+            }
+        },
+        {
+            conditions: {
+                properties: {
+                    value: [0, 50, "@min", "@max"]
+                }
+            },
+            style: {
+                legendValue: "legendValueText",
+                circleStrokeColor: [255, 0, 0, 1]
+            }
+        },
+        {
+            style: {
+                legendValue: "legendValueText",
+                circleStrokeColor: [255, 255, 255, 1]
+            }
+        }
+    ];
+    multiLineStringRules = [{
+        style: {
+            legendValue: "legendValueText",
+            lineStrokeColor: [255, 255, 255, 1]
+        }
+    },
+    {
+        style: {
+            legendValue: "legendValueText",
+            lineStrokeColor: [255, 0, 0, 1]
+        }
+    }];
+    multiPolygonRules = [{
+        style: {
+            legendValue: "legendValueText",
+            polygonStrokeColor: [100, 100, 0, 1]
+        }
+    },
+    {
+        style: {
+            legendValue: "legendValueText",
+            polygonStrokeColor: [255, 0, 0, 1]
+        }
+    }];
+});
+
 describe("createStyle", () => {
     it("should return the correct style for a feature", () => {
         const styleObject = {styleId: "myStyle", rules: [{style: {type: "Point"}}]},
-            isClustered = false,
             style = createStyle.createStyle(styleObject, jsonObjects[0], isClustered, wfsImgPathFromConfig);
 
         expect(style).toBeInstanceOf(Style);
@@ -254,7 +262,6 @@ describe("createStyle", () => {
                 }
             }],
             styleObject = {styleId: "styleId", styleMultiGeomOnlyWithRule: true, rules: stylingRules},
-            isClustered = false,
             multiLineStringFeature = jsonObjects[4],
             style = createStyle.createStyle(styleObject, multiLineStringFeature, isClustered, wfsImgPathFromConfig);
 
@@ -263,7 +270,6 @@ describe("createStyle", () => {
         style.forEach(aStyle => {
             expect(aStyle).toBeInstanceOf(Style);
         });
-        expect(multiLineStringFeature.getStyle()).toEqual(style);
     });
 
     it("should return the correct style for a feature with geometry of type MultiPolygon ", () => {
@@ -288,7 +294,6 @@ describe("createStyle", () => {
                 }
             }],
             styleObject = {styleId: "styleId", styleMultiGeomOnlyWithRule: true, rules: stylingRules},
-            isClustered = false,
             multiPolygonFeature = jsonObjects[5],
             style = createStyle.createStyle(styleObject, multiPolygonFeature, isClustered, wfsImgPathFromConfig);
 
@@ -297,7 +302,6 @@ describe("createStyle", () => {
         style.forEach(aStyle => {
             expect(aStyle).toBeInstanceOf(Style);
         });
-        expect(multiPolygonFeature.getStyle()).toEqual(style);
     });
 
     it("should return the correct style for a feature with geometry of type GeometryCollection ", () => {
@@ -322,7 +326,6 @@ describe("createStyle", () => {
                 }
             }],
             styleObject = {styleId: "styleId", styleMultiGeomOnlyWithRule: true, rules: stylingRules},
-            isClustered = false,
             geometryCollectionFeature = jsonObjects[6],
             style = createStyle.createStyle(styleObject, geometryCollectionFeature, isClustered, wfsImgPathFromConfig);
 
@@ -331,7 +334,6 @@ describe("createStyle", () => {
         style.forEach(aStyle => {
             expect(aStyle).toBeInstanceOf(Style);
         });
-        expect(geometryCollectionFeature.getStyle()).toEqual(style);
     });
 
     it("should return the correct style for a feature with geometry of type MultiPoint ", () => {
@@ -356,7 +358,6 @@ describe("createStyle", () => {
                 }
             }],
             styleObject = {styleId: "styleId", styleMultiGeomOnlyWithRule: true, rules: stylingRules},
-            isClustered = false,
             multiPointFeature = jsonObjects[3],
             style = createStyle.createStyle(styleObject, multiPointFeature, isClustered, wfsImgPathFromConfig);
 
@@ -370,8 +371,6 @@ describe("createStyle", () => {
 });
 
 describe("getSimpleGeometryStyle", function () {
-    let isClustered = false;
-
     it("should return ol point style - not clustered", function () {
         const styleObject = createStyle.getSimpleGeometryStyle("Point", jsonObjects[0], rules[0], isClustered, wfsImgPathFromConfig);
 
@@ -408,7 +407,7 @@ describe("getSimpleGeometryStyle", function () {
 
         expect(styleObject).toBeInstanceOf(PointStyle);
         expect(typeof styleObject).toBe("object");
-        expect(styleObject.getStyle().getImage().getStroke().getColor()).toEqual([0, 0, 0, 1]);
+        expect(styleObject.getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
         expect(styleObject.getLegendInfos()[0].styleObject.circleStrokeColor).toEqual([255, 0, 0, 1]);
     });
     it("should return ol linestring style - clustered", function () {
@@ -438,51 +437,157 @@ describe("getSimpleGeometryStyle", function () {
 
 describe("getMultiGeometryStyle", function () {
     it("should return style array for multipoint", function () {
-        expect(Array.isArray(createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, wfsImgPathFromConfig))).toBe(true);
-        expect(createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, wfsImgPathFromConfig).length).toEqual(2);
+        const style = createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(Array.isArray(style)).toBe(true);
+        expect(style.length).toEqual(2);
+    });
+    it("should include ol point style - use defaultStyle for stroke color", function () {
+        delete rules[0].style.circleStrokeColor;
+        const style = createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PointStyle);
+        expect(style[1]).toBeInstanceOf(PointStyle);
+        expect(style[0].getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
+        expect(style[1].getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
     });
-    it("should include ol point style", function () {
-        expect(createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, wfsImgPathFromConfig)[0]).toBeInstanceOf(PointStyle);
-        expect(typeof createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, wfsImgPathFromConfig)[0]).toBe("object");
-        expect(Array.isArray(createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, wfsImgPathFromConfig)[0].getStyle().getImage().getStroke().getColor())).toBe(true);
-        expect(createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, wfsImgPathFromConfig)[0].getStyle().getImage().getStroke().getColor()).toEqual([0, 0, 0, 1]);
+    it("should include ol point style - is clustered and use defaultStyle for stroke color", function () {
+        isClustered = true;
+        delete rules[0].style.circleStrokeColor;
+        const style = createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PointStyle);
+        expect(style[1]).toBeInstanceOf(PointStyle);
+        expect(style[0].getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
+        expect(style[1].getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
+    });
+    it("should include ol point style- use rules for stroke color", function () {
+        const style = createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PointStyle);
+        expect(style[1]).toBeInstanceOf(PointStyle);
+        expect(style[0].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.circleStrokeColor);
+        expect(style[1].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.circleStrokeColor);
+    });
+    it("should include ol point style- is clustered and use rules for stroke color", function () {
+        isClustered = true;
+        rules[0].style.clusterCircleStrokeColor = [1, 2, 3, 4];
+        const style = createStyle.getMultiGeometryStyle("MultiPoint", jsonObjects[3], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PointStyle);
+        expect(style[1]).toBeInstanceOf(PointStyle);
+        expect(style[0].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.clusterCircleStrokeColor);
+        expect(style[1].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.clusterCircleStrokeColor);
     });
     it("should return style array for MultiLineString", function () {
-        expect(Array.isArray(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, wfsImgPathFromConfig))).toBe(true);
-        expect(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, wfsImgPathFromConfig).length).toEqual(2);
+        const style = createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, isClustered, wfsImgPathFromConfig);
+
+        expect(Array.isArray(style)).toBe(true);
+        expect(style.length).toEqual(2);
+    });
+    it("MultiLineString: should include ol line style - use defaultStyle for stroke color", function () {
+        delete multiLineStringRules[0].style.lineStrokeColor;
+        delete multiLineStringRules[1].style.lineStrokeColor;
+        const style = createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(LineStringStyle);
+        expect(style[1]).toBeInstanceOf(LineStringStyle);
+        expect(style[0].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[0].getStyle().getStroke().getColor()).toEqual(defaultStrokeColor);
+        expect(style[1].getStyle().getStroke().getColor()).toEqual(defaultStrokeColor);
     });
-    it("should include ol stroke style", function () {
-        expect(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, wfsImgPathFromConfig)[0]).toBeInstanceOf(LineStringStyle);
-        expect(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, wfsImgPathFromConfig)[0].getStyle().getStroke()).toBeInstanceOf(Stroke);
-        expect(Array.isArray(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, wfsImgPathFromConfig)[0].getStyle().getStroke().getColor())).toBe(true);
-        expect(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, wfsImgPathFromConfig)[0].getStyle().getStroke().getColor()).toEqual([255, 255, 255, 1]);
+    it("MultiLineString: should include ol line style - use rules for stroke color", function () {
+        const style = createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], multiLineStringRules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(LineStringStyle);
+        expect(style[1]).toBeInstanceOf(LineStringStyle);
+        expect(style[0].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[0].getStyle().getStroke().getColor()).toEqual(multiLineStringRules[0].style.lineStrokeColor);
+        expect(style[1].getStyle().getStroke().getColor()).toEqual(multiLineStringRules[0].style.lineStrokeColor);
     });
     it("should return style array for MultiPolygon", function () {
-        expect(Array.isArray(createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, wfsImgPathFromConfig))).toBe(true);
-        expect(createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, wfsImgPathFromConfig).length).toEqual(2);
+        const style = createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, isClustered, wfsImgPathFromConfig);
+
+        expect(Array.isArray(style)).toBe(true);
+        expect(style.length).toEqual(2);
     });
-    it("should include ol polygon style", function () {
-        expect(createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, wfsImgPathFromConfig)[0]).toBeInstanceOf(PolygonStyle);
-        expect(createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, wfsImgPathFromConfig)[0].getStyle().getStroke()).toBeInstanceOf(Stroke);
-        expect(createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, wfsImgPathFromConfig)[0].getStyle().getFill()).toBeInstanceOf(Fill);
-        expect(Array.isArray(createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, wfsImgPathFromConfig)[0].getStyle().getStroke().getColor())).toBe(true);
-        expect(createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, wfsImgPathFromConfig)[0].getStyle().getStroke().getColor()).toEqual([100, 100, 0, 1]);
+    it("should include ol polygon style - use defaultStyle for stroke color", function () {
+        delete multiPolygonRules[0].style.polygonStrokeColor;
+        delete multiPolygonRules[1].style.polygonStrokeColor;
+        const style = createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PolygonStyle);
+        expect(style[0].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[0].getStyle().getFill()).toBeInstanceOf(Fill);
+        expect(style[0].getStyle().getStroke().getColor()).toEqual(defaultStrokeColor);
+        expect(style[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[1].getStyle().getFill()).toBeInstanceOf(Fill);
+        expect(style[1].getStyle().getStroke().getColor()).toEqual(defaultStrokeColor);
+    });
+    it("should include ol polygon style - use rules for stroke color", function () {
+        const style = createStyle.getMultiGeometryStyle("MultiPolygon", jsonObjects[5], multiPolygonRules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PolygonStyle);
+        expect(style[0].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[0].getStyle().getFill()).toBeInstanceOf(Fill);
+        expect(style[0].getStyle().getStroke().getColor()).toEqual(multiPolygonRules[0].style.polygonStrokeColor);
+        expect(style[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[1].getStyle().getFill()).toBeInstanceOf(Fill);
+        expect(style[1].getStyle().getStroke().getColor()).toEqual(multiPolygonRules[0].style.polygonStrokeColor);
     });
     it("should return style array for GeometryCollection", function () {
-        expect(Array.isArray(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, wfsImgPathFromConfig))).toBe(true);
-        expect(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, wfsImgPathFromConfig).length).toEqual(2);
+        const style = createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(Array.isArray(style)).toBe(true);
+        expect(style.length).toEqual(2);
     });
-    it("should include ol line and point style", function () {
-        expect(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, wfsImgPathFromConfig)[0]).toBeInstanceOf(PointStyle);
-        expect(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], multiLineStringRules, wfsImgPathFromConfig)[1]).toBeInstanceOf(LineStringStyle);
-        expect(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, wfsImgPathFromConfig)[0].getStyle().getImage().getStroke()).toBeInstanceOf(Stroke);
-        expect(Array.isArray(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, wfsImgPathFromConfig)[0].getStyle().getImage().getStroke().getColor())).toBe(true);
-        expect(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, wfsImgPathFromConfig)[0].getStyle().getImage().getStroke().getColor()).toEqual([0, 0, 0, 1]);
-        expect(createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], multiLineStringRules, wfsImgPathFromConfig)[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+    it("should include ol line and point style - use defaultStyle for stroke color", function () {
+        delete rules[0].style.circleStrokeColor;
+        delete rules[0].style.lineStrokeColor;
+        delete multiLineStringRules[0].style.lineStrokeColor;
+        const style = createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, isClustered, wfsImgPathFromConfig),
+            multiLineStyle = createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], multiLineStringRules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PointStyle);
+        expect(style[0].getStyle().getImage().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[0].getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
+        expect(style[1]).toBeInstanceOf(LineStringStyle);
+        expect(style[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[1].getStyle().getStroke().getColor()).toEqual(defaultStrokeColor);
+
+        expect(multiLineStyle[0]).toBeInstanceOf(PointStyle);
+        expect(multiLineStyle[0].getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
+        expect(multiLineStyle[1]).toBeInstanceOf(LineStringStyle);
+        expect(multiLineStyle[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(multiLineStyle[1].getStyle().getStroke().getColor()).toEqual(defaultStrokeColor);
+    });
+    it("should include ol line and point style - use rules for stroke color", function () {
+        const style = createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], rules, isClustered, wfsImgPathFromConfig),
+            multiLineStyle = createStyle.getMultiGeometryStyle("GeometryCollection", jsonObjects[6], multiLineStringRules, isClustered, wfsImgPathFromConfig);
+
+        expect(style[0]).toBeInstanceOf(PointStyle);
+        expect(style[0].getStyle().getImage().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[0].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.circleStrokeColor);
+        expect(style[1]).toBeInstanceOf(LineStringStyle);
+        expect(style[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(style[1].getStyle().getStroke().getColor()).toEqual(rules[0].style.lineStrokeColor);
+
+        expect(multiLineStyle[0]).toBeInstanceOf(PointStyle);
+        // multiLineStringRules[0].style.circleStrokeColor is not defined --> use defaultStrokeColor
+        expect(multiLineStyle[0].getStyle().getImage().getStroke().getColor()).toEqual(defaultStrokeColor);
+        expect(multiLineStyle[1]).toBeInstanceOf(LineStringStyle);
+        expect(multiLineStyle[1].getStyle().getStroke()).toBeInstanceOf(Stroke);
+        expect(multiLineStyle[1].getStyle().getStroke().getColor()).toEqual(multiLineStringRules[0].style.lineStrokeColor);
     });
-    it("features with more geometries than rules (rules: 1, geometries: 2) should have style for all geometries - styleMultiGeomOnlyWithRule=false", function () {
-        expect(Array.isArray(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], rulesWithOneEntry, wfsImgPathFromConfig))).toBe(true);
-        expect(createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], rulesWithOneEntry, wfsImgPathFromConfig).length).toEqual(2);
+    it("features with more geometries than rules (rules: 1, geometries: 2) should have style for all geometries - 'styleMultiGeomOnlyWithRule' is not set", function () {
+        const style = createStyle.getMultiGeometryStyle("MultiLineString", jsonObjects[4], rulesWithOneEntry, isClustered, wfsImgPathFromConfig);
+
+        expect(Array.isArray(style)).toBe(true);
+        expect(style.length).toEqual(2);
+        expect(style[0].getStyle().getStroke().getColor()).toEqual(rulesWithOneEntry[0].style.lineStrokeColor);
+        expect(style[1].getStyle()).toEqual(null);
     });
 });
 
@@ -497,12 +602,22 @@ describe("isMultiGeometry", function () {
 });
 
 describe("getGeometryStyle", function () {
-    it("should return ol style with correct settings", function () {
-        expect(createStyle.getGeometryStyle(jsonObjects[0], rules, wfsImgPathFromConfig)).toBeInstanceOf(PointStyle);
-        expect(Array.isArray(createStyle.getGeometryStyle(jsonObjects[0], rules, wfsImgPathFromConfig).getStyle().getImage().getStroke().getColor())).toBe(true);
-        expect(createStyle.getGeometryStyle(jsonObjects[0], rules, wfsImgPathFromConfig).getStyle().getImage().getStroke().getColor()).toEqual([0, 0, 0, 1]);
+    it("should return point style with correct settings", function () {
+        const style = createStyle.getGeometryStyle(jsonObjects[0], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(style).toBeInstanceOf(PointStyle);
+        expect(Array.isArray(style.getStyle().getImage().getStroke().getColor())).toBe(true);
+        expect(style.getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.circleStrokeColor);
+    });
+    it("should return 'MultiPoint' style with correct settings", function () {
+        const style = createStyle.getGeometryStyle(jsonObjects[3], rules, isClustered, wfsImgPathFromConfig);
+
+        expect(Array.isArray(style)).toBe(true);
+        expect(style.length).toEqual(2);
+        expect(style[0].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.circleStrokeColor);
+        expect(style[1].getStyle().getImage().getStroke().getColor()).toEqual(rules[0].style.circleStrokeColor);
     });
     it("should return null as style if no rule is found", function () {
-        expect(createStyle.getGeometryStyle(jsonObjects[0], [], wfsImgPathFromConfig).getStyle()).toBe(null);
+        expect(createStyle.getGeometryStyle(jsonObjects[0], [], isClustered, wfsImgPathFromConfig).getStyle()).toBe(null);
     });
 });