tippy.js - npm Package Compare versions
Comparing version 5.2.0 to 6.0.0-alpha.0
| /**! | ||
| * tippy.js v5.2.0 | ||
| * tippy.js v6.0.0-alpha.0 | ||
| * (c) 2017-2020 atomiks | ||
| * MIT License | ||
| */ | ||
| import { e as errorWhen, _ as _extends, d as defaultProps, t as tippy, a as div, r as removeProperties, n as normalizeToArray, i as includes, b as isUCBrowser, s as setVisibilityState, w as warnWhen, B as BACKDROP_CLASS, g as getOwnerDocument, c as isMouseEvent, u as useIfDefined, f as currentInput, h as closestCallback, j as getBasePlacement, k as arrayFrom } from './tippy.chunk.esm.js'; | ||
| export { m as createTippyWithPlugins, t as default, l as hideAll, R as roundArrow } from './tippy.chunk.esm.js'; | ||
| import 'popper.js'; | ||
| import { createPopper } from '@popperjs/core'; | ||
| function hasOwnProperty(obj, key) { | ||
| return {}.hasOwnProperty.call(obj, key); | ||
| } | ||
| function getValueAtIndexOrReturn(value, index, defaultValue) { | ||
| if (Array.isArray(value)) { | ||
| var v = value[index]; | ||
| return v == null ? Array.isArray(defaultValue) ? defaultValue[index] : defaultValue : v; | ||
| } | ||
| return value; | ||
| } | ||
| function isType(value, type) { | ||
| var str = {}.toString.call(value); | ||
| return str.indexOf('[object') === 0 && str.indexOf(type + "]") > -1; | ||
| } | ||
| function invokeWithArgsOrReturn(value, args) { | ||
| return typeof value === 'function' ? value.apply(void 0, args) : value; | ||
| } | ||
| function debounce(fn, ms) { | ||
| // Avoid wrapping in `setTimeout` if ms is 0 anyway | ||
| if (ms === 0) { | ||
| return fn; | ||
| } | ||
| var timeout; | ||
| return function (arg) { | ||
| clearTimeout(timeout); | ||
| timeout = setTimeout(function () { | ||
| fn(arg); | ||
| }, ms); | ||
| }; | ||
| } | ||
| function removeProperties(obj, keys) { | ||
| var clone = Object.assign({}, obj); | ||
| keys.forEach(function (key) { | ||
| delete clone[key]; | ||
| }); | ||
| return clone; | ||
| } | ||
| function splitBySpaces(value) { | ||
| return value.split(/\s+/).filter(Boolean); | ||
| } | ||
| function normalizeToArray(value) { | ||
| return [].concat(value); | ||
| } | ||
| function pushIfUnique(arr, value) { | ||
| if (arr.indexOf(value) === -1) { | ||
| arr.push(value); | ||
| } | ||
| } | ||
| function unique(arr) { | ||
| return arr.filter(function (item, index) { | ||
| return arr.indexOf(item) === index; | ||
| }); | ||
| } | ||
| function mergeModifier(modifiers, name) { | ||
| return modifiers.filter(function (modifier) { | ||
| return modifier.name === name; | ||
| }).reduce(function (acc, modifier) { | ||
| return Object.assign({}, acc, {}, modifier, { | ||
| options: Object.assign({}, acc.options, {}, modifier.options) | ||
| }); | ||
| }, {}); | ||
| } | ||
| function getBasePlacement(placement) { | ||
| return placement.split('-')[0]; | ||
| } | ||
| function arrayFrom(value) { | ||
| return [].slice.call(value); | ||
| } | ||
| function createMemoryLeakWarning(method) { | ||
| var txt = method === 'destroy' ? 'n already-' : ' '; | ||
| return [method + "() was called on a" + txt + "destroyed instance. This is a no-op but", 'indicates a potential memory leak.'].join(' '); | ||
| } | ||
| function clean(value) { | ||
| var spacesAndTabs = /[ \t]{2,}/g; | ||
| var lineStartWithSpaces = /^[ \t]*/gm; | ||
| return value.replace(spacesAndTabs, ' ').replace(lineStartWithSpaces, '').trim(); | ||
| } | ||
| function getDevMessage(message) { | ||
| return clean("\n %ctippy.js\n\n %c" + clean(message) + "\n\n %c\uD83D\uDC77\u200D This is a development-only message. It will be removed in production.\n "); | ||
| } | ||
| function getFormattedMessage(message) { | ||
| return [getDevMessage(message), // title | ||
| 'color: #00C584; font-size: 1.3em; font-weight: bold;', // message | ||
| 'line-height: 1.5', // footer | ||
| 'color: #a6a095;']; | ||
| } | ||
| /** | ||
| * Re-uses a single tippy element for many different tippy instances. | ||
| * Replaces v4's `tippy.group()`. | ||
| * Helpful wrapper around `console.warn()`. | ||
| * TODO: Should we use a cache so it only warns a single time and not spam the | ||
| * console? (Need to consider hot reloading and invalidation though). Chrome | ||
| * already batches warnings as well. | ||
| */ | ||
| var createSingleton = function createSingleton(tippyInstances, optionalProps, | ||
| /** @deprecated use Props.plugins */ | ||
| plugins) { | ||
| if (optionalProps === void 0) { | ||
| optionalProps = {}; | ||
| function warnWhen(condition, message) { | ||
| if (condition) { | ||
| var _console; | ||
| (_console = console).warn.apply(_console, getFormattedMessage(message)); | ||
| } | ||
| } | ||
| /** | ||
| * Helpful wrapper around `console.error()` | ||
| */ | ||
| function errorWhen(condition, message) { | ||
| if (condition) { | ||
| var _console2; | ||
| (_console2 = console).error.apply(_console2, getFormattedMessage(message)); | ||
| } | ||
| } | ||
| /** | ||
| * Validates the `targets` value passed to `tippy()` | ||
| */ | ||
| function validateTargets(targets) { | ||
| var didPassFalsyValue = !targets; | ||
| var didPassPlainObject = Object.prototype.toString.call(targets) === '[object Object]' && !targets.addEventListener; | ||
| errorWhen(didPassFalsyValue, ['tippy() was passed', '`' + String(targets) + '`', 'as its targets (first) argument. Valid types are: String, Element,', 'Element[], or NodeList.'].join(' ')); | ||
| errorWhen(didPassPlainObject, ['tippy() was passed a plain object which is not supported as an argument', 'for virtual positioning. Use props.getReferenceClientRect instead.'].join(' ')); | ||
| } | ||
| var pluginProps = { | ||
| animateFill: false, | ||
| followCursor: false, | ||
| inlinePositioning: false, | ||
| sticky: false | ||
| }; | ||
| var renderProps = { | ||
| allowHTML: false, | ||
| animation: 'fade', | ||
| arrow: true, | ||
| content: '', | ||
| inertia: false, | ||
| maxWidth: 350, | ||
| role: 'tooltip', | ||
| theme: '', | ||
| zIndex: 9999 | ||
| }; | ||
| var defaultProps = Object.assign({ | ||
| appendTo: function appendTo() { | ||
| return document.body; | ||
| }, | ||
| aria: 'describedby', | ||
| content: '', | ||
| delay: 0, | ||
| duration: [300, 250], | ||
| getReferenceClientRect: null, | ||
| hideOnClick: true, | ||
| ignoreAttributes: false, | ||
| interactive: false, | ||
| interactiveBorder: 2, | ||
| interactiveDebounce: 0, | ||
| moveTransition: '', | ||
| offset: [0, 10], | ||
| onAfterUpdate: function onAfterUpdate() {}, | ||
| onBeforeUpdate: function onBeforeUpdate() {}, | ||
| onCreate: function onCreate() {}, | ||
| onDestroy: function onDestroy() {}, | ||
| onHidden: function onHidden() {}, | ||
| onHide: function onHide() {}, | ||
| onMount: function onMount() {}, | ||
| onShow: function onShow() {}, | ||
| onShown: function onShown() {}, | ||
| onTrigger: function onTrigger() {}, | ||
| onUntrigger: function onUntrigger() {}, | ||
| placement: 'top', | ||
| plugins: [], | ||
| popperOptions: {}, | ||
| render: null, | ||
| showOnCreate: false, | ||
| touch: true, | ||
| trigger: 'mouseenter focus', | ||
| triggerTarget: null | ||
| }, pluginProps, {}, renderProps); | ||
| var defaultKeys = Object.keys(defaultProps); | ||
| var setDefaultProps = function setDefaultProps(partialProps) { | ||
| /* istanbul ignore else */ | ||
| if (process.env.NODE_ENV !== "production") { | ||
| validateProps(partialProps, []); | ||
| } | ||
| var keys = Object.keys(partialProps); | ||
| keys.forEach(function (key) { | ||
| defaultProps[key] = partialProps[key]; | ||
| }); | ||
| }; | ||
| function getExtendedPassedProps(passedProps) { | ||
| var plugins = passedProps.plugins || []; | ||
| var pluginProps = plugins.reduce(function (acc, plugin) { | ||
| var name = plugin.name, | ||
| defaultValue = plugin.defaultValue; | ||
| if (name) { | ||
| acc[name] = passedProps[name] !== undefined ? passedProps[name] : defaultValue; | ||
| } | ||
| return acc; | ||
| }, {}); | ||
| return Object.assign({}, passedProps, {}, pluginProps); | ||
| } | ||
| function getDataAttributeProps(reference, plugins) { | ||
| var propKeys = plugins ? Object.keys(getExtendedPassedProps(Object.assign({}, defaultProps, { | ||
| plugins: plugins | ||
| }))) : defaultKeys; | ||
| var props = propKeys.reduce(function (acc, key) { | ||
| var valueAsString = (reference.getAttribute("data-tippy-" + key) || '').trim(); | ||
| if (!valueAsString) { | ||
| return acc; | ||
| } | ||
| if (key === 'content') { | ||
| acc[key] = valueAsString; | ||
| } else { | ||
| try { | ||
| acc[key] = JSON.parse(valueAsString); | ||
| } catch (e) { | ||
| acc[key] = valueAsString; | ||
| } | ||
| } | ||
| return acc; | ||
| }, {}); | ||
| return props; | ||
| } | ||
| function evaluateProps(reference, props) { | ||
| var out = Object.assign({}, props, {}, props.ignoreAttributes ? {} : getDataAttributeProps(reference, props.plugins)); | ||
| if (out.interactive) { | ||
| out.aria = null; | ||
| } | ||
| return out; | ||
| } | ||
| function validateProps(partialProps, plugins) { | ||
| if (partialProps === void 0) { | ||
| partialProps = {}; | ||
| } | ||
| if (plugins === void 0) { | ||
@@ -26,53 +257,1292 @@ plugins = []; | ||
| if (process.env.NODE_ENV !== "production") { | ||
| errorWhen(!Array.isArray(tippyInstances), ['The first argument passed to createSingleton() must be an array of tippy', 'instances. The passed value was', String(tippyInstances)].join(' ')); | ||
| var keys = Object.keys(partialProps); | ||
| keys.forEach(function (prop) { | ||
| var nonPluginProps = removeProperties(defaultProps, Object.keys(pluginProps)); | ||
| var didPassUnknownProp = !hasOwnProperty(nonPluginProps, prop); // Check if the prop exists in `plugins` | ||
| if (didPassUnknownProp) { | ||
| didPassUnknownProp = plugins.filter(function (plugin) { | ||
| return plugin.name === prop; | ||
| }).length === 0; | ||
| } | ||
| warnWhen(didPassUnknownProp, ["`" + prop + "`", "is not a valid prop. You may have spelled it incorrectly, or if it's", 'a plugin, forgot to pass it in an array as props.plugins.', '\n\n', 'All props: https://atomiks.github.io/tippyjs/all-props/\n', 'Plugins: https://atomiks.github.io/tippyjs/plugins/'].join(' ')); | ||
| }); | ||
| } | ||
| var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined'; | ||
| var ua = isBrowser ? navigator.userAgent : ''; | ||
| var isIE = /MSIE |Trident\//.test(ua); | ||
| var isIOS = isBrowser && /iPhone|iPad|iPod/.test(navigator.platform); | ||
| var PASSIVE = { | ||
| passive: true | ||
| }; | ||
| var ROUND_ARROW = '<svg width="16" height="6" xmlns="http://www.w3.org/2000/svg"><path d="M0 6s1.796-.013 4.67-3.615C5.851.9 6.93.006 8 0c1.07-.006 2.148.887 3.343 2.385C14.233 6.005 16 6 16 6H0z"></svg>'; | ||
| var IOS_CLASS = "tippy-iOS"; | ||
| var BOX_CLASS = "tippy-box"; | ||
| var CONTENT_CLASS = "tippy-content"; | ||
| var BACKDROP_CLASS = "tippy-backdrop"; | ||
| var ARROW_CLASS = "tippy-arrow"; | ||
| var SVG_ARROW_CLASS = "tippy-svg-arrow"; | ||
| function div() { | ||
| return document.createElement('div'); | ||
| } | ||
| function isElement(value) { | ||
| return isType(value, 'Element'); | ||
| } | ||
| function isNodeList(value) { | ||
| return isType(value, 'NodeList'); | ||
| } | ||
| function isMouseEvent(value) { | ||
| return isType(value, 'MouseEvent'); | ||
| } | ||
| function isReferenceElement(value) { | ||
| return !!(value && value._tippy && value._tippy.reference === value); | ||
| } | ||
| function getArrayOfElements(value) { | ||
| if (isElement(value)) { | ||
| return [value]; | ||
| } | ||
| plugins = optionalProps.plugins || plugins; | ||
| tippyInstances.forEach(function (instance) { | ||
| instance.disable(); | ||
| if (isNodeList(value)) { | ||
| return arrayFrom(value); | ||
| } | ||
| if (Array.isArray(value)) { | ||
| return value; | ||
| } | ||
| return arrayFrom(document.querySelectorAll(value)); | ||
| } | ||
| function setTransitionDuration(els, value) { | ||
| els.forEach(function (el) { | ||
| if (el) { | ||
| el.style.transitionDuration = value + "ms"; | ||
| } | ||
| }); | ||
| } | ||
| function setVisibilityState(els, state) { | ||
| els.forEach(function (el) { | ||
| if (el) { | ||
| el.setAttribute('data-state', state); | ||
| } | ||
| }); | ||
| } | ||
| function closestCallback(element, callback) { | ||
| while (element) { | ||
| if (callback(element)) { | ||
| return element; | ||
| } | ||
| var userAria = _extends({}, defaultProps, {}, optionalProps).aria; | ||
| element = element.parentElement; | ||
| } | ||
| var currentAria; | ||
| return null; | ||
| } | ||
| function getOwnerDocument(elementOrElements) { | ||
| var _normalizeToArray = normalizeToArray(elementOrElements), | ||
| element = _normalizeToArray[0]; | ||
| return element ? element.ownerDocument || document : document; | ||
| } | ||
| function isCursorOutsideInteractiveBorder(popperTreeData, event) { | ||
| var clientX = event.clientX, | ||
| clientY = event.clientY; | ||
| return popperTreeData.every(function (_ref) { | ||
| var basePlacement = _ref.basePlacement, | ||
| popperRect = _ref.popperRect, | ||
| props = _ref.props, | ||
| offsetData = _ref.offsetData; | ||
| var interactiveBorder = props.interactiveBorder; | ||
| var topDistance = basePlacement === 'bottom' ? offsetData.top.y : 0; | ||
| var bottomDistance = basePlacement === 'top' ? offsetData.bottom.y : 0; | ||
| var leftDistance = basePlacement === 'right' ? offsetData.left.x : 0; | ||
| var rightDistance = basePlacement === 'left' ? offsetData.right.x : 0; | ||
| var exceedsTop = popperRect.top - clientY + topDistance > interactiveBorder; | ||
| var exceedsBottom = clientY - popperRect.bottom - bottomDistance > interactiveBorder; | ||
| var exceedsLeft = popperRect.left - clientX + leftDistance > interactiveBorder; | ||
| var exceedsRight = clientX - popperRect.right - rightDistance > interactiveBorder; | ||
| return exceedsTop || exceedsBottom || exceedsLeft || exceedsRight; | ||
| }); | ||
| } | ||
| function updateTransitionEndListener(box, action, listener) { | ||
| var method = action + "EventListener"; // some browsers apparently support `transition` (unprefixed) but only fire | ||
| // `webkitTransitionEnd`... | ||
| ['transitionend', 'webkitTransitionEnd'].forEach(function (event) { | ||
| box[method](event, listener); | ||
| }); | ||
| } | ||
| var currentInput = { | ||
| isTouch: false | ||
| }; | ||
| var lastMouseMoveTime = 0; | ||
| /** | ||
| * When a `touchstart` event is fired, it's assumed the user is using touch | ||
| * input. We'll bind a `mousemove` event listener to listen for mouse input in | ||
| * the future. This way, the `isTouch` property is fully dynamic and will handle | ||
| * hybrid devices that use a mix of touch + mouse input. | ||
| */ | ||
| function onDocumentTouchStart() { | ||
| if (currentInput.isTouch) { | ||
| return; | ||
| } | ||
| currentInput.isTouch = true; | ||
| if (window.performance) { | ||
| document.addEventListener('mousemove', onDocumentMouseMove); | ||
| } | ||
| } | ||
| /** | ||
| * When two `mousemove` event are fired consecutively within 20ms, it's assumed | ||
| * the user is using mouse input again. `mousemove` can fire on touch devices as | ||
| * well, but very rarely that quickly. | ||
| */ | ||
| function onDocumentMouseMove() { | ||
| var now = performance.now(); | ||
| if (now - lastMouseMoveTime < 20) { | ||
| currentInput.isTouch = false; | ||
| document.removeEventListener('mousemove', onDocumentMouseMove); | ||
| } | ||
| lastMouseMoveTime = now; | ||
| } | ||
| /** | ||
| * When an element is in focus and has a tippy, leaving the tab/window and | ||
| * returning causes it to show again. For mouse users this is unexpected, but | ||
| * for keyboard use it makes sense. | ||
| * TODO: find a better technique to solve this problem | ||
| */ | ||
| function onWindowBlur() { | ||
| var activeElement = document.activeElement; | ||
| if (isReferenceElement(activeElement)) { | ||
| var instance = activeElement._tippy; | ||
| if (activeElement.blur && !instance.state.isVisible) { | ||
| activeElement.blur(); | ||
| } | ||
| } | ||
| } | ||
| function bindGlobalEventListeners() { | ||
| document.addEventListener('touchstart', onDocumentTouchStart, Object.assign({}, PASSIVE, { | ||
| capture: true | ||
| })); | ||
| window.addEventListener('blur', onWindowBlur); | ||
| } | ||
| var innerHTML = function innerHTML() { | ||
| return 'innerHTML'; | ||
| }; | ||
| function dangerouslySetInnerHTML(element, html) { | ||
| element[innerHTML()] = html; | ||
| } | ||
| function createArrowElement(value) { | ||
| var arrow = div(); | ||
| if (value === true) { | ||
| arrow.className = ARROW_CLASS; | ||
| } else { | ||
| arrow.className = SVG_ARROW_CLASS; | ||
| if (isElement(value)) { | ||
| arrow.appendChild(value); | ||
| } else { | ||
| dangerouslySetInnerHTML(arrow, value); | ||
| } | ||
| } | ||
| return arrow; | ||
| } | ||
| function setContent(content, _ref) { | ||
| var props = _ref.props, | ||
| reference = _ref.reference; | ||
| var computedContent = typeof props.content === 'function' ? props.content(reference) : props.content; | ||
| if (isElement(computedContent)) { | ||
| dangerouslySetInnerHTML(content, ''); | ||
| content.appendChild(computedContent); | ||
| } else { | ||
| if (props.allowHTML) { | ||
| dangerouslySetInnerHTML(content, computedContent); | ||
| } else { | ||
| content.textContent = computedContent; | ||
| } | ||
| } | ||
| } | ||
| function getChildren(popper) { | ||
| var box = popper.firstElementChild; | ||
| var boxChildren = arrayFrom(box.children); | ||
| return { | ||
| box: box, | ||
| content: boxChildren.find(function (node) { | ||
| return node.classList.contains(CONTENT_CLASS); | ||
| }), | ||
| arrow: boxChildren.find(function (node) { | ||
| return node.classList.contains(ARROW_CLASS) || node.classList.contains(SVG_ARROW_CLASS); | ||
| }) || null, | ||
| backdrop: boxChildren.find(function (node) { | ||
| return node.classList.contains(BACKDROP_CLASS); | ||
| }) || null | ||
| }; | ||
| } | ||
| function render(instance) { | ||
| var popper = div(); | ||
| var box = div(); | ||
| box.className = BOX_CLASS; | ||
| box.setAttribute('data-state', 'hidden'); | ||
| box.setAttribute('tabindex', '-1'); | ||
| var content = div(); | ||
| content.className = CONTENT_CLASS; | ||
| content.setAttribute('data-state', 'hidden'); | ||
| setContent(content, instance); | ||
| popper.appendChild(box); | ||
| box.appendChild(content); | ||
| update(instance.props, instance.props); | ||
| function update(prevProps, nextProps) { | ||
| var _getChildren = getChildren(popper), | ||
| box = _getChildren.box, | ||
| content = _getChildren.content, | ||
| arrow = _getChildren.arrow; | ||
| popper.style.zIndex = "" + nextProps.zIndex; | ||
| if (nextProps.theme) { | ||
| box.setAttribute('data-theme', nextProps.theme); | ||
| } else { | ||
| box.removeAttribute('data-theme'); | ||
| } | ||
| if (nextProps.animation) { | ||
| box.setAttribute('data-animation', nextProps.animation); | ||
| } else { | ||
| box.removeAttribute('data-animation'); | ||
| } | ||
| if (nextProps.inertia) { | ||
| box.setAttribute('data-inertia', ''); | ||
| } else { | ||
| box.removeAttribute('data-inertia'); | ||
| } | ||
| box.style.maxWidth = typeof nextProps.maxWidth === 'number' ? nextProps.maxWidth + "px" : nextProps.maxWidth; | ||
| if (nextProps.role) { | ||
| box.setAttribute('role', nextProps.role); | ||
| } else { | ||
| box.removeAttribute('role'); | ||
| } | ||
| if (prevProps.content !== nextProps.content) { | ||
| setContent(content, instance); | ||
| } | ||
| if (nextProps.arrow) { | ||
| if (!arrow) { | ||
| box.appendChild(createArrowElement(nextProps.arrow)); | ||
| } else if (prevProps.arrow !== nextProps.arrow) { | ||
| box.removeChild(arrow); | ||
| box.appendChild(createArrowElement(nextProps.arrow)); | ||
| } | ||
| } else if (arrow) { | ||
| box.removeChild(arrow); | ||
| } | ||
| } | ||
| return { | ||
| popper: popper, | ||
| update: update | ||
| }; | ||
| } // Runtime check to identify if the render function is the default one; this | ||
| // way we can apply default CSS transitions logic and it can be tree-shaken away | ||
| render.$$tippy = true; | ||
| function isDefaultRenderFn(render) { | ||
| // @ts-ignore | ||
| return render.$$tippy; | ||
| } | ||
| var idCounter = 1; | ||
| var mouseMoveListeners = []; // Used by `hideAll()` | ||
| var mountedInstances = []; | ||
| function createTippy(reference, passedProps) { | ||
| var props = evaluateProps(reference, Object.assign({}, defaultProps, {}, getExtendedPassedProps(passedProps))); // =========================================================================== | ||
| // 🔒 Private members | ||
| // =========================================================================== | ||
| var showTimeout; | ||
| var hideTimeout; | ||
| var scheduleHideAnimationFrame; | ||
| var isVisibleFromClick = false; | ||
| var didHideDueToDocumentMouseDown = false; | ||
| var ignoreOnFirstUpdate = false; | ||
| var lastTriggerEvent; | ||
| var currentTransitionEndListener; | ||
| var onFirstUpdate; | ||
| var listeners = []; | ||
| var debouncedOnMouseMove = debounce(onMouseMove, props.interactiveDebounce); | ||
| var currentTarget; | ||
| var shouldSkipUpdate = false; | ||
| var references = tippyInstances.map(function (instance) { | ||
| return instance.reference; | ||
| var doc = getOwnerDocument(props.triggerTarget || reference); // =========================================================================== | ||
| // 🔑 Public members | ||
| // =========================================================================== | ||
| var id = idCounter++; | ||
| var popperInstance = null; | ||
| var plugins = unique(props.plugins); | ||
| var state = { | ||
| // The current real placement (`data-placement` attribute) | ||
| currentPlacement: null, | ||
| // Is the instance currently enabled? | ||
| isEnabled: true, | ||
| // Is the tippy currently showing and not transitioning out? | ||
| isVisible: false, | ||
| // Has the instance been destroyed? | ||
| isDestroyed: false, | ||
| // Is the tippy currently mounted to the DOM? | ||
| isMounted: false, | ||
| // Has the tippy finished transitioning in? | ||
| isShown: false | ||
| }; | ||
| var instance = { | ||
| // properties | ||
| id: id, | ||
| reference: reference, | ||
| popper: div(), | ||
| popperInstance: popperInstance, | ||
| props: props, | ||
| state: state, | ||
| plugins: plugins, | ||
| // methods | ||
| clearDelayTimeouts: clearDelayTimeouts, | ||
| setProps: setProps, | ||
| setContent: setContent, | ||
| show: show, | ||
| hide: hide, | ||
| enable: enable, | ||
| disable: disable, | ||
| unmount: unmount, | ||
| destroy: destroy | ||
| }; // TODO: Investigate why this early return causes a TDZ error in the tests — | ||
| // it doesn't seem to happen in the browser | ||
| /* istanbul ignore if */ | ||
| if (!props.render) { | ||
| if (process.env.NODE_ENV !== "production") { | ||
| errorWhen(true, 'render() function has not been supplied.'); | ||
| } | ||
| return instance; | ||
| } // =========================================================================== | ||
| // Initial mutations | ||
| // =========================================================================== | ||
| var _props$render = props.render(instance), | ||
| popper = _props$render.popper, | ||
| update = _props$render.update; | ||
| popper.setAttribute('data-tippy-root', ''); | ||
| popper.id = "tippy-" + instance.id; | ||
| instance.popper = popper; | ||
| reference._tippy = instance; | ||
| popper._tippy = instance; | ||
| var pluginsHooks = plugins.map(function (plugin) { | ||
| return plugin.fn(instance); | ||
| }); | ||
| var singleton = { | ||
| fn: function fn(instance) { | ||
| function handleAriaDescribedByAttribute(isShow) { | ||
| if (!currentAria) { | ||
| return; | ||
| } | ||
| var hadAriaExpandedAttributeOnCreate = reference.hasAttribute('aria-expanded'); | ||
| addListenersToTriggerTarget(); | ||
| handleAriaExpandedAttribute(); | ||
| invokeHook('onCreate', [instance]); | ||
| var attr = "aria-" + currentAria; | ||
| if (props.showOnCreate) { | ||
| scheduleShow(); | ||
| } // Prevent a tippy with a delay from hiding if the cursor left then returned | ||
| // before it started hiding | ||
| if (isShow && !instance.props.interactive) { | ||
| currentTarget.setAttribute(attr, instance.popperChildren.tooltip.id); | ||
| popper.addEventListener('mouseenter', function () { | ||
| if (instance.props.interactive && instance.state.isVisible) { | ||
| instance.clearDelayTimeouts(); | ||
| } | ||
| }); | ||
| popper.addEventListener('mouseleave', function () { | ||
| if (instance.props.interactive && instance.props.trigger.indexOf('mouseenter') >= 0) { | ||
| doc.addEventListener('mousemove', debouncedOnMouseMove); | ||
| } | ||
| }); | ||
| return instance; // =========================================================================== | ||
| // 🔒 Private methods | ||
| // =========================================================================== | ||
| function getNormalizedTouchSettings() { | ||
| var touch = instance.props.touch; | ||
| return Array.isArray(touch) ? touch : [touch, 0]; | ||
| } | ||
| function getIsCustomTouchBehavior() { | ||
| return getNormalizedTouchSettings()[0] === 'hold'; | ||
| } | ||
| function getCurrentTarget() { | ||
| return currentTarget || reference; | ||
| } | ||
| function getDefaultTemplateChildren() { | ||
| return getChildren(popper); | ||
| } | ||
| function getDelay(isShow) { | ||
| // For touch or keyboard input, force `0` delay for UX reasons | ||
| // Also if the instance is mounted but not visible (transitioning out), | ||
| // ignore delay | ||
| if (instance.state.isMounted && !instance.state.isVisible || currentInput.isTouch || lastTriggerEvent && lastTriggerEvent.type === 'focus') { | ||
| return 0; | ||
| } | ||
| return getValueAtIndexOrReturn(instance.props.delay, isShow ? 0 : 1, defaultProps.delay); | ||
| } | ||
| function handleInteractiveStyles() { | ||
| popper.style.pointerEvents = instance.props.interactive && instance.state.isVisible ? '' : 'none'; | ||
| } | ||
| function updateIOSClass(isAdd) { | ||
| var shouldAdd = isAdd && isIOS && currentInput.isTouch; | ||
| doc.body.classList[shouldAdd ? 'add' : 'remove'](IOS_CLASS); | ||
| } | ||
| function invokeHook(hook, args, shouldInvokePropsHook) { | ||
| if (shouldInvokePropsHook === void 0) { | ||
| shouldInvokePropsHook = true; | ||
| } | ||
| pluginsHooks.forEach(function (pluginHooks) { | ||
| if (pluginHooks[hook]) { | ||
| pluginHooks[hook].apply(void 0, args); | ||
| } | ||
| }); | ||
| if (shouldInvokePropsHook) { | ||
| var _instance$props; | ||
| (_instance$props = instance.props)[hook].apply(_instance$props, args); | ||
| } | ||
| } | ||
| function handleAriaDescribedByAttribute() { | ||
| var aria = instance.props.aria; | ||
| if (!aria) { | ||
| return; | ||
| } | ||
| var attr = "aria-" + aria; | ||
| var id = popper.id; | ||
| var nodes = normalizeToArray(instance.props.triggerTarget || reference); | ||
| nodes.forEach(function (node) { | ||
| var currentValue = node.getAttribute(attr); | ||
| if (instance.state.isVisible) { | ||
| node.setAttribute(attr, currentValue ? currentValue + " " + id : id); | ||
| } else { | ||
| var nextValue = currentValue && currentValue.replace(id, '').trim(); | ||
| if (nextValue) { | ||
| node.setAttribute(attr, nextValue); | ||
| } else { | ||
| currentTarget.removeAttribute(attr); | ||
| node.removeAttribute(attr); | ||
| } | ||
| } | ||
| }); | ||
| } | ||
| function handleAriaExpandedAttribute() { | ||
| // If the user has specified `aria-expanded` on their reference when the | ||
| // instance was created, we have to assume they're controlling it externally | ||
| // themselves | ||
| if (hadAriaExpandedAttributeOnCreate) { | ||
| return; | ||
| } | ||
| var nodes = normalizeToArray(instance.props.triggerTarget || reference); | ||
| nodes.forEach(function (node) { | ||
| if (instance.props.interactive) { | ||
| node.setAttribute('aria-expanded', instance.state.isVisible && node === getCurrentTarget() ? 'true' : 'false'); | ||
| } else { | ||
| node.removeAttribute('aria-expanded'); | ||
| } | ||
| }); | ||
| } | ||
| function cleanupInteractiveMouseListeners() { | ||
| doc.body.removeEventListener('mouseleave', scheduleHide); | ||
| doc.removeEventListener('mousemove', debouncedOnMouseMove); | ||
| mouseMoveListeners = mouseMoveListeners.filter(function (listener) { | ||
| return listener !== debouncedOnMouseMove; | ||
| }); | ||
| } | ||
| function onDocumentMouseDown(event) { | ||
| // Clicked on interactive popper | ||
| if (instance.props.interactive && popper.contains(event.target)) { | ||
| return; | ||
| } // Clicked on the event listeners target | ||
| if (getCurrentTarget().contains(event.target)) { | ||
| if (currentInput.isTouch) { | ||
| return; | ||
| } | ||
| if (instance.state.isVisible && instance.props.trigger.indexOf('click') >= 0) { | ||
| return; | ||
| } | ||
| } | ||
| if (instance.props.hideOnClick === true) { | ||
| isVisibleFromClick = false; | ||
| instance.clearDelayTimeouts(); | ||
| instance.hide(); // `mousedown` event is fired right before `focus` if pressing the | ||
| // currentTarget. This lets a tippy with `focus` trigger know that it | ||
| // should not show | ||
| didHideDueToDocumentMouseDown = true; | ||
| setTimeout(function () { | ||
| didHideDueToDocumentMouseDown = false; | ||
| }); // The listener gets added in `scheduleShow()`, but this may be hiding it | ||
| // before it shows, and hide()'s early bail-out behavior can prevent it | ||
| // from being cleaned up | ||
| if (!instance.state.isMounted) { | ||
| removeDocumentMouseDownListener(); | ||
| } | ||
| } | ||
| } | ||
| function addDocumentMouseDownListener() { | ||
| doc.addEventListener('mousedown', onDocumentMouseDown, true); | ||
| } | ||
| function removeDocumentMouseDownListener() { | ||
| doc.removeEventListener('mousedown', onDocumentMouseDown, true); | ||
| } | ||
| function onTransitionedOut(duration, callback) { | ||
| onTransitionEnd(duration, function () { | ||
| if (!instance.state.isVisible && popper.parentNode && popper.parentNode.contains(popper)) { | ||
| callback(); | ||
| } | ||
| }); | ||
| } | ||
| function onTransitionedIn(duration, callback) { | ||
| onTransitionEnd(duration, callback); | ||
| } | ||
| function onTransitionEnd(duration, callback) { | ||
| var box = getDefaultTemplateChildren().box; | ||
| function listener(event) { | ||
| if (event.target === box) { | ||
| updateTransitionEndListener(box, 'remove', listener); | ||
| callback(); | ||
| } | ||
| } // Make callback synchronous if duration is 0 | ||
| // `transitionend` won't fire otherwise | ||
| if (duration === 0) { | ||
| return callback(); | ||
| } | ||
| updateTransitionEndListener(box, 'remove', currentTransitionEndListener); | ||
| updateTransitionEndListener(box, 'add', listener); | ||
| currentTransitionEndListener = listener; | ||
| } | ||
| function on(eventType, handler, options) { | ||
| if (options === void 0) { | ||
| options = false; | ||
| } | ||
| var nodes = normalizeToArray(instance.props.triggerTarget || reference); | ||
| nodes.forEach(function (node) { | ||
| node.addEventListener(eventType, handler, options); | ||
| listeners.push({ | ||
| node: node, | ||
| eventType: eventType, | ||
| handler: handler, | ||
| options: options | ||
| }); | ||
| }); | ||
| } | ||
| function addListenersToTriggerTarget() { | ||
| if (getIsCustomTouchBehavior()) { | ||
| on('touchstart', onTrigger, PASSIVE); | ||
| on('touchend', onMouseLeave, PASSIVE); | ||
| } | ||
| splitBySpaces(instance.props.trigger).forEach(function (eventType) { | ||
| if (eventType === 'manual') { | ||
| return; | ||
| } | ||
| on(eventType, onTrigger); | ||
| switch (eventType) { | ||
| case 'mouseenter': | ||
| on('mouseleave', onMouseLeave); | ||
| break; | ||
| case 'focus': | ||
| on(isIE ? 'focusout' : 'blur', onBlurOrFocusOut); | ||
| break; | ||
| case 'focusin': | ||
| on('focusout', onBlurOrFocusOut); | ||
| break; | ||
| } | ||
| }); | ||
| } | ||
| function removeListenersFromTriggerTarget() { | ||
| listeners.forEach(function (_ref) { | ||
| var node = _ref.node, | ||
| eventType = _ref.eventType, | ||
| handler = _ref.handler, | ||
| options = _ref.options; | ||
| node.removeEventListener(eventType, handler, options); | ||
| }); | ||
| listeners = []; | ||
| } | ||
| function onTrigger(event) { | ||
| var shouldScheduleClickHide = false; | ||
| if (!instance.state.isEnabled || isEventListenerStopped(event) || didHideDueToDocumentMouseDown) { | ||
| return; | ||
| } | ||
| lastTriggerEvent = event; | ||
| currentTarget = event.currentTarget; | ||
| handleAriaExpandedAttribute(); | ||
| if (!instance.state.isVisible && isMouseEvent(event)) { | ||
| // If scrolling, `mouseenter` events can be fired if the cursor lands | ||
| // over a new target, but `mousemove` events don't get fired. This | ||
| // causes interactive tooltips to get stuck open until the cursor is | ||
| // moved | ||
| mouseMoveListeners.forEach(function (listener) { | ||
| return listener(event); | ||
| }); | ||
| } // Toggle show/hide when clicking click-triggered tooltips | ||
| if (event.type === 'click' && (instance.props.trigger.indexOf('mouseenter') < 0 || isVisibleFromClick) && instance.props.hideOnClick !== false && instance.state.isVisible) { | ||
| shouldScheduleClickHide = true; | ||
| } else { | ||
| var _getNormalizedTouchSe = getNormalizedTouchSettings(), | ||
| value = _getNormalizedTouchSe[0], | ||
| duration = _getNormalizedTouchSe[1]; | ||
| if (currentInput.isTouch && value === 'hold' && duration) { | ||
| // We can hijack the show timeout here, it will be cleared by | ||
| // `scheduleHide()` when necessary | ||
| showTimeout = setTimeout(function () { | ||
| scheduleShow(event); | ||
| }, duration); | ||
| } else { | ||
| scheduleShow(event); | ||
| } | ||
| } | ||
| if (event.type === 'click') { | ||
| isVisibleFromClick = !shouldScheduleClickHide; | ||
| } | ||
| if (shouldScheduleClickHide) { | ||
| scheduleHide(event); | ||
| } | ||
| } | ||
| function onMouseMove(event) { | ||
| var isCursorOverReferenceOrPopper = closestCallback(event.target, function (el) { | ||
| return el === reference || el === popper; | ||
| }); | ||
| if (isCursorOverReferenceOrPopper) { | ||
| return; | ||
| } | ||
| var popperTreeData = getNestedPopperTree().concat(popper).map(function (popper) { | ||
| var instance = popper._tippy; | ||
| if (instance.popperInstance) { | ||
| return { | ||
| popperRect: popper.getBoundingClientRect(), | ||
| basePlacement: getBasePlacement(instance.state.currentPlacement), | ||
| offsetData: instance.popperInstance.state.modifiersData.offset, | ||
| props: props | ||
| }; | ||
| } | ||
| return null; | ||
| }).filter(Boolean); | ||
| if (isCursorOutsideInteractiveBorder(popperTreeData, event)) { | ||
| cleanupInteractiveMouseListeners(); | ||
| scheduleHide(event); | ||
| } | ||
| } | ||
| function onMouseLeave(event) { | ||
| var shouldBail = isEventListenerStopped(event) || instance.props.trigger.indexOf('click') >= 0 && isVisibleFromClick; | ||
| if (shouldBail) { | ||
| return; | ||
| } | ||
| if (instance.props.interactive) { | ||
| doc.body.addEventListener('mouseleave', scheduleHide); | ||
| doc.addEventListener('mousemove', debouncedOnMouseMove); | ||
| pushIfUnique(mouseMoveListeners, debouncedOnMouseMove); | ||
| return; | ||
| } | ||
| scheduleHide(event); | ||
| } | ||
| function onBlurOrFocusOut(event) { | ||
| if (instance.props.trigger.indexOf('focusin') < 0 && event.target !== getCurrentTarget()) { | ||
| return; | ||
| } // If focus was moved to within the popper | ||
| if (instance.props.interactive && event.relatedTarget && popper.contains(event.relatedTarget)) { | ||
| return; | ||
| } | ||
| scheduleHide(event); | ||
| } | ||
| function isEventListenerStopped(event) { | ||
| var supportsTouch = 'ontouchstart' in window; | ||
| var isTouchEvent = event.type.indexOf('touch') >= 0; | ||
| var isCustomTouch = getIsCustomTouchBehavior(); | ||
| return supportsTouch && currentInput.isTouch && isCustomTouch && !isTouchEvent || currentInput.isTouch && !isCustomTouch && isTouchEvent; | ||
| } | ||
| function createPopperInstance() { | ||
| destroyPopperInstance(); | ||
| var _instance$props2 = instance.props, | ||
| popperOptions = _instance$props2.popperOptions, | ||
| placement = _instance$props2.placement, | ||
| offset = _instance$props2.offset, | ||
| getReferenceClientRect = _instance$props2.getReferenceClientRect, | ||
| moveTransition = _instance$props2.moveTransition; | ||
| var arrow = isDefaultRenderFn(instance.props.render) ? getChildren(popper).arrow : null; | ||
| var computedReference = getReferenceClientRect ? { | ||
| getBoundingClientRect: getReferenceClientRect | ||
| } : reference; | ||
| var tippyModifier = { | ||
| name: '$$tippy', | ||
| enabled: true, | ||
| phase: 'beforeWrite', | ||
| requires: ['computeStyles'], | ||
| fn: function fn(_ref2) { | ||
| var state = _ref2.state; | ||
| if (isDefaultRenderFn(instance.props.render)) { | ||
| // Replace `data-popper-placement` with `data-placement` | ||
| delete state.attributes.popper['data-popper-placement']; | ||
| getDefaultTemplateChildren().box.setAttribute('data-placement', state.placement); | ||
| } | ||
| instance.state.currentPlacement = state.placement; | ||
| } | ||
| }; | ||
| var arrowModifier = { | ||
| name: 'arrow', | ||
| enabled: !!arrow, | ||
| options: { | ||
| element: arrow, | ||
| padding: 3 | ||
| } | ||
| }; | ||
| var mergeableModifiers = [].concat((popperOptions == null ? void 0 : popperOptions.modifiers) || [], [{ | ||
| name: 'offset', | ||
| options: { | ||
| offset: offset | ||
| } | ||
| }, { | ||
| name: 'preventOverflow', | ||
| options: { | ||
| padding: { | ||
| top: 2, | ||
| bottom: 2, | ||
| left: 5, | ||
| right: 5 | ||
| } | ||
| } | ||
| }, { | ||
| name: 'flip', | ||
| options: { | ||
| padding: { | ||
| top: 2, | ||
| bottom: 2, | ||
| left: 5, | ||
| right: 5 | ||
| } | ||
| } | ||
| }, { | ||
| name: 'computeStyles', | ||
| options: { | ||
| adaptive: !moveTransition | ||
| } | ||
| }, tippyModifier]).concat(isDefaultRenderFn(instance.props.render) ? [arrowModifier] : []); | ||
| instance.popperInstance = createPopper(computedReference, popper, Object.assign({}, popperOptions, { | ||
| placement: placement, | ||
| onFirstUpdate: onFirstUpdate, | ||
| modifiers: [mergeModifier(mergeableModifiers, 'offset'), mergeModifier(mergeableModifiers, 'arrow'), mergeModifier(mergeableModifiers, 'preventOverflow'), mergeModifier(mergeableModifiers, 'flip'), mergeModifier(mergeableModifiers, 'computeStyles')].concat(mergeableModifiers) | ||
| })); | ||
| } | ||
| function destroyPopperInstance() { | ||
| if (instance.popperInstance) { | ||
| instance.popperInstance.destroy(); | ||
| instance.popperInstance = null; | ||
| } | ||
| } | ||
| function mount() { | ||
| var appendTo = instance.props.appendTo; | ||
| var parentNode; // By default, we'll append the popper to the triggerTargets's parentNode so | ||
| // it's directly after the reference element so the elements inside the | ||
| // tippy can be tabbed to | ||
| // If there are clipping issues, the user can specify a different appendTo | ||
| // and ensure focus management is handled correctly manually | ||
| var node = getCurrentTarget(); | ||
| if (instance.props.interactive && appendTo === defaultProps.appendTo || appendTo === 'parent') { | ||
| parentNode = node.parentNode; | ||
| } else { | ||
| parentNode = invokeWithArgsOrReturn(appendTo, [node]); | ||
| } // The popper element needs to exist on the DOM before its position can be | ||
| // updated as Popper needs to read its dimensions | ||
| if (!parentNode.contains(popper)) { | ||
| parentNode.appendChild(popper); | ||
| } | ||
| createPopperInstance(); | ||
| /* istanbul ignore else */ | ||
| if (process.env.NODE_ENV !== "production") { | ||
| // Accessibility check | ||
| warnWhen(instance.props.interactive && appendTo === defaultProps.appendTo && node.nextElementSibling !== popper, ['Interactive tippy element may not be accessible via keyboard', 'navigation because it is not directly after the reference element', 'in the DOM source order.', '\n\n', 'Using a wrapper <div> or <span> tag around the reference element', 'solves this by creating a new parentNode context.', '\n\n', 'Specifying `appendTo: document.body` silences this warning, but it', 'assumes you are using a focus management solution to handle', 'keyboard navigation.', '\n\n', 'See: https://atomiks.github.io/tippyjs/accessibility/#interactivity'].join(' ')); | ||
| } | ||
| } | ||
| function getNestedPopperTree() { | ||
| return arrayFrom(popper.querySelectorAll('[data-tippy-root]')); | ||
| } | ||
| function scheduleShow(event) { | ||
| instance.clearDelayTimeouts(); | ||
| if (event) { | ||
| invokeHook('onTrigger', [instance, event]); | ||
| } | ||
| addDocumentMouseDownListener(); | ||
| var delay = getDelay(true); | ||
| if (delay) { | ||
| showTimeout = setTimeout(function () { | ||
| instance.show(); | ||
| }, delay); | ||
| } else { | ||
| instance.show(); | ||
| } | ||
| } | ||
| function scheduleHide(event) { | ||
| instance.clearDelayTimeouts(); | ||
| invokeHook('onUntrigger', [instance, event]); | ||
| if (!instance.state.isVisible) { | ||
| removeDocumentMouseDownListener(); | ||
| return; | ||
| } // For interactive tippies, scheduleHide is added to a document.body handler | ||
| // from onMouseLeave so must intercept scheduled hides from mousemove/leave | ||
| // events when trigger contains mouseenter and click, and the tip is | ||
| // currently shown as a result of a click. | ||
| if (instance.props.trigger.indexOf('mouseenter') >= 0 && instance.props.trigger.indexOf('click') >= 0 && ['mouseleave', 'mousemove'].indexOf(event.type) >= 0 && isVisibleFromClick) { | ||
| return; | ||
| } | ||
| var delay = getDelay(false); | ||
| if (delay) { | ||
| hideTimeout = setTimeout(function () { | ||
| if (instance.state.isVisible) { | ||
| instance.hide(); | ||
| } | ||
| }, delay); | ||
| } else { | ||
| // Fixes a `transitionend` problem when it fires 1 frame too | ||
| // late sometimes, we don't want hide() to be called. | ||
| scheduleHideAnimationFrame = requestAnimationFrame(function () { | ||
| instance.hide(); | ||
| }); | ||
| } | ||
| } // =========================================================================== | ||
| // 🔑 Public methods | ||
| // =========================================================================== | ||
| function enable() { | ||
| instance.state.isEnabled = true; | ||
| } | ||
| function disable() { | ||
| // Disabling the instance should also hide it | ||
| // https://github.com/atomiks/tippy.js-react/issues/106 | ||
| instance.hide(); | ||
| instance.state.isEnabled = false; | ||
| } | ||
| function clearDelayTimeouts() { | ||
| clearTimeout(showTimeout); | ||
| clearTimeout(hideTimeout); | ||
| cancelAnimationFrame(scheduleHideAnimationFrame); | ||
| } | ||
| function setProps(partialProps) { | ||
| /* istanbul ignore else */ | ||
| if (process.env.NODE_ENV !== "production") { | ||
| warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('setProps')); | ||
| } | ||
| if (instance.state.isDestroyed) { | ||
| return; | ||
| } | ||
| invokeHook('onBeforeUpdate', [instance, partialProps]); | ||
| removeListenersFromTriggerTarget(); | ||
| var prevProps = instance.props; | ||
| var nextProps = evaluateProps(reference, Object.assign({}, instance.props, {}, partialProps, { | ||
| ignoreAttributes: true | ||
| })); | ||
| instance.props = nextProps; | ||
| addListenersToTriggerTarget(); | ||
| if (prevProps.interactiveDebounce !== nextProps.interactiveDebounce) { | ||
| cleanupInteractiveMouseListeners(); | ||
| debouncedOnMouseMove = debounce(onMouseMove, nextProps.interactiveDebounce); | ||
| } // Ensure stale aria-expanded attributes are removed | ||
| if (prevProps.triggerTarget && !nextProps.triggerTarget) { | ||
| normalizeToArray(prevProps.triggerTarget).forEach(function (node) { | ||
| node.removeAttribute('aria-expanded'); | ||
| }); | ||
| } else if (nextProps.triggerTarget) { | ||
| reference.removeAttribute('aria-expanded'); | ||
| } | ||
| handleAriaExpandedAttribute(); | ||
| handleInteractiveStyles(); | ||
| if (update) { | ||
| update(prevProps, nextProps); | ||
| } | ||
| if (instance.popperInstance) { | ||
| createPopperInstance(); | ||
| } | ||
| invokeHook('onAfterUpdate', [instance, partialProps]); | ||
| } | ||
| function setContent(content) { | ||
| instance.setProps({ | ||
| content: content | ||
| }); | ||
| } | ||
| function show() { | ||
| /* istanbul ignore else */ | ||
| if (process.env.NODE_ENV !== "production") { | ||
| warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('show')); | ||
| } // Early bail-out | ||
| var isAlreadyVisible = instance.state.isVisible; | ||
| var isDestroyed = instance.state.isDestroyed; | ||
| var isDisabled = !instance.state.isEnabled; | ||
| var isTouchAndTouchDisabled = currentInput.isTouch && !instance.props.touch; | ||
| var duration = getValueAtIndexOrReturn(instance.props.duration, 0, defaultProps.duration); | ||
| if (isAlreadyVisible || isDestroyed || isDisabled || isTouchAndTouchDisabled) { | ||
| return; | ||
| } // Normalize `disabled` behavior across browsers. | ||
| // Firefox allows events on disabled elements, but Chrome doesn't. | ||
| // Using a wrapper element (i.e. <span>) is recommended. | ||
| if (getCurrentTarget().hasAttribute('disabled')) { | ||
| return; | ||
| } | ||
| invokeHook('onShow', [instance], false); | ||
| if (instance.props.onShow(instance) === false) { | ||
| return; | ||
| } | ||
| instance.state.isVisible = true; | ||
| popper.style.visibility = 'visible'; | ||
| handleInteractiveStyles(); | ||
| addDocumentMouseDownListener(); | ||
| popper.style.transition = 'none'; | ||
| onFirstUpdate = function onFirstUpdate() { | ||
| if (!instance.state.isVisible || ignoreOnFirstUpdate) { | ||
| return; | ||
| } | ||
| ignoreOnFirstUpdate = true; // reflow | ||
| void popper.offsetHeight; | ||
| popper.style.transition = instance.props.moveTransition; | ||
| if (isDefaultRenderFn(instance.props.render)) { | ||
| var _getDefaultTemplateCh = getDefaultTemplateChildren(), | ||
| box = _getDefaultTemplateCh.box, | ||
| content = _getDefaultTemplateCh.content; | ||
| if (instance.props.animation) { | ||
| setTransitionDuration([box, content], duration); | ||
| setVisibilityState([box, content], 'visible'); | ||
| } | ||
| } | ||
| handleAriaDescribedByAttribute(); | ||
| handleAriaExpandedAttribute(); | ||
| pushIfUnique(mountedInstances, instance); | ||
| updateIOSClass(true); | ||
| instance.state.isMounted = true; | ||
| invokeHook('onMount', [instance]); | ||
| if (instance.props.animation && isDefaultRenderFn(instance.props.render)) { | ||
| onTransitionedIn(duration, function () { | ||
| instance.state.isShown = true; | ||
| invokeHook('onShown', [instance]); | ||
| }); | ||
| } | ||
| }; | ||
| mount(); | ||
| } | ||
| function hide() { | ||
| /* istanbul ignore else */ | ||
| if (process.env.NODE_ENV !== "production") { | ||
| warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('hide')); | ||
| } // Early bail-out | ||
| var isAlreadyHidden = !instance.state.isVisible; | ||
| var isDestroyed = instance.state.isDestroyed; | ||
| var isDisabled = !instance.state.isEnabled; | ||
| var duration = getValueAtIndexOrReturn(instance.props.duration, 1, defaultProps.duration); | ||
| if (isAlreadyHidden || isDestroyed || isDisabled) { | ||
| return; | ||
| } | ||
| invokeHook('onHide', [instance], false); | ||
| if (instance.props.onHide(instance) === false) { | ||
| return; | ||
| } | ||
| instance.state.isVisible = false; | ||
| instance.state.isShown = false; | ||
| popper.style.visibility = 'hidden'; | ||
| ignoreOnFirstUpdate = false; | ||
| cleanupInteractiveMouseListeners(); | ||
| removeDocumentMouseDownListener(); | ||
| handleInteractiveStyles(); | ||
| if (isDefaultRenderFn(instance.props.render)) { | ||
| var _getDefaultTemplateCh2 = getDefaultTemplateChildren(), | ||
| box = _getDefaultTemplateCh2.box, | ||
| content = _getDefaultTemplateCh2.content; | ||
| if (instance.props.animation) { | ||
| setTransitionDuration([box, content], duration); | ||
| setVisibilityState([box, content], 'hidden'); | ||
| } | ||
| } | ||
| handleAriaDescribedByAttribute(); | ||
| handleAriaExpandedAttribute(); | ||
| if (instance.props.animation && isDefaultRenderFn(instance.props.render)) { | ||
| onTransitionedOut(duration, unmount); | ||
| } | ||
| } | ||
| function unmount() { | ||
| destroyPopperInstance(); // If a popper is not interactive, it will be appended outside the popper | ||
| // tree by default. This seems mainly for interactive tippies, but we should | ||
| // find a workaround if possible | ||
| getNestedPopperTree().forEach(function (nestedPopper) { | ||
| var instance = nestedPopper._tippy; | ||
| instance.unmount(); | ||
| }); | ||
| if (popper.parentNode) { | ||
| popper.parentNode.removeChild(popper); | ||
| } | ||
| mountedInstances = mountedInstances.filter(function (i) { | ||
| return i !== instance; | ||
| }); | ||
| if (mountedInstances.length === 0) { | ||
| updateIOSClass(false); | ||
| } | ||
| instance.state.isMounted = false; | ||
| invokeHook('onHidden', [instance]); | ||
| } | ||
| function destroy() { | ||
| /* istanbul ignore else */ | ||
| if (process.env.NODE_ENV !== "production") { | ||
| warnWhen(instance.state.isDestroyed, createMemoryLeakWarning('destroy')); | ||
| } | ||
| if (instance.state.isDestroyed) { | ||
| return; | ||
| } | ||
| instance.clearDelayTimeouts(); | ||
| instance.unmount(); | ||
| removeListenersFromTriggerTarget(); | ||
| delete reference._tippy; | ||
| instance.state.isDestroyed = true; | ||
| invokeHook('onDestroy', [instance]); | ||
| } | ||
| } | ||
| function tippy(targets, optionalProps) { | ||
| if (optionalProps === void 0) { | ||
| optionalProps = {}; | ||
| } | ||
| var plugins = defaultProps.plugins.concat(optionalProps.plugins || []); | ||
| /* istanbul ignore else */ | ||
| if (process.env.NODE_ENV !== "production") { | ||
| validateTargets(targets); | ||
| validateProps(optionalProps, plugins); | ||
| } | ||
| bindGlobalEventListeners(); | ||
| var passedProps = Object.assign({}, optionalProps, { | ||
| plugins: plugins | ||
| }); | ||
| var elements = getArrayOfElements(targets); | ||
| /* istanbul ignore else */ | ||
| if (process.env.NODE_ENV !== "production") { | ||
| var isSingleContentElement = isElement(passedProps.content); | ||
| var isMoreThanOneReferenceElement = elements.length > 1; | ||
| warnWhen(isSingleContentElement && isMoreThanOneReferenceElement, ['tippy() was passed an Element as the `content` prop, but more than', 'one tippy instance was created by this invocation. This means the', 'content element will only be appended to the last tippy instance.', '\n\n', 'Instead, pass the .innerHTML of the element, or use a function that', 'returns a cloned version of the element instead.', '\n\n', '1) content: element.innerHTML\n', '2) content: () => element.cloneNode(true)'].join(' ')); | ||
| } | ||
| var instances = elements.reduce(function (acc, reference) { | ||
| var instance = reference && createTippy(reference, passedProps); | ||
| if (instance) { | ||
| acc.push(instance); | ||
| } | ||
| return acc; | ||
| }, []); | ||
| return isElement(targets) ? instances[0] : instances; | ||
| } | ||
| tippy.defaultProps = defaultProps; | ||
| tippy.setDefaultProps = setDefaultProps; | ||
| tippy.currentInput = currentInput; | ||
| var hideAll = function hideAll(_temp) { | ||
| var _ref = _temp === void 0 ? {} : _temp, | ||
| excludedReferenceOrInstance = _ref.exclude, | ||
| duration = _ref.duration; | ||
| mountedInstances.forEach(function (instance) { | ||
| var isExcluded = false; | ||
| if (excludedReferenceOrInstance) { | ||
| isExcluded = isReferenceElement(excludedReferenceOrInstance) ? instance.reference === excludedReferenceOrInstance : instance.popper === excludedReferenceOrInstance.popper; | ||
| } | ||
| if (!isExcluded) { | ||
| var originalDuration = instance.props.duration; | ||
| instance.setProps({ | ||
| duration: duration | ||
| }); | ||
| instance.hide(); | ||
| instance.setProps({ | ||
| duration: originalDuration | ||
| }); | ||
| } | ||
| }); | ||
| }; | ||
| var createSingleton = function createSingleton(tippyInstances, optionalProps) { | ||
| if (optionalProps === void 0) { | ||
| optionalProps = {}; | ||
| } | ||
| /* istanbul ignore else */ | ||
| if (process.env.NODE_ENV !== "production") { | ||
| errorWhen(!Array.isArray(tippyInstances), ['The first argument passed to createSingleton() must be an array of', 'tippy instances. The passed value was', String(tippyInstances)].join(' ')); | ||
| } | ||
| tippyInstances.forEach(function (instance) { | ||
| instance.disable(); | ||
| }); | ||
| var currentTarget; | ||
| var references = tippyInstances.map(function (instance) { | ||
| return instance.reference; | ||
| }); | ||
| var singleton = { | ||
| fn: function fn() { | ||
| return { | ||
| onAfterUpdate: function onAfterUpdate(_, _ref) { | ||
| var aria = _ref.aria; | ||
| // Ensure `aria` for the singleton instance stays `null`, while | ||
| // changing the `userAria` value | ||
| if (aria !== undefined && aria !== userAria) { | ||
| if (!shouldSkipUpdate) { | ||
| userAria = aria; | ||
| } else { | ||
| shouldSkipUpdate = true; | ||
| instance.setProps({ | ||
| aria: null | ||
| }); | ||
| shouldSkipUpdate = false; | ||
| } | ||
| } | ||
| }, | ||
| onDestroy: function onDestroy() { | ||
@@ -83,9 +1553,3 @@ tippyInstances.forEach(function (instance) { | ||
| }, | ||
| onMount: function onMount() { | ||
| handleAriaDescribedByAttribute(true); | ||
| }, | ||
| onUntrigger: function onUntrigger() { | ||
| handleAriaDescribedByAttribute(false); | ||
| }, | ||
| onTrigger: function onTrigger(_, event) { | ||
| onTrigger: function onTrigger(instance, event) { | ||
| var target = event.currentTarget; | ||
@@ -99,10 +1563,11 @@ var index = references.indexOf(target); // bail-out | ||
| currentTarget = target; | ||
| currentAria = userAria; | ||
| if (instance.state.isVisible) { | ||
| handleAriaDescribedByAttribute(true); | ||
| } | ||
| instance.popperInstance.reference = target; | ||
| instance.setContent(tippyInstances[index].props.content); | ||
| var overrideProps = (optionalProps.overrides || []).concat('content').reduce(function (acc, prop) { | ||
| acc[prop] = tippyInstances[index].props[prop]; | ||
| return acc; | ||
| }, {}); | ||
| instance.setProps(Object.assign({}, overrideProps, { | ||
| getReferenceClientRect: function getReferenceClientRect() { | ||
| return target.getBoundingClientRect(); | ||
| } | ||
| })); | ||
| } | ||
@@ -112,5 +1577,4 @@ }; | ||
| }; | ||
| return tippy(div(), _extends({}, optionalProps, { | ||
| plugins: [singleton].concat(plugins), | ||
| aria: null, | ||
| return tippy(div(), Object.assign({}, removeProperties(optionalProps, ['overrides']), { | ||
| plugins: [singleton].concat(optionalProps.plugins || []), | ||
| triggerTarget: references | ||
@@ -130,9 +1594,4 @@ })); | ||
| function delegate(targets, props, | ||
| /** @deprecated use Props.plugins */ | ||
| plugins) { | ||
| if (plugins === void 0) { | ||
| plugins = []; | ||
| } | ||
| function delegate(targets, props) { | ||
| /* istanbul ignore else */ | ||
| if (process.env.NODE_ENV !== "production") { | ||
@@ -142,3 +1601,2 @@ errorWhen(!(props && props.target), ['You must specity a `target` prop indicating a CSS selector string matching', 'the target elements that should receive a tippy.'].join(' ')); | ||
| plugins = props.plugins || plugins; | ||
| var listeners = []; | ||
@@ -148,13 +1606,8 @@ var childTippyInstances = []; | ||
| var nativeProps = removeProperties(props, ['target']); | ||
| var parentProps = _extends({}, nativeProps, { | ||
| plugins: plugins, | ||
| var parentProps = Object.assign({}, nativeProps, { | ||
| trigger: 'manual' | ||
| }); | ||
| var childProps = _extends({}, nativeProps, { | ||
| plugins: plugins, | ||
| var childProps = Object.assign({}, nativeProps, { | ||
| showOnCreate: true | ||
| }); | ||
| var returnValue = tippy(targets, parentProps); | ||
@@ -178,5 +1631,7 @@ var normalizedReturnValue = normalizeToArray(returnValue); | ||
| var trigger = targetNode.getAttribute('data-tippy-trigger') || props.trigger || defaultProps.trigger; // Only create the instance if the bubbling event matches the trigger type | ||
| var trigger = targetNode.getAttribute('data-tippy-trigger') || props.trigger || defaultProps.trigger; // Only create the instance if the bubbling event matches the trigger type, | ||
| // or the node already has a tippy instance attached | ||
| if (!includes(trigger, BUBBLING_EVENTS_MAP[event.type])) { | ||
| if (trigger.indexOf(BUBBLING_EVENTS_MAP[event.type]) < 0 || // @ts-ignore | ||
| targetNode._tippy) { | ||
| return; | ||
@@ -254,21 +1709,16 @@ } | ||
| fn: function fn(instance) { | ||
| var _instance$popperChild = instance.popperChildren, | ||
| tooltip = _instance$popperChild.tooltip, | ||
| content = _instance$popperChild.content; | ||
| var backdrop = instance.props.animateFill && !isUCBrowser ? createBackdropElement() : null; | ||
| var _getChildren = getChildren(instance.popper), | ||
| box = _getChildren.box, | ||
| content = _getChildren.content; | ||
| function addBackdropToPopperChildren() { | ||
| instance.popperChildren.backdrop = backdrop; | ||
| } | ||
| var backdrop = instance.props.animateFill ? createBackdropElement() : null; | ||
| return { | ||
| onCreate: function onCreate() { | ||
| if (backdrop) { | ||
| addBackdropToPopperChildren(); | ||
| tooltip.insertBefore(backdrop, tooltip.firstElementChild); | ||
| tooltip.setAttribute('data-animatefill', ''); | ||
| tooltip.style.overflow = 'hidden'; | ||
| box.insertBefore(backdrop, box.firstElementChild); | ||
| box.setAttribute('data-animatefill', ''); | ||
| box.style.overflow = 'hidden'; | ||
| instance.setProps({ | ||
| animation: 'shift-away', | ||
| arrow: false | ||
| arrow: false, | ||
| animation: 'shift-away' | ||
| }); | ||
@@ -279,3 +1729,3 @@ } | ||
| if (backdrop) { | ||
| var transitionDuration = tooltip.style.transitionDuration; | ||
| var transitionDuration = box.style.transitionDuration; | ||
| var duration = Number(transitionDuration.replace('ms', '')); // The content should fade in after the backdrop has mostly filled the | ||
@@ -287,8 +1737,3 @@ // tooltip element. `clip-path` is the other alternative but is not | ||
| backdrop.style.transitionDuration = transitionDuration; | ||
| setVisibilityState([backdrop], 'visible'); // Warn if the stylesheets are not loaded | ||
| if (process.env.NODE_ENV !== "production") { | ||
| warnWhen(getComputedStyle(backdrop).position !== 'absolute', "The `tippy.js/dist/backdrop.css` stylesheet has not been\n imported!\n \n The `animateFill` plugin requires this stylesheet to work."); | ||
| warnWhen(getComputedStyle(tooltip).transform === 'none', "The `tippy.js/animations/shift-away.css` stylesheet has not\n been imported!\n \n The `animateFill` plugin requires this stylesheet to work."); | ||
| } | ||
| setVisibilityState([backdrop], 'visible'); | ||
| } | ||
@@ -305,8 +1750,2 @@ }, | ||
| } | ||
| }, | ||
| onAfterUpdate: function onAfterUpdate() { | ||
| // With this type of prop, it's highly unlikely it will be changed | ||
| // dynamically. We'll leave out the diff/update logic it to save bytes. | ||
| // `popperChildren` is assigned a new object onAfterUpdate | ||
| addBackdropToPopperChildren(); | ||
| } | ||
@@ -328,5 +1767,3 @@ }; | ||
| fn: function fn(instance) { | ||
| var reference = instance.reference, | ||
| popper = instance.popper; | ||
| var originalReference = null; // Support iframe contexts | ||
| var reference = instance.reference; // Support iframe contexts | ||
| // Static check that assumes any of the `triggerTarget` or `reference` | ||
@@ -339,14 +1776,3 @@ // nodes will never change documents, even when they are updated | ||
| var mouseCoords = null; | ||
| var isInternallySettingControlledProp = false; // These are controlled by this plugin, so we need to store the user's | ||
| // original prop value | ||
| var userProps = instance.props; | ||
| function setUserProps(props) { | ||
| var keys = Object.keys(props); | ||
| keys.forEach(function (prop) { | ||
| userProps[prop] = useIfDefined(props[prop], userProps[prop]); | ||
| }); | ||
| } | ||
| function getIsManual() { | ||
@@ -368,37 +1794,7 @@ return instance.props.trigger.trim() === 'manual'; | ||
| function resetReference() { | ||
| if (instance.popperInstance && originalReference) { | ||
| instance.popperInstance.reference = originalReference; | ||
| } | ||
| } | ||
| function handlePlacement() { | ||
| // Due to `getVirtualOffsets()`, we need to reverse the placement if it's | ||
| // shifted (start -> end, and vice-versa) | ||
| // Early bail-out | ||
| if (!getIsEnabled() && instance.props.placement === userProps.placement) { | ||
| return; | ||
| } | ||
| var placement = userProps.placement; | ||
| var shift = placement.split('-')[1]; | ||
| isInternallySettingControlledProp = true; | ||
| instance.setProps({ | ||
| placement: getIsEnabled() && shift ? placement.replace(shift, shift === 'start' ? 'end' : 'start') : placement | ||
| getReferenceClientRect: null | ||
| }); | ||
| isInternallySettingControlledProp = false; | ||
| } | ||
| function handlePopperListeners() { | ||
| if (!instance.popperInstance) { | ||
| return; | ||
| } // Popper's scroll listeners make sense for `true` only. TODO: work out | ||
| // how to only listen horizontal scroll for "horizontal" and vertical | ||
| // scroll for "vertical" | ||
| if (getIsEnabled() && (getIsInitialBehavior() || instance.props.followCursor !== true)) { | ||
| instance.popperInstance.disableEventListeners(); | ||
| } | ||
| } | ||
| function handleMouseMoveListener() { | ||
@@ -429,7 +1825,3 @@ if (getIsEnabled()) { | ||
| clientX = _lastMouseMoveEvent.clientX, | ||
| clientY = _lastMouseMoveEvent.clientY; | ||
| if (!instance.popperInstance || !instance.state.currentPlacement) { | ||
| return; | ||
| } // If the instance is interactive, avoid updating the position unless it's | ||
| clientY = _lastMouseMoveEvent.clientY; // If the instance is interactive, avoid updating the position unless it's | ||
| // over the reference element | ||
@@ -441,37 +1833,18 @@ | ||
| }); | ||
| var rect = reference.getBoundingClientRect(); | ||
| var followCursor = instance.props.followCursor; | ||
| var isHorizontal = followCursor === 'horizontal'; | ||
| var isVertical = followCursor === 'vertical'; | ||
| var isVerticalPlacement = includes(['top', 'bottom'], getBasePlacement(instance.state.currentPlacement)); // The virtual reference needs some size to prevent itself from overflowing | ||
| var _getVirtualOffsets = getVirtualOffsets(popper, isVerticalPlacement), | ||
| size = _getVirtualOffsets.size, | ||
| x = _getVirtualOffsets.x, | ||
| y = _getVirtualOffsets.y; | ||
| if (isCursorOverReference || !instance.props.interactive) { | ||
| // Preserve custom position ReferenceObjects, which may not be the | ||
| // original targets reference passed as an argument | ||
| if (originalReference === null) { | ||
| originalReference = instance.popperInstance.reference; | ||
| } | ||
| instance.popperInstance.reference = { | ||
| referenceNode: reference, | ||
| // These `client` values don't get used by Popper.js if they are 0 | ||
| clientWidth: 0, | ||
| clientHeight: 0, | ||
| getBoundingClientRect: function getBoundingClientRect() { | ||
| instance.setProps({ | ||
| getReferenceClientRect: function getReferenceClientRect() { | ||
| var rect = reference.getBoundingClientRect(); | ||
| return { | ||
| width: isVerticalPlacement ? size : 0, | ||
| height: isVerticalPlacement ? 0 : size, | ||
| top: (isHorizontal ? rect.top : clientY) - y, | ||
| bottom: (isHorizontal ? rect.bottom : clientY) + y, | ||
| left: (isVertical ? rect.left : clientX) - x, | ||
| right: (isVertical ? rect.right : clientX) + x | ||
| width: 0, | ||
| height: 0, | ||
| top: followCursor === 'horizontal' ? rect.top : clientY, | ||
| bottom: followCursor === 'horizontal' ? rect.bottom : clientY, | ||
| left: followCursor === 'vertical' ? rect.left : clientX, | ||
| right: followCursor === 'vertical' ? rect.right : clientX | ||
| }; | ||
| } | ||
| }; | ||
| instance.popperInstance.update(); | ||
| }); | ||
| } | ||
@@ -485,23 +1858,4 @@ | ||
| return { | ||
| onAfterUpdate: function onAfterUpdate(_, partialProps) { | ||
| if (!isInternallySettingControlledProp) { | ||
| setUserProps(partialProps); | ||
| if (partialProps.placement) { | ||
| handlePlacement(); | ||
| } | ||
| } // A new placement causes the popperInstance to be recreated | ||
| if (partialProps.placement) { | ||
| handlePopperListeners(); | ||
| } // Wait for `.update()` to set `instance.state.currentPlacement` to | ||
| // the new placement | ||
| requestAnimationFrame(triggerLastMouseMove); | ||
| }, | ||
| onMount: function onMount() { | ||
| triggerLastMouseMove(); | ||
| handlePopperListeners(); | ||
| }, | ||
@@ -519,3 +1873,2 @@ onShow: function onShow() { | ||
| lastMouseMoveEvent = mouseCoords; | ||
| handlePlacement(); | ||
| handleMouseMoveListener(); | ||
@@ -538,3 +1891,2 @@ } | ||
| handlePlacement(); | ||
| handleMouseMoveListener(); | ||
@@ -557,14 +1909,5 @@ }, | ||
| }; | ||
| function getVirtualOffsets(popper, isVerticalPlacement) { | ||
| var size = isVerticalPlacement ? popper.offsetWidth : popper.offsetHeight; | ||
| return { | ||
| size: size, | ||
| x: isVerticalPlacement ? size : 0, | ||
| y: isVerticalPlacement ? 0 : size | ||
| }; | ||
| } | ||
| // position. This will require the `followCursor` plugin's fixes for overflow | ||
| // due to using event.clientX/Y values. (normalizedPlacement, getVirtualOffsets) | ||
| // TODO: Work on a "cursor" value so it chooses a rect optimal to the cursor | ||
| // position. | ||
| var inlinePositioning = { | ||
@@ -576,26 +1919,41 @@ name: 'inlinePositioning', | ||
| function getIsEnabled() { | ||
| function isEnabled() { | ||
| return !!instance.props.inlinePositioning; | ||
| } | ||
| return { | ||
| onHidden: function onHidden() { | ||
| if (getIsEnabled()) { | ||
| instance.popperInstance.reference = reference; | ||
| var placement; | ||
| var modifier = { | ||
| name: 'tippyInlinePositioning', | ||
| enabled: true, | ||
| phase: 'afterWrite', | ||
| fn: function fn(_ref) { | ||
| var state = _ref.state; | ||
| if (isEnabled()) { | ||
| if (placement !== state.placement) { | ||
| instance.setProps({ | ||
| getReferenceClientRect: function getReferenceClientRect() { | ||
| return _getReferenceClientRect(state.placement); | ||
| } | ||
| }); | ||
| } | ||
| placement = state.placement; | ||
| } | ||
| }, | ||
| onShow: function onShow() { | ||
| if (!getIsEnabled()) { | ||
| return; | ||
| } | ||
| } | ||
| }; | ||
| instance.popperInstance.reference = { | ||
| referenceNode: reference, | ||
| // These `client` values don't get used by Popper.js if they are 0 | ||
| clientWidth: 0, | ||
| clientHeight: 0, | ||
| getBoundingClientRect: function getBoundingClientRect() { | ||
| return getInlineBoundingClientRect(instance.state.currentPlacement && getBasePlacement(instance.state.currentPlacement), reference.getBoundingClientRect(), arrayFrom(reference.getClientRects())); | ||
| function _getReferenceClientRect(placement) { | ||
| return getInlineBoundingClientRect(getBasePlacement(placement), reference.getBoundingClientRect(), arrayFrom(reference.getClientRects())); | ||
| } | ||
| return { | ||
| onCreate: function onCreate() { | ||
| var _instance$popperInsta; | ||
| instance.setProps({ | ||
| popperOptions: { | ||
| modifiers: [].concat(((_instance$popperInsta = instance.popperInstance) == null ? void 0 : _instance$popperInsta.state.options.modifiers) || [], [modifier]) | ||
| } | ||
| }; | ||
| }); | ||
| } | ||
@@ -680,3 +2038,3 @@ }; | ||
| function getReference() { | ||
| return instance.popperInstance ? instance.popperInstance.reference : reference; | ||
| return instance.popperInstance ? instance.popperInstance.state.elements.reference : reference; | ||
| } | ||
@@ -696,3 +2054,5 @@ | ||
| if (currentRefRect && areRectsDifferent(prevRefRect, currentRefRect) || currentPopRect && areRectsDifferent(prevPopRect, currentPopRect)) { | ||
| instance.popperInstance.update(); | ||
| if (instance.popperInstance) { | ||
| instance.popperInstance.update(); | ||
| } | ||
| } | ||
@@ -726,3 +2086,8 @@ | ||
| export { animateFill, createSingleton, delegate, followCursor, inlinePositioning, sticky }; | ||
| tippy.setDefaultProps({ | ||
| render: render | ||
| }); | ||
| export default tippy; | ||
| export { animateFill, createSingleton, delegate, followCursor, hideAll, inlinePositioning, ROUND_ARROW as roundArrow, sticky }; | ||
| //# sourceMappingURL=tippy.esm.js.map |
139
index.d.ts
@@ -1,9 +0,7 @@ | ||
| import Popper from 'popper.js'; | ||
| import * as Popper from '@popperjs/core'; | ||
| export type BasePlacement = 'top' | 'bottom' | 'left' | 'right'; | ||
| export type BasePlacement = Popper.Placement; | ||
| export type Placement = Popper.Placement; | ||
| export type Boundary = Popper.Boundary | HTMLElement; | ||
| export type Content = string | Element | ((ref: Element) => Element | string); | ||
@@ -25,7 +23,2 @@ | ||
| export interface PopperInstance extends Popper { | ||
| // Undo the static so we can mutate values inside for `tippyDistance` | ||
| modifiers: Popper.BaseModifier[]; | ||
| } | ||
| export interface LifecycleHooks<TProps = Props> { | ||
@@ -51,21 +44,24 @@ onAfterUpdate( | ||
| export interface Props extends LifecycleHooks { | ||
| export interface RenderProps { | ||
| allowHTML: boolean; | ||
| animation: string | false; | ||
| arrow: boolean | string | SVGElement; | ||
| content: Content; | ||
| inertia: boolean; | ||
| maxWidth: number | string; | ||
| role: string; | ||
| theme: string; | ||
| zIndex: number; | ||
| } | ||
| export interface Props extends LifecycleHooks, RenderProps { | ||
| animateFill: boolean; | ||
| animation: string; | ||
| appendTo: 'parent' | Element | ((ref: Element) => Element); | ||
| aria: 'describedby' | 'labelledby' | null; | ||
| arrow: boolean | string | SVGElement; | ||
| boundary: Boundary; | ||
| content: Content; | ||
| delay: number | [number | null, number | null]; | ||
| distance: number | string; | ||
| duration: number | [number | null, number | null]; | ||
| flip: boolean; | ||
| flipBehavior: 'flip' | Placement[]; | ||
| flipOnUpdate: boolean; | ||
| followCursor: boolean | 'horizontal' | 'vertical' | 'initial'; | ||
| getReferenceClientRect: null | (() => ClientRect); | ||
| hideOnClick: boolean | 'toggle'; | ||
| ignoreAttributes: boolean; | ||
| inertia: boolean; | ||
| inlinePositioning: boolean; | ||
@@ -75,21 +71,33 @@ interactive: boolean; | ||
| interactiveDebounce: number; | ||
| lazy: boolean; | ||
| maxWidth: number | string; | ||
| multiple: boolean; | ||
| offset: number | string; | ||
| moveTransition: string; | ||
| offset: | ||
| | [number, number] | ||
| | (({ | ||
| placement, | ||
| popper, | ||
| reference, | ||
| }: { | ||
| placement: Placement; | ||
| popper: Popper.Rect; | ||
| reference: Popper.Rect; | ||
| }) => [number, number]); | ||
| placement: Placement; | ||
| plugins: Plugin[]; | ||
| popperOptions: Popper.PopperOptions; | ||
| role: string; | ||
| popperOptions: Partial<Popper.Options>; | ||
| render: | ||
| | (( | ||
| instance: Instance, | ||
| ) => { | ||
| popper: PopperElement; | ||
| update?: (prevProps: Props, nextProps: Props) => void; | ||
| }) | ||
| | null; | ||
| showOnCreate: boolean; | ||
| sticky: boolean | 'reference' | 'popper'; | ||
| theme: string; | ||
| touch: boolean | 'hold' | ['hold', number]; | ||
| trigger: string; | ||
| triggerTarget: Element | Element[] | null; | ||
| updateDuration: number; | ||
| zIndex: number; | ||
| } | ||
| export interface DefaultProps extends Props { | ||
| export interface DefaultProps extends Omit<Props, 'delay' | 'duration'> { | ||
| delay: number | [number, number]; | ||
@@ -104,8 +112,7 @@ duration: number | [number, number]; | ||
| enable(): void; | ||
| hide(duration?: number): void; | ||
| hide(): void; | ||
| id: number; | ||
| plugins: Plugin<TProps>[]; | ||
| popper: PopperElement<TProps>; | ||
| popperChildren: PopperChildren; | ||
| popperInstance: PopperInstance | null; | ||
| popperInstance: Popper.Instance | null; | ||
| props: TProps; | ||
@@ -115,3 +122,3 @@ reference: ReferenceElement<TProps>; | ||
| setProps(partialProps: Partial<TProps>): void; | ||
| show(duration?: number): void; | ||
| show(): void; | ||
| state: { | ||
@@ -125,8 +132,10 @@ currentPlacement: Placement | null; | ||
| }; | ||
| unmount(): void; | ||
| } | ||
| export interface PopperChildren { | ||
| tooltip: HTMLDivElement; | ||
| box: HTMLDivElement; | ||
| content: HTMLDivElement; | ||
| arrow: HTMLDivElement | null; | ||
| backdrop: HTMLDivElement | null; | ||
| } | ||
@@ -137,3 +146,2 @@ | ||
| readonly defaultProps: DefaultProps; | ||
| readonly version: string; | ||
| setDefaultProps(partialProps: Partial<DefaultProps>): void; | ||
@@ -143,17 +151,9 @@ } | ||
| export interface Tippy<TProps = Props> extends TippyStatics { | ||
| ( | ||
| targets: SingleTarget, | ||
| optionalProps?: Partial<TProps>, | ||
| /** @deprecated use Props.plugins */ | ||
| plugins?: Plugin<TProps>[], | ||
| ): Instance<TProps>; | ||
| (targets: SingleTarget, optionalProps?: Partial<TProps>): Instance<TProps>; | ||
| } | ||
| export interface Tippy<TProps = Props> extends TippyStatics { | ||
| ( | ||
| targets: MultipleTargets, | ||
| optionalProps?: Partial<TProps>, | ||
| /** @deprecated use Props.plugins */ | ||
| plugins?: Plugin<TProps>[], | ||
| ): Instance<TProps>[]; | ||
| (targets: MultipleTargets, optionalProps?: Partial<TProps>): Instance< | ||
| TProps | ||
| >[]; | ||
| } | ||
@@ -174,4 +174,2 @@ | ||
| props: Partial<TProps> & {target: string}, | ||
| /** @deprecated use Props.plugins */ | ||
| plugins?: Plugin<TProps>[], | ||
| ): DelegateInstance<TProps>; | ||
@@ -184,4 +182,2 @@ } | ||
| props: Partial<TProps> & {target: string}, | ||
| /** @deprecated use Props.plugins */ | ||
| plugins?: Plugin<TProps>[], | ||
| ): DelegateInstance<TProps>[]; | ||
@@ -192,5 +188,3 @@ } | ||
| tippyInstances: Instance<TProps | Props>[], | ||
| optionalProps?: Partial<TProps>, | ||
| /** @deprecated use Props.plugins */ | ||
| plugins?: Plugin<TProps>[], | ||
| optionalProps?: Partial<TProps> & {overrides?: Array<keyof Props>}, | ||
| ) => Instance<TProps>; | ||
@@ -210,12 +204,5 @@ | ||
| export interface AnimateFillInstance extends Instance { | ||
| popperChildren: PopperChildren & { | ||
| backdrop: HTMLDivElement | null; | ||
| }; | ||
| } | ||
| export interface AnimateFill extends Plugin { | ||
| name: 'animateFill'; | ||
| defaultValue: false; | ||
| fn(instance: AnimateFillInstance): Partial<LifecycleHooks>; | ||
| } | ||
@@ -256,35 +243,5 @@ | ||
| // ============================================================================= | ||
| // Deprecated types - these will be removed in the next major | ||
| // ============================================================================= | ||
| /** | ||
| * @deprecated use tippy.setDefaultProps({plugins: [...]}); | ||
| */ | ||
| export type CreateTippyWithPlugins = (outerPlugins: Plugin[]) => Tippy; | ||
| declare const createTippyWithPlugins: CreateTippyWithPlugins; | ||
| /** @deprecated */ | ||
| export interface AnimateFillProps { | ||
| animateFill: Props['animateFill']; | ||
| } | ||
| /** @deprecated */ | ||
| export interface FollowCursorProps { | ||
| followCursor: Props['followCursor']; | ||
| } | ||
| /** @deprecated */ | ||
| export interface InlinePositioningProps { | ||
| inlinePositioning: Props['inlinePositioning']; | ||
| } | ||
| /** @deprecated */ | ||
| export interface StickyProps { | ||
| sticky: Props['sticky']; | ||
| } | ||
| export default tippy; | ||
| export { | ||
| hideAll, | ||
| createTippyWithPlugins, | ||
| delegate, | ||
@@ -291,0 +248,0 @@ createSingleton, |
102
package.json
| { | ||
| "name": "tippy.js", | ||
| "version": "5.2.0", | ||
| "version": "6.0.0-alpha.0", | ||
| "description": "Highly customizable tooltip and popover library", | ||
| "main": "dist/tippy.cjs.js", | ||
| "main": "dist/tippy.umd.js", | ||
| "module": "dist/tippy.esm.js", | ||
| "unpkg": "dist/tippy-bundle.iife.min.js", | ||
| "unpkg": "dist/tippy-bundle.umd.min.js", | ||
| "types": "index.d.ts", | ||
| "sideEffects": [ | ||
| "dist/tippy-bundle*", | ||
| "**/*.css" | ||
@@ -40,12 +39,11 @@ ], | ||
| "scripts": { | ||
| "dev": "parcel demo/index.html -d .devserver", | ||
| "dev:flip": "parcel demo/flip/index.html -d .devserver", | ||
| "dev:themes": "parcel demo/themes/index.html -d .devserver", | ||
| "dev:animations": "parcel demo/animations/index.html -d .devserver", | ||
| "dev:addons": "parcel demo/addons/index.html -d .devserver", | ||
| "dev:plugins": "parcel demo/plugins/index.html -d .devserver", | ||
| "build": "node rollup.pre-build && rollup --config && bundlesize", | ||
| "test": "jest --coverage", | ||
| "dev": "NODE_ENV=dev rollup -c --watch", | ||
| "build": "node rollup.css && rollup -c && bundlesize", | ||
| "build:visual": "NODE_ENV=test rollup -c", | ||
| "serve": "serve test/visual", | ||
| "test:dom": "jest unit integration --coverage", | ||
| "test:functional": "jest functional", | ||
| "test": "npm run test:dom && npm run test:functional", | ||
| "check-types": "tsc", | ||
| "lint": "eslint --report-unused-disable-directives . --ext .ts,.js", | ||
| "lint": "eslint . --ext .ts,.js", | ||
| "format": "prettier --write \"**/*.{js,ts,json,md,mdx,scss,css}\"", | ||
@@ -55,11 +53,2 @@ "clean": "rimraf dist/ themes/ animations/ coverage/ .devserver/ .cache/ ./index.d.ts", | ||
| }, | ||
| "jest": { | ||
| "globals": { | ||
| "__DEV__": true | ||
| }, | ||
| "setupFilesAfterEnv": [ | ||
| "./test/setup.js" | ||
| ], | ||
| "testRegex": "./test/.*.test.js$" | ||
| }, | ||
| "browserslist": [ | ||
@@ -72,10 +61,14 @@ "> 0.5%", | ||
| { | ||
| "path": "dist/tippy-bundle.iife.min.js", | ||
| "path": "dist/tippy-bundle.umd.min.js", | ||
| "maxSize": "10 kB" | ||
| }, | ||
| { | ||
| "path": "dist/tippy.iife.min.js", | ||
| "path": "dist/tippy-headless.umd.min.js", | ||
| "maxSize": "10 kB" | ||
| }, | ||
| { | ||
| "path": "dist/tippy.umd.min.js", | ||
| "maxSize": "10 kB" | ||
| }, | ||
| { | ||
| "path": "dist/tippy.css", | ||
@@ -93,3 +86,3 @@ "maxSize": "5 kB" | ||
| "jest --findRelatedTests", | ||
| "eslint --report-unused-disable-directives . --ext .ts,.js", | ||
| "eslint . --ext .ts,.js", | ||
| "git add" | ||
@@ -103,30 +96,35 @@ ], | ||
| "devDependencies": { | ||
| "@babel/core": "^7.5.5", | ||
| "@babel/plugin-proposal-object-rest-spread": "^7.5.5", | ||
| "@babel/plugin-transform-template-literals": "^7.4.4", | ||
| "@babel/preset-env": "^7.5.5", | ||
| "@babel/preset-typescript": "^7.3.3", | ||
| "@testing-library/dom": "^6.8.1", | ||
| "@types/node": "^12.7.2", | ||
| "@typescript-eslint/eslint-plugin": "^2.0.0", | ||
| "@typescript-eslint/parser": "^2.12.0", | ||
| "autoprefixer": "^9.6.1", | ||
| "babel-jest": "^24.8.0", | ||
| "@babel/core": "^7.8.3", | ||
| "@babel/plugin-proposal-object-rest-spread": "^7.8.3", | ||
| "@babel/plugin-transform-template-literals": "^7.8.3", | ||
| "@babel/preset-env": "^7.8.3", | ||
| "@babel/preset-typescript": "^7.8.3", | ||
| "@testing-library/dom": "^6.11.0", | ||
| "@types/node": "^12.12.25", | ||
| "@typescript-eslint/eslint-plugin": "^2.17.0", | ||
| "@typescript-eslint/parser": "^2.17.0", | ||
| "autoprefixer": "^9.7.4", | ||
| "babel-jest": "^24.9.0", | ||
| "babel-plugin-dev-expression": "^0.2.2", | ||
| "bundlesize": "^0.18.0", | ||
| "colorette": "^1.1.0", | ||
| "core-js": "^3.6.4", | ||
| "cssnano": "^4.1.10", | ||
| "eslint": "^6.1.0", | ||
| "eslint-config-prettier": "^6.0.0", | ||
| "husky": "^3.0.3", | ||
| "jest": "^24.8.0", | ||
| "lint-staged": "^9.2.1", | ||
| "node-sass": "^4.12.0", | ||
| "parcel-bundler": "^1.12.4", | ||
| "postcss": "^7.0.17", | ||
| "prettier": "^1.18.2", | ||
| "dotenv": "^8.2.0", | ||
| "eslint": "^6.8.0", | ||
| "eslint-config-prettier": "^6.9.0", | ||
| "husky": "^3.1.0", | ||
| "jest": "^24.9.0", | ||
| "jest-environment-jsdom-fourteen": "^1.0.1", | ||
| "jest-image-snapshot": "^2.12.0", | ||
| "jest-puppeteer": "^4.4.0", | ||
| "lint-staged": "^9.5.0", | ||
| "parcel": "^2.0.0-alpha.3.2", | ||
| "popmotion": "^8.7.1", | ||
| "postcss": "^7.0.26", | ||
| "prettier": "^1.19.1", | ||
| "promise": "^8.0.3", | ||
| "react-flip-toolkit": "^6.6.9", | ||
| "puppeteer": "^2.1.0", | ||
| "rimraf": "^3.0.0", | ||
| "rollup": "^1.19.4", | ||
| "rollup": "^1.29.1", | ||
| "rollup-plugin-babel": "^4.3.3", | ||
@@ -136,11 +134,15 @@ "rollup-plugin-commonjs": "^10.0.2", | ||
| "rollup-plugin-json": "^4.0.0", | ||
| "rollup-plugin-livereload": "^1.0.4", | ||
| "rollup-plugin-node-resolve": "^5.2.0", | ||
| "rollup-plugin-replace": "^2.2.0", | ||
| "rollup-plugin-sass": "^1.2.2", | ||
| "rollup-plugin-terser": "^5.1.1", | ||
| "typescript": "^3.5.3" | ||
| "rollup-plugin-serve": "^1.0.1", | ||
| "rollup-plugin-terser": "^5.2.0", | ||
| "sass": "^1.25.0", | ||
| "serve": "^11.3.0", | ||
| "typescript": "^3.7.5" | ||
| }, | ||
| "dependencies": { | ||
| "popper.js": "^1.16.0" | ||
| "@popperjs/core": "^2.0.5" | ||
| } | ||
| } |
@@ -7,3 +7,3 @@ <div align="center"> | ||
| <h1>Tippy.js</h1> | ||
| <p>A highly customizable tooltip and popover library powered by Popper.js.</p> | ||
| <p>A highly customizable tooltip and popover library powered by Popper.</p> | ||
| <a href="https://www.npmjs.com/package/tippy.js"> | ||
@@ -33,6 +33,6 @@ <img src="https://img.shields.io/npm/dm/tippy.js.svg?color=%235599ff&style=for-the-badge" alt="npm Downloads per Month"> | ||
| # npm | ||
| npm i tippy.js | ||
| npm i tippy.js@next | ||
| # Yarn | ||
| yarn add tippy.js | ||
| yarn add tippy.js@next | ||
| ``` | ||
@@ -50,4 +50,4 @@ | ||
| ```html | ||
| <script src="https://unpkg.com/popper.js@1"></script> | ||
| <script src="https://unpkg.com/tippy.js@5"></script> | ||
| <script src="https://unpkg.com/@popperjs/core@2"></script> | ||
| <script src="https://unpkg.com/tippy.js@next"></script> | ||
| ``` | ||
@@ -54,0 +54,0 @@ |
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Long strings
Supply chain riskContains long string literals, which may be a sign of obfuscated or packed code.
Found 1 instance in 1 package
Minified code
QualityThis package contains minified code. This may be harmless in some cases where minified code is included in packaged libraries, however packages on npm should not minify code.
Found 1 instance in 1 package
No v1
QualityPackage is not semver >=1. This means it is not stable and does not support ^ ranges.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Long strings
Supply chain riskContains long string literals, which may be a sign of obfuscated or packed code.
Found 1 instance in 1 package
Improved metrics
- Total package byte prevSize
- increased by3.68%
1359571
- Number of low supply chain risk alerts
- decreased by-14.29%
24
Worsened metrics
- Dev dependency count
- increased by24.32%
46
- Number of package files
- decreased by-9.3%
39
- Lines of code
- decreased by-2.62%
9117
- Number of low quality alerts
- increased byInfinity%
4
- Number of medium supply chain risk alerts
- increased byInfinity%
1
Dependency changes
+ Added@popperjs/core@^2.0.5
+ Added@popperjs/core@2.11.8(transitive)
- Removedpopper.js@^1.16.0
- Removedpopper.js@1.16.1(transitive)