vxe-table 3.15.11 → 3.15.13

package/es/table/src/cell.js

@@ -10,7 +10,7 @@ function renderTitlePrefixIcon(h, params) {
     const titlePrefix = column.titlePrefix || column.titleHelp;
     if (titlePrefix) {
         return h('i', {
-            class: ['vxe-cell-title-prefix-icon', titlePrefix.icon || getIcon().TABLE_TITLE_PREFIX],
+            class: ['vxe-cell-title-prefix-icon', titlePrefix.iconStatus ? `theme--${titlePrefix.iconStatus}` : '', titlePrefix.icon || getIcon().TABLE_TITLE_PREFIX],
             on: {
                 mouseenter(evnt) {
                     $table.triggerHeaderTitleEvent(evnt, titlePrefix, params);
@@ -28,7 +28,7 @@ function renderTitleSuffixIcon(h, params) {
     const titleSuffix = column.titleSuffix;
     if (titleSuffix) {
         return h('i', {
-            class: ['vxe-cell-title-suffix-icon', titleSuffix.icon || getIcon().TABLE_TITLE_SUFFIX],
+            class: ['vxe-cell-title-suffix-icon', titleSuffix.iconStatus ? `theme--${titleSuffix.iconStatus}` : '', titleSuffix.icon || getIcon().TABLE_TITLE_SUFFIX],
             on: {
                 mouseenter(evnt) {
                     $table.triggerHeaderTitleEvent(evnt, titleSuffix, params);

package/es/table/src/methods.js

@@ -2418,12 +2418,12 @@ function calcScrollbar($xeTable) {
     if (bodyWrapperElem) {
         overflowY = scrollYHeight > bodyWrapperElem.clientHeight;
         if (yHandleEl) {
-            reactData.scrollbarWidth = Math.max(scrollbarOpts.width || 0, yHandleEl.offsetWidth - yHandleEl.clientWidth);
+            reactData.scrollbarWidth = scrollbarOpts.width || (yHandleEl.offsetWidth - yHandleEl.clientWidth) || 14;
         }
         reactData.overflowY = overflowY;
         overflowX = scrollXWidth > bodyWrapperElem.clientWidth;
         if (xHandleEl) {
-            reactData.scrollbarHeight = Math.max(scrollbarOpts.height || 0, xHandleEl.offsetHeight - xHandleEl.clientHeight);
+            reactData.scrollbarHeight = scrollbarOpts.height || (xHandleEl.offsetHeight - xHandleEl.clientHeight) || 14;
         }
         reactData.overflowX = overflowX;
         const headerHeight = headerTableElem ? headerTableElem.clientHeight : 0;
@@ -2621,6 +2621,7 @@ function loadTableData($xeTable, datas, isReset) {
     scrollYStore.endIndex = 1;
     scrollXStore.startIndex = 0;
     scrollXStore.endIndex = 1;
+    internalData.cvCacheMaps = {};
     reactData.isRowLoading = true;
     reactData.scrollVMLoading = false;
     internalData.treeExpandedMaps = {};
@@ -3048,42 +3049,42 @@ const createGetColumnCacheProp = (prop) => {
         return -1;
     };
 };
-function lazyScrollXData($xeTable) {
-    const internalData = $xeTable;
-    const { lxTimeout, lxRunTime, scrollXStore } = internalData;
-    const { visibleSize } = scrollXStore;
-    const fpsTime = Math.max(5, Math.min(10, Math.floor(visibleSize / 3)));
-    if (lxTimeout) {
-        clearTimeout(lxTimeout);
-    }
-    if (!lxRunTime || lxRunTime + fpsTime < Date.now()) {
-        internalData.lxRunTime = Date.now();
-        loadScrollXData($xeTable);
-    }
-    internalData.lxTimeout = setTimeout(() => {
-        internalData.lxTimeout = undefined;
-        internalData.lxRunTime = undefined;
-        loadScrollXData($xeTable);
-    }, fpsTime);
-}
-function lazyScrollYData($xeTable) {
-    const internalData = $xeTable;
-    const { lyTimeout, lyRunTime, scrollYStore } = internalData;
-    const { visibleSize } = scrollYStore;
-    const fpsTime = Math.floor(Math.max(4, Math.min(10, visibleSize / 3)));
-    if (lyTimeout) {
-        clearTimeout(lyTimeout);
-    }
-    if (!lyRunTime || lyRunTime + fpsTime < Date.now()) {
-        internalData.lyRunTime = Date.now();
-        loadScrollYData($xeTable);
-    }
-    internalData.lyTimeout = setTimeout(() => {
-        internalData.lyTimeout = undefined;
-        internalData.lyRunTime = undefined;
-        loadScrollYData($xeTable);
-    }, fpsTime);
-}
+// function lazyScrollXData ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
+//   const internalData = $xeTable as unknown as TableInternalData
+//   const { lxTimeout, lxRunTime, scrollXStore } = internalData
+//   const { visibleSize } = scrollXStore
+//   const fpsTime = Math.max(5, Math.min(10, Math.floor(visibleSize / 3)))
+//   if (lxTimeout) {
+//     clearTimeout(lxTimeout)
+//   }
+//   if (!lxRunTime || lxRunTime + fpsTime < Date.now()) {
+//     internalData.lxRunTime = Date.now()
+//     loadScrollXData($xeTable)
+//   }
+//   internalData.lxTimeout = setTimeout(() => {
+//     internalData.lxTimeout = undefined
+//     internalData.lxRunTime = undefined
+//     loadScrollXData($xeTable)
+//   }, fpsTime)
+// }
+// function lazyScrollYData ($xeTable: VxeTableConstructor & VxeTablePrivateMethods) {
+//   const internalData = $xeTable as unknown as TableInternalData
+//   const { lyTimeout, lyRunTime, scrollYStore } = internalData
+//   const { visibleSize } = scrollYStore
+//   const fpsTime = Math.floor(Math.max(4, Math.min(10, visibleSize / 3)))
+//   if (lyTimeout) {
+//     clearTimeout(lyTimeout)
+//   }
+//   if (!lyRunTime || lyRunTime + fpsTime < Date.now()) {
+//     internalData.lyRunTime = Date.now()
+//     loadScrollYData($xeTable)
+//   }
+//   internalData.lyTimeout = setTimeout(() => {
+//     internalData.lyTimeout = undefined
+//     internalData.lyRunTime = undefined
+//     loadScrollYData($xeTable)
+//   }, fpsTime)
+// }
 function checkLastSyncScroll($xeTable, isRollX, isRollY) {
     const reactData = $xeTable;
     const internalData = $xeTable;
@@ -9022,26 +9023,24 @@ const Methods = {
      */
     triggerScrollXEvent() {
         const $xeTable = this;
-        const virtualXOpts = $xeTable.computeVirtualXOpts;
-        if (virtualXOpts.immediate) {
-            loadScrollXData($xeTable);
-        }
-        else {
-            lazyScrollXData($xeTable);
-        }
+        // const virtualXOpts = $xeTable.computeVirtualXOpts
+        // if (virtualXOpts.immediate) {
+        loadScrollXData($xeTable);
+        // } else {
+        //   lazyScrollXData($xeTable)
+        // }
     },
     /**
      * 纵向 Y 可视渲染事件处理
      */
     triggerScrollYEvent() {
         const $xeTable = this;
-        const virtualYOpts = $xeTable.computeVirtualYOpts;
-        if (virtualYOpts.immediate) {
-            loadScrollYData($xeTable);
-        }
-        else {
-            lazyScrollYData($xeTable);
-        }
+        // const virtualYOpts = $xeTable.computeVirtualYOpts
+        // if (virtualYOpts.immediate) {
+        loadScrollYData($xeTable);
+        // } else {
+        //   lazyScrollYData($xeTable)
+        // }
     },
     triggerBodyScrollEvent(evnt, fixedType) {
         const $xeTable = this;
@@ -9585,48 +9584,42 @@ const Methods = {
      */
     scrollTo(scrollLeft, scrollTop) {
         const $xeTable = this;
+        const reactData = $xeTable;
         const internalData = $xeTable;
-        const { $refs } = this;
-        const { refTableBody, refTableHeader, leftBody, rightBody, refTableFooter } = $refs;
-        const tableBodyElem = refTableBody ? refTableBody.$el : null;
-        const leftBodyElem = leftBody ? leftBody.$el : null;
-        const rightBodyElem = rightBody ? rightBody.$el : null;
-        const tableHeaderElem = refTableHeader ? refTableHeader.$el : null;
-        const tableFooterElem = refTableFooter ? refTableFooter.$el : null;
+        const { elemStore } = internalData;
+        const headerScrollElem = getRefElem(elemStore['main-header-scroll']);
+        const bodyScrollElem = getRefElem(elemStore['main-body-scroll']);
+        const footerScrollElem = getRefElem(elemStore['main-footer-scroll']);
+        const leftScrollElem = getRefElem(elemStore['left-body-scroll']);
+        const rightScrollElem = getRefElem(elemStore['right-body-scroll']);
+        const xHandleEl = $xeTable.$refs.refScrollXHandleElem;
+        const yHandleEl = $xeTable.$refs.refScrollYHandleElem;
         internalData.intoRunScroll = true;
         if (XEUtils.isNumber(scrollLeft)) {
-            const xHandleEl = $xeTable.$refs.refScrollXHandleElem;
-            if (xHandleEl) {
-                setScrollLeft(xHandleEl, scrollLeft);
-            }
-            else {
-                setScrollLeft(tableBodyElem, scrollLeft);
-                setScrollLeft(tableHeaderElem, scrollLeft);
-                setScrollLeft(tableFooterElem, scrollLeft);
-            }
+            setScrollLeft(xHandleEl, scrollLeft);
+            setScrollLeft(bodyScrollElem, scrollLeft);
+            setScrollLeft(headerScrollElem, scrollLeft);
+            setScrollLeft(footerScrollElem, scrollLeft);
+            loadScrollXData($xeTable);
         }
         if (XEUtils.isNumber(scrollTop)) {
-            const yHandleEl = $xeTable.$refs.refScrollYHandleElem;
-            if (yHandleEl) {
-                setScrollTop(yHandleEl, scrollTop);
-            }
-            else {
-                setScrollTop(tableBodyElem, scrollTop);
-                setScrollTop(leftBodyElem, scrollTop);
-                setScrollTop(rightBodyElem, scrollTop);
-            }
+            setScrollTop(yHandleEl, scrollTop);
+            setScrollTop(bodyScrollElem, scrollTop);
+            setScrollTop(leftScrollElem, scrollTop);
+            setScrollTop(rightScrollElem, scrollTop);
+            loadScrollYData($xeTable);
         }
-        if (this.scrollXLoad || this.scrollYLoad) {
+        if (reactData.scrollXLoad || reactData.scrollYLoad) {
             return new Promise(resolve => {
                 setTimeout(() => {
                     $xeTable.$nextTick(() => {
                         internalData.intoRunScroll = false;
                         resolve();
                     });
-                });
+                }, 30);
             });
         }
-        return this.$nextTick();
+        return $xeTable.$nextTick();
     },
     /**
      * 如果有滚动条，则滚动到对应的行
@@ -9635,15 +9628,16 @@ const Methods = {
      */
     scrollToRow(row, fieldOrColumn) {
         const $xeTable = this;
+        const props = $xeTable;
         const reactData = $xeTable;
         const { isAllOverflow, scrollYLoad, scrollXLoad } = reactData;
         const rest = [];
         if (row) {
-            if (this.treeConfig) {
-                rest.push(this.scrollToTreeRow(row));
+            if (props.treeConfig) {
+                rest.push($xeTable.scrollToTreeRow(row));
             }
             else {
-                rest.push(rowToVisible(this, row));
+                rest.push(rowToVisible($xeTable, row));
             }
         }
         if (fieldOrColumn) {

package/es/table/src/table.js

@@ -1414,6 +1414,7 @@ export default {
             insertRowMaps: {},
             // 已删除行
             removeRowMaps: {},
+            cvCacheMaps: {},
             swYSize: 0,
             swYInterval: 0,
             swYTotal: 0
@@ -1709,10 +1710,14 @@ export default {
     },
     beforeDestroy() {
         const $xeTable = this;
+        const internalData = $xeTable;
         const tableViewportEl = $xeTable.$refs.refTableViewportElem;
         if (tableViewportEl) {
             tableViewportEl.removeEventListener('wheel', $xeTable.triggerBodyWheelEvent);
         }
+        internalData.cvCacheMaps = {};
+        internalData.prevDragRow = null;
+        internalData.prevDragCol = null;
         if (this.$resize) {
             this.$resize.disconnect();
         }

package/es/table/src/util.js

@@ -64,22 +64,18 @@ export const convertHeaderColumnToRows = (originColumns) => {
 };
 export function restoreScrollLocation($xeTable, scrollLeft, scrollTop) {
     const internalData = $xeTable;
-    return $xeTable.clearScroll().then(() => {
-        if (scrollLeft || scrollTop) {
-            // 重置最后滚动状态
-            internalData.lastScrollLeft = 0;
-            internalData.lastScrollTop = 0;
-            internalData.intoRunScroll = false;
-            internalData.inVirtualScroll = false;
-            internalData.inWheelScroll = false;
-            internalData.inHeaderScroll = false;
-            internalData.inBodyScroll = false;
-            internalData.inFooterScroll = false;
-            internalData.scrollRenderType = '';
-            // 还原滚动状态
-            return $xeTable.scrollTo(scrollLeft, scrollTop);
-        }
-    });
+    if (scrollLeft || scrollTop) {
+        internalData.intoRunScroll = false;
+        internalData.inVirtualScroll = false;
+        internalData.inWheelScroll = false;
+        internalData.inHeaderScroll = false;
+        internalData.inBodyScroll = false;
+        internalData.inFooterScroll = false;
+        internalData.scrollRenderType = '';
+        // 还原滚动状态
+        return $xeTable.scrollTo(scrollLeft, scrollTop);
+    }
+    return $xeTable.$nextTick();
 }
 export function toTreePathSeq(path) {
     return path.map((num, i) => i % 2 === 0 ? (Number(num) + 1) : '.').join('');

package/es/table/style.css

@@ -2327,6 +2327,30 @@
 .vxe-header--column .vxe-cell-title-suffix-icon {
   cursor: help;
 }
+.vxe-header--column .vxe-cell-title-prefix-icon.theme--primary,
+.vxe-header--column .vxe-cell-title-suffix-icon.theme--primary {
+  color: var(--vxe-ui-font-primary-color);
+}
+.vxe-header--column .vxe-cell-title-prefix-icon.theme--success,
+.vxe-header--column .vxe-cell-title-suffix-icon.theme--success {
+  color: var(--vxe-ui-status-success-color);
+}
+.vxe-header--column .vxe-cell-title-prefix-icon.theme--info,
+.vxe-header--column .vxe-cell-title-suffix-icon.theme--info {
+  color: var(--vxe-ui-status-info-color);
+}
+.vxe-header--column .vxe-cell-title-prefix-icon.theme--warning,
+.vxe-header--column .vxe-cell-title-suffix-icon.theme--warning {
+  color: var(--vxe-ui-status-warning-color);
+}
+.vxe-header--column .vxe-cell-title-prefix-icon.theme--danger,
+.vxe-header--column .vxe-cell-title-suffix-icon.theme--danger {
+  color: var(--vxe-ui-status-danger-color);
+}
+.vxe-header--column .vxe-cell-title-prefix-icon.theme--error,
+.vxe-header--column .vxe-cell-title-suffix-icon.theme--error {
+  color: var(--vxe-ui-status-error-color);
+}
 
 .vxe-cell--col-resizable {
   position: absolute;