@coreui/data-grid 0.3.0-rc.0 → 0.4.0

package/dist/types/types.d.mts

@@ -0,0 +1,284 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid types.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+import type { Column, ColumnFiltersState, ColumnOrderState, ColumnPinningState, ColumnSizingState, ColumnVisibilityState, PaginationState, Row, RowSelectionState, SortingState, Table, TableFeatures, TableState } from '@tanstack/table-core';
+import type { DataGridFeatures } from './engine/features.mjs';
+import type { DataGridExportOptions } from './ui/toolbar.mjs';
+export type { Column, ColumnFiltersState, ColumnOrderState, ColumnPinningState, ColumnPinningPosition, ColumnSizingState, ColumnVisibilityState, PaginationState, RowSelectionState, SortingState, Table, TableFeatures } from '@tanstack/table-core';
+export type { DataGridFeatures } from './engine/features.mjs';
+export type { DataGridLiteFeatures } from './engine/features-lite.mjs';
+export type DataGridItem = Record<string, unknown>;
+export type DataGridTable<TFeatures extends TableFeatures = DataGridFeatures> = Table<TFeatures, DataGridItem>;
+export type DataGridTableState<TFeatures extends TableFeatures = DataGridFeatures> = TableState<TFeatures>;
+export type DataGridRow<TFeatures extends TableFeatures = DataGridFeatures> = Row<TFeatures, DataGridItem>;
+export type DataGridColumnPinning = Partial<ColumnPinningState>;
+export interface DataGridColumnFilterContext<TFeatures extends TableFeatures = DataGridFeatures> {
+    column: Column<TFeatures, DataGridItem, unknown>;
+    table: DataGridTable<TFeatures>;
+    labels: DataGridLabels;
+}
+export type DataGridColumnFilterFactory<TFeatures extends TableFeatures = DataGridFeatures> = (context: DataGridColumnFilterContext<TFeatures>) => DataGridSlot;
+export type DataGridFilterType = 'text' | 'number' | 'date' | 'select';
+export type DataGridFilterOperator = 'contains' | 'notContains' | 'equals' | 'notEquals' | 'startsWith' | 'endsWith' | 'blank' | 'notBlank' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'between';
+export interface DataGridFilterCondition {
+    operator: DataGridFilterOperator;
+    value?: unknown;
+    value2?: unknown;
+}
+export type DataGridColumnFilterValue = string | {
+    conditions: DataGridFilterCondition[];
+    join: 'and' | 'or';
+} | {
+    operator: 'in';
+    value: unknown[];
+};
+export type DataGridEditorType = 'text' | 'number' | 'select';
+export interface DataGridEditableOptions {
+    type?: DataGridEditorType;
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: Array<string | number | {
+        label: string;
+        value: unknown;
+    }>;
+}
+export interface DataGridEditorContext {
+    item: DataGridItem;
+    column: DataGridColumn;
+    value: unknown;
+    commit: (value: unknown) => void;
+    cancel: () => void;
+    labels: DataGridLabels;
+}
+export interface DataGridEditor {
+    element: HTMLElement;
+    contains?: (target: Node) => boolean;
+    dispose?: () => void;
+    focus?: () => void;
+    getValue?: () => unknown;
+    popup?: boolean;
+}
+export type DataGridEditorFactory = (context: DataGridEditorContext) => DataGridEditor;
+export interface DataGridEditCommitEvent {
+    item: DataGridItem;
+    columnId: string;
+    value: unknown;
+    previousValue: unknown;
+}
+export interface DataGridColumn<TFeatures extends TableFeatures = DataGridFeatures> {
+    key: string;
+    editable?: boolean | DataGridEditableOptions;
+    editor?: DataGridEditorFactory;
+    editValidate?: (value: unknown, item: DataGridItem) => true | string;
+    filter?: DataGridColumnFilterFactory<TFeatures>;
+    filterable?: boolean;
+    filterFn?: (value: unknown, filterValue: unknown, item: DataGridItem) => boolean;
+    filterType?: DataGridFilterType;
+    formatter?: (value: unknown, item: DataGridItem) => string;
+    hideable?: boolean;
+    label?: string;
+    movable?: boolean;
+    render?: (item: DataGridItem, index: number) => Node | string;
+    resizable?: boolean;
+    sortable?: boolean;
+    style?: Partial<CSSStyleDeclaration>;
+    width?: number;
+}
+export interface DataGridMenuAction {
+    key: string;
+    label: string;
+    disabled?: boolean;
+    group?: string;
+    icon?: string;
+    run: () => void;
+}
+export interface DataGridColumnMenuContext {
+    column: DataGridColumn;
+    defaultActions: DataGridMenuAction[];
+}
+export type DataGridColumnMenuBuilder = (context: DataGridColumnMenuContext) => DataGridMenuAction[];
+export interface DataGridLabels {
+    addCondition: string;
+    applyFilter: string;
+    clearFilter: string;
+    clearSort: string;
+    columnMenu: string;
+    filterAction: string;
+    filterColumn: string;
+    firstPage: string;
+    globalFilterLabel: string;
+    globalFilterPlaceholder: string;
+    hideColumn: string;
+    itemsInfo: string;
+    joinAnd: string;
+    joinOr: string;
+    lastPage: string;
+    loadError: string;
+    loading: string;
+    moveEnd: string;
+    moveStart: string;
+    nextPage: string;
+    operatorBetween: string;
+    operatorBlank: string;
+    operatorContains: string;
+    operatorEndsWith: string;
+    operatorEquals: string;
+    operatorGreaterThan: string;
+    operatorGreaterThanOrEqual: string;
+    operatorLessThan: string;
+    operatorLessThanOrEqual: string;
+    operatorNotBlank: string;
+    operatorNotContains: string;
+    operatorNotEquals: string;
+    operatorStartsWith: string;
+    pageSizeLabel: string;
+    paginationLabel: string;
+    pinEnd: string;
+    pinStart: string;
+    previousPage: string;
+    redoneAnnouncement: string;
+    reorderRow: string;
+    resetColumns: string;
+    resultsAnnouncement: string;
+    searchValues: string;
+    selectAllRows: string;
+    selectAllValues: string;
+    selectRow: string;
+    showAllColumns: string;
+    sortAscending: string;
+    sortDescending: string;
+    toolbarColumns: string;
+    toolbarExport: string;
+    toolbarPrint: string;
+    toolbarRedo: string;
+    toolbarUndo: string;
+    undoneAnnouncement: string;
+    unpin: string;
+}
+export interface DataGridColumnSizingOptions {
+    mode?: 'onChange' | 'onEnd';
+}
+export interface DataGridSlotContext<TFeatures extends TableFeatures = DataGridFeatures> {
+    table: DataGridTable<TFeatures>;
+    labels: DataGridLabels;
+}
+export interface DataGridSlot {
+    element: HTMLElement;
+    update?: () => void;
+    dispose?: () => void;
+}
+export type DataGridSlotFactory<TFeatures extends TableFeatures = DataGridFeatures> = (context: DataGridSlotContext<TFeatures>) => DataGridSlot;
+export interface DataGridSlots<TFeatures extends TableFeatures = DataGridFeatures> {
+    toolbar: DataGridSlotFactory<TFeatures>;
+    pagination: DataGridSlotFactory<TFeatures>;
+    empty: DataGridSlotFactory<TFeatures>;
+}
+export interface DataGridToolbarOptions {
+    columns?: boolean;
+    export?: boolean | DataGridExportOptions;
+    history?: boolean;
+    print?: boolean;
+    search?: boolean;
+}
+export interface DataGridSortingOptions {
+    multiple?: boolean;
+    resetable?: boolean;
+}
+export type DataGridSorterVisibility = 'always' | 'hover' | false;
+export interface DataGridRowSelectionOptions {
+    selectAll?: boolean;
+}
+export interface DataGridPaginationInfoState {
+    pageCount: number;
+    pageIndex: number;
+    pageSize: number;
+    totalRows: number;
+}
+export interface DataGridInfiniteScrollOptions {
+    pageSize?: number;
+    threshold?: number;
+}
+export interface DataGridPaginationOptions {
+    info?: boolean | ((state: DataGridPaginationInfoState) => string);
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    position?: 'top' | 'bottom' | 'both';
+}
+export interface DataGridState {
+    columnFilters: ColumnFiltersState;
+    columnOrder: ColumnOrderState;
+    columnPinning: ColumnPinningState;
+    columnSizing: ColumnSizingState;
+    columnVisibility: ColumnVisibilityState;
+    globalFilter: string;
+    pagination: PaginationState;
+    rowSelection: RowSelectionState;
+    sorting: SortingState;
+}
+export interface DataGridDataRequest {
+    columnFilters: ColumnFiltersState;
+    globalFilter: string;
+    pagination: PaginationState;
+    sorting: SortingState;
+}
+export interface DataGridDataResponse {
+    items: DataGridItem[];
+    totalRows: number;
+}
+export interface DataGridOptions<TFeatures extends TableFeatures = DataGridFeatures> {
+    autoRowHeight: boolean;
+    cellNavigation: boolean;
+    cellSelection: boolean;
+    columnFilters: boolean;
+    columnMenu: boolean | DataGridColumnMenuBuilder;
+    columnMenuIcon: string;
+    columnOrder: boolean | ColumnOrderState;
+    columnPinning: boolean | DataGridColumnPinning;
+    columnSizing: boolean | DataGridColumnSizingOptions;
+    columnVisibility: boolean | ColumnVisibilityState;
+    columns: Array<DataGridColumn<TFeatures>>;
+    dataProvider: ((request: DataGridDataRequest) => Promise<DataGridDataResponse>) | null;
+    editing: boolean;
+    empty: string | (() => Node | string);
+    features: TFeatures | null;
+    filterIcon: string;
+    globalFilter: boolean;
+    hideColumnIcon: string;
+    history: boolean;
+    infiniteScroll: boolean | DataGridInfiniteScrollOptions;
+    itemKey: ((item: DataGridItem, index: number) => string) | null;
+    items: DataGridItem[];
+    labels: Partial<DataGridLabels>;
+    moveEndIcon: string;
+    moveStartIcon: string;
+    overscan: number;
+    pagination: boolean | DataGridPaginationOptions;
+    pinEndIcon: string;
+    pinStartIcon: string;
+    printTitle: string | null;
+    rowHandleIcon: string;
+    rowHeight: number;
+    rowOrder: boolean;
+    rowSelection: boolean | DataGridRowSelectionOptions;
+    sanitize: boolean;
+    sanitizeFn: ((html: string) => string) | null;
+    slots: Partial<DataGridSlots<TFeatures>>;
+    sortAscendingIcon: string;
+    sortDescendingIcon: string;
+    sortNeutralIcon: string;
+    sorterVisibility: DataGridSorterVisibility;
+    sorting: boolean | DataGridSortingOptions;
+    stateKey: string | null;
+    toolbar: boolean | DataGridToolbarOptions;
+    toolbarColumnsIcon: string;
+    toolbarExportIcon: string;
+    toolbarPrintIcon: string;
+    toolbarRedoIcon: string;
+    toolbarUndoIcon: string;
+    unpinIcon: string;
+    virtualization: boolean;
+}

package/dist/types/ui/body.d.mts

@@ -0,0 +1,37 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid ui/body.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+import type { GridVirtualizerInstance } from '../engine/virtualizer.mjs';
+import type { DataGridColumn, DataGridLabels, DataGridRow } from '../types.mjs';
+import { type GridPinning } from './pinning.mjs';
+export interface GridBodyContext {
+    autoRowHeight: boolean;
+    cellNavigation: boolean;
+    headerRowCount: number;
+    labels: DataGridLabels;
+    getDataVersion: () => number;
+    getEditingCell: () => {
+        rowId: string;
+        columnId: string;
+    } | null;
+    getEditorElement: () => HTMLElement | null;
+    getPinning: () => GridPinning | null;
+    getRowIndexOffset: () => number;
+    getRows: () => DataGridRow[];
+    getVisibleColumns: () => DataGridColumn[];
+    getVirtualizer: () => GridVirtualizerInstance | null;
+    renderEmpty: () => Node | string;
+    sanitizeContent: (html: string) => string;
+    cellSelection: boolean;
+    rowOrder: boolean;
+    rowHandleIcon: string;
+    selection: boolean;
+}
+export interface GridBody {
+    element: HTMLTableSectionElement;
+    update: () => void;
+}
+export declare const createBody: (context: GridBodyContext) => GridBody;

package/dist/types/ui/column-chooser.d.mts

@@ -0,0 +1,27 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid ui/column-chooser.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+import type { DataGridLabels } from '../types.mjs';
+export interface ColumnChooserColumn {
+    id: string;
+    label: string;
+    canHide: boolean;
+    visible: boolean;
+}
+export interface GridColumnChooserContext {
+    root: HTMLElement;
+    labels: DataGridLabels;
+    getColumns: () => ColumnChooserColumn[];
+    toggleVisibility: (columnId: string, visible: boolean) => void;
+    showAll: () => void;
+    reset: () => void;
+}
+export interface GridColumnChooser {
+    toggle: (button: HTMLElement) => void;
+    close: () => void;
+    dispose: () => void;
+}
+export declare const createColumnChooser: (context: GridColumnChooserContext) => GridColumnChooser;

package/dist/types/ui/editor.d.mts

@@ -0,0 +1,8 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid ui/editor.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+import type { DataGridEditableOptions, DataGridEditor, DataGridEditorContext } from '../types.mjs';
+export declare const createBuiltInEditor: (options: DataGridEditableOptions, context: DataGridEditorContext) => DataGridEditor;

package/dist/types/ui/filter-menu.d.mts

@@ -0,0 +1,21 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid ui/filter-menu.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+import type { DataGridColumn, DataGridColumnFilterValue, DataGridLabels } from '../types.mjs';
+export interface GridFilterMenuContext {
+    root: HTMLElement;
+    labels: DataGridLabels;
+    getColumn: (columnKey: string) => DataGridColumn | null;
+    getFacetedValues: (columnKey: string) => unknown[];
+    getFilterValue: (columnKey: string) => DataGridColumnFilterValue | undefined;
+    applyFilter: (columnKey: string, value?: DataGridColumnFilterValue) => void;
+}
+export interface GridFilterMenu {
+    toggle: (button: HTMLElement, columnKey: string) => void;
+    close: () => void;
+    dispose: () => void;
+}
+export declare const createFilterMenu: (context: GridFilterMenuContext) => GridFilterMenu;

package/dist/types/ui/header.d.mts

@@ -0,0 +1,51 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid ui/header.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+import type { DataGridColumn, DataGridLabels, DataGridTable, SortingState } from '../types.mjs';
+import { type GridPinning } from './pinning.mjs';
+export interface GridHeaderContext {
+    cellNavigation: boolean;
+    columns: DataGridColumn[];
+    draggable: boolean;
+    filterRow: boolean;
+    hasMenu: (column: DataGridColumn) => boolean;
+    icons: {
+        columnMenu: string;
+        filter: string;
+        sortAscending: string;
+        sortDescending: string;
+        sortNeutral: string;
+    };
+    hasFilterMenu: (column: DataGridColumn) => boolean;
+    isFilterable: (column: DataGridColumn) => boolean;
+    isResizable: (column: DataGridColumn) => boolean;
+    isSortable: (column: DataGridColumn) => boolean;
+    labels: DataGridLabels;
+    resizable: boolean;
+    rowOrder: boolean;
+    selection: boolean;
+    selectAll: boolean;
+    table: DataGridTable;
+}
+export interface GridHeaderState {
+    filteredColumns: string[] | null;
+    order: string[];
+    pinning: GridPinning | null;
+    resizingColumn: string | false;
+    sizes: Record<string, number> | null;
+    sorting: SortingState;
+    selectAll: {
+        checked: boolean;
+        indeterminate: boolean;
+    } | null;
+}
+export interface GridHeader {
+    element: HTMLTableSectionElement;
+    rowCount: number;
+    update: (state: GridHeaderState) => void;
+    dispose: () => void;
+}
+export declare const createHeader: (context: GridHeaderContext) => GridHeader;

package/dist/types/ui/loading.d.mts

@@ -0,0 +1,12 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid ui/loading.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+import type { DataGridLabels } from '../types.mjs';
+export interface GridLoading {
+    element: HTMLDivElement;
+    setVisible: (visible: boolean) => void;
+}
+export declare const createLoading: (labels: DataGridLabels, className?: string) => GridLoading;

package/dist/types/ui/menu.d.mts

@@ -0,0 +1,17 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid ui/menu.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+import type { DataGridMenuAction } from '../types.mjs';
+export interface GridMenuContext {
+    root: HTMLElement;
+    getActions: (columnKey: string) => DataGridMenuAction[];
+}
+export interface GridMenu {
+    toggle: (button: HTMLElement, columnKey: string) => void;
+    close: () => void;
+    dispose: () => void;
+}
+export declare const createMenu: (context: GridMenuContext) => GridMenu;

package/dist/types/ui/pagination.d.mts

@@ -0,0 +1,17 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid ui/pagination.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+import type { DataGridLabels, DataGridPaginationInfoState } from '../types.mjs';
+export interface GridPaginationContext {
+    info: boolean | ((state: DataGridPaginationInfoState) => string);
+    labels: DataGridLabels;
+    pageSizeOptions: number[];
+}
+export interface GridPagination {
+    element: HTMLDivElement;
+    update: (state: DataGridPaginationInfoState) => void;
+}
+export declare const createPagination: (context: GridPaginationContext) => GridPagination;

package/dist/types/ui/pinning.d.mts

@@ -0,0 +1,17 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid ui/pinning.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+export interface PinnedCellInfo {
+    side: 'start' | 'end';
+    offset: number;
+    edge: boolean;
+    afterSelect: boolean;
+}
+export interface GridPinning {
+    columns: Record<string, PinnedCellInfo>;
+    select: PinnedCellInfo | null;
+}
+export declare const applyPinnedCell: (cell: HTMLTableCellElement, info: PinnedCellInfo | null) => void;

package/dist/types/ui/toolbar.d.mts

@@ -0,0 +1,42 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid ui/toolbar.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+import type { CsvDownloadOptions, CsvTable } from '../util/csv.mjs';
+import type { DataGridLabels, DataGridOptions } from '../types.mjs';
+export interface GridToolbarContext {
+    labels: DataGridLabels;
+    columns: boolean;
+    export: boolean;
+    history: boolean;
+    print: boolean;
+    search: boolean;
+    icons: {
+        columns: string;
+        export: string;
+        print: string;
+        redo: string;
+        undo: string;
+    };
+}
+export interface GridToolbar {
+    element: HTMLDivElement;
+}
+export type DataGridExporter = (table: CsvTable, options: DataGridExportOptions) => void;
+export interface DataGridExportOptions extends CsvDownloadOptions {
+    sheetName?: string;
+    exporter?: DataGridExporter;
+}
+export interface ResolvedToolbar {
+    columns: boolean;
+    export: boolean;
+    exportOptions: DataGridExportOptions;
+    history: boolean;
+    print: boolean;
+    search: boolean;
+}
+export declare const resolveToolbar: (options: DataGridOptions) => ResolvedToolbar;
+export declare const isGlobalFilterEnabled: (options: DataGridOptions) => boolean;
+export declare const createToolbar: (context: GridToolbarContext) => GridToolbar;

package/dist/types/ui/tooltip.d.mts

@@ -0,0 +1,10 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid ui/tooltip.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+export interface GridTooltip {
+    dispose: () => void;
+}
+export declare const createTooltip: (root: HTMLElement) => GridTooltip;

package/dist/types/util/clipboard.d.mts

@@ -1 +1,29 @@
-export * from './clipboard.js'
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid util/clipboard.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+import type { DataGridItem } from '../types.mjs';
+export interface ClipboardBounds {
+    maxColumnIndex: number;
+    maxRowIndex: number;
+    minColumnIndex: number;
+    minRowIndex: number;
+}
+export interface ClipboardRow {
+    getValue: (columnId: string) => unknown;
+    original: DataGridItem;
+}
+export interface ClipboardTable {
+    getCellSelectionBounds: () => ClipboardBounds[];
+    getRowModel: () => {
+        rows: ClipboardRow[];
+    };
+}
+export interface ClipboardColumn {
+    id: string;
+    formatter?: (value: unknown, item: DataGridItem) => string;
+}
+export declare const serializeCellSelection: (table: ClipboardTable, columns: ClipboardColumn[]) => string;
+export declare const copyCellSelection: (table: ClipboardTable, columns: ClipboardColumn[]) => Promise<string>;

package/dist/types/util/config.d.mts

@@ -0,0 +1,28 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI util/config.ts
+ * Licensed under MIT (https://github.com/coreui/coreui/blob/main/LICENSE)
+ *
+ * This is a modified version of the Bootstrap's util/config.ts
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+/**
+ * Types
+ */
+type ComponentConfig = Record<string, any>;
+/**
+ * Class definition
+ */
+declare class Config {
+    ['constructor']: typeof Config;
+    static get Default(): ComponentConfig;
+    static get DefaultType(): ComponentConfig;
+    static get NAME(): string;
+    _getConfig(config?: ComponentConfig | null): ComponentConfig;
+    _configAfterMerge(config: ComponentConfig): ComponentConfig;
+    _mergeConfigObj(config?: ComponentConfig | null, element?: Element): ComponentConfig;
+    _typeCheckConfig(config: ComponentConfig, configTypes?: ComponentConfig): void;
+}
+export default Config;
+export type { ComponentConfig };

package/dist/types/util/csv.d.mts

@@ -1 +1,19 @@
-export * from './csv.js'
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid util/csv.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+import { type ExportScope, type ExportTable } from './export-table.mjs';
+export interface CsvOptions {
+    scope?: ExportScope;
+    delimiter?: string;
+    bom?: boolean;
+    sanitize?: boolean;
+}
+export interface CsvDownloadOptions extends CsvOptions {
+    filename?: string;
+}
+export type CsvTable = ExportTable;
+export declare const exportCsv: (table: CsvTable, options?: CsvOptions) => string;
+export declare const downloadCsv: (table: CsvTable, options?: CsvDownloadOptions) => void;

package/dist/types/util/debounce.d.mts

@@ -0,0 +1,7 @@
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid util/debounce.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+export declare const debounce: <Args extends unknown[]>(callback: (...args: Args) => void, delay: number) => ((...args: Args) => void);

package/dist/types/util/direction.d.mts

@@ -1 +1,17 @@
-export * from './direction.js'
+/**
+ * --------------------------------------------------------------------------
+ * CoreUI PRO data-grid util/direction.ts
+ * License (https://coreui.io/pro/license/)
+ * --------------------------------------------------------------------------
+ */
+export declare const isElementRTL: (element: Element | null | undefined) => boolean;
+interface ResizeDirectionTable {
+    options: {
+        columnResizeDirection?: 'ltr' | 'rtl';
+    };
+    setOptions: (updater: (previous: {
+        columnResizeDirection?: 'ltr' | 'rtl';
+    }) => never) => void;
+}
+export declare const syncResizeDirection: (table: ResizeDirectionTable, element: Element | null | undefined) => void;
+export {};