@nocobase/client-v2 2.1.0-alpha.40 → 2.1.0-alpha.46

package/es/collection-manager/interfaces/updatedAt.d.ts

@@ -47,50 +47,7 @@ export declare class UpdatedAtFieldInterface extends CollectionFieldInterface {
         };
     };
     filterable: {
-        operators: ({
-            label: string;
-            value: string;
-            selected: boolean;
-            schema: {
-                'x-component': string;
-                'x-component-props': {
-                    isRange: boolean;
-                };
-            };
-            onlyFilterAction: boolean;
-            noValue?: undefined;
-        } | {
-            label: string;
-            value: string;
-            schema: {
-                'x-component': string;
-                'x-component-props': {
-                    isRange: boolean;
-                };
-            };
-            onlyFilterAction: boolean;
-            selected?: undefined;
-            noValue?: undefined;
-        } | {
-            label: string;
-            value: string;
-            schema: {
-                'x-component': string;
-                'x-component-props': {
-                    isRange: boolean;
-                };
-            };
-            selected?: undefined;
-            onlyFilterAction?: undefined;
-            noValue?: undefined;
-        } | {
-            label: string;
-            value: string;
-            noValue: boolean;
-            selected?: undefined;
-            schema?: undefined;
-            onlyFilterAction?: undefined;
-        })[];
+        operators: string;
     };
     titleUsable: boolean;
 }

package/es/collection-manager/interfaces/updatedBy.d.ts

@@ -6,7 +6,6 @@
  * 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 { ISchema } from '@formily/react';
 import { CollectionFieldInterface } from '../../collection-field-interface/CollectionFieldInterface';
 export declare class UpdatedByFieldInterface extends CollectionFieldInterface {
     name: string;
@@ -56,8 +55,5 @@ export declare class UpdatedByFieldInterface extends CollectionFieldInterface {
         nested: boolean;
         children: any[];
     };
-    schemaInitialize(schema: ISchema, { block }: {
-        block: any;
-    }): void;
     description: string;
 }

package/es/collection-manager/interfaces/url.d.ts

@@ -6,7 +6,6 @@
  * 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 { ISchema } from '@formily/react';
 import { CollectionFieldInterface } from '../../collection-field-interface/CollectionFieldInterface';
 export declare class UrlFieldInterface extends CollectionFieldInterface {
     name: string;
@@ -26,9 +25,6 @@ export declare class UrlFieldInterface extends CollectionFieldInterface {
         value: string;
     }[];
     availableTypes: string[];
-    schemaInitialize(schema: ISchema, { block }: {
-        block: any;
-    }): void;
     validationType: string;
     availableValidationOptions: string[];
     properties: {
@@ -52,21 +48,6 @@ export declare class UrlFieldInterface extends CollectionFieldInterface {
     };
     titleUsable: boolean;
     filterable: {
-        operators: ({
-            label: string;
-            value: string;
-            selected: boolean;
-            noValue?: undefined;
-        } | {
-            label: string;
-            value: string;
-            selected?: undefined;
-            noValue?: undefined;
-        } | {
-            label: string;
-            value: string;
-            noValue: boolean;
-            selected?: undefined;
-        })[];
+        operators: string;
     };
 }

package/es/collection-manager/interfaces/uuid.d.ts

@@ -69,15 +69,6 @@ export declare class UUIDFieldInterface extends CollectionFieldInterface {
                     'x-decorator': string;
                     'x-component': string;
                     'x-disabled': string;
-                    'x-reactions': {
-                        dependencies: string[];
-                        when: string;
-                        fulfill: {
-                            state: {
-                                value: boolean;
-                            };
-                        };
-                    }[];
                 };
                 unique: {
                     type: string;
@@ -85,36 +76,12 @@ export declare class UUIDFieldInterface extends CollectionFieldInterface {
                     'x-decorator': string;
                     'x-component': string;
                     'x-disabled': string;
-                    'x-reactions': {
-                        dependencies: string[];
-                        when: string;
-                        fulfill: {
-                            state: {
-                                value: boolean;
-                            };
-                        };
-                    }[];
                 };
             };
         };
     };
     filterable: {
-        operators: ({
-            label: string;
-            value: string;
-            selected: boolean;
-            noValue?: undefined;
-        } | {
-            label: string;
-            value: string;
-            selected?: undefined;
-            noValue?: undefined;
-        } | {
-            label: string;
-            value: string;
-            noValue: boolean;
-            selected?: undefined;
-        })[];
+        operators: string;
     };
     titleUsable: boolean;
 }

package/es/collection-manager/template-fields.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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 { ReactNode } from 'react';
+export interface CollectionTemplateFieldOption {
+    label: ReactNode;
+    value: string | number | boolean;
+    [key: string]: unknown;
+}
+export interface CollectionTemplateField {
+    name: string;
+    interface?: string;
+    type?: string;
+    title?: ReactNode;
+    options?: CollectionTemplateFieldOption[];
+    component?: string;
+    componentProps?: Record<string, unknown>;
+    uiSchema?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface FieldInterfaceConfigureLike {
+    default?: {
+        uiSchema?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+}
+interface FieldInterfaceLike {
+    default?: {
+        uiSchema?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+}
+export interface CollectionTemplateFieldNormalizeManager {
+    getFieldInterfaceConfigure?: (name: string, collectionInfo?: Record<string, unknown>) => FieldInterfaceConfigureLike | undefined;
+    getFieldInterface?: (name: string) => FieldInterfaceLike | undefined;
+}
+export interface NormalizeCollectionTemplateFieldOptions {
+    collectionInfo?: Record<string, unknown>;
+}
+export declare function normalizeCollectionTemplateField(field: CollectionTemplateField, manager?: CollectionTemplateFieldNormalizeManager, options?: NormalizeCollectionTemplateFieldOptions): {
+    [key: string]: unknown;
+    uiSchema?: Record<string, unknown>;
+} & CollectionTemplateField;
+export declare function normalizeCollectionTemplateFields(fields?: CollectionTemplateField[], manager?: CollectionTemplateFieldNormalizeManager, options?: NormalizeCollectionTemplateFieldOptions): ({
+    [key: string]: unknown;
+    uiSchema?: Record<string, unknown>;
+} & CollectionTemplateField)[];
+export {};

package/es/components/KeepAlive.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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, { FC } from 'react';
+export declare const KeepAliveProvider: FC<{
+    active: boolean;
+    parentActive: boolean;
+}>;
+export declare const useKeepAlive: () => {
+    active: boolean;
+};
+interface KeepAliveProps {
+    uid: string;
+    children: (uid: string) => React.ReactNode;
+}
+export declare const KeepAlive: FC<KeepAliveProps>;
+export {};

package/es/components/RouterBridge.d.ts

@@ -7,7 +7,16 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Application } from '../Application';
+type LayoutMatchLike = {
+    id: string;
+    pathname: string;
+};
+type LayoutDefinitionLike = {
+    routeName: string;
+};
+export declare function findDeepestLayoutMatch(layouts?: LayoutDefinitionLike[], matches?: LayoutMatchLike[]): LayoutMatchLike;
 export declare function useRouterSync(app: Application): void;
 export declare function RouterBridge({ app }: {
     app: any;
 }): any;
+export {};

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

@@ -12,17 +12,9 @@ export interface DialogFormLayoutProps {
     title: React.ReactNode;
     /** Form body — typically a `<Form>` wrapping `<Form.Item>` fields. */
     children: React.ReactNode;
-    /**
-     * Called before the dialog is closed by the Cancel button or the
-     * top-right close (X) icon. Use for "discard changes" confirmations.
-     */
+    /** Called before the dialog is closed by the Cancel button or the top-right close (X) icon. Use for "discard changes" confirmations. */
     onCancel?: () => void | Promise<void>;
-    /**
-     * Called when the Submit button is clicked. Caller owns validation
-     * + the actual API call; the dialog is closed automatically when
-     * `onSubmit` resolves. Throw from `onSubmit` to keep the dialog open
-     * (e.g. on a validation error).
-     */
+    /** Called when the Submit button is clicked. Caller owns validation + the actual API call; the dialog is closed automatically when `onSubmit` resolves. Throw from `onSubmit` to keep the dialog open (e.g. on a validation error). */
     onSubmit?: () => void | Promise<void>;
     /** Drives the Submit button's loading state. */
     submitting?: boolean;
@@ -30,29 +22,13 @@ export interface DialogFormLayoutProps {
     submitText?: React.ReactNode;
     /** Override the Cancel button label. Defaults to "Cancel". */
     cancelText?: React.ReactNode;
-    /**
-     * Full override of the footer content. When provided, the default
-     * Cancel + Submit buttons are replaced. Useful for forms that need
-     * extra actions (e.g. Preview, Save draft).
-     */
+    /** Full override of the footer content. When provided, the default Cancel + Submit buttons are replaced. Useful for forms that need extra actions (e.g. Preview, Save draft). */
     footer?: React.ReactNode;
 }
 /**
- * Standard layout for dialog-hosted forms — the dialog counterpart of
- * `DrawerFormLayout`. Title sits left-aligned in the dialog's native
- * header (no inline close icon — the dialog provides its own X in the
- * top-right when opened with `viewer.dialog({ closable: true, ... })`),
- * the form body fills the middle, and a Cancel + Submit footer sits
- * at the bottom.
+ * Standard layout for dialog-hosted forms — the dialog counterpart of `DrawerFormLayout`. Title sits left-aligned in the dialog's native header, the form body fills the middle, and a Cancel + Submit footer sits at the bottom. Neither this layout nor `DrawerFormLayout` renders a close icon — both rely on the caller passing `closable: true` at the `viewer.dialog` / `viewer.drawer` call site to surface antd Modal's native top-right X (Dialog) or antd Drawer's native left-side X (Drawer).
  *
- * Why not just reuse `DrawerFormLayout`? `DrawerFormLayout` injects a
- * `<CloseOutlined>` button next to the title — that's the drawer
- * visual contract (close lives near the title in a side panel). In a
- * centered dialog the native top-right close button is the expected
- * affordance, so a separate layout keeps the visual contract clean.
- *
- * Callers own the `<Form>` instance, validation, and the actual API
- * call. This component only handles the chrome and close behaviour.
+ * Callers own the `<Form>` instance, validation, and the actual API call. This component only handles the chrome and close behaviour.
  *
  * Example:
  *

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

@@ -0,0 +1,75 @@
+/**
+ * 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 } from '@nocobase/flow-engine';
+import React from 'react';
+import { type VariableDelimiters } from './VariableInput';
+/**
+ * Constant types this input can edit. Subset of v1 `Variable.Input`
+ * `useTypedConstant` — drops `'object'` (no v2 JSON editor yet) and `'null'`
+ * (handled by the dedicated `nullable` prop).
+ */
+export type TypedConstantType = 'string' | 'number' | 'boolean' | 'date';
+/**
+ * One allowed constant type. Either a bare type name (`'number'`) or a
+ * `[type, editorProps]` pair (`['number', { min: 1, max: 65535 }]`) where
+ * `editorProps` is forwarded to the antd editor for that type — same
+ * shape as v1 `useTypedConstant`.
+ */
+export type TypedConstantSpec = TypedConstantType | [TypedConstantType, Record<string, unknown>];
+export interface TypedVariableInputProps {
+    /**
+     * Stored value. A `{{ ... }}` string is treated as a variable reference;
+     * anything else is a constant of the inferred type.
+     */
+    value?: unknown;
+    onChange?: (next: unknown) => void;
+    /**
+     * Allowed constant types. The `Constant` switcher entry always exposes a
+     * typed submenu (matching v1 `Variable.Input`) so users can see what type
+     * the constant is, even when only one type is permitted. Default: all four
+     * supported types.
+     */
+    types?: TypedConstantSpec[];
+    /**
+     * Restrict the variable picker to specific top-level meta-tree namespaces
+     * (e.g. `['$env']`). When omitted, every registered top-level property is
+     * exposed — matching `VariableInput`'s default behaviour.
+     */
+    namespaces?: string[];
+    /** Additional leaves appended to the picker after the namespace-filtered nodes. */
+    extraNodes?: MetaTreeNode[];
+    /**
+     * When true (default), the switcher exposes a `Null` option that resets the
+     * value to `null`. When false, the value is constrained to one of the
+     * allowed types or a variable reference.
+     */
+    nullable?: boolean;
+    /** Variable-token delimiters. Default `['{{', '}}']` — see `VariableInput`. */
+    delimiters?: VariableDelimiters;
+    disabled?: boolean;
+    placeholder?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+/**
+ * Constant-or-variable input. Port of v1 `Variable.Input` typed-constant
+ * Cascader pattern (the `[Null | Constant<type> | Variable<…namespaces>]`
+ * switcher). Use this when a field can accept either a typed literal
+ * (number, boolean, date, string) or a variable reference like
+ * `{{ $env.SMTP_PORT }}` — see `plugin-notification-email`'s port / secure
+ * fields for the canonical example.
+ *
+ * Pure literal fields should keep using the antd primitive
+ * (`InputNumber`, `Select`, `DatePicker`). Pure variable fields should keep
+ * using `EnvVariableInput` / `VariableInput`. This component carries the
+ * Cascader switcher overhead, so reach for it only when the field
+ * genuinely accepts both shapes.
+ */
+export declare function TypedVariableInput(props: TypedVariableInputProps): React.JSX.Element;
+export default TypedVariableInput;

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

@@ -8,8 +8,45 @@
  */
 import { type MetaTreeNode, type VariableHybridInputConverters } from '@nocobase/flow-engine';
 import React from 'react';
-export declare function parseVariablePath(value?: string): string[] | undefined;
-export declare function formatVariablePath(meta?: MetaTreeNode): string | undefined;
+/**
+ * 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'`,
@@ -48,8 +85,22 @@ export interface VariableInputProps {
      * 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;
 }

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';