@fecp/mobile 1.1.53 → 1.1.55

package/es/node_modules/.pnpm/vxe-table@4.13.2_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/module/filter/panel.mjs

@@ -0,0 +1,220 @@
+import { defineComponent, inject, ref, computed, h, Teleport } from "vue";
+import "../../../ui/index.mjs";
+import { isEnableConf, formatText } from "../../../ui/src/utils.mjs";
+import { getPropClass } from "../../../ui/src/dom.mjs";
+import { getSlotVNs } from "../../../ui/src/vn.mjs";
+import XEUtils from "../../../../../../../../../_virtual/index.mjs";
+import { VxeUI } from "../../../../../../../@vxe-ui_core@4.2.12_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.mjs";
+const { getI18n, getIcon, renderer } = VxeUI;
+const TableFilterPanelComponent = defineComponent({
+  name: "VxeTableFilterPanel",
+  props: {
+    filterStore: Object
+  },
+  setup(props, context) {
+    const xID = XEUtils.uniqueId();
+    const $xeTable = inject("$xeTable", {});
+    const { reactData: tableReactData, internalData: tableInternalData, getComputeMaps } = $xeTable;
+    const { computeFilterOpts } = getComputeMaps();
+    const refElem = ref();
+    const refMaps = {
+      refElem
+    };
+    const $xeFilterPanel = {
+      xID,
+      props,
+      context,
+      getRefMaps: () => refMaps
+    };
+    const computeHasCheckOption = computed(() => {
+      const { filterStore } = props;
+      return filterStore && filterStore.options.some((option) => option.checked);
+    });
+    const filterCheckAllEvent = (evnt, value) => {
+      const { filterStore } = props;
+      filterStore.options.forEach((option) => {
+        option._checked = value;
+        option.checked = value;
+      });
+      filterStore.isAllSelected = value;
+      filterStore.isIndeterminate = false;
+    };
+    const confirmFilter = (evnt) => {
+      $xeTable.handleFilterConfirmFilter(evnt);
+    };
+    const changeRadioOption = (evnt, checked, item) => {
+      $xeTable.handleFilterChangeRadioOption(evnt, checked, item);
+    };
+    const resetFilter = (evnt) => {
+      $xeTable.handleFilterResetFilter(evnt);
+    };
+    const changeMultipleOption = (evnt, checked, item) => {
+      $xeTable.handleFilterChangeMultipleOption(evnt, checked, item);
+    };
+    const changeOption = (evnt, checked, item) => {
+      $xeTable.handleFilterChangeOption(evnt, checked, item);
+    };
+    const changeAllOption = (evnt, checked) => {
+      const { filterStore } = props;
+      if (filterStore.multiple) {
+        filterCheckAllEvent(evnt, checked);
+      } else {
+        resetFilter(evnt);
+      }
+    };
+    const filterPanelMethods = {
+      changeRadioOption,
+      changeMultipleOption,
+      changeAllOption,
+      changeOption,
+      confirmFilter,
+      resetFilter
+    };
+    Object.assign($xeFilterPanel, filterPanelMethods);
+    const renderOptions = (filterRender, compConf) => {
+      const { filterStore } = props;
+      const { column, multiple, maxHeight } = filterStore;
+      const slots = column ? column.slots : null;
+      const filterSlot = slots ? slots.filter : null;
+      const params = Object.assign({}, tableInternalData._currFilterParams, { $panel: $xeFilterPanel, $table: $xeTable });
+      const rtFilter = compConf ? compConf.renderTableFilter || compConf.renderFilter : null;
+      if (filterSlot) {
+        return [
+          h("div", {
+            class: "vxe-table--filter-template",
+            style: maxHeight ? {
+              maxHeight: `${maxHeight}px`
+            } : {}
+          }, $xeTable.callSlot(filterSlot, params))
+        ];
+      } else if (rtFilter) {
+        return [
+          h("div", {
+            class: "vxe-table--filter-template",
+            style: maxHeight ? {
+              maxHeight: `${maxHeight}px`
+            } : {}
+          }, getSlotVNs(rtFilter(filterRender, params)))
+        ];
+      }
+      const isAllChecked = multiple ? filterStore.isAllSelected : !filterStore.options.some((item) => item._checked);
+      const isAllIndeterminate = multiple && filterStore.isIndeterminate;
+      return [
+        h("ul", {
+          class: "vxe-table--filter-header"
+        }, [
+          h("li", {
+            class: ["vxe-table--filter-option", {
+              "is--checked": isAllChecked,
+              "is--indeterminate": isAllIndeterminate
+            }],
+            title: getI18n(multiple ? "vxe.table.allTitle" : "vxe.table.allFilter"),
+            onClick: (evnt) => {
+              changeAllOption(evnt, !filterStore.isAllSelected);
+            }
+          }, (multiple ? [
+            h("span", {
+              class: ["vxe-checkbox--icon", isAllIndeterminate ? getIcon().TABLE_CHECKBOX_INDETERMINATE : isAllChecked ? getIcon().TABLE_CHECKBOX_CHECKED : getIcon().TABLE_CHECKBOX_UNCHECKED]
+            })
+          ] : []).concat([
+            h("span", {
+              class: "vxe-checkbox--label"
+            }, getI18n("vxe.table.allFilter"))
+          ]))
+        ]),
+        h("ul", {
+          class: "vxe-table--filter-body",
+          style: maxHeight ? {
+            maxHeight: `${maxHeight}px`
+          } : {}
+        }, filterStore.options.map((item) => {
+          const isChecked = item._checked;
+          return h("li", {
+            class: ["vxe-table--filter-option", {
+              "is--checked": item._checked
+            }],
+            title: item.label,
+            onClick: (evnt) => {
+              changeOption(evnt, !item._checked, item);
+            }
+          }, (multiple ? [
+            h("span", {
+              class: ["vxe-checkbox--icon", isChecked ? getIcon().TABLE_CHECKBOX_CHECKED : getIcon().TABLE_CHECKBOX_UNCHECKED]
+            })
+          ] : []).concat([
+            h("span", {
+              class: "vxe-checkbox--label"
+            }, formatText(item.label, 1))
+          ]));
+        }))
+      ];
+    };
+    const renderFooters = () => {
+      const { filterStore } = props;
+      const { column, multiple } = filterStore;
+      const filterOpts = computeFilterOpts.value;
+      const hasCheckOption = computeHasCheckOption.value;
+      const { filterRender } = column;
+      const compConf = isEnableConf(filterRender) ? renderer.get(filterRender.name) : null;
+      const isDisabled = !hasCheckOption && !filterStore.isAllSelected && !filterStore.isIndeterminate;
+      return multiple && (compConf ? !(compConf.showTableFilterFooter === false || compConf.showFilterFooter === false || compConf.isFooter === false) : true) ? [
+        h("div", {
+          class: "vxe-table--filter-footer"
+        }, [
+          h("button", {
+            class: {
+              "is--disabled": isDisabled
+            },
+            disabled: isDisabled,
+            onClick: confirmFilter
+          }, filterOpts.confirmButtonText || getI18n("vxe.table.confirmFilter")),
+          h("button", {
+            onClick: resetFilter
+          }, filterOpts.resetButtonText || getI18n("vxe.table.resetFilter"))
+        ])
+      ] : [];
+    };
+    const renderVN = () => {
+      const { filterStore } = props;
+      const { initStore } = tableReactData;
+      const { visible, multiple, column } = filterStore;
+      const filterRender = column ? column.filterRender : null;
+      const compConf = isEnableConf(filterRender) ? renderer.get(filterRender.name) : null;
+      const filterClassName = compConf ? compConf.tableFilterClassName || compConf.filterClassName : "";
+      const params = Object.assign({}, tableInternalData._currFilterParams, { $panel: $xeFilterPanel, $table: $xeTable });
+      const tableProps = $xeTable.props;
+      const { computeSize } = $xeTable.getComputeMaps();
+      const vSize = computeSize.value;
+      const filterOpts = computeFilterOpts.value;
+      const { transfer, destroyOnClose } = filterOpts;
+      return h(Teleport, {
+        to: "body",
+        disabled: !transfer
+      }, [
+        h("div", {
+          ref: refElem,
+          class: [
+            "vxe-table--filter-wrapper",
+            "filter--prevent-default",
+            getPropClass(filterClassName, params),
+            {
+              [`size--${vSize}`]: vSize,
+              "is--animat": tableProps.animat,
+              "is--multiple": multiple,
+              "is--active": visible
+            }
+          ],
+          style: filterStore.style
+        }, initStore.filter && (destroyOnClose ? visible : true) && column ? renderOptions(filterRender, compConf).concat(renderFooters()) : [])
+      ]);
+    };
+    $xeFilterPanel.renderVN = renderVN;
+    return $xeFilterPanel;
+  },
+  render() {
+    return this.renderVN();
+  }
+});
+export {
+  TableFilterPanelComponent as default
+};

package/es/node_modules/.pnpm/vxe-table@4.13.2_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/module/keyboard/hook.mjs

@@ -0,0 +1,473 @@
+import XEUtils from "../../../../../../../../../_virtual/index.mjs";
+import "../../../ui/index.mjs";
+import { getRefElem } from "../../src/util.mjs";
+import { addClass, getAbsolutePos, removeClass, hasClass } from "../../../ui/src/dom.mjs";
+import { VxeUI } from "../../../../../../../@vxe-ui_core@4.2.12_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.mjs";
+const { hooks } = VxeUI;
+const browseObj = XEUtils.browse();
+function getTargetOffset(target, container) {
+  let offsetTop = 0;
+  let offsetLeft = 0;
+  const triggerCheckboxLabel = !browseObj.firefox && hasClass(target, "vxe-checkbox--label");
+  if (triggerCheckboxLabel) {
+    const checkboxLabelStyle = getComputedStyle(target);
+    offsetTop -= XEUtils.toNumber(checkboxLabelStyle.paddingTop);
+    offsetLeft -= XEUtils.toNumber(checkboxLabelStyle.paddingLeft);
+  }
+  while (target && target !== container) {
+    offsetTop += target.offsetTop;
+    offsetLeft += target.offsetLeft;
+    target = target.offsetParent;
+    if (triggerCheckboxLabel) {
+      const checkboxStyle = getComputedStyle(target);
+      offsetTop -= XEUtils.toNumber(checkboxStyle.paddingTop);
+      offsetLeft -= XEUtils.toNumber(checkboxStyle.paddingLeft);
+    }
+  }
+  return { offsetTop, offsetLeft };
+}
+hooks.add("tableKeyboardModule", {
+  setupTable($xeTable) {
+    const { props, reactData, internalData } = $xeTable;
+    const { refElem } = $xeTable.getRefMaps();
+    const { computeEditOpts, computeCheckboxOpts, computeMouseOpts, computeTreeOpts, computeRowOpts, computeColumnOpts, computeCellOpts, computeDefaultRowHeight, computeCurrentRowOpts, computeCurrentColumnOpts } = $xeTable.getComputeMaps();
+    function getCheckboxRangeRows(evnt, params, targetTrElem, trRect, offsetClientTop, moveRange) {
+      const { showOverflow } = props;
+      const { fullAllDataRowIdData, isResizeCellHeight } = internalData;
+      const rowOpts = computeRowOpts.value;
+      const cellOpts = computeCellOpts.value;
+      const defaultRowHeight = computeDefaultRowHeight.value;
+      const { row } = params;
+      let countHeight = 0;
+      let rangeRows = [];
+      let moveSize = 0;
+      const isDown = moveRange > 0;
+      const { scrollYLoad } = reactData;
+      const { afterFullData } = internalData;
+      if (isDown) {
+        moveSize = offsetClientTop + moveRange;
+      } else {
+        moveSize = trRect.height - offsetClientTop + Math.abs(moveRange);
+      }
+      if (scrollYLoad) {
+        const _rowIndex = $xeTable.getVTRowIndex(row);
+        const isCustomCellHeight = isResizeCellHeight || cellOpts.height || rowOpts.height;
+        if (!isCustomCellHeight && showOverflow) {
+          if (isDown) {
+            rangeRows = afterFullData.slice(_rowIndex, _rowIndex + Math.ceil(moveSize / defaultRowHeight));
+          } else {
+            rangeRows = afterFullData.slice(_rowIndex - Math.floor(moveSize / defaultRowHeight), _rowIndex + 1);
+          }
+        } else {
+          if (isDown) {
+            for (let i = _rowIndex; i < afterFullData.length; i++) {
+              const item = afterFullData[i];
+              const rowid = $xeTable.getRowid(item);
+              const rowRest = fullAllDataRowIdData[rowid] || {};
+              countHeight += rowRest.resizeHeight || cellOpts.height || rowOpts.height || rowRest.height || defaultRowHeight;
+              rangeRows.push(item);
+              if (countHeight > moveSize) {
+                return rangeRows;
+              }
+            }
+          } else {
+            for (let len = _rowIndex; len >= 0; len--) {
+              const item = afterFullData[len];
+              const rowid = $xeTable.getRowid(item);
+              const rowRest = fullAllDataRowIdData[rowid] || {};
+              countHeight += rowRest.resizeHeight || cellOpts.height || rowOpts.height || rowRest.height || defaultRowHeight;
+              rangeRows.push(item);
+              if (countHeight > moveSize) {
+                return rangeRows;
+              }
+            }
+          }
+        }
+      } else {
+        const siblingProp = isDown ? "next" : "previous";
+        while (targetTrElem && countHeight < moveSize) {
+          const rowNodeRest = $xeTable.getRowNode(targetTrElem);
+          if (rowNodeRest) {
+            rangeRows.push(rowNodeRest.item);
+            countHeight += targetTrElem.offsetHeight;
+            targetTrElem = targetTrElem[`${siblingProp}ElementSibling`];
+          }
+        }
+      }
+      return rangeRows;
+    }
+    const handleCheckboxRangeEvent = (evnt, params) => {
+      const { elemStore } = internalData;
+      const bodyScrollElem = getRefElem(elemStore["main-body-scroll"]);
+      const leftScrollElem = getRefElem(elemStore["left-body-scroll"]);
+      const rightScrollElem = getRefElem(elemStore["right-body-scroll"]);
+      const { column, cell } = params;
+      if (column.type === "checkbox") {
+        let bodyWrapperElem = bodyScrollElem;
+        if (leftScrollElem && column.fixed === "left") {
+          bodyWrapperElem = leftScrollElem;
+        } else if (rightScrollElem && column.fixed === "right") {
+          bodyWrapperElem = rightScrollElem;
+        }
+        if (!bodyWrapperElem) {
+          return;
+        }
+        const el = refElem.value;
+        const disX = evnt.clientX;
+        const disY = evnt.clientY;
+        const checkboxRangeElem = bodyWrapperElem.querySelector(".vxe-table--checkbox-range");
+        const trElem = cell.parentElement;
+        const selectRecords = $xeTable.getCheckboxRecords();
+        let lastRangeRows = [];
+        const marginSize = 1;
+        const offsetRest = getTargetOffset(evnt.target, bodyWrapperElem);
+        const startTop = offsetRest.offsetTop + evnt.offsetY;
+        const startLeft = offsetRest.offsetLeft + evnt.offsetX;
+        const startScrollTop = bodyWrapperElem.scrollTop;
+        const rowHeight = trElem.offsetHeight;
+        const trRect = trElem.getBoundingClientRect();
+        const offsetClientTop = disY - trRect.y;
+        let mouseScrollTimeout = null;
+        let isMouseScrollDown = false;
+        let mouseScrollSpaceSize = 1;
+        const triggerEvent = (type, evnt2) => {
+          $xeTable.dispatchEvent(`checkbox-range-${type}`, { records: $xeTable.getCheckboxRecords(), reserves: $xeTable.getCheckboxReserveRecords() }, evnt2);
+        };
+        const handleChecked = (evnt2) => {
+          const { clientX, clientY } = evnt2;
+          const offsetLeft = clientX - disX;
+          const offsetTop = clientY - disY + (bodyWrapperElem.scrollTop - startScrollTop);
+          let rangeHeight = Math.abs(offsetTop);
+          let rangeWidth = Math.abs(offsetLeft);
+          let rangeTop = startTop;
+          let rangeLeft = startLeft;
+          if (offsetTop < marginSize) {
+            rangeTop += offsetTop;
+            if (rangeTop < marginSize) {
+              rangeTop = marginSize;
+              rangeHeight = startTop;
+            }
+          } else {
+            rangeHeight = Math.min(rangeHeight, bodyWrapperElem.scrollHeight - startTop - marginSize);
+          }
+          if (offsetLeft < marginSize) {
+            rangeLeft += offsetLeft;
+            if (rangeWidth > startLeft) {
+              rangeLeft = marginSize;
+              rangeWidth = startLeft;
+            }
+          } else {
+            rangeWidth = Math.min(rangeWidth, bodyWrapperElem.clientWidth - startLeft - marginSize);
+          }
+          checkboxRangeElem.style.height = `${rangeHeight}px`;
+          checkboxRangeElem.style.width = `${rangeWidth}px`;
+          checkboxRangeElem.style.left = `${rangeLeft}px`;
+          checkboxRangeElem.style.top = `${rangeTop}px`;
+          checkboxRangeElem.style.display = "block";
+          const rangeRows = getCheckboxRangeRows(evnt2, params, trElem, trRect, offsetClientTop, offsetTop < marginSize ? -rangeHeight : rangeHeight);
+          if (rangeHeight > 10 && rangeRows.length !== lastRangeRows.length) {
+            lastRangeRows = rangeRows;
+            if (evnt2.ctrlKey) {
+              rangeRows.forEach((row) => {
+                $xeTable.handleBatchSelectRows([row], selectRecords.indexOf(row) === -1);
+              });
+            } else {
+              $xeTable.setAllCheckboxRow(false);
+              $xeTable.handleCheckedCheckboxRow(rangeRows, true, false);
+            }
+            triggerEvent("change", evnt2);
+          }
+        };
+        const stopMouseScroll = () => {
+          clearTimeout(mouseScrollTimeout);
+          mouseScrollTimeout = null;
+        };
+        const startMouseScroll = (evnt2) => {
+          stopMouseScroll();
+          mouseScrollTimeout = setTimeout(() => {
+            if (mouseScrollTimeout) {
+              const { scrollLeft, scrollTop, clientHeight, scrollHeight } = bodyWrapperElem;
+              const topSize = Math.ceil(mouseScrollSpaceSize * 50 / rowHeight);
+              if (isMouseScrollDown) {
+                if (scrollTop + clientHeight < scrollHeight) {
+                  $xeTable.scrollTo(scrollLeft, scrollTop + topSize);
+                  startMouseScroll(evnt2);
+                  handleChecked(evnt2);
+                } else {
+                  stopMouseScroll();
+                }
+              } else {
+                if (scrollTop) {
+                  $xeTable.scrollTo(scrollLeft, scrollTop - topSize);
+                  startMouseScroll(evnt2);
+                  handleChecked(evnt2);
+                } else {
+                  stopMouseScroll();
+                }
+              }
+            }
+          }, 50);
+        };
+        addClass(el, "drag--range");
+        document.onmousemove = (evnt2) => {
+          evnt2.preventDefault();
+          evnt2.stopPropagation();
+          const { clientY } = evnt2;
+          const { boundingTop } = getAbsolutePos(bodyWrapperElem);
+          if (clientY < boundingTop) {
+            isMouseScrollDown = false;
+            mouseScrollSpaceSize = boundingTop - clientY;
+            if (!mouseScrollTimeout) {
+              startMouseScroll(evnt2);
+            }
+          } else if (clientY > boundingTop + bodyWrapperElem.clientHeight) {
+            isMouseScrollDown = true;
+            mouseScrollSpaceSize = clientY - boundingTop - bodyWrapperElem.clientHeight;
+            if (!mouseScrollTimeout) {
+              startMouseScroll(evnt2);
+            }
+          } else if (mouseScrollTimeout) {
+            stopMouseScroll();
+          }
+          handleChecked(evnt2);
+        };
+        document.onmouseup = (evnt2) => {
+          stopMouseScroll();
+          removeClass(el, "drag--range");
+          checkboxRangeElem.removeAttribute("style");
+          document.onmousemove = null;
+          document.onmouseup = null;
+          triggerEvent("end", evnt2);
+        };
+        triggerEvent("start", evnt);
+      }
+    };
+    const handleCellMousedownEvent = (evnt, params) => {
+      const { editConfig, checkboxConfig, mouseConfig } = props;
+      const checkboxOpts = computeCheckboxOpts.value;
+      const mouseOpts = computeMouseOpts.value;
+      const editOpts = computeEditOpts.value;
+      if (mouseConfig && mouseOpts.area && $xeTable.triggerCellAreaMousedownEvent) {
+        return $xeTable.triggerCellAreaMousedownEvent(evnt, params);
+      } else {
+        if (checkboxConfig && checkboxOpts.range) {
+          handleCheckboxRangeEvent(evnt, params);
+        }
+        if (mouseConfig && mouseOpts.selected) {
+          if (!editConfig || editOpts.mode === "cell") {
+            $xeTable.handleSelected(params, evnt);
+          }
+        }
+      }
+    };
+    const handleMoveSelected = (evnt, args, isLeftArrow, isUpArrow, isRightArrow, isDwArrow) => {
+      const { afterFullData, visibleColumn } = internalData;
+      const params = Object.assign({}, args);
+      const _rowIndex = $xeTable.getVTRowIndex(params.row);
+      const _columnIndex = $xeTable.getVTColumnIndex(params.column);
+      evnt.preventDefault();
+      if (isUpArrow && _rowIndex > 0) {
+        params.rowIndex = _rowIndex - 1;
+        params.row = afterFullData[params.rowIndex];
+      } else if (isDwArrow && _rowIndex < afterFullData.length - 1) {
+        params.rowIndex = _rowIndex + 1;
+        params.row = afterFullData[params.rowIndex];
+      } else if (isLeftArrow && _columnIndex) {
+        params.columnIndex = _columnIndex - 1;
+        params.column = visibleColumn[params.columnIndex];
+      } else if (isRightArrow && _columnIndex < visibleColumn.length - 1) {
+        params.columnIndex = _columnIndex + 1;
+        params.column = visibleColumn[params.columnIndex];
+      }
+      $xeTable.scrollToRow(params.row, params.column).then(() => {
+        params.cell = $xeTable.getCellElement(params.row, params.column);
+        $xeTable.handleSelected(params, evnt);
+      });
+      return params;
+    };
+    const keyboardMethods = {
+      // 处理 Tab 键移动
+      moveTabSelected(args, isLeft, evnt) {
+        const { editConfig } = props;
+        const { afterFullData, visibleColumn } = internalData;
+        const editOpts = computeEditOpts.value;
+        const rowOpts = computeRowOpts.value;
+        const currentRowOpts = computeCurrentRowOpts.value;
+        const columnOpts = computeColumnOpts.value;
+        const currentColumnOpts = computeCurrentColumnOpts.value;
+        let targetRow;
+        let targetRowIndex;
+        let targetColumnIndex;
+        const params = Object.assign({}, args);
+        const _rowIndex = $xeTable.getVTRowIndex(params.row);
+        const _columnIndex = $xeTable.getVTColumnIndex(params.column);
+        evnt.preventDefault();
+        if (isLeft) {
+          if (_columnIndex <= 0) {
+            if (_rowIndex > 0) {
+              targetRowIndex = _rowIndex - 1;
+              targetRow = afterFullData[targetRowIndex];
+              targetColumnIndex = visibleColumn.length - 1;
+            }
+          } else {
+            targetColumnIndex = _columnIndex - 1;
+          }
+        } else {
+          if (_columnIndex >= visibleColumn.length - 1) {
+            if (_rowIndex < afterFullData.length - 1) {
+              targetRowIndex = _rowIndex + 1;
+              targetRow = afterFullData[targetRowIndex];
+              targetColumnIndex = 0;
+            }
+          } else {
+            targetColumnIndex = _columnIndex + 1;
+          }
+        }
+        const targetColumn = visibleColumn[targetColumnIndex];
+        if (targetColumn) {
+          if (targetRow) {
+            params.rowIndex = targetRowIndex;
+            params.row = targetRow;
+          } else {
+            params.rowIndex = _rowIndex;
+          }
+          params.columnIndex = targetColumnIndex;
+          params.column = targetColumn;
+          params.cell = $xeTable.getCellElement(params.row, params.column);
+          if (rowOpts.isCurrent && currentRowOpts.isFollowSelected) {
+            $xeTable.triggerCurrentRowEvent(evnt, params);
+          }
+          if (columnOpts.isCurrent && currentColumnOpts.isFollowSelected) {
+            $xeTable.triggerCurrentColumnEvent(evnt, params);
+          }
+          if (editConfig) {
+            if (editOpts.trigger === "click" || editOpts.trigger === "dblclick") {
+              if (editOpts.mode === "row") {
+                $xeTable.handleEdit(params, evnt);
+              } else {
+                $xeTable.scrollToRow(params.row, params.column).then(() => {
+                  $xeTable.handleSelected(params, evnt);
+                });
+              }
+            }
+          } else {
+            $xeTable.scrollToRow(params.row, params.column).then(() => {
+              $xeTable.handleSelected(params, evnt);
+            });
+          }
+        }
+      },
+      // 处理当前行方向键移动
+      moveCurrentRow(isUpArrow, isDwArrow, evnt) {
+        const { treeConfig } = props;
+        const { currentRow } = reactData;
+        const { afterFullData } = internalData;
+        const treeOpts = computeTreeOpts.value;
+        const childrenField = treeOpts.children || treeOpts.childrenField;
+        let targetRow;
+        if (currentRow) {
+          if (treeConfig) {
+            const { index, items } = XEUtils.findTree(afterFullData, (item) => item === currentRow, { children: childrenField });
+            if (isUpArrow && index > 0) {
+              targetRow = items[index - 1];
+            } else if (isDwArrow && index < items.length - 1) {
+              targetRow = items[index + 1];
+            }
+          } else {
+            const _rowIndex = $xeTable.getVTRowIndex(currentRow);
+            if (isUpArrow && _rowIndex > 0) {
+              targetRow = afterFullData[_rowIndex - 1];
+            } else if (isDwArrow && _rowIndex < afterFullData.length - 1) {
+              targetRow = afterFullData[_rowIndex + 1];
+            }
+          }
+        } else {
+          targetRow = afterFullData[0];
+        }
+        if (targetRow) {
+          evnt.preventDefault();
+          const params = {
+            $table: $xeTable,
+            row: targetRow,
+            rowIndex: $xeTable.getRowIndex(targetRow),
+            $rowIndex: $xeTable.getVMRowIndex(targetRow)
+          };
+          $xeTable.scrollToRow(targetRow).then(() => $xeTable.triggerCurrentRowEvent(evnt, params));
+        }
+      },
+      // 处理当前列方向键移动
+      moveCurrentColumn(isLeftArrow, isRightArrow, evnt) {
+        const { currentColumn } = reactData;
+        const { visibleColumn } = internalData;
+        let targetCol = null;
+        if (currentColumn) {
+          const _columnIndex = $xeTable.getVTColumnIndex(currentColumn);
+          if (isLeftArrow && _columnIndex > 0) {
+            targetCol = visibleColumn[_columnIndex - 1];
+          } else if (isRightArrow && _columnIndex < visibleColumn.length - 1) {
+            targetCol = visibleColumn[_columnIndex + 1];
+          }
+        } else {
+          targetCol = visibleColumn[0];
+        }
+        if (targetCol) {
+          evnt.preventDefault();
+          const params = {
+            $table: $xeTable,
+            column: targetCol,
+            columnIndex: $xeTable.getColumnIndex(targetCol),
+            $columnIndex: $xeTable.getVMColumnIndex(targetCol)
+          };
+          $xeTable.scrollToColumn(targetCol).then(() => $xeTable.triggerCurrentColumnEvent(evnt, params));
+        }
+      },
+      // 处理可编辑方向键移动
+      moveArrowSelected(args, isLeftArrow, isUpArrow, isRightArrow, isDwArrow, evnt) {
+        const { highlightCurrentRow, highlightCurrentColumn } = props;
+        const rowOpts = computeRowOpts.value;
+        const currentRowOpts = computeCurrentRowOpts.value;
+        const columnOpts = computeColumnOpts.value;
+        const currentColumnOpts = computeCurrentColumnOpts.value;
+        const params = handleMoveSelected(evnt, args, isLeftArrow, isUpArrow, isRightArrow, isDwArrow);
+        if (rowOpts.isCurrent || highlightCurrentRow) {
+          if (currentRowOpts.isFollowSelected) {
+            $xeTable.triggerCurrentRowEvent(evnt, params);
+          } else {
+            if ((isUpArrow || isDwArrow) && (rowOpts.isCurrent || highlightCurrentRow)) {
+              $xeTable.moveCurrentRow(isUpArrow, isDwArrow, evnt);
+            }
+          }
+        }
+        if (columnOpts.isCurrent || highlightCurrentColumn) {
+          if (currentColumnOpts.isFollowSelected) {
+            $xeTable.triggerCurrentColumnEvent(evnt, params);
+          } else {
+            if ((isLeftArrow || isRightArrow) && (columnOpts.isCurrent || highlightCurrentColumn)) {
+              $xeTable.moveCurrentColumn(isLeftArrow, isRightArrow, evnt);
+            }
+          }
+        }
+      },
+      moveEnterSelected(args, isLeftArrow, isUpArrow, isRightArrow, isDwArrow, evnt) {
+        const { highlightCurrentRow, highlightCurrentColumn } = props;
+        const rowOpts = computeRowOpts.value;
+        const currentRowOpts = computeCurrentRowOpts.value;
+        const columnOpts = computeColumnOpts.value;
+        const currentColumnOpts = computeCurrentColumnOpts.value;
+        const params = handleMoveSelected(evnt, args, isLeftArrow, isUpArrow, isRightArrow, isDwArrow);
+        if ((rowOpts.isCurrent || highlightCurrentRow) && currentRowOpts.isFollowSelected) {
+          $xeTable.triggerCurrentRowEvent(evnt, params);
+        }
+        if ((columnOpts.isCurrent || highlightCurrentColumn) && currentColumnOpts.isFollowSelected) {
+          $xeTable.triggerCurrentColumnEvent(evnt, params);
+        }
+      },
+      // 已废弃，待删除
+      moveSelected(args, isLeftArrow, isUpArrow, isRightArrow, isDwArrow, evnt) {
+        handleMoveSelected(evnt, args, isLeftArrow, isUpArrow, isRightArrow, isDwArrow);
+      },
+      handleCellMousedownEvent
+    };
+    return keyboardMethods;
+  }
+});