@ant-design/pro-components 3.1.12-0 → 3.1.13-0

package/es/descriptions/index.js

@@ -1,430 +1,4 @@
-import { CheckOutlined, CloseOutlined, EditOutlined } from '@ant-design/icons';
-import { get, toArray } from '@rc-component/util';
-import { ConfigProvider, Descriptions, Space } from 'antd';
-import React, { useContext, useEffect } from 'react';
-import ValueTypeToComponent from "../field/ValueTypeToComponent";
-import ProForm, { ProFormField } from "../form";
-import ProConfigContext, { ProConfigProvider, proTheme } from "../provider";
-import ProSkeleton from "../skeleton";
-import { ErrorBoundary, InlineErrorFormItem, LabelIconTip, genCopyable, getFieldPropsOrFormItemProps, stringify, useEditableMap } from "../utils";
-import useFetchData from "./useFetchData";
-
-/**
- * 定义列表属性的类型定义，用于定义列表的一列
- * @typedef {Object} ProDescriptionsItemProps
- * @property {ProSchema} schema - 用于生成表格项的 schema 配置对象
- * @property {boolean} [hide] - 是否隐藏该列，可用于权限控制
- * @property {boolean} [plain] - 是否只展示文本，不展示标签
- * @property {boolean} [copyable] - 是否可以拷贝该列的内容
- * @property {boolean | { showTitle?: boolean }} [ellipsis] - 是否展示省略号，如果是一个对象，可以设置鼠标悬浮时是否展示完整的内容
- * @property {ProFieldFCMode} [mode] - ProField 组件的模式
- * @property {React.ReactNode} [children] - 表格项的子组件
- * @property {number} [order] - 表格项的排序
- * @property {number} [index] - 表格项的索引
- * @template T - 表格数据的类型
- * @template ValueType - 表格项的值类型
- */
-import { jsx as _jsx } from "react/jsx-runtime";
-import { jsxs as _jsxs } from "react/jsx-runtime";
-import { createElement as _createElement } from "react";
-/**
- * 根据 dataIndex 获取值，支持 dataIndex 为数组
- *
- * @param item
- * @param entity
- */
-const getDataFromConfig = (item, entity) => {
-  const {
-    dataIndex
-  } = item;
-  if (dataIndex) {
-    const data = Array.isArray(dataIndex) ? get(entity, dataIndex) : entity[dataIndex];
-    if (data !== undefined || data !== null) {
-      return data;
-    }
-  }
-  return item.children;
-};
-
-/**
- * 这里会处理编辑的功能
- *
- * @param props
- */
-export const FieldRender = props => {
-  const {
-    valueEnum,
-    action,
-    index,
-    text,
-    entity,
-    mode,
-    render,
-    editableUtils,
-    valueType,
-    plain,
-    dataIndex,
-    request,
-    formItemRender,
-    params,
-    emptyText
-  } = props;
-  const form = ProForm.useFormInstance();
-  const {
-    token
-  } = proTheme.useToken?.();
-  const fieldConfig = {
-    text,
-    valueEnum,
-    mode: mode || 'read',
-    proFieldProps: {
-      emptyText,
-      render: render ? finText => {
-        return render?.(finText, entity, index, action, {
-          ...props,
-          type: 'descriptions'
-        });
-      } : undefined
-    },
-    ignoreFormItem: true,
-    valueType,
-    request,
-    params,
-    plain
-  };
-
-  /** 如果是只读模式，fieldProps 的 form是空的，所以需要兜底处理 */
-  if (mode === 'read' || !mode || valueType === 'option') {
-    const fieldProps = getFieldPropsOrFormItemProps(props.fieldProps, undefined, {
-      ...props,
-      rowKey: dataIndex,
-      isEditable: false
-    });
-    return /*#__PURE__*/_jsx(ProFormField, {
-      name: dataIndex,
-      ...fieldConfig,
-      fieldProps: fieldProps
-    });
-  }
-  const renderDom = () => {
-    const formItemProps = getFieldPropsOrFormItemProps(props.formItemProps, form, {
-      ...props,
-      rowKey: dataIndex,
-      isEditable: true
-    });
-    const fieldProps = getFieldPropsOrFormItemProps(props.fieldProps, form, {
-      ...props,
-      rowKey: dataIndex,
-      isEditable: true
-    });
-    return /*#__PURE__*/_jsxs("div", {
-      style: {
-        display: 'flex',
-        gap: token.marginXS,
-        alignItems: 'baseline'
-      },
-      children: [/*#__PURE__*/_jsx(InlineErrorFormItem, {
-        name: dataIndex,
-        ...formItemProps,
-        style: {
-          margin: 0,
-          ...(formItemProps?.style || {})
-        },
-        initialValue: text || formItemProps?.initialValue,
-        children: /*#__PURE__*/_jsx(ProFormField, {
-          ...fieldConfig,
-          proFieldProps: {
-            ...fieldConfig.proFieldProps
-          },
-          formItemRender: formItemRender ? () => formItemRender?.({
-            ...props,
-            type: 'descriptions'
-          }, {
-            isEditable: true,
-            recordKey: dataIndex,
-            record: form.getFieldValue([dataIndex].flat(1)),
-            defaultRender: () => /*#__PURE__*/_jsx(ProFormField, {
-              ...fieldConfig,
-              fieldProps: fieldProps
-            }),
-            type: 'descriptions'
-          }, form) : undefined,
-          fieldProps: fieldProps
-        })
-      }), /*#__PURE__*/_jsx("div", {
-        style: {
-          display: 'flex',
-          maxHeight: token.controlHeight,
-          alignItems: 'center',
-          gap: token.marginXS
-        },
-        children: editableUtils?.actionRender?.(dataIndex || index, {
-          cancelText: /*#__PURE__*/_jsx(CloseOutlined, {}),
-          saveText: /*#__PURE__*/_jsx(CheckOutlined, {}),
-          deleteText: false
-        })
-      })]
-    });
-  };
-  return /*#__PURE__*/_jsx("div", {
-    style: {
-      marginTop: -5,
-      marginBottom: -5,
-      marginLeft: 0,
-      marginRight: 0,
-      width: '100%'
-    },
-    children: renderDom()
-  });
-};
-const schemaToDescriptionsItem = (items, entity, action, editableUtils, emptyText) => {
-  const options = [];
-  // 因为 Descriptions 只是个语法糖，children 是不会执行的，所以需要这里处理一下
-  const children = items?.map?.((item, index) => {
-    if ( /*#__PURE__*/React.isValidElement(item)) {
-      return {
-        children: item
-      };
-    }
-    const {
-      valueEnum: _valueEnum,
-      render: _render,
-      renderText,
-      mode,
-      plain: _plain,
-      dataIndex,
-      request: _request,
-      params: _params,
-      editable,
-      ...restItem
-    } = item;
-    const defaultData = getDataFromConfig(item, entity) ?? restItem.children;
-    const text = renderText ? renderText(defaultData, entity, index, action) : defaultData;
-    const title = typeof restItem.title === 'function' ? restItem.title(item, 'descriptions', null) : restItem.title;
-
-    //  dataIndex 无所谓是否存在
-    // 有些时候不需要 dataIndex 可以直接 render
-    const valueType = typeof restItem.valueType === 'function' ? restItem.valueType(entity || {}, 'descriptions') : restItem.valueType;
-    const isEditable = editableUtils?.isEditable(dataIndex || index);
-    const fieldMode = mode || isEditable ? 'edit' : 'read';
-    const showEditIcon = editableUtils && fieldMode === 'read' && editable !== false && editable?.(text, entity, index) !== false;
-    const Component = showEditIcon ? Space : React.Fragment;
-    const contentDom = fieldMode === 'edit' ? text : genCopyable(text, item, text, defaultData);
-    const key = restItem.key || restItem.label?.toString() || index;
-    const label = (title || restItem.label || restItem.tooltip) && /*#__PURE__*/_jsx(LabelIconTip, {
-      label: title || restItem.label,
-      tooltip: restItem.tooltip,
-      ellipsis: item.ellipsis
-    });
-    const field = valueType !== 'option' ? {
-      ...restItem,
-      key,
-      label,
-      children: /*#__PURE__*/_jsxs(Component, {
-        children: [/*#__PURE__*/_createElement(FieldRender, {
-          ...item,
-          key: item?.key,
-          dataIndex: item.dataIndex || index,
-          mode: fieldMode,
-          text: contentDom,
-          valueType: valueType,
-          entity: entity,
-          index: index,
-          emptyText: emptyText,
-          action: action,
-          editableUtils: editableUtils
-        }), showEditIcon && /*#__PURE__*/_jsx(EditOutlined, {
-          onClick: () => {
-            editableUtils?.startEditable(dataIndex || index);
-          }
-        })]
-      })
-    } : /*#__PURE__*/_createElement(Descriptions.Item, {
-      ...restItem,
-      key: key,
-      label: label
-    }, /*#__PURE__*/_jsxs(Component, {
-      children: [/*#__PURE__*/_jsx(FieldRender, {
-        ...item,
-        dataIndex: item.dataIndex || index,
-        mode: fieldMode,
-        text: contentDom,
-        valueType: valueType,
-        entity: entity,
-        index: index,
-        action: action,
-        editableUtils: editableUtils
-      }), showEditIcon && valueType !== 'option' && /*#__PURE__*/_jsx(EditOutlined, {
-        onClick: () => {
-          editableUtils?.startEditable(dataIndex || index);
-        }
-      })]
-    }));
-    // 如果类型是 option 自动放到右上角
-    if (valueType === 'option') {
-      options.push(field);
-      return null;
-    }
-    return field;
-  }).filter(item => item);
-  return {
-    // 空数组传递还是会被判定为有值
-    options: options?.length ? options : null,
-    children
-  };
-};
-const ProDescriptionsItem = props => {
-  return /*#__PURE__*/_jsx(Descriptions.Item, {
-    ...props,
-    children: props.children
-  });
-};
-ProDescriptionsItem.displayName = 'ProDescriptionsItem';
-const DefaultProDescriptionsDom = dom => dom.children;
-const ProDescriptions = props => {
-  const {
-    request,
-    columns,
-    params,
-    dataSource,
-    onDataSourceChange,
-    formProps,
-    editable,
-    loading,
-    onLoadingChange,
-    actionRef,
-    onRequestError,
-    emptyText: _emptyText,
-    ...rest
-  } = props;
-  const proContext = useContext(ProConfigContext);
-  const context = useContext(ConfigProvider.ConfigContext);
-  const action = useFetchData(async () => {
-    const data = request ? await request(params || {}) : {
-      data: {}
-    };
-    return data;
-  }, {
-    onRequestError,
-    effects: [stringify(params)],
-    manual: !request,
-    dataSource,
-    loading,
-    onLoadingChange,
-    onDataSourceChange
-  });
-
-  /*
-   * 可编辑行的相关配置
-   */
-  const editableUtils = useEditableMap({
-    ...props.editable,
-    childrenColumnName: undefined,
-    dataSource: action.dataSource,
-    setDataSource: action.setDataSource
-  });
-
-  /** 支持 reload 的功能 */
-  useEffect(() => {
-    if (actionRef) {
-      actionRef.current = {
-        reload: action.reload,
-        ...editableUtils
-      };
-    }
-  }, [action, actionRef, editableUtils]);
-
-  // loading 时展示
-  // loading =  undefined 但是 request 存在时也应该展示
-  if (action.loading || action.loading === undefined && request) {
-    return /*#__PURE__*/_jsx(ProSkeleton, {
-      type: "descriptions",
-      list: false,
-      pageHeader: false
-    });
-  }
-  const getColumns = () => {
-    // 因为 Descriptions 只是个语法糖，children 是不会执行的，所以需要这里处理一下
-    const childrenColumns = toArray(props.children).filter(Boolean).map(item => {
-      if (! /*#__PURE__*/React.isValidElement(item)) {
-        return item;
-      }
-      const {
-        valueEnum,
-        valueType,
-        dataIndex,
-        ellipsis,
-        copyable,
-        request: itemRequest
-      } = item?.props;
-      if (!valueType && !valueEnum && !dataIndex && !itemRequest && !ellipsis && !copyable && item.type?.displayName !== 'ProDescriptionsItem') {
-        return item;
-      }
-      return {
-        ...item?.props,
-        entity: dataSource
-      };
-    });
-    return [...(columns || []), ...childrenColumns].filter(item => {
-      if (!item) return false;
-      if (item?.valueType && ['index', 'indexBorder'].includes(item?.valueType)) {
-        return false;
-      }
-      return !item?.hideInDescriptions;
-    }).sort((a, b) => {
-      if (b.order || a.order) {
-        return (b.order || 0) - (a.order || 0);
-      }
-      return (b.index || 0) - (a.index || 0);
-    });
-  };
-  const {
-    options,
-    children
-  } = schemaToDescriptionsItem(getColumns(), action.dataSource || {}, actionRef?.current || action, editable ? editableUtils : undefined, props.emptyText);
-
-  /** 如果不是可编辑模式，没必要注入 ProForm */
-  const FormComponent = editable ? ProForm : DefaultProDescriptionsDom;
-
-  /** 即使组件返回null了, 在传递的过程中还是会被Description检测到为有值 */
-  let title = null;
-  if (rest.title || rest.tooltip) {
-    title = /*#__PURE__*/_jsx(LabelIconTip, {
-      label: rest.title,
-      tooltip: rest.tooltip
-    });
-  }
-  const className = context.getPrefixCls('pro-descriptions');
-  return /*#__PURE__*/_jsx(ErrorBoundary, {
-    children: /*#__PURE__*/_jsx(ProConfigProvider, {
-      valueTypeMap: {
-        ...proContext.valueTypeMap,
-        ...ValueTypeToComponent
-      },
-      children: /*#__PURE__*/_jsx(FormComponent, {
-        form: props.editable?.form,
-        component: false,
-        submitter: false,
-        ...formProps,
-        onFinish: undefined,
-        children: /*#__PURE__*/_jsx(Descriptions, {
-          className: className,
-          ...rest,
-          styles: {
-            content: {
-              minWidth: 0
-            }
-          },
-          extra: rest.extra ? /*#__PURE__*/_jsxs(Space, {
-            children: [options, rest.extra]
-          }) : options,
-          title: title,
-          items: children
-        })
-      }, "form")
-    })
-  });
-};
-ProDescriptions.Item = ProDescriptionsItem;
-export { ProDescriptions };
-export default ProDescriptions;
+export { FieldRender } from "./FieldRender";
+export { ProDescriptions } from "./ProDescriptions";
+export { default } from "./ProDescriptions";
+export { PRO_FIELD_SCHEMA_LAYOUT_VALUE_TYPES } from "./typing";

package/es/descriptions/resolveValueType.d.ts

@@ -0,0 +1,6 @@
+import type { ProFieldValueTypeInput } from '../utils/typing';
+import type { ProDescriptionsColumn } from './typing';
+/**
+ * 解析列上 `valueType`（支持函数形式），供 Descriptions 渲染路径使用
+ */
+export declare function resolveDescriptionsValueType(item: ProDescriptionsColumn, entity: Record<string, unknown>): ProFieldValueTypeInput;

package/es/descriptions/resolveValueType.js

@@ -0,0 +1,9 @@
+/**
+ * 解析列上 `valueType`（支持函数形式），供 Descriptions 渲染路径使用
+ */
+export function resolveDescriptionsValueType(item, entity) {
+  const {
+    valueType
+  } = item;
+  return typeof valueType === 'function' ? valueType(entity || {}, 'descriptions') : valueType;
+}

package/es/descriptions/schemaToDescriptionsItem.d.ts

@@ -0,0 +1,8 @@
+import type { DescriptionsItemType } from 'antd/es/descriptions';
+import React from 'react';
+import type { ProCoreActionType, UseEditableMapUtilType } from '../utils';
+import type { ProDescriptionsColumn } from './typing';
+export declare function schemaToDescriptionsItem(items: ProDescriptionsColumn<any, any>[], entity: Record<string, unknown> | undefined, action: ProCoreActionType<any>, editableUtils?: UseEditableMapUtilType, emptyText?: React.ReactNode): {
+    options: React.JSX.Element[] | null;
+    children: (React.JSX.Element | DescriptionsItemType | null)[];
+};

package/es/descriptions/schemaToDescriptionsItem.js

@@ -0,0 +1,90 @@
+import { EditOutlined } from '@ant-design/icons';
+import { Space } from 'antd';
+import React from 'react';
+import { LabelIconTip, genCopyable } from "../utils";
+import { FieldRender } from "./FieldRender";
+import { getDataFromConfig } from "./getDataFromConfig";
+import { resolveDescriptionsValueType } from "./resolveValueType";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createElement as _createElement } from "react";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+export function schemaToDescriptionsItem(items, entity, action, editableUtils, emptyText) {
+  const options = [];
+  const children = items?.map?.((item, index) => {
+    const row = entity ?? {};
+    const {
+      valueEnum: _valueEnum,
+      render: _render,
+      renderText,
+      mode,
+      plain: _plain,
+      dataIndex,
+      request: _request,
+      params: _params,
+      editable,
+      ...restItem
+    } = item;
+    const defaultData = getDataFromConfig(item, entity) ?? restItem.children;
+    const text = renderText ? renderText(defaultData, row, index, action) : defaultData;
+    const title = typeof restItem.title === 'function' ? restItem.title(item, 'descriptions', null) : restItem.title;
+    const valueType = resolveDescriptionsValueType(item, row);
+    const isEditable = editableUtils?.isEditable(dataIndex || index);
+    const fieldMode = mode != null ? mode : isEditable ? 'edit' : 'read';
+    const showEditIcon = editableUtils && fieldMode === 'read' && editable !== false && editable?.(text, row, index) !== false;
+    const Component = showEditIcon ? Space : React.Fragment;
+    const contentDom = fieldMode === 'edit' ? text : genCopyable(text, item, text, defaultData);
+    const key = restItem.key || restItem.label?.toString() || index;
+    const label = (title || restItem.label || restItem.tooltip) && /*#__PURE__*/_jsx(LabelIconTip, {
+      label: title || restItem.label,
+      tooltip: restItem.tooltip,
+      ellipsis: item.ellipsis
+    });
+    const field = valueType !== 'option' ? {
+      ...restItem,
+      key,
+      label,
+      children: /*#__PURE__*/_jsxs(Component, {
+        children: [/*#__PURE__*/_createElement(FieldRender, {
+          ...item,
+          key: item?.key,
+          dataIndex: item.dataIndex || index,
+          mode: fieldMode,
+          text: contentDom,
+          valueType: valueType,
+          entity: row,
+          index: index,
+          emptyText: emptyText,
+          action: action,
+          editableUtils: editableUtils
+        }), showEditIcon && /*#__PURE__*/_jsx(EditOutlined, {
+          onClick: () => {
+            editableUtils?.startEditable(dataIndex || index);
+          }
+        })]
+      })
+    } : /*#__PURE__*/_jsx(React.Fragment, {
+      children: /*#__PURE__*/_jsx(Component, {
+        children: /*#__PURE__*/_jsx(FieldRender, {
+          ...item,
+          dataIndex: item.dataIndex || index,
+          mode: fieldMode,
+          text: contentDom,
+          valueType: valueType,
+          entity: row,
+          index: index,
+          action: action,
+          editableUtils: editableUtils
+        })
+      })
+    }, key);
+    if (valueType === 'option') {
+      options.push(field);
+      return null;
+    }
+    return field;
+  }).filter(item => item);
+  return {
+    options: options?.length ? options : null,
+    children
+  };
+}

package/es/descriptions/typing.d.ts

@@ -0,0 +1,70 @@
+import type { DescriptionsProps, FormProps } from 'antd';
+import type { DescriptionsItemProps as AntdDescriptionsCellProps } from 'antd/es/descriptions/Item';
+import type React from 'react';
+import type { ProFieldFCMode } from '../provider';
+import type { LabelTooltipType, ProCoreActionType, ProEllipsis, ProSchema, ProSchemaComponentTypes, RowEditableConfig, UseEditableMapUtilType } from '../utils';
+import type { ProDescriptionsRequestResult } from './useFetchData';
+/** antd Descriptions 单元格 props，与 `antd/es/descriptions/Item` 对齐 */
+export type DescriptionsItemProps = AntdDescriptionsCellProps;
+type ProDescriptionsCellLayout = Omit<AntdDescriptionsCellProps, 'children' | 'label'> & {
+    label?: React.ReactNode;
+    children?: React.ReactNode;
+};
+/**
+ * 描述列表单列配置（`columns` 数组元素）
+ */
+export type ProDescriptionsColumn<TRecord = Record<string, unknown>, TValueType = 'text'> = ProSchema<TRecord, ProDescriptionsCellLayout & {
+    hide?: boolean;
+    plain?: boolean;
+    copyable?: boolean;
+    ellipsis?: ProEllipsis;
+    mode?: ProFieldFCMode;
+    order?: number;
+    index?: number;
+}, ProSchemaComponentTypes, TValueType>;
+/**
+ * @deprecated 使用 {@link ProDescriptionsColumn}
+ */
+export type ProDescriptionsItemProps<T = Record<string, unknown>, ValueType = 'text'> = ProDescriptionsColumn<T, ValueType>;
+/**
+ * ProDescriptions actionRef 暴露的方法集合。
+ *
+ * 与 ProTable 不同，descriptions 是单条记录场景，编辑能力来自 useEditableMap
+ * （Map 编辑工具方法），而非 useEditableArray（Array 编辑）。
+ * 因此用 ProCoreActionType 的第二个泛型显式注入 Map 编辑工具类型，
+ * 保证 actionRef.current 上挂载的是 startEditable / cancelEditable / isEditable 等
+ * Map 编辑相关方法，而非 Array 编辑的 addEditRecord / saveEditable 等不存在的方法。
+ *
+ * 用 Partial 包裹是因为非 editable 模式下这些方法不会被挂载。
+ */
+export type ProDescriptionsActionType<TRecord extends Record<string, any> = Record<string, any>> = ProCoreActionType<{}, Partial<UseEditableMapUtilType>> & {
+    /** 当前 description 持有的数据源（单条记录） */
+    dataSource: TRecord | undefined;
+    /** 更新数据源的方法 */
+    setDataSource: (value: TRecord | undefined) => void;
+};
+export type ProDescriptionsProps<TRecord extends Record<string, any> = Record<string, any>, TValueType = 'text'> = Omit<DescriptionsProps, 'children' | 'items'> & {
+    params?: Record<string, unknown>;
+    onRequestError?: (e: Error) => void;
+    request?: (params: Record<string, unknown> | undefined) => Promise<ProDescriptionsRequestResult<TRecord>>;
+    columns?: ProDescriptionsColumn<TRecord, TValueType>[];
+    /**
+     * actionRef 接受 ProDescriptionsActionType（推荐，含 Map 编辑方法）
+     * 或 ProCoreActionType（向后兼容，仅基础 action）。
+     * 使用时建议显式声明为 `ProDescriptionsActionType<TRecord>` 以拿到完整类型提示。
+     */
+    actionRef?: React.MutableRefObject<ProDescriptionsActionType<any> | ProCoreActionType<any> | undefined>;
+    loading?: boolean;
+    onLoadingChange?: (loading?: boolean) => void;
+    tooltip?: LabelTooltipType | string;
+    formProps?: FormProps;
+    editable?: RowEditableConfig<TRecord>;
+    dataSource?: TRecord;
+    onDataSourceChange?: (value: TRecord | undefined) => void;
+    emptyText?: React.ReactNode;
+};
+/**
+ * 与 `src/utils/typing`、`src/field` 对齐的 valueType 符号。
+ */
+export type { ProFieldBuiltinValueType, ProFieldSchemaLayoutValueType, ProFieldValueObjectType, ProFieldValueType, ProFieldValueTypeInput, } from '../utils/typing';
+export { PRO_FIELD_SCHEMA_LAYOUT_VALUE_TYPES } from '../utils/typing';

package/es/descriptions/typing.js

@@ -0,0 +1,27 @@
+/** antd Descriptions 单元格 props，与 `antd/es/descriptions/Item` 对齐 */
+
+/**
+ * 描述列表单列配置（`columns` 数组元素）
+ */
+
+/**
+ * @deprecated 使用 {@link ProDescriptionsColumn}
+ */
+
+/**
+ * ProDescriptions actionRef 暴露的方法集合。
+ *
+ * 与 ProTable 不同，descriptions 是单条记录场景，编辑能力来自 useEditableMap
+ * （Map 编辑工具方法），而非 useEditableArray（Array 编辑）。
+ * 因此用 ProCoreActionType 的第二个泛型显式注入 Map 编辑工具类型，
+ * 保证 actionRef.current 上挂载的是 startEditable / cancelEditable / isEditable 等
+ * Map 编辑相关方法，而非 Array 编辑的 addEditRecord / saveEditable 等不存在的方法。
+ *
+ * 用 Partial 包裹是因为非 editable 模式下这些方法不会被挂载。
+ */
+
+/**
+ * 与 `src/utils/typing`、`src/field` 对齐的 valueType 符号。
+ */
+
+export { PRO_FIELD_SCHEMA_LAYOUT_VALUE_TYPES } from "../utils/typing";

package/es/descriptions/useFetchData.d.ts

@@ -1,22 +1,23 @@
-export type RequestData<T = any> = {
+export type ProDescriptionsRequestResult<T = unknown> = {
     data?: T;
     success?: boolean;
-    [key: string]: any;
-} & Record<string, any>;
-export type UseFetchDataAction<T extends RequestData> = {
-    dataSource: T['data'] | T;
-    setDataSource: (value: T['data'] | T) => void;
+};
+/** @deprecated 使用 {@link ProDescriptionsRequestResult} */
+export type RequestData<T = unknown> = ProDescriptionsRequestResult<T>;
+export type UseProDescriptionsFetchAction<TData> = {
+    dataSource: TData | undefined;
+    setDataSource: (value: TData | undefined) => void;
     loading?: boolean;
     reload: () => Promise<void>;
 };
-declare const useFetchData: <T extends RequestData<any>>(getData: () => Promise<T>, options?: {
-    effects?: any[] | undefined;
+declare const useFetchData: <TData, TResponse extends ProDescriptionsRequestResult<TData>>(getData: () => Promise<TResponse>, options?: {
+    effects?: unknown[] | undefined;
     manual: boolean;
     loading?: boolean | undefined;
     onLoadingChange?: ((loading?: boolean) => void) | undefined;
     onRequestError?: ((e: Error) => void) | undefined;
-    dataSource?: T["data"] | undefined;
-    defaultDataSource?: T["data"] | undefined;
-    onDataSourceChange?: ((value: T['data']) => void) | undefined;
-} | undefined) => UseFetchDataAction<T>;
+    dataSource?: TData | undefined;
+    defaultDataSource?: TData | undefined;
+    onDataSourceChange?: ((value: TData | undefined) => void) | undefined;
+} | undefined) => UseProDescriptionsFetchAction<TData>;
 export default useFetchData;