@uni-sw/u-design 2.0.4

package/es/components/UForm/FormItem/index.js

@@ -0,0 +1,360 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+import { __rest } from "tslib";
+import { Field, FieldContext, ListContext } from 'rc-field-form';
+import useState from 'rc-util/lib/hooks/useState';
+import { supportRef } from 'rc-util/lib/ref';
+import * as React from 'react';
+import { useContext } from 'react';
+import useFormItemStatus from "../hooks/useFormItemStatus";
+import { ConfigContext } from "../../UConfigProvider";
+import { cloneElement, isValidElement } from "../../_util/reactNode";
+import CustomerContext from "../../UConfigProvider/CustomerContext";
+import { tuple } from "../../_util/type";
+import warning from "../../_util/warning";
+import { FormContext, NoStyleItemContext } from "../context";
+import useFrameState from "../hooks/useFrameState";
+import useItemRef from "../hooks/useItemRef";
+import { getFieldId, toArray } from "../util";
+import ItemHolder from "./ItemHolder";
+import getByteLength from "../../UUploadFile/getByteLength";
+var NAME_SPLIT = '__SPLIT__';
+var ValidateStatuses = tuple('success', 'warning', 'error', 'validating', '');
+var MemoInput = /*#__PURE__*/React.memo(function (_ref) {
+  var children = _ref.children;
+  return children;
+}, function (prev, next) {
+  return prev.value === next.value && prev.update === next.update && prev.childProps.length === next.childProps.length && prev.childProps.every(function (value, index) {
+    return value === next.childProps[index];
+  });
+});
+function hasValidName(name) {
+  if (name === null) {
+    warning(false, 'Form.Item', '`null` is passed as `name` property');
+  }
+  return !(name === undefined || name === null);
+}
+function genEmptyMeta() {
+  return {
+    errors: [],
+    warnings: [],
+    touched: false,
+    validating: false,
+    name: []
+  };
+}
+function InternalFormItem(props) {
+  var disabled = props.disabled,
+    otherProps = __rest(props, ["disabled"]);
+  var name = otherProps.name,
+    noStyle = otherProps.noStyle,
+    dependencies = otherProps.dependencies,
+    customizePrefixCls = otherProps.prefixCls,
+    shouldUpdate = otherProps.shouldUpdate,
+    rules = otherProps.rules,
+    children = otherProps.children,
+    required = otherProps.required,
+    label = otherProps.label,
+    messageVariables = otherProps.messageVariables,
+    _otherProps$trigger = otherProps.trigger,
+    trigger = _otherProps$trigger === void 0 ? 'onChange' : _otherProps$trigger,
+    validateTrigger = otherProps.validateTrigger,
+    hidden = otherProps.hidden,
+    hasRule = otherProps.hasRule,
+    onlyShow = otherProps.onlyShow,
+    fields = otherProps.fields;
+  var realHidden = typeof hidden === 'function' ? !!hidden(fields) : !!hidden;
+  var _useContext = useContext(ConfigContext),
+    getPrefixCls = _useContext.getPrefixCls;
+  var _useContext2 = useContext(FormContext),
+    formName = _useContext2.name;
+  var isRenderProps = typeof children === 'function';
+  var notifyParentMetaChange = useContext(NoStyleItemContext);
+  var _useContext3 = useContext(FieldContext),
+    contextValidateTrigger = _useContext3.validateTrigger;
+  var mergedValidateTrigger = validateTrigger !== undefined ? validateTrigger : contextValidateTrigger;
+  // ===================== Customer =====================
+  var customer = React.useContext(CustomerContext) || {};
+  var hasName = hasValidName(name);
+  var prefixCls = getPrefixCls('form', customizePrefixCls);
+  // ========================= MISC =========================
+  // Get `noStyle` required info
+  var listContext = React.useContext(ListContext);
+  var fieldKeyPathRef = React.useRef();
+  // ======================== Errors ========================
+  // >>>>> Collect sub field errors
+  var _useFrameState = useFrameState({}),
+    _useFrameState2 = _slicedToArray(_useFrameState, 2),
+    subFieldErrors = _useFrameState2[0],
+    setSubFieldErrors = _useFrameState2[1];
+  // >>>>> Current field errors
+  var _useState = useState(function () {
+      return genEmptyMeta();
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    meta = _useState2[0],
+    setMeta = _useState2[1];
+  var onMetaChange = function 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
+    var 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 && notifyParentMetaChange) {
+      var namePath = nextMeta.name;
+      if (!nextMeta.destroy) {
+        if (keyInfo !== undefined) {
+          var _keyInfo = _slicedToArray(keyInfo, 2),
+            fieldKey = _keyInfo[0],
+            restPath = _keyInfo[1];
+          namePath = [fieldKey].concat(_toConsumableArray(restPath));
+          fieldKeyPathRef.current = namePath;
+        }
+      } else {
+        // Use origin cache data
+        namePath = fieldKeyPathRef.current || namePath;
+      }
+      notifyParentMetaChange(nextMeta, namePath);
+    }
+  };
+  // >>>>> Collect noStyle Field error to the top FormItem
+  var onSubItemMetaChange = function onSubItemMetaChange(subMeta, uniqueKeys) {
+    // Only `noStyle` sub item will trigger
+    setSubFieldErrors(function (prevSubFieldErrors) {
+      var clone = Object.assign({}, prevSubFieldErrors);
+      // name: ['user', 1] + key: [4] = ['user', 4]
+      var mergedNamePath = [].concat(_toConsumableArray(subMeta.name.slice(0, -1)), _toConsumableArray(uniqueKeys));
+      var mergedNameKey = mergedNamePath.join(NAME_SPLIT);
+      if (subMeta.destroy) {
+        // Remove
+        delete clone[mergedNameKey];
+      } else {
+        // Update
+        clone[mergedNameKey] = subMeta;
+      }
+      return clone;
+    });
+  };
+  // >>>>> Get merged errors
+  var _React$useMemo = React.useMemo(function () {
+      var errorList = _toConsumableArray(meta.errors);
+      var warningList = _toConsumableArray(meta.warnings);
+      Object.values(subFieldErrors).forEach(function (subFieldError) {
+        errorList.push.apply(errorList, _toConsumableArray(subFieldError.errors || []));
+        warningList.push.apply(warningList, _toConsumableArray(subFieldError.warnings || []));
+      });
+      return [errorList, warningList];
+    }, [subFieldErrors, meta.errors, meta.warnings]),
+    _React$useMemo2 = _slicedToArray(_React$useMemo, 2),
+    mergedErrors = _React$useMemo2[0],
+    mergedWarnings = _React$useMemo2[1];
+  // ===================== Children Ref =====================
+  var getItemRef = useItemRef();
+  // ======================== Render ========================
+  function renderLayout(baseChildren, fieldId, isRequired) {
+    if (noStyle && !realHidden) {
+      return baseChildren;
+    }
+    return /*#__PURE__*/React.createElement(ItemHolder, Object.assign({
+      key: "row"
+    }, otherProps, {
+      hidden: realHidden,
+      prefixCls: prefixCls,
+      fieldId: fieldId,
+      isRequired: isRequired,
+      errors: mergedErrors,
+      warnings: mergedWarnings,
+      meta: meta,
+      onSubItemMetaChange: onSubItemMetaChange
+    }), baseChildren);
+  }
+  if (!hasName && !isRenderProps && !dependencies) {
+    return renderLayout(children);
+  }
+  var variables = {};
+  if (typeof label === 'string') {
+    variables.label = label;
+  } else if (name) {
+    variables.label = String(name);
+  }
+  if (messageVariables) {
+    variables = Object.assign(Object.assign({}, variables), messageVariables);
+  }
+  /**
+   * 支持字节校验
+   * @param rules
+   */
+  var _traRules = function _traRules(rules) {
+    if (!(rules instanceof Array)) {
+      return rules;
+    }
+    return rules.map(function (rule) {
+      if (_typeof(rule) === 'object' && rule.byteLength && typeof rule.byteLength === 'number') {
+        return {
+          validator: function validator(_, value) {
+            var result = getByteLength(value) <= rule.byteLength;
+            if (result) {
+              return Promise.resolve();
+            }
+            return Promise.reject(rule.message);
+          }
+        };
+      }
+      return rule;
+    });
+  };
+  var realRules = function realRules() {
+    if (!!realHidden) {
+      return undefined;
+    }
+    if (undefined === hasRule) {
+      return _traRules(rules);
+    }
+    var result = typeof hasRule === 'function' ? !!hasRule(fields) : !!hasRule;
+    if (result) {
+      return _traRules(rules);
+    }
+  };
+  // >>>>> With Field
+  return /*#__PURE__*/React.createElement(Field, Object.assign({}, otherProps, {
+    rules: realRules(),
+    messageVariables: variables,
+    trigger: trigger,
+    validateTrigger: mergedValidateTrigger,
+    onMetaChange: onMetaChange
+  }), function (control, renderMeta, context) {
+    var mergedName = toArray(name).length && renderMeta ? renderMeta.name : [];
+    var fieldId = getFieldId(mergedName, formName);
+    var isRequired = onlyShow || customer.onlyShow ? false : required !== undefined ? required : !!(rules && rules.some(function (rule) {
+      if (rule && _typeof(rule) === 'object' && rule.required && !rule.warningOnly) {
+        return true;
+      }
+      if (typeof rule === 'function') {
+        var ruleEntity = rule(context);
+        return ruleEntity && ruleEntity.required && !ruleEntity.warningOnly;
+      }
+      return false;
+    }));
+    if (undefined !== hasRule) {
+      if (typeof hasRule === 'function') {
+        isRequired = !!hasRule(fields);
+      } else {
+        isRequired = hasRule;
+      }
+    }
+    // ======================= Children =======================
+    var mergedControl = Object.assign({}, control);
+    var childNode = null;
+    warning(!(shouldUpdate && dependencies), 'Form.Item', '`shouldUpdate` and `dependencies` shouldn\'t be used together. See https://u.ant.design/form-deps.');
+    if (Array.isArray(children) && hasName) {
+      warning(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.');
+      childNode = children;
+    } else if (isRenderProps && (!(shouldUpdate || dependencies) || hasName)) {
+      warning(!!(shouldUpdate || dependencies), 'Form.Item', 'A `Form.Item` with a render function must have either `shouldUpdate` or `dependencies`.');
+      warning(!hasName, 'Form.Item', 'A `Form.Item` with a render function cannot be a field, and thus cannot have a `name` prop.');
+    } else if (dependencies && !isRenderProps && !hasName) {
+      warning(false, 'Form.Item', 'Must set `name` or use a render function when `dependencies` is set.');
+    } else if (isValidElement(children)) {
+      warning(children.props.defaultValue === undefined, 'Form.Item', '`defaultValue` will not work on controlled Field. You should use `initialValues` of Form instead.');
+      var realDisabled = undefined;
+      if (children.props.disabled === undefined) {
+        realDisabled = typeof disabled === 'function' ? disabled(fields) : disabled;
+      } else {
+        realDisabled = children.props.disabled;
+      }
+      var childProps = Object.assign(Object.assign(Object.assign({}, children.props), mergedControl), {
+        disabled: realDisabled,
+        onlyShow: undefined === children.props.onlyShow ? onlyShow : children.props.onlyShow
+      });
+      if (!childProps.id) {
+        childProps.id = fieldId;
+      }
+      if (props.help || mergedErrors.length > 0 || mergedWarnings.length > 0 || props.extra) {
+        var describedbyArr = [];
+        if (props.help || mergedErrors.length > 0) {
+          describedbyArr.push("".concat(fieldId, "_help"));
+        }
+        if (props.extra) {
+          describedbyArr.push("".concat(fieldId, "_extra"));
+        }
+        if (props.iconTip) {
+          describedbyArr.push("".concat(fieldId, "_iconTip"));
+        }
+        childProps['aria-describedby'] = describedbyArr.join(' ');
+      }
+      if (mergedErrors.length > 0) {
+        childProps['aria-invalid'] = 'true';
+      }
+      if (isRequired) {
+        childProps['aria-required'] = 'true';
+      }
+      if (supportRef(children)) {
+        childProps.ref = getItemRef(mergedName, children);
+      }
+      // We should keep user origin event handler
+      var triggers = new Set([].concat(_toConsumableArray(toArray(trigger)), _toConsumableArray(toArray(mergedValidateTrigger))));
+      triggers.forEach(function (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 = children.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
+      var watchingChildProps = [childProps['aria-required'], childProps['aria-invalid'], childProps['aria-describedby']];
+      childNode = /*#__PURE__*/React.createElement(MemoInput, {
+        value: mergedControl[props.valuePropName || 'value'],
+        update: children,
+        childProps: watchingChildProps
+      }, cloneElement(children, childProps));
+    } else if (isRenderProps && (shouldUpdate || dependencies) && !hasName) {
+      childNode = children(context);
+    } else {
+      warning(!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.');
+      childNode = children;
+    }
+    return renderLayout(childNode, fieldId, isRequired);
+  });
+}
+function FormItemInstance(props) {
+  var name = props.name,
+    disabled = props.disabled,
+    hidden = props.hidden,
+    hasRule = props.hasRule;
+  if (name && (typeof disabled === 'function' || typeof hidden === 'function' || typeof hasRule === 'function')) {
+    return /*#__PURE__*/React.createElement(InternalFormItem, {
+      noStyle: true,
+      shouldUpdate: true,
+      disabled: disabled
+    }, function (form) {
+      var fields = form.getFieldsValue();
+      var formItem = function formItem(fields) {
+        return /*#__PURE__*/React.createElement(InternalFormItem, Object.assign({}, props, {
+          fields: fields,
+          disabled: disabled
+        }));
+      };
+      return formItem(fields);
+    });
+  } else {
+    return /*#__PURE__*/React.createElement(InternalFormItem, Object.assign({}, props));
+  }
+}
+var FormItem = FormItemInstance;
+FormItem.useStatus = useFormItemStatus;
+export default FormItem;

package/es/components/UForm/FormItemInput.d.ts

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

package/es/components/UForm/FormItemInput.js

@@ -0,0 +1,119 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+import { __rest } from "tslib";
+import classNames from 'classnames';
+import * as React from 'react';
+import Col from "../UGrid/col";
+import { FormContext, FormItemPrefixContext } from "./context";
+import ErrorList from "./ErrorList";
+import UIcon from "../UIcon";
+import Tooltip from "../UTooltip/tooltip";
+function toTooltipProps(iconTip) {
+  if (!iconTip) {
+    return null;
+  }
+  if (_typeof(iconTip) === 'object' && ! /*#__PURE__*/React.isValidElement(iconTip)) {
+    return iconTip;
+  }
+  return {
+    title: iconTip
+  };
+}
+var FormItemInput = function FormItemInput(props) {
+  var prefixCls = props.prefixCls,
+    status = props.status,
+    wrapperCol = props.wrapperCol,
+    children = props.children,
+    errors = props.errors,
+    warnings = props.warnings,
+    formItemRender = props._internalItemRender,
+    extra = props.extra,
+    help = props.help,
+    iconTip = props.iconTip,
+    fieldId = props.fieldId,
+    marginBottom = props.marginBottom,
+    onErrorVisibleChanged = props.onErrorVisibleChanged,
+    style = props.style;
+  var baseClassName = "".concat(prefixCls, "-item");
+  var formContext = React.useContext(FormContext);
+  var mergedWrapperCol = wrapperCol || formContext.wrapperCol || {};
+  var className = classNames("".concat(baseClassName, "-control"), mergedWrapperCol.className);
+  // Pass to sub FormItem should not with col info
+  var subFormContext = React.useMemo(function () {
+    return Object.assign({}, formContext);
+  }, [formContext]);
+  delete subFormContext.labelCol;
+  delete subFormContext.wrapperCol;
+  var inputDom = /*#__PURE__*/React.createElement("div", {
+    className: "".concat(baseClassName, "-control-input")
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(baseClassName, "-control-input-content")
+  }, children));
+  var formItemContext = React.useMemo(function () {
+    return {
+      prefixCls: prefixCls,
+      status: status
+    };
+  }, [prefixCls, status]);
+  var errorListDom = marginBottom !== null || errors.length || warnings.length ? (/*#__PURE__*/React.createElement("div", {
+    style: {
+      display: 'flex',
+      flexWrap: 'nowrap'
+    }
+  }, /*#__PURE__*/React.createElement(FormItemPrefixContext.Provider, {
+    value: formItemContext
+  }, /*#__PURE__*/React.createElement(ErrorList, {
+    fieldId: fieldId,
+    errors: errors,
+    warnings: warnings,
+    help: help,
+    helpStatus: status,
+    className: "".concat(baseClassName, "-explain-connected"),
+    onVisibleChanged: onErrorVisibleChanged
+  })), !!marginBottom && /*#__PURE__*/React.createElement("div", {
+    style: {
+      width: 0,
+      height: marginBottom
+    }
+  }))) : null;
+  var extraProps = {};
+  if (fieldId) {
+    extraProps.id = "".concat(fieldId, "_extra");
+  }
+  var iconTipProps = {};
+  if (fieldId) {
+    iconTipProps.id = "".concat(fieldId, "_iconTip");
+  }
+  // If extra = 0, && will goes wrong
+  // 0&&error -> 0
+  var extraDom = extra ? (/*#__PURE__*/React.createElement("div", Object.assign({}, extraProps, {
+    className: "".concat(baseClassName, "-extra")
+  }), extra)) : null;
+  var tooltipProps = toTooltipProps(iconTip); //{title:''}
+  var tooltipNode = null;
+  if (tooltipProps) {
+    //{icon=<Que>,...restTooltipProps}={title:""}
+    var _tooltipProps$icon = tooltipProps.icon,
+      icon = _tooltipProps$icon === void 0 ? /*#__PURE__*/React.createElement(UIcon, {
+        icon: "helpIcon"
+      }) : _tooltipProps$icon,
+      restTooltipProps = __rest(tooltipProps, ["icon"]);
+    console.log('restTooltipProps的值为', restTooltipProps);
+    tooltipNode = /*#__PURE__*/React.createElement(Tooltip, Object.assign({}, restTooltipProps), /*#__PURE__*/React.cloneElement(icon, {
+      className: "".concat(baseClassName, "-iconTip"),
+      title: ''
+    }));
+  }
+  var dom = formItemRender && formItemRender.mark === 'pro_table_render' && formItemRender.render ? formItemRender.render(props, {
+    input: inputDom,
+    errorList: errorListDom,
+    extra: extraDom,
+    iconTip: tooltipNode
+  }) : (/*#__PURE__*/React.createElement(React.Fragment, null, inputDom, errorListDom, extraDom, tooltipNode));
+  return /*#__PURE__*/React.createElement(FormContext.Provider, {
+    value: subFormContext
+  }, /*#__PURE__*/React.createElement(Col, Object.assign({}, mergedWrapperCol, {
+    className: className,
+    style: Object.assign(Object.assign({}, mergedWrapperCol.style), style)
+  }), dom));
+};
+export default FormItemInput;

package/es/components/UForm/FormItemLabel.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import type { ColProps } from '../UGrid/col';
+import type { TooltipProps } from '../UTooltip/tooltip';
+import type { RequiredMark } from './Form';
+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;
+    requiredMark?: RequiredMark;
+    tooltip?: LabelTooltipType;
+    style?: any;
+}
+declare const FormItemLabel: React.FC<FormItemLabelProps & {
+    required?: boolean;
+    prefixCls: string;
+}>;
+export default FormItemLabel;

package/es/components/UForm/FormItemLabel.js

@@ -0,0 +1,105 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+import { __rest } from "tslib";
+import QuestionCircleOutlined from '@ant-design/icons/QuestionCircleOutlined';
+import classNames from 'classnames';
+import * as React from 'react';
+import Col from "../UGrid/col";
+import { useLocaleReceiver } from "../locale-provider/LocaleReceiver";
+import defaultLocale from "../locale/default";
+import Tooltip from "../UTooltip/tooltip";
+import { FormContext } from "./context";
+function toTooltipProps(tooltip) {
+  if (!tooltip) {
+    return null;
+  }
+  if (_typeof(tooltip) === 'object' && ! /*#__PURE__*/React.isValidElement(tooltip)) {
+    return tooltip;
+  }
+  return {
+    title: tooltip
+  };
+}
+var FormItemLabel = function FormItemLabel(_ref) {
+  var prefixCls = _ref.prefixCls,
+    label = _ref.label,
+    htmlFor = _ref.htmlFor,
+    labelCol = _ref.labelCol,
+    labelAlign = _ref.labelAlign,
+    colon = _ref.colon,
+    required = _ref.required,
+    requiredMark = _ref.requiredMark,
+    tooltip = _ref.tooltip,
+    style = _ref.style;
+  var _useLocaleReceiver = useLocaleReceiver('Form'),
+    _useLocaleReceiver2 = _slicedToArray(_useLocaleReceiver, 1),
+    formLocale = _useLocaleReceiver2[0];
+  if (!label) return null;
+  return /*#__PURE__*/React.createElement(FormContext.Consumer, {
+    key: "label"
+  }, function (_ref2) {
+    var vertical = _ref2.vertical,
+      contextLabelAlign = _ref2.labelAlign,
+      contextLabelCol = _ref2.labelCol,
+      labelWrap = _ref2.labelWrap,
+      contextColon = _ref2.colon,
+      gridInfo = _ref2.gridInfo,
+      itemAuto = _ref2.itemAuto;
+    var _a;
+    var mergedLabelCol = labelCol || contextLabelCol || {};
+    var mergedLabelAlign = labelAlign || contextLabelAlign;
+    var labelClsBasic = "".concat(prefixCls, "-item-label");
+    var labelColClassName = classNames(labelClsBasic, mergedLabelAlign === 'left' && "".concat(labelClsBasic, "-left"), mergedLabelCol.className, _defineProperty(_defineProperty(_defineProperty({}, "".concat(prefixCls, "-label-required"), required), "".concat(prefixCls, "-label-noRequired"), !required), "".concat(labelClsBasic, "-wrap"), !!labelWrap));
+    var labelChildren = label;
+    // Keep label is original where there should have no colon
+    var computedColon = colon === true || contextColon !== false && colon !== false;
+    var haveColon = computedColon && !vertical;
+    // Remove duplicated user input colon
+    if (haveColon && typeof label === 'string' && label.trim() !== '') {
+      if (gridInfo || itemAuto) {
+        labelChildren = /*#__PURE__*/React.createElement("span", {
+          className: "".concat(prefixCls, "-item-labelText")
+        }, label.replace(/[:|：]\s*$/, ''));
+      } else {
+        labelChildren = label.replace(/[:|：]\s*$/, '');
+      }
+    }
+    // Tooltip
+    var tooltipProps = toTooltipProps(tooltip);
+    if (tooltipProps) {
+      var _tooltipProps$icon = tooltipProps.icon,
+        icon = _tooltipProps$icon === void 0 ? /*#__PURE__*/React.createElement(QuestionCircleOutlined, null) : _tooltipProps$icon,
+        restTooltipProps = __rest(tooltipProps, ["icon"]);
+      var tooltipNode = /*#__PURE__*/React.createElement(Tooltip, Object.assign({}, restTooltipProps), /*#__PURE__*/React.cloneElement(icon, {
+        className: "".concat(prefixCls, "-item-tooltip"),
+        title: ''
+      }));
+      labelChildren = /*#__PURE__*/React.createElement(React.Fragment, null, labelChildren, tooltipNode);
+    }
+    // Add required mark if optional
+    if (requiredMark === 'optional' && !required) {
+      labelChildren = /*#__PURE__*/React.createElement(React.Fragment, null, labelChildren, /*#__PURE__*/React.createElement("span", {
+        className: "".concat(prefixCls, "-item-optional"),
+        title: ""
+      }, (formLocale === null || formLocale === void 0 ? void 0 : formLocale.optional) || ((_a = defaultLocale.Form) === null || _a === void 0 ? void 0 : _a.optional)));
+    }
+    var labelClassName = classNames(_defineProperty(_defineProperty(_defineProperty({}, "".concat(prefixCls, "-item-required"), required), "".concat(prefixCls, "-item-required-mark-optional"), requiredMark === 'optional'), "".concat(prefixCls, "-item-no-colon"), !computedColon));
+    return /*#__PURE__*/React.createElement(Col, Object.assign({}, mergedLabelCol, {
+      className: labelColClassName,
+      style: Object.assign(Object.assign({}, mergedLabelCol.style), style)
+    }), /*#__PURE__*/React.createElement("label", {
+      htmlFor: htmlFor,
+      className: labelClassName,
+      title: typeof label === 'string' ? label : ''
+    }, labelChildren));
+  });
+};
+export default FormItemLabel;

package/es/components/UForm/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;