super-page-runtime 2.2.29-tmp1 → 2.2.29-tmp2

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

@@ -2,348 +2,694 @@ import { getParamNames, getValueFromVariable } from "../../../../utils/page-help
 import { getCustomFunc } from "../../../../utils/events/event-util.js";
 import { getMinValue, getMaxValue, getSumValue, getAvgValue } from "../../../../utils/charts/chart-util.js";
 class ExpressionEvaluator {
-  static evaluate(e, t, o) {
-    const r = t.map((t2) => this.createExpression(e, t2, o)).join(" ");
-    return this.evaluateExpression(r);
-  }
-  static createExpression(e, t, o) {
-    const { propName: r, operator: a, propValue: n, leftBracket: s, rightBracket: l, joinSign: i, dataType: c } = t;
-    if (!r || "" === r) return "";
-    const u = getValueFromVariable(e.entity, r, o);
-    let p = `${s} ${this.getComparisonExpression(u, a, getValueFromVariable(e.entity, n, o), c)} ${l}`;
-    return i && ("and" === i || "AND" === i ? p += "&&" : "or" !== i && "OR" !== i || (p += "||")), p.trim();
-  }
-  static getComparisonExpression(e, t, o, r) {
-    t || (t = "EQ");
-    const a = this.parseValue(e, r), n = this.parseValue(o, r);
-    switch (t) {
+  static evaluate(pageContext, conditions, data2) {
+    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 = getValueFromVariable(pageContext.entity, propName, data2);
+    let expression2 = `${leftBracket} ${this.getComparisonExpression(value, operator, getValueFromVariable(pageContext.entity, propValue, data2), dataType)} ${rightBracket}`;
+    if (joinSign) {
+      if (joinSign === "and" || joinSign === "AND") {
+        expression2 += "&&";
+      } else if (joinSign === "or" || joinSign === "OR") {
+        expression2 += "||";
+      }
+    }
+    return expression2.trim();
+  }
+  static getComparisonExpression(value, operator, propValue, dataType) {
+    if (!operator) {
+      operator = "EQ";
+    }
+    const parsedValue = this.parseValue(value, dataType);
+    const parsedPropValue = this.parseValue(propValue, dataType);
+    switch (operator) {
       case "EQ":
-        return `${a} === ${n}`;
+        return `${parsedValue} === ${parsedPropValue}`;
       case "GT":
-        return `${a} > ${n}`;
+        return `${parsedValue} > ${parsedPropValue}`;
       case "LT":
-        return `${a} < ${n}`;
+        return `${parsedValue} < ${parsedPropValue}`;
       case "GET":
-        return `${a} >= ${n}`;
+        return `${parsedValue} >= ${parsedPropValue}`;
       case "LET":
-        return `${a} <= ${n}`;
+        return `${parsedValue} <= ${parsedPropValue}`;
       case "NET":
-        return `${a} !== ${n}`;
+        return `${parsedValue} !== ${parsedPropValue}`;
       case "CONTAIN":
-        return `${a}.includes(${n})`;
+        return `${parsedValue}.includes(${parsedPropValue})`;
       case "NOT_CONTAIN":
-        return `!${a}.includes(${n})`;
+        return `!${parsedValue}.includes(${parsedPropValue})`;
       case "IS_NULL":
-        return `${a} === null`;
+        return `${parsedValue} === null`;
       case "IS_NOT_NULL":
-        return `${a} !== null`;
+        return `${parsedValue} !== null`;
       default:
-        throw new Error(`比较符号不匹配: ${t}`);
+        throw new Error(`比较符号不匹配: ${operator}`);
     }
   }
-  static changeDataType(e) {
-    let t = e;
-    return e && ("TEXT" === e ? t = "string" : "DATE" === e || "TIME" === e ? t = "date" : "DOUBLE" !== e && "FLOAT" !== e && "INTEGER" !== e && "LONG" !== e && "BOOLEAN" !== e || (t = "number")), t;
+  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" || dataType === "BOOLEAN") {
+        resultDataType = "number";
+      }
+    }
+    return resultDataType;
   }
-  static parseValue(e, t) {
-    switch (t = this.changeDataType(t)) {
+  static parseValue(value, dataType) {
+    dataType = this.changeDataType(dataType);
+    switch (dataType) {
       case "number":
-        return Number(e);
+        return Number(value);
       case "date":
-        return new Date(e).getTime();
+        return new Date(value).getTime();
       case "string":
-        return `"${e}"`;
+        return `"${value}"`;
       default:
-        throw new Error(`数据类型解析错误: ${t}`);
+        throw new Error(`数据类型解析错误: ${dataType}`);
     }
   }
   static evaluateExpression(expression) {
     try {
       return eval(expression);
-    } catch (e) {
-      return console.error("表达式错误:", expression, e), false;
+    } catch (error) {
+      console.error("表达式错误:", expression, error);
+      return false;
     }
   }
 }
-function getSummaryTitleColumn(e) {
+function getSummaryTitleColumn(configure) {
   var _a;
-  const t = {};
-  return ((_a = e.props.summaries) == null ? void 0 : _a.titleColumn) && e.props.summaries.titleColumn.length > 0 && e.props.summaries.titleColumn.forEach((e2) => {
-    t[e2.prop] = e2;
-  }), t;
+  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(e, t) {
+function getSummaryDataColumn(configure, type) {
   var _a;
-  const o = {};
-  return ((_a = e.props.summaries) == null ? void 0 : _a.dataColumn) && e.props.summaries.dataColumn.length > 0 && e.props.summaries.dataColumn.forEach((r) => {
-    var _a2;
-    const a = (_a2 = e.items) == null ? void 0 : _a2.find((e2) => r.prop === e2.props.base.prop);
-    a && ("table" === t && a.props.base.tableSummary || "group" === t && a.props.base.groupSummary) && (o[r.prop] = r);
-  }), o;
+  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(e, t, o, r) {
-  let a = "";
-  const n = e.summaryMode, s = t.map((e2) => Number(e2[o])).filter((e2) => !Number.isNaN(e2));
-  if (s.length > 0) if ("custom" === n) {
-    const n2 = getCustomFunc(r, e.customFunc);
-    if (n2) try {
-      const e2 = n2.apply(n2, [{ data: t, prop: o }]);
-      a = e2 ? ` ${e2}` : " N/A";
-    } catch (e2) {
-      console.error("自定义函数脚本错误:", t, e2);
+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 = 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 a = " N/A";
-  } else switch (n) {
-    case "sum":
-      a = ` ${s.reduce((e2, t2) => e2 + t2, 0)}`;
-      break;
-    case "avg":
-      a = " " + s.reduce((e2, t2) => e2 + t2, 0) / s.length;
-      break;
-    case "min":
-      a = ` ${Math.min(...s)}`;
-      break;
-    case "max":
-      a = ` ${Math.max(...s)}`;
-      break;
-    default:
-      a = " N/A";
+  } else {
+    sumsIndex = " N/A";
   }
-  else a = " N/A";
-  return a;
+  return sumsIndex;
 }
-function replacePlaceholders(e, t) {
-  if (e) return e.replace(/\$\{row\.(\w+)\}/g, (e2, o) => Object.prototype.hasOwnProperty.call(t, o) ? t[o] : "");
+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(e, t, o) {
+function getHeaderCellStyleUtil(data2, runtimeStyle, props) {
   var _a;
-  const r = {};
-  e.column.property && ((_a = t.titleStyle) == null ? void 0 : _a.forEach((t2) => {
-    if (t2.field && t2.field.includes(e.column.property)) if (t2.scopeFunc) {
-      const a2 = getCustomFunc(o.pageContext, t2.scopeFunc);
-      if (a2) try {
-        false !== a2.apply(a2, [{ item: t2, data: e }]) && copyStyle(r, t2);
-      } catch (o2) {
-        console.error("自定义函数脚本错误:", t2, e, o2);
+  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 = 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);
+        }
       }
-    } else copyStyle(r, t2);
-  }));
-  const a = getCellStyleUtil(e, t.cellTitleStyle, o);
-  return a && Object.assign(r, a), r;
+    });
+  }
+  const cellTitleStytle = getCellStyleUtil(data2, runtimeStyle.cellTitleStyle, props);
+  if (cellTitleStytle) {
+    Object.assign(headerStyle, cellTitleStytle);
+  }
+  return headerStyle;
 }
-function getRowStyleUtil(e, t, o) {
-  const r = {};
-  if (o.configure.style.rowStyle) for (let t2 = 0; t2 < o.configure.style.rowStyle.length; t2++) {
-    const a = o.configure.style.rowStyle[t2];
-    if (a.scopeFunc) {
-      const t3 = getCustomFunc(o.pageContext, a.scopeFunc);
-      if (t3) try {
-        const o2 = t3.apply(t3, [{ data: e }]);
-        null != o2 && false !== o2 && copyStyle(r, a);
-      } catch (t4) {
-        console.error("自定义函数脚本错误:", e, t4);
+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 = 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);
       }
-    } else if (a.matchingCondition) {
-      const t3 = ExpressionEvaluator.evaluate(o.pageContext, a.matchingCondition, e.row);
-      (t3 || void 0 === t3) && copyStyle(r, a);
-    } else copyStyle(r, a);
-  }
-  if (t && t.length > 0 && -1 !== t.indexOf(e.rowIndex)) {
-    const e2 = {};
-    if (o.configure.style.collectStyle && o.configure.style.collectStyle.length > 0) for (let t2 = 0; t2 < o.configure.style.collectStyle.length; t2++) {
-      copyStyle(e2, o.configure.style.collectStyle[t2]);
     }
-    return 0 === Object.keys(e2).length && (e2["background-color"] = "var(--el-table-row-hover-bg-color)"), e2;
+    if (Object.keys(result).length === 0) {
+      result["background-color"] = "var(--el-table-row-hover-bg-color)";
+    }
+    return result;
   }
-  return r;
+  return returnStyle;
 }
-function getCellStyleUtil(e, t, o) {
-  const r = {};
-  if (t) for (let a = 0; a < t.length; a++) {
-    const n = t[a];
-    if (isSetStyle(n)) if (n.scopeFunc) {
-      const t2 = getCustomFunc(o.pageContext, n.scopeFunc);
-      if (t2) try {
-        false !== t2.apply(t2, [{ data: e }]) && copyStyle(r, n);
-      } catch (t3) {
-        console.error("自定义函数脚本错误:", e, t3);
+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 = 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);
+        }
       }
-    } else if (n.matchingCondition) {
-      const t2 = ExpressionEvaluator.evaluate(o.pageContext, n.matchingCondition, e.row);
-      (t2 || void 0 === t2) && copyStyle(r, n);
-    } else copyStyle(r, n);
+    }
   }
-  return r;
+  return cellStyle;
 }
-function isSetStyle(e) {
-  let t;
-  return e.customStyle && (t = JSON.parse(e.customStyle)), !!(e.style && Object.keys(e.style).length > 0 || t && Object.keys(t).length > 0);
+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(e, t) {
-  Object.assign(e, t.style), t.customStyle && Object.assign(e, JSON.parse(t.customStyle));
+function copyStyle(target, source) {
+  Object.assign(target, source.style);
+  if (source.customStyle) {
+    Object.assign(target, JSON.parse(source.customStyle));
+  }
 }
-function rowDataToColumn(e, t, o) {
-  const r = t.props.dataOrigin.groupField, a = t.props.dataOrigin.rowToColumn.titleColumns, n = t.props.dataOrigin.rowToColumn.dataColumns, s = [], l = {};
-  if (r && r.length > 0) e.forEach((e2) => {
-    const t2 = r.map((t3) => e2[t3]).join("|");
-    if (!l[t2]) {
-      const o2 = {};
-      r.forEach((t3) => o2[t3] = e2[t3]), l[t2] = o2, s.push(o2);
-    }
-    n.forEach((o2) => {
-      const r2 = `${a.map((t3) => e2[t3]).join("")}${o2}`;
-      l[t2][r2] = e2[o2];
-    });
-  });
-  else {
-    const t2 = [];
-    e.forEach((e2) => {
-      a.forEach((o2) => {
-        e2[o2] && t2.push(e2[o2]);
+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];
       });
-    }), n.forEach((t3) => {
-      const r2 = {}, n2 = o.find((e2) => {
-        var _a, _b;
-        return ((_b = (_a = e2.props) == null ? void 0 : _a.base) == null ? void 0 : _b.prop) === t3;
+    });
+  } else {
+    const titleColProp = [];
+    data2.forEach((item) => {
+      titleColumns.forEach((titleColumn) => {
+        if (item[titleColumn]) {
+          titleColProp.push(item[titleColumn]);
+        }
       });
-      n2 && (r2.$GroupColumn = n2.props.base.name), e.forEach((e2) => {
-        a.forEach((o2) => {
-          const a2 = e2[o2], n3 = e2[t3];
-          r2[a2] = n3;
+    });
+    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;
         });
-      }), s.push(r2);
+      });
+      result.push(rowData);
     });
   }
-  return s;
+  return result;
 }
-function colDataToRow(e, t) {
-  const o = t.props.dataOrigin.groupField, r = t.props.dataOrigin.columnToRow.titleColumns, a = t.props.dataOrigin.columnToRow.dataColumns, n = t.props.dataOrigin.columnToRow.transColumns, s = t.props.dataOrigin.columnToRow.dataColumnsMapping;
-  if (0 === e.length) return e;
-  const l = [], i = groupBy(e, o), c = a.reduce((e2, t2) => t2.columns.length > e2.columns.length ? t2 : e2, a[0]), u = a.reduce((e2, t2) => (t2.columns.forEach((o2) => {
-    e2[o2] = t2.prop;
-  }), e2), {});
-  return i.forEach((e2) => {
-    c.columns.forEach((t2) => {
-      const i2 = c.prop, p = {};
-      if (o.forEach((t3) => {
-        p[t3] = e2[t3];
-      }), p[i2] = e2[t2], a.length > 1) {
-        const o2 = s.find((e3) => e3.props.includes(t2));
-        o2 && o2.props.length > 1 && o2.props.forEach((o3) => {
-          o3 !== t2 && u[o3] && (p[u[o3]] = e2[o3]);
-        });
+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];
+            }
+          });
+        }
       }
-      r.forEach((e3) => {
-        const o2 = n.filter((t3) => t3.relatedTitle === e3.prop);
-        let r2 = false;
-        o2 && o2.length > 0 && o2.forEach((o3) => {
-          if (o3.columns.includes(t2)) return p[e3.prop] = o3.label, void (r2 = true);
-        }), r2 || (p[e3.prop] = t2);
-      }), l.push(p);
+      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);
     });
-  }), l;
+  });
+  return result;
 }
-function getColumnToRowTableConfig(e) {
-  const t = e.items, o = e.props.dataOrigin.groupField, r = e.props.dataOrigin.columnToRow.titleColumns, a = e.props.dataOrigin.columnToRow.dataColumns, n = [];
-  o && o.length > 0 && o.forEach((e2) => {
-    if (t) {
-      const o2 = t.find((t2) => t2.props.base.prop === e2);
-      o2 && n.push(o2);
+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 [...r, ...a].forEach((e2) => {
-    if (t) {
-      const o2 = t.find((t2) => t2.props.base.prop === e2);
-      o2 ? n.push(o2) : n.push({ uuid: (/* @__PURE__ */ new Date()).getTime(), name: "", props: { base: { prop: e2.prop, name: e2.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: "" } } } });
-    }
-  }), n;
+  return newTableColumns;
 }
-function groupBy(e, t) {
-  const o = {};
-  return e.forEach((e2) => {
-    const r = t.map((t2) => e2[t2]).join("|");
-    o[r] || (o[r] = { ...e2, records: [] }, t.forEach((t2, a) => {
-      o[r][t2] = e2[t2];
-    })), o[r].records.push(e2);
-  }), Object.values(o).map((e2) => ({ ...e2, records: void 0 }));
+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: "" } };
+  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(e, t, o, r) {
-  return { uuid: (/* @__PURE__ */ new Date()).getTime(), name: "", props: { base: { prop: e, name: t, displayOrder: o, sortable: true, headerAlign: "center", align: "center", fixed: false, visible: true, dataType: r }, format: {}, size: { pc: {} } }, style: {}, componentIndex: 0, runtime: { common: { class: "", style: { pc_style: {}, pc_class: "" } } } };
+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 = getParamNames(itemConfs[key]);
     datas.forEach((data, index) => {
       const totalValueMap = {};
-      for (const e of paramNames) if (e.startsWith("${min.")) totalValueMap[e] = getMinValue(datas, getFieldName(e));
-      else if (e.startsWith("${max.")) totalValueMap[e] = getMaxValue(datas, getFieldName(e));
-      else if (e.startsWith("${sum.")) totalValueMap[e] = getSumValue(datas, getFieldName(e));
-      else if (e.startsWith("${avg.")) totalValueMap[e] = getAvgValue(datas, getFieldName(e));
-      else if (e.startsWith("${add.")) {
-        const t = getFieldName(e);
-        let o = 0;
-        try {
-          o = Number(data[t]), datas.slice(0, index).forEach((e2) => {
-            o += Number(e2[t]);
-          });
-        } catch (e2) {
-          console.error("计算错误:", e2), o = 0;
+      for (const paramName of paramNames) {
+        if (paramName.startsWith("${min.")) {
+          totalValueMap[paramName] = getMinValue(datas, getFieldName(paramName));
+        } else if (paramName.startsWith("${max.")) {
+          totalValueMap[paramName] = getMaxValue(datas, getFieldName(paramName));
+        } else if (paramName.startsWith("${sum.")) {
+          totalValueMap[paramName] = getSumValue(datas, getFieldName(paramName));
+        } else if (paramName.startsWith("${avg.")) {
+          totalValueMap[paramName] = 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] = getValueFromVariable(entity, paramName, data);
         }
-        totalValueMap[e] = o;
-      } else (e.startsWith("${page.") || e.startsWith("${data.") || e.startsWith("${row.") || e.startsWith("${request.") || e.startsWith("${context.") || e.startsWith("${system.") || e.startsWith("${fixed.")) && (totalValueMap[e] = getValueFromVariable(entity, e, data));
+      }
       let expr = itemConfs[key];
-      Object.keys(totalValueMap).forEach((e) => {
-        expr.indexOf(e) > -1 && (expr = expr.replaceAll(e, totalValueMap[e]));
+      Object.keys(totalValueMap).forEach((exprParam) => {
+        if (expr.indexOf(exprParam) > -1) {
+          expr = expr.replaceAll(exprParam, totalValueMap[exprParam]);
+        }
       });
-      for (const e of paramNames) expr.indexOf(e) > -1 && (expr = expr.replaceAll(e, 0));
+      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;
+        console.error(itemConfs[key] + " 计算错误, 替换后表达式为：" + expr, e);
+        data[key] = 0;
       }
     });
   });
 }
-function getFieldName(e) {
-  return e.substring(6, e.length - 1);
+function getFieldName(paramName) {
+  return paramName.substring(6, paramName.length - 1);
 }
-function formatColContent(e, t, o, r, a) {
-  const n = e[o.props.base.prop];
-  switch (t.type) {
+function formatColContent(row, format, column, pageContext, configure) {
+  const value = row[column.props.base.prop];
+  switch (format.type) {
     case "number":
-      return formatNumber(n, t);
+      return formatNumber(value, format);
     case "currency":
-      return formatCurrency(n, t);
+      return formatCurrency(value, format);
     case "percent":
-      return formatPercent(n, t);
+      return formatPercent(value, format);
     case "custom":
-      return formatCustomFunc(e, t, o, r, a);
+      return formatCustomFunc(row, format, column, pageContext, configure);
     default:
-      return n;
+      return value;
   }
 }
-function formatNumber(e, t) {
-  let o = e;
-  return o || (o = 0), t.scientific && (o = Number(e).toExponential(t.scientificNum)), t.decimalDigit && (o = Number(e).toFixed(t.decimalDigit)), t.thousandsSeparator && (o = o.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",")), t.symbol && (o = `${t.symbol} ${o}`), o;
+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(e, t) {
-  let o = e;
-  return o || (o = 0), t.decimalDigit && (o = Number(e).toFixed(t.decimalDigit)), t.symbol && (o = `${t.symbol} ${o}`), o;
+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(e, t) {
-  let o = e;
-  return o || (o = 0), t.decimalDigit && (o = Number(e).toFixed(t.decimalDigit)), o + " %";
+function formatPercent(value, format) {
+  let formattedValue = value;
+  if (!formattedValue) {
+    formattedValue = 0;
+  }
+  if (format.decimalDigit) {
+    formattedValue = Number(value).toFixed(format.decimalDigit);
+  }
+  return formattedValue + " %";
 }
-function formatCustomFunc(e, t, o, r, a) {
-  const n = getCustomFunc(r, t.customFunc);
-  if (n) {
+function formatCustomFunc(row, format, column, pageContext, configure) {
+  const func = getCustomFunc(pageContext, format.customFunc);
+  if (func) {
     try {
-      return n.apply(n, [{ pageContext: r, configureObj: a, row: e, prop: o.props.base.prop }]);
-    } catch (t2) {
-      console.error("自定义函数脚本错误:", e, t2);
+      const resultValue = func.apply(func, [
+        {
+          pageContext,
+          configureObj: configure,
+          row,
+          prop: column.props.base.prop
+        }
+      ]);
+      return resultValue;
+    } catch (error) {
+      console.error("自定义函数脚本错误:", row, error);
     }
     return "";
   }