@topconsultnpm/sdkui-react 6.21.0-t2 → 6.21.0-t4

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

@@ -1,4 +1,5 @@
 import React from 'react';
+import { MetadataDescriptor } from '@topconsultnpm/sdk-ts';
 import { DcmtInfo } from '../../../ts';
 import { DocumentDownloadSettings, FileNamingMode } from '../../../helper';
 import { IRelatedDcmt } from './TMMasterDetailDcmts';
@@ -19,19 +20,6 @@ export declare const isDirectoryPickerSupported: () => boolean;
  * il file viene restituito senza firma.
  */
 export declare const isPdfExt: (ext: string | null | undefined) => boolean;
-/**
- * Estrae l'estensione completa da un nome file, gestendo estensioni composite
- * a più livelli come .PDF.P7M, .XML.P7M.TS, etc.
- *
- * Esempi:
- * - "documento.pdf" -> ".pdf"
- * - "DCMT_123.PDF.P7M" -> ".PDF.P7M"
- * - "fattura.xml.p7m" -> ".xml.p7m"
- * - "example.XML.P7M.TS" -> ".XML.P7M.TS"
- * - "file.tar.gz" -> ".gz" (tar.gz non è gestito come firma)
- * - "file" -> ""
- */
-export declare const getFullFileExtension: (fileName: string, depth?: number) => string;
 /**
  * Estrae il nome base del file (senza estensione completa).
  * Gestisce estensioni composite come .PDF.P7M
@@ -45,9 +33,9 @@ export declare const fileExists: (dirHandle: FileSystemDirectoryHandle, fileName
 export declare const generateUniqueFileName: (dirHandle: FileSystemDirectoryHandle, originalName: string) => Promise<string>;
 /** Recupera il nome leggibile del tipo documento (cache) */
 export declare const getTypeName: (tid: number | undefined) => Promise<string>;
-/** Formatta un valore convertendo le date in formato dd-MM-yyyy [HH-mm-ss] */
-export declare const formatMetadataValue: (value: string) => string;
-/** Recupera i metadati filtrati (primi 5 con mid > 100 e valore presente), concatenati con separatorChar */
+/** Formatta un valore convertendo le date secondo il formato specificato in MetadataDescriptor.format */
+export declare const formatMetadataValue: (value: string, md?: MetadataDescriptor) => string;
+/** Recupera i metadati filtrati usando buildDcmtDisplayName, concatenati con separatorChar */
 export declare const getFilteredMetadata: (tid: number, did: number, separatorChar: string) => Promise<string | null>;
 /** Opzioni di naming necessarie per generare il nome del file di destinazione */
 export interface IFileNamingOptions {

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

@@ -1,5 +1,5 @@
-import { DcmtTypeListCacheService, LayoutModes, SDK_Globals } from '@topconsultnpm/sdk-ts';
-import { searchResultToMetadataValues, DocumentDownloadSettings } from '../../../helper';
+import { DcmtTypeListCacheService, LayoutModes, MetadataDataTypes, MetadataFormats, SDK_Globals } from '@topconsultnpm/sdk-ts';
+import { searchResultToMetadataValues, DocumentDownloadSettings, getFullFileExtension, buildDcmtDisplayName } from '../../../helper';
 import { TMColors } from '../../../utils/theme';
 /** Numero minimo di file PDF necessari per poterli unire in un unico documento. */
 export const MIN_PDF_FOR_MERGE = 2;
@@ -61,44 +61,6 @@ export const isPdfExt = (ext) => {
     const normalized = ext.trim().toLowerCase().replace(/^\./, '');
     return normalized === 'pdf' || normalized === 'pdf.p7m' || normalized === 'pdf.tsd' || normalized === 'pdf.m7m';
 };
-/**
- * Estensioni di firma/marca temporale note che possono avvolgere altre estensioni.
- * Es: file.pdf.p7m, file.xml.p7m, file.docx.p7m, file.xml.p7m.ts
- */
-const SIGNATURE_EXTENSIONS = new Set(['p7m', 'p7s', 'm7m', 'tsd', 'tsr', 'ts']);
-/** Profondità massima di ricorsione per la ricerca di estensioni composite */
-const MAX_EXTENSION_DEPTH = 5;
-/**
- * Estrae l'estensione completa da un nome file, gestendo estensioni composite
- * a più livelli come .PDF.P7M, .XML.P7M.TS, etc.
- *
- * Esempi:
- * - "documento.pdf" -> ".pdf"
- * - "DCMT_123.PDF.P7M" -> ".PDF.P7M"
- * - "fattura.xml.p7m" -> ".xml.p7m"
- * - "example.XML.P7M.TS" -> ".XML.P7M.TS"
- * - "file.tar.gz" -> ".gz" (tar.gz non è gestito come firma)
- * - "file" -> ""
- */
-export const getFullFileExtension = (fileName, depth = 0) => {
-    if (!fileName || depth > MAX_EXTENSION_DEPTH)
-        return '';
-    const lastDotIndex = fileName.lastIndexOf('.');
-    if (lastDotIndex <= 0)
-        return '';
-    const lastExtension = fileName.substring(lastDotIndex + 1).toLowerCase();
-    // Se l'ultima estensione è una firma/marca, cerca ricorsivamente le estensioni precedenti
-    if (SIGNATURE_EXTENSIONS.has(lastExtension)) {
-        const nameWithoutLastExt = fileName.substring(0, lastDotIndex);
-        const innerExtension = getFullFileExtension(nameWithoutLastExt, depth + 1);
-        if (innerExtension) {
-            // Concatena l'estensione interna con quella corrente
-            return innerExtension + fileName.substring(lastDotIndex);
-        }
-    }
-    // Estensione singola (o estensione base dopo le firme)
-    return fileName.substring(lastDotIndex);
-};
 /**
  * Estrae il nome base del file (senza estensione completa).
  * Gestisce estensioni composite come .PDF.P7M
@@ -120,7 +82,7 @@ export const sanitizeFileName = (fileName, fallbackName, maxLength = 255) => {
         const illegalCharsRegex = /[<>:"/\\|?*]/g;
         const controlCharsRegex = /[\x00-\x1F\x7F]/g;
         let sanitized = fileName
-            .replace(illegalCharsRegex, '_')
+            .replace(illegalCharsRegex, '-')
             .replace(controlCharsRegex, '')
             .trim();
         sanitized = sanitized.replace(/[. ]+$/, '');
@@ -184,27 +146,40 @@ export const getTypeName = async (tid) => {
     const foundDtd = typeList.find(dtd => dtd.id?.toString() === tid?.toString());
     return foundDtd?.name ?? String(tid);
 };
-/** Formatta un valore convertendo le date in formato dd-MM-yyyy [HH-mm-ss] */
-export const formatMetadataValue = (value) => {
+/** Formatta un valore convertendo le date secondo il formato specificato in MetadataDescriptor.format */
+export const formatMetadataValue = (value, md) => {
+    // Formatta come data solo se il MetadataDescriptor indica tipo DateTime
+    if (md?.dataType !== MetadataDataTypes.DateTime) {
+        return value;
+    }
     const date = new Date(value);
-    if (!isNaN(date.getTime())) {
-        const day = date.getDate().toString().padStart(2, '0');
-        const month = (date.getMonth() + 1).toString().padStart(2, '0');
-        const year = date.getFullYear();
-        const hours = date.getHours();
-        const minutes = date.getMinutes();
-        const seconds = date.getSeconds();
-        if (hours !== 0 || minutes !== 0 || seconds !== 0) {
-            const hh = hours.toString().padStart(2, '0');
-            const mm = minutes.toString().padStart(2, '0');
-            const ss = seconds.toString().padStart(2, '0');
-            return `${day}-${month}-${year} ${hh}-${mm}-${ss}`;
-        }
-        return `${day}-${month}-${year}`;
+    if (isNaN(date.getTime())) {
+        return value;
+    }
+    const format = md.format?.format;
+    const formatCulture = md.format?.formatCulture ?? window.navigator.language;
+    switch (format) {
+        case MetadataFormats.ShortDate:
+            return date.toLocaleString(formatCulture, formatCulture === "it-IT" ? { year: "numeric", month: "2-digit", day: "2-digit" } : { dateStyle: 'short' });
+        case MetadataFormats.ShortTime:
+            return date.toLocaleString(formatCulture, { timeStyle: 'short' });
+        case MetadataFormats.ShortDateLongTime:
+            return date.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 date.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 date.toLocaleString(formatCulture, { weekday: "long", year: "numeric", month: "long", day: "numeric" });
+        case MetadataFormats.LongTime:
+            return date.toLocaleString(formatCulture, { timeStyle: 'medium' });
+        case MetadataFormats.LongDateLongTime:
+            return date.toLocaleString(formatCulture, { weekday: "long", year: "numeric", month: "long", day: "numeric", hour: '2-digit', minute: '2-digit', second: '2-digit' });
+        case MetadataFormats.LongDateShortTime:
+            return date.toLocaleString(formatCulture, { weekday: "long", year: "numeric", month: "long", day: "numeric", hour: '2-digit', minute: '2-digit' });
+        default:
+            return date.toLocaleString(formatCulture, formatCulture === "it-IT" ? { year: "numeric", month: "2-digit", day: "2-digit" } : { dateStyle: 'short' });
     }
-    return value;
 };
-/** Recupera i metadati filtrati (primi 5 con mid > 100 e valore presente), concatenati con separatorChar */
+/** Recupera i metadati filtrati usando buildDcmtDisplayName, concatenati con separatorChar */
 export const getFilteredMetadata = async (tid, did, separatorChar) => {
     const metadata = await SDK_Globals.tmSession?.NewSearchEngine().GetMetadataAsync(tid, did, true);
     if (!metadata)
@@ -215,8 +190,18 @@ export const getFilteredMetadata = async (tid, did, separatorChar) => {
     const dtdWithMetadata = await DcmtTypeListCacheService.GetWithNotGrantedAsync(tid, did, metadata);
     const mdList = dtdWithMetadata?.metadata ?? [];
     const metadataList = searchResultToMetadataValues(tid, dtdResult, rows, mids, mdList, LayoutModes.Update);
-    return metadataList
-        .reduce((acc, md) => acc.length < 5 && md.mid && md.mid > 100 && md.value ? [...acc, formatMetadataValue(md.value)] : acc, [])
+    // Converte l'array di MetadataValueDescriptorEx in DcmtMetadataMap per buildDcmtDisplayName
+    const metadataMap = Object.fromEntries(metadataList.filter(mvd => mvd.md?.name).map(mvd => [mvd.md.name, { md: mvd.md, value: mvd.value }]));
+    // Usa buildDcmtDisplayName per ricavare i nomi dei metadati da visualizzare
+    const displayKeys = buildDcmtDisplayName(metadataMap);
+    if (displayKeys.length === 0)
+        return null;
+    return displayKeys
+        .map(key => {
+        const entry = metadataMap[key];
+        return entry?.value ? formatMetadataValue(String(entry.value), entry.md) : null;
+    })
+        .filter(Boolean)
         .join(separatorChar);
 };
 /** Genera il nome file di destinazione in base alle impostazioni di naming */
@@ -239,6 +224,7 @@ export const generateTargetFileName = async (file, dcmtInfo, options) => {
         case 'onlyCustomMetadata': {
             try {
                 const filteredMetadata = await getFilteredMetadata(dcmtInfo.TID, dcmtInfo.DID, separatorChar);
+                console.log("filteredMetadata for TID:", dcmtInfo.TID, "DID:", dcmtInfo.DID, "is", filteredMetadata);
                 if (filteredMetadata) {
                     if (fileNamingMode === 'documentTypeAndCustomMetadata') {
                         const typeName = await getTypeName(dcmtInfo.TID);

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

@@ -0,0 +1,52 @@
+import { DcmtInfo } from '../../../ts';
+import { IRelatedDcmt } from './TMMasterDetailDcmts';
+/** Tipo per gli elementi con chiave e estensione */
+export interface ISelectedItemInfo {
+    key: string;
+    ext: string | undefined;
+}
+/** Risultato delle statistiche di selezione per il merge PDF */
+export interface IMergePdfSelectionStats {
+    /** Elementi con estensioni convertibili in PDF (non nativamente PDF) */
+    convertibleSelectedItems: Array<ISelectedItemInfo>;
+    /** True se ci sono elementi convertibili selezionati */
+    hasConvertibleSelected: boolean;
+    /** Elementi che NON sono PDF e NON sono convertibili */
+    nonPdfSelectedItems: Array<ISelectedItemInfo>;
+    /** True se ci sono elementi non-PDF selezionati */
+    hasNonPdfSelected: boolean;
+    /** Documenti di soli metadati (senza file allegato) */
+    metadataOnlySelectedItems: Array<ISelectedItemInfo>;
+    /** True se ci sono documenti di soli metadati selezionati */
+    hasMetadataOnlySelected: boolean;
+    /** Numero totale di file unibili (PDF nativi + convertibili) */
+    mergeableSelectedCount: number;
+    /** True se ci sono abbastanza file per il merge (>= MIN_PDF_FOR_MERGE) */
+    hasEnoughPdfForMerge: boolean;
+}
+/** Documento di soli metadati: FILEEXT null/undefined oppure FILECOUNT 0 (verrà convertito frontend) */
+export declare const isMetadataOnlyDcmt: (fileExt: string | null | undefined, fileCount: string | number | null | undefined) => boolean;
+/**
+ * Calcola tutte le statistiche di selezione necessarie per il merge PDF.
+ * Restituisce info su file convertibili, non-PDF e conteggio file unibili.
+ *
+ * @param selectedDcmtInfos - Lista dei DcmtInfo selezionati (usata se showTMRelationViewer è false)
+ * @param selectedItemsFull - Lista completa con FILEEXT e FILECOUNT per check documenti di soli metadati
+ * @param selectedItemsRelationViewer - Lista degli IRelatedDcmt selezionati nel RelationViewer
+ * @param showTMRelationViewer - Se true, usa selectedItemsRelationViewer, altrimenti selectedDcmtInfos
+ */
+export declare const getMergePdfSelectionStats: (selectedDcmtInfos: Array<DcmtInfo>, selectedItemsFull: Array<any>, selectedItemsRelationViewer: Array<IRelatedDcmt>, showTMRelationViewer: boolean) => IMergePdfSelectionStats;
+export interface IMetadataKeyValue {
+    label: string;
+    value: string;
+}
+export interface IMetadataPdfResult {
+    file: File;
+    blob: Blob;
+    bytes: Uint8Array;
+}
+/** Crea PDF con metadati documento (header + lista label=valore). Supporta wrapping e paginazione.
+ * @param dcmtInfo - Informazioni del documento
+ * @param showSystemMetadata - Se true, include i metadati di sistema (mid < 100). Default: false
+ */
+export declare const createMetadataPdfFromDocument: (dcmtInfo: DcmtInfo, showSystemMetadata?: boolean) => Promise<IMetadataPdfResult | null>;

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

@@ -0,0 +1,268 @@
+import { DcmtTypeListCacheService, LayoutModes, MetadataDataTypes, SDK_Globals } from '@topconsultnpm/sdk-ts';
+import { Globalization, isConvertibleToPdfExt, searchResultToMetadataValues } from '../../../helper';
+import { isPdfExt, MIN_PDF_FOR_MERGE } from './copyAndMergeDcmtsShared';
+/** Documento di soli metadati: FILEEXT null/undefined oppure FILECOUNT 0 (verrà convertito frontend) */
+export const isMetadataOnlyDcmt = (fileExt, fileCount) => {
+    if (!fileExt)
+        return true;
+    return Number(fileCount) === 0;
+};
+/**
+ * Calcola tutte le statistiche di selezione necessarie per il merge PDF.
+ * Restituisce info su file convertibili, non-PDF e conteggio file unibili.
+ *
+ * @param selectedDcmtInfos - Lista dei DcmtInfo selezionati (usata se showTMRelationViewer è false)
+ * @param selectedItemsFull - Lista completa con FILEEXT e FILECOUNT per check documenti di soli metadati
+ * @param selectedItemsRelationViewer - Lista degli IRelatedDcmt selezionati nel RelationViewer
+ * @param showTMRelationViewer - Se true, usa selectedItemsRelationViewer, altrimenti selectedDcmtInfos
+ */
+export const getMergePdfSelectionStats = (selectedDcmtInfos, selectedItemsFull, selectedItemsRelationViewer, showTMRelationViewer) => {
+    // Mappa per lookup veloce di FILECOUNT da selectedItemsFull (usato solo per isMetadataOnly)
+    const fileCountMap = new Map(selectedItemsFull.map(d => [`${d.TID}_${d.DID}`, d.FILECOUNT]));
+    // Pre-calcolo delle informazioni sui documenti selezionati
+    const docs = showTMRelationViewer
+        ? selectedItemsRelationViewer
+            .filter(i => i.isDcmt)
+            .map(i => {
+            const ext = i.fileExt ?? undefined;
+            return {
+                key: `${i.tid}_${i.did}`,
+                ext,
+                isPdf: isPdfExt(ext),
+                isConvertible: isConvertibleToPdfExt(ext),
+                isMetadataOnly: isMetadataOnlyDcmt(ext, null)
+            };
+        })
+        : selectedDcmtInfos.map(d => {
+            const ext = d.FILEEXT ?? undefined;
+            const key = `${d.TID}_${d.DID}`;
+            const fileCount = fileCountMap.get(key);
+            return {
+                key,
+                ext,
+                isPdf: isPdfExt(ext),
+                isConvertible: isConvertibleToPdfExt(ext),
+                isMetadataOnly: isMetadataOnlyDcmt(ext, fileCount)
+            };
+        });
+    // Elementi convertibili: file con estensione convertibile (esclusi documenti di soli metadati)
+    const convertibleSelectedItems = docs
+        .filter(i => i.isConvertible && !i.isMetadataOnly)
+        .map(i => ({ key: i.key, ext: i.ext }));
+    // Elementi NON PDF e NON convertibili (esclusi documenti di soli metadati)
+    const nonPdfSelectedItems = docs
+        .filter(i => !i.isPdf && !i.isConvertible && !i.isMetadataOnly)
+        .map(i => ({ key: i.key, ext: i.ext }));
+    // Documenti di soli metadati (senza file allegato)
+    const metadataOnlySelectedItems = docs
+        .filter(i => i.isMetadataOnly)
+        .map(i => ({ key: i.key, ext: i.ext }));
+    // Conteggio file unibili: PDF nativi + convertibili + documenti di soli metadati
+    const mergeableSelectedCount = docs
+        .filter(i => i.isPdf || i.isConvertible || i.isMetadataOnly).length;
+    return {
+        convertibleSelectedItems,
+        hasConvertibleSelected: convertibleSelectedItems.length > 0,
+        nonPdfSelectedItems,
+        hasNonPdfSelected: nonPdfSelectedItems.length > 0,
+        metadataOnlySelectedItems,
+        hasMetadataOnlySelected: metadataOnlySelectedItems.length > 0,
+        mergeableSelectedCount,
+        hasEnoughPdfForMerge: mergeableSelectedCount >= MIN_PDF_FOR_MERGE,
+    };
+};
+// LAZY LOADING pdf-lib
+let pdfLibModule = null;
+const loadPdfLib = async () => {
+    if (!pdfLibModule) {
+        pdfLibModule = await import('pdf-lib');
+    }
+    return pdfLibModule;
+};
+// HELPER FUNCTIONS
+/** Ottiene label localizzata del metadato (customName > nameLoc > name) */
+const getMetadataLabel = (md, customName) => {
+    if (customName)
+        return customName;
+    if (!md)
+        return '';
+    return md.nameLoc || md.name || '';
+};
+/** Formatta valore metadato per PDF (null/undefined -> stringa vuota, datetime -> dd/MM/yyyy HH:mm) */
+const formatMetadataValueForPdf = (value, md) => {
+    if (value === undefined || value === null)
+        return '';
+    // Se il metadato è di tipo DateTime, formatta in modo leggibile usando Globalization
+    if (md?.dataType === MetadataDataTypes.DateTime) {
+        return Globalization.getDateTimeDisplayValueCompact(value, undefined, md.format?.format);
+    }
+    return value.toString().trim();
+};
+// ============================================================================
+// CREAZIONE PDF DA METADATI DOCUMENTO
+// ============================================================================
+/** Crea PDF con metadati documento (header + lista label=valore). Supporta wrapping e paginazione.
+ * @param dcmtInfo - Informazioni del documento
+ * @param showSystemMetadata - Se true, include i metadati di sistema (mid < 100). Default: false
+ */
+export const createMetadataPdfFromDocument = async (dcmtInfo, showSystemMetadata = false) => {
+    // Configurazione ottimale per PDF A4
+    const pageWidth = 595; // A4 width in points
+    const pageHeight = 842; // A4 height in points
+    const margin = 50; // Margine confortevole
+    const titleFontSize = 14; // Titolo leggibile ma non troppo grande
+    const contentFontSize = 10; // Font contenuto ottimale per leggibilità
+    try {
+        // Recupera i metadati del documento
+        const metadata = await SDK_Globals.tmSession?.NewSearchEngine().GetMetadataAsync(dcmtInfo.TID, dcmtInfo.DID, true);
+        if (!metadata) {
+            console.warn('createMetadataPdfFromDocument: impossibile recuperare i metadati');
+            return null;
+        }
+        const dtdResult = metadata.dtdResult;
+        const rows = dtdResult?.rows?.[0] ?? [];
+        const mids = metadata.selectMIDs;
+        // Recupera il tipo documento con metadati
+        const dtdWithMetadata = await DcmtTypeListCacheService.GetWithNotGrantedAsync(dcmtInfo.TID, dcmtInfo.DID, metadata);
+        if (!dtdWithMetadata) {
+            console.warn('createMetadataPdfFromDocument: impossibile recuperare il tipo documento');
+            return null;
+        }
+        const mdList = dtdWithMetadata.metadata ?? [];
+        // Converte i metadati in formato leggibile
+        const metadataList = searchResultToMetadataValues(dcmtInfo.TID, dtdResult, rows, mids, mdList, LayoutModes.Update);
+        // Ottiene il nome del tipo documento (localizzato se abilitato)
+        const dcmtTypeName = dtdWithMetadata.nameLoc || dtdWithMetadata.name || 'Documento';
+        // Prepara la lista di metadati chiave-valore
+        const metadataKeyValues = metadataList
+            .filter(mvd => mvd.md && mvd.mid && mvd.mid > 0) // Filtra solo metadati validi
+            .filter(mvd => showSystemMetadata || (mvd.mid && mvd.mid >= 100)) // Filtra metadati di sistema se showSystemMetadata è false
+            .map(mvd => ({
+            label: getMetadataLabel(mvd.md, mvd.customName),
+            value: formatMetadataValueForPdf(mvd.value, mvd.md)
+        }))
+            .filter(kv => kv.label.length > 0); // Rimuovi metadati senza label
+        // Carica pdf-lib on-demand
+        const { PDFDocument, StandardFonts, rgb } = await loadPdfLib();
+        // Crea il documento PDF
+        const pdfDoc = await PDFDocument.create();
+        const helveticaFont = await pdfDoc.embedFont(StandardFonts.Helvetica);
+        const helveticaBoldFont = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
+        // Calcola dimensioni
+        const contentWidth = pageWidth - (margin * 2);
+        const lineHeight = contentFontSize + 5;
+        const titleLineHeight = titleFontSize + 6;
+        // Funzione per aggiungere una nuova pagina
+        const addPage = () => {
+            const page = pdfDoc.addPage([pageWidth, pageHeight]);
+            return { page, yPosition: pageHeight - margin };
+        };
+        // Funzione per calcolare la larghezza del testo
+        const getTextWidth = (text, font, size) => {
+            try {
+                return font.widthOfTextAtSize(text, size);
+            }
+            catch {
+                // Fallback per caratteri non supportati
+                return text.length * size * 0.5;
+            }
+        };
+        // Funzione per spezzare il testo in righe che entrano nella larghezza disponibile
+        const wrapText = (text, font, fontSize, maxWidth) => {
+            const lines = [];
+            const words = text.split(' ');
+            let currentLine = '';
+            for (const word of words) {
+                const testLine = currentLine ? `${currentLine} ${word}` : word;
+                const testWidth = getTextWidth(testLine, font, fontSize);
+                if (testWidth > maxWidth && currentLine) {
+                    lines.push(currentLine);
+                    currentLine = word;
+                }
+                else {
+                    currentLine = testLine;
+                }
+            }
+            if (currentLine) {
+                lines.push(currentLine);
+            }
+            // Se una singola parola è troppo lunga, spezzala in più righe (carattere per carattere)
+            const result = [];
+            for (const line of lines) {
+                if (getTextWidth(line, font, fontSize) <= maxWidth) {
+                    result.push(line);
+                }
+                else {
+                    // Spezza la parola/linea troppo lunga carattere per carattere
+                    let chunk = '';
+                    for (const char of line) {
+                        const testChunk = chunk + char;
+                        if (getTextWidth(testChunk, font, fontSize) > maxWidth && chunk) {
+                            result.push(chunk);
+                            chunk = char;
+                        }
+                        else {
+                            chunk = testChunk;
+                        }
+                    }
+                    if (chunk) {
+                        result.push(chunk);
+                    }
+                }
+            }
+            return result;
+        };
+        // Sanitizza testo per Helvetica (solo ASCII)
+        const sanitize = (text) => text.replace(/[^\x20-\x7E]/g, '_');
+        let { page, yPosition } = addPage();
+        // Header (titolo centrato)
+        const titleText = sanitize(`${dcmtTypeName}`);
+        const titleWidth = getTextWidth(titleText, helveticaBoldFont, titleFontSize);
+        const titleX = Math.max(margin, margin + (contentWidth - titleWidth) / 2);
+        page.drawText(titleText, { x: titleX, y: yPosition, size: titleFontSize, font: helveticaBoldFont, color: rgb(0, 0, 0) });
+        yPosition -= titleLineHeight + 8;
+        // Metadati (label in grassetto, valore normale)
+        for (const kv of metadataKeyValues) {
+            const labelText = sanitize(kv.label) + ': ';
+            const labelWidth = getTextWidth(labelText, helveticaBoldFont, contentFontSize);
+            const valueMaxWidth = contentWidth - labelWidth;
+            const continuationIndent = labelWidth; // Indentazione per righe successive
+            // Wrappa il valore
+            const valueText = sanitize(kv.value);
+            const valueLines = wrapText(valueText, helveticaFont, contentFontSize, valueMaxWidth);
+            // Prima riga: label (bold) + primo pezzo di valore
+            if (yPosition < margin + lineHeight) {
+                ({ page, yPosition } = addPage());
+            }
+            page.drawText(labelText, { x: margin, y: yPosition, size: contentFontSize, font: helveticaBoldFont, color: rgb(0, 0, 0) });
+            if (valueLines.length > 0) {
+                page.drawText(valueLines[0], { x: margin + labelWidth, y: yPosition, size: contentFontSize, font: helveticaFont, color: rgb(0, 0, 0) });
+            }
+            yPosition -= lineHeight;
+            // Righe successive del valore (indentate)
+            for (let i = 1; i < valueLines.length; i++) {
+                if (yPosition < margin + lineHeight) {
+                    ({ page, yPosition } = addPage());
+                }
+                page.drawText(valueLines[i], { x: margin + continuationIndent, y: yPosition, size: contentFontSize, font: helveticaFont, color: rgb(0, 0, 0) });
+                yPosition -= lineHeight;
+            }
+        }
+        // Salva il PDF
+        const pdfBytes = await pdfDoc.save();
+        // Converte in Blob e File
+        const pdfBuffer = pdfBytes.buffer.slice(pdfBytes.byteOffset, pdfBytes.byteOffset + pdfBytes.byteLength);
+        const blob = new Blob([pdfBuffer], { type: 'application/pdf' });
+        const finalFileName = `${dcmtTypeName}_${dcmtInfo.DID}.pdf`;
+        const file = new File([blob], finalFileName, { type: 'application/pdf' });
+        return {
+            file,
+            blob,
+            bytes: pdfBytes
+        };
+    }
+    catch (error) {
+        console.error('createMetadataPdfFromDocument: errore durante la creazione del PDF', error);
+        return null;
+    }
+};

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

@@ -1,8 +1,9 @@
+import React from "react";
 import { DcmtInfo } from "../../../ts";
 interface TMDcmtCheckoutInfoFormProps {
     dtdName: string;
     selectedDcmtOrFocused: DcmtInfo;
     onClose: () => void;
 }
-declare const TMDcmtCheckoutInfoForm: (props: TMDcmtCheckoutInfoFormProps) => import("react/jsx-runtime").JSX.Element;
+declare const TMDcmtCheckoutInfoForm: (props: TMDcmtCheckoutInfoFormProps) => React.JSX.Element;
 export default TMDcmtCheckoutInfoForm;

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

@@ -0,0 +1,18 @@
+import React from "react";
+import { MetadataDescriptor, QueryDescriptor, SelectItem } from "@topconsultnpm/sdk-ts";
+interface TMMetadataOutputFormProps {
+    /** QueryDescriptor da cui estrarre i metadati disponibili */
+    qd?: QueryDescriptor;
+    /** Lista di SelectItem attualmente selezionati */
+    selectedSelectItems?: SelectItem[];
+    /** Consente di visualizzare i metadati di sistema (es. MID < 150) */
+    allowSysMetadata?: boolean;
+    /** Funzione predicato per filtrare i metadati (es. solo quelli con permesso canView) */
+    filterMetadata?: (value: MetadataDescriptor, index: number, array: MetadataDescriptor[]) => unknown;
+    /** Callback chiamata alla chiusura del form */
+    onClose: () => void;
+    /** Callback chiamata quando l'utente conferma la selezione dei SelectItem */
+    onChoose?: (selectItems: SelectItem[] | undefined) => void;
+}
+declare const TMMetadataOutputForm: (props: TMMetadataOutputFormProps) => React.JSX.Element;
+export default TMMetadataOutputForm;