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

package/dist/locale/antd/typography/Base/EllipsisTooltip.js

@@ -0,0 +1,29 @@
+"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 React = _interopRequireWildcard(require("react"));
+var _tooltip = _interopRequireDefault(require("../../tooltip"));
+const EllipsisTooltip = _ref => {
+  let {
+    enabledEllipsis,
+    isEllipsis,
+    children,
+    tooltipProps
+  } = _ref;
+  if (!(tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.title) || !enabledEllipsis) {
+    return children;
+  }
+  return /*#__PURE__*/React.createElement(_tooltip.default, Object.assign({
+    open: isEllipsis ? undefined : false
+  }, tooltipProps), children);
+};
+if (process.env.NODE_ENV !== 'production') {
+  EllipsisTooltip.displayName = 'EllipsisTooltip';
+}
+var _default = EllipsisTooltip;
+exports.default = _default;

package/dist/locale/antd/typography/Base/index.d.ts

@@ -0,0 +1,52 @@
+import type { AutoSizeType } from 'rc-textarea';
+import * as React from 'react';
+import type { TooltipProps } from '../../tooltip';
+import type { TypographyProps } from '../Typography';
+export type BaseType = 'secondary' | 'success' | 'warning' | 'danger';
+interface CopyConfig {
+    text?: string;
+    onCopy?: (event?: React.MouseEvent<HTMLDivElement>) => void;
+    icon?: React.ReactNode;
+    tooltips?: boolean | React.ReactNode;
+    format?: 'text/plain' | 'text/html';
+}
+interface EditConfig {
+    text?: string;
+    editing?: boolean;
+    icon?: React.ReactNode;
+    tooltip?: boolean | React.ReactNode;
+    onStart?: () => void;
+    onChange?: (value: string) => void;
+    onCancel?: () => void;
+    onEnd?: () => void;
+    maxLength?: number;
+    autoSize?: boolean | AutoSizeType;
+    triggerType?: ('icon' | 'text')[];
+    enterIcon?: React.ReactNode;
+}
+export interface EllipsisConfig {
+    rows?: number;
+    expandable?: boolean;
+    suffix?: string;
+    symbol?: React.ReactNode;
+    onExpand?: React.MouseEventHandler<HTMLElement>;
+    onEllipsis?: (ellipsis: boolean) => void;
+    tooltip?: React.ReactNode | TooltipProps;
+}
+export interface BlockProps<C extends keyof JSX.IntrinsicElements = keyof JSX.IntrinsicElements> extends TypographyProps<C> {
+    title?: string;
+    editable?: boolean | EditConfig;
+    copyable?: boolean | CopyConfig;
+    type?: BaseType;
+    disabled?: boolean;
+    ellipsis?: boolean | EllipsisConfig;
+    code?: boolean;
+    mark?: boolean;
+    underline?: boolean;
+    delete?: boolean;
+    strong?: boolean;
+    keyboard?: boolean;
+    italic?: boolean;
+}
+declare const Base: React.ForwardRefExoticComponent<BlockProps<keyof JSX.IntrinsicElements> & React.RefAttributes<HTMLElement>>;
+export default Base;

package/dist/locale/antd/typography/Base/index.js

@@ -0,0 +1,429 @@
+"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 _CheckOutlined = _interopRequireDefault(require("@ant-design/icons/CheckOutlined"));
+var _CopyOutlined = _interopRequireDefault(require("@ant-design/icons/CopyOutlined"));
+var _EditOutlined = _interopRequireDefault(require("@ant-design/icons/EditOutlined"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _copyToClipboard = _interopRequireDefault(require("copy-to-clipboard"));
+var _rcResizeObserver = _interopRequireDefault(require("rc-resize-observer"));
+var _toArray = _interopRequireDefault(require("rc-util/lib/Children/toArray"));
+var _useLayoutEffect = _interopRequireDefault(require("rc-util/lib/hooks/useLayoutEffect"));
+var _useMergedState = _interopRequireDefault(require("rc-util/lib/hooks/useMergedState"));
+var _omit = _interopRequireDefault(require("rc-util/lib/omit"));
+var _ref3 = require("rc-util/lib/ref");
+var React = _interopRequireWildcard(require("react"));
+var _styleChecker = require("../../_util/styleChecker");
+var _transButton = _interopRequireDefault(require("../../_util/transButton"));
+var _configProvider = require("../../config-provider");
+var _useLocale = _interopRequireDefault(require("../../locale/useLocale"));
+var _tooltip = _interopRequireDefault(require("../../tooltip"));
+var _Editable = _interopRequireDefault(require("../Editable"));
+var _Typography = _interopRequireDefault(require("../Typography"));
+var _useMergedConfig = _interopRequireDefault(require("../hooks/useMergedConfig"));
+var _useUpdatedEffect = _interopRequireDefault(require("../hooks/useUpdatedEffect"));
+var _Ellipsis = _interopRequireDefault(require("./Ellipsis"));
+var _EllipsisTooltip = _interopRequireDefault(require("./EllipsisTooltip"));
+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 wrapperDecorations(_ref, content) {
+  let {
+    mark,
+    code,
+    underline,
+    delete: del,
+    strong,
+    keyboard,
+    italic
+  } = _ref;
+  let currentContent = content;
+  function wrap(tag, needed) {
+    if (!needed) {
+      return;
+    }
+    currentContent = /*#__PURE__*/React.createElement(tag, {}, currentContent);
+  }
+  wrap('strong', strong);
+  wrap('u', underline);
+  wrap('del', del);
+  wrap('code', code);
+  wrap('mark', mark);
+  wrap('kbd', keyboard);
+  wrap('i', italic);
+  return currentContent;
+}
+function getNode(dom, defaultNode, needDom) {
+  if (dom === true || dom === undefined) {
+    return defaultNode;
+  }
+  return dom || needDom && defaultNode;
+}
+function toList(val) {
+  if (val === false) {
+    return [false, false];
+  }
+  return Array.isArray(val) ? val : [val];
+}
+const ELLIPSIS_STR = '...';
+const Base = /*#__PURE__*/React.forwardRef((props, ref) => {
+  var _a, _b, _c;
+  const {
+      prefixCls: customizePrefixCls,
+      className,
+      style,
+      type,
+      disabled,
+      children,
+      ellipsis,
+      editable,
+      copyable,
+      component,
+      title
+    } = props,
+    restProps = __rest(props, ["prefixCls", "className", "style", "type", "disabled", "children", "ellipsis", "editable", "copyable", "component", "title"]);
+  const {
+    getPrefixCls,
+    direction
+  } = React.useContext(_configProvider.ConfigContext);
+  const [textLocale] = (0, _useLocale.default)('Text');
+  const typographyRef = React.useRef(null);
+  const editIconRef = React.useRef(null);
+  // ============================ MISC ============================
+  const prefixCls = getPrefixCls('typography', customizePrefixCls);
+  const textProps = (0, _omit.default)(restProps, ['mark', 'code', 'delete', 'underline', 'strong', 'keyboard', 'italic']);
+  // ========================== Editable ==========================
+  const [enableEdit, editConfig] = (0, _useMergedConfig.default)(editable);
+  const [editing, setEditing] = (0, _useMergedState.default)(false, {
+    value: editConfig.editing
+  });
+  const {
+    triggerType = ['icon']
+  } = editConfig;
+  const triggerEdit = edit => {
+    var _a;
+    if (edit) {
+      (_a = editConfig.onStart) === null || _a === void 0 ? void 0 : _a.call(editConfig);
+    }
+    setEditing(edit);
+  };
+  // Focus edit icon when back
+  (0, _useUpdatedEffect.default)(() => {
+    var _a;
+    if (!editing) {
+      (_a = editIconRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+    }
+  }, [editing]);
+  const onEditClick = e => {
+    e === null || e === void 0 ? void 0 : e.preventDefault();
+    triggerEdit(true);
+  };
+  const onEditChange = value => {
+    var _a;
+    (_a = editConfig.onChange) === null || _a === void 0 ? void 0 : _a.call(editConfig, value);
+    triggerEdit(false);
+  };
+  const onEditCancel = () => {
+    var _a;
+    (_a = editConfig.onCancel) === null || _a === void 0 ? void 0 : _a.call(editConfig);
+    triggerEdit(false);
+  };
+  // ========================== Copyable ==========================
+  const [enableCopy, copyConfig] = (0, _useMergedConfig.default)(copyable);
+  const [copied, setCopied] = React.useState(false);
+  const copyIdRef = React.useRef(null);
+  const copyOptions = {};
+  if (copyConfig.format) {
+    copyOptions.format = copyConfig.format;
+  }
+  const cleanCopyId = () => {
+    if (copyIdRef.current) {
+      clearTimeout(copyIdRef.current);
+    }
+  };
+  const onCopyClick = e => {
+    var _a;
+    e === null || e === void 0 ? void 0 : e.preventDefault();
+    e === null || e === void 0 ? void 0 : e.stopPropagation();
+    (0, _copyToClipboard.default)(copyConfig.text || String(children) || '', copyOptions);
+    setCopied(true);
+    // Trigger tips update
+    cleanCopyId();
+    copyIdRef.current = setTimeout(() => {
+      setCopied(false);
+    }, 3000);
+    (_a = copyConfig.onCopy) === null || _a === void 0 ? void 0 : _a.call(copyConfig, e);
+  };
+  React.useEffect(() => cleanCopyId, []);
+  // ========================== Ellipsis ==========================
+  const [isLineClampSupport, setIsLineClampSupport] = React.useState(false);
+  const [isTextOverflowSupport, setIsTextOverflowSupport] = React.useState(false);
+  const [expanded, setExpanded] = React.useState(false);
+  const [isJsEllipsis, setIsJsEllipsis] = React.useState(false);
+  const [isNativeEllipsis, setIsNativeEllipsis] = React.useState(false);
+  const [isNativeVisible, setIsNativeVisible] = React.useState(true);
+  const [enableEllipsis, ellipsisConfig] = (0, _useMergedConfig.default)(ellipsis, {
+    expandable: false
+  });
+  const mergedEnableEllipsis = enableEllipsis && !expanded;
+  // Shared prop to reduce bundle size
+  const {
+    rows = 1
+  } = ellipsisConfig;
+  const needMeasureEllipsis = React.useMemo(() =>
+  // Disable ellipsis
+  !mergedEnableEllipsis ||
+  // Provide suffix
+  ellipsisConfig.suffix !== undefined || ellipsisConfig.onEllipsis ||
+  // Can't use css ellipsis since we need to provide the place for button
+  ellipsisConfig.expandable || enableEdit || enableCopy, [mergedEnableEllipsis, ellipsisConfig, enableEdit, enableCopy]);
+  (0, _useLayoutEffect.default)(() => {
+    if (enableEllipsis && !needMeasureEllipsis) {
+      setIsLineClampSupport((0, _styleChecker.isStyleSupport)('webkitLineClamp'));
+      setIsTextOverflowSupport((0, _styleChecker.isStyleSupport)('textOverflow'));
+    }
+  }, [needMeasureEllipsis, enableEllipsis]);
+  const cssEllipsis = React.useMemo(() => {
+    if (needMeasureEllipsis) {
+      return false;
+    }
+    if (rows === 1) {
+      return isTextOverflowSupport;
+    }
+    return isLineClampSupport;
+  }, [needMeasureEllipsis, isTextOverflowSupport, isLineClampSupport]);
+  const isMergedEllipsis = mergedEnableEllipsis && (cssEllipsis ? isNativeEllipsis : isJsEllipsis);
+  const cssTextOverflow = mergedEnableEllipsis && rows === 1 && cssEllipsis;
+  const cssLineClamp = mergedEnableEllipsis && rows > 1 && cssEllipsis;
+  // >>>>> Expand
+  const onExpandClick = e => {
+    var _a;
+    setExpanded(true);
+    (_a = ellipsisConfig.onExpand) === null || _a === void 0 ? void 0 : _a.call(ellipsisConfig, e);
+  };
+  const [ellipsisWidth, setEllipsisWidth] = React.useState(0);
+  const [ellipsisFontSize, setEllipsisFontSize] = React.useState(0);
+  const onResize = (_ref2, element) => {
+    let {
+      offsetWidth
+    } = _ref2;
+    var _a;
+    setEllipsisWidth(offsetWidth);
+    setEllipsisFontSize(parseInt((_a = window.getComputedStyle) === null || _a === void 0 ? void 0 : _a.call(window, element).fontSize, 10) || 0);
+  };
+  // >>>>> JS Ellipsis
+  const onJsEllipsis = jsEllipsis => {
+    var _a;
+    setIsJsEllipsis(jsEllipsis);
+    // Trigger if changed
+    if (isJsEllipsis !== jsEllipsis) {
+      (_a = ellipsisConfig.onEllipsis) === null || _a === void 0 ? void 0 : _a.call(ellipsisConfig, jsEllipsis);
+    }
+  };
+  // >>>>> Native ellipsis
+  React.useEffect(() => {
+    const textEle = typographyRef.current;
+    if (enableEllipsis && cssEllipsis && textEle) {
+      const currentEllipsis = cssLineClamp ? textEle.offsetHeight < textEle.scrollHeight : textEle.offsetWidth < textEle.scrollWidth;
+      if (isNativeEllipsis !== currentEllipsis) {
+        setIsNativeEllipsis(currentEllipsis);
+      }
+    }
+  }, [enableEllipsis, cssEllipsis, children, cssLineClamp, isNativeVisible]);
+  // https://github.com/ant-design/ant-design/issues/36786
+  // Use IntersectionObserver to check if element is invisible
+  React.useEffect(() => {
+    const textEle = typographyRef.current;
+    if (typeof IntersectionObserver === 'undefined' || !textEle || !cssEllipsis || !mergedEnableEllipsis) {
+      return;
+    }
+    /* eslint-disable-next-line compat/compat */
+    const observer = new IntersectionObserver(() => {
+      setIsNativeVisible(!!textEle.offsetParent);
+    });
+    observer.observe(textEle);
+    return () => {
+      observer.disconnect();
+    };
+  }, [cssEllipsis, mergedEnableEllipsis]);
+  // ========================== Tooltip ===========================
+  let tooltipProps = {};
+  if (ellipsisConfig.tooltip === true) {
+    tooltipProps = {
+      title: (_a = editConfig.text) !== null && _a !== void 0 ? _a : children
+    };
+  } else if ( /*#__PURE__*/React.isValidElement(ellipsisConfig.tooltip)) {
+    tooltipProps = {
+      title: ellipsisConfig.tooltip
+    };
+  } else if (typeof ellipsisConfig.tooltip === 'object') {
+    tooltipProps = Object.assign({
+      title: (_b = editConfig.text) !== null && _b !== void 0 ? _b : children
+    }, ellipsisConfig.tooltip);
+  } else {
+    tooltipProps = {
+      title: ellipsisConfig.tooltip
+    };
+  }
+  const topAriaLabel = React.useMemo(() => {
+    const isValid = val => ['string', 'number'].includes(typeof val);
+    if (!enableEllipsis || cssEllipsis) {
+      return undefined;
+    }
+    if (isValid(editConfig.text)) {
+      return editConfig.text;
+    }
+    if (isValid(children)) {
+      return children;
+    }
+    if (isValid(title)) {
+      return title;
+    }
+    if (isValid(tooltipProps.title)) {
+      return tooltipProps.title;
+    }
+    return undefined;
+  }, [enableEllipsis, cssEllipsis, title, tooltipProps.title, isMergedEllipsis]);
+  // =========================== Render ===========================
+  // >>>>>>>>>>> Editing input
+  if (editing) {
+    return /*#__PURE__*/React.createElement(_Editable.default, {
+      value: (_c = editConfig.text) !== null && _c !== void 0 ? _c : typeof children === 'string' ? children : '',
+      onSave: onEditChange,
+      onCancel: onEditCancel,
+      onEnd: editConfig.onEnd,
+      prefixCls: prefixCls,
+      className: className,
+      style: style,
+      direction: direction,
+      component: component,
+      maxLength: editConfig.maxLength,
+      autoSize: editConfig.autoSize,
+      enterIcon: editConfig.enterIcon
+    });
+  }
+  // >>>>>>>>>>> Typography
+  // Expand
+  const renderExpand = () => {
+    const {
+      expandable,
+      symbol
+    } = ellipsisConfig;
+    if (!expandable) return null;
+    let expandContent;
+    if (symbol) {
+      expandContent = symbol;
+    } else {
+      expandContent = textLocale === null || textLocale === void 0 ? void 0 : textLocale.expand;
+    }
+    return /*#__PURE__*/React.createElement("a", {
+      key: "expand",
+      className: `${prefixCls}-expand`,
+      onClick: onExpandClick,
+      "aria-label": textLocale === null || textLocale === void 0 ? void 0 : textLocale.expand
+    }, expandContent);
+  };
+  // Edit
+  const renderEdit = () => {
+    if (!enableEdit) return;
+    const {
+      icon,
+      tooltip
+    } = editConfig;
+    const editTitle = (0, _toArray.default)(tooltip)[0] || (textLocale === null || textLocale === void 0 ? void 0 : textLocale.edit);
+    const ariaLabel = typeof editTitle === 'string' ? editTitle : '';
+    return triggerType.includes('icon') ? /*#__PURE__*/React.createElement(_tooltip.default, {
+      key: "edit",
+      title: tooltip === false ? '' : editTitle
+    }, /*#__PURE__*/React.createElement(_transButton.default, {
+      ref: editIconRef,
+      className: `${prefixCls}-edit`,
+      onClick: onEditClick,
+      "aria-label": ariaLabel
+    }, icon || /*#__PURE__*/React.createElement(_EditOutlined.default, {
+      role: "button"
+    }))) : null;
+  };
+  // Copy
+  const renderCopy = () => {
+    if (!enableCopy) return;
+    const {
+      tooltips,
+      icon
+    } = copyConfig;
+    const tooltipNodes = toList(tooltips);
+    const iconNodes = toList(icon);
+    const copyTitle = copied ? getNode(tooltipNodes[1], textLocale === null || textLocale === void 0 ? void 0 : textLocale.copied) : getNode(tooltipNodes[0], textLocale === null || textLocale === void 0 ? void 0 : textLocale.copy);
+    const systemStr = copied ? textLocale === null || textLocale === void 0 ? void 0 : textLocale.copied : textLocale === null || textLocale === void 0 ? void 0 : textLocale.copy;
+    const ariaLabel = typeof copyTitle === 'string' ? copyTitle : systemStr;
+    return /*#__PURE__*/React.createElement(_tooltip.default, {
+      key: "copy",
+      title: copyTitle
+    }, /*#__PURE__*/React.createElement(_transButton.default, {
+      className: (0, _classnames.default)(`${prefixCls}-copy`, copied && `${prefixCls}-copy-success`),
+      onClick: onCopyClick,
+      "aria-label": ariaLabel
+    }, copied ? getNode(iconNodes[1], /*#__PURE__*/React.createElement(_CheckOutlined.default, null), true) : getNode(iconNodes[0], /*#__PURE__*/React.createElement(_CopyOutlined.default, null), true)));
+  };
+  const renderOperations = renderExpanded => [renderExpanded && renderExpand(), renderEdit(), renderCopy()];
+  const renderEllipsis = needEllipsis => [needEllipsis && /*#__PURE__*/React.createElement("span", {
+    "aria-hidden": true,
+    key: "ellipsis"
+  }, ELLIPSIS_STR), ellipsisConfig.suffix, renderOperations(needEllipsis)];
+  return /*#__PURE__*/React.createElement(_rcResizeObserver.default, {
+    onResize: onResize,
+    disabled: !mergedEnableEllipsis || cssEllipsis
+  }, resizeRef => /*#__PURE__*/React.createElement(_EllipsisTooltip.default, {
+    tooltipProps: tooltipProps,
+    enabledEllipsis: mergedEnableEllipsis,
+    isEllipsis: isMergedEllipsis
+  }, /*#__PURE__*/React.createElement(_Typography.default, Object.assign({
+    className: (0, _classnames.default)({
+      [`${prefixCls}-${type}`]: type,
+      [`${prefixCls}-disabled`]: disabled,
+      [`${prefixCls}-ellipsis`]: enableEllipsis,
+      [`${prefixCls}-single-line`]: mergedEnableEllipsis && rows === 1,
+      [`${prefixCls}-ellipsis-single-line`]: cssTextOverflow,
+      [`${prefixCls}-ellipsis-multiple-line`]: cssLineClamp
+    }, className),
+    prefixCls: customizePrefixCls,
+    style: Object.assign(Object.assign({}, style), {
+      WebkitLineClamp: cssLineClamp ? rows : undefined
+    }),
+    component: component,
+    ref: (0, _ref3.composeRef)(resizeRef, typographyRef, ref),
+    direction: direction,
+    onClick: triggerType.includes('text') ? onEditClick : undefined,
+    "aria-label": topAriaLabel === null || topAriaLabel === void 0 ? void 0 : topAriaLabel.toString(),
+    title: title
+  }, textProps), /*#__PURE__*/React.createElement(_Ellipsis.default, {
+    enabledMeasure: mergedEnableEllipsis && !cssEllipsis,
+    text: children,
+    rows: rows,
+    width: ellipsisWidth,
+    fontSize: ellipsisFontSize,
+    onEllipsis: onJsEllipsis
+  }, (node, needEllipsis) => {
+    let renderNode = node;
+    if (node.length && needEllipsis && topAriaLabel) {
+      renderNode = /*#__PURE__*/React.createElement("span", {
+        key: "show-content",
+        "aria-hidden": true
+      }, renderNode);
+    }
+    const wrappedContext = wrapperDecorations(props, /*#__PURE__*/React.createElement(React.Fragment, null, renderNode, renderEllipsis(needEllipsis)));
+    return wrappedContext;
+  }))));
+});
+var _default = Base;
+exports.default = _default;

package/dist/locale/antd/typography/Editable.d.ts

@@ -0,0 +1,20 @@
+import type { AutoSizeType } from 'rc-textarea';
+import * as React from 'react';
+import type { DirectionType } from '../config-provider';
+interface EditableProps {
+    prefixCls: string;
+    value: string;
+    ['aria-label']?: string;
+    onSave: (value: string) => void;
+    onCancel: () => void;
+    onEnd?: () => void;
+    className?: string;
+    style?: React.CSSProperties;
+    direction?: DirectionType;
+    maxLength?: number;
+    autoSize?: boolean | AutoSizeType;
+    enterIcon?: React.ReactNode;
+    component?: string;
+}
+declare const Editable: React.FC<EditableProps>;
+export default Editable;

package/dist/locale/antd/typography/Editable.js

@@ -0,0 +1,121 @@
+"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 _EnterOutlined = _interopRequireDefault(require("@ant-design/icons/EnterOutlined"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _KeyCode = _interopRequireDefault(require("rc-util/lib/KeyCode"));
+var React = _interopRequireWildcard(require("react"));
+var _reactNode = require("../_util/reactNode");
+var _TextArea = _interopRequireDefault(require("../input/TextArea"));
+var _style = _interopRequireDefault(require("./style"));
+const Editable = props => {
+  const {
+    prefixCls,
+    'aria-label': ariaLabel,
+    className,
+    style,
+    direction,
+    maxLength,
+    autoSize = true,
+    value,
+    onSave,
+    onCancel,
+    onEnd,
+    component,
+    enterIcon = /*#__PURE__*/React.createElement(_EnterOutlined.default, null)
+  } = props;
+  const ref = React.useRef(null);
+  const inComposition = React.useRef(false);
+  const lastKeyCode = React.useRef();
+  const [current, setCurrent] = React.useState(value);
+  React.useEffect(() => {
+    setCurrent(value);
+  }, [value]);
+  React.useEffect(() => {
+    if (ref.current && ref.current.resizableTextArea) {
+      const {
+        textArea
+      } = ref.current.resizableTextArea;
+      textArea.focus();
+      const {
+        length
+      } = textArea.value;
+      textArea.setSelectionRange(length, length);
+    }
+  }, []);
+  const onChange = _ref => {
+    let {
+      target
+    } = _ref;
+    setCurrent(target.value.replace(/[\n\r]/g, ''));
+  };
+  const onCompositionStart = () => {
+    inComposition.current = true;
+  };
+  const onCompositionEnd = () => {
+    inComposition.current = false;
+  };
+  const onKeyDown = _ref2 => {
+    let {
+      keyCode
+    } = _ref2;
+    // We don't record keyCode when IME is using
+    if (inComposition.current) return;
+    lastKeyCode.current = keyCode;
+  };
+  const confirmChange = () => {
+    onSave(current.trim());
+  };
+  const onKeyUp = _ref3 => {
+    let {
+      keyCode,
+      ctrlKey,
+      altKey,
+      metaKey,
+      shiftKey
+    } = _ref3;
+    // Check if it's a real key
+    if (lastKeyCode.current === keyCode && !inComposition.current && !ctrlKey && !altKey && !metaKey && !shiftKey) {
+      if (keyCode === _KeyCode.default.ENTER) {
+        confirmChange();
+        onEnd === null || onEnd === void 0 ? void 0 : onEnd();
+      } else if (keyCode === _KeyCode.default.ESC) {
+        onCancel();
+      }
+    }
+  };
+  const onBlur = () => {
+    confirmChange();
+  };
+  const textClassName = component ? `${prefixCls}-${component}` : '';
+  const [wrapSSR, hashId] = (0, _style.default)(prefixCls);
+  const textAreaClassName = (0, _classnames.default)(prefixCls, `${prefixCls}-edit-content`, {
+    [`${prefixCls}-rtl`]: direction === 'rtl'
+  }, className, textClassName, hashId);
+  return wrapSSR( /*#__PURE__*/React.createElement("div", {
+    className: textAreaClassName,
+    style: style
+  }, /*#__PURE__*/React.createElement(_TextArea.default, {
+    ref: ref,
+    maxLength: maxLength,
+    value: current,
+    onChange: onChange,
+    onKeyDown: onKeyDown,
+    onKeyUp: onKeyUp,
+    onCompositionStart: onCompositionStart,
+    onCompositionEnd: onCompositionEnd,
+    onBlur: onBlur,
+    "aria-label": ariaLabel,
+    rows: 1,
+    autoSize: autoSize
+  }), enterIcon !== null ? (0, _reactNode.cloneElement)(enterIcon, {
+    className: `${prefixCls}-edit-content-confirm`
+  }) : null));
+};
+var _default = Editable;
+exports.default = _default;

package/dist/locale/antd/typography/Link.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import type { BlockProps } from './Base';
+export interface LinkProps extends BlockProps<'a'>, Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'type' | keyof BlockProps<'a'>> {
+    ellipsis?: boolean;
+}
+declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLElement>>;
+export default Link;