@nocobase/client-v2 2.1.0-alpha.34 → 2.1.0-alpha.35

package/src/flow/admin-shell/admin-layout/__tests__/AdminLayoutMenuModels.test.ts

@@ -311,7 +311,7 @@ describe('AdminLayoutModel menu items', () => {
     expect(route.children[1]._model).toBe(adminLayoutModel.subModels.menuItems?.[1]);
   });
 
-  it('should filter legacy page menu routes in v2 admin layout', () => {
+  it('should filter legacy page menu routes but keep empty groups in v2 admin layout', () => {
     const adminLayoutModel = engine.createModel<AdminLayoutModel>({
       uid: 'admin-layout-model',
       use: AdminLayoutModel,
@@ -369,22 +369,30 @@ describe('AdminLayoutModel menu items', () => {
       t: (title) => title,
     });
 
-    expect(route.children).toHaveLength(2);
+    expect(route.children).toHaveLength(3);
     expect(route.children[0]).toMatchObject({
+      path: '/admin/2',
+      redirect: '/admin/2',
+      _runtimePath: null,
+      _navigationMode: 'spa',
+      _isLegacy: false,
+    });
+    expect(route.children[0].routes).toBeUndefined();
+    expect(route.children[1]).toMatchObject({
       path: '/admin/3',
       redirect: '/admin/nested-flow-page',
       _runtimePath: '/apps/demo/v2/admin/nested-flow-page',
       _navigationMode: 'spa',
       _isLegacy: false,
     });
-    expect(route.children[0].routes).toHaveLength(1);
-    expect(route.children[0].routes?.[0]).toMatchObject({
+    expect(route.children[1].routes).toHaveLength(1);
+    expect(route.children[1].routes?.[0]).toMatchObject({
       path: '/admin/nested-flow-page',
       _runtimePath: '/apps/demo/v2/admin/nested-flow-page',
       _navigationMode: 'spa',
       _isLegacy: false,
     });
-    expect(route.children[1]).toMatchObject({
+    expect(route.children[2]).toMatchObject({
       path: '/admin/__admin_layout__/link/4',
     });
   });

package/src/flow/components/FieldAssignRulesEditor.tsx

@@ -35,6 +35,7 @@ type CollectionFieldLike = {
   title?: unknown;
   type?: unknown;
   interface?: unknown;
+  uiSchema?: unknown;
   targetKey?: unknown;
   targetCollectionTitleFieldName?: unknown;
   targetCollection?: any;
@@ -194,6 +195,7 @@ export const FieldAssignRulesEditor: React.FC<FieldAssignRulesEditorProps> = (pr
           title,
           type: String(f.type || 'string'),
           interface: fieldInterface,
+          uiSchema: (f as any).uiSchema,
           paths: [...basePaths, name],
         };
 

package/src/flow/components/__tests__/FieldAssignRulesEditor.test.tsx

@@ -15,7 +15,7 @@ import type { MetaTreeNode } from '@nocobase/flow-engine';
 import { FieldAssignRulesEditor, type FieldAssignRuleItem } from '../FieldAssignRulesEditor';
 import { mergeItemMetaTreeForAssignValue } from '../FieldAssignValueInput';
 
-const { mockFieldAssignValueInput } = vi.hoisted(() => ({
+const { mockFieldAssignValueInput, mockConditionBuilder } = vi.hoisted(() => ({
   mockFieldAssignValueInput: vi.fn((props: any) => (
     <div
       data-testid="mock-value-input"
@@ -25,6 +25,9 @@ const { mockFieldAssignValueInput } = vi.hoisted(() => ({
       data-date-constant={props?.enableDateVariableAsConstant ? 'yes' : 'no'}
     />
   )),
+  mockConditionBuilder: vi.fn((props: any) => (
+    <div data-testid="mock-condition-builder" data-extra={props?.extraMetaTree ? 'yes' : 'no'} />
+  )),
 }));
 
 vi.mock('../FieldAssignValueInput', async () => {
@@ -39,9 +42,7 @@ vi.mock('../ConditionBuilder', async () => {
   const actual = await vi.importActual<typeof import('../ConditionBuilder')>('../ConditionBuilder');
   return {
     ...actual,
-    ConditionBuilder: (props: any) => (
-      <div data-testid="mock-condition-builder" data-extra={props?.extraMetaTree ? 'yes' : 'no'} />
-    ),
+    ConditionBuilder: mockConditionBuilder,
   };
 });
 
@@ -55,6 +56,7 @@ describe('FieldAssignRulesEditor', () => {
 
   beforeEach(() => {
     mockFieldAssignValueInput.mockClear();
+    mockConditionBuilder.mockClear();
   });
 
   const createAssociationFixture = () => {
@@ -574,6 +576,81 @@ describe('FieldAssignRulesEditor', () => {
     expect(getByTestId('mock-condition-builder').getAttribute('data-extra')).toBe('yes');
   });
 
+  it('preserves uiSchema enum for current item attributes in condition extra tree', async () => {
+    const aaaField: any = {
+      name: 'AAA',
+      title: 'AAA',
+      type: 'array',
+      interface: 'multipleSelect',
+      isAssociationField: () => false,
+      uiSchema: {
+        enum: [
+          { label: 'Test1', value: 'Test1' },
+          { label: 'Test2', value: 'Test2' },
+        ],
+      },
+    };
+    const roleNameField: any = {
+      name: 'name',
+      title: 'Role name',
+      type: 'string',
+      interface: 'input',
+      isAssociationField: () => false,
+    };
+    const rolesCollection = {
+      getField: (name: string) => (name === 'AAA' ? aaaField : name === 'name' ? roleNameField : null),
+      getFields: () => [roleNameField, aaaField],
+    };
+    const rolesField: any = {
+      name: 'roles',
+      title: 'Roles',
+      type: 'belongsToMany',
+      interface: 'm2m',
+      isAssociationField: () => true,
+      targetCollection: rolesCollection,
+    };
+    const rootCollection = {
+      getField: (name: string) => (name === 'roles' ? rolesField : null),
+      getFields: () => [rolesField],
+    };
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: 'rule-roles-name',
+        enable: true,
+        targetPath: 'roles.name',
+        mode: 'assign',
+        condition: { logic: '$and', items: [] },
+      },
+    ];
+
+    render(
+      wrap(
+        <FieldAssignRulesEditor t={t} fieldOptions={[]} rootCollection={rootCollection} value={value} showCondition />,
+      ),
+    );
+
+    const conditionProps = mockConditionBuilder.mock.calls[mockConditionBuilder.mock.calls.length - 1]?.[0];
+    const extraMetaTree = conditionProps?.extraMetaTree as MetaTreeNode[] | undefined;
+    expect(Array.isArray(extraMetaTree)).toBe(true);
+
+    const itemNode = extraMetaTree?.find((node) => node.name === 'item') as MetaTreeNode | undefined;
+    expect(itemNode).toBeTruthy();
+
+    const itemChildren = (Array.isArray(itemNode?.children) ? itemNode.children : []) as MetaTreeNode[];
+    const attributesNode = itemChildren.find((node) => node.name === 'value') as MetaTreeNode | undefined;
+    expect(attributesNode).toBeTruthy();
+
+    const attributeChildren =
+      typeof attributesNode?.children === 'function' ? await attributesNode.children() : attributesNode?.children ?? [];
+    const aaaNode = (attributeChildren as MetaTreeNode[]).find((node) => node.name === 'AAA') as any;
+
+    expect(aaaNode?.interface).toBe('multipleSelect');
+    expect(aaaNode?.uiSchema?.enum).toEqual([
+      { label: 'Test1', value: 'Test1' },
+      { label: 'Test2', value: 'Test2' },
+    ]);
+  });
+
   it('renders empty state when no items', () => {
     const { container } = render(
       wrap(<FieldAssignRulesEditor t={t} fieldOptions={[]} value={[]} showCondition={false} />),

package/src/flow/components/filter/LinkageFilterItem.tsx

@@ -22,7 +22,12 @@ import {
   observer,
 } from '@nocobase/flow-engine';
 import { NumberPicker } from '@formily/antd-v5';
-import { enumToOptions, translateOptions, UiSchemaEnumItem } from '../../internal/utils/enumOptionsUtils';
+import {
+  enumToOptions,
+  normalizeSelectRenderValue,
+  translateOptions,
+  UiSchemaEnumItem,
+} from '../../internal/utils/enumOptionsUtils';
 import { mergeItemMetaTreeForAssignValue } from '../FieldAssignValueInput';
 import { resolveOperatorComponent } from '../../internal/utils/operatorSchemaHelper';
 
@@ -82,7 +87,9 @@ function createStaticInputRenderer(
       } else if (optionsFromEnum) {
         finalProps = { ...finalProps, options: optionsFromEnum };
       }
-      return <Select {...finalProps} {...rest} value={value} onChange={onChange} />;
+      return (
+        <Select {...finalProps} {...rest} value={normalizeSelectRenderValue(value, finalProps)} onChange={onChange} />
+      );
     }
     if (xComponent === 'DateFilterDynamicComponent')
       return <DateFilterDynamicComponentLazy {...commonProps} {...rest} value={value} onChange={onChange} />;

package/src/flow/components/filter/VariableFilterItem.tsx

@@ -25,7 +25,7 @@ import {
 } from '@nocobase/flow-engine';
 import _ from 'lodash';
 import { NumberPicker } from '@formily/antd-v5';
-import { enumToOptions, UiSchemaEnumItem } from '../../internal/utils/enumOptionsUtils';
+import { enumToOptions, normalizeSelectRenderValue, UiSchemaEnumItem } from '../../internal/utils/enumOptionsUtils';
 import { resolveOperatorComponent } from '../../internal/utils/operatorSchemaHelper';
 
 const { DateFilterDynamicComponent: DateFilterDynamicComponentLazy } = lazy(
@@ -155,11 +155,7 @@ function createStaticInputRenderer(
           options={selectOptions}
           {...commonProps}
           {...rest}
-          value={
-            Array.isArray(value) || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
-              ? (value as unknown)
-              : undefined
-          }
+          value={normalizeSelectRenderValue(value, commonProps) as any}
           onChange={(v) => onChange?.(v as unknown as VariableFilterItemValue['value'])}
         />
       );

package/src/flow/components/filter/__tests__/LinkageFilterItem.test.tsx

@@ -67,6 +67,9 @@ function createModel() {
   return { model, app };
 }
 
+const getRenderedSelectTexts = (container: HTMLElement) =>
+  Array.from(container.querySelectorAll('.ant-select-selection-item')).map((node) => (node.textContent || '').trim());
+
 describe('LinkageFilterItem', () => {
   beforeEach(() => {
     document.body.innerHTML = '';
@@ -201,6 +204,74 @@ describe('LinkageFilterItem', () => {
     });
   });
 
+  it('does not render an empty selected option for constant single select', async () => {
+    const value = observable({ path: '', operator: '', value: '' }) as any;
+    const { model } = createModel();
+
+    (globalThis as any).__TEST_META__ = {
+      interface: 'select',
+      uiSchema: {
+        'x-component': 'Select',
+        enum: [{ label: 'Published', value: 'published' }],
+        'x-filter-operators': [
+          {
+            value: '$eq',
+            label: 'is',
+            selected: true,
+            schema: { 'x-component': 'Select' },
+          },
+        ],
+      },
+      paths: ['collection', 'status'],
+      name: 'status',
+      title: 'Status',
+      type: 'string',
+    };
+
+    const view = render(<LinkageFilterItem value={value} model={model} />);
+    fireEvent.click(screen.getByTestId('variable-input'));
+
+    await waitFor(() => {
+      expect(value.operator).toBe('$eq');
+    });
+
+    expect(getRenderedSelectTexts(view.container).filter((text) => text === '')).toHaveLength(0);
+  });
+
+  it('does not render an empty selected tag for constant multi select', async () => {
+    const value = observable({ path: '', operator: '', value: '' }) as any;
+    const { model } = createModel();
+
+    (globalThis as any).__TEST_META__ = {
+      interface: 'select',
+      uiSchema: {
+        'x-component': 'Select',
+        enum: [{ label: 'Published', value: 'published' }],
+        'x-filter-operators': [
+          {
+            value: '$in',
+            label: 'is any of',
+            selected: true,
+            schema: { 'x-component': 'Select', 'x-component-props': { mode: 'tags' } },
+          },
+        ],
+      },
+      paths: ['collection', 'status'],
+      name: 'status',
+      title: 'Status',
+      type: 'string',
+    };
+
+    const view = render(<LinkageFilterItem value={value} model={model} />);
+    fireEvent.click(screen.getByTestId('variable-input'));
+
+    await waitFor(() => {
+      expect(value.operator).toBe('$in');
+    });
+
+    expect(getRenderedSelectTexts(view.container).filter((text) => text === '')).toHaveLength(0);
+  });
+
   it('passes enum options to single select multi-value operators', async () => {
     const value = observable({ path: '', operator: '', value: ['draft'] }) as any;
     const { model, app } = createModel();

package/src/flow/components/filter/__tests__/VariableFilterItem.test.tsx

@@ -47,6 +47,9 @@ vi.mock('@nocobase/flow-engine', async () => {
   return { ...actual, VariableInput: MockVariableInput };
 });
 
+const getRenderedSelectTexts = (root: ParentNode = document.body) =>
+  Array.from(root.querySelectorAll('.ant-select-selection-item')).map((node) => (node.textContent || '').trim());
+
 function CreateModel() {
   const engine = new FlowEngine();
   const model = new FlowModel({ uid: 'm-variable-filter', flowEngine: engine });
@@ -262,6 +265,51 @@ describe('VariableFilterItem', () => {
     delete (globalThis as any).__TEST_META__;
   });
 
+  it('does not render an empty selected option for right constant select', async () => {
+    const value = observable({ path: '', operator: '', value: '' }) as any;
+    const model = CreateModel();
+
+    const prevMeta = (globalThis as any).__TEST_META__;
+    const prevPath = (globalThis as any).__TEST_PATH__;
+    (globalThis as any).__TEST_PATH__ = 'status';
+    (globalThis as any).__TEST_META__ = {
+      interface: 'select',
+      uiSchema: {
+        'x-component': 'Select',
+        enum: [{ label: 'Draft', value: 'draft' }],
+        'x-filter-operators': [
+          {
+            value: '$eq',
+            label: 'Equals',
+            selected: true,
+            schema: { 'x-component': 'Select' },
+          },
+        ],
+      },
+      paths: ['collection', 'status'],
+      name: 'status',
+      title: 'Status',
+      type: 'string',
+    };
+
+    render(<VariableFilterItem value={value} model={model} rightAsVariable />);
+    fireEvent.click(screen.getAllByTestId('variable-input')[0]);
+
+    await waitFor(() => {
+      expect(value.operator).toBe('$eq');
+    });
+
+    const rightVariableInputProps = (globalThis as any).__LAST_VARIABLE_INPUT_PROPS__;
+    const Renderer = rightVariableInputProps?.converters?.renderInputComponent?.({ paths: ['constant'] });
+    expect(Renderer).toBeTruthy();
+
+    const rendered = render(<Renderer value="" onChange={vi.fn()} />);
+    expect(getRenderedSelectTexts(rendered.container).filter((text) => text === '')).toHaveLength(0);
+
+    (globalThis as any).__TEST_META__ = prevMeta;
+    (globalThis as any).__TEST_PATH__ = prevPath;
+  });
+
   it('renders right VariableInput when rightAsVariable=true and hides it for noValue operator', async () => {
     const value = observable({ path: '', operator: '', value: '' }) as any;
     const model = CreateModel();

package/src/flow/internal/utils/__tests__/enumOptionsUtils.test.ts

@@ -8,7 +8,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { enumToOptions, translateOptions } from '../enumOptionsUtils';
+import { enumToOptions, getSelectedEnumLabels, translateOptions } from '../enumOptionsUtils';
 
 // 一个极简的 t：
 // - 直接返回传入 key；
@@ -55,4 +55,13 @@ describe('enumOptions utils', () => {
       { label: '否', value: false },
     ]);
   });
+
+  it('getSelectedEnumLabels: keeps label for selected value missing from limited options', () => {
+    const labels = getSelectedEnumLabels('published', [
+      { label: 'Draft', value: 'draft' },
+      { label: 'Published', value: 'published' },
+    ]);
+
+    expect(labels).toEqual([{ label: 'Published', value: 'published' }]);
+  });
 });

package/src/flow/internal/utils/enumOptionsUtils.ts

@@ -46,6 +46,35 @@ export function enumToOptions(uiEnum: UiSchemaEnumItem[] | undefined, t: (s: str
   return translateOptions(normalized, t);
 }
 
+export function normalizeSelectRenderValue(value: unknown, props?: Record<string, any>) {
+  const mode = props?.mode;
+  const isMultiple = mode === 'multiple' || mode === 'tags' || props?.multiple === true;
+
+  if (Array.isArray(value)) {
+    return value.filter((item) => item !== '' && item !== null && typeof item !== 'undefined');
+  }
+
+  if (value === '' || value === null || typeof value === 'undefined') {
+    return isMultiple ? [] : undefined;
+  }
+
+  return value;
+}
+
+export function getSelectedEnumLabels(value: any, fallbackOptions: Option[] = []): Array<{ value: any; label: any }> {
+  const values = Array.isArray(value) ? value : value == null ? [] : [value];
+  return values.map((item) => {
+    const fallback = fallbackOptions.find((option) => option?.value === item);
+    if (fallback) {
+      return { value: item, label: fallback.label };
+    }
+    return {
+      value: item,
+      label: item?.toString?.() ?? item,
+    };
+  });
+}
+
 // Populate model.props.options from uiSchema.enum if missing; returns whether options were injected
 export function ensureOptionsFromUiSchemaEnumIfAbsent(model: FlowModel, collectionField: CollectionField): boolean {
   const iface = collectionField?.interface;

package/src/flow/models/actions/AssociateActionModel.tsx

@@ -16,6 +16,7 @@ import { SkeletonFallback } from '../../components/SkeletonFallback';
 import { ActionModel, ActionSceneEnum } from '../base';
 import {
   applyAssociateAction,
+  getAssociationSelectorContextInputArgs,
   getAssociationTargetResourceSettings,
   isAssociationBlockContext,
 } from './AssociationActionUtils';
@@ -139,7 +140,6 @@ AssociateActionModel.registerFlow({
   steps: {
     openSelector: {
       async handler(ctx, params) {
-        const blockModel = ctx.blockModel;
         const targetResourceSettings = getAssociationTargetResourceSettings(ctx);
         const openMode = ctx.inputArgs?.isMobileLayout ? 'embed' : ctx.inputArgs?.mode || params?.mode || 'drawer';
         const size = ctx.inputArgs?.size || params?.size || 'medium';
@@ -168,9 +168,9 @@ AssociateActionModel.registerFlow({
             scene: 'select',
             dataSourceKey: targetResourceSettings.dataSourceKey,
             collectionName: targetResourceSettings.collectionName,
+            ...getAssociationSelectorContextInputArgs(ctx),
             rowSelectionProps: {
               type: 'checkbox',
-              defaultSelectedRows: () => blockModel?.resource?.getData?.() || [],
               renderCell: undefined,
               selectedRowKeys: undefined,
               onChange: (_, selectedRows) => {

package/src/flow/models/actions/AssociationActionUtils.ts

@@ -33,6 +33,20 @@ export const getAssociationTargetResourceSettings = (ctx: FlowModelContext | any
   };
 };
 
+export const getAssociationSelectorContextInputArgs = (ctx: FlowModelContext | any) => {
+  const blockModel = ctx?.blockModel || ctx?.model?.context?.blockModel;
+  const association = blockModel?.association;
+  const resourceSettings = getAssociationBlockResourceSettings(ctx);
+  const sourceId = blockModel?.resource?.getSourceId?.() ?? resourceSettings?.sourceId;
+  const associatedRecords = blockModel?.resource?.getData?.() || [];
+
+  return {
+    collectionField: association,
+    sourceId,
+    associatedRecords,
+  };
+};
+
 const callAssociationResourceAction = async (resource: any, action: 'add' | 'remove', values: any[]) => {
   if (typeof resource?.[action] === 'function') {
     return await resource[action]({ values });

package/src/flow/models/actions/__tests__/AssociationActionModel.test.ts

@@ -16,6 +16,7 @@ import {
   AssociateActionModel,
   CollectionActionGroupModel,
   DisassociateActionModel,
+  getAssociationSelectorContextInputArgs,
   getAssociationTargetResourceSettings,
   PopupActionModel,
   RecordActionGroupModel,
@@ -87,6 +88,68 @@ describe('association action models', () => {
     });
   });
 
+  it('passes one-to-many association context to selector table blocks', () => {
+    const association = {
+      name: 'orders',
+      interface: 'o2m',
+      target: 'orders',
+      sourceKey: 'id',
+      foreignKey: 'userId',
+    };
+    const ctx: any = {
+      blockModel: {
+        association,
+        resource: {
+          getSourceId: () => 362872646860800,
+        },
+        getResourceSettingsInitParams: () => ({
+          dataSourceKey: 'main',
+          collectionName: 'orders',
+          associationName: 'users.orders',
+          sourceId: '{{ctx.popup.record.id}}',
+        }),
+      },
+    };
+
+    expect(getAssociationSelectorContextInputArgs(ctx)).toEqual({
+      collectionField: association,
+      sourceId: 362872646860800,
+      associatedRecords: [],
+    });
+  });
+
+  it('passes current associated records to selector table blocks', () => {
+    const associatedRecords = [{ id: 11 }, { id: 12 }];
+    const association = {
+      name: 'tags',
+      interface: 'm2m',
+      target: 'tags',
+      sourceKey: 'id',
+      targetKey: 'id',
+    };
+    const ctx: any = {
+      blockModel: {
+        association,
+        resource: {
+          getSourceId: () => 1,
+          getData: () => associatedRecords,
+        },
+        getResourceSettingsInitParams: () => ({
+          dataSourceKey: 'main',
+          collectionName: 'tags',
+          associationName: 'posts.tags',
+          sourceId: '{{ctx.popup.record.id}}',
+        }),
+      },
+    };
+
+    expect(getAssociationSelectorContextInputArgs(ctx)).toEqual({
+      collectionField: association,
+      sourceId: 1,
+      associatedRecords,
+    });
+  });
+
   it('shows Associate only in collection actions of association blocks', async () => {
     const engine = createEngine();
 

package/src/flow/models/base/CollectionBlockModel.tsx

@@ -662,6 +662,9 @@ CollectionBlockModel.registerFlow({
       async handler(ctx) {
         const blockModel = ctx.model as CollectionBlockModel;
         const filterManager: FilterManager = ctx.model.context.filterManager;
+        const preparedFilterBlocks = filterManager?.prepareFiltersForTarget
+          ? await filterManager.prepareFiltersForTarget(ctx.model.uid)
+          : undefined;
         if (filterManager) {
           filterManager.bindToTarget(ctx.model.uid);
         }
@@ -679,6 +682,10 @@ CollectionBlockModel.registerFlow({
           return;
         }
 
+        preparedFilterBlocks?.forEach((filterBlockModel: any) => {
+          filterBlockModel?.markInitialTargetRefreshHandled?.(ctx.model.uid);
+        });
+
         if (ctx.model.isManualRefresh) {
           ctx.model.resource.loading = false;
         } else {

package/src/flow/models/base/PageModel/RootPageModel.tsx

@@ -162,7 +162,7 @@ RootPageModel.registerFlow({
         const route = ctx.routeRepository.getRouteBySchemaUid(ctx.model.parentId);
         ctx.model.setProps('routeId', route?.id);
         const routes: NocoBaseDesktopRoute[] = _.castArray(route?.children);
-        for (const route of routes.sort((a, b) => a.sort - b.sort)) {
+        for (const route of routes.filter(Boolean).sort((a, b) => (a.sort || 0) - (b.sort || 0))) {
           // 过滤掉隐藏的路由
           if (route.hideInMenu) {
             continue;

package/src/flow/models/blocks/filter-form/FilterFormBlockModel.tsx

@@ -32,7 +32,7 @@ import { BlockSceneEnum } from '../../base/BlockModel';
 import { FilterBlockModel } from '../../base/FilterBlockModel';
 import { FormComponent } from '../form/FormBlockModel';
 import { isEmptyValue } from '../form/value-runtime/utils';
-import { FilterManager } from '../filter-manager/FilterManager';
+import { FilterManager, type RefreshTargetsByFilterOptions } from '../filter-manager/FilterManager';
 import { FilterFormItemModel } from './FilterFormItemModel';
 import { clearLegacyDefaultValuesFromFilterFormModel } from './legacyDefaultValueMigration';
 import { findFormItemModelByFieldPath } from '../../../internal/utils/modelUtils';
@@ -54,6 +54,8 @@ export class FilterFormBlockModel extends FilterBlockModel<{
   autoTriggerFilter = true;
 
   private removeTargetBlockListener?: () => void;
+  private initialDefaultsPromise?: Promise<void>;
+  private initialRefreshHandledTargetIds = new Set<string>();
 
   get form() {
     return this.context.form;
@@ -82,13 +84,13 @@ export class FilterFormBlockModel extends FilterBlockModel<{
     this.context.defineProperty('blockModel', {
       value: this,
     });
-    this.context.defineMethod('refreshTargets', async () => {
+    this.context.defineMethod('refreshTargets', async (options?: RefreshTargetsByFilterOptions) => {
       const gridModel = this.subModels.grid;
       const fieldModels: FilterFormItemModel[] = gridModel.subModels.items;
-      if (fieldModels) {
-        fieldModels.forEach((fieldModel) => {
-          fieldModel?.doFilter?.();
-        });
+      const filterIds = fieldModels?.map((fieldModel) => fieldModel?.uid).filter(Boolean);
+      if (filterIds?.length) {
+        const filterManager: FilterManager = this.context.filterManager;
+        await filterManager.refreshTargetsByFilter(filterIds, options);
       }
     });
   }
@@ -124,9 +126,31 @@ export class FilterFormBlockModel extends FilterBlockModel<{
   }
 
   private async applyDefaultsAndInitialFilter() {
-    await this.ensureFilterItemsBeforeRender();
-    await this.applyFormDefaultValues();
-    await this.context.refreshTargets?.();
+    const prepared = await this.prepareInitialFilterValues();
+    if (prepared) {
+      await this.context.refreshTargets?.({ excludeTargetIds: this.initialRefreshHandledTargetIds });
+    }
+  }
+
+  async prepareInitialFilterValues() {
+    if (!this.form) {
+      return false;
+    }
+
+    if (!this.initialDefaultsPromise) {
+      this.initialDefaultsPromise = (async () => {
+        await this.ensureFilterItemsBeforeRender();
+        await this.applyFormDefaultValues();
+      })();
+    }
+
+    await this.initialDefaultsPromise;
+    return true;
+  }
+
+  markInitialTargetRefreshHandled(targetId: string) {
+    if (!targetId) return;
+    this.initialRefreshHandledTargetIds.add(targetId);
   }
 
   private async ensureFilterItemsBeforeRender() {