beautiful-grid 1.0.12 → 1.0.13

package/cjs/utils/exportExcel.js

@@ -0,0 +1,317 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeXml = escapeXml;
+exports.colIndexToExcelColumn = colIndexToExcelColumn;
+exports.serializeGridExportDataToExcel = serializeGridExportDataToExcel;
+exports.downloadExcel = downloadExcel;
+function makeCrc32Table() {
+    var table = new Uint32Array(256);
+    for (var i = 0; i < 256; i++) {
+        var c = i;
+        for (var k = 0; k < 8; k++) {
+            c = (c & 1) ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1);
+        }
+        table[i] = c;
+    }
+    return table;
+}
+var crcTable = makeCrc32Table();
+function calculateCrc32(bytes) {
+    var crc = 0xffffffff;
+    for (var i = 0; i < bytes.length; i++) {
+        crc = (crc >>> 8) ^ crcTable[(crc ^ bytes[i]) & 0xff];
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;')
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, '');
+}
+function colIndexToExcelColumn(colIndex) {
+    var name = '';
+    var n = colIndex;
+    while (n >= 0) {
+        name = String.fromCharCode((n % 26) + 65) + name;
+        n = Math.floor(n / 26) - 1;
+    }
+    return name;
+}
+function createZipArchive(files) {
+    var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+    var encoder = new TextEncoder();
+    var fileEntries = [];
+    var offset = 0;
+    try {
+        for (var files_1 = __values(files), files_1_1 = files_1.next(); !files_1_1.done; files_1_1 = files_1.next()) {
+            var file = files_1_1.value;
+            var nameBytes = encoder.encode(file.name);
+            var dataBytes = typeof file.data === 'string' ? encoder.encode(file.data) : file.data;
+            var crc = calculateCrc32(dataBytes);
+            var localHeader = new Uint8Array(30 + nameBytes.length);
+            var dv = new DataView(localHeader.buffer);
+            dv.setUint32(0, 0x04034b50, true); // Local file header signature
+            dv.setUint16(4, 20, true); // Version needed to extract (2.0)
+            dv.setUint16(6, 0x0800, true); // Bit flag: UTF-8 filename (bit 11)
+            dv.setUint16(8, 0, true); // Compression method: STORE (0)
+            dv.setUint16(10, 0, true); // File last mod time
+            dv.setUint16(12, 0, true); // File last mod date
+            dv.setUint32(14, crc, true); // CRC-32
+            dv.setUint32(18, dataBytes.length, true); // Compressed size
+            dv.setUint32(22, dataBytes.length, true); // Uncompressed size
+            dv.setUint16(26, nameBytes.length, true); // Filename length
+            dv.setUint16(28, 0, true); // Extra field length
+            localHeader.set(nameBytes, 30);
+            fileEntries.push({
+                nameBytes: nameBytes,
+                dataBytes: dataBytes,
+                crc: crc,
+                localHeader: localHeader,
+                offset: offset,
+            });
+            offset += localHeader.length + dataBytes.length;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (files_1_1 && !files_1_1.done && (_a = files_1.return)) _a.call(files_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var centralDirEntries = [];
+    var centralDirSize = 0;
+    try {
+        for (var fileEntries_1 = __values(fileEntries), fileEntries_1_1 = fileEntries_1.next(); !fileEntries_1_1.done; fileEntries_1_1 = fileEntries_1.next()) {
+            var entry = fileEntries_1_1.value;
+            var cd = new Uint8Array(46 + entry.nameBytes.length);
+            var dv = new DataView(cd.buffer);
+            dv.setUint32(0, 0x02014b50, true); // Central file header signature
+            dv.setUint16(4, 20, true); // Version made by
+            dv.setUint16(6, 20, true); // Version needed to extract
+            dv.setUint16(8, 0x0800, true); // Bit flag: UTF-8
+            dv.setUint16(10, 0, true); // Compression method: STORE
+            dv.setUint16(12, 0, true); // File last mod time
+            dv.setUint16(14, 0, true); // File last mod date
+            dv.setUint32(16, entry.crc, true); // CRC-32
+            dv.setUint32(20, entry.dataBytes.length, true); // Compressed size
+            dv.setUint32(24, entry.dataBytes.length, true); // Uncompressed size
+            dv.setUint16(28, entry.nameBytes.length, true); // Filename length
+            dv.setUint16(30, 0, true); // Extra field length
+            dv.setUint16(32, 0, true); // File comment length
+            dv.setUint16(34, 0, true); // Disk number start
+            dv.setUint16(36, 0, true); // Internal file attributes
+            dv.setUint32(38, 0, true); // External file attributes
+            dv.setUint32(42, entry.offset, true); // Relative offset of local header
+            cd.set(entry.nameBytes, 46);
+            centralDirEntries.push(cd);
+            centralDirSize += cd.length;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (fileEntries_1_1 && !fileEntries_1_1.done && (_b = fileEntries_1.return)) _b.call(fileEntries_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    var eocd = new Uint8Array(22);
+    var dvEocd = new DataView(eocd.buffer);
+    dvEocd.setUint32(0, 0x06054b50, true); // End of central dir signature
+    dvEocd.setUint16(4, 0, true); // Number of this disk
+    dvEocd.setUint16(6, 0, true); // Number of disk with start of central directory
+    dvEocd.setUint16(8, fileEntries.length, true); // Total entries in this disk
+    dvEocd.setUint16(10, fileEntries.length, true); // Total entries
+    dvEocd.setUint32(12, centralDirSize, true); // Size of the central directory
+    dvEocd.setUint32(16, offset, true); // Offset of start of central directory
+    dvEocd.setUint16(20, 0, true); // ZIP file comment length
+    var totalLength = offset + centralDirSize + 22;
+    var result = new Uint8Array(totalLength);
+    var pos = 0;
+    try {
+        for (var fileEntries_2 = __values(fileEntries), fileEntries_2_1 = fileEntries_2.next(); !fileEntries_2_1.done; fileEntries_2_1 = fileEntries_2.next()) {
+            var entry = fileEntries_2_1.value;
+            result.set(entry.localHeader, pos);
+            pos += entry.localHeader.length;
+            result.set(entry.dataBytes, pos);
+            pos += entry.dataBytes.length;
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (fileEntries_2_1 && !fileEntries_2_1.done && (_c = fileEntries_2.return)) _c.call(fileEntries_2);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    try {
+        for (var centralDirEntries_1 = __values(centralDirEntries), centralDirEntries_1_1 = centralDirEntries_1.next(); !centralDirEntries_1_1.done; centralDirEntries_1_1 = centralDirEntries_1.next()) {
+            var cd = centralDirEntries_1_1.value;
+            result.set(cd, pos);
+            pos += cd.length;
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (centralDirEntries_1_1 && !centralDirEntries_1_1.done && (_d = centralDirEntries_1.return)) _d.call(centralDirEntries_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    result.set(eocd, pos);
+    return result;
+}
+function formatCellValueAsXml(cellValue, cellRef) {
+    if (cellValue === null || cellValue === undefined || cellValue === '') {
+        return "<c r=\"".concat(cellRef, "\"/>");
+    }
+    if (typeof cellValue === 'number') {
+        if (Number.isFinite(cellValue)) {
+            return "<c r=\"".concat(cellRef, "\"><v>").concat(cellValue, "</v></c>");
+        }
+        return "<c r=\"".concat(cellRef, "\" t=\"inlineStr\"><is><t>").concat(escapeXml(String(cellValue)), "</t></is></c>");
+    }
+    if (typeof cellValue === 'boolean') {
+        return "<c r=\"".concat(cellRef, "\" t=\"b\"><v>").concat(cellValue ? 1 : 0, "</v></c>");
+    }
+    if (typeof cellValue === 'bigint') {
+        return "<c r=\"".concat(cellRef, "\" t=\"inlineStr\"><is><t>").concat(cellValue.toString(), "</t></is></c>");
+    }
+    if (cellValue instanceof Date) {
+        var dateStr = Number.isNaN(cellValue.getTime()) ? 'Invalid Date' : cellValue.toISOString();
+        return "<c r=\"".concat(cellRef, "\" t=\"inlineStr\"><is><t>").concat(escapeXml(dateStr), "</t></is></c>");
+    }
+    var text;
+    if (typeof cellValue === 'object') {
+        try {
+            text = JSON.stringify(cellValue);
+        }
+        catch (_a) {
+            text = String(cellValue);
+        }
+    }
+    else {
+        text = String(cellValue);
+    }
+    return "<c r=\"".concat(cellRef, "\" t=\"inlineStr\"><is><t xml:space=\"preserve\">").concat(escapeXml(text), "</t></is></c>");
+}
+function serializeGridExportDataToExcel(data, options) {
+    var e_5, _a;
+    var _b;
+    var includeHeader = (_b = options === null || options === void 0 ? void 0 : options.includeHeader) !== null && _b !== void 0 ? _b : true;
+    var rawSheetName = ((options === null || options === void 0 ? void 0 : options.sheetName) || 'Sheet1').trim().replace(/[:\\/?*\[\]]/g, '');
+    if (!rawSheetName) {
+        rawSheetName = 'Sheet1';
+    }
+    else if (rawSheetName.length > 31) {
+        rawSheetName = rawSheetName.slice(0, 31);
+    }
+    var sheetRows = [];
+    var rowIndex = 1;
+    if (includeHeader) {
+        var headerCells = data.columns
+            .map(function (col, colIdx) {
+            var cellRef = "".concat(colIndexToExcelColumn(colIdx)).concat(rowIndex);
+            return formatCellValueAsXml(col.header, cellRef);
+        })
+            .join('');
+        sheetRows.push("<row r=\"".concat(rowIndex, "\">").concat(headerCells, "</row>"));
+        rowIndex++;
+    }
+    try {
+        for (var _c = __values(data.rows), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var row = _d.value;
+            var rowCells = row.cells
+                .map(function (cell, colIdx) {
+                var cellRef = "".concat(colIndexToExcelColumn(colIdx)).concat(rowIndex);
+                return formatCellValueAsXml(cell, cellRef);
+            })
+                .join('');
+            sheetRows.push("<row r=\"".concat(rowIndex, "\">").concat(rowCells, "</row>"));
+            rowIndex++;
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    var contentTypesXml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+        '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">' +
+        '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>' +
+        '<Default Extension="xml" ContentType="application/xml"/>' +
+        '<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>' +
+        '<Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>' +
+        '</Types>';
+    var rootRelsXml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+        '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">' +
+        '<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>' +
+        '</Relationships>';
+    var workbookRelsXml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+        '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">' +
+        '<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>' +
+        '</Relationships>';
+    var workbookXml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+        '<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">' +
+        "<sheets><sheet name=\"".concat(escapeXml(rawSheetName), "\" sheetId=\"1\" r:id=\"rId1\"/></sheets>") +
+        '</workbook>';
+    var worksheetXml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+        '<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">' +
+        "<sheetData>".concat(sheetRows.join(''), "</sheetData>") +
+        '</worksheet>';
+    return createZipArchive([
+        { name: '[Content_Types].xml', data: contentTypesXml },
+        { name: '_rels/.rels', data: rootRelsXml },
+        { name: 'xl/_rels/workbook.xml.rels', data: workbookRelsXml },
+        { name: 'xl/workbook.xml', data: workbookXml },
+        { name: 'xl/worksheets/sheet1.xml', data: worksheetXml },
+    ]);
+}
+function downloadExcel(blobOrBytes, fileName) {
+    if (fileName === void 0) { fileName = 'export.xlsx'; }
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+        return;
+    }
+    var resolvedName = (fileName || '').trim();
+    if (!resolvedName) {
+        resolvedName = 'export.xlsx';
+    }
+    else if (!resolvedName.toLowerCase().endsWith('.xlsx')) {
+        resolvedName += '.xlsx';
+    }
+    var blob = blobOrBytes instanceof Blob
+        ? blobOrBytes
+        : new Blob([blobOrBytes], {
+            type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        });
+    if (typeof URL !== 'undefined' && typeof URL.createObjectURL === 'function') {
+        var url = URL.createObjectURL(blob);
+        var link = document.createElement('a');
+        link.href = url;
+        link.setAttribute('download', resolvedName);
+        link.style.display = 'none';
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        if (typeof URL.revokeObjectURL === 'function') {
+            URL.revokeObjectURL(url);
+        }
+    }
+}

package/cjs/utils/index.js

@@ -43,3 +43,6 @@ __exportStar(require("./rowReorder"), exports);
 __exportStar(require("./checkboxEditor"), exports);
 __exportStar(require("./columnVisibility"), exports);
 __exportStar(require("./checkedIndexes"), exports);
+__exportStar(require("./exportData"), exports);
+__exportStar(require("./exportCsv"), exports);
+__exportStar(require("./exportExcel"), exports);

package/esm/BGrid.js

@@ -685,7 +685,8 @@ export function BGrid({ ref, width, height, headerHeight = 30, footerHeight, sum
     ]);
     return (React.createElement(AppStoreProvider, { initialState: initialStoreState },
         React.createElement(TreeContext.Provider, { value: treeContextValue },
-            React.createElement(Table, { ref: ref, columns: computedColumns,
+            React.createElement(Table, { ref: ref, sourceColumns: resolvedColumns,
+                columns: computedColumns,
                 columnsGroup: visibilityProjection.columnsGroup,
                 columnGroups: visibilityProjection.columnGroups,
                 onChangeColumns: resolvedOnChangeColumns,

package/esm/components/Table.js

@@ -1,9 +1,9 @@
 import * as React from 'react';
 import { useCallback, useEffect, useRef } from 'react';
 import { useShallow } from 'zustand/react/shallow';
-import { useAppStore } from '../store';
+import { useAppStore, useAppStoreApi } from '../store';
 import { BGridDataItemStatus, } from '../types';
-import { getCellValueByRowKey, getFrozenColumnsWidth, getRowIndexAtOffset, getVisibleScrollableRowRange, getVirtualScrollWindowMetrics, getVirtualScrollWindowPosition, isCheckboxValueChecked, markCellEdited, markCellValueChanged, rebaseVirtualScrollWindow, resolveLogicalCell, shouldRenderBottomBar, } from '../utils';
+import { getCellValueByRowKey, getFrozenColumnsWidth, getRowIndexAtOffset, getVisibleScrollableRowRange, getVirtualScrollWindowMetrics, getVirtualScrollWindowPosition, isCheckboxValueChecked, markCellEdited, markCellValueChanged, rebaseVirtualScrollWindow, resolveLogicalCell, shouldRenderBottomBar, createGridExportData, serializeGridExportDataToCsv, downloadCsv, } from '../utils';
 import { clamp, ensureCellVisible } from '../utils/coordinate';
 import Loading from './Loading';
 import TableBody, { createRowKeyRegistry } from './TableBody';
@@ -29,6 +29,7 @@ const LazyGridOptionalSurfaces = React.lazy(() => import('./GridOptionalSurfaces
     default: module.GridOptionalSurfaces,
 })));
 function Table(props) {
+    const store = useAppStoreApi();
     const { cellSelectionOptions, onChangeData, sourceIndexByVisibleIndex } = props;
     const cellSelectionEnabled = cellSelectionOptions?.enabled ?? true;
     const rowKeyRegistryState = useRef({
@@ -507,11 +508,42 @@ function Table(props) {
     const scrollPropsRef = useRef({ top: props.scrollTop, left: props.scrollLeft });
     const syncedDataPropRef = useRef(props.data);
     const [rowScrollRequest, setRowScrollRequest] = React.useState(null);
+    const sourceColumnsRef = useRef(props.sourceColumns);
+    sourceColumnsRef.current = props.sourceColumns;
+    const getCurrentExportData = useCallback((options) => {
+        const state = store.getState();
+        return createGridExportData({
+            options,
+            columns: state.columns,
+            sourceColumns: sourceColumnsRef.current,
+            data: state.data,
+            sourceData: state.sourceData,
+            sourceIndexByVisibleIndex: state.sourceIndexByVisibleIndex,
+            visibleIndexBySourceIndex: state.visibleIndexBySourceIndex,
+            checkedIndexesMap: state.checkedIndexesMap,
+            rowKey: state.rowKey,
+        });
+    }, [store]);
     React.useImperativeHandle(props.ref, () => ({
         scrollToRow(rowIndex, options) {
             setRowScrollRequest({ rowIndex, align: options?.align ?? 'nearest' });
         },
-    }), []);
+        getExportData(options) {
+            return getCurrentExportData(options);
+        },
+        exportCsv(options) {
+            const exportData = getCurrentExportData(options);
+            const csv = serializeGridExportDataToCsv(exportData, options);
+            downloadCsv(csv, options?.fileName ?? 'export.csv');
+        },
+        exportExcel(options) {
+            const exportData = getCurrentExportData(options);
+            void import('../utils/exportExcel').then(({ serializeGridExportDataToExcel, downloadExcel }) => {
+                const excelBytes = serializeGridExportDataToExcel(exportData, options);
+                downloadExcel(excelBytes, options?.fileName ?? 'export.xlsx');
+            });
+        },
+    }), [getCurrentExportData]);
     const scrollRafRef = useRef(null);
     const scrollIdleTimerRef = useRef(null);
     const selectionAutoScrollRafRef = useRef(null);

package/esm/utils/exportCsv.js

@@ -0,0 +1,97 @@
+export function formatCsvCellValue(value, preventFormulaInjection = true) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    let formatted;
+    if (typeof value === 'string') {
+        formatted = value;
+        const startsWithFormula = /^[=+\-@]/.test(formatted);
+        const startsWithDangerousControl = /^[\t\r\n]/.test(formatted);
+        const hasFormulaAfterLeadingWhitespace = /^\s+[=+\-@]/.test(formatted);
+        if (preventFormulaInjection &&
+            (startsWithFormula || startsWithDangerousControl || hasFormulaAfterLeadingWhitespace)) {
+            formatted = `'${formatted}`;
+        }
+        return formatted;
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (value instanceof Date) {
+        return isNaN(value.getTime()) ? 'Invalid Date' : value.toISOString();
+    }
+    if (typeof value === 'object') {
+        try {
+            formatted = JSON.stringify(value);
+        }
+        catch {
+            formatted = String(value);
+        }
+        return formatted;
+    }
+    return String(value);
+}
+export function escapeCsvCell(cell, delimiter = ',') {
+    const needsQuotes = cell.includes(delimiter) ||
+        cell.includes('"') ||
+        cell.includes('\r') ||
+        cell.includes('\n');
+    if (needsQuotes) {
+        return `"${cell.replace(/"/g, '""')}"`;
+    }
+    return cell;
+}
+export function serializeGridExportDataToCsv(data, options) {
+    const delimiter = options?.delimiter ?? ',';
+    const newline = options?.newline ?? '\r\n';
+    const includeHeader = options?.includeHeader ?? true;
+    const bom = options?.bom ?? true;
+    const preventFormulaInjection = options?.preventFormulaInjection ?? true;
+    const lines = [];
+    if (includeHeader) {
+        const headerLine = data.columns
+            .map(col => escapeCsvCell(formatCsvCellValue(col.header, preventFormulaInjection), delimiter))
+            .join(delimiter);
+        lines.push(headerLine);
+    }
+    for (const row of data.rows) {
+        const rowLine = row.cells
+            .map(cell => escapeCsvCell(formatCsvCellValue(cell, preventFormulaInjection), delimiter))
+            .join(delimiter);
+        lines.push(rowLine);
+    }
+    const csvText = lines.join(newline);
+    return (bom ? '\uFEFF' : '') + csvText;
+}
+export function downloadCsv(csv, fileName = 'export.csv') {
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+        return;
+    }
+    let resolvedName = (fileName || '').trim();
+    if (!resolvedName) {
+        resolvedName = 'export.csv';
+    }
+    else if (!resolvedName.toLowerCase().endsWith('.csv')) {
+        resolvedName += '.csv';
+    }
+    const blob = new Blob([csv], { type: 'text/csv;charset=utf-8;' });
+    if (typeof URL !== 'undefined' && typeof URL.createObjectURL === 'function') {
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.setAttribute('download', resolvedName);
+        link.style.display = 'none';
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        if (typeof URL.revokeObjectURL === 'function') {
+            URL.revokeObjectURL(url);
+        }
+    }
+}

package/esm/utils/exportData.js

@@ -0,0 +1,154 @@
+import { getColumnId } from './getColumnId';
+import { getCellValueByRowKey } from './getCellValue';
+export function resolveExportColumns(columns, sourceColumns, scope = 'visible') {
+    let selectedColumns;
+    if (Array.isArray(scope)) {
+        const candidatePool = sourceColumns && sourceColumns.length > 0 ? sourceColumns : columns;
+        const columnMap = new Map();
+        for (const col of candidatePool) {
+            columnMap.set(getColumnId(col), col);
+        }
+        selectedColumns = [];
+        for (const id of scope) {
+            const col = columnMap.get(id);
+            if (col) {
+                selectedColumns.push(col);
+            }
+        }
+    }
+    else if (scope === 'all') {
+        selectedColumns = sourceColumns && sourceColumns.length > 0 ? [...sourceColumns] : [...columns];
+    }
+    else {
+        // 'visible'
+        selectedColumns = [...columns];
+    }
+    const exportableColumns = selectedColumns.filter(col => col.exportable !== false);
+    return exportableColumns.map((column, columnIndex) => {
+        const columnId = getColumnId(column);
+        let header;
+        if (typeof column.exportHeader === 'function') {
+            header = column.exportHeader(column);
+        }
+        else if (typeof column.exportHeader === 'string') {
+            header = column.exportHeader;
+        }
+        else if (typeof column.label === 'string' || typeof column.label === 'number') {
+            header = String(column.label);
+        }
+        else {
+            header = columnId;
+        }
+        return {
+            columnId,
+            header,
+            column,
+            columnIndex,
+        };
+    });
+}
+export function resolveExportRows(exportColumns, params) {
+    const rowScope = params.options?.rows ?? 'displayed';
+    const rows = [];
+    const sourcePool = params.sourceData && params.sourceData.length > 0 ? params.sourceData : params.data;
+    const buildCells = (item, values, sourceIndex, visibleIndex) => {
+        const cells = [];
+        for (const expCol of exportColumns) {
+            const rawValue = getCellValueByRowKey(expCol.column.key, values);
+            if (expCol.column.getExportValue) {
+                cells.push(expCol.column.getExportValue({
+                    column: expCol.column,
+                    columnId: expCol.columnId,
+                    visibleIndex,
+                    sourceIndex,
+                    item,
+                    values,
+                    value: rawValue,
+                }));
+            }
+            else {
+                cells.push(rawValue);
+            }
+        }
+        return cells;
+    };
+    const resolveRowKey = (item, values) => {
+        let rowKey;
+        if (params.rowKey !== undefined && values) {
+            const rawKey = getCellValueByRowKey(params.rowKey, values);
+            if (rawKey !== undefined && rawKey !== null) {
+                rowKey = rawKey;
+            }
+        }
+        if (rowKey === undefined && item?.key !== undefined) {
+            rowKey = item.key;
+        }
+        return rowKey;
+    };
+    if (rowScope === 'displayed') {
+        const displayData = params.data;
+        for (let visibleIndex = 0; visibleIndex < displayData.length; visibleIndex++) {
+            const item = displayData[visibleIndex] ?? { values: {} };
+            const sourceIndex = params.sourceIndexByVisibleIndex?.[visibleIndex] ?? visibleIndex;
+            const values = item.values ?? {};
+            const rowKey = resolveRowKey(item, values);
+            const cells = buildCells(item, values, sourceIndex, visibleIndex);
+            rows.push({
+                visibleIndex,
+                sourceIndex,
+                rowKey,
+                item,
+                values,
+                cells,
+            });
+        }
+    }
+    else if (rowScope === 'checked') {
+        const checkedMap = params.checkedIndexesMap;
+        for (let sourceIndex = 0; sourceIndex < sourcePool.length; sourceIndex++) {
+            if (!checkedMap?.has(sourceIndex))
+                continue;
+            const item = sourcePool[sourceIndex] ?? { values: {} };
+            const visibleIndex = params.visibleIndexBySourceIndex?.get(sourceIndex);
+            const values = item.values ?? {};
+            const rowKey = resolveRowKey(item, values);
+            const cells = buildCells(item, values, sourceIndex, visibleIndex);
+            rows.push({
+                visibleIndex,
+                sourceIndex,
+                rowKey,
+                item,
+                values,
+                cells,
+            });
+        }
+    }
+    else {
+        // 'source'
+        for (let sourceIndex = 0; sourceIndex < sourcePool.length; sourceIndex++) {
+            const item = sourcePool[sourceIndex] ?? { values: {} };
+            const visibleIndex = params.visibleIndexBySourceIndex?.get(sourceIndex);
+            const values = item.values ?? {};
+            const rowKey = resolveRowKey(item, values);
+            const cells = buildCells(item, values, sourceIndex, visibleIndex);
+            rows.push({
+                visibleIndex,
+                sourceIndex,
+                rowKey,
+                item,
+                values,
+                cells,
+            });
+        }
+    }
+    return rows;
+}
+export function createGridExportData(params) {
+    const columnScope = params.options?.columns ?? 'visible';
+    const columns = resolveExportColumns(params.columns, params.sourceColumns, columnScope);
+    const rows = resolveExportRows(columns, params);
+    return {
+        columns,
+        rows,
+    };
+}