@nocobase/client-v2 2.1.0-beta.26 → 2.1.0-beta.29

package/src/flow/models/blocks/form/FormItemModel.tsx

@@ -22,6 +22,7 @@ import { FieldModel } from '../../base/FieldModel';
 import { DetailsItemModel } from '../details/DetailsItemModel';
 import { EditFormModel } from './EditFormModel';
 import _ from 'lodash';
+import { Tooltip } from 'antd';
 import { coerceForToOneField } from '../../../internal/utils/associationValueCoercion';
 import { buildDynamicNamePath } from './dynamicNamePath';
 
@@ -99,54 +100,63 @@ export class FormItemModel<T extends DefaultStructure = DefaultStructure> extend
 
   renderItem() {
     const fieldModel = this.subModels.field as FieldModel;
-    // 行索引（来自数组子表单）
     const idx = this.context.fieldIndex;
     const fieldKey = this.context.fieldKey;
     const parentFieldPathArray = this.parent?.context.fieldPathArray || [];
+    const isHiddenReservedValuePreview =
+      !!this.context.flowSettingsEnabled && !!this.props.hidden && !this.hidden && !this.forbidden;
 
-    // 嵌套场景下继续传透，为字段子模型创建 fork
     const modelForRender =
-      idx != null
+      idx != null || isHiddenReservedValuePreview
         ? (() => {
-            const fork = fieldModel.createFork({}, `${fieldKey}`);
-            fork.context.defineProperty('fieldIndex', {
-              get: () => idx,
-            });
-            fork.context.defineProperty('fieldKey', {
-              get: () => fieldKey,
-            });
-            if (this.context.currentObject) {
-              fork.context.defineProperty('currentObject', {
-                get: () => this.context.currentObject,
+            const forkKey = isHiddenReservedValuePreview ? `${this.uid}:config-visible` : `${fieldKey}`;
+            const fork = fieldModel.createFork({}, forkKey);
+            if (idx != null) {
+              fork.context.defineProperty('fieldIndex', {
+                get: () => idx,
               });
-            }
-            const itemOptions = this.context.getPropertyOptions('item');
-            if (this.context.item) {
-              const { value: _value, ...rest } = (itemOptions || {}) as any;
-              fork.context.defineProperty('item', {
-                ...rest,
-                get: () => this.context.item,
-                cache: false,
+              fork.context.defineProperty('fieldKey', {
+                get: () => fieldKey,
               });
+              if (this.context.currentObject) {
+                fork.context.defineProperty('currentObject', {
+                  get: () => this.context.currentObject,
+                });
+              }
+              const itemOptions = this.context.getPropertyOptions('item');
+              if (this.context.item) {
+                const { value: _value, ...rest } = (itemOptions || {}) as any;
+                fork.context.defineProperty('item', {
+                  ...rest,
+                  get: () => this.context.item,
+                  cache: false,
+                });
+              }
+              if (this.context.pattern) {
+                fork.context.defineProperty('pattern', {
+                  get: () => this.context.pattern,
+                });
+              }
             }
-            if (this.context.pattern) {
-              fork.context.defineProperty('pattern', {
-                get: () => this.context.pattern,
-              });
+            if (isHiddenReservedValuePreview) {
+              fork.setProps({ hidden: false });
             }
             return fork;
           })()
         : fieldModel;
     const mergedProps = this.context.pattern ? { ...this.props, pattern: this.context.pattern } : this.props;
-    const { initialValue, ...mergedPropsWithoutInitial } = mergedProps as any;
+    const { initialValue, hidden, ...mergedPropsWithoutInitial } = mergedProps as any;
+    const formItemProps = isHiddenReservedValuePreview
+      ? mergedPropsWithoutInitial
+      : { hidden, ...mergedPropsWithoutInitial };
     const fieldPath = buildDynamicNamePath(this.props.name, idx);
     this.context.defineProperty('fieldPathArray', {
       value: [...parentFieldPathArray, ..._.castArray(fieldPath)],
     });
     const record = this.context.item?.value || this.context.record;
-    return (
+    const content = (
       <FormItem
-        {...mergedPropsWithoutInitial}
+        {...formItemProps}
         name={fieldPath}
         validateFirst={true}
         disabled={
@@ -158,6 +168,16 @@ export class FormItemModel<T extends DefaultStructure = DefaultStructure> extend
         <FieldModelRenderer model={modelForRender} name={fieldPath} />
       </FormItem>
     );
+
+    if (isHiddenReservedValuePreview) {
+      return (
+        <Tooltip title={this.context.t('The field is hidden and only visible when the UI Editor is active')}>
+          <div style={{ opacity: 0.3 }}>{content}</div>
+        </Tooltip>
+      );
+    }
+
+    return content;
   }
 }
 

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

@@ -159,12 +159,141 @@ describe('FormValueRuntime (default rules)', () => {
     await runtime.setFormValues(fieldCtx, [{ path: ['b'], value: 'Y' }], { source: 'user' });
     await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('Y'));
 
+    // change dependency again -> default keeps following while target is still the last default
+    await runtime.setFormValues(fieldCtx, [{ path: ['b'], value: 'Z' }], { source: 'user' });
+    await waitFor(() => expect(formStub.getFieldValue(['a'])).toBe('Z'));
+
     // user changes target -> default should be disabled permanently
     await runtime.setFormValues(fieldCtx, [{ path: ['a'], value: 'user' }], { source: 'user' });
-    await runtime.setFormValues(fieldCtx, [{ path: ['b'], value: 'Z' }], { source: 'user' });
+    await runtime.setFormValues(fieldCtx, [{ path: ['b'], value: 'W' }], { source: 'user' });
     expect(formStub.getFieldValue(['a'])).toBe('user');
   });
 
+  it('allows direct default patches to keep following until target is explicitly changed', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ roleUid: 'role-uid-1', roleName: '' });
+
+    const blockModel: any = {
+      uid: 'form-direct-default-patch',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    expect(runtime.canApplyDefaultValuePatch(['roleName'], 'role-uid-1')).toBe(true);
+    await runtime.setFormValues(blockCtx, [{ path: ['roleName'], value: 'role-uid-1' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-1',
+      linkageTxId: 'tx-linkage-1',
+    });
+    runtime.recordDefaultValuePatch(['roleName'], 'role-uid-1');
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleUid'], value: 'role-uid-2' }], { source: 'user' });
+    expect(runtime.canApplyDefaultValuePatch(['roleName'], 'role-uid-2')).toBe(true);
+    await runtime.setFormValues(blockCtx, [{ path: ['roleName'], value: 'role-uid-2' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-2',
+      linkageTxId: 'tx-linkage-2',
+    });
+    runtime.recordDefaultValuePatch(['roleName'], 'role-uid-2');
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleUid'], value: 'role-uid-3' }], { source: 'user' });
+    expect(runtime.canApplyDefaultValuePatch(['roleName'], 'role-uid-3')).toBe(true);
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleName'], value: 'manual' }], { source: 'user' });
+    expect(runtime.canApplyDefaultValuePatch(['roleName'], 'role-uid-4')).toBe(false);
+  });
+
+  it('keeps direct default patches active when an unchanged default value is carried by a row change', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ roles: [{ uid: '1', title: '' }] });
+
+    const blockModel: any = {
+      uid: 'form-direct-default-patch-row',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '1')).toBe(true);
+    await runtime.setFormValues(blockCtx, [{ path: ['roles', 0, 'title'], value: '1' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-row-1',
+      linkageTxId: 'tx-linkage-row-1',
+    });
+    runtime.recordDefaultValuePatch(['roles', 0, 'title'], '1');
+
+    lodashSet((runtime as any).valuesMirror, ['roles', 0, 'title'], undefined);
+    runtime.handleFormFieldsChange([{ name: ['roles', 0, 'title'], touched: true } as any]);
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBeNull();
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '12')).toBe(true);
+
+    (runtime as any).markExplicit('roles');
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBeNull();
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '12')).toBe(true);
+
+    lodashSet((runtime as any).valuesMirror, ['roles', 0, 'title'], undefined);
+
+    lodashSet((formStub as any).__store, ['roles', 0, 'uid'], '12');
+    runtime.handleFormValuesChange({ roles: formStub.getFieldValue(['roles']) }, formStub.getFieldsValue());
+
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBeNull();
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '12')).toBe(true);
+    await runtime.setFormValues(blockCtx, [{ path: ['roles', 0, 'title'], value: '12' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-row-2',
+      linkageTxId: 'tx-linkage-row-2',
+    });
+    runtime.recordDefaultValuePatch(['roles', 0, 'title'], '12');
+    expect(formStub.getFieldValue(['roles', 0, 'title'])).toBe('12');
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roles', 0, 'title'], value: 'manual' }], { source: 'user' });
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '13')).toBe(false);
+  });
+
+  it('does not mark omitted sibling fields from partial top-level changedValues as explicit', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({
+      roles: [{ __is_new__: true, __index__: 'row-1', name: '1', title: '1' }],
+    });
+
+    const blockModel: any = {
+      uid: 'form-direct-default-patch-partial-row',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    runtime.recordDefaultValuePatch(['roles', 0, 'title'], '1');
+
+    lodashSet((formStub as any).__store, ['roles', 0, 'name'], '12');
+    runtime.handleFormValuesChange({ roles: [{ name: '12' }] }, formStub.getFieldsValue());
+
+    expect((runtime as any).findExplicitHit('roles[0].title')).toBeNull();
+    expect(runtime.canApplyDefaultValuePatch(['roles', 0, 'title'], '12')).toBe(true);
+  });
+
   it('handles onFieldsChange name as string and triggers default recompute', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();
@@ -3267,4 +3396,41 @@ describe('FormValueRuntime (form assign rules)', () => {
     expect(payload.txId).toBe('tx-current');
     expect(payload.linkageTxId).toBe('tx-root');
   });
+
+  it('does not mark linkage writes explicit so later user edits can keep following default linkage', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ roleUid: 'role-uid-1', roleName: '' });
+
+    const blockModel: any = {
+      uid: 'form-linkage-linkage-not-explicit',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent: vi.fn(),
+      getAclActionName: () => 'create',
+    };
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as any });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    blockModel.context = blockCtx;
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleName'], value: 'role-uid-1' }], {
+      source: 'linkage',
+      txId: 'tx-linkage-1',
+      linkageTxId: 'tx-linkage-1',
+      linkageScopeDepth: 0,
+    });
+
+    expect(formStub.getFieldValue(['roleName'])).toBe('role-uid-1');
+    expect((runtime as any).findExplicitHit('roleName')).toBeNull();
+
+    await runtime.setFormValues(blockCtx, [{ path: ['roleUid'], value: 'role-uid-2' }], {
+      source: 'user',
+      txId: 'tx-user-1',
+    });
+    expect(formStub.getFieldValue(['roleUid'])).toBe('role-uid-2');
+    expect((runtime as any).findExplicitHit('roleName')).toBeNull();
+  });
 });

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

@@ -137,6 +137,42 @@ export class FormValueRuntime {
     return this.getForm().getFieldsValue(true);
   }
 
+  canApplyDefaultValuePatch(namePath: NamePath, resolved: any) {
+    if (!namePath?.length) return false;
+    if (typeof resolved === 'undefined') return false;
+
+    const pathKey = namePathToPathKey(namePath);
+    const current = this.getFormValueAtPath(namePath);
+    const last = this.lastDefaultValueByPathKey.get(pathKey);
+    const nextSnapshot = isObservable(resolved) ? toJS(resolved) : resolved;
+    const currentSnapshot = isObservable(current) ? toJS(current) : current;
+    const currentEqualsLastDefault = typeof last !== 'undefined' && _.isEqual(currentSnapshot, last);
+    const explicitHit = this.findExplicitHit(pathKey);
+
+    if (explicitHit && !currentEqualsLastDefault) return false;
+
+    const canOverwrite = isEmptyValue(current) || currentEqualsLastDefault;
+    if (!canOverwrite && _.isEqual(current, nextSnapshot)) {
+      this.lastDefaultValueByPathKey.set(pathKey, nextSnapshot);
+      return false;
+    }
+
+    return canOverwrite;
+  }
+
+  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);
+    const current = this.getFormValueAtPath(namePath);
+    const currentSnapshot = isObservable(current) ? toJS(current) : current;
+    if (_.isEqual(currentSnapshot, snapshot)) {
+      this.clearExplicitForDefaultPatch(pathKey);
+    }
+  }
+
   private getFormValueAtPath(namePath: NamePath) {
     const form: any = this.getForm?.();
     if (form && typeof form.getFieldValue === 'function') {
@@ -247,11 +283,7 @@ export class FormValueRuntime {
     let bumpedWriteSeq = false;
     for (const field of changedFields || []) {
       const name = field?.name;
-      const namePath: NamePath | null = Array.isArray(name)
-        ? (name as NamePath)
-        : typeof name === 'string' || typeof name === 'number'
-          ? ([name] as NamePath)
-          : null;
+      const namePath = this.normalizeObservedNamePath(name);
       if (!namePath?.length) continue;
       const nextValue = form.getFieldValue(namePath as any);
       const prevValue = _.get(this.valuesMirror, namePath);
@@ -265,8 +297,11 @@ export class FormValueRuntime {
       const isMeaningfulTouched =
         field?.touched === true && !this.shouldIgnoreSyntheticTouchedInit(namePath, prevValue, nextValue);
       if (isMeaningfulTouched) {
-        touchedChangedPathKeys.add(namePathToPathKey(namePath));
-        hasMeaningfulTouchedChange = true;
+        const pathKey = namePathToPathKey(namePath);
+        if (!this.shouldKeepDefaultPathValueEnabled(namePath, nextValue)) {
+          touchedChangedPathKeys.add(pathKey);
+          hasMeaningfulTouchedChange = true;
+        }
       }
     }
 
@@ -526,6 +561,10 @@ export class FormValueRuntime {
   }
 
   private getObservedChangedValue(path: NamePath, changedValues: any, snapshot: any) {
+    if (_.has(snapshot, path as any)) {
+      return _.get(snapshot, path as any);
+    }
+
     if (path?.length === 1) {
       const key = path[0];
       if (
@@ -546,6 +585,7 @@ export class FormValueRuntime {
 
     let observed = snapshot;
     for (const key of Object.keys(changedValues)) {
+      if (_.has(observed, [key])) continue;
       if (observed === snapshot) {
         observed = Array.isArray(snapshot) ? [...snapshot] : { ...snapshot };
       }
@@ -573,7 +613,15 @@ export class FormValueRuntime {
     this.lastObservedChangedPaths = null;
     this.lastObservedSource = null;
 
-    const rawSnapshot = allValues && typeof allValues === 'object' ? allValues : this.getFormValuesSnapshot();
+    // 子表格的 changedValues 可能只包含局部行对象，diff 必须以 form 当前完整快照为准，
+    // 否则缺失的 sibling 字段会被误判为用户清空。
+    const formSnapshot = this.getFormValuesSnapshot();
+    const rawSnapshot =
+      formSnapshot && typeof formSnapshot === 'object'
+        ? formSnapshot
+        : allValues && typeof allValues === 'object'
+          ? allValues
+          : changedValues;
     const snapshot = this.getObservedSnapshot(changedValues, rawSnapshot);
     this.reconcileArrayItemState([...rawChangedPaths, ...changedValuePaths], changedValues, snapshot);
     this.pruneDeletedArrayItemState(snapshot);
@@ -602,8 +650,16 @@ export class FormValueRuntime {
       this.bumpChangeTick();
     }
 
-    // 非 default 来源写入：需要使默认值永久失效（explicit）
+    const explicitPathsToMark: NamePath[] = [];
     for (const p of explicitPaths) {
+      if (this.shouldKeepDefaultPathEnabled(p, snapshot)) {
+        continue;
+      }
+      explicitPathsToMark.push(p);
+    }
+
+    // 非 default 来源写入：需要使默认值永久失效（explicit）
+    for (const p of explicitPathsToMark) {
       this.markExplicit(namePathToPathKey(p));
     }
 
@@ -733,7 +789,7 @@ export class FormValueRuntime {
     const source: ValueSource = options?.source ?? 'system';
     const triggerEvent = options?.triggerEvent !== false;
     const txId = options?.txId ?? createTxId();
-    const markExplicit = options?.markExplicit ?? source !== 'default';
+    const markExplicit = options?.markExplicit ?? (source !== 'default' && source !== 'linkage');
     const ownsTxId = typeof options?.txId === 'undefined';
 
     const linkageScopeDepth =
@@ -1071,10 +1127,12 @@ export class FormValueRuntime {
   private markExplicit(pathKey: string) {
     if (this.explicitSet.has(pathKey)) return;
     this.explicitSet.add(pathKey);
+    const preserveDescendantDefaults = this.shouldPreserveDescendantDefaultsOnExplicit(pathKey);
 
     // explicit 后默认值永远失效：清理该路径及其子路径的 lastDefault 记录，避免误判“仍是默认值”
     for (const k of Array.from(this.lastDefaultValueByPathKey.keys())) {
-      if (k === pathKey || k.startsWith(`${pathKey}.`) || k.startsWith(`${pathKey}[`)) {
+      const isDescendant = k.startsWith(`${pathKey}.`) || k.startsWith(`${pathKey}[`);
+      if (k === pathKey || (!preserveDescendantDefaults && isDescendant)) {
         this.lastDefaultValueByPathKey.delete(k);
       }
     }
@@ -1087,6 +1145,40 @@ export class FormValueRuntime {
     }
   }
 
+  private normalizeObservedNamePath(name: NamePath | string | number | undefined): NamePath | null {
+    if (Array.isArray(name)) return name as NamePath;
+    if (typeof name === 'number') return [name];
+    if (typeof name !== 'string' || !name) return null;
+    const parsed = pathKeyToNamePath(name);
+    return parsed.length ? parsed : [name];
+  }
+
+  private clearExplicitForDefaultPatch(pathKey: string) {
+    for (const key of Array.from(this.explicitSet)) {
+      if (key === pathKey || key.startsWith(`${pathKey}.`) || key.startsWith(`${pathKey}[`)) {
+        this.explicitSet.delete(key);
+      }
+    }
+  }
+
+  private shouldPreserveDescendantDefaultsOnExplicit(pathKey: string) {
+    const value = this.getFormValueAtPath(pathKeyToNamePath(pathKey));
+    return Array.isArray(value);
+  }
+
+  private shouldKeepDefaultPathEnabled(namePath: NamePath, snapshot: any) {
+    return this.shouldKeepDefaultPathValueEnabled(namePath, _.get(snapshot, namePath as any));
+  }
+
+  private shouldKeepDefaultPathValueEnabled(namePath: NamePath, value: any) {
+    const pathKey = namePathToPathKey(namePath);
+    const last = this.lastDefaultValueByPathKey.get(pathKey);
+    if (typeof last === 'undefined') return false;
+
+    const nextSnapshot = isObservable(value) ? toJS(value) : value;
+    return _.isEqual(nextSnapshot, last);
+  }
+
   private isExplicit(pathKey: string) {
     return !!this.findExplicitHit(pathKey);
   }

package/src/flow/models/blocks/shared/filterOperators.ts

@@ -0,0 +1,14 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+export function isArrayLikeField(field: any) {
+  return (
+    ['multipleSelect', 'checkboxGroup'].includes(field?.interface) || ['array', 'json', 'jsonb'].includes(field?.type)
+  );
+}

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

@@ -563,6 +563,9 @@ export class TableBlockModel extends CollectionBlockModel<TableBlockModelStructu
           columns={this.columns.value}
           pagination={this.pagination()}
           highlightedRowKey={highlightedRowKey}
+          selectedRowKeysFromResource={this.resource
+            .getSelectedRows()
+            .map((row) => getRowKey(row, this.collection.filterTargetKey))}
           defaultExpandAllRows={this.props.defaultExpandAllRows}
           expandedRowKeys={this.props.expandedRowKeys}
           heightMode={heightMode}
@@ -581,6 +584,7 @@ const TableBlockContent = (props: {
   columns: any;
   pagination: any;
   highlightedRowKey: string;
+  selectedRowKeysFromResource: string[];
   defaultExpandAllRows?: boolean;
   expandedRowKeys?: any[];
   heightMode?: string;
@@ -594,6 +598,7 @@ const TableBlockContent = (props: {
     columns,
     pagination,
     highlightedRowKey,
+    selectedRowKeysFromResource,
     defaultExpandAllRows,
     expandedRowKeys,
     heightMode,
@@ -620,6 +625,7 @@ const TableBlockContent = (props: {
           columns={columns}
           pagination={pagination}
           highlightedRowKey={highlightedRowKey}
+          selectedRowKeysFromResource={selectedRowKeysFromResource}
           defaultExpandAllRows={defaultExpandAllRows}
           expandedRowKeys={expandedRowKeys}
           tableScroll={tableScroll}
@@ -829,6 +835,7 @@ const HighPerformanceTable = React.memo(
     columns: any;
     pagination: any;
     highlightedRowKey: string;
+    selectedRowKeysFromResource: string[];
     defaultExpandAllRows?: boolean;
     expandedRowKeys?: any[];
     tableScroll;
@@ -841,6 +848,7 @@ const HighPerformanceTable = React.memo(
       columns,
       pagination: _pagination,
       highlightedRowKey,
+      selectedRowKeysFromResource,
       defaultExpandAllRows,
       expandedRowKeys,
       tableScroll,
@@ -848,9 +856,17 @@ const HighPerformanceTable = React.memo(
     const dataSourceRef = useRef(dataSource);
     dataSourceRef.current = dataSource;
 
-    const [selectedRowKeys, setSelectedRowKeys] = React.useState<string[]>(() =>
-      model.resource.getSelectedRows().map((row) => getRowKey(row, model.collection.filterTargetKey)),
-    );
+    const [selectedRowKeys, setSelectedRowKeys] = React.useState<string[]>(selectedRowKeysFromResource || []);
+
+    useEffect(() => {
+      const nextSelectedRowKeys = selectedRowKeysFromResource || [];
+      setSelectedRowKeys((prev) => {
+        if (_.isEqual(prev, nextSelectedRowKeys)) {
+          return prev;
+        }
+        return nextSelectedRowKeys;
+      });
+    }, [selectedRowKeysFromResource]);
 
     const getRowKeyFunc = useCallback(
       (record) => {

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/SubTableColumnModel.tsx

@@ -177,6 +177,25 @@ const MemoFieldRenderer = React.memo(FieldModelRenderer, (prev, next) => {
   return prev.value === next.value && prev.model === next.model;
 });
 
+export function buildRowPathFromFieldIndex(fieldIndex: unknown): Array<string | number> | null {
+  if (!Array.isArray(fieldIndex) || !fieldIndex.length) return null;
+  const out: Array<string | number> = [];
+  for (const entry of fieldIndex) {
+    if (typeof entry !== 'string') continue;
+    const [fieldName, indexStr] = entry.split(':');
+    const index = Number(indexStr);
+    if (!fieldName || !Number.isFinite(index)) continue;
+    out.push(fieldName, index);
+  }
+  return out.length ? out : null;
+}
+
+export function getLatestSubTableRowRecord(form: any, fieldIndex: unknown, fallbackRecord: any): any {
+  const latestRowPath = buildRowPathFromFieldIndex(fieldIndex);
+  const latestRecord = latestRowPath ? form?.getFieldValue?.(latestRowPath) : undefined;
+  return typeof latestRecord === 'undefined' ? fallbackRecord : latestRecord;
+}
+
 function shouldCommitImmediately(value: any) {
   if (Array.isArray(value)) {
     return true;
@@ -574,6 +593,9 @@ export class SubTableColumnModel<
       const rowForkKey = `row:${baseIndexKey}:${rowIdentity}:${String(rowIdx)}`;
       const rowFork: any = (() => {
         const fork = this.createFork({}, rowForkKey);
+        fork.context.defineProperty('subTableRowFork', {
+          value: true,
+        });
         const associationFieldPath =
           (this.parent as any)?.fieldPath ??
           (this.parent as any)?.context?.fieldPath ??
@@ -592,9 +614,11 @@ export class SubTableColumnModel<
         }
         fork.context.defineProperty('item', {
           get: () => {
+            const form = (fork.context as any)?.form || (this.context?.blockModel as any)?.context?.form;
+            const rowRecord = getLatestSubTableRowRecord(form, fork.context.fieldIndex, record);
             const parentItemCtx = (parentItem ?? this.context?.item) as any;
-            const isNew = record?.__is_new__;
-            const isStored = record?.__is_stored__;
+            const isNew = rowRecord?.__is_new__;
+            const isStored = rowRecord?.__is_stored__;
             const list = (this.parent as any)?.props?.value;
             const length = Array.isArray(list) ? list.length : undefined;
             return {
@@ -602,7 +626,7 @@ export class SubTableColumnModel<
               length,
               __is_new__: isNew,
               __is_stored__: isStored,
-              value: record,
+              value: rowRecord,
               parentItem: parentItemCtx,
             };
           },