diff --git a/build/docma-config.json b/build/docma-config.json
index 866162f11f6..8dc114e5c3c 100644
--- a/build/docma-config.json
+++ b/build/docma-config.json
@@ -265,6 +265,7 @@
                 "web/client/plugins/Language.jsx",
                 "web/client/plugins/LayerDownload.jsx",
                 "web/client/plugins/LayerInfo.jsx",
+                "web/client/plugins/LayersSelection/index.js",
                 "web/client/plugins/Locate.jsx",
                 "web/client/plugins/Login.jsx",
                 "web/client/plugins/LongitudinalProfileTool.jsx",
diff --git a/project/standard/templates/configs/pluginsConfig.json b/project/standard/templates/configs/pluginsConfig.json
index bc6b9875374..eda14def5c9 100644
--- a/project/standard/templates/configs/pluginsConfig.json
+++ b/project/standard/templates/configs/pluginsConfig.json
@@ -153,6 +153,13 @@
       "description": "plugins.Permalink.description",
       "denyUserSelection": true
     },
+    {
+      "name": "LayersSelection",
+      "glyph": "hand-down",
+      "title": "plugins.LayersSelection.title",
+      "description": "plugins.LayersSelection.description",
+      "dependencies": ["SidebarMenu"]
+    },
     {
       "name": "BackgroundSelector",
       "title": "plugins.BackgroundSelector.title",
diff --git a/web/client/configs/pluginsConfig.json b/web/client/configs/pluginsConfig.json
index 1ce8f863a29..e7b8155ee38 100644
--- a/web/client/configs/pluginsConfig.json
+++ b/web/client/configs/pluginsConfig.json
@@ -155,6 +155,13 @@
       "title": "plugins.Permalink.title",
       "description": "plugins.Permalink.description"
     },
+    {
+      "name": "LayersSelection",
+      "glyph": "hand-down",
+      "title": "plugins.LayersSelection.title",
+      "description": "plugins.LayersSelection.description",
+      "dependencies": ["SidebarMenu"]
+    },
     {
       "name": "BackgroundSelector",
       "title": "plugins.BackgroundSelector.title",
diff --git a/web/client/plugins/LayersSelection/actions/__tests__/layersSelection-test.js b/web/client/plugins/LayersSelection/actions/__tests__/layersSelection-test.js
new file mode 100644
index 00000000000..03eb9c2659e
--- /dev/null
+++ b/web/client/plugins/LayersSelection/actions/__tests__/layersSelection-test.js
@@ -0,0 +1,59 @@
+
+import expect from 'expect';
+import {
+    cleanSelection,
+    SELECT_CLEAN_SELECTION,
+    storeConfiguration,
+    SELECT_STORE_CFG,
+    addOrUpdateSelection,
+    ADD_OR_UPDATE_SELECTION,
+    updateSelectionFeature,
+    UPDATE_SELECTION_FEATURE
+} from '../layersSelection';
+
+describe('LayersSelection Actions', () => {
+    describe('cleanSelection', () => {
+        it('should create action with a geometry type Point', () => {
+            const geomType = 'Point';
+            const action = cleanSelection(geomType);
+
+            expect(action).toEqual({
+                type: SELECT_CLEAN_SELECTION,
+                geomType
+            });
+        });
+
+        it('should create action of a store Configuration', () => {
+            const cfg = {};
+            const action = storeConfiguration(cfg);
+
+            expect(action).toEqual({
+                type: SELECT_STORE_CFG,
+                cfg
+            });
+        });
+
+        it('should create action to add or update selection', () => {
+            const layer = 'name layer';
+            const geoJsonData = {};
+            const action = addOrUpdateSelection(layer, geoJsonData);
+
+            expect(action).toEqual({
+                type: ADD_OR_UPDATE_SELECTION,
+                layer,
+                geoJsonData
+            });
+        });
+
+        it('should create action to update feature selection', () => {
+            const feature = {};
+            const action = updateSelectionFeature(feature);
+
+            expect(action).toEqual({
+                type: UPDATE_SELECTION_FEATURE,
+                feature
+            });
+        });
+
+    });
+});
diff --git a/web/client/plugins/LayersSelection/actions/layersSelection.js b/web/client/plugins/LayersSelection/actions/layersSelection.js
new file mode 100644
index 00000000000..47f1b985977
--- /dev/null
+++ b/web/client/plugins/LayersSelection/actions/layersSelection.js
@@ -0,0 +1,51 @@
+export const SELECT_CLEAN_SELECTION = "SELECT:CLEAN_SELECTION";
+export const SELECT_STORE_CFG = "SELECT:STORE_CFG";
+export const ADD_OR_UPDATE_SELECTION = "SELECT:ADD_OR_UPDATE_SELECTION";
+export const UPDATE_SELECTION_FEATURE = "SELECT:UPDATE_SELECTION_FEATURE";
+/**
+ * Action creator to clean the current selection based on geometry type.
+ *
+ * @param {string} geomType - The type of geometry to clean (e.g., "Point", "Polygon").
+ * @returns {{ type: string, geomType: string }} The action object.
+ */
+export function cleanSelection(geomType) {
+    return {
+        type: SELECT_CLEAN_SELECTION,
+        geomType
+    };
+}
+
+/**
+ * Action creator to store configuration settings related to selection.
+ *
+ * @param {Object} cfg - Configuration object to store.
+ * @returns {{ type: string, cfg: Object }} The action object.
+ */
+export function storeConfiguration(cfg) {
+    return {
+        type: SELECT_STORE_CFG,
+        cfg
+    };
+}
+
+/**
+ * Action creator to add or update a layer selection with GeoJSON data.
+ *
+ * @param {string} layer - The name or ID of the layer.
+ * @param {Object} geoJsonData - The GeoJSON data representing the selection.
+ * @returns {{ type: string, layer: string, geoJsonData: Object }} The action object.
+ */
+export function addOrUpdateSelection(layer, geoJsonData) {
+    return {
+        type: ADD_OR_UPDATE_SELECTION,
+        layer,
+        geoJsonData
+    };
+}
+
+export function updateSelectionFeature(feature) {
+    return {
+        type: UPDATE_SELECTION_FEATURE,
+        feature
+    };
+}
diff --git a/web/client/plugins/LayersSelection/components/EllipsisButton.jsx b/web/client/plugins/LayersSelection/components/EllipsisButton.jsx
new file mode 100644
index 00000000000..7551cba25f8
--- /dev/null
+++ b/web/client/plugins/LayersSelection/components/EllipsisButton.jsx
@@ -0,0 +1,198 @@
+import React, { useState, useEffect } from 'react';
+import bbox from '@turf/bbox';
+import { saveAs } from 'file-saver';
+import axios from 'axios';
+
+import Message from '../../../components/I18N/Message';
+import { describeFeatureType } from '../../../api/WFS';
+import Statistics from './Statistics';
+import { DropdownButton, Glyphicon, MenuItem } from 'react-bootstrap';
+import uuidv1 from 'uuid/v1';
+
+/**
+ * EllipsisButton provides a contextual menu for selected layer data.
+ * It allows users to:
+ * - Zoom to selection extent
+ * - View statistics
+ * - Create a new layer from selection
+ * - Export data (GeoJSON, JSON, CSV)
+ * - Apply attribute filters (if supported)
+ * - Clear the selection
+ *
+ * @param {Object} props - Component props.
+ * @param {Object} props.node - Layer node (descriptor).
+ * @param {Object} props.selectionData - GeoJSON FeatureCollection.
+ * @param {Function} props.onAddOrUpdateSelection - Callback to update selection.
+ * @param {Function} props.onZoomToExtent - Callback to zoom to selection.
+ * @param {Function} props.onAddLayer - Callback to add a new layer.
+ * @param {Function} props.onChangeLayerProperties - Callback to change layer properties.
+ */
+export default ({
+    node = {},
+    selectionData = {},
+    onAddOrUpdateSelection = () => { },
+    onZoomToExtent = () => { },
+    onAddLayer = () => { },
+    onChangeLayerProperties = () => { }
+}) => {
+
+    const [statisticsOpen, setStatisticsOpen] = useState(false);
+    const [numericFields, setNumericFields] = useState([]);
+    const [primaryKey, setPrimaryKey] = useState(null);
+
+    const triggerAction = (action) => {
+        switch (action) {
+        case 'clear': {
+            onAddOrUpdateSelection(node, {});
+            break;
+        }
+        case 'zoomTo': {
+            if (selectionData.features?.length > 0) {
+                const extent = bbox(selectionData);
+                if (extent) { onZoomToExtent(extent, selectionData.crs.properties[selectionData.crs.type]); }
+            }
+            break;
+        }
+        case 'createLayer': {
+            if (selectionData.features?.length > 0) {
+
+                const nodeName = node.title + '_Select_';
+                const layerBbox = bbox(selectionData);
+                const uniqueId = uuidv1();
+
+                onAddLayer({
+                    id: uniqueId,
+                    type: 'vector',
+                    visibility: true,
+                    name: nodeName + uniqueId,
+                    hideLoading: true,
+                    bbox: layerBbox,
+                    features: selectionData.features
+                });
+            }
+            break;
+        }
+        case 'exportToGeoJson': {
+            if (selectionData.features?.length > 0) { saveAs(new Blob([JSON.stringify(selectionData)], { type: 'application/json' }), node.title + '.json'); }
+            break;
+        }
+        case 'exportToJson': {
+            if (selectionData.features?.length > 0) { saveAs(new Blob([JSON.stringify(selectionData.features.map(feature => feature.properties))], { type: 'application/json' }), node.title + '.json'); }
+            break;
+        }
+        case 'exportToCsv': {
+            if (selectionData.features?.length > 0) { saveAs(new Blob([Object.keys(selectionData.features[0].properties).join(',') + '\n' + selectionData.features.map(feature => Object.values(feature.properties).join(',')).join('\n')], { type: 'text/csv' }), node.title + '.csv'); }
+            break;
+        }
+        case 'filterData': {
+
+            switch (node.type) {
+            case 'arcgis': {
+                // TODO : implement here when MapStore supports filtering for arcgis services
+                throw new Error(`Unsupported layer type: ${node.type}`);
+            }
+            case 'wms':
+            case 'wfs': {
+                onChangeLayerProperties(node.id, {
+                    layerFilter: {
+                        groupFields: [
+                            {
+                                id: 1,
+                                logic: 'OR',
+                                index: 0
+                            }
+                        ],
+                        filterFields: selectionData.features.map(feature => ({
+                            rowId: uuidv1(),
+                            groupId: 1,
+                            attribute: primaryKey,
+                            operator: '=',
+                            value: feature.properties[primaryKey],
+                            type: 'number',
+                            fieldOptions: {
+                                valuesCount: 0,
+                                currentPage: 1
+                            },
+                            exception: null
+                        }))
+                    }
+                });
+                break;
+            }
+            default:
+                throw new Error(`Unsupported layer type: ${node.type}`);
+            }
+            break;
+        }
+        default:
+        }
+    };
+
+    useEffect(() => {
+        switch (node.type) {
+        case 'arcgis': {
+            const arcgisNumericFields = new Set(['esriFieldTypeSmallInteger', 'esriFieldTypeInteger', 'esriFieldTypeSingle', 'esriFieldTypeDouble']);
+            const singleLayerId = parseInt(node.name ?? '', 10);
+            Promise.all((Number.isInteger(singleLayerId) ? node.options.layers.filter(l => l.id === singleLayerId) : node.options.layers).map(l => axios.get(`${node.url}/${l.id}`, { params: { f: 'json' } })
+                .then(describe => describe.data.fields.filter(field => field.domain === null && arcgisNumericFields.has(field.type)).map(field => field.name))
+                .catch(() => [])
+            ))
+                .then(responses => {
+                    setPrimaryKey(null);
+                    setNumericFields(responses.map(response => response ?? []).flat());
+                })
+                .catch(() => {
+                    setPrimaryKey(null);
+                    setNumericFields([]);
+                });
+            break;
+        }
+        case 'wms':
+        case 'wfs': {
+            describeFeatureType(node.url, node.name)
+                .then(describe => {
+                    const featureType = describe.featureTypes.find(fType => node.name.endsWith(fType.typeName));
+                    const newNumericFields = featureType.properties.filter(property => property.localType === 'number').map(property => property.name);
+                    // primary key is not always exposed
+                    const newPrimaryKey = featureType.properties
+                        .find(property =>
+                            ['xsd:string', 'xsd:int'].includes(property.type) && !property.nillable && property.maxOccurs === 1 && property.minOccurs === 1
+                        )?.name || null;
+                    setPrimaryKey(newPrimaryKey);
+                    setNumericFields(newNumericFields);
+                })
+                .catch(() => {
+                    setPrimaryKey(null);
+                    setNumericFields([]);
+                });
+            break;
+        }
+        default:
+        }
+    }, [node.name]);
+
+    return (
+        <>
+            <DropdownButton
+                pullRight
+                title={<Glyphicon glyph="option-vertical"/>}
+                className="_border-transparent"
+                noCaret
+            >
+                <MenuItem onClick={() => triggerAction('zoomTo')}><Message msgId="layersSelection.button.zoomTo" /></MenuItem>
+                <MenuItem onClick={() => { selectionData.features?.length > 0 ? setStatisticsOpen(true) : null; }}><Message msgId="layersSelection.button.statistics" /></MenuItem>
+                <MenuItem onClick={() => triggerAction('createLayer')}><Message msgId="layersSelection.button.createLayer" /></MenuItem>
+                {primaryKey ? <MenuItem onClick={() => triggerAction('filterData')}><Message msgId="layersSelection.button.filterData" /></MenuItem> : null}
+                <MenuItem onClick={() => triggerAction('exportToGeoJson')}><Message msgId="layersSelection.button.exportToGeoJson" /></MenuItem>
+                <MenuItem onClick={() => triggerAction('exportToJson')}><Message msgId="layersSelection.button.exportToJson" /></MenuItem>
+                <MenuItem onClick={() => triggerAction('exportToCsv')}><Message msgId="layersSelection.button.exportToCsv" /></MenuItem>
+                <MenuItem onClick={() => triggerAction('clear')}><Message msgId="layersSelection.button.clear" /></MenuItem>
+            </DropdownButton>
+            {statisticsOpen && <Statistics
+                setStatisticsOpen={setStatisticsOpen}
+                fields={numericFields}
+                features={selectionData.features ?? []}
+            />}
+        </>
+    );
+};
diff --git a/web/client/plugins/LayersSelection/components/LayersSelection.jsx b/web/client/plugins/LayersSelection/components/LayersSelection.jsx
new file mode 100644
index 00000000000..61c47a2171c
--- /dev/null
+++ b/web/client/plugins/LayersSelection/components/LayersSelection.jsx
@@ -0,0 +1,226 @@
+import React, { useEffect, useState } from 'react';
+import { ControlLabel, Glyphicon } from 'react-bootstrap';
+
+import { ControlledTOC } from '../../TOC/components/TOC';
+import ResizableModal from '../../../components/misc/ResizableModal';
+import Message from '../../../components/I18N/Message';
+import VisibilityCheck from '../../TOC/components/VisibilityCheck';
+import NodeHeader from '../../TOC/components/NodeHeader';
+import { getLayerTypeGlyph } from '../../../utils/LayersUtils';
+import NodeTool from '../../TOC/components/NodeTool';
+import InlineLoader from '../../TOC/components/InlineLoader';
+import EllipsisButton from './EllipsisButton';
+import { isSelectQueriable, filterLayerForSelect } from '../selectors/layersSelection';
+import FlexBox from '../../../components/layout/FlexBox';
+import Button from '../../../components/layout/Button';
+import Select from 'react-select';
+import { getMessageById } from '../../../utils/LocaleUtils';
+import PropTypes from 'prop-types';
+
+import './layersSelection.css';
+
+const SelectionToolsTypes = {
+    Point: { type: 'Point', value: 'Point', labelId: 'layersSelection.button.selectByPoint', icon: '1-point' },
+    LineString: { type: 'LineString', value: 'LineString', labelId: 'layersSelection.button.selectByLine', icon: 'polyline' },
+    Circle: { type: 'Circle', value: 'Circle', labelId: 'layersSelection.button.selectByCircle', icon: '1-circle' },
+    Rectangle: { type: 'Rectangle', value: 'BBOX', labelId: 'layersSelection.button.selectByRectangle', icon: 'unchecked' },
+    Polygon: { type: 'Polygon', value: 'Polygon', labelId: 'layersSelection.button.selectByPolygon', icon: 'polygon' }
+};
+
+/**
+ * Appends or updates a cache-busting `_v_` parameter on the layer's legendParams object.
+ *
+ * @param {Object} layer - The layer object to apply the parameter to.
+ * @returns {Object} A new layer object with the `_v_` legend param added.
+ */
+function applyVersionParamToLegend(layer) {
+    // we need to pass a parameter that invalidate the cache for GetLegendGraphic
+    // all layer inside the dataset viewer apply a new _v_ param each time we switch page
+    return { ...layer, legendParams: { ...layer?.legendParams, _v_: layer?._v_ } };
+}
+
+/**
+ * Select tool UI component wrapped with react-intl internationalization.
+ *
+ * @component
+ * @param {Object} props - Component props.
+ * @param {Array} props.layers - List of layers from the map.
+ * @param {Function} props.onUpdateNode - Redux action to update a layer node.
+ * @param {Function} props.onClose - Callback for closing the modal.
+ * @param {Boolean} props.isVisible - Whether the modal is visible.
+ * @param {Object} props.highlightOptions - Highlighting options for selected features.
+ * @param {Object} props.queryOptions - Options for querying features.
+ * @param {Array} props.selectTools - Toolbar tools for the selection module.
+ * @param {Function} props.storeConfiguration - Saves configuration to the Redux store.
+ * @param {Object} props.intl - Internationalization object from `injectIntl`.
+ * @param {Object} props.selections - Selection results grouped by layer ID.
+ * @param {Number} props.maxFeatureCount - Maximum number of features allowed per selection.
+ * @param {Function} props.cleanSelection - Action to clear selection results.
+ * @param {Function} props.addOrUpdateSelection - Action to update the current selection.
+ * @param {Function} props.zoomToExtent - Action to zoom to the extent of selected features.
+ * @param {Function} props.addLayer - Action to add a new layer.
+ * @param {Function} props.changeLayerProperties - Action to update layer properties.
+ *
+ * @returns {JSX.Element} The rendered Select tool modal.
+ */
+const LayersSelection = ({
+    layers,
+    onUpdateNode,
+    onClose,
+    isVisible,
+    highlightOptions,
+    queryOptions,
+    selectTools = [
+        'Point',
+        'LineString',
+        'Circle',
+        'Rectangle',
+        'Polygon'
+    ],
+    storeConfiguration,
+    selections,
+    maxFeatureCount,
+    cleanSelection,
+    addOrUpdateSelection,
+    zoomToExtent,
+    addLayer,
+    changeLayerProperties
+}, context) => {
+
+    const filterLayers = layers.filter(filterLayerForSelect);
+
+    /**
+     * Renders a custom layer node component inside the TOC.
+     *
+     * @param {Object} props
+     * @param {Object} props.node - The layer node.
+     * @param {Object} props.config - Configuration options such as locale.
+     * @returns {JSX.Element} Rendered layer node with feature count, tools, and visibility check.
+     */
+    const customLayerNodeComponent = ({node, config}) => {
+        const selectionData = selections[node.id] ?? {};
+        return (
+            <li className={`ms-node ms-node-layer`}>
+                <InlineLoader loading={selectionData.loading}/>
+                <NodeHeader
+                    node={node}
+                    currentLocale={config?.currentLocale}
+                    showTitleTooltip={false}
+                    showFullTitle
+                    beforeTitle={
+                        <>
+                            <VisibilityCheck
+                                hide={false}
+                                mutuallyExclusive={false}
+                                value={isSelectQueriable(node)}
+                                onChange={checked => onUpdateNode(node.id, 'layers', { isSelectQueriable: checked })}
+                            />
+                            <Glyphicon className="ms-node-icon" glyph={getLayerTypeGlyph(node)} />
+                        </>
+                    }
+                    afterTitle={
+                        <>
+                            {selectionData.error ? (
+                                <NodeTool tooltip={selectionData.error.toString()} glyph="exclamation-mark"/>
+                            ) : (
+                                <div className="features-count-displayer">
+                                    {selectionData.features && selectionData.features.length === maxFeatureCount && <NodeTool tooltip={<Message msgId="layersSelection.hasReachMaxCount"/>} /* tooltip={"ouech"} */  glyph="exclamation-mark"/>}
+                                    <p>{selectionData.loading ? '⊙' : (selectionData.features?.length ?? 0)}</p>
+                                </div>
+                            )}
+
+                            {selectionData.features?.length > 0 && <EllipsisButton
+                                node={node}
+                                layers={layers}
+                                selectionData={selections[node.id]}
+                                onAddOrUpdateSelection={addOrUpdateSelection}
+                                onZoomToExtent={zoomToExtent}
+                                onAddLayer={addLayer}
+                                onChangeLayerProperties={changeLayerProperties}
+                            />}
+                        </>
+                    }
+                />
+            </li>
+        );
+    };
+
+    useEffect(() => storeConfiguration({ highlightOptions, queryOptions }), []);
+
+    const [selectedTool, setSelectedTool] = useState(null);
+
+    const selectionOptions = selectTools
+        .filter(tool => SelectionToolsTypes[tool])
+        .map(tool => {
+            const option = SelectionToolsTypes[tool];
+            return { ...option, label: <><Glyphicon glyph={option.icon} />{' '}<Message msgId={option.labelId} /></> };
+        });
+
+    return (
+        <ResizableModal
+            onClose = {onClose}
+            enableFooter={false}
+            title={<>
+                <Glyphicon glyph="hand-down"/>{' '}
+                <Message msgId="layersSelection.title"/>
+            </>}
+            dialogClassName=" select-dialog"
+            show={isVisible}
+            draggable
+            style={{zIndex: 1993}}>
+            <FlexBox className="_padding-md" gap="sm" column>
+                <ControlLabel><Message msgId="layersSelection.button.select"/></ControlLabel>
+                <FlexBox gap="sm">
+                    <FlexBox.Fill>
+                        <Select
+                            value={selectedTool}
+                            clearable={false}
+                            options={selectionOptions}
+                            onChange={option => {
+                                setSelectedTool(option);
+                                cleanSelection(option?.value ?? null);
+                            }}
+                        />
+                    </FlexBox.Fill>
+                    <Button
+                        disabled={!selectedTool}
+                        onClick={() => {
+                            setSelectedTool(null);
+                            cleanSelection(null);
+                        }}
+                    >
+                        <Message msgId="layersSelection.button.clear"/>
+                    </Button>
+                </FlexBox>
+            </FlexBox>
+            <ControlledTOC
+                tree={filterLayers.map(layer => Object.fromEntries(Object.entries(applyVersionParamToLegend(layer)).filter(([key]) => key !== 'group'))).reverse()}
+                className="select-content"
+                theme="legend"
+                layerNodeComponent={customLayerNodeComponent}
+                treeHeader={
+                    <li className={'ms-node ms-node-layer tree-header'}>
+                        <NodeHeader
+                            node={{ title: getMessageById(context.messages, 'layersSelection.allLayers') }}
+                            beforeTitle={
+                                <VisibilityCheck
+                                    hide={false}
+                                    mutuallyExclusive={false}
+                                    value={filterLayers.every(isSelectQueriable)}
+                                    onChange={checked => filterLayers.forEach(layer => onUpdateNode(layer.id, 'layers', { isSelectQueriable: checked }))}
+                                />
+                            }
+                            afterTitle={<Message msgId="layersSelection.featuresCount" />}
+                        />
+                    </li>
+                }
+            />
+        </ResizableModal>
+    );
+};
+
+LayersSelection.contextTypes = {
+    messages: PropTypes.object
+};
+
+export default LayersSelection;
diff --git a/web/client/plugins/LayersSelection/components/LayersSelectionHeader/LayersSelectionHeader.jsx b/web/client/plugins/LayersSelection/components/LayersSelectionHeader/LayersSelectionHeader.jsx
new file mode 100644
index 00000000000..b2118a9ec83
--- /dev/null
+++ b/web/client/plugins/LayersSelection/components/LayersSelectionHeader/LayersSelectionHeader.jsx
@@ -0,0 +1,95 @@
+import React, { useState, useEffect, useContext } from 'react';
+import ReactDOM from "react-dom";
+import { Glyphicon } from 'react-bootstrap';
+
+import Message from '../../../../components/I18N/Message';
+import InlineLoader from '../../../TOC/components/InlineLoader';
+
+import { SelectRefContext } from '../LayersSelection';
+
+/**
+ * LayersSelectionHeader provides a toolbar for selecting geometry-based
+ * selection tools (point, line, polygon, etc.) and for clearing selections.
+ *
+ * @param {Object} props - Component props.
+ * @param {Function} props.onCleanSelect - Callback to reset or apply selection tool.
+ * @param {Array<string>} props.selectTools - List of enabled selection tool types.
+ *                                            E.g., ['Point', 'Polygon', 'Rectangle']
+ *
+ * @returns {JSX.Element} The selection tool header UI.
+ */
+export default ({
+    onCleanSelect,
+    selectTools
+}) => {
+    const [menuOpen, setMenuOpen] = useState(false);
+    const [menuClosing, setMenuClosing] = useState(false);
+    const [selectedTool, setSelectedTool] = useState(null);
+
+    const selectRef = useContext(SelectRefContext);
+    useEffect(() => {
+        const selectElement = selectRef.current?.addEventListener ? selectRef.current : ReactDOM.findDOMNode(selectRef.current);
+        if (!selectElement || !selectElement.addEventListener) { return null; }
+        const handleClick = () => setMenuClosing(true);
+        selectElement.addEventListener("click", handleClick);
+        return () => selectElement.removeEventListener("click", handleClick);
+    });
+    useEffect(() => {
+        if (menuClosing) {
+            setMenuClosing(false);
+            if (menuOpen) {
+                setTimeout(() => setMenuOpen(false), 50);   // In order that onCleanSelect has the time to trigger its action.
+            }
+        }
+    }, [menuClosing]);
+
+    const toggleMenu = () => setMenuOpen(!menuOpen);
+
+    const clean = tool => {
+        setMenuOpen(false);
+        if (tool) setSelectedTool(tool);
+        onCleanSelect(tool?.action ?? null);
+    };
+
+    const clearSelection = () => {
+        clean();
+        setSelectedTool(null);
+    };
+
+    const allTools = [
+        { type: 'Point', action: 'Point', label: 'layersSelection.button.selectByPoint', icon: '1-point' },
+        { type: 'LineString', action: 'LineString', label: 'layersSelection.button.selectByLine', icon: 'polyline' },
+        { type: 'Circle', action: 'Circle', label: 'layersSelection.button.selectByCircle', icon: '1-circle' },
+        { type: 'Rectangle', action: 'BBOX', label: 'layersSelection.button.selectByRectangle', icon: 'unchecked' },
+        { type: 'Polygon', action: 'Polygon', label: 'layersSelection.button.selectByPolygon', icon: 'polygon' }
+    ];
+    const availableTools = allTools.filter(tool => !Array.isArray(selectTools) || selectTools.includes(tool.type === 'LineString' ? 'Line' : tool.type));
+    const orderedTools = selectedTool ? [availableTools.find(tool => tool.type === selectedTool.type), ...availableTools.filter(tool => tool.type !== selectedTool.type)] : availableTools;
+
+    return (
+        <div className="select-header-container">
+
+            <div className="head-text"><Message msgId="layersSelection.button.select"/></div>
+            <div className="select-header">
+                <div className="select-button-container">
+                    <button className="select-button" onClick={toggleMenu}>
+                        <span className="select-button-text">{selectedTool ? <><Glyphicon glyph={allTools.find(tool => tool.type === selectedTool.type)?.icon} />{' '}</> : null}<Message msgId={selectedTool?.label ?? "layersSelection.button.chooseGeometry"} /></span>
+                        <span className="select-button-arrow"><Glyphicon glyph={menuOpen ? 'chevron-up' : 'chevron-down'}/></span>
+                    </button>
+                    {menuOpen && (
+                        <div className="select-button-menu">
+                            {orderedTools.map(tool => <p key={tool.type} onClick={() => clean(tool)}><Glyphicon glyph={tool.icon} />{' '}<Message msgId={tool.label} /></p>)}
+                        </div>
+                    )}
+                </div>
+                <button className="clear-select-button" onClick={clearSelection}>
+                    <Message msgId="layersSelection.button.clear"/>
+                </button>
+            </div>
+            &nbsp;
+            <InlineLoader loading={false}/>
+            &nbsp;
+            <div className="Selection"><Message msgId="layersSelection.selection"/></div>
+        </div>
+    );
+};
diff --git a/web/client/plugins/LayersSelection/components/LayersSelectionSupport.jsx b/web/client/plugins/LayersSelection/components/LayersSelectionSupport.jsx
new file mode 100644
index 00000000000..2ca24ae3928
--- /dev/null
+++ b/web/client/plugins/LayersSelection/components/LayersSelectionSupport.jsx
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2026, GeoSolutions Sas.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import React, { lazy, Suspense, useEffect } from 'react';
+import { MapLibraries } from '../../../utils/MapTypeUtils';
+import { circleToPolygon } from '../../../utils/DrawGeometryUtils';
+import { createDefaultStyle } from '../../../utils/StyleUtils';
+
+const drawGeometrySupportSupports = {
+    // TODO: include support of Rectangle in Cesium support
+    // TODO: ensure only 2D coordinates are provided to the filter
+    // [MapLibraries.CESIUM]: lazy(() => import(/* webpackChunkName: 'supports/cesiumDrawGeometrySupport' */ '../../../components/map/cesium/DrawGeometrySupport')),
+    [MapLibraries.OPENLAYERS]: lazy(() => import(/* webpackChunkName: 'supports/olDrawGeometrySupport' */ '../../../components/map/openlayers/DrawGeometrySupport'))
+};
+
+const LAYER_SELECTION_LAYER_ID = 'LAYER_SELECTION_LAYER_ID';
+
+const LayersSelectionSupport = ({
+    map,
+    mapType,
+    type,
+    feature,
+    onChange = () => {},
+    onUpdateLayer = () => {},
+    onRemoveLayer = () => {},
+    cleanSelection
+}) => {
+
+    const DrawGeometrySupport = drawGeometrySupportSupports[mapType];
+
+    useEffect(() => {
+        return () => {
+            onChange(null);
+            onRemoveLayer({ owner: LAYER_SELECTION_LAYER_ID });
+            cleanSelection();
+        };
+    }, [onUpdateLayer, onChange, onRemoveLayer, mapType, cleanSelection]);
+
+    useEffect(() => {
+        onUpdateLayer(LAYER_SELECTION_LAYER_ID, LAYER_SELECTION_LAYER_ID, 'overlay', {
+            id: LAYER_SELECTION_LAYER_ID,
+            type: 'vector',
+            visibility: true,
+            features: feature ? [feature] : [],
+            style: feature ? createDefaultStyle({
+                fillColor: '#f2f2f2',
+                fillOpacity: 0.3,
+                strokeColor: '#ffcc33',
+                strokeOpacity: 1,
+                strokeWidth: 2,
+                radius: 10,
+                geometryType: feature?.geometry?.type
+            }) : undefined
+        });
+    }, [feature]);
+
+    if (!DrawGeometrySupport) {
+        return null;
+    }
+    const geometryType = type === 'BBOX' ? 'Rectangle' : type;
+    return (
+        <Suspense fallback={null}>
+            <DrawGeometrySupport
+                map={map}
+                active={!!geometryType && !feature}
+                depthTestAgainstTerrain={false}
+                geometryType={geometryType}
+                getObjectsToExcludeOnPick={() => []}
+                onDrawEnd={({ feature: newFeature }) => {
+                    const geometry = newFeature?.properties?.radius !== undefined
+                        ? circleToPolygon(newFeature.geometry.coordinates, newFeature.properties.radius, false)
+                        : newFeature.geometry;
+                    onChange({
+                        ...newFeature,
+                        properties: {
+                            ...newFeature?.properties,
+                            drawType: geometryType
+                        },
+                        geometry: {
+                            ...geometry,
+                            projection: 'EPSG:4326'
+                        }
+                    });
+                }}
+            />
+        </Suspense>
+    );
+};
+
+export default LayersSelectionSupport;
diff --git a/web/client/plugins/LayersSelection/components/Statistics.jsx b/web/client/plugins/LayersSelection/components/Statistics.jsx
new file mode 100644
index 00000000000..0a82cd6e1ec
--- /dev/null
+++ b/web/client/plugins/LayersSelection/components/Statistics.jsx
@@ -0,0 +1,81 @@
+import React, { useState, useMemo } from 'react';
+
+import Message from '../../../components/I18N/Message';
+import Portal from '../../../components/misc/Portal';
+import ResizableModal from '../../../components/misc/ResizableModal';
+import { ControlLabel, FormControl, Glyphicon } from 'react-bootstrap';
+import FlexBox from '../../../components/layout/FlexBox';
+
+/**
+ * A modal component that displays basic statistical calculations
+ * (count, sum, min, max, mean, standard deviation)
+ * for a selected numeric field from a list of features.
+ *
+ * @param {Object} props - Component props.
+ * @param {string[]} props.fields - List of available field names.
+ * @param {Object[]} props.features - List of GeoJSON features.
+ * @param {Function} props.setStatisticsOpen - Callback to close the statistics modal.
+ * @returns {JSX.Element} The rendered statistics modal.
+ */
+export default ({
+    fields = [],
+    features = [],
+    setStatisticsOpen = () => {}
+}) => {
+    const [selectedField, setSelectedField] = useState(fields.length > 0 ? fields[0] : null);
+
+    const statistics = useMemo(() => {
+        if (!selectedField) return null;
+
+        const values = features.map(f => f.properties[selectedField]).filter(v => typeof v === "number");
+        if (values.length === 0) return null;
+
+        const sum = values.reduce((acc, val) => acc + val, 0);
+        const min = Math.min(...values);
+        const max = Math.max(...values);
+        const mean = sum / values.length;
+        const variance = values.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) / values.length;
+        const stdDev = Math.sqrt(variance);
+
+        return { count: values.length, sum, min, max, mean, stdDev };
+    }, [features, selectedField]);
+
+    return (
+        <Portal>
+            <ResizableModal
+                fade
+                title={<><Glyphicon glyph="stats" />{' '}<Message msgId="layersSelection.statistics.title"/></>}
+                size="sm"
+                show
+                onClose={() => setStatisticsOpen(false)}
+                buttons={[{
+                    text: <Message msgId="close"/>,
+                    onClick: () => setStatisticsOpen(false),
+                    bsStyle: 'primary'
+                }]}>
+                <FlexBox className="_padding-lr-md" column gap="sm">
+                    <FlexBox centerChildrenVertically gap="sm">
+                        <ControlLabel style={{ margin: 0 }}><Message msgId="layersSelection.statistics.field"/></ControlLabel>
+                        <FlexBox.Fill>
+                            <FormControl componentClass="select" onChange={(event) => setSelectedField(event.target.value)}>
+                                {fields.map((field) => ( <option key={field} value={field}>{field}</option> ))}
+                            </FormControl>
+                        </FlexBox.Fill>
+                    </FlexBox>
+                    {statistics && (
+                        <table className="table ms-statistics-table">
+                            <tbody>
+                                <tr><td><Message msgId="layersSelection.statistics.count"/></td><td>{statistics.count}</td></tr>
+                                <tr><td><Message msgId="layersSelection.statistics.sum"/></td><td>{statistics.sum.toFixed(6)}</td></tr>
+                                <tr><td><Message msgId="layersSelection.statistics.min"/></td><td>{statistics.min.toFixed(6)}</td></tr>
+                                <tr><td><Message msgId="layersSelection.statistics.max"/></td><td>{statistics.max.toFixed(6)}</td></tr>
+                                <tr><td><Message msgId="layersSelection.statistics.avg"/></td><td>{statistics.mean.toFixed(6)}</td></tr>
+                                <tr><td><Message msgId="layersSelection.statistics.std"/></td><td>{statistics.stdDev.toFixed(6)}</td></tr>
+                            </tbody>
+                        </table>
+                    )}
+                </FlexBox>
+            </ResizableModal>
+        </Portal>
+    );
+};
diff --git a/web/client/plugins/LayersSelection/components/__tests__/EllipsisButton-test.jsx b/web/client/plugins/LayersSelection/components/__tests__/EllipsisButton-test.jsx
new file mode 100644
index 00000000000..5c213767afe
--- /dev/null
+++ b/web/client/plugins/LayersSelection/components/__tests__/EllipsisButton-test.jsx
@@ -0,0 +1,107 @@
+import React from 'react';
+import ReactDOM from 'react-dom';
+import EllipsisButton from '../EllipsisButton';
+import expect from 'expect';
+import TestUtils from 'react-dom/test-utils';
+
+describe('Ellipsis button component', () => {
+    let container;
+    const defaultProps = {
+        node: {},
+        selectionData: {},
+        onAddOrUpdateSelection: () => { },
+        onZoomToExtent: () => { },
+        onAddLayer: () => { },
+        onChangeLayerProperties: () => { }
+    };
+
+    beforeEach((done) => {
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        setTimeout(done);
+    });
+
+    afterEach((done) => {
+        ReactDOM.unmountComponentAtNode(container);
+        document.body.removeChild(container);
+        setTimeout(done);
+    });
+
+    const renderComponent = (props = {}) => {
+        const component = React.createElement(EllipsisButton, {
+            ...defaultProps,
+            ...props
+        });
+        return ReactDOM.render(component, container);
+    };
+
+    const renderComponentWithFakeFeature = (props = {}) => {
+        const GeoJsonfeatures = {
+            "type": "FeatureCollection",
+            "crs": {
+                "type": "name",
+                "properties": {
+                    "name": "EPSG:4326"
+                }
+            },
+            "features": [
+                {
+                    "type": "Feature",
+                    "geometry": {
+                        "type": "Point",
+                        "coordinates": [102.0, 0.5]
+                    },
+                    "properties": {
+                        "name": "Sample Point"
+                    }
+                }
+            ]
+        };
+
+        props.selectionData = GeoJsonfeatures;
+
+        const component = React.createElement(EllipsisButton, {
+            ...defaultProps,
+            ...props
+        });
+        return ReactDOM.render(component, container);
+    };
+
+    describe('render EllipsisButton component', () => {
+        it('should render with default props', () => {
+            renderComponent();
+            expect(container.querySelector('._border-transparent')).toBeTruthy();
+            expect(container.querySelector('.dropdown-toggle')).toBeTruthy();
+        });
+
+        it('should render with default props', () => {
+            renderComponent();
+            expect(container.querySelector('._border-transparent')).toBeTruthy();
+            expect(container.querySelector('.dropdown-toggle')).toBeTruthy();
+        });
+
+        it('should not render statistics when any features are selected', () => {
+            renderComponent();
+            const spanList = [...container.querySelectorAll('span')];
+            const span = spanList.find(el => el.textContent.trim() === 'layersSelection.button.statistics');
+            const link = span.parentElement;
+            TestUtils.Simulate.click(link);
+
+            const modal = document.getElementById('ms-resizable-modal');
+
+            expect(modal).toBeFalsy();
+        });
+
+        it('should  render statistics when a feature at least is selected', () => {
+            renderComponentWithFakeFeature();
+            const spanList = [...container.querySelectorAll('span')];
+            const span = spanList.find(el => el.textContent.trim() === 'layersSelection.button.statistics');
+            const link = span.parentElement;
+            TestUtils.Simulate.click(link);
+
+            const modal = document.getElementById('ms-resizable-modal');
+            expect(modal).toBeTruthy();
+        });
+
+    });
+});
diff --git a/web/client/plugins/LayersSelection/components/__tests__/LayerSelection-test.jsx b/web/client/plugins/LayersSelection/components/__tests__/LayerSelection-test.jsx
new file mode 100644
index 00000000000..a62f52db951
--- /dev/null
+++ b/web/client/plugins/LayersSelection/components/__tests__/LayerSelection-test.jsx
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2025, GeoSolutions Sas.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import expect from 'expect';
+import React from 'react';
+import ReactDOM from 'react-dom';
+import { getLayerFromRecord } from '../../../../api/catalog/ArcGIS';
+
+import SelectComponent from '../LayersSelection';
+
+describe('Select Component', () => {
+    let container;
+
+    beforeEach((done) => {
+        document.body.innerHTML = '<div id="container"></div>';
+        container = document.getElementById('container');
+        setTimeout(done);
+    });
+
+    afterEach((done) => {
+        ReactDOM.unmountComponentAtNode(container);
+        document.body.innerHTML = '';
+        setTimeout(done);
+    });
+
+    const testRecord = {
+        name: 1,
+        title: "TestedLayer",
+        url: "base/web/client/test-resources/arcgis/arcgis-test-data.json"
+    };
+    const layer = getLayerFromRecord(testRecord, { layerBaseConfig: { group: undefined } });
+
+    const defaultProps = {
+        layers: [layer],
+        onUpdateNode: () => { },
+        onClose: () => { },
+        isVisible: true,
+        highlightOptions: {},
+        queryOptions: {},
+        selectTools: [],
+        storeConfiguration: () => { },
+        selections: {},
+        maxFeatureCount: 1,
+        cleanSelection: () => { },
+        addOrUpdateSelection: () => { },
+        zoomToExtent: () => { },
+        addLayer: () => { },
+        changeLayerProperties: () => { }
+    };
+
+
+    it('should render the component container', () => {
+        ReactDOM.render(<SelectComponent {...defaultProps} />, container);
+        const componentContainer = container.querySelector('.select-dialog');
+        expect(componentContainer).toBeTruthy();
+    });
+
+    it('should render the header when container is visible', () => {
+        ReactDOM.render(<SelectComponent {...defaultProps} />, container);
+        const componentContainer = container.querySelector('.select-dialog');
+        const header = componentContainer.querySelector('.modal-header');
+        expect(header).toBeTruthy();
+    });
+
+    it('shouldn\'t render the component when container is not visible', () => {
+        const props = { ...defaultProps };
+        props.isVisible = false;
+        ReactDOM.render(<SelectComponent {...props} />, container);
+        const componentContainer = container.querySelector('.select-dialog');
+        expect(componentContainer).toBe(null);
+    });
+
+    it('should render layers tree', () => {
+        ReactDOM.render(<SelectComponent {...defaultProps} />, container);
+        const layerTreeIsExisting = container.querySelectorAll('.ms-layers-tree');
+        expect(layerTreeIsExisting).toBeTruthy();
+    });
+
+    it('should render layer TestedLayer in the layers tree', () => {
+        ReactDOM.render(<SelectComponent {...defaultProps} />, container);
+        const msnodestitle = container.querySelectorAll('.ms-node-title');
+        const msnodestitleAsArray = Array.from(msnodestitle);
+        const LookingForTestedLayer = msnodestitleAsArray.filter(obj => obj.innerHTML === 'TestedLayer');
+        expect(LookingForTestedLayer.length).toBeGreaterThanOrEqualTo(1);
+
+    });
+});
diff --git a/web/client/plugins/LayersSelection/components/__tests__/Statistics-test.jsx b/web/client/plugins/LayersSelection/components/__tests__/Statistics-test.jsx
new file mode 100644
index 00000000000..5a5b7a31e42
--- /dev/null
+++ b/web/client/plugins/LayersSelection/components/__tests__/Statistics-test.jsx
@@ -0,0 +1,115 @@
+import React from 'react';
+import ReactDOM from 'react-dom';
+import Statistics from '../Statistics';
+import expect from 'expect';
+
+describe('Statistics component', () => {
+    let container;
+    const defaultProps = {
+        fields: [],
+        features: [],
+        setStatisticsOpen: () => { }
+    };
+
+    const MockGeoJsonfeatures = {
+        "type": "FeatureCollection",
+        "crs": {
+            "type": "name",
+            "properties": {
+                "name": "EPSG:4326"
+            }
+        },
+        "features": [
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "Point",
+                    "coordinates": [102.0, 0.5]
+                },
+                "properties": {
+                    "name": "Sample Point",
+                    "value": 10
+                }
+            },
+            {
+                "type": "Feature",
+                "geometry": {
+                    "type": "Point",
+                    "coordinates": [102.0, 0.5]
+                },
+                "properties": {
+                    "name": "Sample Point",
+                    "value": 12
+                }
+            }
+        ]
+    };
+
+    beforeEach((done) => {
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        setTimeout(done);
+    });
+
+    afterEach((done) => {
+        ReactDOM.unmountComponentAtNode(container);
+        document.body.removeChild(container);
+        setTimeout(done);
+    });
+
+
+    const renderComponentWithFakeFeature = (props = {}) => {
+
+
+        props.fields = ['value'];
+        props.features = MockGeoJsonfeatures.features;
+
+        const component = React.createElement(Statistics, {
+            ...defaultProps,
+            ...props
+        });
+        return ReactDOM.render(component, container);
+    };
+
+    describe('render Statistics component', () => {
+        it('should render a statistics table', () => {
+            renderComponentWithFakeFeature();
+
+            // Verifying that the table rows are displayed based on passed props
+            // Should check into document because it's a modal added outside the DOM hierarchy component
+            const table = document.querySelector('.ms-statistics-table');
+            expect(table).toBeTruthy();
+        });
+
+        it('should render a max value of the mocked GeoJSON', () => {
+            renderComponentWithFakeFeature();
+
+            // Verifying that the table rows are displayed based on passed props
+            // Should check into document because it's a modal added outside the DOM hierarchy component
+            const table = document.querySelector('.ms-statistics-table');
+            const allTrs = table.querySelectorAll('tr');
+            const allTrsAsArray = [...allTrs];
+            const trOfMax = allTrsAsArray.find(el => {
+                const spans = [...el.querySelectorAll('span')];
+                const span = spans.find(elSpan => elSpan.textContent.trim() === 'layersSelection.statistics.max');
+                if (span) {
+                    return true;
+                }
+                return false;
+
+            });
+            const LinesOftrMax = trOfMax.querySelectorAll('td');
+            const LinesOftrMaxAsArray = [...LinesOftrMax];
+            // Max is store in second line
+            const max = LinesOftrMaxAsArray[1].innerHTML;
+
+            // GET MAX
+            const maxCalculated = MockGeoJsonfeatures.features.reduce((maxValue, current) => {
+                return (current.properties.value > maxValue.properties.value) ? current : maxValue;
+            }, MockGeoJsonfeatures.features[0]);
+
+            expect(max).toEqual(maxCalculated.properties.value);
+        });
+
+    });
+});
diff --git a/web/client/plugins/LayersSelection/components/layersSelection.css b/web/client/plugins/LayersSelection/components/layersSelection.css
new file mode 100644
index 00000000000..485136fa020
--- /dev/null
+++ b/web/client/plugins/LayersSelection/components/layersSelection.css
@@ -0,0 +1,19 @@
+
+.ms-resizable-modal>.modal-content.select-dialog {
+    top: 0;
+    right: 50px;
+    left: unset;
+}
+
+.select-content * .ms-node-header-info>.ms-node-header-addons:nth-child(3) {
+    flex: 1;
+    justify-content: space-between;
+}
+
+.features-count-displayer {
+    display: flex;
+}
+
+.ms-statistics-table td:first-child {
+    font-weight: bold;
+}
\ No newline at end of file
diff --git a/web/client/plugins/LayersSelection/epics/layersSelection.js b/web/client/plugins/LayersSelection/epics/layersSelection.js
new file mode 100644
index 00000000000..d8a2a520bfa
--- /dev/null
+++ b/web/client/plugins/LayersSelection/epics/layersSelection.js
@@ -0,0 +1,296 @@
+/*
+ * Copyright 2026, GeoSolutions Sas.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { Observable } from 'rxjs';
+import axios from 'axios';
+import { SET_CONTROL_PROPERTY, TOGGLE_CONTROL } from '../../../actions/controls';
+import { UPDATE_NODE, REMOVE_NODE } from '../../../actions/layers';
+import { registerEventListener, unRegisterEventListener} from '../../../actions/map';
+import { shutdownToolOnAnotherToolDrawing } from "../../../utils/ControlUtils";
+import { describeFeatureType, getFeatureURL } from '../../../api/WFS';
+import { extractGeometryAttributeName } from '../../../utils/WFSLayerUtils';
+import { mergeOptionsByOwner, removeAdditionalLayer } from '../../../actions/additionallayers';
+import { highlightStyleSelector } from '../../../selectors/mapInfo';
+import { layersSelector, groupsSelector } from '../../../selectors/layers';
+import { flattenArrayOfObjects, getInactiveNode } from '../../../utils/LayersUtils';
+
+import { optionsToVendorParams } from '../../../utils/VendorParamsUtils';
+import { selectLayersSelector, isSelectEnabled, filterLayerForSelect, isSelectQueriable, getSelectQueryMaxFeatureCount, getSelectHighlightOptions } from '../selectors/layersSelection';
+import { SELECT_CLEAN_SELECTION, ADD_OR_UPDATE_SELECTION, addOrUpdateSelection, UPDATE_SELECTION_FEATURE } from '../actions/layersSelection';
+import { buildAdditionalLayerId, buildAdditionalLayerOwnerName, arcgisToGeoJSON, makeCrsValid, customUpdateAdditionalLayer } from '../utils/LayersSelection';
+
+/**
+ * Queries a given layer based on geometry and type (ArcGIS, WMS, or WFS).
+ *
+ * @param {Object} layer - Layer configuration object.
+ * @param {Object} geometry - Geometry used for spatial filtering.
+ * @param {number} selectQueryMaxCount - Max features to return.
+ * @returns {Promise<Object>} A Promise resolving to a GeoJSON FeatureCollection.
+ */
+const queryLayer = (layer, geometry, selectQueryMaxCount) => {
+    switch (layer.type) {
+    case 'arcgis': {
+        const parsedGeometry = JSON.stringify({
+            spatialReference: { wkid: geometry.projection.split(':')[1] },
+            ...(geometry.type === 'Point'
+                ? { x: geometry.coordinates[0], y: geometry.coordinates[1] }
+                : (geometry.type === 'LineString' ?
+                    { 'paths': [geometry.coordinates] } :
+                    { 'rings': geometry.coordinates }
+                )
+            )
+        });
+        const geometryType = geometry.type === 'Point' ? "esriGeometryPoint" : (geometry.type === 'LineString' ? 'esriGeometryPolyline' : 'esriGeometryPolygon');
+        const singleLayerId = parseInt(layer.name ?? '', 10);
+        return Promise.all((Number.isInteger(singleLayerId) ? layer.options.layers.filter(l => l.id === singleLayerId) : layer.options.layers).map(l => axios.get(`${layer.url}/${l.id}`, { params: { f: 'json'} })
+            .then(describe =>
+                axios.get(`${layer.url}/${l.id}/query`, {
+                    params: {
+                        f: "json",
+                        geometry: parsedGeometry,
+                        geometryType: geometryType,
+                        spatialRel: "esriSpatialRelIntersects",
+                        where: '1=1',
+                        outFields: '*',
+                        // output feature to EPSG:4326
+                        // to make them visible on the vector layer
+                        outSR: '4326',
+                        ...(describe.data.advancedQueryCapabilities.supportsPagination && selectQueryMaxCount > -1 ? { resultRecordCount: selectQueryMaxCount } : {})
+                    }})
+                    .then(response => ({ features: arcgisToGeoJSON(response.data.features, describe.data.name, response.data.fields.find(field => field.type === 'esriFieldTypeOID')?.name ?? response.data.objectIdFieldName ?? 'objectid'), crs: makeCrsValid(describe.data.sourceSpatialReference.wkid.toString()) }))
+                    .catch(err => { throw new Error(`Error while querying layer: ${err.message}`); })
+            )))
+            .then(responses => responses.reduce((acc, response) => {
+                const features = [...acc.features, ...response.features];
+                return {...acc, ...{
+                    features: selectQueryMaxCount > -1 && features.length > selectQueryMaxCount ? features.slice(0, selectQueryMaxCount) : features,
+                    totalFeatures: acc.totalFeatures + response.features.length,
+                    numberMatched: acc.numberMatched + response.features.length,
+                    numberReturned: acc.numberReturned + response.features.length
+                }};
+            }, {
+                type: "FeatureCollection",
+                features: [],
+                totalFeatures: 0,
+                numberMatched: 0,
+                numberReturned: 0,
+                timeStamp: new Date().toISOString(),
+                crs: {
+                    type: "name",
+                    properties: {
+                        name: makeCrsValid(responses[0].crs.toString())     // All layer crs in a MapServer/FeatureServer are the same
+                    }
+                }
+            }))
+            .catch(err => {
+                throw new Error(`Error while querying layer: ${err.message}`);
+            })
+        ;
+    }
+    case 'wms':
+    case 'wfs': {
+        return describeFeatureType(layer.url, layer.name)
+            .then(describe =>
+                axios.get(
+                    getFeatureURL(
+                        layer.url, layer.name,
+                        optionsToVendorParams({
+                            filterObj: {
+                                spatialField: {
+                                    operation: "INTERSECTS",
+                                    attribute: extractGeometryAttributeName(describe),
+                                    geometry: geometry
+                                }
+                            }
+                        })
+                    ),
+                    { params: {
+                        outputFormat: 'application/json',
+                        // force srs to ensure the zoom to function will work
+                        // without converting unsupported projections client side
+                        srsName: 'EPSG:4326',
+                        ...(selectQueryMaxCount > -1 ? {
+                            maxFeatures: selectQueryMaxCount,   // WFS v1.1.0
+                            count: selectQueryMaxCount
+                        } : {})
+                    }}
+                )
+                    .then(response => ({
+                        ...response.data,
+                        ...(response.data.crs === null ? {} :
+                            {
+                                crs: {
+                                    type: response.data.crs.type,
+                                    properties: {...response.data.crs.properties, [response.data.crs.type]: makeCrsValid(response.data.crs.properties[response.data.crs.type])}
+                                }
+                            })
+                    }))
+                    .catch(err => { throw new Error(`Error ${err.status}: ${err.statusText}`); })
+            ).catch(err => { throw new Error(`Error ${err.status}: ${err.statusText}`); });
+    }
+    default:
+        return new Promise((_, reject) => reject(new Error(`Unsupported layer type: ${layer.type}`)));
+    }
+};
+
+/**
+ * Epic triggered when the Select tool is opened.
+ * Registers map click event and synchronizes visibility of additional layers.
+ *
+ * @param {Observable} action$ - Stream of Redux actions.
+ * @param {Object} store - Redux store.
+ * @returns {Observable} Epic stream.
+ */
+export const openSelectEpic = (action$, store) => action$
+    .ofType(SET_CONTROL_PROPERTY, TOGGLE_CONTROL)
+    .filter(action => action.control === "select" && isSelectEnabled(store.getState()))
+    .switchMap(() => Observable.merge(
+        Observable.of(registerEventListener('click', 'select')),
+        ...selectLayersSelector(store.getState()).map(layer => Observable.of(mergeOptionsByOwner(buildAdditionalLayerOwnerName(layer.id), { visibility: layer.visibility })))
+    ));
+
+/**
+ * Epic triggered when the Select tool is closed.
+ * Unregisters map events and hides additional layers.
+ *
+ * @param {Observable} action$ - Stream of Redux actions.
+ * @param {Object} store - Redux store.
+ * @returns {Observable} Epic stream.
+ */
+export const closeSelectEpics = (action$, store) => action$
+    .ofType(SET_CONTROL_PROPERTY, TOGGLE_CONTROL)
+    .filter(action => action.control === "select" && !isSelectEnabled(store.getState()))
+    .switchMap(() => Observable.merge(
+        Observable.of(unRegisterEventListener('click', 'select')),
+        ...selectLayersSelector(store.getState()).map(layer => Observable.of(mergeOptionsByOwner(buildAdditionalLayerOwnerName(layer.id), { visibility: false }))))
+    );
+
+/**
+ * Shuts down the Select tool if another drawing tool is activated.
+ *
+ * @param {Observable} action$ - Stream of Redux actions.
+ * @param {Object} store - Redux store.
+ * @returns {Observable} Epic stream.
+ */
+export const tearDownSelectOnDrawToolActive = (action$, store) => shutdownToolOnAnotherToolDrawing(action$, store, 'select');
+
+/**
+ * Epic triggered at the end of a drawing session.
+ * Queries layers with the drawn geometry and updates the selection.
+ *
+ * @param {Observable} action$ - Stream of Redux actions.
+ * @param {Object} store - Redux store.
+ * @returns {Observable} Epic stream.
+ */
+export const queryLayers = (action$, store) => action$
+    .ofType(UPDATE_SELECTION_FEATURE)
+    .filter((action) => action?.feature?.geometry && isSelectEnabled(store.getState()))
+    .switchMap(action => {
+        const state = store.getState();
+        const selectQueryMaxCount = getSelectQueryMaxFeatureCount(state);
+        return Observable.from(selectLayersSelector(state))
+            .mergeMap(layer => Observable.concat(
+                Observable.of(addOrUpdateSelection(layer, {})),
+                isSelectQueriable(layer)
+                    ? Observable.concat(
+                        Observable.of(addOrUpdateSelection(layer, { loading: true })),
+                        Observable.fromPromise(queryLayer(layer, action.feature.geometry, selectQueryMaxCount))
+                            .map(geoJsonData => addOrUpdateSelection(layer, geoJsonData))
+                            .catch(error => Observable.of(addOrUpdateSelection(layer, { error })))
+                    )
+                    : Observable.empty()
+            ));
+    });
+
+/**
+ * Epic that handles cleaning of selection data and optionally restarts drawing.
+ *
+ * @param {Observable} action$ - Stream of Redux actions.
+ * @param {Object} store - Redux store.
+ * @returns {Observable} Epic stream.
+ */
+export const cleanSelection = (action$, store) => action$
+    .ofType(SELECT_CLEAN_SELECTION)
+    .filter(() => isSelectEnabled(store.getState()))
+    .switchMap(() => Observable.from(selectLayersSelector(store.getState())).flatMap(layer =>
+        Observable.merge(
+            Observable.of(addOrUpdateSelection(layer, {})),
+            Observable.of(mergeOptionsByOwner(buildAdditionalLayerOwnerName(layer.id), {
+                features: [],
+                visibility: false
+            }))
+        )
+    ));
+
+/**
+ * Epic to synchronize visibility of layers and additional layers when their state changes.
+ *
+ * @param {Observable} action$ - Stream of Redux actions.
+ * @param {Object} store - Redux store.
+ * @returns {Observable} Epic stream.
+ */
+export const synchroniseLayersAndAdditionalLayers = (action$, store) => action$
+    .filter(action => action.type === UPDATE_NODE
+        && isSelectEnabled(store.getState())
+        && Object.hasOwn(action.options || {}, 'visibility')
+    )
+    .concatMap(action => {
+        const state = store.getState();
+        const layersForSelect = layersSelector(state).filter(filterLayerForSelect);
+
+        if (layersForSelect?.find(layer => layer.id === action.node)) {
+            return Observable.of(mergeOptionsByOwner(buildAdditionalLayerOwnerName(action.node), { visibility: action.options.visibility }));
+        }
+
+        const groups = flattenArrayOfObjects(groupsSelector(state));
+        return Observable.from(layersForSelect.filter(layer => layer.group?.startsWith(action.node)))
+            .mergeMap(layer => Observable.of(mergeOptionsByOwner(buildAdditionalLayerOwnerName(layer.id), { visibility: !getInactiveNode(layer.group, groups) }))
+            );
+    });
+
+/**
+ * Epic to remove associated additional layers when a source layer is removed.
+ *
+ * @param {Observable} action$ - Stream of Redux actions.
+ * @param {Object} store - Redux store.
+ * @returns {Observable} Epic stream.
+ */
+export const onRemoveLayer = (action$, store) => action$
+    .ofType(REMOVE_NODE)
+    .filter(action => isSelectEnabled(store.getState())
+        && action.nodeType === 'layers'
+    )
+    .mergeMap(action => Observable.of(removeAdditionalLayer({ id: buildAdditionalLayerId(action.node), owner: buildAdditionalLayerOwnerName(action.node) })));
+
+/**
+ * Epic to update the map layer display with new selection results.
+ *
+ * @param {Observable} action$ - Stream of Redux actions.
+ * @param {Object} store - Redux store.
+ * @returns {Observable} Epic stream.
+ */
+export const onSelectionUpdate = (action$, store) => action$
+    .ofType(ADD_OR_UPDATE_SELECTION)
+    .filter(action => isSelectEnabled(store.getState()) && action.layer)
+    .mergeMap(action => Observable.of(customUpdateAdditionalLayer(
+        action.layer.id,
+        action.geoJsonData.features ?? [],
+        action.layer.visibility && action.geoJsonData.error && !action.geoJsonData.loading,
+        { ...highlightStyleSelector(store.getState()), ...getSelectHighlightOptions(store.getState())}
+    )));
+
+export default {
+    openSelectEpic,
+    closeSelectEpics,
+    tearDownSelectOnDrawToolActive,
+    queryLayers,
+    cleanSelection,
+    synchroniseLayersAndAdditionalLayers,
+    onRemoveLayer,
+    onSelectionUpdate
+};
diff --git a/web/client/plugins/LayersSelection/index.js b/web/client/plugins/LayersSelection/index.js
new file mode 100644
index 00000000000..97d7ecd908c
--- /dev/null
+++ b/web/client/plugins/LayersSelection/index.js
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2026, GeoSolutions Sas.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import React from 'react';
+import { connect } from 'react-redux';
+import { createSelector } from 'reselect';
+import { get } from 'lodash';
+import { Glyphicon } from 'react-bootstrap';
+
+import { createPlugin } from '../../utils/PluginsUtils';
+import { layersSelector } from '../../selectors/layers';
+import { updateNode, addLayer, changeLayerProperties } from '../../actions/layers';
+import { zoomToExtent } from '../../actions/map';
+import { toggleControl } from '../../actions/controls';
+import Message from '../../components/I18N/Message';
+
+import SelectComponent from './components/LayersSelection';
+import epics from './epics/layersSelection';
+import layersSelection from './reducers/layersSelection';
+import { storeConfiguration, cleanSelection, addOrUpdateSelection, updateSelectionFeature } from './actions/layersSelection';
+import { getSelectSelections, getSelectQueryMaxFeatureCount, getSelectDrawType, getSelectionFeature } from './selectors/layersSelection';
+import LayersSelectionSupport from './components/LayersSelectionSupport';
+import { removeAdditionalLayer, updateAdditionalLayer } from '../../actions/additionallayers';
+
+/**
+ * Select plugin that enables layer feature selection in the map.
+ * Uses selectors to retrieve visibility, layers, selection results, and feature count.
+  * @class LayersSelection
+  * @memberof plugins
+  * @static
+  * @example
+ */
+export default createPlugin('LayersSelection', {
+    component: connect(
+        createSelector([
+            (state) => get(state, 'controls.layersSelection.enabled'),
+            layersSelector,
+            getSelectSelections,
+            getSelectQueryMaxFeatureCount
+        ], (isVisible, layers, selections, maxFeatureCount) => ({
+            isVisible,
+            layers,
+            selections,
+            maxFeatureCount
+        })),
+        {
+            onClose: toggleControl.bind(null, 'layersSelection', null),
+            onUpdateNode: updateNode,
+            storeConfiguration,
+            cleanSelection,
+            addOrUpdateSelection,
+            zoomToExtent,
+            addLayer,
+            changeLayerProperties
+        }
+    )(SelectComponent),
+    options: {
+        disablePluginIf: "{state('mapType') === 'cesium'}"
+    },
+    reducers: {
+        layersSelection
+    },
+    epics: epics,
+    containers: {
+        BurgerMenu: {
+            name: 'layersSelection',
+            position: 1000,
+            priority: 1,
+            doNotHide: true,
+            text: <Message msgId="layersSelection.title"/>,
+            tooltip: <Message msgId="layersSelection.tooltip"/>,
+            icon: <Glyphicon glyph="hand-down"/>,
+            action: toggleControl.bind(null, 'layersSelection', null),
+            toggle: true
+        },
+        SidebarMenu: {
+            name: 'layersSelection',
+            position: 1000,
+            priority: 2,
+            doNotHide: true,
+            text: <Message msgId="layersSelection.title"/>,
+            tooltip: <Message msgId="layersSelection.tooltip"/>,
+            icon: <Glyphicon glyph="hand-down"/>,
+            action: toggleControl.bind(null, 'layersSelection', null),
+            toggle: true
+        },
+        Toolbar: {
+            name: 'layersSelection',
+            alwaysVisible: true,
+            position: 2,
+            priority: 0,
+            doNotHide: true,
+            tooltip: <Message msgId="layersSelection.title"/>,
+            icon: <Glyphicon glyph="hand-down"/>,
+            action: toggleControl.bind(null, 'layersSelection', null),
+            toggle: true
+        },
+        Map: {
+            name: 'LayersSelectionSupport',
+            Tool: connect(
+                createSelector([getSelectDrawType, getSelectionFeature], (type, feature) => ({
+                    type,
+                    feature
+                })),
+                {
+                    onChange: updateSelectionFeature,
+                    onUpdateLayer: updateAdditionalLayer,
+                    onRemoveLayer: removeAdditionalLayer,
+                    cleanSelection
+                }
+            )(LayersSelectionSupport),
+            alwaysRender: true
+        }
+    }
+});
diff --git a/web/client/plugins/LayersSelection/reducers/__tests__/layersSelection-test.js b/web/client/plugins/LayersSelection/reducers/__tests__/layersSelection-test.js
new file mode 100644
index 00000000000..777553f05f4
--- /dev/null
+++ b/web/client/plugins/LayersSelection/reducers/__tests__/layersSelection-test.js
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2025, GeoSolutions Sas.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import expect from 'expect';
+import layersSelection from '../layersSelection';
+import {
+    storeConfiguration,
+    addOrUpdateSelection,
+    cleanSelection
+} from '../../actions/layersSelection';
+
+const GeoJsonfeatures = {
+    "type": "FeatureCollection",
+    "crs": {
+        "type": "name",
+        "properties": {
+            "name": "EPSG:4326"
+        }
+    },
+    "features": [
+        {
+            "type": "Feature",
+            "geometry": {
+                "type": "Point",
+                "coordinates": [102.0, 0.5]
+            },
+            "properties": {
+                "name": "Sample Point"
+            }
+        }
+    ]
+};
+
+describe('LayersSelection Reducer', () => {
+    const initialState = {
+        cfg: {},
+        selections: {}
+    };
+
+    describe('Initial State', () => {
+        it('should return initial state when state is undefined', () => {
+            const state = layersSelection(undefined, { type: 'UNKNOWN_ACTION' });
+            expect(state).toEqual(initialState);
+        });
+
+        it('should return update state cfg ', () => {
+            const highlightOptions = {};
+            const queryOptions = {};
+
+            const updatedStateToSetcfg = {
+                cfg: { highlightOptions, queryOptions }
+            };
+
+            const state = layersSelection(initialState, storeConfiguration(updatedStateToSetcfg));
+            expect(state.cfg).toEqual(updatedStateToSetcfg);
+        });
+
+        it('should add to selection ', () => {
+
+            const layer = {
+                id: 'fakelayerId'
+            };
+            const state = layersSelection(initialState, addOrUpdateSelection(layer, GeoJsonfeatures));
+            expect(state.selections[layer.id]).toEqual(GeoJsonfeatures);
+        });
+
+        it('should delete selected geom type ', () => {
+            const state = layersSelection(initialState, cleanSelection(null));
+            expect(state.drawType).toBeFalsy();
+            expect(state.selectionFeature).toBeFalsy();
+        });
+    });
+});
diff --git a/web/client/plugins/LayersSelection/reducers/layersSelection.js b/web/client/plugins/LayersSelection/reducers/layersSelection.js
new file mode 100644
index 00000000000..f32280400ea
--- /dev/null
+++ b/web/client/plugins/LayersSelection/reducers/layersSelection.js
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2026, GeoSolutions Sas.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { SELECT_STORE_CFG, ADD_OR_UPDATE_SELECTION, SELECT_CLEAN_SELECTION, UPDATE_SELECTION_FEATURE } from '../actions/layersSelection';
+
+/**
+ * Reducer for managing selection configuration and selection data per layer.
+ *
+ * @param {Object} state - Current selection state.
+ * @param {Object} state.cfg - Selection configuration object.
+ * @param {Object} state.selections - GeoJSON selection results keyed by layer ID.
+ * @param {Object} action - Redux action.
+ * @param {string} action.type - Action type.
+ * @returns {Object} New state after applying the action.
+ */
+export default function layersSelection(state = {cfg: {}, selections: {}}, action) {
+    switch (action.type) {
+    case SELECT_STORE_CFG: {
+        return {
+            ...state,
+            cfg: action.cfg
+        };
+    }
+    case ADD_OR_UPDATE_SELECTION: {
+        return {
+            ...state,
+            selections: {...state.selections, [action.layer.id]: action.geoJsonData}
+        };
+    }
+    case SELECT_CLEAN_SELECTION: {
+        return {
+            ...state,
+            drawType: action.geomType,
+            ...((action.geomType !== state.drawType) && {
+                selectionFeature: null
+            })
+        };
+    }
+    case UPDATE_SELECTION_FEATURE: {
+        return {
+            ...state,
+            selectionFeature: action.feature
+        };
+    }
+    default:
+        return state;
+    }
+}
diff --git a/web/client/plugins/LayersSelection/selectors/__tests__/layersSelection-test.js b/web/client/plugins/LayersSelection/selectors/__tests__/layersSelection-test.js
new file mode 100644
index 00000000000..32a1dd841c0
--- /dev/null
+++ b/web/client/plugins/LayersSelection/selectors/__tests__/layersSelection-test.js
@@ -0,0 +1,30 @@
+import { filterLayerForSelect } from '../layersSelection';
+import expect from 'expect';
+
+
+describe('LayersSelection Selectors', () => {
+
+    describe('Keep a layer', () => {
+
+        const layerToKeep = {
+            group: 'testA',
+            type: 'wms'
+        };
+
+        const filteredLayer = filterLayerForSelect(layerToKeep);
+        expect(filteredLayer).toBeTruthy();
+    });
+
+    describe('filter a layer', () => {
+
+        const layerToFilter = {
+            group: 'background',
+            type: 'wms'
+        };
+
+        const filteredLayer = filterLayerForSelect(layerToFilter);
+        expect(filteredLayer).toBeFalsy();
+    });
+
+
+});
diff --git a/web/client/plugins/LayersSelection/selectors/layersSelection.js b/web/client/plugins/LayersSelection/selectors/layersSelection.js
new file mode 100644
index 00000000000..cf9ac2e9993
--- /dev/null
+++ b/web/client/plugins/LayersSelection/selectors/layersSelection.js
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2026, GeoSolutions Sas.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { get } from 'lodash';
+
+/**
+ * Filters a layer to determine if it's eligible for selection.
+ * Excludes background layers and only allows WMS, WFS, or ArcGIS types.
+ *
+ * @param {Object} layer - A layer object.
+ * @returns {boolean} True if the layer is selectable.
+ */
+export const filterLayerForSelect = layer => layer && layer.group !== 'background' && ['wms', 'wfs', 'arcgis'].includes(layer.type);
+
+/**
+ * Retrieves all selectable layers from the Redux state.
+ *
+ * @param {Object} state - Redux state.
+ * @returns {Array} List of selectable layers.
+ */
+export const selectLayersSelector = state => (get(state, 'layers.flat') || []).filter(filterLayerForSelect);
+
+/**
+ * Checks if the select control is currently enabled.
+ *
+ * @param {Object} state - Redux state.
+ * @returns {boolean} True if selection is enabled.
+ */
+export const isSelectEnabled = state => get(state, "controls.layersSelection.enabled");
+
+/**
+ * Checks if a node explicitly has the `isSelectQueriable` property.
+ *
+ * @param {Object} node - Layer node or descriptor.
+ * @returns {boolean} True if the property exists.
+ */
+export const hasSelectQueriableProp = node => Object.hasOwn(node, 'isSelectQueriable');
+
+/**
+ * Determines whether a layer node is considered selectable.
+ * If `isSelectQueriable` is defined, it uses that.
+ * Otherwise, falls back to `visibility` status.
+ *
+ * @param {Object} node - Layer node or descriptor.
+ * @returns {boolean} True if the node is considered selectable.
+ */
+export const isSelectQueriable = node => hasSelectQueriableProp(node) ? node.isSelectQueriable : !!node?.visibility;
+
+/**
+ * Retrieves the entire `select` object from Redux state.
+ *
+ * @param {Object} state - Redux state.
+ * @returns {Object} Selection-related state object.
+ */
+export const getSelectObj = state => get(state, 'layersSelection') ?? {};
+
+/**
+ * Retrieves query options used for selection.
+ *
+ * @param {Object} state - Redux state.
+ * @returns {Object} Query options configuration.
+ */
+export const getSelectQueryOptions = state => getSelectObj(state).cfg?.queryOptions ?? {};
+
+/**
+ * Gets the maximum number of features to return in a select query.
+ * Defaults to -1 if not defined or invalid.
+ *
+ * @param {Object} state - Redux state.
+ * @returns {number} Maximum feature count for queries.
+ */
+export const getSelectQueryMaxFeatureCount = state => {
+    const queryOptions = getSelectQueryOptions(state);
+    return Number.isInteger(queryOptions.maxCount) ? queryOptions.maxCount : -1;
+};
+
+/**
+ * Retrieves highlight options to apply on selected features.
+ *
+ * @param {Object} state - Redux state.
+ * @returns {Object} Highlight configuration.
+ */
+export const getSelectHighlightOptions = state => getSelectObj(state).cfg?.highlightOptions ?? {};
+
+/**
+ * Retrieves all current selection data, grouped by layer ID.
+ *
+ * @param {Object} state - Redux state.
+ * @returns {Object} A mapping of layer ID to GeoJSON feature collections.
+ */
+export const getSelectSelections = state => getSelectObj(state).selections ?? {};
+
+
+export const getSelectDrawType = state => getSelectObj(state).drawType;
+export const getSelectionFeature = state => getSelectObj(state).selectionFeature;
diff --git a/web/client/plugins/LayersSelection/utils/LayersSelection.js b/web/client/plugins/LayersSelection/utils/LayersSelection.js
new file mode 100644
index 00000000000..235e9091135
--- /dev/null
+++ b/web/client/plugins/LayersSelection/utils/LayersSelection.js
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2026, GeoSolutions Sas.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { updateAdditionalLayer } from '../../../actions/additionallayers';
+import { applyMapInfoStyle } from '../../../selectors/mapInfo';
+
+export const buildAdditionalLayerName = layerId => `"highlight-select-${layerId}-features"`;
+export const buildAdditionalLayerOwnerName = layerId => `Select_${layerId}`;
+export const buildAdditionalLayerId = layerId => `${buildAdditionalLayerOwnerName(layerId)}_id`;
+
+function getGeometryType(geometry) {
+    if (geometry.x !== undefined && geometry.y !== undefined) {
+        return "Point";
+    } else if (geometry.paths) {
+        return "LineString";
+    } else if (geometry.rings) {
+        return "Polygon";
+    }
+    return null;
+}
+
+function convertCoordinates(geometry) {
+    if (geometry.x !== undefined && geometry.y !== undefined) {
+        return [geometry.x, geometry.y];
+    } else if (geometry.paths) {
+        return geometry.paths[0];
+    } else if (geometry.rings) {
+        return geometry.rings;
+    }
+    return null;
+}
+
+export const makeCrsValid = crs => {
+    const crsSplit = crs.toString().split(':');
+    const crsSplitLength = crsSplit.length;
+    if (crsSplitLength === 1) {
+        return 'EPSG' + ':' + crsSplit[0];
+    } else if (crsSplitLength > 1) {
+        const geodeticIndex = crsSplit.lastIndexOf(s => s.length > 0, crsSplitLength - 2);
+        return (geodeticIndex > -1 ? crsSplit[geodeticIndex] : 'EPSG') + ':' + crsSplit[crsSplitLength - 1];
+    }
+    return 'EPSG:4326';
+};
+
+export const arcgisToGeoJSON = (arcgisFeatures, layerName, idField) => arcgisFeatures.map(feature => ({
+    type: "Feature",
+    id: `${layerName}.${feature.attributes[idField]}`,
+    geometry_name: "geometry",
+    geometry: {
+        type: getGeometryType(feature.geometry),
+        coordinates: convertCoordinates(feature.geometry)
+    },
+    properties: feature.attributes
+}));
+
+export const customUpdateAdditionalLayer = (layerId, features, isVisible, highlightStyle) => updateAdditionalLayer(
+    buildAdditionalLayerId(layerId),
+    buildAdditionalLayerOwnerName(layerId),
+    "overlay",
+    {
+        type: "vector",
+        name: buildAdditionalLayerName(layerId),
+        visibility: isVisible,
+        features: features.map(applyMapInfoStyle(highlightStyle))
+    }
+);
diff --git a/web/client/plugins/LayersSelection/utils/_tests_/LayersSelection-test.js b/web/client/plugins/LayersSelection/utils/_tests_/LayersSelection-test.js
new file mode 100644
index 00000000000..7e7b27c83a4
--- /dev/null
+++ b/web/client/plugins/LayersSelection/utils/_tests_/LayersSelection-test.js
@@ -0,0 +1,31 @@
+import { makeCrsValid } from '../LayersSelection';
+import expect from 'expect';
+
+describe('LayersSelection Utils', () => {
+
+    describe('Crs is valid should return same Crs', () => {
+        // TODO
+        // makeCrsValid
+        const mockCRS = 'EPSG:2056';
+        const crs = makeCrsValid(mockCRS);
+        expect(crs).toEqual(mockCRS);
+    });
+
+    describe('CRS number should be convert as valid CRS ', () => {
+        // TODO
+        // makeCrsValid
+        const mockCRS = '2056';
+        const CRSValid = 'EPSG:2056';
+        const crs = makeCrsValid(mockCRS);
+        expect(crs).toEqual(CRSValid);
+    });
+
+    describe('CRS number should not be convert as default if it is valid ', () => {
+        // TODO
+        // makeCrsValid
+        const mockCRS = '2056';
+        const defaultCRS = 'EPSG:4326';
+        const crs = makeCrsValid(mockCRS);
+        expect(crs).toNotEqual(defaultCRS);
+    });
+});
diff --git a/web/client/plugins/TOC/components/LayersTree.jsx b/web/client/plugins/TOC/components/LayersTree.jsx
index 8f913ee2593..451e0e450cc 100644
--- a/web/client/plugins/TOC/components/LayersTree.jsx
+++ b/web/client/plugins/TOC/components/LayersTree.jsx
@@ -68,6 +68,7 @@ const loopGroupCondition = (groupNode, condition) => {
  * @prop {string} noFilteredResultsMsgId message id for no result on filter
  * @prop {object} config optional configuration available for the nodes
  * @prop {boolean} config.sortable activate the possibility to sort nodes
+ * @prop {component} treeHeader display a header on top of the layer tree
  */
 const LayersTree = ({
     tree,
@@ -91,6 +92,7 @@ const LayersTree = ({
     nodeContentItems,
     singleDefaultGroup = isSingleDefaultGroup(tree),
     theme,
+    treeHeader,
     getNodeStyle = () => ({})
 }) => {
 
@@ -148,6 +150,7 @@ const LayersTree = ({
                     event.preventDefault();
                 }}
             >
+                {treeHeader ?? null}
                 {(root || []).map((node, index) => {
                     return (
                         <DefaultLayerOrGroup
diff --git a/web/client/plugins/TOC/components/TOC.jsx b/web/client/plugins/TOC/components/TOC.jsx
index c4b6a4f1335..0115215274f 100644
--- a/web/client/plugins/TOC/components/TOC.jsx
+++ b/web/client/plugins/TOC/components/TOC.jsx
@@ -58,6 +58,7 @@ import {
  * @prop {boolean} config.layerOptions.hideLegend hide the legend of the layer
  * @prop {object} config.layerOptions.legendOptions additional options for WMS legend
  * @prop {boolean} config.layerOptions.hideFilter hide the filter button in the layer nodes
+ * @prop {component} treeHeader display a header on top of the layer tree
  */
 export function ControlledTOC({
     tree,
@@ -79,6 +80,7 @@ export function ControlledTOC({
     nodeContentItems,
     singleDefaultGroup,
     theme,
+    treeHeader,
     getNodeStyle
 }) {
     return (
@@ -106,6 +108,7 @@ export function ControlledTOC({
             nodeToolItems={nodeToolItems}
             nodeContentItems={nodeContentItems}
             singleDefaultGroup={singleDefaultGroup}
+            treeHeader={treeHeader}
             getNodeStyle={getNodeStyle}
         />
     );
@@ -144,6 +147,7 @@ export function ControlledTOC({
  * @prop {boolean} config.layerOptions.hideLegend hide the legend of the layer
  * @prop {object} config.layerOptions.legendOptions additional options for WMS legend
  * @prop {boolean} config.layerOptions.hideFilter hide the filter button in the layer nodes
+ * @prop {component} treeHeader display a header on top of the layer tree
  */
 function TOC({
     map = { layers: [], groups: [] },
@@ -158,7 +162,8 @@ function TOC({
     singleDefaultGroup,
     nodeItems,
     theme,
-    filterText
+    filterText,
+    treeHeader
 }) {
     const { layers } = splitMapAndLayers(map) || {};
     const tree = denormalizeGroups(layers.flat || [], layers.groups || []).groups;
@@ -222,6 +227,7 @@ function TOC({
             nodeToolItems={nodeToolItems}
             nodeContentItems={nodeContentItems}
             singleDefaultGroup={singleDefaultGroup}
+            treeHeader={treeHeader}
         />
     );
 }
diff --git a/web/client/product/plugins.js b/web/client/product/plugins.js
index 69e4b2fd1ec..c48c6fe2166 100644
--- a/web/client/product/plugins.js
+++ b/web/client/product/plugins.js
@@ -96,6 +96,7 @@ export const plugins = {
     LanguagePlugin: toModulePlugin('Language', () => import(/* webpackChunkName: 'plugins/language' */ '../plugins/Language')),
     LayerDownload: toModulePlugin('LayerDownload', () => import(/* webpackChunkName: 'plugins/layerDownload' */ '../plugins/LayerDownload')),
     LayerInfoPlugin: toModulePlugin('LayerInfo', () => import(/* webpackChunkName: 'plugins/layerInfo' */ '../plugins/LayerInfo')),
+    LayersSelectionPlugin: toModulePlugin('LayersSelection', () => import(/* webpackChunkName: 'plugins/layersSelection' */ '../plugins/LayersSelection')),
     LocatePlugin: toModulePlugin('Locate', () => import(/* webpackChunkName: 'plugins/locate' */ '../plugins/Locate')),
     LongitudinalProfileToolPlugin: toModulePlugin('LongitudinalProfileTool', () => import(/* webpackChunkName: 'plugins/LongitudinalProfileTool' */ '../plugins/LongitudinalProfileTool')),
     ManagerMenuPlugin: toModulePlugin('ManagerMenu', () => import(/* webpackChunkName: 'plugins/managerMenu' */ '../plugins/manager/ManagerMenu')),
diff --git a/web/client/themes/default/less/layer-selection.less b/web/client/themes/default/less/layer-selection.less
new file mode 100644
index 00000000000..5daa4f5ef3b
--- /dev/null
+++ b/web/client/themes/default/less/layer-selection.less
@@ -0,0 +1,232 @@
+// @import '../../themes/default/variables.less';
+// @import './assets/select.less';
+// @import './components/EllipsisButton/EllipsisButton.less';
+
+// **************
+// Theme
+// **************
+#ms-components-theme(@theme-vars) {
+    .select-button {
+        .background-color-var(@theme-vars[main-bg]);
+        .border-color-var(@theme-vars[main-border-color]);
+
+        &:hover {
+            .background-color-var(@theme-vars[main-hover-bg]);
+        }
+    }
+
+    .select-button-menu,
+    .ellipsis-menu {
+        .background-color-var(@theme-vars[main-bg]);
+
+        p:hover {
+            .background-color-var(@theme-vars[main-hover-bg]);
+        }
+    }
+
+    .clear-select-button,
+    .ellipsis-button {
+        .background-color-var(@theme-vars[main-bg]);
+        .border-color-var(@theme-vars[main-border-color]);
+
+        &:hover {
+            .background-color-var(@theme-vars[main-hover-bg]);
+        }
+    }
+
+
+
+}
+
+// **************
+// Layout
+// **************
+
+.select-header-container {
+    margin: 2%;
+}
+
+.select-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 10px 0 0 0;
+}
+
+.select-button-container {
+    position: relative;
+    flex: 1;
+    max-width: 65%;
+    border: none;
+}
+
+
+.select-button {
+    border: 1px solid;
+    border-radius: 5px;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    width: 100%;
+    padding: 3px;
+    cursor: pointer;
+}
+
+.select-button-text {
+    flex: 1;
+    text-align: center;
+}
+
+.select-button-arrow {
+    margin-left: auto;
+}
+
+.select-button-menu {
+    position: absolute;
+    top: 100%;
+    left: 0;
+    right: 0;
+    border-radius: 5px;
+    margin-top: 1%;
+    z-index: 1;
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.6);
+}
+
+.select-button-menu p {
+    padding: 2%;
+    margin: 0;
+    cursor: pointer;
+}
+
+
+.clear-select-button {
+    border: 1px solid;
+    border-radius: 5px;
+    cursor: pointer;
+}
+
+
+// **************
+// elipsis button
+// **************
+.ellipsis-container {
+    position: relative;
+    display: inline-block;
+    opacity: 1;
+}
+
+.ellipsis-button {
+    padding: 2%;
+    border: 1px solid;
+    border-radius: 5px;
+    font-weight: bold;
+    cursor: pointer;
+    text-align: center;
+    line-height: 1;
+}
+
+
+.ellipsis-menu {
+    border: 1px solid;
+    position: absolute;
+    top: 100%;
+    right: 0;
+    border-radius: 5px;
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.5);
+    z-index: 1;
+    width: 10vw;
+}
+
+.ellipsis-menu p {
+    margin: 0;
+    padding: 5%;
+    cursor: pointer;
+}
+
+.export-toggle {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    cursor: pointer;
+    padding: 5px 10px;
+}
+
+.export-toggle span:nth-of-type(2) {
+    font-weight: bold;
+}
+
+/**
+SELECT LESS
+*/
+.ms-resizable-modal>.modal-content.select-dialog {
+    top: 0vh;
+    right: -100vw;
+}
+
+
+.select-content * .ms-node-header-info>.ms-node-header-addons:nth-child(3) {
+    flex: 1;
+    justify-content: space-between;
+}
+
+.features-count-displayer {
+    display: flex;
+}
+
+.title-container {
+    display: flex;
+}
+
+.title-icon {
+    height: 100%;
+    width: auto;
+    margin-right: 0.5em;
+}
+
+.title-title {
+    flex-grow: 1;
+    text-align: center;
+}
+
+.features-count {
+    font-weight: bold;
+}
+
+
+/*Statistics*/
+.feature-statistics {
+    display: flex;
+    flex-direction: column;
+    padding: 1rem;
+    width: 100%;
+}
+
+.select-container {
+    display: flex;
+    width: 100%;
+    align-items: center;
+}
+
+.select-container label {
+    font-weight: bold;
+    margin-right: 0.5rem;
+}
+
+.select-container select {
+    flex-grow: 1;
+    padding: 0.5rem;
+    border: 1px solid #ccc;
+}
+
+.statistics-table {
+    width: 100%;
+    margin-top: 1rem;
+}
+
+.statistics-table td {
+    padding: 0.5rem;
+}
+
+.statistics-table td:first-child {
+    font-weight: bold;
+}
diff --git a/web/client/themes/default/less/mapstore.less b/web/client/themes/default/less/mapstore.less
index 4cfb9160d69..dd17ae22036 100644
--- a/web/client/themes/default/less/mapstore.less
+++ b/web/client/themes/default/less/mapstore.less
@@ -91,4 +91,4 @@
 @import "map-popup.less";
 @import "map-views.less";
 @import "permalink.less";
-@import "itinerary.less";
\ No newline at end of file
+@import "itinerary.less";
diff --git a/web/client/themes/default/less/toc.less b/web/client/themes/default/less/toc.less
index e7e74d76fb8..e9f25f286c0 100644
--- a/web/client/themes/default/less/toc.less
+++ b/web/client/themes/default/less/toc.less
@@ -240,14 +240,14 @@
     font-size: 12px;
     padding: 8px;
     border: 2px solid transparent;
-    ul {
+    ul:not(.dropdown-menu) {
         list-style: none;
         border-left: 1px solid transparent;
         padding-left: 16px;
         display: flex;
         flex-direction: column;
     }
-    & > ul {
+    & > ul:not(.dropdown-menu) {
         list-style: none;
         margin-bottom: 0;
         padding: 0;
@@ -255,7 +255,7 @@
     }
     .ms-node-layer {
         .shadow-soft();
-        ul:not(.ms-legend) {
+        ul:not(.ms-legend):not(.dropdown-menu) {
             padding: 4px 8px;
         }
     }
diff --git a/web/client/translations/data.de-DE.json b/web/client/translations/data.de-DE.json
index f9053ba691b..7fa1b65cb5d 100644
--- a/web/client/translations/data.de-DE.json
+++ b/web/client/translations/data.de-DE.json
@@ -1585,6 +1585,43 @@
         }
       }
     },
+    "layersSelection": {
+      "title": "Auswählen",
+      "tooltip": "Auswahlwerkzeug anzeigen",
+      "description": "Auswahlwerkzeug anzeigen",
+      "hasReachMaxCount": "Maximale Anzahl von Elementen erreicht",
+      "selection": "Auswahl",
+      "allLayers": "Alle Schichten",
+      "featuresCount": "Featuresanzahl",
+      "button": {
+        "select": "Auswahlmodus",
+        "chooseGeometry": "Wählen",
+        "selectByPoint": "Punkt",
+        "selectByLine": "Linie",
+        "selectByCircle": "Kreis",
+        "selectByRectangle": "Rechteck",
+        "selectByPolygon": "Polygon",
+        "clear": "Löschen",
+        "zoomTo": "Zoomen auf",
+        "statistics": "Statistiken",
+        "createLayer": "Ebene erstellen",
+        "filterData": "Daten filtern",
+        "export": "Exportieren",
+        "exportToCsv": "Exportieren nach CSV",
+        "exportToJson": "Exportieren nach JSON",
+        "exportToGeoJson": "Exportieren nach GeoJSON"
+      },
+      "statistics": {
+        "title": "Statistiken",
+        "field": "Feld",
+        "count": "Anzahl der Werte",
+        "sum": "Summe der Werte",
+        "min": "Minimum",
+        "max": "Maximum",
+        "avg": "Durchschnitt",
+        "std": "Standardabweichung"
+      }
+    },
     "snapshot": {
       "title": "Snapshot Vorschau",
       "save": "Speichern",
@@ -3585,6 +3622,10 @@
         "description": "Ermöglicht das Erstellen eines Permalinks der aktuell angezeigten Ressource",
         "title": "Permalink"
       },
+      "LayersSelection": {
+        "title": "Auswählen",
+        "description": "Auswahlwerkzeug anzeigen"
+      },
       "StreetView": {
         "title": "Street-View",
         "description": "Tool zum Durchsuchen von Google Street View-Bildern auf der Karte"
diff --git a/web/client/translations/data.en-US.json b/web/client/translations/data.en-US.json
index 302737d4189..a4c61f93871 100644
--- a/web/client/translations/data.en-US.json
+++ b/web/client/translations/data.en-US.json
@@ -1546,6 +1546,43 @@
         }
       }
     },
+    "layersSelection": {
+      "title": "Select",
+      "tooltip": "Display the selection tool",
+      "description": "Display the selection tool",
+      "hasReachMaxCount": "Maximum number of elements reached",
+      "selection": "Selection",
+      "allLayers": "All layers",
+      "featuresCount": "Features number",
+      "button": {
+        "select": "Selection mode",
+        "chooseGeometry": "Choose",
+        "selectByPoint": "Point",
+        "selectByLine": "Line",
+        "selectByCircle": "Circle",
+        "selectByRectangle": "Rectangle",
+        "selectByPolygon": "Polygon",
+        "clear": "Clear",
+        "zoomTo": "Zoom to",
+        "statistics": "Statistics",
+        "createLayer": "Create layer",
+        "filterData": "Filter data",
+        "export": "Export",
+        "exportToCsv": "Export to CSV",
+        "exportToJson": "Export to JSON",
+        "exportToGeoJson": "Export to GeoJSON"
+      },
+      "statistics": {
+        "title": "Statistics",
+        "field": "Field",
+        "count": "Number of values",
+        "sum": "Sum of values",
+        "min": "Minimum",
+        "max": "Maximum",
+        "avg": "Average",
+        "std": "Standard deviation"
+      }
+    },
     "snapshot": {
       "title": "Snapshot Preview",
       "save": "Save",
@@ -3556,6 +3593,10 @@
         "description": "Allows to create a permalink of the current resource in view",
         "title": "Permalink"
       },
+      "LayersSelection": {
+        "title": "Select",
+        "description": "Display the selection tool"
+      },
       "StreetView": {
         "title": "Street View",
         "description": "Street view tool for browsing Google street view images from the map"
diff --git a/web/client/translations/data.es-ES.json b/web/client/translations/data.es-ES.json
index 4401361889b..30da1dc3aec 100644
--- a/web/client/translations/data.es-ES.json
+++ b/web/client/translations/data.es-ES.json
@@ -1546,6 +1546,43 @@
         }
       }
     },
+    "layersSelection": {
+      "title": "Seleccionar",
+      "tooltip": "Mostrar la herramienta de selección",
+      "description": "Mostrar la herramienta de selección",
+      "hasReachMaxCount": "Número máximo de elementos alcanzado",
+      "selection": "Selección",
+      "allLayers": "Todas las capas",
+      "featuresCount": "Número de entidades",
+      "button": {
+        "select": "Modo de selección",
+        "chooseGeometry": "Elegir",
+        "selectByPoint": "Punto",
+        "selectByLine": "Línea",
+        "selectByCircle": "Círculo",
+        "selectByRectangle": "Rectángulo",
+        "selectByPolygon": "Polígono",
+        "clear": "Borrar",
+        "zoomTo": "Hacer zoom en",
+        "statistics": "Estadísticas",
+        "createLayer": "Crear capa",
+        "filterData": "Filtrar datos",
+        "export": "Exportar",
+        "exportToCsv": "Exportar a CSV",
+        "exportToJson": "Exportar a JSON",
+        "exportToGeoJson": "Exportar a GeoJSON"
+      },
+      "statistics": {
+        "title": "Estadísticas",
+        "field": "Campo",
+        "count": "Número de valores",
+        "sum": "Suma de los valores",
+        "min": "Mínimo",
+        "max": "Máximo",
+        "avg": "Promedio",
+        "std": "Desviación estándar"
+      }
+    },
     "snapshot": {
       "title": "Previsualización de la captura del mapa",
       "save": "Guardar",
@@ -3546,6 +3583,10 @@
         "description": "Permite crear un enlace permanente del recurso actual a la vista",
         "title": "Enlace permanente"
       },
+      "LayersSelection": {
+        "title": "Seleccionar",
+        "description": "Mostrar la herramienta de selección"
+      },
       "StreetView": {
         "title": "Street View",
         "description": "Herramienta para buscar imágenes de Google Street View desde el mapa"
diff --git a/web/client/translations/data.fr-FR.json b/web/client/translations/data.fr-FR.json
index 0453e3d99d5..fc3c218e316 100644
--- a/web/client/translations/data.fr-FR.json
+++ b/web/client/translations/data.fr-FR.json
@@ -1547,6 +1547,43 @@
         }
       }
     },
+    "layersSelection": {
+      "title": "Sélectionner",
+      "tooltip": "Afficher l'outil de sélection",
+      "description": "Afficher l'outil de sélection",
+      "hasReachMaxCount": "Nombre d'éléments maximum atteints",
+      "selection": "Sélection",
+      "allLayers": "Toutes les couches",
+      "featuresCount": "Nombre d'entités",
+      "button": {
+        "select": "Mode de sélection",
+        "chooseGeometry": "Choisir",
+        "selectByPoint": "Point",
+        "selectByLine": "Ligne",
+        "selectByCircle": "Cercle",
+        "selectByRectangle": "Rectangle",
+        "selectByPolygon": "Polygone",
+        "clear": "Effacer",
+        "zoomTo": "Zoomer sur",
+        "statistics": "Statistiques",
+        "createLayer": "Créer une couche",
+        "filterData": "Filtrer les données",
+        "export": "Exporter",
+        "exportToCsv": "Exporter en CSV",
+        "exportToJson": "Exporter en JSON",
+        "exportToGeoJson": "Exporter en GeoJSON"
+      },
+      "statistics": {
+        "title": "Statistiques",
+        "field": "Champs",
+        "count": "Nombre de valeurs",
+        "sum": "Somme des valeurs",
+        "min": "Minimum",
+        "max": "Maximum",
+        "avg": "Moyenne",
+        "std": "Écart type"
+      }
+    },
     "snapshot": {
       "title": "Prévisualisation de la capture de la carte",
       "save": "Sauver",
@@ -3547,6 +3584,10 @@
         "description": "Permet de créer un permalien de la ressource courante en vue",
         "title": "Lien permanent"
       },
+      "LayersSelection": {
+        "title": "Sélectionner",
+        "description": "Afficher l'outil de sélection"
+      },
       "StreetView": {
         "title": "Street View",
         "description": "Outil pour parcourir les images Google Street View à partir de la carte"
diff --git a/web/client/translations/data.it-IT.json b/web/client/translations/data.it-IT.json
index 65bffc98458..be0b4156dcb 100644
--- a/web/client/translations/data.it-IT.json
+++ b/web/client/translations/data.it-IT.json
@@ -1546,6 +1546,43 @@
         }
       }
     },
+    "layersSelection": {
+      "title": "Selezionare",
+      "tooltip": "Mostra lo strumento di selezione",
+      "description": "Mostra lo strumento di selezione",
+      "hasReachMaxCount": "Numero massimo di elementi raggiunto",
+      "selection": "Selezione",
+      "allLayers": "Tutti i livelli",
+      "featuresCount": "Numero di entità",
+      "button": {
+        "select": "Modalità di selezione",
+        "chooseGeometry": "Scegliere",
+        "selectByPoint": "Punto",
+        "selectByLine": "Linea",
+        "selectByCircle": "Cerchio",
+        "selectByRectangle": "Rettangolo",
+        "selectByPolygon": "Poligono",
+        "clear": "Cancella",
+        "zoomTo": "Zoom su",
+        "statistics": "Statistiche",
+        "createLayer": "Crea livello",
+        "filterData": "Filtra dati",
+        "export": "Esporta",
+        "exportToCsv": "Esporta in CSV",
+        "exportToJson": "Esporta in JSON",
+        "exportToGeoJson": "Esporta in GeoJSON"
+      },
+      "statistics": {
+        "title": "Statistiche",
+        "field": "Campo",
+        "count": "Numero di valori",
+        "sum": "Somma dei valori",
+        "min": "Minimo",
+        "max": "Massimo",
+        "avg": "Media",
+        "std": "Deviazione standard"
+      }
+    },
     "snapshot": {
       "title": "Istantanea",
       "save": "Salva",
@@ -3548,6 +3585,10 @@
         "description": "Permette di creare un permalink della risorsa attualmente in vista",
         "title": "Permalink"
       },
+      "LayersSelection": {
+        "title": "Selezionare",
+        "description": "Mostra lo strumento di selezione"
+      },
       "StreetView": {
         "title": "Street View",
         "description": "Strumento Street view, per visualizzare le immagini di Google Street View dalla mappa"
diff --git a/web/client/utils/FilterUtils.js b/web/client/utils/FilterUtils.js
index e2194a228dc..d179359eefa 100644
--- a/web/client/utils/FilterUtils.js
+++ b/web/client/utils/FilterUtils.js
@@ -813,6 +813,7 @@ export const getCQLGeometryElement = function(coordinates, type) {
         geometry += coordinates.join(" ");
         break;
     case "MultiPoint":
+    case "LineString":
         coordinates.forEach((position, index) => {
             geometry += position.join(" ");
             geometry += index < coordinates.length - 1 ? ", " : "";
diff --git a/web/client/utils/openlayers/DrawGeometryInteraction.js b/web/client/utils/openlayers/DrawGeometryInteraction.js
index bf7a0a1f75a..b51b4322466 100644
--- a/web/client/utils/openlayers/DrawGeometryInteraction.js
+++ b/web/client/utils/openlayers/DrawGeometryInteraction.js
@@ -13,7 +13,7 @@ import GeoJSON from 'ol/format/GeoJSON';
 import { Point, Polygon, LineString, Circle } from 'ol/geom';
 import {circular} from 'ol/geom/Polygon';
 import {getDistance} from 'ol/sphere';
-import {transform} from 'ol/proj';
+import {fromUserCoordinate, getUserProjection, transform} from 'ol/proj';
 import Feature from 'ol/Feature';
 import { squaredDistance } from 'ol/coordinate';
 import Style from 'ol/style/Style';
@@ -24,6 +24,7 @@ import tinycolor from 'tinycolor2';
 import { never } from 'ol/events/condition';
 import { transformLineToArcs, reproject } from '../CoordinatesUtils';
 import { generateEditingStyle } from '../DrawUtils';
+import { boundingExtent, getBottomLeft, getBottomRight, getTopLeft, getTopRight } from 'ol/extent';
 
 const geoJSON = new GeoJSON();
 
@@ -149,6 +150,36 @@ const defaultGeometryFunction = {
             coordinates: [..._coordinates]
         });
         return _geometry;
+    },
+    'Rectangle': ({ onDrawing }) => (coordinates, geometry, projection) => {
+        const extent = boundingExtent(([
+            coordinates[0],
+            coordinates[coordinates.length - 1]
+        ])
+            .map(function(coordinate) {
+                return fromUserCoordinate(coordinate, projection);
+            }));
+        const boxCoordinates = [[
+            getBottomLeft(extent),
+            getBottomRight(extent),
+            getTopRight(extent),
+            getTopLeft(extent),
+            getBottomLeft(extent)
+        ]];
+        let _geometry = geometry;
+        if (_geometry) {
+            _geometry.setCoordinates(boxCoordinates);
+        } else {
+            _geometry = new Polygon(boxCoordinates);
+        }
+        const userProjection = getUserProjection();
+        if (userProjection) {
+            _geometry.transform(projection, userProjection);
+        }
+        onDrawing({
+            coordinates: [...boxCoordinates]
+        });
+        return _geometry;
     }
 };
 
@@ -162,7 +193,7 @@ function getColor(color, opacity) {
 
 /**
  * Class to manage all the drawing interaction of OpenLayers library
- * @param {string} options.type type of drawing, one of: `Point`, `LineString`, `Polygon` or `Circle`
+ * @param {string} options.type type of drawing, one of: `Point`, `LineString`, `Polygon`, `Rectangle` or `Circle`
  * @param {object} options.map a Cesium map instance
  * @param {number} options.coordinatesLength maximum count of drawing coordinates
  * @param {object} options.style style for drawing geometries, see the `web/client/DrawUtils.js` file
@@ -223,9 +254,10 @@ class OpenLayersDrawGeometryInteraction {
             ? geodesicGeometryFunction[geometryType]
             : defaultGeometryFunction[geometryType];
 
+        const drawType = ['Rectangle'].includes(geometryType) ? 'Circle' : geometryType;
         this._draw = new Draw({
             source: source,
-            type: geometryType,
+            type: drawType,
             maxPoints: coordinatesLength,
             stopClick: true,
             freehandCondition: never,
@@ -258,7 +290,8 @@ class OpenLayersDrawGeometryInteraction {
                     });
                 }
                 if ((olGeometryType === 'Polygon' && ['Polygon', 'Circle'].includes(geometryType))
-                || olGeometryType === 'Circle') {
+                || olGeometryType === 'Circle'
+                || geometryType === 'Rectangle') {
                     return new Style({
                         stroke: lineDrawingStyle,
                         fill: areaDrawingStyle