@alaarab/ogrid-core 2.1.3 → 2.1.4

package/dist/esm/index.js

@@ -1,54 +1,1426 @@
-export { toUserLike, isInSelectionRange, normalizeSelectionRange, } from './types';
-// Utils — exportToCsv
-export { escapeCsvValue, buildCsvHeader, buildCsvRows, exportToCsv, triggerCsvDownload, } from './utils';
-// Utils — cellValue, columnUtils
-export { getCellValue } from './utils';
-export { flattenColumns, buildHeaderRows } from './utils';
-// Utils — ogridHelpers
-export { isFilterConfig, getFilterField, mergeFilter, deriveFilterOptionsFromData, getMultiSelectFilterFields, } from './utils';
-// Utils — statusBarHelpers, dataGridStatusBar
-export { getStatusBarParts } from './utils';
-export { getDataGridStatusBarConfig } from './utils';
-// Utils — paginationHelpers
-export { getPaginationViewModel, PAGE_SIZE_OPTIONS, MAX_PAGE_BUTTONS, } from './utils';
-// Utils — gridContextMenuHelpers
-export { GRID_CONTEXT_MENU_ITEMS, COLUMN_HEADER_MENU_ITEMS, getContextMenuHandlers, getColumnHeaderMenuItems, formatShortcut, } from './utils';
-// Utils — valueParsers
-export { parseValue, numberParser, currencyParser, dateParser, emailParser, booleanParser, } from './utils';
-// Utils — aggregationUtils
-export { computeAggregations } from './utils';
-// Utils — clientSideData
-export { processClientSideData } from './utils';
-// Utils — gridRowComparator
-export { areGridRowPropsEqual, isRowInRange } from './utils';
-// Utils — columnReorder
-export { getPinStateForColumn, reorderColumnArray, calculateDropTarget, } from './utils';
-// Utils — virtualScroll
-export { computeVisibleRange, computeTotalHeight, getScrollTopForRow, } from './utils';
-// Utils — dataGridViewModel
-export { getHeaderFilterConfig, getCellRenderDescriptor, resolveCellDisplayContent, resolveCellStyle, buildInlineEditorProps, buildPopoverEditorProps, } from './utils';
-// Utils — debounce, dom
-export { debounce } from './utils';
-export { measureRange, injectGlobalStyles } from './utils';
-// Utils — sortHelpers
-export { computeNextSortState } from './utils';
-// Utils — columnAutosize
-export { measureColumnContentWidth, AUTOSIZE_EXTRA_PX, AUTOSIZE_MAX_PX } from './utils';
-// Utils — keyboardNavigation
-export { findCtrlArrowTarget, computeTabNavigation, computeArrowNavigation, applyCellDeletion } from './utils';
-// Utils — selectionHelpers
-export { rangesEqual, clampSelectionToBounds, computeAutoScrollSpeed, applyRangeRowSelection, computeRowSelectionState } from './utils';
-// Utils — clipboardHelpers
-export { formatCellValueForTsv, formatSelectionAsTsv, parseTsvClipboard, applyPastedValues, applyCutClear, } from './utils';
-// Utils — fillHelpers
-export { applyFillValues } from './utils';
-// Utils — undoRedoStack
-export { UndoRedoStack } from './utils';
-// Utils — validation
-export { validateColumns, validateRowIds } from './utils';
-// Constants — layout
-export { CHECKBOX_COLUMN_WIDTH, ROW_NUMBER_COLUMN_WIDTH, DEFAULT_MIN_COLUMN_WIDTH, CELL_PADDING, GRID_BORDER_RADIUS, } from './constants';
-// Constants — timing
-export { DEFAULT_DEBOUNCE_MS, PEOPLE_SEARCH_DEBOUNCE_MS, SIDEBAR_TRANSITION_MS, } from './constants';
-// Constants — zIndex
-export { Z_INDEX } from './constants';
+// src/types/dataGridTypes.ts
+function toUserLike(u) {
+  if (!u) return void 0;
+  return {
+    id: u.id,
+    displayName: u.displayName,
+    email: "email" in u && u.email ? u.email : u.mail || u.userPrincipalName || "",
+    photo: u.photo
+  };
+}
+function isInSelectionRange(range, row, col) {
+  const minR = Math.min(range.startRow, range.endRow);
+  const maxR = Math.max(range.startRow, range.endRow);
+  const minC = Math.min(range.startCol, range.endCol);
+  const maxC = Math.max(range.startCol, range.endCol);
+  return row >= minR && row <= maxR && col >= minC && col <= maxC;
+}
+function normalizeSelectionRange(range) {
+  return {
+    startRow: Math.min(range.startRow, range.endRow),
+    endRow: Math.max(range.startRow, range.endRow),
+    startCol: Math.min(range.startCol, range.endCol),
+    endCol: Math.max(range.startCol, range.endCol)
+  };
+}
+
+// src/utils/exportToCsv.ts
+function escapeCsvValue(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  const s = String(value);
+  if (s.includes(",") || s.includes('"') || s.includes("\n")) {
+    return `"${s.replace(/"/g, '""')}"`;
+  }
+  return s;
+}
+function buildCsvHeader(columns) {
+  return columns.map((c) => escapeCsvValue(c.name)).join(",");
+}
+function buildCsvRows(items, columns, getValue) {
+  return items.map(
+    (item) => columns.map((c) => escapeCsvValue(getValue(item, c.columnId))).join(",")
+  );
+}
+function exportToCsv(items, columns, getValue, filename) {
+  const header = buildCsvHeader(columns);
+  const rows = buildCsvRows(items, columns, getValue);
+  const csv = [header, ...rows].join("\n");
+  triggerCsvDownload(csv, filename ?? `export_${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.csv`);
+}
+function triggerCsvDownload(csvContent, filename) {
+  const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  try {
+    link.setAttribute("href", url);
+    link.setAttribute("download", filename);
+    link.style.visibility = "hidden";
+    document.body.appendChild(link);
+    link.click();
+  } finally {
+    try {
+      document.body.removeChild(link);
+    } catch {
+    }
+    URL.revokeObjectURL(url);
+  }
+}
+
+// src/utils/cellValue.ts
+function getCellValue(item, col) {
+  if (col.valueGetter) return col.valueGetter(item);
+  return item[col.columnId];
+}
+
+// src/utils/columnUtils.ts
+function isColumnGroupDef(c) {
+  return "children" in c && Array.isArray(c.children);
+}
+function flattenColumns(columns) {
+  const result = [];
+  for (const c of columns) {
+    if (isColumnGroupDef(c)) {
+      result.push(...flattenColumns(c.children));
+    } else {
+      result.push(c);
+    }
+  }
+  return result;
+}
+function buildHeaderRows(columns, visibleColumns) {
+  function getMaxDepth(cols, depth) {
+    let max = depth;
+    for (const c of cols) {
+      if (isColumnGroupDef(c)) {
+        max = Math.max(max, getMaxDepth(c.children, depth + 1));
+      }
+    }
+    return max;
+  }
+  const maxDepth = getMaxDepth(columns, 0);
+  if (maxDepth === 0) {
+    const row = [];
+    for (const c of columns) {
+      if (!isColumnGroupDef(c)) {
+        if (visibleColumns && !visibleColumns.has(c.columnId)) continue;
+        row.push({
+          label: c.name,
+          colSpan: 1,
+          isGroup: false,
+          columnDef: c,
+          depth: 0
+        });
+      }
+    }
+    return [row];
+  }
+  const totalRows = maxDepth + 1;
+  const rows = Array.from({ length: totalRows }, () => []);
+  const leafCountCache = /* @__PURE__ */ new Map();
+  function countVisibleLeaves(cols) {
+    const cached = leafCountCache.get(cols);
+    if (cached !== void 0) return cached;
+    let count = 0;
+    for (const c of cols) {
+      if (isColumnGroupDef(c)) {
+        count += countVisibleLeaves(c.children);
+      } else {
+        if (!visibleColumns || visibleColumns.has(c.columnId)) {
+          count++;
+        }
+      }
+    }
+    leafCountCache.set(cols, count);
+    return count;
+  }
+  function walk(cols, depth) {
+    for (const c of cols) {
+      if (isColumnGroupDef(c)) {
+        const leafCount = countVisibleLeaves(c.children);
+        if (leafCount === 0) continue;
+        rows[depth].push({
+          label: c.headerName,
+          colSpan: leafCount,
+          isGroup: true,
+          depth
+        });
+        walk(c.children, depth + 1);
+      } else {
+        if (visibleColumns && !visibleColumns.has(c.columnId)) continue;
+        rows[depth].push({
+          label: c.name,
+          colSpan: 1,
+          isGroup: false,
+          columnDef: c,
+          depth
+        });
+      }
+    }
+  }
+  walk(columns, 0);
+  return rows.filter((row) => row.length > 0);
+}
+
+// src/utils/ogridHelpers.ts
+function isFilterConfig(val) {
+  return val != null && typeof val === "object" && "type" in val;
+}
+function getFilterField(col) {
+  const f = isFilterConfig(col.filterable) ? col.filterable : null;
+  return f?.filterField ?? col.columnId;
+}
+function mergeFilter(prev, key, value) {
+  const isEmpty = value === void 0 || value.type === "text" && value.value.trim() === "" || value.type === "multiSelect" && value.value.length === 0 || value.type === "date" && !value.value.from && !value.value.to || value.type === "people" && !value.value;
+  if (isEmpty) {
+    const { [key]: _, ...rest } = prev;
+    return rest;
+  }
+  return { ...prev, [key]: value };
+}
+function deriveFilterOptionsFromData(items, columns) {
+  const filterCols = [];
+  for (let i = 0; i < columns.length; i++) {
+    const col = columns[i];
+    const f = isFilterConfig(col.filterable) ? col.filterable : null;
+    if (f?.type === "multiSelect") {
+      filterCols.push({ col, field: getFilterField(col) });
+    }
+  }
+  if (filterCols.length === 0) return {};
+  const valueSets = /* @__PURE__ */ new Map();
+  for (let i = 0; i < filterCols.length; i++) {
+    valueSets.set(filterCols[i].field, /* @__PURE__ */ new Set());
+  }
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    for (let j = 0; j < filterCols.length; j++) {
+      const v = getCellValue(item, filterCols[j].col);
+      const set = valueSets.get(filterCols[j].field);
+      if (v != null && v !== "" && set) set.add(String(v));
+    }
+  }
+  const out = {};
+  for (let i = 0; i < filterCols.length; i++) {
+    const set = valueSets.get(filterCols[i].field);
+    out[filterCols[i].field] = set ? Array.from(set).sort() : [];
+  }
+  return out;
+}
+function getMultiSelectFilterFields(columns) {
+  const fields = [];
+  for (const col of columns) {
+    const f = isFilterConfig(col.filterable) ? col.filterable : null;
+    if (f?.type === "multiSelect") fields.push(getFilterField(col));
+  }
+  return fields;
+}
+
+// src/utils/statusBarHelpers.ts
+function getStatusBarParts(input) {
+  const { totalCount, filteredCount, selectedCount, selectedCellCount, aggregation, suppressRowCount } = input;
+  const parts = [];
+  if (!suppressRowCount) {
+    parts.push({ key: "total", label: "Rows:", value: totalCount });
+  }
+  if (filteredCount !== void 0 && filteredCount !== totalCount) {
+    parts.push({ key: "filtered", label: "Filtered:", value: filteredCount });
+  }
+  if (selectedCount !== void 0 && selectedCount > 0) {
+    parts.push({ key: "selected", label: "Selected:", value: selectedCount });
+  }
+  if (selectedCellCount !== void 0 && selectedCellCount > 1) {
+    parts.push({ key: "cells", label: "Cells:", value: selectedCellCount });
+  }
+  if (aggregation) {
+    parts.push({ key: "sum", label: "Sum:", value: aggregation.sum });
+    parts.push({ key: "avg", label: "Avg:", value: Math.round(aggregation.avg * 100) / 100 });
+    parts.push({ key: "min", label: "Min:", value: aggregation.min });
+    parts.push({ key: "max", label: "Max:", value: aggregation.max });
+    parts.push({ key: "count", label: "Count:", value: aggregation.count });
+  }
+  return parts;
+}
+
+// src/utils/dataGridStatusBar.ts
+function getDataGridStatusBarConfig(statusBar, itemsLength, selectedCount, filteredCount) {
+  if (!statusBar) return null;
+  if (typeof statusBar === "object") return statusBar;
+  return {
+    totalCount: itemsLength,
+    selectedCount: selectedCount > 0 ? selectedCount : void 0,
+    filteredCount: filteredCount !== void 0 && filteredCount !== itemsLength ? filteredCount : void 0
+  };
+}
+
+// src/utils/paginationHelpers.ts
+var PAGE_SIZE_OPTIONS = [10, 25, 50, 100];
+function ensurePageSizeInOptions(pageSize, options) {
+  if (options.includes(pageSize)) return options;
+  return [...options, pageSize].sort((a, b) => a - b);
+}
+var MAX_PAGE_BUTTONS = 5;
+function getPaginationViewModel(currentPage, pageSize, totalCount, options) {
+  if (totalCount <= 0) return null;
+  const maxPageButtons = options?.maxPageButtons ?? MAX_PAGE_BUTTONS;
+  const totalPages = Math.ceil(totalCount / pageSize);
+  let pageNumbers;
+  let showStartEllipsis;
+  let showEndEllipsis;
+  if (totalPages <= maxPageButtons) {
+    pageNumbers = [];
+    for (let i = 1; i <= totalPages; i++) pageNumbers.push(i);
+    showStartEllipsis = false;
+    showEndEllipsis = false;
+  } else {
+    let start = Math.max(1, currentPage - 2);
+    let end = Math.min(totalPages, currentPage + 2);
+    if (end - start + 1 < maxPageButtons) {
+      if (start === 1) end = Math.min(totalPages, start + maxPageButtons - 1);
+      else if (end === totalPages) start = Math.max(1, end - maxPageButtons + 1);
+    }
+    pageNumbers = [];
+    for (let i = start; i <= end; i++) pageNumbers.push(i);
+    showStartEllipsis = start > 1;
+    showEndEllipsis = end < totalPages;
+  }
+  const startItem = Math.max(1, (currentPage - 1) * pageSize + 1);
+  const endItem = Math.min(currentPage * pageSize, totalCount);
+  return {
+    totalPages,
+    pageNumbers,
+    showStartEllipsis,
+    showEndEllipsis,
+    startItem,
+    endItem,
+    pageSizeOptions: ensurePageSizeInOptions(pageSize, options?.pageSizeOptions ?? PAGE_SIZE_OPTIONS)
+  };
+}
+
+// src/utils/gridContextMenuHelpers.ts
+var GRID_CONTEXT_MENU_ITEMS = [
+  { id: "undo", label: "Undo", shortcut: "Ctrl+Z" },
+  { id: "redo", label: "Redo", shortcut: "Ctrl+Y" },
+  { id: "copy", label: "Copy", shortcut: "Ctrl+C", disabledWhenNoSelection: true, dividerBefore: true },
+  { id: "cut", label: "Cut", shortcut: "Ctrl+X", disabledWhenNoSelection: true },
+  { id: "paste", label: "Paste", shortcut: "Ctrl+V" },
+  { id: "selectAll", label: "Select all", shortcut: "Ctrl+A", dividerBefore: true }
+];
+function formatShortcut(shortcut) {
+  const isMac = typeof navigator !== "undefined" && /Mac|iPhone|iPad|iPod/.test(navigator.userAgent);
+  return isMac ? shortcut.replace("Ctrl", "\u2318") : shortcut;
+}
+function getContextMenuHandlers(props) {
+  const { onCopy, onCut, onPaste, onSelectAll, onUndo, onRedo, onClose } = props;
+  return {
+    undo: () => {
+      onUndo();
+      onClose();
+    },
+    redo: () => {
+      onRedo();
+      onClose();
+    },
+    copy: () => {
+      onCopy();
+      onClose();
+    },
+    cut: () => {
+      onCut();
+      onClose();
+    },
+    paste: () => {
+      onPaste();
+      onClose();
+    },
+    selectAll: () => {
+      onSelectAll();
+      onClose();
+    }
+  };
+}
+var COLUMN_HEADER_MENU_ITEMS = [
+  { id: "pinLeft", label: "Pin left" },
+  { id: "pinRight", label: "Pin right" },
+  { id: "unpin", label: "Unpin" }
+];
+function getColumnHeaderMenuItems(input) {
+  const { canPinLeft, canPinRight, canUnpin, currentSort, isSortable = true, isResizable = true } = input;
+  const items = [];
+  items.push(
+    { id: "pinLeft", label: "Pin left", disabled: !canPinLeft },
+    { id: "pinRight", label: "Pin right", disabled: !canPinRight },
+    { id: "unpin", label: "Unpin", disabled: !canUnpin, divider: isSortable || isResizable }
+  );
+  if (isSortable) {
+    if (!currentSort) {
+      items.push(
+        { id: "sortAsc", label: "Sort ascending" },
+        { id: "sortDesc", label: "Sort descending", divider: isResizable }
+      );
+    } else {
+      const oppositeSort = currentSort === "asc" ? "desc" : "asc";
+      const oppositeLabel = currentSort === "asc" ? "Sort descending" : "Sort ascending";
+      items.push(
+        { id: `sort${oppositeSort === "asc" ? "Asc" : "Desc"}`, label: oppositeLabel },
+        { id: "clearSort", label: "Clear sort", divider: isResizable }
+      );
+    }
+  }
+  if (isResizable) {
+    items.push(
+      { id: "autosizeThis", label: "Autosize this column" },
+      { id: "autosizeAll", label: "Autosize all columns" }
+    );
+  }
+  return items;
+}
+
+// src/utils/valueParsers.ts
+function parseValue(newValue, oldValue, item, col) {
+  if (col.valueParser) {
+    const params = {
+      newValue,
+      oldValue,
+      data: item,
+      column: col
+    };
+    const parsed = col.valueParser(params);
+    if (parsed === void 0) {
+      return { valid: false, value: void 0 };
+    }
+    return { valid: true, value: parsed };
+  }
+  if (col.cellEditor === "select" && col.cellEditorParams?.values != null && Array.isArray(col.cellEditorParams.values)) {
+    const allowedValues = col.cellEditorParams.values;
+    const strValue = typeof newValue === "string" ? newValue : String(newValue ?? "");
+    if (strValue === "") {
+      return { valid: true, value: "" };
+    }
+    const match = allowedValues.find(
+      (v) => String(v).toLowerCase() === strValue.toLowerCase()
+    );
+    if (match !== void 0) {
+      return { valid: true, value: match };
+    }
+    return { valid: false, value: void 0 };
+  }
+  const colType = col.type;
+  if (colType === "date") {
+    const parsed = dateParser({ newValue});
+    return parsed === void 0 ? { valid: false, value: void 0 } : { valid: true, value: parsed };
+  }
+  if (colType === "boolean") {
+    const parsed = booleanParser({ newValue});
+    return parsed === void 0 ? { valid: false, value: void 0 } : { valid: true, value: parsed };
+  }
+  if (colType === "numeric") {
+    const parsed = numberParser({ newValue});
+    return parsed === void 0 ? { valid: false, value: void 0 } : { valid: true, value: parsed };
+  }
+  return { valid: true, value: newValue };
+}
+function numberParser(params) {
+  const { newValue } = params;
+  if (newValue === "" || newValue == null) return null;
+  const str = String(newValue).replace(/[\s,]/g, "");
+  const num = Number(str);
+  return Number.isNaN(num) ? void 0 : num;
+}
+function currencyParser(params) {
+  const { newValue } = params;
+  if (newValue === "" || newValue == null) return null;
+  const str = String(newValue).replace(/[$\u20AC\u00A3\u00A5]/g, "").replace(/[\s,]/g, "");
+  const num = Number(str);
+  return Number.isNaN(num) ? void 0 : num;
+}
+function dateParser(params) {
+  const { newValue } = params;
+  if (newValue === "" || newValue == null) return null;
+  const str = String(newValue).trim();
+  const date = new Date(str);
+  if (Number.isNaN(date.getTime())) return void 0;
+  return date.toISOString();
+}
+function emailParser(params) {
+  const { newValue } = params;
+  if (newValue === "" || newValue == null) return null;
+  const str = String(newValue).trim();
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str) ? str : void 0;
+}
+function booleanParser(params) {
+  const { newValue } = params;
+  if (newValue === "" || newValue == null) return null;
+  const str = String(newValue).trim().toLowerCase();
+  if (["true", "yes", "1"].includes(str)) return true;
+  if (["false", "no", "0"].includes(str)) return false;
+  return void 0;
+}
+
+// src/utils/aggregationUtils.ts
+function computeAggregations(items, visibleCols, selectionRange) {
+  if (!selectionRange) return null;
+  const norm = normalizeSelectionRange(selectionRange);
+  let totalCells = 0;
+  let sum = 0;
+  let min = Infinity;
+  let max = -Infinity;
+  let count = 0;
+  for (let r = norm.startRow; r <= norm.endRow; r++) {
+    for (let c = norm.startCol; c <= norm.endCol; c++) {
+      if (r >= items.length || c >= visibleCols.length) continue;
+      totalCells++;
+      const item = items[r];
+      const col = visibleCols[c];
+      const raw = getCellValue(item, col);
+      const num = typeof raw === "number" ? raw : Number(raw);
+      if (!isNaN(num) && isFinite(num)) {
+        sum += num;
+        if (num < min) min = num;
+        if (num > max) max = num;
+        count++;
+      }
+    }
+  }
+  if (totalCells < 2 || count === 0) return null;
+  return {
+    sum,
+    avg: sum / count,
+    min,
+    max,
+    count
+  };
+}
+
+// src/utils/clientSideData.ts
+var columnMapCache = /* @__PURE__ */ new WeakMap();
+function processClientSideData(data, columns, filters, sortBy, sortDirection) {
+  let columnMap = columnMapCache.get(columns);
+  if (!columnMap) {
+    columnMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < columns.length; i++) {
+      columnMap.set(columns[i].columnId, columns[i]);
+    }
+    columnMapCache.set(columns, columnMap);
+  }
+  const predicates = [];
+  for (let i = 0; i < columns.length; i++) {
+    const col = columns[i];
+    const filterKey = getFilterField(col);
+    const val = filters[filterKey];
+    if (!val) continue;
+    switch (val.type) {
+      case "multiSelect":
+        if (val.value.length > 0) {
+          const allowedSet = new Set(val.value);
+          predicates.push((r) => allowedSet.has(String(getCellValue(r, col))));
+        }
+        break;
+      case "text": {
+        const trimmed = val.value.trim();
+        if (trimmed) {
+          const lower = trimmed.toLowerCase();
+          predicates.push((r) => String(getCellValue(r, col) ?? "").toLowerCase().includes(lower));
+        }
+        break;
+      }
+      case "people": {
+        const email = val.value.email.toLowerCase();
+        predicates.push((r) => String(getCellValue(r, col) ?? "").toLowerCase() === email);
+        break;
+      }
+      case "date": {
+        const dv = val.value;
+        const fromTs = dv.from ? (/* @__PURE__ */ new Date(dv.from + "T00:00:00")).getTime() : NaN;
+        const toTs = dv.to ? (/* @__PURE__ */ new Date(dv.to + "T23:59:59.999")).getTime() : NaN;
+        predicates.push((r) => {
+          const cellVal = getCellValue(r, col);
+          if (cellVal == null) return false;
+          const cellTs = new Date(String(cellVal)).getTime();
+          if (Number.isNaN(cellTs)) return false;
+          if (!Number.isNaN(fromTs) && cellTs < fromTs) return false;
+          if (!Number.isNaN(toTs) && cellTs > toTs) return false;
+          return true;
+        });
+        break;
+      }
+    }
+  }
+  const filtered = predicates.length > 0;
+  const rows = filtered ? data.filter((row) => {
+    for (let i = 0; i < predicates.length; i++) {
+      if (!predicates[i](row)) return false;
+    }
+    return true;
+  }) : data;
+  if (sortBy) {
+    const sortable = filtered ? rows : rows.slice();
+    const sortCol = columnMap.get(sortBy);
+    const compare = sortCol?.compare;
+    const dir = sortDirection === "asc" ? 1 : -1;
+    const isDateSort = sortCol?.type === "date";
+    if (isDateSort && !compare) {
+      const timestampCache = /* @__PURE__ */ new Map();
+      for (let i = 0; i < sortable.length; i++) {
+        const row = sortable[i];
+        const val = sortCol ? getCellValue(row, sortCol) : row[sortBy];
+        if (val == null) {
+          timestampCache.set(row, NaN);
+        } else {
+          const t = new Date(String(val)).getTime();
+          timestampCache.set(row, Number.isNaN(t) ? 0 : t);
+        }
+      }
+      sortable.sort((a, b) => {
+        const at = timestampCache.get(a) ?? NaN;
+        const bt = timestampCache.get(b) ?? NaN;
+        if (Number.isNaN(at) && Number.isNaN(bt)) return 0;
+        if (Number.isNaN(at)) return -1 * dir;
+        if (Number.isNaN(bt)) return 1 * dir;
+        return at === bt ? 0 : at > bt ? dir : -dir;
+      });
+    } else {
+      sortable.sort((a, b) => {
+        if (compare) return compare(a, b) * dir;
+        const av = sortCol ? getCellValue(a, sortCol) : a[sortBy];
+        const bv = sortCol ? getCellValue(b, sortCol) : b[sortBy];
+        if (av == null && bv == null) return 0;
+        if (av == null) return -1 * dir;
+        if (bv == null) return 1 * dir;
+        if (typeof av === "number" && typeof bv === "number")
+          return av === bv ? 0 : av > bv ? dir : -dir;
+        const as = String(av).toLowerCase();
+        const bs = String(bv).toLowerCase();
+        return as === bs ? 0 : as > bs ? dir : -dir;
+      });
+    }
+    return sortable;
+  }
+  return rows;
+}
+
+// src/utils/gridRowComparator.ts
+function isRowInRange(range, rowIndex) {
+  if (!range) return false;
+  const minR = Math.min(range.startRow, range.endRow);
+  const maxR = Math.max(range.startRow, range.endRow);
+  return rowIndex >= minR && rowIndex <= maxR;
+}
+function areGridRowPropsEqual(prev, next) {
+  if (prev.item !== next.item) return false;
+  if (prev.isSelected !== next.isSelected) return false;
+  if (prev.hasCheckboxCol !== next.hasCheckboxCol) return false;
+  if (prev.visibleCols !== next.visibleCols) return false;
+  if (prev.columnMeta !== next.columnMeta) return false;
+  if (prev.cellClassMap !== next.cellClassMap) return false;
+  if (prev.columnLayouts !== next.columnLayouts) return false;
+  const ri = prev.rowIndex;
+  if (prev.editingRowId !== next.editingRowId) {
+    if (prev.editingRowId === prev.rowId || next.editingRowId === next.rowId) return false;
+  }
+  const prevActive = prev.activeCell?.rowIndex === ri;
+  const nextActive = next.activeCell?.rowIndex === ri;
+  if (prevActive !== nextActive) return false;
+  if (prevActive && nextActive && prev.activeCell?.columnIndex !== next.activeCell?.columnIndex) return false;
+  const prevInSel = isRowInRange(prev.selectionRange, ri);
+  const nextInSel = isRowInRange(next.selectionRange, ri);
+  if (prevInSel !== nextInSel) return false;
+  if (prevInSel && nextInSel) {
+    if (prev.selectionRange?.startCol !== next.selectionRange?.startCol || prev.selectionRange?.endCol !== next.selectionRange?.endCol) return false;
+  }
+  const prevIsEnd = prev.selectionRange?.endRow === ri;
+  const nextIsEnd = next.selectionRange?.endRow === ri;
+  if (prevIsEnd !== nextIsEnd) return false;
+  if ((prevIsEnd || nextIsEnd) && prev.isDragging !== next.isDragging) return false;
+  if (prev.cutRange !== next.cutRange) {
+    if (isRowInRange(prev.cutRange, ri) || isRowInRange(next.cutRange, ri)) return false;
+  }
+  if (prev.copyRange !== next.copyRange) {
+    if (isRowInRange(prev.copyRange, ri) || isRowInRange(next.copyRange, ri)) return false;
+  }
+  return true;
+}
+
+// src/utils/columnReorder.ts
+function getPinStateForColumn(columnId, pinnedColumns) {
+  if (!pinnedColumns) return "unpinned";
+  if (pinnedColumns.left?.includes(columnId)) return "left";
+  if (pinnedColumns.right?.includes(columnId)) return "right";
+  return "unpinned";
+}
+function reorderColumnArray(order, columnId, targetIndex) {
+  const filtered = order.filter((id) => id !== columnId);
+  const clampedIndex = Math.max(0, Math.min(targetIndex, filtered.length));
+  const result = [...filtered];
+  result.splice(clampedIndex, 0, columnId);
+  return result;
+}
+function calculateDropTarget(params) {
+  const { mouseX, columnOrder, draggedColumnId, draggedPinState, tableElement, pinnedColumns } = params;
+  const headerCells = tableElement.querySelectorAll("[data-column-id]");
+  if (headerCells.length === 0) return null;
+  const targets = [];
+  headerCells.forEach((cell) => {
+    const colId = cell.getAttribute("data-column-id");
+    if (!colId) return;
+    const pinState = getPinStateForColumn(colId, pinnedColumns);
+    if (pinState !== draggedPinState) return;
+    const rect = cell.getBoundingClientRect();
+    const orderIndex = columnOrder.indexOf(colId);
+    if (orderIndex === -1) return;
+    targets.push({
+      columnId: colId,
+      left: rect.left,
+      right: rect.right,
+      midX: rect.left + rect.width / 2,
+      orderIndex
+    });
+  });
+  if (targets.length === 0) return null;
+  targets.sort((a, b) => a.left - b.left);
+  let targetIndex;
+  let indicatorX;
+  if (mouseX <= targets[0].midX) {
+    targetIndex = targets[0].orderIndex;
+    indicatorX = targets[0].left;
+  } else if (mouseX >= targets[targets.length - 1].midX) {
+    const last = targets[targets.length - 1];
+    targetIndex = last.orderIndex + 1;
+    indicatorX = last.right;
+  } else {
+    let matchIndex = -1;
+    for (let i = 0; i < targets.length - 1; i++) {
+      if (mouseX >= targets[i].midX && mouseX < targets[i + 1].midX) {
+        matchIndex = i;
+        break;
+      }
+    }
+    if (matchIndex === -1) return null;
+    targetIndex = targets[matchIndex].orderIndex + 1;
+    indicatorX = targets[matchIndex].right;
+  }
+  const currentIndex = columnOrder.indexOf(draggedColumnId);
+  if (currentIndex === targetIndex || currentIndex + 1 === targetIndex) {
+    return { targetIndex, indicatorX: null };
+  }
+  return { targetIndex, indicatorX };
+}
+
+// src/utils/virtualScroll.ts
+function computeVisibleRange(scrollTop, rowHeight, containerHeight, totalRows, overscan = 5) {
+  if (totalRows <= 0 || rowHeight <= 0 || containerHeight <= 0) {
+    return { startIndex: 0, endIndex: 0, offsetTop: 0, offsetBottom: 0 };
+  }
+  const startIndex = Math.max(0, Math.floor(scrollTop / rowHeight) - overscan);
+  const endIndex = Math.min(
+    totalRows - 1,
+    Math.ceil((scrollTop + containerHeight) / rowHeight) + overscan
+  );
+  const offsetTop = startIndex * rowHeight;
+  const offsetBottom = Math.max(0, (totalRows - endIndex - 1) * rowHeight);
+  return { startIndex, endIndex, offsetTop, offsetBottom };
+}
+function computeTotalHeight(totalRows, rowHeight) {
+  return totalRows * rowHeight;
+}
+function getScrollTopForRow(rowIndex, rowHeight, containerHeight, align = "start") {
+  const rowTop = rowIndex * rowHeight;
+  switch (align) {
+    case "start":
+      return rowTop;
+    case "center":
+      return Math.max(0, rowTop - (containerHeight - rowHeight) / 2);
+    case "end":
+      return Math.max(0, rowTop - containerHeight + rowHeight);
+  }
+}
+
+// src/utils/dataGridViewModel.ts
+function getHeaderFilterConfig(col, input) {
+  const filterable = isFilterConfig(col.filterable) ? col.filterable : null;
+  const filterType = filterable?.type ?? "none";
+  const filterField = filterable?.filterField ?? col.columnId;
+  const sortable = col.sortable !== false;
+  const filterValue = input.filters[filterField];
+  const base = {
+    columnKey: col.columnId,
+    columnName: col.name,
+    filterType,
+    isSorted: input.sortBy === col.columnId,
+    isSortedDescending: input.sortBy === col.columnId && input.sortDirection === "desc",
+    onSort: sortable ? () => input.onColumnSort(col.columnId) : void 0
+  };
+  if (filterType === "text") {
+    return {
+      ...base,
+      textValue: filterValue?.type === "text" ? filterValue.value : "",
+      onTextChange: (v) => input.onFilterChange(filterField, v.trim() ? { type: "text", value: v } : void 0)
+    };
+  }
+  if (filterType === "people") {
+    return {
+      ...base,
+      selectedUser: filterValue?.type === "people" ? filterValue.value : void 0,
+      onUserChange: (u) => input.onFilterChange(filterField, u ? { type: "people", value: u } : void 0),
+      peopleSearch: input.peopleSearch
+    };
+  }
+  if (filterType === "multiSelect") {
+    return {
+      ...base,
+      options: input.filterOptions[filterField] ?? [],
+      isLoadingOptions: input.loadingFilterOptions[filterField] ?? false,
+      selectedValues: filterValue?.type === "multiSelect" ? filterValue.value : [],
+      onFilterChange: (values) => input.onFilterChange(filterField, values.length ? { type: "multiSelect", value: values } : void 0)
+    };
+  }
+  if (filterType === "date") {
+    return {
+      ...base,
+      dateValue: filterValue?.type === "date" ? filterValue.value : void 0,
+      onDateChange: (v) => input.onFilterChange(filterField, v ? { type: "date", value: v } : void 0)
+    };
+  }
+  return base;
+}
+function getCellRenderDescriptor(item, col, rowIndex, colIdx, input) {
+  const rowId = input.getRowId(item);
+  const globalColIndex = colIdx + input.colOffset;
+  const colEditable = col.editable === true || typeof col.editable === "function" && col.editable(item);
+  const canEditInline = input.editable !== false && !!colEditable && !!input.onCellValueChanged && typeof col.cellEditor !== "function";
+  const canEditPopup = input.editable !== false && !!colEditable && !!input.onCellValueChanged && typeof col.cellEditor === "function" && col.cellEditorPopup !== false;
+  const canEditAny = canEditInline || canEditPopup;
+  const isEditing = input.editingCell?.rowId === rowId && input.editingCell?.columnId === col.columnId;
+  const isActive = !input.isDragging && input.activeCell?.rowIndex === rowIndex && input.activeCell?.columnIndex === globalColIndex;
+  const isInRange = input.selectionRange != null && isInSelectionRange(input.selectionRange, rowIndex, colIdx);
+  const isInCutRange = input.cutRange != null && isInSelectionRange(input.cutRange, rowIndex, colIdx);
+  const isInCopyRange = input.copyRange != null && isInSelectionRange(input.copyRange, rowIndex, colIdx);
+  const isSelectionEndCell = !input.isDragging && input.copyRange == null && input.cutRange == null && input.selectionRange != null && rowIndex === input.selectionRange.endRow && colIdx === input.selectionRange.endCol;
+  const isPinned = col.pinned != null;
+  const pinnedSide = col.pinned ?? void 0;
+  const cellValue = getCellValue(item, col);
+  let mode = "display";
+  let editorType;
+  if (isEditing && canEditInline) {
+    mode = "editing-inline";
+    if (col.cellEditor === "text" || col.cellEditor === "select" || col.cellEditor === "checkbox" || col.cellEditor === "richSelect" || col.cellEditor === "date") {
+      editorType = col.cellEditor;
+    } else if (col.type === "date") {
+      editorType = "date";
+    } else if (col.type === "boolean") {
+      editorType = "checkbox";
+    } else {
+      editorType = "text";
+    }
+  } else if (isEditing && canEditPopup && typeof col.cellEditor === "function") {
+    mode = "editing-popover";
+  }
+  return {
+    mode,
+    editorType,
+    value: cellValue,
+    isActive,
+    isInRange,
+    isInCutRange,
+    isInCopyRange,
+    isSelectionEndCell,
+    canEditAny,
+    isPinned,
+    pinnedSide,
+    globalColIndex,
+    rowId,
+    rowIndex,
+    displayValue: cellValue
+  };
+}
+function resolveCellDisplayContent(col, item, displayValue) {
+  const c = col;
+  if (c.renderCell && typeof c.renderCell === "function") {
+    return c.renderCell(item);
+  }
+  if (col.valueFormatter) return col.valueFormatter(displayValue, item);
+  if (displayValue == null) return null;
+  if (col.type === "date") {
+    const d = new Date(String(displayValue));
+    if (!Number.isNaN(d.getTime())) return d.toLocaleDateString();
+  }
+  if (col.type === "boolean") {
+    return displayValue ? "True" : "False";
+  }
+  return String(displayValue);
+}
+function resolveCellStyle(col, item) {
+  const c = col;
+  if (!c.cellStyle) return void 0;
+  return typeof c.cellStyle === "function" ? c.cellStyle(item) : c.cellStyle;
+}
+function buildInlineEditorProps(item, col, descriptor, callbacks) {
+  return {
+    value: descriptor.value,
+    item,
+    column: col,
+    rowIndex: descriptor.rowIndex,
+    editorType: descriptor.editorType ?? "text",
+    onCommit: (newValue) => callbacks.commitCellEdit(item, col.columnId, descriptor.value, newValue, descriptor.rowIndex, descriptor.globalColIndex),
+    onCancel: () => callbacks.setEditingCell(null)
+  };
+}
+function buildPopoverEditorProps(item, col, descriptor, pendingEditorValue, callbacks) {
+  const oldValue = descriptor.value;
+  const displayValue = pendingEditorValue !== void 0 ? pendingEditorValue : oldValue;
+  return {
+    value: displayValue,
+    onValueChange: callbacks.setPendingEditorValue,
+    onCommit: () => {
+      const newValue = pendingEditorValue !== void 0 ? pendingEditorValue : oldValue;
+      callbacks.commitCellEdit(item, col.columnId, oldValue, newValue, descriptor.rowIndex, descriptor.globalColIndex);
+    },
+    onCancel: callbacks.cancelPopoverEdit,
+    item,
+    column: col,
+    cellEditorParams: col.cellEditorParams
+  };
+}
+
+// src/utils/debounce.ts
+function debounce(fn, delayMs) {
+  let timeoutId = null;
+  const debounced = ((...args) => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+      timeoutId = null;
+    }, delayMs);
+  });
+  debounced.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return debounced;
+}
+
+// src/utils/dom.ts
+function measureRange(container, range, colOffset) {
+  const startGlobalCol = range.startCol + colOffset;
+  const endGlobalCol = range.endCol + colOffset;
+  const topLeft = container.querySelector(
+    `[data-row-index="${range.startRow}"][data-col-index="${startGlobalCol}"]`
+  );
+  const bottomRight = container.querySelector(
+    `[data-row-index="${range.endRow}"][data-col-index="${endGlobalCol}"]`
+  );
+  if (!topLeft || !bottomRight) return null;
+  const cRect = container.getBoundingClientRect();
+  const tlRect = topLeft.getBoundingClientRect();
+  const brRect = bottomRight.getBoundingClientRect();
+  return {
+    top: tlRect.top - cRect.top,
+    left: tlRect.left - cRect.left,
+    width: brRect.right - tlRect.left,
+    height: brRect.bottom - tlRect.top
+  };
+}
+function injectGlobalStyles(id, css) {
+  if (typeof document === "undefined") return;
+  if (document.getElementById(id)) return;
+  const style = document.createElement("style");
+  style.id = id;
+  style.textContent = css;
+  document.head.appendChild(style);
+}
+
+// src/utils/sortHelpers.ts
+function computeNextSortState(current, columnKey, direction) {
+  if (direction === null) {
+    return { field: "", direction: "asc" };
+  } else if (direction) {
+    return { field: columnKey, direction };
+  } else {
+    return {
+      field: columnKey,
+      direction: current.field === columnKey && current.direction === "asc" ? "desc" : "asc"
+    };
+  }
+}
+
+// src/constants/layout.ts
+var CHECKBOX_COLUMN_WIDTH = 48;
+var ROW_NUMBER_COLUMN_WIDTH = 50;
+var DEFAULT_MIN_COLUMN_WIDTH = 80;
+var CELL_PADDING = 16;
+var GRID_BORDER_RADIUS = 6;
+
+// src/utils/columnAutosize.ts
+var AUTOSIZE_EXTRA_PX = 28;
+var AUTOSIZE_MAX_PX = 520;
+function measureColumnContentWidth(columnId, minWidth, container) {
+  const minW = minWidth ?? DEFAULT_MIN_COLUMN_WIDTH;
+  const root = container ?? document;
+  const cells = root.querySelectorAll(`[data-column-id="${columnId}"]`);
+  if (cells.length === 0) return minW;
+  let maxWidth = minW;
+  cells.forEach((cell) => {
+    const el = cell;
+    const label = el.querySelector?.("[data-header-label]");
+    if (label) {
+      maxWidth = Math.max(maxWidth, label.scrollWidth + AUTOSIZE_EXTRA_PX);
+    } else {
+      maxWidth = Math.max(maxWidth, el.scrollWidth);
+    }
+  });
+  return Math.min(AUTOSIZE_MAX_PX, Math.max(minW, Math.ceil(maxWidth)));
+}
+
+// src/utils/keyboardNavigation.ts
+function findCtrlArrowTarget(pos, edge, step, isEmpty) {
+  if (pos === edge) return pos;
+  const next = pos + step;
+  if (!isEmpty(pos) && !isEmpty(next)) {
+    let p2 = next;
+    while (p2 !== edge) {
+      if (isEmpty(p2 + step)) return p2;
+      p2 += step;
+    }
+    return edge;
+  }
+  let p = next;
+  while (p !== edge) {
+    if (!isEmpty(p)) return p;
+    p += step;
+  }
+  return edge;
+}
+function computeTabNavigation(rowIndex, columnIndex, maxRowIndex, maxColIndex, colOffset, shiftKey) {
+  let newRow = rowIndex;
+  let newCol = columnIndex;
+  if (shiftKey) {
+    if (columnIndex > colOffset) {
+      newCol = columnIndex - 1;
+    } else if (rowIndex > 0) {
+      newRow = rowIndex - 1;
+      newCol = maxColIndex;
+    }
+  } else {
+    if (columnIndex < maxColIndex) {
+      newCol = columnIndex + 1;
+    } else if (rowIndex < maxRowIndex) {
+      newRow = rowIndex + 1;
+      newCol = colOffset;
+    }
+  }
+  return { rowIndex: newRow, columnIndex: newCol };
+}
+function computeArrowNavigation(ctx) {
+  const {
+    direction,
+    rowIndex,
+    columnIndex,
+    dataColIndex,
+    colOffset,
+    maxRowIndex,
+    maxColIndex,
+    visibleColCount,
+    isCtrl,
+    isShift,
+    selectionRange,
+    isEmptyAt
+  } = ctx;
+  let newRowIndex = rowIndex;
+  let newColumnIndex = columnIndex;
+  if (direction === "ArrowDown") {
+    newRowIndex = isCtrl ? findCtrlArrowTarget(rowIndex, maxRowIndex, 1, (r) => isEmptyAt(r, Math.max(0, dataColIndex))) : Math.min(rowIndex + 1, maxRowIndex);
+  } else if (direction === "ArrowUp") {
+    newRowIndex = isCtrl ? findCtrlArrowTarget(rowIndex, 0, -1, (r) => isEmptyAt(r, Math.max(0, dataColIndex))) : Math.max(rowIndex - 1, 0);
+  } else if (direction === "ArrowRight") {
+    if (isCtrl && dataColIndex >= 0) {
+      newColumnIndex = findCtrlArrowTarget(dataColIndex, visibleColCount - 1, 1, (c) => isEmptyAt(rowIndex, c)) + colOffset;
+    } else {
+      newColumnIndex = Math.min(columnIndex + 1, maxColIndex);
+    }
+  } else {
+    if (isCtrl && dataColIndex >= 0) {
+      newColumnIndex = findCtrlArrowTarget(dataColIndex, 0, -1, (c) => isEmptyAt(rowIndex, c)) + colOffset;
+    } else {
+      newColumnIndex = Math.max(columnIndex - 1, colOffset);
+    }
+  }
+  const newDataColIndex = newColumnIndex - colOffset;
+  const isVertical = direction === "ArrowDown" || direction === "ArrowUp";
+  let newRange;
+  if (isShift) {
+    if (isVertical) {
+      newRange = normalizeSelectionRange({
+        startRow: selectionRange?.startRow ?? rowIndex,
+        startCol: selectionRange?.startCol ?? dataColIndex,
+        endRow: newRowIndex,
+        endCol: selectionRange?.endCol ?? dataColIndex
+      });
+    } else {
+      newRange = normalizeSelectionRange({
+        startRow: selectionRange?.startRow ?? rowIndex,
+        startCol: selectionRange?.startCol ?? dataColIndex,
+        endRow: selectionRange?.endRow ?? rowIndex,
+        endCol: newDataColIndex
+      });
+    }
+  } else {
+    newRange = {
+      startRow: newRowIndex,
+      startCol: newDataColIndex,
+      endRow: newRowIndex,
+      endCol: newDataColIndex
+    };
+  }
+  return { newRowIndex, newColumnIndex, newDataColIndex, newRange };
+}
+function applyCellDeletion(range, items, visibleCols) {
+  const norm = normalizeSelectionRange(range);
+  const events = [];
+  for (let r = norm.startRow; r <= norm.endRow; r++) {
+    for (let c = norm.startCol; c <= norm.endCol; c++) {
+      if (r >= items.length || c >= visibleCols.length) continue;
+      const item = items[r];
+      const col = visibleCols[c];
+      const colEditable = col.editable === true || typeof col.editable === "function" && col.editable(item);
+      if (!colEditable) continue;
+      const oldValue = getCellValue(item, col);
+      const result = parseValue("", oldValue, item, col);
+      if (!result.valid) continue;
+      events.push({
+        item,
+        columnId: col.columnId,
+        oldValue,
+        newValue: result.value,
+        rowIndex: r
+      });
+    }
+  }
+  return events;
+}
+
+// src/utils/selectionHelpers.ts
+function rangesEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return a.startRow === b.startRow && a.endRow === b.endRow && a.startCol === b.startCol && a.endCol === b.endCol;
+}
+function clampSelectionToBounds(range, maxRow, maxCol) {
+  if (maxRow < 0 || maxCol < 0) return null;
+  return {
+    startRow: Math.max(0, Math.min(range.startRow, maxRow)),
+    endRow: Math.max(0, Math.min(range.endRow, maxRow)),
+    startCol: Math.max(0, Math.min(range.startCol, maxCol)),
+    endCol: Math.max(0, Math.min(range.endCol, maxCol))
+  };
+}
+function computeAutoScrollSpeed(distance, edgePx = 40, minSpeed = 2, maxSpeed = 20) {
+  const t = Math.min(distance / edgePx, 1);
+  return minSpeed + t * (maxSpeed - minSpeed);
+}
+function applyRangeRowSelection(start, end, checked, items, getRowId, currentSelection) {
+  const next = new Set(currentSelection);
+  const lo = Math.min(start, end);
+  const hi = Math.max(start, end);
+  for (let i = lo; i <= hi; i++) {
+    if (i < items.length) {
+      const id = getRowId(items[i]);
+      if (checked) next.add(id);
+      else next.delete(id);
+    }
+  }
+  return next;
+}
+function computeRowSelectionState(selectedIds, items, getRowId) {
+  if (selectedIds.size === 0 || items.length === 0) {
+    return { allSelected: false, someSelected: false };
+  }
+  const allSelected = items.every((item) => selectedIds.has(getRowId(item)));
+  const someSelected = !allSelected && selectedIds.size > 0;
+  return { allSelected, someSelected };
+}
+
+// src/utils/clipboardHelpers.ts
+function formatCellValueForTsv(raw, formatted) {
+  const val = formatted != null && formatted !== "" ? formatted : raw;
+  if (val == null || val === "") return "";
+  try {
+    return String(val).replace(/[\t\n]/g, " ");
+  } catch {
+    return "[Object]";
+  }
+}
+function formatSelectionAsTsv(items, visibleCols, range) {
+  const norm = normalizeSelectionRange(range);
+  const rows = [];
+  for (let r = norm.startRow; r <= norm.endRow; r++) {
+    const cells = [];
+    for (let c = norm.startCol; c <= norm.endCol; c++) {
+      if (r >= items.length || c >= visibleCols.length) break;
+      const item = items[r];
+      const col = visibleCols[c];
+      const raw = getCellValue(item, col);
+      const clipboard = col.clipboardFormatter ? col.clipboardFormatter(raw, item) : null;
+      const formatted = clipboard ?? (col.valueFormatter ? col.valueFormatter(raw, item) : raw);
+      cells.push(formatCellValueForTsv(raw, formatted));
+    }
+    rows.push(cells.join("	"));
+  }
+  return rows.join("\r\n");
+}
+function parseTsvClipboard(text) {
+  if (!text.trim()) return [];
+  const lines = text.split(/\r?\n/).filter((l) => l.length > 0);
+  return lines.map((line) => line.split("	"));
+}
+function applyPastedValues(parsedRows, anchorRow, anchorCol, items, visibleCols) {
+  const events = [];
+  for (let r = 0; r < parsedRows.length; r++) {
+    const cells = parsedRows[r];
+    for (let c = 0; c < cells.length; c++) {
+      const targetRow = anchorRow + r;
+      const targetCol = anchorCol + c;
+      if (targetRow >= items.length || targetCol >= visibleCols.length) continue;
+      const item = items[targetRow];
+      const col = visibleCols[targetCol];
+      const colEditable = col.editable === true || typeof col.editable === "function" && col.editable(item);
+      if (!colEditable) continue;
+      const rawValue = cells[c] ?? "";
+      const oldValue = getCellValue(item, col);
+      const result = parseValue(rawValue, oldValue, item, col);
+      if (!result.valid) continue;
+      events.push({
+        item,
+        columnId: col.columnId,
+        oldValue,
+        newValue: result.value,
+        rowIndex: targetRow
+      });
+    }
+  }
+  return events;
+}
+function applyCutClear(cutRange, items, visibleCols) {
+  const events = [];
+  for (let r = cutRange.startRow; r <= cutRange.endRow; r++) {
+    for (let c = cutRange.startCol; c <= cutRange.endCol; c++) {
+      if (r >= items.length || c >= visibleCols.length) continue;
+      const item = items[r];
+      const col = visibleCols[c];
+      const colEditable = col.editable === true || typeof col.editable === "function" && col.editable(item);
+      if (!colEditable) continue;
+      const oldValue = getCellValue(item, col);
+      const result = parseValue("", oldValue, item, col);
+      if (!result.valid) continue;
+      events.push({
+        item,
+        columnId: col.columnId,
+        oldValue,
+        newValue: result.value,
+        rowIndex: r
+      });
+    }
+  }
+  return events;
+}
+
+// src/utils/fillHelpers.ts
+function applyFillValues(range, sourceRow, sourceCol, items, visibleCols) {
+  const events = [];
+  const startItem = items[range.startRow];
+  const startColDef = visibleCols[range.startCol];
+  if (!startItem || !startColDef) return events;
+  const startValue = getCellValue(startItem, startColDef);
+  for (let row = range.startRow; row <= range.endRow; row++) {
+    for (let col = range.startCol; col <= range.endCol; col++) {
+      if (row === sourceRow && col === sourceCol) continue;
+      if (row >= items.length || col >= visibleCols.length) continue;
+      const item = items[row];
+      const colDef = visibleCols[col];
+      const colEditable = colDef.editable === true || typeof colDef.editable === "function" && colDef.editable(item);
+      if (!colEditable) continue;
+      const oldValue = getCellValue(item, colDef);
+      const result = parseValue(startValue, oldValue, item, colDef);
+      if (!result.valid) continue;
+      events.push({
+        item,
+        columnId: colDef.columnId,
+        oldValue,
+        newValue: result.value,
+        rowIndex: row
+      });
+    }
+  }
+  return events;
+}
+
+// src/utils/undoRedoStack.ts
+var UndoRedoStack = class {
+  constructor(maxDepth = 100) {
+    this.history = [];
+    this.redoStack = [];
+    this.batch = null;
+    this.maxDepth = maxDepth;
+  }
+  /** Whether there are undo steps available. */
+  get canUndo() {
+    return this.history.length > 0;
+  }
+  /** Whether there are redo steps available. */
+  get canRedo() {
+    return this.redoStack.length > 0;
+  }
+  /** Number of history entries. */
+  get historyLength() {
+    return this.history.length;
+  }
+  /** Number of redo entries. */
+  get redoLength() {
+    return this.redoStack.length;
+  }
+  /** Whether a batch is currently open. */
+  get isBatching() {
+    return this.batch !== null;
+  }
+  /**
+   * Record a group of events as a single undoable step.
+   * If a batch is open, accumulates into the batch instead.
+   * Clears the redo stack on any new entry.
+   */
+  push(events) {
+    if (events.length === 0) return;
+    if (this.batch !== null) {
+      this.batch.push(...events);
+    } else {
+      this.history.push(events);
+      if (this.history.length > this.maxDepth) {
+        this.history.splice(0, this.history.length - this.maxDepth);
+      }
+      this.redoStack.length = 0;
+    }
+  }
+  /**
+   * Record a single event as a step (shorthand for push([event])).
+   * If a batch is open, accumulates into the batch instead.
+   */
+  record(event) {
+    this.push([event]);
+  }
+  /**
+   * Start a batch — subsequent record/push calls accumulate into one undo step.
+   * Has no effect if a batch is already open.
+   */
+  beginBatch() {
+    if (this.batch === null) {
+      this.batch = [];
+    }
+  }
+  /**
+   * End a batch — commits all accumulated events as one undo step.
+   * Has no effect if no batch is open or if the batch is empty.
+   */
+  endBatch() {
+    const b = this.batch;
+    this.batch = null;
+    if (!b || b.length === 0) return;
+    this.history.push(b);
+    if (this.history.length > this.maxDepth) {
+      this.history.splice(0, this.history.length - this.maxDepth);
+    }
+    this.redoStack.length = 0;
+  }
+  /**
+   * Pop the most recent history entry for undo.
+   * Returns the batch of events (in original order) to be reversed by the caller,
+   * or null if there is nothing to undo.
+   *
+   * The caller is responsible for applying the events in reverse order.
+   */
+  undo() {
+    const lastBatch = this.history.pop();
+    if (!lastBatch) return null;
+    this.redoStack.push(lastBatch);
+    return lastBatch;
+  }
+  /**
+   * Pop the most recent redo entry.
+   * Returns the batch of events (in original order) to be re-applied by the caller,
+   * or null if there is nothing to redo.
+   */
+  redo() {
+    const nextBatch = this.redoStack.pop();
+    if (!nextBatch) return null;
+    this.history.push(nextBatch);
+    return nextBatch;
+  }
+  /**
+   * Clear all history and redo state.
+   * Does not affect any open batch — call endBatch() first if needed.
+   */
+  clear() {
+    this.history = [];
+    this.redoStack = [];
+  }
+};
+
+// src/utils/validation.ts
+function validateColumns(columns) {
+  if (!Array.isArray(columns) || columns.length === 0) {
+    console.warn("[OGrid] columns prop is empty or not an array");
+    return;
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const col of columns) {
+    if (!col.columnId) {
+      console.warn("[OGrid] Column missing columnId:", col);
+    }
+    if (ids.has(col.columnId)) {
+      console.warn(`[OGrid] Duplicate columnId: "${col.columnId}"`);
+    }
+    ids.add(col.columnId);
+  }
+}
+function validateRowIds(items, getRowId) {
+  if (typeof process !== "undefined" && process.env.NODE_ENV === "production") return;
+  const ids = /* @__PURE__ */ new Set();
+  const limit = Math.min(items.length, 100);
+  for (let i = 0; i < limit; i++) {
+    const id = getRowId(items[i]);
+    if (id == null) {
+      console.warn(`[OGrid] getRowId returned null/undefined for row ${i}`);
+      return;
+    }
+    if (ids.has(id)) {
+      console.warn(
+        `[OGrid] Duplicate row ID "${id}" at index ${i}. getRowId must return unique values.`
+      );
+      return;
+    }
+    ids.add(id);
+  }
+}
+
+// src/constants/timing.ts
+var DEFAULT_DEBOUNCE_MS = 300;
+var PEOPLE_SEARCH_DEBOUNCE_MS = DEFAULT_DEBOUNCE_MS;
+var SIDEBAR_TRANSITION_MS = 300;
+
+// src/constants/zIndex.ts
+var Z_INDEX = {
+  /** Selection range overlay (marching ants) */
+  SELECTION_OVERLAY: 4,
+  /** Clipboard overlay (copy/cut animation) */
+  CLIPBOARD_OVERLAY: 5,
+  /** Dropdown menus (column chooser, pagination size select) */
+  DROPDOWN: 1e3,
+  /** Modal dialogs */
+  MODAL: 2e3,
+  /** Context menus (right-click grid menu) */
+  CONTEXT_MENU: 9999
+};
+
+export { AUTOSIZE_EXTRA_PX, AUTOSIZE_MAX_PX, CELL_PADDING, CHECKBOX_COLUMN_WIDTH, COLUMN_HEADER_MENU_ITEMS, DEFAULT_DEBOUNCE_MS, DEFAULT_MIN_COLUMN_WIDTH, GRID_BORDER_RADIUS, GRID_CONTEXT_MENU_ITEMS, MAX_PAGE_BUTTONS, PAGE_SIZE_OPTIONS, PEOPLE_SEARCH_DEBOUNCE_MS, ROW_NUMBER_COLUMN_WIDTH, SIDEBAR_TRANSITION_MS, UndoRedoStack, Z_INDEX, applyCellDeletion, applyCutClear, applyFillValues, applyPastedValues, applyRangeRowSelection, areGridRowPropsEqual, booleanParser, buildCsvHeader, buildCsvRows, buildHeaderRows, buildInlineEditorProps, buildPopoverEditorProps, calculateDropTarget, clampSelectionToBounds, computeAggregations, computeArrowNavigation, computeAutoScrollSpeed, computeNextSortState, computeRowSelectionState, computeTabNavigation, computeTotalHeight, computeVisibleRange, currencyParser, dateParser, debounce, deriveFilterOptionsFromData, emailParser, escapeCsvValue, exportToCsv, findCtrlArrowTarget, flattenColumns, formatCellValueForTsv, formatSelectionAsTsv, formatShortcut, getCellRenderDescriptor, getCellValue, getColumnHeaderMenuItems, getContextMenuHandlers, getDataGridStatusBarConfig, getFilterField, getHeaderFilterConfig, getMultiSelectFilterFields, getPaginationViewModel, getPinStateForColumn, getScrollTopForRow, getStatusBarParts, injectGlobalStyles, isFilterConfig, isInSelectionRange, isRowInRange, measureColumnContentWidth, measureRange, mergeFilter, normalizeSelectionRange, numberParser, parseTsvClipboard, parseValue, processClientSideData, rangesEqual, reorderColumnArray, resolveCellDisplayContent, resolveCellStyle, toUserLike, triggerCsvDownload, validateColumns, validateRowIds };