@topconsultnpm/sdkui-react 6.21.0-dev4.15 → 6.21.0-dev4.17

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

@@ -1,16 +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, MetadataDataDomains, RelationCacheService, RelationTypes, UserListCacheService } from "@topconsultnpm/sdk-ts";
-import { genUniqueId, IconFolder, IconBackhandIndexPointingRight, IconCircleInfo, getDcmtCicoStatus, IconChevronDown, IconChevronRight, SDKUI_Localizator, buildDcmtDisplayName } from '../../../helper';
+import { genUniqueId, IconFolder, IconBackhandIndexPointingRight, IconCircleInfo, getDcmtCicoStatus, IconChevronDown, IconChevronRight, SDKUI_Localizator, buildDcmtDisplayName, SDKUI_Globals } 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
  */
@@ -124,13 +126,16 @@ 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, 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('');
@@ -164,6 +169,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
      */
@@ -192,7 +209,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)
@@ -275,7 +295,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)
@@ -1214,13 +1237,231 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
             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.
      */
@@ -1246,9 +1487,11 @@ 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
@@ -1264,27 +1507,50 @@ const TMRelationViewer = ({ inputDcmts, isForMaster = false, showCurrentDcmtIndi
     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);
                 } }))] }));
 };

package/lib/helper/SDKUI_Globals.d.ts

@@ -84,6 +84,7 @@ export declare class SearchSettings {
             height: string;
         };
     };
+    relationExpandLevel: number;
 }
 export declare class FloatingMenuBarSettings {
     orientation?: 'horizontal' | 'vertical';

package/lib/helper/SDKUI_Globals.js

@@ -122,6 +122,7 @@ export class SearchSettings {
         this.maxDcmtsToBeReturned = DEFAULT_MAX_DCMTS_TO_BE_RETURNED;
         this.floatingMenuBar = new FloatingMenuBarSettings();
         this.panelLayout = {};
+        this.relationExpandLevel = 4; // Livello di espansione predefinito per le correlazioni
     }
 }
 export class FloatingMenuBarSettings {

package/lib/helper/SDKUI_Localizator.d.ts

@@ -110,7 +110,9 @@ export declare class SDKUI_Localizator {
     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 Collapse(): "Reduzieren" | "Collapse" | "Contraer" | "Réduire" | "Recolher" | "Comprimi";
     static get CollapseAll(): "Alle reduzieren" | "Collapse all" | "Contraer todo" | "Tout réduire" | "Recolher tudo" | "Comprimi tutto";
+    static get CollapseTree(): "Gesamten Baum reduzieren" | "Collapse entire tree" | "Contraer todo el árbol" | "Réduire tout l'arbre" | "Recolher toda a árvore" | "Comprimi tutto l'albero";
     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;
@@ -273,6 +275,17 @@ export declare class SDKUI_Localizator {
     static get ExtractedOn(): "Ausgezogen am" | "Extracted on" | "Extraído el" | "Extrait le" | "Extraído em" | "Estratto il";
     static get EvaluateResult(): "Bewerten Sie das Ergebnis" | "Evaluate result" | "Valorar el resultado" | "Évalue les résultats" | "Avalia os resultados" | "Valuta il risultato";
     static get ExpandAll(): "Alle erweitern" | "Expand all" | "Expandir todo" | "Tout développer" | "Expandir tudo" | "Espandi tutto";
+    static get ExpandLevels(): "Erweitern ({{0}} Ebenen)" | "Expand ({{0}} levels)" | "Expandir ({{0}} niveles)" | "Développer ({{0}} niveaux)" | "Expandir ({{0}} níveis)" | "Espandi ({{0}} livelli)";
+    static get ExpandAllLevels(): "Erweitern (alle Ebenen)" | "Expand (all levels)" | "Expandir (todos los niveles)" | "Développer (tous les niveaux)" | "Expandir (todos os níveis)" | "Espandi (tutti i livelli)";
+    static get CtrlClickToReloadAll(): "Strg+Klick = alles neu laden" | "Ctrl+click = reload all" | "Ctrl+clic = recargar todo" | "Ctrl+clic = tout recharger" | "Ctrl+clique = recarregar tudo" | "Ctrl+click = ricarica tutto";
+    static get ExpandComplete(): "Erweiterung abgeschlossen" | "Expand complete" | "Expansión completada" | "Expansion terminée" | "Expansão concluída" | "Espansione completata";
+    static get ExpandToLevel(): "Erweitern bis Ebene {{0}}" | "Expand to level {{0}}" | "Expandir hasta el nivel {{0}}" | "Développer jusqu'au niveau {{0}}" | "Expandir até o nível {{0}}" | "Espandi fino al livello {{0}}";
+    static get ExpansionLevel(): "Erweiterungsebene" | "Expansion level" | "Nivel de expansión" | "Niveau d'expansion" | "Nível de expansão" | "Livello di espansione";
+    static get ExpansionLevelSettings(): "Erweiterungsebene Einstellungen" | "Expansion level settings" | "Configuración del nivel de expansión" | "Paramètres du niveau d'expansion" | "Configurações do nível de expansão" | "Impostazioni livello espansione";
+    static get ExpansionSettings(): "Erweiterungseinstellungen" | "Expansion settings" | "Configuración de expansión" | "Paramètres d'expansion" | "Configurações de expansão" | "Impostazioni espansione";
+    static get ExpansionInProgress(): "Erweiterung läuft..." | "Expansion in progress..." | "Expansión en curso..." | "Expansion en cours..." | "Expansão em andamento..." | "Espansione in corso...";
+    static get FullReloadInProgress(): "Vollständiges Neuladen läuft..." | "Full reload in progress..." | "Recarga completa en curso..." | "Rechargement complet en cours..." | "Recarregamento completo em andamento..." | "Ricaricamento completo in corso...";
+    static get ExpansionProgress(): "Erweiterung {{0}} von {{1}}..." | "Expansion {{0}} of {{1}}..." | "Expansión {{0}} de {{1}}..." | "Expansion {{0}} sur {{1}}..." | "Expansão {{0}} de {{1}}..." | "Espansione {{0}} di {{1}}...";
     static get Expected(): "Erwartet" | "Expected" | "Esperado" | "Attendu" | "Atteso";
     static get Expiration(): "Ablaufdatum" | "Expiration" | "Fecha de expiración" | "Date d'expiration" | "Data de expiração" | "Scadenza";
     static get ExpirationDate(): "Ablaufdatum" | "Expiration date" | "Fecha de vencimiento" | "Date d'échéance" | "Data de validade" | "Data di scadenza";
@@ -422,7 +435,10 @@ export declare class SDKUI_Localizator {
     static get List(): "Liste" | "List" | "Lista";
     static get List_Hide(): "Liste ausblenden" | "Hide list" | "Ocultar lista" | "Masquer la liste" | "Nascondi la lista";
     static get List_Show(): "liste anzeigen" | "Show list" | "Ver lista" | "Afficher la liste" | "Visualizza la lista";
+    static get Levels(): "Ebenen" | "Levels" | "Niveles" | "Niveaux" | "Níveis" | "Livelli";
     static get Loading(): "Laden" | "Loading" | "Carga" | "Chargement" | "Caricamento";
+    static get LoadingDetailDocuments(): "Laden der Detaildokumente" | "Loading detail documents" | "Cargando documentos de detalle" | "Chargement des documents de détail" | "Carregando documentos de detalhe" | "Caricamento documenti dettaglio";
+    static get LoadingMasterDocuments(): "Laden der Masterdokumente" | "Loading master documents" | "Cargando documentos maestros" | "Chargement des documents maîtres" | "Carregando documentos mestres" | "Caricamento documenti master";
     static get Localization(): "Lokalisierung" | "Localization" | "Localización" | "Localisation" | "Localização" | "Localizzazione";
     static get LoadingWorkGroups(): string;
     static get LoadingParticipants(): string;