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

package/dist/lib/components/runtime/utils/events/validator-util.js

@@ -0,0 +1,730 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index$1 = require("../../../../node_modules/.pnpm/async-validator@4.2.5/node_modules/async-validator/dist-web/index.js");
+const globalRefs = require("../global-refs.js");
+const util = require("../../../../node_modules/.pnpm/agilebuilder-ui@1.1.58_@vue_29e6d749740d5c0a82211de8e577b320/node_modules/agilebuilder-ui/src/utils/util.js");
+const standardEvent = require("./standard-event.js");
+const commonUtil$1 = require("../../../../node_modules/.pnpm/agilebuilder-ui@1.1.58_@vue_29e6d749740d5c0a82211de8e577b320/node_modules/agilebuilder-ui/src/utils/common-util.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 commonUtil = require("../common-util.js");
+const index = require("../../../../node_modules/.pnpm/element-plus@2.10.5_vue@3.5.18_typescript@5.4.5_/node_modules/element-plus/es/components/message/index.js");
+function setObjectPropRule(prop, rules, leafRule) {
+  const rule = {};
+  if (!rules) {
+    rules = {};
+  }
+  let num = 0;
+  const props = prop.split(".");
+  props.forEach((subProp) => {
+    let objectRule;
+    if (num === props.length - 1) {
+      objectRule = getEndObjectRule(rule, props, subProp);
+      objectRule.fields[subProp] = leafRule;
+    } else {
+      let lastObjectRule;
+      if (num === 0) {
+        objectRule = rules;
+      } else {
+        lastObjectRule = getLastObjectRule(rule, props, props[num - 1]);
+        objectRule = lastObjectRule.fields;
+      }
+      if (!objectRule[subProp]) {
+        objectRule[subProp] = {
+          type: "object",
+          required: true,
+          fields: {}
+        };
+      }
+      if (num === 0) {
+        rule[subProp] = objectRule[subProp];
+      } else {
+        lastObjectRule.fields[subProp] = objectRule[subProp];
+      }
+    }
+    num++;
+  });
+  return rule;
+}
+function getLastObjectRule(rule, props, currentProp) {
+  let lastObjectdRule;
+  for (let i = 0; i < props.length; i++) {
+    const subProp = props[i];
+    if (i === 0) {
+      lastObjectdRule = rule[subProp];
+    } else {
+      lastObjectdRule = lastObjectdRule.fields[props[i]];
+    }
+    if (subProp === currentProp) {
+      break;
+    }
+  }
+  return lastObjectdRule;
+}
+function getEndObjectRule(rule, props, currentProp) {
+  let lastObjectdRule;
+  for (let i = 0; i < props.length; i++) {
+    if (i === 0) {
+      lastObjectdRule = rule[props[i]];
+    } else {
+      lastObjectdRule = lastObjectdRule.fields[props[i]];
+    }
+    if (i !== props.length - 1) {
+      const leafSubProp = props[i + 1];
+      if (leafSubProp === currentProp) {
+        break;
+      }
+    }
+  }
+  return lastObjectdRule;
+}
+function getValidator(columns) {
+  const rules = {};
+  return rules;
+}
+function validator(entity, rules, columns, rowIndex, isSql, pageContext) {
+  return validatorEntity(entity, rules, columns, rowIndex, true, isSql, pageContext);
+}
+function sublistVerify(rules) {
+  if (!rules) {
+    return;
+  }
+  Object.keys(rules).forEach((item) => {
+    if (item.indexOf(".") >= 0) {
+      let ruleKetArr = [];
+      ruleKetArr = item.split(".");
+      if (rules[ruleKetArr[0]]) {
+        rules[ruleKetArr[0]].fields[ruleKetArr[1]] = rules[item][0];
+      } else {
+        rules[ruleKetArr[0]] = new Object();
+        rules[ruleKetArr[0]].fields = new Object();
+        rules[ruleKetArr[0]].fields[ruleKetArr[1]] = rules[item][0];
+        rules[ruleKetArr[0]].type = "object";
+      }
+      delete rules[item];
+    }
+  });
+  return rules;
+}
+function validatorEntity(entity, rules, columns, rowIndex, isShouldRepeateValdate, isSql, pageContext) {
+  let validateRules = sublistVerify(rules);
+  if ((!rules || rules === null) && columns) {
+    validateRules = getValidator();
+  }
+  if (!validateRules || Object.keys(validateRules).length === 0) {
+    entity["validateErrorField"] = "";
+    return true;
+  }
+  let result;
+  const validator2 = new index$1(validateRules);
+  validator2.validate(
+    entity,
+    {
+      first: true
+    },
+    (errors, fields) => {
+      let fieldName;
+      if (errors) {
+        result = errors[0].message;
+        fieldName = errors[0]["field"];
+        index.ElMessage({
+          message: result,
+          showClose: true,
+          type: "warning",
+          duration: 3 * 1e3
+        });
+        const itemRef = globalRefs.getComponentRefByCode(pageContext, fieldName);
+        if (itemRef && itemRef.addRequiredClass) {
+          itemRef.addRequiredClass();
+        }
+        console.log("errors", errors, "fields", fields);
+      } else {
+        result = true;
+      }
+      if (fieldName && isShouldRepeateValdate === true) {
+        const reg1 = /[A-Z]+/;
+        if (reg1.test(fieldName) && entity[fieldName.toLowerCase()] !== void 0) {
+          const copyEntity = JSON.parse(JSON.stringify(entity));
+          copyEntity[fieldName.toUpperCase()] = entity[fieldName.toLowerCase()];
+          delete copyEntity[fieldName.toLowerCase()];
+          result = validatorEntity(copyEntity, rules, columns, rowIndex, false, isSql, pageContext);
+        }
+      }
+    }
+  );
+  return result;
+}
+function validateDataModelFunc(pageContext, configureObj, isEnableRequired) {
+  const dataModel = pageContext.entity.data;
+  const pageModel = pageContext.entity.page;
+  const data = { ...pageModel, ...dataModel };
+  const rules = pageContext.rules;
+  const isEnableRequiredSetting = configureObj.props.base ? configureObj.props.base.isEnableRequired : null;
+  if (isEnableRequiredSetting !== void 0 && isEnableRequiredSetting !== null) {
+    isEnableRequired = isEnableRequiredSetting;
+  }
+  if (typeof isEnableRequired === "undefined" || isEnableRequired === null) {
+    isEnableRequired = false;
+  }
+  return validateDataModel(isEnableRequired, data, rules, pageContext);
+}
+function validateDataModel(isEnableRequired, dataModel, rules, pageContext) {
+  if (isEnableRequired) {
+    const isWorkflow = commonUtil.isWorkflowPage(pageContext);
+    if (isWorkflow) {
+      return validateWorkflowFormDataModel(dataModel, pageContext, rules);
+    } else {
+      return validateCommonFormDataModel(dataModel, pageContext, rules);
+    }
+  } else {
+    return new Promise((resolve, reject) => {
+      resolve(true);
+    });
+  }
+}
+function validateWorkflowFormDataModel(dataModel, pageContext, rules) {
+  return new Promise((resolve, reject) => {
+    const additionalParamMap = standardEvent.getAdditionalParamMap(pageContext);
+    const contextParameter = pageContext.entity.context;
+    const taskParamMap = pageContext.entity.task;
+    const isSql = true;
+    const subTablePageInfo = pageContext.subTablePageInfo;
+    validateCommon(dataModel, pageContext, rules).then((validateResult) => {
+      if (validateResult) {
+        let result = validateResult;
+        let fieldName;
+        let subTableModelName;
+        let rowIndex;
+        let pageNum;
+        const workflowFieldPermissionRules = pageContext.workflowRules;
+        if (!workflowFieldPermissionRules) {
+          result = true;
+        } else {
+          if (!validateSubTableNotEmpty(pageContext, dataModel)) {
+            resolve(false);
+            return;
+          }
+          const isNeedField = true;
+          const validateWfResult = window["$vueApp"].config.globalProperties.$formValidator(
+            dataModel,
+            workflowFieldPermissionRules,
+            isSql,
+            additionalParamMap,
+            taskParamMap,
+            contextParameter,
+            subTablePageInfo,
+            isNeedField
+          );
+          result = validateWfResult.msg;
+          fieldName = validateWfResult.field;
+          subTableModelName = validateWfResult.listCode;
+          rowIndex = validateWfResult.rowIndex;
+          pageNum = validateWfResult.pageNum;
+        }
+        if (result !== true) {
+          index.ElMessage({
+            showClose: true,
+            message: result + "",
+            type: "warning"
+          });
+          if (subTableModelName) {
+            const tableRef = globalRefs.getComponentRefByCode(pageContext, subTableModelName);
+            if (tableRef && tableRef.addRequiredClass) {
+              tableRef.addRequiredClass(fieldName, rowIndex, pageNum);
+            }
+          } else {
+            const itemRef = globalRefs.getComponentRefByCode(pageContext, fieldName);
+            if (itemRef && itemRef.addRequiredClass) {
+              itemRef.addRequiredClass();
+            }
+          }
+          resolve(false);
+        } else {
+          if (Object.keys(dataModel).indexOf("validateErrorField") >= 0) {
+            delete dataModel.validateErrorField;
+          }
+          resolve(dataModel);
+        }
+      } else {
+        reject(new Error(util.getI18n().t("superPageRuntimeMessage.formDataVerificationFailed")).message);
+      }
+    }).catch((error) => {
+      reject(error);
+    });
+  });
+}
+function validateSubTableNotEmpty(pageContext, dataModel) {
+  var _a, _b, _c;
+  if (!pageContext.actionPermissions) {
+    return true;
+  }
+  const keys = Object.keys(pageContext.actionPermissions);
+  for (let index$12 = 0; index$12 < keys.length; index$12++) {
+    const subTableModelName = keys[index$12];
+    const action = pageContext.actionPermissions[subTableModelName];
+    if (action && action.notEmpty) {
+      let isEmpty = false;
+      if (dataModel[subTableModelName]) {
+        if (Array.isArray(dataModel[subTableModelName]) && dataModel[subTableModelName].length === 0) {
+          isEmpty = true;
+        }
+      } else {
+        isEmpty = true;
+      }
+      if (isEmpty) {
+        const tableRef = globalRefs.getComponentRefByCode(pageContext, subTableModelName);
+        const tableConfig = tableRef.getConfigure();
+        if ((_a = action.notEmptyCondition) == null ? void 0 : _a.parentCondition) {
+          const result = calculatorUtil.parseSubTablePermissionCondition(
+            action.notEmptyCondition.parentCondition.replaceAll("${field[", "${parent["),
+            pageContext.dataTypeMaps,
+            dataModel,
+            {},
+            (_b = pageContext.entity) == null ? void 0 : _b.request,
+            (_c = pageContext.entity) == null ? void 0 : _c.task,
+            pageContext.contextParam
+          );
+          if (result === false) {
+            return true;
+          }
+        }
+        index.ElMessage({
+          showClose: true,
+          message: util.getI18n().t("superPageRuntimeMessage.xxxNotEmpty", {
+            label: tableConfig.title ? tableConfig.title : subTableModelName
+          }),
+          type: "warning"
+        });
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function validateCustomRefValidator(pageContext) {
+  return new Promise((resolve, reject) => {
+    const validatorResult = [];
+    const customUuids = pageContext.customValidatorUuids;
+    if (customUuids) {
+      customUuids.forEach((componentUuid) => {
+        const customRef = globalRefs.getComponentRef(pageContext, componentUuid);
+        if (customRef && customRef.validator) {
+          validatorResult.push(customRef.validator());
+        }
+      });
+    }
+    if (validatorResult && validatorResult.length > 0) {
+      Promise.all(validatorResult).then((values) => {
+        if (values.includes(false)) {
+          resolve(false);
+        } else {
+          resolve(true);
+        }
+      });
+    } else {
+      resolve(true);
+    }
+  });
+}
+function validateCommon(dataModel, pageContext, rules) {
+  return new Promise((resolve, reject) => {
+    const handleModels = JSON.parse(JSON.stringify(dataModel));
+    if (!rules || Object.keys(rules).length === 0) {
+      resolve(true);
+    } else {
+      const validateEntityResult = validator(handleModels, rules, null, null, true, pageContext);
+      if (validateEntityResult === true) {
+        const validateResult = validateSubTables(pageContext);
+        if (validateResult === true) {
+          const customRuleResult = validateCustomRuleEvents(pageContext);
+          if (customRuleResult && commonUtil$1.isPromise(customRuleResult)) {
+            customRuleResult.then((result) => {
+              if (result) {
+                validateCustomRefValidator(pageContext).then((customRefValidResult) => {
+                  resolve(customRefValidResult);
+                });
+              } else {
+                resolve(false);
+              }
+            });
+          } else {
+            validateCustomRefValidator(pageContext).then((customRefValidResult) => {
+              resolve(customRefValidResult);
+            });
+          }
+        } else {
+          reject(new Error(util.getI18n().t("superPageRuntimeMessage.tableListSubTableDataVerificationFailed")).message);
+        }
+      } else {
+        reject(new Error(util.getI18n().t("superPageRuntimeMessage.formDataVerificationFailed")).message);
+      }
+    }
+  });
+}
+function validateCommonFormDataModel(dataModel, pageContext, rules) {
+  return new Promise((resolve, reject) => {
+    validateCommon(dataModel, pageContext, rules).then((validateResult) => {
+      if (validateResult) {
+        const handleModels = JSON.parse(JSON.stringify(dataModel));
+        if (Object.keys(handleModels).indexOf("validateErrorField") >= 0) {
+          delete handleModels.validateErrorField;
+        }
+        resolve(handleModels);
+      } else {
+        resolve(false);
+      }
+    }).catch((error) => {
+      reject(error);
+    });
+  });
+}
+function packageCustomRules(orgCustomRules, orgRules) {
+  if (!orgCustomRules) {
+    return orgRules;
+  }
+  if (!orgRules) {
+    orgRules = {};
+  }
+  const customRulesKeys = Object.keys(orgCustomRules);
+  const customRules = orgCustomRules;
+  customRulesKeys.forEach((key) => {
+    if (key === "__subRules") {
+      const subRules = customRules["__subRules"];
+      const customSubTableKey = Object.keys(subRules);
+      customSubTableKey.forEach((subTableKey) => {
+        if (!orgRules.subRules) {
+          orgRules["subRules"] = {};
+        }
+        if (orgRules.subRules[subTableKey]) {
+          Object.assign(orgRules.subRules[subTableKey], subRules[subTableKey]);
+        } else {
+          orgRules.subRules[subTableKey] = subRules[subTableKey];
+        }
+      });
+    } else {
+      packageCustomValidator(customRules[key]);
+      orgRules[key] = customRules[key];
+    }
+  });
+  return sublistVerify(orgRules);
+}
+function validateSubTables(pageContext) {
+  var _a;
+  if (!pageContext) {
+    return true;
+  }
+  const tableUuidArr = pageContext.tableUuids;
+  if (!tableUuidArr) {
+    return true;
+  }
+  for (let i = 0; i < tableUuidArr.length; i++) {
+    const tableUuid = tableUuidArr[i];
+    const refDom = globalRefs.getComponentRef(pageContext, tableUuid);
+    if (refDom) {
+      if (refDom.getConfigure()) {
+        const tableConfig = refDom.getConfigure();
+        if ((_a = tableConfig == null ? void 0 : tableConfig.verification) == null ? void 0 : _a.notEmpty) {
+          const tableData = refDom.getTableData();
+          if (!tableData || !Array.isArray(tableData) || tableData.length === 0) {
+            index.ElMessage({
+              showClose: true,
+              message: util.getI18n().t("superPageRuntimeMessage.xxxNotEmpty", {
+                label: tableConfig.title ? tableConfig.title : tableConfig.code
+              }),
+              type: "warning"
+            });
+            return false;
+          }
+        }
+      }
+      const flag = refDom.validatorSunTableListData();
+      if (!flag) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function i18nValidateRulesMessage(rules) {
+  if (!rules || Object.keys(rules).length === 0) {
+    return;
+  }
+  const newRules = {};
+  const propNames = Object.keys(rules);
+  for (let i = 0; i < propNames.length; i++) {
+    const propName = propNames[i];
+    const propRules = rules[propName];
+    i18nValidatePropRulesMessage(propRules);
+    if (propName.indexOf(".") > 0) {
+      setObjectPropRule(propName, newRules, propRules);
+    } else {
+      if (propRules && propRules.length > 0) {
+        newRules[propName] = [...propRules];
+      }
+    }
+  }
+  return newRules;
+}
+function i18nValidatePropRulesMessage(propRules, isResetMessage) {
+  propRules.forEach((rule) => {
+    if (rule.message && false) ;
+    const label = rule["label"];
+    const i18nLabel = util.getI18n().t(label);
+    if (rule["required"]) {
+      rule["message"] = util.getI18n().t("superPageRuntimeMessage.required", { label: i18nLabel });
+    }
+    if (rule["myType"]) {
+      rule["message"] = util.getI18n().t("superPageRuntimeMessage.formatMismatch", {
+        label: i18nLabel
+      });
+    }
+    if (rule["patternType"]) {
+      rule["message"] = util.getI18n().t("superPageRuntimeMessage.formatMismatch", {
+        label: i18nLabel
+      });
+    }
+    if (rule["max"] !== void 0 && rule["max"] !== null) {
+      rule["message"] = util.getI18n().t("superPageRuntimeMessage.overMaxLength", {
+        label: i18nLabel,
+        value: rule["max"]
+      });
+    }
+    if (rule["min"] !== void 0 && rule["min"] !== null) {
+      rule["message"] = util.getI18n().t("superPageRuntimeMessage.limitMinLength", {
+        label: i18nLabel,
+        value: rule["min"]
+      });
+    }
+  });
+}
+function getWorkflowRules(pageContext) {
+  const dataModel = pageContext.entity.data;
+  const pageModel = pageContext.entity.page;
+  const data = { ...pageModel, ...dataModel };
+  const additionalParamMap = standardEvent.getAdditionalParamMap(pageContext);
+  const contextParameter = pageContext.entity.context;
+  const taskParamMap = pageContext.entity.task;
+  const isSql = true;
+  if (pageContext.formPropTiltleMap && Object.keys(pageContext.formPropTiltleMap).length > 0) {
+    if (pageContext.completeTaskParam.fieldPermissions && pageContext.completeTaskParam.fieldPermissions.length > 0) {
+      pageContext.completeTaskParam.fieldPermissions.forEach((item) => {
+        if (item.name && pageContext.formPropTiltleMap[item.name]) {
+          item.label = pageContext.formPropTiltleMap[item.name];
+        }
+      });
+    }
+  }
+  let workflowFieldPermissionRules = window["$vueApp"].config.globalProperties.$getValidator(
+    pageContext.completeTaskParam.fieldPermissions,
+    data,
+    isSql,
+    additionalParamMap,
+    taskParamMap,
+    contextParameter
+  );
+  const customRules = pageContext.customRules;
+  workflowFieldPermissionRules = packageCustomRules(customRules, workflowFieldPermissionRules);
+  return workflowFieldPermissionRules;
+}
+function validateCustomRuleEvents(pageContext) {
+  const result = [];
+  if (pageContext.customRuleEvents && pageContext.customRuleEvents.length > 0) {
+    pageContext.customRuleEvents.forEach((event) => {
+      event.events.forEach((eventName) => {
+        const eventFun = pageContext.customEvents[eventName];
+        result.push(eventFun.apply(eventFun, [{ prop: event.prop, pageContext }]));
+      });
+    });
+  }
+  if (result && result.length > 0) {
+    return new Promise((resolve, reject) => {
+      const promiseResults = [];
+      const booleanResults = [];
+      result.forEach((validateResult) => {
+        if (commonUtil$1.isPromise(validateResult)) {
+          promiseResults.push(validateResult);
+        } else {
+          booleanResults.push(validateResult);
+        }
+      });
+      if (booleanResults.includes(false)) {
+        resolve(false);
+      }
+      if (promiseResults.length > 0) {
+        Promise.all(promiseResults).then((values) => {
+          if (values.includes(false)) {
+            resolve(false);
+          } else {
+            resolve(true);
+          }
+        }).catch((error) => {
+          console.error(error);
+          resolve(false);
+        });
+      } else {
+        resolve(true);
+      }
+    });
+  }
+  return null;
+}
+function updateFormItemEditState(pageContext, customRules) {
+  if (!customRules) {
+    return;
+  }
+  const formatCustomRules = {};
+  customRules.forEach((rule) => {
+    const { name, rules: rules2 } = rule;
+    if (rules2) {
+      formatCustomRules[name] = rules2;
+    } else {
+      if (rule.required === false) {
+        formatCustomRules[name] = [];
+      }
+    }
+  });
+  let rules = pageContext.rules ? pageContext.rules : {};
+  rules = packageCustomRules(formatCustomRules, rules);
+  pageContext.rules = rules;
+  let workflowRules = pageContext.workflowRules ? pageContext.workflowRules : {};
+  workflowRules = packageCustomRules(formatCustomRules, workflowRules);
+  pageContext.workflowRules = workflowRules;
+  const allFields = customRules.filter((item) => item.name === "_all_fields");
+  if (allFields && allFields.length > 0) {
+    updateAllFieldsState(pageContext, allFields[0]);
+  }
+  customRules.forEach((item) => {
+    if (item.name !== "_all_fields") {
+      const ref = globalRefs.getComponentRefByCode(pageContext, item.name);
+      updateComponentDisplayState(ref, item);
+    }
+  });
+}
+function disabledAllFields(pageContext) {
+  updateAllFieldsState(pageContext, { disabled: true });
+}
+function updateAllFieldsState(pageContext, stateObj) {
+  const allComponetRefs = globalRefs.getAllComponentRefs(pageContext);
+  if (allComponetRefs) {
+    for (const prop in allComponetRefs) {
+      const componentRefProxy = allComponetRefs[prop];
+      const componentRef = componentRefProxy ? componentRefProxy.value : componentRefProxy;
+      updateComponentDisplayState(componentRef, stateObj);
+    }
+  }
+}
+function dynamicControlTableEdit(pageContext, customRules, tableCode) {
+  var _a;
+  let gridRef;
+  let tableUuid;
+  if (tableCode) {
+    gridRef = globalRefs.getComponentRefByCode(pageContext, tableCode);
+    tableUuid = gridRef ? gridRef.getTableUuid() : null;
+  } else {
+    tableUuid = pageContext.tableUuids && pageContext.tableUuids.length > 0 ? pageContext.tableUuids[0] : null;
+    gridRef = tableUuid ? globalRefs.getComponentRef(pageContext, tableUuid) : null;
+  }
+  if (!gridRef) {
+    return;
+  }
+  const pageCode = pageContext.code;
+  const pageVersion = pageContext.version;
+  const listCode = commonUtil.getListCode(pageCode, pageVersion, tableUuid);
+  if (((_a = pageContext.workflowRules) == null ? void 0 : _a.subRules) && pageContext.workflowRules.subRules[tableCode]) {
+    const subRules = pageContext.workflowRules.subRules[tableCode];
+    customRules.forEach((rule) => {
+      subRules[rule.name] = rule;
+    });
+  }
+  gridRef.dynamicControlTableEdit(pageContext, customRules, listCode);
+}
+function updateComponentDisplayState(ref, item) {
+  var _a, _b, _c;
+  if (ref) {
+    const configure = ref.getConfigure();
+    if (item.show !== void 0) {
+      item.show ? ref.show() : ref.hide();
+    }
+    if (item.required !== void 0 && ((_a = configure == null ? void 0 : configure.runtime) == null ? void 0 : _a.props)) {
+      configure.runtime.props.required = item.required;
+    }
+    if (item.readonly !== void 0 && ((_b = configure == null ? void 0 : configure.runtime) == null ? void 0 : _b.props)) {
+      item.readonly ? configure.runtime.props.state = "readonly" : configure.runtime.props.state = "enabled";
+    }
+    if (item.disabled !== void 0 && configure) {
+      if ((_c = configure == null ? void 0 : configure.runtime) == null ? void 0 : _c.props) {
+        item.disabled ? configure.runtime.props.state = "disabled" : configure.runtime.props.state = "enabled";
+      }
+      if (configure.name === "table") {
+        ref.changeOperationAddState(false);
+      }
+    }
+  }
+}
+function packageCustomValidator(fieldRule) {
+  if (!(fieldRule == null ? void 0 : fieldRule.type)) {
+    return;
+  }
+  const config = validatorConfigs[fieldRule.type];
+  if (config) {
+    fieldRule.validator = config.validator;
+  }
+}
+const validatorConfigs = {
+  boolean: {
+    validator: function(rule, value, callback) {
+      const requiredResult = handleRequiredCheck(rule, value);
+      if (requiredResult !== true) {
+        return false;
+      }
+      if (typeof value === "number" && (value === 1 || value === 0)) {
+        return true;
+      } else if (typeof value === "boolean" && (value === true || value === false)) {
+        return true;
+      }
+      return false;
+    }
+  },
+  date: {
+    validator: function(rule, value, callback) {
+      const requiredResult = handleRequiredCheck(rule, value);
+      if (requiredResult !== true) {
+        return false;
+      }
+      const date = new Date(value);
+      return !isNaN(date.getTime());
+    }
+  },
+  number: {
+    validator: function(rule, value, callback) {
+      const requiredResult = handleRequiredCheck(rule, value);
+      if (requiredResult !== true) {
+        return false;
+      }
+      if (typeof value === "string" && value.trim() === "") {
+        return false;
+      }
+      if (typeof value === "number" || !isNaN(Number(value))) {
+        return true;
+      }
+      return false;
+    }
+  }
+};
+const handleRequiredCheck = (rule, value) => {
+  if (value === void 0 || value === null || value === "") {
+    return rule.required ? false : true;
+  }
+  return true;
+};
+exports.disabledAllFields = disabledAllFields;
+exports.dynamicControlTableEdit = dynamicControlTableEdit;
+exports.getWorkflowRules = getWorkflowRules;
+exports.i18nValidatePropRulesMessage = i18nValidatePropRulesMessage;
+exports.i18nValidateRulesMessage = i18nValidateRulesMessage;
+exports.packageCustomRules = packageCustomRules;
+exports.packageCustomValidator = packageCustomValidator;
+exports.setObjectPropRule = setObjectPropRule;
+exports.updateComponentDisplayState = updateComponentDisplayState;
+exports.updateFormItemEditState = updateFormItemEditState;
+exports.validateDataModelFunc = validateDataModelFunc;
+exports.validator = validator;