All notable changes to this project will be documented in this file.

This project adheres to [Semantic Versioning](http://semver.org/).

No breaking changes this time.

* Classes returned by decorators now expose a static `DecoratedComponent` property for easier testing

* Dependencies on `lodash` and `babel-runtime` are dropped

* Now compatible with Babel loose mode

* `composeStore` now ignores non-function values (useful in Babel loose mode)

* A UMD build is added

* The initial action dispatched to the stores now has a built-in `@@INIT` type (might be useful to devtools)

* Bugfix: when `Connector` `select` property changes, the state did not recalculate (#107)

* Renames `compose` root export to `composeMiddleware` to clarify the intent

* Fixes a bug with `getState` returning stale state after a hot reload (#90)

Missing from the 0.10 release notes: **React Native is now supported!**

(And that's actually a breaking change.)

Now, to import React-specific parts (containers or decorators), you need to either import from `redux/react` or `redux/react-native`:

import { createRedux, bindActionCreators } from 'redux';

import { provide, Connector } from 'redux/react';

import { provide, Connector } from 'redux/react-native';

0.10 release also had a problem with ES6 code inside `redux/react` and `redux/react-native` entry points, which is now fixed. Please upgrade if you had problems with 0.10.

Changes introduced in 0.10.1:

* `Connector` now throws if `select` returns something other than a plain object (https://github.com/gaearon/redux/pull/85)

* The custom dispatcher API is tweaked so `setState` now returns the state that was actually set. This makes custom dispatchers more composable. (https://github.com/gaearon/redux/pull/77)

Happy reducing!

Redux 1.0 is within striking distance! Can you believe how quickly Redux has matured? @gaearon made the first commit only [14 days ago](https://github.com/gaearon/redux/commit/8bc14659780c044baac1432845fe1e4ca5123a8d).

The 0.10 release is a follow-up to 0.9, with a focus on what we're calling (at least for now) **middleware**.

You can read all about middleware [here](https://github.com/gaearon/redux/blob/master/docs/middleware.md). We plan to release some official middleware soon, but of course we'd also love to see middleware created by the community.

Just a small one: Redux includes a feature that enables you to return a function from an action creator to perform asynchronous dispatches. The function receives a callback and `getState()` as parameters. This has behavior has been re-implemented as middleware and moved into a separate module called [`thunkMiddleware()`](https://github.com/gaearon/redux/blob/master/src/middleware/thunk.js). It is included automatically when using the `createRedux(stores)` shortcut, but not when using `createDispatcher()`.

We have tests! Still need to improve coverage in a few areas, but we're currently at ~93%. Not bad! Big thanks to @emmenko for setting these up.

This release brings breaking changes necessary to start experimenting with middleware and extensibility (#6, #55). It does *not* bring any support for middleware *per se*, but it untangles “Dispatcher” (a function that tells how actions turn into state updates) from “Redux” (an instance holding the current state and managing subscriptions). It is now possible to specify your own Dispatcher if you want to experiment with ideas like middleware, time travel, action creators returning Promises or Observables, etc.

* `createDispatcher` now returns a function you need to give to `createRedux`

* `createRedux` is the primary API you'll use for initialization

* Instead of `dispatcher` prop, a `dispatch` function prop is injected by the `<Connector>` and `@connect`

* Instead of `dispatcher` prop, `<Provider>` and `@provide` accept a `redux` prop

* Instead of `dispatcher.getAtom()`, use `redux.getState()`

* Instead of `dispatcher.setAtom()`, you may pass a second `initialState` argument to `createRedux`

* Instead of `dispatcher.perfrorm()` or `dispatcher.dispatch()`, use `redux.dispatch()`

* `bindActions` is renamed to `bindActionCreators` and accepts `dispatch` as the second parameter

* You may skip `composeStores` and `createDispatcher` completely and just use `createRedux(stores)` as a shortcut

This is a shortcut for the most common use case.

import { createRedux, Provider } from 'redux';

import * as stores from '../stores/index';

const redux = createRedux(stores);

export default class App {

render() {

return (

<Provider redux={redux}>

{() =>

<CounterApp />

}

</Provider>

);

}

}

This way of writing lets you use compose Stores differently, or even pass a custom Dispatcher function. Its signature is `(initialState, setState) => (action) => ()`.

import { createRedux, createDispatcher, composeStores } from 'redux';

import * as stores from '../stores/index';

const store = composeStores(stores);

const dispatcher = createDispatcher(store); // You may use your custom function here

const redux = createRedux(dispatcher);

export default class App {

render() {

return (

<Provider redux={redux}>

{() =>

<CounterApp />

}

</Provider>

);

}

}

const redux = createRedux(stores);

redux.dispatch(MyActionCreators.doSomething()); // fire action creators to fill the state

const state = redux.getState(); // somehow pass this state to the client

const initialState = window.STATE_FROM_SERVER;

const redux = createRedux(stores, initialState);

import React from 'react';

import { connect, bindActionCreators } from 'redux';

import Counter from '../components/Counter';

import * as CounterActions from '../actions/CounterActions';

@connect(state => ({

counter: state.counter

}))

export default class CounterApp {

render() {

const { counter, dispatch } = this.props;

return (

<Counter counter={counter}

{...bindActionCreators(CounterActions, dispatch)} />

);

}

}

* `hydrate()` and `dehydrate()` are gone, welcome `getAtom()` and `setAtom()` instead

* `initialize()` and `dispose()` are added for advanced use cases

* changing `select` function now updates the `Connector` state

* the bug with action creators accepting `dispatch` instead of `perform` is fixed

This release wouldn't have happened without [this @acdlite's wonderful gist](https://gist.github.com/acdlite/9f1b5883d132ad242323).

New:

* Now there is just one top Store, *but* you may compose your Stores using `composeStores` higher-order Store (seriously.)

* Dispatcher is now part of the public API and offers (de)hydration for isomorphic apps.

* Fine-grained subscriptions via the new `<Connector select={fn}>` prop

* Less surprising, more consistent API

Read the discussion: https://github.com/gaearon/redux/pull/46

* Change second parameter in callback-style action creator from `state` to `read: (Store) => state` (#44)

* Rename: `Container -> Injector, @container -> @inject, Root -> Dispatcher, @root -> @dispatch` (#20)

* `@container`'s second parameter now also accepts the `props` passed to it (#36)

* `<Container />` and `<Root />` invoke their `this.props.children` functions without `this.props` context

* Fix incorrect ES6 Map usage (#35)

* Breaking change: `stores` now accepts an object, just like `actions`

* Breaking change: `Container` children function signature is now `({ actions, state }) => ...`

* More fine-grained `Container` props validation

This fixes #22. There is no more prop shape difference between subscribing to a single or to many stores.

Your container may now look like this:

<Container stores={{ counter: stores.counterStore }}

actions={{ increment, decrement }}>

{({ state, actions }) => <Counter {...state} {...actions} />}

</Container>

Note that you can change the `state` shape by giving arbitrary keys to your stores. It's also easier to choose what exactly you want to pass to the component. For example, you could write `actions={actions}` instead of `{...actions}`, and get all actions in `this.props.actions`.

The decorator version is changed the same way:

@container({

actions: { increment, decrement },

stores: { counter: counterStore }

})

export default class Counter {

It also now accepts a second `transformProps` argument to be just as expressive as the component version:

```js

@container({

actions: { increment, decrement },

stores: { counter: counterStore }

}, ({ actions, state}) => { ...actions, ...state })) // default shape; you can write your own

* Store function names are no longer significant, but you have to pass an object with all your Stores to the `root` (or `Root`). Fixes https://github.com/gaearon/redux/issues/16

```js

import { root } from 'redux';

import * as stores from './stores/index';

@root(stores)

export default class TodoApp {

```js

import { root } from 'redux';

import * as stores from './stores/index';

export default class TodoApp {

render() {

return (

<Root stores={stores}>

* Require `stores` passed to `Container` to be an array

```js

import React, { Component } from 'react';

import { Root, Container } from 'redux';

import { increment, decrement } from './actions/CounterActions';

import counterStore from './stores/counterStore';

import Counter from './Counter';

export default class CounterContainer {

render() {

// stores can be a single store or an array.

// actions can only be a string -> function map.

// props passed to children will combine these actions and state.

return (

<Container stores={counterStore}

actions={{ increment, decrement }}>

{props => <Counter {...props} />}

</Container>

);

}

}

* Pass `state` as a second argument to callback-style action creators

* Fix `@provides` not passing its props down