@ant-design/pro-components 2.8.10 → 3.0.0-beta.1

package/es/form/components/Radio/index.js

@@ -0,0 +1,93 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/form/components/Radio/index.tsx
+import { Radio } from "antd";
+import React from "react";
+import { runFunction } from "../../../utils";
+import ProField from "../Field";
+import warpField from "../FormItem/warpField";
+var RadioGroup = React.forwardRef(
+  (_a2, ref) => {
+    var _b = _a2, {
+      fieldProps,
+      options,
+      radioType,
+      layout,
+      proFieldProps,
+      valueEnum
+    } = _b, rest = __objRest(_b, [
+      "fieldProps",
+      "options",
+      "radioType",
+      "layout",
+      "proFieldProps",
+      "valueEnum"
+    ]);
+    return /* @__PURE__ */ React.createElement(
+      ProField,
+      __spreadProps(__spreadValues({
+        valueType: radioType === "button" ? "radioButton" : "radio",
+        ref,
+        valueEnum: runFunction(valueEnum, void 0)
+      }, rest), {
+        fieldProps: __spreadValues({
+          options,
+          layout
+        }, fieldProps),
+        proFieldProps,
+        filedConfig: {
+          customLightMode: true
+        }
+      })
+    );
+  }
+);
+var ProFormRadioComponents = React.forwardRef(({ fieldProps, children }, ref) => {
+  return /* @__PURE__ */ React.createElement(Radio, __spreadProps(__spreadValues({}, fieldProps), { ref }), children);
+});
+var _a;
+var ProFormRadio = (_a = warpField) == null ? void 0 : _a(
+  ProFormRadioComponents,
+  {
+    valuePropName: "checked",
+    ignoreWidth: true
+  }
+);
+var WrappedProFormRadio = ProFormRadio;
+WrappedProFormRadio.Group = RadioGroup;
+WrappedProFormRadio.Button = Radio.Button;
+WrappedProFormRadio.displayName = "ProFormComponent";
+var Radio_default = WrappedProFormRadio;
+export {
+  Radio_default as default
+};

package/es/form/components/Rate/index.d.ts

@@ -0,0 +1,15 @@
+import type { RateProps } from 'antd';
+import React from 'react';
+declare const _default: React.ForwardRefExoticComponent<{
+    fieldProps?: Partial<import("../../typing").FieldProps<any> & RateProps> | undefined;
+    placeholder?: string | string[] | undefined;
+    secondary?: boolean | undefined;
+    emptyText?: React.ReactNode;
+    cacheForSwr?: boolean | undefined;
+    disabled?: boolean | undefined;
+    width?: number | "xl" | "lg" | "md" | "sm" | "xs" | undefined;
+    proFieldProps?: import("src/utils").ProFieldProps | undefined;
+    footerRender?: import("../../typing").LightFilterFooterRender | undefined;
+    children?: any;
+} & Omit<import("src/form/components").ProFormItemProps, "valueType"> & Pick<import("../../typing").ProFormGridConfig, "colProps"> & import("../../typing").ExtendsProps & React.RefAttributes<any>>;
+export default _default;

package/es/form/components/Rate/index.js

@@ -0,0 +1,67 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/form/components/Rate/index.tsx
+import React from "react";
+import { FieldRate } from "../../../field";
+import { ProConfigProvider } from "../../../provider";
+import ProField from "../Field";
+var ProFormRate = (_a, ref) => {
+  var _b = _a, { fieldProps, proFieldProps } = _b, rest = __objRest(_b, ["fieldProps", "proFieldProps"]);
+  return /* @__PURE__ */ React.createElement(
+    ProConfigProvider,
+    {
+      valueTypeMap: {
+        rate: {
+          render: (text, props) => /* @__PURE__ */ React.createElement(FieldRate, __spreadProps(__spreadValues({}, props), { text })),
+          formItemRender: (text, props) => /* @__PURE__ */ React.createElement(FieldRate, __spreadProps(__spreadValues({}, props), { text }))
+        }
+      }
+    },
+    /* @__PURE__ */ React.createElement(
+      ProField,
+      __spreadValues({
+        valueType: "rate",
+        fieldProps,
+        ref,
+        proFieldProps,
+        filedConfig: {
+          ignoreWidth: true
+        }
+      }, rest)
+    )
+  );
+};
+var Rate_default = React.forwardRef(ProFormRate);
+export {
+  Rate_default as default
+};

package/es/form/components/SchemaForm/index.d.ts

@@ -0,0 +1,9 @@
+import type { FormSchema } from './typing';
+export * from './typing';
+/**
+ * 此组件可以根据 Json Schema 来生成相应的表单,大部分配置与 antd 的 table 列配置相同
+ *
+ * @see 此组件仍为 beta 版本，api 可能发生变化
+ */
+declare function BetaSchemaForm<T, ValueType = 'text'>(props: FormSchema<T, ValueType>): import("react/jsx-runtime").JSX.Element;
+export default BetaSchemaForm;

package/es/form/components/SchemaForm/index.js

@@ -0,0 +1,230 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/form/components/SchemaForm/index.tsx
+import { Form } from "antd";
+import React, {
+  useCallback,
+  useContext,
+  useImperativeHandle,
+  useRef,
+  useState
+} from "react";
+import ValueTypeToComponent from "../../../field/ValueTypeToComponent";
+import ProConfigContext, { ProConfigProvider } from "../../../provider";
+import {
+  LabelIconTip,
+  omitUndefined,
+  runFunction,
+  stringify,
+  useDeepCompareMemo,
+  useLatest,
+  useReactiveRef,
+  useRefFunction
+} from "../../../utils";
+import { DrawerForm } from "../../layouts/DrawerForm";
+import { LightFilter } from "../../layouts/LightFilter";
+import { ModalForm } from "../../layouts/ModalForm";
+import { ProForm } from "../../layouts/ProForm";
+import { QueryFilter } from "../../layouts/QueryFilter";
+import { StepsForm as ProStepsForm } from "../../layouts/StepsForm";
+import { Embed, StepsForm } from "./layoutType";
+import { renderValueType } from "./valueType";
+export * from "./typing";
+var FormLayoutType = {
+  DrawerForm,
+  QueryFilter,
+  LightFilter,
+  StepForm: ProStepsForm.StepForm,
+  StepsForm,
+  ModalForm,
+  Embed,
+  Form: ProForm
+};
+function BetaSchemaForm(props) {
+  const _a = props, {
+    columns,
+    layoutType = "Form",
+    type = "form",
+    action,
+    shouldUpdate = (pre, next) => stringify(pre) !== stringify(next),
+    formRef: propsFormRef
+  } = _a, restProps = __objRest(_a, [
+    "columns",
+    "layoutType",
+    "type",
+    "action",
+    "shouldUpdate",
+    "formRef"
+  ]);
+  const FormRenderComponents = FormLayoutType[layoutType] || ProForm;
+  const [form] = Form.useForm();
+  const formInstance = Form.useFormInstance();
+  const [, forceUpdate] = useState([]);
+  const [formDomsDeps, updatedFormDoms] = useState(() => []);
+  const formRef = useReactiveRef(
+    props.form || formInstance || form
+  );
+  const oldValuesRef = useRef();
+  const propsRef = useLatest(props);
+  const genItems = useRefFunction((items) => {
+    return items.filter((originItem) => {
+      return !(originItem.hideInForm && type === "form");
+    }).sort((a, b) => {
+      if (b.order || a.order) {
+        return (b.order || 0) - (a.order || 0);
+      }
+      return (b.index || 0) - (a.index || 0);
+    }).map((originItem, index) => {
+      const title = runFunction(
+        originItem.title,
+        originItem,
+        "form",
+        /* @__PURE__ */ React.createElement(
+          LabelIconTip,
+          {
+            label: originItem.title,
+            tooltip: originItem.tooltip
+          }
+        )
+      );
+      const item = omitUndefined({
+        title,
+        label: title,
+        name: originItem.name,
+        valueType: runFunction(originItem.valueType, {}),
+        key: originItem.key || originItem.dataIndex || index,
+        columns: originItem.columns,
+        valueEnum: originItem.valueEnum,
+        dataIndex: originItem.dataIndex || originItem.key,
+        initialValue: originItem.initialValue,
+        width: originItem.width,
+        index: originItem.index,
+        readonly: originItem.readonly,
+        colSize: originItem.colSize,
+        colProps: originItem.colProps,
+        rowProps: originItem.rowProps,
+        className: originItem.className,
+        tooltip: originItem.tooltip,
+        dependencies: originItem.dependencies,
+        proFieldProps: originItem.proFieldProps,
+        ignoreFormItem: originItem.ignoreFormItem,
+        getFieldProps: originItem.fieldProps ? () => runFunction(
+          originItem.fieldProps,
+          formRef.current,
+          originItem
+        ) : void 0,
+        getFormItemProps: originItem.formItemProps ? () => runFunction(
+          originItem.formItemProps,
+          formRef.current,
+          originItem
+        ) : void 0,
+        render: originItem.render,
+        formItemRender: originItem.formItemRender,
+        renderText: originItem.renderText,
+        request: originItem.request,
+        params: originItem.params,
+        transform: originItem.transform,
+        convertValue: originItem.convertValue,
+        debounceTime: originItem.debounceTime,
+        defaultKeyWords: originItem.defaultKeyWords
+      });
+      return renderValueType(item, {
+        action,
+        type,
+        originItem,
+        formRef,
+        genItems
+      });
+    }).filter((field) => {
+      return Boolean(field);
+    });
+  });
+  const onValuesChange = useCallback(
+    (changedValues, values) => {
+      const { onValuesChange: propsOnValuesChange } = propsRef.current;
+      if (shouldUpdate === true || typeof shouldUpdate === "function" && shouldUpdate(values, oldValuesRef.current)) {
+        updatedFormDoms([]);
+      }
+      oldValuesRef.current = values;
+      propsOnValuesChange == null ? void 0 : propsOnValuesChange(changedValues, values);
+    },
+    [propsRef, shouldUpdate]
+  );
+  const formChildrenDoms = useDeepCompareMemo(() => {
+    if (!formRef.current)
+      return;
+    if (columns.length && Array.isArray(columns[0]))
+      return;
+    return genItems(columns);
+  }, [columns, restProps == null ? void 0 : restProps.open, action, type, formDomsDeps]);
+  const specificProps = useDeepCompareMemo(() => {
+    if (layoutType === "StepsForm") {
+      return {
+        forceUpdate,
+        columns
+      };
+    }
+    return {};
+  }, [columns, layoutType]);
+  useImperativeHandle(propsFormRef, () => {
+    return formRef.current;
+  }, [formRef.current]);
+  const context = useContext(ProConfigContext);
+  return /* @__PURE__ */ React.createElement(
+    ProConfigProvider,
+    {
+      valueTypeMap: __spreadValues(__spreadValues({}, context.valueTypeMap), ValueTypeToComponent)
+    },
+    /* @__PURE__ */ React.createElement(
+      FormRenderComponents,
+      __spreadProps(__spreadValues(__spreadValues({}, specificProps), restProps), {
+        onInit: (_, initForm) => {
+          var _a2;
+          if (propsFormRef) {
+            propsFormRef.current = initForm;
+          }
+          (_a2 = restProps == null ? void 0 : restProps.onInit) == null ? void 0 : _a2.call(restProps, _, initForm);
+          formRef.current = initForm;
+        },
+        form: props.form || form,
+        formRef,
+        onValuesChange
+      }),
+      formChildrenDoms
+    )
+  );
+}
+var SchemaForm_default = BetaSchemaForm;
+export {
+  SchemaForm_default as default
+};

package/es/form/components/SchemaForm/layoutType/Embed.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+declare const Embed: React.FC<{
+    children: any;
+}>;
+export default Embed;

package/es/form/components/SchemaForm/layoutType/Embed.js

@@ -0,0 +1,6 @@
+// src/form/components/SchemaForm/layoutType/Embed.tsx
+var Embed = ({ children }) => /* @__PURE__ */ React.createElement(React.Fragment, null, children);
+var Embed_default = Embed;
+export {
+  Embed_default as default
+};

package/es/form/components/SchemaForm/layoutType/StepsForm.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { ProFormGridConfig } from '../../../typing';
+import type { FormSchema, ProFormPropsType } from '../typing';
+type StepsFormProps<T, ValueType> = ProFormPropsType<T, ValueType> & Pick<FormSchema, 'steps'> & {
+    layoutType: 'StepsForm';
+    forceUpdate: React.Dispatch<React.SetStateAction<[]>>;
+} & Pick<ProFormGridConfig, 'grid'>;
+declare const StepsForm: <T, ValueType>({ steps, columns, forceUpdate, grid, ...props }: StepsFormProps<T, ValueType>) => import("react/jsx-runtime").JSX.Element;
+export default StepsForm;

package/es/form/components/SchemaForm/layoutType/StepsForm.js

@@ -0,0 +1,76 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/form/components/SchemaForm/layoutType/StepsForm.tsx
+import React, { useCallback, useMemo } from "react";
+import { useLatest } from "../../../../utils";
+import { StepsForm as ProStepsForm } from "../../../layouts/StepsForm";
+import BetaSchemaForm from "../index";
+var StepsForm = (_a) => {
+  var _b = _a, {
+    steps,
+    columns,
+    forceUpdate,
+    grid
+  } = _b, props = __objRest(_b, [
+    "steps",
+    "columns",
+    "forceUpdate",
+    "grid"
+  ]);
+  const propsRef = useLatest(props);
+  const onCurrentChange = useCallback(
+    (current) => {
+      var _a2, _b2;
+      (_b2 = (_a2 = propsRef.current).onCurrentChange) == null ? void 0 : _b2.call(_a2, current);
+      forceUpdate([]);
+    },
+    [forceUpdate, propsRef]
+  );
+  const StepDoms = useMemo(() => {
+    return steps == null ? void 0 : steps.map((step, index) => /* @__PURE__ */ React.createElement(
+      BetaSchemaForm,
+      __spreadProps(__spreadValues({
+        grid
+      }, step), {
+        key: index,
+        layoutType: "StepForm",
+        columns: columns[index]
+      })
+    ));
+  }, [columns, grid, steps]);
+  return /* @__PURE__ */ React.createElement(ProStepsForm, __spreadProps(__spreadValues({}, props), { onCurrentChange }), StepDoms);
+};
+var StepsForm_default = StepsForm;
+export {
+  StepsForm_default as default
+};

package/es/form/components/SchemaForm/layoutType/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Embed } from './Embed';
+export { default as StepsForm } from './StepsForm';

package/es/form/components/SchemaForm/layoutType/index.js

@@ -0,0 +1,7 @@
+// src/form/components/SchemaForm/layoutType/index.ts
+import { default as default2 } from "./Embed";
+import { default as default3 } from "./StepsForm";
+export {
+  default2 as Embed,
+  default3 as StepsForm
+};

package/es/form/components/SchemaForm/typing.d.ts

@@ -0,0 +1,125 @@
+/// <reference types="react" />
+import type { FormInstance, FormProps } from 'antd';
+import type { NamePath } from 'antd/lib/form/interface';
+import type { ProCoreActionType, ProSchema, ProSchemaComponentTypes, SearchConvertKeyFn, SearchTransformKeyFn } from '../../../utils';
+import type { CommonFormProps } from '../../BaseForm';
+import type { DrawerFormProps, LightFilterProps, ModalFormProps, ProFormProps, QueryFilterProps, StepFormProps, StepsFormProps } from '../../layouts';
+import type { ProFormGridConfig } from '../../typing';
+export type ExtraProColumnType = {
+    tooltip?: React.ReactNode;
+    key?: React.Key;
+    className?: string;
+    /**
+     * @type auto 使用组件默认的宽度
+     * @type xs=104px 适用于短数字、短文本或选项。
+     * @type sm=216px 适用于较短字段录入、如姓名、电话、ID 等。
+     * @type md=328px 标准宽度，适用于大部分字段长度。
+     * @type lg=440px 适用于较长字段录入，如长网址、标签组、文件路径等。
+     * @type xl=552px 适用于长文本录入，如长链接、描述、备注等，通常搭配自适应多行输入框或定高文本域使用。
+     */
+    width?: string | number;
+    name?: NamePath | NamePath[];
+    defaultKeyWords?: string;
+} & Pick<ProFormGridConfig, 'rowProps' | 'colProps'>;
+/**
+ * ProForm 支持的相关类型
+ */
+export type ProFormPropsType<T, ValueType = 'text'> = ((({
+    layoutType?: 'Form';
+} & ProFormProps<T>) | ({
+    layoutType: 'DrawerForm';
+} & DrawerFormProps<T>) | ({
+    layoutType: 'ModalForm';
+} & ModalFormProps<T>) | ({
+    layoutType: 'QueryFilter';
+} & QueryFilterProps<T>) | ({
+    layoutType: 'LightFilter';
+} & LightFilterProps<T>) | ({
+    layoutType: 'StepForm';
+} & StepFormProps<T>) | {
+    layoutType: 'Embed';
+}) & {
+    columns: ProFormColumnsType<T, ValueType>[];
+}) | ({
+    layoutType: 'StepsForm';
+    columns: ProFormColumnsType<T, ValueType>[][];
+} & StepsFormProps<T>);
+/** ProForm 的特色 layout */
+export type ProFormLayoutType = ProFormPropsType<any>['layoutType'];
+export type FormFieldType = 'group' | 'formList' | 'formSet' | 'divider' | 'dependency';
+export type ProFormColumnsType<T = any, ValueType = 'text'> = ProSchema<T, ExtraProColumnType & {
+    index?: number;
+    /**
+     * 每个表单占据的格子大小
+     *
+     * @param 总宽度 = span* colSize
+     * @param 默认为 1
+     */
+    colSize?: number;
+    /** 是否只读模式 */
+    readonly?: boolean;
+    /** 搜索表单的默认值 */
+    initialValue?: any;
+    /**
+     * @name 获取时转化值，一般用于将数据格式化为组件接收的格式
+     * @param value 字段的值
+     * @param namePath 字段的name
+     * @returns 字段新的值
+     *
+     *
+     * @example a,b => [a,b]     convertValue: (value,namePath)=> value.split(",")
+     * @example string => json   convertValue: (value,namePath)=> JSON.parse(value)
+     * @example number => date   convertValue: (value,namePath)=> Dayjs(value)
+     * @example YYYY-MM-DD => date   convertValue: (value,namePath)=> Dayjs(value,"YYYY-MM-DD")
+     * @example  string => object   convertValue: (value,namePath)=> { return {value,label:value} }
+     */
+    convertValue?: SearchConvertKeyFn;
+    /**
+     * @name 提交时转化值，一般用于将值转化为提交的数据
+     * @param value 字段的值
+     * @param namePath 字段的name
+     * @param allValues 所有的字段
+     * @returns 字段新的值，如果返回对象，会和所有值 merge 一次
+     *
+     * @example {name:[a,b] => {name:a,b }    transform: (value,namePath,allValues)=> value.join(",")
+     * @example {name: string => { newName:string }    transform: (value,namePath,allValues)=> { newName:value }
+     * @example {name:dayjs} => {name:string transform: (value,namePath,allValues)=> value.format("YYYY-MM-DD")
+     * @example {name:dayjs}=> {name:时间戳} transform: (value,namePath,allValues)=> value.valueOf()
+     * @example {name:{value,label}} => { name:string} transform: (value,namePath,allValues)=> value.value
+     * @example {name:{value,label}} => { valueName,labelName  } transform: (value,namePath,allValues)=> { valueName:value.value, labelName:value.name }
+     */
+    transform?: SearchTransformKeyFn;
+    /** Form 的排序 */
+    order?: number;
+    /** 嵌套子项 */
+    columns?: ProFormColumnsType<T, ValueType | FormFieldType>[] | ((values: any) => ProFormColumnsType<T, ValueType | FormFieldType>[]);
+}, ProSchemaComponentTypes, ValueType | FormFieldType>;
+export type FormSchema<T = Record<string, any>, ValueType = 'text'> = {
+    title?: React.ReactNode | ((schema: ProFormColumnsType<T, ValueType>, type: 'form', dom: React.ReactNode) => React.ReactNode);
+    description?: React.ReactNode;
+    steps?: StepFormProps[];
+    type?: any;
+    action?: React.MutableRefObject<ProCoreActionType | undefined>;
+    /**
+     * @default true
+     * Fine-grained control over when to update
+     */
+    shouldUpdate?: boolean | ((newValues: T, oldValues?: T) => boolean);
+} & Omit<FormProps<T>, 'onFinish'> & ProFormPropsType<T, ValueType> & CommonFormProps<T> & {
+    open?: boolean;
+};
+export type ProFormRenderValueTypeItem<T, ValueType> = {
+    label: any;
+    getFieldProps?: () => any;
+    getFormItemProps?: () => any;
+} & ProFormColumnsType<T, ValueType>;
+export type ProFormRenderValueTypeHelpers<T, ValueType> = {
+    originItem: ProFormColumnsType<T, ValueType>;
+    type: ProSchemaComponentTypes;
+    formRef: React.MutableRefObject<FormInstance<any> | undefined>;
+    genItems: (items: ProFormColumnsType<T, ValueType>[]) => React.ReactNode[];
+} & Pick<FormSchema<T, ValueType>, 'action'>;
+export type ItemType<T, ValueType> = Omit<ProFormRenderValueTypeItem<T, ValueType>, 'key'> & {
+    key?: React.Key | React.Key[];
+};
+export type ProSchemaRenderValueTypeFunction<T = any, ValueType = any> = (item: ItemType<T, ValueType>, helpers: ProFormRenderValueTypeHelpers<T, ValueType>) => React.ReactNode;

package/es/form/components/SchemaForm/valueType/dependency.d.ts

@@ -0,0 +1,2 @@
+import type { ItemType, ProFormRenderValueTypeHelpers } from '../typing';
+export declare const dependency: <DataType, ValueType>(item: ItemType<DataType, ValueType>, helpers: ProFormRenderValueTypeHelpers<DataType, ValueType>) => true | import("react/jsx-runtime").JSX.Element | null;