@gct-paas/excel 0.1.40-beta.11 → 0.1.40-beta.13

package/dist/{dynamic-table-action-DQwZUD0_.js → dynamic-table-action-Bank1QhA.js}

@@ -1,11 +1,11 @@
 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 { aj as CellWidgetViewState, F as FIELD_TYPE, bm as RenderModeEnum, Z as FormTypeEnum, bG as BpmnNodeTypeEnum, cz as getFieldPlaceholder, bY as MobileFillTypeEnum, C as ComponentTypeEnum, a0 as PlatformEnum, cA as isReferenceOptionActive, p as api, bw as uuid2, c6 as calcUtils, bk as findRuntimeTableRow, ca as ensureTableRowKeys, c3 as bindRuntimeTableColumns, bj as getRowId, cB as FRONT_ROW_KEY, cp as isTableRowKeyMatch, by as isAttachFieldActive, cC as filterRulesByTrigger, cD as isEmptyValue$1, c7 as decodeTableCellRowKey, c9 as ensureFrontRowKey, b2 as getParseRuleInfo, aH as transformUtils, aZ as materialCheck, a_ as getLotLockedReason, a$ as validateReinspectionDate, bp as FormulaRuleFieldKeyEnum, h as SubTableType, b3 as getParseRuleValue, cE as buildError, I as CreateType, bn as findRuntimeParentRow, aK as Dependency_ENUM, aJ as ASSIGNMENTSTRATEGY_ENUM, bL as commonUtils, aO as DeviceLink, a9 as _export_sfc, cj as getRenderedRuntimeTableCell, A as CellType, ct as relocateDeletedRowsToEnd, cF as resetTableRowIdentity, K as useModal, cG as q, cH as QUICK_FILL_ALLOWED_FIELDS, cI as groupFixedTableRows, cJ as processQuickFillRows, cK as getIsGroupEmpty } from "./dynamic-table-action.vue_vue_type_style_index_0_scoped_53d7e66c_lang-8yB6zly8.js";
-import { cloneDeep, isEmpty, has, pickBy, isNil, mergeWith, omit, last, pick, merge } from "lodash-es";
+import { ag as CellWidgetViewState, F as FIELD_TYPE, bd as RenderModeEnum, Y as FormTypeEnum, bt as BpmnNodeTypeEnum, ck as getFieldPlaceholder, bK as MobileFillTypeEnum, C as ComponentTypeEnum, bc as findRuntimeTableRow, aU as renderUtils, $ as PlatformEnum, p as api, bm as uuid2, bU as calcUtils, bY as ensureTableRowKeys, bR as bindRuntimeTableColumns, bb as getRowId, cl as FRONT_ROW_KEY, cb as isTableRowKeyMatch, av as RangeCompareOp, au as RangeValidateMode, bV as decodeTableCellRowKey, bX as ensureFrontRowKey, a$ as getParseRuleInfo, aE as transformUtils, aW as materialCheck, aX as getLotLockedReason, aY as validateReinspectionDate, bg as FormulaRuleFieldKeyEnum, h as SubTableType, b0 as getParseRuleValue, I as CreateType, be as findRuntimeParentRow, aH as Dependency_ENUM, aG as ASSIGNMENTSTRATEGY_ENUM, bx as commonUtils, aL as DeviceLink, a8 as _export_sfc, c5 as getRenderedRuntimeTableCell, A as CellType, cm as resetTableRowIdentity, K as useModal, cn as q, co as QUICK_FILL_ALLOWED_FIELDS, cp as groupFixedTableRows, cq as processQuickFillRows, cr as getIsGroupEmpty } from "./dynamic-table-action.vue_vue_type_style_index_0_scoped_53d7e66c_lang-CMUJIaqF.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 "@gct-paas/form-base";
 import { Modal, message } from "ant-design-vue";
-import { u as useFormModel } from "./mb-render-_IUbyYCY.js";
+import { u as useFormModel } from "./mb-render-CAIFQRQe.js";
 var MaterialConsumptionPatternEnum = /* @__PURE__ */ ((MaterialConsumptionPatternEnum2) => {
   MaterialConsumptionPatternEnum2["RECORD"] = "record";
   MaterialConsumptionPatternEnum2["BOM"] = "bom";
@@ -772,6 +772,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";
@@ -1056,7 +1099,7 @@ function normalizeSheetMetadata(sheet) {
   };
   return { ...sheet, paper, nodes, dataCenter: { [ComponentTypeEnum.PAPER]: paper, ...nodes } };
 }
-function normalizeRuntime(runtime) {
+function normalizeRuntime(runtime, formType) {
   if (typeof runtime === "string") {
     if (!runtime.trim()) throw new Error("运行时数据不能为空");
     try {
@@ -1067,7 +1110,16 @@ function normalizeRuntime(runtime) {
   }
   assertObject(runtime, "运行时数据格式无效");
   if (runtime.schemaVersion == null || runtime.schemaVersion === 1) {
-    const normalized = convertV1Runtime(runtime);
+    const legacyRuntime = formType === FormTypeEnum.FILE && runtime[ComponentTypeEnum.PAPER] == null ? {
+      ...runtime,
+      [ComponentTypeEnum.PAPER]: {
+        id: ComponentTypeEnum.PAPER,
+        component: ComponentTypeEnum.PAPER,
+        props: {},
+        nextIds: []
+      }
+    } : runtime;
+    const normalized = convertV1Runtime(legacyRuntime);
     normalized.sheets.forEach(validateSheetGraph);
     return { ...normalized, sheets: normalized.sheets.map(normalizeSheetMetadata) };
   }
@@ -1204,6 +1256,7 @@ function createRuntimeInstanceContext(options) {
     uniqueId: options.uniqueId,
     instanceId: options.instanceId,
     templateId: options.templateId,
+    formType: options.formType,
     schemaVersion: options.runtime.schemaVersion,
     formConfig: options.runtime.formConfig,
     defaultData: options.defaultData,
@@ -1293,7 +1346,7 @@ class RuntimeSheetService {
     this.calculatingDepth += 1;
     let succeeded = false;
     try {
-      const pageData = RuntimeSheetService.calculatePages(sheet.dataCenter, this.formState.state);
+      const pageData = this.context.formType === FormTypeEnum.FILE ? [] : RuntimeSheetService.calculatePages(sheet.dataCenter, this.formState.state);
       this.assertAlive();
       sheet.pageData = pageData;
       sheet.paginationError = void 0;
@@ -2147,7 +2200,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;
   }
@@ -2306,7 +2359,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));
   }
 };
@@ -2493,11 +2546,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);
@@ -2512,7 +2565,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);
@@ -2529,7 +2582,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);
@@ -2544,7 +2597,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);
@@ -2558,11 +2611,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);
     }
   }
@@ -2572,7 +2625,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);
@@ -2587,7 +2640,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);
@@ -2617,7 +2670,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);
@@ -2632,7 +2685,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);
@@ -2646,11 +2699,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);
     }
   }
@@ -2660,11 +2713,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;
@@ -2690,11 +2743,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);
     }
   }
@@ -2704,7 +2757,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);
@@ -3041,6 +3094,518 @@ 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"))
+    });
+  }
+  const configuredMinCoversZero = enableRangeValidate && minValidateMode === RangeValidateMode.Fixed_Number && !isEmptyValue(minValue) && Number(minValue) >= 0 && (resolvedMinCompareOp === RangeCompareOp.GE || resolvedMinCompareOp === RangeCompareOp.GT);
+  if (input.defaultMinValue === 0 && !configuredMinCoversZero) {
+    RuleProps.push(
+      createRule(
+        (_rule, value) => isEmptyValue(value) || Number(value) >= 0,
+        buildError(validatorInfo, rangeCompareMessage(RangeCompareOp.GE, 0))
+      )
+    );
+  }
+  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;
@@ -3166,7 +3731,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];
     }
   }
@@ -3180,7 +3745,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];
     }
@@ -3223,7 +3788,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];
     }
   }
@@ -10437,117 +11002,132 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 });
 const DynamicTableAction = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-53d7e66c"]]);
 export {
-  setFormulaParamsConfig as $,
-  getObjectBomProductQuery as A,
+  DocumentPaper as $,
+  runWithFillProduct as A,
   BorderTD as B,
-  normalizeHistoricalAutofillRow as C,
+  useNocodeFormWidget as C,
   DEFAULT_BOOLEAN_FIELD_WIDTH as D,
-  EMPTY_PRODUCT_VERSION_ID as E,
-  parseRuntimeFieldPath as F,
-  useStyles as G,
-  useDependency as H,
-  useFieldPresentation as I,
-  useRuntimeEditorFlusher as J,
-  createRuntimeInstanceContext as K,
-  RuntimeInstanceRegistry as L,
+  applyConsumeObjectTraceChange as E,
+  getObjectBomProductQuery as F,
+  EMPTY_PRODUCT_VERSION_ID as G,
+  normalizeHistoricalAutofillRow as H,
+  readSealValue as I,
+  isSealStamped as J,
+  stampSealValue as K,
+  isValidSealValue as L,
   MAX_RUNTIME_SHEETS as M,
-  NCB_PROVIDE as N,
-  RequiredQtyCalcRule as O,
-  DocumentPaper as P,
-  DynamicTableAction as Q,
-  RuntimeFormStateStore as R,
-  ScanParamType as S,
-  getRuntimeDataFieldId as T,
-  buildRuntimeFieldPath as U,
-  resolveRuntimeFieldProps as V,
-  resolveRuntimeFieldState as W,
-  getRuntimeDependencyOutputKey as X,
-  isRowAddedInCurrentFormChange as Y,
-  MaterialConsumeTableController as Z,
-  _sfc_main$5 as _,
+  clearSealValue as N,
+  parseRuntimeFieldPath as O,
+  NCB_PROVIDE as P,
+  calculateFormula as Q,
+  useStyles as R,
+  useDependency as S,
+  useFieldPresentation as T,
+  useRuntimeEditorFlusher as U,
+  RuntimeFormStateStore as V,
+  createRuntimeInstanceContext as W,
+  RuntimeInstanceRegistry as X,
+  ScanParamType as Y,
+  RequiredQtyCalcRule as Z,
+  moveSealValue as _,
   MAX_RUNTIME_SHEET_TITLE_LENGTH as a,
-  normalizeRuntime as a0,
-  RuntimeSheetService as a1,
-  validateObjectBomQtyOnSubmit as a2,
-  closeValidatorPopovers as a3,
-  enrichFormChangeRowDetails as a4,
-  useMaterialBalance as a5,
-  collectFormChangeFieldLocations as a6,
-  nextFormChangeRowViewHistoryId as a7,
-  DeviceConnector as a8,
-  DocumentLoading as a9,
-  pickObjectFieldKeys as aA,
-  recordSubtableRowAdd as aB,
-  recordSubtableRowDelete as aC,
-  resolveAnnotationFieldLocation as aD,
-  resolveFormChangeRowUi as aE,
-  resolveRowFormChangeMark as aF,
-  setSelectMobileTdId as aG,
-  stripLegacyFormConfigFromPaper as aH,
-  SubTableActionMenuTypeEnum as aI,
-  getMenuByAction as aJ,
-  SubTableActionEnum as aK,
-  resolveScanFillData as aL,
-  buildDefaultMapFromProfile as aM,
-  buildFieldStatusFromProfile as aN,
-  getRowHandlersForFieldChange as aO,
-  getInsertSubMenu as aP,
-  resolveScanAdjustType as aQ,
-  resolveScanQty as aR,
-  toDateOnly as aS,
-  hasSubtableBusinessData as aT,
-  getCopySubMenu as aU,
-  resolveScanParsedValue as aV,
-  isProductBatchEmptyRow as aW,
-  DynamicQuickFillModal as aa,
-  FixedQuickFillModal as ab,
-  FormTmplConfigController as ac,
-  LEGACY_RUNTIME_FORM_CONFIG_KEYS as ad,
-  LEGACY_RUNTIME_SHEET_ID as ae,
-  LEGACY_RUNTIME_SHEET_TITLE as af,
-  MCDataUtil as ag,
-  OCR_MODEL_PRECISION_ENUM_KEY as ah,
-  RuntimeAsyncTaskCoordinator as ai,
-  RuntimeDependencyService as aj,
-  RuntimeFieldRegistry as ak,
-  RuntimeInstanceEventBus as al,
-  RuntimePersistenceCoordinator as am,
-  RuntimeValidationService as an,
-  SubTableCore as ao,
-  buildFormChangeDisplayRows as ap,
-  convertV1Runtime as aq,
-  detailsHaveFormChangeRowOps as ar,
-  extractFormChangeRowDetails as as,
-  getFormChangeRowKey as at,
-  getFormChangeRowOp as au,
-  getSubTableQuickFillInfo as av,
-  isAnnLocationSelected as aw,
-  isBlank as ax,
-  isFormChangeGhostRow as ay,
-  normalizeHistoricalFieldConfig as az,
+  buildDefaultMapFromProfile as a$,
+  DynamicTableAction as a0,
+  _sfc_main$5 as a1,
+  getRuntimeDataFieldId as a2,
+  buildRuntimeFieldPath as a3,
+  resolveRuntimeFieldProps as a4,
+  resolveRuntimeFieldState as a5,
+  assembleRules as a6,
+  isAttachFieldActive as a7,
+  getRuntimeDependencyOutputKey as a8,
+  isRowAddedInCurrentFormChange as a9,
+  RuntimePersistenceCoordinator as aA,
+  RuntimeValidationService as aB,
+  SubTableCore as aC,
+  buildFormChangeDisplayRows as aD,
+  convertV1Runtime as aE,
+  detailsHaveFormChangeRowOps as aF,
+  extractFormChangeRowDetails as aG,
+  getFormChangeRowKey as aH,
+  getFormChangeRowOp as aI,
+  getSubTableQuickFillInfo as aJ,
+  isAnnLocationSelected as aK,
+  isBlank as aL,
+  isFormChangeGhostRow as aM,
+  normalizeHistoricalFieldConfig as aN,
+  pickObjectFieldKeys as aO,
+  recordSubtableRowAdd as aP,
+  recordSubtableRowDelete as aQ,
+  relocateDeletedRowsToEnd as aR,
+  resolveAnnotationFieldLocation as aS,
+  resolveFormChangeRowUi as aT,
+  resolveRowFormChangeMark as aU,
+  setSelectMobileTdId as aV,
+  stripLegacyFormConfigFromPaper as aW,
+  SubTableActionMenuTypeEnum as aX,
+  getMenuByAction as aY,
+  SubTableActionEnum as aZ,
+  resolveScanFillData as a_,
+  MaterialConsumeTableController as aa,
+  setFormulaParamsConfig as ab,
+  normalizeRuntime as ac,
+  initializeSealFields as ad,
+  RuntimeSheetService as ae,
+  validateObjectBomQtyOnSubmit as af,
+  areValidationCommentsEqual as ag,
+  closeValidatorPopovers as ah,
+  enrichFormChangeRowDetails as ai,
+  useMaterialBalance as aj,
+  collectFormChangeFieldLocations as ak,
+  nextFormChangeRowViewHistoryId as al,
+  DeviceConnector as am,
+  DocumentLoading as an,
+  DynamicQuickFillModal as ao,
+  FixedQuickFillModal as ap,
+  FormTmplConfigController as aq,
+  LEGACY_RUNTIME_FORM_CONFIG_KEYS as ar,
+  LEGACY_RUNTIME_SHEET_ID as as,
+  LEGACY_RUNTIME_SHEET_TITLE as at,
+  MCDataUtil as au,
+  OCR_MODEL_PRECISION_ENUM_KEY as av,
+  RuntimeAsyncTaskCoordinator as aw,
+  RuntimeDependencyService as ax,
+  RuntimeFieldRegistry as ay,
+  RuntimeInstanceEventBus as az,
   bindFormulaCacheInvalidation as b,
+  buildFieldStatusFromProfile as b0,
+  getRowHandlersForFieldChange as b1,
+  getInsertSubMenu as b2,
+  resolveScanAdjustType as b3,
+  resolveScanQty as b4,
+  toDateOnly as b5,
+  hasSubtableBusinessData as b6,
+  getCopySubMenu as b7,
+  resolveScanParsedValue as b8,
+  isProductBatchEmptyRow as b9,
   currentParamsConfig as c,
   MULTI_SHEET_SCHEMA_VERSION as d,
-  createRuntimeDocumentV2 as e,
-  findFieldProfile as f,
-  getBusinessFieldKey as g,
-  normalizeHistoricalBusinessRow as h,
-  DeviceLinkTmplUtil as i,
-  normalizeAIOcrTmpl as j,
-  useWidgetStaticAttrs as k,
-  useRuntimeInstanceServices as l,
-  setSelectAnnotationId as m,
-  normalizeFieldWidth as n,
-  useRuntimeRowState as o,
-  getObjectBomMaterialLotQuery as p,
-  buildObjectLotExtraQuery as q,
-  resolveObjectFieldKeys as r,
+  getBusinessFieldKey as e,
+  createRuntimeDocumentV2 as f,
+  getParseFormulaVarInfos as g,
+  clampSealPosition as h,
+  normalizeFieldWidth as i,
+  findFieldProfile as j,
+  normalizeHistoricalBusinessRow as k,
+  DeviceLinkTmplUtil as l,
+  normalizeAIOcrTmpl as m,
+  normalizeSealDiameter as n,
+  useWidgetStaticAttrs as o,
+  useRuntimeInstanceServices as p,
+  setSelectAnnotationId as q,
+  useRuntimeRowState as r,
   setSelectValidatorId as s,
-  MaterialConsumptionPatternEnum as t,
+  getObjectBomMaterialLotQuery as t,
   useFormTmplConfig as u,
-  validateObjectBomForScan as v,
-  resolveObjectBomEntry as w,
-  runWithFillProduct as x,
-  useNocodeFormWidget as y,
-  applyConsumeObjectTraceChange as z
+  buildObjectLotExtraQuery as v,
+  resolveObjectFieldKeys as w,
+  MaterialConsumptionPatternEnum as x,
+  validateObjectBomForScan as y,
+  resolveObjectBomEntry as z
 };