react 0.13.3 → 0.14.0-beta1

package/lib/isEventSupported.js

@@ -15,12 +15,10 @@ var ExecutionEnvironment = require("./ExecutionEnvironment");
 
 var useHasFeature;
 if (ExecutionEnvironment.canUseDOM) {
-  useHasFeature =
-    document.implementation &&
-    document.implementation.hasFeature &&
-    // always returns true in newer browsers as per the standard.
-    // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature
-    document.implementation.hasFeature('', '') !== true;
+  useHasFeature = document.implementation && document.implementation.hasFeature &&
+  // always returns true in newer browsers as per the standard.
+  // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature
+  document.implementation.hasFeature('', '') !== true;
 }
 
 /**
@@ -38,13 +36,12 @@ if (ExecutionEnvironment.canUseDOM) {
  * @license Modernizr 3.0.0pre (Custom Build) | MIT
  */
 function isEventSupported(eventNameSuffix, capture) {
-  if (!ExecutionEnvironment.canUseDOM ||
-      capture && !('addEventListener' in document)) {
+  if (!ExecutionEnvironment.canUseDOM || capture && !('addEventListener' in document)) {
     return false;
   }
 
   var eventName = 'on' + eventNameSuffix;
-  var isSupported = eventName in document;
+  var isSupported = (eventName in document);
 
   if (!isSupported) {
     var element = document.createElement('div');
@@ -60,4 +57,4 @@ function isEventSupported(eventNameSuffix, capture) {
   return isSupported;
 }
 
-module.exports = isEventSupported;
+module.exports = isEventSupported;

package/lib/isNode.js

@@ -14,12 +14,10 @@
  * @param {*} object The object to check.
  * @return {boolean} Whether or not the object is a DOM node.
  */
+'use strict';
+
 function isNode(object) {
-  return !!(object && (
-    ((typeof Node === 'function' ? object instanceof Node : typeof object === 'object' &&
-    typeof object.nodeType === 'number' &&
-    typeof object.nodeName === 'string'))
-  ));
+  return !!(object && (typeof Node === 'function' ? object instanceof Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'));
 }
 
-module.exports = isNode;
+module.exports = isNode;

package/lib/isTextInputElement.js

@@ -33,9 +33,8 @@ var supportedInputTypes = {
 };
 
 function isTextInputElement(elem) {
-  return elem && (
-    (elem.nodeName === 'INPUT' && supportedInputTypes[elem.type] || elem.nodeName === 'TEXTAREA')
-  );
+  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+  return nodeName && (nodeName === 'input' && supportedInputTypes[elem.type] || nodeName === 'textarea');
 }
 
-module.exports = isTextInputElement;
+module.exports = isTextInputElement;

package/lib/isTextNode.js

@@ -10,6 +10,8 @@
  * @typechecks
  */
 
+'use strict';
+
 var isNode = require("./isNode");
 
 /**
@@ -20,4 +22,4 @@ function isTextNode(object) {
   return isNode(object) && object.nodeType == 3;
 }
 
-module.exports = isTextNode;
+module.exports = isTextNode;

package/lib/joinClasses.js

@@ -16,10 +16,10 @@
  * Combines multiple className strings into one.
  * http://jsperf.com/joinclasses-args-vs-array
  *
- * @param {...?string} classes
+ * @param {...?string} className
  * @return {string}
  */
-function joinClasses(className/*, ... */) {
+function joinClasses(className /*, ... */) {
   if (!className) {
     className = '';
   }
@@ -36,4 +36,4 @@ function joinClasses(className/*, ... */) {
   return className;
 }
 
-module.exports = joinClasses;
+module.exports = joinClasses;

package/lib/keyMirror.js

@@ -32,13 +32,10 @@ var invariant = require("./invariant");
  * @param {object} obj
  * @return {object}
  */
-var keyMirror = function(obj) {
+var keyMirror = function (obj) {
   var ret = {};
   var key;
-  ("production" !== process.env.NODE_ENV ? invariant(
-    obj instanceof Object && !Array.isArray(obj),
-    'keyMirror(...): Argument must be an object.'
-  ) : invariant(obj instanceof Object && !Array.isArray(obj)));
+  !(obj instanceof Object && !Array.isArray(obj)) ? 'production' !== process.env.NODE_ENV ? invariant(false, 'keyMirror(...): Argument must be an object.') : invariant(false) : undefined;
   for (key in obj) {
     if (!obj.hasOwnProperty(key)) {
       continue;
@@ -48,4 +45,4 @@ var keyMirror = function(obj) {
   return ret;
 };
 
-module.exports = keyMirror;
+module.exports = keyMirror;

package/lib/keyOf.js

@@ -19,7 +19,9 @@
  * 'xa12' in that case. Resolve keys you want to use once at startup time, then
  * reuse those resolutions.
  */
-var keyOf = function(oneKeyObj) {
+"use strict";
+
+var keyOf = function (oneKeyObj) {
   var key;
   for (key in oneKeyObj) {
     if (!oneKeyObj.hasOwnProperty(key)) {
@@ -30,5 +32,4 @@ var keyOf = function(oneKeyObj) {
   return null;
 };
 
-
-module.exports = keyOf;
+module.exports = keyOf;

package/lib/mapObject.js

@@ -48,4 +48,4 @@ function mapObject(object, callback, context) {
   return result;
 }
 
-module.exports = mapObject;
+module.exports = mapObject;

package/lib/memoizeStringOnly.js

@@ -20,7 +20,7 @@
  */
 function memoizeStringOnly(callback) {
   var cache = {};
-  return function(string) {
+  return function (string) {
     if (!cache.hasOwnProperty(string)) {
       cache[string] = callback.call(this, string);
     }
@@ -28,4 +28,4 @@ function memoizeStringOnly(callback) {
   };
 }
 
-module.exports = memoizeStringOnly;
+module.exports = memoizeStringOnly;

package/lib/onlyChild.js

@@ -26,11 +26,8 @@ var invariant = require("./invariant");
  * structure.
  */
 function onlyChild(children) {
-  ("production" !== process.env.NODE_ENV ? invariant(
-    ReactElement.isValidElement(children),
-    'onlyChild must be passed a children with exactly one child.'
-  ) : invariant(ReactElement.isValidElement(children)));
+  !ReactElement.isValidElement(children) ? 'production' !== process.env.NODE_ENV ? invariant(false, 'onlyChild must be passed a children with exactly one child.') : invariant(false) : undefined;
   return children;
 }
 
-module.exports = onlyChild;
+module.exports = onlyChild;

package/lib/performance.js

@@ -17,10 +17,7 @@ var ExecutionEnvironment = require("./ExecutionEnvironment");
 var performance;
 
 if (ExecutionEnvironment.canUseDOM) {
-  performance =
-    window.performance ||
-    window.msPerformance ||
-    window.webkitPerformance;
+  performance = window.performance || window.msPerformance || window.webkitPerformance;
 }
 
-module.exports = performance || {};
+module.exports = performance || {};

package/lib/performanceNow.js

@@ -10,6 +10,8 @@
  * @typechecks
  */
 
+'use strict';
+
 var performance = require("./performance");
 
 /**
@@ -23,4 +25,4 @@ if (!performance || !performance.now) {
 
 var performanceNow = performance.now.bind(performance);
 
-module.exports = performanceNow;
+module.exports = performanceNow;

package/lib/quoteAttributeValueForBrowser.js

@@ -23,4 +23,4 @@ function quoteAttributeValueForBrowser(value) {
   return '"' + escapeTextContentForBrowser(value) + '"';
 }
 
-module.exports = quoteAttributeValueForBrowser;
+module.exports = quoteAttributeValueForBrowser;

package/lib/renderSubtreeIntoContainer.js

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2013-2015, 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 renderSubtreeIntoContainer
+*/
+
+'use strict';
+
+var ReactMount = require("./ReactMount");
+
+module.exports = ReactMount.renderSubtreeIntoContainer;

package/lib/setInnerHTML.js

@@ -26,14 +26,14 @@ var NONVISIBLE_TEST = /<(!--|link|noscript|meta|script|style)[ \r\n\t\f\/>]/;
  * @param {string} html
  * @internal
  */
-var setInnerHTML = function(node, html) {
+var setInnerHTML = function (node, html) {
   node.innerHTML = html;
 };
 
 // Win8 apps: Allow all html to be inserted
 if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) {
-  setInnerHTML = function(node, html) {
-    MSApp.execUnsafeLocalFunction(function() {
+  setInnerHTML = function (node, html) {
+    MSApp.execUnsafeLocalFunction(function () {
       node.innerHTML = html;
     });
   };
@@ -49,7 +49,7 @@ if (ExecutionEnvironment.canUseDOM) {
   var testElement = document.createElement('div');
   testElement.innerHTML = ' ';
   if (testElement.innerHTML === '') {
-    setInnerHTML = function(node, html) {
+    setInnerHTML = function (node, html) {
       // Magic theory: IE8 supposedly differentiates between added and updated
       // nodes when processing innerHTML, innerHTML on updated nodes suffers
       // from worse whitespace behavior. Re-adding a node like this triggers
@@ -63,11 +63,14 @@ if (ExecutionEnvironment.canUseDOM) {
       // thin air on IE8, this only happens if there is no visible text
       // in-front of the non-visible tags. Piggyback on the whitespace fix
       // and simply check if any non-visible tags appear in the source.
-      if (WHITESPACE_TEST.test(html) ||
-          html[0] === '<' && NONVISIBLE_TEST.test(html)) {
+      if (WHITESPACE_TEST.test(html) || html[0] === '<' && NONVISIBLE_TEST.test(html)) {
         // Recover leading whitespace by temporarily prepending any character.
         // \uFEFF has the potential advantage of being zero-width/invisible.
-        node.innerHTML = '\uFEFF' + html;
+        // UglifyJS drops U+FEFF chars when parsing, so use String.fromCharCode
+        // in hopes that this is preserved even if "\uFEFF" is transformed to
+        // the actual Unicode character (by Babel, for example).
+        // https://github.com/mishoo/UglifyJS2/blob/v2.4.20/lib/parse.js#L216
+        node.innerHTML = String.fromCharCode(0xFEFF) + html;
 
         // deleteData leaves an empty `TextNode` which offsets the index of all
         // children. Definitely want to avoid this.
@@ -84,4 +87,4 @@ if (ExecutionEnvironment.canUseDOM) {
   }
 }
 
-module.exports = setInnerHTML;
+module.exports = setInnerHTML;

package/lib/setTextContent.js

@@ -25,16 +25,16 @@ var setInnerHTML = require("./setInnerHTML");
  * @param {string} text
  * @internal
  */
-var setTextContent = function(node, text) {
+var setTextContent = function (node, text) {
   node.textContent = text;
 };
 
 if (ExecutionEnvironment.canUseDOM) {
   if (!('textContent' in document.documentElement)) {
-    setTextContent = function(node, text) {
+    setTextContent = function (node, text) {
       setInnerHTML(node, escapeTextContentForBrowser(text));
     };
   }
 }
 
-module.exports = setTextContent;
+module.exports = setTextContent;

package/lib/shallowCompare.js

@@ -0,0 +1,24 @@
+/**
+ * Copyright 2013-2015, 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 shallowCompare
+*/
+
+'use strict';
+
+var shallowEqual = require("./shallowEqual");
+
+/**
+ * Does a shallow comparison for props and state.
+ * See ReactComponentWithPureRenderMixin
+ */
+function shallowCompare(instance, nextProps, nextState) {
+  return !shallowEqual(instance.props, nextProps) || !shallowEqual(instance.state, nextState);
+}
+
+module.exports = shallowCompare;

package/lib/shallowEqual.js

@@ -22,21 +22,27 @@ function shallowEqual(objA, objB) {
   if (objA === objB) {
     return true;
   }
-  var key;
-  // Test for A's keys different from B.
-  for (key in objA) {
-    if (objA.hasOwnProperty(key) &&
-        (!objB.hasOwnProperty(key) || objA[key] !== objB[key])) {
-      return false;
-    }
+
+  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+    return false;
+  }
+
+  var keysA = Object.keys(objA);
+  var keysB = Object.keys(objB);
+
+  if (keysA.length !== keysB.length) {
+    return false;
   }
-  // Test for B's keys missing from A.
-  for (key in objB) {
-    if (objB.hasOwnProperty(key) && !objA.hasOwnProperty(key)) {
+
+  // Test for A's keys different from B.
+  var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
+  for (var i = 0; i < keysA.length; i++) {
+    if (!bHasOwnProperty(keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) {
       return false;
     }
   }
+
   return true;
 }
 
-module.exports = shallowEqual;
+module.exports = shallowEqual;

package/lib/shouldUpdateReactComponent.js

@@ -12,8 +12,6 @@
 
 'use strict';
 
-var warning = require("./warning");
-
 /**
  * Given a `prevElement` and `nextElement`, determines if the existing
  * instance should be updated as opposed to being destroyed or replaced by a new
@@ -30,71 +28,12 @@ function shouldUpdateReactComponent(prevElement, nextElement) {
     var prevType = typeof prevElement;
     var nextType = typeof nextElement;
     if (prevType === 'string' || prevType === 'number') {
-      return (nextType === 'string' || nextType === 'number');
+      return nextType === 'string' || nextType === 'number';
     } else {
-      if (nextType === 'object' &&
-          prevElement.type === nextElement.type &&
-          prevElement.key === nextElement.key) {
-        var ownersMatch = prevElement._owner === nextElement._owner;
-        var prevName = null;
-        var nextName = null;
-        var nextDisplayName = null;
-        if ("production" !== process.env.NODE_ENV) {
-          if (!ownersMatch) {
-            if (prevElement._owner != null &&
-                prevElement._owner.getPublicInstance() != null &&
-                prevElement._owner.getPublicInstance().constructor != null) {
-              prevName =
-                prevElement._owner.getPublicInstance().constructor.displayName;
-            }
-            if (nextElement._owner != null &&
-                nextElement._owner.getPublicInstance() != null &&
-                nextElement._owner.getPublicInstance().constructor != null) {
-              nextName =
-                nextElement._owner.getPublicInstance().constructor.displayName;
-            }
-            if (nextElement.type != null &&
-                nextElement.type.displayName != null) {
-              nextDisplayName = nextElement.type.displayName;
-            }
-            if (nextElement.type != null && typeof nextElement.type === 'string') {
-              nextDisplayName = nextElement.type;
-            }
-            if (typeof nextElement.type !== 'string' ||
-                nextElement.type === 'input' ||
-                nextElement.type === 'textarea') {
-              if ((prevElement._owner != null &&
-                  prevElement._owner._isOwnerNecessary === false) ||
-                  (nextElement._owner != null &&
-                  nextElement._owner._isOwnerNecessary === false)) {
-                if (prevElement._owner != null) {
-                  prevElement._owner._isOwnerNecessary = true;
-                }
-                if (nextElement._owner != null) {
-                  nextElement._owner._isOwnerNecessary = true;
-                }
-                ("production" !== process.env.NODE_ENV ? warning(
-                  false,
-                  '<%s /> is being rendered by both %s and %s using the same ' +
-                  'key (%s) in the same place. Currently, this means that ' +
-                  'they don\'t preserve state. This behavior should be very ' +
-                  'rare so we\'re considering deprecating it. Please contact ' +
-                  'the React team and explain your use case so that we can ' +
-                  'take that into consideration.',
-                  nextDisplayName || 'Unknown Component',
-                  prevName || '[Unknown]',
-                  nextName || '[Unknown]',
-                  prevElement.key
-                ) : null);
-              }
-            }
-          }
-        }
-        return ownersMatch;
-      }
+      return nextType === 'object' && prevElement.type === nextElement.type && prevElement.key === nextElement.key;
     }
   }
   return false;
 }
 
-module.exports = shouldUpdateReactComponent;
+module.exports = shouldUpdateReactComponent;