TypeScript react-router-redux.syncHistory函數代碼示例

export default function configureStore(history: HistoryModule.History, initialState?: Store.ApplicationState) {
    // Build middleware
    const thunk = (thunkModule as any).default; // Workaround for TypeScript not importing thunk module as expected
    const reduxRouterMiddleware = syncHistory(history);
    const middlewares = [thunk, reduxRouterMiddleware, typedToPlain];
    const devToolsExtension = null;//(window as any).devToolsExtension; // If devTools is installed, connect to it
  
    const finalCreateStore = compose(
        applyMiddleware(...middlewares),
        devToolsExtension ? devToolsExtension() : f => f
    )(createStore)

    // Combine all reducers
    const allReducers = buildRootReducer(Store.reducers);

    const store = finalCreateStore(allReducers, initialState) as Redux.Store;
  
    // Required for replaying actions from devtools to work
    reduxRouterMiddleware.listenForReplays(store);
  
    // Enable Webpack hot module replacement for reducers
    if (module.hot) {
        module.hot.accept('./store', () => {
            const nextRootReducer = require<typeof Store>('./store');
            store.replaceReducer(buildRootReducer(nextRootReducer.reducers));
        });
    }

    return store;
}

const thunk = require('redux-thunk').default;
import promiseMiddleware from '../middleware/promise-middleware';
import logger from './logger';
import rootReducer from '../reducers';

// webpack-hot-loader sets some extra attributes on node's `module` if that
// module has been hot-loaded in the browser.
interface HotNodeModule extends NodeModule {
 hot: { accept: Function };
};

// This global is used to turn on redux dev tools when in dev mode.
declare let __DEV__: boolean;
declare let module: HotNodeModule;

const reduxRouterMiddleware = syncHistory(browserHistory);

const storageConfig = {
  key: 'typescript-react-redux-seed',
  serialize: (store) => {
    return store && store.session ?
      JSON.stringify(store.session.toJS()) : store;
  },
  deserialize: (state) => ({
    session: state ? fromJS(JSON.parse(state)) : fromJS({}),
  }),
};

function configureStore(initialState) {
  const store = compose(
  __DEV__

//Redux
import { applyMiddleware, compose, createStore, combineReducers } from 'redux';
import thunkMiddleware from 'redux-thunk';

//Router
import {
    syncHistory, routeReducer
} from 'react-router-redux';
import { createHistory } from 'history'
import {rootReducer} from './reducers/rootReducer.ts';
import {DevTools} from './DevTools.tsx';

export const history = createHistory();

const middleware = syncHistory(history);
const reducer = combineReducers(Object.assign({}, {data: rootReducer}, {
    routing: routeReducer
}));

const finalCreateStore = compose(
    applyMiddleware(middleware, thunkMiddleware),
    DevTools.instrument()
)(createStore);

export const store = finalCreateStore(reducer);
middleware.listenForReplays(store);