TypeScript redux-promise-middleware.default函数代码示例

export default function(todoListReducer, todoFormReducer) {
  const reducer = combineReducers({list: todoListReducer, form: todoFormReducer});
  const createStoreWithMiddleware = applyMiddleware(promiseMiddleware())(createStore);
  const store = createStoreWithMiddleware(reducer);

  return store;
};

import { createStore, applyMiddleware, compose } from 'redux';
import promiseMiddleware from 'redux-promise-middleware';
import thunkMiddleware from 'redux-thunk';
import reducer, { IRootState } from 'app/shared/reducers';
import DevTools from 'app/config/devtools';
import errorMiddleware from 'app/config/error-middleware';
import notificationMiddleware from 'app/config/notification-middleware';
import loggerMiddleware from 'app/config/logger-middleware';
import { loadingBarMiddleware } from 'react-redux-loading-bar';

const defaultMiddlewares = [
  thunkMiddleware,
  errorMiddleware,
  notificationMiddleware,
  promiseMiddleware(),
  loadingBarMiddleware(),
  loggerMiddleware
];
const composedMiddlewares = middlewares =>
  process.env.NODE_ENV === 'development'
    ? compose(
        applyMiddleware(...defaultMiddlewares, ...middlewares),
        DevTools.instrument()
      )
    : compose(applyMiddleware(...defaultMiddlewares, ...middlewares));
// 创建 Redux store 来存放应用的状态。
const initialize
  = ((initialState?: IRootState, middlewares = []) => createStore(reducer, initialState, composedMiddlewares(middlewares)));
// 扩展示例:
// 每次 state 更新时，打印日志
// 注意 subscribe() 返回一个函数用来注销监听器

import { applyMiddleware, createStore, ReducersMapObject, compose } from "redux"
import promise from "redux-promise-middleware"
import { logger } from "logger"

import reducers from "combined-reducers"

export interface IStore extends ReducersMapObject {
    user
}

interface IWindow extends Window {
    devToolsExtension: any
}

declare var window: IWindow;

const middleware = applyMiddleware(promise());

export default createStore(reducers, compose(middleware, window.devToolsExtension && window.devToolsExtension()));

 beforeEach(() => {
   const mockStore = configureStore([thunk, promiseMiddleware()]);
   store = mockStore({});
   axios.get = sinon.stub().returns(Promise.resolve(resolvedObject));
   axios.post = sinon.stub().returns(Promise.resolve(resolvedObject));
   axios.put = sinon.stub().returns(Promise.resolve(resolvedObject));
   axios.delete = sinon.stub().returns(Promise.resolve(resolvedObject));
 });

function _getMiddleware(): Middleware[] {

  let middleware = [
    promiseMiddleware(),
    thunk,
  ];
  if (__DEV__) {
    middleware = [...middleware];
  }
  return middleware;
}

import {createStore, applyMiddleware, compose} from 'redux';
import rootReducer from '../reducers/index';
const createLogger = require('redux-logger');
import thunk from 'redux-thunk';
import promiseMiddleware from 'redux-promise-middleware';
// import { DevTools } from '../containers/DevTools.js';

const logger: any = createLogger();
/**
 * thunk, logger, promiseMiddleware are used as redux middleware
 *
 * uncomment logger to receive debug information in browser console
 */
const finalCreateStore = compose(
  applyMiddleware(logger, thunk, promiseMiddleware())
  // DevTools.instrument()
)(createStore);

export function configureStore(initialState) {
  return finalCreateStore(rootReducer, initialState);
};

 const makeStore = () => applyMiddleware(notificationMiddleware, promiseMiddleware())(createStore)(() => null);

 beforeEach(() => {
   const mockStore = configureStore([thunk, promiseMiddleware()]);
   store = mockStore({ authentication: { account: { langKey: 'en' } } });
 });

import { syncHistoryWithStore, routerReducer, routerMiddleware, push, replace } from 'react-router-redux';
import { createStore, combineReducers, applyMiddleware } from 'redux';
import { browserHistory } from 'react-router';
import thunk from 'redux-thunk';
import promiseMiddleware from 'redux-promise-middleware';

import CurrentUser from './reducers/authorize/reducer';
import UsersRepository from './reducers/users/usersReducer';

const middleware = routerMiddleware(browserHistory);

let reudcers = combineReducers({
  CurrentUser,
  UsersRepository,
  routing: routerReducer,
});

const logger = store => next => action => {
  console.log('dispatching', action);
  let result = next(action);
  console.log('next state', store.getState());
  return result;
};

export var store = createStore<store.IApplicationStore>(reudcers, applyMiddleware(middleware, thunk, promiseMiddleware(), logger));

export var navigate = (path: string): void => {
    store.dispatch(replace(path));
};