function configureStore(modules: Array<IModule<any>>, api: Api): Store<Object> {
  const extraArguments: IExtraArguments = { api };
  const middlewares: Middleware[] = [
    thunk.withExtraArgument(extraArguments),
  ];

  const modulesReducers: ReducersMapObject = modules.reduce((reducers, module) => {
    if (module.getReducer) {
      const reducerData = module.getReducer();
      reducers[reducerData.name] = reducerData.reducer;
    }

    return reducers;
  }, {} as ReducersMapObject);

  const reducer: Reducer<IReduxState> = combineReducers<IReduxState>({
    createPoll: createPollReducer,
    viewPolls: viewPollsReducer,
    ...modulesReducers,
  });

  return createStore(
    reducer,
    compose(
      applyMiddleware(...middlewares),
      ('development' === process.env.NODE_ENV && window.devToolsExtension)
        ? window.devToolsExtension() : ((arg: any) => arg),
    ),
  );
}

export default function(
  media: Media,
  actionEmitter: Emitter,
  customMiddlewares: Middleware[] = [],
  stateOverrides: DeepPartial<AppState> | undefined,
  extras: Extras
) {
  let initialState;
  if (stateOverrides) {
    initialState = merge(
      reducer(undefined, { type: "@@init" }),
      stateOverrides
    );
  }

  const emitterMiddleware = () => (next: Dispatch) => (action: Action) => {
    actionEmitter.trigger(action.type, action);
    return next(action);
  };

  const enhancer = compose(
    applyMiddleware(
      ...[
        thunk.withExtraArgument(extras),
        mediaMiddleware(media),
        emitterMiddleware,
        ...customMiddlewares,
      ].filter(Boolean)
    )
  );

  // The Redux types are a bit confused, and don't realize that passing an
  // undefined initialState is allowed.
  const store = initialState
    ? createStore(reducer, initialState, enhancer)
    : createStore(reducer, enhancer);
  return store;
}

export default (
  axiosInstance: AxiosInstance,
  initialState: AppState = defaultInitialState,
  composeEnhancers = compose,
) => {
  const applyComposeEnhancers =
    (typeof window !== 'undefined' &&
      (window as AppWindow).__REDUX_DEVTOOLS_EXTENSION_COMPOSE__) ||
    composeEnhancers;

  const store = createStore(
    reducers,
    initialState,
    applyComposeEnhancers(
      applyMiddleware(
        thunk.withExtraArgument(axiosInstance),
        LogRocket.reduxMiddleware(),
      ),
    ),
  );

  return store;
};

import { RouteState } from './reducers/route';
import { SpinnerState } from './reducers/spinner';
import { AuthState } from './reducers/auth';
import { LoginState } from './reducers/login';
import { FeedsFeedsState } from './reducers/feeds';
import { ArticlesState } from './reducers/articles';
import { SearchState } from './reducers/search';
import { UrlsState } from './reducers/urls';

export type FeedsState = {
    invalid: InvalidFeedsState,
    route: RouteState,
    spinner: SpinnerState,
    auth: AuthState,
    login: LoginState,
    feeds: FeedsFeedsState,
    articles: ArticlesState,
    search: SearchState,
    urls: UrlsState
};

// tslint:disable-next-line:no-any
const composeEnhancers = (window as any).__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose;

/**
 * State store for the Feeds application.
 * The API interface is passed as a separate
 * argument for thunk-based actions.
 */
export default createStore(reducers, composeEnhancers(applyMiddleware(thunk.withExtraArgument(api))));

import { applyMiddleware, createStore } from "redux";
import { composeWithDevTools } from "redux-devtools-extension";
import thunk from "redux-thunk";
import { auth, firestore } from "../lib/firebase";
import { rootReducer } from "./reducers";

export const store = createStore(
  rootReducer,
  composeWithDevTools(
    applyMiddleware(thunk.withExtraArgument({ auth, firestore }))
  )
);

export let store = Redux.createStore<IState>(
  rootReducer,
  {
    // Pre-populate stored session data
    session: initialSessionState
  } as IState,
  compose(
    Redux.applyMiddleware(
      routerMiddleware(browserHistory as any),
      loadingBarMiddleware({
        promiseTypeSuffixes: [pending(""), success(""), failed("")]
      }),
      promiseMiddleware as any,
      thunkMiddleware.withExtraArgument({
        getCachedClient: getCachedClient,
        createClientWithToken: createClientWithToken,
        getSignalRClient: getSignalRClient
      } as IAsyncActionDependencies),
      (createLogger as any)())));

// Persist session settings to session storage
store.subscribe(debounce(() => {
  const state = store.getState();
  const sessionState = state && state.session;

  if (sessionState) {
    sessionStorage.setItem("impera", JSON.stringify(sessionState));
  }
}, 1000));

// Setup handler for 401 resposes

function getStore() {
  const extras = {};
  const enhancer = applyMiddleware(thunk.withExtraArgument(extras));
  return createStore(reducer, enhancer);
}

/**
 * Helper function to create mock store for testing actions.
 */
// tslint:disable-next-line: no-any
export default (initialState: any): FeedsMockStore => {
    const middlewares = [thunk.withExtraArgument(mockApi)];
    const mockStore = configureStore(middlewares);
    return mockStore(initialState) as FeedsMockStore;
};