Format docs content

Author: markerikson

docs/api/Provider.md

@@ -25,56 +25,54 @@ The single Redux `store` in your application.
 `children` (ReactElement)
 The root of your component hierarchy.
 
-
 ### Example Usage
 
 In the example below, the `<App />` component is our root-level component. This means it’s at the very top of our component hierarchy.
 
 **Vanilla React Example**
 
 ```jsx
-    import React from 'react';
-    import ReactDOM from 'react-dom';
-    import { Provider } from 'react-redux';
-
-    import { App } from './App';
-    import createStore from './createReduxStore';
+import React from 'react'
+import ReactDOM from 'react-dom'
+import { Provider } from 'react-redux'
 
-    const store = createStore();
+import { App } from './App'
+import createStore from './createReduxStore'
 
-    ReactDOM.render(
-      <Provider store={store}>
-        <App />
-      </Provider>,
-      document.getElementById('root')
-    )
-```    
+const store = createStore()
 
+ReactDOM.render(
+  <Provider store={store}>
+    <App />
+  </Provider>,
+  document.getElementById('root')
+)
+```
 
 **Usage with React Router**
 
 ```jsx
-    import React from 'react';
-    import ReactDOM from 'react-dom';
-    import { Provider } from 'react-redux';
-    import { Router, Route } from 'react-router-dom';
-
-    import { App } from './App';
-    import { Foo } from './Foo';
-    import { Bar } from './Bar';
-    import createStore from './createReduxStore';
-
-    const store = createStore();
-
-    ReactDOM.render(
-      <Provider store={store}>
-        <Router history={history}>
-          <Route path="/" component={App}>
-            <Route path="foo" component={Foo}/>
-            <Route path="bar" component={Bar}/>
-          </Route>
-        </Router>
-      </Provider>,
-      document.getElementById('root')
-    )
-```    
+import React from 'react'
+import ReactDOM from 'react-dom'
+import { Provider } from 'react-redux'
+import { Router, Route } from 'react-router-dom'
+
+import { App } from './App'
+import { Foo } from './Foo'
+import { Bar } from './Bar'
+import createStore from './createReduxStore'
+
+const store = createStore()
+
+ReactDOM.render(
+  <Provider store={store}>
+    <Router history={history}>
+      <Route path="/" component={App}>
+        <Route path="foo" component={Foo} />
+        <Route path="bar" component={Bar} />
+      </Route>
+    </Router>
+  </Provider>,
+  document.getElementById('root')
+)
+```

docs/api/connect-advanced.md

@@ -13,29 +13,29 @@ connectAdvanced(selectorFactory, connectOptions?)
 
 Connects a React component to a Redux store. It is the base for `connect()` but is less opinionated about how to combine `state`, `props`, and `dispatch` into your final props. It makes no assumptions about defaults or memoization of results, leaving those responsibilities to the caller.
 
-It does not modify the component class passed to it; instead, it *returns* a new, connected component class for you to use.
+It does not modify the component class passed to it; instead, it _returns_ a new, connected component class for you to use.
 
 Most applications will not need to use this, as the default behavior in `connect` is intended to work for most use cases.
 
-> Note: `connectAdvanced` was added in version 5.0, and `connect` was reimplemented as a specific set of parameters to `connectAdvanced`.  
+> Note: `connectAdvanced` was added in version 5.0, and `connect` was reimplemented as a specific set of parameters to `connectAdvanced`.
 
 ## Arguments
 
-* `selectorFactory(dispatch, factoryOptions): selector(state, ownProps): props` \(*Function*): Initializes a selector function (during each instance's constructor). That selector function is called any time the connector component needs to compute new props, as a result of a store state change or receiving new props. The result of `selector` is expected to be a plain object, which is passed as the props to the wrapped component. If a consecutive call to `selector` returns the same object (`===`) as its previous call, the component will not be re-rendered. It's the responsibility of `selector` to return that previous object when appropriate.
+- `selectorFactory(dispatch, factoryOptions): selector(state, ownProps): props` \(_Function_): Initializes a selector function (during each instance's constructor). That selector function is called any time the connector component needs to compute new props, as a result of a store state change or receiving new props. The result of `selector` is expected to be a plain object, which is passed as the props to the wrapped component. If a consecutive call to `selector` returns the same object (`===`) as its previous call, the component will not be re-rendered. It's the responsibility of `selector` to return that previous object when appropriate.
 
-* [`connectOptions`] *(Object)* If specified, further customizes the behavior of the connector.
+- [`connectOptions`] _(Object)_ If specified, further customizes the behavior of the connector.
 
-  * [`getDisplayName`] *(Function)*: computes the connector component's displayName property relative to that of the wrapped component. Usually overridden by wrapper functions. Default value: `name => 'ConnectAdvanced('+name+')'`
+  - [`getDisplayName`] _(Function)_: computes the connector component's displayName property relative to that of the wrapped component. Usually overridden by wrapper functions. Default value: `name => 'ConnectAdvanced('+name+')'`
 
-  * [`methodName`] *(String)*: shown in error messages. Usually overridden by wrapper functions. Default value: `'connectAdvanced'`
+  - [`methodName`] _(String)_: shown in error messages. Usually overridden by wrapper functions. Default value: `'connectAdvanced'`
 
-  * [`renderCountProp`] *(String)*: if defined, a property named this value will be added to the props passed to the wrapped component. Its value will be the number of times the component has been rendered, which can be useful for tracking down unnecessary re-renders. Default value: `undefined`
+  - [`renderCountProp`] _(String)_: if defined, a property named this value will be added to the props passed to the wrapped component. Its value will be the number of times the component has been rendered, which can be useful for tracking down unnecessary re-renders. Default value: `undefined`
 
-  * [`shouldHandleStateChanges`] *(Boolean)*: controls whether the connector component subscribes to redux store state changes. If set to false, it will only re-render when parent component re-renders. Default value:  `true`
+  - [`shouldHandleStateChanges`] _(Boolean)_: controls whether the connector component subscribes to redux store state changes. If set to false, it will only re-render when parent component re-renders. Default value: `true`
 
-  * [`forwardRef`] *(Boolean)*: If true, adding a ref to the connected wrapper component will actually return the instance of the wrapped component.
+  - [`forwardRef`] _(Boolean)_: If true, adding a ref to the connected wrapper component will actually return the instance of the wrapped component.
 
-  * Additionally, any extra options passed via `connectOptions` will be passed through to your `selectorFactory` in the `factoryOptions` argument.
+  - Additionally, any extra options passed via `connectOptions` will be passed through to your `selectorFactory` in the `factoryOptions` argument.
 
 <a id="connectAdvanced-returns"></a>
 
@@ -45,21 +45,20 @@ A higher-order React component class that builds props from the store state and
 
 ### Static Properties
 
-* `WrappedComponent` *(Component)*: The original component class passed to `connectAdvanced(...)(Component)`.
+- `WrappedComponent` _(Component)_: The original component class passed to `connectAdvanced(...)(Component)`.
 
 ### Static Methods
 
 All the original static methods of the component are hoisted.
 
-
-
 ## Remarks
 
-* Since `connectAdvanced` returns a higher-order component, it needs to be invoked two times. The first time with its arguments as described above, and a second time, with the component: `connectAdvanced(selectorFactory)(MyComponent)`.
+- Since `connectAdvanced` returns a higher-order component, it needs to be invoked two times. The first time with its arguments as described above, and a second time, with the component: `connectAdvanced(selectorFactory)(MyComponent)`.
 
-* `connectAdvanced` does not modify the passed React component. It returns a new, connected component, that you should use instead.
+- `connectAdvanced` does not modify the passed React component. It returns a new, connected component, that you should use instead.
 
 <a id="connectAdvanced-examples"></a>
+
 ### Examples
 
 ### Inject `todos` of a specific user depending on props, and inject `props.userId` into the action
@@ -71,10 +70,10 @@ import { bindActionCreators } from 'redux'
 function selectorFactory(dispatch) {
   let ownProps = {}
   let result = {}
-  
+
   const actions = bindActionCreators(actionCreators, dispatch)
-  const addTodo = (text) => actions.addTodo(ownProps.userId, text)
-  
+  const addTodo = text => actions.addTodo(ownProps.userId, text)
+
   return (nextState, nextOwnProps) => {
     const todos = nextState.todos[nextOwnProps.userId]
     const nextResult = { ...nextOwnProps, todos, addTodo }
@@ -85,4 +84,3 @@ function selectorFactory(dispatch) {
 }
 export default connectAdvanced(selectorFactory)(TodoApp)
 ```
-