检验任务搬迁40%

spring

2025-02-20 2beadb3879986120cb8ddf9ec660175d5b17911e

检验任务搬迁40%

 package.json

@@ -85,7 +85,8 @@
    "sass-loader": "10.1.1",
    "script-ext-html-webpack-plugin": "2.1.5",
    "svg-sprite-loader": "5.1.1",
    "vue-template-compiler": "2.6.12"
    "vue-template-compiler": "2.6.12",
    "worker-loader": "^3.0.8"
  },
  "engines": {
    "node": ">=8.9",

 src/DataWorker.worker.js

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,160 @@
// æ­¤çº¿ç¨‹ä¸ºæ•°æ®é‡‡é›†çº¿ç¨‹

// ä¿å­˜æ•°æ®
// æ•°æ®é‡‡é›†ä¿¡æ¯
let dataAcquisitionInfo = null;
// æ•°æ®åˆ—表
let list = null;
// ä¼ é€’到主线程的数据
let result = {
  method:'',
  value:null
}
// ä¼˜åŒ–数采较多数据时--记录数采项目的Id数组，目的是取最后一个数采项目，传到主线程进行批量的数据采集保存
let arrSpecial = []
// æŽ¥æ”¶ä¸»çº¿ç¨‹ä¼ é€’过来的数据
self.onmessage = function(event) {
  const data = JSON.parse(event.data);
  dataAcquisitionInfo = data.dataAcquisitionInfo;
  list = data.list;
  // console.log(111,dataAcquisitionInfo)
  arrSpecial = []
  // å¤„理数据
  handleData()
}

function handleData(){
  // éåŽ†æ•°æ®åˆ—表
  list.forEach((item,index)=>{
    let num = 0;
    let str = ''
    item.forEach(m=>{
      if(m.v.ps&&(m.v.ps.value=='检验子项'||m.v.ps.value=='检验项'||m.v.ps.value=='检验项分类')){
        if(m.v.ps&&m.v.ps.value=='检验项分类'){
          if(num==0){
            num++
            str = m.v.v+','
          }
        }
        if(m.v.ps&&m.v.ps.value=='检验项'){
          if(num==1){
            str = str+m.v.v + ','
            num++
          } else {
            str = m.v.v+','
            num++
          }
        }
        if(m.v.ps&&m.v.ps.value=='检验子项'){
          str = str+m.v.v
        }
        // ä¸Šé¢åœ¨è®°å½•æ£€éªŒé¡¹+检验子项的名称，如果数采包含检验项+检验子项的数据，则执行
        if(dataAcquisitionInfo[str]){
          let num = 0;//该检验项对应检验值的个数，用用判断最多有多少个检验值，如果多次采集超过了该个数，则赋值给最后一个检验值
          list[index].forEach(n=>{
            if(n.v.ps&&n.v.ps.value&&typeof n.v.ps.value == 'string'&&n.v.ps.value.includes('检验值')){
              num++
            }
          })
          list[index].forEach((n,i)=>{
            if(n.v.ps&&n.v.ps.value&&typeof n.v.ps.value == 'string'&&n.v.ps.value.includes('检验值')){
              let arr = n.v.ps.value.split('值')
              if(Array.isArray(dataAcquisitionInfo[str].value)){
                // å¦‚果数据源为数组，则执行
                for (let i = 0; i < dataAcquisitionInfo[str].value.length; i++) {
                  if(i+1==arr[1]){
                    // èµ‹å€¼æ•°é‡‡ä¼˜åŒ–检验项列表
                    arrSpecial.push(n.i)
                    setTimeout(()=>{
                      let num0 = 0
                      if(n.v.ct&&n.v.ct.fa&&typeof n.v.ct.fa == 'string'&&n.v.ct.fa.includes('.')){
                        // ä¿ç•™æ¨¡æ¿é…ç½®çš„小数点位数
                        let str0 = n.v.ct.fa.split('.')[1]
                        num0 = str0.length
                        n.v.v = dataAcquisitionInfo[str].value[i]?Number(dataAcquisitionInfo[str].value[i]).toFixed(num0):dataAcquisitionInfo[str].value[i]
                      }else{
                        // ç›´æŽ¥èµ‹å€¼
                        n.v.v = dataAcquisitionInfo[str].value[i]
                      }
                      // ä¼ é€’给主线程
                      result = {
                        method:'changeInput',
                        value:{
                          list:list,
                          n:n
                        }
                      }
                      self.postMessage(JSON.stringify(result))
                    },2000)
                  }
                }
              }else{
                // å¦‚果数据源为字符或数字，则执行
                if(arr[1] ==dataAcquisitionInfo[str].frequency){
                  // å¦‚果数采次数等于检验值序号，则赋值给当前检验值
                  arrSpecial.push(n.i)
                  setTimeout(()=>{
                    let num0 = 0
                    if(n.v.ct&&n.v.ct.fa&&typeof n.v.ct.fa == 'string'&&n.v.ct.fa.includes('.')){
                      // ä¿ç•™æ¨¡æ¿é…ç½®çš„小数点位数
                      let str0 = n.v.ct.fa.split('.')[1]
                      num0 = str0.length
                      n.v.v = dataAcquisitionInfo[str].value?Number(dataAcquisitionInfo[str].value).toFixed(num0):dataAcquisitionInfo[str].value
                    }else{
                      // ç›´æŽ¥èµ‹å€¼
                      n.v.v = dataAcquisitionInfo[str].value
                    }
                    // ä¼ é€’给主线程
                    result = {
                      method:'changeInput',
                      value:{
                        list:list,
                        n:n
                      }
                    }
                    self.postMessage(JSON.stringify(result))
                  },2000)
                }else if(Number(dataAcquisitionInfo[str].frequency)>num){
                  // å¦‚果数采次数大于检验值序号，则赋值给最后一个检验值
                  if(n.v.ps.value.includes(num)){
                    arrSpecial.push(n.i)
                    setTimeout(()=>{
                      let num0 = 0
                      if(n.v.ct&&n.v.ct.fa&&typeof n.v.ct.fa == 'string'&&n.v.ct.fa.includes('.')){
                        // ä¿ç•™æ¨¡æ¿é…ç½®çš„小数点位数
                        let str0 = n.v.ct.fa.split('.')[1]
                        num0 = str0.length
                        n.v.v = dataAcquisitionInfo[str].value?Number(dataAcquisitionInfo[str].value).toFixed(num0):dataAcquisitionInfo[str].value
                      }else{
                        // ç›´æŽ¥èµ‹å€¼
                        n.v.v = dataAcquisitionInfo[str].value
                      }
                      // ä¼ é€’给主线程
                      result = {
                        method:'changeInput',
                        value:{
                          list:list,
                          n:n
                        }
                      }
                      self.postMessage(JSON.stringify(result))
                    },2000)
                  }
                }
              }
            }
          })
        }
      }
    })
  })
  // if(arrSpecial[arrSpecial.length-1]){
  //   //优化数采较多数据时-记录最后一个检验项的id，用于后续处理
  //   setTimeout(()=>{
  //     result = {
  //       getDataTypeId:arrSpecial[arrSpecial.length-1],
  //     }
  //     self.postMessage(JSON.stringify(result))
  //   },0)
  // }
}

 src/InspectionWorker.worker.js

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,2352 @@
// å¤šçº¿ç¨‹é‡Œé¢éœ€è¦ä¿å­˜çš„数据
let code = "";
// è¡¨æ ¼æ•°æ®ï¼ˆæ¸²æŸ“）
let tableList = null;
// æ–¹æ³•åˆ—表
let excelMethodList = [];
// excel坐标比较列表
let comparisonList = [];
// å½“前样品信息
let currentSample = {};
// å½“前项目：检测中心、装备电缆
let PROJECT = "";
// å¥—管
let bushing = "";
// å¤šçº¿ç¨‹ä¼ é€’到主线程的数据
let result = {
  method: "",
  value: null,
};

let modelType = "";

// ä¿å­˜æ—¶ä¼ åˆ°åŽç«¯å‚æ•°
let param = null;
// å½“前的模板
let currentTable = "";
// ä¼˜åŒ–数采较多数据时-记录最后一个检验项的id
let getDataTypeId = null;
//当前检验项
let currentInsItem = null;
// æŽ¥æ”¶åˆ°ä¸»çº¿ç¨‹å¤„理逻辑的消息
self.onmessage = function (event) {
  console.log(2222, event);
  // ä¿å­˜ä¸»çº¿ç¨‹ä¼ è¿‡æ¥çš„值
  const data = JSON.parse(event.data);
  if (currentTable != data.currentTable) {
    // æ£€éªŒæ¨¡æ¿æ”¹å˜åŽéœ€è¦åˆ·æ–°è¡¨æ ¼
    tableList = data.tableList;
  }
  currentTable = data.currentTable;
  if (data.type && data.type == "saveData") {
    // æ›´æ–°è¡¨æ ¼æ•°æ®å’Œä¼ é€’到后端的参数
    tableList = data.tableList;
    param = data.param;
    return;
  }
  if (data.bushing && data.bushing != bushing && data.type == "saveData") {
    // æ›´æ–°è¡¨æ ¼æ•°æ®ã€ä¼ é€’到后端的参数和套管数据
    tableList = data.tableList;
    param = data.param;
    bushing = data.bushing;
    return;
  }
  modelType = data.modelType;
  code = data.code;
  if (data.getDataTypeId) {
    // è®°å½• ä¼˜åŒ–数采较多数据时-记录最后一个检验项的id
    getDataTypeId = data.getDataTypeId;
  } else {
    getDataTypeId = null;
  }
  if (tableList) {
    // å¦‚果表格数据存在，则更新当前修改检验项的表格数据
    let str = code.split("-");
    let r = str[1];
    let c = str[2];
    tableList[0].arr.forEach((item, index) => {
      item.forEach((m, i) => {
        if (m.c == c && m.r == r) {
          tableList[0].arr[index] = data.tableList[0].arr[index];
        }
      });
    });
  } else {
    // å¦‚果初始化表格数据不存在，直接赋值
    tableList = data.tableList;
  }
  if (param) {
    // å¦‚果传递到后端的参数存在，则更新当前修改检验项的传递到后端的参数
    let str = code.split("-");
    let pId = str[3];
    param[pId] = data.param[pId];
  } else {
    // åˆå§‹åŒ–传递到后端的参数
    param = data.param;
  }
  if (data.currentInsItem) {
    currentInsItem = data.currentInsItem;
  }
  // æ›´æ–°æ–¹æ³•åˆ—表、坐标比较列表、当前样品信息、项目
  excelMethodList = JSON.parse(JSON.stringify(data.excelMethodList));
  comparisonList = JSON.parse(JSON.stringify(data.comparisonList));
  currentSample = JSON.parse(JSON.stringify(data.currentSample));
  PROJECT = data.PROJECT;
  // æ‰§è¡Œè®¡ç®—方法
  changeInput("", code);
};

function changeInput(m, code) {
  let str = code.split("-");
  let r = str[1]; //当前行
  let c = str[2]; //当前列
  let id = str[0];
  let pId = str[3]; //当前检验项id，param[pId]为当前检验项的所有值，包含：过程值insValue、计算值comValue、设备编码equipValue、设备名称equipName、最终值resValue、结论insResult
  var list = []; //一个双层数组，里面保存有当前页面渲染的所有数据
  // èµ‹å€¼å½“前模板的表格数据
  for (let a in tableList) {
    if (tableList[a].templateId == id) {
      list = tableList[a].arr;
      break;
    }
  }
  let isToExponential = ""; //是否为科学计数法
  let list2 = []; //一个数组，里面保存有当前检验项的所有参数值
  let isPoint = ""; //是否为小数点
  let inputType = null;
  let currentInsItemId = "";
  let isSave = "true";
  // å¾ªçŽ¯æ‰€æœ‰excel方法，找到当前行、列的检验项，如果此单元格（r,c）是某个excel方法里面的参数，则执行此方法
  const index = excelMethodList.findIndex((item) => item.r == r);
  excelMethodList.forEach((item) => {
    inputType =
      item.valueList &&
      item.valueList.length > 0 &&
      item.valueList.find((m) => m.r == r && m.c == c);
    // item.valueList  æ˜¯å½“前excel方法的参数列表，找到当前填入的值是否是参数
    if (
      item.valueList &&
      item.valueList.length > 0 &&
      item.valueList.find((m) => m.r == r && m.c == c)
    ) {
      isSave = "false";
      // å¦‚果是，则定义一个参数的对象集合，用于保存当前excel方法参数的值
      var comValue = {};
      item.valueList.forEach((a) => {
        list.forEach((b) => {
          if (b[0].r == a.r) {
            b.forEach((c) => {
              if (c.c == a.c) {
                // èŽ·å–当前参数的Execl行坐标(ABCD)等等
                var tableCode = "";
                for (var d in comparisonList) {
                  if (c.c == comparisonList[d].value) {
                    tableCode = comparisonList[d].label;
                    break;
                  }
                }
                list2.push(c.v.v);
                // ç»„装参数的对象集合并赋值，列如{A3:12,B4:15}
                if (
                  getInspectionValueType(item.i) == 1 &&
                  !isNaN(parseFloat(c.v.v))
                ) {
                  // å¦‚果是数字输入框
                  let n = String(c.v.v);
                  if (n.includes("/")) {
                    // å¦‚果是分数，则赋值
                    comValue[tableCode + (c.r + 1)] = c.v.v;
                  } else {
                    comValue[tableCode + (c.r + 1)] = parseFloat(c.v.v);
                  }
                } else {
                  // å¦‚果是文本、下拉框等等
                  comValue[tableCode + (c.r + 1)] = c.v.v;
                }
              }
            });
          }
        });
      });
      // å¦‚果此excel方法是结论判断方法，则执行此方法
      // console.log('item.v.ps.value---', item.v.ps.value)
      if (item.v.ps != undefined && item.v.ps.value == "结论") {
        try {
          if (currentSample.insProduct.find((m) => m.id == item.i)) {
            // å¦‚果当前检验项是产品检验项，则执行此方法，找到此检验项的要求值
            let ask = currentSample.insProduct.find((m) => m.id == item.i).ask
              ? currentSample.insProduct
                  .find((m) => m.id == item.i)
                  .ask.split("&")
              : null;
            // èŽ·å–当前结论的参数，也就是当前检验项的最终值
            let res = Object.values(comValue)[0];
            if (typeof res == "string" && res.includes(">")) {
              res = res.replace(">", "");
            }
            if (typeof res == "string" && res.includes("≤")) {
              res = res.replace("≤", "");
            }
            if (typeof res == "string" && res.includes("≥")) {
              res = res.replace("≥", "");
            }
            if (typeof res == "string" && res.includes("<")) {
              res = res.replace("<", "");
            }
            if (typeof res == "string" && res.includes("＞")) {
              res = res.replace("＞", "");
            }
            if (typeof res == "string" && res.includes("＜")) {
              res = res.replace("＜", "");
            }
            if (
              typeof res == "string" &&
              (res === "断裂" || res === "脆化" || res === "断裂脆化")
            ) {
              item.v.v = 0;
              list.forEach((a) => {
                if (a[0].r == item.r) {
                  for (let b = 0; b < a.length; b++) {
                    if (a[b].c == item.c) {
                      a[b].v.v = 0;
                      break;
                    }
                  }
                }
              });
            }
            let comp = [];
            // åˆ¤æ–­å½“前结论的参数（当前检验项的最终值）是否为空，如果为空，则直接赋值
            if (
              res === "" ||
              res === null ||
              res === undefined ||
              res === "Infinity"
            ) {
              item.v.v = null;
              list.forEach((a) => {
                if (a[0].r == item.r) {
                  for (let b = 0; b < a.length; b++) {
                    if (a[b].c == item.c) {
                      a[b].v.v = null;
                      break;
                    }
                  }
                }
              });
            } else {
              // å¦‚果不为空，则判断当前结论就需要进行判断
              //要求值为-，/，—，则结论设置为不判定，结论赋值为3
              if (
                ask == null ||
                ask[0] == "-" ||
                ask[0] == "/" ||
                ask[0] == "—"
              ) {
                item.v.v = 3;
                list.forEach((a) => {
                  if (a[0].r == item.r) {
                    for (let b = 0; b < a.length; b++) {
                      if (a[b].c == item.c) {
                        a[b].v.v = 3;
                        break;
                      }
                    }
                  }
                });
              } else {
                // è¦æ±‚值不为-，/，—，则进行判断
                if (ask) {
                  // å¾ªçŽ¯è¦æ±‚值列表，判断当前结论的参数是否符合要求
                  comp = ask.map((m, i) => {
                    // å¦‚果要求值包含=，则判断当前结论的参数是否等于要求值，
                    // ä»¥ä¸‹åˆ¤æ–­åŸºæœ¬ä¸€è‡´ï¼Œåªæ˜¯åˆ¤æ–­ç±»åž‹ä¸ä¸€æ ·ï¼Œå°±ä¸åšæ³¨é‡Šäº†
                    if (m.includes("=")) {
                      // å¤„理要求值
                      let str = handleFraction(m.split("=")[1]);
                      if (typeof res == "string" && typeof str == "string") {
                        // å¦‚果要求值和当前结论的参数都是字符串，则执行
                        if (res.includes("/")) {
                          // å¦‚果结论的参数是分数，则判断
                          if (m.includes("/")) {
                            // å¦‚果要求值是分数，则判断
                            return eval(res) == eval(str);
                          } else {
                            // å¦‚果要求值不是分数，则判断
                            return handleMoreParam(res, m.split("=")[1], "=");
                          }
                        } else {
                          // å¦‚果结论的参数不是分数，则判断
                          return (
                            res.trim().replace(/[.,。、；：'";?？“，]/g, "") ==
                            str.trim().replace(/[.,。、；：'";?？“，]/g, "")
                          );
                        }
                      } else {
                        // å¦‚果要求值和当前结论的参数有一个是数字，则执行
                        return eval(res) == eval(str);
                      }
                    } else if (m.includes("≥")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let str = handleFraction(m.split("≥")[1]);
                          return eval(res) >= eval(str);
                        } else {
                          return handleMoreParam(res, m.split("≥")[1], "≥");
                        }
                      } else {
                        let str = handleFraction(m.split("≥")[1]);
                        return eval(res) >= eval(str);
                      }
                    } else if (m.includes("≤")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let str = handleFraction(m.split("≤")[1]);
                          return eval(res) <= eval(str);
                        } else {
                          return handleMoreParam(res, m.split("≤")[1], "≤");
                        }
                      } else {
                        let str = handleFraction(m.split("≤")[1]);
                        if (typeof str == "string" && str.includes("A")) {
                          str = str.replace("A", "");
                        }
                        if (typeof str == "string" && str.includes("D")) {
                          str = str.replace("D", "");
                        }
                        if (typeof res == "string" && res.includes("A")) {
                          res = res.replace("A", "");
                        }
                        if (typeof res == "string" && res.includes("D")) {
                          res = res.replace("D", "");
                        }
                        return eval(res) <= eval(str);
                      }
                    } else if (m.includes("<")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let str = handleFraction(m.split("<")[1]);
                          return eval(res) < eval(str);
                        } else {
                          return handleMoreParam(res, m.split("<")[1], "<");
                        }
                      } else {
                        let str = handleFraction(m.split("<")[1]);
                        return eval(res) < eval(str);
                      }
                    } else if (m.includes(">")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let str = handleFraction(m.split(">")[1]);
                          return eval(res) > eval(str);
                        } else {
                          return handleMoreParam(res, m.split(">")[1], ">");
                        }
                      } else {
                        let str = handleFraction(m.split(">")[1]);
                        return eval(res) > eval(str);
                      }
                    } else if (m.includes("~")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let k = m.split("~");
                          return (
                            eval(res) >= eval(handleFraction(k[0])) &&
                            eval(res) <= eval(handleFraction(k[1]))
                          );
                        } else {
                          return handleMoreParam(res, m, "~");
                        }
                      } else {
                        let k = m.split("~");
                        return (
                          eval(res) >= eval(handleFraction(k[0])) &&
                          eval(res) <= eval(handleFraction(k[1]))
                        );
                      }
                    } else if (m.includes("-")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let k = m.split("-");
                          return (
                            eval(res) >= eval(handleFraction(k[0])) &&
                            eval(res) <= eval(handleFraction(k[1]))
                          );
                        } else {
                          return handleMoreParam(res, m, "-");
                        }
                      } else {
                        let k = m.split("-");
                        return (
                          eval(res) >= eval(handleFraction(k[0])) &&
                          eval(res) <= eval(handleFraction(k[1]))
                        );
                      }
                    } else if (m.includes("±")) {
                      if (modelType.includes("φ-")) {
                        if (m.indexOf("±") == 0) {
                          m =
                            modelType.substring(modelType.indexOf("-") + 1) + m;
                        }
                      }
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let k = m.split("±");
                          return (
                            eval(res) >=
                              eval(
                                handleFraction(k[0]) - handleFraction(k[1])
                              ) &&
                            eval(res) <=
                              eval(
                                Number(handleFraction(k[0])) +
                                  Number(handleFraction(k[1]))
                              )
                          );
                        } else {
                          return handleMoreParam(res, m, "±");
                        }
                      } else {
                        let k = m.split("±");
                        return (
                          eval(res) >=
                            eval(handleFraction(k[0]) - handleFraction(k[1])) &&
                          eval(res) <=
                            eval(
                              Number(handleFraction(k[0])) +
                                Number(handleFraction(k[1]))
                            )
                        );
                      }
                    } else if (m.includes("＞")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let str = handleFraction(m.split("＞")[1]);
                          return eval(res) > eval(str);
                        } else {
                          return handleMoreParam(res, m.split("＞")[1], ">");
                        }
                      } else {
                        let str = handleFraction(m.split("＞")[1]);
                        return eval(res) > eval(str);
                      }
                    } else if (m.includes("＜")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let str = handleFraction(m.split("＜")[1]);
                          return eval(res) < eval(str);
                        } else {
                          return handleMoreParam(res, m.split("＜")[1], "<");
                        }
                      } else {
                        let str = handleFraction(m.split("＜")[1]);
                        return eval(res) < eval(str);
                      }
                    }
                  });
                }
                // å¦‚果要求值的每个条件都符合，则给结论赋值为1，合格
                if (comp.every((m) => m)) {
                  item.v.v = 1;
                  list.forEach((a) => {
                    if (a[0].r == item.r) {
                      for (let b = 0; b < a.length; b++) {
                        if (a[b].c == item.c) {
                          a[b].v.v = 1;
                          break;
                        }
                      }
                    }
                  });
                } else {
                  // å¦åˆ™ç»™ç»“论赋值为0，不合格
                  item.v.v = 0;
                  list.forEach((a) => {
                    if (a[0].r == item.r) {
                      for (let b = 0; b < a.length; b++) {
                        if (a[b].c == item.c) {
                          a[b].v.v = 0;
                          break;
                        }
                      }
                    }
                  });
                }
              }
            }
            let getDataType0 = false;
            // ä¼˜åŒ–数采较多数据时-记录最后一个检验项的id，如果当前检验项的id与记录的id相同，则多传一个参数到主线程，进行数据保存，否则数采就不进行保存
            if (item.i == getDataTypeId) {
              getDataType0 = true;
            }
            // èµ‹å€¼ä¼ é€’到主线程的数据，method：saveInsContext表示此消息需要保存数据
            currentInsItemId = item.i;
            // èµ‹å€¼ä¼ é€’到主线程的数据，method：saveInsContext表示此消息需要保存数据
            result = {
              method: "saveInsContext",
              value: {
                tableList, // è¡¨æ ¼æ•°æ®
                param: getParam(), //传给后端的参数
                getDataTypeId: getDataTypeId,
                currentInsItemId: item.i,
              },
            };
            // å‘消息给主线程
            self.postMessage(JSON.stringify(result));
          }
        } catch (error) {
          console.log("error---", error);
        }
      } else {
        // å¦‚果是函数方法，则执行此方法
        let comResult = ""; //初始化计算结果
        try {
          if (getInspectionValueType(item.i) == 1) {
            // å¦‚果检验值类型是数字输入框
            let tell = currentSample.insProduct.find((m) => m.id == item.i).tell
              ? currentSample.insProduct
                  .find((m) => m.id == item.i)
                  .tell.split("&")
              : null;
            isPoint =
              tell &&
              tell.length > 0 &&
              typeof tell[0] == "string" &&
              tell[0].includes("/") &&
              tell[0] !== "/"; // è£…备电缆--判断要求值是否为分数
            const inspectionItemClass = currentSample.insProduct.find(
              (m) => m.id == item.i
            ).inspectionItemClass; // æ£€éªŒé¡¹åˆ†ç±»
            const inspectionItem = currentSample.insProduct.find(
              (m) => m.id == item.i
            ).inspectionItem; // æ£€éªŒé¡¹
            const inspectionItemSubclass = currentSample.insProduct.find(
              (m) => m.id == item.i
            ).inspectionItemSubclass; // æ£€éªŒå­é¡¹
            let isHaveSymbol = false;
            let symbol = "";
            for (var a in comValue) {
              if (
                typeof comValue[a] == "string" &&
                (comValue[a].includes(">") ||
                  comValue[a].includes("≤") ||
                  comValue[a].includes("<") ||
                  comValue[a].includes("≥") ||
                  comValue[a].includes("＜") ||
                  comValue[a].includes("＞"))
              ) {
                if (comValue[a].includes(">")) {
                  symbol = ">";
                } else if (comValue[a].includes("≤")) {
                  symbol = "≤";
                } else if (comValue[a].includes("≥")) {
                  symbol = "≥";
                } else if (comValue[a].includes("＜")) {
                  symbol = "＜";
                } else if (comValue[a].includes("＞")) {
                  symbol = "＞";
                } else {
                  symbol = "<";
                }
                isHaveSymbol = true;
                break;
              }
            }
            // æ ¹æ®è¾“入的数值，进行计算
            comResult = compute(item.v.f.replace(/=/g, " "), comValue, isPoint);
            // æ£€éªŒé¡¹ä¸ºå¯†åº¦æ—¶ï¼Œæ ¹æ®è¦æ±‚值的小数位改变最终值的小数位
            if (inspectionItem == "密度") {
              const str = "" + tell;
              const indexOfDecimal = str.indexOf(".");
              if (indexOfDecimal > -1) {
                const length = str.length - indexOfDecimal - 1;
                comResult = comResult.toFixed(length);
              }
            } else if (
              inspectionItemClass == "外护套机械物理性能" &&
              inspectionItem == "在IRM 902矿物油中浸泡后" &&
              (inspectionItemSubclass == "断裂伸长率变化率" ||
                inspectionItemSubclass == "抗张强度变化率")
            ) {
              comResult = Math.round(comResult).toFixed(0);
            } else if (
              typeof comResult == "string" &&
              (comResult.includes("断裂") || comResult.includes("脆化"))
            ) {
              comResult = comResult + "";
            }
            if (inspectionItem === "邵氏硬度" && tell[0].includes("A")) {
              // è¦æ±‚值如果有包含字母，最终结果要展示出字母
              comResult = comResult + "A";
            }
            if (
              inspectionItemClass === "绝缘机械物理性能" &&
              inspectionItem === "弯曲性能" &&
              inspectionItemSubclass === "最小弯曲半径" &&
              tell[0].includes("D")
            ) {
              // è¦æ±‚值如果有包含字母，最终结果要展示出字母
              comResult = comResult + "D";
            }
            if (isHaveSymbol) {
              comResult = symbol + comResult;
            }
            let list3 = list2.map((item) => item + "");
            // åˆ¤æ–­å¡«çš„检验值是否为科学计数法，如果为科学计数法，则进行转化
            isToExponential = list3.some(
              (val) => val.includes("e+") || val.includes("e-")
            );
            if (isToExponential) {
              let num2 = new Big(comResult);
              comResult = num2.toExponential(1);
            }
          } else {
            // å¦‚果检验值类型是文本输入框、下拉框
            let valueList = [];
            // å¤„理excel函数参数列表
            item.valueList.forEach((a) => {
              valueList.push({
                name: `${comparisonList.find((e) => e.value == a.c).label}${
                  a.r + 1
                }`,
                value: 0,
              });
            });
            // ç»™excel函数参数赋文本值
            for (var a in comValue) {
              valueList.forEach((b) => {
                if (b.name == a) {
                  b.value = comValue[a];
                }
              });
            }
            // è®¡ç®—公式，去掉excel函数的等号，并替换参数，列如：=A1  å˜æˆ A1 å˜æˆ â€˜æ–‡æœ¬è¾“入的值’
            let str = item.v.f.replace(/=/g, " ");
            valueList.forEach((b) => {
              str = str.replace(b.name, b.value);
            });
            // è®¡ç®—结果赋值
            comResult = str;
          }
        } catch (error) {
          console.log("error---", error);
        }
        try {
          // å¾ªçŽ¯è¡¨æ ¼æ•°æ®ï¼Œç»™è¡¨æ ¼æ•°æ®è¿›è¡Œèµ‹å€¼
          list.forEach((a) => {
            if (a[0].r == item.r && comResult !== "") {
              // åˆ¤æ–­å½“前行是否为当前检验项所在行，如果为当前行，则给表格数据赋值
              for (var b in a) {
                if (a[b].c == item.c) {
                  try {
                    if (comResult == 0) {
                      // åˆ¤æ–­è®¡ç®—结果是否为0，如果为0，则给表格数据赋值为0
                      a[b].v.v = 0;
                    } else if (
                      a[b].v.ct &&
                      a[b].v.ct.fa &&
                      typeof a[b].v.ct.fa == "string" &&
                      a[b].v.ct.fa.includes(".")
                    ) {
                      // åˆ¤æ–­å½“前单元格是否保留小数点，如果为保留小数点，则给表格数据赋值为保留小数点，这个是根据模板配置小数点来的
                      let num = 0;
                      let str = a[b].v.ct.fa.split(".")[1];
                      num = str.length;
                      a[b].v.v = comResult
                        ? Number(comResult).toFixed(num)
                        : comResult;
                    } else if (
                      typeof comResult == "string" &&
                      (comResult.includes("e+") || comResult.includes("e-"))
                    ) {
                      // åˆ¤æ–­è®¡ç®—结果是否为科学计数法，如果为科学计数法，则给表格数据赋值为科学计数法
                      a[b].v.v = comResult;
                    } else {
                      const inspectionItem = currentSample.insProduct.find(
                        (m) => m.id == item.i
                      ).inspectionItem;
                      // åˆ¤æ–­è®¡ç®—结果是否为数字，如果为数字，则给表格数据赋值为数字
                      if (inspectionItem == "铜线电阻率ρ20最大值") {
                        let val = parseFloat(Number(comResult).toFixed(5));
                        a[b].v.v = isNaN(val) ? comResult : val;
                      } else {
                        let val = parseFloat(Number(comResult).toFixed(3));
                        a[b].v.v = isNaN(val) ? comResult : val;
                      }
                    }
                  } catch (error) {
                    // å¦‚果以上判断都不支持，则直接赋值
                    a[b].v.v = comResult;
                    console.log("error---", error);
                  }
                  break;
                }
              }
            }
          });
          // å¦‚果此计算结果所属单元格，同时也是另一个excel函数的参数，那么就需要递归进行计算
          changeInput(comResult, `${id}-${item.r}-${item.c}-${pId}`); //改变最终值
          currentInsItemId = item.i;
        } catch (error) {
          console.log("error---", error);
        }
      }
    }
  });
  if (index === -1 || (inputType === undefined && isSave === "true")) {
    // èµ‹å€¼ä¼ é€’到主线程的数据，method：saveInsContext表示此消息需要保存数据
    result = {
      method: "saveInsContext",
      value: {
        tableList, // è¡¨æ ¼æ•°æ®
        param: getParam(), //传给后端的参数
        getDataTypeId: getDataTypeId,
        currentInsItemId: currentInsItemId,
      },
    };
    // å‘消息给主线程
    self.postMessage(JSON.stringify(result));
  }

  // èµ‹å€¼å¤šçº¿ç¨‹ä¼ è¾“数据
  result = {
    method: "tableList",
    value: tableList,
  };
  // å‘送主线程数据
  self.postMessage(JSON.stringify(result));
  try {
    // èµ‹å€¼å¤šçº¿ç¨‹ä¼ è¾“数据
    result = {
      method: "getCurrentInsProduct",
      value: pId,
    };
    // å‘送主线程数据
    self.postMessage(JSON.stringify(result));
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * èŽ·å–检测值类型
 *
 * @param id æ£€æµ‹å€¼ç±»åž‹å¯¹åº”çš„id
 * @returns è¿”回检测值类型
 */
function getInspectionValueType(id) {
  for (var a in currentSample.insProduct) {
    if (currentSample.insProduct[a].id == id) {
      return currentSample.insProduct[a].inspectionValueType;
    }
  }
}
/**
 * å¤„理分数或带有乘法和乘方的字符串
 *
 * @param str å­—符串类型，表示要处理的分数或乘方表达式
 * @returns è¿”回一个数字或原字符串，如果字符串为有效的分数或乘方表达式，则返回计算结果；否则返回原字符串
 */
function handleFraction(str) {
  if (str && typeof str == "string" && str.includes("/")) {
    // å¤„理分数
    return eval(str.split("/")[0] / str.split("/")[1]);
  } else if (
    str &&
    typeof str == "string" &&
    str.includes("*") &&
    str.includes("^")
  ) {
    // è®¡ç®—乘方
    const num1 = str.split("*");
    const num2 = num1[1].split("^");
    let num3 = new Big(num2[0]);
    let num4 = new Big(num2[1]);
    let num5 = Math.pow(num3, num4); // è®¡ç®—次方
    return num1[0] * num5; // æœ€åŽè®¡ç®—乘法
  } else {
    return str;
  }
}

/**
 * å¤„理带有多个参数的函数
 *
 * @param res å­—符串，需要被分割并处理的字符串
 * @param str å­—符串，与res中的每一项进行比较的字符串，可能是分数或者带有比较符号的字符串
 * @param comp å­—符串，表示比较类型的字符（如 '>'、'<'、'='、'≥'、'≤'、'±'、'~'、'-'）
 * @returns è¿”回布尔值，如果res中每一项都满足与str的比较条件，则返回true，否则返回false
 */
function handleMoreParam(res, str, comp) {
  let arr = res.split("/");
  let arr0 = arr.every((item) => {
    switch (comp) {
      case ">":
        return item > handleFraction(str);
      case "<":
        return item < handleFraction(str);
      case "=":
        return item == handleFraction(str);
      case "≥":
        return item >= handleFraction(str);
      case "≤":
        return item <= handleFraction(str);
      case "±":
        let k = str.split("±");
        return (
          item >= eval(handleFraction(k[0]) - handleFraction(k[1])) &&
          item <=
            eval(Number(handleFraction(k[0])) + Number(handleFraction(k[1])))
        );
      case "~":
        let j = str.split("~");
        return (
          item >= eval(handleFraction(j[0])) &&
          item <= eval(handleFraction(j[1]))
        );
      case "-":
        let o = str.split("-");
        return (
          item >= eval(handleFraction(o[0])) &&
          item <= eval(handleFraction(o[1]))
        );
    }
  });
  if (arr0) {
    return true;
  } else {
    return false;
  }
}

/**
 * èŽ·å–参数
 *
 * @returns è¿”回处理后的参数对象
 */
function getParam() {
  tableList[0].arr.forEach((a) => {
    a.forEach((b) => {
      // åˆå§‹åŒ–传递到后端的参数
      if (param[b.i]) {
        param[b.i].insValue = [];
        param[b.i].comValue = [];
        param[b.i].equipValue = [];
        param[b.i].equipName = [];
        param[b.i].resValue = null;
        param[b.i].insResult = null;
      }
    });
  });
  tableList[0].arr.forEach((a) => {
    a.forEach((b) => {
      // æ ¹æ®è¡¨æ ¼æ•°æ®ï¼Œèµ‹å€¼ä¼ é€’到后端的参数
      if (
        b.v.ps != undefined &&
        typeof b.v.ps.value == "string" &&
        b.v.ps.value.includes("检验值")
      ) {
        // èµ‹å€¼æ£€éªŒå€¼
        b.i && b.v.v && param[b.i].insValue.push(b);
      }
      if (b.v.ps != undefined && b.v.ps.value === "计算值") {
        // èµ‹å€¼è®¡ç®—值
        b.i &&
          b.v.v &&
          b.valueList &&
          b.valueList.length > 0 &&
          param[b.i].comValue.push(b);
      }
      if (b.v.ps != undefined && b.v.ps.value === "设备编码") {
        // èµ‹å€¼è®¾å¤‡ç¼–码
        b.i && b.v && param[b.i].equipValue.push(b);
      }
      if (b.v.ps != undefined && b.v.ps.value === "设备名称") {
        // èµ‹å€¼è®¾å¤‡åç§°
        b.i && b.v && param[b.i].equipName.push(b);
      }
      if (b.v.ps != undefined && b.v.ps.value === "最终值") {
        // èµ‹å€¼æœ€ç»ˆå€¼
        b.i &&
          b.v &&
          b.valueList &&
          b.valueList.length > 0 &&
          (param[b.i].resValue = b);
      }
      if (b.v.ps != undefined && b.v.ps.value === "结论") {
        if (b.i && (b.v.v || b.v.v === 0 || b.v.v === "0")) {
          if (b.v.v != "合格" && b.v.v != "不合格") {
            // èµ‹å€¼ç»“论
            param[b.i].insResult = b;
          }
        }
      }
    });
  });
  return param;
}

/**
 * è®¡ç®—多个数值的和
 *
 * @param val æ•°å€¼åž‹å‚数，可变长参数列表
 * @returns è¿”回所有参数的和，如果参数列表为空或参数类型非数值型，则返回null
 */
function SUM(...val) {
  try {
    let num = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      val.forEach((item) => {
        num += item;
      });
    }
    return num;
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * è®¡ç®—传入参数中的最大值
 *
 * @param ...val å¯å˜å‚数列表，用于计算最大值的数值或可转换为数值的类型
 * @returns è¿”回最大值，如果参数列表为空或为null/undefined/''，则返回null
 */
function MAX(...val) {
  try {
    let max = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      val = val.filter((item) => item != null && item !== "");
      if (val.length > 0) {
        max = Math.max(...val);
      } else {
        max = null;
      }
    }
    return max;
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * IF判断
 *
 *
 *
 */
function IF(...val) {
  try {
    let ifNUm = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      if (val[0] === "" || val[0] == 0 || val[0] === " ") {
        ifNUm = val[1];
      } else {
        ifNUm = val[0];
      }
    }
    return ifNUm;
  } catch (error) {
    console.log("IFerror---", error);
  }
}
/**
 * è®¡ç®—传入参数中的最小值
 *
 * @param val å¯å˜å‚数，用于计算最小值的数值数组
 * @returns è¿”回传入参数中的最小值，如果传入参数为空或所有值均为null或空字符串，则返回null
 */
function MIN(...val) {
  try {
    let min = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      val = val.filter((item) => item != null && item !== "");
      if (val.length > 0) {
        min = Math.min(...val);
      }
    }
    return min;
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * è®¡ç®—给定数值的平均值
 *
 * @param val æ•°å€¼åˆ—表，可包含任意个参数
 * @returns è¿”回平均值，如果数值列表为空或包含非数值项，则返回null
 */
function AVERAGE(...val) {
  try {
    let num = null;
    let arr = [];
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      arr = val.filter(
        (item) => item !== null && item !== "" && item != undefined
      );
      arr.forEach((item) => {
        num += item;
      });
      if (arr.length > 0) {
        return num / arr.length;
      } else {
        return null;
      }
    } else {
      return null;
    }
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * å–æ•´æ•°
 *
 * @param val ä»»æ„æ•°å€¼
 * @returns è¿”回该数值的整数
 */
function INT(val) {
  try {
    return Math.round(val);
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * è®¡ç®—一个数的绝对值
 *
 * @param val ä»»æ„æ•°å€¼
 * @returns è¿”回该数值的绝对值
 */
function ABS(val) {
  try {
    return Math.abs(val);
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * è®¡ç®—一组数字的中位数
 *
 * @param val ä»»æ„ä¸ªå‚数，需要计算中位数的数字
 * @returns å¦‚果参数中有有效的数字，则返回计算出的中位数；否则返回null
 */
function MEDIAN(...val) {
  try {
    let arr = [];
    if (val && val.length > 0) {
      arr = val.filter((item) => item != null && item !== "");
      const sortedArr = arr.sort((a, b) => a - b);
      // è®¡ç®—中位数
      const half = Math.floor(sortedArr.length / 2);
      if (arr.length > 0) {
        // å¦‚果数组长度是奇数，直接取中间的元素
        if (sortedArr.length % 2 === 1) {
          return sortedArr[half];
        } else {
          // å¦‚果数组长度是偶数，取中间两个元素的平均值
          return (sortedArr[half - 1] + sortedArr[half]) / 2;
        }
      } else {
        return null;
      }
    } else {
      return null;
    }
  } catch (error) {
    console.log("error---", error);
  }
}

/**
 * è®¡ç®—幂
 *
 * @param str å­—符串形式的幂表达式，例如"2^3"
 * @returns è¿”回计算后的幂值，如果表达式无效则返回null
 */
function CalculatePower(str) {
  try {
    if (str && str.includes("^")) {
      let arr = str.split("^");
      if (arr && arr.length > 1) {
        return Math.pow(arr[0], arr[1]);
      } else {
        return null;
      }
    }
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * è½¬æ¢Ï€
 *
 *
 *
 */
function PI() {
  try {
    return 3.1415926;
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * è®¡ç®—LOG
 *
 *
 *
 */
function LOG(...val) {
  try {
    let LOGNUm = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      val = val.filter((item) => item != null && item !== "");
      if (val.length > 0) {
        LOGNUm = Math.log(val[0]);
      }
    }
    // console.log(LOGNUm);
    return LOGNUm;
  } catch (error) {
    console.log("error---", error);
  }
}

/**
 * æ ¹æ®åæ ‡èŽ·å–列名
 * @param {Object} cellId
 */
function getColumnNameFromId(cellId) {
  try {
    if (!Array.isArray(cellId)) {
      cellId = cellId.split("-");
    }
    var i = cellId[0];
    var letter = "";
    if (i > 701) {
      letter += String.fromCharCode(64 + parseInt(i / 676));
      letter += String.fromCharCode(64 + parseInt((i % 676) / 26));
    } else if (i > 25) {
      letter += String.fromCharCode(64 + parseInt(i / 26));
    }
    letter += String.fromCharCode(65 + (i % 26));
    return letter + (parseInt(cellId[1]) + 1);
  } catch (e) {
    console.log("error", e);
  }
}
/**
 * æ ¹æ®åˆ—名获取坐标
 * @param {Object} id
 * @param {Object} arr
 */
function getIdFromColumnName(id, arr) {
  try {
    // Get the letters
    var t = /^[a-zA-Z]+/.exec(id);
    if (t) {
      // Base 26 calculation
      var code = 0;
      for (var i = 0; i < t[0].length; i++) {
        code +=
          parseInt(t[0].charCodeAt(i) - 64) * Math.pow(26, t[0].length - 1 - i);
      }
      code--;
      // Make sure jexcel starts on zero
      if (code < 0) {
        code = 0;
      }

      // Number
      var number = parseInt(/[0-9]+$/.exec(id));
      if (number > 0) {
        number--;
      }

      if (arr == true) {
        id = [code, number];
      } else {
        // id = code + '-' + number;
        id = {
          c: code,
          r: number,
        };
      }
    }
    return id;
  } catch (e) {
    console.log("error", e);
  }
}

/**
 * æ›´æ”¹å‚æ•°
 *
 * @param f å‚数列表
 * @returns è¿”回一个包含坐标信息的数组
 */
function changeParameter(f) {
  try {
    let arr = getABCList(f);
    let arr2 = [];
    arr.forEach((item) => {
      // åˆ¤æ–­æ˜¯å¦ä¸ºèŒƒå›´ï¼Œåˆ—如MAX(A1:B2)
      if (item.includes(":")) {
        let r0 = getIdFromColumnName(item.split(":")[0]).r;
        let c0 = getIdFromColumnName(item.split(":")[0]).c;
        let r1 = getIdFromColumnName(item.split(":")[1]).r;
        let c1 = getIdFromColumnName(item.split(":")[1]).c;
        for (let i = Number(r0); i <= Number(r1); i++) {
          for (let u = Number(c0); u <= Number(c1); u++) {
            arr2.push({
              r: i,
              c: u,
            });
          }
        }
      } else {
        // æ²¡æœ‰åˆ™ç›´æŽ¥èŽ·å–
        arr2.push(getIdFromColumnName(item));
      }
    });
    return arr2;
  } catch (error) {
    console.log("error", error);
  }
}
/**
 * èŽ·å–包含 ABC å­—符的列表
 *
 * @param f å­—符串，包含需要解析的公式或表达式
 * @returns åŒ…含 ABC å­—符的数组列表
 */
function getABCList(f) {
  try {
    let regex = /[=\+\-\*\%\(\)\/\^\s]/g;
    // ä¸Šé¢è®¡ç®—函数新增后，这里也要同步增加
    let fouList = [
      "SUM",
      "MAX",
      "MIN",
      "AVERAGE",
      "ABS",
      "PI",
      "INT",
      "IF",
      "LOG",
    ];
    // æ›¿æ¢ç‰¹æ®Šå­—符
    f = f
      .replace(regex, ",")
      .replace(new RegExp('"&', "g"), "")
      .replace(new RegExp('&"', "g"), "");
    fouList.forEach((item) => {
      f = f.replace(new RegExp(item, "g"), ",");
    });
    let arr = f.split(",").filter((item) => {
      return (
        item && /[a-zA-Z]/.test(item) && item != "undefined" && item != "null"
      );
    });
    return arr;
  } catch (error) {
    console.log("error", error);
  }
}
/**
 * èŽ·å–所有单元格
 *
 * @param f è¡¨æ ¼æ•°æ®æˆ–相关参数
 * @returns è¿”回一个对象，其键为单元格的唯一标识符（由列和行ID拼接而成），值为null
 */
function getAllCell(f) {
  try {
    let arr = changeParameter(f);
    let arr0 = {};
    arr.forEach((item) => {
      arr0[getColumnNameFromId(`${item.c}` + "-" + `${item.r}`)] = null;
    });
    return arr0;
  } catch (error) {
    console.log("error", error);
  }
}

/**
 * è®¡ç®—函数
 *
 * @param f å­—符串类型，表示待计算的公式
 * @param comValue å¯¹è±¡ç±»åž‹ï¼Œè¡¨ç¤ºè¦æ›¿æ¢çš„单元格值，键为单元格名称，值为替换后的值
 * @returns è¿”回计算后的结果，如果计算失败则返回0
 */
function compute(f, comValue, isPoint) {
  try {
    let str = f;
    // èŽ·å–单元格对应值
    let arr = getAllCell(f);
    for (var a in comValue) {
      if (typeof comValue[a] == "string" && comValue[a].includes(">")) {
        comValue[a] = comValue[a].replace(">", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("≤")) {
        comValue[a] = comValue[a].replace("≤", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("≥")) {
        comValue[a] = comValue[a].replace("≥", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("<")) {
        comValue[a] = comValue[a].replace("<", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("＜")) {
        comValue[a] = comValue[a].replace("＜", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("＞")) {
        comValue[a] = comValue[a].replace("＞", "");
      }
      if (
        comValue[a] !== "undefined" &&
        comValue[a] !== "null" &&
        comValue[a] !== undefined
      ) {
        if (typeof comValue[a] == "string" && comValue[a].includes("^")) {
          // è®¡ç®—幂次
          arr[a] = CalculatePower(comValue[a]);
        } else {
          arr[a] = comValue[a];
        }
      }
    }
    // è§£æžå…¬å¼å‚数，特别是带：的
    let arr0 = getABCList(f);
    let obj = {};
    arr0.forEach((item) => {
      if (item.includes(":")) {
        let arr1 = [];
        let r0 = getIdFromColumnName(item.split(":")[0]).r;
        let c0 = getIdFromColumnName(item.split(":")[0]).c;
        let r1 = getIdFromColumnName(item.split(":")[1]).r;
        let c1 = getIdFromColumnName(item.split(":")[1]).c;
        for (let i = Number(r0); i <= Number(r1); i++) {
          for (let u = Number(c0); u <= Number(c1); u++) {
            arr1.push({
              r: i,
              c: u,
            });
          }
        }
        let arr2 = [];
        arr1.forEach((m) => {
          arr2.push(getColumnNameFromId(`${m.c}` + "-" + `${m.r}`));
        });
        obj[item.split(":").join("-")] = arr2.join(",");
      } else {
        obj[item] = item;
      }
    });
    str = str.replace(new RegExp(":", "g"), "-");
    // æ›¿æ¢å‚æ•°
    for (var a in obj) {
      str = str.replace(new RegExp(a, "g"), obj[a]);
    }
    // è®¡ç®—
    for (var a in arr) {
      str = str.replace(new RegExp(a, "g"), arr[a]);
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes('&"/"&')) {
      // è®¡ç®—带斜杠的
      return str
        .replace(new RegExp('&"/"&', "g"), "/")
        .replace(new RegExp("//", "g"), "");
    } else if (isPoint) {
      // è®¡ç®—带小数点的
      return str.replace("ABS", "").replace(/\(|\)/g, "");
    } else {
      if (str.includes("IF")) {
        str = str.replace("IF", "").replace(/\(|\)/g, "");
        const str1 = str.split(",");
        if (str1[0] === " " || str1[0] === "") {
          str1[0] = 0;
        }
        if (str1[2] === " " || str1[2] === "") {
          str1[2] = 0;
        }
        const str2 = str1.join(",");
        str = "IF(" + str2 + ")";
      }
      // console.log('str---', str)
      if (str.includes("断裂") || str.includes("脆化")) {
        const result = str.replace(/[^\u4e00-\u9fa5]/g, "");
        if (result.includes("断裂") && !result.includes("脆化")) {
          return "断裂";
        } else if (!result.includes("断裂") && result.includes("脆化")) {
          return "脆化";
        } else if (result.includes("断裂") && result.includes("脆化")) {
          return "断裂脆化";
        }
      }
      // è®¡ç®—常规的
      return eval(str);
    }
  } catch (error) {
    console.log("error", error);
  }
}

/*
 *  big.js v5.2.2
 *  A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.
 *  Copyright (c) 2018 Michael Mclaughlin <M8ch88l@gmail.com>
 *  https://github.com/MikeMcl/big.js/LICENCE
 */
(function (GLOBAL) {
  "use strict";
  var Big,
    /************************************** EDITABLE DEFAULTS *****************************************/

    // The default values below must be integers within the stated ranges.

    /*
     * The maximum number of decimal places (DP) of the results of operations involving division:
     * div and sqrt, and pow with negative exponents.
     */
    DP = 20, // 0 to MAX_DP
    /*
     * The rounding mode (RM) used when rounding to the above decimal places.
     *
     *  0  Towards zero (i.e. truncate, no rounding).       (ROUND_DOWN)
     *  1  To nearest neighbour. If equidistant, round up.  (ROUND_HALF_UP)
     *  2  To nearest neighbour. If equidistant, to even.   (ROUND_HALF_EVEN)
     *  3  Away from zero.                                  (ROUND_UP)
     */
    RM = 1, // 0, 1, 2 or 3
    // The maximum value of DP and Big.DP.
    MAX_DP = 1e6, // 0 to 1000000
    // The maximum magnitude of the exponent argument to the pow method.
    MAX_POWER = 1e6, // 1 to 1000000
    /*
     * The negative exponent (NE) at and beneath which toString returns exponential notation.
     * (JavaScript numbers: -7)
     * -1000000 is the minimum recommended exponent value of a Big.
     */
    NE = -7, // 0 to -1000000
    /*
     * The positive exponent (PE) at and above which toString returns exponential notation.
     * (JavaScript numbers: 21)
     * 1000000 is the maximum recommended exponent value of a Big.
     * (This limit is not enforced or checked.)
     */
    PE = 21, // 0 to 1000000
    /**************************************************************************************************/

    // Error messages.
    NAME = "[big.js] ",
    INVALID = NAME + "Invalid ",
    INVALID_DP = INVALID + "decimal places",
    INVALID_RM = INVALID + "rounding mode",
    DIV_BY_ZERO = NAME + "Division by zero",
    // The shared prototype object.
    P = {},
    UNDEFINED = void 0,
    NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;

  /*
   * Create and return a Big constructor.
   *
   */
  function _Big_() {
    /*
     * The Big constructor and exported function.
     * Create and return a new instance of a Big number object.
     *
     * n {number|string|Big} A numeric value.
     */
    function Big(n) {
      var x = this;

      // Enable constructor usage without new.
      if (!(x instanceof Big)) return n === UNDEFINED ? _Big_() : new Big(n);

      // Duplicate.
      if (n instanceof Big) {
        x.s = n.s;
        x.e = n.e;
        x.c = n.c.slice();
      } else {
        parse(x, n);
      }

      /*
       * Retain a reference to this Big constructor, and shadow Big.prototype.constructor which
       * points to Object.
       */
      x.constructor = Big;
    }

    Big.prototype = P;
    Big.DP = DP;
    Big.RM = RM;
    Big.NE = NE;
    Big.PE = PE;
    Big.version = "5.2.2";

    return Big;
  }

  /*
   * Parse the number or string value passed to a Big constructor.
   *
   * x {Big} A Big number instance.
   * n {number|string} A numeric value.
   */
  function parse(x, n) {
    var e, i, nl;

    // Minus zero?
    if (n === 0 && 1 / n < 0) n = "-0";
    else if (!NUMERIC.test((n += ""))) throw Error(INVALID + "number");

    // Determine sign.
    x.s = n.charAt(0) == "-" ? ((n = n.slice(1)), -1) : 1;

    // Decimal point?
    if ((e = n.indexOf(".")) > -1) n = n.replace(".", "");

    // Exponential form?
    if ((i = n.search(/e/i)) > 0) {
      // Determine exponent.
      if (e < 0) e = i;
      e += +n.slice(i + 1);
      n = n.substring(0, i);
    } else if (e < 0) {
      // Integer.
      e = n.length;
    }

    nl = n.length;

    // Determine leading zeros.
    for (i = 0; i < nl && n.charAt(i) == "0"; ) ++i;

    if (i == nl) {
      // Zero.
      x.c = [(x.e = 0)];
    } else {
      // Determine trailing zeros.
      for (; nl > 0 && n.charAt(--nl) == "0"; );
      x.e = e - i - 1;
      x.c = [];

      // Convert string to array of digits without leading/trailing zeros.
      for (e = 0; i <= nl; ) x.c[e++] = +n.charAt(i++);
    }

    return x;
  }

  /*
   * Round Big x to a maximum of dp decimal places using rounding mode rm.
   * Called by stringify, P.div, P.round and P.sqrt.
   *
   * x {Big} The Big to round.
   * dp {number} Integer, 0 to MAX_DP inclusive.
   * rm {number} 0, 1, 2 or 3 (DOWN, HALF_UP, HALF_EVEN, UP)
   * [more] {boolean} Whether the result of division was truncated.
   */
  function round(x, dp, rm, more) {
    var xc = x.c,
      i = x.e + dp + 1;

    if (i < xc.length) {
      if (rm === 1) {
        // xc[i] is the digit after the digit that may be rounded up.
        more = xc[i] >= 5;
      } else if (rm === 2) {
        more =
          xc[i] > 5 ||
          (xc[i] == 5 &&
            (more || i < 0 || xc[i + 1] !== UNDEFINED || xc[i - 1] & 1));
      } else if (rm === 3) {
        more = more || !!xc[0];
      } else {
        more = false;
        if (rm !== 0) throw Error(INVALID_RM);
      }

      if (i < 1) {
        xc.length = 1;

        if (more) {
          // 1, 0.1, 0.01, 0.001, 0.0001 etc.
          x.e = -dp;
          xc[0] = 1;
        } else {
          // Zero.
          xc[0] = x.e = 0;
        }
      } else {
        // Remove any digits after the required decimal places.
        xc.length = i--;

        // Round up?
        if (more) {
          // Rounding up may mean the previous digit has to be rounded up.
          for (; ++xc[i] > 9; ) {
            xc[i] = 0;
            if (!i--) {
              ++x.e;
              xc.unshift(1);
            }
          }
        }

        // Remove trailing zeros.
        for (i = xc.length; !xc[--i]; ) xc.pop();
      }
    } else if (rm < 0 || rm > 3 || rm !== ~~rm) {
      throw Error(INVALID_RM);
    }

    return x;
  }

  /*
   * Return a string representing the value of Big x in normal or exponential notation.
   * Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.
   *
   * x {Big}
   * id? {number} Caller id.
   *         1 toExponential
   *         2 toFixed
   *         3 toPrecision
   *         4 valueOf
   * n? {number|undefined} Caller's argument.
   * k? {number|undefined}
   */
  function stringify(x, id, n, k) {
    var e,
      s,
      Big = x.constructor,
      z = !x.c[0];

    if (n !== UNDEFINED) {
      if (n !== ~~n || n < (id == 3) || n > MAX_DP) {
        throw Error(id == 3 ? INVALID + "precision" : INVALID_DP);
      }

      x = new Big(x);

      // The index of the digit that may be rounded up.
      n = k - x.e;

      // Round?
      if (x.c.length > ++k) round(x, n, Big.RM);

      // toFixed: recalculate k as x.e may have changed if value rounded up.
      if (id == 2) k = x.e + n + 1;

      // Append zeros?
      for (; x.c.length < k; ) x.c.push(0);
    }

    e = x.e;
    s = x.c.join("");
    n = s.length;

    // Exponential notation?
    if (
      id != 2 &&
      (id == 1 || (id == 3 && k <= e) || e <= Big.NE || e >= Big.PE)
    ) {
      s =
        s.charAt(0) +
        (n > 1 ? "." + s.slice(1) : "") +
        (e < 0 ? "e" : "e+") +
        e;

      // Normal notation.
    } else if (e < 0) {
      for (; ++e; ) s = "0" + s;
      s = "0." + s;
    } else if (e > 0) {
      if (++e > n) for (e -= n; e--; ) s += "0";
      else if (e < n) s = s.slice(0, e) + "." + s.slice(e);
    } else if (n > 1) {
      s = s.charAt(0) + "." + s.slice(1);
    }

    return x.s < 0 && (!z || id == 4) ? "-" + s : s;
  }

  // Prototype/instance methods

  /*
   * Return a new Big whose value is the absolute value of this Big.
   */
  P.abs = function () {
    var x = new this.constructor(this);
    x.s = 1;
    return x;
  };

  /*
   * Return 1 if the value of this Big is greater than the value of Big y,
   *       -1 if the value of this Big is less than the value of Big y, or
   *        0 if they have the same value.
   */
  P.cmp = function (y) {
    var isneg,
      x = this,
      xc = x.c,
      yc = (y = new x.constructor(y)).c,
      i = x.s,
      j = y.s,
      k = x.e,
      l = y.e;

    // Either zero?
    if (!xc[0] || !yc[0]) return !xc[0] ? (!yc[0] ? 0 : -j) : i;

    // Signs differ?
    if (i != j) return i;

    isneg = i < 0;

    // Compare exponents.
    if (k != l) return (k > l) ^ isneg ? 1 : -1;

    j = (k = xc.length) < (l = yc.length) ? k : l;

    // Compare digit by digit.
    for (i = -1; ++i < j; ) {
      if (xc[i] != yc[i]) return (xc[i] > yc[i]) ^ isneg ? 1 : -1;
    }

    // Compare lengths.
    return k == l ? 0 : (k > l) ^ isneg ? 1 : -1;
  };

  /*
   * Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,
   * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
   */
  P.div = function (y) {
    var x = this,
      Big = x.constructor,
      a = x.c, // dividend
      b = (y = new Big(y)).c, // divisor
      k = x.s == y.s ? 1 : -1,
      dp = Big.DP;

    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) throw Error(INVALID_DP);

    // Divisor is zero?
    if (!b[0]) throw Error(DIV_BY_ZERO);

    // Dividend is 0? Return +-0.
    if (!a[0]) return new Big(k * 0);

    var bl,
      bt,
      n,
      cmp,
      ri,
      bz = b.slice(),
      ai = (bl = b.length),
      al = a.length,
      r = a.slice(0, bl), // remainder
      rl = r.length,
      q = y, // quotient
      qc = (q.c = []),
      qi = 0,
      d = dp + (q.e = x.e - y.e) + 1; // number of digits of the result

    q.s = k;
    k = d < 0 ? 0 : d;

    // Create version of divisor with leading zero.
    bz.unshift(0);

    // Add zeros to make remainder as long as divisor.
    for (; rl++ < bl; ) r.push(0);

    do {
      // n is how many times the divisor goes into current remainder.
      for (n = 0; n < 10; n++) {
        // Compare divisor and remainder.
        if (bl != (rl = r.length)) {
          cmp = bl > rl ? 1 : -1;
        } else {
          for (ri = -1, cmp = 0; ++ri < bl; ) {
            if (b[ri] != r[ri]) {
              cmp = b[ri] > r[ri] ? 1 : -1;
              break;
            }
          }
        }

        // If divisor < remainder, subtract divisor from remainder.
        if (cmp < 0) {
          // Remainder can't be more than 1 digit longer than divisor.
          // Equalise lengths using divisor with extra leading zero?
          for (bt = rl == bl ? b : bz; rl; ) {
            if (r[--rl] < bt[rl]) {
              ri = rl;
              for (; ri && !r[--ri]; ) r[ri] = 9;
              --r[ri];
              r[rl] += 10;
            }
            r[rl] -= bt[rl];
          }

          for (; !r[0]; ) r.shift();
        } else {
          break;
        }
      }

      // Add the digit n to the result array.
      qc[qi++] = cmp ? n : ++n;

      // Update the remainder.
      if (r[0] && cmp) r[rl] = a[ai] || 0;
      else r = [a[ai]];
    } while ((ai++ < al || r[0] !== UNDEFINED) && k--);

    // Leading zero? Do not remove if result is simply zero (qi == 1).
    if (!qc[0] && qi != 1) {
      // There can't be more than one zero.
      qc.shift();
      q.e--;
    }

    // Round?
    if (qi > d) round(q, dp, Big.RM, r[0] !== UNDEFINED);

    return q;
  };

  /*
   * Return true if the value of this Big is equal to the value of Big y, otherwise return false.
   */
  P.eq = function (y) {
    return !this.cmp(y);
  };

  /*
   * Return true if the value of this Big is greater than the value of Big y, otherwise return
   * false.
   */
  P.gt = function (y) {
    return this.cmp(y) > 0;
  };

  /*
   * Return true if the value of this Big is greater than or equal to the value of Big y, otherwise
   * return false.
   */
  P.gte = function (y) {
    return this.cmp(y) > -1;
  };

  /*
   * Return true if the value of this Big is less than the value of Big y, otherwise return false.
   */
  P.lt = function (y) {
    return this.cmp(y) < 0;
  };

  /*
   * Return true if the value of this Big is less than or equal to the value of Big y, otherwise
   * return false.
   */
  P.lte = function (y) {
    return this.cmp(y) < 1;
  };

  /*
   * Return a new Big whose value is the value of this Big minus the value of Big y.
   */
  P.minus = P.sub = function (y) {
    var i,
      j,
      t,
      xlty,
      x = this,
      Big = x.constructor,
      a = x.s,
      b = (y = new Big(y)).s;

    // Signs differ?
    if (a != b) {
      y.s = -b;
      return x.plus(y);
    }

    var xc = x.c.slice(),
      xe = x.e,
      yc = y.c,
      ye = y.e;

    // Either zero?
    if (!xc[0] || !yc[0]) {
      // y is non-zero? x is non-zero? Or both are zero.
      return yc[0] ? ((y.s = -b), y) : new Big(xc[0] ? x : 0);
    }

    // Determine which is the bigger number. Prepend zeros to equalise exponents.
    if ((a = xe - ye)) {
      if ((xlty = a < 0)) {
        a = -a;
        t = xc;
      } else {
        ye = xe;
        t = yc;
      }

      t.reverse();
      for (b = a; b--; ) t.push(0);
      t.reverse();
    } else {
      // Exponents equal. Check digit by digit.
      j = ((xlty = xc.length < yc.length) ? xc : yc).length;

      for (a = b = 0; b < j; b++) {
        if (xc[b] != yc[b]) {
          xlty = xc[b] < yc[b];
          break;
        }
      }
    }

    // x < y? Point xc to the array of the bigger number.
    if (xlty) {
      t = xc;
      xc = yc;
      yc = t;
      y.s = -y.s;
    }

    /*
     * Append zeros to xc if shorter. No need to add zeros to yc if shorter as subtraction only
     * needs to start at yc.length.
     */
    if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--; ) xc[i++] = 0;

    // Subtract yc from xc.
    for (b = i; j > a; ) {
      if (xc[--j] < yc[j]) {
        for (i = j; i && !xc[--i]; ) xc[i] = 9;
        --xc[i];
        xc[j] += 10;
      }

      xc[j] -= yc[j];
    }

    // Remove trailing zeros.
    for (; xc[--b] === 0; ) xc.pop();

    // Remove leading zeros and adjust exponent accordingly.
    for (; xc[0] === 0; ) {
      xc.shift();
      --ye;
    }

    if (!xc[0]) {
      // n - n = +0
      y.s = 1;

      // Result must be zero.
      xc = [(ye = 0)];
    }

    y.c = xc;
    y.e = ye;

    return y;
  };

  /*
   * Return a new Big whose value is the value of this Big modulo the value of Big y.
   */
  P.mod = function (y) {
    var ygtx,
      x = this,
      Big = x.constructor,
      a = x.s,
      b = (y = new Big(y)).s;

    if (!y.c[0]) throw Error(DIV_BY_ZERO);

    x.s = y.s = 1;
    ygtx = y.cmp(x) == 1;
    x.s = a;
    y.s = b;

    if (ygtx) return new Big(x);

    a = Big.DP;
    b = Big.RM;
    Big.DP = Big.RM = 0;
    x = x.div(y);
    Big.DP = a;
    Big.RM = b;

    return this.minus(x.times(y));
  };

  /*
   * Return a new Big whose value is the value of this Big plus the value of Big y.
   */
  P.plus = P.add = function (y) {
    var t,
      x = this,
      Big = x.constructor,
      a = x.s,
      b = (y = new Big(y)).s;

    // Signs differ?
    if (a != b) {
      y.s = -b;
      return x.minus(y);
    }

    var xe = x.e,
      xc = x.c,
      ye = y.e,
      yc = y.c;

    // Either zero? y is non-zero? x is non-zero? Or both are zero.
    if (!xc[0] || !yc[0]) return yc[0] ? y : new Big(xc[0] ? x : a * 0);

    xc = xc.slice();

    // Prepend zeros to equalise exponents.
    // Note: reverse faster than unshifts.
    if ((a = xe - ye)) {
      if (a > 0) {
        ye = xe;
        t = yc;
      } else {
        a = -a;
        t = xc;
      }

      t.reverse();
      for (; a--; ) t.push(0);
      t.reverse();
    }

    // Point xc to the longer array.
    if (xc.length - yc.length < 0) {
      t = yc;
      yc = xc;
      xc = t;
    }

    a = yc.length;

    // Only start adding at yc.length - 1 as the further digits of xc can be left as they are.
    for (b = 0; a; xc[a] %= 10) b = ((xc[--a] = xc[a] + yc[a] + b) / 10) | 0;

    // No need to check for zero, as +x + +y != 0 && -x + -y != 0

    if (b) {
      xc.unshift(b);
      ++ye;
    }

    // Remove trailing zeros.
    for (a = xc.length; xc[--a] === 0; ) xc.pop();

    y.c = xc;
    y.e = ye;

    return y;
  };

  /*
   * Return a Big whose value is the value of this Big raised to the power n.
   * If n is negative, round to a maximum of Big.DP decimal places using rounding
   * mode Big.RM.
   *
   * n {number} Integer, -MAX_POWER to MAX_POWER inclusive.
   */
  P.pow = function (n) {
    var x = this,
      one = new x.constructor(1),
      y = one,
      isneg = n < 0;

    if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER)
      throw Error(INVALID + "exponent");
    if (isneg) n = -n;

    for (;;) {
      if (n & 1) y = y.times(x);
      n >>= 1;
      if (!n) break;
      x = x.times(x);
    }

    return isneg ? one.div(y) : y;
  };

  /*
   * Return a new Big whose value is the value of this Big rounded using rounding mode rm
   * to a maximum of dp decimal places, or, if dp is negative, to an integer which is a
   * multiple of 10**-dp.
   * If dp is not specified, round to 0 decimal places.
   * If rm is not specified, use Big.RM.
   *
   * dp? {number} Integer, -MAX_DP to MAX_DP inclusive.
   * rm? 0, 1, 2 or 3 (ROUND_DOWN, ROUND_HALF_UP, ROUND_HALF_EVEN, ROUND_UP)
   */
  P.round = function (dp, rm) {
    var Big = this.constructor;
    if (dp === UNDEFINED) dp = 0;
    else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP)
      throw Error(INVALID_DP);
    return round(new Big(this), dp, rm === UNDEFINED ? Big.RM : rm);
  };

  /*
   * Return a new Big whose value is the square root of the value of this Big, rounded, if
   * necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
   */
  P.sqrt = function () {
    var r,
      c,
      t,
      x = this,
      Big = x.constructor,
      s = x.s,
      e = x.e,
      half = new Big(0.5);

    // Zero?
    if (!x.c[0]) return new Big(x);

    // Negative?
    if (s < 0) throw Error(NAME + "No square root");

    // Estimate.
    s = Math.sqrt(x + "");

    // Math.sqrt underflow/overflow?
    // Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.
    if (s === 0 || s === 1 / 0) {
      c = x.c.join("");
      if (!((c.length + e) & 1)) c += "0";
      s = Math.sqrt(c);
      e = (((e + 1) / 2) | 0) - (e < 0 || e & 1);
      r = new Big(
        (s == 1 / 0
          ? "1e"
          : (s = s.toExponential()).slice(0, s.indexOf("e") + 1)) + e
      );
    } else {
      r = new Big(s);
    }

    e = r.e + (Big.DP += 4);

    // Newton-Raphson iteration.
    do {
      t = r;
      r = half.times(t.plus(x.div(t)));
    } while (t.c.slice(0, e).join("") !== r.c.slice(0, e).join(""));

    return round(r, (Big.DP -= 4), Big.RM);
  };

  /*
   * Return a new Big whose value is the value of this Big times the value of Big y.
   */
  P.times = P.mul = function (y) {
    var c,
      x = this,
      Big = x.constructor,
      xc = x.c,
      yc = (y = new Big(y)).c,
      a = xc.length,
      b = yc.length,
      i = x.e,
      j = y.e;

    // Determine sign of result.
    y.s = x.s == y.s ? 1 : -1;

    // Return signed 0 if either 0.
    if (!xc[0] || !yc[0]) return new Big(y.s * 0);

    // Initialise exponent of result as x.e + y.e.
    y.e = i + j;

    // If array xc has fewer digits than yc, swap xc and yc, and lengths.
    if (a < b) {
      c = xc;
      xc = yc;
      yc = c;
      j = a;
      a = b;
      b = j;
    }

    // Initialise coefficient array of result with zeros.
    for (c = new Array((j = a + b)); j--; ) c[j] = 0;

    // Multiply.

    // i is initially xc.length.
    for (i = b; i--; ) {
      b = 0;

      // a is yc.length.
      for (j = a + i; j > i; ) {
        // Current sum of products at this digit position, plus carry.
        b = c[j] + yc[i] * xc[j - i - 1] + b;
        c[j--] = b % 10;

        // carry
        b = (b / 10) | 0;
      }

      c[j] = (c[j] + b) % 10;
    }

    // Increment result exponent if there is a final carry, otherwise remove leading zero.
    if (b) ++y.e;
    else c.shift();

    // Remove trailing zeros.
    for (i = c.length; !c[--i]; ) c.pop();
    y.c = c;

    return y;
  };

  /*
   * Return a string representing the value of this Big in exponential notation to dp fixed decimal
   * places and rounded using Big.RM.
   *
   * dp? {number} Integer, 0 to MAX_DP inclusive.
   */
  P.toExponential = function (dp) {
    return stringify(this, 1, dp, dp);
  };

  /*
   * Return a string representing the value of this Big in normal notation to dp fixed decimal
   * places and rounded using Big.RM.
   *
   * dp? {number} Integer, 0 to MAX_DP inclusive.
   *
   * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.
   * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
   */
  P.toFixed = function (dp) {
    return stringify(this, 2, dp, this.e + dp);
  };

  /*
   * Return a string representing the value of this Big rounded to sd significant digits using
   * Big.RM. Use exponential notation if sd is less than the number of digits necessary to represent
   * the integer part of the value in normal notation.
   *
   * sd {number} Integer, 1 to MAX_DP inclusive.
   */
  P.toPrecision = function (sd) {
    return stringify(this, 3, sd, sd - 1);
  };

  /*
   * Return a string representing the value of this Big.
   * Return exponential notation if this Big has a positive exponent equal to or greater than
   * Big.PE, or a negative exponent equal to or less than Big.NE.
   * Omit the sign for negative zero.
   */
  P.toString = function () {
    return stringify(this);
  };

  /*
   * Return a string representing the value of this Big.
   * Return exponential notation if this Big has a positive exponent equal to or greater than
   * Big.PE, or a negative exponent equal to or less than Big.NE.
   * Include the sign for negative zero.
   */
  P.valueOf = P.toJSON = function () {
    return stringify(this, 4);
  };

  // Export

  Big = _Big_();

  Big["default"] = Big.Big = Big;

  //AMD.
  if (typeof define === "function" && define.amd) {
    define(function () {
      return Big;
    });

    // Node and other CommonJS-like environments that support module.exports.
  } else if (typeof module !== "undefined" && module.exports) {
    module.exports = Big;

    //Browser.
  } else {
    GLOBAL.Big = Big;
  }
})(this);

 src/api/business/inspectionTask.js

@@ -269,3 +269,12 @@
    params: query,
  });
}

// æ£€éªŒå•è¯¦æƒ…-任务切换
export function inspectionOrderDetailsTaskSwitching(query) {
  return request({
    url: "/insOrderPlan/inspectionOrderDetailsTaskSwitching",
    method: "get",
    params: query,
  });
}

 src/components/Table/lims-table.vue

@@ -1,82 +1,29 @@
<template>
  <div>
    <!-- è¡¨æ ¼ -->
    <el-table
      ref="multipleTable"
      v-loading="tableLoading"
      :border="border"
      :data="tableData"
      :header-cell-style="{ background: '#f8f8f9', color: '#515a6e' }"
      :height="height"
      :highlight-current-row="highlightCurrentRow"
      :row-class-name="rowClassName"
      :row-style="rowStyle"
      :row-key="rowKey"
      :span-method="spanMethod"
      stripe
      style="width: 100%"
      tooltip-effect="dark"
      @row-click="rowClick"
      @current-change="currentChange"
      @selection-change="handleSelectionChange"
    >
      <el-table-column
        align="center"
        type="selection"
        width="55"
        v-if="isSelection"
      />
      <el-table-column
        align="center"
        label="序号"
        type="index"
        width="60"
        :index="indexMethod"
      />
    <el-table ref="multipleTable" v-loading="tableLoading" :border="border" :data="tableData"
      :header-cell-style="{ background: '#f8f8f9', color: '#515a6e' }" :height="height"
      :highlight-current-row="highlightCurrentRow" :row-class-name="rowClassName" :row-style="rowStyle"
      :row-key="rowKey" :span-method="spanMethod" stripe style="width: 100%" tooltip-effect="dark" @row-click="rowClick"
      @current-change="currentChange" @selection-change="handleSelectionChange">
      <el-table-column align="center" type="selection" width="55" v-if="isSelection" />
      <el-table-column align="center" label="序号" type="index" width="60" :index="indexMethod" />

      <el-table-column
        v-for="(item, index) in column"
        :key="index"
        :column-key="item.columnKey"
        :filter-method="item.filterHandler"
        :filter-multiple="item.filterMultiple"
        :filtered-value="item.filteredValue"
        :filters="item.filters"
        :fixed="item.fixed"
        :label="item.label"
        :min-width="item.minWidth"
        :prop="item.prop"
        :show-overflow-tooltip="item.dataType === 'action' ? false : true"
        :sortable="item.sortable ? true : false"
        :type="item.type"
        :width="
          item.dataType === 'action' ? getWidth(item.operation) : item.width
        "
        align="center"
      >
      <el-table-column v-for="(item, index) in column" :key="index" :column-key="item.columnKey"
        :filter-method="item.filterHandler" :filter-multiple="item.filterMultiple" :filtered-value="item.filteredValue"
        :filters="item.filters" :fixed="item.fixed" :label="item.label" :min-width="item.minWidth" :prop="item.prop"
        :show-overflow-tooltip="item.dataType === 'action' ? false : true" :sortable="item.sortable ? true : false"
        :type="item.type" :width="item.dataType === 'action' ? getWidth(item.operation) : item.width
          " align="center">
        <!-- <div class="123" v-if="item.type == ''"> -->
        <template
          v-if="item.hasOwnProperty('colunmTemplate')"
          :slot="item.colunmTemplate"
          slot-scope="scope"
        >
          <slot
            v-if="item.theadSlot"
            :index="index"
            :name="item.theadSlot"
            :row="scope.row"
          />
        <template v-if="item.hasOwnProperty('colunmTemplate')" :slot="item.colunmTemplate" slot-scope="scope">
          <slot v-if="item.theadSlot" :index="index" :name="item.theadSlot" :row="scope.row" />
        </template>

        <template slot-scope="scope">
          <!-- æ’槽 -->
          <div v-if="item.dataType == 'slot'">
            <slot
              v-if="item.slot"
              :index="scope.$index"
              :name="item.slot"
              :row="scope.row"
            />
            <slot v-if="item.slot" :index="scope.$index" :name="item.slot" :row="scope.row" />
          </div>
          <!-- è¿›åº¦æ¡ -->
          <div v-else-if="item.dataType == 'progress'">
@@ -84,107 +31,61 @@
          </div>
          <!-- å›¾ç‰‡ -->
          <div v-else-if="item.dataType == 'image'">
            <img
              :src="javaApi + '/img/' + item.prop"
              alt=""
              style="width: 40px; height: 40px; margin-top: 10px"
            />
            <img :src="javaApi + '/img/' + item.prop" alt="" style="width: 40px; height: 40px; margin-top: 10px" />
          </div>

          <!-- tag -->
          <div v-else-if="item.dataType == 'tag'">
            <el-tag
              v-if="
            <el-tag v-if="
                typeof dataTypeFn(scope.row[item.prop], item.formatData) ==
                'string'
              "
              :title="scope.row[item.prop] | formatters(item.formatData)"
              :type="formatType(scope.row[item.prop], item.formatType)"
              >{{ scope.row[item.prop] | formatters(item.formatData) }}</el-tag
            >
            <el-tag
              v-for="(tag, index) in dataTypeFn(
            " :title="scope.row[item.prop] | formatters(item.formatData)"
              :type="formatType(scope.row[item.prop], item.formatType)">{{ scope.row[item.prop] |
                formatters(item.formatData) }}</el-tag>
            <el-tag v-for="(tag, index) in dataTypeFn(
                scope.row[item.prop],
                item.formatData
              )"
              v-else-if="
            )" v-else-if="
                typeof dataTypeFn(scope.row[item.prop], item.formatData) ==
                'object'
              "
              :key="index"
              :title="scope.row[item.prop] | formatters(item.formatData)"
              :type="formatType(tag, item.formatType)"
              >{{
            " :key="index" :title="scope.row[item.prop] | formatters(item.formatData)"
              :type="formatType(tag, item.formatType)">{{
                item.tagGroup
                  ? tag[item.tagGroup.label]
                    ? tag[item.tagGroup.label]
                    : tag
                  : tag
              }}</el-tag
            >
            <el-tag
              v-else
              :title="scope.row[item.prop] | formatters(item.formatData)"
              :type="formatType(scope.row[item.prop], item.formatType)"
              >{{ scope.row[item.prop] | formatters(item.formatData) }}</el-tag
            >
              }}</el-tag>
            <el-tag v-else :title="scope.row[item.prop] | formatters(item.formatData)"
              :type="formatType(scope.row[item.prop], item.formatType)">{{ scope.row[item.prop] |
                formatters(item.formatData) }}</el-tag>
          </div>

          <!-- æŒ‰é’® -->
          <div v-else-if="item.dataType == 'action'">
            <template v-for="(o, key) in item.operation">
              <el-button
                v-if="o.type != 'upload'"
                size="mini"
                v-show="o.showHide ? o.showHide(scope.row) : true"
                :disabled="o.disabled ? o.disabled(scope.row) : false"
                :icon="iconFn(o)"
                :plain="o.plain"
                :style="{ color: o.name === '删除' ? '#f56c6c' : o.color }"
                :type="o.type | typeFn(scope.row)"
                @click="o.clickFun(scope.row)"
                :key="key"
              >
              <el-button v-if="o.type != 'upload'" size="mini" v-show="o.showHide ? o.showHide(scope.row) : true"
                :disabled="o.disabled ? o.disabled(scope.row) : false" :icon="iconFn(o)" :plain="o.plain"
                :style="{ color: o.name === '删除' ? '#f56c6c' : o.color }" :type="o.type | typeFn(scope.row)"
                @click="o.clickFun(scope.row)" :key="key">
                {{ o.name }}
              </el-button>
              <el-upload
                action="#"
                size="mini"
                :on-change="
                  (file, fileList) => o.clickFun(scope.row, file, fileList)
                "
                :multiple="o.multiple ? o.multiple : false"
                :limit="o.limit ? o.limit : 1"
                :disabled="o.disabled ? o.disabled(scope.row) : false"
                :accept="
                  o.accept
              <el-upload action="#" size="mini" :on-change="(file, fileList) => o.clickFun(scope.row, file, fileList)
                " :multiple="o.multiple ? o.multiple : false" :limit="o.limit ? o.limit : 1"
                :disabled="o.disabled ? o.disabled(scope.row) : false" :accept="o.accept
                    ? o.accept
                    : '.jpg,.jpeg,.png,.gif,.doc,.docx,.xls,.xlsx,.ppt,.pptx,.pdf,.zip,.rar'
                "
                v-if="o.type == 'upload'"
                style="display: inline-block; width: 50px"
                v-show="o.showHide ? o.showHide(scope.row) : true"
                :auto-upload="false"
                :on-exceed="onExceed"
                :show-file-list="false"
                :key="key"
              >
                <el-button
                  :size="o.size ? o.size : 'small'"
                  type="text"
                  :disabled="o.disabled ? o.disabled(scope.row) : false"
                  >{{ o.name }}</el-button
                >
                  " v-if="o.type == 'upload'" style="display: inline-block; width: 50px"
                v-show="o.showHide ? o.showHide(scope.row) : true" :auto-upload="false" :on-exceed="onExceed"
                :show-file-list="false" :key="key">
                <el-button :size="o.size ? o.size : 'small'" type="text"
                  :disabled="o.disabled ? o.disabled(scope.row) : false">{{ o.name }}</el-button>
              </el-upload>
            </template>
          </div>
          <!-- å¯ç‚¹å‡»çš„文字 -->
          <div
            v-else-if="item.dataType == 'link'"
            class="cell link"
            style="width: 100%"
            @click="goLink(scope.row, item.linkMethod)"
          >
          <div v-else-if="item.dataType == 'link'" class="cell link" style="width: 100%"
            @click="goLink(scope.row, item.linkMethod)">
            <span v-if="!item.formatData">{{ scope.row[item.prop] }}</span>
          </div>
          <!-- é»˜è®¤çº¯å±•ç¤ºæ•°æ® -->
@@ -197,14 +98,8 @@
        </template>
      </el-table-column>
    </el-table>
    <pagination
      v-show="page.total > 0"
      :total="page.total"
      :layout="page.layout"
      :page.sync="page.current"
      :limit.sync="page.size"
      @pagination="pagination"
    />
    <pagination v-show="page.total > 0" :total="page.total" :layout="page.layout" :page.sync="page.current"
      :limit.sync="page.size" @pagination="pagination" />
  </div>
</template>

@@ -513,6 +408,7 @@
>>> .cell {
  padding: 0 !important;
}

.cell {
  white-space: nowrap;
  overflow: hidden;
@@ -520,11 +416,14 @@
  padding-right: 4px !important;
  padding-left: 10px !important;
}

.link {
  color: rgb(64, 158, 255);
  cursor: pointer;
}

>>> .el-table__body-wrapper::-webkit-scrollbar {
  height: 14px; /* è®¾ç½®æ»šåŠ¨æ¡å®½åº¦ */
  height: 14px;
  /* è®¾ç½®æ»šåŠ¨æ¡å®½åº¦ */
}
</style>

 src/router/index.js

@@ -101,17 +101,21 @@
    children: [
      {
        // åŽŸææ–™ä¸‹å•
        path: 'customsInspection',
        component: () => import('@/views/business/materialOrder/customsInspection'),
        name: 'customsInspection',
        meta: { title: '原材料下单详情', activeMenu: '/business/materialOrder' }
        path: "customsInspection",
        component: () =>
          import("@/views/business/materialOrder/customsInspection"),
        name: "customsInspection",
        meta: {
          title: "原材料下单详情",
          activeMenu: "/business/materialOrder",
        },
      },
      {
        // é“œææ–™ä¸‹å•
        path: 'copperOrder',
        component: () => import('@/views/business/materialOrder/copperOrder'),
        name: 'copperOrder',
        meta: { title: '铜材料下单', activeMenu: '/business/materialOrder' }
        path: "copperOrder",
        component: () => import("@/views/business/materialOrder/copperOrder"),
        name: "copperOrder",
        meta: { title: "铜材料下单", activeMenu: "/business/materialOrder" },
      },
    ],
  },

 src/utils/request.js

@@ -1,114 +1,148 @@
import axios from 'axios'
import { Notification, MessageBox, Message, Loading } from 'element-ui'
import store from '@/store'
import { getToken } from '@/utils/auth'
import errorCode from '@/utils/errorCode'
import axios from "axios";
import { Notification, MessageBox, Message, Loading } from "element-ui";
import store from "@/store";
import { getToken } from "@/utils/auth";
import errorCode from "@/utils/errorCode";
import { tansParams, blobValidate } from "@/utils/ruoyi";
import cache from '@/plugins/cache'
import { saveAs } from 'file-saver'
import cache from "@/plugins/cache";
import { saveAs } from "file-saver";

let downloadLoadingInstance;
// æ˜¯å¦æ˜¾ç¤ºé‡æ–°ç™»å½•
export let isRelogin = { show: false };

axios.defaults.headers['Content-Type'] = 'application/json;charset=utf-8'
axios.defaults.headers["Content-Type"] = "application/json;charset=utf-8";
// åˆ›å»ºaxios实例
const service = axios.create({
  // axios中请求配置有baseURL选项，表示请求URL公共部分
  baseURL: process.env.VUE_APP_BASE_API,
  // è¶…æ—¶
  timeout: 10000
})
  timeout: 10000 * 60,
});

// request拦截器
service.interceptors.request.use(config => {
service.interceptors.request.use(
  (config) => {
  // æ˜¯å¦éœ€è¦è®¾ç½® token
  const isToken = (config.headers || {}).isToken === false
    const isToken = (config.headers || {}).isToken === false;
  // æ˜¯å¦éœ€è¦é˜²æ­¢æ•°æ®é‡å¤æäº¤
  const isRepeatSubmit = (config.headers || {}).repeatSubmit === false
    const isRepeatSubmit = (config.headers || {}).repeatSubmit === false;
  if (getToken() && !isToken) {
    config.headers['Authorization'] = 'Bearer ' + getToken() // è®©æ¯ä¸ªè¯·æ±‚携带自定义token è¯·æ ¹æ®å®žé™…情况自行修改
      config.headers["Authorization"] = "Bearer " + getToken(); // è®©æ¯ä¸ªè¯·æ±‚携带自定义token è¯·æ ¹æ®å®žé™…情况自行修改
  }
  // get请求映射params参数
  if (config.method === 'get' && config.params) {
    let url = config.url + '?' + tansParams(config.params);
    if (config.method === "get" && config.params) {
      let url = config.url + "?" + tansParams(config.params);
    url = url.slice(0, -1);
    config.params = {};
    config.url = url;
  }
  if (!isRepeatSubmit && (config.method === 'post' || config.method === 'put')) {
    if (
      !isRepeatSubmit &&
      (config.method === "post" || config.method === "put")
    ) {
    const requestObj = {
      url: config.url,
      data: typeof config.data === 'object' ? JSON.stringify(config.data) : config.data,
      time: new Date().getTime()
    }
        data:
          typeof config.data === "object"
            ? JSON.stringify(config.data)
            : config.data,
        time: new Date().getTime(),
      };
    const requestSize = Object.keys(JSON.stringify(requestObj)).length; // è¯·æ±‚数据大小
    const limitSize = 5 * 1024 * 1024; // é™åˆ¶å­˜æ”¾æ•°æ®5M
    if (requestSize >= limitSize) {
      console.warn(`[${config.url}]: ` + '请求数据大小超出允许的5M限制，无法进行防重复提交验证。')
        console.warn(
          `[${config.url}]: ` +
            "请求数据大小超出允许的5M限制，无法进行防重复提交验证。"
        );
      return config;
    }
    const sessionObj = cache.session.getJSON('sessionObj')
    if (sessionObj === undefined || sessionObj === null || sessionObj === '') {
      cache.session.setJSON('sessionObj', requestObj)
      const sessionObj = cache.session.getJSON("sessionObj");
      if (
        sessionObj === undefined ||
        sessionObj === null ||
        sessionObj === ""
      ) {
        cache.session.setJSON("sessionObj", requestObj);
    } else {
      const s_url = sessionObj.url;                  // è¯·æ±‚地址
      const s_data = sessionObj.data;                // è¯·æ±‚数据
      const s_time = sessionObj.time;                // è¯·æ±‚时间
      const interval = 1000;                         // é—´éš”时间(ms)，小于此时间视为重复提交
      if (s_data === requestObj.data && requestObj.time - s_time < interval && s_url === requestObj.url) {
        const message = '数据正在处理，请勿重复提交';
        console.warn(`[${s_url}]: ` + message)
        return Promise.reject(new Error(message))
        if (
          s_data === requestObj.data &&
          requestObj.time - s_time < interval &&
          s_url === requestObj.url
        ) {
          const message = "数据正在处理，请勿重复提交";
          console.warn(`[${s_url}]: ` + message);
          return Promise.reject(new Error(message));
      } else {
        cache.session.setJSON('sessionObj', requestObj)
          cache.session.setJSON("sessionObj", requestObj);
      }
    }
  }
  return config
}, error => {
    console.log(error)
    Promise.reject(error)
})
    return config;
  },
  (error) => {
    console.log(error);
    Promise.reject(error);
  }
);

// å“åº”拦截器
service.interceptors.response.use(res => {
service.interceptors.response.use(
  (res) => {
    // æœªè®¾ç½®çŠ¶æ€ç åˆ™é»˜è®¤æˆåŠŸçŠ¶æ€
    const code = res.data.code || 200;
    // èŽ·å–错误信息
    const msg = errorCode[code] || res.data.msg || errorCode['default']
    const msg = errorCode[code] || res.data.msg || errorCode["default"];
    // äºŒè¿›åˆ¶æ•°æ®åˆ™ç›´æŽ¥è¿”回
    if (res.request.responseType ===  'blob' || res.request.responseType ===  'arraybuffer') {
      return res.data
    if (
      res.request.responseType === "blob" ||
      res.request.responseType === "arraybuffer"
    ) {
      return res.data;
    }
    if (code === 401) {
      if (!isRelogin.show) {
        isRelogin.show = true;
        MessageBox.confirm('登录状态已过期，您可以继续留在该页面，或者重新登录', '系统提示', { confirmButtonText: '重新登录', cancelButtonText: '取消', type: 'warning' }).then(() => {
        MessageBox.confirm(
          "登录状态已过期，您可以继续留在该页面，或者重新登录",
          "系统提示",
          {
            confirmButtonText: "重新登录",
            cancelButtonText: "取消",
            type: "warning",
          }
        )
          .then(() => {
          isRelogin.show = false;
          store.dispatch('LogOut').then(() => {
            location.href = '/index';
            store.dispatch("LogOut").then(() => {
              location.href = "/index";
            });
          })
      }).catch(() => {
          .catch(() => {
        isRelogin.show = false;
      });
    }
      return Promise.reject('无效的会话，或者会话已过期，请重新登录。')
      return Promise.reject("无效的会话，或者会话已过期，请重新登录。");
    } else if (code === 500) {
      Message({ message: msg, type: 'error' })
      return Promise.reject(new Error(msg))
      Message({ message: msg, type: "error" });
      return Promise.reject(new Error(msg));
    } else if (code === 601) {
      Message({ message: msg, type: 'warning' })
      return Promise.reject('error')
      Message({ message: msg, type: "warning" });
      return Promise.reject("error");
    } else if (code !== 200) {
      Notification.error({ title: msg })
      return Promise.reject('error')
      Notification.error({ title: msg });
      return Promise.reject("error");
    } else {
      return res.data
      return res.data;
    }
  },
  error => {
    console.log('err' + error)
  (error) => {
    console.log("err" + error);
    let { message } = error;
    if (message == "Network Error") {
      message = "后端接口连接异常";
@@ -117,36 +151,48 @@
    } else if (message.includes("Request failed with status code")) {
      message = "系统接口" + message.substr(message.length - 3) + "异常";
    }
    Message({ message: message, type: 'error', duration: 5 * 1000 })
    return Promise.reject(error)
    Message({ message: message, type: "error", duration: 5 * 1000 });
    return Promise.reject(error);
  }
)
);

// é€šç”¨ä¸‹è½½æ–¹æ³•
export function download(url, params, filename, config) {
  downloadLoadingInstance = Loading.service({ text: "正在下载数据，请稍候", spinner: "el-icon-loading", background: "rgba(0, 0, 0, 0.7)", })
  return service.post(url, params, {
    transformRequest: [(params) => { return tansParams(params) }],
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    responseType: 'blob',
    ...config
  }).then(async (data) => {
  downloadLoadingInstance = Loading.service({
    text: "正在下载数据，请稍候",
    spinner: "el-icon-loading",
    background: "rgba(0, 0, 0, 0.7)",
  });
  return service
    .post(url, params, {
      transformRequest: [
        (params) => {
          return tansParams(params);
        },
      ],
      headers: { "Content-Type": "application/x-www-form-urlencoded" },
      responseType: "blob",
      ...config,
    })
    .then(async (data) => {
    const isBlob = blobValidate(data);
    if (isBlob) {
      const blob = new Blob([data])
      saveAs(blob, filename)
        const blob = new Blob([data]);
        saveAs(blob, filename);
    } else {
      const resText = await data.text();
      const rspObj = JSON.parse(resText);
      const errMsg = errorCode[rspObj.code] || rspObj.msg || errorCode['default']
        const errMsg =
          errorCode[rspObj.code] || rspObj.msg || errorCode["default"];
      Message.error(errMsg);
    }
    downloadLoadingInstance.close();
  }).catch((r) => {
    console.error(r)
    Message.error('下载文件出现错误，请联系管理员！')
    downloadLoadingInstance.close();
  })
    .catch((r) => {
      console.error(r);
      Message.error("下载文件出现错误，请联系管理员！");
      downloadLoadingInstance.close();
    });
}

export default service
export default service;

 src/views/business/inspectionTask/inspection.vue

@@ -1,9 +1,7 @@
<template>
  <div v-loading="loading" class="inspection">
    <el-row class="title">
      <el-col :span="4" style="padding-left: 20px; text-align: left">检验单详情
      </el-col>
      <el-col :span="20" style="text-align: right">
      <el-col :span="8" style="text-align: left">
        <el-form :inline="true" :model="otherForm" class="form-inline" label-width="50px"
          style="text-align: right; padding-top: 0; display: inline">
          <el-form-item label="温度:" style="margin-bottom: 0">
@@ -17,7 +15,9 @@
            <span style="margin-left: 4px">%</span>
          </el-form-item>
        </el-form>
        <el-button size="small" type="primary" @click="refreshView">刷新</el-button>
      </el-col>
      <el-col :span="16" style="text-align: right">
        <!-- <el-button size="small" type="primary" @click="refreshView">刷新</el-button> -->
        <el-button v-if="typeSource === 1" size="small" type="primary" @click="openPurchase">进货验证</el-button>
        <el-button v-if="state === 1 && typeSource === 1" size="small" type="primary"
          @click="openUnPassDialog('add')">不合格处理</el-button>
@@ -68,7 +68,7 @@
        <el-form-item v-if="typeSource === 1" label="厂家密度:">
          <el-input v-model="supplierDensity" clearable disabled placeholder="请输入" size="small"></el-input>
        </el-form-item>
        <el-form-item label="当前样品位数:">
        <el-form-item label="当前样品位数:" label-width="120px">
          <el-tag v-if="currentKey">{{ `NO.${currentKey}` }}</el-tag>
        </el-form-item>
        <el-form-item label="备注:">
@@ -78,6 +78,7 @@
          <!-- <el-tag v-if="currentKey">{{ insOrder.remark }}</el-tag> -->
        </el-form-item>
      </el-form>
      <el-divider></el-divider>
    </div>
    <div class="center">
      <div class="search" style="
@@ -149,19 +150,9 @@
        </div>
      </div>
      <!-- å¸¸è§„检验原始记录 -->
      <div v-if="
        !tableLists.find((m) => m.templateId == currentTable) ||
        (tableLists.find((m) => m.templateId == currentTable).templateName !=
          '温度循环检验原始记录' &&
          !tableLists
            .find((m) => m.templateId == currentTable)
            .templateName.includes('热循环') &&
          !tableLists
            .find((m) => m.templateId == currentTable)
            .templateName.includes('温升试验') &&
          tableLists.find((m) => m.templateId == currentTable).templateName !=
          '弧垂特性检验原始记录')
      " id="nav" v-loading="tableLoading" class="center-box">
      <div id="nav" v-loading="tableLoading" class="center-box">
        <template v-if="
          tableLists.find((m) => m.templateId == currentTable)">
        <table v-for="(item, index) in tableList" :key="index + currentTable + currentSample.id" border="1"
          cellpadding="10" class="tables" id="myTable">
          <tbody>
@@ -258,12 +249,8 @@
                        :style="`font-family:${n.v.ff} !important;color: #3A7BFA;`">不判定</span>
                      <span v-else :style="`font-family:${n.v.ff} !important;`">待定</span>
                    </template>
                    <template v-if="
                      PROJECT == '检测中心' ||
                      (PROJECT == '装备电缆' &&
                        getInspectionValueType(n.i) != 2 &&
                        state == 1)
                    ">
                      <template v-if="getInspectionValueType(n.i) != 2 &&
                        state == 1">
                      <span v-if="n.v.v === 1" :style="`font-family:${n.v.ff} !important;color: green;`">合格</span>
                      <span v-else-if="n.v.v === 0" :style="`font-family:${n.v.ff} !important;color: red;`">不合格</span>
                      <span v-else-if="n.v.v === 3"
@@ -284,7 +271,8 @@
                    <el-select v-model="n.v.v" :disabled="state > 1" class="table_input" filterable multiple
                      placeholder="设备" remote @change="(val) => changeEquip(val, n)"
                      @visible-change="(e) => getEquipOptions(e, n.i)">
                      <el-option v-for="item in equipOptions" :key="item.value" :label="item.label" :value="item.value">
                        <el-option v-for="item in equipOptions" :key="item.value" :label="item.label"
                          :value="item.value">
                        {{ item.label + "--" + item.value }}
                      </el-option>
                    </el-select>
@@ -323,14 +311,12 @@
                        align-items: center;
                        width: 100%;
                      ">
                      <i v-if="!currentFiberOpticTape && !currentFiberOptic" class="el-icon-caret-left table_caret"
                        style="width: 16px" @click="caretSample(-1)"></i>
                        <i class="el-icon-caret-left table_caret" style="width: 16px" @click="caretSample(-1)"></i>
                      <div
                        :style="`font-family:${n.v.ff} !important;overflow: hidden;white-space: nowrap;width: calc(100% - 32px);`">
                        {{ currentSample.sampleCode }}
                      </div>
                      <i v-if="!currentFiberOpticTape && !currentFiberOptic" class="el-icon-caret-right table_caret"
                        style="width: 16px" @click="caretSample(1)"></i>
                        <i class="el-icon-caret-right table_caret" style="width: 16px" @click="caretSample(1)"></i>
                    </div>
                  </template>
                  <template v-else-if="
@@ -349,16 +335,16 @@
            </tr>
          </tbody>
        </table>
        </template>
      </div>
      <el-upload v-if="state == 1" ref="upload" :action="action" :before-upload="beforeUpload" :data="{
        orderId: id,
      }" :headers="headers" :on-error="onError" :on-success="handleSuccessUp" :show-file-list="false"
        accept=".jpg,.jpeg,.png,.gif,.doc,.docx,.xls,.xlsx,.ppt,.pptx,.pdf,.zip,.rar" style="width: 80px !important">
        accept=".jpg,.jpeg,.png,.gif,.doc,.docx,.xls,.xlsx,.ppt,.pptx,.pdf,.zip,.rar"
        style="width: 80px !important;margin-top: 10px;">
        <el-button v-if="state == 1" size="small" type="primary">附件上传</el-button></el-upload>
      <lims-table :tableData="tableData" :column="column" :page="page" :tableLoading="tableLoading"
        :height="'calc(100vh - 290px)'" @pagination="pagination"></lims-table>
      <!-- <ValueTable :key="upIndex" ref="fileList" :componentData="componentData0" :delUrl="$api.insOrderPlan.delfile"
        :url="$api.insOrderPlan.getFileList" class="value-table" style="height: 100%; margin-top: 16px" /> -->
        :height="'calc(100vh - 290px)'" @pagination="pagination" style="height: 100%; margin-top: 16px"></lims-table>
    </div>
    <el-drawer :size="550" :visible.sync="sampleVisible" title="样品切换">
      <el-table v-if="sampleVisible" ref="productTable" :current-row-key="currentKey" :data="sampleProduct"
@@ -390,8 +376,8 @@
      </el-table>
    </el-drawer>
    <el-drawer :size="500" :visible.sync="taskVisible" title="任务切换">
      <!-- <ValueTable :key="upIndex" ref="insOrderPlan" :componentData="componentData"
        :url="$api.insOrderPlan.inspectionOrderDetailsTaskSwitching" class="value-table" style="height: 100%" /> -->
      <lims-table :tableData="tableData0" :column="column0" :page="page0" :tableLoading="tableLoading0"
        :height="'calc(100vh - 90px)'" :currentChange="handleChangeTask"></lims-table>
    </el-drawer>
    <el-dialog :visible.sync="reviewDia" title="检验复核" width="500px">
      <div v-if="reviewDia" class="body" style="display: flex; padding: 10px">
@@ -519,8 +505,8 @@
        <el-button :loading="reviewLoading" type="primary" @click="upInsReview(1)">ç¡® å®š</el-button>
      </span>
    </el-dialog>
    <add-un-pass v-if="addUnPassDialog" ref="addUnPassDialog" :addUnPassDialog="addUnPassDialog"
      @resetAddUnPass="resetAddUnPass"></add-un-pass>
    <!-- <add-un-pass v-if="addUnPassDialog" ref="addUnPassDialog" :addUnPassDialog="addUnPassDialog"
      @resetAddUnPass="resetAddUnPass"></add-un-pass> -->
    <!-- <UnPassDialog
      v-if="unPassDialog"
      ref="unPassDialog"
@@ -565,8 +551,6 @@
  dataCollection,
  write,
  getInsProduct,
  getReportModel,
  determineWhetherToCollectData,
  search,
  verifyPlan,
  checkSubmitPlan,
@@ -575,8 +559,11 @@
  selectUserCondition,
  downFile,
  getFileList,
  delfile
  delfile,
  inspectionOrderDetailsTaskSwitching
} from "@/api/business/inspectionTask.js";
import InspectionWorker from '../../../InspectionWorker.worker';
import DataWorker from '../../../DataWorker.worker';
import html2canvas from "html2canvas";
import { mapGetters } from "vuex";
export default {
@@ -606,7 +593,6 @@
        load: null,
      },
      dataGetDia: false,
      wareTableDataLoading: false,
      fileAdd: false,
      sampleVisible: false,
      taskVisible: false,
@@ -616,34 +602,7 @@
        state: null,
      },
      id: null,
      componentData: {
        entity: {
          sonLaboratory: null,
          userId: 0,
        },
        isIndex: false,
        showSelect: false,
        select: false,
        selectMethod: "handleChangeTask",
        sort: false,
        do: [],
        isPage: false,
        linkEvent: {},
        tagField: {
          type: {
            select: [],
          },
          insState: {
            select: [],
          },
        },
        currentId: "",
        selectField: {},
        requiredAdd: [],
        requiredUp: [],
      },
      changeType: null,
      getReportModelLoading: false,
      insOrder: {},
      sampleProduct: [],
      supplierDensity: "", // åŽ‚家密度
@@ -672,30 +631,14 @@
      verifyUser: null,
      personList: [],
      enumList: [],
      fiberOpticVisible: false,
      fiberOpticTapeVisible: false,
      bushingVisible: false,
      fiberOpticTape: [], //光纤带列表
      fiberOptic: [], //光纤列表
      bushing: [], //套管列表
      currentFiberOpticTape: null, //当前光纤带
      currentFiberOptic: null, //当前光纤
      currentBushing: null, //当前套管
      tableLoading: false,
      upLoading: false,
      temptList: null,
      fiber: [],
      fibers: [],
      casing: [],
      currentTab: null,
      wareForm: {
        inspectionItem: 1,
        inspectionItemSubclass: "20(常温)",
      },
      wareForm0: {},
      numOptions: [],
      temperatureOptions: [],
      wareTableData: [],
      otherForm: {
        humidity: null,
        temperature: null,
@@ -713,18 +656,8 @@
      dataAcquisitionInfo: {},
      dataAcquisitionInfoNew: {},
      dataAcquisitionEidtAble: false,
      isGet: false,
      dataAcquisitionLoading: false,
      collected: false,
      // çƒ­å¾ªçŽ¯---开始
      thermalCyclingInfo: {
        max: 0,
        inspectionItem: 1,
        arr: [],
        length: 1,
        inspectionItemClass: null,
      },
      thermalCyclingLoading: false,
      temDataAcquisition: false,
      getData: [
        {
@@ -781,7 +714,7 @@
            } else {
              return '文件'
            }
          },
          }
        },
        { label: "附件名称", prop: "fileName" },
        { label: "上传人", prop: "name" },
@@ -818,6 +751,39 @@
      },
      tableLoading: false,
      // æ–‡ä»¶åˆ—表相关--结束
      // ä»»åŠ¡åˆ‡æ¢åˆ—表--开始
      tableData0: [],
      column0: [
        { label: "委托编号", prop: "entrustCode", width: '160px' },
        { label: "检验对象", prop: "sampleType", width: '140px' },
        {
          label: "紧急程度", prop: "type", dataType: "tag",
          formatData: (params) => {
            return this.urgentList.find(m => m.value == params).label
          },
          formatType: (params) => {
            return this.urgentList.find(m => m.value == params).type
          }
        },
        {
          label: "状态", prop: "insState", dataType: "tag",
          formatData: (params) => {
            return this.typeList.find(m => m.value == params).label
          },
          formatType: (params) => {
            return this.typeList.find(m => m.value == params).type
          }
        },
        { label: "约定时间", prop: "appointed", width: '140px' },
        { label: "下发时间", prop: "sendTime", width: '140px' },
      ],
      page0: {
        total: 0,
        size: -1,
        current: -1,
      },
      tableLoading0: false,
      // ä»»åŠ¡åˆ‡æ¢åˆ—表--结束
    };
  },
  // ç”¨äºŽä¸Šä¼ æ–‡ä»¶çš„信息
@@ -833,8 +799,6 @@
    },
  },
  created() {
    this.componentData.entity.sonLaboratory = this.sonLaboratory;
    this.getUserInfo();
    let { sonLaboratory, orderId, state, inspectorList, typeSource } =
      this.$route.query;
    this.sonLaboratory = sonLaboratory;
@@ -849,9 +813,10 @@
    this.getInsStateDicts();
    this.getComparisonList();
    this.getAuthorizedPerson();
    this.scrollInit();
    // this.getPower();
    this.startWorker();
    this.getList0()
    this.scrollInit();
  },
  watch: {
    // ç›‘听任务id，获取任务信息
@@ -897,8 +862,6 @@
        this.param = {};
        this.changeType = 0;
        this.currentSample.insProduct.forEach((a) => {
          // æ˜¯å¦ä¸ºæˆå“ç”µç¼†ä¸‹çš„松套管项目，不是则执行初始化
          if (this.handleCasing(a.inspectionItem)) {
            this.param[a.id] = {
              insValue: [],
              comValue: [],
@@ -907,30 +870,15 @@
              equipName: [],
              insResult: null,
            };
          }
        });
        this.determineWhetherToCollectData(); //是否需要数采
        this.getReportModel(this.currentSample.id); //获取套管、光纤带、光纤信息
        if (this.currentSample.index == undefined)
          this.currentSample["index"] = 1;
        let bushing = this.currentSample.bushing;
        this.getTableLists(); //处理模板列表信息

        this.componentData.currentId = val;
        this.currentKey = 1;
        this.getCableTag(this.currentSample.id); // æŸ¥è¯¢æ˜¯å¦æœ‰è¦å¤šæ¬¡æ£€éªŒçš„电缆配置
        this.getRepetitionTag(this.currentSample.id); // æŸ¥è¯¢æ˜¯å¦æœ‰è¦é‡å¤æ£€éªŒé¡¹
        // æ¸…空光纤配置相关数据---下面信息暂时可忽略
        this.fiberOpticTape = [];
        this.currentFiberOpticTape = null;
        this.fiberOptic = [];
        this.currentFiberOptic = null;
        this.bushing = [];
        this.currentBushing = null;
        this.currentTab = null;
        if (bushing && bushing.length > 0) {
          this.bushing = bushing;
        }
      });
    },
    // ç›‘听当前模板变化
@@ -946,7 +894,6 @@
            this.currentSample.insProduct = this.HaveJson(list); //赋值当前样品的检验项
            this.param = {}; //初始化传到后端的参数
            this.currentSample.insProduct.forEach((a, j) => {
              if (this.handleCasing(a.inspectionItem)) {
                this.param[a.id] = {
                  insValue: [],
                  comValue: [],
@@ -955,9 +902,7 @@
                  equipName: [],
                  insResult: null,
                };
              }
            });
            this.getReportModel(this.currentSample.id); //获取套管、光纤带、光纤信息
            // åŽ»é‡æ¨¡æ¿ï¼Œè¿”回有几个模板
            const mySet1 = new Set();
            this.tableLists = this.currentSample.insProduct.filter((m) => {
@@ -1041,14 +986,32 @@
    },
    // æ–‡ä»¶ç®¡ç†--结束

    // ä»»åŠ¡åˆ‡æ¢--开始
    getList0() {
      this.tableLoading0 = true;
      let param = { userId: this.userId, sonLaboratory: this.sonLaboratory, ...this.page0 };
      delete param.total;
      inspectionOrderDetailsTaskSwitching({ ...param })
        .then((res) => {
          this.tableLoading0 = false;
          if (res.code === 200) {
            this.tableData0 = res.data.records;
          }
        })
        .catch((err) => {
          this.tableLoading0 = false;
        });
    },
    // ä»»åŠ¡åˆ‡æ¢--结束

    closeAddVerifyDia() {
      this.addCheck = false;
      this.checkUser = "";
    },
    // åˆ·æ–°é¡µé¢
    refreshView() {
      this.$emit("refreshView");
    },
    // refreshView() {
    //   this.$emit("refreshView");
    // },
    closeUnPassCheckDialog() {
      this.unPassCheck = false;
    },
@@ -1336,11 +1299,11 @@
                      n.v.ps.value.includes("检验值")
                    ) {
                      num++;
                    }
                  });
                  if (str0 == str) {
                    maxNum = num;
                  }
                    }
                  });
                }
                // ç»‘定设备
                if (
@@ -1510,12 +1473,12 @@
        this.stopWorker(); // ç¡®ä¿ä¹‹å‰çš„ Worker å·²åœæ­¢
      }
      // åˆ›å»º Worker å®žä¾‹
      this.worker = new Worker("/static/js/worker.js");
      this.worker = new InspectionWorker();
      if (this.worker0) {
        this.stopWorker(); // ç¡®ä¿ä¹‹å‰çš„ Worker å·²åœæ­¢
      }
      // åˆ›å»º Worker å®žä¾‹
      this.worker0 = new Worker("/static/js/worker0.js");
      this.worker0 = new DataWorker();
    },
    // åœæ­¢å¤šçº¿ç¨‹
    stopWorker() {
@@ -1528,7 +1491,6 @@
        this.worker0 = null;
      }
    },
    // çƒ­å¾ªçŽ¯---结束
    // ä¿å­˜æ¹¿åº¦ã€æ¸©åº¦æ•°æ®
    subOtherForm(m, type) {
      console.log("m---", m);
@@ -1617,13 +1579,6 @@
    async handleChangeSample(row, column, event) {
      // åˆå§‹åŒ–数据
      this.param = {};
      // æ¸…空光纤配置相关数据
      this.fiberOpticTape = [];
      this.currentFiberOpticTape = null;
      this.fiberOptic = [];
      this.currentFiberOptic = null;
      this.bushing = [];
      this.currentBushing = null;
      this.sampleVisible = false;
      // èµ‹å€¼æ ·å“
      this.currentSample = this.HaveJson(row);
@@ -1634,7 +1589,6 @@
      this.param = {};
      this.changeType = 0;
      this.currentSample.insProduct.forEach((a, j) => {
        if (this.handleCasing(a.inspectionItem)) {
          this.param[a.id] = {
            insValue: [],
            comValue: [],
@@ -1643,14 +1597,7 @@
            equipName: [],
            insResult: null,
          };
        }
      });
      // èŽ·å–套管,光纤带,光纤数据
      this.getReportModel(row.id);
      let bushing = this.currentSample.bushing;
      if (bushing && bushing.length > 0) {
        this.bushing = bushing;
      }
      // å¤„理页面列表数据
      this.getTableLists();
      this.currentKey = row.index;
@@ -1665,33 +1612,6 @@
          currentTable: this.currentTable,
        })
      );
    },
    // æ¾å¥—管的判断\如果changeType不等于3那么页面不展示松套管检验项
    handleCasing(inspectionItem) {
      if (this.changeType != 3) {
        if (inspectionItem.includes("松套管")) {
          return false;
        } else {
          return true;
        }
      } else {
        return true;
      }
    },
    // èŽ·å–套管,光纤带,光纤数据
    getReportModel(id) {
      if (this.PROJECT != "检测中心") {
        return;
      }
      this.getReportModelLoading = true;
      getReportModel({
        sampleId: id
      }).then((res) => {
        this.getReportModelLoading = false;
        this.fibers = res.data["光纤带"];
        this.fiber = res.data["光纤"];
        this.casing = res.data["套管"];
      });
    },
    async handleChangeCableTag(m, type, num, m2) {
      let cableTag = "";
@@ -1724,7 +1644,6 @@
            };
          });
          this.getTableLists0(list);
          this.getReportModel(this.currentSample.id);
          this.worker.postMessage(
            JSON.stringify({
              type: "saveData",
@@ -1743,21 +1662,19 @@
    },
    // æ”¹å˜ä»»åŠ¡
    handleChangeTask(row) {
      if (row.length > 0) this.id = row[0].id;
      if (row) this.id = row.id;
      this.taskVisible = false;
    },
    // å­—典获取信息
    getTypeDicts() {
      this.getDicts("urgency_level").then((response) => {
        this.urgentList = this.dictToValue(response.data);
        this.componentData.tagField.type.select = this.urgentList;
      });
    },
    // å­—典获取信息
    getInsStateDicts() {
      this.getDicts("inspection_task_state").then((response) => {
        this.typeList = this.dictToValue(response.data);
        this.componentData.tagField.insState.select = this.typeList;
      });
    },
    // å­—典获取信息
@@ -2196,7 +2113,8 @@
          }
        });
        // ä»¥ä¸‹æ˜¯æ ·å¼å¤„理逻辑
        set = Array.sort(set);
        set = [...set]
        // set = set.sort();
        set.forEach((b) => {
          let arr = [];
          a.template.forEach((c) => {
@@ -2406,11 +2324,6 @@
          this.saveInsContext(currentInsItemId);
        }
      }, 200);
    },
    // æ˜¯å¦éœ€è¦æ•°é‡‡
    async determineWhetherToCollectData() {
      let res = await determineWhetherToCollectData({ managementNumber: '' })
      this.isGet = res.data;
    },
    // æ ¹æ®åŽç«¯ä¼ å‚更新页面数据   param => this.tableList[0].insProductResult
    getCurrentInsProduct(pId) {
@@ -2635,9 +2548,6 @@
    //     }
    //   }
    // },
    getUserInfo() {
      this.componentData.entity.userId = this.userId;
    },
    openAddCheck() {
      this.addCheck = true;
    },
@@ -2806,6 +2716,8 @@
            param: JSON.stringify(param),
            currentTable: this.currentTable,
            sampleId: this.currentSample.id,
            orderId: this.orderId,
            sonLaboratory: this.sonLaboratory
          }).then((res) => {
            if (res.code == 201) {
              this.$message.error("保存失败");
@@ -2936,7 +2848,6 @@
      this.param = {};
      this.changeType = 0;
      this.currentSample.insProduct.forEach((a, j) => {
        if (this.handleCasing(a.inspectionItem)) {
          this.param[a.id] = {
            insValue: [],
            comValue: [],
@@ -2945,7 +2856,6 @@
            equipName: [],
            insResult: null,
          };
        }
      });
      // é¡µé¢æ•°æ®å¤„理
      this.getTableLists();
@@ -3020,6 +2930,10 @@
};
</script>
<style scoped>
>>>.el-divider {
  margin: 0 !important;
}

.custom-table .el-table__header-wrapper th {
  background-color: #87ceeb;
  /* åªå¯¹å¸¦æœ‰my-custom-table类的表格生效 */
@@ -3048,11 +2962,11 @@
.title {
  height: 60px;
  line-height: 60px;
  padding: 0 16px;
}

.search {
  width: 100%;
  margin-bottom: 10px;
  background-color: #fff;
  border-radius: 3px;
}
@@ -3064,7 +2978,7 @@
}

.center {
  width: calc(100% - 40px);
  width: 100%;
  /* max-height: 580px; */
  background-color: #fff;
  border-radius: 3px;
@@ -3091,6 +3005,7 @@
.tables {
  table-layout: fixed;
  margin: 5px 5px 16px;
  border-collapse: collapse;
}

.tables td {

 vue.config.js

@@ -36,7 +36,7 @@
    proxy: {
      // detail: https://cli.vuejs.org/config/#devserver-proxy
      [process.env.VUE_APP_BASE_API]: {
        target: `http://192.168.0.170:8002`,
        target: `http://192.168.0.104:8002`,
        changeOrigin: true,
        pathRewrite: {
          ["^" + process.env.VUE_APP_BASE_API]: "",
@@ -59,6 +59,19 @@
        "@": resolve("src"),
      },
    },
    module: {
      rules: [
        {
          test: /\.worker\.js$/,
          use: {
            loader: "worker-loader",
            options: {
              inline: "fallback",
            },
          },
        },
      ],
    },
    plugins: [
      // http://doc.ruoyi.vip/ruoyi-vue/other/faq.html#使用gzip解压缩静态文件
      new CompressionPlugin({