@esfaenza/es-table 20.3.48 → 20.3.50

package/fesm2022/esfaenza-es-table.mjs

@@ -8427,6 +8427,11 @@ class EsTable2Component {
     selectEverything() {
         if (this.SelectionDisabled() || this.SingleSelection())
             return;
+        this.selectEverythingState();
+        this.emitSelection(this.currentSelection());
+    }
+    /** Porta la selezione a "tutto selezionato" SENZA emettere (vedi setSelectionStatus) */
+    selectEverythingState() {
         const sel = this.currentSelection();
         sel.all = true;
         sel.items = [];
@@ -8435,7 +8440,6 @@ class EsTable2Component {
             r._selected = true;
         this.refreshSelectionCount(sel);
         this.globalCheck.set(true);
-        this.emitSelection(sel);
     }
     /** Azzera completamente la selezione */
     clearSelection() {
@@ -9419,6 +9423,103 @@ class EsTable2Component {
         this.refresh();
         this.cdr.markForCheck();
     }
+    /**
+     * Imposta in maniera ARBITRARIA lo stato di selezione. Stessa firma dell'es-table
+     * originale, così un consumer che la chiamava continua a compilare.
+     *
+     * A differenza di `toggleRow` (che INVERTE) qui lo stato viene FORZATO: chiamarla
+     * con `select = true` su righe già selezionate non le deseleziona.
+     *
+     * @param {any[]} items Righe da selezionare/deselezionare (ignorato se `all`)
+     * @param {boolean} all Agisce sull'intera ricerca invece che sulle singole righe
+     * @param {boolean} select `true` per selezionare, `false` per deselezionare
+     * @param {boolean} emit Se `true` emette `onSelectionChanged`
+     */
+    setSelectionStatus(items, all, select, emit = false) {
+        if (all) {
+            if (this.SingleSelection()) {
+                console.error('[es-table2] setSelectionStatus: la selezione totale non ha senso con [SingleSelection]');
+                return;
+            }
+            if (!this.SelectAll()) {
+                console.error("[es-table2] setSelectionStatus: impossibile impostare la selezione totale con [SelectAll] a false");
+                return;
+            }
+            // Deselezionare tutto è esattamente `resetSelection`, che gestisce già l'emit
+            if (!select) {
+                this.resetSelection(emit);
+                return;
+            }
+            this.selectEverythingState();
+        }
+        else {
+            this.setRowsSelected(items, select);
+        }
+        const sel = this.currentSelection();
+        if (emit)
+            this.emitSelection(sel);
+        else {
+            this.changed();
+            this.cdr.markForCheck();
+        }
+    }
+    /**
+     * Forza lo stato di selezione di un gruppo di righe. In modalità "tutto
+     * selezionato" si lavora sulle ESCLUSIONI, come fa `toggleRow`: selezionare
+     * significa toglierle dalle esclusioni, deselezionare aggiungerle.
+     *
+     * Il confronto passa da `selKey`, quindi funziona anche con la cache di selezione
+     * attiva (righe rigenerate dal server) e con le righe aggiunte (`_localId`).
+     */
+    setRowsSelected(items, select) {
+        if (this.SelectionDisabled())
+            return;
+        const rows = (items ?? []).filter(it => it != null && !it._sep && !it._group);
+        if (rows.length === 0)
+            return;
+        const sel = this.currentSelection();
+        if (this.SingleSelection()) {
+            if (rows.length > 1)
+                console.error('[es-table2] setSelectionStatus: con [SingleSelection] si imposta una riga alla volta, uso la prima');
+            const only = rows[0];
+            for (const r of this.selectableRows())
+                r._selected = false;
+            sel.all = false;
+            sel.exclusions = [];
+            sel.items = select ? [only] : [];
+            only._selected = select;
+        }
+        else {
+            for (const it of rows)
+                it._selected = select;
+            // Con `all` la lista di lavoro è quella delle esclusioni, e la riga ci deve
+            // stare quando NON è selezionata: la condizione si inverte.
+            const target = sel.all ? sel.exclusions : sel.items;
+            const wantInTarget = sel.all ? !select : select;
+            if (wantInTarget) {
+                // aggiungo deduplicando per chiave, senza riscandire l'array a ogni push
+                const have = new Set(target.map(i => this.selKey(i)));
+                for (const it of rows) {
+                    const k = this.selKey(it);
+                    if (!have.has(k)) {
+                        have.add(k);
+                        target.push(it);
+                    }
+                }
+            }
+            else {
+                const drop = new Set(rows.map(i => this.selKey(i)));
+                const kept = target.filter(i => !drop.has(this.selKey(i)));
+                if (sel.all)
+                    sel.exclusions = kept;
+                else
+                    sel.items = kept;
+            }
+        }
+        this.selectionAnchor = rows[rows.length - 1];
+        this.refreshSelectionCount(sel);
+        this.syncGlobalCheck();
+    }
     /**
      * Azzera la selezione corrente (voci, esclusioni e "tutto selezionato").
      * Come nell'originale l'evento NON viene emesso salvo richiesta esplicita.