@topconsultnpm/sdkui-react 6.22.0-dev2.9 → 6.22.0-dev3.10

package/lib/components/features/search/TMSearch.js

@@ -1,17 +1,17 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { SavedQueryCacheService, DcmtTypeListCacheService, SDK_Localizator, LayoutModes } from '@topconsultnpm/sdk-ts';
 import TMSavedQuerySelector from './TMSavedQuerySelector';
 import TMTreeSelector from './TMTreeSelector';
-import { TabPanel, Item } from 'devextreme-react/tab-panel';
 import TMSearchQueryPanel, { refreshLastSearch } from './TMSearchQueryPanel';
-import { getSysAllDcmtsSQD, IconFilter, IconRecentlyViewed, IconSavedQuery, IconTree, mergeSearchResultsAppend, removeMruTid, SDKUI_Globals, SDKUI_Localizator, updateMruTids } from '../../../helper';
+import { getSysAllDcmtsSQD, SYS_ALL_DCMTS_SQD_ID, IconFilter, IconRecentlyViewed, IconSavedQuery, IconTree, mergeSearchResultsAppend, removeMruTid, SDKUI_Globals, SDKUI_Localizator, updateMruTids } from '../../../helper';
 import TMSearchResult from './TMSearchResult';
+import TMTabControl, { TMTabPanel, useTMTabs } from '../../base/TMTabControl';
 import TMRecentsManager from '../../grids/TMRecentsManager';
 import { SearchResultContext } from '../../../ts';
 import { useDeviceType, DeviceType } from '../../base/TMDeviceProvider';
 import { StyledMultiViewPanel } from '../../base/Styled';
-import { useTMPanelManagerContext } from '../../layout/panelManager/TMPanelManagerContext';
+import { TMPanelManagerProvider, useTMPanelManagerContext } from '../../layout/panelManager/TMPanelManagerContext';
 import TMPanelManagerContainer from '../../layout/panelManager/TMPanelManagerContainer';
 import { TMPanelManagerWithPersistenceProvider } from '../../layout/panelManager/TMPanelManagerWithPersistenceProvider';
 import { TMExceptionBoxManager } from '../../base/TMPopUp';
@@ -20,7 +20,7 @@ var TMSearchViews;
     TMSearchViews[TMSearchViews["Search"] = 0] = "Search";
     TMSearchViews[TMSearchViews["Result"] = 1] = "Result";
 })(TMSearchViews || (TMSearchViews = {}));
-const TMSearch = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTaskCallback, editTaskCallback, handleNavigateToWGs, handleNavigateToDossiers, openInOffice, isVisible, inputTID, inputSqdID, inputMids, isExpertMode = SDKUI_Globals.userSettings.advancedSettings.expertMode === 1, floatingActionConfig, onFileOpened, onRefreshAfterAddDcmtToFavs, onTaskCreateRequest, openWGsCopyMoveForm, editPdfForm = false, openS4TViewer, onOpenS4TViewerRequest, onOpenPdfEditorRequest, openFileUploaderPdfEditor, showTodoDcmtForm, showToppyDraggableHelpCenter = true, toppyHelpCenterUsePortal = false, passToArchiveCallback, onCurrentTIDChangedCallback, onlyShowSearchQueryPanel, onReferenceClick, refreshFavoriteSavedQueries, inputDID, formAutoOpen, fetchRemoteCertificates, graphometricManager }) => {
+const TMSearchInstance = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTaskCallback, editTaskCallback, handleNavigateToWGs, handleNavigateToDossiers, openInOffice, isVisible, inputTID, inputSqdID, inputMids, isExpertMode = SDKUI_Globals.userSettings.advancedSettings.expertMode === 1, floatingActionConfig, onFileOpened, onRefreshAfterAddDcmtToFavs, onTaskCreateRequest, openWGsCopyMoveForm, editPdfForm = false, openS4TViewer, onOpenS4TViewerRequest, onOpenPdfEditorRequest, openFileUploaderPdfEditor, showTodoDcmtForm, showToppyDraggableHelpCenter = true, toppyHelpCenterUsePortal = false, passToArchiveCallback, onCurrentTIDChangedCallback, onlyShowSearchQueryPanel, onReferenceClick, refreshFavoriteSavedQueries, inputDID, formAutoOpen, fetchRemoteCertificates, graphometricManager, onSelectedNameChanged }) => {
     const [allSQDs, setAllSQDs] = useState([]);
     const [filteredByTIDSQDs, setFilteredByTIDSQDs] = useState([]);
     const [currentSQD, setCurrentSQD] = useState();
@@ -32,8 +32,22 @@ const TMSearch = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTask
     const [currentSearchView, setCurrentSearchView] = useState(TMSearchViews.Search);
     const [currentSQDMode, setCurrentSQDMode] = useState(1);
     const [lastQdSearched, setLastQdSearched] = useState();
-    const [showSearchResults, setShowSearchResults] = useState(true);
+    const [showSearchResults, setShowSearchResults] = useState(!onlyShowSearchQueryPanel);
     const [maxDcmtsToBeReturned, setMaxDcmtsToBeReturned] = useState(SDKUI_Globals.userSettings.searchSettings?.maxDcmtsToBeReturned ?? 1000);
+    // Il titolo del tab e' il nome del tipo documento dell'ultima scelta dell'utente, sia questa fatta
+    // dall'albero, dalle scorciatoie o da una ricerca rapida (di cui conta il tipo documento, non il nome).
+    // La callback sta in un ref cosi non entra nelle dipendenze di effetti e memo.
+    const selectedNameRef = useRef(onSelectedNameChanged);
+    selectedNameRef.current = onSelectedNameChanged;
+    // Il nome del tipo documento scelto arriva dal descrittore, che qui e' gia' in cache
+    const notifySelectedTIDAsync = useCallback(async (tid) => {
+        if (!tid || !selectedNameRef.current)
+            return;
+        const dtd = await DcmtTypeListCacheService.GetAsync(tid);
+        const name = dtd?.nameLoc ?? dtd?.name;
+        if (name)
+            selectedNameRef.current(name);
+    }, []);
     const deviceType = useDeviceType();
     useEffect(() => {
         if (onCurrentTIDChangedCallback) {
@@ -47,6 +61,7 @@ const TMSearch = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTask
     useEffect(() => {
         if (!inputTID)
             return;
+        notifySelectedTIDAsync(inputTID);
         setCurrentTID(inputTID);
         setCurrentSearchView(TMSearchViews.Search);
     }, [inputTID]);
@@ -54,6 +69,7 @@ const TMSearch = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTask
         const loadSqd = async () => {
             try {
                 const resultSqd = await SavedQueryCacheService.GetAsync(inputSqdID);
+                notifySelectedTIDAsync(resultSqd?.masterTID);
                 await setSQDAsync(resultSqd);
                 // Mostra la vista Search per visualizzare i filtri della SavedQuery caricata
                 setCurrentSearchView(TMSearchViews.Search);
@@ -141,17 +157,54 @@ const TMSearch = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTask
             setCurrentMruTID(0);
     };
     const onSQDItemClick = useCallback(async (sqd, setSqdAsync) => {
+        notifySelectedTIDAsync(sqd.masterTID);
         // Forza ricaricamento completo se la query è già selezionata
         if (sqd.id === currentSQD?.id) {
             await setSqdAsync(undefined);
         }
         await setSqdAsync(sqd);
-    }, [currentSQD]);
+    }, [currentSQD, notifySelectedTIDAsync]);
     const onSQDDeleted = useCallback(async (sqd, sqdToBeSet, setSqdAsync) => {
         await loadDataSQDsAsync(true, sqd.masterTID);
         if (sqdToBeSet)
             await setSqdAsync?.(sqdToBeSet);
     }, []);
+    // --- REFRESH DEI PANNELLI ---
+    // Scorciatoie: rilegge dal server l'elenco dei tipi documento, così le scorciatoie riflettono
+    // quelli aggiunti o rimossi. La nuova identità di mruTIDs fa ricaricare i descrittori a TMRecentsManager.
+    const refreshRecentsAsync = useCallback(async () => {
+        DcmtTypeListCacheService.RemoveAllWithoutMetadata();
+        await DcmtTypeListCacheService.GetAllWithoutMetadataAsync();
+        setMruTIDs([...SDKUI_Globals.userSettings.searchSettings.mruTIDs]);
+    }, []);
+    // Ricerche rapide: invalida la cache delle saved query e ricarica l'elenco del tipo documento corrente
+    const refreshSavedQueriesAsync = useCallback(async () => {
+        // loadDataSQDsAsync riporta la selezione sulla prima tab: il refresh non deve spostare quella scelta dall'utente
+        const sqdMode = currentSQDMode;
+        await loadDataSQDsAsync(true, fromDTD?.id ?? currentTID);
+        setCurrentSQDMode(sqdMode);
+    }, [fromDTD?.id, currentTID, currentSQDMode]);
+    // Pannello dei metadati: rilegge dal server i metadati del tipo documento e la definizione della
+    // ricerca rapida corrente, con cui il pannello ricostruisce i filtri (i valori digitati vengono persi)
+    const refreshSearchQueryPanelAsync = useCallback(async () => {
+        const tid = fromDTD?.id ?? currentTID;
+        if (!tid)
+            return;
+        const dtd = await DcmtTypeListCacheService.GetAsync(tid, true, undefined, false, true);
+        setFromDTD(dtd);
+        // Passare da undefined forza la ricostruzione dei filtri anche quando la query selezionata non cambia
+        const sqdToRestore = currentSQD;
+        SavedQueryCacheService.Remove();
+        await setSQDAsync(undefined);
+        // La ricerca di sistema non è in cache: va ricostruita, così recepisce i metadati appena riletti
+        await setSQDAsync(sqdToRestore?.id === SYS_ALL_DCMTS_SQD_ID ? await getSysAllDcmtsSQD(tid, false) : sqdToRestore);
+        // mruTIDs è tra le dipendenze perché setSQDAsync lo legge
+    }, [fromDTD?.id, currentTID, currentSQD, mruTIDs]);
+    // Prima di ogni ricerca il pannello rilegge i metadati del tipo documento: si recepisce il descrittore
+    // aggiornato, così anche il resto della vista (titoli, badge, form dei metadati) lavora sulla lista corrente
+    const handleDcmtTypeReloaded = useCallback((dtd) => {
+        setFromDTD(dtd);
+    }, []);
     const onRefreshSearchAsyncDatagrid = async () => {
         try {
             if (lastQdSearched) {
@@ -194,29 +247,35 @@ const TMSearch = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTask
     const isTabletOrMobile = deviceType === DeviceType.TABLET || deviceType === DeviceType.MOBILE;
     // --- JSX WRAPPERS ---
     const tmTreeSelectorElement = useMemo(() => _jsx(TMTreeSelectorWrapper, { isMobile: isTabletOrMobile, onSelectedTIDChanged: (tid) => {
+            notifySelectedTIDAsync(tid);
             setCurrentTID(tid);
             if (tid && mruTIDs.includes(tid))
                 setCurrentMruTID(tid);
             else
                 setCurrentMruTID(0);
-        } }), [isTabletOrMobile, mruTIDs]);
+        } }), [isTabletOrMobile, mruTIDs, notifySelectedTIDAsync]);
     const tmRecentsManagerElement = useMemo(() => _jsx(TMRecentsManagerWrapper, { mruTIDs: mruTIDs, currentMruTID: currentMruTID, deviceType: deviceType, onSelectedTID: (tid) => {
+            notifySelectedTIDAsync(tid);
             setCurrentMruTID(tid);
             setCurrentTID(tid);
         }, onDeletedTID: (tid) => {
             let newMruTIDS = removeMruTid(SDKUI_Globals.userSettings.searchSettings.mruTIDs, tid);
             SDKUI_Globals.userSettings.searchSettings.mruTIDs = newMruTIDS;
             setMruTIDs(newMruTIDS);
-        } }), [mruTIDs, currentMruTID, deviceType]);
-    const tmSearchQueryPanelElement = useMemo(() => _jsx(TMSearchQueryPanelWrapper, { passToArchiveCallback: passToArchiveCallback, isExpertMode: isExpertMode, showBackToResultButton: searchResult.length > 0, fromDTD: fromDTD, SQD: currentSQD, inputMids: inputMids, maxDcmtsToBeReturned: maxDcmtsToBeReturned, onBackToResult: () => { setCurrentSearchView(TMSearchViews.Result); }, onSearchCompleted: handleSearchCompleted, onSqdSaved: async (newSqd) => {
+        } }), [mruTIDs, currentMruTID, deviceType, notifySelectedTIDAsync]);
+    const tmSearchQueryPanelElement = useMemo(() => _jsx(TMSearchQueryPanelWrapper, { isSearchViewOnScreen: currentSearchView === TMSearchViews.Search, passToArchiveCallback: passToArchiveCallback, isExpertMode: isExpertMode, showBackToResultButton: searchResult.length > 0, fromDTD: fromDTD, SQD: currentSQD, inputMids: inputMids, maxDcmtsToBeReturned: maxDcmtsToBeReturned, onBackToResult: () => { if (onlyShowSearchQueryPanel)
+            setShowSearchResults(true); setCurrentSearchView(TMSearchViews.Result); }, onSearchCompleted: handleSearchCompleted, onRefreshRequested: refreshSearchQueryPanelAsync, onDcmtTypeReloaded: handleDcmtTypeReloaded, onSqdSaved: async (newSqd) => {
             await loadDataSQDsAsync(true, newSqd.masterTID);
             await setSQDAsync(newSqd);
-        } }), [fromDTD, showSearchResults, setShowSearchResults, currentSQD, isExpertMode, mruTIDs, searchResult, passToArchiveCallback, inputMids, maxDcmtsToBeReturned, handleSearchCompleted]);
-    const tmSavedQuerySelectorElement = useMemo(() => _jsxs(TabPanel, { width: "100%", height: "100%", showNavButtons: true, repaintChangesOnly: true, selectedIndex: currentSQDMode, onSelectedIndexChange: (index) => setCurrentSQDMode(index), children: [(currentTID || currentSQD) ? _jsx(Item, { title: fromDTD?.nameLoc, children: _jsx(TMSavedQuerySelectorWrapper, { allowShowSearch: false, items: filteredByTIDSQDs, selectedId: currentSQD?.id, onRefreshData: () => { loadDataSQDsAsync(true); }, onItemClick: (sqd) => {
+        } }), [fromDTD, showSearchResults, setShowSearchResults, currentSQD, currentSearchView, isExpertMode, mruTIDs, searchResult, passToArchiveCallback, inputMids, maxDcmtsToBeReturned, handleSearchCompleted, refreshSearchQueryPanelAsync, handleDcmtTypeReloaded, onlyShowSearchQueryPanel]);
+    // I due tab delle ricerche rapide nell'ordine in cui compaiono: il primo c'e' solo con un tipo
+    // documento o una ricerca rapida correnti. currentSQDMode resta la posizione nell'elenco visibile.
+    const sqdTabIds = useMemo(() => (currentTID || currentSQD) ? ['byTID', 'all'] : ['all'], [currentTID, currentSQD]);
+    const tmSavedQuerySelectorElement = useMemo(() => _jsxs(TMTabControl, { variant: 'module', style: { height: '100%', width: '100%' }, contentStyle: { display: 'flex', flexDirection: 'column', flex: 1, minHeight: 0 }, selectedId: sqdTabIds[currentSQDMode] ?? sqdTabIds[sqdTabIds.length - 1], onSelectedIdChange: (id) => setCurrentSQDMode(sqdTabIds.indexOf(id)), children: [_jsx(TMTabPanel, { id: 'byTID', label: fromDTD?.nameLoc, visible: !!(currentTID || currentSQD), children: _jsx(TMSavedQuerySelectorWrapper, { allowShowSearch: false, items: filteredByTIDSQDs, selectedId: currentSQD?.id, onRefreshData: () => { loadDataSQDsAsync(true); }, onItemClick: (sqd) => {
                         onSQDItemClick(sqd, setSQDAsync);
-                    }, onDeleted: (sqd) => onSQDDeleted(sqd, sqd.id == currentSQD?.id ? filteredByTIDSQDs.find(o => o.id == 1) : currentSQD, setSQDAsync), refreshFavoriteSavedQueries: refreshFavoriteSavedQueries }) }) : _jsx(_Fragment, {}), _jsx(Item, { title: SDKUI_Localizator.AllFemale, children: _jsx(TMSavedQuerySelectorWrapper, { allowShowSearch: true, items: allSQDs, manageDefault: false, onItemClick: (sqd) => {
+                    }, onDeleted: (sqd) => onSQDDeleted(sqd, sqd.id == currentSQD?.id ? filteredByTIDSQDs.find(o => o.id == 1) : currentSQD, setSQDAsync), refreshFavoriteSavedQueries: refreshFavoriteSavedQueries }) }), _jsx(TMTabPanel, { id: 'all', label: SDKUI_Localizator.AllFemale, children: _jsx(TMSavedQuerySelectorWrapper, { allowShowSearch: true, items: allSQDs, manageDefault: false, onItemClick: (sqd) => {
                         onSQDItemClick(sqd, setSQDAsync);
-                    }, onDeleted: (sqd) => onSQDDeleted(sqd, sqd.id == currentSQD?.id ? undefined : currentSQD, setSQDAsync), refreshFavoriteSavedQueries: refreshFavoriteSavedQueries }) })] }), [currentSQDMode, currentTID, currentSQD, fromDTD, filteredByTIDSQDs, allSQDs]);
+                    }, onDeleted: (sqd) => onSQDDeleted(sqd, sqd.id == currentSQD?.id ? undefined : currentSQD, setSQDAsync), refreshFavoriteSavedQueries: refreshFavoriteSavedQueries }) })] }), [currentSQDMode, sqdTabIds, currentTID, currentSQD, fromDTD, filteredByTIDSQDs, allSQDs]);
     // Returns the current panelLayout from user settings, falling back to an empty object if not present.
     const getPanelLayoutSetting = () => {
         return SDKUI_Globals.userSettings.searchSettings.panelLayout ?? {};
@@ -263,7 +322,14 @@ const TMSearch = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTask
         {
             id: 'TMRecentsManager',
             name: SDKUI_Localizator.Shortcuts,
-            contentOptions: { component: tmRecentsManagerElement, panelContainer: { title: SDKUI_Localizator.Shortcuts, totalItems: mruTIDs.length } },
+            contentOptions: {
+                component: tmRecentsManagerElement,
+                panelContainer: {
+                    title: SDKUI_Localizator.Shortcuts,
+                    totalItems: mruTIDs.length,
+                    onRefresh: refreshRecentsAsync
+                }
+            },
             toolbarOptions: { icon: _jsx(IconRecentlyViewed, { fontSize: 24 }), visible: true, orderNumber: 2, isActive: allInitialPanelVisibility['TMRecentsManager'] }
         },
         {
@@ -275,11 +341,70 @@ const TMSearch = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTask
         {
             id: 'TMSavedQuerySelector',
             name: SDK_Localizator.SavedQueries,
-            contentOptions: { component: tmSavedQuerySelectorElement, panelContainer: { title: SDK_Localizator.SavedQueries } },
+            contentOptions: {
+                component: tmSavedQuerySelectorElement,
+                panelContainer: {
+                    title: SDK_Localizator.SavedQueries,
+                    onRefresh: refreshSavedQueriesAsync
+                }
+            },
             toolbarOptions: { icon: _jsx(IconSavedQuery, { fontSize: 24 }), visible: true, orderNumber: 4, isActive: allInitialPanelVisibility['TMSavedQuerySelector'] }
         }
-    ], [tmTreeSelectorElement, showSearchResults, tmRecentsManagerElement, tmSearchQueryPanelElement, tmSavedQuerySelectorElement, fromDTD, mruTIDs]);
-    return (_jsxs(_Fragment, { children: [showSearchResults ? _jsx(StyledMultiViewPanel, { "$isVisible": currentSearchView === TMSearchViews.Search, children: _jsx(TMPanelManagerWithPersistenceProvider, { panels: initialPanels, initialVisibility: allInitialPanelVisibility, defaultDimensions: initialPanelDimensions, initialDimensions: initialPanelDimensions, initialMobilePanelId: 'TMRecentsManager', isPersistenceEnabled: !isMobile ? hasSavedLayout() : false, persistPanelStates: !isMobile ? (state) => persistPanelStates(state) : undefined, persistedPanelStates: getPersistedPanelStates(), children: _jsx(TMPanelManagerContainer, { panels: initialPanels, direction: "horizontal", showToolbar: true, minPanelSizePx: !isMobile ? 250 : 150 }) }) }) : tmSearchQueryPanelElement, showSearchResults && _jsx(TMSearchResult, { isVisible: isVisible && currentSearchView === TMSearchViews.Result, context: SearchResultContext.METADATA_SEARCH, searchResults: searchResult, floatingActionConfig: floatingActionConfig, onRefreshAfterAddDcmtToFavs: onRefreshAfterAddDcmtToFavs, openInOffice: openInOffice, onRefreshSearchAsyncDatagrid: onRefreshSearchAsyncDatagrid, onClose: () => { onlyShowSearchQueryPanel ? setShowSearchResults(false) : setCurrentSearchView(TMSearchViews.Search); }, onFileOpened: onFileOpened, onTaskCreateRequest: onTaskCreateRequest, openWGsCopyMoveForm: openWGsCopyMoveForm, editPdfForm: editPdfForm, onOpenPdfEditorRequest: onOpenPdfEditorRequest, openS4TViewer: openS4TViewer, onOpenS4TViewerRequest: onOpenS4TViewerRequest, openFileUploaderPdfEditor: openFileUploaderPdfEditor, passToArchiveCallback: passToArchiveCallback, onSelectedTIDChanged: onCurrentTIDChangedCallback, showTodoDcmtForm: showTodoDcmtForm, showToppyDraggableHelpCenter: showToppyDraggableHelpCenter, toppyHelpCenterUsePortal: toppyHelpCenterUsePortal, onReferenceClick: onReferenceClick, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers, inputDID: inputDID, formAutoOpen: formAutoOpen, fetchRemoteCertificates: fetchRemoteCertificates, graphometricManager: graphometricManager })] }));
+    ], [tmTreeSelectorElement, showSearchResults, tmRecentsManagerElement, tmSearchQueryPanelElement, tmSavedQuerySelectorElement, fromDTD, mruTIDs, refreshRecentsAsync, refreshSavedQueriesAsync]);
+    // Quando è visibile solo il pannello di ricerca (es. modale di abbinamento molti a molti) serve
+    const singlePanelVisibility = { 'TMSearchQueryPanel': true };
+    const singlePanelDimensions = { 'TMSearchQueryPanel': { width: '100%', height: '100%' } };
+    const singlePanelDefinition = useMemo(() => [
+        {
+            id: 'TMSearchQueryPanel',
+            name: fromDTD?.nameLoc ?? SDKUI_Localizator.Search_Metadata,
+            contentOptions: { component: tmSearchQueryPanelElement },
+            toolbarOptions: { icon: _jsx(IconFilter, { fontSize: 24 }), visible: false, orderNumber: 1, isActive: true }
+        }
+    ], [tmSearchQueryPanelElement, fromDTD]);
+    return (_jsxs(_Fragment, { children: [onlyShowSearchQueryPanel
+                // Il pannello di ricerca resta montato anche quando sono a schermo i risultati: tornando
+                // indietro si ritrova l'ultima ricerca impostata, senza rimontaggi che ne resettano i filtri
+                ? _jsx(StyledMultiViewPanel, { $isVisible: !showSearchResults, children: _jsx(TMPanelManagerProvider, { panels: singlePanelDefinition, initialVisibility: singlePanelVisibility, defaultDimensions: singlePanelDimensions, initialDimensions: singlePanelDimensions, initialMobilePanelId: 'TMSearchQueryPanel', children: tmSearchQueryPanelElement }) })
+                : _jsx(StyledMultiViewPanel, { $isVisible: currentSearchView === TMSearchViews.Search, children: _jsx(TMPanelManagerWithPersistenceProvider, { panels: initialPanels, initialVisibility: allInitialPanelVisibility, defaultDimensions: initialPanelDimensions, initialDimensions: initialPanelDimensions, initialMobilePanelId: 'TMRecentsManager', isPersistenceEnabled: !isMobile ? hasSavedLayout() : false, persistPanelStates: !isMobile ? (state) => persistPanelStates(state) : undefined, persistedPanelStates: getPersistedPanelStates(), children: _jsx(TMPanelManagerContainer, { panels: initialPanels, direction: "horizontal", showToolbar: true, minPanelSizePx: !isMobile ? 250 : 150 }) }) }), showSearchResults && _jsx(TMSearchResult, { isVisible: isVisible && currentSearchView === TMSearchViews.Result, context: SearchResultContext.METADATA_SEARCH, searchResults: searchResult, floatingActionConfig: floatingActionConfig, onRefreshAfterAddDcmtToFavs: onRefreshAfterAddDcmtToFavs, openInOffice: openInOffice, onRefreshSearchAsyncDatagrid: onRefreshSearchAsyncDatagrid, onClose: () => { if (onlyShowSearchQueryPanel)
+                    setShowSearchResults(false); setCurrentSearchView(TMSearchViews.Search); }, backCaption: onlyShowSearchQueryPanel ? SDKUI_Localizator.BackToSearch : undefined, onFileOpened: onFileOpened, onTaskCreateRequest: onTaskCreateRequest, openWGsCopyMoveForm: openWGsCopyMoveForm, editPdfForm: editPdfForm, onOpenPdfEditorRequest: onOpenPdfEditorRequest, openS4TViewer: openS4TViewer, onOpenS4TViewerRequest: onOpenS4TViewerRequest, openFileUploaderPdfEditor: openFileUploaderPdfEditor, passToArchiveCallback: passToArchiveCallback, onSelectedTIDChanged: onCurrentTIDChangedCallback, showTodoDcmtForm: showTodoDcmtForm, showToppyDraggableHelpCenter: showToppyDraggableHelpCenter, toppyHelpCenterUsePortal: toppyHelpCenterUsePortal, onReferenceClick: onReferenceClick, allTasks: allTasks, getAllTasks: getAllTasks, deleteTaskByIdsCallback: deleteTaskByIdsCallback, addTaskCallback: addTaskCallback, editTaskCallback: editTaskCallback, handleNavigateToWGs: handleNavigateToWGs, handleNavigateToDossiers: handleNavigateToDossiers, inputDID: inputDID, formAutoOpen: formAutoOpen, fetchRemoteCertificates: fetchRemoteCertificates, graphometricManager: graphometricManager })] }));
+};
+const ENABLE_SEARCH_TABS = false;
+// Ogni tab e' un TMSearch completo e indipendente: TMTabControl li tiene tutti montati, cosi piu ricerche
+// restano vive insieme, ognuna con i suoi tipi documento, i suoi filtri e i suoi risultati.
+const TMSearch = (props) => {
+    const { isVisible, inputTID, inputSqdID, inputDID, onlyShowSearchQueryPanel, onCurrentTIDChangedCallback } = props;
+    const tabs = useTMTabs({ label: SDKUI_Localizator.Search });
+    // Tab attivo leggibile senza rilanciare l'effetto qui sotto a ogni cambio tab
+    const activeIdRef = useRef(tabs.activeId);
+    activeIdRef.current = tabs.activeId;
+    // Titoli correnti leggibili dalla callback senza rigenerarla a ogni rinomina
+    const itemsRef = useRef(tabs.items);
+    itemsRef.current = tabs.items;
+    // Il titolo del tab e' il nome appena selezionato; se un altro tab ha gia' quel titolo si numera
+    // tra parentesi a partire da 2: NomeTipoDocumento, NomeTipoDocumento (2), NomeTipoDocumento (3)...
+    const setTabTitle = useCallback((id, name) => {
+        const used = new Set(itemsRef.current.filter(t => t.id !== id).map(t => t.label));
+        let label = name;
+        for (let i = 2; used.has(label); i++)
+            label = `${name} (${i})`;
+        tabs.rename(id, label);
+    }, [tabs.rename]);
+    // Una richiesta dall'esterno (tipo documento, ricerca rapida, documento) riguarda il tab a video in
+    // quel momento: gli altri restano sulla ricerca che stanno svolgendo.
+    const [inputsTabId, setInputsTabId] = useState(tabs.activeId);
+    useEffect(() => { setInputsTabId(activeIdRef.current); }, [inputTID, inputSqdID, inputDID]);
+    // Nella modalita a solo pannello di ricerca (es. abbinamento molti a molti) i tab non servono,
+    // cosi come non servono finche' i tab non vengono rilasciati
+    if (!ENABLE_SEARCH_TABS || onlyShowSearchQueryPanel)
+        return _jsx(TMSearchInstance, { ...props });
+    return (_jsx(TMTabControl, { ...tabs.controlProps, contentAnimation: 'none', onTabRename: undefined, variant: 'module', style: { height: '100%', width: '100%' }, contentStyle: { display: 'flex', flex: 1, minHeight: 0, position: 'relative' }, children: tabs.items.map(t => {
+            const isActiveTab = t.id === tabs.activeId;
+            const hasInputs = t.id === inputsTabId;
+            return (_jsx(TMTabPanel, { id: t.id, label: t.label, children: _jsx(TMSearchInstance, { ...props, isVisible: isVisible && isActiveTab, inputTID: hasInputs ? inputTID : undefined, inputSqdID: hasInputs ? inputSqdID : undefined, inputDID: hasInputs ? inputDID : undefined, 
+                    // Il tipo documento corrente lo comunica solo il tab a video
+                    onCurrentTIDChangedCallback: isActiveTab ? onCurrentTIDChangedCallback : undefined, onSelectedNameChanged: (name) => setTabTitle(t.id, name) }) }, t.id));
+        }) }));
 };
 export default TMSearch;
 const TMTreeSelectorWrapper = ({ isMobile, onSelectedTIDChanged }) => {
@@ -298,11 +423,11 @@ const TMRecentsManagerWrapper = ({ mruTIDs, currentMruTID, deviceType, onSelecte
             onDeletedTID?.(tid);
         } }));
 };
-const TMSearchQueryPanelWrapper = ({ fromDTD, SQD, isExpertMode, showBackToResultButton, onSearchCompleted, onSqdSaved, onBackToResult, passToArchiveCallback, inputMids, maxDcmtsToBeReturned }) => {
+const TMSearchQueryPanelWrapper = ({ isSearchViewOnScreen, fromDTD, SQD, isExpertMode, showBackToResultButton, onSearchCompleted, onSqdSaved, onBackToResult, passToArchiveCallback, inputMids, maxDcmtsToBeReturned, onRefreshRequested, onDcmtTypeReloaded }) => {
     const { setPanelVisibilityById, toggleMaximize, countVisibleLeafPanels } = useTMPanelManagerContext();
     const deviceType = useDeviceType();
     const isMobile = deviceType === DeviceType.MOBILE;
-    return (_jsx(TMSearchQueryPanel, { onClosePanel: (!isMobile && countVisibleLeafPanels() > 1) ? () => setPanelVisibilityById('TMSearchQueryPanel', false) : undefined, allowMaximize: !isMobile && countVisibleLeafPanels() > 1, onMaximizePanel: (!isMobile && countVisibleLeafPanels() > 1) ? () => toggleMaximize("TMSearchQueryPanel") : undefined, isExpertMode: isExpertMode, fromDTD: fromDTD, SQD: SQD, inputMids: inputMids, onSearchCompleted: onSearchCompleted, onSqdSaved: onSqdSaved, showBackToResultButton: showBackToResultButton, onBackToResult: onBackToResult, passToArchiveCallback: passToArchiveCallback, maxDcmtsToBeReturned: maxDcmtsToBeReturned }));
+    return (_jsx(TMSearchQueryPanel, { isSearchViewOnScreen: isSearchViewOnScreen, onClosePanel: (!isMobile && countVisibleLeafPanels() > 1) ? () => setPanelVisibilityById('TMSearchQueryPanel', false) : undefined, allowMaximize: !isMobile && countVisibleLeafPanels() > 1, onMaximizePanel: (!isMobile && countVisibleLeafPanels() > 1) ? () => toggleMaximize("TMSearchQueryPanel") : undefined, isExpertMode: isExpertMode, fromDTD: fromDTD, SQD: SQD, inputMids: inputMids, onSearchCompleted: onSearchCompleted, onRefreshRequested: onRefreshRequested, onDcmtTypeReloaded: onDcmtTypeReloaded, onSqdSaved: onSqdSaved, showBackToResultButton: showBackToResultButton, onBackToResult: onBackToResult, passToArchiveCallback: passToArchiveCallback, maxDcmtsToBeReturned: maxDcmtsToBeReturned }));
 };
 const TMSavedQuerySelectorWrapper = ({ items, selectedId, allowShowSearch, manageDefault, onRefreshData, onItemClick, onDeleted, refreshFavoriteSavedQueries }) => {
     const { setPanelVisibilityById } = useTMPanelManagerContext();

package/lib/components/features/search/TMSearchQueryEditor.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { LayoutModes, DcmtTypeListCacheService, PlatformObjectValidator, MetadataDataTypes, QueryOperators, DataListCacheService, MetadataDataDomains, SDK_Localizator, UserListCacheService } from '@topconsultnpm/sdk-ts';
 import styled from 'styled-components';
@@ -58,10 +58,12 @@ const TMSearchQueryEditor = ({ qd, dcmtTypesList = [], isExpertMode = SDKUI_Glob
     const handleItemSelect = useCallback((tid, mid) => {
         if (currentEditingMID !== mid)
             setCurrentEditingMID(mid);
-        if (!focusedTidMid || mid !== focusedTidMid.mid) {
-            setFocusedTidMid({ tid: tid, mid: mid });
+        if (!focusedTidMid || mid !== focusedTidMid.mid || tid !== focusedTidMid.tid) {
+            const newFocusedTidMid = { tid: tid, mid: mid };
+            setFocusedTidMid(newFocusedTidMid);
+            onFocusedMetadataChanged?.(newFocusedTidMid);
         }
-    }, [currentEditingMID, focusedTidMid]);
+    }, [currentEditingMID, focusedTidMid, onFocusedMetadataChanged]);
     const handleAdvancedMenuClick = useCallback((e) => {
         if (e.button === AdvancedMenuButtons.MakeEditable && e.mid) {
             addOrRemoveEditableList(e.mid);
@@ -373,7 +375,7 @@ const WhereItemRow = React.memo(({ whereItem, index, dcmtTypesList, isExpertMode
     };
     // --- Rendering ---
     if (isCompactView) {
-        return (_jsx(StyledMetadataListItem, { id: `wi-item-${whereItem.mid}`, onClick: () => onItemSelect(whereItem.tid, whereItem.mid), onFocus: () => onItemSelect(whereItem.tid, whereItem.mid), "$backgroundColor": !PlatformObjectValidator.WhereItemHasValues(whereItem) ? `${TMColors.primary}66` : 'rgba(236, 202, 156, 1)', "$hoverColor": !PlatformObjectValidator.WhereItemHasValues(whereItem) ? `${TMColors.primary}33` : 'rgba(236, 202, 156, .5)', children: _jsx(TMSearchWhereItemCard, { isSelected: isSelected, index: index, whereItem: whereItem, showEditor: currentEditingMID === whereItem.mid, isEditableList: isEditable, queryParamsDynDataList: queryParamsDynDataList, onWhereItemChange: onItemChange, onHideEditor: onHideMobileEditor, onCascadeRefreshDynDataLists: onCascadeRefreshDynDataLists, onCascadeUpdateMIDs: onCascadeUpdateMIDs, updateIsModalOpen: updateIsModalOpen }) }));
+        return (_jsx(StyledMetadataListItem, { id: `wi-item-${whereItem.mid}`, onClick: () => onItemSelect(whereItem.tid, whereItem.mid), onFocus: () => onItemSelect(whereItem.tid, whereItem.mid), $backgroundColor: !PlatformObjectValidator.WhereItemHasValues(whereItem) ? `${TMColors.primary}66` : 'rgba(236, 202, 156, 1)', $hoverColor: !PlatformObjectValidator.WhereItemHasValues(whereItem) ? `${TMColors.primary}33` : 'rgba(236, 202, 156, .5)', children: _jsx(TMSearchWhereItemCard, { isSelected: isSelected, index: index, whereItem: whereItem, showEditor: currentEditingMID === whereItem.mid, isEditableList: isEditable, queryParamsDynDataList: queryParamsDynDataList, onWhereItemChange: onItemChange, onHideEditor: onHideMobileEditor, onCascadeRefreshDynDataLists: onCascadeRefreshDynDataLists, onCascadeUpdateMIDs: onCascadeUpdateMIDs, updateIsModalOpen: updateIsModalOpen }) }));
     }
     return (_jsxs(React.Fragment, { children: [_jsx("div", { id: `wi-item-${whereItem.mid}`, style: { gridColumn: 1 }, children: _jsx(TMMidViewer, { color: TMColors.primaryColor, isMetadataSelected: isSelected, showIcon: true, tid_mid: { tid: whereItem?.tid, mid: whereItem?.mid, aliasTID: whereItem?.alias } }) }), _jsx("div", { style: { gridColumn: 2, paddingLeft: '5px', paddingRight: '5px' }, children: _jsx(TMDropDownMenu, { backgroundColor: colorOperator, color: getOperatorColor(), items: queryOperatorsItems, content: _jsx(StyledItemWrapper, { children: LocalizeQueryOperators(whereItem.operator) }) }) }), _jsxs("div", { style: { gridColumn: 3, position: 'relative' }, onClick: () => onItemSelect(whereItem.tid, whereItem.mid), onFocus: () => onItemSelect(whereItem.tid, whereItem.mid), children: [_jsx(TMSearchWhereItemEditor, { isSelected: isSelected, openChooserBySingleClick: !isSelected, whereItem: whereItem, index: index, isEditableList: isEditable, queryParamsDynDataList: queryParamsDynDataList, onValueChanged: (values) => {
                             onItemChange({ ...whereItem, value1: values[0], value2: values[1] });

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

@@ -1,6 +1,7 @@
 import React from 'react';
 import { DcmtTypeDescriptor, QueryDescriptor, SavedQueryDescriptor, SearchResultDescriptor } from '@topconsultnpm/sdk-ts';
 interface ITMSearchQueryPanelProps {
+    isSearchViewOnScreen?: boolean;
     fromDTD?: DcmtTypeDescriptor;
     SQD?: SavedQueryDescriptor;
     isExpertMode?: boolean;
@@ -21,6 +22,9 @@ interface ITMSearchQueryPanelProps {
         value: string;
     }>, tid?: number) => void;
     maxDcmtsToBeReturned?: number;
+    onRefreshRequested?: () => Promise<void>;
+    /** Notifica il tipo documento riletto dal server prima di ogni ricerca, così il chiamante allinea il proprio descrittore */
+    onDcmtTypeReloaded?: (dtd: DcmtTypeDescriptor) => void;
 }
 declare const TMSearchQueryPanel: React.FunctionComponent<ITMSearchQueryPanelProps>;
 export default TMSearchQueryPanel;

package/lib/components/features/search/TMSearchQueryPanel.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { PlatformObjectValidator, QueryDescriptor, WhereItem, SDK_Localizator, SelectItemVisibilities, SDK_Globals, SavedQueryCacheService, SearchEngine, QueryOperators, AccessLevelsEx, AccessLevels } from '@topconsultnpm/sdk-ts';
 import styled from 'styled-components';
@@ -24,11 +24,9 @@ import TMToppyMessage from '../../../helper/TMToppyMessage';
 import TMMetadataSorterForm from './TMMetadataSorterForm';
 import TMMetadataOutputForm from './TMMetadataOutputForm';
 import TMTooltip from '../../base/TMTooltip';
-const TMSearchQueryPanel = ({ fromDTD, showBackToResultButton, isExpertMode = SDKUI_Globals.userSettings.advancedSettings.expertMode === 1, SQD, inputMids, onSearchCompleted, onSqdSaved, onBack, onClosePanel, allowMaximize = true, onMaximizePanel, onBackToResult, passToArchiveCallback, maxDcmtsToBeReturned }) => {
+const TMSearchQueryPanel = ({ isSearchViewOnScreen = true, fromDTD, showBackToResultButton, isExpertMode = SDKUI_Globals.userSettings.advancedSettings.expertMode === 1, SQD, inputMids, onSearchCompleted, onSqdSaved, onBack, onClosePanel, allowMaximize = true, onMaximizePanel, onBackToResult, passToArchiveCallback, maxDcmtsToBeReturned, onRefreshRequested, onDcmtTypeReloaded }) => {
     const [confirmQueryParams, ConfirmQueryParamsDialog] = useQueryParametersDialog();
     const [qd, setQd] = useState();
-    const [shouldSearch, setShouldSearch] = useState(false);
-    const [isQueryPanelActive, setIsQueryPanelActive] = useState(false);
     const [lastQdParams, setLastQdParams] = useState([]);
     const [dcmtTypesList, setDcmtTypesList] = useState([]);
     const [showSqdForm, setShowSqdForm] = useState(false);
@@ -44,10 +42,32 @@ const TMSearchQueryPanel = ({ fromDTD, showBackToResultButton, isExpertMode = SD
     const deviceType = useDeviceType();
     const isMobile = deviceType === DeviceType.MOBILE;
     let initialMaxItems = deviceType === DeviceType.MOBILE ? 8 : 12;
+    const tmPanelRef = useRef(null);
+    // Contenitore del form: l'Invio avvia la ricerca solo se il focus si trova al suo interno
+    const contentRef = useRef(null);
+    // Passando nella vista risultati si prenota il focus, che verrà ripreso al rientro nella ricerca
+    const shouldRefocusOnReturnRef = useRef(false);
     const appliedInputMidsRef = useRef(null);
     const pendingMidsRef = useRef(null);
-    // Flag "accoda": impostato dall'azione secondaria del bottone Ricerca, consumato in executeSearch
-    const appendNextSearchRef = useRef(false);
+    // Impedisce ricerche sovrapposte (doppio Invio, o Invio mentre la precedente e' ancora in corso)
+    const isSearchingRef = useRef(false);
+    // Snapshot letti da runSearch al momento dell'esecuzione: evitano di cercare con dati stantii
+    const qdRef = useRef(undefined);
+    const showAdvancedSearchRef = useRef(false);
+    const searchAsyncRef = useRef();
+    const reloadMetadataAsyncRef = useRef();
+    // Tornando dalla vista risultati il pannello dei metadati di ricerca riprende il focus,
+    // così è lui quello evidenziato: prendendo il focus gli altri pannelli ricevono l'onBlur e si disattivano
+    useEffect(() => {
+        if (!isSearchViewOnScreen) {
+            shouldRefocusOnReturnRef.current = true;
+            return;
+        }
+        if (!shouldRefocusOnReturnRef.current)
+            return;
+        shouldRefocusOnReturnRef.current = false;
+        tmPanelRef.current?.focusPanel();
+    }, [isSearchViewOnScreen]);
     useEffect(() => {
         if (!SQD)
             return;
@@ -120,39 +140,6 @@ const TMSearchQueryPanel = ({ fromDTD, showBackToResultButton, isExpertMode = SD
         setQd({ ...qd, where: newWhere });
         setShowAllMdWhere(true);
     }, [qd, fromDTD, inputMids]);
-    // Eseguire la ricerca quando shouldSearch è true e qd è definito
-    useEffect(() => {
-        if (shouldSearch && qd) {
-            const executeSearch = async () => {
-                // Legge e consuma il flag "accoda" impostato dall'azione secondaria del bottone Ricerca
-                const append = appendNextSearchRef.current;
-                appendNextSearchRef.current = false;
-                await searchAsync(qd, showAdvancedSearch, append);
-                setShouldSearch(false); // Resetta il trigger dopo la ricerca
-            };
-            executeSearch();
-        }
-    }, [shouldSearch, qd, showAdvancedSearch]);
-    // Se il pannello è attivo e non ci sono modali aperti, rimuove il focus e avvia la ricerca
-    useEffect(() => {
-        const handleKeyDown = (e) => {
-            if (isQueryPanelActive && !modalIsOpen) {
-                if (e.key === 'Enter') {
-                    e.preventDefault();
-                    // Disattiva l'elemento attivo per forzare l'onBlur
-                    if (document.activeElement instanceof HTMLElement) {
-                        document.activeElement.blur();
-                    }
-                    // Attiva il flag di ricerca. L'useEffect sopra gestirà l'attesa di qd.
-                    setShouldSearch(true);
-                }
-            }
-        };
-        window.addEventListener('keydown', handleKeyDown);
-        return () => {
-            window.removeEventListener('keydown', handleKeyDown);
-        };
-    }, [isQueryPanelActive, modalIsOpen]);
     const setDataAsync = async (sqd) => {
         let newSqd = (sqd?.id == 1) ? sqd : await SavedQueryCacheService.GetAsync(sqd?.id);
         let newQd = SearchEngine.NormalizeQueryDescriptor(newSqd?.qd);
@@ -184,11 +171,92 @@ const TMSearchQueryPanel = ({ fromDTD, showBackToResultButton, isExpertMode = SD
             let results = [];
             if (searchResult?.result)
                 results.push(searchResult?.result);
-            // Before notifying onSearchComplete, let's set the panel to NOT active
-            setIsQueryPanelActive(false);
             onSearchCompleted?.(results, searchResult?.qd, append);
         }
     };
+    // Tra l'apertura della ricerca e il click su Ricerca la lista dei metadati del tipo documento può essere
+    // cambiata (metadati aggiunti o rimossi lato amministrazione): prima di cercare si rileggono dal server.
+    // I valori digitati restano, mentre i filtri sui metadati non più disponibili vengono scartati.
+    // Restituisce il qd con cui eseguire la ricerca.
+    const reloadMetadataAsync = async (qdInput) => {
+        if (!qdInput?.from?.tid)
+            return qdInput;
+        let dcmtTypes;
+        try {
+            TMSpinner.show({ description: `${SDKUI_Localizator.Loading} ...`, backgroundColor: 'transparent' });
+            dcmtTypes = await getDcmtTypesByQdAsync(qdInput, true);
+        }
+        finally {
+            TMSpinner.hide();
+        }
+        // Rilettura non riuscita: si cerca con i metadati che si hanno, senza scartare nulla
+        if (dcmtTypes.length <= 0)
+            return qdInput;
+        setDcmtTypesList(dcmtTypes);
+        const reloadedFromDTD = dcmtTypes.find(o => o.id === qdInput.from?.tid);
+        if (reloadedFromDTD)
+            onDcmtTypeReloaded?.(reloadedFromDTD);
+        const { qd: newQd, removedCount } = dropUnavailableMetadataFromQd(qdInput, dcmtTypes);
+        if (removedCount <= 0)
+            return qdInput;
+        setQd(newQd);
+        return newQd;
+    };
+    // Allineati a ogni render: runSearch li legge quando esegue, non quando viene creata
+    qdRef.current = qd;
+    showAdvancedSearchRef.current = showAdvancedSearch;
+    searchAsyncRef.current = searchAsync;
+    reloadMetadataAsyncRef.current = reloadMetadataAsync;
+    // Unico punto di avvio della ricerca: bottone Ricerca, Ricerca e accoda e tasto Invio passano tutti da qui
+    const runSearch = useCallback((append) => {
+        if (isSearchingRef.current)
+            return;
+        isSearchingRef.current = true;
+        // Toglie il focus per far committare il valore del campo in editing
+        if (document.activeElement instanceof HTMLElement)
+            document.activeElement.blur();
+        // Alcuni editor committano il valore in modo asincrono: si attende un tick prima di leggere il qd definitivo
+        setTimeout(async () => {
+            try {
+                // I metadati si rileggono a ogni ricerca: si cerca sempre sulla lista aggiornata
+                const qdToSearch = await reloadMetadataAsyncRef.current?.(qdRef.current) ?? qdRef.current;
+                await searchAsyncRef.current?.(qdToSearch, showAdvancedSearchRef.current, append);
+            }
+            catch (ex) {
+                TMExceptionBoxManager.show({ exception: ex });
+            }
+            finally {
+                isSearchingRef.current = false;
+            }
+        }, 0);
+    }, []);
+    // I dialoghi (TMModal/chooser) escono da contentRef perche' DevExtreme Popup li rende in un portale su document.body:
+    // il controllo di contenimento li esclude gia'. Questi flag coprono il caso in cui il focus sia sul contenitore del pannello.
+    // NB: si usano solo flag locali affidabili, non modalIsOpen, che resterebbe a true se un chooser venisse smontato senza onClose.
+    const isAnyDialogOpen = showFiltersConfig || showOutputConfig || showMetadataSorterForm || showSqdForm || showDistinctValuesPanel;
+    // L'Invio avvia SEMPRE la ricerca quando il focus e' nel form di ricerca (o sul pannello che lo contiene).
+    // Il criterio e' il contenimento nel DOM, non uno stato di "pannello attivo" che puo' desincronizzarsi.
+    useEffect(() => {
+        const handleKeyDown = (e) => {
+            if (e.key !== 'Enter' || e.repeat)
+                return;
+            if (isAnyDialogOpen)
+                return;
+            const content = contentRef.current;
+            const target = e.target;
+            if (!content || !target)
+                return;
+            const isInsideForm = content.contains(target);
+            // Al rientro dai risultati il focus e' sul contenitore del pannello, che e' antenato del form
+            const isPanelContainer = target !== document.body && target !== document.documentElement && target.contains(content);
+            if (!isInsideForm && !isPanelContainer)
+                return;
+            e.preventDefault();
+            runSearch(false);
+        };
+        window.addEventListener('keydown', handleKeyDown);
+        return () => { window.removeEventListener('keydown', handleKeyDown); };
+    }, [isAnyDialogOpen, runSearch]);
     const updateIsModalOpen = useCallback((isOpen) => {
         setModalIsOpen(isOpen);
     }, []);
@@ -215,36 +283,15 @@ const TMSearchQueryPanel = ({ fromDTD, showBackToResultButton, isExpertMode = SD
             }
         }
     };
-    const handleSearchButtonClick = useCallback(async () => {
-        // Propagazione blur
-        if (document.activeElement instanceof HTMLElement) {
-            document.activeElement.blur();
-        }
-        // Ricerca normale: azzera l'eventuale flag accoda e avvia
-        appendNextSearchRef.current = false;
-        setShouldSearch(true);
-    }, []);
-    const handleSearchAndAppendClick = useCallback(() => {
-        // Propagazione blur
-        if (document.activeElement instanceof HTMLElement) {
-            document.activeElement.blur();
-        }
-        // Ricerca e accoda: imposta il flag consumato da executeSearch
-        appendNextSearchRef.current = true;
-        setShouldSearch(true);
-    }, []);
+    const handleSearchButtonClick = useCallback(() => { runSearch(false); }, [runSearch]);
+    const handleSearchAndAppendClick = useCallback(() => { runSearch(true); }, [runSearch]);
     const searchButtonSecondaryActions = useMemo(() => [{
             name: SDKUI_Localizator.SearchAndAppend,
             icon: _jsx(IconSearch, {}),
             onClick: handleSearchAndAppendClick
         }], [handleSearchAndAppendClick]);
     const handleQdChanged = useCallback((newQd) => {
-        if (!deepCompare(qd, newQd)) {
-            setQd(newQd);
-        }
-    }, []);
-    const handlePanelActiveChanged = useCallback((isActive) => {
-        setIsQueryPanelActive(isActive);
+        setQd(prev => deepCompare(prev, newQd) ? prev : newQd);
     }, []);
     const handleAdvancedMenuClick = useCallback((e) => {
         if (e.button === AdvancedMenuButtons.DistinctValues) {
@@ -342,10 +389,10 @@ const TMSearchQueryPanel = ({ fromDTD, showBackToResultButton, isExpertMode = SD
             return false;
         return qd?.orderBy && qd.orderBy.length > 0;
     }, [showAdvancedSearch, qd?.orderBy]);
-    return (_jsxs(_Fragment, { children: [_jsxs(TMPanel, { title: fromDTD?.nameLoc ?? SDKUI_Localizator.Search_Metadata, allowMaximize: allowMaximize, onMaximize: onMaximizePanel, onHeaderDoubleClick: onMaximizePanel, onBack: onBack, onActiveChanged: handlePanelActiveChanged, toolbar: _jsx(_Fragment, { children: (SQD && !showSqdForm) ?
-                        _jsx(ContextMenu, { items: contextMenuItems, trigger: "left", children: _jsx(TMButton, { btnStyle: 'icon', caption: 'Altro', icon: _jsx(IconMenuVertical, { color: 'white' }), showTooltip: false, onClick: () => setIsQueryPanelActive(true) }) })
+    return (_jsxs(_Fragment, { children: [_jsxs(TMPanel, { ref: tmPanelRef, title: fromDTD?.nameLoc ?? SDKUI_Localizator.Search_Metadata, allowMaximize: allowMaximize, onMaximize: onMaximizePanel, onHeaderDoubleClick: onMaximizePanel, onBack: onBack, onRefresh: (!SQD || showSqdForm) ? undefined : onRefreshRequested, toolbar: _jsx(_Fragment, { children: (SQD && !showSqdForm) ?
+                        _jsx(ContextMenu, { items: contextMenuItems, trigger: "left", children: _jsx(TMButton, { btnStyle: 'icon', caption: 'Altro', icon: _jsx(IconMenuVertical, { color: 'white' }), showTooltip: false }) })
                         : _jsx(_Fragment, {}) }), children: [_jsx(ConfirmQueryParamsDialog, {}), SQD
-                        ? _jsxs("div", { onContextMenu: (e) => e.preventDefault(), style: { height: '100%', width: '100%', position: 'relative', display: showSqdForm ? 'none' : 'flex', flexDirection: 'column', gap: 5 }, children: [showAdvancedSearch
+                        ? _jsxs("div", { ref: contentRef, onContextMenu: (e) => e.preventDefault(), style: { height: '100%', width: '100%', position: 'relative', display: showSqdForm ? 'none' : 'flex', flexDirection: 'column', gap: 5 }, children: [showAdvancedSearch
                                     ? _jsx(TMQueryEditor, { formMode: FormModes.Update, showToolbar: false, inputData: qd, validateSelect: true, showApply: false, onQDChanged: handleQdChanged, updateIsModalOpen: updateIsModalOpen })
                                     : _jsx(TMSearchQueryEditor, { qd: qd, dcmtTypesList: dcmtTypesList, isExpertMode: isExpertMode, showAllMdWhere: showAllMdWhere, onQdChanged: handleQdChanged, onFocusedMetadataChanged: setFocusedTidMid, onAdvancedMenuClick: handleAdvancedMenuClick, updateIsModalOpen: updateIsModalOpen }), shouldShowOutputBadges && qd?.select && qd.select.length > 0 && (_jsxs(StyledSelectBadgesContainer, { children: [_jsxs(StyledSelectLabel, { children: [SDK_Localizator.QuerySelect, ":"] }), _jsx(StyledSelectBadgesWrapper, { children: (() => {
                                                 const selectItems = qd.select ?? [];
@@ -403,6 +450,33 @@ const TMSearchQueryPanel = ({ fromDTD, showBackToResultButton, isExpertMode = SD
                     } })] }));
 };
 export default TMSearchQueryPanel;
+/** Scarta dal qd filtri, colonne e ordinamenti sui metadati non più esistenti o non più accessibili, in base
+ *  alla lista dei metadati appena riletta dal server. I valori digitati su quelli ancora presenti si mantengono. */
+const dropUnavailableMetadataFromQd = (qdInput, dcmtTypes) => {
+    const metadataOf = (tid) => dcmtTypes.find(o => o.id === tid)?.metadata;
+    // Un tipo documento non riletto non è verificabile: i suoi item si mantengono così come sono.
+    // Sui metadati di sistema si verifica solo l'esistenza: i loro permessi non li rendono inutilizzabili.
+    const isStillAvailable = (tid, mid, isUsable) => {
+        const metadata = metadataOf(tid);
+        if (!metadata || metadata.length <= 0 || mid == undefined)
+            return true;
+        const md = metadata.find(o => o.id === mid);
+        if (!md)
+            return false;
+        return md.isSystem == 1 || isUsable(md);
+    };
+    const canSearch = (md) => md.perm?.canSearch != AccessLevels.No;
+    const canOutput = (md) => !(md.perm?.canView == AccessLevels.No && md.perm?.canUpdate == AccessLevels.No);
+    const where = qdInput.where?.filter(o => isStillAvailable(o.tid, o.mid, canSearch)) ?? [];
+    const select = qdInput.select?.filter(o => isStillAvailable(o.tid, o.mid, canOutput)) ?? [];
+    const orderBy = qdInput.orderBy?.filter(o => isStillAvailable(o.tid, o.mid, canOutput)) ?? [];
+    const removedCount = ((qdInput.where?.length ?? 0) - where.length)
+        + ((qdInput.select?.length ?? 0) - select.length)
+        + ((qdInput.orderBy?.length ?? 0) - orderBy.length);
+    let qd = new QueryDescriptor();
+    qd.init({ ...qdInput, where: where, select: select, orderBy: orderBy });
+    return { qd: qd, removedCount: removedCount };
+};
 const searchByQdAsync = async (qdInput, searchParams) => {
     let result;
     let qdSearch;