beautiful-grid 1.0.11 → 1.0.13

package/esm/components/TableBodyCell.js

@@ -2,6 +2,7 @@ import * as React from 'react';
 import { PluginCellEditor } from './PluginCellEditor';
 import { CellEditorIcon } from './CellEditorIcon';
 import { CheckboxCellEditor } from './CheckboxCellEditor';
+import { TreeCell } from './TreeCell';
 function Cell({ index, hostIndex = index, columnIndex, column, item, valueByRowKey, handleSave, handleCancel, handleMove, editable, cellEditable, interactionEditing = false, editSession, }) {
     const isPluginEditorActive = Boolean(editable && editSession && column.editor?.type === 'plugin');
     let content;
@@ -36,7 +37,7 @@ function Cell({ index, hostIndex = index, columnIndex, column, item, valueByRowK
         content = renderSafeCellValue(valueByRowKey);
     }
     return (React.createElement("div", { className: isPluginEditorActive ? 'bgrid-cell-content bgrid-cell-content-plugin-editor' : 'bgrid-cell-content' },
-        React.createElement("div", { className: 'bgrid-cell-value' }, content),
+        React.createElement("div", { className: 'bgrid-cell-value' }, column.treeCell ? (React.createElement(TreeCell, { column: column, item: item }, content)) : (content)),
         column.editorIcon && column.editor?.type !== 'checkbox' && cellEditable && (React.createElement(CellEditorIcon, { hostCell: { rowIndex: hostIndex, columnIndex }, index: index, columnIndex: columnIndex, column: column, item: item, value: valueByRowKey, editing: interactionEditing }))));
 }
 function renderSafeCellValue(value, preserveRenderableArrays = false) {

package/esm/components/TableBodyRow.js

@@ -4,6 +4,7 @@ import { getCellValueByRowKey, isCellEdited, isCellValueChanged, resolveLogicalC
 import { TableBodyCell } from './TableBodyCell';
 import RowSelector from './RowSelector';
 import { GripVertical } from './GripVertical';
+import { useTreeContext } from './TreeContext';
 function TableBodyCellItemInner({ ri, columnIndex, column, canonicalIndex, canonicalItem, valueByRowKey, editable, disabled, editTrigger, rowSpan, isMerged, tdEditable, cellEditable, isLogicalEditing, isCheckboxEditor, isSearchMatch, isCurrentSearchMatch, cellInteractionSession, handleClick, setEditItem, setItemValue, handleMoveEditFocus, }) {
     const resolvedEditTrigger = column.editTrigger ?? editTrigger ?? 'dblclick';
     const edited = isCellEdited(canonicalItem, column);
@@ -55,9 +56,12 @@ function TableBodyCellItemInner({ ri, columnIndex, column, canonicalIndex, canon
 }
 const TableBodyCellItem = React.memo(TableBodyCellItemInner);
 function TableBodyRowInner({ item, data, ri, sourceIndex, columns, startCIdx, endCIdx, frozenColumnIndex, isLeftRegion, showLineNumber, hasRowChecked, isRadio, checked, rowCheckedDisabled, rowStatus, active, className, resolvedRowHeight, itemHeight, itemPadding, editable, disabled, editTrigger, hasOnClick, cellMergeOptions, mergeColumns, odd, variant, rowReorderEnabled, rowReorderRole, rowReorderPhase, rowReorderDirection, rowReorderOffset, reorder, reorderingInfo, searchMatchTokens, currentSearchToken, isRowEditing, cellInteractionSession, handleClick, setEditItem, setItemValue, handleMoveEditFocus, handleChangeChecked, handleChangeCheckedRadio, getRowSpan, onRowReorderPointerDown, onRowReorderKeyDown, }) {
+    const tree = useTreeContext();
+    const treeRowKey = tree?.getRowKey(item.values);
+    const treeMeta = treeRowKey === undefined ? undefined : tree?.metaByRowKey.get(treeRowKey);
     const clickable = !editable && hasOnClick;
     const rowClassName = ['bgrid-body-row', active ? 'bgrid-row-active' : '', className].filter(Boolean).join(' ');
-    return (React.createElement("tr", { className: rowClassName, "data-ri": ri, "data-odd": !mergeColumns && odd ? 'true' : undefined, "data-clickable": clickable ? 'true' : undefined, "data-bgrid-row-reorder-role": rowReorderRole, "data-bgrid-row-reorder-phase": rowReorderRole ? rowReorderPhase : undefined, "data-bgrid-row-reorder-direction": rowReorderRole ? rowReorderDirection : undefined, style: {
+    return (React.createElement("tr", { className: rowClassName, "data-ri": ri, "data-bgrid-tree-row": treeMeta ? 'true' : undefined, "aria-level": treeMeta ? treeMeta.depth + 1 : undefined, "aria-posinset": treeMeta ? treeMeta.siblingIndex + 1 : undefined, "aria-setsize": treeMeta?.siblingCount, "aria-expanded": treeMeta?.hasChildren ? treeMeta.expanded : undefined, "data-odd": !mergeColumns && odd ? 'true' : undefined, "data-clickable": clickable ? 'true' : undefined, "data-bgrid-row-reorder-role": rowReorderRole, "data-bgrid-row-reorder-phase": rowReorderRole ? rowReorderPhase : undefined, "data-bgrid-row-reorder-direction": rowReorderRole ? rowReorderDirection : undefined, style: {
             ['--bgrid-item-line-height']: `${itemHeight}px`,
             ['--bgrid-item-cell-height']: `${resolvedRowHeight}px`,
             ...(rowReorderRole && rowReorderRole !== 'source'

package/esm/components/TreeCell.js

@@ -0,0 +1,49 @@
+import * as React from 'react';
+import { useAppStoreApi } from '../store';
+import { getColumnId } from '../utils';
+import { useTreeContext } from './TreeContext';
+export function TreeCell({ column, item, children }) {
+    const tree = useTreeContext();
+    const store = useAppStoreApi();
+    if (!tree || getColumnId(column) !== tree.treeColumnId)
+        return React.createElement(React.Fragment, null, children);
+    const key = tree.getRowKey(item.values);
+    const meta = key === undefined ? undefined : tree.metaByRowKey.get(key);
+    if (!meta)
+        return React.createElement(React.Fragment, null, children);
+    return (React.createElement("span", { className: 'bgrid-tree-cell', style: {
+            '--bgrid-tree-depth': meta.depth,
+            '--bgrid-tree-indent-size': `${tree.indentSize}px`,
+        } },
+        meta.hasChildren ? (React.createElement("button", { type: 'button', className: 'bgrid-tree-toggle', "aria-expanded": meta.expanded, "aria-label": meta.expanded ? tree.collapseAriaLabel : tree.expandAriaLabel, disabled: tree.disabled, onClick: event => {
+                event.stopPropagation();
+                if (meta.expanded) {
+                    const state = store.getState();
+                    const activeCell = state.activeCell;
+                    const activeSourceIndex = activeCell === undefined
+                        ? undefined
+                        : state.sourceIndexByVisibleIndex?.[activeCell.rowIndex] ?? activeCell.rowIndex;
+                    let activeMeta = activeSourceIndex === undefined ? undefined : tree.metaBySourceIndex.get(activeSourceIndex);
+                    let activeIsDescendant = false;
+                    while (activeMeta?.parentSourceIndex !== undefined) {
+                        if (activeMeta.parentSourceIndex === meta.sourceIndex) {
+                            activeIsDescendant = true;
+                            break;
+                        }
+                        activeMeta = tree.metaBySourceIndex.get(activeMeta.parentSourceIndex);
+                    }
+                    state.clearCellSelection();
+                    if (activeCell && activeIsDescendant) {
+                        state.endCellEdit();
+                        state.setActiveCell({
+                            rowIndex: state.visibleIndexBySourceIndex?.get(meta.sourceIndex) ?? 0,
+                            columnIndex: activeCell.columnIndex,
+                        });
+                    }
+                }
+                tree.toggle(meta);
+            } },
+            React.createElement("span", { className: 'bgrid-tree-icon', "aria-hidden": 'true' }, meta.expanded ? tree.icons?.expanded ?? '⌄' : tree.icons?.collapsed ?? '›'))) : (React.createElement("span", { className: 'bgrid-tree-toggle-spacer', "aria-hidden": 'true' },
+            React.createElement("span", { className: 'bgrid-tree-icon' }, tree.icons?.leaf))),
+        React.createElement("span", { className: 'bgrid-tree-cell-content' }, children)));
+}

package/esm/components/TreeContext.js

@@ -0,0 +1,5 @@
+import * as React from 'react';
+export const TreeContext = React.createContext(undefined);
+export function useTreeContext() {
+    return React.useContext(TreeContext);
+}

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,
+    };
+}

package/esm/utils/exportExcel.js

@@ -0,0 +1,246 @@
+function makeCrc32Table() {
+    const table = new Uint32Array(256);
+    for (let i = 0; i < 256; i++) {
+        let c = i;
+        for (let k = 0; k < 8; k++) {
+            c = (c & 1) ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1);
+        }
+        table[i] = c;
+    }
+    return table;
+}
+const crcTable = makeCrc32Table();
+function calculateCrc32(bytes) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < bytes.length; i++) {
+        crc = (crc >>> 8) ^ crcTable[(crc ^ bytes[i]) & 0xff];
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+export 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, '');
+}
+export function colIndexToExcelColumn(colIndex) {
+    let name = '';
+    let n = colIndex;
+    while (n >= 0) {
+        name = String.fromCharCode((n % 26) + 65) + name;
+        n = Math.floor(n / 26) - 1;
+    }
+    return name;
+}
+function createZipArchive(files) {
+    const encoder = new TextEncoder();
+    const fileEntries = [];
+    let offset = 0;
+    for (const file of files) {
+        const nameBytes = encoder.encode(file.name);
+        const dataBytes = typeof file.data === 'string' ? encoder.encode(file.data) : file.data;
+        const crc = calculateCrc32(dataBytes);
+        const localHeader = new Uint8Array(30 + nameBytes.length);
+        const 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,
+            dataBytes,
+            crc,
+            localHeader,
+            offset,
+        });
+        offset += localHeader.length + dataBytes.length;
+    }
+    const centralDirEntries = [];
+    let centralDirSize = 0;
+    for (const entry of fileEntries) {
+        const cd = new Uint8Array(46 + entry.nameBytes.length);
+        const 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;
+    }
+    const eocd = new Uint8Array(22);
+    const 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
+    const totalLength = offset + centralDirSize + 22;
+    const result = new Uint8Array(totalLength);
+    let pos = 0;
+    for (const entry of fileEntries) {
+        result.set(entry.localHeader, pos);
+        pos += entry.localHeader.length;
+        result.set(entry.dataBytes, pos);
+        pos += entry.dataBytes.length;
+    }
+    for (const cd of centralDirEntries) {
+        result.set(cd, pos);
+        pos += cd.length;
+    }
+    result.set(eocd, pos);
+    return result;
+}
+function formatCellValueAsXml(cellValue, cellRef) {
+    if (cellValue === null || cellValue === undefined || cellValue === '') {
+        return `<c r="${cellRef}"/>`;
+    }
+    if (typeof cellValue === 'number') {
+        if (Number.isFinite(cellValue)) {
+            return `<c r="${cellRef}"><v>${cellValue}</v></c>`;
+        }
+        return `<c r="${cellRef}" t="inlineStr"><is><t>${escapeXml(String(cellValue))}</t></is></c>`;
+    }
+    if (typeof cellValue === 'boolean') {
+        return `<c r="${cellRef}" t="b"><v>${cellValue ? 1 : 0}</v></c>`;
+    }
+    if (typeof cellValue === 'bigint') {
+        return `<c r="${cellRef}" t="inlineStr"><is><t>${cellValue.toString()}</t></is></c>`;
+    }
+    if (cellValue instanceof Date) {
+        const dateStr = Number.isNaN(cellValue.getTime()) ? 'Invalid Date' : cellValue.toISOString();
+        return `<c r="${cellRef}" t="inlineStr"><is><t>${escapeXml(dateStr)}</t></is></c>`;
+    }
+    let text;
+    if (typeof cellValue === 'object') {
+        try {
+            text = JSON.stringify(cellValue);
+        }
+        catch {
+            text = String(cellValue);
+        }
+    }
+    else {
+        text = String(cellValue);
+    }
+    return `<c r="${cellRef}" t="inlineStr"><is><t xml:space="preserve">${escapeXml(text)}</t></is></c>`;
+}
+export function serializeGridExportDataToExcel(data, options) {
+    const includeHeader = options?.includeHeader ?? true;
+    let rawSheetName = (options?.sheetName || 'Sheet1').trim().replace(/[:\\/?*\[\]]/g, '');
+    if (!rawSheetName) {
+        rawSheetName = 'Sheet1';
+    }
+    else if (rawSheetName.length > 31) {
+        rawSheetName = rawSheetName.slice(0, 31);
+    }
+    const sheetRows = [];
+    let rowIndex = 1;
+    if (includeHeader) {
+        const headerCells = data.columns
+            .map((col, colIdx) => {
+            const cellRef = `${colIndexToExcelColumn(colIdx)}${rowIndex}`;
+            return formatCellValueAsXml(col.header, cellRef);
+        })
+            .join('');
+        sheetRows.push(`<row r="${rowIndex}">${headerCells}</row>`);
+        rowIndex++;
+    }
+    for (const row of data.rows) {
+        const rowCells = row.cells
+            .map((cell, colIdx) => {
+            const cellRef = `${colIndexToExcelColumn(colIdx)}${rowIndex}`;
+            return formatCellValueAsXml(cell, cellRef);
+        })
+            .join('');
+        sheetRows.push(`<row r="${rowIndex}">${rowCells}</row>`);
+        rowIndex++;
+    }
+    const 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>';
+    const 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>';
+    const 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>';
+    const 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="${escapeXml(rawSheetName)}" sheetId="1" r:id="rId1"/></sheets>` +
+        '</workbook>';
+    const worksheetXml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+        '<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">' +
+        `<sheetData>${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 },
+    ]);
+}
+export function downloadExcel(blobOrBytes, fileName = 'export.xlsx') {
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+        return;
+    }
+    let resolvedName = (fileName || '').trim();
+    if (!resolvedName) {
+        resolvedName = 'export.xlsx';
+    }
+    else if (!resolvedName.toLowerCase().endsWith('.xlsx')) {
+        resolvedName += '.xlsx';
+    }
+    const blob = blobOrBytes instanceof Blob
+        ? blobOrBytes
+        : new Blob([blobOrBytes], {
+            type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        });
+    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/index.js

@@ -16,6 +16,7 @@ export * from './number';
 export * from './buildHeaderMatrix';
 export * from './getVisibleScrollableRowRange';
 export * from './virtualScrollWindow';
+export * from './treeData';
 export * from './rowHeightMetrics';
 export * from './cellEditState';
 export * from './getCellSelectionAxisState';
@@ -26,3 +27,6 @@ export * from './rowReorder';
 export * from './checkboxEditor';
 export * from './columnVisibility';
 export * from './checkedIndexes';
+export * from './exportData';
+export * from './exportCsv';
+export * from './exportExcel';