@topconsultnpm/sdkui-react 6.19.0-dev1.10

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

@@ -0,0 +1,1293 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { SDK_Globals, DataColumnTypes, MetadataDataDomains, DataListViewModes, MetadataFormats, LayoutModes, TemplateTIDs, DcmtTypeListCacheService, AccessLevels, SystemMIDsAsNumber, RelationCacheService, RelationTypes } from '@topconsultnpm/sdk-ts';
+import styled from 'styled-components';
+import { getCommandsMenuItems, getSelectedDcmtsOrFocused } from './TMSearchResultsMenuItems';
+import { genUniqueId, IconShow, IconBoard, IconDcmtTypeSys, IconDetailDcmts, SDKUI_Localizator, IconDelete, IconRefresh, IconMenuVertical, IconDownload, deepCompare, getDataColumnName, searchResultDescriptorToSimpleArray, searchResultToMetadataValues, IconSearchCheck, TMCommandsContextMenu, IconRelation } from '../../../helper';
+import { useDcmtOperations } from '../../../hooks/useDcmtOperations';
+import { useInputAttachmentsDialog, useInputCvtFormatDialog } from '../../../hooks/useInputDialog';
+import { DcmtOperationTypes, FormModes, SearchResultContext, DownloadTypes } from '../../../ts';
+import { Gutters, TMColors } from '../../../utils/theme';
+import { StyledModalContainer, StyledBadge, StyledMultiViewPanel } from '../../base/Styled';
+import TMButton from '../../base/TMButton';
+import TMDataGrid, { TMDataGridPageSize } from '../../base/TMDataGrid';
+import { useDeviceType, DeviceType } from '../../base/TMDeviceProvider';
+import { TMSplitterLayout, TMLayoutItem } from '../../base/TMLayout';
+import { TMMessageBoxManager, ButtonNames, TMExceptionBoxManager } from '../../base/TMPopUp';
+import TMTooltip from '../../base/TMTooltip';
+import { TMLayoutWaitingContainer } from '../../base/TMWaitPanel';
+import { TMUserIdViewer } from '../../choosers/TMUserChooser';
+import TMMetadataValues from '../../editors/TMMetadataValues';
+import { TMSaveFormButtonPrevious, TMSaveFormButtonNext } from '../../forms/TMSaveForm';
+import TMDataListItemViewer from '../../viewers/TMDataListItemViewer';
+import TMTidViewer from '../../viewers/TMTidViewer';
+import { hasDetailRelations, hasMasterRelations } from '../../../helper/dcmtsHelper';
+import TMDcmtPreview from '../documents/TMDcmtPreview';
+import TMFloatingToolbar from '../../base/TMFloatingToolbar';
+import { WorkFlowApproveRejectPopUp, WorkFlowMoreInfoPopUp, WorkFlowOperationButtons, WorkFlowReAssignPopUp } from '../workflow/TMWorkflowPopup';
+import TMMasterDetailDcmts from '../documents/TMMasterDetailDcmts';
+import TMBatchUpdateForm from '../../features/documents/TMBatchUpdateForm';
+import TMDcmtForm from '../documents/TMDcmtForm';
+import TMDcmtBlog from '../documents/TMDcmtBlog';
+import TMDcmtIcon from '../documents/TMDcmtIcon';
+import { TMPanelManagerProvider, useTMPanelManagerContext } from '../../layout/panelManager/TMPanelManagerContext';
+import TMPanelManagerContainer from '../../layout/panelManager/TMPanelManagerContainer';
+import ToppyHelpCenter from '../assistant/ToppyHelpCenter';
+import TMAccordion from '../../base/TMAccordion';
+import TMDataGridExportForm from '../../base/TMDataGridExportForm';
+import TMSearchResultFloatingActionButton from './TMSearchResultFloatingActionButton';
+import ShowAlert from '../../base/TMAlert';
+import TMSpinner from '../../base/TMSpinner';
+import TMChooserForm from '../../forms/TMChooserForm';
+import TMModal from '../../base/TMModal';
+//#region Helper Methods
+export const getSearchResultCountersSingleCategory = (searchResults) => {
+    // let totDcmtTypes = searchResults.length;
+    let totDcmts = 0;
+    for (let dcmt of searchResults) {
+        totDcmts += dcmt.dcmtsFound ?? 0;
+    }
+    return ` (${totDcmts})`;
+};
+const orderByName = (array) => {
+    let arr = [...array];
+    return arr.sort((a, b) => { if (a['fromName'] < b['fromName']) {
+        return -1;
+    } if (a['fromName'] > b['fromName']) {
+        return 1;
+    } return 0; });
+};
+const TMSearchResult = ({ context = SearchResultContext.METADATA_SEARCH, isVisible = true, allowRelations = true, openDcmtFormAsModal = false, searchResults = [], showSearchResultSidebar = true, showSelector = false, groupId, title, isClosable = false, allowFloatingBar = true, showToolbarHeader = true, selectedSearchResultTID, workingGroupContext = undefined, disableAccordionIfSingleCategory = false, floatingActionConfig, openInOffice, onRefreshAfterAddDcmtToFavs, onRefreshSearchAsync, onSelectedTIDChanged, onWFOperationCompleted, onClose, onFileOpened, onTaskCreateRequest, openWGsCopyMoveForm, openEditPdf, openCommentFormCallback, openAddDocumentForm, openS4TViewer = false, onOpenS4TViewerRequest, passToArchiveCallback, showTodoDcmtForm = false }) => {
+    const [id, setID] = useState('');
+    const [showApprovePopup, setShowApprovePopup] = useState(false);
+    const [showRejectPopup, setShowRejectPopup] = useState(false);
+    const [showReAssignPopup, setShowReAssignPopup] = useState(false);
+    const [showMoreInfoPopup, setShowMoreInfoPopup] = useState(false);
+    const [splitterSize, setSplitterSize] = useState(['100%', '0']);
+    const [showFloatingBar, setShowFloatingBar] = useState(true);
+    const [lastUpdateSearchTime, setLastUpdateSearchTime] = useState();
+    const [fromDTD, setFromDTD] = useState();
+    const [selectedSearchResult, setSelectedSearchResult] = useState();
+    const [currentSearchResults, setCurrentSearchResults] = useState(searchResults || []);
+    const [showSearch, setShowSearch] = useState(false);
+    // States for Related Documents
+    const [relatedDcmts, setRelatedDcmts] = useState(undefined);
+    const [showRelatedDcmtsChooser, setShowRelatedDcmtsChooser] = useState(false);
+    const [archiveType, setArchiveType] = useState(undefined);
+    const [isOpenDetails, setIsOpenDetails] = useState(false);
+    const [isOpenMaster, setIsOpenMaster] = useState(false);
+    const [isOpenArchiveRelationForm, setIsOpenArchiveRelationForm] = useState(false);
+    const [archiveRelatedDcmtFormTID, setArchiveRelatedDcmtFormTID] = useState(undefined);
+    const [archiveRelatedDcmtFormMids, setArchiveRelatedDcmtFormMids] = useState([]);
+    const [relatedDcmtsChooserDataSource, setRelatedDcmtsChooserDataSource] = useState(undefined);
+    const [showPairDcmtsModal, setShowPairDcmtsModal] = useState(false);
+    const [isPairingManyToMany, setIsPairingManyToMany] = useState(false);
+    const [pairedSearchResults, setPairedSearchResults] = useState([]);
+    const [manyToManyRelations, setManyToManyRelations] = useState(undefined);
+    const [showManyToManyChooser, setShowManyToManyChooser] = useState(false);
+    const [manyToManyChooserDataSource, setManyToManyChooserDataSource] = useState(undefined);
+    const [secondaryMasterDcmts, setSecondaryMasterDcmts] = useState([]);
+    const [isOpenDcmtForm, setIsOpenDcmtForm] = useState(false);
+    const [currentTIDHasDetailRelations, setCurrentTIDHasDetailRelations] = useState();
+    const [currentTIDHasMasterRelations, setCurrentTIDHasMasterRelations] = useState();
+    const [canArchiveMasterRelation, setCanArchiveMasterRelation] = useState(false);
+    const [canArchiveDetailRelation, setCanArchiveDetailRelation] = useState(false);
+    const [isOpenBatchUpdate, setIsOpenBatchUpdate] = useState(false);
+    const [visibleItems, setVisibleItems] = useState([]);
+    const [focusedItem, setFocusedItem] = useState();
+    const [selectedItems, setSelectedItems] = useState([]);
+    const [currentDcmt, setCurrentDcmt] = useState();
+    const [currentMetadataValues, setCurrentMetadataValues] = useState([]);
+    const [dcmtFormLayoutMode, setDcmtFormLayoutMode] = useState(LayoutModes.Update);
+    const [isModifiedBatchUpdate, setIsModifiedBatchUpdate] = useState(false);
+    // State to control whether the export form (for exporting to Excel/CSV/txt and others) should be shown
+    const [showExportForm, setShowExportForm] = useState(false);
+    const [confirmFormat, ConfirmFormatDialog] = useInputCvtFormatDialog();
+    const { openConfirmAttachmentsDialog, ConfirmAttachmentsDialog } = useInputAttachmentsDialog();
+    const { abortController, showWaitPanel, waitPanelTitle, showPrimary, waitPanelTextPrimary, waitPanelValuePrimary, waitPanelMaxValuePrimary, showSecondary, waitPanelTextSecondary, waitPanelValueSecondary, waitPanelMaxValueSecondary, downloadDcmtsAsync, runOperationAsync } = useDcmtOperations();
+    const deviceType = useDeviceType();
+    const isMobile = deviceType === DeviceType.MOBILE;
+    const disable = getSelectedDcmtsOrFocused(selectedItems, focusedItem).length === 0;
+    // Disable the "Sign/Approve" button if:
+    // 1. No document or multiple documents are selected, OR
+    // 2. Exactly one document is selected but its FILEEXT property is null
+    const disableSignApproveDisable = getSelectedDcmtsOrFocused(selectedItems, focusedItem).length !== 1 || (getSelectedDcmtsOrFocused(selectedItems, focusedItem).length === 1 && getSelectedDcmtsOrFocused(selectedItems, focusedItem)[0].FILEEXT === null);
+    const dcmtsReturned = (searchResults?.length > 1 ? selectedSearchResult?.dcmtsReturned : searchResults[0]?.dcmtsReturned ?? 0);
+    const dcmtsFound = (searchResults?.length > 1 ? selectedSearchResult?.dcmtsFound : searchResults[0]?.dcmtsFound ?? 0);
+    useEffect(() => { setID(genUniqueId()); }, []);
+    useEffect(() => {
+        setSelectedItems([]);
+        setFocusedItem(undefined);
+        setIsOpenBatchUpdate(false);
+        setCurrentSearchResults(searchResults);
+        if (searchResults.length <= 0)
+            return;
+        if (searchResults.length === 1) {
+            setSelectedSearchResult(searchResults[0]);
+            return;
+        }
+        setSelectedSearchResult(orderByName(searchResults)[0]);
+    }, [searchResults]);
+    useEffect(() => {
+        setFocusedItem(undefined);
+        setSelectedItems([]);
+        DcmtTypeListCacheService.GetWithNotGrantedAsync(selectedSearchResult?.fromTID, Number(selectedSearchResult?.dtdResult?.rows?.[0]?.[1])).then((dtd) => {
+            setFromDTD(dtd);
+        });
+        hasDetailRelations(selectedSearchResult?.fromTID).then((value) => setCurrentTIDHasDetailRelations(value));
+        hasMasterRelations(selectedSearchResult?.fromTID).then((value) => setCurrentTIDHasMasterRelations(value));
+        checkRelatedDcmtsArchiveCapability();
+        // Ricava il nuovo dataSource
+        const newDataSource = searchResultDescriptorToSimpleArray(selectedSearchResult);
+        // Se esiste almeno una riga, seleziona la prima
+        setFocusedItem(newDataSource && newDataSource.length > 0 ? newDataSource[0] : undefined);
+    }, [selectedSearchResult]);
+    useEffect(() => {
+        if (!focusedItem)
+            return;
+        if (!fromDTD)
+            return;
+        let dtd = searchResults.length > 1 ? searchResults.find(res => res.fromTID == focusedItem?.TID)?.dtdResult : searchResults[0]?.dtdResult;
+        if (!dtd)
+            return;
+        let rows = dtd.rows ? dtd.rows[focusedItem.rowIndex] : [];
+        let mids = searchResults.length > 1 ? searchResults.find(res => res.fromTID == focusedItem?.TID)?.selectMIDs : searchResults[0]?.selectMIDs;
+        let metadataList = searchResultToMetadataValues(focusedItem?.TID, dtd, rows, mids, fromDTD?.metadata, LayoutModes.Update);
+        setCurrentMetadataValues(metadataList);
+    }, [focusedItem]);
+    useEffect(() => {
+        setCurrentDcmt({
+            tid: currentMetadataValues.find(o => o.mid == SystemMIDsAsNumber.TID)?.value,
+            did: currentMetadataValues.find(o => o.mid == SystemMIDsAsNumber.DID)?.value,
+            fileCount: currentMetadataValues.find(o => o.mid == SystemMIDsAsNumber.FileCount)?.value,
+            fileSize: currentMetadataValues.find(o => o.mid == SystemMIDsAsNumber.FileSize)?.value,
+            fileExt: currentMetadataValues.find(o => o.mid == SystemMIDsAsNumber.FileExt)?.value
+        });
+    }, [currentMetadataValues]);
+    const openFormHandler = (layoutMode) => { setIsOpenDcmtForm(true); setDcmtFormLayoutMode(layoutMode); };
+    const openTaskFormHandler = (onTaskCreated) => {
+        if (selectedItems.length > 1)
+            return;
+        const item = selectedItems.length === 1 ? selectedItems[0] : focusedItem;
+        if (item?.TID && item?.DID) {
+            const fetchData = async () => {
+                try {
+                    const dtd = await DcmtTypeListCacheService.GetWithNotGrantedAsync(item.TID, item?.DID);
+                    if (dtd) {
+                        const isWorkItem = dtd?.templateTID === TemplateTIDs.WF_WIApprView;
+                        const name = `${dtd.name ?? '-'} (DID: ${item.DID})`;
+                        onTaskCreateRequest?.(isWorkItem
+                            ? { workItem: { tid: item.TID, did: item.DID, name } }
+                            : { document: { tid: item.TID, did: item.DID, name } }, onTaskCreated);
+                    }
+                }
+                catch (error) {
+                    console.error("Error fetching data:", error);
+                }
+            };
+            fetchData();
+        }
+    };
+    const openDetailDcmtsFormHandler = (value) => { setIsOpenDetails(value); };
+    const openMasterDcmtsFormHandler = (value) => { setIsOpenMaster(value); };
+    const openBatchUpdateFormHandler = (value) => { setIsOpenBatchUpdate(value); };
+    const openExportForm = useCallback(() => {
+        setShowExportForm(true);
+    }, []);
+    const onCloseExportForm = useCallback(() => {
+        setShowExportForm(false);
+    }, []);
+    const handleToggleSearch = () => {
+        setShowSearch(prev => !prev);
+    };
+    const getTitleHeader = () => {
+        let counters = (showSelector && disableAccordionIfSingleCategory && searchResults.length > 1) ? getSearchResultCountersSingleCategory(searchResults) : "";
+        if (title)
+            return title + counters;
+        let titleHeader = 'Ricerca per metadati';
+        switch (context) {
+            case SearchResultContext.MASTER_DETAIL:
+            case SearchResultContext.METADATA_SEARCH:
+                titleHeader = `${searchResults?.length > 1 ? selectedSearchResult?.fromName ?? 'Ricerca per metadati' : searchResults[0]?.fromName ?? 'Ricerca per metadati'}`;
+                break;
+            case SearchResultContext.FAVORITES_AND_RECENTS:
+                titleHeader = SDKUI_Localizator.FavoritesAndRecentDcmts;
+                break;
+            case SearchResultContext.WORKFLOW_APPROVE:
+                titleHeader = SDKUI_Localizator.WorkflowApproval;
+                break;
+            case SearchResultContext.FREE_SEARCH:
+                titleHeader = `Risultato della ricerca full text`;
+                break;
+        }
+        return titleHeader + counters;
+    };
+    const handleSignApprove = () => {
+        if (onOpenS4TViewerRequest) {
+            onOpenS4TViewerRequest(getSelectedDcmtsOrFocused(selectedItems, focusedItem), onRefreshSearchAsync);
+            return;
+        }
+        ShowAlert({
+            message: "Non è stato possibile proseguire con la firma e l'approvazione.",
+            mode: "warning",
+            duration: 3000,
+            title: SDKUI_Localizator.SignatureAndApprove,
+        });
+    };
+    const onBack = () => {
+        if (isOpenBatchUpdate && isModifiedBatchUpdate) {
+            TMMessageBoxManager.show({
+                title: SDKUI_Localizator.Cancel, message: SDKUI_Localizator.ConfirmOnCancel, buttons: [ButtonNames.YES, ButtonNames.NO],
+                onButtonClick: (e) => {
+                    if (e !== ButtonNames.YES)
+                        return;
+                    setSplitterSize(['100%', '0']);
+                    onClose?.();
+                }
+            });
+        }
+        else if (isOpenDcmtForm) {
+            setIsOpenDcmtForm(false);
+        }
+        else {
+            setSplitterSize(['100%', '0']);
+            onClose?.();
+        }
+    };
+    const onContextMenuPreparing = (e) => {
+        if (e === undefined)
+            return;
+        if (e.target === 'content') {
+            e.items = e.items || [];
+            const menuItems = getCommandsMenuItems(isMobile, fromDTD, selectedItems, focusedItem, context, showFloatingBar, workingGroupContext, showSearch, setShowFloatingBar, openFormHandler, downloadDcmtsAsync, runOperationAsync, onRefreshSearchAsync, refreshSelectionDataRowsAsync, onRefreshAfterAddDcmtToFavs, confirmFormat, openConfirmAttachmentsDialog, openTaskFormHandler, openDetailDcmtsFormHandler, openMasterDcmtsFormHandler, openBatchUpdateFormHandler, openExportForm, handleToggleSearch, handleSignApprove, openWGsCopyMoveForm, openCommentFormCallback, openEditPdf, openAddDocumentForm, passToArchiveCallback, archiveMasterDocuments, archiveDetailDocuments, currentTIDHasMasterRelations, currentTIDHasDetailRelations, canArchiveMasterRelation, canArchiveDetailRelation, pairManyToMany);
+            e.items.push(...menuItems);
+        }
+    };
+    const refreshDataGridAfterRemoveAsync = async () => {
+        let index = selectedSearchResult?.dtdResult?.columns?.findIndex(col => col.caption === 'DID');
+        let selectedRows = [];
+        if (!index)
+            return;
+        for (let data of getSelectedDcmtsOrFocused(selectedItems, focusedItem)) {
+            selectedRows.push(selectedSearchResult?.dtdResult?.rows?.findIndex(row => row[index] === data.DID.toString()));
+        }
+        if (!selectedSearchResult?.dtdResult?.rows)
+            return;
+        let newRows = [];
+        for (let i = 0; i < selectedSearchResult.dtdResult.rows.length; i++) {
+            if (!selectedRows.includes(i))
+                newRows.push(selectedSearchResult.dtdResult.rows[i]);
+        }
+        let newSearchresult = structuredClone(selectedSearchResult);
+        let newDtd = structuredClone(selectedSearchResult.dtdResult);
+        newDtd.rows = newRows;
+        newSearchresult.dtdResult = newDtd;
+        newSearchresult.dcmtsReturned = newRows.length;
+        newSearchresult.dcmtsFound = newRows.length;
+        setSelectedSearchResult(newSearchresult);
+        setCurrentSearchResults((prev) => {
+            let newResults = [...prev];
+            let index = newResults.findIndex((res) => res.fromTID === selectedSearchResult?.fromTID);
+            if (index >= 0) {
+                newResults[index] = newSearchresult;
+            }
+            return newResults;
+        });
+    };
+    const removeDcmtFromFavsOrRecents = async () => {
+        switch (selectedSearchResult?.category) {
+            case "Favorites":
+                await runOperationAsync(getSelectedDcmtsOrFocused(selectedItems, focusedItem), DcmtOperationTypes.RemoveFromFavs, refreshDataGridAfterRemoveAsync);
+                break;
+            case "RecentArchive":
+                await runOperationAsync(getSelectedDcmtsOrFocused(selectedItems, focusedItem), DcmtOperationTypes.RemoveFromRecentsArk, refreshDataGridAfterRemoveAsync);
+                break;
+            case "RecentView":
+                await runOperationAsync(getSelectedDcmtsOrFocused(selectedItems, focusedItem), DcmtOperationTypes.RemoveFromRecentsView, refreshDataGridAfterRemoveAsync);
+                break;
+            default: break;
+        }
+    };
+    const onSearchResultSelectionChanged = (e) => {
+        setSelectedSearchResult(e);
+        if (deviceType === DeviceType.MOBILE) {
+            setSplitterSize(['0', '100%']);
+        }
+        onSelectedTIDChanged?.(e.fromTID);
+    };
+    const refreshFocusedDataRowAsync = async (tid, did, refreshUI, metadataResult) => {
+        if (!tid || !did)
+            return;
+        let currentResult = searchResults.length > 1 ? selectedSearchResult : searchResults[0];
+        let currentResultColIndexTID = currentResult?.dtdResult?.columns?.findIndex(o => o.caption == "TID");
+        if (currentResultColIndexTID == undefined)
+            return;
+        let currentResultColIndexDID = currentResult?.dtdResult?.columns?.findIndex(o => o.caption == "DID");
+        if (currentResultColIndexDID == undefined)
+            return;
+        let newDcmt;
+        // Se metadataResult è null (non undefined!), significa che GetMetadataAsync è già fallito
+        // nel form e l'errore è già stato mostrato all'utente, quindi non ritentiamo
+        if (metadataResult === null) {
+            newDcmt = undefined;
+        }
+        // Se metadataResult è un oggetto valido, usiamolo
+        else if (metadataResult !== undefined) {
+            newDcmt = metadataResult;
+        }
+        // Altrimenti (metadataResult === undefined), tentiamo di ottenerlo
+        else {
+            try {
+                newDcmt = await SDK_Globals.tmSession?.NewSearchEngine().GetMetadataAsync(tid, did, true);
+            }
+            catch (error) {
+                newDcmt = undefined;
+            }
+        }
+        // Se newDcmt è undefined o non ha righe, significa che il documento non esiste più
+        // o non è più accessibile. Rimuovi la riga dal risultato della ricerca
+        if (!newDcmt || !newDcmt.dtdResult?.rows?.[0]) {
+            if (currentResult?.dtdResult?.rows) {
+                // IMPORTANTE: Modifica direttamente l'oggetto originale per mantenere la sincronizzazione
+                currentResult.dtdResult.rows = currentResult.dtdResult.rows.filter((row) => !(row[currentResultColIndexTID] == tid?.toString() && row[currentResultColIndexDID] == did?.toString()));
+                currentResult.dcmtsReturned = currentResult.dtdResult.rows.length;
+                currentResult.dcmtsFound = Math.max(0, (currentResult.dcmtsFound ?? 0) - 1);
+                // Se il documento rimosso era quello focalizzato, resetta il focus
+                if (focusedItem?.TID === tid && focusedItem?.DID === did) {
+                    setFocusedItem(undefined);
+                    setSelectedItems([]);
+                }
+            }
+            // IMPORTANTE: forza l'aggiornamento della griglia
+            if (refreshUI)
+                setLastUpdateSearchTime(new Date(Date.now()));
+            return;
+        }
+        // Se il documento esiste, aggiorna i valori come prima
+        let newDcmtRow = newDcmt.dtdResult.rows[0];
+        let currentDcmtRow = currentResult?.dtdResult?.rows?.filter((row) => row[currentResultColIndexTID] == tid?.toString() && row[currentResultColIndexDID] == did?.toString()) ?? [];
+        for (const row of currentDcmtRow) {
+            let mids = currentResult?.selectMIDs ?? [];
+            for (let i = 0; i < mids.length; i++) {
+                const mid = mids[i];
+                let newDcmtMidIndex = newDcmt?.selectMIDs?.findIndex(o => o == mid) ?? -1;
+                if (newDcmtMidIndex >= 0 && row[i] != newDcmtRow[newDcmtMidIndex]) {
+                    row[i] = newDcmtRow[newDcmtMidIndex];
+                }
+            }
+        }
+        if (refreshUI)
+            setLastUpdateSearchTime(new Date(Date.now()));
+    };
+    const refreshSelectionDataRowsAsync = async () => {
+        let dcmts = getSelectedDcmtsOrFocused(selectedItems, focusedItem);
+        for (const dcmt of dcmts) {
+            await refreshFocusedDataRowAsync(dcmt.TID, dcmt.DID);
+        }
+        setLastUpdateSearchTime(new Date(Date.now()));
+    };
+    const getSelectionDcmtInfo = () => { return getSelectedDcmtsOrFocused(selectedItems, focusedItem); };
+    const canNavigateHandler = (dir) => {
+        if (!focusedItem)
+            return false;
+        let index = -1;
+        if (visibleItems) {
+            index = visibleItems.findIndex(item => item.rowIndex === focusedItem.rowIndex);
+        }
+        switch (dir) {
+            case 'next': if (visibleItems && index < visibleItems.length - 1) {
+                return true;
+            }
+            else {
+                return false;
+            }
+            default: if (visibleItems && index > 0) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+    };
+    const onNavigateHandler = (dir) => {
+        let index = -1;
+        if (visibleItems && focusedItem) {
+            index = visibleItems.findIndex(item => item.rowIndex === focusedItem.rowIndex);
+        }
+        switch (dir) {
+            case 'next':
+                setFocusedItem(visibleItems[index + 1]);
+                break;
+            default:
+                setFocusedItem(visibleItems[index - 1]);
+                break;
+        }
+    };
+    //#region Related Documents Archive Section
+    const pairFloatingActionConfig = useMemo(() => ({
+        isVisible: true,
+        type: 'multi',
+        onClick: (selected) => { console.log(selected); },
+        iconElement: _jsx(IconRelation, { fontSize: 26 }),
+        tooltip: isPairingManyToMany ? 'Abbina' : 'Disabbina',
+    }), [isPairingManyToMany, pairedSearchResults]);
+    const getAllRelationsAsync = async () => {
+        const tmSession = SDK_Globals.tmSession;
+        try {
+            TMSpinner.show({ description: SDKUI_Localizator.Loading });
+            let relations = await RelationCacheService.GetAllAsync(tmSession);
+            if (!relations)
+                throw new Error("Impossibile caricare le relazioni.");
+            return relations;
+        }
+        catch (error) {
+            TMExceptionBoxManager.show({ exception: error });
+            return undefined;
+        }
+        finally {
+            TMSpinner.hide();
+        }
+    };
+    const checkRelatedDcmtsArchiveCapability = async () => {
+        const tid = selectedSearchResult?.fromTID;
+        if (!tid) {
+            setCanArchiveMasterRelation(false);
+            setCanArchiveDetailRelation(false);
+            return;
+        }
+        try {
+            const relations = await getAllRelationsAsync();
+            if (!relations) {
+                setCanArchiveMasterRelation(false);
+                setCanArchiveDetailRelation(false);
+                return;
+            }
+            const detailRelations = relations.filter(r => r.detailTID === tid);
+            const hasMasterWithAssociations = detailRelations.some(rel => rel.associations && rel.associations.length > 0);
+            setCanArchiveMasterRelation(hasMasterWithAssociations);
+            const masterRelations = relations.filter(r => r.masterTID === tid);
+            const hasDetailWithAssociations = masterRelations.some(rel => rel.associations && rel.associations.length > 0);
+            setCanArchiveDetailRelation(hasDetailWithAssociations);
+        }
+        catch (error) {
+            console.error("Error checking archive capability:", error);
+            setCanArchiveMasterRelation(false);
+            setCanArchiveDetailRelation(false);
+        }
+    };
+    const getFocusedItem = () => {
+        if (!focusedItem || currentSearchResults.length !== 1)
+            return undefined;
+        return { mdList: currentSearchResults[0].dtdResult?.rows?.[focusedItem?.rowIndex ?? 0], mids: currentSearchResults[0].selectMIDs ?? [] };
+    };
+    const fetchAssociatedValues = (mid) => {
+        let mdList = getFocusedItem();
+        if (!mdList)
+            return;
+        let index = mdList.mids.findIndex(m => m == mid);
+        if (index === -1)
+            return;
+        return mdList.mdList?.[index];
+    };
+    const filterRelationsByType = (relations, tid, type) => {
+        return type === 'detail'
+            ? relations.filter(r => r.masterTID == tid)
+            : relations.filter(r => r.detailTID == tid);
+    };
+    const filterRelationsWithAssociations = (relations) => {
+        return relations.filter(rel => rel.associations && rel.associations.length > 0);
+    };
+    const getRelatedDcmt = async (relation, type) => {
+        return await DcmtTypeListCacheService.GetAsync(type === 'detail' ? relation.detailTID : relation.masterTID);
+    };
+    const showNoRelationsAlert = (type) => {
+        ShowAlert({
+            message: type === 'detail'
+                ? "Nessun documento di dettaglio trovato per l'archiviazione."
+                : "Nessun documento di master trovato per l'archiviazione.",
+            mode: 'info',
+            title: type === 'detail' ? SDKUI_Localizator.DcmtsDetail : SDKUI_Localizator.DcmtsMaster,
+            duration: 5000
+        });
+    };
+    const showNoAssociationsAlert = (type) => {
+        ShowAlert({
+            message: type === 'detail'
+                ? "Nessuna associazione trovata per i documenti di dettaglio."
+                : "Nessuna associazione trovata per i documenti di master.",
+            mode: 'info',
+            title: type === 'detail' ? SDKUI_Localizator.DcmtsDetail : SDKUI_Localizator.DcmtsMaster,
+            duration: 5000
+        });
+    };
+    const mapAssociationsToMids = (relation, type) => {
+        return relation.associations?.map(assoc => ({
+            mid: type === 'detail' ? (assoc.item2 ?? 0) : (assoc.item1 ?? 0),
+            value: fetchAssociatedValues(type === 'detail' ? (assoc.item1 ?? 0) : (assoc.item2 ?? 0)) ?? ''
+        })) ?? [];
+    };
+    const archiveRelatedDcmtHandler = (relation, type) => {
+        const targetTID = type === 'detail' ? relation.detailTID : relation.masterTID;
+        if (!targetTID)
+            return;
+        const mids = mapAssociationsToMids(relation, type);
+        setArchiveType(type);
+        setArchiveRelatedDcmtFormTID(targetTID);
+        setArchiveRelatedDcmtFormMids(mids);
+        setIsOpenArchiveRelationForm(true);
+    };
+    const archiveRelatedDocuments = async (tid, type) => {
+        try {
+            TMSpinner.show({ description: SDKUI_Localizator.Loading });
+            const relations = await getAllRelationsAsync();
+            if (!relations || !tid)
+                return;
+            const filteredRelations = filterRelationsByType(relations, tid, type);
+            if (!filteredRelations || filteredRelations.length === 0) {
+                showNoRelationsAlert(type);
+                return;
+            }
+            const withAssociations = filterRelationsWithAssociations(filteredRelations);
+            if (withAssociations.length === 0) {
+                showNoAssociationsAlert(type);
+                return;
+            }
+            setRelatedDcmts(withAssociations);
+            if (withAssociations.length > 1) {
+                const dataSourcePromises = withAssociations.map(async (rel) => {
+                    const relatedDcmt = await getRelatedDcmt(rel, type);
+                    return { id: rel?.id, name: relatedDcmt?.name };
+                });
+                const dataSource = await Promise.all(dataSourcePromises);
+                setRelatedDcmtsChooserDataSource(dataSource);
+                setArchiveType(type);
+                setShowRelatedDcmtsChooser(true);
+            }
+            else {
+                archiveRelatedDcmtHandler(withAssociations[0], type);
+            }
+        }
+        catch (error) {
+            TMExceptionBoxManager.show({ exception: error });
+        }
+        finally {
+            TMSpinner.hide();
+        }
+    };
+    const archiveDetailDocuments = async (tid) => {
+        await archiveRelatedDocuments(tid, 'detail');
+    };
+    const archiveMasterDocuments = async (tid) => {
+        await archiveRelatedDocuments(tid, 'master');
+    };
+    const getAlreadyPairedDIDs = async (relation, currentTID, currentDID) => {
+        if (!relation || !currentDID)
+            return [];
+        try {
+            const tmSession = SDK_Globals.tmSession;
+            if (!tmSession)
+                return [];
+            const searchEngine = tmSession.NewSearchEngine();
+            if (!searchEngine)
+                return [];
+            const isMaster = currentTID === relation.masterTID;
+            const pairedResults = isMaster
+                ? await searchEngine.GetAllDetailDcmtsAsync(currentTID, currentDID)
+                : await searchEngine.GetAllMasterDcmtsAsync(currentTID, currentDID);
+            if (!pairedResults || pairedResults.length === 0)
+                return [];
+            const relationResult = pairedResults.find(r => r.relationID === relation.id);
+            if (!relationResult?.dtdResult)
+                return [];
+            const pairedDIDs = [];
+            const rows = relationResult.dtdResult.rows ?? [];
+            const columns = relationResult.dtdResult.columns ?? [];
+            const didColumnIndex = columns.findIndex(col => {
+                const caption = col.caption?.toUpperCase();
+                const mid = col.extendedProperties?.["MID"];
+                const midNum = typeof mid === 'string' ? Number.parseInt(mid, 10) : mid;
+                return caption === 'DID' || midNum === 5;
+            });
+            if (didColumnIndex === -1)
+                return [];
+            for (const row of rows) {
+                const did = row[didColumnIndex];
+                if (did) {
+                    const didNumber = typeof did === 'string' ? Number.parseInt(did, 10) : did;
+                    if (!Number.isNaN(didNumber)) {
+                        pairedDIDs.push(didNumber);
+                    }
+                }
+            }
+            return pairedDIDs;
+        }
+        catch (error) {
+            console.error('getAlreadyPairedDIDs - Error:', error);
+            return [];
+        }
+    };
+    const executeManyToManyPairing = async (relation, isPairing) => {
+        const searchEngine = SDK_Globals.tmSession?.NewSearchEngine();
+        if (!focusedItem?.TID || !focusedItem?.DID) {
+            alert("Seleziona un documento per eseguire la ricerca molti-a-molti.");
+            return;
+        }
+        let qd;
+        if (relation.detailTID === selectedSearchResult?.fromTID) {
+            qd = relation.retrieveMastersQuery;
+        }
+        if (relation.masterTID === selectedSearchResult?.fromTID) {
+            qd = relation.retrieveDetailsQuery;
+        }
+        if (!qd) {
+            alert("La relazione molti-a-molti selezionata non ha una query di ricerca definita.");
+            return;
+        }
+        qd = structuredClone(qd);
+        if (qd.select) {
+            for (const s of qd.select) {
+                s.visibility = 1;
+            }
+        }
+        const qdRetrieveParamsValue = {
+            from: { tid: focusedItem.TID },
+            select: [],
+            where: [
+                {
+                    tid: focusedItem.TID,
+                    mid: 5,
+                    leftBrackets: "(",
+                    rightBrackets: ")",
+                    operator: 0,
+                    value1: focusedItem.DID.toString()
+                }
+            ]
+        };
+        let notMappedMIDs = false;
+        if (qd.params && qd.params.length > 0) {
+            for (const param of qd.params) {
+                if (!param.mappedMID)
+                    continue;
+                qdRetrieveParamsValue.select.push({
+                    tid: param.mappedTID ?? focusedItem.TID,
+                    mid: param.mappedMID,
+                    visibility: 1
+                });
+                const currentRowValue = currentSearchResults[0]?.dtdResult?.rows?.[focusedItem.rowIndex];
+                const midIndex = currentSearchResults[0]?.selectMIDs?.indexOf(param.mappedMID);
+                if (currentRowValue && midIndex !== undefined && midIndex >= 0) {
+                    const value = currentRowValue[midIndex];
+                    param.value = value ?? '';
+                    if (param.value === null || param.value === '')
+                        notMappedMIDs = true;
+                }
+                else {
+                    notMappedMIDs = true;
+                }
+            }
+            if (notMappedMIDs && qdRetrieveParamsValue.select && qdRetrieveParamsValue.select.length > 0) {
+                const paramMetadata = await searchEngine.SearchByIDAsync(qdRetrieveParamsValue);
+                if (paramMetadata?.dtdResult?.rows?.[0]) {
+                    for (const param of qd.params) {
+                        if (!param.mappedMID)
+                            continue;
+                        const colIndex = paramMetadata.selectMIDs?.indexOf(param.mappedMID);
+                        if (colIndex !== undefined && colIndex >= 0) {
+                            const value = paramMetadata.dtdResult.rows[0][colIndex];
+                            param.value = value ?? '';
+                        }
+                    }
+                }
+            }
+            if (qd.where && qd.where.length > 0) {
+                for (const whereItem of qd.where) {
+                    for (const param of qd.params) {
+                        if (!param.name)
+                            continue;
+                        param.value ??= '';
+                        const paramValue = param.value.toString();
+                        if (whereItem.value1) {
+                            whereItem.value1 = whereItem.value1.replace(param.name, paramValue);
+                        }
+                        if (whereItem.value2) {
+                            whereItem.value2 = whereItem.value2.replace(param.name, paramValue);
+                        }
+                    }
+                }
+            }
+        }
+        const targetTID = relation.detailTID === selectedSearchResult?.fromTID
+            ? relation.masterTID
+            : relation.detailTID;
+        const qdWithDID = structuredClone(qd);
+        const didSelect = { tid: targetTID, mid: 1, visibility: 1 };
+        const fileExtSelect = { tid: targetTID, mid: 5, visibility: 1 };
+        if (qdWithDID.select) {
+            qdWithDID.select = [didSelect, fileExtSelect, ...qdWithDID.select];
+        }
+        else {
+            qdWithDID.select = [didSelect, fileExtSelect];
+        }
+        const sq = await searchEngine.SearchByIDAsync(qdWithDID);
+        if (!sq?.dtdResult?.rows || sq.dtdResult.rows.length === 0) {
+            alert("Nessun documento trovato.");
+            return;
+        }
+        const pairedDIDs = await getAlreadyPairedDIDs(relation, focusedItem.TID, focusedItem.DID);
+        const filteredRows = sq.dtdResult.rows.filter(row => {
+            const did = row[0];
+            const didNum = typeof did === 'string' ? parseInt(did, 10) : did;
+            if (isPairing) {
+                return !pairedDIDs.includes(didNum);
+            }
+            else {
+                return pairedDIDs.includes(didNum);
+            }
+        });
+        const filteredSq = {
+            ...sq,
+            dtdResult: {
+                ...sq.dtdResult,
+                rows: filteredRows
+            },
+            dcmtsReturned: filteredRows.length,
+            dcmtsFound: filteredRows.length
+        };
+        if (filteredRows.length === 0) {
+            alert(isPairing ? "Nessun documento da abbinare." : "Nessun documento abbinato trovato.");
+            return;
+        }
+        setPairedSearchResults([filteredSq]);
+        setIsPairingManyToMany(isPairing);
+        setShowPairDcmtsModal(true);
+    };
+    const pairManyToMany = async (isPairing) => {
+        try {
+            TMSpinner.show({ description: SDKUI_Localizator.Loading });
+            const relations = await getAllRelationsAsync();
+            if (!relations)
+                return;
+            if (!relations.some(r => r.relationType === RelationTypes.ManyToMany)) {
+                alert("Nessuna relazione molti-a-molti definita nel sistema.");
+                return;
+            }
+            const manyToManyRels = relations.filter(r => r.relationType === RelationTypes.ManyToMany);
+            if (!manyToManyRels.some(r => r.masterTID === selectedSearchResult?.fromTID || r.detailTID === selectedSearchResult?.fromTID)) {
+                alert("Nessuna relazione molti-a-molti definita per il tipo di documento selezionato.");
+                return;
+            }
+            const relsManyToMany = manyToManyRels.filter(r => r.masterTID === selectedSearchResult?.fromTID || r.detailTID === selectedSearchResult?.fromTID);
+            setManyToManyRelations(relsManyToMany);
+            if (relsManyToMany.length > 1) {
+                const dataSourcePromises = relsManyToMany.map(async (rel) => {
+                    const targetTID = rel.masterTID === selectedSearchResult?.fromTID ? rel.detailTID : rel.masterTID;
+                    const relatedDcmt = await DcmtTypeListCacheService.GetAsync(targetTID);
+                    return { id: rel?.id, name: relatedDcmt?.name };
+                });
+                const dataSource = await Promise.all(dataSourcePromises);
+                setManyToManyChooserDataSource(dataSource);
+                setIsPairingManyToMany(isPairing);
+                setShowManyToManyChooser(true);
+            }
+            else {
+                await executeManyToManyPairing(relsManyToMany[0], isPairing);
+            }
+        }
+        catch (error) {
+            TMExceptionBoxManager.show({ exception: error });
+        }
+        finally {
+            TMSpinner.hide();
+        }
+    };
+    //#endregion Related Documents Archive Section
+    const searchResutlToolbar = _jsxs(_Fragment, { children: [(dcmtsReturned != dcmtsFound) && _jsx("p", { style: { backgroundColor: `white`, color: TMColors.primaryColor, textAlign: 'center', padding: '1px 4px', borderRadius: '3px', display: 'flex' }, children: `${dcmtsReturned}/${dcmtsFound} restituiti` }), context === SearchResultContext.FAVORITES_AND_RECENTS &&
+                _jsx("div", { style: { display: 'flex', alignItems: 'center', gap: '5px' }, children: _jsx(TMButton, { btnStyle: 'icon', icon: _jsx(IconDelete, { color: 'white' }), caption: "Rimuovi da " + (selectedSearchResult?.category === "Favorites" ? '"Preferiti"' : '"Recenti"'), disabled: getSelectedDcmtsOrFocused(selectedItems, focusedItem).length <= 0, onClick: removeDcmtFromFavsOrRecents }) }), _jsx(TMButton, { btnStyle: 'icon', icon: _jsx(IconRefresh, { color: 'white' }), caption: SDKUI_Localizator.Refresh, onClick: onRefreshSearchAsync }), _jsx(IconMenuVertical, { id: `commands-header-${id}`, color: 'white', cursor: 'pointer' }), _jsx(TMCommandsContextMenu, { target: `#commands-header-${id}`, showEvent: "click", menuItems: getCommandsMenuItems(isMobile, fromDTD, selectedItems, focusedItem, context, showFloatingBar, workingGroupContext, showSearch, setShowFloatingBar, openFormHandler, downloadDcmtsAsync, runOperationAsync, onRefreshSearchAsync, refreshSelectionDataRowsAsync, onRefreshAfterAddDcmtToFavs, confirmFormat, openConfirmAttachmentsDialog, openTaskFormHandler, openDetailDcmtsFormHandler, openMasterDcmtsFormHandler, openBatchUpdateFormHandler, openExportForm, handleToggleSearch, handleSignApprove, openWGsCopyMoveForm, openCommentFormCallback, openEditPdf, openAddDocumentForm, passToArchiveCallback, archiveMasterDocuments, archiveDetailDocuments, currentTIDHasMasterRelations, currentTIDHasDetailRelations, canArchiveMasterRelation, canArchiveDetailRelation, pairManyToMany) })] });
+    const middlePanelToolbar = _jsxs("div", { style: { width: 'max-content', display: 'flex', alignItems: 'center', gap: '10px' }, children: [_jsx(TMSaveFormButtonPrevious, { btnStyle: 'icon', isModified: false, iconColor: TMColors.default_background, formMode: FormModes.ReadOnly, canPrev: canNavigateHandler('prev'), onPrev: () => onNavigateHandler('prev') }), _jsx(TMSaveFormButtonNext, { btnStyle: 'icon', isModified: false, iconColor: TMColors.default_background, formMode: FormModes.ReadOnly, canNext: canNavigateHandler('next'), onNext: () => onNavigateHandler('next') })] });
+    const handleAddItem = (tid, did) => {
+        let newItem = { TID: tid ?? 0, DID: did ?? 0 };
+        setSecondaryMasterDcmts((prevItems) => [...prevItems, newItem]);
+    };
+    const handleRemoveItem = (tid, did) => {
+        setSecondaryMasterDcmts((prevItems) => prevItems.filter(item => item.TID !== tid && item.DID !== did));
+    };
+    const showToppyForApprove = (isVisible && fromDTD?.templateTID === TemplateTIDs.WF_WIApprView && !isOpenDcmtForm && !isOpenDetails && !isOpenMaster);
+    const tmSearchResult = useMemo(() => (!searchResults || searchResults.length <= 0)
+        ? _jsxs("div", { style: { display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', height: '100%', width: '100%' }, children: [_jsx(IconBoard, { fontSize: 96 }), _jsx("div", { style: { fontSize: "15px", marginTop: "10px" }, children: SDKUI_Localizator.NoDcmtFound }), openAddDocumentForm && _jsx("div", { style: { marginTop: "10px" }, children: _jsx(TMButton, { fontSize: "15px", icon: _jsx("i", { className: 'dx-icon-share' }), caption: SDKUI_Localizator.Share, onClick: openAddDocumentForm }) })] })
+        :
+            _jsxs(_Fragment, { children: [_jsxs(TMLayoutItem, { height: '100%', children: [_jsxs(TMSplitterLayout, { direction: 'horizontal', overflow: 'visible', separatorSize: Gutters.getGutters(), separatorActiveColor: 'transparent', separatorColor: 'transparent', min: ['0', '0'], showSeparator: showSelector && deviceType !== DeviceType.MOBILE, start: showSelector ? deviceType !== DeviceType.MOBILE ? ['30%', '70%'] : splitterSize : ['0%', '100%'], children: [showSelector ?
+                                        _jsx(TMLayoutItem, { children: _jsx(TMSearchResultSelector, { searchResults: currentSearchResults, disableAccordionIfSingleCategory: disableAccordionIfSingleCategory, selectedTID: selectedSearchResultTID, onSelectionChanged: onSearchResultSelectionChanged }) })
+                                        :
+                                            _jsx(_Fragment, {}), _jsxs(TMLayoutItem, { children: [_jsx(TMSearchResultGrid, { showSearch: showSearch, inputFocusedItem: focusedItem, inputSelectedItems: selectedItems, searchResult: searchResults.length > 1 ? selectedSearchResult : searchResults[0], lastUpdateSearchTime: lastUpdateSearchTime, openInOffice: openInOffice, onDblClick: () => openFormHandler(LayoutModes.Update), onContextMenuPreparing: onContextMenuPreparing, onSelectionChanged: (items) => { setSelectedItems(items); }, onVisibleItemChanged: setVisibleItems, onFocusedItemChanged: setFocusedItem, onDownloadDcmtsAsync: async (inputDcmts, downloadType, downloadMode, _y, confirmAttachments) => await downloadDcmtsAsync(inputDcmts, downloadType, downloadMode, onFileOpened, confirmAttachments), showExportForm: showExportForm, onCloseExportForm: onCloseExportForm }), allowFloatingBar && showFloatingBar && deviceType !== DeviceType.MOBILE &&
+                                                _jsxs(TMFloatingToolbar, { backgroundColor: TMColors.primaryColor, initialLeft: '10px', initialTop: 'calc(100% - 75px)', children: [fromDTD?.perm?.canRetrieveFile === AccessLevels.Yes && _jsx(TMButton, { btnStyle: 'icon', caption: "Download file", disabled: fromDTD?.perm?.canRetrieveFile !== AccessLevels.Yes || !focusedItem?.DID, icon: _jsx(IconDownload, { color: 'white' }), onClick: () => { downloadDcmtsAsync(getSelectedDcmtsOrFocused(selectedItems, focusedItem), DownloadTypes.Dcmt, "download"); } }), allowRelations && _jsx(TMButton, { btnStyle: 'icon', disabled: !currentTIDHasDetailRelations || !focusedItem?.DID, icon: _jsx(IconDetailDcmts, { color: 'white' }), caption: SDKUI_Localizator.DcmtsDetail, onClick: () => setIsOpenDetails(true) }), allowRelations && _jsx(TMButton, { btnStyle: 'icon', disabled: !currentTIDHasMasterRelations || !focusedItem?.DID, icon: _jsx(IconDetailDcmts, { color: 'white', transform: 'scale(-1, 1)' }), caption: SDKUI_Localizator.DcmtsMaster, onClick: () => setIsOpenMaster(true) }), _jsx(IconMenuVertical, { id: `commands-floating-${id}`, color: 'white', cursor: 'pointer' }), _jsx(TMCommandsContextMenu, { target: `#commands-floating-${id}`, showEvent: "click", menuItems: getCommandsMenuItems(isMobile, fromDTD, selectedItems, focusedItem, context, showFloatingBar, workingGroupContext, showSearch, setShowFloatingBar, openFormHandler, downloadDcmtsAsync, runOperationAsync, onRefreshSearchAsync, refreshSelectionDataRowsAsync, onRefreshAfterAddDcmtToFavs, confirmFormat, openConfirmAttachmentsDialog, openTaskFormHandler, openDetailDcmtsFormHandler, openMasterDcmtsFormHandler, openBatchUpdateFormHandler, openExportForm, handleToggleSearch, handleSignApprove, openWGsCopyMoveForm, openCommentFormCallback, openEditPdf, openAddDocumentForm, passToArchiveCallback, archiveMasterDocuments, archiveDetailDocuments, currentTIDHasMasterRelations, currentTIDHasDetailRelations, canArchiveMasterRelation, canArchiveDetailRelation, pairManyToMany) })] })] })] }), showApprovePopup && _jsx(WorkFlowApproveRejectPopUp, { deviceType: deviceType, onCompleted: onWFOperationCompleted, selectedItems: getSelectedDcmtsOrFocused(selectedItems, focusedItem), isReject: 0, onClose: () => setShowApprovePopup(false) }), showRejectPopup && _jsx(WorkFlowApproveRejectPopUp, { deviceType: deviceType, onCompleted: onWFOperationCompleted, selectedItems: getSelectedDcmtsOrFocused(selectedItems, focusedItem), isReject: 1, onClose: () => setShowRejectPopup(false) }), showReAssignPopup && _jsx(WorkFlowReAssignPopUp, { deviceType: deviceType, onCompleted: onWFOperationCompleted, selectedItems: getSelectedDcmtsOrFocused(selectedItems, focusedItem), onClose: () => setShowReAssignPopup(false) }), showMoreInfoPopup && _jsx(WorkFlowMoreInfoPopUp, { TID: focusedItem?.TID, DID: focusedItem?.DID, deviceType: deviceType, onCompleted: onWFOperationCompleted, onClose: () => setShowMoreInfoPopup(false) }), isOpenBatchUpdate && _jsx(TMBatchUpdateForm, { isModal: true, titleModal: `${SDKUI_Localizator.BatchUpdate} (${getSelectionDcmtInfo().length} documenti selezionati)`, inputDcmts: getSelectionDcmtInfo(), TID: focusedItem ? focusedItem?.TID : selectedItems[0]?.TID, DID: focusedItem ? focusedItem?.DID : selectedItems[0]?.DID, onBack: () => {
+                                    setIsOpenBatchUpdate(false);
+                                }, onSavedCallbackAsync: async () => {
+                                    setIsOpenBatchUpdate(false);
+                                    setIsModifiedBatchUpdate(false);
+                                    await refreshSelectionDataRowsAsync();
+                                }, onStatusChanged: (isModified) => { setIsModifiedBatchUpdate(isModified); } }), (showToppyForApprove && !showApprovePopup && !showRejectPopup && !showReAssignPopup && !showMoreInfoPopup && !openS4TViewer && !showTodoDcmtForm) &&
+                                _jsx(ToppyHelpCenter, { deviceType: deviceType, content: _jsx("div", { style: { display: 'flex', flexDirection: 'column', gap: '10px' }, children: _jsx(WorkFlowOperationButtons, { deviceType: deviceType, onApprove: () => setShowApprovePopup(true), onSignApprove: handleSignApprove, onReject: () => setShowRejectPopup(true), onReAssign: () => setShowReAssignPopup(true), onMoreInfo: () => setShowMoreInfoPopup(true), approveDisable: disable, signApproveDisable: disableSignApproveDisable, rejectDisable: disable, reassignDisable: disable, infoDisable: getSelectedDcmtsOrFocused(selectedItems, focusedItem).length !== 1 }) }) })] }), _jsx(ConfirmFormatDialog, {}), _jsx(ConfirmAttachmentsDialog, {}), showRelatedDcmtsChooser &&
+                        _jsx(TMChooserForm, { dataSource: relatedDcmtsChooserDataSource, onChoose: async (selectedRelation) => {
+                                try {
+                                    setShowRelatedDcmtsChooser(false);
+                                    TMSpinner.show({ description: SDKUI_Localizator.Loading });
+                                    const relation = relatedDcmts?.find(r => r.id === selectedRelation[0]);
+                                    if (!relation || !archiveType)
+                                        return;
+                                    archiveRelatedDcmtHandler(relation, archiveType);
+                                }
+                                catch (error) {
+                                    TMExceptionBoxManager.show({ exception: error });
+                                }
+                                finally {
+                                    TMSpinner.hide();
+                                }
+                            }, onClose: () => setShowRelatedDcmtsChooser(false), manageUseLocalizedName: false }), showManyToManyChooser &&
+                        _jsx(TMChooserForm, { dataSource: manyToManyChooserDataSource, onChoose: async (selectedRelation) => {
+                                try {
+                                    setShowManyToManyChooser(false);
+                                    TMSpinner.show({ description: SDKUI_Localizator.Loading });
+                                    const relation = manyToManyRelations?.find(r => r.id === selectedRelation[0]);
+                                    if (!relation)
+                                        return;
+                                    await executeManyToManyPairing(relation, isPairingManyToMany);
+                                }
+                                catch (error) {
+                                    TMExceptionBoxManager.show({ exception: error });
+                                }
+                                finally {
+                                    TMSpinner.hide();
+                                }
+                            }, onClose: () => setShowManyToManyChooser(false), manageUseLocalizedName: false }), showPairDcmtsModal &&
+                        _jsx(TMModal, { title: (isPairingManyToMany ? "Abbina" : "Disabbina") + " documenti", onClose: () => setShowPairDcmtsModal(false), children: _jsx(TMSearchResult, { searchResults: pairedSearchResults, onRefreshAfterAddDcmtToFavs: onRefreshAfterAddDcmtToFavs, onRefreshSearchAsync: onRefreshSearchAsync, onFileOpened: onFileOpened, onTaskCreateRequest: onTaskCreateRequest, openWGsCopyMoveForm: openWGsCopyMoveForm, openEditPdf: openEditPdf, openS4TViewer: openS4TViewer, onOpenS4TViewerRequest: onOpenS4TViewerRequest, passToArchiveCallback: passToArchiveCallback, showTodoDcmtForm: showTodoDcmtForm, floatingActionConfig: pairFloatingActionConfig }) }), (floatingActionConfig && floatingActionConfig.isVisible) && _jsx(TMSearchResultFloatingActionButton, { selectedDcmtsOrFocused: getSelectedDcmtsOrFocused(selectedItems, focusedItem), config: floatingActionConfig })] }), [
+        searchResults,
+        selectedSearchResult,
+        lastUpdateSearchTime,
+        focusedItem,
+        selectedItems,
+        fromDTD,
+        currentTIDHasDetailRelations,
+        currentTIDHasMasterRelations,
+        canArchiveMasterRelation,
+        canArchiveDetailRelation,
+        showApprovePopup,
+        showRejectPopup,
+        showReAssignPopup,
+        showFloatingBar,
+        isOpenBatchUpdate,
+        isOpenDetails,
+        isOpenMaster,
+        isOpenDcmtForm,
+        isOpenArchiveRelationForm,
+        showToppyForApprove,
+        floatingActionConfig,
+        disableAccordionIfSingleCategory,
+        getTitleHeader,
+        openS4TViewer,
+        showRelatedDcmtsChooser,
+        relatedDcmts,
+        setShowRelatedDcmtsChooser,
+        relatedDcmtsChooserDataSource,
+        showManyToManyChooser,
+        manyToManyRelations,
+        manyToManyChooserDataSource,
+        showPairDcmtsModal,
+        isPairingManyToMany,
+        pairedSearchResults,
+    ]);
+    const tmBlog = useMemo(() => _jsx(TMDcmtBlog, { tid: focusedItem?.TID, did: focusedItem?.DID }), [focusedItem]);
+    const tmSysMetadata = useMemo(() => _jsx(TMMetadataValues, { layoutMode: LayoutModes.Update, openChooserBySingleClick: true, TID: focusedItem?.TID, isReadOnly: true, deviceType: deviceType, metadataValues: currentMetadataValues.filter(o => (o.mid != undefined && o.mid <= 100)), metadataValuesOrig: currentMetadataValues.filter(o => (o.mid != undefined && o.mid <= 100)), validationItems: [] }), [focusedItem, currentMetadataValues, deviceType]);
+    const tmDcmtPreview = useMemo(() => _jsx(TMDcmtPreviewWrapper, { currentDcmt: currentDcmt }), [currentDcmt]);
+    const allInitialPanelVisibility = {
+        'tmSearchResult': true,
+        'tmBlog': false,
+        'tmSysMetadata': false,
+        'tmDcmtPreview': false,
+    };
+    const initialPanelDimensions = {
+        'tmSearchResult': { width: '25%', height: '100%' },
+        'tmBlog': { width: '25%', height: '100%' },
+        'tmSysMetadata': { width: '25%', height: '100%' },
+        'tmDcmtPreview': { width: '25%', height: '100%' },
+    };
+    const initialPanels = useMemo(() => [
+        {
+            id: 'tmSearchResult',
+            name: getTitleHeader(),
+            contentOptions: {
+                component: tmSearchResult,
+                panelContainer: {
+                    title: getTitleHeader(),
+                    showHeader: showToolbarHeader,
+                    allowMaximize: !isMobile,
+                    onBack: (!isClosable && context === SearchResultContext.METADATA_SEARCH) || (isMobile && context !== SearchResultContext.METADATA_SEARCH && splitterSize[1] === '100%') ? onBack : undefined,
+                    onClose: isClosable ? onBack : undefined,
+                    toolbar: searchResutlToolbar
+                },
+            },
+            toolbarOptions: { icon: _jsx(IconSearchCheck, { fontSize: 24 }), visible: true, orderNumber: 1, isActive: allInitialPanelVisibility['tmSearchResult'] }
+        },
+        {
+            id: 'tmBlog',
+            name: SDKUI_Localizator.BlogCase,
+            contentOptions: { component: tmBlog, panelContainer: { title: SDKUI_Localizator.BlogCase, allowMaximize: !isMobile } },
+            toolbarOptions: { icon: _jsx(IconBoard, { fontSize: 24 }), visible: true, orderNumber: 2, isActive: allInitialPanelVisibility['tmBlog'] }
+        },
+        {
+            id: 'tmSysMetadata',
+            name: SDKUI_Localizator.MetadataSystem,
+            contentOptions: { component: tmSysMetadata, panelContainer: { title: SDKUI_Localizator.MetadataSystem, allowMaximize: !isMobile } },
+            toolbarOptions: { icon: _jsx(IconDcmtTypeSys, { fontSize: 24 }), visible: true, orderNumber: 3, isActive: allInitialPanelVisibility['tmSysMetadata'] }
+        },
+        {
+            id: 'tmDcmtPreview',
+            name: SDKUI_Localizator.PreviewDocument,
+            contentOptions: { component: tmDcmtPreview },
+            toolbarOptions: { icon: _jsx(IconShow, { fontSize: 24 }), visible: true, orderNumber: 4, isActive: allInitialPanelVisibility['tmDcmtPreview'] }
+        }
+    ], [tmSearchResult, tmBlog, tmSysMetadata, tmDcmtPreview, showToolbarHeader]);
+    return (_jsxs(StyledMultiViewPanel, { "$isVisible": isVisible, children: [_jsx(StyledMultiViewPanel, { "$isVisible": !isOpenDcmtForm && !isOpenDetails && !isOpenMaster, style: {
+                    display: 'flex',
+                    flexDirection: isMobile ? 'column' : 'row',
+                    justifyContent: 'space-between',
+                    gap: Gutters.getGutters(),
+                    width: '100%',
+                    height: '100%',
+                }, children: _jsx(TMLayoutWaitingContainer, { direction: 'vertical', showWaitPanel: showWaitPanel, showWaitPanelPrimary: showPrimary, showWaitPanelSecondary: showSecondary, waitPanelTitle: waitPanelTitle, waitPanelTextPrimary: waitPanelTextPrimary, waitPanelValuePrimary: waitPanelValuePrimary, waitPanelMaxValuePrimary: waitPanelMaxValuePrimary, waitPanelTextSecondary: waitPanelTextSecondary, waitPanelValueSecondary: waitPanelValueSecondary, waitPanelMaxValueSecondary: waitPanelMaxValueSecondary, isCancelable: true, abortController: abortController, children: (groupId && groupId.length > 0) ?
+                        _jsx(TMPanelManagerContainer, { panels: initialPanels, direction: "horizontal", parentId: groupId, showToolbar: showSearchResultSidebar })
+                        :
+                            _jsx(TMPanelManagerProvider, { panels: initialPanels, initialVisibility: allInitialPanelVisibility, defaultDimensions: initialPanelDimensions, initialDimensions: initialPanelDimensions, initialMobilePanelId: 'tmSearchResult', children: _jsx(TMPanelManagerContainer, { panels: initialPanels, direction: "horizontal", parentId: groupId, showToolbar: showSearchResultSidebar }) }) }) }), _jsx(StyledMultiViewPanel, { "$isVisible": isOpenDetails, children: isOpenDetails && _jsx(TMMasterDetailDcmts, { deviceType: deviceType, isForMaster: false, inputDcmts: getSelectionDcmtInfo(), allowNavigation: focusedItem && selectedItems.length <= 0, canNext: canNavigateHandler('next'), canPrev: canNavigateHandler('prev'), onNext: () => onNavigateHandler('next'), onPrev: () => onNavigateHandler('prev'), onBack: () => setIsOpenDetails(false) }) }), _jsxs(StyledMultiViewPanel, { "$isVisible": isOpenMaster, children: [isOpenMaster && _jsx(TMMasterDetailDcmts, { deviceType: deviceType, inputDcmts: getSelectionDcmtInfo(), isForMaster: true, allowNavigation: focusedItem && selectedItems.length <= 0, canNext: canNavigateHandler('next'), canPrev: canNavigateHandler('prev'), onNext: () => onNavigateHandler('next'), onPrev: () => onNavigateHandler('prev'), onBack: () => setIsOpenMaster(false), appendMasterDcmts: handleAddItem }), secondaryMasterDcmts.length > 0 && secondaryMasterDcmts.map((dcmt, index) => {
+                        return (_jsx(StyledModalContainer, { style: { backgroundColor: 'white' }, children: _jsx(TMMasterDetailDcmts, { deviceType: deviceType, inputDcmts: [dcmt], isForMaster: true, allowNavigation: false, onBack: () => handleRemoveItem(dcmt.TID, dcmt.DID), appendMasterDcmts: handleAddItem }) }, `${index}-${dcmt.DID}`));
+                    })] }), _jsx(StyledMultiViewPanel, { "$isVisible": isOpenDcmtForm, children: isOpenDcmtForm && _jsx(TMDcmtForm, { isModal: openDcmtFormAsModal || (dcmtFormLayoutMode === LayoutModes.Ark && focusedItem?.DID), titleModal: fromDTD?.name ?? '', TID: focusedItem?.TID, DID: focusedItem?.DID, layoutMode: dcmtFormLayoutMode, count: visibleItems.length, itemIndex: visibleItems.findIndex(o => o.rowIndex === focusedItem?.rowIndex) + 1, canNext: canNavigateHandler('next'), canPrev: canNavigateHandler('prev'), onNext: () => onNavigateHandler('next'), onPrev: () => onNavigateHandler('prev'), onClose: () => { setIsOpenDcmtForm(false); }, onWFOperationCompleted: onWFOperationCompleted, onTaskCreateRequest: onTaskCreateRequest, onSavedAsyncCallback: async (tid, did, metadataResult) => {
+                        await refreshFocusedDataRowAsync(tid, did, true, metadataResult);
+                    }, onOpenS4TViewerRequest: onOpenS4TViewerRequest }) }), isOpenArchiveRelationForm && _jsx(TMDcmtForm, { isModal: true, titleModal: SDKUI_Localizator.Archive + ' - ' + (archiveType === 'detail' ? SDKUI_Localizator.DcmtsDetail : SDKUI_Localizator.DcmtsMaster), TID: archiveRelatedDcmtFormTID, layoutMode: LayoutModes.Ark, inputMids: archiveRelatedDcmtFormMids, onClose: () => {
+                    setIsOpenArchiveRelationForm(false);
+                    setArchiveType(undefined);
+                    setArchiveRelatedDcmtFormTID(undefined);
+                    setArchiveRelatedDcmtFormMids([]);
+                }, onSavedAsyncCallback: async (tid, did, metadataResult) => {
+                    setIsOpenArchiveRelationForm(false);
+                    setArchiveType(undefined);
+                    setArchiveRelatedDcmtFormTID(undefined);
+                    setArchiveRelatedDcmtFormMids([]);
+                    await onRefreshSearchAsync?.();
+                } })] }));
+};
+export default TMSearchResult;
+const renderDcmtIcon = (cellData, onDownloadDcmtsAsync, openInOffice) => _jsx(TMDcmtIcon, { tid: cellData.data.TID, did: cellData.data.DID, fileExtension: cellData.data.FILEEXT, fileCount: cellData.data.FILECOUNT, isLexProt: cellData.data.IsLexProt, isMail: cellData.data.ISMAIL, isShared: cellData.data.ISSHARED, isSigned: cellData.data.ISSIGNED, downloadMode: 'openInNewWindow', onDownloadDcmtsAsync: onDownloadDcmtsAsync, openInOffice: openInOffice });
+const TMSearchResultGrid = ({ openInOffice, inputFocusedItem, showSearch, allowMultipleSelection = true, showExportForm = false, onCloseExportForm, onFocusedItemChanged, onDownloadDcmtsAsync, onVisibleItemChanged, inputSelectedItems = [], lastUpdateSearchTime, searchResult, onContextMenuPreparing, onSelectionChanged, onDblClick }) => {
+    const [dataSource, setDataSource] = useState();
+    const [columns, setColumns] = useState([]);
+    // State to store selected row keys
+    const [selectedRowKeys, setSelectedRowKeys] = useState([]);
+    const [focusedItem, setFocusedItem] = useState();
+    const [visibleItems, setVisibleItems] = useState([]);
+    useEffect(() => {
+        if (deepCompare(inputFocusedItem, focusedItem))
+            return;
+        setFocusedItem(inputFocusedItem);
+    }, [inputFocusedItem]);
+    useEffect(() => {
+        const inputSelectedItemsRowIndex = inputSelectedItems.map(e => e.rowIndex);
+        if (JSON.stringify(inputSelectedItemsRowIndex) === JSON.stringify(selectedRowKeys))
+            return;
+        setSelectedRowKeys(inputSelectedItemsRowIndex);
+    }, [inputSelectedItems]);
+    const onKeyDown = useCallback((e) => {
+        // Check if the pressed key is the "Delete" key.
+        if (e.event?.key === 'Delete' && !showExportForm) {
+            // Get the selected or focused documents/items from the grid.
+            const dcmts = getSelectedDcmtsOrFocused(inputSelectedItems, inputFocusedItem);
+            // If there are no selected or focused items, do nothing.
+            if (dcmts === undefined || dcmts.length === 0)
+                return;
+            // --- CASE 1: Only one item selected ---
+            if (dcmts.length === 1) {
+                const current = dcmts[0];
+                // If the selected item has a row index (valid entry)
+                if (current.rowIndex !== undefined) {
+                    TMSpinner.show({ description: SDKUI_Localizator.RemovingFromList });
+                    const currentDataSource = dataSource ?? [];
+                    setTimeout(() => {
+                        // Remove the selected item from the data source by filtering it out.
+                        setDataSource(currentDataSource.filter((data) => data.rowIndex !== current.rowIndex));
+                        // Clear any selection, focused item, and update callbacks.
+                        onSelectionChanged?.([]);
+                        setSelectedRowKeys([]);
+                        onFocusedItemChanged?.(undefined);
+                        setFocusedItem(undefined);
+                        TMSpinner.hide();
+                    }, 500);
+                }
+                return;
+            }
+            // --- CASE 2: Multiple items selected ---
+            if (dcmts.length > 1) {
+                // Show a confirmation message box before deleting multiple items.
+                TMMessageBoxManager.show({
+                    buttons: [ButtonNames.YES, ButtonNames.NO],
+                    title: SDKUI_Localizator.RemoveFromList,
+                    message: `${SDKUI_Localizator.ConfirmSelectedDocumentsMessage.replaceParams(dcmts.length)}`,
+                    confirmOnEnter: true,
+                    onButtonClick(e) {
+                        // Only proceed if user clicks "YES"
+                        if (e !== ButtonNames.YES)
+                            return;
+                        TMSpinner.show({ description: SDKUI_Localizator.RemovingFromList });
+                        const currentDataSource = dataSource ?? [];
+                        setTimeout(() => {
+                            // Remove all selected items from the data source.
+                            setDataSource(currentDataSource.filter((data) => !dcmts.some((d) => d.rowIndex === data.rowIndex)));
+                            // Clear selections and focus after deletion.
+                            onSelectionChanged?.([]);
+                            setSelectedRowKeys([]);
+                            onFocusedItemChanged?.(undefined);
+                            setFocusedItem(undefined);
+                            TMSpinner.hide();
+                        }, 500);
+                    },
+                });
+            }
+        }
+    }, [inputSelectedItems, inputFocusedItem, dataSource]);
+    const cellRender = useCallback((cellData, dataDomain, dataListID, dataListViewMode) => {
+        if (!cellData || cellData.value === undefined)
+            return null;
+        const isLogDel = cellData.data.ISLOGDEL == 1;
+        const isLexProt = cellData.data.IsLexProt == 1;
+        let style = {};
+        if (isLogDel) {
+            style = { color: 'gray', textDecoration: 'line-through' };
+        }
+        else if (isLexProt)
+            style = { color: 'blue' };
+        let child = _jsx("div", { children: cellData.text });
+        if (dataDomain === MetadataDataDomains.DataList) {
+            child = _jsx(TMDataListItemViewer, { dataListId: dataListID, viewMode: dataListViewMode, value: cellData.value });
+        }
+        if (dataDomain === MetadataDataDomains.UserID) {
+            child = _jsx(TMUserIdViewer, { userId: cellData.value, showIcon: true, noneSelectionText: '' });
+        }
+        return _jsx("div", { style: style, children: child });
+    }, []);
+    const dataType = useCallback((col) => {
+        switch (col.dataType) {
+            case DataColumnTypes.DateTime: return "datetime";
+            case DataColumnTypes.Bool: return "boolean";
+            case DataColumnTypes.Number: return "number";
+            default: return "string";
+        }
+    }, []);
+    const getDisplayFormat = useCallback((col) => {
+        if (col.dataType === DataColumnTypes.Text)
+            return undefined;
+        const format = MetadataFormats[(col.extendedProperties?.["Format"] ?? "None")];
+        const formatCulture = col.extendedProperties?.["FormatCulture"] ?? window.navigator.language;
+        if (col.dataType === DataColumnTypes.DateTime) {
+            return {
+                formatter: function (value) {
+                    switch (format) {
+                        case MetadataFormats.ShortDate: return value.toLocaleString(formatCulture, formatCulture == "it-IT" ? { year: "numeric", month: "2-digit", day: "2-digit" } : { dateStyle: 'short' });
+                        case MetadataFormats.ShortTime: return value.toLocaleString(formatCulture, { timeStyle: 'short' });
+                        case MetadataFormats.ShortDateLongTime: return value.toLocaleString(formatCulture, formatCulture == "it-IT" ? { year: "numeric", month: "2-digit", day: "2-digit", hour: '2-digit', minute: '2-digit', second: '2-digit' } : { dateStyle: 'short', timeStyle: 'medium' }).replace(',', '');
+                        case MetadataFormats.ShortDateShortTime: return value.toLocaleString(formatCulture, formatCulture == "it-IT" ? { year: "numeric", month: "2-digit", day: "2-digit", hour: '2-digit', minute: '2-digit' } : { dateStyle: 'short', timeStyle: 'short' }).replace(',', '');
+                        case MetadataFormats.LongDate: return value.toLocaleString(formatCulture, { weekday: "long", year: "numeric", month: "long", day: "numeric" });
+                        case MetadataFormats.LongTime: return value.toLocaleString(formatCulture, { timeStyle: 'medium' });
+                        case MetadataFormats.LongDateLongTime: return value.toLocaleString(formatCulture, { weekday: "long", year: "numeric", month: "long", day: "numeric", hour: '2-digit', minute: '2-digit', second: '2-digit' });
+                        case MetadataFormats.LongDateShortTime: return value.toLocaleString(formatCulture, { weekday: "long", year: "numeric", month: "long", day: "numeric", hour: '2-digit', minute: '2-digit' });
+                        default: return value.toLocaleString(formatCulture, formatCulture == "it-IT" ? { year: "numeric", month: "2-digit", day: "2-digit" } : { dateStyle: 'short' });
+                    }
+                }
+            };
+        }
+        if (col.dataType === DataColumnTypes.Number) {
+            return {
+                formatter: function (value) {
+                    return value.toLocaleString(formatCulture, { useGrouping: format == MetadataFormats.NumberWithThousandsSeparator });
+                }
+            };
+        }
+        if (format == MetadataFormats.None)
+            return undefined;
+        if (format == MetadataFormats.CurrencyEuro)
+            return { type: 'currency', precision: 2, currency: "EUR" };
+        if (format == MetadataFormats.CurrencyDollar)
+            return { type: 'currency', precision: 2, currency: "USD" };
+        if (format == MetadataFormats.CurrencyPound)
+            return { type: 'currency', precision: 2, currency: "GBP" };
+        if (format == MetadataFormats.CurrencyYen)
+            return { type: 'currency', currency: "JPY" };
+        return undefined;
+    }, []);
+    useEffect(() => {
+        setFocusedItem(undefined); // resetta sempre prima
+        let cols = [];
+        searchResult?.dtdResult?.columns?.map((col, index) => {
+            let keyField = getDataColumnName(searchResult?.fromTID, col);
+            const isVisible = col.extendedProperties?.["Visibility"] != "Hidden";
+            const dataDomain = MetadataDataDomains[(col.extendedProperties?.["DataDomain"] ?? "None")];
+            const dataListID = Number(col.extendedProperties?.["DataListID"]);
+            const dataListViewMode = DataListViewModes[(col.extendedProperties?.["DataListViewMode"] ?? "None")];
+            cols.push({
+                dataField: keyField,
+                dataType: dataType(col),
+                visible: isVisible,
+                cellRender: (cellData) => cellRender(cellData, dataDomain, dataListID, dataListViewMode),
+                caption: col.caption,
+                format: getDisplayFormat(col),
+            });
+        });
+        setColumns(cols);
+        let newDataSource = searchResultDescriptorToSimpleArray(searchResult);
+        setDataSource(newDataSource);
+        // setFocusedItem(newDataSource && newDataSource.length > 0 ? newDataSource[0] : undefined);
+    }, [searchResult]);
+    useEffect(() => {
+        let newDataSource = searchResultDescriptorToSimpleArray(searchResult);
+        setDataSource(newDataSource);
+        // setFocusedItem(newDataSource?.find(o => o?.rowIndex === focusedItem?.rowIndex));
+    }, [lastUpdateSearchTime]);
+    // Handles selection change in the data grid
+    const handleSelectionChange = useCallback((e) => {
+        if (onSelectionChanged === undefined)
+            return;
+        const selectedRowsData = e.component.getSelectedRowsData() ?? [];
+        onSelectionChanged(selectedRowsData);
+    }, [onSelectionChanged]);
+    // Handles focus change in the data grid
+    const handleFocusedRowChange = useCallback((e) => {
+        // if (setFocusedItem === undefined) return;
+        // if (e.row === undefined) { setFocusedItem(undefined); return; }
+        // setFocusedItem(e.row.data);
+        onFocusedItemChanged?.(e.row?.data);
+    }, [setFocusedItem]);
+    // useEffect(() => {
+    //     onFocusedItemChanged?.(focusedItem)
+    // }, [focusedItem])
+    // Handler for double-click row event
+    const onRowDblClick = useCallback((e) => {
+        if (onDblClick === undefined)
+            return;
+        if (e.data === undefined)
+            return;
+        if (e.event?.target.closest('.tm-dcmt-icon')) {
+            // Era sull'icona, non fare nulla
+            return;
+        }
+        // setFocusedItem(e.data);
+        onFocusedItemChanged?.(e.data);
+        onDblClick();
+    }, [onDblClick]);
+    const dataColumns = useMemo(() => {
+        return [
+            {
+                dataType: "object",
+                dataField: 'FILEEXT',
+                caption: '',
+                visible: true,
+                width: 50,
+                cellRender: (cellData) => renderDcmtIcon(cellData, onDownloadDcmtsAsync, openInOffice),
+                allowResizing: false,
+                filterOperations: ['=']
+            },
+            ...columns.filter(col => col.dataField !== 'FILEEXT')
+        ];
+    }, [columns, onDownloadDcmtsAsync, openInOffice]);
+    const onContentReady = useCallback((e) => {
+        if (e === undefined)
+            return;
+        if (setVisibleItems === undefined)
+            return;
+        const visibleRows = e.component.getVisibleRows();
+        setVisibleItems(visibleRows.map((row) => { return row.data; }));
+    }, []);
+    useEffect(() => { onVisibleItemChanged?.(visibleItems); }, [visibleItems]);
+    return _jsxs("div", { style: { width: "100%", height: "100%" }, children: [_jsx(TMDataGrid, { id: "tm-search-result", keyExpr: "rowIndex", dataColumns: dataColumns, dataSource: dataSource, repaintChangesOnly: true, selectedRowKeys: selectedRowKeys, focusedRowKey: Number(focusedItem?.rowIndex ?? 0), showSearchPanel: showSearch, showFilterPanel: true, sorting: { mode: "multiple" }, selection: { mode: allowMultipleSelection ? 'multiple' : 'single' }, pageSize: TMDataGridPageSize.Small, onSelectionChanged: handleSelectionChange, onFocusedRowChanged: handleFocusedRowChange, onRowDblClick: onRowDblClick, onContentReady: onContentReady, onContextMenuPreparing: onContextMenuPreparing, onKeyDown: onKeyDown, counterConfig: { show: true } }), (showExportForm && searchResult && onCloseExportForm) && _jsx(TMDataGridExportForm, { dataColumns: dataColumns, dataSource: dataSource, selectedRowKeys: selectedRowKeys, onCloseExportForm: onCloseExportForm, searchResult: searchResult })] });
+};
+//#region TMSearchResultSelector
+const StyledItemTemplate = styled.div ` 
+    background: ${(props) => props.$isSelected ? 'oklch(from var(--dx-color-primary) l c h / .2) !important' : 'transparent'};
+    cursor: pointer; 
+`;
+const MemoizedStyledItemTemplate = React.memo(StyledItemTemplate);
+const TMSearchResultSelector = ({ searchResults = [], disableAccordionIfSingleCategory = false, selectedTID, onSelectionChanged }) => {
+    const [selectedResult, setSelectedResult] = useState(undefined);
+    /**  Group results by category */
+    const groupedResults = useMemo(() => {
+        return searchResults.reduce((acc, result) => {
+            const category = result.category ?? 'Uncategorized';
+            if (!acc[category])
+                acc[category] = [];
+            acc[category].push(result);
+            return acc;
+        }, {});
+    }, [searchResults]);
+    /** Sort categories alphabetically */
+    const sortedCategories = useMemo(() => {
+        const cats = Object.keys(groupedResults);
+        cats.forEach((category) => {
+            groupedResults[category].sort((a, b) => (a.fromName ?? '').localeCompare(b.fromName ?? ''));
+        });
+        return cats.sort((a, b) => a.localeCompare(b));
+    }, [groupedResults]);
+    /** Sort items within each category alphabetically by fromName */
+    sortedCategories.forEach((category) => {
+        groupedResults[category].sort((a, b) => (a.fromName ?? '').localeCompare(b.fromName ?? ''));
+    });
+    useEffect(() => {
+        if (sortedCategories.length > 0) {
+            const firstCategory = sortedCategories[0];
+            if (groupedResults[firstCategory].length > 0) {
+                setSelectedResult(groupedResults[firstCategory][0]);
+                onSelectionChanged?.(groupedResults[firstCategory][0]);
+            }
+        }
+    }, [sortedCategories.length]);
+    useEffect(() => {
+        if (selectedTID !== undefined) {
+            const found = searchResults.find(r => Number(r.fromTID) === selectedTID);
+            handleSelect(found);
+        }
+    }, [selectedTID, searchResults]);
+    const handleSelect = useCallback((result) => {
+        if (selectedResult !== result && result !== undefined) {
+            setSelectedResult(result);
+            onSelectionChanged?.(result);
+        }
+    }, [selectedResult, onSelectionChanged]);
+    const resultDcmtCounter = (category) => {
+        let dcmts = searchResults.filter(res => res?.category === category || (res?.category === undefined && category === "Uncategorized"));
+        if (!dcmts)
+            return 0;
+        let counter = 0;
+        for (let dcmt of dcmts) {
+            counter += dcmt.dcmtsFound ?? 0;
+        }
+        return counter;
+    };
+    const getHeaderTitle = (category) => {
+        switch (category) {
+            case "RecentArchive": return SDKUI_Localizator.RecentDocs_Archived;
+            case "RecentView": return SDKUI_Localizator.RecentDocs_Visualized;
+            case "WFAppr": return SDKUI_Localizator.WorkflowApproval;
+            case "Favorites": return SDKUI_Localizator.Favorites;
+            case "FullText": return 'Full text';
+            case "Uncategorized": return "";
+            default: return category;
+        }
+    };
+    const renderItemTemplate = useCallback((data) => (_jsxs("div", { style: { width: '100%', padding: '5px', display: 'flex', alignItems: 'center', justifyContent: 'space-between' }, children: [_jsx(TMTidViewer, { tid: data.fromTID, did: Number(data.dtdResult?.rows?.[0]?.[1]), showIcon: true, color: TMColors.primary }), _jsx("div", { style: { padding: 3, display: 'flex', alignItems: 'center', justifyContent: 'center', backgroundColor: 'white', color: 'gray', borderRadius: 3 }, children: data.dcmtsReturned })] })), []);
+    const renderCategoryItems = (category) => (_jsx("div", { style: { padding: '5px' }, children: groupedResults[category].map((result, index) => (_jsx(MemoizedStyledItemTemplate, { "$isSelected": selectedResult === result, onClick: () => handleSelect(result), children: renderItemTemplate(result) }, index))) }));
+    if (disableAccordionIfSingleCategory && sortedCategories.length === 1) {
+        const category = sortedCategories[0];
+        return renderCategoryItems(category);
+    }
+    return (_jsx("div", { style: { height: '100%', width: '100%', overflow: 'auto' }, children: sortedCategories.map((category, index) => (_jsx(TMAccordion, { title: getHeaderTitle(category), titleSize: 'Small', firstCounter: _jsx(TMTooltip, { content: 'Numero di tipi documento', children: _jsx(StyledBadge, { style: { width: 'max-content' }, "$backgroundColor": TMColors.primaryColor, children: searchResults.length > 1 && searchResults?.filter(data => data.category === category || (data?.category === undefined && category === "Uncategorized")).length }) }), secondCounter: _jsx(TMTooltip, { content: 'Numero di tutti documenti', children: _jsx(StyledBadge, { style: { width: 'max-content' }, "$backgroundColor": TMColors.tertiary, children: resultDcmtCounter(category) }) }), defaultOpen: (index === 0), children: renderCategoryItems(category) }, category))) }));
+};
+//#endregion TMSearchResultSelector
+const TMDcmtPreviewWrapper = ({ currentDcmt, isVisible }) => {
+    const { setPanelVisibilityById, toggleMaximize, isResizingActive, countVisibleLeafPanels } = useTMPanelManagerContext();
+    const deviceType = useDeviceType();
+    const isMobile = deviceType === DeviceType.MOBILE;
+    return (_jsx(TMDcmtPreview, { onClosePanel: (!isMobile && countVisibleLeafPanels() > 1) ? () => setPanelVisibilityById('tmDcmtPreview', false) : undefined, allowMaximize: !isMobile && countVisibleLeafPanels() > 1, onMaximizePanel: (!isMobile && countVisibleLeafPanels() > 1) ? () => toggleMaximize("tmDcmtPreview") : undefined, dcmtData: currentDcmt, isResizingActive: isResizingActive, isVisible: isVisible }));
+};