@masterportal/masterportalapi 2.62.0 → 2.64.0

package/src/vectorStyle/styles/style.js

@@ -106,9 +106,12 @@ class StyleClass {
         else if (rule?.conditions) {
             let label = "";
 
-            if (rule.conditions?.properties) {
+            if (rule.conditions?.properties && !Array.isArray(rule.conditions.properties)) {
                 label = Object.values(rule.conditions.properties).join(", ");
             }
+            if (Array.isArray(rule.conditions?.properties)) {
+                label = rule.conditions.properties.map(prop => prop.value).join(", ");
+            }
 
             if (rule.conditions?.sequence
                 && Array.isArray(rule.conditions.sequence)
@@ -117,7 +120,6 @@ class StyleClass {
                 && rule.conditions.sequence[1] >= rule.conditions.sequence[0]) {
                 label = label + " (" + rule.conditions.sequence.join("-") + ")";
             }
-
             return label;
         }
 

package/test/lib/attributeMapper.test.js

@@ -54,6 +54,16 @@ describe("src/utils/attributeMapper.js", () => {
                 result: 123
             });
         });
+        it("should map object with 0 as valid numeric value", () => {
+            const mappingObj = {
+                random_int: "count"
+            };
+            const propsWithZero = Object.assign({}, props, {random_int: 0});
+
+            expect(mapAttributes(propsWithZero, mappingObj)).toEqual({
+                count: 0
+            });
+        });
         it("should map object with multiple attributes", () => {
             const mappingObj = {
                 random_text: "text",

package/test/maps/interactions/drawInteraction.test.js

@@ -60,6 +60,16 @@ describe("src/maps/interactions/drawInteraction.js", () => {
 
             expect(mapUnitRadius).toEqual(0.0008983152841195215);
         });
+
+        it("should return the radius unchanged for unknown map units", () => {
+            const radius = 100,
+                mapProjection = {
+                    getUnits: () => "ft"
+                },
+                mapUnitRadius = drawInteractions.transformMapUnitRadius(radius, mapProjection);
+
+            expect(mapUnitRadius).toEqual(100);
+        });
     });
 
     describe("drawInnerCircle", () => {
@@ -87,7 +97,10 @@ describe("src/maps/interactions/drawInteraction.js", () => {
                 fillTransparency: 0,
                 strokeColor: [0, 0, 0],
                 strokeWidth: 1,
-                polygonDash: [4]
+                polygonDash: [4],
+                text: "Text",
+                textFont: "Arial",
+                textFontSize: 10
             };
 
             drawInteractions.setStyleObject(currentLayout);
@@ -111,7 +124,8 @@ describe("src/maps/interactions/drawInteraction.js", () => {
                             lineStrokeColor: [
                                 0,
                                 0,
-                                0
+                                0,
+                                1
                             ],
                             lineStrokeWidth: 1,
                             polygonFillColor: [
@@ -127,7 +141,10 @@ describe("src/maps/interactions/drawInteraction.js", () => {
                             ],
                             polygonStrokeDash: [4],
                             polygonStrokeDashOffset: undefined,
-                            polygonStrokeWidth: 1
+                            polygonStrokeWidth: 1,
+                            text: "Text",
+                            textFont: "Arial",
+                            textFontSize: 10
                         }
                     }
                 ]
@@ -155,6 +172,145 @@ describe("src/maps/interactions/drawInteraction.js", () => {
             expect(drawInteraction).toBeNull();
             expect(drawInteraction).not.toBeInstanceOf(Draw);
         });
+
+        it("should create a draw interaction for writeText", () => {
+            const source = new VectorSource(),
+                drawInteraction = drawInteractions.createDrawInteraction("writeText", source);
+
+            expect(drawInteraction).not.toBeNull();
+            expect(drawInteraction).toBeInstanceOf(Draw);
+        });
+
+        it("should create a draw interaction for each supported drawType", () => {
+            const source = new VectorSource(),
+                supportedTypes = ["box", "circle", "doubleCircle", "line", "pen", "point", "polygon", "writeText", "square"];
+
+            supportedTypes.forEach(type => {
+                const interaction = drawInteractions.createDrawInteraction(type, source);
+
+                expect(interaction).not.toBeNull();
+                expect(interaction).toBeInstanceOf(Draw);
+            });
+        });
+
+        it("should create a draw interaction for an image symbol", () => {
+            const source = new VectorSource(),
+                iconList = [{id: "myIcon", type: "image", value: "/icons/test.svg", scale: 1}],
+                drawInteraction = drawInteractions.createDrawInteraction("myIcon", source, iconList);
+
+            expect(drawInteraction).not.toBeNull();
+            expect(drawInteraction).toBeInstanceOf(Draw);
+        });
+
+        it("should create a draw interaction for a simple_point symbol", () => {
+            const source = new VectorSource(),
+                iconList = [{id: "myPoint", type: "simple_point", value: "simple_point"}];
+
+            drawInteractions.setStyleObject({
+                fillColor: [255, 0, 0],
+                fillTransparency: 0,
+                strokeColor: [0, 0, 0],
+                strokeWidth: 2
+            });
+
+            const drawInteraction = drawInteractions.createDrawInteraction("myPoint", source, iconList);
+
+            expect(drawInteraction).not.toBeNull();
+            expect(drawInteraction).toBeInstanceOf(Draw);
+        });
+    });
+
+    describe("drawOuterCircle", () => {
+        it("should set the outer radius on the feature and add inner circle to source", () => {
+            const source = new VectorSource(),
+                feature = new Feature({geometry: new Circle([0, 0], 10)}),
+                mapProjection = {getUnits: () => "m"},
+                options = {innerRadius: 100, outerRadius: 500, unit: "m"};
+
+            drawInteractions.setStyleObject({
+                fillColor: [55, 126, 184],
+                fillTransparency: 0,
+                strokeColor: [0, 0, 0],
+                strokeWidth: 1
+            });
+            drawInteractions.setStyleObject({
+                fillColor: [0, 0, 0],
+                fillTransparency: 100,
+                strokeColor: [200, 0, 0],
+                strokeWidth: 1
+            }, true);
+
+            drawInteractions.drawOuterCircle(feature, mapProjection, source, options);
+
+            expect(feature.getGeometry().getRadius()).toEqual(500);
+            expect(source.getFeatures().length).toEqual(1);
+            expect(source.getFeatures()[0].getGeometry().getRadius()).toEqual(100);
+        });
+    });
+
+    describe("drawCircle", () => {
+        it("should register drawstart listener for non-interactive circle", () => {
+            const source = new VectorSource(),
+                drawInteraction = drawInteractions.createDrawInteraction("circle", source),
+                mapProjection = {getUnits: () => "m"},
+                options = {innerRadius: 200, interactive: false, outerRadius: 0, unit: "m"};
+
+            drawInteractions.drawCircle(drawInteraction, "circle", mapProjection, source, options);
+
+            expect(drawInteraction.getListeners("drawstart").length).toBeGreaterThan(0);
+        });
+
+        it("should not register additional listener if innerRadius is 0", () => {
+            const source = new VectorSource(),
+                drawInteraction = drawInteractions.createDrawInteraction("circle", source),
+                mapProjection = {getUnits: () => "m"},
+                options = {innerRadius: 0, interactive: false, outerRadius: 0, unit: "m"},
+                listenersBefore = drawInteraction.getListeners("drawstart")?.length || 0;
+
+            drawInteractions.drawCircle(drawInteraction, "circle", mapProjection, source, options);
+
+            const listenersAfter = drawInteraction.getListeners("drawstart")?.length || 0;
+
+            expect(listenersAfter).toEqual(listenersBefore);
+        });
+    });
+
+    describe("setStyleObject", () => {
+        it("should handle fillTransparency correctly", () => {
+            drawInteractions.setStyleObject({
+                fillColor: [255, 0, 0],
+                fillTransparency: 50,
+                strokeColor: [0, 0, 0],
+                strokeWidth: 2
+            });
+
+            expect(styleObject.rules[0].style.polygonFillColor).toEqual([255, 0, 0, 0.5]);
+            expect(styleObject.rules[0].style.lineStrokeColor).toEqual([0, 0, 0, 0.5]);
+        });
+
+        it("should use default text values when not provided", () => {
+            drawInteractions.setStyleObject({
+                fillColor: [0, 0, 0],
+                fillTransparency: 0,
+                strokeColor: [0, 0, 0],
+                strokeWidth: 1
+            });
+
+            expect(styleObject.rules[0].style.text).toEqual("Text");
+            expect(styleObject.rules[0].style.textFont).toEqual("Arial");
+            expect(styleObject.rules[0].style.textFontSize).toEqual(10);
+        });
+
+        it("should set outer circle style when outerCircle is true", () => {
+            drawInteractions.setStyleObject({
+                fillColor: [200, 0, 0],
+                fillTransparency: 100,
+                strokeColor: [200, 0, 0],
+                strokeWidth: 2
+            }, true);
+
+            expect(styleObject.rules[0].style.circleStrokeWidth).toEqual(1);
+        });
     });
 
 });

package/test/maps/interactions/modifyInteraction.test.js

@@ -13,6 +13,34 @@ describe("src/maps/interactions/modifyInteraction.js", () => {
             expect(modifyInteraction).not.toBeNull();
             expect(modifyInteraction).toBeInstanceOf(Modify);
         });
+
+        it("should register optional modify callbacks", () => {
+            const source = new VectorSource(),
+                onModifyStart = jest.fn(),
+                onModifyEnd = jest.fn(),
+                modifyInteraction = modifyInteractions.createModifyInteraction(source, {
+                    onModifyStart,
+                    onModifyEnd
+                });
+
+            modifyInteraction.dispatchEvent("modifystart");
+            modifyInteraction.dispatchEvent("modifyend");
+
+            expect(onModifyStart).toHaveBeenCalledTimes(1);
+            expect(onModifyEnd).toHaveBeenCalledTimes(1);
+        });
+
+        it("should work with only onModifyEnd provided", () => {
+            const source = new VectorSource(),
+                onModifyEnd = jest.fn(),
+                modifyInteraction = modifyInteractions.createModifyInteraction(source, {
+                    onModifyEnd
+                });
+
+            modifyInteraction.dispatchEvent("modifyend");
+
+            expect(onModifyEnd).toHaveBeenCalledTimes(1);
+        });
     });
 
 });

package/test/shared/exportItem.test.js

@@ -0,0 +1,265 @@
+import Feature from "ol/Feature.js";
+import {Point, LineString, Polygon, Circle} from "ol/geom.js";
+import {GeoJSON, GPX} from "ol/format.js";
+import proj4 from "proj4";
+import {register} from "ol/proj/proj4.js";
+import exportItem, {setCsvAttributes} from "../../src/shared/exportItem";
+
+// Register projection used in tests
+proj4.defs("EPSG:25832", "+proj=utm +zone=32 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs");
+register(proj4);
+
+describe("src/shared/exportItem.js", () => {
+    describe("transform", () => {
+        it("transforms line coordinates from source projection to EPSG:4326", () => {
+            const coords = [[565874, 5934140], [566000, 5934200]],
+                result = exportItem.transform("EPSG:25832", coords, false);
+
+            expect(result).toHaveLength(2);
+            result.forEach(point => {
+                expect(point).toHaveLength(2);
+                expect(typeof point[0]).toBe("number");
+                expect(typeof point[1]).toBe("number");
+            });
+        });
+
+        it("transforms polygon coordinates from source projection to EPSG:4326", () => {
+            const coords = [[[565874, 5934140], [566000, 5934200], [566100, 5934100], [565874, 5934140]]],
+                result = exportItem.transform("EPSG:25832", coords, true);
+
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toHaveLength(4);
+        });
+
+        it("handles single-ring polygon correctly", () => {
+            const coords = [[[565874, 5934140], [566000, 5934200], [566100, 5934100], [565874, 5934140]]],
+                result = exportItem.transform("EPSG:25832", coords, true);
+
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toHaveLength(4);
+            result[0].forEach(point => {
+                expect(point).toHaveLength(2);
+                expect(typeof point[0]).toBe("number");
+                expect(typeof point[1]).toBe("number");
+            });
+        });
+
+        it("returns wrapped array for polygon, flat array for line", () => {
+            const lineCoords = [[565874, 5934140], [566000, 5934200]],
+                polyCoords = [[[565874, 5934140], [566000, 5934200], [566100, 5934100], [565874, 5934140]]],
+                lineResult = exportItem.transform("EPSG:25832", lineCoords, false),
+                polyResult = exportItem.transform("EPSG:25832", polyCoords, true);
+
+            // Line result is a flat array of points
+            expect(Array.isArray(lineResult[0])).toBe(true);
+            expect(typeof lineResult[0][0]).toBe("number");
+
+            // Polygon result is wrapped in an extra array
+            expect(Array.isArray(polyResult[0])).toBe(true);
+            expect(Array.isArray(polyResult[0][0])).toBe(true);
+        });
+    });
+
+    describe("transformCoordinates", () => {
+        it("transforms a Point geometry", () => {
+            const geometry = new Point([565874, 5934140]),
+                result = exportItem.transformCoordinates(geometry, "EPSG:25832");
+
+            expect(result).toHaveLength(2);
+            expect(typeof result[0]).toBe("number");
+            expect(typeof result[1]).toBe("number");
+        });
+
+        it("transforms a LineString geometry", () => {
+            const geometry = new LineString([[565874, 5934140], [566000, 5934200]]),
+                result = exportItem.transformCoordinates(geometry, "EPSG:25832");
+
+            expect(result).toHaveLength(2);
+            result.forEach(point => {
+                expect(point).toHaveLength(2);
+            });
+        });
+
+        it("transforms a Polygon geometry", () => {
+            const geometry = new Polygon([[[565874, 5934140], [566000, 5934200], [566100, 5934100], [565874, 5934140]]]),
+                result = exportItem.transformCoordinates(geometry, "EPSG:25832");
+
+            expect(Array.isArray(result)).toBe(true);
+            expect(result).toHaveLength(1);
+        });
+
+        it("returns an empty array for unsupported geometry types", () => {
+            const geometry = {
+                getCoordinates: () => [[[[[0, 0]]]]],
+                getType: () => "MultiPolygon"
+            };
+
+            expect(exportItem.transformCoordinates(geometry, "EPSG:25832")).toEqual([]);
+        });
+    });
+
+    describe("convertFeatures", () => {
+        it("converts features to GeoJSON string", async () => {
+            const feature = new Feature({geometry: new Point([565874, 5934140])}),
+                format = new GeoJSON(),
+                result = await exportItem.convertFeatures([feature], format, "EPSG:25832");
+
+            expect(typeof result).toBe("string");
+            const parsed = JSON.parse(result);
+
+            expect(parsed.type).toBe("FeatureCollection");
+            expect(parsed.features).toHaveLength(1);
+            expect(parsed.features[0].geometry.type).toBe("Point");
+        });
+
+        it("converts multiple features", async () => {
+            const features = [
+                    new Feature({geometry: new Point([565874, 5934140])}),
+                    new Feature({geometry: new LineString([[565874, 5934140], [566000, 5934200]])})
+                ],
+                format = new GeoJSON(),
+                result = await exportItem.convertFeatures(features, format, "EPSG:25832"),
+                parsed = JSON.parse(result);
+
+            expect(parsed.features).toHaveLength(2);
+        });
+
+        it("removes trailing zero from 3D point coordinates", async () => {
+            const feature = new Feature({geometry: new Point([565874, 5934140, 0])}),
+                format = new GeoJSON(),
+                result = await exportItem.convertFeatures([feature], format, "EPSG:25832"),
+                parsed = JSON.parse(result);
+
+            expect(parsed.features[0].geometry.coordinates).toHaveLength(2);
+        });
+
+        it("returns an empty FeatureCollection string for empty array", async () => {
+            const format = new GeoJSON(),
+                result = await exportItem.convertFeatures([], format, "EPSG:25832"),
+                parsed = JSON.parse(result);
+
+            expect(parsed.features).toHaveLength(0);
+        });
+
+        it("preserves drawState in GPX extensions", async () => {
+            const drawState = {
+                    drawType: {id: "drawLine", geometry: "LineString"},
+                    strokeWidth: 4,
+                    colorContour: [12, 34, 56, 1]
+                },
+                feature = new Feature({
+                    geometry: new LineString([[565874, 5934140], [566000, 5934200]]),
+                    masterportal_attributes: {drawState}
+                }),
+                result = await exportItem.convertFeatures([feature], new GPX(), "EPSG:25832");
+
+            expect(result).toContain("masterportal:drawState");
+            expect(result).toContain(JSON.stringify(drawState));
+        });
+    });
+
+    describe("prepareFeatures", () => {
+        it("clones features without modifying the originals", () => {
+            const original = new Feature({geometry: new Point([565874, 5934140])}),
+                result = exportItem.prepareFeatures([original], "EPSG:25832");
+
+            expect(result).toHaveLength(1);
+            expect(result[0]).not.toBe(original);
+        });
+
+        it("converts Circle geometries to Polygons and sets masterportal_attributes", () => {
+            const circle = new Feature({geometry: new Circle([565874, 5934140], 100)}),
+                result = exportItem.prepareFeatures([circle], "EPSG:25832");
+
+            expect(result[0].getGeometry().getType()).toBe("Polygon");
+            expect(result[0].get("masterportal_attributes")).toBeDefined();
+            expect(result[0].get("masterportal_attributes").isGeoCircle).toBe(true);
+            expect(result[0].get("masterportal_attributes").geoCircleCenter).toBeDefined();
+            expect(typeof result[0].get("masterportal_attributes").geoCircleRadius).toBe("number");
+        });
+
+        it("does not modify non-Circle features", () => {
+            const feature = new Feature({geometry: new Point([565874, 5934140])}),
+                result = exportItem.prepareFeatures([feature], "EPSG:25832");
+
+            expect(result[0].getGeometry().getType()).toBe("Point");
+            expect(result[0].get("masterportal_attributes")).toBeUndefined();
+        });
+
+        it("preserves existing masterportal_attributes on Circle features", () => {
+            const circle = new Feature({geometry: new Circle([565874, 5934140], 100)});
+
+            circle.set("masterportal_attributes", {existingKey: "existingValue"});
+            const result = exportItem.prepareFeatures([circle], "EPSG:25832");
+
+            expect(result[0].get("masterportal_attributes").existingKey).toBe("existingValue");
+            expect(result[0].get("masterportal_attributes").isGeoCircle).toBe(true);
+        });
+    });
+
+    describe("setCsvAttributes", () => {
+        it("returns false if features is not an array", () => {
+            expect(setCsvAttributes(undefined)).toBe(false);
+            expect(setCsvAttributes(null)).toBe(false);
+            expect(setCsvAttributes("string")).toBe(false);
+            expect(setCsvAttributes({})).toBe(false);
+            expect(setCsvAttributes(123)).toBe(false);
+        });
+
+        it("sets WKT geometry and EPSG code on csv_attributes", () => {
+            const feature = new Feature({geometry: new Point([565874, 5934140])}),
+                result = setCsvAttributes([feature], "EPSG:25832");
+
+            expect(result).toHaveLength(1);
+            expect(result[0].get("csv_attributes")).toBeDefined();
+            expect(result[0].get("csv_attributes").geometry).toContain("POINT");
+            expect(result[0].get("csv_attributes").epsg).toBe("EPSG:25832");
+        });
+
+        it("converts Circle geometries to Polygon WKT", () => {
+            const feature = new Feature({geometry: new Circle([565874, 5934140], 100)}),
+                result = setCsvAttributes([feature], "EPSG:25832");
+
+            expect(result[0].get("csv_attributes").geometry).toContain("POLYGON");
+        });
+
+        it("copies non-reserved properties to csv_attributes", () => {
+            const feature = new Feature({
+                geometry: new Point([565874, 5934140]),
+                name: "test feature",
+                category: "example"
+            });
+
+            setCsvAttributes([feature], "EPSG:25832");
+            expect(feature.get("csv_attributes").name).toBe("test feature");
+            expect(feature.get("csv_attributes").category).toBe("example");
+        });
+
+        it("does not copy reserved properties to csv_attributes", () => {
+            const feature = new Feature({geometry: new Point([565874, 5934140])});
+
+            feature.set("masterportal_attributes", {some: "data"});
+            setCsvAttributes([feature], "EPSG:25832");
+
+            expect(feature.get("csv_attributes").masterportal_attributes).toBeUndefined();
+            expect(feature.get("csv_attributes").geometry).toContain("POINT");
+        });
+
+        it("skips non-Feature items in the array", () => {
+            const feature = new Feature({geometry: new Point([565874, 5934140])}),
+                result = setCsvAttributes([feature, "not a feature", null], "EPSG:25832");
+
+            expect(result).toHaveLength(3);
+            expect(result[0].get("csv_attributes")).toBeDefined();
+        });
+
+        it("returns the features array on success", () => {
+            const features = [new Feature({geometry: new Point([565874, 5934140])})],
+                result = setCsvAttributes(features, "EPSG:25832");
+
+            expect(result).toBe(features);
+        });
+    });
+});