limitng 0.21.68 → 0.21.70

package/fesm2022/limitng-blob-response-handler.mjs

@@ -0,0 +1,871 @@
+import * as i0 from '@angular/core';
+import { inject, Injectable } from '@angular/core';
+import saveAs from 'file-saver';
+import { TranslateService } from '@ngx-translate/core';
+import { GlobalFunctions } from 'limitng/api';
+import ExcelJS from 'exceljs';
+import { NumberFormatlar, FontStyle } from 'limitng/api/models/fourDConstants';
+import { XLHAlign, XLVAlign } from 'limitng/api/models/xl/xlConstants';
+
+class JsonToExcelParser {
+    static async indir(sonuc, dosyaAdi) {
+        const blob = await this.blobOlustur(sonuc);
+        const normalizeDosyaAdi = this.dosyaAdiDuzenle(dosyaAdi);
+        saveAs(blob, `${normalizeDosyaAdi}.xlsx`);
+    }
+    static async blobOlustur(sonuc) {
+        const workbook = this.workbookOlustur(sonuc);
+        const buffer = await workbook.xlsx.writeBuffer();
+        return new Blob([buffer], {
+            type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+        });
+    }
+    static standartPageSetupOlustur() {
+        return {
+            bottomMargin: 1,
+            centerHorizontally: true,
+            centerVertically: true,
+            fitToPagesTall: 1,
+            fitToPagesWide: 1,
+            leftMargin: 1,
+            orientation: 2,
+            rightMargin: 1,
+            topMargin: 1
+        };
+    }
+    static ustBilgiEkle(ustBilgi, font) {
+        return font ? { font, ustBilgi } : { ustBilgi };
+    }
+    static workbookOlustur(sonuc) {
+        const workbook = new ExcelJS.Workbook();
+        workbook.created = new Date();
+        workbook.calcProperties.fullCalcOnLoad = true;
+        const gridLinesGorunur = sonuc.window.displayGridLines;
+        if (this.yeniYapiMi(sonuc)) {
+            workbook.creator = sonuc.book.author || 'MedPlan';
+            workbook.subject = '';
+            workbook.description = '';
+            this.yeniFormatSheetsYaz(workbook, sonuc, gridLinesGorunur);
+        }
+        else {
+            workbook.creator = sonuc.book.author || 'MedPlan';
+            workbook.subject = this.konuVer(sonuc.book, sonuc.ustBilgiler?.[0]?.ustBilgi);
+            workbook.description = sonuc.book.comments || '';
+            this.eskiFormatSheetsYaz(workbook, sonuc, gridLinesGorunur);
+        }
+        this.aktifSayfayiAyarla(workbook, sonuc.book.activeSheetNo, workbook.worksheets.length);
+        return workbook;
+    }
+    static yeniYapiMi(sonuc) {
+        const ilkSheet = sonuc.sheets[0];
+        if (Array.isArray(ilkSheet?.tables)) {
+            return true;
+        }
+        const runtimeSonuc = sonuc;
+        return !Array.isArray(runtimeSonuc.tables);
+    }
+    static yeniFormatSheetsYaz(workbook, sonuc, gridLinesGorunur) {
+        for (let index = 0; index < sonuc.sheets.length; index++) {
+            const sheet = sonuc.sheets[index];
+            const sheetAdi = this.sayfaAdiDuzenle(sheet.sheetName || 'Rapor', index + 1);
+            const worksheet = workbook.addWorksheet(sheetAdi);
+            const zoomScale = sheet.zoom && sheet.zoom > 0 ? sheet.zoom : undefined;
+            worksheet.views = [{ showGridLines: gridLinesGorunur, ...(zoomScale !== undefined && { zoomScale }) }];
+            this.sayfaDuzeniniBelirle(worksheet, sheet);
+            const ustBilgiler = sheet.ustBilgiler ?? [];
+            this.yeniFormatUstBilgileriYaz(worksheet, ustBilgiler, sonuc.defaultFont);
+            let sonSatir = ustBilgiler.length + 1;
+            for (const table of sheet.tables ?? []) {
+                sonSatir = Math.max(sonSatir, this.tabloyuYaz(worksheet, sonuc, table));
+            }
+            if (sheet.notlar?.length) {
+                this.notlariYazList(worksheet, sheet.notlar, sheet.not?.font, sonSatir + 2, sonuc.defaultFont);
+            }
+        }
+        if (sonuc.sheets.length === 0) {
+            const worksheet = workbook.addWorksheet('Rapor');
+            worksheet.views = [{ showGridLines: gridLinesGorunur }];
+        }
+    }
+    static eskiFormatSheetsYaz(workbook, sonuc, gridLinesGorunur) {
+        const tablesBySheet = this.sheetBazliTablolar(sonuc);
+        const ustBilgiler = sonuc.ustBilgiler ?? [];
+        const notlar = sonuc.notlar ?? [];
+        for (const sheetGrup of tablesBySheet) {
+            const worksheet = workbook.addWorksheet(sheetGrup.sheetName);
+            worksheet.views = [{ showGridLines: gridLinesGorunur }];
+            this.ustBilgileriYaz(worksheet, ustBilgiler, sonuc.defaultFont);
+            let sonSatir = 1;
+            for (const table of sheetGrup.tables) {
+                sonSatir = Math.max(sonSatir, this.tabloyuYaz(worksheet, sonuc, table));
+            }
+            this.notlariYazList(worksheet, notlar, sonuc.not?.font, sonSatir + 2, sonuc.defaultFont);
+        }
+        if (tablesBySheet.length === 0) {
+            const worksheet = workbook.addWorksheet(this.bosRaporSheetAdiniVer(sonuc));
+            worksheet.views = [{ showGridLines: gridLinesGorunur }];
+            this.ustBilgileriYaz(worksheet, ustBilgiler, sonuc.defaultFont);
+            this.notlariYazList(worksheet, notlar, sonuc.not?.font, ustBilgiler.length + 2, sonuc.defaultFont);
+        }
+    }
+    static sheetBazliTablolar(sonuc) {
+        const grouped = new Map();
+        for (const table of sonuc.tables ?? []) {
+            const sheetNo = this.tableSheetNoVer(table);
+            const sheetKey = this.sheetKeyVer(table, sheetNo, grouped.size + 1);
+            const existing = grouped.get(sheetKey);
+            if (existing) {
+                existing.tables.push(table);
+                continue;
+            }
+            grouped.set(sheetKey, {
+                sheetName: this.sheetAdiniBelirle(sonuc, table, grouped.size + 1, sheetNo),
+                ...(sheetNo !== undefined && { sheetNo }),
+                tables: [table]
+            });
+        }
+        return Array.from(grouped.values()).sort((a, b) => this.sheetGrupSirasiVer(a) - this.sheetGrupSirasiVer(b));
+    }
+    static tableSheetNoVer(table) {
+        const runtimeTable = table;
+        return runtimeTable.sheetNo;
+    }
+    static sheetKeyVer(table, sheetNo, index) {
+        if (sheetNo !== undefined) {
+            return `sheet-no-${sheetNo}`;
+        }
+        const eskiSheetName = table.sheetName?.trim();
+        if (eskiSheetName) {
+            return `sheet-name-${eskiSheetName}`;
+        }
+        return `sheet-index-${index}`;
+    }
+    static sheetAdiniBelirle(sonuc, table, index, sheetNo) {
+        const jsonSheet = this.jsonSheetBul(sonuc.sheets, sheetNo, index);
+        if (jsonSheet?.sheetName?.trim()) {
+            return this.sayfaAdiDuzenle(jsonSheet.sheetName, index);
+        }
+        return this.sayfaAdiDuzenle(table.sheetName || 'Rapor', index);
+    }
+    static jsonSheetBul(sheets, sheetNo, index) {
+        if (sheetNo !== undefined) {
+            return sheets.find(sheet => sheet.sheetNo === sheetNo);
+        }
+        return sheets.find(sheet => sheet.sheetNo === index) ?? sheets[index - 1];
+    }
+    static konuVer(book, ilkUstBilgi) {
+        return book.subject || ilkUstBilgi || 'Rapor';
+    }
+    static bosRaporSheetAdiniVer(sonuc) {
+        const ilkSheetAdi = sonuc.sheets[0]?.sheetName;
+        return this.sayfaAdiDuzenle(ilkSheetAdi || 'Rapor', 1);
+    }
+    static aktifSayfayiAyarla(workbook, activeSheetNo, toplamSheetSayisi) {
+        const aktifTab = this.aktifTabNoVer(activeSheetNo, toplamSheetSayisi);
+        if (aktifTab === undefined) {
+            return;
+        }
+        workbook.views = [{
+                activeTab: aktifTab,
+                firstSheet: aktifTab,
+                height: 20000,
+                visibility: 'visible',
+                width: 20000,
+                x: 0,
+                y: 0
+            }];
+    }
+    static aktifTabNoVer(activeSheetNo, toplamSheetSayisi) {
+        if (toplamSheetSayisi <= 0) {
+            return undefined;
+        }
+        const aktifSheetNo = Number.isFinite(activeSheetNo) && activeSheetNo > 0 ? activeSheetNo : 1;
+        return Math.min(aktifSheetNo - 1, toplamSheetSayisi - 1);
+    }
+    static sheetGrupSirasiVer(sheetGrup) {
+        return sheetGrup.sheetNo ?? Number.MAX_SAFE_INTEGER;
+    }
+    static yeniFormatUstBilgileriYaz(worksheet, ustBilgiler, defaultFont) {
+        for (let index = 0; index < ustBilgiler.length; index++) {
+            const ustBilgi = ustBilgiler[index];
+            const hucre = worksheet.getCell(index + 1, 1);
+            hucre.value = ustBilgi.ustBilgi;
+            this.hucreFontunuUygula(hucre, ustBilgi.font, defaultFont);
+            hucre.alignment = { horizontal: 'left', vertical: 'middle', wrapText: false };
+        }
+    }
+    static ustBilgileriYaz(worksheet, ustBilgiler, defaultFont) {
+        for (const ustBilgi of ustBilgiler) {
+            const hucre = worksheet.getCell(ustBilgi.rowNo ?? 1, 1);
+            hucre.value = ustBilgi.ustBilgi;
+            this.hucreFontunuUygula(hucre, ustBilgi.font, defaultFont);
+            hucre.alignment = { horizontal: 'left', vertical: 'middle', wrapText: false };
+        }
+    }
+    static notlariYazList(worksheet, notlar, notFont, baslangicSatiri, defaultFont) {
+        let satirNo = baslangicSatiri;
+        for (const not of notlar) {
+            const cell = worksheet.getCell(satirNo, 1);
+            cell.value = not;
+            this.hucreFontunuUygula(cell, notFont, defaultFont);
+            cell.alignment = { vertical: 'middle', wrapText: true };
+            satirNo++;
+        }
+    }
+    static sayfaDuzeniniBelirle(worksheet, sheet) {
+        const { pageSetup } = sheet;
+        if (!pageSetup) {
+            return;
+        }
+        if (pageSetup.orientation === 2) {
+            worksheet.pageSetup.orientation = 'landscape';
+        }
+        else if (pageSetup.orientation === 1) {
+            worksheet.pageSetup.orientation = 'portrait';
+        }
+        const hasMargin = pageSetup.leftMargin !== undefined ||
+            pageSetup.rightMargin !== undefined ||
+            pageSetup.topMargin !== undefined ||
+            pageSetup.bottomMargin !== undefined ||
+            pageSetup.headerMargin !== undefined ||
+            pageSetup.footerMargin !== undefined;
+        if (hasMargin) {
+            worksheet.pageSetup.margins = {
+                left: pageSetup.leftMargin ?? 0.7,
+                right: pageSetup.rightMargin ?? 0.7,
+                top: pageSetup.topMargin ?? 0.75,
+                bottom: pageSetup.bottomMargin ?? 0.75,
+                header: pageSetup.headerMargin ?? 0.3,
+                footer: pageSetup.footerMargin ?? 0.3
+            };
+        }
+        if (pageSetup.centerHorizontally !== undefined) {
+            worksheet.pageSetup.horizontalCentered = pageSetup.centerHorizontally;
+        }
+        if (pageSetup.centerVertically !== undefined) {
+            worksheet.pageSetup.verticalCentered = pageSetup.centerVertically;
+        }
+        const fitTall = pageSetup.fitToPagesTall;
+        const fitWide = pageSetup.fitToPagesWide;
+        if (fitTall !== undefined || fitWide !== undefined || pageSetup.fitToPagesTAut || pageSetup.fitToPagesWAut) {
+            worksheet.pageSetup.fitToPage = true;
+            worksheet.pageSetup.fitToHeight = pageSetup.fitToPagesTAut ? 0 : (fitTall ?? 1);
+            worksheet.pageSetup.fitToWidth = pageSetup.fitToPagesWAut ? 0 : (fitWide ?? 1);
+        }
+        if (typeof pageSetup.zoom === 'number' && pageSetup.zoom > 0) {
+            worksheet.pageSetup.scale = pageSetup.zoom;
+        }
+        if (pageSetup.printArea) {
+            worksheet.pageSetup.printArea = pageSetup.printArea;
+        }
+        const pageHeader = this.baslikAltbilgiMetniOlustur(pageSetup.leftHeader, pageSetup.centerHeader, pageSetup.rightHeader);
+        const pageFooter = this.baslikAltbilgiMetniOlustur(pageSetup.leftFooter, pageSetup.centerFooter, pageSetup.rightFooter);
+        if (pageHeader) {
+            worksheet.headerFooter.oddHeader = pageHeader;
+        }
+        if (pageFooter) {
+            worksheet.headerFooter.oddFooter = pageFooter;
+        }
+    }
+    static baslikAltbilgiMetniOlustur(sol, orta, sag) {
+        const parcalar = [];
+        if (sol) {
+            parcalar.push(`&L${sol}`);
+        }
+        if (orta) {
+            parcalar.push(`&C${orta}`);
+        }
+        if (sag) {
+            parcalar.push(`&R${sag}`);
+        }
+        return parcalar.length ? parcalar.join('') : undefined;
+    }
+    static tabloyuYaz(worksheet, sonuc, table) {
+        if (!table.columns.length) {
+            return table.ust ?? 1;
+        }
+        const startRow = Math.max(1, table.ust ?? 1);
+        const startCol = Math.max(1, table.sol ?? 1);
+        const gecerliTableStyle = this.gecerliTableStyleVer(sonuc.currentTableStyle);
+        const headerTitlelari = table.columns.map(column => this.baslikMetniniHazirla(column.header.title || ''));
+        const gorunenBaslikMetinleri = headerTitlelari.map(title => title.replaceAll('\n', ' '));
+        const tabloKolonAdlari = this.benzersizKolonAdlariOlustur(gorunenBaslikMetinleri);
+        const headerFont = table.header?.font;
+        const uygulanacakHeaderFont = headerFont?.color ? headerFont : {
+            ...headerFont,
+            color: 'FFFFFFFF'
+        };
+        const dataFont = table.data?.font;
+        const hiddenRowSet = new Set(table.hiddenRows ?? []);
+        const formulCeller = [];
+        const satirlar = table.collection.map((rowData, rowIndex) => table.columns.map((column, colIndex) => {
+            const deger = this.hucreDegeriniHazirla(rowData, column, sonuc.sifirlariBasmaSayi);
+            if (deger !== null && typeof deger === 'object' && 'formula' in deger) {
+                formulCeller.push({ rowIndex, colIndex, column, formula: deger });
+                return '';
+            }
+            return deger;
+        }));
+        this.kolonGrubuYaz(worksheet, startRow, startCol, table);
+        const tableStyle = this.tableStyleDonustur(gecerliTableStyle);
+        worksheet.addTable({
+            name: this.tabloAdiOlustur(worksheet.name, startRow, startCol),
+            ref: worksheet.getCell(startRow, startCol).address,
+            headerRow: true,
+            totalsRow: false,
+            ...(tableStyle && { style: tableStyle }),
+            columns: tabloKolonAdlari.map(ad => ({ name: ad, filterButton: true })),
+            rows: satirlar
+        });
+        this.kolonGenislikleriniUygula(worksheet, startCol, table.columns, satirlar);
+        const headerRow = worksheet.getRow(startRow);
+        for (let colIndex = 0; colIndex < table.columns.length; colIndex++) {
+            const column = table.columns[colIndex];
+            const cell = headerRow.getCell(startCol + colIndex);
+            cell.alignment = {
+                horizontal: this.yatayHizaDonustur(column.header.horizontalAlignment),
+                vertical: 'bottom',
+                wrapText: false
+            };
+            this.hucreFontunuUygula(cell, uygulanacakHeaderFont, sonuc.defaultFont);
+        }
+        for (let rowIndex = 0; rowIndex < table.collection.length; rowIndex++) {
+            const wsRow = worksheet.getRow(startRow + 1 + rowIndex);
+            const satir1Bazli = rowIndex + 1;
+            if (hiddenRowSet.has(satir1Bazli)) {
+                wsRow.hidden = true;
+            }
+            const rowHeight = table.rowHeights?.find(rh => rh.rowNo === satir1Bazli);
+            if (rowHeight?.height) {
+                wsRow.height = rowHeight.height;
+            }
+            for (let colIndex = 0; colIndex < table.columns.length; colIndex++) {
+                const column = table.columns[colIndex];
+                const cell = wsRow.getCell(startCol + colIndex);
+                const hucreDegeri = satirlar[rowIndex][colIndex];
+                cell.value = hucreDegeri;
+                this.hucreFontunuUygula(cell, dataFont, sonuc.defaultFont);
+                const numFmt = this.numberFormatDonustur(column.format);
+                if (numFmt) {
+                    cell.numFmt = numFmt;
+                }
+                cell.alignment = {
+                    horizontal: this.hucreYatayHizasiniBelirle(hucreDegeri, column),
+                    vertical: this.dikeyHizaDonustur(column.verticalAlignment),
+                    wrapText: false
+                };
+                // Sütun rengi
+                const colFontColor = table.columnFontColors?.[colIndex];
+                if (colFontColor) {
+                    const argb = this.argbDonustur(colFontColor);
+                    if (argb) {
+                        cell.font = { ...(cell.font ?? {}), color: { argb } };
+                    }
+                }
+                const colIntColor = table.columnInteriorColors?.[colIndex];
+                if (colIntColor) {
+                    const argb = this.argbDonustur(colIntColor);
+                    if (argb) {
+                        cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb } };
+                    }
+                }
+                // Satır rengi (sütun rengini ezer)
+                const rowFontColor = table.rowFontColors?.find(rc => rc.rowNo === satir1Bazli);
+                if (rowFontColor) {
+                    const argb = this.argbDonustur(rowFontColor.color);
+                    if (argb) {
+                        cell.font = { ...(cell.font ?? {}), color: { argb } };
+                    }
+                }
+                const rowIntColor = table.rowInteriorColors?.find(rc => rc.rowNo === satir1Bazli);
+                if (rowIntColor) {
+                    const argb = this.argbDonustur(rowIntColor.color);
+                    if (argb) {
+                        cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb } };
+                    }
+                }
+            }
+        }
+        for (const { rowIndex, colIndex, column, formula } of formulCeller) {
+            const cell = worksheet.getRow(startRow + 1 + rowIndex).getCell(startCol + colIndex);
+            cell.value = formula;
+            cell.alignment = {
+                ...(cell.alignment ?? {}),
+                horizontal: this.hucreYatayHizasiniBelirle(formula, column)
+            };
+        }
+        let sonSatir = startRow + table.collection.length;
+        // Footer satırları
+        const footer = table.footer;
+        if (footer?.basilacak) {
+            const ustBosluk = footer.ustBosluk ?? 0;
+            const satirSayisi = footer.satirSayisi ?? 1;
+            const footerBasSatir = sonSatir + 1 + ustBosluk;
+            for (let fi = 0; fi < satirSayisi; fi++) {
+                const footerRow = worksheet.getRow(footerBasSatir + fi);
+                for (let colIndex = 0; colIndex < table.columns.length; colIndex++) {
+                    const column = table.columns[colIndex];
+                    const cell = footerRow.getCell(startCol + colIndex);
+                    this.hucreFontunuUygula(cell, footer.font, sonuc.defaultFont);
+                    const colFooter = column.footer;
+                    if (!colFooter?.isFunction && colFooter?.title) {
+                        cell.value = colFooter.title;
+                    }
+                    cell.alignment = {
+                        horizontal: this.yatayHizaDonustur(colFooter?.horizontalAlignment),
+                        vertical: 'middle',
+                        wrapText: false
+                    };
+                }
+            }
+            sonSatir = footerBasSatir + satirSayisi - 1;
+        }
+        return sonSatir;
+    }
+    static kolonGenislikleriniUygula(worksheet, startCol, columns, satirlar) {
+        const filtreButonuBoslukPayi = 1.25;
+        const veriSagBoslukPayi = 1;
+        for (let index = 0; index < columns.length; index++) {
+            const worksheetColumn = worksheet.getColumn(startCol + index);
+            const baslikUzunlugu = this.metinUzunlugu(this.baslikMetniniHazirla(columns[index].header.title));
+            const veriUzunlugu = satirlar.reduce((max, satir) => Math.max(max, this.hucreMetinUzunlugu(satir[index])), 0);
+            const tasarimGenisligi = (columns[index].width ?? 0) > 0 ? Math.round(columns[index].width / 7) : 0;
+            worksheetColumn.width = Math.max(10, tasarimGenisligi, baslikUzunlugu + 2 + filtreButonuBoslukPayi, veriUzunlugu + 2 + veriSagBoslukPayi);
+        }
+    }
+    static baslikMetniniHazirla(metin) {
+        return metin
+            .replaceAll('\r\n', ' ')
+            .replaceAll('\r', ' ')
+            .replaceAll('\n', ' ')
+            .trim();
+    }
+    static hucreMetinUzunlugu(deger) {
+        if (deger === null || deger === undefined) {
+            return 0;
+        }
+        if (typeof deger === 'string') {
+            return this.metinUzunlugu(deger);
+        }
+        if (typeof deger === 'number' || typeof deger === 'boolean') {
+            return String(deger).length;
+        }
+        if (deger instanceof Date) {
+            return '14.05.2026 09:13:29'.length;
+        }
+        if (typeof deger === 'object' && 'formula' in deger) {
+            return this.metinUzunlugu(String(deger.formula));
+        }
+        return this.metinUzunlugu(String(deger));
+    }
+    static hucreYatayHizasiniBelirle(deger, column) {
+        if (typeof deger === 'number') {
+            return 'right';
+        }
+        if (typeof deger === 'object' && deger !== null && 'formula' in deger && this.sayisalFormatMi(column.format)) {
+            return 'right';
+        }
+        return this.yatayHizaDonustur(column.horizontalAlignment);
+    }
+    static sayisalFormatMi(format) {
+        switch (format) {
+            case NumberFormatlar.long:
+            case NumberFormatlar.real:
+            case NumberFormatlar.yuzde_BirHane:
+            case 2:
+            case 5:
+            case 7:
+            case 11:
+            case 12:
+                return true;
+            default:
+                return false;
+        }
+    }
+    static metinUzunlugu(metin) {
+        return metin
+            .replaceAll('\r', '')
+            .split('\n')
+            .reduce((max, parca) => Math.max(max, parca.trim().length), 0);
+    }
+    static kolonGrubuYaz(worksheet, startRow, startCol, table) {
+        const columnGroups = table.columnGroup;
+        if (!columnGroups?.length || startRow <= 1) {
+            return;
+        }
+        const grupSatiri = startRow - 1;
+        for (const columnGroup of columnGroups) {
+            const baslangicIndex = table.columns.findIndex(column => column.property === columnGroup.groupStart);
+            const bitisIndex = table.columns.findIndex(column => column.property === columnGroup.groupEnd);
+            const baslangicKolonu = baslangicIndex >= 0 ? startCol + baslangicIndex : undefined;
+            const bitisKolonu = bitisIndex >= 0 ? startCol + bitisIndex : undefined;
+            if (!baslangicKolonu || !bitisKolonu || bitisKolonu < baslangicKolonu) {
+                continue;
+            }
+            worksheet.mergeCells(grupSatiri, baslangicKolonu, grupSatiri, bitisKolonu);
+            const grupHucre = worksheet.getCell(grupSatiri, baslangicKolonu);
+            grupHucre.value = columnGroup.groupName;
+            grupHucre.alignment = { horizontal: 'center', vertical: 'middle' };
+            grupHucre.font = { bold: true, size: 11, color: { argb: 'FFF79646' } };
+            grupHucre.fill = {
+                type: 'pattern',
+                pattern: 'solid',
+                fgColor: { argb: 'FFFFFFFF' }
+            };
+            for (let col = baslangicKolonu; col <= bitisKolonu; col++) {
+                const hucre = worksheet.getCell(grupSatiri, col);
+                hucre.border = {
+                    ...hucre.border,
+                    top: { style: 'medium', color: { argb: 'FFF79646' } },
+                    ...(col === baslangicKolonu ? { left: { style: 'medium', color: { argb: 'FFF79646' } } } : (hucre.border?.left ? { left: hucre.border.left } : {})),
+                    ...(col === bitisKolonu ? { right: { style: 'medium', color: { argb: 'FFF79646' } } } : (hucre.border?.right ? { right: hucre.border.right } : {}))
+                };
+            }
+        }
+    }
+    static hucreDegeriniHazirla(row, column, sifirlariBasmaSayi) {
+        const value = row[column.property];
+        if ((typeof value === 'string') && value.startsWith('=')) {
+            return { formula: this.excelFormuluneDonustur(value) };
+        }
+        if ((typeof value === 'number') && sifirlariBasmaSayi && (value === 0)) {
+            return '';
+        }
+        if (value === null || value === undefined) {
+            return '';
+        }
+        if (typeof value === 'boolean' || typeof value === 'number' || typeof value === 'string' || value instanceof Date) {
+            return value;
+        }
+        return String(value);
+    }
+    static benzersizKolonAdlariOlustur(adlar) {
+        const sayaclar = new Map();
+        return adlar.map(ad => {
+            const temelAd = ad || ' ';
+            const sayi = sayaclar.get(temelAd) ?? 0;
+            sayaclar.set(temelAd, sayi + 1);
+            return sayi === 0 ? temelAd : `${temelAd}_${sayi}`;
+        });
+    }
+    static hucreFontunuUygula(cell, font, defaultFont) {
+        const style = font?.style ?? 0;
+        const excelFont = {};
+        const fontName = font?.name || defaultFont?.name;
+        if (fontName) {
+            excelFont.name = fontName;
+        }
+        const fontSize = (font?.size && font.size > 0) ? font.size : defaultFont?.size;
+        if (fontSize && fontSize > 0) {
+            excelFont.size = fontSize;
+        }
+        if (font?.color) {
+            const color = this.argbDonustur(font.color);
+            if (color) {
+                excelFont.color = { argb: color };
+            }
+        }
+        excelFont.bold = Boolean(style & FontStyle.bold);
+        excelFont.italic = Boolean(style & FontStyle.italic);
+        excelFont.underline = Boolean(style & FontStyle.underline);
+        cell.font = excelFont;
+    }
+    static gecerliTableStyleVer(tableStyle) {
+        if (!tableStyle) {
+            return undefined;
+        }
+        const style = tableStyle.trim();
+        if (/^TableStyleLight([1-9]|1\d|2[0-1])$/.test(style)) {
+            return style;
+        }
+        if (/^TableStyleMedium([1-9]|1\d|2[0-1])$/.test(style)) {
+            return style;
+        }
+        if (/^TableStyleDark([1-9]|10|11)$/.test(style)) {
+            return style;
+        }
+        return undefined;
+    }
+    static tableStyleDonustur(theme) {
+        if (!theme) {
+            return undefined;
+        }
+        return {
+            theme: theme,
+            showRowStripes: true
+        };
+    }
+    static tabloAdiOlustur(sheetName, startRow, startCol) {
+        const temizSheetName = sheetName.replaceAll(/[^A-Za-z0-9]/g, '_');
+        return `T_${temizSheetName}_R${startRow}C${startCol}`;
+    }
+    static yatayHizaDonustur(value) {
+        switch (value) {
+            case XLHAlign.xlHAlignCenter: return 'center';
+            case XLHAlign.xlHAlignCenterAcrossSelection: return 'centerContinuous';
+            case XLHAlign.xlHAlignDistributed: return 'distributed';
+            case XLHAlign.xlHAlignFill: return 'fill';
+            case XLHAlign.xlHAlignGeneral: return 'left';
+            case XLHAlign.xlHAlignJustify: return 'justify';
+            case XLHAlign.xlHAlignLeft: return 'left';
+            case XLHAlign.xlHAlignRight: return 'right';
+            default: return 'left';
+        }
+    }
+    static dikeyHizaDonustur(value) {
+        switch (value) {
+            case XLVAlign.xlVAlignTop: return 'top';
+            case XLVAlign.xlVAlignBottom: return 'bottom';
+            case XLVAlign.xlVAlignDistributed: return 'distributed';
+            case XLVAlign.xlVAlignJustify: return 'justify';
+            default: return 'middle';
+        }
+    }
+    static argbDonustur(color) {
+        if (!color) {
+            return undefined;
+        }
+        if (/^[0-9A-Fa-f]{8}$/.test(color)) {
+            return color.toUpperCase();
+        }
+        const numericColor = Number(color);
+        if (!Number.isFinite(numericColor)) {
+            return undefined;
+        }
+        const r = numericColor & 255;
+        const g = (numericColor >> 8) & 255;
+        const b = (numericColor >> 16) & 255;
+        return `FF${[r, g, b].map(value => value.toString(16).padStart(2, '0')).join('').toUpperCase()}`;
+    }
+    static excelFormuluneDonustur(formul) {
+        const ceviriler = {
+            'TOPLA': 'SUM',
+            'EĞER': 'IF',
+            'VE': 'AND',
+            'VEYA': 'OR',
+            'YUVARLA': 'ROUND',
+            'EĞERSAY': 'COUNTIF',
+            'ETOPLA': 'SUMIF',
+            'ORTALAMA': 'AVERAGE',
+            'MİN': 'MIN',
+            'MAK': 'MAX'
+        };
+        let sonuc = formul.slice(1).replaceAll(';', ',');
+        for (const [kaynak, hedef] of Object.entries(ceviriler)) {
+            const pattern = new RegExp(`\\b${kaynak}\\b`, 'g');
+            sonuc = sonuc.replace(pattern, hedef);
+        }
+        return sonuc;
+    }
+    static sayfaAdiDuzenle(sheetName, index) {
+        const temizAd = sheetName
+            .replaceAll(/[\\/*?:[\]]/g, ' ')
+            .trim()
+            .slice(0, 31);
+        if (temizAd) {
+            return temizAd;
+        }
+        return `Sheet${index}`;
+    }
+    static dosyaAdiDuzenle(dosyaAdi) {
+        const temizAd = dosyaAdi
+            .replaceAll(/[<>:"/\\|?*]/g, ' ')
+            .trim()
+            .replaceAll(/\s+/g, ' ');
+        if (temizAd) {
+            return temizAd;
+        }
+        return 'Rapor';
+    }
+    static numberFormatDonustur(format) {
+        switch (format) {
+            case NumberFormatlar.long:
+            case 2:
+            case 5:
+            case 11:
+                return '#,##0';
+            case NumberFormatlar.real:
+            case 7:
+            case 12:
+                return '#,##0.00';
+            case 8:
+                return 'hh:mm';
+            case NumberFormatlar.tarih:
+                return 'dd.mm.yyyy';
+            case NumberFormatlar.tarih_yyyymmdd_tireli:
+                return 'yyyy-mm-dd';
+            case NumberFormatlar.tarih_AAAAYYYY:
+                return 'mmmm yyyy';
+            case NumberFormatlar.tarih_GGAAAAYYYY:
+                return 'dd mmmm yyyy';
+            case NumberFormatlar.tarih_YYYYMMDD:
+                return 'yyyy/mm/dd';
+            case NumberFormatlar.tarih_LongDate:
+                return 'dd mmmm yyyy dddd';
+            case NumberFormatlar.tarih_ga:
+                return 'd.m;@';
+            case NumberFormatlar.tarih_ggaa:
+                return 'dd.mm';
+            case NumberFormatlar.tarih_gaaaa:
+                return 'd.mmmm';
+            case NumberFormatlar.tarih_ggaaa:
+                return 'dd.mmm';
+            case NumberFormatlar.tarih_ggaaaa:
+                return 'dd.mmmm';
+            case NumberFormatlar.yuzde_BirHane:
+                return '0.0%';
+            case NumberFormatlar.genel:
+                return 'General';
+            case NumberFormatlar.metin:
+                return '@';
+            case NumberFormatlar.imp:
+                return '#,##0 "imp"';
+            case NumberFormatlar.clicks:
+                return '#,##0 "Clicks"';
+            case NumberFormatlar.gun:
+                return '#,##0 "Gün"';
+            case NumberFormatlar.view:
+                return '#,##0 "View"';
+            case NumberFormatlar.session:
+                return '#,##0 "Session"';
+            case NumberFormatlar.kisi:
+                return '#,##0 "Kişi"';
+            case NumberFormatlar.okunma:
+                return '#,##0 "Okunma"';
+            case NumberFormatlar.dinlenme:
+                return '#,##0 "Dinlenme"';
+            case NumberFormatlar.lead:
+                return '#,##0 "Lead"';
+            case NumberFormatlar.gizli:
+                return ';;;';
+            default:
+                return undefined;
+        }
+    }
+}
+
+class BlobResponseHandlerService {
+    constructor() {
+        this.translateService = inject(TranslateService);
+    }
+    handleReportResponse(response, successDetailKey, htmlTitle = 'Rapor Sonucu') {
+        const body = response.body;
+        if (!body) {
+            return null;
+        }
+        const contentDisposition = response.headers.get('content-disposition');
+        const contentType = response.headers.get('Content-Type') ?? body.type;
+        if (contentDisposition) {
+            return this.handleDownload(body, contentDisposition, contentType, successDetailKey);
+        }
+        this.handleViewHtml(body, htmlTitle);
+        return null;
+    }
+    downloadResponse(response) {
+        const body = response.body;
+        if (!body) {
+            return false;
+        }
+        const contentDisposition = response.headers.get('content-disposition');
+        if (!contentDisposition) {
+            return false;
+        }
+        const contentType = response.headers.get('Content-Type') ?? (body instanceof Blob ? body.type : 'application/octet-stream');
+        this.downloadBlob(body, contentDisposition, contentType);
+        return true;
+    }
+    viewHtmlBody(body, htmlTitle = 'Rapor Sonucu') {
+        if (!body) {
+            return;
+        }
+        this.handleViewHtml(body, htmlTitle);
+    }
+    async handleJsonExcelResponse(body, options) {
+        if (!body) {
+            return null;
+        }
+        try {
+            const jsonStr = await body.text();
+            const result = Object.assign(options.createResult(), JSON.parse(jsonStr));
+            const fileName = options.getFileName?.(result) ?? options.fileName;
+            if (!fileName) {
+                return null;
+            }
+            await JsonToExcelParser.indir(result, fileName);
+            return {
+                severity: 'success',
+                summary: this.translateService.instant('genel.bilgi'),
+                detail: options.successDetail ?? this.translateService.instant(options.successDetailKey ?? '')
+            };
+        }
+        catch (error) {
+            console.error(options.errorLogMessage, error);
+            return null;
+        }
+    }
+    handleDownload(body, contentDisposition, contentType, successDetailKey) {
+        this.downloadBlob(body, contentDisposition, contentType);
+        return {
+            severity: 'success',
+            summary: this.translateService.instant('genel.bilgi'),
+            detail: this.translateService.instant(successDetailKey)
+        };
+    }
+    downloadBlob(body, contentDisposition, contentType) {
+        const decodedContentDisposition = contentDisposition.replaceAll(/\\u([0-9A-Fa-f]{4})/g, (_, code) => String.fromCodePoint(Number.parseInt(code, 16)));
+        const filename = GlobalFunctions.getFilenameFromContentDisposition(decodedContentDisposition);
+        const blob = new Blob([body], { type: contentType });
+        saveAs(blob, filename);
+    }
+    handleViewHtml(body, htmlTitle) {
+        body.text().then((html) => {
+            const wnd = window.open('', '_blank');
+            if (!wnd) {
+                return;
+            }
+            wnd.document.title = htmlTitle;
+            const iframe = wnd.document.createElement('iframe');
+            iframe.style.width = '100%';
+            iframe.style.height = '100%';
+            iframe.style.border = 'none';
+            iframe.setAttribute('srcdoc', html);
+            wnd.document.body.style.margin = '0';
+            wnd.document.body.style.padding = '0';
+            wnd.document.body.appendChild(iframe);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: BlobResponseHandlerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: BlobResponseHandlerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: BlobResponseHandlerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class ExcelRaporuSonuc {
+    constructor() {
+        this.book = {
+            author: 'MedPlan',
+            activeSheetNo: 1
+        };
+        this.defaultFont = {
+            name: 'Calibri',
+            size: 11
+        };
+        this.currentTableStyle = '';
+        this.sifirlariBasmaSayi = false;
+        this.sifirlariBasmaTarih = false;
+        // Yeni format: her sheet kendi tablolarını, üst bilgilerini ve notlarını taşır
+        this.sheets = [];
+        this.window = {
+            displayGridLines: false
+        };
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BlobResponseHandlerService, ExcelRaporuSonuc, JsonToExcelParser };
+//# sourceMappingURL=limitng-blob-response-handler.mjs.map