@varlet/ui 3.17.0 → 3.18.0-alpha.1781190469654

package/es/data-table/DataTable.mjs

@@ -0,0 +1,656 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { callOrReturn, isArray, isFunction } from "@varlet/shared";
+import { useVModel } from "@varlet/use";
+import { computed, defineComponent } from "vue";
+import VarLoading from "../loading/index.mjs";
+import { t } from "../locale/index.mjs";
+import { injectLocaleProvider } from "../locale-provider/provide.mjs";
+import VarPagination from "../pagination/index.mjs";
+import { createNamespace, formatElevation, MaybeVNode } from "../utils/components.mjs";
+import { toSizeUnit } from "../utils/elements.mjs";
+import DataTableBodyCellComponent from "./DataTableBodyCell.mjs";
+import DataTableHeaderCellComponent from "./DataTableHeaderCell.mjs";
+import {
+  props
+} from "./props.mjs";
+import { useBodyRows } from "./useBodyRows.mjs";
+import { useColumnsFixedOffsets } from "./useColumnsFixedOffsets.mjs";
+import { useColumnSizes } from "./useColumnSizes.mjs";
+import { useContainerScroll } from "./useContainerScroll.mjs";
+import { useExpandRow } from "./useExpandRow.mjs";
+import { useFootRows } from "./useFootRows.mjs";
+import { useHeaderRows } from "./useHeaderRows.mjs";
+import { usePagination } from "./usePagination.mjs";
+import { useSelectionColumn } from "./useSelectionColumn.mjs";
+import { useSorter } from "./useSorter.mjs";
+import { useTreeExpand } from "./useTreeExpand.mjs";
+const { name, n, classes } = createNamespace("data-table");
+import { renderList as _renderList, Fragment as _Fragment, openBlock as _openBlock, createElementBlock as _createElementBlock, normalizeStyle as _normalizeStyle, createElementVNode as _createElementVNode, resolveComponent as _resolveComponent, createBlock as _createBlock, normalizeClass as _normalizeClass, mergeProps as _mergeProps, createVNode as _createVNode, createCommentVNode as _createCommentVNode, renderSlot as _renderSlot, toDisplayString as _toDisplayString, createTextVNode as _createTextVNode, withCtx as _withCtx, createSlots as _createSlots } from "vue";
+const _hoisted_1 = { key: 0 };
+const _hoisted_2 = ["colspan"];
+const _hoisted_3 = { key: 1 };
+const _hoisted_4 = ["colspan", "rowspan"];
+function __render__(_ctx, _cache) {
+  const _component_data_table_header_cell = _resolveComponent("data-table-header-cell");
+  const _component_data_table_body_cell = _resolveComponent("data-table-body-cell");
+  const _component_maybe_v_node = _resolveComponent("maybe-v-node");
+  const _component_var_pagination = _resolveComponent("var-pagination");
+  const _component_var_loading = _resolveComponent("var-loading");
+  return _openBlock(), _createElementBlock(
+    "div",
+    {
+      class: _normalizeClass(
+        _ctx.classes(
+          _ctx.n(),
+          [!_ctx.plain, _ctx.formatElevation(_ctx.elevation, 1)],
+          _ctx.n("$--box"),
+          [_ctx.surface === "low", _ctx.n("--surface-low")],
+          [_ctx.cellBordered, _ctx.n("--cell-bordered")],
+          [_ctx.plain, _ctx.n("--plain")],
+          [_ctx.showPagination, _ctx.n("--with-footer")],
+          _ctx.n(`--${_ctx.size}`)
+        )
+      )
+    },
+    [
+      _createVNode(_component_var_loading, { loading: _ctx.loading }, _createSlots({
+        default: _withCtx(() => [
+          _createElementVNode(
+            "div",
+            {
+              ref: "container",
+              class: _normalizeClass(_ctx.classes(_ctx.n("container"), _ctx.n("$--scrollbar"))),
+              style: _normalizeStyle(_ctx.containerStyle),
+              onScroll: _cache[0] || (_cache[0] = (...args) => _ctx.handleContainerScroll && _ctx.handleContainerScroll(...args))
+            },
+            [
+              _ctx.columns.length ? (_openBlock(), _createElementBlock(
+                "table",
+                {
+                  key: 0,
+                  class: _normalizeClass(_ctx.n("table")),
+                  style: _normalizeStyle(_ctx.tableStyle)
+                },
+                [
+                  _createElementVNode("colgroup", null, [
+                    (_openBlock(true), _createElementBlock(
+                      _Fragment,
+                      null,
+                      _renderList(_ctx.columns, (column, index) => {
+                        var _a, _b;
+                        return _openBlock(), _createElementBlock(
+                          "col",
+                          {
+                            key: (_b = (_a = column.key) != null ? _a : column.type) != null ? _b : index,
+                            style: _normalizeStyle(_ctx.getColStyle(column, index))
+                          },
+                          null,
+                          4
+                          /* STYLE */
+                        );
+                      }),
+                      128
+                      /* KEYED_FRAGMENT */
+                    ))
+                  ]),
+                  _createElementVNode("thead", null, [
+                    (_openBlock(true), _createElementBlock(
+                      _Fragment,
+                      null,
+                      _renderList(_ctx.headerRows, (headerRow, rowIndex) => {
+                        return _openBlock(), _createElementBlock(
+                          "tr",
+                          {
+                            key: rowIndex,
+                            class: _normalizeClass(_ctx.n("header-row"))
+                          },
+                          [
+                            (_openBlock(true), _createElementBlock(
+                              _Fragment,
+                              null,
+                              _renderList(headerRow, (headerCell) => {
+                                return _openBlock(), _createBlock(_component_data_table_header_cell, {
+                                  key: headerCell.key,
+                                  "header-cell": headerCell,
+                                  style: _normalizeStyle(_ctx.getHeaderCellStyle(headerCell)),
+                                  "all-current-rows-selected": _ctx.allCurrentRowsSelected,
+                                  "some-current-rows-selected": _ctx.someCurrentRowsSelected,
+                                  "has-selectable-rows": !!_ctx.currentSelectableRows.length,
+                                  "is-selection-column": _ctx.isSelectionColumn,
+                                  "is-expand-column": _ctx.isExpandColumn,
+                                  "is-multiple-selection-column": _ctx.isMultipleSelectionColumn,
+                                  "is-selection-column-selectable": _ctx.isSelectionColumnSelectable,
+                                  "is-column-sortable": _ctx.isColumnSortable,
+                                  "get-column-sorter-order": _ctx.getColumnSorterOrder,
+                                  "is-column-resizable": _ctx.isColumnResizable,
+                                  "is-last-header-column": _ctx.isLastHeaderColumn,
+                                  "should-render-left-fixed-shadow": _ctx.shouldRenderLeftFixedShadow,
+                                  "should-render-right-fixed-shadow": _ctx.shouldRenderRightFixedShadow,
+                                  "toggle-column-sorter": _ctx.toggleColumnSorter,
+                                  "toggle-current-selectable-rows": _ctx.toggleCurrentSelectableRows,
+                                  "start-column-resize": _ctx.startColumnResize
+                                }, null, 8, ["header-cell", "style", "all-current-rows-selected", "some-current-rows-selected", "has-selectable-rows", "is-selection-column", "is-expand-column", "is-multiple-selection-column", "is-selection-column-selectable", "is-column-sortable", "get-column-sorter-order", "is-column-resizable", "is-last-header-column", "should-render-left-fixed-shadow", "should-render-right-fixed-shadow", "toggle-column-sorter", "toggle-current-selectable-rows", "start-column-resize"]);
+                              }),
+                              128
+                              /* KEYED_FRAGMENT */
+                            ))
+                          ],
+                          2
+                          /* CLASS */
+                        );
+                      }),
+                      128
+                      /* KEYED_FRAGMENT */
+                    ))
+                  ]),
+                  _ctx.bodyRows.length ? (_openBlock(), _createElementBlock("tbody", _hoisted_1, [
+                    (_openBlock(true), _createElementBlock(
+                      _Fragment,
+                      null,
+                      _renderList(_ctx.bodyRows, (bodyRow) => {
+                        return _openBlock(), _createElementBlock(
+                          _Fragment,
+                          {
+                            key: bodyRow.key
+                          },
+                          [
+                            _createElementVNode(
+                              "tr",
+                              _mergeProps({
+                                class: _ctx.classes(_ctx.n("row"), _ctx.getRowClass(bodyRow))
+                              }, { ref_for: true }, _ctx.getRowProps(bodyRow)),
+                              [
+                                (_openBlock(true), _createElementBlock(
+                                  _Fragment,
+                                  null,
+                                  _renderList(bodyRow.cells, (cell) => {
+                                    return _openBlock(), _createBlock(_component_data_table_body_cell, {
+                                      key: cell.key,
+                                      "body-row": bodyRow,
+                                      cell,
+                                      style: _normalizeStyle(_ctx.getBodyCellStyle(cell)),
+                                      tree: _ctx.tree,
+                                      "is-selection-column": _ctx.isSelectionColumn,
+                                      "is-expand-column": _ctx.isExpandColumn,
+                                      "is-multiple-selection-column": _ctx.isMultipleSelectionColumn,
+                                      "is-selection-column-selectable": _ctx.isSelectionColumnSelectable,
+                                      "is-row-selectable": _ctx.isRowSelectable,
+                                      "is-row-key-selected": _ctx.isRowKeySelected,
+                                      "is-row-key-indeterminate": _ctx.isRowKeyIndeterminate,
+                                      "is-row-expandable": _ctx.isRowExpandable,
+                                      "should-render-left-fixed-shadow": _ctx.shouldRenderLeftFixedShadow,
+                                      "should-render-right-fixed-shadow": _ctx.shouldRenderRightFixedShadow,
+                                      "toggle-row-selection": _ctx.toggleRowSelection,
+                                      "toggle-row-expanded": _ctx.toggleRowExpanded,
+                                      "toggle-tree-row-expanded": _ctx.toggleTreeRowExpanded,
+                                      "render-cell": _ctx.renderCell,
+                                      "get-cell-props": _ctx.getCellProps
+                                    }, null, 8, ["body-row", "cell", "style", "tree", "is-selection-column", "is-expand-column", "is-multiple-selection-column", "is-selection-column-selectable", "is-row-selectable", "is-row-key-selected", "is-row-key-indeterminate", "is-row-expandable", "should-render-left-fixed-shadow", "should-render-right-fixed-shadow", "toggle-row-selection", "toggle-row-expanded", "toggle-tree-row-expanded", "render-cell", "get-cell-props"]);
+                                  }),
+                                  128
+                                  /* KEYED_FRAGMENT */
+                                ))
+                              ],
+                              16
+                              /* FULL_PROPS */
+                            ),
+                            bodyRow.expanded ? (_openBlock(), _createElementBlock(
+                              "tr",
+                              {
+                                key: 0,
+                                class: _normalizeClass(_ctx.n("expanded-row"))
+                              },
+                              [
+                                _createElementVNode("td", {
+                                  class: _normalizeClass(_ctx.classes(_ctx.n("cell"), _ctx.n("body-cell"), _ctx.n("expanded-cell"))),
+                                  colspan: _ctx.columns.length
+                                }, [
+                                  _createElementVNode(
+                                    "div",
+                                    {
+                                      class: _normalizeClass(_ctx.n("expanded-content"))
+                                    },
+                                    [
+                                      _createVNode(_component_maybe_v_node, {
+                                        is: _ctx.renderExpandedRow(bodyRow),
+                                        tag: "div"
+                                      }, null, 8, ["is"])
+                                    ],
+                                    2
+                                    /* CLASS */
+                                  )
+                                ], 10, _hoisted_2)
+                              ],
+                              2
+                              /* CLASS */
+                            )) : _createCommentVNode("v-if", true)
+                          ],
+                          64
+                          /* STABLE_FRAGMENT */
+                        );
+                      }),
+                      128
+                      /* KEYED_FRAGMENT */
+                    ))
+                  ])) : _createCommentVNode("v-if", true),
+                  _ctx.footRows.length ? (_openBlock(), _createElementBlock("tfoot", _hoisted_3, [
+                    (_openBlock(true), _createElementBlock(
+                      _Fragment,
+                      null,
+                      _renderList(_ctx.footRows, (footRow, rowIndex) => {
+                        return _openBlock(), _createElementBlock(
+                          "tr",
+                          {
+                            key: rowIndex,
+                            class: _normalizeClass(_ctx.n("summary-row"))
+                          },
+                          [
+                            (_openBlock(true), _createElementBlock(
+                              _Fragment,
+                              null,
+                              _renderList(footRow, (cell) => {
+                                return _openBlock(), _createElementBlock("td", {
+                                  key: cell.key,
+                                  class: _normalizeClass(
+                                    _ctx.classes(
+                                      _ctx.n("cell"),
+                                      _ctx.n("summary-cell"),
+                                      [cell.column.fixed, _ctx.n("fixed-cell")],
+                                      [_ctx.shouldRenderLeftFixedShadow(cell.columnIndex), _ctx.n("fixed-cell--shadow-right")],
+                                      [_ctx.shouldRenderRightFixedShadow(cell.columnIndex), _ctx.n("fixed-cell--shadow-left")]
+                                    )
+                                  ),
+                                  style: _normalizeStyle(_ctx.getBodyCellStyle(cell)),
+                                  colspan: cell.colSpan,
+                                  rowspan: cell.rowSpan
+                                }, [
+                                  _createVNode(_component_maybe_v_node, {
+                                    is: cell.value,
+                                    tag: "div"
+                                  }, null, 8, ["is"])
+                                ], 14, _hoisted_4);
+                              }),
+                              128
+                              /* KEYED_FRAGMENT */
+                            ))
+                          ],
+                          2
+                          /* CLASS */
+                        );
+                      }),
+                      128
+                      /* KEYED_FRAGMENT */
+                    ))
+                  ])) : _createCommentVNode("v-if", true)
+                ],
+                6
+                /* CLASS, STYLE */
+              )) : _createCommentVNode("v-if", true),
+              !_ctx.bodyRows.length ? (_openBlock(), _createElementBlock(
+                "div",
+                {
+                  key: 1,
+                  class: _normalizeClass(_ctx.n("empty"))
+                },
+                [
+                  _renderSlot(_ctx.$slots, "empty", {}, () => [
+                    _createTextVNode(
+                      _toDisplayString((_ctx.pt ? _ctx.pt : _ctx.t)("dataTableEmptyText")),
+                      1
+                      /* TEXT */
+                    )
+                  ])
+                ],
+                2
+                /* CLASS */
+              )) : _createCommentVNode("v-if", true)
+            ],
+            38
+            /* CLASS, STYLE, NEED_HYDRATION */
+          ),
+          _ctx.showPagination ? (_openBlock(), _createElementBlock(
+            "div",
+            {
+              key: 0,
+              class: _normalizeClass(_ctx.n("footer"))
+            },
+            [
+              _renderSlot(_ctx.$slots, "footer-prefix"),
+              _createVNode(_component_var_pagination, {
+                "var-data-table-cover": "",
+                current: _ctx.normalizedPage,
+                size: _ctx.pageSize,
+                total: _ctx.paginationTotal,
+                simple: _ctx.paginationProps.simple,
+                disabled: _ctx.paginationProps.disabled,
+                "show-size-changer": _ctx.paginationProps.showSizeChanger,
+                "show-quick-jumper": _ctx.paginationProps.showQuickJumper,
+                "max-pager-count": _ctx.paginationProps.maxPagerCount,
+                "size-option": _ctx.paginationProps.sizeOption,
+                "show-total": _ctx.paginationProps.showTotal,
+                onChange: _ctx.handlePaginationChange
+              }, null, 8, ["current", "size", "total", "simple", "disabled", "show-size-changer", "show-quick-jumper", "max-pager-count", "size-option", "show-total", "onChange"])
+            ],
+            2
+            /* CLASS */
+          )) : _createCommentVNode("v-if", true)
+        ]),
+        _: 2
+        /* DYNAMIC */
+      }, [
+        _ctx.$slots["loading-description"] ? {
+          name: "description",
+          fn: _withCtx(() => [
+            _renderSlot(_ctx.$slots, "loading-description")
+          ]),
+          key: "0"
+        } : void 0
+      ]), 1032, ["loading"])
+    ],
+    2
+    /* CLASS */
+  );
+}
+const __sfc__ = defineComponent({
+  name,
+  components: {
+    DataTableBodyCell: DataTableBodyCellComponent,
+    DataTableHeaderCell: DataTableHeaderCellComponent,
+    VarLoading,
+    VarPagination,
+    MaybeVNode
+  },
+  props,
+  setup(props2) {
+    const { t: pt } = injectLocaleProvider();
+    const checkedRowKeys = useVModel(props2, "checkedRowKeys");
+    const expandedRowKeys = useVModel(props2, "expandedRowKeys");
+    const expandedTreeRowKeys = useVModel(props2, "expandedTreeRowKeys");
+    const page = useVModel(props2, "page");
+    const pageSize = useVModel(props2, "pageSize");
+    const { collapsedTreeRowKeys, toggleTreeRowExpanded } = useTreeExpand({
+      tree: () => props2.tree,
+      data: () => props2.data,
+      expandedTreeRowKeys,
+      getRowKey,
+      getTreeChildren
+    });
+    const { normalizedColumns: columns, headerRows } = useHeaderRows({
+      columns: () => props2.columns
+    });
+    const {
+      hasResolvedColumnWidth,
+      resolvedColumnWidths,
+      totalResolvedColumnWidth,
+      getColStyle,
+      isColumnResizable,
+      startColumnResize
+    } = useColumnSizes({
+      columns: () => columns.value,
+      isSelectionColumn,
+      isExpandColumn
+    });
+    const containerStyle = computed(() => {
+      const style = {};
+      if (props2.maxHeight != null) {
+        style.maxHeight = toSizeUnit(props2.maxHeight);
+        style.overflow = "auto";
+      }
+      style.overflowX = "auto";
+      return style;
+    });
+    const tableStyle = computed(() => {
+      const style = {
+        width: "100%",
+        tableLayout: hasResolvedColumnWidth.value ? "fixed" : props2.tableLayout
+      };
+      if (props2.scrollX != null) {
+        const width = toSizeUnit(props2.scrollX);
+        style.width = width;
+        style.minWidth = width;
+        return style;
+      }
+      if (hasResolvedColumnWidth.value) {
+        style.minWidth = toSizeUnit(totalResolvedColumnWidth.value);
+      }
+      return style;
+    });
+    const { getFixedStyle, isFirstRightFixedColumn, isLastLeftFixedColumn } = useColumnsFixedOffsets({
+      columns: () => columns.value,
+      resolvedColumnWidths: () => resolvedColumnWidths.value
+    });
+    const { getColumnSorterOrder, isColumnSortable, toggleColumnSorter } = useSorter({
+      sorters: () => props2.sorters,
+      sortMode: () => props2.sortMode,
+      onUpdateSorters: () => props2["onUpdate:sorters"]
+    });
+    const { paginationProps, paginationTotal, showPagination, normalizedPage, pagedData } = usePagination({
+      pagination: () => props2.pagination,
+      remote: () => props2.remote,
+      loading: () => props2.loading,
+      page: () => page.value,
+      pageSize: () => pageSize.value,
+      total: () => props2.total,
+      data: () => props2.data,
+      onUpdatePage: () => (nextPage) => {
+        page.value = nextPage;
+      }
+    });
+    const firstTreeColumnIndex = computed(
+      () => columns.value.findIndex((column) => !isSelectionColumn(column) && !isExpandColumn(column))
+    );
+    const { expandedRowKeySet, isRowExpandable, toggleRowExpanded, renderExpandedRow } = useExpandRow({
+      columns: () => columns.value,
+      expandedRowKeys,
+      isExpandColumn
+    });
+    const { allFlatRows, treeRowMeta, bodyRows } = useBodyRows({
+      collapsedTreeRowKeys,
+      expandedRowKeySet,
+      firstTreeColumnIndex,
+      getRowKey,
+      getTreeChildren,
+      columns: () => columns.value,
+      sourceRows: () => pagedData.value,
+      tree: () => props2.tree
+    });
+    const { footRows } = useFootRows({
+      columns: () => columns.value,
+      sourceRows: () => pagedData.value,
+      summary: () => props2.summary
+    });
+    const { container, scrollLeft, maxScrollDistance, handleContainerScroll } = useContainerScroll([
+      columns,
+      bodyRows,
+      footRows,
+      totalResolvedColumnWidth,
+      () => props2.scrollX
+    ]);
+    const {
+      currentSelectableRows,
+      allCurrentRowsSelected,
+      someCurrentRowsSelected,
+      isMultipleSelectionColumn,
+      isSelectionColumnSelectable,
+      isRowSelectable,
+      isRowKeySelected,
+      isRowKeyIndeterminate,
+      toggleRowSelection,
+      toggleCurrentSelectableRows
+    } = useSelectionColumn({
+      checkedRowKeys,
+      isSelectionColumn,
+      getTreeChildren,
+      columns: () => columns.value,
+      tree: () => props2.tree,
+      cascade: () => props2.cascade,
+      pagedData: () => pagedData.value,
+      allFlatRows: () => allFlatRows.value,
+      treeRowMeta: () => treeRowMeta.value
+    });
+    function getRowKey(row, rowIndex) {
+      var _a;
+      if (isFunction(props2.rowKey)) {
+        return props2.rowKey({ row, rowIndex });
+      }
+      return (_a = row[props2.rowKey]) != null ? _a : rowIndex;
+    }
+    function getTreeChildren(row) {
+      const children = row[props2.childrenKey];
+      return isArray(children) ? children : [];
+    }
+    function isSelectionColumn(column) {
+      return column.type === "selection";
+    }
+    function isExpandColumn(column) {
+      return column.type === "expand";
+    }
+    function renderCell(bodyRow, column) {
+      if (isSelectionColumn(column) || isExpandColumn(column)) {
+        return;
+      }
+      if (column.render) {
+        return column.render({
+          row: bodyRow.row,
+          rowIndex: bodyRow.rowIndex
+        });
+      }
+      return bodyRow.row[column.key];
+    }
+    function getRowProps(bodyRow) {
+      if (!props2.rowProps) {
+        return;
+      }
+      return callOrReturn(props2.rowProps, {
+        row: bodyRow.row,
+        rowIndex: bodyRow.rowIndex
+      });
+    }
+    function getRowClass(bodyRow) {
+      if (!props2.rowClass) {
+        return;
+      }
+      return callOrReturn(props2.rowClass, {
+        row: bodyRow.row,
+        rowIndex: bodyRow.rowIndex
+      });
+    }
+    function getCellProps(bodyRow, column) {
+      if (!column.cellProps) {
+        return;
+      }
+      return callOrReturn(column.cellProps, {
+        row: bodyRow.row,
+        rowIndex: bodyRow.rowIndex
+      });
+    }
+    function getAlign(align) {
+      return align != null ? align : "left";
+    }
+    function isLastHeaderColumn(columnIndex) {
+      return columnIndex === columns.value.length - 1;
+    }
+    function shouldRenderLeftFixedShadow(columnIndex) {
+      return scrollLeft.value > 1 && isLastLeftFixedColumn(columnIndex);
+    }
+    function shouldRenderRightFixedShadow(columnIndex) {
+      return scrollLeft.value < maxScrollDistance.value - 1 && isFirstRightFixedColumn(columnIndex);
+    }
+    function getHeaderCellStyle(cell) {
+      var _a;
+      return __spreadProps(__spreadValues({
+        textAlign: getAlign((_a = cell.column.titleAlign) != null ? _a : cell.column.align)
+      }, getFixedStyle(cell.fixed, cell.startLeafColumnIndex)), {
+        zIndex: cell.fixed ? 3 : 2
+      });
+    }
+    function getBodyCellStyle(cell) {
+      return __spreadProps(__spreadValues({
+        textAlign: getAlign(cell.column.align)
+      }, getFixedStyle(cell.column.fixed, cell.columnIndex)), {
+        zIndex: cell.column.fixed ? 1 : void 0
+      });
+    }
+    function handlePaginationChange(nextPage, nextPageSize) {
+      page.value = nextPage;
+      pageSize.value = nextPageSize;
+    }
+    return {
+      pt,
+      t,
+      container,
+      expandedRowKeys,
+      containerStyle,
+      paginationProps,
+      paginationTotal,
+      showPagination,
+      normalizedPage,
+      pageSize,
+      tableStyle,
+      columns,
+      currentSelectableRows,
+      allCurrentRowsSelected,
+      someCurrentRowsSelected,
+      headerRows,
+      bodyRows,
+      footRows,
+      isColumnResizable,
+      getRowProps,
+      getRowClass,
+      getCellProps,
+      isSelectionColumn,
+      isExpandColumn,
+      isColumnSortable,
+      isMultipleSelectionColumn,
+      isSelectionColumnSelectable,
+      getColumnSorterOrder,
+      isRowExpandable,
+      isRowKeyIndeterminate,
+      isRowKeySelected,
+      isRowSelectable,
+      shouldRenderLeftFixedShadow,
+      shouldRenderRightFixedShadow,
+      toggleColumnSorter,
+      toggleCurrentSelectableRows,
+      toggleRowExpanded,
+      toggleTreeRowExpanded,
+      toggleRowSelection,
+      renderCell,
+      renderExpandedRow,
+      getColStyle,
+      getHeaderCellStyle,
+      getBodyCellStyle,
+      handlePaginationChange,
+      handleContainerScroll,
+      isLastHeaderColumn,
+      startColumnResize,
+      n,
+      classes,
+      formatElevation,
+      toSizeUnit
+    };
+  }
+});
+__sfc__.render = __render__;
+var stdin_default = __sfc__;
+export {
+  stdin_default as default
+};