@esfaenza/es-table 20.3.31 → 20.3.32

package/fesm2022/esfaenza-es-table.mjs

@@ -7787,6 +7787,7 @@ class EsTable2Component {
                 sel.exclusions = sel.exclusions.filter(i => i !== item);
             else if (!sel.exclusions.includes(item))
                 sel.exclusions.push(item);
+            this.selectionAnchor = item;
         }
         else {
             item._selected = !item._selected;
@@ -7885,76 +7886,60 @@ class EsTable2Component {
             this.toggleRow(item);
             return;
         }
-        // Selezione stile Windows (plain / Ctrl / Shift) quando ShiftClick è attivo
-        if (this.ShiftClick() && !this.Hierarchy()) {
+        const shift = !!event?.shiftKey;
+        const ctrl = !!(event?.ctrlKey || event?.metaKey);
+        // Con [ShiftClick] lo Shift+click estende il range dall'ancora (stile Esplora
+        // risorse) e il Ctrl+click fa il toggle della singola riga. Il click SEMPLICE
+        // invece NON è mai "seleziona solo questa": vedi sotto.
+        if (this.ShiftClick() && !this.Hierarchy() && (shift || ctrl)) {
             this.windowsSelect(item, event);
             return;
         }
-        // Comportamento classico: Ctrl+click lascia il default del browser (link, ecc.)
-        if (event?.ctrlKey || event?.metaKey)
+        // Senza [ShiftClick] il Ctrl+click lascia il default del browser (link, ecc.)
+        if (ctrl)
             return;
+        // Click semplice (con o senza [ShiftClick]): riga già selezionata → deseleziona,
+        // riga non selezionata → si AGGIUNGE alla selezione. `toggleRow` aggiorna anche
+        // l'ancora per un eventuale Shift+click successivo.
         this.toggleRow(item);
     }
-    /** Selezione a click stile Esplora risorse: plain=solo questo, Ctrl=toggle, Shift=range dall'ancora */
+    /**
+     * Shift/Ctrl+click stile Esplora risorse, attivo solo con `[ShiftClick]`.
+     *
+     * Lo **Shift+click** estende il range dall'ancora (l'ultima riga cliccata); senza
+     * Ctrl il range SOSTITUISCE la selezione, con Ctrl la somma a quella esistente.
+     * Ogni altro caso (Ctrl+click, o Shift senza un'ancora valida) è un toggle della
+     * singola riga: passa da `toggleRow`, che è il percorso canonico usato anche dalle
+     * checkbox e che gestisce correttamente la modalità "tutto selezionato"
+     * (`sel.all` → toggle dell'esclusione invece di azzerare la selezione).
+     */
     windowsSelect(item, event) {
         if (this.SelectionDisabled() || item?._sep)
             return;
         const rows = this.selectableRows();
-        const sel = this.currentSelection();
         const shift = !!event?.shiftKey;
         const ctrl = !!(event?.ctrlKey || event?.metaKey);
-        // In modalità "tutto selezionato" (selectEverything → sel.all), un Ctrl+click
-        // NON deve azzerare la selezione: deve solo togliere/rimettere la singola riga
-        // dalle esclusioni, mantenendo sel.all. `toggleRow` gestisce già esattamente
-        // questo caso (come fa la checkbox). Senza questo ramo, il reset di sel.all/
-        // exclusions in coda a questa funzione collasserebbe la selezione a 0.
-        if (sel.all && ctrl && !shift) {
+        const anchor = this.selectionAnchor != null ? rows.indexOf(this.selectionAnchor) : -1;
+        if (!shift || anchor < 0) {
             this.toggleRow(item);
             return;
         }
-        if (shift && this.selectionAnchor != null && rows.indexOf(this.selectionAnchor) >= 0) {
-            const a = rows.indexOf(this.selectionAnchor);
-            const b = rows.indexOf(item);
-            if (b >= 0) {
-                const [lo, hi] = a <= b ? [a, b] : [b, a];
-                if (!ctrl) {
-                    for (const r of rows)
-                        r._selected = false;
-                    sel.items = [];
-                }
-                for (let i = lo; i <= hi; i++) {
-                    rows[i]._selected = true;
-                    if (!sel.items.includes(rows[i]))
-                        sel.items.push(rows[i]);
-                }
-                // l'ancora resta invariata per estensioni successive
-            }
-        }
-        else if (ctrl) {
-            item._selected = !item._selected;
-            if (item._selected) {
-                if (!sel.items.includes(item))
-                    sel.items.push(item);
-            }
-            else
-                sel.items = sel.items.filter(i => i !== item);
-            this.selectionAnchor = item;
-        }
-        else {
-            // Re-click sull'unica riga selezionata => deseleziona; altrimenti seleziona solo questa
-            const onlyThisSelected = item._selected && !sel.all && sel.items.length === 1 && sel.items[0] === item;
+        const b = rows.indexOf(item);
+        if (b < 0)
+            return;
+        const sel = this.currentSelection();
+        const [lo, hi] = anchor <= b ? [anchor, b] : [b, anchor];
+        if (!ctrl) {
             for (const r of rows)
                 r._selected = false;
-            if (onlyThisSelected) {
-                sel.items = [];
-                this.selectionAnchor = null;
-            }
-            else {
-                sel.items = [item];
-                item._selected = true;
-                this.selectionAnchor = item;
-            }
+            sel.items = [];
+        }
+        for (let i = lo; i <= hi; i++) {
+            rows[i]._selected = true;
+            if (!sel.items.includes(rows[i]))
+                sel.items.push(rows[i]);
         }
+        // l'ancora resta invariata, così Shift+click successivi ri-estendono da lì
         sel.all = false;
         sel.exclusions = [];
         this.refreshSelectionCount(sel);