@gct-paas/excel 0.1.16 → 0.1.18

package/dist/{document-quick-fillin.vue_vue_type_style_index_0_scoped_a18386ab_lang-Bbu6cwRC.js → document-quick-fillin.vue_vue_type_style_index_0_scoped_a18386ab_lang-DKTGEH4Q.js}

@@ -1,5 +1,6 @@
-import { computed, defineComponent, ref, onMounted, openBlock, createBlock, Transition, withCtx, withDirectives, createElementVNode, normalizeClass, normalizeStyle, toDisplayString, vShow, createVNode, render as render$1, inject, toRef, h as h$1, toRaw, watch, nextTick as nextTick$1, defineAsyncComponent, getCurrentInstance } from "vue";
+import { computed, defineComponent, ref, onMounted, openBlock, createBlock, Transition, withCtx, withDirectives, createElementVNode, normalizeClass, normalizeStyle, toDisplayString, vShow, createVNode, render as render$1, inject, toRef, h as h$1, toRaw, nextTick as nextTick$1, watch, defineAsyncComponent, getCurrentInstance } from "vue";
 import { isNil, keyBy, pick, isEmpty, mapKeys, cloneDeep, flatMap, zip, merge, pickBy, omit, has, isObject as isObject$1, defaults, groupBy, omitBy, isEqual, get as get$1, last, first } from "lodash-es";
+import { api as api$1 } from "@gct-paas/api";
 import dayjs from "dayjs";
 var PlatformEnum = /* @__PURE__ */ ((PlatformEnum2) => {
   PlatformEnum2["INTEGRATION_PAAS_DP"] = "INTEGRATION_PAAS_DP";
@@ -161,6 +162,13 @@ var RangeValidateMode = /* @__PURE__ */ ((RangeValidateMode2) => {
   RangeValidateMode2["Variable_Validate"] = "VariableValidate";
   return RangeValidateMode2;
 })(RangeValidateMode || {});
+var RangeCompareOp = /* @__PURE__ */ ((RangeCompareOp2) => {
+  RangeCompareOp2["LE"] = "le";
+  RangeCompareOp2["LT"] = "lt";
+  RangeCompareOp2["GE"] = "ge";
+  RangeCompareOp2["GT"] = "gt";
+  return RangeCompareOp2;
+})(RangeCompareOp || {});
 var DecimalDisplayMode = /* @__PURE__ */ ((DecimalDisplayMode2) => {
   DecimalDisplayMode2["PERCENT"] = "percent";
   DecimalDisplayMode2["ORIGIN"] = "origin";
@@ -475,28 +483,39 @@ const mergeByMultiKey = (A, B, {
   });
   return result;
 };
+const CLIENT_ROW_UID_KEY = "__gct_rv_uid";
+const FRONT_ROW_KEY = "front_row_key_";
+function ensureFrontRowKey(row) {
+  if (!row) return "";
+  const existing = row[FRONT_ROW_KEY];
+  if (existing != null && String(existing).trim() !== "") return String(existing);
+  const uid = `r_${Date.now()}_${uuid2(8)}`;
+  row[FRONT_ROW_KEY] = uid;
+  return uid;
+}
 const getRowId = (row) => {
   if (!row) return "";
-  if (!isNil(row.id_)) return row.id_;
-  const ROW_UID_KEY = "__gct_rv_uid";
-  if (!row[ROW_UID_KEY]) {
-    row[ROW_UID_KEY] = `r_${Date.now()}_${uuid2(8)}`;
+  if (row[FRONT_ROW_KEY] != null && String(row[FRONT_ROW_KEY]).trim() !== "") {
+    return String(row[FRONT_ROW_KEY]);
   }
-  return row[ROW_UID_KEY];
+  if (!isNil(row.id_)) return String(row.id_);
+  return ensureFrontRowKey(row);
 };
-function getGct() {
-  return window?._gct;
-}
-const api = new Proxy(
-  {},
-  {
-    get(_target, prop) {
-      const hostApi = getGct()?.api;
-      const value = hostApi?.[prop];
-      return typeof value === "function" ? value.bind(hostApi) : value;
+function getApi$2() {
+  if (typeof globalThis !== "undefined") {
+    const globalApi = globalThis._api;
+    if (globalApi) {
+      return globalApi;
     }
   }
-);
+  return api$1;
+}
+const api = new Proxy(api$1, {
+  get(_target, prop) {
+    const real = getApi$2();
+    return Reflect.get(real, prop, real);
+  }
+});
 const baseDataUtils = {
   baseApis: {
     getOneData2SqlView: api.apaas.sqlView.postBizServiceModelKeyBsKey,
@@ -56592,10 +56611,14 @@ const transformUtils = {
     const rowData = { ...baseData };
     if (payload.isRowSubTable2d) {
       const groupKey = `dyn${uuid2(16)}`;
-      const _2DTABLE_ = Array.from({ length: payload.childInitRowLen }, () => ({
-        ...baseData,
-        ...pick(subDefaultData, payload.crossFieldKeys)
-      }));
+      const _2DTABLE_ = Array.from({ length: payload.childInitRowLen }, () => {
+        const child = {
+          ...baseData,
+          ...pick(subDefaultData, payload.crossFieldKeys)
+        };
+        ensureFrontRowKey(child);
+        return child;
+      });
       const extraData = { ...omit(subDefaultData, payload.crossFieldKeys) };
       Object.assign(rowData, {
         group_: groupKey,
@@ -56605,6 +56628,7 @@ const transformUtils = {
     } else {
       Object.assign(rowData, subDefaultData);
     }
+    ensureFrontRowKey(rowData);
     return rowData;
   },
   /** 数据转成真实提交数据（二维表要平铺） */
@@ -56615,7 +56639,7 @@ const transformUtils = {
       materialConsumeTableList = []
     } = paper?.props || {};
     const list2D = [...subTable2DList, ...checkTable2DList];
-    const filterKeys = ["_DICT", "_OPCT", "__FOREIGN__", "_MCTABLE"];
+    const filterKeys = ["_DICT", "_OPCT", "__FOREIGN__", "_MCTABLE", CLIENT_ROW_UID_KEY];
     const realFormData = Object.keys(formData).reduce((acc, fieldKey) => {
       const info = list2D.find(
         (item) => (item.subTable2d || item.checkTable2d) && item.rowSubFieldKey === fieldKey
@@ -56644,7 +56668,10 @@ const transformUtils = {
             )
           )
         ).map((item) => omit(item, "_2DTABLE_"));
-        acc[fieldKey] = arr.every((item) => Object.keys(item).length === 1 && has(item, "group_")) ? [] : arr;
+        acc[fieldKey] = arr.every((item) => {
+          const keys2 = Object.keys(item).filter((key) => key !== FRONT_ROW_KEY);
+          return keys2.length === 1 && has(item, "group_");
+        }) ? [] : arr;
       } else if (Array.isArray(formData[fieldKey])) {
         acc[fieldKey] = formData[fieldKey].map(
           (item) => Object.fromEntries(
@@ -57297,17 +57324,19 @@ const renderUtils = {
     return Boolean(parseInt(value));
   },
   /** 判断一个日期或日期时间字符串是否在最小和最大时间戳之间 */
-  isOutOfRange: (inputStr, minTimestamp, maxTimestamp) => {
+  isOutOfRange: (inputStr, minTimestamp, maxTimestamp, minCompareOp, maxCompareOp) => {
     if (isNil(inputStr)) {
       return false;
     }
     const inputTime = dayjs(inputStr).unix();
     if (isNaN(inputTime)) return false;
-    if (!isNil(minTimestamp) && !isNaN(minTimestamp) && inputTime < minTimestamp) {
-      return true;
+    if (!isNil(minTimestamp) && !isNaN(minTimestamp)) {
+      const pass = minCompareOp === "gt" ? inputTime > minTimestamp : inputTime >= minTimestamp;
+      if (!pass) return true;
     }
-    if (!isNil(maxTimestamp) && !isNaN(maxTimestamp) && inputTime > maxTimestamp) {
-      return true;
+    if (!isNil(maxTimestamp) && !isNaN(maxTimestamp)) {
+      const pass = maxCompareOp === "lt" ? inputTime < maxTimestamp : inputTime <= maxTimestamp;
+      if (!pass) return true;
     }
     return false;
   },
@@ -57444,7 +57473,7 @@ const renderUtils = {
           FIELD_TYPE.PRODUCT,
           FIELD_TYPE.ROUTING_OPERATION,
           FIELD_TYPE.MFG_ORDER
-        ].includes(fieldType) || [FIELD_TYPE.WAREHOUSE, FIELD_TYPE.E_SOP, FIELD_TYPE.E_SOP_VERSION].includes(bizType)) || !isNil(defaultValue) && defaultValue !== "";
+        ].includes(fieldType) || [FIELD_TYPE.E_SOP, FIELD_TYPE.E_SOP_VERSION].includes(bizType)) && !subFieldKey && !subModelKey || bizType === FIELD_TYPE.WAREHOUSE || !isNil(defaultValue) && defaultValue !== "";
         if (shouldPushDefaultValueField && !useDefaultValueFields[key]) {
           useDefaultValueFields[key] = {
             fieldId,
@@ -57741,6 +57770,7 @@ const renderUtils = {
           case FIELD_TYPE.REF:
           case FIELD_TYPE.REF_MULTI:
             const isRdo = [FIELD_TYPE.E_SOP].includes(bizType);
+            const isBizType = [FIELD_TYPE.E_SOP].includes(bizType);
             const queryCondition = refUtils.generateQueryConditions(field.dataFilter, paramsConfig);
             return await getRefList({
               modelKey,
@@ -57749,7 +57779,10 @@ const renderUtils = {
               queryData: {
                 ...queryCondition.dataFilterFixedQueryData,
                 ...defaultQuery,
-                ...newQueryData
+                ...newQueryData,
+                ...isBizType ? {
+                  operating_state_: true
+                } : {}
               },
               // 库位需要数据联动，初始化不要加载
               needDataLink: field.field === "location_id_",
@@ -59471,194 +59504,1217 @@ const calcUtils = {
     return pageData;
   }
 };
-function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function(target) {
-    for (var i2 = 1; i2 < arguments.length; i2++) {
-      var source = arguments[i2];
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
+var NCB_PROVIDE = /* @__PURE__ */ ((NCB_PROVIDE2) => {
+  NCB_PROVIDE2["IS_PDF"] = "NCB_IsPdf";
+  NCB_PROVIDE2["FROM_DATA"] = "NCB_FromState";
+  NCB_PROVIDE2["DEFAULT_FIELD_DATA"] = "NCB_DefaultFieldData";
+  NCB_PROVIDE2["DATA_RELATION_SHIP"] = "NCB_DataRelationShip";
+  NCB_PROVIDE2["PAGE_DATA_CALL_BACK"] = "NCB_PageDataCallback";
+  NCB_PROVIDE2["FORM_INST_LIST"] = "NCB_FormInstList";
+  NCB_PROVIDE2["MOBILE_FILL_FIELDS_POPUP"] = "NCB_MobileFillFieldsPopup";
+  NCB_PROVIDE2["TMPL_BOM_CONTROLLER_MAP"] = "NCB_TmplBomControllerMap";
+  NCB_PROVIDE2["MATERIAL_CONSUME_TABLE_CONTROLLER"] = "NCB_MaterialConsumeTableController";
+  NCB_PROVIDE2["CHECK_TABLE_COL_INDEX"] = "NCB_CheckTableColIndex";
+  NCB_PROVIDE2["SUB_TABLE_CORE_FACTORY_MAP"] = "NCB_SubTableCoreFactoryMap";
+  NCB_PROVIDE2["SUB_TABLE_CORE"] = "NCB_SubTableCore";
+  NCB_PROVIDE2["PAGER"] = "NCB_Pager";
+  return NCB_PROVIDE2;
+})(NCB_PROVIDE || {});
+function mitt(all) {
+  all = all || /* @__PURE__ */ new Map();
+  return {
+    /**
+     * A Map of event names to registered handler functions.
+     */
+    all,
+    /**
+     * Register an event handler for the given type.
+     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events
+     * @param {Function} handler Function to call in response to given event
+     * @memberOf mitt
+     */
+    on(type4, handler) {
+      const handlers = all.get(type4);
+      if (handlers) {
+        handlers.push(handler);
+      } else {
+        all.set(type4, [handler]);
+      }
+    },
+    /**
+     * Remove an event handler for the given type.
+     * If `handler` is omitted, all handlers of the given type are removed.
+     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
+     * @param {Function} [handler] Handler function to remove
+     * @memberOf mitt
+     */
+    off(type4, handler) {
+      const handlers = all.get(type4);
+      if (handlers) {
+        if (handler) {
+          handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+        } else {
+          all.set(type4, []);
         }
       }
+    },
+    /**
+     * Invoke all handlers for the given type.
+     * If present, `'*'` handlers are invoked after type-matched handlers.
+     *
+     * Note: Manually firing '*' handlers is not supported.
+     *
+     * @param {string|symbol} type The event type to invoke
+     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
+     * @memberOf mitt
+     */
+    emit(type4, evt) {
+      let handlers = all.get(type4);
+      if (handlers) {
+        handlers.slice().forEach((handler) => {
+          handler(evt);
+        });
+      }
+      handlers = all.get("*");
+      if (handlers) {
+        handlers.slice().forEach((handler) => {
+          handler(type4, evt);
+        });
+      }
+    },
+    /**
+     * Clear all
+     */
+    clear() {
+      this.all.clear();
     }
-    return target;
   };
-  return _extends.apply(this, arguments);
 }
-function _inheritsLoose(subClass, superClass) {
-  subClass.prototype = Object.create(superClass.prototype);
-  subClass.prototype.constructor = subClass;
-  _setPrototypeOf(subClass, superClass);
-}
-function _getPrototypeOf(o) {
-  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
-    return o2.__proto__ || Object.getPrototypeOf(o2);
+const emitter = mitt();
+var EmitterEnum = /* @__PURE__ */ ((EmitterEnum2) => {
+  EmitterEnum2["__on__open_single_annotation_detail_"] = "__on__open_single_annotation_detail_";
+  EmitterEnum2["__on__update_page_dom_"] = "__on__update_page_dom_";
+  EmitterEnum2["__on_select_ebr_doc_instance_id"] = "__on_select_ebr_doc_instance_id";
+  EmitterEnum2["__on_looper_auto_save"] = "__on_looper_auto_save";
+  EmitterEnum2["__on_diff_ebr_form_state"] = "__on_diff_ebr_form_state";
+  return EmitterEnum2;
+})(EmitterEnum || {});
+function useNocodeEmitter() {
+  return {
+    emitter,
+    EmitterEnum
   };
-  return _getPrototypeOf(o);
 }
-function _setPrototypeOf(o, p2) {
-  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p3) {
-    o2.__proto__ = p3;
-    return o2;
+function useCurrentPageFormState() {
+  const formStateMap = inject(NCB_PROVIDE.FROM_DATA);
+  const dataRelationShip = inject(NCB_PROVIDE.DATA_RELATION_SHIP);
+  const currentPageFormState = computed(() => {
+    return formStateMap?.[dataRelationShip?.uniqueId ?? ""] ?? {};
+  });
+  return {
+    currentPageFormState
   };
-  return _setPrototypeOf(o, p2);
 }
-function _isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-  if (Reflect.construct.sham) return false;
-  if (typeof Proxy === "function") return true;
-  try {
-    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
-    }));
-    return true;
-  } catch (e) {
-    return false;
+function useWidgetStaticAttrs(widget) {
+  const dataRelationShip = inject(NCB_PROVIDE.DATA_RELATION_SHIP);
+  const {
+    field = "",
+    fieldType,
+    bizType,
+    isFieldModel,
+    fieldLink,
+    modelKey = dataRelationShip?.modelKey,
+    refModelKey,
+    placeholder,
+    bindCompStyleType,
+    newSpecificConfig
+  } = widget.props || {};
+  let viewState = widget.props?.viewState;
+  if (fieldType === FIELD_TYPE.ATTACHMENT && viewState === CellWidgetViewState.Auto) {
+    viewState = CellWidgetViewState.Readonly;
   }
-}
-function _construct(Parent, args, Class) {
-  if (_isNativeReflectConstruct()) {
-    _construct = Reflect.construct.bind();
-  } else {
-    _construct = function _construct2(Parent2, args2, Class2) {
-      var a = [null];
-      a.push.apply(a, args2);
-      var Constructor = Function.bind.apply(Parent2, a);
-      var instance = new Constructor();
-      if (Class2) _setPrototypeOf(instance, Class2.prototype);
-      return instance;
+  const disabled = toRef(widget.props, "disabled");
+  const readonly = toRef(widget.props, "field_readonly");
+  const newRequired = toRef(widget.props, "required");
+  const newQueryDataRef = computed(() => widget.props.newSpecificConfig?.newQueryData);
+  const customLoaderRef = computed(() => widget.props.newSpecificConfig?.customLoader);
+  const {
+    newFieldName,
+    newModelName,
+    newOptions = [],
+    newUploadConfig = {},
+    newPrecision = 0,
+    newLoadFinished2Options,
+    newTotalCount,
+    newRefRecordNo,
+    newQueryData,
+    newQueryCondition,
+    forcedDisabled,
+    forcedReadonlyText,
+    newPlaceholder,
+    newRulesForRounding,
+    newComponentProps = {},
+    newDisplayRule = void 0,
+    newSnNo = void 0
+  } = newSpecificConfig || {};
+  const targetFieldId = field ? isFieldModel ? fieldLink : field : "";
+  const newDisplayStatus = computed(() => {
+    const readonlyString = viewState === CellWidgetViewState.Disabled || viewState === CellWidgetViewState.Auto ? "readonly-component" : "readonly-text";
+    const editString = readonly.value ? "readonly-component" : "edit-component";
+    if (dataRelationShip?.annSwitchStatus || forcedReadonlyText) return "readonly-text";
+    if (isFieldModel) return readonlyString;
+    const renderMode = dataRelationShip?.renderModeType;
+    const bpmnMap = dataRelationShip?.bpmnFieldAuthMap;
+    const key = `${modelKey}.${field}`;
+    const getFieldAuth = () => bpmnMap?.[key];
+    const resolveFromAuth = (info) => {
+      if (isEmpty(info)) return null;
+      if (info.edit && !info.readonly) return editString;
+      if (info.readonly && !info.edit) return readonlyString;
+      return null;
     };
-  }
-  return _construct.apply(null, arguments);
-}
-function _isNativeFunction(fn) {
-  return Function.toString.call(fn).indexOf("[native code]") !== -1;
-}
-function _wrapNativeSuper(Class) {
-  var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
-  _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
-    if (Class2 === null || !_isNativeFunction(Class2)) return Class2;
-    if (typeof Class2 !== "function") {
-      throw new TypeError("Super expression must either be null or a function");
+    if (renderMode === RenderModeEnum.FormMode) {
+      if (dataRelationShip?.formType !== FormTypeEnum.PROCESS) {
+        const auth2 = getFieldAuth();
+        const fromAuth2 = resolveFromAuth(auth2);
+        return fromAuth2 ?? editString;
+      }
+      const auth = getFieldAuth();
+      const fromAuth = resolveFromAuth(auth);
+      if (fromAuth) return fromAuth;
+      const bpmnType = dataRelationShip?.bpmnType;
+      if (bpmnType === BpmnNodeTypeEnum.BpmnApproval || bpmnType === BpmnNodeTypeEnum.BpmnJudge) {
+        return readonlyString;
+      }
+      return editString;
     }
-    if (typeof _cache !== "undefined") {
-      if (_cache.has(Class2)) return _cache.get(Class2);
-      _cache.set(Class2, Wrapper);
+    if (renderMode === RenderModeEnum.ViewMode) {
+      return readonlyString;
     }
-    function Wrapper() {
-      return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
+    return readonly.value ? "readonly-text" : "edit-component";
+  });
+  const newDisabled = computed(() => {
+    if (newDisplayStatus.value === "edit-component") {
+      return forcedDisabled || disabled.value;
     }
-    Wrapper.prototype = Object.create(Class2.prototype, {
-      constructor: {
-        value: Wrapper,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-    return _setPrototypeOf(Wrapper, Class2);
+    return viewState === CellWidgetViewState.Disabled || disabled.value;
+  });
+  const isAutoLineBreak = computed(() => {
+    if (!isEmpty(widget.style) && has(widget.style, "whiteSpace") && has(widget.style, "wordBreak") && widget.style.whiteSpace === "pre-wrap" && widget.style.wordBreak === "break-all") {
+      return true;
+    }
+    return false;
+  });
+  return {
+    field,
+    fieldType,
+    /** 业务类型 */
+    bizType,
+    modelKey,
+    refModelKey,
+    isFieldModel,
+    fieldLink,
+    targetFieldId,
+    placeholder: newPlaceholder || placeholder,
+    bindCompStyleType,
+    /** 字段名称 */
+    showFieldName: newFieldName,
+    /** 字段所属模型名称 */
+    showModelName: newModelName,
+    /** 是否必填 */
+    showRequired: newRequired,
+    /** 是否禁用 */
+    showDisabled: newDisabled,
+    /** 显示状态 */
+    showDisplayStatus: newDisplayStatus,
+    /** 下拉列表 */
+    options: newOptions,
+    /** 附件、图片配置项 */
+    uploadConfig: newUploadConfig,
+    /** 小数位数 */
+    realPrecision: newPrecision,
+    /** 精度小数的修约规则 */
+    rulesForRounding: newRulesForRounding,
+    /** 记录单号是否是链接 */
+    realRefRecordNo: newRefRecordNo,
+    /** 下拉列表内容是否都加载完成 */
+    loadFinished2Options: newLoadFinished2Options,
+    /** Rdo下拉框内容总数 */
+    newTotalCount,
+    /** 查询条件 */
+    newQueryData,
+    /** 查询条件响应式 */
+    newQueryDataRef,
+    /** 自定义数据源加载函数 */
+    customLoaderRef,
+    /** 查询条件 */
+    queryCondition: newQueryCondition,
+    /** 组件额外参数 */
+    newComponentProps,
+    /** 显示规则 */
+    newDisplayRule,
+    dataRelationShip,
+    /** 是否是自动换行 */
+    isAutoLineBreak,
+    /** 序列号 */
+    newSnNo
   };
-  return _wrapNativeSuper(Class);
 }
-var formatRegExp = /%[sdj%]/g;
-var warning = function warning2() {
-};
-if (typeof process !== "undefined" && process.env && process.env.NODE_ENV !== "production" && typeof window !== "undefined" && typeof document !== "undefined") {
-  warning = function warning3(type4, errors) {
-    if (typeof console !== "undefined" && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === "undefined") {
-      if (errors.every(function(e) {
-        return typeof e === "string";
-      })) {
-        console.warn(type4, errors);
-      }
+function useCalculateFormula() {
+  const { identify, calculate } = {
+    identify: (...args) => window.NocodeAdapter.utils?.formulaIdentify?.(...args) ?? [],
+    calculate: (...args) => window.NocodeAdapter.utils?.formulaCalculate?.(...args)
+  };
+  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((i2) => !isNil(i2));
     }
+    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 getParseFormulaVarInfos2 = (expr) => {
+    const rowArgs = expr ? identify(expr) : [];
+    return {
+      rowArgs,
+      parseInfos: rowArgs.map((curr) => parseFormulaVar(curr))
+    };
+  };
+  const calculateFormula2 = async (expr, formData, currentPageFormState) => {
+    const rowArgs = identify(expr);
+    const formulaData = isEmpty(rowArgs) ? {} : rowArgs.reduce((total, curr) => {
+      const parseInfo = parseFormulaVar(curr);
+      total[curr] = getFieldDataValue(
+        parseInfo,
+        parseInfo.dataType === "currentRowType" ? formData : currentPageFormState
+      );
+      return total;
+    }, {});
+    return calculate(expr, formulaData);
+  };
+  const mergeParseInfos = (a = [], b = []) => {
+    const map = /* @__PURE__ */ new Map();
+    const keyOf = (p2) => `${p2.type}||${p2.processed}||${p2.hashValue ?? ""}`;
+    for (const p2 of a || []) map.set(keyOf(p2), p2);
+    for (const p2 of b || []) map.set(keyOf(p2), p2);
+    return Array.from(map.values());
+  };
+  const getMergeParseInfos = (options) => {
+    const { minFormulaExpr, maxFormulaExpr } = options;
+    let minInfos = [];
+    let maxInfos = [];
+    try {
+      if (minFormulaExpr) minInfos = getParseFormulaVarInfos2(minFormulaExpr)?.parseInfos || [];
+    } catch (e) {
+      minInfos = [];
+    }
+    try {
+      if (maxFormulaExpr) maxInfos = getParseFormulaVarInfos2(maxFormulaExpr)?.parseInfos || [];
+    } catch (e) {
+      maxInfos = [];
+    }
+    const merged = mergeParseInfos(minInfos, maxInfos);
+    return merged;
+  };
+  return {
+    identify,
+    getParseFormulaVarInfos: getParseFormulaVarInfos2,
+    calculateFormula: calculateFormula2,
+    getMergeParseInfos
   };
 }
-function convertFieldsError(errors) {
-  if (!errors || !errors.length) return null;
-  var fields = {};
-  errors.forEach(function(error) {
-    var field = error.field;
-    fields[field] = fields[field] || [];
-    fields[field].push(error);
-  });
-  return fields;
-}
-function format(template) {
-  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    args[_key - 1] = arguments[_key];
-  }
-  var i2 = 0;
-  var len = args.length;
-  if (typeof template === "function") {
-    return template.apply(null, args);
-  }
-  if (typeof template === "string") {
-    var str = template.replace(formatRegExp, function(x) {
-      if (x === "%%") {
-        return "%";
-      }
-      if (i2 >= len) {
-        return x;
-      }
-      switch (x) {
-        case "%s":
-          return String(args[i2++]);
-        case "%d":
-          return Number(args[i2++]);
-        case "%j":
-          try {
-            return JSON.stringify(args[i2++]);
-          } catch (_) {
-            return "[Circular]";
-          }
-          break;
-        default:
-          return x;
+function setSelectAnnotationId(id, basicInfoItem, event) {
+  if (!basicInfoItem) return;
+  const { emitter: emitter2, EmitterEnum: EmitterEnum2 } = useNocodeEmitter();
+  if (event?.target) {
+    const target = event.target;
+    const clickedIcon = target.closest(".annotation-icon");
+    if (clickedIcon) {
+      const cellDiv = target.closest(".cell-wrapper-container");
+      if (cellDiv) {
+        const scope = cellDiv.closest(".combine-fields-area") ?? cellDiv.closest("td") ?? cellDiv;
+        const locations = [
+          ...new Set(
+            Array.from(scope.querySelectorAll(".annotation-icon")).map((el2) => el2.dataset.ann).filter((loc) => !!loc)
+          )
+        ];
+        if (locations.length) {
+          basicInfoItem.annSelectId = locations.length === 1 ? locations[0] : locations;
+          emitter2.emit(EmitterEnum2.__on__open_single_annotation_detail_, {
+            cellLocation: locations.length === 1 ? locations[0] : locations
+          });
+          return;
+        }
       }
-    });
-    return str;
-  }
-  return template;
-}
-function isNativeStringType(type4) {
-  return type4 === "string" || type4 === "url" || type4 === "hex" || type4 === "email" || type4 === "date" || type4 === "pattern";
-}
-function isEmptyValue(value, type4) {
-  if (value === void 0 || value === null) {
-    return true;
-  }
-  if (type4 === "array" && Array.isArray(value) && !value.length) {
-    return true;
-  }
-  if (isNativeStringType(type4) && typeof value === "string" && !value) {
-    return true;
-  }
-  return false;
-}
-function asyncParallelArray(arr, func, callback) {
-  var results = [];
-  var total = 0;
-  var arrLength = arr.length;
-  function count(errors) {
-    results.push.apply(results, errors || []);
-    total++;
-    if (total === arrLength) {
-      callback(results);
     }
   }
-  arr.forEach(function(a) {
-    func(a, count);
+  if (isEmpty(id)) return;
+  const newId = id === "gct-nocode-ann-main" ? "" : id;
+  basicInfoItem.annSelectId = newId;
+  emitter2.emit(EmitterEnum2.__on__open_single_annotation_detail_, {
+    cellLocation: newId
   });
 }
-function asyncSerialArray(arr, func, callback) {
-  var index2 = 0;
-  var arrLength = arr.length;
-  function next(errors) {
-    if (errors && errors.length) {
-      callback(errors);
-      return;
-    }
-    var original = index2;
+function closeValidatorPopovers() {
+  document.querySelectorAll(".nocode-validator-tooltip-wrapper").forEach((node) => {
+    const host = node.closest(".ant-popover, .gct-popover, .popover");
+    host?.remove();
+  });
+}
+function setSelectValidatorId(event, basicInfoItem) {
+  if (basicInfoItem && event.target) {
+    closeValidatorPopovers();
+    const cellDiv = event.target.closest(".cell-wrapper-container");
+    if (!cellDiv) return;
+    const clickedIcon = event.target.closest(
+      ".validator-icon"
+    );
+    const scope = clickedIcon ? cellDiv.closest(".combine-fields-area") ?? cellDiv.closest("td") ?? cellDiv : cellDiv;
+    const ids = [
+      ...new Set(
+        Array.from(scope.querySelectorAll(".validator-icon")).map((el2) => el2.dataset.ann).filter((id) => !!id)
+      )
+    ];
+    const validateList = ids.map((id) => basicInfoItem.validatorMessageMap?.[id]).filter(Boolean);
+    const flattenedErrors = validateList.flatMap(
+      (validates) => validates.map(({ field: _field, message: message2 }) => JSON.parse(message2))
+    );
+    const resultMap = flattenedErrors.reduce((acc, item) => {
+      const { showModelName, showModelKey, subFieldKey, showFieldName, targetFieldId, message: message2 } = item;
+      if (!acc[showModelKey]) {
+        acc[showModelKey] = {
+          showModelName,
+          showModelKey,
+          subFieldKey,
+          fields: []
+        };
+      }
+      acc[showModelKey].fields.push({ showFieldName, targetFieldId, message: message2 });
+      return acc;
+    }, {});
+    if (Object.keys(resultMap).length) {
+      const contentVNode = h$1(
+        "div",
+        { class: "nocode-validator-tooltip-wrapper" },
+        Object.values(resultMap).map(
+          (data) => h$1("div", { class: "nocode-validator-tooltip-container", key: data.showModelKey }, [
+            h$1("div", { class: "nocode-validator-tooltip-header" }, data.showModelName),
+            h$1(
+              "div",
+              { class: "nocode-validator-tooltip-header-label" },
+              `${data.showModelKey}${data.subFieldKey ? "｜" + data.subFieldKey : ""}`
+            ),
+            h$1(
+              "ul",
+              { class: "nocode-validator-tooltip-content" },
+              data.fields.map(
+                (field, index2) => h$1(
+                  "li",
+                  { key: `${field.targetFieldId}-${index2}` },
+                  `${field.showFieldName}（${field.targetFieldId}）：${field.message}`
+                )
+              )
+            )
+          ])
+        )
+      );
+      const iconEl = clickedIcon ?? scope.querySelector(".validator-icon");
+      const anchorEl = iconEl ?? cellDiv;
+      window.window.NocodeAdapter.utils.overlay.popover(
+        anchorEl,
+        contentVNode,
+        {},
+        { placement: "top-center" }
+      );
+    }
+  }
+}
+function setSelectMobileTdId(tdInfo, basicInfoItem, widgetCenter, callback, sbRowIndex) {
+  const getWidgetInfo = () => {
+    const { preLocation, props: tdProps } = tdInfo || {};
+    const paper = widgetCenter?.[ComponentTypeEnum.PAPER];
+    const subTable2DList = paper.props.subTable2DList ?? [];
+    const checkTable2DList = paper.props.checkTable2DList ?? [];
+    const fixedTableLenMap = paper.props.fixedTableLenMap ?? {};
+    const getTdIds = (key) => [...basicInfoItem?.mobileTdIdGroups.get(key) || []];
+    const assignWidgetInfo = (fillType, params) => {
+      const { rowSubFieldKey = "", colSubFieldKey = "" } = params;
+      const mainSetKey = rowSubFieldKey !== "gct_mobile_main" ? `gct_mobile_sub.${rowSubFieldKey}` : rowSubFieldKey;
+      const linkSetKey = colSubFieldKey ? `gct_mobile_sub.${colSubFieldKey}` : colSubFieldKey;
+      return {
+        fillType,
+        clickTdId: tdInfo.id,
+        clickSbRowIndex: sbRowIndex,
+        mainWidgetIds: getTdIds(mainSetKey),
+        linkWidgetIds: getTdIds(linkSetKey),
+        subInfo: params
+      };
+    };
+    if (preLocation === ComponentTypeEnum.PAPER) {
+      if (tdProps.isNewFixedTableTd) {
+        const item2 = subTable2DList.find(
+          (i2) => i2.subTable2d && i2.colSubFieldKey === tdProps.fixedTableFieldId
+        );
+        return item2 ? assignWidgetInfo(MobileFillTypeEnum.SUB_TABLE_2D, {
+          ...item2,
+          childInitRowLen: 1 * ((fixedTableLenMap?.[item2.colSubFieldKey] ?? 0) + 1)
+        }) : assignWidgetInfo(MobileFillTypeEnum.FIXED_TABLE, {
+          rowSubFieldKey: tdProps.fixedTableFieldId
+        });
+      }
+      if (tdProps.isNewCheckTable2D) {
+        const item2 = checkTable2DList.find(
+          (i2) => i2.checkTable2d && (i2.colSubFieldKey === tdProps.fixedTableFieldId || i2.rowSubFieldKey === tdProps.fixedTableFieldId)
+        );
+        if (item2) {
+          return assignWidgetInfo(MobileFillTypeEnum.CHECK_TABLE_2D, item2);
+        }
+      }
+      return assignWidgetInfo(MobileFillTypeEnum.MAIN_FIELD, { rowSubFieldKey: "gct_mobile_main" });
+    }
+    const subTableFieldId = widgetCenter?.[preLocation]?.props?.field;
+    if (!subTableFieldId) return;
+    const item = subTable2DList.find((i2) => i2.subTable2d && i2.rowSubFieldKey === subTableFieldId);
+    return item ? assignWidgetInfo(MobileFillTypeEnum.SUB_TABLE_2D, {
+      ...item,
+      childInitRowLen: 1 * ((fixedTableLenMap?.[item.colSubFieldKey] ?? 0) + 1)
+    }) : assignWidgetInfo(MobileFillTypeEnum.SUB_TABLE, { rowSubFieldKey: subTableFieldId });
+  };
+  if (basicInfoItem) {
+    basicInfoItem.mobileSelectTdId = tdInfo.id;
+    const widgetInfo = getWidgetInfo();
+    callback?.(basicInfoItem, widgetInfo);
+  }
+}
+function getSubTableQuickFillInfo(subTableFieldId, mobileTdIdGroups) {
+  const getTdIds = (key) => [...mobileTdIdGroups.get(key) || []];
+  const assignWidgetInfo = (fillType, params) => {
+    const { rowSubFieldKey = "", colSubFieldKey = "" } = params;
+    const mainSetKey = rowSubFieldKey !== "gct_mobile_main" ? `gct_mobile_sub.${rowSubFieldKey}` : rowSubFieldKey;
+    const linkSetKey = colSubFieldKey ? `gct_mobile_sub.${colSubFieldKey}` : colSubFieldKey;
+    return {
+      fillType,
+      mainWidgetIds: getTdIds(mainSetKey),
+      linkWidgetIds: getTdIds(linkSetKey),
+      subInfo: params
+    };
+  };
+  if (!subTableFieldId) return;
+  return assignWidgetInfo(MobileFillTypeEnum.SUB_TABLE, { rowSubFieldKey: subTableFieldId });
+}
+const isEmptyValue$1 = (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 });
+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 getCurrentFormData(_rule, options) {
+  if (!_rule._subtableFieldId) return options?.formData;
+  const subTableData = options?.formData?.[_rule._subtableFieldId];
+  if (!isNil(_rule._realRowIndex) && isNil(_rule._childSubTableDataIndex)) {
+    return subTableData?.[_rule._realRowIndex];
+  }
+  if (!isNil(_rule._realRowIndex) && !isNil(_rule._childSubTableDataIndex)) {
+    return subTableData?.[_rule._realRowIndex]?.["_2DTABLE_"]?.[_rule._childSubTableDataIndex];
+  }
+  return options?.formData;
+}
+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 resolveAttachContext(rule, metaAttach) {
+  if (metaAttach?.belongFieldId != null && !isNil(metaAttach.optionValue)) {
+    return {
+      _belongFieldId: metaAttach.belongFieldId,
+      _optionValue: metaAttach.optionValue,
+      _multiple: metaAttach.multiple,
+      _subtableFieldId: metaAttach.subtableFieldId,
+      _realRowIndex: metaAttach.realRowIndex,
+      _childSubTableDataIndex: metaAttach.childSubTableDataIndex
+    };
+  }
+  return rule;
+}
+function isAttachFieldActive(rule, formData) {
+  if (!rule?._belongFieldId || isNil(rule._optionValue)) {
+    return true;
+  }
+  const row = getCurrentFormData(rule, { formData });
+  if (rule._subtableFieldId && (isNil(rule._realRowIndex) || !row || row === formData)) {
+    return false;
+  }
+  const raw = row?.[rule._belongFieldId];
+  if (rule._multiple) {
+    const current = renderUtils.getValue(raw, true);
+    if (!Array.isArray(current)) return false;
+    return current.some((v) => isSameOptionValue(v, rule._optionValue));
+  }
+  return isSameOptionValue(raw, rule._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 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 (showRequired) {
+    RuleProps.push(
+      createRule(
+        (_rule, value) => !isEmptyValue$1(value),
+        buildError(validatorInfo, $t("sys.fieldRequired")),
+        "manual"
+      )
+    );
+  }
+  if (!isNil(minlength)) {
+    RuleProps.push(
+      createRule((_rule, value) => {
+        if (isEmptyValue$1(value)) return true;
+        return String(value).length >= minlength;
+      }, buildError(validatorInfo, $t("sys.fieldLengthNotLessThan", { len: minlength })))
+    );
+  }
+  if (!isNil(maxlength)) {
+    RuleProps.push(
+      createRule((_rule, value) => {
+        if (isEmptyValue$1(value)) return true;
+        return String(value).length <= maxlength;
+      }, buildError(validatorInfo, $t("sys.fieldLengthNoMoreThan", { len: maxlength })))
+    );
+  }
+  if (regex) {
+    RuleProps.push(
+      createRule((_rule, value) => {
+        if (isEmptyValue$1(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) {
+    RuleProps.push(
+      createRule((_rule, value) => {
+        if (isEmptyValue$1(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 { calculateFormula: calculateFormula2 } = useCalculateFormula();
+        const currentFormData = getCurrentFormData(_rule, options);
+        const formulaValue = await calculateFormula2(
+          minFormulaExpr,
+          currentFormData,
+          options?.formData
+        );
+        const parsedMin = parseFloat(formulaValue);
+        if (!isNaN(parsedMin)) {
+          if (isEmptyValue$1(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) {
+    RuleProps.push(
+      createRule((_rule, value) => {
+        if (isEmptyValue$1(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 { calculateFormula: calculateFormula2 } = useCalculateFormula();
+        const currentFormData = getCurrentFormData(_rule, options);
+        const formulaValue = await calculateFormula2(
+          maxFormulaExpr,
+          currentFormData,
+          options?.formData
+        );
+        const parsedMax = parseFloat(formulaValue);
+        if (!isNaN(parsedMax)) {
+          if (isEmptyValue$1(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$1(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$1(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 { calculateFormula: calculateFormula2 } = useCalculateFormula();
+        const currentFormData = getCurrentFormData(_rule, options);
+        const formulaValue = await calculateFormula2(
+          minDateFormulaExpr,
+          currentFormData,
+          options?.formData
+        );
+        const limitTime = toUnixTimestamp(formulaValue);
+        if (limitTime !== null) {
+          if (isEmptyValue$1(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 { calculateFormula: calculateFormula2 } = useCalculateFormula();
+        const currentFormData = getCurrentFormData(_rule, options);
+        const formulaValue = await calculateFormula2(
+          maxDateFormulaExpr,
+          currentFormData,
+          options?.formData
+        );
+        const limitTime = toUnixTimestamp(formulaValue);
+        if (limitTime !== null) {
+          if (isEmptyValue$1(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;
+}
+const formRules = ref({});
+const formRuleMeta = ref({});
+const formRuleOwner = /* @__PURE__ */ new Map();
+function setFormRule(key, rules2, meta, owner) {
+  formRules.value[key] = rules2;
+  formRuleMeta.value[key] = meta;
+  if (owner !== void 0) formRuleOwner.set(key, owner);
+}
+function deleteFormRule(key, owner) {
+  if (owner !== void 0 && formRuleOwner.get(key) !== owner) {
+    return;
+  }
+  delete formRules.value[key];
+  delete formRuleMeta.value[key];
+  formRuleOwner.delete(key);
+}
+function clearFormRules$1() {
+  formRules.value = {};
+  formRuleMeta.value = {};
+  formRuleOwner.clear();
+}
+function getRawFormRules() {
+  return toRaw(formRules.value);
+}
+function getRawFormRuleMeta() {
+  return toRaw(formRuleMeta.value);
+}
+function listFormRuleKeys() {
+  return Object.keys(formRules.value);
+}
+function deleteSubtableRow$1(subtableFieldId, realRowIndex) {
+  const newFormRules = {};
+  const newFormRuleMeta = {};
+  const newFormRuleOwner = /* @__PURE__ */ new Map();
+  for (const key in formRules.value) {
+    const regex = new RegExp(`^${subtableFieldId}_(\\d+)_`);
+    const match = key.match(regex);
+    if (match) {
+      const rowIndex = parseInt(match[1], 10);
+      if (rowIndex < realRowIndex) {
+        newFormRules[key] = formRules.value[key];
+        if (formRuleMeta.value[key]) {
+          newFormRuleMeta[key] = formRuleMeta.value[key];
+        }
+        if (formRuleOwner.has(key)) newFormRuleOwner.set(key, formRuleOwner.get(key));
+      } else if (rowIndex > realRowIndex) {
+        const newKey = key.replace(
+          `${subtableFieldId}_${rowIndex}_`,
+          `${subtableFieldId}_${rowIndex - 1}_`
+        );
+        newFormRules[newKey] = formRules.value[key];
+        if (formRuleMeta.value[key]) {
+          newFormRuleMeta[newKey] = formRuleMeta.value[key];
+        }
+        if (formRuleOwner.has(key)) newFormRuleOwner.set(newKey, formRuleOwner.get(key));
+      }
+    } else {
+      newFormRules[key] = formRules.value[key];
+      if (formRuleMeta.value[key]) {
+        newFormRuleMeta[key] = formRuleMeta.value[key];
+      }
+      if (formRuleOwner.has(key)) newFormRuleOwner.set(key, formRuleOwner.get(key));
+    }
+  }
+  formRules.value = newFormRules;
+  formRuleMeta.value = newFormRuleMeta;
+  formRuleOwner.clear();
+  for (const [k, v] of newFormRuleOwner) formRuleOwner.set(k, v);
+}
+function insertSubtableRows$1(subtableFieldId, insertIndex, count = 1) {
+  if (count <= 0) return;
+  const newFormRules = {};
+  const newFormRuleMeta = {};
+  const newFormRuleOwner = /* @__PURE__ */ new Map();
+  const regex = new RegExp(`^${subtableFieldId}_(\\d+)_`);
+  const entries = Object.keys(formRules.value).map((key) => {
+    const match = key.match(regex);
+    return {
+      key,
+      rowIndex: match ? parseInt(match[1], 10) : -1
+    };
+  });
+  entries.sort((a, b) => b.rowIndex - a.rowIndex).forEach(({ key, rowIndex }) => {
+    if (rowIndex < 0) {
+      newFormRules[key] = formRules.value[key];
+      if (formRuleMeta.value[key]) {
+        newFormRuleMeta[key] = formRuleMeta.value[key];
+      }
+      if (formRuleOwner.has(key)) newFormRuleOwner.set(key, formRuleOwner.get(key));
+      return;
+    }
+    if (rowIndex < insertIndex) {
+      newFormRules[key] = formRules.value[key];
+      if (formRuleMeta.value[key]) {
+        newFormRuleMeta[key] = formRuleMeta.value[key];
+      }
+      if (formRuleOwner.has(key)) newFormRuleOwner.set(key, formRuleOwner.get(key));
+      return;
+    }
+    const newKey = key.replace(
+      `${subtableFieldId}_${rowIndex}_`,
+      `${subtableFieldId}_${rowIndex + count}_`
+    );
+    newFormRules[newKey] = formRules.value[key];
+    if (formRuleMeta.value[key]) {
+      newFormRuleMeta[newKey] = formRuleMeta.value[key];
+    }
+    if (formRuleOwner.has(key)) newFormRuleOwner.set(newKey, formRuleOwner.get(key));
+  });
+  formRules.value = newFormRules;
+  formRuleMeta.value = newFormRuleMeta;
+  formRuleOwner.clear();
+  for (const [k, v] of newFormRuleOwner) formRuleOwner.set(k, v);
+}
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i2 = 1; i2 < arguments.length; i2++) {
+      var source = arguments[i2];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p2) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p3) {
+    o2.__proto__ = p3;
+    return o2;
+  };
+  return _setPrototypeOf(o, p2);
+}
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct.bind();
+  } else {
+    _construct = function _construct2(Parent2, args2, Class2) {
+      var a = [null];
+      a.push.apply(a, args2);
+      var Constructor = Function.bind.apply(Parent2, a);
+      var instance = new Constructor();
+      if (Class2) _setPrototypeOf(instance, Class2.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
+  _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
+    if (Class2 === null || !_isNativeFunction(Class2)) return Class2;
+    if (typeof Class2 !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class2)) return _cache.get(Class2);
+      _cache.set(Class2, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class2.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class2);
+  };
+  return _wrapNativeSuper(Class);
+}
+var formatRegExp = /%[sdj%]/g;
+var warning = function warning2() {
+};
+if (typeof process !== "undefined" && process.env && process.env.NODE_ENV !== "production" && typeof window !== "undefined" && typeof document !== "undefined") {
+  warning = function warning3(type4, errors) {
+    if (typeof console !== "undefined" && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === "undefined") {
+      if (errors.every(function(e) {
+        return typeof e === "string";
+      })) {
+        console.warn(type4, errors);
+      }
+    }
+  };
+}
+function convertFieldsError(errors) {
+  if (!errors || !errors.length) return null;
+  var fields = {};
+  errors.forEach(function(error) {
+    var field = error.field;
+    fields[field] = fields[field] || [];
+    fields[field].push(error);
+  });
+  return fields;
+}
+function format(template) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+  var i2 = 0;
+  var len = args.length;
+  if (typeof template === "function") {
+    return template.apply(null, args);
+  }
+  if (typeof template === "string") {
+    var str = template.replace(formatRegExp, function(x) {
+      if (x === "%%") {
+        return "%";
+      }
+      if (i2 >= len) {
+        return x;
+      }
+      switch (x) {
+        case "%s":
+          return String(args[i2++]);
+        case "%d":
+          return Number(args[i2++]);
+        case "%j":
+          try {
+            return JSON.stringify(args[i2++]);
+          } catch (_) {
+            return "[Circular]";
+          }
+          break;
+        default:
+          return x;
+      }
+    });
+    return str;
+  }
+  return template;
+}
+function isNativeStringType(type4) {
+  return type4 === "string" || type4 === "url" || type4 === "hex" || type4 === "email" || type4 === "date" || type4 === "pattern";
+}
+function isEmptyValue(value, type4) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (type4 === "array" && Array.isArray(value) && !value.length) {
+    return true;
+  }
+  if (isNativeStringType(type4) && typeof value === "string" && !value) {
+    return true;
+  }
+  return false;
+}
+function asyncParallelArray(arr, func, callback) {
+  var results = [];
+  var total = 0;
+  var arrLength = arr.length;
+  function count(errors) {
+    results.push.apply(results, errors || []);
+    total++;
+    if (total === arrLength) {
+      callback(results);
+    }
+  }
+  arr.forEach(function(a) {
+    func(a, count);
+  });
+}
+function asyncSerialArray(arr, func, callback) {
+  var index2 = 0;
+  var arrLength = arr.length;
+  function next(errors) {
+    if (errors && errors.length) {
+      callback(errors);
+      return;
+    }
+    var original = index2;
     index2 = index2 + 1;
     if (original < arrLength) {
       func(arr[original], next);
@@ -59967,8 +61023,8 @@ var rules = {
 };
 var string = function string2(rule, value, callback, source, options) {
   var errors = [];
-  var validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
-  if (validate2) {
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
     if (isEmptyValue(value, "string") && !rule.required) {
       return callback();
     }
@@ -59986,8 +61042,8 @@ var string = function string2(rule, value, callback, source, options) {
 };
 var method2 = function method3(rule, value, callback, source, options) {
   var errors = [];
-  var validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
-  if (validate2) {
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
     if (isEmptyValue(value) && !rule.required) {
       return callback();
     }
@@ -60000,8 +61056,8 @@ var method2 = function method3(rule, value, callback, source, options) {
 };
 var number2 = function number3(rule, value, callback, source, options) {
   var errors = [];
-  var validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
-  if (validate2) {
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
     if (value === "") {
       value = void 0;
     }
@@ -60018,8 +61074,8 @@ var number2 = function number3(rule, value, callback, source, options) {
 };
 var _boolean = function _boolean2(rule, value, callback, source, options) {
   var errors = [];
-  var validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
-  if (validate2) {
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
     if (isEmptyValue(value) && !rule.required) {
       return callback();
     }
@@ -60032,8 +61088,8 @@ var _boolean = function _boolean2(rule, value, callback, source, options) {
 };
 var regexp2 = function regexp3(rule, value, callback, source, options) {
   var errors = [];
-  var validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
-  if (validate2) {
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
     if (isEmptyValue(value) && !rule.required) {
       return callback();
     }
@@ -60046,8 +61102,8 @@ var regexp2 = function regexp3(rule, value, callback, source, options) {
 };
 var integer2 = function integer3(rule, value, callback, source, options) {
   var errors = [];
-  var validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
-  if (validate2) {
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
     if (isEmptyValue(value) && !rule.required) {
       return callback();
     }
@@ -60061,8 +61117,8 @@ var integer2 = function integer3(rule, value, callback, source, options) {
 };
 var floatFn = function floatFn2(rule, value, callback, source, options) {
   var errors = [];
-  var validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
-  if (validate2) {
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
     if (isEmptyValue(value) && !rule.required) {
       return callback();
     }
@@ -60076,8 +61132,8 @@ var floatFn = function floatFn2(rule, value, callback, source, options) {
 };
 var array2 = function array3(rule, value, callback, source, options) {
   var errors = [];
-  var validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
-  if (validate2) {
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
     if ((value === void 0 || value === null) && !rule.required) {
       return callback();
     }
@@ -60091,8 +61147,8 @@ var array2 = function array3(rule, value, callback, source, options) {
 };
 var object2 = function object3(rule, value, callback, source, options) {
   var errors = [];
-  var validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
-  if (validate2) {
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
     if (isEmptyValue(value) && !rule.required) {
       return callback();
     }
@@ -60106,8 +61162,8 @@ var object2 = function object3(rule, value, callback, source, options) {
 var ENUM = "enum";
 var enumerable2 = function enumerable3(rule, value, callback, source, options) {
   var errors = [];
-  var validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
-  if (validate2) {
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
     if (isEmptyValue(value) && !rule.required) {
       return callback();
     }
@@ -60120,8 +61176,8 @@ var enumerable2 = function enumerable3(rule, value, callback, source, options) {
 };
 var pattern2 = function pattern3(rule, value, callback, source, options) {
   var errors = [];
-  var validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
-  if (validate2) {
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
     if (isEmptyValue(value, "string") && !rule.required) {
       return callback();
     }
@@ -60134,8 +61190,8 @@ var pattern2 = function pattern3(rule, value, callback, source, options) {
 };
 var date2 = function date3(rule, value, callback, source, options) {
   var errors = [];
-  var validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
-  if (validate2) {
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
     if (isEmptyValue(value, "date") && !rule.required) {
       return callback();
     }
@@ -60164,8 +61220,8 @@ var required2 = function required3(rule, value, callback, source, options) {
 var type2 = function type3(rule, value, callback, source, options) {
   var ruleType = rule.type;
   var errors = [];
-  var validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
-  if (validate2) {
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
     if (isEmptyValue(value, ruleType) && !rule.required) {
       return callback();
     }
@@ -60178,8 +61234,8 @@ var type2 = function type3(rule, value, callback, source, options) {
 };
 var any = function any2(rule, value, callback, source, options) {
   var errors = [];
-  var validate2 = rule.required || !rule.required && source.hasOwnProperty(rule.field);
-  if (validate2) {
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
     if (isEmptyValue(value) && !rule.required) {
       return callback();
     }
@@ -60288,7 +61344,7 @@ var Schema = /* @__PURE__ */ (function() {
     }
     return this._messages;
   };
-  _proto.validate = function validate2(source_, o, oc) {
+  _proto.validate = function validate(source_, o, oc) {
     var _this2 = this;
     if (o === void 0) {
       o = {};
@@ -60517,962 +61573,30 @@ Schema.register = function register(type4, validator) {
 Schema.warning = warning;
 Schema.messages = messages;
 Schema.validators = validators;
-var NCB_PROVIDE = /* @__PURE__ */ ((NCB_PROVIDE2) => {
-  NCB_PROVIDE2["IS_PDF"] = "NCB_IsPdf";
-  NCB_PROVIDE2["FROM_DATA"] = "NCB_FromState";
-  NCB_PROVIDE2["DEFAULT_FIELD_DATA"] = "NCB_DefaultFieldData";
-  NCB_PROVIDE2["DATA_RELATION_SHIP"] = "NCB_DataRelationShip";
-  NCB_PROVIDE2["PAGE_DATA_CALL_BACK"] = "NCB_PageDataCallback";
-  NCB_PROVIDE2["FORM_INST_LIST"] = "NCB_FormInstList";
-  NCB_PROVIDE2["MOBILE_FILL_FIELDS_POPUP"] = "NCB_MobileFillFieldsPopup";
-  NCB_PROVIDE2["TMPL_BOM_CONTROLLER_MAP"] = "NCB_TmplBomControllerMap";
-  NCB_PROVIDE2["MATERIAL_CONSUME_TABLE_CONTROLLER"] = "NCB_MaterialConsumeTableController";
-  NCB_PROVIDE2["CHECK_TABLE_COL_INDEX"] = "NCB_CheckTableColIndex";
-  NCB_PROVIDE2["SUB_TABLE_CORE_FACTORY_MAP"] = "NCB_SubTableCoreFactoryMap";
-  NCB_PROVIDE2["SUB_TABLE_CORE"] = "NCB_SubTableCore";
-  NCB_PROVIDE2["PAGER"] = "NCB_Pager";
-  return NCB_PROVIDE2;
-})(NCB_PROVIDE || {});
-function mitt(all) {
-  all = all || /* @__PURE__ */ new Map();
-  return {
-    /**
-     * A Map of event names to registered handler functions.
-     */
-    all,
-    /**
-     * Register an event handler for the given type.
-     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events
-     * @param {Function} handler Function to call in response to given event
-     * @memberOf mitt
-     */
-    on(type4, handler) {
-      const handlers = all.get(type4);
-      if (handlers) {
-        handlers.push(handler);
-      } else {
-        all.set(type4, [handler]);
-      }
-    },
-    /**
-     * Remove an event handler for the given type.
-     * If `handler` is omitted, all handlers of the given type are removed.
-     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
-     * @param {Function} [handler] Handler function to remove
-     * @memberOf mitt
-     */
-    off(type4, handler) {
-      const handlers = all.get(type4);
-      if (handlers) {
-        if (handler) {
-          handlers.splice(handlers.indexOf(handler) >>> 0, 1);
-        } else {
-          all.set(type4, []);
-        }
-      }
-    },
-    /**
-     * Invoke all handlers for the given type.
-     * If present, `'*'` handlers are invoked after type-matched handlers.
-     *
-     * Note: Manually firing '*' handlers is not supported.
-     *
-     * @param {string|symbol} type The event type to invoke
-     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
-     * @memberOf mitt
-     */
-    emit(type4, evt) {
-      let handlers = all.get(type4);
-      if (handlers) {
-        handlers.slice().forEach((handler) => {
-          handler(evt);
-        });
-      }
-      handlers = all.get("*");
-      if (handlers) {
-        handlers.slice().forEach((handler) => {
-          handler(type4, evt);
-        });
-      }
-    },
-    /**
-     * Clear all
-     */
-    clear() {
-      this.all.clear();
-    }
-  };
-}
-const emitter = mitt();
-var EmitterEnum = /* @__PURE__ */ ((EmitterEnum2) => {
-  EmitterEnum2["__on__open_single_annotation_detail_"] = "__on__open_single_annotation_detail_";
-  EmitterEnum2["__on__update_page_dom_"] = "__on__update_page_dom_";
-  EmitterEnum2["__on_select_ebr_doc_instance_id"] = "__on_select_ebr_doc_instance_id";
-  EmitterEnum2["__on_looper_auto_save"] = "__on_looper_auto_save";
-  EmitterEnum2["__on_diff_ebr_form_state"] = "__on_diff_ebr_form_state";
-  return EmitterEnum2;
-})(EmitterEnum || {});
-function useNocodeEmitter() {
-  return {
-    emitter,
-    EmitterEnum
-  };
-}
-function useCurrentPageFormState() {
-  const formStateMap = inject(NCB_PROVIDE.FROM_DATA);
-  const dataRelationShip = inject(NCB_PROVIDE.DATA_RELATION_SHIP);
-  const currentPageFormState = computed(() => {
-    return formStateMap?.[dataRelationShip?.uniqueId ?? ""] ?? {};
-  });
-  return {
-    currentPageFormState
-  };
-}
-function useWidgetStaticAttrs(widget) {
-  const dataRelationShip = inject(NCB_PROVIDE.DATA_RELATION_SHIP);
-  const {
-    field = "",
-    fieldType,
-    bizType,
-    isFieldModel,
-    fieldLink,
-    modelKey = dataRelationShip?.modelKey,
-    refModelKey,
-    placeholder,
-    bindCompStyleType,
-    newSpecificConfig
-  } = widget.props || {};
-  let viewState = widget.props?.viewState;
-  if (fieldType === FIELD_TYPE.ATTACHMENT && viewState === CellWidgetViewState.Auto) {
-    viewState = CellWidgetViewState.Readonly;
+function resolveKeepExceptionHighlight(formValue, fieldValue) {
+  if (typeof fieldValue === "boolean") {
+    return fieldValue;
   }
-  const disabled = toRef(widget.props, "disabled");
-  const readonly = toRef(widget.props, "field_readonly");
-  const newRequired = toRef(widget.props, "required");
-  const newQueryDataRef = computed(() => widget.props.newSpecificConfig?.newQueryData);
-  const customLoaderRef = computed(() => widget.props.newSpecificConfig?.customLoader);
-  const {
-    newFieldName,
-    newModelName,
-    newOptions = [],
-    newUploadConfig = {},
-    newPrecision = 0,
-    newLoadFinished2Options,
-    newTotalCount,
-    newRefRecordNo,
-    newQueryData,
-    newQueryCondition,
-    forcedDisabled,
-    forcedReadonlyText,
-    newPlaceholder,
-    newRulesForRounding,
-    newComponentProps = {},
-    newDisplayRule = void 0,
-    newSnNo = void 0
-  } = newSpecificConfig || {};
-  const targetFieldId = field ? isFieldModel ? fieldLink : field : "";
-  const newDisplayStatus = computed(() => {
-    const readonlyString = viewState === CellWidgetViewState.Disabled || viewState === CellWidgetViewState.Auto ? "readonly-component" : "readonly-text";
-    const editString = readonly.value ? "readonly-component" : "edit-component";
-    if (dataRelationShip?.annSwitchStatus || forcedReadonlyText) return "readonly-text";
-    if (isFieldModel) return readonlyString;
-    const renderMode = dataRelationShip?.renderModeType;
-    const bpmnMap = dataRelationShip?.bpmnFieldAuthMap;
-    const key = `${modelKey}.${field}`;
-    const getFieldAuth = () => bpmnMap?.[key];
-    const resolveFromAuth = (info) => {
-      if (isEmpty(info)) return null;
-      if (info.edit && !info.readonly) return editString;
-      if (info.readonly && !info.edit) return readonlyString;
-      return null;
-    };
-    if (renderMode === RenderModeEnum.FormMode) {
-      if (dataRelationShip?.formType !== FormTypeEnum.PROCESS) {
-        const auth2 = getFieldAuth();
-        const fromAuth2 = resolveFromAuth(auth2);
-        return fromAuth2 ?? editString;
-      }
-      const auth = getFieldAuth();
-      const fromAuth = resolveFromAuth(auth);
-      if (fromAuth) return fromAuth;
-      const bpmnType = dataRelationShip?.bpmnType;
-      if (bpmnType === BpmnNodeTypeEnum.BpmnApproval || bpmnType === BpmnNodeTypeEnum.BpmnJudge) {
-        return readonlyString;
-      }
-      return editString;
-    }
-    if (renderMode === RenderModeEnum.ViewMode) {
-      return readonlyString;
-    }
-    return readonly.value ? "readonly-text" : "edit-component";
-  });
-  const newDisabled = computed(() => {
-    if (newDisplayStatus.value === "edit-component") {
-      return forcedDisabled || disabled.value;
-    }
-    return viewState === CellWidgetViewState.Disabled || disabled.value;
-  });
-  const isAutoLineBreak = computed(() => {
-    if (!isEmpty(widget.style) && has(widget.style, "whiteSpace") && has(widget.style, "wordBreak") && widget.style.whiteSpace === "pre-wrap" && widget.style.wordBreak === "break-all") {
-      return true;
-    }
-    return false;
-  });
-  return {
-    field,
-    fieldType,
-    /** 业务类型 */
-    bizType,
-    modelKey,
-    refModelKey,
-    isFieldModel,
-    fieldLink,
-    targetFieldId,
-    placeholder: newPlaceholder || placeholder,
-    bindCompStyleType,
-    /** 字段名称 */
-    showFieldName: newFieldName,
-    /** 字段所属模型名称 */
-    showModelName: newModelName,
-    /** 是否必填 */
-    showRequired: newRequired,
-    /** 是否禁用 */
-    showDisabled: newDisabled,
-    /** 显示状态 */
-    showDisplayStatus: newDisplayStatus,
-    /** 下拉列表 */
-    options: newOptions,
-    /** 附件、图片配置项 */
-    uploadConfig: newUploadConfig,
-    /** 小数位数 */
-    realPrecision: newPrecision,
-    /** 精度小数的修约规则 */
-    rulesForRounding: newRulesForRounding,
-    /** 记录单号是否是链接 */
-    realRefRecordNo: newRefRecordNo,
-    /** 下拉列表内容是否都加载完成 */
-    loadFinished2Options: newLoadFinished2Options,
-    /** Rdo下拉框内容总数 */
-    newTotalCount,
-    /** 查询条件 */
-    newQueryData,
-    /** 查询条件响应式 */
-    newQueryDataRef,
-    /** 自定义数据源加载函数 */
-    customLoaderRef,
-    /** 查询条件 */
-    queryCondition: newQueryCondition,
-    /** 组件额外参数 */
-    newComponentProps,
-    /** 显示规则 */
-    newDisplayRule,
-    dataRelationShip,
-    /** 是否是自动换行 */
-    isAutoLineBreak,
-    /** 序列号 */
-    newSnNo
-  };
-}
-function useCalculateFormula() {
-  const { identify, calculate } = {
-    identify: (...args) => window.NocodeAdapter.utils?.formulaIdentify?.(...args) ?? [],
-    calculate: (...args) => window.NocodeAdapter.utils?.formulaCalculate?.(...args)
-  };
-  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((i2) => !isNil(i2));
-    }
-    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 getParseFormulaVarInfos2 = (expr) => {
-    const rowArgs = expr ? identify(expr) : [];
-    return {
-      rowArgs,
-      parseInfos: rowArgs.map((curr) => parseFormulaVar(curr))
-    };
-  };
-  const calculateFormula2 = async (expr, formData, currentPageFormState) => {
-    const rowArgs = identify(expr);
-    const formulaData = isEmpty(rowArgs) ? {} : rowArgs.reduce((total, curr) => {
-      const parseInfo = parseFormulaVar(curr);
-      total[curr] = getFieldDataValue(
-        parseInfo,
-        parseInfo.dataType === "currentRowType" ? formData : currentPageFormState
-      );
-      return total;
-    }, {});
-    return calculate(expr, formulaData);
-  };
-  const mergeParseInfos = (a = [], b = []) => {
-    const map = /* @__PURE__ */ new Map();
-    const keyOf = (p2) => `${p2.type}||${p2.processed}||${p2.hashValue ?? ""}`;
-    for (const p2 of a || []) map.set(keyOf(p2), p2);
-    for (const p2 of b || []) map.set(keyOf(p2), p2);
-    return Array.from(map.values());
-  };
-  const getMergeParseInfos = (options) => {
-    const { minFormulaExpr, maxFormulaExpr } = options;
-    let minInfos = [];
-    let maxInfos = [];
-    try {
-      if (minFormulaExpr) minInfos = getParseFormulaVarInfos2(minFormulaExpr)?.parseInfos || [];
-    } catch (e) {
-      minInfos = [];
-    }
-    try {
-      if (maxFormulaExpr) maxInfos = getParseFormulaVarInfos2(maxFormulaExpr)?.parseInfos || [];
-    } catch (e) {
-      maxInfos = [];
-    }
-    const merged = mergeParseInfos(minInfos, maxInfos);
-    return merged;
-  };
-  return {
-    identify,
-    getParseFormulaVarInfos: getParseFormulaVarInfos2,
-    calculateFormula: calculateFormula2,
-    getMergeParseInfos
-  };
-}
-function setSelectAnnotationId(id, basicInfoItem) {
-  if (!isEmpty(id) && basicInfoItem) {
-    const { emitter: emitter2, EmitterEnum: EmitterEnum2 } = useNocodeEmitter();
-    const newId = id === "gct-nocode-ann-main" ? "" : id;
-    basicInfoItem.annSelectId = newId;
-    emitter2.emit(EmitterEnum2.__on__open_single_annotation_detail_, {
-      cellLocation: newId
-    });
+  if (typeof formValue === "boolean") {
+    return formValue;
   }
+  return true;
 }
-function setSelectValidatorId(event, basicInfoItem) {
-  if (basicInfoItem && event.target) {
-    const cellDiv = event.target.closest(".cell-wrapper");
-    if (!cellDiv) return;
-    const ids = Array.from(cellDiv.querySelectorAll(".validator-icon")).map((el2) => el2.dataset.ann).filter(Boolean);
-    const validateList = ids.map((id) => basicInfoItem.validatorMessageMap?.[id]).filter(Boolean);
-    const flattenedErrors = validateList.flatMap(
-      (validates) => validates.map(({ field, message: message2 }) => JSON.parse(message2))
-    );
-    const resultMap = flattenedErrors.reduce((acc, item) => {
-      const { showModelName, showModelKey, subFieldKey, showFieldName, targetFieldId, message: message2 } = item;
-      if (!acc[showModelKey]) {
-        acc[showModelKey] = {
-          showModelName,
-          showModelKey,
-          subFieldKey,
-          fields: []
-        };
-      }
-      acc[showModelKey].fields.push({ showFieldName, targetFieldId, message: message2 });
-      return acc;
-    }, {});
-    if (Object.keys(resultMap).length) {
-      const contentVNode = h$1(
-        "div",
-        { class: "nocode-validator-tooltip-wrapper" },
-        Object.values(resultMap).map(
-          (data) => h$1("div", { class: "nocode-validator-tooltip-container", key: data.showModelKey }, [
-            h$1("div", { class: "nocode-validator-tooltip-header" }, data.showModelName),
-            h$1(
-              "div",
-              { class: "nocode-validator-tooltip-header-label" },
-              `${data.showModelKey}${data.subFieldKey ? "｜" + data.subFieldKey : ""}`
-            ),
-            h$1(
-              "ul",
-              { class: "nocode-validator-tooltip-content" },
-              data.fields.map(
-                (field, index2) => h$1(
-                  "li",
-                  { key: `${field.targetFieldId}-${index2}` },
-                  `${field.showFieldName}（${field.targetFieldId}）：${field.message}`
-                )
-              )
-            )
-          ])
-        )
-      );
-      window.window.NocodeAdapter.utils.overlay.popover(
-        event.target,
-        contentVNode,
-        {},
-        { placement: "top-center" }
-      );
-    }
+function resolveValidationAdmission(input) {
+  if (input.mode === "display") {
+    if (!input.keepExceptionHighlight) return { admit: false };
+    return { admit: true };
   }
+  if (input.blocked) return { admit: false };
+  return { admit: true };
 }
-function setSelectMobileTdId(tdInfo, basicInfoItem, widgetCenter, callback, sbRowIndex) {
-  const getWidgetInfo = () => {
-    const { preLocation, props: tdProps } = tdInfo || {};
-    const paper = widgetCenter?.[ComponentTypeEnum.PAPER];
-    const subTable2DList = paper.props.subTable2DList ?? [];
-    const checkTable2DList = paper.props.checkTable2DList ?? [];
-    const fixedTableLenMap = paper.props.fixedTableLenMap ?? {};
-    const getTdIds = (key) => [...basicInfoItem?.mobileTdIdGroups.get(key) || []];
-    const assignWidgetInfo = (fillType, params) => {
-      const { rowSubFieldKey = "", colSubFieldKey = "" } = params;
-      const mainSetKey = rowSubFieldKey !== "gct_mobile_main" ? `gct_mobile_sub.${rowSubFieldKey}` : rowSubFieldKey;
-      const linkSetKey = colSubFieldKey ? `gct_mobile_sub.${colSubFieldKey}` : colSubFieldKey;
-      return {
-        fillType,
-        clickTdId: tdInfo.id,
-        clickSbRowIndex: sbRowIndex,
-        mainWidgetIds: getTdIds(mainSetKey),
-        linkWidgetIds: getTdIds(linkSetKey),
-        subInfo: params
-      };
-    };
-    if (preLocation === ComponentTypeEnum.PAPER) {
-      if (tdProps.isNewFixedTableTd) {
-        const item2 = subTable2DList.find(
-          (i2) => i2.subTable2d && i2.colSubFieldKey === tdProps.fixedTableFieldId
-        );
-        return item2 ? assignWidgetInfo(MobileFillTypeEnum.SUB_TABLE_2D, {
-          ...item2,
-          childInitRowLen: 1 * ((fixedTableLenMap?.[item2.colSubFieldKey] ?? 0) + 1)
-        }) : assignWidgetInfo(MobileFillTypeEnum.FIXED_TABLE, {
-          rowSubFieldKey: tdProps.fixedTableFieldId
-        });
-      }
-      if (tdProps.isNewCheckTable2D) {
-        const item2 = checkTable2DList.find(
-          (i2) => i2.checkTable2d && (i2.colSubFieldKey === tdProps.fixedTableFieldId || i2.rowSubFieldKey === tdProps.fixedTableFieldId)
-        );
-        if (item2) {
-          return assignWidgetInfo(MobileFillTypeEnum.CHECK_TABLE_2D, item2);
-        }
-      }
-      return assignWidgetInfo(MobileFillTypeEnum.MAIN_FIELD, { rowSubFieldKey: "gct_mobile_main" });
-    }
-    const subTableFieldId = widgetCenter?.[preLocation]?.props?.field;
-    if (!subTableFieldId) return;
-    const item = subTable2DList.find((i2) => i2.subTable2d && i2.rowSubFieldKey === subTableFieldId);
-    return item ? assignWidgetInfo(MobileFillTypeEnum.SUB_TABLE_2D, {
-      ...item,
-      childInitRowLen: 1 * ((fixedTableLenMap?.[item.colSubFieldKey] ?? 0) + 1)
-    }) : assignWidgetInfo(MobileFillTypeEnum.SUB_TABLE, { rowSubFieldKey: subTableFieldId });
-  };
-  if (basicInfoItem) {
-    basicInfoItem.mobileSelectTdId = tdInfo.id;
-    const widgetInfo = getWidgetInfo();
-    callback?.(basicInfoItem, widgetInfo);
-  }
-}
-function getSubTableQuickFillInfo(subTableFieldId, mobileTdIdGroups) {
-  const getTdIds = (key) => [...mobileTdIdGroups.get(key) || []];
-  const assignWidgetInfo = (fillType, params) => {
-    const { rowSubFieldKey = "", colSubFieldKey = "" } = params;
-    const mainSetKey = rowSubFieldKey !== "gct_mobile_main" ? `gct_mobile_sub.${rowSubFieldKey}` : rowSubFieldKey;
-    const linkSetKey = colSubFieldKey ? `gct_mobile_sub.${colSubFieldKey}` : colSubFieldKey;
-    return {
-      fillType,
-      mainWidgetIds: getTdIds(mainSetKey),
-      linkWidgetIds: getTdIds(linkSetKey),
-      subInfo: params
-    };
-  };
-  if (!subTableFieldId) return;
-  return assignWidgetInfo(MobileFillTypeEnum.SUB_TABLE, { rowSubFieldKey: subTableFieldId });
-}
-const formRules = ref({});
-const constantRequiredStyles = {
-  "--required-border-color": "rgb(255, 31, 31, 0.36)",
-  "--required-border-hover-color": "rgb(255, 31, 31, 0.86)",
-  "--required-background-color": "rgb(255, 31, 31, 0.04)"
-};
-const reliableVerticalTextStyles = {
-  "writing-mode": "horizontal-tb",
-  display: "inline-block",
-  width: "1em",
-  "line-height": "1.2",
-  "white-space": "normal",
-  "word-break": "break-all",
-  "letter-spacing": "0",
-  "text-align": "center"
-};
-const isVerticalLrText = (style) => {
-  const mode = style?.writingMode ?? style?.["writing-mode"];
-  return mode === "vertical-lr";
-};
-function useValidator(props) {
-  const widget = props.widget;
-  const {
-    showModelName,
-    showFieldName,
-    modelKey,
-    fieldType,
-    targetFieldId,
-    isFieldModel,
-    showRequired,
-    showDisabled,
-    showDisplayStatus,
-    dataRelationShip
-  } = useWidgetStaticAttrs(widget);
-  const sizeStyles = {
-    "--size": `${widget.props.size ?? 12}px`,
-    "--cmp-width": `${widget.props.cmpWidth ?? 0}px`,
-    "--cmp-height": `${widget.props.cmpHeight ?? 0}px`
-  };
-  const showFormItem = computed(() => {
-    if (dataRelationShip?.renderModeType === RenderModeEnum.ViewMode) {
-      return false;
-    }
-    if (widget.component === ComponentTypeEnum.DynValue) {
-      return false;
-    }
-    return widget.formItem;
-  });
-  const rules2 = computed(() => {
-    const RuleProps = [];
-    if (!showFormItem.value) {
-      return RuleProps;
-    }
-    if (!targetFieldId || showDisabled.value || ["readonly-text", "readonly-component"].includes(showDisplayStatus.value)) {
-      return RuleProps;
-    }
-    const {
-      subFieldKey,
-      minlength,
-      regex,
-      regexHint,
-      validateTrue,
-      validateFalse,
-      enableRangeValidate,
-      maxValidateMode,
-      minValidateMode,
-      minValue,
-      maxValue,
-      minFormulaExpr,
-      maxFormulaExpr,
-      minDate,
-      maxDate,
-      minDateFormulaExpr,
-      maxDateFormulaExpr,
-      maxDateValidateMode,
-      minDateValidateMode
-    } = widget.props;
-    const validatorInfo = {
-      showModelName,
-      showModelKey: modelKey,
-      showFieldName,
-      subFieldKey,
-      targetFieldId
-    };
-    const buildError = (message2) => JSON.stringify({ ...validatorInfo, message: message2 });
-    const getCurrentFormData = (_rule, options) => {
-      if (!_rule._subtableFieldId) return options?.formData;
-      const subTableData = options?.formData?.[_rule._subtableFieldId];
-      if (!isNil(_rule._realRowIndex) && isNil(_rule._childSubTableDataIndex)) {
-        return subTableData?.[_rule._realRowIndex];
-      }
-      if (!isNil(_rule._realRowIndex) && !isNil(_rule._childSubTableDataIndex)) {
-        return subTableData?.[_rule._realRowIndex]?.["_2DTABLE_"]?.[_rule._childSubTableDataIndex];
-      }
-      return options?.formData;
-    };
-    const shouldSkipEnumValidation = (_rule, options) => {
-      if (!_rule._belongFieldId || isNil(_rule._optionValue)) {
-        return false;
-      }
-      const _formData_ = getCurrentFormData(_rule, options);
-      const enumFieldValue = renderUtils.getValue(
-        _formData_?.[_rule._belongFieldId],
-        _rule._multiple
-      );
-      const shouldValidate = Array.isArray(enumFieldValue) ? enumFieldValue.includes(_rule._optionValue) : enumFieldValue === _rule._optionValue;
-      return !shouldValidate;
-    };
-    const isEmptyValue2 = (value) => {
-      return value === void 0 || value === null || typeof value === "string" && value.trim() === "" || Array.isArray(value) && value.length === 0;
-    };
-    const createValidationRule = (validator, message2) => ({
-      required: true,
-      validator: (rule, value, callback, source, options) => {
-        if (shouldSkipEnumValidation(rule, options)) {
-          return true;
-        }
-        return validator(rule, value, callback, source, options);
-      },
-      message: message2
-    });
-    if (showRequired.value) {
-      RuleProps.push(
-        createValidationRule(
-          (_rule, value, callback, source, options) => {
-            if (isEmptyValue2(value)) return false;
-            return true;
-          },
-          buildError($t("sys.edhr.fieldRequired"))
-        )
-      );
-    }
-    if (minlength) {
-      RuleProps.push(
-        createValidationRule(
-          (_rule, value, callback, source, options) => {
-            if (isEmptyValue2(value)) return true;
-            return value.length >= minlength;
-          },
-          buildError($t("sys.edhr.fieldLengthNotLessThan", { len: minlength }))
-        )
-      );
-    }
-    if (regex) {
-      RuleProps.push(
-        createValidationRule(
-          (_rule, value, callback, source, options) => {
-            if (isEmptyValue2(value)) return true;
-            return new RegExp(regex).test(value);
-          },
-          buildError(regexHint ?? $t("sys.edhr.fieldFormatError"))
-        )
-      );
-    }
-    if (validateTrue) {
-      RuleProps.push({
-        required: true,
-        validator: (_rule, value) => value === true,
-        message: buildError($t("sys.edhr.fieldValueNeedTrue"))
-      });
-    }
-    if (validateFalse) {
-      RuleProps.push({
-        required: true,
-        validator: (_rule, value) => value === false,
-        message: buildError($t("sys.edhr.fieldValueNeedFalse"))
-      });
-    }
-    if (enableRangeValidate) {
-      if (minValidateMode === RangeValidateMode.Fixed_Number) {
-        RuleProps.push(
-          createValidationRule(
-            (_rule, value, callback, source, options) => {
-              if (isEmptyValue2(value)) return true;
-              const numberValue = Number(value);
-              if (numberValue < minValue) {
-                return false;
-              }
-              return true;
-            },
-            buildError($t("sys.edhr.fieldValueNotLessThan", { val: minValue }))
-          )
-        );
-      }
-      if (minValidateMode === RangeValidateMode.Variable_Validate && minFormulaExpr) {
-        RuleProps.push({
-          required: true,
-          validator: async (_rule, value, callback, source, options) => {
-            if (shouldSkipEnumValidation(_rule, options)) {
-              return Promise.resolve();
-            }
-            const { calculateFormula: calculateFormula2 } = useCalculateFormula();
-            const currentFormData = getCurrentFormData(_rule, options);
-            const formulaValue = await calculateFormula2(
-              minFormulaExpr,
-              currentFormData,
-              options?.formData
-            );
-            const parsedMin = parseFloat(formulaValue);
-            if (!isNaN(parsedMin)) {
-              if (isEmptyValue2(value)) {
-                return Promise.resolve();
-              }
-              const numberValue = Number(value);
-              if (numberValue < parsedMin) {
-                return Promise.reject(
-                  new Error(buildError($t("sys.edhr.fieldValueNotLessThan", { val: parsedMin })))
-                );
-              }
-            }
-            return Promise.resolve();
-          }
-        });
-      }
-      if (maxValidateMode === RangeValidateMode.Fixed_Number) {
-        RuleProps.push(
-          createValidationRule(
-            (_rule, value, callback, source, options) => {
-              if (isEmptyValue2(value)) return true;
-              const numberValue = Number(value);
-              if (numberValue > maxValue) {
-                return false;
-              }
-              return true;
-            },
-            buildError($t("sys.edhr.fieldValueNoMoreThan", { val: maxValue }))
-          )
-        );
-      }
-      if (maxValidateMode === RangeValidateMode.Variable_Validate && maxFormulaExpr) {
-        RuleProps.push({
-          required: true,
-          validator: async (_rule, value, callback, source, options) => {
-            if (shouldSkipEnumValidation(_rule, options)) {
-              return Promise.resolve();
-            }
-            const { calculateFormula: calculateFormula2 } = useCalculateFormula();
-            const currentFormData = getCurrentFormData(_rule, options);
-            const formulaValue = await calculateFormula2(
-              maxFormulaExpr,
-              currentFormData,
-              options?.formData
-            );
-            const parsedMax = parseFloat(formulaValue);
-            if (!isNaN(parsedMax)) {
-              if (isEmptyValue2(value)) {
-                return Promise.resolve();
-              }
-              const numberValue = Number(value);
-              if (numberValue > parsedMax) {
-                return Promise.reject(
-                  new Error(buildError($t("sys.edhr.fieldValueNoMoreThan", { val: parsedMax })))
-                );
-              }
-            }
-            return Promise.resolve();
-          }
-        });
-      }
-      if (minDateValidateMode === RangeValidateMode.Fixed_Number && minDate) {
-        RuleProps.push(
-          createValidationRule(
-            (_rule, value, callback, source, options) => {
-              if (isEmptyValue2(value)) return true;
-              const inputTime = dayjs(value).unix();
-              const minTimestamp = dayjs(minDate).unix();
-              if (inputTime < minTimestamp) {
-                return false;
-              }
-              return true;
-            },
-            buildError($t("sys.edhr.fieldValueNotLessThan", { val: minDate }))
-          )
-        );
-      }
-      if (maxDateValidateMode === RangeValidateMode.Fixed_Number && maxDate) {
-        RuleProps.push(
-          createValidationRule(
-            (_rule, value, callback, source, options) => {
-              if (isEmptyValue2(value)) return true;
-              const inputTime = dayjs(value).unix();
-              const maxTimestamp = dayjs(maxDate).unix();
-              if (inputTime > maxTimestamp) {
-                return false;
-              }
-              return true;
-            },
-            buildError($t("sys.edhr.fieldValueNoMoreThan", { val: maxDate }))
-          )
-        );
-      }
-      if (minDateValidateMode === RangeValidateMode.Variable_Validate && minDateFormulaExpr) {
-        RuleProps.push({
-          required: true,
-          validator: async (_rule, value, callback, source, options) => {
-            if (shouldSkipEnumValidation(_rule, options)) {
-              return Promise.resolve();
-            }
-            const { calculateFormula: calculateFormula2 } = useCalculateFormula();
-            const currentFormData = getCurrentFormData(_rule, options);
-            const formulaValue = await calculateFormula2(
-              minDateFormulaExpr,
-              currentFormData,
-              options?.formData
-            );
-            if (!isNil(formulaValue) && !isNaN(formulaValue)) {
-              if (isEmptyValue2(value)) {
-                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 (inputTime < formulaValue) {
-                return Promise.reject(
-                  new Error(
-                    buildError(
-                      $t("sys.edhr.fieldValueNotLessThan", {
-                        val: dayjs.unix(formulaValue).format(fmt)
-                      })
-                    )
-                  )
-                );
-              }
-            }
-            return Promise.resolve();
-          }
-        });
-      }
-      if (maxDateValidateMode === RangeValidateMode.Variable_Validate && maxDateFormulaExpr) {
-        RuleProps.push({
-          required: true,
-          validator: async (_rule, value, callback, source, options) => {
-            if (shouldSkipEnumValidation(_rule, options)) {
-              return Promise.resolve();
-            }
-            const { calculateFormula: calculateFormula2 } = useCalculateFormula();
-            const currentFormData = getCurrentFormData(_rule, options);
-            const formulaValue = await calculateFormula2(
-              maxDateFormulaExpr,
-              currentFormData,
-              options?.formData
-            );
-            if (!isNil(formulaValue) && !isNaN(formulaValue)) {
-              if (isEmptyValue2(value)) {
-                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 (inputTime > formulaValue) {
-                return Promise.reject(
-                  new Error(
-                    buildError(
-                      $t("sys.edhr.fieldValueNoMoreThan", {
-                        val: dayjs.unix(formulaValue).format(fmt)
-                      })
-                    )
-                  )
-                );
-              }
-            }
-            return Promise.resolve();
-          }
-        });
-      }
-    }
-    return RuleProps;
-  });
-  const getRules = (rules22, options) => rules22.map((item) => {
-    return {
-      ...item,
-      ...options
-    };
-  });
-  const resolveSubtableColIndex = () => {
-    if (!isNil(props.childSubTableDataIndex)) {
-      return props.childSubTableDataIndex;
-    }
-    if (targetFieldId === "value_") {
-      if (!isNil(props.realColIndex)) return props.realColIndex;
-      if (!isNil(props.realRowIndex)) return 0;
-    }
-    return void 0;
-  };
-  const resolveRuleEntry = () => {
-    if (props.subtableFieldId) {
-      if (!isNil(props.realRowIndex)) {
-        const colIdx = resolveSubtableColIndex();
-        if (colIdx !== void 0) {
-          return {
-            key: `${props.subtableFieldId}_${props.realRowIndex}_${targetFieldId}_${colIdx}`,
-            options: {
-              _subtableFieldId: props.subtableFieldId,
-              _realRowIndex: props.realRowIndex,
-              _targetFieldId: targetFieldId,
-              _childSubTableDataIndex: colIdx,
-              _belongFieldId: props.referenceInfo?.belongFieldId,
-              _optionValue: props.referenceInfo?.optionValue,
-              _multiple: props.referenceInfo?.multiple
-            }
-          };
-        }
-        return {
-          key: `${props.subtableFieldId}_${props.realRowIndex}_${targetFieldId}`,
-          options: {
-            _subtableFieldId: props.subtableFieldId,
-            _realRowIndex: props.realRowIndex,
-            _targetFieldId: targetFieldId,
-            _belongFieldId: props.referenceInfo?.belongFieldId,
-            _optionValue: props.referenceInfo?.optionValue,
-            _multiple: props.referenceInfo?.multiple
-          }
-        };
-      }
-      return null;
-    }
-    return {
-      key: targetFieldId,
-      options: {
-        _targetFieldId: targetFieldId,
-        _belongFieldId: props.referenceInfo?.belongFieldId,
-        _optionValue: props.referenceInfo?.optionValue,
-        _multiple: props.referenceInfo?.multiple
-      }
-    };
-  };
-  watch(
-    () => rules2.value,
-    () => {
-      if (!targetFieldId || !rules2.value) return;
-      const entry = resolveRuleEntry();
-      if (!entry) return;
-      if (rules2.value.length === 0) {
-        delete formRules.value[entry.key];
-        return;
-      }
-      formRules.value[entry.key] = getRules(toRaw(rules2.value), entry.options);
-    },
-    {
-      immediate: true,
-      deep: true
-    }
-  );
-  const widgetStyles = computed(() => {
-    if (widget.component === ComponentTypeEnum.DynValue) return {};
-    const requiredActive = showRequired.value && !showDisabled.value && !["readonly-text", "readonly-component"].includes(showDisplayStatus.value);
-    return {
-      ...sizeStyles,
-      ...requiredActive ? constantRequiredStyles : {},
-      // 竖排文本替换为可靠实现，避免服务端打印时字符重叠
-      ...isVerticalLrText(widget.style) ? reliableVerticalTextStyles : {}
-    };
-  });
-  return {
-    widgetStyles,
-    targetFieldId,
-    isFieldModel
-  };
-}
-const validate = async (formData, paper) => {
-  if (!paper?.props) return;
+const flattenFormData = (formData, paper) => {
   const subTable2DList = paper.props.subTable2DList ?? [];
   const checkTable2DList = paper.props.checkTable2DList ?? [];
   const list2D = [].concat(
     subTable2DList,
     checkTable2DList
   );
-  const _formRules_ = toRaw(formRules.value);
-  console.log("_formRules_", _formRules_);
   const filterKey = ["_DICT", "_OPCT", "__FOREIGN__", "_2DTABLE_"];
   const _formData_ = {};
   Object.keys(omit(formData, filterKey)).forEach((key) => {
@@ -61502,46 +61626,446 @@ const validate = async (formData, paper) => {
       _formData_[key] = formData[key];
     }
   });
-  console.log("_formData_", _formData_);
-  const validator = new Schema(_formRules_);
-  return new Promise((resolve, reject) => {
-    validator.validate(_formData_, {}, (errors, fields) => {
-      console.log("errors", errors);
+  return _formData_;
+};
+function resolveActiveRules(mode, rules2, meta, formKeepExceptionHighlight) {
+  const blocked = !!meta?.blocked;
+  const keepExceptionHighlight = resolveKeepExceptionHighlight(
+    formKeepExceptionHighlight,
+    meta?.keepExceptionHighlight
+  );
+  const decision = resolveValidationAdmission({
+    mode,
+    blocked,
+    keepExceptionHighlight
+  });
+  if (!decision.admit) {
+    return [];
+  }
+  if (mode === "all") return rules2;
+  if (mode === "display") {
+    return blocked ? rules2 : filterRulesByTrigger(rules2, "change");
+  }
+  return filterRulesByTrigger(rules2, mode);
+}
+async function runValidation(formData, paper, options = {}) {
+  if (!paper?.props) return;
+  const mode = options.mode ?? "all";
+  const rawRules = getRawFormRules();
+  const rawMeta = getRawFormRuleMeta();
+  const flatData = flattenFormData(formData, paper);
+  const activeRules = {};
+  const editablePaths = [];
+  const livePaths = [];
+  const validatedPaths = [];
+  const ruleKeys = Object.keys(rawRules);
+  for (const key of ruleKeys) {
+    const meta = rawMeta[key];
+    const rawPathRules = rawRules[key] ?? [];
+    const attachCtx = resolveAttachContext(rawPathRules[0], meta?.attach);
+    if (!isAttachFieldActive(attachCtx, formData)) {
+      validatedPaths.push(key);
+      if (!meta?.blocked) {
+        editablePaths.push(key);
+      }
+      if (mode !== "all" && mode !== "display") {
+        livePaths.push(key);
+      }
+      continue;
+    }
+    const rules2 = resolveActiveRules(mode, rawPathRules, meta, options.keepExceptionHighlight);
+    if (!rules2.length) {
+      if (mode === "display") {
+        const isEditableAttachField = !!meta?.attach?.belongFieldId && !meta?.blocked;
+        if (!isEditableAttachField) {
+          validatedPaths.push(key);
+        }
+      }
+      continue;
+    }
+    activeRules[key] = rules2;
+    validatedPaths.push(key);
+    if (!meta?.blocked) {
+      editablePaths.push(key);
+    }
+    if (mode !== "all" && mode !== "display") {
+      livePaths.push(key);
+    }
+  }
+  const validator = new Schema(activeRules);
+  const fields = await new Promise((resolve) => {
+    validator.validate(flatData, { first: false, formData }, (errors, errorFields) => {
       if (errors?.length) {
-        resolve({
-          isValid: false,
-          fields
-        });
+        resolve(errorFields);
       } else {
-        resolve({ isValid: true });
+        resolve(void 0);
       }
     });
   });
-};
-function clearFormRules() {
-  formRules.value = {};
+  return {
+    isValid: !fields || Object.keys(fields).length === 0,
+    fields,
+    editablePaths,
+    livePaths,
+    validatedPaths,
+    ruleKeys,
+    flatData
+  };
 }
-function deleteSubtableRow(subtableFieldId, realRowIndex) {
-  const newFormRules = {};
-  for (const key in formRules.value) {
-    const regex = new RegExp(`^${subtableFieldId}_(\\d+)_`);
-    const match = key.match(regex);
-    if (match) {
-      const rowIndex = parseInt(match[1]);
-      if (rowIndex < realRowIndex) {
-        newFormRules[key] = formRules.value[key];
-      } else if (rowIndex > realRowIndex) {
-        const newKey = key.replace(
-          `${subtableFieldId}_${rowIndex}_`,
-          `${subtableFieldId}_${rowIndex - 1}_`
-        );
-        newFormRules[newKey] = formRules.value[key];
+function resolvePayloadForPath(path, flatData) {
+  const rules2 = getRawFormRules()[path];
+  if (!rules2) return null;
+  return {
+    value: flatData[path],
+    rules: rules2
+  };
+}
+function clearResolvedManualErrors(map, resolvePayload) {
+  if (!map) return map;
+  const next = { ...map };
+  for (const path of Object.keys(next)) {
+    const payload = resolvePayload(path);
+    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)) {
+      delete next[path];
+    }
+  }
+  return Object.keys(next).length ? next : null;
+}
+function mergeLiveValidation(current, liveResult, livePaths, resolvePayload) {
+  const base = current && Object.keys(current).length ? { ...current } : {};
+  for (const path of livePaths) {
+    if (liveResult?.[path]) {
+      base[path] = liveResult[path];
+      continue;
+    }
+    const payload = resolvePayload(path);
+    const keepManualComment = !!payload && filterRulesByTrigger(payload.rules, "manual").length > 0 && isEmptyValue$1(payload.value) && !!base[path]?.length;
+    if (!keepManualComment) {
+      delete base[path];
+    }
+  }
+  const merged = Object.keys(base).length ? base : liveResult;
+  return clearResolvedManualErrors(merged, resolvePayload);
+}
+function mergeSubmitValidation(current, submitResult, editablePaths) {
+  const next = current && Object.keys(current).length ? { ...current } : {};
+  for (const path of editablePaths) {
+    if (submitResult?.[path]) {
+      next[path] = submitResult[path];
+    } else {
+      delete next[path];
+    }
+  }
+  return Object.keys(next).length ? next : null;
+}
+function pruneValidationComments(current, validPaths) {
+  if (!current) return null;
+  const next = {};
+  for (const path of Object.keys(current)) {
+    if (validPaths.has(path)) {
+      next[path] = current[path];
+    }
+  }
+  return Object.keys(next).length ? next : null;
+}
+function mergeDisplayValidation(current, displayResult, ruleKeys, validatedPaths) {
+  const next = current && Object.keys(current).length ? { ...current } : {};
+  const ruleSet = new Set(ruleKeys);
+  const validatedSet = new Set(validatedPaths);
+  for (const path of Object.keys(next)) {
+    if (!ruleSet.has(path)) {
+      delete next[path];
+    }
+  }
+  for (const path of validatedSet) {
+    if (displayResult?.[path]?.length) {
+      next[path] = displayResult[path];
+    } else {
+      delete next[path];
+    }
+  }
+  return Object.keys(next).length ? next : null;
+}
+const DEBOUNCE_MS = 300;
+const schedulersById = /* @__PURE__ */ new Map();
+function getScheduler(id) {
+  let scheduler = schedulersById.get(id);
+  if (!scheduler) {
+    scheduler = {
+      debounceTimer: null,
+      running: false,
+      pendingTrigger: "change"
+    };
+    schedulersById.set(id, scheduler);
+  }
+  return scheduler;
+}
+function clearValidationScheduler(id) {
+  const scheduler = schedulersById.get(id);
+  if (!scheduler) return;
+  if (scheduler.debounceTimer) {
+    clearTimeout(scheduler.debounceTimer);
+    scheduler.debounceTimer = null;
+  }
+  schedulersById.delete(id);
+}
+function clearAllValidationSchedulers() {
+  for (const id of [...schedulersById.keys()]) {
+    clearValidationScheduler(id);
+  }
+}
+function requestScheduledValidation(id, execute, options = {}) {
+  const { immediate = false, trigger = "change" } = options;
+  const scheduler = getScheduler(id);
+  const run = async (mode) => {
+    if (scheduler.running) {
+      scheduler.pendingTrigger = mode;
+      return;
+    }
+    scheduler.running = true;
+    try {
+      await execute(mode);
+      const pending = scheduler.pendingTrigger;
+      scheduler.pendingTrigger = "change";
+      if (pending !== mode) {
+        await execute(pending);
+      }
+    } finally {
+      scheduler.running = false;
+    }
+  };
+  if (immediate) {
+    if (scheduler.debounceTimer) {
+      clearTimeout(scheduler.debounceTimer);
+      scheduler.debounceTimer = null;
+    }
+    scheduler.pendingTrigger = trigger;
+    void run(trigger);
+    return;
+  }
+  scheduler.pendingTrigger = trigger;
+  if (scheduler.debounceTimer) {
+    clearTimeout(scheduler.debounceTimer);
+  }
+  scheduler.debounceTimer = setTimeout(() => {
+    scheduler.debounceTimer = null;
+    void run(scheduler.pendingTrigger);
+  }, DEBOUNCE_MS);
+}
+async function waitForTickSettle() {
+  await nextTick$1();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
+function countAttachRules() {
+  const meta = getRawFormRuleMeta();
+  let n = 0;
+  for (const key of Object.keys(meta)) {
+    if (meta[key]?.attach?.belongFieldId != null) n += 1;
+  }
+  return n;
+}
+async function waitForValidationReady(options) {
+  const timeoutMs = options?.timeoutMs ?? 3e3;
+  const intervalMs = options?.intervalMs ?? 50;
+  const stableRounds = options?.stableRounds ?? 4;
+  const minElapsedMs = options?.minElapsedMs ?? 0;
+  await waitForTickSettle();
+  const startedAt = Date.now();
+  const deadline = startedAt + timeoutMs;
+  let lastSignature = "";
+  let stable = 0;
+  while (Date.now() < deadline) {
+    const signature = `${listFormRuleKeys().length}:${countAttachRules()}`;
+    if (signature === lastSignature) {
+      stable += 1;
+      if (stable >= stableRounds && Date.now() - startedAt >= minElapsedMs) {
+        await nextTick$1();
+        await nextTick$1();
+        return;
       }
     } else {
-      newFormRules[key] = formRules.value[key];
+      lastSignature = signature;
+      stable = 0;
     }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
   }
-  formRules.value = newFormRules;
+  await nextTick$1();
+}
+const contexts = /* @__PURE__ */ new Map();
+function registerValidationContext(ctx) {
+  contexts.set(ctx.uniqueId, ctx);
+}
+function unregisterValidationContext(uniqueId) {
+  clearValidationScheduler(uniqueId);
+  cancelPendingDisplayTimer(uniqueId);
+  cancelStructureChangeTimer(uniqueId);
+  contexts.delete(uniqueId);
+}
+function getContext(uniqueId) {
+  return contexts.get(uniqueId);
+}
+function resolveFormKeep(ctx) {
+  return resolveKeepExceptionHighlight(ctx.getKeepExceptionHighlight?.(), void 0);
+}
+function cancelPendingDisplayTimer(uniqueId) {
+  const prev = displayDebounceTimers.get(uniqueId);
+  if (prev) {
+    clearTimeout(prev);
+    displayDebounceTimers.delete(uniqueId);
+  }
+}
+async function executeValidation(ctx, mode) {
+  const paper = ctx.getPaper();
+  if (!paper) return;
+  const formData = ctx.getFormData();
+  const res = await runValidation(formData, paper, {
+    mode,
+    keepExceptionHighlight: resolveFormKeep(ctx)
+  });
+  if (!res) return;
+  const fields = res.fields ?? null;
+  const editablePaths = res.editablePaths ?? [];
+  const livePaths = res.livePaths ?? [];
+  const flatData = res.flatData ?? {};
+  if (mode === "all") {
+    const merged = mergeSubmitValidation(ctx.getComments(), fields, editablePaths);
+    ctx.applyComments(merged);
+  } else if (mode === "display") {
+    const merged = mergeDisplayValidation(
+      ctx.getComments(),
+      fields,
+      res.ruleKeys ?? listFormRuleKeys(),
+      res.validatedPaths ?? Object.keys(fields ?? {})
+    );
+    ctx.applyComments(merged);
+  } else {
+    const merged = mergeLiveValidation(
+      ctx.getComments(),
+      fields,
+      livePaths,
+      (path) => resolvePayloadForPath(path, flatData)
+    );
+    ctx.applyComments(merged);
+  }
+  return res;
+}
+async function validateAllFields(uniqueId) {
+  const ctx = getContext(uniqueId);
+  if (!ctx) {
+    return void 0;
+  }
+  return executeValidation(ctx, "all");
+}
+async function validateDisplayFields(uniqueId) {
+  const ctx = getContext(uniqueId);
+  if (!ctx) return;
+  return executeValidation(ctx, "display");
+}
+const displayDebounceTimers = /* @__PURE__ */ new Map();
+const DISPLAY_DEBOUNCE_MS = 320;
+const structureChangeTimers = /* @__PURE__ */ new Map();
+function cancelStructureChangeTimer(uniqueId) {
+  const prev = structureChangeTimers.get(uniqueId);
+  if (prev) {
+    clearTimeout(prev);
+    structureChangeTimers.delete(uniqueId);
+  }
+}
+function scheduleRevalidateAfterStructureChange(uniqueId) {
+  cancelStructureChangeTimer(uniqueId);
+  structureChangeTimers.set(
+    uniqueId,
+    setTimeout(() => {
+      structureChangeTimers.delete(uniqueId);
+      void (async () => {
+        await waitForValidationReady({
+          timeoutMs: 2e3,
+          stableRounds: 3,
+          minElapsedMs: 40
+        });
+        pruneFormValidationComments(uniqueId);
+        requestFullValidation(uniqueId, { trigger: "change" });
+        requestDisplayValidation(uniqueId);
+      })();
+    }, 60)
+  );
+}
+function requestDisplayValidation(uniqueId, immediate = false) {
+  cancelPendingDisplayTimer(uniqueId);
+  const run = () => {
+    displayDebounceTimers.delete(uniqueId);
+    void validateDisplayFields(uniqueId);
+  };
+  if (immediate) {
+    run();
+    return;
+  }
+  displayDebounceTimers.set(uniqueId, setTimeout(run, DISPLAY_DEBOUNCE_MS));
+}
+function requestFullValidation(uniqueId, options = {}) {
+  const ctx = getContext(uniqueId);
+  if (!ctx) return;
+  requestScheduledValidation(
+    uniqueId,
+    async (trigger) => {
+      await executeValidation(ctx, trigger);
+    },
+    options
+  );
+}
+function pruneFormValidationComments(uniqueId) {
+  const ctx = getContext(uniqueId);
+  if (!ctx) return;
+  const validPaths = new Set(listFormRuleKeys());
+  ctx.applyComments(pruneValidationComments(ctx.getComments(), validPaths));
+}
+function clearFormRules() {
+  clearAllValidationSchedulers();
+  for (const timer of displayDebounceTimers.values()) {
+    clearTimeout(timer);
+  }
+  displayDebounceTimers.clear();
+  for (const timer of structureChangeTimers.values()) {
+    clearTimeout(timer);
+  }
+  structureChangeTimers.clear();
+  clearFormRules$1();
+}
+function deleteSubtableRow(subtableFieldId, realRowIndex) {
+  deleteSubtableRow$1(subtableFieldId, realRowIndex);
+  for (const uniqueId of contexts.keys()) {
+    pruneFormValidationComments(uniqueId);
+    scheduleRevalidateAfterStructureChange(uniqueId);
+  }
+}
+function insertSubtableRows(subtableFieldId, insertIndex, count = 1) {
+  insertSubtableRows$1(subtableFieldId, insertIndex, count);
+  for (const uniqueId of contexts.keys()) {
+    pruneFormValidationComments(uniqueId);
+    scheduleRevalidateAfterStructureChange(uniqueId);
+  }
+}
+async function settleAndValidateDisplay(uniqueId) {
+  await waitForValidationReady();
+  await validateDisplayFields(uniqueId);
+}
+async function settleAfterModeSwitch(uniqueId, options) {
+  const ctx = getContext(uniqueId);
+  if (!ctx) return;
+  cancelPendingDisplayTimer(uniqueId);
+  await waitForValidationReady({ timeoutMs: 4e3, stableRounds: 6, minElapsedMs: 450 });
+  await nextTick$1();
+  await waitForTickSettle();
+  await new Promise((resolve) => setTimeout(resolve, 280));
+  await waitForValidationReady({ timeoutMs: 2500, stableRounds: 5, minElapsedMs: 200 });
+  cancelPendingDisplayTimer(uniqueId);
+  if (options?.runChangeLive) {
+    await executeValidation(ctx, "change");
+  }
+  await validateDisplayFields(uniqueId);
 }
 const getApi$1 = api.apaas.modelComprehensive.getBizServiceModelCategoryModelKeyBsKey;
 const postApi = api.apaas.modelComprehensive.postBizServiceModelCategoryModelKeyBsKey;
@@ -61711,6 +62235,303 @@ function calcFillData(data, fillMapArr) {
   }
   return obj;
 }
+const FormChangeRowCellType = {
+  ADD: "SUBTABLE_ROW_ADD",
+  DEL: "SUBTABLE_ROW_DEL"
+};
+const ROW_LOC_RE = /^(.+)__ROW__(ADD|DEL)__(.+)$/;
+const FIELD_RID_MARK = "__RID__";
+const FIELD_MARK = "__FIELD__";
+const COL_MARK = "__COL__";
+const ROW_LABEL = {
+  dash: "—",
+  add: "新增一行",
+  del: "已删除"
+};
+const SNAPSHOT_SKIP = /* @__PURE__ */ new Set([
+  "tempDeleted",
+  FRONT_ROW_KEY,
+  "id_",
+  "group_",
+  "sort_num_",
+  "ref_master_id_",
+  "ref_field_key_",
+  "ref_model_key_",
+  "tenant_id_",
+  "deleted_",
+  "is_confirmed_"
+]);
+function rowIdentityKeys(row) {
+  if (!row) return [];
+  return [
+    row[FRONT_ROW_KEY] != null && String(row[FRONT_ROW_KEY]).trim() !== "" ? String(row[FRONT_ROW_KEY]) : void 0,
+    row.id_ != null && row.id_ !== "" ? String(row.id_) : void 0
+  ].filter(Boolean);
+}
+function getFormChangeRowKey(row) {
+  return rowIdentityKeys(row)[0];
+}
+function rowMatchesIdentity(row, ...idents) {
+  const keys2 = rowIdentityKeys(row);
+  return idents.some((id) => id != null && id !== "" && keys2.includes(String(id)));
+}
+function buildFormChangeRowLocation(subFieldId, rowKey, op) {
+  return `${subFieldId}__ROW__${op}__${rowKey}`;
+}
+function parseFormChangeRowLocation(cellLocation) {
+  if (!cellLocation) return null;
+  const matched = cellLocation.match(ROW_LOC_RE);
+  if (!matched) return null;
+  return {
+    subFieldId: matched[1],
+    op: matched[2],
+    rowKey: matched[3]
+  };
+}
+function isFormChangeRowLocation(cellLocation) {
+  return !!parseFormChangeRowLocation(cellLocation);
+}
+function getFormChangeRowOp(cellLocation) {
+  return parseFormChangeRowLocation(cellLocation)?.op ?? null;
+}
+function isAnnLocationSelected(selectId, loc) {
+  if (!loc || selectId == null) return false;
+  return Array.isArray(selectId) ? selectId.includes(loc) : selectId === loc;
+}
+function isFormChangeGhostRow(row) {
+  return !!(row?.deleted_ || row?.__fcOrphanAdd);
+}
+function buildStableFieldLocation(subFieldId, rowKey, fieldId, colIdx) {
+  const base = `${subFieldId}${FIELD_RID_MARK}${rowKey}${FIELD_MARK}${fieldId}`;
+  return colIdx === void 0 ? base : `${base}${COL_MARK}${colIdx}`;
+}
+function parseStableFieldLocation(cellLocation) {
+  if (!cellLocation || !cellLocation.includes(FIELD_RID_MARK)) return null;
+  const ridAt = cellLocation.indexOf(FIELD_RID_MARK);
+  const subFieldId = cellLocation.slice(0, ridAt);
+  const afterRid = cellLocation.slice(ridAt + FIELD_RID_MARK.length);
+  const fieldAt = afterRid.indexOf(FIELD_MARK);
+  if (fieldAt < 0) return null;
+  const rowKey = afterRid.slice(0, fieldAt);
+  const afterField = afterRid.slice(fieldAt + FIELD_MARK.length);
+  const colAt = afterField.indexOf(COL_MARK);
+  if (colAt >= 0) {
+    return {
+      subFieldId,
+      rowKey,
+      fieldId: afterField.slice(0, colAt),
+      colIdx: Number(afterField.slice(colAt + COL_MARK.length))
+    };
+  }
+  return { subFieldId, rowKey, fieldId: afterField, colIdx: void 0 };
+}
+function resolveAnnotationFieldLocation(options) {
+  const { annList, subFieldId, fieldId, row, colIdx } = options;
+  if (!Array.isArray(annList) || !annList.length || !subFieldId) return void 0;
+  if (!rowIdentityKeys(row).length) return void 0;
+  return annList.find((loc) => {
+    const parsed = parseStableFieldLocation(loc);
+    if (!parsed || parsed.subFieldId !== subFieldId || parsed.fieldId !== fieldId) return false;
+    if (colIdx !== void 0 && parsed.colIdx !== colIdx) return false;
+    if (colIdx === void 0 && parsed.colIdx !== void 0) return false;
+    return rowMatchesIdentity(row, parsed.rowKey);
+  });
+}
+function shouldSkipSnapshotKey(key) {
+  return SNAPSHOT_SKIP.has(key) || key.startsWith("__fc") || key.startsWith("_") || key.endsWith("_lb_");
+}
+function pickRowSnapshot(row) {
+  if (!row) return {};
+  const out = {};
+  Object.keys(row).forEach((key) => {
+    if (shouldSkipSnapshotKey(key)) return;
+    const value = row[key];
+    if (value == null || value === "") return;
+    out[key] = cloneDeep(value);
+  });
+  return out;
+}
+function buildRowPayload(rowKey, row, prevId) {
+  return JSON.stringify({
+    rowKey,
+    snapshot: pickRowSnapshot(row),
+    id: row?.id_ ?? prevId
+  });
+}
+function parseRowPayload(raw) {
+  if (raw == null || raw === "") return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && parsed.rowKey) {
+      return {
+        rowKey: String(parsed.rowKey),
+        snapshot: parsed.snapshot && typeof parsed.snapshot === "object" ? parsed.snapshot : {},
+        id: parsed.id
+      };
+    }
+  } catch (e) {
+  }
+  return null;
+}
+function recordRowOp(ds, subFieldId, row, op) {
+  if (!ds?.formChangeStatus) return;
+  const rowKey = getFormChangeRowKey(row);
+  if (!rowKey) return;
+  const loc = buildFormChangeRowLocation(subFieldId, rowKey, op);
+  if (op === "DEL") {
+    const addLoc = buildFormChangeRowLocation(subFieldId, rowKey, "ADD");
+    const hadAdd = !!ds.formChangeNewData?.[addLoc];
+    const next = { ...ds.formChangeNewData || {} };
+    delete next[addLoc];
+    delete next[loc];
+    ds.formChangeNewData = next;
+    if (hadAdd) return;
+  }
+  const payload = buildRowPayload(rowKey, row);
+  ds.formChangeNewData = {
+    ...ds.formChangeNewData || {},
+    [loc]: {
+      cellLocation: loc,
+      cellType: FormChangeRowCellType[op],
+      beforeValue: op === "DEL" ? payload : "",
+      beforeLabel: ROW_LABEL.dash,
+      afterValue: op === "ADD" ? payload : "",
+      afterLabel: op === "ADD" ? ROW_LABEL.add : ROW_LABEL.del
+    }
+  };
+}
+function isRowAddedInCurrentFormChange(dataRelationShip, subFieldId, row) {
+  if (!dataRelationShip?.formChangeStatus || !subFieldId || !row) return false;
+  const rowKey = getFormChangeRowKey(row);
+  if (!rowKey) return false;
+  return !!dataRelationShip.formChangeNewData?.[buildFormChangeRowLocation(subFieldId, rowKey, "ADD")];
+}
+function recordSubtableRowAdd(dataRelationShip, subFieldId, rows) {
+  rows?.forEach((row) => recordRowOp(dataRelationShip, subFieldId, row, "ADD"));
+}
+function recordSubtableRowDelete(dataRelationShip, subFieldId, row) {
+  if (row) recordRowOp(dataRelationShip, subFieldId, row, "DEL");
+}
+function findRowByKey(candidates, rowKey, id) {
+  return candidates.find((row) => rowMatchesIdentity(row, rowKey, id));
+}
+function enrichFormChangeRowDetails(formChangeNewData, formState) {
+  if (!formChangeNewData || !formState) return formChangeNewData;
+  Object.values(formChangeNewData).forEach((detail) => {
+    const loc = parseFormChangeRowLocation(detail?.cellLocation);
+    if (!loc) return;
+    const rows = formState[loc.subFieldId];
+    if (!Array.isArray(rows)) return;
+    const isAdd = loc.op === "ADD";
+    const prev = parseRowPayload(isAdd ? detail.afterValue : detail.beforeValue);
+    const row = findRowByKey(rows, loc.rowKey, prev?.id);
+    if (!row) return;
+    const payload = buildRowPayload(loc.rowKey, row, prev?.id);
+    if (isAdd) {
+      detail.afterValue = payload;
+      detail.afterLabel = ROW_LABEL.add;
+    } else {
+      detail.beforeValue = payload;
+      detail.beforeLabel = ROW_LABEL.dash;
+      detail.afterLabel = ROW_LABEL.del;
+    }
+  });
+  return formChangeNewData;
+}
+function extractFormChangeRowDetails(items) {
+  const result = [];
+  (items || []).forEach((item) => {
+    (item?.details || []).forEach((detail) => {
+      const loc = parseFormChangeRowLocation(detail?.cellLocation);
+      if (!loc) return;
+      const raw = loc.op === "ADD" ? detail.afterValue : detail.beforeValue;
+      const payload = parseRowPayload(raw) || { rowKey: loc.rowKey, snapshot: {} };
+      result.push({
+        cellLocation: detail.cellLocation,
+        cellType: loc.op === "ADD" ? FormChangeRowCellType.ADD : FormChangeRowCellType.DEL,
+        op: loc.op,
+        subFieldId: loc.subFieldId,
+        rowKey: payload.rowKey || loc.rowKey,
+        snapshot: payload.snapshot || {},
+        id: payload.id != null ? String(payload.id) : void 0
+      });
+    });
+  });
+  return result;
+}
+function detailsHaveFormChangeRowOps(details) {
+  return (details || []).some((d) => isFormChangeRowLocation(d?.cellLocation));
+}
+function collectFormChangeFieldLocations(items) {
+  const set2 = /* @__PURE__ */ new Set();
+  (items || []).forEach((item) => {
+    (item.details || []).forEach((detail) => {
+      const loc = detail?.cellLocation;
+      if (loc && !isFormChangeRowLocation(loc)) set2.add(loc);
+    });
+  });
+  return Array.from(set2);
+}
+function resolveRowFormChangeMark(subFieldId, row, annRowDetails) {
+  if (!rowIdentityKeys(row).length) return null;
+  const details = (annRowDetails || []).filter(
+    (item) => item.subFieldId === subFieldId && rowMatchesIdentity(row, item.rowKey, item.id)
+  );
+  if (!details.length) return null;
+  const foundDel = details.find((item) => item.op === "DEL");
+  const foundAdd = details.find((item) => item.op === "ADD");
+  const hit = row?.deleted_ ? foundDel : foundAdd || foundDel;
+  return hit ? { op: hit.op, cellLocation: hit.cellLocation } : null;
+}
+const WM_UI = {
+  ADD: {
+    trClass: "form-change-row-add",
+    wmText: "新增",
+    wmClass: "form-change-row-wm--add"
+  },
+  DEL: {
+    trClass: "form-change-row-del",
+    wmText: "删除",
+    wmClass: "form-change-row-wm--del"
+  },
+  ORPHAN: {
+    trClass: "form-change-row-orphan",
+    wmText: "增后删",
+    wmClass: "form-change-row-wm--orphan"
+  }
+};
+function resolveFormChangeRowUi(row, rowMark) {
+  if (!rowMark) {
+    return { trClass: "", wmKind: null, wmText: "", wmClass: "" };
+  }
+  const wmKind = rowMark.op === "DEL" ? "DEL" : row?.__fcOrphanAdd ? "ORPHAN" : "ADD";
+  return { wmKind, ...WM_UI[wmKind] };
+}
+function buildFormChangeDisplayRows(subFieldId, currentRows, annRowDetails) {
+  const rows = currentRows || [];
+  const liveRows = rows.filter((row) => !row?.deleted_);
+  const details = (annRowDetails || []).filter((item) => item.subFieldId === subFieldId);
+  if (!details.length) return liveRows;
+  const deletedRows = rows.filter((row) => row?.deleted_);
+  const makeGhost = (detail, orphan = false) => ({
+    ...cloneDeep(detail.snapshot || {}),
+    ...detail.id != null ? { id_: detail.id } : {},
+    [FRONT_ROW_KEY]: detail.rowKey,
+    ...orphan ? { __fcOrphanAdd: true } : { deleted_: true }
+  });
+  const delTail = details.filter((item) => item.op === "DEL").map((item) => findRowByKey(deletedRows, item.rowKey, item.id) || makeGhost(item));
+  const orphanTail = details.filter((item) => item.op === "ADD" && !findRowByKey(liveRows, item.rowKey, item.id)).map((item) => makeGhost(item, true));
+  return [...liveRows, ...delTail, ...orphanTail];
+}
+function nextFormChangeRowViewHistoryId(currentId, historyId, items) {
+  if (!historyId || currentId === historyId) {
+    return { historyId: void 0, rowDetails: [] };
+  }
+  const item = (items || []).find((x) => x.id === historyId);
+  const rowDetails = extractFormChangeRowDetails(item ? [item] : []);
+  if (!rowDetails.length) return { historyId: void 0, rowDetails: [] };
+  return { historyId, rowDetails };
+}
 const { getParseFormulaVarInfos, calculateFormula } = useCalculateFormula();
 function useNocodeFormWidget(props, emit) {
   const widget = props.widget;
@@ -61866,29 +62687,55 @@ function useNocodeFormWidget(props, emit) {
       // 修改之后的值(展示值)
     };
   }
+  function resolveSubtableColIdx() {
+    if (!props.subtableFieldId) return void 0;
+    if (!isNil(props.childSubTableDataIndex)) return props.childSubTableDataIndex;
+    if (targetFieldId === "value_") {
+      if (!isNil(props.realColIndex)) return props.realColIndex;
+      if (!isNil(props.realRowIndex)) return 0;
+    }
+    return void 0;
+  }
   function handleOperationLog(callback) {
-    const operationId = realFieldId.value ?? "";
+    if (props.subtableFieldId && isRowAddedInCurrentFormChange(dataRelationShip, props.subtableFieldId, props.formData)) {
+      return;
+    }
+    let operationId = realFieldId.value ?? "";
+    if (props.subtableFieldId && props.formData) {
+      const rowKey = getFormChangeRowKey(props.formData);
+      if (rowKey) {
+        operationId = buildStableFieldLocation(
+          props.subtableFieldId,
+          rowKey,
+          targetFieldId,
+          resolveSubtableColIdx()
+        );
+      }
+    }
     let originData;
     if (props.subtableFieldId) {
-      if (has(props, "childSubTableDataIndex") && !isNil(props.childSubTableDataIndex)) {
-        originData = dataRelationShip?.formChangeOriginData?.[props.subtableFieldId]?.[props.realRowIndex]?.["_2DTABLE_"]?.[props.childSubTableDataIndex] ?? {};
-      } else {
-        originData = dataRelationShip?.formChangeOriginData?.[props.subtableFieldId]?.[props.realRowIndex] ?? {};
-      }
+      const originRows = dataRelationShip?.formChangeOriginData?.[props.subtableFieldId];
+      const currentKey = getFormChangeRowKey(props.formData);
+      const childIdx = !isNil(props.childSubTableDataIndex) ? props.childSubTableDataIndex : void 0;
+      const originRow = (Array.isArray(originRows) ? originRows.find((item) => {
+        if (item?.deleted_) return false;
+        if (getFormChangeRowKey(item) === currentKey) return true;
+        return childIdx != null && item?._2DTABLE_?.some((child) => getFormChangeRowKey(child) === currentKey);
+      }) : void 0) ?? originRows?.[props.realRowIndex];
+      originData = childIdx != null ? originRow?.["_2DTABLE_"]?.[childIdx] ?? {} : originRow ?? {};
     } else {
       originData = dataRelationShip?.formChangeOriginData;
     }
     const newData = getOperationLogData(targetFieldId, originData, callback);
     if (dataRelationShip) {
-      dataRelationShip.formChangeNewData = merge({}, dataRelationShip.formChangeNewData, {
+      dataRelationShip.formChangeNewData = {
+        ...dataRelationShip.formChangeNewData || {},
         [operationId]: {
           ...newData,
           cellLocation: operationId,
-          // 单元格坐标
           cellType: fieldType
-          // 单元格类型(对应前端组件类型)
         }
-      });
+      };
     }
   }
   async function formulaOperationLog() {
@@ -61915,8 +62762,21 @@ function useNocodeFormWidget(props, emit) {
         option: optionDetail ?? valueData
       });
     }
+    const triggerLiveValidation = () => {
+      const uniqueId = dataRelationShip?.uniqueId;
+      if (!uniqueId || dataRelationShip?.renderModeType !== RenderModeEnum.FormMode) {
+        return;
+      }
+      if (eventType === "onChange") {
+        requestFullValidation(uniqueId, { trigger: "change" });
+        requestDisplayValidation(uniqueId);
+      } else if (eventType === "onBlur") {
+        requestFullValidation(uniqueId, { trigger: "blur", immediate: true });
+      }
+    };
     if (eventType === "onChange" && dataRelationShip?.formChangeStatus) {
       handleOperationLog(callback);
+      triggerLiveValidation();
       return;
     }
     const methodName = isExecuteEvent(eventType);
@@ -61934,6 +62794,7 @@ function useNocodeFormWidget(props, emit) {
     }
     const { emitter: emitter2, EmitterEnum: EmitterEnum2 } = useNocodeEmitter();
     emitter2.emit(EmitterEnum2.__on_looper_auto_save, { changed: true });
+    triggerLiveValidation();
   }
   const onChange = (callback = () => {
   }, valueData, optionDetail) => handleEvent("onChange", callback, valueData, optionDetail);
@@ -61944,13 +62805,7 @@ function useNocodeFormWidget(props, emit) {
   const onPressEnter = () => handleEvent("onPressEnter");
   const realFieldId = computed(() => {
     if (props.subtableFieldId) {
-      let colIdx;
-      if (!isNil(props.childSubTableDataIndex)) {
-        colIdx = props.childSubTableDataIndex;
-      } else if (targetFieldId === "value_") {
-        if (!isNil(props.realColIndex)) colIdx = props.realColIndex;
-        else if (!isNil(props.realRowIndex)) colIdx = 0;
-      }
+      const colIdx = resolveSubtableColIdx();
       if (colIdx !== void 0) {
         return `${props.subtableFieldId}_${props.realRowIndex}_${targetFieldId}_${colIdx}`;
       }
@@ -61960,21 +62815,40 @@ function useNocodeFormWidget(props, emit) {
   });
   const annotationInfo = computed(() => {
     const fieldId = realFieldId.value;
-    if (!fieldId) {
+    if (!fieldId && !props.subtableFieldId) {
       return false;
     }
+    const annRowDetails = dataRelationShip?.annRowDetails;
+    const rowViewActive = !!annRowDetails?.length;
+    if (props.subtableFieldId && props.formData && rowViewActive) {
+      if (isFormChangeGhostRow(props.formData) || resolveRowFormChangeMark(props.subtableFieldId, props.formData, annRowDetails)) {
+        return false;
+      }
+    }
     const annList = dataRelationShip?.annCellLocationList;
     const validatorList = dataRelationShip?.validatorLocationList;
-    const annIncluded = dataRelationShip?.annSwitchStatus && Array.isArray(annList) && annList.includes(fieldId);
-    const isSelected = dataRelationShip?.annSelectId === fieldId;
-    const isInvalid = Array.isArray(validatorList) && validatorList.includes(fieldId);
+    const colIdx = resolveSubtableColIdx();
+    const matchedAnnLoc = props.subtableFieldId ? resolveAnnotationFieldLocation({
+      annList,
+      subFieldId: props.subtableFieldId,
+      fieldId: targetFieldId,
+      row: props.formData,
+      colIdx
+    }) : dataRelationShip?.annSwitchStatus && Array.isArray(annList) && fieldId && annList.includes(fieldId) ? fieldId : void 0;
+    const annIncluded = !!dataRelationShip?.annSwitchStatus && !!matchedAnnLoc;
+    const isSelected = isAnnLocationSelected(dataRelationShip?.annSelectId, matchedAnnLoc);
+    const isInvalid = !dataRelationShip?.annSwitchStatus && Array.isArray(validatorList) && !!fieldId && validatorList.includes(fieldId);
     const annClassList = [];
-    if (annIncluded) {
-      annClassList.push(fieldId, "annotation-mark");
+    if (annIncluded && matchedAnnLoc) {
+      annClassList.push(matchedAnnLoc, "annotation-mark");
       if (isSelected) annClassList.push("annotation-select");
     }
     if (annClassList.length || isInvalid) {
-      return { annClassList, annFieldId: fieldId, showValidatorClass: isInvalid };
+      return {
+        annClassList,
+        annFieldId: matchedAnnLoc || fieldId,
+        showValidatorClass: isInvalid
+      };
     }
     return false;
   });
@@ -62310,27 +63184,27 @@ var loadModule = (cmpMeta, hostRef, hmrVersionId) => {
       case "revo-grid":
         return import(
           /* webpackMode: "lazy" */
-          "./revo-grid.entry-ztDhASK3.js"
+          "./revo-grid.entry-BeRVTVKO.js"
         ).then(processMod, consoleError);
       case "revogr-filter-panel":
         return import(
           /* webpackMode: "lazy" */
-          "./revogr-filter-panel.entry-unpVAD7l.js"
+          "./revogr-filter-panel.entry-BDkhY-74.js"
         ).then(processMod, consoleError);
       case "revogr-attribution_7":
         return import(
           /* webpackMode: "lazy" */
-          "./revogr-attribution_7.entry-BtXV91vv.js"
+          "./revogr-attribution_7.entry-CHtbU2lV.js"
         ).then(processMod, consoleError);
       case "revogr-clipboard_3":
         return import(
           /* webpackMode: "lazy" */
-          "./revogr-clipboard_3.entry-DXpq4oNb.js"
+          "./revogr-clipboard_3.entry-DnvQ-Rl7.js"
         ).then(processMod, consoleError);
       case "revogr-data_4":
         return import(
           /* webpackMode: "lazy" */
-          "./revogr-data_4.entry-WA1PNcGb.js"
+          "./revogr-data_4.entry-DLRSuaN8.js"
         ).then(processMod, consoleError);
     }
   }
@@ -72401,7 +73275,7 @@ export {
   ReturnTypeEnum as Z,
   _export_sfc as _,
   PaperWidgeType as a,
-  fetchCustomCheckDsData as a$,
+  MobileFillTypeEnum as a$,
   PaperSizeMap as a0,
   EntityModelCategoryEnum as a1,
   CheckDsTypeEnum as a2,
@@ -72412,174 +73286,207 @@ export {
   BinarizeMethodOptions as a7,
   ParamModelTypeEnum as a8,
   JoinModelTypeEum as a9,
-  transformUtils as aA,
-  clearFormRules as aB,
-  baseDataUtils as aC,
-  validate as aD,
-  calcUtils as aE,
-  uuid2 as aF,
-  normalizeToArray as aG,
-  safeParseArray as aH,
-  BpmnNodeTypeEnum as aI,
-  mergeByMultiKey as aJ,
-  getSubTableQuickFillInfo as aK,
-  BpmnSignatureTypeEnum as aL,
-  ButtonTypeEnum as aM,
-  CHECK_TABLE_MEDPRO_PROTOCOL_KEY as aN,
-  CodeRunner as aO,
-  Config_Fields as aP,
-  ControlStatusEnum as aQ,
-  EBR_PROVIDE_ENUM as aR,
-  FieldSysVarDefaultValueEnum as aS,
-  MobileFillTypeEnum as aT,
-  OfficeTypeEnum as aU,
-  PosEnum as aV,
-  SummaryApproveHisTypeEnum as aW,
-  applyCheckDsDataToRuntime as aX,
-  applyMedProCheckDsDataToRuntime as aY,
-  deleteSubtableRow as aZ,
-  fetchCheckDsDataForTable as a_,
+  settleAndValidateDisplay as aA,
+  unregisterValidationContext as aB,
+  clearFormRules as aC,
+  registerValidationContext as aD,
+  requestFullValidation as aE,
+  requestDisplayValidation as aF,
+  closeValidatorPopovers as aG,
+  baseDataUtils as aH,
+  getRawFormRuleMeta as aI,
+  enrichFormChangeRowDetails as aJ,
+  settleAfterModeSwitch as aK,
+  calcUtils as aL,
+  uuid2 as aM,
+  normalizeToArray as aN,
+  safeParseArray as aO,
+  BpmnNodeTypeEnum as aP,
+  mergeByMultiKey as aQ,
+  getRowId as aR,
+  getSubTableQuickFillInfo as aS,
+  BpmnSignatureTypeEnum as aT,
+  ButtonTypeEnum as aU,
+  CHECK_TABLE_MEDPRO_PROTOCOL_KEY as aV,
+  CodeRunner as aW,
+  Config_Fields as aX,
+  ControlStatusEnum as aY,
+  EBR_PROVIDE_ENUM as aZ,
+  FieldSysVarDefaultValueEnum as a_,
   sqlUtils as aa,
   useWidgetStaticAttrs as ab,
   setSelectValidatorId as ac,
   setSelectAnnotationId as ad,
-  useCurrentPageFormState as ae,
-  useNocodeFormWidget as af,
-  RangeValidateMode as ag,
-  renderUtils as ah,
-  DateFormat as ai,
-  BindCmpStyleEnum as aj,
-  DecimalDisplayMode as ak,
-  NCB_PROVIDE as al,
-  normalizeRefLoaderResult as am,
-  refUtils as an,
-  getParseRuleInfo as ao,
-  getParseRuleValue as ap,
+  useNocodeFormWidget as ae,
+  DateFormat as af,
+  renderUtils as ag,
+  BindCmpStyleEnum as ah,
+  DecimalDisplayMode as ai,
+  NCB_PROVIDE as aj,
+  normalizeRefLoaderResult as ak,
+  refUtils as al,
+  getParseRuleInfo as am,
+  getParseRuleValue as an,
+  useCurrentPageFormState as ao,
+  RangeValidateMode as ap,
   RenderModeEnum as aq,
-  useValidator as ar,
-  EFieldBizTypeEnum as as,
-  FormulaRuleFieldKeyEnum as at,
-  formulaRuleFieldDict as au,
-  useNocodeEmitter as av,
-  fetchHistoryConsume as aw,
-  isBomGranted as ax,
-  calcFillData as ay,
-  extractKeywordFromQueryData as az,
+  EFieldBizTypeEnum as ar,
+  FormulaRuleFieldKeyEnum as as,
+  formulaRuleFieldDict as at,
+  useNocodeEmitter as au,
+  fetchHistoryConsume as av,
+  isBomGranted as aw,
+  calcFillData as ax,
+  extractKeywordFromQueryData as ay,
+  transformUtils as az,
   PageSizeEnum as b,
-  ViewportStore as b$,
-  fetchMedProCheckDsData as b0,
-  getParseRuleConfig as b1,
-  handleOldConfig as b2,
-  isMedProSuite as b3,
-  jsonSchemaUtils as b4,
-  requestNonMedProCheckDsData as b5,
-  setSelectMobileTdId as b6,
-  stockCheck as b7,
-  materialCheck as b8,
-  judgeUnique as b9,
-  FilterPlugin as bA,
-  ExportFilePlugin as bB,
-  SortingPlugin as bC,
-  ColumnMovePlugin as bD,
-  ThemeService as bE,
-  h as bF,
-  Host as bG,
-  getElement as bH,
-  BasePlugin as bI,
-  reduce as bJ,
-  columnTypes as bK,
-  debounce$1 as bL,
-  RESIZE_INTERVAL as bM,
-  DimensionStore as bN,
-  gatherTrimmedItems as bO,
-  getColumnSizes as bP,
-  getItemByIndex as bQ,
-  DataStore as bR,
-  getSourceItem as bS,
-  getSourceItemVirtualIndexByProp as bT,
-  getColumnType as bU,
-  setSourceByPhysicalIndex as bV,
-  setSourceByVirtualIndex as bW,
-  SelectionStore as bX,
-  cropCellToMax as bY,
-  nextCell as bZ,
-  isRowType as b_,
-  getRowId as ba,
-  q as bb,
-  getAugmentedNamespace as bc,
-  CardControlEnum as bd,
-  EntityModelTypeEnum as be,
-  FIELD_TYPE_BASIC as bf,
-  FIELD_TYPE_INSPECTION as bg,
-  FIELD_TYPE_LOGIC as bh,
-  FIELD_TYPE_MATERIAL as bi,
-  FIELD_TYPE_PRETREATMENT as bj,
-  FIELD_TYPE_PRODUCE as bk,
-  FIELD_TYPE_STERILIZATION as bl,
-  FormDesignEnum as bm,
-  RecordNoGenerateEnum as bn,
-  TagTypeEnum as bo,
-  registerInstance as bp,
-  createEvent as bq,
-  getColumnByProp as br,
-  timeout as bs,
-  getVisibleSourceItem as bt,
-  getColumns as bu,
-  rowTypes as bv,
-  GroupingRowPlugin as bw,
-  StretchColumn as bx,
-  isStretchPlugin as by,
-  AutoSizeColumnPlugin as bz,
+  getColumns as b$,
+  OfficeTypeEnum as b0,
+  PosEnum as b1,
+  RangeCompareOp as b2,
+  SummaryApproveHisTypeEnum as b3,
+  applyCheckDsDataToRuntime as b4,
+  applyMedProCheckDsDataToRuntime as b5,
+  buildFormChangeDisplayRows as b6,
+  buildStableFieldLocation as b7,
+  collectFormChangeFieldLocations as b8,
+  deleteSubtableRow as b9,
+  setFormRule as bA,
+  isReferenceOptionActive as bB,
+  validateAllFields as bC,
+  runValidation as bD,
+  stockCheck as bE,
+  materialCheck as bF,
+  judgeUnique as bG,
+  FRONT_ROW_KEY as bH,
+  q as bI,
+  getAugmentedNamespace as bJ,
+  CardControlEnum as bK,
+  EntityModelTypeEnum as bL,
+  FIELD_TYPE_BASIC as bM,
+  FIELD_TYPE_INSPECTION as bN,
+  FIELD_TYPE_LOGIC as bO,
+  FIELD_TYPE_MATERIAL as bP,
+  FIELD_TYPE_PRETREATMENT as bQ,
+  FIELD_TYPE_PRODUCE as bR,
+  FIELD_TYPE_STERILIZATION as bS,
+  FormDesignEnum as bT,
+  RecordNoGenerateEnum as bU,
+  TagTypeEnum as bV,
+  registerInstance as bW,
+  createEvent as bX,
+  getColumnByProp as bY,
+  timeout as bZ,
+  getVisibleSourceItem as b_,
+  detailsHaveFormChangeRowOps as ba,
+  extractFormChangeRowDetails as bb,
+  fetchCheckDsDataForTable as bc,
+  fetchCustomCheckDsData as bd,
+  fetchMedProCheckDsData as be,
+  getFormChangeRowKey as bf,
+  getFormChangeRowOp as bg,
+  getParseRuleConfig as bh,
+  handleOldConfig as bi,
+  insertSubtableRows as bj,
+  isAnnLocationSelected as bk,
+  isFormChangeGhostRow as bl,
+  isMedProSuite as bm,
+  isRowAddedInCurrentFormChange as bn,
+  jsonSchemaUtils as bo,
+  nextFormChangeRowViewHistoryId as bp,
+  recordSubtableRowAdd as bq,
+  recordSubtableRowDelete as br,
+  relocateDeletedRowsToEnd as bs,
+  requestNonMedProCheckDsData as bt,
+  resolveAnnotationFieldLocation as bu,
+  resolveFormChangeRowUi as bv,
+  resolveRowFormChangeMark as bw,
+  setSelectMobileTdId as bx,
+  assembleRules as by,
+  deleteFormRule as bz,
   FIELD_TYPE_TRACE as c,
-  AndOrButton as c0,
-  ReorderButton as c1,
-  TrashButton as c2,
-  isFilterBtn as c3,
-  ColumnService as c4,
-  MOBILE_CLASS as c5,
-  SELECTION_BORDER_CLASS as c6,
-  getCellData as c7,
-  getCellEditor as c8,
-  getRange as c9,
-  DRAGGABLE_CLASS as cA,
-  getCellDataParsed as cB,
-  GROUP_EXPAND_EVENT as cC,
-  isGrouping as cD,
-  HEADER_ROW_CLASS as cE,
-  HEADER_ACTUAL_ROW_CLASS as cF,
-  ROW_FOCUSED_CLASS as cG,
-  HEADER_SORTABLE_CLASS as cH,
-  MIN_COL_SIZE as cI,
-  FilterButton as cJ,
-  HeaderCellRenderer as cK,
-  HEADER_CLASS as cL,
-  isRangeSingleCell as ca,
-  codesLetter as cb,
-  calculateRowHeaderSize as cc,
-  ROW_HEADER_TYPE as cd,
-  getScrollbarSize as ce,
-  FOCUS_CLASS as cf,
-  CELL_HANDLER_CLASS as cg,
-  TMP_SELECTION_BG_CLASS as ch,
-  getItemByPosition as ci,
-  EDIT_INPUT_WR as cj,
-  keyValues as ck,
-  isObject as cl,
-  DRAGG_TEXT as cm,
-  PSEUDO_GROUP_ITEM as cn,
-  GROUP_EXPANDED as co,
-  GROUP_DEPTH as cp,
-  GROUP_EXPAND_BTN as cq,
-  DATA_ROW as cr,
-  isGroupingColumn as cs,
-  GROUP_COLUMN_PROP as ct,
-  getCellRaw as cu,
-  DATA_COL as cv,
-  CELL_CLASS as cw,
-  Build as cx,
-  isRowDragService as cy,
-  DRAG_ICON_CLASS as cz,
+  getCellRaw as c$,
+  rowTypes as c0,
+  GroupingRowPlugin as c1,
+  StretchColumn as c2,
+  isStretchPlugin as c3,
+  AutoSizeColumnPlugin as c4,
+  FilterPlugin as c5,
+  ExportFilePlugin as c6,
+  SortingPlugin as c7,
+  ColumnMovePlugin as c8,
+  ThemeService as c9,
+  isFilterBtn as cA,
+  ColumnService as cB,
+  MOBILE_CLASS as cC,
+  SELECTION_BORDER_CLASS as cD,
+  getCellData as cE,
+  getCellEditor as cF,
+  getRange as cG,
+  isRangeSingleCell as cH,
+  codesLetter as cI,
+  calculateRowHeaderSize as cJ,
+  ROW_HEADER_TYPE as cK,
+  getScrollbarSize as cL,
+  FOCUS_CLASS as cM,
+  CELL_HANDLER_CLASS as cN,
+  TMP_SELECTION_BG_CLASS as cO,
+  getItemByPosition as cP,
+  EDIT_INPUT_WR as cQ,
+  keyValues as cR,
+  isObject as cS,
+  DRAGG_TEXT as cT,
+  PSEUDO_GROUP_ITEM as cU,
+  GROUP_EXPANDED as cV,
+  GROUP_DEPTH as cW,
+  GROUP_EXPAND_BTN as cX,
+  DATA_ROW as cY,
+  isGroupingColumn as cZ,
+  GROUP_COLUMN_PROP as c_,
+  h as ca,
+  Host as cb,
+  getElement as cc,
+  BasePlugin as cd,
+  reduce as ce,
+  columnTypes as cf,
+  debounce$1 as cg,
+  RESIZE_INTERVAL as ch,
+  DimensionStore as ci,
+  gatherTrimmedItems as cj,
+  getColumnSizes as ck,
+  getItemByIndex as cl,
+  DataStore as cm,
+  getSourceItem as cn,
+  getSourceItemVirtualIndexByProp as co,
+  getColumnType as cp,
+  setSourceByPhysicalIndex as cq,
+  setSourceByVirtualIndex as cr,
+  SelectionStore as cs,
+  cropCellToMax as ct,
+  nextCell as cu,
+  isRowType as cv,
+  ViewportStore as cw,
+  AndOrButton as cx,
+  ReorderButton as cy,
+  TrashButton as cz,
   FIELD_TYPE_BUSINESS as d,
+  DATA_COL as d0,
+  CELL_CLASS as d1,
+  Build as d2,
+  isRowDragService as d3,
+  DRAG_ICON_CLASS as d4,
+  DRAGGABLE_CLASS as d5,
+  getCellDataParsed as d6,
+  GROUP_EXPAND_EVENT as d7,
+  isGrouping as d8,
+  HEADER_ROW_CLASS as d9,
+  HEADER_ACTUAL_ROW_CLASS as da,
+  ROW_FOCUSED_CLASS as db,
+  HEADER_SORTABLE_CLASS as dc,
+  MIN_COL_SIZE as dd,
+  FilterButton as de,
+  HeaderCellRenderer as df,
+  HEADER_CLASS as dg,
   ComponentTypeEnum as e,
   estraverse as f,
   SubTableType as g,