@nocobase/client-v2 2.2.0-beta.3 → 2.2.0-beta.6

package/src/flow/models/blocks/form/value-runtime/runtime.ts

@@ -44,6 +44,7 @@ export class FormValueRuntime {
 
   private readonly valuesMirror = observable({});
   private readonly explicitSet = new Set<string>();
+  private readonly userEditedSet = new Set<string>();
   private readonly lastDefaultValueByPathKey = new Map<string, any>();
   private readonly lastWriteMetaByPathKey = new Map<string, FormValueWriteMeta>();
   private readonly observableBindings = new Map<string, ObservableBinding>();
@@ -59,6 +60,8 @@ export class FormValueRuntime {
   private lastObservedToken = 0;
 
   private readonly formValuesProxy: any;
+  private readonly mountedFieldModelsByPathKey = new Map<string, Set<FlowModel>>();
+  private readonly mountedFieldModelPathKeys = new WeakMap<FlowModel, Set<string>>();
 
   private mountedListener?: (payload: { model: FlowModel }) => void;
   private unmountedListener?: (payload: { model: FlowModel }) => void;
@@ -99,6 +102,7 @@ export class FormValueRuntime {
       getFormValueAtPath: (namePath) => this.getFormValueAtPath(namePath),
       setFormValues: (callerCtx, patch, ruleOptions) => this.setFormValues(callerCtx, patch, ruleOptions),
       findExplicitHit: (pathKey) => this.findExplicitHit(pathKey),
+      findUserEditedHit: (pathKey) => this.findUserEditedHit(pathKey),
       lastDefaultValueByPathKey: this.lastDefaultValueByPathKey,
       lastWriteMetaByPathKey: this.lastWriteMetaByPathKey,
       observableBindings: this.observableBindings,
@@ -117,6 +121,7 @@ export class FormValueRuntime {
    *
    * - mode=default → source=default（遵循 explicit/空值覆盖语义）
    * - mode=assign  → source=system（不受 explicit 影响，依赖变化时持续生效）
+   * - mode=override → source=override（首次覆盖已有值，用户修改后停止）
    */
   syncAssignRules(items: FormAssignRuleItem[]) {
     this.ruleEngine.syncAssignRules(items);
@@ -137,6 +142,15 @@ export class FormValueRuntime {
     return this.getForm().getFieldsValue(true);
   }
 
+  private toMirrorSnapshot(value: any) {
+    const raw = isObservable(value) ? toJS(value) : value;
+    return _.cloneDeepWith(raw, (item) => {
+      if (!item || typeof item !== 'object') return undefined;
+      if (Array.isArray(item) || _.isPlainObject(item)) return undefined;
+      return item;
+    });
+  }
+
   canApplyDefaultValuePatch(namePath: NamePath, resolved: any) {
     if (!namePath?.length) return false;
     if (typeof resolved === 'undefined') return false;
@@ -153,19 +167,24 @@ export class FormValueRuntime {
 
     const canOverwrite = isEmptyValue(current) || currentEqualsLastDefault;
     if (!canOverwrite && _.isEqual(current, nextSnapshot)) {
-      this.lastDefaultValueByPathKey.set(pathKey, nextSnapshot);
+      this.lastDefaultValueByPathKey.set(pathKey, this.toMirrorSnapshot(nextSnapshot));
       return false;
     }
 
     return canOverwrite;
   }
 
+  canApplyOverrideValuePatch(namePath: NamePath) {
+    if (!namePath?.length) return false;
+    return !this.findUserEditedHit(namePathToPathKey(namePath));
+  }
+
   recordDefaultValuePatch(namePath: NamePath, value?: any) {
     if (!namePath?.length) return;
     const pathKey = namePathToPathKey(namePath);
     const snapshot =
       arguments.length >= 2 ? (isObservable(value) ? toJS(value) : value) : this.getFormValueAtPath(namePath);
-    this.lastDefaultValueByPathKey.set(pathKey, snapshot);
+    this.lastDefaultValueByPathKey.set(pathKey, this.toMirrorSnapshot(snapshot));
     const current = this.getFormValueAtPath(namePath);
     const currentSnapshot = isObservable(current) ? toJS(current) : current;
     if (_.isEqual(currentSnapshot, snapshot)) {
@@ -195,9 +214,11 @@ export class FormValueRuntime {
 
     if (!this.mountedListener && !this.unmountedListener) {
       this.mountedListener = ({ model }: { model: FlowModel }) => {
+        this.indexMountedFieldModelTree(model);
         this.ruleEngine.onModelMounted(model);
       };
       this.unmountedListener = ({ model }: { model: FlowModel }) => {
+        this.unindexMountedFieldModelTree(model);
         this.ruleEngine.onModelUnmounted(model);
       };
 
@@ -205,10 +226,12 @@ export class FormValueRuntime {
       engineEmitter.on('model:unmounted', this.unmountedListener);
     }
 
+    this.rebuildMountedFieldModelIndex();
+
     if (options?.sync) {
       const snapshot = this.getFormValuesSnapshot();
       if (snapshot && typeof snapshot === 'object') {
-        _.merge(this.valuesMirror, snapshot);
+        _.merge(this.valuesMirror, this.toMirrorSnapshot(snapshot));
         this.bumpChangeTick();
       }
       this.ruleEngine.enable();
@@ -228,6 +251,7 @@ export class FormValueRuntime {
     }
 
     this.ruleEngine.dispose();
+    this.mountedFieldModelsByPathKey.clear();
 
     for (const binding of this.observableBindings.values()) {
       binding.dispose();
@@ -241,6 +265,7 @@ export class FormValueRuntime {
     if (this.disposed) return;
 
     this.explicitSet.clear();
+    this.userEditedSet.clear();
     this.lastDefaultValueByPathKey.clear();
     this.lastWriteMetaByPathKey.clear();
     this.txWriteCounts.clear();
@@ -258,7 +283,7 @@ export class FormValueRuntime {
       delete (this.valuesMirror as Record<string, any>)[key];
     }
     if (snapshot && typeof snapshot === 'object') {
-      _.merge(this.valuesMirror, snapshot);
+      _.merge(this.valuesMirror, this.toMirrorSnapshot(snapshot));
     }
 
     this.writeSeq += 1;
@@ -266,6 +291,13 @@ export class FormValueRuntime {
     this.ruleEngine.rescheduleAllRules();
   }
 
+  resetUserEditedState() {
+    if (this.disposed) return;
+
+    this.userEditedSet.clear();
+    this.ruleEngine.rescheduleAllRules();
+  }
+
   isSuppressed() {
     return this.suppressFormCallbackDepth > 0;
   }
@@ -292,7 +324,7 @@ export class FormValueRuntime {
         this.writeSeq += 1;
         bumpedWriteSeq = true;
       }
-      _.set(this.valuesMirror, namePath, nextValue);
+      _.set(this.valuesMirror, namePath, this.toMirrorSnapshot(nextValue));
       changedPaths.push(namePath);
       const isMeaningfulTouched =
         field?.touched === true && !this.shouldIgnoreSyntheticTouchedInit(namePath, prevValue, nextValue);
@@ -311,6 +343,7 @@ export class FormValueRuntime {
     if (!suppressed && touchedChangedPathKeys.size) {
       for (const key of touchedChangedPathKeys) {
         this.markExplicit(key);
+        this.markUserEdited(key);
       }
     }
 
@@ -374,6 +407,11 @@ export class FormValueRuntime {
       this.explicitSet.delete(key);
     }
 
+    for (const key of Array.from(this.userEditedSet)) {
+      if (!this.isDeletedArrayItemPath(key, snapshot)) continue;
+      this.userEditedSet.delete(key);
+    }
+
     for (const key of Array.from(this.lastDefaultValueByPathKey.keys())) {
       if (!this.isDeletedArrayItemPath(key, snapshot)) continue;
       this.lastDefaultValueByPathKey.delete(key);
@@ -444,6 +482,7 @@ export class FormValueRuntime {
       if (!nextIndexByIdentity.size) continue;
 
       this.reconcileArrayItemSet(this.explicitSet, path, prevValue, nextIndexByIdentity);
+      this.reconcileArrayItemSet(this.userEditedSet, path, prevValue, nextIndexByIdentity);
       this.reconcileArrayItemMap(this.lastDefaultValueByPathKey, path, prevValue, nextIndexByIdentity);
       this.reconcileArrayItemMap(this.lastWriteMetaByPathKey, path, prevValue, nextIndexByIdentity);
       this.reconcileObservableBindings(path, prevValue, nextIndexByIdentity);
@@ -647,7 +686,7 @@ export class FormValueRuntime {
         this.writeSeq += 1;
         bumpedWriteSeq = true;
       }
-      _.set(this.valuesMirror, p, nextValue);
+      _.set(this.valuesMirror, p, this.toMirrorSnapshot(nextValue));
       hasMirrorChange = true;
       actuallyChangedPaths.push(p);
     }
@@ -665,7 +704,11 @@ export class FormValueRuntime {
 
     // 非 default 来源写入：需要使默认值永久失效（explicit）
     for (const p of explicitPathsToMark) {
-      this.markExplicit(namePathToPathKey(p));
+      const pathKey = namePathToPathKey(p);
+      this.markExplicit(pathKey);
+      if (source === 'user') {
+        this.markUserEdited(pathKey);
+      }
     }
 
     if (hasMirrorChange) {
@@ -726,6 +769,9 @@ export class FormValueRuntime {
             seen,
           );
         }
+        if (prevValue.length !== nextValue.length) {
+          return nestedCount + (this.pushExplicitPath(basePath, explicitPaths, seen) ? 1 : 0);
+        }
         return nestedCount;
       }
 
@@ -870,7 +916,8 @@ export class FormValueRuntime {
             } else {
               form.setFieldsValue?.({ [pathKey]: value });
             }
-            _.set(this.valuesMirror, [pathKey], value);
+            _.set(this.valuesMirror, [pathKey], this.toMirrorSnapshot(value));
+            this.syncMountedFieldModelValue([pathKey], value);
           }
           this.bumpChangeTick();
         } finally {
@@ -885,6 +932,9 @@ export class FormValueRuntime {
         if (markExplicit) {
           for (const k of patchKeys) {
             this.markExplicit(k);
+            if (source === 'user') {
+              this.markUserEdited(k);
+            }
           }
         }
 
@@ -969,7 +1019,8 @@ export class FormValueRuntime {
       try {
         for (const { namePath, value } of filteredToWrite) {
           form.setFieldValue?.(namePath, value);
-          _.set(this.valuesMirror, namePath, value);
+          _.set(this.valuesMirror, namePath, this.toMirrorSnapshot(value));
+          this.syncMountedFieldModelValue(namePath, value);
           changedPaths.push(namePath);
         }
         this.bumpChangeTick();
@@ -984,13 +1035,16 @@ export class FormValueRuntime {
       if (markExplicit) {
         for (const { pathKey } of filteredToWrite) {
           this.markExplicit(pathKey);
+          if (source === 'user') {
+            this.markUserEdited(pathKey);
+          }
         }
       }
 
       if (source === 'default') {
         for (const { namePath, pathKey } of filteredToWrite) {
           const current = this.getFormValueAtPath(namePath);
-          this.lastDefaultValueByPathKey.set(pathKey, current);
+          this.lastDefaultValueByPathKey.set(pathKey, this.toMirrorSnapshot(current));
         }
       }
 
@@ -1052,6 +1106,7 @@ export class FormValueRuntime {
     if (this.disposed) return;
     const form = this.getForm?.();
     if (!form) return;
+    if (source === 'override' && this.findUserEditedHit(pathKey)) return;
 
     const prevValue = _.get(this.valuesMirror, namePath);
     if (_.isEqual(prevValue, nextValue)) return;
@@ -1062,7 +1117,8 @@ export class FormValueRuntime {
     this.suppressFormCallbackDepth++;
     try {
       form.setFieldValue?.(namePath, nextValue);
-      _.set(this.valuesMirror, namePath, nextValue);
+      _.set(this.valuesMirror, namePath, this.toMirrorSnapshot(nextValue));
+      this.syncMountedFieldModelValue(namePath, nextValue);
       this.bumpChangeTick();
     } finally {
       this.suppressFormCallbackDepth--;
@@ -1098,7 +1154,10 @@ export class FormValueRuntime {
     }
     this.emitFormValuesChange(payload);
 
-    if (source === 'default' && this.isExplicit(pathKey)) {
+    if (
+      (source === 'default' && this.isExplicit(pathKey)) ||
+      (source === 'override' && this.findUserEditedHit(pathKey))
+    ) {
       const existing = this.observableBindings.get(pathKey);
       if (existing) {
         existing.dispose();
@@ -1107,7 +1166,7 @@ export class FormValueRuntime {
     }
 
     if (source === 'default') {
-      this.lastDefaultValueByPathKey.set(pathKey, this.getFormValueAtPath(namePath));
+      this.lastDefaultValueByPathKey.set(pathKey, this.toMirrorSnapshot(this.getFormValueAtPath(namePath)));
     }
   }
 
@@ -1133,6 +1192,148 @@ export class FormValueRuntime {
     this.model.emitter?.emit?.('formValuesChange', payload);
   }
 
+  private syncMountedFieldModelValue(namePath: NamePath, value: unknown) {
+    const targetKey = namePathToPathKey(namePath);
+    if (!targetKey) return;
+
+    const models = this.mountedFieldModelsByPathKey.get(targetKey);
+    if (!models?.size) return;
+
+    const visited = new Set<FlowModel>();
+    for (const model of Array.from(models)) {
+      this.syncMountedFieldModelValueForModel(model, value, visited);
+    }
+  }
+
+  private syncMountedFieldModelValueForModel(
+    model: FlowModel | null | undefined,
+    value: unknown,
+    visited: Set<FlowModel>,
+  ) {
+    if (!model || visited.has(model)) return;
+    visited.add(model);
+    if (!this.isMountedModelInThisForm(model)) return;
+
+    const nextProps = { value };
+    model.setProps?.(nextProps);
+    const fieldModel = (model as FlowModel & { subModels?: { field?: FlowModel } }).subModels?.field;
+    fieldModel?.setProps?.(nextProps);
+  }
+
+  private rebuildMountedFieldModelIndex() {
+    this.mountedFieldModelsByPathKey.clear();
+    const engine = this.model?.context?.engine;
+    if (!engine || typeof engine.forEachModel !== 'function') return;
+
+    engine.forEachModel((model: FlowModel) => {
+      this.indexMountedFieldModelTree(model);
+    });
+  }
+
+  private indexMountedFieldModelTree(model: FlowModel | null | undefined) {
+    this.visitModelAndForks(model, (item) => this.indexMountedFieldModel(item));
+  }
+
+  private unindexMountedFieldModelTree(model: FlowModel | null | undefined) {
+    this.visitModelAndForks(model, (item) => this.unindexMountedFieldModel(item));
+  }
+
+  private visitModelAndForks(model: FlowModel | null | undefined, visit: (model: FlowModel) => void) {
+    if (!model) return;
+    const visited = new Set<FlowModel>();
+    const walk = (item: FlowModel | null | undefined) => {
+      if (!item || visited.has(item)) return;
+      visited.add(item);
+      visit(item);
+      const forks = (item as FlowModel & { forks?: { forEach?: (cb: (fork: FlowModel) => void) => void } }).forks;
+      forks?.forEach?.((fork) => walk(fork));
+    };
+    walk(model);
+  }
+
+  private indexMountedFieldModel(model: FlowModel) {
+    if (!this.isMountedModelInThisForm(model)) return;
+
+    const pathKeys = new Set<string>();
+    for (const path of this.getMountedModelNamePaths(model)) {
+      const key = namePathToPathKey(path);
+      if (key) pathKeys.add(key);
+    }
+    if (!pathKeys.size) return;
+
+    this.unindexMountedFieldModel(model);
+    this.mountedFieldModelPathKeys.set(model, pathKeys);
+
+    for (const key of pathKeys) {
+      const models = this.mountedFieldModelsByPathKey.get(key) || new Set<FlowModel>();
+      models.add(model);
+      this.mountedFieldModelsByPathKey.set(key, models);
+    }
+  }
+
+  private unindexMountedFieldModel(model: FlowModel) {
+    const pathKeys = this.mountedFieldModelPathKeys.get(model);
+    if (!pathKeys) return;
+
+    for (const key of pathKeys) {
+      const models = this.mountedFieldModelsByPathKey.get(key);
+      if (!models) continue;
+      models.delete(model);
+      if (!models.size) {
+        this.mountedFieldModelsByPathKey.delete(key);
+      }
+    }
+
+    this.mountedFieldModelPathKeys.delete(model);
+  }
+
+  private isMountedModelInThisForm(model: FlowModel) {
+    const blockModel = (model.context as { blockModel?: FlowModel } | undefined)?.blockModel;
+    return !!blockModel && String(blockModel.uid) === String(this.model.uid);
+  }
+
+  private getMountedModelNamePaths(model: FlowModel): NamePath[] {
+    const paths: NamePath[] = [];
+    const push = (value: unknown) => {
+      const path = this.normalizeNamePathValue(value);
+      if (path?.length) paths.push(path);
+    };
+
+    push((model.context as { fieldPathArray?: unknown } | undefined)?.fieldPathArray);
+
+    const props = typeof model.getProps === 'function' ? model.getProps() : (model as { props?: unknown }).props;
+    if (props && typeof props === 'object') {
+      push((props as { name?: unknown }).name);
+    }
+
+    try {
+      const init = model.getStepParams?.('fieldSettings', 'init');
+      if (init && typeof init === 'object') {
+        push((init as { fieldPath?: unknown }).fieldPath);
+      }
+    } catch {
+      // ignore models without field settings
+    }
+
+    const seen = new Set<string>();
+    return paths.filter((path) => {
+      const key = namePathToPathKey(path);
+      if (!key || seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
+  private normalizeNamePathValue(value: unknown): NamePath | null {
+    if (Array.isArray(value)) {
+      const path = value.filter((seg): seg is string | number => typeof seg === 'string' || typeof seg === 'number');
+      return path.length === value.length ? path : null;
+    }
+    if (typeof value === 'number') return [value];
+    if (typeof value === 'string' && value) return pathKeyToNamePath(value);
+    return null;
+  }
+
   private markExplicit(pathKey: string) {
     if (this.explicitSet.has(pathKey)) return;
     this.explicitSet.add(pathKey);
@@ -1154,6 +1355,18 @@ export class FormValueRuntime {
     }
   }
 
+  private markUserEdited(pathKey: string) {
+    if (this.userEditedSet.has(pathKey)) return;
+    this.userEditedSet.add(pathKey);
+
+    for (const [k, binding] of Array.from(this.observableBindings.entries())) {
+      if (binding.source !== 'override') continue;
+      if (!this.findUserEditedHit(k)) continue;
+      binding.dispose();
+      this.observableBindings.delete(k);
+    }
+  }
+
   private normalizeObservedNamePath(name: NamePath | string | number | undefined): NamePath | null {
     if (Array.isArray(name)) return name as NamePath;
     if (typeof name === 'number') return [name];
@@ -1216,4 +1429,35 @@ export class FormValueRuntime {
     }
     return null;
   }
+
+  private findUserEditedHit(pathKey: string): string | null {
+    if (this.userEditedSet.has(pathKey)) return pathKey;
+    const namePath = pathKeyToNamePath(pathKey);
+    const prefix: NamePath = [];
+
+    for (let i = 0; i < namePath.length; i++) {
+      prefix.push(namePath[i]);
+      const key = namePathToPathKey(prefix as any);
+      if (!this.userEditedSet.has(key)) continue;
+
+      const nextSeg = namePath[i + 1];
+      if (typeof nextSeg === 'number') {
+        continue;
+      }
+      return key;
+    }
+    for (const key of this.userEditedSet) {
+      if (!this.isDescendantPathKey(key, pathKey)) continue;
+      return key;
+    }
+    return null;
+  }
+
+  private isDescendantPathKey(candidateKey: string, parentKey: string) {
+    if (!candidateKey || !parentKey || candidateKey === parentKey) return false;
+    const candidatePath = pathKeyToNamePath(candidateKey);
+    const parentPath = pathKeyToNamePath(parentKey);
+    if (candidatePath.length <= parentPath.length) return false;
+    return parentPath.every((seg, index) => candidatePath[index] === seg);
+  }
 }

package/src/flow/models/blocks/form/value-runtime/types.ts

@@ -9,7 +9,7 @@
 
 export type NamePath = Array<string | number>;
 
-export type ValueSource = 'default' | 'linkage' | 'user' | 'system';
+export type ValueSource = 'default' | 'linkage' | 'user' | 'system' | 'override';
 
 export type Patch =
   | Record<string, any>
@@ -57,7 +57,7 @@ export interface FormValuesChangePayload {
   allValuesSnapshot?: any;
 }
 
-export type AssignMode = 'default' | 'assign';
+export type AssignMode = 'default' | 'assign' | 'override';
 
 export type FormAssignRuleItem = {
   key?: string;

package/src/flow/models/blocks/js-block/JSBlock.tsx

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { ElementProxy, tExpr, createSafeDocument, createSafeWindow, createSafeNavigator } from '@nocobase/flow-engine';
+import { ElementProxy, tExpr } from '@nocobase/flow-engine';
 import React from 'react';
 import { BlockModel } from '../../base';
 import { BlockItemCard } from '../../../components';
@@ -167,12 +167,7 @@ ctx.render(\`
               },
             },
           });
-          const navigator = createSafeNavigator();
-          await ctx.runjs(
-            code,
-            { window: createSafeWindow({ navigator }), document: createSafeDocument(), navigator },
-            { version },
-          );
+          await ctx.runjs(code, undefined, { version });
         });
       },
     },

package/src/flow/models/blocks/table/JSColumnModel.tsx

@@ -19,9 +19,6 @@ import {
   createRecordMetaFactory,
   createRecordResolveOnServerWithLocal,
   ElementProxy,
-  createSafeDocument,
-  createSafeWindow,
-  createSafeNavigator,
   observer,
 } from '@nocobase/flow-engine';
 import { Tooltip } from 'antd';
@@ -294,12 +291,7 @@ JSColumnModel.registerFlow({
             get: () => new ElementProxy((ctx.ref?.current as HTMLElement | null) || element),
             cache: false,
           });
-          const navigator = createSafeNavigator();
-          await ctx.runjs(
-            code,
-            { window: createSafeWindow({ navigator }), document: createSafeDocument(), navigator },
-            { version },
-          );
+          await ctx.runjs(code, undefined, { version });
         });
       },
     },

package/src/flow/models/blocks/table/TableActionsColumnModel.tsx

@@ -140,7 +140,7 @@ const AddActionToolbarComponent = observer(({ model }: any) => {
       subModelBaseClass={model.context.getModelClassName('RecordActionGroupModel')}
       subModelKey="actions"
       afterSubModelInit={async (actionModel) => {
-        actionModel.setStepParams('buttonSettings', 'general', { type: 'link', icon: null });
+        actionModel.setStepParams('buttonSettings', 'general', { type: 'link', icon: null, iconOnly: false });
       }}
     >
       <PlusOutlined />

package/src/flow/models/blocks/table/TableBlockModel.tsx

@@ -179,11 +179,21 @@ const AddFieldColumn = ({ model }: { model: TableBlockModel }) => {
       ].filter(Boolean)}
       keepDropdownOpen
     >
-      <FlowSettingsButton icon={<SettingOutlined />}>{model.translate('Fields')}</FlowSettingsButton>
+      {renderTableSettingsButton(model, 'Fields')}
     </AddSubModelButton>
   );
 };
 
+function renderTableSettingsButton(model: TableBlockModel, title: string) {
+  const label = model.translate(title);
+
+  return (
+    <FlowSettingsButton aria-label={label} icon={<SettingOutlined />}>
+      {model.context.isMobileLayout ? null : label}
+    </FlowSettingsButton>
+  );
+}
+
 type CustomTableBlockModelClassesEnum = {
   CollectionActionGroupModel?: string;
   RecordActionGroupModel?: string;
@@ -265,7 +275,7 @@ export class TableBlockModel extends CollectionBlockModel<TableBlockModelStructu
       cols.push({
         key: 'addColumn',
         fixed: 'right',
-        width: 100,
+        ...(this.context.isMobileLayout ? {} : { width: 100 }),
         title: <AddFieldColumn model={this} />,
       } as any);
     }
@@ -508,7 +518,7 @@ export class TableBlockModel extends CollectionBlockModel<TableBlockModelStructu
         subModelBaseClass={this.getModelClassName('CollectionActionGroupModel')}
         subModelKey="actions"
       >
-        <FlowSettingsButton icon={<SettingOutlined />}>{this.translate('Actions')}</FlowSettingsButton>
+        {renderTableSettingsButton(this, 'Actions')}
       </AddSubModelButton>
     );
   }

package/src/flow/models/blocks/table/TableColumnModel.tsx

@@ -35,6 +35,7 @@ import { ErrorBoundary } from 'react-error-boundary';
 import { getRowKey } from './utils';
 import { getSavedAssociationTitleField, getTableColumnSortField } from './sortUtils';
 import { getFieldBindingUse, rebuildFieldSubModel } from '../../../internal/utils/rebuildFieldSubModel';
+import { getSavedDateTimeFormatParams, resolveDateTimeDisplayProps } from '../../../utils/dateTimeDisplayProps';
 
 export function FieldDeletePlaceholder(props: any) {
   const { t } = useTranslation();
@@ -128,6 +129,15 @@ export const CustomWidth = ({ setOpen, t, handleChange, defaultValue }) => {
   );
 };
 
+const resetDateTimeDisplayProps = {
+  dateOnly: undefined,
+  dateFormat: undefined,
+  format: undefined,
+  picker: undefined,
+  showTime: undefined,
+  timeFormat: undefined,
+};
+
 export class TableColumnModel extends DisplayItemModel {
   // 标记：该类的 render 返回函数， 避免错误的reactive封装
   static renderMode: ModelRenderMode = ModelRenderMode.RenderFunction;
@@ -353,11 +363,22 @@ TableColumnModel.registerFlow({
           return;
         }
         const titleField = getSavedAssociationTitleField(ctx.model);
+        const fieldModel = Array.isArray(ctx.model.subModels.field) ? undefined : ctx.model.subModels.field;
+        const targetCollectionField = collectionField.targetCollection?.getField?.(titleField);
+        const savedDateTimeDisplayProps = getSavedDateTimeFormatParams(fieldModel)
+          ? resolveDateTimeDisplayProps({
+              model: fieldModel,
+              collectionField,
+              titleField,
+              currentProps: ctx.model.props,
+            })
+          : undefined;
         const componentProps =
           collectionField.isAssociationField() && titleField
             ? {
                 ...collectionField.getComponentProps(),
-                ...collectionField.targetCollection?.getField?.(titleField)?.getComponentProps?.(),
+                ...targetCollectionField?.getComponentProps?.(),
+                ...savedDateTimeDisplayProps,
               }
             : collectionField.getComponentProps();
         ctx.model.setProps('title', collectionField.title);
@@ -539,21 +560,33 @@ TableColumnModel.registerFlow({
           typeof binding?.defaultProps === 'function'
             ? binding.defaultProps(ctx, targetCollectionField)
             : binding?.defaultProps;
+        const componentProps = targetCollectionField.getComponentProps?.() || {};
+        const nextFieldProps = {
+          ...(defaultProps || {}),
+          ...componentProps,
+          titleField: params.label,
+        };
+        const nextColumnProps = {
+          ...resetDateTimeDisplayProps,
+          ...nextFieldProps,
+        };
         if (targetUse && targetUse !== currentUse) {
           await rebuildFieldSubModel({
             parentModel: ctx.model as any,
             targetUse,
-            defaultProps,
+            defaultProps: nextFieldProps,
             fieldSettingsInit,
           });
         } else if (fieldModel) {
+          fieldModel.setProps(nextColumnProps);
           fieldModel.setStepParams('fieldSettings', 'init', fieldSettingsInit);
           await fieldModel.dispatchEvent('beforeRender', undefined, { useCache: false });
+          await fieldModel.save();
         }
         if (targetUse) {
           ctx.model.setStepParams('tableColumnSettings', 'model', { use: targetUse });
         }
-        ctx.model.setProps(targetCollectionField.getComponentProps());
+        ctx.model.setProps(nextColumnProps);
       },
       defaultParams: (ctx: any) => {
         const titleField = ctx.model?.context?.collectionField?.targetCollectionTitleFieldName;