@nocobase/client-v2 2.2.0-alpha.1 → 2.2.0-alpha.2

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

@@ -26,6 +26,7 @@ import {
   observer,
   FlowModelProvider,
   FlowErrorFallback,
+  extractUsedVariablePaths,
 } from '@nocobase/flow-engine';
 import { TableColumnProps, Tooltip, Input, Space, Divider } from 'antd';
 import { ErrorBoundary } from 'react-error-boundary';
@@ -37,6 +38,14 @@ import { FieldDeletePlaceholder, CustomWidth, normalizeTableColumnWidth } from '
 import { buildDynamicNamePath } from '../../../blocks/form/dynamicNamePath';
 import { getSubTableRowIdentity } from './rowIdentity';
 import { getFieldBindingUse, rebuildFieldSubModel } from '../../../../internal/utils/rebuildFieldSubModel';
+import {
+  buildCurrentItemTitle,
+  createAssociationItemChainContextPropertyOptions,
+  createItemChainGetter,
+  createParentItemAccessorsFromContext,
+  createRootItemChain,
+  type ItemChain,
+} from '../itemChain';
 
 export const SUB_TABLE_COLUMN_FIELD_COMPONENT_CONTEXT = 'subTableColumn';
 
@@ -180,6 +189,25 @@ const handleModelName = (modelName) => {
   return modelName;
 };
 
+const DATA_SCOPE_FLOW_KEYS = ['selectSettings', 'cascadeSelectSettings'];
+
+function hasFormValueDrivenDataScope(filter: any) {
+  if (!filter) return false;
+  try {
+    const usage = extractUsedVariablePaths(filter) || {};
+    return ['item', 'formValues'].some((name) => Object.prototype.hasOwnProperty.call(usage, name));
+  } catch {
+    return false;
+  }
+}
+
+function hasFormValueDrivenDataScopeField(fieldModel: any) {
+  return DATA_SCOPE_FLOW_KEYS.some((flowKey) => {
+    const params = fieldModel?.getStepParams?.(flowKey, 'dataScope');
+    return hasFormValueDrivenDataScope(params?.filter);
+  });
+}
+
 const MemoFieldRenderer = React.memo(FieldModelRenderer, (prev, next) => {
   return prev.value === next.value && prev.model === next.model;
 });
@@ -203,6 +231,20 @@ export function getLatestSubTableRowRecord(form: any, fieldIndex: unknown, fallb
   return typeof latestRecord === 'undefined' ? fallbackRecord : latestRecord;
 }
 
+export function buildSubTableColumnNamePath(
+  fieldPath: Array<string | number>,
+  rowIdx: number,
+  namePath: string | number,
+  rowFieldIndex: unknown,
+): Array<string | number> {
+  const currentRowPath = buildRowPathFromFieldIndex(rowFieldIndex);
+  if (currentRowPath?.length) {
+    return [...currentRowPath, namePath];
+  }
+
+  return [...fieldPath, rowIdx, namePath];
+}
+
 function shouldCommitImmediately(value: any) {
   if (Array.isArray(value)) {
     return true;
@@ -344,11 +386,23 @@ const MemoCell: React.FC<CellProps> = React.memo(
         {parent.mapSubModels('field', (action: FieldModel) => {
           const fieldPath = action.context.fieldPath.split('.');
           const namePath = fieldPath.pop();
+          if (typeof namePath === 'undefined') {
+            return null;
+          }
+          const fieldNamePath = buildSubTableColumnNamePath(fieldPath, rowIdx, namePath, rowFork?.context?.fieldIndex);
+          const formItemName = buildDynamicNamePath([...fieldPath, rowIdx, namePath], parentFieldIndex);
 
           const fork: any = action.createFork({}, `${id}`);
           fork.context.defineProperty('currentObject', { get: () => record });
+          fork.context.defineProperty('fieldPathArray', {
+            get: () => fieldNamePath,
+            cache: false,
+          });
           if (rowFork) {
+            const itemOptions = rowFork.context.getPropertyOptions?.('item');
+            const { value: _value, ...itemOptionsWithoutValue } = (itemOptions || {}) as any;
             fork.context.defineProperty('item', {
+              ...itemOptionsWithoutValue,
               get: () => rowFork.context.item,
               cache: false,
             });
@@ -384,7 +438,7 @@ const MemoCell: React.FC<CellProps> = React.memo(
             <FormItem
               {...parent.props}
               key={id}
-              name={buildDynamicNamePath([...fieldPath, rowIdx, namePath], parentFieldIndex)}
+              name={formItemName}
               style={{ marginBottom: 0 }}
               showLabel={false}
               disabled={
@@ -445,6 +499,57 @@ export class SubTableColumnModel<
   static renderMode = ModelRenderMode.RenderFunction;
   static fieldComponentContext = SUB_TABLE_COLUMN_FIELD_COMPONENT_CONTEXT;
 
+  private getAssociationField() {
+    return (this.parent as any)?.context?.collectionField;
+  }
+
+  private getParentFormValues() {
+    return (this.context?.blockModel as any)?.context?.formValues;
+  }
+
+  private createParentItemAccessors(parentItemAccessor?: () => ItemChain | undefined) {
+    const baseAccessors = createParentItemAccessorsFromContext({
+      parentContextAccessor: () => (this.parent as any)?.context,
+      fallbackParentPropertiesAccessor: () => this.getParentFormValues(),
+    });
+
+    if (!parentItemAccessor) {
+      return baseAccessors;
+    }
+
+    return {
+      parentPropertiesAccessor: (ctx?: any) =>
+        parentItemAccessor()?.value ?? baseAccessors.parentPropertiesAccessor(ctx),
+      parentItemMetaAccessor: baseAccessors.parentItemMetaAccessor,
+      parentItemResolverAccessor: baseAccessors.parentItemResolverAccessor,
+    };
+  }
+
+  private createRowItemContextPropertyOptions(
+    options: {
+      resolverPropertiesAccessor?: () => unknown;
+      parentItemAccessor?: () => ItemChain | undefined;
+      showParentIndex?: boolean;
+    } = {},
+  ) {
+    const associationField = this.getAssociationField();
+
+    return createAssociationItemChainContextPropertyOptions({
+      t: this.context.t,
+      title: buildCurrentItemTitle(this.context.t, associationField, this.props?.name),
+      showIndex: true,
+      showParentIndex:
+        options.showParentIndex ??
+        (Array.isArray((this.parent as any)?.context?.fieldIndex) &&
+          (this.parent as any).context.fieldIndex.length > 0),
+      collectionAccessor: () => (this.parent as any)?.collection ?? associationField?.targetCollection ?? null,
+      propertiesAccessor: (ctx) => ctx?.item?.value,
+      resolverPropertiesAccessor: options.resolverPropertiesAccessor ?? (() => undefined),
+      parentCollectionAccessor: () => associationField?.collection,
+      parentAccessors: this.createParentItemAccessors(options.parentItemAccessor),
+    });
+  }
+
   renderHiddenInConfig() {
     return <FieldWithoutPermissionPlaceholder targetModel={this} />;
   }
@@ -505,6 +610,14 @@ export class SubTableColumnModel<
     ).some(Boolean);
   }
 
+  get hasFormValueDrivenDataScopeColumn() {
+    return (
+      this.parent?.mapSubModels('columns', (column: SubTableColumnModel) => {
+        return hasFormValueDrivenDataScopeField(column?.subModels?.field);
+      }) || []
+    ).some(Boolean);
+  }
+
   onInit(options: any): void {
     super.onInit(options);
     this.context.defineProperty('resourceName', {
@@ -516,6 +629,10 @@ export class SubTableColumnModel<
     this.context.defineProperty('actionName', {
       get: () => 'view',
     });
+    this.context.defineProperty('item', {
+      get: () => undefined,
+      ...this.createRowItemContextPropertyOptions(),
+    });
     this.emitter.on('onSubModelAdded', (subModel: FieldModel) => {
       if (this.collectionField) {
         subModel.setProps(this.collectionField.getComponentProps());
@@ -673,25 +790,30 @@ export class SubTableColumnModel<
             value: [...baseArr, `${associationKey}:${rowIndex}`],
           });
         }
-        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 = rowRecord?.__is_new__;
-            const isStored = rowRecord?.__is_stored__;
+        const getRowRecord = () => {
+          const form = (fork.context as any)?.form || (this.context?.blockModel as any)?.context?.form;
+          return getLatestSubTableRowRecord(form, fork.context.fieldIndex, record);
+        };
+        const getParentItem = () => {
+          const parentItemCtx = (parentItem ?? (this.parent as any)?.context?.item) as ItemChain | undefined;
+          return parentItemCtx ?? createRootItemChain(this.getParentFormValues());
+        };
+        const getRowItem = createItemChainGetter({
+          valueAccessor: getRowRecord,
+          parentItemAccessor: getParentItem,
+          indexAccessor: () => (Number.isFinite(rowIndex) ? rowIndex : undefined),
+          lengthAccessor: () => {
             const list = (this.parent as any)?.props?.value;
-            const length = Array.isArray(list) ? list.length : undefined;
-            return {
-              index: Number.isFinite(rowIndex) ? rowIndex : undefined,
-              length,
-              __is_new__: isNew,
-              __is_stored__: isStored,
-              value: rowRecord,
-              parentItem: parentItemCtx,
-            };
+            return Array.isArray(list) ? list.length : undefined;
           },
-          cache: false,
+        });
+        fork.context.defineProperty('item', {
+          get: getRowItem,
+          ...this.createRowItemContextPropertyOptions({
+            resolverPropertiesAccessor: getRowRecord,
+            parentItemAccessor: getParentItem,
+            showParentIndex: baseArr.length > 0,
+          }),
         });
         return fork;
       })();
@@ -707,7 +829,7 @@ export class SubTableColumnModel<
           rowFork={rowFork}
           memoKey={cellModeKey}
           width={this.props.width}
-          commitOnChange={this.hasFormulaColumn}
+          commitOnChange={this.hasFormulaColumn || this.hasFormValueDrivenDataScopeColumn}
         />
       );
     };

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

@@ -70,6 +70,7 @@ export function SubTableField(props) {
     getCurrentValue,
     fieldPathArray,
     formValuesChangeEmitter,
+    onResetFieldValue,
   } = props;
   const [currentPage, setCurrentPage] = useState(1);
   const [currentPageSize, setCurrentPageSize] = useState(pageSize);
@@ -97,6 +98,17 @@ export function SubTableField(props) {
       formValuesChangeEmitter.off('formValuesChange', listener);
     };
   }, [fieldPathArray, formValuesChangeEmitter]);
+  useEffect(() => {
+    if (!formValuesChangeEmitter?.on || !formValuesChangeEmitter?.off || !onResetFieldValue) return;
+    const listener = () => {
+      onResetFieldValue();
+      forceRefresh((v) => v + 1);
+    };
+    formValuesChangeEmitter.on('onFieldReset', listener);
+    return () => {
+      formValuesChangeEmitter.off('onFieldReset', listener);
+    };
+  }, [formValuesChangeEmitter, onResetFieldValue]);
   const applyValue = React.useCallback((nextValue: any) => onChange?.(normalizeSubTableRows(nextValue)), [onChange]);
   const getLatestValue = React.useCallback(() => normalizeSubTableRows(getCurrentValue()), [getCurrentValue]);
   useEffect(() => {
@@ -125,7 +137,7 @@ export function SubTableField(props) {
         return t('Total {{count}} items', { count: total });
       },
     } as any;
-  }, [currentPage, currentPageSize, currentValue.length]);
+  }, [currentPage, currentPageSize, currentValue.length, t]);
 
   // 新增一行
   const handleAdd = () => {

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/__tests__/SubTableColumnModel.rowRecord.test.ts

@@ -15,18 +15,50 @@ import {
   SubTableColumnModel,
   getLatestSubTableRowRecord,
   buildRowPathFromFieldIndex,
+  buildSubTableColumnNamePath,
   isSubTableColumnConfiguredReadPretty,
   getSubTableColumnTitleField,
   getSubTableColumnReadPrettyFieldProps,
   isSubTableColumnReadPretty,
 } from '../SubTableColumnModel';
 
+function createMockCollection(name: string, fields: any[] = []) {
+  const collection: any = {
+    name,
+    title: name,
+    dataSourceKey: 'main',
+    filterTargetKey: 'id',
+    fields,
+    getFields: () => collection.fields,
+    getField: (fieldName: string) => collection.fields.find((field) => field.name === fieldName),
+  };
+
+  collection.fields.forEach((field) => {
+    field.collection = field.collection ?? collection;
+    field.filterable = field.filterable ?? true;
+    field.isAssociationField = field.isAssociationField ?? (() => false);
+  });
+
+  return collection;
+}
+
 describe('SubTableColumnModel row record helpers', () => {
   it('builds the row path from fieldIndex entries', () => {
     expect(buildRowPathFromFieldIndex(['roles:0'])).toEqual(['roles', 0]);
     expect(buildRowPathFromFieldIndex(['users:1', 'roles:2'])).toEqual(['users', 1, 'roles', 2]);
   });
 
+  it('builds absolute form item paths for nested sub-table columns', () => {
+    expect(buildSubTableColumnNamePath(['roles'], 0, 'name', ['roles:0'])).toEqual(['roles', 0, 'name']);
+    expect(buildSubTableColumnNamePath(['orders', 'lines'], 1, 'product', ['orders:0', 'lines:1'])).toEqual([
+      'orders',
+      0,
+      'lines',
+      1,
+      'product',
+    ]);
+  });
+
   it('prefers the latest row value from form over the fallback record', () => {
     const form = {
       getFieldValue: vi.fn((path: any) => {
@@ -51,6 +83,171 @@ describe('SubTableColumnModel row record helpers', () => {
     expect(getLatestSubTableRowRecord(form, ['roles:0'], fallback)).toBe(fallback);
   });
 
+  it('provides current item meta for sub-table column data scope variables', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ SubTableColumnModel });
+
+    const tagsCollection = createMockCollection('tags', [
+      { name: 'id', title: 'ID', type: 'integer', interface: 'integer' },
+      { name: 'name', title: 'Name', type: 'string', interface: 'input' },
+    ]);
+    const rolesCollection = createMockCollection('roles', [
+      { name: 'id', title: 'ID', type: 'integer', interface: 'integer' },
+      { name: 'name', title: 'Name', type: 'string', interface: 'input' },
+      {
+        name: 'tags',
+        title: 'Tags',
+        type: 'hasMany',
+        interface: 'o2m',
+        target: 'tags',
+        targetCollection: tagsCollection,
+        isAssociationField: () => true,
+      },
+    ]);
+    const usersCollection = createMockCollection('users', [
+      { name: 'id', title: 'ID', type: 'integer', interface: 'integer' },
+      { name: 'nickname', title: 'Nickname', type: 'string', interface: 'input' },
+    ]);
+    const rolesField = {
+      name: 'roles',
+      title: 'Roles',
+      type: 'hasMany',
+      interface: 'o2m',
+      collection: usersCollection,
+      target: 'roles',
+      targetCollection: rolesCollection,
+      isAssociationField: () => true,
+    };
+
+    const form = {
+      getFieldValue: vi.fn((path: any) => {
+        if (JSON.stringify(path) === JSON.stringify(['roles', 0])) {
+          return { id: 11, name: 'Admin', tags: [{ id: 7 }] };
+        }
+      }),
+    };
+    const blockModel: any = engine.createModel({ use: 'FlowModel', uid: 'form-block', structure: {} as any });
+    blockModel.context.defineProperty('form', { value: form });
+    blockModel.context.defineProperty('formValues', {
+      value: {
+        id: 1,
+        nickname: 'Alice',
+        roles: [{ id: 11, name: 'Admin' }],
+      },
+    });
+
+    const subTableFieldModel: any = engine.createModel({
+      use: 'FlowModel',
+      uid: 'users.roles',
+      structure: {} as any,
+    });
+    subTableFieldModel.collection = rolesCollection;
+    subTableFieldModel.setProps({ value: [{ id: 11, name: 'Admin' }] });
+    subTableFieldModel.context.defineProperty('collectionField', { value: rolesField });
+    subTableFieldModel.context.defineProperty('fieldPath', { value: 'roles' });
+    subTableFieldModel.context.defineProperty('blockModel', { value: blockModel });
+
+    const column: any = engine.createModel({
+      use: 'SubTableColumnModel',
+      uid: 'users.roles.tags',
+      stepParams: {
+        fieldSettings: {
+          init: {
+            fieldPath: 'roles.tags',
+          },
+        },
+      },
+      structure: {} as any,
+    });
+    column.setParent(subTableFieldModel);
+    column.context.defineProperty('blockModel', { value: blockModel });
+    column.subModels = { field: [] };
+
+    const designTimeItemOptions = column.context.getPropertyOptions('item');
+    expect(typeof designTimeItemOptions.meta).toBe('function');
+    const designTimeMeta = await designTimeItemOptions.meta();
+    expect(designTimeMeta.properties.value.title).toBe('Attributes');
+    expect(designTimeMeta.properties.parentItem.properties.value.title).toBe('Attributes');
+
+    const renderCell = column.renderItem();
+    renderCell({
+      id: 'cell-roles-tags-0',
+      rowIdx: 0,
+      record: { id: 11, name: 'Stale admin', tags: [{ id: 7 }] },
+      parentItem: {
+        value: { id: 1, nickname: 'Alice' },
+      },
+    });
+
+    const [rowFork] = Array.from(column.forks ?? []) as any[];
+    const rowItemOptions = rowFork.context.getPropertyOptions('item');
+    expect(typeof rowItemOptions.meta).toBe('function');
+    expect(rowItemOptions.resolveOnServer('value.tags.name')).toBe(true);
+
+    const rowMeta = await rowItemOptions.meta();
+    expect(rowMeta.properties.value.title).toBe('Attributes');
+    expect(rowMeta.properties.parentItem.properties.value.title).toBe('Attributes');
+    expect(rowFork.context.item).toMatchObject({
+      index: 0,
+      length: 1,
+      value: { id: 11, name: 'Admin', tags: [{ id: 7 }] },
+      parentItem: {
+        value: { id: 1, nickname: 'Alice' },
+      },
+    });
+  });
+
+  it('detects variable data scope columns for immediate row commits', () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ SubTableColumnModel });
+
+    const inputColumn: any = engine.createModel({
+      use: 'SubTableColumnModel',
+      uid: 'users.roles.name',
+      structure: {} as any,
+    });
+    const scopedColumn: any = engine.createModel({
+      use: 'SubTableColumnModel',
+      uid: 'users.roles.tags',
+      structure: {} as any,
+    });
+
+    inputColumn.subModels = {
+      field: {
+        getStepParams: vi.fn(() => undefined),
+      },
+    };
+    scopedColumn.subModels = {
+      field: {
+        getStepParams: vi.fn((flowKey: string, stepKey: string) => {
+          if (flowKey !== 'selectSettings' || stepKey !== 'dataScope') {
+            return undefined;
+          }
+          return {
+            filter: {
+              logic: '$and',
+              items: [{ path: 'name', operator: '$eq', value: '{{ ctx.item.value.name }}' }],
+            },
+          };
+        }),
+      },
+    };
+
+    const parent: any = engine.createModel({
+      use: 'FlowModel',
+      uid: 'users.roles-table',
+      structure: {} as any,
+    });
+    parent.mapSubModels = vi.fn((key: string, iterator: (column: SubTableColumnModel) => unknown) => {
+      if (key !== 'columns') return [];
+      return [inputColumn, scopedColumn].map(iterator);
+    });
+    inputColumn.setParent(parent);
+    scopedColumn.setParent(parent);
+
+    expect(inputColumn.hasFormValueDrivenDataScopeColumn).toBe(true);
+  });
+
   it('treats a display-only column pattern as read-pretty mode', () => {
     expect(isSubTableColumnReadPretty({ props: { pattern: 'readPretty' } })).toBe(true);
     expect(isSubTableColumnReadPretty({ props: { readPretty: true } })).toBe(true);

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/__tests__/SubTableFieldModel.reset.test.ts

@@ -0,0 +1,180 @@
+/**
+ * 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.
+ */
+
+import React from 'react';
+import { act, render } from '@nocobase/test/client';
+import { FlowEngine, type FlowModel } from '@nocobase/flow-engine';
+import { describe, expect, it, vi } from 'vitest';
+import { PopupSubTableFieldModel } from '../../PopupSubTableFieldModel';
+import { SubTableFieldModel } from '..';
+
+vi.mock('react-i18next', async (importOriginal) => ({
+  ...(await importOriginal<any>()),
+  useTranslation: () => ({
+    t: (value: string) => value,
+  }),
+}));
+
+vi.mock('antd', async () => {
+  const actual = await vi.importActual<any>('antd');
+  return {
+    ...actual,
+    Table: ({ dataSource = [], columns = [] }: any) =>
+      React.createElement(
+        'div',
+        { 'data-testid': 'subtable' },
+        dataSource.map((record: any, rowIdx: number) =>
+          React.createElement(
+            'div',
+            { 'data-testid': `row-${rowIdx}`, key: record.__index__ || rowIdx },
+            columns.map((column: any) =>
+              React.createElement(
+                'div',
+                { 'data-testid': `cell-${rowIdx}-${String(column.dataIndex || column.key)}`, key: column.key },
+                column.render?.(record[column.dataIndex], record, rowIdx),
+              ),
+            ),
+          ),
+        ),
+      ),
+  };
+});
+
+function createSubTableFieldModel(props: Record<string, unknown> = {}) {
+  const engine = new FlowEngine();
+  engine.registerModels({ SubTableFieldModel });
+  const setFieldValue = vi.fn();
+
+  const blockModel = engine.createModel<FlowModel>({
+    use: 'FlowModel',
+    uid: 'form-block',
+  });
+  (blockModel as FlowModel & { setFieldValue: typeof setFieldValue }).setFieldValue = setFieldValue;
+  const parent = engine.createModel<FlowModel>({
+    use: 'FlowModel',
+    uid: 'form-item',
+  });
+
+  parent.context.defineProperty('blockModel', { value: blockModel });
+  parent.context.defineProperty('collectionField', {
+    value: {
+      target: 'roles',
+      targetCollection: {
+        filterTargetKey: 'id',
+      },
+    },
+  });
+  parent.context.defineProperty('fieldPathArray', { value: ['roles'] });
+
+  const model = engine.createModel<SubTableFieldModel>({
+    use: 'SubTableFieldModel',
+    uid: 'roles-subtable',
+    parentId: parent.uid,
+    props,
+  });
+
+  return { blockModel, model, setFieldValue };
+}
+
+async function createPopupSubTableFieldModel(props: Record<string, unknown> = {}) {
+  const engine = new FlowEngine();
+  engine.registerModels({ PopupSubTableFieldModel });
+  const setFieldValue = vi.fn();
+
+  const blockModel = engine.createModel<FlowModel>({
+    use: 'FlowModel',
+    uid: 'popup-form-block',
+  });
+  (blockModel as FlowModel & { setFieldValue: typeof setFieldValue }).setFieldValue = setFieldValue;
+  const parent = engine.createModel<FlowModel>({
+    use: 'FlowModel',
+    uid: 'popup-form-item',
+  });
+
+  parent.context.defineProperty('blockModel', { value: blockModel });
+  parent.context.defineProperty('collectionField', {
+    value: {
+      target: 'roles',
+      targetCollection: {
+        filterTargetKey: 'id',
+      },
+    },
+  });
+  parent.context.defineProperty('fieldPathArray', { value: ['roles'] });
+
+  const model = engine.createModel<PopupSubTableFieldModel>({
+    use: 'PopupSubTableFieldModel',
+    uid: 'roles-popup-subtable',
+    parentId: parent.uid,
+    props,
+  });
+  (model.subModels as Record<string, unknown>).subTableColumns = [];
+  await model.onDispatchEventStart('beforeRender');
+
+  return { blockModel, model, setFieldValue };
+}
+
+describe('SubTable field reset', () => {
+  it('resets the rendered fork through its own form field path', () => {
+    const onChange = vi.fn();
+    const { blockModel, model, setFieldValue } = createSubTableFieldModel({
+      onChange,
+      value: [{ id: 1 }],
+    });
+    const fork = model.createFork({ value: [{ id: 1 }] }, 'orders.0.lines');
+    fork.context.defineProperty('fieldPathArray', { value: ['orders', 0, 'lines'] });
+
+    render(React.createElement(React.Fragment, null, fork.render()));
+
+    act(() => {
+      blockModel.emitter.emit('onFieldReset');
+    });
+
+    expect(fork.props.value).toEqual([]);
+    expect(setFieldValue).toHaveBeenCalledWith(['orders', 0, 'lines'], []);
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it('resets the non-forked model through the parent form field path', () => {
+    const onChange = vi.fn();
+    const { blockModel, model, setFieldValue } = createSubTableFieldModel({
+      onChange,
+      value: [{ id: 1 }],
+    });
+
+    render(React.createElement(React.Fragment, null, model.render()));
+
+    act(() => {
+      blockModel.emitter.emit('onFieldReset');
+    });
+
+    expect(model.props.value).toEqual([]);
+    expect(setFieldValue).toHaveBeenCalledWith(['roles'], []);
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it('resets popup sub-table form values without relying on onChange', async () => {
+    const onChange = vi.fn();
+    const { blockModel, model, setFieldValue } = await createPopupSubTableFieldModel({
+      onChange,
+      pageSize: 10,
+      value: [{ id: 1 }],
+    });
+
+    render(React.createElement(React.Fragment, null, model.render()));
+
+    act(() => {
+      blockModel.emitter.emit('onFieldReset');
+    });
+
+    expect(model.props.value).toEqual([]);
+    expect(setFieldValue).toHaveBeenCalledWith(['roles'], []);
+    expect(onChange).not.toHaveBeenCalled();
+  });
+});