@masterportal/masterportalapi 2.15.1 → 2.16.0

package/CHANGELOG.md

@@ -3,6 +3,40 @@
 
  The [Semantic Versioning](https://semver.org/spec/v2.0.0.html) is used.
 
+## 2.16.0 - 2023-03-28
+### Added
+- Added support for `npm` version ^9.1.3.
+
+### Changed
+- The following packages have been updated:
+    - dependencies:
+        - core-js: 3.27.1 to 3.29.1
+        - ol: 7.2.2 to 7.3.0
+        - proj4: 2.8.1 to 2.9.0
+    - devDependencies:
+        - @babel/core: 7.20.12 to 7.21.3
+        - @babel/plugin-transform-modules-commonjs: 7.20.11 to 7.21.2
+        - eslint: 8.31.0 to 8.36.0
+        - jest: 29.3.1 to 29.5.0
+        - jest-environment-jsdom: 29.3.1 to 29.5.0
+        - jsdoc: 4.0.0 to 4.0.2
+        - sass: 1.57.1 to 1.59.3
+
+### Fixed
+- Issue Masterportal.#870: Features with `null` style were shown with default style. However, the default style is only supposed to be used for fallbacks; `null` style features must explicitly be invisible. This has been resolved.
+- Style of legend is now always not clustered.
+
+---
+
+## 2.15.2 - 2023-03-14
+### Changed
+- Update parameters for getGeometryTypeFromService.getGeometryTypeFromWFS and getGeometryTypeFromService.getGeometryTypeFromOAF to pass wfsImgPath.
+
+### Fixed
+- Fix imports in createLegendInfo.js
+
+---
+
 ## 2.15.1 - 2023-03-09
 ### Fixed
 - The `labelField` attribute is now evaluated correctly for a text style.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masterportal/masterportalapi",
   "author": "Implementierungspartnerschaft Masterportal <info@masterportal.org> (https://www.masterportal.org)",
-  "version": "2.15.1",
+  "version": "2.16.0",
   "license": "MIT",
   "description": "Basic functions of the Masterportal as api",
   "repository": {
@@ -19,28 +19,28 @@
     "prepare": "husky install"
   },
   "dependencies": {
-    "core-js": "^3.27.1",
-    "ol": "7.2.2",
+    "core-js": "^3.29.1",
+    "ol": "7.3.0",
     "olcs": "^2.13.1",
-    "proj4": "^2.8.1",
+    "proj4": "^2.9.0",
     "xml2js": "^0.4.23"
   },
   "devDependencies": {
-    "@babel/core": "^7.20.12",
-    "@babel/plugin-transform-modules-commonjs": "^7.20.11",
+    "@babel/core": "^7.21.3",
+    "@babel/plugin-transform-modules-commonjs": "^7.21.2",
     "@parcel/transformer-sass": "^2.6.0",
     "buffer": "^6.0.3",
     "canvas": "^2.11.0",
-    "eslint": "^8.31.0",
+    "eslint": "^8.36.0",
     "events": "^3.3.0",
     "husky": "^8.0.3",
-    "jest": "^29.3.1",
+    "jest": "^29.5.0",
     "jest-canvas-mock": "^2.4.0",
-    "jest-environment-jsdom": "^29.3.1",
-    "jsdoc": "^4.0.0",
+    "jest-environment-jsdom": "^29.5.0",
+    "jsdoc": "^4.0.2",
     "parcel": "^2.6.0",
     "process": "^0.11.10",
-    "sass": "^1.57.1",
+    "sass": "^1.59.3",
     "stream-browserify": "^3.0.0",
     "timers-browserify": "^2.0.12",
     "use-resize-observer": "^9.1.0"
@@ -50,7 +50,7 @@
   },
   "engines": {
     "node": "^16.13.2 || ^18.12.0",
-    "npm": "^8.1.2"
+    "npm": "^8.1.2 || ^9.3.1"
   },
   "homepage": "https://bitbucket.org/geowerkstatt-hamburg/masterportalapi#readme",
   "directories": {

package/src/vectorStyle/createStyle.js

@@ -32,7 +32,8 @@ function getSimpleGeometryStyle (geometryType, feature, rule, isClustered, wfsIm
     const style = rule?.style,
         legendValue = style ? style.legendValue : null,
         alreadyExisitingStyle = uniqueStyles.find(element => element.featureStyle === style && element.geometryType === geometryType);
-    let styleObject;
+    let styleObject,
+        styleObjectForLegend = null;
 
     feature.legendValue = legendValue ? legendValue : null;
 
@@ -41,12 +42,21 @@ function getSimpleGeometryStyle (geometryType, feature, rule, isClustered, wfsIm
     }
     else if (geometryType === "Point") {
         styleObject = new PointStyle(feature, style, isClustered);
+        if (isClustered) {
+            styleObjectForLegend = new PointStyle(feature, style, false);
+        }
     }
     else if (geometryType === "LineString") {
         styleObject = new LineStringStyle(feature, style, isClustered);
+        if (isClustered) {
+            styleObjectForLegend = new LineStringStyle(feature, style, false);
+        }
     }
     else if (geometryType === "Polygon") {
         styleObject = new PolygonStyle(feature, style, isClustered);
+        if (isClustered) {
+            styleObjectForLegend = new PolygonStyle(feature, style, false);
+        }
     }
     else if (geometryType === "Cesium") {
         styleObject = new CesiumStyle(rule);
@@ -63,9 +73,14 @@ function getSimpleGeometryStyle (geometryType, feature, rule, isClustered, wfsIm
         console.warn("Geometry type not implemented: " + geometryType + " default style ist used for feature " + feature);
         return new Style();
     }
+
+    if (styleObjectForLegend !== null) {
+        styleObjectForLegend.initialize(feature, style, false, wfsImgPathFromConfig);
+        styleObjectForLegend.legendValue = legendValue;
+    }
     uniqueStyles.push({featureStyle: style, featureStyleObject: styleObject, geometryType});
     styleObject.initialize(feature, style, isClustered, wfsImgPathFromConfig);
-    styleObject.addLegendInfo(geometryType, styleObject, rule);
+    styleObject.addLegendInfo(geometryType, styleObjectForLegend === null ? styleObject : styleObjectForLegend, rule);
     styleObject.legendValue = legendValue;
     return styleObject;
 }

package/src/vectorStyle/lib/createLegendInfo.js

@@ -1,28 +1,29 @@
-import {getSimpleGeometryStyle, getMultiGeometryStyle} from "../createStyle";
+import createStyle from "../createStyle";
 /**
  * Creates the style objects for the layer
  * @param   {object[]} rules styling rules from the styleObject
  * @param   {string[]} geometryType Array of geometry types
+ * @param   {String} wfsImgPath path to wfsImg from Config
  * @returns {void}
  */
-export function createLegendInfo (rules, geometryType) {
+export function createLegendInfo (rules, geometryType, wfsImgPath) {
     let styleObject,
         simpleGeom;
 
     geometryType.forEach(geom => rules.forEach(rule => {
         if (geom === "MultiSurface") {
             simpleGeom = "Polygon";
-            styleObject = getSimpleGeometryStyle(simpleGeom, "", rule, false);
+            styleObject = createStyle.getSimpleGeometryStyle(simpleGeom, "", rule, false, wfsImgPath);
             return styleObject;
         }
         else if (geom.includes("Multi")) {
             simpleGeom = geom.replace("Multi", "");
-            styleObject = getMultiGeometryStyle(simpleGeom, "", rule, false);
+            styleObject = createStyle.getMultiGeometryStyle(simpleGeom, "", rule, false, wfsImgPath);
             return styleObject;
         }
 
         simpleGeom = geom;
-        styleObject = getSimpleGeometryStyle(simpleGeom, "", rule, false);
+        styleObject = createStyle.getSimpleGeometryStyle(simpleGeom, "", rule, false, wfsImgPath);
         return styleObject;
     }));
 }

package/src/vectorStyle/lib/getGeometryTypeFromService.js

@@ -86,11 +86,12 @@ function getTypeAttributesFromSubelements (subElements = [], styleGeometryType =
 * @param   {string} featureType wfs feature type from layer
 * @param   {string[] | string} styleGeometryType The configured geometry type of the layer
 * @param   {boolean} isSecured true if wfs is secured
+* @param   {String} wfsImgPath path to wfsImg from Config
 * @param {function} [callback] - called with services after loaded; called with false and error on error
 * @returns {void}
 */
 // eslint-disable-next-line max-params
-function getGeometryTypeFromWFS (rules, wfsURL, version, featureType, styleGeometryType, isSecured, callback) {
+function getGeometryTypeFromWFS (rules, wfsURL, version, featureType, styleGeometryType, isSecured, wfsImgPath, callback) {
     const params = {
         "SERVICE": "WFS",
         "VERSION": version,
@@ -114,7 +115,7 @@ function getGeometryTypeFromWFS (rules, wfsURL, version, featureType, styleGeome
             const subElements = getSubelementsFromXML(responseXML, featureType),
                 geometryTypes = getTypeAttributesFromSubelements(subElements, styleGeometryType);
 
-            createLegendInfo(rules, geometryTypes);
+            createLegendInfo(rules, geometryTypes, wfsImgPath);
         }).catch(error => {
             return callback(error);
         });
@@ -125,10 +126,11 @@ function getGeometryTypeFromWFS (rules, wfsURL, version, featureType, styleGeome
  * @param   {object[]} rules styling rules from the styleObject
  * @param   {string} oafURL url from layer
  * @param   {String} collection the collection name to fetch geometry type for
+ * @param   {String} wfsImgPath path to wfsImg from Config
  * @param {function} [callback] - called with services after loaded; called with false and error on error
  * @returns {void}
  */
-function getGeometryTypeFromOAF (rules, oafURL, collection, callback) {
+function getGeometryTypeFromOAF (rules, oafURL, collection, wfsImgPath, callback) {
     const url = oafURL + "/collections/" + collection + "/items?limit=1";
 
     fetch(url, {
@@ -140,7 +142,7 @@ function getGeometryTypeFromOAF (rules, oafURL, collection, callback) {
         const geometryType = response.data?.features[0]?.geometry?.type;
 
         if (geometryType) {
-            createLegendInfo(rules, [geometryType]);
+            createLegendInfo(rules, [geometryType], wfsImgPath);
         }
     }).catch(error => {
         return callback(error);

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

@@ -46,6 +46,10 @@ class PointStyle extends StyleClass {
      * @returns {ol/style} - The created style.
      */
     getStyle () {
+        if (this.nullStyle) {
+            return null;
+        }
+
         const isClustered = this.isClustered;
         let type = this.attributes.type.toLowerCase();
 

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

@@ -52,7 +52,7 @@ export function createIconStyle (attributes, feature, isClustered) {
     if (!showCluster) {
         iconOptions.anchorXUnits = attributes.imageOffsetXUnit;
         iconOptions.anchorYUnits = attributes.imageOffsetYUnit;
-        iconOptions.rotation = getRotationValue(attributes.rotation, feature.getProperties());
+        iconOptions.rotation = feature ? getRotationValue(attributes.rotation, feature.getProperties()) : 0;
     }
 
     return new Style({

package/src/vectorStyle/styles/polygon/stylePolygon.js

@@ -36,6 +36,10 @@ class PolygonStyle extends StyleClass {
      * @returns {ol/style} - The created style.
      */
     getStyle () {
+        if (this.nullStyle) {
+            return null;
+        }
+
         const polygonFillColor = this.attributes.polygonFillColor,
             polygonFillHatch = this.attributes.polygonFillHatch;
 

package/src/vectorStyle/styles/style.js

@@ -14,6 +14,7 @@ class StyleClass {
         this.attributes = {};
         this.legendInfos = [];
         this.styleMultiGeomOnlyWithRule = false;
+        this.nullStyle = false;
     }
 
     /**
@@ -43,12 +44,16 @@ class StyleClass {
         // check if styles object is defined
         // if not, use defaults instead
         if (styles) {
+            this.nullStyle = false;
             Object.keys(styles).forEach(element => {
                 const value = styles[element];
 
                 this.attributes[element] = value;
             });
         }
+        else {
+            this.nullStyle = true;
+        }
     }
 
     /**

package/src/vectorStyle/styles/styleLine.js

@@ -34,6 +34,10 @@ class LineStringStyle extends StyleClass {
      * @returns {ol/style/Style} - The created style.
      */
     getStyle () {
+        if (this.nullStyle) {
+            return null;
+        }
+
         return new Style({
             stroke: new Stroke({
                 lineCap: this.attributes.lineStrokeCap,

package/src/vectorStyle/styles/styleText.js

@@ -36,6 +36,10 @@ class TextStyle extends StyleClass {
     * @returns {ol/style} - The created style.
     */
     getStyle () {
+        if (this.nullStyle) {
+            return null;
+        }
+
         const isClustered = this.isClustered,
             feature = this.feature,
             labelField = this.attributes.labelField;

package/test/vectorStyle/createStyle.test.js

@@ -242,23 +242,69 @@ describe("createStyle", () => {
 });
 
 describe("getSimpleGeometryStyle", function () {
-    it("should return ol point style", function () {
-        expect(createStyle.getSimpleGeometryStyle("Point", jsonObjects[0], rules[0], wfsImgPathFromConfig)).toBeInstanceOf(PointStyle);
-        expect(typeof createStyle.getSimpleGeometryStyle("Point", jsonObjects[0], rules[0], wfsImgPathFromConfig).getStyle().getImage().getStroke().getColor()).toBe("object");
-        expect(createStyle.getSimpleGeometryStyle("Point", jsonObjects[0], rules[0], wfsImgPathFromConfig).getStyle().getImage().getStroke().getColor()).toEqual([0, 0, 0, 1]);
+    let isClustered = false;
+
+    it("should return ol point style - not clustered", function () {
+        const styleObject = createStyle.getSimpleGeometryStyle("Point", jsonObjects[0], rules[0], isClustered, wfsImgPathFromConfig);
+
+        expect(styleObject).toBeInstanceOf(PointStyle);
+        expect(typeof styleObject.getStyle().getImage().getStroke().getColor()).toBe("object");
+        expect(styleObject.getStyle().getImage().getStroke().getColor()).toEqual([255, 0, 0, 1]);
+        expect(styleObject.getLegendInfos()[0].styleObject.circleStrokeColor).toEqual([255, 0, 0, 1]);
+    });
+    it("should return ol linestring style - not clustered", function () {
+        const styleObject = createStyle.getSimpleGeometryStyle("LineString", jsonObjects[1], rules[1], isClustered, wfsImgPathFromConfig);
+
+        expect(styleObject).toBeInstanceOf(LineStringStyle);
+        expect(typeof styleObject.getStyle().getStroke().getColor()).toBe("object");
+        expect(styleObject.getStyle().getStroke().getColor()).toEqual([255, 0, 0, 1]);
+        expect(styleObject.getLegendInfos()[0].styleObject.lineStrokeColor).toEqual([255, 0, 0, 1]);
+    });
+    it("should return ol polygon style - not clustered", function () {
+        const styleObject = createStyle.getSimpleGeometryStyle("Polygon", jsonObjects[2], rules[2], isClustered, wfsImgPathFromConfig);
+
+        expect(styleObject).toBeInstanceOf(PolygonStyle);
+        expect(typeof styleObject.getStyle().getStroke().getColor()).toBe("object");
+        expect(styleObject.getStyle().getStroke().getColor()).toEqual([255, 0, 0, 255]);
+        expect(styleObject.getStyle().getFill().getColor()).toEqual([10, 200, 100, 0.5]);
+        expect(styleObject.getLegendInfos()[0].styleObject.polygonStrokeColor).toEqual([255, 0, 0, 255]);
+        expect(styleObject.getLegendInfos()[0].styleObject.polygonFillColor).toEqual([10, 200, 100, 0.5]);
     });
-    it("should return ol linestring style", function () {
-        expect(createStyle.getSimpleGeometryStyle("LineString", jsonObjects[1], rules[1], wfsImgPathFromConfig)).toBeInstanceOf(LineStringStyle);
-        expect(typeof createStyle.getSimpleGeometryStyle("LineString", jsonObjects[1], rules[1], wfsImgPathFromConfig).getStyle().getStroke().getColor()).toBe("object");
-        expect(createStyle.getSimpleGeometryStyle("LineString", jsonObjects[1], rules[1], wfsImgPathFromConfig).getStyle().getStroke().getColor()).toEqual([255, 0, 0, 1]);
+    it("should return ol default style - not clustered", function () {
+        expect(createStyle.getSimpleGeometryStyle("not exist", jsonObjects[0], null, isClustered, wfsImgPathFromConfig)).toBeInstanceOf(Style);
     });
-    it("should return ol polygon style", function () {
-        expect(createStyle.getSimpleGeometryStyle("Polygon", jsonObjects[2], rules[2], wfsImgPathFromConfig)).toBeInstanceOf(PolygonStyle);
-        expect(typeof createStyle.getSimpleGeometryStyle("Polygon", jsonObjects[2], rules[2], wfsImgPathFromConfig).getStyle().getStroke().getColor()).toBe("object");
-        expect(createStyle.getSimpleGeometryStyle("Polygon", jsonObjects[2], rules[2], wfsImgPathFromConfig).getStyle().getStroke().getColor()).toEqual([255, 0, 0, 255]);
+
+    it("should return ol point style - clustered", function () {
+        isClustered = true;
+        const styleObject = createStyle.getSimpleGeometryStyle("Point", jsonObjects[0], rules[0], isClustered, wfsImgPathFromConfig);
+
+        expect(styleObject).toBeInstanceOf(PointStyle);
+        expect(typeof styleObject).toBe("object");
+        expect(styleObject.getStyle().getImage().getStroke().getColor()).toEqual([0, 0, 0, 1]);
+        expect(styleObject.getLegendInfos()[0].styleObject.circleStrokeColor).toEqual([255, 0, 0, 1]);
+    });
+    it("should return ol linestring style - clustered", function () {
+        isClustered = true;
+        const styleObject = createStyle.getSimpleGeometryStyle("LineString", jsonObjects[1], rules[1], isClustered, wfsImgPathFromConfig);
+
+        expect(styleObject).toBeInstanceOf(LineStringStyle);
+        expect(typeof styleObject.getStyle().getStroke().getColor()).toBe("object");
+        expect(styleObject.getStyle().getStroke().getColor()).toEqual([255, 0, 0, 1]);
+        expect(styleObject.getLegendInfos()[0].styleObject.lineStrokeColor).toEqual([255, 0, 0, 1]);
+    });
+    it("should return ol polygon style - clustered", function () {
+        isClustered = true;
+        const styleObject = createStyle.getSimpleGeometryStyle("Polygon", jsonObjects[2], rules[2], isClustered, wfsImgPathFromConfig);
+
+        expect(styleObject).toBeInstanceOf(PolygonStyle);
+        expect(typeof styleObject.getStyle().getStroke().getColor()).toBe("object");
+        expect(styleObject.getStyle().getStroke().getColor()).toEqual([255, 0, 0, 255]);
+        expect(styleObject.getLegendInfos()[0].styleObject.polygonStrokeColor).toEqual([255, 0, 0, 255]);
+        expect(styleObject.getLegendInfos()[0].styleObject.polygonFillColor).toEqual([10, 200, 100, 0.5]);
     });
-    it("should return ol default style", function () {
-        expect(createStyle.getSimpleGeometryStyle("not exist", jsonObjects[0], null, wfsImgPathFromConfig)).toBeInstanceOf(Style);
+    it("should return ol default style - clustered", function () {
+        isClustered = true;
+        expect(createStyle.getSimpleGeometryStyle("not exist", jsonObjects[0], null, isClustered, wfsImgPathFromConfig)).toBeInstanceOf(Style);
     });
 });
 
@@ -328,8 +374,7 @@ describe("getGeometryStyle", function () {
         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 default style if no rule is found", function () {
-        expect(Array.isArray(createStyle.getGeometryStyle(jsonObjects[0], [], wfsImgPathFromConfig).getStyle().getImage().getStroke().getColor())).toBe(true);
-        expect(createStyle.getGeometryStyle(jsonObjects[0], [], wfsImgPathFromConfig).getStyle().getImage().getStroke().getColor()).toEqual([0, 0, 0, 1]);
+    it("should return null as style if no rule is found", function () {
+        expect(createStyle.getGeometryStyle(jsonObjects[0], [], wfsImgPathFromConfig).getStyle()).toBe(null);
     });
 });