(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.ReactTooltip = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { args[_key - 1] = arguments[_key]; } var argIndex = 0; var message = 'Warning: ' + format.replace(/%s/g, function () { return args[argIndex++]; }); if (typeof console !== 'undefined') { console.error(message); } try { // --- Welcome to debugging React --- // This error was thrown as a convenience so that you can use this stack // to find the callsite that caused this warning to fire. throw new Error(message); } catch (x) {} }; warning = function warning(condition, format) { if (format === undefined) { throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument'); } if (format.indexOf('Failed Composite propType: ') === 0) { return; // Ignore CompositeComponent proptype check. } if (!condition) { for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { args[_key2 - 2] = arguments[_key2]; } printWarning.apply(undefined, [format].concat(args)); } }; } module.exports = warning; }).call(this,require('_process')) },{"./emptyFunction":2,"_process":6}],5:[function(require,module,exports){ /* object-assign (c) Sindre Sorhus @license MIT */ 'use strict'; /* eslint-disable no-unused-vars */ var getOwnPropertySymbols = Object.getOwnPropertySymbols; var hasOwnProperty = Object.prototype.hasOwnProperty; var propIsEnumerable = Object.prototype.propertyIsEnumerable; function toObject(val) { if (val === null || val === undefined) { throw new TypeError('Object.assign cannot be called with null or undefined'); } return Object(val); } function shouldUseNative() { try { if (!Object.assign) { return false; } // Detect buggy property enumeration order in older V8 versions. // https://bugs.chromium.org/p/v8/issues/detail?id=4118 var test1 = new String('abc'); // eslint-disable-line no-new-wrappers test1[5] = 'de'; if (Object.getOwnPropertyNames(test1)[0] === '5') { return false; } // https://bugs.chromium.org/p/v8/issues/detail?id=3056 var test2 = {}; for (var i = 0; i < 10; i++) { test2['_' + String.fromCharCode(i)] = i; } var order2 = Object.getOwnPropertyNames(test2).map(function (n) { return test2[n]; }); if (order2.join('') !== '0123456789') { return false; } // https://bugs.chromium.org/p/v8/issues/detail?id=3056 var test3 = {}; 'abcdefghijklmnopqrst'.split('').forEach(function (letter) { test3[letter] = letter; }); if (Object.keys(Object.assign({}, test3)).join('') !== 'abcdefghijklmnopqrst') { return false; } return true; } catch (err) { // We don't expect any of the above to throw, but better to be safe. return false; } } module.exports = shouldUseNative() ? Object.assign : function (target, source) { var from; var to = toObject(target); var symbols; for (var s = 1; s < arguments.length; s++) { from = Object(arguments[s]); for (var key in from) { if (hasOwnProperty.call(from, key)) { to[key] = from[key]; } } if (getOwnPropertySymbols) { symbols = getOwnPropertySymbols(from); for (var i = 0; i < symbols.length; i++) { if (propIsEnumerable.call(from, symbols[i])) { to[symbols[i]] = from[symbols[i]]; } } } } return to; }; },{}],6:[function(require,module,exports){ // shim for using process in browser var process = module.exports = {}; // cached from whatever global is present so that test runners that stub it // don't break things. But we need to wrap it in a try catch in case it is // wrapped in strict mode code which doesn't define any globals. It's inside a // function because try/catches deoptimize in certain engines. var cachedSetTimeout; var cachedClearTimeout; function defaultSetTimout() { throw new Error('setTimeout has not been defined'); } function defaultClearTimeout () { throw new Error('clearTimeout has not been defined'); } (function () { try { if (typeof setTimeout === 'function') { cachedSetTimeout = setTimeout; } else { cachedSetTimeout = defaultSetTimout; } } catch (e) { cachedSetTimeout = defaultSetTimout; } try { if (typeof clearTimeout === 'function') { cachedClearTimeout = clearTimeout; } else { cachedClearTimeout = defaultClearTimeout; } } catch (e) { cachedClearTimeout = defaultClearTimeout; } } ()) function runTimeout(fun) { if (cachedSetTimeout === setTimeout) { //normal enviroments in sane situations return setTimeout(fun, 0); } // if setTimeout wasn't available but was latter defined if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { cachedSetTimeout = setTimeout; return setTimeout(fun, 0); } try { // when when somebody has screwed with setTimeout but no I.E. maddness return cachedSetTimeout(fun, 0); } catch(e){ try { // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally return cachedSetTimeout.call(null, fun, 0); } catch(e){ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error return cachedSetTimeout.call(this, fun, 0); } } } function runClearTimeout(marker) { if (cachedClearTimeout === clearTimeout) { //normal enviroments in sane situations return clearTimeout(marker); } // if clearTimeout wasn't available but was latter defined if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { cachedClearTimeout = clearTimeout; return clearTimeout(marker); } try { // when when somebody has screwed with setTimeout but no I.E. maddness return cachedClearTimeout(marker); } catch (e){ try { // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally return cachedClearTimeout.call(null, marker); } catch (e){ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. // Some versions of I.E. have different rules for clearTimeout vs setTimeout return cachedClearTimeout.call(this, marker); } } } var queue = []; var draining = false; var currentQueue; var queueIndex = -1; function cleanUpNextTick() { if (!draining || !currentQueue) { return; } draining = false; if (currentQueue.length) { queue = currentQueue.concat(queue); } else { queueIndex = -1; } if (queue.length) { drainQueue(); } } function drainQueue() { if (draining) { return; } var timeout = runTimeout(cleanUpNextTick); draining = true; var len = queue.length; while(len) { currentQueue = queue; queue = []; while (++queueIndex < len) { if (currentQueue) { currentQueue[queueIndex].run(); } } queueIndex = -1; len = queue.length; } currentQueue = null; draining = false; runClearTimeout(timeout); } process.nextTick = function (fun) { var args = new Array(arguments.length - 1); if (arguments.length > 1) { for (var i = 1; i < arguments.length; i++) { args[i - 1] = arguments[i]; } } queue.push(new Item(fun, args)); if (queue.length === 1 && !draining) { runTimeout(drainQueue); } }; // v8 likes predictible objects function Item(fun, array) { this.fun = fun; this.array = array; } Item.prototype.run = function () { this.fun.apply(null, this.array); }; process.title = 'browser'; process.browser = true; process.env = {}; process.argv = []; process.version = ''; // empty string to avoid regexp issues process.versions = {}; function noop() {} process.on = noop; process.addListener = noop; process.once = noop; process.off = noop; process.removeListener = noop; process.removeAllListeners = noop; process.emit = noop; process.prependListener = noop; process.prependOnceListener = noop; process.listeners = function (name) { return [] } process.binding = function (name) { throw new Error('process.binding is not supported'); }; process.cwd = function () { return '/' }; process.chdir = function (dir) { throw new Error('process.chdir is not supported'); }; process.umask = function() { return 0; }; },{}],7:[function(require,module,exports){ (function (process){ /** * Copyright (c) 2013-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ 'use strict'; if (process.env.NODE_ENV !== 'production') { var invariant = require('fbjs/lib/invariant'); var warning = require('fbjs/lib/warning'); var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret'); var loggedTypeFailures = {}; } /** * Assert that the values match with the type specs. * Error messages are memorized and will only be shown once. * * @param {object} typeSpecs Map of name to a ReactPropType * @param {object} values Runtime values that need to be type-checked * @param {string} location e.g. "prop", "context", "child context" * @param {string} componentName Name of the component for error messages. * @param {?Function} getStack Returns the component stack. * @private */ function checkPropTypes(typeSpecs, values, location, componentName, getStack) { if (process.env.NODE_ENV !== 'production') { for (var typeSpecName in typeSpecs) { if (typeSpecs.hasOwnProperty(typeSpecName)) { var error; // Prop type validation may throw. In case they do, we don't want to // fail the render phase where it didn't fail before. So we log it. // After these have been cleaned up, we'll let them throw. try { // This is intentionally an invariant that gets caught. It's the same // behavior as without this statement except with a better message. invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]); error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret); } catch (ex) { error = ex; } warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error); if (error instanceof Error && !(error.message in loggedTypeFailures)) { // Only monitor this failure once because there tends to be a lot of the // same error. loggedTypeFailures[error.message] = true; var stack = getStack ? getStack() : ''; warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : ''); } } } } } module.exports = checkPropTypes; }).call(this,require('_process')) },{"./lib/ReactPropTypesSecret":11,"_process":6,"fbjs/lib/invariant":3,"fbjs/lib/warning":4}],8:[function(require,module,exports){ /** * Copyright (c) 2013-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ 'use strict'; var emptyFunction = require('fbjs/lib/emptyFunction'); var invariant = require('fbjs/lib/invariant'); var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret'); module.exports = function() { function shim(props, propName, componentName, location, propFullName, secret) { if (secret === ReactPropTypesSecret) { // It is still safe when called from React. return; } invariant( false, 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use PropTypes.checkPropTypes() to call them. ' + 'Read more at http://fb.me/use-check-prop-types' ); }; shim.isRequired = shim; function getShim() { return shim; }; // Important! // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`. var ReactPropTypes = { array: shim, bool: shim, func: shim, number: shim, object: shim, string: shim, symbol: shim, any: shim, arrayOf: getShim, element: shim, instanceOf: getShim, node: shim, objectOf: getShim, oneOf: getShim, oneOfType: getShim, shape: getShim, exact: getShim }; ReactPropTypes.checkPropTypes = emptyFunction; ReactPropTypes.PropTypes = ReactPropTypes; return ReactPropTypes; }; },{"./lib/ReactPropTypesSecret":11,"fbjs/lib/emptyFunction":2,"fbjs/lib/invariant":3}],9:[function(require,module,exports){ (function (process){ /** * Copyright (c) 2013-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ 'use strict'; var emptyFunction = require('fbjs/lib/emptyFunction'); var invariant = require('fbjs/lib/invariant'); var warning = require('fbjs/lib/warning'); var assign = require('object-assign'); var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret'); var checkPropTypes = require('./checkPropTypes'); module.exports = function(isValidElement, throwOnDirectAccess) { /* global Symbol */ var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec. /** * Returns the iterator method function contained on the iterable object. * * Be sure to invoke the function with the iterable as context: * * var iteratorFn = getIteratorFn(myIterable); * if (iteratorFn) { * var iterator = iteratorFn.call(myIterable); * ... * } * * @param {?object} maybeIterable * @return {?function} */ function getIteratorFn(maybeIterable) { var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]); if (typeof iteratorFn === 'function') { return iteratorFn; } } /** * Collection of methods that allow declaration and validation of props that are * supplied to React components. Example usage: * * var Props = require('ReactPropTypes'); * var MyArticle = React.createClass({ * propTypes: { * // An optional string prop named "description". * description: Props.string, * * // A required enum prop named "category". * category: Props.oneOf(['News','Photos']).isRequired, * * // A prop named "dialog" that requires an instance of Dialog. * dialog: Props.instanceOf(Dialog).isRequired * }, * render: function() { ... } * }); * * A more formal specification of how these methods are used: * * type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...) * decl := ReactPropTypes.{type}(.isRequired)? * * Each and every declaration produces a function with the same signature. This * allows the creation of custom validation functions. For example: * * var MyLink = React.createClass({ * propTypes: { * // An optional string or URI prop named "href". * href: function(props, propName, componentName) { * var propValue = props[propName]; * if (propValue != null && typeof propValue !== 'string' && * !(propValue instanceof URI)) { * return new Error( * 'Expected a string or an URI for ' + propName + ' in ' + * componentName * ); * } * } * }, * render: function() {...} * }); * * @internal */ var ANONYMOUS = '<>'; // Important! // Keep this list in sync with production version in `./factoryWithThrowingShims.js`. var ReactPropTypes = { array: createPrimitiveTypeChecker('array'), bool: createPrimitiveTypeChecker('boolean'), func: createPrimitiveTypeChecker('function'), number: createPrimitiveTypeChecker('number'), object: createPrimitiveTypeChecker('object'), string: createPrimitiveTypeChecker('string'), symbol: createPrimitiveTypeChecker('symbol'), any: createAnyTypeChecker(), arrayOf: createArrayOfTypeChecker, element: createElementTypeChecker(), instanceOf: createInstanceTypeChecker, node: createNodeChecker(), objectOf: createObjectOfTypeChecker, oneOf: createEnumTypeChecker, oneOfType: createUnionTypeChecker, shape: createShapeTypeChecker, exact: createStrictShapeTypeChecker, }; /** * inlined Object.is polyfill to avoid requiring consumers ship their own * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is */ /*eslint-disable no-self-compare*/ function is(x, y) { // SameValue algorithm if (x === y) { // Steps 1-5, 7-10 // Steps 6.b-6.e: +0 != -0 return x !== 0 || 1 / x === 1 / y; } else { // Step 6.a: NaN == NaN return x !== x && y !== y; } } /*eslint-enable no-self-compare*/ /** * We use an Error-like object for backward compatibility as people may call * PropTypes directly and inspect their output. However, we don't use real * Errors anymore. We don't inspect their stack anyway, and creating them * is prohibitively expensive if they are created too often, such as what * happens in oneOfType() for any type before the one that matched. */ function PropTypeError(message) { this.message = message; this.stack = ''; } // Make `instanceof Error` still work for returned errors. PropTypeError.prototype = Error.prototype; function createChainableTypeChecker(validate) { if (process.env.NODE_ENV !== 'production') { var manualPropTypeCallCache = {}; var manualPropTypeWarningCount = 0; } function checkType(isRequired, props, propName, componentName, location, propFullName, secret) { componentName = componentName || ANONYMOUS; propFullName = propFullName || propName; if (secret !== ReactPropTypesSecret) { if (throwOnDirectAccess) { // New behavior only for users of `prop-types` package invariant( false, 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use `PropTypes.checkPropTypes()` to call them. ' + 'Read more at http://fb.me/use-check-prop-types' ); } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') { // Old behavior for people using React.PropTypes var cacheKey = componentName + ':' + propName; if ( !manualPropTypeCallCache[cacheKey] && // Avoid spamming the console because they are often not actionable except for lib authors manualPropTypeWarningCount < 3 ) { warning( false, 'You are manually calling a React.PropTypes validation ' + 'function for the `%s` prop on `%s`. This is deprecated ' + 'and will throw in the standalone `prop-types` package. ' + 'You may be seeing this warning due to a third-party PropTypes ' + 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.', propFullName, componentName ); manualPropTypeCallCache[cacheKey] = true; manualPropTypeWarningCount++; } } } if (props[propName] == null) { if (isRequired) { if (props[propName] === null) { return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.')); } return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.')); } return null; } else { return validate(props, propName, componentName, location, propFullName); } } var chainedCheckType = checkType.bind(null, false); chainedCheckType.isRequired = checkType.bind(null, true); return chainedCheckType; } function createPrimitiveTypeChecker(expectedType) { function validate(props, propName, componentName, location, propFullName, secret) { var propValue = props[propName]; var propType = getPropType(propValue); if (propType !== expectedType) { // `propValue` being instance of, say, date/regexp, pass the 'object' // check, but we can offer a more precise error message here rather than // 'of type `object`'. var preciseType = getPreciseType(propValue); return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.')); } return null; } return createChainableTypeChecker(validate); } function createAnyTypeChecker() { return createChainableTypeChecker(emptyFunction.thatReturnsNull); } function createArrayOfTypeChecker(typeChecker) { function validate(props, propName, componentName, location, propFullName) { if (typeof typeChecker !== 'function') { return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.'); } var propValue = props[propName]; if (!Array.isArray(propValue)) { var propType = getPropType(propValue); return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.')); } for (var i = 0; i < propValue.length; i++) { var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret); if (error instanceof Error) { return error; } } return null; } return createChainableTypeChecker(validate); } function createElementTypeChecker() { function validate(props, propName, componentName, location, propFullName) { var propValue = props[propName]; if (!isValidElement(propValue)) { var propType = getPropType(propValue); return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.')); } return null; } return createChainableTypeChecker(validate); } function createInstanceTypeChecker(expectedClass) { function validate(props, propName, componentName, location, propFullName) { if (!(props[propName] instanceof expectedClass)) { var expectedClassName = expectedClass.name || ANONYMOUS; var actualClassName = getClassName(props[propName]); return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.')); } return null; } return createChainableTypeChecker(validate); } function createEnumTypeChecker(expectedValues) { if (!Array.isArray(expectedValues)) { process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0; return emptyFunction.thatReturnsNull; } function validate(props, propName, componentName, location, propFullName) { var propValue = props[propName]; for (var i = 0; i < expectedValues.length; i++) { if (is(propValue, expectedValues[i])) { return null; } } var valuesString = JSON.stringify(expectedValues); return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.')); } return createChainableTypeChecker(validate); } function createObjectOfTypeChecker(typeChecker) { function validate(props, propName, componentName, location, propFullName) { if (typeof typeChecker !== 'function') { return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.'); } var propValue = props[propName]; var propType = getPropType(propValue); if (propType !== 'object') { return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.')); } for (var key in propValue) { if (propValue.hasOwnProperty(key)) { var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret); if (error instanceof Error) { return error; } } } return null; } return createChainableTypeChecker(validate); } function createUnionTypeChecker(arrayOfTypeCheckers) { if (!Array.isArray(arrayOfTypeCheckers)) { process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0; return emptyFunction.thatReturnsNull; } for (var i = 0; i < arrayOfTypeCheckers.length; i++) { var checker = arrayOfTypeCheckers[i]; if (typeof checker !== 'function') { warning( false, 'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' + 'received %s at index %s.', getPostfixForTypeWarning(checker), i ); return emptyFunction.thatReturnsNull; } } function validate(props, propName, componentName, location, propFullName) { for (var i = 0; i < arrayOfTypeCheckers.length; i++) { var checker = arrayOfTypeCheckers[i]; if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) { return null; } } return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.')); } return createChainableTypeChecker(validate); } function createNodeChecker() { function validate(props, propName, componentName, location, propFullName) { if (!isNode(props[propName])) { return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.')); } return null; } return createChainableTypeChecker(validate); } function createShapeTypeChecker(shapeTypes) { function validate(props, propName, componentName, location, propFullName) { var propValue = props[propName]; var propType = getPropType(propValue); if (propType !== 'object') { return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.')); } for (var key in shapeTypes) { var checker = shapeTypes[key]; if (!checker) { continue; } var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret); if (error) { return error; } } return null; } return createChainableTypeChecker(validate); } function createStrictShapeTypeChecker(shapeTypes) { function validate(props, propName, componentName, location, propFullName) { var propValue = props[propName]; var propType = getPropType(propValue); if (propType !== 'object') { return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.')); } // We need to check all keys in case some are required but missing from // props. var allKeys = assign({}, props[propName], shapeTypes); for (var key in allKeys) { var checker = shapeTypes[key]; if (!checker) { return new PropTypeError( 'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' + '\nBad object: ' + JSON.stringify(props[propName], null, ' ') + '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' ') ); } var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret); if (error) { return error; } } return null; } return createChainableTypeChecker(validate); } function isNode(propValue) { switch (typeof propValue) { case 'number': case 'string': case 'undefined': return true; case 'boolean': return !propValue; case 'object': if (Array.isArray(propValue)) { return propValue.every(isNode); } if (propValue === null || isValidElement(propValue)) { return true; } var iteratorFn = getIteratorFn(propValue); if (iteratorFn) { var iterator = iteratorFn.call(propValue); var step; if (iteratorFn !== propValue.entries) { while (!(step = iterator.next()).done) { if (!isNode(step.value)) { return false; } } } else { // Iterator will provide entry [k,v] tuples rather than values. while (!(step = iterator.next()).done) { var entry = step.value; if (entry) { if (!isNode(entry[1])) { return false; } } } } } else { return false; } return true; default: return false; } } function isSymbol(propType, propValue) { // Native Symbol. if (propType === 'symbol') { return true; } // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol' if (propValue['@@toStringTag'] === 'Symbol') { return true; } // Fallback for non-spec compliant Symbols which are polyfilled. if (typeof Symbol === 'function' && propValue instanceof Symbol) { return true; } return false; } // Equivalent of `typeof` but with special handling for array and regexp. function getPropType(propValue) { var propType = typeof propValue; if (Array.isArray(propValue)) { return 'array'; } if (propValue instanceof RegExp) { // Old webkits (at least until Android 4.0) return 'function' rather than // 'object' for typeof a RegExp. We'll normalize this here so that /bla/ // passes PropTypes.object. return 'object'; } if (isSymbol(propType, propValue)) { return 'symbol'; } return propType; } // This handles more types than `getPropType`. Only used for error messages. // See `createPrimitiveTypeChecker`. function getPreciseType(propValue) { if (typeof propValue === 'undefined' || propValue === null) { return '' + propValue; } var propType = getPropType(propValue); if (propType === 'object') { if (propValue instanceof Date) { return 'date'; } else if (propValue instanceof RegExp) { return 'regexp'; } } return propType; } // Returns a string that is postfixed to a warning about an invalid type. // For example, "undefined" or "of type array" function getPostfixForTypeWarning(value) { var type = getPreciseType(value); switch (type) { case 'array': case 'object': return 'an ' + type; case 'boolean': case 'date': case 'regexp': return 'a ' + type; default: return type; } } // Returns class name of the object, if any. function getClassName(propValue) { if (!propValue.constructor || !propValue.constructor.name) { return ANONYMOUS; } return propValue.constructor.name; } ReactPropTypes.checkPropTypes = checkPropTypes; ReactPropTypes.PropTypes = ReactPropTypes; return ReactPropTypes; }; }).call(this,require('_process')) },{"./checkPropTypes":7,"./lib/ReactPropTypesSecret":11,"_process":6,"fbjs/lib/emptyFunction":2,"fbjs/lib/invariant":3,"fbjs/lib/warning":4,"object-assign":5}],10:[function(require,module,exports){ (function (process){ /** * Copyright (c) 2013-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ if (process.env.NODE_ENV !== 'production') { var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' && Symbol.for && Symbol.for('react.element')) || 0xeac7; var isValidElement = function(object) { return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; }; // By explicitly using `prop-types` you are opting into new development behavior. // http://fb.me/prop-types-in-prod var throwOnDirectAccess = true; module.exports = require('./factoryWithTypeCheckers')(isValidElement, throwOnDirectAccess); } else { // By explicitly using `prop-types` you are opting into new production behavior. // http://fb.me/prop-types-in-prod module.exports = require('./factoryWithThrowingShims')(); } }).call(this,require('_process')) },{"./factoryWithThrowingShims":8,"./factoryWithTypeCheckers":9,"_process":6}],11:[function(require,module,exports){ /** * Copyright (c) 2013-present, Facebook, Inc. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ 'use strict'; var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'; module.exports = ReactPropTypesSecret; },{}],12:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = { GLOBAL: { HIDE: '__react_tooltip_hide_event', REBUILD: '__react_tooltip_rebuild_event', SHOW: '__react_tooltip_show_event' } }; },{}],13:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = function (target) { target.prototype.isCustomEvent = function (ele) { var event = this.state.event; return event || !!ele.getAttribute('data-event'); }; /* Bind listener for custom event */ target.prototype.customBindListener = function (ele) { var _this = this; var _state = this.state, event = _state.event, eventOff = _state.eventOff; var dataEvent = ele.getAttribute('data-event') || event; var dataEventOff = ele.getAttribute('data-event-off') || eventOff; dataEvent.split(' ').forEach(function (event) { ele.removeEventListener(event, customListener); customListener = checkStatus.bind(_this, dataEventOff); ele.addEventListener(event, customListener, false); }); if (dataEventOff) { dataEventOff.split(' ').forEach(function (event) { ele.removeEventListener(event, _this.hideTooltip); ele.addEventListener(event, _this.hideTooltip, false); }); } }; /* Unbind listener for custom event */ target.prototype.customUnbindListener = function (ele) { var _state2 = this.state, event = _state2.event, eventOff = _state2.eventOff; var dataEvent = event || ele.getAttribute('data-event'); var dataEventOff = eventOff || ele.getAttribute('data-event-off'); ele.removeEventListener(dataEvent, customListener); if (dataEventOff) ele.removeEventListener(dataEventOff, this.hideTooltip); }; }; /** * Custom events to control showing and hiding of tooltip * * @attributes * - `event` {String} * - `eventOff` {String} */ var checkStatus = function checkStatus(dataEventOff, e) { var show = this.state.show; var id = this.props.id; var dataIsCapture = e.currentTarget.getAttribute('data-iscapture'); var isCapture = dataIsCapture && dataIsCapture === 'true' || this.props.isCapture; var currentItem = e.currentTarget.getAttribute('currentItem'); if (!isCapture) e.stopPropagation(); if (show && currentItem === 'true') { if (!dataEventOff) this.hideTooltip(e); } else { e.currentTarget.setAttribute('currentItem', 'true'); setUntargetItems(e.currentTarget, this.getTargetArray(id)); this.showTooltip(e); } }; var setUntargetItems = function setUntargetItems(currentTarget, targetArray) { for (var i = 0; i < targetArray.length; i++) { if (currentTarget !== targetArray[i]) { targetArray[i].setAttribute('currentItem', 'false'); } else { targetArray[i].setAttribute('currentItem', 'true'); } } }; var customListener = void 0; },{}],14:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = function (target) { target.prototype.getEffect = function (currentTarget) { var dataEffect = currentTarget.getAttribute('data-effect'); return dataEffect || this.props.effect || 'float'; }; }; },{}],15:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = function (target) { target.prototype.isCapture = function (currentTarget) { var dataIsCapture = currentTarget.getAttribute('data-iscapture'); return dataIsCapture && dataIsCapture === 'true' || this.props.isCapture || false; }; }; },{}],16:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = function (target) { /** * Hide all tooltip * @trigger ReactTooltip.hide() */ target.hide = function (target) { dispatchGlobalEvent(_constant2.default.GLOBAL.HIDE, { target: target }); }; /** * Rebuild all tooltip * @trigger ReactTooltip.rebuild() */ target.rebuild = function () { dispatchGlobalEvent(_constant2.default.GLOBAL.REBUILD); }; /** * Show specific tooltip * @trigger ReactTooltip.show() */ target.show = function (target) { dispatchGlobalEvent(_constant2.default.GLOBAL.SHOW, { target: target }); }; target.prototype.globalRebuild = function () { if (this.mount) { this.unbindListener(); this.bindListener(); } }; target.prototype.globalShow = function (event) { if (this.mount) { // Create a fake event, specific show will limit the type to `solid` // only `float` type cares e.clientX e.clientY var e = { currentTarget: event.detail.target }; this.showTooltip(e, true); } }; target.prototype.globalHide = function (event) { if (this.mount) { var hasTarget = event && event.detail && event.detail.target && true || false; this.hideTooltip({ currentTarget: hasTarget && event.detail.target }, hasTarget); } }; }; var _constant = require('../constant'); var _constant2 = _interopRequireDefault(_constant); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } var dispatchGlobalEvent = function dispatchGlobalEvent(eventName, opts) { // Compatibale with IE // @see http://stackoverflow.com/questions/26596123/internet-explorer-9-10-11-event-constructor-doesnt-work var event = void 0; if (typeof window.CustomEvent === 'function') { event = new window.CustomEvent(eventName, { detail: opts }); } else { event = document.createEvent('Event'); event.initEvent(eventName, false, true); event.detail = opts; } window.dispatchEvent(event); }; /** * Static methods for react-tooltip */ },{"../constant":12}],17:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = function (target) { target.prototype.bindRemovalTracker = function () { var _this = this; var MutationObserver = getMutationObserverClass(); if (MutationObserver == null) return; var observer = new MutationObserver(function (mutations) { var _iteratorNormalCompletion = true; var _didIteratorError = false; var _iteratorError = undefined; try { for (var _iterator = mutations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { var mutation = _step.value; var _iteratorNormalCompletion2 = true; var _didIteratorError2 = false; var _iteratorError2 = undefined; try { for (var _iterator2 = mutation.removedNodes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { var element = _step2.value; if (element === _this.state.currentTarget) { _this.hideTooltip(); return; } } } catch (err) { _didIteratorError2 = true; _iteratorError2 = err; } finally { try { if (!_iteratorNormalCompletion2 && _iterator2.return) { _iterator2.return(); } } finally { if (_didIteratorError2) { throw _iteratorError2; } } } } } catch (err) { _didIteratorError = true; _iteratorError = err; } finally { try { if (!_iteratorNormalCompletion && _iterator.return) { _iterator.return(); } } finally { if (_didIteratorError) { throw _iteratorError; } } } }); observer.observe(window.document, { childList: true, subtree: true }); this.removalTracker = observer; }; target.prototype.unbindRemovalTracker = function () { if (this.removalTracker) { this.removalTracker.disconnect(); this.removalTracker = null; } }; }; /** * Tracking target removing from DOM. * It's nessesary to hide tooltip when it's target disappears. * Otherwise, the tooltip would be shown forever until another target * is triggered. * * If MutationObserver is not available, this feature just doesn't work. */ // https://hacks.mozilla.org/2012/05/dom-mutationobserver-reacting-to-dom-changes-without-killing-browser-performance/ var getMutationObserverClass = function getMutationObserverClass() { return window.MutationObserver || window.WebKitMutationObserver || window.MozMutationObserver; }; },{}],18:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = function (target) { target.prototype.bindWindowEvents = function (resizeHide) { // ReactTooltip.hide window.removeEventListener(_constant2.default.GLOBAL.HIDE, this.globalHide); window.addEventListener(_constant2.default.GLOBAL.HIDE, this.globalHide, false); // ReactTooltip.rebuild window.removeEventListener(_constant2.default.GLOBAL.REBUILD, this.globalRebuild); window.addEventListener(_constant2.default.GLOBAL.REBUILD, this.globalRebuild, false); // ReactTooltip.show window.removeEventListener(_constant2.default.GLOBAL.SHOW, this.globalShow); window.addEventListener(_constant2.default.GLOBAL.SHOW, this.globalShow, false); // Resize if (resizeHide) { window.removeEventListener('resize', this.onWindowResize); window.addEventListener('resize', this.onWindowResize, false); } }; target.prototype.unbindWindowEvents = function () { window.removeEventListener(_constant2.default.GLOBAL.HIDE, this.globalHide); window.removeEventListener(_constant2.default.GLOBAL.REBUILD, this.globalRebuild); window.removeEventListener(_constant2.default.GLOBAL.SHOW, this.globalShow); window.removeEventListener('resize', this.onWindowResize); }; /** * invoked by resize event of window */ target.prototype.onWindowResize = function () { if (!this.mount) return; this.hideTooltip(); }; }; var _constant = require('../constant'); var _constant2 = _interopRequireDefault(_constant); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } },{"../constant":12}],19:[function(require,module,exports){ (function (global){ 'use strict'; var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); var _class, _class2, _temp; /* Decoraters */ /* Utils */ /* CSS */ var _react = (typeof window !== "undefined" ? window['React'] : typeof global !== "undefined" ? global['React'] : null); var _react2 = _interopRequireDefault(_react); var _propTypes = require('prop-types'); var _propTypes2 = _interopRequireDefault(_propTypes); var _reactDom = (typeof window !== "undefined" ? window['ReactDOM'] : typeof global !== "undefined" ? global['ReactDOM'] : null); var _reactDom2 = _interopRequireDefault(_reactDom); var _classnames = require('classnames'); var _classnames2 = _interopRequireDefault(_classnames); var _staticMethods = require('./decorators/staticMethods'); var _staticMethods2 = _interopRequireDefault(_staticMethods); var _windowListener = require('./decorators/windowListener'); var _windowListener2 = _interopRequireDefault(_windowListener); var _customEvent = require('./decorators/customEvent'); var _customEvent2 = _interopRequireDefault(_customEvent); var _isCapture = require('./decorators/isCapture'); var _isCapture2 = _interopRequireDefault(_isCapture); var _getEffect = require('./decorators/getEffect'); var _getEffect2 = _interopRequireDefault(_getEffect); var _trackRemoval = require('./decorators/trackRemoval'); var _trackRemoval2 = _interopRequireDefault(_trackRemoval); var _getPosition = require('./utils/getPosition'); var _getPosition2 = _interopRequireDefault(_getPosition); var _getTipContent = require('./utils/getTipContent'); var _getTipContent2 = _interopRequireDefault(_getTipContent); var _aria = require('./utils/aria'); var _nodeListToArray = require('./utils/nodeListToArray'); var _nodeListToArray2 = _interopRequireDefault(_nodeListToArray); var _style = require('./style'); var _style2 = _interopRequireDefault(_style); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } var ReactTooltip = (0, _staticMethods2.default)(_class = (0, _windowListener2.default)(_class = (0, _customEvent2.default)(_class = (0, _isCapture2.default)(_class = (0, _getEffect2.default)(_class = (0, _trackRemoval2.default)(_class = (_temp = _class2 = function (_Component) { _inherits(ReactTooltip, _Component); function ReactTooltip(props) { _classCallCheck(this, ReactTooltip); var _this = _possibleConstructorReturn(this, (ReactTooltip.__proto__ || Object.getPrototypeOf(ReactTooltip)).call(this, props)); _this.state = { place: 'top', // Direction of tooltip type: 'dark', // Color theme of tooltip effect: 'float', // float or fixed show: false, border: false, placeholder: '', offset: {}, extraClass: '', html: false, delayHide: 0, delayShow: 0, event: props.event || null, eventOff: props.eventOff || null, currentEvent: null, // Current mouse event currentTarget: null, // Current target of mouse event ariaProps: (0, _aria.parseAria)(props), // aria- and role attributes isEmptyTip: false, disable: false }; _this.bind(['showTooltip', 'updateTooltip', 'hideTooltip', 'globalRebuild', 'globalShow', 'globalHide', 'onWindowResize']); _this.mount = true; _this.delayShowLoop = null; _this.delayHideLoop = null; _this.intervalUpdateContent = null; return _this; } /** * For unify the bind and unbind listener */ _createClass(ReactTooltip, [{ key: 'bind', value: function bind(methodArray) { var _this2 = this; methodArray.forEach(function (method) { _this2[method] = _this2[method].bind(_this2); }); } }, { key: 'componentDidMount', value: function componentDidMount() { var _props = this.props, insecure = _props.insecure, resizeHide = _props.resizeHide; if (insecure) { this.setStyleHeader(); // Set the style to the } this.bindListener(); // Bind listener for tooltip this.bindWindowEvents(resizeHide); // Bind global event for static method } }, { key: 'componentWillReceiveProps', value: function componentWillReceiveProps(props) { var ariaProps = this.state.ariaProps; var newAriaProps = (0, _aria.parseAria)(props); var isChanged = Object.keys(newAriaProps).some(function (props) { return newAriaProps[props] !== ariaProps[props]; }); if (isChanged) { this.setState({ ariaProps: newAriaProps }); } } }, { key: 'componentWillUnmount', value: function componentWillUnmount() { this.mount = false; this.clearTimer(); this.unbindListener(); this.removeScrollListener(); this.unbindWindowEvents(); } /** * Pick out corresponded target elements */ }, { key: 'getTargetArray', value: function getTargetArray(id) { var targetArray = void 0; if (!id) { targetArray = document.querySelectorAll('[data-tip]:not([data-for])'); } else { var escaped = id.replace(/\\/g, '\\\\').replace(/"/g, '\\"'); targetArray = document.querySelectorAll('[data-tip][data-for="' + escaped + '"]'); } // targetArray is a NodeList, convert it to a real array return (0, _nodeListToArray2.default)(targetArray); } /** * Bind listener to the target elements * These listeners used to trigger showing or hiding the tooltip */ }, { key: 'bindListener', value: function bindListener() { var _this3 = this; var _props2 = this.props, id = _props2.id, globalEventOff = _props2.globalEventOff; var targetArray = this.getTargetArray(id); targetArray.forEach(function (target) { var isCaptureMode = _this3.isCapture(target); var effect = _this3.getEffect(target); if (target.getAttribute('currentItem') === null) { target.setAttribute('currentItem', 'false'); } _this3.unbindBasicListener(target); if (_this3.isCustomEvent(target)) { _this3.customBindListener(target); return; } target.addEventListener('mouseenter', _this3.showTooltip, isCaptureMode); if (effect === 'float') { target.addEventListener('mousemove', _this3.updateTooltip, isCaptureMode); } target.addEventListener('mouseleave', _this3.hideTooltip, isCaptureMode); }); // Global event to hide tooltip if (globalEventOff) { window.removeEventListener(globalEventOff, this.hideTooltip); window.addEventListener(globalEventOff, this.hideTooltip, false); } // Track removal of targetArray elements from DOM this.bindRemovalTracker(); } /** * Unbind listeners on target elements */ }, { key: 'unbindListener', value: function unbindListener() { var _this4 = this; var _props3 = this.props, id = _props3.id, globalEventOff = _props3.globalEventOff; var targetArray = this.getTargetArray(id); targetArray.forEach(function (target) { _this4.unbindBasicListener(target); if (_this4.isCustomEvent(target)) _this4.customUnbindListener(target); }); if (globalEventOff) window.removeEventListener(globalEventOff, this.hideTooltip); this.unbindRemovalTracker(); } /** * Invoke this before bind listener and ummount the compont * it is necessary to invloke this even when binding custom event * so that the tooltip can switch between custom and default listener */ }, { key: 'unbindBasicListener', value: function unbindBasicListener(target) { var isCaptureMode = this.isCapture(target); target.removeEventListener('mouseenter', this.showTooltip, isCaptureMode); target.removeEventListener('mousemove', this.updateTooltip, isCaptureMode); target.removeEventListener('mouseleave', this.hideTooltip, isCaptureMode); } /** * When mouse enter, show the tooltip */ }, { key: 'showTooltip', value: function showTooltip(e, isGlobalCall) { var _this5 = this; if (isGlobalCall) { // Don't trigger other elements belongs to other ReactTooltip var targetArray = this.getTargetArray(this.props.id); var isMyElement = targetArray.some(function (ele) { return ele === e.currentTarget; }); if (!isMyElement || this.state.show) return; } // Get the tooltip content // calculate in this phrase so that tip width height can be detected var _props4 = this.props, children = _props4.children, multiline = _props4.multiline, getContent = _props4.getContent; var originTooltip = e.currentTarget.getAttribute('data-tip'); var isMultiline = e.currentTarget.getAttribute('data-multiline') || multiline || false; // Generate tootlip content var content = void 0; if (getContent) { if (Array.isArray(getContent)) { content = getContent[0] && getContent[0](); } else { content = getContent(); } } var placeholder = (0, _getTipContent2.default)(originTooltip, children, content, isMultiline); var isEmptyTip = typeof placeholder === 'string' && placeholder === '' || placeholder === null; // If it is focus event or called by ReactTooltip.show, switch to `solid` effect var switchToSolid = e instanceof window.FocusEvent || isGlobalCall; // if it needs to skip adding hide listener to scroll var scrollHide = true; if (e.currentTarget.getAttribute('data-scroll-hide')) { scrollHide = e.currentTarget.getAttribute('data-scroll-hide') === 'true'; } else if (this.props.scrollHide != null) { scrollHide = this.props.scrollHide; } // To prevent previously created timers from triggering this.clearTimer(); this.setState({ placeholder: placeholder, isEmptyTip: isEmptyTip, place: e.currentTarget.getAttribute('data-place') || this.props.place || 'top', type: e.currentTarget.getAttribute('data-type') || this.props.type || 'dark', effect: switchToSolid && 'solid' || this.getEffect(e.currentTarget), offset: e.currentTarget.getAttribute('data-offset') || this.props.offset || {}, html: e.currentTarget.getAttribute('data-html') ? e.currentTarget.getAttribute('data-html') === 'true' : this.props.html || false, delayShow: e.currentTarget.getAttribute('data-delay-show') || this.props.delayShow || 0, delayHide: e.currentTarget.getAttribute('data-delay-hide') || this.props.delayHide || 0, border: e.currentTarget.getAttribute('data-border') ? e.currentTarget.getAttribute('data-border') === 'true' : this.props.border || false, extraClass: e.currentTarget.getAttribute('data-class') || this.props.class || this.props.className || '', disable: e.currentTarget.getAttribute('data-tip-disable') ? e.currentTarget.getAttribute('data-tip-disable') === 'true' : this.props.disable || false }, function () { if (scrollHide) _this5.addScrollListener(e); _this5.updateTooltip(e); if (getContent && Array.isArray(getContent)) { _this5.intervalUpdateContent = setInterval(function () { if (_this5.mount) { var _getContent = _this5.props.getContent; var _placeholder = (0, _getTipContent2.default)(originTooltip, _getContent[0](), isMultiline); var _isEmptyTip = typeof _placeholder === 'string' && _placeholder === ''; _this5.setState({ placeholder: _placeholder, isEmptyTip: _isEmptyTip }); } }, getContent[1]); } }); } /** * When mouse hover, updatetooltip */ }, { key: 'updateTooltip', value: function updateTooltip(e) { var _this6 = this; var _state = this.state, delayShow = _state.delayShow, show = _state.show, isEmptyTip = _state.isEmptyTip, disable = _state.disable; var afterShow = this.props.afterShow; var placeholder = this.state.placeholder; var delayTime = show ? 0 : parseInt(delayShow, 10); var eventTarget = e.currentTarget; if (isEmptyTip || disable) return; // if the tooltip is empty, disable the tooltip var updateState = function updateState() { if (Array.isArray(placeholder) && placeholder.length > 0 || placeholder) { var isInvisible = !_this6.state.show; _this6.setState({ currentEvent: e, currentTarget: eventTarget, show: true }, function () { _this6.updatePosition(); if (isInvisible && afterShow) afterShow(); }); } }; clearTimeout(this.delayShowLoop); if (delayShow) { this.delayShowLoop = setTimeout(updateState, delayTime); } else { updateState(); } } /** * When mouse leave, hide tooltip */ }, { key: 'hideTooltip', value: function hideTooltip(e, hasTarget) { var _this7 = this; var _state2 = this.state, delayHide = _state2.delayHide, isEmptyTip = _state2.isEmptyTip, disable = _state2.disable; var afterHide = this.props.afterHide; if (!this.mount) return; if (isEmptyTip || disable) return; // if the tooltip is empty, disable the tooltip if (hasTarget) { // Don't trigger other elements belongs to other ReactTooltip var targetArray = this.getTargetArray(this.props.id); var isMyElement = targetArray.some(function (ele) { return ele === e.currentTarget; }); if (!isMyElement || !this.state.show) return; } var resetState = function resetState() { var isVisible = _this7.state.show; _this7.setState({ show: false }, function () { _this7.removeScrollListener(); if (isVisible && afterHide) afterHide(); }); }; this.clearTimer(); if (delayHide) { this.delayHideLoop = setTimeout(resetState, parseInt(delayHide, 10)); } else { resetState(); } } /** * Add scroll eventlistener when tooltip show * automatically hide the tooltip when scrolling */ }, { key: 'addScrollListener', value: function addScrollListener(e) { var isCaptureMode = this.isCapture(e.currentTarget); window.addEventListener('scroll', this.hideTooltip, isCaptureMode); } }, { key: 'removeScrollListener', value: function removeScrollListener() { window.removeEventListener('scroll', this.hideTooltip); } // Calculation the position }, { key: 'updatePosition', value: function updatePosition() { var _this8 = this; var _state3 = this.state, currentEvent = _state3.currentEvent, currentTarget = _state3.currentTarget, place = _state3.place, effect = _state3.effect, offset = _state3.offset; var node = _reactDom2.default.findDOMNode(this); var result = (0, _getPosition2.default)(currentEvent, currentTarget, node, place, effect, offset); if (result.isNewState) { // Switch to reverse placement return this.setState(result.newState, function () { _this8.updatePosition(); }); } // Set tooltip position node.style.left = result.position.left + 'px'; node.style.top = result.position.top + 'px'; } /** * Set style tag in header * in this way we can insert default css */ }, { key: 'setStyleHeader', value: function setStyleHeader() { if (!document.getElementsByTagName('head')[0].querySelector('style[id="react-tooltip"]')) { var tag = document.createElement('style'); tag.id = 'react-tooltip'; tag.innerHTML = _style2.default; document.getElementsByTagName('head')[0].appendChild(tag); } } /** * CLear all kinds of timeout of interval */ }, { key: 'clearTimer', value: function clearTimer() { clearTimeout(this.delayShowLoop); clearTimeout(this.delayHideLoop); clearInterval(this.intervalUpdateContent); } }, { key: 'render', value: function render() { var _state4 = this.state, placeholder = _state4.placeholder, extraClass = _state4.extraClass, html = _state4.html, ariaProps = _state4.ariaProps, disable = _state4.disable, isEmptyTip = _state4.isEmptyTip; var tooltipClass = (0, _classnames2.default)('__react_component_tooltip', { 'show': this.state.show && !disable && !isEmptyTip }, { 'border': this.state.border }, { 'place-top': this.state.place === 'top' }, { 'place-bottom': this.state.place === 'bottom' }, { 'place-left': this.state.place === 'left' }, { 'place-right': this.state.place === 'right' }, { 'type-dark': this.state.type === 'dark' }, { 'type-success': this.state.type === 'success' }, { 'type-warning': this.state.type === 'warning' }, { 'type-error': this.state.type === 'error' }, { 'type-info': this.state.type === 'info' }, { 'type-light': this.state.type === 'light' }); var Wrapper = this.props.wrapper; if (ReactTooltip.supportedWrappers.indexOf(Wrapper) < 0) { Wrapper = ReactTooltip.defaultProps.wrapper; } if (html) { return _react2.default.createElement(Wrapper, _extends({ className: tooltipClass + ' ' + extraClass }, ariaProps, { 'data-id': 'tooltip', dangerouslySetInnerHTML: { __html: placeholder } })); } else { return _react2.default.createElement( Wrapper, _extends({ className: tooltipClass + ' ' + extraClass }, ariaProps, { 'data-id': 'tooltip' }), placeholder ); } } }]); return ReactTooltip; }(_react.Component), _class2.propTypes = { children: _propTypes2.default.any, place: _propTypes2.default.string, type: _propTypes2.default.string, effect: _propTypes2.default.string, offset: _propTypes2.default.object, multiline: _propTypes2.default.bool, border: _propTypes2.default.bool, insecure: _propTypes2.default.bool, class: _propTypes2.default.string, className: _propTypes2.default.string, id: _propTypes2.default.string, html: _propTypes2.default.bool, delayHide: _propTypes2.default.number, delayShow: _propTypes2.default.number, event: _propTypes2.default.string, eventOff: _propTypes2.default.string, watchWindow: _propTypes2.default.bool, isCapture: _propTypes2.default.bool, globalEventOff: _propTypes2.default.string, getContent: _propTypes2.default.any, afterShow: _propTypes2.default.func, afterHide: _propTypes2.default.func, disable: _propTypes2.default.bool, scrollHide: _propTypes2.default.bool, resizeHide: _propTypes2.default.bool, wrapper: _propTypes2.default.string }, _class2.defaultProps = { insecure: true, resizeHide: true, wrapper: 'div' }, _class2.supportedWrappers = ['div', 'span'], _temp)) || _class) || _class) || _class) || _class) || _class) || _class; /* export default not fit for standalone, it will exports {default:...} */ module.exports = ReactTooltip; }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) },{"./decorators/customEvent":13,"./decorators/getEffect":14,"./decorators/isCapture":15,"./decorators/staticMethods":16,"./decorators/trackRemoval":17,"./decorators/windowListener":18,"./style":20,"./utils/aria":21,"./utils/getPosition":22,"./utils/getTipContent":23,"./utils/nodeListToArray":24,"classnames":1,"prop-types":10}],20:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = '.__react_component_tooltip{border-radius:3px;display:inline-block;font-size:13px;left:-999em;opacity:0;padding:8px 21px;position:fixed;pointer-events:none;transition:opacity 0.3s ease-out;top:-999em;visibility:hidden;z-index:999}.__react_component_tooltip:before,.__react_component_tooltip:after{content:"";width:0;height:0;position:absolute}.__react_component_tooltip.show{opacity:0.9;margin-top:0px;margin-left:0px;visibility:visible}.__react_component_tooltip.type-dark{color:#fff;background-color:#222}.__react_component_tooltip.type-dark.place-top:after{border-top-color:#222;border-top-style:solid;border-top-width:6px}.__react_component_tooltip.type-dark.place-bottom:after{border-bottom-color:#222;border-bottom-style:solid;border-bottom-width:6px}.__react_component_tooltip.type-dark.place-left:after{border-left-color:#222;border-left-style:solid;border-left-width:6px}.__react_component_tooltip.type-dark.place-right:after{border-right-color:#222;border-right-style:solid;border-right-width:6px}.__react_component_tooltip.type-dark.border{border:1px solid #fff}.__react_component_tooltip.type-dark.border.place-top:before{border-top:8px solid #fff}.__react_component_tooltip.type-dark.border.place-bottom:before{border-bottom:8px solid #fff}.__react_component_tooltip.type-dark.border.place-left:before{border-left:8px solid #fff}.__react_component_tooltip.type-dark.border.place-right:before{border-right:8px solid #fff}.__react_component_tooltip.type-success{color:#fff;background-color:#8DC572}.__react_component_tooltip.type-success.place-top:after{border-top-color:#8DC572;border-top-style:solid;border-top-width:6px}.__react_component_tooltip.type-success.place-bottom:after{border-bottom-color:#8DC572;border-bottom-style:solid;border-bottom-width:6px}.__react_component_tooltip.type-success.place-left:after{border-left-color:#8DC572;border-left-style:solid;border-left-width:6px}.__react_component_tooltip.type-success.place-right:after{border-right-color:#8DC572;border-right-style:solid;border-right-width:6px}.__react_component_tooltip.type-success.border{border:1px solid #fff}.__react_component_tooltip.type-success.border.place-top:before{border-top:8px solid #fff}.__react_component_tooltip.type-success.border.place-bottom:before{border-bottom:8px solid #fff}.__react_component_tooltip.type-success.border.place-left:before{border-left:8px solid #fff}.__react_component_tooltip.type-success.border.place-right:before{border-right:8px solid #fff}.__react_component_tooltip.type-warning{color:#fff;background-color:#F0AD4E}.__react_component_tooltip.type-warning.place-top:after{border-top-color:#F0AD4E;border-top-style:solid;border-top-width:6px}.__react_component_tooltip.type-warning.place-bottom:after{border-bottom-color:#F0AD4E;border-bottom-style:solid;border-bottom-width:6px}.__react_component_tooltip.type-warning.place-left:after{border-left-color:#F0AD4E;border-left-style:solid;border-left-width:6px}.__react_component_tooltip.type-warning.place-right:after{border-right-color:#F0AD4E;border-right-style:solid;border-right-width:6px}.__react_component_tooltip.type-warning.border{border:1px solid #fff}.__react_component_tooltip.type-warning.border.place-top:before{border-top:8px solid #fff}.__react_component_tooltip.type-warning.border.place-bottom:before{border-bottom:8px solid #fff}.__react_component_tooltip.type-warning.border.place-left:before{border-left:8px solid #fff}.__react_component_tooltip.type-warning.border.place-right:before{border-right:8px solid #fff}.__react_component_tooltip.type-error{color:#fff;background-color:#BE6464}.__react_component_tooltip.type-error.place-top:after{border-top-color:#BE6464;border-top-style:solid;border-top-width:6px}.__react_component_tooltip.type-error.place-bottom:after{border-bottom-color:#BE6464;border-bottom-style:solid;border-bottom-width:6px}.__react_component_tooltip.type-error.place-left:after{border-left-color:#BE6464;border-left-style:solid;border-left-width:6px}.__react_component_tooltip.type-error.place-right:after{border-right-color:#BE6464;border-right-style:solid;border-right-width:6px}.__react_component_tooltip.type-error.border{border:1px solid #fff}.__react_component_tooltip.type-error.border.place-top:before{border-top:8px solid #fff}.__react_component_tooltip.type-error.border.place-bottom:before{border-bottom:8px solid #fff}.__react_component_tooltip.type-error.border.place-left:before{border-left:8px solid #fff}.__react_component_tooltip.type-error.border.place-right:before{border-right:8px solid #fff}.__react_component_tooltip.type-info{color:#fff;background-color:#337AB7}.__react_component_tooltip.type-info.place-top:after{border-top-color:#337AB7;border-top-style:solid;border-top-width:6px}.__react_component_tooltip.type-info.place-bottom:after{border-bottom-color:#337AB7;border-bottom-style:solid;border-bottom-width:6px}.__react_component_tooltip.type-info.place-left:after{border-left-color:#337AB7;border-left-style:solid;border-left-width:6px}.__react_component_tooltip.type-info.place-right:after{border-right-color:#337AB7;border-right-style:solid;border-right-width:6px}.__react_component_tooltip.type-info.border{border:1px solid #fff}.__react_component_tooltip.type-info.border.place-top:before{border-top:8px solid #fff}.__react_component_tooltip.type-info.border.place-bottom:before{border-bottom:8px solid #fff}.__react_component_tooltip.type-info.border.place-left:before{border-left:8px solid #fff}.__react_component_tooltip.type-info.border.place-right:before{border-right:8px solid #fff}.__react_component_tooltip.type-light{color:#222;background-color:#fff}.__react_component_tooltip.type-light.place-top:after{border-top-color:#fff;border-top-style:solid;border-top-width:6px}.__react_component_tooltip.type-light.place-bottom:after{border-bottom-color:#fff;border-bottom-style:solid;border-bottom-width:6px}.__react_component_tooltip.type-light.place-left:after{border-left-color:#fff;border-left-style:solid;border-left-width:6px}.__react_component_tooltip.type-light.place-right:after{border-right-color:#fff;border-right-style:solid;border-right-width:6px}.__react_component_tooltip.type-light.border{border:1px solid #222}.__react_component_tooltip.type-light.border.place-top:before{border-top:8px solid #222}.__react_component_tooltip.type-light.border.place-bottom:before{border-bottom:8px solid #222}.__react_component_tooltip.type-light.border.place-left:before{border-left:8px solid #222}.__react_component_tooltip.type-light.border.place-right:before{border-right:8px solid #222}.__react_component_tooltip.place-top{margin-top:-10px}.__react_component_tooltip.place-top:before{border-left:10px solid transparent;border-right:10px solid transparent;bottom:-8px;left:50%;margin-left:-10px}.__react_component_tooltip.place-top:after{border-left:8px solid transparent;border-right:8px solid transparent;bottom:-6px;left:50%;margin-left:-8px}.__react_component_tooltip.place-bottom{margin-top:10px}.__react_component_tooltip.place-bottom:before{border-left:10px solid transparent;border-right:10px solid transparent;top:-8px;left:50%;margin-left:-10px}.__react_component_tooltip.place-bottom:after{border-left:8px solid transparent;border-right:8px solid transparent;top:-6px;left:50%;margin-left:-8px}.__react_component_tooltip.place-left{margin-left:-10px}.__react_component_tooltip.place-left:before{border-top:6px solid transparent;border-bottom:6px solid transparent;right:-8px;top:50%;margin-top:-5px}.__react_component_tooltip.place-left:after{border-top:5px solid transparent;border-bottom:5px solid transparent;right:-6px;top:50%;margin-top:-4px}.__react_component_tooltip.place-right{margin-left:10px}.__react_component_tooltip.place-right:before{border-top:6px solid transparent;border-bottom:6px solid transparent;left:-8px;top:50%;margin-top:-5px}.__react_component_tooltip.place-right:after{border-top:5px solid transparent;border-bottom:5px solid transparent;left:-6px;top:50%;margin-top:-4px}.__react_component_tooltip .multi-line{display:block;padding:2px 0px;text-align:center}'; },{}],21:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.parseAria = parseAria; /** * Support aria- and role in ReactTooltip * * @params props {Object} * @return {Object} */ function parseAria(props) { var ariaObj = {}; Object.keys(props).filter(function (prop) { // aria-xxx and role is acceptable return (/(^aria-\w+$|^role$)/.test(prop) ); }).forEach(function (prop) { ariaObj[prop] = props[prop]; }); return ariaObj; } },{}],22:[function(require,module,exports){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = function (e, target, node, place, effect, offset) { var tipWidth = node.clientWidth; var tipHeight = node.clientHeight; var _getCurrentOffset = getCurrentOffset(e, target, effect), mouseX = _getCurrentOffset.mouseX, mouseY = _getCurrentOffset.mouseY; var defaultOffset = getDefaultPosition(effect, target.clientWidth, target.clientHeight, tipWidth, tipHeight); var _calculateOffset = calculateOffset(offset), extraOffset_X = _calculateOffset.extraOffset_X, extraOffset_Y = _calculateOffset.extraOffset_Y; var windowWidth = window.innerWidth; var windowHeight = window.innerHeight; var _getParent = getParent(node), parentTop = _getParent.parentTop, parentLeft = _getParent.parentLeft; // Get the edge offset of the tooltip var getTipOffsetLeft = function getTipOffsetLeft(place) { var offset_X = defaultOffset[place].l; return mouseX + offset_X + extraOffset_X; }; var getTipOffsetRight = function getTipOffsetRight(place) { var offset_X = defaultOffset[place].r; return mouseX + offset_X + extraOffset_X; }; var getTipOffsetTop = function getTipOffsetTop(place) { var offset_Y = defaultOffset[place].t; return mouseY + offset_Y + extraOffset_Y; }; var getTipOffsetBottom = function getTipOffsetBottom(place) { var offset_Y = defaultOffset[place].b; return mouseY + offset_Y + extraOffset_Y; }; // Judge if the tooltip has over the window(screen) var outsideVertical = function outsideVertical() { var result = false; var newPlace = void 0; if (getTipOffsetTop('left') < 0 && getTipOffsetBottom('left') <= windowHeight && getTipOffsetBottom('bottom') <= windowHeight) { result = true; newPlace = 'bottom'; } else if (getTipOffsetBottom('left') > windowHeight && getTipOffsetTop('left') >= 0 && getTipOffsetTop('top') >= 0) { result = true; newPlace = 'top'; } return { result: result, newPlace: newPlace }; }; var outsideLeft = function outsideLeft() { var _outsideVertical = outsideVertical(), result = _outsideVertical.result, newPlace = _outsideVertical.newPlace; // Deal with vertical as first priority if (result && outsideHorizontal().result) { return { result: false // No need to change, if change to vertical will out of space }; } if (!result && getTipOffsetLeft('left') < 0 && getTipOffsetRight('right') <= windowWidth) { result = true; // If vertical ok, but let out of side and right won't out of side newPlace = 'right'; } return { result: result, newPlace: newPlace }; }; var outsideRight = function outsideRight() { var _outsideVertical2 = outsideVertical(), result = _outsideVertical2.result, newPlace = _outsideVertical2.newPlace; if (result && outsideHorizontal().result) { return { result: false // No need to change, if change to vertical will out of space }; } if (!result && getTipOffsetRight('right') > windowWidth && getTipOffsetLeft('left') >= 0) { result = true; newPlace = 'left'; } return { result: result, newPlace: newPlace }; }; var outsideHorizontal = function outsideHorizontal() { var result = false; var newPlace = void 0; if (getTipOffsetLeft('top') < 0 && getTipOffsetRight('top') <= windowWidth && getTipOffsetRight('right') <= windowWidth) { result = true; newPlace = 'right'; } else if (getTipOffsetRight('top') > windowWidth && getTipOffsetLeft('top') >= 0 && getTipOffsetLeft('left') >= 0) { result = true; newPlace = 'left'; } return { result: result, newPlace: newPlace }; }; var outsideTop = function outsideTop() { var _outsideHorizontal = outsideHorizontal(), result = _outsideHorizontal.result, newPlace = _outsideHorizontal.newPlace; if (result && outsideVertical().result) { return { result: false }; } if (!result && getTipOffsetTop('top') < 0 && getTipOffsetBottom('bottom') <= windowHeight) { result = true; newPlace = 'bottom'; } return { result: result, newPlace: newPlace }; }; var outsideBottom = function outsideBottom() { var _outsideHorizontal2 = outsideHorizontal(), result = _outsideHorizontal2.result, newPlace = _outsideHorizontal2.newPlace; if (result && outsideVertical().result) { return { result: false }; } if (!result && getTipOffsetBottom('bottom') > windowHeight && getTipOffsetTop('top') >= 0) { result = true; newPlace = 'top'; } return { result: result, newPlace: newPlace }; }; // Return new state to change the placement to the reverse if possible var outsideLeftResult = outsideLeft(); var outsideRightResult = outsideRight(); var outsideTopResult = outsideTop(); var outsideBottomResult = outsideBottom(); if (place === 'left' && outsideLeftResult.result) { return { isNewState: true, newState: { place: outsideLeftResult.newPlace } }; } else if (place === 'right' && outsideRightResult.result) { return { isNewState: true, newState: { place: outsideRightResult.newPlace } }; } else if (place === 'top' && outsideTopResult.result) { return { isNewState: true, newState: { place: outsideTopResult.newPlace } }; } else if (place === 'bottom' && outsideBottomResult.result) { return { isNewState: true, newState: { place: outsideBottomResult.newPlace } }; } // Return tooltip offset position return { isNewState: false, position: { left: parseInt(getTipOffsetLeft(place) - parentLeft, 10), top: parseInt(getTipOffsetTop(place) - parentTop, 10) } }; }; // Get current mouse offset var getCurrentOffset = function getCurrentOffset(e, currentTarget, effect) { var boundingClientRect = currentTarget.getBoundingClientRect(); var targetTop = boundingClientRect.top; var targetLeft = boundingClientRect.left; var targetWidth = currentTarget.clientWidth; var targetHeight = currentTarget.clientHeight; if (effect === 'float') { return { mouseX: e.clientX, mouseY: e.clientY }; } return { mouseX: targetLeft + targetWidth / 2, mouseY: targetTop + targetHeight / 2 }; }; // List all possibility of tooltip final offset // This is useful in judging if it is necessary for tooltip to switch position when out of window /** * Calculate the position of tooltip * * @params * - `e` {Event} the event of current mouse * - `target` {Element} the currentTarget of the event * - `node` {DOM} the react-tooltip object * - `place` {String} top / right / bottom / left * - `effect` {String} float / solid * - `offset` {Object} the offset to default position * * @return {Object * - `isNewState` {Bool} required * - `newState` {Object} * - `position` {OBject} {left: {Number}, top: {Number}} */ var getDefaultPosition = function getDefaultPosition(effect, targetWidth, targetHeight, tipWidth, tipHeight) { var top = void 0; var right = void 0; var bottom = void 0; var left = void 0; var disToMouse = 3; var triangleHeight = 2; var cursorHeight = 12; // Optimize for float bottom only, cause the cursor will hide the tooltip if (effect === 'float') { top = { l: -(tipWidth / 2), r: tipWidth / 2, t: -(tipHeight + disToMouse + triangleHeight), b: -disToMouse }; bottom = { l: -(tipWidth / 2), r: tipWidth / 2, t: disToMouse + cursorHeight, b: tipHeight + disToMouse + triangleHeight + cursorHeight }; left = { l: -(tipWidth + disToMouse + triangleHeight), r: -disToMouse, t: -(tipHeight / 2), b: tipHeight / 2 }; right = { l: disToMouse, r: tipWidth + disToMouse + triangleHeight, t: -(tipHeight / 2), b: tipHeight / 2 }; } else if (effect === 'solid') { top = { l: -(tipWidth / 2), r: tipWidth / 2, t: -(targetHeight / 2 + tipHeight + triangleHeight), b: -(targetHeight / 2) }; bottom = { l: -(tipWidth / 2), r: tipWidth / 2, t: targetHeight / 2, b: targetHeight / 2 + tipHeight + triangleHeight }; left = { l: -(tipWidth + targetWidth / 2 + triangleHeight), r: -(targetWidth / 2), t: -(tipHeight / 2), b: tipHeight / 2 }; right = { l: targetWidth / 2, r: tipWidth + targetWidth / 2 + triangleHeight, t: -(tipHeight / 2), b: tipHeight / 2 }; } return { top: top, bottom: bottom, left: left, right: right }; }; // Consider additional offset into position calculation var calculateOffset = function calculateOffset(offset) { var extraOffset_X = 0; var extraOffset_Y = 0; if (Object.prototype.toString.apply(offset) === '[object String]') { offset = JSON.parse(offset.toString().replace(/\'/g, '\"')); } for (var key in offset) { if (key === 'top') { extraOffset_Y -= parseInt(offset[key], 10); } else if (key === 'bottom') { extraOffset_Y += parseInt(offset[key], 10); } else if (key === 'left') { extraOffset_X -= parseInt(offset[key], 10); } else if (key === 'right') { extraOffset_X += parseInt(offset[key], 10); } } return { extraOffset_X: extraOffset_X, extraOffset_Y: extraOffset_Y }; }; // Get the offset of the parent elements var getParent = function getParent(currentTarget) { var currentParent = currentTarget; while (currentParent) { if (window.getComputedStyle(currentParent).getPropertyValue('transform') !== 'none') break; currentParent = currentParent.parentElement; } var parentTop = currentParent && currentParent.getBoundingClientRect().top || 0; var parentLeft = currentParent && currentParent.getBoundingClientRect().left || 0; return { parentTop: parentTop, parentLeft: parentLeft }; }; },{}],23:[function(require,module,exports){ (function (global){ 'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = function (tip, children, getContent, multiline) { if (children) return children; if (getContent !== undefined && getContent !== null) return getContent; // getContent can be 0, '', etc. if (getContent === null) return null; // Tip not exist and childern is null or undefined var regexp = //; if (!multiline || multiline === 'false' || !regexp.test(tip)) { // No trim(), so that user can keep their input return tip; } // Multiline tooltip content return tip.split(regexp).map(function (d, i) { return _react2.default.createElement( 'span', { key: i, className: 'multi-line' }, d ); }); }; var _react = (typeof window !== "undefined" ? window['React'] : typeof global !== "undefined" ? global['React'] : null); var _react2 = _interopRequireDefault(_react); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) },{}],24:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = function (nodeList) { var length = nodeList.length; if (nodeList.hasOwnProperty) { return Array.prototype.slice.call(nodeList); } return new Array(length).fill().map(function (index) { return nodeList[index]; }); }; },{}]},{},[19])(19) });