"use strict";
Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
const event = require("../../../constants/event.js");
const types = require("../../../utils/types.js");
const error = require("../../../utils/error.js");
const runtime = require("../../../utils/vue/props/runtime.js");
const icon = require("../../../utils/vue/icon.js");
const typescript = require("../../../utils/typescript.js");
const index$3 = require("../../../hooks/use-deprecated/index.js");
const index = require("../../../hooks/use-locale/index.js");
const index$1 = require("../../../hooks/use-namespace/index.js");
const index$2 = require("../../../hooks/use-size/index.js");
const constants = require("./constants.js");
const prev2 = require("./components/prev2.js");
const next2 = require("./components/next2.js");
const sizes2 = require("./components/sizes2.js");
const jumper2 = require("./components/jumper2.js");
const total2 = require("./components/total2.js");
const pager2 = require("./components/pager2.js");
const index$4 = require("../../../../../@element-plus/icons-vue/dist/index.js");
const Vue = require("vue");
const isAbsent = (v) => typeof v !== "number";
const paginationProps = runtime.buildProps({
  pageSize: Number,
  defaultPageSize: Number,
  total: Number,
  pageCount: Number,
  pagerCount: {
    type: Number,
    validator: (value) => {
      return types.isNumber(value) && Math.trunc(value) === value && value > 4 && value < 22 && value % 2 === 1;
    },
    default: 7
  },
  currentPage: Number,
  defaultCurrentPage: Number,
  layout: {
    type: String,
    default: [
      "prev",
      "pager",
      "next",
      "jumper",
      "->",
      "total"
    ].join(", ")
  },
  pageSizes: {
    type: runtime.definePropType(Array),
    default: () => typescript.mutable([
      10,
      20,
      30,
      40,
      50,
      100
    ])
  },
  popperClass: {
    type: String,
    default: ""
  },
  popperStyle: { type: runtime.definePropType([String, Object]) },
  prevText: {
    type: String,
    default: ""
  },
  prevIcon: {
    type: icon.iconPropType,
    default: () => index$4.ArrowLeft
  },
  nextText: {
    type: String,
    default: ""
  },
  nextIcon: {
    type: icon.iconPropType,
    default: () => index$4.ArrowRight
  },
  teleported: {
    type: Boolean,
    default: true
  },
  small: Boolean,
  size: index$2.useSizeProp,
  background: Boolean,
  disabled: Boolean,
  hideOnSinglePage: Boolean,
  appendSizeTo: String
});
const paginationEmits = {
  "update:current-page": (val) => types.isNumber(val),
  "update:page-size": (val) => types.isNumber(val),
  "size-change": (val) => types.isNumber(val),
  change: (currentPage, pageSize) => types.isNumber(currentPage) && types.isNumber(pageSize),
  "current-change": (val) => types.isNumber(val),
  "prev-click": (val) => types.isNumber(val),
  "next-click": (val) => types.isNumber(val)
};
const componentName = "ElPagination";
var pagination_default = Vue.defineComponent({
  name: componentName,
  props: paginationProps,
  emits: paginationEmits,
  setup(props, { emit, slots }) {
    const { t } = index.useLocale();
    const ns = index$1.useNamespace("pagination");
    const vnodeProps = Vue.getCurrentInstance().vnode.props || {};
    const _globalSize = index$2.useGlobalSize();
    const _size = Vue.computed(() => props.small ? "small" : props.size ?? _globalSize.value);
    index$3.useDeprecated({
      from: "small",
      replacement: "size",
      version: "3.0.0",
      scope: "el-pagination",
      ref: "https://element-plus.org/zh-CN/component/pagination.html"
    }, Vue.computed(() => !!props.small));
    const hasCurrentPageListener = "onUpdate:currentPage" in vnodeProps || "onUpdate:current-page" in vnodeProps || "onCurrentChange" in vnodeProps;
    const hasPageSizeListener = "onUpdate:pageSize" in vnodeProps || "onUpdate:page-size" in vnodeProps || "onSizeChange" in vnodeProps;
    const assertValidUsage = Vue.computed(() => {
      if (isAbsent(props.total) && isAbsent(props.pageCount)) return false;
      if (!isAbsent(props.currentPage) && !hasCurrentPageListener) return false;
      if (props.layout.includes("sizes")) {
        if (!isAbsent(props.pageCount)) {
          if (!hasPageSizeListener) return false;
        } else if (!isAbsent(props.total)) {
          if (!isAbsent(props.pageSize)) {
            if (!hasPageSizeListener) return false;
          }
        }
      }
      return true;
    });
    const innerPageSize = Vue.ref(isAbsent(props.defaultPageSize) ? 10 : props.defaultPageSize);
    const innerCurrentPage = Vue.ref(isAbsent(props.defaultCurrentPage) ? 1 : props.defaultCurrentPage);
    const pageSizeBridge = Vue.computed({
      get() {
        return isAbsent(props.pageSize) ? innerPageSize.value : props.pageSize;
      },
      set(v) {
        if (isAbsent(props.pageSize)) innerPageSize.value = v;
        if (hasPageSizeListener) {
          emit("update:page-size", v);
          emit("size-change", v);
        }
      }
    });
    const pageCountBridge = Vue.computed(() => {
      let pageCount = 0;
      if (!isAbsent(props.pageCount)) pageCount = props.pageCount;
      else if (!isAbsent(props.total)) pageCount = Math.max(1, Math.ceil(props.total / pageSizeBridge.value));
      return pageCount;
    });
    const currentPageBridge = Vue.computed({
      get() {
        return isAbsent(props.currentPage) ? innerCurrentPage.value : props.currentPage;
      },
      set(v) {
        let newCurrentPage = v;
        if (v < 1) newCurrentPage = 1;
        else if (v > pageCountBridge.value) newCurrentPage = pageCountBridge.value;
        if (isAbsent(props.currentPage)) innerCurrentPage.value = newCurrentPage;
        if (hasCurrentPageListener) {
          emit("update:current-page", newCurrentPage);
          emit("current-change", newCurrentPage);
        }
      }
    });
    Vue.watch(pageCountBridge, (val) => {
      if (currentPageBridge.value > val) currentPageBridge.value = val;
    });
    Vue.watch([currentPageBridge, pageSizeBridge], (value) => {
      emit(event.CHANGE_EVENT, ...value);
    }, { flush: "post" });
    function handleCurrentChange(val) {
      currentPageBridge.value = val;
    }
    function handleSizeChange(val) {
      pageSizeBridge.value = val;
      const newPageCount = pageCountBridge.value;
      if (currentPageBridge.value > newPageCount) currentPageBridge.value = newPageCount;
    }
    function prev() {
      if (props.disabled) return;
      currentPageBridge.value -= 1;
      emit("prev-click", currentPageBridge.value);
    }
    function next() {
      if (props.disabled) return;
      currentPageBridge.value += 1;
      emit("next-click", currentPageBridge.value);
    }
    function addClass(element, cls) {
      if (element) {
        if (!element.props) element.props = {};
        element.props.class = [element.props.class, cls].join(" ");
      }
    }
    Vue.provide(constants.elPaginationKey, {
      pageCount: pageCountBridge,
      disabled: Vue.computed(() => props.disabled),
      currentPage: currentPageBridge,
      changeEvent: handleCurrentChange,
      handleSizeChange
    });
    return () => {
      var _a;
      if (!assertValidUsage.value) {
        error.debugWarn(componentName, t("el.pagination.deprecationWarning"));
        return null;
      }
      if (!props.layout) return null;
      if (props.hideOnSinglePage && pageCountBridge.value <= 1) return null;
      const rootChildren = [];
      const rightWrapperChildren = [];
      const rightWrapperRoot = Vue.h("div", { class: ns.e("rightwrapper") }, rightWrapperChildren);
      const TEMPLATE_MAP = {
        prev: Vue.h(prev2.default, {
          disabled: props.disabled,
          currentPage: currentPageBridge.value,
          prevText: props.prevText,
          prevIcon: props.prevIcon,
          onClick: prev
        }),
        jumper: Vue.h(jumper2.default, { size: _size.value }),
        pager: Vue.h(pager2.default, {
          currentPage: currentPageBridge.value,
          pageCount: pageCountBridge.value,
          pagerCount: props.pagerCount,
          onChange: handleCurrentChange,
          disabled: props.disabled
        }),
        next: Vue.h(next2.default, {
          disabled: props.disabled,
          currentPage: currentPageBridge.value,
          pageCount: pageCountBridge.value,
          nextText: props.nextText,
          nextIcon: props.nextIcon,
          onClick: next
        }),
        sizes: Vue.h(sizes2.default, {
          pageSize: pageSizeBridge.value,
          pageSizes: props.pageSizes,
          popperClass: props.popperClass,
          popperStyle: props.popperStyle,
          disabled: props.disabled,
          teleported: props.teleported,
          size: _size.value,
          appendSizeTo: props.appendSizeTo
        }),
        slot: ((_a = slots == null ? void 0 : slots.default) == null ? void 0 : _a.call(slots)) ?? null,
        total: Vue.h(total2.default, { total: isAbsent(props.total) ? 0 : props.total })
      };
      const components = props.layout.split(",").map((item) => item.trim());
      let haveRightWrapper = false;
      components.forEach((c) => {
        if (c === "->") {
          haveRightWrapper = true;
          return;
        }
        if (!haveRightWrapper) rootChildren.push(TEMPLATE_MAP[c]);
        else rightWrapperChildren.push(TEMPLATE_MAP[c]);
      });
      addClass(rootChildren[0], ns.is("first"));
      addClass(rootChildren[rootChildren.length - 1], ns.is("last"));
      if (haveRightWrapper && rightWrapperChildren.length > 0) {
        addClass(rightWrapperChildren[0], ns.is("first"));
        addClass(rightWrapperChildren[rightWrapperChildren.length - 1], ns.is("last"));
        rootChildren.push(rightWrapperRoot);
      }
      return Vue.h("div", { class: [
        ns.b(),
        ns.is("background", props.background),
        ns.m(_size.value)
      ] }, rootChildren);
    };
  }
});
exports.default = pagination_default;
exports.paginationEmits = paginationEmits;
exports.paginationProps = paginationProps;
