@shival99/z-ui 1.0.15 → 1.0.16

package/fesm2022/shival99-z-ui-services.mjs

@@ -1,6 +1,10 @@
-import { HttpClient, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
 import * as i0 from '@angular/core';
-import { inject, signal, Injectable, InjectionToken, PLATFORM_ID, effect } from '@angular/core';
+import { Injectable, inject, signal, InjectionToken, PLATFORM_ID, effect } from '@angular/core';
+import { zFormatNumExcel, zConvertColorToArgb } from '@shival99/z-ui/utils';
+import * as ExcelJS from 'exceljs';
+import { saveAs } from 'file-saver';
+import * as XLSX from 'xlsx';
+import { HttpClient, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
 import { Router } from '@angular/router';
 import { firstValueFrom, from, switchMap, of, catchError, throwError, tap, map, defer, BehaviorSubject, Subject } from 'rxjs';
 import { TranslateService } from '@ngx-translate/core';
@@ -156,6 +160,763 @@ class ZCacheService {
     }
 }
 
+const Z_EXCEL_COLORS = {
+    'green-50': 'FFF0FDF4',
+    'green-100': 'FFDCFCE7',
+    'green-200': 'FFBBF7D0',
+    'green-300': 'FF86EFAC',
+    'green-400': 'FF4ADE80',
+    'green-500': 'FF22C55E',
+    'blue-50': 'FFEFF6FF',
+    'blue-100': 'FFDBEAFE',
+    'blue-200': 'FFBFDBFE',
+    'blue-300': 'FF93C5FD',
+    'blue-400': 'FF60A5FA',
+    'blue-500': 'FF3B82F6',
+    'gray-50': 'FFF9FAFB',
+    'gray-100': 'FFF3F4F6',
+    'gray-200': 'FFE5E7EB',
+    'gray-300': 'FFD1D5DB',
+    'gray-400': 'FF9CA3AF',
+    'gray-500': 'FF6B7280',
+    'yellow-50': 'FFFFFBEB',
+    'yellow-100': 'FFFEF3C7',
+    'yellow-200': 'FFFDE68A',
+    'yellow-300': 'FFFCD34D',
+    'red-50': 'FFFEF2F2',
+    'red-100': 'FFFEE2E2',
+    'red-200': 'FFFECACA',
+    'red-300': 'FFFCA5A5',
+    white: 'FFFFFFFF',
+    black: 'FF000000',
+    transparent: '00000000',
+};
+const Z_EXCEL_DEFAULT_CONFIG = {
+    font: {
+        name: 'Calibri',
+        size: 11,
+    },
+    headerFont: {
+        name: 'Calibri',
+        size: 11,
+        bold: true,
+    },
+    headerColors: {
+        level0: Z_EXCEL_COLORS['green-300'],
+        level1: Z_EXCEL_COLORS['blue-200'],
+    },
+};
+const Z_EXCEL_BORDER_THIN = {
+    top: { style: 'thin' },
+    left: { style: 'thin' },
+    bottom: { style: 'thin' },
+    right: { style: 'thin' },
+};
+const Z_EXCEL_CHAR_WIDTH_MAP = {
+    W: 1.4,
+    M: 1.4,
+    D: 1.2,
+    O: 1.2,
+    Q: 1.2,
+    A: 1.1,
+    B: 1.1,
+    C: 1.1,
+    G: 1.1,
+    H: 1.1,
+    N: 1.1,
+    R: 1.1,
+    S: 1.1,
+    U: 1.1,
+    V: 1.1,
+    X: 1.1,
+    Y: 1.1,
+    Z: 1.1,
+    E: 1.0,
+    F: 1.0,
+    K: 1.0,
+    P: 1.0,
+    T: 1.0,
+    J: 0.9,
+    L: 0.9,
+    I: 0.6,
+    i: 0.5,
+    l: 0.5,
+    t: 0.6,
+    f: 0.6,
+    j: 0.5,
+    '1': 0.8,
+    '!': 0.5,
+    '.': 0.5,
+    ',': 0.5,
+    ':': 0.5,
+    ';': 0.5,
+    '|': 0.5,
+    ' ': 0.5,
+};
+const Z_EXCEL_FONT_MULTIPLIERS = {
+    'Times New Roman': 1.0,
+    Arial: 0.95,
+    Calibri: 0.95,
+    'Courier New': 1.2,
+    'Comic Sans MS': 1.15,
+    Verdana: 1.05,
+    Tahoma: 0.9,
+    Georgia: 1.05,
+    Impact: 0.85,
+    'Trebuchet MS': 0.95,
+};
+const Z_EXCEL_WIDTH_LIMITS = {
+    min: 5,
+    max: 50,
+    tableMin: 8,
+    tableMax: 30,
+    default: 20,
+};
+
+class ZExcelService {
+    static _isHeaderConfig(config) {
+        if (!config || typeof config !== 'object') {
+            return false;
+        }
+        return config.constructor === Object;
+    }
+    static _getHeaderConfig(col) {
+        const empty = {
+            content: undefined,
+            class: undefined,
+            style: undefined,
+            align: undefined,
+            tooltip: undefined,
+            rowSpan: undefined,
+            colSpan: undefined,
+        };
+        if (!col) {
+            return empty;
+        }
+        if (!ZExcelService._isHeaderConfig(col.header)) {
+            return { ...empty, content: col.header };
+        }
+        return {
+            content: col.header.content,
+            class: undefined,
+            style: undefined,
+            align: col.header.align,
+            tooltip: undefined,
+            rowSpan: undefined,
+            colSpan: undefined,
+        };
+    }
+    async exportExcel(config, options = {}) {
+        try {
+            const result = await ZExcelService.exportExcelStatic(config);
+            await this._saveFile(result, options);
+        }
+        catch (error) {
+            console.error('Error exporting Excel:', error);
+            options.toast?.error?.('Failed to export Excel file');
+            throw error;
+        }
+    }
+    async exportFromTable(config, options = {}) {
+        try {
+            const excelColumns = this._convertTableColumnsToExcel(config);
+            const excelConfig = {
+                fileName: config.fileName,
+                columns: excelColumns,
+                source: config.source,
+            };
+            await this.exportExcel(excelConfig, options);
+        }
+        catch (error) {
+            console.error('Error exporting from table:', error);
+            options.toast?.error?.('Failed to export Excel file');
+            throw error;
+        }
+    }
+    async exportFromElement(elementId, fileName = 'export', options = {}) {
+        try {
+            const result = await ZExcelService.exportFromElementStatic(elementId, fileName);
+            await this._saveFile(result, options);
+        }
+        catch (error) {
+            console.error('Error exporting from element:', error);
+            options.toast?.error?.('Failed to export Excel file');
+            throw error;
+        }
+    }
+    async exportFromElementXlsx(elementId, fileName = 'export', options = {}) {
+        try {
+            const element = document.getElementById(elementId);
+            if (!element) {
+                throw new Error(`Element with id "${elementId}" not found`);
+            }
+            const table = element.querySelector('table') || element;
+            if (table.tagName !== 'TABLE') {
+                throw new Error('Element must be a table or contain a table');
+            }
+            const workbook = XLSX.utils.table_to_book(table, { sheet: 'Sheet1' });
+            const { addTimestamp = true } = options;
+            let finalFileName = `${fileName}.xlsx`;
+            if (addTimestamp) {
+                finalFileName = `${fileName}_${ZExcelService._formatTimestamp()}.xlsx`;
+            }
+            XLSX.writeFile(workbook, finalFileName);
+            if (options.showNotification !== false) {
+                options.toast?.success?.(`File "${finalFileName}" has been downloaded`);
+            }
+        }
+        catch (error) {
+            console.error('Error exporting from element with XLSX:', error);
+            options.toast?.error?.('Failed to export Excel file');
+            throw error;
+        }
+    }
+    static async exportExcelStatic(config) {
+        const workbook = new ExcelJS.Workbook();
+        const { fileName = 'export', columns, source } = config;
+        for (const sheetSource of source) {
+            const sheet = workbook.addWorksheet(sheetSource.sheetName || 'Sheet1');
+            const flatColumns = ZExcelService._flattenColumns(columns);
+            const headerLevels = ZExcelService._calculateHeaderLevels(columns);
+            sheet.columns = flatColumns.map(col => ({
+                key: col.id,
+                header: col.header || col.id,
+                width: col.width || Z_EXCEL_WIDTH_LIMITS.default,
+                style: { font: Z_EXCEL_DEFAULT_CONFIG.font },
+            }));
+            ZExcelService._createHeaderRows(sheet, columns, headerLevels);
+            const dataStartRow = headerLevels + 1;
+            const mergedCells = new Set();
+            const mergeRegions = ZExcelService._processMergeRegions(flatColumns, sheetSource.data, dataStartRow);
+            sheetSource.data.forEach((dataItem, rowIndex) => {
+                const row = sheet.addRow([]);
+                flatColumns.forEach((col, colIndex) => {
+                    const cell = row.getCell(colIndex + 1);
+                    const cellValue = ZExcelService._getCellValue(col, dataItem, rowIndex, sheetSource.data);
+                    cell.value = cellValue;
+                });
+                row.eachCell((cell, colNumber) => {
+                    const colConfig = flatColumns[colNumber - 1];
+                    const currentRow = dataStartRow + rowIndex + 1;
+                    const cellKey = `${currentRow}:${colNumber}`;
+                    if (mergedCells.has(cellKey)) {
+                        return;
+                    }
+                    cell.font = {
+                        name: Z_EXCEL_DEFAULT_CONFIG.font.name,
+                        size: Z_EXCEL_DEFAULT_CONFIG.font.size,
+                        ...(cell.font || {}),
+                    };
+                    if (colConfig.formatNum) {
+                        const rawValue = ZExcelService._getCellValue(colConfig, dataItem, rowIndex, sheetSource.data);
+                        zFormatNumExcel(cell, rawValue, colConfig.formatNum);
+                    }
+                    if (!colConfig.formatNum && colConfig.format) {
+                        const context = {
+                            row: dataItem,
+                            rowIndex,
+                            data: sheetSource.data,
+                            cell: cell,
+                        };
+                        colConfig.format(context);
+                    }
+                    if (colConfig.align) {
+                        cell.alignment = {
+                            horizontal: colConfig.align,
+                            vertical: 'middle',
+                            ...(cell.alignment || {}),
+                        };
+                    }
+                    if (colConfig.note) {
+                        const noteText = colConfig.note(dataItem, rowIndex, sheetSource.data);
+                        if (noteText) {
+                            cell.note = noteText;
+                        }
+                    }
+                    cell.border = Z_EXCEL_BORDER_THIN;
+                });
+            });
+            mergeRegions.forEach(region => {
+                try {
+                    sheet.mergeCells(region.startRow, region.startCol, region.endRow, region.endCol);
+                    const mergedCell = sheet.getCell(region.startRow, region.startCol);
+                    if (!mergedCell.alignment) {
+                        mergedCell.alignment = { vertical: 'middle' };
+                    }
+                    for (let r = region.startRow; r <= region.endRow; r++) {
+                        for (let c = region.startCol; c <= region.endCol; c++) {
+                            mergedCells.add(`${r}:${c}`);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.warn(`Failed to merge cells:`, error);
+                }
+            });
+            ZExcelService._applyAutoFitWidth(sheet, flatColumns);
+        }
+        const buffer = await workbook.xlsx.writeBuffer();
+        return { buffer: buffer, fileName: `${fileName}.xlsx` };
+    }
+    static async exportFromElementStatic(elementId, fileName = 'export') {
+        const workbook = new ExcelJS.Workbook();
+        const element = document.getElementById(elementId);
+        if (!element) {
+            throw new Error(`Element with id "${elementId}" not found`);
+        }
+        const sheet = workbook.addWorksheet('Sheet1');
+        const table = element.querySelector('table') || element;
+        if (table.tagName !== 'TABLE') {
+            throw new Error('Element must be a table or contain a table');
+        }
+        ZExcelService._processTableElement(sheet, table);
+        ZExcelService._applyAutoFitWidthForTable(sheet);
+        const buffer = await workbook.xlsx.writeBuffer();
+        return { buffer: buffer, fileName: `${fileName}.xlsx` };
+    }
+    async _saveFile(result, options) {
+        const { addTimestamp = true, showNotification = true } = options;
+        let finalFileName = result.fileName;
+        if (addTimestamp) {
+            const timestamp = ZExcelService._formatTimestamp();
+            if (!finalFileName.includes(timestamp.slice(0, 8))) {
+                finalFileName = finalFileName.replace('.xlsx', `_${timestamp}.xlsx`);
+            }
+        }
+        const blob = new Blob([result.buffer], {
+            type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        });
+        saveAs(blob, finalFileName);
+        if (showNotification) {
+            options.toast?.success?.(`File "${finalFileName}" has been downloaded`);
+        }
+    }
+    _convertTableColumnsToExcel(config) {
+        const { tableColumns, excelOverrides = {}, excludeColumns = [], headerResolver } = config;
+        const convertColumn = (col) => {
+            if (excludeColumns.includes(col.id)) {
+                return null;
+            }
+            if (['select', 'expand', 'actions'].includes(col.id)) {
+                return null;
+            }
+            const headerConfig = ZExcelService._getHeaderConfig(col);
+            let headerText = '';
+            headerText = col.id;
+            if (headerResolver) {
+                headerText = headerResolver(col);
+            }
+            if (!headerResolver && typeof headerConfig.content === 'string') {
+                headerText = headerConfig.content;
+            }
+            if (!headerResolver && typeof headerConfig.content === 'function') {
+                const result = headerConfig.content();
+                headerText = typeof result === 'string' ? result : col.id;
+            }
+            const excelCol = {
+                id: col.id,
+                header: headerText,
+                accessorKey: col.accessorKey,
+                accessorFn: col.accessorFn ? (row) => col.accessorFn(row) : undefined,
+                width: col.size,
+                align: headerConfig.align,
+                visible: typeof col.visible === 'boolean' ? col.visible : true,
+            };
+            const override = excelOverrides[col.id];
+            if (override) {
+                Object.assign(excelCol, override);
+            }
+            if (col.columns && col.columns.length > 0) {
+                excelCol.columns = col.columns
+                    .map((childCol) => convertColumn(childCol))
+                    .filter((c) => c !== null);
+                if (excelCol.columns && excelCol.columns.length > 0) {
+                    excelCol.headerColSpan = ZExcelService._getLeafCount(excelCol.columns);
+                }
+            }
+            return excelCol;
+        };
+        return tableColumns
+            .map((col) => convertColumn(col))
+            .filter((c) => c !== null);
+    }
+    static _flattenColumns(columns) {
+        const result = [];
+        const flatten = (cols) => {
+            for (const col of cols) {
+                if (col.visible === false) {
+                    continue;
+                }
+                if (col.columns && col.columns.length > 0) {
+                    flatten(col.columns);
+                    continue;
+                }
+                result.push(col);
+            }
+        };
+        flatten(columns);
+        return result;
+    }
+    static _calculateHeaderLevels(columns) {
+        const getLevel = (cols, currentLevel = 1) => {
+            let maxLevel = currentLevel;
+            for (const col of cols) {
+                let currentColLevel = currentLevel;
+                if (col.headerRowSpan && col.headerRowSpan > 1) {
+                    currentColLevel = currentLevel + col.headerRowSpan - 1;
+                }
+                if (col.columns && col.columns.length > 0) {
+                    if (!col.headerRowSpan || col.headerRowSpan <= 1) {
+                        const childLevel = getLevel(col.columns, currentLevel + 1);
+                        currentColLevel = Math.max(currentColLevel, childLevel);
+                    }
+                }
+                maxLevel = Math.max(maxLevel, currentColLevel);
+            }
+            return maxLevel;
+        };
+        return getLevel(columns);
+    }
+    static _createHeaderRows(sheet, columns, maxLevels) {
+        const headerStructure = [];
+        for (let i = 0; i < maxLevels; i++) {
+            headerStructure[i] = [];
+        }
+        ZExcelService._buildHeaderStructure(columns, headerStructure, 0, maxLevels);
+        const processedMergeRegions = new Set();
+        headerStructure.forEach((row, rowIndex) => {
+            const headerRow = sheet.getRow(rowIndex + 1);
+            const sortedRow = row.sort((a, b) => (a.startCol || 0) - (b.startCol || 0));
+            sortedRow.forEach((headerCell) => {
+                if (headerCell.isProcessed || headerCell.isEmpty) {
+                    return;
+                }
+                const colIndex = (headerCell.startCol || 0) + 1;
+                const cell = headerRow.getCell(colIndex);
+                cell.value = headerCell.header;
+                if (headerCell.colSpan > 1 || headerCell.rowSpan > 1) {
+                    const startRow = rowIndex + 1;
+                    const endRow = startRow + headerCell.rowSpan - 1;
+                    const startCol = colIndex;
+                    const endCol = colIndex + headerCell.colSpan - 1;
+                    const mergeKey = `${startRow}:${startCol}-${endRow}:${endCol}`;
+                    if (!processedMergeRegions.has(mergeKey)) {
+                        try {
+                            sheet.mergeCells(startRow, startCol, endRow, endCol);
+                            processedMergeRegions.add(mergeKey);
+                            headerCell.isProcessed = true;
+                        }
+                        catch (error) {
+                            console.warn(`Failed to merge header cells:`, error);
+                        }
+                    }
+                }
+                const defaultColor = rowIndex === 0 ? Z_EXCEL_DEFAULT_CONFIG.headerColors.level0 : Z_EXCEL_DEFAULT_CONFIG.headerColors.level1;
+                cell.fill = {
+                    type: 'pattern',
+                    pattern: 'solid',
+                    fgColor: { argb: defaultColor },
+                };
+                cell.font = Z_EXCEL_DEFAULT_CONFIG.headerFont;
+                cell.alignment = { horizontal: 'center', vertical: 'middle' };
+                cell.border = Z_EXCEL_BORDER_THIN;
+                if (headerCell.formatHeader) {
+                    headerCell.formatHeader(cell);
+                }
+            });
+        });
+    }
+    static _buildHeaderStructure(columns, headerStructure, level, maxLevels, startCol = 0) {
+        let currentCol = startCol;
+        for (const col of columns) {
+            if (col.visible === false) {
+                continue;
+            }
+            if (col.columns && col.columns.length > 0) {
+                const childrenLeafCount = ZExcelService._getLeafCount(col.columns);
+                const colSpan = col.headerColSpan || childrenLeafCount;
+                const rowSpan = col.headerRowSpan || 1;
+                headerStructure[level].push({
+                    header: col.header || col.id,
+                    colSpan,
+                    rowSpan,
+                    formatHeader: col.formatHeader,
+                    startCol: currentCol,
+                    endCol: currentCol + colSpan - 1,
+                });
+                if (col.headerRowSpan && col.headerRowSpan > 1) {
+                    currentCol += colSpan;
+                    continue;
+                }
+                ZExcelService._buildHeaderStructure(col.columns, headerStructure, level + 1, maxLevels, currentCol);
+                currentCol += colSpan;
+                continue;
+            }
+            const colSpan = col.headerColSpan || 1;
+            const rowSpan = col.headerRowSpan || maxLevels - level;
+            headerStructure[level].push({
+                header: col.header || col.id,
+                colSpan,
+                rowSpan,
+                formatHeader: col.formatHeader,
+                startCol: currentCol,
+                endCol: currentCol + colSpan - 1,
+            });
+            currentCol += colSpan;
+        }
+        return currentCol;
+    }
+    static _getLeafCount(columns) {
+        let count = 0;
+        for (const col of columns) {
+            if (col.visible === false) {
+                continue;
+            }
+            if (col.columns && col.columns.length > 0) {
+                count += ZExcelService._getLeafCount(col.columns);
+                continue;
+            }
+            count++;
+        }
+        return count;
+    }
+    static _getCellValue(col, row, rowIndex, data) {
+        if (col.accessorFn) {
+            return col.accessorFn(row, rowIndex, data);
+        }
+        if (col.accessorKey) {
+            return row[col.accessorKey];
+        }
+        return '';
+    }
+    static _processMergeRegions(flatColumns, data, dataStartRow) {
+        const mergeRegions = [];
+        const dataLength = data.length;
+        flatColumns.forEach((colConfig, colIndex) => {
+            const colNumber = colIndex + 1;
+            if (colConfig.rowSpan || colConfig.colSpan) {
+                let currentGroupStart = 0;
+                while (currentGroupStart < dataLength) {
+                    const currentItem = data[currentGroupStart];
+                    const rowSpan = typeof colConfig.rowSpan === 'function'
+                        ? colConfig.rowSpan(currentItem, currentGroupStart, data)
+                        : colConfig.rowSpan || 1;
+                    const colSpan = typeof colConfig.colSpan === 'function'
+                        ? colConfig.colSpan(currentItem, currentGroupStart, data)
+                        : colConfig.colSpan || 1;
+                    const hasRowSpan = rowSpan > 1;
+                    const hasColSpan = colSpan > 1;
+                    if (hasRowSpan || hasColSpan) {
+                        const startRow = dataStartRow + currentGroupStart;
+                        const endRow = hasRowSpan ? Math.min(startRow + rowSpan - 1, dataStartRow + dataLength - 1) : startRow;
+                        const startCol = colNumber;
+                        const endCol = hasColSpan ? colNumber + colSpan - 1 : colNumber;
+                        if ((endRow > startRow || endCol > startCol) && endRow < dataStartRow + dataLength) {
+                            mergeRegions.push({
+                                startRow,
+                                startCol,
+                                endRow,
+                                endCol,
+                                firstItemIndex: currentGroupStart,
+                            });
+                        }
+                    }
+                    currentGroupStart += Math.max(1, rowSpan);
+                }
+            }
+        });
+        return mergeRegions;
+    }
+    static _applyAutoFitWidth(sheet, flatColumns) {
+        flatColumns.forEach((col, index) => {
+            const colNumber = index + 1;
+            const column = sheet.getColumn(colNumber);
+            if (col.autoFit && !col.width) {
+                let maxWidth = 0;
+                sheet.eachRow((row) => {
+                    const cell = row.getCell(colNumber);
+                    if (cell.value) {
+                        const cellWidth = ZExcelService._calculateCellWidth(cell, String(cell.value));
+                        maxWidth = Math.max(maxWidth, cellWidth);
+                    }
+                });
+                const calculatedWidth = Math.max(Z_EXCEL_WIDTH_LIMITS.min, Math.min(Z_EXCEL_WIDTH_LIMITS.max, maxWidth + 1));
+                column.width = calculatedWidth;
+            }
+        });
+    }
+    static _applyAutoFitWidthForTable(sheet) {
+        const { columnCount } = sheet;
+        for (let colNumber = 1; colNumber <= columnCount; colNumber++) {
+            const column = sheet.getColumn(colNumber);
+            let maxWidth = 0;
+            sheet.eachRow((row) => {
+                const cell = row.getCell(colNumber);
+                if (cell.value) {
+                    const cellWidth = ZExcelService._calculateCellWidth(cell, String(cell.value));
+                    maxWidth = Math.max(maxWidth, cellWidth);
+                }
+            });
+            const calculatedWidth = Math.max(Z_EXCEL_WIDTH_LIMITS.tableMin, Math.min(Z_EXCEL_WIDTH_LIMITS.tableMax, maxWidth * 0.8 + 2));
+            column.width = calculatedWidth;
+        }
+    }
+    static _calculateCellWidth(cell, text) {
+        const font = cell.font || {};
+        const fontSize = font.size || Z_EXCEL_DEFAULT_CONFIG.font.size;
+        const fontFamily = font.name || Z_EXCEL_DEFAULT_CONFIG.font.name;
+        const isBold = font.bold || false;
+        const isItalic = font.italic || false;
+        const fontSizeMultiplier = fontSize / 11;
+        const fontMultiplier = Z_EXCEL_FONT_MULTIPLIERS[fontFamily] || 1.0;
+        let adjustedWidth = 0;
+        for (const char of text) {
+            const charWidth = Z_EXCEL_CHAR_WIDTH_MAP[char] || 1.0;
+            adjustedWidth += charWidth;
+        }
+        adjustedWidth *= fontSizeMultiplier * fontMultiplier;
+        if (isBold) {
+            adjustedWidth *= 1.1;
+        }
+        if (isItalic) {
+            adjustedWidth *= 1.05;
+        }
+        return Math.ceil(adjustedWidth * 1.2);
+    }
+    static _processTableElement(sheet, table) {
+        const rows = Array.from(table.rows);
+        const mergedCells = new Set();
+        rows.forEach((row, rowIndex) => {
+            const cells = Array.from(row.cells);
+            let colOffset = 0;
+            cells.forEach((cell, cellIndex) => {
+                const computedStyle = window.getComputedStyle(cell);
+                if (computedStyle.display === 'none' || computedStyle.visibility === 'hidden') {
+                    return;
+                }
+                const rect = cell.getBoundingClientRect();
+                if (rect.width === 0 && rect.height === 0) {
+                    return;
+                }
+                while (mergedCells.has(`${rowIndex + 1}:${cellIndex + colOffset + 1}`)) {
+                    colOffset++;
+                }
+                const excelRow = sheet.getRow(rowIndex + 1);
+                const colIndex = cellIndex + colOffset;
+                const excelCell = excelRow.getCell(colIndex + 1);
+                const cellContent = cell.textContent?.trim() || '';
+                excelCell.value = ZExcelService._parseContentValue(cellContent);
+                if (!excelCell.font) {
+                    excelCell.font = Z_EXCEL_DEFAULT_CONFIG.font;
+                }
+                ZExcelService._applyCellFormatFromHTML(excelCell, cell);
+                const rowSpan = parseInt(cell.getAttribute('rowspan') || '1');
+                const colSpan = parseInt(cell.getAttribute('colspan') || '1');
+                if (rowSpan > 1 || colSpan > 1) {
+                    const startRow = rowIndex + 1;
+                    const startCol = colIndex + 1;
+                    const endRow = startRow + rowSpan - 1;
+                    const endCol = startCol + colSpan - 1;
+                    const mergeKey = `${startRow}:${startCol}-${endRow}:${endCol}`;
+                    if (!mergedCells.has(mergeKey)) {
+                        sheet.mergeCells(startRow, startCol, endRow, endCol);
+                        mergedCells.add(mergeKey);
+                        for (let r = startRow; r <= endRow; r++) {
+                            for (let c = startCol; c <= endCol; c++) {
+                                mergedCells.add(`${r}:${c}`);
+                            }
+                        }
+                    }
+                }
+            });
+        });
+    }
+    static _parseContentValue(content) {
+        if (!content || content.trim() === '') {
+            return '';
+        }
+        const trimmedContent = content.trim();
+        if (/^-?\d+(\.\d+)?$/.test(trimmedContent)) {
+            const parsed = parseFloat(trimmedContent);
+            if (!isNaN(parsed) && isFinite(parsed)) {
+                return parsed;
+            }
+        }
+        if (/^-?\d+(\.\d+)?%$/.test(trimmedContent)) {
+            const numberPart = trimmedContent.replace('%', '');
+            const parsed = parseFloat(numberPart);
+            if (!isNaN(parsed) && isFinite(parsed)) {
+                return parsed / 100;
+            }
+        }
+        return trimmedContent;
+    }
+    static _applyCellFormatFromHTML(excelCell, htmlCell) {
+        const computedStyle = window.getComputedStyle(htmlCell);
+        excelCell.font = {
+            name: Z_EXCEL_DEFAULT_CONFIG.font.name,
+            bold: computedStyle.fontWeight === 'bold' || parseInt(computedStyle.fontWeight) >= 600,
+            italic: computedStyle.fontStyle === 'italic',
+            size: parseInt(computedStyle.fontSize) || Z_EXCEL_DEFAULT_CONFIG.font.size,
+            color: { argb: zConvertColorToArgb(computedStyle.color) },
+        };
+        if (computedStyle.backgroundColor && computedStyle.backgroundColor !== 'rgba(0, 0, 0, 0)') {
+            excelCell.fill = {
+                type: 'pattern',
+                pattern: 'solid',
+                fgColor: { argb: zConvertColorToArgb(computedStyle.backgroundColor) },
+            };
+        }
+        excelCell.alignment = {
+            horizontal: ZExcelService._getExcelAlignment(computedStyle.textAlign),
+            vertical: ZExcelService._getExcelVerticalAlignment(computedStyle.verticalAlign),
+        };
+        excelCell.border = Z_EXCEL_BORDER_THIN;
+    }
+    static _getExcelAlignment(textAlign) {
+        switch (textAlign) {
+            case 'center':
+                return 'center';
+            case 'right':
+                return 'right';
+            case 'left':
+                return 'left';
+            default:
+                return undefined;
+        }
+    }
+    static _getExcelVerticalAlignment(verticalAlign) {
+        switch (verticalAlign) {
+            case 'middle':
+                return 'middle';
+            case 'top':
+                return 'top';
+            case 'bottom':
+                return 'bottom';
+            default:
+                return 'middle';
+        }
+    }
+    static _formatTimestamp() {
+        const now = new Date();
+        const year = now.getFullYear();
+        const month = String(now.getMonth() + 1).padStart(2, '0');
+        const day = String(now.getDate()).padStart(2, '0');
+        const hours = String(now.getHours()).padStart(2, '0');
+        const minutes = String(now.getMinutes()).padStart(2, '0');
+        const seconds = String(now.getSeconds()).padStart(2, '0');
+        return `${year}${month}${day}_${hours}${minutes}${seconds}`;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZExcelService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZExcelService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ZExcelService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
 const Z_INDEXDB_DEFAULT_CONFIG = {
     dbName: 'ZDatabase',
     version: 1,
@@ -1237,5 +1998,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { ZCacheService, ZHttpAbstractService, ZIndexDbService, ZSubjectService, ZThemeService, ZTranslateService, Z_DARK_MODE_CACHE_KEY, Z_DEFAULT_THEME, Z_THEME_CACHE_KEY, Z_THEME_CONFIG, Z_THEME_CSS_MAP };
+export { ZCacheService, ZExcelService, ZHttpAbstractService, ZIndexDbService, ZSubjectService, ZThemeService, ZTranslateService, Z_DARK_MODE_CACHE_KEY, Z_DEFAULT_THEME, Z_EXCEL_BORDER_THIN, Z_EXCEL_CHAR_WIDTH_MAP, Z_EXCEL_COLORS, Z_EXCEL_DEFAULT_CONFIG, Z_EXCEL_FONT_MULTIPLIERS, Z_EXCEL_WIDTH_LIMITS, Z_THEME_CACHE_KEY, Z_THEME_CONFIG, Z_THEME_CSS_MAP };
 //# sourceMappingURL=shival99-z-ui-services.mjs.map