@masterportal/masterportalapi 2.54.0 → 2.56.0

package/.eslintrc

@@ -4,6 +4,7 @@
         "browser": true,
         "node": true,
         "es6": true,
+        "es2020": true,
         "jest": true
     },
     "globals": {

package/CHANGELOG.md

@@ -2,11 +2,36 @@
  All important changes in this project are stored in this file.
 
  The [Semantic Versioning](https://semver.org/spec/v2.0.0.html) is used.
- 
+
+## 2.56.0 - 2026-01-22
+
+### Changed
+- Terrain-Layer: Removed `this`, uses closures instead.
+
+### Fixed
+- VectorStyle: 
+    - Fixed styling of polygons: `"zig-line-horizontal"` and `"diagonal-right"` are rotated by 90°.
+    - Creating legend and capture event ensures working on EventTarget.
+
+---
+
+## 2.55.0 - 2026-01-09
+
+### Changed
+- Changed Node.js support: Versions from Node.js **22.19.0** up to Node.js **24.12.0** (LTS) are now supported
+
+### Fixed
+- Legend: Shows all information, even for objects that are not yet visible on the map.
+- WMS-Layer: the default tileLoadFunction or imageLoadfunction from openlayers is used, if layer not has the atrribute `isSecured` or `isSecured=false`. If on call of createLayer `layerParams.useFetchForWMS = true`, the overwritten load-function of wms is used.
+- 3D WMS: Remove invalid `cql_filter` values.
+
+---
+
 ## 2.54.0 - 2025-11-26
 
 ### Fixed
 - Restored compatibility for deep imports under @masterportal/masterportalapi/src/* by adding a scoped subpath export in package.json.
+
 ---
 
 ## 2.53.0 - 2025-11-18

package/License.txt

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2018-2023 Freie und Hansestadt Hamburg, Landesbetrieb Geoinformation und Vermessung
+Copyright (c) 2018-2026 Freie und Hansestadt Hamburg, Landesbetrieb Geoinformation und Vermessung
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/example/index.js

@@ -305,7 +305,8 @@ document.getElementById("enable").addEventListener("click", function () {
         document.getElementById("layer-visibility").style.display = "block";
 
         load3DScriptModule.load3DScript(lib, function Loaded3DCallback () {
-            let tilesetLayer = null;
+            let tilesetLayer = null,
+                terrainLayer = null;
 
             const settings3D = {
                     map2D: window.mpapi.map2D,
@@ -335,8 +336,8 @@ document.getElementById("enable").addEventListener("click", function () {
             mpapi.entities.createLayer(rawLayerEntities, window.mpapi.map);
             mpapi.entities.setVisible(true, rawLayerEntities, window.mpapi.map);
 
-            mpapi.terrain.createLayer(rawLayerTerrain, window.mpapi.map);
-            mpapi.terrain.setVisible(true, rawLayerTerrain, window.mpapi.map);
+            terrainLayer = mpapi.terrain.createLayer(rawLayerTerrain, window.mpapi.map);
+            terrainLayer.setVisible(true, rawLayerTerrain, window.mpapi.map);
 
             window.mpapi.map.setEnabled(true);
         });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masterportal/masterportalapi",
   "author": "Implementierungspartnerschaft Masterportal <info@masterportal.org> (https://www.masterportal.org)",
-  "version": "2.54.0",
+  "version": "2.56.0",
   "license": "MIT",
   "description": "Basic functions of the Masterportal as api",
   "repository": {
@@ -19,7 +19,8 @@
       "source": "src/index.js",
       "distDir": "dist",
       "outputFormat": "commonjs"
-    }
+    },
+    "main": false
   },
   "scripts": {
     "test": "jest .test.js --config ./jest.config.js --collectCoverage",
@@ -72,11 +73,12 @@
     "@cesium/engine": "^20.0.1"
   },
   "engines": {
-    "node": "^22.19.0",
-    "npm": "^10.5.0"
+    "node": "^22.19.0 || ^24.11.1",
+    "npm": "^10.5.0 || ^11.6.2"
   },
   "homepage": "https://bitbucket.org/geowerkstatt-hamburg/masterportalapi#readme",
   "directories": {
+    "doc": "docs",
     "example": "example",
     "test": "test"
   },

package/publiccode.yml

@@ -75,14 +75,14 @@ maintenance:
       affiliation:  Freie und Hansestadt Hamburg, Landesbetrieb Geoinformation und Vermessung
   contractors:
     - name: Landesbetrieb Geoinformation und Vermessung
-      until: '2025-12-01'
+      until: '2026-12-01'
       website: 'https://www.hamburg.de/bsw/landesbetrieb-geoinformation-und-vermessung/'
   type: community
 name: Masterportal
 platforms:
   - web
-releaseDate: '2025-11-26'
+releaseDate: '2026-01-22'
 roadmap: 'https://bitbucket.org/geowerkstatt-hamburg/masterportalapi/src/master/'
 softwareType: api
-softwareVersion: 2.54.0
+softwareVersion: 2.56.0
 url: 'https://bitbucket.org/geowerkstatt-hamburg/masterportalapi.git'

package/src/layer/terrain.js

@@ -3,7 +3,7 @@
  * @param {Object} rawLayer  attributes of the layer
  * @param {string} [rawLayer.url] - the URL of the Cesium terrain server
  * @param {string} [rawLayer.cesiumTerrainProviderOptions] - see https://cesiumjs.org/Cesium/Build/Documentation/CesiumTerrainProvider.html
- * @returns {void}
+ * @returns {Promise<Cesium.CesiumTerrainProvider>} the terrain provider
  */
 async function createTerrainProvider (rawLayer) {
     const options = {};
@@ -17,25 +17,6 @@ async function createTerrainProvider (rawLayer) {
     return terrainProvider;
 }
 
-/**
- * Sets the layers visibility by setting the terrain provider at Cesium scene.
- * @param {boolean} value  if true, terrainProvider is set to map and terrain will be visible
- * @param {Object} rawLayer  attributes of the layer
- * @param {string} [rawLayer.url] - the URL of the Cesium terrain server
- * @param {string} [rawLayer.cesiumTerrainProviderOptions] - see https://cesiumjs.org/Cesium/Build/Documentation/CesiumTerrainProvider.html
- * @param {OLCesium} map ol cesium map
- * @returns {void}
- */
-export async function setVisible (value, rawLayer, map) {
-    if (map && typeof map.getCesiumScene === "function") {
-        if (value) {
-            map.getCesiumScene().terrainProvider = await createTerrainProvider(rawLayer);
-        }
-        else {
-            map.getCesiumScene().terrainProvider = new Cesium.EllipsoidTerrainProvider({});
-        }
-    }
-}
 
 /**
  * Creates an terrain layer to use in ol-Cesium map.
@@ -46,21 +27,41 @@ export async function setVisible (value, rawLayer, map) {
  * @returns {Object} layer
  */
 export function createLayer (rawLayer) {
-    this.values = {
-        name: rawLayer.name,
-        id: rawLayer.id,
-        typ: rawLayer.typ
+    const layer = {
+        values: {
+            name: rawLayer.name,
+            id: rawLayer.id,
+            typ: rawLayer.typ
+        },
+        /**
+         * Returns the value for the given key of the rawlayer.
+         * @param {String} key to get the value for
+         * @returns {*} the value to the key
+         */
+        get (key) {
+            return this.values?.[key];
+        },
+        /**
+         * Sets the layers visibility by setting the terrain provider at Cesium scene.
+         * @param {boolean} value  if true, terrainProvider is set to map and terrain will be visible
+         * @param {Object} layerAttributes  attributes of the layer - the raw layer
+         * @param {string} [layerAttributes.url] - the URL of the Cesium terrain server
+         * @param {Object} [layerAttributes.cesiumTerrainProviderOptions] - see https://cesiumjs.org/Cesium/Build/Documentation/CesiumTerrainProvider.html
+         * @param {OLCesium} map ol cesium map
+         * @returns {void}
+         */
+        async setVisible (value, layerAttributes, map) {
+            if (map && typeof map.getCesiumScene === "function") {
+                if (value) {
+                    map.getCesiumScene().terrainProvider = await createTerrainProvider(layerAttributes);
+                }
+                else {
+                    map.getCesiumScene().terrainProvider = new Cesium.EllipsoidTerrainProvider({});
+                }
+            }
+        }
     };
-    return this;
-}
-/**
- * Returns the value for the given key of the rawlayer.
- * @param {String} key to get the value for
- * @returns {*} the value to the key
- */
-export function get (key) {
-    if (!this.values) {
-        return undefined;
-    }
-    return this.values[key];
+
+    return layer;
 }
+

package/src/layer/wms.js

@@ -112,13 +112,15 @@ export function defaultLoadFunction ({isSecured}) {
  * @param {Array} [options.resolutions] - optional resolutions to create the TileGrid, must be in descending order
  * @param {Array} [options.origin] - optional origin to create the TileGrid
  * @param {string} [options.crs] - optional projection code, if not available, projection of map is used
+ * @param {object} layerParams - optional layer params
+ * @param {Array} [layerParams.useFetchForWMS] - if true, fetch is used to load the tiles, else openlayers default load function is used
  * @returns {(ol.source.TileWMS|ol.source.ImageWMS)} TileWMS or ImageWMS, depending on whether singleTile is true.
  */
-export function createLayerSource (rawLayer, options) {
+export function createLayerSource (rawLayer, options, layerParams = {}) {
     const params = makeParams(rawLayer),
         projection = rawLayer.crs ? getProjection(rawLayer.crs) : undefined;
-    let tileGrid = null;
-
+    let tileGrid = null,
+        wmsParams = {};
 
     // Fix for daily updated WMS-Time Layer, which use 'current' as the default value of the time-Extent in their getCapabilities
     // The promise isn't resolved quickly enough for the continued work with the layer.
@@ -128,15 +130,19 @@ export function createLayerSource (rawLayer, options) {
     }
 
     if (rawLayer.singleTile) {
-        return new ImageWMS({
+        wmsParams = {
             url: rawLayer.url,
             params,
             serverType: rawLayer.serverType,
             projection: projection,
             attributions: rawLayer.olAttribution,
-            crossOrigin: rawLayer.crossOrigin,
-            imageLoadFunction: defaultLoadFunction(rawLayer)
-        });
+            crossOrigin: rawLayer.crossOrigin
+        };
+
+        if (rawLayer.isSecured || layerParams.useFetchForWMS) {
+            wmsParams = Object.assign(wmsParams, {imageLoadFunction: defaultLoadFunction(rawLayer)});
+        }
+        return new ImageWMS(wmsParams);
     }
     if (options && options.resolutions) {
         tileGrid = new TileGrid({
@@ -145,16 +151,19 @@ export function createLayerSource (rawLayer, options) {
             tileSize: parseInt(rawLayer.tilesize, 10)
         });
     }
-    return new TileWMS({
+    wmsParams = {
         url: rawLayer.url,
         params,
         gutter: rawLayer.gutter || 0,
         tileGrid: tileGrid,
         projection: projection,
         attributions: rawLayer.olAttribution,
-        crossOrigin: rawLayer.crossOrigin,
-        tileLoadFunction: defaultLoadFunction(rawLayer)
-    });
+        crossOrigin: rawLayer.crossOrigin
+    };
+    if (rawLayer.isSecured || layerParams.useFetchForWMS) {
+        wmsParams = Object.assign(wmsParams, {tileLoadFunction: defaultLoadFunction(rawLayer)});
+    }
+    return new TileWMS(wmsParams);
 }
 
 /**
@@ -178,7 +187,7 @@ export function createLayerSource (rawLayer, options) {
  * @returns {ol.Layer} Layer that can be added to map.
  */
 export function createLayer (rawLayer = {}, {layerParams = {}, options = {}} = {}) {
-    const source = createLayerSource(rawLayer, options),
+    const source = createLayerSource(rawLayer, options, layerParams),
         Layer = rawLayer.singleTile ? ImageLayer : TileLayer;
 
     source.set("olcs_projection", getProjection(OLCS_DEFAULT_OLCS_PROJECTION_CRS));

package/src/maps/olcs/3dUtils/wmsRasterSynchronizer.js

@@ -159,6 +159,10 @@ class WMSRasterSynchronizer extends AbstractSynchronizer {
             },
             tileGrid = source.getTileGrid();
 
+        if (typeof params.CQL_FILTER === "undefined") {
+            delete params.CQL_FILTER;
+        }
+
         if (tileGrid) {
             const ext = olLayer.getExtent();
 

package/src/maps/olcs/olcsMap.js

@@ -26,7 +26,7 @@ export function setCesiumSceneParams (scene, params) {
     }
 
     Object.entries(params).forEach(([key, value]) => {
-        if (["0", "1", "2", "heading", "tilt", "altitude"].includes(key)) {
+        if (["0", "1", "2", "heading", "tilt", "altitude", "pitch"].includes(key)) {
             return;
         }
 

package/src/vectorStyle/createStyle.js

@@ -201,7 +201,7 @@ function captureLegendFromFeature (styleId, legendInformation) {
         legend = {id: styleId, legendInformation: []};
         legendsOfAllStyles.push(legend);
     }
-    else if (styleId === "default" && legend.legendInformation !== legendInformation) {
+    if (styleId === "default" && legend.legendInformation !== legendInformation) {
         legend.legendInformation = legendInformation;
         legendInformationLength = legendInformation.length;
     }
@@ -211,7 +211,7 @@ function captureLegendFromFeature (styleId, legendInformation) {
         const event = new CustomEvent("legendCaptured");
 
         event.id = legend.id;
-        if (this) {
+        if (this instanceof EventTarget && typeof this.dispatchEvent === "function") {
             this.dispatchEvent(event);
         }
     }
@@ -277,14 +277,16 @@ async function returnLegendByStyleId (styleId) {
             resolve(legend);
         }
 
-        this.addEventListener("legendCaptured", event => {
-            if (event.id === styleId && event.id !== "default") {
-                resolve(legendsOfAllStyles.find(element => element.id === event.id));
-            }
-            else if (legend && legend.legendInformation.length === legendInformationLength) {
-                resolve(legendsOfAllStyles.find(element => element.id === event.id));
-            }
-        }, false);
+        if (this) {
+            this.addEventListener("legendCaptured", event => {
+                if (event.id === styleId && event.id !== "default") {
+                    resolve(legendsOfAllStyles.find(element => element.id === event.id));
+                }
+                else if (legend && legend.legendInformation.length === legendInformationLength) {
+                    resolve(legendsOfAllStyles.find(element => element.id === event.id));
+                }
+            }, false);
+        }
     });
 }
 

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

@@ -127,7 +127,7 @@ function rotateContextCenter (context, size, degrees = 90) {
     const halfSize = 0.5 * size;
 
     context.translate(halfSize, halfSize);
-    context.rotate(degrees * (Math.PI / 180));
+    context.rotate(degrees * Math.PI / 180);
     context.translate(-halfSize, -halfSize);
 }
 
@@ -146,13 +146,12 @@ export function drawHatch (context, size, pattern) {
     if (hatchDefinition) {
         const {draw, rotate} = hatchDefinition;
 
-        if (draw) {
-            draw.forEach(segment => drawSegment(context, size, segment));
-        }
-
         if (rotate) {
             rotateContextCenter(context, size, rotate);
         }
+        if (draw) {
+            draw.forEach(segment => drawSegment(context, size, segment));
+        }
     }
     else {
         console.error(`polygonStyleHatches: Unknown polygon style "${pattern}". Skipping hatching.`);

package/test/layer/wms.test.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-underscore-dangle*/
 import {Map, Attribution} from "ol";
 import TileLayer from "ol/layer/Tile";
 import ImageLayer from "ol/layer/Image";
@@ -135,95 +136,112 @@ describe("wms.js", function () {
             expect(input.src).toEqual("blob:BLOB");
         });
     });
-
     describe("createLayerSource", function () {
-        it("creates a TileWMS for multi tile requests", function () {
-            const source = wms.createLayerSource({singleTile: false});
 
-            expect(source).toBeInstanceOf(TileWMS);
-        });
+        describe("createLayerSource", function () {
+            it("creates a TileWMS for multi tile requests uses defaultTileLoadFunction from", function () {
+                const source = wms.createLayerSource({singleTile: false});
 
-        it("creates an ImageWMS for single tile requests", function () {
-            const source = wms.createLayerSource({singleTile: true});
+                expect(source).toBeInstanceOf(TileWMS);
+                expect(source.tileLoadFunction.toString().indexOf("defaultTileLoadFunction") > -1).toEqual(true);
+            });
+            it("creates a TileWMS for multi tile requests - uses defaultLoadFunction", function () {
+                const layerParams = {useFetchForWMS: true},
+                    source = wms.createLayerSource({singleTile: false}, {}, layerParams);
 
-            expect(source).toBeInstanceOf(ImageWMS);
-        });
-        it("creates a LayerSource with crossOrigin set to 'anonymous'", function () {
+                expect(source).toBeInstanceOf(TileWMS);
+                expect(source.tileLoadFunction.toString().indexOf("await fetch") > -1).toEqual(true);
+                expect(source.tileLoadFunction.toString().indexOf("defaultTileLoadFunction") === -1).toEqual(true);
+            });
+
+            it("creates an ImageWMS for single tile requests uses defaultImageLoadFunction from openlayers", function () {
+                const source = wms.createLayerSource({singleTile: true});
+
+                expect(source).toBeInstanceOf(ImageWMS);
+                expect(source.imageLoadFunction_.toString().indexOf("defaultImageLoadFunction") > -1).toEqual(true);
+            });
+            it("creates an ImageWMS for single tile requests - uses defaultLoadFunction", function () {
+                const layerParams = {useFetchForWMS: true},
+                    source = wms.createLayerSource({singleTile: true}, {}, layerParams);
+
+                expect(source).toBeInstanceOf(ImageWMS);
+                expect(source.imageLoadFunction_.toString().indexOf("await fetch") > -1).toEqual(true);
+                expect(source.imageLoadFunction_.toString().indexOf("defaultImageLoadFunction") === -1).toEqual(true);
+            });
+            it("creates a LayerSource with crossOrigin set to 'anonymous'", function () {
             // only relevant for TileWMS and ImageWMS instances
-            const
-                tileWMS = wms.createLayerSource({singleTile: false, crossOrigin: "anonymous"}),
-                imageWMS = wms.createLayerSource({singleTile: true, crossOrigin: "anonymous"});
+                const
+                    tileWMS = wms.createLayerSource({singleTile: false, crossOrigin: "anonymous"}),
+                    imageWMS = wms.createLayerSource({singleTile: true, crossOrigin: "anonymous"});
 
-            // eslint-disable-next-line no-underscore-dangle
-            expect(imageWMS.crossOrigin_).toEqual("anonymous");
-            expect(tileWMS.crossOrigin).toEqual("anonymous");
+                expect(imageWMS.crossOrigin_).toEqual("anonymous");
+                expect(tileWMS.crossOrigin).toEqual("anonymous");
+            });
         });
-    });
-    describe("createLayerSource with a tileGrid", function () {
-        function attrFunction () {
-            return [new Attribution({
-                html: "© " +
+        describe("createLayerSource with a tileGrid", function () {
+            function attrFunction () {
+                return [new Attribution({
+                    html: "© " +
                 "<a href=\"http://www.geo.admin.ch/internet/geoportal/" +
                 "en/home.html\">" +
                 "Pixelmap 1:1000000 / geo.admin.ch</a>"
-            })];
-        }
-        it("creates a TileWMS without tileGrid, options are undefined", function () {
-            const options = undefined,
-                source = wms.createLayerSource({singleTile: false, tilesize: "10"}, options);
-
-            expect(source).toBeInstanceOf(TileWMS);
-            expect(source.getTileGrid()).toEqual(null);
-        });
-        it("creates a TileWMS without tileGrid, options without resolutions", function () {
-            const options = {
-                    origin: [442800, 5809000]
-                },
-                source = wms.createLayerSource({singleTile: false, tilesize: "10"}, options);
-
-            expect(source).toBeInstanceOf(TileWMS);
-            expect(source.getTileGrid()).toEqual(null);
-        });
-        it("creates a TileWMS containing a tileGrid", function () {
-            const options = {
-                    resolutions: [2000, 1000],
-                    origin: [442800, 5809000]
-                },
-                rawLayer = {
-                    singleTile: false,
-                    tilesize: "10",
-                    gutter: "1",
-                    serverType: "geoserver",
-                    url: "https://url.de",
-                    olAttribution: attrFunction
-                },
-                source = wms.createLayerSource(rawLayer, options);
-
-            expect(source).toBeInstanceOf(TileWMS);
-            expect(source.getTileGrid()).toBeInstanceOf(TileGrid);
-            expect(source.getTileGrid().getOrigin()).toEqual(options.origin);
-            expect(source.getTileGrid().getResolutions()).toEqual(options.resolutions);
-            expect(source.getTileGrid().getTileSize()).toEqual(parseInt(rawLayer.tilesize, 10));
-            expect(source.getAttributions()).toBe(attrFunction);
-            expect(source.getUrls()).toEqual([rawLayer.url]);
-            /* eslint-disable no-underscore-dangle */
-            expect(source.gutter_).toEqual(rawLayer.gutter);
-        });
-
-        it("creates an ImageWMS for single tile requests, contains no tileGrid", function () {
-            const rawLayer = {
-                    singleTile: true,
-                    serverType: "geoserver",
-                    url: "https://url.de",
-                    olAttribution: attrFunction
-                },
-                source = wms.createLayerSource(rawLayer);
+                })];
+            }
+            it("creates a TileWMS without tileGrid, options are undefined", function () {
+                const options = undefined,
+                    source = wms.createLayerSource({singleTile: false, tilesize: "10"}, options);
+
+                expect(source).toBeInstanceOf(TileWMS);
+                expect(source.getTileGrid()).toEqual(null);
+            });
+            it("creates a TileWMS without tileGrid, options without resolutions", function () {
+                const options = {
+                        origin: [442800, 5809000]
+                    },
+                    source = wms.createLayerSource({singleTile: false, tilesize: "10"}, options);
+
+                expect(source).toBeInstanceOf(TileWMS);
+                expect(source.getTileGrid()).toEqual(null);
+            });
+            it("creates a TileWMS containing a tileGrid", function () {
+                const options = {
+                        resolutions: [2000, 1000],
+                        origin: [442800, 5809000]
+                    },
+                    rawLayer = {
+                        singleTile: false,
+                        tilesize: "10",
+                        gutter: "1",
+                        serverType: "geoserver",
+                        url: "https://url.de",
+                        olAttribution: attrFunction
+                    },
+                    source = wms.createLayerSource(rawLayer, options);
+
+                expect(source).toBeInstanceOf(TileWMS);
+                expect(source.getTileGrid()).toBeInstanceOf(TileGrid);
+                expect(source.getTileGrid().getOrigin()).toEqual(options.origin);
+                expect(source.getTileGrid().getResolutions()).toEqual(options.resolutions);
+                expect(source.getTileGrid().getTileSize()).toEqual(parseInt(rawLayer.tilesize, 10));
+                expect(source.getAttributions()).toBe(attrFunction);
+                expect(source.getUrls()).toEqual([rawLayer.url]);
+                expect(source.gutter_).toEqual(rawLayer.gutter);
+            });
 
-            expect(source).toBeInstanceOf(ImageWMS);
-            expect(source.getAttributions()).toBe(attrFunction);
-            expect(source.getUrl()).toEqual(rawLayer.url);
-            /* eslint-disable no-underscore-dangle */
-            expect(source.serverType_).toEqual(rawLayer.serverType);
+            it("creates an ImageWMS for single tile requests, contains no tileGrid", function () {
+                const rawLayer = {
+                        singleTile: true,
+                        serverType: "geoserver",
+                        url: "https://url.de",
+                        olAttribution: attrFunction
+                    },
+                    source = wms.createLayerSource(rawLayer);
+
+                expect(source).toBeInstanceOf(ImageWMS);
+                expect(source.getAttributions()).toBe(attrFunction);
+                expect(source.getUrl()).toEqual(rawLayer.url);
+                expect(source.serverType_).toEqual(rawLayer.serverType);
+            });
         });
     });