@topconsultnpm/sdkui-react 6.22.0-dev3.14 → 6.22.0-dev3.15

package/lib/components/base/TMTreeView.js

@@ -459,6 +459,12 @@ const TMTreeView = ({ dataSource = [], focusedItem, selectedItems = [], allowMul
         return selectedCount > 0 && selectedCount < childKeys.length;
     }, [flattenTree]);
     const hasVisibleItems = useCallback((node) => {
+        // Nodo già caricato: conta i figli visibili (isExpandible è solo una stima a priori)
+        if (node.isLoaded) {
+            if (!node.items)
+                return false;
+            return node.items.filter(o => !o.hidden).length > 0;
+        }
         // If node has explicit isExpandible value, use that
         if (node.isExpandible !== undefined) {
             return node.isExpandible;

package/lib/components/base/TMWaitPanel.js

@@ -34,7 +34,7 @@ const StyledTitle = styled.h2 ` margin: 0; font-size: 1.5em; color: #333; `;
 const StyledProgressBarContainer = styled.div ` width: 100%; height: 20px; background: #e0e0e0; border-radius: 10px; overflow: hidden; margin: 20px 0; `;
 const StyledProgressBar = styled.div ` height: 100%; background: #4caf50; transition: width 0.3s ease; `;
 const StyledProgressText = styled.p ` font-weight: bold; color: #333; margin: 0; `;
-const StyledMessage = styled.p ` color: #666; font-size: 0.9em; margin-top: 10px; `;
+const StyledMessage = styled.p ` color: #666; font-size: 0.9em; margin-top: 10px; white-space: pre-line; `;
 const StyledAbortButton = styled.button ` background: #ff4d4d; color: white; border: none; border-radius: 5px; padding: 10px 20px; font-size: 1em; cursor: pointer; margin-top: 20px; &:hover { background: #ff6666; } `;
 export const TMWaitPanel = (props) => {
     const { title, showPrimary, textPrimary, valuePrimary, maxValuePrimary, showSecondary, textSecondary, valueSecondary, maxValueSecondary, isCancelable, abortController, onAbortClick, useHighZIndex } = props;

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

@@ -45,6 +45,13 @@ const TMMasterDetailDcmts = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallba
     const [refreshKey, setRefreshKey] = useState(0);
     // Separate refresh key for TMFormOrResultWrapper only (doesn't affect tmTreeView)
     const [refreshKeyFormOrResult, setRefreshKeyFormOrResult] = useState(0);
+    // Stato dell'albero conservato qui perché il bump di refreshKey rimonta TMRelationViewer:
+    // una ref interna al viewer non sopravvivrebbe. Riletto dal useMemo di tmTreeView,
+    // che si ricalcola proprio al refresh.
+    const treeStateRef = useRef(undefined);
+    const handleTreeStateChange = useCallback((state) => {
+        treeStateRef.current = state;
+    }, []);
     /** State for transformed focusedItem metadata values (similar to formData in TMDcmtForm) */
     const [focusedItemFormData, setFocusedItemFormData] = useState([]);
     // Trigger operationItems refresh (after file substitution, etc.)
@@ -386,11 +393,11 @@ const TMMasterDetailDcmts = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallba
                         setContextMenuVisible(true);
                     }, children: [_jsx(TMRelationViewerWrapper, { refreshKey: refreshKey, inputDcmts: inputDcmts, isForMaster: isForMaster, showCurrentDcmtIndicator: showCurrentDcmtIndicator, showZeroDcmts: showZeroDcmts, 
                             // customItemRender={customItemRender}
-                            allowMultipleSelection: allowMultipleSelection, focusedItem: focusedItem, selectedItems: selectedItems, onFocusedItemChanged: handleFocusedItemChanged, onSelectedItemsChanged: handleSelectedItemsChanged, onNoRelationsFound: handleNoRelationsFound, onItemContextMenu: isRelationViewerLoading ? undefined : onItemContextMenu, focusedItemFormData: focusedItemFormData, onLoadingStateChanged: setIsRelationViewerLoading, onLoadingProgress: handleRelationsProgress, onStopCalculationReady: handleStopCalculationReady, onCalculationStopped: handleRelationsCalculationStopped }), _jsx(TMContextMenu, { items: operationItems, externalControl: {
+                            allowMultipleSelection: allowMultipleSelection, focusedItem: focusedItem, selectedItems: selectedItems, onFocusedItemChanged: handleFocusedItemChanged, onSelectedItemsChanged: handleSelectedItemsChanged, onNoRelationsFound: handleNoRelationsFound, onItemContextMenu: isRelationViewerLoading ? undefined : onItemContextMenu, focusedItemFormData: focusedItemFormData, onLoadingStateChanged: setIsRelationViewerLoading, onLoadingProgress: handleRelationsProgress, onStopCalculationReady: handleStopCalculationReady, onCalculationStopped: handleRelationsCalculationStopped, initialTreeState: treeStateRef.current, onTreeStateChange: handleTreeStateChange }), _jsx(TMContextMenu, { items: operationItems, externalControl: {
                                 visible: contextMenuVisible,
                                 position: contextMenuPosition,
                                 onClose: () => setContextMenuVisible(false)
-                            } })] }) }), [inputDcmts, isForMaster, showCurrentDcmtIndicator, showZeroDcmts, allowMultipleSelection, focusedItem, selectedItems, handleFocusedItemChanged, handleSelectedItemsChanged, handleNoRelationsFound, onItemContextMenu, contextMenuVisible, contextMenuPosition, refreshKey, focusedItemFormData, isRelationViewerLoading, handleStopCalculationReady, handleRelationsCalculationStopped]);
+                            } })] }) }), [inputDcmts, isForMaster, showCurrentDcmtIndicator, showZeroDcmts, allowMultipleSelection, focusedItem, selectedItems, handleFocusedItemChanged, handleSelectedItemsChanged, handleNoRelationsFound, onItemContextMenu, contextMenuVisible, contextMenuPosition, refreshKey, focusedItemFormData, isRelationViewerLoading, handleStopCalculationReady, handleRelationsCalculationStopped, handleTreeStateChange]);
     const tmFormOrResult = useMemo(() => _jsx(TMFormOrResultWrapper, { refreshKey: refreshKeyFormOrResult, deviceType: deviceType, focusedItem: focusedItem, onTaskCreateRequest: onTaskCreateRequest, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers, handleNavigateToReference: handleNavigateToReference, onRefreshAfterAddDcmtToFavs: onRefreshAfterAddDcmtToFavs, editPdfForm: editPdfForm, openS4TViewer: openS4TViewer, onOpenS4TViewerRequest: onOpenS4TViewerRequest, onOpenPdfEditorRequest: onOpenPdfEditorRequest, onRefreshSearchResults: onRefreshAllPanels }), [focusedItem, deviceType, allTasks, handleNavigateToWGs, handleNavigateToDossiers, handleNavigateToReference, editPdfForm, openS4TViewer, onOpenS4TViewerRequest, onOpenPdfEditorRequest, onRefreshAfterAddDcmtToFavs, refreshKeyFormOrResult]);
     const initialPanelDimensions = {
         'tmTreeView': { width: '50%', height: '100%' },
@@ -484,7 +491,7 @@ export default TMMasterDetailDcmts;
  * - Panel visibility toggling
  * - Focus delay handling
  */
-const TMRelationViewerWrapper = ({ refreshKey, inputDcmts, isForMaster, showCurrentDcmtIndicator, showZeroDcmts, customItemRender, allowMultipleSelection, focusedItem, selectedItems, onFocusedItemChanged, onSelectedItemsChanged, onNoRelationsFound, onItemContextMenu, focusedItemFormData, onLoadingStateChanged, onLoadingProgress, onStopCalculationReady, onCalculationStopped }) => {
+const TMRelationViewerWrapper = ({ refreshKey, inputDcmts, isForMaster, showCurrentDcmtIndicator, showZeroDcmts, customItemRender, allowMultipleSelection, focusedItem, selectedItems, onFocusedItemChanged, onSelectedItemsChanged, onNoRelationsFound, onItemContextMenu, focusedItemFormData, onLoadingStateChanged, onLoadingProgress, onStopCalculationReady, onCalculationStopped, initialTreeState, onTreeStateChange }) => {
     const { setPanelVisibilityById, setToolbarButtonVisibility } = useTMPanelManagerContext();
     // Monitor device type changes to restore panel visibility when switching from mobile to desktop
     const deviceType = useDeviceType();
@@ -544,7 +551,7 @@ const TMRelationViewerWrapper = ({ refreshKey, inputDcmts, isForMaster, showCurr
             onItemContextMenu?.(item, e);
         }, 100);
     }, [onItemContextMenu, handleFocusedItemChanged]);
-    return (_jsx(TMRelationViewer, { inputDcmts: inputDcmts, isForMaster: isForMaster, showCurrentDcmtIndicator: showCurrentDcmtIndicator, initialShowZeroDcmts: showZeroDcmts, customItemRender: customItemRender, allowMultipleSelection: allowMultipleSelection, focusedItem: focusedItem, selectedItems: selectedItems, onFocusedItemChanged: handleFocusedItemChanged, onSelectedItemsChanged: onSelectedItemsChanged, maxDepthLevel: 1, invertMasterNavigation: false, showExpandAllButton: true, onNoRelationsFound: onNoRelationsFound, onItemContextMenu: onContextMenu, focusedItemFormData: focusedItemFormData, onLoadingStateChanged: onLoadingStateChanged, onLoadingProgress: onLoadingProgress, onStopCalculationReady: onStopCalculationReady, onCalculationStopped: onCalculationStopped }, refreshKey));
+    return (_jsx(TMRelationViewer, { inputDcmts: inputDcmts, isForMaster: isForMaster, showCurrentDcmtIndicator: showCurrentDcmtIndicator, initialShowZeroDcmts: showZeroDcmts, customItemRender: customItemRender, allowMultipleSelection: allowMultipleSelection, focusedItem: focusedItem, selectedItems: selectedItems, onFocusedItemChanged: handleFocusedItemChanged, onSelectedItemsChanged: onSelectedItemsChanged, maxDepthLevel: 1, invertMasterNavigation: false, showExpandAllButton: true, onNoRelationsFound: onNoRelationsFound, onItemContextMenu: onContextMenu, focusedItemFormData: focusedItemFormData, onLoadingStateChanged: onLoadingStateChanged, onLoadingProgress: onLoadingProgress, onStopCalculationReady: onStopCalculationReady, onCalculationStopped: onCalculationStopped, initialTreeState: initialTreeState, onTreeStateChange: onTreeStateChange }, refreshKey));
 };
 const TMFormOrResultWrapper = ({ refreshKey, deviceType, focusedItem, onTaskCreateRequest, allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTaskCallback, editTaskCallback, handleNavigateToWGs, handleNavigateToDossiers, onRefreshAfterAddDcmtToFavs, editPdfForm, openS4TViewer, onOpenS4TViewerRequest, onOpenPdfEditorRequest, onRefreshSearchAsyncDatagrid, onRefreshSearchResults, handleNavigateToReference, fetchRemoteCertificates }) => {
     const { setPanelVisibilityById } = useTMPanelManagerContext();

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

@@ -3,6 +3,7 @@ import { DcmtTypeDescriptor, SearchResultDescriptor, DataColumnDescriptor } from
 import { DcmtMetadataMap } from '../../../helper';
 import { DcmtInfo, MetadataValueDescriptorEx } from '../../../ts';
 import { ITMTreeItem } from '../../base/TMTreeView';
+import { RelationTreeState } from './relationTreeState';
 /**
  * Tree item structure for relations
  */
@@ -26,6 +27,7 @@ export interface RelationTreeItem extends ITMTreeItem {
     fileExt?: string;
     fileCount?: number;
 }
+export type { RelationTreeState } from './relationTreeState';
 /**
  * Props for TMRelationViewer component
  */
@@ -151,6 +153,14 @@ export interface TMRelationViewerProps {
      * Riceve quanti documenti di input sono stati completati sul totale.
      */
     onCalculationStopped?: (loadedCount: number, totalCount: number) => void;
+    /**
+     * Stato dell'albero da ripristinare al primo caricamento, al posto dell'espansione
+     * iniziale predefinita: permette al padre di rimontare il viewer dopo un'operazione
+     * senza che l'albero torni allo stato di partenza. Se assente vale il default.
+     */
+    initialTreeState?: RelationTreeState;
+    /** Notifica lo stato dell'albero, da restituire come `initialTreeState` dopo un refresh. */
+    onTreeStateChange?: (state: RelationTreeState) => void;
 }
 /**
  * Check if document type has detail relations

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
  */
@@ -143,7 +144,7 @@ export const searchResultToDataSource = async (searchResult, hideSysMetadata, si
     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, onLoadingProgress, 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([]);
@@ -177,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
@@ -479,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.
@@ -566,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
      */
@@ -852,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
      */
@@ -872,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.
      */
@@ -951,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) {
@@ -1028,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)
@@ -1064,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
@@ -1119,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);
@@ -1146,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)
      */
@@ -1179,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
@@ -1210,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;
@@ -1386,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.
@@ -1409,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
          *
@@ -1479,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
@@ -1506,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
@@ -1544,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/helper/SDKUI_Localizator.d.ts

@@ -318,6 +318,7 @@ export declare class SDKUI_Localizator {
     static get ExpansionInProgress(): "Erweiterung läuft..." | "Espansione in corso..." | "Expansion en cours..." | "Expansion in progress..." | "Expansión en curso..." | "Expansão em andamento...";
     static get FullReloadInProgress(): "Full reload in progress..." | "Recarga completa en curso..." | "Recarregamento completo em andamento..." | "Rechargement complet en cours..." | "Ricaricamento completo in corso..." | "Vollständiges Neuladen läuft...";
     static get ExpansionProgress(): "Erweiterung {{0}} von {{1}}..." | "Espansione {{0}} di {{1}}..." | "Expansion {{0}} of {{1}}..." | "Expansion {{0}} sur {{1}}..." | "Expansión {{0}} de {{1}}..." | "Expansão {{0}} de {{1}}...";
+    static get ExpansionProgressIsEstimated(): "D'autres nœuds sont trouvés pendant l'expansion : le total augmente et le pourcentage est indicatif." | "Durante a expansão são encontrados mais nós: o total aumenta e a percentagem é indicativa." | "Durante l'espansione vengono trovati altri nodi: il totale aumenta e la percentuale è indicativa." | "Durante la expansión se encuentran más nodos: el total aumenta y el porcentaje es orientativo." | "More nodes are found during the expansion: the total increases and the percentage is approximate." | "Während der Erweiterung werden weitere Knoten gefunden: Der Gesamtwert steigt und der Prozentsatz ist ein Richtwert.";
     static get Expected(): "Attendu" | "Atteso" | "Erwartet" | "Esperado" | "Expected";
     static get Expiration(): "Ablaufdatum" | "Data de expiração" | "Date d'expiration" | "Expiration" | "Fecha de expiración" | "Scadenza";
     static get ExpirationDate(): "Ablaufdatum" | "Data de validade" | "Data di scadenza" | "Date d'échéance" | "Expiration date" | "Fecha de vencimiento";

package/lib/helper/SDKUI_Localizator.js

@@ -3147,6 +3147,16 @@ export class SDKUI_Localizator {
             default: return "Espansione {{0}} di {{1}}...";
         }
     }
+    static get ExpansionProgressIsEstimated() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Während der Erweiterung werden weitere Knoten gefunden: Der Gesamtwert steigt und der Prozentsatz ist ein Richtwert.";
+            case CultureIDs.En_US: return "More nodes are found during the expansion: the total increases and the percentage is approximate.";
+            case CultureIDs.Es_ES: return "Durante la expansión se encuentran más nodos: el total aumenta y el porcentaje es orientativo.";
+            case CultureIDs.Fr_FR: return "D'autres nœuds sont trouvés pendant l'expansion : le total augmente et le pourcentage est indicatif.";
+            case CultureIDs.Pt_PT: return "Durante a expansão são encontrados mais nós: o total aumenta e a percentagem é indicativa.";
+            default: return "Durante l'espansione vengono trovati altri nodi: il totale aumenta e la percentuale è indicativa.";
+        }
+    }
     static get Expected() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Erwartet";

package/package.json

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