react-glide-table 2.0.2 → 2.2.0

package/dist/compound.js

@@ -21,6 +21,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/DataTableContext.tsx
 import { createContext, use } from "react";
@@ -861,23 +862,49 @@ var useConvertTreeData = ({
 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 });
   }
@@ -899,10 +926,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;
 }
@@ -918,7 +985,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)
       });
     }
   };
@@ -1757,6 +1825,348 @@ function getMergedHeaderGroups(headerGroups) {
   }));
 }
 
+// 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-reorder/useColumnReorder.ts
+import {
+  useCallback,
+  useEffect as useEffect3,
+  useRef as useRef3,
+  useState
+} from "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 = useRef3(null);
+  const columnOrderRef = useRef3(columnOrder);
+  const onColumnOrderChangeRef = useRef3(onColumnOrderChange);
+  const [draggingColumnId, setDraggingColumnId] = useState(null);
+  const [dropTarget, setDropTarget] = useState(
+    null
+  );
+  const dropTargetRef = useRef3(dropTarget);
+  const previousUserSelectRef = useRef3(null);
+  columnOrderRef.current = columnOrder;
+  onColumnOrderChangeRef.current = onColumnOrderChange;
+  dropTargetRef.current = dropTarget;
+  const resetDrag = 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");
+  }, []);
+  useEffect3(() => {
+    if (!enabled) resetDrag();
+  }, [enabled, resetDrag]);
+  useEffect3(() => {
+    return () => {
+      resetDrag();
+    };
+  }, [resetDrag]);
+  const onHeaderPointerDown = 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]
+  );
+  useEffect3(() => {
+    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/core/useGlideTable.ts
 import {
   getCoreRowModel,
@@ -1766,15 +2176,15 @@ import {
   useVirtualizer
 } from "@tanstack/react-virtual";
 import {
-  useCallback as useCallback4,
-  useEffect as useEffect6,
+  useCallback as useCallback5,
+  useEffect as useEffect7,
   useMemo as useMemo3,
-  useRef as useRef6,
-  useState as useState4
+  useRef as useRef7,
+  useState as useState5
 } from "react";
 
 // src/components/ui/table/features/cell-edit/useCellEdit.ts
-import { useCallback, useEffect as useEffect3, useRef as useRef3, useState } from "react";
+import { useCallback as useCallback2, useEffect as useEffect4, useRef as useRef4, useState as useState2 } from "react";
 
 // src/components/ui/table/features/cell-render/commitCellValue.ts
 function commitCellValue({
@@ -1814,21 +2224,21 @@ function useCellEdit({
   onDataChange,
   onCellChange
 }) {
-  const [editingCell, setEditingCell] = useState(null);
-  const [draftValue, setDraftValue] = useState("");
-  const draftValueRef = useRef3(draftValue);
-  const editingCellRef = useRef3(editingCell);
-  useEffect3(() => {
+  const [editingCell, setEditingCell] = useState2(null);
+  const [draftValue, setDraftValue] = useState2("");
+  const draftValueRef = useRef4(draftValue);
+  const editingCellRef = useRef4(editingCell);
+  useEffect4(() => {
     draftValueRef.current = draftValue;
   }, [draftValue]);
-  useEffect3(() => {
+  useEffect4(() => {
     editingCellRef.current = editingCell;
   }, [editingCell]);
-  const cancelEdit = useCallback(() => {
+  const cancelEdit = useCallback2(() => {
     setEditingCell(null);
     setDraftValue("");
   }, []);
-  const commitEdit = useCallback(
+  const commitEdit = useCallback2(
     (raw) => {
       const current = editingCellRef.current;
       if (!current) return true;
@@ -1864,7 +2274,7 @@ function useCellEdit({
     },
     [cancelEdit, data, onCellChange, onDataChange, rows]
   );
-  const startEdit = useCallback(
+  const startEdit = useCallback2(
     (rowIndex, colIndex) => {
       const cell = rows[rowIndex]?.getVisibleCells()[colIndex];
       if (!cell || !isColumnEditable(cell.column.columnDef)) return;
@@ -2100,7 +2510,7 @@ function formatDefaultCellValue(value) {
 }
 
 // src/components/ui/table/features/cell-selection/useCellSelection.ts
-import { useCallback as useCallback2, useEffect as useEffect4, useRef as useRef4, useState as useState2 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect5, useRef as useRef5, useState as useState3 } from "react";
 
 // src/components/ui/table/features/cell-selection/copyData.ts
 function formatPrimitive(value) {
@@ -2379,15 +2789,15 @@ function useCellSelection({
   onRowsPaste,
   onCellNavigate
 }) {
-  const [dragState, setDragState] = useState2(INITIAL_DRAG_STATE);
-  const pendingPasteModeRef = useRef4(null);
-  const dragStateRef = useRef4(dragState);
-  const onCellNavigateRef = useRef4(onCellNavigate);
+  const [dragState, setDragState] = useState3(INITIAL_DRAG_STATE);
+  const pendingPasteModeRef = useRef5(null);
+  const dragStateRef = useRef5(dragState);
+  const onCellNavigateRef = useRef5(onCellNavigate);
   dragStateRef.current = dragState;
   onCellNavigateRef.current = onCellNavigate;
   const cellSelectionBounds = getCellSelectionBounds(dragState.start, dragState.end);
   const activeSelectionBounds = enabled ? getActiveSelectionBounds(dragState, cellSelectionBounds) : null;
-  const handleCellMouseDown = useCallback2(
+  const handleCellMouseDown = useCallback3(
     (rowIndex, colIndex, options) => {
       if (!enabled) return;
       setDragState((prev) => {
@@ -2413,7 +2823,7 @@ function useCellSelection({
     },
     [enabled]
   );
-  const handleCellMouseEnter = useCallback2(
+  const handleCellMouseEnter = useCallback3(
     (rowIndex, colIndex) => {
       if (!enabled) return;
       setDragState((prev) => {
@@ -2428,7 +2838,7 @@ function useCellSelection({
     },
     [enabled]
   );
-  const handleFillHandleMouseDown = useCallback2(
+  const handleFillHandleMouseDown = useCallback3(
     (rowIndex, colIndex) => {
       if (!enabled) return;
       setDragState((prev) => {
@@ -2445,12 +2855,12 @@ function useCellSelection({
     },
     [enabled]
   );
-  useEffect4(() => {
+  useEffect5(() => {
     if (!enabled) {
       setDragState(INITIAL_DRAG_STATE);
     }
   }, [enabled]);
-  useEffect4(() => {
+  useEffect5(() => {
     if (!enabled) return;
     const handleKeyDown = (e) => {
       if (e.ctrlKey || e.metaKey || e.altKey) return;
@@ -2497,7 +2907,7 @@ function useCellSelection({
     window.addEventListener("keydown", handleKeyDown);
     return () => window.removeEventListener("keydown", handleKeyDown);
   }, [columnCount, enabled, rows]);
-  const copySelection = useCallback2(
+  const copySelection = useCallback3(
     async (options) => {
       if (!enabled || !activeSelectionBounds) return false;
       const mode = options?.includeDescendants && enableSubtreeCopy ? "subtree" : "visible";
@@ -2505,7 +2915,7 @@ function useCellSelection({
     },
     [activeSelectionBounds, enableSubtreeCopy, enabled, rows]
   );
-  useEffect4(() => {
+  useEffect5(() => {
     if (!enabled) return;
     const handleKeyDown = (e) => {
       if (!activeSelectionBounds) return;
@@ -2519,7 +2929,7 @@ function useCellSelection({
     window.addEventListener("keydown", handleKeyDown);
     return () => window.removeEventListener("keydown", handleKeyDown);
   }, [activeSelectionBounds, copySelection, enableSubtreeCopy, enabled]);
-  const emitRowsPaste = useCallback2(
+  const emitRowsPaste = useCallback3(
     (text, mode) => {
       if (!onRowsPaste || !activeSelectionBounds) return false;
       const payload = buildRowsPastePayload(
@@ -2536,7 +2946,7 @@ function useCellSelection({
     },
     [activeSelectionBounds, onRowsPaste, rows]
   );
-  useEffect4(() => {
+  useEffect5(() => {
     if (!enabled || !onRowsPaste) return;
     const pasteHandledRef = { current: false };
     const ignoreNextPasteRef = { current: false };
@@ -2604,7 +3014,7 @@ function useCellSelection({
     enabled,
     onRowsPaste
   ]);
-  useEffect4(() => {
+  useEffect5(() => {
     if (!enabled) return;
     const handleMouseUp = () => {
       setDragState((prev) => {
@@ -2656,12 +3066,12 @@ function useCellSelection({
 
 // src/components/ui/table/features/inline-search/useInlineSearch.ts
 import {
-  useCallback as useCallback3,
-  useEffect as useEffect5,
+  useCallback as useCallback4,
+  useEffect as useEffect6,
   useId,
   useMemo as useMemo2,
-  useRef as useRef5,
-  useState as useState3
+  useRef as useRef6,
+  useState as useState4
 } from "react";
 var EMPTY_MATCH_KEYS = /* @__PURE__ */ new Set();
 function useInlineSearch({
@@ -2680,45 +3090,45 @@ function useInlineSearch({
   rootRef
 }) {
   const searchInputId = useId();
-  const searchInputRef = useRef5(null);
-  const [internalShowSearch, setInternalShowSearch] = useState3(false);
-  const [internalSearchValue, setInternalSearchValue] = useState3("");
-  const [internalResults, setInternalResults] = useState3(
+  const searchInputRef = useRef6(null);
+  const [internalShowSearch, setInternalShowSearch] = useState4(false);
+  const [internalSearchValue, setInternalSearchValue] = useState4("");
+  const [internalResults, setInternalResults] = useState4(
     []
   );
-  const [searchStatus, setSearchStatus] = useState3();
-  const searchStatusRef = useRef5(searchStatus);
+  const [searchStatus, setSearchStatus] = useState4();
+  const searchStatusRef = useRef6(searchStatus);
   searchStatusRef.current = searchStatus;
-  const abortControllerRef = useRef5(null);
-  const searchHandleRef = useRef5(void 0);
-  const initialStartRowRef = useRef5(initialStartRow);
+  const abortControllerRef = useRef6(null);
+  const searchHandleRef = useRef6(void 0);
+  const initialStartRowRef = useRef6(initialStartRow);
   initialStartRowRef.current = initialStartRow;
-  const getCellValueRef = useRef5(getCellValue);
+  const getCellValueRef = useRef6(getCellValue);
   getCellValueRef.current = getCellValue;
   const showSearch = controlledShowSearch ?? internalShowSearch;
   const searchValue = controlledSearchValue ?? internalSearchValue;
   const searchResults = controlledSearchResults ?? internalResults;
-  const setSearchValue = useCallback3(
+  const setSearchValue = useCallback4(
     (value) => {
       setInternalSearchValue(value);
       onSearchValueChange?.(value);
     },
     [onSearchValueChange]
   );
-  const cancelSearch = useCallback3(() => {
+  const cancelSearch = useCallback4(() => {
     if (searchHandleRef.current !== void 0) {
       window.cancelAnimationFrame(searchHandleRef.current);
       searchHandleRef.current = void 0;
     }
     abortControllerRef.current?.abort();
   }, []);
-  const emitResultsChanged = useCallback3(
+  const emitResultsChanged = useCallback4(
     (results, navIndex) => {
       onSearchResultsChanged?.(results, navIndex);
     },
     [onSearchResultsChanged]
   );
-  const navigateToIndex = useCallback3(
+  const navigateToIndex = useCallback4(
     (results, navIndex) => {
       if (onSearchResultsChanged) return;
       if (navIndex < 0 || navIndex >= results.length) return;
@@ -2728,7 +3138,7 @@ function useInlineSearch({
     },
     [onNavigateToResult, onSearchResultsChanged]
   );
-  const beginSearch = useCallback3(
+  const beginSearch = useCallback4(
     (query) => {
       if (controlledSearchResults !== void 0) return;
       const totalRows = rowCount;
@@ -2800,12 +3210,12 @@ function useInlineSearch({
       rowCount
     ]
   );
-  const openSearch = useCallback3(() => {
+  const openSearch = useCallback4(() => {
     if (controlledShowSearch === void 0) {
       setInternalShowSearch(true);
     }
   }, [controlledShowSearch]);
-  const closeSearch = useCallback3(() => {
+  const closeSearch = useCallback4(() => {
     if (controlledShowSearch === void 0) {
       setInternalShowSearch(false);
     }
@@ -2820,7 +3230,7 @@ function useInlineSearch({
     emitResultsChanged,
     onSearchClose
   ]);
-  const goToNext = useCallback3(() => {
+  const goToNext = useCallback4(() => {
     if (!searchStatus || searchStatus.results === 0) return;
     const newIndex = nextSearchIndex(
       searchStatus.selectedIndex,
@@ -2830,7 +3240,7 @@ function useInlineSearch({
     emitResultsChanged(searchResults, newIndex);
     navigateToIndex(searchResults, newIndex);
   }, [emitResultsChanged, navigateToIndex, searchResults, searchStatus]);
-  const goToPrevious = useCallback3(() => {
+  const goToPrevious = useCallback4(() => {
     if (!searchStatus || searchStatus.results === 0) return;
     const newIndex = previousSearchIndex(
       searchStatus.selectedIndex,
@@ -2840,7 +3250,7 @@ function useInlineSearch({
     emitResultsChanged(searchResults, newIndex);
     navigateToIndex(searchResults, newIndex);
   }, [emitResultsChanged, navigateToIndex, searchResults, searchStatus]);
-  useEffect5(() => {
+  useEffect6(() => {
     if (controlledSearchResults === void 0) return;
     if (controlledSearchResults.length > 0) {
       setSearchStatus((current) => ({
@@ -2852,7 +3262,7 @@ function useInlineSearch({
       setSearchStatus(void 0);
     }
   }, [controlledSearchResults, rowCount]);
-  useEffect5(() => {
+  useEffect6(() => {
     if (!enabled) return;
     setSearchStatus(void 0);
     setInternalResults([]);
@@ -2865,7 +3275,7 @@ function useInlineSearch({
       cancelSearch();
     }
   }, [enabled, showSearch]);
-  useEffect5(() => {
+  useEffect6(() => {
     if (!enabled || !showSearch) return;
     if (controlledSearchResults !== void 0) return;
     if (searchValue.trim() === "") {
@@ -2885,7 +3295,7 @@ function useInlineSearch({
     searchValue,
     showSearch
   ]);
-  useEffect5(() => {
+  useEffect6(() => {
     if (!enabled) return;
     const handleKeyDown = (event) => {
       if (!(event.ctrlKey || event.metaKey)) return;
@@ -2912,7 +3322,7 @@ function useInlineSearch({
     window.addEventListener("keydown", handleKeyDown, true);
     return () => window.removeEventListener("keydown", handleKeyDown, true);
   }, [controlledShowSearch, enabled, rootRef, showSearch]);
-  useEffect5(() => () => cancelSearch(), [cancelSearch]);
+  useEffect6(() => () => cancelSearch(), [cancelSearch]);
   const searchMatchKeys = useMemo2(
     () => buildSearchMatchKeys(searchResults),
     [searchResults]
@@ -2982,6 +3392,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",
@@ -3039,6 +3450,9 @@ function useGlideTable(options) {
     columnSizing: controlledColumnSizing,
     onColumnSizingChange,
     columnResizeMode = "onChange",
+    enableColumnReorder = false,
+    columnOrder: controlledColumnOrder,
+    onColumnOrderChange,
     enableColumnFreeze = false,
     enableInlineSearch = false,
     showSearch,
@@ -3059,16 +3473,17 @@ function useGlideTable(options) {
   }, [labelsProp, emptyText, loadingText, selectionLabel]);
   const enableExpand = Boolean(toggleField);
   const resolvedEnableSubtreeCopy = enableSubtreeCopy ?? enableExpand;
-  const [internalRowSelection, setInternalRowSelection] = useState4({});
-  const [internalColumnSizing, setInternalColumnSizing] = useState4({});
-  const [internalExpandedRows, setInternalExpandedRows] = useState4(
+  const [internalRowSelection, setInternalRowSelection] = useState5({});
+  const [internalColumnSizing, setInternalColumnSizing] = useState5({});
+  const [internalColumnOrder, setInternalColumnOrder] = useState5([]);
+  const [internalExpandedRows, setInternalExpandedRows] = useState5(
     () => /* @__PURE__ */ new Set()
   );
-  const [hoveredRowIndex, setHoveredRowIndex] = useState4(null);
-  const scrollRef = useRef6(null);
-  const rootRef = useRef6(null);
+  const [hoveredRowIndex, setHoveredRowIndex] = useState5(null);
+  const scrollRef = useRef7(null);
+  const rootRef = useRef7(null);
   const shouldVirtualize = enableVirtualization && !enableRowSpan;
-  useEffect6(() => {
+  useEffect7(() => {
     if (enableVirtualization && enableRowSpan) {
       console.warn(
         "[useGlideTable] enableRowSpan is on; virtualization is disabled to preserve cell merges."
@@ -3081,8 +3496,23 @@ function useGlideTable(options) {
     internalRowSelection
   );
   const columnSizing = controlledColumnSizing ?? internalColumnSizing;
+  const columnOrder = controlledColumnOrder ?? internalColumnOrder;
+  const tableColumns = useMemo3(() => {
+    if (!enableColumnReorder) return columns;
+    return applyLeafColumnOrder(columns, columnOrder);
+  }, [columnOrder, columns, enableColumnReorder]);
+  const setColumnOrder = useCallback5(
+    (next) => {
+      if (onColumnOrderChange) {
+        onColumnOrderChange(next);
+        return;
+      }
+      setInternalColumnOrder(next);
+    },
+    [onColumnOrderChange]
+  );
   const expandedRows = controlledExpandedRows ?? internalExpandedRows;
-  const handleExpandedRowsChange = useCallback4(
+  const handleExpandedRowsChange = useCallback5(
     (next) => {
       if (onExpandedRowsChange) {
         onExpandedRowsChange(next);
@@ -3105,7 +3535,7 @@ function useGlideTable(options) {
   });
   const table = useReactTable({
     data: tableData,
-    columns,
+    columns: tableColumns,
     ...enableColumnResize ? {
       defaultColumn: {
         minSize: DATA_TABLE_COLUMN_MIN_SIZE,
@@ -3185,7 +3615,7 @@ function useGlideTable(options) {
     }
     return indices;
   }, [selectedRows]);
-  const scrollCellIntoView = useCallback4(
+  const scrollCellIntoView = useCallback5(
     (rowIndex, colIndex, options2) => {
       const align = options2?.align ?? "nearest";
       const blockAlign = align === "center" ? "center" : "nearest";
@@ -3212,7 +3642,7 @@ function useGlideTable(options) {
     },
     [rowVirtualizer, shouldVirtualize]
   );
-  const handleCellNavigate = useCallback4(
+  const handleCellNavigate = useCallback5(
     (position) => {
       scrollCellIntoView(position.row, position.col, { align: "nearest" });
     },
@@ -3249,7 +3679,7 @@ function useGlideTable(options) {
     () => createCellRendererRegistry(cellRenderers),
     [cellRenderers]
   );
-  const commitRenderedCellValue = useCallback4(
+  const commitRenderedCellValue = useCallback5(
     (rowId, columnId, value) => commitCellValue({
       data: tableData,
       rows,
@@ -3261,11 +3691,11 @@ function useGlideTable(options) {
     }),
     [onCellChange, onDataChange, rows, tableData]
   );
-  const getCellContext = useCallback4(
+  const getCellContext = useCallback5(
     (cell) => withCellUpdate(cell.getContext(), commitRenderedCellValue),
     [commitRenderedCellValue]
   );
-  const handleCellMouseDownWithCommit = useCallback4(
+  const handleCellMouseDownWithCommit = useCallback5(
     (rowIndex, colIndex, options2) => {
       const isSameEditingCell = editingCell?.rowIndex === rowIndex && editingCell?.colIndex === colIndex;
       if (editingCell && !isSameEditingCell && !commitEdit()) {
@@ -3275,7 +3705,7 @@ function useGlideTable(options) {
     },
     [commitEdit, editingCell, handleCellMouseDown]
   );
-  const navigateToSearchResult = useCallback4(
+  const navigateToSearchResult = useCallback5(
     (item) => {
       const [colIndex, rowIndex] = item;
       handleCellMouseDownWithCommit(rowIndex, colIndex);
@@ -3283,7 +3713,7 @@ function useGlideTable(options) {
     },
     [handleCellMouseDownWithCommit, scrollCellIntoView]
   );
-  const resolveSearchRowId = useCallback4(
+  const resolveSearchRowId = useCallback5(
     (row, index) => {
       if (getRowId) return getRowId(row, index);
       if (enableExpand) {
@@ -3323,7 +3753,7 @@ function useGlideTable(options) {
     tableData,
     toggleField
   ]);
-  const searchCorpusRef = useRef6(searchCorpus);
+  const searchCorpusRef = useRef7(searchCorpus);
   searchCorpusRef.current = searchCorpus;
   const visibleRowIndexById = useMemo3(() => {
     const map = /* @__PURE__ */ new Map();
@@ -3332,7 +3762,7 @@ function useGlideTable(options) {
     }
     return map;
   }, [resolveSearchRowId, rows]);
-  const getSearchCellValue = useCallback4(
+  const getSearchCellValue = useCallback5(
     (rowIndex, colIndex) => {
       const corpusRow = searchCorpusRef.current[rowIndex];
       const column = visibleLeafColumns[colIndex];
@@ -3355,14 +3785,14 @@ function useGlideTable(options) {
     },
     [rows, visibleLeafColumns, visibleRowIndexById]
   );
-  const pendingSearchNavRef = useRef6(null);
-  const focusSearchResult = useCallback4(
+  const pendingSearchNavRef = useRef7(null);
+  const focusSearchResult = useCallback5(
     (colIndex, visibleRowIndex) => {
       navigateToSearchResult([colIndex, visibleRowIndex]);
     },
     [navigateToSearchResult]
   );
-  const navigateToCorpusSearchResult = useCallback4(
+  const navigateToCorpusSearchResult = useCallback5(
     (item) => {
       const [colIndex, corpusRowIndex] = item;
       const corpusRow = searchCorpusRef.current[corpusRowIndex];
@@ -3395,7 +3825,7 @@ function useGlideTable(options) {
       visibleRowIndexById
     ]
   );
-  useEffect6(() => {
+  useEffect7(() => {
     const pending = pendingSearchNavRef.current;
     if (!pending) return;
     const visibleRowIndex = visibleRowIndexById.get(pending.rowId);
@@ -3445,13 +3875,13 @@ function useGlideTable(options) {
     searchCorpus,
     visibleRowIndexById
   ]);
-  const clearHover = useCallback4(() => {
+  const clearHover = useCallback5(() => {
     setHoveredRowIndex(null);
   }, []);
-  const handleRowHover = useCallback4((rowIndex, _rowData) => {
+  const handleRowHover = useCallback5((rowIndex, _rowData) => {
     setHoveredRowIndex(rowIndex);
   }, []);
-  const handleToggleSelect = useCallback4(
+  const handleToggleSelect = useCallback5(
     (row) => {
       if (!row.getCanSelect()) return;
       if (preserveRowSelection && row.getIsSelected()) {
@@ -3461,7 +3891,7 @@ function useGlideTable(options) {
     },
     [preserveRowSelection]
   );
-  const handleToggleExpand = useCallback4(
+  const handleToggleExpand = useCallback5(
     (rowKey) => {
       if (preventExpand) return;
       handleExpandedRowsChange(toggleExpandedRowId(rowKey, expandedRows));
@@ -3567,12 +3997,12 @@ function useGlideTable(options) {
     visibleSearchMatchKeys,
     visibleActiveMatch
   ]);
-  const copySelectionRef = useRef6(copySelection);
-  useEffect6(() => {
+  const copySelectionRef = useRef7(copySelection);
+  useEffect7(() => {
     copySelectionRef.current = copySelection;
   }, [copySelection]);
-  const stableCopySelection = useCallback4((options2) => copySelectionRef.current(options2), []);
-  useEffect6(() => {
+  const stableCopySelection = useCallback5((options2) => copySelectionRef.current(options2), []);
+  useEffect7(() => {
     onCopyActionsReady?.({ copySelection: stableCopySelection });
   }, [onCopyActionsReady, stableCopySelection]);
   return {
@@ -3587,6 +4017,7 @@ function useGlideTable(options) {
     selectionLabel: labels.selection,
     enableCellSelection,
     enableColumnResize,
+    enableColumnReorder,
     enableColumnFreeze,
     enableInlineSearch,
     shouldVirtualize,
@@ -3600,6 +4031,7 @@ function useGlideTable(options) {
     getCellContext,
     handleToggleSelect,
     clearHover,
+    setColumnOrder,
     copySelection: stableCopySelection,
     inlineSearch: {
       showSearch: inlineSearch.showSearch,
@@ -3683,6 +4115,7 @@ function DataTable({
     selectionLabel,
     enableCellSelection,
     enableColumnResize,
+    enableColumnReorder,
     enableColumnFreeze,
     enableInlineSearch,
     shouldVirtualize,
@@ -3695,6 +4128,7 @@ function DataTable({
     rowContextValue,
     handleToggleSelect,
     clearHover,
+    setColumnOrder,
     inlineSearch
   } = useGlideTable(glideOptions);
   const ToolbarSlot = slots?.Toolbar ?? DataTableToolbar;
@@ -3704,6 +4138,12 @@ function DataTable({
   const EmptySlot = slots?.Empty ?? DefaultEmpty;
   const freezeOffsets = rowContextValue.columnFreeze.offsets;
   const headerGroups = getMergedHeaderGroups(table.getHeaderGroups());
+  const leafColumnIds = table.getVisibleLeafColumns().map((column) => column.id);
+  const { isReordering, draggingColumnId, dropTarget, onHeaderPointerDown } = useColumnReorder({
+    enabled: enableColumnReorder,
+    columnOrder: leafColumnIds,
+    onColumnOrderChange: setColumnOrder
+  });
   const contextValue = useMemo4(
     () => ({ ...rowContextValue, classNames }),
     [rowContextValue, classNames]
@@ -3726,6 +4166,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,
@@ -3794,20 +4236,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__ */ jsxs6(
                       "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: [
@@ -3929,10 +4394,10 @@ function DataTable({
 }
 
 // src/components/ui/table/components/Table/Table.tsx
-import { useCallback as useCallback6, useMemo as useMemo5, useState as useState5 } from "react";
+import { useCallback as useCallback7, useMemo as useMemo5, useState as useState6 } from "react";
 
 // src/components/ui/table/features/cell-render/ResolvedTableCell.tsx
-import { useCallback as useCallback5 } from "react";
+import { useCallback as useCallback6 } from "react";
 function ResolvedTableCell({
   info
 }) {
@@ -3941,7 +4406,7 @@ function ResolvedTableCell({
   const meta = column.columnDef.meta;
   const value = getValue();
   const columnId = column.id;
-  const update = useCallback5(
+  const update = useCallback6(
     (next) => {
       cellRender.commitValue(row.id, columnId, next);
     },
@@ -4001,10 +4466,12 @@ function buildColumnDef(props, sort, onSort) {
     minWidth,
     maxWidth,
     resizable,
+    reorderable,
     frozen,
     align,
     rowSpan,
     rowSpanKey,
+    rowSpanParent,
     editable,
     editType,
     editInputProps,
@@ -4039,6 +4506,7 @@ function buildColumnDef(props, sort, onSort) {
       align,
       rowSpan,
       rowSpanKey,
+      rowSpanParent,
       editable,
       editType,
       editInputProps,
@@ -4046,6 +4514,7 @@ function buildColumnDef(props, sort, onSort) {
       cellProps,
       cellRender: render,
       frozen,
+      reorderable,
       className,
       headerClassName
     }
@@ -4293,8 +4762,8 @@ function TableRoot({
     () => parseTableChildren(children),
     [children]
   );
-  const [sort, setSort] = useState5(null);
-  const handleSort = useCallback6((field) => {
+  const [sort, setSort] = useState6(null);
+  const handleSort = useCallback7((field) => {
     setSort((previous) => {
       if (previous?.field !== field) {
         return { field, direction: "asc" };