cilog-lib 1.13.0 → 1.13.2

package/fesm2022/cilog-lib.mjs

@@ -491,70 +491,70 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImpo
         }], propDecorators: { cell: [{ type: i0.Input, args: [{ isSignal: true, alias: "cell", required: false }] }] } });
 
 class ExportService {
+    colorCache = {};
     constructor() { }
     exportExcel(values, columns, byFiltre, withColors) {
-        // Workbook
         let wb = new Excel.Workbook();
-        // Worksheet
         let ws = wb.addWorksheet('Export', {
             properties: { defaultColWidth: 20 },
         });
-        // Colonnes
+        const activeColumns = columns.filter(col => !col.invisible && (!byFiltre || col.exportable === true));
+        // Génération des colonnes Excel
         let cols = [];
-        columns = columns.filter(col => !col.invisible);
-        columns.forEach(col => {
-            if (!byFiltre || col.exportable == true) {
-                let colExcel = {
-                    header: col.libelle,
-                    key: col.id,
-                    style: this.getStyleByType(col.type)
-                };
-                if (col.width != null && col.width.toString().includes('px')) {
-                    const px = parseInt(col.width.toString().replace('px', '').trim(), 10);
-                    const excelWidth = px / 7;
-                    colExcel.width = parseFloat(excelWidth.toFixed(2));
-                }
-                cols.push(colExcel);
+        activeColumns.forEach(col => {
+            let colExcel = {
+                header: col.libelle,
+                key: col.id,
+                style: this.getStyleByType(col.type)
+            };
+            if (col.width != null && col.width.toString().includes('px')) {
+                const px = parseInt(col.width.toString().replace('px', '').trim(), 10);
+                colExcel.width = parseFloat((px / 7).toFixed(2));
             }
+            cols.push(colExcel);
         });
         ws.columns = cols;
-        // Lignes
-        values.forEach(row => {
-            if (!byFiltre || row.exportable == true) {
-                let rowExcel = {};
-                columns.filter(obj => !byFiltre || obj.exportable == true).forEach(col => {
-                    if (row[col.id].excelSubstitution != null) {
-                        rowExcel[col.id] = row[col.id].excelSubstitution;
-                    }
-                    else {
-                        rowExcel[col.id] = this.getValueByType(row[col.id], col);
-                    }
-                });
-                // Application du style de chaque cellule
-                let result = ws.addRow(rowExcel);
-                columns.filter(obj => !byFiltre || obj.exportable == true).forEach((col, index) => {
+        const activeRows = byFiltre ? values.filter(row => row.exportable === true) : values;
+        // Traitement des lignes
+        activeRows.forEach(row => {
+            let rowExcel = {};
+            // Remplissage rapide des données
+            activeColumns.forEach(col => {
+                const cellData = row[col.id];
+                if (cellData) {
+                    rowExcel[col.id] = cellData.excelSubstitution != null
+                        ? cellData.excelSubstitution
+                        : this.getValueByType(cellData, col);
+                }
+            });
+            let result = ws.addRow(rowExcel);
+            // Application des styles par cellule (uniquement si nécessaire)
+            activeColumns.forEach((col, index) => {
+                const cellData = row[col.id];
+                if (!cellData)
+                    return;
+                // On ne récupère la cellule Excel que si on a vraiment un style à lui appliquer
+                if (cellData.bold || (withColors && (row.color || cellData.color))) {
                     const cell = result.getCell(index + 1);
-                    if (row[col.id].bold) {
+                    if (cellData.bold) {
                         cell.font = { bold: true };
                     }
                     if (withColors) {
-                        if ((row.color != null && row.color != '') || (row[col.id].color != null && row[col.id].color != '')) {
-                            cell.style.fill = {
+                        const targetColor = cellData.color || row.color;
+                        if (targetColor) {
+                            const hexaColor = this.getHexaColor(targetColor);
+                            cell.fill = {
                                 type: "pattern",
                                 pattern: "solid",
-                                fgColor: {
-                                    argb: row[col.id].color != null ? this.getHexaColor(row[col.id].color) : this.getHexaColor(row.color)
-                                },
-                                bgColor: {
-                                    argb: row[col.id].color != null ? this.getHexaColor(row[col.id].color) : this.getHexaColor(row.color)
-                                }
+                                fgColor: { argb: hexaColor },
+                                bgColor: { argb: hexaColor }
                             };
                         }
                     }
-                });
-            }
+                }
+            });
         });
-        // Style
+        // Style Global
         this.setStyleGlobalGrille(ws);
         // Sauvegarde
         wb.xlsx.writeBuffer().then(function (buffer) {
@@ -565,85 +565,86 @@ class ExportService {
         });
     }
     getHexaColor(color) {
-        var ctx = document.createElement('canvas').getContext('2d');
+        if (!color)
+            return '';
+        // Si la couleur est déjà au format #hex, on nettoie directement sans créer de canvas
+        if (color.startsWith('#')) {
+            return color.replace('#', '');
+        }
+        // Si c'est un nom de couleur (ex: 'red', 'blue') ou du rgb(), on utilise le cache ou le canvas
+        if (this.colorCache[color]) {
+            return this.colorCache[color];
+        }
+        const ctx = document.createElement('canvas').getContext('2d');
+        if (!ctx)
+            return color;
         ctx.fillStyle = color;
-        return ctx.fillStyle.replace('#', '');
+        const hexa = ctx.fillStyle.replace('#', '');
+        this.colorCache[color] = hexa; // On s'en rappelle pour la prochaine fois !
+        return hexa;
     }
     setStyleGlobalGrille(ws) {
-        ws.views = [
-            { state: 'frozen', ySplit: 1 }
-        ];
+        ws.views = [{ state: 'frozen', ySplit: 1 }];
+        const totalColumns = ws.columnCount;
+        const lastColumnLetter = this.columnIndexToColumnLetter(totalColumns);
         ws.eachRow((row, rowNumber) => {
-            row.eachCell({ includeEmpty: true }, (cell, number) => {
-                if (rowNumber == 1) {
+            if (rowNumber === 1) {
+                // En-tête : Inclure les cellules vides, fond vert, texte blanc/gras centré
+                row.eachCell({ includeEmpty: true }, (cell) => {
                     cell.fill = {
                         pattern: 'solid',
                         type: 'pattern',
-                        fgColor: {
-                            argb: '2fab49',
-                        },
-                    };
-                    cell.alignment = { horizontal: 'center' };
-                    cell.alignment.vertical = 'middle';
-                    cell.font = {
-                        name: 'Arial',
-                        size: 10,
-                        bold: true
+                        fgColor: { argb: '2fab49' },
                     };
+                    cell.alignment = { horizontal: 'center', vertical: 'middle' };
+                    cell.font = { name: 'Arial', size: 10, bold: true, color: { argb: 'FFFFFF' } };
                     cell.border = {
-                        bottom: { style: 'thin' },
-                        top: { style: 'thin' },
-                        left: { style: 'thin' },
-                        right: { style: 'thin' },
+                        bottom: { style: 'thin' }, top: { style: 'thin' },
+                        left: { style: 'thin' }, right: { style: 'thin' },
                     };
-                }
-                else {
+                });
+            }
+            else {
+                row.eachCell({ includeEmpty: true }, (cell) => {
                     cell.border = {
-                        bottom: { style: 'thin' },
-                        top: { style: 'thin' },
-                        left: { style: 'thin' },
-                        right: { style: 'thin' },
+                        bottom: { style: 'thin' }, top: { style: 'thin' },
+                        left: { style: 'thin' }, right: { style: 'thin' },
                     };
-                }
-            });
+                });
+            }
         });
-        ws.autoFilter = {
-            from: 'A1',
-            to: this.columnIndexToColumnLetter(ws.columnCount).toString() + '1',
-        };
+        ws.autoFilter = { from: 'A1', to: `${lastColumnLetter}1` };
     }
     columnIndexToColumnLetter(column) {
-        var temp, letter = '';
+        let letter = '';
         while (column > 0) {
-            temp = (column - 1) % 26;
+            let temp = (column - 1) % 26;
             letter = String.fromCharCode(temp + 65) + letter;
-            column = (column - temp - 1) / 26;
+            column = Math.floor((column - temp - 1) / 26); // Math.floor pour éviter les flottants
         }
         return letter;
     }
     getValueByType(cell, col) {
+        if (cell.value == null)
+            return null;
         switch (col.type) {
             case ColType.MultiSelect:
-                let optionLabelMulti = cell.options != null && cell.options.optionLabel != null ? cell.options.optionLabel : col.options.optionLabel;
-                return cell.value.map(val => val[optionLabelMulti]).join(', ');
+                const optionLabelMulti = cell.options?.optionLabel || col.options?.optionLabel;
+                return Array.isArray(cell.value) ? cell.value.map(val => val[optionLabelMulti]).join(', ') : '';
             case ColType.SelectButton:
             case ColType.Dropdown:
             case ColType.State:
-                let optionLabel = cell.options != null && cell.options.optionLabel != null ? cell.options.optionLabel : col.options.optionLabel;
-                return cell.value != null ? cell.value[optionLabel] : null;
+                const optionLabel = cell.options?.optionLabel || col.options?.optionLabel;
+                return cell.value[optionLabel] || null;
             case ColType.Image:
             case ColType.Button:
                 return null;
             case ColType.Switch:
-                return cell.value == true ? 'Oui' : 'Non';
+                return cell.value === true ? 'Oui' : 'Non';
             case ColType.Date:
-                if (cell.value != null) {
-                    let dateStr = cell.value.getFullYear() + '-' + ((cell.value.getMonth() + 1 < 10) ? '0' + (cell.value.getMonth() + 1) : (cell.value.getMonth() + 1)) + '-' + (cell.value.getDate() < 10 ? '0' + cell.value.getDate() : cell.value.getDate()) + 'T00:00:00.000Z';
-                    return new Date(dateStr);
-                }
-                else {
-                    return null;
-                }
+                // Correction du parsing de date plus propre
+                const d = new Date(cell.value);
+                return isNaN(d.getTime()) ? null : d;
             default:
                 return cell.value;
         }