super-page-runtime 2.3.17-sit4 → 2.3.18-tmp1

package/dist/lib/components/runtime/views/assemblys/chart/table/chart-table-util.js

@@ -0,0 +1,786 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pageHelperUtil = require("../../../../utils/page-helper-util.js");
+const eventUtil = require("../../../../utils/events/event-util.js");
+const chartUtil = require("../../../../utils/charts/chart-util.js");
+class ExpressionEvaluator {
+  /**
+   *
+   * @param pageContext 页面上下文
+   * @param conditions 条件集合
+   * @param data 数据对象，一般是行数据
+   * @returns
+   */
+  static evaluate(pageContext, conditions, data2) {
+    if (conditions && conditions.length > 0) {
+      const lastCondition = conditions[conditions.length - 1];
+      if (lastCondition.joinSign) {
+        lastCondition.joinSign = "";
+      }
+    }
+    const expressions = conditions.map((condition) => this.createExpression(pageContext, condition, data2));
+    const joinedExpression = expressions.join(" ");
+    return this.evaluateExpression(joinedExpression);
+  }
+  static createExpression(pageContext, condition, data2) {
+    const { propName, operator, propValue, leftBracket, rightBracket, joinSign, dataType } = condition;
+    if (!propName || propName === "") {
+      return "";
+    }
+    const value = pageHelperUtil.getValueFromVariable(pageContext.entity, propName, data2);
+    let expression2 = `${leftBracket} ${this.getComparisonExpression(value, condition, pageHelperUtil.getValueFromVariable(pageContext.entity, propValue, data2))} ${rightBracket}`;
+    if (joinSign) {
+      if (joinSign === "and" || joinSign === "AND") {
+        expression2 += "&&";
+      } else if (joinSign === "or" || joinSign === "OR") {
+        expression2 += "||";
+      }
+    }
+    return expression2.trim();
+  }
+  static getComparisonExpression(value, condition, propValue) {
+    const { dataType, variableIsNull } = condition;
+    let operator = condition.operator;
+    if (!operator) {
+      operator = "EQ";
+    }
+    let parsedValue = this.parseValue(value, dataType);
+    const parsedPropValue = this.parseValue(propValue, dataType);
+    if (parsedPropValue === void 0 || parsedPropValue === null) {
+      if (variableIsNull) {
+        if (parsedValue === void 0 || parsedValue === null) {
+          parsedValue = "null";
+        }
+        if ("null" === variableIsNull) {
+          return `${parsedValue} === null`;
+        } else if ("ignore" === variableIsNull) {
+          return "1=1";
+        } else if ("notequal" === variableIsNull) {
+          return "1!=1";
+        }
+      }
+    }
+    switch (operator) {
+      case "EQ":
+        return `${parsedValue} === ${parsedPropValue}`;
+      case "GT":
+        return `${parsedValue} > ${parsedPropValue}`;
+      case "LT":
+        return `${parsedValue} < ${parsedPropValue}`;
+      case "GET":
+        return `${parsedValue} >= ${parsedPropValue}`;
+      case "LET":
+        return `${parsedValue} <= ${parsedPropValue}`;
+      case "NET":
+        return `${parsedValue} !== ${parsedPropValue}`;
+      case "CONTAIN":
+        return `${parsedValue}.includes(${parsedPropValue})`;
+      case "NOT_CONTAIN":
+        return `!${parsedValue}.includes(${parsedPropValue})`;
+      case "IS_NULL":
+        return `${parsedValue} === null`;
+      case "IS_NOT_NULL":
+        return `${parsedValue} !== null`;
+      case "IN":
+        if (dataType === "TEXT") {
+          const parseValues = parsedPropValue.split(",");
+          return `${parseValues}.includes(${parsedValue})`;
+        }
+        return `[${parsedPropValue}].includes(${parsedValue})`;
+      default:
+        throw new Error(`比较符号不匹配: ${operator}`);
+    }
+  }
+  static changeDataType(dataType) {
+    let resultDataType = dataType;
+    if (dataType) {
+      if (dataType === "TEXT") {
+        resultDataType = "string";
+      } else if (dataType === "DATE" || dataType === "TIME") {
+        resultDataType = "date";
+      } else if (dataType === "DOUBLE" || dataType === "FLOAT" || dataType === "INTEGER" || dataType === "LONG") {
+        resultDataType = "number";
+      } else if (dataType === "BOOLEAN") {
+        return "boolean";
+      }
+    }
+    return resultDataType;
+  }
+  static parseValue(value, dataType) {
+    dataType = this.changeDataType(dataType);
+    if (value === null || value === void 0) {
+      return null;
+    }
+    switch (dataType) {
+      case "number":
+        return getNumberValue(value);
+      case "date":
+        return new Date(value).getTime();
+      case "string":
+        return `"${value}"`;
+      case "boolean":
+        return value === "true" || value === true || value === 1;
+      default:
+        return `"${value}"`;
+    }
+  }
+  static evaluateExpression(expression) {
+    try {
+      return eval(expression);
+    } catch (error) {
+      console.error("表达式错误:", expression, error);
+      return false;
+    }
+  }
+}
+function getNumberValue(value) {
+  if (isNumber(value)) {
+    return Number(value);
+  } else {
+    if (value && value.indexOf(",") > 0) {
+      const values = value.split(",");
+      const result = [];
+      for (let i = 0; i < values.length; i++) {
+        result.push(Number(values[i]));
+      }
+      return result;
+    }
+    return value;
+  }
+}
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+function getSummaryTitleColumn(configure) {
+  var _a;
+  const result = {};
+  if (((_a = configure.props.summaries) == null ? void 0 : _a.titleColumn) && configure.props.summaries.titleColumn.length > 0) {
+    configure.props.summaries.titleColumn.forEach((item) => {
+      result[item.prop] = item;
+    });
+  }
+  return result;
+}
+function getSummaryDataColumn(configure, type) {
+  var _a;
+  const result = {};
+  if (((_a = configure.props.summaries) == null ? void 0 : _a.dataColumn) && configure.props.summaries.dataColumn.length > 0) {
+    configure.props.summaries.dataColumn.forEach((item) => {
+      var _a2;
+      const columnConfigs = (_a2 = configure.items) == null ? void 0 : _a2.find((columnItem) => item.prop === columnItem.props.base.prop);
+      if (columnConfigs) {
+        if (type === "table" && columnConfigs.props.base.tableSummary) {
+          result[item.prop] = item;
+        } else if (type === "group" && columnConfigs.props.base.groupSummary) {
+          result[item.prop] = item;
+        }
+      }
+    });
+  }
+  return result;
+}
+function summaryStatistics(summaryColumn, data2, prop, pageContext) {
+  let sumsIndex = "";
+  const summaryMode = summaryColumn.summaryMode;
+  const values = data2.map((item) => Number(item[prop])).filter((value) => !Number.isNaN(value));
+  if (values.length > 0) {
+    if (summaryMode === "custom") {
+      const func = eventUtil.getCustomFunc(pageContext, summaryColumn.customFunc);
+      if (func) {
+        try {
+          const resultValue = func.apply(func, [{ data: data2, prop }]);
+          if (resultValue) {
+            sumsIndex = ` ${resultValue}`;
+          } else {
+            sumsIndex = " N/A";
+          }
+        } catch (error) {
+          console.error("自定义函数脚本错误:", data2, error);
+        }
+      } else {
+        sumsIndex = " N/A";
+      }
+    } else {
+      switch (summaryMode) {
+        case "sum":
+          sumsIndex = ` ${values.reduce((prev, curr) => prev + curr, 0)}`;
+          break;
+        case "avg":
+          sumsIndex = ` ${values.reduce((prev, curr) => prev + curr, 0) / values.length}`;
+          break;
+        case "min":
+          sumsIndex = ` ${Math.min(...values)}`;
+          break;
+        case "max":
+          sumsIndex = ` ${Math.max(...values)}`;
+          break;
+        default:
+          sumsIndex = " N/A";
+      }
+    }
+  } else {
+    sumsIndex = " N/A";
+  }
+  return sumsIndex;
+}
+function replacePlaceholders(template, data2) {
+  if (template) {
+    return template.replace(/\$\{row\.(\w+)\}/g, (match, p1) => {
+      return Object.prototype.hasOwnProperty.call(data2, p1) ? data2[p1] : "";
+    });
+  }
+}
+function getHeaderCellStyleUtil(data2, runtimeStyle, props) {
+  var _a;
+  const headerStyle = {};
+  if (data2.column.property) {
+    (_a = runtimeStyle.titleStyle) == null ? void 0 : _a.forEach((item) => {
+      if (item.field && item.field.includes(data2.column.property)) {
+        if (item.scopeFunc) {
+          const func = eventUtil.getCustomFunc(props.pageContext, item.scopeFunc);
+          if (func) {
+            try {
+              const funcResult = func.apply(func, [{ item, data: data2 }]);
+              if (funcResult !== false) {
+                copyStyle(headerStyle, item);
+              }
+            } catch (error) {
+              console.error("自定义函数脚本错误:", item, data2, error);
+            }
+          }
+        } else {
+          copyStyle(headerStyle, item);
+        }
+      }
+    });
+  }
+  const cellTitleStytle = getCellStyleUtil(data2, runtimeStyle.cellTitleStyle, props);
+  if (cellTitleStytle) {
+    Object.assign(headerStyle, cellTitleStytle);
+  }
+  return headerStyle;
+}
+function getRowStyleUtil(data2, groupSummaryDataRowIndex, props) {
+  const returnStyle = {};
+  if (props.configure.style.rowStyle) {
+    for (let i = 0; i < props.configure.style.rowStyle.length; i++) {
+      const rowStyle = props.configure.style.rowStyle[i];
+      if (rowStyle.scopeFunc) {
+        const func = eventUtil.getCustomFunc(props.pageContext, rowStyle.scopeFunc);
+        if (func) {
+          try {
+            const funcResult = func.apply(func, [{ data: data2 }]);
+            if (funcResult !== void 0 && funcResult !== null && funcResult !== false) {
+              copyStyle(returnStyle, rowStyle);
+            }
+          } catch (error) {
+            console.error("自定义函数脚本错误:", data2, error);
+          }
+        }
+      } else if (rowStyle.matchingCondition) {
+        const result = ExpressionEvaluator.evaluate(props.pageContext, rowStyle.matchingCondition, data2.row);
+        if (result || result === void 0) {
+          copyStyle(returnStyle, rowStyle);
+        }
+      } else {
+        copyStyle(returnStyle, rowStyle);
+      }
+    }
+  }
+  if (groupSummaryDataRowIndex && groupSummaryDataRowIndex.length > 0 && groupSummaryDataRowIndex.indexOf(data2.rowIndex) !== -1) {
+    const result = {};
+    if (props.configure.style.collectStyle && props.configure.style.collectStyle.length > 0) {
+      for (let i = 0; i < props.configure.style.collectStyle.length; i++) {
+        const collectStyle = props.configure.style.collectStyle[i];
+        copyStyle(result, collectStyle);
+      }
+    }
+    if (Object.keys(result).length === 0) {
+      result["background-color"] = "var(--el-table-row-hover-bg-color)";
+    }
+    return result;
+  }
+  return returnStyle;
+}
+function getCellStyleUtil(data2, cellStyles, props) {
+  const cellStyle = {};
+  if (cellStyles) {
+    for (let i = 0; i < cellStyles.length; i++) {
+      const columnsStyleSetting = cellStyles[i];
+      if (isSetStyle(columnsStyleSetting)) {
+        if (columnsStyleSetting.scopeFunc) {
+          const func = eventUtil.getCustomFunc(props.pageContext, columnsStyleSetting.scopeFunc);
+          if (func) {
+            try {
+              const funcResult = func.apply(func, [{ data: data2 }]);
+              if (funcResult !== false) {
+                copyStyle(cellStyle, columnsStyleSetting);
+              }
+            } catch (error) {
+              console.error("自定义函数脚本错误:", data2, error);
+            }
+          }
+        } else if (columnsStyleSetting.matchingCondition) {
+          const result = ExpressionEvaluator.evaluate(
+            props.pageContext,
+            columnsStyleSetting.matchingCondition,
+            data2.row
+          );
+          if (result || result === void 0) {
+            copyStyle(cellStyle, columnsStyleSetting);
+          }
+        } else {
+          copyStyle(cellStyle, columnsStyleSetting);
+        }
+      }
+    }
+  }
+  return cellStyle;
+}
+function isSetStyle(columnsStyleSetting) {
+  let customStyle;
+  if (columnsStyleSetting.customStyle) {
+    customStyle = JSON.parse(columnsStyleSetting.customStyle);
+  }
+  if (columnsStyleSetting.style && Object.keys(columnsStyleSetting.style).length > 0 || customStyle && Object.keys(customStyle).length > 0) {
+    return true;
+  }
+  return false;
+}
+function copyStyle(target, source) {
+  Object.assign(target, source.style);
+  if (source.customStyle) {
+    Object.assign(target, JSON.parse(source.customStyle));
+  }
+}
+function rowDataToColumn(data2, configure, sourceTableColumnsConfig) {
+  const groupByFields = configure.props.dataOrigin.groupField;
+  const titleColumns = configure.props.dataOrigin.rowToColumn.titleColumns;
+  const dataColumns = configure.props.dataOrigin.rowToColumn.dataColumns;
+  const result = [];
+  const groupedData = {};
+  if (groupByFields && groupByFields.length > 0) {
+    data2.forEach((item) => {
+      const key2 = groupByFields.map((field) => item[field]).join("|");
+      if (!groupedData[key2]) {
+        const group = {};
+        groupByFields.forEach((field) => group[field] = item[field]);
+        groupedData[key2] = group;
+        result.push(group);
+      }
+      dataColumns.forEach((valueField) => {
+        const columnNameParts = titleColumns.map((field) => item[field]);
+        const columnName = `${columnNameParts.join("")}${valueField}`;
+        groupedData[key2][columnName] = item[valueField];
+      });
+    });
+  } else {
+    const titleColProp = [];
+    data2.forEach((item) => {
+      titleColumns.forEach((titleColumn) => {
+        if (item[titleColumn]) {
+          titleColProp.push(item[titleColumn]);
+        }
+      });
+    });
+    dataColumns.forEach((dataColumn) => {
+      const rowData = {};
+      const sourceDataColumns = sourceTableColumnsConfig.find((column) => {
+        var _a, _b;
+        return ((_b = (_a = column.props) == null ? void 0 : _a.base) == null ? void 0 : _b.prop) === dataColumn;
+      });
+      if (sourceDataColumns) {
+        rowData.$GroupColumn = sourceDataColumns.props.base.name;
+      }
+      data2.forEach((item) => {
+        titleColumns.forEach((titleProp) => {
+          const prop = item[titleProp];
+          const value = item[dataColumn];
+          rowData[prop] = value;
+        });
+      });
+      result.push(rowData);
+    });
+  }
+  return result;
+}
+function colDataToRow(data2, configure) {
+  const groupByFields = configure.props.dataOrigin.groupField;
+  const titleColumns = configure.props.dataOrigin.columnToRow.titleColumns;
+  const dataColumns = configure.props.dataOrigin.columnToRow.dataColumns;
+  const transColumns = configure.props.dataOrigin.columnToRow.transColumns;
+  const dataColumnsMapping = configure.props.dataOrigin.columnToRow.dataColumnsMapping;
+  if (data2.length === 0) {
+    return data2;
+  }
+  const result = [];
+  const newData = groupBy(data2, groupByFields);
+  const dataColumnsConfig = dataColumns.reduce((max, current) => {
+    return current.columns.length > max.columns.length ? current : max;
+  }, dataColumns[0]);
+  const dataColumnsAndNewColumnMapping = dataColumns.reduce((acc, item) => {
+    item.columns.forEach((column) => {
+      acc[column] = item.prop;
+    });
+    return acc;
+  }, {});
+  newData.forEach((item) => {
+    dataColumnsConfig.columns.forEach((col) => {
+      const newColumnsProp = dataColumnsConfig.prop;
+      const dataRow = {};
+      groupByFields.forEach((field) => {
+        dataRow[field] = item[field];
+      });
+      dataRow[newColumnsProp] = item[col];
+      if (dataColumns.length > 1) {
+        const columnMapping = dataColumnsMapping.find((item2) => item2.props.includes(col));
+        if (columnMapping && columnMapping.props.length > 1) {
+          columnMapping.props.forEach((prop) => {
+            if (prop !== col && dataColumnsAndNewColumnMapping[prop]) {
+              dataRow[dataColumnsAndNewColumnMapping[prop]] = item[prop];
+            }
+          });
+        }
+      }
+      titleColumns.forEach((titleCol) => {
+        const sourceTitleRenameConfigs = transColumns.filter((transCol) => transCol.relatedTitle === titleCol.prop);
+        let rename = false;
+        if (sourceTitleRenameConfigs && sourceTitleRenameConfigs.length > 0) {
+          sourceTitleRenameConfigs.forEach((item2) => {
+            if (item2.columns.includes(col)) {
+              dataRow[titleCol.prop] = item2.label;
+              rename = true;
+              return;
+            }
+          });
+        }
+        if (!rename) {
+          dataRow[titleCol.prop] = col;
+        }
+      });
+      result.push(dataRow);
+    });
+  });
+  return result;
+}
+function getColumnToRowTableConfig(configure) {
+  const sourceConfig = configure.items;
+  const groupField = configure.props.dataOrigin.groupField;
+  const titleColumns = configure.props.dataOrigin.columnToRow.titleColumns;
+  const dataColumns = configure.props.dataOrigin.columnToRow.dataColumns;
+  const newTableColumns = [];
+  if (groupField && groupField.length > 0) {
+    groupField.forEach((field) => {
+      if (sourceConfig) {
+        const column = sourceConfig.find((item) => item.props.base.prop === field);
+        if (column) {
+          newTableColumns.push(column);
+        }
+      }
+    });
+  }
+  const newCols = [...titleColumns, ...dataColumns];
+  newCols.forEach((field) => {
+    if (sourceConfig) {
+      const column = sourceConfig.find((item) => item.props.base.prop === field);
+      if (column) {
+        newTableColumns.push(column);
+      } else {
+        newTableColumns.push({
+          uuid: (/* @__PURE__ */ new Date()).getTime(),
+          // 生成新的UUID
+          name: "",
+          props: {
+            base: {
+              prop: field.prop,
+              name: field.title,
+              sortable: true,
+              headerAlign: "center",
+              align: "center",
+              fixed: false,
+              visible: true,
+              dataType: "string"
+            },
+            format: {},
+            size: {
+              pc: {}
+            }
+          },
+          style: {},
+          componentIndex: 0,
+          // 根据实际情况设置
+          runtime: {
+            common: {
+              class: "",
+              style: {
+                pc_style: {},
+                pc_class: ""
+              }
+            }
+          }
+        });
+      }
+    }
+  });
+  return newTableColumns;
+}
+function groupBy(data2, groupFields) {
+  const grouped = {};
+  data2.forEach((item) => {
+    const key2 = groupFields.map((field) => item[field]).join("|");
+    if (!grouped[key2]) {
+      grouped[key2] = {
+        ...item,
+        // 复制所有字段
+        records: []
+        // 初始化记录数组
+      };
+      groupFields.forEach((field, index2) => {
+        grouped[key2][field] = item[field];
+      });
+    }
+    grouped[key2].records.push(item);
+  });
+  return Object.values(grouped).map((group) => ({
+    ...group,
+    // 复制所有分组信息
+    records: void 0
+    // 移除records字段，因为不需要展示
+  }));
+}
+function getIndexColumn() {
+  return {
+    props: {
+      base: {
+        name: "序号",
+        prop: "$index",
+        columnWidth: 80,
+        sortable: true,
+        visible: true,
+        displayOrder: 1,
+        alignTitle: "center",
+        alignContent: "center"
+      }
+    },
+    events: [],
+    style: {
+      titleFont: {},
+      contentFont: {},
+      width: {},
+      background: {},
+      tableCell: [{ type: "", model: "" }],
+      conentPadding: {},
+      tittlePadding: {},
+      border: {},
+      shadow: {},
+      tittleClass: ""
+    }
+  };
+}
+function getNewColumnConfig(prop, name, displayOrder, dataType) {
+  return {
+    uuid: (/* @__PURE__ */ new Date()).getTime(),
+    // 生成新的UUID
+    name: "",
+    props: {
+      base: {
+        prop,
+        name,
+        displayOrder,
+        // 更新显示顺序
+        sortable: true,
+        headerAlign: "center",
+        align: "center",
+        fixed: false,
+        visible: true,
+        dataType
+      },
+      format: {},
+      size: {
+        pc: {}
+      }
+    },
+    style: {},
+    componentIndex: 0,
+    // 根据实际情况设置
+    runtime: {
+      common: {
+        class: "",
+        style: {
+          pc_style: {},
+          pc_class: ""
+        }
+      }
+    }
+  };
+}
+function computeFormula(itemConfs, datas, entity) {
+  Object.keys(itemConfs).forEach((key) => {
+    const paramNames = pageHelperUtil.getParamNames(itemConfs[key]);
+    datas.forEach((data, index) => {
+      const totalValueMap = {};
+      for (const paramName of paramNames) {
+        if (paramName.startsWith("${min.")) {
+          totalValueMap[paramName] = chartUtil.getMinValue(datas, getFieldName(paramName));
+        } else if (paramName.startsWith("${max.")) {
+          totalValueMap[paramName] = chartUtil.getMaxValue(datas, getFieldName(paramName));
+        } else if (paramName.startsWith("${sum.")) {
+          totalValueMap[paramName] = chartUtil.getSumValue(datas, getFieldName(paramName));
+        } else if (paramName.startsWith("${avg.")) {
+          totalValueMap[paramName] = chartUtil.getAvgValue(datas, getFieldName(paramName));
+        } else if (paramName.startsWith("${add.")) {
+          const fieldName = getFieldName(paramName);
+          let currentRowValue = 0;
+          try {
+            currentRowValue = Number(data[fieldName]);
+            datas.slice(0, index).forEach((item) => {
+              currentRowValue += Number(item[fieldName]);
+            });
+          } catch (e) {
+            console.error("计算错误:", e);
+            currentRowValue = 0;
+          }
+          totalValueMap[paramName] = currentRowValue;
+        } else if (paramName.startsWith("${page.") || paramName.startsWith("${data.") || paramName.startsWith("${row.") || paramName.startsWith("${request.") || paramName.startsWith("${context.") || paramName.startsWith("${system.") || paramName.startsWith("${fixed.")) {
+          totalValueMap[paramName] = pageHelperUtil.getValueFromVariable(entity, paramName, data);
+        }
+      }
+      let expr = itemConfs[key];
+      Object.keys(totalValueMap).forEach((exprParam) => {
+        if (expr.indexOf(exprParam) > -1) {
+          expr = expr.replaceAll(exprParam, totalValueMap[exprParam]);
+        }
+      });
+      for (const paramName of paramNames) {
+        if (expr.indexOf(paramName) > -1) {
+          expr = expr.replaceAll(paramName, 0);
+        }
+      }
+      try {
+        data[key] = eval(expr);
+      } catch (e) {
+        console.error(itemConfs[key] + " 计算错误, 替换后表达式为：" + expr, e);
+        data[key] = 0;
+      }
+    });
+  });
+}
+function getFieldName(paramName) {
+  return paramName.substring(6, paramName.length - 1);
+}
+function formatColContent(row, format, column, pageContext, configure) {
+  const value = row[column.props.base.prop];
+  switch (format.type) {
+    case "number":
+      return formatNumber(value, format);
+    case "currency":
+      return formatCurrency(value, format);
+    case "percent":
+      return formatPercent(value, format);
+    case "custom":
+      return formatCustomFunc(row, format, column, pageContext, configure);
+    default:
+      return value;
+  }
+}
+function formatNumber(value, format) {
+  let formattedValue = value;
+  if (!formattedValue) {
+    formattedValue = 0;
+  }
+  if (format.scientific) {
+    formattedValue = Number(value).toExponential(format.scientificNum);
+  }
+  if (format.decimalDigit) {
+    formattedValue = Number(value).toFixed(format.decimalDigit);
+  }
+  if (format.thousandsSeparator) {
+    formattedValue = formattedValue.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  }
+  if (format.symbol) {
+    formattedValue = `${format.symbol} ${formattedValue}`;
+  }
+  return formattedValue;
+}
+function formatCurrency(value, format) {
+  let formattedValue = value;
+  if (!formattedValue) {
+    formattedValue = 0;
+  }
+  if (format.decimalDigit) {
+    formattedValue = Number(value).toFixed(format.decimalDigit);
+  }
+  if (format.symbol) {
+    formattedValue = `${format.symbol} ${formattedValue}`;
+  }
+  return formattedValue;
+}
+function formatPercent(value, format) {
+  let formattedValue = value;
+  if (!formattedValue) {
+    formattedValue = 0;
+  }
+  if (format.decimalDigit) {
+    formattedValue = Number(value).toFixed(format.decimalDigit);
+  }
+  return formattedValue + " %";
+}
+function formatCustomFunc(row, format, column, pageContext, configure) {
+  const func = eventUtil.getCustomFunc(pageContext, format.customFunc);
+  if (func) {
+    try {
+      const resultValue = func.apply(func, [
+        {
+          pageContext,
+          configureObj: configure,
+          row,
+          prop: column.props.base.prop
+        }
+      ]);
+      return resultValue;
+    } catch (error) {
+      console.error("自定义函数脚本错误:", row, error);
+    }
+    return "";
+  }
+}
+function mergeRowByProperty(row, column, rowIndex, property, data2) {
+  const currentValue = row[property];
+  let spanCount = 1;
+  let isFirstOccurrence = true;
+  for (let i = rowIndex - 1; i >= 0; i--) {
+    if (data2[i][property] === currentValue) {
+      isFirstOccurrence = false;
+      break;
+    } else {
+      break;
+    }
+  }
+  if (!isFirstOccurrence) {
+    return [0, 0];
+  }
+  for (let i = rowIndex + 1; i < data2.length; i++) {
+    if (data2[i][property] === currentValue) {
+      spanCount++;
+    } else {
+      break;
+    }
+  }
+  return [spanCount, 1];
+}
+exports.ExpressionEvaluator = ExpressionEvaluator;
+exports.colDataToRow = colDataToRow;
+exports.computeFormula = computeFormula;
+exports.formatColContent = formatColContent;
+exports.getCellStyleUtil = getCellStyleUtil;
+exports.getColumnToRowTableConfig = getColumnToRowTableConfig;
+exports.getHeaderCellStyleUtil = getHeaderCellStyleUtil;
+exports.getIndexColumn = getIndexColumn;
+exports.getNewColumnConfig = getNewColumnConfig;
+exports.getRowStyleUtil = getRowStyleUtil;
+exports.getSummaryDataColumn = getSummaryDataColumn;
+exports.getSummaryTitleColumn = getSummaryTitleColumn;
+exports.mergeRowByProperty = mergeRowByProperty;
+exports.replacePlaceholders = replacePlaceholders;
+exports.rowDataToColumn = rowDataToColumn;
+exports.summaryStatistics = summaryStatistics;