super-page-runtime 2.1.48 → 2.1.50

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

@@ -0,0 +1,480 @@
+import { getValueFromVariable } from "../../../../utils/page-helper-util.js";
+import { getCustomFunc } from "../../../../utils/events/event-util.js";
+class ExpressionEvaluator {
+  static evaluate(pageContext, conditions, data) {
+    const expressions = conditions.map(
+      (condition) => this.createExpression(pageContext, condition, data)
+    );
+    const joinedExpression = expressions.join(" ");
+    return this.evaluateExpression(joinedExpression);
+  }
+  static createExpression(pageContext, condition, data) {
+    const { propName, operator, propValue, leftBracket, rightBracket, joinSign, dataType } = condition;
+    if (!propName || propName === "") {
+      return "";
+    }
+    let value = getValueFromVariable(pageContext.entity, propName, data);
+    let expression2 = `${leftBracket} ${this.getComparisonExpression(value, operator, getValueFromVariable(pageContext.entity, propValue, data), 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 `${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`;
+      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" || dataType === "BOOLEAN") {
+        resultDataType = "number";
+      }
+    }
+    return resultDataType;
+  }
+  static parseValue(value, dataType) {
+    dataType = this.changeDataType(dataType);
+    switch (dataType) {
+      case "number":
+        return Number(value);
+      case "date":
+        return new Date(value).getTime();
+      case "string":
+        return `"${value}"`;
+      default:
+        throw new Error(`数据类型解析错误: ${dataType}`);
+    }
+  }
+  static evaluateExpression(expression) {
+    try {
+      return eval(expression);
+    } catch (error) {
+      console.error("表达式错误:", expression, error);
+      return false;
+    }
+  }
+}
+function getSummaryTitleColumn(configure) {
+  const result = {};
+  if (configure.props.summaries.titleColumn && configure.props.summaries.titleColumn.length > 0) {
+    configure.props.summaries.titleColumn.forEach((item) => {
+      result[item.prop] = item;
+    });
+  }
+  return result;
+}
+function getSummaryDataColumn(configure, type) {
+  const result = {};
+  if (configure.props.summaries.dataColumn && configure.props.summaries.dataColumn.length > 0) {
+    configure.props.summaries.dataColumn.forEach((item) => {
+      var _a;
+      const columnConfigs = (_a = configure.items) == null ? void 0 : _a.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, data, prop, pageContext) {
+  let sumsIndex = "";
+  const summaryMode = summaryColumn.summaryMode;
+  const values = data.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) {
+        const resultValue = func.apply(func, [{ data, prop }]);
+        if (resultValue) {
+          sumsIndex = ` ${resultValue}`;
+        } else {
+          sumsIndex = " N/A";
+        }
+      } 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, data) {
+  if (template) {
+    return template.replace(/\$\{row\.(\w+)\}/g, (match, p1) => {
+      return Object.prototype.hasOwnProperty.call(data, p1) ? data[p1] : "";
+    });
+  }
+}
+function getHeaderCellStyleUtil(data, runtimeStyle, props) {
+  var _a;
+  const headerStyle = {};
+  if (data.column.property) {
+    (_a = runtimeStyle.titleStyle) == null ? void 0 : _a.forEach((item) => {
+      if (item.field && item.field.includes(data.column.property)) {
+        if (item.scopeFunc) {
+          const func = getCustomFunc(props.pageContext, item.scopeFunc);
+          if (func) {
+            const funcResult = func.apply(func, [{ item, data }]);
+            if (funcResult !== false) {
+              copyStyle(headerStyle, item);
+            }
+          }
+        } else {
+          copyStyle(headerStyle, item);
+        }
+      }
+    });
+  }
+  const cellTitleStytle = getCellStyleUtil(data, runtimeStyle.cellTitleStyle, props);
+  if (cellTitleStytle) {
+    Object.assign(headerStyle, cellTitleStytle);
+  }
+  return headerStyle;
+}
+function getRowStyleUtil(data, 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];
+      debugger;
+      if (rowStyle.scopeFunc) {
+        const func = getCustomFunc(props.pageContext, rowStyle.scopeFunc);
+        if (func) {
+          const funcResult = func.apply(func, [{ data }]);
+          if (funcResult !== void 0 && funcResult !== null && funcResult !== false) {
+            copyStyle(returnStyle, rowStyle);
+          }
+        }
+      } else if (rowStyle.matchingCondition) {
+        const result = ExpressionEvaluator.evaluate(
+          props.pageContext,
+          rowStyle.matchingCondition,
+          data.row
+        );
+        if (result || result === void 0) {
+          copyStyle(returnStyle, rowStyle);
+        }
+      } else {
+        copyStyle(returnStyle, rowStyle);
+      }
+    }
+  }
+  if (groupSummaryDataRowIndex && groupSummaryDataRowIndex.length > 0 && groupSummaryDataRowIndex.indexOf(data.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(data, cellStyles, props) {
+  const cellStyle = {};
+  if (cellStyles) {
+    for (let i = 0; i < cellStyles.length; i++) {
+      const columnsStyleSetting = cellStyles[i];
+      if (columnsStyleSetting.scopeFunc) {
+        const func = getCustomFunc(props.pageContext, columnsStyleSetting.scopeFunc);
+        if (func) {
+          const funcResult = func.apply(func, [{ data }]);
+          if (funcResult !== false) {
+            copyStyle(cellStyle, columnsStyleSetting);
+          }
+        }
+      } else if (columnsStyleSetting.matchingCondition) {
+        const result = ExpressionEvaluator.evaluate(
+          props.pageContext,
+          columnsStyleSetting.matchingCondition,
+          data.row
+        );
+        if (result || result === void 0) {
+          copyStyle(cellStyle, columnsStyleSetting);
+        }
+      } else {
+        copyStyle(cellStyle, columnsStyleSetting);
+      }
+    }
+  }
+  return cellStyle;
+}
+function copyStyle(target, source) {
+  Object.assign(target, source.style);
+  if (source.customStyle) {
+    Object.assign(target, JSON.parse(source.customStyle));
+  }
+}
+function rowDataToColumn(data, configure) {
+  const groupByFields = configure.props.dataOrigin.groupField;
+  const titleColumns = configure.props.dataOrigin.rowToColumn.titleColumns;
+  const dataColumns = configure.props.dataOrigin.rowToColumn.dataColumns;
+  const result = [];
+  const groupedData = {};
+  data.forEach((item) => {
+    const key = groupByFields.map((field) => item[field]).join("|");
+    if (!groupedData[key]) {
+      const group = {};
+      groupByFields.forEach((field) => group[field] = item[field]);
+      groupedData[key] = group;
+      result.push(group);
+    }
+    dataColumns.forEach((valueField) => {
+      const columnNameParts = titleColumns.map((field) => item[field]);
+      const columnName = `${columnNameParts.join("")}${valueField}`;
+      groupedData[key][columnName] = item[valueField];
+    });
+  });
+  return result;
+}
+function colDataToRow(data, 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 (data.length === 0) {
+    return data;
+  }
+  const result = [];
+  const newData = groupBy(data, 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 = [];
+  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(data, groupFields) {
+  const grouped = {};
+  data.forEach((item) => {
+    const key = groupFields.map((field) => item[field]).join("|");
+    if (!grouped[key]) {
+      grouped[key] = {
+        ...item,
+        // 复制所有字段
+        records: []
+        // 初始化记录数组
+      };
+      groupFields.forEach((field, index) => {
+        grouped[key][field] = item[field];
+      });
+    }
+    grouped[key].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: ""
+    }
+  };
+}
+export {
+  ExpressionEvaluator,
+  colDataToRow,
+  getCellStyleUtil,
+  getColumnToRowTableConfig,
+  getHeaderCellStyleUtil,
+  getIndexColumn,
+  getRowStyleUtil,
+  getSummaryDataColumn,
+  getSummaryTitleColumn,
+  replacePlaceholders,
+  rowDataToColumn,
+  summaryStatistics
+};

package/dist/es/components/runtime/views/assemblys/chart/table/group-column-item.vue.js

@@ -0,0 +1,44 @@
+import { defineComponent, openBlock, createBlock } from "vue";
+import _sfc_main$1 from "./group-column.vue.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "group-column-item",
+  props: {
+    configure: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    },
+    pageContext: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    },
+    groupColumnItem: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    },
+    columnsConfigKeyValues: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$1, {
+        configure: __props.configure,
+        pageContext: __props.pageContext,
+        groupColumn: __props.groupColumnItem,
+        columnsConfigKeyValues: __props.columnsConfigKeyValues
+      }, null, 8, ["configure", "pageContext", "groupColumn", "columnsConfigKeyValues"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/es/components/runtime/views/assemblys/chart/table/group-column-item.vue2.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./group-column-item.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/es/components/runtime/views/assemblys/chart/table/group-column.vue.js

@@ -0,0 +1,64 @@
+import { defineComponent, resolveComponent, openBlock, createBlock, withCtx, createTextVNode, toDisplayString, createElementBlock, Fragment, renderList, createCommentVNode } from "vue";
+import _sfc_main$2 from "./normal-column.vue.js";
+import _sfc_main$1 from "./group-column-item.vue.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "group-column",
+  props: {
+    configure: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    },
+    pageContext: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    },
+    groupColumn: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    },
+    columnsConfigKeyValues: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      const _component_el_table_column = resolveComponent("el-table-column");
+      return openBlock(), createBlock(_component_el_table_column, { "header-align": "center" }, {
+        header: withCtx(() => [
+          createTextVNode(toDisplayString(__props.groupColumn.titleText), 1)
+        ]),
+        default: withCtx(() => [
+          __props.groupColumn.children && __props.groupColumn.children.length > 0 ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(__props.groupColumn.children, (item, index) => {
+            return openBlock(), createElementBlock(Fragment, { key: index }, [
+              item.children && item.children.length > 0 ? (openBlock(), createBlock(_sfc_main$1, {
+                key: index,
+                configure: __props.configure,
+                pageContext: __props.pageContext,
+                groupColumnItem: item,
+                columnsConfigKeyValues: __props.columnsConfigKeyValues
+              }, null, 8, ["configure", "pageContext", "groupColumnItem", "columnsConfigKeyValues"])) : (openBlock(), createBlock(_sfc_main$2, {
+                key: 1,
+                pageContext: __props.pageContext,
+                configure: __props.configure,
+                column: __props.columnsConfigKeyValues[item.columnUuid]
+              }, null, 8, ["pageContext", "configure", "column"]))
+            ], 64);
+          }), 128)) : createCommentVNode("", true)
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/es/components/runtime/views/assemblys/chart/table/group-column.vue2.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./group-column.vue.js";
+export {
+  _sfc_main as default
+};