@1money/component-ui 0.0.75 → 0.0.77

package/es/components/ProForm/interface.d.ts

@@ -1,5 +1,6 @@
 import type { ReactNode, FC, ReactElement, MutableRefObject, CSSProperties, FormHTMLAttributes } from 'react';
-import type { FormInstance, FormSize, LabelAlign, ValidateStatus, ValidateTrigger, Rule } from './core/interface';
+import type { FormInstance, FormSize, LabelAlign, ValidateStatus, ValidateTriggerProp, FormRule } from './core/interface';
+import type { ProFormFieldName, ProFormPathValue, ProFormFieldValueMap, ProFormRecursivePartial, ProFormValuesPatch } from './core/namePathType';
 import type { ButtonProps, ButtonSize } from "../Button";
 import type { DrawerProps, DrawerPlacement } from "../Drawer";
 import type { GridRowProps, GridColSize } from "../Grid";
@@ -7,28 +8,24 @@ import type { DialogProps } from "../Dialog";
 import type { ProFormMode } from './constants';
 import type { ProFormSyncToUrl } from './hooks/useUrlSync';
 export type { ProFormSyncToUrl };
-export type ProFormFieldTransformFn = (value: unknown, name: string, allValues: Record<string, unknown>) => unknown;
-export type ProFormDateFormatter = 'string' | 'number' | (string & {}) | ((value: Date, name: string) => unknown) | false;
-export type ProFormFieldConvertValueFn = (value: unknown, name: string) => unknown;
+export type { ProFormFieldName, ProFormPathValue, ProFormFieldValueMap, ProFormRecursivePartial, ProFormValuesPatch, } from './core/namePathType';
+export type ProFormFieldTransformFn<Values = Record<string, any>, Name extends ProFormFieldName<Values> = ProFormFieldName<Values>> = (value: ProFormPathValue<Values, Name>, name: Name, allValues: Values) => any;
+export type ProFormDateFormatter = 'string' | 'number' | (string & {}) | ((value: Date, name: string) => any) | false;
+export type ProFormFieldConvertValueFn<Values = Record<string, any>, Name extends ProFormFieldName<Values> = ProFormFieldName<Values>> = (value: ProFormPathValue<Values, Name>, name: Name) => any;
 export type ProFormValueEnumObj = Record<string | number, string | {
     text: string;
     disabled?: boolean;
 }>;
-/**
- * Top-level keys of `Values` (for editor autocomplete) while still accepting
- * any string — names may be dot-paths (`"address.city"`), list paths
- * (`"items.0.qty"`), or keys produced by a renaming `transform`.
- */
-export type ProFormFieldName<Values = Record<string, unknown>> = Extract<keyof Values, string> | (string & {});
 export interface ProFormColProps {
     span?: number;
     sm?: GridColSize;
     md?: GridColSize;
     lg?: GridColSize;
 }
-export interface ProFormRequestOption {
+export type ProFormFieldOptionValue<Values = Record<string, any>, Name extends ProFormFieldName<Values> = ProFormFieldName<Values>> = Name extends ProFormFieldName<Values> ? ProFormPathValue<Values, Name> extends readonly (infer Item)[] ? Item : ProFormPathValue<Values, Name> : never;
+export interface ProFormRequestOption<Value = any> {
     label: string;
-    value: unknown;
+    value: Value;
     disabled?: boolean;
 }
 /**
@@ -37,32 +34,32 @@ export interface ProFormRequestOption {
  * Each branch declares the other property as `undefined` so unguarded access
  * (`result.values`) still type-checks as `Values | undefined`.
  */
-export type ProFormValidateResult<Values = Record<string, unknown>> = {
+export type ProFormValidateResult<Values = Record<string, any>> = {
     success: true;
     values: Values;
     errors?: undefined;
 } | {
     success: false;
-    errors: Record<string, string>;
+    errors: Record<string, ReactNode>;
     values?: undefined;
 };
-export interface ProFormFormInstance<Values = Record<string, unknown>> extends FormInstance<Values> {
+export interface ProFormFormInstance<Values = Record<string, any>> extends FormInstance<Values> {
     getFieldsFormatValue: () => Values;
     /** Single-field value with dateFormatter + transform applied (no omitNil). */
-    getFieldFormatValue: (name: string) => unknown;
+    getFieldFormatValue: <Name extends ProFormFieldName<Values>>(name: Name) => ProFormPathValue<Values, Name>;
     /**
      * Formatted values as an object: the whole form when `name` is omitted,
      * otherwise narrowed to the top-level key of `name` (note: a `transform`
      * that RENAMES its key keeps the renamed shape and may not match `name`).
      */
-    getFieldFormatValueObject: (name?: string) => Record<string, unknown>;
+    getFieldFormatValueObject: (name?: ProFormFieldName<Values>) => Record<string, any>;
     validateFieldsReturnFormatValue: () => Promise<ProFormValidateResult<Values>>;
     submitForm: () => Promise<void>;
 }
-export interface ProFormStateContextValue {
-    values: Record<string, unknown>;
-    errors: Record<string, string>;
-    warnings: Record<string, string>;
+export interface ProFormStateContextValue<Values = Record<string, any>> {
+    values: Values;
+    errors: Record<string, ReactNode>;
+    warnings: Record<string, ReactNode>;
     touched: Record<string, boolean>;
     validating: Record<string, boolean>;
 }
@@ -79,38 +76,37 @@ export interface ProFormLayoutConfig {
      */
     itemGap?: number | string;
 }
-export interface ProFormStableContextValue {
-    formInstance: ProFormFormInstance;
-    setFieldValue: (name: string, value: unknown) => void;
-    setFieldError: (name: string, error: string | null) => void;
-    setFieldWarning: (name: string, warning: string | null) => void;
-    validateField: (name: string, rules: Rule[], providedValue?: unknown) => boolean;
-    validateFieldAsync: (name: string, value: unknown, rules: Rule[]) => Promise<{
+export interface ProFormStableContextValue<Values = Record<string, any>> {
+    formInstance: ProFormFormInstance<Values>;
+    setFieldValue: <Name extends ProFormFieldName<Values>>(name: Name, value: ProFormPathValue<Values, Name>) => void;
+    setFieldError: (name: ProFormFieldName<Values>, error: ReactNode | null) => void;
+    setFieldWarning: (name: ProFormFieldName<Values>, warning: ReactNode | null) => void;
+    validateFieldAsync: <Name extends ProFormFieldName<Values>>(name: Name, value: ProFormPathValue<Values, Name>, rules: FormRule<Values>[]) => Promise<{
         isValid: boolean;
-        error: string | null;
+        error: ReactNode | null;
     }>;
-    registerField: (name: string, rules: Rule[]) => void;
-    unregisterField: (name: string) => void;
+    registerField: (name: ProFormFieldName<Values>, rules: FormRule<Values>[]) => void;
+    unregisterField: (name: ProFormFieldName<Values>) => void;
+    /** Count a mounted instance for `name` — pair with `releaseField` on unmount. */
+    retainField: (name: ProFormFieldName<Values>) => void;
+    /** Drop one instance count; the field's rules are removed only at zero. */
+    releaseField: (name: ProFormFieldName<Values>) => void;
     size: FormSize;
     labelAlign: LabelAlign;
     disabled: boolean;
-    colon: boolean;
-    requiredMark: boolean;
-    validateTrigger: ValidateTrigger;
-    /** @deprecated Use `mode` instead. Kept for backward compatibility. */
-    readonly: boolean;
+    validateTrigger: ValidateTriggerProp;
     mode: ProFormMode;
     grid: boolean;
     colProps: ProFormColProps;
-    registerTransform: (name: string, fn: ProFormFieldTransformFn) => void;
+    registerTransform: <Name extends ProFormFieldName<Values>>(name: Name, fn: ProFormFieldTransformFn<Values, Name>) => void;
     /** When `fn` is given, removal happens only if the registry still holds it. */
-    unregisterTransform: (name: string, fn?: ProFormFieldTransformFn) => void;
+    unregisterTransform: <Name extends ProFormFieldName<Values>>(name: Name, fn?: ProFormFieldTransformFn<Values, Name>) => void;
     /** Register a field's valueType for valueType-aware submit formatting (dateFormatter) */
-    registerValueType: (name: string, valueType: ProFormValueType) => void;
+    registerValueType: (name: ProFormFieldName<Values>, valueType: ProFormValueType) => void;
     /** When `valueType` is given, removal happens only if the registry still holds it. */
-    unregisterValueType: (name: string, valueType?: ProFormValueType) => void;
+    unregisterValueType: (name: ProFormFieldName<Values>, valueType?: ProFormValueType) => void;
     /** Form-level defaults injected into every ProFormXxx field's component props (field-level wins) */
-    fieldProps?: Record<string, unknown>;
+    fieldProps?: Record<string, any>;
     /** Form-level defaults merged into every ProForm.Item (item-level wins) */
     formItemProps?: ProFormItemSharedProps;
     /** Form-level layout configuration (e.g. itemGap) read by every ProForm.Item */
@@ -118,13 +114,12 @@ export interface ProFormStableContextValue {
     /** Set by DialogForm/DrawerForm/QueryFilter so overlay fields can adapt (e.g. popup mounting) */
     formComponentType?: 'DialogForm' | 'DrawerForm' | 'QueryFilter';
 }
-export interface ProFormContextValue extends ProFormStableContextValue, ProFormStateContextValue {
+export interface ProFormContextValue<Values = Record<string, any>> extends ProFormStableContextValue<Values>, ProFormStateContextValue<Values> {
 }
-export interface ProFormFieldProps<FieldProps = Record<string, unknown>> {
-    name?: string;
+export interface ProFormTypedFieldProps<Values = Record<string, any>, Name extends ProFormFieldName<Values> = ProFormFieldName<Values>, FieldProps = Record<string, any>, FieldParams = Record<string, any>> {
+    name?: Name;
     label?: ReactNode;
-    rules?: Rule[];
-    required?: boolean;
+    rules?: FormRule<Values>[];
     description?: ReactNode;
     feedback?: ReactNode;
     validateStatus?: string;
@@ -136,9 +131,6 @@ export interface ProFormFieldProps<FieldProps = Record<string, unknown>> {
         span?: number;
         offset?: number;
     };
-    colon?: boolean;
-    /** @deprecated Use `mode='read'` instead */
-    readonly?: boolean;
     mode?: ProFormMode;
     hidden?: boolean;
     colProps?: ProFormColProps;
@@ -146,15 +138,17 @@ export interface ProFormFieldProps<FieldProps = Record<string, unknown>> {
     placeholder?: string;
     disabled?: boolean;
     width?: 'sm' | 'md' | 'lg' | 'xl' | number;
-    transform?: ProFormFieldTransformFn;
-    convertValue?: ProFormFieldConvertValueFn;
-    dependencies?: string[];
-    request?: (params?: Record<string, unknown>, signal?: AbortSignal) => Promise<ProFormRequestOption[]>;
-    params?: Record<string, unknown>;
+    transform?: ProFormFieldTransformFn<Values, Name>;
+    convertValue?: ProFormFieldConvertValueFn<Values, Name>;
+    dependencies?: ProFormFieldName<Values>[];
+    request?: (params?: FieldParams & ProFormFieldValueMap<Values>, signal?: AbortSignal) => Promise<ProFormRequestOption<ProFormFieldOptionValue<Values, Name>>[]>;
+    params?: FieldParams;
     valueEnum?: ProFormValueEnumObj;
     debounceTime?: number;
     /** Debounce (ms) applied to onChange-triggered validation */
     validateDebounce?: number;
+    /** Item-level validateTrigger - overrides the form-level setting */
+    validateTrigger?: ValidateTriggerProp;
     /**
      * Registered into the form's valueType registry (drives valueType-aware
      * dateFormatter, e.g. `"dateTime"` → `YYYY-MM-DD HH:mm:ss`) and read-mode
@@ -162,29 +156,32 @@ export interface ProFormFieldProps<FieldProps = Record<string, unknown>> {
      */
     valueType?: ProFormValueType;
 }
+/**
+ * Common field props with the historical generic order preserved:
+ * `ProFormFieldProps<FieldProps, Values, Name, FieldParams>`.
+ */
+export type ProFormFieldProps<FieldProps = Record<string, any>, Values = Record<string, any>, Name extends ProFormFieldName<Values> = ProFormFieldName<Values>, FieldParams = Record<string, any>> = ProFormTypedFieldProps<Values, Name, FieldProps, FieldParams>;
 export type ProFormValueType = 'text' | 'password' | 'digit' | 'date' | 'dateTime' | 'select' | 'radio' | 'switch' | 'tag';
-export interface ProFormItemProps {
+export interface ProFormItemProps<Values = Record<string, any>, Name extends ProFormFieldName<Values> = ProFormFieldName<Values>> {
     children?: ReactNode;
     className?: string;
     prefixCls?: string;
     label?: ReactNode;
-    name?: string;
-    rules?: Rule[];
-    required?: boolean;
+    name?: Name;
+    rules?: FormRule<Values>[];
     description?: ReactNode;
     feedback?: ReactNode;
     validateStatus?: ValidateStatus;
     hasFeedback?: boolean;
-    colon?: boolean;
     hidden?: boolean;
     /** Transform before submit, registered into ProForm pipeline */
-    transform?: ProFormFieldTransformFn;
+    transform?: ProFormFieldTransformFn<Values, Name>;
     /** Convert the displayed value before rendering into children */
-    convertValue?: ProFormFieldConvertValueFn;
+    convertValue?: ProFormFieldConvertValueFn<Values, Name>;
     /** Built-in read-mode value type renderer */
     valueType?: ProFormValueType;
     /** Custom read-mode rendering; overrides valueType */
-    readonlyRender?: (value: unknown, values: Record<string, unknown>) => ReactNode;
+    readonlyRender?: (value: ProFormPathValue<Values, Name>, values: Values) => ReactNode;
     /** Grid column config; falls back to ProForm.colProps */
     colProps?: ProFormColProps;
     /** Per-item mode override */
@@ -197,10 +194,12 @@ export interface ProFormItemProps {
     valuePropName?: string;
     /** Debounce (ms) applied to onChange-triggered validation */
     validateDebounce?: number;
+    /** Item-level validateTrigger - overrides the form-level setting */
+    validateTrigger?: ValidateTriggerProp;
 }
 /** Item props that can be shared form-wide via ProForm's `formItemProps` */
 export type ProFormItemSharedProps = Partial<Omit<ProFormItemProps, 'children' | 'name' | 'label' | 'rules'>>;
-export interface SubmitterProps<Values = Record<string, unknown>> {
+export interface SubmitterProps<Values = Record<string, any>> {
     submitText?: ReactNode;
     resetText?: ReactNode;
     render?: (props: {
@@ -213,11 +212,11 @@ export interface SubmitterProps<Values = Record<string, unknown>> {
     submitButtonProps?: Partial<ButtonProps>;
     resetButtonProps?: Partial<ButtonProps>;
 }
-export interface ProFormProps<Values = Record<string, unknown>> extends Omit<FormHTMLAttributes<HTMLFormElement>, 'onSubmit' | 'onReset'> {
+export interface ProFormProps<Values = Record<string, any>, Params = Record<string, any>> extends Omit<FormHTMLAttributes<HTMLFormElement>, 'onSubmit' | 'onReset'> {
     children?: ReactNode;
     className?: string;
     prefixCls?: string;
-    initialValues?: Partial<Values>;
+    initialValues?: ProFormRecursivePartial<Values>;
     /**
      * Called after validation passes with the pipelined values. The return value
      * gates `syncToUrl`: an explicit `false` (or a throw/reject) skips writing
@@ -226,9 +225,9 @@ export interface ProFormProps<Values = Record<string, unknown>> extends Omit<For
     onFinish?: (values: Values) => void | boolean | Promise<void | boolean>;
     onFinishFailed?: (errorInfo: {
         values: Values;
-        errors: Record<string, string>;
+        errors: Record<string, ReactNode>;
     }) => void;
-    onValuesChange?: (changedValues: Partial<Values>, allValues: Values) => void;
+    onValuesChange?: (changedValues: ProFormValuesPatch<Values>, allValues: Values) => void;
     /** Fires once per reset action, with the (post-reset) formatted values. */
     onReset?: (values?: Values) => void;
     /** Fires once after the form is initialized (after `request` resolves when present). */
@@ -240,11 +239,11 @@ export interface ProFormProps<Values = Record<string, unknown>> extends Omit<For
      * both ways. Assumes route navigation unmounts the form (writes are guarded
      * by mount-route pathname + an unmount flag).
      */
-    syncToUrl?: ProFormSyncToUrl;
+    syncToUrl?: ProFormSyncToUrl<Values>;
     /** On mount, URL params win over `initialValues` (default: initialValues win). */
     syncToUrlAsImportant?: boolean;
     /** Extra params always written to the URL alongside the form values. */
-    extraUrlParams?: Record<string, unknown>;
+    extraUrlParams?: Record<string, any>;
     /** Focus the first input on mount (default false). */
     autoFocusFirstInput?: boolean;
     /** Internal: set by DialogForm/DrawerForm/QueryFilter for overlay-aware fields. */
@@ -254,19 +253,15 @@ export interface ProFormProps<Values = Record<string, unknown>> extends Omit<For
     layout?: ProFormLayoutConfig;
     labelAlign?: LabelAlign;
     disabled?: boolean;
-    colon?: boolean;
-    requiredMark?: boolean;
-    validateTrigger?: ValidateTrigger;
+    validateTrigger?: ValidateTriggerProp;
     submitter?: SubmitterProps<Values> | false;
-    /** @deprecated Use `mode='read'` instead */
-    readonly?: boolean;
     mode?: ProFormMode;
     grid?: boolean;
     colProps?: ProFormColProps;
     rowProps?: Partial<GridRowProps>;
     loading?: boolean;
-    request?: (params?: unknown) => Promise<Partial<Values>>;
-    params?: unknown;
+    request?: (params?: Params) => Promise<ProFormValuesPatch<Values>>;
+    params?: Params;
     formRef?: MutableRefObject<ProFormFormInstance<Values> | undefined>;
     omitNil?: boolean;
     /**
@@ -277,25 +272,26 @@ export interface ProFormProps<Values = Record<string, unknown>> extends Omit<For
      */
     dateFormatter?: ProFormDateFormatter;
     /** Defaults injected into every ProFormXxx field's component props (field-level wins) */
-    fieldProps?: Record<string, unknown>;
+    fieldProps?: Record<string, any>;
     /** Defaults merged into every ProForm.Item (item-level wins) */
     formItemProps?: ProFormItemSharedProps;
 }
-export interface ProFormListAction {
-    add: (defaultValue?: Record<string, unknown>, index?: number) => void;
+export interface ProFormListAction<Item = Record<string, any>> {
+    add: (defaultValue?: Item, index?: number) => void;
     remove: (index: number) => void;
     move: (from: number, to: number) => void;
     copy: (index: number) => void;
-    getList: () => unknown[];
+    get: (index: number) => Item | undefined;
+    getList: () => Item[];
 }
-export interface ProFormListProps {
+export interface ProFormListProps<Item = Record<string, any>> {
     name: string;
     label?: ReactNode;
     min?: number;
     max?: number;
     required?: boolean;
     requiredMessage?: string;
-    initialValue?: Record<string, unknown>[];
+    initialValue?: Item[];
     copyIconProps?: false | Partial<ButtonProps>;
     deleteIconProps?: false | Partial<ButtonProps>;
     creatorButtonProps?: false | (Partial<ButtonProps> & {
@@ -304,35 +300,33 @@ export interface ProFormListProps {
     });
     itemRender?: (props: {
         listDom: ReactNode;
-        action: ProFormListAction;
+        action: ProFormListAction<Item>;
     }) => ReactNode;
     actionRender?: (row: {
         index: number;
-        record: unknown;
-    }, action: ProFormListAction, defaultDom: {
+        record: Item;
+    }, action: ProFormListAction<Item>, defaultDom: {
         copy: ReactNode;
         delete: ReactNode;
     }) => ReactNode;
     children?: ReactNode | ((fields: Array<{
         name: string;
         key: string;
-    }>, action: ProFormListAction) => ReactNode);
-    onAfterAdd?: (defaultValue: Record<string, unknown>, index: number) => void;
+    }>, action: ProFormListAction<Item>) => ReactNode);
+    onAfterAdd?: (defaultValue: Item, index: number) => void;
     onAfterRemove?: (index: number) => void;
 }
-export interface ProFormDependencyProps<Values = Record<string, unknown>> {
-    name: ProFormFieldName<Values>[];
-    ignoreFormListField?: boolean;
-    children: (values: Record<string, unknown>, form: ProFormFormInstance<Values>) => ReactNode;
+export interface ProFormDependencyProps<Values = Record<string, any>, Name extends ProFormFieldName<Values> = ProFormFieldName<Values>> {
+    name: Name[];
+    children: (values: ProFormFieldValueMap<Values, Name>, form: ProFormFormInstance<Values>) => ReactNode;
 }
 export interface FormListContextValue {
     listName?: string;
 }
-export interface ProFormFieldSetProps {
-    name?: string;
+export interface ProFormFieldSetProps<Values = Record<string, any>, Name extends ProFormFieldName<Values> = ProFormFieldName<Values>> {
+    name?: Name;
     label?: ReactNode;
-    rules?: Rule[];
-    required?: boolean;
+    rules?: FormRule<Values>[];
     description?: ReactNode;
     feedback?: ReactNode;
     gap?: number;
@@ -349,7 +343,7 @@ export interface ProFormGroupProps {
     style?: CSSProperties;
     children?: ReactNode;
 }
-export interface DialogFormProps<Values = Record<string, unknown>> extends Omit<ProFormProps<Values>, 'title'> {
+export interface DialogFormProps<Values = Record<string, any>, Params = Record<string, any>> extends Omit<ProFormProps<Values, Params>, 'title'> {
     open?: boolean;
     onOpenChange?: (open: boolean) => void;
     trigger?: ReactElement;
@@ -362,7 +356,7 @@ export interface DialogFormProps<Values = Record<string, unknown>> extends Omit<
     destroyOnClose?: boolean;
     dialogProps?: Partial<DialogProps>;
 }
-export interface DrawerFormProps<Values = Record<string, unknown>> extends Omit<ProFormProps<Values>, 'title'> {
+export interface DrawerFormProps<Values = Record<string, any>, Params = Record<string, any>> extends Omit<ProFormProps<Values, Params>, 'title'> {
     open?: boolean;
     onOpenChange?: (open: boolean) => void;
     trigger?: ReactElement;
@@ -376,7 +370,7 @@ export interface DrawerFormProps<Values = Record<string, unknown>> extends Omit<
     destroyOnClose?: boolean;
     drawerProps?: Partial<DrawerProps>;
 }
-export interface QueryFilterProps<Values = Record<string, unknown>> extends ProFormProps<Values> {
+export interface QueryFilterProps<Values = Record<string, any>, Params = Record<string, any>> extends ProFormProps<Values, Params> {
     defaultCollapsed?: boolean;
     collapsed?: boolean;
     onCollapse?: (collapsed: boolean) => void;
@@ -391,18 +385,17 @@ export interface QueryFilterProps<Values = Record<string, unknown>> extends ProF
     };
 }
 export type ProFormSchemaValueType = 'text' | 'password' | 'textarea' | 'digit' | 'select' | 'checkbox' | 'checkboxGroup' | 'radioGroup' | 'switch' | 'slider' | 'date' | 'dateTime' | 'upload';
-export interface ProFormSchemaColumn<Values = Record<string, unknown>> {
+export interface ProFormSchemaColumn<Values = Record<string, any>, Name extends ProFormFieldName<Values> = ProFormFieldName<Values>, FieldParams = Record<string, any>> {
     /** Field label */
     title?: ReactNode;
     /** Field name; top-level keys of `Values` autocomplete, dot-paths accepted (e.g. `"address.city"`) */
-    dataIndex: ProFormFieldName<Values>;
+    dataIndex: Name;
     /** Which ProForm field renders the column (default `'text'`) */
     valueType?: ProFormSchemaValueType;
     valueEnum?: ProFormValueEnumObj;
     /** Seeded into the form's initialValues (form-level initialValues win) */
-    initialValue?: unknown;
-    rules?: Rule[];
-    required?: boolean;
+    initialValue?: ProFormPathValue<Values, Name>;
+    rules?: FormRule<Values>[];
     description?: ReactNode;
     placeholder?: string;
     disabled?: boolean;
@@ -410,19 +403,24 @@ export interface ProFormSchemaColumn<Values = Record<string, unknown>> {
     mode?: ProFormMode;
     width?: 'sm' | 'md' | 'lg' | 'xl' | number;
     colProps?: ProFormColProps;
-    fieldProps?: Record<string, unknown>;
-    transform?: ProFormFieldTransformFn;
-    convertValue?: ProFormFieldConvertValueFn;
-    dependencies?: string[];
-    request?: (params?: Record<string, unknown>, signal?: AbortSignal) => Promise<ProFormRequestOption[]>;
-    params?: Record<string, unknown>;
+    fieldProps?: Record<string, any>;
+    transform?: ProFormFieldTransformFn<Values, Name>;
+    convertValue?: ProFormFieldConvertValueFn<Values, Name>;
+    dependencies?: ProFormFieldName<Values>[];
+    request?: (params?: FieldParams & ProFormFieldValueMap<Values>, signal?: AbortSignal) => Promise<ProFormRequestOption<ProFormFieldOptionValue<Values, Name>>[]>;
+    params?: FieldParams;
     debounceTime?: number;
     validateDebounce?: number;
+    /** Item-level validateTrigger - overrides the form-level setting */
+    validateTrigger?: ValidateTriggerProp;
     /** Fully custom renderer for this column; overrides valueType mapping */
-    renderFormItem?: (column: ProFormSchemaColumn<Values>) => ReactNode;
+    renderFormItem?: (column: ProFormSchemaColumn<Values, Name, FieldParams>) => ReactNode;
 }
-export interface SchemaFormProps<Values = Record<string, unknown>> extends Omit<ProFormProps<Values>, 'children'> {
-    columns: ProFormSchemaColumn<Values>[];
+export type ProFormSchemaColumns<Values = Record<string, any>, FieldParams = any> = Array<ProFormSchemaColumn<Values, ProFormFieldName<Values>, FieldParams> | {
+    [Name in ProFormFieldName<Values>]: ProFormSchemaColumn<Values, Name, FieldParams>;
+}[ProFormFieldName<Values>]>;
+export interface SchemaFormProps<Values = Record<string, any>, Params = Record<string, any>, FieldParams = any> extends Omit<ProFormProps<Values, Params>, 'children'> {
+    columns: ProFormSchemaColumns<Values, FieldParams>;
 }
 export interface CreateProFormFieldConfig<FieldProps> {
     component: FC<FieldProps> | (FC<FieldProps> & {
@@ -431,13 +429,11 @@ export interface CreateProFormFieldConfig<FieldProps> {
     valuePropName?: string;
     /** Default valueType registered for fields from this factory (per-field `valueType` prop overrides) */
     valueType?: ProFormValueType;
-    mapProps?: (props: Record<string, unknown>) => Record<string, unknown>;
-    renderReadonly?: (value: unknown, props?: Partial<FieldProps>) => ReactNode;
+    mapProps?: (props: Record<string, any>) => Record<string, any>;
     /**
-     * Name of the component prop that controls overlay mounting (e.g. `appendTo`).
-     * When set and the field renders inside a DialogForm/DrawerForm, the prop is
-     * injected with `'self'` so the overlay mounts next to the trigger instead
-     * of document.body.
+     * Read-mode renderer. `props` receives the field's RESOLVED component props
+     * (form/field `fieldProps` merged, `valueEnum`/`request` results landed in
+     * `options`) so the renderer can map values to option labels.
      */
-    popupContainerProp?: string;
+    renderReadonly?: (value: any, props?: Partial<FieldProps>) => ReactNode;
 }

package/es/components/ProForm/layouts/DialogForm.d.ts

@@ -1,7 +1,7 @@
 import type { ReactElement } from 'react';
 import type { DialogFormProps } from '../interface';
 /** Generic-aware export — keeps `<DialogForm<MyValues> …>` fully typed. */
-export declare const DialogForm: (<Values = Record<string, unknown>>(props: DialogFormProps<Values>) => ReactElement | null) & {
+export declare const DialogForm: (<Values = Record<string, any>, Params = Record<string, any>>(props: DialogFormProps<Values, Params>) => ReactElement | null) & {
     displayName?: string;
 };
 export default DialogForm;

package/es/components/ProForm/layouts/DialogForm.js

@@ -82,4 +82,4 @@ DialogFormBase.displayName = 'DialogForm';
 /** Generic-aware export — keeps `<DialogForm<MyValues> …>` fully typed. */
 export var DialogForm = /*#__PURE__*/memo(DialogFormBase);
 export default DialogForm;
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProForm/layouts/DialogForm.js","components/ProForm/src/components/ProForm/layouts/DialogForm.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","Fragment","_Fragment","jsxs","_jsxs","memo","default","classnames","Dialog","ProForm","CSS_PREFIX","useOverlayForm","classes","concat","DialogFormBase","props","_a","open","onOpenChange","trigger","title","width","submitTimeout","_props$autoClose","autoClose","_props$closeOnReset","closeOnReset","dialogProps","onFinish","onReset","submitter","children","_destroyOnClose","destroyOnClose","formProps","_useOverlayForm","mergedOpen","triggerNode","handleFinish","handleHide","assign","onCancel","footer","undefined","rootStyle","className","formComponentType","values","resetText","cancelText","_typeof","displayName","DialogForm"],"mappings":"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","file":"components/ProForm/layouts/DialogForm.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { memo } from 'react';\nimport { default as classnames } from '../../../utils/classnames';\nimport { Dialog } from '../../Dialog';\nimport { ProForm } from '../ProForm';\nimport { CSS_PREFIX } from '../constants';\nimport { useOverlayForm } from './useOverlayForm';\nconst classes = classnames(`${CSS_PREFIX}-dialog-form`);\nconst DialogFormBase = (props) => {\n    var _a;\n    const { open, onOpenChange, trigger, title, width, submitTimeout, autoClose = true, closeOnReset = true, dialogProps, onFinish, onReset, submitter, children, \n    // destroyOnClose is accepted for API compat but not used —\n    // Dialog's own usePresence already unmounts the entire DOM tree\n    // (including form content) after the close animation finishes.\n    destroyOnClose: _destroyOnClose } = props, formProps = __rest(props, [\"open\", \"onOpenChange\", \"trigger\", \"title\", \"width\", \"submitTimeout\", \"autoClose\", \"closeOnReset\", \"dialogProps\", \"onFinish\", \"onReset\", \"submitter\", \"children\", \"destroyOnClose\"]);\n    const { mergedOpen, triggerNode, handleFinish, handleHide, } = useOverlayForm({ open, onOpenChange, trigger, autoClose, submitTimeout }, onFinish);\n    return (_jsxs(_Fragment, { children: [triggerNode, _jsx(Dialog, Object.assign({}, dialogProps, { open: mergedOpen, title: title, onCancel: handleHide, footer: null }, (width !== undefined ? { rootStyle: Object.assign(Object.assign({}, dialogProps === null || dialogProps === void 0 ? void 0 : dialogProps.rootStyle), { width }) } : {}), { children: _jsx(\"div\", { className: classes(), children: _jsx(ProForm, Object.assign({}, formProps, { formComponentType: \"DialogForm\", onFinish: handleFinish, \n                        // Close rides the FORM-LEVEL reset channel — the single point\n                        // where every reset surface converges (default Cancel button,\n                        // custom submitter render calling `reset`, native type=\"reset\"\n                        // buttons). Consumer onReset runs first; closeOnReset opts out.\n                        onReset: (values) => {\n                            onReset === null || onReset === void 0 ? void 0 : onReset(values);\n                            if (closeOnReset)\n                                handleHide();\n                        }, submitter: submitter === false ? false : Object.assign({ resetText: (_a = dialogProps === null || dialogProps === void 0 ? void 0 : dialogProps.cancelText) !== null && _a !== void 0 ? _a : 'Cancel' }, (typeof submitter === 'object' ? submitter : {})), children: children })) }) }))] }));\n};\nDialogFormBase.displayName = 'DialogForm';\n/** Generic-aware export — keeps `<DialogForm<MyValues> …>` fully typed. */\nexport const DialogForm = memo(DialogFormBase);\nexport default DialogForm;",null],"sourceRoot":"../../../../../../../../../../src"}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProForm/layouts/DialogForm.js","components/ProForm/src/components/ProForm/layouts/DialogForm.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","Fragment","_Fragment","jsxs","_jsxs","memo","default","classnames","Dialog","ProForm","CSS_PREFIX","useOverlayForm","classes","concat","DialogFormBase","props","_a","open","onOpenChange","trigger","title","width","submitTimeout","_props$autoClose","autoClose","_props$closeOnReset","closeOnReset","dialogProps","onFinish","onReset","submitter","children","_destroyOnClose","destroyOnClose","formProps","_useOverlayForm","mergedOpen","triggerNode","handleFinish","handleHide","assign","onCancel","footer","undefined","rootStyle","className","formComponentType","values","resetText","cancelText","_typeof","displayName","DialogForm"],"mappings":"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","file":"components/ProForm/layouts/DialogForm.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { memo } from 'react';\nimport { default as classnames } from '../../../utils/classnames';\nimport { Dialog } from '../../Dialog';\nimport { ProForm } from '../ProForm';\nimport { CSS_PREFIX } from '../constants';\nimport { useOverlayForm } from './useOverlayForm';\nconst classes = classnames(`${CSS_PREFIX}-dialog-form`);\nconst DialogFormBase = (props) => {\n    var _a;\n    const { open, onOpenChange, trigger, title, width, submitTimeout, autoClose = true, closeOnReset = true, dialogProps, onFinish, onReset, submitter, children, \n    // destroyOnClose is accepted for API compat but not used —\n    // Dialog's own usePresence already unmounts the entire DOM tree\n    // (including form content) after the close animation finishes.\n    destroyOnClose: _destroyOnClose } = props, formProps = __rest(props, [\"open\", \"onOpenChange\", \"trigger\", \"title\", \"width\", \"submitTimeout\", \"autoClose\", \"closeOnReset\", \"dialogProps\", \"onFinish\", \"onReset\", \"submitter\", \"children\", \"destroyOnClose\"]);\n    const { mergedOpen, triggerNode, handleFinish, handleHide, } = useOverlayForm({ open, onOpenChange, trigger, autoClose, submitTimeout }, onFinish);\n    return (_jsxs(_Fragment, { children: [triggerNode, _jsx(Dialog, Object.assign({}, dialogProps, { open: mergedOpen, title: title, onCancel: handleHide, footer: null }, (width !== undefined ? { rootStyle: Object.assign(Object.assign({}, dialogProps === null || dialogProps === void 0 ? void 0 : dialogProps.rootStyle), { width }) } : {}), { children: _jsx(\"div\", { className: classes(), children: _jsx(ProForm, Object.assign({}, formProps, { formComponentType: \"DialogForm\", onFinish: handleFinish, \n                        // Close rides the FORM-LEVEL reset channel — the single point\n                        // where every reset surface converges (default Cancel button,\n                        // custom submitter render calling `reset`, native type=\"reset\"\n                        // buttons). Consumer onReset runs first; closeOnReset opts out.\n                        onReset: (values) => {\n                            onReset === null || onReset === void 0 ? void 0 : onReset(values);\n                            if (closeOnReset)\n                                handleHide();\n                        }, submitter: submitter === false ? false : Object.assign({ resetText: (_a = dialogProps === null || dialogProps === void 0 ? void 0 : dialogProps.cancelText) !== null && _a !== void 0 ? _a : 'Cancel' }, (typeof submitter === 'object' ? submitter : {})), children: children })) }) }))] }));\n};\nDialogFormBase.displayName = 'DialogForm';\n/** Generic-aware export — keeps `<DialogForm<MyValues> …>` fully typed. */\nexport const DialogForm = memo(DialogFormBase);\nexport default DialogForm;",null],"sourceRoot":"../../../../../../../../../../src"}

package/es/components/ProForm/layouts/DrawerForm.d.ts

@@ -1,7 +1,7 @@
 import type { ReactElement } from 'react';
 import type { DrawerFormProps } from '../interface';
 /** Generic-aware export — keeps `<DrawerForm<MyValues> …>` fully typed. */
-export declare const DrawerForm: (<Values = Record<string, unknown>>(props: DrawerFormProps<Values>) => ReactElement | null) & {
+export declare const DrawerForm: (<Values = Record<string, any>, Params = Record<string, any>>(props: DrawerFormProps<Values, Params>) => ReactElement | null) & {
     displayName?: string;
 };
 export default DrawerForm;

package/es/components/ProForm/layouts/DrawerForm.js

@@ -80,4 +80,4 @@ DrawerFormBase.displayName = 'DrawerForm';
 /** Generic-aware export — keeps `<DrawerForm<MyValues> …>` fully typed. */
 export var DrawerForm = /*#__PURE__*/memo(DrawerFormBase);
 export default DrawerForm;
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProForm/layouts/DrawerForm.js","components/ProForm/src/components/ProForm/layouts/DrawerForm.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","Fragment","_Fragment","jsxs","_jsxs","memo","default","classnames","Drawer","ProForm","CSS_PREFIX","useOverlayForm","classes","concat","DrawerFormBase","props","open","onOpenChange","trigger","title","_props$width","width","_props$placement","placement","submitTimeout","_props$autoClose","autoClose","_props$closeOnReset","closeOnReset","drawerProps","onFinish","onReset","submitter","children","_destroyOnClose","destroyOnClose","formProps","_useOverlayForm","mergedOpen","triggerNode","handleFinish","handleHide","assign","onClose","footer","className","formComponentType","values","resetText","_typeof","displayName","DrawerForm"],"mappings":";AAAA,IAAIA,MAAM,GAAI,IAAI,IAAI,IAAI,CAACA,MAAM,IAAK,UAAUC,CAAC,EAAEC,CAAC,EAAE;EAClD,IAAIC,CAAC,GAAG,CAAC,CAAC;EACV,KAAK,IAAIC,CAAC,IAAIH,CAAC,EAAE,IAAII,MAAM,CAACC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACP,CAAC,EAAEG,CAAC,CAAC,IAAIF,CAAC,CAACO,OAAO,CAACL,CAAC,CAAC,GAAG,CAAC,EAC/ED,CAAC,CAACC,CAAC,CAAC,GAAGH,CAAC,CAACG,CAAC,CAAC;EACf,IAAIH,CAAC,IAAI,IAAI,IAAI,OAAOI,MAAM,CAACK,qBAAqB,KAAK,UAAU,EAC/D,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEP,CAAC,GAAGC,MAAM,CAACK,qBAAqB,CAACT,CAAC,CAAC,EAAEU,CAAC,GAAGP,CAAC,CAACQ,MAAM,EAAED,CAAC,EAAE,EAAE;IACpE,IAAIT,CAAC,CAACO,OAAO,CAACL,CAAC,CAACO,CAAC,CAAC,CAAC,GAAG,CAAC,IAAIN,MAAM,CAACC,SAAS,CAACO,oBAAoB,CAACL,IAAI,CAACP,CAAC,EAAEG,CAAC,CAACO,CAAC,CAAC,CAAC,EAC1ER,CAAC,CAACC,CAAC,CAACO,CAAC,CAAC,CAAC,GAAGV,CAAC,CAACG,CAAC,CAACO,CAAC,CAAC,CAAC;EACzB;EACJ,OAAOR,CAAC;AACZ,CAAC;AACD,SAASW,GAAG,IAAIC,IAAI,EAAEC,QAAQ,IAAIC,SAAS,EAAEC,IAAI,IAAIC,KAAK,QAAQ,mBAAmB;ACXrF,SAASC,IAAI,QAAQ,OAAO;AAE5B,SAASC,OAAO,IAAIC,UAAU,QAAQ,2BAA2B;AACjE,SAASC,MAAM,QAAQ,cAAc;AACrC,SAASC,OAAO,QAAQ,YAAY;AACpC,SAASC,UAAU,QAAQ,cAAc;AACzC,SAASC,cAAc,QAAQ,kBAAkB;AAGjD,IAAMC,OAAO,GAAGL,UAAU,IAAAM,MAAA,CAAIH,UAAU,iBAAc,CAAC;AAEvD,IAAMI,cAAc,GAAwB,SAAtCA,cAAcA,CAAyBC,KAAK,EAAI;EACpD,IACEC,IAAI,GAmBFD,KAAK,CAnBPC,IAAI;IACJC,YAAY,GAkBVF,KAAK,CAlBPE,YAAY;IACZC,OAAO,GAiBLH,KAAK,CAjBPG,OAAO;IACPC,KAAK,GAgBHJ,KAAK,CAhBPI,KAAK;IAAAC,YAAA,GAgBHL,KAAK,CAfPM,KAAK;IAALA,KAAK,GAAAD,YAAA,cAAG,GAAG,GAAAA,YAAA;IAAAE,gBAAA,GAeTP,KAAK,CAdPQ,SAAS;IAATA,SAAS,GAAAD,gBAAA,cAAG,OAAO,GAAAA,gBAAA;IACnBE,aAAa,GAaXT,KAAK,CAbPS,aAAa;IAAAC,gBAAA,GAaXV,KAAK,CAZPW,SAAS;IAATA,SAAS,GAAAD,gBAAA,cAAG,IAAI,GAAAA,gBAAA;IAAAE,mBAAA,GAYdZ,KAAK,CAXPa,YAAY;IAAZA,YAAY,GAAAD,mBAAA,cAAG,IAAI,GAAAA,mBAAA;IACnBE,WAAW,GAUTd,KAAK,CAVPc,WAAW;IACXC,QAAQ,GASNf,KAAK,CATPe,QAAQ;IACRC,QAAO,GAQLhB,KAAK,CARPgB,OAAO;IACPC,SAAS,GAOPjB,KAAK,CAPPiB,SAAS;IACTC,QAAQ,GAMNlB,KAAK,CANPkB,QAAQ;IAIQC,eAAe,GAE7BnB,KAAK,CAFPoB,cAAc;IACXC,SAAS,GAAAnD,MAAA,CACV8B,KAAK,EApBH,CAAA,MAAA,EAAA,cAAA,EAAA,SAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,EAAA,eAAA,EAAA,WAAA,EAAA,cAAA,EAAA,aAAA,EAAA,UAAA,EAAA,SAAA,EAAA,WAAA,EAAA,UAAA,EAAA,gBAAA,CAoBL,CAAQ;EAET,IAAAsB,eAAA,GAKI1B,cAAc,CAChB;MAAEK,IAAI,EAAJA,IAAI;MAAEC,YAAY,EAAZA,YAAY;MAAEC,OAAO,EAAPA,OAAO;MAAEQ,SAAS,EAATA,SAAS;MAAEF,aAAa,EAAbA;IAAa,CAAE,EACzDM,QAAQ,CACT;IAPCQ,UAAU,GAAAD,eAAA,CAAVC,UAAU;IACVC,WAAW,GAAAF,eAAA,CAAXE,WAAW;IACXC,YAAY,GAAAH,eAAA,CAAZG,YAAY;IACZC,UAAU,GAAAJ,eAAA,CAAVI,UAAU;EAMZ,OACErC,KAAA,CAAAF,SAAA,EAAA;IAAA+B,QAAA,EAAA,CACGM,WAAW,EACZvC,IAAA,CAACQ,MAAM,EAAAlB,MAAA,CAAAoD,MAAA,CAAA,CAAA,CAAA,EACDb,WAAW,EAAA;MACfb,IAAI,EAAEsB,UAAU;MAChBnB,KAAK,EAAEA,KAAK;MACZI,SAAS,EAAEA,SAAS;MACpBF,KAAK,EAAEA,KAAK;MACZsB,OAAO,EAAEF,UAAU;MACnBG,MAAM,EAAE,IAAI;MAAAX,QAAA,EAEZjC,IAAA,CAAA,KAAA,EAAA;QAAK6C,SAAS,EAAEjC,OAAO,CAAA,CAAE;QAAAqB,QAAA,EACvBjC,IAAA,CAACS,OAAO,EAAAnB,MAAA,CAAAoD,MAAA,CAAA,CAAA,CAAA,EACFN,SAAS,EAAA;UACbU,iBAAiB,EAAC,YAAY;UAC9BhB,QAAQ,EAAEU,YAAY;UACtB;UACA;UACA;UACAT,OAAO,EAAE,SAATA,OAAOA,CAAGgB,MAAM,EAAI;YAClBhB,QAAO,KAAA,IAAA,IAAPA,QAAO,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAPA,QAAO,CAAGgB,MAAM,CAAC;YACjB,IAAInB,YAAY,EAAEa,UAAU,CAAA,CAAE;UAChC,CAAC;UACDT,SAAS,EAAEA,SAAS,KAAK,KAAK,GAAG,KAAK,GAAE1C,MAAA,CAAAoD,MAAA,CAAA;YACtCM,SAAS,EAAE;UAAQ,CAAA,EACfC,OAAA,CAAOjB,SAAS,MAAK,QAAQ,GAAGA,SAAS,GAAG,CAAA,CAAG,CACpD;UAAAC,QAAA,EAEAA;QAAQ,CAAA,CAAA;MACD,CAAA;IACN,CAAA,CAAA,CACC;EAAA,CAAA,CACR;AAEP,CAAC;AAEDnB,cAAc,CAACoC,WAAW,GAAG,YAAY;AAEzC;AACA,OAAO,IAAMC,UAAU,gBAAG9C,IAAI,CAACS,cAAc,CAEO;AAEpD,eAAeqC,UAAU","file":"components/ProForm/layouts/DrawerForm.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { memo } from 'react';\nimport { default as classnames } from '../../../utils/classnames';\nimport { Drawer } from '../../Drawer';\nimport { ProForm } from '../ProForm';\nimport { CSS_PREFIX } from '../constants';\nimport { useOverlayForm } from './useOverlayForm';\nconst classes = classnames(`${CSS_PREFIX}-drawer-form`);\nconst DrawerFormBase = (props) => {\n    const { open, onOpenChange, trigger, title, width = 480, placement = 'right', submitTimeout, autoClose = true, closeOnReset = true, drawerProps, onFinish, onReset, submitter, children, \n    // destroyOnClose is accepted for API compat but not used —\n    // Drawer's own useDrawerTransition already unmounts the entire\n    // DOM tree (including form content) after the close animation.\n    destroyOnClose: _destroyOnClose } = props, formProps = __rest(props, [\"open\", \"onOpenChange\", \"trigger\", \"title\", \"width\", \"placement\", \"submitTimeout\", \"autoClose\", \"closeOnReset\", \"drawerProps\", \"onFinish\", \"onReset\", \"submitter\", \"children\", \"destroyOnClose\"]);\n    const { mergedOpen, triggerNode, handleFinish, handleHide, } = useOverlayForm({ open, onOpenChange, trigger, autoClose, submitTimeout }, onFinish);\n    return (_jsxs(_Fragment, { children: [triggerNode, _jsx(Drawer, Object.assign({}, drawerProps, { open: mergedOpen, title: title, placement: placement, width: width, onClose: handleHide, footer: null, children: _jsx(\"div\", { className: classes(), children: _jsx(ProForm, Object.assign({}, formProps, { formComponentType: \"DrawerForm\", onFinish: handleFinish, \n                        // Close rides the FORM-LEVEL reset channel — the single point\n                        // where every reset surface converges. Consumer onReset runs\n                        // first; closeOnReset opts out.\n                        onReset: (values) => {\n                            onReset === null || onReset === void 0 ? void 0 : onReset(values);\n                            if (closeOnReset)\n                                handleHide();\n                        }, submitter: submitter === false ? false : Object.assign({ resetText: 'Cancel' }, (typeof submitter === 'object' ? submitter : {})), children: children })) }) }))] }));\n};\nDrawerFormBase.displayName = 'DrawerForm';\n/** Generic-aware export — keeps `<DrawerForm<MyValues> …>` fully typed. */\nexport const DrawerForm = memo(DrawerFormBase);\nexport default DrawerForm;",null],"sourceRoot":"../../../../../../../../../../src"}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProForm/layouts/DrawerForm.js","components/ProForm/src/components/ProForm/layouts/DrawerForm.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","Fragment","_Fragment","jsxs","_jsxs","memo","default","classnames","Drawer","ProForm","CSS_PREFIX","useOverlayForm","classes","concat","DrawerFormBase","props","open","onOpenChange","trigger","title","_props$width","width","_props$placement","placement","submitTimeout","_props$autoClose","autoClose","_props$closeOnReset","closeOnReset","drawerProps","onFinish","onReset","submitter","children","_destroyOnClose","destroyOnClose","formProps","_useOverlayForm","mergedOpen","triggerNode","handleFinish","handleHide","assign","onClose","footer","className","formComponentType","values","resetText","_typeof","displayName","DrawerForm"],"mappings":"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","file":"components/ProForm/layouts/DrawerForm.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { memo } from 'react';\nimport { default as classnames } from '../../../utils/classnames';\nimport { Drawer } from '../../Drawer';\nimport { ProForm } from '../ProForm';\nimport { CSS_PREFIX } from '../constants';\nimport { useOverlayForm } from './useOverlayForm';\nconst classes = classnames(`${CSS_PREFIX}-drawer-form`);\nconst DrawerFormBase = (props) => {\n    const { open, onOpenChange, trigger, title, width = 480, placement = 'right', submitTimeout, autoClose = true, closeOnReset = true, drawerProps, onFinish, onReset, submitter, children, \n    // destroyOnClose is accepted for API compat but not used —\n    // Drawer's own useDrawerTransition already unmounts the entire\n    // DOM tree (including form content) after the close animation.\n    destroyOnClose: _destroyOnClose } = props, formProps = __rest(props, [\"open\", \"onOpenChange\", \"trigger\", \"title\", \"width\", \"placement\", \"submitTimeout\", \"autoClose\", \"closeOnReset\", \"drawerProps\", \"onFinish\", \"onReset\", \"submitter\", \"children\", \"destroyOnClose\"]);\n    const { mergedOpen, triggerNode, handleFinish, handleHide, } = useOverlayForm({ open, onOpenChange, trigger, autoClose, submitTimeout }, onFinish);\n    return (_jsxs(_Fragment, { children: [triggerNode, _jsx(Drawer, Object.assign({}, drawerProps, { open: mergedOpen, title: title, placement: placement, width: width, onClose: handleHide, footer: null, children: _jsx(\"div\", { className: classes(), children: _jsx(ProForm, Object.assign({}, formProps, { formComponentType: \"DrawerForm\", onFinish: handleFinish, \n                        // Close rides the FORM-LEVEL reset channel — the single point\n                        // where every reset surface converges. Consumer onReset runs\n                        // first; closeOnReset opts out.\n                        onReset: (values) => {\n                            onReset === null || onReset === void 0 ? void 0 : onReset(values);\n                            if (closeOnReset)\n                                handleHide();\n                        }, submitter: submitter === false ? false : Object.assign({ resetText: 'Cancel' }, (typeof submitter === 'object' ? submitter : {})), children: children })) }) }))] }));\n};\nDrawerFormBase.displayName = 'DrawerForm';\n/** Generic-aware export — keeps `<DrawerForm<MyValues> …>` fully typed. */\nexport const DrawerForm = memo(DrawerFormBase);\nexport default DrawerForm;",null],"sourceRoot":"../../../../../../../../../../src"}

package/es/components/ProForm/layouts/QueryFilter.d.ts

@@ -1,7 +1,7 @@
 import type { ReactElement } from 'react';
 import type { QueryFilterProps } from '../interface';
 /** Generic-aware export — keeps `<QueryFilter<MyValues> …>` fully typed. */
-export declare const QueryFilter: (<Values = Record<string, unknown>>(props: QueryFilterProps<Values>) => ReactElement | null) & {
+export declare const QueryFilter: (<Values = Record<string, any>, Params = Record<string, any>>(props: QueryFilterProps<Values, Params>) => ReactElement | null) & {
     displayName?: string;
 };
 export default QueryFilter;