@jeecg/online 1.0.1

package/useTableColumns.js

@@ -0,0 +1,1154 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { E as ENHANCEJS, c as SETUP } from "./FormSchemaFactory.js";
+import { useRoute, useRouter } from "vue-router";
+import * as vue from "vue";
+import { ref, onBeforeUnmount, toRaw, nextTick, reactive, computed, unref, h, defineAsyncComponent, watch } from "vue";
+import * as UTIL_AXIOS from "/@/utils/http/axios";
+import { defHttp } from "/@/utils/http/axios";
+import * as HOOK_MESSAGE from "/@/hooks/web/useMessage";
+import { useMessage } from "/@/hooks/web/useMessage";
+import { randomString, filterObj, getFileAccessHttpUrl } from "/@/utils/common/compUtils";
+import * as UTIL_CACHE from "/@/utils/cache";
+import { onMountedOrActivated } from "/@/hooks/core/onMountedOrActivated";
+import { useModal } from "/@/components/Modal";
+import { Modal } from "ant-design-vue";
+import { useMethods } from "/@/hooks/system/useMethods";
+import { p as pick } from "./pick.js";
+import { filterMultiDictText } from "/@/utils/dict/JDictSelectUtil";
+import { getAreaTextByCode } from "/@/components/Form/src/utils/Area";
+import { createImgPreview } from "/@/components/Preview/index";
+const $exports = {
+  vue,
+  "@": {
+    hooks: {
+      useMessage: HOOK_MESSAGE
+    },
+    utils: {
+      axios: UTIL_AXIOS,
+      cache: UTIL_CACHE
+    }
+  }
+};
+function useCustomHook(otherExports, context) {
+  const assignExports = Object.assign({}, $exports, otherExports);
+  function doImport(path) {
+    if (path != null && path != "") {
+      let paths = path.toString().split("/");
+      let result = assignExports[paths[0]];
+      for (let i = 1; i < paths.length; i++) {
+        result = result[paths[i]];
+      }
+      return result;
+    }
+    return null;
+  }
+  function doExport() {
+  }
+  function executeJsEnhanced(code) {
+    let randomKey = randomString(6);
+    let exportKey = "__export_" + randomKey;
+    const executeCode = `return function (customImport, ${exportKey}) {"use strict"; ${code}}`;
+    console.group("executeJsEnhanced");
+    console.log(executeCode);
+    console.groupEnd();
+    const fun = new Function(executeCode)();
+    fun.call(context, doImport, doExport);
+  }
+  return {
+    executeJsEnhanced
+  };
+}
+const CONTEXT_PROP_DESCRIPTION = {
+  acceptHrefParams: "<p> \u8DF3\u8F6C\u65F6\u83B7\u53D6\u7684\u53C2\u6570\u4FE1\u606F",
+  currentPage: "<p> \u5F53\u524D\u9875\u6570",
+  currentTableName: "<p> \u5F53\u524D\u8868\u540D",
+  description: "<p> \u5F53\u524D\u8868\u63CF\u8FF0",
+  hasChildrenField: "<p> \u662F\u5426\u6709\u5B50\u8282\u70B9\u7684\u5B57\u6BB5\u540D\uFF0C\u4EC5\u6811\u5F62\u8868\u5355\u4E0B\u6709\u6548",
+  isDesForm: "<p> xx",
+  isTree: "<m> \u662F\u5426\u662F\u6811\u5F62\u8868\u5355 ",
+  loadData: "<m> \u52A0\u8F7D\u5217\u8868\u6570\u636E",
+  pageSize: "<p> \u6BCF\u4E00\u9875\u663E\u793A\u6761\u6570",
+  queryParam: "<p> \u67E5\u8BE2\u6761\u4EF6\u5BF9\u8C61\uFF0C\u6BCF\u6B21\u70B9\u51FB\u67E5\u8BE2\u540E\u624D\u4F1A\u66F4\u65B0\u6B64\u6570\u636E",
+  selectedRowKeys: "<p> \u9009\u4E2D\u7684\u884C\u7684id\u6570\u7EC4",
+  sortField: "<p> \u6392\u5E8F\u5B57\u6BB5",
+  sortType: "<p> \u6392\u5E8F\u89C4\u5219",
+  total: "<p> \u603B\u9875\u6570"
+};
+const onlineUrl = {
+  getColumns: "/online/cgform/api/getColumns/",
+  getQueryInfo: "/online/cgform/api/getQueryInfo/",
+  getData: "/online/cgform/api/getData/",
+  getTreeData: "/online/cgform/api/getTreeData/",
+  optPre: "/online/cgform/api/form/",
+  buttonAction: "/online/cgform/api/doButton",
+  exportXls: "/online/cgform/api/exportXls/",
+  importXls: "/online/cgform/api/importXls/",
+  startProcess: "/act/process/extActProcess/startMutilProcess"
+};
+let config = {
+  sortField: "id",
+  sortType: "asc",
+  currentPage: 1,
+  pageSize: 10,
+  total: 0,
+  selectedRowKeys: [],
+  queryParam: {},
+  acceptHrefParams: {},
+  description: "",
+  currentTableName: "",
+  isDesForm: false,
+  desFormCode: "",
+  cache: false,
+  isTree: false,
+  hasChildrenField: ""
+};
+const metaPagination = {
+  current: 1,
+  pageSize: 10,
+  pageSizeOptions: ["10", "20", "30"],
+  showTotal: (total, range) => {
+    return range[0] + "-" + range[1] + " \u5171" + total + "\u6761";
+  },
+  showQuickJumper: true,
+  showSizeChanger: true,
+  total: 0
+};
+const { createMessage: $message } = useMessage();
+const GET_FUN_BODY_REG = /(?:\/\*[\s\S]*?\*\/|\/\/.*?\r?\n|[^{])+\{([\s\S]*)\}$/;
+function useOnlineTableContext() {
+  console.log("-------------------------useOnlineTableContext----------------------->");
+  const ID = ref("");
+  const route = useRoute();
+  const onlineQueryFormOuter = ref();
+  const superQueryButtonRef = ref();
+  const pagination = ref(false);
+  const dataSource = ref([]);
+  let specialConfigMap = {};
+  const methods = {
+    execButtonEnhance: function(code, record2) {
+      if (onlineTableContext2[ENHANCEJS][code]) {
+        if (SETUP === code) {
+          executeEnhanceJsHook(code);
+        } else {
+          let row = toRaw(record2);
+          return onlineTableContext2[ENHANCEJS][code].call(onlineTableContext2, onlineTableContext2, row);
+        }
+      } else if (onlineTableContext2[ENHANCEJS][code + "_hook"]) {
+        executeEnhanceJsHook(code + "_hook");
+      } else {
+        console.log("\u589E\u5F3A\u6CA1\u627E\u5230!", code);
+      }
+    },
+    isTree: function(status) {
+      if (typeof status === "boolean") {
+        onlineTableContext2["isTreeTable"] = status;
+        return status;
+      } else {
+        return onlineTableContext2["isTreeTable"];
+      }
+    }
+  };
+  function executeEnhanceJsHook(code) {
+    let str = onlineTableContext2[ENHANCEJS][code].toLocaleString();
+    let arr = str.match(GET_FUN_BODY_REG);
+    if (arr.length > 1) {
+      let temp = arr[1];
+      executeJsEnhanced(temp);
+    }
+  }
+  const onlineTableContext2 = new Proxy(CONTEXT_PROP_DESCRIPTION, {
+    get(_target, prop) {
+      if (typeof methods[prop] === "function") {
+        return methods[prop];
+      } else {
+        let temp = specialConfigMap[ID.value];
+        return Reflect.get(temp, prop);
+      }
+    },
+    set(_target, prop, value) {
+      let temp = getCurrentPageSpecialConfigMap();
+      if (typeof value === "function") {
+        return Reflect.set(methods, prop, value);
+      } else {
+        return Reflect.set(temp, prop, value);
+      }
+    },
+    deleteProperty(_target, key) {
+      if (key === ID.value) {
+        delete specialConfigMap[key];
+        return true;
+      } else {
+        return false;
+      }
+    }
+  });
+  const { executeJsEnhanced } = useCustomHook({}, onlineTableContext2);
+  function getTableId() {
+    let idValue = route.params.id;
+    if (!idValue) {
+      idValue = "";
+    }
+    return idValue;
+  }
+  onMountedOrActivated(() => {
+    console.log("-------------------onMountedOrActivated-------------------");
+    handlePageChange();
+  });
+  onBeforeUnmount(() => {
+    console.log("-------------------onBeforeUnmount-------------------");
+    delete specialConfigMap[ID.value];
+  });
+  function getCurrentPageSpecialConfigMap() {
+    let temp = specialConfigMap[ID.value];
+    if (!temp) {
+      let obj = Object.assign({}, config, { onlineUrl });
+      temp = JSON.parse(JSON.stringify(obj));
+      specialConfigMap[ID.value] = temp;
+    }
+    return temp;
+  }
+  function handleAcceptHrefParams() {
+    let acceptHrefParams = {};
+    let hrefParam = route.query;
+    if (hrefParam) {
+      Object.keys(hrefParam).map((key) => {
+        acceptHrefParams[key] = hrefParam[key];
+      });
+      onlineTableContext2["acceptHrefParams"] = acceptHrefParams;
+    }
+  }
+  function getColumnList() {
+    return new Promise((resolve, reject) => {
+      defHttp.get({
+        url: `${onlineTableContext2.onlineUrl.getColumns}${ID.value}`
+      }, { isTransformResponse: false }).then((res) => {
+        if (res.success) {
+          resolve(res.result);
+        } else {
+          $message.warning(res.message);
+          reject();
+        }
+      }).catch(() => {
+        reject();
+      });
+    });
+  }
+  function loadData() {
+    return new Promise((resolve, reject) => {
+      let url = `${onlineTableContext2.onlineUrl.getData}${ID.value}`;
+      if (onlineTableContext2.isTree() === true) {
+        url = `${onlineTableContext2.onlineUrl.getTreeData}${ID.value}`;
+      }
+      let params = getLoadDataParams();
+      console.log("------\u67E5\u8BE2\u53C2\u6570-----", params);
+      defHttp.get({ url, params }, { isTransformResponse: false }).then((res) => {
+        console.log("--onlineList-\u67E5\u8BE2\u5217\u8868\u6570\u636E", res);
+        if (res.success) {
+          handleDataResult(res.result);
+          resolve(true);
+        } else {
+          $message.warning(res.message);
+          reject(false);
+        }
+      }).catch(() => {
+        let error = "\u8BF7\u6C42\u5217\u8868\u6570\u636E\u5F02\u5E38!";
+        $message.warning(error);
+        reject(false);
+      });
+    });
+  }
+  function getLoadDataParams() {
+    const { sortField, sortType, acceptHrefParams, queryParam } = onlineTableContext2;
+    let treeParam = {};
+    if (onlineTableContext2.isTree() === true) {
+      treeParam["hasQuery"] = "false";
+    } else {
+      treeParam["hasQuery"] = "true";
+    }
+    let params = Object.assign({}, treeParam, acceptHrefParams, queryParam, { column: sortField, order: sortType });
+    if (pagination.value) {
+      params.pageNo = pagination.value.current;
+      params.pageSize = pagination.value.pageSize;
+    } else {
+      params["pageSize"] = -521;
+    }
+    let superQueryData = getSuperQueryData();
+    params.superQueryMatchType = superQueryData.matchType || "";
+    params.superQueryParams = superQueryData.params || "";
+    return filterObj(params);
+  }
+  function handleDataResult(result) {
+    let total = 0;
+    if (Number(result.total) > 0) {
+      if (onlineTableContext2.isTree() === true) {
+        dataSource.value = getTreeDataByResult(result.records);
+        nextTick(() => {
+          loadDataByExpandedRows(dataSource.value);
+        });
+      } else {
+        dataSource.value = result.records;
+      }
+      total = Number(result.total);
+    } else {
+      dataSource.value = [];
+    }
+    if (pagination.value) {
+      pagination.value = __spreadProps(__spreadValues({}, pagination.value), { total });
+    }
+  }
+  function handleChangeInTable($pagination, _filters, sorter) {
+    if (sorter && sorter.order) {
+      onlineTableContext2["sortField"] = sorter.field;
+      onlineTableContext2["sortType"] = sorter.order == "ascend" ? "asc" : "desc";
+    } else {
+      onlineTableContext2["sortField"] = "id";
+      onlineTableContext2["sortType"] = "asc";
+    }
+    if (pagination.value) {
+      pagination.value = $pagination;
+    }
+    loadData();
+  }
+  function handleSpecialConfig(result) {
+    onlineTableContext2["description"] = result.description;
+    onlineTableContext2["currentTableName"] = result.currentTableName;
+    onlineTableContext2["isDesForm"] = result.isDesForm;
+    onlineTableContext2["desFormCode"] = result.desFormCode;
+    onlineTableContext2["ID"] = ID.value;
+    let { acceptHrefParams, queryParam, superQuery, currentPage, pageSize } = onlineTableContext2;
+    handleAcceptHrefParams();
+    if (!queryParam) {
+      onlineTableContext2["queryParam"] = {};
+    } else {
+      onlineQueryFormOuter.value.initDefaultValues(queryParam, acceptHrefParams);
+    }
+    if (!superQuery) {
+      onlineTableContext2["superQuery"] = { params: "", matchType: "" };
+    } else {
+      superQueryButtonRef.value.initDefaultValues(superQuery);
+    }
+    if (result.paginationFlag == "Y") {
+      pagination.value = __spreadValues(__spreadValues({}, metaPagination), { current: currentPage, pageSize });
+    } else {
+      pagination.value = false;
+    }
+  }
+  const add2Context = {
+    loadData,
+    getLoadDataParams
+  };
+  Object.keys(add2Context).map((key) => {
+    onlineTableContext2[key] = add2Context[key];
+  });
+  let loading = ref(false);
+  function reload() {
+    return __async(this, null, function* () {
+      if (pagination.value) {
+        pagination.value = __spreadProps(__spreadValues({}, pagination.value), { current: 1 });
+      }
+      onlineTableContext2.clearSelectedRow();
+      yield loadData();
+    });
+  }
+  function getTreeDataByResult(result) {
+    if (result) {
+      return result.map((item) => {
+        let hasChildrenField = onlineTableContext2["hasChildrenField"];
+        if (item[hasChildrenField] == "1") {
+          let loadChild = { id: item.id + "_loadChild", name: "loading...", isLoading: true };
+          loadChild["jeecg_row_key"] = loadChild.id;
+          item.children = [loadChild];
+        }
+        return item;
+      });
+    }
+  }
+  const expandedRowKeys = ref([]);
+  function handleExpandedRowsChange(expandedRowKeysValue) {
+    expandedRowKeys.value = expandedRowKeysValue;
+  }
+  function loadDataByExpandedRows(dataList) {
+    let expandedRowKeysValue = expandedRowKeys.value;
+    if (expandedRowKeysValue.length > 0) {
+      const { sortField, sortType, pidField } = onlineTableContext2;
+      let params = Object.assign({}, { column: sortField, order: sortType });
+      params["hasQuery"] = "in";
+      let superParams = Object.assign({});
+      superParams.rule = "in";
+      superParams.type = "text";
+      superParams.val = expandedRowKeysValue.join(",");
+      superParams.field = pidField;
+      superParams = [superParams];
+      params["superQueryParams"] = encodeURI(JSON.stringify(superParams));
+      params["superQueryMatchType"] = "and";
+      params["batchFlag"] = "true";
+      let url = `${onlineTableContext2.onlineUrl.getTreeData}${ID.value}`;
+      console.log("--onlineList-\u67E5\u8BE2\u5B50\u8282\u70B9\u53C2\u6570", superParams);
+      defHttp.get({ url, params }, { isTransformResponse: false }).then((res) => {
+        console.log("--onlineList-\u67E5\u8BE2\u5B50\u8282\u70B9\u5217\u8868\u6570\u636E", res);
+        if (res.success && res.result.records && res.result.records.length > 0) {
+          let records = res.result.records;
+          const listMap = /* @__PURE__ */ new Map();
+          for (let item of records) {
+            let pid = item[pidField];
+            if (expandedRowKeysValue.join(",").includes(pid)) {
+              let mapList = listMap.get(pid);
+              if (mapList == null) {
+                mapList = [];
+              }
+              mapList.push(item);
+              listMap.set(pid, mapList);
+            }
+          }
+          let childrenMap = listMap;
+          let fn = (list) => {
+            if (list) {
+              list.forEach((data) => {
+                if (expandedRowKeysValue.includes(data.id)) {
+                  data.children = getTreeDataByResult(childrenMap.get(data.id));
+                  fn(data.children);
+                }
+              });
+            }
+          };
+          fn(dataList);
+        }
+      }).catch(() => {
+        let error = "loadDataByExpandedRows\u8BF7\u6C42\u5217\u8868\u6570\u636E\u5F02\u5E38!";
+        $message.warning(error);
+      });
+    } else {
+      return Promise.resolve();
+    }
+  }
+  function getSuperQueryData() {
+    if (!onlineTableContext2.superQuery) {
+      return {};
+    }
+    const { superQuery: { params, matchType }, currentTableName } = onlineTableContext2;
+    let pre = currentTableName + "@";
+    let arr = [];
+    if (params.length > 0) {
+      for (let data of params) {
+        let item = __spreadValues({}, data);
+        let field2 = item.field;
+        if (field2.startsWith(pre)) {
+          item.field = field2.replace(pre, "");
+        }
+        arr.push(item);
+      }
+    }
+    let str = arr.length > 0 ? JSON.stringify(arr) : "";
+    console.log("\u9AD8\u7EA7\u67E5\u8BE2\u6761\u4EF6", arr, matchType);
+    return {
+      params: encodeURIComponent(str),
+      matchType
+    };
+  }
+  const superQueryStatus = ref(false);
+  function handleSuperQuery(params, matchType) {
+    onlineTableContext2["superQuery"] = {
+      params,
+      matchType
+    };
+    if (params.length == 0) {
+      superQueryStatus.value = false;
+    } else {
+      superQueryStatus.value = true;
+    }
+    loadData();
+  }
+  const [registerCustomModal, { openModal: doOpenCustomModal }] = useModal();
+  function openCustomModal(param) {
+    if (!param) {
+      param = {};
+    }
+    if (!param.row) {
+      let rows = onlineTableContext2["selectedRows"];
+      if (!rows || rows.length == 0 || rows.length > 1) {
+        $message.warning("\u8BF7\u9009\u62E9\u4E00\u6761\u6570\u636E");
+        return;
+      }
+      param.row = rows[0];
+    }
+    param["code"] = ID.value;
+    doOpenCustomModal(true, param);
+  }
+  onlineTableContext2["openCustomModal"] = openCustomModal;
+  function handlePageChange() {
+    let idValue = getTableId();
+    ID.value = idValue;
+  }
+  handlePageChange();
+  return __spreadValues({
+    ID,
+    onlineQueryFormOuter,
+    superQueryButtonRef,
+    loading,
+    reload,
+    dataSource,
+    pagination,
+    handleSpecialConfig,
+    onlineTableContext: onlineTableContext2,
+    handleChangeInTable,
+    getColumnList,
+    getTreeDataByResult,
+    expandedRowKeys,
+    handleExpandedRowsChange,
+    superQueryStatus,
+    handleSuperQuery,
+    registerCustomModal
+  }, add2Context);
+}
+const FLOW_CODE_PRE = "onl_";
+function useListButton(onlineTableContext2) {
+  const buttonStatus = {
+    add: true,
+    addSub: true,
+    update: true,
+    delete: true,
+    batch_delete: true,
+    import: true,
+    export: true,
+    detail: true,
+    super_query: true,
+    bpm: true
+  };
+  const [registerModal, { openModal }] = useModal();
+  const [registerImportModal, { openModal: openImportModal }] = useModal();
+  const { createMessage: $message2 } = useMessage();
+  const buttonSwitch = reactive(buttonStatus);
+  const cgLinkButtonList = reactive([]);
+  const cgTopButtonList = reactive([]);
+  function initButtonList(btnList) {
+    cgLinkButtonList.length = 0;
+    cgTopButtonList.length = 0;
+    if (btnList && btnList.length > 0) {
+      for (let i = 0; i < btnList.length; i++) {
+        let temp = pick(btnList[i], "buttonCode", "buttonName", "buttonStyle", "optType", "exp", "buttonIcon");
+        if (temp.buttonStyle == "button") {
+          cgTopButtonList.push(temp);
+        } else if (temp.buttonStyle == "link") {
+          cgLinkButtonList.push(temp);
+        }
+      }
+    }
+  }
+  function initButtonSwitch(hideColumns) {
+    Object.keys(buttonSwitch).forEach((key) => {
+      buttonSwitch[key] = true;
+    });
+    if (hideColumns && hideColumns.length > 0) {
+      Object.keys(buttonSwitch).forEach((key) => {
+        if (hideColumns.indexOf(key) >= 0) {
+          buttonSwitch[key] = false;
+        }
+      });
+    }
+  }
+  function handleAdd(param) {
+    let data = { isUpdate: false };
+    if (param) {
+      data["param"] = param;
+    }
+    openModal(true, data);
+  }
+  function handleEdit(record2) {
+    onlineTableContext2.beforeEdit(record2).then(() => {
+      openModal(true, {
+        isUpdate: true,
+        record: record2
+      });
+    }).catch((msg) => {
+      $message2.warning(msg);
+    });
+  }
+  const getDeleteButton = (record2) => {
+    return {
+      label: "\u5220\u9664",
+      popConfirm: {
+        title: "\u662F\u5426\u5220\u9664\uFF1F",
+        confirm: handleDeleteOne.bind(null, record2)
+      }
+    };
+  };
+  function handleDeleteOne(record2) {
+    onlineTableContext2.beforeDelete(record2).then(() => {
+      handleDelete(record2.id);
+    }).catch((msg) => {
+      $message2.warning(msg);
+    });
+  }
+  function getActions(record2) {
+    if (toRaw(buttonSwitch.update) === true) {
+      return [
+        {
+          label: "\u7F16\u8F91",
+          onClick: handleEdit.bind(null, record2)
+        }
+      ];
+    }
+    return [];
+  }
+  function getSubmitFlowButton(record2) {
+    return {
+      label: "\u63D0\u4EA4\u6D41\u7A0B",
+      popConfirm: {
+        title: "\u786E\u8BA4\u63D0\u4EA4\u6D41\u7A0B\u5417\uFF1F",
+        confirm: handleSubmitFlow.bind(null, record2)
+      }
+    };
+  }
+  function getDropDownActions(record2) {
+    let arr = [];
+    if (toRaw(buttonSwitch.delete) === true) {
+      arr.push({
+        label: "\u8BE6\u60C5",
+        onClick: handleDetail.bind(null, record2)
+      });
+    }
+    if (onlineTableContext2["hasBpmStatus"] === true) {
+      arr.push(getSubmitFlowButton(record2));
+    }
+    if (toRaw(buttonSwitch.delete) === true) {
+      arr.push(getDeleteButton(record2));
+    }
+    let buttonList = cgLinkButtonList;
+    if (buttonList && buttonList.length > 0) {
+      for (let item of buttonList) {
+        if (showLinkButtonOfExpression(item.exp || "", record2) === true) {
+          arr.push({
+            label: item.buttonName,
+            onClick: cgButtonLinkHandler.bind(null, record2, item.buttonCode, item.optType)
+          });
+        }
+      }
+    }
+    return arr;
+  }
+  function handleDetail(record2) {
+    openModal(true, {
+      isUpdate: true,
+      disableSubmit: true,
+      record: record2
+    });
+  }
+  function startProcess(record2) {
+    const { currentTableName, onlineUrl: { startProcess: startProcess2 } } = onlineTableContext2;
+    let postConfig = {
+      url: startProcess2,
+      params: {
+        flowCode: FLOW_CODE_PRE + currentTableName,
+        id: record2.id,
+        formUrl: "modules/bpm/task/form/OnlineFormDetail",
+        formUrlMobile: "check/onlineForm/detail"
+      }
+    };
+    let postOption = { isTransformResponse: false };
+    return new Promise((resolve, reject) => {
+      defHttp.post(postConfig, postOption).then((res) => {
+        if (res.success) {
+          resolve(res);
+          $message2.success(res.message);
+        } else {
+          reject();
+          $message2.warning(res.message);
+        }
+      });
+    });
+  }
+  function handleSubmitFlow(record2) {
+    return __async(this, null, function* () {
+      yield startProcess(record2);
+      onlineTableContext2.loadData();
+    });
+  }
+  function handleDelete(dataId) {
+    console.log("\u5220\u9664\u6570\u636Eid\u503C", dataId);
+    let url = `${onlineTableContext2.onlineUrl.optPre}${onlineTableContext2.ID}/${dataId}`;
+    return new Promise((resolve, reject) => {
+      defHttp.delete({
+        url
+      }, { isTransformResponse: false }).then((res) => {
+        if (res.success) {
+          $message2.success(res.message);
+          onlineTableContext2.loadData();
+          resolve(true);
+        } else {
+          $message2.warning(res.message);
+          reject();
+        }
+      });
+    });
+  }
+  function handleBatchDelete() {
+    let arr = onlineTableContext2["selectedRowKeys"];
+    if (arr.length <= 0) {
+      $message2.warning("\u8BF7\u9009\u62E9\u4E00\u6761\u8BB0\u5F55\uFF01");
+      return false;
+    } else {
+      let idSet = [];
+      arr.forEach(function(val) {
+        let temp = val;
+        if (temp && temp.endsWith("_loadChild")) {
+          temp = temp.replace("_loadChild", "");
+        }
+        if (idSet.indexOf(temp) < 0) {
+          idSet.push(temp);
+        }
+      });
+      let ids = idSet.join(",");
+      Modal.confirm({
+        title: "\u786E\u8BA4\u5220\u9664",
+        content: "\u662F\u5426\u5220\u9664\u9009\u4E2D\u6570\u636E",
+        okText: "\u786E\u8BA4",
+        cancelText: "\u53D6\u6D88",
+        onOk: () => __async(this, null, function* () {
+          yield handleDelete(ids);
+          onlineTableContext2.clearSelectedRow();
+        })
+      });
+    }
+  }
+  function cgButtonLinkHandler(record2, buttonCode, optType) {
+    if (optType == "js") {
+      onlineTableContext2["execButtonEnhance"](buttonCode, record2);
+    } else if (optType == "action") {
+      let params = {
+        formId: onlineTableContext2["ID"],
+        buttonCode,
+        dataId: record2.id
+      };
+      let url = `${onlineTableContext2.onlineUrl.buttonAction}`;
+      defHttp.post({
+        url,
+        params
+      }, { isTransformResponse: false }).then((res) => {
+        if (res.success) {
+          onlineTableContext2.loadData();
+          $message2.success("\u5904\u7406\u5B8C\u6210!");
+        } else {
+          $message2.warning(res.message);
+        }
+      });
+    }
+  }
+  function cgButtonJsHandler(buttonCode) {
+    onlineTableContext2["execButtonEnhance"](buttonCode);
+  }
+  function cgButtonActionHandler(buttonCode) {
+    let arr = onlineTableContext2["selectedRowKeys"];
+    if (!arr || arr.length == 0) {
+      $message2.warning("\u8BF7\u5148\u9009\u4E2D\u4E00\u6761\u8BB0\u5F55");
+      return false;
+    }
+    let dataId = arr.join(",");
+    let params = {
+      formId: onlineTableContext2["ID"],
+      buttonCode,
+      dataId
+    };
+    let url = `${onlineTableContext2.onlineUrl.buttonAction}`;
+    defHttp.post({
+      url,
+      params
+    }, { isTransformResponse: false }).then((res) => {
+      if (res.success) {
+        onlineTableContext2.loadData();
+        onlineTableContext2.clearSelectedRow();
+        $message2.success("\u5904\u7406\u5B8C\u6210!");
+      } else {
+        $message2.warning(res.message);
+      }
+    });
+  }
+  function onImportExcel() {
+    openImportModal(true);
+  }
+  const importUrl = () => {
+    return `${onlineTableContext2.onlineUrl.importXls}${onlineTableContext2.ID}`;
+  };
+  const { handleExportXlsx } = useMethods();
+  function onExportExcel() {
+    let params = onlineTableContext2.getLoadDataParams();
+    let selections = onlineTableContext2["selectedRowKeys"];
+    if (selections && selections.length > 0) {
+      params["selections"] = selections.join(",");
+    }
+    let paramsStr = JSON.stringify(filterObj(params));
+    let url = `${onlineTableContext2.onlineUrl.exportXls}${onlineTableContext2.ID}`;
+    const description = onlineTableContext2.description;
+    handleExportXlsx(description, url, { paramsStr });
+  }
+  function showLinkButtonOfExpression(expression, row) {
+    if (!expression || expression == "") {
+      return true;
+    }
+    let arr = expression.split("#");
+    let fieldValue = row[arr[0]];
+    let exp = arr[1].toLowerCase();
+    if (exp === "eq") {
+      return fieldValue == arr[2];
+    } else if (exp === "ne") {
+      return !(fieldValue == arr[2]);
+    } else if (exp === "empty") {
+      if (arr[2] === "true") {
+        return !fieldValue || fieldValue == "";
+      } else {
+        return fieldValue && fieldValue.length > 0;
+      }
+    } else if (exp === "in") {
+      let arr2 = arr[2].split(",");
+      return arr2.indexOf(String(fieldValue)) >= 0;
+    }
+    return false;
+  }
+  return {
+    buttonSwitch,
+    cgLinkButtonList,
+    cgTopButtonList,
+    importUrl,
+    registerModal,
+    handleAdd,
+    handleEdit,
+    handleBatchDelete,
+    registerImportModal,
+    onImportExcel,
+    onExportExcel,
+    getDropDownActions,
+    getActions,
+    cgButtonJsHandler,
+    cgButtonActionHandler,
+    cgButtonLinkHandler,
+    initButtonList,
+    initButtonSwitch,
+    getDeleteButton,
+    handleSubmitFlow,
+    getSubmitFlowButton
+  };
+}
+function useTableColumns(onlineTableContext) {
+  let router = useRouter();
+  const columns = ref([]);
+  const dictOptionInfo = ref({});
+  const selectedKeys = ref([]);
+  const rowSelection = ref(null);
+  let enableScrollBar = ref(true);
+  let tableScroll = computed(() => {
+    if (enableScrollBar.value == true) {
+      return void 0;
+    } else {
+      return { x: false };
+    }
+  });
+  function handleColumnResult(result) {
+    dictOptionInfo.value = result.dictOptions;
+    if (result.checkboxFlag == "Y") {
+      rowSelection.value = {
+        selectedRowKeys: selectedKeys,
+        onChange: onSelectChange
+      };
+    } else {
+      rowSelection.value = null;
+    }
+    enableScrollBar.value = result.scrollFlag == 1;
+    let dataColumns = result.columns;
+    dataColumns.forEach((column) => {
+      Object.keys(column).map((key) => {
+        if (column[key] == null) {
+          delete column[key];
+        }
+      });
+    });
+    let fieldHrefSlots = result.fieldHrefSlots;
+    const fieldHrefSlotKeysMap = {};
+    fieldHrefSlots.forEach((item) => fieldHrefSlotKeysMap[item.slotName] = item);
+    let tableColumns = [];
+    tableColumns = handleColumnHrefAndDict(dataColumns, fieldHrefSlotKeysMap);
+    bpmStatusFilter(tableColumns);
+    console.log("-----\u5217\u8868\u5217\u914D\u7F6E----", tableColumns);
+    if (onlineTableContext.isTree() === true) {
+      let firstField = result.textField;
+      let index = -1;
+      for (let i = 0; i < tableColumns.length; i++) {
+        if (tableColumns[i].dataIndex == firstField) {
+          index = i;
+          break;
+        }
+      }
+      if (index > 0) {
+        let deleteColumns = tableColumns.splice(index, 1);
+        tableColumns.unshift(deleteColumns[0]);
+      }
+      if (tableColumns.length > 0) {
+        tableColumns[0].align = "left";
+      }
+    }
+    columns.value = tableColumns;
+  }
+  function onSelectChange(selectedRowKeys, selectedRows) {
+    selectedKeys.value = selectedRowKeys;
+    onlineTableContext["selectedRows"] = toRaw(selectedRows);
+    onlineTableContext["selectedRowKeys"] = toRaw(selectedRowKeys);
+  }
+  function handleColumnHrefAndDict(columns2, fieldHrefSlotKeysMap) {
+    for (let column of columns2) {
+      let { customRender, hrefSlotName, fieldType } = column;
+      if (fieldType == "Date") {
+        column.customRender = ({ text: text2 }) => {
+          if (!text2) {
+            return "";
+          }
+          if (text2.length > 10) {
+            return text2.substring(0, 10);
+          }
+          return text2;
+        };
+      } else {
+        if (!hrefSlotName && (column.scopedSlots && column.scopedSlots.customRender)) {
+          if (fieldHrefSlotKeysMap.hasOwnProperty(column.scopedSlots.customRender)) {
+            hrefSlotName = column.scopedSlots.customRender;
+          }
+        }
+        if (customRender || hrefSlotName) {
+          let dictCode = customRender;
+          let replaceFlag = "_replace_text_";
+          column.ellipsis = true;
+          column.customRender = ({ text: text2, record: record2 }) => {
+            let value = text2;
+            if (dictCode) {
+              if (dictCode.startsWith(replaceFlag)) {
+                let textFieldName = dictCode.replace(replaceFlag, "");
+                value = record2[textFieldName];
+              } else {
+                value = filterMultiDictText(unref(dictOptionInfo)[dictCode], text2 + "");
+              }
+            }
+            if (column.showLength) {
+              if (value && value.length > column.showLength) {
+                value = value.substr(0, column.showLength) + "...";
+              }
+            }
+            if (hrefSlotName) {
+              let field2 = fieldHrefSlotKeysMap[hrefSlotName];
+              if (field2) {
+                return h("a", {
+                  onClick: () => handleClickFieldHref(field2, record2)
+                }, value);
+              }
+            }
+            return value;
+          };
+        }
+        if (column.scopedSlots) {
+          column.ellipsis = true;
+          let slots = column.scopedSlots;
+          column["slots"] = slots;
+          delete column.scopedSlots;
+        }
+      }
+    }
+    return columns2;
+  }
+  function handleClickFieldHref(field, record) {
+    let href = field.href;
+    let urlPattern = /(ht|f)tp(s?)\:\/\/[0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*(:(0-9)*)*(\/?)([a-zA-Z0-9\-\.\?\,\'\/\\\+&amp;%\$#_]*)?/;
+    let compPattern = /\.vue(\?.*)?$/;
+    let jsPattern = /{{([^}]+)}}/g;
+    if (typeof href === "string") {
+      href = href.trim().replace(/\${([^}]+)?}/g, (_s1, s2) => record[s2]);
+      if (jsPattern.test(href)) {
+        href = href.replace(jsPattern, function(text, s0) {
+          try {
+            return eval(s0);
+          } catch (e) {
+            console.error(e);
+            return text;
+          }
+        });
+      }
+      if (urlPattern.test(href)) {
+        window.open(href, "_blank");
+      } else if (compPattern.test(href)) {
+        openHrefCompModal(href);
+      } else {
+        router.push(href);
+      }
+    }
+  }
+  const dialogStyle = {
+    top: 0,
+    left: 0,
+    height: "100%",
+    margin: 0,
+    padding: 0
+  };
+  const hrefComponent = reactive({
+    model: {
+      title: "",
+      okText: "\u5173\u95ED",
+      width: "100%",
+      visible: false,
+      destroyOnClose: true,
+      style: dialogStyle,
+      bodyStyle: { padding: "8px", height: "calc(100vh - 108px)", overflow: "auto", overflowX: "hidden" },
+      cancelButtonProps: { style: { display: "none" } }
+    },
+    on: {
+      ok: () => hrefComponent.model.visible = false,
+      cancel: () => hrefComponent.model.visible = false
+    },
+    is: null,
+    params: {}
+  });
+  function openHrefCompModal(href2) {
+    let index = href2.indexOf("?");
+    let path = href2;
+    if (index !== -1) {
+      path = href2.substring(0, index);
+      let paramString = href2.substring(index + 1, href2.length);
+      let paramArray = paramString.split("&");
+      let params = {};
+      paramArray.forEach((paramObject) => {
+        let paramItem = paramObject.split("=");
+        params[paramItem[0]] = paramItem[1];
+      });
+      hrefComponent.params = params;
+    } else {
+      hrefComponent.params = {};
+    }
+    hrefComponent.model.visible = true;
+    hrefComponent.model.title = "\u64CD\u4F5C";
+    hrefComponent.is = defineAsyncComponent(() => import(
+      /* @vite-ignore */
+      "/@/views/" + (path.startsWith("/") ? path.slice(1) : path)
+    ));
+  }
+  const actionColumn = reactive({
+    title: "\u64CD\u4F5C",
+    dataIndex: "action",
+    slots: { customRender: "action" },
+    align: "center",
+    width: 150
+  });
+  function bpmStatusFilter(tableColumns) {
+    let flag = false;
+    for (let i = 0; i < tableColumns.length; i++) {
+      let item = tableColumns[i];
+      let fieldName = item.dataIndex;
+      if (fieldName.toLowerCase() == "bpm_status") {
+        flag = true;
+        break;
+      }
+    }
+    onlineTableContext["hasBpmStatus"] = flag;
+    return flag;
+  }
+  function downloadRowFile(text2) {
+    if (!text2) {
+      return;
+    }
+    if (text2.indexOf(",") > 0) {
+      text2 = text2.substring(0, text2.indexOf(","));
+    }
+    let url = getFileAccessHttpUrl(text2);
+    window.open(url);
+  }
+  function getImgView(text2) {
+    if (text2 && text2.indexOf(",") > 0) {
+      text2 = text2.substring(0, text2.indexOf(","));
+    }
+    return getFileAccessHttpUrl(text2);
+  }
+  function getPcaText(code) {
+    if (!code) {
+      return "";
+    }
+    return getAreaTextByCode(code);
+  }
+  function getFormatDate(text2) {
+    if (!text2) {
+      return "";
+    }
+    let a = text2;
+    if (a.length > 10) {
+      a = a.substring(0, 10);
+    }
+    return a;
+  }
+  watch(selectedKeys, () => {
+    onlineTableContext["selectedRowKeys"] = toRaw(selectedKeys.value);
+  });
+  onlineTableContext["clearSelectedRow"] = () => {
+    selectedKeys.value = [];
+    onlineTableContext["selectedRows"] = [];
+    onlineTableContext["selectedRowKeys"] = [];
+  };
+  function viewOnlineCellImage(text2) {
+    if (text2) {
+      let imgList = [];
+      let arr = text2.split(",");
+      for (let str of arr) {
+        if (str) {
+          imgList.push(getFileAccessHttpUrl(str));
+        }
+      }
+      createImgPreview({ imageList: imgList });
+    }
+  }
+  return {
+    columns,
+    actionColumn,
+    selectedKeys,
+    rowSelection,
+    enableScrollBar,
+    tableScroll,
+    downloadRowFile,
+    getImgView,
+    getPcaText,
+    getFormatDate,
+    handleColumnResult,
+    onSelectChange,
+    hrefComponent,
+    viewOnlineCellImage
+  };
+}
+export { useListButton as a, useTableColumns as b, useOnlineTableContext as u };