@topconsultnpm/sdkui-react 6.22.0-t1 → 6.22.0-t3

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

@@ -56,4 +56,4 @@ export declare const getDcmtInfosToDownload: (selectedDcmtInfos: Array<DcmtInfo>
  * - i default della classe
  * Nota: destinationFolder e zipPassword vengono sempre resettati per sicurezza.
  */
-export declare const buildInitialDownloadSettings: (saved: DocumentDownloadSettings | undefined, defaultInvoiceFormat: DocumentDownloadSettings["invoiceFormat"], defaultOrderFormat: DocumentDownloadSettings["orderFormat"]) => DocumentDownloadSettings;
+export declare const buildInitialDownloadSettings: (saved: DocumentDownloadSettings | undefined, defaultInvoiceFormat: DocumentDownloadSettings['invoiceFormat'], defaultOrderFormat: DocumentDownloadSettings['orderFormat']) => DocumentDownloadSettings;

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

@@ -0,0 +1,32 @@
+import type { RelationTreeItem } from './TMRelationViewer';
+/**
+ * Conserva lo stato di un albero delle correlazioni (nodi espansi e fuoco) attraverso
+ * un refresh che ricarica i dati da zero. I nodi non sono confrontabili per `key`, che
+ * contiene un GUID rigenerato ad ogni caricamento: si usa un percorso costruito sui campi.
+ */
+export interface RelationTreeState {
+    /** Documenti di input a cui lo stato si riferisce: non va applicato ad altri */
+    inputKey: string;
+    expandedPaths: string[];
+    /**
+     * Documenti espansi che avevano già i figli caricati. Quelli espansi ma vuoti
+     * (es. il root) non vanno ricaricati: mostrerebbero più di quanto c'era prima.
+     */
+    loadedPaths: string[];
+    focusedPath?: string;
+}
+/** Carica i figli di un documento durante il ripristino. */
+export type LoadChildrenFn = (node: RelationTreeItem) => Promise<RelationTreeItem[]>;
+/**
+ * Fotografa lo stato dell'albero.
+ * `previousFocusedPath` viene usato quando il fuoco è già stato azzerato dall'esterno.
+ */
+export declare const collectRelationTreeState: (nodes: RelationTreeItem[], inputKey: string, focusedKey: string | undefined, previousFocusedPath?: string) => RelationTreeState;
+/**
+ * Riapplica lo stato all'albero appena caricato. I nodi che non compaiono nello stato,
+ * o che non esistono più (es. documento cancellato), restano chiusi: il confronto per
+ * percorso è tollerante per costruzione.
+ */
+export declare const applyRelationTreeState: (nodes: RelationTreeItem[], state: RelationTreeState, loadChildren: LoadChildrenFn, isAborted: () => boolean) => Promise<RelationTreeItem[]>;
+/** Cerca un nodo per percorso, per rimettere il fuoco dov'era. */
+export declare const findRelationNodeByPath: (nodes: RelationTreeItem[], path: string) => RelationTreeItem | null;

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

@@ -0,0 +1,89 @@
+/** I nodi generati (messaggi informativi, separatori) non hanno identità stabile. */
+const hasStableIdentity = (node) => !node.isInfoMessage && !node.isSeparator;
+const getNodeIdentity = (node) => node.isDcmt
+    ? `d:${node.tid ?? ''}:${node.did ?? ''}:${node.relationId ?? ''}`
+    : `c:${node.tid ?? ''}:${node.relationId ?? ''}:${node.name ?? ''}`;
+/** Il percorso include i padri: lo stesso documento può comparire sotto padri diversi. */
+const getNodePath = (node, parentPath) => {
+    const identity = getNodeIdentity(node);
+    return parentPath ? `${parentPath}>${identity}` : identity;
+};
+/**
+ * Fotografa lo stato dell'albero.
+ * `previousFocusedPath` viene usato quando il fuoco è già stato azzerato dall'esterno.
+ */
+export const collectRelationTreeState = (nodes, inputKey, focusedKey, previousFocusedPath) => {
+    const expandedPaths = [];
+    const loadedPaths = [];
+    let focusedPath;
+    const collect = (items, parentPath) => {
+        for (const node of items) {
+            if (!hasStableIdentity(node))
+                continue;
+            const path = getNodePath(node, parentPath);
+            if (node.expanded)
+                expandedPaths.push(path);
+            if (node.expanded && node.isDcmt && node.items)
+                loadedPaths.push(path);
+            // Entro la stessa istanza montata la key è univoca
+            if (focusedKey && node.key === focusedKey)
+                focusedPath = path;
+            if (node.items)
+                collect(node.items, path);
+        }
+    };
+    collect(nodes, '');
+    return { inputKey, expandedPaths, loadedPaths, focusedPath: focusedPath ?? previousFocusedPath };
+};
+/**
+ * Riapplica lo stato all'albero appena caricato. I nodi che non compaiono nello stato,
+ * o che non esistono più (es. documento cancellato), restano chiusi: il confronto per
+ * percorso è tollerante per costruzione.
+ */
+export const applyRelationTreeState = async (nodes, state, loadChildren, isAborted) => {
+    const expandedPaths = new Set(state.expandedPaths);
+    const loadedPaths = new Set(state.loadedPaths);
+    const apply = async (items, parentPath) => {
+        const result = [];
+        for (const node of items) {
+            if (!hasStableIdentity(node)) {
+                result.push(node);
+                continue;
+            }
+            const path = getNodePath(node, parentPath);
+            const wasExpanded = expandedPaths.has(path);
+            let children = node.items;
+            let isLoaded = node.isLoaded;
+            let itemsCount = node.itemsCount;
+            // I figli dei documenti sono lazy: vanno ricaricati se l'utente li aveva aperti
+            if (wasExpanded && node.isDcmt && !children && loadedPaths.has(path) && !isAborted()) {
+                children = await loadChildren(node);
+                isLoaded = true;
+                itemsCount = children.length;
+            }
+            const updatedItems = children ? await apply(children, path) : children;
+            result.push({ ...node, expanded: wasExpanded, items: updatedItems, isLoaded, itemsCount });
+        }
+        return result;
+    };
+    return await apply(nodes, '');
+};
+/** Cerca un nodo per percorso, per rimettere il fuoco dov'era. */
+export const findRelationNodeByPath = (nodes, path) => {
+    const find = (items, parentPath) => {
+        for (const node of items) {
+            if (!hasStableIdentity(node))
+                continue;
+            const currentPath = getNodePath(node, parentPath);
+            if (currentPath === path)
+                return node;
+            if (node.items) {
+                const found = find(node.items, currentPath);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    };
+    return find(nodes, '');
+};

package/lib/components/features/search/TMMetadataOutputForm.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 { SDK_Localizator, SelectItem, SelectItemVisibilities } from "@topconsultnpm/sdk-ts";
 import { IconAddCircleOutline, IconApply, IconClear, IconDelete, IconDraggabledots, IconUndo, SDKUI_Localizator } from "../../../helper";

package/lib/components/features/search/TMMetadataSorterForm.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 { OrderByItem, SDK_Localizator } from "@topconsultnpm/sdk-ts";
 import { IconAddCircleOutline, IconApply, IconClear, IconDelete, IconDraggabledots, IconUndo, SDKUI_Localizator } from "../../../helper";

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

@@ -181,7 +181,7 @@ const TMSavedQuerySelector = React.memo(({ items, selectedId, allowShowSearch =
                     overflow: 'auto'
                 }, children: dataSource.slice(0, showAllRoot || searchText.length > 0 ? dataSource.length : initialSQDsMaxItems).filter(o => searchText.length <= 0 || (searchText.length > 0 && o.name?.toLocaleLowerCase().includes(searchText.toLocaleLowerCase())) || o.description?.toLocaleLowerCase().includes(searchText.toLocaleLowerCase())).map((sqd, index) => {
                     const isCurrent = selectedItem?.id == sqd.id;
-                    return (_jsx(StyledSqdItem, { id: `sqd-item-${sqd.id}`, "$isMobile": isMobile, onClick: () => {
+                    return (_jsx(StyledSqdItem, { id: `sqd-item-${sqd.id}`, $isMobile: isMobile, onClick: () => {
                             setSelectedItem(sqd);
                             onItemClick?.(sqd);
                         }, onContextMenu: (e) => {
@@ -227,6 +227,6 @@ const TMSavedQuerySelector = React.memo(({ items, selectedId, allowShowSearch =
                     visible: contextMenuState.visible,
                     position: contextMenuState.position,
                     onClose: () => setContextMenuState(prev => ({ ...prev, visible: false, sqd: null }))
-                } }), _jsxs(StyledOffCanvasPanel, { ref: panelRef, "$isOpen": isMobile && infoSQD !== undefined, children: [_jsxs(StyledDivHorizontal, { style: { gap: 10, padding: '10px 8px', width: '100%', alignItems: 'center' }, children: [_jsx("p", { style: { fontSize: '1.1rem', fontWeight: 'bold' }, children: `${SDK_Localizator.SavedQuery} - ${SDKUI_Localizator.About}` }), _jsx(IconCloseOutline, { style: { marginLeft: 'auto', cursor: 'pointer' }, onClick: () => setInfoSQD(undefined) })] }), getTooltipBySqd(infoSQD)] })] }));
+                } }), _jsxs(StyledOffCanvasPanel, { ref: panelRef, $isOpen: isMobile && infoSQD !== undefined, children: [_jsxs(StyledDivHorizontal, { style: { gap: 10, padding: '10px 8px', width: '100%', alignItems: 'center' }, children: [_jsx("p", { style: { fontSize: '1.1rem', fontWeight: 'bold' }, children: `${SDK_Localizator.SavedQuery} - ${SDKUI_Localizator.About}` }), _jsx(IconCloseOutline, { style: { marginLeft: 'auto', cursor: 'pointer' }, onClick: () => setInfoSQD(undefined) })] }), getTooltipBySqd(infoSQD)] })] }));
 });
 export default TMSavedQuerySelector;

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

@@ -46,5 +46,5 @@ interface ITMSearchProps {
     fetchRemoteCertificates?: (email: string) => Promise<IntesiCertificateData[]>;
     graphometricManager?: IGraphometricManagerProp;
 }
-declare const TMSearch: React.FunctionComponent<ITMSearchProps>;
+declare const TMSearch: (props: ITMSearchProps) => React.JSX.Element;
 export default TMSearch;

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, 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) {
@@ -164,46 +217,65 @@ const TMSearch = ({ allTasks = [], getAllTasks, deleteTaskByIdsCallback, addTask
             console.error("Error refreshing search:", error);
         }
     };
+    const handleSearchCompleted = useCallback((searchResult, qd, append) => {
+        if (searchResult.length <= 0) {
+            // In ricerca normale un array vuoto resetta i risultati; in accoda si mantiene il set accumulato
+            if (!append)
+                setSearchResult(searchResult);
+            return;
+        }
+        const newResult = searchResult[0];
+        // In modalità accoda unisce il nuovo risultato a quello precedente (più recenti in cima).
+        setSearchResult(prev => {
+            if (append && prev.length > 0 && prev[0]?.fromTID === newResult?.fromTID) {
+                const merged = mergeSearchResultsAppend(prev[0], newResult);
+                return merged ? [merged] : searchResult;
+            }
+            return searchResult;
+        });
+        setLastQdSearched(qd);
+        setCurrentSearchView(TMSearchViews.Result);
+        // Salvataggio ultimi 10 TIDs
+        let fromTID = searchResult?.[0].fromTID;
+        let newMruTIDS = updateMruTids(SDKUI_Globals.userSettings.searchSettings.mruTIDs, fromTID);
+        SDKUI_Globals.userSettings.searchSettings.mruTIDs = newMruTIDS;
+        setMruTIDs(newMruTIDS);
+        setCurrentMruTID(fromTID);
+        setShowSearchResults(true);
+    }, []);
     const isMobile = deviceType === DeviceType.MOBILE;
     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: (searchResult, qd) => {
-            setSearchResult(searchResult);
-            if (searchResult.length <= 0)
-                return;
-            setLastQdSearched(qd);
-            setCurrentSearchView(TMSearchViews.Result);
-            // Salvataggio ultimi 10 TIDs 
-            let fromTID = searchResult?.[0].fromTID;
-            let newMruTIDS = updateMruTids(SDKUI_Globals.userSettings.searchSettings.mruTIDs, fromTID);
-            SDKUI_Globals.userSettings.searchSettings.mruTIDs = newMruTIDS;
-            setMruTIDs(newMruTIDS);
-            setCurrentMruTID(fromTID);
-            setShowSearchResults(true);
-        }, 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]);
-    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 ?? {};
@@ -250,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'] }
         },
         {
@@ -262,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 }) => {
@@ -285,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;
@@ -12,7 +13,7 @@ interface ITMSearchQueryPanelProps {
     onBack?: () => void;
     onBackToResult?: () => void;
     onSqdSaved?: (newSqd: SavedQueryDescriptor) => void;
-    onSearchCompleted?: (searchResult: SearchResultDescriptor[], qd: QueryDescriptor | undefined) => void;
+    onSearchCompleted?: (searchResult: SearchResultDescriptor[], qd: QueryDescriptor | undefined, append?: boolean) => void;
     onClosePanel?: () => void;
     allowMaximize?: boolean;
     onMaximizePanel?: () => void;
@@ -21,10 +22,19 @@ 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;
 export declare const refreshLastSearch: (qd: QueryDescriptor | undefined) => Promise<SearchResultDescriptor[] | undefined>;
-export declare const StyledToppyTextContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
-export declare const StyledToppyText: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, never>>> & string;
-export declare const StyledToppyImage: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, never>>> & string;
+export declare const StyledToppyTextContainer: import("styled-components/dist/types").IStyledComponentBase<"web", Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "style"> & {
+    style?: React.CSSProperties | import("styled-components/dist/types").CSSPropertiesWithVars | undefined;
+}> & string;
+export declare const StyledToppyText: import("styled-components/dist/types").IStyledComponentBase<"web", Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "style"> & {
+    style?: React.CSSProperties | import("styled-components/dist/types").CSSPropertiesWithVars | undefined;
+}> & string;
+export declare const StyledToppyImage: import("styled-components/dist/types").IStyledComponentBase<"web", Omit<React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "style"> & {
+    style?: React.CSSProperties | import("styled-components/dist/types").CSSPropertiesWithVars | undefined;
+}> & string;