@topconsultnpm/sdkui-react 6.20.0-dev2.47 → 6.20.0-dev2.49

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

@@ -6,8 +6,9 @@ export interface ITMTreeItem {
     hidden?: boolean;
     isLoaded?: boolean;
     isContainer: boolean;
+    isExpandible?: boolean;
     items?: ITMTreeItem[];
-    visibleItemsCount?: number;
+    currentPage?: number;
     totalItemsCount?: number;
 }
 interface ITMTreeViewProps<T extends ITMTreeItem> {
@@ -31,3 +32,4 @@ export default TMTreeView;
 export declare const StyledTreeNode: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
     $isSelected?: boolean;
 }>> & string;
+export declare const StyledStickyPaginator: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/lib/components/base/TMTreeView.js

@@ -85,7 +85,9 @@ const TMTreeView = ({ dataSource = [], focusedItem, selectedItems = [], allowMul
                         let newItems = node.items;
                         // Solo se calculateItemsForNode è definito E (ctrl è premuto O non è già caricato)
                         if (calculateItemsForNode && (ctrlKey || !node.isLoaded)) {
-                            newItems = await calculateItemsForNode(node);
+                            // Se ctrl è premuto, passa un nodo con isLoaded resettato per forzare il refresh
+                            const nodeForCalculation = ctrlKey ? { ...node, isLoaded: false } : node;
+                            newItems = await calculateItemsForNode(nodeForCalculation);
                             const updatedNode = { ...node, expanded: true, items: newItems, isLoaded: true };
                             onNodeUpdate?.(updatedNode);
                             return updatedNode;
@@ -274,53 +276,62 @@ const TMTreeView = ({ dataSource = [], focusedItem, selectedItems = [], allowMul
         return childKeys.every(key => selectedChildKeys.includes(key));
     };
     const hasVisibleItems = (node) => {
+        // If node has explicit isExpandible value, use that
+        if (node.isExpandible !== undefined) {
+            return node.isExpandible;
+        }
+        // Fallback: check if node has visible items
         if (!node.items)
             return false;
         if (node.items.length <= 0)
             return false;
         return node.items.filter(o => !o.hidden).length > 0;
     };
-    // Gestisce il caricamento di più items per un nodo
-    const handleLoadMoreItems = useCallback((nodeKey) => {
-        const updateNodeVisibleCount = (nodes) => {
+    // Gestisce il cambio di pagina per un nodo
+    const handlePageChange = useCallback((nodeKey, newPage) => {
+        const updateNodePage = (nodes) => {
             return nodes.map(node => {
                 if (node.key === nodeKey) {
-                    const currentVisible = node.visibleItemsCount ?? itemsPerPage;
-                    const newVisible = Math.min(currentVisible + itemsPerPage, node.totalItemsCount ?? node.items?.length ?? 0);
-                    const updatedNode = { ...node, visibleItemsCount: newVisible };
+                    const updatedNode = { ...node, currentPage: newPage };
                     onNodeUpdate?.(updatedNode);
                     return updatedNode;
                 }
                 if (node.items) {
-                    return { ...node, items: updateNodeVisibleCount(node.items) };
+                    return { ...node, items: updateNodePage(node.items) };
                 }
                 return node;
             });
         };
-        const updatedData = updateNodeVisibleCount(dataSource);
+        const updatedData = updateNodePage(dataSource);
         onDataChanged?.(updatedData);
-    }, [dataSource, itemsPerPage, onDataChanged, onNodeUpdate]);
+    }, [dataSource, onDataChanged, onNodeUpdate]);
     // Filtra gli items da mostrare in base alla paginazione
     const getVisibleItems = useCallback((node) => {
         if (!node.items)
             return [];
         const totalItems = node.items.length;
-        const visibleCount = node.visibleItemsCount ?? itemsPerPage;
         // Se non c'è paginazione attiva o gli items sono pochi, mostra tutti
         if (totalItems <= itemsPerPage || !showLoadMoreButton) {
             return node.items;
         }
-        // Altrimenti mostra solo i primi N items
-        return node.items.slice(0, visibleCount);
+        // Altrimenti mostra solo gli items della pagina corrente
+        const currentPage = node.currentPage ?? 0;
+        const startIndex = currentPage * itemsPerPage;
+        const endIndex = startIndex + itemsPerPage;
+        return node.items.slice(startIndex, endIndex);
     }, [itemsPerPage, showLoadMoreButton]);
-    // Verifica se c'è bisogno del bottone "Load More"
-    const needsLoadMoreButton = useCallback((node) => {
+    // Verifica se c'è bisogno del paginatore
+    const needsPagination = useCallback((node) => {
         if (!showLoadMoreButton || !node.items)
             return false;
-        const totalItems = node.items.length;
-        const visibleCount = node.visibleItemsCount ?? itemsPerPage;
-        return totalItems > itemsPerPage && visibleCount < totalItems;
+        return node.items.length > itemsPerPage;
     }, [itemsPerPage, showLoadMoreButton]);
+    // Calcola il numero totale di pagine per un nodo
+    const getTotalPages = useCallback((node) => {
+        if (!node.items)
+            return 0;
+        return Math.ceil(node.items.length / itemsPerPage);
+    }, [itemsPerPage]);
     const renderTree = useCallback((nodes) => {
         return nodes.map(node => !node.hidden && (_jsxs("div", { style: { width: '100%', margin: 0, padding: 0 }, children: [_jsxs(StyledTreeNode, { "$isSelected": node.key === focusedItem?.key, children: [_jsx("div", { style: {
                                 display: 'flex',
@@ -339,8 +350,8 @@ const TMTreeView = ({ dataSource = [], focusedItem, selectedItems = [], allowMul
                                 if (input) {
                                     input.indeterminate = isIndeterminate(node);
                                 }
-                            } })), _jsx("div", { style: { display: 'flex', alignItems: 'center', flex: 1, minWidth: 0 }, onClick: (e) => { handleNodeClick(node, e); }, children: itemRender(node) })] }), node.expanded && node.items && (_jsxs("div", { style: { paddingLeft: 20, width: '100%' }, children: [renderTree(getVisibleItems(node)), needsLoadMoreButton(node) && (_jsx("div", { style: { display: 'flex', justifyContent: 'center', margin: '5px 0' }, children: _jsx(TMButton, { onClick: () => handleLoadMoreItems(node.key), showTooltip: false, caption: `Carica altri ${itemsPerPage}... (${node.visibleItemsCount ?? itemsPerPage} / ${node.items?.length ?? 0})` }) }))] }))] }, node.key)));
-    }, [handleNodeClick, handleNodeToggle, handleCheckboxChange, focusedItem, selectedItems, allowMultipleSelection, getVisibleItems, needsLoadMoreButton, handleLoadMoreItems, itemsPerPage]);
+                            } })), _jsx("div", { style: { display: 'flex', alignItems: 'center', flex: 1, minWidth: 0 }, onClick: (e) => { handleNodeClick(node, e); }, children: itemRender(node) })] }), node.expanded && node.items && (_jsxs("div", { style: { paddingLeft: 20, width: '100%' }, children: [renderTree(getVisibleItems(node)), needsPagination(node) && (_jsxs(StyledStickyPaginator, { children: [_jsx(TMButton, { onClick: () => handlePageChange(node.key, (node.currentPage ?? 0) - 1), showTooltip: false, caption: "\u25C4", disabled: (node.currentPage ?? 0) <= 0 }), _jsxs("span", { style: { fontSize: '12px', whiteSpace: 'nowrap', fontWeight: 500, overflow: 'hidden', textOverflow: 'ellipsis', minWidth: 0 }, children: ["Pagina ", (node.currentPage ?? 0) + 1, " di ", getTotalPages(node), " (", node.items?.length ?? 0, " elementi)"] }), _jsx(TMButton, { onClick: () => handlePageChange(node.key, (node.currentPage ?? 0) + 1), showTooltip: false, caption: "\u25BA", disabled: (node.currentPage ?? 0) >= getTotalPages(node) - 1 })] }))] }))] }, node.key)));
+    }, [handleNodeClick, handleNodeToggle, handleCheckboxChange, focusedItem, selectedItems, allowMultipleSelection, getVisibleItems, needsPagination, handlePageChange, getTotalPages]);
     return (_jsx("div", { style: { height: '100%', width: '100%', overflowY: 'auto', overflowX: 'hidden', padding: '0px 5px 2px 2px' }, children: renderTree(dataSource) }));
 };
 export default TMTreeView;
@@ -361,3 +372,35 @@ export const StyledTreeNode = styled.div `
         background: ${() => `oklch(from var(--dx-color-primary) l c h / .1)`};
     }
 `;
+export const StyledStickyPaginator = styled.div `
+	position: sticky;
+	bottom: 0;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	gap: 8px;
+	margin: 8px 0;
+	padding: 8px 12px;
+	background: oklch(from var(--dx-color-primary) l c h / .85);
+	border: 1px solid oklch(from var(--dx-color-primary) l c h / .9);
+	border-radius: 6px;
+	box-shadow: 0 -2px 8px oklch(from var(--dx-color-primary) l c h / .15);
+	transition: all 0.2s ease;
+	min-width: 0;
+	z-index: 10;
+
+	& > button {
+		flex-shrink: 0;
+	}
+
+	& > span {
+		flex: 1 1 auto;
+		min-width: 0;
+	}
+
+	&:hover {
+		background: oklch(from var(--dx-color-primary) l c h / .95);
+		border-color: oklch(from var(--dx-color-primary) l c h / 1);
+		box-shadow: 0 -2px 12px oklch(from var(--dx-color-primary) l c h / .2);
+	}
+`;

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

@@ -1,6 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { DcmtTypeListCacheService, SDK_Localizator } from '@topconsultnpm/sdk-ts';
+import styled from 'styled-components';
 import TMRelationViewer from './TMRelationViewer';
 import TMContextMenu from '../../NewComponents/ContextMenu/TMContextMenu';
 import { genUniqueId, IconMultipleSelection, IconCheckFile, IconDetailDcmts, SDKUI_Localizator, IconMail, IconDcmtTypeOnlyMetadata, IconCopy, IconMenuVertical, IconDataList, IconPreview, IconSearchCheck, IconBoard, IconDcmtTypeSys, IconShow, getMoreInfoTasksForDocument } from '../../../helper';
@@ -14,6 +15,44 @@ import { TMPanelManagerProvider, useTMPanelManagerContext } from '../../layout/p
 import TMSearchResult from '../search/TMSearchResult';
 import TMDcmtForm from './TMDcmtForm';
 import { TMNothingToShow } from './TMDcmtPreview';
+import TMButton from '../../base/TMButton';
+const StyledNoRelationsOverlay = styled.div `
+    width: 100%;
+    height: 100%;
+    position: fixed;
+    top: 0;
+    left: 0;
+    z-index: 1501;
+    overflow: visible; 
+    background-color: rgba(0, 0, 0, 0.5);
+    backdrop-filter: blur(8px);
+`;
+const StyledNoRelationsPanel = styled.div `
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    width: 400px; 
+    background: white; 
+    border-radius: 8px; 
+    padding: 20px; 
+    text-align: center; 
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+`;
+const StyledNoRelationsTitle = styled.h2 `
+    margin: 0 0 20px 0;
+    font-size: 1.3em;
+    color: #333;
+`;
+const StyledNoRelationsMessage = styled.p `
+    color: #666;
+    font-size: 1em;
+    margin: 0 0 25px 0;
+    line-height: 1.4;
+`;
 const TMMasterDetailDcmts = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTaskCallback, editTaskCallback, handleNavigateToWGs, handleNavigateToDossiers, deviceType, inputDcmts, isForMaster, showCurrentDcmtIndicator = true, allowNavigation, canNext, canPrev, onNext, onPrev, onBack, appendMasterDcmts, onTaskCreateRequest }) => {
     const [id, setID] = useState('');
     const [focusedItem, setFocusedItem] = useState();
@@ -21,6 +60,10 @@ const TMMasterDetailDcmts = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallba
     const [showZeroDcmts, setShowZeroDcmts] = useState(false);
     const [allowMultipleSelection, setAllowMultipleSelection] = useState(false);
     const [dtdMaster, setDtdMaster] = useState();
+    const [showNoRelationsModal, setShowNoRelationsModal] = useState(false);
+    const [shouldGoBackOnClose, setShouldGoBackOnClose] = useState(false);
+    // Ref to track if this is the first load (vs navigation with onPrev/onNext)
+    const isFirstLoadRef = useRef(true);
     useEffect(() => { setID(genUniqueId()); }, []);
     // Load dtdMaster when inputDcmts changes
     useEffect(() => {
@@ -40,10 +83,23 @@ const TMMasterDetailDcmts = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallba
     }, [inputDcmts?.length, inputDcmts?.[0]?.TID, isForMaster]);
     const handleFocusedItemChanged = useCallback((item) => {
         setFocusedItem(item);
+        // When data is loaded and an item is focused, mark as no longer first load
+        if (item) {
+            isFirstLoadRef.current = false;
+        }
     }, []);
     const handleSelectedItemsChanged = useCallback((items) => {
         setSelectedItems(items);
     }, []);
+    const handleNoRelationsFound = useCallback(() => {
+        // Show modal only on first load, not during navigation with onPrev/onNext
+        if (isFirstLoadRef.current) {
+            setShowNoRelationsModal(true);
+            setShouldGoBackOnClose(true);
+        }
+        // Mark as no longer first load
+        isFirstLoadRef.current = false;
+    }, []);
     const commandsMenuItems = [
         {
             icon: _jsx(IconMultipleSelection, { color: allowMultipleSelection ? TMColors.tertiary : TMColors.text_normal }),
@@ -153,7 +209,7 @@ const TMMasterDetailDcmts = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallba
             :
                 _jsx(TMRelationViewerWrapper, { inputDcmts: inputDcmts, isForMaster: isForMaster, showCurrentDcmtIndicator: showCurrentDcmtIndicator, showZeroDcmts: showZeroDcmts, 
                     // customItemRender={customItemRender}
-                    allowMultipleSelection: allowMultipleSelection, focusedItem: focusedItem, selectedItems: selectedItems, onFocusedItemChanged: handleFocusedItemChanged, onSelectedItemsChanged: handleSelectedItemsChanged }) }), [inputDcmts, isForMaster, showCurrentDcmtIndicator, showZeroDcmts, allowMultipleSelection, focusedItem, selectedItems, handleFocusedItemChanged, handleSelectedItemsChanged]);
+                    allowMultipleSelection: allowMultipleSelection, focusedItem: focusedItem, selectedItems: selectedItems, onFocusedItemChanged: handleFocusedItemChanged, onSelectedItemsChanged: handleSelectedItemsChanged, onNoRelationsFound: handleNoRelationsFound }) }), [inputDcmts, isForMaster, showCurrentDcmtIndicator, showZeroDcmts, allowMultipleSelection, focusedItem, selectedItems, handleFocusedItemChanged, handleSelectedItemsChanged, handleNoRelationsFound]);
     const tmFormOrResult = useMemo(() => _jsx(TMFormOrResultWrapper, { deviceType: deviceType, focusedItem: focusedItem, onTaskCreateRequest: onTaskCreateRequest, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers }), [focusedItem, deviceType, allTasks, handleNavigateToWGs, handleNavigateToDossiers]);
     const initialPanelDimensions = {
         'tmTreeView': { width: '50%', height: '100%' },
@@ -231,7 +287,12 @@ const TMMasterDetailDcmts = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallba
             toolbarOptions: { icon: _jsx(IconSearchCheck, { fontSize: 24 }), visible: false, orderNumber: 2, isActive: allInitialPanelVisibility['tmFormOrResult'] }
         }
     ], [tmTreeView, tmFormOrResult, focusedItem?.isDcmt, dtdMaster]);
-    return (_jsx(TMPanelManagerProvider, { panels: initialPanels, initialVisibility: allInitialPanelVisibility, defaultDimensions: initialPanelDimensions, initialDimensions: initialPanelDimensions, initialMobilePanelId: 'tmTreeView', children: _jsx(TMPanelManagerContainer, { panels: initialPanels, direction: "horizontal", showToolbar: true }) }));
+    return (_jsxs(_Fragment, { children: [_jsx(TMPanelManagerProvider, { panels: initialPanels, initialVisibility: allInitialPanelVisibility, defaultDimensions: initialPanelDimensions, initialDimensions: initialPanelDimensions, initialMobilePanelId: 'tmTreeView', children: _jsx(TMPanelManagerContainer, { panels: initialPanels, direction: "horizontal", showToolbar: true }) }), showNoRelationsModal && (_jsx(StyledNoRelationsOverlay, { children: _jsxs(StyledNoRelationsPanel, { children: [_jsx(StyledNoRelationsTitle, { children: SDKUI_Localizator.RelationsNotFound }), _jsx(StyledNoRelationsMessage, { children: SDKUI_Localizator.RelatedDcmtsNotFound }), _jsx(TMButton, { caption: "OK", showTooltip: false, onClick: () => {
+                                setShowNoRelationsModal(false);
+                                if (shouldGoBackOnClose) {
+                                    onBack?.();
+                                }
+                            }, btnStyle: "normal" })] }) }))] }));
 };
 export default TMMasterDetailDcmts;
 /**
@@ -240,7 +301,7 @@ export default TMMasterDetailDcmts;
  * - Panel visibility toggling
  * - Focus delay handling
  */
-const TMRelationViewerWrapper = ({ inputDcmts, isForMaster, showCurrentDcmtIndicator, showZeroDcmts, customItemRender, allowMultipleSelection, focusedItem, selectedItems, onFocusedItemChanged, onSelectedItemsChanged }) => {
+const TMRelationViewerWrapper = ({ inputDcmts, isForMaster, showCurrentDcmtIndicator, showZeroDcmts, customItemRender, allowMultipleSelection, focusedItem, selectedItems, onFocusedItemChanged, onSelectedItemsChanged, onNoRelationsFound }) => {
     const { setPanelVisibilityById, setToolbarButtonVisibility } = useTMPanelManagerContext();
     // Handle focused item changes with panel visibility management
     const handleFocusedItemChanged = useCallback((item) => {
@@ -259,7 +320,7 @@ const TMRelationViewerWrapper = ({ inputDcmts, isForMaster, showCurrentDcmtIndic
             setToolbarButtonVisibility('tmDcmtForm', false);
         }
     }, [onFocusedItemChanged, setPanelVisibilityById, setToolbarButtonVisibility]);
-    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 }));
+    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, onNoRelationsFound: onNoRelationsFound }));
 };
 const TMFormOrResultWrapper = ({ deviceType, focusedItem, onTaskCreateRequest, allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTaskCallback, editTaskCallback, handleNavigateToWGs, handleNavigateToDossiers }) => {
     const { setPanelVisibilityById } = useTMPanelManagerContext();

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

@@ -16,8 +16,9 @@ export interface RelationTreeItem extends ITMTreeItem {
     isRoot?: boolean;
     isMaster?: boolean;
     isCorrelated?: boolean;
-    isLoaded?: boolean;
     isSeparator?: boolean;
+    isInfoMessage?: boolean;
+    isLogDel?: number;
     values?: any;
     searchResult?: SearchResultDescriptor[];
     itemsCount?: number;
@@ -92,6 +93,11 @@ export interface TMRelationViewerProps {
      * If not provided, uses the document type name.
      */
     labelMainContainer?: string;
+    /**
+     * Callback invoked when no relations are found for any of the input documents.
+     * Useful to notify parent component that there are no correlated documents to display.
+     */
+    onNoRelationsFound?: () => void;
 }
 /**
  * Check if document type has detail relations

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

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import React, { useCallback, useEffect, useMemo, useState } from 'react';
 import { DcmtTypeListCacheService, SDK_Globals, DataColumnTypes, MetadataFormats, SystemMIDs, MetadataDataDomains, RelationCacheService, RelationTypes } from "@topconsultnpm/sdk-ts";
-import { genUniqueId, IconFolder, IconBackhandIndexPointingRight } from '../../../helper';
+import { genUniqueId, IconFolder, IconBackhandIndexPointingRight, IconCircleInfo } from '../../../helper';
 import { TMColors } from '../../../utils/theme';
 import { StyledDivHorizontal, StyledBadge } from '../../base/Styled';
 import TMTreeView from '../../base/TMTreeView';
@@ -136,7 +136,7 @@ export const searchResultToDataSource = async (searchResult, hideSysMetadata) =>
     }
     return output;
 };
-const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndicator = true, allowShowZeroDcmts = true, initialShowZeroDcmts = false, allowedTIDs, allowMultipleSelection = false, focusedItem, selectedItems, onFocusedItemChanged, onSelectedItemsChanged, onDocumentDoubleClick, customItemRender, customDocumentStyle, customMainContainerContent, customDocumentContent, showMetadataNames = false, maxDepthLevel = 2, invertMasterNavigation = true, additionalStaticItems, showMainDocument = true, labelMainContainer, }) => {
+const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndicator = true, allowShowZeroDcmts = true, initialShowZeroDcmts = false, allowedTIDs, allowMultipleSelection = false, focusedItem, selectedItems, onFocusedItemChanged, onSelectedItemsChanged, onDocumentDoubleClick, customItemRender, customDocumentStyle, customMainContainerContent, customDocumentContent, showMetadataNames = false, maxDepthLevel = 2, invertMasterNavigation = true, additionalStaticItems, showMainDocument = true, labelMainContainer, onNoRelationsFound, }) => {
     // State
     const [dcmtTypes, setDcmtTypes] = useState([]);
     const [treeData, setTreeData] = useState([]);
@@ -156,6 +156,8 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
     const lastLoadedInputRef = React.useRef('');
     // Ref to track if user has manually expanded/collapsed static items
     const userInteractedWithStaticItemsRef = React.useRef(false);
+    // Ref to track if we've already set the initial focused item
+    const initialFocusSetRef = React.useRef(false);
     /**
      * Generate a stable key from inputDcmts to detect real changes
      */
@@ -219,20 +221,27 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                 const source = await searchResultToDataSource(searchResult);
                 if (source && source.length > 0) {
                     const dcmtDetails = [];
+                    // Check once if this document type can have detail relations
+                    // (optimization: avoid checking for each document)
+                    const canHaveDetails = await hasDetailRelations(searchResult.fromTID);
                     for (const row of source) {
                         const rowGUID = genUniqueId();
                         const tid = row?.TID?.value;
                         const did = row?.DID?.value;
+                        const isLogDel = row?.ISLOGDEL?.value;
                         dcmtDetails.push({
                             tid: tid,
                             did: did,
+                            isLogDel: isLogDel,
                             key: `${tid}_${did}_${searchResult.relationID}_${mTID}_${mDID}_${rowGUID}`,
                             isDcmt: true,
                             isContainer: false,
                             isZero: false, // Documents are never zero (they exist)
+                            isExpandible: canHaveDetails, // Can this doc be expanded?
                             values: row,
                             searchResult: [searchResult],
-                            itemsCount: 0,
+                            // Leave items and itemsCount undefined so TMTreeView shows expand arrow based on isExpandible
+                            // Children will be loaded lazily by calculateItemsForNode when expanded
                             expanded: false,
                             hidden: false,
                             name: row?.SYS_Abstract?.value || row?.SYS_SUBJECT?.value || `Documento ${did}`
@@ -293,20 +302,30 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                 const source = await searchResultToDataSource(searchResult);
                 if (source && source.length > 0) {
                     const dcmtMasters = [];
+                    // Check once if this document type can have master relations (for inverted mode)
+                    // or detail relations (for standard mode when expanding masters)
+                    // (optimization: avoid checking for each document)
+                    const canExpand = isForMaster && invertMasterNavigation
+                        ? await hasMasterRelations(searchResult.fromTID)
+                        : await hasDetailRelations(searchResult.fromTID);
                     for (const row of source) {
                         const rowGUID = genUniqueId();
                         const tid = row?.TID?.value;
                         const did = row?.DID?.value;
+                        const isLogDel = row?.ISLOGDEL?.value;
                         dcmtMasters.push({
                             tid: tid,
                             did: did,
+                            isLogDel: isLogDel,
                             key: `${tid}_${did}_${searchResult.relationID}_${dTID}_${dDID}_${rowGUID}`,
                             isDcmt: true,
                             isContainer: false,
                             isZero: false, // Documents are never zero (they exist)
+                            isExpandible: canExpand, // Can this doc be expanded?
                             values: row,
                             searchResult: [searchResult],
-                            itemsCount: 0,
+                            // Leave items and itemsCount undefined so TMTreeView shows expand arrow based on isExpandible
+                            // Children will be loaded lazily by calculateItemsForNode when expanded
                             expanded: false,
                             hidden: false,
                             name: row?.SYS_Abstract?.value || row?.SYS_SUBJECT?.value || `Documento ${did}`
@@ -324,17 +343,128 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         return items;
     }, [allowedTIDs]);
     /**
-     * Update hidden property based on showZeroDcmts (original simple logic)
+     * Update hidden property based on showZeroDcmts
+     * Updates items in-place without resetting isLoaded (no API calls needed)
      */
     const updateHiddenProperty = useCallback((nodes) => {
+        // Safety check: if nodes is undefined or not an array, return empty array
+        if (!nodes || !Array.isArray(nodes)) {
+            return [];
+        }
         return nodes.map(node => {
-            const updatedNode = { ...node, hidden: !showZeroDcmts && node.isZero };
-            if (node.items) {
-                updatedNode.items = updateHiddenProperty(node.items);
+            let shouldHide = false;
+            let updatedItems = undefined;
+            if (node.items && Array.isArray(node.items)) {
+                // Recursively update children first - this creates a new array
+                let updatedChildren = updateHiddenProperty(node.items);
+                // Remove any existing auto-generated info messages (with key starting with __info__)
+                const filteredChildren = updatedChildren.filter(child => !(child.isInfoMessage && child.key?.startsWith('__info__')));
+                // Check if all real children (excluding info messages) are hidden
+                const realChildren = filteredChildren.filter(child => !child.isInfoMessage);
+                const allChildrenHidden = realChildren.length > 0 && realChildren.every(child => child.hidden);
+                // If node is expanded AND showZeroDcmts is false AND all children are hidden, add info message
+                // This applies to both containers and document nodes with children
+                if (node.expanded && !showZeroDcmts && allChildrenHidden) {
+                    // Add info message at the beginning, keep original children (hidden but preserved)
+                    updatedItems = [
+                        {
+                            key: `__info__${node.key}`,
+                            name: 'Nessun documento correlato da visualizzare',
+                            isContainer: false,
+                            isDcmt: false,
+                            isInfoMessage: true,
+                            isExpandible: false
+                        },
+                        ...filteredChildren
+                    ];
+                    // Don't hide the node itself if it's showing an info message
+                    shouldHide = false;
+                }
+                else {
+                    updatedItems = filteredChildren;
+                    // Hide zero-item containers when showZeroDcmts is false (only if not showing info message)
+                    shouldHide = !showZeroDcmts && (node.isZero ?? false);
+                }
+            }
+            else {
+                // No items, apply normal hide logic
+                shouldHide = !showZeroDcmts && (node.isZero ?? false);
             }
-            return updatedNode;
+            // IMPORTANT: Always create new object to trigger React re-render
+            return { ...node, hidden: shouldHide, items: updatedItems };
         });
     }, [showZeroDcmts]);
+    /**
+     * Helper function to set up initial tree expansion state.
+     * Called after all data is loaded but before setTreeData.
+     * Ensures: root container expanded, first document expanded with isRoot=true (for focus), first correlation folder expanded
+     * Returns a NEW tree with the modifications (immutable approach)
+     */
+    const setupInitialTreeExpansion = (tree) => {
+        if (tree.length === 0)
+            return tree;
+        // ALWAYS expand the first container (even if empty, to show infoMessage)
+        const firstRootContainer = tree[0];
+        if (!firstRootContainer)
+            return tree;
+        // Create a deep copy of the first container with expanded=true, isRoot=true
+        let newFirstContainer = {
+            ...firstRootContainer,
+            expanded: true,
+            isRoot: true
+        };
+        // 2. Find first document/container and expand it
+        const firstRootItems = newFirstContainer.items;
+        if (firstRootItems && firstRootItems.length > 0) {
+            const firstDocOrContainer = firstRootItems[0];
+            if (firstDocOrContainer.isDcmt) {
+                // First item is a document - expand it and mark as root for focus
+                let newFirstDoc = {
+                    ...firstDocOrContainer,
+                    expanded: true,
+                    isRoot: true
+                };
+                // 3. Expand first correlation folder (child of the document)
+                const docItems = newFirstDoc.items;
+                if (docItems && docItems.length > 0 && docItems[0].isContainer) {
+                    const newFirstCorrelation = { ...docItems[0], expanded: true };
+                    newFirstDoc = {
+                        ...newFirstDoc,
+                        items: [newFirstCorrelation, ...docItems.slice(1)]
+                    };
+                }
+                // Update the container's items
+                newFirstContainer = {
+                    ...newFirstContainer,
+                    items: [newFirstDoc, ...firstRootItems.slice(1)]
+                };
+            }
+            else if (firstDocOrContainer.isContainer) {
+                // First item is a container (correlation folder) - expand it
+                let newFirstCorrelation = {
+                    ...firstDocOrContainer,
+                    expanded: true
+                };
+                // Find first document inside this container and mark for focus
+                const containerItems = newFirstCorrelation.items;
+                if (containerItems && containerItems.length > 0 && containerItems[0].isDcmt) {
+                    const newFirstDoc = { ...containerItems[0], isRoot: true };
+                    newFirstCorrelation = {
+                        ...newFirstCorrelation,
+                        items: [newFirstDoc, ...containerItems.slice(1)]
+                    };
+                }
+                // Update the container's items
+                newFirstContainer = {
+                    ...newFirstContainer,
+                    items: [newFirstCorrelation, ...firstRootItems.slice(1)]
+                };
+            }
+        }
+        // If firstRootItems is empty/undefined, the container is still expanded (will show infoMessage)
+        // Return new tree with the modified first container
+        return [newFirstContainer, ...tree.slice(1)];
+    };
     /**
      * Main data loading function
      */
@@ -405,13 +535,12 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                         tid: dcmt.TID,
                         dtd,
                         isContainer: true,
-                        isRoot: true,
                         isLoaded: true,
                         isZero: false,
                         searchResult: result ? [result] : [],
                         items: relatedDocs, // Directly show detail containers
                         itemsCount: relatedDocs.length,
-                        expanded: tree.length === 0,
+                        expanded: false,
                         hidden: false
                     };
                     tree.push(typeContainer);
@@ -426,10 +555,9 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                         did: dcmt.DID,
                         isDcmt: true,
                         isContainer: false,
-                        expanded: tree.length === 0,
+                        expanded: false,
                         isZero: dcmt.DID === 0,
                         isMaster: !isForMaster,
-                        isRoot: true,
                         isLoaded: true,
                         hidden: false,
                         values: docRow,
@@ -444,13 +572,12 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                         tid: dcmt.TID,
                         dtd,
                         isContainer: true,
-                        isRoot: true,
                         isLoaded: true,
                         isZero: false, // Type container is never zero (contains documents)
                         searchResult: result ? [result] : [],
                         items: [docNode],
                         itemsCount: 1,
-                        expanded: tree.length === 0,
+                        expanded: false,
                         hidden: false
                     };
                     tree.push(typeContainer);
@@ -460,8 +587,55 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
             processedCount++;
             setWaitPanelValuePrimary(processedCount);
         }
-        setTreeData(updateHiddenProperty(tree));
-    }, [inputDcmts, dcmtTypes, maxDepthLevel, isForMaster, invertMasterNavigation, getDetailDcmtsAsync, getMasterDcmtsAsync, abortController, updateHiddenProperty, showMainDocument, labelMainContainer]);
+        /**
+         * Helper function to check if a node has any actual correlated documents
+         * Returns true if there are NO documents (relations are empty)
+         */
+        const hasNoActualDocuments = (items) => {
+            if (!items || items.length === 0)
+                return true;
+            // Check each item
+            return items.every(item => {
+                // If it's a container, check if it's zero or has no documents
+                if (item.isContainer) {
+                    // Container with isZero=true has no documents
+                    if (item.isZero)
+                        return true;
+                    // Container with no items has no documents
+                    if (!item.items || item.items.length === 0)
+                        return true;
+                    // Otherwise, it has documents
+                    return false;
+                }
+                // If it's a document node, check its children (relation containers)
+                if (item.isDcmt) {
+                    // Check if all child containers are empty
+                    return hasNoActualDocuments(item.items);
+                }
+                // For other types, assume no documents
+                return true;
+            });
+        };
+        // Check if there are no relations for any document
+        const hasNoRelations = tree.length === 0 || tree.every(container => {
+            // Check if container has no items
+            if (!container.items || container.items.length === 0)
+                return true;
+            // Check recursively if there are any actual documents
+            return hasNoActualDocuments(container.items);
+        });
+        // If no relations found, notify parent
+        if (hasNoRelations && onNoRelationsFound) {
+            onNoRelationsFound();
+        }
+        // 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);
+        // 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]);
     /**
      * Merge main tree data with additional static items
      */
@@ -509,10 +683,56 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
     }, [inputDcmts, dcmtTypes, maxDepthLevel, getInputKey, loadData, treeData.length]);
     /**
      * Update tree when showZeroDcmts changes
+     * Updates the visualization without re-fetching data (isLoaded stays true)
      */
     useEffect(() => {
         setTreeData(prevData => updateHiddenProperty(prevData));
     }, [showZeroDcmts, updateHiddenProperty]);
+    /**
+     * Set initial focused item when showMainDocument = true
+     * Focuses on the main document (first inputDcmts) when data is loaded
+     * For master mode with invertMasterNavigation=false, focuses on the first master document
+     */
+    useEffect(() => {
+        // Only execute if:
+        // 1. showMainDocument is true
+        // 2. onFocusedItemChanged callback exists
+        // 3. We have tree data
+        // 4. We have input documents
+        // 5. We haven't already set the initial focus
+        if (!showMainDocument || !onFocusedItemChanged || !treeData.length || !inputDcmts?.length || initialFocusSetRef.current) {
+            return;
+        }
+        // Helper function to recursively find the first document with isRoot=true
+        const findFirstRootDocument = (items) => {
+            for (const item of items) {
+                // Check if this item is a document with isRoot=true
+                if (item.isDcmt && item.isRoot) {
+                    return item;
+                }
+                // Recursively search in children
+                if (item.items && Array.isArray(item.items)) {
+                    const found = findFirstRootDocument(item.items);
+                    if (found)
+                        return found;
+                }
+            }
+            return null;
+        };
+        // Find the first document marked as root (set by setupInitialTreeExpansion)
+        const docNode = findFirstRootDocument(treeData);
+        if (docNode) {
+            // Set the focused item
+            onFocusedItemChanged(docNode);
+            initialFocusSetRef.current = true;
+        }
+    }, [treeData, showMainDocument, onFocusedItemChanged, inputDcmts]);
+    /**
+     * Reset initial focus flag when input documents change
+     */
+    useEffect(() => {
+        initialFocusSetRef.current = false;
+    }, [getInputKey()]);
     /**
      * Sync static items state when additionalStaticItems change
      * IMPORTANT: Only update if user hasn't manually interacted with the tree,
@@ -548,6 +768,10 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
     /**
      * Calculate items for node when expanded (lazy loading)
      * Note: additionalStaticItems are already fully loaded, so skip calculation for them
+     *
+     * PERFORMANCE OPTIMIZATION:
+     * - Containers: Return items immediately (no API calls) - items are already loaded
+     * - Documents: Load children lazily only when the specific document is expanded (1 API call)
      */
     const calculateItemsForNode = useCallback(async (node) => {
         // Skip calculation for separator (it has no children)
@@ -558,62 +782,129 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         if (node.isStaticItem || node.isAdditionalContainer || node.isAdditional) {
             return node.items;
         }
-        // If it's a document, return existing items
-        if (node.isDcmt)
-            return node.items;
-        // If container is already loaded, return items
-        if (node.isLoaded)
-            return node.items;
-        const newAbortController = new AbortController();
-        setExpansionAbortController(newAbortController);
-        const itemsToLoad = node.items?.length ?? 0;
-        setShowExpansionWaitPanel(true);
-        setExpansionWaitPanelMaxValue(itemsToLoad);
-        setExpansionWaitPanelValue(0);
-        setExpansionWaitPanelText(`Caricamento documenti correlati...`);
-        try {
-            const newItems = [];
-            let processedCount = 0;
-            for (const dcmt of node.items ?? []) {
-                if (newAbortController.signal.aborted) {
-                    console.log('Folder expansion aborted by user');
-                    return node.items;
-                }
-                const item = { ...dcmt };
-                if (item.tid && item.did && !item.isLoaded) {
-                    // Update progress
-                    processedCount++;
-                    setExpansionWaitPanelValue(processedCount);
-                    setExpansionWaitPanelText(`Caricamento ${processedCount} di ${itemsToLoad}...`);
-                    // Nella modalità originale (invertMasterNavigation=false), 
-                    // i documenti detail non devono caricare i master come figli
-                    if (isForMaster && !invertMasterNavigation) {
-                        // Carica i detail dei detail (navigazione naturale detail→detail)
-                        const loadedItems = await getDetailDcmtsAsync(item.tid, item.did, 1);
-                        item.items = updateHiddenProperty(loadedItems);
-                    }
-                    else {
-                        // Modalità standard o invertita
-                        const loadedItems = isForMaster
-                            ? await getMasterDcmtsAsync(item.tid, item.did, 1)
-                            : await getDetailDcmtsAsync(item.tid, item.did, 1);
-                        item.items = updateHiddenProperty(loadedItems);
-                    }
-                    item.isLoaded = true;
+        // If already loaded, apply current visualization logic without re-fetching
+        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: 'Nessun documento correlato da visualizzare',
+                            isContainer: false,
+                            isDcmt: false,
+                            isInfoMessage: true,
+                            isExpandible: false
+                        },
+                        ...filteredItems // Keep hidden containers so they can be shown when toggling
+                    ];
                 }
-                newItems.push(item);
             }
-            return newItems;
+            return updatedItems;
         }
-        catch (error) {
-            console.error('Error loading folder contents:', error);
-            return node.items;
+        // ============================================
+        // CONTAINER: Show items immediately (no API calls)
+        // Items are already loaded from initial load or parent expansion
+        // ============================================
+        if (node.isContainer) {
+            // No API calls needed - just return existing items
+            // Children of these items will be loaded lazily when user expands each document
+            // Apply updateHiddenProperty to respect current showZeroDcmts setting
+            // If node has no items, return empty array
+            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: 'Nessun documento correlato da visualizzare',
+                        isContainer: false,
+                        isDcmt: false,
+                        isInfoMessage: true,
+                        isExpandible: false
+                    },
+                    ...updatedItems // Keep hidden containers so they can be shown when toggling
+                ];
+            }
+            return updatedItems;
         }
-        finally {
-            setShowExpansionWaitPanel(false);
-            setExpansionAbortController(undefined);
+        // ============================================
+        // DOCUMENT: Load its children (relation containers) lazily
+        // Only makes ONE API call for this specific document
+        // ============================================
+        if (node.isDcmt && node.tid && node.did) {
+            const newAbortController = new AbortController();
+            setExpansionAbortController(newAbortController);
+            setShowExpansionWaitPanel(true);
+            setExpansionWaitPanelMaxValue(1);
+            setExpansionWaitPanelValue(0);
+            setExpansionWaitPanelText(`Caricamento documenti correlati...`);
+            try {
+                // Check for abort
+                if (newAbortController.signal.aborted) {
+                    return [];
+                }
+                // Determine which load function to use based on mode
+                let loadedItems = [];
+                if (isForMaster && !invertMasterNavigation) {
+                    // Original mode: detail documents load detail documents (natural detail→detail navigation)
+                    loadedItems = await getDetailDcmtsAsync(node.tid, node.did, 1);
+                }
+                else if (isForMaster) {
+                    // Inverted master mode: load master documents
+                    loadedItems = await getMasterDcmtsAsync(node.tid, node.did, 1);
+                }
+                else {
+                    // Standard mode: load detail documents
+                    loadedItems = await getDetailDcmtsAsync(node.tid, node.did, 1);
+                }
+                // Espandi automaticamente il primo container se ci sono documenti correlati
+                if (loadedItems.length > 0 && loadedItems[0].isContainer) {
+                    loadedItems[0].expanded = true;
+                }
+                // Apply updateHiddenProperty to respect current showZeroDcmts setting
+                // This ensures that dynamically loaded nodes respect the visibility rules:
+                // - 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: 'Nessun documento correlato da visualizzare',
+                            isContainer: false,
+                            isDcmt: false,
+                            isInfoMessage: true,
+                            isExpandible: false
+                        },
+                        ...updatedItems // Keep hidden containers so they can be shown when toggling
+                    ];
+                }
+                return updatedItems;
+            }
+            catch (error) {
+                console.error('Error loading document relations:', error);
+                return [];
+            }
+            finally {
+                setShowExpansionWaitPanel(false);
+                setExpansionAbortController(undefined);
+            }
         }
-    }, [isForMaster, invertMasterNavigation, getDetailDcmtsAsync, getMasterDcmtsAsync, updateHiddenProperty]);
+        // Default: return existing items
+        return node.items;
+    }, [isForMaster, invertMasterNavigation, getDetailDcmtsAsync, getMasterDcmtsAsync, updateHiddenProperty, showZeroDcmts]);
     /**
      * Default item renderer with metadata display (adapted from TMMasterDetailDcmts.tsx)
      */
@@ -626,6 +917,18 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
             e.stopPropagation();
             onDocumentDoubleClick?.(item.tid, item.did, item.name);
         };
+        // Info message rendering
+        if (item.isInfoMessage) {
+            return (_jsxs("div", { style: {
+                    display: 'flex',
+                    alignItems: 'center',
+                    gap: '10px',
+                    height: '32px',
+                    padding: '6px 0',
+                    color: '#666',
+                    fontStyle: 'italic'
+                }, children: [_jsx(IconCircleInfo, { fontSize: 20, color: TMColors.iconLight }), _jsx("span", { children: item.name })] }));
+        }
         // Container rendering
         if (item.isContainer || !item.isDcmt) {
             const defaultContainerStyle = {
@@ -634,7 +937,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                 gap: '10px',
                 height: '32px',
                 padding: '6px 0',
-                opacity: item.isZero ? 0.4 : 1,
+                opacity: item.isZero ? 0.99 : 1,
                 transition: 'opacity 0.2s ease-in-out'
             };
             // Se è il container principale (root) e showMainDocument è false,
@@ -653,6 +956,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
             return (_jsx("div", { style: defaultContainerStyle, children: content }));
         }
         // Document rendering with full metadata display
+        const isLogicallyDeleted = Number(item.isLogDel) === 1;
         const defaultDocumentStyle = {
             minWidth: '90px',
             width: '100%',
@@ -664,18 +968,23 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
             alignItems: 'center',
             cursor: 'pointer',
             userSelect: 'none',
-            opacity: item.isZero ? 0.4 : 1,
-            transition: 'opacity 0.2s ease-in-out'
+            opacity: item.isZero ? 0.99 : 1,
+            transition: 'opacity 0.2s ease-in-out',
+            textDecoration: isLogicallyDeleted ? 'line-through' : 'none'
         };
         const documentStyle = customDocumentStyle
             ? { ...defaultDocumentStyle, ...customDocumentStyle(item) }
             : defaultDocumentStyle;
+        const textDecoration = isLogicallyDeleted ? 'line-through' : 'none';
+        const textColor = isLogicallyDeleted ? 'gray' : undefined;
         const defaultMetadataContent = item.values && (_jsx(StyledDivHorizontal, { style: {
                 fontSize: '1rem',
                 overflow: 'hidden',
                 flex: 1,
                 minWidth: 0,
-                whiteSpace: 'nowrap'
+                whiteSpace: 'nowrap',
+                textDecoration: textDecoration,
+                color: textColor
             }, children: getDcmtDisplayValue(item.values).map((key, index) => {
                 const md = item.values?.[key]?.md;
                 const value = item.values?.[key]?.value;
@@ -684,12 +993,16 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                 return (_jsxs(StyledDivHorizontal, { style: {
                         flexShrink: isLast ? 1 : 0,
                         minWidth: isLast ? 0 : 'auto',
-                        overflow: isLast ? 'hidden' : 'visible'
-                    }, children: [index > 0 && _jsx("span", { style: { margin: '0 5px', color: '#999' }, children: "\u2022" }), showMetadataNames && (_jsxs("span", { style: { color: '#666', marginRight: '5px' }, children: [md?.name || key, ":"] })), md?.dataDomain === MetadataDataDomains.DataList ? (_jsx(TMDataListItemViewer, { dataListId: md.dataListID, viewMode: md.dataListViewMode, value: value })) : md?.dataDomain === MetadataDataDomains.UserID ? (_jsx(TMDataUserIdItemViewer, { userId: value, showIcon: true })) : (_jsx("span", { style: {
+                        overflow: isLast ? 'hidden' : 'visible',
+                        textDecoration: textDecoration,
+                        color: textColor
+                    }, children: [index > 0 && _jsx("span", { style: { margin: '0 5px', color: textColor || '#999', textDecoration: textDecoration }, children: "\u2022" }), showMetadataNames && (_jsxs("span", { style: { color: textColor || '#666', marginRight: '5px', textDecoration: textDecoration }, children: [md?.name || key, ":"] })), md?.dataDomain === MetadataDataDomains.DataList ? (_jsx("span", { style: { textDecoration: textDecoration, color: textColor }, children: _jsx(TMDataListItemViewer, { dataListId: md.dataListID, viewMode: md.dataListViewMode, value: value }) })) : md?.dataDomain === MetadataDataDomains.UserID ? (_jsx("span", { style: { textDecoration: textDecoration, color: textColor }, children: _jsx(TMDataUserIdItemViewer, { userId: value, showIcon: true }) })) : (_jsx("span", { style: {
                                 fontWeight: 500,
                                 overflow: isLast ? 'hidden' : 'visible',
                                 textOverflow: isLast ? 'ellipsis' : 'clip',
-                                whiteSpace: 'nowrap'
+                                whiteSpace: 'nowrap',
+                                textDecoration: textDecoration,
+                                color: textColor
                             }, children: value }))] }, `${key}_${index}`));
             }) }));
         const metadataContent = customDocumentContent
@@ -744,7 +1057,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
     if (mergedTreeData.length === 0) {
         return _jsx("div", { style: { padding: '20px', textAlign: 'center', color: '#666' }, children: "Nessuna relazione disponibile." });
     }
-    return (_jsxs(_Fragment, { children: [_jsx(TMTreeView, { dataSource: mergedTreeData, itemRender: finalItemRender, calculateItemsForNode: calculateItemsForNode, onDataChanged: handleDataChanged, focusedItem: focusedItem, onFocusedItemChanged: handleFocusedItemChanged, allowMultipleSelection: allowMultipleSelection, selectedItems: selectedItems, onSelectionChanged: handleSelectedItemsChanged }), showExpansionWaitPanel && (_jsx(TMWaitPanel, { title: isForMaster ? 'Caricamento documenti master' : 'Caricamento documenti dettaglio', showPrimary: true, textPrimary: expansionWaitPanelText, valuePrimary: expansionWaitPanelValue, maxValuePrimary: expansionWaitPanelMaxValue, isCancelable: true, abortController: expansionAbortController, onAbortClick: (abortController) => {
+    return (_jsxs(_Fragment, { children: [_jsx(TMTreeView, { dataSource: mergedTreeData, itemRender: finalItemRender, calculateItemsForNode: calculateItemsForNode, onDataChanged: handleDataChanged, focusedItem: focusedItem, onFocusedItemChanged: handleFocusedItemChanged, allowMultipleSelection: allowMultipleSelection, selectedItems: selectedItems, itemsPerPage: 100, onSelectionChanged: handleSelectedItemsChanged }), showExpansionWaitPanel && (_jsx(TMWaitPanel, { title: isForMaster ? 'Caricamento documenti master' : 'Caricamento documenti dettaglio', showPrimary: true, textPrimary: expansionWaitPanelText, valuePrimary: expansionWaitPanelValue, maxValuePrimary: expansionWaitPanelMaxValue, isCancelable: true, abortController: expansionAbortController, onAbortClick: (abortController) => {
                     setTimeout(() => {
                         abortController?.abort();
                     }, 100);

package/lib/components/features/tasks/TMTaskFormUtils.js

@@ -274,9 +274,9 @@ export const RenderTaskFormStateField = (props) => {
     const closeTaskCallback = () => {
         if (!formData || !formData.id)
             return;
-        const msg = `Sei sicuro voler chiudere l'attività ${formData.name ?? 'N/A'}?`;
+        const msg = _jsxs("span", { children: ["Sei sicuro voler chiudere l'attivit\u00E0 \"", _jsx("b", { children: formData.name ?? "N/A" }), "\"?"] });
         TMMessageBoxManager.show({
-            title: SDKUI_Localizator.MarkAs, message: msg, buttons: [ButtonNames.YES, ButtonNames.NO],
+            title: SDKUI_Localizator.CloseTask, message: msg, buttons: [ButtonNames.YES, ButtonNames.NO],
             onButtonClick: async (e) => {
                 if (e !== ButtonNames.YES)
                     return;
@@ -345,7 +345,7 @@ export const TMChangeStateForm = (props) => {
     const [dropdownValues, setDropdownValues] = React.useState([]);
     useEffect(() => {
         const availableTransitions = getAvailableTaskTransitions(formData?.state ?? Task_States.None, taskRole);
-        const values = getDropdownValuesFromTaskStates(availableTransitions, formData?.state ?? Task_States.None);
+        const values = getDropdownValuesFromTaskStates(availableTransitions);
         setDropdownValues(values);
         if (values.length > 0) {
             const currentState = formData?.state ?? Task_States.None;
@@ -416,7 +416,7 @@ const getAvailableTaskTransitions = (currentStatus, role) => {
     const transitions = STATUS_TRANSITIONS[role];
     return transitions?.[currentStatus] ?? [];
 };
-const getDropdownValuesFromTaskStates = (states, currentState) => {
+const getDropdownValuesFromTaskStates = (states) => {
     const map = {
         [Task_States.Completed]: SDKUI_Localizator.Completed,
         [Task_States.Closed]: SDKUI_Localizator.Closed,
@@ -427,6 +427,6 @@ const getDropdownValuesFromTaskStates = (states, currentState) => {
         [Task_States.None]: "",
     };
     return states
-        .filter(state => state !== Task_States.None && state !== currentState)
+        .filter(state => state !== Task_States.None)
         .map(state => ({ value: state, display: map[state] }));
 };

package/lib/helper/SDKUI_Localizator.d.ts

@@ -100,6 +100,7 @@ export declare class SDKUI_Localizator {
     static get ClearOTP(): "OTP löschen" | "Clear OTP" | "Borrar OTP" | "Effacer l'OTP" | "Limpar OTP" | "Cancella OTP";
     static get Close(): "Ausgang" | "Close" | "Salida" | "Sortie" | "Saída" | "Chiudi";
     static get Closed(): "Geschlossen" | "Closed" | "Cerrada" | "Fermée" | "Fechada" | "Chiusa";
+    static get CloseTask(): string;
     static get Columns_All_Hide(): "Alle Spalten ausblenden" | "Hide all columns" | "Ocultar todas las columnas" | "Masquer toutes les colonnes" | "Ocultar todas as colunas" | "Nascondi tutte le colonne";
     static get Columns_All_Show(): "Alle Spalten anzeigen" | "Show all columns" | "Mostrar todas las columnas" | "Afficher toutes les colonnes" | "Mostrar todas as colunas" | "Visualizza tutte le colonne";
     static get Comment(): string;
@@ -517,6 +518,8 @@ export declare class SDKUI_Localizator {
     static get Redo(): "Wiederherstellen" | "Redo" | "Rehacer" | "Rétablir" | "Refazer" | "Rifai";
     static get Reject(): "Ablehnen" | "Reject" | "Rechazar" | "Rejeter" | "Rejeitar" | "Rifiuta";
     static get Relations(): "Korrelationen" | "Correlations" | "Correlaciones" | "Relations" | "Correlacionados" | "Correlazioni";
+    static get RelationsNotFound(): "Keine Korrelationen gefunden" | "No correlations found" | "No se encontraron correlaciones" | "Aucune corrélation trouvée" | "Nenhuma correlação encontrada" | "Nessuna correlazione trovata";
+    static get RelatedDcmtsNotFound(): "Für das ausgewählte Dokument wurden keine zugehörigen Dokumente gefunden." | "No related documents were found for the selected document." | "No se encontraron documentos relacionados para el documento seleccionado." | "Aucun document associé n'a été trouvé pour le document sélectionné." | "Nenhum documento relacionado foi encontrado para o documento selecionado." | "Non sono stati trovati documenti correlati per il documento selezionato.";
     static get RelationManyToMany(): "Folge viele mit vielen" | "Relation many to many" | "Correlación muchos a muchos" | "Corrélation plusieurs à plusieurs" | "Muitos para muitos relação" | "Correlazione molti a molti";
     static get RelationType(): "Art der Beziehung" | "Relation type" | "Tipo de relación" | "Type de relation" | "Tipo de relacionamento" | "Tipo di relazione";
     static get RemoveContextualFilter(): "Kontextbezogenen Filter entfernen" | "Remove contextual filter" | "Eliminar filtro contextual" | "Supprimer le filtre contextuel" | "Remover filtro contextual" | "Rimuovi filtro contestuale";

package/lib/helper/SDKUI_Localizator.js

@@ -980,6 +980,16 @@ export class SDKUI_Localizator {
             default: return "Chiusa";
         }
     }
+    static get CloseTask() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Aufgabe schließen";
+            case CultureIDs.En_US: return "Close task";
+            case CultureIDs.Es_ES: return "Cerrar tarea";
+            case CultureIDs.Fr_FR: return "Fermer la tâche";
+            case CultureIDs.Pt_PT: return "Fechar tarefa";
+            default: return "Chiudi attività";
+        }
+    }
     static get Columns_All_Hide() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Alle Spalten ausblenden";
@@ -5135,6 +5145,26 @@ export class SDKUI_Localizator {
         }
         ;
     }
+    static get RelationsNotFound() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Keine Korrelationen gefunden";
+            case CultureIDs.En_US: return "No correlations found";
+            case CultureIDs.Es_ES: return "No se encontraron correlaciones";
+            case CultureIDs.Fr_FR: return "Aucune corrélation trouvée";
+            case CultureIDs.Pt_PT: return "Nenhuma correlação encontrada";
+            default: return "Nessuna correlazione trovata";
+        }
+    }
+    static get RelatedDcmtsNotFound() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Für das ausgewählte Dokument wurden keine zugehörigen Dokumente gefunden.";
+            case CultureIDs.En_US: return "No related documents were found for the selected document.";
+            case CultureIDs.Es_ES: return "No se encontraron documentos relacionados para el documento seleccionado.";
+            case CultureIDs.Fr_FR: return "Aucun document associé n'a été trouvé pour le document sélectionné.";
+            case CultureIDs.Pt_PT: return "Nenhum documento relacionado foi encontrado para o documento selecionado.";
+            default: return "Non sono stati trovati documenti correlati per il documento selezionato.";
+        }
+    }
     static get RelationManyToMany() {
         switch (this._cultureID) {
             case CultureIDs.De_DE: return "Folge viele mit vielen";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@topconsultnpm/sdkui-react",
-    "version": "6.20.0-dev2.47",
+    "version": "6.20.0-dev2.49",
     "description": "",
     "scripts": {
         "test": "echo \"Error: no test specified\" && exit 1",