react-glide-table 1.1.1 → 1.1.3

package/dist/compound.js

@@ -0,0 +1,2217 @@
+// src/components/ui/table/components/DataTable/DataTable.tsx
+import { flexRender as flexRender2 } from "@tanstack/react-table";
+import { useMemo as useMemo3 } from "react";
+
+// src/components/ui/table/components/DataTable/DataTableRow.tsx
+import { flexRender } from "@tanstack/react-table";
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+
+// src/components/ui/table/constants.ts
+var CELL_ALIGN_CLASS = {
+  left: "cell-align-left",
+  center: "cell-align-center",
+  right: "cell-align-right"
+};
+var ROW_HOVER_CLASS = "row-hoverable";
+var ROW_HOVERED_BG_CLASS = "row-hovered";
+var CELL_SELECTION_FILL_CLASS = "cell-selection-fill";
+var DATA_TABLE_ROW_HEIGHT = 44;
+var DATA_TABLE_VIRTUAL_OVERSCAN = 8;
+
+// src/components/ui/table/DataTableContext.tsx
+import { createContext, use } from "react";
+import { jsx } from "react/jsx-runtime";
+var DataTableContext = createContext(null);
+function useDataTableRowContext() {
+  const context = use(DataTableContext);
+  if (!context) {
+    throw new Error("useDataTableRowContext must be used within a DataTableContextProvider");
+  }
+  return context;
+}
+function DataTableContextProvider({
+  value,
+  children
+}) {
+  return /* @__PURE__ */ jsx(DataTableContext, { value, children });
+}
+
+// src/components/ui/table/features/cell-edit/cellEdit.ts
+function getColumnAccessorKey(columnDef) {
+  if (columnDef.accessorKey !== void 0 && columnDef.accessorKey !== null) {
+    return String(columnDef.accessorKey);
+  }
+  return columnDef.id;
+}
+function isColumnEditable(columnDef) {
+  return Boolean(columnDef.meta?.editable);
+}
+function getColumnEditType(columnDef) {
+  return columnDef.meta?.editType ?? "text";
+}
+function parseCellEditValue(raw, editType) {
+  if (editType === "text") {
+    return { ok: true, value: raw };
+  }
+  const trimmed = raw.trim();
+  if (trimmed === "") {
+    return { ok: true, value: null };
+  }
+  const parsed = Number(trimmed);
+  if (Number.isNaN(parsed)) {
+    return { ok: false };
+  }
+  return { ok: true, value: parsed };
+}
+function getCellEditDraftValue(value) {
+  if (value === null || value === void 0) return "";
+  return String(value);
+}
+function applyCellEdit(data, rows, rowIndex, colIndex, raw) {
+  const cell = rows[rowIndex]?.getVisibleCells()[colIndex];
+  if (!cell) return null;
+  const columnDef = cell.column.columnDef;
+  if (!isColumnEditable(columnDef)) return null;
+  const accessorKey = getColumnAccessorKey(columnDef);
+  if (!accessorKey) return null;
+  const parsed = parseCellEditValue(raw, getColumnEditType(columnDef));
+  if (!parsed.ok) return null;
+  const newData = data.map((row) => ({ ...row }));
+  if (!newData[rowIndex]) return null;
+  newData[rowIndex][accessorKey] = parsed.value;
+  return newData;
+}
+
+// src/components/ui/table/features/cell-selection/cellSelection.ts
+var INITIAL_DRAG_STATE = {
+  isSelecting: false,
+  isFillDragging: false,
+  start: null,
+  end: null,
+  fillAnchor: null,
+  fillEnd: null
+};
+function getCellSelectionBounds(start, end) {
+  if (!start || !end) return null;
+  return {
+    startRow: Math.min(start.row, end.row),
+    endRow: Math.max(start.row, end.row),
+    startCol: Math.min(start.col, end.col),
+    endCol: Math.max(start.col, end.col)
+  };
+}
+function getRowIndexInMergedCell(clientY, cellElement, rowIndex, rowSpan) {
+  if (rowSpan <= 1) return rowIndex;
+  const rect = cellElement.getBoundingClientRect();
+  const relativeY = clientY - rect.top;
+  const rowHeight = rect.height / rowSpan;
+  const offset = Math.min(
+    Math.max(Math.floor(relativeY / rowHeight), 0),
+    rowSpan - 1
+  );
+  return rowIndex + offset;
+}
+function isCellInSelection(rowIndex, colIndex, bounds, rowSpan = 1) {
+  if (!bounds) return false;
+  const cellEndRow = rowIndex + rowSpan - 1;
+  return cellEndRow >= bounds.startRow && rowIndex <= bounds.endRow && colIndex >= bounds.startCol && colIndex <= bounds.endCol;
+}
+function getActiveSelectionBounds(dragState, selectionBounds) {
+  if (dragState.isFillDragging && dragState.fillAnchor && dragState.fillEnd) {
+    return getCellSelectionBounds(dragState.fillAnchor, dragState.fillEnd);
+  }
+  return selectionBounds;
+}
+var SELECTION_EDGE_WIDTH_PX = 2;
+var SELECTION_EDGE_COLOR = "var(--color-brand-primary)";
+var CELL_SELECTION_EDGES_CLASS = "cell-selection-edges";
+function getMergedCellStepEdges(rowIndex, colIndex, bounds, rowSpan, isVisuallySelectedAt) {
+  const cellEndRow = rowIndex + rowSpan - 1;
+  const span = cellEndRow - rowIndex + 1;
+  if (span <= 1) return [];
+  const edges = [];
+  const isNeighborSelected = (row, neighborCol) => {
+    if (isVisuallySelectedAt) {
+      return isVisuallySelectedAt(row, neighborCol);
+    }
+    return row >= bounds.startRow && row <= bounds.endRow && neighborCol >= bounds.startCol && neighborCol <= bounds.endCol;
+  };
+  const pushUnselectedRuns = (side, neighborCol, fromRow, toRowExclusive) => {
+    let runStart = null;
+    for (let row = fromRow; row < toRowExclusive; row++) {
+      if (!isNeighborSelected(row, neighborCol)) {
+        if (runStart === null) runStart = row;
+        continue;
+      }
+      if (runStart !== null) {
+        edges.push({
+          side,
+          offsetRatio: (runStart - rowIndex) / span,
+          heightRatio: (row - runStart) / span
+        });
+        runStart = null;
+      }
+    }
+    if (runStart !== null) {
+      edges.push({
+        side,
+        offsetRatio: (runStart - rowIndex) / span,
+        heightRatio: (toRowExclusive - runStart) / span
+      });
+    }
+  };
+  const collectSide = (side, neighborCol) => {
+    if (bounds.startRow > rowIndex) {
+      pushUnselectedRuns(
+        side,
+        neighborCol,
+        rowIndex,
+        Math.min(bounds.startRow, cellEndRow + 1)
+      );
+    }
+    if (bounds.endRow < cellEndRow) {
+      pushUnselectedRuns(
+        side,
+        neighborCol,
+        Math.max(bounds.endRow + 1, rowIndex),
+        cellEndRow + 1
+      );
+    }
+  };
+  if (colIndex < bounds.endCol) {
+    collectSide("right", colIndex + 1);
+  }
+  if (colIndex > bounds.startCol) {
+    collectSide("left", colIndex - 1);
+  }
+  return edges;
+}
+function buildPartialVerticalGradient(edge) {
+  const startPct = edge.offsetRatio * 100;
+  const endPct = (edge.offsetRatio + edge.heightRatio) * 100;
+  const overlapPx = SELECTION_EDGE_WIDTH_PX + 1;
+  const isTopProtrusion = edge.offsetRatio === 0 && edge.heightRatio < 1;
+  const isBottomProtrusion = edge.offsetRatio > 0;
+  const startStop = isBottomProtrusion ? `calc(${startPct}% - ${overlapPx}px)` : `${startPct}%`;
+  const endStop = isTopProtrusion ? `calc(${endPct}% + ${overlapPx}px)` : `${endPct}%`;
+  const xPos = edge.side === "left" ? "0" : "100%";
+  const layers = [
+    {
+      image: `linear-gradient(to bottom, transparent 0%, transparent ${startStop}, ${SELECTION_EDGE_COLOR} ${startStop}, ${SELECTION_EDGE_COLOR} ${endStop}, transparent ${endStop}, transparent 100%)`,
+      size: `${SELECTION_EDGE_WIDTH_PX}px 100%`,
+      position: `${xPos} 0`
+    }
+  ];
+  if (isTopProtrusion || isBottomProtrusion) {
+    const capTop = isTopProtrusion ? `calc(${endPct}% - ${SELECTION_EDGE_WIDTH_PX}px)` : `calc(${startPct}% - ${SELECTION_EDGE_WIDTH_PX}px)`;
+    layers.push({
+      image: `linear-gradient(${SELECTION_EDGE_COLOR}, ${SELECTION_EDGE_COLOR})`,
+      size: `${SELECTION_EDGE_WIDTH_PX}px ${SELECTION_EDGE_WIDTH_PX}px`,
+      position: `${xPos} ${capTop}`
+    });
+  }
+  return layers;
+}
+function getCellSelectionEdgeStyle(rowIndex, colIndex, bounds, rowSpan = 1, isVisuallySelectedAt) {
+  if (!isCellInSelection(rowIndex, colIndex, bounds, rowSpan) || !bounds)
+    return void 0;
+  const cellEndRow = rowIndex + rowSpan - 1;
+  const isTopEdge = bounds.startRow >= rowIndex && bounds.startRow <= cellEndRow;
+  const isBottomEdge = bounds.endRow >= rowIndex && bounds.endRow <= cellEndRow;
+  const isLeftEdge = colIndex === bounds.startCol;
+  const isRightEdge = colIndex === bounds.endCol;
+  const selectionContinuesBelow = cellEndRow < bounds.endRow;
+  const shadows = [];
+  if (isTopEdge) {
+    shadows.push(
+      `inset 0 ${SELECTION_EDGE_WIDTH_PX}px 0 0 ${SELECTION_EDGE_COLOR}`
+    );
+  }
+  if (isBottomEdge) {
+    shadows.push(
+      `inset 0 -${SELECTION_EDGE_WIDTH_PX}px 0 0 ${SELECTION_EDGE_COLOR}`
+    );
+  }
+  if (isLeftEdge) {
+    shadows.push(
+      `inset ${SELECTION_EDGE_WIDTH_PX}px 0 0 0 ${SELECTION_EDGE_COLOR}`
+    );
+  }
+  if (isRightEdge) {
+    shadows.push(
+      `inset -${SELECTION_EDGE_WIDTH_PX}px 0 0 0 ${SELECTION_EDGE_COLOR}`
+    );
+  }
+  const stepEdges = getMergedCellStepEdges(
+    rowIndex,
+    colIndex,
+    bounds,
+    rowSpan,
+    isVisuallySelectedAt
+  );
+  const gradients = [];
+  const sizes = [];
+  const positions = [];
+  for (const edge of stepEdges) {
+    for (const partial of buildPartialVerticalGradient(edge)) {
+      gradients.push(partial.image);
+      sizes.push(partial.size);
+      positions.push(partial.position);
+    }
+  }
+  if (shadows.length === 0 && gradients.length === 0 && !selectionContinuesBelow) {
+    return void 0;
+  }
+  const style = {};
+  if (shadows.length > 0) {
+    style["--selection-edge-shadows"] = shadows.join(", ");
+  }
+  if (gradients.length > 0) {
+    style["--selection-edge-gradients"] = gradients.join(", ");
+    style["--selection-edge-sizes"] = sizes.join(", ");
+    style["--selection-edge-positions"] = positions.join(", ");
+  }
+  if (selectionContinuesBelow) {
+    style.borderBottomColor = "var(--color-brand-surface)";
+  }
+  return style;
+}
+function hasCellSelectionEdges(style) {
+  return Boolean(
+    style?.["--selection-edge-shadows"] || style?.["--selection-edge-gradients"]
+  );
+}
+
+// src/components/ui/table/features/row-expand/row-expand.ts
+import { useEffect, useMemo, useRef } from "react";
+
+// src/core/treeDefaults.ts
+var DEFAULT_TREE_ID_FIELD = "id";
+var DEFAULT_TREE_PARENT_ID_FIELD = "parentId";
+var DEFAULT_TREE_CHILDREN_FIELD = "children";
+var DEFAULT_TREE_QTY_FIELD = "qty";
+
+// src/components/ui/table/features/row-expand/row-expand.ts
+function getFieldValue(row, key) {
+  return row[key];
+}
+function canExpandRow(row) {
+  const children = row.children;
+  const level = row.level;
+  return Array.isArray(children) && children.length > 0 && (level === 0 || level === void 0);
+}
+function toggleExpandedRowId(rowId, previous) {
+  const next = new Set(previous);
+  if (next.has(rowId)) {
+    next.delete(rowId);
+  } else {
+    next.add(rowId);
+  }
+  return next;
+}
+var useConvertTreeData = ({
+  data,
+  enabled = true,
+  toggleField = DEFAULT_TREE_ID_FIELD,
+  childField = DEFAULT_TREE_PARENT_ID_FIELD,
+  flattenField = DEFAULT_TREE_CHILDREN_FIELD,
+  qtyField = DEFAULT_TREE_QTY_FIELD,
+  preventExpand = false,
+  startIndex = 1,
+  expandedRows,
+  onExpandedRowsChange
+}) => {
+  const onExpandedRowsChangeRef = useRef(onExpandedRowsChange);
+  const hasInitializedRef = useRef(false);
+  useEffect(() => {
+    onExpandedRowsChangeRef.current = onExpandedRowsChange;
+  }, [onExpandedRowsChange]);
+  useEffect(() => {
+    if (!data || data.length === 0) {
+      hasInitializedRef.current = false;
+      return;
+    }
+    if (!enabled || hasInitializedRef.current) return;
+    const ids = data.map((item) => getFieldValue(item, toggleField)).filter((value) => typeof value === "string" && value.length > 0);
+    onExpandedRowsChangeRef.current?.(new Set(ids));
+    hasInitializedRef.current = true;
+  }, [enabled, data, toggleField]);
+  const processedData = useMemo(() => {
+    if (!enabled || !data || data.length === 0) return [];
+    const flattenedData = [];
+    const flattenItems = (items) => {
+      items.forEach((item) => {
+        const newItem = { ...item };
+        const nested = newItem[flattenField];
+        if (Array.isArray(nested)) {
+          const children = nested.map(
+            (child) => typeof child === "object" && child !== null ? { ...child } : child
+          );
+          delete newItem[flattenField];
+          flattenedData.push(newItem);
+          children.forEach((child) => {
+            if (typeof child === "object" && child !== null) {
+              ;
+              child[childField] = newItem[toggleField];
+            }
+          });
+          flattenItems(children);
+        } else {
+          flattenedData.push(newItem);
+        }
+      });
+    };
+    flattenItems(data);
+    const dataWithLevels = flattenedData.map((item) => ({
+      ...item,
+      level: 0,
+      children: [],
+      processed: false
+    }));
+    const itemMap = /* @__PURE__ */ new Map();
+    dataWithLevels.forEach((item) => {
+      const key = getFieldValue(item, toggleField);
+      if (typeof key !== "string" || !key) return;
+      if (!itemMap.has(key)) {
+        itemMap.set(key, []);
+      }
+      itemMap.get(key)?.push(item);
+    });
+    const rootItems = [];
+    dataWithLevels.forEach((item) => {
+      if (!getFieldValue(item, childField)) {
+        rootItems.push(item);
+        item.processed = true;
+      }
+    });
+    dataWithLevels.forEach((item) => {
+      const parentKey = getFieldValue(item, childField);
+      if (!parentKey || item.processed) return;
+      const parentItems = dataWithLevels.filter(
+        (parent) => getFieldValue(parent, toggleField) === parentKey && !getFieldValue(parent, childField)
+      );
+      if (parentItems.length > 0) {
+        const parent = parentItems[0];
+        item.level = parent.level + 1;
+        parent.children.push(item);
+        item.processed = true;
+      } else {
+        const otherParents = itemMap.get(String(parentKey)) || [];
+        if (otherParents.length > 0) {
+          const parent = otherParents[0];
+          item.level = parent.level + 1;
+          parent.children.push(item);
+          item.processed = true;
+        } else {
+          rootItems.push(item);
+          item.processed = true;
+        }
+      }
+    });
+    return rootItems;
+  }, [enabled, data, toggleField, childField, flattenField]);
+  const flattenTree = useMemo(() => {
+    if (!enabled) return [];
+    const flatten = (nodes, result = [], level = 0) => {
+      nodes.forEach((node, index) => {
+        const currentIndex = level === 0 ? `${index + startIndex}` : `${level}-${index + 1}`;
+        const toggleValue = getFieldValue(node, toggleField);
+        const uniqueId = `${index}-${String(toggleValue ?? "")}`;
+        result.push({
+          ...node,
+          treeNo: currentIndex,
+          uniqueId,
+          processed: true
+        });
+        const shouldExpandChildren = node.children.length > 0 && (preventExpand || typeof toggleValue === "string" && expandedRows?.has(toggleValue));
+        if (shouldExpandChildren) {
+          flatten(node.children, result, index + startIndex);
+        }
+      });
+      return result;
+    };
+    const flattenedData = flatten(processedData, [], 0);
+    flattenedData.forEach((item) => {
+      if (getFieldValue(item, childField)) {
+        const parentItem = flattenedData.find(
+          (parent) => getFieldValue(parent, toggleField) === getFieldValue(item, childField)
+        );
+        const parentAmount = parentItem ? Number(getFieldValue(parentItem, qtyField) ?? 1) : 1;
+        item.parentCount = parentAmount || 1;
+      } else {
+        item.parentCount = 1;
+      }
+    });
+    return flattenedData;
+  }, [
+    enabled,
+    processedData,
+    startIndex,
+    toggleField,
+    childField,
+    qtyField,
+    preventExpand,
+    expandedRows
+  ]);
+  const sortedData = useMemo(() => {
+    if (!enabled) {
+      return data ?? [];
+    }
+    return [...flattenTree].sort((a, b) => {
+      const aParts = String(a.treeNo ?? "").split("-").map(Number);
+      const bParts = String(b.treeNo ?? "").split("-").map(Number);
+      for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+        const aVal = aParts[i] || 0;
+        const bVal = bParts[i] || 0;
+        if (aVal !== bVal) {
+          return aVal - bVal;
+        }
+      }
+      return 0;
+    });
+  }, [enabled, data, flattenTree]);
+  return sortedData;
+};
+
+// src/components/ui/table/features/row-span/rowSpan.ts
+function getRowFieldValue(row, key) {
+  return row[key];
+}
+function computeRowSpans(data, rowSpanKey) {
+  if (data.length === 0) return [];
+  const result = [];
+  for (let index = 0; index < data.length; index++) {
+    const currentValue = getRowFieldValue(data[index], rowSpanKey);
+    const previousValue = index > 0 ? getRowFieldValue(data[index - 1], rowSpanKey) : void 0;
+    if (index > 0 && currentValue === previousValue) {
+      result.push({ rowSpan: 0, isFirstInGroup: false });
+      continue;
+    }
+    let span = 1;
+    for (let nextIndex = index + 1; nextIndex < data.length; nextIndex++) {
+      if (getRowFieldValue(data[nextIndex], rowSpanKey) === currentValue) {
+        span++;
+      } else {
+        break;
+      }
+    }
+    result.push({ rowSpan: span, isFirstInGroup: true });
+  }
+  return result;
+}
+function resolveRowSpanAt(rowSpans, rowIndex) {
+  if (!rowSpans?.[rowIndex]) {
+    return { startRow: rowIndex, rowSpan: 1 };
+  }
+  const current = rowSpans[rowIndex];
+  if (current.rowSpan > 0) {
+    return { startRow: rowIndex, rowSpan: current.rowSpan };
+  }
+  for (let row = rowIndex - 1; row >= 0; row--) {
+    const info = rowSpans[row];
+    if (info && info.rowSpan > 0) {
+      return { startRow: row, rowSpan: info.rowSpan };
+    }
+  }
+  return { startRow: rowIndex, rowSpan: 1 };
+}
+function buildColumnRowSpanMap(data, columnKeys) {
+  const map = /* @__PURE__ */ new Map();
+  for (const { columnId, rowSpanKey } of columnKeys) {
+    map.set(columnId, computeRowSpans(data, rowSpanKey));
+  }
+  return map;
+}
+function collectRowSpanColumns(columns) {
+  const result = [];
+  const visit = (defs) => {
+    for (const columnDef of defs) {
+      if ("columns" in columnDef && columnDef.columns?.length) {
+        visit(columnDef.columns);
+        continue;
+      }
+      const columnId = columnDef.id ?? ("accessorKey" in columnDef && columnDef.accessorKey ? String(columnDef.accessorKey) : void 0);
+      if (!columnId || !columnDef.meta?.rowSpan) continue;
+      result.push({
+        columnId,
+        rowSpanKey: columnDef.meta.rowSpanKey ?? columnId
+      });
+    }
+  };
+  visit(columns);
+  return result;
+}
+
+// src/components/ui/table/components/icons.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function ChevronDown({ className, "aria-hidden": ariaHidden = true }) {
+  return /* @__PURE__ */ jsx2(
+    "svg",
+    {
+      className,
+      "aria-hidden": ariaHidden,
+      width: "16",
+      height: "16",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: /* @__PURE__ */ jsx2("path", { d: "m6 9 6 6 6-6" })
+    }
+  );
+}
+function ChevronUp({ className, "aria-hidden": ariaHidden = true }) {
+  return /* @__PURE__ */ jsx2(
+    "svg",
+    {
+      className,
+      "aria-hidden": ariaHidden,
+      width: "16",
+      height: "16",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: /* @__PURE__ */ jsx2("path", { d: "m18 15-6-6-6 6" })
+    }
+  );
+}
+function ChevronLeft({ className, "aria-hidden": ariaHidden = true }) {
+  return /* @__PURE__ */ jsx2(
+    "svg",
+    {
+      className,
+      "aria-hidden": ariaHidden,
+      width: "16",
+      height: "16",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: /* @__PURE__ */ jsx2("path", { d: "m15 18-6-6 6-6" })
+    }
+  );
+}
+function ChevronRight({ className, "aria-hidden": ariaHidden = true }) {
+  return /* @__PURE__ */ jsx2(
+    "svg",
+    {
+      className,
+      "aria-hidden": ariaHidden,
+      width: "16",
+      height: "16",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: /* @__PURE__ */ jsx2("path", { d: "m9 18 6-6-6-6" })
+    }
+  );
+}
+function ArrowUp({ className, "aria-hidden": ariaHidden = true }) {
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      className,
+      "aria-hidden": ariaHidden,
+      width: "14",
+      height: "14",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx2("path", { d: "m18 15-6-6-6 6" }),
+        /* @__PURE__ */ jsx2("path", { d: "M12 21V9" })
+      ]
+    }
+  );
+}
+function ArrowDown({ className, "aria-hidden": ariaHidden = true }) {
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      className,
+      "aria-hidden": ariaHidden,
+      width: "14",
+      height: "14",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx2("path", { d: "m6 9 6 6 6-6" }),
+        /* @__PURE__ */ jsx2("path", { d: "M12 3v12" })
+      ]
+    }
+  );
+}
+function ArrowUpDown({ className, "aria-hidden": ariaHidden = true }) {
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      className,
+      "aria-hidden": ariaHidden,
+      width: "14",
+      height: "14",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx2("path", { d: "m21 16-4 4-4-4" }),
+        /* @__PURE__ */ jsx2("path", { d: "M17 20V4" }),
+        /* @__PURE__ */ jsx2("path", { d: "m3 8 4-4 4 4" }),
+        /* @__PURE__ */ jsx2("path", { d: "M7 4v16" })
+      ]
+    }
+  );
+}
+
+// src/lib/cn.ts
+function cn(...inputs) {
+  return inputs.filter(Boolean).join(" ");
+}
+
+// src/components/ui/table/components/DataTable/DataTableRow.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function resolveExpandCellIndex(cells, toggleField) {
+  if (!toggleField) return 0;
+  const matchedIndex = cells.findIndex(
+    (cell) => cell.column.id === toggleField
+  );
+  if (matchedIndex >= 0) return matchedIndex;
+  const noColumnIndex = cells.findIndex(
+    (cell) => cell.column.id === "no" || cell.column.id === "treeNo"
+  );
+  if (noColumnIndex >= 0 && noColumnIndex + 1 < cells.length) {
+    return noColumnIndex + 1;
+  }
+  return 0;
+}
+function DataTableRow({
+  row,
+  onToggleSelect,
+  virtualIndex,
+  measureElement
+}) {
+  const { classNames, rowSpan, selection, cellSelection, cellEdit, expand } = useDataTableRowContext();
+  const {
+    enableRowSpan,
+    primaryRowSpanKey,
+    columnRowSpanMap,
+    hoveredRowIndex,
+    hoveredGroupKey,
+    selectedGroupKeys,
+    onRowHover
+  } = rowSpan;
+  const { rowSelectionMode, selectOnRowClick, onRowClick, getRowClassName } = selection;
+  const {
+    enableCellSelection,
+    activeSelectionBounds,
+    dragState,
+    onCellMouseDown,
+    onCellMouseEnter,
+    onFillHandleMouseDown
+  } = cellSelection;
+  const {
+    editingCell,
+    draftValue,
+    onDraftValueChange,
+    onStartEdit,
+    onCommitEdit,
+    onCancelEdit
+  } = cellEdit;
+  const {
+    enableExpand,
+    toggleField,
+    expandedRows,
+    preventExpand,
+    onToggleExpand,
+    expandRowLabel,
+    collapseRowLabel
+  } = expand;
+  const rowIndex = row.index;
+  const rowData = row.original;
+  const isRowHovered = hoveredRowIndex === rowIndex;
+  const isRowSelected = row.getIsSelected();
+  const rowGroupKey = primaryRowSpanKey !== void 0 && rowData[primaryRowSpanKey] !== null && rowData[primaryRowSpanKey] !== void 0 ? String(rowData[primaryRowSpanKey]) : null;
+  const isGroupHovered = enableRowSpan && hoveredGroupKey !== null && rowGroupKey === hoveredGroupKey;
+  const isGroupSelected = enableRowSpan && rowGroupKey !== null && selectedGroupKeys.has(rowGroupKey);
+  const visibleCells = row.getVisibleCells();
+  const columnIdsByIndex = visibleCells.map((cell) => cell.column.id);
+  const isVisuallySelectedAt = activeSelectionBounds ? (targetRow, targetCol) => {
+    if (targetCol < activeSelectionBounds.startCol || targetCol > activeSelectionBounds.endCol) {
+      return false;
+    }
+    const columnId = columnIdsByIndex[targetCol];
+    const { startRow, rowSpan: span } = resolveRowSpanAt(
+      columnId ? columnRowSpanMap.get(columnId) : void 0,
+      targetRow
+    );
+    return isCellInSelection(
+      startRow,
+      targetCol,
+      activeSelectionBounds,
+      span
+    );
+  } : void 0;
+  const expandCellIndex = enableExpand ? resolveExpandCellIndex(visibleCells, toggleField) : -1;
+  const canExpand = enableExpand && !preventExpand && canExpandRow(rowData);
+  const expandKey = toggleField && rowData[toggleField] !== null && rowData[toggleField] !== void 0 ? String(rowData[toggleField]) : null;
+  const isExpanded = expandKey !== null && Boolean(expandedRows?.has(expandKey));
+  const rowLevel = typeof rowData.level === "number" ? rowData.level : 0;
+  const editInputRef = useRef2(null);
+  const isRowEditing = editingCell?.rowIndex === rowIndex;
+  useEffect2(() => {
+    if (!isRowEditing) return;
+    editInputRef.current?.focus();
+    editInputRef.current?.select();
+  }, [isRowEditing, editingCell?.colIndex]);
+  return /* @__PURE__ */ jsx3(
+    "tr",
+    {
+      ref: measureElement,
+      "data-index": virtualIndex,
+      "data-selected": isRowSelected ? "" : void 0,
+      "data-hovered": isRowHovered || isGroupHovered ? "" : void 0,
+      "data-expandable": enableExpand && canExpand ? "" : void 0,
+      "data-expanded": isExpanded ? "" : void 0,
+      className: cn(
+        "DataTableRowJSX",
+        !enableRowSpan && ROW_HOVER_CLASS,
+        enableRowSpan && isRowHovered && !isRowSelected && ROW_HOVERED_BG_CLASS,
+        isRowSelected && "is-selected",
+        enableExpand && canExpand && "is-expandable",
+        classNames?.row,
+        getRowClassName?.(rowData, rowIndex)
+      ),
+      onMouseEnter: () => onRowHover(rowIndex, rowData),
+      onClick: () => {
+        if (isRowEditing) return;
+        onRowClick?.(rowData, rowIndex);
+        if (rowSelectionMode !== "none" && selectOnRowClick) {
+          onToggleSelect();
+        }
+      },
+      children: visibleCells.map((cell, cellIndex) => {
+        const columnId = cell.column.id;
+        const meta = cell.column.columnDef.meta;
+        const align = meta?.align ?? "center";
+        const cellClassName = meta?.className;
+        const isRowSpanColumn = Boolean(enableRowSpan && meta?.rowSpan);
+        const isExpandCell = cellIndex === expandCellIndex;
+        const editable = isColumnEditable(cell.column.columnDef);
+        const editType = getColumnEditType(cell.column.columnDef);
+        let rowSpanInfo;
+        if (isRowSpanColumn) {
+          rowSpanInfo = columnRowSpanMap.get(columnId)?.[rowIndex];
+          if (rowSpanInfo && rowSpanInfo.rowSpan === 0) {
+            return null;
+          }
+        }
+        const isEditing = editingCell?.rowIndex === rowIndex && editingCell?.colIndex === cellIndex;
+        const showCellHover = isRowSpanColumn ? isGroupHovered : isRowHovered;
+        const showCellSelected = isRowSpanColumn ? isGroupSelected : isRowSelected;
+        const cellRowSpan = rowSpanInfo?.rowSpan ?? 1;
+        const isMerged = cellRowSpan > 1;
+        const showMergedRightEdge = isMerged && (cellIndex === visibleCells.length - 1 || resolveRowSpanAt(
+          columnRowSpanMap.get(columnIdsByIndex[cellIndex + 1]),
+          rowIndex
+        ).rowSpan <= 1);
+        const isCellDragSelected = isCellInSelection(
+          rowIndex,
+          cellIndex,
+          activeSelectionBounds,
+          cellRowSpan
+        );
+        const isBottomRightCell = !isEditing && activeSelectionBounds && !dragState.isSelecting && activeSelectionBounds.endRow >= rowIndex && activeSelectionBounds.endRow <= rowIndex + cellRowSpan - 1 && cellIndex === activeSelectionBounds.endCol;
+        const selectionEdgeStyle = getCellSelectionEdgeStyle(
+          rowIndex,
+          cellIndex,
+          activeSelectionBounds,
+          cellRowSpan,
+          isVisuallySelectedAt
+        );
+        const resolveCellRowIndex = (clientY, element) => getRowIndexInMergedCell(clientY, element, rowIndex, cellRowSpan);
+        const hasSelectionEdges = hasCellSelectionEdges(selectionEdgeStyle);
+        return /* @__PURE__ */ jsxs2(
+          "td",
+          {
+            rowSpan: rowSpanInfo && rowSpanInfo.rowSpan > 1 ? rowSpanInfo.rowSpan : void 0,
+            "data-merged": isMerged && cellIndex > 0 ? "" : void 0,
+            "data-merged-edge-right": showMergedRightEdge ? "" : void 0,
+            "data-group-selected": enableRowSpan && showCellSelected ? "" : void 0,
+            "data-group-hovered": enableRowSpan && showCellHover && !showCellSelected ? "" : void 0,
+            "data-selection-fill": isCellDragSelected ? "" : void 0,
+            "data-selection-edges": hasSelectionEdges ? "" : void 0,
+            "data-editable": editable ? "" : void 0,
+            "data-editing": isEditing ? "" : void 0,
+            onMouseDown: (event) => {
+              if (isEditing) {
+                event.stopPropagation();
+                return;
+              }
+              if (!enableCellSelection) return;
+              event.preventDefault();
+              onCellMouseDown(
+                resolveCellRowIndex(event.clientY, event.currentTarget),
+                cellIndex
+              );
+            },
+            onMouseEnter: (event) => {
+              if (!enableCellSelection) return;
+              onCellMouseEnter(
+                resolveCellRowIndex(event.clientY, event.currentTarget),
+                cellIndex
+              );
+            },
+            onMouseMove: (event) => {
+              if (!enableCellSelection) return;
+              if (!dragState.isSelecting && !dragState.isFillDragging) return;
+              onCellMouseEnter(
+                resolveCellRowIndex(event.clientY, event.currentTarget),
+                cellIndex
+              );
+            },
+            onDoubleClick: (event) => {
+              if (!editable) return;
+              event.preventDefault();
+              event.stopPropagation();
+              onStartEdit(rowIndex, cellIndex);
+            },
+            style: selectionEdgeStyle,
+            className: cn(
+              "data-table-cell",
+              CELL_ALIGN_CLASS[align],
+              cellClassName,
+              isMerged && cellIndex > 0 && "is-merged",
+              showMergedRightEdge && "is-merged-edge-right",
+              enableRowSpan && showCellSelected && "is-group-selected",
+              enableRowSpan && showCellHover && !showCellSelected && "is-group-hovered",
+              isCellDragSelected && CELL_SELECTION_FILL_CLASS,
+              hasSelectionEdges && CELL_SELECTION_EDGES_CLASS,
+              editable && "is-editable",
+              classNames?.cell
+            ),
+            children: [
+              isEditing ? /* @__PURE__ */ jsx3(
+                "input",
+                {
+                  ref: editInputRef,
+                  type: editType === "number" ? "number" : "text",
+                  defaultValue: draftValue,
+                  className: cn(
+                    "cell-edit-input",
+                    CELL_ALIGN_CLASS[align],
+                    classNames?.cellEditInput
+                  ),
+                  onChange: (event) => onDraftValueChange(event.target.value),
+                  onMouseDown: (event) => event.stopPropagation(),
+                  onClick: (event) => event.stopPropagation(),
+                  onKeyDown: (event) => {
+                    if (event.key === "Enter") {
+                      event.preventDefault();
+                      onCommitEdit(event.currentTarget.value);
+                    }
+                    if (event.key === "Escape") {
+                      event.preventDefault();
+                      onCancelEdit();
+                    }
+                  },
+                  onBlur: (event) => {
+                    onCommitEdit(event.currentTarget.value);
+                  }
+                }
+              ) : isExpandCell && enableExpand ? /* @__PURE__ */ jsxs2("div", { className: cn("expand-cell", classNames?.expandCell), children: [
+                /* @__PURE__ */ jsxs2(
+                  "div",
+                  {
+                    className: cn(
+                      "expand-cell-content",
+                      classNames?.expandCellContent
+                    ),
+                    children: [
+                      rowLevel > 0 && /* @__PURE__ */ jsx3(
+                        "span",
+                        {
+                          className: cn(
+                            "expand-cell-indent",
+                            classNames?.expandCellIndent
+                          ),
+                          children: "\xB7"
+                        }
+                      ),
+                      /* @__PURE__ */ jsx3(
+                        "div",
+                        {
+                          className: cn(
+                            "expand-cell-value",
+                            classNames?.expandCellValue
+                          ),
+                          children: flexRender(cell.column.columnDef.cell, cell.getContext())
+                        }
+                      )
+                    ]
+                  }
+                ),
+                canExpand && expandKey && /* @__PURE__ */ jsx3(
+                  "button",
+                  {
+                    type: "button",
+                    "aria-label": isExpanded ? collapseRowLabel : expandRowLabel,
+                    className: cn(
+                      "expand-toggle-button",
+                      classNames?.expandToggle
+                    ),
+                    onClick: (event) => {
+                      event.stopPropagation();
+                      onToggleExpand?.(expandKey);
+                    },
+                    onMouseDown: (event) => event.stopPropagation(),
+                    children: isExpanded ? /* @__PURE__ */ jsx3(
+                      ChevronUp,
+                      {
+                        className: cn(
+                          "expand-toggle-icon",
+                          classNames?.expandToggleIcon
+                        )
+                      }
+                    ) : /* @__PURE__ */ jsx3(
+                      ChevronDown,
+                      {
+                        className: cn(
+                          "expand-toggle-icon",
+                          classNames?.expandToggleIcon
+                        )
+                      }
+                    )
+                  }
+                )
+              ] }) : flexRender(cell.column.columnDef.cell, cell.getContext()),
+              isBottomRightCell && /* @__PURE__ */ jsx3(
+                "div",
+                {
+                  role: "presentation",
+                  className: cn("fill-handle", classNames?.fillHandle),
+                  onMouseDown: (event) => {
+                    event.stopPropagation();
+                    event.preventDefault();
+                    onFillHandleMouseDown(rowIndex, cellIndex);
+                  }
+                }
+              )
+            ]
+          },
+          cell.id
+        );
+      })
+    }
+  );
+}
+
+// src/components/ui/table/components/DataTable/DataTableToolbar.tsx
+import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function DataTableToolbar({
+  filteredCount,
+  totalCount,
+  summary,
+  selectedCount,
+  selectionLabel,
+  toolbar,
+  className,
+  classNames
+}) {
+  const displayFiltered = filteredCount ?? totalCount;
+  const hasCount = displayFiltered !== void 0 || totalCount !== void 0;
+  const hasLeftContent = hasCount || Boolean(summary);
+  const hasToolbar = Boolean(toolbar);
+  const selectionContent = selectionLabel?.(selectedCount) ?? null;
+  const hasSelectionContent = selectionContent !== null && selectionContent !== false && selectionContent !== void 0 && typeof selectionContent !== "boolean";
+  if (!hasLeftContent && !hasToolbar && !hasSelectionContent) return null;
+  return /* @__PURE__ */ jsxs3("div", { className: cn("DataTableToolbarJSX", classNames?.toolbar, className), children: [
+    /* @__PURE__ */ jsxs3("div", { className: cn("toolbar-left", classNames?.toolbarLeft), children: [
+      hasCount && /* @__PURE__ */ jsx4("span", { className: cn("toolbar-count", classNames?.toolbarCount), children: displayFiltered !== void 0 && totalCount !== void 0 ? /* @__PURE__ */ jsxs3(Fragment, { children: [
+        /* @__PURE__ */ jsx4("span", { className: "toolbar-count-primary", children: displayFiltered }),
+        /* @__PURE__ */ jsxs3("span", { className: "toolbar-count-placeholder", children: [
+          " / ",
+          totalCount
+        ] })
+      ] }) : /* @__PURE__ */ jsx4("span", { className: "toolbar-count-primary", children: displayFiltered ?? totalCount }) }),
+      summary
+    ] }),
+    /* @__PURE__ */ jsxs3("div", { className: cn("toolbar-right", classNames?.toolbarRight), children: [
+      hasSelectionContent && (typeof selectionContent === "string" || typeof selectionContent === "number" ? /* @__PURE__ */ jsx4("span", { className: cn("toolbar-selection", classNames?.toolbarSelection), children: selectionContent }) : selectionContent),
+      hasToolbar && /* @__PURE__ */ jsx4("div", { className: cn("toolbar-actions", classNames?.toolbarActions), children: toolbar })
+    ] })
+  ] });
+}
+
+// src/core/useGlideTable.ts
+import {
+  getCoreRowModel,
+  useReactTable
+} from "@tanstack/react-table";
+import {
+  useVirtualizer
+} from "@tanstack/react-virtual";
+import {
+  useCallback as useCallback3,
+  useEffect as useEffect5,
+  useMemo as useMemo2,
+  useRef as useRef4,
+  useState as useState3
+} from "react";
+
+// src/components/ui/table/features/cell-edit/useCellEdit.ts
+import { useCallback, useEffect as useEffect3, useRef as useRef3, useState } from "react";
+function useCellEdit({
+  data,
+  rows,
+  onDataChange,
+  onCellChange
+}) {
+  const [editingCell, setEditingCell] = useState(null);
+  const [draftValue, setDraftValue] = useState("");
+  const draftValueRef = useRef3(draftValue);
+  const editingCellRef = useRef3(editingCell);
+  useEffect3(() => {
+    draftValueRef.current = draftValue;
+  }, [draftValue]);
+  useEffect3(() => {
+    editingCellRef.current = editingCell;
+  }, [editingCell]);
+  const cancelEdit = useCallback(() => {
+    setEditingCell(null);
+    setDraftValue("");
+  }, []);
+  const commitEdit = useCallback(
+    (raw) => {
+      const current = editingCellRef.current;
+      if (!current) return true;
+      if (!onCellChange && !onDataChange) {
+        cancelEdit();
+        return true;
+      }
+      const row = rows[current.rowIndex];
+      const cell = row?.getVisibleCells()[current.colIndex];
+      if (!row || !cell) {
+        cancelEdit();
+        return true;
+      }
+      const value = raw ?? draftValueRef.current;
+      if (!isColumnEditable(cell.column.columnDef)) {
+        cancelEdit();
+        return true;
+      }
+      const parsed = parseCellEditValue(value, getColumnEditType(cell.column.columnDef));
+      if (!parsed.ok) return false;
+      if (onCellChange) {
+        onCellChange(row.id, cell.column.id, parsed.value);
+        cancelEdit();
+        return true;
+      }
+      const next = applyCellEdit(data, rows, current.rowIndex, current.colIndex, value);
+      if (!next) return false;
+      onDataChange?.(next);
+      cancelEdit();
+      return true;
+    },
+    [cancelEdit, data, onCellChange, onDataChange, rows]
+  );
+  const startEdit = useCallback(
+    (rowIndex, colIndex) => {
+      const cell = rows[rowIndex]?.getVisibleCells()[colIndex];
+      if (!cell || !isColumnEditable(cell.column.columnDef)) return;
+      const current = editingCellRef.current;
+      if (current && (current.rowIndex !== rowIndex || current.colIndex !== colIndex) && !commitEdit()) {
+        return;
+      }
+      setEditingCell({ rowIndex, colIndex });
+      setDraftValue(getCellEditDraftValue(cell.getValue()));
+    },
+    [commitEdit, rows]
+  );
+  return {
+    editingCell,
+    draftValue,
+    setDraftValue,
+    startEdit,
+    commitEdit,
+    cancelEdit
+  };
+}
+
+// src/components/ui/table/features/cell-selection/useCellSelection.ts
+import { useCallback as useCallback2, useEffect as useEffect4, useState as useState2 } from "react";
+
+// src/components/ui/table/features/cell-selection/fillData.ts
+function getColumnAccessorKey2(columnDef) {
+  if ("accessorKey" in columnDef && columnDef.accessorKey) {
+    return String(columnDef.accessorKey);
+  }
+  return columnDef.id;
+}
+function collectFillTargets(rows, sourceBounds, fillBounds) {
+  const targets = [];
+  const sourceHeight = sourceBounds.endRow - sourceBounds.startRow + 1;
+  const sourceWidth = sourceBounds.endCol - sourceBounds.startCol + 1;
+  for (let rowIndex = fillBounds.startRow; rowIndex <= fillBounds.endRow; rowIndex += 1) {
+    for (let colIndex = fillBounds.startCol; colIndex <= fillBounds.endCol; colIndex += 1) {
+      if (isCellInSelection(rowIndex, colIndex, sourceBounds)) continue;
+      const offsetRow = rowIndex - sourceBounds.startRow;
+      const offsetCol = colIndex - sourceBounds.startCol;
+      const sourceRowIndex = sourceBounds.startRow + (offsetRow % sourceHeight + sourceHeight) % sourceHeight;
+      const sourceColIndex = sourceBounds.startCol + (offsetCol % sourceWidth + sourceWidth) % sourceWidth;
+      const targetRow = rows[rowIndex];
+      const targetCell = targetRow?.getVisibleCells()[colIndex];
+      const sourceCell = rows[sourceRowIndex]?.getVisibleCells()[sourceColIndex];
+      if (!targetRow || !targetCell || !sourceCell) continue;
+      const accessorKey = getColumnAccessorKey2(
+        targetCell.column.columnDef
+      );
+      if (!accessorKey) continue;
+      targets.push({
+        rowIndex,
+        accessorKey,
+        columnId: targetCell.column.id,
+        value: sourceCell.getValue(),
+        rowId: targetRow.id
+      });
+    }
+  }
+  return targets;
+}
+function collectFillChanges(rows, sourceBounds, fillBounds) {
+  return collectFillTargets(rows, sourceBounds, fillBounds).map(
+    ({ rowId, columnId, value }) => ({ rowId, columnId, value })
+  );
+}
+function applyFillData(data, rows, sourceBounds, fillBounds) {
+  const newData = data.map((row) => ({ ...row }));
+  const targets = collectFillTargets(rows, sourceBounds, fillBounds);
+  for (const target of targets) {
+    if (!newData[target.rowIndex]) continue;
+    newData[target.rowIndex][target.accessorKey] = target.value;
+  }
+  return newData;
+}
+function hasFillExtension(sourceBounds, fillBounds) {
+  if (!sourceBounds) return false;
+  return fillBounds.startRow < sourceBounds.startRow || fillBounds.endRow > sourceBounds.endRow || fillBounds.startCol < sourceBounds.startCol || fillBounds.endCol > sourceBounds.endCol;
+}
+
+// src/components/ui/table/features/cell-selection/useCellSelection.ts
+function useCellSelection({
+  data,
+  rows,
+  enabled = true,
+  onDataChange,
+  onBatchChange
+}) {
+  const [dragState, setDragState] = useState2(INITIAL_DRAG_STATE);
+  const cellSelectionBounds = getCellSelectionBounds(dragState.start, dragState.end);
+  const activeSelectionBounds = enabled ? getActiveSelectionBounds(dragState, cellSelectionBounds) : null;
+  const handleCellMouseDown = useCallback2(
+    (rowIndex, colIndex) => {
+      if (!enabled) return;
+      setDragState({
+        isSelecting: true,
+        isFillDragging: false,
+        start: { row: rowIndex, col: colIndex },
+        end: { row: rowIndex, col: colIndex },
+        fillAnchor: null,
+        fillEnd: null
+      });
+    },
+    [enabled]
+  );
+  const handleCellMouseEnter = useCallback2(
+    (rowIndex, colIndex) => {
+      if (!enabled) return;
+      setDragState((prev) => {
+        if (prev.isSelecting) {
+          return { ...prev, end: { row: rowIndex, col: colIndex } };
+        }
+        if (prev.isFillDragging) {
+          return { ...prev, fillEnd: { row: rowIndex, col: colIndex } };
+        }
+        return prev;
+      });
+    },
+    [enabled]
+  );
+  const handleFillHandleMouseDown = useCallback2(
+    (rowIndex, colIndex) => {
+      if (!enabled) return;
+      setDragState((prev) => {
+        const bounds = getCellSelectionBounds(prev.start, prev.end);
+        if (!bounds) return prev;
+        return {
+          ...prev,
+          isSelecting: false,
+          isFillDragging: true,
+          fillAnchor: { row: bounds.startRow, col: bounds.startCol },
+          fillEnd: { row: rowIndex, col: colIndex }
+        };
+      });
+    },
+    [enabled]
+  );
+  useEffect4(() => {
+    if (!enabled) {
+      setDragState(INITIAL_DRAG_STATE);
+    }
+  }, [enabled]);
+  useEffect4(() => {
+    if (!enabled) return;
+    const handleKeyDown = (e) => {
+      if ((e.ctrlKey || e.metaKey) && e.key === "c" && activeSelectionBounds) {
+        const { startRow, endRow, startCol, endCol } = activeSelectionBounds;
+        const selectedData = rows.slice(startRow, endRow + 1).map((row) => {
+          const cells = row.getVisibleCells();
+          return cells.slice(startCol, endCol + 1).map((cell) => cell.getValue()).join("	");
+        }).join("\n");
+        navigator.clipboard.writeText(selectedData);
+      }
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, [activeSelectionBounds, enabled, rows]);
+  useEffect4(() => {
+    if (!enabled) return;
+    const handleMouseUp = () => {
+      setDragState((prev) => {
+        if (prev.isFillDragging && prev.fillAnchor && prev.fillEnd) {
+          const sourceBounds = getCellSelectionBounds(prev.start, prev.end);
+          const newBounds = getCellSelectionBounds(prev.fillAnchor, prev.fillEnd);
+          if (newBounds) {
+            if (hasFillExtension(sourceBounds, newBounds) && sourceBounds) {
+              if (onBatchChange) {
+                const changes = collectFillChanges(rows, sourceBounds, newBounds);
+                if (changes.length > 0) {
+                  onBatchChange(changes);
+                }
+              } else if (onDataChange) {
+                onDataChange(applyFillData(data, rows, sourceBounds, newBounds));
+              }
+            }
+            return {
+              isSelecting: false,
+              isFillDragging: false,
+              start: { row: newBounds.startRow, col: newBounds.startCol },
+              end: { row: newBounds.endRow, col: newBounds.endCol },
+              fillAnchor: null,
+              fillEnd: null
+            };
+          }
+        }
+        if (prev.isSelecting) {
+          return { ...prev, isSelecting: false };
+        }
+        if (prev.isFillDragging) {
+          return { ...prev, isFillDragging: false, fillAnchor: null, fillEnd: null };
+        }
+        return prev;
+      });
+    };
+    window.addEventListener("mouseup", handleMouseUp);
+    return () => window.removeEventListener("mouseup", handleMouseUp);
+  }, [data, enabled, onBatchChange, onDataChange, rows]);
+  return {
+    dragState: enabled ? dragState : INITIAL_DRAG_STATE,
+    activeSelectionBounds,
+    handleCellMouseDown,
+    handleCellMouseEnter,
+    handleFillHandleMouseDown
+  };
+}
+
+// src/components/ui/table/features/row-selection/rowSelection.ts
+function resolveRowSelection(mode, controlledSelection, internalSelection) {
+  if (mode === "none") return {};
+  return controlledSelection ?? internalSelection;
+}
+function normalizeSingleSelection(next) {
+  const selectedIds = Object.keys(next).filter((id) => next[id]);
+  if (selectedIds.length <= 1) return next;
+  return { [selectedIds[selectedIds.length - 1]]: true };
+}
+function applySelectionUpdater(mode, updater, previous) {
+  const next = typeof updater === "function" ? updater(previous) : updater;
+  return mode === "single" ? normalizeSingleSelection(next) : next;
+}
+
+// src/core/labels.ts
+var DEFAULT_DATA_TABLE_LABELS = {
+  empty: "No data",
+  loading: "Loading...",
+  selection: (selectedCount) => selectedCount > 0 ? `\u2713 ${selectedCount} selected` : null,
+  expandRow: "Expand row",
+  collapseRow: "Collapse row"
+};
+function resolveDataTableLabels(partial) {
+  return {
+    ...DEFAULT_DATA_TABLE_LABELS,
+    ...partial
+  };
+}
+
+// src/core/useGlideTable.ts
+function useGlideTable(options) {
+  const {
+    data,
+    columns,
+    rowSelectionMode = "none",
+    rowSelection: controlledRowSelection,
+    onRowSelectionChange,
+    selectionLabel,
+    emptyText,
+    loadingText,
+    labels: labelsProp,
+    enableRowSpan = false,
+    getRowId,
+    onRowClick,
+    getRowClassName,
+    getRowCanSelect,
+    selectOnRowClick = true,
+    enableCellSelection = true,
+    onDataChange,
+    onCellChange,
+    onBatchChange,
+    preserveRowSelection = false,
+    toggleField,
+    childField,
+    flattenField,
+    qtyField,
+    expandedRows: controlledExpandedRows,
+    onExpandedRowsChange,
+    preventExpand = false,
+    enableVirtualization = true,
+    estimateRowHeight = DATA_TABLE_ROW_HEIGHT,
+    virtualOverscan = DATA_TABLE_VIRTUAL_OVERSCAN
+  } = options;
+  const labels = useMemo2(() => {
+    const resolved = resolveDataTableLabels(labelsProp);
+    return {
+      ...resolved,
+      empty: labelsProp?.empty ?? emptyText ?? resolved.empty,
+      loading: labelsProp?.loading ?? loadingText ?? resolved.loading,
+      selection: labelsProp?.selection ?? selectionLabel ?? resolved.selection
+    };
+  }, [labelsProp, emptyText, loadingText, selectionLabel]);
+  const enableExpand = Boolean(toggleField);
+  const [internalRowSelection, setInternalRowSelection] = useState3({});
+  const [internalExpandedRows, setInternalExpandedRows] = useState3(
+    () => /* @__PURE__ */ new Set()
+  );
+  const [hoveredRowIndex, setHoveredRowIndex] = useState3(null);
+  const [hoveredGroupKey, setHoveredGroupKey] = useState3(null);
+  const scrollRef = useRef4(null);
+  const shouldVirtualize = enableVirtualization && !enableRowSpan;
+  useEffect5(() => {
+    if (enableVirtualization && enableRowSpan) {
+      console.warn(
+        "[useGlideTable] enableRowSpan is on; virtualization is disabled to preserve cell merges."
+      );
+    }
+  }, [enableVirtualization, enableRowSpan]);
+  const rowSelection = resolveRowSelection(
+    rowSelectionMode,
+    controlledRowSelection,
+    internalRowSelection
+  );
+  const expandedRows = controlledExpandedRows ?? internalExpandedRows;
+  const handleExpandedRowsChange = useCallback3(
+    (next) => {
+      if (onExpandedRowsChange) {
+        onExpandedRowsChange(next);
+        return;
+      }
+      setInternalExpandedRows(next);
+    },
+    [onExpandedRowsChange]
+  );
+  const tableData = useConvertTreeData({
+    data,
+    enabled: enableExpand,
+    toggleField,
+    childField,
+    flattenField,
+    qtyField,
+    expandedRows,
+    onExpandedRowsChange: enableExpand ? handleExpandedRowsChange : void 0,
+    preventExpand
+  });
+  const table = useReactTable({
+    data: tableData,
+    columns,
+    state: {
+      rowSelection: rowSelectionMode === "none" ? {} : rowSelection
+    },
+    enableRowSelection: rowSelectionMode === "none" ? false : getRowCanSelect ? (row) => getRowCanSelect(row.original, row.index) : true,
+    enableMultiRowSelection: rowSelectionMode === "multi",
+    onRowSelectionChange: (updater) => {
+      if (onRowSelectionChange) {
+        onRowSelectionChange(
+          (previous) => applySelectionUpdater(rowSelectionMode, updater, previous)
+        );
+        return;
+      }
+      setInternalRowSelection(
+        (previous) => applySelectionUpdater(rowSelectionMode, updater, previous)
+      );
+    },
+    getCoreRowModel: getCoreRowModel(),
+    getRowId: getRowId ? (originalRow, index) => getRowId(originalRow, index) : (_originalRow, index) => String(index)
+  });
+  const rowSpanColumnKeys = useMemo2(() => {
+    if (!enableRowSpan) return [];
+    return collectRowSpanColumns(columns);
+  }, [enableRowSpan, columns]);
+  const primaryRowSpanKey = rowSpanColumnKeys[0]?.rowSpanKey;
+  const columnRowSpanMap = useMemo2(
+    () => buildColumnRowSpanMap(tableData, rowSpanColumnKeys),
+    [tableData, rowSpanColumnKeys]
+  );
+  const selectedRows = table.getSelectedRowModel().rows;
+  const selectedCount = selectedRows.length;
+  const rows = table.getRowModel().rows;
+  const columnCount = table.getAllLeafColumns().length || 1;
+  const rowVirtualizer = useVirtualizer({
+    count: shouldVirtualize ? rows.length : 0,
+    getScrollElement: () => scrollRef.current,
+    estimateSize: () => estimateRowHeight,
+    overscan: virtualOverscan
+  });
+  const virtualRows = rowVirtualizer.getVirtualItems();
+  const totalSize = rowVirtualizer.getTotalSize();
+  const paddingTop = virtualRows.length > 0 ? virtualRows[0]?.start ?? 0 : 0;
+  const paddingBottom = virtualRows.length > 0 ? totalSize - (virtualRows[virtualRows.length - 1]?.end ?? 0) : 0;
+  const selectedGroupKeys = useMemo2(() => {
+    if (!enableRowSpan || !primaryRowSpanKey) return /* @__PURE__ */ new Set();
+    const keys = /* @__PURE__ */ new Set();
+    for (const selectedRow of selectedRows) {
+      const value = selectedRow.original[primaryRowSpanKey];
+      if (value !== null && value !== void 0) keys.add(String(value));
+    }
+    return keys;
+  }, [enableRowSpan, primaryRowSpanKey, selectedRows]);
+  const {
+    dragState,
+    activeSelectionBounds,
+    handleCellMouseDown,
+    handleCellMouseEnter,
+    handleFillHandleMouseDown
+  } = useCellSelection({
+    data: tableData,
+    rows,
+    enabled: enableCellSelection,
+    onDataChange,
+    onBatchChange
+  });
+  const {
+    editingCell,
+    draftValue,
+    setDraftValue,
+    startEdit,
+    commitEdit,
+    cancelEdit
+  } = useCellEdit({ data: tableData, rows, onDataChange, onCellChange });
+  const handleCellMouseDownWithCommit = useCallback3(
+    (rowIndex, colIndex) => {
+      const isSameEditingCell = editingCell?.rowIndex === rowIndex && editingCell?.colIndex === colIndex;
+      if (editingCell && !isSameEditingCell && !commitEdit()) {
+        return;
+      }
+      handleCellMouseDown(rowIndex, colIndex);
+    },
+    [commitEdit, editingCell, handleCellMouseDown]
+  );
+  const clearHover = useCallback3(() => {
+    setHoveredRowIndex(null);
+    setHoveredGroupKey(null);
+  }, []);
+  const handleRowHover = useCallback3(
+    (rowIndex, rowData) => {
+      setHoveredRowIndex(rowIndex);
+      if (!primaryRowSpanKey) {
+        setHoveredGroupKey(null);
+        return;
+      }
+      const groupValue = rowData[primaryRowSpanKey];
+      setHoveredGroupKey(
+        groupValue === null || groupValue === void 0 ? null : String(groupValue)
+      );
+    },
+    [primaryRowSpanKey]
+  );
+  const handleToggleSelect = useCallback3(
+    (row) => {
+      if (!row.getCanSelect()) return;
+      if (preserveRowSelection && row.getIsSelected()) {
+        return;
+      }
+      row.toggleSelected();
+    },
+    [preserveRowSelection]
+  );
+  const handleToggleExpand = useCallback3(
+    (rowKey) => {
+      if (preventExpand) return;
+      handleExpandedRowsChange(toggleExpandedRowId(rowKey, expandedRows));
+    },
+    [preventExpand, handleExpandedRowsChange, expandedRows]
+  );
+  const rowContextValue = useMemo2(() => {
+    return {
+      rowSpan: {
+        enableRowSpan,
+        primaryRowSpanKey,
+        columnRowSpanMap,
+        hoveredRowIndex,
+        hoveredGroupKey,
+        selectedGroupKeys,
+        onRowHover: handleRowHover
+      },
+      selection: {
+        rowSelectionMode,
+        selectOnRowClick,
+        onRowClick,
+        getRowClassName
+      },
+      cellSelection: {
+        enableCellSelection,
+        activeSelectionBounds,
+        dragState,
+        onCellMouseDown: handleCellMouseDownWithCommit,
+        onCellMouseEnter: handleCellMouseEnter,
+        onFillHandleMouseDown: handleFillHandleMouseDown
+      },
+      cellEdit: {
+        editingCell,
+        draftValue,
+        onDraftValueChange: setDraftValue,
+        onStartEdit: startEdit,
+        onCommitEdit: commitEdit,
+        onCancelEdit: cancelEdit
+      },
+      expand: {
+        enableExpand,
+        toggleField,
+        expandedRows,
+        preventExpand,
+        onToggleExpand: handleToggleExpand,
+        expandRowLabel: labels.expandRow,
+        collapseRowLabel: labels.collapseRow
+      }
+    };
+  }, [
+    enableRowSpan,
+    primaryRowSpanKey,
+    columnRowSpanMap,
+    hoveredRowIndex,
+    hoveredGroupKey,
+    selectedGroupKeys,
+    handleRowHover,
+    rowSelectionMode,
+    selectOnRowClick,
+    onRowClick,
+    getRowClassName,
+    enableCellSelection,
+    activeSelectionBounds,
+    dragState,
+    handleCellMouseDownWithCommit,
+    handleCellMouseEnter,
+    handleFillHandleMouseDown,
+    editingCell,
+    draftValue,
+    setDraftValue,
+    startEdit,
+    commitEdit,
+    cancelEdit,
+    enableExpand,
+    toggleField,
+    expandedRows,
+    preventExpand,
+    handleToggleExpand,
+    labels.expandRow,
+    labels.collapseRow
+  ]);
+  return {
+    table,
+    tableData,
+    rows,
+    columnCount,
+    selectedCount,
+    labels,
+    emptyText: labels.empty,
+    loadingText: labels.loading,
+    selectionLabel: labels.selection,
+    enableCellSelection,
+    shouldVirtualize,
+    scrollRef,
+    rowVirtualizer,
+    virtualRows,
+    paddingTop,
+    paddingBottom,
+    rowContextValue,
+    handleToggleSelect,
+    clearHover
+  };
+}
+
+// src/components/ui/table/components/DataTable/DataTable.tsx
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function DefaultPending({
+  loadingText,
+  className,
+  classNames
+}) {
+  return /* @__PURE__ */ jsx5(
+    "div",
+    {
+      className: cn(
+        "DataTableJSX",
+        "DataTableJSX--pending",
+        classNames?.root,
+        classNames?.pending,
+        className
+      ),
+      children: /* @__PURE__ */ jsx5("span", { className: cn("data-table-loading-text", classNames?.loadingText), children: loadingText })
+    }
+  );
+}
+function DefaultEmpty({
+  emptyText,
+  columnCount,
+  classNames
+}) {
+  return /* @__PURE__ */ jsx5("tr", { children: /* @__PURE__ */ jsx5(
+    "td",
+    {
+      colSpan: columnCount,
+      className: cn("data-table-empty-cell", classNames?.emptyCell),
+      children: emptyText
+    }
+  ) });
+}
+function DataTable({
+  isPending = false,
+  summary,
+  toolbar,
+  filteredCount,
+  totalCount,
+  className,
+  classNames,
+  slots,
+  ...glideOptions
+}) {
+  const {
+    table,
+    tableData,
+    rows,
+    columnCount,
+    selectedCount,
+    emptyText,
+    loadingText,
+    selectionLabel,
+    enableCellSelection,
+    shouldVirtualize,
+    scrollRef,
+    rowVirtualizer,
+    virtualRows,
+    paddingTop,
+    paddingBottom,
+    rowContextValue,
+    handleToggleSelect,
+    clearHover
+  } = useGlideTable(glideOptions);
+  const ToolbarSlot = slots?.Toolbar ?? DataTableToolbar;
+  const RowSlot = slots?.Row ?? DataTableRow;
+  const PendingSlot = slots?.Pending ?? DefaultPending;
+  const EmptySlot = slots?.Empty ?? DefaultEmpty;
+  const contextValue = useMemo3(
+    () => ({ ...rowContextValue, classNames }),
+    [rowContextValue, classNames]
+  );
+  if (isPending) {
+    return /* @__PURE__ */ jsx5(
+      PendingSlot,
+      {
+        loadingText,
+        className,
+        classNames
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs4(
+    "div",
+    {
+      className: cn(
+        "DataTableJSX",
+        !enableCellSelection && "DataTableJSX--no-cell-selection",
+        classNames?.root,
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsx5(
+          ToolbarSlot,
+          {
+            filteredCount: filteredCount ?? tableData.length,
+            totalCount,
+            summary,
+            selectedCount,
+            selectionLabel,
+            toolbar,
+            classNames
+          }
+        ),
+        /* @__PURE__ */ jsx5("div", { ref: scrollRef, className: cn("data-table-scroll", classNames?.scroll), children: /* @__PURE__ */ jsxs4(
+          "table",
+          {
+            className: cn("data-table", classNames?.table),
+            onDragStart: enableCellSelection ? (event) => event.preventDefault() : void 0,
+            children: [
+              /* @__PURE__ */ jsx5("thead", { className: cn("data-table-head", classNames?.head), children: table.getHeaderGroups().map((headerGroup) => /* @__PURE__ */ jsx5(
+                "tr",
+                {
+                  className: cn("data-table-head-row", classNames?.headRow),
+                  children: headerGroup.headers.map((header) => {
+                    const align = header.column.columnDef.meta?.align ?? "center";
+                    const headerClassName = header.column.columnDef.meta?.headerClassName;
+                    return /* @__PURE__ */ jsx5(
+                      "th",
+                      {
+                        style: { width: header.getSize() !== 150 ? header.getSize() : void 0 },
+                        className: cn(
+                          "data-table-head-cell",
+                          CELL_ALIGN_CLASS[align],
+                          classNames?.headCell,
+                          headerClassName
+                        ),
+                        children: header.isPlaceholder ? null : flexRender2(header.column.columnDef.header, header.getContext())
+                      },
+                      header.id
+                    );
+                  })
+                },
+                headerGroup.id
+              )) }),
+              /* @__PURE__ */ jsx5(DataTableContextProvider, { value: contextValue, children: /* @__PURE__ */ jsx5(
+                "tbody",
+                {
+                  onMouseLeave: clearHover,
+                  className: cn("data-table-body", classNames?.body),
+                  children: rows.length === 0 ? /* @__PURE__ */ jsx5(
+                    EmptySlot,
+                    {
+                      emptyText,
+                      columnCount,
+                      classNames
+                    }
+                  ) : shouldVirtualize ? /* @__PURE__ */ jsxs4(Fragment2, { children: [
+                    paddingTop > 0 && /* @__PURE__ */ jsx5(
+                      "tr",
+                      {
+                        "aria-hidden": true,
+                        className: cn(
+                          "data-table-virtual-spacer",
+                          classNames?.virtualSpacer
+                        ),
+                        children: /* @__PURE__ */ jsx5(
+                          "td",
+                          {
+                            colSpan: columnCount,
+                            style: { height: paddingTop },
+                            className: cn(
+                              "data-table-virtual-spacer-cell",
+                              classNames?.virtualSpacerCell
+                            )
+                          }
+                        )
+                      }
+                    ),
+                    virtualRows.map((virtualRow) => {
+                      const row = rows[virtualRow.index];
+                      if (!row) return null;
+                      return /* @__PURE__ */ jsx5(
+                        RowSlot,
+                        {
+                          row,
+                          virtualIndex: virtualRow.index,
+                          measureElement: rowVirtualizer.measureElement,
+                          onToggleSelect: () => handleToggleSelect(row)
+                        },
+                        row.id
+                      );
+                    }),
+                    paddingBottom > 0 && /* @__PURE__ */ jsx5(
+                      "tr",
+                      {
+                        "aria-hidden": true,
+                        className: cn(
+                          "data-table-virtual-spacer",
+                          classNames?.virtualSpacer
+                        ),
+                        children: /* @__PURE__ */ jsx5(
+                          "td",
+                          {
+                            colSpan: columnCount,
+                            style: { height: paddingBottom },
+                            className: cn(
+                              "data-table-virtual-spacer-cell",
+                              classNames?.virtualSpacerCell
+                            )
+                          }
+                        )
+                      }
+                    )
+                  ] }) : rows.map((row) => /* @__PURE__ */ jsx5(
+                    RowSlot,
+                    {
+                      row,
+                      onToggleSelect: () => handleToggleSelect(row)
+                    },
+                    row.id
+                  ))
+                }
+              ) })
+            ]
+          }
+        ) })
+      ]
+    }
+  );
+}
+
+// src/components/ui/table/components/Table/Table.tsx
+import { useCallback as useCallback4, useMemo as useMemo4, useState as useState4 } from "react";
+
+// src/components/ui/table/components/Table/buildColumnDef.tsx
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function SortableHeader({
+  label,
+  field,
+  sort,
+  onSort
+}) {
+  const isActive = sort?.field === field;
+  const Icon = isActive ? sort.direction === "asc" ? ArrowUp : ArrowDown : ArrowUpDown;
+  return /* @__PURE__ */ jsxs5(
+    "button",
+    {
+      type: "button",
+      className: cn("SortableHeaderJSX", isActive ? "is-active" : "is-inactive"),
+      onClick: () => onSort(field),
+      children: [
+        /* @__PURE__ */ jsx6("span", { children: label }),
+        /* @__PURE__ */ jsx6(Icon, { className: "sortable-header-icon" })
+      ]
+    }
+  );
+}
+function buildColumnDef(props, sort, onSort) {
+  const {
+    field,
+    virtual = false,
+    children,
+    sortable = false,
+    width,
+    align,
+    rowSpan,
+    rowSpanKey,
+    editable,
+    editType,
+    className,
+    headerClassName,
+    render
+  } = props;
+  return {
+    id: field,
+    ...!virtual ? { accessorKey: field } : {},
+    size: width ?? 150,
+    header: sortable ? () => /* @__PURE__ */ jsx6(SortableHeader, { label: children, field, sort, onSort }) : (
+      // eslint-disable-next-line @typescript-eslint/promise-function-async
+      () => children
+    ),
+    ...render ? {
+      // eslint-disable-next-line @typescript-eslint/promise-function-async
+      cell: ({ row, getValue }) => render(
+        getValue(),
+        row,
+        row.index
+      )
+    } : {},
+    meta: {
+      align,
+      rowSpan,
+      rowSpanKey,
+      editable,
+      editType,
+      className,
+      headerClassName
+    }
+  };
+}
+
+// src/components/ui/table/components/Table/parseTableChildren.ts
+import { Children } from "react";
+
+// src/components/ui/table/components/Table/tableChildTypes.ts
+import { isValidElement } from "react";
+var TABLE_HEADER_DISPLAY_NAME = "Table.Header";
+var TABLE_BODY_DISPLAY_NAME = "Table.Body";
+var TABLE_COLUMN_DISPLAY_NAME = "Table.Column";
+var TABLE_PAGINATION_DISPLAY_NAME = "Table.Pagination";
+function getComponentDisplayName(type) {
+  if (typeof type === "function" || typeof type === "object" && type !== null) {
+    return type.displayName;
+  }
+  return void 0;
+}
+function isTableHeaderElement(child) {
+  return isValidElement(child) && getComponentDisplayName(child.type) === TABLE_HEADER_DISPLAY_NAME;
+}
+function isTableBodyElement(child) {
+  return isValidElement(child) && getComponentDisplayName(child.type) === TABLE_BODY_DISPLAY_NAME;
+}
+function isTableColumnElement(child) {
+  return isValidElement(child) && getComponentDisplayName(child.type) === TABLE_COLUMN_DISPLAY_NAME;
+}
+function isTablePaginationElement(child) {
+  return isValidElement(child) && getComponentDisplayName(child.type) === TABLE_PAGINATION_DISPLAY_NAME;
+}
+
+// src/components/ui/table/components/Table/parseTableChildren.ts
+function parseTableChildren(children) {
+  const slots = {
+    header: null,
+    body: null,
+    pagination: null
+  };
+  for (const child of Children.toArray(children)) {
+    if (isTableHeaderElement(child)) {
+      slots.header = child;
+      continue;
+    }
+    if (isTableBodyElement(child)) {
+      slots.body = child;
+      continue;
+    }
+    if (isTablePaginationElement(child)) {
+      slots.pagination = child;
+    }
+  }
+  return slots;
+}
+function extractColumnElements(header) {
+  if (!header) return [];
+  const { children } = header.props;
+  return Children.toArray(children).filter(isTableColumnElement);
+}
+
+// src/components/ui/table/components/Table/TableBody.tsx
+function TableBody() {
+  return null;
+}
+TableBody.displayName = TABLE_BODY_DISPLAY_NAME;
+
+// src/components/ui/table/components/Table/TableColumn.tsx
+function TableColumn(props) {
+  void props;
+  return null;
+}
+TableColumn.displayName = TABLE_COLUMN_DISPLAY_NAME;
+
+// src/components/ui/table/components/Table/tableDataPipeline.ts
+function sortTableData(data, sort) {
+  if (!sort) return data;
+  const { field, direction } = sort;
+  const multiplier = direction === "asc" ? 1 : -1;
+  return [...data].sort((left, right) => {
+    const leftValue = left[field];
+    const rightValue = right[field];
+    if ((leftValue === null || leftValue === void 0) && (rightValue === null || rightValue === void 0)) {
+      return 0;
+    }
+    if (leftValue === null || leftValue === void 0) return 1;
+    if (rightValue === null || rightValue === void 0) return -1;
+    if (typeof leftValue === "number" && typeof rightValue === "number") {
+      return (leftValue - rightValue) * multiplier;
+    }
+    return String(leftValue).localeCompare(String(rightValue), "ko") * multiplier;
+  });
+}
+function paginateTableData(data, page, pageSize) {
+  const safePage = Math.max(1, page);
+  const start = (safePage - 1) * pageSize;
+  return data.slice(start, start + pageSize);
+}
+function getTotalPages(totalCount, pageSize) {
+  if (pageSize <= 0) return 1;
+  return Math.max(1, Math.ceil(totalCount / pageSize));
+}
+
+// src/components/ui/table/components/Table/TableHeader.tsx
+function TableHeader(props) {
+  void props;
+  return null;
+}
+TableHeader.displayName = TABLE_HEADER_DISPLAY_NAME;
+
+// src/components/ui/table/components/Table/TablePagination.tsx
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function TablePagination({
+  page,
+  pageSize = 10,
+  totalCount = 0,
+  onChange,
+  className
+}) {
+  const totalPages = getTotalPages(totalCount, pageSize);
+  const safePage = Math.min(Math.max(1, page), totalPages);
+  const canGoPrev = safePage > 1;
+  const canGoNext = safePage < totalPages;
+  return /* @__PURE__ */ jsxs6("div", { className: cn("TablePaginationJSX", className), children: [
+    /* @__PURE__ */ jsx7(
+      "button",
+      {
+        type: "button",
+        className: "pagination-button",
+        disabled: !canGoPrev,
+        onClick: () => onChange(safePage - 1),
+        "aria-label": "Previous page",
+        children: /* @__PURE__ */ jsx7(ChevronLeft, { className: "pagination-button-icon" })
+      }
+    ),
+    /* @__PURE__ */ jsxs6("span", { className: "pagination-label", children: [
+      safePage,
+      " / ",
+      totalPages
+    ] }),
+    /* @__PURE__ */ jsx7(
+      "button",
+      {
+        type: "button",
+        className: "pagination-button",
+        disabled: !canGoNext,
+        onClick: () => onChange(safePage + 1),
+        "aria-label": "Next page",
+        children: /* @__PURE__ */ jsx7(ChevronRight, { className: "pagination-button-icon" })
+      }
+    )
+  ] });
+}
+TablePagination.displayName = TABLE_PAGINATION_DISPLAY_NAME;
+
+// src/components/ui/table/components/Table/Table.tsx
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+function TableRoot({
+  data,
+  children,
+  className,
+  totalCount,
+  filteredCount,
+  ...dataTableProps
+}) {
+  const { header, pagination: paginationElement } = useMemo4(
+    () => parseTableChildren(children),
+    [children]
+  );
+  const [sort, setSort] = useState4(null);
+  const handleSort = useCallback4((field) => {
+    setSort((previous) => {
+      if (previous?.field !== field) {
+        return { field, direction: "asc" };
+      }
+      if (previous.direction === "asc") {
+        return { field, direction: "desc" };
+      }
+      return null;
+    });
+  }, []);
+  const columns = useMemo4(() => {
+    return extractColumnElements(header).map(
+      (columnElement) => buildColumnDef(columnElement.props, sort, handleSort)
+    );
+  }, [header, sort, handleSort]);
+  const paginationProps = paginationElement?.props;
+  const pageSize = paginationProps?.pageSize ?? 10;
+  const page = paginationProps?.page ?? 1;
+  const resolvedTotalCount = paginationProps?.totalCount ?? totalCount ?? data.length;
+  const tableData = useMemo4(() => {
+    const sortedData = sortTableData(data, sort);
+    if (!paginationProps) return sortedData;
+    return paginateTableData(sortedData, page, pageSize);
+  }, [data, sort, paginationProps, page, pageSize]);
+  if (columns.length === 0) {
+    console.warn("[Table] Declare at least one Table.Column inside Table.Header.");
+  }
+  return /* @__PURE__ */ jsxs7("div", { className: "TableJSX", children: [
+    /* @__PURE__ */ jsx8(
+      DataTable,
+      {
+        ...dataTableProps,
+        data: tableData,
+        columns,
+        totalCount: paginationProps ? resolvedTotalCount : totalCount,
+        filteredCount: filteredCount ?? data.length,
+        className: cn(className, paginationProps && "DataTableJSX--with-pagination")
+      }
+    ),
+    paginationProps && /* @__PURE__ */ jsx8(
+      TablePagination,
+      {
+        page,
+        pageSize,
+        totalCount: resolvedTotalCount,
+        onChange: paginationProps.onChange,
+        className: paginationProps.className
+      }
+    )
+  ] });
+}
+function createTable() {
+  function Column(props) {
+    void props;
+    return null;
+  }
+  Column.displayName = TABLE_COLUMN_DISPLAY_NAME;
+  return Object.assign(
+    function BoundTable(props) {
+      return /* @__PURE__ */ jsx8(TableRoot, { ...props });
+    },
+    {
+      Header: TableHeader,
+      Column,
+      Body: TableBody,
+      Pagination: TablePagination
+    }
+  );
+}
+var Table = Object.assign(TableRoot, {
+  Header: TableHeader,
+  Column: TableColumn,
+  Body: TableBody,
+  Pagination: TablePagination
+});
+export {
+  DataTable,
+  Table,
+  createTable
+};