cloud-web-corejs 1.0.54-dev.575 → 1.0.54-dev.577

package/src/components/table/index - /345/211/257/346/234/254.js"

@@ -0,0 +1,1009 @@
+/**version-1.0*/
+let modules = {};
+import Sortable from "sortablejs";
+import tableConfig from "./config.js";
+import customConfig from "./customConfig.js";
+import Vue from "vue";
+import {extendDeeply} from "../../utils/index.js";
+import corejsConfig from "@/corejsConfig";
+import settingConfig from "@/settings.js";
+import {getCellValue, createParams} from "./util/index";
+
+let configUtil = {
+  Sortable,
+  extendDeeply,
+  tableConfig,
+  Vue,
+};
+
+function getGrid(that, tableRef) {
+  let $grid;
+  if (Array.isArray(that.$refs[tableRef])) {
+    $grid = that.$refs[tableRef][0];
+  } else {
+    $grid = that.$refs[tableRef];
+  }
+  return $grid;
+}
+
+async function initVxeTable(option) {
+  let tableName = option.tableName;
+  if (
+    !configUtil.tableConfig.disableTableName
+    && option.tableNameRequired !== false
+    && !tableName
+    && settingConfig.tableStorageDisabled !== true
+  ) {
+    return false;
+  }
+  let that = option.vue;
+  if (!that.$refs[option.tableRef]) {
+    await that.$nextTick();
+  }
+  let $grid = getGrid(that, option.tableRef);
+  if (!$grid) {
+    return false;
+  }
+  delete option.vue;
+
+  //操作列自动补全
+  handleCustomAlign(option);
+
+  $grid.originOption = that.$baseLodash.cloneDeep(option);
+  $grid.originOption.vue = that;
+  option.vue = that;
+
+  let isQueryAllPage = true;
+  if (option.isQueryAllPage !== null  && option.isQueryAllPage  !== undefined) {
+    isQueryAllPage = option.isQueryAllPage;
+  }
+
+  if (tableName) {
+    $grid.tableName = tableName;
+    if (option.path) {
+      await getTableData(that, option.tableRef, "isQueryAllPage", (res1) => {
+        let result = res1.objx ? res1.objx.data : null;
+        if (result !== null  && result  !== undefined) {
+          if (result === "false" || result === false) {
+            isQueryAllPage = false;
+          } else {
+            isQueryAllPage = true;
+          }
+        }
+      });
+    }
+    await getTableJson(tableName, that, (resultMsg) => {
+      let objx = resultMsg.objx;
+      if (objx !== null  && objx  !== undefined) {
+        let jsonStr = objx.data;
+        if (jsonStr) {
+          let json = JSON.parse(decodeURIComponent(jsonStr));
+          let columnData = json.columns ? json.columns : json;
+          if (columnData) {
+            option.columns = initColumn(option, columnData);
+          }
+          $grid.searchColumns = initSearchColumns(option, json.searchColumns);
+          initExportColumns($grid, json);
+        }
+      }
+      if (!$grid.searchColumns || !$grid.searchColumns.length) {
+        $grid.searchColumns = initSearchColumns(option);
+      }
+    });
+  } else {
+    $grid.searchColumns = initSearchColumns(option);
+  }
+
+  if(!!$grid?.$refs?.xTable){
+    $grid.$refs.xTable.getCellValue = getCellValue;
+    $grid.$refs.xTable.createParams = createParams;
+  }
+
+  $grid.getCellValue = getCellValue;
+  $grid.createParams = createParams;
+
+  option.isQueryAllPage = isQueryAllPage;
+  let nOption = initOption(option);
+
+  $grid.isQueryAllPage = isQueryAllPage;
+
+  if (tableName) {
+    nOption.tableName = tableName;
+  }
+
+  nOption.vue = that;
+  //绑定列位置拖拽
+  columnDrop(that, tableName, option.tableRef);
+
+  //自动绑定toobar
+  handleToolbar($grid, option);
+
+  return nOption;
+}
+
+//自动绑定toobar
+function handleToolbar($grid, option) {
+  let selfConfig = getSelfConfig();
+  if (
+    option.bindToolbar
+    || (option.bindToolbar !== false && selfConfig.bindToolbar)
+  ) {
+    let loopDo = function (children) {
+      if (children && children.length) {
+        children.forEach((item) => {
+          if (item.$options.name === "VxeToolbar") {
+            $grid.connect(item);
+          } else {
+            loopDo(item.$children);
+          }
+        });
+      }
+    };
+    that.$nextTick(() => {
+      loopDo($grid.$children);
+    });
+  }
+}
+
+//操作列自动补全
+function handleCustomAlign(option) {
+  let selfConfig = getSelfConfig();
+  // let customAlign = option.customAlign || selfConfig.customAlign || "right";
+  let customAlign
+    = selfConfig.customAlign === false
+    ? false
+    : selfConfig.customAlign || "right";
+  customAlign
+    = option.customAlign === false ? false : option.customAlign || customAlign;
+
+  let customColumnWidth
+    = option.customColumnWidth || selfConfig.customColumnWidth || 47;
+  let checkBoxColumnWidth
+    = option.checkBoxColumnWidth || selfConfig.checkBoxColumnWidth || 48;
+
+  let checkBoxRequired = selfConfig.checkBoxRequired !== false;
+  if (option.checkBoxRequired === false) {
+    checkBoxRequired = false;
+  }
+
+  let columnSize = option.columns.length;
+  if (columnSize > 0) {
+    if (checkBoxRequired) {
+      let firstColumn = option.columns[0];
+      if (firstColumn.type !== "checkbox") {
+        option.columns.splice(0, 0, {
+          type: "checkbox",
+          width: checkBoxColumnWidth,
+          resizable: false,
+          fixed: "left",
+        });
+      }
+    }
+    if (customAlign !== false) {
+      let lastColumn = option.columns[columnSize - 1];
+      if (customAlign === "left") {
+        if (!lastColumn.field && lastColumn.fixed === "right") {
+          option.columns.splice(columnSize - 1, 1);
+          lastColumn.fixed = "left";
+          option.columns.splice(1, 0, lastColumn);
+        } else if (columnSize > 1) {
+          if (option.columns[1].field) {
+            option.columns.splice(1, 0, {
+              width: customColumnWidth,
+              fixed: "left",
+              title: "",
+              sortable: false,
+            });
+          }
+        }
+      } else if (customAlign === "right") {
+        let column1 = option.columns[1];
+        if (!column1.field && column1.fixed === "left") {
+          option.columns.splice(1, 1);
+          column1.fixed = "right";
+          option.columns.push(column1);
+        } else if (lastColumn.field || lastColumn.fixed !== "right") {
+          option.columns.push({
+            width: customColumnWidth,
+            fixed: "right",
+            title: "",
+            sortable: false,
+          });
+        }
+      }
+    }
+  }
+}
+
+//列位置拖拽
+function columnDrop(t, tableName, tableRef) {
+  let that = t;
+  const $table = getGrid(that, tableRef);
+  if (!$table) {
+    return;
+  }
+  if ($table.sortable) {
+    $table.sortable.destroy();
+  }
+  $table.sortable = configUtil.Sortable.create(
+    $table.$el.querySelector(
+      ".body--wrapper>.vxe-table--header .vxe-header--row"
+    ),
+    {
+      handle: ".vxe-header--column:not(.col--fixed)",
+      onEnd: ({item, newIndex, oldIndex}) => {
+        const {fullColumn, tableColumn,collectColumn} = $table.getTableColumn();
+        const targetThElem = item;
+        const wrapperElem = targetThElem.parentNode;
+        const newColumn = tableColumn[newIndex];
+        if (newColumn.fixed) {
+          // 错误的移动
+          if (newIndex > oldIndex) {
+            wrapperElem.insertBefore(
+              targetThElem,
+              wrapperElem.children[oldIndex]
+            );
+          } else {
+            wrapperElem.insertBefore(
+              wrapperElem.children[oldIndex],
+              targetThElem
+            );
+          }
+          return;
+          /* return that.$XModal.message({
+          content: '固定列不允许拖动！',
+          status: 'error'
+        }) */
+        }
+        // 转换真实索引
+        const oldColumnIndex = $table.getColumnIndex(tableColumn[oldIndex]);
+        const newColumnIndex = $table.getColumnIndex(tableColumn[newIndex]);
+        // 移动到目标列
+        const currRow = collectColumn.splice(oldColumnIndex, 1)[0];
+        collectColumn.splice(newColumnIndex, 0, currRow);
+
+        $table.loadColumn(collectColumn);
+        addTableJson(that, $table, tableName, collectColumn);
+      },
+    }
+  );
+}
+
+function getSelfConfig() {
+  let tableConfig = configUtil.tableConfig || {};
+  let selfConfig = tableConfig.selfConfig || {};
+  return selfConfig;
+}
+
+function initColumnDefaulAttrs(columns, opts) {
+  if (opts.sortAll === true || (opts.sortAll !== false && !opts.treeNodeUrl)) {
+    for (let i = 0; i < columns.length; i++) {
+      if (columns[i].title && columns[i].sortable === null || columns[i].sortable === undefined) {
+        columns[i].sortable = true;
+      }
+    }
+  }
+
+  let tableConfig = configUtil.tableConfig || {};
+  let selfConfig = getSelfConfig();
+  if (opts.filterType !== false && !opts.treeNodeUrl) {
+    let filterType
+      = opts.filterType || selfConfig.filterType || "filterContent";
+    if (filterType) {
+      columns.forEach((column) => {
+        if (column.title && column.field) {
+          if (
+            column.filterType === "filterContent"
+            || ((column.filterType === null || column.filterType === undefined) && filterType === "filterContent")
+          ) {
+            if (!column.filters) {
+              column.filters = [
+                {
+                  data: {},
+                },
+              ];
+            }
+            if (!column.filterRender) {
+              column.filterRender = {
+                name: "FilterContent",
+              };
+            }
+          } else if (
+            column.filterType === "filterInput"
+            || ((column.filterType === null || column.filterType === undefined) && filterType === "filterInput")
+          ) {
+            if (!column.filters) {
+              column.filters = [
+                {
+                  data: "",
+                },
+              ];
+            }
+            if (!column.filterRender) {
+              column.filterRender = {
+                name: "FilterInput",
+              };
+            }
+          }
+        }
+      });
+    }
+  }
+
+  //设置复选框列的锁定宽度
+  if (opts.lockCheckboxWidth !== false) {
+    let lockCheckboxWidth
+      = opts.lockCheckboxWidth || selfConfig.lockCheckboxWidth;
+    if (lockCheckboxWidth) {
+      columns.forEach((column) => {
+        if (column.type === "checkbox") {
+          column.width = lockCheckboxWidth;
+        }
+      });
+    }
+  }
+}
+
+function initOption(opts) {
+  let result = {};
+  let that = opts.vue;
+  let $grid = getGrid(that, opts.tableRef);
+
+  let path = opts.path || "";
+  // let columns = JSON.parse(JSON.stringify(opts.columns || []));
+  let columns = opts.columns || [];
+  let isQueryAllPage = opts.isQueryAllPage;
+  let pagerLayouts = getPagerConfigLayouts(opts);
+
+  let config = opts.config || {};
+
+  initColumnDefaulAttrs(columns, opts);
+
+  let defaultOptions = {
+    columnKey: true,
+    resizable: true,
+    showOverflow: true,
+    showHeaderOverflow: true,
+    showFooterOverflow: true,
+    highlightHoverRow: true,
+    border: "inner",
+    height: "auto",
+    // maxHeight:"1000px",
+    // rowId: 'id',
+    emptyText: " ",
+    sortConfig: {
+      trigger: "cell",
+      remote: false,
+    },
+    filterConfig: {
+      remote: false,
+    },
+    pagerConfig: {
+      autoHidden: true,
+      perfect: true,
+      pageSize: 200,
+      pageSizes: [50, 100, 200, 500],
+      layouts: pagerLayouts,
+      slots: {
+        left: (obj, b, c) => {
+          let $grid = obj.$grid;
+          let k = $grid.$data;
+          let tableDataInfo = $grid.getTableData();
+          let data = tableDataInfo.fullData;
+          let h = $grid.$createElement;
+
+          let proxyInfo = $grid.getProxyInfo();
+          let pager = proxyInfo ? proxyInfo.pager : null;
+
+          let celems = [
+            h("span", $grid.$t2("本页记录数", "components.table.currentNum")),
+            h(
+              "span",
+              {
+                attrs: {
+                  class: "f-red",
+                },
+              },
+              " " + tableDataInfo.visibleData.length + " "
+            ),
+          ];
+          if (pager && $grid.isQueryAllPage) {
+            celems.push(
+              h(
+                "span",
+                "，" + $grid.$t2("总记录数", "components.table.totalNum")
+              )
+            );
+            celems.push(
+              h(
+                "span",
+                {
+                  attrs: {
+                    class: "f-red",
+                  },
+                },
+                " " + pager.total + " "
+              )
+            );
+          }
+          let elem = h("span", {}, celems);
+          return [elem];
+        },
+      },
+    },
+    exportConfig: {
+      // 默认选中类型
+      type: "xlsx",
+      // 局部自定义类型
+      types: ["xlsx", "csv", "html", "xml", "txt"],
+      // 自定义数据量列表
+      modes: ["current", "all"],
+    },
+    radioConfig: {
+      labelField: "id",
+      reserve: true,
+      highlight: true,
+    },
+    checkboxConfig: {
+      highlight: true,
+    },
+    customConfig: {
+      storage: false,
+    },
+    scrollX: {
+      // enabled: true,
+      gt: 10,
+      // oSize: 5
+    },
+    /*loadingConfig: {
+      icon: "vxe-loading--spinner",
+      text: ' '
+    },*/
+    columns: columns,
+  };
+  let tableDefaultConfig
+    = corejsConfig?.componentConfig?.table?.defaultConfig || {};
+  defaultOptions = configUtil.extendDeeply(defaultOptions, tableConfig);
+  defaultOptions = configUtil.extendDeeply(defaultOptions, customConfig);
+  defaultOptions = configUtil.extendDeeply(defaultOptions, tableDefaultConfig);
+
+  if (opts.path) {
+    // defaultOptions.filterInput = true;
+    defaultOptions.pagerConfig.autoHidden = false;
+    defaultOptions.proxyConfig = {
+      seq: true, // 启用动态序号代理
+      sort: true, // 启用排序代理
+      filter: true, // 启用筛选代理
+      props: {
+        result: "objx.records", // 配置响应结果列表字段
+        total: "objx.total", // 配置响应结果总页数字段
+      },
+      ajax: {
+        // 接收 Promise 对象
+        query: ({page, sorts, filters, form}) => {
+          if (!opts.path) {
+            return;
+          }
+          return new Promise((resolve, reject) => {
+            let toDo = () => {
+              let formData = opts.param ? opts.param() || {} : {};
+              const queryParams = Object.assign({}, formData);
+
+              // 处理排序条件
+              /*const firstSort = sorts[0];
+              if (firstSort) {
+                queryParams.sort = firstSort.property;
+                queryParams.order = firstSort.order;
+              }*/
+              // 处理筛选条件
+              filters.forEach(({property, values}) => {
+                queryParams[property] = values.join(",");
+              });
+              if (page.pageSize !== undefined) {
+                queryParams["size"] = page.pageSize;
+                queryParams["current"] = page.currentPage;
+              }
+
+              let $grid = getGrid(that, opts.tableRef);
+              let isQueryAllPage = $grid.isQueryAllPage;
+              let pathStr1 = "";
+              if (isQueryAllPage === false) {
+                queryParams.searchCount = false;
+              }
+
+              let reqPath = typeof path === "function" ? path() : path;
+              let addUserForTableEnabled
+                = settingConfig.addUserForTableDisabled !== true;
+              let addCreateInfo
+                = opts.addCreateInfo === true || addUserForTableEnabled;
+              let queryCreateInfo
+                = opts.queryCreateInfo === true || addUserForTableEnabled;
+              that.$commonHttp({
+                aes: opts.aes || false,
+                url: reqPath,
+                method: "post",
+                data: queryParams,
+                addCreateInfo: addCreateInfo,
+                queryCreateInfo: queryCreateInfo,
+                callback: (res) => {
+                  resolve(res);
+                  if (res.type === "success") {
+                    let rows = res.objx
+                      ? res.objx.records || res.objx || []
+                      : [];
+                    if (opts.treeNodeUrl) {
+                      if (rows.length > 0) {
+                        let $t = getGrid(that, opts.tableRef);
+                        let treeConditions = $t.originOption.treeConditions || [
+                          "enabled",
+                        ];
+                        let treeFiled = Object.keys(formData).some((key) => {
+                          return (
+                            !treeConditions.includes(key)
+                            && formData[key] !== null && formData[key] !== undefined
+                            && formData[key] !== ""
+                          );
+                        });
+                        if (treeFiled) {
+                          that.$nextTick(() => {
+                            setTimeout(function () {
+                              let isLazy = $t.treeConfig.lazy;
+                              $t.treeConfig.lazy = false;
+                              $t.setAllTreeExpand(true).then(() => {
+                                let fullAllDataRowMap
+                                  = $t.$refs.xTable.fullAllDataRowMap;
+                                let fullData = $t.getTableData().fullData;
+                                fullData.forEach((lineData) => {
+                                  if (
+                                    $t.$refs.xTable.isTreeExpandByRow(lineData)
+                                  ) {
+                                    let rest = fullAllDataRowMap.get(lineData);
+                                    rest.treeLoaded = true;
+                                  }
+                                });
+                                $t.treeConfig.lazy = isLazy;
+                              });
+                            }, 0);
+                          });
+                        } else {
+                          let row = rows[0];
+                          if (row[result.treeConfig.hasChild]) {
+                            that.$nextTick(() => {
+                              setTimeout(function () {
+                                $t.setTreeExpand(row, true);
+                              }, 0);
+                            });
+                          }
+                        }
+                      }
+                    }
+                    if (opts.callback) {
+                      that.$nextTick(() => {
+                        setTimeout(function () {
+                          opts.callback(rows, res);
+                        }, 0);
+                      });
+                    }
+                  }
+                },
+                error: (error) => {
+                  reject(error);
+                },
+              });
+            };
+            let index = 0;
+            let loopHandle = () => {
+              if (index < 500 && $grid.tableFormStop === true) {
+                //阻塞列表查询，或者次数达到500时，自动释放
+                index++;
+                setTimeout(() => {
+                  loopHandle();
+                }, 10);
+              } else {
+                if ($grid.tableFormStop) $grid.tableFormStop = false;
+                toDo();
+              }
+            };
+            loopHandle();
+          });
+        },
+        // 被某些特殊功能所触发，例如：导出数据 mode=all 时，会触发该方法并对返回的数据进行导出
+        queryAll: () => fetch(path || "").then((response) => response.json()),
+      },
+    };
+    /*defaultOptions.scrollX = {
+      enabled: true,
+      gt: 20
+    };*/
+    defaultOptions.scrollY = {
+      // enabled: false,
+      gt: 20,
+      oSize: 20,
+    };
+  } else {
+    if (!$grid.height && (!opts.config || !opts.config.height)) {
+      defaultOptions.maxHeight = "528px";
+    }
+    defaultOptions.scrollY = {
+      // enabled: false,
+      gt: 20,
+      oSize: 20,
+    };
+  }
+
+  if (opts.editSaveUrl) {
+    (defaultOptions.keepSource = true),
+      (defaultOptions.editConfig = {
+        trigger: "manual",
+        mode: "row",
+        showStatus: true,
+        autoClear: false,
+      });
+  }
+  if (opts.treeNodeUrl) {
+    defaultOptions.proxyConfig.props.result = "objx";
+    defaultOptions.pagerConfig.autoHidden = true;
+    defaultOptions.treeConfig = {
+      lazy: true,
+      children: "children",
+      hasChild: "hasChild", // 设置是否有子节点标识
+      parentField: "parent",
+      transform: true,
+      loadMethod({$table, row}) {
+        // 模拟后台接口
+        return new Promise((resolve, reject) => {
+          let treeNodeParam = opts.treeNodeParam
+            ? opts.treeNodeParam(row) || {}
+            : {
+              parent: row.id,
+            };
+          that.$http({
+            aes: opts.aes || false,
+            url: opts.treeNodeUrl,
+            method: "post",
+            data: treeNodeParam,
+            callback: (res) => {
+              if (res.type === "success") {
+                // let rows = res.objx || [];
+                let rows = res.objx ? res.objx.records || res.objx || [] : [];
+                let hasChildField = $grid.treeConfig.hasChild;
+                if (row[hasChildField] && !rows.length) {
+                  row[hasChildField] = false;
+                }
+                resolve(rows);
+                if (opts.treeCallback) {
+                  that.$nextTick(() => {
+                    setTimeout(function () {
+                      opts.treeCallback(rows, res);
+                    }, 0);
+                  });
+                }
+              } else {
+                reject(res);
+              }
+            },
+          });
+        });
+      },
+    };
+  }
+
+  result = configUtil.extendDeeply(defaultOptions, config);
+
+  let pageSize = result.pagerConfig.pageSize;
+  let pageSizes = result.pagerConfig.pageSizes;
+  if (pageSizes && !pageSizes.includes(pageSize)) {
+    for (let i = 0; i < pageSizes.length; i++) {
+      let item = pageSizes[i];
+      if (item > pageSize) {
+        pageSizes.splice(i, 0, pageSize);
+        break;
+      }
+    }
+  }
+
+  return result;
+}
+
+function getTableJson(tableName, that, success) {
+  if (
+    configUtil.tableConfig.disableTableName
+    || settingConfig.tableStorageDisabled
+  )
+    return false;
+  if (!tableName) return;
+  let url = USER_PREFIX + "/table_column/getTableJson";
+  let data = {
+    tableName: tableName,
+  };
+  let json = null;
+  return that.$http({
+    url: url,
+    method: "post",
+    data: data,
+    success: success,
+  });
+}
+
+function addTableExportJson() {
+}
+
+function addTableJson(that, $grid, tableName, columns, success) {
+  if (
+    configUtil.tableConfig.disableTableName
+    || settingConfig.tableStorageDisabled
+  )
+    return false;
+  if (!tableName) return;
+  if (!columns) {
+    columns = $grid.getTableColumn().fullColumn;
+  }
+  let saveColumn = [];
+  columns.forEach(function (item, index) {
+    saveColumn.push({
+      field: item.field || item.property,
+      title: item.title,
+      visible: item.visible,
+      width: item.renderWidth || item.width,
+    });
+  });
+
+  let searchColumns = $grid.searchColumns || [];
+  let jsonData = {
+    columns: saveColumn,
+    searchColumns: searchColumns,
+  };
+  if ($grid.exportColumns && $grid.exportColumns.length) {
+    jsonData.exportColumns = $grid.exportColumns;
+  }
+  if ($grid.exportItemColumns && $grid.exportItemColumns.length) {
+    jsonData.exportItemColumns = $grid.exportItemColumns;
+  }
+  let json = encodeURIComponent(JSON.stringify(jsonData));
+
+  let url = USER_PREFIX + "/table_column/addTableJson";
+  let data = {
+    tableName: tableName,
+    // json: encodeURIComponent(JSON.stringify(saveColumn)),
+    json: json,
+  };
+  that.$http({
+    url: url,
+    method: "post",
+    data: data,
+    success: success,
+  });
+}
+
+function initColumn(option, syncColumns) {
+  let oldColumns = option.columns;
+  let newColumns = [];
+  if (syncColumns) {
+    let fields = [];
+    syncColumns.forEach(function (syncColumn) {
+      let field = syncColumn.field;
+      if (field) {
+        oldColumns.some(function (oldColumn) {
+          let flag = oldColumn.field === field;
+          if (flag) {
+            if(!oldColumn.params)oldColumn.params = {}
+            let visibleSync = option.visibleSync !== false && oldColumn.visibleSync !== false;
+            oldColumn.params._visible = oldColumn.visible ?? true;
+            if (visibleSync) {
+              oldColumn.visible = syncColumn.visible;
+            }
+            if(oldColumn.width !== undefined && oldColumn.width !== undefined){
+              oldColumn.params._width = oldColumn.width;
+            }
+            if (syncColumn.width) oldColumn.width = syncColumn.width;
+            newColumns.push(oldColumn);
+            fields.push(field);
+          }
+          return flag;
+        });
+      }
+    });
+    oldColumns.forEach(function (oldColumn, index) {
+      let field = oldColumn.field;
+      if (field) {
+        if (!fields.includes(field)) {
+          newColumns.splice(index, 0, oldColumn);
+        }
+      } else {
+        newColumns.splice(index, 0, oldColumn);
+      }
+    });
+  } else {
+    newColumns = oldColumns;
+  }
+  return newColumns;
+}
+
+function initExportColumns($grid, json) {
+  if (json?.exportColumns?.length) {
+    $grid.exportColumns = json.exportColumns;
+  }
+  if (json?.exportItemColumns?.length) {
+    $grid.exportItemColumns = json.exportItemColumns;
+  }
+}
+
+function initSearchColumns(option, syncColumns) {
+  let oldColumns = option.searchColumns || [];
+  let newColumns = [];
+  if (syncColumns) {
+    let fields = [];
+    syncColumns.forEach(function (syncColumn) {
+      let field = syncColumn.field;
+      if (field) {
+        oldColumns.some(function (oldColumn) {
+          let flag = oldColumn.field === field && !oldColumn.fixed;
+          if (flag) {
+            oldColumn.common = syncColumn.common || false;
+            if (syncColumn.defaultValue !== undefined) {
+              oldColumn.defaultValue = syncColumn.defaultValue;
+            }
+            newColumns.push(oldColumn);
+            fields.push(field);
+          }
+          return flag;
+        });
+      }
+    });
+    oldColumns.forEach(function (oldColumn, index) {
+      let field = oldColumn.field;
+      if (field && !oldColumn.fixed) {
+        if (!fields.includes(field)) {
+          newColumns.splice(index, 0, oldColumn);
+        }
+      } else {
+        newColumns.splice(index, 0, oldColumn);
+      }
+    });
+  } else {
+    newColumns = oldColumns;
+  }
+  return newColumns.length ? newColumns : oldColumns;
+}
+
+function onColumnWitchChange(option) {
+  let that = option.$grid.$parent;
+  let $grid = option.$grid;
+  let originOption = $grid.originOption;
+  let tableName = originOption.tableName;
+  if (tableName) {
+    // let columns = $grid.columns;
+    const {fullColumn, tableColumn} = $grid.getTableColumn();
+    addTableJson(that, $grid, tableName);
+  }
+}
+
+function customHandle(option) {
+  let that = option.$grid.$parent;
+  let $grid = option.$grid;
+  let originOption = $grid.originOption;
+  if (option.type === "confirm" || option.type === "reset") {
+    let tableName = originOption.tableName;
+    if (option.type === "reset") {
+      const {fullColumn} = $grid.getTableColumn();
+      const loopDo = (columns)=>{
+        columns.forEach((item)=>{
+          if(item.children && item.children.length){
+            loopDo(item.children);
+          }else{
+            if(item.params){
+              item.visible = item.params._visible ?? true;
+              if(item.params._width !== undefined)item.width = item.params._width;
+            }
+          }
+        })
+      }
+      loopDo(fullColumn);
+      $grid.loadColumn(fullColumn);
+      // let columns = that.$baseLodash.cloneDeep(originOption.columns);
+      // initColumnDefaulAttrs(columns, originOption);
+      // $grid.columns = columns;
+    }
+    if (tableName) {
+      setTimeout(() => {
+        const {fullColumn, tableColumn} = $grid.getTableColumn();
+        addTableJson(that, $grid, tableName);
+      }, 200);
+    }
+
+    if (option && option.$event && option.$event.preventDefault) {
+      option.$event.preventDefault(); // 取消事件的默认行为
+    }
+  }
+  originOption.customCallback && originOption.customCallback(option);
+}
+
+function changeSelectCount(checked) {
+  let checkedLength = checked.records.length;
+}
+
+function getTableData(that, tableRef, type, success) {
+  if (
+    configUtil.tableConfig.disableTableName
+    || settingConfig.tableStorageDisabled
+  )
+    return false;
+  let $grid = getGrid(that, tableRef);
+  let tableName = $grid.tableName;
+  let url = USER_PREFIX + "/table_column/getTableData";
+  let param = {
+    tableName: tableName,
+    type: type,
+  };
+  let data = null;
+  return that.$http({
+    async: false,
+    url: url,
+    method: "post",
+    data: param,
+    success: success,
+  });
+}
+
+function addTableData(that, tableRef, value, success) {
+  if (
+    configUtil.tableConfig.disableTableName
+    || settingConfig.tableStorageDisabled
+  )
+    return false;
+  let $grid = getGrid(that, tableRef);
+  let tableName = $grid.tableName;
+  if (tableName) {
+    that.$http({
+      method: "post",
+      url: USER_PREFIX + "/table_column/addTableData",
+      data: {
+        tableName: tableName,
+        type: "isQueryAllPage",
+        data: value,
+        success: success,
+      },
+    });
+  }
+}
+
+function checkQueryTotal(that, tableRef, value) {
+  let $grid = getGrid(that, tableRef);
+  $grid.isQueryAllPage = value;
+  let tableName = $grid.tableName;
+  let option = $grid.getProxyInfo();
+  let pagerConfig = $grid.pagerConfig;
+
+  $grid.pagerConfig.layouts = pagerConfig.layouts || [];
+  addTableData(that, tableRef, value);
+  $grid.commitProxy("query");
+}
+
+function getPagerConfigLayouts(opts) {
+  if (opts.showPageSizes !== false) {
+    return ["Sizes", "PrevPage", "JumpNumber", "NextPage"];
+  } else {
+    return ["PrevPage", "JumpNumber", "NextPage"];
+  }
+}
+
+modules = {
+  initVxeTable,
+  columnDrop,
+  initOption,
+  getTableJson,
+  addTableJson,
+  onColumnWitchChange,
+  customHandle,
+  changeSelectCount,
+  getTableData,
+  addTableData,
+  checkQueryTotal,
+  getCellValue,
+  createParams,
+};
+
+if (!configUtil.Vue.prototype.$vxeTableUtil)
+  configUtil.Vue.prototype.$vxeTableUtil = modules;
+
+export default modules;