react-glide-table 2.2.1 → 2.3.1

package/dist/index.cjs

@@ -83,6 +83,7 @@ __export(src_exports, {
   previousSearchIndex: () => previousSearchIndex,
   resolveCellRenderer: () => resolveCellRenderer,
   resolveColumnFreezeSide: () => resolveColumnFreezeSide,
+  resolveColumnLayoutWidths: () => resolveColumnLayoutWidths,
   resolveDataTableLabels: () => resolveDataTableLabels,
   resolveDropEdge: () => resolveDropEdge,
   resolveHeaderFreezeOffset: () => resolveHeaderFreezeOffset,
@@ -136,7 +137,7 @@ var DEFAULT_TREE_QTY_FIELD = "qty";
 // src/core/useGlideTable.ts
 var import_react_table = require("@tanstack/react-table");
 var import_react_virtual = require("@tanstack/react-virtual");
-var import_react5 = require("react");
+var import_react6 = require("react");
 
 // src/components/ui/table/constants.ts
 var CELL_ALIGN_CLASS = {
@@ -537,8 +538,92 @@ function withCellUpdate(context, commitValue) {
   };
 }
 
+// src/components/ui/table/features/cell-selection/pasteData.ts
+function countLeadingEmptyCells(cells) {
+  let depth = 0;
+  while (depth < cells.length && cells[depth] === "") {
+    depth += 1;
+  }
+  return depth;
+}
+function looksLikeSubtreeIndentation(leadingEmptyCounts) {
+  if (leadingEmptyCounts.length === 0) return false;
+  const firstDepth = leadingEmptyCounts[0] ?? 0;
+  if (firstDepth !== 0) return false;
+  return leadingEmptyCounts.some((depth) => depth > 0);
+}
+function parseClipboardTSV(text) {
+  return parseClipboardTSVWithDepths(text).values;
+}
+function parseClipboardTSVWithDepths(text) {
+  if (!text) return { values: [], depths: [] };
+  const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const withoutTrailing = normalized.replace(/\n+$/, "");
+  if (!withoutTrailing) return { values: [], depths: [] };
+  const rows = withoutTrailing.split("\n").map((line) => line.split("	"));
+  const leadingEmptyCounts = rows.map(countLeadingEmptyCells);
+  const treatAsDepth = looksLikeSubtreeIndentation(leadingEmptyCounts);
+  const values = [];
+  const depths = [];
+  for (let index = 0; index < rows.length; index += 1) {
+    const cells = rows[index] ?? [];
+    const depth = leadingEmptyCounts[index] ?? 0;
+    if (treatAsDepth) {
+      values.push(cells.slice(depth));
+      depths.push(depth);
+    } else {
+      values.push(cells);
+      depths.push(0);
+    }
+  }
+  return { values, depths };
+}
+function resolvePasteColumnIds(rows, startCol, width) {
+  if (width <= 0) return [];
+  const cells = rows[0]?.getVisibleCells() ?? [];
+  const columnIds = [];
+  for (let offset = 0; offset < width; offset += 1) {
+    const cell = cells[startCol + offset];
+    if (!cell) break;
+    columnIds.push(cell.column.id);
+  }
+  return columnIds;
+}
+function buildRowsPastePayload(rows, startRow, startCol, text, mode, endRow = startRow) {
+  const { values, depths } = parseClipboardTSVWithDepths(text);
+  if (values.length === 0) return null;
+  const width = Math.max(...values.map((row) => row.length), 0);
+  if (width === 0) return null;
+  const columnIds = resolvePasteColumnIds(rows, startCol, width);
+  if (columnIds.length === 0) return null;
+  const rowIds = [];
+  for (let offset = 0; offset < values.length; offset += 1) {
+    const row = rows[startRow + offset];
+    if (!row) break;
+    rowIds.push(row.id);
+  }
+  const anchorRow = rows[endRow] ?? rows[startRow];
+  return {
+    mode,
+    startRow,
+    startCol,
+    endRow,
+    rowIds,
+    anchorRowId: anchorRow?.id ?? "",
+    columnIds,
+    values,
+    depths
+  };
+}
+function isEditablePasteTarget(target) {
+  if (!(target instanceof HTMLElement)) return false;
+  const tag = target.tagName;
+  if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
+  return Boolean(target.isContentEditable);
+}
+
 // src/components/ui/table/features/cell-selection/useCellSelection.ts
-var import_react2 = require("react");
+var import_react3 = require("react");
 
 // src/components/ui/table/features/cell-selection/cellSelection.ts
 var INITIAL_DRAG_STATE = {
@@ -846,6 +931,219 @@ function hasCellSelectionEdges(style) {
 }
 
 // src/components/ui/table/features/cell-selection/copyData.ts
+var import_react2 = require("react");
+function isReactNodeIterable(node) {
+  return typeof node === "object" && node !== null && !(0, import_react2.isValidElement)(node) && Symbol.iterator in node;
+}
+function getElementTypeName(type) {
+  if (typeof type === "string") return type;
+  if (typeof type === "function") {
+    const fn = type;
+    return fn.displayName || fn.name || "";
+  }
+  if (typeof type === "object" && type !== null) {
+    const component = type;
+    return component.displayName || component.render?.displayName || component.render?.name || "";
+  }
+  return "";
+}
+function isButtonReactElement(node) {
+  const typeName = getElementTypeName(node.type);
+  if (typeName === "button" || /button/i.test(typeName)) return true;
+  const props = node.props;
+  if (props.role === "button") return true;
+  if (typeName === "input" && props.type === "button") return true;
+  return false;
+}
+function isImageReactElement(node) {
+  const typeName = getElementTypeName(node.type);
+  return typeName === "img" || typeName === "image" || /image/i.test(typeName);
+}
+var IMAGE_URL_PROP_KEYS = ["src", "url", "href", "imageUrl", "srcUrl"];
+function isLikelyUrl(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return false;
+  if (/^(https?:|blob:|data:|\/\/)/i.test(trimmed)) return true;
+  if (trimmed.startsWith("/") && trimmed.includes("/")) return true;
+  return false;
+}
+function pickUrlFromUnknown(value) {
+  if (typeof value === "string") {
+    return isLikelyUrl(value) ? value.trim() : "";
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => pickUrlFromUnknown(item)).filter((item) => item.length > 0).join(", ");
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    for (const key of IMAGE_URL_PROP_KEYS) {
+      const candidate = record[key];
+      if (typeof candidate === "string" && candidate.trim()) {
+        return candidate.trim();
+      }
+    }
+  }
+  return "";
+}
+function imageElementText(node) {
+  const props = node.props;
+  for (const key of IMAGE_URL_PROP_KEYS) {
+    const candidate = props[key];
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate.trim();
+    }
+  }
+  return "";
+}
+function reactNodeContainsImage(node) {
+  if ((0, import_react2.isValidElement)(node)) {
+    if (isImageReactElement(node)) return true;
+    return reactNodeContainsImage(node.props.children);
+  }
+  if (isReactNodeIterable(node)) {
+    for (const child of node) {
+      if (reactNodeContainsImage(child)) return true;
+    }
+  }
+  return false;
+}
+function readImgUrl(img) {
+  const attr = img.getAttribute("src")?.trim() ?? "";
+  if (attr) return attr;
+  if (img instanceof HTMLImageElement) {
+    const current = img.currentSrc?.trim() ?? "";
+    if (current && current !== img.baseURI) return current;
+  }
+  return "";
+}
+function readDomImageUrls(rowIndex, colIndex, root) {
+  const scope = root ?? (typeof document === "undefined" ? null : document);
+  if (!scope) return "";
+  const cells = scope.querySelectorAll(
+    `[data-row-index="${rowIndex}"][data-col-index="${colIndex}"]`
+  );
+  for (const cell of cells) {
+    const urls = Array.from(cell.querySelectorAll("img")).flatMap((img) => {
+      const url = readImgUrl(img);
+      return url ? [url] : [];
+    });
+    if (urls.length > 0) return urls.join(", ");
+  }
+  return "";
+}
+function reactNodeToText(node) {
+  if (node == null || typeof node === "boolean") return "";
+  if (typeof node === "string" || typeof node === "number" || typeof node === "bigint") {
+    return String(node);
+  }
+  if (isReactNodeIterable(node)) {
+    let text = "";
+    for (const child of node) {
+      text += reactNodeToText(child);
+    }
+    return text;
+  }
+  if ((0, import_react2.isValidElement)(node)) {
+    if (isButtonReactElement(node)) return "";
+    const props = node.props;
+    const childText = reactNodeToText(props.children);
+    if (childText) return childText;
+    const fromImage = imageElementText(node);
+    if (fromImage) return fromImage;
+    if (isImageReactElement(node)) return "";
+    if (typeof props.alt === "string" && props.alt) return props.alt;
+    if (typeof props.title === "string" && props.title) return props.title;
+    return "";
+  }
+  return "";
+}
+function sanitizeClipboardCell(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function createCopyRenderRow(rowData, index) {
+  return {
+    id: getOriginalRowId(rowData) || String(index),
+    index,
+    original: rowData,
+    getIsCellDragSelected: () => false
+  };
+}
+function buildVisibleRowLookup(visibleRows) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const row of visibleRows) {
+    lookup.set(row.original, row);
+  }
+  return lookup;
+}
+function resolveCopyColumnId(cell) {
+  if (cell.column.id) return cell.column.id;
+  const columnDef = cell.column.columnDef;
+  if (columnDef.id) return columnDef.id;
+  if (columnDef.accessorKey != null && columnDef.accessorKey !== "") {
+    return String(columnDef.accessorKey);
+  }
+  return "";
+}
+function isPrimitiveCopyValue(value) {
+  return value == null || typeof value !== "object";
+}
+function extractRenderedCopyText(node, value, cellPosition, root) {
+  const rendered = sanitizeClipboardCell(reactNodeToText(node));
+  if (reactNodeContainsImage(node)) {
+    const fromDom = cellPosition != null ? sanitizeClipboardCell(
+      readDomImageUrls(cellPosition.rowIndex, cellPosition.colIndex, root)
+    ) : "";
+    if (fromDom) return fromDom;
+    if (rendered && isLikelyUrl(rendered)) return rendered;
+    return sanitizeClipboardCell(pickUrlFromUnknown(value));
+  }
+  return rendered;
+}
+function formatCopyCellText(rowData, columnDef, columnId, visibleRow, fallbackIndex, sourceCell, cellPosition, options) {
+  const meta = columnDef.meta;
+  const value = sourceCell ? sourceCell.getValue() : readRowColumnValue(rowData, columnDef);
+  const cellRender = meta?.cellRender;
+  if (typeof cellRender === "function") {
+    try {
+      const row = visibleRow ?? createCopyRenderRow(rowData, fallbackIndex);
+      const node = cellRender({
+        value,
+        row,
+        index: row.index,
+        columnId,
+        cellProps: meta?.cellProps,
+        update: () => {
+        }
+      });
+      return extractRenderedCopyText(node, value, cellPosition, options?.root);
+    } catch {
+      return formatCellValue(value);
+    }
+  }
+  if (options?.registry && meta?.kind && isPrimitiveCopyValue(value)) {
+    try {
+      const row = visibleRow ?? createCopyRenderRow(rowData, fallbackIndex);
+      const ctx = {
+        value,
+        row,
+        index: row.index,
+        columnId,
+        cellProps: meta.cellProps,
+        update: () => {
+        }
+      };
+      const renderer = resolveCellRenderer(options.registry, meta.kind, ctx);
+      if (renderer) {
+        const node = renderer.render(ctx);
+        const rendered = extractRenderedCopyText(node, value, cellPosition, options.root);
+        if (rendered) return rendered;
+      }
+    } catch {
+      return formatCellValue(value);
+    }
+  }
+  return formatCellValue(value);
+}
 function formatPrimitive(value) {
   if (value === null || value === void 0) return "";
   if (typeof value === "string") return value;
@@ -951,37 +1249,47 @@ function collectCopyRowEntries(visibleRows, bounds, mode = "visible") {
 function collectCopyRows(visibleRows, bounds, mode = "visible") {
   return collectCopyRowEntries(visibleRows, bounds, mode).map((entry) => entry.row);
 }
-function serializeCopyRowsToTSV(copyRows, visibleRows, bounds, depths) {
+function serializeCopyRowsToTSV(copyRows, visibleRows, bounds, depths, options) {
   if (copyRows.length === 0) return "";
   const { startCol, endCol } = bounds;
   const columnCells = visibleRows[0]?.getVisibleCells().slice(startCol, endCol + 1) ?? [];
   if (columnCells.length === 0) return "";
   const resolvedDepths = depths && depths.length === copyRows.length ? depths : copyRows.map((row) => getRowDepth(row));
   const minDepth = Math.min(...resolvedDepths);
+  const visibleRowByOriginal = buildVisibleRowLookup(visibleRows);
   return copyRows.map((rowData, index) => {
     const relativeDepth = Math.max(0, (resolvedDepths[index] ?? 0) - minDepth);
-    const line = columnCells.map(
-      (cell) => formatCellValue(
-        readRowColumnValue(
-          rowData,
-          cell.column.columnDef
-        )
-      )
-    ).join("	");
+    const visibleRow = visibleRowByOriginal.get(rowData);
+    const matchingCells = visibleRow?.getVisibleCells().slice(startCol, endCol + 1);
+    const line = columnCells.map((templateCell, colOffset) => {
+      const sourceCell = matchingCells?.[colOffset];
+      const column = sourceCell?.column ?? templateCell.column;
+      return formatCopyCellText(
+        rowData,
+        column.columnDef,
+        resolveCopyColumnId(sourceCell ?? templateCell),
+        visibleRow,
+        visibleRow?.index ?? index,
+        sourceCell,
+        visibleRow != null ? { rowIndex: visibleRow.index, colIndex: startCol + colOffset } : void 0,
+        options
+      );
+    }).join("	");
     return `${"	".repeat(relativeDepth)}${line}`;
   }).join("\n");
 }
-function serializeSelectionToTSV(visibleRows, bounds, mode = "visible") {
+function serializeSelectionToTSV(visibleRows, bounds, mode = "visible", options) {
   const entries = collectCopyRowEntries(visibleRows, bounds, mode);
   return serializeCopyRowsToTSV(
     entries.map((entry) => entry.row),
     visibleRows,
     bounds,
-    entries.map((entry) => entry.depth)
+    entries.map((entry) => entry.depth),
+    options
   );
 }
-async function writeSelectionToClipboard(visibleRows, bounds, mode = "visible") {
-  const text = serializeSelectionToTSV(visibleRows, bounds, mode);
+async function writeSelectionToClipboard(visibleRows, bounds, mode = "visible", options) {
+  const text = serializeSelectionToTSV(visibleRows, bounds, mode, options);
   if (!text) return false;
   try {
     await navigator.clipboard.writeText(text);
@@ -1047,90 +1355,6 @@ function hasFillExtension(sourceBounds, fillBounds) {
   return fillBounds.startRow < sourceBounds.startRow || fillBounds.endRow > sourceBounds.endRow || fillBounds.startCol < sourceBounds.startCol || fillBounds.endCol > sourceBounds.endCol;
 }
 
-// src/components/ui/table/features/cell-selection/pasteData.ts
-function countLeadingEmptyCells(cells) {
-  let depth = 0;
-  while (depth < cells.length && cells[depth] === "") {
-    depth += 1;
-  }
-  return depth;
-}
-function looksLikeSubtreeIndentation(leadingEmptyCounts) {
-  if (leadingEmptyCounts.length === 0) return false;
-  const firstDepth = leadingEmptyCounts[0] ?? 0;
-  if (firstDepth !== 0) return false;
-  return leadingEmptyCounts.some((depth) => depth > 0);
-}
-function parseClipboardTSV(text) {
-  return parseClipboardTSVWithDepths(text).values;
-}
-function parseClipboardTSVWithDepths(text) {
-  if (!text) return { values: [], depths: [] };
-  const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-  const withoutTrailing = normalized.replace(/\n+$/, "");
-  if (!withoutTrailing) return { values: [], depths: [] };
-  const rows = withoutTrailing.split("\n").map((line) => line.split("	"));
-  const leadingEmptyCounts = rows.map(countLeadingEmptyCells);
-  const treatAsDepth = looksLikeSubtreeIndentation(leadingEmptyCounts);
-  const values = [];
-  const depths = [];
-  for (let index = 0; index < rows.length; index += 1) {
-    const cells = rows[index] ?? [];
-    const depth = leadingEmptyCounts[index] ?? 0;
-    if (treatAsDepth) {
-      values.push(cells.slice(depth));
-      depths.push(depth);
-    } else {
-      values.push(cells);
-      depths.push(0);
-    }
-  }
-  return { values, depths };
-}
-function resolvePasteColumnIds(rows, startCol, width) {
-  if (width <= 0) return [];
-  const cells = rows[0]?.getVisibleCells() ?? [];
-  const columnIds = [];
-  for (let offset = 0; offset < width; offset += 1) {
-    const cell = cells[startCol + offset];
-    if (!cell) break;
-    columnIds.push(cell.column.id);
-  }
-  return columnIds;
-}
-function buildRowsPastePayload(rows, startRow, startCol, text, mode, endRow = startRow) {
-  const { values, depths } = parseClipboardTSVWithDepths(text);
-  if (values.length === 0) return null;
-  const width = Math.max(...values.map((row) => row.length), 0);
-  if (width === 0) return null;
-  const columnIds = resolvePasteColumnIds(rows, startCol, width);
-  if (columnIds.length === 0) return null;
-  const rowIds = [];
-  for (let offset = 0; offset < values.length; offset += 1) {
-    const row = rows[startRow + offset];
-    if (!row) break;
-    rowIds.push(row.id);
-  }
-  const anchorRow = rows[endRow] ?? rows[startRow];
-  return {
-    mode,
-    startRow,
-    startCol,
-    endRow,
-    rowIds,
-    anchorRowId: anchorRow?.id ?? "",
-    columnIds,
-    values,
-    depths
-  };
-}
-function isEditablePasteTarget(target) {
-  if (!(target instanceof HTMLElement)) return false;
-  const tag = target.tagName;
-  if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
-  return Boolean(target.isContentEditable);
-}
-
 // src/components/ui/table/features/cell-selection/useCellSelection.ts
 function useCellSelection({
   data,
@@ -1142,17 +1366,19 @@ function useCellSelection({
   onDataChange,
   onBatchChange,
   onRowsPaste,
-  onCellNavigate
+  onCellNavigate,
+  cellRendererRegistry,
+  rootRef
 }) {
-  const [dragState, setDragState] = (0, import_react2.useState)(INITIAL_DRAG_STATE);
-  const pendingPasteModeRef = (0, import_react2.useRef)(null);
-  const dragStateRef = (0, import_react2.useRef)(dragState);
-  const onCellNavigateRef = (0, import_react2.useRef)(onCellNavigate);
+  const [dragState, setDragState] = (0, import_react3.useState)(INITIAL_DRAG_STATE);
+  const pendingPasteModeRef = (0, import_react3.useRef)(null);
+  const dragStateRef = (0, import_react3.useRef)(dragState);
+  const onCellNavigateRef = (0, import_react3.useRef)(onCellNavigate);
   dragStateRef.current = dragState;
   onCellNavigateRef.current = onCellNavigate;
   const cellSelectionBounds = getCellSelectionBounds(dragState.start, dragState.end);
   const activeSelectionBounds = enabled ? getActiveSelectionBounds(dragState, cellSelectionBounds) : null;
-  const handleCellMouseDown = (0, import_react2.useCallback)(
+  const handleCellMouseDown = (0, import_react3.useCallback)(
     (rowIndex, colIndex, options) => {
       if (!enabled) return;
       setDragState((prev) => {
@@ -1178,7 +1404,7 @@ function useCellSelection({
     },
     [enabled]
   );
-  const handleCellMouseEnter = (0, import_react2.useCallback)(
+  const handleCellMouseEnter = (0, import_react3.useCallback)(
     (rowIndex, colIndex) => {
       if (!enabled) return;
       setDragState((prev) => {
@@ -1193,7 +1419,7 @@ function useCellSelection({
     },
     [enabled]
   );
-  const handleFillHandleMouseDown = (0, import_react2.useCallback)(
+  const handleFillHandleMouseDown = (0, import_react3.useCallback)(
     (rowIndex, colIndex) => {
       if (!enabled) return;
       setDragState((prev) => {
@@ -1210,12 +1436,20 @@ function useCellSelection({
     },
     [enabled]
   );
-  (0, import_react2.useEffect)(() => {
+  const clearSelection = (0, import_react3.useCallback)(() => {
+    const prev = dragStateRef.current;
+    if (prev.start === null && prev.end === null && !prev.isSelecting && !prev.isFillDragging) {
+      return;
+    }
+    dragStateRef.current = INITIAL_DRAG_STATE;
+    setDragState(INITIAL_DRAG_STATE);
+  }, []);
+  (0, import_react3.useEffect)(() => {
     if (!enabled) {
-      setDragState(INITIAL_DRAG_STATE);
+      clearSelection();
     }
-  }, [enabled]);
-  (0, import_react2.useEffect)(() => {
+  }, [clearSelection, enabled]);
+  (0, import_react3.useEffect)(() => {
     if (!enabled) return;
     const handleKeyDown = (e) => {
       if (e.ctrlKey || e.metaKey || e.altKey) return;
@@ -1262,19 +1496,32 @@ function useCellSelection({
     window.addEventListener("keydown", handleKeyDown);
     return () => window.removeEventListener("keydown", handleKeyDown);
   }, [columnCount, enabled, rows]);
-  const copySelection = (0, import_react2.useCallback)(
+  const copySelection = (0, import_react3.useCallback)(
     async (options) => {
       if (!enabled || !activeSelectionBounds) return false;
       const mode = options?.includeDescendants && enableSubtreeCopy ? "subtree" : "visible";
-      return writeSelectionToClipboard(rows, activeSelectionBounds, mode);
+      return writeSelectionToClipboard(rows, activeSelectionBounds, mode, {
+        registry: cellRendererRegistry,
+        root: rootRef?.current
+      });
     },
-    [activeSelectionBounds, enableSubtreeCopy, enabled, rows]
+    [
+      activeSelectionBounds,
+      cellRendererRegistry,
+      enableSubtreeCopy,
+      enabled,
+      rootRef,
+      rows
+    ]
   );
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     if (!enabled) return;
     const handleKeyDown = (e) => {
       if (!activeSelectionBounds) return;
       if (!(e.ctrlKey || e.metaKey)) return;
+      if (isEditablePasteTarget(e.target) || isEditablePasteTarget(document.activeElement)) {
+        return;
+      }
       const isSubtreeShortcut = enableSubtreeCopy && e.shiftKey && e.key.toLowerCase() === "c";
       const isVisibleCopyShortcut = !e.shiftKey && e.key.toLowerCase() === "c";
       if (!isSubtreeShortcut && !isVisibleCopyShortcut) return;
@@ -1284,7 +1531,7 @@ function useCellSelection({
     window.addEventListener("keydown", handleKeyDown);
     return () => window.removeEventListener("keydown", handleKeyDown);
   }, [activeSelectionBounds, copySelection, enableSubtreeCopy, enabled]);
-  const emitRowsPaste = (0, import_react2.useCallback)(
+  const emitRowsPaste = (0, import_react3.useCallback)(
     (text, mode) => {
       if (!onRowsPaste || !activeSelectionBounds) return false;
       const payload = buildRowsPastePayload(
@@ -1301,7 +1548,7 @@ function useCellSelection({
     },
     [activeSelectionBounds, onRowsPaste, rows]
   );
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     if (!enabled || !onRowsPaste) return;
     const pasteHandledRef = { current: false };
     const ignoreNextPasteRef = { current: false };
@@ -1369,7 +1616,7 @@ function useCellSelection({
     enabled,
     onRowsPaste
   ]);
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     if (!enabled) return;
     const handleMouseUp = () => {
       setDragState((prev) => {
@@ -1415,6 +1662,7 @@ function useCellSelection({
     handleCellMouseDown,
     handleCellMouseEnter,
     handleFillHandleMouseDown,
+    clearSelection,
     copySelection
   };
 }
@@ -1818,7 +2066,7 @@ function collectAncestorKeysToExpand(corpusRow, expandedRows) {
 }
 
 // src/components/ui/table/features/inline-search/useInlineSearch.ts
-var import_react3 = require("react");
+var import_react4 = require("react");
 var EMPTY_MATCH_KEYS = /* @__PURE__ */ new Set();
 function useInlineSearch({
   enabled = false,
@@ -1835,46 +2083,46 @@ function useInlineSearch({
   onNavigateToResult,
   rootRef
 }) {
-  const searchInputId = (0, import_react3.useId)();
-  const searchInputRef = (0, import_react3.useRef)(null);
-  const [internalShowSearch, setInternalShowSearch] = (0, import_react3.useState)(false);
-  const [internalSearchValue, setInternalSearchValue] = (0, import_react3.useState)("");
-  const [internalResults, setInternalResults] = (0, import_react3.useState)(
+  const searchInputId = (0, import_react4.useId)();
+  const searchInputRef = (0, import_react4.useRef)(null);
+  const [internalShowSearch, setInternalShowSearch] = (0, import_react4.useState)(false);
+  const [internalSearchValue, setInternalSearchValue] = (0, import_react4.useState)("");
+  const [internalResults, setInternalResults] = (0, import_react4.useState)(
     []
   );
-  const [searchStatus, setSearchStatus] = (0, import_react3.useState)();
-  const searchStatusRef = (0, import_react3.useRef)(searchStatus);
+  const [searchStatus, setSearchStatus] = (0, import_react4.useState)();
+  const searchStatusRef = (0, import_react4.useRef)(searchStatus);
   searchStatusRef.current = searchStatus;
-  const abortControllerRef = (0, import_react3.useRef)(null);
-  const searchHandleRef = (0, import_react3.useRef)(void 0);
-  const initialStartRowRef = (0, import_react3.useRef)(initialStartRow);
+  const abortControllerRef = (0, import_react4.useRef)(null);
+  const searchHandleRef = (0, import_react4.useRef)(void 0);
+  const initialStartRowRef = (0, import_react4.useRef)(initialStartRow);
   initialStartRowRef.current = initialStartRow;
-  const getCellValueRef = (0, import_react3.useRef)(getCellValue);
+  const getCellValueRef = (0, import_react4.useRef)(getCellValue);
   getCellValueRef.current = getCellValue;
   const showSearch = controlledShowSearch ?? internalShowSearch;
   const searchValue = controlledSearchValue ?? internalSearchValue;
   const searchResults = controlledSearchResults ?? internalResults;
-  const setSearchValue = (0, import_react3.useCallback)(
+  const setSearchValue = (0, import_react4.useCallback)(
     (value) => {
       setInternalSearchValue(value);
       onSearchValueChange?.(value);
     },
     [onSearchValueChange]
   );
-  const cancelSearch = (0, import_react3.useCallback)(() => {
+  const cancelSearch = (0, import_react4.useCallback)(() => {
     if (searchHandleRef.current !== void 0) {
       window.cancelAnimationFrame(searchHandleRef.current);
       searchHandleRef.current = void 0;
     }
     abortControllerRef.current?.abort();
   }, []);
-  const emitResultsChanged = (0, import_react3.useCallback)(
+  const emitResultsChanged = (0, import_react4.useCallback)(
     (results, navIndex) => {
       onSearchResultsChanged?.(results, navIndex);
     },
     [onSearchResultsChanged]
   );
-  const navigateToIndex = (0, import_react3.useCallback)(
+  const navigateToIndex = (0, import_react4.useCallback)(
     (results, navIndex) => {
       if (onSearchResultsChanged) return;
       if (navIndex < 0 || navIndex >= results.length) return;
@@ -1884,7 +2132,7 @@ function useInlineSearch({
     },
     [onNavigateToResult, onSearchResultsChanged]
   );
-  const beginSearch = (0, import_react3.useCallback)(
+  const beginSearch = (0, import_react4.useCallback)(
     (query) => {
       if (controlledSearchResults !== void 0) return;
       const totalRows = rowCount;
@@ -1956,12 +2204,12 @@ function useInlineSearch({
       rowCount
     ]
   );
-  const openSearch = (0, import_react3.useCallback)(() => {
+  const openSearch = (0, import_react4.useCallback)(() => {
     if (controlledShowSearch === void 0) {
       setInternalShowSearch(true);
     }
   }, [controlledShowSearch]);
-  const closeSearch = (0, import_react3.useCallback)(() => {
+  const closeSearch = (0, import_react4.useCallback)(() => {
     if (controlledShowSearch === void 0) {
       setInternalShowSearch(false);
     }
@@ -1976,7 +2224,7 @@ function useInlineSearch({
     emitResultsChanged,
     onSearchClose
   ]);
-  const goToNext = (0, import_react3.useCallback)(() => {
+  const goToNext = (0, import_react4.useCallback)(() => {
     if (!searchStatus || searchStatus.results === 0) return;
     const newIndex = nextSearchIndex(
       searchStatus.selectedIndex,
@@ -1986,7 +2234,7 @@ function useInlineSearch({
     emitResultsChanged(searchResults, newIndex);
     navigateToIndex(searchResults, newIndex);
   }, [emitResultsChanged, navigateToIndex, searchResults, searchStatus]);
-  const goToPrevious = (0, import_react3.useCallback)(() => {
+  const goToPrevious = (0, import_react4.useCallback)(() => {
     if (!searchStatus || searchStatus.results === 0) return;
     const newIndex = previousSearchIndex(
       searchStatus.selectedIndex,
@@ -1996,7 +2244,7 @@ function useInlineSearch({
     emitResultsChanged(searchResults, newIndex);
     navigateToIndex(searchResults, newIndex);
   }, [emitResultsChanged, navigateToIndex, searchResults, searchStatus]);
-  (0, import_react3.useEffect)(() => {
+  (0, import_react4.useEffect)(() => {
     if (controlledSearchResults === void 0) return;
     if (controlledSearchResults.length > 0) {
       setSearchStatus((current) => ({
@@ -2008,7 +2256,7 @@ function useInlineSearch({
       setSearchStatus(void 0);
     }
   }, [controlledSearchResults, rowCount]);
-  (0, import_react3.useEffect)(() => {
+  (0, import_react4.useEffect)(() => {
     if (!enabled) return;
     setSearchStatus(void 0);
     setInternalResults([]);
@@ -2021,7 +2269,7 @@ function useInlineSearch({
       cancelSearch();
     }
   }, [enabled, showSearch]);
-  (0, import_react3.useEffect)(() => {
+  (0, import_react4.useEffect)(() => {
     if (!enabled || !showSearch) return;
     if (controlledSearchResults !== void 0) return;
     if (searchValue.trim() === "") {
@@ -2041,7 +2289,7 @@ function useInlineSearch({
     searchValue,
     showSearch
   ]);
-  (0, import_react3.useEffect)(() => {
+  (0, import_react4.useEffect)(() => {
     if (!enabled) return;
     const handleKeyDown = (event) => {
       if (!(event.ctrlKey || event.metaKey)) return;
@@ -2068,12 +2316,12 @@ function useInlineSearch({
     window.addEventListener("keydown", handleKeyDown, true);
     return () => window.removeEventListener("keydown", handleKeyDown, true);
   }, [controlledShowSearch, enabled, rootRef, showSearch]);
-  (0, import_react3.useEffect)(() => () => cancelSearch(), [cancelSearch]);
-  const searchMatchKeys = (0, import_react3.useMemo)(
+  (0, import_react4.useEffect)(() => () => cancelSearch(), [cancelSearch]);
+  const searchMatchKeys = (0, import_react4.useMemo)(
     () => buildSearchMatchKeys(searchResults),
     [searchResults]
   );
-  const activeMatch = (0, import_react3.useMemo)(() => {
+  const activeMatch = (0, import_react4.useMemo)(() => {
     if (!searchStatus || searchStatus.selectedIndex < 0) return null;
     return searchResults[searchStatus.selectedIndex] ?? null;
   }, [searchResults, searchStatus]);
@@ -2116,7 +2364,7 @@ function useInlineSearch({
 }
 
 // src/components/ui/table/features/row-expand/row-expand.ts
-var import_react4 = require("react");
+var import_react5 = require("react");
 function getFieldValue(row, key) {
   return row[key];
 }
@@ -2146,12 +2394,12 @@ var useConvertTreeData = ({
   expandedRows,
   onExpandedRowsChange
 }) => {
-  const onExpandedRowsChangeRef = (0, import_react4.useRef)(onExpandedRowsChange);
-  const hasInitializedRef = (0, import_react4.useRef)(false);
-  (0, import_react4.useEffect)(() => {
+  const onExpandedRowsChangeRef = (0, import_react5.useRef)(onExpandedRowsChange);
+  const hasInitializedRef = (0, import_react5.useRef)(false);
+  (0, import_react5.useEffect)(() => {
     onExpandedRowsChangeRef.current = onExpandedRowsChange;
   }, [onExpandedRowsChange]);
-  (0, import_react4.useEffect)(() => {
+  (0, import_react5.useEffect)(() => {
     if (!data || data.length === 0) {
       hasInitializedRef.current = false;
       return;
@@ -2161,7 +2409,7 @@ var useConvertTreeData = ({
     onExpandedRowsChangeRef.current?.(new Set(ids));
     hasInitializedRef.current = true;
   }, [enabled, data, toggleField]);
-  const processedData = (0, import_react4.useMemo)(() => {
+  const processedData = (0, import_react5.useMemo)(() => {
     if (!enabled || !data || data.length === 0) return [];
     const flattenedData = [];
     const flattenItems = (items) => {
@@ -2225,7 +2473,7 @@ var useConvertTreeData = ({
     });
     return rootItems;
   }, [enabled, data, toggleField, childField, flattenField]);
-  const flattenTree = (0, import_react4.useMemo)(() => {
+  const flattenTree = (0, import_react5.useMemo)(() => {
     if (!enabled) return [];
     const flatten = (nodes, result = [], level = 0) => {
       nodes.forEach((node, index) => {
@@ -2275,7 +2523,7 @@ var useConvertTreeData = ({
     preventExpand,
     expandedRows
   ]);
-  const sortedData = (0, import_react4.useMemo)(() => {
+  const sortedData = (0, import_react5.useMemo)(() => {
     if (!enabled) {
       return data ?? [];
     }
@@ -2502,7 +2750,7 @@ function useGlideTable(options) {
     searchResults,
     onSearchResultsChanged
   } = options;
-  const labels = (0, import_react5.useMemo)(() => {
+  const labels = (0, import_react6.useMemo)(() => {
     const resolved = resolveDataTableLabels(labelsProp);
     return {
       ...resolved,
@@ -2513,17 +2761,21 @@ function useGlideTable(options) {
   }, [labelsProp, emptyText, loadingText, selectionLabel]);
   const enableExpand = Boolean(toggleField);
   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)(
+  const [internalRowSelection, setInternalRowSelection] = (0, import_react6.useState)({});
+  const [internalColumnSizing, setInternalColumnSizing] = (0, import_react6.useState)({});
+  const [internalColumnOrder, setInternalColumnOrder] = (0, import_react6.useState)([]);
+  const [internalExpandedRows, setInternalExpandedRows] = (0, import_react6.useState)(
     () => /* @__PURE__ */ new Set()
   );
-  const [hoveredRowIndex, setHoveredRowIndex] = (0, import_react5.useState)(null);
-  const scrollRef = (0, import_react5.useRef)(null);
-  const rootRef = (0, import_react5.useRef)(null);
+  const [hoveredRowIndex, setHoveredRowIndex] = (0, import_react6.useState)(null);
+  const scrollRef = (0, import_react6.useRef)(null);
+  const rootRef = (0, import_react6.useRef)(null);
+  const cellRendererRegistry = (0, import_react6.useMemo)(
+    () => createCellRendererRegistry(cellRenderers),
+    [cellRenderers]
+  );
   const shouldVirtualize = enableVirtualization && !enableRowSpan;
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     if (enableVirtualization && enableRowSpan) {
       console.warn(
         "[useGlideTable] enableRowSpan is on; virtualization is disabled to preserve cell merges."
@@ -2537,11 +2789,11 @@ function useGlideTable(options) {
   );
   const columnSizing = controlledColumnSizing ?? internalColumnSizing;
   const columnOrder = controlledColumnOrder ?? internalColumnOrder;
-  const tableColumns = (0, import_react5.useMemo)(() => {
+  const tableColumns = (0, import_react6.useMemo)(() => {
     if (!enableColumnReorder) return columns;
     return applyLeafColumnOrder(columns, columnOrder);
   }, [columnOrder, columns, enableColumnReorder]);
-  const setColumnOrder = (0, import_react5.useCallback)(
+  const setColumnOrder = (0, import_react6.useCallback)(
     (next) => {
       if (onColumnOrderChange) {
         onColumnOrderChange(next);
@@ -2552,7 +2804,7 @@ function useGlideTable(options) {
     [onColumnOrderChange]
   );
   const expandedRows = controlledExpandedRows ?? internalExpandedRows;
-  const handleExpandedRowsChange = (0, import_react5.useCallback)(
+  const handleExpandedRowsChange = (0, import_react6.useCallback)(
     (next) => {
       if (onExpandedRowsChange) {
         onExpandedRowsChange(next);
@@ -2613,13 +2865,13 @@ function useGlideTable(options) {
     getCoreRowModel: (0, import_react_table.getCoreRowModel)(),
     getRowId: getRowId ? (originalRow, index) => getRowId(originalRow, index) : (_originalRow, index) => String(index)
   });
-  const rowSpanColumnKeys = (0, import_react5.useMemo)(() => {
+  const rowSpanColumnKeys = (0, import_react6.useMemo)(() => {
     if (!enableRowSpan) return [];
     return collectRowSpanColumns(columns);
   }, [enableRowSpan, columns]);
   const primaryRowSpanKey = rowSpanColumnKeys[0]?.rowSpanKey;
   const primaryRowSpanColumnId = rowSpanColumnKeys[0]?.columnId;
-  const columnRowSpanMap = (0, import_react5.useMemo)(
+  const columnRowSpanMap = (0, import_react6.useMemo)(
     () => buildColumnRowSpanMap(tableData, rowSpanColumnKeys),
     [tableData, rowSpanColumnKeys]
   );
@@ -2628,7 +2880,7 @@ function useGlideTable(options) {
   const rows = table.getRowModel().rows;
   const columnCount = table.getAllLeafColumns().length || 1;
   const visibleLeafColumns = table.getVisibleLeafColumns();
-  const columnFreezeOffsets = (0, import_react5.useMemo)(() => {
+  const columnFreezeOffsets = (0, import_react6.useMemo)(() => {
     if (!enableColumnFreeze) return EMPTY_COLUMN_FREEZE_OFFSETS;
     return buildColumnFreezeOffsets(
       visibleLeafColumns.map((column) => ({
@@ -2648,14 +2900,14 @@ function useGlideTable(options) {
   const totalSize = rowVirtualizer.getTotalSize();
   const paddingTop = virtualRows.length > 0 ? virtualRows[0]?.start ?? 0 : 0;
   const paddingBottom = virtualRows.length > 0 ? totalSize - (virtualRows[virtualRows.length - 1]?.end ?? 0) : 0;
-  const selectedRowIndices = (0, import_react5.useMemo)(() => {
+  const selectedRowIndices = (0, import_react6.useMemo)(() => {
     const indices = /* @__PURE__ */ new Set();
     for (const selectedRow of selectedRows) {
       indices.add(selectedRow.index);
     }
     return indices;
   }, [selectedRows]);
-  const scrollCellIntoView = (0, import_react5.useCallback)(
+  const scrollCellIntoView = (0, import_react6.useCallback)(
     (rowIndex, colIndex, options2) => {
       const align = options2?.align ?? "nearest";
       const blockAlign = align === "center" ? "center" : "nearest";
@@ -2682,7 +2934,7 @@ function useGlideTable(options) {
     },
     [rowVirtualizer, shouldVirtualize]
   );
-  const handleCellNavigate = (0, import_react5.useCallback)(
+  const handleCellNavigate = (0, import_react6.useCallback)(
     (position) => {
       scrollCellIntoView(position.row, position.col, { align: "nearest" });
     },
@@ -2694,6 +2946,7 @@ function useGlideTable(options) {
     handleCellMouseDown,
     handleCellMouseEnter,
     handleFillHandleMouseDown,
+    clearSelection: clearCellSelection,
     copySelection
   } = useCellSelection({
     data: tableData,
@@ -2705,8 +2958,46 @@ function useGlideTable(options) {
     onDataChange,
     onBatchChange,
     onRowsPaste,
-    onCellNavigate: handleCellNavigate
+    onCellNavigate: handleCellNavigate,
+    cellRendererRegistry,
+    rootRef
   });
+  const clearRowSelection = (0, import_react6.useCallback)(() => {
+    if (rowSelectionMode === "none") return;
+    const hasSelection = Object.values(rowSelection).some(Boolean);
+    if (!hasSelection) return;
+    if (onRowSelectionChange) {
+      onRowSelectionChange(() => ({}));
+      return;
+    }
+    setInternalRowSelection({});
+  }, [onRowSelectionChange, rowSelection, rowSelectionMode]);
+  (0, import_react6.useEffect)(() => {
+    const clearAllSelections = () => {
+      clearCellSelection();
+      clearRowSelection();
+    };
+    const handleKeyDown = (event) => {
+      if (event.key !== "Escape") return;
+      if (event.defaultPrevented) return;
+      if (isEditablePasteTarget(event.target) || isEditablePasteTarget(document.activeElement)) {
+        return;
+      }
+      clearAllSelections();
+    };
+    const handleMouseDown = (event) => {
+      const root = rootRef.current;
+      if (!root) return;
+      if (event.target instanceof Node && root.contains(event.target)) return;
+      clearAllSelections();
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    document.addEventListener("mousedown", handleMouseDown);
+    return () => {
+      window.removeEventListener("keydown", handleKeyDown);
+      document.removeEventListener("mousedown", handleMouseDown);
+    };
+  }, [clearCellSelection, clearRowSelection]);
   const {
     editingCell,
     draftValue,
@@ -2715,11 +3006,7 @@ function useGlideTable(options) {
     commitEdit,
     cancelEdit
   } = useCellEdit({ data: tableData, rows, onDataChange, onCellChange });
-  const cellRendererRegistry = (0, import_react5.useMemo)(
-    () => createCellRendererRegistry(cellRenderers),
-    [cellRenderers]
-  );
-  const commitRenderedCellValue = (0, import_react5.useCallback)(
+  const commitRenderedCellValue = (0, import_react6.useCallback)(
     (rowId, columnId, value) => commitCellValue({
       data: tableData,
       rows,
@@ -2731,11 +3018,11 @@ function useGlideTable(options) {
     }),
     [onCellChange, onDataChange, rows, tableData]
   );
-  const getCellContext = (0, import_react5.useCallback)(
+  const getCellContext = (0, import_react6.useCallback)(
     (cell) => withCellUpdate(cell.getContext(), commitRenderedCellValue),
     [commitRenderedCellValue]
   );
-  const handleCellMouseDownWithCommit = (0, import_react5.useCallback)(
+  const handleCellMouseDownWithCommit = (0, import_react6.useCallback)(
     (rowIndex, colIndex, options2) => {
       const isSameEditingCell = editingCell?.rowIndex === rowIndex && editingCell?.colIndex === colIndex;
       if (editingCell && !isSameEditingCell && !commitEdit()) {
@@ -2745,7 +3032,7 @@ function useGlideTable(options) {
     },
     [commitEdit, editingCell, handleCellMouseDown]
   );
-  const navigateToSearchResult = (0, import_react5.useCallback)(
+  const navigateToSearchResult = (0, import_react6.useCallback)(
     (item) => {
       const [colIndex, rowIndex] = item;
       handleCellMouseDownWithCommit(rowIndex, colIndex);
@@ -2753,7 +3040,7 @@ function useGlideTable(options) {
     },
     [handleCellMouseDownWithCommit, scrollCellIntoView]
   );
-  const resolveSearchRowId = (0, import_react5.useCallback)(
+  const resolveSearchRowId = (0, import_react6.useCallback)(
     (row, index) => {
       if (getRowId) return getRowId(row, index);
       if (enableExpand) {
@@ -2777,7 +3064,7 @@ function useGlideTable(options) {
     },
     [enableExpand, getRowId, toggleField]
   );
-  const searchCorpus = (0, import_react5.useMemo)(() => {
+  const searchCorpus = (0, import_react6.useMemo)(() => {
     if (!enableInlineSearch) return [];
     if (enableExpand && toggleField) {
       return buildTreeSearchCorpus(tableData, {
@@ -2793,16 +3080,16 @@ function useGlideTable(options) {
     tableData,
     toggleField
   ]);
-  const searchCorpusRef = (0, import_react5.useRef)(searchCorpus);
+  const searchCorpusRef = (0, import_react6.useRef)(searchCorpus);
   searchCorpusRef.current = searchCorpus;
-  const visibleRowIndexById = (0, import_react5.useMemo)(() => {
+  const visibleRowIndexById = (0, import_react6.useMemo)(() => {
     const map = /* @__PURE__ */ new Map();
     for (const row of rows) {
       map.set(resolveSearchRowId(row.original, row.index), row.index);
     }
     return map;
   }, [resolveSearchRowId, rows]);
-  const getSearchCellValue = (0, import_react5.useCallback)(
+  const getSearchCellValue = (0, import_react6.useCallback)(
     (rowIndex, colIndex) => {
       const corpusRow = searchCorpusRef.current[rowIndex];
       const column = visibleLeafColumns[colIndex];
@@ -2825,14 +3112,14 @@ function useGlideTable(options) {
     },
     [rows, visibleLeafColumns, visibleRowIndexById]
   );
-  const pendingSearchNavRef = (0, import_react5.useRef)(null);
-  const focusSearchResult = (0, import_react5.useCallback)(
+  const pendingSearchNavRef = (0, import_react6.useRef)(null);
+  const focusSearchResult = (0, import_react6.useCallback)(
     (colIndex, visibleRowIndex) => {
       navigateToSearchResult([colIndex, visibleRowIndex]);
     },
     [navigateToSearchResult]
   );
-  const navigateToCorpusSearchResult = (0, import_react5.useCallback)(
+  const navigateToCorpusSearchResult = (0, import_react6.useCallback)(
     (item) => {
       const [colIndex, corpusRowIndex] = item;
       const corpusRow = searchCorpusRef.current[corpusRowIndex];
@@ -2865,7 +3152,7 @@ function useGlideTable(options) {
       visibleRowIndexById
     ]
   );
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     const pending = pendingSearchNavRef.current;
     if (!pending) return;
     const visibleRowIndex = visibleRowIndexById.get(pending.rowId);
@@ -2889,7 +3176,7 @@ function useGlideTable(options) {
     onNavigateToResult: navigateToCorpusSearchResult,
     rootRef
   });
-  const visibleSearchMatchKeys = (0, import_react5.useMemo)(() => {
+  const visibleSearchMatchKeys = (0, import_react6.useMemo)(() => {
     if (!enableInlineSearch) return EMPTY_SEARCH_MATCH_KEYS;
     return mapSearchResultsToVisibleKeys(
       inlineSearch.searchResults,
@@ -2902,7 +3189,7 @@ function useGlideTable(options) {
     searchCorpus,
     visibleRowIndexById
   ]);
-  const visibleActiveMatch = (0, import_react5.useMemo)(() => {
+  const visibleActiveMatch = (0, import_react6.useMemo)(() => {
     if (!enableInlineSearch || !inlineSearch.activeMatch) return null;
     return mapSearchResultToVisibleItem(
       inlineSearch.activeMatch,
@@ -2915,13 +3202,13 @@ function useGlideTable(options) {
     searchCorpus,
     visibleRowIndexById
   ]);
-  const clearHover = (0, import_react5.useCallback)(() => {
+  const clearHover = (0, import_react6.useCallback)(() => {
     setHoveredRowIndex(null);
   }, []);
-  const handleRowHover = (0, import_react5.useCallback)((rowIndex, _rowData) => {
+  const handleRowHover = (0, import_react6.useCallback)((rowIndex, _rowData) => {
     setHoveredRowIndex(rowIndex);
   }, []);
-  const handleToggleSelect = (0, import_react5.useCallback)(
+  const handleToggleSelect = (0, import_react6.useCallback)(
     (row) => {
       if (!row.getCanSelect()) return;
       if (preserveRowSelection && row.getIsSelected()) {
@@ -2931,14 +3218,14 @@ function useGlideTable(options) {
     },
     [preserveRowSelection]
   );
-  const handleToggleExpand = (0, import_react5.useCallback)(
+  const handleToggleExpand = (0, import_react6.useCallback)(
     (rowKey) => {
       if (preventExpand) return;
       handleExpandedRowsChange(toggleExpandedRowId(rowKey, expandedRows));
     },
     [preventExpand, handleExpandedRowsChange, expandedRows]
   );
-  const rowContextValue = (0, import_react5.useMemo)(() => {
+  const rowContextValue = (0, import_react6.useMemo)(() => {
     return {
       rowSpan: {
         enableRowSpan,
@@ -3037,12 +3324,12 @@ function useGlideTable(options) {
     visibleSearchMatchKeys,
     visibleActiveMatch
   ]);
-  const copySelectionRef = (0, import_react5.useRef)(copySelection);
-  (0, import_react5.useEffect)(() => {
+  const copySelectionRef = (0, import_react6.useRef)(copySelection);
+  (0, import_react6.useEffect)(() => {
     copySelectionRef.current = copySelection;
   }, [copySelection]);
-  const stableCopySelection = (0, import_react5.useCallback)((options2) => copySelectionRef.current(options2), []);
-  (0, import_react5.useEffect)(() => {
+  const stableCopySelection = (0, import_react6.useCallback)((options2) => copySelectionRef.current(options2), []);
+  (0, import_react6.useEffect)(() => {
     onCopyActionsReady?.({ copySelection: stableCopySelection });
   }, [onCopyActionsReady, stableCopySelection]);
   return {
@@ -3091,16 +3378,18 @@ function useGlideTable(options) {
 }
 
 // src/components/ui/table/features/cell-render/ResolvedTableCell.tsx
-var import_react7 = require("react");
+var import_react8 = require("react");
 
 // src/components/ui/table/DataTableContext.tsx
-var import_react6 = require("react");
+var import_react7 = require("react");
 var import_jsx_runtime2 = require("react/jsx-runtime");
-var DataTableContext = (0, import_react6.createContext)(null);
+var DataTableContext = (0, import_react7.createContext)(null);
 function useDataTableRowContext() {
-  const context = (0, import_react6.use)(DataTableContext);
+  const context = (0, import_react7.use)(DataTableContext);
   if (!context) {
-    throw new Error("useDataTableRowContext must be used within a DataTableContextProvider");
+    throw new Error(
+      "useDataTableRowContext must be used within a DataTableContextProvider"
+    );
   }
   return context;
 }
@@ -3120,7 +3409,7 @@ function ResolvedTableCell({
   const meta = column.columnDef.meta;
   const value = getValue();
   const columnId = column.id;
-  const update = (0, import_react7.useCallback)(
+  const update = (0, import_react8.useCallback)(
     (next) => {
       cellRender.commitValue(row.id, columnId, next);
     },
@@ -3145,8 +3434,105 @@ function ResolvedTableCell({
 }
 
 // src/components/ui/table/features/column-resize/columnResize.ts
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function floorOf(column) {
+  return column.minWidth ?? 0;
+}
+function ceilOf(column) {
+  return column.maxWidth ?? Number.POSITIVE_INFINITY;
+}
+function preferOf(column) {
+  const floor = floorOf(column);
+  const ceil = ceilOf(column);
+  const preferred = column.maxWidth ?? column.minWidth ?? 0;
+  return clamp(preferred, floor, Number.isFinite(ceil) ? ceil : preferred);
+}
+function resolveColumnLayoutWidths(containerWidth, columns) {
+  const widths = /* @__PURE__ */ new Map();
+  const fixed = [];
+  const bounded = [];
+  let flexCount = 0;
+  for (const column of columns) {
+    if (column.width != null) {
+      fixed.push(column);
+    } else if (column.minWidth != null || column.maxWidth != null) {
+      bounded.push(column);
+    } else {
+      flexCount += 1;
+    }
+  }
+  let used = 0;
+  for (const column of fixed) {
+    let size = column.width;
+    if (column.minWidth != null) size = Math.max(size, column.minWidth);
+    if (column.maxWidth != null) size = Math.min(size, column.maxWidth);
+    widths.set(column.id, size);
+    used += size;
+  }
+  if (bounded.length === 0) {
+    return widths;
+  }
+  const boundedSizes = /* @__PURE__ */ new Map();
+  let preferredSum = 0;
+  let floorSum = 0;
+  for (const column of bounded) {
+    const preferred = preferOf(column);
+    boundedSizes.set(column.id, preferred);
+    preferredSum += preferred;
+    floorSum += floorOf(column);
+  }
+  if (containerWidth > 0) {
+    const remaining = Math.max(0, containerWidth - used);
+    if (remaining >= preferredSum) {
+    } else if (remaining >= floorSum) {
+      let deficit = preferredSum - remaining;
+      const open = bounded.map((column) => ({
+        id: column.id,
+        current: boundedSizes.get(column.id),
+        floor: floorOf(column)
+      }));
+      while (deficit >= 1) {
+        const shrinkable = open.filter((entry) => entry.current > entry.floor);
+        if (shrinkable.length === 0) break;
+        const portion = Math.floor(deficit / shrinkable.length);
+        const rem = deficit % shrinkable.length;
+        let consumed = 0;
+        for (let index = 0; index < shrinkable.length; index += 1) {
+          const entry = shrinkable[index];
+          const reduce = Math.min(
+            entry.current - entry.floor,
+            portion + (index < rem ? 1 : 0)
+          );
+          entry.current -= reduce;
+          consumed += reduce;
+        }
+        if (consumed === 0) break;
+        deficit -= consumed;
+      }
+      for (const entry of open) {
+        boundedSizes.set(entry.id, entry.current);
+      }
+    } else {
+      for (const column of bounded) {
+        boundedSizes.set(column.id, floorOf(column));
+      }
+    }
+  }
+  for (const [id, size] of boundedSizes) {
+    widths.set(id, Math.round(size));
+  }
+  return widths;
+}
 function getColumnSizeStyle(size, options) {
-  const { force = false, lockMax = false, minWidth, maxWidth } = options ?? {};
+  const {
+    force = false,
+    lockMax = false,
+    minWidth,
+    maxWidth,
+    layoutWidth
+  } = options ?? {};
   if (lockMax) {
     return {
       width: size,
@@ -3154,14 +3540,27 @@ function getColumnSizeStyle(size, options) {
       maxWidth: size
     };
   }
+  if (layoutWidth != null) {
+    return {
+      width: layoutWidth,
+      minWidth: layoutWidth,
+      maxWidth: layoutWidth
+    };
+  }
+  const resolvedSize = size;
   const hasExplicitSize = force || size !== DATA_TABLE_COLUMN_SIZE;
   if (!hasExplicitSize && minWidth == null && maxWidth == null) {
     return void 0;
   }
   const style = {};
   if (hasExplicitSize) {
-    style.width = size;
-    style.minWidth = minWidth ?? size;
+    const used = minWidth != null || maxWidth != null ? clamp(
+      resolvedSize,
+      minWidth ?? Number.NEGATIVE_INFINITY,
+      maxWidth ?? Number.POSITIVE_INFINITY
+    ) : resolvedSize;
+    style.width = used;
+    style.minWidth = minWidth ?? used;
   } else if (minWidth != null) {
     style.minWidth = minWidth;
   }
@@ -3172,7 +3571,7 @@ function getColumnSizeStyle(size, options) {
 }
 
 // src/components/ui/table/features/column-reorder/useColumnReorder.ts
-var import_react8 = require("react");
+var import_react9 = require("react");
 function hitTestReorderHeader(table, clientX, clientY) {
   const headers = Array.from(
     table.querySelectorAll(
@@ -3220,19 +3619,19 @@ function readTargetIds(table, columnId) {
 }
 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)(
+  const sessionRef = (0, import_react9.useRef)(null);
+  const columnOrderRef = (0, import_react9.useRef)(columnOrder);
+  const onColumnOrderChangeRef = (0, import_react9.useRef)(onColumnOrderChange);
+  const [draggingColumnId, setDraggingColumnId] = (0, import_react9.useState)(null);
+  const [dropTarget, setDropTarget] = (0, import_react9.useState)(
     null
   );
-  const dropTargetRef = (0, import_react8.useRef)(dropTarget);
-  const previousUserSelectRef = (0, import_react8.useRef)(null);
+  const dropTargetRef = (0, import_react9.useRef)(dropTarget);
+  const previousUserSelectRef = (0, import_react9.useRef)(null);
   columnOrderRef.current = columnOrder;
   onColumnOrderChangeRef.current = onColumnOrderChange;
   dropTargetRef.current = dropTarget;
-  const resetDrag = (0, import_react8.useCallback)(() => {
+  const resetDrag = (0, import_react9.useCallback)(() => {
     sessionRef.current = null;
     setDraggingColumnId(null);
     setDropTarget(null);
@@ -3248,15 +3647,15 @@ function useColumnReorder(options) {
     }
     document.body.style.removeProperty("user-select");
   }, []);
-  (0, import_react8.useEffect)(() => {
+  (0, import_react9.useEffect)(() => {
     if (!enabled) resetDrag();
   }, [enabled, resetDrag]);
-  (0, import_react8.useEffect)(() => {
+  (0, import_react9.useEffect)(() => {
     return () => {
       resetDrag();
     };
   }, [resetDrag]);
-  const onHeaderPointerDown = (0, import_react8.useCallback)(
+  const onHeaderPointerDown = (0, import_react9.useCallback)(
     (event, meta) => {
       if (!enabled || !meta.canDrag) return;
       if (event.button !== 0) return;
@@ -3279,7 +3678,7 @@ function useColumnReorder(options) {
     },
     [enabled]
   );
-  (0, import_react8.useEffect)(() => {
+  (0, import_react9.useEffect)(() => {
     if (!enabled) return;
     const onPointerMove = (event) => {
       const session = sessionRef.current;
@@ -3381,11 +3780,11 @@ function useColumnReorder(options) {
 
 // src/components/ui/table/components/DataTable/DataTable.tsx
 var import_react_table3 = require("@tanstack/react-table");
-var import_react10 = require("react");
+var import_react11 = require("react");
 
 // src/components/ui/table/components/DataTable/DataTableRow.tsx
 var import_react_table2 = require("@tanstack/react-table");
-var import_react9 = require("react");
+var import_react10 = require("react");
 
 // src/components/ui/table/components/icons.tsx
 var import_jsx_runtime3 = require("react/jsx-runtime");
@@ -3547,6 +3946,12 @@ function isInteractiveMouseTarget(target) {
   ].join(",");
   return target.closest(interactiveSelector) !== null;
 }
+function blurActiveElementOutside(container) {
+  const active = document.activeElement;
+  if (!(active instanceof HTMLElement) || active === document.body) return;
+  if (container instanceof Node && container.contains(active)) return;
+  active.blur();
+}
 function resolveExpandCellIndex(cells, toggleField) {
   if (!toggleField) return 0;
   const matchedIndex = cells.findIndex(
@@ -3579,7 +3984,7 @@ function DataTableRow({
     columnFreeze,
     inlineSearch
   } = useDataTableRowContext();
-  const { enableColumnResize } = columnResize;
+  const { enableColumnResize, layoutWidths } = columnResize;
   const { enableColumnFreeze, offsets: freezeOffsets } = columnFreeze;
   const {
     enabled: enableInlineSearch,
@@ -3683,9 +4088,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_react9.useRef)(null);
+  const editInputRef = (0, import_react10.useRef)(null);
   const isRowEditing = editingCell?.rowIndex === rowIndex;
-  (0, import_react9.useEffect)(() => {
+  (0, import_react10.useEffect)(() => {
     if (!isRowEditing) return;
     editInputRef.current?.focus();
     editInputRef.current?.select();
@@ -3774,7 +4179,8 @@ function DataTableRow({
           force: enableColumnResize,
           lockMax: enableColumnResize,
           minWidth: meta?.minWidth,
-          maxWidth: meta?.maxWidth
+          maxWidth: meta?.maxWidth,
+          layoutWidth: layoutWidths?.get(columnId)
         });
         const freezeOffset = enableColumnFreeze ? freezeOffsets.get(columnId) : void 0;
         const freezeStyle = getColumnFreezeStyle(freezeOffset);
@@ -3814,6 +4220,7 @@ function DataTableRow({
               if (!enableCellSelection) return;
               if (isInteractiveMouseTarget(event.target)) return;
               event.preventDefault();
+              blurActiveElementOutside(event.currentTarget);
               onCellMouseDown(
                 resolveCellRowIndex(event.clientY, event.currentTarget),
                 cellIndex,
@@ -3977,6 +4384,7 @@ function DataTableRow({
                   onMouseDown: (event) => {
                     event.stopPropagation();
                     event.preventDefault();
+                    blurActiveElementOutside(event.currentTarget);
                     onFillHandleMouseDown(rowIndex, cellIndex);
                   }
                 }
@@ -4306,17 +4714,74 @@ function DataTable({
   const RowSlot = slots?.Row ?? DataTableRow;
   const PendingSlot = slots?.Pending ?? DefaultPending;
   const EmptySlot = slots?.Empty ?? DefaultEmpty;
-  const freezeOffsets = rowContextValue.columnFreeze.offsets;
   const headerGroups = getMergedHeaderGroups(table.getHeaderGroups());
   const leafColumnIds = table.getVisibleLeafColumns().map((column) => column.id);
+  const columnLayoutMetaSignature = table.getVisibleLeafColumns().map((column) => {
+    const meta = column.columnDef.meta;
+    return `${column.id}:${meta?.width ?? ""}:${meta?.minWidth ?? ""}:${meta?.maxWidth ?? ""}`;
+  }).join("|");
   const { isReordering, draggingColumnId, dropTarget, onHeaderPointerDown } = useColumnReorder({
     enabled: enableColumnReorder,
     columnOrder: leafColumnIds,
     onColumnOrderChange: setColumnOrder
   });
-  const contextValue = (0, import_react10.useMemo)(
-    () => ({ ...rowContextValue, classNames }),
-    [rowContextValue, classNames]
+  const [containerWidth, setContainerWidth] = (0, import_react11.useState)(0);
+  (0, import_react11.useEffect)(() => {
+    if (enableColumnResize || isPending) return;
+    const element = scrollRef.current;
+    if (!element) return;
+    const updateWidth = () => {
+      setContainerWidth(Math.floor(element.clientWidth));
+    };
+    updateWidth();
+    if (typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver(() => {
+      updateWidth();
+    });
+    observer.observe(element);
+    return () => observer.disconnect();
+  }, [enableColumnResize, isPending, scrollRef, rows.length, leafColumnIds.join("|")]);
+  const layoutWidths = (0, import_react11.useMemo)(() => {
+    if (enableColumnResize) return void 0;
+    const columns = table.getVisibleLeafColumns().map((column) => ({
+      id: column.id,
+      width: column.columnDef.meta?.width,
+      minWidth: column.columnDef.meta?.minWidth,
+      maxWidth: column.columnDef.meta?.maxWidth
+    }));
+    return resolveColumnLayoutWidths(containerWidth, columns);
+  }, [enableColumnResize, containerWidth, table, columnLayoutMetaSignature]);
+  const freezeOffsets = (0, import_react11.useMemo)(() => {
+    if (!enableColumnFreeze || enableColumnResize || !layoutWidths) {
+      return rowContextValue.columnFreeze.offsets;
+    }
+    const columns = table.getVisibleLeafColumns().map((column) => ({
+      id: column.id,
+      size: layoutWidths.get(column.id) ?? column.getSize(),
+      side: resolveColumnFreezeSide(column.columnDef.meta?.frozen)
+    }));
+    return buildColumnFreezeOffsets(columns);
+  }, [
+    enableColumnFreeze,
+    enableColumnResize,
+    layoutWidths,
+    rowContextValue.columnFreeze.offsets,
+    table
+  ]);
+  const contextValue = (0, import_react11.useMemo)(
+    () => ({
+      ...rowContextValue,
+      classNames,
+      columnFreeze: {
+        ...rowContextValue.columnFreeze,
+        offsets: freezeOffsets
+      },
+      columnResize: {
+        ...rowContextValue.columnResize,
+        layoutWidths
+      }
+    }),
+    [rowContextValue, classNames, freezeOffsets, layoutWidths]
   );
   if (isPending) {
     return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
@@ -4397,7 +4862,8 @@ function DataTable({
                       force: enableColumnResize,
                       lockMax: enableColumnResize,
                       minWidth: header.column.columnDef.meta?.minWidth,
-                      maxWidth: header.column.columnDef.meta?.maxWidth
+                      maxWidth: header.column.columnDef.meta?.maxWidth,
+                      layoutWidth: layoutWidths?.get(header.column.id)
                     });
                     const freezeOffset = enableColumnFreeze ? resolveHeaderFreezeOffset(header.column, freezeOffsets) : void 0;
                     const freezeStyle = getColumnFreezeStyle(freezeOffset, {
@@ -4410,7 +4876,9 @@ function DataTable({
                     };
                     const isPlaceholder = header.isPlaceholder;
                     const leafColumns = header.column.getLeafColumns();
-                    const leafIds = leafColumns.map((leafColumn) => leafColumn.id);
+                    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)
@@ -4566,7 +5034,7 @@ function DataTable({
 }
 
 // src/components/ui/table/components/Table/Table.tsx
-var import_react13 = require("react");
+var import_react14 = require("react");
 
 // src/components/ui/table/components/Table/buildColumnDef.tsx
 var import_jsx_runtime8 = require("react/jsx-runtime");
@@ -4655,6 +5123,7 @@ function buildColumnDef(props, sort, onSort) {
       cellRender: render,
       frozen,
       reorderable,
+      width,
       minWidth,
       maxWidth,
       className,
@@ -4702,10 +5171,10 @@ function countLeafColumns(nodes) {
 }
 
 // src/components/ui/table/components/Table/parseTableChildren.ts
-var import_react12 = require("react");
+var import_react13 = require("react");
 
 // src/components/ui/table/components/Table/tableChildTypes.ts
-var import_react11 = require("react");
+var import_react12 = require("react");
 var TABLE_HEADER_DISPLAY_NAME = "Table.Header";
 var TABLE_BODY_DISPLAY_NAME = "Table.Body";
 var TABLE_COLUMN_DISPLAY_NAME = "Table.Column";
@@ -4718,19 +5187,19 @@ function getComponentDisplayName(type) {
   return void 0;
 }
 function isTableHeaderElement(child) {
-  return (0, import_react11.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_HEADER_DISPLAY_NAME;
+  return (0, import_react12.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_HEADER_DISPLAY_NAME;
 }
 function isTableBodyElement(child) {
-  return (0, import_react11.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_BODY_DISPLAY_NAME;
+  return (0, import_react12.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_BODY_DISPLAY_NAME;
 }
 function isTableColumnElement(child) {
-  return (0, import_react11.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_COLUMN_DISPLAY_NAME;
+  return (0, import_react12.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_COLUMN_DISPLAY_NAME;
 }
 function isTableColumnGroupElement(child) {
-  return (0, import_react11.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_COLUMN_GROUP_DISPLAY_NAME;
+  return (0, import_react12.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_COLUMN_GROUP_DISPLAY_NAME;
 }
 function isTablePaginationElement(child) {
-  return (0, import_react11.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_PAGINATION_DISPLAY_NAME;
+  return (0, import_react12.isValidElement)(child) && getComponentDisplayName(child.type) === TABLE_PAGINATION_DISPLAY_NAME;
 }
 
 // src/components/ui/table/components/Table/parseTableChildren.ts
@@ -4740,7 +5209,7 @@ function parseTableChildren(children) {
     body: null,
     pagination: null
   };
-  for (const child of import_react12.Children.toArray(children)) {
+  for (const child of import_react13.Children.toArray(children)) {
     if (isTableHeaderElement(child)) {
       slots.header = child;
       continue;
@@ -4757,7 +5226,7 @@ function parseTableChildren(children) {
 }
 function walkColumnTreeNodes(children) {
   const result = [];
-  for (const child of import_react12.Children.toArray(children)) {
+  for (const child of import_react13.Children.toArray(children)) {
     if (isTableColumnElement(child)) {
       result.push({
         type: "leaf",
@@ -4774,7 +5243,7 @@ function walkColumnTreeNodes(children) {
       });
       continue;
     }
-    if ((0, import_react12.isValidElement)(child)) {
+    if ((0, import_react13.isValidElement)(child)) {
       const nested = child.props.children;
       if (nested != null) {
         result.push(...walkColumnTreeNodes(nested));
@@ -4900,12 +5369,12 @@ function TableRoot({
   filteredCount,
   ...dataTableProps
 }) {
-  const { header, pagination: paginationElement } = (0, import_react13.useMemo)(
+  const { header, pagination: paginationElement } = (0, import_react14.useMemo)(
     () => parseTableChildren(children),
     [children]
   );
-  const [sort, setSort] = (0, import_react13.useState)(null);
-  const handleSort = (0, import_react13.useCallback)((field) => {
+  const [sort, setSort] = (0, import_react14.useState)(null);
+  const handleSort = (0, import_react14.useCallback)((field) => {
     setSort((previous) => {
       if (previous?.field !== field) {
         return { field, direction: "asc" };
@@ -4916,8 +5385,8 @@ function TableRoot({
       return null;
     });
   }, []);
-  const columnTree = (0, import_react13.useMemo)(() => extractColumnTree(header), [header]);
-  const columns = (0, import_react13.useMemo)(
+  const columnTree = (0, import_react14.useMemo)(() => extractColumnTree(header), [header]);
+  const columns = (0, import_react14.useMemo)(
     () => buildColumnDefsFromTree(columnTree, sort, handleSort),
     [columnTree, sort, handleSort]
   );
@@ -4925,7 +5394,7 @@ function TableRoot({
   const pageSize = paginationProps?.pageSize ?? 10;
   const page = paginationProps?.page ?? 1;
   const resolvedTotalCount = paginationProps?.totalCount ?? totalCount ?? data.length;
-  const tableData = (0, import_react13.useMemo)(() => {
+  const tableData = (0, import_react14.useMemo)(() => {
     const sortedData = sortTableData(data, sort);
     if (!paginationProps) return sortedData;
     return paginateTableData(sortedData, page, pageSize);
@@ -5053,6 +5522,7 @@ var Table = Object.assign(TableRoot, {
   previousSearchIndex,
   resolveCellRenderer,
   resolveColumnFreezeSide,
+  resolveColumnLayoutWidths,
   resolveDataTableLabels,
   resolveDropEdge,
   resolveHeaderFreezeOffset,