refactor(Pagination): refactor with composition api

src/pagination/index.js

@@ -1,5 +1,6 @@
 import { createNamespace } from '../utils';
 import { BORDER } from '../utils/constant';
+import { computed, watch } from 'vue';
 
 const [createComponent, bem, t] = createNamespace('pagination');
 
@@ -40,19 +41,20 @@ export default createComponent({
 
   emits: ['change', 'update:modelValue'],
 
-  computed: {
+  setup(props, { emit, slots }) {
-    count() {
+    const count = computed(() => {
-      const count =
+      const { pageCount, totalItems, itemsPerPage } = props;
-        this.pageCount || Math.ceil(this.totalItems / this.itemsPerPage);
+      const count = pageCount || Math.ceil(totalItems / itemsPerPage);
       return Math.max(1, count);
-    },
+    });
 
-    pages() {
+    const pages = computed(() => {
       const pages = [];
-      const pageCount = this.count;
+      const pageCount = count.value;
-      const showPageSize = +this.showPageSize;
+      const showPageSize = +props.showPageSize;
+      const { modelValue, forceEllipses } = props;
 
-      if (this.mode !== 'multi') {
+      if (props.mode !== 'multi') {
         return pages;
       }
 
@@ -64,7 +66,7 @@ export default createComponent({
       // recompute if showPageSize
       if (isMaxSized) {
         // Current page is displayed in the middle of the visible ones
-        startPage = Math.max(this.modelValue - Math.floor(showPageSize / 2), 1);
+        startPage = Math.max(modelValue - Math.floor(showPageSize / 2), 1);
         endPage = startPage + showPageSize - 1;
 
         // Adjust if limit is exceeded
@@ -76,91 +78,97 @@ export default createComponent({
 
       // Add page number links
       for (let number = startPage; number <= endPage; number++) {
-        const page = makePage(number, number, number === this.modelValue);
+        const page = makePage(number, number, number === modelValue);
         pages.push(page);
       }
 
       // Add links to move between page sets
-      if (isMaxSized && showPageSize > 0 && this.forceEllipses) {
+      if (isMaxSized && showPageSize > 0 && forceEllipses) {
         if (startPage > 1) {
-          const previousPageSet = makePage(startPage - 1, '...', false);
+          const prevPages = makePage(startPage - 1, '...');
-          pages.unshift(previousPageSet);
+          pages.unshift(prevPages);
         }
 
         if (endPage < pageCount) {
-          const nextPageSet = makePage(endPage + 1, '...', false);
+          const nextPages = makePage(endPage + 1, '...');
-          pages.push(nextPageSet);
+          pages.push(nextPages);
         }
       }
 
       return pages;
-    },
+    });
-  },
 
-  watch: {
+    const select = (page, emitChange) => {
-    modelValue: {
+      page = Math.min(count.value, Math.max(1, page));
-      handler(page) {
-        this.select(page);
-      },
-      immediate: true,
-    },
-  },
 
-  methods: {
+      if (props.modelValue !== page) {
-    select(page, emitChange) {
+        emit('update:modelValue', page);
-      page = Math.min(this.count, Math.max(1, page));
-      if (this.modelValue !== page) {
-        this.$emit('update:modelValue', page);
 
         if (emitChange) {
-          this.$emit('change', page);
+          emit('change', page);
         }
       }
-    },
+    };
-  },
 
-  render() {
+    watch(() => props.modelValue, select, { immediate: true });
-    const value = this.modelValue;
+
-    const simple = this.mode !== 'multi';
+    const renderDesc = () => {
+      if (props.mode !== 'multi') {
+        return (
+          <li class={bem('page-desc')}>
+            {slots.pageDesc
+              ? slots.pageDesc()
+              : `${props.modelValue}/${count.value}`}
+          </li>
+        );
+      }
+    };
+
+    return () => {
+      const value = props.modelValue;
+      const simple = props.mode !== 'multi';
 
       const onSelect = (value) => () => {
-      this.select(value, true);
+        select(value, true);
       };
 
       return (
         <ul class={bem({ simple })}>
           <li
-          class={[bem('item', { disabled: value === 1 }), bem('prev'), BORDER]}
+            class={[
+              bem('item', { disabled: value === 1 }),
+              bem('prev'),
+              BORDER,
+            ]}
             onClick={onSelect(value - 1)}
           >
-          {this.prevText || t('prev')}
+            {props.prevText || t('prev')}
           </li>
-        {this.pages.map((page) => (
+          {pages.value.map((page) => (
             <li
-            class={[bem('item', { active: page.active }), bem('page'), BORDER]}
+              class={[
+                bem('item', { active: page.active }),
+                bem('page'),
+                BORDER,
+              ]}
               onClick={onSelect(page.number)}
             >
               {page.text}
             </li>
           ))}
-        {simple && (
+          {renderDesc()}
-          <li class={bem('page-desc')}>
-            {this.$slots.pageDesc
-              ? this.$slots.pageDesc()
-              : `${value}/${this.count}`}
-          </li>
-        )}
           <li
             class={[
-            bem('item', { disabled: value === this.count }),
+              bem('item', { disabled: value === count.value }),
               bem('next'),
               BORDER,
             ]}
             onClick={onSelect(value + 1)}
           >
-          {this.nextText || t('next')}
+            {props.nextText || t('next')}
           </li>
         </ul>
       );
+    };
   },
 });