super-page-runtime 2.1.45 → 2.1.50-temp1

package/dist/es/components/runtime/utils/page-helper-util.js

@@ -80,8 +80,7 @@ function getTableQueryInfo(dataOriginInfo, pageContext2) {
           }
         }
       }
-      if (f.propValue)
-        ;
+      if (f.propValue) ;
       searchForm.push(tempObj);
     }
     infoObj.props.searchForm = searchForm;
@@ -342,7 +341,7 @@ function formatVariableValue(pageContext2, variable) {
     const paramValue = getValueFromVariable(entity, param);
     variable = variable.replace(
       param,
-      paramValue == void 0 || paramValue == null ? "" : paramValue
+      paramValue === void 0 || paramValue === null ? "" : paramValue
     );
   }
   return variable;
@@ -408,7 +407,7 @@ function formatValueByType(value, formatType, formatInfo) {
   }
   return value;
 }
-function getValueFromVariable(entity, variable) {
+function getValueFromVariable(entity, variable, row) {
   if (variable == null || variable == void 0) {
     return variable;
   }
@@ -442,8 +441,12 @@ function getValueFromVariable(entity, variable) {
       valueSource = entity.system;
     } else if (paramName.startsWith("fixed.")) {
       return paramName.substring(6);
+    } else if (paramName.startsWith("row.")) {
+      paramName = paramName.substring(4);
+      valueSource = row;
+      paramType = "row";
     }
-    if (!paramName || !paramName) {
+    if (!paramName) {
       console.log("获取变量失败", variable, entity);
       return "";
     }
@@ -628,6 +631,9 @@ function getSizeConfig(pageContext2, configure2) {
   if (configure2.props && configure2.props.size && configure2.props.size[pageModeType]) {
     sizeConfig = configure2.props.size[pageModeType];
   }
+  if (!sizeConfig && configure2.props && configure2.props.size) {
+    sizeConfig = configure2.props.size["pc"];
+  }
   return sizeConfig;
 }
 function getPageModeType(pageContext2) {
@@ -637,9 +643,20 @@ function getPageModeType(pageContext2) {
   }
   return dimensions;
 }
+function isPromise(p) {
+  return p && Object.prototype.toString.call(p) === "[object Promise]";
+}
+function decomposeVariable(variable) {
+  if (!variable) {
+    return [];
+  }
+  const paramNames = variable.match(/\${(.*?)}/);
+  return paramNames ? paramNames[1].split(".") : [];
+}
 export {
   autoSetAfterSelect,
   caculateShowCondition,
+  decomposeVariable,
   formatValueByType,
   formatVariableValue,
   getChartDatasFromPage,
@@ -651,6 +668,7 @@ export {
   getValueFromSource,
   getValueFromVariable,
   getVariableValue,
+  isPromise,
   monitorFieldChange,
   queryOptionDatasources,
   setValueForVariableName,

package/dist/es/components/runtime/utils/page-init-util.js

@@ -138,8 +138,7 @@ function getRequestObject(pageRequest) {
       requestObj[paramStrs[0]] = paramStrs.length > 1 ? paramStrs[1] : "";
     }
   }
-  if (requestObj["_t_"])
-    ;
+  if (requestObj["_t_"]) ;
   return requestObj;
 }
 function packageAdditionalMapWithRoute(route, requestObj) {

package/dist/es/components/runtime/views/assemblys/button/button/button-runtime.vue2.js

@@ -1,4 +1,4 @@
-import { defineComponent, ref, resolveComponent, openBlock, createElementBlock, createVNode, normalizeClass, unref, normalizeStyle, withCtx, Fragment, createTextVNode, toDisplayString, createCommentVNode, createBlock } from "vue";
+import { defineComponent, ref, onMounted, resolveComponent, openBlock, createElementBlock, createVNode, normalizeClass, unref, normalizeStyle, withCtx, Fragment, createTextVNode, toDisplayString, createCommentVNode, createBlock } from "vue";
 import { SuperIcon } from "agilebuilder-ui";
 import { handleEvent } from "../../../../utils/events/event-util.js";
 import { $t } from "../../../../utils/i18n-util.js";
@@ -21,6 +21,9 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     function isButtongLoading() {
       return props.pageContext.canClick !== void 0 && props.pageContext.clickUuid !== void 0 ? !props.pageContext.canClick && props.pageContext.clickUuid === props.configure.uuid : false;
     }
+    onMounted(() => {
+      console.log("select-runtime onMounted");
+    });
     return (_ctx, _cache) => {
       const _component_el_button = resolveComponent("el-button");
       return openBlock(), createElementBlock("span", _hoisted_1, [

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

@@ -29,7 +29,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     ]);
     const props = __props;
     const thisRef = ref(null);
-    const chartRef = ref(null);
+    const chartRef = ref();
     const headerRef = ref(null);
     const enableDrill = props.configure.props ? props.configure.props.enableDrill : null;
     const drillEndTrigger = props.configure.props ? props.configure.props.drillEndTrigger : null;
@@ -123,6 +123,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       refresh(true);
     });
     function updateChartDatas(resultData) {
+      var _a;
       if (!resultData) {
         resultData = [];
       }
@@ -144,7 +145,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         headerInfo.groupValue = hisGroupValue;
       }
       if (!dataConfig.autoRefresh || !enableDrill) {
-        clearChartSelected(props.pageContext, props.configure, chartRef.value.chart);
+        clearChartSelected(props.pageContext, props.configure, (_a = chartRef.value) == null ? void 0 : _a.chart);
       }
       dataConfig.autoRefresh = false;
       updateChartOption(props.pageContext, props.configure, chartOption, resultData);

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

@@ -0,0 +1,491 @@
+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 "";
+    }
+    const 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];
+      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: ""
+    }
+  };
+}
+function computeFormula(row, formula) {
+  try {
+    return new Function(
+      "row",
+      `return ${formula.replace(/\$\{row\.(\w+)\}/g, (_, key) => `row.${key}`)}`
+    )(row);
+  } catch (error) {
+    console.error("数据公式解析错误:", error);
+    return 0;
+  }
+}
+export {
+  ExpressionEvaluator,
+  colDataToRow,
+  computeFormula,
+  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
+};