@topconsultnpm/sdkui-react 6.22.0-dev2.8 → 6.22.0-dev3.10

package/lib/hooks/useArchiveListForm.d.ts

@@ -0,0 +1,39 @@
+import { MutableRefObject } from 'react';
+import { MetadataValueDescriptorEx } from '../ts';
+/** Modalità "aggiungi a elenco": il form non archivia a sistema, restituisce i metadati al chiamante (TMMultiMasterDetailDcmts). */
+export interface ArchiveListMode {
+    /** true quando si modifica una riga già presente nell'elenco ("Modifica" al posto di "Aggiungi"). */
+    isEditingRow: boolean;
+    /** Restituisce metadati e file al chiamante, che aggiunge o aggiorna la riga nell'elenco (senza archiviare). */
+    onUpsertRow: (metadataValues: Array<MetadataValueDescriptorEx>, file: File | undefined, tid?: number) => void;
+}
+interface UseArchiveListFormParams {
+    /** Assente = modalità "aggiungi a elenco" spenta. */
+    mode?: ArchiveListMode;
+    /** Valori della riga in modifica, con cui pre-compilare il form. */
+    editingRowValues?: Array<{
+        mid: number;
+        value: string;
+    }>;
+    /** Template vuoto del form. */
+    formDataOrig: Array<MetadataValueDescriptorEx>;
+    /** Ref ai valori correnti del form (per leggerli al submit senza stale closure). */
+    formDataRef: MutableRefObject<Array<MetadataValueDescriptorEx>>;
+    /** Ref al file caricato. */
+    dcmtFileRef: MutableRefObject<File | null>;
+    tid?: number;
+    isModal?: boolean;
+    /** Id del form, usato come parentId del message box quando è in modale. */
+    id?: string;
+    /** Svuota il form dopo aver restituito i valori. */
+    clearForm: () => void;
+}
+/** Isola la logica della modalità "aggiungi a elenco": valori di riferimento, submit e chiusura del form. */
+export declare const useArchiveListForm: ({ mode, editingRowValues, formDataOrig, formDataRef, dcmtFileRef, tid, isModal, id, clearForm, }: UseArchiveListFormParams) => {
+    enabled: boolean;
+    isEditingRow: boolean;
+    referenceValues: MetadataValueDescriptorEx[];
+    submit: () => void;
+    requestClose: (isModified: boolean, onClose?: () => void) => boolean;
+};
+export {};

package/lib/hooks/useArchiveListForm.js

@@ -0,0 +1,46 @@
+import { useCallback, useMemo } from 'react';
+import { ButtonNames, TMMessageBoxManager } from '../components';
+/** Isola la logica della modalità "aggiungi a elenco": valori di riferimento, submit e chiusura del form. */
+export const useArchiveListForm = ({ mode, editingRowValues, formDataOrig, formDataRef, dcmtFileRef, tid, isModal, id, clearForm, }) => {
+    const enabled = !!mode;
+    const isEditingRow = !!mode?.isEditingRow;
+    // Valori con cui si confronta il form per capire cosa è cambiato (flag "modificato" ed evidenza gialla).
+    // Modificando una riga si parte dai suoi valori, così i campi pre-compilati non risultano subito modificati.
+    const referenceValues = useMemo(() => {
+        if (!isEditingRow || !editingRowValues || editingRowValues.length === 0)
+            return formDataOrig;
+        return formDataOrig.map(md => {
+            const rowValue = editingRowValues.find(rv => rv.mid === md.mid);
+            return rowValue ? { ...md, value: rowValue.value } : md;
+        });
+    }, [isEditingRow, editingRowValues, formDataOrig]);
+    // Restituisce metadati e file al chiamante, poi svuota il form.
+    const submit = useCallback(() => {
+        if (!mode)
+            return;
+        const values = formDataRef.current.filter(md => md.mid !== undefined && md.mid > 99);
+        mode.onUpsertRow(values, dcmtFileRef.current ?? undefined, tid);
+        clearForm();
+    }, [mode, formDataRef, dcmtFileRef, tid, clearForm]);
+    // Gestisce la chiusura del form
+    const requestClose = useCallback((isModified, onClose) => {
+        if (!mode)
+            return false;
+        if (!isModified) {
+            onClose?.();
+            return true;
+        }
+        TMMessageBoxManager.show({
+            parentId: isModal ? "TMDcmtFormShowConfirmForClose-" + id : undefined,
+            message: "Chiudendo, le modifiche andranno perse. Proseguire?",
+            buttons: [ButtonNames.YES, ButtonNames.NO],
+            onButtonClick: (e) => {
+                // Sì: scarta le modifiche e chiude senza aggiungere all'elenco. No: resta sul form.
+                if (e == ButtonNames.YES)
+                    onClose?.();
+            }
+        });
+        return true;
+    }, [mode, isModal, id]);
+    return { enabled, isEditingRow, referenceValues, submit, requestClose };
+};

package/lib/hooks/useCaseFlowApprove.d.ts

@@ -0,0 +1,56 @@
+import { CaseFlowInstanceDescriptor, CaseFlowWorkItem } from '@topconsultnpm/sdk-ts';
+/**
+ * Attività (workitem) delle PRATICHE assegnate all'utente, con il documento su
+ * cui lavorano già risolto.
+ *
+ * Gemello di `useWorkflowApprove` per il modulo CaseFlow: i dati stanno in una
+ * cache di modulo e le istanze del hook si sincronizzano con un evento, così il
+ * form del documento — da qualunque punto venga aperto — sa che su quel TID/DID
+ * c'è una firma da fare o un'approvazione da dare, senza che il chiamante debba
+ * passargli nulla.
+ */
+/** Workitem di pratica già risolto sul documento cui si riferisce. */
+export interface CaseFlowDcmtWorkItem {
+    caseflow: CaseFlowInstanceDescriptor;
+    workItem: CaseFlowWorkItem;
+    tid: number;
+    did: number;
+}
+/**
+ * Ricarica i workitem di pratica dell'utente. Con `force` ignora la finestra
+ * anti-raffica (da usare dopo un'operazione che li ha modificati).
+ */
+export declare const refreshCaseFlowApproveData: (force?: boolean) => Promise<void>;
+/**
+ * Workitem di pratica pendenti su quel documento (lettura sincrona dalla cache).
+ *
+ * TID/DID vanno NORMALIZZATI: pur essendo tipati `number`, arrivano come stringhe
+ * quando il documento è aperto da una griglia (righe di datagrid) — per lo stesso
+ * motivo il resto della libreria fa `Number(TID)`/`Number(DID)` in ogni confronto.
+ * Senza normalizzazione il confronto stretto falliva, e l'attività risultava
+ * assente aprendo il documento dalla ricerca mentre compariva dal widget "Per te".
+ */
+export declare const getCaseFlowWorkItemsByDcmt: (tid?: number | string, did?: number | string) => CaseFlowDcmtWorkItem[];
+/** Svuota la cache (logout / cambio archivio). */
+export declare const clearCaseFlowApproveData: () => void;
+/** Completa il workitem di pratica e ricarica la cache. */
+export declare const completeCaseFlowWorkItem: (item: CaseFlowDcmtWorkItem, comment?: string) => Promise<void>;
+/** Rifiuta il workitem di pratica (motivo obbligatorio) e ricarica la cache. */
+export declare const rejectCaseFlowWorkItem: (item: CaseFlowDcmtWorkItem, reason: string) => Promise<void>;
+/**
+ * Completa l'attività di FIRMA di una pratica sul documento indicato, se esiste.
+ * La chiama il viewer di firma quando la firma è riuscita: è il gemello di quanto
+ * già avviene per i workitem del workflow legacy.
+ * @returns true se un'attività è stata completata.
+ */
+export declare const completeCaseFlowSignatureForDcmt: (tid: number | string, did: number | string, comment?: string) => Promise<boolean>;
+/**
+ * Attività di pratica sul documento indicato. Senza sessione o senza attività
+ * l'elenco è vuoto e nulla cambia nella UI.
+ */
+export declare const useCaseFlowApprove: (tid?: number | string, did?: number | string) => {
+    caseFlowWorkItems: CaseFlowDcmtWorkItem[];
+    refreshCaseFlowApprove: typeof refreshCaseFlowApproveData;
+    completeCaseFlowWorkItem: typeof completeCaseFlowWorkItem;
+    rejectCaseFlowWorkItem: typeof rejectCaseFlowWorkItem;
+};

package/lib/hooks/useCaseFlowApprove.js

@@ -0,0 +1,157 @@
+import { useCallback, useEffect, useState } from 'react';
+import { SDK_Globals } from '@topconsultnpm/sdk-ts';
+import { CaseFlowService } from '../services/caseflow/CaseFlowService';
+import { getWorkItemTargetDoc, isMoreInfoWorkItem, isSignatureWorkItem } from '../services/caseflow/caseFlowWorkItemUtils';
+const CASEFLOW_APPROVE_CHANGED_EVENT = 'onCaseFlowApproveChange';
+let cache = [];
+let inFlight;
+let lastLoadedAt = 0;
+/**
+ * Finestra minima fra due ricariche: il form del documento chiede un refresh a
+ * ogni apertura e la lista è una scansione delle istanze, non una query puntuale.
+ */
+const MIN_RELOAD_INTERVAL_MS = 15000;
+const notifyChanged = () => {
+    if (typeof window === 'undefined')
+        return;
+    window.dispatchEvent(new CustomEvent(CASEFLOW_APPROVE_CHANGED_EVENT));
+};
+/**
+ * Ricarica la cache: i workitem pendenti dell'utente, risolti sul documento su
+ * cui lavorano. Le richieste di informazioni sono escluse (si rispondono nella
+ * pratica, non sul documento) come i workitem senza documento.
+ */
+const reload = async () => {
+    const userId = SDK_Globals.tmSession?.SessionDescr?.userID;
+    if (userId == null) {
+        cache = [];
+        return;
+    }
+    const groups = await CaseFlowService.getMyPendingWorkItems(userId);
+    const resolved = [];
+    for (const { caseflow, workItems } of groups) {
+        // Le richieste di informazioni si rispondono nella pratica, non sul documento.
+        const relevant = workItems.filter(wi => !isMoreInfoWorkItem(wi));
+        if (relevant.length === 0)
+            continue;
+        // Il TID dell'azione è autorato sul TEMPLATE e non materializzato
+        // sull'istanza: senza template risolto il documento non è calcolabile.
+        if (caseflow.cftid != null) {
+            await CaseFlowService.getTemplate(caseflow.cftid);
+        }
+        // I DOCUMENTI AGGANCIATI non arrivano dalla RetrieveAll (che porta solo i
+        // dati delle card): serve la Retrieve completa, altrimenti `dcmts` è vuoto
+        // e nessun workitem risulterebbe associato a un documento.
+        let instance = caseflow;
+        if ((instance.dcmts?.length ?? 0) === 0 && instance.id != null) {
+            instance = (await CaseFlowService.getCaseflow(instance.id, instance.cftid)) ?? instance;
+        }
+        for (const wi of relevant) {
+            const target = getWorkItemTargetDoc(instance, wi);
+            if (!target)
+                continue;
+            resolved.push({ caseflow: instance, workItem: wi, tid: target.tid, did: target.did });
+        }
+    }
+    cache = resolved;
+    lastLoadedAt = Date.now();
+    // Diagnostica del bring-up: se il Toppy non compare, qui si vede a che punto
+    // la catena si interrompe (nessun workitem / nessun documento risolto).
+    // Rimuovibile una volta stabilizzato il flusso.
+    console.debug('[CaseFlow] attività su documenti:', {
+        istanzeConPendenti: groups.length,
+        workItemPendenti: groups.reduce((n, g) => n + g.workItems.length, 0),
+        risolteSuDocumento: resolved.length,
+        documenti: resolved.map(r => `${r.tid}/${r.did}`),
+    });
+};
+/**
+ * Ricarica i workitem di pratica dell'utente. Con `force` ignora la finestra
+ * anti-raffica (da usare dopo un'operazione che li ha modificati).
+ */
+export const refreshCaseFlowApproveData = async (force = false) => {
+    if (inFlight)
+        return inFlight;
+    if (!force && lastLoadedAt > 0 && Date.now() - lastLoadedAt < MIN_RELOAD_INTERVAL_MS)
+        return;
+    inFlight = reload()
+        .catch(error => { console.error('Errore nel caricare le attività di pratica sui documenti', error); })
+        .finally(() => { inFlight = undefined; notifyChanged(); });
+    return inFlight;
+};
+/**
+ * Workitem di pratica pendenti su quel documento (lettura sincrona dalla cache).
+ *
+ * TID/DID vanno NORMALIZZATI: pur essendo tipati `number`, arrivano come stringhe
+ * quando il documento è aperto da una griglia (righe di datagrid) — per lo stesso
+ * motivo il resto della libreria fa `Number(TID)`/`Number(DID)` in ogni confronto.
+ * Senza normalizzazione il confronto stretto falliva, e l'attività risultava
+ * assente aprendo il documento dalla ricerca mentre compariva dal widget "Per te".
+ */
+export const getCaseFlowWorkItemsByDcmt = (tid, did) => {
+    const t = Number(tid);
+    const d = Number(did);
+    if (!Number.isFinite(t) || !Number.isFinite(d))
+        return [];
+    return cache.filter(r => Number(r.tid) === t && Number(r.did) === d);
+};
+/** Svuota la cache (logout / cambio archivio). */
+export const clearCaseFlowApproveData = () => {
+    cache = [];
+    lastLoadedAt = 0;
+    notifyChanged();
+};
+/** Completa il workitem di pratica e ricarica la cache. */
+export const completeCaseFlowWorkItem = async (item, comment) => {
+    if (item.caseflow.id == null || item.workItem.id == null)
+        return;
+    await CaseFlowService.completeWorkItem(item.caseflow.id, item.workItem.id, comment?.trim() || undefined);
+    await refreshCaseFlowApproveData(true);
+};
+/** Rifiuta il workitem di pratica (motivo obbligatorio) e ricarica la cache. */
+export const rejectCaseFlowWorkItem = async (item, reason) => {
+    if (item.caseflow.id == null || item.workItem.id == null)
+        return;
+    await CaseFlowService.rejectWorkItem(item.caseflow.id, item.workItem.id, reason);
+    await refreshCaseFlowApproveData(true);
+};
+/**
+ * Completa l'attività di FIRMA di una pratica sul documento indicato, se esiste.
+ * La chiama il viewer di firma quando la firma è riuscita: è il gemello di quanto
+ * già avviene per i workitem del workflow legacy.
+ * @returns true se un'attività è stata completata.
+ */
+export const completeCaseFlowSignatureForDcmt = async (tid, did, comment) => {
+    const target = getCaseFlowWorkItemsByDcmt(tid, did).find(r => isSignatureWorkItem(r.workItem));
+    if (!target)
+        return false;
+    await completeCaseFlowWorkItem(target, comment);
+    return true;
+};
+/**
+ * Attività di pratica sul documento indicato. Senza sessione o senza attività
+ * l'elenco è vuoto e nulla cambia nella UI.
+ */
+export const useCaseFlowApprove = (tid, did) => {
+    const readItems = useCallback(() => getCaseFlowWorkItemsByDcmt(tid, did), [tid, did]);
+    const [caseFlowWorkItems, setCaseFlowWorkItems] = useState(readItems);
+    useEffect(() => { setCaseFlowWorkItems(readItems()); }, [readItems]);
+    useEffect(() => {
+        const handleChange = () => setCaseFlowWorkItems(readItems());
+        window.addEventListener(CASEFLOW_APPROVE_CHANGED_EVENT, handleChange);
+        return () => window.removeEventListener(CASEFLOW_APPROVE_CHANGED_EVENT, handleChange);
+    }, [readItems]);
+    // All'apertura di un documento la cache può essere vecchia (attività assegnate
+    // dopo l'ultimo caricamento) o non ancora popolata.
+    useEffect(() => {
+        if (tid == null || did == null)
+            return;
+        void refreshCaseFlowApproveData();
+    }, [tid, did]);
+    return {
+        caseFlowWorkItems,
+        refreshCaseFlowApprove: refreshCaseFlowApproveData,
+        completeCaseFlowWorkItem,
+        rejectCaseFlowWorkItem,
+    };
+};

package/lib/hooks/useDataUserIdItem.d.ts

@@ -3,6 +3,7 @@ import { UserDescriptor } from '@topconsultnpm/sdk-ts';
 export declare const useDataUserIdItem: () => {
     loadUsersAsync: (userIDs: Set<number>) => Promise<void>;
     getUserItem: (userId: number) => UserDescriptor | undefined;
+    getCompleteUserName: (domain: string | undefined, name: string | undefined) => string | undefined;
     clearCache: () => void;
     hasUser: (userId: number) => boolean;
     usersCache: React.MutableRefObject<Map<number, UserDescriptor>>;

package/lib/hooks/useDataUserIdItem.js

@@ -90,6 +90,7 @@ export const useDataUserIdItem = () => {
     return {
         loadUsersAsync,
         getUserItem,
+        getCompleteUserName,
         clearCache,
         hasUser,
         usersCache: usersCacheRef,

package/lib/hooks/useDcmtOperations.d.ts

@@ -24,6 +24,13 @@ export interface DownloadDcmtsAsyncParams {
      * - false (default): usa il nome file recuperato dal backend (file.name) come priorità
      */
     useInputFileName?: boolean;
+    /**
+     * Numero di download eseguiti in parallelo (default 1 = sequenziale, comportamento preesistente).
+     * Valori > 1 vanno usati solo quando il chiamante consuma i file via
+     * `onFileDownloaded`: nel percorso senza callback ogni file genera un click su un
+     * tag <a download>, e più click ravvicinati vengono bloccati dal browser.
+     */
+    downloadConcurrency?: number;
 }
 export interface UseDcmtOperationsReturn {
     abortController: AbortController;

package/lib/hooks/useDcmtOperations.js

@@ -9,6 +9,10 @@ import { importCertificatesAsync } from '../helper/certificateImportHelper';
 import { isXMLFileExt } from '../helper/dcmtsHelper';
 import { ShowConfirm } from '../components/base/TMConfirm';
 import { generateTargetFileName } from '../components/features/documents/copyAndMergeDcmtsShared';
+/** Limite massimo di download paralleli accettato da `downloadDcmtsAsync`. */
+const MAX_DOWNLOAD_CONCURRENCY = 8;
+/** Intervallo minimo (ms) fra due aggiornamenti della progress bar di download. */
+const DOWNLOAD_PROGRESS_THROTTLE_MS = 100;
 const isScannerLicenseConfigured = () => {
     try {
         const scannerLicense = SDKUI_Globals.userSettings.advancedSettings.scannerLicense;
@@ -257,7 +261,7 @@ export const useDcmtOperations = () => {
             ShowAlert({ message: SDKUI_Localizator.ZipCreatedSavedInFolder.replaceParams(zipFileName, "Zip creato con successo"), mode: 'success', duration: 5000, title: SDKUI_Localizator.CompressToZipFile });
         }
     };
-    const _downloadDcmtsAsync = async (inputDcmts, downloadMode = "download", onFileDownloaded, skipConfirmation = false, retrieveOptions, useCache = true, showSuccessAlert = true, useInputFileName = false) => {
+    const _downloadDcmtsAsync = async (inputDcmts, downloadMode = "download", onFileDownloaded, skipConfirmation = false, retrieveOptions, useCache = true, showSuccessAlert = true, useInputFileName = false, downloadConcurrency = 1) => {
         if (inputDcmts === undefined)
             return;
         if (inputDcmts.length <= 0)
@@ -286,85 +290,150 @@ export const useDcmtOperations = () => {
         setShowSecondary(true);
         setWaitPanelTitle(operationTitle);
         abortController = new AbortController();
-        const rfo = new RetrieveFileOptions();
-        rfo.retrieveReason = retrieveOptions?.retrieveReason ?? DcmtOpers.ShowFile;
-        if (retrieveOptions?.cvtFormat !== undefined)
-            rfo.cvtFormat = retrieveOptions.cvtFormat;
-        if (retrieveOptions?.generalRetrieveFormat !== undefined)
-            rfo.generalRetrieveFormat = retrieveOptions.generalRetrieveFormat;
-        rfo.invoiceRetrieveFormat = retrieveOptions?.invoiceRetrieveFormat ?? SDKUI_Globals.userSettings.searchSettings.invoiceRetrieveFormat;
-        rfo.orderRetrieveFormat = retrieveOptions?.orderRetrieveFormat ?? SDKUI_Globals.userSettings.searchSettings.orderRetrieveFormat;
-        let result = [];
-        setWaitPanelMaxValuePrimary(inputDcmts.length);
-        let firstBlock = true;
-        let maxFileSize = 0;
-        for (let i = 0; i < inputDcmts.length; i++) {
-            if (abortController.signal.aborted) {
-                result.push({ rowIndex: i, id1: inputDcmts[i].TID, id2: inputDcmts[i].DID, resultType: ResultTypes.WARNING, description: `Operazione interrotta. Elaborati ${i + 1} documenti` });
-                break;
+        // Riferimento const: il narrowing su inputDcmts non sopravvive dentro le closure del pool.
+        const dcmts = inputDcmts;
+        /**
+         * Ogni richiesta usa la propria istanza di RetrieveFileOptions: con il pool più
+         * download sono in volo contemporaneamente e non possono condividere lo stesso oggetto.
+         */
+        const buildRetrieveFileOptions = (dcmt) => {
+            const rfo = new RetrieveFileOptions();
+            rfo.retrieveReason = retrieveOptions?.retrieveReason ?? DcmtOpers.ShowFile;
+            if (retrieveOptions?.cvtFormat !== undefined)
+                rfo.cvtFormat = retrieveOptions.cvtFormat;
+            if (retrieveOptions?.generalRetrieveFormat !== undefined)
+                rfo.generalRetrieveFormat = retrieveOptions.generalRetrieveFormat;
+            rfo.invoiceRetrieveFormat = retrieveOptions?.invoiceRetrieveFormat ?? SDKUI_Globals.userSettings.searchSettings.invoiceRetrieveFormat;
+            rfo.orderRetrieveFormat = retrieveOptions?.orderRetrieveFormat ?? SDKUI_Globals.userSettings.searchSettings.orderRetrieveFormat;
+            return rfo;
+        };
+        const results = new Array(dcmts.length);
+        setWaitPanelMaxValuePrimary(dcmts.length);
+        // ---- Progress secondaria: aggregata sui download in volo e throttlata ----
+        // Gli eventi di avanzamento di axios arrivano a ogni chunk: senza throttle ognuno
+        // provoca un re-render dell'intera form (relation viewer compreso).
+        const inFlightBytes = new Map();
+        let pendingSecondary;
+        let secondaryTimer;
+        const flushSecondaryProgress = () => {
+            secondaryTimer = undefined;
+            if (!pendingSecondary)
+                return;
+            setWaitPanelMaxValueSecondary(pendingSecondary.max);
+            setWaitPanelValueSecondary(pendingSecondary.value);
+            setWaitPanelTextSecondary(pendingSecondary.text);
+            pendingSecondary = undefined;
+        };
+        const publishSecondaryProgress = () => {
+            let loaded = 0;
+            let total = 0;
+            for (const bytes of inFlightBytes.values()) {
+                loaded += bytes.loaded;
+                total += bytes.total;
             }
-            try {
-                setWaitPanelTextPrimary(`Download file ${i + 1} di ${inputDcmts.length}`);
-                let file;
-                const cacheKey = `${inputDcmts[i].TID}-${inputDcmts[i].DID}`;
-                if (useCache && dcmtsFileCacheDownload.has(cacheKey)) {
-                    file = dcmtsFileCacheDownload.get(cacheKey);
+            pendingSecondary = total > 0
+                ? { value: loaded, max: total, text: `Downloading... ${Globalization.getNumberDisplayValue(loaded, true)} / ${Globalization.getNumberDisplayValue(total, true)}` }
+                : { value: 0, max: 0, text: '' };
+            if (secondaryTimer === undefined)
+                secondaryTimer = setTimeout(flushSecondaryProgress, DOWNLOAD_PROGRESS_THROTTLE_MS);
+        };
+        // ---- Pool di download ----
+        let nextIndex = 0;
+        let started = 0;
+        let completed = 0;
+        let abortReported = false;
+        const downloadOne = async (i) => {
+            started++;
+            setWaitPanelTextPrimary(`Download file ${started} di ${dcmts.length}`);
+            let file;
+            const cacheKey = `${dcmts[i].TID}-${dcmts[i].DID}`;
+            if (useCache && dcmtsFileCacheDownload.has(cacheKey)) {
+                file = dcmtsFileCacheDownload.get(cacheKey);
+            }
+            else {
+                inFlightBytes.set(i, { loaded: 0, total: 0 });
+                try {
+                    file = await SDK_Globals.tmSession?.NewSearchEngine().RetrieveFileAsync(dcmts[i].TID, dcmts[i].DID, buildRetrieveFileOptions(dcmts[i]), abortController.signal, (pd) => {
+                        inFlightBytes.set(i, { loaded: pd.ProgressBarValue, total: pd.ProgressBarMaximum ?? 0 });
+                        publishSecondaryProgress();
+                    });
+                }
+                finally {
+                    inFlightBytes.delete(i);
+                    publishSecondaryProgress();
+                }
+            }
+            completed++;
+            setWaitPanelValuePrimary(completed);
+            if (downloadMode === "openInNewWindow") {
+                if (onFileDownloaded && file) {
+                    onFileDownloaded(file, dcmts[i]);
                 }
                 else {
-                    file = await SDK_Globals.tmSession?.NewSearchEngine().RetrieveFileAsync(inputDcmts[i].TID, inputDcmts[i].DID, rfo, abortController.signal, (pd) => {
-                        if (firstBlock) {
-                            maxFileSize = pd.ProgressBarMaximum ?? 0;
-                            setWaitPanelMaxValueSecondary(maxFileSize);
-                            firstBlock = false;
-                        }
-                        setWaitPanelValueSecondary(pd.ProgressBarValue);
-                        setWaitPanelTextSecondary(`Downloading... ${Globalization.getNumberDisplayValue(pd.ProgressBarValue, true)} / ${Globalization.getNumberDisplayValue(maxFileSize, true)}`);
-                        if (pd.ProgressBarValue === pd.ProgressBarMaximum) {
-                            setWaitPanelMaxValueSecondary(0);
-                            setWaitPanelValueSecondary(0);
-                            setWaitPanelTextSecondary('');
-                            firstBlock = true;
-                        }
-                    });
+                    window.open(window.URL.createObjectURL(file), '_blank', 'noopener');
                 }
-                setWaitPanelValuePrimary(i + 1);
-                const fileURL = window.URL.createObjectURL(file);
-                if (downloadMode === "openInNewWindow") {
-                    (onFileDownloaded && file)
-                        ? onFileDownloaded(file, inputDcmts[i])
-                        : window.open(fileURL, '_blank', 'noopener');
+            }
+            else {
+                if (onFileDownloaded && file) {
+                    await onFileDownloaded(file, dcmts[i]);
                 }
                 else {
-                    if (onFileDownloaded && file) {
-                        await onFileDownloaded(file, inputDcmts[i]);
-                    }
-                    else {
-                        const alink2 = document.createElement('a');
-                        alink2.href = fileURL;
-                        // Usa useInputFileName per determinare la priorità del nome file
-                        alink2.download = getDownloadFileName(file, inputDcmts[i], useInputFileName);
-                        alink2.target = "_blank";
-                        alink2.rel = "noreferrer";
-                        alink2.click();
-                    }
+                    // L'object URL serve solo in questo ramo: creato qui e revocato dopo il
+                    // click, così i blob non restano agganciati al documento per sempre.
+                    const fileURL = window.URL.createObjectURL(file);
+                    const alink2 = document.createElement('a');
+                    alink2.href = fileURL;
+                    // Usa useInputFileName per determinare la priorità del nome file
+                    alink2.download = getDownloadFileName(file, dcmts[i], useInputFileName);
+                    alink2.target = "_blank";
+                    alink2.rel = "noreferrer";
+                    alink2.click();
+                    // 60s come per l'iframe di stampa: revocare troppo presto può far fallire
+                    // il download se il browser non ha ancora risolto il blob URL.
+                    setTimeout(() => window.URL.revokeObjectURL(fileURL), 60000);
                 }
-                if (useCache) {
-                    if (dcmtsFileCacheDownload.size >= CACHE_SIZE_LIMIT) {
-                        const oldestKey = dcmtsFileCacheDownload.keys().next().value;
-                        dcmtsFileCacheDownload.delete(oldestKey);
-                    }
-                    dcmtsFileCacheDownload.set(cacheKey, file);
+            }
+            if (useCache) {
+                if (dcmtsFileCacheDownload.size >= CACHE_SIZE_LIMIT) {
+                    const oldestKey = dcmtsFileCacheDownload.keys().next().value;
+                    dcmtsFileCacheDownload.delete(oldestKey);
                 }
-                result.push({ rowIndex: i, id1: inputDcmts[i].TID, id2: inputDcmts[i].DID, resultType: ResultTypes.SUCCESS });
+                dcmtsFileCacheDownload.set(cacheKey, file);
             }
-            catch (ex) {
-                result.push({ rowIndex: i, id1: inputDcmts[i].TID, id2: inputDcmts[i].DID, resultType: ResultTypes.ERROR, description: getExceptionMessage(ex) });
-                const err = ex;
-                if (err.name === 'CanceledError') {
-                    ShowAlert({ message: err.message, mode: 'warning', duration: 3000, title: 'Abort' });
+            results[i] = { rowIndex: i, id1: dcmts[i].TID, id2: dcmts[i].DID, resultType: ResultTypes.SUCCESS };
+        };
+        const runWorker = async () => {
+            while (true) {
+                const i = nextIndex++;
+                if (i >= dcmts.length)
+                    return;
+                if (abortController.signal.aborted) {
+                    // Un solo avviso di interruzione anche quando più worker si fermano insieme.
+                    if (!abortReported) {
+                        abortReported = true;
+                        results[i] = { rowIndex: i, id1: dcmts[i].TID, id2: dcmts[i].DID, resultType: ResultTypes.WARNING, description: `Operazione interrotta. Elaborati ${completed} documenti` };
+                    }
+                    return;
+                }
+                try {
+                    await downloadOne(i);
+                }
+                catch (ex) {
+                    results[i] = { rowIndex: i, id1: dcmts[i].TID, id2: dcmts[i].DID, resultType: ResultTypes.ERROR, description: getExceptionMessage(ex) };
+                    const err = ex;
+                    if (err.name === 'CanceledError') {
+                        ShowAlert({ message: err.message, mode: 'warning', duration: 3000, title: 'Abort' });
+                    }
                 }
             }
-        }
+        };
+        // `|| 1` intercetta NaN/0/negativi: senza, Array.from({length: NaN}) non creerebbe
+        // alcun worker e il download terminerebbe in silenzio senza scaricare nulla.
+        const workers = Math.max(1, Math.min(Math.trunc(downloadConcurrency) || 1, MAX_DOWNLOAD_CONCURRENCY, dcmts.length));
+        await Promise.all(Array.from({ length: workers }, () => runWorker()));
+        if (secondaryTimer !== undefined)
+            clearTimeout(secondaryTimer);
+        const result = results.filter((r) => r !== undefined);
         setWaitPanelTextPrimary('');
         setWaitPanelMaxValuePrimary(0);
         setWaitPanelValuePrimary(0);
@@ -436,12 +505,13 @@ export const useDcmtOperations = () => {
     };
     const downloadDcmtsAsync = async (params) => {
         const { inputDcmts, downloadType = DownloadTypes.Attachment, downloadMode = "download", onFileDownloaded, confirmAttachments, skipConfirmation = false, retrieveOptions, useCache = true, showSuccessAlert = true, useInputFileName = false, // Default: usa il nome dal backend
+        downloadConcurrency = 1, // Default: sequenziale
          } = params;
         switch (downloadType) {
             // Per il download di documenti, passa useInputFileName per controllare la priorità del nome
-            case DownloadTypes.Dcmt: return await _downloadDcmtsAsync(inputDcmts, downloadMode, onFileDownloaded, skipConfirmation, retrieveOptions, useCache, showSuccessAlert, useInputFileName);
+            case DownloadTypes.Dcmt: return await _downloadDcmtsAsync(inputDcmts, downloadMode, onFileDownloaded, skipConfirmation, retrieveOptions, useCache, showSuccessAlert, useInputFileName, downloadConcurrency);
             case DownloadTypes.Attachment: return await _downloadAttachmentsAsync(inputDcmts, confirmAttachments, showSuccessAlert);
-            default: return await _downloadDcmtsAsync(inputDcmts, undefined, undefined, skipConfirmation, retrieveOptions, useCache, showSuccessAlert, useInputFileName);
+            default: return await _downloadDcmtsAsync(inputDcmts, undefined, undefined, skipConfirmation, retrieveOptions, useCache, showSuccessAlert, useInputFileName, downloadConcurrency);
         }
     };
     const uploadDcmtsAsync = async (inputDcmts, operationTitle, operType, actionAfterOperationAsync) => {

package/lib/hooks/useDocumentOperations.d.ts

@@ -105,10 +105,13 @@ interface UseDocumentOperationsProps {
 }
 export interface UseDocumentOperationsResult {
     operationItems: Array<TMContextMenuItemProps>;
+    selectedDcmtInfos: Array<DcmtInfo>;
     renderFloatingBar: React.ReactNode;
     renderDcmtOperations: React.ReactNode;
     features: {
         isOpenDcmtForm: boolean;
+        /** Il form del documento è aperto come popup sopra il contenuto, che resta visibile sotto */
+        isDcmtFormModal: boolean;
         openFormHandler: (layoutMode: LayoutModes) => void;
         dcmtFormLayoutMode: LayoutModes;
         onDcmtFormOpenChange: (isOpen: boolean, layoutMode: LayoutModes) => void;
@@ -118,6 +121,7 @@ export interface UseDocumentOperationsResult {
         closeDcmtFormHandler: () => void;
         handleSignApprove: () => void;
         showSearchTMDatagrid: boolean;
+        showDcmtTypesSelection: boolean;
         showExportForm: boolean;
         checkoutInfo: UseCheckInOutOperationsReturn;
         relatedDocumentsInfo: UseRelatedDocumentsReturn;