super-page-runtime 2.0.39 → 2.0.40-beta1

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

@@ -0,0 +1,668 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const request = require("../../../node_modules/.pnpm/agilebuilder-ui@1.0.28_vue@3.4.21/node_modules/agilebuilder-ui/src/utils/request.js");
+const dayjs_min = require("../../../node_modules/.pnpm/dayjs@1.11.11/node_modules/dayjs/dayjs.min.js");
+const calculatorUtil = require("../../../node_modules/.pnpm/agilebuilder-ui@1.0.28_vue@3.4.21/node_modules/agilebuilder-ui/src/utils/calculator/calculator-util.js");
+const globalRefs = require("./global-refs.js");
+const Vue = require("vue");
+function getComponentOptionConfigs(component, pageContext2) {
+  if (!component.props || !component.props.dataOrigin) {
+    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, pageContext2);
+    Object.assign(infoObj, tempObj);
+  } else if (dataOriginInfo.optionValueSetType == "service") {
+    infoObj.filterType = dataOriginInfo.filterType;
+    const tempObj = getServiceQueryInfo(dataOriginInfo, pageContext2);
+    Object.assign(infoObj, tempObj);
+  }
+  if (infoObj.type) {
+    return infoObj;
+  } else {
+    return void 0;
+  }
+}
+function getTableQueryInfo(dataOriginInfo, pageContext2) {
+  const infoObj = {};
+  infoObj.type = "dataTable";
+  infoObj.props = {
+    tableName: dataOriginInfo.tableName,
+    systemCode: dataOriginInfo.tableSysCode ? dataOriginInfo.tableSysCode : pageContext2.systemCode,
+    systemVersion: dataOriginInfo.tableSysCode ? dataOriginInfo.tableSysVersion : pageContext2.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, pageContext2) {
+  const infoObj = {};
+  infoObj.type = "service";
+  infoObj.props = {
+    serivceCode: dataOriginInfo.serviceCode,
+    systemCode: dataOriginInfo.tableSysCode ? dataOriginInfo.tableSysCode : pageContext2.systemCode,
+    systemVersion: dataOriginInfo.tableSysCode ? dataOriginInfo.tableSysCode : pageContext2.systemCode
+  };
+  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) {
+  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);
+    }
+    if (appendParams) {
+      Object.assign(additionalParamMap, appendParams);
+    }
+    const taskMap = {};
+    if (entityData2.task) {
+      Object.assign(taskMap, entityData2.task);
+    }
+    const param = {
+      entityMap: entityData2.data,
+      additionalParamMap,
+      taskMap,
+      dataSourceList: dataSourceConfs,
+      systemCode: pageContext2.systemCode,
+      pageCode: pageContext2.code
+    };
+    let baseUrl = pageContext2.backendUrl;
+    if (!baseUrl) {
+      baseUrl = window["$vueApp"].config.globalProperties.baseURL;
+    }
+    const url = baseUrl + "/common/common-data/find-chart-datas";
+    request.post(url, param).then((result) => {
+      if (!pageContext2.chartDataSourceMap) {
+        pageContext2.chartDataSourceMap = {};
+      }
+      for (const uuid in result) {
+        pageContext2.chartDataSourceMap[uuid] = result[uuid];
+        const componentObj = globalRefs.getComponentRef(pageContext2, uuid);
+        if (componentObj && componentObj.updateChartDatas) {
+          componentObj.updateChartDatas(result[uuid]);
+        }
+      }
+      console.log("查询统计图数据完成", result);
+      resolve(result);
+    }).catch((error) => {
+      console.log("查询统计图数据失败", error);
+      reject(error);
+    });
+  });
+}
+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
+    };
+    let baseUrl = pageContext2.backendUrl;
+    if (!baseUrl) {
+      baseUrl = window["$vueApp"].config.globalProperties.baseURL;
+    }
+    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, configure2) {
+  if (!pageContext2 || !pageContext2.optionSourceMap || !configure2) {
+    return [];
+  }
+  const cacheOptions = pageContext2.optionSourceMap[configure2.uuid];
+  return cacheOptions ? cacheOptions : [];
+}
+function getChartDatasFromPage(pageContext2, configure2) {
+  if (!pageContext2 || !pageContext2.chartDataSourceMap || !configure2) {
+    return null;
+  }
+  const cacheDatas = pageContext2.chartDataSourceMap[configure2.uuid];
+  return cacheDatas;
+}
+function queryOptionDatasources(pageContext2, dataSourceConf, query) {
+  return updateOptionDatasources(pageContext2, dataSourceConf ? [dataSourceConf] : [], query);
+}
+function queryOptions(component, pageContext2, query) {
+  if (!component.props || !component.props.dataOrigin) {
+    return new Promise(function(resolve, reject) {
+      resolve([]);
+    });
+  }
+  const dataOriginInfo = component.props.dataOrigin;
+  if (dataOriginInfo.optionValueSetType == "dynamicData") {
+    if (!dataOriginInfo.dynamicDataSourceCode) {
+      return new Promise(function(resolve, reject) {
+        throw new Error("未指定动态数据源!");
+      });
+    }
+    return queryByDynamicCode(dataOriginInfo.dynamicDataSourceCode, query);
+  } else if (dataOriginInfo.optionValueSetType == "dataTable") {
+    if (!dataOriginInfo.tableName) {
+      return new Promise(function(resolve, reject) {
+        throw new Error("未指定查询的数据表!");
+      });
+    }
+    const tempObj = getTableQueryInfo(dataOriginInfo, pageContext2);
+    return queryByTable(tempObj);
+  } else {
+    return new Promise(function(resolve, reject) {
+      throw new Error("无有效的查询设置!");
+    });
+  }
+}
+function queryByDynamicCode(dynamicCode, query) {
+  const param = {
+    code: dynamicCode,
+    query
+  };
+  return request.post("", param);
+}
+function queryByTable(tableQueryInfo) {
+  const param = tableQueryInfo.props;
+  return request.post("", param);
+}
+function autoSetAfterSelect(component, pageContext2, autoSets, selItems) {
+  if (!autoSets || autoSets.length == 0) {
+    return;
+  }
+  const entity = pageContext2.entity ? pageContext2.entity : {};
+  for (const as of autoSets) {
+    if (!as.source || !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 {
+      tempObj = tempObj[fieldName];
+      if (tempObj == void 0) {
+        tempObj[fieldName] = {};
+        tempObj = tempObj[fieldName];
+      }
+    }
+  }
+}
+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);
+    variable = variable.replace(
+      param,
+      paramValue == void 0 || paramValue == null ? "" : paramValue
+    );
+  }
+  return variable;
+}
+function getParamNames(variable) {
+  if (!variable) {
+    return [];
+  }
+  const reg = /\$\{[^\{|\}]+\}/g;
+  return variable.match(reg);
+}
+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) {
+  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);
+    }
+    if (!paramName || !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") {
+      console.log("newDate", paramName);
+      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, configure, showConditions) {
+  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);
+    let propValue = getValueFromVariable(entityData, condition.propValue);
+    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 (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]);
+        }
+      }
+    }
+  }
+  const entity = pageContext2.entity;
+  let firstValue = getMonitorFieldValues(monitorFieldInfos, entity);
+  let monitorTimeout = false;
+  for (const preField of preFields) {
+    Vue.watch(entity[preField], () => {
+      if (monitorTimeout) {
+        clearTimeout(monitorTimeout);
+      }
+      monitorTimeout = setTimeout(function() {
+        const newValue = getMonitorFieldValues(monitorFieldInfos, 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;
+  }
+}
+exports.autoSetAfterSelect = autoSetAfterSelect;
+exports.caculateShowCondition = caculateShowCondition;
+exports.formatValueByType = formatValueByType;
+exports.formatVariableValue = formatVariableValue;
+exports.getChartDatasFromPage = getChartDatasFromPage;
+exports.getComponentOptionConfigs = getComponentOptionConfigs;
+exports.getFormPropName = getFormPropName;
+exports.getOptionDatasFromPage = getOptionDatasFromPage;
+exports.getValueFromSource = getValueFromSource;
+exports.getValueFromVariable = getValueFromVariable;
+exports.getVariableValue = getVariableValue;
+exports.monitorFieldChange = monitorFieldChange;
+exports.queryOptionDatasources = queryOptionDatasources;
+exports.queryOptions = queryOptions;
+exports.setValueForVariableName = setValueForVariableName;
+exports.setVariableValue = setVariableValue;
+exports.updateChartDatasources = updateChartDatasources;
+exports.updateOptionDatasources = updateOptionDatasources;

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

@@ -0,0 +1,40 @@
+import { Component, PageContext, PageDesign } from './interfaces/page-design-types';
+
+/**
+ * 查询页面设计对象
+ * @param pageId
+ * @returns
+ */
+export declare function queryPageDesign(pageId: number): Promise<any>;
+/**
+ * 查询页面设计对象
+ * @param pageCode
+ * @returns
+ */
+export declare function queryPageDesignByCode(pageCode: string): Promise<any>;
+/**
+ * 转换页面设计对象为运行时对象
+ * @param pageDesign 页面设计对象
+ */
+export declare function convertToPageContext(pageDesign: PageDesign, pageRequest: object): PageContext | null;
+export declare function getModelFields(pageContext: PageContext, formItemConfigure: Component, prop?: string): string[];
+/**
+ * 获取表单元素模型名称
+ * @param pageContext 页面对象
+ * @param formItemConfigure 表单元素配置参数
+ */
+export declare function getFormModelFields(pageContext: PageContext, formItemConfigure: any, prop?: string): string[];
+/**
+ * 获取组件的权限编码
+ * @param configure
+ * @param pageContext
+ * @returns
+ */
+export declare function getPermissionCodes(configure: Component, pageContext: PageContext): string;
+/**
+ * 查询页面中所有列表配置
+ * @param pageCode
+ * @returns
+ */
+export declare function queryPageSuperGrids(pageDesign: any, pageContext: any, publishVersion: any): Promise<any>;
+export declare function packageFormRules(pageContext: PageContext, configure: any): void;