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

package/src/lib/features/custom-selection.feature.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomSelectionFeature = void 0;
+const react_table_1 = require("@tanstack/react-table");
+exports.CustomSelectionFeature = {
+    getInitialState: (state) => {
+        return Object.assign({ selectionState: {
+                ids: [],
+                type: 'include',
+                selectMode: 'page',
+            } }, state);
+    },
+    getDefaultOptions: (table) => {
+        return {
+            enableCustomSelection: true,
+            selectMode: 'page',
+            onSelectionStateChange: (0, react_table_1.makeStateUpdater)('selectionState', table),
+        };
+    },
+    createTable: (table) => {
+        table.setSelectionState = (updater) => {
+            var _a, _b;
+            const safeUpdater = (old) => {
+                const newState = (0, react_table_1.functionalUpdate)(updater, old);
+                return newState;
+            };
+            return (_b = (_a = table.options).onSelectionStateChange) === null || _b === void 0 ? void 0 : _b.call(_a, safeUpdater);
+        };
+        table.selectRow = (rowId) => {
+            if (!table.canSelectRow(rowId))
+                return;
+            table.setSelectionState((old) => {
+                if (old.type === 'exclude') {
+                    return Object.assign(Object.assign({}, old), { ids: old.ids.filter(id => id !== rowId) });
+                }
+                else {
+                    const newIds = old.ids.includes(rowId) ? old.ids : [...old.ids, rowId];
+                    return Object.assign(Object.assign({}, old), { ids: newIds });
+                }
+            });
+        };
+        table.deselectRow = (rowId) => {
+            table.setSelectionState((old) => {
+                if (old.type === 'exclude') {
+                    const newIds = old.ids.includes(rowId) ? old.ids : [...old.ids, rowId];
+                    return Object.assign(Object.assign({}, old), { ids: newIds });
+                }
+                else {
+                    return Object.assign(Object.assign({}, old), { ids: old.ids.filter(id => id !== rowId) });
+                }
+            });
+        };
+        table.toggleRowSelected = (rowId) => {
+            if (table.getIsRowSelected(rowId)) {
+                table.deselectRow(rowId);
+            }
+            else {
+                table.selectRow(rowId);
+            }
+        };
+        table.selectAll = () => {
+            const selectMode = table.options.selectMode || 'page';
+            if (selectMode === 'all') {
+                table.setSelectionState((old) => (Object.assign(Object.assign({}, old), { ids: [], type: 'exclude' })));
+            }
+            else {
+                const currentPageRows = table.getPaginationRowModel().rows;
+                const selectableRowIds = currentPageRows
+                    .filter(row => table.canSelectRow(row.id))
+                    .map(row => row.id);
+                table.setSelectionState((old) => (Object.assign(Object.assign({}, old), { ids: selectableRowIds, type: 'include' })));
+            }
+        };
+        table.deselectAll = () => {
+            table.setSelectionState((old) => (Object.assign(Object.assign({}, old), { ids: [], type: 'include' })));
+        };
+        table.toggleAllRowsSelected = () => {
+            if (table.getIsAllRowsSelected()) {
+                table.deselectAll();
+            }
+            else {
+                table.selectAll();
+            }
+        };
+        table.getIsRowSelected = (rowId) => {
+            const state = table.getSelectionState();
+            if (state.type === 'exclude') {
+                return !state.ids.includes(rowId);
+            }
+            else {
+                return state.ids.includes(rowId);
+            }
+        };
+        table.getIsAllRowsSelected = () => {
+            const state = table.getSelectionState();
+            const selectMode = table.options.selectMode || 'page';
+            if (selectMode === 'all') {
+                if (state.type === 'exclude') {
+                    return state.ids.length === 0;
+                }
+                else {
+                    const totalCount = table.getRowCount();
+                    return state.ids.length === totalCount;
+                }
+            }
+            else {
+                const currentPageRows = table.getPaginationRowModel().rows;
+                const selectableRows = currentPageRows.filter(row => table.canSelectRow(row.id));
+                if (selectableRows.length === 0)
+                    return false;
+                return selectableRows.every(row => table.getIsRowSelected(row.id));
+            }
+        };
+        table.getIsSomeRowsSelected = () => {
+            const state = table.getSelectionState();
+            const selectMode = table.options.selectMode || 'page';
+            if (selectMode === 'all' && state.type === 'exclude') {
+                const totalCount = table.getRowCount();
+                return state.ids.length < totalCount;
+            }
+            else {
+                return state.ids.length > 0;
+            }
+        };
+        table.getSelectionState = () => {
+            return table.getState().selectionState || {
+                ids: [],
+                type: 'include',
+                selectMode: 'page',
+            };
+        };
+        table.getSelectedCount = () => {
+            const state = table.getSelectionState();
+            const selectMode = table.options.selectMode || 'page';
+            if (selectMode === 'all' && state.type === 'exclude') {
+                const totalCount = table.getRowCount();
+                return totalCount - state.ids.length;
+            }
+            else {
+                return state.ids.length;
+            }
+        };
+        table.getSelectedRowIds = () => {
+            const state = table.getSelectionState();
+            if (state.type === 'exclude') {
+                console.warn('getSelectedRowIds() in exclude mode returns exclude list. Use getSelectionState() instead.');
+                return state.ids;
+            }
+            else {
+                return state.ids;
+            }
+        };
+        table.getSelectedRows = () => {
+            const state = table.getSelectionState();
+            const allRows = table.getRowModel().rows;
+            if (state.type === 'exclude') {
+                return allRows.filter(row => !state.ids.includes(row.id));
+            }
+            else {
+                return allRows.filter(row => state.ids.includes(row.id));
+            }
+        };
+        table.canSelectRow = (rowId) => {
+            if (!table.options.isRowSelectable)
+                return true;
+            const row = table.getRowModel().rows.find(r => r.id === rowId);
+            if (!row)
+                return false;
+            return table.options.isRowSelectable({ row: row.original, id: rowId });
+        };
+    },
+};

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

@@ -0,0 +1,2 @@
+export { CustomColumnFilterFeature, matchesCustomColumnFilters, type ColumnFilterRule, type CustomColumnFilterOptions, type CustomColumnFilterTableState, type CustomColumnFilterInstance, } from './custom-column-filter.feature';
+export { CustomSelectionFeature, type SelectionState, type SelectMode, type CustomSelectionOptions, type CustomSelectionTableState, type CustomSelectionInstance, } from './custom-selection.feature';

package/src/lib/features/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomSelectionFeature = exports.matchesCustomColumnFilters = exports.CustomColumnFilterFeature = void 0;
+var custom_column_filter_feature_1 = require("./custom-column-filter.feature");
+Object.defineProperty(exports, "CustomColumnFilterFeature", { enumerable: true, get: function () { return custom_column_filter_feature_1.CustomColumnFilterFeature; } });
+Object.defineProperty(exports, "matchesCustomColumnFilters", { enumerable: true, get: function () { return custom_column_filter_feature_1.matchesCustomColumnFilters; } });
+var custom_selection_feature_1 = require("./custom-selection.feature");
+Object.defineProperty(exports, "CustomSelectionFeature", { enumerable: true, get: function () { return custom_selection_feature_1.CustomSelectionFeature; } });

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

@@ -0,0 +1 @@
+export * from './use-data-table-api';

package/src/lib/hooks/index.js

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

package/src/lib/hooks/use-data-table-api.d.ts

@@ -0,0 +1,56 @@
+import { ColumnOrderState, ColumnPinningState, SortingState, Table } from '@tanstack/react-table';
+import { Ref } from 'react';
+import { CustomColumnFilterState, TableFilters, TableState } from '../types';
+import { DataTableApi } from '../types/data-table-api';
+import { SelectionState } from '../features';
+interface UseDataTableApiProps<T> {
+    table: Table<T>;
+    data: T[];
+    idKey: keyof T;
+    globalFilter: string;
+    customColumnsFilter: CustomColumnFilterState;
+    sorting: SortingState;
+    pagination: {
+        pageIndex: number;
+        pageSize: number;
+    };
+    columnOrder: ColumnOrderState;
+    columnPinning: ColumnPinningState;
+    enhancedColumns: any[];
+    enablePagination: boolean;
+    enableColumnPinning: boolean;
+    initialPageIndex: number;
+    initialPageSize?: number;
+    pageSize: number;
+    selectMode?: 'page' | 'all';
+    onSelectionChange?: (state: SelectionState) => void;
+    handleColumnFilterStateChange: (filterState: CustomColumnFilterState) => void;
+    onDataStateChange?: (state: Partial<TableState>) => void;
+    onFetchData?: (filters: Partial<TableFilters>) => void;
+    onDataChange?: (newData: T[]) => void;
+    exportFilename?: string;
+    onExportProgress?: (progress: {
+        processedRows: number;
+        totalRows: number;
+        percentage: number;
+    }) => void;
+    onExportComplete?: (result: {
+        success: boolean;
+        filename: string;
+        totalRows: number;
+    }) => void;
+    onExportError?: (error: {
+        message: string;
+        code: string;
+    }) => void;
+    onServerExport?: (filters?: Partial<TableFilters>, selection?: any) => Promise<{
+        data: any[];
+        total: number;
+    }>;
+    exportController?: AbortController | null;
+    setExportController?: (controller: AbortController | null) => void;
+    isExporting?: boolean;
+    dataMode?: 'client' | 'server';
+}
+export declare function useDataTableApi<T extends Record<string, any>>(props: UseDataTableApiProps<T>, ref: Ref<DataTableApi<T>>): void;
+export {};