beautiful-grid 1.0.12 → 1.0.13

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

@@ -27,3 +27,6 @@ export * from './rowReorder';
 export * from './checkboxEditor';
 export * from './columnVisibility';
 export * from './checkedIndexes';
+export * from './exportData';
+export * from './exportCsv';
+export * from './exportExcel';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beautiful-grid",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "A beautiful, powerful, open-source React Data Grid.",
   "homepage": "https://bgrid.axisj.com",
   "bugs": {

package/types/components/Table.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { Key } from 'react';
-import { BGridCellNavigationOptions, AppModelColumn, BGridColumnGroup, BGridColumnGroupNode, BGridColumnVisibilityState, BGridDataControl, BGridDataItem, BGridDataQuery, BGridPage, BGridProps, BGridRowChecked, BGridSortInfo, BGridSortParam, BGridResolvedScrollbarOptions, BGridResolvedStatusOptions, BGridResolvedPaginationViewOptions } from '../types';
+import { BGridCellNavigationOptions, BGridColumn, AppModelColumn, BGridColumnGroup, BGridColumnGroupNode, BGridColumnVisibilityState, BGridDataControl, BGridDataItem, BGridDataQuery, BGridPage, BGridProps, BGridRowChecked, BGridSortInfo, BGridSortParam, BGridResolvedScrollbarOptions, BGridResolvedStatusOptions, BGridResolvedPaginationViewOptions } from '../types';
 import { type BGridRowHeightMetrics } from '../utils';
 interface Props<T> {
     ref?: BGridProps<T>['ref'];
@@ -19,6 +19,7 @@ interface Props<T> {
     frozenColumnIndex?: number;
     frozenRowCount?: number;
     columns: AppModelColumn<T>[];
+    sourceColumns?: BGridColumn<T>[];
     columnsGroup: BGridColumnGroup[];
     columnGroups: BGridColumnGroupNode[];
     onChangeColumns?: BGridProps<T>['onChangeColumns'];

package/types/types.d.ts

@@ -148,6 +148,15 @@ export interface BGridSearchCellParams<T> {
     values: T;
     value: unknown;
 }
+export interface BGridCellExportValueParams<T> {
+    column: BGridColumn<T>;
+    columnId: string;
+    visibleIndex?: number;
+    sourceIndex: number;
+    item: BGridDataItem<T>;
+    values: T;
+    value: unknown;
+}
 export interface BGridColumn<T> {
     id?: string;
     key: string | string[];
@@ -184,6 +193,9 @@ export interface BGridColumn<T> {
         aItem: BGridDataItem<T>;
         bItem: BGridDataItem<T>;
     }) => number;
+    exportable?: boolean;
+    exportHeader?: string | ((column: BGridColumn<T>) => string);
+    getExportValue?: (params: BGridCellExportValueParams<T>) => unknown;
 }
 export interface BGridColumnGroup {
     label: ReactNode;
@@ -657,13 +669,72 @@ export interface BGridScrollToRowOptions {
     /** Defaults to nearest: scroll only as far as needed to reveal the row. */
     align?: 'start' | 'center' | 'end' | 'nearest';
 }
-export interface BGridRef {
+export type BGridExportRowScope = 'displayed' | 'checked' | 'source';
+export type BGridExportColumnScope = 'visible' | 'all' | readonly string[];
+export interface BGridExportColumn<T> {
+    columnId: string;
+    header: string;
+    column: BGridColumn<T>;
+    columnIndex: number;
+}
+export interface BGridExportRow<T> {
+    visibleIndex?: number;
+    sourceIndex: number;
+    rowKey?: React.Key;
+    item: BGridDataItem<T>;
+    values: T;
+    cells: unknown[];
+}
+export interface BGridExportData<T> {
+    columns: BGridExportColumn<T>[];
+    rows: BGridExportRow<T>[];
+}
+export interface BGridExportDataOptions {
+    rows?: BGridExportRowScope;
+    columns?: BGridExportColumnScope;
+}
+export interface BGridCsvSerializeOptions {
+    delimiter?: string;
+    newline?: '\n' | '\r\n';
+    includeHeader?: boolean;
+    bom?: boolean;
+    preventFormulaInjection?: boolean;
+}
+export interface BGridCsvExportOptions extends BGridExportDataOptions {
+    fileName?: string;
+    delimiter?: string;
+    newline?: '\n' | '\r\n';
+    includeHeader?: boolean;
+    bom?: boolean;
+    preventFormulaInjection?: boolean;
+}
+export interface BGridExcelSerializeOptions {
+    sheetName?: string;
+    includeHeader?: boolean;
+}
+export interface BGridExcelExportOptions extends BGridExportDataOptions, BGridExcelSerializeOptions {
+    fileName?: string;
+}
+export interface BGridRef<T = any> {
     /**
      * Reveal a zero-based row in the displayed (sorted/filtered) data on the current page.
      * Runs after pending data updates. Invalid indexes and frozen rows are ignored.
      * Preserves horizontal scroll, cell focus and selection; does not load other pages.
      */
     scrollToRow: (rowIndex: number, options?: BGridScrollToRowOptions) => void;
+    /**
+     * Extract logical grid data for export without touching the DOM.
+     * Supports displayed, checked, or source row scopes, and visible, all, or custom column scopes.
+     */
+    getExportData: (options?: BGridExportDataOptions) => BGridExportData<T>;
+    /**
+     * Serialize grid data and trigger a browser CSV file download.
+     */
+    exportCsv: (options?: BGridCsvExportOptions) => void;
+    /**
+     * Serialize grid data and trigger a browser Excel (.xlsx) file download.
+     */
+    exportExcel: (options?: BGridExcelExportOptions) => void;
 }
 export interface BGridToolboxMessages {
     sort?: string;
@@ -712,7 +783,7 @@ export interface BGridMessages {
     toolbox?: BGridToolboxMessages;
 }
 export interface BGridProps<T> {
-    ref?: React.Ref<BGridRef>;
+    ref?: React.Ref<BGridRef<T>>;
     width: number;
     height: number;
     headerHeight?: number;

package/types/utils/exportCsv.d.ts

@@ -0,0 +1,5 @@
+import { BGridCsvSerializeOptions, BGridExportData } from '../types';
+export declare function formatCsvCellValue(value: unknown, preventFormulaInjection?: boolean): string;
+export declare function escapeCsvCell(cell: string, delimiter?: string): string;
+export declare function serializeGridExportDataToCsv<T>(data: BGridExportData<T>, options?: BGridCsvSerializeOptions): string;
+export declare function downloadCsv(csv: string, fileName?: string): void;

package/types/utils/exportData.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { BGridColumn, BGridDataItem, BGridExportColumn, BGridExportColumnScope, BGridExportData, BGridExportDataOptions, BGridExportRow } from '../types';
+export declare function resolveExportColumns<T>(columns: readonly BGridColumn<T>[], sourceColumns?: readonly BGridColumn<T>[], scope?: BGridExportColumnScope): BGridExportColumn<T>[];
+export interface CreateGridExportDataParams<T> {
+    options?: BGridExportDataOptions;
+    columns: readonly BGridColumn<T>[];
+    sourceColumns?: readonly BGridColumn<T>[];
+    data: readonly BGridDataItem<T>[];
+    sourceData?: readonly BGridDataItem<T>[];
+    sourceIndexByVisibleIndex?: readonly number[];
+    visibleIndexBySourceIndex?: ReadonlyMap<number, number>;
+    checkedIndexesMap?: ReadonlyMap<number, unknown>;
+    rowKey?: React.Key | React.Key[];
+}
+export declare function resolveExportRows<T>(exportColumns: readonly BGridExportColumn<T>[], params: CreateGridExportDataParams<T>): BGridExportRow<T>[];
+export declare function createGridExportData<T>(params: CreateGridExportDataParams<T>): BGridExportData<T>;

package/types/utils/exportExcel.d.ts

@@ -0,0 +1,5 @@
+import { BGridExcelSerializeOptions, BGridExportData } from '../types';
+export declare function escapeXml(value: string): string;
+export declare function colIndexToExcelColumn(colIndex: number): string;
+export declare function serializeGridExportDataToExcel<T>(data: BGridExportData<T>, options?: BGridExcelSerializeOptions): Uint8Array;
+export declare function downloadExcel(blobOrBytes: Blob | Uint8Array, fileName?: string): void;

package/types/utils/index.d.ts

@@ -27,3 +27,6 @@ export * from './rowReorder';
 export * from './checkboxEditor';
 export * from './columnVisibility';
 export * from './checkedIndexes';
+export * from './exportData';
+export * from './exportCsv';
+export * from './exportExcel';