@1money/component-ui 0.0.71 → 0.0.74

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

@@ -1,15 +1,19 @@
 import { ProFormItem } from './ProFormItem';
 import type { FormInstance, UseFormConfig } from './core/interface';
 import './style';
-declare const ProForm: import("react").NamedExoticComponent<import("./interface").ProFormProps> & {
+declare const ProForm: import("./ProForm").ProFormComponent & {
     Item: import("react").NamedExoticComponent<import("./interface").ProFormItemProps>;
-    useForm: (config?: UseFormConfig) => [FormInstance];
-    useInstance: () => import("./interface").ProFormFormInstance;
+    useForm: <Values = Record<string, unknown>>(config?: UseFormConfig<Values>) => [FormInstance<Values>];
+    useInstance: <Values = Record<string, unknown>>() => import("./interface").ProFormFormInstance<Values>;
     useContext: () => import("./interface").ProFormContextValue;
-    Dependency: import("react").NamedExoticComponent<import("./interface").ProFormDependencyProps>;
+    useWatch: import("./context").UseFormWatch;
+    Dependency: import("./ProFormDependency").ProFormDependencyComponent;
     List: import("react").NamedExoticComponent<import("./interface").ProFormListProps>;
     Group: import("react").NamedExoticComponent<import("./interface").ProFormGroupProps>;
     FieldSet: import("react").NamedExoticComponent<import("./interface").ProFormFieldSetProps>;
+    SchemaForm: (<Values = Record<string, unknown>>(props: import("./interface").SchemaFormProps<Values>) => import("react").ReactElement | null) & {
+        displayName?: string;
+    };
     Submitter: import("react").NamedExoticComponent<import("./Submitter").SubmitterInternalProps>;
     Text: import("react").FC<import("./interface").ProFormFieldProps<import("../Input").InputProps>>;
     Password: import("react").FC<import("./interface").ProFormFieldProps<import("../Input").InputPasswordProps>>;
@@ -29,10 +33,13 @@ export { createProFormField, ProFormText, ProFormPassword, ProFormTextArea, ProF
 export { ProFormDependency } from './ProFormDependency';
 export { ProFormList } from './ProFormList';
 export { ProFormGroup } from './ProFormGroup';
+export { SchemaForm } from './SchemaForm';
 export { DrawerForm } from './layouts/DrawerForm';
 export { DialogForm } from './layouts/DialogForm';
 export { QueryFilter } from './layouts/QueryFilter';
-export type { ProFormProps, ProFormItemProps, ProFormFieldProps, ProFormContextValue, ProFormFormInstance, ProFormFieldTransformFn, ProFormFieldConvertValueFn, ProFormValueEnumObj, ProFormRequestOption, ProFormValueType, FormListContextValue, ProFormColProps, ProFormFieldSetProps, ProFormGroupProps, SubmitterProps, ProFormDependencyProps, ProFormListProps, ProFormListAction, DrawerFormProps, DialogFormProps, QueryFilterProps, CreateProFormFieldConfig, } from './interface';
+export { useFormWatch } from './context';
+export type { UseFormWatch } from './context';
+export type { ProFormSyncToUrl, ProFormProps, ProFormItemProps, ProFormItemSharedProps, ProFormLayoutConfig, ProFormFieldProps, ProFormContextValue, ProFormStableContextValue, ProFormStateContextValue, ProFormFormInstance, ProFormValidateResult, ProFormFieldName, ProFormFieldTransformFn, ProFormFieldConvertValueFn, ProFormDateFormatter, ProFormValueEnumObj, ProFormRequestOption, ProFormValueType, FormListContextValue, ProFormColProps, ProFormFieldSetProps, ProFormGroupProps, SubmitterProps, ProFormDependencyProps, ProFormListProps, ProFormListAction, DrawerFormProps, DialogFormProps, QueryFilterProps, CreateProFormFieldConfig, ProFormSchemaColumn, ProFormSchemaValueType, SchemaFormProps, } from './interface';
 export { CSS_PREFIX, WIDTH_SIZE_MAP, DEFAULT_COL_SPAN, DEFAULT_TEXT, PROFORM_MODES } from './constants';
 export type { ProFormMode } from './constants';
 export type { FormInstance, FormCoreInstance, Rule, ValidateTrigger, ValidateStatus, FormLayout, FormSize, LabelAlign, UseFormConfig, UseFormReturn, UseFormInternals, } from './core/interface';

package/es/components/ProForm/index.js

@@ -3,10 +3,11 @@ import { ProFormItem } from './ProFormItem';
 import { ProFormDependency } from './ProFormDependency';
 import { ProFormList } from './ProFormList';
 import { ProFormGroup } from './ProFormGroup';
+import { SchemaForm } from './SchemaForm';
 import { Submitter } from './Submitter';
 import { ProFormText, ProFormPassword, ProFormTextArea, ProFormCheckbox, ProFormCheckboxGroup, ProFormSwitch, ProFormSelect, ProFormRadioGroup, ProFormSlider, ProFormDatePicker, ProFormUpload, ProFormFieldSet } from './fields';
 import { useForm as useFormInternal } from './core/hooks/useForm';
-import { useProFormContext, useFormInstance } from './context';
+import { useProFormContext, useFormInstance, useFormWatch } from './context';
 import './style';
 /** Public hook — returns [FormInstance] for backward compatibility */
 var useForm = function useForm(config) {
@@ -21,11 +22,13 @@ var ProForm = Object.assign(ProFormBase, {
   useForm: useForm,
   useInstance: useFormInstance,
   useContext: useProFormContext,
+  useWatch: useFormWatch,
   // Composition
   Dependency: ProFormDependency,
   List: ProFormList,
   Group: ProFormGroup,
   FieldSet: ProFormFieldSet,
+  SchemaForm: SchemaForm,
   Submitter: Submitter,
   // Fields
   Text: ProFormText,
@@ -48,8 +51,10 @@ export { createProFormField, ProFormText, ProFormPassword, ProFormTextArea, ProF
 export { ProFormDependency } from './ProFormDependency';
 export { ProFormList } from './ProFormList';
 export { ProFormGroup } from './ProFormGroup';
+export { SchemaForm } from './SchemaForm';
 export { DrawerForm } from './layouts/DrawerForm';
 export { DialogForm } from './layouts/DialogForm';
 export { QueryFilter } from './layouts/QueryFilter';
+export { useFormWatch } from './context';
 export { CSS_PREFIX, WIDTH_SIZE_MAP, DEFAULT_COL_SPAN, DEFAULT_TEXT, PROFORM_MODES } from './constants';
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

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

@@ -5,12 +5,21 @@ import type { DrawerProps, DrawerPlacement } from "../Drawer";
 import type { GridRowProps, GridColSize } from "../Grid";
 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 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;
@@ -22,23 +31,59 @@ export interface ProFormRequestOption {
     value: unknown;
     disabled?: boolean;
 }
-export interface ProFormFormInstance extends FormInstance {
-    getFieldsFormatValue: () => Record<string, unknown>;
-    validateFieldsReturnFormatValue: () => Promise<{
-        success: boolean;
-        values?: Record<string, unknown>;
-        errors?: Record<string, string>;
-    }>;
+/**
+ * Result of `validateFieldsReturnFormatValue` — a discriminated union: checking
+ * `success` narrows to `values` (success) or `errors` (failure) without `!`.
+ * 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>> = {
+    success: true;
+    values: Values;
+    errors?: undefined;
+} | {
+    success: false;
+    errors: Record<string, string>;
+    values?: undefined;
+};
+export interface ProFormFormInstance<Values = Record<string, unknown>> extends FormInstance<Values> {
+    getFieldsFormatValue: () => Values;
+    /** Single-field value with dateFormatter + transform applied (no omitNil). */
+    getFieldFormatValue: (name: string) => unknown;
+    /**
+     * 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>;
+    validateFieldsReturnFormatValue: () => Promise<ProFormValidateResult<Values>>;
     submitForm: () => Promise<void>;
 }
-export interface ProFormContextValue {
+export interface ProFormStateContextValue {
     values: Record<string, unknown>;
     errors: Record<string, string>;
+    warnings: Record<string, string>;
     touched: Record<string, boolean>;
     validating: Record<string, boolean>;
+}
+/**
+ * Form-level layout configuration. Groups presentational layout knobs in one
+ * object so future options (label placement, density, …) extend here instead
+ * of adding new top-level props.
+ */
+export interface ProFormLayoutConfig {
+    /**
+     * Vertical space between form items. Overrides the uniform 24px default
+     * (form `size` does not affect spacing). Number = px; string = any CSS
+     * length.
+     */
+    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<{
         isValid: boolean;
@@ -58,7 +103,22 @@ export interface ProFormContextValue {
     grid: boolean;
     colProps: ProFormColProps;
     registerTransform: (name: string, fn: ProFormFieldTransformFn) => void;
-    unregisterTransform: (name: string) => void;
+    /** When `fn` is given, removal happens only if the registry still holds it. */
+    unregisterTransform: (name: string, fn?: ProFormFieldTransformFn) => void;
+    /** Register a field's valueType for valueType-aware submit formatting (dateFormatter) */
+    registerValueType: (name: string, valueType: ProFormValueType) => void;
+    /** When `valueType` is given, removal happens only if the registry still holds it. */
+    unregisterValueType: (name: string, valueType?: ProFormValueType) => void;
+    /** Form-level defaults injected into every ProFormXxx field's component props (field-level wins) */
+    fieldProps?: Record<string, unknown>;
+    /** 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 */
+    layout?: ProFormLayoutConfig;
+    /** 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 ProFormFieldProps<FieldProps = Record<string, unknown>> {
     name?: string;
@@ -89,10 +149,18 @@ export interface ProFormFieldProps<FieldProps = Record<string, unknown>> {
     transform?: ProFormFieldTransformFn;
     convertValue?: ProFormFieldConvertValueFn;
     dependencies?: string[];
-    request?: (params?: Record<string, unknown>) => Promise<ProFormRequestOption[]>;
+    request?: (params?: Record<string, unknown>, signal?: AbortSignal) => Promise<ProFormRequestOption[]>;
     params?: Record<string, unknown>;
     valueEnum?: ProFormValueEnumObj;
     debounceTime?: number;
+    /** Debounce (ms) applied to onChange-triggered validation */
+    validateDebounce?: number;
+    /**
+     * Registered into the form's valueType registry (drives valueType-aware
+     * dateFormatter, e.g. `"dateTime"` → `YYYY-MM-DD HH:mm:ss`) and read-mode
+     * rendering. Overrides the factory's default valueType.
+     */
+    valueType?: ProFormValueType;
 }
 export type ProFormValueType = 'text' | 'password' | 'digit' | 'date' | 'dateTime' | 'select' | 'radio' | 'switch' | 'tag';
 export interface ProFormItemProps {
@@ -125,12 +193,18 @@ export interface ProFormItemProps {
     emptyText?: ReactNode;
     /** Value enum for select/radio/tag value types */
     valueEnum?: ProFormValueEnumObj;
+    /** Prop name the controlled value is injected under (default `value`; e.g. `checked` for Switch/Checkbox) */
+    valuePropName?: string;
+    /** Debounce (ms) applied to onChange-triggered validation */
+    validateDebounce?: number;
 }
-export interface SubmitterProps {
+/** 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>> {
     submitText?: ReactNode;
     resetText?: ReactNode;
     render?: (props: {
-        form: ProFormFormInstance;
+        form: ProFormFormInstance<Values>;
         submit: () => void;
         reset: () => void;
     }, dom: ReactElement[]) => ReactNode;
@@ -139,25 +213,51 @@ export interface SubmitterProps {
     submitButtonProps?: Partial<ButtonProps>;
     resetButtonProps?: Partial<ButtonProps>;
 }
-export interface ProFormProps extends Omit<FormHTMLAttributes<HTMLFormElement>, 'onSubmit' | 'onReset'> {
+export interface ProFormProps<Values = Record<string, unknown>> extends Omit<FormHTMLAttributes<HTMLFormElement>, 'onSubmit' | 'onReset'> {
     children?: ReactNode;
     className?: string;
     prefixCls?: string;
-    initialValues?: Record<string, unknown>;
-    onFinish?: (values: Record<string, unknown>) => void;
+    initialValues?: Partial<Values>;
+    /**
+     * Called after validation passes with the pipelined values. The return value
+     * gates `syncToUrl`: an explicit `false` (or a throw/reject) skips writing
+     * the URL; any other result — including void — syncs.
+     */
+    onFinish?: (values: Values) => void | boolean | Promise<void | boolean>;
     onFinishFailed?: (errorInfo: {
-        values: Record<string, unknown>;
+        values: Values;
         errors: Record<string, string>;
     }) => void;
-    onValuesChange?: (changedValues: Record<string, unknown>, allValues: Record<string, unknown>) => void;
-    onReset?: () => void;
+    onValuesChange?: (changedValues: Partial<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). */
+    onInit?: (values: Values, form: ProFormFormInstance<Values>) => void;
+    /** Observes the internal submit loading state (true on start, false on settle). */
+    onLoadingChange?: (loading: boolean) => void;
+    /**
+     * Sync form values to the URL query string; the function form maps values
+     * both ways. Assumes route navigation unmounts the form (writes are guarded
+     * by mount-route pathname + an unmount flag).
+     */
+    syncToUrl?: ProFormSyncToUrl;
+    /** 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>;
+    /** Focus the first input on mount (default false). */
+    autoFocusFirstInput?: boolean;
+    /** Internal: set by DialogForm/DrawerForm/QueryFilter for overlay-aware fields. */
+    formComponentType?: 'DialogForm' | 'DrawerForm' | 'QueryFilter';
     size?: FormSize;
+    /** Form-level layout configuration, e.g. `layout={{ itemGap: 16 }}` */
+    layout?: ProFormLayoutConfig;
     labelAlign?: LabelAlign;
     disabled?: boolean;
     colon?: boolean;
     requiredMark?: boolean;
     validateTrigger?: ValidateTrigger;
-    submitter?: SubmitterProps | false;
+    submitter?: SubmitterProps<Values> | false;
     /** @deprecated Use `mode='read'` instead */
     readonly?: boolean;
     mode?: ProFormMode;
@@ -165,10 +265,21 @@ export interface ProFormProps extends Omit<FormHTMLAttributes<HTMLFormElement>,
     colProps?: ProFormColProps;
     rowProps?: Partial<GridRowProps>;
     loading?: boolean;
-    request?: (params?: unknown) => Promise<Record<string, unknown>>;
+    request?: (params?: unknown) => Promise<Partial<Values>>;
     params?: unknown;
-    formRef?: MutableRefObject<ProFormFormInstance | undefined>;
+    formRef?: MutableRefObject<ProFormFormInstance<Values> | undefined>;
     omitNil?: boolean;
+    /**
+     * How Date values are serialized in the submit pipeline (default `'string'`):
+     * `'string'` → `YYYY-MM-DD` (`YYYY-MM-DD HH:mm:ss` for `valueType="dateTime"` fields),
+     * `'number'` → timestamp, a custom pattern (e.g. `'YYYY/MM/DD'`), a function, or
+     * `false` to pass Date objects through untouched.
+     */
+    dateFormatter?: ProFormDateFormatter;
+    /** Defaults injected into every ProFormXxx field's component props (field-level wins) */
+    fieldProps?: Record<string, unknown>;
+    /** Defaults merged into every ProForm.Item (item-level wins) */
+    formItemProps?: ProFormItemSharedProps;
 }
 export interface ProFormListAction {
     add: (defaultValue?: Record<string, unknown>, index?: number) => void;
@@ -209,10 +320,10 @@ export interface ProFormListProps {
     onAfterAdd?: (defaultValue: Record<string, unknown>, index: number) => void;
     onAfterRemove?: (index: number) => void;
 }
-export interface ProFormDependencyProps {
-    name: string[];
+export interface ProFormDependencyProps<Values = Record<string, unknown>> {
+    name: ProFormFieldName<Values>[];
     ignoreFormListField?: boolean;
-    children: (values: Record<string, unknown>, form: ProFormFormInstance) => ReactNode;
+    children: (values: Record<string, unknown>, form: ProFormFormInstance<Values>) => ReactNode;
 }
 export interface FormListContextValue {
     listName?: string;
@@ -238,7 +349,7 @@ export interface ProFormGroupProps {
     style?: CSSProperties;
     children?: ReactNode;
 }
-export interface DialogFormProps extends Omit<ProFormProps, 'title'> {
+export interface DialogFormProps<Values = Record<string, unknown>> extends Omit<ProFormProps<Values>, 'title'> {
     open?: boolean;
     onOpenChange?: (open: boolean) => void;
     trigger?: ReactElement;
@@ -246,10 +357,12 @@ export interface DialogFormProps extends Omit<ProFormProps, 'title'> {
     width?: number | string;
     submitTimeout?: number;
     autoClose?: boolean;
+    /** Close the overlay when the form is reset (default true). Set false for reset-without-close (e.g. a "Clear" button). */
+    closeOnReset?: boolean;
     destroyOnClose?: boolean;
     dialogProps?: Partial<DialogProps>;
 }
-export interface DrawerFormProps extends Omit<ProFormProps, 'title'> {
+export interface DrawerFormProps<Values = Record<string, unknown>> extends Omit<ProFormProps<Values>, 'title'> {
     open?: boolean;
     onOpenChange?: (open: boolean) => void;
     trigger?: ReactElement;
@@ -258,10 +371,12 @@ export interface DrawerFormProps extends Omit<ProFormProps, 'title'> {
     placement?: DrawerPlacement;
     submitTimeout?: number;
     autoClose?: boolean;
+    /** Close the overlay when the form is reset (default true). Set false for reset-without-close (e.g. a "Clear" button). */
+    closeOnReset?: boolean;
     destroyOnClose?: boolean;
     drawerProps?: Partial<DrawerProps>;
 }
-export interface QueryFilterProps extends ProFormProps {
+export interface QueryFilterProps<Values = Record<string, unknown>> extends ProFormProps<Values> {
     defaultCollapsed?: boolean;
     collapsed?: boolean;
     onCollapse?: (collapsed: boolean) => void;
@@ -274,13 +389,55 @@ export interface QueryFilterProps extends ProFormProps {
         /** Size of the search / reset / collapse buttons. Defaults to the Button default. */
         size?: ButtonSize;
     };
-    syncToUrl?: boolean | ((values: Record<string, unknown>, type: 'get' | 'set') => Record<string, unknown>);
+}
+export type ProFormSchemaValueType = 'text' | 'password' | 'textarea' | 'digit' | 'select' | 'checkbox' | 'checkboxGroup' | 'radioGroup' | 'switch' | 'slider' | 'date' | 'dateTime' | 'upload';
+export interface ProFormSchemaColumn<Values = Record<string, unknown>> {
+    /** Field label */
+    title?: ReactNode;
+    /** Field name; top-level keys of `Values` autocomplete, dot-paths accepted (e.g. `"address.city"`) */
+    dataIndex: ProFormFieldName<Values>;
+    /** 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;
+    description?: ReactNode;
+    placeholder?: string;
+    disabled?: boolean;
+    hidden?: boolean;
+    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>;
+    debounceTime?: number;
+    validateDebounce?: number;
+    /** Fully custom renderer for this column; overrides valueType mapping */
+    renderFormItem?: (column: ProFormSchemaColumn<Values>) => ReactNode;
+}
+export interface SchemaFormProps<Values = Record<string, unknown>> extends Omit<ProFormProps<Values>, 'children'> {
+    columns: ProFormSchemaColumn<Values>[];
 }
 export interface CreateProFormFieldConfig<FieldProps> {
     component: FC<FieldProps> | (FC<FieldProps> & {
         displayName?: string;
     });
     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;
+    /**
+     * 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.
+     */
+    popupContainerProp?: string;
 }

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

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

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

@@ -1,3 +1,4 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
 var __rest = this && this.__rest || function (s, e) {
   var t = {};
   for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
@@ -24,12 +25,15 @@ var DialogFormBase = function DialogFormBase(props) {
     submitTimeout = props.submitTimeout,
     _props$autoClose = props.autoClose,
     autoClose = _props$autoClose === void 0 ? true : _props$autoClose,
+    _props$closeOnReset = props.closeOnReset,
+    closeOnReset = _props$closeOnReset === void 0 ? true : _props$closeOnReset,
     dialogProps = props.dialogProps,
     onFinish = props.onFinish,
+    _onReset = props.onReset,
     submitter = props.submitter,
     children = props.children,
     _destroyOnClose = props.destroyOnClose,
-    formProps = __rest(props, ["open", "onOpenChange", "trigger", "title", "width", "submitTimeout", "autoClose", "dialogProps", "onFinish", "submitter", "children", "destroyOnClose"]);
+    formProps = __rest(props, ["open", "onOpenChange", "trigger", "title", "width", "submitTimeout", "autoClose", "closeOnReset", "dialogProps", "onFinish", "onReset", "submitter", "children", "destroyOnClose"]);
   var _useOverlayForm = useOverlayForm({
       open: open,
       onOpenChange: onOpenChange,
@@ -55,13 +59,19 @@ var DialogFormBase = function DialogFormBase(props) {
       children: _jsx("div", {
         className: classes(),
         children: _jsx(ProForm, Object.assign({}, formProps, {
+          formComponentType: "DialogForm",
           onFinish: handleFinish,
-          submitter: submitter !== undefined ? submitter : {
-            resetButtonProps: {
-              onClick: handleHide
-            },
-            resetText: (_a = dialogProps === null || dialogProps === void 0 ? void 0 : dialogProps.cancelText) !== null && _a !== void 0 ? _a : 'Cancel'
+          // Close rides the FORM-LEVEL reset channel — the single point
+          // where every reset surface converges (default Cancel button,
+          // custom submitter render calling `reset`, native type="reset"
+          // buttons). Consumer onReset runs first; closeOnReset opts out.
+          onReset: function onReset(values) {
+            _onReset === null || _onReset === void 0 ? void 0 : _onReset(values);
+            if (closeOnReset) handleHide();
           },
+          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
         }))
       })
@@ -69,6 +79,7 @@ var DialogFormBase = function DialogFormBase(props) {
   });
 };
 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","dialogProps","onFinish","submitter","children","_destroyOnClose","destroyOnClose","formProps","_useOverlayForm","mergedOpen","triggerNode","handleFinish","handleHide","assign","onCancel","footer","undefined","rootStyle","className","resetButtonProps","onClick","resetText","cancelText","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, dialogProps, onFinish, 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\", \"dialogProps\", \"onFinish\", \"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, { onFinish: handleFinish, submitter: submitter !== undefined ? submitter : {\n                            resetButtonProps: { onClick: handleHide },\n                            resetText: (_a = dialogProps === null || dialogProps === void 0 ? void 0 : dialogProps.cancelText) !== null && _a !== void 0 ? _a : 'Cancel',\n                        }, children: children })) }) }))] }));\n};\nDialogFormBase.displayName = 'DialogForm';\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,3 +1,7 @@
+import type { ReactElement } from 'react';
 import type { DrawerFormProps } from '../interface';
-export declare const DrawerForm: import("react").NamedExoticComponent<DrawerFormProps>;
+/** Generic-aware export — keeps `<DrawerForm<MyValues> …>` fully typed. */
+export declare const DrawerForm: (<Values = Record<string, unknown>>(props: DrawerFormProps<Values>) => ReactElement | null) & {
+    displayName?: string;
+};
 export default DrawerForm;