react/src/addons/transitions/ReactTransitionGroup.js

/**
 * Copyright 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule ReactTransitionGroup
 */

'use strict';

var React = require('React');
var ReactAddonsDOMDependencies = require('ReactAddonsDOMDependencies');
var ReactTransitionChildMapping = require('ReactTransitionChildMapping');

var emptyFunction = require('emptyFunction');

/**
 * A basis for animations. When children are declaratively added or removed,
 * special lifecycle hooks are called.
 * See https://facebook.github.io/react/docs/animation.html#low-level-api-reacttransitiongroup
 */
class ReactTransitionGroup extends React.Component {
  static displayName = 'ReactTransitionGroup';

  static propTypes = {
    component: React.PropTypes.any,
    childFactory: React.PropTypes.func,
  };

  static defaultProps = {
    component: 'span',
    childFactory: emptyFunction.thatReturnsArgument,
  };

  state = {
    // TODO: can we get useful debug information to show at this point?
    children: ReactTransitionChildMapping.getChildMapping(this.props.children),
  };

  componentWillMount() {
    this.currentlyTransitioningKeys = {};
    this.keysToEnter = [];
    this.keysToLeave = [];
  }

  componentDidMount() {
    var initialChildMapping = this.state.children;
    for (var key in initialChildMapping) {
      if (initialChildMapping[key]) {
        this.performAppear(key);
      }
    }
  }

  componentWillReceiveProps(nextProps) {
    var nextChildMapping;
    if (__DEV__) {
      nextChildMapping = ReactTransitionChildMapping.getChildMapping(
        nextProps.children,
        ReactAddonsDOMDependencies.getReactInstanceMap().get(this)._debugID
      );
    } else {
      nextChildMapping = ReactTransitionChildMapping.getChildMapping(
        nextProps.children
      );
    }
    var prevChildMapping = this.state.children;

    this.setState({
      children: ReactTransitionChildMapping.mergeChildMappings(
        prevChildMapping,
        nextChildMapping
      ),
    });

    var key;

    for (key in nextChildMapping) {
      var hasPrev = prevChildMapping && prevChildMapping.hasOwnProperty(key);
      if (nextChildMapping[key] && !hasPrev &&
          !this.currentlyTransitioningKeys[key]) {
        this.keysToEnter.push(key);
      }
    }

    for (key in prevChildMapping) {
      var hasNext = nextChildMapping && nextChildMapping.hasOwnProperty(key);
      if (prevChildMapping[key] && !hasNext &&
          !this.currentlyTransitioningKeys[key]) {
        this.keysToLeave.push(key);
      }
    }

    // If we want to someday check for reordering, we could do it here.
  }

  componentDidUpdate() {
    var keysToEnter = this.keysToEnter;
    this.keysToEnter = [];
    keysToEnter.forEach(this.performEnter);

    var keysToLeave = this.keysToLeave;
    this.keysToLeave = [];
    keysToLeave.forEach(this.performLeave);
  }

  performAppear = (key) => {
    this.currentlyTransitioningKeys[key] = true;

    var component = this.refs[key];

    if (component.componentWillAppear) {
      component.componentWillAppear(
        this._handleDoneAppearing.bind(this, key)
      );
    } else {
      this._handleDoneAppearing(key);
    }
  };

  _handleDoneAppearing = (key) => {
    var component = this.refs[key];
    if (component.componentDidAppear) {
      component.componentDidAppear();
    }

    delete this.currentlyTransitioningKeys[key];

    var currentChildMapping;
    if (__DEV__) {
      currentChildMapping = ReactTransitionChildMapping.getChildMapping(
        this.props.children,
        ReactAddonsDOMDependencies.getReactInstanceMap().get(this)._debugID
      );
    } else {
      currentChildMapping = ReactTransitionChildMapping.getChildMapping(
        this.props.children
      );
    }

    if (!currentChildMapping || !currentChildMapping.hasOwnProperty(key)) {
      // This was removed before it had fully appeared. Remove it.
      this.performLeave(key);
    }
  };

  performEnter = (key) => {
    this.currentlyTransitioningKeys[key] = true;

    var component = this.refs[key];

    if (component.componentWillEnter) {
      component.componentWillEnter(
        this._handleDoneEntering.bind(this, key)
      );
    } else {
      this._handleDoneEntering(key);
    }
  };

  _handleDoneEntering = (key) => {
    var component = this.refs[key];
    if (component.componentDidEnter) {
      component.componentDidEnter();
    }

    delete this.currentlyTransitioningKeys[key];

    var currentChildMapping;
    if (__DEV__) {
      currentChildMapping = ReactTransitionChildMapping.getChildMapping(
        this.props.children,
        ReactAddonsDOMDependencies.getReactInstanceMap().get(this)._debugID
      );
    } else {
      currentChildMapping = ReactTransitionChildMapping.getChildMapping(
        this.props.children
      );
    }

    if (!currentChildMapping || !currentChildMapping.hasOwnProperty(key)) {
      // This was removed before it had fully entered. Remove it.
      this.performLeave(key);
    }
  };

  performLeave = (key) => {
    this.currentlyTransitioningKeys[key] = true;

    var component = this.refs[key];
    if (component.componentWillLeave) {
      component.componentWillLeave(this._handleDoneLeaving.bind(this, key));
    } else {
      // Note that this is somewhat dangerous b/c it calls setState()
      // again, effectively mutating the component before all the work
      // is done.
      this._handleDoneLeaving(key);
    }
  };

  _handleDoneLeaving = (key) => {
    var component = this.refs[key];

    if (component.componentDidLeave) {
      component.componentDidLeave();
    }

    delete this.currentlyTransitioningKeys[key];

    var currentChildMapping;
    if (__DEV__) {
      currentChildMapping = ReactTransitionChildMapping.getChildMapping(
        this.props.children,
        ReactAddonsDOMDependencies.getReactInstanceMap().get(this)._debugID
      );
    } else {
      currentChildMapping = ReactTransitionChildMapping.getChildMapping(
        this.props.children
      );
    }

    if (currentChildMapping && currentChildMapping.hasOwnProperty(key)) {
      // This entered again before it fully left. Add it again.
      this.performEnter(key);
    } else {
      this.setState(function(state) {
        var newChildren = Object.assign({}, state.children);
        delete newChildren[key];
        return {children: newChildren};
      });
    }
  };

  render() {
    // TODO: we could get rid of the need for the wrapper node
    // by cloning a single child
    var childrenToRender = [];
    for (var key in this.state.children) {
      var child = this.state.children[key];
      if (child) {
        // You may need to apply reactive updates to a child as it is leaving.
        // The normal React way to do it won't work since the child will have
        // already been removed. In case you need this behavior you can provide
        // a childFactory function to wrap every child, even the ones that are
        // leaving.
        childrenToRender.push(React.cloneElement(
          this.props.childFactory(child),
          {ref: key, key: key}
        ));
      }
    }

    // Do not forward ReactTransitionGroup props to primitive DOM nodes
    var props = Object.assign({}, this.props);
    delete props.transitionLeave;
    delete props.transitionName;
    delete props.transitionAppear;
    delete props.transitionEnter;
    delete props.childFactory;
    delete props.transitionLeaveTimeout;
    delete props.transitionEnterTimeout;
    delete props.transitionAppearTimeout;
    delete props.component;

    return React.createElement(
      this.props.component,
      props,
      childrenToRender
    );
  }
}

module.exports = ReactTransitionGroup;