@nocobase/client-v2 2.1.0-alpha.3 → 2.1.0-alpha.30

package/src/flow/models/blocks/details/__tests__/DetailsItemModel.value.test.ts

@@ -0,0 +1,49 @@
+/**
+ * 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 { getDetailsItemValue, getValueWithIndex } from '../DetailsItemModel';
+
+describe('DetailsItemModel value resolving', () => {
+  it('reads nested list item from record with index chain', () => {
+    expect(
+      getValueWithIndex(
+        {
+          users: [{ profile: { nickname: 'A' } }],
+        },
+        'users.profile.nickname',
+        ['users:0'],
+      ),
+    ).toBe('A');
+  });
+
+  it('falls back to currentObject with relative field path in sub-detail rows', () => {
+    expect(
+      getDetailsItemValue({
+        record: { unrelated: true },
+        currentObject: { nickname: 'B' },
+        fieldPath: 'users.nickname',
+        prefixFieldPath: 'users',
+        idx: ['users:0'],
+      }),
+    ).toBe('B');
+  });
+
+  it('returns currentObject itself when field path equals prefix field path', () => {
+    const currentObject = { id: 1, nickname: 'C' };
+    expect(
+      getDetailsItemValue({
+        record: {},
+        currentObject,
+        fieldPath: 'users',
+        prefixFieldPath: 'users',
+      }),
+    ).toBe(currentObject);
+  });
+});

package/src/flow/models/blocks/details/index.ts

@@ -0,0 +1,16 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+export * from './DetailsAssociationFieldGroupModel';
+export * from './DetailsBlockModel';
+export * from './DetailsCustomItemModel';
+export * from './DetailsGridModel';
+export * from './DetailsItemModel';
+export * from './DetailsJSFieldItemModel';
+//

package/src/flow/models/blocks/details/utils.ts

@@ -0,0 +1,67 @@
+/**
+ * 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 { useCallback, useEffect, useLayoutEffect, useState } from 'react';
+
+const getOuterHeight = (element?: HTMLElement | null) => {
+  if (!element) return 0;
+  const rect = element.getBoundingClientRect();
+  const style = window.getComputedStyle(element);
+  const marginTop = parseFloat(style.marginTop) || 0;
+  const marginBottom = parseFloat(style.marginBottom) || 0;
+  return rect.height + marginTop + marginBottom;
+};
+
+export const useDetailsGridHeight = ({
+  heightMode,
+  containerRef,
+  actionsRef,
+  paginationRef,
+  deps = [],
+}: {
+  heightMode?: string;
+  containerRef: React.RefObject<HTMLDivElement>;
+  actionsRef: React.RefObject<HTMLDivElement>;
+  paginationRef: React.RefObject<HTMLDivElement>;
+  deps?: React.DependencyList;
+}) => {
+  const [gridHeight, setGridHeight] = useState<number>();
+  const calcGridHeight = useCallback(() => {
+    if (heightMode !== 'specifyValue' && heightMode !== 'fullHeight') {
+      setGridHeight((prev) => (prev === undefined ? prev : undefined));
+      return;
+    }
+    const container = containerRef.current;
+    if (!container) return;
+    const containerHeight = container.getBoundingClientRect().height;
+    if (!containerHeight) return;
+    const actionsHeight = getOuterHeight(actionsRef.current);
+    const paginationHeight = getOuterHeight(paginationRef.current);
+    const nextHeight = Math.max(0, Math.floor(containerHeight - actionsHeight - paginationHeight));
+    setGridHeight((prev) => (prev === nextHeight ? prev : nextHeight));
+  }, [heightMode, containerRef, actionsRef, paginationRef]);
+
+  useLayoutEffect(() => {
+    calcGridHeight();
+  }, [calcGridHeight, ...deps]);
+
+  useEffect(() => {
+    if (!containerRef.current || typeof ResizeObserver === 'undefined') return;
+    const container = containerRef.current;
+    const actions = actionsRef.current;
+    const pagination = paginationRef.current;
+    const observer = new ResizeObserver(() => calcGridHeight());
+    observer.observe(container);
+    if (actions) observer.observe(actions);
+    if (pagination) observer.observe(pagination);
+    return () => observer.disconnect();
+  }, [calcGridHeight, containerRef, actionsRef, paginationRef, ...deps]);
+
+  return gridHeight;
+};

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

@@ -0,0 +1,59 @@
+/**
+ * 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, { useEffect, useMemo, useRef } from 'react';
+import { FilterableItemModel, useFlowContext, useFlowEngine } from '@nocobase/flow-engine';
+import { Select } from '@formily/antd-v5';
+
+export function FieldModelSelect(props) {
+  const { source = [], onChange } = props;
+  const flowEngine = useFlowEngine();
+  const ctx = useFlowContext();
+  const valueMap = props.valueMap || {};
+  const sourceKey = source.join('.');
+  const previousSourceKeyRef = useRef<string>();
+  const normalizeValue = useMemo(() => {
+    return (value) => (valueMap && valueMap[value] ? valueMap[value] : value);
+  }, [valueMap]);
+
+  const defaultValue = useMemo(() => {
+    if (!source.length) return undefined;
+    const collectionField = flowEngine.dataSourceManager.getCollectionField(sourceKey);
+    const binding = FilterableItemModel.getDefaultBindingByField(ctx.model.context, collectionField);
+    if (!binding) {
+      return;
+    }
+    return normalizeValue(binding.modelName);
+  }, [sourceKey, normalizeValue]);
+
+  useEffect(() => {
+    if (!defaultValue) {
+      previousSourceKeyRef.current = sourceKey;
+      return;
+    }
+
+    const sourceChanged = previousSourceKeyRef.current !== undefined && previousSourceKeyRef.current !== sourceKey;
+    previousSourceKeyRef.current = sourceKey;
+
+    // Migrate legacy value if mapped
+    const currentNormalized = normalizeValue(props.value);
+    if (props.value && props.value !== currentNormalized && currentNormalized !== defaultValue) {
+      onChange?.(currentNormalized);
+      return;
+    }
+
+    // Keep field model aligned with latest source metadata.
+    // Users can still adjust it manually after the auto-fill.
+    if ((!props.value || sourceChanged) && currentNormalized !== defaultValue) {
+      onChange?.(defaultValue);
+    }
+  }, [defaultValue, onChange, props.value, sourceKey, normalizeValue]);
+
+  return <Select allowClear {...props} value={normalizeValue(props.value ?? defaultValue)} />;
+}

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

@@ -0,0 +1,109 @@
+/**
+ * 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, { useEffect, useMemo } from 'react';
+import { useField } from '@formily/react';
+import { Select } from '@formily/antd-v5';
+import { observer, useFlowContext, useFlowEngine } from '@nocobase/flow-engine';
+
+import {
+  resolveCustomFieldOperatorList,
+  resolveDefaultCustomFieldOperator,
+  toOperatorSelectOptions,
+} from './customFieldOperators';
+
+export const FieldOperatorSelect = observer((props: any) => {
+  const { fieldModel, source = [], fieldModelProps = {}, value, onChange, ...others } = props;
+  const currentField = useField<any>();
+  const flowEngine = useFlowEngine();
+  const ctx = useFlowContext();
+  const formValues = currentField?.form?.values || {};
+  const resolvedFieldModel = fieldModel || formValues?.fieldModel;
+  const resolvedSource = source.length ? source : formValues?.source || [];
+  const resolvedFieldModelProps =
+    formValues?.fieldModelProps && Object.keys(formValues.fieldModelProps).length > 0
+      ? formValues.fieldModelProps
+      : fieldModelProps;
+
+  const sourceKey = Array.isArray(resolvedSource) ? resolvedSource.join('.') : '';
+  const fieldModelPropsMode = resolvedFieldModelProps?.mode;
+  const fieldModelPropsAllowMultiple = resolvedFieldModelProps?.allowMultiple;
+  const fieldModelPropsMultiple = resolvedFieldModelProps?.multiple;
+  const fieldModelPropsDataSourceKey = resolvedFieldModelProps?.recordSelectDataSourceKey;
+  const fieldModelPropsTargetCollection = resolvedFieldModelProps?.recordSelectTargetCollection;
+  const fieldModelPropsValueField = resolvedFieldModelProps?.recordSelectValueField;
+
+  const operatorList = useMemo(() => {
+    return resolveCustomFieldOperatorList({
+      flowEngine,
+      fieldModel: resolvedFieldModel,
+      source: resolvedSource,
+      fieldModelProps: resolvedFieldModelProps,
+    });
+  }, [
+    flowEngine,
+    resolvedFieldModel,
+    sourceKey,
+    fieldModelPropsMode,
+    fieldModelPropsAllowMultiple,
+    fieldModelPropsMultiple,
+    fieldModelPropsDataSourceKey,
+    fieldModelPropsTargetCollection,
+    fieldModelPropsValueField,
+  ]);
+
+  const options = useMemo(() => toOperatorSelectOptions(operatorList, (text) => ctx.t(text)), [operatorList, ctx]);
+
+  useEffect(() => {
+    if (!options.length) {
+      if (value !== undefined) {
+        onChange?.(undefined);
+      }
+      return;
+    }
+    const hasCurrentValue = options.some((item) => item.value === value);
+    if (hasCurrentValue) return;
+    const nextValue = resolveDefaultCustomFieldOperator({
+      flowEngine,
+      fieldModel: resolvedFieldModel,
+      source: resolvedSource,
+      fieldModelProps: resolvedFieldModelProps,
+    });
+    if (nextValue !== value) {
+      onChange?.(nextValue);
+    }
+  }, [
+    flowEngine,
+    resolvedFieldModel,
+    onChange,
+    options,
+    sourceKey,
+    value,
+    fieldModelPropsMode,
+    fieldModelPropsAllowMultiple,
+    fieldModelPropsMultiple,
+    fieldModelPropsDataSourceKey,
+    fieldModelPropsTargetCollection,
+    fieldModelPropsValueField,
+  ]);
+
+  return (
+    <Select
+      allowClear
+      showSearch
+      optionFilterProp="label"
+      placeholder={ctx.t('Please select')}
+      {...others}
+      options={options}
+      value={value}
+      onChange={onChange}
+      disabled={options.length === 0}
+    />
+  );
+});

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

@@ -0,0 +1,15 @@
+/**
+ * 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 { ActionGroupModel } from '../../base';
+import { FilterFormActionModel } from './FilterFormActionModel';
+
+export class FilterFormActionGroupModel extends ActionGroupModel {
+  static baseClass = FilterFormActionModel;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * 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 { ActionModel } from '../../base';
+
+export class FilterFormActionModel extends ActionModel {}

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

@@ -0,0 +1,338 @@
+/**
+ * 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 { SettingOutlined } from '@ant-design/icons';
+import { FormButtonGroup } from '@formily/antd-v5';
+import {
+  AddSubModelButton,
+  DndProvider,
+  DragHandler,
+  Droppable,
+  isRunJSValue,
+  normalizeRunJSValue,
+  runjsWithSafeGlobals,
+  tExpr,
+  FlowModelRenderer,
+  FlowSettingsButton,
+} from '@nocobase/flow-engine';
+import { Form } from 'antd';
+import React from 'react';
+import { commonConditionHandler, ConditionBuilder } from '../../../components/ConditionBuilder';
+import {
+  markSaveStepParamsWithSubModels,
+  saveStepParamsWithSubModelsIfNeeded,
+} from '../../../internal/utils/saveStepParamsWithSubModels';
+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 { FilterFormItemModel } from './FilterFormItemModel';
+import { clearLegacyDefaultValuesFromFilterFormModel } from './legacyDefaultValueMigration';
+import { findFormItemModelByFieldPath } from '../../../internal/utils/modelUtils';
+import { FormItemModel } from '../form/FormItemModel';
+import { getDefaultOperator } from '../filter-manager/utils';
+import { normalizeFilterValueByOperator } from './valueNormalization';
+
+export class FilterFormBlockModel extends FilterBlockModel<{
+  subModels: {
+    grid: any; // Replace with actual type if available
+    actions?: any[]; // Replace with actual type if available
+  };
+}> {
+  static scene = BlockSceneEnum.filter;
+
+  /**
+   * 是否需要自动触发筛选，当字段值变更时自动执行筛选
+   */
+  autoTriggerFilter = true;
+
+  private removeTargetBlockListener?: () => void;
+
+  get form() {
+    return this.context.form;
+  }
+
+  get title() {
+    return 'Filter form';
+  }
+
+  useHooksBeforeRender() {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    const [form] = Form.useForm();
+    this.context.defineProperty('form', { get: () => form, cache: false });
+  }
+
+  async saveStepParams() {
+    return await saveStepParamsWithSubModelsIfNeeded(this, async () => {
+      return await super.saveStepParams();
+    });
+  }
+
+  addAppends() {}
+
+  onInit(options) {
+    super.onInit(options);
+    this.context.defineProperty('blockModel', {
+      value: this,
+    });
+    this.context.defineMethod('refreshTargets', async () => {
+      const gridModel = this.subModels.grid;
+      const fieldModels: FilterFormItemModel[] = gridModel.subModels.items;
+      if (fieldModels) {
+        fieldModels.forEach((fieldModel) => {
+          fieldModel?.doFilter?.();
+        });
+      }
+    });
+  }
+
+  onMount() {
+    super.onMount();
+    this.context.defineProperty('filterFormGridModel', {
+      value: this.subModels.grid,
+    });
+
+    // 首次进入页面：等待子模型 beforeRender 完成（例如 name 初始化），再应用表单级默认值并触发筛选
+    void this.applyDefaultsAndInitialFilter();
+
+    // 监听页面区块删除，自动清理已失效的筛选字段。
+    // 这里使用 onSubModelDestroyed 而不是 onSubModelRemoved，避免弹窗关闭时
+    // 的临时模型卸载被误判成“用户删除了目标区块”。
+    const blockGridModel = this.context.blockGridModel;
+    if (blockGridModel?.emitter) {
+      const handleTargetDestroyed = (model) => {
+        if (!model?.uid || model.uid === this.uid) return;
+        void this.handleTargetBlockRemoved(model.uid).catch((error) => {
+          console.error('Failed to handle destroyed target block in FilterFormBlockModel:', error);
+        });
+      };
+      blockGridModel.emitter.on('onSubModelDestroyed', handleTargetDestroyed);
+      this.removeTargetBlockListener = () => blockGridModel.emitter.off('onSubModelDestroyed', handleTargetDestroyed);
+    }
+  }
+
+  onUnmount() {
+    this.removeTargetBlockListener?.();
+    super.onUnmount();
+  }
+
+  private async applyDefaultsAndInitialFilter() {
+    await this.ensureFilterItemsBeforeRender();
+    await this.applyFormDefaultValues();
+    await this.context.refreshTargets?.();
+  }
+
+  private async ensureFilterItemsBeforeRender() {
+    const gridModel = this.subModels?.grid;
+    const items = (gridModel as any)?.subModels?.items || [];
+    if (!Array.isArray(items) || items.length === 0) return;
+
+    for (const itemModel of items) {
+      if (typeof itemModel?.dispatchEvent === 'function') {
+        await itemModel.dispatchEvent('beforeRender');
+      }
+    }
+  }
+
+  async applyFormDefaultValues(options?: { force?: boolean }) {
+    const form = this.form;
+    if (!form) return;
+
+    const force = options?.force === true;
+    const params = this.getStepParams?.('formFilterBlockModelSettings', 'defaultValues');
+    const rules = (params?.value || []) as any[];
+    if (!Array.isArray(rules) || rules.length === 0) return;
+
+    const resolveValue = async (raw: any) => {
+      // RunJS support
+      if (isRunJSValue(raw)) {
+        const { code, version } = normalizeRunJSValue(raw);
+        const ret = await runjsWithSafeGlobals(this.context, code, { version });
+        return ret?.success ? ret.value : undefined;
+      }
+
+      return await (this.context as any).resolveJsonTemplate?.(raw);
+    };
+
+    for (const rule of rules) {
+      if (!rule || typeof rule !== 'object') continue;
+      if (rule.enable === false) continue;
+      if (rule.mode && String(rule.mode) !== 'default') continue;
+
+      const targetPath = rule.targetPath ? String(rule.targetPath).trim() : '';
+      const fieldUid = rule.field ? String(rule.field).trim() : '';
+
+      const itemModel: FormItemModel =
+        (targetPath ? findFormItemModelByFieldPath(this, targetPath) : null) ??
+        (fieldUid ? this.context?.engine?.getModel?.(fieldUid) : null);
+      if (!itemModel) continue;
+
+      const props = typeof itemModel.getProps === 'function' ? itemModel.getProps() : itemModel.props;
+      const name = props?.name ?? (itemModel.fieldPath ? `${itemModel.fieldPath}_${itemModel.uid}` : undefined);
+      if (!name) continue;
+
+      const current = (form as any).getFieldValue?.(name);
+      if (!force && !isEmptyValue(current)) continue;
+
+      const resolved = await resolveValue(rule.value);
+      if (typeof resolved === 'undefined') continue;
+
+      const operator = getDefaultOperator(itemModel as any);
+      const normalized = normalizeFilterValueByOperator(operator, resolved);
+
+      if (typeof (form as any).setFieldValue === 'function') {
+        (form as any).setFieldValue(name, normalized);
+      } else {
+        (form as any).setFieldsValue?.({ [String(name)]: normalized });
+      }
+    }
+  }
+
+  private async handleTargetBlockRemoved(targetUid: string) {
+    const filterManager: FilterManager = this.context.filterManager;
+    const gridModel = this.subModels.grid;
+    const fieldModels: FilterFormItemModel[] = gridModel.subModels.items || [];
+
+    for (const fieldModel of [...fieldModels]) {
+      const connectConfig = filterManager.getConnectFieldsConfig(fieldModel.uid);
+      const targets = connectConfig?.targets || [];
+      const hasTarget = targets.some((target) => target.targetId === targetUid);
+      const defaultMatches = fieldModel.defaultTargetUid === targetUid;
+
+      if (!hasTarget && !defaultMatches) continue;
+
+      const remainingTargets = targets.filter((target) => target.targetId !== targetUid);
+
+      if (remainingTargets.length > 0) {
+        await filterManager.saveConnectFieldsConfig(fieldModel.uid, { targets: remainingTargets });
+        continue;
+      }
+
+      await filterManager.removeFilterConfig({ filterId: fieldModel.uid });
+      await fieldModel.destroy();
+    }
+  }
+
+  async destroy(): Promise<boolean> {
+    // 清理所有子模型的筛选配置
+    const filterManager: FilterManager = this.context.filterManager;
+    this.subModels.grid.subModels.items?.map((item) => {
+      filterManager.removeFilterConfig({ filterId: item.uid, persist: false });
+    });
+
+    return await super.destroy();
+  }
+
+  renderComponent() {
+    const { colon, labelAlign, labelWidth, labelWrap, layout } = this.props;
+    const isConfigMode = !!this.context.flowSettingsEnabled;
+
+    return (
+      <FormComponent
+        model={this}
+        onFinish={() => {
+          this.context.refreshTargets();
+        }}
+        layoutProps={{ colon, labelAlign, labelWidth, labelWrap, layout }}
+      >
+        <FlowModelRenderer model={this.subModels.grid} showFlowSettings={false} />
+        <DndProvider>
+          <FormButtonGroup align="right">
+            {this.mapSubModels('actions', (action) => {
+              if (action.hidden && !isConfigMode) {
+                return;
+              }
+              return (
+                <Droppable model={action} key={action.uid}>
+                  <FlowModelRenderer
+                    key={action.uid}
+                    model={action}
+                    showFlowSettings={{ showBackground: false, showBorder: false, toolbarPosition: 'above' }}
+                    extraToolbarItems={[
+                      {
+                        key: 'drag-handler',
+                        component: DragHandler,
+                        sort: 1,
+                      },
+                    ]}
+                  />
+                </Droppable>
+              );
+            })}
+            <AddSubModelButton
+              key="filter-form-actions-add"
+              model={this}
+              subModelKey="actions"
+              subModelBaseClass={'FilterFormActionGroupModel'}
+            >
+              <FlowSettingsButton icon={<SettingOutlined />}>{this.translate('Actions')}</FlowSettingsButton>
+            </AddSubModelButton>
+          </FormButtonGroup>
+        </DndProvider>
+      </FormComponent>
+    );
+  }
+}
+
+FilterFormBlockModel.define({
+  label: tExpr('Form'),
+  createModelOptions: {
+    use: 'FilterFormBlockModel',
+    subModels: {
+      grid: {
+        use: 'FilterFormGridModel',
+      },
+    },
+  },
+});
+
+FilterFormBlockModel.registerFlow({
+  key: 'formFilterBlockModelSettings',
+  title: tExpr('Form settings'),
+  steps: {
+    layout: {
+      use: 'layout',
+      title: tExpr('Layout'),
+    },
+    defaultValues: {
+      use: 'filterFormDefaultValues',
+      title: tExpr('Field values'),
+      beforeParamsSave(ctx) {
+        // 迁移：保存表单级默认值后，移除字段级默认值配置（filterFormItemSettings.initialValue）
+        const cleared = clearLegacyDefaultValuesFromFilterFormModel(ctx.model);
+        if (Array.isArray(cleared) && cleared.length) {
+          // FlowModelRepository({ onlyStepParams: true }) 不会写入 subModels，
+          // 此处标记后在 saveStepParams 中触发一次全量保存以持久化清理结果。
+          markSaveStepParamsWithSubModels(ctx.model);
+        }
+      },
+      afterParamsSave(ctx) {
+        // 保存后立即回填默认值（用于配置态预览），并触发一次筛选刷新
+        void ctx.model?.applyFormDefaultValues?.({ force: true }).then(() => ctx.model?.context?.refreshTargets?.());
+      },
+    },
+  },
+});
+
+FilterFormBlockModel.registerEvents({
+  formValuesChange: {
+    title: tExpr('Form values change'),
+    name: 'formValuesChange',
+    uiSchema: {
+      condition: {
+        type: 'object',
+        title: tExpr('Trigger condition'),
+        'x-decorator': 'FormItem',
+        'x-component': ConditionBuilder,
+      },
+    },
+    handler: commonConditionHandler,
+  },
+});