react 0.14.0-alpha2 → 0.14.0-beta3

package/lib/instantiateReactComponent.js

@@ -12,13 +12,13 @@
 
 'use strict';
 
-var ReactCompositeComponent = require("./ReactCompositeComponent");
-var ReactEmptyComponent = require("./ReactEmptyComponent");
-var ReactNativeComponent = require("./ReactNativeComponent");
+var ReactCompositeComponent = require('./ReactCompositeComponent');
+var ReactEmptyComponent = require('./ReactEmptyComponent');
+var ReactNativeComponent = require('./ReactNativeComponent');
 
-var assign = require("./Object.assign");
-var invariant = require("./invariant");
-var warning = require("./warning");
+var assign = require('./Object.assign');
+var invariant = require('fbjs/lib/invariant');
+var warning = require('fbjs/lib/warning');
 
 // To avoid a cyclic dependency, we create the final class in this module
 var ReactCompositeComponentWrapper = function () {};
@@ -26,6 +26,16 @@ assign(ReactCompositeComponentWrapper.prototype, ReactCompositeComponent.Mixin,
   _instantiateReactComponent: instantiateReactComponent
 });
 
+function getDeclarationErrorAddendum(owner) {
+  if (owner) {
+    var name = owner.getName();
+    if (name) {
+      return ' Check the render method of `' + name + '`.';
+    }
+  }
+  return '';
+}
+
 /**
  * Check if the type reference is a known internal type. I.e. not a user
  * provided composite type.
@@ -41,11 +51,10 @@ function isInternalComponentType(type) {
  * Given a ReactNode, create an instance that will actually be mounted.
  *
  * @param {ReactNode} node
- * @param {*} parentCompositeType The composite type that resolved this.
  * @return {object} A new instance of the element's constructor.
  * @protected
  */
-function instantiateReactComponent(node, parentCompositeType) {
+function instantiateReactComponent(node) {
   var instance;
 
   if (node === null || node === false) {
@@ -54,16 +63,11 @@ function instantiateReactComponent(node, parentCompositeType) {
 
   if (typeof node === 'object') {
     var element = node;
-    if ('production' !== process.env.NODE_ENV) {
-      'production' !== process.env.NODE_ENV ? warning(element && (typeof element.type === 'function' || typeof element.type === 'string'), 'Only functions or strings can be mounted as React components.') : null;
-    }
+    !(element && (typeof element.type === 'function' || typeof element.type === 'string')) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Element type is invalid: expected a string (for built-in components) ' + 'or a class/function (for composite components) but got: %s.%s', element.type == null ? element.type : typeof element.type, getDeclarationErrorAddendum(element._owner)) : invariant(false) : undefined;
 
     // Special case string values
-    if (parentCompositeType === element.type && typeof element.type === 'string') {
-      // Avoid recursion if the wrapper renders itself.
+    if (typeof element.type === 'string') {
       instance = ReactNativeComponent.createInternalComponent(element);
-      // All native components are currently wrapped in a composite so we're
-      // safe to assume that this is what we should instantiate.
     } else if (isInternalComponentType(element.type)) {
       // This is temporarily available for custom components that are not string
       // represenations. I.e. ART. Once those are updated to use the string
@@ -75,11 +79,11 @@ function instantiateReactComponent(node, parentCompositeType) {
   } else if (typeof node === 'string' || typeof node === 'number') {
     instance = ReactNativeComponent.createInstanceForText(node);
   } else {
-    'production' !== process.env.NODE_ENV ? invariant(false, 'Encountered invalid React node of type %s', typeof node) : invariant(false);
+    !false ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Encountered invalid React node of type %s', typeof node) : invariant(false) : undefined;
   }
 
-  if ('production' !== process.env.NODE_ENV) {
-    'production' !== process.env.NODE_ENV ? warning(typeof instance.construct === 'function' && typeof instance.mountComponent === 'function' && typeof instance.receiveComponent === 'function' && typeof instance.unmountComponent === 'function', 'Only React Components can be mounted.') : null;
+  if (process.env.NODE_ENV !== 'production') {
+    process.env.NODE_ENV !== 'production' ? warning(typeof instance.construct === 'function' && typeof instance.mountComponent === 'function' && typeof instance.receiveComponent === 'function' && typeof instance.unmountComponent === 'function', 'Only React Components can be mounted.') : undefined;
   }
 
   // Sets up the instance. This can probably just move into the constructor now.
@@ -91,14 +95,14 @@ function instantiateReactComponent(node, parentCompositeType) {
   instance._mountIndex = 0;
   instance._mountImage = null;
 
-  if ('production' !== process.env.NODE_ENV) {
+  if (process.env.NODE_ENV !== 'production') {
     instance._isOwnerNecessary = false;
     instance._warnedAboutRefsInRender = false;
   }
 
   // Internal instances should fully constructed at this point, so they should
   // not get any new fields added to them at this point.
-  if ('production' !== process.env.NODE_ENV) {
+  if (process.env.NODE_ENV !== 'production') {
     if (Object.preventExtensions) {
       Object.preventExtensions(instance);
     }

package/lib/isEventSupported.js

@@ -11,7 +11,7 @@
 
 'use strict';
 
-var ExecutionEnvironment = require("./ExecutionEnvironment");
+var ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');
 
 var useHasFeature;
 if (ExecutionEnvironment.canUseDOM) {

package/lib/isTextInputElement.js

@@ -33,7 +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;

package/lib/joinClasses.js

@@ -16,7 +16,7 @@
  * Combines multiple className strings into one.
  * http://jsperf.com/joinclasses-args-vs-array
  *
- * @param {...?string} classes
+ * @param {...?string} className
  * @return {string}
  */
 function joinClasses(className /*, ... */) {

package/lib/onlyChild.js

@@ -10,9 +10,9 @@
  */
 'use strict';
 
-var ReactElement = require("./ReactElement");
+var ReactElement = require('./ReactElement');
 
-var invariant = require("./invariant");
+var invariant = require('fbjs/lib/invariant');
 
 /**
  * Returns the first child in a collection of children and verifies that there
@@ -26,7 +26,7 @@ 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) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'onlyChild must be passed a children with exactly one child.') : invariant(false) : undefined;
   return children;
 }
 

package/lib/quoteAttributeValueForBrowser.js

@@ -11,7 +11,7 @@
 
 'use strict';
 
-var escapeTextContentForBrowser = require("./escapeTextContentForBrowser");
+var escapeTextContentForBrowser = require('./escapeTextContentForBrowser');
 
 /**
  * Escapes attribute value to prevent scripting attacks.

package/lib/reactComponentExpect.js

@@ -0,0 +1,210 @@
+/**
+ * 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 reactComponentExpect
+ * @nolint
+ */
+
+'use strict';
+
+var ReactInstanceMap = require('./ReactInstanceMap');
+var ReactTestUtils = require('./ReactTestUtils');
+
+var assign = require('./Object.assign');
+var invariant = require('fbjs/lib/invariant');
+
+function reactComponentExpect(instance) {
+  if (instance instanceof reactComponentExpectInternal) {
+    return instance;
+  }
+
+  if (!(this instanceof reactComponentExpect)) {
+    return new reactComponentExpect(instance);
+  }
+
+  expect(instance).not.toBeNull();
+
+  !ReactTestUtils.isCompositeComponent(instance) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'reactComponentExpect(...): instance must be a composite component') : invariant(false) : undefined;
+  var internalInstance = ReactInstanceMap.get(instance);
+
+  expect(typeof internalInstance).toBe('object');
+  expect(typeof internalInstance.constructor).toBe('function');
+  expect(ReactTestUtils.isElement(internalInstance)).toBe(false);
+
+  return new reactComponentExpectInternal(internalInstance);
+}
+
+function reactComponentExpectInternal(internalInstance) {
+  this._instance = internalInstance;
+}
+
+assign(reactComponentExpectInternal.prototype, {
+  // Getters -------------------------------------------------------------------
+
+  /**
+   * @instance: Retrieves the backing instance.
+   */
+  instance: function () {
+    return this._instance.getPublicInstance();
+  },
+
+  /**
+   * There are two types of components in the world.
+   * - A component created via React.createClass() - Has a single child
+   *   subComponent - the return value from the .render() function. This
+   *   function @subComponent expects that this._instance is component created
+   *   with React.createClass().
+   * - A primitive DOM component - which has many renderedChildren, each of
+   *   which may have a name that is unique with respect to its siblings. This
+   *   method will fail if this._instance is a primitive component.
+   *
+   * TL;DR: An instance may have a subComponent (this._renderedComponent) or
+   * renderedChildren, but never both. Neither will actually show up until you
+   * render the component (simply instantiating is not enough).
+   */
+  expectRenderedChild: function () {
+    this.toBeCompositeComponent();
+    var child = this._instance._renderedComponent;
+    // TODO: Hide ReactEmptyComponent instances here?
+    return new reactComponentExpectInternal(child);
+  },
+
+  /**
+   * The nth child of a DOMish component instance that is not falsy.
+   */
+  expectRenderedChildAt: function (childIndex) {
+    // Currently only dom components have arrays of children, but that will
+    // change soon.
+    this.toBeDOMComponent();
+    var renderedChildren = this._instance._renderedChildren || {};
+    for (var name in renderedChildren) {
+      if (!renderedChildren.hasOwnProperty(name)) {
+        continue;
+      }
+      if (renderedChildren[name]) {
+        if (renderedChildren[name]._mountIndex === childIndex) {
+          return new reactComponentExpectInternal(renderedChildren[name]);
+        }
+      }
+    }
+    throw new Error('Child:' + childIndex + ' is not found');
+  },
+
+  toBeDOMComponentWithChildCount: function (count) {
+    this.toBeDOMComponent();
+    var renderedChildren = this._instance._renderedChildren;
+    expect(renderedChildren).toBeTruthy();
+    expect(Object.keys(renderedChildren).length).toBe(count);
+    return this;
+  },
+
+  toBeDOMComponentWithNoChildren: function () {
+    this.toBeDOMComponent();
+    expect(this._instance._renderedChildren).toBeFalsy();
+    return this;
+  },
+
+  // Matchers ------------------------------------------------------------------
+
+  toBeComponentOfType: function (constructor) {
+    expect(this._instance._currentElement.type === constructor).toBe(true);
+    return this;
+  },
+
+  /**
+   * A component that is created with React.createClass. Just duck typing
+   * here.
+   */
+  toBeCompositeComponent: function () {
+    expect(typeof this.instance() === 'object' && typeof this.instance().render === 'function').toBe(true);
+    return this;
+  },
+
+  toBeCompositeComponentWithType: function (constructor) {
+    this.toBeCompositeComponent();
+    expect(this._instance._currentElement.type === constructor).toBe(true);
+    return this;
+  },
+
+  toBeTextComponentWithValue: function (val) {
+    var elementType = typeof this._instance._currentElement;
+    expect(elementType === 'string' || elementType === 'number').toBe(true);
+    expect(this._instance._stringText).toBe(val);
+    return this;
+  },
+
+  toBePresent: function () {
+    expect(this.instance()).toBeTruthy();
+    return this;
+  },
+
+  /**
+   * A terminal type of component representing some virtual dom node. Just duck
+   * typing here.
+   */
+  toBeDOMComponent: function () {
+    expect(ReactTestUtils.isDOMComponent(this.instance())).toBe(true);
+    return this;
+  },
+
+  /**
+   * @deprecated
+   * @see toBeComponentOfType
+   */
+  toBeDOMComponentWithTag: function (tag) {
+    this.toBeDOMComponent();
+    expect(this.instance().tagName).toBe(tag.toUpperCase());
+    return this;
+  },
+
+  /**
+   * Check that internal state values are equal to a state of expected values.
+   */
+  scalarStateEqual: function (stateNameToExpectedValue) {
+    expect(this.instance()).toBeTruthy();
+    for (var stateName in stateNameToExpectedValue) {
+      if (!stateNameToExpectedValue.hasOwnProperty(stateName)) {
+        continue;
+      }
+      expect(this.instance().state[stateName]).toEqual(stateNameToExpectedValue[stateName]);
+    }
+    return this;
+  },
+
+  /**
+   * Check a set of props are equal to a set of expected values - only works
+   * with scalars.
+   */
+  scalarPropsEqual: function (propNameToExpectedValue) {
+    expect(this.instance()).toBeTruthy();
+    for (var propName in propNameToExpectedValue) {
+      if (!propNameToExpectedValue.hasOwnProperty(propName)) {
+        continue;
+      }
+      expect(this.instance().props[propName]).toEqual(propNameToExpectedValue[propName]);
+    }
+    return this;
+  },
+
+  /**
+   * Check a set of props are equal to a set of expected values - only works
+   * with scalars.
+   */
+  scalarContextEqual: function (contextNameToExpectedValue) {
+    expect(this.instance()).toBeTruthy();
+    for (var contextName in contextNameToExpectedValue) {
+      if (!contextNameToExpectedValue.hasOwnProperty(contextName)) {
+        continue;
+      }
+      expect(this.instance().context[contextName]).toEqual(contextNameToExpectedValue[contextName]);
+    }
+    return this;
+  }
+});
+
+module.exports = reactComponentExpect;

package/lib/renderSubtreeIntoContainer.js

@@ -11,6 +11,6 @@
 
 'use strict';
 
-var ReactMount = require("./ReactMount");
+var ReactMount = require('./ReactMount');
 
 module.exports = ReactMount.renderSubtreeIntoContainer;

package/lib/setInnerHTML.js

@@ -13,7 +13,7 @@
 
 'use strict';
 
-var ExecutionEnvironment = require("./ExecutionEnvironment");
+var ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');
 
 var WHITESPACE_TEST = /^[ \r\n\t\f]/;
 var NONVISIBLE_TEST = /<(!--|link|noscript|meta|script|style)[ \r\n\t\f\/>]/;
@@ -70,7 +70,7 @@ if (ExecutionEnvironment.canUseDOM) {
         // 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(65279) + html;
+        node.innerHTML = String.fromCharCode(0xFEFF) + html;
 
         // deleteData leaves an empty `TextNode` which offsets the index of all
         // children. Definitely want to avoid this.

package/lib/setTextContent.js

@@ -11,9 +11,9 @@
 
 'use strict';
 
-var ExecutionEnvironment = require("./ExecutionEnvironment");
-var escapeTextContentForBrowser = require("./escapeTextContentForBrowser");
-var setInnerHTML = require("./setInnerHTML");
+var ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');
+var escapeTextContentForBrowser = require('./escapeTextContentForBrowser');
+var setInnerHTML = require('./setInnerHTML');
 
 /**
  * Set the textContent property of a node, ensuring that whitespace is preserved

package/lib/shallowCompare.js

@@ -11,7 +11,7 @@
 
 'use strict';
 
-var shallowEqual = require("./shallowEqual");
+var shallowEqual = require('fbjs/lib/shallowEqual');
 
 /**
  * Does a shallow comparison for props and state.

package/lib/sliceChildren.js

@@ -0,0 +1,51 @@
+/**
+ * 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 sliceChildren
+ */
+
+'use strict';
+
+var ReactFragment = require('./ReactFragment');
+
+var flattenChildren = require('./flattenChildren');
+
+/**
+ * Slice children that are typically specified as `props.children`. This version
+ * of slice children ignores empty child components.
+ *
+ * @param {*} children The children set to filter.
+ * @param {number} start The first zero-based index to include in the subset.
+ * @param {?number} end The non-inclusive last index of the subset.
+ * @return {object} mirrored array with mapped children
+ */
+function sliceChildren(children, start, end) {
+  if (children == null) {
+    return children;
+  }
+
+  var slicedChildren = {};
+  var flattenedMap = flattenChildren(children);
+  var ii = 0;
+  for (var key in flattenedMap) {
+    if (!flattenedMap.hasOwnProperty(key)) {
+      continue;
+    }
+    var child = flattenedMap[key];
+    if (ii >= start) {
+      slicedChildren[key] = child;
+    }
+    ii++;
+    if (end != null && ii >= end) {
+      break;
+    }
+  }
+  return ReactFragment.create(slicedChildren);
+}
+
+module.exports = sliceChildren;