@nocobase/client-v2 2.1.0-alpha.4 → 2.1.0-alpha.45

package/es/components/form/VariableInput.d.ts

@@ -0,0 +1,124 @@
+/**
+ * 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 { type MetaTreeNode, type VariableHybridInputConverters } from '@nocobase/flow-engine';
+import React from 'react';
+/**
+ * The flow-engine defaults emit `{{ ctx.$X.Y }}` and only parse the same
+ * shape back into a path — but NocoBase server templates (and v1 stored
+ * values) use the bare `{{$X.Y}}` form without the `ctx.` prefix. These
+ * converters keep the picker's output stable against v1 and let already-
+ * stored values round-trip to a labelled pill instead of falling back to a
+ * raw `{{…}}` literal.
+ */
+/**
+ * Variable delimiters: opening + closing tokens. Default `['{{', '}}']`
+ * matches NocoBase server template convention (Handlebars HTML-escaped
+ * output). Pass `['{{{', '}}}']` to switch to Handlebars' raw/unescaped
+ * form — required for fields whose content is rendered as HTML (e.g.
+ * in-app message body) so the variable expansion bypasses HTML escaping.
+ *
+ * Restrict to literal-token pairs, since the regex builder escapes them
+ * verbatim.
+ */
+export type VariableDelimiters = readonly [string, string];
+/**
+ * Factory: returns a `parseValueToPath` bound to the given delimiters.
+ * Anchored (`^…$`) — only treats the whole input as a single variable
+ * reference, matching the v1 single-line picker behaviour.
+ */
+export declare function makeParseVariablePath(delimiters?: VariableDelimiters): (value?: string) => string[] | undefined;
+/**
+ * Factory: returns a `formatPathToValue` bound to the given delimiters.
+ * No inner spaces — matches the v1 storage shape exactly so round-trips
+ * through the API stay byte-stable.
+ */
+export declare function makeFormatVariablePath(delimiters?: VariableDelimiters): (meta?: MetaTreeNode) => string | undefined;
+/**
+ * Factory: returns a global regex matching every occurrence of the
+ * variable token within a longer string. Used by `VariableHybridInput`
+ * to render embedded variables as pills.
+ */
+export declare function makeVariableRegExp(delimiters?: VariableDelimiters): RegExp;
+export declare const parseVariablePath: (value?: string) => string[] | undefined;
+export declare const formatVariablePath: (meta?: MetaTreeNode) => string | undefined;
+/**
+ * Resolve the meta tree the variable picker should expose. Filters the global
+ * meta tree by `namespaces` (top-level property names like `'$env'`,
+ * `'$user'`), appends `extraNodes`, and eagerly resolves any lazy `children`
+ * thunks so labels render on first paint.
+ *
+ * Returns `[]` while loading or when no nodes survive the filter, mirroring
+ * the existing EnvVariableInput behavior so the picker still opens but offers
+ * nothing.
+ */
+export declare function useFilteredMetaTree(options: {
+    namespaces?: string[];
+    extraNodes?: MetaTreeNode[];
+}): MetaTreeNode[];
+export interface VariableInputProps {
+    value?: string;
+    onChange?: (value: string) => void;
+    disabled?: boolean;
+    placeholder?: string;
+    addonBefore?: React.ReactNode;
+    /**
+     * Restrict the picker to specific top-level meta tree namespaces (e.g.
+     * `['$env', '$user']`). When omitted, every registered top-level property is
+     * exposed. Filter happens at the picker level — the underlying regex used
+     * for pill rendering still matches any `{{ ... }}` expression so pre-existing
+     * out-of-scope values stay legible.
+     */
+    namespaces?: string[];
+    /**
+     * Static leaves appended to the picker, after the namespace-filtered nodes.
+     * Use for ad-hoc local-only variables (e.g. `$resetLink`) that are not part
+     * of the global FlowContext registry.
+     */
+    extraNodes?: MetaTreeNode[];
+    /**
+     * Override the converters used by the underlying `VariableHybridInput`.
+     * Mostly useful when the caller wants to constrain `formatPathToValue` to a
+     * specific namespace (see `EnvVariableInput` for that pattern).
+     *
+     * Takes precedence over `delimiters` when both are set on the same field
+     * (an explicit converter wins over the delimiter-derived one).
+     */
+    converters?: VariableHybridInputConverters;
+    /**
+     * Token pair wrapping variable references in the stored string. Defaults
+     * to `['{{', '}}']` — the standard NocoBase server-template form,
+     * HTML-escaped by Handlebars. Pass `['{{{', '}}}']` for fields rendered
+     * as HTML where escaping would corrupt the variable value (e.g. the
+     * in-app message body).
+     *
+     * Ignored when `converters` is also supplied — caller-provided converters
+     * win.
+     */
+    delimiters?: VariableDelimiters;
+    className?: string;
+    style?: React.CSSProperties;
+}
+/**
+ * Inline (single-line) variable input. Renders the literal text and any
+ * `{{ ... }}` references as styled pills via `VariableHybridInput`. Use for
+ * fields like form input titles, email subject lines, or any place a single
+ * line of mixed literal+variable content is appropriate.
+ */
+export declare function VariableInput(props: VariableInputProps): React.JSX.Element;
+export interface VariableTextAreaProps extends Omit<VariableInputProps, 'converters' | 'addonBefore'> {
+    rows?: number;
+    maxRows?: number;
+}
+/**
+ * Multi-line variable input. Variables are inserted as raw `{{ ... }}` text at
+ * the caret rather than rendered as pills — use for email body templates and
+ * other free-form long-form text where literal display of variable expressions
+ * is desirable (the server expands them at render time).
+ */
+export declare function VariableTextArea(props: VariableTextAreaProps): React.JSX.Element;

package/es/components/form/createFormRegistry.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 interface FormRegistryEntry {
+    name: string;
+}
+export interface FormRegistry<T extends FormRegistryEntry> {
+    readonly namespace: string;
+    register(entry: T): void;
+    unregister(name: string): boolean;
+    get(name: string): T | undefined;
+    has(name: string): boolean;
+    list(): T[];
+}
+/**
+ * Create an isolated, namespaced registry of form-like entries.
+ *
+ * Each call returns a fresh registry instance backed by its own closure-scoped
+ * `Map`, so plugins do not share state across namespaces. Plugins that need an
+ * extension point for form-shaped registrations (e.g. storage configuration
+ * forms, data-source connection forms) can build their own typed registry on
+ * top of this primitive instead of re-implementing the same boilerplate.
+ *
+ * Re-registering the same `name` overwrites the previous entry and emits a
+ * console warning. This is intentional so HMR / hot reload works without
+ * throwing, while still surfacing unintended duplicates during development.
+ */
+export declare function createFormRegistry<T extends FormRegistryEntry>(namespace: string): FormRegistry<T>;

package/es/components/form/filter/CollectionFilter.d.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 type { Collection } from '@nocobase/flow-engine';
+import { type ButtonProps, type PopoverProps } from 'antd';
+import React, { FC } from 'react';
+import { CompiledFilter } from './useFilterActionProps';
+export interface CollectionFilterProps {
+    /** Collection whose fields drive the filter row's field picker. */
+    collection: Collection | undefined;
+    /** Called on Submit or Reset with the compiled NocoBase filter param (`undefined` when cleared). */
+    onChange: (filter: CompiledFilter) => void;
+    /** Translator. Defaults to identity. */
+    t?: (key: string, options?: Record<string, any>) => string;
+    /** Whitelist of root-level field names to expose. */
+    filterableFieldNames?: string[];
+    /**
+     * Blacklist of root-level field names to drop. Mirrors v1's `nonfilterable: [...]` on `Filter.Action`. When both `filterableFieldNames` and this prop are supplied, both apply (final = whitelist ∩ ¬blacklist).
+     */
+    nonfilterableFieldNames?: string[];
+    /**
+     * Bypass the `filterableFieldNames` whitelist.
+     *
+     * Legacy escape hatch — prefer adjusting `filterableFieldNames` / `nonfilterableFieldNames` instead.
+     */
+    noIgnore?: boolean;
+    /** Override the trigger button's label. Defaults to `t('Filter')`, or the v1-style `t('{{count}} filter items', { count })` when conditions are present. */
+    buttonText?: React.ReactNode;
+    /** Swap the default `t('Filter')` label for v1's `t('{{count}} filter items', { count })` when conditions are present. Defaults to `true`. */
+    showCount?: boolean;
+    /** Pass-through props for the antd `<Popover>`. */
+    popoverProps?: Omit<PopoverProps, 'open' | 'onOpenChange' | 'content' | 'children'>;
+    /** Pass-through props for the trigger `<Button>`. */
+    buttonProps?: Omit<ButtonProps, 'icon' | 'type' | 'children' | 'onClick'>;
+    /** Min-width applied to the popover body. Defaults to `520`. */
+    popoverMinWidth?: number;
+}
+/**
+ * Filter button bound to a collection. Renders an antd `<Popover>` over a `<Button>`; the popover hosts a multi-condition filter form (field picker, operator, value). Submit dismisses the popover and emits the compiled filter via `onChange`; Reset keeps the popover open and emits `undefined`.
+ *
+ * Pair with `<ExtendCollectionsProvider>` when the target collection is client-only (e.g. a `schema-only` server collection that isn't auto-published to the v2 data source).
+ */
+export declare const CollectionFilter: FC<CollectionFilterProps>;
+export default CollectionFilter;

package/es/components/form/filter/CollectionFilterItem.d.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 { Collection } from '@nocobase/flow-engine';
+import React, { FC } from 'react';
+export interface CollectionFilterItemValue {
+    path: string;
+    operator: string;
+    /** Operator-dependent — string for default ops, descriptor for $date*, etc. */
+    value: any;
+}
+export interface CollectionFilterItemProps {
+    /** Reactive filter row managed by the parent `FilterContainer`. */
+    value: CollectionFilterItemValue;
+    /** Target collection whose fields populate the field selector. */
+    collection: Collection;
+    /** Whitelist of field names to expose; empty/undefined means all filterable fields. */
+    filterableFieldNames?: string[];
+    /**
+     * Blacklist of field names to drop. Mirrors v1's `nonfilterable: [...]` on `Filter.Action`. When both whitelist and blacklist are supplied, both apply (final = whitelist ∩ ¬blacklist).
+     */
+    nonfilterableFieldNames?: string[];
+    /**
+     * Bypass the `filterableFieldNames` whitelist (matches the legacy FilterItem `noIgnore`).
+     *
+     * Legacy escape hatch — prefer adjusting `filterableFieldNames` / `nonfilterableFieldNames` instead.
+     */
+    noIgnore?: boolean;
+    /** Translator; defaults to identity so callers can omit it. */
+    t?: (key: string) => string;
+}
+/**
+ * Filter row bound directly to a `Collection`, with no `FlowModel` dependency. Use this from settings pages or other surfaces that need a filter UI but don't have (and shouldn't synthesise) a block model just to satisfy `FilterItem`. Pair with `FilterContainer` via either an inline wrapper or `createCollectionFilterItem(collection)`.
+ *
+ * The field selector is an antd `Cascader`, mirroring v1's `Filter.Action` so association fields (belongsTo / m2o / etc.) can be drilled into — picking `user.username` is a first-class action. The value renderer is delegated to `FilterValueInput`, which dispatches to interface-specific controls (the smart date picker for `$date*` operators, tag-mode Select for array/enum, etc.) the same way v1's `DynamicComponent` did.
+ */
+export declare const CollectionFilterItem: FC<CollectionFilterItemProps>;
+/**
+ * Convenience factory returning a `FilterContainer`-compatible `FilterItem` component bound to a specific collection. Avoids creating an inline closure on every parent render, which would otherwise reset any focused inner antd control.
+ */
+export declare function createCollectionFilterItem(collection: Collection, bound?: Pick<CollectionFilterItemProps, 'filterableFieldNames' | 'nonfilterableFieldNames' | 'noIgnore' | 't'>): React.FC<{
+    value: CollectionFilterItemValue;
+}>;
+export default CollectionFilterItem;

package/es/components/form/filter/DateFilterDynamicComponent.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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 { type Dayjs } from 'dayjs';
+import React from 'react';
+/**
+ * Value shape used by NocoBase's `$date*` filter operators. Two flavours:
+ *
+ * - For "Exact day" mode: a **formatted string** at the granularity of the picker — `"2026-02-15"` (date), `"2026-02"` (month), `"2026"` (year), `"2026-Q1"` (quarter). For `$dateBetween` (`isRange`), a `[string, string]` tuple. Strings (not Dayjs) so the value serializes verbatim into the query string the same way v1 does (`filter=%7B%22$and%22:[%7B%22lockedTs%22:%7B%22$dateOn%22:%222026-02%22%7D%7D]%7D`).
+ * - For relative modes (Today / Past 3 days / This Week / …): a `{ type, number?, unit? }` descriptor that the server resolves to a concrete range at query time.
+ */
+export type DateFilterValue = string | [string, string] | {
+    type: string;
+    number?: number;
+    unit?: 'day' | 'week' | 'month' | 'year';
+} | null | undefined;
+export interface DateFilterDynamicComponentProps {
+    value?: DateFilterValue;
+    onChange?: (value: DateFilterValue) => void;
+    /** `true` for `$dateBetween`; renders a `DatePicker.RangePicker`. */
+    isRange?: boolean;
+    /**
+     * Translator. Defaults to identity so callers can omit it when running outside a translation context (tests, storybook).
+     */
+    t?: (key: string) => string;
+}
+type PickerMode = 'date' | 'month' | 'quarter' | 'year';
+/**
+ * The exact format strings NocoBase's `$date*` server operators expect per picker granularity. Mirrors v1's `getPickerFormat` output under `underFilter=true`, so the URL-encoded query stays identical.
+ *
+ * Exported for unit tests and for downstream callers that need to parse / format `$date*` values outside this component.
+ */
+export declare const FORMAT_BY_PICKER: Record<PickerMode, string>;
+/**
+ * Parse a granularity-formatted string back into a `Dayjs`. Returns `null` on missing or unparseable input so the DatePicker's controlled-value contract stays clean.
+ */
+export declare const parseDateFilterValue: (value: string | undefined, picker: PickerMode) => Dayjs | null;
+/**
+ * Format a `Dayjs` (typically from `DatePicker.onChange`) into the server-facing string at the active picker's granularity. Returns `undefined` for empty input so callers can drop the value entirely.
+ */
+export declare const formatDateFilterValue: (value: Dayjs | null | undefined, picker: PickerMode) => string | undefined;
+/**
+ * v2 port of v1's `DateFilterDynamicComponent` — a multi-mode value input for the `$date*` operator family. Three sub-controls glued in a `Space.Compact` row:
+ *
+ * 1. Mode select — `Exact day` / `Past` / `Next` / `Today` / `This Week` / … Picking a relative mode emits a `{ type, number?, unit? }` descriptor that the server resolves at query time; picking `Exact day` emits a raw `Dayjs` instead.
+ * 2. Picker granularity — only when mode is `Exact day`: `Date` / `Month` / `Quarter` / `Year`. Controls the antd `DatePicker`'s `picker` mode so admins can filter to e.g. "any day in 2026-03".
+ * 3. Date input — antd `DatePicker` for single dates, or `DatePicker.RangePicker` when `isRange` is true (used by `$dateBetween`).
+ *
+ * v1 wired its own `<DatePicker.FilterWithPicker>` for the third slot; v2 inlines the picker-granularity selector here so we don't have to fork antd's DatePicker. Drops v1's `@emotion/css` (uses antd token spacing) and the `useCompile` schema-template chain (call sites pass a plain `t` translator).
+ */
+export declare const DateFilterDynamicComponent: React.FC<DateFilterDynamicComponentProps>;
+export default DateFilterDynamicComponent;

package/es/components/form/filter/FilterValueInput.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 type { FilterOperator, FilterOption } from '../../../flow/components/filter/useFilterOptions';
+export interface FilterValueInputProps {
+    /** The currently selected leaf field option from the field picker. */
+    field?: FilterOption;
+    /** The currently selected operator (full object, not just `.value`). */
+    operator?: FilterOperator;
+    /** Current value. Shape depends on operator/field. */
+    value: any;
+    /** Notify the parent when the user edits the value. */
+    onChange: (value: any) => void;
+    /** Translator used by sub-renderers. */
+    t?: (key: string) => string;
+    /** Optional placeholder for the fallback `Input`. */
+    placeholder?: string;
+}
+/**
+ * Interface-aware value renderer for filter rows. Returns `null` for `noValue` operators (`$empty`, `$notEmpty`). Otherwise dispatches the effective `x-component` (operator schema > field uiSchema > Input) to a small registry of antd controls.
+ */
+export declare const FilterValueInput: React.FC<FilterValueInputProps>;
+export default FilterValueInput;

package/es/components/form/filter/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 { CollectionFilter } from './CollectionFilter';
+export type { CollectionFilterProps } from './CollectionFilter';
+export type { CompiledFilter } from './useFilterActionProps';

package/es/components/form/filter/useFilterActionProps.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 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 { Collection } from '@nocobase/flow-engine';
+import { FilterOption, UseFilterOptionsArgs } from '../../../flow/components/filter/useFilterOptions';
+import { CollectionFilterItemValue, createCollectionFilterItem } from './CollectionFilterItem';
+/** A single condition row (`{ path, operator, value }`) or a nested group. */
+export type FilterGroupItem = CollectionFilterItemValue | FilterGroupValue;
+/**
+ * Reactive shape consumed by `FilterContainer` / `FilterGroup`. `logic` is the join (`$and` / `$or`) and `items` is a heterogeneous list of leaf conditions and nested groups.
+ */
+export type FilterGroupValue = {
+    logic: '$and' | '$or';
+    items: FilterGroupItem[];
+};
+/** Compiled filter param accepted by NocoBase resource `list`. */
+export type CompiledFilter = Record<string, unknown> | undefined;
+interface FilterCtxModel {
+    translate: (key: string) => string;
+    dispatchEvent: (event: 'submit' | 'reset' | (string & {})) => void;
+}
+export interface FilterCtx {
+    model: FilterCtxModel;
+}
+/**
+ * Compile a reactive filter group into the `{ $and: [{ path: { op: val } }] }` envelope accepted by NocoBase's resource `list` filter param. Returns `undefined` when the group is empty so callers can drop the param.
+ *
+ * Mirrors v1's `removeNullCondition` + filter compile path, but works on the v2 `{ logic, items }` group structure rather than v1's Formily-bracketed `$and.0.path.$eq` shape:
+ *
+ * - Rows missing `path` or `operator` are dropped (still mid-edit).
+ * - Rows whose `value` is empty (`undefined`, `''`, `[]`, `{}`) are dropped — matches v1, which sends `filter={}` for a row with only a field/operator picked. Sending `{lockedTs:{}}` would 500.
+ * - Dotted association paths (`user.createdBy.password`) are expanded into nested objects — matches v1's payload shape, which the server resolves along the association chain rather than treating the dotted string as a single key.
+ * - Empty groups (after pruning) propagate as `undefined` so the outermost caller can drop the whole `filter` param.
+ */
+export declare function compileFilterGroup(group: FilterGroupValue | undefined): CompiledFilter;
+/** Which footer button triggered the apply — useful for closing a popover on Submit but keeping it open on Reset. */
+export type FilterApplyAction = 'submit' | 'reset';
+export interface UseFilterActionPropsArgs extends UseFilterOptionsArgs {
+    /** Collection whose fields populate the filter row's field picker. */
+    collection: Collection | undefined;
+    /**
+     * Called when the user submits or resets the filter popover. Receives the compiled filter param (`undefined` when cleared) and which footer button triggered the call. Typical implementation: `(filter, action) => { listRequest.run(filter); if (action === 'submit') closePopover(); }`.
+     */
+    onApply: (filter: CompiledFilter, action: FilterApplyAction) => void;
+}
+export interface UseFilterActionPropsResult {
+    /**
+     * Reactive filter group state. Pass directly to `<FilterContent value={...}>`. Stable across renders.
+     */
+    value: FilterGroupValue;
+    /** Field-option tree (for inspection or custom badges). */
+    options: FilterOption[];
+    /** Bound `FilterItem` component to plug into `<FilterContent FilterItem={...}>`. */
+    FilterItem: ReturnType<typeof createCollectionFilterItem> | undefined;
+    /**
+     * Ready-to-use `ctx` for `<FilterContent ctx={...}>`. Wires Submit / Reset buttons to `onSubmit` / `onReset` below.
+     */
+    ctx: FilterCtx;
+    /** Imperative trigger — submit current group as a compiled filter. */
+    onSubmit: () => void;
+    /** Imperative trigger — clear the group and emit an empty filter. */
+    onReset: () => void;
+    /**
+     * Count of top-level condition rows. Useful for showing a badge like `Filter (3)` on the trigger button — matches v1's `field.title = t('{{count}} filter items', { count })`.
+     */
+    conditionCount: number;
+}
+/**
+ * v2 equivalent of v1's `useFilterActionProps` for non-schema surfaces (settings pages, panels, side drawers). Bundles three things v1's hook returned implicitly through schema:
+ *
+ * - A reactive `{ logic, items }` group state that `<FilterContent>` reads.
+ * - A bound `FilterItem` component (driven by `createCollectionFilterItem`).
+ * - A `ctx` object that turns `<FilterContent>`'s `dispatchEvent('submit' | 'reset')` into a compiled filter param passed to `onApply`.
+ *
+ * Pair with antd `Popover` to recreate the legacy `Filter.Action` UX:
+ *
+ * ```tsx
+ * const { value, ctx, FilterItem, onSubmit, conditionCount } = useFilterActionProps({
+ *   collection,
+ *   onApply: (filter) => listRequest.run(filter),
+ *   t,
+ * });
+ * return (
+ *   <Popover content={<FilterContent value={value} ctx={ctx} FilterItem={FilterItem} />}>
+ *     <Button>{t('Filter')}{conditionCount ? ` (${conditionCount})` : ''}</Button>
+ *   </Popover>
+ * );
+ * ```
+ */
+export declare function useFilterActionProps(args: UseFilterActionPropsArgs): UseFilterActionPropsResult;
+export {};

package/es/components/form/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 './createFormRegistry';
+export * from './filter';
+export * from './DialogFormLayout';
+export * from './DrawerFormLayout';
+export * from './EnvVariableInput';
+export * from './FileSizeInput';
+export * from './JsonTextArea';
+export * from './PasswordInput';
+export * from './RemoteSelect';
+export * from './VariableInput';

package/es/components/form/table/RowOverlayPreview.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 type { RowSnapshot } from './utils';
+/**
+ * Floating clone of the row being dragged, rendered inside a `<DragOverlay>`
+ * so it follows the cursor while the source row stays in place. We inject the
+ * snapshot's `outerHTML` straight into a mini `<table>` so every antd class
+ * (`ant-table-cell`, `ant-table-selection-column`, theme tokens, etc.) is
+ * preserved. A `<colgroup>` re-applies the measured cell widths so the clone
+ * lines up column-for-column with the source row; the wrapper's pinned
+ * `height` + table `height:100%` keeps vertical sizing consistent regardless
+ * of which antd table size variant the caller picked.
+ *
+ * The wrapper also carries `overlayCellStylesClassName` so the index numeric
+ * (`.nb-table-index`) is hidden while dragging — only the handle + checkbox
+ * are surfaced inside the floating clone.
+ */
+export declare function RowOverlayPreview(props: {
+    snapshot: RowSnapshot;
+}): React.JSX.Element;

package/es/components/form/table/SelectionCell.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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';
+export interface SelectionCellProps {
+    /** Whether the row is currently selected — drives the index/checkbox swap. */
+    checked: boolean;
+    /** Zero-based row index (within the current page). `TableIndex` displays it as `index + 1`. */
+    index: number;
+    /** Render the drag handle on the left gutter. Mutually exclusive with `showStandaloneHandle`. */
+    showHandle: boolean;
+    /** Render the row index numeric. When `false` only the antd checkbox is shown (default antd UX). */
+    showIndex: boolean;
+    /** The original antd checkbox node produced by `rowSelection.renderCell`. */
+    originalNode: React.ReactNode;
+}
+/**
+ * The body half of the rowSelection column. Renders, in order:
+ *   1. An absolute-positioned drag handle pinned to the left gutter (only
+ *      when `showHandle` is true). The parent `<td>` must be
+ *      `position: relative` for the handle to land inside the gutter —
+ *      `selectionGutterClassName` in `styles.ts` adds that.
+ *   2. A `.nb-row-selection-cell` wrapper that contains both the row index
+ *      and the checkbox. CSS in `indexSwapClassName` swaps which one is
+ *      visible depending on hover / `checked` state.
+ *
+ * When `showIndex` is false we drop the swap entirely and render only the
+ * original antd checkbox — matches the default antd selection column UX for
+ * tables that don't want the index numeric.
+ */
+export declare function SelectionCell(props: SelectionCellProps): React.JSX.Element;

package/es/components/form/table/Table.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 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 { type TableProps as AntdTableProps } from 'antd';
+import React from 'react';
+import { type RowKey } from './utils';
+/**
+ * Default initial page size for `Table`. Exposed so consumers can seed their
+ * controlled `pageSize` state with the same value the component would use if
+ * they relied purely on the built-in pagination defaults.
+ */
+export declare const DEFAULT_PAGE_SIZE = 50;
+/**
+ * Default `pageSizeOptions` injected into the pagination config. Matches the
+ * v1 settings-page table so users see the same choices across versions.
+ * Consumers can override by passing their own `pageSizeOptions` in
+ * `pagination`.
+ */
+export declare const PAGE_SIZE_OPTIONS: readonly number[];
+export interface TableProps<RecordType extends object = any> extends AntdTableProps<RecordType> {
+    /**
+     * Required so drag-sort, hover-swap and row identity work. Accepts the same
+     * shape as antd `Table.rowKey`. When passed as a function it gets the
+     * record + index and must return a serializable id.
+     */
+    rowKey: RowKey<RecordType>;
+    /**
+     * Show row index (1, 2, 3, …) in the rowSelection column by default; hovering
+     * a row or selecting it reveals the checkbox in the same cell. Requires
+     * `rowSelection` — the index lives in the selection column. Defaults to
+     * `true`.
+     */
+    showIndex?: boolean;
+    /**
+     * Enable vertical drag-and-drop row reordering. When true, rows show a drag
+     * handle on the left and `onSortEnd` fires after each drop. Defaults to
+     * `false`; the rest of the table behaves like a plain antd Table.
+     */
+    isDraggable?: boolean;
+    /**
+     * Called after a row is dropped onto another. Only used when `isDraggable`
+     * is true. The caller persists the move (e.g. `resource.move(...)`) and
+     * refreshes `dataSource` — this component does NOT mutate the data array.
+     */
+    onSortEnd?: (from: RecordType, to: RecordType) => void | Promise<void>;
+    /**
+     * Hide the drag handle entirely while still keeping `isDraggable` on. Useful
+     * when the caller wants to embed `<SortHandle />` inside a custom column.
+     * Defaults to `true`.
+     */
+    showSortHandle?: boolean;
+    /**
+     * Override the width of the auto-inserted handle column when `rowSelection`
+     * is absent. When `rowSelection` is provided the handle is rendered inside
+     * the selection column instead, so this prop is ignored.
+     */
+    sortHandleColumnWidth?: number;
+}
+/**
+ * Generic v2 settings-page table primitive. Built on antd's `Table` and adds:
+ *
+ * - Row-index ↔ checkbox swap inside the selection column (`showIndex`,
+ *   on by default): index visible at rest, checkbox shows on hover or when
+ *   selected. Both elements are absolutely positioned inside the cell so
+ *   they share the same center anchor and never compete for layout space.
+ * - Optional vertical drag-and-drop reordering (`isDraggable`): handle is
+ *   absolute-positioned in a 32px left gutter so the checkbox column stays
+ *   visually centered. The drag overlay renders an `outerHTML` clone of the
+ *   source `<tr>`; the index is suppressed inside the clone so the row
+ *   being moved doesn't display a stale ordinal.
+ *
+ * Use this in place of antd `Table` for any settings-page list. When
+ * `isDraggable` is false the component is a thin pass-through to antd Table
+ * plus the index swap, so it is safe as the default table on any page.
+ */
+export declare function Table<RecordType extends object = any>(props: TableProps<RecordType>): React.JSX.Element;
+export default Table;

package/es/components/form/table/constants.d.ts

@@ -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.
+ */
+/**
+ * Pixel reservation on the left side of the rowSelection column for the drag
+ * handle. Used by the runtime `selectionGutterClassName` (real table) and by
+ * the drag overlay `overlayCellStylesClassName` (floating clone) so both
+ * variants put the handle in the same gutter position.
+ */
+export declare const SORT_HANDLE_GUTTER = 32;