@geogirafe/lib-geoportal 1.0.2170130456 → 1.0.2178444470

package/components/infobox/component.d.ts

@@ -4,8 +4,10 @@ declare class InfoboxComponent extends GirafeHTMLElement {
     template: () => import("uhtml").Hole;
     infos: InfoBoxContent[];
     urlRegExp: RegExp;
+    private readonly autoCloseTimers;
     constructor();
     registerEvents(): void;
+    private setupAutoClose;
     closeMessage(info: InfoBoxContent): void;
     linkify(str: string): string;
     connectedCallback(): void;

package/components/infobox/component.js

@@ -11,14 +11,45 @@ class InfoboxComponent extends GirafeHTMLElement {
     };
     infos = [];
     urlRegExp = /(https?:\/\/[^"<]*?(?=\s|$|<\/[^a]>))/gi;
+    // Each message can have a seperate timer or be persistent (until closed by user)
+    autoCloseTimers = new Map();
     constructor() {
         super('infobox');
     }
     registerEvents() {
-        this.subscribe('infobox.elements', () => super.refreshRender());
+        this.subscribe('infobox.elements', () => {
+            super.refreshRender();
+            this.setupAutoClose();
+        });
+    }
+    setupAutoClose() {
+        const elements = this.state.infobox.elements ?? [];
+        elements.forEach((info) => {
+            const duration = info.duration;
+            // No duration specified (persistent)
+            if (!duration) {
+                return;
+            }
+            if (this.autoCloseTimers.has(info.id)) {
+                return;
+            }
+            const timerId = globalThis.setTimeout(() => {
+                this.autoCloseTimers.delete(info.id);
+                this.closeMessage(info);
+            }, duration);
+            this.autoCloseTimers.set(info.id, timerId);
+        });
     }
     closeMessage(info) {
-        this.state.infobox.elements.splice(this.state.infobox.elements.findIndex((el) => el.id === info.id), 1);
+        const timerId = this.autoCloseTimers.get(info.id);
+        if (timerId !== undefined) {
+            clearTimeout(timerId);
+            this.autoCloseTimers.delete(info.id);
+        }
+        const index = this.state.infobox.elements.findIndex((el) => el.id === info.id);
+        if (index !== -1) {
+            this.state.infobox.elements.splice(index, 1);
+        }
     }
     linkify(str) {
         if (this.urlRegExp.test(str)) {

package/components/print/tools/MFPEncoder.d.ts

@@ -1,4 +1,5 @@
-import type { BaseCustomizer, MFPLayer, MFPImageLayer, MFPMap, MFPWmtsLayer } from '@geoblocks/mapfishprint';
+import type { BaseCustomizer, MFPLayer, MFPMap, MFPWmtsLayer, MFPWmsLayer } from '@geoblocks/mapfishprint';
+import GroupLayer from '../../../models/layers/grouplayer';
 import type BaseLayer from '../../../models/layers/baselayer';
 import MapManager from '../../../tools/state/mapManager';
 import State from '../../../tools/state/state';
@@ -53,16 +54,25 @@ export default class MFPEncoder {
      * @returns A promise that resolves to an array of MFP layers, a single MFP layer, or null.
      */
     encodeLayer(layer: BaseLayer): MFPLayer[] | MFPLayer | null;
+    /**
+     * Only non mixed groups of WMS layers are supported.
+     *
+     * Will convert a group of WMS layers sharing the same OGC server into a single MFPWmsLayer
+     * where its 'layers' property is a concatenation of all child layers' 'layers' property.
+     *
+     * @param groupLayer
+     */
+    encodeGroupLayer(groupLayer: GroupLayer): MFPWmsLayer | null;
     /**
      * Encodes an image layer from a WMS layer object.
      * @returns The encoded image layer or null if the layer is not visible.
      */
-    encodeImageLayer(layerWms: LayerWms): MFPImageLayer | null;
+    encodeWmsLayer(layerWms: LayerWms): MFPWmsLayer | null;
     /**
-     * Encodes a WMTS layer into a MFPWmtsLayer or MFPImageLayer object.
+     * Encodes a WMTS layer into a MFPWmtsLayer or MFPWmsLayer object.
      * @returns The encoded layer object, or null if the layer is not visible.
      */
-    encodeTileWmtsLayer(layerWmts: LayerWmts): MFPWmtsLayer | MFPImageLayer | null;
+    encodeTileWmtsLayer(layerWmts: LayerWmts): MFPWmtsLayer | MFPWmsLayer | null;
     /**
      * Encodes a local file layer.
      * @returns The encoded local file layer or null if the layer is not visible.
@@ -72,5 +82,5 @@ export default class MFPEncoder {
      * Encodes a WMS layer from a WMTS layer.
      * @returns The encoded WMS layer or null if the ogcServer is missing.
      */
-    encodeWmsFromWmtsLayer(layerWmts: LayerWmts): MFPImageLayer | null;
+    encodeWmsFromWmtsLayer(layerWmts: LayerWmts): MFPWmsLayer | null;
 }

package/components/print/tools/MFPEncoder.js

@@ -1,3 +1,4 @@
+import GroupLayer from '../../../models/layers/grouplayer';
 import { getAbsoluteUrl, getWmtsMatrices, getWmtsUrl, MFPVectorEncoder } from '@geoblocks/mapfishprint';
 import { toDegrees } from 'ol/math';
 import LayerLocalFile from '../../../models/layers/layerlocalfile';
@@ -59,9 +60,18 @@ export default class MFPEncoder {
      */
     getFlatLayers(baseLayers) {
         return baseLayers.reduce((layers, layer) => {
-            if (layer.children) {
-                const resultLayers = this.getFlatLayers(layer.children);
-                layers.push(...resultLayers);
+            const children = layer.children;
+            if (children) {
+                const group = layer;
+                // If all the children have the same ogcServer and the group
+                // has no grandchildren, we keep the layers together
+                if (group.isMixed === false && group.hasGrandChildren === false) {
+                    layers.push(group);
+                }
+                else {
+                    const resultLayers = this.getFlatLayers(group.children);
+                    layers.push(...resultLayers);
+                }
             }
             else {
                 layers.push(layer);
@@ -113,22 +123,52 @@ export default class MFPEncoder {
      * @returns A promise that resolves to an array of MFP layers, a single MFP layer, or null.
      */
     encodeLayer(layer) {
-        if (layer.className === LayerWms.name) {
-            return this.encodeImageLayer(layer);
+        switch (layer.className) {
+            case GroupLayer.name:
+                return this.encodeGroupLayer(layer);
+            case LayerWms.name:
+                return this.encodeWmsLayer(layer);
+            case LayerWmts.name:
+                return this.encodeTileWmtsLayer(layer);
+            case LayerLocalFile.name:
+                return this.encodeLocalFileLayer(layer);
+            default:
+                console.warn('Unsupported layer type for encoding:', layer.className);
+                return null;
+        }
+    }
+    /**
+     * Only non mixed groups of WMS layers are supported.
+     *
+     * Will convert a group of WMS layers sharing the same OGC server into a single MFPWmsLayer
+     * where its 'layers' property is a concatenation of all child layers' 'layers' property.
+     *
+     * @param groupLayer
+     */
+    encodeGroupLayer(groupLayer) {
+        if (groupLayer.isMixed) {
+            console.error("A mixed group layer is passed to print and shouldn't", groupLayer);
+            return null;
+        }
+        if (groupLayer.hasGrandChildren) {
+            console.error("A group layer that has grandchildren is passed to print and shouldn't", groupLayer);
+            return null;
         }
-        if (layer.className === LayerWmts.name) {
-            return this.encodeTileWmtsLayer(layer);
+        const firstWmsLayer = groupLayer.children.shift();
+        const spec = this.encodeWmsLayer(firstWmsLayer);
+        if (!spec) {
+            return this.encodeGroupLayer(groupLayer);
         }
-        if (layer.className === LayerLocalFile.name) {
-            return this.encodeLocalFileLayer(layer);
+        for (const childLayer of groupLayer.children) {
+            spec.layers.push(childLayer.layers || '');
         }
-        return null;
+        return spec;
     }
     /**
      * Encodes an image layer from a WMS layer object.
      * @returns The encoded image layer or null if the layer is not visible.
      */
-    encodeImageLayer(layerWms) {
+    encodeWmsLayer(layerWms) {
         if (!isLayerVisible(layerWms, this.options?.printResolution)) {
             return null;
         }
@@ -170,7 +210,7 @@ export default class MFPEncoder {
         return object;
     }
     /**
-     * Encodes a WMTS layer into a MFPWmtsLayer or MFPImageLayer object.
+     * Encodes a WMTS layer into a MFPWmtsLayer or MFPWmsLayer object.
      * @returns The encoded layer object, or null if the layer is not visible.
      */
     encodeTileWmtsLayer(layerWmts) {
@@ -236,6 +276,6 @@ export default class MFPEncoder {
         const printLayers = layerWmts.printLayers ?? layerWmts.wmsLayers ?? '';
         const layerWms = new LayerWms(0, printLayers, 0, layerWmts.ogcServer, { layers: printLayers });
         layerWms.opacity = layerWmts.opacity;
-        return this.encodeImageLayer(layerWms);
+        return this.encodeWmsLayer(layerWms);
     }
 }

package/components/print/tools/MFPEncoder.spec.js

@@ -52,10 +52,20 @@ describe('MFPEncoder', () => {
             groupLayers[2].children = [layers[3], groupLayers[0]];
             groupLayers[3].children = [groupLayers[1], groupLayers[2]];
             topLevelGroup = [groupLayers[3]];
+            // Structure:
+            // topLevelGroup
+            //  └─ groupLayers[3]
+            //      ├─ groupLayers[1]
+            //      │   └─ layers[2] (wms-2)
+            //      └─ groupLayers[2]
+            //          ├─ layers[3] (wmts)
+            //          └─ groupLayers[0]
+            //              ├─ layers[0] (wms-0)
+            //              └─ layers[1] (wms-1)
         });
         it('getFlatLayersGroupLayers', () => {
             const result = encoder.getFlatLayers(topLevelGroup);
-            expect(result.length).toBe(4); // 4 wms layers
+            expect(result.length).toBe(4);
         });
         it('encode the map', () => {
             context.stateManager.state.layers.layersList = topLevelGroup;
@@ -77,21 +87,21 @@ describe('MFPEncoder', () => {
             expect(result.dpi).toBe(defaultOptions.dpi);
             expect(result.scale).toBe(defaultOptions.scale);
             expect(result.rotation).toBe(180);
-            expect(result.layers.length).toBe(6);
+            expect(result.layers.length).toBe(5);
             // Test order
             expect(result.layers[0].name).toBe('Test Vector layer');
-            expect(result.layers[5].name).toBe('basemap-below');
+            expect(result.layers[4].name).toBe('basemap-below');
         });
     });
-    describe('encodeImageLayer method', () => {
+    describe('encodeWmsLayer method', () => {
         it('should return null for not visible layer', () => {
             const layer = createTestLayerWms({ opacity: 0 });
-            const result = encoder.encodeImageLayer(layer);
+            const result = encoder.encodeWmsLayer(layer);
             expect(result).toEqual(null);
         });
         it('should encode a wms layer', () => {
             const layer = createTestLayerWms({ layers: 'tree,plant', opacity: 0.6 });
-            const result = encoder.encodeImageLayer(layer);
+            const result = encoder.encodeWmsLayer(layer);
             expect(result).toEqual({
                 baseURL: 'https://ogc.test.url/',
                 customParams: {
@@ -107,6 +117,32 @@ describe('MFPEncoder', () => {
             });
         });
     });
+    describe('encodeGroupLayer with same ogcServer', () => {
+        it('should encode a group layer', () => {
+            const ogcServer = createTestOgcServer();
+            context.stateManager.state.ogcServers = { [ogcServer.name]: ogcServer };
+            const layer1 = createTestLayerWms({ layers: 'tree', opacity: 0.6 });
+            const layer2 = createTestLayerWms({ layers: 'plant', opacity: 0.6 });
+            layer1.ogcServer = ogcServer;
+            layer2.ogcServer = ogcServer;
+            const groupLayer = createTestGroupLayer();
+            groupLayer.children = [layer1, layer2];
+            const result = encoder.encodeGroupLayer(groupLayer);
+            expect(result).toEqual({
+                baseURL: 'https://ogc.test.url/',
+                customParams: {
+                    TRANSPARENT: 'TRUE'
+                },
+                imageFormat: 'image/png',
+                layers: ['tree', 'plant'],
+                opacity: 0.6,
+                serverType: 'mapserver',
+                styles: [''],
+                type: 'wms',
+                useNativeAngle: undefined
+            });
+        });
+    });
     describe('encodeTileWmtsLayer', () => {
         it('Testing encodeTileWmtsLayer method with inactive layer', () => {
             const layer = createTestLayerWmts({ opacity: 0 });

package/models/gmf.d.ts

@@ -39,6 +39,7 @@ export interface GMFTreeItem {
     id: number;
     name: string;
     metadata?: GMFMetadata;
+    mixed?: boolean;
     ogcServer?: string;
     children?: GMFTreeItem[];
     type?: 'OSM' | 'WMS' | 'WMTS' | 'VectorTiles' | 'COG' | 'XYZ';

package/models/layers/grouplayer.d.ts

@@ -7,6 +7,7 @@ export type GroupLayerOptions = {
     metadataUrl?: string;
     isDefaultExpanded?: boolean;
     isExclusiveGroup?: boolean;
+    isMixed?: boolean;
     time?: ITimeOptions;
     timeAttribute?: string;
 };
@@ -20,6 +21,7 @@ declare class GroupLayer extends BaseLayer implements ILayerWithTime {
      */
     isExclusiveGroup: boolean;
     isExpanded: boolean;
+    _isMixed?: boolean;
     activeState: 'on' | 'off' | 'semi';
     timeOptions?: ITimeOptions;
     timeAttribute?: string;
@@ -31,6 +33,12 @@ declare class GroupLayer extends BaseLayer implements ILayerWithTime {
     get inactive(): boolean;
     get semiActive(): boolean;
     get hasTimeRestriction(): boolean;
+    get hasGrandChildren(): boolean;
     setDefaultTimeRestriction(): void;
+    /**
+     * Checks if all the children are LayerWms with the same ogcServer, opacity
+     * time
+     */
+    get isMixed(): boolean;
 }
 export default GroupLayer;

package/models/layers/grouplayer.js

@@ -1,5 +1,6 @@
 import BaseLayer from './baselayer';
 import LayerTimeFormatter from '../../tools/time/layertimeformatter';
+import LayerWms from './layerwms';
 class GroupLayer extends BaseLayer {
     /**
      * This class is a used in the state of the application, which will be accessed behind a javascript proxy.
@@ -10,6 +11,7 @@ class GroupLayer extends BaseLayer {
      */
     isExclusiveGroup;
     isExpanded;
+    _isMixed;
     activeState = 'off';
     timeOptions;
     timeAttribute;
@@ -19,6 +21,7 @@ class GroupLayer extends BaseLayer {
         super(id, name, order, options);
         this.isExpanded = options?.isDefaultExpanded || false;
         this.isExclusiveGroup = options?.isExclusiveGroup ?? false;
+        this._isMixed = options?.isMixed;
         this.timeOptions = options?.time;
         this.timeAttribute = options?.timeAttribute;
         this.setDefaultTimeRestriction();
@@ -30,6 +33,7 @@ class GroupLayer extends BaseLayer {
             disclaimer: this.disclaimer,
             isDefaultExpanded: this.isExpanded,
             isExclusiveGroup: this.isExclusiveGroup,
+            isMixed: this._isMixed,
             time: this.timeOptions,
             timeAttribute: this.timeAttribute
         };
@@ -56,11 +60,62 @@ class GroupLayer extends BaseLayer {
     get hasTimeRestriction() {
         return !!this.timeRestriction;
     }
+    get hasGrandChildren() {
+        for (const child of this.children) {
+            if (child.children?.length) {
+                return true;
+            }
+        }
+        return false;
+    }
     setDefaultTimeRestriction() {
         if (this.timeOptions) {
             const timeFormatter = new LayerTimeFormatter(this.timeOptions);
             this.timeRestriction = timeFormatter.getFormattedDefault();
         }
     }
+    /**
+     * Checks if all the children are LayerWms with the same ogcServer, opacity
+     * time
+     */
+    get isMixed() {
+        // It was explicitly set to true, it can't be unmixed
+        if (this._isMixed) {
+            return this._isMixed;
+        }
+        // If any child is not a GroupLayer or LayerWms, return true immediately
+        for (const child of this.children) {
+            if (!(child instanceof GroupLayer) && !(child instanceof LayerWms)) {
+                return true;
+            }
+        }
+        // Collect all LayerWms children and grandchildren recursively
+        const layerWmsList = [];
+        function collectLayerWms(layer) {
+            if (layer instanceof LayerWms) {
+                layerWmsList.push(layer);
+            }
+            else if (layer instanceof GroupLayer) {
+                for (const child of layer.children) {
+                    collectLayerWms(child);
+                }
+            }
+        }
+        for (const child of this.children) {
+            collectLayerWms(child);
+        }
+        // Check if all LayerWms have the same properties
+        if (layerWmsList.length > 0) {
+            const first = layerWmsList[0];
+            const allSame = layerWmsList.every((lw) => lw.opacity === first.opacity &&
+                lw.ogcServer === first.ogcServer &&
+                lw.filter === first.filter &&
+                lw.timeRestriction === first.timeRestriction);
+            if (allSame) {
+                return false;
+            }
+        }
+        return true;
+    }
 }
 export default GroupLayer;

package/package.json

@@ -5,7 +5,7 @@
     "name": "GeoGirafe PSC",
     "url": "https://doc.geomapfish.dev"
   },
-  "version": "1.0.2170130456",
+  "version": "1.0.2178444470",
   "type": "module",
   "engines": {
     "node": ">=20.19.0"

package/templates/public/about.json

@@ -1 +1 @@
-{"version":"1.0.2170130456", "build":"2170130456", "date":"20/11/2025"}
+{"version":"1.0.2178444470", "build":"2178444470", "date":"25/11/2025"}

package/tools/state/state.d.ts

@@ -30,6 +30,7 @@ export type InfoBoxContent = {
     id: string;
     text: string;
     type: 'info' | 'warning' | 'error';
+    duration?: number;
 };
 export type Lidar = {
     line: OlGeomLineString | null;

package/tools/themes/themesmanager.js

@@ -294,6 +294,7 @@ class ThemesManager extends GirafeSingleton {
             disclaimer: elem.metadata?.disclaimer,
             isDefaultExpanded: elem.metadata?.isExpanded,
             isExclusiveGroup: elem.metadata?.exclusiveGroup,
+            isMixed: elem.mixed,
             time: elem.time
         };
         if (options.metadataUrl) {

package/tools/wms/wmsclient.js

@@ -181,6 +181,8 @@ export default class WmsClient {
         }
         const isBasemapLayer = layerWms.treeItemId in this.basemapLayers;
         const isLayerIndependent = layerWms.treeItemId in this.independentLayers;
+        // TODO SMS: if all layers share the same opacity, then mustBeIndependent can be false even if isTransparent is true.
+        // This will be changed in the future.
         const mustBeIndependent = layerWms.hasFilter || layerWms.hasTimeRestriction || layerWms.isTransparent || layerWms.swiped !== 'no';
         if (!isBasemapLayer) {
             if (isLayerIndependent && !mustBeIndependent) {