super-page-runtime 2.3.17 → 2.3.18-tmp1

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

@@ -0,0 +1,767 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const request = require("../../../node_modules/.pnpm/agilebuilder-ui@1.1.58_@vue_29e6d749740d5c0a82211de8e577b320/node_modules/agilebuilder-ui/src/utils/request.js");
+const dayjs_min = require("../../../node_modules/.pnpm/dayjs@1.11.13/node_modules/dayjs/dayjs.min.js");
+const calculatorUtil = require("../../../node_modules/.pnpm/agilebuilder-ui@1.1.58_@vue_29e6d749740d5c0a82211de8e577b320/node_modules/agilebuilder-ui/src/utils/calculator/calculator-util.js");
+const globalRefs = require("./global-refs.js");
+const Vue = require("vue");
+const commonUtil = require("./common-util.js");
+function getComponentOptionConfigs(component, pageContext2, systemCode, systemVersion) {
+  return getComponentOptionConfigsBase(
+    component,
+    (pageContext2 == null ? void 0 : pageContext2.systemCode) ? pageContext2.systemCode : systemCode,
+    (pageContext2 == null ? void 0 : pageContext2.systemVersion) ? pageContext2 == null ? void 0 : pageContext2.systemVersion : systemVersion
+  );
+}
+function getComponentOptionConfigsBase(component, systemCode, systemVersion) {
+  if (!component.props || !component.props.dataOrigin) {
+    return;
+  }
+  if (component.name && component.name === "table") {
+    return;
+  }
+  const dataOriginInfo = component.props.dataOrigin;
+  const infoObj = {
+    uuid: component.uuid
+  };
+  if (dataOriginInfo.optionValueSetType == "optionGroup") {
+    infoObj.type = "optionGroup";
+    infoObj.props = {
+      code: dataOriginInfo.optionGroup
+    };
+  } else if (dataOriginInfo.optionValueSetType == "dynamicData") {
+    infoObj.type = "dynamicData";
+    infoObj.filterType = dataOriginInfo.filterType;
+    infoObj.props = {
+      code: dataOriginInfo.dynamicDataSourceCode
+    };
+  } else if (dataOriginInfo.optionValueSetType == "dataTable") {
+    infoObj.filterType = dataOriginInfo.filterType;
+    const tempObj = getTableQueryInfo(dataOriginInfo, systemCode, systemVersion);
+    Object.assign(infoObj, tempObj);
+  } else if (dataOriginInfo.optionValueSetType == "service") {
+    infoObj.filterType = dataOriginInfo.filterType;
+    const tempObj = getServiceQueryInfo(dataOriginInfo, systemCode, systemVersion);
+    Object.assign(infoObj, tempObj);
+  }
+  if (infoObj.type) {
+    return infoObj;
+  } else {
+    return void 0;
+  }
+}
+function getTableQueryInfo(dataOriginInfo, systemCode, systemVersion) {
+  const infoObj = {};
+  infoObj.type = "dataTable";
+  infoObj.valueLabelSwitch = dataOriginInfo.valueLabelSwitch ? true : false;
+  infoObj.props = {
+    tableName: dataOriginInfo.tableName,
+    systemCode: dataOriginInfo.tableSysCode ? dataOriginInfo.tableSysCode : systemCode,
+    systemVersion: dataOriginInfo.tableSysVersion ? dataOriginInfo.tableSysVersion : systemVersion
+  };
+  if (dataOriginInfo.sortFields) {
+    const sortFields = [];
+    for (const field of dataOriginInfo.sortFields) {
+      if (field.name) {
+        sortFields.push({
+          prop: field.name,
+          order: field.type ? field.type : "asc"
+        });
+      }
+    }
+    infoObj.props.sorts = sortFields;
+  }
+  const autoMonitorFields = [];
+  if (dataOriginInfo.filterList) {
+    const searchForm = [];
+    for (const f of dataOriginInfo.filterList) {
+      if (!f.propName) {
+        continue;
+      }
+      if (!f.propDbName) {
+        f.propDbName = f.propName;
+      }
+      const tempObj = {};
+      Object.assign(tempObj, f);
+      const paramsNames = getParamNames(f.propValue);
+      for (const p of paramsNames) {
+        if (p && (p.startsWith("${data.") || p.startsWith("${task.") || p.startsWith("${page."))) {
+          if (!autoMonitorFields.includes(p)) {
+            autoMonitorFields.push(p);
+          }
+        }
+      }
+      if (f.propValue) ;
+      searchForm.push(tempObj);
+    }
+    infoObj.props.searchForm = searchForm;
+  }
+  infoObj.props.monitorFields = autoMonitorFields;
+  const queryFields = [];
+  if (dataOriginInfo.tableValueField) {
+    infoObj.props.valueField = dataOriginInfo.tableValueField;
+  }
+  if (dataOriginInfo.tableLableField && queryFields.indexOf(dataOriginInfo.tableLableField) == -1) {
+    infoObj.props.lableField = dataOriginInfo.tableLableField;
+  }
+  if (dataOriginInfo.autoSets) {
+    for (const field of dataOriginInfo.autoSets) {
+      if (field.source && queryFields.indexOf(field.source) == -1) {
+        queryFields.push(field.source);
+      }
+    }
+  }
+  infoObj.props.queryFields = queryFields;
+  infoObj.props.pageSize = dataOriginInfo.displayQuantity;
+  return infoObj;
+}
+function getServiceQueryInfo(dataOriginInfo, systemCode, systemVersion) {
+  const infoObj = {};
+  infoObj.type = "service";
+  infoObj.valueLabelSwitch = dataOriginInfo.valueLabelSwitch ? true : false;
+  infoObj.props = {
+    serivceCode: dataOriginInfo.serviceCode,
+    systemCode: dataOriginInfo.tableSysCode ? dataOriginInfo.tableSysCode : systemCode,
+    systemVersion: dataOriginInfo.tableSysVersion ? dataOriginInfo.tableSysVersion : systemVersion
+  };
+  if (dataOriginInfo.serviceInputs) {
+    const searchForm = [];
+    for (const f of dataOriginInfo.serviceInputs) {
+      if (!f.name || f.value) {
+        continue;
+      }
+      const tempObj = {};
+      Object.assign(tempObj, f);
+      searchForm.push(tempObj);
+    }
+    infoObj.props.inputs = searchForm;
+  }
+  infoObj.props.dataSetField = dataOriginInfo.serviceDataSetField;
+  infoObj.props.valueField = dataOriginInfo.serviceValueField;
+  infoObj.props.labelField = dataOriginInfo.serviceLabelField;
+  return infoObj;
+}
+function updateChartDatasources(pageContext2, dataSourceConfs, appendParams, isInit) {
+  return new Promise((resolve, reject) => {
+    if (!dataSourceConfs || dataSourceConfs.length == 0) {
+      reject(new Error("无需查询的统计图配置!"));
+      return;
+    }
+    const dataSourceConfsCopy = commonUtil.deepCopy(dataSourceConfs);
+    dataSourceConfsCopy.forEach((item) => {
+      const services = item.services;
+      if (services && services.length > 0) {
+        const serviceInputs = services[0].serviceInputs;
+        if (serviceInputs) {
+          services[0].serviceInParams = {};
+          serviceInputs.forEach((inParam) => {
+            const paramName = inParam.name;
+            const paramValue = inParam.value;
+            services[0].serviceInParams[paramName] = getValueFromVariable(pageContext2.entity, paramValue);
+          });
+          delete services[0].serviceInputs;
+        }
+      }
+    });
+    const entityData2 = pageContext2.entity ? pageContext2.entity : {};
+    const additionalParamMap = {};
+    if (entityData2.request) {
+      Object.assign(additionalParamMap, entityData2.request);
+    }
+    if (entityData2.page) {
+      Object.assign(additionalParamMap, entityData2.page);
+    }
+    if (appendParams) {
+      Object.assign(additionalParamMap, appendParams);
+    }
+    const taskMap = {};
+    if (entityData2.task) {
+      Object.assign(taskMap, entityData2.task);
+    }
+    const param = {
+      entityMap: entityData2.data,
+      additionalParamMap,
+      taskMap,
+      dataSourceList: dataSourceConfsCopy,
+      systemCode: pageContext2.systemCode,
+      pageCode: pageContext2.code
+    };
+    const backendUrl = pageContext2.backendUrl;
+    const baseUrl = commonUtil.getBaseUrl(backendUrl, pageContext2.isTest);
+    const url = baseUrl + "/common/common-data/find-chart-datas";
+    request.post(url, param, {
+      headers: { customSystem: pageContext2.systemCode }
+    }).then((result) => {
+      var _a, _b;
+      if (!pageContext2.chartDataSourceMap) {
+        pageContext2.chartDataSourceMap = {};
+      }
+      for (const uuid in result) {
+        pageContext2.chartDataSourceMap[uuid] = result[uuid];
+        const componentObj = globalRefs.getComponentRef(pageContext2, uuid);
+        if (componentObj) {
+          const chartConfig = componentObj.getConfigure();
+          if (!isInit || chartConfig && (chartConfig.initializationQuery === void 0 || chartConfig.initializationQuery)) {
+            if (componentObj.updateChartDatas) {
+              componentObj.updateChartDatas(result[uuid]);
+              if ((_b = (_a = chartConfig.runtime) == null ? void 0 : _a.dataConfig) == null ? void 0 : _b.resultSet) {
+                const serviceData = result[uuid] && result[uuid].length > 0 ? result[uuid][0] : {};
+                const chartData = serviceData && serviceData.result ? serviceData.result : {};
+                let datas = null;
+                if (chartConfig.serviceDataField) {
+                  datas = chartData[chartConfig.serviceDataField];
+                } else {
+                  if (chartData) {
+                    if (Array.isArray(chartData)) {
+                      datas = chartData;
+                    } else {
+                      datas = [chartData];
+                    }
+                  }
+                }
+                if (!datas) {
+                  datas = [];
+                }
+                setValueForVariableName(pageContext2.entity, chartConfig.runtime.dataConfig.resultSet, datas);
+              }
+            }
+          }
+        }
+      }
+      console.log("查询统计图数据完成", result);
+      resolve(result);
+    }).catch((error) => {
+      console.log("查询统计图数据失败", error);
+      reject(error);
+    });
+  });
+}
+function updateChartDatasourcesByComponent(pageContext2, componentUuid) {
+  const chartDataSource = pageContext2.initChartServiceConfigs.find((item) => item.uuid === componentUuid);
+  if (chartDataSource) {
+    updateChartDatasources(pageContext2, [chartDataSource], null, false);
+  }
+}
+function updateOptionDatasources(pageContext2, dataSourceConfs, query) {
+  return new Promise((resolve, reject) => {
+    if (!dataSourceConfs || dataSourceConfs.length == 0) {
+      reject(new Error("无需查询的配置!"));
+      return;
+    }
+    const entityData2 = pageContext2.entity ? pageContext2.entity : {};
+    const additionalParamMap = {};
+    if (entityData2.request) {
+      Object.assign(additionalParamMap, entityData2.request);
+    }
+    if (entityData2.page) {
+      Object.assign(additionalParamMap, entityData2.page);
+    }
+    additionalParamMap.query = query;
+    const param = {
+      entityMap: entityData2.data,
+      additionalParamMap,
+      dataSourceList: dataSourceConfs,
+      systemCode: pageContext2.systemCode,
+      query
+    };
+    const backendUrl = pageContext2.backendUrl;
+    const baseUrl = commonUtil.getBaseUrl(backendUrl, pageContext2.isTest);
+    const url = baseUrl + "/common/common-data/find-datas";
+    request.post(url, param).then((result) => {
+      if (!pageContext2.optionSourceMap) {
+        pageContext2.optionSourceMap = {};
+      }
+      for (const uuid in result) {
+        pageContext2.optionSourceMap[uuid] = result[uuid];
+        const componentObj = globalRefs.getComponentRef(pageContext2, uuid);
+        if (componentObj && componentObj.updateOptions) {
+          componentObj.updateOptions(result[uuid]);
+        }
+      }
+      console.log("查询选项数据完成", result);
+      resolve(result);
+    }).catch((error) => {
+      console.log("查询选项数据失败", error);
+      reject(error);
+    });
+  });
+}
+function getOptionDatasFromPage(pageContext2, configure) {
+  return getComponentOptionDatasFromPage(pageContext2, configure.uuid);
+}
+function getComponentOptionDatasFromPage(pageContext2, configureUuid) {
+  const optionSourceMap = getOptionDatasSourceMap(pageContext2);
+  const cacheOptions = optionSourceMap[configureUuid];
+  return cacheOptions ? cacheOptions : [];
+}
+function getOptionDatasSourceMap(pageContext2) {
+  if (!pageContext2 || !pageContext2.optionSourceMap) {
+    return {};
+  }
+  const cacheOptions = pageContext2.optionSourceMap;
+  return cacheOptions ? cacheOptions : {};
+}
+function getChartDatasFromPage(pageContext2, configure) {
+  if (!pageContext2 || !pageContext2.chartDataSourceMap || !configure) {
+    return null;
+  }
+  const cacheDatas = pageContext2.chartDataSourceMap[configure.uuid];
+  return cacheDatas;
+}
+function queryOptionDatasources(pageContext2, dataSourceConf, query) {
+  return updateOptionDatasources(pageContext2, dataSourceConf ? [dataSourceConf] : [], query);
+}
+function autoSetAfterSelect(component, pageContext2, autoSets, selItems, skipProps = []) {
+  if (!autoSets || autoSets.length == 0) {
+    return;
+  }
+  const entity = pageContext2.entity ? pageContext2.entity : {};
+  for (const as of autoSets) {
+    if (!as.source || !as.target || skipProps.includes(as.target)) {
+      continue;
+    }
+    const values = getValuesByField(selItems, as.source);
+    let targetField = as.target;
+    if (!targetField || !targetField.startsWith("${")) {
+      continue;
+    }
+    targetField = targetField.substring(2, targetField.length - 1);
+    const fields = targetField.split(".");
+    setVariableValue(entity, fields, values.join(","));
+  }
+}
+function getValuesByField(items, fieldName) {
+  if (!items) {
+    return [""];
+  } else {
+    const values = [];
+    for (const i of items) {
+      let val = i[fieldName];
+      if (val == void 0 || val == null) {
+        val = "";
+      }
+      values.push(val);
+    }
+    return values;
+  }
+}
+function getVariableValue(entity, fields) {
+  if (!entity || !fields || fields.length == 0) {
+    return;
+  }
+  let tempObj = entity;
+  for (let i = 0; i < fields.length; i++) {
+    if (tempObj == void 0) {
+      return tempObj;
+    }
+    const fieldName = fields[i];
+    tempObj = tempObj[fieldName];
+  }
+  return tempObj;
+}
+function setValueForVariableName(entity, variableName, newValue) {
+  if (!variableName || !variableName.startsWith("${")) {
+    return;
+  }
+  variableName = variableName.substring(2, variableName.length - 1);
+  const fields = variableName.split(".");
+  setVariableValue(entity, fields, newValue);
+}
+function setVariableValue(entity, fields, newValue) {
+  if (!entity || !fields || fields.length == 0) {
+    return;
+  }
+  let tempObj = entity;
+  for (let i = 0; i < fields.length; i++) {
+    const fieldName = fields[i];
+    if (i + 1 === fields.length) {
+      tempObj[fieldName] = newValue;
+    } else {
+      if (tempObj[fieldName] === void 0) {
+        tempObj[fieldName] = {};
+      }
+      tempObj = tempObj[fieldName];
+    }
+  }
+}
+function setVariableValueWithProp(entity, prop, newValue) {
+  if (!entity || !prop) {
+    return;
+  }
+  const fields = prop.split(".");
+  setVariableValue(entity, fields, newValue);
+}
+function formatVariableValue(pageContext2, variable) {
+  if (!pageContext2 || variable == "" || variable == null || variable == void 0) {
+    return variable;
+  }
+  const entity = pageContext2.entity ? pageContext2.entity : {};
+  const t = getParamNames(variable);
+  for (const c in t) {
+    const param = t[c];
+    const paramValue = getValueFromVariable(entity, param);
+    if (paramValue && Object.prototype.toString.call(paramValue) === "[object Date]") {
+      return dayjs_min(paramValue).format("YYYY-MM-DD HH:mm:ss");
+    } else if (paramValue && typeof paramValue === "number") {
+      return paramValue;
+    }
+    variable = variable.replace(param, paramValue === void 0 || paramValue === null ? "" : paramValue);
+  }
+  return variable;
+}
+function getParamNames(variable) {
+  if (!variable) {
+    return [];
+  }
+  const reg = /\$\{[^\{|\}]+\}/g;
+  const paramNames = variable.match(reg);
+  return paramNames ? paramNames : [];
+}
+function formatValueByType(value, formatType, formatInfo) {
+  if (!formatType || value == "" || value == null || value == void 0) {
+    return value;
+  }
+  console.log("aaa", value, formatType, formatInfo);
+  formatInfo = formatInfo ? formatInfo : {};
+  if (formatType == "number" || formatType == "percent") {
+    if (isNaN(value)) {
+      return value;
+    }
+    let precision = parseInt(formatInfo.decimalDigit);
+    if (precision == null || isNaN(precision)) {
+      precision = -1;
+    }
+    value = parseFloat(value);
+    if (formatType == "percent") {
+      value = value * 100;
+    }
+    if (precision > -1) {
+      value = parseFloat(value.toFixed(precision));
+    }
+    if (formatType == "percent") {
+      value = value + "%";
+    } else {
+      if (formatInfo.thousandsSeparator) {
+        const parts = value.toString().split(".");
+        parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+        value = parts.length > 1 ? parts.join(".") : parts[0];
+      }
+      if (formatInfo.symbol) {
+        value = formatInfo.symbol + "" + value;
+      }
+    }
+    return value;
+  } else if (formatType == "date" || formatType == "time") {
+    let formatStr = "";
+    if (formatType == "date") {
+      formatStr = formatInfo.dateFormat;
+      if (!formatStr) {
+        formatStr = "YYYY-MM-DD";
+      }
+    } else {
+      formatStr = formatInfo.timeFormat;
+      if (!formatStr) {
+        formatStr = "HH:mm:ss";
+      }
+    }
+    return dayjs_min(value).format(formatStr);
+  } else if (formatType == "custom" && formatInfo.formatEventUuid) {
+    console.log("自定义方法", formatInfo);
+  }
+  return value;
+}
+function getValueFromVariable(entity, variable, row2) {
+  if (variable == null || variable == void 0) {
+    return variable;
+  }
+  if (variable.startsWith("${") && variable.endsWith("}")) {
+    let paramName = variable.substring(2, variable.length - 1);
+    let paramType = null;
+    let valueSource = null;
+    if (paramName.startsWith("data.")) {
+      paramName = paramName.substring(5);
+      valueSource = entity.data;
+      paramType = "data";
+    } else if (paramName.startsWith("page.")) {
+      paramName = paramName.substring(5);
+      paramType = "page";
+      valueSource = entity.page;
+    } else if (paramName.startsWith("task.")) {
+      paramName = paramName.substring(5);
+      paramType = "task";
+      valueSource = entity.task;
+    } else if (paramName.startsWith("request.")) {
+      paramName = paramName.substring(8);
+      paramType = "request";
+      valueSource = entity.request;
+    } else if (paramName.startsWith("context.")) {
+      paramName = paramName.substring(8);
+      paramType = "context";
+      valueSource = entity.context;
+    } else if (paramName.startsWith("system.")) {
+      paramName = paramName.substring(7);
+      paramType = "system";
+      valueSource = entity.system;
+    } else if (paramName.startsWith("fixed.")) {
+      return paramName.substring(6);
+    } else if (paramName.startsWith("row.")) {
+      paramName = paramName.substring(4);
+      valueSource = row2;
+      paramType = "row";
+    }
+    if (!paramName) {
+      console.log("获取变量失败", variable, entity);
+      return "";
+    }
+    return getValueFromSource(valueSource, paramName, paramType);
+  } else {
+    return variable;
+  }
+}
+function getValueFromSource(valueSource, paramName, paramType) {
+  if (paramType != "context" && !valueSource || !paramName) {
+    return void 0;
+  }
+  const firstIndex = paramName.indexOf(".");
+  if (firstIndex > -1) {
+    const tempParamName = paramName.substring(0, firstIndex);
+    const newParamName = paramName.substring(firstIndex + 1);
+    let childValue = valueSource[tempParamName];
+    if (childValue && Array.isArray(childValue) && childValue.length > 0) {
+      childValue = childValue[0];
+    }
+    return getValueFromSource(childValue, newParamName, paramType);
+  } else {
+    if (paramType == "context") {
+      if (paramName == "currentDate" || paramName == "currentTime") {
+        return /* @__PURE__ */ new Date();
+      } else if (paramName.startsWith("currentDate") && paramName.length > 11) {
+        const str = paramName.substring(11);
+        const symbol = str.substring(0, 1);
+        let num = parseInt(str.substring(1, str.length - 1), 10);
+        const unit = str.substring(str.length - 1);
+        const date = /* @__PURE__ */ new Date();
+        num = "+" === symbol ? num : -num;
+        if (unit === "d" || unit === "w") {
+          num = unit === "w" ? num * 7 : num;
+          date.setDate(date.getDate() + num);
+        } else if (unit === "m") {
+          date.setMonth(date.getMonth() + num);
+        } else if (unit === "y") {
+          date.setFullYear(date.getFullYear() + num);
+        }
+        return date;
+      }
+      if (!valueSource) {
+        return void 0;
+      }
+    }
+    return valueSource[paramName];
+  }
+}
+function caculateShowCondition(pageContext, showConditions, row) {
+  if (!showConditions || showConditions.length == 0 || !pageContext || !pageContext.entity) {
+    return true;
+  }
+  const entityData = pageContext.entity;
+  let conditions = "";
+  const maxLen = showConditions.length;
+  for (let i = 0; i < maxLen; i++) {
+    const condition = showConditions[i];
+    const propName = condition.propName;
+    let operator = condition.operator;
+    if (!propName || propName === "") {
+      continue;
+    }
+    if (!operator) {
+      operator = "EQ";
+    }
+    const leftValue = getValueFromVariable(entityData, propName, row);
+    let propValue = getValueFromVariable(entityData, condition.propValue, row);
+    const dataType = condition.dataType;
+    if (operator == "CONTAIN" || operator == "NOT_CONTAIN") {
+      if (leftValue && !leftValue.includes) {
+        operator = operator == "CONTAIN" ? "EQ" : "NET";
+      }
+    }
+    let variableIsNullStr = condition.variableIsNull;
+    if (!variableIsNullStr) {
+      variableIsNullStr = "null";
+    }
+    let conditionResult = void 0;
+    if (operator !== "IS_NULL" && operator !== "IS_NOT_NULL") {
+      if (propValue === void 0 || propValue === "") {
+        propValue = null;
+        if (variableIsNullStr === "null") {
+          operator = "IS_NULL";
+        } else if (variableIsNullStr === "notequal") {
+          operator = "IS_NOT_NULL";
+        } else {
+          conditionResult = true;
+        }
+      }
+    }
+    if (conditionResult == void 0) {
+      try {
+        conditionResult = calculatorUtil.executeExpression(leftValue, operator, propValue, dataType);
+      } catch (e) {
+        console.log("executeExpression error", e);
+        conditionResult = false;
+      }
+    }
+    const leftBracket = condition.leftBracket;
+    const rightBracket = condition.rightBracket;
+    let joinSign = condition.joinSign;
+    if (leftBracket && leftBracket !== null && leftBracket !== "") {
+      conditions = conditions + leftBracket;
+      conditions = conditions + " ";
+    }
+    conditions += conditionResult + " ";
+    if (rightBracket && rightBracket !== null && rightBracket !== "") {
+      conditions = conditions + rightBracket;
+      conditions = conditions + " ";
+    }
+    if (i < maxLen - 1) {
+      if (joinSign && joinSign !== null && joinSign !== "") {
+        const joinSignIgnoreCase = joinSign.toLowerCase();
+        if (joinSignIgnoreCase === "and") {
+          joinSign = joinSignIgnoreCase.replace("and", "&&");
+        } else if (joinSignIgnoreCase === "or") {
+          joinSign = joinSignIgnoreCase.replace("or", "||");
+        }
+        conditions += joinSign + " ";
+      }
+    }
+  }
+  if (conditions) {
+    return eval("(" + conditions + ")");
+  } else {
+    return true;
+  }
+}
+function monitorFieldChange(pageContext2, monitorFields, triggerFunc) {
+  if (!triggerFunc || !pageContext2 || !monitorFields || monitorFields.length == 0) {
+    return;
+  }
+  const monitorFieldInfos = [];
+  const preFields = [];
+  for (let propName of monitorFields) {
+    if (propName.startsWith("${")) {
+      propName = propName.substring(2, propName.length - 1);
+      const fields = propName.split(".");
+      if (fields[0] === "page" || fields[0] === "task" || fields[0] === "data") {
+        monitorFieldInfos.push(fields);
+        if (!preFields.includes(fields[0])) {
+          preFields.push(fields[0]);
+        }
+      }
+    }
+  }
+  let firstValue = getMonitorFieldValues(monitorFieldInfos, pageContext2.entity);
+  let monitorTimeout = false;
+  for (const preField of preFields) {
+    Vue.watch(pageContext2.entity[preField], () => {
+      if (monitorTimeout) {
+        clearTimeout(monitorTimeout);
+      }
+      monitorTimeout = setTimeout(function() {
+        const newValue = getMonitorFieldValues(monitorFieldInfos, pageContext2.entity);
+        if (firstValue != newValue) {
+          firstValue = newValue;
+          triggerFunc();
+        }
+      }, 200);
+    });
+  }
+}
+function getMonitorFieldValues(monitorFieldInfos, entity) {
+  let values = "";
+  for (const fieldInfo of monitorFieldInfos) {
+    values += "_" + getVariableValue(entity, fieldInfo);
+  }
+  return values;
+}
+function getFormPropName(prop) {
+  if (prop && prop.indexOf("${") >= 0) {
+    return prop.substring(prop.indexOf(".") + 1, prop.lastIndexOf("}"));
+  } else {
+    return prop;
+  }
+}
+function getSizeConfig(pageContext2, configure) {
+  const pageModeType = getPageModeType(pageContext2);
+  let sizeConfig;
+  if (configure.props && configure.props.size && configure.props.size[pageModeType]) {
+    sizeConfig = configure.props.size[pageModeType];
+  }
+  if (!sizeConfig && configure.props && configure.props.size) {
+    sizeConfig = configure.props.size["pc"];
+  }
+  return sizeConfig;
+}
+function getPageModeType(pageContext2) {
+  let dimensions = pageContext2.dimensions;
+  if (!dimensions) {
+    dimensions = "pc";
+  }
+  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(".") : [];
+}
+function getModelFieldFromPageContext(fields, pageContext2) {
+  if (!pageContext2.modelFieldsMap) {
+    return;
+  }
+  let modelField = null;
+  for (let i = 0; i < fields.length; i++) {
+    const fieldName = fields[i];
+    if (i + 1 === fields.length) {
+      modelField = pageContext2.modelFieldsMap[fieldName];
+    }
+  }
+  return modelField;
+}
+function isNumberDataType(dataType) {
+  return dataType === "INTEGER" || dataType === "LONG" || dataType === "DOUBLE" || dataType === "FLOAT_COM";
+}
+function isDateDataType(dataType) {
+  dataType = dataType ? dataType.toUpperCase() : "";
+  return dataType === "DATE" || dataType === "TIME" || dataType === "DATETIME" || dataType === "TIMESTAMP";
+}
+exports.autoSetAfterSelect = autoSetAfterSelect;
+exports.caculateShowCondition = caculateShowCondition;
+exports.decomposeVariable = decomposeVariable;
+exports.formatValueByType = formatValueByType;
+exports.formatVariableValue = formatVariableValue;
+exports.getChartDatasFromPage = getChartDatasFromPage;
+exports.getComponentOptionConfigs = getComponentOptionConfigs;
+exports.getComponentOptionConfigsBase = getComponentOptionConfigsBase;
+exports.getComponentOptionDatasFromPage = getComponentOptionDatasFromPage;
+exports.getFormPropName = getFormPropName;
+exports.getModelFieldFromPageContext = getModelFieldFromPageContext;
+exports.getOptionDatasFromPage = getOptionDatasFromPage;
+exports.getOptionDatasSourceMap = getOptionDatasSourceMap;
+exports.getParamNames = getParamNames;
+exports.getSizeConfig = getSizeConfig;
+exports.getValueFromSource = getValueFromSource;
+exports.getValueFromVariable = getValueFromVariable;
+exports.getVariableValue = getVariableValue;
+exports.isDateDataType = isDateDataType;
+exports.isNumberDataType = isNumberDataType;
+exports.isPromise = isPromise;
+exports.monitorFieldChange = monitorFieldChange;
+exports.queryOptionDatasources = queryOptionDatasources;
+exports.setValueForVariableName = setValueForVariableName;
+exports.setVariableValue = setVariableValue;
+exports.setVariableValueWithProp = setVariableValueWithProp;
+exports.updateChartDatasources = updateChartDatasources;
+exports.updateChartDatasourcesByComponent = updateChartDatasourcesByComponent;
+exports.updateOptionDatasources = updateOptionDatasources;