@nocobase/client-v2 2.3.0-beta.2 → 2.3.0-beta.21

package/src/flow/models/blocks/assign-form/AssignFormItemModel.tsx

@@ -10,7 +10,14 @@
 import React from 'react';
 import { Input } from 'antd';
 import { define, observable } from '@formily/reactive';
-import { FlowModelRenderer, FormItem, tExpr, EditableItemModel, jioToJoiSchema } from '@nocobase/flow-engine';
+import {
+  EditableItemModel,
+  FieldDeletePlaceholder,
+  FlowModelRenderer,
+  FormItem,
+  jioToJoiSchema,
+  tExpr,
+} from '@nocobase/flow-engine';
 // 无需类型导入（避免未使用的类型）
 import { FormItemModel } from '../form/FormItemModel';
 import { EditFormModel } from '../form/EditFormModel';
@@ -24,6 +31,7 @@ import {
   isDateLikeField,
   resolveDateVariableComponentProps,
 } from '../../../components/field-value-variable';
+import { isArrayValueField, normalizeAssignFormValue } from './assignFormValue';
 
 type AssignFormTempOriginField = {
   uid?: string;
@@ -105,8 +113,6 @@ export class AssignFormItemModel extends FormItemModel {
   }
 
   onInit(options: any) {
-    const initAssign = this.getStepParams('fieldSettings', 'assignValue')?.value;
-    if (typeof initAssign !== 'undefined') this.assignValue = initAssign;
     this.context.defineProperty('collectionField', {
       get: () => {
         const params = this.getStepParams('fieldSettings', 'init') || {};
@@ -115,6 +121,10 @@ export class AssignFormItemModel extends FormItemModel {
         return dsm?.getCollectionField?.(key);
       },
     });
+    const initAssign = this.getStepParams('fieldSettings', 'assignValue')?.value;
+    if (typeof initAssign !== 'undefined') {
+      this.assignValue = normalizeAssignFormValue(initAssign, isArrayValueField(this.collectionField));
+    }
 
     // 确保存在 subModels.field，便于沿用 FormItemModel 的组件切换/设置步骤（fieldComponent 等）
     const ctx: any = this.context;
@@ -160,11 +170,15 @@ export class AssignFormItemModel extends FormItemModel {
 
   getAssignedEntry(): [string, any] | null {
     const name = this.fieldPath;
-    if (!name) return null;
-    return [name, this.assignValue];
+    if (!name || !this.collectionField) return null;
+    return [name, normalizeAssignFormValue(this.assignValue, isArrayValueField(this.collectionField))];
   }
 
   render() {
+    if (!this.collectionField) {
+      return <FieldDeletePlaceholder />;
+    }
+
     // 与 FormItemModel.render 结构保持一致，仅替换内部渲染为 VariableInput + 常量编辑器
     const ctx: any = this.context;
     const collection = ctx.collection;
@@ -173,6 +187,7 @@ export class AssignFormItemModel extends FormItemModel {
     const fieldPath = this.fieldPath;
     const originField = this.subModels?.field as AssignFormTempOriginField | undefined;
     const tempFieldRefreshKey = getAssignFormTempFieldRefreshKey(originField);
+    const arrayValueField = isArrayValueField(this.collectionField);
 
     const FieldRow: React.FC = () => {
       const [tempRoot, setTempRoot] = React.useState<any>(null);
@@ -241,6 +256,14 @@ export class AssignFormItemModel extends FormItemModel {
         fm?.dispatchEvent?.('beforeRender', undefined, { sequential: true, useCache: true });
         // 为本地枚举型字段补全可选项（仅在未显式传入 options 时处理）
         ensureOptionsFromUiSchemaEnumIfAbsent(fm as any, cfForMultiple as any);
+        // `mode` is the antd Select switch for multi-select. It is normally injected by
+        // `collectionField.getComponentProps()`, which the temp field does not apply.
+        // Apply the fallback after `beforeRender` so field flows keep precedence; a
+        // schema-provided mode is used when present, otherwise default to `multiple`.
+        if (cfForMultiple?.interface === 'multipleSelect' && fm?.props?.mode === undefined) {
+          const schemaMode = cfForMultiple?.uiSchema?.['x-component-props']?.mode as string | undefined;
+          fm?.setProps?.({ mode: schemaMode ?? 'multiple' });
+        }
         if (!fm?.props?.fieldNames && cfForMultiple?.targetCollection) {
           const targetCol = cfForMultiple.targetCollection;
           const valueKey = cfForMultiple?.targetKey || targetCol?.filterTargetKey || 'id';
@@ -257,16 +280,17 @@ export class AssignFormItemModel extends FormItemModel {
       const ConstantValueEditor: React.FC<any> = (inputProps: any) => {
         React.useEffect(() => {
           if (!tempRoot) return;
+          const isArrayField = isArrayValueField(this.collectionField);
           // 同步根 props（变量输入的受控 value/onChange）
           tempRoot.setProps?.({ ...inputProps });
           // 同步到具体字段模型，确保字段组件能触发 onChange
           const fm = tempRoot?.subModels?.fields?.[0];
           if (fm) {
             fm.setProps?.({
-              value: inputProps?.value,
+              value: normalizeAssignFormValue(inputProps?.value, isArrayField),
               onChange: (...args: unknown[]) => {
                 const nextArg = args && args.length ? args[0] : undefined;
-                const nextValue = normalizeAssignFormInputValue(nextArg);
+                const nextValue = normalizeAssignFormValue(normalizeAssignFormInputValue(nextArg), isArrayField);
                 fm.setProps?.({ value: nextValue });
                 this.assignValue = nextValue;
                 inputProps?.onChange?.(nextValue);
@@ -319,20 +343,24 @@ export class AssignFormItemModel extends FormItemModel {
           {...this.props}
           label={labelText}
           name={namePath}
-          initialValue={this.assignValue}
+          initialValue={normalizeAssignFormValue(this.assignValue, arrayValueField)}
           valuePropName="__assign_value__"
           trigger="__assign_trigger__"
           validateTrigger="__assign_trigger__"
         >
           {React.createElement((formBindingProps: any) => {
             const formValue = formBindingProps?.__assign_value__;
-            const mergedValue = typeof formValue === 'undefined' ? this.assignValue : formValue;
+            const mergedValue = normalizeAssignFormValue(
+              typeof formValue === 'undefined' ? this.assignValue : formValue,
+              arrayValueField,
+            );
             return (
               <FieldValueVariableInput
                 value={mergedValue}
                 onChange={(v) => {
-                  this.assignValue = v;
-                  formBindingProps?.__assign_trigger__?.(v);
+                  const nextValue = normalizeAssignFormValue(v, arrayValueField);
+                  this.assignValue = nextValue;
+                  formBindingProps?.__assign_trigger__?.(nextValue);
                 }}
                 baseMetaTree={baseMetaTree}
                 constantComponent={ConstantValueEditor}
@@ -392,7 +420,7 @@ AssignFormItemModel.registerFlow({
       },
       defaultParams: (ctx) => {
         return {
-          label: (ctx.model as any).collectionField.title,
+          label: (ctx.model as any).collectionField?.title || (ctx.model as any).fieldPath,
         };
       },
       handler(ctx, params) {

package/src/flow/models/blocks/assign-form/__tests__/assignFieldValuesFlow.editor.test.tsx

@@ -47,6 +47,146 @@ class MockFlowModelRepository implements IFlowModelRepository {
 }
 
 describe('assignFieldValuesFlow (editor)', () => {
+  it('shows the deleted-field placeholder for a stale assigned value', async () => {
+    const engine = new FlowEngine();
+    engine.setModelRepository(new MockFlowModelRepository());
+    engine.registerModels({
+      AssignFormModel,
+      AssignFormGridModel,
+      AssignFormItemModel,
+      InputFieldModel,
+      VariableFieldFormModel,
+    });
+    engine.context.defineProperty('location', { value: { search: '' } });
+    engine.context.defineProperty('themeToken', { value: { marginLG: 24 } });
+    engine.context.defineProperty('flowSettingsEnabled', { value: true });
+
+    const main = engine.context.dataSourceManager.getDataSource('main');
+    main.addCollection({
+      name: 'users',
+      fields: [{ name: 'nickname', type: 'string', interface: 'input' }],
+    });
+    const users = engine.context.dataSourceManager.getCollection('main', 'users');
+
+    const action = engine.createModel({
+      use: 'FlowModel',
+      uid: 'act-assign-deleted-field',
+    });
+    action.setStepParams('assignSettings', 'assignFieldValues', {
+      assignedValues: { deletedField: 'stale value' },
+    });
+    action.context.defineProperty('blockModel', { value: { collection: users } });
+
+    const step = createAssignFieldValuesStep({ settingsFlowKey: 'assignSettings' });
+    const Editor = step.uiSchema().editor?.['x-component'] as React.ComponentType;
+    const flowSettingsCtx = new FlowRuntimeContext(action, 'assignSettings', 'settings');
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>
+            <FlowSettingsContextProvider value={flowSettingsCtx}>
+              <Editor />
+            </FlowSettingsContextProvider>
+          </App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByRole('button', { name: /Fields/ })).toBeInTheDocument();
+      expect(screen.getByText(/deletedField.*may have been deleted/)).toBeInTheDocument();
+      const form = engine.findModelByParentId<AssignFormModel>(action.uid, 'assignForm');
+      expect(form).toBeDefined();
+      expect(form?.subModels.grid.subModels.items || []).toHaveLength(1);
+      expect(form?.getAssignedValues()).toEqual({});
+    });
+  });
+
+  it('shows the standard deleted-field placeholder for a persisted assigned field model', async () => {
+    const engine = new FlowEngine();
+    engine.setModelRepository(new MockFlowModelRepository());
+    engine.registerModels({
+      AssignFormModel,
+      AssignFormGridModel,
+      AssignFormItemModel,
+      InputFieldModel,
+      VariableFieldFormModel,
+    });
+    engine.context.defineProperty('location', { value: { search: '' } });
+    engine.context.defineProperty('themeToken', { value: { marginLG: 24 } });
+    engine.context.defineProperty('flowSettingsEnabled', { value: true });
+
+    const main = engine.context.dataSourceManager.getDataSource('main');
+    main.addCollection({
+      name: 'users',
+      fields: [{ name: 'nickname', type: 'string', interface: 'input' }],
+    });
+    const users = engine.context.dataSourceManager.getCollection('main', 'users');
+
+    const action = engine.createModel({
+      use: 'FlowModel',
+      uid: 'act-assign-persisted-deleted-field',
+    });
+    action.setStepParams('assignSettings', 'assignFieldValues', {
+      assignedValues: { deletedField: 'stale value' },
+    });
+    action.context.defineProperty('blockModel', { value: { collection: users } });
+
+    const form = engine.createModel<AssignFormModel>({
+      use: 'AssignFormModel',
+      uid: 'form-assign-persisted-deleted-field',
+      parentId: action.uid,
+      subKey: 'assignForm',
+      stepParams: {
+        resourceSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'users',
+          },
+        },
+      },
+    });
+    action.setSubModel('assignForm', form);
+    form.subModels.grid.addSubModel('items', {
+      use: 'AssignFormItemModel',
+      uid: 'item-assign-persisted-deleted-field',
+      stepParams: {
+        fieldSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'users',
+            fieldPath: 'deletedField',
+          },
+          assignValue: { value: 'stale value' },
+        },
+      },
+    });
+    form.subModels.grid.resetRows(true);
+
+    const step = createAssignFieldValuesStep({ settingsFlowKey: 'assignSettings' });
+    const Editor = step.uiSchema().editor?.['x-component'] as React.ComponentType;
+    const flowSettingsCtx = new FlowRuntimeContext(action, 'assignSettings', 'settings');
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>
+            <FlowSettingsContextProvider value={flowSettingsCtx}>
+              <Editor />
+            </FlowSettingsContextProvider>
+          </App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText(/deletedField.*may have been deleted/)).toBeInTheDocument();
+      expect(form.subModels.grid.subModels.items).toHaveLength(1);
+      expect(form.getAssignedValues()).toEqual({});
+    });
+  });
+
   it('repairs AssignFormModel resource init and clears cached collection', async () => {
     const engine = new FlowEngine();
     engine.setModelRepository(new MockFlowModelRepository());

package/src/flow/models/blocks/assign-form/__tests__/assignFieldValuesFlow.multipleSelect.test.tsx

@@ -0,0 +1,216 @@
+/**
+ * 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 { App, ConfigProvider } from 'antd';
+import { describe, expect, it } from 'vitest';
+import { render, waitFor } from '@nocobase/test/client';
+import {
+  FlowEngine,
+  FlowEngineProvider,
+  FlowRuntimeContext,
+  FlowSettingsContextProvider,
+  type FlowModel,
+  type IFlowModelRepository,
+} from '@nocobase/flow-engine';
+import { AssignFormGridModel } from '../AssignFormGridModel';
+import { AssignFormItemModel } from '../AssignFormItemModel';
+import { AssignFormModel } from '../AssignFormModel';
+import { createAssignFieldValuesStep } from '../assignFieldValuesFlow';
+import { InputFieldModel } from '../../../fields/InputFieldModel';
+import { SelectFieldModel } from '../../../fields/SelectFieldModel';
+import { VariableFieldFormModel } from '../../../fields/VariableFieldFormModel';
+
+class MockFlowModelRepository implements IFlowModelRepository {
+  async findOne(): Promise<Record<string, any> | null> {
+    return null;
+  }
+
+  async save(model: FlowModel): Promise<Record<string, any>> {
+    return { uid: model.uid };
+  }
+
+  async destroy(): Promise<boolean> {
+    return true;
+  }
+
+  async move(): Promise<void> {}
+
+  async duplicate(): Promise<Record<string, any> | null> {
+    return null;
+  }
+}
+
+function createEngine() {
+  const engine = new FlowEngine();
+  engine.setModelRepository(new MockFlowModelRepository());
+  engine.registerModels({
+    AssignFormModel,
+    AssignFormGridModel,
+    AssignFormItemModel,
+    InputFieldModel,
+    SelectFieldModel,
+    VariableFieldFormModel,
+  });
+  engine.context.defineProperty('location', { value: { search: '' } });
+  engine.context.defineProperty('themeToken', { value: { marginLG: 24 } });
+  return engine;
+}
+
+function addMultipleSelectCollection(engine: FlowEngine) {
+  const dsm = engine.context.dataSourceManager;
+  const main = dsm.getDataSource('main');
+  main.addCollection({
+    name: 'assign_multiple_select',
+    fields: [
+      {
+        name: 'tags',
+        type: 'array',
+        interface: 'multipleSelect',
+        uiSchema: {
+          type: 'array',
+          'x-component': 'Select',
+          'x-component-props': { mode: 'multiple' },
+          enum: [
+            { value: 'a', label: 'A' },
+            { value: 'b', label: 'B' },
+          ],
+        },
+      },
+      {
+        // Fields created before the interface default was persisted may miss `mode`.
+        name: 'legacyTags',
+        type: 'array',
+        interface: 'multipleSelect',
+        uiSchema: {
+          type: 'array',
+          'x-component': 'Select',
+          enum: [{ value: 'c', label: 'C' }],
+        },
+      },
+      {
+        name: 'tagMode',
+        type: 'array',
+        interface: 'multipleSelect',
+        uiSchema: {
+          type: 'array',
+          'x-component': 'Select',
+          'x-component-props': { mode: 'tags' },
+          enum: [{ value: 't', label: 'T' }],
+        },
+      },
+      {
+        name: 'single',
+        type: 'string',
+        interface: 'select',
+        uiSchema: {
+          type: 'string',
+          'x-component': 'Select',
+          enum: [{ value: 'x', label: 'X' }],
+        },
+      },
+      { name: 'nickname', type: 'string', interface: 'input' },
+    ],
+  });
+  return dsm.getCollection('main', 'assign_multiple_select');
+}
+
+async function renderAssignEditor(engine: FlowEngine, action: FlowModel) {
+  const step = createAssignFieldValuesStep({ settingsFlowKey: 'assignSettings' });
+  const Editor = step.uiSchema().editor?.['x-component'] as React.ComponentType;
+  const flowSettingsCtx = new FlowRuntimeContext(action as any, 'assignSettings', 'settings');
+
+  render(
+    <FlowEngineProvider engine={engine}>
+      <ConfigProvider>
+        <App>
+          <FlowSettingsContextProvider value={flowSettingsCtx}>
+            <Editor />
+          </FlowSettingsContextProvider>
+        </App>
+      </ConfigProvider>
+    </FlowEngineProvider>,
+  );
+}
+
+describe('assignFieldValuesFlow multipleSelect', () => {
+  it('renders multipleSelect as multi select and normalizes historical scalar values', async () => {
+    const engine = createEngine();
+    const collection = addMultipleSelectCollection(engine);
+
+    const action = engine.createModel({ use: 'FlowModel', uid: 'act-assign-multiple-select' });
+    action.setStepParams('assignSettings', 'assignFieldValues', {
+      assignedValues: {
+        tags: 'a',
+        legacyTags: 'c',
+        tagMode: 't',
+        single: 'x',
+        nickname: 'hello',
+      },
+    });
+    action.context.defineProperty('blockModel', { value: { collection } });
+
+    const tempFields: any[] = [];
+    const originalCreateModel = engine.createModel.bind(engine);
+    (engine as any).createModel = (options: any) => {
+      const model = originalCreateModel(options);
+      if (options?.use === 'VariableFieldFormModel') {
+        tempFields.push(model);
+      }
+      return model;
+    };
+
+    await renderAssignEditor(engine, action);
+
+    await waitFor(() => {
+      const form = engine.findModelByParentId<AssignFormModel>(action.uid, 'assignForm');
+      expect(form?.subModels.grid.subModels.items || []).toHaveLength(5);
+    });
+
+    const form = engine.findModelByParentId<AssignFormModel>(action.uid, 'assignForm');
+    await waitFor(() => {
+      expect(form?.getAssignedValues()).toEqual({
+        tags: ['a'],
+        legacyTags: ['c'],
+        tagMode: ['t'],
+        single: 'x',
+        nickname: 'hello',
+      });
+    });
+
+    await waitFor(() => {
+      // All three multipleSelect fields must render as antd multi select, including the
+      // field without schema `mode`; the normal select stays single.
+      expect(document.querySelectorAll('.ant-select-multiple')).toHaveLength(3);
+      expect(document.querySelectorAll('.ant-select-single').length).toBeGreaterThanOrEqual(1);
+    });
+
+    const findTempField = (fieldPath: string) =>
+      tempFields
+        .map((root) => root?.subModels?.fields?.[0])
+        .find((field) => field?.getStepParams?.('fieldSettings', 'init')?.fieldPath === fieldPath);
+    await waitFor(() => {
+      expect(findTempField('tags')?.props?.onChange).toBeTypeOf('function');
+      expect(findTempField('tags')?.props?.mode).toBe('multiple');
+      expect(findTempField('legacyTags')?.props?.mode).toBe('multiple');
+      // An explicit schema mode must be preserved by the fallback.
+      expect(findTempField('tagMode')?.props?.mode).toBe('tags');
+    });
+
+    findTempField('tags').props.onChange(['a', 'b']);
+    await waitFor(() => {
+      expect(form?.getAssignedValues()).toMatchObject({ tags: ['a', 'b'], single: 'x' });
+    });
+
+    findTempField('tags').props.onChange('');
+    await waitFor(() => {
+      expect(form?.getAssignedValues()).toMatchObject({ tags: [] });
+    });
+  });
+});

package/src/flow/models/blocks/assign-form/__tests__/assignFormValue.test.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { describe, expect, it } from 'vitest';
+import { isArrayValueField, normalizeAssignFormValue } from '../assignFormValue';
+
+describe('assignFormValue', () => {
+  it('detects array-valued fields', () => {
+    expect(isArrayValueField({ interface: 'multipleSelect' })).toBe(true);
+    expect(isArrayValueField({ interface: 'checkboxGroup' })).toBe(true);
+    expect(isArrayValueField({ uiSchema: { type: 'array' } })).toBe(true);
+    expect(isArrayValueField({ interface: 'select', uiSchema: { type: 'string' } })).toBe(false);
+    expect(isArrayValueField(undefined)).toBe(false);
+  });
+
+  it('wraps scalar constants for array fields', () => {
+    expect(normalizeAssignFormValue('a', true)).toEqual(['a']);
+    expect(normalizeAssignFormValue(0, true)).toEqual([0]);
+    expect(normalizeAssignFormValue(false, true)).toEqual([false]);
+    expect(normalizeAssignFormValue(['a', 'b'], true)).toEqual(['a', 'b']);
+  });
+
+  it('keeps non-constant and empty values unchanged', () => {
+    expect(normalizeAssignFormValue('', true)).toEqual([]);
+    expect(normalizeAssignFormValue(null, true)).toBeNull();
+    expect(normalizeAssignFormValue(undefined, true)).toBeUndefined();
+    expect(normalizeAssignFormValue('{{ ctx.record.name }}', true)).toBe('{{ ctx.record.name }}');
+    expect(normalizeAssignFormValue({ code: 'return 1;' }, true)).toEqual({ code: 'return 1;' });
+  });
+
+  it('does not touch non-array fields', () => {
+    expect(normalizeAssignFormValue('a', false)).toBe('a');
+    expect(normalizeAssignFormValue(['a'], false)).toEqual(['a']);
+  });
+});

package/src/flow/models/blocks/assign-form/assignFormValue.ts

@@ -0,0 +1,64 @@
+/**
+ * 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 { isRunJSValue, isVariableExpression } from '@nocobase/flow-engine';
+
+type ArrayValueCollectionField =
+  | {
+      interface?: string;
+      uiSchema?: {
+        type?: string;
+      } | null;
+    }
+  | null
+  | undefined;
+
+/**
+ * Fields whose stored value is an array. Besides `multipleSelect`/`checkboxGroup`,
+ * some legacy fields declare `uiSchema.type === 'array'` explicitly.
+ */
+export function isArrayValueField(collectionField: ArrayValueCollectionField): boolean {
+  if (!collectionField) {
+    return false;
+  }
+  if (collectionField.interface === 'multipleSelect' || collectionField.interface === 'checkboxGroup') {
+    return true;
+  }
+  return collectionField.uiSchema?.type === 'array';
+}
+
+/**
+ * Normalize a constant assignment value for array-valued fields.
+ *
+ * Historical configurations may store a scalar (before the multi-select control
+ * was rendered correctly), so wrap it into an array instead of submitting a
+ * string to the server. Variable expressions, RunJS values, Null and empty
+ * values are kept as-is so the assignment mode is not changed.
+ */
+export function normalizeAssignFormValue(value: unknown, arrayValueField: boolean): unknown {
+  if (!arrayValueField) {
+    return value;
+  }
+  if (isVariableExpression(value) || isRunJSValue(value)) {
+    return value;
+  }
+  if (value === '') {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (value === null || typeof value === 'undefined') {
+    return value;
+  }
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return [value];
+  }
+  return value;
+}

package/src/flow/models/blocks/filter-form/__tests__/FilterFormGridModel.toggleFormFieldsCollapse.test.ts

@@ -21,6 +21,35 @@ describe('FilterFormGridModel.toggleFormFieldsCollapse', () => {
     engine.registerModels({ FilterFormGridModel });
   });
 
+  it.each([false, true])('preserves collapsed fields in mobile layout with settings enabled: %s', (settingsEnabled) => {
+    engine.flowSettings[settingsEnabled ? 'enable' : 'disable']();
+    const rows = {
+      first: [['field-1']],
+      second: [['field-2']],
+      third: [['field-3']],
+    };
+    const model = engine.createModel<FilterFormGridModel>({
+      uid: 'mobile-filter-grid',
+      use: 'FilterFormGridModel',
+      props: { rows },
+      subModels: {
+        items: ['field-1', 'field-2', 'field-3'].map((uid) => ({ use: 'FlowModel', uid })),
+      },
+    });
+    model.context.defineProperty('isMobileLayout', { value: true });
+    model.setStepParams(GRID_FLOW_KEY, GRID_STEP, { rows });
+    type VisibleLayoutReader = { getVisibleLayout(): { rows: Record<string, string[][]> } };
+    const renderedItems = () =>
+      Object.values((model as unknown as VisibleLayoutReader).getVisibleLayout().rows).flat(2);
+
+    expect(renderedItems()).toEqual(['field-1', 'field-2', 'field-3']);
+    model.toggleFormFieldsCollapse(true, 1);
+    expect(renderedItems()).toEqual(['field-1']);
+    model.toggleFormFieldsCollapse(false, 1);
+    expect(renderedItems()).toEqual(['field-1', 'field-2', 'field-3']);
+    expect(model.getStepParams(GRID_FLOW_KEY, GRID_STEP).rows).toEqual(rows);
+  });
+
   it('uses rowOrder from the full layout when collapsing after reorder', () => {
     const model = engine.createModel<FilterFormGridModel>({
       uid: 'filter-grid-collapse-order',

package/src/flow/models/blocks/filter-form/fields/FieldComponentProps.tsx

@@ -351,7 +351,7 @@ export const FieldComponentProps: React.FC<{ fieldModel: string; source: string[
       <FormItem label={t('Options')}>
         <Space direction="vertical" size={8} style={{ width: '100%' }}>
           {options.map((option: any, index: number) => (
-            <Space key={`${option.value}-${index}`} style={{ width: '100%' }} size={8} wrap align="start">
+            <Space key={index} style={{ width: '100%' }} size={8} wrap align="start">
               <Input
                 style={{ flex: 1, minWidth: 120 }}
                 placeholder={t('Option label')}