text: /**
   * Copyright 2013 Facebook, Inc.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *
   * @providesModule ReactPropTransferer
   */
  
  "use strict";
  
  var emptyFunction = require("./emptyFunction");
  var joinClasses = require("./joinClasses");
  var merge = require("./merge");
  
  /**
   * Creates a transfer strategy that will merge prop values using the supplied
   * `mergeStrategy`. If a prop was previously unset, this just sets it.
   *
   * @param {function} mergeStrategy
   * @return {function}
   */
  function createTransferStrategy(mergeStrategy) {
    return function(props, key, value) {
      if (!props.hasOwnProperty(key)) {
        props[key] = value;
      } else {
        props[key] = mergeStrategy(props[key], value);
      }
    };
  }
  
  /**
   * Transfer strategies dictate how props are transferred by `transferPropsTo`.
   */
  var TransferStrategies = {
    /**
     * Never transfer `children`.
     */
    children: emptyFunction,
    /**
     * Transfer the `className` prop by merging them.
     */
    className: createTransferStrategy(joinClasses),
    /**
     * Never transfer the `ref` prop.
     */
    ref: emptyFunction,
    /**
     * Transfer the `style` prop (which is an object) by merging them.
     */
    style: createTransferStrategy(merge)
  };
  
  /**
   * ReactPropTransferer are capable of transferring props to another component
   * using a `transferPropsTo` method.
   *
   * @class ReactPropTransferer
   */
  var ReactPropTransferer = {
  
    TransferStrategies: TransferStrategies,
  
    /**
     * @lends {ReactPropTransferer.prototype}
     */
    Mixin: {
  
      /**
       * Transfer props from this component to a target component.
       *
       * Props that do not have an explicit transfer strategy will be transferred
       * only if the target component does not already have the prop set.
       *
       * This is usually used to pass down props to a returned root component.
       *
       * @param {ReactComponent} component Component receiving the properties.
       * @return {ReactComponent} The supplied `component`.
       * @final
       * @protected
       */
      transferPropsTo: function(component) {
        var props = {};
        for (var thatKey in component.props) {
          if (component.props.hasOwnProperty(thatKey)) {
            props[thatKey] = component.props[thatKey];
          }
        }
        for (var thisKey in this.props) {
          if (!this.props.hasOwnProperty(thisKey)) {
            continue;
          }
          var transferStrategy = TransferStrategies[thisKey];
          if (transferStrategy) {
            transferStrategy(props, thisKey, this.props[thisKey]);
          } else if (!props.hasOwnProperty(thisKey)) {
            props[thisKey] = this.props[thisKey];
          }
        }
        component.props = props;
        return component;
      }
  
    }
  
  };
  
  module.exports = ReactPropTransferer;
  