diff --git a/docs/docs/08-working-with-the-browser.md b/docs/docs/08-working-with-the-browser.md
index aec2aaa270..4e2c7ff909 100644
--- a/docs/docs/08-working-with-the-browser.md
+++ b/docs/docs/08-working-with-the-browser.md
@@ -56,10 +56,9 @@ React provides lifecycle methods that you can specify to hook into this process.
### Mounted Methods
-_Mounted_ composite components also support the following methods:
+_Mounted_ composite components also support the following method:
-* `findDOMNode(): DOMElement` can be invoked on any mounted component in order to obtain a reference to its rendered DOM node.
-* `forceUpdate()` can be invoked on any mounted component when you know that some deeper aspect of the component's state has changed without using `this.setState()`.
+* `component.forceUpdate()` can be invoked on any mounted component when you know that some deeper aspect of the component's state has changed without using `this.setState()`.
## Browser Support and Polyfills
diff --git a/docs/docs/08.1-more-about-refs.md b/docs/docs/08.1-more-about-refs.md
index 8eefaab1c8..f1ae11f92a 100644
--- a/docs/docs/08.1-more-about-refs.md
+++ b/docs/docs/08.1-more-about-refs.md
@@ -63,9 +63,9 @@ or using an ES6 arrow function:
},
```
-Note that when the referenced component is unmounted and whenever the ref changes, the old ref will be called with `null` as an argument. This prevents memory leaks in the case that the instance is stored, as in the first example. Also note that when writing refs with inline function expressions as in the examples here, React sees a different function object each time so on every update, ref will be called with `null` immediately before it's called with the component instance.
+When attaching a ref to a DOM component like `
`, you get the DOM node back; when attaching a ref to a composite component like ``, you'll get the React class instance. In the latter case, you can call methods on that component if any are exposed in its class definition.
-You can access the component's DOM node directly by calling `ReactDOM.findDOMNode(argumentToYourCallback)`.
+Note that when the referenced component is unmounted and whenever the ref changes, the old ref will be called with `null` as an argument. This prevents memory leaks in the case that the instance is stored, as in the first example. Also note that when writing refs with inline function expressions as in the examples here, React sees a different function object each time so on every update, ref will be called with `null` immediately before it's called with the component instance.
## The ref String Attribute
@@ -81,11 +81,11 @@ React also supports using a string (instead of a callback) as a ref prop on any
2. In some other code (typically event handler code), access the **backing instance** via `this.refs` as in:
```javascript
- this.refs.myInput
+ var input = this.refs.myInput;
+ var inputValue = input.value;
+ var inputRect = input.getBoundingClientRect();
```
- You can access the component's DOM node directly by calling `ReactDOM.findDOMNode(this.refs.myInput)`.
-
## A Complete Example
In order to get a reference to a React component, you can either use `this` to get the current React component, or you can use a ref to get a reference to a component you own. They work like this:
@@ -120,7 +120,7 @@ ReactDOM.render(
In this example, we get a reference to the text input **backing instance** and we call `focus()` when the button is clicked.
-For composite components, the reference will refer to an instance of the component class so you can invoke any methods that are defined on that class. If you need access to the underlying DOM node for that component, you can use [ReactDOM.findDOMNode](/react/docs/top-level-api.html#reactdom.finddomnode).
+For composite components, the reference will refer to an instance of the component class so you can invoke any methods that are defined on that class. If you need access to the underlying DOM node for that component, you can use [ReactDOM.findDOMNode](/react/docs/top-level-api.html#reactdom.finddomnode) as an "escape hatch" but we don't recommend it since it breaks encapsulation and in almost every case there's a clearer way to structure your code within the React model.
## Summary
@@ -128,13 +128,13 @@ Refs are a great way to send a message to a particular child instance in a way t
### Benefits:
-- You can define any public method on your component classes (such as a reset method on a Typeahead) and call those public methods through refs (such as `this.refs.myTypeahead.reset()`).
-- Performing DOM measurements almost always requires reaching out to a "native" component such as `` and accessing its underlying DOM node via `ReactDOM.findDOMNode(this.refs.myInput)`. Refs are one of the only practical ways of doing this reliably.
+- You can define any public method on your component classes (such as a reset method on a Typeahead) and call those public methods through refs (such as `this.refs.myTypeahead.reset()`). In most cases, it's clearer to use the built-in React data flow instead of using refs imperatively.
+- Performing DOM measurements almost always requires reaching out to a "native" component such as `` and accessing its underlying DOM node using a ref. Refs are one of the only practical ways of doing this reliably.
- Refs are automatically managed for you! If that child is destroyed, its ref is also destroyed for you. No worrying about memory here (unless you do something crazy to retain a reference yourself).
### Cautions:
- *Never* access refs inside of any component's render method - or while any component's render method is even running anywhere in the call stack.
-- If you want to preserve Google Closure Compiler Crushing resilience, make sure to never access as a property what was specified as a string. This means you must access using `this.refs['myRefString']` if your ref was defined as `ref="myRefString"`.
+- If you want to preserve Google Closure Compiler advanced-mode crushing resilience, make sure to never access as a property what was specified as a string. This means you must access using `this.refs['myRefString']` if your ref was defined as `ref="myRefString"`.
- If you have not programmed several apps with React, your first inclination is usually going to be to try to use refs to "make things happen" in your app. If this is the case, take a moment and think more critically about where `state` should be owned in the component hierarchy. Often, it becomes clear that the proper place to "own" that state is at a higher level in the hierarchy. Placing the state there often eliminates any desire to use `ref`s to "make things happen" – instead, the data flow will usually accomplish your goal.
- Refs may not be attached to a [stateless function](/react/docs/reusable-components.html#stateless-functions), because the component does not have a backing instance. You can always wrap a stateless component in a standard composite component and attach a ref to the composite component.
diff --git a/docs/docs/10-addons.md b/docs/docs/10-addons.md
index d076bd122b..a0a5cc5063 100644
--- a/docs/docs/10-addons.md
+++ b/docs/docs/10-addons.md
@@ -6,7 +6,7 @@ prev: tooling-integration.html
next: animation.html
---
-`React.addons` is where we park some useful utilities for building React apps. **These should be considered experimental** but will eventually be rolled into core or a blessed utilities library:
+The React add-ons are a collection of useful utility modules for building React apps. **These should be considered experimental** and tend to change more often than the core.
- [`TransitionGroup` and `CSSTransitionGroup`](animation.html), for dealing with animations and transitions that are usually not simple to implement, such as before a component's removal.
- [`LinkedStateMixin`](two-way-binding-helpers.html), to simplify the coordination between user's form input data and the component's state.
@@ -20,6 +20,4 @@ The add-ons below are in the development (unminified) version of React only:
- [`TestUtils`](test-utils.html), simple helpers for writing test cases (unminified build only).
- [`Perf`](perf.html), for measuring performance and giving you hint where to optimize.
-To get the add-ons, use `react-with-addons.js` (and its minified counterpart) rather than the common `react.js`.
-
-When using the react package from npm, simply `require('react/addons')` instead of `require('react')` to get React with all of the add-ons.
+To get the add-ons, install them individually from npm (e.g., `npm install react-addons-pure-render-mixin`). We don't support using the addons if you're not using npm.
diff --git a/docs/docs/10.1-animation.md b/docs/docs/10.1-animation.md
index bccdcc98f8..5cc1defe88 100644
--- a/docs/docs/10.1-animation.md
+++ b/docs/docs/10.1-animation.md
@@ -17,7 +17,7 @@ React provides a `ReactTransitionGroup` addon component as a low-level API for a
`ReactCSSTransitionGroup` is the interface to `ReactTransitions`. This is a simple element that wraps all of the components you are interested in animating. Here's an example where we fade list items in and out.
```javascript{28-30}
-var ReactCSSTransitionGroup = React.addons.CSSTransitionGroup;
+var ReactCSSTransitionGroup = require('react-addons-css-transition-group');
var TodoList = React.createClass({
getInitialState: function() {
@@ -173,7 +173,7 @@ In order for it to apply transitions to its children, the `ReactCSSTransitionGro
In the example above, we rendered a list of items into `ReactCSSTransitionGroup`. However, the children of `ReactCSSTransitionGroup` can also be one or zero items. This makes it possible to animate a single element entering or leaving. Similarly, you can animate a new element replacing the current element. For example, we can implement a simple image carousel like this:
```javascript{10-12}
-var ReactCSSTransitionGroup = React.addons.CSSTransitionGroup;
+var ReactCSSTransitionGroup = require('react-addons-css-transition-group');
var ImageCarousel = React.createClass({
propTypes: {
@@ -201,7 +201,7 @@ You can disable animating `enter` or `leave` animations if you want. For example
## Low-level API: `ReactTransitionGroup`
-`ReactTransitionGroup` is the basis for animations. It is accessible as `React.addons.TransitionGroup`. When children are declaratively added or removed from it (as in the example above) special lifecycle hooks are called on them.
+`ReactTransitionGroup` is the basis for animations. It is accessible from `require('react-addons-transition-group')`. When children are declaratively added or removed from it (as in the example above) special lifecycle hooks are called on them.
### `componentWillAppear(callback)`
@@ -237,11 +237,7 @@ By default `ReactTransitionGroup` renders as a `span`. You can change this behav
```
-Every DOM component that React can render is available for use. However, `component` does not need to be a DOM component. It can be any React component you want; even ones you've written yourself!
-
-> Note:
->
-> Prior to v0.12, when using DOM components, the `component` prop needed to be a reference to `React.DOM.*`. Since the component is simply passed to `React.createElement`, it must now be a string. Composite components must pass the factory.
+Every DOM component that React can render is available for use. However, `component` does not need to be a DOM component. It can be any React component you want; even ones you've written yourself! Just write `component={List}` and your component will receive `this.props.children`.
Any additional, user-defined, properties will become properties of the rendered component. For example, here's how you would render a `
` with CSS class:
diff --git a/docs/docs/10.2-form-input-binding-sugar.md b/docs/docs/10.2-form-input-binding-sugar.md
index 1ff4995a81..3270b3788b 100644
--- a/docs/docs/10.2-form-input-binding-sugar.md
+++ b/docs/docs/10.2-form-input-binding-sugar.md
@@ -46,8 +46,10 @@ var NoLink = React.createClass({
This works really well and it's very clear how data is flowing, however, with a lot of form fields it could get a bit verbose. Let's use `ReactLink` to save us some typing:
```javascript{2,7}
+var LinkedStateMixin = require('react-addons-linked-state-mixin');
+
var WithLink = React.createClass({
- mixins: [React.addons.LinkedStateMixin],
+ mixins: [LinkedStateMixin],
getInitialState: function() {
return {message: 'Hello!'};
},
@@ -96,8 +98,10 @@ As you can see, `ReactLink` objects are very simple objects that just have a `va
### ReactLink Without valueLink
```javascript
+var LinkedStateMixin = require('react-addons-linked-state-mixin');
+
var WithoutLink = React.createClass({
- mixins: [React.addons.LinkedStateMixin],
+ mixins: [LinkedStateMixin],
getInitialState: function() {
return {message: 'Hello!'};
},
diff --git a/docs/docs/10.3-class-name-manipulation.md b/docs/docs/10.3-class-name-manipulation.md
index d6f28f5aeb..4a3567d410 100644
--- a/docs/docs/10.3-class-name-manipulation.md
+++ b/docs/docs/10.3-class-name-manipulation.md
@@ -8,55 +8,4 @@ next: test-utils.html
> NOTE:
>
-> This module now exists independently at [JedWatson/classnames](https://github.com/JedWatson/classnames) and is React-agnostic. The add-on here will thus be removed in the future.
-
-`classSet()` is a neat utility for easily manipulating the DOM `class` string.
-
-Here's a common scenario and its solution without `classSet()`:
-
-```javascript
-// inside some `` React component
-render: function() {
- var classString = 'message';
- if (this.props.isImportant) {
- classString += ' message-important';
- }
- if (this.props.isRead) {
- classString += ' message-read';
- }
- // 'message message-important message-read'
- return
Great, I'll be there.
;
-}
-```
-
-This can quickly get tedious, as assigning class name strings can be hard to read and error-prone. `classSet()` solves this problem:
-
-```javascript
-render: function() {
- var cx = React.addons.classSet;
- var classes = cx({
- 'message': true,
- 'message-important': this.props.isImportant,
- 'message-read': this.props.isRead
- });
- // same final string, but much cleaner
- return
Great, I'll be there.
;
-}
-```
-
-When using `classSet()`, pass an object with keys of the CSS class names you might or might not need. Truthy values will result in the key being a part of the resulting string.
-
-`classSet()` also lets you pass class names in as arguments that are then concatenated for you:
-
-```javascript
-render: function() {
- var cx = React.addons.classSet;
- var importantModifier = 'message-important';
- var readModifier = 'message-read';
- var classes = cx('message', importantModifier, readModifier);
- // Final string is 'message message-important message-read'
- return
Great, I'll be there.
;
-}
-```
-
-No more hacky string concatenations!
+> This module has been deprecated; use [JedWatson/classnames](https://github.com/JedWatson/classnames) instead.
diff --git a/docs/docs/10.4-test-utils.md b/docs/docs/10.4-test-utils.md
index 24eac44a0a..28bdf5a782 100644
--- a/docs/docs/10.4-test-utils.md
+++ b/docs/docs/10.4-test-utils.md
@@ -6,7 +6,11 @@ prev: two-way-binding-helpers.html
next: clone-with-props.html
---
-`React.addons.TestUtils` makes it easy to test React components in the testing framework of your choice (we use [Jest](https://facebook.github.io/jest/)).
+`ReactTestUtils` makes it easy to test React components in the testing framework of your choice (we use [Jest](https://facebook.github.io/jest/)).
+
+```
+var ReactTestUtils = require('react-addons-test-utils');
+```
### Simulate
@@ -22,17 +26,19 @@ Simulate an event dispatch on a DOM node with optional `eventData` event data. *
**Clicking an element**
```javascript
-var node = ReactDOM.findDOMNode(this.refs.button);
-React.addons.TestUtils.Simulate.click(node);
+//
+var node = this.refs.button;
+ReactTestUtils.Simulate.click(node);
```
**Changing the value of an input field and then pressing ENTER**
```javascript
-var node = ReactDOM.findDOMNode(this.refs.input);
+//
+var node = this.refs.input;
node.value = 'giraffe'
-React.addons.TestUtils.Simulate.change(node);
-React.addons.TestUtils.Simulate.keyDown(node, {key: "Enter", keyCode: 13, which: 13});
+ReactTestUtils.Simulate.change(node);
+ReactTestUtils.Simulate.keyDown(node, {key: "Enter", keyCode: 13, which: 13});
```
*note that you will have to provide any event property that you're using in your component (e.g. keyCode, which, etc...) as React is not creating any of these for you*
diff --git a/docs/docs/10.5-clone-with-props.md b/docs/docs/10.5-clone-with-props.md
index 597b9b78e7..279d04a98d 100644
--- a/docs/docs/10.5-clone-with-props.md
+++ b/docs/docs/10.5-clone-with-props.md
@@ -12,8 +12,10 @@ next: create-fragment.html
In rare situations, you may want to create a copy of a React element with different props from those of the original element. One example is cloning the elements passed into `this.props.children` and rendering them with different props:
```js
+var cloneWithProps = require('react-addons-clone-with-props');
+
var _makeBlue = function(element) {
- return React.addons.cloneWithProps(element, {style: {color: 'blue'}});
+ return cloneWithProps(element, {style: {color: 'blue'}});
};
var Blue = React.createClass({
diff --git a/docs/docs/10.6-create-fragment.md b/docs/docs/10.6-create-fragment.md
index 92c5218cac..91879d4e0f 100644
--- a/docs/docs/10.6-create-fragment.md
+++ b/docs/docs/10.6-create-fragment.md
@@ -33,20 +33,22 @@ var Swapper = React.createClass({
The children will unmount and remount as you change the `swapped` prop because there aren't any keys marked on the two sets of children.
-To solve this problem, you can use `React.addons.createFragment` to give keys to the sets of children.
+To solve this problem, you can use the `createFragment` add-on to give keys to the sets of children.
-#### `ReactFragment React.addons.createFragment(object children)`
+#### `Array createFragment(object children)`
Instead of creating arrays, we write:
```js
+var createFragment = require('react-addons-create-fragment');
+
if (this.props.swapped) {
- children = React.addons.createFragment({
+ children = createFragment({
right: this.props.rightChildren,
left: this.props.leftChildren
});
} else {
- children = React.addons.createFragment({
+ children = createFragment({
left: this.props.leftChildren,
right: this.props.rightChildren
});
diff --git a/docs/docs/10.7-update.md b/docs/docs/10.7-update.md
index 2e25ede11b..8940e8b488 100644
--- a/docs/docs/10.7-update.md
+++ b/docs/docs/10.7-update.md
@@ -44,7 +44,9 @@ While this is fairly performant (since it only makes a shallow copy of `log n` o
`update()` provides simple syntactic sugar around this pattern to make writing this code easier. This code becomes:
```js
-var newData = React.addons.update(myData, {
+var update = require('react-addons-update');
+
+var newData = update(myData, {
x: {y: {z: {$set: 7}}},
a: {b: {$push: [9]}}
});
diff --git a/docs/docs/10.9-perf.md b/docs/docs/10.9-perf.md
index 735aac04a0..f4f658232c 100644
--- a/docs/docs/10.9-perf.md
+++ b/docs/docs/10.9-perf.md
@@ -10,14 +10,14 @@ React is usually quite fast out of the box. However, in situations where you nee
In addition to giving you an overview of your app's overall performance, ReactPerf is a profiling tool that tells you exactly where you need to put these hooks.
+## General API
+
+The `Perf` object documented here is exposed as `require('react-addons-perf')` and can be used with React in development mode only. You should not include this bundle when building your app for production.
+
> Note:
>
> The dev build of React is slower than the prod build, due to all the extra logic for providing, for example, React's friendly console warnings (stripped away in the prod build). Therefore, the profiler only serves to indicate the _relatively_ expensive parts of your app.
-## General API
-
-The `Perf` object documented here is exposed as `React.addons.Perf` when using the `react-with-addons.js` build in development mode.
-
### `Perf.start()` and `Perf.stop()`
Start/stop the measurement. The React operations in-between are recorded for analyses below. Operations that took an insignificant amount of time are ignored.
diff --git a/docs/docs/getting-started.md b/docs/docs/getting-started.md
index 10ed3d2293..4bd3a8f41d 100644
--- a/docs/docs/getting-started.md
+++ b/docs/docs/getting-started.md
@@ -12,9 +12,31 @@ The easiest way to start hacking on React is using the following JSFiddle Hello
* **[React JSFiddle](https://jsfiddle.net/reactjs/69z2wepo/)**
* [React JSFiddle without JSX](https://jsfiddle.net/reactjs/5vjqabv3/)
-## Starter Kit
+## Using React from npm
-Download the starter kit to get started.
+We recommend using React with a CommonJS module system like [browserify](http://browserify.org/) or [webpack](https://webpack.github.io/). Use the [`react`](https://www.npmjs.com/package/react) and [`react-dom`](https://www.npmjs.com/package/react-dom) npm packages.
+
+```js
+// main.js
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+ReactDOM.render(
+
Hello, world!
,
+ document.getElementById('example')
+);
+```
+
+To install React DOM and build your bundle after installing browserify:
+
+```sh
+$ npm install --save react react-dom
+$ browserify -t babelify main.js -o bundle.js
+```
+
+## Quick Start Without npm
+
+If you're not ready to use npm yet, you can download the starter kit which includes prebuilt copies of React and React DOM.