@gct-paas/excel 0.1.39-beta.30 → 0.1.39-beta.32

package/dist/{dynamic-table-action-DXlLVZZF.js → dynamic-table-action-BvHth2cC.js}

@@ -1,10 +1,10 @@
 import { reactive, toRaw, computed, watch, onScopeDispose, inject, h, shallowReactive, markRaw, ref, nextTick, toRef, provide, defineComponent, openBlock, createElementBlock, mergeProps, unref, createElementVNode, normalizeClass, renderSlot, createCommentVNode, createVNode, toDisplayString, Fragment, renderList, onUnmounted, isVNode, onMounted, onBeforeMount, resolveComponent, createBlock, withCtx, createTextVNode } from "vue";
-import { ai as CellWidgetViewState, F as FIELD_TYPE, b9 as RenderModeEnum, Y as FormTypeEnum, bF as BpmnNodeTypeEnum, cw as getFieldPlaceholder, bW as MobileFillTypeEnum, C as ComponentTypeEnum, $ as PlatformEnum, cx as isReferenceOptionActive, E as api, bv as uuid2, c4 as calcUtils, bk as findRuntimeTableRow, c8 as ensureTableRowKeys, c1 as bindRuntimeTableColumns, bj as getRowId, cy as FRONT_ROW_KEY, cn as isTableRowKeyMatch, bx as isAttachFieldActive, cz as filterRulesByTrigger, cA as isEmptyValue$1, c5 as decodeTableCellRowKey, c7 as ensureFrontRowKey, b1 as getParseRuleInfo, aF as transformUtils, aY as materialCheck, aZ as getLotLockedReason, a_ as validateReinspectionDate, bo as FormulaRuleFieldKeyEnum, f as SubTableType, b2 as getParseRuleValue, cB as buildError, H as CreateType, bm as findRuntimeParentRow, aI as Dependency_ENUM, aH as ASSIGNMENTSTRATEGY_ENUM, bK as commonUtils, aM as DeviceLink, a8 as _export_sfc, ch as getRenderedRuntimeTableCell, y as CellType, cr as relocateDeletedRowsToEnd, cC as resetTableRowIdentity, J as useModal, cD as q, cE as QUICK_FILL_ALLOWED_FIELDS, cF as groupFixedTableRows, cG as processQuickFillRows, cH as getIsGroupEmpty } from "./dynamic-table-action.vue_vue_type_style_index_0_scoped_53d7e66c_lang-DlcK-wt_.js";
-import { cloneDeep, isEmpty, has, pickBy, isNil, mergeWith, omit, last, pick, merge } from "lodash-es";
+import { af as CellWidgetViewState, F as FIELD_TYPE, b4 as RenderModeEnum, X as FormTypeEnum, bs as BpmnNodeTypeEnum, ch as getFieldPlaceholder, bI as MobileFillTypeEnum, C as ComponentTypeEnum, bc as findRuntimeTableRow, aT as renderUtils, _ as PlatformEnum, E as api, bl as uuid2, bS as calcUtils, bW as ensureTableRowKeys, bP as bindRuntimeTableColumns, bb as getRowId, ci as FRONT_ROW_KEY, c9 as isTableRowKeyMatch, au as RangeCompareOp, at as RangeValidateMode, bT as decodeTableCellRowKey, bV as ensureFrontRowKey, a_ as getParseRuleInfo, aC as transformUtils, aV as materialCheck, aW as getLotLockedReason, aX as validateReinspectionDate, bf as FormulaRuleFieldKeyEnum, f as SubTableType, a$ as getParseRuleValue, H as CreateType, bd as findRuntimeParentRow, aF as Dependency_ENUM, aE as ASSIGNMENTSTRATEGY_ENUM, bw as commonUtils, aJ as DeviceLink, a7 as _export_sfc, c3 as getRenderedRuntimeTableCell, y as CellType, cj as resetTableRowIdentity, J as useModal, ck as q, cl as QUICK_FILL_ALLOWED_FIELDS, cm as groupFixedTableRows, cn as processQuickFillRows, co as getIsGroupEmpty } from "./dynamic-table-action.vue_vue_type_style_index_0_scoped_53d7e66c_lang-vRTNdchM.js";
 import dayjs from "dayjs";
+import { cloneDeep, isEmpty, has, isNil, pickBy, mergeWith, omit, last, pick, merge } from "lodash-es";
 import { a as useNamespace, I as Icon } from "./AntdIcon-DCIaV352.js";
 import { Modal, message } from "ant-design-vue";
-import { u as useFormModel } from "./mb-render-Dc2J-VKn.js";
+import { u as useFormModel } from "./mb-render-FUO_-FXR.js";
 var MaterialConsumptionPatternEnum = /* @__PURE__ */ ((MaterialConsumptionPatternEnum2) => {
   MaterialConsumptionPatternEnum2["RECORD"] = "record";
   MaterialConsumptionPatternEnum2["BOM"] = "bom";
@@ -703,6 +703,49 @@ function getSubTableQuickFillInfo(subTableFieldId, mobileTdIdGroups) {
   if (!subTableFieldId) return;
   return assignWidgetInfo(MobileFillTypeEnum.SUB_TABLE, { rowSubFieldKey: subTableFieldId });
 }
+function getCurrentFormData(_rule, options) {
+  if (!_rule._subtableFieldId) return options?.formData;
+  return findRuntimeTableRow(options?.formData?.[_rule._subtableFieldId], _rule._rowKey);
+}
+function isSameOptionValue(current, expected) {
+  if (typeof expected === "boolean") {
+    return renderUtils.getBoolValue(current) === expected;
+  }
+  if (current === void 0 || current === null || current === "") {
+    return false;
+  }
+  return String(current) === String(expected);
+}
+function isAttachFieldActive(attach, formData) {
+  if (attach?.parent && !isAttachFieldActive(attach.parent, formData)) return false;
+  if (!attach?.belongFieldId || isNil(attach.optionValue)) {
+    return true;
+  }
+  const row = attach.subtableFieldId ? findRuntimeTableRow(formData?.[attach.subtableFieldId], attach.rowKey) : formData;
+  if (attach.subtableFieldId && (!attach.rowKey || !row || row === formData)) {
+    return false;
+  }
+  const raw = row?.[attach.belongFieldId];
+  if (attach.multiple) {
+    const current = renderUtils.getValue(raw, true);
+    if (!Array.isArray(current)) return false;
+    return current.some((v) => isSameOptionValue(v, attach.optionValue));
+  }
+  return isSameOptionValue(raw, attach.optionValue);
+}
+function isReferenceOptionActive(referenceInfo, rowFormData) {
+  if (!referenceInfo?.belongFieldId || isNil(referenceInfo.optionValue)) {
+    return true;
+  }
+  return isAttachFieldActive(
+    {
+      belongFieldId: referenceInfo.belongFieldId,
+      optionValue: referenceInfo.optionValue,
+      multiple: referenceInfo.multiple
+    },
+    rowFormData
+  );
+}
 function fieldChromeStyles(state) {
   const required4 = state === "required";
   const disabled = state === "disabled";
@@ -2086,7 +2129,7 @@ function format(template) {
 function isNativeStringType(type4) {
   return type4 === "string" || type4 === "url" || type4 === "hex" || type4 === "email" || type4 === "date" || type4 === "pattern";
 }
-function isEmptyValue(value, type4) {
+function isEmptyValue$1(value, type4) {
   if (value === void 0 || value === null) {
     return true;
   }
@@ -2245,7 +2288,7 @@ function deepMerge(target, source) {
   return target;
 }
 var required$1 = function required(rule, value, source, errors, options, type4) {
-  if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type4 || rule.type))) {
+  if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue$1(value, type4 || rule.type))) {
     errors.push(format(options.messages.required, rule.fullField));
   }
 };
@@ -2432,11 +2475,11 @@ var string = function string2(rule, value, callback, source, options) {
   var errors = [];
   var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
   if (validate) {
-    if (isEmptyValue(value, "string") && !rule.required) {
+    if (isEmptyValue$1(value, "string") && !rule.required) {
       return callback();
     }
     rules.required(rule, value, source, errors, options, "string");
-    if (!isEmptyValue(value, "string")) {
+    if (!isEmptyValue$1(value, "string")) {
       rules.type(rule, value, source, errors, options);
       rules.range(rule, value, source, errors, options);
       rules.pattern(rule, value, source, errors, options);
@@ -2451,7 +2494,7 @@ var method2 = function method3(rule, value, callback, source, options) {
   var errors = [];
   var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
   if (validate) {
-    if (isEmptyValue(value) && !rule.required) {
+    if (isEmptyValue$1(value) && !rule.required) {
       return callback();
     }
     rules.required(rule, value, source, errors, options);
@@ -2468,7 +2511,7 @@ var number2 = function number3(rule, value, callback, source, options) {
     if (value === "") {
       value = void 0;
     }
-    if (isEmptyValue(value) && !rule.required) {
+    if (isEmptyValue$1(value) && !rule.required) {
       return callback();
     }
     rules.required(rule, value, source, errors, options);
@@ -2483,7 +2526,7 @@ var _boolean = function _boolean2(rule, value, callback, source, options) {
   var errors = [];
   var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
   if (validate) {
-    if (isEmptyValue(value) && !rule.required) {
+    if (isEmptyValue$1(value) && !rule.required) {
       return callback();
     }
     rules.required(rule, value, source, errors, options);
@@ -2497,11 +2540,11 @@ var regexp2 = function regexp3(rule, value, callback, source, options) {
   var errors = [];
   var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
   if (validate) {
-    if (isEmptyValue(value) && !rule.required) {
+    if (isEmptyValue$1(value) && !rule.required) {
       return callback();
     }
     rules.required(rule, value, source, errors, options);
-    if (!isEmptyValue(value)) {
+    if (!isEmptyValue$1(value)) {
       rules.type(rule, value, source, errors, options);
     }
   }
@@ -2511,7 +2554,7 @@ var integer2 = function integer3(rule, value, callback, source, options) {
   var errors = [];
   var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
   if (validate) {
-    if (isEmptyValue(value) && !rule.required) {
+    if (isEmptyValue$1(value) && !rule.required) {
       return callback();
     }
     rules.required(rule, value, source, errors, options);
@@ -2526,7 +2569,7 @@ var floatFn = function floatFn2(rule, value, callback, source, options) {
   var errors = [];
   var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
   if (validate) {
-    if (isEmptyValue(value) && !rule.required) {
+    if (isEmptyValue$1(value) && !rule.required) {
       return callback();
     }
     rules.required(rule, value, source, errors, options);
@@ -2556,7 +2599,7 @@ var object2 = function object3(rule, value, callback, source, options) {
   var errors = [];
   var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
   if (validate) {
-    if (isEmptyValue(value) && !rule.required) {
+    if (isEmptyValue$1(value) && !rule.required) {
       return callback();
     }
     rules.required(rule, value, source, errors, options);
@@ -2571,7 +2614,7 @@ var enumerable2 = function enumerable3(rule, value, callback, source, options) {
   var errors = [];
   var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
   if (validate) {
-    if (isEmptyValue(value) && !rule.required) {
+    if (isEmptyValue$1(value) && !rule.required) {
       return callback();
     }
     rules.required(rule, value, source, errors, options);
@@ -2585,11 +2628,11 @@ var pattern2 = function pattern3(rule, value, callback, source, options) {
   var errors = [];
   var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
   if (validate) {
-    if (isEmptyValue(value, "string") && !rule.required) {
+    if (isEmptyValue$1(value, "string") && !rule.required) {
       return callback();
     }
     rules.required(rule, value, source, errors, options);
-    if (!isEmptyValue(value, "string")) {
+    if (!isEmptyValue$1(value, "string")) {
       rules.pattern(rule, value, source, errors, options);
     }
   }
@@ -2599,11 +2642,11 @@ var date2 = function date3(rule, value, callback, source, options) {
   var errors = [];
   var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
   if (validate) {
-    if (isEmptyValue(value, "date") && !rule.required) {
+    if (isEmptyValue$1(value, "date") && !rule.required) {
       return callback();
     }
     rules.required(rule, value, source, errors, options);
-    if (!isEmptyValue(value, "date")) {
+    if (!isEmptyValue$1(value, "date")) {
       var dateObject;
       if (value instanceof Date) {
         dateObject = value;
@@ -2629,11 +2672,11 @@ var type2 = function type3(rule, value, callback, source, options) {
   var errors = [];
   var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
   if (validate) {
-    if (isEmptyValue(value, ruleType) && !rule.required) {
+    if (isEmptyValue$1(value, ruleType) && !rule.required) {
       return callback();
     }
     rules.required(rule, value, source, errors, options, ruleType);
-    if (!isEmptyValue(value, ruleType)) {
+    if (!isEmptyValue$1(value, ruleType)) {
       rules.type(rule, value, source, errors, options);
     }
   }
@@ -2643,7 +2686,7 @@ var any = function any2(rule, value, callback, source, options) {
   var errors = [];
   var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
   if (validate) {
-    if (isEmptyValue(value) && !rule.required) {
+    if (isEmptyValue$1(value) && !rule.required) {
       return callback();
     }
     rules.required(rule, value, source, errors, options);
@@ -2980,6 +3023,504 @@ Schema.register = function register(type4, validator) {
 Schema.warning = warning;
 Schema.messages = messages;
 Schema.validators = validators;
+const stampKeys = [
+  "sealId",
+  "sealName",
+  "sealType",
+  "sealImage",
+  "sealUserId",
+  "sealUserName",
+  "sealUserTime"
+];
+function isSealPosition(value) {
+  if (!value || typeof value !== "object") return false;
+  const p = value;
+  return typeof p.sheetId === "string" && !!p.sheetId && Number.isInteger(p.pageIndex) && p.pageIndex >= 0 && Number.isFinite(p.leftMm) && p.leftMm >= 0 && Number.isFinite(p.topMm) && p.topMm >= 0;
+}
+function readSealValue(raw, fallback) {
+  let parsed = {};
+  try {
+    const value = typeof raw === "string" ? JSON.parse(raw || "{}") : raw;
+    if (value && typeof value === "object" && !Array.isArray(value)) parsed = value;
+  } catch {
+  }
+  const stamp = Object.fromEntries(
+    stampKeys.map((key) => [key, typeof parsed[key] === "string" ? parsed[key] : ""])
+  );
+  return {
+    ...stamp,
+    sealPosition: { ...isSealPosition(parsed.sealPosition) ? parsed.sealPosition : fallback }
+  };
+}
+function isSealStamped(raw) {
+  try {
+    const value = typeof raw === "string" ? JSON.parse(raw || "{}") : raw;
+    return !!value && typeof value.sealId === "string" && !!value.sealId && typeof value.sealImage === "string" && !!value.sealImage;
+  } catch {
+    return false;
+  }
+}
+function isValidSealValue(raw) {
+  try {
+    const value = typeof raw === "string" ? JSON.parse(raw || "{}") : raw;
+    return !!value && stampKeys.every((key) => typeof value[key] === "string") && isSealPosition(value.sealPosition) && (stampKeys.every((key) => !value[key]) || stampKeys.every((key) => !!value[key]));
+  } catch {
+    return false;
+  }
+}
+function moveSealValue(raw, fallback, position) {
+  return JSON.stringify({ ...readSealValue(raw, fallback), sealPosition: { ...position } });
+}
+function stampSealValue(raw, fallback, stamp) {
+  const current = readSealValue(raw, fallback);
+  const next = readSealValue({ ...stamp, sealPosition: current.sealPosition }, fallback);
+  return JSON.stringify(next);
+}
+function clearSealValue(raw, fallback) {
+  return JSON.stringify(
+    readSealValue({ sealPosition: readSealValue(raw, fallback).sealPosition }, fallback)
+  );
+}
+function normalizeSealDiameter(value) {
+  const diameter = Number(value);
+  return Number.isFinite(diameter) && diameter > 0 ? Math.min(diameter, 200) : 42;
+}
+function clampSealPosition(position, widthMm, heightMm, diameterMm) {
+  return {
+    ...position,
+    leftMm: Math.max(0, Math.min(position.leftMm, Math.max(0, widthMm - diameterMm))),
+    topMm: Math.max(0, Math.min(position.topMm, Math.max(0, heightMm - diameterMm)))
+  };
+}
+function initializeSealFields(fields, formData) {
+  for (const { props } of fields) {
+    if (!props.field || props.isFieldModel || props.subFieldKey) continue;
+    const raw = formData[props.field];
+    if (raw == null || raw === "") {
+      formData[props.field] = JSON.stringify(readSealValue("", props.sealPosition));
+      continue;
+    }
+    try {
+      const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+      if (!isSealPosition(parsed.sealPosition)) {
+        formData[props.field] = JSON.stringify({
+          ...parsed,
+          sealPosition: { ...props.sealPosition }
+        });
+      } else if (typeof raw !== "string") {
+        formData[props.field] = JSON.stringify(parsed);
+      }
+    } catch {
+    }
+  }
+}
+const { identify, calculate: calculate$1 } = {
+  identify: (expression) => window.NocodeAdapter.utils?.formulaIdentify?.(expression) ?? [],
+  calculate: (expression, data) => window.NocodeAdapter.utils?.formulaCalculate?.(expression, data)
+};
+const getFieldDataValue = (parseInfo, formData) => {
+  const getTextValue = (processedKey, value) => {
+    const textValue = value ?? formData?.[processedKey] ?? "";
+    return Array.isArray(textValue) ? textValue.join() : textValue;
+  };
+  const { type: type4, processed, hashValue } = parseInfo;
+  if (type4 === "hash") {
+    const tableData = toRaw(formData?.[hashValue] || []);
+    return tableData.filter((d) => !d.deleted_).map((row) => getTextValue(processed, row?.[processed])).filter((i) => !isNil(i));
+  }
+  return getTextValue(processed, formData?.[processed]);
+};
+const parseFormulaVar = (formulaVar) => {
+  const result = {
+    original: formulaVar,
+    type: "",
+    processed: "",
+    hashValue: "",
+    dataType: ""
+  };
+  if (/^\$([^$]+)\$\.(.+)$/.test(formulaVar)) {
+    const match = formulaVar.match(/^\$([^$]+)\$\.(.+)$/);
+    result.type = "hash";
+    result.processed = match[2];
+    result.hashValue = match[1];
+    result.dataType = "globType";
+  } else if (/^_\.(.+)$/.test(formulaVar)) {
+    const match = formulaVar.match(/^_\.(.+)$/);
+    result.type = "underscore";
+    result.processed = match[1];
+    result.dataType = "currentRowType";
+  } else {
+    result.type = "plain";
+    result.processed = formulaVar;
+    result.dataType = "globType";
+  }
+  return result;
+};
+const getParseFormulaVarInfos = (expr) => {
+  const rowArgs = expr ? identify(expr) : [];
+  return {
+    rowArgs,
+    parseInfos: rowArgs.map((curr) => parseFormulaVar(curr))
+  };
+};
+const calculateFormula = async (expr, formData, instanceFormState) => {
+  const rowArgs = identify(expr);
+  const formulaData = isEmpty(rowArgs) ? {} : rowArgs.reduce((total, curr) => {
+    const parseInfo = parseFormulaVar(curr);
+    total[curr] = getFieldDataValue(
+      parseInfo,
+      parseInfo.dataType === "currentRowType" ? formData : instanceFormState
+    );
+    return total;
+  }, {});
+  return calculate$1(expr, formulaData);
+};
+const isEmptyValue = (value) => {
+  return value === void 0 || value === null || typeof value === "string" && value.trim() === "" || Array.isArray(value) && value.length === 0;
+};
+const compareByOp = (left, right, op) => {
+  switch (op) {
+    case RangeCompareOp.LT:
+      return left < right;
+    case RangeCompareOp.LE:
+      return left <= right;
+    case RangeCompareOp.GT:
+      return left > right;
+    case RangeCompareOp.GE:
+    default:
+      return left >= right;
+  }
+};
+const rangeCompareMessage = (op, val) => {
+  switch (op) {
+    case RangeCompareOp.LT:
+      return $t("sys.fieldValueNotGreaterOrEqual", { val });
+    case RangeCompareOp.LE:
+      return $t("sys.fieldValueNoMoreThan", { val });
+    case RangeCompareOp.GT:
+      return $t("sys.fieldValueNotLessOrEqual", { val });
+    case RangeCompareOp.GE:
+    default:
+      return $t("sys.fieldValueNotLessThan", { val });
+  }
+};
+const toUnixTimestamp = (input) => {
+  if (isNil(input) || input === "") return null;
+  const asNumber = typeof input === "number" || typeof input === "string" && /^-?\d+(\.\d+)?$/.test(input.trim());
+  if (asNumber) {
+    const n = Number(input);
+    if (Number.isNaN(n)) return null;
+    const parsed2 = n > 1e12 ? dayjs(n) : dayjs.unix(n);
+    return parsed2.isValid() ? parsed2.unix() : null;
+  }
+  const parsed = dayjs(input);
+  return parsed.isValid() ? parsed.unix() : null;
+};
+const buildError = (validatorInfo, message2) => JSON.stringify({ ...validatorInfo, message: message2 });
+function areValidationCommentsEqual(left, right) {
+  const serialize = (comments) => JSON.stringify(
+    comments,
+    (_key, value) => value && typeof value === "object" && "message" in value ? { ...value, message: value.message } : value
+  );
+  return serialize(left) === serialize(right);
+}
+const createRule = (validator, message2, trigger = "change") => ({
+  required: true,
+  validator,
+  message: message2,
+  trigger
+});
+function relocateDeletedRowsToEnd(rows = []) {
+  const active = [];
+  const deleted = [];
+  for (const row of rows) {
+    if (row?.deleted_) deleted.push(row);
+    else active.push(row);
+  }
+  return [...active, ...deleted];
+}
+function filterRulesByTrigger(rules2, trigger) {
+  return rules2.filter((rule) => {
+    const ruleTrigger = rule.trigger;
+    if (!ruleTrigger) return trigger === "change";
+    if (trigger === "blur") {
+      return ruleTrigger === "blur" || ruleTrigger === "change";
+    }
+    return ruleTrigger === trigger;
+  });
+}
+function assembleRules(input) {
+  const { showRequired, fieldType, validatorInfo, props } = input;
+  const {
+    minlength,
+    maxlength,
+    regex,
+    regexHint,
+    validateTrue,
+    validateFalse,
+    enableRangeValidate,
+    maxValidateMode,
+    minValidateMode,
+    maxCompareOp,
+    minCompareOp,
+    minValue,
+    maxValue,
+    minFormulaExpr,
+    maxFormulaExpr,
+    minDate,
+    maxDate,
+    minDateFormulaExpr,
+    maxDateFormulaExpr,
+    maxDateValidateMode,
+    minDateValidateMode
+  } = props;
+  const resolvedMaxCompareOp = maxCompareOp ?? RangeCompareOp.LE;
+  const resolvedMinCompareOp = minCompareOp ?? RangeCompareOp.GE;
+  const RuleProps = [];
+  if (props.bizType === FIELD_TYPE.SEAL) {
+    if (showRequired) {
+      RuleProps.push(
+        createRule(
+          (_rule, value) => isSealStamped(value),
+          buildError(
+            { ...validatorInfo, validationCode: "seal-required" },
+            $t("sys.fieldRequired")
+          ),
+          "manual"
+        )
+      );
+    }
+    RuleProps.push(createRule((_rule, value) => isEmptyValue(value) || isValidSealValue(value), buildError(validatorInfo, $t("sys.seal.invalid"))));
+    return RuleProps;
+  }
+  if (showRequired) {
+    RuleProps.push(
+      createRule(
+        (_rule, value) => !isEmptyValue(value),
+        buildError(validatorInfo, $t("sys.fieldRequired")),
+        "manual"
+      )
+    );
+  }
+  if (!isNil(minlength)) {
+    RuleProps.push(
+      createRule((_rule, value) => {
+        if (isEmptyValue(value)) return true;
+        return String(value).length >= minlength;
+      }, buildError(validatorInfo, $t("sys.fieldLengthNotLessThan", { len: minlength })))
+    );
+  }
+  const effectiveMaxlength = isNil(maxlength) && fieldType === FIELD_TYPE.TEXT ? 1024 : maxlength;
+  if (!isNil(effectiveMaxlength)) {
+    RuleProps.push(
+      createRule((_rule, value) => {
+        if (isEmptyValue(value)) return true;
+        return String(value).length <= effectiveMaxlength;
+      }, buildError(validatorInfo, $t("sys.fieldLengthNoMoreThan", { len: effectiveMaxlength })))
+    );
+  }
+  if (regex) {
+    RuleProps.push(
+      createRule((_rule, value) => {
+        if (isEmptyValue(value)) return true;
+        return new RegExp(regex).test(value);
+      }, buildError(validatorInfo, regexHint ?? $t("sys.fieldFormatError")))
+    );
+  }
+  if (validateTrue) {
+    RuleProps.push({
+      required: true,
+      trigger: "manual",
+      validator: (_rule, value) => value === true,
+      message: buildError(validatorInfo, $t("sys.fieldValueNeedTrue"))
+    });
+  }
+  if (validateFalse) {
+    RuleProps.push({
+      required: true,
+      trigger: "manual",
+      validator: (_rule, value) => value === false,
+      message: buildError(validatorInfo, $t("sys.fieldValueNeedFalse"))
+    });
+  }
+  if (!enableRangeValidate) {
+    return RuleProps;
+  }
+  if (minValidateMode === RangeValidateMode.Fixed_Number && !isEmptyValue(minValue)) {
+    RuleProps.push(
+      createRule((_rule, value) => {
+        if (isEmptyValue(value)) return true;
+        return compareByOp(Number(value), Number(minValue), resolvedMinCompareOp);
+      }, buildError(validatorInfo, rangeCompareMessage(resolvedMinCompareOp, minValue)))
+    );
+  }
+  if (minValidateMode === RangeValidateMode.Variable_Validate && minFormulaExpr) {
+    RuleProps.push({
+      required: true,
+      trigger: "change",
+      validator: async (_rule, value, _callback, _source, options) => {
+        const currentFormData = getCurrentFormData(_rule, options);
+        const formulaValue = await calculateFormula(
+          minFormulaExpr,
+          currentFormData,
+          options?.formData
+        );
+        if (isEmptyValue(formulaValue)) {
+          return Promise.resolve();
+        }
+        const parsedMin = parseFloat(formulaValue);
+        if (!isNaN(parsedMin)) {
+          if (isEmptyValue(value)) {
+            return Promise.resolve();
+          }
+          if (!compareByOp(Number(value), parsedMin, resolvedMinCompareOp)) {
+            return Promise.reject(
+              new Error(
+                buildError(validatorInfo, rangeCompareMessage(resolvedMinCompareOp, parsedMin))
+              )
+            );
+          }
+        }
+        return Promise.resolve();
+      }
+    });
+  }
+  if (maxValidateMode === RangeValidateMode.Fixed_Number && !isEmptyValue(maxValue)) {
+    RuleProps.push(
+      createRule((_rule, value) => {
+        if (isEmptyValue(value)) return true;
+        return compareByOp(Number(value), Number(maxValue), resolvedMaxCompareOp);
+      }, buildError(validatorInfo, rangeCompareMessage(resolvedMaxCompareOp, maxValue)))
+    );
+  }
+  if (maxValidateMode === RangeValidateMode.Variable_Validate && maxFormulaExpr) {
+    RuleProps.push({
+      required: true,
+      trigger: "change",
+      validator: async (_rule, value, _callback, _source, options) => {
+        const currentFormData = getCurrentFormData(_rule, options);
+        const formulaValue = await calculateFormula(
+          maxFormulaExpr,
+          currentFormData,
+          options?.formData
+        );
+        if (isEmptyValue(formulaValue)) {
+          return Promise.resolve();
+        }
+        const parsedMax = parseFloat(formulaValue);
+        if (!isNaN(parsedMax)) {
+          if (isEmptyValue(value)) {
+            return Promise.resolve();
+          }
+          if (!compareByOp(Number(value), parsedMax, resolvedMaxCompareOp)) {
+            return Promise.reject(
+              new Error(
+                buildError(validatorInfo, rangeCompareMessage(resolvedMaxCompareOp, parsedMax))
+              )
+            );
+          }
+        }
+        return Promise.resolve();
+      }
+    });
+  }
+  if (minDateValidateMode === RangeValidateMode.Fixed_Number && minDate) {
+    RuleProps.push(
+      createRule((_rule, value) => {
+        if (isEmptyValue(value)) return true;
+        const inputTime = dayjs(value).unix();
+        const minTimestamp = dayjs(minDate).unix();
+        if (!dayjs(value).isValid() || !dayjs(minDate).isValid()) return true;
+        return compareByOp(inputTime, minTimestamp, resolvedMinCompareOp);
+      }, buildError(validatorInfo, rangeCompareMessage(resolvedMinCompareOp, minDate)))
+    );
+  }
+  if (maxDateValidateMode === RangeValidateMode.Fixed_Number && maxDate) {
+    RuleProps.push(
+      createRule((_rule, value) => {
+        if (isEmptyValue(value)) return true;
+        const inputTime = dayjs(value).unix();
+        const maxTimestamp = dayjs(maxDate).unix();
+        if (!dayjs(value).isValid() || !dayjs(maxDate).isValid()) return true;
+        return compareByOp(inputTime, maxTimestamp, resolvedMaxCompareOp);
+      }, buildError(validatorInfo, rangeCompareMessage(resolvedMaxCompareOp, maxDate)))
+    );
+  }
+  if (minDateValidateMode === RangeValidateMode.Variable_Validate && minDateFormulaExpr) {
+    RuleProps.push({
+      required: true,
+      trigger: "change",
+      validator: async (_rule, value, _callback, _source, options) => {
+        const currentFormData = getCurrentFormData(_rule, options);
+        const formulaValue = await calculateFormula(
+          minDateFormulaExpr,
+          currentFormData,
+          options?.formData
+        );
+        const limitTime = toUnixTimestamp(formulaValue);
+        if (limitTime !== null) {
+          if (isEmptyValue(value)) {
+            return Promise.resolve();
+          }
+          if (!dayjs(value).isValid()) {
+            return Promise.resolve();
+          }
+          const inputTime = dayjs(value).unix();
+          const fmt = fieldType === FIELD_TYPE.DATE_TIME ? "YYYY-MM-DD HH:mm:ss" : "YYYY-MM-DD";
+          if (!compareByOp(inputTime, limitTime, resolvedMinCompareOp)) {
+            return Promise.reject(
+              new Error(
+                buildError(
+                  validatorInfo,
+                  rangeCompareMessage(resolvedMinCompareOp, dayjs.unix(limitTime).format(fmt))
+                )
+              )
+            );
+          }
+        }
+        return Promise.resolve();
+      }
+    });
+  }
+  if (maxDateValidateMode === RangeValidateMode.Variable_Validate && maxDateFormulaExpr) {
+    RuleProps.push({
+      required: true,
+      trigger: "change",
+      validator: async (_rule, value, _callback, _source, options) => {
+        const currentFormData = getCurrentFormData(_rule, options);
+        const formulaValue = await calculateFormula(
+          maxDateFormulaExpr,
+          currentFormData,
+          options?.formData
+        );
+        const limitTime = toUnixTimestamp(formulaValue);
+        if (limitTime !== null) {
+          if (isEmptyValue(value)) {
+            return Promise.resolve();
+          }
+          if (!dayjs(value).isValid()) {
+            return Promise.resolve();
+          }
+          const inputTime = dayjs(value).unix();
+          const fmt = fieldType === FIELD_TYPE.DATE_TIME ? "YYYY-MM-DD HH:mm:ss" : "YYYY-MM-DD";
+          if (!compareByOp(inputTime, limitTime, resolvedMaxCompareOp)) {
+            return Promise.reject(
+              new Error(
+                buildError(
+                  validatorInfo,
+                  rangeCompareMessage(resolvedMaxCompareOp, dayjs.unix(limitTime).format(fmt))
+                )
+              )
+            );
+          }
+        }
+        return Promise.resolve();
+      }
+    });
+  }
+  return RuleProps;
+}
 function resolveKeepExceptionHighlight(formValue, fieldValue) {
   if (typeof fieldValue === "boolean") {
     return fieldValue;
@@ -3105,7 +3646,7 @@ function clearResolvedManualErrors(map, resolvePayload) {
     if (!payload) continue;
     const hasManual = filterRulesByTrigger(payload.rules, "manual").length > 0;
     const hasLive = filterRulesByTrigger(payload.rules, "change").length > 0;
-    if (hasManual && !hasLive && !isEmptyValue$1(payload.value)) {
+    if (hasManual && !hasLive && !isEmptyValue(payload.value)) {
       delete next[path];
     }
   }
@@ -3119,7 +3660,7 @@ function mergeLiveValidation(current, liveResult, livePaths, resolvePayload) {
       continue;
     }
     const payload = resolvePayload(path);
-    const keepManualComment = !!payload && filterRulesByTrigger(payload.rules, "manual").length > 0 && isEmptyValue$1(payload.value) && !!base[path]?.length;
+    const keepManualComment = !!payload && filterRulesByTrigger(payload.rules, "manual").length > 0 && isEmptyValue(payload.value) && !!base[path]?.length;
     if (!keepManualComment) {
       delete base[path];
     }
@@ -3162,7 +3703,7 @@ function mergeDisplayValidation(current, displayResult, ruleKeys, validatedPaths
       next[path] = displayResult[path];
     } else {
       const payload = resolvePayload(path);
-      const keepManualComment = !!payload && filterRulesByTrigger(payload.rules, "manual").length > 0 && isEmptyValue$1(payload.value) && !!next[path]?.length;
+      const keepManualComment = !!payload && filterRulesByTrigger(payload.rules, "manual").length > 0 && isEmptyValue(payload.value) && !!next[path]?.length;
       if (!keepManualComment) delete next[path];
     }
   }
@@ -10338,112 +10879,127 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 });
 const DynamicTableAction = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-53d7e66c"]]);
 export {
-  RuntimeSheetService as $,
-  useStyles as A,
+  _sfc_main$5 as $,
+  getObjectBomProductQuery as A,
   BorderTD as B,
-  useDependency as C,
+  normalizeHistoricalAutofillRow as C,
   DEFAULT_BOOLEAN_FIELD_WIDTH as D,
   EMPTY_PRODUCT_VERSION_ID as E,
-  useFieldPresentation as F,
-  useRuntimeEditorFlusher as G,
-  createRuntimeInstanceContext as H,
-  RuntimeInstanceRegistry as I,
-  RequiredQtyCalcRule as J,
-  registerFormulaFuncs as K,
-  DocumentPaper as L,
+  readSealValue as F,
+  isSealStamped as G,
+  stampSealValue as H,
+  isValidSealValue as I,
+  clearSealValue as J,
+  parseRuntimeFieldPath as K,
+  calculateFormula as L,
   MAX_RUNTIME_SHEETS as M,
   NCB_PROVIDE as N,
-  DynamicTableAction as O,
-  getRuntimeDataFieldId as P,
-  buildRuntimeFieldPath as Q,
-  RuntimeFormStateStore as R,
-  ScanParamType as S,
-  resolveRuntimeFieldProps as T,
-  resolveRuntimeFieldState as U,
-  getRuntimeDependencyOutputKey as V,
-  isRowAddedInCurrentFormChange as W,
-  MaterialConsumeTableController as X,
-  setFormulaParamsConfig as Y,
-  normalizeRuntime as Z,
-  _sfc_main$5 as _,
+  useStyles as O,
+  useDependency as P,
+  useFieldPresentation as Q,
+  useRuntimeEditorFlusher as R,
+  RuntimeFormStateStore as S,
+  createRuntimeInstanceContext as T,
+  RuntimeInstanceRegistry as U,
+  ScanParamType as V,
+  RequiredQtyCalcRule as W,
+  registerFormulaFuncs as X,
+  moveSealValue as Y,
+  DocumentPaper as Z,
+  DynamicTableAction as _,
   MAX_RUNTIME_SHEET_TITLE_LENGTH as a,
-  validateObjectBomQtyOnSubmit as a0,
-  closeValidatorPopovers as a1,
-  enrichFormChangeRowDetails as a2,
-  useMaterialBalance as a3,
-  collectFormChangeFieldLocations as a4,
-  nextFormChangeRowViewHistoryId as a5,
-  DeviceConnector as a6,
-  DocumentLoading as a7,
-  DynamicQuickFillModal as a8,
-  FixedQuickFillModal as a9,
-  recordSubtableRowDelete as aA,
-  resolveAnnotationFieldLocation as aB,
-  resolveFormChangeRowUi as aC,
-  resolveRowFormChangeMark as aD,
-  setSelectMobileTdId as aE,
-  stripLegacyFormConfigFromPaper as aF,
-  SubTableActionMenuTypeEnum as aG,
-  getMenuByAction as aH,
-  SubTableActionEnum as aI,
-  resolveScanFillData as aJ,
-  getInsertSubMenu as aK,
-  resolveScanAdjustType as aL,
-  resolveScanQty as aM,
-  toDateOnly as aN,
-  hasSubtableBusinessData as aO,
-  getCopySubMenu as aP,
-  resolveScanParsedValue as aQ,
-  isProductBatchEmptyRow as aR,
-  FormTmplConfigController as aa,
-  LEGACY_RUNTIME_FORM_CONFIG_KEYS as ab,
-  LEGACY_RUNTIME_SHEET_ID as ac,
-  LEGACY_RUNTIME_SHEET_TITLE as ad,
-  MCDataUtil as ae,
-  OCR_MODEL_PRECISION_ENUM_KEY as af,
-  RuntimeAsyncTaskCoordinator as ag,
-  RuntimeDependencyService as ah,
-  RuntimeFieldRegistry as ai,
-  RuntimeInstanceEventBus as aj,
-  RuntimePersistenceCoordinator as ak,
-  RuntimeValidationService as al,
-  SubTableCore as am,
-  buildFormChangeDisplayRows as an,
-  convertV1Runtime as ao,
-  detailsHaveFormChangeRowOps as ap,
-  extractFormChangeRowDetails as aq,
-  getFormChangeRowKey as ar,
-  getFormChangeRowOp as as,
-  getSubTableQuickFillInfo as at,
-  isAnnLocationSelected as au,
-  isBlank as av,
-  isFormChangeGhostRow as aw,
-  normalizeHistoricalFieldConfig as ax,
-  pickObjectFieldKeys as ay,
-  recordSubtableRowAdd as az,
+  resolveScanQty as a$,
+  getRuntimeDataFieldId as a0,
+  buildRuntimeFieldPath as a1,
+  resolveRuntimeFieldProps as a2,
+  resolveRuntimeFieldState as a3,
+  assembleRules as a4,
+  isAttachFieldActive as a5,
+  getRuntimeDependencyOutputKey as a6,
+  isRowAddedInCurrentFormChange as a7,
+  MaterialConsumeTableController as a8,
+  setFormulaParamsConfig as a9,
+  SubTableCore as aA,
+  buildFormChangeDisplayRows as aB,
+  convertV1Runtime as aC,
+  detailsHaveFormChangeRowOps as aD,
+  extractFormChangeRowDetails as aE,
+  getFormChangeRowKey as aF,
+  getFormChangeRowOp as aG,
+  getSubTableQuickFillInfo as aH,
+  isAnnLocationSelected as aI,
+  isBlank as aJ,
+  isFormChangeGhostRow as aK,
+  normalizeHistoricalFieldConfig as aL,
+  pickObjectFieldKeys as aM,
+  recordSubtableRowAdd as aN,
+  recordSubtableRowDelete as aO,
+  relocateDeletedRowsToEnd as aP,
+  resolveAnnotationFieldLocation as aQ,
+  resolveFormChangeRowUi as aR,
+  resolveRowFormChangeMark as aS,
+  setSelectMobileTdId as aT,
+  stripLegacyFormConfigFromPaper as aU,
+  SubTableActionMenuTypeEnum as aV,
+  getMenuByAction as aW,
+  SubTableActionEnum as aX,
+  resolveScanFillData as aY,
+  getInsertSubMenu as aZ,
+  resolveScanAdjustType as a_,
+  normalizeRuntime as aa,
+  initializeSealFields as ab,
+  RuntimeSheetService as ac,
+  validateObjectBomQtyOnSubmit as ad,
+  areValidationCommentsEqual as ae,
+  closeValidatorPopovers as af,
+  enrichFormChangeRowDetails as ag,
+  useMaterialBalance as ah,
+  collectFormChangeFieldLocations as ai,
+  nextFormChangeRowViewHistoryId as aj,
+  DeviceConnector as ak,
+  DocumentLoading as al,
+  DynamicQuickFillModal as am,
+  FixedQuickFillModal as an,
+  FormTmplConfigController as ao,
+  LEGACY_RUNTIME_FORM_CONFIG_KEYS as ap,
+  LEGACY_RUNTIME_SHEET_ID as aq,
+  LEGACY_RUNTIME_SHEET_TITLE as ar,
+  MCDataUtil as as,
+  OCR_MODEL_PRECISION_ENUM_KEY as at,
+  RuntimeAsyncTaskCoordinator as au,
+  RuntimeDependencyService as av,
+  RuntimeFieldRegistry as aw,
+  RuntimeInstanceEventBus as ax,
+  RuntimePersistenceCoordinator as ay,
+  RuntimeValidationService as az,
   MULTI_SHEET_SCHEMA_VERSION as b,
-  createRuntimeDocumentV2 as c,
-  normalizeHistoricalBusinessRow as d,
-  DeviceLinkTmplUtil as e,
-  normalizeAIOcrTmpl as f,
-  getBusinessFieldKey as g,
-  useWidgetStaticAttrs as h,
-  useRuntimeInstanceServices as i,
-  setSelectAnnotationId as j,
-  useRuntimeRowState as k,
-  getObjectBomMaterialLotQuery as l,
-  buildObjectLotExtraQuery as m,
-  normalizeFieldWidth as n,
-  MaterialConsumptionPatternEnum as o,
-  resolveObjectBomEntry as p,
-  runWithFillProduct as q,
+  toDateOnly as b0,
+  hasSubtableBusinessData as b1,
+  getCopySubMenu as b2,
+  resolveScanParsedValue as b3,
+  isProductBatchEmptyRow as b4,
+  getBusinessFieldKey as c,
+  createRuntimeDocumentV2 as d,
+  clampSealPosition as e,
+  normalizeFieldWidth as f,
+  getParseFormulaVarInfos as g,
+  normalizeHistoricalBusinessRow as h,
+  DeviceLinkTmplUtil as i,
+  normalizeAIOcrTmpl as j,
+  useWidgetStaticAttrs as k,
+  useRuntimeInstanceServices as l,
+  setSelectAnnotationId as m,
+  normalizeSealDiameter as n,
+  useRuntimeRowState as o,
+  getObjectBomMaterialLotQuery as p,
+  buildObjectLotExtraQuery as q,
   resolveObjectFieldKeys as r,
   setSelectValidatorId as s,
-  useNocodeFormWidget as t,
+  MaterialConsumptionPatternEnum as t,
   useFormTmplConfig as u,
   validateObjectBomForScan as v,
-  applyConsumeObjectTraceChange as w,
-  getObjectBomProductQuery as x,
-  normalizeHistoricalAutofillRow as y,
-  parseRuntimeFieldPath as z
+  resolveObjectBomEntry as w,
+  runWithFillProduct as x,
+  useNocodeFormWidget as y,
+  applyConsumeObjectTraceChange as z
 };