bj-web-components 0.2.26 → 0.2.28

package/dist/web/Table/BTable.js

@@ -0,0 +1,950 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const react = require("react");
+const reactDom = require("react-dom");
+const Pagination = require("../Pagination/Pagination.js");
+const Icon = require("../Icon/Icon.js");
+;/* empty css                       */
+const ContentTooltip = require("../Tooltip/ContentTooltip.js");
+const TooltipWrapper = require("../Tooltip/TooltipWrapper.js");
+const index = require("../CheckBox/index.js");
+const BDropdown = require("../Dropdown/BDropdown.js");
+const BOverlayScrollbar = require("../OverlayScrollbar/BOverlayScrollbar.js");
+const spin_loading_red = require("../SkuInputCard/spin_loading_red.gif.js");
+const no_data_light = require("../ProductField/no_data_light.svg.js");
+const Column = require("./Column.js");
+const ColumnGroup = require("./ColumnGroup.js");
+const sortFilter = require("./utils/sortFilter.js");
+const columns = require("./utils/columns.js");
+;/* empty css             */
+const FILTER_SEARCH_DEBOUNCE_MS = 300;
+const SCROLL_EDGE_THRESHOLD = 1;
+function classNames(...values) {
+  return values.filter(Boolean).join(" ");
+}
+function getValue(record, dataIndex) {
+  if (dataIndex === void 0) {
+    return void 0;
+  }
+  const path = Array.isArray(dataIndex) ? dataIndex : [dataIndex];
+  return path.reduce((value, key) => {
+    if (value === null || value === void 0 || typeof value !== "object") {
+      return void 0;
+    }
+    return value[key];
+  }, record);
+}
+function getRowKey(record, index2, rowKey) {
+  if (typeof rowKey === "function") {
+    return rowKey(record, index2);
+  }
+  if (rowKey) {
+    const value = record[String(rowKey)];
+    if (typeof value === "string" || typeof value === "number") {
+      return value;
+    }
+  }
+  return index2;
+}
+function getPageCount(total, pageSize) {
+  return Math.max(1, Math.ceil(total / pageSize));
+}
+function isRenderedCell(value) {
+  return Boolean(value && typeof value === "object" && !react.isValidElement(value) && "props" in value);
+}
+function defaultFilterSearch(input, item) {
+  const searchableText = typeof item.text === "string" || typeof item.text === "number" ? String(item.text) : String(item.value);
+  return searchableText.toLocaleLowerCase().includes(input.toLocaleLowerCase());
+}
+function SelectionControl({
+  checked,
+  disabled,
+  label,
+  name,
+  onChange,
+  type = "checkbox"
+}) {
+  if (type === "checkbox") {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      index.BCheckBox,
+      {
+        "aria-label": label,
+        checked,
+        className: "bj-table__selection-checkbox",
+        disabled,
+        name,
+        onChange,
+        skipGroup: true
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("label", { className: classNames("bj-table__selection-control", checked && "bj-table__selection-control--checked", disabled && "bj-table__selection-control--disabled"), children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        "aria-label": label,
+        checked,
+        className: "bj-table__selection-input",
+        disabled,
+        name,
+        onChange,
+        type
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", className: "bj-table__selection-box", children: checked && /* @__PURE__ */ jsxRuntime.jsx(Icon, { className: "bj-table__selection-check-icon", type: "icon-a-dagouxi" }) })
+  ] });
+}
+function BTable({
+  columns: columns$1,
+  dataSource = [],
+  rowKey,
+  preserveSelectedRowKeys = false,
+  rowSelection,
+  pagination = false,
+  loading = false,
+  bordered = true,
+  size = "middle",
+  showHeader = true,
+  emptyText,
+  emptyImage = no_data_light,
+  emptyHeight,
+  t = (text) => text,
+  className,
+  style,
+  rowClassName,
+  sortDirections = ["ascend", "descend", null],
+  onChange,
+  children,
+  title,
+  footer,
+  summary,
+  tableLayout,
+  components,
+  onRow,
+  onHeaderRow,
+  id,
+  scroll,
+  locale,
+  groupCollapse
+}) {
+  var _a, _b, _c;
+  const tableRootRef = react.useRef(null);
+  const tableScrollRef = react.useRef(null);
+  const mergedColumns = react.useMemo(
+    () => columns$1 ?? columns.convertChildrenToColumns(children),
+    [children, columns$1]
+  );
+  const leafColumns = react.useMemo(() => columns.flattenColumns(mergedColumns), [mergedColumns]);
+  const headerRows = react.useMemo(() => columns.buildHeaderRows(mergedColumns), [mergedColumns]);
+  const [uncontrolledSelectedKeys, setUncontrolledSelectedKeys] = react.useState(
+    (rowSelection == null ? void 0 : rowSelection.defaultSelectedRowKeys) ?? []
+  );
+  const [uncontrolledCurrent, setUncontrolledCurrent] = react.useState(
+    pagination ? pagination.defaultCurrent ?? 1 : 1
+  );
+  const [uncontrolledPageSize, setUncontrolledPageSize] = react.useState(
+    pagination ? pagination.defaultPageSize ?? 10 : 10
+  );
+  const [uncontrolledSortOrders, setUncontrolledSortOrders] = react.useState(
+    () => new Map(leafColumns.flatMap((column, index2) => {
+      if (!column.defaultSortOrder) return [];
+      return [[sortFilter.getColumnKey(column, index2), column.defaultSortOrder]];
+    }))
+  );
+  const [uncontrolledFilters, setUncontrolledFilters] = react.useState(
+    () => new Map(leafColumns.flatMap((column, index2) => {
+      if (column.defaultFilteredValue === void 0) return [];
+      return [[sortFilter.getColumnKey(column, index2), column.defaultFilteredValue]];
+    }))
+  );
+  const [uncontrolledExpandedGroupKeys, setUncontrolledExpandedGroupKeys] = react.useState(
+    (groupCollapse == null ? void 0 : groupCollapse.defaultExpandedKeys) ? [...groupCollapse.defaultExpandedKeys] : []
+  );
+  const [openFilterKey, setOpenFilterKey] = react.useState(null);
+  const [draftFilters, setDraftFilters] = react.useState(/* @__PURE__ */ new Map());
+  const [hoveredBadgeKey, setHoveredBadgeKey] = react.useState(null);
+  const tableInstanceIdRef = react.useRef(`btable-${Math.random().toString(36).slice(2, 10)}`);
+  const tableInstanceId = tableInstanceIdRef.current;
+  const [filterAnchor, setFilterAnchor] = react.useState(null);
+  const [filterPopupPosition, setFilterPopupPosition] = react.useState(null);
+  const [filterSearchInput, setFilterSearchInput] = react.useState("");
+  const [debouncedFilterSearch, setDebouncedFilterSearch] = react.useState("");
+  const [requestedFilterOptions, setRequestedFilterOptions] = react.useState();
+  const filterRequestIdRef = react.useRef(0);
+  const ignoreNextPaginationChangeRef = react.useRef(false);
+  const [horizontalInsets, setHorizontalInsets] = react.useState({ start: 0, end: 0 });
+  const [scrollPing, setScrollPing] = react.useState({ start: false, end: false });
+  const paginationConfig = pagination || void 0;
+  const pageSize = (paginationConfig == null ? void 0 : paginationConfig.pageSize) ?? uncontrolledPageSize;
+  const selectedKeys = (rowSelection == null ? void 0 : rowSelection.selectedRowKeys) ?? uncontrolledSelectedKeys;
+  const activeColumns = leafColumns;
+  const fixedLayoutSignature = `${activeColumns.map((column) => `${String(column.fixed ?? "")}:${String(column.width ?? "")}`).join("|")}|${rowSelection ? String(rowSelection.columnWidth ?? "") : "-"}|${String((scroll == null ? void 0 : scroll.x) ?? "")}|${String(tableLayout ?? "")}`;
+  const isFixedLeftColumn = (column) => Boolean(column && (column.fixed === "left" || column.fixed === true));
+  const isFixedRightColumn = (column) => Boolean(column && column.fixed === "right");
+  const sortOrders = new Map(uncontrolledSortOrders);
+  const activeFilters = new Map(uncontrolledFilters);
+  activeColumns.forEach((rawColumn, index2) => {
+    if ("children" in rawColumn) return;
+    const key = sortFilter.getColumnKey(rawColumn, index2);
+    if (rawColumn.sortOrder !== void 0) sortOrders.set(key, rawColumn.sortOrder);
+    if (rawColumn.filteredValue !== void 0) activeFilters.set(key, rawColumn.filteredValue);
+  });
+  const filteredData = react.useMemo(
+    () => sortFilter.filterRecords(dataSource, activeColumns, activeFilters),
+    [activeColumns, activeFilters, dataSource]
+  );
+  const processedData = react.useMemo(
+    () => sortFilter.sortRecords(filteredData, activeColumns, sortOrders),
+    [activeColumns, filteredData, sortOrders]
+  );
+  const total = (paginationConfig == null ? void 0 : paginationConfig.total) ?? processedData.length;
+  const pageCount = getPageCount(total, pageSize);
+  const current = Math.min((paginationConfig == null ? void 0 : paginationConfig.current) ?? uncontrolledCurrent, pageCount);
+  const expandedGroupKeys = (groupCollapse == null ? void 0 : groupCollapse.expandedKeys) ?? uncontrolledExpandedGroupKeys;
+  const isGroupRow = (record, index2) => (groupCollapse == null ? void 0 : groupCollapse.isGroupRow) ? groupCollapse.isGroupRow(record, index2) : Boolean(record.isGroup);
+  const getGroupKey = (record, index2) => (groupCollapse == null ? void 0 : groupCollapse.groupKey) ? groupCollapse.groupKey(record, index2) : record.groupId;
+  const getChildrenKeys = (record, index2) => (groupCollapse == null ? void 0 : groupCollapse.childrenKeys) ? groupCollapse.childrenKeys(record, index2) : record.childrenIds ?? [];
+  const toggleGroup = (record, index2) => {
+    var _a2;
+    const key = getGroupKey(record, index2);
+    const expanded = expandedGroupKeys.includes(key);
+    const nextKeys = expanded ? expandedGroupKeys.filter((expandedKey) => expandedKey !== key) : [...expandedGroupKeys, key];
+    if ((groupCollapse == null ? void 0 : groupCollapse.expandedKeys) === void 0) setUncontrolledExpandedGroupKeys(nextKeys);
+    (_a2 = groupCollapse == null ? void 0 : groupCollapse.onExpandedKeysChange) == null ? void 0 : _a2.call(groupCollapse, nextKeys, record, !expanded);
+  };
+  react.useEffect(() => {
+    if (current !== uncontrolledCurrent && (paginationConfig == null ? void 0 : paginationConfig.current) === void 0) {
+      setUncontrolledCurrent(current);
+    }
+  }, [current, paginationConfig == null ? void 0 : paginationConfig.current, uncontrolledCurrent]);
+  react.useEffect(() => {
+    if (!filterAnchor || openFilterKey === null) {
+      setFilterPopupPosition(null);
+      return;
+    }
+    const updatePosition = () => {
+      const rect = filterAnchor.getBoundingClientRect();
+      setFilterPopupPosition({ left: rect.left, top: rect.bottom + 4 });
+    };
+    updatePosition();
+    document.addEventListener("scroll", updatePosition, true);
+    window.addEventListener("resize", updatePosition);
+    return () => {
+      document.removeEventListener("scroll", updatePosition, true);
+      window.removeEventListener("resize", updatePosition);
+    };
+  }, [filterAnchor, openFilterKey]);
+  react.useEffect(() => {
+    if (openFilterKey === null) return;
+    const handleOutsideClick = (event) => {
+      const target = event.target;
+      if ((filterAnchor == null ? void 0 : filterAnchor.contains(target)) || target.closest(".bj-table__filter-dropdown")) return;
+      setOpenFilterKey(null);
+      setFilterAnchor(null);
+    };
+    document.addEventListener("mousedown", handleOutsideClick);
+    return () => document.removeEventListener("mousedown", handleOutsideClick);
+  }, [filterAnchor, openFilterKey]);
+  react.useEffect(() => {
+    const timer = window.setTimeout(
+      () => setDebouncedFilterSearch(filterSearchInput.trim()),
+      FILTER_SEARCH_DEBOUNCE_MS
+    );
+    return () => window.clearTimeout(timer);
+  }, [filterSearchInput]);
+  react.useEffect(() => {
+    if (openFilterKey === null) return;
+    const openColumn = leafColumns.find((column, index2) => sortFilter.getColumnKey(column, index2) === openFilterKey);
+    if (!openColumn || "children" in openColumn || !openColumn.filterRequest) return;
+    const requestId = ++filterRequestIdRef.current;
+    Promise.resolve().then(() => openColumn.filterRequest(debouncedFilterSearch)).then(
+      (options) => {
+        if (filterRequestIdRef.current === requestId) setRequestedFilterOptions(options);
+      },
+      () => {
+        if (filterRequestIdRef.current === requestId) setRequestedFilterOptions([]);
+      }
+    );
+  }, [debouncedFilterSearch, leafColumns, openFilterKey]);
+  const visibleRecords = react.useMemo(() => {
+    if (!paginationConfig || paginationConfig.serverPagination) {
+      return processedData.map((record, index2) => ({ record, index: index2 })).filter(({ record, index: index2 }) => {
+        if (!groupCollapse || isGroupRow(record, index2)) return true;
+        const childKey = getRowKey(record, index2, rowKey);
+        return processedData.some(
+          (group, groupIndex) => isGroupRow(group, groupIndex) && expandedGroupKeys.includes(getGroupKey(group, groupIndex)) && getChildrenKeys(group, groupIndex).includes(childKey)
+        );
+      });
+    }
+    const start = (current - 1) * pageSize;
+    return processedData.slice(start, start + pageSize).map((record, index2) => ({
+      record,
+      index: start + index2
+    })).filter(({ record, index: index2 }) => {
+      if (!groupCollapse || isGroupRow(record, index2)) return true;
+      const childKey = getRowKey(record, index2, rowKey);
+      return processedData.some(
+        (group, groupIndex) => isGroupRow(group, groupIndex) && expandedGroupKeys.includes(getGroupKey(group, groupIndex)) && getChildrenKeys(group, groupIndex).includes(childKey)
+      );
+    });
+  }, [current, expandedGroupKeys, groupCollapse, pageSize, paginationConfig, processedData, rowKey]);
+  const visibleSelectionKeys = react.useMemo(
+    () => visibleRecords.map(({ record, index: index2 }) => getRowKey(record, index2, rowKey)),
+    [rowKey, visibleRecords]
+  );
+  const selectedKeySignature = selectedKeys.map(String).join("|");
+  const visibleKeySignature = visibleSelectionKeys.map(String).join("|");
+  react.useEffect(() => {
+    var _a2;
+    if (!rowSelection || preserveSelectedRowKeys || selectedKeys.length === 0) return;
+    const visibleKeySet = new Set(visibleSelectionKeys);
+    const nextSelectedKeys = selectedKeys.filter((key) => visibleKeySet.has(key));
+    if (nextSelectedKeys.length === selectedKeys.length) return;
+    if (rowSelection.selectedRowKeys === void 0) {
+      setUncontrolledSelectedKeys(nextSelectedKeys);
+    }
+    const nextSelectedKeySet = new Set(nextSelectedKeys);
+    const nextSelectedRows = visibleRecords.filter(({ record, index: index2 }) => nextSelectedKeySet.has(getRowKey(record, index2, rowKey))).map(({ record }) => record);
+    (_a2 = rowSelection.onChange) == null ? void 0 : _a2.call(rowSelection, nextSelectedKeys, nextSelectedRows, { type: "multiple" });
+  }, [preserveSelectedRowKeys, rowSelection, rowKey, selectedKeySignature, visibleKeySignature, visibleRecords]);
+  react.useEffect(() => {
+    const element = tableScrollRef.current;
+    if (!element || !(scroll == null ? void 0 : scroll.x)) {
+      setHorizontalInsets((previous) => previous.start === 0 && previous.end === 0 ? previous : { start: 0, end: 0 });
+      setScrollPing((previous) => previous.start || previous.end ? { start: false, end: false } : previous);
+      return;
+    }
+    const measure = () => {
+      const layoutRow = element.querySelector(".bj-table__header .bj-table__header-row") ?? element.querySelector(".bj-table__body .bj-table__row");
+      let start = 0;
+      let end = 0;
+      if (layoutRow) {
+        Array.from(layoutRow.children).forEach((cell) => {
+          const width = cell.getBoundingClientRect().width;
+          if (cell.classList.contains("bj-table__cell--fixed-right")) {
+            end += width;
+          } else if (cell.classList.contains("bj-table__cell--fixed-left") || cell.classList.contains("bj-table__selection-cell--fixed")) {
+            start += width;
+          }
+        });
+        const borderWidth = element.clientLeft;
+        if (start > 0) start += borderWidth;
+        if (end > 0) end = Math.max(end - borderWidth, 0);
+      }
+      setHorizontalInsets((previous) => previous.start === start && previous.end === end ? previous : { start, end });
+    };
+    const syncPing = () => {
+      const maxScroll = element.scrollWidth - element.clientWidth;
+      const scrollable = maxScroll > SCROLL_EDGE_THRESHOLD;
+      const next = {
+        start: scrollable && element.scrollLeft > SCROLL_EDGE_THRESHOLD,
+        end: scrollable && element.scrollLeft < maxScroll - SCROLL_EDGE_THRESHOLD
+      };
+      setScrollPing((previous) => previous.start === next.start && previous.end === next.end ? previous : next);
+    };
+    const sync = () => {
+      measure();
+      syncPing();
+    };
+    sync();
+    element.addEventListener("scroll", syncPing, { passive: true });
+    const observer = new ResizeObserver(sync);
+    observer.observe(element);
+    if (element.firstElementChild) observer.observe(element.firstElementChild);
+    return () => {
+      element.removeEventListener("scroll", syncPing);
+      observer.disconnect();
+    };
+  }, [fixedLayoutSignature, scroll == null ? void 0 : scroll.x, showHeader, visibleRecords.length]);
+  const emitChange = (action, nextSortOrders = sortOrders, nextFilters = activeFilters, nextCurrent = current, nextPageSize = pageSize) => {
+    const filterInfo = Object.fromEntries(nextFilters);
+    const nextFilteredData = sortFilter.filterRecords(dataSource, activeColumns, nextFilters);
+    const nextProcessedData = sortFilter.sortRecords(nextFilteredData, activeColumns, nextSortOrders);
+    onChange == null ? void 0 : onChange(
+      { ...paginationConfig, current: nextCurrent, pageSize: nextPageSize, total: (paginationConfig == null ? void 0 : paginationConfig.total) ?? nextProcessedData.length },
+      filterInfo,
+      sortFilter.getSorterResult(activeColumns, nextSortOrders),
+      { action, currentDataSource: nextProcessedData }
+    );
+  };
+  const changeSorter = (column, index2) => {
+    if (!column.sorter) return;
+    const key = sortFilter.getColumnKey(column, index2);
+    const nextOrder = sortFilter.getNextSortOrder(sortOrders.get(key) ?? null, column.sortDirections ?? sortDirections);
+    const nextOrders = /* @__PURE__ */ new Map();
+    nextOrders.set(key, nextOrder);
+    if (column.sortOrder === void 0) setUncontrolledSortOrders(nextOrders);
+    emitChange("sort", nextOrders);
+  };
+  const confirmFilter = (column, index2, selectedKeys2) => {
+    const key = sortFilter.getColumnKey(column, index2);
+    const nextFilters = new Map(activeFilters);
+    nextFilters.set(key, selectedKeys2);
+    if (column.filteredValue === void 0) setUncontrolledFilters(nextFilters);
+    setOpenFilterKey(null);
+    if ((paginationConfig == null ? void 0 : paginationConfig.current) === void 0) setUncontrolledCurrent(1);
+    emitChange("filter", sortOrders, nextFilters, 1);
+  };
+  const resetFilter = (column, index2) => {
+    const key = sortFilter.getColumnKey(column, index2);
+    const nextKeys = column.filterResetToDefaultFilteredValue ? column.defaultFilteredValue ?? [] : [];
+    setDraftFilters((filters) => new Map(filters).set(key, nextKeys));
+  };
+  const toggleFilter = (column, index2, anchor) => {
+    var _a2, _b2, _c2, _d;
+    const key = sortFilter.getColumnKey(column, index2);
+    if (openFilterKey === key) {
+      setOpenFilterKey(null);
+      setFilterAnchor(null);
+      (_a2 = column.onFilterDropdownOpenChange) == null ? void 0 : _a2.call(column, false);
+      (_b2 = column.onFilterDropdownVisibleChange) == null ? void 0 : _b2.call(column, false);
+      return;
+    }
+    setFilterSearchInput("");
+    setDebouncedFilterSearch("");
+    setRequestedFilterOptions(void 0);
+    setDraftFilters((filters) => new Map(filters).set(key, activeFilters.get(key) ?? []));
+    setOpenFilterKey(key);
+    if (anchor) setFilterAnchor(anchor);
+    (_c2 = column.onFilterDropdownOpenChange) == null ? void 0 : _c2.call(column, true);
+    (_d = column.onFilterDropdownVisibleChange) == null ? void 0 : _d.call(column, true);
+  };
+  const renderHeaderCell = (column, index2) => {
+    var _a2, _b2;
+    const key = sortFilter.getColumnKey(column, index2);
+    const badgeId = `bj-table-badge-${tableInstanceId}-${String(key).replace(/[^a-zA-Z0-9_-]/g, "-")}`;
+    const sortOrder = sortOrders.get(key) ?? null;
+    const filteredKeys = activeFilters.get(key) ?? [];
+    const draftKeys = draftFilters.get(key) ?? filteredKeys;
+    const isFilterOpen = column.filterDropdownOpen ?? column.filterDropdownVisible ?? openFilterKey === key;
+    const isFiltered = column.filtered || filteredKeys.length > 0;
+    const sortIconType = sortOrder === "ascend" ? "icon-a-zhengxumian" : sortOrder === "descend" ? "icon-a-daoxumian" : "icon-a-weipaixumian";
+    const title2 = sortFilter.renderColumnTitle(column.title, {
+      sortOrder,
+      sortColumn: sortOrder ? column : void 0,
+      sortColumns: sortOrder ? [{ column, order: sortOrder }] : [],
+      filters: Object.fromEntries(activeFilters)
+    });
+    const customFilterContent = typeof column.filterDropdown === "function" ? column.filterDropdown({
+      prefixCls: "bj-table",
+      selectedKeys: draftKeys.filter((value) => typeof value !== "boolean"),
+      setSelectedKeys: (keys) => setDraftFilters((filters) => new Map(filters).set(key, keys)),
+      confirm: (options) => {
+        confirmFilter(column, index2, draftFilters.get(key) ?? draftKeys);
+        if ((options == null ? void 0 : options.closeDropdown) === false) setOpenFilterKey(key);
+      },
+      clearFilters: (options) => {
+        const nextKeys = column.filterResetToDefaultFilteredValue ? column.defaultFilteredValue ?? [] : [];
+        setDraftFilters((filters) => new Map(filters).set(key, nextKeys));
+        if ((options == null ? void 0 : options.confirm) === true) confirmFilter(column, index2, nextKeys);
+        if ((options == null ? void 0 : options.closeDropdown) === false || (options == null ? void 0 : options.confirm) !== true) setOpenFilterKey(key);
+      },
+      filters: column.filters,
+      close: () => setOpenFilterKey(null),
+      visible: isFilterOpen
+    }) : column.filterDropdown;
+    const filterOptions = column.filterRequest ? requestedFilterOptions ?? [] : column.filters ?? [];
+    const visibleFilterOptions = debouncedFilterSearch && !column.filterRequest ? filterOptions.filter((option) => typeof column.filterSearch === "function" ? column.filterSearch(debouncedFilterSearch, option) : defaultFilterSearch(debouncedFilterSearch, option)) : filterOptions;
+    const showFilterSearch = Boolean(column.filterSearch || column.filterRequest);
+    const headerContent = /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames("bj-table__column-header", column.sorter && "bj-table__column-header--sortable"), children: [
+      column.badge !== void 0 && /* @__PURE__ */ jsxRuntime.jsx(
+        "span",
+        {
+          "aria-label": "表头提示",
+          className: "bj-table__column-badge-trigger",
+          id: badgeId,
+          onBlur: () => setHoveredBadgeKey(null),
+          onClick: (event) => event.stopPropagation(),
+          onFocus: () => setHoveredBadgeKey(key),
+          onKeyDown: (event) => event.stopPropagation(),
+          onMouseEnter: () => setHoveredBadgeKey(key),
+          onMouseLeave: () => setHoveredBadgeKey(null),
+          role: "button",
+          tabIndex: 0,
+          children: /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", className: "bj-table__column-badge-shape" })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "bj-table__column-title", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "bj-table__column-title-content", children: title2 }),
+        column.sorter && /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", className: "bj-table__column-sorter", children: /* @__PURE__ */ jsxRuntime.jsx(Icon, { className: "bj-table__column-sorter-icon", type: sortIconType }) })
+      ] }),
+      (column.filters || column.filterDropdown) && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "bj-table__filter", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            "aria-expanded": isFilterOpen,
+            "aria-label": "筛选",
+            className: classNames("bj-table__filter-trigger", isFiltered && "bj-table__filter-trigger--active"),
+            onClick: (event) => {
+              event.stopPropagation();
+              toggleFilter(column, index2);
+            },
+            type: "button",
+            children: typeof column.filterIcon === "function" ? column.filterIcon(isFiltered) : column.filterIcon ?? /* @__PURE__ */ jsxRuntime.jsx(
+              Icon,
+              {
+                className: "bj-table__filter-icon",
+                type: isFiltered ? "icon-shaixuan-daidian" : "icon-a-shaixuanxi"
+              }
+            )
+          }
+        ),
+        isFilterOpen && filterPopupPosition && typeof document !== "undefined" && reactDom.createPortal(
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              className: "bj-table__filter-dropdown",
+              onClick: (event) => event.stopPropagation(),
+              role: "dialog",
+              style: { left: filterPopupPosition.left, top: filterPopupPosition.top },
+              children: customFilterContent ?? /* @__PURE__ */ jsxRuntime.jsx(
+                BDropdown.BDropdown,
+                {
+                  ...column.filterDropdownProps,
+                  emptyText: (locale == null ? void 0 : locale.filterEmptyText) ?? t("暂无结果"),
+                  multiple: column.filterMultiple !== false,
+                  onChange: (nextKeys, option) => {
+                    var _a3, _b3;
+                    setDraftFilters((filters) => new Map(filters).set(key, nextKeys));
+                    (_b3 = (_a3 = column.filterDropdownProps) == null ? void 0 : _a3.onChange) == null ? void 0 : _b3.call(_a3, nextKeys, option);
+                  },
+                  onConfirm: (nextKeys) => {
+                    var _a3, _b3;
+                    confirmFilter(column, index2, nextKeys);
+                    (_b3 = (_a3 = column.filterDropdownProps) == null ? void 0 : _a3.onConfirm) == null ? void 0 : _b3.call(_a3, nextKeys);
+                  },
+                  onReset: () => {
+                    var _a3, _b3;
+                    resetFilter(column, index2);
+                    (_b3 = (_a3 = column.filterDropdownProps) == null ? void 0 : _a3.onReset) == null ? void 0 : _b3.call(_a3);
+                  },
+                  onSearch: (nextSearchValue) => {
+                    var _a3, _b3;
+                    setFilterSearchInput(nextSearchValue);
+                    (_b3 = (_a3 = column.filterDropdownProps) == null ? void 0 : _a3.onSearch) == null ? void 0 : _b3.call(_a3, nextSearchValue);
+                  },
+                  options: visibleFilterOptions.map((option) => ({
+                    label: option.text,
+                    description: option.description,
+                    value: option.value
+                  })),
+                  searchable: ((_a2 = column.filterDropdownProps) == null ? void 0 : _a2.searchable) ?? showFilterSearch,
+                  searchPlaceholder: ((_b2 = column.filterDropdownProps) == null ? void 0 : _b2.searchPlaceholder) ?? (column.filterRequest ? t("请输入搜索内容") : (locale == null ? void 0 : locale.filterSearchPlaceholder) ?? t("搜索")),
+                  searchValue: filterSearchInput,
+                  t,
+                  value: draftKeys
+                }
+              )
+            }
+          ),
+          document.body
+        )
+      ] })
+    ] });
+    return column.badge !== void 0 ? /* @__PURE__ */ jsxRuntime.jsxs(
+      TooltipWrapper,
+      {
+        className: "bj-table__column-tooltip-wrapper",
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bj-table__column-tooltip-trigger", children: headerContent }),
+          hoveredBadgeKey === key && /* @__PURE__ */ jsxRuntime.jsx(
+            ContentTooltip,
+            {
+              className: "bj-table__column-tooltip",
+              content: column.badge,
+              getAnchorElement: () => document.getElementById(badgeId),
+              getPopupContainer: () => document.body,
+              placement: "top"
+            }
+          )
+        ]
+      }
+    ) : headerContent;
+  };
+  const updateSelection = (nextSelectedKeys, selection, selectedRecord) => {
+    var _a2, _b2;
+    if (selection.selectedRowKeys === void 0) {
+      setUncontrolledSelectedKeys(nextSelectedKeys);
+    }
+    const selectedKeySet = new Set(nextSelectedKeys);
+    const selectedRows = dataSource.filter(
+      (record, index2) => selectedKeySet.has(getRowKey(record, index2, rowKey))
+    );
+    (_a2 = selection.onChange) == null ? void 0 : _a2.call(selection, nextSelectedKeys, selectedRows);
+    if (selectedRecord) {
+      (_b2 = selection.onSelect) == null ? void 0 : _b2.call(
+        selection,
+        selectedRecord,
+        selectedKeySet.has(getRowKey(selectedRecord, dataSource.indexOf(selectedRecord), rowKey)),
+        selectedRows
+      );
+    }
+  };
+  const toggleRow = (record, index2) => {
+    if (!rowSelection) {
+      return;
+    }
+    const key = getRowKey(record, index2, rowKey);
+    const selected = selectedKeys.includes(key);
+    const nextSelectedKeys = rowSelection.type === "radio" ? selected ? [] : [key] : selected ? selectedKeys.filter((selectedKey) => selectedKey !== key) : [...selectedKeys, key];
+    updateSelection(nextSelectedKeys, rowSelection, record);
+  };
+  const selectableVisibleRecords = visibleRecords.filter(
+    ({ record }) => {
+      var _a2;
+      return !((_a2 = rowSelection == null ? void 0 : rowSelection.getCheckboxProps) == null ? void 0 : _a2.call(rowSelection, record).disabled);
+    }
+  );
+  const selectableVisibleKeys = selectableVisibleRecords.map(
+    ({ record, index: index2 }) => getRowKey(record, index2, rowKey)
+  );
+  const allVisibleSelected = selectableVisibleKeys.length > 0 && selectableVisibleKeys.every((key) => selectedKeys.includes(key));
+  const toggleAll = () => {
+    var _a2;
+    if (!rowSelection || rowSelection.type === "radio") {
+      return;
+    }
+    const visibleKeySet = new Set(selectableVisibleKeys);
+    const nextSelectedKeys = allVisibleSelected ? selectedKeys.filter((key) => !visibleKeySet.has(key)) : Array.from(/* @__PURE__ */ new Set([...selectedKeys, ...selectableVisibleKeys]));
+    updateSelection(nextSelectedKeys, rowSelection);
+    new Set(nextSelectedKeys);
+    (_a2 = rowSelection.onSelectAll) == null ? void 0 : _a2.call(
+      rowSelection,
+      !allVisibleSelected,
+      selectableVisibleRecords.map(({ record }) => record)
+    );
+  };
+  const changePage = (nextPage) => {
+    var _a2;
+    if (!paginationConfig || nextPage < 1 || nextPage > pageCount || nextPage === current) {
+      return;
+    }
+    if (paginationConfig.current === void 0) {
+      setUncontrolledCurrent(nextPage);
+    }
+    (_a2 = paginationConfig.onChange) == null ? void 0 : _a2.call(paginationConfig, nextPage, pageSize);
+    emitChange("paginate", sortOrders, activeFilters, nextPage);
+  };
+  const changePageSize = (nextPageSize) => {
+    var _a2, _b2;
+    if (!paginationConfig || nextPageSize === pageSize) {
+      return;
+    }
+    const nextCurrent = 1;
+    ignoreNextPaginationChangeRef.current = true;
+    if (paginationConfig.pageSize === void 0) {
+      setUncontrolledPageSize(nextPageSize);
+    }
+    if (paginationConfig.current === void 0) {
+      setUncontrolledCurrent(nextCurrent);
+    }
+    (_a2 = paginationConfig.onShowSizeChange) == null ? void 0 : _a2.call(paginationConfig, nextCurrent, nextPageSize);
+    (_b2 = paginationConfig.onChange) == null ? void 0 : _b2.call(paginationConfig, nextCurrent, nextPageSize);
+    emitChange("paginate", sortOrders, activeFilters, nextCurrent, nextPageSize);
+  };
+  const columnCount = activeColumns.length + (rowSelection ? 1 : 0);
+  const selectionColumnWidth = (rowSelection == null ? void 0 : rowSelection.columnWidth) ?? 48;
+  const getColumnWidth = (column) => typeof column.width === "number" ? column.width : 0;
+  const getFixedStyle = (column, columnIndex) => {
+    const fixed = column.fixed === true ? "left" : column.fixed;
+    if (fixed === "left") {
+      const left = activeColumns.slice(0, columnIndex).reduce((offset, current2) => offset + getColumnWidth(current2), rowSelection && typeof selectionColumnWidth === "number" ? selectionColumnWidth : 0);
+      return { position: "sticky", left, zIndex: 2 };
+    }
+    if (fixed === "right") {
+      const right = activeColumns.slice(columnIndex + 1).reduce((offset, current2) => offset + getColumnWidth(current2), 0);
+      return { position: "sticky", right, zIndex: 2 };
+    }
+    return {};
+  };
+  const scrollTableStyle = (scroll == null ? void 0 : scroll.x) ? {
+    width: scroll.x === true ? "max-content" : scroll.x,
+    minWidth: "100%",
+    tableLayout: tableLayout ?? "fixed"
+  } : { tableLayout };
+  const TableComponent = (components == null ? void 0 : components.table) ?? "table";
+  const HeaderWrapper = ((_a = components == null ? void 0 : components.header) == null ? void 0 : _a.wrapper) ?? "thead";
+  const HeaderRow = ((_b = components == null ? void 0 : components.header) == null ? void 0 : _b.row) ?? "tr";
+  const HeaderCell = ((_c = components == null ? void 0 : components.header) == null ? void 0 : _c.cell) ?? "th";
+  const bodyComponents = typeof (components == null ? void 0 : components.body) === "object" ? components.body : void 0;
+  const BodyWrapper = (bodyComponents == null ? void 0 : bodyComponents.wrapper) ?? "tbody";
+  const BodyRow = (bodyComponents == null ? void 0 : bodyComponents.row) ?? "tr";
+  const BodyCell = (bodyComponents == null ? void 0 : bodyComponents.cell) ?? "td";
+  const resolvedEmptyText = typeof emptyText === "function" ? emptyText() : emptyText ?? t("暂无数据");
+  const resolvedEmptyImage = typeof emptyImage === "string" ? /* @__PURE__ */ jsxRuntime.jsx("img", { alt: "", className: "bj-table__empty-image", src: emptyImage }) : emptyImage;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      id,
+      ref: tableRootRef,
+      className: classNames(
+        "bj-table",
+        bordered && "bj-table--bordered",
+        `bj-table--${size}`,
+        loading && "bj-table--loading",
+        processedData.length === 0 && "bj-table--empty",
+        scrollPing.start && "bj-table--ping-left",
+        scrollPing.end && "bj-table--ping-right",
+        className
+      ),
+      style,
+      children: [
+        title && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bj-table__title", children: title(processedData) }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "bj-table__viewport", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              className: classNames("bj-table__scroll", Boolean((scroll == null ? void 0 : scroll.x) || (scroll == null ? void 0 : scroll.y)) && "bj-overlay-scrollbar-hidden"),
+              ref: tableScrollRef,
+              style: { maxHeight: scroll == null ? void 0 : scroll.y },
+              children: /* @__PURE__ */ jsxRuntime.jsxs(TableComponent, { className: "bj-table__native-table", style: scrollTableStyle, children: [
+                activeColumns.some((column) => column.width) && /* @__PURE__ */ jsxRuntime.jsxs("colgroup", { children: [
+                  rowSelection && /* @__PURE__ */ jsxRuntime.jsx("col", { className: "bj-table__selection-col", style: { width: selectionColumnWidth } }),
+                  activeColumns.map((column, index2) => /* @__PURE__ */ jsxRuntime.jsx("col", { style: { width: column.width } }, column.key ?? index2))
+                ] }),
+                showHeader && /* @__PURE__ */ jsxRuntime.jsx(HeaderWrapper, { className: "bj-table__header", children: headerRows.map((headerRow, rowIndex) => /* @__PURE__ */ jsxRuntime.jsxs(HeaderRow, { className: "bj-table__header-row", ...onHeaderRow == null ? void 0 : onHeaderRow(activeColumns, rowIndex), children: [
+                  rowSelection && rowIndex === 0 && /* @__PURE__ */ jsxRuntime.jsxs(
+                    HeaderCell,
+                    {
+                      className: classNames(
+                        "bj-table__header-cell",
+                        "bj-table__selection-cell",
+                        Boolean(scroll == null ? void 0 : scroll.x) && "bj-table__selection-cell--fixed",
+                        // 选择列就是最后一个左固定区域时，由它承担左侧渐变阴影
+                        Boolean(scroll == null ? void 0 : scroll.x) && !isFixedLeftColumn(activeColumns[0]) && "bj-table__cell--fixed-left-last"
+                      ),
+                      rowSpan: headerRows.length,
+                      scope: "col",
+                      style: { width: selectionColumnWidth },
+                      children: [
+                        rowSelection.type !== "radio" && /* @__PURE__ */ jsxRuntime.jsx(
+                          SelectionControl,
+                          {
+                            checked: allVisibleSelected,
+                            disabled: selectableVisibleKeys.length === 0,
+                            onChange: toggleAll,
+                            label: "选择当前页所有行"
+                          }
+                        ),
+                        rowSelection.columnTitle
+                      ]
+                    }
+                  ),
+                  headerRow.map(({ column: rawColumn, colSpan, rowSpan }, index2) => {
+                    var _a2, _b2;
+                    const column = rawColumn;
+                    const leafIndex = activeColumns.indexOf(column);
+                    const interactionIndex = leafIndex >= 0 ? leafIndex : index2;
+                    const isFilterable = !("children" in rawColumn) && Boolean(column.filters || column.filterDropdown);
+                    const isSortable = !("children" in rawColumn) && Boolean(column.sorter);
+                    const triggerHeaderAction = () => {
+                      if (isFilterable) {
+                        toggleFilter(column, interactionIndex);
+                      } else if (isSortable) {
+                        changeSorter(column, interactionIndex);
+                      }
+                    };
+                    return /* @__PURE__ */ react.createElement(
+                      HeaderCell,
+                      {
+                        ...(_a2 = column.onHeaderCell) == null ? void 0 : _a2.call(column, rawColumn, index2),
+                        "aria-label": typeof column.title === "string" ? column.title : void 0,
+                        "aria-sort": isSortable ? sortOrders.get(sortFilter.getColumnKey(column, interactionIndex)) === "ascend" ? "ascending" : sortOrders.get(sortFilter.getColumnKey(column, interactionIndex)) === "descend" ? "descending" : "none" : void 0,
+                        className: classNames(
+                          "bj-table__header-cell",
+                          ((_b2 = activeColumns[interactionIndex + 1]) == null ? void 0 : _b2.fixed) === "right" && "bj-table__cell--before-fixed-right",
+                          column.fixed && "bj-table__cell--fixed",
+                          isFixedLeftColumn(column) && "bj-table__cell--fixed-left",
+                          isFixedLeftColumn(column) && !isFixedLeftColumn(activeColumns[interactionIndex + 1]) && "bj-table__cell--fixed-left-last",
+                          isFixedRightColumn(column) && "bj-table__cell--fixed-right",
+                          isFixedRightColumn(column) && !isFixedRightColumn(activeColumns[interactionIndex - 1]) && "bj-table__cell--fixed-right-first",
+                          column.sorter && "bj-table__header-cell--sortable",
+                          isFilterable && "bj-table__header-cell--filterable",
+                          sortOrders.get(sortFilter.getColumnKey(column, interactionIndex)) && "bj-table__header-cell--sorted",
+                          column.className
+                        ),
+                        colSpan,
+                        key: column.key ?? String(column.dataIndex ?? index2),
+                        onClick: (event) => {
+                          var _a3, _b3, _c2;
+                          (_c2 = (_b3 = (_a3 = column.onHeaderCell) == null ? void 0 : _a3.call(column, rawColumn, index2)) == null ? void 0 : _b3.onClick) == null ? void 0 : _c2.call(_b3, event);
+                          if (event.target.closest(".bj-table__filter-dropdown")) return;
+                          if (isFilterable) {
+                            toggleFilter(column, interactionIndex, event.currentTarget);
+                          } else {
+                            triggerHeaderAction();
+                          }
+                        },
+                        onKeyDown: (event) => {
+                          var _a3, _b3, _c2;
+                          (_c2 = (_b3 = (_a3 = column.onHeaderCell) == null ? void 0 : _a3.call(column, rawColumn, index2)) == null ? void 0 : _b3.onKeyDown) == null ? void 0 : _c2.call(_b3, event);
+                          if (event.target.closest(".bj-table__filter-dropdown")) return;
+                          if (event.key === "Enter" || event.key === " ") {
+                            event.preventDefault();
+                            if (isFilterable) {
+                              toggleFilter(column, interactionIndex, event.currentTarget);
+                            } else {
+                              triggerHeaderAction();
+                            }
+                          }
+                        },
+                        rowSpan,
+                        scope: "col",
+                        style: { textAlign: column.align, ...getFixedStyle(column, interactionIndex) },
+                        tabIndex: isFilterable || isSortable ? 0 : void 0
+                      },
+                      "children" in rawColumn ? sortFilter.renderColumnTitle(rawColumn.title, { filters: Object.fromEntries(activeFilters) }) : renderHeaderCell(column, interactionIndex)
+                    );
+                  })
+                ] }, rowIndex)) }),
+                /* @__PURE__ */ jsxRuntime.jsx(BodyWrapper, { className: "bj-table__body", children: visibleRecords.length > 0 ? visibleRecords.map(({ record, index: index2 }) => {
+                  var _a2;
+                  const key = getRowKey(record, index2, rowKey);
+                  const groupRow = isGroupRow(record, index2);
+                  const isDisabled = ((_a2 = rowSelection == null ? void 0 : rowSelection.getCheckboxProps) == null ? void 0 : _a2.call(rowSelection, record).disabled) ?? false;
+                  const isSelected = selectedKeys.includes(key);
+                  const resolvedRowClassName = typeof rowClassName === "function" ? rowClassName(record, index2, 0) : rowClassName;
+                  return /* @__PURE__ */ react.createElement(
+                    BodyRow,
+                    {
+                      ...onRow == null ? void 0 : onRow(record, index2),
+                      className: classNames("bj-table__row", groupRow && "bj-table__row--group", isSelected && "bj-table__row--selected", resolvedRowClassName),
+                      key
+                    },
+                    rowSelection && !groupRow && /* @__PURE__ */ jsxRuntime.jsx(
+                      BodyCell,
+                      {
+                        className: classNames(
+                          "bj-table__cell",
+                          "bj-table__selection-cell",
+                          Boolean(scroll == null ? void 0 : scroll.x) && "bj-table__selection-cell--fixed",
+                          // 选择列就是最后一个左固定区域时，由它承担左侧渐变阴影
+                          Boolean(scroll == null ? void 0 : scroll.x) && !isFixedLeftColumn(activeColumns[0]) && "bj-table__cell--fixed-left-last"
+                        ),
+                        style: { width: selectionColumnWidth },
+                        children: /* @__PURE__ */ jsxRuntime.jsx(
+                          SelectionControl,
+                          {
+                            checked: isSelected,
+                            disabled: isDisabled,
+                            label: `选择第 ${index2 + 1} 行`,
+                            name: rowSelection.type === "radio" ? "bj-table-row-selection" : void 0,
+                            onChange: () => toggleRow(record, index2),
+                            type: rowSelection.type ?? "checkbox"
+                          }
+                        )
+                      }
+                    ),
+                    activeColumns.map((rawColumn, columnIndex) => {
+                      var _a3, _b2, _c2;
+                      if (groupRow && columnIndex > 0) return null;
+                      const column = rawColumn;
+                      const value = getValue(record, column.dataIndex);
+                      const rendered = column.render ? column.render(value, record, index2) : value;
+                      const renderedCell = isRenderedCell(rendered) ? rendered : void 0;
+                      const cellProps = { ...(_a3 = column.onCell) == null ? void 0 : _a3.call(column, record, index2), ...renderedCell == null ? void 0 : renderedCell.props };
+                      const content = renderedCell ? renderedCell.children : rendered;
+                      if (cellProps.colSpan === 0 || cellProps.rowSpan === 0) return null;
+                      return /* @__PURE__ */ react.createElement(
+                        BodyCell,
+                        {
+                          ...cellProps,
+                          className: classNames(
+                            "bj-table__cell",
+                            ((_b2 = activeColumns[columnIndex + 1]) == null ? void 0 : _b2.fixed) === "right" && "bj-table__cell--before-fixed-right",
+                            groupRow && "bj-table__cell--group",
+                            column.fixed && "bj-table__cell--fixed",
+                            isFixedLeftColumn(column) && "bj-table__cell--fixed-left",
+                            isFixedLeftColumn(column) && !isFixedLeftColumn(activeColumns[columnIndex + 1]) && "bj-table__cell--fixed-left-last",
+                            isFixedRightColumn(column) && "bj-table__cell--fixed-right",
+                            isFixedRightColumn(column) && !isFixedRightColumn(activeColumns[columnIndex - 1]) && "bj-table__cell--fixed-right-first",
+                            column.ellipsis && "bj-table__cell--ellipsis",
+                            column.className,
+                            cellProps.className
+                          ),
+                          key: column.key ?? String(column.dataIndex ?? columnIndex),
+                          colSpan: groupRow ? columnCount : cellProps.colSpan,
+                          style: { textAlign: column.align, ...getFixedStyle(column, columnIndex), ...cellProps.style }
+                        },
+                        groupRow ? ((_c2 = groupCollapse == null ? void 0 : groupCollapse.render) == null ? void 0 : _c2.call(groupCollapse, {
+                          record,
+                          expanded: expandedGroupKeys.includes(getGroupKey(record, index2)),
+                          onToggle: () => toggleGroup(record, index2)
+                        })) ?? content ?? "" : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bj-table__cell-content", children: content ?? "" })
+                      );
+                    })
+                  );
+                }) : /* @__PURE__ */ jsxRuntime.jsx(BodyRow, { className: "bj-table__empty-row", children: /* @__PURE__ */ jsxRuntime.jsx(
+                  BodyCell,
+                  {
+                    className: "bj-table__empty-cell",
+                    colSpan: Math.max(columnCount, 1),
+                    style: { height: emptyHeight }
+                  }
+                ) }) }),
+                summary && /* @__PURE__ */ jsxRuntime.jsx("tfoot", { className: "bj-table__summary", children: summary(processedData) })
+              ] })
+            }
+          ),
+          visibleRecords.length === 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bj-table__empty-overlay", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "bj-table__empty-content", children: [
+            resolvedEmptyImage && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bj-table__empty-image-wrap", children: resolvedEmptyImage }),
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bj-table__empty-text", children: resolvedEmptyText })
+          ] }) })
+        ] }),
+        ((scroll == null ? void 0 : scroll.x) || (scroll == null ? void 0 : scroll.y)) && /* @__PURE__ */ jsxRuntime.jsx(
+          BOverlayScrollbar,
+          {
+            containerRef: tableRootRef,
+            direction: (scroll == null ? void 0 : scroll.x) && (scroll == null ? void 0 : scroll.y) ? "both" : (scroll == null ? void 0 : scroll.x) ? "horizontal" : "vertical",
+            gap: 2,
+            horizontalInsetEnd: horizontalInsets.end,
+            horizontalInsetStart: horizontalInsets.start,
+            size: 4,
+            targetRef: tableScrollRef
+          }
+        ),
+        footer && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bj-table__footer", children: footer(processedData) }),
+        loading && /* @__PURE__ */ jsxRuntime.jsxs("div", { "aria-live": "polite", "aria-busy": "true", className: "bj-table__loading", role: "status", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("img", { alt: "", className: "bj-table__loading-indicator", src: spin_loading_red }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "bj-table__loading-text", children: "加载中..." })
+        ] }),
+        paginationConfig && processedData.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bj-table__pagination", children: /* @__PURE__ */ jsxRuntime.jsx(
+          Pagination,
+          {
+            align: "end",
+            disabled: loading || paginationConfig.disabled,
+            current,
+            defaultCurrent: paginationConfig.defaultCurrent,
+            defaultPageSize: paginationConfig.defaultPageSize,
+            dropdownClassName: paginationConfig.dropdownClassName,
+            hideOnSinglePage: paginationConfig.hideOnSinglePage,
+            onChange: (nextPage) => {
+              if (ignoreNextPaginationChangeRef.current) {
+                ignoreNextPaginationChangeRef.current = false;
+                return;
+              }
+              changePage(nextPage);
+            },
+            onShowSizeChange: (_, nextPageSize) => changePageSize(nextPageSize),
+            pageSize,
+            pageSizeOptions: paginationConfig.pageSizeOptions,
+            popupPlacement: paginationConfig.popupPlacement,
+            resolvePopupPlacement: paginationConfig.resolvePopupPlacement,
+            showQuickJumper: paginationConfig.showQuickJumper,
+            showSizeChanger: paginationConfig.showSizeChanger,
+            showTotal: paginationConfig.showTotal,
+            simple: paginationConfig.simple,
+            size: paginationConfig.size,
+            t: paginationConfig.t ?? t,
+            total
+          }
+        ) })
+      ]
+    }
+  );
+}
+const CompoundBTable = BTable;
+CompoundBTable.Column = Column;
+CompoundBTable.ColumnGroup = ColumnGroup;
+exports.BTable = CompoundBTable;