@zat-design/sisyphus-react 4.5.5 → 4.5.6-beta.1

package/es/ProForm/components/combination/ProRangeLimit/propsType.d.ts

@@ -0,0 +1,23 @@
+import { RangePickerProps } from 'antd/es/date-picker';
+import { Dayjs } from 'dayjs';
+type Value = [Dayjs?, Dayjs?] | null;
+type ValueStr = [string?, string?] | null;
+type HandleChange = (valueStr: ValueStr | null, value: Value | null) => void;
+export type ProRangeLimitType = Omit<RangePickerProps, 'value' | 'onChange' | 'format' | 'separator' | 'mode'> & {
+    disabled?: boolean | [boolean, boolean];
+    foreverText?: string;
+    foreverDate?: string;
+    otherProps?: any;
+    onChange?: HandleChange;
+    value?: ValueStr;
+    format?: string;
+    separator?: any;
+    isView?: boolean;
+    showTime?: any;
+    valueType?: any;
+    /**
+     * 是否限制时间范围
+     */
+    limit?: boolean;
+};
+export {};

package/es/ProForm/components/combination/ProTimeLimit/hooks/useControlled.d.ts

@@ -0,0 +1,8 @@
+import type { Dayjs } from 'dayjs';
+interface Props<T = any> {
+    value?: T;
+    onChange?: (value: T, ...rest: any[]) => void;
+    format?: string;
+}
+declare const useControlled: (props: Props) => [Dayjs | undefined, (value: Dayjs | undefined) => void];
+export default useControlled;

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

@@ -0,0 +1,33 @@
+import { DatePickerProps, TimePickerProps } from 'antd';
+import type { Dayjs } from 'dayjs';
+import React from 'react';
+import type { ProFormOtherType } from '../../../propsType';
+import type { ProRangeLimitType } from '../ProRangeLimit/propsType';
+import type { DistributiveOmit } from '../../../../ProForm/propsType';
+export type DateType = DatePickerProps['value'];
+export type ProTimeLimitType = DistributiveOmit<DatePickerProps, 'value' | 'onChange' | 'mode'> & {
+    value?: string;
+    onChange?: (value: ProTimeLimitType['value'] | null, valueData: Dayjs) => void;
+    disabled?: boolean;
+    foreverDate?: string;
+    foreverText?: string;
+    viewEmpty?: React.ReactNode;
+    format?: string;
+    valueType?: 'dayjs' | 'format' | 'ISO' | 'dateTime' | 'dateStartEndTime';
+    otherProps?: ProFormOtherType;
+    mode?: 'DatePicker';
+    isView?: boolean;
+    /**
+     * 是否限制时间范围
+     */
+    limit?: boolean;
+} & TimePickerProps & {
+    showTime?: DatePickerProps['showTime'];
+    showNow?: boolean;
+};
+export declare const ProTimeLimit: React.FC<ProTimeLimitType>;
+export type ProLimitType = ProTimeLimitType | (ProRangeLimitType & {
+    mode: 'RangePicker';
+});
+declare const LimitPick: React.FC<ProLimitType>;
+export default LimitPick;

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

@@ -0,0 +1,29 @@
+import * as componentMap from './index';
+export { default as Select } from './base/Select';
+export { default as DatePicker } from './base/DatePicker';
+export { default as RangePicker } from './base/RangePicker';
+export { default as TextArea } from './base/TextArea';
+export { default as Switch } from './base/Switch';
+export { default as Radio } from './base/Radio';
+export { default as Checkbox } from './base/Checkbox';
+export { default as Input } from './base/Input';
+export { default as InputNumber } from './base/InputNumber';
+export { default as SwitchCheckbox } from './base/SwitchCheckbox';
+export { default as TimePicker } from './base/TimePicker';
+export { default as FormList } from './combination/FormList';
+export { default as ProEditTable } from '../../ProEditTable';
+export { default as ProCascader } from './combination/ProCascader';
+export { default as ProNumberRange } from './combination/ProNumberRange';
+export { default as ProModalSelect } from './combination/ProModalSelect';
+export { default as ProTimeLimit } from './combination/ProTimeLimit';
+export { default as ProRangeLimit } from './combination/ProRangeLimit';
+export { default as Group } from './combination/Group';
+export { default as ProCollapse } from './combination/Container';
+export { default as Container } from './combination/Container';
+export { default as ProEnum } from '../../ProEnum';
+export { default as ProSelect } from '../../ProSelect';
+export { default as ProUpload } from '../../ProUpload';
+export { default as ProTreeModal } from '../../ProTreeModal';
+export { default as ProTree } from '../../ProTree';
+export { default as FormFooter } from './FormFooter';
+export type ProFormComponentType = keyof typeof componentMap;

package/es/ProForm/components/render/ChangedWrapper.d.ts

@@ -0,0 +1,17 @@
+import { FormInstance } from 'antd';
+import { NamePath } from 'antd/lib/form/interface';
+import React from 'react';
+import { DiffOriginalParams } from '../../utils/diffOriginal';
+import type { DiffConfigType } from '../../propsType';
+interface Props {
+    name?: NamePath;
+    names?: NamePath[];
+    namesStr?: string;
+    diffConfig?: DiffConfigType;
+    form: FormInstance;
+    onDiff?: DiffOriginalParams['onDiff'];
+    valuePropName?: string;
+    [name: string]: any;
+}
+declare const ChangedWrapper: React.FC<Props>;
+export default ChangedWrapper;

package/es/ProForm/components/render/ConfirmWrapper.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { ProFormColumnType } from '../../propsType';
+interface Props<T = any> {
+    value?: T;
+    onChange?: (value: T, ...rest: any[]) => void;
+    confirm: ProFormColumnType['confirm'];
+    [K: string]: any;
+}
+declare const ConfirmWrapper: React.FC<Props>;
+export default ConfirmWrapper;

package/es/ProForm/components/render/CustomComponentViewWrapper.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { FormItemProps, FormInstance } from 'antd';
+import type { NamePath } from 'antd/es/form/interface';
+interface CustomComponentViewWrapperProps {
+    formItemProps: FormItemProps;
+    internalItemRender?: any;
+    className?: string;
+    style?: React.CSSProperties;
+    filterFormItemKey?: string[];
+    form: FormInstance;
+    name?: NamePath;
+    isView?: boolean;
+    viewRender?: (value: any, record: any, options: {
+        form: FormInstance;
+        index?: any;
+        namePath?: any;
+    }) => React.ReactNode | string | null | undefined;
+    originComponent?: React.ReactNode;
+    viewEmpty?: React.ReactNode;
+    otherProps?: any;
+    component?: any;
+    AutoComponent?: any;
+    children: React.ReactNode;
+}
+/**
+ * 自定义组件视图模式包装器
+ * 用于处理自定义组件在 isView 模式下的渲染逻辑
+ */
+declare const CustomComponentViewWrapper: React.FC<CustomComponentViewWrapperProps>;
+export default CustomComponentViewWrapper;

package/es/ProForm/components/render/Render.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { RenderType } from './propsType';
+declare const Render: React.FC<RenderType>;
+export default Render;

package/es/ProForm/components/render/RenderFields.d.ts

@@ -0,0 +1,26 @@
+import { ColProps } from 'antd';
+import { FormInstance } from 'antd/es/form/Form';
+import React from 'react';
+import type { ProFormColumnType } from './propsType';
+import type { DiffConfigType } from '../../propsType';
+interface Props<T = any> {
+    isView?: boolean;
+    columns: ProFormColumnType[];
+    disabled?: boolean;
+    form: FormInstance<T>;
+    expand?: boolean | number;
+    colProps?: ColProps;
+    /** 列宽占比 */
+    span?: number;
+    viewEmpty?: React.ReactNode;
+    openState?: boolean;
+    labelWidth?: string | number;
+    diffConfig?: DiffConfigType;
+    clearNotShow?: boolean;
+    requiredOnView?: boolean;
+    required?: boolean | boolean[] | (() => boolean | boolean[]);
+    globalControl?: boolean;
+    shouldUpdateDebounce?: number;
+}
+declare const RenderFields: React.FC<Props>;
+export default RenderFields;

package/es/ProForm/components/render/propsType.d.ts

@@ -0,0 +1,279 @@
+import type { ColProps, FormInstance, FormItemProps, ModalFuncProps } from 'antd';
+import type { NamePath } from 'antd/es/form/interface';
+import React from 'react';
+import { validate, regExp } from '@zat-design/utils';
+import type { RuleObject } from 'antd/es/form';
+import type { Props as InputProps } from '../base/Input/propsType';
+import type { Props as InputNumberProps } from '../base/InputNumber';
+import type { Props as RadioProps } from '../base/Radio';
+import type { Props as CheckboxProps } from '../base/Checkbox';
+import type { Props as DatePickerProps } from '../base/DatePicker';
+import type { Props as RangePickerProps } from '../base/RangePicker';
+import type { TypeWithRef as FormListType } from '../combination/FormList/propsType';
+import type { Props as SelectProps } from '../base/Select';
+import type { Props as TimePickerProps } from '../base/TimePicker';
+import type { Props as SwitchProps } from '../base/Switch';
+import type { Props as SwitchCheckboxProps } from '../base/SwitchCheckbox';
+import type { Props as TextAreaProps } from '../base/TextArea';
+import type { ProCascaderType } from '../combination/ProCascader/propsType';
+import type { ProModalSelectType } from '../combination/ProModalSelect/propsType';
+import type { ProNumberRangeType } from '../combination/ProNumberRange/propsType';
+import type { ProLimitType } from '../combination/ProTimeLimit';
+import type { ProRangeLimitType } from '../combination/ProRangeLimit/propsType';
+import type { CheckboxPropsMapType, ProEnumType, PropProSelectsMapType, PropRadioPropsMapType } from '../../../ProEnum/propsType';
+import type { PropSelectType as ProSelectProps } from '../../../ProSelect/propsType';
+import type { ProEditTableType } from '../../../ProEditTable/propsType';
+import type { ProTreeModalType } from '../../../ProTreeModal/propsType';
+import type { ProUploadType } from '../../../ProUpload/propsType';
+import type { ProTreeType } from '../../../ProTree/propsType';
+import type { GroupType as GroupCopyProps } from '../combination/Group/propsType';
+import type { ProCollapseType } from '../../../ProLayout/components/ProCollapse/PropTypes';
+import type { DistributiveOmit } from '../../propsType';
+import type { DiffOriginalParams } from '../../utils/diffOriginal';
+import { NamePathsDependencyType } from '../../utils/processDependencies';
+type ValidateKey = keyof typeof validate;
+type RegExpKey = keyof typeof regExp;
+export interface ProRule extends Omit<RuleObject, 'type'> {
+    type?: ValidateKey | RegExpKey;
+    message?: string;
+}
+/**
+ * percent 百分比 permillage 千分比 amount 金额
+ */
+export type ViewType = 'percent' | 'permillage' | 'amount' | 'thousandth';
+export type PartialOf<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+interface ControlProps {
+    value?: unknown;
+    onChange?: (...args: any[]) => void;
+}
+/**
+ * 扩展函数的参数
+ */
+export type FunctionArgs<Values, R = any> = (value: any, record: any, { form, index, namePath, option, selectedOptions, dateString, }: {
+    form: FormInstance<Values>;
+    index?: number;
+    namePath?: NamePath;
+    [key: string]: any;
+}) => R;
+type TransformToFormField<T extends ControlProps, Values> = DistributiveOmit<T, 'onChange' | 'value' | 'role'> & {
+    value?: T['value'];
+    onChange?: (value: Parameters<T['onChange']>[0], options: Parameters<T['onChange']>[1], form: FormInstance<Values>) => void;
+    onFieldChange?: FunctionArgs<Values>;
+    dataSource?: any[];
+    /** ProForm disable时，是否完全受控 */
+    disabledStrictly?: boolean;
+};
+type ProEnumFormType<Values> = TransformToFormField<ProEnumType, Values> | TransformToFormField<ProEnumType & PropProSelectsMapType, Values> | TransformToFormField<ProEnumType & PropRadioPropsMapType, Values> | TransformToFormField<ProEnumType & CheckboxPropsMapType, Values>;
+type ProEnumTableType<Values> = TransformToTableField<ProEnumType, Values> | TransformToTableField<ProEnumType & PropProSelectsMapType, Values> | TransformToTableField<ProEnumType & PropRadioPropsMapType, Values> | TransformToTableField<ProEnumType & CheckboxPropsMapType, Values>;
+type ProEnumFieldType<Values, TT> = TT extends 'ProForm' ? ProEnumFormType<Values> | ReactiveFunction<Values, ProEnumFormType<Values>> : ProEnumTableType<Values> | ((text: any, values: Values, index: number) => ProEnumTableType<Values>);
+type TransformToTableField<T extends ControlProps, Values> = Omit<T, 'onChange' | 'value' | 'onBlur' | 'role'> & {
+    value?: T['value'];
+    onChange?: (value: Parameters<T['onChange']>[0], options: Parameters<T['onChange']>[1], record: any, index: number, form: FormInstance<Values>) => void;
+    onFieldChange?: FunctionArgs<Values>;
+    onBlur?: FunctionArgs<Values>;
+};
+export type ReactiveFunction<Values, R> = (values: Values, { form, index, namePath, }: {
+    form: FormInstance<Values>;
+    index?: number;
+    namePath?: NamePath;
+    [key: string]: any;
+}) => R;
+type FieldType<T extends ControlProps, Values, TT> = TT extends 'ProForm' ? TransformToFormField<T, Values> | ReactiveFunction<Values, TransformToFormField<T, Values>> : TransformToTableField<T, Values> | ((text: any, values: Values, index: number) => TransformToTableField<T, Values>);
+/**
+ * 值转换
+ */
+export type ProFormValueType = 'percentage' | 'permillage' | 'thousandth' | 'datePicker' | 'enumName' | 'enumCodeName' | 'address' | 'thousandthCNY' | 'date' | 'dateTime' | 'dateStartTime' | 'dateEndTime' | 'dateStartEndTime' | 'switch' | 'desensitization';
+export type ColumnTypeMap<Values = any, T = 'ProForm'> = {
+    type?: 'Input';
+    fieldProps?: FieldType<InputProps, Values, T>;
+} | {
+    type?: 'InputNumber';
+    fieldProps?: FieldType<InputNumberProps, Values, T>;
+} | {
+    type?: 'Radio';
+    fieldProps?: FieldType<RadioProps, Values, T>;
+} | {
+    type?: 'Checkbox';
+    fieldProps?: FieldType<CheckboxProps, Values, T>;
+} | {
+    type?: 'DatePicker';
+    fieldProps?: FieldType<DatePickerProps, Values, T>;
+} | {
+    type?: 'RangePicker';
+    fieldProps?: FieldType<RangePickerProps, Values, T>;
+} | {
+    type?: 'FormList';
+    fieldProps?: FieldType<Omit<FormListType, 'fields' | 'operation' | 'meta'>, Values, T>;
+} | {
+    type?: 'Select';
+    fieldProps?: FieldType<SelectProps, Values, T>;
+} | {
+    type?: 'TimePicker';
+    fieldProps?: FieldType<TimePickerProps, Values, T>;
+} | {
+    type?: 'Switch';
+    fieldProps?: FieldType<SwitchProps, Values, T>;
+} | {
+    type?: 'SwitchCheckbox';
+    fieldProps?: FieldType<SwitchCheckboxProps, Values, T>;
+} | {
+    type?: 'TextArea';
+    fieldProps?: FieldType<TextAreaProps, Values, T>;
+} | {
+    type?: 'ProCascader';
+    fieldProps?: FieldType<ProCascaderType, Values, T>;
+} | {
+    type?: 'ProModalSelect';
+    fieldProps?: FieldType<ProModalSelectType, Values, T>;
+} | {
+    type?: 'ProNumberRange';
+    fieldProps?: FieldType<ProNumberRangeType, Values, T>;
+} | {
+    type?: 'ProRangeLimit';
+    fieldProps?: FieldType<ProRangeLimitType, Values, T>;
+} | {
+    type?: 'ProTimeLimit';
+    fieldProps?: FieldType<ProLimitType, Values, T>;
+} | {
+    type?: 'ProEnum';
+    fieldProps?: ProEnumFieldType<Values, T>;
+} | {
+    type?: 'ProSelect';
+    fieldProps?: FieldType<ProSelectProps, Values, T>;
+} | {
+    type?: 'ProEditTable';
+    fieldProps?: FieldType<ProEditTableType, Values, T>;
+} | {
+    type?: 'ProTreeModal';
+    fieldProps?: FieldType<ProTreeModalType, Values, T>;
+} | {
+    type?: 'ProUpload';
+    fieldProps?: FieldType<ProUploadType, Values, T>;
+} | {
+    type?: 'ProTree';
+    fieldProps?: FieldType<ProTreeType, Values, T>;
+} | {
+    type?: 'Group';
+    fieldProps?: GroupCopyProps | ReactiveFunction<Values, GroupCopyProps>;
+} | {
+    type?: 'ProCollapse';
+    fieldProps?: ProCollapseType | ReactiveFunction<Values, ProCollapseType>;
+} | {
+    type?: 'Container';
+    fieldProps?: any;
+};
+export interface ProFormColumn<Values = any> extends Omit<FormItemProps<Values>, 'rules' | 'required'> {
+    component?: React.ReactNode | ReactiveFunction<Values, React.ReactNode>;
+    names?: NamePath[];
+    show?: boolean | ReactiveFunction<Values, boolean>;
+    valueType?: ProFormValueType;
+    switchValue?: [any, any];
+    isView?: boolean;
+    viewRender?: (value: any, record: Values, { form, index, namePath, }: {
+        form: FormInstance<Values>;
+        index?: number | undefined;
+        [key: string]: any;
+    }) => React.ReactElement<any, any> | string | undefined | null;
+    viewType?: ViewType;
+    colProps?: ColProps;
+    /** 列宽占比 */
+    span?: number;
+    /** 依赖刷新字段列表 */
+    dependNames?: NamePath[];
+    /**
+     * @description       表单props属性
+     * @deprecated        将于下个版本 4.0.0 被弃用, 请使用fieldProps进行替换
+     * @default           -
+     */
+    labelWidth?: string | number;
+    disabled?: boolean | boolean[] | ReactiveFunction<Values, boolean | boolean[]>;
+    trim?: boolean;
+    upperCase?: boolean;
+    hiddenNames?: string[] | any[];
+    rules?: ProRule[] | ReactiveFunction<Values, ProRule[]>;
+    onDiff?: DiffOriginalParams['onDiff'];
+    required?: boolean | boolean[] | ReactiveFunction<Values, boolean | boolean[]>;
+    labelRequired?: boolean;
+    toISOString?: boolean;
+    toCSTString?: boolean;
+    clearNotShow?: boolean;
+    index?: number;
+    namePath?: NamePath;
+    listName?: NamePath;
+    /** 表单前缀信息 */
+    before?: string | React.ReactNode;
+    /** 表单后缀信息 */
+    after?: string | React.ReactNode;
+    /** 表单上方辅助信息 */
+    above?: string | React.ReactNode;
+    /** 表单下方辅助信息 */
+    extra?: string | React.ReactNode;
+    /** 是否固定字段, 不隐藏 */
+    fixed?: boolean;
+    confirm?: boolean | ModalFuncProps | FunctionArgs<Values, boolean | ModalFuncProps | void | Promise<boolean | ModalFuncProps | void>>;
+    /** 防抖模式 */
+    debounceWait?: number;
+    /** 脱敏数据位置下标 */
+    desensitization?: [number, number] | ReactiveFunction<Values, [number, number]>;
+}
+export interface ProFormColumnWithExtendedDeps<Values = any> extends Omit<ProFormColumn<Values>, 'dependencies'> {
+    /** 表单项依赖关系，扩展支持namesPaths类型 */
+    dependencies?: NamePath[] | (NamePath | NamePathsDependencyType)[];
+}
+export type ProFormColumnType<T = any> = ProFormColumnWithExtendedDeps<T> & ColumnTypeMap<T, 'ProForm'>;
+/**
+ * 表单渲染类型
+ */
+export interface RenderType<Values = any> {
+    component: any;
+    formItemProps: FormItemProps<Values> & {
+        labelWidth?: string | number;
+        disabled?: boolean;
+        hiddenNames?: string[];
+        trim?: boolean;
+        upperCase?: boolean;
+        rules?: ProRule[];
+        labelRequired?: boolean;
+        tooltip?: any;
+        isView?: boolean;
+        disabledStrictly?: boolean;
+        /** 表单前缀信息 */
+        before?: string | React.ReactNode;
+        /** 表单后缀信息 */
+        after?: string | React.ReactNode;
+        /** 表单上方辅助信息 */
+        above?: string | React.ReactNode;
+        /** 表单下方辅助信息 */
+        extra?: string | React.ReactNode;
+        parentNames?: string;
+        names?: NamePath[];
+    };
+    componentProps: {
+        disabledStrictly?: boolean;
+        [name: string]: any;
+    };
+    /** 列宽占比 */
+    span?: number;
+    show?: boolean | ((values: Values, { form, index, namePath, }: {
+        form: FormInstance<Values>;
+        index?: number;
+        namePath?: NamePath;
+        [key: string]: any;
+    }) => boolean);
+    fieldProps?: ReactiveFunction<Values, React.ReactNode>;
+    isSelect: boolean;
+    requiredOnView?: boolean;
+    confirm?: ProFormColumnType['confirm'];
+    [name: string]: any;
+}
+/**
+ * 兼容旧命名导出
+ */
+export type ProEnumFormProps<Values> = ProEnumFormType<Values>;
+export type ProEnumTableProps<Values> = ProEnumTableType<Values>;
+export type ProEnumFieldProps<Values, TT> = ProEnumFieldType<Values, TT>;
+export type FieldProps<T extends ControlProps, Values, TT> = FieldType<T, Values, TT>;
+export type ColumnPropsMap<Values = any, T = 'ProForm'> = ColumnTypeMap<Values, T>;
+export type ProColumnProps<Values = any> = ProFormColumnType<Values>;
+export type RenderProps<Values = any> = RenderType<Values>;
+export {};

package/es/ProForm/hooks/useControlled.d.ts

@@ -0,0 +1 @@
+export declare const useControlled: (props: any) => any[];

package/es/ProForm/hooks/useDeepCompareMemo.d.ts

@@ -0,0 +1,2 @@
+/** 深度比较依赖变化memo */
+export declare const useDeepCompareMemo: (fun: () => any, changedCb: (last: any, current: any) => void, depList: any[]) => any;

package/es/ProForm/hooks/useFieldProps.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { ProFormOtherType } from '../propsType';
+export declare const FieldProvider: React.Provider<ProFormOtherType>;
+export declare const useFieldProps: () => ProFormOtherType;

package/es/ProForm/hooks/useForm.d.ts

@@ -0,0 +1,8 @@
+import type { ModifiedFormInstanceType } from '../propsType';
+export interface FormInstanceOption {
+    scrollToError?: boolean;
+    optimize?: boolean;
+    formKey?: string;
+    source?: string;
+}
+export declare const useForm: <T>(originForm?: ModifiedFormInstanceType<T> | FormInstanceOption, options?: FormInstanceOption) => [ModifiedFormInstanceType<T>];

package/es/ProForm/hooks/useRules.d.ts

@@ -0,0 +1,16 @@
+import type { InternalNamePath } from 'antd/lib/form/interface';
+import type { ProRule } from '../components/render/propsType';
+interface Props {
+    rules?: ProRule[];
+    required?: boolean;
+    isSelect: boolean;
+    label?: string;
+    names?: InternalNamePath[];
+    labelRequired?: boolean;
+    type?: string;
+}
+declare const useRules: (props: Props) => {
+    rules: ProRule[];
+    required?: boolean;
+};
+export default useRules;

package/es/ProForm/hooks/useShouldUpdate.d.ts

@@ -0,0 +1,31 @@
+import { FormInstance, FormItemProps } from 'antd';
+import type { ProFormColumnType, ProRule } from '../components/render/propsType';
+interface Result<Values> {
+    shouldUpdate?: FormItemProps<Values>['shouldUpdate'];
+    show?: boolean;
+    disabled?: boolean | boolean[];
+    rules?: ProRule[];
+    required?: boolean;
+    [key: string]: any;
+}
+interface UseShouldUpdateProps<Values> {
+    show?: ProFormColumnType['show'];
+    formItemProps?: FormItemProps<Values> & {
+        clearNotShow?: boolean;
+        names?: any[];
+        index?: number;
+        namePath?: any;
+        dependNames?: any[];
+        parentNames?: any;
+    };
+    form?: FormInstance<Values>;
+    disabled?: boolean;
+    rules?: ProRule[];
+    required?: boolean;
+    type: string;
+    shouldUpdateDebounce?: number;
+    [key: string]: any;
+}
+type HookShouldUpdate<Values = any> = (props: UseShouldUpdateProps<Values>) => Result<Values>;
+declare const useShouldUpdate: HookShouldUpdate;
+export default useShouldUpdate;

package/es/ProForm/hooks/useWatch.d.ts

@@ -0,0 +1,22 @@
+import { FormInstance } from 'antd/es/form/Form';
+import { NamePath } from 'antd/es/form/interface';
+/**
+ * selector 函数：接收所有表单值，返回派生值
+ * 与 antd 5.12.0+ Form.useWatch selector 行为一致
+ */
+export type WatchSelector<T = any> = (values: any) => T;
+/**
+ * ProForm的useWatch hook，用于监听表单字段变化
+ * 支持三种依赖形式：
+ *   1. 字符串路径：useWatch('fieldName', form)
+ *   2. 路径数组：useWatch(['a', 'b'], form) 或 useWatch([['a', 'b'], 'c'], form)
+ *   3. selector 函数：useWatch((values) => values.a + values.b, form)
+ *
+ * @param dependencies 监听的字段路径或 selector 函数
+ * @param form 表单实例
+ * @param wait 防抖等待时间
+ * @returns 表单值或 selector 返回的派生值
+ */
+declare function useWatch<T = any>(selector: WatchSelector<T>, form?: FormInstance, wait?: number): T;
+declare function useWatch(dependencies: string | NamePath[], form?: FormInstance, wait?: number): Record<string, any>;
+export default useWatch;

package/es/ProForm/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { FormProviderProps } from 'antd/es/form/context';
+import type { ProFormInstanceType } from './propsType';
+declare const ProFormForward: ProFormInstanceType;
+export declare const ProFormProvider: React.FC<FormProviderProps>;
+export default ProFormForward;