@nocobase/client-v2 2.1.0-beta.35 → 2.1.0-beta.37

package/src/components/form/filter/__tests__/DateFilterDynamicComponent.test.tsx

@@ -0,0 +1,148 @@
+/**
+ * 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 { fireEvent, render, screen } from '@testing-library/react';
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import quarterOfYear from 'dayjs/plugin/quarterOfYear';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  DateFilterDynamicComponent,
+  FORMAT_BY_PICKER,
+  formatDateFilterValue,
+  parseDateFilterValue,
+} from '../DateFilterDynamicComponent';
+
+// `formatDateFilterValue` needs the quarter plugin to format `[Q]Q`, and `parseDateFilterValue` needs customParseFormat to parse non-ISO strings like `2026-02`. The component itself imports `dayjs` directly and relies on plugins being registered at app boot; in tests we register them locally so the unit-style helpers can run standalone.
+dayjs.extend(customParseFormat);
+dayjs.extend(quarterOfYear);
+
+function openModeDropdown(container: HTMLElement) {
+  const selector = container.querySelector('.ant-select-selector');
+  if (!selector) throw new Error('expected mode Select to be rendered');
+  fireEvent.mouseDown(selector);
+}
+
+describe('DateFilterDynamicComponent', () => {
+  it('defaults to Exact day mode and shows the picker-granularity + DatePicker controls', () => {
+    const { container } = render(<DateFilterDynamicComponent value={undefined} onChange={() => undefined} />);
+    // Three controls in the compact row: mode select, granularity select, DatePicker. antd renders Select via `.ant-select`, DatePicker via `.ant-picker`.
+    expect(container.querySelectorAll('.ant-select').length).toBeGreaterThanOrEqual(2);
+    expect(container.querySelector('.ant-picker')).not.toBeNull();
+    // Mode display reads "Exact day" with no value yet.
+    expect(screen.getByText('Exact day')).toBeInTheDocument();
+  });
+
+  it('emits { type: "past", number: 1, unit: "day" } when switching mode to Past', () => {
+    const onChange = vi.fn();
+    const { container } = render(<DateFilterDynamicComponent value={undefined} onChange={onChange} />);
+
+    openModeDropdown(container);
+    // "Past" appears in the dropdown's primary list (rendered via dropdownRender, so options have role="option" instead of antd's stock list).
+    const option = screen.getAllByRole('option').find((el) => el.textContent === 'Past');
+    if (!option) throw new Error('expected a Past option in the dropdown');
+    fireEvent.click(option);
+
+    expect(onChange).toHaveBeenCalledWith({ type: 'past', number: 1, unit: 'day' });
+  });
+
+  it('emits { type: "today" } when switching mode to Today (no number / unit / picker)', () => {
+    const onChange = vi.fn();
+    const { container } = render(<DateFilterDynamicComponent value={undefined} onChange={onChange} />);
+
+    openModeDropdown(container);
+    const option = screen.getAllByRole('option').find((el) => el.textContent === 'Today');
+    if (!option) throw new Error('expected a Today option in the dropdown');
+    fireEvent.click(option);
+
+    expect(onChange).toHaveBeenCalledWith({ type: 'today' });
+  });
+
+  it('emits undefined (clears the descriptor) when switching back to Exact day', () => {
+    const onChange = vi.fn();
+    const { container } = render(<DateFilterDynamicComponent value={{ type: 'today' }} onChange={onChange} />);
+
+    openModeDropdown(container);
+    const option = screen.getAllByRole('option').find((el) => el.textContent === 'Exact day');
+    if (!option) throw new Error('expected an Exact day option in the dropdown');
+    fireEvent.click(option);
+
+    // Exact mode owns its value via the DatePicker, so the descriptor is cleared first; the picker emits its own value on user pick.
+    expect(onChange).toHaveBeenCalledWith(undefined);
+  });
+
+  it('shows InputNumber + unit Select when the value is a past/next descriptor', () => {
+    const onChange = vi.fn();
+    const { container } = render(
+      <DateFilterDynamicComponent value={{ type: 'past', number: 3, unit: 'week' }} onChange={onChange} />,
+    );
+
+    // InputNumber present (antd renders `.ant-input-number`); unit Select is the second `.ant-select` in the row (mode is first).
+    expect(container.querySelector('.ant-input-number')).not.toBeNull();
+    expect(container.querySelectorAll('.ant-select').length).toBeGreaterThanOrEqual(2);
+    // DatePicker should NOT be rendered in relative-number mode.
+    expect(container.querySelector('.ant-picker')).toBeNull();
+  });
+
+  it('renders the RangePicker when isRange is true', () => {
+    const { container } = render(<DateFilterDynamicComponent value={undefined} onChange={() => undefined} isRange />);
+    // RangePicker carries the `.ant-picker-range` class; the granularity Select is suppressed in range mode (only mode select + range picker).
+    expect(container.querySelector('.ant-picker-range')).not.toBeNull();
+  });
+
+  it('hydrates a stored granularity-formatted string back into the DatePicker', () => {
+    // `2026-02-15` is the canonical Date-picker shape NocoBase's `$dateOn` operator emits when the user picks an exact day. The DatePicker must hydrate from it (so reopening the popover or re-rendering keeps the value) instead of treating it as an opaque blob.
+    //
+    // Note: the picker-mode state is local to the component and defaults to `date` on every mount, so values stored at other granularities (`2026-02` for month, `2026` for year) won't pre-fill on remount — only when the user is still in the same session. This matches v1's behaviour, where reopening a filter popover also re-derives the picker mode from the input shape.
+    const { container } = render(<DateFilterDynamicComponent value="2026-02-15" onChange={() => undefined} />);
+    const dateInput = container.querySelector('.ant-picker input') as HTMLInputElement;
+    if (!dateInput) throw new Error('expected antd DatePicker input to be rendered');
+    expect(dateInput.value).toBe('2026-02-15');
+  });
+
+  describe('format helpers (parseDateFilterValue / formatDateFilterValue)', () => {
+    // These two helpers are the heart of the v1-compatible URL output: `formatDateFilterValue` converts a Dayjs into the picker-shaped string the server expects, and `parseDateFilterValue` round-trips back so the controlled DatePicker can hydrate. Driving them directly is more reliable than poking antd's picker panel under jsdom.
+
+    it('formats Dayjs values per picker granularity (date / month / quarter / year)', () => {
+      const sample = dayjs('2026-02-15');
+      expect(formatDateFilterValue(sample, 'date')).toBe('2026-02-15');
+      expect(formatDateFilterValue(sample, 'month')).toBe('2026-02');
+      expect(formatDateFilterValue(sample, 'year')).toBe('2026');
+      expect(formatDateFilterValue(sample, 'quarter')).toBe('2026-Q1');
+    });
+
+    it('returns undefined for empty / non-Dayjs input so callers can drop the value', () => {
+      expect(formatDateFilterValue(null, 'date')).toBeUndefined();
+      expect(formatDateFilterValue(undefined, 'date')).toBeUndefined();
+    });
+
+    it('round-trips a granularity string back into a Dayjs at the matching format', () => {
+      const parsed = parseDateFilterValue('2026-02', 'month');
+      expect(parsed?.isValid()).toBe(true);
+      expect(parsed?.format(FORMAT_BY_PICKER.month)).toBe('2026-02');
+    });
+
+    it('returns null for missing / unparseable strings', () => {
+      expect(parseDateFilterValue(undefined, 'month')).toBeNull();
+      expect(parseDateFilterValue('', 'month')).toBeNull();
+      expect(parseDateFilterValue('not-a-date', 'month')).toBeNull();
+    });
+  });
+
+  it('translates mode labels via the provided t function', () => {
+    const t = (key: string) => (key === 'Past' ? 'PAST_ZH' : key);
+    const { container } = render(<DateFilterDynamicComponent value={undefined} onChange={() => undefined} t={t} />);
+
+    openModeDropdown(container);
+    // The translated label should appear in the dropdown options.
+    expect(screen.getAllByRole('option').some((el) => el.textContent === 'PAST_ZH')).toBe(true);
+    expect(container).toBeTruthy();
+  });
+});

package/src/components/form/filter/__tests__/FilterValueInput.test.tsx

@@ -0,0 +1,243 @@
+/**
+ * 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 { fireEvent, render, screen } from '@testing-library/react';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { FilterValueInput } from '../FilterValueInput';
+import type { FilterOperator, FilterOption } from '../../../../flow/components/filter/useFilterOptions';
+
+type Case = {
+  /** Human-readable description of the v1 interface this case mirrors. */
+  name: string;
+  /** Field uiSchema. Operator schema is optional and overrides this. */
+  fieldComponent?: string;
+  fieldEnum?: any[];
+  operator?: FilterOperator;
+  /** Selector used to confirm the right antd control rendered. */
+  selector: string;
+  /** Optional: drive an interaction and assert onChange payload. */
+  interact?: (container: HTMLElement, onChange: ReturnType<typeof vi.fn>) => void;
+  expectedOnChange?: any;
+};
+
+const fieldOf = (component: string, extra: Partial<FilterOption['schema']> = {}): FilterOption => ({
+  name: 'f',
+  title: 'F',
+  schema: { 'x-component': component, ...extra },
+});
+
+const opOf = (overrides: Partial<FilterOperator> = {}): FilterOperator => ({
+  value: '$eq',
+  label: 'is',
+  ...overrides,
+});
+
+// One row per v1 field interface → expected v2 antd control. Detection is kept to a single CSS selector per case so the table reads as "interface ↔ selector"; interactive assertions are added only where the value-onChange contract is non-trivial (e.g. Checkbox.target.checked, ColorPicker hex extraction).
+const CASES: Case[] = [
+  // string / email / phone / uuid / nanoid / url all default to Input
+  { name: 'input → antd Input', fieldComponent: 'Input', selector: 'input[type="text"]' },
+  { name: 'Input.URL → antd Input', fieldComponent: 'Input.URL', selector: 'input[type="text"]' },
+  { name: 'NanoIDInput → antd Input', fieldComponent: 'NanoIDInput', selector: 'input[type="text"]' },
+
+  // textarea / markdown / richText / json all collapse to TextArea
+  { name: 'textarea → antd Input.TextArea', fieldComponent: 'Input.TextArea', selector: 'textarea' },
+  { name: 'markdown → antd Input.TextArea', fieldComponent: 'Markdown', selector: 'textarea' },
+  { name: 'richText → antd Input.TextArea', fieldComponent: 'RichText', selector: 'textarea' },
+  { name: 'json → antd Input.TextArea', fieldComponent: 'Input.JSON', selector: 'textarea' },
+
+  // numeric inputs
+  { name: 'integer → antd InputNumber', fieldComponent: 'InputNumber', selector: '.ant-input-number' },
+  { name: 'percent → antd InputNumber', fieldComponent: 'Percent', selector: '.ant-input-number' },
+
+  // password — the case that prompted this audit
+  {
+    name: 'password → PasswordInput (Input.Password)',
+    fieldComponent: 'Password',
+    selector: 'input[type="password"]',
+  },
+
+  // pickers
+  {
+    name: 'datetime field → antd DatePicker (no operator override)',
+    fieldComponent: 'DatePicker',
+    selector: '.ant-picker',
+  },
+  { name: 'unixTimestamp → antd DatePicker', fieldComponent: 'UnixTimestamp', selector: '.ant-picker' },
+  { name: 'time → antd TimePicker', fieldComponent: 'TimePicker', selector: '.ant-picker' },
+  { name: 'color → antd ColorPicker', fieldComponent: 'ColorPicker', selector: '.ant-color-picker-trigger' },
+
+  // boolean / single-choice / multi-choice
+  { name: 'checkbox → antd Checkbox', fieldComponent: 'Checkbox', selector: 'input[type="checkbox"]' },
+  {
+    name: 'checkboxGroup with field enum → antd Checkbox.Group',
+    fieldComponent: 'Checkbox.Group',
+    fieldEnum: [
+      { label: 'A', value: 'a' },
+      { label: 'B', value: 'b' },
+    ],
+    selector: '.ant-checkbox-group',
+  },
+  {
+    name: 'radioGroup with field enum → antd Radio.Group',
+    fieldComponent: 'Radio.Group',
+    fieldEnum: [
+      { label: 'A', value: 'a' },
+      { label: 'B', value: 'b' },
+    ],
+    selector: '.ant-radio-group',
+  },
+  { name: 'select → antd Select', fieldComponent: 'Select', selector: '.ant-select' },
+
+  // operator-level overrides — datetime operator schema wins over field uiSchema
+  {
+    name: '$dateOn operator → smart date picker',
+    fieldComponent: 'DatePicker',
+    operator: opOf({
+      schema: { 'x-component': 'DateFilterDynamicComponent', 'x-component-props': { isRange: false } },
+    }),
+    selector: '.ant-picker',
+  },
+  {
+    name: '$anyOf array operator → Select with tags mode',
+    fieldComponent: 'Input',
+    operator: opOf({
+      value: '$anyOf',
+      schema: { 'x-component': 'Select', 'x-component-props': { mode: 'tags' } },
+    }),
+    selector: '.ant-select-selection-overflow',
+  },
+
+  // noValue operators render nothing
+  {
+    name: '$empty operator → renders nothing',
+    fieldComponent: 'Input',
+    operator: opOf({ value: '$empty', noValue: true }),
+    selector: '*',
+    // selector intentionally generic; we assert empty container via interact
+  },
+];
+
+function setup(c: Case) {
+  const onChange = vi.fn();
+  const field = c.fieldComponent
+    ? fieldOf(c.fieldComponent, c.fieldEnum ? ({ enum: c.fieldEnum } as any) : {})
+    : undefined;
+  const utils = render(<FilterValueInput field={field} operator={c.operator} value={undefined} onChange={onChange} />);
+  return { onChange, ...utils };
+}
+
+describe('FilterValueInput dispatch table', () => {
+  for (const c of CASES) {
+    it(c.name, () => {
+      const { container } = setup(c);
+      if (c.operator?.noValue) {
+        // For noValue operators the component returns null.
+        expect(
+          container.querySelector('input, textarea, .ant-select, .ant-picker, .ant-color-picker-trigger'),
+        ).toBeNull();
+        return;
+      }
+      expect(container.querySelector(c.selector)).not.toBeNull();
+    });
+  }
+});
+
+describe('FilterValueInput interaction wiring', () => {
+  // Spot-check a handful of write-through paths that have non-trivial event shapes (target.checked, event vs raw value, hex extraction from ColorPicker).
+  it('Checkbox emits the boolean from target.checked', () => {
+    const onChange = vi.fn();
+    const { container } = render(
+      <FilterValueInput field={fieldOf('Checkbox')} operator={opOf()} value={false} onChange={onChange} />,
+    );
+    fireEvent.click(container.querySelector('input[type="checkbox"]') as HTMLInputElement);
+    expect(onChange).toHaveBeenCalledWith(true);
+  });
+
+  it('Password emits the unwrapped string from the input event', () => {
+    const onChange = vi.fn();
+    const { container } = render(
+      <FilterValueInput field={fieldOf('Password')} operator={opOf()} value="" onChange={onChange} />,
+    );
+    const input = container.querySelector('input[type="password"]') as HTMLInputElement;
+    fireEvent.change(input, { target: { value: 'hunter2' } });
+    expect(onChange).toHaveBeenCalledWith('hunter2');
+  });
+
+  it('TextArea emits the unwrapped string', () => {
+    const onChange = vi.fn();
+    const { container } = render(
+      <FilterValueInput field={fieldOf('Input.TextArea')} operator={opOf()} value="" onChange={onChange} />,
+    );
+    fireEvent.change(container.querySelector('textarea') as HTMLTextAreaElement, {
+      target: { value: 'abuse' },
+    });
+    expect(onChange).toHaveBeenCalledWith('abuse');
+  });
+
+  it('Radio.Group emits the picked value (not the event)', () => {
+    const onChange = vi.fn();
+    const { container } = render(
+      <FilterValueInput
+        field={fieldOf('Radio.Group', {
+          enum: [
+            { label: 'A', value: 'a' },
+            { label: 'B', value: 'b' },
+          ],
+        } as any)}
+        operator={opOf()}
+        value={undefined}
+        onChange={onChange}
+      />,
+    );
+    fireEvent.click(container.querySelectorAll('input[type="radio"]')[1] as HTMLInputElement);
+    expect(onChange).toHaveBeenCalledWith('b');
+  });
+
+  it('Fallback Input honours the placeholder prop', () => {
+    render(<FilterValueInput operator={opOf()} value="" onChange={() => undefined} placeholder="Enter value" />);
+    expect(screen.getByPlaceholderText('Enter value')).toBeInTheDocument();
+  });
+});
+
+describe('FilterValueInput schema precedence', () => {
+  it('operator schema wins over field uiSchema', () => {
+    // Field would render Input, but operator forces Select.
+    render(
+      <FilterValueInput
+        field={fieldOf('Input')}
+        operator={opOf({
+          schema: { 'x-component': 'Select', 'x-component-props': { mode: 'tags' } },
+        })}
+        value={[]}
+        onChange={() => undefined}
+      />,
+    );
+    expect(document.querySelector('.ant-select')).not.toBeNull();
+  });
+
+  it('field uiSchema is used when operator has none', () => {
+    const { container } = render(
+      <FilterValueInput
+        field={fieldOf('InputNumber')}
+        operator={opOf()}
+        value={undefined}
+        onChange={() => undefined}
+      />,
+    );
+    expect(container.querySelector('.ant-input-number')).not.toBeNull();
+  });
+
+  it('plain Input is used when neither side has a schema', () => {
+    const { container } = render(
+      <FilterValueInput operator={opOf()} value="" onChange={() => undefined} placeholder="x" />,
+    );
+    expect(container.querySelector('input[type="text"]')).not.toBeNull();
+  });
+});

package/src/components/form/filter/__tests__/compileFilterGroup.test.ts

@@ -0,0 +1,146 @@
+/**
+ * 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 { compileFilterGroup } from '../useFilterActionProps';
+
+describe('compileFilterGroup', () => {
+  it('returns undefined for an empty group so callers can drop the filter param', () => {
+    expect(compileFilterGroup(undefined)).toBeUndefined();
+    expect(compileFilterGroup({ logic: '$and', items: [] })).toBeUndefined();
+  });
+
+  it('compiles a single condition into the NocoBase {path: {op: val}} envelope', () => {
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [{ path: 'lockReason', operator: '$includes', value: 'abuse' }],
+    });
+    expect(out).toEqual({ $and: [{ lockReason: { $includes: 'abuse' } }] });
+  });
+
+  it('preserves the parent logic ($and / $or)', () => {
+    const out = compileFilterGroup({
+      logic: '$or',
+      items: [
+        { path: 'lockReason', operator: '$eq', value: 'abuse' },
+        { path: 'lockReason', operator: '$eq', value: 'spam' },
+      ],
+    });
+    expect(out).toEqual({
+      $or: [{ lockReason: { $eq: 'abuse' } }, { lockReason: { $eq: 'spam' } }],
+    });
+  });
+
+  it('compiles nested groups recursively', () => {
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [
+        { path: 'lockReason', operator: '$eq', value: 'abuse' },
+        {
+          logic: '$or',
+          items: [
+            { path: 'lockedTs', operator: '$dateAfter', value: '2026-01-01' },
+            { path: 'lockedTs', operator: '$dateBefore', value: '2026-12-31' },
+          ],
+        },
+      ],
+    });
+    expect(out).toEqual({
+      $and: [
+        { lockReason: { $eq: 'abuse' } },
+        {
+          $or: [{ lockedTs: { $dateAfter: '2026-01-01' } }, { lockedTs: { $dateBefore: '2026-12-31' } }],
+        },
+      ],
+    });
+  });
+
+  it('drops items with empty values (undefined / "" / [] / {}) so half-edited rows do not 500 the server', () => {
+    // Mirrors v1's `removeNullCondition` behaviour. A user who selected a field + operator but hasn't typed a value yet must NOT cause `{path:{operator:undefined}}` to fly out — the server rejects empty operator bodies on `$dateOn` etc.
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [
+        { path: 'lockedTs', operator: '$dateOn', value: undefined },
+        { path: 'lockReason', operator: '$eq', value: '' },
+        { path: 'lockReason', operator: '$in', value: [] },
+        { path: 'lockedTs', operator: '$dateOn', value: {} },
+        { path: 'lockReason', operator: '$eq', value: 'kept' },
+      ],
+    });
+    expect(out).toEqual({ $and: [{ lockReason: { $eq: 'kept' } }] });
+  });
+
+  it('expands dotted association paths into nested objects (matches v1 payload shape)', () => {
+    // `user.createdBy.password` must reach the server as a nested object so the filter resolver walks the association chain. Flattened-key form (`{ "user.createdBy.password": ... }`) leaves the server treating the whole string as one column name.
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [{ path: 'user.createdBy.password', operator: '$includes', value: '123' }],
+    });
+    expect(out).toEqual({
+      $and: [{ user: { createdBy: { password: { $includes: '123' } } } }],
+    });
+  });
+
+  it('keeps relative date descriptors (non-empty plain objects) intact', () => {
+    // `{ type: 'today' }` is an empty-keys-only check away from being pruned by accident. Confirm it survives — that's the server-readable shape for relative-date filters.
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [{ path: 'lockedTs', operator: '$dateOn', value: { type: 'today' } }],
+    });
+    expect(out).toEqual({ $and: [{ lockedTs: { $dateOn: { type: 'today' } } }] });
+  });
+
+  it('drops items missing path or operator so half-typed rows do not break the query', () => {
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [
+        { path: '', operator: '$eq', value: 'orphan' },
+        { path: 'lockReason', operator: '', value: 'orphan' },
+        { path: 'lockReason', operator: '$eq', value: 'kept' },
+      ],
+    });
+    expect(out).toEqual({ $and: [{ lockReason: { $eq: 'kept' } }] });
+  });
+
+  it('drops empty nested groups so a half-built sub-group does not produce { $or: [] }', () => {
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [
+        { path: 'lockReason', operator: '$eq', value: 'abuse' },
+        { logic: '$or', items: [] },
+      ],
+    });
+    expect(out).toEqual({ $and: [{ lockReason: { $eq: 'abuse' } }] });
+  });
+
+  it('returns undefined when every item drops out', () => {
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [
+        { path: '', operator: '', value: '' },
+        { logic: '$or', items: [] },
+      ],
+    });
+    expect(out).toBeUndefined();
+  });
+
+  it('passes complex value shapes (date descriptors, arrays) through unchanged', () => {
+    const dateDescriptor = { type: 'past', number: 3, unit: 'day' };
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [
+        { path: 'lockedTs', operator: '$dateOn', value: dateDescriptor },
+        { path: 'lockReason', operator: '$in', value: ['abuse', 'spam'] },
+      ],
+    });
+    expect(out).toEqual({
+      $and: [{ lockedTs: { $dateOn: dateDescriptor } }, { lockReason: { $in: ['abuse', 'spam'] } }],
+    });
+  });
+});

package/src/components/form/filter/index.ts

@@ -0,0 +1,13 @@
+/**
+ * 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.
+ */
+
+// Higher-level filter compositions for non-schema surfaces (settings pages, panels, side drawers). The low-level primitives — `FilterContainer`, `FilterGroup`, `FilterItem`, `fieldsToOptions`, `useFilterOptions` — live under `src/flow/components/filter/`; this layer composes them with a `Collection` binding and exposes the hook/component pair callers actually reach for. The dependency direction is form/filter → flow/components/filter only.
+export { CollectionFilter } from './CollectionFilter';
+export type { CollectionFilterProps } from './CollectionFilter';
+export type { CompiledFilter } from './useFilterActionProps';