@topconsultnpm/sdkui-react 6.22.0-dev3.7 → 6.22.0-dev3.9

package/lib/components/base/TMTabControl.d.ts

@@ -36,6 +36,8 @@ export interface TMTabControlProps {
     hideBarWhenSingle?: boolean;
     /** Se valorizzata mostra la 'x' sui tab e notifica la richiesta di chiusura. */
     onTabClose?: (id: string) => void;
+    /** Se true anche l'ultimo tab rimasto e chiudibile, lasciando il controllo senza tab. Default false. */
+    closableWhenSingle?: boolean;
     /** Se valorizzata abilita la rinomina del titolo. */
     onTabRename?: (id: string, label: string) => void;
     /** Se valorizzata abilita lo spostamento con trascinamento: sposta draggedId nella posizione di targetId. */

package/lib/components/base/TMTabControl.js

@@ -341,7 +341,7 @@ const shortenLabel = (label) => {
 /** Contenitore dichiarativo di un tab: figlio diretto di TMTabControl, non renderizza nulla di suo. */
 export const TMTabPanel = ({ children }) => _jsx(_Fragment, { children: children });
 const TMTabControl = (props) => {
-    const { selectedId, defaultSelectedId, onSelectedIdChange, hideBarWhenSingle = false, onTabClose, onTabRename, onTabReorder, onTabAdd, tabMenuItems, addCaption = SDKUI_Localizator.AddTab, renameCaption = SDKUI_Localizator.Rename, closeCaption = SDKUI_Localizator.Close, closeOtherCaption = SDKUI_Localizator.CloseOtherTabs, variant = 'module', textColor, idleTextColor, contentAnimation = 'none', animationDuration = 300, swipeEnabled = true, contentStyle, style, children } = props;
+    const { selectedId, defaultSelectedId, onSelectedIdChange, hideBarWhenSingle = false, onTabClose, closableWhenSingle = false, onTabRename, onTabReorder, onTabAdd, tabMenuItems, addCaption = SDKUI_Localizator.AddTab, renameCaption = SDKUI_Localizator.Rename, closeCaption = SDKUI_Localizator.Close, closeOtherCaption = SDKUI_Localizator.CloseOtherTabs, variant = 'module', textColor, idleTextColor, contentAnimation = 'none', animationDuration = 300, swipeEnabled = true, contentStyle, style, children } = props;
     const v = useMemo(() => VARIANTS[variant](), [variant]);
     const titleColor = textColor ?? v.textColor;
     const titleIdleColor = idleTextColor ?? v.idleTextColor;
@@ -523,8 +523,8 @@ const TMTabControl = (props) => {
             // L'input si apre dopo la chiusura del menu, altrimenti perde subito il focus
             pushOwn({ name: renameCaption, icon: _jsx(IconEdit, { fontSize: 18 }), onClick: () => { closeMenu(); setTimeout(() => setEditingId(panel.props.id), 0); } });
         }
-        // Come per la 'x': l'ultimo tab rimasto non si chiude
-        if (onTabClose && panel.props.closable !== false && panels.length > 1) {
+        // Come per la 'x': l'ultimo tab rimasto non si chiude, salvo closableWhenSingle
+        if (onTabClose && panel.props.closable !== false && (closableWhenSingle || panels.length > 1)) {
             pushOwn({ name: closeCaption, icon: _jsx(IconCloseOutline, { fontSize: 18 }), onClick: () => { closeMenu(); onTabClose(panel.props.id); } });
         }
         // Chiude in blocco gli altri tab chiudibili, ma prima chiede conferma dicendo quanti sono
@@ -547,7 +547,7 @@ const TMTabControl = (props) => {
             pushOwn({ name: addCaption, icon: _jsx(IconAdd, { fontSize: 18 }), onClick: () => { closeMenu(); onTabAdd(); } }, items.length > 0);
         }
         return items;
-    }, [panels, tabMenuItems, onTabRename, onTabClose, onTabAdd, renameCaption, closeCaption, closeOtherCaption, addCaption]);
+    }, [panels, tabMenuItems, onTabRename, onTabClose, closableWhenSingle, onTabAdd, renameCaption, closeCaption, closeOtherCaption, addCaption]);
     // Tasto destro sul tab: niente menu del browser, si apre quello con Rinomina e Chiudi.
     const openMenu = (e, id) => {
         e.preventDefault();
@@ -562,8 +562,9 @@ const TMTabControl = (props) => {
     return (_jsxs("div", { style: { display: 'flex', flexDirection: 'column', minHeight: 0, ...style }, children: [showBar &&
                 _jsxs(TabsHeader, { $v: v, onContextMenu: (e) => e.preventDefault(), children: [arrows.left && _jsx(NavButton, { $v: v, type: 'button', tabIndex: -1, onClick: () => scrollTabs(-1), children: _jsx(IconLeft, { fontSize: 18 }) }), _jsxs(TabsStrip, { $v: v, ref: stripRef, role: 'tablist', onScroll: refreshArrows, onKeyDown: handleBarKeyDown, children: [panels.map((p, index) => {
                                     const isActive = p.props.id === activeId;
-                                    // Con un solo tab la 'x' sparisce: non deve essere possibile restare senza contenuto
-                                    const canClose = !!onTabClose && p.props.closable !== false && panels.length > 1;
+                                    // Con un solo tab la 'x' sparisce: non deve essere possibile restare senza contenuto,
+                                    // a meno che closableWhenSingle non consenta di chiudere anche l'ultimo tab.
+                                    const canClose = !!onTabClose && p.props.closable !== false && (closableWhenSingle || panels.length > 1);
                                     const canRename = !!onTabRename && p.props.renamable !== false && typeof p.props.label === 'string';
                                     const isDropTarget = !!dragId && dropId === p.props.id && dragId !== p.props.id;
                                     const draggedIndex = panels.findIndex(t => t.props.id === dragId);

package/lib/components/base/TMTreeView.js

@@ -147,15 +147,26 @@ const TMTreeView = ({ dataSource = [], focusedItem, selectedItems = [], allowMul
             return [];
         return flattenTreeWithDepth(dataSource);
     }, [enableVirtualization, dataSource, flattenTreeWithDepth]);
+    // Chiave dell'ultimo elemento verso cui si è effettivamente scrollato.
+    // Evita di ripetere lo scroll quando cambia solo la struttura dell'albero
+    // (es. espansione di un nodo) a parità di elemento focalizzato.
+    const lastScrolledKeyRef = useRef(undefined);
     // Scroll verso l'elemento focalizzato quando cambia (navigazione con frecce)
     useEffect(() => {
-        if (!focusedItem?.key)
+        if (!focusedItem?.key) {
+            lastScrolledKeyRef.current = undefined;
+            return;
+        }
+        // Focus invariato: l'effect è stato rieseguito solo perché l'albero è cambiato
+        // (espansione/collasso di un nodo). La posizione di scroll non va toccata.
+        if (lastScrolledKeyRef.current === focusedItem.key)
             return;
         if (enableVirtualization) {
             // Lista virtualizzata: usa scrollToRow per garantire che l'elemento sia visibile
             const index = flattenedItems.findIndex(item => item.node.key === focusedItem.key);
             if (index >= 0 && listRef.current) {
                 listRef.current.scrollToRow({ index, align: 'smart' });
+                lastScrolledKeyRef.current = focusedItem.key;
             }
         }
         else {
@@ -164,6 +175,7 @@ const TMTreeView = ({ dataSource = [], focusedItem, selectedItems = [], allowMul
                 const element = containerRef.current.querySelector(`[data-node-key="${focusedItem.key}"]`);
                 if (element) {
                     element.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+                    lastScrolledKeyRef.current = focusedItem.key;
                 }
             }
         }

package/lib/components/features/documents/TMCopyToFolderForm.js

@@ -20,6 +20,12 @@ import ShowAlert from '../../base/TMAlert';
 import { TMColors } from '../../../utils/theme';
 import TMDownloadRelationViewerSection from './TMDownloadRelationViewerSection';
 import { buildInitialDownloadSettings, fileExists, generateTargetFileName, generateUniqueFileName, getDcmtInfosToDownload, getFloatingLabelStyle, isDirectoryPickerSupported, } from './copyAndMergeDcmtsShared';
+/**
+ * Numero di documenti scaricati in parallelo.
+ * I file vengono consumati via callback (scrittura su cartella o raccolta per lo ZIP),
+ * quindi il parallelismo è sicuro; l'ordine finale è garantito a valle del download.
+ */
+const COPY_DOWNLOAD_CONCURRENCY = 5;
 /**
  * Form per la copia/zip dei documenti in una cartella locale.
  * Logica condivisa con TMMergeToPdfForm è esternalizzata in copyAndMergeDcmtsShared
@@ -111,10 +117,24 @@ const TMCopyToFolderForm = ({ mode, selectedDcmtInfos, onClose, showTMRelationVi
     const handleSeparatorChange = (e) => {
         updateSettings('separatorChar', e.target.value.slice(0, 1));
     };
+    // ---- Serializzazione delle scritture su filesystem ----
+    // I download sono paralleli, le scritture no: fileExists/generateUniqueFileName/
+    // getFileHandle sono check-then-act sulla stessa cartella e due scritture contemporanee
+    // potrebbero sovrascriversi o calcolare lo stesso nome "univoco".
+    const writeChainRef = useRef(Promise.resolve());
+    const runExclusive = (action) => {
+        const result = writeChainRef.current.then(action);
+        // La catena non deve interrompersi se una scrittura fallisce: l'errore viene
+        // comunque propagato al chiamante tramite il promise restituito.
+        writeChainRef.current = result.catch(() => undefined);
+        return result;
+    };
     // ---- Scrittura file nel filesystem locale ----
     const writeFileToFolder = async (file, dcmtInfo) => {
         try {
-            let targetFileName = await generateTargetFileName(file, dcmtInfo, {
+            // Fuori dal lock: con la denominazione da metadati questa fa una chiamata al
+            // server per documento e deve poter andare in parallelo agli altri download.
+            const baseFileName = await generateTargetFileName(file, dcmtInfo, {
                 fileNamingMode: settings.fileNamingMode,
                 separatorChar: settings.separatorChar,
             });
@@ -123,7 +143,7 @@ const TMCopyToFolderForm = ({ mode, selectedDcmtInfos, onClose, showTMRelationVi
                 const url = URL.createObjectURL(file);
                 const a = document.createElement('a');
                 a.href = url;
-                a.download = targetFileName;
+                a.download = baseFileName;
                 document.body.appendChild(a);
                 a.target = '_blank';
                 a.rel = 'noreferrer';
@@ -132,23 +152,29 @@ const TMCopyToFolderForm = ({ mode, selectedDcmtInfos, onClose, showTMRelationVi
                 URL.revokeObjectURL(url);
                 return;
             }
-            const exists = await fileExists(folderHandleRef.current, targetFileName);
-            if (exists) {
-                switch (settings.fileExistsMode) {
-                    case 'skip':
-                        return;
-                    case 'rename':
-                        targetFileName = await generateUniqueFileName(folderHandleRef.current, targetFileName);
-                        break;
-                    case 'overwrite':
-                    default:
-                        break;
+            // Dentro il lock: controllo esistenza, calcolo del nome univoco e scrittura
+            // devono restare un'unica operazione atomica sulla cartella.
+            const folderHandle = folderHandleRef.current;
+            await runExclusive(async () => {
+                let targetFileName = baseFileName;
+                const exists = await fileExists(folderHandle, targetFileName);
+                if (exists) {
+                    switch (settings.fileExistsMode) {
+                        case 'skip':
+                            return;
+                        case 'rename':
+                            targetFileName = await generateUniqueFileName(folderHandle, targetFileName);
+                            break;
+                        case 'overwrite':
+                        default:
+                            break;
+                    }
                 }
-            }
-            const fileHandle = await folderHandleRef.current.getFileHandle(targetFileName, { create: true });
-            const writable = await fileHandle.createWritable();
-            await writable.write(file);
-            await writable.close();
+                const fileHandle = await folderHandle.getFileHandle(targetFileName, { create: true });
+                const writable = await fileHandle.createWritable();
+                await writable.write(file);
+                await writable.close();
+            });
         }
         catch (err) {
             console.error('Errore nella scrittura del file:', err);
@@ -176,10 +202,12 @@ const TMCopyToFolderForm = ({ mode, selectedDcmtInfos, onClose, showTMRelationVi
         retrieveOptions.invoiceRetrieveFormat = settings.invoiceFormat ?? SDKUI_Globals.userSettings.searchSettings.invoiceRetrieveFormat;
         retrieveOptions.orderRetrieveFormat = settings.orderFormat ?? SDKUI_Globals.userSettings.searchSettings.orderRetrieveFormat;
         if (settings.exportMode === 'copy') {
-            await downloadDcmtsAsync({ inputDcmts: dcmtInfosToDownload, downloadType: DownloadTypes.Dcmt, downloadMode: 'download', onFileDownloaded: writeFileToFolder, skipConfirmation: true, retrieveOptions, useCache: false });
+            // Senza handle della cartella ogni file viene salvato con un click su <a download>:
+            // in quel caso si resta sequenziali, perché il browser blocca i click ravvicinati.
+            const copyConcurrency = folderHandleRef.current ? COPY_DOWNLOAD_CONCURRENCY : 1;
+            await downloadDcmtsAsync({ inputDcmts: dcmtInfosToDownload, downloadType: DownloadTypes.Dcmt, downloadMode: 'download', onFileDownloaded: writeFileToFolder, skipConfirmation: true, retrieveOptions, useCache: false, downloadConcurrency: copyConcurrency });
         }
         else if (settings.exportMode === 'zip') {
-            const zipEntries = [];
             const fileNameCounts = new Map();
             const getUniqueZipFileName = (fileName) => {
                 const lowerName = fileName.toLowerCase();
@@ -192,14 +220,25 @@ const TMCopyToFolderForm = ({ mode, selectedDcmtInfos, onClose, showTMRelationVi
                 const ext = dotIndex > 0 ? fileName.substring(dotIndex) : '';
                 return `${baseName} (${count})${ext}`;
             };
+            // Con i download paralleli i file arrivano in ordine di completamento: si raccolgono
+            // in mappa (nome incluso, calcolato in parallelo) e l'archivio viene costruito dopo
+            // nell'ordine di selezione, così i suffissi di deduplica restano quelli sequenziali.
+            const downloadedEntries = new Map();
             const collectFileForZip = async (file, dcmtInfo) => {
                 const targetFileName = await generateTargetFileName(file, dcmtInfo, {
                     fileNamingMode: settings.fileNamingMode,
                     separatorChar: settings.separatorChar,
                 });
-                zipEntries.push({ filename: getUniqueZipFileName(targetFileName), data: file });
+                downloadedEntries.set(`${dcmtInfo.TID}_${dcmtInfo.DID}`, { file, targetFileName });
             };
-            await downloadDcmtsAsync({ inputDcmts: dcmtInfosToDownload, downloadType: DownloadTypes.Dcmt, downloadMode: 'download', onFileDownloaded: collectFileForZip, skipConfirmation: true, retrieveOptions, useCache: false });
+            await downloadDcmtsAsync({ inputDcmts: dcmtInfosToDownload, downloadType: DownloadTypes.Dcmt, downloadMode: 'download', onFileDownloaded: collectFileForZip, skipConfirmation: true, retrieveOptions, useCache: false, downloadConcurrency: COPY_DOWNLOAD_CONCURRENCY });
+            const zipEntries = [];
+            for (const dcmtInfo of dcmtInfosToDownload) {
+                const entry = downloadedEntries.get(`${dcmtInfo.TID}_${dcmtInfo.DID}`);
+                if (!entry)
+                    continue;
+                zipEntries.push({ filename: getUniqueZipFileName(entry.targetFileName), data: entry.file });
+            }
             if (zipEntries.length > 0) {
                 const zipFileName = settings.zipFileName.trim().toLowerCase().endsWith('.zip')
                     ? settings.zipFileName.trim()

package/lib/components/features/documents/TMMasterDetailDcmts.js

@@ -472,7 +472,10 @@ const TMMasterDetailDcmts = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallba
     ], [tmTreeView, tmFormOrResult, focusedItem?.isDcmt, dtdMaster]);
     return (_jsxs("div", { style: { width: '100%', height: '100%', position: 'relative' }, children: [isCheckingFirstLoad && (_jsx(TMLoadingOverlay, { onCancel: handleCancelFirstLoad, onStop: handleStopRelationsCalculation, description: relationsProgress.max > 1
                     ? `${isForMaster ? SDKUI_Localizator.LoadingMasterDocuments : SDKUI_Localizator.LoadingDetailDocuments} (${relationsProgress.value}/${relationsProgress.max})`
-                    : undefined, progressValue: relationsProgress.value, progressMax: relationsProgress.max })), _jsxs("div", { style: isCheckingFirstLoad ? { position: 'absolute', width: 0, height: 0, overflow: 'hidden', opacity: 0, pointerEvents: 'none' } : { width: '100%', height: '100%' }, children: [_jsx(TMLayoutWaitingContainer, { direction: 'vertical', showWaitPanel: showWaitPanel, showWaitPanelPrimary: showPrimary, showWaitPanelSecondary: showSecondary, waitPanelTitle: waitPanelTitle, waitPanelTextPrimary: waitPanelTextPrimary, waitPanelValuePrimary: waitPanelValuePrimary, waitPanelMaxValuePrimary: waitPanelMaxValuePrimary, waitPanelTextSecondary: waitPanelTextSecondary, waitPanelValueSecondary: waitPanelValueSecondary, waitPanelMaxValueSecondary: waitPanelMaxValueSecondary, isCancelable: true, abortController: abortController, children: _jsx(TMPanelManagerProvider, { panels: initialPanels, initialVisibility: allInitialPanelVisibility, defaultDimensions: initialPanelDimensions, initialDimensions: initialPanelDimensions, initialMobilePanelId: 'tmTreeView', children: _jsx(TMPanelManagerContainer, { panels: initialPanels, direction: "horizontal", showToolbar: true }) }) }), renderDcmtOperations, renderFloatingBar] })] }));
+                    : undefined, progressValue: relationsProgress.value, progressMax: relationsProgress.max, 
+                // Con un solo documento in input la chiamata è unica: non ci sono
+                // risultati parziali da mostrare, quindi il pulsante resta disabilitato
+                stopDisabled: (inputDcmts?.length ?? 0) <= 1 })), _jsxs("div", { style: isCheckingFirstLoad ? { position: 'absolute', width: 0, height: 0, overflow: 'hidden', opacity: 0, pointerEvents: 'none' } : { width: '100%', height: '100%' }, children: [_jsx(TMLayoutWaitingContainer, { direction: 'vertical', showWaitPanel: showWaitPanel, showWaitPanelPrimary: showPrimary, showWaitPanelSecondary: showSecondary, waitPanelTitle: waitPanelTitle, waitPanelTextPrimary: waitPanelTextPrimary, waitPanelValuePrimary: waitPanelValuePrimary, waitPanelMaxValuePrimary: waitPanelMaxValuePrimary, waitPanelTextSecondary: waitPanelTextSecondary, waitPanelValueSecondary: waitPanelValueSecondary, waitPanelMaxValueSecondary: waitPanelMaxValueSecondary, isCancelable: true, abortController: abortController, children: _jsx(TMPanelManagerProvider, { panels: initialPanels, initialVisibility: allInitialPanelVisibility, defaultDimensions: initialPanelDimensions, initialDimensions: initialPanelDimensions, initialMobilePanelId: 'tmTreeView', children: _jsx(TMPanelManagerContainer, { panels: initialPanels, direction: "horizontal", showToolbar: true }) }) }), renderDcmtOperations, renderFloatingBar] })] }));
 };
 export default TMMasterDetailDcmts;
 /**
@@ -551,7 +554,7 @@ const TMFormOrResultWrapper = ({ refreshKey, deviceType, focusedItem, onTaskCrea
                 }, fetchRemoteCertificates: fetchRemoteCertificates }, refreshKey) :
             focusedItem?.searchResult === undefined ? (_jsx(TMPanel, { title: SDKUI_Localizator.SearchResult, children: _jsx(TMToppyMessage, { message: SDKUI_Localizator.SelectDocumentToViewSearchResults }) })) : (_jsx(TMSearchResult, { groupId: 'tmFormOrResult', isClosable: deviceType !== DeviceType.MOBILE, context: SearchResultContext.METADATA_SEARCH, allowFloatingBar: false, allowRelations: false, openDcmtFormAsModal: true, searchResults: focusedItem?.searchResult ?? [], showSearchResultSidebar: false, showDcmtFormSidebar: false, autoFocusFirstRow: false, onTaskCreateRequest: onTaskCreateRequest, onClose: () => { setPanelVisibilityById('tmTreeView', true); }, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers, editPdfForm: editPdfForm, onOpenPdfEditorRequest: onOpenPdfEditorRequest, openS4TViewer: openS4TViewer, onOpenS4TViewerRequest: onOpenS4TViewerRequest, enablePinIcons: false, onRefreshAfterAddDcmtToFavs: onRefreshAfterAddDcmtToFavs, showBackButton: false, onRefreshSearchAsyncDatagrid: onRefreshSearchResults, onReferenceClick: handleNavigateToReference, fetchRemoteCertificates: fetchRemoteCertificates }, refreshKey)) }));
 };
-const TMLoadingOverlay = ({ onCancel, onStop, description, cancelText, stopText, progressValue, progressMax }) => {
+const TMLoadingOverlay = ({ onCancel, onStop, description, cancelText, stopText, progressValue, progressMax, stopDisabled }) => {
     // Stesso calcolo di TMWaitPanel: 0 quando il massimo non è ancora noto
     const progressPercent = (progressMax ?? 0) > 0
         ? Math.min(100, ((progressValue ?? 0) / (progressMax ?? 1)) * 100)
@@ -625,20 +628,24 @@ const TMLoadingOverlay = ({ onCancel, onStop, description, cancelText, stopText,
 						.tm-spinner-animation div:nth-child(7):after { top: 63px; left: 17px; background: #782b7d; }
 						.tm-spinner-animation div:nth-child(8) { animation-delay: -0.288s; }
 						.tm-spinner-animation div:nth-child(8):after { top: 56px; left: 12px; background: #782b7d; }
-					` }), _jsxs("div", { className: "tm-spinner-animation", children: [_jsx("div", {}), _jsx("div", {}), _jsx("div", {}), _jsx("div", {}), _jsx("div", {}), _jsx("div", {}), _jsx("div", {}), _jsx("div", {})] })] }), _jsx("span", { style: { fontSize: '14px', color: '#334155', textAlign: 'center' }, children: description ?? SDKUI_Localizator.Loading }), (progressMax ?? 0) > 1 && (_jsxs("div", { style: { width: '260px' }, children: [_jsx("div", { style: { width: '100%', height: '20px', background: '#e0e0e0', borderRadius: '10px', overflow: 'hidden' }, children: _jsx("div", { style: { width: `${progressPercent.toFixed(2)}%`, height: '100%', background: '#4caf50', transition: 'width 0.3s ease' } }) }), _jsxs("p", { style: { fontWeight: 'bold', color: '#333', margin: '8px 0 0', textAlign: 'center' }, children: [progressPercent.toFixed(2), "%"] })] })), (onStop || onCancel) && (_jsxs("div", { style: { marginTop: '4px', display: 'flex', alignItems: 'center', justifyContent: 'center', flexWrap: 'wrap', gap: '10px' }, children: [onStop && (_jsx("button", { onClick: onStop, title: SDKUI_Localizator.StopRelationsCalculation, style: {
+					` }), _jsxs("div", { className: "tm-spinner-animation", children: [_jsx("div", {}), _jsx("div", {}), _jsx("div", {}), _jsx("div", {}), _jsx("div", {}), _jsx("div", {}), _jsx("div", {}), _jsx("div", {})] })] }), _jsx("span", { style: { fontSize: '14px', color: '#334155', textAlign: 'center' }, children: description ?? SDKUI_Localizator.Loading }), (progressMax ?? 0) > 1 && (_jsxs("div", { style: { width: '260px' }, children: [_jsx("div", { style: { width: '100%', height: '20px', background: '#e0e0e0', borderRadius: '10px', overflow: 'hidden' }, children: _jsx("div", { style: { width: `${progressPercent.toFixed(2)}%`, height: '100%', background: '#4caf50', transition: 'width 0.3s ease' } }) }), _jsxs("p", { style: { fontWeight: 'bold', color: '#333', margin: '8px 0 0', textAlign: 'center' }, children: [progressPercent.toFixed(2), "%"] })] })), (onStop || onCancel) && (_jsxs("div", { style: { marginTop: '4px', display: 'flex', alignItems: 'center', justifyContent: 'center', flexWrap: 'wrap', gap: '10px' }, children: [onStop && (_jsx("button", { onClick: onStop, disabled: stopDisabled, title: SDKUI_Localizator.StopRelationsCalculation, style: {
                                 padding: '8px 24px',
                                 fontSize: '13px',
                                 fontWeight: 500,
-                                color: 'white',
-                                background: '#0c448e',
-                                border: '1.5px solid #0c448e',
+                                color: stopDisabled ? '#94a3b8' : 'white',
+                                background: stopDisabled ? '#e2e8f0' : '#0c448e',
+                                border: `1.5px solid ${stopDisabled ? '#e2e8f0' : '#0c448e'}`,
                                 borderRadius: '6px',
-                                cursor: 'pointer',
+                                cursor: stopDisabled ? 'not-allowed' : 'pointer',
                                 transition: 'all 0.2s ease',
                             }, onMouseEnter: (e) => {
+                                if (stopDisabled)
+                                    return;
                                 e.currentTarget.style.background = '#0a3872';
                                 e.currentTarget.style.borderColor = '#0a3872';
                             }, onMouseLeave: (e) => {
+                                if (stopDisabled)
+                                    return;
                                 e.currentTarget.style.background = '#0c448e';
                                 e.currentTarget.style.borderColor = '#0c448e';
                             }, children: stopText ?? SDKUI_Localizator.ShowPartialResults })), onCancel && (_jsx("button", { onClick: onCancel, style: {

package/lib/components/features/documents/TMMergeToPdfForm.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useRef, useState } from 'react';
 import { DownloadTypes } from '../../../ts';
 import { calcResponsiveSizes, getExceptionMessage, IconFolderOpen, IconPlay, IconUndo, SDKUI_Globals, SDKUI_Localizator, } from '../../../helper';
-import { DcmtOpers, FileFormats, GeneralRetrieveFormats, InvoiceRetrieveFormats, OrderRetrieveFormats, ResultTypes, RetrieveFileOptions, ValidationItem, } from '@topconsultnpm/sdk-ts';
+import { DcmtOpers, FileFormats, GeneralRetrieveFormats, InvoiceRetrieveFormats, OrderRetrieveFormats, ResultTypes, ValidationItem, } from '@topconsultnpm/sdk-ts';
 import TMModal from '../../base/TMModal';
 import { useDeviceType } from '../../base/TMDeviceProvider';
 import TMTextBox from '../../editors/TMTextBox';
@@ -18,6 +18,12 @@ import ShowAlert from '../../base/TMAlert';
 import TMTooltip from '../../base/TMTooltip';
 import MergePdfManager from '../../../helper/MergePdfManager';
 import { TMResultManager } from '../../forms/TMResultDialog';
+/**
+ * Numero di documenti scaricati in parallelo durante l'unione.
+ * I file vengono consumati via callback (nessun click su <a download>), quindi il
+ * parallelismo è sicuro; il riordino finale è garantito da pdfFilesMap.
+ */
+const MERGE_DOWNLOAD_CONCURRENCY = 5;
 /**
  * Converte il formato di visualizzazione fatture impostato dall'utente nel corrispondente formato PDF:
  * il foglio di stile SDI resta SDI, in tutti gli altri casi si usa ASW.
@@ -190,16 +196,17 @@ const TMMergeToPdfForm = (props) => {
         }
         // Per i documenti con file, usa il download normale
         if (dcmtsWithFile.length > 0) {
-            const rfo = new RetrieveFileOptions();
-            rfo.retrieveReason = DcmtOpers.None;
-            rfo.generalRetrieveFormat = GeneralRetrieveFormats.OriginalUnsigned;
-            rfo.cvtFormat = FileFormats.PDF;
-            rfo.invoiceRetrieveFormat = toPdfInvoiceRetrieveFormat(SDKUI_Globals.userSettings?.searchSettings.invoiceRetrieveFormat);
-            rfo.orderRetrieveFormat = toPdfOrderRetrieveFormat(SDKUI_Globals.userSettings?.searchSettings.orderRetrieveFormat);
+            const rfo = {
+                retrieveReason: DcmtOpers.None,
+                generalRetrieveFormat: GeneralRetrieveFormats.OriginalUnsigned,
+                cvtFormat: FileFormats.PDF,
+                invoiceRetrieveFormat: toPdfInvoiceRetrieveFormat(SDKUI_Globals.userSettings?.searchSettings.invoiceRetrieveFormat),
+                orderRetrieveFormat: toPdfOrderRetrieveFormat(SDKUI_Globals.userSettings?.searchSettings.orderRetrieveFormat),
+            };
             const collectFileForMerge = async (file, dcmtInfo) => {
                 pdfFilesMap.set(`${dcmtInfo.TID}_${dcmtInfo.DID}`, file);
             };
-            await downloadDcmtsAsync({ inputDcmts: dcmtsWithFile, downloadType: DownloadTypes.Dcmt, downloadMode: 'download', onFileDownloaded: collectFileForMerge, skipConfirmation: true, retrieveOptions: rfo, useCache: false });
+            await downloadDcmtsAsync({ inputDcmts: dcmtsWithFile, downloadType: DownloadTypes.Dcmt, downloadMode: 'download', onFileDownloaded: collectFileForMerge, skipConfirmation: true, retrieveOptions: rfo, useCache: false, downloadConcurrency: MERGE_DOWNLOAD_CONCURRENCY });
         }
         // Ricostruisci l'array pdfFiles nell'ordine originale di selezione
         const pdfFiles = [];

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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@topconsultnpm/sdkui-react",
-    "version": "6.22.0-dev3.7",
+    "version": "6.22.0-dev3.9",
     "description": "",
     "scripts": {
         "test": "echo \"Error: no test specified\" && exit 1",