@996-design/996-components 1.0.0

package/lib/timeline/useItems.js

@@ -0,0 +1,84 @@
+"use strict";
+"use client";
+
+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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _objectSpread3 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var React = _interopRequireWildcard(require("react"));
+var _LoadingOutlined = _interopRequireDefault(require("@996-design/996-icons/LoadingOutlined"));
+var _util = require("@rc-component/util");
+var _clsx = require("clsx");
+var _genStyleUtils = require("../theme/util/genStyleUtils");
+var _excluded = ["label", "children", "title", "content", "color", "className", "style", "icon", "dot", "placement", "position", "loading"];
+var useItems = function useItems(rootPrefixCls, prefixCls, mode, items, children, pending, pendingDot) {
+  var itemCls = "".concat(prefixCls, "-item");
+  var _genCssVar = (0, _genStyleUtils.genCssVar)(rootPrefixCls, 'cmp-steps'),
+    _genCssVar2 = (0, _slicedToArray2.default)(_genCssVar, 1),
+    varName = _genCssVar2[0];
+  // Merge items and children
+  var parseItems = React.useMemo(function () {
+    return Array.isArray(items) ? items : (0, _util.toArray)(children).map(function (ele) {
+      return (0, _objectSpread3.default)({}, ele.props);
+    });
+  }, [items, children]);
+  // convert legacy type
+  return React.useMemo(function () {
+    var mergedItems = parseItems.map(function (item, index) {
+      var _ref;
+      var label = item.label,
+        children = item.children,
+        title = item.title,
+        content = item.content,
+        color = item.color,
+        className = item.className,
+        style = item.style,
+        icon = item.icon,
+        dot = item.dot,
+        placement = item.placement,
+        position = item.position,
+        loading = item.loading,
+        restProps = (0, _objectWithoutProperties2.default)(item, _excluded);
+      var mergedStyle = style;
+      var mergedClassName = className;
+      if (color) {
+        if (['blue', 'red', 'green', 'gray'].includes(color)) {
+          mergedClassName = (0, _clsx.clsx)(className, "".concat(itemCls, "-color-").concat(color));
+        } else {
+          mergedStyle = (0, _objectSpread3.default)((0, _defineProperty2.default)({}, varName('item-icon-dot-color'), color), style);
+        }
+      }
+      // Placement
+      var mergedPlacement = (_ref = placement !== null && placement !== void 0 ? placement : position) !== null && _ref !== void 0 ? _ref : mode === 'alternate' ? index % 2 === 0 ? 'start' : 'end' : mode;
+      mergedClassName = (0, _clsx.clsx)(mergedClassName, "".concat(itemCls, "-placement-").concat(mergedPlacement));
+      // Icon
+      var mergedIcon = icon !== null && icon !== void 0 ? icon : dot;
+      if (!mergedIcon && loading) {
+        mergedIcon = /*#__PURE__*/React.createElement(_LoadingOutlined.default, null);
+      }
+      return (0, _objectSpread3.default)((0, _objectSpread3.default)({}, restProps), {}, {
+        title: title !== null && title !== void 0 ? title : label,
+        content: content !== null && content !== void 0 ? content : children,
+        style: mergedStyle,
+        className: mergedClassName,
+        icon: mergedIcon,
+        status: loading ? 'process' : 'finish'
+      });
+    });
+    if (pending) {
+      mergedItems.push({
+        icon: pendingDot !== null && pendingDot !== void 0 ? pendingDot : /*#__PURE__*/React.createElement(_LoadingOutlined.default, null),
+        content: pending,
+        status: 'process'
+      });
+    }
+    return mergedItems;
+  }, [parseItems, pending, mode, itemCls, varName, pendingDot]);
+};
+var _default = exports.default = useItems;

package/lib/timeline.d.ts

@@ -0,0 +1,2 @@
+export * from './timeline/index';
+export { default } from './timeline/index';

package/lib/timeline.js

@@ -0,0 +1 @@
+module.exports = require('./timeline/index.js');

package/lib/tooltip/PurePanel.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import type { TooltipProps } from '.';
+export interface PurePanelProps extends Omit<TooltipProps, 'children'> {
+}
+/** @private Internal Component. Do not use in your production. */
+declare const PurePanel: React.FC<PurePanelProps>;
+export default PurePanel;

package/lib/tooltip/PurePanel.js

@@ -0,0 +1,71 @@
+"use strict";
+"use client";
+
+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 _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var React = _interopRequireWildcard(require("react"));
+var _tooltip = require("@rc-component/tooltip");
+var _clsx = require("clsx");
+var _useMergeSemantic3 = require("../_util/hooks/useMergeSemantic");
+var _configProvider = require("../config-provider");
+var _useCSSVarCls = _interopRequireDefault(require("../config-provider/hooks/useCSSVarCls"));
+var _style = _interopRequireDefault(require("./style"));
+var _util = require("./util");
+/** @private Internal Component. Do not use in your production. */
+var PurePanel = function PurePanel(props) {
+  var customizePrefixCls = props.prefixCls,
+    className = props.className,
+    _props$placement = props.placement,
+    placement = _props$placement === void 0 ? 'top' : _props$placement,
+    title = props.title,
+    color = props.color,
+    overlayInnerStyle = props.overlayInnerStyle,
+    classNames = props.classNames,
+    styles = props.styles;
+  var _React$useContext = React.useContext(_configProvider.ConfigContext),
+    getPrefixCls = _React$useContext.getPrefixCls;
+  var prefixCls = getPrefixCls('tooltip', customizePrefixCls);
+  var rootPrefixCls = getPrefixCls();
+  var rootCls = (0, _useCSSVarCls.default)(prefixCls);
+  var _useStyle = (0, _style.default)(prefixCls, rootCls),
+    _useStyle2 = (0, _slicedToArray2.default)(_useStyle, 2),
+    hashId = _useStyle2[0],
+    cssVarCls = _useStyle2[1];
+  // Color
+  var colorInfo = (0, _util.parseColor)(rootPrefixCls, prefixCls, color);
+  var arrowContentStyle = colorInfo.arrowStyle;
+  var innerStyles = React.useMemo(function () {
+    var mergedStyle = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, overlayInnerStyle), colorInfo.overlayStyle);
+    return {
+      container: mergedStyle
+    };
+  }, [overlayInnerStyle, colorInfo.overlayStyle]);
+  var mergedProps = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, props), {}, {
+    placement: placement
+  });
+  var _useMergeSemantic = (0, _useMergeSemantic3.useMergeSemantic)([classNames], [innerStyles, styles], {
+      props: mergedProps
+    }),
+    _useMergeSemantic2 = (0, _slicedToArray2.default)(_useMergeSemantic, 2),
+    mergedClassNames = _useMergeSemantic2[0],
+    mergedStyles = _useMergeSemantic2[1];
+  var rootClassName = (0, _clsx.clsx)(rootCls, hashId, cssVarCls, prefixCls, "".concat(prefixCls, "-pure"), "".concat(prefixCls, "-placement-").concat(placement), className, colorInfo.className);
+  return /*#__PURE__*/React.createElement("div", {
+    className: rootClassName,
+    style: arrowContentStyle
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-arrow")
+  }), /*#__PURE__*/React.createElement(_tooltip.Popup, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, props), {}, {
+    className: hashId,
+    prefixCls: prefixCls,
+    classNames: mergedClassNames,
+    styles: mergedStyles
+  }), title));
+};
+var _default = exports.default = PurePanel;

package/lib/tooltip/UniqueProvider/MotionContent.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const MotionContent: React.FC<React.PropsWithChildren>;
+export default MotionContent;

package/lib/tooltip/UniqueProvider/MotionContent.js

@@ -0,0 +1,43 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _react = _interopRequireDefault(require("react"));
+var _motion = _interopRequireDefault(require("@rc-component/motion"));
+var _clsx = require("clsx");
+var _reactNode = require("../../_util/reactNode");
+var _context = require("../../config-provider/context");
+var MotionContent = function MotionContent(_ref) {
+  var children = _ref.children;
+  var _React$useContext = _react.default.useContext(_context.ConfigContext),
+    getPrefixCls = _React$useContext.getPrefixCls;
+  var rootPrefixCls = getPrefixCls();
+  // This will never reach since we will not render this when no children
+  /* istanbul ignore next */
+  if (! /*#__PURE__*/_react.default.isValidElement(children)) {
+    return children;
+  }
+  return /*#__PURE__*/_react.default.createElement(_motion.default, {
+    visible: true,
+    motionName: "".concat(rootPrefixCls, "-fade"),
+    motionAppear: true,
+    motionEnter: true,
+    motionLeave: false,
+    removeOnLeave: false
+  }, function (_ref2) {
+    var motionStyle = _ref2.style,
+      motionClassName = _ref2.className;
+    return (0, _reactNode.cloneElement)(children, function (oriProps) {
+      return {
+        className: (0, _clsx.clsx)(oriProps.className, motionClassName),
+        style: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, oriProps.style), motionStyle)
+      };
+    });
+  });
+};
+var _default = exports.default = MotionContent;

package/lib/tooltip/UniqueProvider/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const UniqueProvider: React.FC<React.PropsWithChildren>;
+export default UniqueProvider;

package/lib/tooltip/UniqueProvider/index.js

@@ -0,0 +1,49 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _react = _interopRequireDefault(require("react"));
+var _trigger = require("@rc-component/trigger");
+var _is = require("../../_util/is");
+var _MotionContent = _interopRequireDefault(require("./MotionContent"));
+var cachedPlacements = [null, null];
+function uniqueBuiltinPlacements(ori) {
+  if (cachedPlacements[0] !== ori) {
+    var target = {};
+    Object.keys(ori).forEach(function (placement) {
+      target[placement] = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, ori[placement]), {}, {
+        dynamicInset: false
+      });
+    });
+    cachedPlacements[0] = ori;
+    cachedPlacements[1] = target;
+  }
+  return cachedPlacements[1];
+}
+var UniqueProvider = function UniqueProvider(_ref) {
+  var children = _ref.children;
+  var renderPopup = function renderPopup(options) {
+    var id = options.id,
+      builtinPlacements = options.builtinPlacements,
+      popup = options.popup;
+    var popupEle = (0, _is.isFunction)(popup) ? popup() : popup;
+    var parsedPlacements = uniqueBuiltinPlacements(builtinPlacements);
+    return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, options), {}, {
+      getPopupContainer: null,
+      arrow: false,
+      popup: /*#__PURE__*/_react.default.createElement(_MotionContent.default, {
+        key: id
+      }, popupEle),
+      builtinPlacements: parsedPlacements
+    });
+  };
+  return /*#__PURE__*/_react.default.createElement(_trigger.UniqueProvider, {
+    postTriggerProps: renderPopup
+  }, children);
+};
+var _default = exports.default = UniqueProvider;

package/lib/tooltip/UniqueProvider.d.ts

@@ -0,0 +1,2 @@
+export * from './UniqueProvider/index';
+export { default } from './UniqueProvider/index';

package/lib/tooltip/UniqueProvider.js

@@ -0,0 +1 @@
+module.exports = require('./UniqueProvider/index.js');

package/lib/tooltip/hook/useMergedArrow.d.ts

@@ -0,0 +1,8 @@
+import type { AbstractTooltipProps } from '..';
+import type { TooltipConfig } from '../../config-provider/context';
+interface MergedArrow {
+    show: boolean;
+    pointAtCenter?: boolean;
+}
+declare const useMergedArrow: (providedArrow?: AbstractTooltipProps["arrow"], providedContextArrow?: TooltipConfig["arrow"]) => MergedArrow;
+export default useMergedArrow;

package/lib/tooltip/hook/useMergedArrow.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _react = _interopRequireDefault(require("react"));
+var useMergedArrow = function useMergedArrow(providedArrow, providedContextArrow) {
+  var toConfig = function toConfig(arrow) {
+    return typeof arrow === 'boolean' ? {
+      show: arrow
+    } : arrow || {};
+  };
+  return _react.default.useMemo(function () {
+    var _ref, _arrowConfig$show;
+    var arrowConfig = toConfig(providedArrow);
+    var contextArrowConfig = toConfig(providedContextArrow);
+    return (0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, contextArrowConfig), arrowConfig), {}, {
+      show: (_ref = (_arrowConfig$show = arrowConfig.show) !== null && _arrowConfig$show !== void 0 ? _arrowConfig$show : contextArrowConfig.show) !== null && _ref !== void 0 ? _ref : true
+    });
+  }, [providedArrow, providedContextArrow]);
+};
+var _default = exports.default = useMergedArrow;

package/lib/tooltip/index.d.ts

@@ -0,0 +1,95 @@
+import * as React from 'react';
+import RcTooltip from '@rc-component/tooltip';
+import type { PresetColorType } from '../_util/colors';
+import type { RenderFunction } from '../_util/getRenderPropValue';
+import type { GenerateSemantic } from '../_util/hooks/useMergeSemantic/semanticType';
+import type { AdjustOverflow, PlacementsConfig } from '../_util/placements';
+import type { LiteralUnion } from '../_util/type';
+import PurePanel from './PurePanel';
+import UniqueProvider from './UniqueProvider';
+type RcTooltipProps = React.ComponentPropsWithoutRef<typeof RcTooltip>;
+type Placements = NonNullable<RcTooltipProps['builtinPlacements']>;
+export type { AdjustOverflow, PlacementsConfig };
+export interface TooltipRef {
+    forceAlign: VoidFunction;
+    /** Wrapped dom element. Not promise valid if child not support ref */
+    nativeElement: HTMLElement;
+    /** Popup dom element */
+    popupElement: HTMLDivElement;
+}
+export type TooltipPlacement = 'top' | 'left' | 'right' | 'bottom' | 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight' | 'leftTop' | 'leftBottom' | 'rightTop' | 'rightBottom';
+export interface TooltipAlignConfig {
+    points?: [string, string];
+    offset?: [number | string, number | string];
+    targetOffset?: [number | string, number | string];
+    overflow?: {
+        adjustX: boolean;
+        adjustY: boolean;
+    };
+    useCssRight?: boolean;
+    useCssBottom?: boolean;
+    useCssTransform?: boolean;
+}
+interface LegacyTooltipProps extends Partial<Omit<RcTooltipProps, 'children' | 'visible' | 'defaultVisible' | 'onVisibleChange' | 'afterVisibleChange' | 'destroyTooltipOnHide' | 'classNames' | 'styles'>> {
+    open?: RcTooltipProps['visible'];
+    defaultOpen?: RcTooltipProps['defaultVisible'];
+    onOpenChange?: RcTooltipProps['onVisibleChange'];
+    afterOpenChange?: RcTooltipProps['afterVisibleChange'];
+}
+export type TooltipSemanticType = {
+    classNames?: {
+        root?: string;
+        container?: string;
+        arrow?: string;
+    };
+    styles?: {
+        root?: React.CSSProperties;
+        container?: React.CSSProperties;
+        arrow?: React.CSSProperties;
+    };
+};
+export type TooltipSemanticAllType = GenerateSemantic<TooltipSemanticType, TooltipProps>;
+export interface AbstractTooltipProps extends LegacyTooltipProps {
+    style?: React.CSSProperties;
+    className?: string;
+    rootClassName?: string;
+    color?: LiteralUnion<PresetColorType>;
+    placement?: TooltipPlacement;
+    builtinPlacements?: Placements;
+    openClassName?: string;
+    arrow?: boolean | {
+        pointAtCenter?: boolean;
+    };
+    autoAdjustOverflow?: boolean | AdjustOverflow;
+    getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    children?: React.ReactNode;
+    /**
+     * @since 5.25.0
+     */
+    destroyOnHidden?: boolean;
+    /** @deprecated Please use `destroyOnHidden` instead */
+    destroyTooltipOnHide?: boolean | {
+        keepParent?: boolean;
+    };
+    /** @deprecated Please use `styles.root` instead */
+    overlayStyle?: React.CSSProperties;
+    /** @deprecated Please use `styles.container` instead */
+    overlayInnerStyle?: React.CSSProperties;
+    /** @deprecated Please use `classNames.root` instead */
+    overlayClassName?: string;
+}
+export interface TooltipProps extends AbstractTooltipProps {
+    title?: React.ReactNode | RenderFunction;
+    overlay?: React.ReactNode | RenderFunction;
+    classNames?: TooltipSemanticAllType['classNamesAndFn'];
+    styles?: TooltipSemanticAllType['stylesAndFn'];
+}
+interface InternalTooltipProps extends TooltipProps {
+}
+declare const InternalTooltip: React.ForwardRefExoticComponent<InternalTooltipProps & React.RefAttributes<TooltipRef>>;
+type CompoundedComponent = typeof InternalTooltip & {
+    _InternalPanelDoNotUseOrYouWillBeFired: typeof PurePanel;
+    UniqueProvider: typeof UniqueProvider;
+};
+declare const Tooltip: CompoundedComponent;
+export default Tooltip;

package/lib/tooltip/index.js

@@ -0,0 +1,244 @@
+"use strict";
+"use client";
+
+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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var React = _interopRequireWildcard(require("react"));
+var _tooltip = _interopRequireDefault(require("@rc-component/tooltip"));
+var _util = require("@rc-component/util");
+var _clsx2 = require("clsx");
+var _ContextIsolator = _interopRequireDefault(require("../_util/ContextIsolator"));
+var _hooks = require("../_util/hooks");
+var _useMergeSemantic3 = require("../_util/hooks/useMergeSemantic");
+var _is = require("../_util/is");
+var _motion = require("../_util/motion");
+var _placements = _interopRequireDefault(require("../_util/placements"));
+var _reactNode = require("../_util/reactNode");
+var _warning = require("../_util/warning");
+var _zindexContext = _interopRequireDefault(require("../_util/zindexContext"));
+var _context = require("../config-provider/context");
+var _useCSSVarCls = _interopRequireDefault(require("../config-provider/hooks/useCSSVarCls"));
+var _TableMeasureRowContext = _interopRequireDefault(require("../table/TableMeasureRowContext"));
+var _internal = require("../theme/internal");
+var _useMergedArrow = _interopRequireDefault(require("./hook/useMergedArrow"));
+var _PurePanel = _interopRequireDefault(require("./PurePanel"));
+var _style = _interopRequireDefault(require("./style"));
+var _UniqueProvider = _interopRequireDefault(require("./UniqueProvider"));
+var _util2 = require("./util");
+var _excluded = ["prefixCls", "openClassName", "getTooltipContainer", "color", "children", "afterOpenChange", "arrow", "destroyTooltipOnHide", "destroyOnHidden", "title", "overlay", "trigger", "builtinPlacements", "autoAdjustOverflow", "motion", "getPopupContainer", "placement", "mouseEnterDelay", "mouseLeaveDelay", "rootClassName", "styles", "classNames", "onOpenChange", "overlayInnerStyle", "overlayStyle", "overlayClassName"],
+  _excluded2 = ["getPopupContainer", "getPrefixCls", "direction"];
+var InternalTooltip = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var _props$defaultOpen;
+  var customizePrefixCls = props.prefixCls,
+    openClassName = props.openClassName,
+    getTooltipContainer = props.getTooltipContainer,
+    color = props.color,
+    children = props.children,
+    afterOpenChange = props.afterOpenChange,
+    tooltipArrow = props.arrow,
+    destroyTooltipOnHide = props.destroyTooltipOnHide,
+    destroyOnHidden = props.destroyOnHidden,
+    title = props.title,
+    overlay = props.overlay,
+    trigger = props.trigger,
+    builtinPlacements = props.builtinPlacements,
+    _props$autoAdjustOver = props.autoAdjustOverflow,
+    autoAdjustOverflow = _props$autoAdjustOver === void 0 ? true : _props$autoAdjustOver,
+    motion = props.motion,
+    getPopupContainer = props.getPopupContainer,
+    _props$placement = props.placement,
+    placement = _props$placement === void 0 ? 'top' : _props$placement,
+    _props$mouseEnterDela = props.mouseEnterDelay,
+    mouseEnterDelay = _props$mouseEnterDela === void 0 ? 0.1 : _props$mouseEnterDela,
+    _props$mouseLeaveDela = props.mouseLeaveDelay,
+    mouseLeaveDelay = _props$mouseLeaveDela === void 0 ? 0.1 : _props$mouseLeaveDela,
+    rootClassName = props.rootClassName,
+    styles = props.styles,
+    classNames = props.classNames,
+    onOpenChange = props.onOpenChange,
+    overlayInnerStyle = props.overlayInnerStyle,
+    overlayStyle = props.overlayStyle,
+    overlayClassName = props.overlayClassName,
+    restProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+  var _useToken = (0, _internal.useToken)(),
+    _useToken2 = (0, _slicedToArray2.default)(_useToken, 2),
+    token = _useToken2[1];
+  var injectFromPopover = props['data-popover-inject'];
+  var _useComponentConfig = (0, _context.useComponentConfig)('tooltip'),
+    getContextPopupContainer = _useComponentConfig.getPopupContainer,
+    getPrefixCls = _useComponentConfig.getPrefixCls,
+    direction = _useComponentConfig.direction,
+    semanticConfig = (0, _objectWithoutProperties2.default)(_useComponentConfig, _excluded2);
+  // When injected from Popover/Popconfirm, skip tooltip-specific semantic config
+  // to prevent ConfigProvider tooltip config from leaking into those components
+  var _ref = injectFromPopover ? {} : semanticConfig,
+    contextClassName = _ref.className,
+    contextStyle = _ref.style,
+    contextClassNames = _ref.classNames,
+    contextStyles = _ref.styles,
+    contextArrow = _ref.arrow,
+    contextTrigger = _ref.trigger;
+  var mergedArrow = (0, _useMergedArrow.default)(tooltipArrow, contextArrow);
+  var mergedShowArrow = mergedArrow.show;
+  var mergedTrigger = trigger || contextTrigger || 'hover';
+  var mergedGetPopupContainer = getPopupContainer || getContextPopupContainer;
+  var mergedDestroyOnHidden = destroyOnHidden !== null && destroyOnHidden !== void 0 ? destroyOnHidden : !!destroyTooltipOnHide;
+  var inTableMeasureRow = React.useContext(_TableMeasureRowContext.default);
+  // ============================== Ref ===============================
+  var warning = (0, _warning.devUseWarning)('Tooltip');
+  var tooltipRef = React.useRef(null);
+  var forceAlign = function forceAlign() {
+    var _tooltipRef$current;
+    (_tooltipRef$current = tooltipRef.current) === null || _tooltipRef$current === void 0 || _tooltipRef$current.forceAlign();
+  };
+  React.useImperativeHandle(ref, function () {
+    var _tooltipRef$current2, _tooltipRef$current3;
+    return {
+      forceAlign: forceAlign,
+      nativeElement: (_tooltipRef$current2 = tooltipRef.current) === null || _tooltipRef$current2 === void 0 ? void 0 : _tooltipRef$current2.nativeElement,
+      popupElement: (_tooltipRef$current3 = tooltipRef.current) === null || _tooltipRef$current3 === void 0 ? void 0 : _tooltipRef$current3.popupElement
+    };
+  });
+  // ============================== Warn ==============================
+  if (process.env.NODE_ENV !== 'production') {
+    [['overlayStyle', 'styles.root'], ['overlayInnerStyle', 'styles.container'], ['overlayClassName', 'classNames.root'], ['destroyTooltipOnHide', 'destroyOnHidden']].forEach(function (_ref2) {
+      var _ref3 = (0, _slicedToArray2.default)(_ref2, 2),
+        deprecatedName = _ref3[0],
+        newName = _ref3[1];
+      warning.deprecated(!(deprecatedName in props), deprecatedName, newName);
+    });
+    process.env.NODE_ENV !== "production" ? warning(!destroyTooltipOnHide || typeof destroyTooltipOnHide === 'boolean', 'usage', '`destroyTooltipOnHide` no need config `keepParent` anymore. Please use `boolean` value directly.') : void 0;
+  }
+  // ============================== Open ==============================
+  var _useControlledState = (0, _util.useControlledState)((_props$defaultOpen = props.defaultOpen) !== null && _props$defaultOpen !== void 0 ? _props$defaultOpen : false, props.open),
+    _useControlledState2 = (0, _slicedToArray2.default)(_useControlledState, 2),
+    open = _useControlledState2[0],
+    setOpen = _useControlledState2[1];
+  var noTitle = !title && !overlay && title !== 0; // overlay for old version compatibility
+  var onInternalOpenChange = function onInternalOpenChange(vis) {
+    setOpen(noTitle ? false : vis);
+    if (!noTitle && onOpenChange) {
+      onOpenChange(vis);
+    }
+  };
+  var tooltipPlacements = React.useMemo(function () {
+    var _mergedArrow$pointAtC;
+    return builtinPlacements || (0, _placements.default)({
+      arrowPointAtCenter: (_mergedArrow$pointAtC = mergedArrow === null || mergedArrow === void 0 ? void 0 : mergedArrow.pointAtCenter) !== null && _mergedArrow$pointAtC !== void 0 ? _mergedArrow$pointAtC : false,
+      autoAdjustOverflow: autoAdjustOverflow,
+      arrowWidth: mergedShowArrow ? token.sizePopupArrow : 0,
+      borderRadius: token.borderRadius,
+      offset: token.marginXXS,
+      visibleFirst: true
+    });
+  }, [mergedArrow, builtinPlacements, token, mergedShowArrow, autoAdjustOverflow]);
+  var memoOverlay = React.useMemo(function () {
+    if (title === 0) {
+      return title;
+    }
+    return overlay || title || '';
+  }, [overlay, title]);
+  var memoOverlayWrapper = /*#__PURE__*/React.createElement(_ContextIsolator.default, {
+    space: true,
+    form: true
+  }, (0, _is.isFunction)(memoOverlay) ? memoOverlay() : memoOverlay);
+  // =========== Merged Props for Semantic ===========
+  var mergedProps = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, props), {}, {
+    trigger: mergedTrigger,
+    builtinPlacements: tooltipPlacements,
+    getPopupContainer: mergedGetPopupContainer,
+    destroyOnHidden: mergedDestroyOnHidden
+  });
+  var _useMergeSemantic = (0, _useMergeSemantic3.useMergeSemantic)([contextClassNames, classNames], [contextStyles, styles], {
+      props: mergedProps
+    }),
+    _useMergeSemantic2 = (0, _slicedToArray2.default)(_useMergeSemantic, 2),
+    mergedClassNames = _useMergeSemantic2[0],
+    mergedStyles = _useMergeSemantic2[1];
+  var prefixCls = getPrefixCls('tooltip', customizePrefixCls);
+  var rootPrefixCls = getPrefixCls();
+  var tempOpen = open;
+  // Hide tooltip when there is no title or in table measure row
+  if (!('open' in props) && noTitle || inTableMeasureRow) {
+    tempOpen = false;
+  }
+  // ============================= Render =============================
+  var child = /*#__PURE__*/React.isValidElement(children) && !(0, _reactNode.isFragment)(children) ? children : /*#__PURE__*/React.createElement("span", null, children);
+  var childProps = child.props;
+  var childCls = !childProps.className || typeof childProps.className === 'string' ? (0, _clsx2.clsx)(childProps.className, openClassName || "".concat(prefixCls, "-open")) : childProps.className;
+  // Style
+  var rootCls = (0, _useCSSVarCls.default)(prefixCls);
+  var _useStyle = (0, _style.default)(prefixCls, rootCls, !injectFromPopover),
+    _useStyle2 = (0, _slicedToArray2.default)(_useStyle, 2),
+    hashId = _useStyle2[0],
+    cssVarCls = _useStyle2[1];
+  // Color
+  var colorInfo = (0, _util2.parseColor)(rootPrefixCls, prefixCls, color);
+  var arrowContentStyle = colorInfo.arrowStyle;
+  var themeCls = (0, _clsx2.clsx)(rootCls, hashId, cssVarCls);
+  var rootClassNames = (0, _clsx2.clsx)(overlayClassName, (0, _defineProperty2.default)({}, "".concat(prefixCls, "-rtl"), direction === 'rtl'), colorInfo.className, rootClassName, themeCls, contextClassName, mergedClassNames.root);
+  // ============================ zIndex ============================
+  var _useZIndex = (0, _hooks.useZIndex)('Tooltip', restProps.zIndex),
+    _useZIndex2 = (0, _slicedToArray2.default)(_useZIndex, 2),
+    zIndex = _useZIndex2[0],
+    contextZIndex = _useZIndex2[1];
+  var containerStyle = (0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, mergedStyles.container), overlayInnerStyle), colorInfo.overlayStyle);
+  var content = /*#__PURE__*/React.createElement(_tooltip.default, (0, _objectSpread2.default)((0, _objectSpread2.default)({
+    unique: true
+  }, restProps), {}, {
+    zIndex: zIndex,
+    showArrow: mergedShowArrow,
+    placement: placement,
+    mouseEnterDelay: mouseEnterDelay,
+    mouseLeaveDelay: mouseLeaveDelay,
+    prefixCls: prefixCls,
+    classNames: {
+      root: rootClassNames,
+      container: mergedClassNames.container,
+      arrow: mergedClassNames.arrow,
+      uniqueContainer: (0, _clsx2.clsx)(themeCls, mergedClassNames.container)
+    },
+    styles: {
+      root: (0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({}, arrowContentStyle), mergedStyles.root), contextStyle), overlayStyle),
+      container: containerStyle,
+      uniqueContainer: containerStyle,
+      arrow: mergedStyles.arrow
+    },
+    ref: tooltipRef,
+    overlay: memoOverlayWrapper,
+    visible: tempOpen,
+    onVisibleChange: onInternalOpenChange,
+    afterVisibleChange: afterOpenChange,
+    arrowContent: /*#__PURE__*/React.createElement("span", {
+      className: "".concat(prefixCls, "-arrow-content")
+    }),
+    motion: {
+      motionName: (0, _motion.getTransitionName)(rootPrefixCls, 'zoom-big-fast', typeof (motion === null || motion === void 0 ? void 0 : motion.motionName) === 'string' ? motion === null || motion === void 0 ? void 0 : motion.motionName : undefined),
+      motionDeadline: 1000
+    },
+    trigger: mergedTrigger,
+    builtinPlacements: tooltipPlacements,
+    getTooltipContainer: mergedGetPopupContainer,
+    destroyOnHidden: mergedDestroyOnHidden
+  }), tempOpen ? (0, _reactNode.cloneElement)(child, {
+    className: childCls
+  }) : child);
+  return /*#__PURE__*/React.createElement(_zindexContext.default.Provider, {
+    value: contextZIndex
+  }, content);
+});
+var Tooltip = InternalTooltip;
+if (process.env.NODE_ENV !== 'production') {
+  Tooltip.displayName = 'Tooltip';
+}
+Tooltip._InternalPanelDoNotUseOrYouWillBeFired = _PurePanel.default;
+Tooltip.UniqueProvider = _UniqueProvider.default;
+var _default = exports.default = Tooltip;