vue-devui 0.1.3 → 1.0.0-alpha.10

package/pagination/index.es.js

@@ -0,0 +1,820 @@
+import { defineComponent, ref, onMounted, onUnmounted, withDirectives, createVNode, createTextVNode, resolveDirective, toRefs, watch, resolveComponent, computed, Fragment, reactive, getCurrentInstance, mergeProps, nextTick } from "vue";
+const paginationProps = {
+  pageSize: {
+    type: Number,
+    default: 10
+  },
+  total: {
+    type: Number,
+    default: 0
+  },
+  pageSizeOptions: {
+    type: Array,
+    default: () => [5, 10, 20, 50]
+  },
+  pageSizeDirection: {
+    type: Array,
+    default: () => ["centerDown", "centerUp"]
+  },
+  pageIndex: {
+    type: Number,
+    default: 1
+  },
+  maxItems: {
+    type: Number,
+    default: 10
+  },
+  preLink: {
+    type: String,
+    default: "<"
+  },
+  nextLink: {
+    type: String,
+    default: ">"
+  },
+  size: {
+    type: String,
+    default: ""
+  },
+  canJumpPage: {
+    type: Boolean,
+    default: false
+  },
+  canChangePageSize: {
+    type: Boolean,
+    default: false
+  },
+  canViewTotal: {
+    type: Boolean,
+    default: false
+  },
+  totalItemText: {
+    type: String
+  },
+  goToText: {
+    type: String
+  },
+  showJumpButton: {
+    type: Boolean,
+    default: false
+  },
+  showTruePageIndex: {
+    type: Boolean,
+    default: false
+  },
+  lite: {
+    type: Boolean,
+    default: false
+  },
+  showPageSelector: {
+    type: Boolean,
+    default: true
+  },
+  haveConfigMenu: {
+    type: Boolean,
+    default: false
+  },
+  autoFixPageIndex: {
+    type: Boolean,
+    default: true
+  },
+  autoHide: {
+    type: Boolean,
+    default: false
+  },
+  "onUpdate:pageIndex": {
+    type: Function
+  },
+  "onUpdate:pageSize": {
+    type: Function
+  },
+  "onPageIndexChange": {
+    type: Function
+  },
+  "onPageSizeChange": {
+    type: Function
+  }
+};
+const handlePages = (cursor, maxItems, totalPages) => {
+  const currentPage = cursor;
+  const maxPages = maxItems;
+  if (maxPages >= totalPages) {
+    return [2, totalPages];
+  }
+  const midPages = maxPages - 2;
+  let midStart = currentPage - (midPages >> 1);
+  let midEnd = currentPage + (midPages - 1 >> 1);
+  if (midStart < 2) {
+    midStart = 2;
+    midEnd = maxPages - 2;
+  }
+  if (midEnd > totalPages) {
+    midStart = totalPages - maxPages + 3;
+    midEnd = totalPages;
+  }
+  return [midStart, midEnd];
+};
+function liteSelectOptions(total) {
+  return new Array(total || 1).fill(0).map((v, index2) => {
+    return {
+      name: `${index2 + 1}/${total}`,
+      value: index2 + 1
+    };
+  });
+}
+function on(element, eventName, handler) {
+  if (document.addEventListener) {
+    if (element && eventName && handler) {
+      element.addEventListener(eventName, handler, false);
+    }
+  } else {
+    if (element && eventName && handler) {
+      element.attachEvent("on" + eventName, handler);
+    }
+  }
+}
+function off(element, eventName, handler) {
+  if (document.removeEventListener) {
+    if (element && eventName && handler) {
+      element.removeEventListener(eventName, handler, false);
+    }
+  } else {
+    if (element && eventName && handler) {
+      element.detachEvent("on" + eventName, handler);
+    }
+  }
+}
+const inBrowser = typeof window !== "undefined";
+const ctx = Symbol("@@clickoutside");
+const nodeList = /* @__PURE__ */ new Map();
+let startClick;
+let nid = 0;
+let isFirst = true;
+function createDocumentHandler(el, binding, vnode) {
+  if (inBrowser && isFirst) {
+    isFirst = false;
+    on(document, "mousedown", (e) => {
+      startClick = e;
+    });
+    on(document, "mouseup", (e) => {
+      for (const [id, node] of nodeList) {
+        node[ctx].documentHandler(e, startClick);
+      }
+    });
+  }
+  return function(mouseup, mousedown) {
+    if (!vnode || !binding.instance || !mouseup.target || !mousedown.target || el.contains(mouseup.target) || el.contains(mousedown.target) || el === mouseup.target) {
+      return;
+    }
+    el[ctx].bindingFn && el[ctx].bindingFn();
+  };
+}
+const clickoutsideDirective = {
+  beforeMount: function(el, binding, vnode) {
+    nid++;
+    nodeList.set(nid, el);
+    el[ctx] = {
+      nid,
+      documentHandler: createDocumentHandler(el, binding, vnode),
+      bindingFn: binding.value
+    };
+  },
+  updated: function(el, binding, vnode) {
+    el[ctx].documentHandler = createDocumentHandler(el, binding, vnode);
+    el[ctx].bindingFn = binding.value;
+  },
+  unmounted: function(el) {
+    nodeList.delete(el[ctx].nid);
+    delete el[ctx];
+  }
+};
+function createBem(namespace, element, modifier) {
+  let cls = namespace;
+  if (element) {
+    cls += `__${element}`;
+  }
+  if (modifier) {
+    cls += `--${modifier}`;
+  }
+  return cls;
+}
+function useNamespace(block, needDot = false) {
+  const namespace = needDot ? `.devui-${block}` : `devui-${block}`;
+  const b = () => createBem(namespace);
+  const e = (element) => element ? createBem(namespace, element) : "";
+  const m = (modifier) => modifier ? createBem(namespace, "", modifier) : "";
+  const em = (element, modifier) => element && modifier ? createBem(namespace, element, modifier) : "";
+  return {
+    b,
+    e,
+    m,
+    em
+  };
+}
+var ConfigMenu = defineComponent({
+  directives: {
+    clickoutside: clickoutsideDirective
+  },
+  props: {
+    currentPageSize: Number,
+    pageSizeChange: Function,
+    pageSizeOptions: Array
+  },
+  setup() {
+    const paginationConfig = ref(null);
+    const isShowConfig = ref(false);
+    const closeConfigMenu = (e) => {
+      isShowConfig.value = isShowConfig.value ? false : !!e;
+    };
+    onMounted(() => {
+      on(paginationConfig.value, "click", closeConfigMenu);
+    });
+    onUnmounted(() => {
+      off(paginationConfig.value, "click", closeConfigMenu);
+    });
+    return {
+      paginationConfig,
+      isShowConfig,
+      closeConfigMenu
+    };
+  },
+  render() {
+    var _a;
+    const {
+      closeConfigMenu,
+      currentPageSize,
+      pageSizeChange,
+      pageSizeOptions,
+      isShowConfig,
+      $slots
+    } = this;
+    const ns = useNamespace("pagination");
+    return withDirectives(createVNode("div", {
+      "class": ns.e("config"),
+      "ref": "paginationConfig"
+    }, [createVNode("div", {
+      "class": ns.e("setup-icon")
+    }, [createVNode("i", {
+      "class": "icon-setting",
+      "style": "font-weight: bold;"
+    }, null)]), isShowConfig && createVNode("div", {
+      "class": ns.e("config-container")
+    }, [(_a = $slots.default) == null ? void 0 : _a.call($slots), createVNode("div", {
+      "class": ns.e("config-item")
+    }, [createVNode("div", {
+      "class": "config-item-title"
+    }, [createTextVNode("\u6BCF\u9875\u6761\u6570")]), createVNode("div", {
+      "class": ns.e("number")
+    }, [pageSizeOptions.map((v) => {
+      return createVNode("div", {
+        "class": {
+          choosed: v === currentPageSize
+        },
+        "key": v,
+        "onClick": pageSizeChange.bind(null, {
+          value: v
+        })
+      }, [v]);
+    })])])])]), [[resolveDirective("clickoutside"), closeConfigMenu]]);
+  }
+});
+const jumpPageProps = {
+  goToText: String,
+  size: {
+    type: String,
+    default: ""
+  },
+  pageIndex: Number,
+  showJumpButton: Boolean,
+  totalPages: Number,
+  cursor: Number,
+  onChangeCursorEmit: Function
+};
+var JumpPage = defineComponent({
+  props: jumpPageProps,
+  emits: ["changeCursorEmit"],
+  setup(props, {
+    emit
+  }) {
+    const {
+      pageIndex,
+      totalPages,
+      cursor
+    } = toRefs(props);
+    const inputNum = ref(pageIndex == null ? void 0 : pageIndex.value);
+    watch(() => pageIndex == null ? void 0 : pageIndex.value, (val) => {
+      inputNum.value = val;
+    });
+    let curPage = pageIndex == null ? void 0 : pageIndex.value;
+    const jumpPageChange = (currentPage) => {
+      curPage = +currentPage;
+      inputNum.value = currentPage;
+      if (isNaN(currentPage)) {
+        setTimeout(() => {
+          inputNum.value = pageIndex == null ? void 0 : pageIndex.value;
+        }, 300);
+      }
+    };
+    const jump = (e) => {
+      if (curPage > (totalPages == null ? void 0 : totalPages.value)) {
+        return;
+      }
+      if ((e === "btn" || e.key === "Enter") && (cursor == null ? void 0 : cursor.value) !== curPage) {
+        emit("changeCursorEmit", curPage);
+      }
+    };
+    return {
+      inputNum,
+      jumpPageChange,
+      jump
+    };
+  },
+  render() {
+    const {
+      goToText,
+      size,
+      inputNum,
+      jumpPageChange,
+      jump,
+      showJumpButton
+    } = this;
+    const ns = useNamespace("pagination");
+    const inputProps = {
+      class: [ns.e("input"), size ? ns.em("input", size) : ""],
+      size,
+      modelValue: String(inputNum),
+      "onUpdate:modelValue": jumpPageChange,
+      onKeydown: jump
+    };
+    return createVNode("div", {
+      "class": ns.e("jump-container")
+    }, [
+      goToText,
+      createVNode(resolveComponent("d-input"), inputProps, null),
+      goToText === "\u8DF3\u81F3" && "\u9875",
+      showJumpButton && createVNode("div", {
+        "class": [ns.e("jump-button"), size ? ns.em("jump-size", size) : ns.em("jump-size", "default")],
+        "onClick": jump.bind(null, "btn"),
+        "title": goToText
+      }, [createVNode("div", {
+        "class": ns.e("go")
+      }, null)])
+    ]);
+  }
+});
+const pageNumBtnProps = {
+  size: {
+    type: String,
+    default: ""
+  },
+  preLink: String,
+  nextLink: String,
+  lite: Boolean,
+  cursor: Number,
+  maxItems: Number,
+  totalPages: Number,
+  onChangeCursorEmit: Function,
+  showTruePageIndex: Boolean
+};
+var PageNumBtn = defineComponent({
+  props: pageNumBtnProps,
+  emits: ["changeCursorEmit"],
+  setup(props, {
+    emit
+  }) {
+    const showPageNum = computed(() => handlePages(props.cursor, props.maxItems, props.totalPages));
+    const changeCursor = (pageSize) => {
+      if (isNaN(pageSize)) {
+        return;
+      }
+      const page = pageSize < 1 ? 1 : pageSize > props.totalPages ? props.totalPages : pageSize | 0;
+      emit("changeCursorEmit", page);
+    };
+    const prevChange = (page) => {
+      if (props.cursor > 1) {
+        const toPage = page === -1 ? props.cursor - 1 : page;
+        emit("changeCursorEmit", toPage);
+      }
+    };
+    const nextChange = (page) => {
+      if (props.cursor < props.totalPages) {
+        const toPage = page === -1 ? props.cursor + 1 : page;
+        emit("changeCursorEmit", toPage);
+      }
+    };
+    return {
+      showPageNum,
+      changeCursor,
+      prevChange,
+      nextChange
+    };
+  },
+  render() {
+    const {
+      size,
+      preLink,
+      nextLink,
+      lite,
+      changeCursor,
+      cursor,
+      showPageNum,
+      prevChange,
+      totalPages,
+      nextChange,
+      showTruePageIndex
+    } = this;
+    const ns = useNamespace("pagination");
+    return createVNode("ul", {
+      "class": [ns.e("list"), size ? ns.m(size) : ""]
+    }, [createVNode("li", {
+      "onClick": prevChange.bind(null, -1),
+      "class": {
+        [ns.e("item")]: true,
+        disabled: cursor <= 1
+      }
+    }, [createVNode("a", {
+      "innerHTML": preLink,
+      "class": ns.e("link")
+    }, null)]), !lite && createVNode(Fragment, null, [
+      createVNode("li", {
+        "onClick": changeCursor.bind(null, 1),
+        "class": {
+          [ns.e("item")]: true,
+          active: cursor === 1
+        }
+      }, [createVNode("a", {
+        "class": ns.e("link")
+      }, [createTextVNode("1")])]),
+      showPageNum[0] > 2 && createVNode("li", {
+        "onClick": prevChange.bind(null, showPageNum[0] - 1),
+        "class": ns.e("item")
+      }, [createVNode("a", {
+        "class": ns.e("link")
+      }, [createTextVNode("...")])]),
+      (() => {
+        const list = [];
+        for (let i = showPageNum[0]; i <= showPageNum[1]; i++) {
+          list.push(createVNode("li", {
+            "onClick": changeCursor.bind(null, i),
+            "key": i,
+            "class": {
+              [ns.e("item")]: true,
+              active: cursor === i
+            }
+          }, [createVNode("a", {
+            "class": ns.e("link")
+          }, [i])]));
+        }
+        return list;
+      })(),
+      showPageNum[1] < totalPages - 1 && createVNode("li", {
+        "onClick": nextChange.bind(null, showPageNum[1] + 1),
+        "class": ns.e("item")
+      }, [createVNode("a", {
+        "class": ns.e("link")
+      }, [createTextVNode("...")])]),
+      showPageNum[1] < totalPages && createVNode("li", {
+        "onClick": changeCursor.bind(null, totalPages),
+        "class": {
+          [ns.e("item")]: true,
+          active: cursor === totalPages
+        }
+      }, [createVNode("a", {
+        "class": ns.e("link")
+      }, [totalPages])]),
+      showTruePageIndex && cursor > totalPages && totalPages > 0 && createVNode(Fragment, null, [cursor > totalPages + 1 && createVNode("li", {
+        "class": [ns.e("item"), "disabled"]
+      }, [createVNode("a", {
+        "class": ns.e("link")
+      }, [createTextVNode("...")])]), createVNode("li", {
+        "class": [ns.e("item"), "disabled", "active"]
+      }, [createVNode("a", {
+        "class": ns.e("link")
+      }, [cursor])])])
+    ]), createVNode("li", {
+      "onClick": nextChange.bind(null, -1),
+      "class": {
+        [ns.e("item")]: true,
+        disabled: cursor >= totalPages
+      }
+    }, [createVNode("a", {
+      "innerHTML": nextLink,
+      "class": ns.e("link")
+    }, null)])]);
+  }
+});
+function deepAssign(...objects) {
+  const isObject = (obj) => obj && typeof obj === "object";
+  return objects.reduce((prev, from) => {
+    Object.keys(from).forEach((key) => {
+      const pVal = prev[key];
+      const oVal = from[key];
+      if (Array.isArray(pVal) && Array.isArray(oVal)) {
+        prev[key] = Array.from(/* @__PURE__ */ new Set([...oVal, ...pVal]));
+      } else if (isObject(pVal) && isObject(oVal)) {
+        prev[key] = deepAssign(pVal, oVal);
+      } else {
+        prev[key] = oVal;
+      }
+    });
+    return prev;
+  }, {});
+}
+var zhCN = {
+  pagination: {
+    totalItemText: "\u6240\u6709\u6761\u76EE",
+    goToText: "\u8DF3\u81F3"
+  },
+  accordion: {
+    loading: "\u52A0\u8F7D\u4E2D",
+    noData: "\u6CA1\u6709\u6570\u636E"
+  },
+  autoCompleteDropdown: {
+    latestInput: "\u6700\u8FD1\u8F93\u5165"
+  },
+  cascaderList: {
+    noData: "\u6CA1\u6709\u6570\u636E"
+  },
+  colorPicker: {
+    foundationPanel: "\u57FA\u7840\u9762\u677F",
+    advancedPanel: "\u9AD8\u7EA7\u9762\u677F"
+  },
+  datePickerPro: {
+    ok: "\u786E\u5B9A",
+    placeholder: "\u8BF7\u9009\u62E9\u65E5\u671F",
+    month1: "1\u6708",
+    month2: "2\u6708",
+    month3: "3\u6708",
+    month4: "4\u6708",
+    month5: "5\u6708",
+    month6: "6\u6708",
+    month7: "7\u6708",
+    month8: "8\u6708",
+    month9: "9\u6708",
+    month10: "10\u6708",
+    month11: "11\u6708",
+    month12: "12\u6708",
+    year: "\u5E74",
+    startPlaceholder: "\u8BF7\u9009\u62E9\u5F00\u59CB\u65E5\u671F",
+    endPlaceholder: "\u8BF7\u9009\u62E9\u7ED3\u675F\u65E5\u671F",
+    getWeekDays() {
+      return ["\u65E5", "\u4E00", "\u4E8C", "\u4E09", "\u56DB", "\u4E94", "\u516D"];
+    },
+    getTimeArr() {
+      return ["\u65F6", "\u5206", "\u79D2"];
+    },
+    getYearMonthStr(year, month) {
+      return `${year}\u5E74${month}\u6708`;
+    }
+  },
+  editableSelect: {
+    noRelatedRecords: "\u627E\u4E0D\u5230\u76F8\u5173\u8BB0\u5F55",
+    noData: "\u6CA1\u6709\u6570\u636E"
+  },
+  input: {
+    placeholder: "\u8BF7\u8F93\u5165"
+  },
+  splitterBar: {
+    collapse: "\u6536\u8D77",
+    expand: "\u5C55\u5F00"
+  },
+  stepsGuide: {
+    previous: "\u4E0A\u4E00\u6B65",
+    continue: "\u6211\u77E5\u9053\u5566\uFF0C\u7EE7\u7EED",
+    ok: "\u6211\u77E5\u9053\u5566"
+  },
+  table: {
+    selectAll: "\u5168\u9009",
+    ok: "\u786E\u5B9A"
+  },
+  timePopup: {
+    ok: "\u786E\u5B9A"
+  },
+  transfer: {
+    unit: "\u9879",
+    panelUnit: "\u9879",
+    headerUnit: "\u9879",
+    noData: "\u6682\u65E0\u6570\u636E",
+    placeholder: "\u8BF7\u8F93\u5165\u5173\u952E\u8BCD\u641C\u7D22"
+  },
+  tree: {
+    loading: "\u52A0\u8F7D\u4E2D",
+    newNode: "\u65B0\u8282\u70B9",
+    selectPlaceholder: "\u8BF7\u9009\u62E9"
+  },
+  upload: {
+    placeholder: "\u9009\u62E9\u6587\u4EF6",
+    getExistSameNameFilesMsg(sameNames) {
+      return `\u60A8\u4E0A\u4F20\u7684 "${sameNames}" \u5B58\u5728\u91CD\u540D\u6587\u4EF6, \u8BF7\u91CD\u65B0\u9009\u62E9\u6587\u4EF6`;
+    },
+    getAllFilesBeyondMaximalFileSizeMsg(maximalSize) {
+      return `\u6700\u5927\u652F\u6301\u4E0A\u4F20${maximalSize}MB\u7684\u6587\u4EF6, \u60A8\u672C\u6B21\u4E0A\u4F20\u7684\u6240\u6709\u6587\u4EF6\u8D85\u8FC7\u53EF\u4E0A\u4F20\u6587\u4EF6\u5927\u5C0F`;
+    },
+    getBeyondMaximalFileSizeMsg(filename, maximalSize) {
+      return `\u6700\u5927\u652F\u6301\u4E0A\u4F20${maximalSize}MB\u7684\u6587\u4EF6, \u60A8\u4E0A\u4F20\u7684\u6587\u4EF6"${filename}"\u8D85\u8FC7\u53EF\u4E0A\u4F20\u6587\u4EF6\u5927\u5C0F`;
+    },
+    getNotAllowedFileTypeMsg(filename, scope) {
+      return `\u652F\u6301\u7684\u6587\u4EF6\u7C7B\u578B: "${scope}", \u60A8\u4E0A\u4F20\u7684\u6587\u4EF6"${filename}"\u4E0D\u5728\u5141\u8BB8\u8303\u56F4\u5185\uFF0C\u8BF7\u91CD\u65B0\u9009\u62E9\u6587\u4EF6`;
+    }
+  },
+  search: {
+    placeholder: "\u8BF7\u8F93\u5165\u5173\u952E\u5B57"
+  },
+  select: {
+    placeholder: "\u8BF7\u9009\u62E9",
+    noDataText: "\u65E0\u6570\u636E",
+    noMatchText: "\u627E\u4E0D\u5230\u76F8\u5173\u8BB0\u5F55",
+    loadingText: "\u52A0\u8F7D\u4E2D..."
+  },
+  tagInput: {
+    maxTagsText: "\u5DF2\u8FBE\u5230\u6700\u5927\u4E2A\u6570\uFF1A"
+  },
+  timeSelect: {
+    placeholder: "\u8BF7\u9009\u62E9\u65F6\u95F4"
+  }
+};
+const lang = ref("zh-CN");
+let langMessages = reactive({
+  [lang.value]: zhCN
+});
+const Locale = {
+  messages() {
+    return langMessages[lang.value];
+  },
+  lang() {
+    return lang.value;
+  },
+  use(newLang, newMessages) {
+    lang.value = newLang;
+    this.add({ [newLang]: newMessages });
+  },
+  add(newMessages = {}) {
+    langMessages = deepAssign(langMessages, newMessages);
+  }
+};
+const camelize = (name) => name.substring(1).replace(/^\S/, (s) => s.toLocaleLowerCase());
+function get(object, path) {
+  const keys = path.split(".");
+  let result = object;
+  keys.forEach((key) => {
+    var _a;
+    result = (_a = result[key]) != null ? _a : "";
+  });
+  return result;
+}
+function createI18nTranslate(name, app, newPrefix) {
+  const prefix = newPrefix || camelize(name) + ".";
+  return (path) => {
+    var _a;
+    const messages = ((_a = app == null ? void 0 : app.appContext.config.globalProperties.langMessages) == null ? void 0 : _a.value) || Locale.messages();
+    const message = get(messages, prefix + path) || get(messages, path);
+    return message;
+  };
+}
+var pagination = "";
+var Pagination = defineComponent({
+  name: "DPagination",
+  components: {
+    ConfigMenu,
+    JumpPage,
+    PageNumBtn
+  },
+  props: paginationProps,
+  emits: ["pageIndexChange", "pageSizeChange", "update:pageSize", "update:pageIndex"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const app = getCurrentInstance();
+    const t = createI18nTranslate("DPagination", app);
+    const {
+      autoHide,
+      pageSizeOptions,
+      total,
+      canChangePageSize,
+      lite,
+      size,
+      pageSizeDirection,
+      showPageSelector,
+      canViewTotal,
+      totalItemText,
+      maxItems,
+      preLink,
+      nextLink,
+      showTruePageIndex,
+      canJumpPage,
+      goToText,
+      pageIndex,
+      showJumpButton,
+      haveConfigMenu
+    } = toRefs(props);
+    const ns = useNamespace("pagination");
+    const totalPages = computed(() => Math.ceil(props.total / props.pageSize));
+    const litePageOptions = computed(() => liteSelectOptions(totalPages.value));
+    const cursor = computed({
+      get() {
+        if (!props.showTruePageIndex && props.pageIndex > totalPages.value) {
+          emit("update:pageIndex", totalPages.value || 1);
+          return totalPages.value || 1;
+        }
+        return props.pageIndex || 1;
+      },
+      set(val) {
+        emit("update:pageIndex", val);
+      }
+    });
+    const currentPageSize = computed({
+      get() {
+        return props.pageSize;
+      },
+      set(val) {
+        emit("update:pageSize", val);
+      }
+    });
+    const changeCursorEmit = (val) => {
+      cursor.value = val;
+      emit("pageIndexChange", val);
+    };
+    const pageSizeChange = (val) => {
+      currentPageSize.value = val.value;
+      if (props.autoFixPageIndex) {
+        nextTick(() => {
+          if (cursor.value > totalPages.value) {
+            changeCursorEmit(totalPages.value);
+          }
+        });
+      }
+      emit("pageSizeChange", val.value);
+    };
+    const litePageIndexChange = (page) => {
+      changeCursorEmit(page.value);
+    };
+    return () => {
+      return autoHide.value && Math.min(...pageSizeOptions.value) > total.value ? null : createVNode("div", {
+        "class": ns.b()
+      }, [
+        canChangePageSize.value && !lite.value && createVNode("div", {
+          "class": [ns.e("size"), size.value ? ns.em("size", size.value) : ""]
+        }, [createVNode(resolveComponent("d-select"), {
+          "options": pageSizeOptions.value,
+          "modelValue": currentPageSize.value,
+          "onValueChange": pageSizeChange,
+          "pageSizeDirection": pageSizeDirection.value
+        }, null)]),
+        (!lite.value || lite.value && showPageSelector.value) && canViewTotal.value && createVNode("div", {
+          "class": ns.e("total-size")
+        }, [totalItemText.value || t("totalItemText"), createTextVNode(": "), total.value]),
+        lite.value && showPageSelector.value && createVNode("div", {
+          "class": ns.e("size")
+        }, [createVNode(resolveComponent("d-select"), {
+          "options": litePageOptions.value,
+          "disabled": total.value === 0,
+          "modelValue": cursor.value,
+          "onValueChange": litePageIndexChange,
+          "pageSizeDirection": pageSizeDirection.value
+        }, null)]),
+        createVNode(resolveComponent("page-num-btn"), mergeProps({
+          cursor: cursor.value,
+          totalPages: totalPages.value,
+          size: size.value,
+          lite: lite.value,
+          maxItems: maxItems.value,
+          preLink: preLink.value,
+          nextLink: nextLink.value,
+          showTruePageIndex: showTruePageIndex.value
+        }, {
+          "onChangeCursorEmit": changeCursorEmit
+        }), null),
+        canJumpPage.value && !lite.value && createVNode(resolveComponent("jump-page"), mergeProps({
+          goToText: goToText.value || t("goToText"),
+          size: size.value,
+          pageIndex: pageIndex.value,
+          totalPages: totalPages.value,
+          cursor: cursor.value,
+          showJumpButton: showJumpButton.value
+        }, {
+          "onChangeCursorEmit": changeCursorEmit
+        }), null),
+        lite.value && haveConfigMenu.value && createVNode(resolveComponent("config-menu"), {
+          currentPageSize: currentPageSize.value,
+          pageSizeChange,
+          pageSizeOptions: pageSizeOptions.value
+        }, {
+          default: () => {
+            var _a;
+            return [(_a = slots.default) == null ? void 0 : _a.call(slots)];
+          }
+        })
+      ]);
+    };
+  }
+});
+var index = {
+  title: "Pagination \u5206\u9875",
+  category: "\u5BFC\u822A",
+  status: "100%",
+  install(app) {
+    app.component(Pagination.name, Pagination);
+  }
+};
+export { Pagination, index as default, paginationProps };