@duskmoon-dev/components 0.1.2

package/dist/components/table/index.js

@@ -0,0 +1,721 @@
+"use client";
+
+// src/components/table/Table.tsx
+import React, {
+  forwardRef,
+  useMemo,
+  useState
+} from "react";
+
+// ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+function r(e) {
+  var t, f, n = "";
+  if (typeof e == "string" || typeof e == "number")
+    n += e;
+  else if (typeof e == "object")
+    if (Array.isArray(e)) {
+      var o = e.length;
+      for (t = 0;t < o; t++)
+        e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+    } else
+      for (f in e)
+        e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length;f < o; f++)
+    (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+
+// src/utils/cn.ts
+function cn(...inputs) {
+  return clsx(inputs);
+}
+// src/classes/table.ts
+var tableWrapperClass = "table-wrapper";
+var tableBaseClass = "table";
+var tableBorderedClass = "table-bordered";
+var tableLoadingClass = "table-loading";
+var tableSmallClass = "table-sm";
+var tableLargeClass = "table-lg";
+var tableHeaderCellClass = "table-header-cell";
+var tableCellClass = "table-cell";
+var tableRowClass = "table-row";
+var tableRowSelectedClass = "table-row-selected";
+var tableRowExpandedClass = "table-row-expanded";
+var tableEmptyClass = "table-empty";
+var tableLoadingIndicatorClass = "table-loading-indicator";
+var tableSorterClass = "table-sorter";
+var tableSorterActiveClass = "table-sorter-active";
+var tableFilterClass = "table-filter";
+var tableSelectionCellClass = "table-selection-cell";
+var tableExpandCellClass = "table-expand-cell";
+var tableExpandButtonClass = "table-expand-button";
+var tablePaginationClass = "table-pagination";
+var tablePaginationButtonClass = "table-pagination-button";
+var tablePaginationInfoClass = "table-pagination-info";
+function getTableWrapperClasses({
+  loading,
+  className
+}) {
+  return cn(tableWrapperClass, loading && tableLoadingClass, className);
+}
+function getTableClasses({
+  bordered,
+  size
+}) {
+  return cn(tableBaseClass, bordered && tableBorderedClass, size === "small" && tableSmallClass, size === "large" && tableLargeClass);
+}
+function getTableRowClasses({
+  selected,
+  expanded,
+  className
+}) {
+  return cn(tableRowClass, selected && tableRowSelectedClass, expanded && tableRowExpandedClass, className);
+}
+function getTableSorterClasses(active) {
+  return cn(tableSorterClass, active && tableSorterActiveClass);
+}
+
+// src/components/table/Table.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+import { createElement } from "react";
+var defaultPageSize = 10;
+var defaultSortDirections = ["ascend", "descend", null];
+function hasNode(node) {
+  return node !== undefined && node !== null && node !== false;
+}
+function textFromNode(node, fallback) {
+  return typeof node === "string" || typeof node === "number" ? String(node) : fallback;
+}
+function dataIndexKey(dataIndex) {
+  if (dataIndex === undefined) {
+    return;
+  }
+  return typeof dataIndex === "string" || typeof dataIndex === "number" ? dataIndex : Array.from(dataIndex).join(".");
+}
+function getValue(record, dataIndex) {
+  if (dataIndex === undefined) {
+    return;
+  }
+  const path = Array.isArray(dataIndex) ? dataIndex : [dataIndex];
+  return path.reduce((current, key) => {
+    if (current === null || current === undefined) {
+      return;
+    }
+    return current[key];
+  }, record);
+}
+function getRecordKey(record, index, rowKey) {
+  if (typeof rowKey === "function") {
+    return rowKey(record, index);
+  }
+  if (rowKey) {
+    const key2 = record[rowKey];
+    return typeof key2 === "string" || typeof key2 === "number" ? key2 : index;
+  }
+  const key = record.key;
+  return typeof key === "string" || typeof key === "number" ? key : index;
+}
+function normalizeKeys(keys) {
+  return keys?.map(String) ?? [];
+}
+function normalizeColumns(columns, prefix = "column") {
+  return columns.map((column, index) => {
+    const rawKey = column.key ?? dataIndexKey(column.dataIndex) ?? `${prefix}-${index}`;
+    return {
+      ...column,
+      columnKey: rawKey,
+      children: column.children ? normalizeColumns(column.children, String(rawKey)) : undefined
+    };
+  });
+}
+function leafColumns(columns) {
+  return columns.flatMap((column) => column.children?.length ? leafColumns(column.children) : [column]);
+}
+function getDepth(columns) {
+  if (columns.length === 0) {
+    return 1;
+  }
+  return Math.max(...columns.map((column) => column.children?.length ? 1 + getDepth(column.children) : 1));
+}
+function getLeafCount(column) {
+  return column.children?.length ? column.children.reduce((count, child) => count + getLeafCount(child), 0) : 1;
+}
+function buildHeaderRows(columns, depth, level = 0, rows = []) {
+  rows[level] ??= [];
+  columns.forEach((column) => {
+    const grouped = Boolean(column.children?.length);
+    rows[level].push({
+      column,
+      colSpan: grouped ? getLeafCount(column) : 1,
+      rowSpan: grouped ? 1 : depth - level
+    });
+    if (column.children?.length) {
+      buildHeaderRows(column.children, depth, level + 1, rows);
+    }
+  });
+  return rows;
+}
+function optionValues(filters) {
+  return (filters ?? []).flatMap((filter) => [
+    filter,
+    ...filter.children ?? []
+  ]);
+}
+function sortCompare(sorter) {
+  if (typeof sorter === "function") {
+    return sorter;
+  }
+  if (typeof sorter === "object" && sorter.compare) {
+    return sorter.compare;
+  }
+  return;
+}
+function sortOrderFor(column, sortStates) {
+  if (column.sortOrder !== undefined) {
+    return column.sortOrder;
+  }
+  return sortStates[String(column.columnKey)] ?? column.defaultSortOrder;
+}
+function filterValueFor(column, filterStates) {
+  if (column.filteredValue !== undefined) {
+    return column.filteredValue;
+  }
+  const state = filterStates[String(column.columnKey)];
+  return state !== undefined ? state : column.defaultFilteredValue;
+}
+function nextSortOrder(column, current) {
+  const directions = column.sortDirections ?? defaultSortDirections;
+  const index = directions.findIndex((order) => order === (current ?? null));
+  return directions[(index + 1) % directions.length] ?? null;
+}
+function selectedRowsForKeys(data, keys, rowKey) {
+  const keySet = new Set(normalizeKeys(keys));
+  return data.filter((record, index) => keySet.has(String(getRecordKey(record, index, rowKey))));
+}
+var Column = forwardRef(() => null);
+Column.displayName = "Table.Column";
+var ColumnGroup = forwardRef(() => null);
+ColumnGroup.displayName = "Table.ColumnGroup";
+var SummaryRow = forwardRef((props, ref) => /* @__PURE__ */ jsx("tr", {
+  ...props,
+  ref
+}));
+SummaryRow.displayName = "Table.Summary.Row";
+var SummaryCell = forwardRef(({ index, ...props }, ref) => {
+  return /* @__PURE__ */ jsx("td", {
+    ...props,
+    ref
+  });
+});
+SummaryCell.displayName = "Table.Summary.Cell";
+var Summary = Object.assign(forwardRef(({ fixed, ...props }, ref) => {
+  return /* @__PURE__ */ jsx("tfoot", {
+    ...props,
+    ref
+  });
+}), {
+  Row: SummaryRow,
+  Cell: SummaryCell
+});
+Summary.displayName = "Table.Summary";
+function columnsFromChildren(children) {
+  return React.Children.toArray(children).flatMap((child) => {
+    if (!React.isValidElement(child)) {
+      return [];
+    }
+    if (child.type === Column) {
+      const props = child.props;
+      const { children: columnChildren, ...column } = props;
+      return [column];
+    }
+    if (child.type === ColumnGroup) {
+      const props = child.props;
+      const { children: groupChildren, ...column } = props;
+      return [
+        {
+          ...column,
+          children: columnsFromChildren(groupChildren)
+        }
+      ];
+    }
+    return [];
+  });
+}
+function renderSummary(summary, pageData, colSpan) {
+  if (!summary) {
+    return null;
+  }
+  const node = summary(pageData);
+  if (React.isValidElement(node) && node.type === Summary) {
+    return node;
+  }
+  return /* @__PURE__ */ jsx("tfoot", {
+    children: /* @__PURE__ */ jsx("tr", {
+      children: /* @__PURE__ */ jsx("td", {
+        className: tableCellClass,
+        colSpan,
+        children: node
+      })
+    })
+  });
+}
+function resolvePagination(pagination, total) {
+  if (pagination === false) {
+    return null;
+  }
+  const config = pagination ?? {};
+  return {
+    current: config.current,
+    defaultCurrent: config.defaultCurrent ?? 1,
+    pageSize: config.pageSize,
+    defaultPageSize: config.defaultPageSize ?? defaultPageSize,
+    total: config.total ?? total,
+    disabled: config.disabled,
+    hideOnSinglePage: config.hideOnSinglePage,
+    showTotal: config.showTotal,
+    onChange: config.onChange
+  };
+}
+function TableRoot({
+  columns,
+  dataSource = [],
+  rowKey,
+  loading,
+  bordered,
+  size = "middle",
+  pagination,
+  rowSelection,
+  expandable,
+  summary,
+  locale,
+  tableLayout,
+  scroll,
+  onChange,
+  children,
+  className,
+  ...props
+}, ref) {
+  const childColumns = useMemo(() => columnsFromChildren(children), [children]);
+  const normalizedColumns = useMemo(() => normalizeColumns(columns ?? childColumns), [childColumns, columns]);
+  const leaves = useMemo(() => leafColumns(normalizedColumns), [normalizedColumns]);
+  const headerRows = useMemo(() => buildHeaderRows(normalizedColumns, getDepth(normalizedColumns)), [normalizedColumns]);
+  const [sortStates, setSortStates] = useState({});
+  const [filterStates, setFilterStates] = useState({});
+  const [internalCurrent, setInternalCurrent] = useState(1);
+  const [internalPageSize, setInternalPageSize] = useState(defaultPageSize);
+  const [internalSelectedKeys, setInternalSelectedKeys] = useState(rowSelection?.defaultSelectedRowKeys ?? []);
+  const [internalExpandedKeys, setInternalExpandedKeys] = useState(expandable?.defaultExpandedRowKeys ?? []);
+  const spinning = typeof loading === "object" ? loading.spinning : Boolean(loading);
+  const activeFilters = useMemo(() => {
+    return leaves.reduce((result, column) => {
+      const value = filterValueFor(column, filterStates) ?? null;
+      if (value !== null) {
+        result[String(column.columnKey)] = value;
+      }
+      return result;
+    }, {});
+  }, [filterStates, leaves]);
+  const activeSorter = useMemo(() => {
+    const column = leaves.find((item) => sortOrderFor(item, sortStates));
+    if (!column) {
+      return {};
+    }
+    return {
+      column,
+      columnKey: column.columnKey,
+      field: column.dataIndex,
+      order: sortOrderFor(column, sortStates) ?? null
+    };
+  }, [leaves, sortStates]);
+  const filteredData = useMemo(() => {
+    return leaves.reduce((records, column) => {
+      const values = filterValueFor(column, filterStates);
+      if (!values?.length || !column.onFilter) {
+        return records;
+      }
+      return records.filter((record) => values.some((value) => column.onFilter?.(value, record)));
+    }, dataSource);
+  }, [dataSource, filterStates, leaves]);
+  const sortedData = useMemo(() => {
+    const sorterColumn = leaves.find((column) => sortOrderFor(column, sortStates));
+    const order = sorterColumn ? sortOrderFor(sorterColumn, sortStates) : null;
+    const compare = sorterColumn ? sortCompare(sorterColumn.sorter) : undefined;
+    if (!sorterColumn || !order || !compare) {
+      return filteredData;
+    }
+    return [...filteredData].sort((first, second) => {
+      const result = compare(first, second);
+      return order === "descend" ? -result : result;
+    });
+  }, [filteredData, leaves, sortStates]);
+  const paginationConfig = resolvePagination(pagination, sortedData.length);
+  const pageSize = Math.max(1, Math.floor(paginationConfig?.pageSize ?? (internalPageSize === defaultPageSize ? paginationConfig?.defaultPageSize : internalPageSize) ?? defaultPageSize));
+  const pageCount = paginationConfig ? Math.max(1, Math.ceil(Math.max(0, paginationConfig.total ?? sortedData.length) / pageSize)) : 1;
+  const current = paginationConfig ? Math.min(pageCount, Math.max(1, Math.floor(paginationConfig.current ?? internalCurrent ?? paginationConfig.defaultCurrent ?? 1))) : 1;
+  const pageData = paginationConfig ? sortedData.slice((current - 1) * pageSize, current * pageSize) : sortedData;
+  const selectedKeys = rowSelection?.selectedRowKeys ?? internalSelectedKeys;
+  const selectedKeySet = new Set(normalizeKeys(selectedKeys));
+  const expandedKeys = expandable?.expandedRowKeys ?? internalExpandedKeys;
+  const expandedKeySet = new Set(normalizeKeys(expandedKeys));
+  const hasSelection = Boolean(rowSelection);
+  const hasExpandable = Boolean(expandable?.expandedRowRender);
+  const structuralColumnCount = leaves.length + (hasSelection ? 1 : 0) + (hasExpandable ? 1 : 0);
+  const bodyEmpty = pageData.length === 0;
+  function emitTableChange(nextPagination, nextFilters, nextSorter, action) {
+    onChange?.(nextPagination, nextFilters, nextSorter, {
+      currentDataSource: sortedData,
+      action
+    });
+  }
+  function changePage(nextPage, nextPageSize = pageSize) {
+    if (!paginationConfig || paginationConfig.disabled) {
+      return;
+    }
+    const nextPageCount = Math.max(1, Math.ceil((paginationConfig.total ?? sortedData.length) / nextPageSize));
+    const normalizedPage = Math.min(nextPageCount, Math.max(1, nextPage));
+    if (paginationConfig.current === undefined) {
+      setInternalCurrent(normalizedPage);
+    }
+    if (paginationConfig.pageSize === undefined) {
+      setInternalPageSize(nextPageSize);
+    }
+    paginationConfig.onChange?.(normalizedPage, nextPageSize);
+    emitTableChange({ ...paginationConfig, current: normalizedPage, pageSize: nextPageSize }, activeFilters, activeSorter, "paginate");
+  }
+  function changeSorter(column) {
+    if (!column.sorter) {
+      return;
+    }
+    const nextOrder = nextSortOrder(column, sortOrderFor(column, sortStates));
+    const nextSortStates = { [String(column.columnKey)]: nextOrder };
+    const nextSorter = nextOrder ? {
+      column,
+      columnKey: column.columnKey,
+      field: column.dataIndex,
+      order: nextOrder
+    } : {};
+    setSortStates(nextSortStates);
+    setInternalCurrent(1);
+    emitTableChange({ ...paginationConfig ?? {}, current: 1, pageSize }, activeFilters, nextSorter, "sort");
+  }
+  function changeFilter(column, event) {
+    const selected = Array.from(event.currentTarget.selectedOptions).map((option) => option.value).filter((value) => value !== "");
+    const nextValue = selected.length > 0 ? selected : null;
+    const nextFilters = {
+      ...activeFilters,
+      [String(column.columnKey)]: nextValue
+    };
+    if (nextValue === null) {
+      delete nextFilters[String(column.columnKey)];
+    }
+    setFilterStates((currentFilters) => ({
+      ...currentFilters,
+      [String(column.columnKey)]: nextValue
+    }));
+    setInternalCurrent(1);
+    emitTableChange({ ...paginationConfig ?? {}, current: 1, pageSize }, nextFilters, activeSorter, "filter");
+  }
+  function commitSelection(nextKeys, nativeEvent, changedRecord, selected, changedRows) {
+    if (!rowSelection) {
+      return;
+    }
+    const normalizedNextKeys = Array.from(new Set(nextKeys.map(String)));
+    const originalKeys = normalizedNextKeys.map((key) => {
+      const index = dataSource.findIndex((record, itemIndex) => String(getRecordKey(record, itemIndex, rowKey)) === key);
+      return index >= 0 ? getRecordKey(dataSource[index], index, rowKey) : key;
+    });
+    const selectedRows = selectedRowsForKeys(dataSource, originalKeys, rowKey);
+    if (rowSelection.selectedRowKeys === undefined) {
+      setInternalSelectedKeys(originalKeys);
+    }
+    rowSelection.onChange?.(originalKeys, selectedRows);
+    if (changedRecord && selected !== undefined) {
+      rowSelection.onSelect?.(changedRecord, selected, selectedRows, nativeEvent);
+    }
+    if (changedRows) {
+      rowSelection.onSelectAll?.(Boolean(selected), selectedRows, changedRows);
+    }
+  }
+  function toggleRowSelection(record, index, event) {
+    if (!rowSelection) {
+      return;
+    }
+    const key = getRecordKey(record, index, rowKey);
+    const keyString = String(key);
+    const checked = event.currentTarget.checked;
+    const nextKeys = rowSelection.type === "radio" ? checked ? [key] : [] : checked ? [...selectedKeys, key] : selectedKeys.filter((selectedKey) => String(selectedKey) !== keyString);
+    commitSelection(nextKeys, event.nativeEvent, record, checked);
+  }
+  function toggleAllRows(event) {
+    if (!rowSelection) {
+      return;
+    }
+    const checked = event.currentTarget.checked;
+    const selectableRows = pageData.filter((record, index) => {
+      const checkboxProps = rowSelection.getCheckboxProps?.(record);
+      return !checkboxProps?.disabled && getRecordKey(record, index, rowKey) !== undefined;
+    });
+    const pageKeys = selectableRows.map((record, index) => getRecordKey(record, index, rowKey));
+    const pageKeySet = new Set(normalizeKeys(pageKeys));
+    const nextKeys = checked ? [...selectedKeys, ...pageKeys] : selectedKeys.filter((key) => !pageKeySet.has(String(key)));
+    commitSelection(nextKeys, event.nativeEvent, undefined, checked, selectableRows);
+  }
+  function toggleExpand(record, index) {
+    if (!expandable?.expandedRowRender) {
+      return;
+    }
+    const key = getRecordKey(record, index, rowKey);
+    const keyString = String(key);
+    const expanded = !expandedKeySet.has(keyString);
+    const nextKeys = expanded ? [...expandedKeys, key] : expandedKeys.filter((expandedKey) => String(expandedKey) !== keyString);
+    if (expandable.expandedRowKeys === undefined) {
+      setInternalExpandedKeys(nextKeys);
+    }
+    expandable.onExpand?.(expanded, record);
+    expandable.onExpandedRowsChange?.(nextKeys);
+  }
+  function renderSelectionHeader() {
+    if (!rowSelection) {
+      return null;
+    }
+    if (rowSelection.type === "radio" || rowSelection.hideSelectAll) {
+      return /* @__PURE__ */ jsx("th", {
+        className: cn(tableHeaderCellClass, tableSelectionCellClass),
+        children: rowSelection.columnTitle
+      });
+    }
+    const pageKeys = pageData.map((record, index) => getRecordKey(record, index, rowKey));
+    const allSelected = pageKeys.length > 0 && pageKeys.every((key) => selectedKeySet.has(String(key)));
+    return /* @__PURE__ */ jsx("th", {
+      className: cn(tableHeaderCellClass, tableSelectionCellClass),
+      children: /* @__PURE__ */ jsxs("label", {
+        children: [
+          /* @__PURE__ */ jsx("input", {
+            type: "checkbox",
+            "aria-label": "Select all rows",
+            checked: allSelected,
+            onChange: toggleAllRows
+          }),
+          hasNode(rowSelection.columnTitle) ? rowSelection.columnTitle : null
+        ]
+      })
+    });
+  }
+  function renderHeaderCell(cell, index) {
+    const { column } = cell;
+    const title = column.title ?? dataIndexKey(column.dataIndex) ?? index + 1;
+    const sortOrder = sortOrderFor(column, sortStates);
+    const headerProps = column.onHeaderCell?.(column) ?? {};
+    return /* @__PURE__ */ createElement("th", {
+      ...headerProps,
+      key: String(column.columnKey),
+      className: cn(tableHeaderCellClass, column.className, headerProps.className),
+      colSpan: cell.colSpan,
+      rowSpan: cell.rowSpan,
+      style: {
+        width: column.width,
+        textAlign: column.align,
+        ...headerProps.style
+      }
+    }, /* @__PURE__ */ jsx("span", {
+      children: title
+    }), column.sorter ? /* @__PURE__ */ jsx("button", {
+      type: "button",
+      className: getTableSorterClasses(Boolean(sortOrder)),
+      "aria-label": `Sort ${textFromNode(title, String(column.columnKey))}`,
+      onClick: () => changeSorter(column),
+      children: sortOrder === "ascend" ? "Asc" : sortOrder === "descend" ? "Desc" : "Sort"
+    }) : null, column.filters?.length ? /* @__PURE__ */ jsxs("select", {
+      className: tableFilterClass,
+      "aria-label": `Filter ${textFromNode(title, String(column.columnKey))}`,
+      multiple: column.filterMultiple !== false,
+      value: column.filterMultiple === false ? String((filterValueFor(column, filterStates) ?? [])[0] ?? "") : (filterValueFor(column, filterStates) ?? []).map(String),
+      onChange: (event) => changeFilter(column, event),
+      children: [
+        column.filterMultiple === false ? /* @__PURE__ */ jsx("option", {
+          value: "",
+          children: "All"
+        }) : null,
+        optionValues(column.filters).map((filter) => /* @__PURE__ */ jsx("option", {
+          value: String(filter.value),
+          children: filter.text
+        }, String(filter.value)))
+      ]
+    }) : null);
+  }
+  function renderCell(record, recordIndex, column) {
+    const value = getValue(record, column.dataIndex);
+    const rendered = column.render ? column.render(value, record, recordIndex) : value;
+    const cellProps = column.onCell?.(record, recordIndex) ?? {};
+    return /* @__PURE__ */ createElement("td", {
+      ...cellProps,
+      key: String(column.columnKey),
+      className: cn(tableCellClass, column.className, cellProps.className),
+      style: { textAlign: column.align, ...cellProps.style }
+    }, hasNode(rendered) ? rendered : null);
+  }
+  function renderSelectionCell(record, index) {
+    if (!rowSelection) {
+      return null;
+    }
+    const key = getRecordKey(record, index, rowKey);
+    const checked = selectedKeySet.has(String(key));
+    const checkboxProps = rowSelection.getCheckboxProps?.(record) ?? {};
+    const originNode = /* @__PURE__ */ jsx("input", {
+      ...checkboxProps,
+      type: rowSelection.type === "radio" ? "radio" : "checkbox",
+      "aria-label": `Select row ${index + 1}`,
+      checked,
+      onChange: (event) => toggleRowSelection(record, index, event)
+    });
+    return /* @__PURE__ */ jsx("td", {
+      className: cn(tableCellClass, tableSelectionCellClass),
+      children: rowSelection.renderCell ? rowSelection.renderCell(checked, record, index, originNode) : originNode
+    });
+  }
+  function renderExpandCell(record, index) {
+    if (!expandable?.expandedRowRender) {
+      return null;
+    }
+    const key = getRecordKey(record, index, rowKey);
+    const expanded = expandedKeySet.has(String(key));
+    const expandableRow = expandable.rowExpandable?.(record) ?? true;
+    return /* @__PURE__ */ jsx("td", {
+      className: cn(tableCellClass, tableExpandCellClass),
+      children: expandableRow ? /* @__PURE__ */ jsx("button", {
+        type: "button",
+        className: tableExpandButtonClass,
+        "aria-label": `${expanded ? "Collapse" : "Expand"} row ${index + 1}`,
+        onClick: () => toggleExpand(record, index),
+        children: expanded ? "-" : "+"
+      }) : null
+    });
+  }
+  function renderRow(record, index) {
+    const key = getRecordKey(record, index, rowKey);
+    const expanded = expandedKeySet.has(String(key));
+    const selected = selectedKeySet.has(String(key));
+    const row = /* @__PURE__ */ jsxs("tr", {
+      className: getTableRowClasses({ selected, expanded }),
+      onClick: () => {
+        if (expandable?.expandRowByClick) {
+          toggleExpand(record, index);
+        }
+      },
+      children: [
+        renderSelectionCell(record, index),
+        renderExpandCell(record, index),
+        leaves.map((column) => renderCell(record, index, column))
+      ]
+    }, String(key));
+    if (!expanded || !expandable?.expandedRowRender) {
+      return row;
+    }
+    return /* @__PURE__ */ jsxs(React.Fragment, {
+      children: [
+        row,
+        /* @__PURE__ */ jsx("tr", {
+          className: "table-expanded-row",
+          children: /* @__PURE__ */ jsx("td", {
+            className: tableCellClass,
+            colSpan: structuralColumnCount,
+            children: expandable.expandedRowRender(record, index, 0, expanded)
+          })
+        })
+      ]
+    }, String(key));
+  }
+  const tableNode = /* @__PURE__ */ jsxs("table", {
+    className: getTableClasses({ bordered, size }),
+    style: { tableLayout },
+    children: [
+      /* @__PURE__ */ jsx("thead", {
+        children: headerRows.map((row, rowIndex) => /* @__PURE__ */ jsxs("tr", {
+          children: [
+            rowIndex === 0 ? renderSelectionHeader() : null,
+            rowIndex === 0 && hasExpandable ? /* @__PURE__ */ jsx("th", {
+              className: cn(tableHeaderCellClass, tableExpandCellClass),
+              children: expandable?.columnTitle
+            }) : null,
+            row.map(renderHeaderCell)
+          ]
+        }, rowIndex))
+      }),
+      /* @__PURE__ */ jsx("tbody", {
+        children: bodyEmpty ? /* @__PURE__ */ jsx("tr", {
+          children: /* @__PURE__ */ jsx("td", {
+            className: tableEmptyClass,
+            colSpan: structuralColumnCount,
+            children: locale?.emptyText ?? "No data"
+          })
+        }) : pageData.map(renderRow)
+      }),
+      renderSummary(summary, pageData, structuralColumnCount)
+    ]
+  });
+  return /* @__PURE__ */ jsxs("div", {
+    ...props,
+    ref,
+    className: getTableWrapperClasses({ loading: spinning, className }),
+    children: [
+      scroll?.x || scroll?.y ? /* @__PURE__ */ jsx("div", {
+        style: {
+          overflow: "auto",
+          maxHeight: scroll.y,
+          width: scroll.x === true ? "100%" : scroll.x
+        },
+        children: tableNode
+      }) : tableNode,
+      spinning ? /* @__PURE__ */ jsx("div", {
+        className: tableLoadingIndicatorClass,
+        role: "status",
+        children: typeof loading === "object" && loading.indicator ? loading.indicator : "Loading"
+      }) : null,
+      paginationConfig && !(paginationConfig.hideOnSinglePage && pageCount <= 1) ? /* @__PURE__ */ jsxs("nav", {
+        className: tablePaginationClass,
+        "aria-label": "Table pagination",
+        children: [
+          /* @__PURE__ */ jsx("button", {
+            type: "button",
+            className: tablePaginationButtonClass,
+            disabled: paginationConfig.disabled || current <= 1,
+            onClick: () => changePage(current - 1),
+            children: "Previous"
+          }),
+          /* @__PURE__ */ jsx("span", {
+            className: tablePaginationInfoClass,
+            children: paginationConfig.showTotal ? paginationConfig.showTotal(paginationConfig.total ?? sortedData.length, [
+              bodyEmpty ? 0 : (current - 1) * pageSize + 1,
+              Math.min(current * pageSize, sortedData.length)
+            ]) : `${current} / ${pageCount}`
+          }),
+          /* @__PURE__ */ jsx("button", {
+            type: "button",
+            className: tablePaginationButtonClass,
+            disabled: paginationConfig.disabled || current >= pageCount,
+            onClick: () => changePage(current + 1),
+            children: "Next"
+          })
+        ]
+      }) : null
+    ]
+  });
+}
+var TableWithRef = forwardRef(TableRoot);
+var Table = Object.assign(TableWithRef, {
+  Column,
+  ColumnGroup,
+  Summary,
+  SELECTION_ALL: "SELECT_ALL",
+  SELECTION_INVERT: "SELECT_INVERT",
+  SELECTION_NONE: "SELECT_NONE",
+  SELECTION_COLUMN: "SELECTION_COLUMN",
+  EXPAND_COLUMN: "EXPAND_COLUMN"
+});
+Table.displayName = "Table";
+export {
+  Table
+};