@fecp/mobile 1.1.44 → 1.1.46

package/lib/node_modules/.pnpm/vxe-table@4.17.0_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/module/export/import-panel.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const comp = require("../../../ui/src/comp.js");
+require("../../../ui/index.js");
+const index = require("../../../../../../../../../_virtual/index.js");
+const utils = require("../../../ui/src/utils.js");
+const log = require("../../../ui/src/log.js");
+const index_esm = require("../../../../../../../@vxe-ui_core@4.2.12_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.js");
+const { getI18n, getIcon, renderEmptyElement } = index_esm.VxeUI;
+const TableImportPanelComponent = comp.defineVxeComponent({
+  name: "VxeTableImportPanel",
+  props: {
+    defaultOptions: Object,
+    storeData: Object
+  },
+  setup(props) {
+    const VxeUIModalComponent = index_esm.VxeUI.getComponent("VxeModal");
+    const VxeUIButtonComponent = index_esm.VxeUI.getComponent("VxeButton");
+    const VxeUISelectComponent = index_esm.VxeUI.getComponent("VxeSelect");
+    const $xeTable = vue.inject("$xeTable", {});
+    const { computeImportOpts } = $xeTable.getComputeMaps();
+    const reactData = vue.reactive({
+      loading: false
+    });
+    const refFileBtn = vue.ref();
+    const computeSelectName = vue.computed(() => {
+      const { storeData } = props;
+      return `${storeData.filename}.${storeData.type}`;
+    });
+    const computeHasFile = vue.computed(() => {
+      const { storeData } = props;
+      return storeData.file && storeData.type;
+    });
+    const computeParseTypeLabel = vue.computed(() => {
+      const { storeData } = props;
+      const { type, typeList } = storeData;
+      if (type) {
+        const selectItem = index.default.find(typeList, (item) => type === item.value);
+        return selectItem ? selectItem.label : "*.*";
+      }
+      return `*.${typeList.map((item) => item.value).join(", *.")}`;
+    });
+    const clearFileEvent = () => {
+      const { storeData } = props;
+      Object.assign(storeData, {
+        filename: "",
+        sheetName: "",
+        type: ""
+      });
+    };
+    const selectFileEvent = () => {
+      const { storeData, defaultOptions } = props;
+      $xeTable.readFile(defaultOptions).then((params) => {
+        const { file } = params;
+        Object.assign(storeData, utils.parseFile(file), { file });
+      }).catch((e) => e);
+    };
+    const showEvent = () => {
+      vue.nextTick(() => {
+        const targetElem = refFileBtn.value;
+        if (targetElem) {
+          targetElem.focus();
+        }
+      });
+    };
+    const cancelEvent = () => {
+      const { storeData } = props;
+      storeData.visible = false;
+    };
+    const importEvent = () => {
+      const { storeData, defaultOptions } = props;
+      const importOpts = computeImportOpts.value;
+      reactData.loading = true;
+      $xeTable.importByFile(storeData.file, Object.assign({}, importOpts, defaultOptions)).then(() => {
+        reactData.loading = false;
+        storeData.visible = false;
+      }).catch(() => {
+        reactData.loading = false;
+      });
+    };
+    const renderVN = () => {
+      const $xeGrid = $xeTable.xeGrid;
+      const $xeGantt = $xeTable.xeGantt;
+      const { defaultOptions, storeData } = props;
+      const selectName = computeSelectName.value;
+      const hasFile = computeHasFile.value;
+      const parseTypeLabel = computeParseTypeLabel.value;
+      const slots = defaultOptions.slots || {};
+      const topSlot = slots.top;
+      const bottomSlot = slots.bottom;
+      const defaultSlot = slots.default;
+      const footerSlot = slots.footer;
+      return VxeUIModalComponent ? vue.h(VxeUIModalComponent, {
+        id: "VXE_IMPORT_MODAL",
+        modelValue: storeData.visible,
+        title: getI18n("vxe.import.impTitle"),
+        className: "vxe-table-export-popup-wrapper",
+        width: 540,
+        minWidth: 360,
+        minHeight: 240,
+        mask: true,
+        lockView: true,
+        showFooter: true,
+        escClosable: true,
+        maskClosable: true,
+        showMaximize: true,
+        resize: true,
+        loading: reactData.loading,
+        "onUpdate:modelValue"(value) {
+          storeData.visible = value;
+        },
+        onShow: showEvent
+      }, {
+        default: () => {
+          const params = {
+            $table: $xeTable,
+            $grid: $xeGrid,
+            $gantt: $xeGantt,
+            options: defaultOptions,
+            params: defaultOptions.params
+          };
+          return vue.h("div", {
+            class: "vxe-table-export--panel"
+          }, [
+            topSlot ? vue.h("div", {
+              class: "vxe-table-export--panel-top"
+            }, $xeTable.callSlot(topSlot, params)) : renderEmptyElement($xeTable),
+            vue.h("div", {
+              class: "vxe-table-export--panel-body"
+            }, defaultSlot ? $xeTable.callSlot(defaultSlot, params) : [
+              vue.h("table", {
+                class: "vxe-table-export--panel-table",
+                cellspacing: 0,
+                cellpadding: 0,
+                border: 0
+              }, [
+                vue.h("tbody", [
+                  vue.h("tr", [
+                    vue.h("td", getI18n("vxe.import.impFile")),
+                    vue.h("td", [
+                      hasFile ? vue.h("div", {
+                        class: "vxe-table-export--selected--file",
+                        title: selectName
+                      }, [
+                        vue.h("span", selectName),
+                        vue.h("i", {
+                          class: getIcon().INPUT_CLEAR,
+                          onClick: clearFileEvent
+                        })
+                      ]) : vue.h("button", {
+                        ref: refFileBtn,
+                        class: "vxe-table-export--select--file",
+                        onClick: selectFileEvent
+                      }, getI18n("vxe.import.impSelect"))
+                    ])
+                  ]),
+                  vue.h("tr", [
+                    vue.h("td", getI18n("vxe.import.impType")),
+                    vue.h("td", parseTypeLabel)
+                  ]),
+                  vue.h("tr", [
+                    vue.h("td", getI18n("vxe.import.impMode")),
+                    vue.h("td", [
+                      VxeUISelectComponent ? vue.h(VxeUISelectComponent, {
+                        modelValue: defaultOptions.mode,
+                        options: storeData.modeList,
+                        "onUpdate:modelValue"(value) {
+                          defaultOptions.mode = value;
+                        }
+                      }) : renderEmptyElement($xeTable)
+                    ])
+                  ])
+                ])
+              ])
+            ]),
+            bottomSlot ? vue.h("div", {
+              class: "vxe-table-export--panel-bottom"
+            }, $xeTable.callSlot(bottomSlot, params)) : renderEmptyElement($xeTable)
+          ]);
+        },
+        footer() {
+          const params = {
+            $table: $xeTable,
+            $grid: $xeGrid,
+            $gantt: $xeGantt,
+            options: defaultOptions,
+            params: defaultOptions.params
+          };
+          return vue.h("div", {
+            class: "vxe-table-export--panel-footer"
+          }, footerSlot ? $xeTable.callSlot(footerSlot, params) : [
+            vue.h("div", {
+              class: "vxe-table-export--panel-btns"
+            }, [
+              VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
+                content: getI18n("vxe.import.impCancel"),
+                onClick: cancelEvent
+              }) : renderEmptyElement($xeTable),
+              VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
+                status: "primary",
+                disabled: !hasFile || reactData.loading,
+                content: getI18n("vxe.import.impConfirm"),
+                onClick: importEvent
+              }) : renderEmptyElement($xeTable)
+            ])
+          ]);
+        }
+      }) : renderEmptyElement($xeTable);
+    };
+    vue.nextTick(() => {
+      if (!VxeUIModalComponent) {
+        log.errLog("vxe.error.reqComp", ["vxe-modal"]);
+      }
+      if (!VxeUIButtonComponent) {
+        log.errLog("vxe.error.reqComp", ["vxe-button"]);
+      }
+      if (!VxeUISelectComponent) {
+        log.errLog("vxe.error.reqComp", ["vxe-select"]);
+      }
+    });
+    return renderVN;
+  }
+});
+exports.default = TableImportPanelComponent;

package/lib/node_modules/.pnpm/vxe-table@4.17.0_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/module/export/util.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const defaultHtmlStyle = 'body{margin:0;padding: 0 1px;color:#333333;font-size:14px;font-family:"Microsoft YaHei",微软雅黑,"MicrosoftJhengHei",华文细黑,STHeiti,MingLiu}body *{-webkit-box-sizing:border-box;box-sizing:border-box}.vxe-table{border-collapse:collapse;text-align:left;border-spacing:0}.vxe-table:not(.is--print){table-layout:fixed}.vxe-table,.vxe-table th,.vxe-table td,.vxe-table td{border-color:#D0D0D0;border-style:solid;border-width:0}.vxe-table.is--print{width:100%}.border--default,.border--full,.border--outer{border-top-width:1px}.border--default,.border--full,.border--outer{border-left-width:1px}.border--outer,.border--default th,.border--default td,.border--full th,.border--full td,.border--outer th,.border--inner th,.border--inner td{border-bottom-width:1px}.border--default,.border--outer,.border--full th,.border--full td{border-right-width:1px}.border--default th,.border--full th,.border--outer th{background-color:#f8f8f9}.vxe-table td>div,.vxe-table th>div{padding:.5em .4em}.col--center{text-align:center}.col--right{text-align:right}.vxe-table:not(.is--print) .col--ellipsis>div{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;word-break:break-all}.vxe-table--tree-node{text-align:left}.vxe-table--tree-node-wrapper{position:relative}.vxe-table--tree-icon-wrapper{position:absolute;top:50%;width:1em;height:1em;text-align:center;-webkit-transform:translateY(-50%);transform:translateY(-50%);-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:pointer}.vxe-table--tree-unfold-icon,.vxe-table--tree-fold-icon{position:absolute;width:0;height:0;border-style:solid;border-width:.5em;border-right-color:transparent;border-bottom-color:transparent}.vxe-table--tree-unfold-icon{left:.3em;top:0;border-left-color:#939599;border-top-color:transparent}.vxe-table--tree-fold-icon{left:0;top:.3em;border-left-color:transparent;border-top-color:#939599}.vxe-table--tree-cell{display:block;padding-left:1.5em}.vxe-table input[type="checkbox"]{margin:0}.vxe-table input[type="checkbox"],.vxe-table input[type="radio"],.vxe-table input[type="checkbox"]+span,.vxe-table input[type="radio"]+span{vertical-align:middle;padding-left:0.4em}';
+function getExportBlobByContent(content, options) {
+  return new Blob([content], { type: `text/${options.type};charset=utf-8;` });
+}
+function createHtmlPage(opts, content) {
+  const { style } = opts;
+  return [
+    "<!DOCTYPE html><html>",
+    "<head>",
+    '<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1,minimum-scale=1,maximum-scale=1,user-scalable=no,minimal-ui">',
+    `<title>${opts.sheetName}</title>`,
+    '<style media="print">.vxe-page-break-before{page-break-before:always;}.vxe-page-break-after{page-break-after:always;}</style>',
+    `<style>${defaultHtmlStyle}</style>`,
+    style ? `<style>${style}</style>` : "",
+    "</head>",
+    `<body>${content}</body>`,
+    "</html>"
+  ].join("");
+}
+exports.createHtmlPage = createHtmlPage;
+exports.getExportBlobByContent = getExportBlobByContent;

package/lib/node_modules/.pnpm/vxe-table@4.17.0_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/module/filter/hook.js

@@ -0,0 +1,408 @@
+"use strict";
+const vue = require("vue");
+const index = require("../../../../../../../../../_virtual/index.js");
+require("../../../ui/index.js");
+const util = require("../../src/util.js");
+const dom = require("../../../ui/src/dom.js");
+const utils = require("../../../ui/src/utils.js");
+const index_esm = require("../../../../../../../@vxe-ui_core@4.2.12_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.js");
+const { renderer, hooks } = index_esm.VxeUI;
+const tableFilterMethodKeys = ["openFilter", "setFilter", "clearFilter", "saveFilter", "saveFilterByEvent", "saveFilterPanel", "saveFilterPanelByEvent", "resetFilter", "resetFilterByEvent", "resetFilterPanel", "resetFilterPanelByEvent", "getCheckedFilters", "updateFilterOptionStatus"];
+hooks.add("tableFilterModule", {
+  setupTable($xeTable) {
+    const $xeGrid = $xeTable.xeGrid;
+    const $xeGantt = $xeTable.xeGantt;
+    const $xeGGWrapper = $xeGrid || $xeGantt;
+    const { props, reactData, internalData } = $xeTable;
+    const { refElem, refTableFilter } = $xeTable.getRefMaps();
+    const { computeFilterOpts, computeMouseOpts } = $xeTable.getComputeMaps();
+    const filterPrivateMethods = {
+      checkFilterOptions() {
+        const { filterStore } = reactData;
+        const { column } = filterStore;
+        if (column) {
+          const filterOptions = column.filters || [];
+          filterStore.isAllSelected = filterOptions.every((item) => item._checked);
+          filterStore.isIndeterminate = !filterStore.isAllSelected && filterOptions.some((item) => item._checked);
+        }
+      },
+      /**
+       * 点击筛选事件
+       * 当筛选图标被点击时触发
+       * 更新选项是否全部状态
+       * 打开筛选面板
+       * @param {Event} evnt 事件
+       * @param {ColumnInfo} column 列配置
+       * @param {Object} params 参数
+       */
+      triggerFilterEvent(evnt, column, params) {
+        const { initStore, filterStore } = reactData;
+        const { elemStore } = internalData;
+        if (filterStore.column === column && filterStore.visible) {
+          filterStore.visible = false;
+        } else {
+          const tableEl = refElem.value;
+          const { scrollTop, scrollLeft, visibleHeight, visibleWidth } = dom.getDomNode();
+          const filterOpts = computeFilterOpts.value;
+          const { transfer } = filterOpts;
+          const tableRect = tableEl.getBoundingClientRect();
+          const btnElem = evnt.currentTarget;
+          const filterRender = column ? column.filterRender : null;
+          const compConf = filterRender && utils.isEnableConf(filterRender) ? renderer.get(filterRender.name) : null;
+          $xeTable.handleFilterOptions(column);
+          internalData._currFilterParams = params;
+          filterStore.style = null;
+          filterStore.visible = true;
+          initStore.filter = true;
+          vue.nextTick(() => {
+            const headerScrollElem = util.getRefElem(elemStore["main-header-scroll"]);
+            if (!headerScrollElem) {
+              return;
+            }
+            const tableFilter = refTableFilter.value;
+            const filterWrapperElem = tableFilter ? tableFilter.getRefMaps().refElem.value : null;
+            if (!filterWrapperElem) {
+              return;
+            }
+            const btnRect = btnElem.getBoundingClientRect();
+            const filterHeadElem = filterWrapperElem.querySelector(".vxe-table--filter-header");
+            const filterFootElem = filterWrapperElem.querySelector(".vxe-table--filter-footer");
+            const filterWidth = filterWrapperElem.offsetWidth;
+            const centerWidth = filterWidth / 2;
+            let left = 0;
+            let top = 0;
+            let maxHeight = 0;
+            if (transfer) {
+              left = btnRect.left - centerWidth + scrollLeft;
+              top = btnRect.top + btnElem.clientHeight + scrollTop;
+              maxHeight = Math.min(Math.max(tableRect.height, Math.floor(visibleHeight / 2)), Math.max(80, visibleHeight - top - (filterHeadElem ? filterHeadElem.clientHeight : 0) - (filterFootElem ? filterFootElem.clientHeight : 0) - 28));
+              if (left < 16) {
+                left = 16;
+              } else if (left > visibleWidth - filterWidth - 16) {
+                left = visibleWidth - filterWidth - 16;
+              }
+            } else {
+              left = btnRect.left - tableRect.left - centerWidth;
+              top = btnRect.top - tableRect.top + btnElem.clientHeight;
+              maxHeight = Math.max(40, tableEl.clientHeight - top - (filterHeadElem ? filterHeadElem.clientHeight : 0) - (filterFootElem ? filterFootElem.clientHeight : 0) - 14);
+              if (left < 1) {
+                left = 1;
+              } else if (left > tableEl.clientWidth - filterWidth - 1) {
+                left = tableEl.clientWidth - filterWidth - 1;
+              }
+              if ($xeGGWrapper) {
+                const wrapperEl = $xeGGWrapper.getRefMaps().refElem.value;
+                if (wrapperEl) {
+                  const wrapperRect = wrapperEl.getBoundingClientRect();
+                  top += tableRect.top - wrapperRect.top;
+                }
+              }
+            }
+            filterStore.style = {
+              top: dom.toCssUnit(top),
+              left: dom.toCssUnit(left)
+            };
+            if (compConf ? !compConf.tableFilterAutoHeight : false) {
+              maxHeight = 0;
+            }
+            filterStore.maxHeight = maxHeight;
+          });
+        }
+        $xeTable.dispatchEvent("filter-visible", { column, field: column.field, property: column.field, filterList: $xeTable.getCheckedFilters(), visible: filterStore.visible }, evnt);
+      },
+      handleClearFilter(column) {
+        if (column) {
+          const { filters, filterRender } = column;
+          if (filters) {
+            const compConf = utils.isEnableConf(filterRender) ? renderer.get(filterRender.name) : null;
+            const frMethod = column.filterResetMethod || (compConf ? compConf.tableFilterResetMethod || compConf.filterResetMethod : null);
+            filters.forEach((item) => {
+              item._checked = false;
+              item.checked = false;
+              if (!frMethod) {
+                item.data = index.default.clone(item.resetValue, true);
+              }
+            });
+            if (frMethod) {
+              frMethod({ options: filters, column, $table: $xeTable });
+            }
+          }
+        }
+      },
+      handleColumnConfirmFilter(column, evnt) {
+        const { mouseConfig } = props;
+        const { scrollXLoad: oldScrollXLoad, scrollYLoad: oldScrollYLoad } = reactData;
+        const filterOpts = computeFilterOpts.value;
+        const mouseOpts = computeMouseOpts.value;
+        const { field, filters } = column;
+        const filterOptions = filters || [];
+        const values = [];
+        const datas = [];
+        filterOptions.forEach((item) => {
+          if (item.checked) {
+            values.push(item.value);
+            datas.push(item.data);
+          }
+        });
+        const filterList = $xeTable.getCheckedFilters();
+        const params = { $table: $xeTable, $event: evnt, column, field, property: field, values, datas, filters: filterList, filterList };
+        if (!filterOpts.remote) {
+          $xeTable.handleTableData(true);
+          $xeTable.checkSelectionStatus();
+        }
+        if (mouseConfig && mouseOpts.area && $xeTable.handleFilterEvent) {
+          $xeTable.handleFilterEvent(evnt, params);
+        }
+        if (evnt) {
+          $xeTable.dispatchEvent("filter-change", params, evnt);
+        }
+        $xeTable.closeFilter();
+        return $xeTable.updateFooter().then(() => {
+          const { scrollXLoad, scrollYLoad } = reactData;
+          if (oldScrollXLoad || scrollXLoad || (oldScrollYLoad || scrollYLoad)) {
+            if (oldScrollXLoad || scrollXLoad) {
+              $xeTable.updateScrollXSpace();
+            }
+            if (oldScrollYLoad || scrollYLoad) {
+              $xeTable.updateScrollYSpace();
+            }
+            return $xeTable.refreshScroll();
+          }
+        }).then(() => {
+          $xeTable.updateCellAreas();
+          return $xeTable.recalculate(true);
+        }).then(() => {
+          setTimeout(() => $xeTable.recalculate(), 50);
+        });
+      },
+      /**
+       * 确认筛选
+       * 当筛选面板中的确定按钮被按下时触发
+       */
+      confirmFilterEvent(evnt, column) {
+        if (column) {
+          $xeTable.handleColumnConfirmFilter(column, evnt);
+        }
+      },
+      // （单选）筛选发生改变
+      handleFilterChangeRadioOption(evnt, checked, item) {
+        const { filterStore } = reactData;
+        const { column } = filterStore;
+        if (column) {
+          const filterOptions = column.filters || [];
+          filterOptions.forEach((option) => {
+            option._checked = false;
+          });
+          item._checked = checked;
+          $xeTable.checkFilterOptions();
+          $xeTable.handleFilterConfirmFilter(evnt, column);
+        }
+      },
+      // （多选）筛选发生改变
+      handleFilterChangeMultipleOption(evnt, checked, item) {
+        item._checked = checked;
+        $xeTable.checkFilterOptions();
+      },
+      // 筛选发生改变
+      handleFilterChangeOption(evnt, checked, item) {
+        const { filterStore } = reactData;
+        const { fullColumnIdData } = internalData;
+        let column = filterStore.column;
+        if (!column) {
+          const colRest = fullColumnIdData[item._colId];
+          if (colRest) {
+            column = colRest.column;
+            filterStore.column = column;
+          }
+        }
+        if (column) {
+          if (column.filterMultiple) {
+            $xeTable.handleFilterChangeMultipleOption(evnt, checked, item);
+          } else {
+            $xeTable.handleFilterChangeRadioOption(evnt, checked, item);
+          }
+        }
+      },
+      // 确认筛选
+      handleFilterConfirmFilter(evnt, column) {
+        if (column) {
+          const filterOptions = column.filters || [];
+          filterOptions.forEach((option) => {
+            option.checked = option._checked;
+          });
+          $xeTable.confirmFilterEvent(evnt, column);
+        }
+      },
+      /**
+       * 重置筛选
+       * 当筛选面板中的重置按钮被按下时触发
+       */
+      handleFilterResetFilter(evnt, column) {
+        if (column) {
+          $xeTable.handleClearFilter(column);
+          $xeTable.confirmFilterEvent(evnt, column);
+          if (evnt) {
+            $xeTable.dispatchEvent("clear-filter", { filterList: [] }, evnt);
+          }
+        }
+      }
+    };
+    const filterMethods = {
+      /**
+       * 手动弹出筛选面板
+       * @param column
+       */
+      openFilter(fieldOrColumn) {
+        const column = util.handleFieldOrColumn($xeTable, fieldOrColumn);
+        if (column && column.filters) {
+          const { elemStore } = internalData;
+          const { fixed } = column;
+          return $xeTable.scrollToColumn(column).then(() => {
+            const headerWrapperElem = util.getRefElem(elemStore[`${fixed || "main"}-header-wrapper`] || elemStore["main-header-wrapper"]);
+            if (headerWrapperElem) {
+              const filterBtnElem = headerWrapperElem.querySelector(`.vxe-header--column.${column.id} .vxe-cell--filter`);
+              dom.triggerEvent(filterBtnElem, "click");
+            }
+          });
+        }
+        return vue.nextTick();
+      },
+      /**
+       * 修改筛选条件列表
+       * @param {ColumnInfo} fieldOrColumn 列或字段名
+       * @param {Array} options 选项
+       */
+      setFilter(fieldOrColumn, options, isUpdate) {
+        const { filterStore } = reactData;
+        const column = util.handleFieldOrColumn($xeTable, fieldOrColumn);
+        if (column && column.filters) {
+          column.filters = util.toFilters(options || [], column.id);
+          if (isUpdate) {
+            return $xeTable.handleColumnConfirmFilter(column, null);
+          } else {
+            if (filterStore.visible) {
+              $xeTable.handleFilterOptions(column);
+            }
+          }
+        }
+        return vue.nextTick();
+      },
+      /**
+       * 清空指定列的筛选条件
+       * 如果为空则清空所有列的筛选条件
+       * @param {String} fieldOrColumn 列或字段名
+       */
+      clearFilter(fieldOrColumn) {
+        const { filterStore } = reactData;
+        const { tableFullColumn } = internalData;
+        const filterOpts = computeFilterOpts.value;
+        let column;
+        if (fieldOrColumn) {
+          column = util.handleFieldOrColumn($xeTable, fieldOrColumn);
+          if (column) {
+            $xeTable.handleClearFilter(column);
+          }
+        } else {
+          tableFullColumn.forEach($xeTable.handleClearFilter);
+        }
+        if (!fieldOrColumn || column !== filterStore.column) {
+          Object.assign(filterStore, {
+            isAllSelected: false,
+            isIndeterminate: false,
+            style: null,
+            options: [],
+            column: null,
+            multiple: false,
+            visible: false
+          });
+        }
+        if (!filterOpts.remote) {
+          return $xeTable.updateData();
+        }
+        return vue.nextTick();
+      },
+      saveFilter(fieldOrColumn) {
+        if (fieldOrColumn) {
+          const column = util.handleFieldOrColumn($xeTable, fieldOrColumn);
+          $xeTable.handleFilterConfirmFilter(null, column);
+        }
+        return vue.nextTick();
+      },
+      saveFilterByEvent(evnt, fieldOrColumn) {
+        if (fieldOrColumn) {
+          const column = util.handleFieldOrColumn($xeTable, fieldOrColumn);
+          $xeTable.handleFilterConfirmFilter(evnt, column);
+        }
+        return vue.nextTick();
+      },
+      resetFilter(fieldOrColumn) {
+        if (fieldOrColumn) {
+          const column = util.handleFieldOrColumn($xeTable, fieldOrColumn);
+          $xeTable.handleFilterResetFilter(null, column);
+        }
+        return vue.nextTick();
+      },
+      resetFilterByEvent(evnt, fieldOrColumn) {
+        if (fieldOrColumn) {
+          const column = util.handleFieldOrColumn($xeTable, fieldOrColumn);
+          $xeTable.handleFilterResetFilter(evnt, column);
+        }
+        return vue.nextTick();
+      },
+      saveFilterPanel() {
+        const { filterStore } = reactData;
+        $xeTable.handleFilterConfirmFilter(null, filterStore.column || null);
+        return vue.nextTick();
+      },
+      saveFilterPanelByEvent(evnt) {
+        const { filterStore } = reactData;
+        $xeTable.handleFilterConfirmFilter(evnt, filterStore.column || null);
+        return vue.nextTick();
+      },
+      resetFilterPanel() {
+        const { filterStore } = reactData;
+        $xeTable.handleFilterResetFilter(null, filterStore.column || null);
+        return vue.nextTick();
+      },
+      resetFilterPanelByEvent(evnt) {
+        const { filterStore } = reactData;
+        $xeTable.handleFilterResetFilter(evnt, filterStore.column || null);
+        return vue.nextTick();
+      },
+      getCheckedFilters() {
+        const { tableFullColumn } = internalData;
+        const filterList = [];
+        tableFullColumn.forEach((column) => {
+          const { field, filters } = column;
+          const filterOptions = filters || [];
+          const valueList = [];
+          const dataList = [];
+          if (filterOptions) {
+            filterOptions.forEach((item) => {
+              if (item.checked) {
+                valueList.push(item.value);
+                dataList.push(item.data);
+              }
+            });
+            if (valueList.length) {
+              filterList.push({ column, field, property: field, values: valueList, datas: dataList });
+            }
+          }
+        });
+        return filterList;
+      },
+      updateFilterOptionStatus(item, checked) {
+        item._checked = checked;
+        item.checked = checked;
+        return vue.nextTick();
+      }
+    };
+    return Object.assign(Object.assign({}, filterMethods), filterPrivateMethods);
+  },
+  setupGrid($xeGrid) {
+    return $xeGrid.extendTableMethods(tableFilterMethodKeys);
+  },
+  setupGantt($xeGantt) {
+    return $xeGantt.extendTableMethods(tableFilterMethodKeys);
+  }
+});