` by default. You can change this\n * behavior by providing a `component` prop.\n * If you use React v16+ and would like to avoid a wrapping `
` element\n * you can pass in `component={null}`. This is useful if the wrapping div\n * borks your css styles.\n */\n component: _propTypes.default.any,\n\n /**\n * A set of `` components, that are toggled `in` and out as they\n * leave. the `` will inject specific transition props, so\n * remember to spread them through if you are wrapping the `` as\n * with our `` example.\n *\n * While this component is meant for multiple `Transition` or `CSSTransition`\n * children, sometimes you may want to have a single transition child with\n * content that you want to be transitioned out and in when you change it\n * (e.g. routes, images etc.) In that case you can change the `key` prop of\n * the transition child as you change its content, this will cause\n * `TransitionGroup` to transition the child out and back in.\n */\n children: _propTypes.default.node,\n\n /**\n * A convenience prop that enables or disables appear animations\n * for all children. Note that specifying this will override any defaults set\n * on individual children Transitions.\n */\n appear: _propTypes.default.bool,\n\n /**\n * A convenience prop that enables or disables enter animations\n * for all children. Note that specifying this will override any defaults set\n * on individual children Transitions.\n */\n enter: _propTypes.default.bool,\n\n /**\n * A convenience prop that enables or disables exit animations\n * for all children. Note that specifying this will override any defaults set\n * on individual children Transitions.\n */\n exit: _propTypes.default.bool,\n\n /**\n * You may need to apply reactive updates to a child as it is exiting.\n * This is generally done by using `cloneElement` however in the case of an exiting\n * child the element has already been removed and not accessible to the consumer.\n *\n * If you do need to update a child as it leaves you can provide a `childFactory`\n * to wrap every child, even the ones that are leaving.\n *\n * @type Function(child: ReactElement) -> ReactElement\n */\n childFactory: _propTypes.default.func\n} : {};\nTransitionGroup.defaultProps = defaultProps;\n\nvar _default = (0, _reactLifecyclesCompat.polyfill)(TransitionGroup);\n\nexports.default = _default;\nmodule.exports = exports[\"default\"];","\"use strict\";\n\nexports.__esModule = true;\nexports.getChildMapping = getChildMapping;\nexports.mergeChildMappings = mergeChildMappings;\nexports.getInitialChildMapping = getInitialChildMapping;\nexports.getNextChildMapping = getNextChildMapping;\n\nvar _react = require(\"react\");\n\n/**\n * Given `this.props.children`, return an object mapping key to child.\n *\n * @param {*} children `this.props.children`\n * @return {object} Mapping of key to child\n */\nfunction getChildMapping(children, mapFn) {\n var mapper = function mapper(child) {\n return mapFn && (0, _react.isValidElement)(child) ? mapFn(child) : child;\n };\n\n var result = Object.create(null);\n if (children) _react.Children.map(children, function (c) {\n return c;\n }).forEach(function (child) {\n // run the map function here instead so that the key is the computed one\n result[child.key] = mapper(child);\n });\n return result;\n}\n/**\n * When you're adding or removing children some may be added or removed in the\n * same render pass. We want to show *both* since we want to simultaneously\n * animate elements in and out. This function takes a previous set of keys\n * and a new set of keys and merges them with its best guess of the correct\n * ordering. In the future we may expose some of the utilities in\n * ReactMultiChild to make this easy, but for now React itself does not\n * directly have this concept of the union of prevChildren and nextChildren\n * so we implement it here.\n *\n * @param {object} prev prev children as returned from\n * `ReactTransitionChildMapping.getChildMapping()`.\n * @param {object} next next children as returned from\n * `ReactTransitionChildMapping.getChildMapping()`.\n * @return {object} a key set that contains all keys in `prev` and all keys\n * in `next` in a reasonable order.\n */\n\n\nfunction mergeChildMappings(prev, next) {\n prev = prev || {};\n next = next || {};\n\n function getValueForKey(key) {\n return key in next ? next[key] : prev[key];\n } // For each key of `next`, the list of keys to insert before that key in\n // the combined list\n\n\n var nextKeysPending = Object.create(null);\n var pendingKeys = [];\n\n for (var prevKey in prev) {\n if (prevKey in next) {\n if (pendingKeys.length) {\n nextKeysPending[prevKey] = pendingKeys;\n pendingKeys = [];\n }\n } else {\n pendingKeys.push(prevKey);\n }\n }\n\n var i;\n var childMapping = {};\n\n for (var nextKey in next) {\n if (nextKeysPending[nextKey]) {\n for (i = 0; i < nextKeysPending[nextKey].length; i++) {\n var pendingNextKey = nextKeysPending[nextKey][i];\n childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);\n }\n }\n\n childMapping[nextKey] = getValueForKey(nextKey);\n } // Finally, add the keys which didn't appear before any key in `next`\n\n\n for (i = 0; i < pendingKeys.length; i++) {\n childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);\n }\n\n return childMapping;\n}\n\nfunction getProp(child, prop, props) {\n return props[prop] != null ? props[prop] : child.props[prop];\n}\n\nfunction getInitialChildMapping(props, onExited) {\n return getChildMapping(props.children, function (child) {\n return (0, _react.cloneElement)(child, {\n onExited: onExited.bind(null, child),\n in: true,\n appear: getProp(child, 'appear', props),\n enter: getProp(child, 'enter', props),\n exit: getProp(child, 'exit', props)\n });\n });\n}\n\nfunction getNextChildMapping(nextProps, prevChildMapping, onExited) {\n var nextChildMapping = getChildMapping(nextProps.children);\n var children = mergeChildMappings(prevChildMapping, nextChildMapping);\n Object.keys(children).forEach(function (key) {\n var child = children[key];\n if (!(0, _react.isValidElement)(child)) return;\n var hasPrev = key in prevChildMapping;\n var hasNext = key in nextChildMapping;\n var prevChild = prevChildMapping[key];\n var isLeaving = (0, _react.isValidElement)(prevChild) && !prevChild.props.in; // item is new (entering)\n\n if (hasNext && (!hasPrev || isLeaving)) {\n // console.log('entering', key)\n children[key] = (0, _react.cloneElement)(child, {\n onExited: onExited.bind(null, child),\n in: true,\n exit: getProp(child, 'exit', nextProps),\n enter: getProp(child, 'enter', nextProps)\n });\n } else if (!hasNext && hasPrev && !isLeaving) {\n // item is old (exiting)\n // console.log('leaving', key)\n children[key] = (0, _react.cloneElement)(child, {\n in: false\n });\n } else if (hasNext && hasPrev && (0, _react.isValidElement)(prevChild)) {\n // item hasn't changed transition states\n // copy over the last transition props;\n // console.log('unchanged', key)\n children[key] = (0, _react.cloneElement)(child, {\n onExited: onExited.bind(null, child),\n in: prevChild.props.in,\n exit: getProp(child, 'exit', nextProps),\n enter: getProp(child, 'enter', nextProps)\n });\n }\n });\n return children;\n}","\"use strict\";\n\nexports.__esModule = true;\nexports.classNamesShape = exports.timeoutsShape = void 0;\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar timeoutsShape = process.env.NODE_ENV !== 'production' ? _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.shape({\n enter: _propTypes.default.number,\n exit: _propTypes.default.number,\n appear: _propTypes.default.number\n}).isRequired]) : null;\nexports.timeoutsShape = timeoutsShape;\nvar classNamesShape = process.env.NODE_ENV !== 'production' ? _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.shape({\n enter: _propTypes.default.string,\n exit: _propTypes.default.string,\n active: _propTypes.default.string\n}), _propTypes.default.shape({\n enter: _propTypes.default.string,\n enterDone: _propTypes.default.string,\n enterActive: _propTypes.default.string,\n exit: _propTypes.default.string,\n exitDone: _propTypes.default.string,\n exitActive: _propTypes.default.string\n})]) : null;\nexports.classNamesShape = classNamesShape;","'use strict';\n\nvar _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; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _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; }\n\nfunction _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; }\n\n/*\nCopyright (c) 2015 Twitter, Inc. and other contributors\n\nComponent to add Velocity animations to one or more children. Wraps a single child without adding\nadditional DOM nodes.\n\nThe API attempts to be as declarative as possible. A single animation property declares what\nanimation the child should have. If that property changes, this component applies the new animation\nto the child on the next tick.\n\nBy default, the animation is not run when the component is mounted. Instead, Velocity's \"finish\"\ncommand is used to jump to the animation's end state. For a component that animates out of and\nback in to a default state, this allows the parent to specify the \"animate into\" animation as\nthe default, and therefore not have to distinguish between the initial state and the state to\nreturn to after animating away.\n\nProperties:\n animation: Either an animation key or hash defining the animation. See Velocity's documentation\n for what this can be. (It is passed to Velocity exactly.)\n runOnMount: If true, runs the animation even when the component is first mounted.\n targetQuerySelector: By default, this component's single child is animated. If targetQuerySelector\n is provided, it is used to select descendants to apply the animation to. Use with caution, only\n when you're confident that React's reconciliation will preserve these nodes during animation.\n Also note querySelectorAll's silly behavior w.r.t. pruning results when being called on a node.\n A special value of \"children\" will use the direct children of the node, since there isn't a\n great way to specify that to querySelectorAll.\n interruptBehavior: Sets how the previous animation should behave when the \"animation\" prop is\n changed before it’s done. Default is \"stop\", which halts the animation where it is. \"finish\"\n will jump the animation to its completed appearance. \"queue\" will run the new animation after\n the previous one has finished.\n\nUnrecognized properties are passed as options to Velocity (e.g. \"duration\", \"delay\", \"loop\").\n\nMethods:\n runAnimation: Triggers the animation immediately. Useful for when you want an animation that\n corresponds to an event but not a particular model state change (e.g. a \"bump\" when a click\n occurs).\n*/\n/* eslint react/no-find-dom-node: 0 */\n\nvar _ = {\n forEach: require('lodash/forEach'),\n isEqual: require('lodash/isEqual'),\n keys: require('lodash/keys'),\n omit: require('lodash/omit')\n};\n\nvar React = require('react');\nvar ReactDOM = require('react-dom');\nvar PropTypes = require('prop-types');\nvar Velocity = require('./lib/velocity-animate-shim');\n\nvar VelocityComponent = function (_React$Component) {\n _inherits(VelocityComponent, _React$Component);\n\n function VelocityComponent(props) {\n _classCallCheck(this, VelocityComponent);\n\n var _this = _possibleConstructorReturn(this, (VelocityComponent.__proto__ || Object.getPrototypeOf(VelocityComponent)).call(this, props));\n\n _this._animationTimeout = null;\n\n // This public method is kept as self-bound to maintain compatibility with the React.createClass\n // version of the component.\n _this.runAnimation = _this.runAnimation.bind(_this);\n return _this;\n }\n\n _createClass(VelocityComponent, [{\n key: 'componentDidMount',\n value: function componentDidMount() {\n this.runAnimation();\n\n // Jump to the end so that the component has the visual appearance of the animation having\n // been run to completion.\n if (this.props.runOnMount !== true) {\n this._finishAnimation();\n }\n }\n }, {\n key: 'componentDidUpdate',\n value: function componentDidUpdate(oldProps) {\n if (!_.isEqual(oldProps.animation, this.props.animation)) {\n if (this.props.interruptBehavior === 'stop') {\n this._stopAnimation();\n } else if (this.props.interruptBehavior === 'finish') {\n this._finishAnimation();\n }\n\n this._scheduleAnimation();\n }\n }\n }, {\n key: 'componentWillUnmount',\n value: function componentWillUnmount() {\n this._stopAnimation();\n this._clearVelocityCache(this._getDOMTarget());\n\n if (this._animationTimeout) {\n clearTimeout(this._animationTimeout);\n }\n }\n\n // It's ok to call this externally! By default the animation will be queued up. Pass stop: true in\n // to stop the current animation before running. Pass finish: true to finish the current animation\n // before running.\n\n }, {\n key: 'runAnimation',\n value: function runAnimation(config) {\n config = config || {};\n\n this._animationTimeout = null;\n\n if (this.props.animation == null) {\n return;\n }\n\n if (config.stop) {\n Velocity(this._getDOMTarget(), 'stop', true);\n } else if (config.finish) {\n Velocity(this._getDOMTarget(), 'finishAll', true);\n }\n\n // Delegate all props except for the ones that we have specified as our own via propTypes.\n var opts = _.omit(this.props, _.keys(VelocityComponent.propTypes));\n Velocity(this._getDOMTarget(), this.props.animation, opts);\n }\n\n // We trigger animations on a new tick because of a Velocity bug where adding a\n // multi-step animation from within a complete callback causes the first 2 animations to run\n // simultaneously.\n\n }, {\n key: '_scheduleAnimation',\n value: function _scheduleAnimation() {\n if (this._animationTimeout) {\n return;\n }\n\n this._animationTimeout = setTimeout(this.runAnimation, 0);\n }\n\n // Returns one or more DOM nodes to apply the animation to. This is checked every time we start\n // or stop an animation, which means that if an animation is proceeding but the element is removed\n // from the page, it will run its course rather than ever being stopped. (We go this route\n // because of difficulty in tracking what animations are currently being animated, due to both\n // chained animations and the need to be able to \"stop\" an animation before it begins.)\n\n }, {\n key: '_getDOMTarget',\n value: function _getDOMTarget() {\n var node = ReactDOM.findDOMNode(this);\n\n if (this.props.targetQuerySelector === 'children') {\n return node.children;\n } else if (this.props.targetQuerySelector != null) {\n return node.querySelectorAll(this.props.targetQuerySelector);\n } else {\n return node;\n }\n }\n }, {\n key: '_finishAnimation',\n value: function _finishAnimation() {\n Velocity(this._getDOMTarget(), 'finishAll', true);\n }\n }, {\n key: '_stopAnimation',\n value: function _stopAnimation() {\n Velocity(this._getDOMTarget(), 'stop', true);\n }\n\n // Velocity keeps extensive caches for all animated elements to minimize layout thrashing.\n // This can cause a serious memory leak, keeping references to unmounted elements as well\n // completion handlers and associated react objects. This crudely clears these references.\n\n }, {\n key: '_clearVelocityCache',\n value: function _clearVelocityCache(target) {\n if (target.length) {\n _.forEach(target, this._clearVelocityCache);\n } else {\n Velocity.Utilities.removeData(target, ['velocity', 'fxqueue']);\n }\n }\n\n // This component does not include any DOM footprint of its own, so instead we return our\n // child out of render(). (Render must only return a single element, which restricts us to\n // one child. If you want to animate multiple children, provide your own wrapper element and\n // use the \"targetQuerySelector\" prop to target its children.)\n\n }, {\n key: 'render',\n value: function render() {\n return this.props.children;\n }\n }]);\n\n return VelocityComponent;\n}(React.Component);\n\nVelocityComponent.propTypes = {\n animation: PropTypes.any,\n children: PropTypes.element.isRequired,\n runOnMount: PropTypes.bool,\n targetQuerySelector: PropTypes.string,\n interruptBehavior: PropTypes.string\n // Any additional properties will be sent as options to Velocity\n};\n\nVelocityComponent.defaultProps = {\n animation: null,\n runOnMount: false,\n targetQuerySelector: null,\n interruptBehavior: 'stop'\n};\n\nmodule.exports = VelocityComponent;","'use strict';\n\n// Copyright (c) 2015 Twitter, Inc. and other contributors\n\nvar _ = {\n isObject: require('lodash/isObject')\n};\nvar Velocity = require('./lib/velocity-animate-shim');\n\nvar effectCounter = 0;\n\n// Takes a Velocity \"UI pack effect\" definition and registers it with a unique key, returning that\n// key (to later pass as a value for the \"animation\" property). Takes an optional suffix, which can\n// be \"In\" or \"Out\" to modify UI Pack's behavior.\n//\n// Unlike what you get from passing a style hash to VelocityComponent's \"animation\" property,\n// Velocity \"UI pack effects\" can have chained animation calls and specify a \"defaultDuration\", and\n// also can take advantage of \"stagger\" and \"reverse\" options on the VelocityComponent.\n//\n// You will need to manually register the UI Pack with the global Velocity in your application with:\n//\n// require('velocity');\n// require('velocity-animate/velocity.ui');\n//\n// See: http://julian.com/research/velocity/#uiPack\n//\n// Typical usage:\n//\n// var Animations = {\n// down: VelocityHelpers.registerEffect({\n// defaultDuration: 1100,\n// calls: [\n// [{\n// transformOriginX: [ '50%', '50%' ],\n// transformOriginY: [ 0, 0 ],\n// rotateX: [0, 'spring'],\n// }, 1, {\n// delay: 100,\n// easing: 'ease-in',\n// }]\n// ],\n// }),\n//\n// up: VelocityHelpers.registerEffect({\n// defaultDuration: 200,\n// calls: [\n// [{\n// transformOriginX: [ '50%', '50%' ],\n// transformOriginY: [ 0, 0 ],\n// rotateX: 160,\n// }]\n// ],\n// }),\n// };\n// ...\n// \n// ...\n// \nfunction registerEffect(suffix, animation) {\n if (_.isObject(suffix)) {\n animation = suffix;\n suffix = '';\n }\n\n var key = 'VelocityHelper.animation.' + effectCounter++ + suffix;\n\n // No-op on the server for now.\n if (Velocity.velocityReactServerShim) {\n return key;\n }\n\n if (Velocity.RegisterEffect === undefined) {\n throw \"Velocity.RegisterEffect not found. You need to require 'velocity-animate/velocity.ui' at a top level for UI Pack.\";\n }\n\n Velocity.RegisterEffect(key, animation);\n return key;\n}\n\nmodule.exports = {\n registerEffect: registerEffect\n};","'use strict';\n\nvar _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; };\n\nvar _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; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _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; }\n\nfunction _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; }\n\n/*\nCopyright (c) 2015 Twitter, Inc. and other contributors\n\nComponent to add Velocity animations around React transitions. Delegates to the React TransitionGroup\naddon.\n\nProperties\n enter: Animation to run on a child component being added\n leave: Animation to run on a child component leaving\n runOnMount: if true, runs the \"enter\" animation on the elements that exist as children when this\n component is mounted.\n enterHideStyle/enterShowStyle: see below.\n\nAny additional properties (e.g. \"className\", \"component\") will be passed to the internal\nTransitionGroup.\n\n\"enter\" and \"leave\" should either be a string naming an animation, or a hash with an\n\"animation\" key that can either be a string itself, or a hash of style attributes to animate (this\nvalue is passed to Velocity its the first arg).\n\nIf \"enter\" or \"leave\" is a hash, it can additionally have a \"style\" value that is applied the tick\nbefore the Velocity animation starts. Use this for non-animating properties (like \"position\") that\nare prerequisites for correct animation. The style value is applied using Velocity's JS -> CSS\nroutines, which may differ from React's.\n\nAny hash entries beyond \"animation\" and \"style\" are passed in an options hash to Velocity. Use this\nfor options like \"stagger\", \"reverse\", &tc.\n\nBy default, this component will immediately hide all entering children with display: 'none', and\nunhide them one tick later with display: ''. This is done so that we can coalesce multiple enters\ninto a single animation, and we want to avoid any popping of elements in while they're collected. If\nyou prefer a different way of hiding these elements so that e.g. geometry can be immediately\ncalculated, use the enterHideStyle and enterShowStyle props to provide alternate style hashes for\nhiding and revealing entering elements.\n\nStatics\n disabledForTest: Set this to true globally to turn off all custom animation logic. Instead, this\n component will behave like a vanilla TransitionGroup.\n\nInspired by https://gist.github.com/tkafka/0d94c6ec94297bb67091\n*/\n/* eslint react/no-find-dom-node: 0 */\n\nvar _ = {\n each: require('lodash/each'),\n extend: require('lodash/extend'),\n forEach: require('lodash/forEach'),\n isEqual: require('lodash/isEqual'),\n keys: require('lodash/keys'),\n omit: require('lodash/omit'),\n map: require('lodash/map')\n};\nvar React = require('react');\nvar ReactDOM = require('react-dom');\nvar PropTypes = require('prop-types');\nvar TransitionGroup = require('react-transition-group/TransitionGroup');\nvar Transition = require('react-transition-group/Transition').default;\nvar Velocity = require('./lib/velocity-animate-shim');\n\n// Shim requestAnimationFrame for browsers that don't support it, in particular IE 9.\nvar shimRequestAnimationFrame = typeof window !== 'undefined' && (window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || function (callback) {\n window.setTimeout(callback, 0);\n});\n\n// Fix 'Invalid calling object' error in IE\nshimRequestAnimationFrame = typeof window !== 'undefined' && shimRequestAnimationFrame.bind(window);\n\nvar shimCancelAnimationFrame = typeof window !== 'undefined' && (window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || function (timeout) {\n window.clearTimeout(timeout);\n});\n\nshimCancelAnimationFrame = typeof window !== 'undefined' && shimCancelAnimationFrame.bind(window);\n\n// Internal wrapper for the transitioned elements. Delegates all child lifecycle events to the\n// parent VelocityTransitionGroup so that it can co-ordinate animating all of the elements at once.\n\nvar VelocityTransitionGroupChild = function (_React$Component) {\n _inherits(VelocityTransitionGroupChild, _React$Component);\n\n function VelocityTransitionGroupChild() {\n var _ref;\n\n var _temp, _this, _ret;\n\n _classCallCheck(this, VelocityTransitionGroupChild);\n\n for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = VelocityTransitionGroupChild.__proto__ || Object.getPrototypeOf(VelocityTransitionGroupChild)).call.apply(_ref, [this].concat(args))), _this), _this.lastState = 'appear', _this.componentWillEnter = function (node, appearing) {\n _this.lastState = appearing ? 'appear' : 'enter';\n }, _this.componentWillExit = function () {\n _this.lastState = 'exit';\n }, _this.endListener = function (node, done) {\n switch (_this.lastState) {\n case 'appear':\n _this.props.willAppearFunc(node, done);\n break;\n case 'enter':\n _this.props.willEnterFunc(node, done);\n break;\n case 'exit':\n _this.props.willLeaveFunc(node, done);\n break;\n }\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n // We trigger our transitions out of endListener because that gives us access to the done callback\n // we can use to tell the Transition that the animation has completed.\n\n\n _createClass(VelocityTransitionGroupChild, [{\n key: 'componentWillUnmount',\n value: function componentWillUnmount() {\n // Clear references from velocity cache.\n Velocity.Utilities.removeData(ReactDOM.findDOMNode(this), ['velocity', 'fxqueue']);\n }\n }, {\n key: 'render',\n value: function render() {\n var transitionProps = _.omit(this.props, _.keys(VelocityTransitionGroupChild.propTypes));\n\n return React.createElement(Transition, _extends({}, transitionProps, {\n timeout: null,\n addEndListener: this.endListener,\n appear: true,\n onEnter: this.componentWillEnter,\n onExit: this.componentWillExit\n }), this.props.children);\n }\n }]);\n\n return VelocityTransitionGroupChild;\n}(React.Component);\n\nVelocityTransitionGroupChild.propTypes = {\n children: PropTypes.element.isRequired,\n willAppearFunc: PropTypes.func.isRequired,\n willEnterFunc: PropTypes.func.isRequired,\n willLeaveFunc: PropTypes.func.isRequired\n};\n\nvar VelocityTransitionGroup = function (_React$Component2) {\n _inherits(VelocityTransitionGroup, _React$Component2);\n\n function VelocityTransitionGroup(props) {\n _classCallCheck(this, VelocityTransitionGroup);\n\n var _this2 = _possibleConstructorReturn(this, (VelocityTransitionGroup.__proto__ || Object.getPrototypeOf(VelocityTransitionGroup)).call(this, props));\n\n _this2._scheduledAnimationFrame = null;\n _this2._scheduledAnimationRunFrames = [];\n _this2._entering = [];\n _this2._leaving = [];\n\n _this2._timers = [];\n _this2._unmounted = false;\n\n _this2.childWillAppear = _this2.childWillAppear.bind(_this2);\n _this2.childWillEnter = _this2.childWillEnter.bind(_this2);\n _this2.childWillLeave = _this2.childWillLeave.bind(_this2);\n\n _this2._runAnimations = _this2._runAnimations.bind(_this2);\n _this2._wrapChild = _this2._wrapChild.bind(_this2);\n return _this2;\n }\n\n _createClass(VelocityTransitionGroup, [{\n key: 'componentWillUnmount',\n value: function componentWillUnmount() {\n if (this._scheduledAnimationFrame) {\n shimCancelAnimationFrame(this._scheduledAnimationFrame);\n }\n\n _.forEach(this._timers, function (timer) {\n clearTimeout(timer);\n });\n\n _.forEach(this._scheduledAnimationRunFrames, function (frame) {\n shimCancelAnimationFrame(frame);\n });\n\n // We don't cancel all the in-process animations, so we use this to know if the component\n // is gone when an animation is over.\n this._unmounted = true;\n }\n }, {\n key: 'render',\n value: function render() {\n // Pass any props that are not our own on into the TransitionGroup delegate.\n var transitionGroupProps = _.omit(this.props, _.keys(VelocityTransitionGroup.propTypes));\n\n return React.createElement(TransitionGroup, transitionGroupProps, !this.constructor.disabledForTest && !Velocity.velocityReactServerShim ? React.Children.map(this.props.children, this._wrapChild) : React.Children.map(this.props.children,\n // Wrapping in a no-op Transition to consume the props that\n // TransitionGroup gives its children. Fixes react-dom warnings\n // in test for those props appearing on divs and such.\n function (child) {\n return child && React.createElement(Transition, { timeout: 0 }, child);\n }));\n }\n }, {\n key: 'childWillAppear',\n value: function childWillAppear(node, doneFn) {\n var _this3 = this;\n\n if (this.props.runOnMount) {\n this.childWillEnter(node, doneFn);\n } else {\n this._finishAnimation(node, this.props.enter);\n\n // Important to tick over so that any callbacks due to finishing the animation complete first.\n //\n // Using setTimeout so that doneFn gets called even when the tab is hidden.\n var t = setTimeout(function () {\n var idx = _this3._timers.indexOf(t);\n if (idx >= 0) {\n _this3._timers.splice(idx, 1);\n }\n\n doneFn();\n }, 0);\n this._timers.push(t);\n }\n }\n }, {\n key: 'childWillEnter',\n value: function childWillEnter(node, doneFn) {\n if (this._shortCircuitAnimation(this.props.enter, doneFn)) return;\n\n // By finishing a \"leave\" on the element, we put it in the right state to be animated in. Useful\n // if \"leave\" includes a rotation or something that we'd like to have as our starting point, for\n // symmetry.\n // We use overrideOpts to prevent any \"begin\" or \"complete\" callback from triggering in this case, since\n // it doesn't make a ton of sense.\n this._finishAnimation(node, this.props.leave, {\n begin: undefined,\n complete: undefined\n });\n\n // We're not going to start the animation for a tick, so set the node's display to none (or any\n // custom \"hide\" style provided) so that it doesn't flash in.\n _.forEach(this.props.enterHideStyle, function (val, key) {\n Velocity.CSS.setPropertyValue(node, key, val);\n });\n\n this._entering.push({\n node: node,\n doneFn: doneFn\n });\n\n this._schedule();\n }\n }, {\n key: 'childWillLeave',\n value: function childWillLeave(node, doneFn) {\n if (this._shortCircuitAnimation(this.props.leave, doneFn)) return;\n\n this._leaving.push({\n node: node,\n doneFn: doneFn\n });\n\n this._schedule();\n }\n\n // document.hidden check is there because animation completion callbacks won't fire (due to\n // chaining off of rAF), which would prevent entering / leaving DOM nodes from being cleaned up\n // while the tab is hidden.\n //\n // Returns true if this did short circuit, false if lifecycle methods should continue with\n // their animations.\n\n }, {\n key: '_shortCircuitAnimation',\n value: function _shortCircuitAnimation(animationProp, doneFn) {\n if (document.hidden || this._parseAnimationProp(animationProp).animation == null) {\n doneFn();\n\n return true;\n } else {\n return false;\n }\n }\n }, {\n key: '_schedule',\n value: function _schedule() {\n if (this._scheduledAnimationFrame) {\n return;\n }\n\n // Need rAF to make sure we're in the same event queue as Velocity from here out. Important\n // for avoiding getting wrong interleaving with Velocity callbacks.\n this._scheduledAnimationFrame = shimRequestAnimationFrame(this._runAnimations);\n }\n\n // arrow function because this is used as an rAF callback\n\n }, {\n key: '_runAnimations',\n value: function _runAnimations() {\n this._scheduledAnimationFrame = null;\n\n this._runAnimation(true, this._entering, this.props.enter);\n this._runAnimation(false, this._leaving, this.props.leave);\n\n this._entering = [];\n this._leaving = [];\n }\n\n // Used to parse out the 'enter' and 'leave' properties. Handles cases where they are omitted\n // as well as when they are just strings and not hashes of animation and options.\n\n }, {\n key: '_parseAnimationProp',\n value: function _parseAnimationProp(animationProp) {\n var animation, opts, style;\n\n if (typeof animationProp === 'string') {\n animation = animationProp;\n style = null;\n opts = {};\n } else {\n animation = animationProp != null ? animationProp.animation : null;\n style = animationProp != null ? animationProp.style : null;\n opts = _.omit(animationProp, 'animation', 'style');\n }\n\n return {\n animation: animation,\n style: style,\n opts: opts\n };\n }\n }, {\n key: '_runAnimation',\n value: function _runAnimation(entering, queue, animationProp) {\n var _this4 = this;\n\n if (queue.length === 0) {\n return;\n }\n\n var nodes = _.map(queue, 'node');\n var doneFns = _.map(queue, 'doneFn');\n\n var parsedAnimation = this._parseAnimationProp(animationProp);\n var animation = parsedAnimation.animation;\n var style = parsedAnimation.style;\n var opts = parsedAnimation.opts;\n\n // Clearing display reverses the behavior from childWillAppear where all elements are added with\n // display: none to prevent them from flashing in before the animation starts. We don't do this\n // for the fade/slide animations or any animation that ends in \"In,\" since Velocity will handle\n // it for us.\n //\n // If a custom \"enterShowStyle\" prop is passed, (i.e. not one that just reverses display: none)\n // we always run it, regardless of the animation, since it's probably doing something around\n // opacity or positioning that Velocity will not necessarily reset.\n if (entering) {\n if (!_.isEqual(this.props.enterShowStyle, { display: '' }) || !(/^(fade|slide)/.test(animation) || /In$/.test(animation))) {\n style = _.extend({}, this.props.enterShowStyle, style);\n }\n }\n\n // Because Safari can synchronously repaint when CSS \"display\" is reset, we set styles for all\n // browsers before the rAF tick below that starts the animation. This way you know in all\n // cases that you need to support your static styles being visible on the element before\n // the animation begins.\n if (style != null) {\n _.each(style, function (value, key) {\n Velocity.hook(nodes, key, value);\n });\n }\n\n var doneFn = function doneFn() {\n // calling doneFns after the parent has unmounted leads to errors\n if (_this4._unmounted) {\n return;\n }\n\n doneFns.map(function (doneFn) {\n doneFn();\n });\n };\n\n // For nodes that are entering, we tell the TransitionGroup that we're done with them\n // immediately. That way, they can be removed later before their entering animations complete.\n // If we're leaving, we stop current animations (which may be partially-completed enter\n // animations) so that we can then animate out. Velocity typically makes these transitions\n // very smooth, correctly animating from whatever state the element is currently in.\n if (entering) {\n doneFn();\n doneFn = null;\n } else {\n Velocity(nodes, 'stop');\n }\n\n var combinedCompleteFn;\n if (doneFn && opts.complete) {\n var optsCompleteFn = opts.complete;\n combinedCompleteFn = function combinedCompleteFn() {\n doneFn();\n // preserve this / args from Velocity so the complete function has context for what completed\n optsCompleteFn.apply(this, arguments);\n };\n } else {\n // One or the other or neither.\n combinedCompleteFn = doneFn || opts.complete;\n }\n\n // Bit of a hack. Without this rAF, sometimes an enter animation doesn't start running, or is\n // stopped before getting anywhere. This should get us on the other side of both completeFn and\n // any _finishAnimation that's happening.\n var t = shimRequestAnimationFrame(function () {\n var idx = _this4._scheduledAnimationRunFrames.indexOf(t);\n if (idx >= 0) {\n _this4._scheduledAnimationRunFrames.splice(idx, 1);\n }\n\n Velocity(nodes, animation, _.extend({}, opts, {\n complete: combinedCompleteFn\n }));\n });\n\n this._scheduledAnimationRunFrames.push(t);\n }\n }, {\n key: '_finishAnimation',\n value: function _finishAnimation(node, animationProp, overrideOpts) {\n var parsedAnimation = this._parseAnimationProp(animationProp);\n var animation = parsedAnimation.animation;\n var style = parsedAnimation.style;\n var opts = _.extend({}, parsedAnimation.opts, overrideOpts);\n\n if (style != null) {\n _.each(style, function (value, key) {\n Velocity.hook(node, key, value);\n });\n }\n\n if (animation != null) {\n // Opts are relevant even though we're immediately finishing, since things like \"display\"\n // can affect the animation outcome.\n\n Velocity(node, animation, opts);\n Velocity(node, 'finishAll', true);\n }\n }\n }, {\n key: '_wrapChild',\n value: function _wrapChild(child) {\n // Need to guard against falsey children, which React will sometimes pass\n // in.\n if (!child) {\n return null;\n }\n\n return React.createElement(VelocityTransitionGroupChild, {\n key: child.key,\n willAppearFunc: this.childWillAppear,\n willEnterFunc: this.childWillEnter,\n willLeaveFunc: this.childWillLeave\n }, child);\n }\n }]);\n\n return VelocityTransitionGroup;\n}(React.Component);\n\nVelocityTransitionGroup.disabledForTest = false; // global, mutable, for disabling animations during test\n\nVelocityTransitionGroup.propTypes = {\n runOnMount: PropTypes.bool,\n enter: PropTypes.any,\n leave: PropTypes.any,\n children: PropTypes.any,\n enterHideStyle: PropTypes.object,\n enterShowStyle: PropTypes.object\n};\n\nVelocityTransitionGroup.defaultProps = {\n runOnMount: false,\n enter: null,\n leave: null,\n enterHideStyle: {\n display: 'none'\n },\n enterShowStyle: {\n display: ''\n }\n};\n\nmodule.exports = VelocityTransitionGroup;"],"sourceRoot":""}