bolt-table 0.1.26 → 0.1.27

package/dist/index.mjs

@@ -90,6 +90,18 @@ var EyeOffIcon = ({ style, className }) => /* @__PURE__ */ jsxs("svg", { ...svgB
   /* @__PURE__ */ jsx("path", { d: "M6.61 6.61A13.526 13.526 0 0 0 2 12s3 7 10 7a9.74 9.74 0 0 0 5.39-1.61" }),
   /* @__PURE__ */ jsx("line", { x1: "2", x2: "22", y1: "2", y2: "22" })
 ] });
+var SearchIcon = ({ style, className }) => /* @__PURE__ */ jsxs("svg", { ...svgBase, style, className, children: [
+  /* @__PURE__ */ jsx("circle", { cx: "11", cy: "11", r: "8" }),
+  /* @__PURE__ */ jsx("path", { d: "m21 21-4.3-4.3" })
+] });
+var ColumnsIcon = ({ style, className }) => /* @__PURE__ */ jsxs("svg", { ...svgBase, style, className, children: [
+  /* @__PURE__ */ jsx("rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", ry: "2" }),
+  /* @__PURE__ */ jsx("line", { x1: "12", x2: "12", y1: "3", y2: "21" })
+] });
+var XIcon = ({ style, className }) => /* @__PURE__ */ jsxs("svg", { ...svgBase, style, className, children: [
+  /* @__PURE__ */ jsx("path", { d: "M18 6 6 18" }),
+  /* @__PURE__ */ jsx("path", { d: "m6 6 12 12" })
+] });
 
 // src/DraggableHeader.tsx
 import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
@@ -762,7 +774,13 @@ ResizeOverlay.displayName = "ResizeOverlay";
 var ResizeOverlay_default = ResizeOverlay;
 
 // src/TableBody.tsx
-import React3, { useCallback, useEffect as useEffect2, useMemo, useRef as useRef3, useState as useState2 } from "react";
+import React3, {
+  useCallback,
+  useEffect as useEffect2,
+  useMemo,
+  useRef as useRef3,
+  useState as useState2
+} from "react";
 import { Fragment as Fragment3, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 var SHIMMER_WIDTHS = [55, 70, 45, 80, 60, 50, 75, 65];
 var EditableCell = ({
@@ -789,7 +807,15 @@ var EditableCell = ({
       onEdit(coerced, record, column.dataIndex, rowIndex);
     }
     onEditComplete();
-  }, [draft, value, column.dataIndex, record, rowIndex, onEdit, onEditComplete]);
+  }, [
+    draft,
+    value,
+    column.dataIndex,
+    record,
+    rowIndex,
+    onEdit,
+    onEditComplete
+  ]);
   const cancel = useCallback(() => {
     onEditComplete();
   }, [onEditComplete]);
@@ -891,7 +917,11 @@ var Cell = React3.memo(
             rowSelection.onSelect?.(record, true, [record], e.nativeEvent);
             rowSelection.onChange?.([rawKey], [record], { type: "single" });
           },
-          style: { cursor: "pointer", accentColor, backgroundColor: "#94A3B8" }
+          style: {
+            cursor: "pointer",
+            accentColor,
+            backgroundColor: "#94A3B8"
+          }
         }
       ) : /* @__PURE__ */ jsx4(
         "input",
@@ -917,7 +947,11 @@ var Cell = React3.memo(
               type: "multiple"
             });
           },
-          style: { cursor: "pointer", accentColor, backgroundColor: "#94A3B8" }
+          style: {
+            cursor: "pointer",
+            accentColor,
+            backgroundColor: "#94A3B8"
+          }
         }
       );
       return /* @__PURE__ */ jsx4(
@@ -1053,6 +1087,33 @@ var MeasuredExpandedRow = React3.memo(
   }
 );
 MeasuredExpandedRow.displayName = "MeasuredExpandedRow";
+var DynamicRowMeasurer = React3.memo(
+  ({
+    index,
+    onHeightChange,
+    children
+  }) => {
+    const ref = useRef3(null);
+    const onHeightChangeRef = useRef3(onHeightChange);
+    useEffect2(() => {
+      onHeightChangeRef.current = onHeightChange;
+    }, [onHeightChange]);
+    useEffect2(() => {
+      const el = ref.current;
+      if (!el) return;
+      const observer = new ResizeObserver((entries) => {
+        const height = entries[0]?.borderBoxSize?.[0]?.blockSize;
+        if (height != null && height > 0) {
+          onHeightChangeRef.current(index, Math.ceil(height));
+        }
+      });
+      observer.observe(el);
+      return () => observer.disconnect();
+    }, [index]);
+    return /* @__PURE__ */ jsx4("div", { ref, children });
+  }
+);
+DynamicRowMeasurer.displayName = "DynamicRowMeasurer";
 var TableBody = ({
   data,
   orderedColumns,
@@ -1082,11 +1143,16 @@ var TableBody = ({
   bodyGridRow = 2,
   onEdit,
   editingCell,
-  onEditComplete
+  onEditComplete,
+  enableDynamicRowHeight = false,
+  onRowHeightChange
 }) => {
   const virtualItems = rowVirtualizer.getVirtualItems();
   const totalSize = rowVirtualizer.getTotalSize();
-  const selectedKeySet = useMemo(() => new Set(normalizedSelectedKeys), [normalizedSelectedKeys]);
+  const selectedKeySet = useMemo(
+    () => new Set(normalizedSelectedKeys),
+    [normalizedSelectedKeys]
+  );
   const safeData = data ?? [];
   const safeColumns = orderedColumns ?? [];
   const allDataForSelection = useMemo(() => {
@@ -1169,15 +1235,58 @@ var TableBody = ({
                   top: `${virtualRow.start}px`,
                   left: 0,
                   right: 0,
-                  height: `${virtualRow.size}px`,
-                  ...rowSty
+                  height: enableDynamicRowHeight ? void 0 : `${virtualRow.size}px`,
+                  minHeight: enableDynamicRowHeight ? `${rowHeight}px` : void 0
                 },
-                children: /* @__PURE__ */ jsx4(
+                children: enableDynamicRowHeight && onRowHeightChange && colIndex === 0 ? /* @__PURE__ */ jsx4(
+                  DynamicRowMeasurer,
+                  {
+                    index: virtualRow.index,
+                    onHeightChange: onRowHeightChange,
+                    children: /* @__PURE__ */ jsx4(
+                      "div",
+                      {
+                        style: {
+                          minHeight: `${rowHeight}px`,
+                          position: "relative",
+                          ...rowSty
+                        },
+                        children: /* @__PURE__ */ jsx4(
+                          Cell,
+                          {
+                            value: cellValue,
+                            record: row,
+                            column: col,
+                            rowIndex: virtualRow.index,
+                            classNames,
+                            styles,
+                            isSelected,
+                            isExpanded,
+                            rowSelection,
+                            normalizedSelectedKeys,
+                            rowKey,
+                            allData: allDataForSelection,
+                            getRowKey,
+                            getRawRowKey,
+                            accentColor,
+                            isLoading: isRowShimmer,
+                            recordFingerprint,
+                            onEdit,
+                            isEditing: editingCell?.rowKey === rowKey && editingCell?.columnKey === col.key,
+                            onEditComplete
+                          }
+                        )
+                      }
+                    )
+                  }
+                ) : /* @__PURE__ */ jsx4(
                   "div",
                   {
                     style: {
-                      height: `${rowHeight}px`,
-                      position: "relative"
+                      height: enableDynamicRowHeight ? void 0 : `${rowHeight}px`,
+                      minHeight: enableDynamicRowHeight ? `${rowHeight}px` : void 0,
+                      position: "relative",
+                      ...rowSty
                     },
                     children: /* @__PURE__ */ jsx4(
                       Cell,
@@ -1232,7 +1341,12 @@ var TableBody = ({
           if (!(resolvedExpandedKeys?.has(rk) ?? false)) return null;
           let expandedRenderResult = null;
           try {
-            expandedRenderResult = expandable.expandedRowRender(row, virtualRow.index, 0, true);
+            expandedRenderResult = expandable.expandedRowRender(
+              row,
+              virtualRow.index,
+              0,
+              true
+            );
           } catch {
           }
           const expandedContent = /* @__PURE__ */ jsx4(
@@ -1600,7 +1714,14 @@ function BoltTable({
   onCopy,
   keepPinnedRowsAcrossPages,
   onEdit,
-  onRowClick
+  onRowClick,
+  enableColumnVirtualization = false,
+  enableDynamicRowHeight = false,
+  columnPersistence = false,
+  showColumnSettings = true,
+  hideGlobalSearch = false,
+  globalSearchValue,
+  onGlobalSearchChange
 }) {
   const data = useMemo2(() => {
     if (!Array.isArray(rawData)) return STABLE_EMPTY_DATA;
@@ -1608,7 +1729,8 @@ function BoltTable({
     return filtered.length > 0 ? filtered : STABLE_EMPTY_DATA;
   }, [rawData]);
   const initialColumns = useMemo2(() => {
-    if (!Array.isArray(rawInitialColumns)) return STABLE_EMPTY_COLS;
+    if (!Array.isArray(rawInitialColumns))
+      return STABLE_EMPTY_COLS;
     const safe = rawInitialColumns.filter(
       (col) => col != null && typeof col.key === "string"
     );
@@ -1673,6 +1795,106 @@ function BoltTable({
     () => /* @__PURE__ */ new Map()
   );
   const manuallyResizedRef = useRef4(/* @__PURE__ */ new Set());
+  const persistenceAppliedRef = useRef4(false);
+  React4.useEffect(() => {
+    if (!columnPersistence || persistenceAppliedRef.current) return;
+    persistenceAppliedRef.current = true;
+    const {
+      storageKey,
+      persistOrder = true,
+      persistWidths = true,
+      persistVisibility = true,
+      persistPinned = true
+    } = columnPersistence;
+    try {
+      const raw = localStorage.getItem(`bt_${storageKey}`);
+      if (!raw) return;
+      const saved = JSON.parse(raw);
+      if (persistOrder && saved.order) {
+        setColumnOrder(saved.order);
+      }
+      if (persistWidths && saved.widths) {
+        setColumnWidths(
+          new Map(Object.entries(saved.widths).map(([k, v]) => [k, Number(v)]))
+        );
+      }
+      if (persistVisibility && saved.hidden || persistPinned && saved.pinned) {
+        setColumns(
+          (prev) => prev.map((col) => {
+            let updated = col;
+            if (persistVisibility && saved.hidden && col.key in saved.hidden) {
+              updated = { ...updated, hidden: saved.hidden[col.key] };
+            }
+            if (persistPinned && saved.pinned && col.key in saved.pinned) {
+              updated = { ...updated, pinned: saved.pinned[col.key] };
+            }
+            return updated;
+          })
+        );
+      }
+    } catch {
+    }
+  }, [columnPersistence]);
+  const persistColumnsToStorage = useCallback2(() => {
+    if (!columnPersistence) return;
+    const {
+      storageKey,
+      persistOrder = true,
+      persistWidths = true,
+      persistVisibility = true,
+      persistPinned = true
+    } = columnPersistence;
+    try {
+      const saved = {};
+      if (persistOrder) saved.order = columnOrder;
+      if (persistWidths) {
+        const widths = {};
+        columnWidths.forEach((v, k) => {
+          widths[k] = v;
+        });
+        saved.widths = widths;
+      }
+      if (persistVisibility) {
+        const hidden = {};
+        columns.forEach((c) => {
+          if (c.hidden) hidden[c.key] = true;
+        });
+        saved.hidden = hidden;
+      }
+      if (persistPinned) {
+        const pinned = {};
+        columns.forEach((c) => {
+          if (c.pinned) pinned[c.key] = c.pinned;
+        });
+        saved.pinned = pinned;
+      }
+      localStorage.setItem(`bt_${storageKey}`, JSON.stringify(saved));
+    } catch {
+    }
+  }, [columnPersistence, columnOrder, columnWidths, columns]);
+  React4.useEffect(() => {
+    if (!columnPersistence || !persistenceAppliedRef.current) return;
+    persistColumnsToStorage();
+  }, [columnPersistence, persistColumnsToStorage]);
+  const [showColumnPicker, setShowColumnPicker] = useState3(false);
+  const columnPickerRef = useRef4(null);
+  React4.useEffect(() => {
+    if (!showColumnPicker) return;
+    const close = (e) => {
+      if (columnPickerRef.current && !columnPickerRef.current.contains(e.target)) {
+        setShowColumnPicker(false);
+      }
+    };
+    const onKey = (e) => {
+      if (e.key === "Escape") setShowColumnPicker(false);
+    };
+    document.addEventListener("mousedown", close);
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("mousedown", close);
+      document.removeEventListener("keydown", onKey);
+    };
+  }, [showColumnPicker]);
   const columnsWithPersistedWidths = useMemo2(
     () => columns.map((col) => ({
       ...col,
@@ -1737,6 +1959,32 @@ function BoltTable({
     },
     [rowKey]
   );
+  const deduplicatedRowKeys = useMemo2(() => {
+    const seen = /* @__PURE__ */ new Map();
+    return data.map((row, idx) => {
+      const raw = getRowKey(row, idx);
+      const count = seen.get(raw) ?? 0;
+      seen.set(raw, count + 1);
+      return count > 0 ? `${raw}__${idx}` : raw;
+    });
+  }, [data, getRowKey]);
+  const hasDuplicateKeys = useMemo2(() => {
+    const seen = /* @__PURE__ */ new Set();
+    for (const row of data) {
+      if (row == null) continue;
+      const k = getRowKey(row, 0);
+      if (seen.has(k)) return true;
+      seen.add(k);
+    }
+    return false;
+  }, [data, getRowKey]);
+  const getSafeRowKey = useCallback2(
+    (record, index) => {
+      if (!hasDuplicateKeys) return getRowKey(record, index);
+      return deduplicatedRowKeys[index] ?? getRowKey(record, index);
+    },
+    [getRowKey, hasDuplicateKeys, deduplicatedRowKeys]
+  );
   const getRawRowKey = useCallback2(
     (record, index) => {
       if (record == null) return index;
@@ -1754,16 +2002,13 @@ function BoltTable({
     },
     [rowKey]
   );
-  const normalizedSelectedKeys = useMemo2(
-    () => {
-      const keys = rowSelection?.selectedRowKeys;
-      if (!Array.isArray(keys)) return [];
-      return keys.filter((k) => k != null).map((k) => String(k));
-    },
-    [rowSelection?.selectedRowKeys]
-  );
-  const getRowKeyRef = useRef4(getRowKey);
-  getRowKeyRef.current = getRowKey;
+  const normalizedSelectedKeys = useMemo2(() => {
+    const keys = rowSelection?.selectedRowKeys;
+    if (!Array.isArray(keys)) return [];
+    return keys.filter((k) => k != null).map((k) => String(k));
+  }, [rowSelection?.selectedRowKeys]);
+  const getRowKeyRef = useRef4(getSafeRowKey);
+  getRowKeyRef.current = getSafeRowKey;
   const resolvedExpandedKeysRef = useRef4(resolvedExpandedKeys);
   resolvedExpandedKeysRef.current = resolvedExpandedKeys;
   const toggleExpandRef = useRef4(toggleExpand);
@@ -1946,7 +2191,9 @@ function BoltTable({
         }
         const scrollEl = tableAreaRef.current;
         if (!scrollEl) return;
-        const headers = scrollEl.querySelectorAll("[data-bt-header][data-column-key]");
+        const headers = scrollEl.querySelectorAll(
+          "[data-bt-header][data-column-key]"
+        );
         let newOverId = null;
         headers.forEach((h) => {
           const key = h.dataset.columnKey;
@@ -1988,10 +2235,7 @@ function BoltTable({
               const newIndex = items.indexOf(currentOverId);
               if (oldIndex === -1 || newIndex === -1) return items;
               const newOrder = arrayMove(items, oldIndex, newIndex);
-              setTimeout(
-                () => onColumnOrderChangeRef.current?.(newOrder),
-                0
-              );
+              setTimeout(() => onColumnOrderChangeRef.current?.(newOrder), 0);
               return newOrder;
             });
           });
@@ -2091,9 +2335,7 @@ function BoltTable({
     [leftPinned, unpinned, rightPinned]
   );
   const freshOrderedColumns = useMemo2(() => {
-    const latestMap = new Map(
-      initialColumnsRef.current.map((c) => [c.key, c])
-    );
+    const latestMap = new Map(initialColumnsRef.current.map((c) => [c.key, c]));
     return orderedColumns.map((col) => {
       if (col.key === "__select__" || col.key === "__expand__") return col;
       const latest = latestMap.get(col.key);
@@ -2150,22 +2392,27 @@ function BoltTable({
   };
   const [internalRowPinning, setInternalRowPinning] = useState3({ top: [], bottom: [] });
   const resolvedRowPinning = rowPinning === true ? internalRowPinning : rowPinning && typeof rowPinning === "object" ? rowPinning : void 0;
-  const handleRowPin = useCallback2((rk, pinned) => {
-    if (onRowPin) {
-      onRowPin(rk, pinned);
-      return;
-    }
-    if (rowPinning === true) {
-      setInternalRowPinning((prev) => {
-        const rkStr = String(rk);
-        const newTop = (prev.top ?? []).filter((k) => String(k) !== rkStr);
-        const newBottom = (prev.bottom ?? []).filter((k) => String(k) !== rkStr);
-        if (pinned === "top") newTop.push(rk);
-        else if (pinned === "bottom") newBottom.push(rk);
-        return { top: newTop, bottom: newBottom };
-      });
-    }
-  }, [onRowPin, rowPinning]);
+  const handleRowPin = useCallback2(
+    (rk, pinned) => {
+      if (onRowPin) {
+        onRowPin(rk, pinned);
+        return;
+      }
+      if (rowPinning === true) {
+        setInternalRowPinning((prev) => {
+          const rkStr = String(rk);
+          const newTop = (prev.top ?? []).filter((k) => String(k) !== rkStr);
+          const newBottom = (prev.bottom ?? []).filter(
+            (k) => String(k) !== rkStr
+          );
+          if (pinned === "top") newTop.push(rk);
+          else if (pinned === "bottom") newBottom.push(rk);
+          return { top: newTop, bottom: newBottom };
+        });
+      }
+    },
+    [onRowPin, rowPinning]
+  );
   const onSortChangeRef = useRef4(onSortChange);
   onSortChangeRef.current = onSortChange;
   const [sortState, setSortState] = useState3({ key: "", direction: null });
@@ -2188,6 +2435,7 @@ function BoltTable({
   const [columnFilters, setColumnFilters] = useState3(
     {}
   );
+  const [internalGlobalSearch, setInternalGlobalSearch] = useState3("");
   const handleColumnFilter = useCallback2(
     (columnKey, value) => {
       setColumnFilters((prev) => {
@@ -2212,6 +2460,20 @@ function BoltTable({
   columnsLookupRef.current = initialColumns;
   const processedData = useMemo2(() => {
     let result = data;
+    const globalSearch = globalSearchValue ?? internalGlobalSearch;
+    if (globalSearch) {
+      const searchLower = globalSearch.toLowerCase();
+      result = result.filter((row) => {
+        if (row == null) return false;
+        for (const key of Object.keys(row)) {
+          const val = row[key];
+          if (val != null && String(val).toLowerCase().includes(searchLower)) {
+            return true;
+          }
+        }
+        return false;
+      });
+    }
     if (!onFilterChangeRef.current) {
       const filterKeys = Object.keys(columnFilters);
       if (filterKeys.length > 0) {
@@ -2221,7 +2483,11 @@ function BoltTable({
             try {
               const col = columnsLookupRef.current.find((c) => c.key === key);
               if (typeof col?.filterFn === "function") {
-                return col.filterFn(columnFilters[key], row, col.dataIndex ?? key);
+                return col.filterFn(
+                  columnFilters[key],
+                  row,
+                  col.dataIndex ?? key
+                );
               }
               const cellVal = String(row[key] ?? "").toLowerCase();
               return cellVal.includes(columnFilters[key].toLowerCase());
@@ -2264,7 +2530,7 @@ function BoltTable({
       }
     }
     return result;
-  }, [data, sortState, columnFilters]);
+  }, [data, sortState, columnFilters, globalSearchValue, internalGlobalSearch]);
   const pinnedRowCacheRef = useRef4(/* @__PURE__ */ new Map());
   const { pinnedTopRows, pinnedBottomRows, unpinnedProcessedData } = useMemo2(() => {
     if (!resolvedRowPinning || !resolvedRowPinning.top?.length && !resolvedRowPinning.bottom?.length) {
@@ -2276,19 +2542,23 @@ function BoltTable({
       };
     }
     const topKeySet = new Set((resolvedRowPinning.top ?? []).map(String));
-    const bottomKeySet = new Set((resolvedRowPinning.bottom ?? []).map(String));
+    const bottomKeySet = new Set(
+      (resolvedRowPinning.bottom ?? []).map(String)
+    );
     const topMap = /* @__PURE__ */ new Map();
     const bottomMap = /* @__PURE__ */ new Map();
     const rest = [];
     processedData.forEach((row, idx) => {
       if (row == null) return;
-      const key = getRowKey(row, idx);
+      const key = getSafeRowKey(row, idx);
       if (topKeySet.has(key)) {
         topMap.set(key, row);
-        if (keepPinnedRowsAcrossPages) pinnedRowCacheRef.current.set(key, row);
+        if (keepPinnedRowsAcrossPages)
+          pinnedRowCacheRef.current.set(key, row);
       } else if (bottomKeySet.has(key)) {
         bottomMap.set(key, row);
-        if (keepPinnedRowsAcrossPages) pinnedRowCacheRef.current.set(key, row);
+        if (keepPinnedRowsAcrossPages)
+          pinnedRowCacheRef.current.set(key, row);
       } else {
         rest.push(row);
       }
@@ -2306,7 +2576,8 @@ function BoltTable({
       }
       const allPinnedKeys = /* @__PURE__ */ new Set([...topKeySet, ...bottomKeySet]);
       for (const cachedKey of pinnedRowCacheRef.current.keys()) {
-        if (!allPinnedKeys.has(cachedKey)) pinnedRowCacheRef.current.delete(cachedKey);
+        if (!allPinnedKeys.has(cachedKey))
+          pinnedRowCacheRef.current.delete(cachedKey);
       }
     }
     const orderedTop = (resolvedRowPinning.top ?? []).map((k) => topMap.get(String(k))).filter((r) => r !== void 0);
@@ -2316,7 +2587,12 @@ function BoltTable({
       pinnedBottomRows: orderedBottom,
       unpinnedProcessedData: rest
     };
-  }, [processedData, resolvedRowPinning, getRowKey, keepPinnedRowsAcrossPages]);
+  }, [
+    processedData,
+    resolvedRowPinning,
+    getSafeRowKey,
+    keepPinnedRowsAcrossPages
+  ]);
   const pinnedTopHeight = pinnedTopRows.length * rowHeight;
   const pinnedBottomHeight = pinnedBottomRows.length * rowHeight;
   const pinnedTopKeySet = useMemo2(
@@ -2333,9 +2609,7 @@ function BoltTable({
   }, []);
   const [cellContextMenu, setCellContextMenu] = useState3(null);
   const cellMenuRef = useRef4(null);
-  const cellLongPressTimer = useRef4(
-    null
-  );
+  const cellLongPressTimer = useRef4(null);
   const cellTouchStart = useRef4(null);
   const cancelCellLongPress = useCallback2(() => {
     if (cellLongPressTimer.current) {
@@ -2362,10 +2636,11 @@ function BoltTable({
     };
   }, [cellContextMenu]);
   const columnFiltersKey = Object.keys(columnFilters).sort().map((k) => `${k}:${columnFilters[k]}`).join("|");
+  const activeGlobalSearch = globalSearchValue ?? internalGlobalSearch;
   React4.useEffect(() => {
     setInternalPage(1);
     tableAreaRef.current?.scrollTo({ top: 0 });
-  }, [columnFiltersKey]);
+  }, [columnFiltersKey, activeGlobalSearch]);
   const DEFAULT_PAGE_SIZE = 15;
   const [internalPage, setInternalPage] = useState3(1);
   const [internalPageSize, setInternalPageSize] = useState3(DEFAULT_PAGE_SIZE);
@@ -2411,6 +2686,17 @@ function BoltTable({
     return paginatedData;
   }, [shimmerData, infiniteLoadingShimmer, paginatedData]);
   const measuredExpandedHeights = useRef4(/* @__PURE__ */ new Map());
+  const measuredRowHeights = useRef4(/* @__PURE__ */ new Map());
+  const handleRowHeightChange = useCallback2(
+    (index, height) => {
+      if (!enableDynamicRowHeight) return;
+      const prev = measuredRowHeights.current.get(index);
+      if (prev === height) return;
+      measuredRowHeights.current.set(index, height);
+      rowVirtualizerRef.current?.measure();
+    },
+    [enableDynamicRowHeight]
+  );
   const expandedRowMeasureRafRef = useRef4(null);
   const handleExpandedRowResize = useCallback2(
     (rk, contentHeight) => {
@@ -2435,23 +2721,73 @@ function BoltTable({
       if (shimmerData) return rowHeight;
       const item = displayData[index];
       if (!item) return rowHeight;
-      const key = getRowKey(item, index);
-      if (!resolvedExpandedKeys.has(key)) return rowHeight;
+      const baseHeight = enableDynamicRowHeight ? measuredRowHeights.current.get(index) ?? rowHeight : rowHeight;
+      const key = getSafeRowKey(item, index);
+      if (!resolvedExpandedKeys.has(key)) return baseHeight;
       const cached = measuredExpandedHeights.current.get(key);
-      return cached ? rowHeight + cached : rowHeight + expandedRowHeight;
+      return cached ? baseHeight + cached : baseHeight + expandedRowHeight;
     },
     overscan: 5,
     getItemKey: (index) => {
       if (shimmerData) return `__shimmer_${index}__`;
       const item = displayData[index];
       if (!item) return `__fallback_${index}__`;
-      return getRowKey(item, index);
+      return getSafeRowKey(item, index);
     },
     paddingStart: pinnedTopHeight,
     paddingEnd: pinnedBottomHeight
   });
   const rowVirtualizerRef = useRef4(rowVirtualizer);
   rowVirtualizerRef.current = rowVirtualizer;
+  const scrollLeftRef = useRef4(0);
+  const [visibleColumnRange, setVisibleColumnRange] = useState3(null);
+  React4.useEffect(() => {
+    if (!enableColumnVirtualization) return;
+    const el = tableAreaRef.current;
+    if (!el) return;
+    const updateVisibleColumns = () => {
+      const scrollLeft = el.scrollLeft;
+      scrollLeftRef.current = scrollLeft;
+      const viewportWidth = el.clientWidth;
+      const viewStart = scrollLeft;
+      const viewEnd = scrollLeft + viewportWidth;
+      let cumWidth = 0;
+      let startIdx = -1;
+      let endIdx = orderedColumns.length - 1;
+      for (let i = 0; i < orderedColumns.length; i++) {
+        const col = orderedColumns[i];
+        const colWidth = col.width ?? 150;
+        const colStart = cumWidth;
+        const colEnd = cumWidth + colWidth;
+        cumWidth = colEnd;
+        if (col.pinned) continue;
+        if (startIdx === -1 && colEnd > viewStart) {
+          startIdx = Math.max(0, i - 1);
+        }
+        if (colStart > viewEnd) {
+          endIdx = Math.min(orderedColumns.length - 1, i + 1);
+          break;
+        }
+      }
+      if (startIdx === -1) startIdx = 0;
+      setVisibleColumnRange((prev) => {
+        if (prev && prev.start === startIdx && prev.end === endIdx) return prev;
+        return { start: startIdx, end: endIdx };
+      });
+    };
+    updateVisibleColumns();
+    el.addEventListener("scroll", updateVisibleColumns, { passive: true });
+    return () => el.removeEventListener("scroll", updateVisibleColumns);
+  }, [enableColumnVirtualization, orderedColumns]);
+  const virtualizedColumns = useMemo2(() => {
+    if (!enableColumnVirtualization || !visibleColumnRange)
+      return freshOrderedColumns;
+    return freshOrderedColumns.filter((col, idx) => {
+      if (col.pinned) return true;
+      if (col.key === "__select__" || col.key === "__expand__") return true;
+      return idx >= visibleColumnRange.start && idx <= visibleColumnRange.end;
+    });
+  }, [enableColumnVirtualization, visibleColumnRange, freshOrderedColumns]);
   const resolvedExpandedKeysFingerprint = Array.from(resolvedExpandedKeys).sort().join(",");
   React4.useLayoutEffect(() => {
     rowVirtualizer.measure();
@@ -2518,7 +2854,10 @@ function BoltTable({
   }, [pgCurrent, needsClientPagination]);
   const getPageNumbers = () => {
     if (totalPages <= 7)
-      return Array.from({ length: totalPages }, (_, i) => i + 1);
+      return Array.from(
+        { length: totalPages },
+        (_, i) => i + 1
+      );
     const leftSibling = Math.max(currentPage - 1, 2);
     const showLeftEllipsis = leftSibling > 2;
     const rightSibling = Math.min(currentPage + 1, totalPages - 1);
@@ -2529,7 +2868,10 @@ function BoltTable({
       return [
         1,
         "ellipsis-left",
-        ...Array.from({ length: 5 }, (_, i) => totalPages - 4 + i)
+        ...Array.from(
+          { length: 5 },
+          (_, i) => totalPages - 4 + i
+        )
       ];
     return [
       1,
@@ -2600,6 +2942,189 @@ function BoltTable({
           }
           ${onRowClick ? "[data-bt-cell] { cursor: pointer; }" : ""}
         ` }),
+          (!hideGlobalSearch || showColumnSettings) && /* @__PURE__ */ jsxs5(
+            "div",
+            {
+              style: {
+                display: "flex",
+                alignItems: "center",
+                gap: 8,
+                padding: "6px 8px",
+                borderBottom: "1px solid rgba(128,128,128,0.2)",
+                fontSize: 12,
+                flexShrink: 0
+              },
+              children: [
+                !hideGlobalSearch && /* @__PURE__ */ jsxs5(
+                  "div",
+                  {
+                    style: {
+                      display: "flex",
+                      alignItems: "center",
+                      gap: 4,
+                      flex: "1 1 0%",
+                      position: "relative"
+                    },
+                    children: [
+                      /* @__PURE__ */ jsx5(
+                        "span",
+                        {
+                          style: { display: "flex", color: "GrayText", flexShrink: 0 },
+                          children: icons?.search ?? /* @__PURE__ */ jsx5(SearchIcon, { style: { width: 14, height: 14 } })
+                        }
+                      ),
+                      /* @__PURE__ */ jsx5(
+                        "input",
+                        {
+                          type: "text",
+                          placeholder: "Search all columns...",
+                          value: globalSearchValue ?? internalGlobalSearch,
+                          onChange: (e) => {
+                            const v = e.target.value;
+                            if (onGlobalSearchChange) onGlobalSearchChange(v);
+                            else setInternalGlobalSearch(v);
+                          },
+                          style: {
+                            flex: "1 1 0%",
+                            border: "none",
+                            outline: "none",
+                            background: "transparent",
+                            font: "inherit",
+                            color: "inherit",
+                            padding: "4px 6px",
+                            minWidth: 0
+                          }
+                        }
+                      ),
+                      (globalSearchValue ?? internalGlobalSearch) && /* @__PURE__ */ jsx5(
+                        "button",
+                        {
+                          type: "button",
+                          onClick: () => {
+                            if (onGlobalSearchChange) onGlobalSearchChange("");
+                            else setInternalGlobalSearch("");
+                          },
+                          style: {
+                            display: "flex",
+                            alignItems: "center",
+                            justifyContent: "center",
+                            background: "none",
+                            border: "none",
+                            cursor: "pointer",
+                            padding: 2,
+                            color: "GrayText",
+                            flexShrink: 0
+                          },
+                          children: icons?.close ?? /* @__PURE__ */ jsx5(XIcon, { style: { width: 12, height: 12 } })
+                        }
+                      )
+                    ]
+                  }
+                ),
+                showColumnSettings && /* @__PURE__ */ jsxs5("div", { style: { position: "relative", flexShrink: 0 }, children: [
+                  /* @__PURE__ */ jsxs5(
+                    "button",
+                    {
+                      type: "button",
+                      onClick: () => setShowColumnPicker((p) => !p),
+                      style: {
+                        display: "flex",
+                        alignItems: "center",
+                        justifyContent: "center",
+                        background: "none",
+                        border: "1px solid rgba(128,128,128,0.2)",
+                        borderRadius: 4,
+                        cursor: "pointer",
+                        padding: "4px 6px",
+                        color: "inherit",
+                        gap: 4,
+                        fontSize: 12
+                      },
+                      title: "Column settings",
+                      children: [
+                        icons?.columns ?? /* @__PURE__ */ jsx5(ColumnsIcon, { style: { width: 14, height: 14 } }),
+                        /* @__PURE__ */ jsx5("span", { children: "Columns" })
+                      ]
+                    }
+                  ),
+                  showColumnPicker && /* @__PURE__ */ jsx5(
+                    "div",
+                    {
+                      ref: columnPickerRef,
+                      style: {
+                        position: "absolute",
+                        top: "100%",
+                        right: 0,
+                        zIndex: 99999,
+                        minWidth: 200,
+                        maxHeight: 320,
+                        overflowY: "auto",
+                        borderRadius: 8,
+                        border: "1px solid rgba(128,128,128,0.2)",
+                        boxShadow: "0 4px 24px rgba(0,0,0,0.12)",
+                        backdropFilter: "blur(16px)",
+                        WebkitBackdropFilter: "blur(16px)",
+                        backgroundColor: "rgba(128,128,128,0.08)",
+                        padding: "4px 0",
+                        marginTop: 4
+                      },
+                      children: initialColumns.filter(
+                        (c) => c.key !== "__select__" && c.key !== "__expand__"
+                      ).map((col) => {
+                        const current = columns.find((c) => c.key === col.key);
+                        const isHidden = current?.hidden ?? false;
+                        const isPinned = !!current?.pinned;
+                        return /* @__PURE__ */ jsxs5(
+                          "label",
+                          {
+                            style: {
+                              display: "flex",
+                              alignItems: "center",
+                              gap: 8,
+                              padding: "6px 12px",
+                              cursor: isPinned ? "not-allowed" : "pointer",
+                              opacity: isPinned ? 0.5 : 1,
+                              fontSize: 12
+                            },
+                            children: [
+                              /* @__PURE__ */ jsx5(
+                                "input",
+                                {
+                                  type: "checkbox",
+                                  checked: !isHidden,
+                                  disabled: isPinned,
+                                  onChange: () => {
+                                    if (isPinned) return;
+                                    handleToggleHide(col.key);
+                                  },
+                                  style: {
+                                    cursor: isPinned ? "not-allowed" : "pointer",
+                                    accentColor
+                                  }
+                                }
+                              ),
+                              /* @__PURE__ */ jsx5(
+                                "span",
+                                {
+                                  style: {
+                                    overflow: "hidden",
+                                    textOverflow: "ellipsis",
+                                    whiteSpace: "nowrap"
+                                  },
+                                  children: typeof col.title === "string" ? col.title : col.key
+                                }
+                              )
+                            ]
+                          },
+                          col.key
+                        );
+                      })
+                    }
+                  )
+                ] })
+              ]
+            }
+          ),
           /* @__PURE__ */ jsx5(
             "div",
             {
@@ -2744,19 +3269,20 @@ function BoltTable({
                           ...isEmpty ? { height: "100%" } : {}
                         },
                         onContextMenu: (e) => {
-                          const cell = e.target.closest("[data-bt-cell]");
+                          const cell = e.target.closest(
+                            "[data-bt-cell]"
+                          );
                           if (!cell) return;
                           const rk = cell.dataset.rowKey;
                           const ck = cell.dataset.columnKey;
                           if (!rk || !ck) return;
-                          const col = freshOrderedColumns.find(
-                            (c) => c.key === ck
-                          );
+                          const col = freshOrderedColumns.find((c) => c.key === ck);
                           const hasCopy = !!col?.copy;
                           const hasRowPin = !!rowPinning;
                           const hasCellItems = col?.columnCellContextMenuItems && col.columnCellContextMenuItems.length > 0;
                           const hasEdit = !!col?.editable && !col?.render && !!onEdit;
-                          if (!hasCopy && !hasRowPin && !hasCellItems && !hasEdit) return;
+                          if (!hasCopy && !hasRowPin && !hasCellItems && !hasEdit)
+                            return;
                           e.preventDefault();
                           setCellContextMenu({
                             x: Math.min(e.clientX, window.innerWidth - 200),
@@ -2767,7 +3293,9 @@ function BoltTable({
                         },
                         onTouchStart: (e) => {
                           cancelCellLongPress();
-                          const cell = e.target.closest("[data-bt-cell]");
+                          const cell = e.target.closest(
+                            "[data-bt-cell]"
+                          );
                           if (!cell) return;
                           const touch = e.touches[0];
                           cellTouchStart.current = {
@@ -2779,14 +3307,13 @@ function BoltTable({
                           cellLongPressTimer.current = setTimeout(() => {
                             cellLongPressTimer.current = null;
                             if (!rk || !ck) return;
-                            const col = freshOrderedColumns.find(
-                              (c) => c.key === ck
-                            );
+                            const col = freshOrderedColumns.find((c) => c.key === ck);
                             const hasCopy = !!col?.copy;
                             const hasRowPin = !!rowPinning;
                             const hasCellItems = col?.columnCellContextMenuItems && col.columnCellContextMenuItems.length > 0;
                             const hasEdit = !!col?.editable && !col?.render && !!onEdit;
-                            if (!hasCopy && !hasRowPin && !hasCellItems && !hasEdit) return;
+                            if (!hasCopy && !hasRowPin && !hasCellItems && !hasEdit)
+                              return;
                             setCellContextMenu({
                               x: Math.min(touch.clientX, window.innerWidth - 200),
                               y: Math.min(touch.clientY, window.innerHeight - 200),
@@ -2807,7 +3334,8 @@ function BoltTable({
                         onTouchCancel: cancelCellLongPress,
                         onClick: onRowClick ? (e) => {
                           const target = e.target;
-                          if (target.closest("input, button, a, select, textarea")) return;
+                          if (target.closest("input, button, a, select, textarea"))
+                            return;
                           const cell = target.closest("[data-bt-cell]");
                           if (!cell) return;
                           const rk = cell.dataset.rowKey;
@@ -2815,21 +3343,21 @@ function BoltTable({
                           for (let i = 0; i < displayData.length; i++) {
                             const row = displayData[i];
                             if (row == null) continue;
-                            if (getRowKey(row, i) === rk) {
+                            if (getSafeRowKey(row, i) === rk) {
                               onRowClick(row, i, e);
                               return;
                             }
                           }
                           for (let i = 0; i < pinnedTopRows.length; i++) {
                             if (pinnedTopRows[i] == null) continue;
-                            if (getRowKey(pinnedTopRows[i], i) === rk) {
+                            if (getSafeRowKey(pinnedTopRows[i], i) === rk) {
                               onRowClick(pinnedTopRows[i], i, e);
                               return;
                             }
                           }
                           for (let i = 0; i < pinnedBottomRows.length; i++) {
                             if (pinnedBottomRows[i] == null) continue;
-                            if (getRowKey(pinnedBottomRows[i], i) === rk) {
+                            if (getSafeRowKey(pinnedBottomRows[i], i) === rk) {
                               onRowClick(pinnedBottomRows[i], i, e);
                               return;
                             }
@@ -2939,7 +3467,11 @@ function BoltTable({
                                             });
                                           }
                                         },
-                                        style: { cursor: "pointer", accentColor, backgroundColor: "#94A3B8" }
+                                        style: {
+                                          cursor: "pointer",
+                                          accentColor,
+                                          backgroundColor: "#94A3B8"
+                                        }
                                       }
                                     )
                                   },
@@ -2999,7 +3531,10 @@ function BoltTable({
                                   filterValue: columnFilters[column.key] ?? "",
                                   onFilter: handleColumnFilter,
                                   onClearFilter: handleClearFilter,
-                                  customContextMenuItems: column.columnHeaderContextMenuItems ? [...columnContextMenuItems ?? [], ...column.columnHeaderContextMenuItems] : columnContextMenuItems,
+                                  customContextMenuItems: column.columnHeaderContextMenuItems ? [
+                                    ...columnContextMenuItems ?? [],
+                                    ...column.columnHeaderContextMenuItems
+                                  ] : columnContextMenuItems,
                                   disabledFilters,
                                   headerGridRow: leafGridRow,
                                   headerHeight: leafHeight,
@@ -3051,14 +3586,14 @@ function BoltTable({
                             TableBody_default,
                             {
                               data: displayData,
-                              orderedColumns: freshOrderedColumns,
+                              orderedColumns: virtualizedColumns,
                               rowVirtualizer,
                               columnOffsets,
                               styles,
                               classNames,
                               rowSelection: !showShimmer ? rowSelection : void 0,
                               normalizedSelectedKeys,
-                              getRowKey,
+                              getRowKey: getSafeRowKey,
                               getRawRowKey,
                               expandable: !showShimmer ? expandable : void 0,
                               resolvedExpandedKeys,
@@ -3079,7 +3614,9 @@ function BoltTable({
                               bodyGridRow: hasColumnGroups ? 3 : 2,
                               onEdit,
                               editingCell,
-                              onEditComplete: handleEditComplete
+                              onEditComplete: handleEditComplete,
+                              enableDynamicRowHeight,
+                              onRowHeightChange: handleRowHeightChange
                             }
                           )
                         ]
@@ -3109,39 +3646,53 @@ function BoltTable({
                 ...styles.pagination
               },
               children: [
-                /* @__PURE__ */ jsx5("div", { style: { display: "flex", flex: "1 1 0%", alignItems: "center" }, children: (() => {
-                  const rangeStart = total > 0 ? (currentPage - 1) * pageSize + 1 : 0;
-                  const rangeEnd = Math.min(currentPage * pageSize, total);
-                  return typeof pagination === "object" && pagination?.showTotal ? /* @__PURE__ */ jsxs5(
-                    "span",
-                    {
-                      className: classNames.paginationInfo ?? "",
-                      style: { color: "GrayText", fontSize: 12, ...styles.paginationInfo },
-                      children: [
-                        "Showing",
-                        " ",
-                        pagination.showTotal(total, [rangeStart, rangeEnd]),
-                        " of",
-                        " ",
-                        total,
-                        " items"
-                      ]
-                    }
-                  ) : /* @__PURE__ */ jsxs5(
-                    "span",
-                    {
-                      className: classNames.paginationInfo ?? "",
-                      style: { color: "GrayText", fontSize: 12, ...styles.paginationInfo },
-                      children: [
-                        rangeStart,
-                        "\u2013",
-                        rangeEnd,
-                        " of ",
-                        total
-                      ]
-                    }
-                  );
-                })() }),
+                /* @__PURE__ */ jsx5(
+                  "div",
+                  {
+                    style: { display: "flex", flex: "1 1 0%", alignItems: "center" },
+                    children: (() => {
+                      const rangeStart = total > 0 ? (currentPage - 1) * pageSize + 1 : 0;
+                      const rangeEnd = Math.min(currentPage * pageSize, total);
+                      return typeof pagination === "object" && pagination?.showTotal ? /* @__PURE__ */ jsxs5(
+                        "span",
+                        {
+                          className: classNames.paginationInfo ?? "",
+                          style: {
+                            color: "GrayText",
+                            fontSize: 12,
+                            ...styles.paginationInfo
+                          },
+                          children: [
+                            "Showing",
+                            " ",
+                            pagination.showTotal(total, [rangeStart, rangeEnd]),
+                            " of",
+                            " ",
+                            total,
+                            " items"
+                          ]
+                        }
+                      ) : /* @__PURE__ */ jsxs5(
+                        "span",
+                        {
+                          className: classNames.paginationInfo ?? "",
+                          style: {
+                            color: "GrayText",
+                            fontSize: 12,
+                            ...styles.paginationInfo
+                          },
+                          children: [
+                            rangeStart,
+                            "\u2013",
+                            rangeEnd,
+                            " of ",
+                            total
+                          ]
+                        }
+                      );
+                    })()
+                  }
+                ),
                 /* @__PURE__ */ jsxs5(
                   "div",
                   {
@@ -3424,9 +3975,7 @@ function BoltTable({
         (c) => c.key === cellContextMenu.columnKey
       );
       const isPinnedTop = pinnedTopKeySet.has(cellContextMenu.rowKey);
-      const isPinnedBottom = pinnedBottomKeySet.has(
-        cellContextMenu.rowKey
-      );
+      const isPinnedBottom = pinnedBottomKeySet.has(cellContextMenu.rowKey);
       const hasCopy = !!menuCol?.copy;
       const hasRowPin = !!rowPinning;
       const hasEdit = !!menuCol?.editable && !menuCol?.render && !!onEdit;
@@ -3439,7 +3988,7 @@ function BoltTable({
       ];
       for (let i = 0; i < allRows.length; i++) {
         if (allRows[i] == null) continue;
-        const rk = getRowKey(allRows[i], i);
+        const rk = getSafeRowKey(allRows[i], i);
         if (rk === cellContextMenu.rowKey) {
           menuRecord = allRows[i];
           menuRowIndex = i;
@@ -3641,7 +4190,20 @@ function BoltTable({
                       setCellContextMenu(null);
                     },
                     children: [
-                      item.icon && /* @__PURE__ */ jsx5("span", { style: { display: "flex", width: 14, height: 14, alignItems: "center", justifyContent: "center", flexShrink: 0 }, children: item.icon }),
+                      item.icon && /* @__PURE__ */ jsx5(
+                        "span",
+                        {
+                          style: {
+                            display: "flex",
+                            width: 14,
+                            height: 14,
+                            alignItems: "center",
+                            justifyContent: "center",
+                            flexShrink: 0
+                          },
+                          children: item.icon
+                        }
+                      ),
                       item.label
                     ]
                   },