eidos-ui 0.1.0

package/dist/chunk-HPIBYEGE.cjs

@@ -0,0 +1,1484 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkL3UPSLJ5cjs = require('./chunk-L3UPSLJ5.cjs');
+
+
+var _chunkR36SGSJXcjs = require('./chunk-R36SGSJX.cjs');
+
+
+var _chunkVZ43OLU6cjs = require('./chunk-VZ43OLU6.cjs');
+
+
+var _chunkSAFSEXMUcjs = require('./chunk-SAFSEXMU.cjs');
+
+
+var _chunkQGZF5MOScjs = require('./chunk-QGZF5MOS.cjs');
+
+
+var _chunkV5JNYS77cjs = require('./chunk-V5JNYS77.cjs');
+
+
+var _chunkG2FANEA2cjs = require('./chunk-G2FANEA2.cjs');
+
+
+var _chunkCDV2OAS3cjs = require('./chunk-CDV2OAS3.cjs');
+
+
+var _chunkBFYSYUA6cjs = require('./chunk-BFYSYUA6.cjs');
+
+
+var _chunkKV2FG7ANcjs = require('./chunk-KV2FG7AN.cjs');
+
+
+var _chunkLTOHGCU4cjs = require('./chunk-LTOHGCU4.cjs');
+
+
+var _chunkTBMVUI7Scjs = require('./chunk-TBMVUI7S.cjs');
+
+// src/components/DataGrid/DataGrid.component.tsx
+var _react = require('react'); var _react2 = _interopRequireDefault(_react);
+var _reactdom = require('react-dom');
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _lucidereact = require('lucide-react');
+var _jsxruntime = require('react/jsx-runtime');
+function SortableTableRow({
+  id,
+  disabled,
+  className,
+  children
+}) {
+  const { attributes, listeners, setNodeRef, transform, transition, isDragging } = _chunkL3UPSLJ5cjs.useSortable.call(void 0, {
+    id,
+    disabled
+  });
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    "tr",
+    {
+      ref: setNodeRef,
+      className: [className, isDragging ? "eidos-datagrid-row--dragging" : ""].filter(Boolean).join(" "),
+      style: {
+        transform: _chunkL3UPSLJ5cjs.CSS.Transform.toString(transform),
+        transition: _nullishCoalesce(transition, () => ( void 0)),
+        opacity: isDragging ? 0.4 : 1
+      },
+      ...attributes,
+      children: children(_nullishCoalesce(listeners, () => ( {})), isDragging)
+    }
+  );
+}
+function useExpandAnimation(isOpen) {
+  const outerRef = _react.useRef.call(void 0, null);
+  const innerRef = _react.useRef.call(void 0, null);
+  const [maxHeight, setMaxHeight] = _react.useState.call(void 0, 0);
+  const [mounted, setMounted] = _react.useState.call(void 0, isOpen);
+  _react.useEffect.call(void 0, () => {
+    if (isOpen) setMounted(true);
+  }, [isOpen]);
+  _react.useEffect.call(void 0, () => {
+    if (!mounted) return;
+    if (!isOpen) {
+      setMaxHeight(0);
+      return;
+    }
+    const node = innerRef.current;
+    if (!node) return;
+    const update = () => setMaxHeight(node.scrollHeight);
+    update();
+    const observer = new ResizeObserver(update);
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, [isOpen, mounted]);
+  const handleTransitionEnd = _react.useCallback.call(void 0, () => {
+    if (!isOpen) setMounted(false);
+  }, [isOpen]);
+  return { mounted, maxHeight, outerRef, innerRef, handleTransitionEnd };
+}
+function ExpandedTableRow({
+  isOpen,
+  colSpan,
+  render
+}) {
+  const { mounted, maxHeight, outerRef, innerRef, handleTransitionEnd } = useExpandAnimation(isOpen);
+  if (!mounted) return null;
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tr", { className: "eidos-datagrid-expanded-row", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "td", { colSpan, className: "eidos-datagrid-expanded-cell", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    "div",
+    {
+      ref: outerRef,
+      className: "eidos-datagrid-expand-panel",
+      style: { maxHeight: `${maxHeight}px` },
+      onTransitionEnd: handleTransitionEnd,
+      children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { ref: innerRef, className: "eidos-datagrid-expand-panel-inner", children: render() })
+    }
+  ) }) });
+}
+function ExpandedCardPanel({
+  isOpen,
+  render
+}) {
+  const { mounted, maxHeight, outerRef, innerRef, handleTransitionEnd } = useExpandAnimation(isOpen);
+  if (!mounted) return null;
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    "div",
+    {
+      ref: outerRef,
+      className: "eidos-datagrid-expand-panel",
+      style: { maxHeight: `${maxHeight}px` },
+      onTransitionEnd: handleTransitionEnd,
+      children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { ref: innerRef, className: "eidos-datagrid-expand-panel-inner", children: render() })
+    }
+  );
+}
+function DataGridInner({
+  // ── Existing props ─────────────────────────────────────────────────────────
+  columns,
+  data,
+  rowKey = "id",
+  onChange,
+  onRowAdd,
+  editable = false,
+  loading = false,
+  emptyText = "No data available",
+  className,
+  stickyHeader = false,
+  maxHeight,
+  showRowNumbers = false,
+  draggableRows = false,
+  onRowReorder,
+  // ── Sorting ────────────────────────────────────────────────────────────────
+  currentSort,
+  onSortChange,
+  // ── Filtering ──────────────────────────────────────────────────────────────
+  showFilters = false,
+  filterConfig = [],
+  filters,
+  onFiltersChange,
+  // ── Pagination ─────────────────────────────────────────────────────────────
+  showPagination = false,
+  pageSize = 10,
+  pageSizeOptions,
+  totalRows: totalRowsProp,
+  onPageChange,
+  // ── Row selection + bulk actions ───────────────────────────────────────────
+  selectable = false,
+  selectedRows: controlledSelectedRows,
+  defaultSelectedRows,
+  onSelectionChange,
+  bulkActions,
+  // ── Row expansion ────────────────────────────────────────────────────────────
+  expandable = false,
+  renderExpandedContent,
+  isRowExpandable,
+  expandMultiple = true,
+  expandedRows: controlledExpandedRows,
+  defaultExpandedRows,
+  onExpandedRowsChange,
+  // ── Display ────────────────────────────────────────────────────────────────
+  density = "comfortable",
+  showDensity = false,
+  // ── Card view ────────────────────────────────────────────────────────────────
+  hasCardView = false,
+  cardViewBreakpoint = 640,
+  cardMinWidth = 280
+}) {
+  const [localData, _setLocalData] = _react.useState.call(void 0, data);
+  const localDataRef = _react.useRef.call(void 0, data);
+  const [editingCell, _setEditingCell] = _react.useState.call(void 0, null);
+  const editingCellRef = _react.useRef.call(void 0, null);
+  const [editValue, _setEditValue] = _react.useState.call(void 0, null);
+  const editValueRef = _react.useRef.call(void 0, null);
+  const [editError, setEditError] = _react.useState.call(void 0, null);
+  const errorTooltipAnchorRef = _react.useRef.call(void 0, null);
+  const [errorTooltipPosition, setErrorTooltipPosition] = _react.useState.call(void 0, null);
+  const activeCellError = editingCell && editError ? editError : null;
+  _react.useLayoutEffect.call(void 0, () => {
+    if (!activeCellError) {
+      setErrorTooltipPosition(null);
+      return;
+    }
+    const updatePosition = () => {
+      const node = errorTooltipAnchorRef.current;
+      if (!node) return;
+      const rect = node.getBoundingClientRect();
+      setErrorTooltipPosition({ top: rect.bottom + 4, left: rect.left });
+    };
+    updatePosition();
+    window.addEventListener("resize", updatePosition);
+    window.addEventListener("scroll", updatePosition, true);
+    return () => {
+      window.removeEventListener("resize", updatePosition);
+      window.removeEventListener("scroll", updatePosition, true);
+    };
+  }, [activeCellError]);
+  const [internalDensity, setInternalDensity] = _react.useState.call(void 0, 
+    density
+  );
+  const effectiveDensity = showDensity ? internalDensity : density;
+  const [internalSort, setInternalSort] = _react.useState.call(void 0, null);
+  const [internalFilters, setInternalFilters] = _react.useState.call(void 0, {});
+  const [currentPage, setCurrentPage] = _react.useState.call(void 0, 1);
+  const [currentPageSize, setCurrentPageSize] = _react.useState.call(void 0, pageSize);
+  const isControlledSelection = controlledSelectedRows !== void 0;
+  const [internalSelectedKeys, setInternalSelectedKeys] = _react.useState.call(void 0, 
+    () => new Set(_nullishCoalesce(defaultSelectedRows, () => ( [])))
+  );
+  const isControlledExpansion = controlledExpandedRows !== void 0;
+  const [internalExpandedKeys, setInternalExpandedKeys] = _react.useState.call(void 0, 
+    () => new Set(_nullishCoalesce(defaultExpandedRows, () => ( [])))
+  );
+  const [containerWidth, setContainerWidth] = _react.useState.call(void 0, null);
+  const resizeObserverRef = _react.useRef.call(void 0, null);
+  const setContainerRef = _react.useCallback.call(void 0, 
+    (el) => {
+      _optionalChain([resizeObserverRef, 'access', _ => _.current, 'optionalAccess', _2 => _2.disconnect, 'call', _3 => _3()]);
+      resizeObserverRef.current = null;
+      if (!el || !hasCardView) return;
+      const observer = new ResizeObserver((entries) => {
+        const width = _optionalChain([entries, 'access', _4 => _4[0], 'optionalAccess', _5 => _5.contentRect, 'access', _6 => _6.width]);
+        if (width != null) setContainerWidth(width);
+      });
+      observer.observe(el);
+      resizeObserverRef.current = observer;
+    },
+    [hasCardView]
+  );
+  const isCardView = hasCardView && containerWidth !== null && containerWidth < cardViewBreakpoint;
+  const cardHeaderColumn = _react.useMemo.call(void 0, () => columns.find((c) => c.cardHeader), [columns]);
+  const cardSubheaderColumn = _react.useMemo.call(void 0, () => columns.find((c) => c.cardSubheader), [columns]);
+  const actionsColumn = _react.useMemo.call(void 0, () => columns.find((c) => c.type === "actions"), [columns]);
+  const dataColumns = _react.useMemo.call(void 0, 
+    () => columns.filter((c) => c !== actionsColumn),
+    [columns, actionsColumn]
+  );
+  const cardFieldColumns = _react.useMemo.call(void 0, 
+    () => dataColumns.filter((c) => c !== cardHeaderColumn && c !== cardSubheaderColumn),
+    [dataColumns, cardHeaderColumn, cardSubheaderColumn]
+  );
+  const theadRef = _react.useRef.call(void 0, null);
+  const [pinnedOffsets, setPinnedOffsets] = _react.useState.call(void 0, /* @__PURE__ */ new Map());
+  const setLocalData = _react.useCallback.call(void 0, (v) => {
+    localDataRef.current = v;
+    _setLocalData(v);
+  }, []);
+  const setEditingCell = _react.useCallback.call(void 0, (v) => {
+    editingCellRef.current = v;
+    _setEditingCell(v);
+  }, []);
+  const setEditValue = _react.useCallback.call(void 0, (v) => {
+    editValueRef.current = v;
+    _setEditValue(v);
+  }, []);
+  _react.useEffect.call(void 0, () => {
+    setLocalData(data);
+  }, [data, setLocalData]);
+  const activeSort = _nullishCoalesce(currentSort, () => ( internalSort));
+  const activeFilters = _react.useMemo.call(void 0, 
+    () => onFiltersChange ? _nullishCoalesce(filters, () => ( {})) : internalFilters,
+    [onFiltersChange, filters, internalFilters]
+  );
+  const selectedSet = _react.useMemo.call(void 0, 
+    () => new Set(isControlledSelection ? _nullishCoalesce(controlledSelectedRows, () => ( [])) : [...internalSelectedKeys]),
+    [isControlledSelection, controlledSelectedRows, internalSelectedKeys]
+  );
+  const allKeys = _react.useMemo.call(void 0, 
+    () => localData.map((row, idx) => String(_nullishCoalesce(row[rowKey], () => ( idx)))),
+    [localData, rowKey]
+  );
+  const allSelected = allKeys.length > 0 && allKeys.every((k) => selectedSet.has(k));
+  const someSelected = !allSelected && allKeys.some((k) => selectedSet.has(k));
+  const hasSelection = selectedSet.size > 0;
+  const selectedItems = _react.useMemo.call(void 0, 
+    () => localData.filter((row, idx) => selectedSet.has(String(_nullishCoalesce(row[rowKey], () => ( idx))))),
+    [localData, selectedSet, rowKey]
+  );
+  const expandedSet = _react.useMemo.call(void 0, 
+    () => new Set(isControlledExpansion ? _nullishCoalesce(controlledExpandedRows, () => ( [])) : [...internalExpandedKeys]),
+    [isControlledExpansion, controlledExpandedRows, internalExpandedKeys]
+  );
+  const filterDropdownColumns = _react.useMemo.call(void 0, () => {
+    return filterConfig.map(
+      (field) => ({
+        key: field.key,
+        label: field.label,
+        filterable: true,
+        filterType: field.filterType,
+        filterOptions: field.filterOptions,
+        dateFilterMode: field.dateFilterMode
+      })
+    );
+  }, [filterConfig]);
+  const filteredData = _react.useMemo.call(void 0, () => {
+    if (onFiltersChange) return localData;
+    const filterEntries = Object.entries(activeFilters).filter(([, val]) => {
+      if (val === void 0 || val === null || val === "") return false;
+      if (Array.isArray(val) && val.length === 0) return false;
+      return true;
+    });
+    if (filterEntries.length === 0) return localData;
+    return localData.filter(
+      (row) => filterEntries.every(([key, filterValue]) => {
+        const cellValue = row[key];
+        if (Array.isArray(filterValue)) {
+          return filterValue.includes(String(_nullishCoalesce(cellValue, () => ( ""))));
+        }
+        if (typeof filterValue === "boolean") {
+          return Boolean(cellValue) === filterValue;
+        }
+        if (typeof filterValue === "object" && filterValue !== null && "start" in filterValue) {
+          const { start, end } = filterValue;
+          const dateStr = String(_nullishCoalesce(cellValue, () => ( "")));
+          if (start && dateStr < start) return false;
+          if (end && dateStr > end) return false;
+          return true;
+        }
+        return String(_nullishCoalesce(cellValue, () => ( ""))).toLowerCase().includes(String(filterValue).toLowerCase());
+      })
+    );
+  }, [localData, activeFilters, onFiltersChange]);
+  const sortedData = _react.useMemo.call(void 0, () => {
+    if (onSortChange || !activeSort) return filteredData;
+    return [...filteredData].sort((a, b) => {
+      const aVal = a[activeSort.key];
+      const bVal = b[activeSort.key];
+      if (aVal == null && bVal == null) return 0;
+      if (aVal == null) return 1;
+      if (bVal == null) return -1;
+      const compare = typeof aVal === "number" && typeof bVal === "number" ? aVal - bVal : String(aVal).localeCompare(String(bVal));
+      return activeSort.direction === "asc" ? compare : -compare;
+    });
+  }, [filteredData, activeSort, onSortChange]);
+  const displayData = _react.useMemo.call(void 0, () => {
+    if (!showPagination) return sortedData;
+    if (onPageChange) return sortedData;
+    const start = (currentPage - 1) * currentPageSize;
+    return sortedData.slice(start, start + currentPageSize);
+  }, [sortedData, showPagination, currentPage, currentPageSize, onPageChange]);
+  const totalItemCount = _nullishCoalesce(totalRowsProp, () => ( sortedData.length));
+  const totalPages = Math.max(1, Math.ceil(totalItemCount / currentPageSize));
+  const activeFiltersKey = _react.useMemo.call(void 0, () => JSON.stringify(activeFilters), [activeFilters]);
+  _react.useEffect.call(void 0, () => {
+    setCurrentPage(1);
+  }, [activeFiltersKey]);
+  _react.useEffect.call(void 0, () => {
+    setCurrentPage(1);
+  }, [internalSort]);
+  _react.useLayoutEffect.call(void 0, () => {
+    const hasPinned = columns.some((c) => c.pin);
+    if (!hasPinned || !theadRef.current) {
+      setPinnedOffsets((prev) => prev.size > 0 ? /* @__PURE__ */ new Map() : prev);
+      return;
+    }
+    const headerRow = theadRef.current.querySelector("tr");
+    if (!headerRow) return;
+    const cells = Array.from(headerRow.querySelectorAll("th[data-col-key]"));
+    const newOffsets = /* @__PURE__ */ new Map();
+    const hasLeftPin = columns.some((c) => c.pin === "left");
+    let leftAccum = 0;
+    for (const cell of cells) {
+      const key = cell.dataset.colKey;
+      if (key === "__expand__" || key === "__sel__" || key === "__drag__" || key === "__rownum__") {
+        if (hasLeftPin) {
+          newOffsets.set(key, { side: "left", offset: leftAccum });
+        }
+        leftAccum += cell.offsetWidth;
+      } else {
+        const col = columns.find((c) => c.key === key);
+        if (_optionalChain([col, 'optionalAccess', _7 => _7.pin]) === "left") {
+          newOffsets.set(key, { side: "left", offset: leftAccum });
+          leftAccum += cell.offsetWidth;
+        }
+      }
+    }
+    let rightAccum = 0;
+    for (let i = cells.length - 1; i >= 0; i--) {
+      const cell = cells[i];
+      const key = cell.dataset.colKey;
+      if (key === "__actions__") {
+        rightAccum += cell.offsetWidth;
+      } else {
+        const col = columns.find((c) => c.key === key);
+        if (_optionalChain([col, 'optionalAccess', _8 => _8.pin]) === "right") {
+          newOffsets.set(key, { side: "right", offset: rightAccum });
+          rightAccum += cell.offsetWidth;
+        }
+      }
+    }
+    setPinnedOffsets(newOffsets);
+  }, [columns, selectable, draggableRows, showRowNumbers, expandable]);
+  const getCellPinnedProps = _react.useCallback.call(void 0, 
+    (colKey) => {
+      const info = pinnedOffsets.get(colKey);
+      if (!info) return { style: {}, className: "" };
+      return {
+        style: { position: "sticky", [info.side]: info.offset, zIndex: 1 },
+        className: info.side === "left" ? "eidos-datagrid-cell--pinned-left" : "eidos-datagrid-cell--pinned-right"
+      };
+    },
+    [pinnedOffsets]
+  );
+  const getHeaderPinnedProps = _react.useCallback.call(void 0, 
+    (colKey) => {
+      const info = pinnedOffsets.get(colKey);
+      if (!info) return { style: {}, className: "" };
+      return {
+        // z-index 3: above both body sticky cells (1) and non-sticky header (1 from SCSS)
+        style: { position: "sticky", [info.side]: info.offset, zIndex: 3 },
+        className: info.side === "left" ? "eidos-datagrid-header-cell--pinned-left" : "eidos-datagrid-header-cell--pinned-right"
+      };
+    },
+    [pinnedOffsets]
+  );
+  const isCellEditable = _react.useCallback.call(void 0, 
+    (col) => {
+      if (!editable) return false;
+      if (col.type === "readonly" || col.type === "actions") return false;
+      if (col.editable === false) return false;
+      return true;
+    },
+    [editable]
+  );
+  const validateCell = _react.useCallback.call(void 0, (col, value) => {
+    if (col.required && (value === "" || value === null || value === void 0)) {
+      return "This field is required";
+    }
+    if (col.validate) {
+      const result = col.validate(value);
+      if (result !== true) return result;
+    }
+    return null;
+  }, []);
+  const cellErrorKey = (rowIndex, colKey) => `${rowIndex}:${colKey}`;
+  const cellErrors = _react.useMemo.call(void 0, () => {
+    const errors = {};
+    localData.forEach((row, rowIndex) => {
+      for (const col of columns) {
+        if (!isCellEditable(col)) continue;
+        const error = validateCell(col, row[col.key]);
+        if (error) errors[cellErrorKey(rowIndex, col.key)] = error;
+      }
+    });
+    return errors;
+  }, [localData, columns, isCellEditable, validateCell]);
+  const commitValue = _react.useCallback.call(void 0, 
+    (rowIndex, colKey, value) => {
+      const col = columns.find((c) => c.key === colKey);
+      if (!col) return null;
+      const error = validateCell(col, value);
+      const newData = localDataRef.current.map(
+        (row, idx) => idx === rowIndex ? { ...row, [colKey]: value } : row
+      );
+      setLocalData(newData);
+      _optionalChain([onChange, 'optionalCall', _9 => _9(newData)]);
+      return error;
+    },
+    [columns, onChange, setLocalData, validateCell]
+  );
+  const commitEdit = _react.useCallback.call(void 0, () => {
+    const cell = editingCellRef.current;
+    if (!cell) return;
+    const col = columns.find((c) => c.key === cell.colKey);
+    if (!col) {
+      setEditingCell(null);
+      return;
+    }
+    commitValue(cell.rowIndex, cell.colKey, editValueRef.current);
+    setEditingCell(null);
+    setEditError(null);
+  }, [columns, commitValue, setEditingCell]);
+  const discardEdit = _react.useCallback.call(void 0, () => {
+    setEditingCell(null);
+    setEditError(null);
+  }, [setEditingCell]);
+  const commitEditRef = _react.useRef.call(void 0, commitEdit);
+  _react.useEffect.call(void 0, () => {
+    commitEditRef.current = commitEdit;
+  }, [commitEdit]);
+  _react.useEffect.call(void 0, () => {
+    if (!editingCell) return;
+    const handleMouseDown = (e) => {
+      const target = e.target;
+      if (_optionalChain([target, 'access', _10 => _10.closest, 'optionalCall', _11 => _11(
+        ".eidos-data-grid-cell--editing, .eidos-datagrid-card-value--editing, .eidos-dropdown-content"
+      )])) {
+        return;
+      }
+      commitEditRef.current();
+    };
+    document.addEventListener("mousedown", handleMouseDown);
+    return () => document.removeEventListener("mousedown", handleMouseDown);
+  }, [editingCell]);
+  const startEdit = _react.useCallback.call(void 0, 
+    (rowIndex, colKey, currentValue) => {
+      const col = columns.find((c) => c.key === colKey);
+      if (!col || !isCellEditable(col)) return;
+      setEditingCell({ rowIndex, colKey });
+      setEditValue(currentValue);
+      setEditError(_nullishCoalesce(cellErrors[cellErrorKey(rowIndex, colKey)], () => ( null)));
+    },
+    [columns, isCellEditable, setEditingCell, setEditValue, cellErrors]
+  );
+  const handleCellClick = _react.useCallback.call(void 0, 
+    (rowIndex, col) => {
+      const value = _optionalChain([localDataRef, 'access', _12 => _12.current, 'access', _13 => _13[rowIndex], 'optionalAccess', _14 => _14[col.key]]);
+      if (col.type === "checkbox") {
+        if (!editable || col.editable === false) return;
+        const newData = localDataRef.current.map(
+          (row, idx) => idx === rowIndex ? { ...row, [col.key]: !value } : row
+        );
+        setLocalData(newData);
+        _optionalChain([onChange, 'optionalCall', _15 => _15(newData)]);
+        return;
+      }
+      if (!isCellEditable(col)) return;
+      const cell = editingCellRef.current;
+      if (_optionalChain([cell, 'optionalAccess', _16 => _16.rowIndex]) === rowIndex && _optionalChain([cell, 'optionalAccess', _17 => _17.colKey]) === col.key) return;
+      if (cell) commitEdit();
+      startEdit(rowIndex, col.key, value);
+    },
+    [editable, isCellEditable, commitEdit, startEdit, setLocalData, onChange]
+  );
+  const handleKeyDown = _react.useCallback.call(void 0, 
+    (e, rowIndex, colKey) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        discardEdit();
+        return;
+      }
+      if (e.key === "Enter") {
+        e.preventDefault();
+        commitEdit();
+        return;
+      }
+      if (e.key === "Tab") {
+        e.preventDefault();
+        const editableCells = [];
+        for (let ri = 0; ri < localDataRef.current.length; ri++) {
+          for (const c of columns) {
+            if (isCellEditable(c)) {
+              editableCells.push({ rowIndex: ri, colKey: c.key });
+            }
+          }
+        }
+        const idx = editableCells.findIndex((c) => c.rowIndex === rowIndex && c.colKey === colKey);
+        const next = e.shiftKey ? editableCells[idx - 1] : editableCells[idx + 1];
+        commitValue(rowIndex, colKey, editValueRef.current);
+        if (next) {
+          setEditingCell(next);
+          setEditValue(localDataRef.current[next.rowIndex][next.colKey]);
+          setEditError(_nullishCoalesce(cellErrors[cellErrorKey(next.rowIndex, next.colKey)], () => ( null)));
+        } else {
+          setEditingCell(null);
+          setEditError(null);
+        }
+      }
+    },
+    [
+      columns,
+      isCellEditable,
+      commitEdit,
+      commitValue,
+      discardEdit,
+      cellErrors,
+      setEditingCell,
+      setEditValue
+    ]
+  );
+  const handleRowAdd = _react.useCallback.call(void 0, () => {
+    if (!onRowAdd) return;
+    const newRow = onRowAdd();
+    const newData = [newRow, ...localDataRef.current];
+    setLocalData(newData);
+    _optionalChain([onChange, 'optionalCall', _18 => _18(newData)]);
+    setCurrentPage(1);
+  }, [onRowAdd, onChange, setLocalData]);
+  const commitSelection = _react.useCallback.call(void 0, 
+    (keys) => {
+      if (!isControlledSelection) setInternalSelectedKeys(new Set(keys));
+      const rows = localDataRef.current.filter(
+        (row, idx) => keys.includes(String(_nullishCoalesce(row[rowKey], () => ( idx))))
+      );
+      _optionalChain([onSelectionChange, 'optionalCall', _19 => _19(keys, rows)]);
+    },
+    [isControlledSelection, rowKey, onSelectionChange]
+  );
+  const toggleRow = _react.useCallback.call(void 0, 
+    (key) => {
+      const next = selectedSet.has(key) ? [...selectedSet].filter((k) => k !== key) : [...selectedSet, key];
+      commitSelection(next);
+    },
+    [selectedSet, commitSelection]
+  );
+  const toggleAll = _react.useCallback.call(void 0, () => {
+    commitSelection(allSelected ? [] : allKeys);
+  }, [allSelected, allKeys, commitSelection]);
+  const clearSelection = _react.useCallback.call(void 0, () => commitSelection([]), [commitSelection]);
+  const commitExpanded = _react.useCallback.call(void 0, 
+    (keys) => {
+      if (!isControlledExpansion) setInternalExpandedKeys(new Set(keys));
+      _optionalChain([onExpandedRowsChange, 'optionalCall', _20 => _20(keys)]);
+    },
+    [isControlledExpansion, onExpandedRowsChange]
+  );
+  const toggleExpanded = _react.useCallback.call(void 0, 
+    (key) => {
+      const isOpen = expandedSet.has(key);
+      const next = expandMultiple ? isOpen ? [...expandedSet].filter((k) => k !== key) : [...expandedSet, key] : isOpen ? [] : [key];
+      commitExpanded(next);
+    },
+    [expandedSet, expandMultiple, commitExpanded]
+  );
+  const handleSortClick = _react.useCallback.call(void 0, 
+    (colKey) => {
+      if (onSortChange) {
+        const newDir = _optionalChain([currentSort, 'optionalAccess', _21 => _21.key]) === colKey && _optionalChain([currentSort, 'optionalAccess', _22 => _22.direction]) === "asc" ? "desc" : "asc";
+        onSortChange(colKey, newDir);
+      } else {
+        setInternalSort((prev) => {
+          if (_optionalChain([prev, 'optionalAccess', _23 => _23.key]) === colKey) {
+            return prev.direction === "asc" ? { key: colKey, direction: "desc" } : null;
+          }
+          return { key: colKey, direction: "asc" };
+        });
+      }
+    },
+    [onSortChange, currentSort]
+  );
+  const handleFiltersChange = _react.useCallback.call(void 0, 
+    (newFilters) => {
+      setCurrentPage(1);
+      if (onFiltersChange) {
+        onFiltersChange(newFilters);
+      } else {
+        setInternalFilters(newFilters);
+      }
+    },
+    [onFiltersChange]
+  );
+  const handlePageChange = _react.useCallback.call(void 0, 
+    (page) => {
+      setCurrentPage(page);
+      _optionalChain([onPageChange, 'optionalCall', _24 => _24(page, currentPageSize)]);
+    },
+    [currentPageSize, onPageChange]
+  );
+  const handlePageSizeChange = _react.useCallback.call(void 0, 
+    (newPageSize) => {
+      setCurrentPageSize(newPageSize);
+      setCurrentPage(1);
+      _optionalChain([onPageChange, 'optionalCall', _25 => _25(1, newPageSize)]);
+    },
+    [onPageChange]
+  );
+  const sensors = _chunkL3UPSLJ5cjs.useSensors.call(void 0, 
+    _chunkL3UPSLJ5cjs.useSensor.call(void 0, _chunkL3UPSLJ5cjs.PointerSensor, { activationConstraint: { distance: 5 } }),
+    _chunkL3UPSLJ5cjs.useSensor.call(void 0, _chunkL3UPSLJ5cjs.KeyboardSensor)
+  );
+  const handleRowDragEnd = _react.useCallback.call(void 0, 
+    (event) => {
+      if (!draggableRows) return;
+      const { active, over } = event;
+      if (!over || active.id === over.id) return;
+      const oldIndex = localDataRef.current.findIndex(
+        (row, i) => String(_nullishCoalesce(row[rowKey], () => ( i))) === String(active.id)
+      );
+      const newIndex = localDataRef.current.findIndex(
+        (row, i) => String(_nullishCoalesce(row[rowKey], () => ( i))) === String(over.id)
+      );
+      if (oldIndex === -1 || newIndex === -1) return;
+      const newData = _chunkL3UPSLJ5cjs.arrayMove.call(void 0, localDataRef.current, oldIndex, newIndex);
+      setLocalData(newData);
+      _optionalChain([onChange, 'optionalCall', _26 => _26(newData)]);
+      _optionalChain([onRowReorder, 'optionalCall', _27 => _27(newData)]);
+    },
+    [draggableRows, rowKey, setLocalData, onChange, onRowReorder]
+  );
+  const renderViewCell = (col, value, row, rowIndex) => {
+    if (col.renderCell) return col.renderCell(value, row, rowIndex);
+    switch (col.type) {
+      case "checkbox":
+        return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _chunkG2FANEA2cjs.Checkbox,
+          {
+            checked: Boolean(value),
+            onChange: () => {
+            },
+            size: "sm"
+          }
+        );
+      case "select": {
+        const option = _optionalChain([col, 'access', _28 => _28.options, 'optionalAccess', _29 => _29.find, 'call', _30 => _30((o) => o.value === String(_nullishCoalesce(value, () => ( ""))))]);
+        return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { children: option ? option.label : String(_nullishCoalesce(value, () => ( ""))) });
+      }
+      case "readonly":
+      case "text":
+      case "number":
+      case "date":
+      default:
+        return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { children: String(_nullishCoalesce(value, () => ( ""))) });
+    }
+  };
+  const renderEditCell = (col, value, row, rowIndex, context = "table") => {
+    if (col.renderEditor) {
+      return col.renderEditor(value, (v) => setEditValue(v), row);
+    }
+    const variant = context === "table" ? "bare" : void 0;
+    const size = context === "table" ? "sm" : void 0;
+    switch (col.type) {
+      case "number":
+        return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _chunkCDV2OAS3cjs.Input,
+          {
+            type: "number",
+            variant,
+            size,
+            value: String(_nullishCoalesce(value, () => ( ""))),
+            onChange: (e) => setEditValue(e.target.value),
+            autoFocus: true,
+            fullWidth: true,
+            clearable: false
+          }
+        );
+      case "date":
+        return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _chunkCDV2OAS3cjs.Input,
+          {
+            type: "date",
+            variant,
+            size,
+            value: String(_nullishCoalesce(value, () => ( ""))),
+            onChange: (e) => setEditValue(e.target.value),
+            autoFocus: true,
+            fullWidth: true,
+            clearable: false
+          }
+        );
+      case "select": {
+        const selectOptions = (_nullishCoalesce(col.options, () => ( []))).map((o) => ({
+          id: o.value,
+          value: o.value,
+          label: o.label
+        }));
+        return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _chunkQGZF5MOScjs.Select,
+          {
+            options: selectOptions,
+            value: String(_nullishCoalesce(value, () => ( ""))),
+            autoOpen: true,
+            fullWidth: true,
+            inputProps: { variant, size },
+            onChange: (v) => {
+              const selected = Array.isArray(v) ? _nullishCoalesce(v[0], () => ( "")) : v;
+              const newData = localDataRef.current.map(
+                (r, i) => i === rowIndex ? { ...r, [col.key]: selected } : r
+              );
+              setLocalData(newData);
+              _optionalChain([onChange, 'optionalCall', _31 => _31(newData)]);
+              setEditingCell(null);
+            },
+            clearable: false
+          }
+        );
+      }
+      default:
+        return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _chunkCDV2OAS3cjs.Input,
+          {
+            type: "text",
+            variant,
+            size,
+            value: String(_nullishCoalesce(value, () => ( ""))),
+            onChange: (e) => setEditValue(e.target.value),
+            autoFocus: true,
+            fullWidth: true,
+            clearable: false
+          }
+        );
+    }
+  };
+  const renderCardValue = (col, row, localIndex, baseClassName) => {
+    const value = row[col.key];
+    const isEditing = _optionalChain([editingCell, 'optionalAccess', _32 => _32.rowIndex]) === localIndex && _optionalChain([editingCell, 'optionalAccess', _33 => _33.colKey]) === col.key;
+    const canEdit = isCellEditable(col);
+    const isFlagged = cellErrorKey(localIndex, col.key) in cellErrors;
+    const hasError = isEditing && Boolean(editError);
+    const valueCls = [
+      baseClassName,
+      // Deliberately NOT `eidos-data-grid-cell--editing` (unlike the <td>
+      // version of this same state) - that class's whole job is forcing the
+      // editor into `position: absolute; inset: 0` so it fills a <td>
+      // without changing the table row's height. A card field has no row
+      // to preserve the height of, so it just needs its own "is editing"
+      // hook for spacing - the editor itself renders normally, with each
+      // component's own default (non-`bare`) look (see `renderEditCell`).
+      isEditing && "eidos-datagrid-card-value--editing",
+      hasError && "eidos-data-grid-cell--error",
+      isFlagged && !hasError && "eidos-data-grid-cell--has-error",
+      canEdit && !isEditing && "eidos-data-grid-cell--editable",
+      col.type === "readonly" && "eidos-data-grid-cell--readonly",
+      // Checkbox glyph is intrinsically narrow - without this the value
+      // wrapper stretches to the card's full width (block layout), making
+      // the whole row clickable/toggleable instead of just the checkbox.
+      col.type === "checkbox" && "eidos-datagrid-card-value--checkbox"
+    ].filter(Boolean).join(" ");
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      "div",
+      {
+        ref: hasError ? errorTooltipAnchorRef : void 0,
+        className: valueCls,
+        onClick: () => handleCellClick(localIndex, col),
+        onKeyDown: isEditing ? (e) => handleKeyDown(e, localIndex, col.key) : void 0,
+        tabIndex: isEditing ? -1 : void 0,
+        children: isEditing ? renderEditCell(col, editValue, row, localIndex, "card") : renderViewCell(col, value, row, localIndex)
+      }
+    );
+  };
+  const renderCardField = (col, row, localIndex) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "eidos-datagrid-card-field", children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "eidos-datagrid-card-field-label", children: col.header }),
+    renderCardValue(col, row, localIndex, "eidos-datagrid-card-field-value")
+  ] }, col.key);
+  const renderActionsMenu = (row, localIndex) => {
+    if (!actionsColumn) return null;
+    const items = actionsColumn.renderActions ? actionsColumn.renderActions(row, localIndex) : (_nullishCoalesce(actionsColumn.actions, () => ( []))).flatMap((action, index) => {
+      const id = _nullishCoalesce(action.id, () => ( `${action.label}-${index}`));
+      const isDisabled = typeof action.disabled === "function" ? action.disabled(row) : Boolean(action.disabled);
+      const item = {
+        id,
+        type: "item",
+        label: action.label,
+        icon: action.icon,
+        disabled: isDisabled,
+        color: action.danger ? "danger" : void 0,
+        onClick: () => action.onClick(row, localIndex)
+      };
+      return action.divider ? [{ id: `${id}-divider`, type: "separator" }, item] : [item];
+    });
+    if (!items.length) return null;
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _chunkBFYSYUA6cjs.Menu,
+      {
+        trigger: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "button", { type: "button", className: "eidos-datagrid-actions-trigger", "aria-label": "Row actions", children: actionsColumn.actionsIcon ? _chunkTBMVUI7Scjs.renderIcon.call(void 0, actionsColumn.actionsIcon, "eidos-datagrid-actions-trigger-icon") : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.MoreVertical, { size: 16 }) }),
+        items
+      }
+    );
+  };
+  const sortedColumns = _react.useMemo.call(void 0, 
+    () => [
+      ...dataColumns.filter((c) => c.pin === "left"),
+      ...dataColumns.filter((c) => !c.pin),
+      ...dataColumns.filter((c) => c.pin === "right")
+    ],
+    [dataColumns]
+  );
+  const totalCols = dataColumns.length + (showRowNumbers ? 1 : 0) + (actionsColumn ? 1 : 0) + (draggableRows ? 1 : 0) + (selectable ? 1 : 0) + (expandable ? 1 : 0);
+  const rowIds = displayData.map((row, i) => String(_nullishCoalesce(row[rowKey], () => ( i))));
+  const containerStyle = {};
+  if (stickyHeader && maxHeight) {
+    containerStyle.maxHeight = typeof maxHeight === "number" ? `${maxHeight}px` : maxHeight;
+  }
+  const showToolbar = !!showFilters || !!showDensity || !!selectable || !!onRowAdd;
+  const densityClass = effectiveDensity !== "comfortable" ? `eidos-datagrid--${effectiveDensity}` : "";
+  const effectivePageSizeOptions = _react.useMemo.call(void 0, () => {
+    const opts = _nullishCoalesce(pageSizeOptions, () => ( [10, 25, 50, 100]));
+    return opts.includes(pageSize) ? opts : [...opts, pageSize].sort((a, b) => a - b);
+  }, [pageSizeOptions, pageSize]);
+  if (loading) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      "div",
+      {
+        ref: setContainerRef,
+        className: ["eidos-data-grid-container", className].filter(Boolean).join(" "),
+        children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "eidos-data-grid-loading", children: [
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkR36SGSJXcjs.Spinner, { size: "md" }),
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "p", { children: "Loading\u2026" })
+        ] })
+      }
+    );
+  }
+  const expandHeaderPin = getHeaderPinnedProps("__expand__");
+  const selHeaderPin = getHeaderPinnedProps("__sel__");
+  const dragHeaderPin = getHeaderPinnedProps("__drag__");
+  const rownumHeaderPin = getHeaderPinnedProps("__rownum__");
+  const expandCellPin = getCellPinnedProps("__expand__");
+  const selCellPin = getCellPinnedProps("__sel__");
+  const dragCellPin = getCellPinnedProps("__drag__");
+  const rownumCellPin = getCellPinnedProps("__rownum__");
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    "div",
+    {
+      ref: setContainerRef,
+      className: [
+        "eidos-data-grid-container",
+        stickyHeader && "eidos-data-grid-container--sticky-header",
+        densityClass,
+        className
+      ].filter(Boolean).join(" "),
+      style: containerStyle,
+      children: [
+        showToolbar && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "eidos-datagrid-toolbar", children: [
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "eidos-datagrid-toolbar-left", children: selectable && hasSelection && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+            /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "span", { className: "eidos-datagrid-selection-count", children: [
+              selectedSet.size,
+              " selected"
+            ] }),
+            bulkActions && bulkActions.length > 0 && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "eidos-datagrid-bulk-actions", children: bulkActions.map((action) => {
+              const isDisabled = typeof action.disabled === "function" ? action.disabled(selectedItems) : _nullishCoalesce(action.disabled, () => ( false));
+              if (action.type === "split-button") {
+                return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                  _chunkVZ43OLU6cjs.SplitButton,
+                  {
+                    size: "sm",
+                    variant: _nullishCoalesce(action.variant, () => ( "outlined")),
+                    color: _nullishCoalesce(action.color, () => ( "secondary")),
+                    preIcon: action.icon,
+                    disabled: isDisabled,
+                    label: action.label,
+                    onClick: () => action.onClick(selectedItems),
+                    options: action.options.map((option) => ({
+                      id: option.id,
+                      label: option.label,
+                      icon: option.icon,
+                      disabled: option.disabled,
+                      onClick: () => option.onClick(selectedItems)
+                    }))
+                  },
+                  action.id
+                );
+              }
+              return action.label ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                _chunkLTOHGCU4cjs.Button,
+                {
+                  size: "sm",
+                  variant: _nullishCoalesce(action.variant, () => ( "outlined")),
+                  color: _nullishCoalesce(action.color, () => ( "secondary")),
+                  preIcon: action.icon,
+                  posIcon: action.posIcon,
+                  disabled: isDisabled,
+                  onClick: () => action.onClick(selectedItems),
+                  children: action.label
+                },
+                action.id
+              ) : action.icon ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                _chunkLTOHGCU4cjs.Button,
+                {
+                  size: "sm",
+                  variant: _nullishCoalesce(action.variant, () => ( "outlined")),
+                  color: _nullishCoalesce(action.color, () => ( "secondary")),
+                  icon: action.icon,
+                  disabled: isDisabled,
+                  onClick: () => action.onClick(selectedItems)
+                },
+                action.id
+              ) : null;
+            }) }),
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              "button",
+              {
+                type: "button",
+                className: "eidos-datagrid-clear-selection",
+                onClick: clearSelection,
+                "aria-label": "Clear selection",
+                children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.X, { size: 14 })
+              }
+            )
+          ] }) }),
+          /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "eidos-datagrid-toolbar-right", children: [
+            showDensity && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              _chunkKV2FG7ANcjs.Dropdown,
+              {
+                placement: "bottom",
+                align: "end",
+                autoWidth: false,
+                trigger: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkLTOHGCU4cjs.Button, { variant: "text", size: "sm", preIcon: _lucidereact.AlignJustify, children: "Density" }),
+                content: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "eidos-table-menu-panel", children: [
+                  { value: "compact", label: "Compact" },
+                  { value: "comfortable", label: "Comfortable" },
+                  { value: "spacious", label: "Spacious" }
+                ].map((option) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+                  "button",
+                  {
+                    className: [
+                      "eidos-table-menu-item",
+                      effectiveDensity === option.value ? "eidos-table-menu-item--active" : ""
+                    ].filter(Boolean).join(" "),
+                    onClick: () => setInternalDensity(option.value),
+                    children: [
+                      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "eidos-table-menu-item-check", children: effectiveDensity === option.value && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.Check, { size: 14 }) }),
+                      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { children: option.label })
+                    ]
+                  },
+                  option.value
+                )) })
+              }
+            ),
+            showFilters && filterDropdownColumns.length > 0 && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              _chunkL3UPSLJ5cjs.TableFiltersDropdown,
+              {
+                columns: filterDropdownColumns,
+                filters: activeFilters,
+                onFiltersChange: handleFiltersChange
+              }
+            ),
+            onRowAdd && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkLTOHGCU4cjs.Button, { variant: "outlined", size: "sm", preIcon: _lucidereact.Plus, onClick: handleRowAdd, children: "Add row" })
+          ] })
+        ] }),
+        isCardView ? (
+          /* ── Card view ────────────────────────────────────────────────── */
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            "div",
+            {
+              className: "eidos-datagrid-cards",
+              style: { "--eidos-datagrid-card-min-width": `${cardMinWidth}px` },
+              children: displayData.length > 0 ? displayData.map((row, displayIndex) => {
+                const localIndex = localData.indexOf(row);
+                const rowKeyValue = String(_nullishCoalesce(row[rowKey], () => ( displayIndex)));
+                const isRowSelected = selectable && selectedSet.has(rowKeyValue);
+                const isRowExpanded = expandable && expandedSet.has(rowKeyValue);
+                const canExpandRow = !isRowExpandable || isRowExpandable(row);
+                return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+                  "div",
+                  {
+                    className: [
+                      "eidos-datagrid-card",
+                      isRowSelected && "eidos-datagrid-card--selected"
+                    ].filter(Boolean).join(" "),
+                    children: [
+                      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "eidos-datagrid-card-toolbar", onClick: (e) => e.stopPropagation(), children: [
+                        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "eidos-datagrid-card-toolbar-left", children: [
+                          expandable && canExpandRow && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                            "button",
+                            {
+                              type: "button",
+                              className: [
+                                "eidos-datagrid-expand-toggle",
+                                isRowExpanded && "eidos-datagrid-expand-toggle--open"
+                              ].filter(Boolean).join(" "),
+                              onClick: () => toggleExpanded(rowKeyValue),
+                              "aria-expanded": isRowExpanded,
+                              "aria-label": isRowExpanded ? "Collapse row" : "Expand row",
+                              children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.ChevronRight, { size: 14 })
+                            }
+                          ),
+                          selectable && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                            _chunkG2FANEA2cjs.Checkbox,
+                            {
+                              checked: isRowSelected,
+                              onChange: () => toggleRow(rowKeyValue),
+                              size: "sm"
+                            }
+                          ),
+                          showRowNumbers && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "span", { className: "eidos-datagrid-card-row-number", children: [
+                            "#",
+                            localIndex + 1
+                          ] })
+                        ] }),
+                        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "eidos-datagrid-card-heading", children: [
+                          cardHeaderColumn && renderCardValue(
+                            cardHeaderColumn,
+                            row,
+                            localIndex,
+                            "eidos-datagrid-card-heading-title"
+                          ),
+                          cardSubheaderColumn && renderCardValue(
+                            cardSubheaderColumn,
+                            row,
+                            localIndex,
+                            "eidos-datagrid-card-heading-subtitle"
+                          )
+                        ] }),
+                        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "eidos-datagrid-card-toolbar-right", children: renderActionsMenu(row, localIndex) })
+                      ] }),
+                      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "eidos-datagrid-card-fields", children: cardFieldColumns.map((col) => renderCardField(col, row, localIndex)) }),
+                      expandable && renderExpandedContent && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                        ExpandedCardPanel,
+                        {
+                          isOpen: isRowExpanded,
+                          render: () => renderExpandedContent(row, localIndex)
+                        }
+                      )
+                    ]
+                  },
+                  rowKeyValue
+                );
+              }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "eidos-datagrid-card-empty", children: Object.keys(activeFilters).length > 0 ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                _chunkV5JNYS77cjs.EmptyState,
+                {
+                  icon: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.SearchX, {}),
+                  title: "No results found",
+                  description: "Try adjusting your filters or search terms.",
+                  action: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                    _chunkLTOHGCU4cjs.Button,
+                    {
+                      size: "sm",
+                      variant: "outlined",
+                      color: "primary",
+                      onClick: () => handleFiltersChange({}),
+                      children: "Clear filters"
+                    }
+                  ),
+                  size: "sm"
+                }
+              ) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                _chunkV5JNYS77cjs.EmptyState,
+                {
+                  icon: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.FolderOpen, {}),
+                  title: emptyText,
+                  description: onRowAdd ? "Add a row to get started." : "There are no records to display.",
+                  size: "sm"
+                }
+              ) })
+            }
+          )
+        ) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _chunkL3UPSLJ5cjs.DndContext,
+          {
+            sensors,
+            collisionDetection: _chunkL3UPSLJ5cjs.closestCenter,
+            onDragEnd: handleRowDragEnd,
+            children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "eidos-data-grid-scroll", children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "table", { className: ["eidos-data-grid", densityClass].filter(Boolean).join(" "), children: [
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "thead", { ref: theadRef, children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "tr", { children: [
+                draggableRows && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                  "th",
+                  {
+                    className: [
+                      "eidos-data-grid-header-cell",
+                      "eidos-datagrid-drag-handle-cell",
+                      dragHeaderPin.className
+                    ].filter(Boolean).join(" "),
+                    style: dragHeaderPin.style,
+                    "data-col-key": "__drag__"
+                  }
+                ),
+                expandable && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                  "th",
+                  {
+                    className: [
+                      "eidos-data-grid-header-cell",
+                      "eidos-datagrid-expand-cell",
+                      expandHeaderPin.className
+                    ].filter(Boolean).join(" "),
+                    style: expandHeaderPin.style,
+                    "data-col-key": "__expand__"
+                  }
+                ),
+                selectable && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                  "th",
+                  {
+                    className: [
+                      "eidos-data-grid-header-cell",
+                      "eidos-datagrid-checkbox-cell",
+                      selHeaderPin.className
+                    ].filter(Boolean).join(" "),
+                    style: selHeaderPin.style,
+                    "data-col-key": "__sel__",
+                    children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                      _chunkG2FANEA2cjs.Checkbox,
+                      {
+                        checked: allSelected,
+                        indeterminate: someSelected,
+                        onChange: toggleAll,
+                        size: "sm"
+                      }
+                    )
+                  }
+                ),
+                showRowNumbers && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                  "th",
+                  {
+                    className: [
+                      "eidos-data-grid-header-cell",
+                      "eidos-data-grid-row-number-col",
+                      rownumHeaderPin.className
+                    ].filter(Boolean).join(" "),
+                    style: rownumHeaderPin.style,
+                    "data-col-key": "__rownum__",
+                    children: "#"
+                  }
+                ),
+                sortedColumns.map((col) => {
+                  const colKey = col.key;
+                  const isSortable = !!col.sortable;
+                  const isCurrentlySorted = _optionalChain([activeSort, 'optionalAccess', _34 => _34.key]) === colKey;
+                  const sortDir = isCurrentlySorted ? activeSort.direction : null;
+                  const { style: pinnedStyle, className: pinnedClass } = getHeaderPinnedProps(colKey);
+                  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                    "th",
+                    {
+                      className: [
+                        "eidos-data-grid-header-cell",
+                        isSortable && "eidos-datagrid-header-cell--sortable",
+                        isCurrentlySorted && "eidos-datagrid-header-cell--sorted",
+                        pinnedClass
+                      ].filter(Boolean).join(" "),
+                      style: {
+                        width: col.width != null ? typeof col.width === "number" ? `${col.width}px` : col.width : void 0,
+                        minWidth: col.minWidth != null ? typeof col.minWidth === "number" ? `${col.minWidth}px` : col.minWidth : void 0,
+                        ...pinnedStyle
+                      },
+                      "data-col-key": colKey,
+                      onClick: isSortable ? () => handleSortClick(colKey) : void 0,
+                      children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "eidos-datagrid-header-content", children: [
+                        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "eidos-datagrid-header-label", children: col.header }),
+                        isSortable && /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "span", { className: "eidos-datagrid-sort-icon", children: [
+                          sortDir === "asc" && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.ArrowUp, { size: 14 }),
+                          sortDir === "desc" && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.ArrowDown, { size: 14 }),
+                          !sortDir && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.ChevronsUpDown, { size: 14 })
+                        ] })
+                      ] })
+                    },
+                    colKey
+                  );
+                }),
+                actionsColumn && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                  "th",
+                  {
+                    className: "eidos-data-grid-header-cell eidos-data-grid-actions-col",
+                    "data-col-key": "__actions__"
+                  }
+                )
+              ] }) }),
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tbody", { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkL3UPSLJ5cjs.SortableContext, { items: rowIds, strategy: _chunkL3UPSLJ5cjs.verticalListSortingStrategy, children: displayData.length > 0 ? displayData.map((row, displayIndex) => {
+                const localIndex = localData.indexOf(row);
+                const rowKeyValue = String(_nullishCoalesce(row[rowKey], () => ( displayIndex)));
+                const isRowSelected = selectable && selectedSet.has(rowKeyValue);
+                const isRowExpanded = expandable && expandedSet.has(rowKeyValue);
+                const canExpandRow = !isRowExpandable || isRowExpandable(row);
+                return (
+                  // React.Fragment (rather than SortableTableRow taking the
+                  // `key` directly) so an expanded row's detail <tr> - see
+                  // ExpandedTableRow below - can sit right underneath it as
+                  // a sibling, keyed together as one reconciliation unit.
+                  /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _react2.default.Fragment, { children: [
+                    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                      SortableTableRow,
+                      {
+                        id: rowKeyValue,
+                        disabled: !draggableRows,
+                        className: [
+                          "eidos-data-grid-row",
+                          isRowSelected && "eidos-datagrid-row--selected"
+                        ].filter(Boolean).join(" "),
+                        children: (dragHandleProps, isDragging) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+                          draggableRows && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                            "td",
+                            {
+                              className: [
+                                "eidos-datagrid-drag-handle-cell",
+                                dragCellPin.className
+                              ].filter(Boolean).join(" "),
+                              style: dragCellPin.style,
+                              onClick: (e) => e.stopPropagation(),
+                              children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                                "span",
+                                {
+                                  ...dragHandleProps,
+                                  className: [
+                                    "eidos-datagrid-drag-handle",
+                                    isDragging && "eidos-datagrid-drag-handle--dragging"
+                                  ].filter(Boolean).join(" "),
+                                  title: "Drag to reorder",
+                                  children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.GripVertical, { size: 14 })
+                                }
+                              )
+                            }
+                          ),
+                          expandable && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                            "td",
+                            {
+                              className: [
+                                "eidos-data-grid-cell",
+                                "eidos-datagrid-expand-cell",
+                                expandCellPin.className
+                              ].filter(Boolean).join(" "),
+                              style: expandCellPin.style,
+                              onClick: (e) => e.stopPropagation(),
+                              children: canExpandRow && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                                "button",
+                                {
+                                  type: "button",
+                                  className: [
+                                    "eidos-datagrid-expand-toggle",
+                                    isRowExpanded && "eidos-datagrid-expand-toggle--open"
+                                  ].filter(Boolean).join(" "),
+                                  onClick: () => toggleExpanded(rowKeyValue),
+                                  "aria-expanded": isRowExpanded,
+                                  "aria-label": isRowExpanded ? "Collapse row" : "Expand row",
+                                  children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.ChevronRight, { size: 14 })
+                                }
+                              )
+                            }
+                          ),
+                          selectable && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                            "td",
+                            {
+                              className: [
+                                "eidos-data-grid-cell",
+                                "eidos-datagrid-checkbox-cell",
+                                selCellPin.className
+                              ].filter(Boolean).join(" "),
+                              style: selCellPin.style,
+                              onClick: (e) => e.stopPropagation(),
+                              children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                                _chunkG2FANEA2cjs.Checkbox,
+                                {
+                                  checked: isRowSelected,
+                                  onChange: () => toggleRow(rowKeyValue),
+                                  size: "sm"
+                                }
+                              )
+                            }
+                          ),
+                          showRowNumbers && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                            "td",
+                            {
+                              className: [
+                                "eidos-data-grid-cell",
+                                "eidos-data-grid-row-number",
+                                rownumCellPin.className
+                              ].filter(Boolean).join(" "),
+                              style: rownumCellPin.style,
+                              children: localIndex + 1
+                            }
+                          ),
+                          sortedColumns.map((col) => {
+                            const value = row[col.key];
+                            const isEditing = _optionalChain([editingCell, 'optionalAccess', _35 => _35.rowIndex]) === localIndex && _optionalChain([editingCell, 'optionalAccess', _36 => _36.colKey]) === col.key;
+                            const canEdit = isCellEditable(col);
+                            const isFlagged = cellErrorKey(localIndex, col.key) in cellErrors;
+                            const hasError = isEditing && Boolean(editError);
+                            const { style: pinnedStyle, className: pinnedClass } = getCellPinnedProps(col.key);
+                            const cellCls = [
+                              "eidos-data-grid-cell",
+                              isEditing && "eidos-data-grid-cell--editing",
+                              hasError && "eidos-data-grid-cell--error",
+                              isFlagged && !hasError && "eidos-data-grid-cell--has-error",
+                              canEdit && !isEditing && "eidos-data-grid-cell--editable",
+                              col.type === "readonly" && "eidos-data-grid-cell--readonly",
+                              pinnedClass
+                            ].filter(Boolean).join(" ");
+                            return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                              "td",
+                              {
+                                ref: hasError ? errorTooltipAnchorRef : void 0,
+                                className: cellCls,
+                                style: pinnedStyle,
+                                onClick: () => handleCellClick(localIndex, col),
+                                onKeyDown: isEditing ? (e) => handleKeyDown(e, localIndex, col.key) : void 0,
+                                tabIndex: isEditing ? -1 : void 0,
+                                children: isEditing ? renderEditCell(col, editValue, row, localIndex) : renderViewCell(col, value, row, localIndex)
+                              },
+                              col.key
+                            );
+                          }),
+                          actionsColumn && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                            "td",
+                            {
+                              className: "eidos-data-grid-cell eidos-data-grid-actions-col",
+                              onClick: (e) => e.stopPropagation(),
+                              children: renderActionsMenu(row, localIndex)
+                            }
+                          )
+                        ] })
+                      }
+                    ),
+                    expandable && renderExpandedContent && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                      ExpandedTableRow,
+                      {
+                        isOpen: isRowExpanded,
+                        colSpan: totalCols,
+                        render: () => renderExpandedContent(row, localIndex)
+                      }
+                    )
+                  ] }, rowKeyValue)
+                );
+              }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "tr", { className: "eidos-data-grid-empty-row", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                "td",
+                {
+                  colSpan: totalCols,
+                  className: "eidos-data-grid-cell eidos-data-grid-empty-cell",
+                  children: Object.keys(activeFilters).length > 0 ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                    _chunkV5JNYS77cjs.EmptyState,
+                    {
+                      icon: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.SearchX, {}),
+                      title: "No results found",
+                      description: "Try adjusting your filters or search terms.",
+                      action: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                        _chunkLTOHGCU4cjs.Button,
+                        {
+                          size: "sm",
+                          variant: "outlined",
+                          color: "primary",
+                          onClick: () => handleFiltersChange({}),
+                          children: "Clear filters"
+                        }
+                      ),
+                      size: "sm"
+                    }
+                  ) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                    _chunkV5JNYS77cjs.EmptyState,
+                    {
+                      icon: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _lucidereact.FolderOpen, {}),
+                      title: emptyText,
+                      description: onRowAdd ? "Add a row to get started." : "There are no records to display.",
+                      size: "sm"
+                    }
+                  )
+                }
+              ) }) }) })
+            ] }) })
+          }
+        ) }),
+        showPagination && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "eidos-datagrid-footer", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _chunkSAFSEXMUcjs.Pagination,
+          {
+            page: currentPage,
+            totalPages,
+            onChange: handlePageChange,
+            totalItems: totalItemCount,
+            pageSize: currentPageSize,
+            onPageSizeChange: handlePageSizeChange,
+            pageSizeOptions: effectivePageSizeOptions
+          }
+        ) }),
+        activeCellError && errorTooltipPosition && _reactdom.createPortal.call(void 0, 
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            "div",
+            {
+              className: "eidos-data-grid-cell-error",
+              style: { top: errorTooltipPosition.top, left: errorTooltipPosition.left },
+              children: activeCellError
+            }
+          ),
+          document.body
+        )
+      ]
+    }
+  );
+}
+var DataGrid = Object.assign(DataGridInner, { displayName: "DataGrid" });
+
+
+
+exports.DataGrid = DataGrid;
+//# sourceMappingURL=chunk-HPIBYEGE.cjs.map