@nocobase/plugin-client 0.11.1-alpha.5 → 0.12.0-alpha.2

package/dist/locale/antd/form/FormItem/index.js

@@ -0,0 +1,265 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _rcFieldForm = require("rc-field-form");
+var _useState = _interopRequireDefault(require("rc-util/lib/hooks/useState"));
+var _ref2 = require("rc-util/lib/ref");
+var React = _interopRequireWildcard(require("react"));
+var _reactNode = require("../../_util/reactNode");
+var _warning = _interopRequireDefault(require("../../_util/warning"));
+var _configProvider = require("../../config-provider");
+var _context = require("../context");
+var _useFormItemStatus = _interopRequireDefault(require("../hooks/useFormItemStatus"));
+var _useFrameState = _interopRequireDefault(require("../hooks/useFrameState"));
+var _useItemRef = _interopRequireDefault(require("../hooks/useItemRef"));
+var _util = require("../util");
+var _ItemHolder = _interopRequireDefault(require("./ItemHolder"));
+var _useChildren = _interopRequireDefault(require("../hooks/useChildren"));
+var _style = _interopRequireDefault(require("../style"));
+const NAME_SPLIT = '__SPLIT__';
+const ValidateStatuses = ['success', 'warning', 'error', 'validating', ''];
+const MemoInput = /*#__PURE__*/React.memo(_ref => {
+  let {
+    children
+  } = _ref;
+  return children;
+}, (prev, next) => prev.value === next.value && prev.update === next.update && prev.childProps.length === next.childProps.length && prev.childProps.every((value, index) => value === next.childProps[index]));
+function hasValidName(name) {
+  if (name === null) {
+    process.env.NODE_ENV !== "production" ? (0, _warning.default)(false, 'Form.Item', '`null` is passed as `name` property') : void 0;
+  }
+  return !(name === undefined || name === null);
+}
+function genEmptyMeta() {
+  return {
+    errors: [],
+    warnings: [],
+    touched: false,
+    validating: false,
+    name: [],
+    validated: false
+  };
+}
+function InternalFormItem(props) {
+  const {
+    name,
+    noStyle,
+    className,
+    dependencies,
+    prefixCls: customizePrefixCls,
+    shouldUpdate,
+    rules,
+    children,
+    required,
+    label,
+    messageVariables,
+    trigger = 'onChange',
+    validateTrigger,
+    hidden,
+    help
+  } = props;
+  const {
+    getPrefixCls
+  } = React.useContext(_configProvider.ConfigContext);
+  const {
+    name: formName
+  } = React.useContext(_context.FormContext);
+  const mergedChildren = (0, _useChildren.default)(children);
+  const isRenderProps = typeof mergedChildren === 'function';
+  const notifyParentMetaChange = React.useContext(_context.NoStyleItemContext);
+  const {
+    validateTrigger: contextValidateTrigger
+  } = React.useContext(_rcFieldForm.FieldContext);
+  const mergedValidateTrigger = validateTrigger !== undefined ? validateTrigger : contextValidateTrigger;
+  const hasName = hasValidName(name);
+  const prefixCls = getPrefixCls('form', customizePrefixCls);
+  // Style
+  const [wrapSSR, hashId] = (0, _style.default)(prefixCls);
+  // ========================= MISC =========================
+  // Get `noStyle` required info
+  const listContext = React.useContext(_rcFieldForm.ListContext);
+  const fieldKeyPathRef = React.useRef();
+  // ======================== Errors ========================
+  // >>>>> Collect sub field errors
+  const [subFieldErrors, setSubFieldErrors] = (0, _useFrameState.default)({});
+  // >>>>> Current field errors
+  const [meta, setMeta] = (0, _useState.default)(() => genEmptyMeta());
+  const onMetaChange = nextMeta => {
+    // This keyInfo is not correct when field is removed
+    // Since origin keyManager no longer keep the origin key anymore
+    // Which means we need cache origin one and reuse when removed
+    const keyInfo = listContext === null || listContext === void 0 ? void 0 : listContext.getKey(nextMeta.name);
+    // Destroy will reset all the meta
+    setMeta(nextMeta.destroy ? genEmptyMeta() : nextMeta, true);
+    // Bump to parent since noStyle
+    if (noStyle && help !== false && notifyParentMetaChange) {
+      let namePath = nextMeta.name;
+      if (!nextMeta.destroy) {
+        if (keyInfo !== undefined) {
+          const [fieldKey, restPath] = keyInfo;
+          namePath = [fieldKey].concat((0, _toConsumableArray2.default)(restPath));
+          fieldKeyPathRef.current = namePath;
+        }
+      } else {
+        // Use origin cache data
+        namePath = fieldKeyPathRef.current || namePath;
+      }
+      notifyParentMetaChange(nextMeta, namePath);
+    }
+  };
+  // >>>>> Collect noStyle Field error to the top FormItem
+  const onSubItemMetaChange = (subMeta, uniqueKeys) => {
+    // Only `noStyle` sub item will trigger
+    setSubFieldErrors(prevSubFieldErrors => {
+      const clone = Object.assign({}, prevSubFieldErrors);
+      // name: ['user', 1] + key: [4] = ['user', 4]
+      const mergedNamePath = [].concat((0, _toConsumableArray2.default)(subMeta.name.slice(0, -1)), (0, _toConsumableArray2.default)(uniqueKeys));
+      const mergedNameKey = mergedNamePath.join(NAME_SPLIT);
+      if (subMeta.destroy) {
+        // Remove
+        delete clone[mergedNameKey];
+      } else {
+        // Update
+        clone[mergedNameKey] = subMeta;
+      }
+      return clone;
+    });
+  };
+  // >>>>> Get merged errors
+  const [mergedErrors, mergedWarnings] = React.useMemo(() => {
+    const errorList = (0, _toConsumableArray2.default)(meta.errors);
+    const warningList = (0, _toConsumableArray2.default)(meta.warnings);
+    Object.values(subFieldErrors).forEach(subFieldError => {
+      errorList.push.apply(errorList, (0, _toConsumableArray2.default)(subFieldError.errors || []));
+      warningList.push.apply(warningList, (0, _toConsumableArray2.default)(subFieldError.warnings || []));
+    });
+    return [errorList, warningList];
+  }, [subFieldErrors, meta.errors, meta.warnings]);
+  // ===================== Children Ref =====================
+  const getItemRef = (0, _useItemRef.default)();
+  // ======================== Render ========================
+  function renderLayout(baseChildren, fieldId, isRequired) {
+    if (noStyle && !hidden) {
+      return baseChildren;
+    }
+    return /*#__PURE__*/React.createElement(_ItemHolder.default, Object.assign({
+      key: "row"
+    }, props, {
+      className: (0, _classnames.default)(className, hashId),
+      prefixCls: prefixCls,
+      fieldId: fieldId,
+      isRequired: isRequired,
+      errors: mergedErrors,
+      warnings: mergedWarnings,
+      meta: meta,
+      onSubItemMetaChange: onSubItemMetaChange
+    }), baseChildren);
+  }
+  if (!hasName && !isRenderProps && !dependencies) {
+    return wrapSSR(renderLayout(mergedChildren));
+  }
+  let variables = {};
+  if (typeof label === 'string') {
+    variables.label = label;
+  } else if (name) {
+    variables.label = String(name);
+  }
+  if (messageVariables) {
+    variables = Object.assign(Object.assign({}, variables), messageVariables);
+  }
+  // >>>>> With Field
+  return wrapSSR( /*#__PURE__*/React.createElement(_rcFieldForm.Field, Object.assign({}, props, {
+    messageVariables: variables,
+    trigger: trigger,
+    validateTrigger: mergedValidateTrigger,
+    onMetaChange: onMetaChange
+  }), (control, renderMeta, context) => {
+    const mergedName = (0, _util.toArray)(name).length && renderMeta ? renderMeta.name : [];
+    const fieldId = (0, _util.getFieldId)(mergedName, formName);
+    const isRequired = required !== undefined ? required : !!(rules && rules.some(rule => {
+      if (rule && typeof rule === 'object' && rule.required && !rule.warningOnly) {
+        return true;
+      }
+      if (typeof rule === 'function') {
+        const ruleEntity = rule(context);
+        return ruleEntity && ruleEntity.required && !ruleEntity.warningOnly;
+      }
+      return false;
+    }));
+    // ======================= Children =======================
+    const mergedControl = Object.assign({}, control);
+    let childNode = null;
+    process.env.NODE_ENV !== "production" ? (0, _warning.default)(!(shouldUpdate && dependencies), 'Form.Item', "`shouldUpdate` and `dependencies` shouldn't be used together. See https://u.ant.design/form-deps.") : void 0;
+    if (Array.isArray(mergedChildren) && hasName) {
+      process.env.NODE_ENV !== "production" ? (0, _warning.default)(false, 'Form.Item', 'A `Form.Item` with a `name` prop must have a single child element. For information on how to render more complex form items, see https://u.ant.design/complex-form-item.') : void 0;
+      childNode = mergedChildren;
+    } else if (isRenderProps && (!(shouldUpdate || dependencies) || hasName)) {
+      process.env.NODE_ENV !== "production" ? (0, _warning.default)(!!(shouldUpdate || dependencies), 'Form.Item', 'A `Form.Item` with a render function must have either `shouldUpdate` or `dependencies`.') : void 0;
+      process.env.NODE_ENV !== "production" ? (0, _warning.default)(!hasName, 'Form.Item', 'A `Form.Item` with a render function cannot be a field, and thus cannot have a `name` prop.') : void 0;
+    } else if (dependencies && !isRenderProps && !hasName) {
+      process.env.NODE_ENV !== "production" ? (0, _warning.default)(false, 'Form.Item', 'Must set `name` or use a render function when `dependencies` is set.') : void 0;
+    } else if ((0, _reactNode.isValidElement)(mergedChildren)) {
+      process.env.NODE_ENV !== "production" ? (0, _warning.default)(mergedChildren.props.defaultValue === undefined, 'Form.Item', '`defaultValue` will not work on controlled Field. You should use `initialValues` of Form instead.') : void 0;
+      const childProps = Object.assign(Object.assign({}, mergedChildren.props), mergedControl);
+      if (!childProps.id) {
+        childProps.id = fieldId;
+      }
+      if (help || mergedErrors.length > 0 || mergedWarnings.length > 0 || props.extra) {
+        const describedbyArr = [];
+        if (help || mergedErrors.length > 0) {
+          describedbyArr.push(`${fieldId}_help`);
+        }
+        if (props.extra) {
+          describedbyArr.push(`${fieldId}_extra`);
+        }
+        childProps['aria-describedby'] = describedbyArr.join(' ');
+      }
+      if (mergedErrors.length > 0) {
+        childProps['aria-invalid'] = 'true';
+      }
+      if (isRequired) {
+        childProps['aria-required'] = 'true';
+      }
+      if ((0, _ref2.supportRef)(mergedChildren)) {
+        childProps.ref = getItemRef(mergedName, mergedChildren);
+      }
+      // We should keep user origin event handler
+      const triggers = new Set([].concat((0, _toConsumableArray2.default)((0, _util.toArray)(trigger)), (0, _toConsumableArray2.default)((0, _util.toArray)(mergedValidateTrigger))));
+      triggers.forEach(eventName => {
+        childProps[eventName] = function () {
+          var _a2, _c2;
+          var _a, _b, _c;
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+          (_a = mergedControl[eventName]) === null || _a === void 0 ? void 0 : (_a2 = _a).call.apply(_a2, [mergedControl].concat(args));
+          (_c = (_b = mergedChildren.props)[eventName]) === null || _c === void 0 ? void 0 : (_c2 = _c).call.apply(_c2, [_b].concat(args));
+        };
+      });
+      // List of props that need to be watched for changes -> if changes are detected in MemoInput -> rerender
+      const watchingChildProps = [childProps['aria-required'], childProps['aria-invalid'], childProps['aria-describedby']];
+      childNode = /*#__PURE__*/React.createElement(MemoInput, {
+        value: mergedControl[props.valuePropName || 'value'],
+        update: mergedChildren,
+        childProps: watchingChildProps
+      }, (0, _reactNode.cloneElement)(mergedChildren, childProps));
+    } else if (isRenderProps && (shouldUpdate || dependencies) && !hasName) {
+      childNode = mergedChildren(context);
+    } else {
+      process.env.NODE_ENV !== "production" ? (0, _warning.default)(!mergedName.length, 'Form.Item', '`name` is only used for validate React element. If you are using Form.Item as layout display, please remove `name` instead.') : void 0;
+      childNode = mergedChildren;
+    }
+    return renderLayout(childNode, fieldId, isRequired);
+  }));
+}
+const FormItem = InternalFormItem;
+FormItem.useStatus = _useFormItemStatus.default;
+var _default = FormItem;
+exports.default = _default;

package/dist/locale/antd/form/FormItemInput.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import type { ColProps } from '../grid/col';
+import type { ValidateStatus } from './FormItem';
+interface FormItemInputMiscProps {
+    prefixCls: string;
+    children: React.ReactNode;
+    errors: React.ReactNode[];
+    warnings: React.ReactNode[];
+    marginBottom?: number | null;
+    onErrorVisibleChanged?: (visible: boolean) => void;
+}
+export interface FormItemInputProps {
+    wrapperCol?: ColProps;
+    extra?: React.ReactNode;
+    status?: ValidateStatus;
+    help?: React.ReactNode;
+    fieldId?: string;
+}
+declare const FormItemInput: React.FC<FormItemInputProps & FormItemInputMiscProps>;
+export default FormItemInput;

package/dist/locale/antd/form/FormItemInput.js

@@ -0,0 +1,88 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _classnames = _interopRequireDefault(require("classnames"));
+var React = _interopRequireWildcard(require("react"));
+var _col = _interopRequireDefault(require("../grid/col"));
+var _context = require("./context");
+var _ErrorList = _interopRequireDefault(require("./ErrorList"));
+const FormItemInput = props => {
+  const {
+    prefixCls,
+    status,
+    wrapperCol,
+    children,
+    errors,
+    warnings,
+    _internalItemRender: formItemRender,
+    extra,
+    help,
+    fieldId,
+    marginBottom,
+    onErrorVisibleChanged
+  } = props;
+  const baseClassName = `${prefixCls}-item`;
+  const formContext = React.useContext(_context.FormContext);
+  const mergedWrapperCol = wrapperCol || formContext.wrapperCol || {};
+  const className = (0, _classnames.default)(`${baseClassName}-control`, mergedWrapperCol.className);
+  // Pass to sub FormItem should not with col info
+  const subFormContext = React.useMemo(() => Object.assign({}, formContext), [formContext]);
+  delete subFormContext.labelCol;
+  delete subFormContext.wrapperCol;
+  const inputDom = /*#__PURE__*/React.createElement("div", {
+    className: `${baseClassName}-control-input`
+  }, /*#__PURE__*/React.createElement("div", {
+    className: `${baseClassName}-control-input-content`
+  }, children));
+  const formItemContext = React.useMemo(() => ({
+    prefixCls,
+    status
+  }), [prefixCls, status]);
+  const errorListDom = marginBottom !== null || errors.length || warnings.length ? /*#__PURE__*/React.createElement("div", {
+    style: {
+      display: 'flex',
+      flexWrap: 'nowrap'
+    }
+  }, /*#__PURE__*/React.createElement(_context.FormItemPrefixContext.Provider, {
+    value: formItemContext
+  }, /*#__PURE__*/React.createElement(_ErrorList.default, {
+    fieldId: fieldId,
+    errors: errors,
+    warnings: warnings,
+    help: help,
+    helpStatus: status,
+    className: `${baseClassName}-explain-connected`,
+    onVisibleChanged: onErrorVisibleChanged
+  })), !!marginBottom && /*#__PURE__*/React.createElement("div", {
+    style: {
+      width: 0,
+      height: marginBottom
+    }
+  })) : null;
+  const extraProps = {};
+  if (fieldId) {
+    extraProps.id = `${fieldId}_extra`;
+  }
+  // If extra = 0, && will goes wrong
+  // 0&&error -> 0
+  const extraDom = extra ? /*#__PURE__*/React.createElement("div", Object.assign({}, extraProps, {
+    className: `${baseClassName}-extra`
+  }), extra) : null;
+  const dom = formItemRender && formItemRender.mark === 'pro_table_render' && formItemRender.render ? formItemRender.render(props, {
+    input: inputDom,
+    errorList: errorListDom,
+    extra: extraDom
+  }) : /*#__PURE__*/React.createElement(React.Fragment, null, inputDom, errorListDom, extraDom);
+  return /*#__PURE__*/React.createElement(_context.FormContext.Provider, {
+    value: subFormContext
+  }, /*#__PURE__*/React.createElement(_col.default, Object.assign({}, mergedWrapperCol, {
+    className: className
+  }), dom));
+};
+var _default = FormItemInput;
+exports.default = _default;

package/dist/locale/antd/form/FormItemLabel.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import type { ColProps } from '../grid/col';
+import type { TooltipProps } from '../tooltip';
+import type { FormLabelAlign } from './interface';
+export type WrapperTooltipProps = TooltipProps & {
+    icon?: React.ReactElement;
+};
+export type LabelTooltipType = WrapperTooltipProps | React.ReactNode;
+export interface FormItemLabelProps {
+    colon?: boolean;
+    htmlFor?: string;
+    label?: React.ReactNode;
+    labelAlign?: FormLabelAlign;
+    labelCol?: ColProps;
+    tooltip?: LabelTooltipType;
+}
+declare const FormItemLabel: React.FC<FormItemLabelProps & {
+    required?: boolean;
+    prefixCls: string;
+}>;
+export default FormItemLabel;

package/dist/locale/antd/form/FormItemLabel.js

@@ -0,0 +1,107 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _QuestionCircleOutlined = _interopRequireDefault(require("@ant-design/icons/QuestionCircleOutlined"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var React = _interopRequireWildcard(require("react"));
+var _col = _interopRequireDefault(require("../grid/col"));
+var _en_US = _interopRequireDefault(require("../locale/en_US"));
+var _locale = require("../locale");
+var _tooltip = _interopRequireDefault(require("../tooltip"));
+var _context = require("./context");
+var __rest = void 0 && (void 0).__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;
+};
+function toTooltipProps(tooltip) {
+  if (!tooltip) {
+    return null;
+  }
+  if (typeof tooltip === 'object' && ! /*#__PURE__*/React.isValidElement(tooltip)) {
+    return tooltip;
+  }
+  return {
+    title: tooltip
+  };
+}
+const FormItemLabel = _ref => {
+  let {
+    prefixCls,
+    label,
+    htmlFor,
+    labelCol,
+    labelAlign,
+    colon,
+    required,
+    requiredMark,
+    tooltip
+  } = _ref;
+  var _a;
+  const [formLocale] = (0, _locale.useLocale)('Form');
+  const {
+    vertical,
+    labelAlign: contextLabelAlign,
+    labelCol: contextLabelCol,
+    labelWrap,
+    colon: contextColon
+  } = React.useContext(_context.FormContext);
+  if (!label) {
+    return null;
+  }
+  const mergedLabelCol = labelCol || contextLabelCol || {};
+  const mergedLabelAlign = labelAlign || contextLabelAlign;
+  const labelClsBasic = `${prefixCls}-item-label`;
+  const labelColClassName = (0, _classnames.default)(labelClsBasic, mergedLabelAlign === 'left' && `${labelClsBasic}-left`, mergedLabelCol.className, {
+    [`${labelClsBasic}-wrap`]: !!labelWrap
+  });
+  let labelChildren = label;
+  // Keep label is original where there should have no colon
+  const computedColon = colon === true || contextColon !== false && colon !== false;
+  const haveColon = computedColon && !vertical;
+  // Remove duplicated user input colon
+  if (haveColon && typeof label === 'string' && label.trim() !== '') {
+    labelChildren = label.replace(/[:|：]\s*$/, '');
+  }
+  // Tooltip
+  const tooltipProps = toTooltipProps(tooltip);
+  if (tooltipProps) {
+    const {
+        icon = /*#__PURE__*/React.createElement(_QuestionCircleOutlined.default, null)
+      } = tooltipProps,
+      restTooltipProps = __rest(tooltipProps, ["icon"]);
+    const tooltipNode = /*#__PURE__*/React.createElement(_tooltip.default, Object.assign({}, restTooltipProps), /*#__PURE__*/React.cloneElement(icon, {
+      className: `${prefixCls}-item-tooltip`,
+      title: ''
+    }));
+    labelChildren = /*#__PURE__*/React.createElement(React.Fragment, null, labelChildren, tooltipNode);
+  }
+  if (requiredMark === 'optional' && !required) {
+    labelChildren = /*#__PURE__*/React.createElement(React.Fragment, null, labelChildren, /*#__PURE__*/React.createElement("span", {
+      className: `${prefixCls}-item-optional`,
+      title: ""
+    }, (formLocale === null || formLocale === void 0 ? void 0 : formLocale.optional) || ((_a = _en_US.default.Form) === null || _a === void 0 ? void 0 : _a.optional)));
+  }
+  const labelClassName = (0, _classnames.default)({
+    [`${prefixCls}-item-required`]: required,
+    [`${prefixCls}-item-required-mark-optional`]: requiredMark === 'optional',
+    [`${prefixCls}-item-no-colon`]: !computedColon
+  });
+  return /*#__PURE__*/React.createElement(_col.default, Object.assign({}, mergedLabelCol, {
+    className: labelColClassName
+  }), /*#__PURE__*/React.createElement("label", {
+    htmlFor: htmlFor,
+    className: labelClassName,
+    title: typeof label === 'string' ? label : ''
+  }, labelChildren));
+};
+var _default = FormItemLabel;
+exports.default = _default;

package/dist/locale/antd/form/FormList.d.ts

@@ -0,0 +1,25 @@
+import type { StoreValue, ValidatorRule } from 'rc-field-form/lib/interface';
+import * as React from 'react';
+export interface FormListFieldData {
+    name: number;
+    key: number;
+    /** @deprecated No need anymore Use key instead */
+    fieldKey?: number;
+}
+export interface FormListOperation {
+    add: (defaultValue?: StoreValue, insertIndex?: number) => void;
+    remove: (index: number | number[]) => void;
+    move: (from: number, to: number) => void;
+}
+export interface FormListProps {
+    prefixCls?: string;
+    name: string | number | (string | number)[];
+    rules?: ValidatorRule[];
+    initialValue?: any[];
+    children: (fields: FormListFieldData[], operation: FormListOperation, meta: {
+        errors: React.ReactNode[];
+        warnings: React.ReactNode[];
+    }) => React.ReactNode;
+}
+declare const FormList: React.FC<FormListProps>;
+export default FormList;

package/dist/locale/antd/form/FormList.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rcFieldForm = require("rc-field-form");
+var React = _interopRequireWildcard(require("react"));
+var _warning = _interopRequireDefault(require("../_util/warning"));
+var _configProvider = require("../config-provider");
+var _context = require("./context");
+var __rest = void 0 && (void 0).__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;
+};
+const FormList = _a => {
+  var {
+      prefixCls: customizePrefixCls,
+      children
+    } = _a,
+    props = __rest(_a, ["prefixCls", "children"]);
+  process.env.NODE_ENV !== "production" ? (0, _warning.default)(typeof props.name === 'number' || (Array.isArray(props.name) ? !!props.name.length : !!props.name), 'Form.List', 'Miss `name` prop.') : void 0;
+  const {
+    getPrefixCls
+  } = React.useContext(_configProvider.ConfigContext);
+  const prefixCls = getPrefixCls('form', customizePrefixCls);
+  const contextValue = React.useMemo(() => ({
+    prefixCls,
+    status: 'error'
+  }), [prefixCls]);
+  return /*#__PURE__*/React.createElement(_rcFieldForm.List, Object.assign({}, props), (fields, operation, meta) => /*#__PURE__*/React.createElement(_context.FormItemPrefixContext.Provider, {
+    value: contextValue
+  }, children(fields.map(field => Object.assign(Object.assign({}, field), {
+    fieldKey: field.key
+  })), operation, {
+    errors: meta.errors,
+    warnings: meta.warnings
+  })));
+};
+var _default = FormList;
+exports.default = _default;

package/dist/locale/antd/form/context.d.ts

@@ -0,0 +1,50 @@
+import type { FormProviderProps as RcFormProviderProps } from 'rc-field-form/lib/FormContext';
+import type { Meta } from 'rc-field-form/lib/interface';
+import type { FC, PropsWithChildren, ReactNode } from 'react';
+import * as React from 'react';
+import type { ColProps } from '../grid/col';
+import type { FormInstance, RequiredMark } from './Form';
+import type { ValidateStatus } from './FormItem';
+import type { FormLabelAlign } from './interface';
+/** Form Context. Set top form style and pass to Form Item usage. */
+export interface FormContextProps {
+    vertical: boolean;
+    name?: string;
+    colon?: boolean;
+    labelAlign?: FormLabelAlign;
+    labelWrap?: boolean;
+    labelCol?: ColProps;
+    wrapperCol?: ColProps;
+    requiredMark?: RequiredMark;
+    itemRef: (name: (string | number)[]) => (node: React.ReactElement) => void;
+    form?: FormInstance;
+}
+export declare const FormContext: React.Context<FormContextProps>;
+/** `noStyle` Form Item Context. Used for error collection */
+export type ReportMetaChange = (meta: Meta, uniqueKeys: React.Key[]) => void;
+export declare const NoStyleItemContext: React.Context<ReportMetaChange | null>;
+/** Form Provider */
+export interface FormProviderProps extends Omit<RcFormProviderProps, 'validateMessages'> {
+    prefixCls?: string;
+}
+export declare const FormProvider: React.FC<FormProviderProps>;
+/** Used for ErrorList only */
+export interface FormItemPrefixContextProps {
+    prefixCls: string;
+    status?: ValidateStatus;
+}
+export declare const FormItemPrefixContext: React.Context<FormItemPrefixContextProps>;
+export interface FormItemStatusContextProps {
+    isFormItemInput?: boolean;
+    status?: ValidateStatus;
+    errors?: React.ReactNode[];
+    warnings?: React.ReactNode[];
+    hasFeedback?: boolean;
+    feedbackIcon?: ReactNode;
+}
+export declare const FormItemInputContext: React.Context<FormItemStatusContextProps>;
+export type NoFormStyleProps = PropsWithChildren<{
+    status?: boolean;
+    override?: boolean;
+}>;
+export declare const NoFormStyle: FC<NoFormStyleProps>;