@topconsultnpm/sdkui-react 6.21.0-t3 → 6.21.0-t5

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

@@ -1,14 +1,18 @@
 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, UserListCacheService } from "@topconsultnpm/sdk-ts";
-import { genUniqueId, IconFolder, IconBackhandIndexPointingRight, IconCircleInfo, getDcmtCicoStatus, IconChevronDown, IconChevronRight, SDKUI_Localizator } from '../../../helper';
+import { DcmtTypeListCacheService, SDK_Globals, DataColumnTypes, MetadataFormats, MetadataDataDomains, RelationCacheService, RelationTypes, UserListCacheService, LayoutModes } from "@topconsultnpm/sdk-ts";
+import { genUniqueId, IconFolder, IconBackhandIndexPointingRight, IconCircleInfo, getDcmtCicoStatus, IconChevronDown, IconChevronRight, SDKUI_Localizator, buildDcmtDisplayName, SDKUI_Globals, searchResultToMetadataValues } from '../../../helper';
+import ShowAlert from '../../base/TMAlert';
+import TMToppyMessage from '../../../helper/TMToppyMessage';
 import { TMColors } from '../../../utils/theme';
-import { StyledDivHorizontal, StyledBadge, StyledToolbarForm } from '../../base/Styled';
+import { StyledDivHorizontal, StyledBadge } from '../../base/Styled';
 import TMTreeView from '../../base/TMTreeView';
 import { TMWaitPanel } from '../../base/TMWaitPanel';
 import TMDataListItemViewer from '../../viewers/TMDataListItemViewer';
 import TMDcmtIcon from './TMDcmtIcon';
 import TMDataUserIdItemViewer from '../../viewers/TMDataUserIdItemViewer';
+import TMTooltip from '../../base/TMTooltip';
+import TMSpinner from '../../base/TMSpinner';
 /**
  * Check if document type has detail relations
  */
@@ -41,31 +45,6 @@ const isManyToManyRelation = async (relationID) => {
     const rdlManyToMany = allRelations.filter(o => o.relationType == RelationTypes.ManyToMany && o.id === relationID) ?? [];
     return rdlManyToMany.length > 0;
 };
-/**
- * Get metadata keys excluding system metadata
- */
-export const getMetadataKeys = (obj) => {
-    if (!obj)
-        return [];
-    const keys = Object.keys(obj);
-    // Escludi metadati di sistema (MID < 100 che sono uppercase) e altri campi tecnici
-    const sysMIDs = Object.values(SystemMIDs).map(o => o.toUpperCase());
-    return keys.filter(k => obj?.[k].value && !sysMIDs.includes(k)).filter(o => o !== "rowIndex" && o !== "ISLEXPROT");
-};
-/**
- * Get display value keys for a document (max 5, prioritize SYS_Abstract)
- */
-export const getDcmtDisplayValue = (obj) => {
-    if (!obj)
-        return [];
-    // Prima cerca SYS_Abstract
-    if (obj['SYS_Abstract']?.value) {
-        return ['SYS_Abstract'];
-    }
-    // Altrimenti prendi i primi 5 metadati non di sistema
-    const mdKeys = getMetadataKeys(obj);
-    return mdKeys.slice(0, 5);
-};
 /**
  * Get display value formatted by column type
  */
@@ -109,40 +88,90 @@ export const getDisplayValueByColumn = (col, value) => {
 };
 /**
  * Convert SearchResultDescriptor to structured data source with metadata
+ * For each document, fetches complete metadata using GetMetadataAsync to ensure
+ * all metadata properties (isSpecialSearchOutput, permissions, etc.) are available
  */
 export const searchResultToDataSource = async (searchResult, hideSysMetadata) => {
     const rows = searchResult?.dtdResult?.rows ?? [];
-    const tid = searchResult?.fromTID;
-    const dtd = await DcmtTypeListCacheService.GetAsync(tid);
     const output = [];
+    // Find TID and DID column indices
+    const columns = searchResult?.dtdResult?.columns ?? [];
+    const tidColIndex = columns.findIndex(col => col.caption?.toUpperCase() === 'TID');
+    const didColIndex = columns.findIndex(col => col.caption?.toUpperCase() === 'DID');
     for (let index = 0; index < rows.length; index++) {
-        const item = { rowIndex: index };
         const row = rows[index];
-        for (let i = 0; i < row.length; i++) {
-            const mid = Number(searchResult?.dtdResult?.columns?.[i]?.extendedProperties?.["MID"] ?? "0");
-            if (hideSysMetadata && mid < 100)
-                continue;
-            let key = searchResult?.dtdResult?.columns?.[i].caption ?? '';
-            if (mid <= 100)
-                key = key.toUpperCase();
-            const value = row[i];
-            const md = dtd?.metadata?.find(o => o.id == mid);
-            item[key] = {
-                md: md,
-                value: getDisplayValueByColumn(searchResult?.dtdResult?.columns?.[i], value)
-            };
+        // Extract TID and DID from row
+        const tid = tidColIndex >= 0 ? Number(row[tidColIndex]) : searchResult?.fromTID;
+        const did = didColIndex >= 0 ? Number(row[didColIndex]) : undefined;
+        // Fetch complete metadata for this specific document (like getFilteredMetadata does)
+        const metadata = await SDK_Globals.tmSession?.NewSearchEngine().GetMetadataAsync(tid, did, true);
+        if (metadata) {
+            // Get full DTD with metadata for this document
+            const dtdResult = metadata.dtdResult;
+            const metadataRows = dtdResult?.rows?.[0] ?? [];
+            const mids = metadata.selectMIDs;
+            const dtdWithMetadata = await DcmtTypeListCacheService.GetWithNotGrantedAsync(tid, did, metadata);
+            const mdList = dtdWithMetadata?.metadata ?? [];
+            // Convert to MetadataValueDescriptorEx array
+            const metadataList = searchResultToMetadataValues(tid, dtdResult, metadataRows, mids, mdList, LayoutModes.Update);
+            // Convert to DcmtMetadataMap format (like getFilteredMetadata does)
+            const item = { rowIndex: index };
+            for (const mvd of metadataList) {
+                if (hideSysMetadata && mvd.mid !== undefined && mvd.mid < 100)
+                    continue;
+                const key = mvd.mid !== undefined && mvd.mid <= 100
+                    ? (mvd.md?.name ?? '').toUpperCase()
+                    : (mvd.md?.name ?? '');
+                if (key) {
+                    item[key] = {
+                        md: mvd.md,
+                        value: mvd.value
+                    };
+                }
+            }
+            output.push(item);
+        }
+        else {
+            // Fallback: use original row data with basic parsing
+            const item = { rowIndex: index };
+            const fallbackTid = searchResult?.fromTID;
+            const dtd = await DcmtTypeListCacheService.GetWithNotGrantedAsync(fallbackTid, undefined, searchResult);
+            for (let i = 0; i < row.length; i++) {
+                const column = searchResult?.dtdResult?.columns?.[i];
+                const mid = Number(column?.extendedProperties?.["MID"] ?? "0");
+                if (hideSysMetadata && mid < 100)
+                    continue;
+                let key = column?.caption ?? '';
+                if (mid <= 100) {
+                    key = key.toUpperCase();
+                }
+                else {
+                    if (item[key] !== undefined && item[key]?.md?.id !== mid) {
+                        key = `${key}_${mid}`;
+                    }
+                }
+                const value = row[i];
+                const md = dtd?.metadata?.find(o => o.id == mid);
+                item[key] = {
+                    md: md,
+                    value: getDisplayValueByColumn(column, value)
+                };
+            }
+            output.push(item);
         }
-        output.push(item);
     }
     return output;
 };
-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 }) => {
+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 }) => {
     // State
     const [dcmtTypes, setDcmtTypes] = useState([]);
     const [treeData, setTreeData] = useState([]);
     const [showZeroDcmts, setShowZeroDcmts] = useState(initialShowZeroDcmts);
     const [staticItemsState, setStaticItemsState] = useState([]);
-    const [allExpanded, setAllExpanded] = useState(defaultExpandAll);
+    const getInitialExpandLevel = () => SDKUI_Globals.userSettings?.searchSettings?.relationExpandLevel ?? DEFAULT_RELATION_EXPAND_LEVEL;
+    const [expandLevel, setExpandLevel] = useState(getInitialExpandLevel);
+    const [isAllCollapsed, setIsAllCollapsed] = useState(false);
     const initialExpandAllAppliedRef = React.useRef(false);
     const [showWaitPanel, setShowWaitPanel] = useState(false);
     const [waitPanelTextPrimary, setWaitPanelTextPrimary] = useState('');
@@ -158,6 +187,10 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
     const lastLoadedInputRef = React.useRef('');
     // State to track loaded input key - triggers re-render for focus selection
     const [loadedInputKey, setLoadedInputKey] = React.useState('');
+    // State to track how many GetMetadataAsync calls failed
+    const [metadataErrorCount, setMetadataErrorCount] = React.useState(0);
+    // State to track total master documents found (used when isForMaster is true)
+    const [totalMasterDocuments, setTotalMasterDocuments] = React.useState(0);
     // Ref to track if user has manually expanded/collapsed static items
     const userInteractedWithStaticItemsRef = React.useRef(false);
     // Ref to track the last inputKey for which we set the focused item
@@ -172,6 +205,18 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         };
         fetchAllUsers();
     }, []);
+    // Notify parent when loading state changes
+    useEffect(() => {
+        const isLoading = showWaitPanel || showExpansionWaitPanel;
+        onLoadingStateChanged?.(isLoading);
+    }, [showWaitPanel, showExpansionWaitPanel, onLoadingStateChanged]);
+    // Sincronizza expandLevel quando userSettings.searchSettings.relationExpandLevel cambia
+    useEffect(() => {
+        const globalExpandLevel = SDKUI_Globals.userSettings?.searchSettings?.relationExpandLevel;
+        if (globalExpandLevel !== undefined && globalExpandLevel !== expandLevel) {
+            setExpandLevel(globalExpandLevel);
+        }
+    }, [SDKUI_Globals.userSettings?.searchSettings?.relationExpandLevel]);
     /**
      * Generate a stable key from inputDcmts to detect real changes
      */
@@ -200,7 +245,10 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
             return [];
         if (!mDID)
             return [];
-        if (maxLevel <= 0)
+        // maxLevel = 0 means unlimited depth (expand as much as possible)
+        // maxLevel > 0 means specific depth limit
+        // maxLevel < 0 means stop recursion
+        if (maxLevel < 0)
             return [];
         const dcmtTypeHasRel = await hasDetailRelations(mTID);
         if (!dcmtTypeHasRel)
@@ -261,6 +309,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                             hidden: false,
                             name: row?.SYS_Abstract?.value || row?.SYS_SUBJECT?.value || `Documento ${did}`,
                             fileExt: row?.FILEEXT?.value,
+                            fileCount: row?.FILECOUNT?.value,
                             // Note: Recursive loading on expansion is handled by calculateItemsForNode
                         });
                     }
@@ -270,7 +319,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
             }
         }
         catch (error) {
-            console.error('❌ Error loading detail documents:', error);
+            console.error('Error loading detail documents:', error);
         }
         return items;
     }, [allowedTIDs]);
@@ -283,7 +332,10 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
             return [];
         if (!dDID)
             return [];
-        if (maxLevel <= 0)
+        // maxLevel = 0 means unlimited depth (expand as much as possible)
+        // maxLevel > 0 means specific depth limit
+        // maxLevel < 0 means stop recursion
+        if (maxLevel < 0)
             return [];
         const dcmtTypeHasRel = await hasMasterRelations(dTID);
         if (!dcmtTypeHasRel)
@@ -341,6 +393,8 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                             isExpandible: canExpand, // Can this doc be expanded?
                             values: row,
                             searchResult: [searchResult],
+                            fileExt: row?.FILEEXT?.value,
+                            fileCount: row?.FILECOUNT?.value,
                             // Leave items and itemsCount undefined so TMTreeView shows expand arrow based on isExpandible
                             // Children will be loaded lazily by calculateItemsForNode when expanded
                             expanded: false,
@@ -386,7 +440,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                     updatedItems = [
                         {
                             key: `__info__${node.key}`,
-                            name: 'Nessun documento correlato da visualizzare',
+                            name: SDKUI_Localizator.NoRelatedDocumentsToDisplay,
                             isContainer: false,
                             isDcmt: false,
                             isInfoMessage: true,
@@ -421,71 +475,82 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
     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 ONLY if there's exactly one
-                const docItems = newFirstDoc.items;
-                const containerChildren = docItems?.filter(child => child.isContainer) ?? [];
-                if (containerChildren.length === 1 && docItems && docItems.length > 0 && docItems[0].isContainer) {
-                    const newFirstCorrelation = { ...docItems[0], expanded: true };
-                    newFirstDoc = {
-                        ...newFirstDoc,
-                        items: [newFirstCorrelation, ...docItems.slice(1)]
-                    };
+        // Find the first container with documents (not empty)
+        // This ensures we focus on an actual document, not an empty container
+        const findFirstNonEmptyContainerIndex = () => {
+            for (let i = 0; i < tree.length; i++) {
+                const container = tree[i];
+                if (!container.isZero && container.items && Array.isArray(container.items) && container.items.length > 0) {
+                    return i;
                 }
-                // Update the container's items
-                newFirstContainer = {
-                    ...newFirstContainer,
-                    items: [newFirstDoc, ...firstRootItems.slice(1)]
-                };
             }
-            else if (firstDocOrContainer.isContainer) {
-                // First item is a container (correlation folder)
-                // Count how many sibling containers there are
-                const siblingContainers = firstRootItems.filter(child => child.isContainer);
-                const shouldExpand = siblingContainers.length === 1;
-                let newFirstCorrelation = {
-                    ...firstDocOrContainer,
-                    expanded: shouldExpand
-                };
-                // 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)]
-                    };
+            return 0; // Fallback to first container if all are empty
+        };
+        const targetContainerIndex = findFirstNonEmptyContainerIndex();
+        // Process all containers, but only mark the target one for focus
+        const result = tree.map((container, index) => {
+            const isTargetContainer = index === targetContainerIndex;
+            const isFirstContainer = index === 0;
+            // Always expand the first container (even if empty, to show infoMessage)
+            // Also expand the target container if different
+            const shouldExpand = isFirstContainer || isTargetContainer;
+            if (!shouldExpand && !isTargetContainer) {
+                return container; // Keep non-target containers as-is
+            }
+            // Create a copy with expanded state
+            let newContainer = {
+                ...container,
+                expanded: shouldExpand,
+                isRoot: isTargetContainer // Only mark target container as root
+            };
+            // Only process items for the target container (the one with documents)
+            if (isTargetContainer) {
+                const containerItems = newContainer.items;
+                if (containerItems && containerItems.length > 0) {
+                    const firstDocOrContainer = containerItems[0];
+                    if (firstDocOrContainer.isDcmt) {
+                        // First item is a document - expand it and mark as root for focus
+                        let newFirstDoc = {
+                            ...firstDocOrContainer,
+                            expanded: true,
+                            isRoot: true
+                        };
+                        // NOTE: Le cartelle di correlazione rimangono con expanded: false.
+                        // Verranno espanse solo tramite il pulsante "espandi n livelli" o espansione manuale.
+                        // Update the container's items
+                        newContainer = {
+                            ...newContainer,
+                            items: [newFirstDoc, ...containerItems.slice(1)]
+                        };
+                    }
+                    else if (firstDocOrContainer.isContainer) {
+                        // First item is a container (correlation folder)
+                        // NOTE: Le cartelle di correlazione rimangono con expanded: false.
+                        // Verranno espanse solo tramite il pulsante "espandi n livelli" o espansione manuale.
+                        let newFirstCorrelation = {
+                            ...firstDocOrContainer,
+                            expanded: false
+                        };
+                        // Find first document inside this container and mark for focus
+                        const correlationItems = newFirstCorrelation.items;
+                        if (correlationItems && correlationItems.length > 0 && correlationItems[0].isDcmt) {
+                            const newFirstDoc = { ...correlationItems[0], isRoot: true };
+                            newFirstCorrelation = {
+                                ...newFirstCorrelation,
+                                items: [newFirstDoc, ...correlationItems.slice(1)]
+                            };
+                        }
+                        // Update the container's items
+                        newContainer = {
+                            ...newContainer,
+                            items: [newFirstCorrelation, ...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)];
+            return newContainer;
+        });
+        return result;
     };
     /**
      * Main data loading function
@@ -497,6 +562,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         }
         const tree = [];
         let processedCount = 0;
+        let errorCount = 0;
         for (const dcmt of inputDcmts) {
             // Check for abort
             if (abortController.signal.aborted) {
@@ -509,7 +575,24 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
             if (!searchEngine)
                 continue;
             // Load document metadata
-            const result = await searchEngine.GetMetadataAsync(dcmt.TID, dcmt.DID, false);
+            let result;
+            try {
+                result = await searchEngine.GetMetadataAsync(dcmt.TID, dcmt.DID, false);
+            }
+            catch (metadataError) {
+                console.warn('[TMRelationViewer] GetMetadataAsync failed for TID:', dcmt.TID, 'DID:', dcmt.DID, metadataError);
+                errorCount++;
+                ShowAlert({
+                    title: SDKUI_Localizator.Warning,
+                    message: `Il documento (TID: ${dcmt.TID}, DID: ${dcmt.DID}) non esiste più o non è accessibile.`,
+                    mode: 'warning',
+                    duration: 5000
+                });
+                // Skip this document and continue with the next one
+                processedCount++;
+                setWaitPanelValuePrimary(processedCount);
+                continue;
+            }
             const dtd = await DcmtTypeListCacheService.GetAsync(dcmt.TID);
             // Parse document values
             const docValues = await searchResultToDataSource(result);
@@ -636,7 +719,8 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                         searchResult: result ? [result] : [],
                         items: relatedDocs,
                         itemsCount: relatedDocs.length,
-                        fileExt: docRow?.FILEEXT?.value
+                        fileExt: docRow?.FILEEXT?.value,
+                        fileCount: docRow?.FILECOUNT?.value
                     };
                     // Check if a type container for this TID already exists in the tree
                     const existingContainer = tree.find(c => c.tid === dcmt.TID && c.isContainer);
@@ -714,6 +798,24 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         if (hasNoRelations && onNoRelationsFound) {
             onNoRelationsFound();
         }
+        // Update metadata error count state
+        setMetadataErrorCount(errorCount);
+        // Count total master documents (only relevant when isForMaster is true)
+        if (isForMaster) {
+            const countMasterDocuments = (items) => {
+                let count = 0;
+                for (const item of items) {
+                    if (item.isDcmt && !item.isZero) {
+                        count++;
+                    }
+                    if (item.items && Array.isArray(item.items)) {
+                        count += countMasterDocuments(item.items);
+                    }
+                }
+                return count;
+            };
+            setTotalMasterDocuments(countMasterDocuments(tree));
+        }
         // 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);
@@ -904,7 +1006,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                     return [
                         {
                             key: `__info__${node.key}`,
-                            name: 'Nessun documento correlato da visualizzare',
+                            name: SDKUI_Localizator.NoRelatedDocumentsToDisplay,
                             isContainer: false,
                             isDcmt: false,
                             isInfoMessage: true,
@@ -933,7 +1035,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                 return [
                     {
                         key: `__info__${node.key}`,
-                        name: 'Nessun documento correlato da visualizzare',
+                        name: SDKUI_Localizator.NoRelatedDocumentsToDisplay,
                         isContainer: false,
                         isDcmt: false,
                         isInfoMessage: true,
@@ -988,7 +1090,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                     return [
                         {
                             key: `__info__${node.key}`,
-                            name: 'Nessun documento correlato da visualizzare',
+                            name: SDKUI_Localizator.NoRelatedDocumentsToDisplay,
                             isContainer: false,
                             isDcmt: false,
                             isInfoMessage: true,
@@ -1078,42 +1180,40 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
             transition: 'opacity 0.2s ease-in-out',
             textDecoration: isLogicallyDeleted ? 'line-through' : 'none'
         };
-        const documentStyle = customDocumentStyle
-            ? { ...defaultDocumentStyle, ...customDocumentStyle(item) }
-            : defaultDocumentStyle;
+        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',
-                textDecoration: textDecoration,
-                color: textColor
-            }, children: getDcmtDisplayValue(item.values).map((key, index) => {
-                const md = item.values?.[key]?.md;
-                const value = item.values?.[key]?.value;
-                const displayValues = getDcmtDisplayValue(item.values);
-                const isLast = index === displayValues.length - 1;
-                return (_jsxs(StyledDivHorizontal, { style: {
-                        flexShrink: isLast ? 1 : 0,
-                        minWidth: isLast ? 0 : 'auto',
-                        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',
-                                textDecoration: textDecoration,
-                                color: textColor
-                            }, children: value }))] }, `${key}_${index}`));
-            }) }));
-        const metadataContent = customDocumentContent
-            ? customDocumentContent(item, defaultMetadataContent || _jsx(_Fragment, {}))
-            : defaultMetadataContent;
+        const defaultMetadataContent = item.values && (() => {
+            const displayKeys = buildDcmtDisplayName(item.values);
+            return (_jsx(StyledDivHorizontal, { style: {
+                    fontSize: '1rem',
+                    overflow: 'hidden',
+                    flex: 1,
+                    minWidth: 0,
+                    whiteSpace: 'nowrap',
+                    textDecoration: textDecoration,
+                    color: textColor
+                }, children: displayKeys.map((key, index) => {
+                    const md = item.values?.[key]?.md;
+                    const value = item.values?.[key]?.value;
+                    const isLast = index === displayKeys.length - 1;
+                    return (_jsxs(StyledDivHorizontal, { style: {
+                            flexShrink: isLast ? 1 : 0,
+                            minWidth: isLast ? 0 : 'auto',
+                            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',
+                                    textDecoration: textDecoration,
+                                    color: textColor
+                                }, children: value }))] }, `${key}_${index}`));
+                }) }));
+        })();
+        const metadataContent = customDocumentContent ? customDocumentContent(item, defaultMetadataContent || _jsx(_Fragment, {})) : defaultMetadataContent;
         // Calculate checkout status for non-root documents
         let checkoutStatusIcon = null;
         if (item.values && item.dtd) {
@@ -1137,7 +1237,7 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
                 checkoutStatusIcon = checkoutStatus.icon;
             }
         }
-        return (_jsxs("div", { onDoubleClick: handleDoubleClick, style: documentStyle, children: [item.did && item.tid && showCurrentDcmtIndicator && inputDcmts?.some(d => d.DID === item.did && d.TID === item.tid) ? _jsx(IconBackhandIndexPointingRight, { fontSize: 22, overflow: 'visible' }) : _jsx(_Fragment, {}), item.values && (_jsx(TMDcmtIcon, { tid: item.values?.TID?.value, did: item.values?.DID?.value, fileExtension: item.values?.FILEEXT?.value, fileCount: item.values?.FILECOUNT?.value, isLexProt: item.values?.IsLexProt?.value, isMail: item.values?.ISMAIL?.value, isShared: item.values?.ISSHARED?.value, isSigned: item.values?.ISSIGNED?.value, downloadMode: 'openInNewWindow' })), checkoutStatusIcon, metadataContent] }));
+        return (_jsxs("div", { onDoubleClick: handleDoubleClick, style: documentStyle, children: [item.did && item.tid && showCurrentDcmtIndicator && inputDcmts?.some(d => d.DID === item.did && d.TID === item.tid) ? _jsx(IconBackhandIndexPointingRight, { fontSize: 22, overflow: 'visible' }) : _jsx(_Fragment, {}), item.values && (_jsx(TMDcmtIcon, { tid: item.values?.TID?.value, did: item.values?.DID?.value, fileExtension: item.values?.FILEEXT?.value, fileCount: item.values?.FILECOUNT?.value, isLexProt: item.values?.IsLexProt?.value, isMail: item.values?.ISMAIL?.value, isShared: item.values?.ISSHARED?.value, isSigned: item.values?.ISSIGNED?.value, downloadMode: 'openInNewWindow', usePortal: true })), checkoutStatusIcon, metadataContent] }));
     }, [onDocumentDoubleClick, showCurrentDcmtIndicator, inputDcmts, customMainContainerContent, customDocumentStyle, customDocumentContent, showMetadataNames, showMainDocument, allUsers]);
     /**
      * Wrapper renderer that handles custom rendering if provided
@@ -1171,6 +1271,8 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
     /**
      * Recursively set the `expanded` property on every node that has children loaded.
      * Nodes without `items` are left untouched (will be loaded lazily on user click).
+     * NOTE: Solo i nodi con figli già caricati (isLoaded o hasChildren) vengono espansi.
+     * I nodi con isExpandible ma senza figli caricati rimangono chiusi.
      */
     const setExpandedRecursively = useCallback((nodes, expanded) => {
         if (!nodes || !Array.isArray(nodes))
@@ -1178,18 +1280,237 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         return nodes.map(node => {
             const hasChildren = Array.isArray(node.items) && node.items.length > 0;
             const newItems = hasChildren ? setExpandedRecursively(node.items, expanded) : node.items;
-            // Only toggle expansion if the node is expandable (container/doc with children or marked expandible)
-            const canExpand = hasChildren || node.isExpandible;
+            // Only toggle expansion if the node has children already loaded.
+            // Nodes with isExpandible but no loaded children stay collapsed (will be loaded lazily).
+            const canExpand = hasChildren || node.isLoaded;
             return { ...node, expanded: canExpand ? expanded : node.expanded, items: newItems };
         });
     }, []);
-    const handleToggleExpandAll = useCallback(() => {
-        const next = !allExpanded;
-        setAllExpanded(next);
-        setTreeData(prev => setExpandedRecursively(prev, next));
-        setStaticItemsState(prev => setExpandedRecursively(prev, next));
-        userInteractedWithStaticItemsRef.current = true;
-    }, [allExpanded, setExpandedRecursively]);
+    // Collassa l'albero impostando tutti i nodi come non espansi
+    const handleCollapseTree = useCallback(() => {
+        // Funzione helper per collassare ricorsivamente tutti i nodi
+        const collapseAllNodes = (nodes) => {
+            return nodes.map(node => ({
+                ...node,
+                expanded: false,
+                items: node.items ? collapseAllNodes(node.items) : node.items
+            }));
+        };
+        // Collassa tutti i nodi dell'albero
+        setTreeData(prevData => collapseAllNodes(prevData));
+        setStaticItemsState(prevData => collapseAllNodes(prevData));
+        setIsAllCollapsed(true);
+    }, []);
+    /**
+     * Espande ricorsivamente l'albero fino a `expandLevel`.
+     * Carica i figli lazy (API) solo se non già in memoria (isLoaded).
+     * Il contatore totalNodes cresce dinamicamente per una % progresso accurata.
+     *
+     * @param forceReload - Se true (Ctrl+click), ricarica tutto ignorando la cache
+     */
+    const handleExpandToLevel = useCallback(async (forceReload = false) => {
+        // Mostra spinner per feedback immediato all'utente
+        TMSpinner.show({ description: forceReload ? SDKUI_Localizator.FullReloadInProgress : SDKUI_Localizator.ExpansionInProgress });
+        // Piccolo delay per permettere allo spinner di renderizzarsi prima del processing pesante
+        await new Promise(resolve => setTimeout(resolve, 50));
+        /**
+         * Se forceReload è true, prima resettiamo tutti i nodi come se non fossero mai stati caricati.
+         * Questo significa rimuovere isLoaded e items da tutti i nodi documento,
+         * così l'espansione successiva li ricaricherà tutti da API.
+         */
+        const resetLoadedState = (nodes) => {
+            return nodes.map(node => {
+                const resetNode = { ...node };
+                // Reset isLoaded per forzare il ricaricamento
+                if (resetNode.isDcmt || resetNode.isExpandible) {
+                    resetNode.isLoaded = false;
+                    // Manteniamo items solo per i container (cartelle), 
+                    // perché i container non vengono ricaricati via API
+                    // I documenti invece devono ricaricare i loro figli (correlazioni)
+                    if (resetNode.isDcmt) {
+                        resetNode.items = undefined;
+                        resetNode.itemsCount = undefined;
+                    }
+                }
+                // Reset ricorsivo sui figli
+                if (resetNode.items && Array.isArray(resetNode.items)) {
+                    resetNode.items = resetLoadedState(resetNode.items);
+                }
+                return resetNode;
+            });
+        };
+        // Se forceReload, reset dello stato prima di iniziare
+        let workingTreeData = treeData;
+        let workingStaticData = staticItemsState;
+        if (forceReload) {
+            workingTreeData = resetLoadedState(treeData);
+            workingStaticData = resetLoadedState(staticItemsState);
+            // Aggiorna subito lo stato per riflettere il reset
+            setTreeData(workingTreeData);
+            setStaticItemsState(workingStaticData);
+        }
+        const targetLevel = expandLevel;
+        const newAbortController = new AbortController();
+        setExpansionAbortController(newAbortController);
+        // 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)
+        let totalNodes = 0;
+        let processedNodes = 0;
+        let hasApiCalls = false;
+        let maxReachedProgress = 0;
+        /**
+         * Conta i nodi espandibili in un array (solo primo livello, non ricorsivo).
+         * Usato per aggiornare totalNodes man mano che scopriamo nuovi figli.
+         */
+        const countNodesAtLevel = (nodes) => {
+            let count = 0;
+            for (const node of nodes) {
+                if (node.isContainer || node.isExpandible || node.isDcmt) {
+                    count++;
+                }
+            }
+            return count;
+        };
+        // Conta iniziale: solo i nodi al livello root
+        totalNodes = countNodesAtLevel([...workingTreeData, ...workingStaticData]);
+        /**
+         * FUNZIONE RICORSIVA DI ESPANSIONE
+         *
+         * @param nodes - Array di nodi da processare
+         * @param currentLevel - Livello corrente (0 = root)
+         * @returns Array di nodi con expanded=true e figli caricati
+         *
+         * FLUSSO:
+         * 1. Se targetLevel > 0 e currentLevel >= targetLevel → STOP, ritorna i nodi così come sono
+         *    (Se targetLevel = 0 → espandi senza limiti, non applicare mai il limite)
+         * 2. Per ogni nodo espandibile:
+         *    a) Imposta expanded = true
+         *    b) Se i figli non sono caricati → chiama API per caricarli
+         *    c) Aggiorna totalNodes con i nuovi figli scoperti
+         *    d) CHIAMATA RICORSIVA su expandedNode.items con currentLevel + 1
+         *       → QUESTO È IL PUNTO CHIAVE: i nuovi nodi vengono espansi!
+         */
+        const expandToLevel = async (nodes, currentLevel) => {
+            // CONDIZIONE DI USCITA: abbiamo raggiunto il livello target
+            // targetLevel = 0 significa espandi senza limiti (non applicare mai il limite)
+            // targetLevel > 0 significa applica il limite normalmente
+            if (targetLevel > 0 && currentLevel >= targetLevel)
+                return nodes;
+            // Controlla se l'utente ha annullato l'operazione
+            if (newAbortController.signal.aborted)
+                return nodes;
+            const result = [];
+            for (const node of nodes) {
+                // Controlla abort per ogni nodo (permette cancellazione veloce)
+                if (newAbortController.signal.aborted) {
+                    result.push(node);
+                    continue;
+                }
+                // Crea copia del nodo (immutabilità React)
+                let expandedNode = { ...node };
+                // Verifica se questo nodo può essere espanso
+                const canExpand = node.isContainer || node.isExpandible || node.isDcmt;
+                if (canExpand) {
+                    // PASSO 1: Imposta il nodo come espanso
+                    expandedNode.expanded = true;
+                    // PASSO 2: Verifica se i figli sono già caricati o vanno caricati via API
+                    // Se forceReload è true, ricarica sempre (ignora isLoaded e items esistenti)
+                    const hasLoadedItems = !forceReload && node.items && Array.isArray(node.items) && node.items.length > 0;
+                    const actualHasItems = node.items && Array.isArray(node.items) && node.items.length > 0;
+                    const needsLoading = (forceReload || (!hasLoadedItems && !node.isLoaded)) && (node.isExpandible || node.isDcmt);
+                    if (needsLoading && node.tid && node.did) {
+                        // ═══════════════════════════════════════════════════════════════
+                        // CASO A: I figli NON sono in memoria → CHIAMATA API
+                        // ═══════════════════════════════════════════════════════════════
+                        // Mostra pannello di attesa solo quando ci sono chiamate API
+                        if (!hasApiCalls) {
+                            hasApiCalls = true;
+                            TMSpinner.hide();
+                            setShowExpansionWaitPanel(true);
+                            setExpansionWaitPanelMaxValue(100);
+                            setExpansionWaitPanelValue(0);
+                        }
+                        try {
+                            let loadedItems = [];
+                            // Carica i documenti correlati (detail o master in base alla modalità)
+                            if (isForMaster && !invertMasterNavigation) {
+                                loadedItems = await getDetailDcmtsAsync(node.tid, node.did, 1);
+                            }
+                            else if (isForMaster) {
+                                loadedItems = await getMasterDcmtsAsync(node.tid, node.did, 1);
+                            }
+                            else {
+                                loadedItems = await getDetailDcmtsAsync(node.tid, node.did, 1);
+                            }
+                            // Applica le regole di visibilità (showZeroDcmts)
+                            expandedNode.items = updateHiddenProperty(loadedItems);
+                            expandedNode.isLoaded = true;
+                            expandedNode.itemsCount = loadedItems.length;
+                            // IMPORTANTE: Aggiungi i nuovi nodi scoperti al contatore totale
+                            // Questo viene fatto SOLO se non siamo all'ultimo livello
+                            // (perché i nodi dell'ultimo livello non verranno espansi)
+                            // targetLevel = 0 significa illimitato, quindi aggiungi sempre
+                            if (targetLevel === 0 || currentLevel + 1 < targetLevel) {
+                                const newExpandableCount = countNodesAtLevel(loadedItems);
+                                totalNodes += newExpandableCount;
+                            }
+                        }
+                        catch (error) {
+                            console.error('Errore nel caricamento dei figli del nodo:', error);
+                        }
+                    }
+                    else if (actualHasItems && (targetLevel === 0 || currentLevel + 1 < targetLevel)) {
+                        // ═══════════════════════════════════════════════════════════════
+                        // CASO B: I figli esistono già in memoria (non ricaricati via API)
+                        // Aggiungiamo comunque il loro conteggio a totalNodes
+                        // Usiamo actualHasItems invece di hasLoadedItems per gestire anche forceReload
+                        // ═══════════════════════════════════════════════════════════════
+                        const childCount = countNodesAtLevel(node.items);
+                        totalNodes += childCount;
+                    }
+                    // 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()));
+                    // ═══════════════════════════════════════════════════════════════════
+                    // PASSO 3: CHIAMATA RICORSIVA SUI FIGLI
+                    // Questo è il punto chiave: i nuovi nodi appena caricati vengono
+                    // passati a expandToLevel con currentLevel + 1, quindi anche loro
+                    // verranno espansi (se non abbiamo raggiunto il livello target)
+                    // ═══════════════════════════════════════════════════════════════════
+                    if (expandedNode.items && Array.isArray(expandedNode.items) && expandedNode.items.length > 0) {
+                        expandedNode.items = await expandToLevel(expandedNode.items, currentLevel + 1);
+                    }
+                }
+                result.push(expandedNode);
+            }
+            return result;
+        };
+        try {
+            // Avvia l'espansione dal livello 0 (root)
+            const expandedTree = await expandToLevel(workingTreeData, 0);
+            setTreeData(expandedTree);
+            // Espandi anche gli item statici (se presenti)
+            const expandedStatic = await expandToLevel(workingStaticData, 0);
+            setStaticItemsState(expandedStatic);
+            setIsAllCollapsed(false);
+            userInteractedWithStaticItemsRef.current = true;
+        }
+        finally {
+            // Cleanup: nascondi spinner e pannello di attesa
+            TMSpinner.hide();
+            setShowExpansionWaitPanel(false);
+            setExpansionAbortController(undefined);
+        }
+    }, [expandLevel, treeData, staticItemsState, isForMaster, invertMasterNavigation, getDetailDcmtsAsync, getMasterDcmtsAsync, updateHiddenProperty]);
     /**
      * Apply defaultExpandAll once on initial tree load.
      */
@@ -1215,37 +1536,70 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
         setStaticItemsState(staticItems); // Preserve static items state (expanded/collapsed)
         // Mark that user has interacted with the tree (expanded/collapsed nodes)
         userInteractedWithStaticItemsRef.current = true;
+        // Reset collapsed state when user manually expands a node
+        setIsAllCollapsed(false);
     }, []);
     if (showWaitPanel) {
-        return _jsx("div", { style: { padding: '20px', textAlign: 'center' }, children: _jsx(TMWaitPanel, { title: 'Caricamento documenti dettaglio', showPrimary: true, textPrimary: waitPanelTextPrimary, valuePrimary: waitPanelValuePrimary, maxValuePrimary: waitPanelMaxValuePrimary, isCancelable: true, abortController: abortController, onAbortClick: (abortController) => { setTimeout(() => { abortController?.abort(); }, 1000); } }) });
+        return _jsx("div", { style: { padding: '20px', textAlign: 'center' }, children: _jsx(TMWaitPanel, { title: SDKUI_Localizator.LoadingDetailDocuments, showPrimary: true, textPrimary: waitPanelTextPrimary, valuePrimary: waitPanelValuePrimary, maxValuePrimary: waitPanelMaxValuePrimary, isCancelable: true, abortController: abortController, onAbortClick: () => { setTimeout(() => { abortController.abort(); }, 1000); } }) });
     }
     if (mergedTreeData.length === 0) {
+        // Se NON isForMaster e tutti i GetMetadataAsync sono falliti
+        if (!isForMaster && metadataErrorCount === inputDcmts.length) {
+            return _jsx(TMToppyMessage, { message: SDKUI_Localizator.DocumentsNotAvailableOrNoCorrelations });
+        }
         // If parent handles no-relations via callback, render nothing to avoid UI flash
         if (onNoRelationsFound)
             return null;
-        return _jsx("div", { style: { padding: '20px', textAlign: 'center', color: '#666' }, children: "Nessuna relazione disponibile." });
+        return _jsx("div", { style: { padding: '20px', textAlign: 'center', color: '#666' }, children: SDKUI_Localizator.NoRelationsAvailable });
+    }
+    // Se isForMaster e non ci sono master documents disponibili
+    if (isForMaster && totalMasterDocuments === 0) {
+        return _jsx(TMToppyMessage, { message: SDKUI_Localizator.NoMasterDocumentsAvailable });
     }
-    return (_jsxs("div", { style: { display: 'flex', flexDirection: 'column', height: '100%', minHeight: 0, width: '100%' }, children: [showExpandAllButton && (_jsx(StyledToolbarForm, { style: { flexShrink: 0 }, children: _jsxs("button", { type: "button", onClick: handleToggleExpandAll, title: allExpanded ? SDKUI_Localizator.CollapseAll : SDKUI_Localizator.ExpandAll, style: {
-                        display: 'inline-flex',
-                        alignItems: 'center',
-                        gap: '4px',
-                        padding: '4px 8px',
-                        fontSize: '0.8rem',
-                        color: TMColors.primary,
-                        background: 'transparent',
-                        border: `1px solid ${TMColors.border_normal}`,
-                        borderRadius: '4px',
-                        cursor: 'pointer',
-                        whiteSpace: 'nowrap',
-                        outline: 'none'
-                    }, children: [_jsx("span", { style: { display: 'flex', alignItems: 'center' }, children: allExpanded ? _jsx(IconChevronRight, { fontSize: 14 }) : _jsx(IconChevronDown, { fontSize: 14 }) }), _jsx("span", { children: allExpanded ? SDKUI_Localizator.CollapseAll : SDKUI_Localizator.ExpandAll })] }) })), _jsx("div", { style: { flex: 1, minHeight: 0, overflow: 'auto' }, children: _jsx(TMTreeView, { dataSource: mergedTreeData, itemRender: finalItemRender, calculateItemsForNode: calculateItemsForNode, onDataChanged: handleDataChanged, focusedItem: focusedItem, onFocusedItemChanged: handleFocusedItemChanged, allowMultipleSelection: allowMultipleSelection, selectedItems: selectedItems, itemsPerPage: 100, onSelectionChanged: handleSelectedItemsChanged, onItemContextMenu: onItemContextMenu, shouldDelayFocusOnEvent: (node, e) => {
+    return (_jsxs("div", { style: { display: 'flex', flexDirection: 'column', height: '100%', minHeight: 0, width: '100%' }, children: [showExpandAllButton && (_jsxs("div", { style: { flexShrink: 0, display: 'flex', alignItems: 'center', gap: '6px', height: '40px', paddingLeft: '10px', backgroundColor: TMColors.toolbar_background }, children: [_jsx(TMTooltip, { content: expandLevel === 0
+                            ? `${SDKUI_Localizator.ExpandAllLevels} (${SDKUI_Localizator.CtrlClickToReloadAll})`
+                            : `${SDKUI_Localizator.ExpandToLevel.replaceParams(expandLevel.toString())} (${SDKUI_Localizator.CtrlClickToReloadAll})`, children: _jsxs("button", { type: "button", onClick: (e) => handleExpandToLevel(e.ctrlKey), style: {
+                                display: 'inline-flex',
+                                alignItems: 'center',
+                                justifyContent: 'center',
+                                gap: '5px',
+                                height: '28px',
+                                padding: '0 10px',
+                                fontSize: '0.8rem',
+                                fontWeight: 500,
+                                color: 'white',
+                                background: TMColors.primary,
+                                border: 'none',
+                                borderRadius: '4px',
+                                cursor: 'pointer',
+                                whiteSpace: 'nowrap',
+                                outline: 'none',
+                                transition: 'background 0.2s'
+                            }, children: [_jsx(IconChevronDown, { fontSize: 14 }), _jsx("span", { children: expandLevel === 0 ? SDKUI_Localizator.ExpandAllLevels : SDKUI_Localizator.ExpandLevels.replaceParams(expandLevel.toString()) })] }) }), _jsx(TMTooltip, { content: SDKUI_Localizator.CollapseTree, children: _jsxs("button", { type: "button", onClick: handleCollapseTree, disabled: isAllCollapsed, style: {
+                                display: 'inline-flex',
+                                alignItems: 'center',
+                                justifyContent: 'center',
+                                gap: '5px',
+                                height: '28px',
+                                padding: '0 10px',
+                                fontSize: '0.8rem',
+                                fontWeight: 500,
+                                color: isAllCollapsed ? '#999' : 'white',
+                                background: isAllCollapsed ? '#e0e0e0' : TMColors.secondary || '#6c757d',
+                                border: 'none',
+                                borderRadius: '4px',
+                                cursor: isAllCollapsed ? 'not-allowed' : 'pointer',
+                                whiteSpace: 'nowrap',
+                                outline: 'none',
+                                transition: 'background 0.2s'
+                            }, children: [_jsx(IconChevronRight, { fontSize: 14 }), _jsx("span", { children: SDKUI_Localizator.CollapseAll })] }) })] })), _jsx("div", { style: { flex: 1, minHeight: 0, overflow: 'auto' }, children: _jsx(TMTreeView, { dataSource: mergedTreeData, itemRender: finalItemRender, calculateItemsForNode: calculateItemsForNode, onDataChanged: handleDataChanged, focusedItem: focusedItem, onFocusedItemChanged: handleFocusedItemChanged, allowMultipleSelection: allowMultipleSelection, selectedItems: selectedItems, itemsPerPage: 100, onSelectionChanged: handleSelectedItemsChanged, onItemContextMenu: showExpansionWaitPanel ? undefined : onItemContextMenu, enableVirtualization: true, shouldDelayFocusOnEvent: (node, e) => {
                         // Ritarda il focus quando si clicca sull'icona del documento
                         // per permettere al doppio click di funzionare
                         const target = e.target;
                         return !!target.closest('.tm-dcmt-icon');
-                    } }) }), 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) => {
+                    } }) }), showExpansionWaitPanel && (_jsx(TMWaitPanel, { title: isForMaster ? SDKUI_Localizator.LoadingMasterDocuments : SDKUI_Localizator.LoadingDetailDocuments, showPrimary: true, textPrimary: expansionWaitPanelText, valuePrimary: expansionWaitPanelValue, maxValuePrimary: expansionWaitPanelMaxValue, isCancelable: true, abortController: expansionAbortController, onAbortClick: () => {
                     setTimeout(() => {
-                        abortController?.abort();
+                        expansionAbortController?.abort();
                     }, 100);
                 } }))] }));
 };