@1money/component-ui 0.0.73 → 0.0.74

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

@@ -5,6 +5,8 @@ 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;
@@ -12,6 +14,12 @@ 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;
@@ -23,13 +31,32 @@ export interface ProFormRequestOption {
     value: unknown;
     disabled?: boolean;
 }
+/**
+ * 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;
-    validateFieldsReturnFormatValue: () => Promise<{
-        success: boolean;
-        values?: Values;
-        errors?: Record<string, string>;
-    }>;
+    /** 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 ProFormStateContextValue {
@@ -39,6 +66,19 @@ export interface ProFormStateContextValue {
     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;
@@ -63,14 +103,20 @@ export interface ProFormStableContextValue {
     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;
-    unregisterValueType: (name: string) => 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 {
 }
@@ -103,7 +149,7 @@ 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;
@@ -154,11 +200,11 @@ export interface ProFormItemProps {
 }
 /** 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 {
+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;
@@ -172,20 +218,46 @@ export interface ProFormProps<Values = Record<string, unknown>> extends Omit<For
     className?: string;
     prefixCls?: string;
     initialValues?: Partial<Values>;
-    onFinish?: (values: Values) => void | Promise<void>;
+    /**
+     * 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: Values;
         errors: Record<string, string>;
     }) => void;
     onValuesChange?: (changedValues: Partial<Values>, allValues: Values) => void;
-    onReset?: () => 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;
@@ -248,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;
@@ -285,6 +357,8 @@ export interface DialogFormProps<Values = Record<string, unknown>> extends Omit<
     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>;
 }
@@ -297,6 +371,8 @@ export interface DrawerFormProps<Values = Record<string, unknown>> extends Omit<
     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>;
 }
@@ -313,14 +389,13 @@ export interface QueryFilterProps<Values = Record<string, unknown>> extends ProF
         /** 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 {
+export interface ProFormSchemaColumn<Values = Record<string, unknown>> {
     /** Field label */
     title?: ReactNode;
-    /** Field name; dot-paths supported (e.g. `"address.city"`) */
-    dataIndex: string;
+    /** 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;
@@ -339,15 +414,15 @@ export interface ProFormSchemaColumn {
     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>;
     debounceTime?: number;
     validateDebounce?: number;
     /** Fully custom renderer for this column; overrides valueType mapping */
-    renderFormItem?: (column: ProFormSchemaColumn) => ReactNode;
+    renderFormItem?: (column: ProFormSchemaColumn<Values>) => ReactNode;
 }
 export interface SchemaFormProps<Values = Record<string, unknown>> extends Omit<ProFormProps<Values>, 'children'> {
-    columns: ProFormSchemaColumn[];
+    columns: ProFormSchemaColumn<Values>[];
 }
 export interface CreateProFormFieldConfig<FieldProps> {
     component: FC<FieldProps> | (FC<FieldProps> & {
@@ -358,4 +433,11 @@ export interface CreateProFormFieldConfig<FieldProps> {
     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.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
         }))
       })
@@ -72,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","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":"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;EDSlD,IAAIC,EAAE;ECRR,IACEC,IAAI,GAgBFF,KAAK,CAhBPE,IAAI;IACJC,YAAY,GAeVH,KAAK,CAfPG,YAAY;IACZC,OAAO,GAcLJ,KAAK,CAdPI,OAAO;IACPC,KAAK,GAaHL,KAAK,CAbPK,KAAK;IACLC,KAAK,GAYHN,KAAK,CAZPM,KAAK;IACLC,aAAa,GAWXP,KAAK,CAXPO,aAAa;IAAAC,gBAAA,GAWXR,KAAK,CAVPS,SAAS;IAATA,SAAS,GAAAD,gBAAA,cAAG,IAAI,GAAAA,gBAAA;IAChBE,WAAW,GASTV,KAAK,CATPU,WAAW;IACXC,QAAQ,GAQNX,KAAK,CARPW,QAAQ;IACRC,SAAS,GAOPZ,KAAK,CAPPY,SAAS;IACTC,QAAQ,GAMNb,KAAK,CANPa,QAAQ;IAIQC,eAAe,GAE7Bd,KAAK,CAFPe,cAAc;IACXC,SAAS,GAAA9C,MAAA,CACV8B,KAAK,EAjBH,CAAA,MAAA,EAAA,cAAA,EAAA,SAAA,EAAA,OAAA,EAAA,OAAA,EAAA,eAAA,EAAA,WAAA,EAAA,aAAA,EAAA,UAAA,EAAA,WAAA,EAAA,UAAA,EAAA,gBAAA,CAiBL,CAAQ;EAET,IAAAiB,eAAA,GAKIrB,cAAc,CAChB;MAAEM,IAAI,EAAJA,IAAI;MAAEC,YAAY,EAAZA,YAAY;MAAEC,OAAO,EAAPA,OAAO;MAAEK,SAAS,EAATA,SAAS;MAAEF,aAAa,EAAbA;IAAa,CAAE,EACzDI,QAAQ,CACT;IAPCO,UAAU,GAAAD,eAAA,CAAVC,UAAU;IACVC,WAAW,GAAAF,eAAA,CAAXE,WAAW;IACXC,YAAY,GAAAH,eAAA,CAAZG,YAAY;IACZC,UAAU,GAAAJ,eAAA,CAAVI,UAAU;EAMZ,OACEhC,KAAA,CAAAF,SAAA,EAAA;IAAA0B,QAAA,EAAA,CACGM,WAAW,EACZlC,IAAA,CAACQ,MAAM,EAAAlB,MAAA,CAAA+C,MAAA,CAAA,CAAA,CAAA,EACDZ,WAAW,EAAA;MACfR,IAAI,EAAEgB,UAAU;MAChBb,KAAK,EAAEA,KAAK;MACZkB,QAAQ,EAAEF,UAAU;MACpBG,MAAM,EAAE;IAAI,CAAA,EACPlB,KAAK,KAAKmB,SAAS,GAAG;MAAEC,SAAS,EAAAnD,MAAA,CAAA+C,MAAA,CAAA/C,MAAA,CAAA+C,MAAA,CAAA,CAAA,CAAA,EAAOZ,WAAW,KAAA,IAAA,IAAXA,WAAW,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAXA,WAAW,CAAEgB,SAAS,CAAA,EAAA;QAAEpB,KAAK,EAALA;MAAK,CAAA;IAAE,CAAE,GAAG,CAAA,CAAE,EAAC;MAAAO,QAAA,EAEpF5B,IAAA,CAAA,KAAA,EAAA;QAAK0C,SAAS,EAAE9B,OAAO,CAAA,CAAE;QAAAgB,QAAA,EACvB5B,IAAA,CAACS,OAAO,EAAAnB,MAAA,CAAA+C,MAAA,CAAA,CAAA,CAAA,EACFN,SAAS,EAAA;UACbL,QAAQ,EAAES,YAAY;UACtBR,SAAS,EAAEA,SAAS,KAAKa,SAAS,GAAGb,SAAS,GAAG;YAC/CgB,gBAAgB,EAAE;cAAEC,OAAO,EAAER;YAAU,CAAE;YACzCS,SAAS,EAAE,CAAA7B,EAAA,GAAAS,WAAW,KAAA,IAAA,IAAXA,WAAW,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAXA,WAAW,CAAEqB,UAAU,MAAA,IAAA,IAAA9B,EAAA,KAAA,KAAA,CAAA,GAAAA,EAAA,GAAI;UD5B5B,CC6BX;UAAAY,QAAA,EAEAA;QAAQ,CAAA,CAAA;MACD,CAAA;IACN,CAAA,CAAA,CACC;EAAA,CAAA,CACR;AAEP,CAAC;AAEDd,cAAc,CAACiC,WAAW,GAAG,YAAY;AAEzC;AACA,OAAO,IAAMC,UAAU,gBAAG3C,IAAI,CAACS,cAAc,CAEO;AAEpD,eAAekC,UAAU","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';\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.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];
@@ -26,12 +27,15 @@ var DrawerFormBase = function DrawerFormBase(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,
     drawerProps = props.drawerProps,
     onFinish = props.onFinish,
+    _onReset = props.onReset,
     submitter = props.submitter,
     children = props.children,
     _destroyOnClose = props.destroyOnClose,
-    formProps = __rest(props, ["open", "onOpenChange", "trigger", "title", "width", "placement", "submitTimeout", "autoClose", "drawerProps", "onFinish", "submitter", "children", "destroyOnClose"]);
+    formProps = __rest(props, ["open", "onOpenChange", "trigger", "title", "width", "placement", "submitTimeout", "autoClose", "closeOnReset", "drawerProps", "onFinish", "onReset", "submitter", "children", "destroyOnClose"]);
   var _useOverlayForm = useOverlayForm({
       open: open,
       onOpenChange: onOpenChange,
@@ -54,13 +58,18 @@ var DrawerFormBase = function DrawerFormBase(props) {
       children: _jsx("div", {
         className: classes(),
         children: _jsx(ProForm, Object.assign({}, formProps, {
+          formComponentType: "DrawerForm",
           onFinish: handleFinish,
-          submitter: submitter !== undefined ? submitter : {
-            resetButtonProps: {
-              onClick: handleHide
-            },
-            resetText: 'Cancel'
+          // Close rides the FORM-LEVEL reset channel — the single point
+          // where every reset surface converges. 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: 'Cancel'
+          }, _typeof(submitter) === 'object' ? submitter : {}),
           children: children
         }))
       })
@@ -71,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","drawerProps","onFinish","submitter","children","_destroyOnClose","destroyOnClose","formProps","_useOverlayForm","mergedOpen","triggerNode","handleFinish","handleHide","assign","onClose","footer","className","undefined","resetButtonProps","onClick","resetText","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, drawerProps, onFinish, 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\", \"drawerProps\", \"onFinish\", \"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, { onFinish: handleFinish, submitter: submitter !== undefined ? submitter : {\n                            resetButtonProps: { onClick: handleHide },\n                            resetText: 'Cancel',\n                        }, 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":";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"}