@masterportal/masterportalapi 2.53.0 → 2.55.0

package/CHANGELOG.md

@@ -2,7 +2,27 @@
  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.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
 
 ### Changed

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masterportal/masterportalapi",
   "author": "Implementierungspartnerschaft Masterportal <info@masterportal.org> (https://www.masterportal.org)",
-  "version": "2.53.0",
+  "version": "2.55.0",
   "license": "MIT",
   "description": "Basic functions of the Masterportal as api",
   "repository": {
@@ -11,14 +11,16 @@
   "source": "src/index.js",
   "main": "src/index.js",
   "exports": {
-    ".": "./src/index.js"
+    ".": "./src/index.js",
+    "./src/*": "./src/*"
   },
   "targets": {
     "library": {
       "source": "src/index.js",
       "distDir": "dist",
       "outputFormat": "commonjs"
-    }
+    },
+    "main": false
   },
   "scripts": {
     "test": "jest .test.js --config ./jest.config.js --collectCoverage",
@@ -71,8 +73,8 @@
     "@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": {

package/publiccode.yml

@@ -81,8 +81,8 @@ maintenance:
 name: Masterportal
 platforms:
   - web
-releaseDate: '2025-11-18'
+releaseDate: '2026-01-09'
 roadmap: 'https://bitbucket.org/geowerkstatt-hamburg/masterportalapi/src/master/'
 softwareType: api
-softwareVersion: 2.53.0
+softwareVersion: 2.55.0
 url: 'https://bitbucket.org/geowerkstatt-hamburg/masterportalapi.git'

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/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;
     }

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);
+            });
         });
     });