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

package/lib/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/lib/descriptions/typing.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "PRO_FIELD_SCHEMA_LAYOUT_VALUE_TYPES", {
+  enumerable: true,
+  get: function () {
+    return _typing.PRO_FIELD_SCHEMA_LAYOUT_VALUE_TYPES;
+  }
+});
+var _typing = require("../utils/typing");

package/lib/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;

package/lib/descriptions/useFetchData.js

@@ -7,6 +7,8 @@ exports.default = void 0;
 var _util = require("@rc-component/util");
 var _react = require("react");
 var _utils = require("../utils");
+/** @deprecated 使用 {@link ProDescriptionsRequestResult} */
+
 const useFetchData = (getData, options) => {
   const {
     onRequestError,
@@ -50,41 +52,48 @@ const useFetchData = (getData, options) => {
     setEntity(data);
     setLoading(false);
   };
-  /** 请求数据 */
-  const fetchList = async () => {
-    if (loading) {
+  const getDataRef = (0, _react.useRef)(getData);
+  getDataRef.current = getData;
+  const fetchingRef = (0, _react.useRef)(false);
+
+  /** 请求数据（稳定引用，始终读取最新的 getData） */
+  const fetchList = (0, _utils.useRefFunction)(async () => {
+    if (fetchingRef.current) {
       return;
     }
+    fetchingRef.current = true;
     setLoading(true);
     try {
       const {
         data,
         success
-      } = (await getData()) || {};
+      } = (await getDataRef.current()) || {};
       if (success !== false) {
         updateDataAndLoading(data);
       }
     } catch (e) {
       // 如果没有传递这个方法的话，需要把错误抛出去，以免吞掉错误
-      if (onRequestError === undefined) throw new Error(e);else onRequestError(e);
+      if (onRequestError === undefined) {
+        throw e instanceof Error ? e : new Error(String(e));
+      }
+      onRequestError(e instanceof Error ? e : new Error(String(e)));
       setLoading(false);
     } finally {
+      fetchingRef.current = false;
       setLoading(false);
     }
-  };
+  });
   (0, _react.useEffect)(() => {
     if (manual) {
       return;
     }
     fetchList();
-  }, [...(effects || []), manual]);
-  return {
+  }, [...(effects || []), manual, fetchList]);
+  return (0, _react.useMemo)(() => ({
     dataSource: entity,
     setDataSource: setEntity,
     loading,
-    reload: () => {
-      return fetchList();
-    }
-  };
+    reload: fetchList
+  }), [entity, setEntity, loading, fetchList]);
 };
 var _default = exports.default = useFetchData;

package/lib/field/AllProField.d.ts

@@ -1,35 +1,9 @@
 import React from 'react';
-import type { BaseProFieldFC, ProFieldFCRenderProps, ProRenderFieldPropsType } from '../provider';
-import { ProFieldRequestData, ProFieldTextType, ProFieldValueObjectType, ProFieldValueType } from '../utils';
-import { ProFieldPropsType } from './PureProField';
-/** 默认的 Field 需要实现的功能 */
-export type ProFieldFC<T = {}> = React.ForwardRefRenderFunction<any, BaseProFieldFC & ProRenderFieldPropsType & T>;
-/** 轻量筛选的field属性 */
-export type ProFieldLightProps = {
-    lightLabel?: React.RefObject<{
-        labelRef: React.RefObject<HTMLElement>;
-        clearRef: React.RefObject<HTMLElement>;
-    }>;
-    labelTrigger?: boolean;
-};
-/** Value type by function */
-export type ProFieldValueTypeFunction<T> = (item: T) => ProFieldValueType | ProFieldValueObjectType;
-type RenderProps = Omit<ProFieldFCRenderProps, 'text' | 'placeholder'> & ProRenderFieldPropsType & {
-    /** 从服务器读取选项 */
-    request?: ProFieldRequestData;
-    emptyText?: React.ReactNode;
-    open?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    [key: string]: any;
-};
-/**
- * 根据不同的类型来转化数值
- *
- * @param dataValue
- * @param valueType
- * @param props
- * @param valueTypeMap
- */
-export declare const defaultRenderText: (dataValue: ProFieldTextType, valueType: ProFieldValueType | ProFieldValueObjectType, props: RenderProps, valueTypeMap: Record<string, ProRenderFieldPropsType>) => React.ReactNode;
-export declare const ProField: React.ForwardRefRenderFunction<any, ProFieldPropsType>;
-export {};
+import { type ProFieldRenderText } from './ProFieldCore';
+/** 只读：空值占位、context valueTypeMap 的 render、内置 valueType */
+export declare const defaultRenderRead: ProFieldRenderText;
+/** 编辑：context valueTypeMap 的 formItemRender、内置 valueType */
+export declare const defaultRenderEdit: ProFieldRenderText;
+/** 按 mode 调度（直接调用 defaultRenderText 时与旧行为一致） */
+export declare const defaultRenderText: ProFieldRenderText;
+export declare const ProField: React.ForwardRefRenderFunction<any, import("./types").ProFieldPropsType>;