@1money/component-ui 0.0.1

package/es/components/ProForm/hooks/useFieldRequest.js

@@ -0,0 +1,90 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+import { useEffect, useRef } from 'react';
+import { useSafeState, useMemoizedFn } from '@1money/hooks';
+import { stableSerialize } from '../utils';
+/**
+ * Hook for async option fetching with param-based re-fetching.
+ * Returns [loading, options].
+ */
+export function useFieldRequest(request, params) {
+  var _this = this;
+  var _useSafeState = useSafeState(false),
+    _useSafeState2 = _slicedToArray(_useSafeState, 2),
+    loading = _useSafeState2[0],
+    setLoading = _useSafeState2[1];
+  var _useSafeState3 = useSafeState([]),
+    _useSafeState4 = _slicedToArray(_useSafeState3, 2),
+    options = _useSafeState4[0],
+    setOptions = _useSafeState4[1];
+  var requestRef = useRef(request);
+  requestRef.current = request;
+  var serializedParams = stableSerialize(params);
+  var fetchOptions = useMemoizedFn(function () {
+    return __awaiter(_this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var fn, result;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            fn = requestRef.current;
+            if (fn) {
+              _context.next = 3;
+              break;
+            }
+            return _context.abrupt("return");
+          case 3:
+            setLoading(true);
+            _context.prev = 4;
+            _context.next = 7;
+            return fn(params);
+          case 7:
+            result = _context.sent;
+            if (Array.isArray(result)) {
+              setOptions(result);
+            }
+          case 9:
+            _context.prev = 9;
+            setLoading(false);
+            return _context.finish(9);
+          case 12:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[4,, 9, 12]]);
+    }));
+  });
+  useEffect(function () {
+    if (!requestRef.current) return;
+    fetchOptions();
+  }, [serializedParams]);
+  return [loading, options];
+}
+export default useFieldRequest;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

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

@@ -0,0 +1,30 @@
+import './style';
+declare const ProForm: import("react").NamedExoticComponent<import("./interface").ProFormProps> & {
+    Dependency: import("react").NamedExoticComponent<import("./interface").ProFormDependencyProps>;
+    List: import("react").NamedExoticComponent<import("./interface").ProFormListProps>;
+    Group: import("react").NamedExoticComponent<import("./interface").ProFormGroupProps>;
+    FieldSet: import("react").NamedExoticComponent<import("./interface").ProFormFieldSetProps>;
+    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>>;
+    TextArea: import("react").FC<import("./interface").ProFormFieldProps<import("../Input").InputTextAreaProps>>;
+    Checkbox: import("react").FC<import("./interface").ProFormFieldProps<import("../Checkbox").CheckboxProps>>;
+    CheckboxGroup: import("react").FC<import("./interface").ProFormFieldProps<import("../Checkbox").CheckboxGroupProps>>;
+    Switch: import("react").FC<import("./interface").ProFormFieldProps<import("../Switch").SwitchProps>>;
+    Select: import("react").FC<import("./interface").ProFormFieldProps<import("../Select").SelectProps>>;
+    Upload: import("react").FC<import("./interface").ProFormFieldProps<import("../Upload").UploadProps>>;
+};
+export { ProForm };
+export default ProForm;
+export { ProFormDependency } from './ProFormDependency';
+export { ProFormList } from './ProFormList';
+export { ProFormGroup } from './ProFormGroup';
+export { Submitter } from './Submitter';
+export { createProFormField, ProFormText, ProFormPassword, ProFormTextArea, ProFormCheckbox, ProFormCheckboxGroup, ProFormSwitch, ProFormSelect, ProFormUpload, ProFormFieldSet, } from './fields';
+export { DrawerForm } from './layouts/DrawerForm';
+export { ModalForm } from './layouts/ModalForm';
+export { QueryFilter } from './layouts/QueryFilter';
+export { useProFormContext, FormListContext, useFormListContext } from './context';
+export type { ProFormProps, ProFormFieldProps, ProFormContextValue, ProFormFormInstance, ProFormFieldTransformFn, ProFormFieldConvertValueFn, ProFormValueEnumObj, ProFormRequestOption, FormListContextValue, ProFormColProps, ProFormFieldSetProps, ProFormGroupProps, SubmitterProps, ProFormDependencyProps, ProFormListProps, ProFormListAction, DrawerFormProps, ModalFormProps, QueryFilterProps, CreateProFormFieldConfig, } from './interface';
+export { CSS_PREFIX, WIDTH_SIZE_MAP, DEFAULT_COL_SPAN, DEFAULT_TEXT, PROFORM_MODES } from './constants';
+export type { ProFormMode } from './constants';

package/es/components/ProForm/index.js

@@ -0,0 +1,37 @@
+import { ProForm as ProFormBase } from './ProForm';
+import { ProFormDependency } from './ProFormDependency';
+import { ProFormList } from './ProFormList';
+import { ProFormGroup } from './ProFormGroup';
+import { Submitter } from './Submitter';
+import { ProFormText, ProFormPassword, ProFormTextArea, ProFormCheckbox, ProFormCheckboxGroup, ProFormSwitch, ProFormSelect, ProFormUpload, ProFormFieldSet } from './fields';
+import './style';
+// Compose ProForm with static sub-components
+var ProForm = Object.assign(ProFormBase, {
+  Dependency: ProFormDependency,
+  List: ProFormList,
+  Group: ProFormGroup,
+  FieldSet: ProFormFieldSet,
+  Submitter: Submitter,
+  Text: ProFormText,
+  Password: ProFormPassword,
+  TextArea: ProFormTextArea,
+  Checkbox: ProFormCheckbox,
+  CheckboxGroup: ProFormCheckboxGroup,
+  Switch: ProFormSwitch,
+  Select: ProFormSelect,
+  Upload: ProFormUpload
+});
+export { ProForm };
+export default ProForm;
+// Re-export individual pieces for named imports
+export { ProFormDependency } from './ProFormDependency';
+export { ProFormList } from './ProFormList';
+export { ProFormGroup } from './ProFormGroup';
+export { Submitter } from './Submitter';
+export { createProFormField, ProFormText, ProFormPassword, ProFormTextArea, ProFormCheckbox, ProFormCheckboxGroup, ProFormSwitch, ProFormSelect, ProFormUpload, ProFormFieldSet } from './fields';
+export { DrawerForm } from './layouts/DrawerForm';
+export { ModalForm } from './layouts/ModalForm';
+export { QueryFilter } from './layouts/QueryFilter';
+export { useProFormContext, FormListContext, useFormListContext } 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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

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

@@ -0,0 +1,240 @@
+import type { ReactNode, FC, ReactElement, MutableRefObject, CSSProperties } from 'react';
+import type { FormProps, FormCoreInstance, Rule } from "../Form";
+import type { ButtonProps } from "../Button";
+import type { DrawerProps, DrawerPlacement } from "../Drawer";
+import type { GridRowProps, GridColSize } from "../Grid";
+import type { ModalProps } from "../Modal";
+import type { ProFormMode } from './constants';
+/** Transform field value before submission */
+export type ProFormFieldTransformFn = (value: unknown, name: string, allValues: Record<string, unknown>) => unknown;
+/** Convert stored value before displaying in the field */
+export type ProFormFieldConvertValueFn = (value: unknown, name: string) => unknown;
+export type ProFormValueEnumObj = Record<string | number, string | {
+    text: string;
+    disabled?: boolean;
+}>;
+export interface ProFormColProps {
+    span?: number;
+    sm?: GridColSize;
+    md?: GridColSize;
+    lg?: GridColSize;
+}
+export interface ProFormRequestOption {
+    label: string;
+    value: unknown;
+    disabled?: boolean;
+}
+export interface ProFormContextValue {
+    /** @deprecated Use `mode` instead. Kept for backward compatibility. */
+    readonly?: boolean;
+    /** Form mode: 'edit' (default), 'read' (readonly), 'update' (edit existing data) */
+    mode?: ProFormMode;
+    grid?: boolean;
+    colProps?: ProFormColProps;
+    registerTransform?: (name: string, fn: ProFormFieldTransformFn) => void;
+    unregisterTransform?: (name: string) => void;
+    formInstance?: ProFormFormInstance;
+}
+export interface ProFormFormInstance {
+    submit: () => {
+        success: boolean;
+        values?: Record<string, unknown>;
+        errors?: Record<string, string>;
+    };
+    resetFields: () => void;
+    getFieldValue: (name: string) => unknown;
+    getFieldsValue: () => Record<string, unknown>;
+    setFieldsValue: (values: Record<string, unknown>) => void;
+    setFieldValue: (name: string, value: unknown) => void;
+    validateFields: (fieldsRules?: Record<string, Rule[]>) => boolean;
+    getFieldsFormatValue: () => Record<string, unknown>;
+    validateFieldsReturnFormatValue: () => {
+        success: boolean;
+        values?: Record<string, unknown>;
+        errors?: Record<string, string>;
+    };
+}
+export interface ProFormFieldProps<FieldProps = Record<string, unknown>> {
+    name?: string;
+    label?: ReactNode;
+    rules?: Rule[];
+    required?: boolean;
+    help?: ReactNode;
+    validateStatus?: string;
+    labelCol?: {
+        span?: number;
+        offset?: number;
+    };
+    wrapperCol?: {
+        span?: number;
+        offset?: number;
+    };
+    colon?: boolean;
+    /** @deprecated Use `mode='read'` instead */
+    readonly?: boolean;
+    /** Field-level mode override: 'edit', 'read', or 'update' */
+    mode?: ProFormMode;
+    hidden?: boolean;
+    colProps?: ProFormColProps;
+    fieldProps?: Partial<FieldProps>;
+    placeholder?: string;
+    disabled?: boolean;
+    width?: 'sm' | 'md' | 'lg' | 'xl' | number;
+    transform?: ProFormFieldTransformFn;
+    convertValue?: ProFormFieldConvertValueFn;
+    /** Field names to watch — auto-wraps with ProFormDependency */
+    dependencies?: string[];
+    /** Async option loader (works with Select, RadioGroup, CheckboxGroup) */
+    request?: (params?: Record<string, unknown>) => Promise<ProFormRequestOption[]>;
+    /** Extra params passed to request; merged with dependency values */
+    params?: Record<string, unknown>;
+    /** Quick enum → options conversion for Select/Radio/Checkbox fields */
+    valueEnum?: ProFormValueEnumObj;
+    /** Debounce delay (ms) for field onChange */
+    debounceTime?: number;
+}
+export interface SubmitterProps {
+    submitText?: ReactNode;
+    resetText?: ReactNode;
+    render?: (props: {
+        form: FormCoreInstance;
+        submit: () => void;
+        reset: () => void;
+    }, dom: ReactElement[]) => ReactNode;
+    onSubmit?: () => void;
+    onReset?: () => void;
+    submitButtonProps?: Partial<ButtonProps>;
+    resetButtonProps?: Partial<ButtonProps>;
+}
+export interface ProFormProps extends Omit<FormProps, 'onSubmit'> {
+    submitter?: SubmitterProps | false;
+    /** @deprecated Use `mode='read'` instead */
+    readonly?: boolean;
+    /** Form mode: 'edit' (default), 'read' (readonly), 'update' (edit existing data) */
+    mode?: ProFormMode;
+    grid?: boolean;
+    colProps?: ProFormColProps;
+    rowProps?: Partial<GridRowProps>;
+    loading?: boolean;
+    request?: (params?: unknown) => Promise<Record<string, unknown>>;
+    params?: unknown;
+    formRef?: MutableRefObject<ProFormFormInstance | undefined>;
+    /** Strip null / undefined / empty-string values before onFinish (default: true) */
+    omitNil?: boolean;
+}
+export interface ProFormListAction {
+    add: (defaultValue?: Record<string, unknown>, index?: number) => void;
+    remove: (index: number) => void;
+    move: (from: number, to: number) => void;
+    copy: (index: number) => void;
+    getList: () => unknown[];
+}
+export interface ProFormListProps {
+    name: string;
+    label?: ReactNode;
+    min?: number;
+    max?: number;
+    /** Validate that the list is not empty on form submission */
+    required?: boolean;
+    /** Error message when list is empty (used with required) */
+    requiredMessage?: string;
+    initialValue?: Record<string, unknown>[];
+    copyIconProps?: false | Partial<ButtonProps>;
+    deleteIconProps?: false | Partial<ButtonProps>;
+    creatorButtonProps?: false | (Partial<ButtonProps> & {
+        text?: ReactNode;
+        position?: 'top' | 'bottom';
+    });
+    itemRender?: (props: {
+        listDom: ReactNode;
+        action: ProFormListAction;
+    }) => ReactNode;
+    actionRender?: (row: {
+        index: number;
+        record: unknown;
+    }, action: ProFormListAction, 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;
+    onAfterRemove?: (index: number) => void;
+}
+export interface ProFormDependencyProps {
+    name: string[];
+    ignoreFormListField?: boolean;
+    children: (values: Record<string, unknown>, form: ProFormFormInstance) => ReactNode;
+}
+export interface FormListContextValue {
+    listName?: string;
+}
+export interface ProFormFieldSetProps {
+    name?: string;
+    label?: ReactNode;
+    rules?: Rule[];
+    required?: boolean;
+    help?: ReactNode;
+    /** Gap between child fields in px */
+    gap?: number;
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+export interface ProFormGroupProps {
+    title?: ReactNode;
+    /** Extra content rendered at the right of the title */
+    extra?: ReactNode;
+    collapsible?: boolean;
+    defaultCollapsed?: boolean;
+    collapsed?: boolean;
+    onCollapse?: (collapsed: boolean) => void;
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+export interface ModalFormProps extends Omit<ProFormProps, 'title'> {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    trigger?: ReactElement;
+    title?: ReactNode;
+    width?: number | string;
+    submitTimeout?: number;
+    autoClose?: boolean;
+    destroyOnClose?: boolean;
+    modalProps?: Partial<ModalProps>;
+}
+export interface DrawerFormProps extends Omit<ProFormProps, 'title'> {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    trigger?: ReactElement;
+    title?: ReactNode;
+    width?: number | string;
+    placement?: DrawerPlacement;
+    submitTimeout?: number;
+    autoClose?: boolean;
+    destroyOnClose?: boolean;
+    drawerProps?: Partial<DrawerProps>;
+}
+export interface QueryFilterProps extends ProFormProps {
+    defaultCollapsed?: boolean;
+    collapsed?: boolean;
+    onCollapse?: (collapsed: boolean) => void;
+    defaultColsNumber?: number;
+    labelWidth?: number | 'auto';
+    split?: boolean;
+    searchConfig?: {
+        searchText?: ReactNode;
+        resetText?: ReactNode;
+    };
+    /** Sync form values to URL search params */
+    syncToUrl?: boolean | ((values: Record<string, unknown>, type: 'get' | 'set') => Record<string, unknown>);
+}
+export interface CreateProFormFieldConfig<FieldProps> {
+    component: FC<FieldProps> | (FC<FieldProps> & {
+        displayName?: string;
+    });
+    valuePropName?: string;
+    mapProps?: (props: Record<string, unknown>) => Record<string, unknown>;
+    renderReadonly?: (value: unknown, props?: Partial<FieldProps>) => ReactNode;
+}

package/es/components/ProForm/interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50cy9Qcm9Gb3JtL2ludGVyZmFjZS5qcyIsIm5hbWVzIjpbXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyIsInNvdXJjZXMiOlsiY29tcG9uZW50cy9Qcm9Gb3JtL2ludGVyZmFjZS5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge307Il0sIm1hcHBpbmdzIjoiQUFBQSIsImlnbm9yZUxpc3QiOltdfQ==

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

@@ -0,0 +1,3 @@
+import type { DrawerFormProps } from '../interface';
+export declare const DrawerForm: import("react").NamedExoticComponent<DrawerFormProps>;
+export default DrawerForm;

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

@@ -0,0 +1,73 @@
+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];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo } from 'react';
+import { default as classnames } from '../../../utils/classnames';
+import { Drawer } from '../../Drawer';
+import { ProForm } from '../ProForm';
+import { CSS_PREFIX } from '../constants';
+import { useOverlayForm } from './useOverlayForm';
+var classes = classnames("".concat(CSS_PREFIX, "-drawer-form"));
+var DrawerFormBase = function DrawerFormBase(props) {
+  var open = props.open,
+    onOpenChange = props.onOpenChange,
+    trigger = props.trigger,
+    title = props.title,
+    _props$width = props.width,
+    width = _props$width === void 0 ? 480 : _props$width,
+    _props$placement = props.placement,
+    placement = _props$placement === void 0 ? 'right' : _props$placement,
+    submitTimeout = props.submitTimeout,
+    _props$autoClose = props.autoClose,
+    autoClose = _props$autoClose === void 0 ? true : _props$autoClose,
+    drawerProps = props.drawerProps,
+    onFinish = props.onFinish,
+    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"]);
+  var _useOverlayForm = useOverlayForm({
+      open: open,
+      onOpenChange: onOpenChange,
+      trigger: trigger,
+      autoClose: autoClose,
+      submitTimeout: submitTimeout
+    }, onFinish),
+    mergedOpen = _useOverlayForm.mergedOpen,
+    triggerNode = _useOverlayForm.triggerNode,
+    handleFinish = _useOverlayForm.handleFinish,
+    handleHide = _useOverlayForm.handleHide;
+  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 : {
+            resetButtonProps: {
+              onClick: handleHide
+            },
+            resetText: 'Cancel'
+          },
+          children: children
+        }))
+      })
+    }))]
+  });
+};
+DrawerFormBase.displayName = 'DrawerForm';
+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';\nexport const DrawerForm = memo(DrawerFormBase);\nexport default DrawerForm;",null],"sourceRoot":"../../../../../../../../../../src"}

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

@@ -0,0 +1,3 @@
+import type { ModalFormProps } from '../interface';
+export declare const ModalForm: import("react").NamedExoticComponent<ModalFormProps>;
+export default ModalForm;

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

@@ -0,0 +1,74 @@
+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];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo } from 'react';
+import { default as classnames } from '../../../utils/classnames';
+import { Modal } from '../../Modal';
+import { ProForm } from '../ProForm';
+import { CSS_PREFIX } from '../constants';
+import { useOverlayForm } from './useOverlayForm';
+var classes = classnames("".concat(CSS_PREFIX, "-modal-form"));
+var ModalFormBase = function ModalFormBase(props) {
+  var _a;
+  var open = props.open,
+    onOpenChange = props.onOpenChange,
+    trigger = props.trigger,
+    title = props.title,
+    width = props.width,
+    submitTimeout = props.submitTimeout,
+    _props$autoClose = props.autoClose,
+    autoClose = _props$autoClose === void 0 ? true : _props$autoClose,
+    modalProps = props.modalProps,
+    onFinish = props.onFinish,
+    submitter = props.submitter,
+    children = props.children,
+    _destroyOnClose = props.destroyOnClose,
+    formProps = __rest(props, ["open", "onOpenChange", "trigger", "title", "width", "submitTimeout", "autoClose", "modalProps", "onFinish", "submitter", "children", "destroyOnClose"]);
+  var _useOverlayForm = useOverlayForm({
+      open: open,
+      onOpenChange: onOpenChange,
+      trigger: trigger,
+      autoClose: autoClose,
+      submitTimeout: submitTimeout
+    }, onFinish),
+    mergedOpen = _useOverlayForm.mergedOpen,
+    triggerNode = _useOverlayForm.triggerNode,
+    handleFinish = _useOverlayForm.handleFinish,
+    handleHide = _useOverlayForm.handleHide;
+  return _jsxs(_Fragment, {
+    children: [triggerNode, _jsx(Modal, Object.assign({}, modalProps, {
+      open: mergedOpen,
+      title: title,
+      onCancel: handleHide,
+      footer: null
+    }, width !== undefined ? {
+      rootStyle: Object.assign(Object.assign({}, modalProps === null || modalProps === void 0 ? void 0 : modalProps.rootStyle), {
+        width: width
+      })
+    } : {}, {
+      children: _jsx("div", {
+        className: classes(),
+        children: _jsx(ProForm, Object.assign({}, formProps, {
+          onFinish: handleFinish,
+          submitter: submitter !== undefined ? submitter : {
+            resetButtonProps: {
+              onClick: handleHide
+            },
+            resetText: (_a = modalProps === null || modalProps === void 0 ? void 0 : modalProps.cancelText) !== null && _a !== void 0 ? _a : 'Cancel'
+          },
+          children: children
+        }))
+      })
+    }))]
+  });
+};
+ModalFormBase.displayName = 'ModalForm';
+export var ModalForm = /*#__PURE__*/memo(ModalFormBase);
+export default ModalForm;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProForm/layouts/ModalForm.js","components/ProForm/src/components/ProForm/layouts/ModalForm.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","Modal","ProForm","CSS_PREFIX","useOverlayForm","classes","concat","ModalFormBase","props","_a","open","onOpenChange","trigger","title","width","submitTimeout","_props$autoClose","autoClose","modalProps","onFinish","submitter","children","_destroyOnClose","destroyOnClose","formProps","_useOverlayForm","mergedOpen","triggerNode","handleFinish","handleHide","assign","onCancel","footer","undefined","rootStyle","className","resetButtonProps","onClick","resetText","cancelText","displayName","ModalForm"],"mappings":"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","file":"components/ProForm/layouts/ModalForm.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 { Modal } from '../../Modal';\nimport { ProForm } from '../ProForm';\nimport { CSS_PREFIX } from '../constants';\nimport { useOverlayForm } from './useOverlayForm';\nconst classes = classnames(`${CSS_PREFIX}-modal-form`);\nconst ModalFormBase = (props) => {\n    var _a;\n    const { open, onOpenChange, trigger, title, width, submitTimeout, autoClose = true, modalProps, onFinish, submitter, children, \n    // destroyOnClose is accepted for API compat but not used —\n    // Modal'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\", \"modalProps\", \"onFinish\", \"submitter\", \"children\", \"destroyOnClose\"]);\n    const { mergedOpen, triggerNode, handleFinish, handleHide, } = useOverlayForm({ open, onOpenChange, trigger, autoClose, submitTimeout }, onFinish);\n    return (_jsxs(_Fragment, { children: [triggerNode, _jsx(Modal, Object.assign({}, modalProps, { open: mergedOpen, title: title, onCancel: handleHide, footer: null }, (width !== undefined ? { rootStyle: Object.assign(Object.assign({}, modalProps === null || modalProps === void 0 ? void 0 : modalProps.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 = modalProps === null || modalProps === void 0 ? void 0 : modalProps.cancelText) !== null && _a !== void 0 ? _a : 'Cancel',\n                        }, children: children })) }) }))] }));\n};\nModalFormBase.displayName = 'ModalForm';\nexport const ModalForm = memo(ModalFormBase);\nexport default ModalForm;",null],"sourceRoot":"../../../../../../../../../../src"}

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

@@ -0,0 +1,4 @@
+import type { QueryFilterProps } from '../interface';
+import React from 'react';
+export declare const QueryFilter: React.NamedExoticComponent<QueryFilterProps>;
+export default QueryFilter;