jky-component-lib 0.0.56 → 0.0.61

package/dist/lib/page-table/PageTable.vue.js

@@ -0,0 +1,374 @@
+"use strict";
+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));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const ElementPlus = require("element-plus");
+const index = require("../form/index.js");
+const Toolbar_vue_vue_type_script_setup_true_lang = require("./Toolbar.vue.js");
+;/* empty css              */
+const _hoisted_1 = { class: "jky-page-table__filter-actions" };
+const _hoisted_2 = {
+  key: 0,
+  class: "flex flex-end mt-4 jky-page-table__pagination"
+};
+const _sfc_main = /* @__PURE__ */ vue.defineComponent(__spreadProps(__spreadValues({}, {
+  name: "JkyPageTable"
+}), {
+  __name: "PageTable",
+  props: {
+    title: { default: "" },
+    filterItems: { default: () => [] },
+    filterModel: { default: () => ({}) },
+    columns: {},
+    dataSource: {},
+    showSearchButton: { type: Boolean, default: true },
+    searchText: { default: "查询" },
+    resetText: { default: "重置" },
+    selection: { type: Boolean, default: false },
+    selectedRows: { default: () => [] },
+    pagination: {},
+    border: { type: Boolean, default: true },
+    stripe: { type: Boolean, default: false },
+    height: {},
+    maxHeight: {},
+    emptyText: { default: "暂无数据" },
+    loading: { type: Boolean, default: false },
+    className: { default: "" },
+    formProps: { default: () => ({}) },
+    tableProps: { default: () => ({}) },
+    paginationProps: { default: () => ({}) },
+    toolbarButtonLimit: { default: 0 },
+    toolbarButtons: {}
+  },
+  emits: ["search", "reset", "rowClick", "rowDblclick", "selectionChange", "pageChange", "sortChange"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    var _a, _b, _c;
+    const props = __props;
+    const emit = __emit;
+    const internalFilterModel = vue.ref(__spreadValues({}, props.filterModel));
+    const internalData = vue.ref([]);
+    const internalPagination = vue.ref({
+      currentPage: ((_a = props.pagination) == null ? void 0 : _a.currentPage) || 1,
+      pageSize: ((_b = props.pagination) == null ? void 0 : _b.pageSize) || 10,
+      total: ((_c = props.pagination) == null ? void 0 : _c.total) || 0
+    });
+    const tableRef = vue.ref(null);
+    const formRef = vue.ref(null);
+    const paginationRef = vue.ref(null);
+    const isLoading = vue.ref(props.loading);
+    const showPagination = vue.computed(() => {
+      var _a2;
+      return !!((_a2 = props.dataSource) == null ? void 0 : _a2.api);
+    });
+    function getColumnProps(column) {
+      return __spreadValues({}, column);
+    }
+    vue.watch(
+      () => props.pagination,
+      (newPagination) => {
+        if (newPagination) {
+          internalPagination.value.currentPage = newPagination.currentPage || 1;
+          internalPagination.value.pageSize = newPagination.pageSize || 10;
+          internalPagination.value.total = newPagination.total || 0;
+        }
+      },
+      { deep: true }
+    );
+    function loadData() {
+      return __async(this, null, function* () {
+        var _a2;
+        if (!((_a2 = props.dataSource) == null ? void 0 : _a2.api))
+          return;
+        isLoading.value = true;
+        try {
+          const result = yield props.dataSource.api(__spreadValues({
+            currentPage: internalPagination.value.currentPage,
+            pageSize: internalPagination.value.pageSize
+          }, internalFilterModel.value));
+          const responseProps = props.dataSource.responseProps || {};
+          const recordsField = responseProps.recordsField || "records";
+          const totalField = responseProps.totalField || "total";
+          internalData.value = result[recordsField] || [];
+          internalPagination.value.total = result[totalField] || 0;
+          emit("pageChange", {
+            currentPage: internalPagination.value.currentPage,
+            pageSize: internalPagination.value.pageSize
+          });
+        } catch (error) {
+          console.error("加载数据失败:", error);
+          internalData.value = [];
+          internalPagination.value.total = 0;
+        } finally {
+          isLoading.value = false;
+        }
+      });
+    }
+    function handleSearch() {
+      var _a2;
+      emit("search", __spreadValues({}, internalFilterModel.value));
+      if ((_a2 = props.dataSource) == null ? void 0 : _a2.api) {
+        internalPagination.value.currentPage = 1;
+        loadData();
+      }
+    }
+    function handleReset() {
+      var _a2;
+      internalFilterModel.value = {};
+      emit("reset");
+      if (formRef.value) {
+        formRef.value.resetFields();
+      }
+      if ((_a2 = props.dataSource) == null ? void 0 : _a2.api) {
+        internalPagination.value.currentPage = 1;
+        loadData();
+      }
+    }
+    function handlePageChange(page) {
+      var _a2, _b2;
+      internalPagination.value.currentPage = page;
+      if ((_a2 = props.dataSource) == null ? void 0 : _a2.api) {
+        loadData();
+      } else if ((_b2 = props.pagination) == null ? void 0 : _b2.onPageChange) {
+        props.pagination.onPageChange(page);
+      }
+      emit("pageChange", {
+        currentPage: internalPagination.value.currentPage,
+        pageSize: internalPagination.value.pageSize
+      });
+    }
+    function handlePageSizeChange(size) {
+      var _a2, _b2;
+      internalPagination.value.pageSize = size;
+      internalPagination.value.currentPage = 1;
+      if ((_a2 = props.dataSource) == null ? void 0 : _a2.api) {
+        loadData();
+      } else if ((_b2 = props.pagination) == null ? void 0 : _b2.onPageSizeChange) {
+        props.pagination.onPageSizeChange(size);
+      }
+      emit("pageChange", {
+        currentPage: internalPagination.value.currentPage,
+        pageSize: internalPagination.value.pageSize
+      });
+    }
+    const selectedCount = vue.ref(0);
+    function handleSelectionChange(selection) {
+      selectedCount.value = selection.length;
+      emit("selectionChange", selection);
+    }
+    function handleRowClick(row, column) {
+      emit("rowClick", row, column);
+    }
+    function handleRowDblclick(row, column) {
+      emit("rowDblclick", row, column);
+    }
+    function handleSortChange({ column, prop, order }) {
+      emit("sortChange", { column, prop, order });
+    }
+    __expose({
+      refresh: loadData,
+      getFilterData: () => __spreadValues({}, internalFilterModel.value),
+      setFilterData: (data) => {
+        internalFilterModel.value = __spreadValues({}, data);
+      },
+      resetFilter: handleReset,
+      getSelectedRows: () => {
+        var _a2;
+        return ((_a2 = tableRef.value) == null ? void 0 : _a2.getSelectionRows()) || [];
+      },
+      clearSelection: () => {
+        var _a2;
+        (_a2 = tableRef.value) == null ? void 0 : _a2.clearSelection();
+      },
+      toggleRowSelection: (row, selected) => {
+        var _a2;
+        (_a2 = tableRef.value) == null ? void 0 : _a2.toggleRowSelection(row, selected);
+      },
+      sort: (prop, order) => {
+        var _a2;
+        (_a2 = tableRef.value) == null ? void 0 : _a2.sort(prop, order);
+      },
+      formRef,
+      tableRef,
+      paginationRef
+    });
+    vue.onMounted(() => {
+      var _a2;
+      if ((_a2 = props.dataSource) == null ? void 0 : _a2.api) {
+        loadData();
+      }
+    });
+    return (_ctx, _cache) => {
+      const _component_ElButton = vue.resolveComponent("ElButton");
+      const _directive_loading = vue.resolveDirective("loading");
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(["bg-transparent jky-page-table", [__props.className]])
+      }, [
+        __props.filterItems && __props.filterItems.length > 0 ? (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElCard), {
+          key: 0,
+          class: "mb-4 jky-page-table__filter-card"
+        }, {
+          default: vue.withCtx(() => [
+            vue.createVNode(vue.unref(index.JkyForm), vue.mergeProps({
+              ref_key: "formRef",
+              ref: formRef,
+              modelValue: internalFilterModel.value,
+              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => internalFilterModel.value = $event),
+              items: __props.filterItems,
+              inline: true,
+              disabled: isLoading.value
+            }, __props.formProps), null, 16, ["modelValue", "items", "disabled"]),
+            vue.createElementVNode("div", _hoisted_1, [
+              vue.createVNode(_component_ElButton, {
+                type: "primary",
+                loading: isLoading.value,
+                onClick: handleSearch
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createTextVNode(vue.toDisplayString(__props.searchText), 1)
+                ]),
+                _: 1
+              }, 8, ["loading"]),
+              vue.createVNode(_component_ElButton, { onClick: handleReset }, {
+                default: vue.withCtx(() => [
+                  vue.createTextVNode(vue.toDisplayString(__props.resetText), 1)
+                ]),
+                _: 1
+              })
+            ])
+          ]),
+          _: 1
+        })) : vue.createCommentVNode("", true),
+        vue.createVNode(vue.unref(ElementPlus.ElCard), { class: "jky-page-table__table-card" }, {
+          default: vue.withCtx(() => {
+            var _a2, _b2, _c2, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+            return [
+              vue.createVNode(Toolbar_vue_vue_type_script_setup_true_lang.default, {
+                "left-buttons": ((_a2 = props.toolbarButtons) == null ? void 0 : _a2.left) || [],
+                "batch-buttons": ((_b2 = props.toolbarButtons) == null ? void 0 : _b2.batch) || [],
+                "right-buttons": ((_c2 = props.toolbarButtons) == null ? void 0 : _c2.right) || [],
+                "selected-count": selectedCount.value,
+                "toolbar-button-limit": __props.toolbarButtonLimit,
+                payload: {
+                  currentPage: internalPagination.value.currentPage,
+                  pageSize: internalPagination.value.pageSize,
+                  total: internalPagination.value.total,
+                  tableData: internalData.value,
+                  selectedRows: ((_d = tableRef.value) == null ? void 0 : _d.getSelectionRows()) || [],
+                  filterData: __spreadValues({}, internalFilterModel.value)
+                }
+              }, null, 8, ["left-buttons", "batch-buttons", "right-buttons", "selected-count", "toolbar-button-limit", "payload"]),
+              vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElTable), vue.mergeProps({
+                ref_key: "tableRef",
+                ref: tableRef,
+                data: internalData.value,
+                border: __props.border,
+                stripe: __props.stripe,
+                height: __props.height,
+                "max-height": __props.maxHeight,
+                "empty-text": __props.emptyText
+              }, __props.tableProps, {
+                onSelectionChange: handleSelectionChange,
+                onRowClick: handleRowClick,
+                onRowDblclick: handleRowDblclick,
+                onSortChange: handleSortChange
+              }), {
+                default: vue.withCtx(() => [
+                  __props.selection ? (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElTableColumn), {
+                    key: 0,
+                    type: "selection",
+                    width: "55",
+                    align: "center"
+                  })) : vue.createCommentVNode("", true),
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.columns, (column) => {
+                    return vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElTableColumn), vue.mergeProps({
+                      key: column.prop
+                    }, { ref_for: true }, getColumnProps(column)), {
+                      default: vue.withCtx((scope) => [
+                        vue.renderSlot(_ctx.$slots, `column-${column.prop}`, {
+                          row: scope.row,
+                          column: scope.column,
+                          index: scope.$index
+                        }, () => {
+                          var _a3;
+                          return [
+                            column.render ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent((_a3 = column.render) == null ? void 0 : _a3.call(column, scope)), { key: 0 })) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+                              vue.createTextVNode(vue.toDisplayString(column.formatter ? column.formatter(scope.row, scope.column, scope.row[column.prop], scope.$index) : scope.row[column.prop]), 1)
+                            ], 64))
+                          ];
+                        })
+                      ]),
+                      _: 2
+                    }, 1040);
+                  }), 128)),
+                  vue.renderSlot(_ctx.$slots, "columns")
+                ]),
+                _: 3
+              }, 16, ["data", "border", "stripe", "height", "max-height", "empty-text"])), [
+                [_directive_loading, isLoading.value]
+              ]),
+              showPagination.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
+                vue.createVNode(vue.unref(ElementPlus.ElPagination), vue.mergeProps({
+                  ref_key: "paginationRef",
+                  ref: paginationRef,
+                  "current-page": internalPagination.value.currentPage,
+                  "onUpdate:currentPage": _cache[1] || (_cache[1] = ($event) => internalPagination.value.currentPage = $event),
+                  "page-size": internalPagination.value.pageSize,
+                  "onUpdate:pageSize": _cache[2] || (_cache[2] = ($event) => internalPagination.value.pageSize = $event),
+                  total: internalPagination.value.total,
+                  "page-sizes": ((_e = __props.pagination) == null ? void 0 : _e.pageSizes) || [10, 20, 50, 100],
+                  layout: ((_f = __props.pagination) == null ? void 0 : _f.layout) || "total, sizes, prev, pager, next, jumper",
+                  "show-size-picker": (_h = (_g = __props.pagination) == null ? void 0 : _g.showSizePicker) != null ? _h : true,
+                  "show-total": (_j = (_i = __props.pagination) == null ? void 0 : _i.showTotal) != null ? _j : true,
+                  "show-jumper": (_l = (_k = __props.pagination) == null ? void 0 : _k.showJumper) != null ? _l : true
+                }, __props.paginationProps, {
+                  onSizeChange: handlePageSizeChange,
+                  onCurrentChange: handlePageChange
+                }), null, 16, ["current-page", "page-size", "total", "page-sizes", "layout", "show-size-picker", "show-total", "show-jumper"])
+              ])) : vue.createCommentVNode("", true)
+            ];
+          }),
+          _: 3
+        })
+      ], 2);
+    };
+  }
+}));
+exports.default = _sfc_main;

package/dist/lib/page-table/PageTable.vue3.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const PageTable_vue_vue_type_script_setup_true_lang = require("./PageTable.vue.js");
+;/* empty css                */
+exports.default = PageTable_vue_vue_type_script_setup_true_lang.default;

package/dist/lib/page-table/Toolbar.vue.d.ts

@@ -0,0 +1,32 @@
+import { ToolbarButtonConfig, ToolbarProps } from './types';
+declare function handleBatchCommand(index: number): void;
+declare function handleRightCommand(index: number): void;
+declare const _default: import('vue').DefineComponent<ToolbarProps, {
+    handleBatchCommand: typeof handleBatchCommand;
+    handleRightCommand: typeof handleRightCommand;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    batchCommand: (index: number) => any;
+    buttonClick: (button: ToolbarButtonConfig) => any;
+    rightCommand: (index: number) => any;
+}, string, import('vue').PublicProps, Readonly<ToolbarProps> & Readonly<{
+    onBatchCommand?: ((index: number) => any) | undefined;
+    onButtonClick?: ((button: ToolbarButtonConfig) => any) | undefined;
+    onRightCommand?: ((index: number) => any) | undefined;
+}>, {
+    leftButtons: ToolbarButtonConfig[];
+    batchButtons: ToolbarButtonConfig[];
+    rightButtons: ToolbarButtonConfig[];
+    selectedCount: number;
+    toolbarButtonLimit: number;
+    payload: {
+        currentPage: number;
+        pageSize: number;
+        total: number;
+        tableData: any[];
+        selectedRows: any[];
+        filterData: Record<string, any>;
+    };
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    toolbarRightRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/lib/page-table/Toolbar.vue.js

@@ -0,0 +1,268 @@
+"use strict";
+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));
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const index = require("../node_modules/@element-plus/icons-vue/dist/index.js");
+const ElementPlus = require("element-plus");
+const responsiveToolbar = require("../utils/responsive-toolbar.js");
+const _hoisted_1 = { class: "flex items-center justify-between mb-2 py-2 jky-page-table__toolbar" };
+const _hoisted_2 = { class: "flex items-center" };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent(__spreadProps(__spreadValues({}, {
+  name: "JkyPageTableToolbar"
+}), {
+  __name: "Toolbar",
+  props: {
+    leftButtons: { default: () => [] },
+    batchButtons: { default: () => [] },
+    rightButtons: { default: () => [] },
+    selectedCount: { default: 0 },
+    toolbarButtonLimit: { default: 0 },
+    payload: { default: () => ({
+      currentPage: 1,
+      pageSize: 10,
+      total: 0,
+      tableData: [],
+      selectedRows: [],
+      filterData: {}
+    }) }
+  },
+  emits: ["batchCommand", "rightCommand", "buttonClick"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const toolbarRightRef = vue.ref(null);
+    const {
+      visibleCount: visibleRightCount,
+      needCollapse: needCollapseRight
+    } = responsiveToolbar.useResponsiveToolbar({
+      toolbarRef: toolbarRightRef,
+      buttonLimit: props.toolbarButtonLimit > 0 ? props.toolbarButtonLimit : void 0,
+      minVisibleButtons: 1,
+      widthPercentage: 0.5
+      // 右侧占 50%
+    });
+    const showBatchActions = vue.computed(() => {
+      return props.batchButtons && props.batchButtons.length > 0 && props.selectedCount && props.selectedCount > 0;
+    });
+    function getButtonPayload() {
+      return props.payload || {
+        currentPage: 1,
+        pageSize: 10,
+        total: 0,
+        tableData: [],
+        selectedRows: [],
+        filterData: {}
+      };
+    }
+    function handleToolbarButtonClick(button) {
+      emit("buttonClick", button);
+      if (button.onClick) {
+        button.onClick(getButtonPayload());
+      }
+    }
+    function handleBatchCommand(index2) {
+      var _a;
+      emit("batchCommand", index2);
+      const button = (_a = props.batchButtons) == null ? void 0 : _a[index2];
+      if (button && button.onClick) {
+        button.onClick(getButtonPayload());
+      }
+    }
+    function handleRightCommand(index2) {
+      var _a;
+      emit("rightCommand", index2);
+      const button = (_a = props.rightButtons) == null ? void 0 : _a[index2];
+      if (button && button.onClick) {
+        button.onClick(getButtonPayload());
+      }
+    }
+    function renderLeftButtons() {
+      const buttons = [];
+      if (props.leftButtons) {
+        props.leftButtons.forEach((button, index2) => {
+          buttons.push(
+            vue.h(
+              ElementPlus.ElButton,
+              {
+                key: index2,
+                type: button.type,
+                size: button.size,
+                disabled: button.disabled,
+                plain: button.plain,
+                class: button.className,
+                onClick: () => handleToolbarButtonClick(button)
+              },
+              { default: () => button.label }
+            )
+          );
+        });
+      }
+      return buttons;
+    }
+    function renderBatchDropdownItems() {
+      const items = [];
+      if (props.batchButtons) {
+        props.batchButtons.forEach((button, index2) => {
+          items.push(
+            vue.h(
+              ElementPlus.ElDropdownItem,
+              {
+                key: index2,
+                type: button.type,
+                disabled: button.disabled,
+                class: button.className,
+                command: index2
+              },
+              { default: () => button.label }
+            )
+          );
+        });
+      }
+      return items;
+    }
+    function renderRightButtons() {
+      const buttons = [];
+      if (props.rightButtons) {
+        props.rightButtons.forEach((button, index2) => {
+          const isVisible = index2 < visibleRightCount.value || !needCollapseRight.value;
+          if (isVisible) {
+            buttons.push(
+              vue.h(
+                ElementPlus.ElButton,
+                {
+                  key: index2,
+                  type: button.type,
+                  size: button.size,
+                  disabled: button.disabled,
+                  plain: button.plain,
+                  class: button.className,
+                  onClick: () => handleToolbarButtonClick(button)
+                },
+                { default: () => button.label }
+              )
+            );
+          }
+        });
+      }
+      return buttons;
+    }
+    function renderRightDropdownItems() {
+      const items = [];
+      if (props.rightButtons) {
+        props.rightButtons.slice(visibleRightCount.value).forEach((button, index2) => {
+          const originalIndex = visibleRightCount.value + index2;
+          items.push(
+            vue.h(
+              ElementPlus.ElDropdownItem,
+              {
+                key: originalIndex,
+                command: originalIndex
+              },
+              { default: () => button.label }
+            )
+          );
+        });
+      }
+      return items;
+    }
+    __expose({
+      handleBatchCommand,
+      handleRightCommand
+    });
+    return (_ctx, _cache) => {
+      const _component_ElIcon = vue.resolveComponent("ElIcon");
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+        vue.createElementVNode("div", _hoisted_2, [
+          (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(renderLeftButtons))),
+          showBatchActions.value ? (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElDropdown), {
+            key: 0,
+            onCommand: handleBatchCommand
+          }, {
+            dropdown: vue.withCtx(() => [
+              vue.createVNode(vue.unref(ElementPlus.ElDropdownMenu), null, {
+                default: vue.withCtx(() => [
+                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(renderBatchDropdownItems)))
+                ]),
+                _: 1
+              })
+            ]),
+            default: vue.withCtx(() => {
+              var _a;
+              return [
+                vue.createVNode(vue.unref(ElementPlus.ElButton), {
+                  type: "primary",
+                  class: vue.normalizeClass([((_a = props.leftButtons) == null ? void 0 : _a.length) ? "ml-3" : ""])
+                }, {
+                  suffix: vue.withCtx(() => [
+                    vue.createVNode(_component_ElIcon, { class: "text-white" }, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(index.ArrowDown))
+                      ]),
+                      _: 1
+                    })
+                  ]),
+                  default: vue.withCtx(() => [
+                    vue.createTextVNode(" 批量操作 (" + vue.toDisplayString(__props.selectedCount) + ") ", 1)
+                  ]),
+                  _: 1
+                }, 8, ["class"])
+              ];
+            }),
+            _: 1
+          })) : vue.createCommentVNode("", true)
+        ]),
+        vue.createElementVNode("div", {
+          ref_key: "toolbarRightRef",
+          ref: toolbarRightRef,
+          class: "flex items-center jky-page-table__toolbar-right"
+        }, [
+          (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(renderRightButtons))),
+          vue.unref(needCollapseRight) && __props.rightButtons && __props.rightButtons.length > vue.unref(visibleRightCount) ? (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElDropdown), {
+            key: 0,
+            onCommand: handleRightCommand
+          }, {
+            dropdown: vue.withCtx(() => [
+              vue.createVNode(vue.unref(ElementPlus.ElDropdownMenu), null, {
+                default: vue.withCtx(() => [
+                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(renderRightDropdownItems)))
+                ]),
+                _: 1
+              })
+            ]),
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(ElementPlus.ElButton), {
+                type: "primary",
+                class: "ml-3"
+              }, {
+                default: vue.withCtx(() => [..._cache[0] || (_cache[0] = [
+                  vue.createTextVNode(" 更多 ", -1)
+                ])]),
+                _: 1
+              })
+            ]),
+            _: 1
+          })) : vue.createCommentVNode("", true)
+        ], 512)
+      ]);
+    };
+  }
+}));
+exports.default = _sfc_main;

package/dist/lib/page-table/Toolbar.vue3.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Toolbar_vue_vue_type_script_setup_true_lang = require("./Toolbar.vue.js");
+;/* empty css              */
+exports.default = Toolbar_vue_vue_type_script_setup_true_lang.default;

package/dist/lib/page-table/index.d.ts

@@ -0,0 +1,4 @@
+import { InstallWithSFC } from '../utils/types';
+import { default as PageTable } from './PageTable.vue';
+export declare const JkyPageTable: InstallWithSFC<typeof PageTable>;
+export default JkyPageTable;