super-page-designer 0.0.2-tmp8 → 1.0.1

package/dist/lib/components/design/utils/form-design-util.js

@@ -0,0 +1,549 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pageStore = require("../../../stores/page-store.js");
+const pageHelperUtil = require("super-page-runtime/src/components/runtime/utils/page-helper-util");
+function caculateDetailComponentStyle(configure, designStyle, designClass, designHeaderStyle) {
+  const tempStyle = {};
+  const tempHeaderStyle = {};
+  let tempClass = "";
+  let defineStyle = {};
+  if (configure.default && configure.default.style) {
+    Object.assign(defineStyle, configure.default.style);
+  }
+  if (configure.style) {
+    for (let pro in configure.style) {
+      const proValue = configure.style[pro];
+      if (proValue != void 0 && proValue != null && proValue != "") {
+        defineStyle[pro] = proValue;
+      }
+    }
+  }
+  if (defineStyle.fontWeight) {
+    tempStyle["font-weight"] = "bold";
+  }
+  if (defineStyle.incline) {
+    tempStyle["font-style"] = "italic";
+  }
+  if (defineStyle.fontSize) {
+    tempStyle["font-size"] = defineStyle.fontSize;
+  }
+  if (defineStyle.color) {
+    tempStyle["color"] = defineStyle.color;
+  }
+  if (defineStyle.textAlign) {
+    tempStyle["text-align"] = defineStyle.textAlign;
+  }
+  if (defineStyle.paddingTop) {
+    tempStyle["padding-top"] = defineStyle.paddingTop + "px";
+  }
+  if (defineStyle.paddingRight) {
+    tempStyle["padding-right"] = defineStyle.paddingRight + "px";
+  }
+  if (defineStyle.paddingBottom) {
+    tempStyle["padding-bottom"] = defineStyle.paddingBottom + "px";
+  }
+  if (defineStyle.paddingLeft) {
+    tempStyle["padding-left"] = defineStyle.paddingLeft + "px";
+  }
+  if (defineStyle.cursor) {
+    tempStyle["cursor"] = defineStyle.cursor;
+  }
+  if (defineStyle.borderColor) {
+    tempStyle["border-color"] = defineStyle.borderColor;
+  }
+  if (defineStyle.borderWidth) {
+    tempStyle["border-width"] = defineStyle.borderWidth + "px";
+  }
+  if (defineStyle.borderType) {
+    tempStyle["border-style"] = defineStyle.borderType;
+  }
+  if (defineStyle.radius) {
+    tempStyle["border-radius"] = defineStyle.radius + "px";
+  }
+  if (defineStyle.customClass) {
+    tempClass += " " + defineStyle.customClass.replace(/;/g, " ");
+  }
+  if (defineStyle.customStyle) {
+    const strs = defineStyle.customStyle.replace(/[\r\n]/g, "").split(";");
+    for (let index = 0; index < strs.length; index++) {
+      const ss = strs[index].split(":");
+      if (ss.length > 1 && ss[0] && ss[1]) {
+        if (!isNaN(ss[0])) {
+          continue;
+        }
+        tempStyle[ss[0]] = ss[1];
+      }
+    }
+  }
+  if (defineStyle.headerFontWeight) {
+    tempHeaderStyle["font-weight"] = "bold";
+  }
+  if (defineStyle.headerIncline) {
+    tempHeaderStyle["font-style"] = "italic";
+  }
+  if (defineStyle.headerFontSize) {
+    tempHeaderStyle["font-size"] = defineStyle.headerFontSize;
+  }
+  if (defineStyle.headerColor) {
+    tempHeaderStyle["color"] = defineStyle.headerColor;
+  }
+  if (defineStyle.headerTextAlign) {
+    tempHeaderStyle["text-align"] = defineStyle.headerTextAlign;
+  } else {
+    tempHeaderStyle["text-align"] = "left";
+  }
+  designStyle.value = tempStyle;
+  designClass.value = tempClass;
+  if (designHeaderStyle) {
+    designHeaderStyle.value = tempHeaderStyle;
+  }
+}
+function caculateComponentProps(configure, property) {
+  const tempProps = {};
+  let defineProps = {};
+  if (configure.default && configure.default.props) {
+    Object.assign(defineProps, configure.default.props);
+  }
+  if (configure.props) {
+    for (let pro in configure.props) {
+      const proValue = configure.props[pro];
+      if (proValue != void 0 && proValue != null && proValue != "") {
+        defineProps[pro] = proValue;
+      }
+    }
+  }
+  if (defineProps.base && defineProps.base.name) {
+    tempProps["name"] = defineProps.base.name;
+  }
+  if (defineProps.base && defineProps.base.prop) {
+    tempProps["prop"] = defineProps.base.prop;
+  }
+  if (defineProps.base && defineProps.base.title) {
+    tempProps["title"] = defineProps.base.title;
+  }
+  if (defineProps.base && defineProps.base.titleWidth) {
+    tempProps["labelWidth"] = defineProps.base.titleWidth + "px";
+  }
+  if (defineProps.base && defineProps.base.tittleShow) {
+    tempProps["tittleShow"] = true;
+  } else {
+    tempProps["tittleShow"] = false;
+  }
+  if (defineProps.base && defineProps.base.titlePosition) {
+    tempProps["titlePosition"] = defineProps.base.titlePosition;
+  }
+  if (defineProps.base && defineProps.base.defaultValue) {
+    tempProps["defaultValue"] = defineProps.base.defaultValue;
+  }
+  if (defineProps.base && defineProps.base.placeholder) {
+    tempProps["placeholder"] = defineProps.base.placeholder;
+  }
+  if (defineProps.base && defineProps.base.clearable) {
+    tempProps["clearable"] = true;
+  }
+  if (defineProps.base && defineProps.base.showInputNum) {
+    tempProps["showInputNum"] = true;
+  }
+  if (defineProps.base && defineProps.base.rows) {
+    tempProps["rows"] = defineProps.base.rows;
+  }
+  if (defineProps.base && defineProps.base.size) {
+    tempProps["size"] = defineProps.base.size;
+  }
+  if (defineProps.base && defineProps.base.state) {
+    tempProps["state"] = defineProps.base.state;
+  }
+  if (defineProps.scan && defineProps.scan.enable) {
+    tempProps["enable"] = true;
+  }
+  if (defineProps.verification && defineProps.verification.required) {
+    tempProps["required"] = true;
+  } else {
+    tempProps["required"] = false;
+  }
+  if (defineProps.verification && defineProps.verification.verificationType) {
+    tempProps["verificationType"] = defineProps.verification.verificationType;
+  }
+  if (defineProps.verification && defineProps.verification.verifyMinLength && defineProps.verification.minLength) {
+    tempProps["minLength"] = defineProps.verification.minLength;
+  }
+  if (defineProps.verification && defineProps.verification.verifyMaxLength && defineProps.verification.maxLength) {
+    tempProps["maxLength"] = defineProps.verification.maxLength;
+  }
+  if (defineProps.verification && defineProps.verification.verifyRegex && defineProps.verification.regex) {
+    tempProps["regex"] = defineProps.verification.regex;
+  }
+  const dataOrigin = configure.props && configure.props.dataOrigin ? configure.props.dataOrigin : {};
+  if (!dataOrigin.optionValueSetType || dataOrigin.optionValueSetType == "static") {
+    const options = [];
+    if (dataOrigin.staticStates) {
+      for (let o of dataOrigin.staticStates) {
+        if (o.label != void 0 && o.label != "") {
+          options.push(o);
+        }
+      }
+    }
+    tempProps["options"] = options;
+  }
+  const monitorFields = [];
+  if (defineProps.linkages) {
+    for (let l of defineProps.linkages) {
+      if (l.fieldName && !monitorFields.includes(l.fieldName)) {
+        monitorFields.push(l.fieldName);
+      }
+    }
+  }
+  const pageDesignUtil = pageStore.usePageContextStore();
+  const pageDesign = pageDesignUtil.pageContext;
+  if (pageDesign) {
+    if (!pageDesign.initOptionConfigs) {
+      pageDesign.initOptionConfigs = [];
+    }
+    let existIndex = -1;
+    for (let i = 0; i < pageDesign.initOptionConfigs.length; i++) {
+      const o = pageDesign.initOptionConfigs[i];
+      if (o.uuid == configure.uuid) {
+        existIndex = i;
+        break;
+      }
+    }
+    if (existIndex > -1) {
+      pageDesign.initOptionConfigs.shift(existIndex, 1);
+    }
+    const optionConf = pageHelperUtil.getComponentOptionConfigs(configure, pageDesign);
+    if (optionConf) {
+      if (dataOrigin)
+        pageDesign.initOptionConfigs.push(optionConf);
+      tempProps["optionconfigInfo"] = optionConf;
+      if (optionConf.props && optionConf.props.monitorFields) {
+        for (let fieldName of optionConf.props.monitorFields) {
+          if (fieldName && !monitorFields.includes(fieldName)) {
+            monitorFields.push(fieldName);
+          }
+        }
+      }
+    }
+  }
+  tempProps["monitorFields"] = monitorFields;
+  property.value = tempProps;
+}
+function removComponentOptionConfigs(configure) {
+  const pageDesignUtil = pageStore.usePageContextStore();
+  const pageDesign = pageDesignUtil.pageContext;
+  if (pageDesign) {
+    if (!pageDesign.initOptionConfigs) {
+      pageDesign.initOptionConfigs = [];
+    }
+    let existIndex = -1;
+    for (let i = 0; i < pageDesign.initOptionConfigs.length; i++) {
+      const o = pageDesign.initOptionConfigs[i];
+      if (o.uuid == configure.uuid) {
+        existIndex = i;
+        break;
+      }
+    }
+    if (existIndex > -1) {
+      pageDesign.initOptionConfigs.shift(existIndex, 1);
+    }
+  }
+}
+function columnTittleStyle(configure) {
+  const tempTittleStyle = {};
+  let defineStyle = {};
+  if (configure.style) {
+    for (let pro in configure.style) {
+      const proValue = configure.style[pro];
+      if (proValue != void 0 && proValue != null && proValue != "") {
+        defineStyle[pro] = proValue;
+      }
+    }
+  }
+  if (defineStyle.titleFontbold) {
+    tempTittleStyle["font-weight"] = "bold";
+  }
+  if (defineStyle.titleFontitalic) {
+    tempTittleStyle["font-style"] = "italic";
+  }
+  if (defineStyle.titleFontfontSize) {
+    tempTittleStyle["font-size"] = defineStyle.titleFontfontSize;
+  }
+  if (defineStyle.titleFontColor) {
+    tempTittleStyle["color"] = defineStyle.titleFontColor;
+  }
+  if (defineStyle.titleFontAlign) {
+    tempTittleStyle["text-align"] = defineStyle.titleFontAlign;
+  }
+  if (defineStyle.tittlePaddingTop) {
+    tempTittleStyle["padding-top"] = defineStyle.tittlePaddingTop + "px";
+  }
+  if (defineStyle.tittlePaddingRight) {
+    tempTittleStyle["padding-right"] = defineStyle.tittlePaddingRight + "px";
+  }
+  if (defineStyle.tittlePaddingBottom) {
+    tempTittleStyle["padding-bottom"] = defineStyle.tittlePaddingBottom + "px";
+  }
+  if (defineStyle.tittlePaddingLeft) {
+    tempTittleStyle["padding-left"] = defineStyle.tittlePaddingLeft + "px";
+  }
+  if (defineStyle.tittleStyleCustom) {
+    const strs = defineStyle.tittleStyleCustom.replace(/[\r\n]/g, "").split(";");
+    for (let index = 0; index < strs.length; index++) {
+      const ss = strs[index].split(":");
+      if (ss.length > 1 && ss[0] && ss[1]) {
+        if (!isNaN(ss[0])) {
+          continue;
+        }
+        tempTittleStyle[ss[0]] = ss[1];
+      }
+    }
+  }
+  return tempTittleStyle;
+}
+function columnCustomTittleClass(configure) {
+  let tempTittleClass = "";
+  let defineStyle = {};
+  if (configure.style) {
+    for (let pro in configure.style) {
+      const proValue = configure.style[pro];
+      if (proValue != void 0 && proValue != null && proValue != "") {
+        defineStyle[pro] = proValue;
+      }
+    }
+  }
+  if (defineStyle.tittleClassCustom) {
+    tempTittleClass += " " + defineStyle.tittleClassCustom.replace(/;/g, " ");
+  }
+  return tempTittleClass;
+}
+function watchRequiredValidate(pageDesign, configure, isRequired, fieldInfo) {
+  if (isRequired) {
+    if (!pageDesign.rules) {
+      pageDesign.rules = {};
+    }
+    const prop = configure.props.base.prop;
+    if (prop) {
+      const propName = getFormPropName(prop);
+      if (!pageDesign.rules[propName]) {
+        pageDesign.rules[propName] = [];
+      }
+      const validations = pageDesign.rules[propName];
+      const ruleIndex = validations.findIndex((item) => item.required);
+      if (ruleIndex !== void 0 && ruleIndex !== null && ruleIndex >= 0) {
+        validations.splice(ruleIndex, 1);
+      }
+      const rule = {
+        required: true,
+        message: `${configure.props.base.title}必填`,
+        label: configure.props.base.title
+      };
+      packageRuleByDataType(fieldInfo, rule);
+      pageDesign.rules[propName].push(rule);
+    }
+  } else {
+    const prop = configure.props.base.prop;
+    if (prop) {
+      const propName = getFormPropName(prop);
+      if (pageDesign.rules && pageDesign.rules[propName]) {
+        const validations = pageDesign.rules[propName];
+        const ruleIndex = validations.findIndex((item) => item.required);
+        if (ruleIndex !== void 0 && ruleIndex !== null && ruleIndex >= 0) {
+          validations.splice(ruleIndex, 1);
+        }
+      }
+    }
+  }
+}
+function watchValidateType(pageDesign, configure, type, fieldInfo) {
+  if (type) {
+    if (!pageDesign.rules) {
+      pageDesign.rules = {};
+    }
+    const prop = configure.props.base.prop;
+    if (prop) {
+      const propName = getFormPropName(prop);
+      if (!pageDesign.rules[propName]) {
+        pageDesign.rules[propName] = [];
+      }
+      const validations = pageDesign.rules[propName];
+      const ruleIndex = validations.findIndex((item) => item.type === type);
+      if (ruleIndex !== void 0 && ruleIndex !== null && ruleIndex >= 0) {
+        validations.splice(ruleIndex, 1);
+      }
+      const rule = {
+        type,
+        message: `${configure.props.base.title}格式不匹配`,
+        label: configure.props.base.title,
+        myType: type
+        // 删除格式时需要用该属性
+      };
+      packageStringRuleByDataType(fieldInfo, type, rule);
+      pageDesign.rules[propName].push(rule);
+    }
+  } else {
+    const prop = configure.props.base.prop;
+    if (prop) {
+      const propName = getFormPropName(prop);
+      if (pageDesign.rules && pageDesign.rules[propName]) {
+        const validations = pageDesign.rules[propName];
+        const ruleIndex = validations.findIndex((item) => item.myType);
+        if (ruleIndex !== void 0 && ruleIndex !== null && ruleIndex >= 0) {
+          validations.splice(ruleIndex, 1);
+        }
+      }
+    }
+  }
+}
+function watchPatternValidate(pageDesign, configure, pattern, fieldInfo) {
+  if (configure.props.verification && configure.props.verification.verifyRegex && pattern) {
+    if (!pageDesign.rules) {
+      pageDesign.rules = {};
+    }
+    const prop = configure.props.base.prop;
+    if (prop) {
+      const propName = getFormPropName(prop);
+      if (!pageDesign.rules[propName]) {
+        pageDesign.rules[propName] = [];
+      }
+      const validations = pageDesign.rules[propName];
+      const ruleIndex = validations.findIndex((item) => item.patternType);
+      if (ruleIndex !== void 0 && ruleIndex !== null && ruleIndex >= 0) {
+        validations.splice(ruleIndex, 1);
+      }
+      const rule = {
+        pattern,
+        message: `${configure.props.base.title}格式不匹配`,
+        label: configure.props.base.title,
+        patternType: "pattern"
+        // 删除格式时需要用该属性
+      };
+      packageRuleByDataType(fieldInfo, rule);
+      pageDesign.rules[propName].push(rule);
+    }
+  } else {
+    const prop = configure.props.base.prop;
+    if (prop) {
+      const propName = getFormPropName(prop);
+      if (pageDesign.rules && pageDesign.rules[propName]) {
+        const validations = pageDesign.rules[propName];
+        const ruleIndex = validations.findIndex((item) => item.patternType);
+        if (ruleIndex !== void 0 && ruleIndex !== null && ruleIndex >= 0) {
+          validations.splice(ruleIndex, 1);
+        }
+      }
+    }
+  }
+}
+function watchMaxOrMinValidate(pageDesign, configure, type, isEnable, value, fieldInfo) {
+  if (isEnable && type && value !== void 0 && value !== null) {
+    if (!pageDesign.rules) {
+      pageDesign.rules = {};
+    }
+    const prop = configure.props.base.prop;
+    if (prop) {
+      const propName = getFormPropName(prop);
+      if (!pageDesign.rules[propName]) {
+        pageDesign.rules[propName] = [];
+      }
+      const validations = pageDesign.rules[propName];
+      const ruleIndex = validations.findIndex((item) => item[type]);
+      if (ruleIndex !== void 0 && ruleIndex !== null && ruleIndex >= 0) {
+        validations.splice(ruleIndex, 1);
+      }
+      const rule = {
+        label: configure.props.base.title
+      };
+      rule[type] = value;
+      if (type === "max") {
+        rule["message"] = `${configure.props.base.title}最多只能输入${value}字符`;
+      } else {
+        rule["message"] = `${configure.props.base.title}至少输入${value}字符`;
+      }
+      packageRuleByDataType(fieldInfo, rule);
+      pageDesign.rules[propName].push(rule);
+    }
+  } else {
+    const prop = configure.props.base.prop;
+    if (prop) {
+      const propName = getFormPropName(prop);
+      if (pageDesign.rules && pageDesign.rules[propName]) {
+        const validations = pageDesign.rules[propName];
+        const ruleIndex = validations.findIndex((item) => item[type]);
+        if (ruleIndex !== void 0 && ruleIndex !== null && ruleIndex >= 0) {
+          validations.splice(ruleIndex, 1);
+        }
+      }
+    }
+  }
+}
+function deleteRule(pageDesign, configure) {
+  if (!configure.props || !configure.props.base) {
+    return;
+  }
+  const prop = configure.props.base.prop;
+  if (prop) {
+    const propName = getFormPropName(prop);
+    if (pageDesign.rules && pageDesign.rules[propName]) {
+      delete pageDesign.rules[propName];
+    }
+  }
+}
+function getFormPropName(prop) {
+  if (prop && prop.indexOf("${") >= 0) {
+    return prop.substring(prop.indexOf(".") + 1, prop.lastIndexOf("}"));
+  } else {
+    return prop;
+  }
+}
+function packageRuleByDataType(fieldInfo, rule) {
+  if (!fieldInfo || !fieldInfo.dataType) {
+    return;
+  }
+  const dataType = fieldInfo.dataType;
+  if (dataType === "DATE" || dataType === "TIME") {
+    rule.type = "number";
+  } else if (dataType === "INTEGER" || dataType === "LONG") {
+    rule.type = "number";
+  } else if (dataType === "FLOAT" || dataType === "DOUBLE") {
+    if (!rule.pattern) {
+      rule.pattern = new RegExp("^(-?\\d+)(\\.\\d+)?$");
+    }
+  }
+  rule.trigger = "blur";
+}
+function packageStringRuleByDataType(fieldInfo, type, rule) {
+  if (!fieldInfo || !fieldInfo.dataType) {
+    return;
+  }
+  const dataType = fieldInfo.dataType;
+  if (dataType && dataType === "TEXT") {
+    if (type === "integer") {
+      rule.pattern = new RegExp("^-?d+$");
+    } else if (type === "number") {
+      rule.validator = function(rule2, value, callback) {
+        const integerRegx = new RegExp("^-?d+$");
+        const floatRegx = new RegExp("^(-?\\d+)(\\.\\d+)?$");
+        if (value === void 0 || value === null) {
+          return true;
+        } else if (integerRegx.test(value)) {
+          return true;
+        } else if (floatRegx.test(value)) {
+          return true;
+        }
+        return false;
+      };
+    } else if (type === "float") {
+      rule.pattern = new RegExp("^(-?\\d+)(\\.\\d+)?$");
+    }
+    rule.trigger = "blur";
+  }
+}
+exports.caculateComponentProps = caculateComponentProps;
+exports.caculateDetailComponentStyle = caculateDetailComponentStyle;
+exports.columnCustomTittleClass = columnCustomTittleClass;
+exports.columnTittleStyle = columnTittleStyle;
+exports.deleteRule = deleteRule;
+exports.removComponentOptionConfigs = removComponentOptionConfigs;
+exports.watchMaxOrMinValidate = watchMaxOrMinValidate;
+exports.watchPatternValidate = watchPatternValidate;
+exports.watchRequiredValidate = watchRequiredValidate;
+exports.watchValidateType = watchValidateType;

package/dist/lib/components/design/utils/interfaces/page-design-types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var EnableStates = /* @__PURE__ */ ((EnableStates2) => {
+  EnableStates2["ENABLE"] = "ENABLE";
+  EnableStates2["DISABLE"] = "DISABLE";
+  return EnableStates2;
+})(EnableStates || {});
+var PageDimensions = /* @__PURE__ */ ((PageDimensions2) => {
+  PageDimensions2["PC"] = "pc";
+  PageDimensions2["IPAD"] = "ipad";
+  PageDimensions2["PHONE"] = "phone";
+  return PageDimensions2;
+})(PageDimensions || {});
+exports.EnableStates = EnableStates;
+exports.PageDimensions = PageDimensions;

package/dist/lib/components/design/utils/page-design-util.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const http = require("agilebuilder-ui/src/utils/request");
+const system = require("./system.js");
+function queryWorkflowsRequest(tableName) {
+  const params = {
+    appCode: system.getSystemCode(),
+    publishVersion: system.getPublishVersion(),
+    tableName
+  };
+  return http.post(
+    window["$vueApp"].config.globalProperties.baseAPI + "/component/super-page-design/workflow-definitions",
+    params
+  );
+}
+function createWorkflowRequest(tableName, pageName) {
+  const params = {
+    appCode: system.getSystemCode(),
+    publishVersion: system.getPublishVersion(),
+    tableName,
+    pageName
+  };
+  return http.post(
+    window["$vueApp"].config.globalProperties.baseAPI + "/component/super-page-design/workflow-definitions/create",
+    params
+  );
+}
+function getHighestVersionDefinition(wfDefinitionCode, defVersion) {
+  const params = {
+    wfDefinitionCode,
+    publishVersion: system.getPublishVersion()
+  };
+  if (defVersion !== void 0) {
+    params["defVersion"] = defVersion;
+  }
+  return http.post(
+    window["$vueApp"].config.globalProperties.baseAPI + "/component/super-page-design/get-workflow-definition",
+    params
+  );
+}
+exports.createWorkflowRequest = createWorkflowRequest;
+exports.getHighestVersionDefinition = getHighestVersionDefinition;
+exports.queryWorkflowsRequest = queryWorkflowsRequest;

package/dist/lib/components/design/utils/page-explore-util.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function convertToExploreTreeDatas(designItems, searchItemName, cachePageItemMap, eventResult) {
+  console.log("页面大纲树的管理类----designItems=", designItems);
+  const topItem = {
+    uuid: "-1",
+    label: "页面",
+    name: "page",
+    componentIndex: -1
+  };
+  if (!designItems || designItems.length == 0) {
+    return [topItem];
+  }
+  const treeItems = [];
+  for (let index = 0; index < designItems.length; index++) {
+    const treeItem = convertPageItemToTreeItem(designItems[index], searchItemName, cachePageItemMap, eventResult);
+    if (treeItem) {
+      treeItems.push(treeItem);
+    }
+  }
+  topItem.children = treeItems;
+  return [topItem];
+}
+function convertPageItemToTreeItem(pageItem, searchItemName, cachePageItemMap, eventResult) {
+  const children = [];
+  if (pageItem.items && pageItem.items.length > 0) {
+    for (let index = 0; index < pageItem.items.length; index++) {
+      const childItem = convertPageItemToTreeItem(pageItem.items[index], searchItemName, cachePageItemMap, eventResult);
+      if (childItem != null) {
+        children.push(childItem);
+      }
+    }
+  }
+  let isHas = true;
+  if (children.length == 0 && searchItemName) {
+    isHas = false;
+    if (pageItem.type && pageItem.type.indexOf(searchItemName) > -1 || pageItem.label && pageItem.label.indexOf(searchItemName) > -1 || pageItem.name && pageItem.name.indexOf(searchItemName) > -1) {
+      isHas = true;
+    }
+  }
+  if (isHas) {
+    const treeItem = {
+      componentIndex: pageItem.componentIndex,
+      name: pageItem.name,
+      label: pageItem.label,
+      uuid: pageItem.uuid,
+      children
+    };
+    if (cachePageItemMap != null && pageItem.componentIndex) {
+      cachePageItemMap.value[pageItem.componentIndex] = pageItem;
+    }
+    if (eventResult != null && pageItem.componentIndex && pageItem.events) {
+      const filteredEvents = pageItem.events.filter((event) => event.eventName !== void 0 && event.eventName !== null && event.eventName !== "");
+      if (filteredEvents && filteredEvents.length > 0) {
+        filteredEvents.forEach((event) => {
+          event.componentName = pageItem.name;
+          event.componentLabel = pageItem.label;
+          event.componentUuid = pageItem.uuid;
+          event.componentProp = pageItem.prop;
+          event.componentIndex = pageItem.componentIndex;
+        });
+        eventResult.value = eventResult.value.concat(filteredEvents);
+      }
+    }
+    return treeItem;
+  } else {
+    return null;
+  }
+}
+exports.convertToExploreTreeDatas = convertToExploreTreeDatas;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@vueuse/core");
+function initComponentRefState(pageDesign) {
+  const state = getComponentRefCache(pageDesign);
+  state.value = {};
+  return state;
+}
+function getComponentRefCache(pageDesign) {
+  const cacheKey = getPageRefKey(pageDesign.code, pageDesign.version);
+  return core.useStorage(cacheKey, {}, sessionStorage);
+}
+function addComponentRef(pageDesign, componentIndex, refObj) {
+  const state = getComponentRefCache(pageDesign);
+  state.value[componentIndex] = refObj;
+  return state;
+}
+function getPageRefKey(pageCode, pageVersion) {
+  return "pageDesignRef-" + pageCode + "-" + (pageVersion ? pageVersion : 1);
+}
+exports.addComponentRef = addComponentRef;
+exports.initComponentRefState = initComponentRefState;