How to use the redux-saga function in redux-saga

// @flow
import { createStore, applyMiddleware, compose } from 'redux';
import createSagaMiddleware, { END } from 'redux-saga';
import createLogger from 'redux-logger';

import rootReducer from 'reducers';

import appConfig from '../config/main';

const sagaMiddleware = createSagaMiddleware();
const devtools = typeof window === 'object' && window.devToolsExtension ?
  window.devToolsExtension :
  (() => noop => noop);

export default function configureStore(initialState: Object) {
  const middlewares = [
    sagaMiddleware,
  ];

  if (appConfig.env !== 'production' && process.env.BROWSER) {
    const logger = createLogger();
    middlewares.push(logger);
  }

  const enhancers = [
    applyMiddleware(...middlewares),

export function initStore(preloadedState) {
  const sagaMiddleware = createSagaMiddleware();
  const middlewares = [sagaMiddleware];
  try {
    middlewares.push(require('redux-logger').logger);
  }
  // eslint-disable-next-line no-empty
  catch (_) {}
  const store = createStore(
    rootReducer,
    preloadedState || {},
    applyMiddleware(...middlewares)
  );
  store.close = () => store.dispatch(END);
  sagaMiddleware.run(rootSaga);
  storeInstance = store;
  return store;
}

it('dispatch batched actions before saga', async done => {
      function* createTodo() {
        yield put(addTodo('Hello'))
        const response = yield call(mockFetch, { response: 'Actions' })
        yield put(addTodo(response))
      }

      function* mySaga() {
        yield takeEvery(REQUEST_ADD_TODO, createTodo)
      }

      const sagaMiddleware = createSagaMiddleware()

      const store = createStore(
        reducers.todos,
        createBatchEnhancer(applyMiddleware(sagaMiddleware)),
      )

      sagaMiddleware.run(mySaga)

      function* stateCheckerGen() {
        yield expect(store.getState()).toEqual([
          {
            id: 1,
            text: 'Hello',
          },
          {
            id: 2,

export const withSaga = (...sagaMWArgs) => (createStore) => (...args) => {
  const sagaMiddleware = createSagaMiddleware(...sagaMWArgs)
  const store = applyMiddleware(sagaMiddleware)(createStore)(...args)
  return {
    ...store,
    runSaga: sagaMiddleware.run,
  }
}

export default function configureStore() {
  const sagaMiddleware = createSagaMiddleware();

  const store = createStore(
    rootReducer,
    compose(
      applyMiddleware(
        sagaMiddleware,
        createLogger()
      ),
      window.devToolsExtension ? window.devToolsExtension() : value => value
    )
  );

  sagaMiddleware.run(rootSaga);

  if (module.hot) {
    module.hot.accept('../reducers', () => {

export const setupStore = () => {
	const sagaMiddleware = createSagaMiddleware();

	const store = createStore(
		withDebug(rootReducer),
		getInitialStateRenderer(),
		applyMiddleware(forwardToMain, sagaMiddleware)
	);

	replayActionRenderer(store);

	if (process.env.NODE_ENV === 'development') {
		window.store = store;
	}

	resolve({ store, sagaMiddleware });
};

/**
 * External dependencies
 */
import { createStore, applyMiddleware } from 'redux';
import { composeWithDevTools } from 'redux-devtools-extension/developmentOnly';
import { augmentStore } from '@nfen/redux-reducer-injector';
import thunk from 'redux-thunk';
import createSagaMiddleware from 'redux-saga';

/**
 * Internal dependencies
 */
import reducer from '@moderntribe/common/data';
import { wpRequest } from './middlewares';

const sagaMiddleware = createSagaMiddleware();

export default () => {
	if ( window.__tribe_common_store__ ) {
		return window.__tribe_common_store__;
	}

	const middlewares = [
		thunk,
		sagaMiddleware,
		wpRequest,
	];

	const composeEnhancers = composeWithDevTools( { name: 'tribe/common' } );

	const store = createStore( reducer( {} ), composeEnhancers( applyMiddleware( ...middlewares ) ) );
	augmentStore( reducer, store );

export default function configureStore() {
  const sagaMiddleware = createSagaMiddleware();
  const store = createStore(reducer, applyMiddleware(sagaMiddleware));
  sagaMiddleware.run(saga);
  return store;
}

export const configureStore = (initialState = {}) => {
  const enhancers = []

  if (process.env.NODE_ENV === 'development' && window.__REDUX_DEVTOOLS_EXTENSION__) {
    enhancers.push(window.__REDUX_DEVTOOLS_EXTENSION__())
  }

  const sagaMiddleware = createSagaMiddleware()

  const ipcMiddleware = createIpc({
    [Channel.DOWNLOAD_PROGRESS]: (event, args) => {
      return downloadsActions.onDownloadProgress(args)
    },
    [Channel.DOWNLOAD_COMPLETE]: (event, args) => {
      return downloadsActions.onDownloadComplete(args)
    },
    [Channel.DOWNLOAD_ERROR]: (event, args) => {
      return downloadsActions.onDownloadError(args)
    },
    [Channel.SEARCH_FOUND]: (event, args) => {
      return downloadsActions.onSearchFound(args)
    },
    [Channel.UPDATE_SETTINGS]: (event, args) => {
      return settingsActions.onUpdateSettings(args)