@ackplus/react-tanstack-data-table 1.0.19-beta-0.7 → 1.0.19-beta-0.8

package/src/lib/icons/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExcelIcon = exports.CsvIcon = exports.ViewComfortableIcon = exports.ViewCompactIcon = exports.DeleteIcon = exports.AddIcon = exports.UnpinIcon = void 0;
+var unpin_icon_1 = require("./unpin-icon");
+Object.defineProperty(exports, "UnpinIcon", { enumerable: true, get: function () { return unpin_icon_1.UnpinIcon; } });
+var add_icon_1 = require("./add-icon");
+Object.defineProperty(exports, "AddIcon", { enumerable: true, get: function () { return add_icon_1.AddIcon; } });
+var delete_icon_1 = require("./delete-icon");
+Object.defineProperty(exports, "DeleteIcon", { enumerable: true, get: function () { return delete_icon_1.DeleteIcon; } });
+var view_compact_icon_1 = require("./view-compact-icon");
+Object.defineProperty(exports, "ViewCompactIcon", { enumerable: true, get: function () { return view_compact_icon_1.ViewCompactIcon; } });
+var view_comfortable_icon_1 = require("./view-comfortable-icon");
+Object.defineProperty(exports, "ViewComfortableIcon", { enumerable: true, get: function () { return view_comfortable_icon_1.ViewComfortableIcon; } });
+var csv_icon_1 = require("./csv-icon");
+Object.defineProperty(exports, "CsvIcon", { enumerable: true, get: function () { return csv_icon_1.CsvIcon; } });
+var excel_icon_1 = require("./excel-icon");
+Object.defineProperty(exports, "ExcelIcon", { enumerable: true, get: function () { return excel_icon_1.ExcelIcon; } });

package/src/lib/icons/unpin-icon.d.ts

@@ -0,0 +1,2 @@
+import { SvgIconProps } from '@mui/material';
+export declare function UnpinIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;

package/src/lib/icons/unpin-icon.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnpinIcon = UnpinIcon;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const material_1 = require("@mui/material");
+function UnpinIcon(props) {
+    return ((0, jsx_runtime_1.jsxs)(material_1.SvgIcon, Object.assign({}, props, { viewBox: "0 0 24 24", children: [(0, jsx_runtime_1.jsx)("path", { d: "M2 5.27L3.28 4 20 20.72 18.73 22l-3.41-3.41V22h-1.6v-6H8v-2l2-2V9.27L2 5.27zM16 12V4h1V2H7v2h1v3.73l8 8z", opacity: "0.7" }), (0, jsx_runtime_1.jsx)("path", { d: "M14.73 12L16 10.73V4h1V2H7v2h1v3.73l2.27 2.27z" })] })));
+}

package/src/lib/icons/view-comfortable-icon.d.ts

@@ -0,0 +1,2 @@
+import { SvgIconProps } from '@mui/material';
+export declare function ViewComfortableIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;

package/src/lib/icons/view-comfortable-icon.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewComfortableIcon = ViewComfortableIcon;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const material_1 = require("@mui/material");
+function ViewComfortableIcon(props) {
+    return ((0, jsx_runtime_1.jsxs)(material_1.SvgIcon, Object.assign({}, props, { viewBox: "0 0 24 24", children: [(0, jsx_runtime_1.jsx)("rect", { x: "3", y: "3", width: "18", height: "3", fill: "currentColor", rx: "1" }), (0, jsx_runtime_1.jsx)("rect", { x: "3", y: "8", width: "18", height: "3", fill: "currentColor", rx: "1" }), (0, jsx_runtime_1.jsx)("rect", { x: "3", y: "13", width: "18", height: "3", fill: "currentColor", rx: "1" }), (0, jsx_runtime_1.jsx)("rect", { x: "3", y: "18", width: "18", height: "3", fill: "currentColor", rx: "1" })] })));
+}

package/src/lib/icons/view-compact-icon.d.ts

@@ -0,0 +1,2 @@
+import { SvgIconProps } from '@mui/material';
+export declare function ViewCompactIcon(props: SvgIconProps): import("react/jsx-runtime").JSX.Element;

package/src/lib/icons/view-compact-icon.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewCompactIcon = ViewCompactIcon;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const material_1 = require("@mui/material");
+function ViewCompactIcon(props) {
+    return ((0, jsx_runtime_1.jsxs)(material_1.SvgIcon, Object.assign({}, props, { viewBox: "0 0 24 24", children: [(0, jsx_runtime_1.jsx)("rect", { x: "3", y: "4", width: "18", height: "2", fill: "currentColor" }), (0, jsx_runtime_1.jsx)("rect", { x: "3", y: "7", width: "18", height: "2", fill: "currentColor" }), (0, jsx_runtime_1.jsx)("rect", { x: "3", y: "10", width: "18", height: "2", fill: "currentColor" }), (0, jsx_runtime_1.jsx)("rect", { x: "3", y: "13", width: "18", height: "2", fill: "currentColor" }), (0, jsx_runtime_1.jsx)("rect", { x: "3", y: "16", width: "18", height: "2", fill: "currentColor" }), (0, jsx_runtime_1.jsx)("rect", { x: "3", y: "19", width: "18", height: "2", fill: "currentColor" })] })));
+}

package/src/lib/types/column.types.d.ts

@@ -0,0 +1,29 @@
+import { ColumnDef, RowData, Column } from '@tanstack/react-table';
+import { ColumnFilterRule } from '../features';
+export declare const DEFAULT_SELECTION_COLUMN_NAME = "_selection";
+export declare const DEFAULT_EXPANDING_COLUMN_NAME = "_expanding";
+declare module '@tanstack/table-core' {
+    interface ColumnDefBase<TData extends RowData, TValue> {
+        type?: 'boolean' | 'number' | 'date' | 'select' | 'text';
+        options?: {
+            label: string;
+            value: string;
+        }[];
+        align?: 'left' | 'center' | 'right';
+        filterable?: boolean;
+        hideInExport?: boolean;
+        editComponent?: React.ComponentType<{
+            value: any;
+            onChange: (value: any) => void;
+            filter: ColumnFilterRule;
+            column: Column<TData, TValue>;
+        }>;
+        filterComponent?: React.ComponentType<{
+            value: any;
+            onChange: (value: any) => void;
+            filter: ColumnFilterRule;
+            column: Column<TData, TValue>;
+        }>;
+    }
+}
+export type DataTableColumn<TData extends RowData, TValue = unknown> = ColumnDef<TData, TValue> & {};

package/src/lib/types/column.types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EXPANDING_COLUMN_NAME = exports.DEFAULT_SELECTION_COLUMN_NAME = void 0;
+exports.DEFAULT_SELECTION_COLUMN_NAME = '_selection';
+exports.DEFAULT_EXPANDING_COLUMN_NAME = '_expanding';

package/src/lib/types/data-table-api.d.ts

@@ -0,0 +1,134 @@
+import { ColumnPinningState, SortingState, ColumnOrderState, TableState, Row } from '@tanstack/react-table';
+import { CustomColumnFilterState } from './table.types';
+import { SelectionState } from '../features/custom-selection.feature';
+export interface DataTableApi<T = any> {
+    columnVisibility: {
+        showColumn: (columnId: string) => void;
+        hideColumn: (columnId: string) => void;
+        toggleColumn: (columnId: string) => void;
+        showAllColumns: () => void;
+        hideAllColumns: () => void;
+        resetColumnVisibility: () => void;
+    };
+    columnOrdering: {
+        setColumnOrder: (columnOrder: ColumnOrderState) => void;
+        moveColumn: (columnId: string, toIndex: number) => void;
+        resetColumnOrder: () => void;
+    };
+    columnPinning: {
+        pinColumnLeft: (columnId: string) => void;
+        pinColumnRight: (columnId: string) => void;
+        unpinColumn: (columnId: string) => void;
+        setPinning: (pinning: ColumnPinningState) => void;
+        resetColumnPinning: () => void;
+    };
+    columnResizing: {
+        resizeColumn: (columnId: string, width: number) => void;
+        autoSizeColumn: (columnId: string) => void;
+        autoSizeAllColumns: () => void;
+        resetColumnSizing: () => void;
+    };
+    filtering: {
+        setGlobalFilter: (filter: string) => void;
+        clearGlobalFilter: () => void;
+        setCustomColumnFilters: (filters: CustomColumnFilterState) => void;
+        addColumnFilter: (columnId: string, operator: string, value: any) => void;
+        removeColumnFilter: (filterId: string) => void;
+        clearAllFilters: () => void;
+        resetFilters: () => void;
+    };
+    sorting: {
+        setSorting: (sorting: SortingState) => void;
+        sortColumn: (columnId: string, direction: 'asc' | 'desc' | false) => void;
+        clearSorting: () => void;
+        resetSorting: () => void;
+    };
+    pagination: {
+        goToPage: (pageIndex: number) => void;
+        nextPage: () => void;
+        previousPage: () => void;
+        setPageSize: (pageSize: number) => void;
+        goToFirstPage: () => void;
+        goToLastPage: () => void;
+    };
+    selection: {
+        selectRow: (rowId: string) => void;
+        deselectRow: (rowId: string) => void;
+        toggleRowSelection: (rowId: string) => void;
+        selectAll: () => void;
+        deselectAll: () => void;
+        toggleSelectAll: () => void;
+        getSelectionState: () => SelectionState;
+        getSelectedCount: () => number;
+        getSelectedRows: () => Row<T>[];
+        isRowSelected: (rowId: string) => boolean;
+    };
+    data: {
+        refresh: () => void;
+        reload: () => void;
+        getAllData: () => T[];
+        getRowData: (rowId: string) => T | undefined;
+        getRowByIndex: (index: number) => T | undefined;
+        updateRow: (rowId: string, updates: Partial<T>) => void;
+        updateRowByIndex: (index: number, updates: Partial<T>) => void;
+        insertRow: (newRow: T, index?: number) => void;
+        deleteRow: (rowId: string) => void;
+        deleteRowByIndex: (index: number) => void;
+        deleteSelectedRows: () => void;
+        replaceAllData: (newData: T[]) => void;
+        updateMultipleRows: (updates: Array<{
+            rowId: string;
+            data: Partial<T>;
+        }>) => void;
+        insertMultipleRows: (newRows: T[], startIndex?: number) => void;
+        deleteMultipleRows: (rowIds: string[]) => void;
+        updateField: (rowId: string, fieldName: keyof T, value: any) => void;
+        updateFieldByIndex: (index: number, fieldName: keyof T, value: any) => void;
+        findRows: (predicate: (row: T) => boolean) => T[];
+        findRowIndex: (predicate: (row: T) => boolean) => number;
+        getDataCount: () => number;
+        getFilteredDataCount: () => number;
+    };
+    layout: {
+        resetLayout: () => void;
+        resetAll: () => void;
+        saveLayout: () => any;
+        restoreLayout: (layout: any) => void;
+    };
+    state: {
+        getTableState: () => any;
+        getCurrentFilters: () => CustomColumnFilterState;
+        getCurrentSorting: () => SortingState;
+        getCurrentPagination: () => {
+            pageIndex: number;
+            pageSize: number;
+        };
+        getCurrentSelection: () => string[];
+    };
+    export: {
+        exportCSV: (options?: {
+            filename?: string;
+            onlyVisibleColumns?: boolean;
+            onlySelectedRows?: boolean;
+            includeHeaders?: boolean;
+        }) => Promise<void>;
+        exportExcel: (options?: {
+            filename?: string;
+            onlyVisibleColumns?: boolean;
+            onlySelectedRows?: boolean;
+            includeHeaders?: boolean;
+        }) => Promise<void>;
+        exportServerData: (options: {
+            format: 'csv' | 'excel';
+            filename?: string;
+            fetchData: (filters?: Partial<TableState>) => Promise<{
+                data: T[];
+                total: number;
+            }>;
+            pageSize?: number;
+            includeHeaders?: boolean;
+        }) => Promise<void>;
+        isExporting: () => boolean;
+        cancelExport: () => void;
+    };
+}

package/src/lib/types/data-table-api.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/lib/types/export.types.d.ts

@@ -0,0 +1,99 @@
+import { TableState } from './table.types';
+export interface ServerExportColumn<T = any> {
+    id: string;
+    header: string;
+    accessor: keyof T | string;
+    formatter?: (value: any, row: T) => string;
+}
+export interface ExportOptions {
+    filename?: string;
+    format: 'csv' | 'excel';
+    includeHeaders?: boolean;
+    onlyVisibleColumns?: boolean;
+    onlyFilteredData?: boolean;
+    chunkSize?: number;
+    onProgress?: (progress: ExportProgress) => void;
+    onComplete?: (result: ExportResult) => void;
+    onError?: (error: ExportError) => void;
+    signal?: AbortSignal;
+}
+export interface ExportProgress {
+    processedRows: number;
+    totalRows: number;
+    percentage: number;
+    currentChunk: number;
+    totalChunks: number;
+    estimatedTimeRemaining?: number;
+}
+export interface ExportResult {
+    success: boolean;
+    filename: string;
+    totalRows: number;
+    totalColumns: number;
+    processingTime: number;
+    fileSize?: number;
+}
+export interface ExportError {
+    message: string;
+    code: 'CANCELLED' | 'MEMORY_ERROR' | 'PROCESSING_ERROR' | 'UNKNOWN';
+    details?: any;
+}
+export interface ExportConfig {
+    enabled: boolean;
+    formats: ('csv' | 'excel')[];
+    filename?: string;
+    includeHeaders?: boolean;
+    onlyVisibleColumns?: boolean;
+    onlyFilteredData?: boolean;
+    chunkSize?: number;
+    enableProgressTracking?: boolean;
+    maxMemoryThreshold?: number;
+}
+export interface ExportState {
+    isExporting: boolean;
+    progress?: ExportProgress;
+    controller?: AbortController;
+    startTime?: number;
+}
+export interface ChunkProcessingConfig {
+    chunkSize: number;
+    delayBetweenChunks: number;
+    useWebWorker: boolean;
+}
+export interface PinnedColumnStyleOptions {
+    width?: number | string;
+    isPinned?: 'left' | 'right' | false;
+    pinnedPosition?: number;
+    pinnedRightPosition?: number;
+    zIndex?: number;
+    disableStickyHeader?: boolean;
+    isLastLeftPinnedColumn?: boolean;
+    isFirstRightPinnedColumn?: boolean;
+}
+export interface SimpleExportOptions {
+    filename?: string;
+    format: 'csv' | 'excel';
+    includeHeaders?: boolean;
+    onlyVisibleColumns?: boolean;
+    onlySelectedRows?: boolean;
+}
+export interface SelectionExportData {
+    selectAllMatching?: boolean;
+    excludedIds?: string[];
+    selectedIds?: string[];
+    hasSelection?: boolean;
+}
+export interface ServerExportOptions extends SimpleExportOptions {
+    fetchData: (filters?: Partial<TableState>, selection?: SelectionExportData) => Promise<{
+        data: any[];
+        total: number;
+    }>;
+    currentFilters?: any;
+    pageSize?: number;
+    selection?: SelectionExportData;
+}
+export interface ExportCallbacks {
+    onProgress?: (progress: ExportProgress) => void;
+    onComplete?: (result: ExportResult) => void;
+    onError?: (error: ExportError) => void;
+}

package/src/lib/types/export.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/lib/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './column.types';
+export * from './table.types';
+export * from './export.types';
+export * from './data-table-api';
+export * from './slots.types';
+export type { DataTableApi } from './data-table-api';

package/src/lib/types/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./column.types"), exports);
+tslib_1.__exportStar(require("./table.types"), exports);
+tslib_1.__exportStar(require("./export.types"), exports);
+tslib_1.__exportStar(require("./data-table-api"), exports);
+tslib_1.__exportStar(require("./slots.types"), exports);

package/src/lib/types/slots.types.d.ts

@@ -0,0 +1,272 @@
+import { TableProps, TableContainerProps, BoxProps } from '@mui/material';
+import { Table, Row, Column } from '@tanstack/react-table';
+import { ComponentType, ReactNode } from 'react';
+import { DataTableColumn, TableFilters, ExportProgress, ExportResult, ExportError, ServerExportColumn } from './index';
+import { DataTableSize } from '../utils/table-helpers';
+import { DataTablePaginationProps } from "../components/pagination";
+export interface DataTableSlots<T = any> {
+    root?: ComponentType<DataTableSlotProps<T>['root']>;
+    tableContainer?: ComponentType<DataTableSlotProps<T>['tableContainer']>;
+    table?: ComponentType<DataTableSlotProps<T>['table']>;
+    toolbar?: ComponentType<DataTableSlotProps<T>['toolbar']>;
+    header?: ComponentType<DataTableSlotProps<T>['header']>;
+    headerRow?: ComponentType<DataTableSlotProps<T>['headerRow']>;
+    headerCell?: ComponentType<DataTableSlotProps<T>['headerCell']>;
+    sortIconAsc?: ComponentType<DataTableSlotProps<T>['sortIconAsc']>;
+    sortIconDesc?: ComponentType<DataTableSlotProps<T>['sortIconDesc']>;
+    body?: ComponentType<DataTableSlotProps<T>['body']>;
+    row?: ComponentType<DataTableSlotProps<T>['row']>;
+    cell?: ComponentType<DataTableSlotProps<T>['cell']>;
+    loadingRow?: ComponentType<DataTableSlotProps<T>['loadingRow']>;
+    emptyRow?: ComponentType<DataTableSlotProps<T>['emptyRow']>;
+    expandedRow?: ComponentType<DataTableSlotProps<T>['expandedRow']>;
+    footer?: ComponentType<DataTableSlotProps<T>['footer']>;
+    pagination?: ComponentType<DataTableSlotProps<T>['pagination']>;
+    searchInput?: ComponentType<DataTableSlotProps<T>['searchInput']>;
+    columnVisibilityControl?: ComponentType<DataTableSlotProps<T>['columnVisibilityControl']>;
+    columnCustomFilterControl?: ComponentType<DataTableSlotProps<T>['columnCustomFilterControl']>;
+    columnPinningControl?: ComponentType<DataTableSlotProps<T>['columnPinningControl']>;
+    exportButton?: ComponentType<DataTableSlotProps<T>['exportButton']>;
+    resetButton?: ComponentType<DataTableSlotProps<T>['resetButton']>;
+    tableSizeControl?: ComponentType<DataTableSlotProps<T>['tableSizeControl']>;
+    bulkActionsToolbar?: ComponentType<DataTableSlotProps<T>['bulkActionsToolbar']>;
+    searchIcon?: ComponentType<DataTableSlotProps<T>['searchIcon']>;
+    clearIcon?: ComponentType<DataTableSlotProps<T>['clearIcon']>;
+    exportIcon?: ComponentType<DataTableSlotProps<T>['exportIcon']>;
+    columnIcon?: ComponentType<DataTableSlotProps<T>['columnIcon']>;
+    resetIcon?: ComponentType<DataTableSlotProps<T>['resetIcon']>;
+    moreIcon?: ComponentType<DataTableSlotProps<T>['moreIcon']>;
+    filterIcon?: ComponentType<DataTableSlotProps<T>['filterIcon']>;
+    pinIcon?: ComponentType<DataTableSlotProps<T>['pinIcon']>;
+    unpinIcon?: ComponentType<DataTableSlotProps<T>['unpinIcon']>;
+    leftIcon?: ComponentType<DataTableSlotProps<T>['leftIcon']>;
+    rightIcon?: ComponentType<DataTableSlotProps<T>['rightIcon']>;
+    csvIcon?: ComponentType<DataTableSlotProps<T>['csvIcon']>;
+    excelIcon?: ComponentType<DataTableSlotProps<T>['excelIcon']>;
+    selectAllIcon?: ComponentType<DataTableSlotProps<T>['selectAllIcon']>;
+    deselectIcon?: ComponentType<DataTableSlotProps<T>['deselectIcon']>;
+    tableSizeIcon?: ComponentType<DataTableSlotProps<T>['tableSizeIcon']>;
+    tableSizeSmallIcon?: ComponentType<DataTableSlotProps<T>['tableSizeSmallIcon']>;
+    tableSizeMediumIcon?: ComponentType<DataTableSlotProps<T>['tableSizeMediumIcon']>;
+    checkboxSelection?: ComponentType<DataTableSlotProps<T>['checkboxSelection']>;
+    expandIcon?: ComponentType<DataTableSlotProps<T>['expandIcon']>;
+    collapseIcon?: ComponentType<DataTableSlotProps<T>['collapseIcon']>;
+    loadingSkeleton?: ComponentType<DataTableSlotProps<T>['loadingSkeleton']>;
+    noDataOverlay?: ComponentType<DataTableSlotProps<T>['noDataOverlay']>;
+    exportProgressDialog?: ComponentType<DataTableSlotProps<T>['exportProgressDialog']>;
+}
+export interface BaseSlotProps<T = any> {
+    table: Table<T>;
+    data: T[];
+    columns: DataTableColumn<T>[];
+}
+export interface DataTableSlotProps<T = any> {
+    root: BaseSlotProps<T> & BoxProps & {
+        children: ReactNode;
+    };
+    tableContainer: BaseSlotProps<T> & TableContainerProps & {
+        children: ReactNode;
+        enableStickyHeader?: boolean;
+        maxHeight?: string | number;
+        enableVirtualization?: boolean;
+    };
+    table: BaseSlotProps<T> & TableProps & {
+        children: ReactNode;
+        tableSize?: DataTableSize;
+        enableStickyHeader?: boolean;
+        fitToScreen?: boolean;
+        tableStyle?: React.CSSProperties;
+    };
+    toolbar: BaseSlotProps<T> & {
+        title?: string;
+        subtitle?: string;
+        enableGlobalFilter?: boolean;
+        enableColumnVisibility?: boolean;
+        enableColumnFilter?: boolean;
+        enableExport?: boolean;
+        enableReset?: boolean;
+        enableTableSizeControl?: boolean;
+        enableColumnPinning?: boolean;
+        extraFilter?: ReactNode;
+        serverExport?: {
+            fetchData: (page: number, pageSize: number, filters: TableFilters) => Promise<{
+                data: T[];
+                total: number;
+            }>;
+            columns: ServerExportColumn<T>[];
+            pageSize?: number;
+        };
+        currentFilters?: TableFilters;
+        onExportStart?: (format: 'csv' | 'excel', summary: {
+            mode: 'client' | 'server';
+            totalRows: number;
+            estimatedMemoryMB?: number;
+        }) => void;
+        onExportProgress?: (progress: ExportProgress) => void;
+        onExportComplete?: (result: ExportResult) => void;
+        onExportError?: (error: ExportError) => void;
+        onExportCancel?: () => void;
+    };
+    header: BaseSlotProps<T> & {
+        enableSorting?: boolean;
+        draggable?: boolean;
+        enableColumnResizing?: boolean;
+        enableStickyHeader?: boolean;
+        fitToScreen?: boolean;
+        onColumnReorder?: (draggedColumnId: string, targetColumnId: string) => void;
+    };
+    headerRow: BaseSlotProps<T> & {
+        headerGroups: any[];
+    };
+    headerCell: BaseSlotProps<T> & {
+        header: any;
+        column: Column<T>;
+        enableSorting?: boolean;
+        draggable?: boolean;
+        enableColumnResizing?: boolean;
+        onColumnReorder?: (draggedColumnId: string, targetColumnId: string) => void;
+        isPinned?: boolean | 'left' | 'right';
+        pinnedPosition?: number;
+        pinnedRightPosition?: number;
+    };
+    sortIconAsc: Record<string, any>;
+    sortIconDesc: Record<string, any>;
+    body: BaseSlotProps<T> & {
+        children: ReactNode;
+        rows: Row<T>[];
+        loading?: boolean;
+        emptyMessage?: string;
+        enableVirtualization?: boolean;
+        enablePagination?: boolean;
+    };
+    row: BaseSlotProps<T> & {
+        row: Row<T>;
+        index: number;
+        enableHover?: boolean;
+        enableStripes?: boolean;
+        isOdd?: boolean;
+        renderSubComponent?: (row: Row<T>) => ReactNode;
+        disableStickyHeader?: boolean;
+    };
+    cell: BaseSlotProps<T> & {
+        row: Row<T>;
+        cell: any;
+        column: Column<T>;
+        value: any;
+        isPinned?: boolean | 'left' | 'right';
+        pinnedPosition?: number;
+        pinnedRightPosition?: number;
+        alignment?: 'left' | 'center' | 'right';
+    };
+    loadingRow: BaseSlotProps<T> & {
+        rowCount: number;
+        colSpan: number;
+    };
+    emptyRow: BaseSlotProps<T> & {
+        colSpan: number;
+        message: string;
+    };
+    expandedRow: BaseSlotProps<T> & {
+        row: Row<T>;
+        colSpan: number;
+        children: ReactNode;
+    };
+    footer: BaseSlotProps<T> & {
+        children: ReactNode;
+        enableStickyFooter?: boolean;
+    };
+    pagination: BaseSlotProps<T> & DataTablePaginationProps;
+    searchInput: BaseSlotProps<T> & {
+        value: string;
+        onChange: (value: string) => void;
+        placeholder?: string;
+        autoFocus?: boolean;
+    };
+    columnsPanel: BaseSlotProps<T> & {
+        getTogglableColumns: (columns: DataTableColumn<T>[]) => DataTableColumn<T>[];
+        getPinnableColumns: (columns: DataTableColumn<T>[]) => DataTableColumn<T>[];
+    };
+    columnVisibilityControl: BaseSlotProps<T>;
+    columnCustomFilterControl: BaseSlotProps<T>;
+    columnPinningControl: BaseSlotProps<T>;
+    resetButton: BaseSlotProps<T>;
+    tableSizeControl: BaseSlotProps<T>;
+    bulkActionsToolbar: BaseSlotProps<T> & {
+        selectionState: any;
+        selectedRowCount: number;
+        bulkActions?: (selectionState: any) => ReactNode;
+        onBulkAction?: (action: string, selectionState: T[]) => void;
+        enableSelectAll?: boolean;
+        onSelectAll?: () => void;
+        onDeselectAll?: () => void;
+    };
+    exportButton: BaseSlotProps<T> & {
+        filename?: string;
+        dataMode?: 'client' | 'server';
+        serverExport?: {
+            fetchData: (page: number, pageSize: number, filters: TableFilters) => Promise<{
+                data: T[];
+                total: number;
+            }>;
+            columns: ServerExportColumn<T>[];
+            pageSize?: number;
+        };
+        currentFilters?: TableFilters;
+        onExportStart?: (format: 'csv' | 'excel', summary: {
+            mode: 'client' | 'server';
+            totalRows: number;
+            estimatedMemoryMB?: number;
+        }) => void;
+        onExportProgress?: (progress: ExportProgress) => void;
+        onExportComplete?: (result: ExportResult) => void;
+        onExportError?: (error: ExportError) => void;
+        onExportCancel?: () => void;
+    };
+    searchIcon: Record<string, any>;
+    clearIcon: Record<string, any>;
+    exportIcon: Record<string, any>;
+    columnIcon: Record<string, any>;
+    resetIcon: Record<string, any>;
+    moreIcon: Record<string, any>;
+    filterIcon: Record<string, any>;
+    pinIcon: Record<string, any>;
+    unpinIcon: Record<string, any>;
+    leftIcon: Record<string, any>;
+    rightIcon: Record<string, any>;
+    expandIcon: Record<string, any>;
+    collapseIcon: Record<string, any>;
+    csvIcon: Record<string, any>;
+    excelIcon: Record<string, any>;
+    selectAllIcon: Record<string, any>;
+    deselectIcon: Record<string, any>;
+    tableSizeIcon: Record<string, any>;
+    tableSizeSmallIcon: Record<string, any>;
+    tableSizeMediumIcon: Record<string, any>;
+    checkboxSelection: BaseSlotProps<T> & {
+        row?: Row<T>;
+        checked: boolean;
+        indeterminate?: boolean;
+        onChange: (checked: boolean) => void;
+        disabled?: boolean;
+    };
+    selectionColumn: DataTableColumn<T>;
+    expandColumn: DataTableColumn<T>;
+    loadingSkeleton: BaseSlotProps<T> & {
+        rows: number;
+        columns: number;
+    };
+    noDataOverlay: BaseSlotProps<T> & {
+        message: string;
+    };
+    exportProgressDialog: BaseSlotProps<T> & {
+        open: boolean;
+        progress: ExportProgress;
+        onCancel: () => void;
+    };
+}
+export interface DefaultSlots<T = any> extends DataTableSlots<T> {
+}
+export type PartialSlotProps<T = any> = {
+    [K in keyof DataTableSlotProps<T>]?: Partial<DataTableSlotProps<T>[K]>;
+};
+export type SlotComponentProps<TSlot extends keyof DataTableSlots<T>, T = any> = DataTableSlotProps<T>[TSlot];

package/src/lib/types/slots.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });