react-glide-table 2.0.2 → 2.2.0

package/dist/index.cjs

@@ -33,6 +33,7 @@ __export(src_exports, {
   Table: () => Table,
   applyCellEdit: () => applyCellEdit,
   applyFillData: () => applyFillData,
+  applyLeafColumnOrder: () => applyLeafColumnOrder,
   applySelectionUpdater: () => applySelectionUpdater,
   buildColumnFreezeOffsets: () => buildColumnFreezeOffsets,
   buildColumnRowSpanMap: () => buildColumnRowSpanMap,
@@ -47,6 +48,7 @@ __export(src_exports, {
   collectCopyRowEntries: () => collectCopyRowEntries,
   collectCopyRows: () => collectCopyRows,
   collectFillChanges: () => collectFillChanges,
+  collectLeafColumnIds: () => collectLeafColumnIds,
   collectRowSpanColumns: () => collectRowSpanColumns,
   collectSearchMatchesInRange: () => collectSearchMatchesInRange,
   commitCellValue: () => commitCellValue,
@@ -72,6 +74,7 @@ __export(src_exports, {
   mapSearchResultToVisibleItem: () => mapSearchResultToVisibleItem,
   mapSearchResultsToVisibleKeys: () => mapSearchResultsToVisibleKeys,
   measureMergedSpanRowHeights: () => measureMergedSpanRowHeights,
+  moveColumnIds: () => moveColumnIds,
   nextSearchIndex: () => nextSearchIndex,
   nextSearchStride: () => nextSearchStride,
   parseCellEditValue: () => parseCellEditValue,
@@ -81,7 +84,9 @@ __export(src_exports, {
   resolveCellRenderer: () => resolveCellRenderer,
   resolveColumnFreezeSide: () => resolveColumnFreezeSide,
   resolveDataTableLabels: () => resolveDataTableLabels,
+  resolveDropEdge: () => resolveDropEdge,
   resolveHeaderFreezeOffset: () => resolveHeaderFreezeOffset,
+  resolveLeafColumnOrder: () => resolveLeafColumnOrder,
   resolvePasteColumnIds: () => resolvePasteColumnIds,
   resolveRowSelection: () => resolveRowSelection,
   resolveRowSpanAt: () => resolveRowSpanAt,
@@ -91,6 +96,7 @@ __export(src_exports, {
   toggleExpandedRowId: () => toggleExpandedRowId,
   useCellEdit: () => useCellEdit,
   useCellSelection: () => useCellSelection,
+  useColumnReorder: () => useColumnReorder,
   useConvertTreeData: () => useConvertTreeData,
   useGlideTable: () => useGlideTable,
   useInlineSearch: () => useInlineSearch,
@@ -107,6 +113,7 @@ var DEFAULT_DATA_TABLE_LABELS = {
   expandRow: "Expand row",
   collapseRow: "Collapse row",
   resizeColumn: "Resize column",
+  reorderColumn: "Reorder column",
   searchPlaceholder: "Search\u2026",
   searchResultHint: "Type to search",
   searchPrevious: "Previous result",
@@ -146,6 +153,7 @@ var DATA_TABLE_VIRTUAL_OVERSCAN = 8;
 var DATA_TABLE_COLUMN_SIZE = 150;
 var DATA_TABLE_COLUMN_MIN_SIZE = 40;
 var DATA_TABLE_COLUMN_MAX_SIZE = 800;
+var DATA_TABLE_COLUMN_REORDER_THRESHOLD = 4;
 
 // src/components/ui/table/features/cell-edit/useCellEdit.ts
 var import_react = require("react");
@@ -1411,6 +1419,135 @@ function useCellSelection({
   };
 }
 
+// src/components/ui/table/features/column-reorder/columnReorder.ts
+function getColumnDefId(column) {
+  if (column.id != null && column.id !== "") return column.id;
+  if ("accessorKey" in column && column.accessorKey != null) {
+    return String(column.accessorKey);
+  }
+  return void 0;
+}
+function getColumnDefChildren(column) {
+  if (!("columns" in column) || !Array.isArray(column.columns)) return void 0;
+  if (column.columns.length === 0) return void 0;
+  return column.columns;
+}
+function collectLeafColumnIds(columns) {
+  const ids = [];
+  for (const column of columns) {
+    const children = getColumnDefChildren(column);
+    if (children) {
+      ids.push(...collectLeafColumnIds(children));
+      continue;
+    }
+    const id = getColumnDefId(column);
+    if (id) ids.push(id);
+  }
+  return ids;
+}
+function areColumnOrdersEqual(left, right) {
+  if (left.length !== right.length) return false;
+  return left.every((id, index) => id === right[index]);
+}
+function resolveLeafColumnOrder(columns, order) {
+  const leafIds = collectLeafColumnIds(columns);
+  if (!order?.length) return leafIds;
+  const leafSet = new Set(leafIds);
+  const seen = /* @__PURE__ */ new Set();
+  const next = order.filter((id) => {
+    if (!leafSet.has(id) || seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  });
+  for (const id of leafIds) {
+    if (!seen.has(id)) next.push(id);
+  }
+  return next;
+}
+function flattenColumnSlots(columns, group) {
+  const slots = [];
+  for (const column of columns) {
+    const id = getColumnDefId(column);
+    const children = getColumnDefChildren(column);
+    if (children) {
+      const nestedGroup = id ? { id, def: column } : group;
+      slots.push(...flattenColumnSlots(children, nestedGroup));
+      continue;
+    }
+    if (!id) continue;
+    slots.push({ id, def: column, group });
+  }
+  return slots;
+}
+function rebuildColumnTree(slots) {
+  const result = [];
+  let index = 0;
+  while (index < slots.length) {
+    const slot = slots[index];
+    if (!slot.group) {
+      result.push(slot.def);
+      index += 1;
+      continue;
+    }
+    const groupId = slot.group.id;
+    const children = [];
+    while (index < slots.length && slots[index]?.group?.id === groupId) {
+      children.push(slots[index].def);
+      index += 1;
+    }
+    const firstChildId = children[0] ? getColumnDefId(children[0]) : groupId;
+    result.push({
+      ...slot.group.def,
+      id: `${groupId}::${firstChildId}`,
+      columns: children
+    });
+  }
+  return result;
+}
+function applyLeafColumnOrder(columns, order) {
+  const resolved = resolveLeafColumnOrder(columns, order);
+  const defaultOrder = collectLeafColumnIds(columns);
+  if (areColumnOrdersEqual(resolved, defaultOrder)) {
+    return columns;
+  }
+  const byId = new Map(
+    flattenColumnSlots(columns).map((slot) => [
+      slot.id,
+      slot
+    ])
+  );
+  const ordered = [];
+  for (const id of resolved) {
+    const slot = byId.get(id);
+    if (slot) ordered.push(slot);
+  }
+  return rebuildColumnTree(ordered);
+}
+function moveColumnIds(order, fromIds, targetIds, edge) {
+  if (fromIds.length === 0 || targetIds.length === 0) return [...order];
+  const fromSet = new Set(fromIds);
+  if (targetIds.some((id) => fromSet.has(id))) return [...order];
+  const rest = order.filter((id) => !fromSet.has(id));
+  const anchorId = edge === "before" ? targetIds[0] : targetIds[targetIds.length - 1];
+  const anchorIndex = rest.indexOf(anchorId);
+  if (anchorIndex < 0) return [...order];
+  const insertAt = edge === "before" ? anchorIndex : anchorIndex + 1;
+  return [...rest.slice(0, insertAt), ...fromIds, ...rest.slice(insertAt)];
+}
+function resolveDropEdge(clientX, rect) {
+  return clientX < rect.left + rect.width / 2 ? "before" : "after";
+}
+function parseReorderIds(value) {
+  if (!value) return [];
+  return value.split(",").filter(Boolean);
+}
+function serializeReorderIds(ids) {
+  return ids.join(",");
+}
+function isColumnReorderable(meta) {
+  return meta?.reorderable !== false;
+}
+
 // src/components/ui/table/features/column-freeze/columnFreeze.ts
 var HEADER_Z_BASE = 30;
 var BODY_Z_BASE = 5;
@@ -2177,23 +2314,49 @@ function applySelectionUpdater(mode, updater, previous) {
 function getRowFieldValue(row, key) {
   return row[key];
 }
-function computeRowSpans(data, rowSpanKey) {
+function normalizeRowSpanParent(value) {
+  if (!value) return [];
+  return typeof value === "string" ? [value] : [...value];
+}
+function toParentSpanList(parentSpans) {
+  if (!parentSpans?.length) return [];
+  const first = parentSpans[0];
+  if (!Array.isArray(first)) {
+    return [parentSpans];
+  }
+  return parentSpans;
+}
+function buildStartRowLookup(spans) {
+  const startRows = new Array(spans.length);
+  let origin = 0;
+  for (let i = 0; i < spans.length; i++) {
+    if ((spans[i]?.rowSpan ?? 1) > 0) origin = i;
+    startRows[i] = origin;
+  }
+  return startRows;
+}
+function sharesParentGroup(parentStartRows, rowIndex) {
+  if (parentStartRows.length === 0 || rowIndex <= 0) return true;
+  return parentStartRows.every(
+    (startRows) => startRows[rowIndex - 1] === startRows[rowIndex]
+  );
+}
+function computeRowSpans(data, rowSpanKey, parentSpans) {
   if (data.length === 0) return [];
+  const parentStartRows = toParentSpanList(parentSpans).map(buildStartRowLookup);
   const result = [];
   for (let index = 0; index < data.length; index++) {
     const currentValue = getRowFieldValue(data[index], rowSpanKey);
     const previousValue = index > 0 ? getRowFieldValue(data[index - 1], rowSpanKey) : void 0;
-    if (index > 0 && currentValue === previousValue) {
+    if (index > 0 && currentValue === previousValue && sharesParentGroup(parentStartRows, index)) {
       result.push({ rowSpan: 0, isFirstInGroup: false });
       continue;
     }
     let span = 1;
     for (let nextIndex = index + 1; nextIndex < data.length; nextIndex++) {
-      if (getRowFieldValue(data[nextIndex], rowSpanKey) === currentValue) {
-        span++;
-      } else {
-        break;
-      }
+      if (getRowFieldValue(data[nextIndex], rowSpanKey) !== currentValue) break;
+      if (!sharesParentGroup(parentStartRows, nextIndex)) break;
+      span++;
     }
     result.push({ rowSpan: span, isFirstInGroup: true });
   }
@@ -2215,10 +2378,50 @@ function resolveRowSpanAt(rowSpans, rowIndex) {
   }
   return { startRow: rowIndex, rowSpan: 1 };
 }
+function findRowSpanColumn(spec, ref) {
+  return spec.find((column) => column.columnId === ref) ?? spec.find((column) => column.rowSpanKey === ref);
+}
 function buildColumnRowSpanMap(data, columnKeys) {
   const map = /* @__PURE__ */ new Map();
-  for (const { columnId, rowSpanKey } of columnKeys) {
-    map.set(columnId, computeRowSpans(data, rowSpanKey));
+  const visiting = /* @__PURE__ */ new Set();
+  const warnedCycles = /* @__PURE__ */ new Set();
+  const virtualParents = /* @__PURE__ */ new Map();
+  const spansForColumn = (columnId) => {
+    const cached = map.get(columnId);
+    if (cached !== void 0) return cached;
+    const column = columnKeys.find((item) => item.columnId === columnId);
+    if (!column) return void 0;
+    if (visiting.has(columnId)) {
+      if (!warnedCycles.has(columnId)) {
+        warnedCycles.add(columnId);
+        console.warn(
+          `[rowSpan] rowSpanParent cycle detected at column "${columnId}"; dropping the cyclic parent reference.`
+        );
+      }
+      return void 0;
+    }
+    visiting.add(columnId);
+    const parentSpans = (column.rowSpanParent ?? []).map((ref) => spansForParentRef(ref)).filter((spans2) => Boolean(spans2));
+    visiting.delete(columnId);
+    const spans = computeRowSpans(
+      data,
+      column.rowSpanKey,
+      parentSpans.length > 0 ? parentSpans : void 0
+    );
+    map.set(columnId, spans);
+    return spans;
+  };
+  const spansForParentRef = (ref) => {
+    const parentColumn = findRowSpanColumn(columnKeys, ref);
+    if (parentColumn) return spansForColumn(parentColumn.columnId);
+    const cached = virtualParents.get(ref);
+    if (cached !== void 0) return cached;
+    const spans = computeRowSpans(data, ref);
+    virtualParents.set(ref, spans);
+    return spans;
+  };
+  for (const column of columnKeys) {
+    spansForColumn(column.columnId);
   }
   return map;
 }
@@ -2234,7 +2437,8 @@ function collectRowSpanColumns(columns) {
       if (!columnId || !columnDef.meta?.rowSpan) continue;
       result.push({
         columnId,
-        rowSpanKey: columnDef.meta.rowSpanKey ?? columnId
+        rowSpanKey: columnDef.meta.rowSpanKey ?? columnId,
+        rowSpanParent: normalizeRowSpanParent(columnDef.meta.rowSpanParent)
       });
     }
   };
@@ -2286,6 +2490,9 @@ function useGlideTable(options) {
     columnSizing: controlledColumnSizing,
     onColumnSizingChange,
     columnResizeMode = "onChange",
+    enableColumnReorder = false,
+    columnOrder: controlledColumnOrder,
+    onColumnOrderChange,
     enableColumnFreeze = false,
     enableInlineSearch = false,
     showSearch,
@@ -2308,6 +2515,7 @@ function useGlideTable(options) {
   const resolvedEnableSubtreeCopy = enableSubtreeCopy ?? enableExpand;
   const [internalRowSelection, setInternalRowSelection] = (0, import_react5.useState)({});
   const [internalColumnSizing, setInternalColumnSizing] = (0, import_react5.useState)({});
+  const [internalColumnOrder, setInternalColumnOrder] = (0, import_react5.useState)([]);
   const [internalExpandedRows, setInternalExpandedRows] = (0, import_react5.useState)(
     () => /* @__PURE__ */ new Set()
   );
@@ -2328,6 +2536,21 @@ function useGlideTable(options) {
     internalRowSelection
   );
   const columnSizing = controlledColumnSizing ?? internalColumnSizing;
+  const columnOrder = controlledColumnOrder ?? internalColumnOrder;
+  const tableColumns = (0, import_react5.useMemo)(() => {
+    if (!enableColumnReorder) return columns;
+    return applyLeafColumnOrder(columns, columnOrder);
+  }, [columnOrder, columns, enableColumnReorder]);
+  const setColumnOrder = (0, import_react5.useCallback)(
+    (next) => {
+      if (onColumnOrderChange) {
+        onColumnOrderChange(next);
+        return;
+      }
+      setInternalColumnOrder(next);
+    },
+    [onColumnOrderChange]
+  );
   const expandedRows = controlledExpandedRows ?? internalExpandedRows;
   const handleExpandedRowsChange = (0, import_react5.useCallback)(
     (next) => {
@@ -2352,7 +2575,7 @@ function useGlideTable(options) {
   });
   const table = (0, import_react_table.useReactTable)({
     data: tableData,
-    columns,
+    columns: tableColumns,
     ...enableColumnResize ? {
       defaultColumn: {
         minSize: DATA_TABLE_COLUMN_MIN_SIZE,
@@ -2834,6 +3057,7 @@ function useGlideTable(options) {
     selectionLabel: labels.selection,
     enableCellSelection,
     enableColumnResize,
+    enableColumnReorder,
     enableColumnFreeze,
     enableInlineSearch,
     shouldVirtualize,
@@ -2847,6 +3071,7 @@ function useGlideTable(options) {
     getCellContext,
     handleToggleSelect,
     clearHover,
+    setColumnOrder,
     copySelection: stableCopySelection,
     inlineSearch: {
       showSearch: inlineSearch.showSearch,
@@ -2932,13 +3157,221 @@ function getColumnSizeStyle(size, options) {
   };
 }
 
+// src/components/ui/table/features/column-reorder/useColumnReorder.ts
+var import_react8 = require("react");
+function hitTestReorderHeader(table, clientX, clientY) {
+  const headers = Array.from(
+    table.querySelectorAll(
+      "thead th[data-column-id][data-reorder-ids]"
+    )
+  );
+  const containing = headers.find((element) => {
+    const rect = element.getBoundingClientRect();
+    return clientX >= rect.left && clientX <= rect.right && clientY >= rect.top && clientY <= rect.bottom;
+  });
+  if (containing) {
+    return {
+      columnId: containing.dataset.columnId ?? "",
+      edge: resolveDropEdge(clientX, containing.getBoundingClientRect())
+    };
+  }
+  const leaves = headers.filter(
+    (element) => element.hasAttribute("data-reorder-leaf")
+  );
+  let match;
+  for (const element of leaves) {
+    const rect = element.getBoundingClientRect();
+    if (clientX >= rect.left && clientX <= rect.right) {
+      match = element;
+      break;
+    }
+  }
+  if (!match && leaves.length > 0) {
+    const first = leaves[0].getBoundingClientRect();
+    const last = leaves[leaves.length - 1].getBoundingClientRect();
+    if (clientX < first.left) match = leaves[0];
+    else if (clientX > last.right) match = leaves[leaves.length - 1];
+  }
+  if (!match) return null;
+  return {
+    columnId: match.dataset.columnId ?? "",
+    edge: resolveDropEdge(clientX, match.getBoundingClientRect())
+  };
+}
+function readTargetIds(table, columnId) {
+  const element = table.querySelector(
+    `thead th[data-column-id="${CSS.escape(columnId)}"]`
+  );
+  return parseReorderIds(element?.getAttribute("data-reorder-ids"));
+}
+function useColumnReorder(options) {
+  const { enabled, columnOrder, onColumnOrderChange } = options;
+  const sessionRef = (0, import_react8.useRef)(null);
+  const columnOrderRef = (0, import_react8.useRef)(columnOrder);
+  const onColumnOrderChangeRef = (0, import_react8.useRef)(onColumnOrderChange);
+  const [draggingColumnId, setDraggingColumnId] = (0, import_react8.useState)(null);
+  const [dropTarget, setDropTarget] = (0, import_react8.useState)(
+    null
+  );
+  const dropTargetRef = (0, import_react8.useRef)(dropTarget);
+  const previousUserSelectRef = (0, import_react8.useRef)(null);
+  columnOrderRef.current = columnOrder;
+  onColumnOrderChangeRef.current = onColumnOrderChange;
+  dropTargetRef.current = dropTarget;
+  const resetDrag = (0, import_react8.useCallback)(() => {
+    sessionRef.current = null;
+    setDraggingColumnId(null);
+    setDropTarget(null);
+    const backup = previousUserSelectRef.current;
+    previousUserSelectRef.current = null;
+    if (backup) {
+      if (backup.value) {
+        document.body.style.setProperty("user-select", backup.value, backup.priority);
+      } else {
+        document.body.style.removeProperty("user-select");
+      }
+      return;
+    }
+    document.body.style.removeProperty("user-select");
+  }, []);
+  (0, import_react8.useEffect)(() => {
+    if (!enabled) resetDrag();
+  }, [enabled, resetDrag]);
+  (0, import_react8.useEffect)(() => {
+    return () => {
+      resetDrag();
+    };
+  }, [resetDrag]);
+  const onHeaderPointerDown = (0, import_react8.useCallback)(
+    (event, meta) => {
+      if (!enabled || !meta.canDrag) return;
+      if (event.button !== 0) return;
+      if (event.pointerType === "mouse" && event.ctrlKey) return;
+      const target = event.target;
+      if (target instanceof Element && target.closest("[data-table-disable-cell-selection]")) {
+        return;
+      }
+      const table = event.currentTarget.closest("table");
+      if (!(table instanceof HTMLTableElement)) return;
+      sessionRef.current = {
+        pointerId: event.pointerId,
+        startX: event.clientX,
+        startY: event.clientY,
+        columnId: meta.columnId,
+        fromIds: meta.leafIds,
+        table,
+        active: false
+      };
+    },
+    [enabled]
+  );
+  (0, import_react8.useEffect)(() => {
+    if (!enabled) return;
+    const onPointerMove = (event) => {
+      const session = sessionRef.current;
+      if (!session || event.pointerId !== session.pointerId) return;
+      const deltaX = event.clientX - session.startX;
+      const deltaY = event.clientY - session.startY;
+      const distance = Math.hypot(deltaX, deltaY);
+      if (!session.active) {
+        if (distance < DATA_TABLE_COLUMN_REORDER_THRESHOLD) return;
+        session.active = true;
+        if (!previousUserSelectRef.current) {
+          previousUserSelectRef.current = {
+            value: document.body.style.getPropertyValue("user-select"),
+            priority: document.body.style.getPropertyPriority("user-select")
+          };
+        }
+        document.body.style.setProperty("user-select", "none");
+        setDraggingColumnId(session.columnId);
+      }
+      event.preventDefault();
+      const nextTarget = hitTestReorderHeader(
+        session.table,
+        event.clientX,
+        event.clientY
+      );
+      if (!nextTarget || !nextTarget.columnId) {
+        setDropTarget(null);
+        return;
+      }
+      const targetIds = readTargetIds(session.table, nextTarget.columnId);
+      const fromSet = new Set(session.fromIds);
+      if (targetIds.some((id) => fromSet.has(id))) {
+        setDropTarget(null);
+        return;
+      }
+      setDropTarget((previous) => {
+        if (previous?.columnId === nextTarget.columnId && previous.edge === nextTarget.edge) {
+          return previous;
+        }
+        return nextTarget;
+      });
+    };
+    const onPointerUp = (event) => {
+      const session = sessionRef.current;
+      if (!session || event.pointerId !== session.pointerId) {
+        return;
+      }
+      if (session.active) {
+        event.preventDefault();
+        const target = dropTargetRef.current;
+        if (target) {
+          const targetIds = readTargetIds(session.table, target.columnId);
+          const next = moveColumnIds(
+            columnOrderRef.current,
+            session.fromIds,
+            targetIds,
+            target.edge
+          );
+          onColumnOrderChangeRef.current(next);
+        }
+        const suppressClick = (clickEvent) => {
+          clickEvent.preventDefault();
+          clickEvent.stopPropagation();
+          document.removeEventListener("click", suppressClick, true);
+        };
+        document.addEventListener("click", suppressClick, true);
+        window.setTimeout(() => {
+          document.removeEventListener("click", suppressClick, true);
+        }, 0);
+      }
+      resetDrag();
+    };
+    const onPointerCancel = (event) => {
+      const session = sessionRef.current;
+      if (!session || event.pointerId !== session.pointerId) {
+        return;
+      }
+      if (session.active) {
+        event.preventDefault();
+      }
+      resetDrag();
+    };
+    document.addEventListener("pointermove", onPointerMove);
+    document.addEventListener("pointerup", onPointerUp);
+    document.addEventListener("pointercancel", onPointerCancel);
+    return () => {
+      document.removeEventListener("pointermove", onPointerMove);
+      document.removeEventListener("pointerup", onPointerUp);
+      document.removeEventListener("pointercancel", onPointerCancel);
+    };
+  }, [enabled, resetDrag]);
+  return {
+    isReordering: draggingColumnId != null,
+    draggingColumnId,
+    dropTarget,
+    onHeaderPointerDown
+  };
+}
+
 // src/components/ui/table/components/DataTable/DataTable.tsx
 var import_react_table3 = require("@tanstack/react-table");
-var import_react9 = require("react");
+var import_react10 = require("react");
 
 // src/components/ui/table/components/DataTable/DataTableRow.tsx
 var import_react_table2 = require("@tanstack/react-table");
-var import_react8 = require("react");
+var import_react9 = require("react");
 
 // src/components/ui/table/components/icons.tsx
 var import_jsx_runtime3 = require("react/jsx-runtime");
@@ -3236,9 +3669,9 @@ function DataTableRow({
   const expandKey = toggleField && rowData[toggleField] !== null && rowData[toggleField] !== void 0 ? String(rowData[toggleField]) : null;
   const isExpanded = expandKey !== null && Boolean(expandedRows?.has(expandKey));
   const rowLevel = typeof rowData.level === "number" ? rowData.level : 0;
-  const editInputRef = (0, import_react8.useRef)(null);
+  const editInputRef = (0, import_react9.useRef)(null);
   const isRowEditing = editingCell?.rowIndex === rowIndex;
-  (0, import_react8.useEffect)(() => {
+  (0, import_react9.useEffect)(() => {
     if (!isRowEditing) return;
     editInputRef.current?.focus();
     editInputRef.current?.select();
@@ -3836,6 +4269,7 @@ function DataTable({
     selectionLabel,
     enableCellSelection,
     enableColumnResize,
+    enableColumnReorder,
     enableColumnFreeze,
     enableInlineSearch,
     shouldVirtualize,
@@ -3848,6 +4282,7 @@ function DataTable({
     rowContextValue,
     handleToggleSelect,
     clearHover,
+    setColumnOrder,
     inlineSearch
   } = useGlideTable(glideOptions);
   const ToolbarSlot = slots?.Toolbar ?? DataTableToolbar;
@@ -3857,7 +4292,13 @@ function DataTable({
   const EmptySlot = slots?.Empty ?? DefaultEmpty;
   const freezeOffsets = rowContextValue.columnFreeze.offsets;
   const headerGroups = getMergedHeaderGroups(table.getHeaderGroups());
-  const contextValue = (0, import_react9.useMemo)(
+  const leafColumnIds = table.getVisibleLeafColumns().map((column) => column.id);
+  const { isReordering, draggingColumnId, dropTarget, onHeaderPointerDown } = useColumnReorder({
+    enabled: enableColumnReorder,
+    columnOrder: leafColumnIds,
+    onColumnOrderChange: setColumnOrder
+  });
+  const contextValue = (0, import_react10.useMemo)(
     () => ({ ...rowContextValue, classNames }),
     [rowContextValue, classNames]
   );
@@ -3879,6 +4320,8 @@ function DataTable({
         "DataTableJSX",
         !enableCellSelection && "DataTableJSX--no-cell-selection",
         enableColumnResize && "DataTableJSX--column-resize",
+        enableColumnReorder && "DataTableJSX--column-reorder",
+        isReordering && "DataTableJSX--column-reordering",
         enableColumnFreeze && "DataTableJSX--column-freeze",
         enableInlineSearch && "DataTableJSX--inline-search",
         classNames?.root,
@@ -3947,20 +4390,43 @@ function DataTable({
                       ...sizeStyle,
                       ...freezeStyle
                     };
+                    const isPlaceholder = header.isPlaceholder;
+                    const leafColumns = header.column.getLeafColumns();
+                    const leafIds = leafColumns.map((leafColumn) => leafColumn.id);
+                    const isLeafHeader = !isPlaceholder && header.subHeaders.length === 0;
+                    const canDrag = enableColumnReorder && !isPlaceholder && leafIds.length > 0 && leafColumns.every(
+                      (leafColumn) => isColumnReorderable(leafColumn.columnDef.meta)
+                    );
+                    const isDragging = draggingColumnId === header.column.id;
+                    const dropEdge = !isPlaceholder && dropTarget?.columnId === header.column.id ? dropTarget.edge : void 0;
                     return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
                       "th",
                       {
                         colSpan: header.colSpan,
                         rowSpan: header.mergedRowSpan,
+                        "data-column-id": enableColumnReorder && !isPlaceholder ? header.column.id : void 0,
+                        "data-reorder-ids": enableColumnReorder && !isPlaceholder ? serializeReorderIds(leafIds) : void 0,
+                        "data-reorder-leaf": enableColumnReorder && isLeafHeader ? "" : void 0,
+                        "data-reorderable": canDrag ? "" : void 0,
+                        "data-reordering": isDragging ? "" : void 0,
+                        "data-drop-edge": dropEdge,
                         "data-resizing": header.column.getIsResizing() ? "" : void 0,
                         "data-frozen": freezeOffset?.side,
                         "data-freeze-edge": getColumnFreezeEdgeAttr(freezeOffset),
+                        "aria-grabbed": isDragging ? true : void 0,
+                        title: canDrag ? labels.reorderColumn : void 0,
+                        onPointerDown: enableColumnReorder ? (event) => onHeaderPointerDown(event, {
+                          columnId: header.column.id,
+                          leafIds,
+                          canDrag
+                        }) : void 0,
                         style: Object.keys(headerStyle).length > 0 ? headerStyle : void 0,
                         className: cn(
                           "data-table-head-cell",
                           freezeOffset && `data-table-head-cell--frozen-${freezeOffset.side}`,
                           CELL_ALIGN_CLASS[align],
                           classNames?.headCell,
+                          dropEdge && classNames?.dropEdge,
                           headerClassName
                         ),
                         children: [
@@ -4082,7 +4548,7 @@ function DataTable({
 }
 
 // src/components/ui/table/components/Table/Table.tsx
-var import_react12 = require("react");
+var import_react13 = require("react");
 
 // src/components/ui/table/components/Table/buildColumnDef.tsx
 var import_jsx_runtime8 = require("react/jsx-runtime");
@@ -4120,10 +4586,12 @@ function buildColumnDef(props, sort, onSort) {
     minWidth,
     maxWidth,
     resizable,
+    reorderable,
     frozen,
     align,
     rowSpan,
     rowSpanKey,
+    rowSpanParent,
     editable,
     editType,
     editInputProps,
@@ -4158,6 +4626,7 @@ function buildColumnDef(props, sort, onSort) {
       align,
       rowSpan,
       rowSpanKey,
+      rowSpanParent,
       editable,
       editType,
       editInputProps,
@@ -4165,6 +4634,7 @@ function buildColumnDef(props, sort, onSort) {
       cellProps,
       cellRender: render,
       frozen,
+      reorderable,
       className,
       headerClassName
     }
@@ -4210,10 +4680,10 @@ function countLeafColumns(nodes) {
 }
 
 // src/components/ui/table/components/Table/parseTableChildren.ts
-var import_react11 = require("react");
+var import_react12 = require("react");
 
 // src/components/ui/table/components/Table/tableChildTypes.ts
-var import_react10 = require("react");
+var import_react11 = require("react");
 var TABLE_HEADER_DISPLAY_NAME = "Table.Header";
 var TABLE_BODY_DISPLAY_NAME = "Table.Body";
 var TABLE_COLUMN_DISPLAY_NAME = "Table.Column";
@@ -4226,19 +4696,19 @@ function getComponentDisplayName(type) {
   return void 0;
 }
 function isTableHeaderElement(child) {
-  return (0, import_react10.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_HEADER_DISPLAY_NAME;
+  return (0, import_react11.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_HEADER_DISPLAY_NAME;
 }
 function isTableBodyElement(child) {
-  return (0, import_react10.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_BODY_DISPLAY_NAME;
+  return (0, import_react11.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_BODY_DISPLAY_NAME;
 }
 function isTableColumnElement(child) {
-  return (0, import_react10.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_COLUMN_DISPLAY_NAME;
+  return (0, import_react11.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_COLUMN_DISPLAY_NAME;
 }
 function isTableColumnGroupElement(child) {
-  return (0, import_react10.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_COLUMN_GROUP_DISPLAY_NAME;
+  return (0, import_react11.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_COLUMN_GROUP_DISPLAY_NAME;
 }
 function isTablePaginationElement(child) {
-  return (0, import_react10.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_PAGINATION_DISPLAY_NAME;
+  return (0, import_react11.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_PAGINATION_DISPLAY_NAME;
 }
 
 // src/components/ui/table/components/Table/parseTableChildren.ts
@@ -4248,7 +4718,7 @@ function parseTableChildren(children) {
     body: null,
     pagination: null
   };
-  for (const child of import_react11.Children.toArray(children)) {
+  for (const child of import_react12.Children.toArray(children)) {
     if (isTableHeaderElement(child)) {
       slots.header = child;
       continue;
@@ -4265,7 +4735,7 @@ function parseTableChildren(children) {
 }
 function walkColumnTreeNodes(children) {
   const result = [];
-  for (const child of import_react11.Children.toArray(children)) {
+  for (const child of import_react12.Children.toArray(children)) {
     if (isTableColumnElement(child)) {
       result.push({
         type: "leaf",
@@ -4282,7 +4752,7 @@ function walkColumnTreeNodes(children) {
       });
       continue;
     }
-    if ((0, import_react11.isValidElement)(child)) {
+    if ((0, import_react12.isValidElement)(child)) {
       const nested = child.props.children;
       if (nested != null) {
         result.push(...walkColumnTreeNodes(nested));
@@ -4408,12 +4878,12 @@ function TableRoot({
   filteredCount,
   ...dataTableProps
 }) {
-  const { header, pagination: paginationElement } = (0, import_react12.useMemo)(
+  const { header, pagination: paginationElement } = (0, import_react13.useMemo)(
     () => parseTableChildren(children),
     [children]
   );
-  const [sort, setSort] = (0, import_react12.useState)(null);
-  const handleSort = (0, import_react12.useCallback)((field) => {
+  const [sort, setSort] = (0, import_react13.useState)(null);
+  const handleSort = (0, import_react13.useCallback)((field) => {
     setSort((previous) => {
       if (previous?.field !== field) {
         return { field, direction: "asc" };
@@ -4424,8 +4894,8 @@ function TableRoot({
       return null;
     });
   }, []);
-  const columnTree = (0, import_react12.useMemo)(() => extractColumnTree(header), [header]);
-  const columns = (0, import_react12.useMemo)(
+  const columnTree = (0, import_react13.useMemo)(() => extractColumnTree(header), [header]);
+  const columns = (0, import_react13.useMemo)(
     () => buildColumnDefsFromTree(columnTree, sort, handleSort),
     [columnTree, sort, handleSort]
   );
@@ -4433,7 +4903,7 @@ function TableRoot({
   const pageSize = paginationProps?.pageSize ?? 10;
   const page = paginationProps?.page ?? 1;
   const resolvedTotalCount = paginationProps?.totalCount ?? totalCount ?? data.length;
-  const tableData = (0, import_react12.useMemo)(() => {
+  const tableData = (0, import_react13.useMemo)(() => {
     const sortedData = sortTableData(data, sort);
     if (!paginationProps) return sortedData;
     return paginateTableData(sortedData, page, pageSize);
@@ -4511,6 +4981,7 @@ var Table = Object.assign(TableRoot, {
   Table,
   applyCellEdit,
   applyFillData,
+  applyLeafColumnOrder,
   applySelectionUpdater,
   buildColumnFreezeOffsets,
   buildColumnRowSpanMap,
@@ -4525,6 +4996,7 @@ var Table = Object.assign(TableRoot, {
   collectCopyRowEntries,
   collectCopyRows,
   collectFillChanges,
+  collectLeafColumnIds,
   collectRowSpanColumns,
   collectSearchMatchesInRange,
   commitCellValue,
@@ -4550,6 +5022,7 @@ var Table = Object.assign(TableRoot, {
   mapSearchResultToVisibleItem,
   mapSearchResultsToVisibleKeys,
   measureMergedSpanRowHeights,
+  moveColumnIds,
   nextSearchIndex,
   nextSearchStride,
   parseCellEditValue,
@@ -4559,7 +5032,9 @@ var Table = Object.assign(TableRoot, {
   resolveCellRenderer,
   resolveColumnFreezeSide,
   resolveDataTableLabels,
+  resolveDropEdge,
   resolveHeaderFreezeOffset,
+  resolveLeafColumnOrder,
   resolvePasteColumnIds,
   resolveRowSelection,
   resolveRowSpanAt,
@@ -4569,6 +5044,7 @@ var Table = Object.assign(TableRoot, {
   toggleExpandedRowId,
   useCellEdit,
   useCellSelection,
+  useColumnReorder,
   useConvertTreeData,
   useGlideTable,
   useInlineSearch,