@nocobase/client-v2 2.2.0-alpha.7 → 2.2.0-alpha.9

package/src/flow/actions/__tests__/linkageRules.tab.test.ts

@@ -0,0 +1,171 @@
+/**
+ * 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 { ActionScene } from '@nocobase/flow-engine';
+import { describe, expect, it, vi } from 'vitest';
+
+import * as registeredActions from '../index';
+import * as linkageActions from '../linkageRules';
+
+const tabLinkageRules = (linkageActions as Record<string, unknown>).tabLinkageRules as
+  | typeof linkageActions.menuLinkageRules
+  | undefined;
+const linkageSetTabProps = (linkageActions as Record<string, unknown>).linkageSetTabProps as
+  | typeof linkageActions.linkageSetMenuItemProps
+  | undefined;
+
+function createRuntime() {
+  let matched = true;
+  const setProps = vi.fn(function (this: { props: Record<string, unknown> }, props: Record<string, unknown>) {
+    this.props = {
+      ...this.props,
+      ...props,
+    };
+  });
+  const setHidden = vi.fn(function (this: { hidden: boolean }, value: boolean) {
+    this.hidden = value;
+  });
+  const model = {
+    uid: 'tab-1',
+    props: {} as Record<string, unknown>,
+    hidden: false,
+    __allModels: [],
+    setProps,
+    setHidden,
+  };
+  const ctx = {
+    app: { jsonLogic: { apply: () => matched } },
+    model,
+    t: (text: string) => text,
+    getAction: (name: string) => (name === 'linkageSetTabProps' ? linkageSetTabProps : undefined),
+    resolveJsonTemplate: vi.fn(async (value: unknown) => value),
+  };
+
+  return {
+    ctx,
+    model,
+    setMatched(value: boolean) {
+      matched = value;
+    },
+  };
+}
+
+const hideRule = {
+  value: [
+    {
+      key: 'rule-1',
+      title: 'Hide tab',
+      enable: true,
+      condition: {
+        logic: '$and',
+        items: [{ path: 'status', operator: '$eq', value: 'visible' }],
+      },
+      actions: [
+        {
+          key: 'action-1',
+          name: 'linkageSetTabProps',
+          params: { value: 'hidden' },
+        },
+      ],
+    },
+  ],
+};
+
+describe('tab linkage rules', () => {
+  it('should append the tab linkage scene without changing existing scene values', () => {
+    const scenes = ActionScene as unknown as Record<string, number>;
+
+    expect(scenes.MENU_LINKAGE_RULES).toBe(7);
+    expect(scenes.TAB_LINKAGE_RULES).toBe(8);
+    expect(scenes.TAB_LINKAGE_RULES).toBe(Math.max(...Object.values(scenes).filter(Number.isInteger)));
+  });
+
+  it('should register tab linkage actions from the actions entry', () => {
+    expect((registeredActions as Record<string, unknown>).tabLinkageRules).toBe(tabLinkageRules);
+    expect((registeredActions as Record<string, unknown>).linkageSetTabProps).toBe(linkageSetTabProps);
+    expect(tabLinkageRules).toBeDefined();
+    expect(linkageSetTabProps).toBeDefined();
+  });
+
+  it('should expose tab state and runjs actions in ui schema', () => {
+    expect(tabLinkageRules).toBeDefined();
+    expect(linkageSetTabProps).toBeDefined();
+
+    const schema = tabLinkageRules?.uiSchema?.({
+      getActions: () =>
+        new Map([
+          ['linkageSetTabProps', linkageSetTabProps],
+          ['linkageRunjs', linkageActions.linkageRunjs],
+          ['linkageSetMenuItemProps', linkageActions.linkageSetMenuItemProps],
+        ]),
+    } as never) as Record<string, Record<string, Record<string, unknown>>> | undefined;
+
+    expect(schema?.value?.['x-component-props']?.supportedActions).toEqual(['linkageSetTabProps', 'linkageRunjs']);
+    expect(linkageSetTabProps?.scene).toBe((ActionScene as unknown as Record<string, number>).TAB_LINKAGE_RULES);
+    expect(linkageActions.linkageRunjs.scene).toContain(
+      (ActionScene as unknown as Record<string, number>).TAB_LINKAGE_RULES,
+    );
+  });
+
+  it('should hide the tab when the condition matches and restore it when the condition misses', async () => {
+    expect(tabLinkageRules).toBeDefined();
+    const runtime = createRuntime();
+
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.hidden).toBe(true);
+
+    runtime.setMatched(false);
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.hidden).toBe(false);
+  });
+
+  it('should restore the tab when linkage rules are cleared', async () => {
+    expect(tabLinkageRules).toBeDefined();
+    const runtime = createRuntime();
+
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.hidden).toBe(true);
+
+    await tabLinkageRules?.handler(runtime.ctx as never, { value: [] });
+    expect(runtime.model.hidden).toBe(false);
+  });
+
+  it('should not restore stale tab props while applying or clearing visibility rules', async () => {
+    expect(tabLinkageRules).toBeDefined();
+    const runtime = createRuntime();
+    runtime.model.props = {
+      title: 'Original title',
+      icon: 'original-icon',
+      route: { options: { badge: 'original' } },
+    };
+
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.hidden).toBe(true);
+
+    const updatedProps = {
+      title: 'Updated title',
+      icon: 'updated-icon',
+      route: { options: { badge: 'updated' } },
+    };
+    runtime.model.props = updatedProps;
+
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.props).toMatchObject(updatedProps);
+    expect(runtime.model.hidden).toBe(true);
+
+    runtime.setMatched(false);
+    await tabLinkageRules?.handler(runtime.ctx as never, hideRule);
+    expect(runtime.model.props).toMatchObject(updatedProps);
+    expect(runtime.model.hidden).toBe(false);
+
+    await tabLinkageRules?.handler(runtime.ctx as never, { value: [] });
+    expect(runtime.model.props).toMatchObject(updatedProps);
+    expect(runtime.model.hidden).toBe(false);
+  });
+});

package/src/flow/actions/__tests__/linkageRulesRefresh.test.ts

@@ -135,11 +135,15 @@ describe('linkageRulesRefresh action', () => {
     expect(handler).toHaveBeenCalledWith(ctx, { value: ['master-mounted'] });
   });
 
-  it('runs linkage action on master model when forks exist in design mode', async () => {
+  it('skips master model when forks can handle flow in design mode', async () => {
     const handler = vi.fn(async () => {});
     const model: any = {
       isFork: false,
-      forks: new Set([{}]),
+      forks: new Set([
+        {
+          getFlow: vi.fn(() => ({})),
+        },
+      ]),
       getFlow: vi.fn(() => ({})),
       getStepParams: vi.fn(() => ({ value: ['master'] })),
       context: {
@@ -157,7 +161,7 @@ describe('linkageRulesRefresh action', () => {
       flowKey: 'buttonSettings',
     });
 
-    expect(handler).toHaveBeenCalledWith(ctx, { value: ['master'] });
+    expect(handler).not.toHaveBeenCalled();
   });
 
   it('runs linkage action on fork model and resolves params', async () => {

package/src/flow/actions/index.ts

@@ -43,10 +43,12 @@ export {
   linkageSetDetailsFieldProps,
   actionLinkageRules,
   menuLinkageRules,
+  tabLinkageRules,
   blockLinkageRules,
   linkageSetBlockProps,
   linkageSetActionProps,
   linkageSetMenuItemProps,
+  linkageSetTabProps,
   linkageSetFieldProps,
   subFormLinkageSetFieldProps,
   linkageAssignField,

package/src/flow/actions/linkageRules.tsx

@@ -731,6 +731,41 @@ export const linkageSetMenuItemProps = defineAction({
   },
 });
 
+export const linkageSetTabProps = defineAction({
+  name: 'linkageSetTabProps',
+  title: tExpr('Set tab state'),
+  scene: ActionScene.TAB_LINKAGE_RULES,
+  sort: 100,
+  uiSchema: {
+    value: {
+      type: 'string',
+      'x-component': (props) => {
+        const { value, onChange } = props;
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const ctx = useFlowContext();
+        const t = ctx.model.translate.bind(ctx.model);
+
+        return (
+          <Select
+            value={value}
+            onChange={onChange}
+            placeholder={t('Please select state')}
+            style={{ width: '100%' }}
+            options={[
+              { label: t('Visible'), value: 'visible' },
+              { label: t('Hidden'), value: 'hidden' },
+            ]}
+            allowClear
+          />
+        );
+      },
+    },
+  },
+  handler(ctx, { value, setProps }) {
+    setProps(ctx.model, { hiddenModel: value === 'hidden' });
+  },
+});
+
 export const linkageSetFieldProps = defineAction({
   name: 'linkageSetFieldProps',
   title: tExpr('Set field state'),
@@ -1339,6 +1374,7 @@ export const linkageRunjs = defineAction({
     ActionScene.FIELD_LINKAGE_RULES,
     ActionScene.ACTION_LINKAGE_RULES,
     ActionScene.MENU_LINKAGE_RULES,
+    ActionScene.TAB_LINKAGE_RULES,
     ActionScene.DETAILS_FIELD_LINKAGE_RULES,
     ActionScene.SUB_FORM_FIELD_LINKAGE_RULES,
   ],
@@ -2169,17 +2205,30 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
               }
             : props;
 
-        // 存储原始值，用于恢复
-        if (!model.__originalProps) {
-          model.__originalProps = {
-            hiddenModel: model.hidden,
-            hiddenText: undefined,
-            disabled: undefined,
-            required: undefined,
-            hidden: undefined,
-            ...model.props,
-          };
-        }
+        // 只记录联动实际控制的属性，避免之后恢复状态时把标题、路由等无关的新配置回滚到旧快照。
+        const originalProps = model.__originalProps || (model.__originalProps = {});
+        const rememberOriginalProp = (key: string, value: unknown) => {
+          if (!Object.prototype.hasOwnProperty.call(originalProps, key)) {
+            originalProps[key] = value;
+          }
+        };
+        Object.keys(normalizedProps || {}).forEach((key) => {
+          if (key === 'hiddenModel') {
+            rememberOriginalProp(
+              key,
+              Object.prototype.hasOwnProperty.call(model.props || {}, key) ? model.props?.[key] : model.hidden,
+            );
+            return;
+          }
+
+          rememberOriginalProp(key, model.props?.[key]);
+          if (key === 'hiddenText') {
+            rememberOriginalProp('title', model.props?.title);
+          }
+          if (key === 'required') {
+            rememberOriginalProp('rules', model.props?.rules);
+          }
+        });
 
         // 临时存起来，遍历完所有规则后，再统一处理
         patchPropsByModel.set(model, {
@@ -2463,6 +2512,32 @@ export const menuLinkageRules = defineAction({
   },
 });
 
+export const tabLinkageRules = defineAction({
+  name: 'tabLinkageRules',
+  title: tExpr('Tab linkage rules'),
+  uiMode: 'embed',
+  uiSchema(ctx) {
+    return {
+      value: {
+        type: 'array',
+        'x-component': LinkageRulesUI,
+        'x-component-props': {
+          supportedActions: getSupportedActions(ctx, ActionScene.TAB_LINKAGE_RULES),
+          title: tExpr('Tab linkage rules'),
+        },
+      },
+    };
+  },
+  defaultParams: {
+    value: [],
+  },
+  useRawParams: true,
+  handler: async (ctx, params) => {
+    const resolved = await resolveLinkageRulesParamsPreservingRunJsScripts(ctx, params);
+    return commonLinkageRulesHandler(ctx, resolved);
+  },
+});
+
 export const fieldLinkageRules = defineAction({
   name: 'fieldLinkageRules',
   title: tExpr('Field linkage rules'),

package/src/flow/actions/linkageRulesRefresh.tsx

@@ -35,12 +35,8 @@ export const linkageRulesRefresh = defineAction({
     // Prefer running on the current model; fallback to blockModel when the current model doesn't own the flow.
     if (!hasFlow) return;
 
-    // In runtime, only skip master when there are mounted forks that can handle the same flow.
+    // Skip master when unmounted forks can handle the same flow.
     // Otherwise master is likely the rendered model and still needs refresh.
-    // In design mode, always refresh master so the currently edited model state stays in sync.
-    const flowSettingsEnabled = Boolean(
-      (ctx as any)?.flowSettingsEnabled || (model as any)?.context?.flowSettingsEnabled,
-    );
     const hasForkWithFlow =
       !model?.isFork &&
       !!model?.forks?.size &&
@@ -49,7 +45,7 @@ export const linkageRulesRefresh = defineAction({
         return !!fork?.getFlow?.(flowKey);
       });
     const isMasterMounted = Boolean((model as any)?.context?.ref?.current);
-    if (hasForkWithFlow && !isMasterMounted && !flowSettingsEnabled) {
+    if (hasForkWithFlow && !isMasterMounted) {
       return;
     }
 

package/src/flow/components/FieldAssignValueInput.tsx

@@ -42,6 +42,12 @@ import { normalizeFilterValueByOperator } from '../models/blocks/filter-form/val
 import { FieldAssignExactDatePicker, type ExactDatePickerMode } from './FieldAssignExactDatePicker';
 import { limitAssociationMetaTree } from './filter/metaTreeAssociationDepth';
 
+type VariableInputConverters = {
+  renderInputComponent?: (metaTreeNode: MetaTreeNode | null) => React.ComponentType<any> | null;
+  resolvePathFromValue?: (value: any) => string[] | undefined;
+  resolveValueFromPath?: (metaTreeNode: MetaTreeNode) => any;
+};
+
 const DATE_FIELD_INTERFACES = new Set(['date', 'datetime', 'datetimeNoTz', 'createdAt', 'updatedAt', 'unixTimestamp']);
 
 const TZ_AWARE_DATE_INTERFACES = new Set(['datetime', 'createdAt', 'updatedAt', 'unixTimestamp']);
@@ -345,6 +351,7 @@ interface Props {
   allowRunJS?: boolean;
   maxAssociationFieldDepth?: number;
   disabled?: boolean;
+  variableConverters?: VariableInputConverters;
 }
 
 type ResolvedFieldContext = {
@@ -718,6 +725,7 @@ export const FieldAssignValueInput: React.FC<Props> = ({
   allowRunJS = true,
   maxAssociationFieldDepth = 2,
   disabled = false,
+  variableConverters,
 }) => {
   const flowCtx = useFlowContext<FlowModelContext>();
   const normalizeEventValue = React.useCallback((eventOrValue: unknown) => {
@@ -1511,7 +1519,12 @@ export const FieldAssignValueInput: React.FC<Props> = ({
       clearValue={''}
       disabled={disabled}
       converters={{
+        ...variableConverters,
         renderInputComponent: (meta) => {
+          const external = variableConverters?.renderInputComponent?.(meta ?? null);
+          if (external) {
+            return external;
+          }
           const firstPath = meta?.paths?.[0];
           if (firstPath === 'constant') return ConstantEditor;
           if (firstPath === 'null') return NullComponent;
@@ -1519,6 +1532,10 @@ export const FieldAssignValueInput: React.FC<Props> = ({
           return null;
         },
         resolveValueFromPath: (item) => {
+          const external = variableConverters?.resolveValueFromPath?.(item);
+          if (external !== undefined) {
+            return external;
+          }
           const firstPath = item?.paths?.[0];
           if (firstPath === 'constant') {
             return useDateVariableConstant ? { type: 'today' } : '';
@@ -1528,6 +1545,10 @@ export const FieldAssignValueInput: React.FC<Props> = ({
           return undefined;
         },
         resolvePathFromValue: (currentValue) => {
+          const external = variableConverters?.resolvePathFromValue?.(currentValue);
+          if (external !== undefined) {
+            return external;
+          }
           if (currentValue === null) return ['null'];
           if (allowRunJS && isRunJSValue(currentValue)) return ['runjs'];
           if (useDateVariableConstant && isCtxDateExpression(currentValue)) {

package/src/flow/components/__tests__/FieldAssignValueInput.context.test.tsx

@@ -12,9 +12,10 @@ import { describe, expect, it, vi } from 'vitest';
 import { render, waitFor } from '@nocobase/test/client';
 import { FieldAssignValueInput } from '../FieldAssignValueInput';
 
-const { mockUseFlowContext, mockGetDefaultBindingByField } = vi.hoisted(() => ({
+const { mockUseFlowContext, mockGetDefaultBindingByField, mockVariableInput } = vi.hoisted(() => ({
   mockUseFlowContext: vi.fn(),
   mockGetDefaultBindingByField: vi.fn(),
+  mockVariableInput: vi.fn(() => <div data-testid="variable-input" />),
 }));
 
 vi.mock('@nocobase/flow-engine', async () => {
@@ -25,7 +26,7 @@ vi.mock('@nocobase/flow-engine', async () => {
   return {
     ...actual,
     useFlowContext: () => mockUseFlowContext(),
-    VariableInput: () => <div data-testid="variable-input" />,
+    VariableInput: mockVariableInput,
     FlowModelRenderer: () => <div data-testid="flow-model-renderer" />,
     EditableItemModel: MockEditableItemModel,
   };
@@ -131,4 +132,85 @@ describe('FieldAssignValueInput context', () => {
     });
     expect(engine.createModel).toHaveBeenCalledWith(expect.any(Object), { delegate: sourceContext });
   });
+
+  it('lets callers override variable path parsing for domain-specific stored formats', async () => {
+    mockVariableInput.mockClear();
+    const sourceContext = {
+      dataSourceManager: {
+        getDataSource: vi.fn(() => ({})),
+      },
+      t: (key: string) => key,
+    };
+    const fieldModel = {
+      props: {},
+      setProps: vi.fn(),
+      dispatchEvent: vi.fn(),
+      remove: vi.fn(),
+    };
+    const tempRoot = {
+      context: {
+        defineProperty: vi.fn(),
+      },
+      subModels: {
+        fields: [fieldModel],
+      },
+      setProps: vi.fn(),
+      remove: vi.fn(),
+    };
+    const engine = {
+      createModel: vi.fn(() => tempRoot),
+    };
+    const collectionField = {
+      name: 'status',
+      interface: 'input',
+      uiSchema: { 'x-component': 'Input' },
+      isAssociationField: () => false,
+      getComponentProps: () => ({}),
+    };
+    const collection = {
+      dataSourceKey: 'main',
+      name: 'tasks',
+      getField: (name: string) => (name === 'status' ? collectionField : null),
+      getFields: () => [collectionField],
+    };
+    const formModel = {
+      context: { ...sourceContext, engine, collection, blockModel: null as any },
+      collection,
+      subModels: {},
+    };
+    formModel.context.blockModel = formModel;
+
+    mockGetDefaultBindingByField.mockReturnValue({ modelName: 'InputFieldModel' });
+    mockUseFlowContext.mockReturnValue({
+      model: formModel,
+      t: (key: string) => key,
+      getPropertyMetaTree: vi.fn(async () => []),
+    });
+
+    const variableConverters = {
+      resolvePathFromValue: vi.fn((value: string) =>
+        value === '{{$context.data.updatedAt}}' ? ['$context', 'data', 'updatedAt'] : undefined,
+      ),
+      resolveValueFromPath: vi.fn(() => undefined),
+    };
+
+    render(
+      <FieldAssignValueInput
+        targetPath="status"
+        value="{{$context.data.updatedAt}}"
+        onChange={vi.fn()}
+        variableConverters={variableConverters}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(engine.createModel).toHaveBeenCalled();
+    });
+    const latestVariableInputCall = mockVariableInput.mock.calls.at(-1)?.[0];
+    expect(latestVariableInputCall.converters.resolvePathFromValue('{{$context.data.updatedAt}}')).toEqual([
+      '$context',
+      'data',
+      'updatedAt',
+    ]);
+  });
 });

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

@@ -45,6 +45,7 @@ interface FilterGroupProps {
   value: Record<string, any>;
   /** 自定义筛选项组件 */
   FilterItem?: React.FC<FilterItemProps>;
+  disabled?: boolean;
   closeIcon?: ReactNode;
   /** 是否显示边框 */
   showBorder?: boolean;
@@ -89,6 +90,7 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
     const {
       value = { logic: '$and', items: [] },
       FilterItem,
+      disabled = false,
       showBorder = false,
       onRemove,
       onChange,
@@ -120,11 +122,17 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
         };
 
     const handleLogicChange = (newLogic: '$and' | '$or') => {
+      if (disabled) {
+        return;
+      }
       value.logic = newLogic;
       onChange?.(value);
     };
 
     const handleAddCondition = () => {
+      if (disabled) {
+        return;
+      }
       items.push({
         path: '',
         operator: '',
@@ -134,6 +142,9 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
     };
 
     const handleAddConditionGroup = () => {
+      if (disabled) {
+        return;
+      }
       items.push({
         logic: '$and',
         items: [],
@@ -142,6 +153,9 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
     };
 
     const handleRemoveItem = (index: number) => {
+      if (disabled) {
+        return;
+      }
       items.splice(index, 1);
       onChange?.(value);
     };
@@ -160,11 +174,12 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
           <button
             type="button"
             aria-label="icon-close"
+            disabled={disabled}
             style={{
               position: 'absolute',
               right: 10,
               top: 10,
-              cursor: 'pointer',
+              cursor: disabled ? 'not-allowed' : 'pointer',
               background: 'transparent',
               border: 0,
               padding: 0,
@@ -182,6 +197,7 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
               data-testid="filter-select-all-or-any"
               style={{ width: 'auto' }}
               value={logic}
+              disabled={disabled}
               onChange={handleLogicChange}
             >
               <Select.Option value="$and">{t('All')}</Select.Option>
@@ -200,6 +216,7 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
                   key={getFilterItemKey(item)}
                   value={item}
                   FilterItem={FilterItem}
+                  disabled={disabled}
                   showBorder={true}
                   onRemove={() => handleRemoveItem(index)}
                   onChange={(v) => {
@@ -221,11 +238,12 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
                       <button
                         type="button"
                         aria-label="icon-close"
+                        disabled={disabled}
                         style={{
                           marginLeft: 8,
                           marginRight: 8,
                           flex: '0 0 auto',
-                          cursor: 'pointer',
+                          cursor: disabled ? 'not-allowed' : 'pointer',
                           background: 'transparent',
                           border: 0,
                           padding: 0,
@@ -251,11 +269,12 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
                       <button
                         type="button"
                         aria-label="icon-close"
+                        disabled={disabled}
                         style={{
                           marginLeft: 8,
                           marginRight: 8,
                           flex: '0 0 auto',
-                          cursor: 'pointer',
+                          cursor: disabled ? 'not-allowed' : 'pointer',
                           background: 'transparent',
                           border: 0,
                           padding: 0,
@@ -277,11 +296,12 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
                     <button
                       type="button"
                       aria-label="icon-close"
+                      disabled={disabled}
                       style={{
                         marginLeft: 8,
                         marginRight: 8,
                         flex: '0 0 auto',
-                        cursor: 'pointer',
+                        cursor: disabled ? 'not-allowed' : 'pointer',
                         background: 'transparent',
                         border: 0,
                         padding: 0,
@@ -298,7 +318,14 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
         </div>
 
         <Space size={16} style={{ marginTop: 8, marginBottom: 8 }}>
-          <Button style={{ padding: 0 }} type="link" size="small" icon={<PlusOutlined />} onClick={handleAddCondition}>
+          <Button
+            style={{ padding: 0 }}
+            type="link"
+            size="small"
+            icon={<PlusOutlined />}
+            onClick={handleAddCondition}
+            disabled={disabled}
+          >
             {t('Add condition')}
           </Button>
           <Button
@@ -307,6 +334,7 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
             size="small"
             icon={<PlusOutlined />}
             onClick={handleAddConditionGroup}
+            disabled={disabled}
           >
             {t('Add condition group')}
           </Button>