Time Travelling does not work about connected-react-router HOT 8 CLOSED

// reducer.js
import { LOCATION_CHANGE } from './actions'

/**
 * This reducer will update the state with the most recent location history
 * has transitioned to.
 */
export default history => {
	const initialState = {
		location: history.location,
		action: history.action
	};
	
	return (state = initialState, { type, payload } = {}) => {
		if (type === LOCATION_CHANGE) {
			return {
				...state,
				...payload,
			};
		}

		return state;
	};
};

// store.js
import {combineReducers} from 'redux';
import createRouter from 'connected-react-router';
import {createBrowserHistory} from 'history';

export const history = createBrowserHistory()

export default combineReducers({
	router: createRouter(history)
});

// ConnectedRouter.js
import React, {Component, PropTypes} from 'react';
import {connect} from 'react-redux';
import {StaticRouter} from 'react-router';
import {onLocationChanged} from './actions';

/*
 * ConnectedRouter listens to a history object passed from props.
 * When history is changed, it dispatches action to redux store.
 * Then, store will pass props to component to render.
 * This creates uni-directional flow from history->store->router->components.
 */
class ConnectedRouter extends Component {
	constructor(props) {
		super(props);
		
		this.unlisten = props.history.listen((location, action) => {
			props.onLocationChanged(location, action);
		});
	}
	
	componentWillUnmount() {
		this.unlisten();
	}

	render() {
		const {location, action, history, basename, children} = this.props;

		return (
			<StaticRouter
				action={action}
				location={location}
				basename={basename}
				onPush={history.push}
				onReplace={history.replace}
				blockTransitions={history.block}
			>
				{children}
			</StaticRouter>
		);
	}
}

ConnectedRouter.propTypes = {
	history: PropTypes.object.isRequired,
	location: PropTypes.oneOfType([ PropTypes.object, PropTypes.string ]),
	action: PropTypes.string,
	basename: PropTypes.string,
	children: PropTypes.oneOfType([ PropTypes.func, PropTypes.node ]),
	onLocationChanged: PropTypes.func.isRequired
};

const mapStateToProps = state => ({
	action: state.router.action,
	location: state.router.location
});

const mapDispatchToProps = dispatch => ({
	onLocationChanged: (location, action) => dispatch(onLocationChanged(location, action))
});

export default connect(mapStateToProps, mapDispatchToProps)(ConnectedRouter);

import { createBrowserHistory } from 'history'
import { LOCATION_CHANGE } from './actions'

/**
 * This reducer will update the state with the most recent location history
 * has transitioned to.
 */
const history = createBrowserHistory()
const initialState = {
  location: history.location,
  action: history.action,
}

const routerReducer = (state = initialState, { type, payload } = {}) => {
  if (type === LOCATION_CHANGE) {
    return {
      ...state,
      ...payload,
    }
  }

  return state
}

export default routerReducer

// Your main client entrypoint

import rootReducer from 'reducers'
import configureStore from './store'
import {connectRouter} from 'connected-react-router'
import {createBrowserHistory} from 'history'

const history = createBrowserHistory()
const store = configureStore(
  connectRouter(history)(rootReducer)
)

// Set up router ...

import { LOCATION_CHANGE } from './actions'

function routerReducer(state, { type, payload } = {}) {
	if (type === LOCATION_CHANGE) {
		return {
			...state,
			...payload,
		};
	}

	return state;
};


function connectRouter(history) {
	const initialRouterState = {
		location: history.location,
		action: history.action
	};
	
	return function wrapReducer(reducer) {
		
		return function(state, action) {
			const reducerResults(state, action)
			
			return {
				...reducerResults,
				router: routerReducer(state = initialRouterState, action)
			}
			
		}
	}
}

import { LOCATION_CHANGE } from './actions'

/**
 * This reducer will update the state with the most recent location history
 * has transitioned to.
 */
const routerReducer = (state, { type, payload } = {}) => {
  if (type === LOCATION_CHANGE) {
    return {
      ...state,
      ...payload,
    }
  }

  return state
}

const connectRouter = (history) => {
  const initialRouterState = {
    location: history.location,
    action: history.action,
  }
  // Wrap a root reducer and return a new root reducer with router state
  return (rootReducer) => (state, action) => {
    let routerState = initialRouterState

    // Extract router state
    if (state) {
      const { router, ...rest} = state
      routerState = router || routerState
      state = rest
    }
    const reducerResults = rootReducer(state, action)

    return {
      ...reducerResults,
      router: routerReducer(routerState, action)
    }
  }
}

export default connectRouter