maycur-business/lib/Tippy/js/tippy.js

maycur business react components of web

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _globals = require("./core/globals");

var _reactDom = _interopRequireDefault(require("react-dom"));

var _init = _interopRequireDefault(require("./core/init"));

var _defer = _interopRequireDefault(require("./utils/defer"));

var _find = _interopRequireDefault(require("./utils/find"));

var _findIndex = _interopRequireDefault(require("./utils/findIndex"));

var _removeTitle = _interopRequireDefault(require("./utils/removeTitle"));

var _elementIsInViewport = _interopRequireDefault(require("./utils/elementIsInViewport"));

var _triggerReflow = _interopRequireDefault(require("./utils/triggerReflow"));

var _modifyClassList = _interopRequireDefault(require("./utils/modifyClassList"));

var _getInnerElements4 = _interopRequireDefault(require("./utils/getInnerElements"));

var _applyTransitionDuration = _interopRequireDefault(require("./utils/applyTransitionDuration"));

var _isVisible = _interopRequireDefault(require("./utils/isVisible"));

var _noop = _interopRequireDefault(require("./utils/noop"));

var _followCursorHandler = _interopRequireDefault(require("./core/followCursorHandler"));

var _getArrayOfElements = _interopRequireDefault(require("./core/getArrayOfElements"));

var _onTransitionEnd = _interopRequireDefault(require("./core/onTransitionEnd"));

var _mountPopper = _interopRequireDefault(require("./core/mountPopper"));

var _makeSticky = _interopRequireDefault(require("./core/makeSticky"));

var _createTooltips = _interopRequireDefault(require("./core/createTooltips"));

var _utils = _interopRequireDefault(require("../../utils/utils"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

var prefix = _utils["default"].prefixCls;
/**
* @param {String|Element|Element[]} selector
* @param {Object} settings (optional) - the object of settings to be applied to the instance
*/

var Tippy =
/*#__PURE__*/
function () {
  function Tippy(selector) {
    var settings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    _classCallCheck(this, Tippy);

    // Use default browser tooltip on unsupported browsers
    if (!_globals.Browser.SUPPORTED) return;
    (0, _init["default"])();
    this.state = {
      destroyed: false
    };
    this.selector = selector;
    this.hide = this.hide;
    this.destroy = this.destroy;
    this.settings = _objectSpread({}, _globals.Defaults, {}, settings);

    if (settings.show || settings.shown || settings.hide || settings.hidden) {
      console.warn('Callbacks without the `on` prefix are deprecated (with the exception of `wait`).' + ' Use onShow, onShown, onHide, and onHidden instead.');
    }

    this.callbacks = {
      wait: settings.wait,
      show: settings.onShow || settings.show || _noop["default"],
      shown: settings.onShown || settings.shown || _noop["default"],
      hide: settings.onHide || settings.hide || _noop["default"],
      hidden: settings.onHidden || settings.hidden || _noop["default"]
    };
    this.store = _createTooltips["default"].call(this, (0, _getArrayOfElements["default"])(selector));

    _globals.Store.push.apply(_globals.Store, this.store);
  }
  /**
  * Returns the reference element's popper element
  * @param {Element} el
  * @return {Element}
  */


  _createClass(Tippy, [{
    key: "getPopperElement",
    value: function getPopperElement(el) {
      try {
        return (0, _find["default"])(this.store, function (data) {
          return data.el === el;
        }).popper;
      } catch (e) {
        console.error('[getPopperElement]: Element passed as the argument does not exist in the instance');
      }
    }
    /**
    * Returns a popper's reference element
    * @param {Element} popper
    * @return {Element}
    */

  }, {
    key: "getReferenceElement",
    value: function getReferenceElement(popper) {
      try {
        return (0, _find["default"])(this.store, function (data) {
          return data.popper === popper;
        }).el;
      } catch (e) {
        console.error('[getReferenceElement]: Popper passed as the argument does not exist in the instance');
      }
    }
    /**
    * Returns the reference data object from either the reference element or popper element
    * @param {Element} x (reference element or popper)
    * @return {Object}
    */

  }, {
    key: "getReferenceData",
    value: function getReferenceData(x) {
      return (0, _find["default"])(this.store, function (data) {
        return data.el === x || data.popper === x;
      });
    }
    /**
    * Update settings
    * @param {DOMElement} - popper
    * @param {string} - name
    * @param {string} - value
    */

  }, {
    key: "updateSettings",
    value: function updateSettings(popper, name, value) {
      var data = (0, _find["default"])(this.store, function (data) {
        return data.popper === popper;
      });
      if (!data) return;

      var newSettings = _objectSpread({}, data.settings, _defineProperty({}, name, value));

      data.settings = newSettings;
    }
  }, {
    key: "updateForReact",

    /**
    * Update for React
    * @param {DOMElement} - popper
    * @param {ReactElement} - content
    */
    value: function updateForReact(popper, updatedContent) {
      var tooltipContent = popper.querySelector(_globals.Selectors.CONTENT);
      var data = (0, _find["default"])(this.store, function (data) {
        return data.popper === popper;
      });
      if (!data) return;
      var useContext = data.settings.useContext;

      if (useContext) {
        _reactDom["default"].unstable_renderSubtreeIntoContainer(data.settings.reactInstance, updatedContent, tooltipContent);
      } else {
        _reactDom["default"].render(updatedContent, tooltipContent);
      }
    }
    /**
    * Shows a popper
    * @param {Element} popper
    * @param {Number} customDuration (optional)
    */

  }, {
    key: "show",
    value: function show(popper, customDuration) {
      var _this = this;

      if (this.state.destroyed) return;
      var data = (0, _find["default"])(this.store, function (data) {
        return data.popper === popper;
      });
      if (!data) return;

      var _getInnerElements = (0, _getInnerElements4["default"])(popper),
          tooltip = _getInnerElements.tooltip,
          circle = _getInnerElements.circle,
          content = _getInnerElements.content;

      if (!document.body.contains(data.el)) {
        this.destroy(popper);
        return;
      }

      this.callbacks.show.call(popper); // Custom react

      if (data.settings && data.settings.open === false) {
        return;
      }

      if (data.settings.reactDOM) {
        this.updateForReact(popper, data.settings.reactDOM);
      } // end: Custom react


      var el = data.el,
          _data$settings = data.settings,
          sticky = _data$settings.sticky,
          interactive = _data$settings.interactive,
          followCursor = _data$settings.followCursor,
          flipDuration = _data$settings.flipDuration,
          duration = _data$settings.duration,
          dynamicTitle = _data$settings.dynamicTitle;

      if (dynamicTitle) {
        var title = el.getAttribute('title');

        if (title) {
          content.innerHTML = title;
          (0, _removeTitle["default"])(el);
        }
      }

      var _duration = customDuration !== undefined ? customDuration : Array.isArray(duration) ? duration[0] : duration; // Prevent a transition when popper changes position


      (0, _applyTransitionDuration["default"])([popper, tooltip, circle], 0);
      (0, _mountPopper["default"])(data);
      popper.style.visibility = 'visible';
      popper.setAttribute('aria-hidden', 'false'); // Wait for popper's position to update

      (0, _defer["default"])(function () {
        // Sometimes the arrow will not be in the correct position, force another update
        if (!followCursor || _globals.Browser.touch) {
          data.popperInstance.update();
          (0, _applyTransitionDuration["default"])([popper], flipDuration);
        } // Re-apply transition durations


        (0, _applyTransitionDuration["default"])([tooltip, circle], _duration); // Make content fade out a bit faster than the tooltip if `animateFill`

        if (circle) content.style.opacity = 1; // Interactive tooltips receive a class of 'active'

        interactive && el.classList.add('active'); // Update popper's position on every animation frame

        sticky && (0, _makeSticky["default"])(data); // Repaint/reflow is required for CSS transition when appending

        (0, _triggerReflow["default"])(tooltip, circle);
        (0, _modifyClassList["default"])([tooltip, circle], function (list) {
          list.contains("".concat(prefix, "-tippy-notransition")) && list.remove("".concat(prefix, "-tippy-notransition"));
          list.remove('leave');
          list.add('enter');
        }); // Wait for transitions to complete

        (0, _onTransitionEnd["default"])(data, _duration, function () {
          if (!(0, _isVisible["default"])(popper) || data._onShownFired) return; // Focus interactive tooltips only

          interactive && popper.focus(); // Remove transitions from tooltip

          tooltip.classList.add("".concat(prefix, "-tippy-notransition")); // Prevents shown() from firing more than once from early transition cancellations

          data._onShownFired = true;

          _this.callbacks.shown.call(popper);
        });
      });
    }
    /**
    * Hides a popper
    * @param {Element} popper
    * @param {Number} customDuration (optional)
    */

  }, {
    key: "hide",
    value: function hide(popper, customDuration) {
      var _this2 = this;

      if (this.state.destroyed) return;
      this.callbacks.hide.call(popper);
      var data = (0, _find["default"])(this.store, function (data) {
        return data.popper === popper;
      });
      if (!data) return;

      var _getInnerElements2 = (0, _getInnerElements4["default"])(popper),
          tooltip = _getInnerElements2.tooltip,
          circle = _getInnerElements2.circle,
          content = _getInnerElements2.content; // custom react
      // Prevent hide if open


      if (data.settings.disabled === false && data.settings.open) {
        return;
      }

      var isUnmount = data && data.settings && data.settings.unmountHTMLWhenHide && data.settings.reactDOM; // end: custom react

      var el = data.el,
          _data$settings2 = data.settings,
          appendTo = _data$settings2.appendTo,
          interactive = _data$settings2.interactive,
          html = _data$settings2.html,
          trigger = _data$settings2.trigger,
          duration = _data$settings2.duration;

      var _duration = customDuration !== undefined ? customDuration : Array.isArray(duration) ? duration[1] : duration;

      data._onShownFired = false;
      interactive && el.classList.remove('active');
      popper.style.visibility = 'hidden';
      popper.setAttribute('aria-hidden', 'true');
      (0, _applyTransitionDuration["default"])([tooltip, circle, circle ? content : null], _duration);
      if (circle) content.style.opacity = 0;
      (0, _modifyClassList["default"])([tooltip, circle], function (list) {
        list.contains("".concat(prefix, "-tippy-tooltip")) && list.remove("".concat(prefix, "-tippy-notransition"));
        list.remove('enter');
        list.add('leave');
      }); // Re-focus click-triggered html elements
      // and the tooltipped element IS in the viewport (otherwise it causes unsightly scrolling
      // if the tooltip is closed and the element isn't in the viewport anymore)

      if (html && trigger.indexOf('click') !== -1 && (0, _elementIsInViewport["default"])(el)) {
        el.focus();
      } // Wait for transitions to complete


      (0, _onTransitionEnd["default"])(data, _duration, function () {
        // `isVisible` is not completely reliable to determine if we shouldn't
        // run the hidden callback, we need to check the computed opacity style.
        // This prevents glitchy behavior of the transition when quickly showing
        // and hiding a tooltip.
        if ((0, _isVisible["default"])(popper) || !appendTo.contains(popper) || getComputedStyle(tooltip).opacity === '1') return;
        el.removeEventListener('mousemove', _followCursorHandler["default"]);
        data.popperInstance.disableEventListeners();
        appendTo.removeChild(popper);

        _this2.callbacks.hidden.call(popper); // custom react


        if (isUnmount) {
          _reactDom["default"].unmountComponentAtNode(content);
        }
      });
    }
    /**
    * Updates a popper with new content
    * @param {Element} popper
    */

  }, {
    key: "update",
    value: function update(popper) {
      if (this.state.destroyed) return;
      var data = (0, _find["default"])(this.store, function (data) {
        return data.popper === popper;
      });
      if (!data) return;

      var _getInnerElements3 = (0, _getInnerElements4["default"])(popper),
          content = _getInnerElements3.content;

      var el = data.el,
          html = data.settings.html;

      if (html instanceof Element) {
        console.warn('Aborted: update() should not be used if `html` is a DOM element');
        return;
      }

      content.innerHTML = html ? document.getElementById(html.replace('#', '')).innerHTML : el.getAttribute('title') || el.getAttribute('data-original-title');
      if (!html) (0, _removeTitle["default"])(el);
    }
    /**
    * Destroys a popper
    * @param {Element} popper
    * @param {Boolean} _isLast - private param used by destroyAll to optimize
    */

  }, {
    key: "destroy",
    value: function destroy(popper, _isLast) {
      var _this3 = this;

      if (this.state.destroyed) return;
      var data = (0, _find["default"])(this.store, function (data) {
        return data.popper === popper;
      });
      if (!data) return;
      var el = data.el,
          popperInstance = data.popperInstance,
          listeners = data.listeners,
          _mutationObserver = data._mutationObserver; // Ensure the popper is hidden

      if ((0, _isVisible["default"])(popper)) {
        this.hide(popper, 0);
      } // Remove Tippy-only event listeners from tooltipped element


      listeners.forEach(function (listener) {
        return el.removeEventListener(listener.event, listener.handler);
      }); // Restore original title

      el.setAttribute('title', el.getAttribute('data-original-title'));
      el.removeAttribute('data-original-title');
      el.removeAttribute('data-tooltipped');
      el.removeAttribute('aria-describedby');
      popperInstance && popperInstance.destroy();
      _mutationObserver && _mutationObserver.disconnect(); // Remove from store

      _globals.Store.splice((0, _findIndex["default"])(_globals.Store, function (data) {
        return data.popper === popper;
      }), 1); // Ensure filter is called only once


      if (_isLast === undefined || _isLast) {
        this.store = _globals.Store.filter(function (data) {
          return data.tippyInstance === _this3;
        });
      }
    }
    /**
    * Destroys all tooltips created by the instance
    */

  }, {
    key: "destroyAll",
    value: function destroyAll() {
      var _this4 = this;

      if (this.state.destroyed) return;
      var storeLength = this.store.length;
      this.store.forEach(function (_ref, index) {
        var popper = _ref.popper;

        _this4.destroy(popper, index === storeLength - 1);
      });
      this.store = null;
      this.state.destroyed = true;
    }
  }]);

  return Tippy;
}();

function tippy(selector, settings) {
  return new Tippy(selector, settings);
}

tippy.Browser = _globals.Browser;
tippy.Defaults = _globals.Defaults;

tippy.disableDynamicInputDetection = function () {
  return _globals.Browser.dynamicInputDetection = false;
};

tippy.enableDynamicInputDetection = function () {
  return _globals.Browser.dynamicInputDetection = true;
};

var _default = tippy;
exports["default"] = _default;