choerodon-ui/pro/es/tooltip/singleton.js

import _regeneratorRuntime from "@babel/runtime/regenerator";
import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import _extends from "@babel/runtime/helpers/extends";
import _objectSpread from "@babel/runtime/helpers/objectSpread2";
import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
import React, { createRef, forwardRef, useCallback, useImperativeHandle, useMemo, useState } from 'react';
import { render } from 'react-dom';
import { getTooltipTheme } from '../../../es/_util/TooltipUtils';
import { getProPrefixCls } from '../../../es/configure';
import { getGlobalPopupContainer } from '../../../es/trigger/Popup';
import Tooltip from './Tooltip';
import TaskRunner from '../_util/TaskRunner';
export var suffixCls = 'singleton-tooltip';
var manager = {};
var TooltipContainer = forwardRef(function (_, ref) {
  var task = useMemo(function () {
    return new TaskRunner();
  }, []);

  var _useState = useState(),
      _useState2 = _slicedToArray(_useState, 2),
      tooltipProps = _useState2[0],
      setTooltipProps = _useState2[1];

  var open = useCallback(function (target, args) {
    var duration = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 100;
    task.cancel();
    task.delay(duration, function () {
      setTooltipProps(_objectSpread({
        theme: getTooltipTheme()
      }, args, {
        hidden: false,
        getRootDomNode: function getRootDomNode() {
          return target;
        }
      }));
    });
    return task;
  }, [task]);
  var close = useCallback(function () {
    var duration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 100;
    task.cancel();
    task.delay(duration, function () {
      setTooltipProps(function (preState) {
        return _objectSpread({}, preState, {
          hidden: true
        });
      });
    });
    return task;
  }, [task]);
  var handlePopupMouseEnter = useCallback(function () {
    task.cancel();
  }, [task]);
  var handlePopupMouseLeave = useCallback(function () {
    close();
  }, [close]);
  useImperativeHandle(ref, function () {
    return {
      open: open,
      close: close
    };
  }, [open, close]);
  return React.createElement(Tooltip, _extends({}, tooltipProps, {
    onPopupMouseEnter: handlePopupMouseEnter,
    onPopupMouseLeave: handlePopupMouseLeave
  }));
});

function getRoot() {
  var root = manager.root;

  if (typeof window !== 'undefined') {
    var popupContainer = getGlobalPopupContainer();
    var doc = window.document;

    if (root) {
      if (!root.parentNode) {
        popupContainer.appendChild(root);
      }
    } else {
      root = doc.createElement('div');
      root.className = "".concat(getProPrefixCls(suffixCls), "-container");
      popupContainer.appendChild(root);
      manager.root = root;
    }
  }

  return root;
}

function getContainer() {
  return _getContainer.apply(this, arguments);
}

function _getContainer() {
  _getContainer = _asyncToGenerator(
  /*#__PURE__*/
  _regeneratorRuntime.mark(function _callee() {
    var container;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            container = manager.container;

            if (!container) {
              _context.next = 3;
              break;
            }

            return _context.abrupt("return", container);

          case 3:
            return _context.abrupt("return", new Promise(function (resolve) {
              var root = getRoot();

              if (root) {
                var ref = createRef();
                manager.container = ref;
                render(React.createElement(TooltipContainer, {
                  ref: ref
                }), root, function () {
                  return resolve(ref);
                });
              }
            }));

          case 4:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _getContainer.apply(this, arguments);
}

export function show(_x, _x2, _x3) {
  return _show.apply(this, arguments);
}

function _show() {
  _show = _asyncToGenerator(
  /*#__PURE__*/
  _regeneratorRuntime.mark(function _callee2(target, props, duration) {
    var container, current;
    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            _context2.next = 2;
            return getContainer();

          case 2:
            container = _context2.sent;
            current = container.current;

            if (!current) {
              _context2.next = 6;
              break;
            }

            return _context2.abrupt("return", current.open(target, props, duration));

          case 6:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));
  return _show.apply(this, arguments);
}

export function hide(_x4) {
  return _hide.apply(this, arguments);
}

function _hide() {
  _hide = _asyncToGenerator(
  /*#__PURE__*/
  _regeneratorRuntime.mark(function _callee3(duration) {
    var container, current;
    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            _context3.next = 2;
            return getContainer();

          case 2:
            container = _context3.sent;
            current = container.current;

            if (!current) {
              _context3.next = 6;
              break;
            }

            return _context3.abrupt("return", current.close(duration));

          case 6:
          case "end":
            return _context3.stop();
        }
      }
    }, _callee3);
  }));
  return _hide.apply(this, arguments);
}
//# sourceMappingURL=singleton.js.map