@topconsultnpm/sdkui-react 6.22.0-dev3.2 → 6.22.0-dev3.20

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

@@ -13,6 +13,7 @@ import TMDcmtIcon from './TMDcmtIcon';
 import TMDataUserIdItemViewer from '../../viewers/TMDataUserIdItemViewer';
 import TMTooltip from '../../base/TMTooltip';
 import TMSpinner from '../../base/TMSpinner';
+import { applyRelationTreeState, collectRelationTreeState, findRelationNodeByPath } from './relationTreeState';
 /**
  * Check if document type has detail relations
  */
@@ -67,8 +68,10 @@ export const getDisplayValueByColumn = (col, value) => {
 };
 /**
  * Convert SearchResultDescriptor to structured data source with metadata
- * For each document, fetches complete metadata using GetMetadataAsync to ensure
- * all metadata properties (isSpecialSearchOutput, permissions, etc.) are available
+ * I valori dei documenti sono GIÀ presenti nelle righe restituite dalla ricerca:
+ * qui vengono solo abbinati ai rispettivi MetadataDescriptor (perm,
+ * isSpecialSearchOutput, ...), risolti UNA SOLA VOLTA per tipo documento.
+ * Nessuna chiamata al server per riga.
  */
 export const searchResultToDataSource = async (searchResult, hideSysMetadata, signal) => {
     const rows = searchResult?.dtdResult?.rows ?? [];
@@ -77,27 +80,28 @@ export const searchResultToDataSource = async (searchResult, hideSysMetadata, si
     const columns = searchResult?.dtdResult?.columns ?? [];
     const tidColIndex = columns.findIndex(col => col.caption?.toUpperCase() === 'TID');
     const didColIndex = columns.findIndex(col => col.caption?.toUpperCase() === 'DID');
+    const firstRow = rows[0] ?? [];
+    const tid = tidColIndex >= 0 && firstRow.length > 0 ? Number(firstRow[tidColIndex]) : searchResult?.fromTID;
+    const firstDid = didColIndex >= 0 && firstRow.length > 0 ? Number(firstRow[didColIndex]) : undefined;
+    const dtdWithMetadata = await DcmtTypeListCacheService.GetWithNotGrantedAsync(tid, firstDid, searchResult);
+    const mdList = dtdWithMetadata?.metadata ?? [];
+    // Posizione di ogni MID nelle colonne del risultato: identica per tutte le righe,
+    // quindi calcolata una volta sola invece di una find() per metadato per riga.
+    const mids = columns.map(col => Number(col.extendedProperties?.["MID"] ?? "0"));
+    const columnByMid = new Map();
+    columns.forEach((col, i) => { if (!columnByMid.has(mids[i]))
+        columnByMid.set(mids[i], col); });
+    const dtdResult = searchResult?.dtdResult;
     for (let index = 0; index < rows.length; index++) {
         // Interruzione richiesta dall'utente: restituisce i documenti già elaborati
         if (signal?.aborted)
             break;
         const row = rows[index];
-        // Extract TID and DID from row
-        const tid = tidColIndex >= 0 ? Number(row[tidColIndex]) : searchResult?.fromTID;
-        const did = didColIndex >= 0 ? Number(row[didColIndex]) : undefined;
-        // Fetch complete metadata for this specific document (like getFilteredMetadata does)
-        const metadata = await SDK_Globals.tmSession?.NewSearchEngine().GetMetadataAsync(tid, did, true);
-        if (metadata) {
-            // Get full DTD with metadata for this document
-            const dtdResult = metadata.dtdResult;
-            const metadataRows = dtdResult?.rows?.[0] ?? [];
-            const mids = metadata.selectMIDs;
-            const dtdWithMetadata = await DcmtTypeListCacheService.GetWithNotGrantedAsync(tid, did, metadata);
-            const mdList = dtdWithMetadata?.metadata ?? [];
+        const item = { rowIndex: index };
+        if (mdList.length > 0) {
             // Convert to MetadataValueDescriptorEx array
-            const metadataList = searchResultToMetadataValues(tid, dtdResult, metadataRows, mids, mdList, LayoutModes.Update);
+            const metadataList = searchResultToMetadataValues(tid, dtdResult, row, mids, mdList, LayoutModes.Update);
             // Convert to DcmtMetadataMap format (like getFilteredMetadata does)
-            const item = { rowIndex: index };
             for (const mvd of metadataList) {
                 if (hideSysMetadata && mvd.mid !== undefined && mvd.mid < 100)
                     continue;
@@ -106,23 +110,18 @@ export const searchResultToDataSource = async (searchResult, hideSysMetadata, si
                     : (mvd.md?.name ?? '');
                 if (key) {
                     // Find the corresponding column by MID to format the value
-                    const column = dtdResult?.columns?.find(c => Number(c.extendedProperties?.["MID"] ?? "0") === mvd.mid);
                     item[key] = {
                         md: mvd.md,
-                        value: getDisplayValueByColumn(column, mvd.value)
+                        value: getDisplayValueByColumn(columnByMid.get(mvd.mid ?? 0), mvd.value)
                     };
                 }
             }
-            output.push(item);
         }
         else {
-            // Fallback: use original row data with basic parsing
-            const item = { rowIndex: index };
-            const fallbackTid = searchResult?.fromTID;
-            const dtd = await DcmtTypeListCacheService.GetWithNotGrantedAsync(fallbackTid, undefined, searchResult);
+            // Fallback: il DTD non è risolvibile, usa le colonne grezze del risultato
             for (let i = 0; i < row.length; i++) {
-                const column = searchResult?.dtdResult?.columns?.[i];
-                const mid = Number(column?.extendedProperties?.["MID"] ?? "0");
+                const column = columns[i];
+                const mid = mids[i];
                 if (hideSysMetadata && mid < 100)
                     continue;
                 let key = column?.caption ?? '';
@@ -134,20 +133,18 @@ export const searchResultToDataSource = async (searchResult, hideSysMetadata, si
                         key = `${key}_${mid}`;
                     }
                 }
-                const value = row[i];
-                const md = dtd?.metadata?.find(o => o.id == mid);
                 item[key] = {
-                    md: md,
-                    value: getDisplayValueByColumn(column, value)
+                    md: undefined,
+                    value: getDisplayValueByColumn(column, row[i])
                 };
             }
-            output.push(item);
         }
+        output.push(item);
     }
     return output;
 };
 export const DEFAULT_RELATION_EXPAND_LEVEL = 4; // Default maximum depth level for expansion (can be adjusted)
-const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndicator = true, allowShowZeroDcmts = true, initialShowZeroDcmts = false, allowedTIDs, allowMultipleSelection = false, focusedItem, selectedItems, onFocusedItemChanged, onSelectedItemsChanged, onAllItemsChanged, onDocumentDoubleClick, customItemRender, customDocumentStyle, customMainContainerContent, customDocumentContent, showMetadataNames = false, maxDepthLevel = 2, invertMasterNavigation = true, additionalStaticItems, showMainDocument = true, labelMainContainer, onNoRelationsFound, onItemContextMenu, focusedItemFormData = [], showExpandAllButton = false, defaultExpandAll = false, onLoadingStateChanged, onStopCalculationReady, onCalculationStopped }) => {
+const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndicator = true, allowShowZeroDcmts = true, initialShowZeroDcmts = false, allowedTIDs, allowMultipleSelection = false, focusedItem, selectedItems, onFocusedItemChanged, onSelectedItemsChanged, onAllItemsChanged, onDocumentDoubleClick, customItemRender, customDocumentStyle, customMainContainerContent, customDocumentContent, showMetadataNames = false, maxDepthLevel = 2, invertMasterNavigation = true, additionalStaticItems, showMainDocument = true, labelMainContainer, onNoRelationsFound, onItemContextMenu, focusedItemFormData = [], showExpandAllButton = false, defaultExpandAll = false, onLoadingStateChanged, onLoadingProgress, onStopCalculationReady, onCalculationStopped, initialTreeState, onTreeStateChange }) => {
     // State
     const [dcmtTypes, setDcmtTypes] = useState([]);
     const [treeData, setTreeData] = useState([]);
@@ -181,6 +178,14 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
     const userInteractedWithStaticItemsRef = React.useRef(false);
     // Ref to track the last inputKey for which we set the focused item
     const lastFocusedInputRef = React.useRef('');
+    // Catturato al mount (il padre lo aggiorna di continuo) e azzerato dopo l'uso,
+    // così vale solo per il primo caricamento
+    const stateToRestoreRef = React.useRef(initialTreeState);
+    // Parte dallo stato ricevuto: il padre azzera il fuoco prima di rimontare, quindi
+    // la prima notifica dopo il rimontaggio lo perderebbe
+    const lastReportedStateRef = React.useRef(initialTreeState);
+    // Percorso su cui rimettere il fuoco dopo un ripristino
+    const pendingFocusPathRef = React.useRef(undefined);
     // State for all users (used for checkout status display)
     const [allUsers, setAllUsers] = useState([]);
     // Load all users for checkout status resolution
@@ -196,6 +201,11 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         const isLoading = showWaitPanel || showExpansionWaitPanel;
         onLoadingStateChanged?.(isLoading);
     }, [showWaitPanel, showExpansionWaitPanel, onLoadingStateChanged]);
+    // Notifica al padre l'avanzamento del caricamento iniziale (documenti processati
+    // sul totale), così può mostrarlo nel proprio overlay che copre il wait panel interno
+    useEffect(() => {
+        onLoadingProgress?.(waitPanelValuePrimary, waitPanelMaxValuePrimary);
+    }, [waitPanelValuePrimary, waitPanelMaxValuePrimary, onLoadingProgress]);
     // Mantiene l'AbortController dell'espansione in corso accessibile da callback stabili
     const expansionAbortControllerRef = React.useRef(undefined);
     useEffect(() => {
@@ -478,6 +488,26 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
             return { ...node, hidden: shouldHide, items: updatedItems };
         });
     }, [showZeroDcmts]);
+    /** Messaggio informativo in testa se tutti i figli sono nascosti dal filtro; senza figli il nodo resta vuoto (nessuna freccina). */
+    const applyZeroFilterInfoMessage = useCallback((nodeKey, items) => {
+        const cleaned = items.filter(child => !(child.isInfoMessage && child.key?.startsWith('__info__')));
+        if (showZeroDcmts)
+            return cleaned;
+        const realChildren = cleaned.filter(child => !child.isInfoMessage);
+        if (realChildren.length === 0 || !realChildren.every(child => child.hidden))
+            return cleaned;
+        return [
+            {
+                key: `__info__${nodeKey}`,
+                name: SDKUI_Localizator.NoRelatedDocumentsToDisplay,
+                isContainer: false,
+                isDcmt: false,
+                isInfoMessage: true,
+                isExpandible: false
+            },
+            ...cleaned // Keep hidden containers so they can be shown when toggling
+        ];
+    }, [showZeroDcmts]);
     /**
      * Helper function to set up initial tree expansion state.
      * Called after all data is loaded but before setTreeData.
@@ -565,6 +595,18 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         });
         return result;
     };
+    /**
+     * Carica i figli di un documento durante il ripristino. Usa i loader e non
+     * calculateItemsForNode, che accenderebbe il wait panel di espansione mentre
+     * è già attivo quello del caricamento principale.
+     */
+    const loadChildrenForRestore = async (node) => {
+        if (!node.tid || !node.did)
+            return [];
+        if (isForMaster && invertMasterNavigation)
+            return await getMasterDcmtsAsync(node.tid, node.did, 1, abortController.signal);
+        return await getDetailDcmtsAsync(node.tid, node.did, 1, abortController.signal);
+    };
     /**
      * Main data loading function
      */
@@ -638,6 +680,11 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                         }
                     }
                 }
+                // Interruzione richiesta dall'utente: il documento corrente non è stato
+                // caricato per intero, quindi non viene aggiunto all'albero. Il parziale
+                // resta così a granularità di documento (es. 3 completi su 10).
+                if (abortController.signal.aborted)
+                    break;
                 // Aggiungi i master come root, raggruppando per TID e relationId
                 for (const masterContainer of masterDocs) {
                     const existingContainer = tree.find(c => c.tid === masterContainer.tid && c.relationId === masterContainer.relationId && c.isContainer);
@@ -666,6 +713,9 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                 const relatedDocs = isForMaster
                     ? await getMasterDcmtsAsync(dcmt.TID, dcmt.DID, maxDepthLevel, abortController.signal)
                     : await getDetailDcmtsAsync(dcmt.TID, dcmt.DID, maxDepthLevel, abortController.signal);
+                // Interruzione richiesta dall'utente
+                if (abortController.signal.aborted)
+                    break;
                 // Se showMainDocument è false, mostra i container dei dettagli direttamente sotto il container principale
                 if (!showMainDocument) {
                     // Check if a container for this TID already exists in the tree
@@ -817,7 +867,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         const wasStopped = abortController.signal.aborted;
         if (wasStopped) {
             setLoadStoppedByUser(true);
-            onCalculationStopped?.();
+            onCalculationStopped?.(processedCount, inputDcmts.length);
         }
         // If no relations found, notify parent
         if (!wasStopped && hasNoRelations && onNoRelationsFound) {
@@ -843,12 +893,20 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         }
         // FIRST setup initial expansion state (root container expanded, first document expanded with focus, first correlation folder expanded)
         // This must run BEFORE updateHiddenProperty so that infoMessage logic sees expanded=true
-        const expandedTree = setupInitialTreeExpansion(tree);
+        let expandedTree = setupInitialTreeExpansion(tree);
+        // Stato precedente da ripristinare (rimontaggio dopo un'operazione): si riapplica
+        // sopra l'espansione iniziale, che resta necessaria perché marca isRoot.
+        const stateToRestore = stateToRestoreRef.current;
+        stateToRestoreRef.current = undefined;
+        if (stateToRestore && stateToRestore.inputKey === getInputKey()) {
+            expandedTree = await applyRelationTreeState(expandedTree, stateToRestore, loadChildrenForRestore, () => abortController.signal.aborted);
+            pendingFocusPathRef.current = stateToRestore.focusedPath;
+        }
         // THEN apply hidden property transformations (creates new objects, adds infoMessage where needed)
         // Now it will correctly detect expanded nodes and add infoMessage if all children are hidden
         const processedTree = updateHiddenProperty(expandedTree);
         setTreeData(processedTree);
-    }, [inputDcmts, dcmtTypes, maxDepthLevel, isForMaster, invertMasterNavigation, getDetailDcmtsAsync, getMasterDcmtsAsync, abortController, updateHiddenProperty, showMainDocument, labelMainContainer, onNoRelationsFound, onCalculationStopped]);
+    }, [inputDcmts, dcmtTypes, maxDepthLevel, isForMaster, invertMasterNavigation, getDetailDcmtsAsync, getMasterDcmtsAsync, abortController, updateHiddenProperty, showMainDocument, labelMainContainer, onNoRelationsFound, onCalculationStopped, getInputKey]);
     /**
      * Merge main tree data with additional static items
      */
@@ -863,6 +921,18 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         // and may contain custom properties that would be lost by the spread operator
         return [...treeData, ...itemsToMerge];
     }, [treeData, additionalStaticItems, staticItemsState]);
+    /** Notifica al padre lo stato dell'albero, così che possa restituirlo dopo un refresh. */
+    useEffect(() => {
+        if (!onTreeStateChange)
+            return;
+        // Ad albero vuoto (caricamento in corso) si sovrascriverebbe lo stato da ripristinare
+        if (treeData.length === 0)
+            return;
+        // Il padre azzera il fuoco all'avvio di un refresh: si conserva l'ultimo noto
+        const state = collectRelationTreeState(treeData, getInputKey(), focusedItem?.key, lastReportedStateRef.current?.focusedPath);
+        lastReportedStateRef.current = state;
+        onTreeStateChange(state);
+    }, [treeData, focusedItem, getInputKey, onTreeStateChange]);
     /**
      * Notify parent with a flattened list of all items whenever the merged tree data changes.
      */
@@ -942,6 +1012,18 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         if (lastFocusedInputRef.current === currentInputKey) {
             return;
         }
+        // Ripristino dopo un refresh. Se il nodo non esiste più (es. documento cancellato
+        // fisicamente) si prosegue con il fuoco predefinito sul root.
+        const focusPathToRestore = pendingFocusPathRef.current;
+        pendingFocusPathRef.current = undefined;
+        if (focusPathToRestore) {
+            const nodeToFocus = findRelationNodeByPath(treeData, focusPathToRestore);
+            if (nodeToFocus) {
+                onFocusedItemChanged(nodeToFocus);
+                lastFocusedInputRef.current = currentInputKey;
+                return;
+            }
+        }
         // Helper function to recursively find the first document with isRoot=true
         const findFirstRootDocument = (items) => {
             for (const item of items) {
@@ -1019,29 +1101,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         if (node.isLoaded && node.items) {
             // Apply current show/hide logic based on showZeroDcmts
             const updatedItems = updateHiddenProperty(node.items);
-            // If this is a container, check if we need to show info message
-            if (node.isContainer) {
-                // Remove any existing info messages
-                const filteredItems = updatedItems.filter(child => !(child.isInfoMessage && child.key?.startsWith('__info__')));
-                // Check if all real children are hidden
-                const realChildren = filteredItems.filter(child => !child.isInfoMessage);
-                const allChildrenHidden = realChildren.length > 0 && realChildren.every(child => child.hidden);
-                // If showZeroDcmts is false and all items are hidden, show info message + keep hidden containers
-                if (!showZeroDcmts && allChildrenHidden) {
-                    return [
-                        {
-                            key: `__info__${node.key}`,
-                            name: SDKUI_Localizator.NoRelatedDocumentsToDisplay,
-                            isContainer: false,
-                            isDcmt: false,
-                            isInfoMessage: true,
-                            isExpandible: false
-                        },
-                        ...filteredItems // Keep hidden containers so they can be shown when toggling
-                    ];
-                }
-            }
-            return updatedItems;
+            return applyZeroFilterInfoMessage(node.key, updatedItems);
         }
         // ============================================
         // CONTAINER: Show items immediately (no API calls)
@@ -1055,21 +1115,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
             if (!node.items)
                 return [];
             const updatedItems = updateHiddenProperty(node.items);
-            // If showZeroDcmts is false and all items are hidden, add info message + keep hidden containers
-            if (!showZeroDcmts && updatedItems.length > 0 && updatedItems.every(item => item.hidden)) {
-                return [
-                    {
-                        key: `__info__${node.key}`,
-                        name: SDKUI_Localizator.NoRelatedDocumentsToDisplay,
-                        isContainer: false,
-                        isDcmt: false,
-                        isInfoMessage: true,
-                        isExpandible: false
-                    },
-                    ...updatedItems // Keep hidden containers so they can be shown when toggling
-                ];
-            }
-            return updatedItems;
+            return applyZeroFilterInfoMessage(node.key, updatedItems);
         }
         // ============================================
         // DOCUMENT: Load its children (relation containers) lazily
@@ -1110,21 +1156,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                 // - Relation type containers are always visible (even if empty)
                 // - Other containers with zero items can be hidden based on showZeroDcmts
                 const updatedItems = updateHiddenProperty(loadedItems);
-                // If showZeroDcmts is false and all items are hidden, add info message + keep hidden containers
-                if (!showZeroDcmts && updatedItems.length > 0 && updatedItems.every(item => item.hidden)) {
-                    return [
-                        {
-                            key: `__info__${node.key}`,
-                            name: SDKUI_Localizator.NoRelatedDocumentsToDisplay,
-                            isContainer: false,
-                            isDcmt: false,
-                            isInfoMessage: true,
-                            isExpandible: false
-                        },
-                        ...updatedItems // Keep hidden containers so they can be shown when toggling
-                    ];
-                }
-                return updatedItems;
+                return applyZeroFilterInfoMessage(node.key, updatedItems);
             }
             catch (error) {
                 console.error('Error loading document relations:', error);
@@ -1137,7 +1169,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         }
         // Default: return existing items
         return node.items;
-    }, [isForMaster, invertMasterNavigation, getDetailDcmtsAsync, getMasterDcmtsAsync, updateHiddenProperty, showZeroDcmts]);
+    }, [isForMaster, invertMasterNavigation, getDetailDcmtsAsync, getMasterDcmtsAsync, updateHiddenProperty, applyZeroFilterInfoMessage, showZeroDcmts]);
     /**
      * Default item renderer with metadata display (adapted from TMMasterDetailDcmts.tsx)
      */
@@ -1170,8 +1202,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                 gap: '10px',
                 height: '32px',
                 padding: '6px 0',
-                opacity: item.isZero ? 0.99 : 1,
-                transition: 'opacity 0.2s ease-in-out'
+                opacity: item.isZero ? 0.4 : 1,
             };
             // Se è il container principale (root) e showMainDocument è false,
             // non mostrare il badge perché conterrebbe il numero di sotto-container, non di documenti
@@ -1201,8 +1232,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
             alignItems: 'center',
             cursor: 'pointer',
             userSelect: 'none',
-            opacity: item.isZero ? 0.99 : 1,
-            transition: 'opacity 0.2s ease-in-out',
+            opacity: item.isZero ? 0.4 : 1,
             textDecoration: isLogicallyDeleted ? 'line-through' : 'none'
         };
         const documentStyle = customDocumentStyle ? { ...defaultDocumentStyle, ...customDocumentStyle(item) } : defaultDocumentStyle;
@@ -1377,14 +1407,17 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         const targetLevel = expandLevel;
         const newAbortController = new AbortController();
         setExpansionAbortController(newAbortController);
+        // Denominatore subito: con maxValue = 0 TMWaitPanel disegna una barra ferma a 0%
+        setExpansionWaitPanelMaxValue(100);
+        setExpansionWaitPanelValue(0);
         // CONTATORI DINAMICI:
         // - totalNodes: cresce quando scopriamo nuovi nodi (evita che percentuale > 100%)
         // - processedNodes: quanti nodi abbiamo già processato
-        // - maxReachedProgress: percentuale massima raggiunta (evita che la barra torni indietro)
+        // - shownProgress: percentuale mostrata, che non torna mai indietro
         let totalNodes = 0;
         let processedNodes = 0;
         let hasApiCalls = false;
-        let maxReachedProgress = 0;
+        let shownProgress = 0;
         /**
          * Conta i nodi espandibili in un array (solo primo livello, non ricorsivo).
          * Usato per aggiornare totalNodes man mano che scopriamo nuovi figli.
@@ -1400,6 +1433,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         };
         // Conta iniziale: solo i nodi al livello root
         totalNodes = countNodesAtLevel([...workingTreeData, ...workingStaticData]);
+        const initialTotalNodes = totalNodes;
         /**
          * FUNZIONE RICORSIVA DI ESPANSIONE
          *
@@ -1470,7 +1504,8 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                                 loadedItems = await getDetailDcmtsAsync(node.tid, node.did, 1, newAbortController.signal);
                             }
                             // Applica le regole di visibilità (showZeroDcmts)
-                            expandedNode.items = updateHiddenProperty(loadedItems);
+                            // Stesse regole dell'espansione manuale (messaggio informativo se tutto nascosto)
+                            expandedNode.items = applyZeroFilterInfoMessage(node.key, updateHiddenProperty(loadedItems));
                             expandedNode.isLoaded = true;
                             expandedNode.itemsCount = loadedItems.length;
                             // IMPORTANTE: Aggiungi i nuovi nodi scoperti al contatore totale
@@ -1497,14 +1532,15 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                     }
                     // Aggiorna il progresso DOPO aver processato questo nodo
                     processedNodes++;
-                    // Calcola percentuale e aggiorna solo se è più alta di prima
-                    // (evita che la barra di progresso torni indietro)
-                    const currentProgress = totalNodes > 0 ? Math.floor((processedNodes / totalNodes) * 100) : 0;
-                    if (currentProgress > maxReachedProgress) {
-                        maxReachedProgress = currentProgress;
-                        setExpansionWaitPanelValue(maxReachedProgress);
-                    }
-                    setExpansionWaitPanelText(SDKUI_Localizator.ExpansionProgress.replaceParams(processedNodes.toString(), totalNodes.toString()));
+                    // La barra non torna mai indietro: segue il valore reale quando sale, altrimenti avanza verso il 99%
+                    const realProgress = totalNodes > 0 ? (processedNodes / totalNodes) * 100 : 0;
+                    shownProgress = Math.min(99, realProgress > shownProgress
+                        ? realProgress
+                        : shownProgress + (99 - shownProgress) * 0.01);
+                    setExpansionWaitPanelValue(shownProgress);
+                    // Seconda riga: spiega perché percentuale e conteggio non vanno di pari passo
+                    setExpansionWaitPanelText(SDKUI_Localizator.ExpansionProgress.replaceParams(processedNodes.toString(), totalNodes.toString())
+                        + (totalNodes > initialTotalNodes ? `\n${SDKUI_Localizator.ExpansionProgressIsEstimated}` : ''));
                     // ═══════════════════════════════════════════════════════════════════
                     // PASSO 3: CHIAMATA RICORSIVA SUI FIGLI
                     // Questo è il punto chiave: i nuovi nodi appena caricati vengono
@@ -1535,7 +1571,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
             setShowExpansionWaitPanel(false);
             setExpansionAbortController(undefined);
         }
-    }, [expandLevel, treeData, staticItemsState, isForMaster, invertMasterNavigation, getDetailDcmtsAsync, getMasterDcmtsAsync, updateHiddenProperty]);
+    }, [expandLevel, treeData, staticItemsState, isForMaster, invertMasterNavigation, getDetailDcmtsAsync, getMasterDcmtsAsync, updateHiddenProperty, applyZeroFilterInfoMessage]);
     /**
      * Apply defaultExpandAll once on initial tree load.
      */

package/lib/components/features/documents/relationTreeState.d.ts

@@ -0,0 +1,32 @@
+import type { RelationTreeItem } from './TMRelationViewer';
+/**
+ * Conserva lo stato di un albero delle correlazioni (nodi espansi e fuoco) attraverso
+ * un refresh che ricarica i dati da zero. I nodi non sono confrontabili per `key`, che
+ * contiene un GUID rigenerato ad ogni caricamento: si usa un percorso costruito sui campi.
+ */
+export interface RelationTreeState {
+    /** Documenti di input a cui lo stato si riferisce: non va applicato ad altri */
+    inputKey: string;
+    expandedPaths: string[];
+    /**
+     * Documenti espansi che avevano già i figli caricati. Quelli espansi ma vuoti
+     * (es. il root) non vanno ricaricati: mostrerebbero più di quanto c'era prima.
+     */
+    loadedPaths: string[];
+    focusedPath?: string;
+}
+/** Carica i figli di un documento durante il ripristino. */
+export type LoadChildrenFn = (node: RelationTreeItem) => Promise<RelationTreeItem[]>;
+/**
+ * Fotografa lo stato dell'albero.
+ * `previousFocusedPath` viene usato quando il fuoco è già stato azzerato dall'esterno.
+ */
+export declare const collectRelationTreeState: (nodes: RelationTreeItem[], inputKey: string, focusedKey: string | undefined, previousFocusedPath?: string) => RelationTreeState;
+/**
+ * Riapplica lo stato all'albero appena caricato. I nodi che non compaiono nello stato,
+ * o che non esistono più (es. documento cancellato), restano chiusi: il confronto per
+ * percorso è tollerante per costruzione.
+ */
+export declare const applyRelationTreeState: (nodes: RelationTreeItem[], state: RelationTreeState, loadChildren: LoadChildrenFn, isAborted: () => boolean) => Promise<RelationTreeItem[]>;
+/** Cerca un nodo per percorso, per rimettere il fuoco dov'era. */
+export declare const findRelationNodeByPath: (nodes: RelationTreeItem[], path: string) => RelationTreeItem | null;

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

@@ -0,0 +1,89 @@
+/** I nodi generati (messaggi informativi, separatori) non hanno identità stabile. */
+const hasStableIdentity = (node) => !node.isInfoMessage && !node.isSeparator;
+const getNodeIdentity = (node) => node.isDcmt
+    ? `d:${node.tid ?? ''}:${node.did ?? ''}:${node.relationId ?? ''}`
+    : `c:${node.tid ?? ''}:${node.relationId ?? ''}:${node.name ?? ''}`;
+/** Il percorso include i padri: lo stesso documento può comparire sotto padri diversi. */
+const getNodePath = (node, parentPath) => {
+    const identity = getNodeIdentity(node);
+    return parentPath ? `${parentPath}>${identity}` : identity;
+};
+/**
+ * Fotografa lo stato dell'albero.
+ * `previousFocusedPath` viene usato quando il fuoco è già stato azzerato dall'esterno.
+ */
+export const collectRelationTreeState = (nodes, inputKey, focusedKey, previousFocusedPath) => {
+    const expandedPaths = [];
+    const loadedPaths = [];
+    let focusedPath;
+    const collect = (items, parentPath) => {
+        for (const node of items) {
+            if (!hasStableIdentity(node))
+                continue;
+            const path = getNodePath(node, parentPath);
+            if (node.expanded)
+                expandedPaths.push(path);
+            if (node.expanded && node.isDcmt && node.items)
+                loadedPaths.push(path);
+            // Entro la stessa istanza montata la key è univoca
+            if (focusedKey && node.key === focusedKey)
+                focusedPath = path;
+            if (node.items)
+                collect(node.items, path);
+        }
+    };
+    collect(nodes, '');
+    return { inputKey, expandedPaths, loadedPaths, focusedPath: focusedPath ?? previousFocusedPath };
+};
+/**
+ * Riapplica lo stato all'albero appena caricato. I nodi che non compaiono nello stato,
+ * o che non esistono più (es. documento cancellato), restano chiusi: il confronto per
+ * percorso è tollerante per costruzione.
+ */
+export const applyRelationTreeState = async (nodes, state, loadChildren, isAborted) => {
+    const expandedPaths = new Set(state.expandedPaths);
+    const loadedPaths = new Set(state.loadedPaths);
+    const apply = async (items, parentPath) => {
+        const result = [];
+        for (const node of items) {
+            if (!hasStableIdentity(node)) {
+                result.push(node);
+                continue;
+            }
+            const path = getNodePath(node, parentPath);
+            const wasExpanded = expandedPaths.has(path);
+            let children = node.items;
+            let isLoaded = node.isLoaded;
+            let itemsCount = node.itemsCount;
+            // I figli dei documenti sono lazy: vanno ricaricati se l'utente li aveva aperti
+            if (wasExpanded && node.isDcmt && !children && loadedPaths.has(path) && !isAborted()) {
+                children = await loadChildren(node);
+                isLoaded = true;
+                itemsCount = children.length;
+            }
+            const updatedItems = children ? await apply(children, path) : children;
+            result.push({ ...node, expanded: wasExpanded, items: updatedItems, isLoaded, itemsCount });
+        }
+        return result;
+    };
+    return await apply(nodes, '');
+};
+/** Cerca un nodo per percorso, per rimettere il fuoco dov'era. */
+export const findRelationNodeByPath = (nodes, path) => {
+    const find = (items, parentPath) => {
+        for (const node of items) {
+            if (!hasStableIdentity(node))
+                continue;
+            const currentPath = getNodePath(node, parentPath);
+            if (currentPath === path)
+                return node;
+            if (node.items) {
+                const found = find(node.items, currentPath);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    };
+    return find(nodes, '');
+};

package/lib/components/features/search/TMDcmtCheckoutInfoForm.d.ts

@@ -1,8 +1,9 @@
+import React from "react";
 import { DcmtInfo } from "../../../ts";
 interface TMDcmtCheckoutInfoFormProps {
     dtdName: string;
     selectedDcmtOrFocused: DcmtInfo;
     onClose: () => void;
 }
-declare const TMDcmtCheckoutInfoForm: (props: TMDcmtCheckoutInfoFormProps) => import("react/jsx-runtime").JSX.Element;
+declare const TMDcmtCheckoutInfoForm: (props: TMDcmtCheckoutInfoFormProps) => React.JSX.Element;
 export default TMDcmtCheckoutInfoForm;

package/lib/components/features/search/TMMetadataOutputForm.d.ts

@@ -1,3 +1,4 @@
+import React from "react";
 import { MetadataDescriptor, QueryDescriptor, SelectItem } from "@topconsultnpm/sdk-ts";
 interface TMMetadataOutputFormProps {
     /** QueryDescriptor da cui estrarre i metadati disponibili */
@@ -13,5 +14,5 @@ interface TMMetadataOutputFormProps {
     /** Callback chiamata quando l'utente conferma la selezione dei SelectItem */
     onChoose?: (selectItems: SelectItem[] | undefined) => void;
 }
-declare const TMMetadataOutputForm: (props: TMMetadataOutputFormProps) => import("react/jsx-runtime").JSX.Element;
+declare const TMMetadataOutputForm: (props: TMMetadataOutputFormProps) => React.JSX.Element;
 export default TMMetadataOutputForm;

package/lib/components/features/search/TMMetadataSorterForm.d.ts

@@ -1,3 +1,4 @@
+import React from "react";
 import { MetadataDescriptor, OrderByItem, QueryDescriptor } from "@topconsultnpm/sdk-ts";
 interface TMMetadataSorterFormProps {
     /** QueryDescriptor da cui estrarre i metadati disponibili */
@@ -13,5 +14,5 @@ interface TMMetadataSorterFormProps {
     /** Callback chiamata quando l'utente conferma la selezione degli OrderByItem */
     onChoose?: (orderByItems: OrderByItem[] | undefined) => void;
 }
-declare const TMMetadataSorterForm: (props: TMMetadataSorterFormProps) => import("react/jsx-runtime").JSX.Element;
+declare const TMMetadataSorterForm: (props: TMMetadataSorterFormProps) => React.JSX.Element;
 export default TMMetadataSorterForm;

package/lib/components/features/search/TMSavedQuerySelector.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { SavedQueryDescriptor } from '@topconsultnpm/sdk-ts';
-export declare const getTooltipBySqd: (sqd: SavedQueryDescriptor | undefined) => import("react/jsx-runtime").JSX.Element | null;
+export declare const getTooltipBySqd: (sqd: SavedQueryDescriptor | undefined) => React.JSX.Element | null;
 interface ITMSavedQuerySelectorProps {
     height?: string;
     items?: SavedQueryDescriptor[];
@@ -12,5 +12,5 @@ interface ITMSavedQuerySelectorProps {
     refreshFavoriteSavedQueries?: (sqd: SavedQueryDescriptor) => void;
     onRefreshData?: () => void;
 }
-declare const TMSavedQuerySelector: React.MemoExoticComponent<({ items, selectedId, allowShowSearch, height, manageDefault, onItemClick, onDeleted, refreshFavoriteSavedQueries, onRefreshData }: ITMSavedQuerySelectorProps) => import("react/jsx-runtime").JSX.Element>;
+declare const TMSavedQuerySelector: React.MemoExoticComponent<({ items, selectedId, allowShowSearch, height, manageDefault, onItemClick, onDeleted, refreshFavoriteSavedQueries, onRefreshData }: ITMSavedQuerySelectorProps) => React.JSX.Element>;
 export default TMSavedQuerySelector;

package/lib/components/features/search/TMSearch.d.ts

@@ -46,5 +46,5 @@ interface ITMSearchProps {
     fetchRemoteCertificates?: (email: string) => Promise<IntesiCertificateData[]>;
     graphometricManager?: IGraphometricManagerProp;
 }
-declare const TMSearch: React.FunctionComponent<ITMSearchProps>;
+declare const TMSearch: (props: ITMSearchProps) => React.JSX.Element;
 export default TMSearch;