super-page-designer 0.0.1-tmp1

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/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;