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

package/dist/lib/components/runtime/utils/charts/chart-util.js

@@ -0,0 +1,550 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const theme1 = require("../../../../assets/chart-themes/theme1.js");
+const theme2 = require("../../../../assets/chart-themes/theme2.js");
+const theme3 = require("../../../../assets/chart-themes/theme3.js");
+const pageInitUtil = require("../page-init-util.js");
+const pageHelperUtil = require("../page-helper-util.js");
+const eventUtil = require("../events/event-util.js");
+var CommonName = /* @__PURE__ */ ((CommonName2) => {
+  CommonName2["X_FIELD_NAME"] = "__x";
+  CommonName2["Y_TEMP_NAME"] = "__y";
+  return CommonName2;
+})(CommonName || {});
+const themeMap = {
+  theme1,
+  theme2,
+  theme3
+};
+function getCustomTheme(themeName) {
+  return themeMap[themeName];
+}
+function getCustomThemeOptions() {
+  return [
+    {
+      value: "theme1",
+      label: "主题1"
+    },
+    {
+      value: "theme2",
+      label: "主题2"
+    },
+    {
+      value: "theme3",
+      label: "主题3"
+    }
+  ];
+}
+function getNumFormatter(labelNumFormat, numPrecision, numPrefix, numAppend, isValueFormatter) {
+  const func = function(params) {
+    let labelValue = params == null ? void 0 : params.value;
+    if (isValueFormatter) {
+      labelValue = params;
+    }
+    if (labelValue == void 0 || labelValue == null) {
+      return labelValue;
+    }
+    if (Array.isArray(labelValue)) {
+      console.log("numformatter is array", labelValue);
+      return labelValue;
+    }
+    if (isNaN(labelValue) || !labelNumFormat || !labelNumFormat.indexOf) {
+      return labelValue;
+    }
+    if (labelNumFormat.indexOf("precision") > -1) {
+      let precision = parseInt(numPrecision);
+      if (precision == null || isNaN(precision)) {
+        precision = 2;
+      }
+      labelValue = parseFloat(parseFloat(labelValue).toFixed(precision));
+    }
+    let prefix = "";
+    if (labelNumFormat.indexOf("prefix") > -1 && numPrefix) {
+      prefix = numPrefix;
+    }
+    let append = "";
+    if (labelNumFormat.indexOf("append") > -1 && numAppend) {
+      append = numAppend;
+    }
+    return prefix + labelValue.toLocaleString() + append;
+  };
+  return func;
+}
+function initChartOption(configure, chartOption) {
+  if (!chartOption) {
+    return;
+  }
+  if (chartOption.tooltipFormatterArgs) {
+    if (!chartOption.tooltip) {
+      chartOption.tooltip = {};
+    }
+    chartOption.tooltip.valueFormatter = getNumFormatter.apply(chartOption, chartOption.tooltipFormatterArgs);
+  }
+  if (chartOption.series) {
+    const enableDrill = configure.props ? configure.props.enableDrill : null;
+    for (const s of chartOption.series) {
+      if (!chartOption.radar) {
+        s.data = [];
+      }
+      if (s.labelFormatterArgs) {
+        if (!s.label) {
+          s.label = {};
+        }
+        s.label.formatter = getNumFormatter.apply(s, s.labelFormatterArgs);
+      }
+      if (!enableDrill && configure.clickSet && configure.clickSet.selected) {
+        if (s.emphasis) {
+          s.emphasis.disabled = false;
+        }
+      }
+      if (s.type === "pie" && configure.clickSet) {
+        if (configure.clickSet.selected) {
+          if (configure.clickSet.multiple) {
+            s.selectedMode = "multiple";
+          } else {
+            s.selectedMode = "single";
+          }
+        }
+      }
+    }
+  }
+  if (chartOption.radar) {
+    for (const r of chartOption.radar) {
+      r.indicator = [];
+    }
+  }
+  const defaultSeries = chartOption.series;
+  configure.defaultSeries = defaultSeries;
+  const defaultXaxis = chartOption.xAxis;
+  if (defaultXaxis && defaultXaxis.length > 0 && defaultXaxis[0].data) {
+    defaultXaxis[0].data = [];
+  }
+  configure.defaultXaxis = defaultXaxis;
+  const defaultYaxis = chartOption.yAxis;
+  if (defaultYaxis) {
+    for (const yAxis of defaultYaxis) {
+      if (yAxis.data) {
+        yAxis.data = [];
+      }
+      if (yAxis._dataMin === "auto") {
+        yAxis.min = function(value) {
+          if (value.min) {
+            return Math.floor(value.min / 10) * 10;
+          }
+        };
+      }
+      if (yAxis._dataMax === "auto") {
+        yAxis.max = function(value) {
+          if (value.max) {
+            return Math.ceil(value.max / 10) * 10;
+          }
+        };
+      }
+    }
+  }
+  configure.defaultYaxis = defaultYaxis;
+}
+function monitorChartClickToVariable(pageContext, configure, chart) {
+  if (!chart || !configure || !configure.clickSet || !pageContext) {
+    return;
+  }
+  const clickSet = configure.clickSet;
+  chart.on("click", function(params) {
+    let highlightInfos = configure.highlightInfos ? configure.highlightInfos : [];
+    console.log("highlightInfos", highlightInfos, params);
+    let hisSelectIndex = -1;
+    if (highlightInfos) {
+      const newInfos = [];
+      for (let i = 0; i < highlightInfos.length; i++) {
+        const info = highlightInfos[i];
+        const hisSelected = info.seriesIndex === params.seriesIndex && info.dataIndex === params.dataIndex;
+        if (hisSelected || !clickSet.multiple) {
+          if (clickSet.selected) {
+            const typeName = configure.name === "chart-pie" ? "unselect" : "downplay";
+            chart.dispatchAction({
+              type: typeName,
+              seriesIndex: info.seriesIndex,
+              dataIndex: info.dataIndex
+            });
+          }
+        } else {
+          newInfos.push(info);
+        }
+        if (hisSelected) {
+          hisSelectIndex = i;
+        }
+      }
+      highlightInfos = newInfos;
+    }
+    if (hisSelectIndex === -1) {
+      if (clickSet.selected) {
+        const typeName = configure.name === "chart-pie" ? "select" : "highlight";
+        chart.dispatchAction({
+          type: typeName,
+          seriesIndex: params.seriesIndex,
+          dataIndex: params.dataIndex
+        });
+      }
+      highlightInfos.push({
+        seriesIndex: params.seriesIndex,
+        dataIndex: params.dataIndex
+      });
+    }
+    configure.highlightInfos = highlightInfos;
+    updateClickVariablesForSelected(pageContext, configure);
+  });
+}
+function clearChartSelected(pageContext, configure, chart) {
+  if (!chart || !configure || !pageContext) {
+    return;
+  }
+  const highlightInfos = configure.highlightInfos ? configure.highlightInfos : [];
+  for (let i = 0; i < highlightInfos.length; i++) {
+    const info = highlightInfos[i];
+    const typeName = configure.name === "chart-pie" ? "unselect" : "downplay";
+    chart.dispatchAction({
+      type: typeName,
+      seriesIndex: info.seriesIndex,
+      dataIndex: info.dataIndex
+    });
+  }
+  configure.highlightInfos = [];
+  updateClickVariablesForSelected(pageContext, configure);
+}
+function updateClickVariablesForSelected(pageContext, configure) {
+  if (!configure.clickSet) {
+    return;
+  }
+  const clickSet = configure.clickSet;
+  const variables = clickSet.variables;
+  if (!variables || variables.length == 0) {
+    return;
+  }
+  const highlightInfos = configure.highlightInfos ? configure.highlightInfos : [];
+  const caheDatas = configure.cacheDatas ? configure.cacheDatas : [];
+  const selDatas = [];
+  const existIndexs = [];
+  for (const highlightInfo of highlightInfos) {
+    if (existIndexs.includes(highlightInfo.dataIndex)) {
+      continue;
+    }
+    existIndexs.push(highlightInfo.dataIndex);
+    if (highlightInfo.dataIndex < caheDatas.length) {
+      selDatas.push(caheDatas[highlightInfo.dataIndex]);
+    }
+  }
+  for (const v of variables) {
+    if (!v.fieldName || !v.variable) {
+      continue;
+    }
+    const values = [];
+    for (const data of selDatas) {
+      const value = pageHelperUtil.getValueFromSource(data, v.fieldName, void 0);
+      if (value == void 0) {
+        continue;
+      }
+      values.push(value);
+    }
+    if (clickSet.multiple) {
+      pageHelperUtil.setValueForVariableName(pageContext.entity, v.variable, values);
+    } else {
+      pageHelperUtil.setValueForVariableName(pageContext.entity, v.variable, values.length > 0 ? values[0] : void 0);
+    }
+  }
+}
+function sortDatas(pageContext, configure, datas) {
+  const itemConfs = configure.items ? configure.items : [];
+  const orderByTarget = configure.props ? configure.props.orderByTarget : "";
+  let orderField = null;
+  if (orderByTarget == "x" || orderByTarget == "X") {
+    orderField = "__x";
+  } else if (orderByTarget) {
+    for (const item of itemConfs) {
+      if (item.uuid == orderByTarget) {
+        const itemProps = item.props ? item.props : {};
+        const sourceType = itemProps.yaxisSource;
+        const yaxisField = itemProps.yaxisField;
+        if (yaxisField && (!sourceType || sourceType == "variable")) {
+          orderField = yaxisField;
+          break;
+        }
+      }
+    }
+  }
+  if (!orderField) {
+    return;
+  }
+  const orderSource = configure.props ? configure.props.orderSource : "";
+  let orderValue = configure.props ? configure.props.orderFix : "";
+  if (orderSource == "variable") {
+    const orderVariable = configure.props ? configure.props.orderVariable : "";
+    orderValue = pageHelperUtil.formatVariableValue(pageContext, orderVariable);
+  }
+  orderValue = orderValue == "desc" || orderValue == "DESC" ? "desc" : "asc";
+  datas.sort((dataObj1, dataObj2) => {
+    const val1 = pageHelperUtil.getValueFromSource(dataObj1, orderField, void 0);
+    const val2 = pageHelperUtil.getValueFromSource(dataObj2, orderField, void 0);
+    if (orderValue === "desc") {
+      return val2 - val1;
+    } else {
+      return val1 - val2;
+    }
+  });
+}
+function limitDatas(pageContext, configure, datas, groupFields, numFields) {
+  if (!datas) {
+    return datas;
+  }
+  const confProps = configure.props ? configure.props : {};
+  if (!confProps.limitQuantity) {
+    return datas;
+  }
+  let limitNum = null;
+  if (confProps.itemNumVariable) {
+    limitNum = pageHelperUtil.formatVariableValue(pageContext, confProps.itemNumVariable);
+    limitNum = parseInt(limitNum);
+  } else {
+    limitNum = confProps.itemNumFix ? confProps.itemNumFix : 10;
+  }
+  if (limitNum == null || limitNum == void 0 || isNaN(limitNum)) {
+    return datas;
+  }
+  if (datas.length < limitNum) {
+    return datas;
+  }
+  const overItemAlias = confProps.overItemAlias;
+  const newDatas = [];
+  const otherData = {};
+  groupFields = groupFields ? groupFields : [];
+  numFields = numFields ? numFields : [];
+  for (let i = 0; i < datas.length; i++) {
+    const data = datas[i];
+    if (i < limitNum) {
+      newDatas.push(data);
+      continue;
+    }
+    if (!overItemAlias) {
+      break;
+    }
+    for (const groupField of groupFields) {
+      if (!groupField) {
+        continue;
+      }
+      let value = pageHelperUtil.getValueFromSource(data, groupField, void 0);
+      value = value == null || value == void 0 ? "" : value;
+      if (!otherData[groupField]) {
+        otherData[groupField] = [];
+      }
+      const existValues = otherData[groupField];
+      if (!existValues.includes(value)) {
+        existValues.push(value);
+      }
+    }
+    for (const numField of numFields) {
+      if (!numField) {
+        continue;
+      }
+      const value = pageHelperUtil.getValueFromSource(data, numField, void 0);
+      if (isNaN(value)) {
+        continue;
+      }
+      const hisValue = otherData[numField];
+      if (isNaN(hisValue)) {
+        otherData[numField] = value;
+      } else {
+        otherData[numField] = value + hisValue;
+      }
+    }
+  }
+  if (overItemAlias) {
+    otherData[
+      "__x"
+      /* X_FIELD_NAME */
+    ] = overItemAlias;
+    newDatas.push(otherData);
+  }
+  return newDatas;
+}
+function caculateFormulaValue(itemConfs, datas, accumulateFields) {
+  const totalValueMap = {};
+  for (const item of itemConfs) {
+    const itemProps = item.props ? item.props : {};
+    const sourceType = itemProps.yaxisSource;
+    if (sourceType === "formula") {
+      const paramNames = pageHelperUtil.getParamNames(itemProps.formula);
+      for (const paramName of paramNames) {
+        if (paramName in totalValueMap) {
+          continue;
+        }
+        if (paramName.startsWith("${min.")) {
+          totalValueMap[paramName] = getMinValue(datas, paramName.substring(6, paramName.length - 1));
+        } else if (paramName.startsWith("${max.")) {
+          totalValueMap[paramName] = getMaxValue(datas, paramName.substring(6, paramName.length - 1));
+        } else if (paramName.startsWith("${sum.")) {
+          totalValueMap[paramName] = getSumValue(datas, paramName.substring(6, paramName.length - 1));
+        } else if (paramName.startsWith("${avg.")) {
+          totalValueMap[paramName] = getAvgValue(datas, paramName.substring(6, paramName.length - 1));
+        } else if (paramName.startsWith("${add.")) {
+          const fieldName = paramName.substring(6, paramName.length - 1);
+          accumulateFields.add(fieldName);
+        }
+      }
+    }
+  }
+  return totalValueMap;
+}
+function getMinValue(datas, fieldName) {
+  let minValue = void 0;
+  for (const d of datas) {
+    const value = parseFloat(pageHelperUtil.getValueFromSource(d, fieldName, null));
+    if (minValue === void 0) {
+      minValue = value;
+    } else if (!isNaN(value) && value < minValue) {
+      minValue = value;
+    }
+  }
+  return minValue;
+}
+function getMaxValue(datas, fieldName) {
+  let maxValue = void 0;
+  for (const d of datas) {
+    const value = parseFloat(pageHelperUtil.getValueFromSource(d, fieldName, null));
+    if (maxValue === void 0) {
+      maxValue = value;
+    } else if (!isNaN(value) && value > maxValue) {
+      maxValue = value;
+    }
+  }
+  return maxValue;
+}
+function getSumValue(datas, fieldName) {
+  let sumValue = void 0;
+  for (const d of datas) {
+    const value = parseFloat(pageHelperUtil.getValueFromSource(d, fieldName, null));
+    if (sumValue === void 0) {
+      sumValue = value;
+    } else if (!isNaN(value)) {
+      sumValue += value;
+    }
+  }
+  return sumValue;
+}
+function getAvgValue(datas, fieldName) {
+  const sumValue = getSumValue(datas, fieldName);
+  if (sumValue === void 0 || datas.length === 0) {
+    return sumValue;
+  }
+  return parseFloat((sumValue / datas.length).toFixed(5));
+}
+function executeChartFormula(formulaStr, accumulateMap, rowData, pageContext) {
+  if (!formulaStr) {
+    return void 0;
+  }
+  if (accumulateMap) {
+    for (const accumulateField in accumulateMap) {
+      formulaStr = formulaStr.replace(
+        new RegExp("\\${add." + accumulateField + "}", "g"),
+        accumulateMap[accumulateField]
+      );
+    }
+  }
+  const paramNames = pageHelperUtil.getParamNames(formulaStr);
+  for (const paramName of paramNames) {
+    let value = null;
+    if (paramName.startsWith("${row.")) {
+      value = pageHelperUtil.getValueFromSource(rowData, paramName.substring(6, paramName.length - 1), null);
+    } else {
+      value = pageHelperUtil.getValueFromVariable(pageContext.entity, paramName);
+    }
+    formulaStr = formulaStr.replace(new RegExp(paramName.replace("$", "\\$"), "g"), value);
+  }
+  if (!formulaStr.includes("return ")) {
+    formulaStr = "return " + formulaStr;
+  }
+  const newFunc = new Function("params", formulaStr);
+  eventUtil.appendDefaultMethods(newFunc, pageContext);
+  return newFunc({
+    pageContext,
+    row: rowData
+  });
+}
+function exportCommonChart(chartRef) {
+  if (!chartRef || !chartRef.$el) {
+    return;
+  }
+  const canvasDoms = chartRef.$el.getElementsByTagName("canvas");
+  if (!canvasDoms || canvasDoms.length === 0) {
+    return;
+  }
+  const canvasDom = canvasDoms[0];
+  const fileSize = canvasDom.width + ":" + canvasDom.height;
+  return {
+    isTable: false,
+    fileContent: canvasDom.toDataURL(),
+    fileSize
+  };
+}
+function setHomeChartInitConfigValue(initConfig, tempContext, homeChartSettingUserId) {
+  const homeMyChartsConditions = window.localStorage.getItem("HOME_MY_CHARTS_CONDITIONS");
+  let setInitConfig = true;
+  if (homeMyChartsConditions) {
+    const conditions = JSON.parse(homeMyChartsConditions);
+    if (conditions[homeChartSettingUserId]) {
+      const conditionValues = conditions[homeChartSettingUserId];
+      if (Object.keys(conditionValues).length > 0) {
+        setInitConfig = false;
+        for (const key in conditionValues) {
+          if (conditionValues[key] !== null && conditionValues[key] !== void 0) {
+            pageHelperUtil.setValueForVariableName(tempContext.entity, key, conditionValues[key]);
+          }
+        }
+      }
+    }
+  }
+  if (setInitConfig && initConfig) {
+    for (const variable of initConfig) {
+      if (variable.prop) {
+        if (variable.value) {
+          const defaultValue = pageInitUtil.getDefaultValue(tempContext, variable.value, "input-text", false);
+          const propName = variable.prop.substring(2, variable.prop.length - 1);
+          const fields = propName.split(".");
+          if (defaultValue !== void 0 && defaultValue !== null) {
+            pageHelperUtil.setVariableValue(tempContext.entity, fields, defaultValue);
+          }
+        }
+      }
+    }
+  }
+}
+function setDefaultGrid(chartOption) {
+  if (chartOption == null ? void 0 : chartOption.grid) {
+    const grid = chartOption.grid;
+    const isEmpty = (val) => !val || val === "0";
+    if (isEmpty(grid.top) && isEmpty(grid.right) && isEmpty(grid.bottom) && isEmpty(grid.left)) {
+      Object.assign(grid, {
+        right: "10%",
+        bottom: "60",
+        left: "10%"
+      });
+    }
+  }
+}
+exports.CommonName = CommonName;
+exports.caculateFormulaValue = caculateFormulaValue;
+exports.clearChartSelected = clearChartSelected;
+exports.executeChartFormula = executeChartFormula;
+exports.exportCommonChart = exportCommonChart;
+exports.getAvgValue = getAvgValue;
+exports.getCustomTheme = getCustomTheme;
+exports.getCustomThemeOptions = getCustomThemeOptions;
+exports.getMaxValue = getMaxValue;
+exports.getMinValue = getMinValue;
+exports.getNumFormatter = getNumFormatter;
+exports.getSumValue = getSumValue;
+exports.initChartOption = initChartOption;
+exports.limitDatas = limitDatas;
+exports.monitorChartClickToVariable = monitorChartClickToVariable;
+exports.setDefaultGrid = setDefaultGrid;
+exports.setHomeChartInitConfigValue = setHomeChartInitConfigValue;
+exports.sortDatas = sortDatas;
+exports.updateClickVariablesForSelected = updateClickVariablesForSelected;

package/dist/lib/components/runtime/utils/common-util.d.ts

@@ -0,0 +1,33 @@
+import { Component, PageContext } from './interfaces/page-design-types';
+
+export declare function isArrayFn(value: any): boolean;
+export declare function getBaseUrl(backendUrl: string | null | undefined, isTest?: boolean): any;
+export declare function getRealRestApiPath(orgRestApiPath: any, systemCode: any, backendUrl: any, isTest?: boolean): any;
+/**
+ * 封装模板文件列表
+ * @param templateFiles
+ * @returns
+ */
+export declare function packageTemplateFiles(templateFiles: any, pageContext: PageContext, configure: Component): any;
+export declare function upperFirstCase(str: any): any;
+export declare function getListCode(pageCode: any, pageVersion: any, tableUuid: any): string;
+/**
+ * 深度复制
+ * @returns
+ */
+export declare function deepCopy(srcObj: any): any;
+export declare function getWorkflowId(pageContext: any): any;
+/**
+ * 获得当前属性名，封装到class中，操作dom时可能会使用
+ * @param configure
+ * @returns
+ */
+export declare function getPropClassName(configure: Component): any;
+export declare function isNumber(numStr: any): boolean;
+export declare function isWorkflowPage(pageContext: PageContext): boolean;
+export declare function refreshMobileDialogType(jumpPageSetting: any, isMobile: boolean): void;
+export declare function isVariableInvalidValue(values: any, variable: string): boolean;
+/**
+ * 给主表字段添加必填高亮样式
+ */
+export declare function addRequiredClassUtil(): string;