@codezee/sixtify-brahma 0.2.207 → 0.2.209

package/packages/shared-components/dist/SmartGrid/hooks/useCellSelection.js

@@ -1,207 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useCellSelection = void 0;
-const react_1 = require("react");
-const useCellSelection = ({ enabled, table, }) => {
-    const [selectionState, setSelectionState] = (0, react_1.useState)({
-        activeCell: null,
-        isSelecting: false,
-        selectedCells: new Set(),
-        selectionRange: null,
-    });
-    const [isCopyFlashing, setIsCopyFlashing] = (0, react_1.useState)(false);
-    const isSelectingRef = (0, react_1.useRef)(false);
-    const anchorCellRef = (0, react_1.useRef)(null);
-    const getCellKey = (0, react_1.useCallback)((rowId, columnId) => {
-        return `${rowId}-${columnId}`;
-    }, []);
-    const getCellsInRange = (0, react_1.useCallback)((start, end) => {
-        const cells = new Set();
-        const { getRowModel, getVisibleFlatColumns } = table;
-        const rows = getRowModel().rows;
-        const visibleColumns = getVisibleFlatColumns();
-        // Find row indices
-        const startRowIndex = rows.findIndex(({ id }) => id === start.rowId);
-        const endRowIndex = rows.findIndex(({ id }) => id === end.rowId);
-        // Find column indices
-        const startColIndex = visibleColumns.findIndex(({ id }) => id === start.columnId);
-        const endColIndex = visibleColumns.findIndex(({ id }) => id === end.columnId);
-        if (startRowIndex === -1 ||
-            endRowIndex === -1 ||
-            startColIndex === -1 ||
-            endColIndex === -1) {
-            return cells;
-        }
-        const minRow = Math.min(startRowIndex, endRowIndex);
-        const maxRow = Math.max(startRowIndex, endRowIndex);
-        const minCol = Math.min(startColIndex, endColIndex);
-        const maxCol = Math.max(startColIndex, endColIndex);
-        for (let rowIndex = minRow; rowIndex <= maxRow; rowIndex++) {
-            const row = rows[rowIndex];
-            if (!row) {
-                continue;
-            }
-            for (let colIndex = minCol; colIndex <= maxCol; colIndex++) {
-                const column = visibleColumns[colIndex];
-                if (!column) {
-                    continue;
-                }
-                cells.add(getCellKey(row.id, column.id));
-            }
-        }
-        return cells;
-    }, [table, getCellKey]);
-    //  useCallback is used Prevents unnecessary re-renders and Prevents infinite loops
-    const startCellSelection = (0, react_1.useCallback)((rowId, columnId, isShiftClick = false) => {
-        if (!enabled) {
-            return;
-        }
-        const cellPosition = { columnId, rowId };
-        // Handle Shift+Click: select range from anchor to current cell
-        if (isShiftClick && anchorCellRef.current) {
-            const selectedCells = getCellsInRange(anchorCellRef.current, cellPosition);
-            setSelectionState({
-                activeCell: cellPosition,
-                isSelecting: false,
-                selectedCells,
-                selectionRange: {
-                    end: cellPosition,
-                    start: anchorCellRef.current,
-                },
-            });
-            return;
-        }
-        // Normal click: start new selection and set anchor
-        isSelectingRef.current = true;
-        anchorCellRef.current = cellPosition;
-        setSelectionState({
-            activeCell: cellPosition,
-            isSelecting: true,
-            selectedCells: new Set([getCellKey(rowId, columnId)]),
-            selectionRange: { end: cellPosition, start: cellPosition },
-        });
-    }, [enabled, getCellKey, getCellsInRange]);
-    const updateCellSelection = (0, react_1.useCallback)((rowId, columnId) => {
-        if (!enabled || !isSelectingRef.current) {
-            return;
-        }
-        setSelectionState((prev) => {
-            if (!prev.selectionRange) {
-                return prev;
-            }
-            const endPosition = { columnId, rowId };
-            const newRange = {
-                end: endPosition,
-                start: prev.selectionRange.start,
-            };
-            const selectedCells = getCellsInRange(newRange.start, newRange.end);
-            return {
-                ...prev,
-                isSelecting: true,
-                selectedCells,
-                selectionRange: newRange,
-            };
-        });
-    }, [enabled, getCellsInRange]);
-    const endCellSelection = (0, react_1.useCallback)(() => {
-        if (!enabled) {
-            return;
-        }
-        isSelectingRef.current = false;
-        setSelectionState((prev) => ({
-            ...prev,
-            isSelecting: false,
-        }));
-    }, [enabled]);
-    const clearCellSelection = (0, react_1.useCallback)(() => {
-        isSelectingRef.current = false;
-        anchorCellRef.current = null;
-        setSelectionState({
-            activeCell: null,
-            isSelecting: false,
-            selectedCells: new Set(),
-            selectionRange: null,
-        });
-    }, []);
-    const isCellSelected = (0, react_1.useCallback)((rowId, columnId) => {
-        return selectionState.selectedCells.has(getCellKey(rowId, columnId));
-    }, [selectionState.selectedCells, getCellKey]);
-    const triggerCopyFlash = (0, react_1.useCallback)(() => {
-        setIsCopyFlashing(true);
-        // Clear the flash after animation completes (500ms)
-        setTimeout(() => {
-            setIsCopyFlashing(false);
-        }, 500);
-    }, []);
-    // eslint-disable-next-line sonarjs/cognitive-complexity
-    const getCellSelectionData = (0, react_1.useCallback)(() => {
-        if (!selectionState.selectionRange) {
-            return [];
-        }
-        const { end, start } = selectionState.selectionRange;
-        const { getRowModel, getVisibleFlatColumns } = table;
-        const rows = getRowModel().rows;
-        const visibleColumns = getVisibleFlatColumns();
-        // Find row indices
-        const startRowIndex = rows.findIndex(({ id }) => id === start.rowId);
-        const endRowIndex = rows.findIndex(({ id }) => id === end.rowId);
-        // Find column indices
-        const startColIndex = visibleColumns.findIndex(({ id }) => id === start.columnId);
-        const endColIndex = visibleColumns.findIndex(({ id }) => id === end.columnId);
-        if (startRowIndex === -1 ||
-            endRowIndex === -1 ||
-            startColIndex === -1 ||
-            endColIndex === -1) {
-            return [];
-        }
-        const minRow = Math.min(startRowIndex, endRowIndex);
-        const maxRow = Math.max(startRowIndex, endRowIndex);
-        const minCol = Math.min(startColIndex, endColIndex);
-        const maxCol = Math.max(startColIndex, endColIndex);
-        const data = [];
-        for (let rowIndex = minRow; rowIndex <= maxRow; rowIndex++) {
-            const row = rows[rowIndex];
-            if (!row) {
-                continue;
-            }
-            const rowData = [];
-            for (let colIndex = minCol; colIndex <= maxCol; colIndex++) {
-                const column = visibleColumns[colIndex];
-                if (!column) {
-                    continue;
-                }
-                const cell = row
-                    .getVisibleCells()
-                    .find((c) => c.column.id === column.id);
-                if (!cell) {
-                    rowData.push("");
-                    continue;
-                }
-                // Get the cell value
-                let cellValue = "";
-                const value = cell.getValue();
-                if (typeof value === "object") {
-                    cellValue = JSON.stringify(value);
-                }
-                else {
-                    cellValue = String(value);
-                }
-                rowData.push(cellValue);
-            }
-            data.push(rowData);
-        }
-        return data;
-    }, [selectionState.selectionRange, table]);
-    return {
-        clearCellSelection,
-        endCellSelection,
-        getCellSelectionData,
-        isCellSelected,
-        isCopyFlashing,
-        selectionState,
-        startCellSelection,
-        triggerCopyFlash,
-        updateCellSelection,
-    };
-};
-exports.useCellSelection = useCellSelection;

package/packages/shared-components/dist/SmartGrid/hooks/useCopyToClipboard.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useCopyToClipboard = void 0;
-const react_1 = require("react");
-const useCopyToClipboard = ({ enabled, getCellSelectionData, hasSelection, triggerCopyFlash, }) => {
-    const copyToClipboard = (0, react_1.useCallback)(async (data) => {
-        if (!data || data.length === 0) {
-            return;
-        }
-        try {
-            // Convert data to TSV format (Tab-Separated Values)
-            // This is the format Excel expects for copying tabular data
-            const tsvData = data
-                .map((row) => row
-                .map((cell) => {
-                // Escape cells containing tabs, newlines, or quotes
-                const cellStr = String(cell ?? "");
-                if (cellStr.includes("\t") ||
-                    cellStr.includes("\n") ||
-                    // eslint-disable-next-line quotes
-                    cellStr.includes('"')) {
-                    // Wrap in quotes and escape existing quotes
-                    // eslint-disable-next-line quotes
-                    return `"${cellStr.replace(/"/g, '""')}"`;
-                }
-                return cellStr;
-            })
-                .join("\t"))
-                .join("\n");
-            // Use the Clipboard API if available
-            if (navigator.clipboard?.writeText) {
-                await navigator.clipboard.writeText(tsvData);
-                triggerCopyFlash(); // Trigger flash animation on successful copy
-            }
-            else {
-                // Fallback for older browsers
-                const textArea = document.createElement("textarea");
-                textArea.value = tsvData;
-                textArea.style.position = "fixed";
-                textArea.style.left = "-999999px";
-                textArea.style.top = "-999999px";
-                document.body.appendChild(textArea);
-                textArea.focus();
-                textArea.select();
-                // eslint-disable-next-line sonarjs/deprecation
-                document.execCommand("copy");
-                triggerCopyFlash(); // Trigger flash animation on successful copy
-                document.body.removeChild(textArea);
-            }
-            // eslint-disable-next-line sonarjs/no-ignored-exceptions
-        }
-        catch {
-            // Silently fail for clipboard operations
-        }
-    }, [triggerCopyFlash]);
-    const handleCopy = (0, react_1.useCallback)((event) => {
-        if (!enabled || !hasSelection) {
-            return;
-        }
-        // Check for Ctrl+C (Windows/Linux) or Cmd+C (Mac)
-        if ((event.ctrlKey || event.metaKey) && event.key === "c") {
-            const data = getCellSelectionData();
-            if (data.length > 0) {
-                event.preventDefault();
-                copyToClipboard(data);
-            }
-        }
-    }, [enabled, hasSelection, getCellSelectionData, copyToClipboard]);
-    (0, react_1.useEffect)(() => {
-        if (!enabled) {
-            return;
-        }
-        document.addEventListener("keydown", handleCopy);
-        return () => {
-            document.removeEventListener("keydown", handleCopy);
-        };
-    }, [enabled, handleCopy]);
-    return { copyToClipboard };
-};
-exports.useCopyToClipboard = useCopyToClipboard;

package/packages/shared-components/dist/SmartGrid/hooks/useExportToExcel.js

@@ -1,241 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useExportToExcel = useExportToExcel;
-const material_1 = require("@mui/material");
-const exceljs_1 = __importDefault(require("exceljs"));
-const file_saver_1 = require("file-saver");
-const Toast_1 = require("../../Toast");
-const helper_1 = require("../exportUtils/helper");
-const DEFAULT_EXCLUDED_COLUMNS = [
-    "select",
-    "srNo",
-    "action",
-    "actionBy",
-];
-// Theme-based Excel styling hook
-const useExcelStyles = () => {
-    const theme = (0, material_1.useTheme)();
-    const { iron, black } = theme.palette.app.color;
-    const argbIron700 = (0, helper_1.hslaToArgb)(iron[700]);
-    const argbBlack900 = (0, helper_1.hslaToArgb)(black[900]);
-    const argbIron800 = (0, helper_1.hslaToArgb)(iron[800]);
-    const EXCEL_BORDER = {
-        bottom: { color: { argb: argbIron800 }, style: "thin" },
-        left: { color: { argb: argbIron800 }, style: "thin" },
-        right: { color: { argb: argbIron800 }, style: "thin" },
-        top: { color: { argb: argbIron800 }, style: "thin" },
-    };
-    const EXCEL_FILL = {
-        fgColor: { argb: argbIron700 },
-        pattern: "solid",
-        type: "pattern",
-    };
-    const styleCell = (cell, style) => {
-        cell.border = EXCEL_BORDER;
-        if (style === "header") {
-            cell.font = {
-                bold: true,
-                color: { argb: argbBlack900 },
-                size: 14,
-            };
-            cell.fill = EXCEL_FILL;
-        }
-        else if (style === "total") {
-            cell.font = {
-                bold: true,
-                size: 12,
-            };
-            cell.fill = EXCEL_FILL;
-        }
-    };
-    return { styleCell };
-};
-// Column Processing
-const buildColumnMappings = (cols, excludedIds) => {
-    const filtered = cols.filter(({ id }) => !excludedIds.includes(id));
-    const headers = [];
-    const colIdToHeader = {};
-    filtered.forEach((col) => {
-        const label = (0, helper_1.getColumnLabel)(col);
-        headers.push(label);
-        colIdToHeader[col.id] = label;
-    });
-    return { colIdToHeader, filteredVisibleCols: filtered, headers };
-};
-// Group Stack Management
-const ensureGroupStackSize = (stack, size, numericCols) => {
-    while (stack.length < size) {
-        stack.push({
-            count: 0,
-            id: "",
-            totals: (0, helper_1.createEmptyTotals)(numericCols),
-        });
-    }
-};
-const createTotalRow = (group, headers, colIdToHeader, numericCols) => {
-    const row = (0, helper_1.createEmptyRow)(headers);
-    const { id, totals } = group;
-    const groupLabel = colIdToHeader[id];
-    if (groupLabel) {
-        row[groupLabel] = "Total";
-    }
-    numericCols.forEach((col) => {
-        const label = colIdToHeader[col];
-        if (label) {
-            row[label] = String(totals[col] ?? 0);
-        }
-    });
-    return row;
-};
-const pushTotalRow = (context, levelIndex) => {
-    const { groupStack, numericColumns, builtRows, headers, colIdToHeader } = context;
-    const group = groupStack[levelIndex];
-    if (!group || !numericColumns.size) {
-        return;
-    }
-    builtRows.push({
-        data: createTotalRow(group, headers, colIdToHeader, numericColumns),
-        type: "total",
-    });
-};
-// Group Row Processing
-const createGroupHeaderRow = (row, context) => {
-    const { headers, filteredVisibleCols, lastSeenGrouped } = context;
-    const { getValue, subRows, groupingColumnId } = row;
-    const headerRow = (0, helper_1.createEmptyRow)(headers);
-    if (!groupingColumnId) {
-        return headerRow;
-    }
-    const colMeta = filteredVisibleCols.find(({ id }) => id === groupingColumnId);
-    if (!colMeta) {
-        return headerRow;
-    }
-    const label = (0, helper_1.getColumnLabel)(colMeta);
-    const val = (0, helper_1.toCellValue)(getValue(groupingColumnId));
-    const count = subRows?.length;
-    headerRow[label] =
-        count && count > 0 ? `${String(val)} (${count})` : String(val);
-    lastSeenGrouped[label] = val;
-    return headerRow;
-};
-const processGroupRow = (row, context) => {
-    const { depth, groupingColumnId, subRows } = row;
-    const { groupStack, numericColumns, builtRows } = context;
-    const level = typeof depth === "number" && depth >= 0 ? depth : 0;
-    while (groupStack.length > level) {
-        pushTotalRow(context, groupStack.length - 1);
-        groupStack.pop();
-    }
-    ensureGroupStackSize(groupStack, level + 1, numericColumns);
-    groupStack[level] = {
-        count: subRows?.length ?? 0,
-        id: groupingColumnId ?? "",
-        totals: (0, helper_1.createEmptyTotals)(numericColumns),
-    };
-    builtRows.push({
-        data: createGroupHeaderRow(row, context),
-        type: "group",
-    });
-};
-// Data Row Processing
-const processDataRow = (row, context) => {
-    const { filteredVisibleCols, hasGrouping, groupingColumnNames, lastSeenGrouped, numericColumns, groupStack, builtRows, } = context;
-    const { getValue } = row;
-    const dataRow = {};
-    filteredVisibleCols.forEach((col) => {
-        const { id } = col;
-        const label = (0, helper_1.getColumnLabel)(col);
-        const cell = (0, helper_1.toCellValue)(getValue(id));
-        let finalValue = cell;
-        if (hasGrouping && groupingColumnNames.includes(id)) {
-            const last = lastSeenGrouped[label];
-            finalValue = last === cell ? "" : cell;
-            lastSeenGrouped[label] = cell;
-        }
-        dataRow[label] = finalValue;
-        if (numericColumns.has(id)) {
-            const numVal = typeof cell === "number" ? cell : 0;
-            groupStack.forEach(({ totals }) => {
-                totals[id] = (totals[id] ?? 0) + numVal;
-            });
-        }
-    });
-    builtRows.push({ data: dataRow, type: "data" });
-};
-const processAllRows = (rows, context) => {
-    const { groupStack } = context;
-    rows.forEach((row) => {
-        if (row.getIsGrouped?.() ?? false) {
-            processGroupRow(row, context);
-        }
-        else {
-            processDataRow(row, context);
-        }
-    });
-    while (groupStack.length > 0) {
-        pushTotalRow(context, groupStack.length - 1);
-        groupStack.pop();
-    }
-};
-// Excel Generation
-const generateExcelFile = async (builtRows, headers, groupingColumnNames, colIdToHeader, fileName, styleCell) => {
-    const workbook = new exceljs_1.default.Workbook();
-    const sheet = workbook.addWorksheet("Sheet1");
-    const groupingHeaderSet = new Set(groupingColumnNames.map((name) => colIdToHeader[name]).filter(Boolean));
-    const headerRow = sheet.addRow(headers);
-    headerRow.eachCell((cell) => styleCell(cell, "header"));
-    builtRows.forEach((row) => {
-        const values = headers.map((h) => (0, helper_1.formatCellForExcel)(row.data[h] ?? "", row.type, groupingHeaderSet.has(h)));
-        const excelRow = sheet.addRow(values);
-        excelRow.eachCell((cell) => styleCell(cell, row.type === "total" ? "total" : undefined));
-    });
-    sheet.columns.forEach((col) => {
-        let maxWidth = 12;
-        col.eachCell?.({ includeEmpty: true }, ({ value }) => {
-            maxWidth = Math.max(maxWidth, (0, helper_1.extractTextForWidth)(value).length + 2);
-        });
-        col.width = Math.min(maxWidth, 60);
-    });
-    const buffer = await workbook.xlsx.writeBuffer();
-    (0, file_saver_1.saveAs)(new Blob([buffer]), `${fileName}.xlsx`);
-};
-// Main Export Function
-async function exportSmartGridToExcel(gridRef, options, styleCell) {
-    try {
-        const table = gridRef.current?.getTable();
-        const excludedIds = [
-            ...DEFAULT_EXCLUDED_COLUMNS,
-            ...(options.excludedColumns ?? []),
-        ];
-        const visibleCols = table?.getVisibleLeafColumns();
-        const { colIdToHeader, filteredVisibleCols, headers } = buildColumnMappings(visibleCols, excludedIds);
-        const rows = table?.getRowModel().rows;
-        const groupingColumnNames = table?.getState().grouping ?? [];
-        const context = {
-            builtRows: [],
-            colIdToHeader,
-            filteredVisibleCols,
-            groupStack: [],
-            groupingColumnNames,
-            hasGrouping: groupingColumnNames.length > 0,
-            headers,
-            lastSeenGrouped: {},
-            numericColumns: new Set(options.numericColumns ?? []),
-        };
-        processAllRows(rows, context);
-        await generateExcelFile(context.builtRows, headers, groupingColumnNames, colIdToHeader, options.fileName, styleCell);
-    }
-    catch (error) {
-        Toast_1.toasts.error({ title: `Failed to export to Excel: ${error}` });
-    }
-}
-// Hook: useExportToExcel
-function useExportToExcel() {
-    const { styleCell } = useExcelStyles();
-    return {
-        exportToExcel: (gridRef, fileName, numericColumns, excludedColumns) => exportSmartGridToExcel(gridRef, { fileName, numericColumns, excludedColumns }, styleCell),
-    };
-}

package/packages/shared-components/dist/SmartGrid/hooks/useGetColumnWidth.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useGetColumnWidth = void 0;
-const react_1 = require("react");
-const useGetColumnWidth = ({ columns, headerRef, table, }) => {
-    const [columnWidths, setColumnWidths] = (0, react_1.useState)([]);
-    const { getColumn, getRowModel, getState } = table;
-    const columnSizing = getState().columnSizing;
-    const columnOrder = getState().columnOrder;
-    const rowDataLength = getRowModel().rows.length;
-    const updateColumnWidths = (0, react_1.useCallback)(() => {
-        if (headerRef.current) {
-            // Find all header rows
-            const headerRows = headerRef.current.querySelectorAll("tr");
-            // Get the last row which contains the actual data column headers (not grouped headers)
-            const lastHeaderRow = headerRows[headerRows.length - 1];
-            if (lastHeaderRow) {
-                const headerCells = lastHeaderRow.querySelectorAll("th");
-                const widths = Array.from(headerCells).map((cell) => {
-                    const columnId = cell.getAttribute("data-column-id");
-                    const columnDef = columnId ? getColumn(columnId)?.columnDef : null;
-                    return cell.getBoundingClientRect().width ?? columnDef?.size ?? 50;
-                });
-                setColumnWidths(widths);
-            }
-        }
-        else {
-            const flatColumns = [];
-            const flattenColumns = (cols) => {
-                cols.forEach((col) => {
-                    if ("columns" in col && col.columns) {
-                        flattenColumns(col.columns);
-                    }
-                    else {
-                        flatColumns.push(col);
-                    }
-                });
-            };
-            flattenColumns(columns);
-            setColumnWidths(flatColumns.map((col) => col.size ?? 150));
-        }
-    }, [headerRef, table, columns]);
-    (0, react_1.useEffect)(() => {
-        updateColumnWidths();
-        window.addEventListener("resize", updateColumnWidths);
-        const observer = new ResizeObserver(() => {
-            updateColumnWidths();
-        });
-        if (headerRef.current?.parentElement) {
-            observer.observe(headerRef.current.parentElement);
-        }
-        return () => {
-            window.removeEventListener("resize", updateColumnWidths);
-            observer.disconnect();
-        };
-    }, [
-        columnSizing,
-        columnOrder,
-        columns.length,
-        rowDataLength,
-        updateColumnWidths,
-    ]);
-    return { columnWidths };
-};
-exports.useGetColumnWidth = useGetColumnWidth;

package/packages/shared-components/dist/SmartGrid/hooks/useGetDragMethods.js

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useGetDragMethods = void 0;
-const core_1 = require("@dnd-kit/core");
-const sortable_1 = require("@dnd-kit/sortable");
-const react_1 = require("react");
-const useGetDragMethods = ({ swipeableColumns, table, }) => {
-    // Memoize non-reorderable column IDs to avoid recreating the Set on every render
-    const nonReorderableColumnIds = (0, react_1.useMemo)(() => new Set(["select", "action"]), []);
-    // Initialize DnD sensors with pointer detection and minimal activation distance
-    const sensors = (0, core_1.useSensors)((0, core_1.useSensor)(core_1.PointerSensor, {
-        activationConstraint: {
-            distance: 5,
-        },
-    }));
-    /**
-     *  useCallback is used here to memoize the function
-     * so it doesn’t get re-created on every render.
-     *
-     * Checks if a header (column) is reorderable.
-     * Returns false for pinned, placeholder, or disabled columns.
-     */
-    const isHeaderReorderable = (0, react_1.useCallback)((header, isLeaf) => {
-        if (!swipeableColumns || !isLeaf || header.isPlaceholder) {
-            return false;
-        }
-        const columnId = header.column.id;
-        const columnDef = header.column.columnDef;
-        const accessorKey = columnDef?.accessorKey;
-        const { enableColumnOrdering } = columnDef;
-        return (enableColumnOrdering !== false &&
-            accessorKey !== "action" &&
-            !nonReorderableColumnIds.has(columnId));
-    }, [swipeableColumns, nonReorderableColumnIds]);
-    /**
-     *  useCallback is used again to memoize `handleDragEnd`
-     * to ensure stable reference across renders.
-     *
-     * Handles column drag-and-drop reordering:
-     * - Skips pinned columns
-     * - Updates the column order in the TanStack Table instance
-     */
-    const handleDragEnd = (0, react_1.useCallback)((event) => {
-        if (!swipeableColumns) {
-            return;
-        }
-        const { active, over } = event;
-        if (!over || active.id === over.id) {
-            return;
-        }
-        const activeId = String(active.id);
-        const overId = String(over.id);
-        const activeColumn = table.getColumn(activeId);
-        const overColumn = table.getColumn(overId);
-        if (!activeColumn || !overColumn) {
-            return;
-        }
-        if (activeColumn.getIsPinned() || overColumn.getIsPinned()) {
-            return;
-        }
-        const allLeafColumns = table.getAllLeafColumns();
-        const currentOrder = table.getState().columnOrder.length > 0
-            ? table.getState().columnOrder
-            : allLeafColumns.map((column) => column.id);
-        const { center, left, right } = currentOrder.reduce((acc, columnId) => {
-            const column = table.getColumn(columnId);
-            if (!column) {
-                return acc;
-            }
-            const pinState = column.getIsPinned();
-            if (pinState === "left") {
-                acc.left.push(columnId);
-            }
-            else if (pinState === "right") {
-                acc.right.push(columnId);
-            }
-            else {
-                acc.center.push(columnId);
-            }
-            return acc;
-        }, {
-            center: [],
-            left: [],
-            right: [],
-        });
-        const activeIndex = center.indexOf(activeId);
-        const overIndex = center.indexOf(overId);
-        if (activeIndex === -1 || overIndex === -1) {
-            return;
-        }
-        const updatedCenterOrder = (0, sortable_1.arrayMove)(center, activeIndex, overIndex);
-        const newOrder = [...left, ...updatedCenterOrder, ...right];
-        table.setColumnOrder(newOrder);
-    }, [swipeableColumns, table]);
-    return {
-        handleDragEnd,
-        isHeaderReorderable,
-        sensors,
-    };
-};
-exports.useGetDragMethods = useGetDragMethods;